Merge lp:~n-muench/ubuntu/saucy/open-vm-tools/open-vm-tools.april-update.part2-merge into lp:ubuntu/saucy/open-vm-tools

[Nate Muench (Mink)]

Merged some items from Debian. Added patches for Linux 3.10 & 3.11.

vmhgfs is still kind of flaky. Either because of something related to the kernel or a build package, I'm not really sure. It's been broken since the original upload, with the 3.9 kernel)

0007-dkms-suppress-error.patch tweaks the dkms.conf file. There are modules that still fail to build, modules that are either in the kernel or flaky. The patch lets only the vmblock module (fixed with the 3.11 patch) and the vmxnet module (fixed with the 3.10 patch) build. The reason is if during the DKMS build process, any modules fail to build, none will get installed.

vmxnet builds successfully because of the 3.10 patch.

0007-dkms-suppress-error.patch will be removed once a new upstream version is released. That will be the last merge proposal of this cycle.

I was planning on more updates (including the paper work to become the package's official maintainer (and gain uploader rights)) during the Saucy devel cycle, but there were some delays related to the package. These plans have been postponed until 14.04.

Did I say too much to get this disapproved?

[Luke Yelavich (themuso)]

You will have to either turn one of the existing bugs into a feature freeze exception, or create a new one and link it to this merge proposal.

[Nate Muench (Mink) (n-muench)]

open-vm-tools is not a core package (as in not everyone is gonna use it), therefore it doesn't need a freeze exception. I think that's what the policy is.

[Nate Muench (Mink) (n-muench)]

Luke, we had the same debate 6 months ago: https://code.launchpad.net/~n-muench/ubuntu/raring/open-vm-tools/open-vm-tools-december.sid-sync/+merge/153466

[Dimitri John Ledkov (xnox)]

review: Approve

Unmerged revisions

37. By Nate Muench (Mink) on 2013-09-08

* Ubuntu-specific Changes
  - debian/rules: Removed Wno-error=unused-local-typedefs from CLFAGS.
    + We now enforce building with GCC 4.7.

  - debian/patches: Add 0005-linux-310-fix.patch & 0006-linux-311-fix.patch
    + Fixes building against Saucy Kernels. (LP: #1194940, LP: #1208011)

  - debian/patches: Add 0007-dkms-supress-error.patch
    + Don't build modules that are broken, so modules that do build
      are available to be loaded.
    + Will be removed after next upstream release.

* Items merged from Debian experimental:
  (From 2:9.2.2-893683-7 release)
  - Removing purely cosmetical 'sleep 1' leftover in initscript.

  (From 2:9.2.3-1031360-2 release)
  - Renaming debian-specific open-vm-toolbox package to open-vm-tools-
    desktop for consistency with upstream.
  - Revamping package descriptions.
  - Renaming open-vm-dkms to open-vm-tools-dkms for consistent package
    namespace.

  (From 2:9.2.3-1031360-3 release)
  - Adding initial systemd service file from fedora.

  (From 2:9.2.3-1031360-4 release)
  - Dropping kfreebsd from architecture list, it has never built and
    nobody seems willing to make it work (neither upstream, porters, nor
    users).

  (From 2:9.2.3-1031360-6 release)
  - Correcting syntax of file entries in copyright.
  - Adding section override for open-vm-tools-dkms.
  - Enforcing build with gcc 4.7 for the time being.

=== added directory '.pc/0005-linux-310-fix.patch'
=== added directory '.pc/0005-linux-310-fix.patch/modules'
=== added directory '.pc/0005-linux-310-fix.patch/modules/linux'
=== added directory '.pc/0005-linux-310-fix.patch/modules/linux/shared'
=== added file '.pc/0005-linux-310-fix.patch/modules/linux/shared/compat_fs.h'
--- .pc/0005-linux-310-fix.patch/modules/linux/shared/compat_fs.h	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/shared/compat_fs.h	2013-09-21 20:15:28 +0000
@@ -0,0 +1,266 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+#ifndef __COMPAT_FS_H__
+#   define __COMPAT_FS_H__
+
+#include <linux/fs.h>
+
+/*
+ * 2.6.5+ kernels define FS_BINARY_MOUNTDATA. Since it didn't exist and
+ * wasn't used prior, it's safe to define it to zero.
+ */
+
+#ifndef FS_BINARY_MOUNTDATA
+#define FS_BINARY_MOUNTDATA 0
+#endif
+
+/*
+ * MAX_LFS_FILESIZE wasn't defined until 2.5.4.
+ */
+#ifndef MAX_LFS_FILESIZE
+#   include <linux/pagemap.h>
+#   if BITS_PER_LONG == 32
+#      define MAX_LFS_FILESIZE       (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG - 1)) - 1)
+#   elif BITS_PER_LONG == 64
+#      define MAX_LFS_FILESIZE       0x7fffffffffffffffUL
+#   endif
+#endif
+
+
+/*
+ * sendfile as a VFS op was born in 2.5.30. Unfortunately, it also changed
+ * signatures, first in 2.5.47, then again in 2.5.70, then again in 2.6.8.
+ * Luckily, the 2.6.8+ signature is the same as the 2.5.47 signature.  And
+ * as of 2.6.23-rc1 sendfile is gone, replaced by splice_read...
+ *
+ * Let's not support sendfile from 2.5.30 to 2.5.47, because the 2.5.30
+ * signature is much different and file_send_actor isn't externed.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
+#define VMW_SENDFILE_NONE
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 8)
+#define VMW_SENDFILE_NEW
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 70)
+#define VMW_SENDFILE_OLD
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 47)
+#define VMW_SENDFILE_NEW
+#else
+#define VMW_SENDFILE_NONE
+#endif
+
+/*
+ * splice_read is there since 2.6.17, but let's avoid 2.6.17-rcX kernels...
+ * After all nobody is using splice system call until 2.6.23 using it to
+ * implement sendfile.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
+#define VMW_SPLICE_READ 1
+#endif
+
+/*
+ * Filesystems wishing to use generic page cache read/write routines are
+ * supposed to implement aio_read and aio_write (calling into
+ * generic_file_aio_read() and generic_file_aio_write() if necessary).
+ *
+ * The VFS exports do_sync_read() and do_sync_write() as the "new"
+ * generic_file_read() and generic_file_write(), but filesystems need not
+ * actually implement read and write- the VFS will automatically call
+ * do_sync_write() and do_sync_read() when applications invoke the standard
+ * read() and write() system calls.
+ *
+ * In 2.6.19, generic_file_read() and generic_file_write() were removed,
+ * necessitating this change. AIO dates as far back as 2.5.42, but the API has
+ * changed over time, so for simplicity, we'll only enable it from 2.6.19 and
+ * on.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
+# define VMW_USE_AIO
+#endif
+
+
+/*
+ * The alloc_inode and destroy_inode VFS ops didn't exist prior to 2.4.21.
+ * Without these functions, file systems can't embed inodes.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 21)
+# define VMW_EMBED_INODE
+#endif
+
+
+/*
+ * iget() was removed from the VFS as of 2.6.25-rc1. The replacement for iget()
+ * is iget_locked() which was added in 2.5.17.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 17)
+# define VMW_USE_IGET_LOCKED
+#endif
+
+/*
+ * parent_ino was born in 2.5.5. For older kernels, let's use 2.5.5
+ * implementation. It uses the dcache lock which is OK because per-dentry
+ * locking appeared after 2.5.5.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 5)
+#define compat_parent_ino(dentry) parent_ino(dentry)
+#else
+#define compat_parent_ino(dentry)                                             \
+({                                                                            \
+   ino_t res;                                                                 \
+   spin_lock(&dcache_lock);                                                   \
+   res = dentry->d_parent->d_inode->i_ino;                                    \
+   spin_unlock(&dcache_lock);                                                 \
+   res;                                                                       \
+})
+#endif
+
+
+/*
+ * putname changed to __putname in 2.6.6.
+ */
+#define compat___getname() __getname()
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 6)
+#define compat___putname(name) putname(name)
+#else
+#define compat___putname(name) __putname(name)
+#endif
+
+
+/*
+ * inc_nlink, drop_nlink, and clear_nlink were added in 2.6.19.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+#define compat_inc_nlink(inode) ((inode)->i_nlink++)
+#define compat_drop_nlink(inode) ((inode)->i_nlink--)
+#define compat_clear_nlink(inode) ((inode)->i_nlink = 0)
+#else
+#define compat_inc_nlink(inode) inc_nlink(inode)
+#define compat_drop_nlink(inode) drop_nlink(inode)
+#define compat_clear_nlink(inode) clear_nlink(inode)
+#endif
+
+
+/*
+ * i_size_write and i_size_read were introduced in 2.6.0-test1 
+ * (though we'll look for them as of 2.6.1). They employ slightly different
+ * locking in order to guarantee atomicity, depending on the length of a long,
+ * whether the kernel is SMP, or whether the kernel is preemptible. Prior to
+ * i_size_write and i_size_read, there was no such locking, so that's the
+ * behavior we'll emulate.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 1)
+#define compat_i_size_read(inode) ((inode)->i_size)
+#define compat_i_size_write(inode, size) ((inode)->i_size = size)
+#else
+#define compat_i_size_read(inode) i_size_read(inode)
+#define compat_i_size_write(inode, size) i_size_write(inode, size)
+#endif
+
+
+/*
+ * filemap_fdatawrite was introduced in 2.5.12. Prior to that, modules used
+ * filemap_fdatasync instead. In 2.4.18, both filemap_fdatawrite and 
+ * filemap_fdatawait began returning status codes. Prior to that, they were 
+ * void functions, so we'll just have them return 0.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 18)
+#define compat_filemap_fdatawrite(mapping)                                    \
+({                                                                            \
+   int result = 0;                                                            \
+   filemap_fdatasync(mapping);                                                \
+   result;                                                                    \
+})
+#define compat_filemap_fdatawait(mapping)                                     \
+({                                                                            \
+   int result = 0;                                                            \
+   filemap_fdatawait(mapping);                                                \
+   result;                                                                    \
+})
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 12)
+#define compat_filemap_fdatawrite(mapping) filemap_fdatasync(mapping)
+#define compat_filemap_fdatawait(mapping) filemap_fdatawait(mapping)
+#else
+#define compat_filemap_fdatawrite(mapping) filemap_fdatawrite(mapping)
+#define compat_filemap_fdatawait(mapping) filemap_fdatawait(mapping)
+#endif
+
+
+/*
+ * filemap_write_and_wait was introduced in 2.6.6 and exported for module use
+ * in 2.6.16. It's really just a simple wrapper around filemap_fdatawrite and 
+ * and filemap_fdatawait, which initiates a flush of all dirty pages, then 
+ * waits for the pages to flush. The implementation here is a simplified form 
+ * of the one found in 2.6.20-rc3.
+ *
+ * Unfortunately, it just isn't possible to implement this prior to 2.4.5, when
+ * neither filemap_fdatawait nor filemap_fdatasync were exported for module
+ * use. So we'll define it out and hope for the best.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 5)
+#define compat_filemap_write_and_wait(mapping)
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
+#define compat_filemap_write_and_wait(mapping)                                \
+({                                                                            \
+   int result = 0;                                                            \
+   if (mapping->nrpages) {                                                    \
+      result = compat_filemap_fdatawrite(mapping);                            \
+      if (result != -EIO) {                                                   \
+         int result2 = compat_filemap_fdatawait(mapping);                     \
+         if (!result) {                                                       \
+            result = result2;                                                 \
+         }                                                                    \
+      }                                                                       \
+   }                                                                          \
+   result;                                                                    \
+})
+#else
+#define compat_filemap_write_and_wait(mapping) filemap_write_and_wait(mapping)
+#endif
+
+
+/*
+ * invalidate_remote_inode was introduced in 2.6.0-test5. Prior to that, 
+ * filesystems wishing to invalidate pages belonging to an inode called 
+ * invalidate_inode_pages.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
+#define compat_invalidate_remote_inode(inode) invalidate_inode_pages(inode)
+#else
+#define compat_invalidate_remote_inode(inode) invalidate_remote_inode(inode)
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
+#define VMW_FSYNC_OLD
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)
+typedef umode_t compat_umode_t;
+#else
+typedef int compat_umode_t;
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0)
+#define d_make_root(inode) ({                      \
+   struct dentry * ____res = d_alloc_root(inode);  \
+   if (!____res) {                                 \
+      iput(inode);                                 \
+   }                                               \
+   ____res;                                        \
+})
+#endif
+#endif /* __COMPAT_FS_H__ */

=== added directory '.pc/0005-linux-310-fix.patch/modules/linux/vmblock'
=== added directory '.pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux'
=== added file '.pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/control.c'
--- .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/control.c	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/control.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,375 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * control.c --
+ *
+ *   Control operations for the vmblock driver.
+ *
+ */
+
+#include "driver-config.h"
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/stat.h>
+#include <linux/fs.h>
+
+#include <asm/uaccess.h>
+
+#include "vmblockInt.h"
+#include "block.h"
+
+
+/* procfs initialization/cleanup functions */
+static int SetupProcDevice(void);
+static int CleanupProcDevice(void);
+
+/* procfs entry file operations */
+ssize_t ControlFileOpWrite(struct file *filp, const char __user *buf,
+                           size_t cmd, loff_t *ppos);
+static int ControlFileOpRelease(struct inode *inode, struct file *file);
+
+
+static struct proc_dir_entry *controlProcDirEntry;
+struct file_operations ControlFileOps = {
+   .owner   = THIS_MODULE,
+   .write   = ControlFileOpWrite,
+   .release = ControlFileOpRelease,
+};
+
+
+/* Public initialization/cleanup routines */
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * VMBlockInitControlOps --
+ *
+ *    Sets up state for control operations.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+VMBlockInitControlOps(void)
+{
+   int ret;
+
+   ret = BlockInit();
+   if (ret < 0) {
+      Warning("VMBlockInitControlOps: could not initialize blocking ops.\n");
+      return ret;
+   }
+
+   ret = SetupProcDevice();
+   if (ret < 0) {
+      Warning("VMBlockInitControlOps: could not setup proc device.\n");
+      BlockCleanup();
+      return ret;
+   }
+
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * VMBlockCleanupControlOps --
+ *
+ *    Cleans up state for control operations.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+VMBlockCleanupControlOps(void)
+{
+   int ret;
+
+   ret = CleanupProcDevice();
+   if (ret < 0) {
+      Warning("VMBlockCleanupControlOps: could not cleanup proc device.\n");
+      return ret;
+   }
+
+   BlockCleanup();
+   return 0;
+}
+
+
+/* Private initialization/cleanup routines */
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * VMBlockSetProcEntryOwner --
+ *
+ *    Sets proc_dir_entry owner if necessary:
+ *
+ *    Before version 2.6.24 kernel prints nasty warning when in-use
+ *    directory entry is destroyed, which happens when module is unloaded.
+ *    We try to prevent this warning in most cases by setting owner to point
+ *    to our module, so long operations (like current directory pointing to
+ *    directory we created) prevent module from unloading.  Since 2.6.24 this
+ *    situation is handled without nastygrams, allowing module unload even
+ *    when current directory points to directory created by unloaded module,
+ *    so we do not have to set owner anymore.  And since 2.6.29 we must not
+ *    set owner at all, as there is none...
+ *
+ * Results:
+ *    None.  Always succeeds.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static void
+VMBlockSetProcEntryOwner(struct proc_dir_entry *entry) // IN/OUT: directory entry
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
+   entry->owner = THIS_MODULE;
+#endif
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * SetupProcDevice --
+ *
+ *    Adds entries to /proc used to control file blocks.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+SetupProcDevice(void)
+{
+   struct proc_dir_entry *controlProcEntry;
+   struct proc_dir_entry *controlProcMountpoint;
+
+   /* Create /proc/fs/vmblock */
+   controlProcDirEntry = proc_mkdir(VMBLOCK_CONTROL_PROC_DIRNAME, NULL);
+   if (!controlProcDirEntry) {
+      Warning("SetupProcDevice: could not create /proc/"
+              VMBLOCK_CONTROL_PROC_DIRNAME "\n");
+      return -EINVAL;
+   }
+
+   VMBlockSetProcEntryOwner(controlProcDirEntry);
+
+   /* Create /proc/fs/vmblock/mountPoint */
+   controlProcMountpoint = proc_mkdir(VMBLOCK_CONTROL_MOUNTPOINT,
+                                      controlProcDirEntry);
+   if (!controlProcMountpoint) {
+      Warning("SetupProcDevice: could not create "
+              VMBLOCK_MOUNT_POINT "\n");
+      remove_proc_entry(VMBLOCK_CONTROL_PROC_DIRNAME, NULL);
+      return -EINVAL;
+   }
+
+   VMBlockSetProcEntryOwner(controlProcMountpoint);
+
+   /* Create /proc/fs/vmblock/dev */
+   controlProcEntry = create_proc_entry(VMBLOCK_CONTROL_DEVNAME,
+                                        VMBLOCK_CONTROL_MODE,
+                                        controlProcDirEntry);
+   if (!controlProcEntry) {
+      Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");
+      remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);
+      remove_proc_entry(VMBLOCK_CONTROL_PROC_DIRNAME, NULL);
+      return -EINVAL;
+   }
+
+   controlProcEntry->proc_fops = &ControlFileOps;
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * CleanupProcDevice --
+ *
+ *    Removes /proc entries for controlling file blocks.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+CleanupProcDevice(void)
+{
+   if (controlProcDirEntry) {
+      remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);
+      remove_proc_entry(VMBLOCK_CONTROL_DEVNAME, controlProcDirEntry);
+      remove_proc_entry(VMBLOCK_CONTROL_PROC_DIRNAME, NULL);
+   }
+   return 0;
+}
+
+
+/* procfs file operations */
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * ExecuteBlockOp --
+ *
+ *    Copy block name from user buffer into kernel space, canonicalize it
+ *    by removing all trailing path separators, and execute desired block
+ *    operation.
+ *
+ * Results:
+ *    0 on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+ExecuteBlockOp(const char __user *buf,                // IN: buffer with name
+               const os_blocker_id_t blocker,         // IN: blocker ID (file)
+               int (*blockOp)(const char *filename,   // IN: block operation
+                              const os_blocker_id_t blocker))
+{
+   char *name;
+   int i;
+   int retval;
+
+   name = getname(buf);
+   if (IS_ERR(name)) {
+      return PTR_ERR(name);
+   }
+
+   for (i = strlen(name) - 1; i >= 0 && name[i] == '/'; i--) {
+      name[i] = '\0';
+   }
+
+   retval = i < 0 ? -EINVAL : blockOp(name, blocker);
+
+   putname(name);
+
+   return retval;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * ControlFileOpWrite --
+ *
+ *    write implementation for our control file.  This accepts either add or
+ *    delete commands and the buffer contains the file to block.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+ssize_t
+ControlFileOpWrite(struct file *file,       // IN: Opened file, used for ID
+                   const char __user *buf,  // IN: NUL-terminated filename
+                   size_t cmd,              // IN: VMBlock command (usually count)
+                   loff_t *ppos)            // IN/OUT: File offset (unused)
+{
+   int ret;
+
+   switch (cmd) {
+   case VMBLOCK_ADD_FILEBLOCK:
+      ret = ExecuteBlockOp(buf, file, BlockAddFileBlock);
+      break;
+
+   case VMBLOCK_DEL_FILEBLOCK:
+      ret = ExecuteBlockOp(buf, file, BlockRemoveFileBlock);
+      break;
+
+#ifdef VMX86_DEVEL
+   case VMBLOCK_LIST_FILEBLOCKS:
+      BlockListFileBlocks();
+      ret = 0;
+      break;
+#endif
+
+   default:
+      Warning("ControlFileOpWrite: unrecognized command (%u) recieved\n",
+              (unsigned)cmd);
+      ret = -EINVAL;
+      break;
+   }
+
+   return ret;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * ControlFileOpRelease --
+ *
+ *    Called when the file is closed.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+ControlFileOpRelease(struct inode *inode,  // IN
+                     struct file *file)    // IN
+{
+   BlockRemoveAllBlocks(file);
+   return 0;
+}

=== added file '.pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/dentry.c'
--- .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/dentry.c	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/dentry.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,118 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * dentry.c --
+ *
+ *   Dentry operations for the file system of the vmblock driver.
+ *
+ */
+
+#include "driver-config.h"
+
+#include <linux/fs.h>
+#include "compat_namei.h"
+#include "vmblockInt.h"
+#include "filesystem.h"
+#include "block.h"
+
+
+static int DentryOpRevalidate(struct dentry *dentry, struct nameidata *nd);
+
+struct dentry_operations LinkDentryOps = {
+   .d_revalidate = DentryOpRevalidate,
+};
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * DentryOpRevalidate --
+ *
+ *    This function is invoked every time the dentry is accessed from the cache
+ *    to ensure it is still valid.  We use it to block since any threads
+ *    looking up this dentry after the initial lookup should still block if the
+ *    block has not been cleared.
+ *
+ * Results:
+ *    1 if the dentry is valid, 0 if it is not.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+DentryOpRevalidate(struct dentry *dentry,  // IN: dentry revalidating
+                   struct nameidata *nd)   // IN: lookup flags & intent
+{
+   VMBlockInodeInfo *iinfo;
+   struct nameidata actualNd;
+   struct dentry *actualDentry;
+   int ret;
+
+   if (!dentry) {
+      Warning("DentryOpRevalidate: invalid args from kernel\n");
+      return 0;
+   }
+
+   /*
+    * If a dentry does not have an inode associated with it then
+    * we are dealing with a negative dentry. Always invalidate a negative
+    * dentry which will cause a fresh lookup.
+    */
+   if (!dentry->d_inode) {
+      return 0;
+   }
+
+
+   iinfo = INODE_TO_IINFO(dentry->d_inode);
+   if (!iinfo) {
+      Warning("DentryOpRevalidate: dentry has no fs-specific data\n");
+      return 0;
+   }
+
+   /* Block if there is a pending block on this file */
+   BlockWaitOnFile(iinfo->name, NULL);
+
+   /*
+    * If the actual dentry has a revalidate function, we'll let it figure out
+    * whether the dentry is still valid.  If not, do a path lookup to ensure
+    * that the file still exists.
+    */
+   actualDentry = iinfo->actualDentry;
+
+   if (actualDentry &&
+       actualDentry->d_op &&
+       actualDentry->d_op->d_revalidate) {
+      return actualDentry->d_op->d_revalidate(actualDentry, nd);
+   }
+
+   if (compat_path_lookup(iinfo->name, 0, &actualNd)) {
+      LOG(4, "DentryOpRevalidate: [%s] no longer exists\n", iinfo->name);
+      return 0;
+   }
+   ret = compat_vmw_nd_to_dentry(actualNd) &&
+         compat_vmw_nd_to_dentry(actualNd)->d_inode;
+   compat_path_release(&actualNd);
+
+   LOG(8, "DentryOpRevalidate: [%s] %s revalidated\n",
+       iinfo->name, ret ? "" : "not");
+   return ret;
+}

=== added file '.pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/inode.c'
--- .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/inode.c	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/vmblock/linux/inode.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,232 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * inode.c --
+ *
+ *   Inode operations for the file system of the vmblock driver.
+ *
+ */
+
+#include "driver-config.h"
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/time.h>
+#include <linux/namei.h>
+
+#include "vmblockInt.h"
+#include "filesystem.h"
+#include "block.h"
+
+
+/* Inode operations */
+static struct dentry *InodeOpLookup(struct inode *dir,
+                                    struct dentry *dentry, struct nameidata *nd);
+static int InodeOpReadlink(struct dentry *dentry, char __user *buffer, int buflen);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+static void *InodeOpFollowlink(struct dentry *dentry, struct nameidata *nd);
+#else
+static int InodeOpFollowlink(struct dentry *dentry, struct nameidata *nd);
+#endif
+
+
+struct inode_operations RootInodeOps = {
+   .lookup = InodeOpLookup,
+};
+
+static struct inode_operations LinkInodeOps = {
+   .readlink    = InodeOpReadlink,
+   .follow_link = InodeOpFollowlink,
+};
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * InodeOpLookup --
+ *
+ *    Looks up a name (dentry) in provided directory.  Invoked every time
+ *    a directory entry is traversed in path lookups.
+ *
+ * Results:
+ *    NULL on success, negative error code on error.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static struct dentry *
+InodeOpLookup(struct inode *dir,      // IN: parent directory's inode
+              struct dentry *dentry,  // IN: dentry to lookup
+              struct nameidata *nd)   // IN: lookup intent and information
+{
+   char *filename;
+   struct inode *inode;
+   int ret;
+
+   if (!dir || !dentry) {
+      Warning("InodeOpLookup: invalid args from kernel\n");
+      return ERR_PTR(-EINVAL);
+   }
+
+   /* The kernel should only pass us our own inodes, but check just to be safe. */
+   if (!INODE_TO_IINFO(dir)) {
+      Warning("InodeOpLookup: invalid inode provided\n");
+      return ERR_PTR(-EINVAL);
+   }
+
+   /* Get a slab from the kernel's names_cache of PATH_MAX-sized buffers. */
+   filename = __getname();
+   if (!filename) {
+      Warning("InodeOpLookup: unable to obtain memory for filename.\n");
+      return ERR_PTR(-ENOMEM);
+   }
+
+   ret = MakeFullName(dir, dentry, filename, PATH_MAX);
+   if (ret < 0) {
+      Warning("InodeOpLookup: could not construct full name\n");
+      __putname(filename);
+      return ERR_PTR(ret);
+   }
+
+   /* Block if there is a pending block on this file */
+   BlockWaitOnFile(filename, NULL);
+   __putname(filename);
+
+   inode = Iget(dir->i_sb, dir, dentry, GetNextIno());
+   if (!inode) {
+      Warning("InodeOpLookup: failed to get inode\n");
+      return ERR_PTR(-ENOMEM);
+   }
+
+   dentry->d_op = &LinkDentryOps;
+   dentry->d_time = jiffies;
+
+   /*
+    * If the actual file's dentry doesn't have an inode, it means the file we
+    * are redirecting to doesn't exist.  Give back the inode that was created
+    * for this and add a NULL dentry->inode entry in the dcache.  (The NULL
+    * entry is added so ops to create files/directories are invoked by VFS.)
+    */
+   if (!INODE_TO_ACTUALDENTRY(inode) || !INODE_TO_ACTUALINODE(inode)) {
+      iput(inode);
+      d_add(dentry, NULL);
+      return NULL;
+   }
+
+   inode->i_mode = S_IFLNK | S_IRWXUGO;
+   inode->i_size = INODE_TO_IINFO(inode)->nameLen;
+   inode->i_version = 1;
+   inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+   inode->i_uid = inode->i_gid = 0;
+   inode->i_op = &LinkInodeOps;
+
+   d_add(dentry, inode);
+   return NULL;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * InodeOpReadlink --
+ *
+ *    Provides the symbolic link's contents to the user.  Invoked when
+ *    readlink(2) is invoked on our symlinks.
+ *
+ * Results:
+ *    0 on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+InodeOpReadlink(struct dentry *dentry,  // IN : dentry of symlink
+                char __user *buffer,    // OUT: output buffer (user space)
+                int buflen)             // IN : length of output buffer
+{
+   VMBlockInodeInfo *iinfo;
+
+   if (!dentry || !buffer) {
+      Warning("InodeOpReadlink: invalid args from kernel\n");
+      return -EINVAL;
+   }
+
+   iinfo = INODE_TO_IINFO(dentry->d_inode);
+   if (!iinfo) {
+      return -EINVAL;
+   }
+
+   return vfs_readlink(dentry, buffer, buflen, iinfo->name);
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * InodeOpFollowlink --
+ *
+ *    Provides the inode corresponding to this symlink through the nameidata
+ *    structure.
+ *
+ * Results:
+ *    0 on success, negative error on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+static void *
+#else
+static int
+#endif
+InodeOpFollowlink(struct dentry *dentry,  // IN : dentry of symlink
+                  struct nameidata *nd)   // OUT: stores result
+{
+   int ret;
+   VMBlockInodeInfo *iinfo;
+
+   if (!dentry) {
+      Warning("InodeOpReadlink: invalid args from kernel\n");
+      ret = -EINVAL;
+      goto out;
+   }
+
+   iinfo = INODE_TO_IINFO(dentry->d_inode);
+   if (!iinfo) {
+      ret = -EINVAL;
+      goto out;
+   }
+
+   ret = vfs_follow_link(nd, iinfo->name);
+
+out:
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+   return ERR_PTR(ret);
+#else
+   return ret;
+#endif
+}

=== added directory '.pc/0005-linux-310-fix.patch/modules/linux/vmhgfs'
=== added file '.pc/0005-linux-310-fix.patch/modules/linux/vmhgfs/file.c'
--- .pc/0005-linux-310-fix.patch/modules/linux/vmhgfs/file.c	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/vmhgfs/file.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,1280 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * file.c --
+ *
+ * File operations for the filesystem portion of the vmhgfs driver.
+ */
+
+/* Must come before any kernel header file. */
+#include "driver-config.h"
+
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/signal.h>
+#include "compat_cred.h"
+#include "compat_fs.h"
+#include "compat_kernel.h"
+#include "compat_slab.h"
+
+#include "cpName.h"
+#include "hgfsProto.h"
+#include "module.h"
+#include "request.h"
+#include "hgfsUtil.h"
+#include "fsutil.h"
+#include "vm_assert.h"
+#include "vm_basic_types.h"
+
+/* Private functions. */
+static int HgfsPackOpenRequest(struct inode *inode,
+                               struct file *file,
+			       HgfsOp opUsed,
+                               HgfsReq *req);
+static int HgfsUnpackOpenReply(HgfsReq *req,
+                               HgfsOp opUsed,
+                               HgfsHandle *file,
+                               HgfsLockType *lock);
+static int HgfsGetOpenFlags(uint32 flags);
+
+/* HGFS file operations for files. */
+static int HgfsOpen(struct inode *inode,
+                    struct file *file);
+#if defined VMW_USE_AIO
+static ssize_t HgfsAioRead(struct kiocb *iocb,
+                           const struct iovec *iov,
+                           unsigned long numSegs,
+                           loff_t offset);
+static ssize_t HgfsAioWrite(struct kiocb *iocb,
+                            const struct iovec *iov,
+                            unsigned long numSegs,
+                            loff_t offset);
+#else
+static ssize_t HgfsRead(struct file *file,
+                        char __user *buf,
+                        size_t count,
+                        loff_t *offset);
+static ssize_t HgfsWrite(struct file *file,
+                         const char __user *buf,
+                         size_t count,
+                         loff_t *offset);
+#endif
+
+static loff_t HgfsSeek(struct file *file,
+                       loff_t  offset,
+                       int origin);
+
+static int HgfsFsync(struct file *file,
+#if defined VMW_FSYNC_OLD
+                     struct dentry *dentry,
+#elif defined VMW_FSYNC_31
+                     loff_t start,
+                     loff_t end,
+#endif
+                     int datasync);
+static int HgfsMmap(struct file *file,
+                    struct vm_area_struct *vma);
+static int HgfsRelease(struct inode *inode,
+                       struct file *file);
+
+#ifndef VMW_SENDFILE_NONE
+#if defined VMW_SENDFILE_OLD
+static ssize_t HgfsSendfile(struct file *file,
+                            loff_t *offset,
+                            size_t count,
+                            read_actor_t actor,
+                            void __user *target);
+#else /* defined VMW_SENDFILE_NEW */
+static ssize_t HgfsSendfile(struct file *file,
+                            loff_t *offset,
+                            size_t count,
+                            read_actor_t actor,
+                            void *target);
+#endif
+#endif
+#ifdef VMW_SPLICE_READ
+static ssize_t HgfsSpliceRead(struct file *file,
+                              loff_t *offset,
+                              struct pipe_inode_info *pipe,
+                              size_t len,
+                              unsigned int flags);
+#endif
+
+/* HGFS file operations structure for files. */
+struct file_operations HgfsFileFileOperations = {
+   .owner      = THIS_MODULE,
+   .open       = HgfsOpen,
+   .llseek     = HgfsSeek,
+#if defined VMW_USE_AIO
+   .aio_read   = HgfsAioRead,
+   .aio_write  = HgfsAioWrite,
+#else
+   .read       = HgfsRead,
+   .write      = HgfsWrite,
+#endif
+   .fsync      = HgfsFsync,
+   .mmap       = HgfsMmap,
+   .release    = HgfsRelease,
+#ifndef VMW_SENDFILE_NONE
+   .sendfile   = HgfsSendfile,
+#endif
+#ifdef VMW_SPLICE_READ
+   .splice_read = HgfsSpliceRead,
+#endif
+};
+
+/* File open mask. */
+#define HGFS_FILE_OPEN_MASK (HGFS_OPEN_VALID_MODE | \
+                             HGFS_OPEN_VALID_FLAGS | \
+                             HGFS_OPEN_VALID_SPECIAL_PERMS | \
+			     HGFS_OPEN_VALID_OWNER_PERMS | \
+			     HGFS_OPEN_VALID_GROUP_PERMS | \
+			     HGFS_OPEN_VALID_OTHER_PERMS | \
+			     HGFS_OPEN_VALID_FILE_NAME | \
+			     HGFS_OPEN_VALID_SERVER_LOCK)
+
+
+/*
+ * Private functions.
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsPackOpenRequest --
+ *
+ *    Setup the Open request, depending on the op version.
+ *
+ * Results:
+ *    Returns zero on success, or negative error on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsPackOpenRequest(struct inode *inode, // IN: Inode of the file to open
+                    struct file *file,   // IN: File pointer for this open
+		    HgfsOp opUsed,       // IN: Op to use
+                    HgfsReq *req)        // IN/OUT: Packet to write into
+{
+   char *name;
+   uint32 *nameLength;
+   size_t requestSize;
+   int result;
+
+   ASSERT(inode);
+   ASSERT(file);
+   ASSERT(req);
+
+   switch (opUsed) {
+    case HGFS_OP_OPEN_V3: {
+      HgfsRequest *requestHeader;
+      HgfsRequestOpenV3 *requestV3;
+
+      requestHeader = (HgfsRequest *)HGFS_REQ_PAYLOAD(req);
+      requestHeader->op = opUsed;
+      requestHeader->id = req->id;
+
+      requestV3 = (HgfsRequestOpenV3 *)HGFS_REQ_PAYLOAD_V3(req);
+      requestSize = HGFS_REQ_PAYLOAD_SIZE_V3(requestV3);
+
+      /* We'll use these later. */
+      name = requestV3->fileName.name;
+      nameLength = &requestV3->fileName.length;
+
+      requestV3->mask = HGFS_FILE_OPEN_MASK;
+
+      /* Linux clients need case-sensitive lookups. */
+      requestV3->fileName.flags = 0;
+      requestV3->fileName.caseType = HGFS_FILE_NAME_CASE_SENSITIVE;
+      requestV3->fileName.fid = HGFS_INVALID_HANDLE;
+
+      /* Set mode. */
+      result = HgfsGetOpenMode(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open mode\n"));
+         return -EINVAL;
+      }
+      requestV3->mode = result;
+
+      /* Set flags. */
+      result = HgfsGetOpenFlags(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open flags\n"));
+         return -EINVAL;
+      }
+      requestV3->flags = result;
+
+      /* Set permissions. */
+      requestV3->specialPerms = (inode->i_mode & (S_ISUID | S_ISGID | S_ISVTX))
+                                >> 9;
+      requestV3->ownerPerms = (inode->i_mode & S_IRWXU) >> 6;
+      requestV3->groupPerms = (inode->i_mode & S_IRWXG) >> 3;
+      requestV3->otherPerms = (inode->i_mode & S_IRWXO);
+
+      /* XXX: Request no lock for now. */
+      requestV3->desiredLock = HGFS_LOCK_NONE;
+
+      requestV3->reserved1 = 0;
+      requestV3->reserved2 = 0;
+      break;
+   }
+
+   case HGFS_OP_OPEN_V2: {
+      HgfsRequestOpenV2 *requestV2;
+
+      requestV2 = (HgfsRequestOpenV2 *)(HGFS_REQ_PAYLOAD(req));
+      requestV2->header.op = opUsed;
+      requestV2->header.id = req->id;
+
+      /* We'll use these later. */
+      name = requestV2->fileName.name;
+      nameLength = &requestV2->fileName.length;
+      requestSize = sizeof *requestV2;
+
+      requestV2->mask = HGFS_FILE_OPEN_MASK;
+
+      /* Set mode. */
+      result = HgfsGetOpenMode(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open mode\n"));
+         return -EINVAL;
+      }
+      requestV2->mode = result;
+
+      /* Set flags. */
+      result = HgfsGetOpenFlags(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open flags\n"));
+         return -EINVAL;
+      }
+      requestV2->flags = result;
+
+      /* Set permissions. */
+      requestV2->specialPerms = (inode->i_mode & (S_ISUID | S_ISGID | S_ISVTX))
+                                >> 9;
+      requestV2->ownerPerms = (inode->i_mode & S_IRWXU) >> 6;
+      requestV2->groupPerms = (inode->i_mode & S_IRWXG) >> 3;
+      requestV2->otherPerms = (inode->i_mode & S_IRWXO);
+
+      /* XXX: Request no lock for now. */
+      requestV2->desiredLock = HGFS_LOCK_NONE;
+      break;
+   }
+   case HGFS_OP_OPEN: {
+      HgfsRequestOpen *request;
+
+      request = (HgfsRequestOpen *)(HGFS_REQ_PAYLOAD(req));
+      request->header.op = opUsed;
+      request->header.id = req->id;
+
+      /* We'll use these later. */
+      name = request->fileName.name;
+      nameLength = &request->fileName.length;
+      requestSize = sizeof *request;
+
+      /* Set mode. */
+      result = HgfsGetOpenMode(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open mode\n"));
+         return -EINVAL;
+      }
+      request->mode = result;
+
+      /* Set flags. */
+      result = HgfsGetOpenFlags(file->f_flags);
+      if (result < 0) {
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: failed to get "
+                 "open flags\n"));
+         return -EINVAL;
+      }
+      request->flags = result;
+
+      /* Set permissions. */
+      request->permissions = (inode->i_mode & S_IRWXU) >> 6;
+      break;
+   }
+   default:
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: unexpected "
+              "OP type encountered\n"));
+      return -EPROTO;
+   }
+
+   /* Build full name to send to server. */
+   if (HgfsBuildPath(name,
+                     req->bufferSize - (requestSize - 1),
+                     file->f_dentry) < 0) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: build path "
+              "failed\n"));
+      return -EINVAL;
+   }
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: opening \"%s\", "
+           "flags %o, create perms %o\n", name,
+           file->f_flags, file->f_mode));
+
+   /* Convert to CP name. */
+   result = CPName_ConvertTo(name,
+                             req->bufferSize - (requestSize - 1),
+                             name);
+   if (result < 0) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsPackOpenRequest: CP conversion "
+              "failed\n"));
+      return -EINVAL;
+   }
+
+   *nameLength = (uint32) result;
+   req->payloadSize = requestSize + result;
+
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsUnpackOpenReply --
+ *
+ *    Get interesting fields out of the Open reply, depending on the op
+ *    version.
+ *
+ * Results:
+ *    Returns zero on success, or negative error on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsUnpackOpenReply(HgfsReq *req,          // IN: Packet with reply inside
+                    HgfsOp opUsed,         // IN: What request op did we send
+                    HgfsHandle *file,      // OUT: Handle in reply packet
+                    HgfsLockType *lock)    // OUT: The server lock we got
+{
+   HgfsReplyOpenV3 *replyV3;
+   HgfsReplyOpenV2 *replyV2;
+   HgfsReplyOpen *replyV1;
+   size_t replySize;
+
+   ASSERT(req);
+   ASSERT(file);
+   ASSERT(lock);
+
+   switch (opUsed) {
+   case HGFS_OP_OPEN_V3:
+      replyV3 = (HgfsReplyOpenV3 *)HGFS_REP_PAYLOAD_V3(req);
+      replySize = HGFS_REP_PAYLOAD_SIZE_V3(replyV3);
+      *file = replyV3->file;
+      *lock = replyV3->acquiredLock;
+      break;
+   case HGFS_OP_OPEN_V2:
+      replyV2 = (HgfsReplyOpenV2 *)(HGFS_REQ_PAYLOAD(req));
+      replySize = sizeof *replyV2;
+      *file = replyV2->file;
+      *lock = replyV2->acquiredLock;
+      break;
+   case HGFS_OP_OPEN:
+      replyV1 = (HgfsReplyOpen *)(HGFS_REQ_PAYLOAD(req));
+      replySize = sizeof *replyV1;
+      *file = replyV1->file;
+      *lock = HGFS_LOCK_NONE;
+      break;
+   default:
+
+      /* This really shouldn't happen since we set opUsed ourselves. */
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackOpenReply: unexpected "
+              "OP type encountered\n"));
+      ASSERT(FALSE);
+      return -EPROTO;
+   }
+
+   if (req->payloadSize != replySize) {
+      /*
+       * The reply to Open is a fixed size. So the size of the payload
+       * really ought to match the expected size of an HgfsReplyOpen[V2].
+       */
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsUnpackOpenReply: wrong packet "
+              "size\n"));
+      return -EPROTO;
+   }
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsGetOpenFlags --
+ *
+ *    Based on the flags requested by the process making the open()
+ *    syscall, determine which flags to send to the server to open the
+ *    file.
+ *
+ * Results:
+ *    Returns the correct HgfsOpenFlags enumeration to send to the
+ *    server, or -1 on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsGetOpenFlags(uint32 flags) // IN: Open flags
+{
+   uint32 mask = O_CREAT | O_TRUNC | O_EXCL;
+   int result = -1;
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsGetOpenFlags: entered\n"));
+
+   /*
+    * Mask the flags to only look at O_CREAT, O_EXCL, and O_TRUNC.
+    */
+
+   flags &= mask;
+
+   /* O_EXCL has no meaning if O_CREAT is not set. */
+   if (!(flags & O_CREAT)) {
+      flags &= ~O_EXCL;
+   }
+
+   /* Pick the right HgfsOpenFlags. */
+   switch (flags) {
+
+   case 0:
+      /* Regular open; fails if file nonexistant. */
+      result = HGFS_OPEN;
+      break;
+
+   case O_CREAT:
+      /* Create file; if it exists already just open it. */
+      result = HGFS_OPEN_CREATE;
+      break;
+
+   case O_TRUNC:
+      /* Truncate existing file; fails if nonexistant. */
+      result = HGFS_OPEN_EMPTY;
+      break;
+
+   case (O_CREAT | O_EXCL):
+      /* Create file; fail if it exists already. */
+      result = HGFS_OPEN_CREATE_SAFE;
+      break;
+
+   case (O_CREAT | O_TRUNC):
+      /* Create file; if it exists already, truncate it. */
+      result = HGFS_OPEN_CREATE_EMPTY;
+      break;
+
+   default:
+      /*
+       * This can only happen if all three flags are set, which
+       * conceptually makes no sense because O_EXCL and O_TRUNC are
+       * mutually exclusive if O_CREAT is set.
+       *
+       * However, the open(2) man page doesn't say you can't set all
+       * three flags, and certain apps (*cough* Nautilus *cough*) do
+       * so. To be friendly to those apps, we just silenty drop the
+       * O_TRUNC flag on the assumption that it's safer to honor
+       * O_EXCL.
+       */
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsGetOpenFlags: invalid open "
+              "flags %o. Ignoring the O_TRUNC flag.\n", flags));
+      result = HGFS_OPEN_CREATE_SAFE;
+      break;
+   }
+
+   return result;
+}
+
+
+/*
+ * HGFS file operations for files.
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsOpen --
+ *
+ *    Called whenever a process opens a file in our filesystem.
+ *
+ *    We send an "Open" request to the server with the name stored in
+ *    this file's inode. If the Open succeeds, we store the filehandle
+ *    sent by the server in the file struct so it can be accessed by
+ *    read/write/close.
+ *
+ * Results:
+ *    Returns zero if on success, error on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsOpen(struct inode *inode,  // IN: Inode of the file to open
+         struct file *file)    // IN: File pointer for this open
+{
+   HgfsReq *req;
+   HgfsOp opUsed;
+   HgfsStatus replyStatus;
+   HgfsHandle replyFile;
+   HgfsLockType replyLock;
+   HgfsInodeInfo *iinfo;
+   int result = 0;
+
+   ASSERT(inode);
+   ASSERT(inode->i_sb);
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+   ASSERT(file->f_dentry->d_inode);
+
+   iinfo = INODE_GET_II_P(inode);
+
+   req = HgfsGetNewRequest();
+   if (!req) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: out of memory while "
+              "getting new request\n"));
+      result = -ENOMEM;
+      goto out;
+   }
+
+  retry:
+   /*
+    * Set up pointers using the proper struct This lets us check the
+    * version exactly once and use the pointers later.
+    */
+
+   opUsed = hgfsVersionOpen;
+   result = HgfsPackOpenRequest(inode, file, opUsed, req);
+   if (result != 0) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: error packing request\n"));
+      goto out;
+   }
+
+   /* Send the request and process the reply. */
+   result = HgfsSendRequest(req);
+   if (result == 0) {
+      /* Get the reply and check return status. */
+      replyStatus = HgfsReplyStatus(req);
+      result = HgfsStatusConvertToLinux(replyStatus);
+
+      switch (result) {
+      case 0:
+         iinfo->createdAndUnopened = FALSE;
+         LOG(10, (KERN_DEBUG "VMware hgfs: HgfsOpen: old hostFileId = "
+                  "%"FMT64"u\n", iinfo->hostFileId));
+         /*
+          * Invalidate the hostFileId as we need to retrieve it from
+          * the server.
+          */
+         iinfo->hostFileId = 0;
+         result = HgfsUnpackOpenReply(req, opUsed, &replyFile, &replyLock);
+         if (result != 0) {
+            break;
+         }
+         result = HgfsCreateFileInfo(file, replyFile);
+         if (result != 0) {
+            break;
+         }
+         LOG(6, (KERN_DEBUG "VMware hgfs: HgfsOpen: set handle to %u\n",
+                 replyFile));
+
+         /*
+          * HgfsCreate faked all of the inode's attributes, so by the time
+          * we're done in HgfsOpen, we need to make sure that the attributes
+          * in the inode are real. The following is only necessary when
+          * O_CREAT is set, otherwise we got here after HgfsLookup (which sent
+          * a getattr to the server and got the real attributes).
+          *
+          * In particular, we'd like to at least try and set the inode's
+          * uid/gid to match the caller's. We don't expect this to work,
+          * because Windows servers will ignore it, and Linux servers running
+          * as non-root won't be able to change it, but we're forward thinking
+          * people.
+          *
+          * Either way, we force a revalidate following the setattr so that
+          * we'll get the actual uid/gid from the server.
+          */
+         if (file->f_flags & O_CREAT) {
+            struct dentry *dparent;
+            struct inode *iparent;
+
+            /*
+             * This is not the root of our file system so there should always
+             * be a parent.
+             */
+            ASSERT(file->f_dentry->d_parent);
+
+            /*
+             * Here we obtain a reference on the parent to make sure it doesn't
+             * go away.  This might not be necessary, since the existence of
+             * a child (which we hold a reference to in this call) should
+             * account for a reference in the parent, but it's safe to do so.
+             * Overly cautious and safe is better than risky and broken.
+             *
+             * XXX Note that this and a handful of other hacks wouldn't be
+             * necessary if we actually created the file in our create
+             * implementation (where references and locks are properly held).
+             * We could do this if we were willing to give up support for
+             * O_EXCL on 2.4 kernels.
+             */
+            dparent = dget(file->f_dentry->d_parent);
+            iparent = dparent->d_inode;
+
+            HgfsSetUidGid(iparent, file->f_dentry,
+                          current_fsuid(), current_fsgid());
+
+            dput(dparent);
+         }
+         break;
+
+      case -EPROTO:
+         /* Retry with older version(s). Set globally. */
+         if (opUsed == HGFS_OP_OPEN_V3) {
+            LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: Version 3 not "
+                    "supported. Falling back to version 2.\n"));
+            hgfsVersionOpen = HGFS_OP_OPEN_V2;
+            goto retry;
+         }
+
+         /* Retry with Version 1 of Open. Set globally. */
+         if (opUsed == HGFS_OP_OPEN_V2) {
+            LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: Version 2 not "
+                    "supported. Falling back to version 1.\n"));
+            hgfsVersionOpen = HGFS_OP_OPEN;
+            goto retry;
+         }
+
+         /* Fallthrough. */
+      default:
+         break;
+      }
+   } else if (result == -EIO) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: timed out\n"));
+   } else if (result == -EPROTO) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: server "
+              "returned error: %d\n", result));
+   } else {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsOpen: unknown error: "
+              "%d\n", result));
+   }
+out:
+   HgfsFreeRequest(req);
+
+   /*
+    * If the open failed (for any reason) and we tried to open a newly created
+    * file, we must ensure that the next operation on this inode triggers a
+    * revalidate to the server. This is because the file wasn't created on the
+    * server, yet we currently believe that it was, because we created a fake
+    * inode with a hashed dentry for it in HgfsCreate. We will continue to
+    * believe this until the dentry's ttl expires, which will cause a
+    * revalidate to the server that will reveal the truth. So in order to find
+    * the truth as soon as possible, we'll reset the dentry's last revalidate
+    * time now to force a revalidate the next time someone uses the dentry.
+    *
+    * We're using our own flag to track this case because using O_CREAT isn't
+    * good enough: HgfsOpen will be called with O_CREAT even if the file exists
+    * on the server, and if that's the case, there's no need to revalidate.
+    *
+    * XXX: Note that this will need to be reworked if/when we support hard
+    * links, because multiple dentries will point to the same inode, and
+    * forcing a revalidate on one will not force it on any others.
+    */
+   if (result != 0 && iinfo->createdAndUnopened == TRUE) {
+      HgfsDentryAgeForce(file->f_dentry);
+   }
+   return result;
+}
+
+
+#if defined VMW_USE_AIO
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsAioRead --
+ *
+ *    Called when the kernel initiates an asynchronous read to a file in
+ *    our filesystem. Our function is just a thin wrapper around
+ *    generic_file_aio_read() that tries to validate the dentry first.
+ *
+ * Results:
+ *    Returns the number of bytes read on success, or an error on
+ *    failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static ssize_t
+HgfsAioRead(struct kiocb *iocb,      // IN:  I/O control block
+            const struct iovec *iov, // OUT: Array of I/O buffers
+            unsigned long numSegs,   // IN:  Number of buffers
+            loff_t offset)           // IN:  Offset at which to read
+{
+   int result;
+
+   ASSERT(iocb);
+   ASSERT(iocb->ki_filp);
+   ASSERT(iocb->ki_filp->f_dentry);
+   ASSERT(iov);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsAioRead: was called\n"));
+
+   result = HgfsRevalidate(iocb->ki_filp->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsAioRead: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_aio_read(iocb, iov, numSegs, offset);
+  out:
+   return result;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsAioWrite --
+ *
+ *    Called when the kernel initiates an asynchronous write to a file in
+ *    our filesystem. Our function is just a thin wrapper around
+ *    generic_file_aio_write() that tries to validate the dentry first.
+ *
+ *    Note that files opened with O_SYNC (or superblocks mounted with
+ *    "sync") are synchronously written to by the VFS.
+ *
+ * Results:
+ *    Returns the number of bytes written on success, or an error on
+ *    failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static ssize_t
+HgfsAioWrite(struct kiocb *iocb,      // IN:  I/O control block
+             const struct iovec *iov, // IN:  Array of I/O buffers
+             unsigned long numSegs,   // IN:  Number of buffers
+             loff_t offset)           // IN:  Offset at which to read
+{
+   int result;
+
+   ASSERT(iocb);
+   ASSERT(iocb->ki_filp);
+   ASSERT(iocb->ki_filp->f_dentry);
+   ASSERT(iov);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsAioWrite: was called\n"));
+
+   result = HgfsRevalidate(iocb->ki_filp->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsAioWrite: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_aio_write(iocb, iov, numSegs, offset);
+  out:
+   return result;
+}
+
+
+#else
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsRead --
+ *
+ *    Called whenever a process reads from a file in our filesystem. Our
+ *    function is just a thin wrapper around generic_read_file() that
+ *    tries to validate the dentry first.
+ *
+ * Results:
+ *    Returns the number of bytes read on success, or an error on
+ *    failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static ssize_t
+HgfsRead(struct file *file,  // IN:  File to read from
+         char __user *buf,   // OUT: User buffer to copy data into
+         size_t count,       // IN:  Number of bytes to read
+         loff_t *offset)     // IN:  Offset at which to read
+{
+   int result;
+
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+   ASSERT(buf);
+   ASSERT(offset);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsRead: read %Zu bytes from fh %u "
+           "at offset %Lu\n", count, FILE_GET_FI_P(file)->handle, *offset));
+
+   result = HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRead: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_read(file, buf, count, offset);
+  out:
+   return result;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsWrite --
+ *
+ *    Called whenever a process writes to a file in our filesystem. Our
+ *    function is just a thin wrapper around generic_write_file() that
+ *    tries to validate the dentry first.
+ *
+ *    Note that files opened with O_SYNC (or superblocks mounted with
+ *    "sync") are synchronously written to by the VFS.
+ *
+ * Results:
+ *    Returns the number of bytes written on success, or an error on
+ *    failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static ssize_t
+HgfsWrite(struct file *file,      // IN: File to write to
+          const char __user *buf, // IN: User buffer where the data is
+          size_t count,           // IN: Number of bytes to write
+          loff_t *offset)         // IN: Offset to begin writing at
+{
+   int result;
+
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+   ASSERT(file->f_dentry->d_inode);
+   ASSERT(buf);
+   ASSERT(offset);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsWrite: write %Zu bytes to fh %u "
+           "at offset %Lu\n", count, FILE_GET_FI_P(file)->handle, *offset));
+
+   result = HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsWrite: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_write(file, buf, count, offset);
+  out:
+   return result;
+}
+#endif
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsSeek --
+ *
+ *    Called whenever a process moves the file pointer for a file in our
+ *    filesystem. Our function is just a thin wrapper around
+ *    generic_file_llseek() that tries to validate the dentry first.
+ *
+ * Results:
+ *    Returns the new position of the file pointer on success,
+ *    or a negative error on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static loff_t
+HgfsSeek(struct file *file,  // IN:  File to seek
+         loff_t offset,      // IN:  Number of bytes to seek
+         int origin)         // IN:  Position to seek from
+
+{
+   loff_t result = -1;
+
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsSeek: seek to %Lu bytes from fh %u "
+           "from position %d\n", offset, FILE_GET_FI_P(file)->handle, origin));
+
+   result = (loff_t) HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(6, (KERN_DEBUG "VMware hgfs: HgfsSeek: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_llseek(file, offset, origin);
+
+  out:
+   return result;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsFsync --
+ *
+ *    Called when user process calls fsync() on hgfs file.
+ *
+ *    The hgfs protocol doesn't support fsync yet, so for now, we punt
+ *    and just return success. This is a little less sketchy than it
+ *    might sound, because hgfs skips the buffer cache in the guest
+ *    anyway (we always write to the host immediately).
+ *
+ *    In the future we might want to try harder though, since
+ *    presumably the intent of an app calling fsync() is to get the
+ *    data onto persistent storage, and as things stand now we're at
+ *    the whim of the hgfs server code running on the host to fsync or
+ *    not if and when it pleases.
+ *
+ *    Note that do_fsync will call filemap_fdatawrite() before us and
+ *    filemap_fdatawait() after us, so there's no need to do anything
+ *    here w.r.t. writing out dirty pages.
+ *
+ * Results:
+ *    Returns zero on success. (Currently always succeeds).
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsFsync(struct file *file,		// IN: File we operate on
+#if defined VMW_FSYNC_OLD
+          struct dentry *dentry,        // IN: Dentry for this file
+#elif defined VMW_FSYNC_31
+          loff_t start,                 // IN: start of range to sync
+          loff_t end,                   // IN: end of range to sync
+#endif
+          int datasync)	                // IN: fdatasync or fsync
+{
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsFsync: was called\n"));
+
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsMmap --
+ *
+ *    Called when user process calls mmap() on hgfs file. This is a very
+ *    thin wrapper function- we simply attempt to revalidate the
+ *    dentry prior to calling generic_file_mmap().
+ *
+ * Results:
+ *    Returns zero on success.
+ *    Returns negative error value on failure
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsMmap(struct file *file,		// IN: File we operate on
+         struct vm_area_struct *vma)	// IN/OUT: VM area information
+{
+   int result;
+
+   ASSERT(file);
+   ASSERT(vma);
+   ASSERT(file->f_dentry);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsMmap: was called\n"));
+
+   result = HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsMmap: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_mmap(file, vma);
+  out:
+   return result;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HgfsRelease --
+ *
+ *    Called when the last user of a file closes it, i.e. when the
+ *    file's f_count becomes zero.
+ *
+ * Results:
+ *    Returns zero on success, or an error on failure.
+ *
+ * Side effects:
+ *    None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HgfsRelease(struct inode *inode,  // IN: Inode that this file points to
+            struct file *file)    // IN: File that is getting released
+{
+   HgfsReq *req;
+   HgfsHandle handle;
+   HgfsOp opUsed;
+   HgfsStatus replyStatus;
+   int result = 0;
+
+   ASSERT(inode);
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+   ASSERT(file->f_dentry->d_sb);
+
+   handle = FILE_GET_FI_P(file)->handle;
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsRelease: close fh %u\n", handle));
+
+   /*
+    * This may be our last open handle to an inode, so we should flush our
+    * dirty pages before closing it.
+    */
+   compat_filemap_write_and_wait(inode->i_mapping);
+
+   HgfsReleaseFileInfo(file);
+
+   req = HgfsGetNewRequest();
+   if (!req) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: out of memory while "
+              "getting new request\n"));
+      result = -ENOMEM;
+      goto out;
+   }
+
+ retry:
+   opUsed = hgfsVersionClose;
+   if (opUsed == HGFS_OP_CLOSE_V3) {
+      HgfsRequest *header;
+      HgfsRequestCloseV3 *request;
+
+      header = (HgfsRequest *)(HGFS_REQ_PAYLOAD(req));
+      header->id = req->id;
+      header->op = opUsed;
+
+      request = (HgfsRequestCloseV3 *)(HGFS_REQ_PAYLOAD_V3(req));
+      request->file = handle;
+      request->reserved = 0;
+      req->payloadSize = HGFS_REQ_PAYLOAD_SIZE_V3(request);
+   } else {
+      HgfsRequestClose *request;
+
+      request = (HgfsRequestClose *)(HGFS_REQ_PAYLOAD(req));
+      request->header.id = req->id;
+      request->header.op = opUsed;
+      request->file = handle;
+      req->payloadSize = sizeof *request;
+   }
+
+   /* Send the request and process the reply. */
+   result = HgfsSendRequest(req);
+   if (result == 0) {
+      /* Get the reply. */
+      replyStatus = HgfsReplyStatus(req);
+      result = HgfsStatusConvertToLinux(replyStatus);
+
+      switch (result) {
+      case 0:
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: released handle %u\n",
+                 handle));
+         break;
+      case -EPROTO:
+         /* Retry with older version(s). Set globally. */
+         if (opUsed == HGFS_OP_CLOSE_V3) {
+            LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: Version 3 not "
+                    "supported. Falling back to version 1.\n"));
+            hgfsVersionClose = HGFS_OP_CLOSE;
+            goto retry;
+         }
+         break;
+      default:
+         LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: failed handle %u\n",
+                 handle));
+         break;
+      }
+   } else if (result == -EIO) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: timed out\n"));
+   } else if (result == -EPROTO) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: server "
+              "returned error: %d\n", result));
+   } else {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsRelease: unknown error: "
+              "%d\n", result));
+   }
+
+out:
+   HgfsFreeRequest(req);
+   return result;
+}
+
+
+#ifndef VMW_SENDFILE_NONE
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * HgfsSendfile --
+ *
+ *    sendfile() wrapper for HGFS. Note that this is for sending a file
+ *    from HGFS to another filesystem (or socket). To use HGFS as the
+ *    destination file in a call to sendfile(), we must implement sendpage()
+ *    as well.
+ *
+ *    Like mmap(), we're just interested in validating the dentry and then
+ *    calling into generic_file_sendfile().
+ *
+ * Results:
+ *    Returns number of bytes written on success, or an error on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#if defined VMW_SENDFILE_OLD
+static ssize_t
+HgfsSendfile(struct file *file,    // IN: File to read from
+             loff_t *offset,       // IN/OUT: Where to start reading
+             size_t count,         // IN: How much to read
+             read_actor_t actor,   // IN: Routine to send a page of data
+             void __user *target)  // IN: Destination file/socket
+#elif defined VMW_SENDFILE_NEW
+static ssize_t
+HgfsSendfile(struct file *file,    // IN: File to read from
+             loff_t *offset,       // IN/OUT: Where to start reading
+             size_t count,         // IN: How much to read
+             read_actor_t actor,   // IN: Routine to send a page of data
+             void *target)         // IN: Destination file/socket
+#endif
+{
+   ssize_t result;
+
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+   ASSERT(target);
+   ASSERT(offset);
+   ASSERT(actor);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsSendfile: was called\n"));
+
+   result = HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsSendfile: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_sendfile (file, offset, count, actor, target);
+  out:
+   return result;
+
+}
+#endif
+
+
+#ifdef VMW_SPLICE_READ
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * HgfsSpliceRead --
+ *
+ *    splice_read() wrapper for HGFS. Note that this is for sending a file
+ *    from HGFS to another filesystem (or socket). To use HGFS as the
+ *    destination file in a call to splice, we must implement splice_write()
+ *    as well.
+ *
+ *    Like mmap(), we're just interested in validating the dentry and then
+ *    calling into generic_file_splice_read().
+ *
+ * Results:
+ *    Returns number of bytes written on success, or an error on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static ssize_t
+HgfsSpliceRead(struct file *file,            // IN: File to read from
+               loff_t *offset,               // IN/OUT: Where to start reading
+               struct pipe_inode_info *pipe, // IN: Pipe where to write data
+               size_t len,                   // IN: How much to read
+               unsigned int flags)           // IN: Various flags
+{
+   ssize_t result;
+
+   ASSERT(file);
+   ASSERT(file->f_dentry);
+
+   LOG(6, (KERN_DEBUG "VMware hgfs: HgfsSpliceRead: was called\n"));
+
+   result = HgfsRevalidate(file->f_dentry);
+   if (result) {
+      LOG(4, (KERN_DEBUG "VMware hgfs: HgfsSpliceRead: invalid dentry\n"));
+      goto out;
+   }
+
+   result = generic_file_splice_read(file, offset, pipe, len, flags);
+  out:
+   return result;
+
+}
+#endif
+
+

=== added directory '.pc/0005-linux-310-fix.patch/modules/linux/vmsync'
=== added file '.pc/0005-linux-310-fix.patch/modules/linux/vmsync/sync.c'
--- .pc/0005-linux-310-fix.patch/modules/linux/vmsync/sync.c	1970-01-01 00:00:00 +0000
+++ .pc/0005-linux-310-fix.patch/modules/linux/vmsync/sync.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,711 @@
+/*********************************************************
+ * Copyright (C) 2007 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * sync.c --
+ *
+ * Linux "sync driver" implementation.
+ *
+ * A typical user of vmsync will:
+ *
+ * - call ioctl() with the SYNC_IOC_FREEZE to freeze a list of paths.
+ *   The list should be a colon-separated list of paths to be frozen.
+ * - call ioctl() with the SYNC_IOC_THAW command.
+ *
+ * The driver has an internal timer that is set up as soon as devices
+ * are frozen (i.e., after a successful SYNC_IOC_FREEZE). Subsequent calls
+ * to SYNC_IOC_FREEZE will not reset the timer. This timer is not designed
+ * as a way to protect the driver from being an avenue for a DoS attack
+ * (after all, if the user already has CAP_SYS_ADMIN privileges...), but
+ * as a way to protect itself from faulty user level apps during testing.
+ */
+
+/* Must come before any kernel header file. */
+#include "driver-config.h"
+
+#include <asm/bug.h>
+#include <asm/uaccess.h>
+#include <asm/string.h>
+#include <linux/buffer_head.h>
+#include <linux/proc_fs.h>
+
+#include "compat_fs.h"
+#include "compat_module.h"
+#include "compat_namei.h"
+#include "compat_mutex.h"
+#include "compat_slab.h"
+#include "compat_workqueue.h"
+
+#include "syncDriverIoc.h"
+#include "vmsync_version.h"
+
+/*
+ * After a successful SYNC_IOC_FREEZE ioctl, a timer will be enabled to thaw
+ * *all* frozen block devices after this delay.
+ */
+#define VMSYNC_THAW_TASK_DELAY (30 * HZ)
+
+/* Module information. */
+MODULE_AUTHOR("VMware, Inc.");
+MODULE_DESCRIPTION("VMware Sync Driver");
+MODULE_VERSION(VMSYNC_DRIVER_VERSION_STRING);
+MODULE_LICENSE("GPL v2");
+/*
+ * Starting with SLE10sp2, Novell requires that IHVs sign a support agreement
+ * with them and mark their kernel modules as externally supported via a
+ * change to the module header. If this isn't done, the module will not load
+ * by default (i.e., neither mkinitrd nor modprobe will accept it).
+ */
+MODULE_INFO(supported, "external");
+
+static int VmSyncRelease(struct inode* inode,
+                         struct file *file);
+
+static long VmSyncUnlockedIoctl(struct file *file,
+                                unsigned cmd,
+                                unsigned long arg);
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
+static int VmSyncIoctl(struct inode *inode,
+                       struct file *file,
+                       unsigned cmd,
+                       unsigned long arg);
+#endif
+
+static int VmSyncOpen(struct inode *inode,
+                      struct file *f);
+
+static struct file_operations VmSyncFileOps = {
+   .owner            = THIS_MODULE,
+   .open             = VmSyncOpen,
+   .release          = VmSyncRelease,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11)
+   .unlocked_ioctl   = VmSyncUnlockedIoctl,
+#else
+   .ioctl            = VmSyncIoctl,
+#endif
+};
+
+
+typedef struct VmSyncBlockDevice {
+   struct list_head     list;
+   struct block_device  *bdev;
+   struct nameidata     nd;
+   struct super_block   *sb;
+} VmSyncBlockDevice;
+
+
+typedef struct VmSyncState {
+   struct list_head     devices;
+   compat_mutex_t       lock;
+   compat_delayed_work  thawTask;
+} VmSyncState;
+
+
+/*
+ * Serializes freeze operations. Used to make sure that two different
+ * fds aren't allowed to freeze the same device.
+ */
+static compat_mutex_t gFreezeLock;
+
+/* A global count of how many devices are currently frozen by the driver. */
+static atomic_t gFreezeCount;
+
+static compat_kmem_cache *gSyncStateCache;
+static compat_kmem_cache *gBlockDeviceCache;
+
+static compat_kmem_cache_ctor VmSyncBlockDeviceCtor;
+static compat_kmem_cache_ctor VmSyncStateCtor;
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncThawDevices --
+ *
+ *    Thaws all currently frozen devices.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    Devices are thawed, thaw task is cancelled.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VmSyncThawDevices(void  *_state)  // IN
+{
+   struct list_head *cur, *tmp;
+   VmSyncBlockDevice *dev;
+   VmSyncState *state;
+
+   state = (VmSyncState *) _state;
+
+   compat_mutex_lock(&state->lock);
+   cancel_delayed_work(&state->thawTask);
+   list_for_each_safe(cur, tmp, &state->devices) {
+      dev = list_entry(cur, VmSyncBlockDevice, list);
+      if (dev->sb != NULL && dev->sb->s_frozen != SB_UNFROZEN) {
+         thaw_bdev(dev->bdev, dev->sb);
+         atomic_dec(&gFreezeCount);
+      }
+      list_del_init(&dev->list);
+      kmem_cache_free(gBlockDeviceCache, dev);
+   }
+   compat_mutex_unlock(&state->lock);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncThawDevicesCallback --
+ *
+ *    Wrapper around VmSyncThawDevices used by the work queue.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    See VmSyncThawDevices.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VmSyncThawDevicesCallback(compat_delayed_work_arg data) // IN
+{
+   VmSyncState *state = COMPAT_DELAYED_WORK_GET_DATA(data,
+                                                     VmSyncState, thawTask);
+   VmSyncThawDevices(state);
+}
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncAddPath --
+ *
+ *    Adds the block device associated with the path to the internal list
+ *    of devices to be frozen.
+ *
+ * Results:
+ *    0 on success.
+ *    -EINVAL if path doesn't point to a freezable mount.
+ *    -EALREADY if path is already frozen.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VmSyncAddPath(const VmSyncState *state,   // IN
+              const char *path,           // IN
+              struct list_head *pathList) // IN
+{
+   int result;
+   struct list_head *cur, *tmp;
+   struct inode *inode;
+   struct nameidata nd;
+   VmSyncBlockDevice *dev;
+
+   if ((result = compat_path_lookup(path, LOOKUP_FOLLOW, &nd)) != 0) {
+      goto exit;
+   }
+   inode = compat_vmw_nd_to_dentry(nd)->d_inode;
+
+   /*
+    * Abort if the inode's superblock isn't backed by a block device, or if
+    * the superblock is already frozen.
+    */
+   if (inode->i_sb->s_bdev == NULL ||
+       inode->i_sb->s_frozen != SB_UNFROZEN) {
+      result = (inode->i_sb->s_bdev == NULL) ? -EINVAL : -EALREADY;
+      compat_path_release(&nd);
+      goto exit;
+   }
+
+   /*
+    * Check if we've already added the block device to the list.
+    */
+   list_for_each_safe(cur, tmp, &state->devices) {
+      dev = list_entry(cur, VmSyncBlockDevice, list);
+      if (dev->bdev == inode->i_sb->s_bdev) {
+         result = 0;
+         compat_path_release(&nd);
+         goto exit;
+      }
+   }
+
+   /*
+    * Allocate a new entry and add it to the list.
+    */
+   dev = kmem_cache_alloc(gBlockDeviceCache, GFP_KERNEL);
+   if (dev == NULL) {
+      result = -ENOMEM;
+      compat_path_release(&nd);
+      goto exit;
+   }
+
+   /*
+    * Whenever we add a device to the "freeze list", the reference to
+    * the nameidata struct is retained until the device is actually
+    * frozen; this ensures the kernel knows the path is being used.
+    * Here we copy the nameidata struct so we can release our reference
+    * at that time.
+    */
+   dev->bdev = inode->i_sb->s_bdev;
+   memcpy(&dev->nd, &nd, sizeof nd);
+   list_add_tail(&dev->list, pathList);
+   result = 0;
+
+exit:
+   return result;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncFreezeDevices --
+ *
+ *    Tries to freeze all the devices provided by the user.
+ *
+ * Results:
+ *    o on success, -errno on error.
+ *
+ * Side effects:
+ *    A task is scheduled to automatically thaw devices after a timeout.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VmSyncFreezeDevices(VmSyncState *state,            // IN
+                    const char __user *userPaths)  // IN
+{
+   int result = 0;
+   char *paths;
+   char *currPath;
+   char *nextSep;
+   struct list_head *cur, *tmp;
+   struct list_head pathList;
+   VmSyncBlockDevice *dev;
+
+   INIT_LIST_HEAD(&pathList);
+
+   /*
+    * XXX: Using getname() will restrict the list of paths to PATH_MAX.
+    * Although this is not ideal, it shouldn't be a problem. We need an
+    * upper bound anyway.
+    */
+   paths = getname(userPaths);
+   if (IS_ERR(paths)) {
+      return PTR_ERR(paths);
+   }
+
+   compat_mutex_lock(&gFreezeLock);
+   compat_mutex_lock(&state->lock);
+
+   /*
+    * First, try to add all paths to the list of paths to be frozen.
+    */
+   currPath = paths;
+   do {
+      nextSep = strchr(currPath, ':');
+      if (nextSep != NULL) {
+         *nextSep = '\0';
+      }
+      result = VmSyncAddPath(state, currPath, &pathList);
+      /*
+       * Due to the way our user level app decides which paths to freeze
+       * now, we need to ignore EINVAL since there's no way to detect
+       * from user-land which paths are freezable or not.
+       */
+      if (result != 0 && result != -EINVAL) {
+         break;
+      } else {
+         result = 0;
+      }
+      currPath = nextSep + 1;
+   } while (nextSep != NULL);
+
+   /*
+    * If adding all the requested paths worked, then freeze them.
+    * Otherwise, clean the list. Make sure we only touch the devices
+    * added in the current call.
+    */
+   list_for_each_safe(cur, tmp, &pathList) {
+      dev = list_entry(cur, VmSyncBlockDevice, list);
+      if (result == 0) {
+         dev->sb = freeze_bdev(dev->bdev);
+         compat_path_release(&dev->nd);
+         if (dev->sb != NULL) {
+            atomic_inc(&gFreezeCount);
+         }
+         list_move_tail(&dev->list, &state->devices);
+      } else {
+         list_del_init(&dev->list);
+         kmem_cache_free(gBlockDeviceCache, dev);
+      }
+   }
+
+   compat_mutex_unlock(&state->lock);
+   compat_mutex_unlock(&gFreezeLock);
+
+   if (result == 0) {
+      compat_schedule_delayed_work(&state->thawTask, VMSYNC_THAW_TASK_DELAY);
+   }
+   return result;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncQuery --
+ *
+ *    Writes the number of devices currently frozen by the driver to the
+ *    given address. The address should be in user space and be able to
+ *    hold an int32_t.
+ *
+ * Results:
+ *    0 on success, -errno on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static inline int
+VmSyncQuery(void __user *dst) // OUT
+{
+   int32_t active;
+   int result = 0;
+
+   active = (int32_t) atomic_read(&gFreezeCount);
+   if (copy_to_user(dst, &active, sizeof active)) {
+      result = -EFAULT;
+   }
+
+   return result;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncUnlockedIoctl --
+ *
+ *    Handles the IOCTLs recognized by the driver.
+ *
+ *    - SYNC_IOC_FREEZE: freezes the block device associated with the
+ *      path passed as a parameter.
+ *
+ *    - SYNC_IOC_THAW: thaws all currently frozen block devices.
+ *
+ *    - SYNC_IOC_QUERY: returns the number of block devices currently
+ *      frozen by the driver. This is a global view of the driver state
+ *      and doesn't reflect any fd-specific data.
+ *
+ * Results:
+ *    0 on success, -errno otherwise.
+ *
+ * Side effects:
+ *    See ioctl descriptions above.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static long
+VmSyncUnlockedIoctl(struct file *file,   // IN
+                    unsigned cmd,        // IN
+                    unsigned long arg)   // IN/OUT
+{
+   int result = -ENOTTY;
+   VmSyncState *state;
+
+   state = (VmSyncState *) file->private_data;
+
+   switch (cmd) {
+   case SYNC_IOC_FREEZE:
+      if (!capable(CAP_SYS_ADMIN)) {
+         result = -EPERM;
+         break;
+      }
+      result = VmSyncFreezeDevices(state, (const char __user *) arg);
+      break;
+
+   case SYNC_IOC_THAW:
+      if (!capable(CAP_SYS_ADMIN)) {
+         result = -EPERM;
+         break;
+      }
+      VmSyncThawDevices(state);
+      result = 0;
+      break;
+
+   case SYNC_IOC_QUERY:
+      result = VmSyncQuery((void __user *)arg);
+      break;
+
+   default:
+      printk(KERN_DEBUG "vmsync: unknown ioctl %d\n", cmd);
+      break;
+   }
+   return result;
+}
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncIoctl --
+ *
+ *    Wrapper around VmSyncUnlockedIoctl for kernels < 2.6.11, which don't
+ *    support unlocked_ioctl.
+ *
+ * Results:
+ *    See VmSyncUnlockedIoctl.
+ *
+ * Side effects:
+ *    See VmSyncUnlockedIoctl.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VmSyncIoctl(struct inode *inode, // IN
+            struct file *file,   // IN
+            unsigned cmd,        // IN
+            unsigned long arg)   // IN/OUT
+{
+   return (int) VmSyncUnlockedIoctl(file, cmd, arg);
+}
+#endif
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncOpen --
+ *
+ *    Instantiates a new state object and attached it to the file struct.
+ *
+ * Results:
+ *    0, or -ENOMEM if can't allocate memory.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VmSyncOpen(struct inode *inode,  // IN
+           struct file *f)       // IN
+{
+   if (capable(CAP_SYS_ADMIN)) {
+      f->private_data = kmem_cache_alloc(gSyncStateCache, GFP_KERNEL);
+      if (f->private_data == NULL) {
+         return -ENOMEM;
+      }
+   }
+   return 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncRelease --
+ *
+ *    If the fd was used to freeze devices, then thaw all frozen block devices.
+ *
+ * Results:
+ *    Returns 0.
+ *
+ * Side effects:
+ *    Calls VmSyncThawDevices.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VmSyncRelease(struct inode *inode,  // IN
+              struct file *file)    // IN
+{
+   if (capable(CAP_SYS_ADMIN)) {
+      VmSyncState *state = (VmSyncState *) file->private_data;
+      if (!cancel_delayed_work(&state->thawTask)) {
+         flush_scheduled_work();
+      }
+      VmSyncThawDevices(state);
+      kmem_cache_free(gSyncStateCache, state);
+   }
+   return 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncBlockDeviceCtor --
+ *
+ *    Constructor for VmSyncBlockDevice objects.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VmSyncBlockDeviceCtor(COMPAT_KMEM_CACHE_CTOR_ARGS(slabelem))  // IN
+{
+   VmSyncBlockDevice *dev = slabelem;
+
+   INIT_LIST_HEAD(&dev->list);
+   dev->bdev = NULL;
+   dev->sb = NULL;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VmSyncStateCtor --
+ *
+ *    Constructor for VmSyncState objects.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VmSyncStateCtor(COMPAT_KMEM_CACHE_CTOR_ARGS(slabelem))  // IN
+{
+   VmSyncState *state = slabelem;
+
+   INIT_LIST_HEAD(&state->devices);
+   COMPAT_INIT_DELAYED_WORK(&state->thawTask,
+                            VmSyncThawDevicesCallback, state);
+   compat_mutex_init(&state->lock);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * init_module --
+ *
+ *    Initializes the structures used by the driver, and creates the
+ *    proc file used by the driver to receive commands.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+int
+init_module(void)
+{
+   struct proc_dir_entry *controlProcEntry;
+
+   atomic_set(&gFreezeCount, 0);
+   compat_mutex_init(&gFreezeLock);
+
+   /* Create the slab allocators for the module. */
+   gBlockDeviceCache = compat_kmem_cache_create("VmSyncBlockDeviceCache",
+                                                sizeof (VmSyncBlockDevice),
+                                                0,
+                                                SLAB_HWCACHE_ALIGN,
+                                                VmSyncBlockDeviceCtor);
+   if (gBlockDeviceCache == NULL) {
+      printk(KERN_ERR "vmsync: no memory for block dev slab allocator\n");
+      return -ENOMEM;
+   }
+
+   gSyncStateCache = compat_kmem_cache_create("VmSyncStateCache",
+                                              sizeof (VmSyncState),
+                                              0,
+                                              SLAB_HWCACHE_ALIGN,
+                                              VmSyncStateCtor);
+   if (gSyncStateCache == NULL) {
+      printk(KERN_ERR "vmsync: no memory for sync state slab allocator\n");
+      kmem_cache_destroy(gBlockDeviceCache);
+      return -ENOMEM;
+   }
+
+   /* Create /proc/driver/vmware-sync */
+   controlProcEntry = create_proc_entry("driver/vmware-sync",
+                                        S_IFREG | S_IRUSR | S_IRGRP | S_IROTH,
+                                        NULL);
+   if (!controlProcEntry) {
+      printk(KERN_ERR "vmsync: could not create /proc/driver/vmware-sync\n");
+      kmem_cache_destroy(gSyncStateCache);
+      kmem_cache_destroy(gBlockDeviceCache);
+      return -EINVAL;
+   }
+
+   controlProcEntry->proc_fops = &VmSyncFileOps;
+   return 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * cleanup_module --
+ *
+ *    Unregisters the proc file used by the driver.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+void
+cleanup_module(void)
+{
+   remove_proc_entry("driver/vmware-sync", NULL);
+   kmem_cache_destroy(gSyncStateCache);
+   kmem_cache_destroy(gBlockDeviceCache);
+}
+

=== added directory '.pc/0006-linux-311-fix.patch'
=== added directory '.pc/0006-linux-311-fix.patch/modules'
=== added directory '.pc/0006-linux-311-fix.patch/modules/linux'
=== added directory '.pc/0006-linux-311-fix.patch/modules/linux/vmblock'
=== added directory '.pc/0006-linux-311-fix.patch/modules/linux/vmblock/linux'
=== added file '.pc/0006-linux-311-fix.patch/modules/linux/vmblock/linux/file.c'
--- .pc/0006-linux-311-fix.patch/modules/linux/vmblock/linux/file.c	1970-01-01 00:00:00 +0000
+++ .pc/0006-linux-311-fix.patch/modules/linux/vmblock/linux/file.c	2013-09-21 20:15:28 +0000
@@ -0,0 +1,244 @@
+/*********************************************************
+ * Copyright (C) 2006 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ *********************************************************/
+
+/*
+ * file.c --
+ *
+ *   File operations for the file system of the vmblock driver.
+ *
+ */
+
+#include "driver-config.h"
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/pagemap.h>
+
+#include "vmblockInt.h"
+#include "filesystem.h"
+
+#if defined(VMW_FILLDIR_2618)
+typedef u64 inode_num_t;
+#else
+typedef ino_t inode_num_t;
+#endif
+
+/* Specifically for our filldir_t callback */
+typedef struct FilldirInfo {
+   filldir_t filldir;
+   void *dirent;
+} FilldirInfo;
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Filldir --
+ *
+ *    Callback function for readdir that we use in place of the one provided.
+ *    This allows us to specify that each dentry is a symlink, but pass through
+ *    everything else to the original filldir function.
+ *
+ * Results:
+ *    Original filldir's return value.
+ *
+ * Side effects:
+ *    Directory information gets copied to user's buffer.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+Filldir(void *buf,              // IN: Dirent buffer passed from FileOpReaddir
+        const char *name,       // IN: Dirent name
+        int namelen,            // IN: len of dirent's name
+        loff_t offset,          // IN: Offset
+        inode_num_t ino,        // IN: Inode number of dirent
+        unsigned int d_type)    // IN: Type of file
+{
+   FilldirInfo *info = buf;
+
+   /* Specify DT_LNK regardless */
+   return info->filldir(info->dirent, name, namelen, offset, ino, DT_LNK);
+}
+
+
+/* File operations */
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * FileOpOpen --
+ *
+ *    Invoked when open(2) has been called on our root inode.  We get an open
+ *    file instance of the actual file that we are providing indirect access
+ *    to.
+ *
+ * Results:
+ *    0 on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+FileOpOpen(struct inode *inode,  // IN
+           struct file *file)    // IN
+{
+   VMBlockInodeInfo *iinfo;
+   struct file *actualFile;
+
+   if (!inode || !file || !INODE_TO_IINFO(inode)) {
+      Warning("FileOpOpen: invalid args from kernel\n");
+      return -EINVAL;
+   }
+
+   iinfo = INODE_TO_IINFO(inode);
+
+   /*
+    * Get an open file for the directory we are redirecting to.  This ensure we
+    * can gracefully handle cases where that directory is removed after we are
+    * mounted.
+    */
+   actualFile = filp_open(iinfo->name, file->f_flags, file->f_flags);
+   if (IS_ERR(actualFile)) {
+      Warning("FileOpOpen: could not open file [%s]\n", iinfo->name);
+      file->private_data = NULL;
+      return PTR_ERR(actualFile);
+   }
+
+   /*
+    * If the file opened is the same as the one retrieved for the file then we
+    * shouldn't allow the open to happen.  This can only occur if the
+    * redirected root directory specified at mount time is the same as where
+    * the mount is placed.  Later in FileOpReaddir() we'd call vfs_readdir()
+    * and that would try to acquire the inode's semaphore; if the two inodes
+    * are the same we'll deadlock.
+    */
+   if (actualFile->f_dentry && inode == actualFile->f_dentry->d_inode) {
+      Warning("FileOpOpen: identical inode encountered, open cannot succeed.\n");
+      if (filp_close(actualFile, current->files) < 0) {
+         Warning("FileOpOpen: unable to close opened file.\n");
+      }
+      return -EINVAL;
+   }
+
+   file->private_data = actualFile;
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * FileOpReaddir --
+ *
+ *    Invoked when a user invokes getdents(2) or readdir(2) on the root of our
+ *    file system.  We perform a readdir on the actual underlying file but
+ *    interpose the callback by providing our own Filldir() function.  This
+ *    enables us to change dentry types to symlinks.
+ *
+ * Results:
+ *    0 on success, negative error code on error.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+FileOpReaddir(struct file *file,  // IN
+              void *dirent,       // IN
+              filldir_t filldir)  // IN
+{
+   int ret;
+   FilldirInfo info;
+   struct file *actualFile;
+
+   if (!file) {
+      Warning("FileOpReaddir: invalid args from kernel\n");
+      return -EINVAL;
+   }
+
+   actualFile = file->private_data;
+   if (!actualFile) {
+      Warning("FileOpReaddir: no actual file found\n");
+      return -EINVAL;
+   }
+
+   info.filldir = filldir;
+   info.dirent = dirent;
+
+   actualFile->f_pos = file->f_pos;
+   ret = vfs_readdir(actualFile, Filldir, &info);
+   file->f_pos = actualFile->f_pos;
+
+   return ret;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * FileOpRelease --
+ *
+ *    Invoked when a user close(2)s the root of our file system.  Here we just
+ *    close the actual file we opened in FileOpOpen().
+ *
+ * Results:
+ *    0 on success, negative value on error.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static int
+FileOpRelease(struct inode *inode, // IN
+              struct file *file)   // IN
+{
+   int ret;
+   struct file *actualFile;
+
+   if (!inode || !file) {
+      Warning("FileOpRelease: invalid args from kerel\n");
+      return -EINVAL;
+   }
+
+   actualFile = file->private_data;
+   if (!actualFile) {
+      Warning("FileOpRelease: no actual file found\n");
+      return -EINVAL;
+   }
+
+   ret = filp_close(actualFile, current->files);
+
+   return ret;
+}
+
+
+struct file_operations RootFileOps = {
+   .readdir = FileOpReaddir,
+   .open    = FileOpOpen,
+   .release = FileOpRelease,
+};
+

=== added directory '.pc/0007-dkms-suppress-error.patch'
=== added directory '.pc/0007-dkms-suppress-error.patch/modules'
=== added directory '.pc/0007-dkms-suppress-error.patch/modules/linux'
=== added file '.pc/0007-dkms-suppress-error.patch/modules/linux/dkms.conf'
--- .pc/0007-dkms-suppress-error.patch/modules/linux/dkms.conf	1970-01-01 00:00:00 +0000
+++ .pc/0007-dkms-suppress-error.patch/modules/linux/dkms.conf	2013-09-21 20:15:28 +0000
@@ -0,0 +1,34 @@
+PACKAGE_NAME=open-vm-tools
+PACKAGE_VERSION=2013.04.16
+MAKE_CMD_TMPL="make VM_UNAME=\$kernelver \
+               MODULEBUILDDIR=$dkms_tree/$PACKAGE_NAME/$PACKAGE_VERSION/build"
+
+# The vsock module depends on symbols exported by the vmci module, so it
+# needs to be built afterwards; the MODULEBUILDDIR variable tells the makefiles
+# where to store / retrive those symbol files.
+MAKE[0]="$MAKE_CMD_TMPL -C vmblock;    \
+         $MAKE_CMD_TMPL -C vmci;       \
+         $MAKE_CMD_TMPL -C vmhgfs;     \
+         $MAKE_CMD_TMPL -C vmxnet;     \
+         $MAKE_CMD_TMPL -C vsock"
+CLEAN[0]="$MAKE_CMD_TMPL -C vmblock clean;    \
+          $MAKE_CMD_TMPL -C vmci clean;       \
+          $MAKE_CMD_TMPL -C vmhgfs clean;     \
+          $MAKE_CMD_TMPL -C vmxnet clean;     \
+          $MAKE_CMD_TMPL -C vsock clean"
+BUILT_MODULE_NAME[0]="vmblock"
+BUILT_MODULE_NAME[1]="vmci"
+BUILT_MODULE_NAME[2]="vmhgfs"
+BUILT_MODULE_NAME[3]="vmxnet"
+BUILT_MODULE_NAME[4]="vsock"
+BUILT_MODULE_LOCATION[0]="vmblock/"
+BUILT_MODULE_LOCATION[1]="vmci/"
+BUILT_MODULE_LOCATION[2]="vmhgfs/"
+BUILT_MODULE_LOCATION[3]="vmxnet/"
+BUILT_MODULE_LOCATION[4]="vsock/"
+DEST_MODULE_LOCATION[0]="/kernel/fs/vmblock"
+DEST_MODULE_LOCATION[1]="/kernel/drivers/misc"
+DEST_MODULE_LOCATION[2]="/kernel/fs/vmhgfs"
+DEST_MODULE_LOCATION[3]="/kernel/drivers/net"
+DEST_MODULE_LOCATION[4]="/kernel/net/vsock"
+AUTOINSTALL="YES"

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-05-29 12:57:21 +0000
+++ .pc/applied-patches	2013-09-21 20:15:28 +0000
@@ -2,3 +2,6 @@
 0002-dkms.patch
 0003-dkms-vmsync.patch
 0004-vsock-cve.patch
+0005-linux-310-fix.patch
+0006-linux-311-fix.patch
+0007-dkms-suppress-error.patch

=== modified file 'debian/changelog'
--- debian/changelog	2013-05-29 12:57:21 +0000
+++ debian/changelog	2013-09-21 20:15:28 +0000
@@ -1,3 +1,69 @@
+open-vm-tools (2013.04.16-1098359-0ubuntu2) saucy-proposed; urgency=low
+
+  * Ubuntu-specific Changes
+    - debian/rules: Removed Wno-error=unused-local-typedefs from CLFAGS.
+      + We now enforce building with GCC 4.7.
+
+    - debian/patches: Add 0005-linux-310-fix.patch & 0006-linux-311-fix.patch
+      + Fixes building against Saucy Kernels. (LP: #1194940, LP: #1208011)
+
+    - debian/patches: Add 0007-dkms-supress-error.patch
+      + Don't build modules that are broken, so modules that do build
+        are available to be loaded.
+      + Will be removed after next upstream release.
+
+  * Items merged from Debian experimental:
+    (From 2:9.2.2-893683-7 release)
+    - Removing purely cosmetical 'sleep 1' leftover in initscript.
+
+    (From 2:9.2.3-1031360-2 release)
+    - Renaming debian-specific open-vm-toolbox package to open-vm-tools-
+      desktop for consistency with upstream.
+    - Revamping package descriptions.
+    - Renaming open-vm-dkms to open-vm-tools-dkms for consistent package
+      namespace.
+
+    (From 2:9.2.3-1031360-3 release)
+    - Adding initial systemd service file from fedora.
+
+    (From 2:9.2.3-1031360-4 release)
+    - Dropping kfreebsd from architecture list, it has never built and
+      nobody seems willing to make it work (neither upstream, porters, nor
+      users).
+
+    (From 2:9.2.3-1031360-6 release)
+    - Correcting syntax of file entries in copyright.
+    - Adding section override for open-vm-tools-dkms.
+    - Enforcing build with gcc 4.7 for the time being.
+
+ -- Nate Muench <[e-mail]>  Sat, 07 Sep 2013 20:50:33 -0500
+
+open-vm-tools (2:9.2.3-1031360-6) unstable; urgency=low
+
+  * Correcting syntax of file entries in copyright.
+  * Adding section override for open-vm-tools-dkms.
+  * Enforcing build with gcc 4.7 for the time being.
+  * Orphaning package.
+
+ -- Daniel Baumann <[e-mail]>  Tue, 16 Jul 2013 10:18:50 +0200
+
+open-vm-tools (2:9.2.3-1031360-4) experimental; urgency=low
+
+  * Dropping kfreebsd from architecture list, it has never built and
+    nobody seems willing to make it work (neither upstream, porters, nor
+    users).
+
+ -- Daniel Baumann <[e-mail]>  Thu, 06 Jun 2013 13:10:41 +0200
+
+open-vm-tools (2:9.2.3-1031360-3) experimental; urgency=low
+
+  * Adding initial systemd service file from fedora.
+  * Skipping vmsync kernel module for the time being until it has been
+    fixed for the debian specific change introduced in linux 3.8.11-1 that
+    broke it (Closes: #707208).
+
+ -- Daniel Baumann <[e-mail]>  Fri, 31 May 2013 12:01:52 +0200
+
 open-vm-tools (2013.04.16-1098359-0ubuntu1) saucy-proposed; urgency=low
 
   * Merging upstream version 2013.04.16-1098359.
@@ -23,6 +89,39 @@
 
  -- Nate Muench <[e-mail]>  Wed, 29 May 2013 12:57:21 -0500
 
+open-vm-tools (2:9.2.3-1031360-2) experimental; urgency=low
+
+  * Renaming debian-specific open-vm-toolbox package to open-vm-tools-
+    desktop for consistency with upstream.
+  * Revamping package descriptions.
+  * Renaming open-vm-dkms to open-vm-tools-dkms for consistent package
+    namespace.
+
+ -- Daniel Baumann <[e-mail]>  Thu, 23 May 2013 19:13:26 +0200
+
+open-vm-tools (2:9.2.3-1031360-1) experimental; urgency=low
+
+  * Merging upstream version 9.2.3-1031360.
+  * Removing procps.patch, not needed anymore.
+  * Renumbering patches.
+
+ -- Daniel Baumann <[e-mail]>  Sun, 05 May 2013 09:58:58 +0200
+
+open-vm-tools (2:9.2.2-893683-8) experimental; urgency=low
+
+  * Adding patch from Mathias Krause <[e-mail]> to fix
+    kernel stack memory leack in vsock module [CVE-2013-3237] (Closes:
+    #706557).
+
+ -- Daniel Baumann <[e-mail]>  Wed, 01 May 2013 17:11:01 +0200
+
+open-vm-tools (2:9.2.2-893683-7) experimental; urgency=low
+
+  * Removing purely cosmetical 'sleep 1' leftover in initscript (Closes:
+    #686200).
+
+ -- Daniel Baumann <[e-mail]>  Sun, 31 Mar 2013 20:57:51 +0200
+
 open-vm-tools (2012.12.26-958366-0ubuntu3) raring-proposed; urgency=low
 
   * Ubuntu-specific Changes

=== modified file 'debian/control'
--- debian/control	2013-03-13 16:44:46 +0000
+++ debian/control	2013-09-21 20:15:28 +0000
@@ -2,86 +2,113 @@
 Section: admin
 Priority: extra
 Maintainer: Ubuntu Developers <[e-mail]>
-XSBC-Original-Maintainer: Daniel Baumann <[e-mail]>
+XSBC-Original-Maintainer: Debian QA Group <[e-mail]>
 Build-Depends:
  debhelper (>= 9), autotools-dev, doxygen, libcunit1-dev, libdumbnet-dev,
  libfuse-dev, libgtk2.0-dev, libgtkmm-2.4-dev, libicu-dev, libnotify-dev,
  libpam0g-dev, libprocps0-dev, libx11-dev, libxinerama-dev, libxss-dev,
- libxtst-dev
+ libxtst-dev, gcc-4.7
 Standards-Version: 3.9.4
 Homepage: http://open-vm-tools.sourceforge.net/
 
 Package: open-vm-tools
-Architecture: amd64 i386 kfreebsd-amd64 kfreebsd-i386
+Architecture: amd64 i386
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends}, ${shlibs:Depends}
-Recommends: open-vm-dkms, ethtool, zerofree
-Suggests: open-vm-toolbox
-Description: tools and components for VMware guest systems (CLI tools)
- The Open Virtual Machine Tools (open-vm-tools) are the open source
- implementation of VMware Tools. They are a set of guest operating system
- virtualization components that enhance performance and user experience of
- virtual machines.
+Recommends: open-vm-tools-dkms, ethtool, zerofree
+Suggests: open-vm-tools-desktop
+Description: Open VMware Tools for virtual machines hosted on VMware (CLI)
+ The Open Virtual Machine Tools (open-vm-tools) project is an open source
+ implementation of VMware Tools. It is a suite of virtualization utilities and
+ drivers to improve the functionality, user experience and administration of
+ VMware virtual machines.
  .
- As virtualization technology rapidly becomes mainstream, each virtualization
- solution provider implements their own set of tools and utilities to supplement
- the guest virtual machine. However, most of the implementations are proprietary
- and are tied to a specific virtualization platform.
+ This package contains only the core user-space programs and libraries.
 
-Package: open-vm-toolbox
-Architecture: amd64 i386 kfreebsd-amd64 kfreebsd-i386
+Package: open-vm-tools-desktop
+Architecture: amd64 i386
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends}, ${shlibs:Depends}, open-vm-tools (= ${binary:Version})
 Recommends:
- open-vm-dkms, xauth, xserver-xorg-input-vmmouse, xserver-xorg-video-vmware
+ open-vm-tools-dkms, xauth, xserver-xorg-input-vmmouse, xserver-xorg-video-vmware
 Suggests: xdg-utils
-Replaces: open-vm-source
-Breaks: open-vm-source
-Description: tools and components for VMware guest systems (GUI tools)
- The Open Virtual Machine Tools (open-vm-tools) are the open source
- implementation of VMware Tools. They are a set of guest operating system
- virtualization components that enhance performance and user experience of
- virtual machines.
+Conflicts: open-vm-toolbox (<< 2013.04.16-1098359-0ubuntu2~)
+Replaces: open-vm-toolbox
+Description: Open VMware Tools for virtual machines hosted on VMware (GUI)
+ The Open Virtual Machine Tools (open-vm-tools) project is an open source
+ implementation of VMware Tools. It is a suite of virtualization utilities and
+ drivers to improve the functionality, user experience and administration of
+ VMware virtual machines.
  .
- As virtualization technology rapidly becomes mainstream, each virtualization
- solution provider implements their own set of tools and utilities to supplement
- the guest virtual machine. However, most of the implementations are proprietary
- and are tied to a specific virtualization platform.
+ This package contains the user-space programs and libraries that are essential
+ for improved user experience of VMware virtual machines
 
 Package: open-vm-tools-dev
 Section: devel
 Architecture: all
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends}
-Description: tools and components for VMware guest systems (development)
- The Open Virtual Machine Tools (open-vm-tools) are the open source
- implementation of VMware Tools. They are a set of guest operating system
- virtualization components that enhance performance and user experience of
- virtual machines.
+Description: Open VMware Tools for virtual machines hosted on VMware (development)
+ The Open Virtual Machine Tools (open-vm-tools) project is an open source
+ implementation of VMware Tools. It is a suite of virtualization utilities and
+ drivers to improve the functionality, user experience and administration of
+ VMware virtual machines. 
  .
  This package contains the development files.
 
 Package: open-vm-tools-dbg
 Section: debug
 Priority: extra
-Architecture: amd64 i386 kfreebsd-amd64 kfreebsd-i386
+Architecture: amd64 i386
 Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends}, open-vm-tools (= ${binary:Version}), open-vm-toolbox (= ${binary:Version})
-Description: tools and components for VMware guest systems (debug)
- The Open Virtual Machine Tools (open-vm-tools) are the open source
- implementation of VMware Tools. They are a set of guest operating system
- virtualization components that enhance performance and user experience of
- virtual machines.
+Depends: ${misc:Depends}, open-vm-tools (= ${binary:Version}), open-vm-tools-desktop (= ${binary:Version})
+Description: Open VMware Tools for virtual machines hosted on VMware (debug)
+ The Open Virtual Machine Tools (open-vm-tools) project is an open source
+ implementation of VMware Tools. It is a suite of virtualization utilities and
+ drivers to improve the functionality, user experience and administration of
+ VMware virtual machines.
  .
  This package contains the debugging symbols.
 
-Package: open-vm-dkms
+Package: open-vm-tools-dkms
 Architecture: all
+Section: kernel
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends}, dkms, make
+Conflicts: open-vm-dkms (<< 2013.04.16-1098359-0ubuntu2~)
+Replaces: open-vm-dkms
 Recommends: open-vm-tools
-Suggests: open-vm-toolbox
-Description: Source for VMware guest systems driver (DKMS)
+Suggests: open-vm-tools-desktop
+Description: Open VMware Tools for virtual machines hosted on VMware (DKMS)
+ The Open Virtual Machine Tools (open-vm-tools) project is an open source
+ implementation of VMware Tools. It is a suite of virtualization utilities and
+ drivers to improve the functionality, user experience and administration of
+ VMware virtual machines.
+ .
  This package provides the source code for the open-vm kernel modules.
  The open-vm-tools package is also required in order to make use of these
  modules. Kernel source or headers are required to compile these modules.
+
+Package: open-vm-dkms
+Section: oldlibs
+Priority: extra
+Architecture: all
+Depends: ${misc:Depends}, open-vm-tools-dkms
+Description: Open VMware Tools for virtual machines hosted on VMware (transitional package)
+ Package to ease upgrading from older open-vm-dkms packages to the new
+ open-vm-tools-dkms package.
+ .
+ This package can be purged at anytime once the open-vm-tools-dkms package has
+ been installed.
+
+Package: open-vm-toolbox
+Section: oldlibs
+Priority: extra
+Architecture: all
+Depends: ${misc:Depends}, open-vm-tools-desktop
+Description: Open VMware Tools for virtual machines hosted on VMware (transitional package)
+ Package to ease upgrading from older open-vm-toolbox packages to the new
+ open-vm-tools-desktop package.
+ .
+ This package can be purged at anytime once the open-vm-tools-desktop package
+ has been installed.

=== modified file 'debian/copyright'
--- debian/copyright	2013-05-29 12:57:21 +0000
+++ debian/copyright	2013-09-21 20:15:28 +0000
@@ -7,11 +7,11 @@
 Copyright: VMware, Inc. <http://www.vmware.com/>
 License: LGPL-2.1
 
-Files: */Makefile*, modules/*
+Files: */Makefile* modules/*
 Copyright: VMware, Inc. <http://www.vmware.com/>
 License: GPL-2
 
-Files: lib/include/bsd*, lib/string/bsd*
+Files: lib/include/bsd* lib/string/bsd*
 Copyright: 1990, 1993 The Regents of the University of California.
 License: BSD-3
 

=== added file 'debian/local/open-vm-tools.service'
--- debian/local/open-vm-tools.service	1970-01-01 00:00:00 +0000
+++ debian/local/open-vm-tools.service	2013-09-21 20:15:28 +0000
@@ -0,0 +1,11 @@
+[Unit]
+Description=Service for virtual machines hosted on VMware
+Documentation=http://open-vm-tools.sourceforge.net/about.php
+ConditionVirtualization=vmware
+
+[Service]
+ExecStart=/usr/bin/vmtoolsd
+TimeoutStopSec=5
+
+[Install]
+WantedBy=multi-user.target

=== modified file 'debian/manpages/libguestlib.3'
--- debian/manpages/libguestlib.3	2013-03-13 16:44:46 +0000
+++ debian/manpages/libguestlib.3	2013-09-21 20:15:28 +0000
@@ -23,12 +23,8 @@
 .br
 \fIvmware\-user\-suid\-wrapper\fR(8)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/libvmtools.3'
--- debian/manpages/libvmtools.3	2013-03-13 16:44:46 +0000
+++ debian/manpages/libvmtools.3	2013-09-21 20:15:28 +0000
@@ -23,12 +23,8 @@
 .br
 \fIvmware\-user\-suid\-wrapper\fR(8)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmblock.9'
--- debian/manpages/vmblock.9	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmblock.9	2013-09-21 20:15:28 +0000
@@ -37,12 +37,8 @@
 .br
 \fIvmware\-user\-suid\-wrapper\fR(8)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmhgfs.9'
--- debian/manpages/vmhgfs.9	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmhgfs.9	2013-09-21 20:15:28 +0000
@@ -45,10 +45,6 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-checkvm.1'
--- debian/manpages/vmware-checkvm.1	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmware-checkvm.1	2013-09-21 20:15:28 +0000
@@ -31,12 +31,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-hgfsclient.1'
--- debian/manpages/vmware-hgfsclient.1	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmware-hgfsclient.1	2013-09-21 20:15:28 +0000
@@ -31,12 +31,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-hgfsmounter.8'
--- debian/manpages/vmware-hgfsmounter.8	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmware-hgfsmounter.8	2013-09-21 20:15:28 +0000
@@ -83,12 +83,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-toolbox-cmd.1'
--- debian/manpages/vmware-toolbox-cmd.1	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmware-toolbox-cmd.1	2013-09-21 20:15:28 +0000
@@ -33,12 +33,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-user-suid-wrapper.8'
--- debian/manpages/vmware-user-suid-wrapper.8	2013-03-13 21:46:00 +0000
+++ debian/manpages/vmware-user-suid-wrapper.8	2013-09-21 20:15:28 +0000
@@ -33,12 +33,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmware-xferlogs.1'
--- debian/manpages/vmware-xferlogs.1	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmware-xferlogs.1	2013-09-21 20:15:28 +0000
@@ -43,12 +43,8 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
 .br
-\fIvmsock\fR(9)
-.br
 \fIvmxnet\fR(9)
 
 .SH HOMEPAGE

=== modified file 'debian/manpages/vmxnet.9'
--- debian/manpages/vmxnet.9	2013-03-13 16:44:46 +0000
+++ debian/manpages/vmxnet.9	2013-09-21 20:15:28 +0000
@@ -40,11 +40,7 @@
 .br
 \fIvmblock\fR(9)
 .br
-\fIvmci\fR(9)
-.br
 \fIvmhgfs\fR(9)
-.br
-\fIvmsock\fR(9)
 
 .SH HOMEPAGE
 More information about vmxnet and the Open VM Tools can be found at <\fIhttp://open\-vm\-tools.sourceforge.net/\fR>.

=== removed file 'debian/open-vm-dkms.dkms'
--- debian/open-vm-dkms.dkms	2013-05-29 12:57:21 +0000
+++ debian/open-vm-dkms.dkms	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-PACKAGE_NAME="open-vm-tools"
-PACKAGE_VERSION="#MODULE_VERSION#"
-
-BUILT_MODULE_NAME[2]="vmhgfs"
-DEST_MODULE_LOCATION[2]="/updates/dkms/"
-AUTOINSTALL=yes
-
-BUILT_MODULE_NAME[3]="vmxnet"
-DEST_MODULE_LOCATION[3]="/updates/dkms/"
-AUTOINSTALL=yes

=== removed file 'debian/open-vm-dkms.postinst'
--- debian/open-vm-dkms.postinst	2010-05-29 17:35:25 +0000
+++ debian/open-vm-dkms.postinst	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-#!/bin/sh
-
-set -e
-
-NAME="open-vm-tools"
-PACKAGE_NAME="open-vm-dkms"
-CVERSION="$(dpkg-query -W -f='${Version}' ${PACKAGE_NAME} | awk -F "-" '{ print $1 }' | cut -d\: -f2)"
-ARCH=$(dpkg --print-architecture)
-
-case "${1}" in
-	configure)
-		for POSTINST in /usr/lib/dkms/common.postinst /usr/share/${PACKAGE_NAME}/postinst
-		do
-			if [ -f ${POSTINST} ]
-			then
-				${POSTINST} ${NAME} ${CVERSION} /usr/share/${PACKAGE_NAME} ${ARCH} ${2}
-				exit ${?}
-			fi
-
-			echo "WARNING: ${POSTINST} does not exist."
-		done
-
-		echo "ERROR: DKMS version is too old and ${PACKAGE_NAME} was not"
-		echo "built with legacy DKMS support."
-		echo "You must either rebuild ${PACKAGE_NAME} with legacy postinst"
-		echo "support or upgrade DKMS to a more current version."
-		exit 1
-		;;
-
-	abort-upgrade|abort-remove|abort-deconfigure)
-
-		;;
-
-	*)
-		echo "postinst called with unknown argument \`${1}'" >&2
-		exit 1
-	;;
-esac
-
-#DEBHELPER#
-
-exit 0

=== removed file 'debian/open-vm-dkms.prerm'
--- debian/open-vm-dkms.prerm	2010-05-29 17:35:25 +0000
+++ debian/open-vm-dkms.prerm	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-#!/bin/sh
-
-NAME="open-vm-tools"
-PACKAGE_NAME="open-vm-dkms"
-CVERSION="$(dpkg-query -W -f='${Version}' ${PACKAGE_NAME} | awk -F "-" '{ print $1 }' | cut -d\: -f2)"
-
-set -e
-
-case "${1}" in
-	remove|upgrade|deconfigure)
-		if [  "$(dkms status -m ${NAME})" ]
-		then
-			dkms remove -m ${NAME} -v ${CVERSION} --all
-		fi
-		;;
-
-	failed-upgrade)
-
-		;;
-
-	*)
-		echo "prerm called with unknown argument \`${1}'" >&2
-		exit 1
-		;;
-esac
-
-#DEBHELPER#
-
-exit 0

=== removed file 'debian/open-vm-toolbox.lintian-overrides'
--- debian/open-vm-toolbox.lintian-overrides	2012-01-23 16:09:45 +0000
+++ debian/open-vm-toolbox.lintian-overrides	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-open-vm-toolbox: desktop-command-not-in-package /usr/share/applications/vmware-user.desktop vmware-user-suid-wrapper
-open-vm-toolbox: setuid-binary usr/sbin/vmware-user-suid-wrapper 4755 root/root

=== removed file 'debian/open-vm-toolbox.manpages'
--- debian/open-vm-toolbox.manpages	2011-08-28 16:10:21 +0000
+++ debian/open-vm-toolbox.manpages	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-debian/manpages/vmware-user-suid-wrapper.8

=== added file 'debian/open-vm-tools-desktop.lintian-overrides'
--- debian/open-vm-tools-desktop.lintian-overrides	1970-01-01 00:00:00 +0000
+++ debian/open-vm-tools-desktop.lintian-overrides	2013-09-21 20:15:28 +0000
@@ -0,0 +1,2 @@
+open-vm-toolbox: desktop-command-not-in-package /usr/share/applications/vmware-user.desktop vmware-user-suid-wrapper
+open-vm-toolbox: setuid-binary usr/sbin/vmware-user-suid-wrapper 4755 root/root

=== added file 'debian/open-vm-tools-desktop.manpages'
--- debian/open-vm-tools-desktop.manpages	1970-01-01 00:00:00 +0000
+++ debian/open-vm-tools-desktop.manpages	2013-09-21 20:15:28 +0000
@@ -0,0 +1,1 @@
+debian/manpages/vmware-user-suid-wrapper.8

=== added file 'debian/open-vm-tools-dkms.dkms'
--- debian/open-vm-tools-dkms.dkms	1970-01-01 00:00:00 +0000
+++ debian/open-vm-tools-dkms.dkms	2013-09-21 20:15:28 +0000
@@ -0,0 +1,6 @@
+PACKAGE_NAME="open-vm-tools"
+PACKAGE_VERSION="#MODULE_VERSION#"
+
+BUILT_MODULE_NAME[1]="vmxnet"
+DEST_MODULE_LOCATION[1]="/updates/dkms/"
+AUTOINSTALL=yes

=== added file 'debian/open-vm-tools-dkms.postinst'
--- debian/open-vm-tools-dkms.postinst	1970-01-01 00:00:00 +0000
+++ debian/open-vm-tools-dkms.postinst	2013-09-21 20:15:28 +0000
@@ -0,0 +1,42 @@
+#!/bin/sh
+
+set -e
+
+NAME="open-vm-tools"
+PACKAGE_NAME="open-vm-tools-dkms"
+CVERSION="$(dpkg-query -W -f='${Version}' ${PACKAGE_NAME} | awk -F "-" '{ print $1 }' | cut -d\: -f2)"
+ARCH=$(dpkg --print-architecture)
+
+case "${1}" in
+	configure)
+		for POSTINST in /usr/lib/dkms/common.postinst /usr/share/${PACKAGE_NAME}/postinst
+		do
+			if [ -f ${POSTINST} ]
+			then
+				${POSTINST} ${NAME} ${CVERSION} /usr/share/${PACKAGE_NAME} ${ARCH} ${2}
+				exit ${?}
+			fi
+
+			echo "WARNING: ${POSTINST} does not exist."
+		done
+
+		echo "ERROR: DKMS version is too old and ${PACKAGE_NAME} was not"
+		echo "built with legacy DKMS support."
+		echo "You must either rebuild ${PACKAGE_NAME} with legacy postinst"
+		echo "support or upgrade DKMS to a more current version."
+		exit 1
+		;;
+
+	abort-upgrade|abort-remove|abort-deconfigure)
+
+		;;
+
+	*)
+		echo "postinst called with unknown argument \`${1}'" >&2
+		exit 1
+	;;
+esac
+
+#DEBHELPER#
+
+exit 0

=== added file 'debian/open-vm-tools-dkms.prerm'
--- debian/open-vm-tools-dkms.prerm	1970-01-01 00:00:00 +0000
+++ debian/open-vm-tools-dkms.prerm	2013-09-21 20:15:28 +0000
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+NAME="open-vm-tools"
+PACKAGE_NAME="open-vm-tools-dkms"
+CVERSION="$(dpkg-query -W -f='${Version}' ${PACKAGE_NAME} | awk -F "-" '{ print $1 }' | cut -d\: -f2)"
+
+set -e
+
+case "${1}" in
+	remove|upgrade|deconfigure)
+		if [  "$(dkms status -m ${NAME})" ]
+		then
+			dkms remove -m ${NAME} -v ${CVERSION} --all
+		fi
+		;;
+
+	failed-upgrade)
+
+		;;
+
+	*)
+		echo "prerm called with unknown argument \`${1}'" >&2
+		exit 1
+		;;
+esac
+
+#DEBHELPER#
+
+exit 0

=== modified file 'debian/open-vm-tools.init'
--- debian/open-vm-tools.init	2013-05-29 12:57:21 +0000
+++ debian/open-vm-tools.init	2013-09-21 20:15:28 +0000
@@ -62,14 +62,13 @@
 		log_end_msg 0
 
 		log_daemon_msg "Removing open-vm-tools modules"
-		log_progress_msg "vmhgfs"; modprobe -r vmhgfs
+#		log_progress_msg "vmhgfs"; modprobe -r vmhgfs
 		log_progress_msg "vmxnet"; modprobe -r vmxnet
 		log_end_msg 0
 		;;
 
 	force-reload|restart)
 		${0} stop
-		sleep 1
 		${0} start
 		;;
 

=== added file 'debian/patches/0005-linux-310-fix.patch'
--- debian/patches/0005-linux-310-fix.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0005-linux-310-fix.patch	2013-09-21 20:15:28 +0000
@@ -0,0 +1,225 @@
+Author: Nate Muench <[e-mail]>
+Description: Fixes building against 3.10 Kernel
+
+Index: open-vm-tools.april-update.part2/modules/linux/shared/compat_fs.h
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/shared/compat_fs.h	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/shared/compat_fs.h	2013-09-06 16:04:05.104047078 -0500
+@@ -129,18 +129,6 @@
+ })
+ #endif
+ 
+-
+-/*
+- * putname changed to __putname in 2.6.6.
+- */
+-#define compat___getname() __getname()
+-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 6)
+-#define compat___putname(name) putname(name)
+-#else
+-#define compat___putname(name) __putname(name)
+-#endif
+-
+-
+ /*
+  * inc_nlink, drop_nlink, and clear_nlink were added in 2.6.19.
+  */
+Index: open-vm-tools.april-update.part2/modules/linux/vmblock/linux/control.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmblock/linux/control.c	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmblock/linux/control.c	2013-09-06 16:04:05.104047078 -0500
+@@ -208,9 +208,10 @@
+    VMBlockSetProcEntryOwner(controlProcMountpoint);
+ 
+    /* Create /proc/fs/vmblock/dev */
+-   controlProcEntry = create_proc_entry(VMBLOCK_CONTROL_DEVNAME,
+-                                        VMBLOCK_CONTROL_MODE,
+-                                        controlProcDirEntry);
++   controlProcEntry = proc_create(VMBLOCK_CONTROL_DEVNAME,
++                                  VMBLOCK_CONTROL_MODE,
++                                  controlProcDirEntry,
++                                  &ControlFileOps);
+    if (!controlProcEntry) {
+       Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");
+       remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);
+@@ -218,7 +219,6 @@
+       return -EINVAL;
+    }
+ 
+-   controlProcEntry->proc_fops = &ControlFileOps;
+    return 0;
+ }
+ 
+@@ -278,7 +278,7 @@
+                int (*blockOp)(const char *filename,   // IN: block operation
+                               const os_blocker_id_t blocker))
+ {
+-   char *name;
++   struct filename *name;
+    int i;
+    int retval;
+ 
+@@ -287,13 +287,13 @@
+       return PTR_ERR(name);
+    }
+ 
+-   for (i = strlen(name) - 1; i >= 0 && name[i] == '/'; i--) {
+-      name[i] = '\0';
++   for (i = strlen(name->name) - 1; i >= 0 && name->name[i] == '/'; i--) {
++      ((char *)name->name)[i] = '\0';
+    }
+ 
+-   retval = i < 0 ? -EINVAL : blockOp(name, blocker);
++   retval = i < 0 ? -EINVAL : blockOp(name->name, blocker);
+ 
+-   putname(name);
++   __putname(name);
+ 
+    return retval;
+ }
+Index: open-vm-tools.april-update.part2/modules/linux/vmblock/linux/dentry.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmblock/linux/dentry.c	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmblock/linux/dentry.c	2013-09-06 16:04:05.104047078 -0500
+@@ -31,8 +31,7 @@
+ #include "filesystem.h"
+ #include "block.h"
+ 
+-
+-static int DentryOpRevalidate(struct dentry *dentry, struct nameidata *nd);
++static int DentryOpRevalidate(struct dentry *dentry, unsigned int flags);
+ 
+ struct dentry_operations LinkDentryOps = {
+    .d_revalidate = DentryOpRevalidate,
+@@ -60,7 +59,7 @@
+ 
+ static int
+ DentryOpRevalidate(struct dentry *dentry,  // IN: dentry revalidating
+-                   struct nameidata *nd)   // IN: lookup flags & intent
++                   unsigned int flags)     // IN: lookup flags
+ {
+    VMBlockInodeInfo *iinfo;
+    struct nameidata actualNd;
+@@ -101,7 +100,7 @@
+    if (actualDentry &&
+        actualDentry->d_op &&
+        actualDentry->d_op->d_revalidate) {
+-      return actualDentry->d_op->d_revalidate(actualDentry, nd);
++      return actualDentry->d_op->d_revalidate(actualDentry, flags);
+    }
+ 
+    if (compat_path_lookup(iinfo->name, 0, &actualNd)) {
+Index: open-vm-tools.april-update.part2/modules/linux/vmblock/linux/inode.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmblock/linux/inode.c	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmblock/linux/inode.c	2013-09-06 16:04:05.104047078 -0500
+@@ -36,7 +36,7 @@
+ 
+ /* Inode operations */
+ static struct dentry *InodeOpLookup(struct inode *dir,
+-                                    struct dentry *dentry, struct nameidata *nd);
++                                    struct dentry *dentry, unsigned int flags);
+ static int InodeOpReadlink(struct dentry *dentry, char __user *buffer, int buflen);
+ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
+ static void *InodeOpFollowlink(struct dentry *dentry, struct nameidata *nd);
+@@ -75,7 +75,7 @@
+ static struct dentry *
+ InodeOpLookup(struct inode *dir,      // IN: parent directory's inode
+               struct dentry *dentry,  // IN: dentry to lookup
+-              struct nameidata *nd)   // IN: lookup intent and information
++              unsigned int flags)     // IN: lookup flags
+ {
+    char *filename;
+    struct inode *inode;
+Index: open-vm-tools.april-update.part2/modules/linux/vmhgfs/file.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmhgfs/file.c	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmhgfs/file.c	2013-09-06 16:04:05.104047078 -0500
+@@ -25,6 +25,7 @@
+ /* Must come before any kernel header file. */
+ #include "driver-config.h"
+ 
++#include <linux/aio.h>
+ #include <linux/errno.h>
+ #include <linux/module.h>
+ #include <linux/signal.h>
+Index: open-vm-tools.april-update.part2/modules/linux/vmsync/sync.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmsync/sync.c	2013-09-06 16:04:05.108047078 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmsync/sync.c	2013-09-06 16:04:05.104047078 -0500
+@@ -162,7 +162,7 @@
+    cancel_delayed_work(&state->thawTask);
+    list_for_each_safe(cur, tmp, &state->devices) {
+       dev = list_entry(cur, VmSyncBlockDevice, list);
+-      if (dev->sb != NULL && dev->sb->s_frozen != SB_UNFROZEN) {
++      if (dev->sb != NULL && dev->sb->s_writers.frozen != SB_UNFROZEN) {
+          thaw_bdev(dev->bdev, dev->sb);
+          atomic_dec(&gFreezeCount);
+       }
+@@ -237,7 +237,7 @@
+     * the superblock is already frozen.
+     */
+    if (inode->i_sb->s_bdev == NULL ||
+-       inode->i_sb->s_frozen != SB_UNFROZEN) {
++       inode->i_sb->s_writers.frozen != SB_UNFROZEN) {
+       result = (inode->i_sb->s_bdev == NULL) ? -EINVAL : -EALREADY;
+       compat_path_release(&nd);
+       goto exit;
+@@ -303,7 +303,7 @@
+                     const char __user *userPaths)  // IN
+ {
+    int result = 0;
+-   char *paths;
++   struct filename *paths;
+    char *currPath;
+    char *nextSep;
+    struct list_head *cur, *tmp;
+@@ -328,7 +328,8 @@
+    /*
+     * First, try to add all paths to the list of paths to be frozen.
+     */
+-   currPath = paths;
++   currPath = __getname();
++   strcpy(currPath, paths->name);
+    do {
+       nextSep = strchr(currPath, ':');
+       if (nextSep != NULL) {
+@@ -347,6 +348,7 @@
+       }
+       currPath = nextSep + 1;
+    } while (nextSep != NULL);
++   __putname(currPath);
+ 
+    /*
+     * If adding all the requested paths worked, then freeze them.
+@@ -371,6 +373,8 @@
+    compat_mutex_unlock(&state->lock);
+    compat_mutex_unlock(&gFreezeLock);
+ 
++   __putname(paths);
++
+    if (result == 0) {
+       compat_schedule_delayed_work(&state->thawTask, VMSYNC_THAW_TASK_DELAY);
+    }
+@@ -670,9 +674,10 @@
+    }
+ 
+    /* Create /proc/driver/vmware-sync */
+-   controlProcEntry = create_proc_entry("driver/vmware-sync",
+-                                        S_IFREG | S_IRUSR | S_IRGRP | S_IROTH,
+-                                        NULL);
++   controlProcEntry = proc_create("driver/vmware-sync",
++                                  S_IFREG | S_IRUSR | S_IRGRP | S_IROTH,
++                                  NULL,
++                                  &VmSyncFileOps);
+    if (!controlProcEntry) {
+       printk(KERN_ERR "vmsync: could not create /proc/driver/vmware-sync\n");
+       kmem_cache_destroy(gSyncStateCache);
+@@ -680,7 +685,6 @@
+       return -EINVAL;
+    }
+ 
+-   controlProcEntry->proc_fops = &VmSyncFileOps;
+    return 0;
+ }
+ 

=== added file 'debian/patches/0006-linux-311-fix.patch'
--- debian/patches/0006-linux-311-fix.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0006-linux-311-fix.patch	2013-09-21 20:15:28 +0000
@@ -0,0 +1,94 @@
+Author: Nate Muench <[e-mail]>
+Description: Fixes building of vmblock module against 3.11 Kernel
+
+Index: open-vm-tools.april-update.part2/modules/linux/vmblock/linux/file.c
+===================================================================
+--- open-vm-tools.april-update.part2.orig/modules/linux/vmblock/linux/file.c	2013-09-06 16:04:22.336046467 -0500
++++ open-vm-tools.april-update.part2/modules/linux/vmblock/linux/file.c	2013-09-06 16:04:22.332046467 -0500
+@@ -38,46 +38,6 @@
+ typedef ino_t inode_num_t;
+ #endif
+ 
+-/* Specifically for our filldir_t callback */
+-typedef struct FilldirInfo {
+-   filldir_t filldir;
+-   void *dirent;
+-} FilldirInfo;
+-
+-
+-/*
+- *----------------------------------------------------------------------------
+- *
+- * Filldir --
+- *
+- *    Callback function for readdir that we use in place of the one provided.
+- *    This allows us to specify that each dentry is a symlink, but pass through
+- *    everything else to the original filldir function.
+- *
+- * Results:
+- *    Original filldir's return value.
+- *
+- * Side effects:
+- *    Directory information gets copied to user's buffer.
+- *
+- *----------------------------------------------------------------------------
+- */
+-
+-static int
+-Filldir(void *buf,              // IN: Dirent buffer passed from FileOpReaddir
+-        const char *name,       // IN: Dirent name
+-        int namelen,            // IN: len of dirent's name
+-        loff_t offset,          // IN: Offset
+-        inode_num_t ino,        // IN: Inode number of dirent
+-        unsigned int d_type)    // IN: Type of file
+-{
+-   FilldirInfo *info = buf;
+-
+-   /* Specify DT_LNK regardless */
+-   return info->filldir(info->dirent, name, namelen, offset, ino, DT_LNK);
+-}
+-
+-
+ /* File operations */
+ 
+ /*
+@@ -166,11 +126,10 @@
+ 
+ static int
+ FileOpReaddir(struct file *file,  // IN
+-              void *dirent,       // IN
+-              filldir_t filldir)  // IN
++              struct dir_context *ctx)  // IN
+ {
+    int ret;
+-   FilldirInfo info;
++
+    struct file *actualFile;
+ 
+    if (!file) {
+@@ -184,12 +143,10 @@
+       return -EINVAL;
+    }
+ 
+-   info.filldir = filldir;
+-   info.dirent = dirent;
+-
+-   actualFile->f_pos = file->f_pos;
+-   ret = vfs_readdir(actualFile, Filldir, &info);
+-   file->f_pos = actualFile->f_pos;
++   /* Ricky Wong Yung Fei:
++    * Manipulation of pos is now handled internally by iterate_dir().
++    */
++   ret = iterate_dir(actualFile, ctx);
+ 
+    return ret;
+ }
+@@ -237,7 +194,7 @@
+ 
+ 
+ struct file_operations RootFileOps = {
+-   .readdir = FileOpReaddir,
++   .iterate = FileOpReaddir,
+    .open    = FileOpOpen,
+    .release = FileOpRelease,
+ };

=== added file 'debian/patches/0007-dkms-suppress-error.patch'
--- debian/patches/0007-dkms-suppress-error.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0007-dkms-suppress-error.patch	2013-09-21 20:15:28 +0000
@@ -0,0 +1,41 @@
+Author: Nate Muench <[e-mail]>
+Description: Builds only the modules that actually work.
+
+Index: open-vm-tools-2013.04.16-1098359/modules/linux/dkms.conf
+===================================================================
+--- open-vm-tools-2013.04.16-1098359.orig/modules/linux/dkms.conf	2013-09-07 20:50:04.000000000 -0500
++++ open-vm-tools-2013.04.16-1098359/modules/linux/dkms.conf	2013-09-07 20:53:21.168995183 -0500
+@@ -7,28 +7,13 @@
+ # needs to be built afterwards; the MODULEBUILDDIR variable tells the makefiles
+ # where to store / retrive those symbol files.
+ MAKE[0]="$MAKE_CMD_TMPL -C vmblock;    \
+-         $MAKE_CMD_TMPL -C vmci;       \
+-         $MAKE_CMD_TMPL -C vmhgfs;     \
+-         $MAKE_CMD_TMPL -C vmxnet;     \
+-         $MAKE_CMD_TMPL -C vsock"
++         $MAKE_CMD_TMPL -C vmxnet"
+ CLEAN[0]="$MAKE_CMD_TMPL -C vmblock clean;    \
+-          $MAKE_CMD_TMPL -C vmci clean;       \
+-          $MAKE_CMD_TMPL -C vmhgfs clean;     \
+-          $MAKE_CMD_TMPL -C vmxnet clean;     \
+-          $MAKE_CMD_TMPL -C vsock clean"
++          $MAKE_CMD_TMPL -C vmxnet clean"
+ BUILT_MODULE_NAME[0]="vmblock"
+-BUILT_MODULE_NAME[1]="vmci"
+-BUILT_MODULE_NAME[2]="vmhgfs"
+-BUILT_MODULE_NAME[3]="vmxnet"
+-BUILT_MODULE_NAME[4]="vsock"
++BUILT_MODULE_NAME[1]="vmxnet"
+ BUILT_MODULE_LOCATION[0]="vmblock/"
+-BUILT_MODULE_LOCATION[1]="vmci/"
+-BUILT_MODULE_LOCATION[2]="vmhgfs/"
+-BUILT_MODULE_LOCATION[3]="vmxnet/"
+-BUILT_MODULE_LOCATION[4]="vsock/"
++BUILT_MODULE_LOCATION[1]="vmxnet/"
+ DEST_MODULE_LOCATION[0]="/kernel/fs/vmblock"
+-DEST_MODULE_LOCATION[1]="/kernel/drivers/misc"
+-DEST_MODULE_LOCATION[2]="/kernel/fs/vmhgfs"
+-DEST_MODULE_LOCATION[3]="/kernel/drivers/net"
+-DEST_MODULE_LOCATION[4]="/kernel/net/vsock"
++DEST_MODULE_LOCATION[1]="/kernel/drivers/net"
+ AUTOINSTALL="YES"

=== modified file 'debian/patches/series'
--- debian/patches/series	2013-05-29 12:57:21 +0000
+++ debian/patches/series	2013-09-21 20:15:28 +0000
@@ -2,3 +2,6 @@
 0002-dkms.patch
 0003-dkms-vmsync.patch
 0004-vsock-cve.patch
+0005-linux-310-fix.patch
+0006-linux-311-fix.patch
+0007-dkms-suppress-error.patch

=== modified file 'debian/rules'
--- debian/rules	2013-05-29 12:57:21 +0000
+++ debian/rules	2013-09-21 20:15:28 +0000
@@ -1,19 +1,19 @@
 #!/usr/bin/make -f
 
 export CFLAGS += -Wno-deprecated-declarations
-export CFLAGS += -Wno-error=unused-local-typedefs
+#export CFLAGS += -Wno-error=unused-local-typedefs
 export LIBS += -lpthread
 
 %:
 	dh ${@} --with autotools_dev
 
 override_dh_auto_configure:
-	dh_auto_configure -- --prefix=/usr --libdir=\$${prefix}/lib --without-kernel-modules
+	dh_auto_configure -- --prefix=/usr --libdir=\$${prefix}/lib --without-kernel-modules CC=/usr/bin/gcc-4.7
 
 override_dh_auto_install:
 	dh_auto_install -- DESTDIR=$(CURDIR)/debian/open-vm-tools
 
-	install -D -m 0755 vmware-user-suid-wrapper/vmware-user-suid-wrapper debian/open-vm-toolbox/usr/sbin/vmware-user-suid-wrapper
+	install -D -m 0755 vmware-user-suid-wrapper/vmware-user-suid-wrapper debian/open-vm-tools-desktop/usr/sbin/vmware-user-suid-wrapper
 
 	if [ -e debian/open-vm-tools/etc/pam.d/vmtoolsd-x64 ]; \
 	then \
@@ -24,18 +24,19 @@
 	chmod 0644 debian/open-vm-tools/etc/pam.d/vmtoolsd
 
 	install -D -m 0755 debian/local/vmxnet.hook debian/open-vm-tools/usr/share/initramfs-tools/hooks/vmxnet
-	install -D -m 0644 debian/local/xautostart.conf debian/open-vm-toolbox/etc/vmware-tools/xautostart.conf
+	install -D -m 0644 debian/local/xautostart.conf debian/open-vm-tools-desktop/etc/vmware-tools/xautostart.conf
 	install -D -m 0644 debian/local/tools.conf debian/open-vm-tools/etc/vmware-tools/tools.conf
+	install -D -m 0755 debian/local/open-vm-tools.service debian/open-vm-tools/lib/systemd/system/open-vm-tools.service
 
 	# open-vm-tools-dev
 	mkdir -p debian/open-vm-tools-dev/usr/share/doc/open-vm-tools
 	mv debian/open-vm-tools/usr/share/doc/open-vm-tools/api debian/open-vm-tools-dev/usr/share/doc/open-vm-tools
 
-	# open-vm-dkms
-	mkdir -p debian/open-vm-dkms/usr/src
-	sh modules/linux/dkms.sh . debian/open-vm-dkms/usr/src
-	find debian/open-vm-dkms/usr/src -name COPYING | xargs rm -f
-	find debian/open-vm-dkms/usr/src -name "Makefile*" | xargs chmod 0755
+	# open-vm-tools-dkms
+	mkdir -p debian/open-vm-tools-dkms/usr/src
+	sh modules/linux/dkms.sh . debian/open-vm-tools-dkms/usr/src
+	find debian/open-vm-tools-dkms/usr/src -name COPYING | xargs rm -f
+	find debian/open-vm-tools-dkms/usr/src -name "Makefile*" | xargs chmod 0755
 
 	# removing useless files
 	rm -f debian/open-vm-tools/usr/lib/*.la
@@ -46,16 +47,16 @@
 	mkdir -p debian/open-vm-tools/sbin
 	mv debian/open-vm-tools/usr/sbin/mount.vmhgfs debian/open-vm-tools/sbin/mount.vmhgfs
 
-	# moving open-vm-toolbox files
-	mkdir -p debian/open-vm-toolbox/etc
-	mv debian/open-vm-tools/etc/xdg debian/open-vm-toolbox/etc/
-
-	mkdir -p debian/open-vm-toolbox/usr/lib/open-vm-tools/plugins
-	mv debian/open-vm-tools/usr/lib/open-vm-tools/plugins/vmusr debian/open-vm-toolbox/usr/lib/open-vm-tools/plugins
-
-	mkdir -p debian/open-vm-toolbox/usr/bin
-	install -m 755 scripts/common/vmware-xdg-detect-de debian/open-vm-toolbox/usr/bin
-	install -D -m 4755 vmware-user-suid-wrapper/vmware-user-suid-wrapper debian/open-vm-toolbox/usr/sbin/vmware-user-suid-wrapper
+	# moving open-vm-tools-desktop files
+	mkdir -p debian/open-vm-tools-desktop/etc
+	mv debian/open-vm-tools/etc/xdg debian/open-vm-tools-desktop/etc/
+
+	mkdir -p debian/open-vm-tools-desktop/usr/lib/open-vm-tools/plugins
+	mv debian/open-vm-tools/usr/lib/open-vm-tools/plugins/vmusr debian/open-vm-tools-desktop/usr/lib/open-vm-tools/plugins
+
+	mkdir -p debian/open-vm-tools-desktop/usr/bin
+	install -m 755 scripts/common/vmware-xdg-detect-de debian/open-vm-tools-desktop/usr/bin
+	install -D -m 4755 vmware-user-suid-wrapper/vmware-user-suid-wrapper debian/open-vm-tools-desktop/usr/sbin/vmware-user-suid-wrapper
 
 override_dh_builddeb:
 	dh_builddeb -- -Zxz

=== modified file 'modules/linux/dkms.conf'
--- modules/linux/dkms.conf	2013-05-29 12:57:21 +0000
+++ modules/linux/dkms.conf	2013-09-21 20:15:28 +0000
@@ -7,28 +7,13 @@
 # needs to be built afterwards; the MODULEBUILDDIR variable tells the makefiles
 # where to store / retrive those symbol files.
 MAKE[0]="$MAKE_CMD_TMPL -C vmblock;    \
-         $MAKE_CMD_TMPL -C vmci;       \
-         $MAKE_CMD_TMPL -C vmhgfs;     \
-         $MAKE_CMD_TMPL -C vmxnet;     \
-         $MAKE_CMD_TMPL -C vsock"
+         $MAKE_CMD_TMPL -C vmxnet"
 CLEAN[0]="$MAKE_CMD_TMPL -C vmblock clean;    \
-          $MAKE_CMD_TMPL -C vmci clean;       \
-          $MAKE_CMD_TMPL -C vmhgfs clean;     \
-          $MAKE_CMD_TMPL -C vmxnet clean;     \
-          $MAKE_CMD_TMPL -C vsock clean"
+          $MAKE_CMD_TMPL -C vmxnet clean"
 BUILT_MODULE_NAME[0]="vmblock"
-BUILT_MODULE_NAME[1]="vmci"
-BUILT_MODULE_NAME[2]="vmhgfs"
-BUILT_MODULE_NAME[3]="vmxnet"
-BUILT_MODULE_NAME[4]="vsock"
+BUILT_MODULE_NAME[1]="vmxnet"
 BUILT_MODULE_LOCATION[0]="vmblock/"
-BUILT_MODULE_LOCATION[1]="vmci/"
-BUILT_MODULE_LOCATION[2]="vmhgfs/"
-BUILT_MODULE_LOCATION[3]="vmxnet/"
-BUILT_MODULE_LOCATION[4]="vsock/"
+BUILT_MODULE_LOCATION[1]="vmxnet/"
 DEST_MODULE_LOCATION[0]="/kernel/fs/vmblock"
-DEST_MODULE_LOCATION[1]="/kernel/drivers/misc"
-DEST_MODULE_LOCATION[2]="/kernel/fs/vmhgfs"
-DEST_MODULE_LOCATION[3]="/kernel/drivers/net"
-DEST_MODULE_LOCATION[4]="/kernel/net/vsock"
+DEST_MODULE_LOCATION[1]="/kernel/drivers/net"
 AUTOINSTALL="YES"

=== modified file 'modules/linux/shared/compat_fs.h'
--- modules/linux/shared/compat_fs.h	2012-08-03 16:09:30 +0000
+++ modules/linux/shared/compat_fs.h	2013-09-21 20:15:28 +0000
@@ -129,18 +129,6 @@
 })
 #endif
 
-
-/*
- * putname changed to __putname in 2.6.6.
- */
-#define compat___getname() __getname()
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 6)
-#define compat___putname(name) putname(name)
-#else
-#define compat___putname(name) __putname(name)
-#endif
-
-
 /*
  * inc_nlink, drop_nlink, and clear_nlink were added in 2.6.19.
  */

=== modified file 'modules/linux/vmblock/linux/control.c'
--- modules/linux/vmblock/linux/control.c	2012-01-23 16:09:45 +0000
+++ modules/linux/vmblock/linux/control.c	2013-09-21 20:15:28 +0000
@@ -208,9 +208,10 @@
    VMBlockSetProcEntryOwner(controlProcMountpoint);
 
    /* Create /proc/fs/vmblock/dev */
-   controlProcEntry = create_proc_entry(VMBLOCK_CONTROL_DEVNAME,
-                                        VMBLOCK_CONTROL_MODE,
-                                        controlProcDirEntry);
+   controlProcEntry = proc_create(VMBLOCK_CONTROL_DEVNAME,
+                                  VMBLOCK_CONTROL_MODE,
+                                  controlProcDirEntry,
+                                  &ControlFileOps);
    if (!controlProcEntry) {
       Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");
       remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);
@@ -218,7 +219,6 @@
       return -EINVAL;
    }
 
-   controlProcEntry->proc_fops = &ControlFileOps;
    return 0;
 }
 
@@ -278,7 +278,7 @@
                int (*blockOp)(const char *filename,   // IN: block operation
                               const os_blocker_id_t blocker))
 {
-   char *name;
+   struct filename *name;
    int i;
    int retval;
 
@@ -287,13 +287,13 @@
       return PTR_ERR(name);
    }
 
-   for (i = strlen(name) - 1; i >= 0 && name[i] == '/'; i--) {
-      name[i] = '\0';
+   for (i = strlen(name->name) - 1; i >= 0 && name->name[i] == '/'; i--) {
+      ((char *)name->name)[i] = '\0';
    }
 
-   retval = i < 0 ? -EINVAL : blockOp(name, blocker);
+   retval = i < 0 ? -EINVAL : blockOp(name->name, blocker);
 
-   putname(name);
+   __putname(name);
 
    return retval;
 }

=== modified file 'modules/linux/vmblock/linux/dentry.c'
--- modules/linux/vmblock/linux/dentry.c	2012-01-23 16:09:45 +0000
+++ modules/linux/vmblock/linux/dentry.c	2013-09-21 20:15:28 +0000
@@ -31,8 +31,7 @@
 #include "filesystem.h"
 #include "block.h"
 
-
-static int DentryOpRevalidate(struct dentry *dentry, struct nameidata *nd);
+static int DentryOpRevalidate(struct dentry *dentry, unsigned int flags);
 
 struct dentry_operations LinkDentryOps = {
    .d_revalidate = DentryOpRevalidate,
@@ -60,7 +59,7 @@
 
 static int
 DentryOpRevalidate(struct dentry *dentry,  // IN: dentry revalidating
-                   struct nameidata *nd)   // IN: lookup flags & intent
+                   unsigned int flags)     // IN: lookup flags
 {
    VMBlockInodeInfo *iinfo;
    struct nameidata actualNd;
@@ -101,7 +100,7 @@
    if (actualDentry &&
        actualDentry->d_op &&
        actualDentry->d_op->d_revalidate) {
-      return actualDentry->d_op->d_revalidate(actualDentry, nd);
+      return actualDentry->d_op->d_revalidate(actualDentry, flags);
    }
 
    if (compat_path_lookup(iinfo->name, 0, &actualNd)) {

=== modified file 'modules/linux/vmblock/linux/file.c'
--- modules/linux/vmblock/linux/file.c	2011-08-28 16:10:21 +0000
+++ modules/linux/vmblock/linux/file.c	2013-09-21 20:15:28 +0000
@@ -38,46 +38,6 @@
 typedef ino_t inode_num_t;
 #endif
 
-/* Specifically for our filldir_t callback */
-typedef struct FilldirInfo {
-   filldir_t filldir;
-   void *dirent;
-} FilldirInfo;
-
-
-/*
- *----------------------------------------------------------------------------
- *
- * Filldir --
- *
- *    Callback function for readdir that we use in place of the one provided.
- *    This allows us to specify that each dentry is a symlink, but pass through
- *    everything else to the original filldir function.
- *
- * Results:
- *    Original filldir's return value.
- *
- * Side effects:
- *    Directory information gets copied to user's buffer.
- *
- *----------------------------------------------------------------------------
- */
-
-static int
-Filldir(void *buf,              // IN: Dirent buffer passed from FileOpReaddir
-        const char *name,       // IN: Dirent name
-        int namelen,            // IN: len of dirent's name
-        loff_t offset,          // IN: Offset
-        inode_num_t ino,        // IN: Inode number of dirent
-        unsigned int d_type)    // IN: Type of file
-{
-   FilldirInfo *info = buf;
-
-   /* Specify DT_LNK regardless */
-   return info->filldir(info->dirent, name, namelen, offset, ino, DT_LNK);
-}
-
-
 /* File operations */
 
 /*
@@ -166,11 +126,10 @@
 
 static int
 FileOpReaddir(struct file *file,  // IN
-              void *dirent,       // IN
-              filldir_t filldir)  // IN
+              struct dir_context *ctx)  // IN
 {
    int ret;
-   FilldirInfo info;
+
    struct file *actualFile;
 
    if (!file) {
@@ -184,12 +143,10 @@
       return -EINVAL;
    }
 
-   info.filldir = filldir;
-   info.dirent = dirent;
-
-   actualFile->f_pos = file->f_pos;
-   ret = vfs_readdir(actualFile, Filldir, &info);
-   file->f_pos = actualFile->f_pos;
+   /* Ricky Wong Yung Fei:
+    * Manipulation of pos is now handled internally by iterate_dir().
+    */
+   ret = iterate_dir(actualFile, ctx);
 
    return ret;
 }
@@ -237,7 +194,7 @@
 
 
 struct file_operations RootFileOps = {
-   .readdir = FileOpReaddir,
+   .iterate = FileOpReaddir,
    .open    = FileOpOpen,
    .release = FileOpRelease,
 };

=== modified file 'modules/linux/vmblock/linux/inode.c'
--- modules/linux/vmblock/linux/inode.c	2009-08-25 10:35:29 +0000
+++ modules/linux/vmblock/linux/inode.c	2013-09-21 20:15:28 +0000
@@ -36,7 +36,7 @@
 
 /* Inode operations */
 static struct dentry *InodeOpLookup(struct inode *dir,
-                                    struct dentry *dentry, struct nameidata *nd);
+                                    struct dentry *dentry, unsigned int flags);
 static int InodeOpReadlink(struct dentry *dentry, char __user *buffer, int buflen);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
 static void *InodeOpFollowlink(struct dentry *dentry, struct nameidata *nd);
@@ -75,7 +75,7 @@
 static struct dentry *
 InodeOpLookup(struct inode *dir,      // IN: parent directory's inode
               struct dentry *dentry,  // IN: dentry to lookup
-              struct nameidata *nd)   // IN: lookup intent and information
+              unsigned int flags)     // IN: lookup flags
 {
    char *filename;
    struct inode *inode;

=== modified file 'modules/linux/vmhgfs/file.c'
--- modules/linux/vmhgfs/file.c	2013-01-28 16:11:13 +0000
+++ modules/linux/vmhgfs/file.c	2013-09-21 20:15:28 +0000
@@ -25,6 +25,7 @@
 /* Must come before any kernel header file. */
 #include "driver-config.h"
 
+#include <linux/aio.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/signal.h>

=== modified file 'modules/linux/vmsync/sync.c'
--- modules/linux/vmsync/sync.c	2012-01-23 16:09:45 +0000
+++ modules/linux/vmsync/sync.c	2013-09-21 20:15:28 +0000
@@ -162,7 +162,7 @@
    cancel_delayed_work(&state->thawTask);
    list_for_each_safe(cur, tmp, &state->devices) {
       dev = list_entry(cur, VmSyncBlockDevice, list);
-      if (dev->sb != NULL && dev->sb->s_frozen != SB_UNFROZEN) {
+      if (dev->sb != NULL && dev->sb->s_writers.frozen != SB_UNFROZEN) {
          thaw_bdev(dev->bdev, dev->sb);
          atomic_dec(&gFreezeCount);
       }
@@ -237,7 +237,7 @@
     * the superblock is already frozen.
     */
    if (inode->i_sb->s_bdev == NULL ||
-       inode->i_sb->s_frozen != SB_UNFROZEN) {
+       inode->i_sb->s_writers.frozen != SB_UNFROZEN) {
       result = (inode->i_sb->s_bdev == NULL) ? -EINVAL : -EALREADY;
       compat_path_release(&nd);
       goto exit;
@@ -303,7 +303,7 @@
                     const char __user *userPaths)  // IN
 {
    int result = 0;
-   char *paths;
+   struct filename *paths;
    char *currPath;
    char *nextSep;
    struct list_head *cur, *tmp;
@@ -328,7 +328,8 @@
    /*
     * First, try to add all paths to the list of paths to be frozen.
     */
-   currPath = paths;
+   currPath = __getname();
+   strcpy(currPath, paths->name);
    do {
       nextSep = strchr(currPath, ':');
       if (nextSep != NULL) {
@@ -347,6 +348,7 @@
       }
       currPath = nextSep + 1;
    } while (nextSep != NULL);
+   __putname(currPath);
 
    /*
     * If adding all the requested paths worked, then freeze them.
@@ -371,6 +373,8 @@
    compat_mutex_unlock(&state->lock);
    compat_mutex_unlock(&gFreezeLock);
 
+   __putname(paths);
+
    if (result == 0) {
       compat_schedule_delayed_work(&state->thawTask, VMSYNC_THAW_TASK_DELAY);
    }
@@ -670,9 +674,10 @@
    }
 
    /* Create /proc/driver/vmware-sync */
-   controlProcEntry = create_proc_entry("driver/vmware-sync",
-                                        S_IFREG | S_IRUSR | S_IRGRP | S_IROTH,
-                                        NULL);
+   controlProcEntry = proc_create("driver/vmware-sync",
+                                  S_IFREG | S_IRUSR | S_IRGRP | S_IROTH,
+                                  NULL,
+                                  &VmSyncFileOps);
    if (!controlProcEntry) {
       printk(KERN_ERR "vmsync: could not create /proc/driver/vmware-sync\n");
       kmem_cache_destroy(gSyncStateCache);
@@ -680,7 +685,6 @@
       return -EINVAL;
    }
 
-   controlProcEntry->proc_fops = &VmSyncFileOps;
    return 0;
 }