Merge lp:~n-muench/ubuntu/precise/open-vm-tools/open-vm-tools.quantal-modules.backport into lp:ubuntu/precise/open-vm-tools

[Nate Muench (Mink)]

Looking at what's been uploaded to Ubuntu. I noticed that Quantal has the 3.5 kernel.

So I've created a patch that takes all the modules from Quantal and upgrades the Precise ones. I've done a diff of the modules folders from the Precise packaging and the Quantal packaging (excluding the FreeBSD and solaris folders, because we don't use them)

This time there is no backporting any packaging, just cherry-picking the modules from Quantal.

[Robie Basak (racb)]

(I am not a sponsor and cannot merge your changes; just an interested bystander. I appreciate your efforts in getting this fixed)

> You mean I have to revert the (/debian) DKMS files from Raring->Precise. Yeah I figured that out.

No, that's not what I meant. Explanation below. Sorry, I've just seen your message; I'd like to have responded to you earlier.

You seem to have backported the entire module but not the packaging, so I'd say that this *is* a backport, which I think carries a higher risk of regression.

IIRC, it is possible to make DKMS packages build different sources depending on the kernel version. So you could arrange for the actual module itself to be based on an identical source for those running the original Precise kernel, and only apply your changes when using the backport kernel.

This way, you could minimise the chance of regressions for those using the original Precise kernel, since although you would be bumping their DKMS packages the actual module source wouldn't change for them. And you'd enhance the package for users of the backport kernel, since the DKMS package doesn't build for them anyway.

See the PATCH and PATCH_MATCH configuration options in dkms.conf for details. Annoyingly it means that you have to carry a full source and a delta, instead of two full sources for two different versions. But the delta can be constructed and the effect is the same.

This is neither a +1 nor a -1; just a note to say that there may be a safer way. I'm not sure what the appropriate approach here should be.

review: Abstain

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

Nothing has changed in the /debian folder. In fact I originally planned on using the whole Raring packaging, and just downgrading, like you seem to be saying. But it didn't turn out as planned.

Then, I tried to use the upstream packaging used for Raring, along with the /debian folder from Precise. And sure enough it built successfully.

I guess I'm assuming if there are problems (after approval), could fix them. Honestly, I'm just sick of people file bug reports saying that the package in Precise won't build against the 3.5 kernel

[Dmitry Shachnev (mitya57)]

Can you cherry-pick the changes needed to support 3.5 instead of upgrading to a new upstream version?

Also, as this contains a fix for a CVE, it would be nice if someone from security team reviewed it (maybe it should also go to -security pocket).

review: Abstain

[Dmitry Shachnev (mitya57)]

Looks like I can't add ~ubuntu-security-sponsors to the reviewers, can you please do that yourself?

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

> Can you cherry-pick the changes needed to support 3.5 instead of upgrading to
> a new upstream version?
>
> Also, as this contains a fix for a CVE, it would be nice if someone from
> security team reviewed it (maybe it should also go to -security pocket).
Honestly, I don't know what changes were needed for 3.5 support (I'm not able to access VMware git repo for the packaging at the moment).

The reason for upgrading over cherry-picking is because the package has a less likely chance of breakage. I've tested it on Precise, it works to the best of my knowledge.

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

Gonna redo it, with a patch based on Quantal's modules

review: Needs Resubmitting

[lp:~n-muench/ubuntu/precise/open-vm-tools/open-vm-tools.quantal-modules.backport]

28. By Nate Muench (Mink) on 2013-06-28

* Added 04-quantal-module-backport.patch
  - Backports kernel modules from Quantal packaging to Precise.
    + Fixes building on Precise backport kernels. (LP: #1083719)

* Adding patch from Mathias Krause <email address hidden> to fix
  kernel stack memory leack in vsock module [CVE-2013-3237].

[Jamie Strandboge (jdstrand)]

Thanks for the patch, but it can't be applied in its current form. Please see https://bugs.launchpad.net/ubuntu/+source/open-vm-tools/+bug/1083719/comments/18 for details.

review: Needs Fixing

[Dimitri John Ledkov (xnox)]

based on last comment, setting this merge proposal to work in progress.

Unmerged revisions

28. By Nate Muench (Mink) on 2013-06-28

* Added 04-quantal-module-backport.patch
  - Backports kernel modules from Quantal packaging to Precise.
    + Fixes building on Precise backport kernels. (LP: #1083719)

* Adding patch from Mathias Krause <email address hidden> to fix
  kernel stack memory leack in vsock module [CVE-2013-3237].

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2013-06-28 21:11:42 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2013-06-28 21:11:42 +0000
@@ -0,0 +1,1 @@
+series

=== added directory '.pc/04-quantal-module-backport.patch'
=== added directory '.pc/04-quantal-module-backport.patch/modules'
=== added file '.pc/04-quantal-module-backport.patch/modules/Makefile.in'
--- .pc/04-quantal-module-backport.patch/modules/Makefile.in	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/Makefile.in	2013-06-28 21:11:42 +0000
@@ -0,0 +1,588 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = modules
+DIST_COMMON = $(am__include_HEADERS_DIST) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
+	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/vmtools.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+SOURCES =
+DIST_SOURCES =
+am__include_HEADERS_DIST = $(top_srcdir)/lib/include/vmci_sockets.h
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(includedir)"
+HEADERS = $(include_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+COMMON_PLUGIN_INSTALLDIR = @COMMON_PLUGIN_INSTALLDIR@
+COMMON_XLIBS = @COMMON_XLIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CUNIT_CPPFLAGS = @CUNIT_CPPFLAGS@
+CUNIT_LIBS = @CUNIT_LIBS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DNET_CPPFLAGS = @DNET_CPPFLAGS@
+DNET_LIBS = @DNET_LIBS@
+DOT = @DOT@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+FUSE_CPPFLAGS = @FUSE_CPPFLAGS@
+FUSE_LIBS = @FUSE_LIBS@
+GLIB2_CPPFLAGS = @GLIB2_CPPFLAGS@
+GLIB2_LIBS = @GLIB2_LIBS@
+GMODULE_CPPFLAGS = @GMODULE_CPPFLAGS@
+GMODULE_LIBS = @GMODULE_LIBS@
+GOBJECT_CPPFLAGS = @GOBJECT_CPPFLAGS@
+GOBJECT_LIBS = @GOBJECT_LIBS@
+GREP = @GREP@
+GTHREAD_CPPFLAGS = @GTHREAD_CPPFLAGS@
+GTHREAD_LIBS = @GTHREAD_LIBS@
+GTKMM_CPPFLAGS = @GTKMM_CPPFLAGS@
+GTKMM_LIBS = @GTKMM_LIBS@
+GTK_CPPFLAGS = @GTK_CPPFLAGS@
+GTK_LIBS = @GTK_LIBS@
+HAVE_DOT = @HAVE_DOT@
+HAVE_PKG_CONFIG = @HAVE_PKG_CONFIG@
+HGFS_LIBS = @HGFS_LIBS@
+ICU_CPPFLAGS = @ICU_CPPFLAGS@
+ICU_LIBS = @ICU_LIBS@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INSTVMSG = @INSTVMSG@
+KERNEL_RELEASE = @KERNEL_RELEASE@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBVMTOOLS_LIBADD = @LIBVMTOOLS_LIBADD@
+LIB_AUTH_CPPFLAGS = @LIB_AUTH_CPPFLAGS@
+LIB_IMPERSONATE_CPPFLAGS = @LIB_IMPERSONATE_CPPFLAGS@
+LIB_USER_CPPFLAGS = @LIB_USER_CPPFLAGS@
+LINUXINCLUDE = @LINUXINCLUDE@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+MODULES = @MODULES@
+MODULES_DIR = @MODULES_DIR@
+MODULES_OS = @MODULES_OS@
+MSCGEN = @MSCGEN@
+MSCGEN_DIR = @MSCGEN_DIR@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PAM_CPPFLAGS = @PAM_CPPFLAGS@
+PAM_LIBS = @PAM_LIBS@
+PAM_PREFIX = @PAM_PREFIX@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PLUGIN_CPPFLAGS = @PLUGIN_CPPFLAGS@
+PLUGIN_LDFLAGS = @PLUGIN_LDFLAGS@
+PROCPS_CPPFLAGS = @PROCPS_CPPFLAGS@
+PROCPS_LIBS = @PROCPS_LIBS@
+RANLIB = @RANLIB@
+RPCGEN = @RPCGEN@
+RPCGENFLAGS = @RPCGENFLAGS@
+RPCGEN_WRAPPER = @RPCGEN_WRAPPER@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SYSDIR = @SYSDIR@
+TARGET_OS = @TARGET_OS@
+TEST_PLUGIN_INSTALLDIR = @TEST_PLUGIN_INSTALLDIR@
+TOOLS_VERSION = @TOOLS_VERSION@
+VERSION = @VERSION@
+VIX_LIBADD = @VIX_LIBADD@
+VMSVC_PLUGIN_INSTALLDIR = @VMSVC_PLUGIN_INSTALLDIR@
+VMTOOLS_CPPFLAGS = @VMTOOLS_CPPFLAGS@
+VMTOOLS_LIBS = @VMTOOLS_LIBS@
+VMUSR_PLUGIN_INSTALLDIR = @VMUSR_PLUGIN_INSTALLDIR@
+XCOMPOSITE_LIBS = @XCOMPOSITE_LIBS@
+XDR_LIBS = @XDR_LIBS@
+XMKMF = @XMKMF@
+XSM_LIBS = @XSM_LIBS@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+ac_vmw_lib_cfg = @ac_vmw_lib_cfg@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+have_cxx = @have_cxx@
+have_doxygen = @have_doxygen@
+have_genmarshal = @have_genmarshal@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+lt_ECHO = @lt_ECHO@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+modulesrc = $(abs_top_srcdir)/modules
+@FREEBSD_CUSTOM_SYSDIR_TRUE@EXTRA_ARGS = "SYSDIR=@SYSDIR@"
+# Solaris does not have Kbuild-like system so we need to supply
+# compiler and linker and other items discovered by configure
+# script.
+@SOLARIS_TRUE@EXTRA_ARGS = "CC=$(CC)" "CC_WARNINGS=$(CC_WARNINGS)" \
+@SOLARIS_TRUE@	"GLOBAL_DEFS=$(GLOBAL_DEFS)" "LD=$(LD)" \
+@SOLARIS_TRUE@	"HAVE_GNU_LD=$(HAVE_GNU_LD)"
+@LINUX_TRUE@include_HEADERS = $(top_srcdir)/lib/include/vmci_sockets.h
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu modules/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu modules/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-includeHEADERS: $(include_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)"
+	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
+	done
+
+uninstall-includeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$files" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(includedir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(includedir)" && rm -f $$files
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(includedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-local mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-includeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec-hook
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-includeHEADERS
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) uninstall-hook
+.MAKE: install-am install-exec-am install-strip uninstall-am
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-local ctags distclean distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-exec-hook install-html install-html-am \
+	install-includeHEADERS install-info install-info-am \
+	install-man install-pdf install-pdf-am install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+	ps ps-am tags uninstall uninstall-am uninstall-hook \
+	uninstall-includeHEADERS
+
+all: modules
+
+.PHONY: modules $(MODULES)
+modules: $(MODULES)
+
+$(MODULES):
+	$(MAKE) VM_UNAME=$(KERNEL_RELEASE) MV=mv RM=rm      \
+	   OVT_SOURCE_DIR=$(abs_top_srcdir)                 \
+	   MODULEBUILDDIR=$(modulesrc)/$(MODULES_OS)        \
+	   $(EXTRA_ARGS) -C "$(modulesrc)/$(MODULES_OS)/$@"
+
+@LINUX_TRUE@export LINUXINCLUDE := @LINUXINCLUDE@
+@LINUX_TRUE@export vmblockdir := $(MODULES_DIR)/fs/vmblock
+@LINUX_TRUE@export vmcidir := $(MODULES_DIR)/drivers/misc
+@LINUX_TRUE@export vmhgfsdir := $(MODULES_DIR)/fs/vmhgfs
+@LINUX_TRUE@export vmsyncdir := $(MODULES_DIR)/drivers/misc
+@LINUX_TRUE@export vmxnetdir := $(MODULES_DIR)/drivers/net
+@LINUX_TRUE@export vsockdir := $(MODULES_DIR)/net/vsock
+@LINUX_TRUE@@WITH_ROOT_PRIVILEGES_TRUE@export DEPMOD := depmod -a
+
+@SOLARIS_TRUE@export vmhgfsdir := $(MODULES_DIR)
+
+clean-local:
+	for MOD in $(MODULES); do                                              \
+	   if [ -d "$(modulesrc)/$(MODULES_OS)/$$MOD" ]; then                  \
+	      $(MAKE) VM_UNAME=$(KERNEL_RELEASE) MV=mv RM=rm                   \
+	             -C "$(modulesrc)/$(MODULES_OS)/$$MOD" clean || exit 1;    \
+	   fi                                                                  \
+	done
+	rm -f $(modulesrc)/$(MODULES_OS)/*.o $(modulesrc)/$(MODULES_OS)/*.ko
+	rm -f $(modulesrc)/$(MODULES_OS)/VMwareVMCIModule.symvers
+
+install-exec-hook:
+@SOLARIS_TRUE@	for MOD in $(MODULES); do                                              \
+@SOLARIS_TRUE@	   $(MAKE) VM_UNAME=$(KERNEL_RELEASE) MV=mv RM=rm                      \
+@SOLARIS_TRUE@	      -C "$(modulesrc)/$(MODULES_OS)/$$MOD" install || exit 1;         \
+@SOLARIS_TRUE@	done
+@FREEBSD_TRUE@	for MOD in $(MODULES); do                                              \
+@FREEBSD_TRUE@	   $(INSTALL) -d $(DESTDIR)$(MODULES_DIR);                             \
+@FREEBSD_TRUE@	   $(INSTALL) -m644 $(modulesrc)/$(MODULES_OS)/$$MOD.ko                \
+@FREEBSD_TRUE@	      $(DESTDIR)$(MODULES_DIR);                                        \
+@FREEBSD_TRUE@	done
+@LINUX_TRUE@	for MOD in $(MODULES); do                                              \
+@LINUX_TRUE@	   $(INSTALL) -d $(DESTDIR)`eval echo '$$'$${MOD}dir`;                 \
+@LINUX_TRUE@	   $(INSTALL) -m644 $(modulesrc)/$(MODULES_OS)/$$MOD/$$MOD.ko          \
+@LINUX_TRUE@	      $(DESTDIR)`eval echo '$$'$${MOD}dir`;                            \
+@LINUX_TRUE@	done
+@LINUX_TRUE@	eval "$$DEPMOD"
+
+uninstall-hook:
+	for MOD in $(MODULES); do                                              \
+	   rm -f $(DESTDIR)`eval echo '$$'$${MOD}dir`/$$MOD.ko &> /dev/null;\
+	done
+	eval "$$DEPMOD"
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

=== added directory '.pc/04-quantal-module-backport.patch/modules/linux'
=== added file '.pc/04-quantal-module-backport.patch/modules/linux/dkms.conf'
--- .pc/04-quantal-module-backport.patch/modules/linux/dkms.conf	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/dkms.conf	2013-06-28 21:11:42 +0000
@@ -0,0 +1,39 @@
+PACKAGE_NAME=open-vm-tools
+PACKAGE_VERSION=2011.12.20
+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 vmsync;     \
+         $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 vmsync 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]="vmsync"
+BUILT_MODULE_NAME[4]="vmxnet"
+BUILT_MODULE_NAME[5]="vsock"
+BUILT_MODULE_LOCATION[0]="vmblock/"
+BUILT_MODULE_LOCATION[1]="vmci/"
+BUILT_MODULE_LOCATION[2]="vmhgfs/"
+BUILT_MODULE_LOCATION[3]="vmsync/"
+BUILT_MODULE_LOCATION[4]="vmxnet/"
+BUILT_MODULE_LOCATION[5]="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/misc"
+DEST_MODULE_LOCATION[4]="/kernel/drivers/net"
+DEST_MODULE_LOCATION[5]="/kernel/net/vsock"
+AUTOINSTALL="YES"

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/dkms.sh'
--- .pc/04-quantal-module-backport.patch/modules/linux/dkms.sh	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/dkms.sh	2013-06-28 21:11:42 +0000
@@ -0,0 +1,118 @@
+#!/bin/sh
+################################################################################
+### Copyright 2009 VMware, Inc.  All rights reserved.
+###
+### Script for creating a dmks-compliant source tree from an open-vm-tools
+### distribution.
+###
+###
+### This program is free software; you can redistribute it and/or modify
+### it under the terms of version 2 of the GNU General Public License as
+### published by the Free Software Foundation.
+###
+### 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
+################################################################################
+
+if test -z "$1" -o -z "$2"
+then
+   echo "usage: $0 src dst"
+   echo
+   echo "Where:"
+   echo "   src:  root of unpacked open-vm-tools package"
+   echo "   dst:  where to create the dkms tree"
+   echo
+   echo "The script will create an 'open-vm-tools' module with version 2011.12.20."
+   exit 1
+fi
+
+src=$1
+dst=$2/open-vm-tools-2011.12.20
+
+SHARED_HEADERS="backdoor_def.h"
+SHARED_HEADERS="$SHARED_HEADERS backdoor_types.h"
+SHARED_HEADERS="$SHARED_HEADERS circList.h"
+SHARED_HEADERS="$SHARED_HEADERS community_source.h"
+SHARED_HEADERS="$SHARED_HEADERS dbllnklst.h"
+SHARED_HEADERS="$SHARED_HEADERS guest_msg_def.h"
+SHARED_HEADERS="$SHARED_HEADERS includeCheck.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_assert.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_atomic.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_asm.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_asm_x86.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_asm_x86_64.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_defs.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_math.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_basic_types.h"
+SHARED_HEADERS="$SHARED_HEADERS vm_device_version.h"
+SHARED_HEADERS="$SHARED_HEADERS vmci_sockets.h"
+SHARED_HEADERS="$SHARED_HEADERS vmware.h"
+SHARED_HEADERS="$SHARED_HEADERS vmware_pack_begin.h"
+SHARED_HEADERS="$SHARED_HEADERS vmware_pack_end.h"
+SHARED_HEADERS="$SHARED_HEADERS vmware_pack_init.h"
+SHARED_HEADERS="$SHARED_HEADERS x86cpuid.h"
+SHARED_HEADERS="$SHARED_HEADERS x86vendor.h"
+SHARED_HEADERS="$SHARED_HEADERS x86cpuid_asm.h"
+
+rm -rf $dst
+mkdir -p $dst
+cp -f `dirname $0`/dkms.conf $dst
+
+for m in vmblock vmci vmhgfs vmsync vmxnet vsock
+do
+   mdst="$dst/$m"
+
+   cp -rf $src/modules/linux/$m $mdst
+   cp -rf $src/modules/linux/shared $mdst
+   for h in $SHARED_HEADERS
+   do
+      cp -f $src/lib/include/$h $mdst/shared
+   done
+
+   # Shared vmblock code.
+   if test $m = vmblock
+   then
+      cp -f $src/lib/include/vmblock.h $mdst/linux
+      cp -rf $src/modules/shared/vmblock/* $mdst/linux
+   fi
+
+   # Backdoor library (for vmhgfs and vmmemctl).
+   if test $m = vmhgfs -o $m = vmmemctl
+   then
+      cp -f $src/lib/include/backdoor.h $mdst
+      cp -f $src/lib/backdoor/*.c $src/lib/backdoor/*.h $mdst
+   fi
+
+   # Other libraries used by vmhgfs
+   if test $m = vmhgfs
+   then
+      cp -f $src/lib/include/cpName*.h $mdst
+      cp -f $src/lib/include/escBitvector.h $mdst
+      cp -f $src/lib/include/hgfs*.h $mdst
+      cp -f $src/lib/include/message.h $mdst
+      cp -f $src/lib/include/rpcout.h $mdst
+      cp -f $src/lib/hgfs/*.c $src/lib/hgfs/*.h $mdst
+      cp -f $src/lib/hgfsBd/*.c $mdst
+      cp -f $src/lib/message/*.c $mdst
+      cp -f $src/lib/rpcOut/*.c $mdst
+   fi
+
+   # Extra header file for vmsync.
+   if test $m = vmsync
+   then
+      cp -f $src/lib/include/syncDriverIoc.h $mdst
+   fi
+
+   # Shared vmxnet headers.
+   if test $m = vmxnet
+   then
+      cp -f $src/modules/shared/vmxnet/* $mdst/shared
+   fi
+done
+

=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/shared'
=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/shared/autoconf'
=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/autoconf/file_operations_fsync.c'
=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/compat_ethtool.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_ethtool.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_ethtool.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,54 @@
+/*********************************************************
+ * 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
+ *
+ *********************************************************/
+
+#ifndef _COMPAT_ETHTOOL_H
+#define _COMPAT_ETHTOOL_H
+
+/*
+ * ethtool is a userspace utility for getting and setting ethernet device
+ * settings. Kernel support for it was first published in 2.4.0-test11, but
+ * only in 2.4.15 were the ethtool_value struct and the ETHTOOL_GLINK ioctl
+ * added to ethtool.h (together, because the ETHTOOL_GLINK ioctl expects a 
+ * single value response).
+ *
+ * Likewise, ioctls for getting and setting TSO were published in 2.4.22.
+ */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0)
+#   include <linux/ethtool.h>
+
+#   ifndef ETHTOOL_GLINK
+#      define ETHTOOL_GLINK 0x0a
+
+typedef struct {
+	__u32 cmd;
+	__u32 data;
+} compat_ethtool_value;
+
+#   else
+
+typedef struct ethtool_value compat_ethtool_value;
+#   endif
+
+#   ifndef ETHTOOL_GTSO
+#      define ETHTOOL_GTSO 0x1E
+#      define ETHTOOL_STSO 0x1F
+#   endif
+#endif
+
+#endif /* _COMPAT_ETHTOOL_H */

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/compat_fs.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_fs.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_fs.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,251 @@
+/*********************************************************
+ * 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
+
+#endif /* __COMPAT_FS_H__ */

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/compat_netdevice.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_netdevice.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/compat_netdevice.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,334 @@
+/*********************************************************
+ * Copyright (C) 2002 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_NETDEVICE_H__
+#   define __COMPAT_NETDEVICE_H__
+
+
+#include <linux/skbuff.h>
+#include <linux/rtnetlink.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/pci.h>
+
+/*
+ * The enet_statistics structure moved from linux/if_ether.h to
+ * linux/netdevice.h and is renamed net_device_stats in 2.1.25 --hpreg
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 1, 25)
+#   include <linux/if_ether.h>
+
+#   define net_device_stats enet_statistics
+#endif
+
+
+/* The netif_rx_ni() API appeared in 2.4.8 --hpreg */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 8)
+#   define netif_rx_ni netif_rx
+#endif
+
+
+/* The device struct was renamed net_device in 2.3.14 --hpreg */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 14)
+#   define net_device device
+#endif
+
+
+/*
+ * SET_MODULE_OWNER appeared sometime during 2.3.x. It was setting
+ * dev->owner = THIS_MODULE until 2.5.70, where netdevice refcounting
+ * was completely changed.  SET_MODULE_OWNER was nop for whole
+ * 2.6.x series, and finally disappeared in 2.6.24.
+ *
+ * MOD_xxx_USE_COUNT wrappers are here, as they must be mutually
+ * exclusive with SET_MODULE_OWNER call.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
+#   define COMPAT_SET_MODULE_OWNER(dev) do {} while (0)
+#   define COMPAT_NETDEV_MOD_INC_USE_COUNT MOD_INC_USE_COUNT
+#   define COMPAT_NETDEV_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT
+#else
+#   if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
+#      define COMPAT_SET_MODULE_OWNER(dev) SET_MODULE_OWNER(dev)
+#   else
+#      define COMPAT_SET_MODULE_OWNER(dev) do {} while (0)
+#   endif
+#   define COMPAT_NETDEV_MOD_INC_USE_COUNT do {} while (0)
+#   define COMPAT_NETDEV_MOD_DEC_USE_COUNT do {} while (0)
+#endif
+
+/*
+ * SET_NETDEV_DEV appeared sometime during 2.5.x, and later was
+ * crossported to various 2.4.x kernels (as dummy macro).
+ */
+#ifdef SET_NETDEV_DEV
+#   define COMPAT_SET_NETDEV_DEV(dev, pdev) SET_NETDEV_DEV(dev, pdev)
+#else
+#   define COMPAT_SET_NETDEV_DEV(dev, pdev) do {} while (0)
+#endif
+
+/*
+ * Build alloc_etherdev API on the top of init_etherdev.  For 2.0.x kernels
+ * we must provide dummy init method, otherwise register_netdev does
+ * nothing.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 3)
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 0)
+int
+vmware_dummy_init(struct net_device *dev)
+{
+   return 0;
+}
+#endif
+
+
+static inline struct net_device*
+compat_alloc_etherdev(int priv_size)
+{
+   struct net_device* dev;
+   int size = sizeof *dev + priv_size;
+
+   /*
+    * The name is dynamically allocated before 2.4.0, but 
+    * is an embedded array in later kernels.
+    */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
+   size += sizeof("ethXXXXXXX");
+#endif
+   dev = kmalloc(size, GFP_KERNEL);
+   if (dev) {
+      memset(dev, 0, size);
+      if (priv_size) {
+         dev->priv = dev + 1;
+      }
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
+      dev->name = (char *)(dev + 1) + priv_size;
+#endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 0)
+      dev->init = vmware_dummy_init;
+#endif
+      if (init_etherdev(dev, 0) != dev) {
+         kfree(dev);
+         dev = NULL;
+      }
+   }
+   return dev;
+}
+#else
+#define compat_alloc_etherdev(sz)   alloc_etherdev(sz)
+#endif
+
+
+/*
+ * alloc_netdev and free_netdev are there since 2.4.23.  Their use is mandatory
+ * since 2.6.24.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 23)
+static inline struct net_device *
+compat_alloc_netdev(int priv_size,
+                    const char *mask,
+                    void (*setup)(struct net_device *))
+{
+   struct net_device *dev;
+   int netdev_size = sizeof *dev;
+   int alloc_size;
+
+#   if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
+   netdev_size += IFNAMSIZ;
+#   endif
+
+   alloc_size = netdev_size + priv_size;
+   dev = kmalloc(alloc_size, GFP_KERNEL);
+   if (dev) {
+      memset(dev, 0, alloc_size);
+      dev->priv = (char*)dev + netdev_size;
+      setup(dev);
+#   if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
+      dev->name = (char*)(dev + 1);
+#   endif
+      strcpy(dev->name, mask);   
+   }
+   return dev;
+}
+#   define compat_free_netdev(dev)     kfree(dev)
+#else
+#   define compat_alloc_netdev(size, mask, setup) alloc_netdev(size, mask, setup)
+#   define compat_free_netdev(dev)                free_netdev(dev)
+#endif
+
+/* netdev_priv() appeared in 2.6.3 */
+#if  LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 3)
+#   define compat_netdev_priv(netdev)   (netdev)->priv
+#else
+#   define compat_netdev_priv(netdev)   netdev_priv(netdev)
+#endif
+
+/*
+ * In 3.1 merge window feature maros were removed from mainline,
+ * so let's add back ones we care about.
+ */
+#if !defined(HAVE_NET_DEVICE_OPS) && \
+         LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0)
+#   define HAVE_NET_DEVICE_OPS 1
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 9)
+#   define COMPAT_NETDEV_TX_OK    NETDEV_TX_OK
+#   define COMPAT_NETDEV_TX_BUSY  NETDEV_TX_BUSY
+#else
+#   define COMPAT_NETDEV_TX_OK    0
+#   define COMPAT_NETDEV_TX_BUSY  1
+#endif
+
+/* unregister_netdevice_notifier was not safe prior to 2.6.17 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17) && \
+    !defined(ATOMIC_NOTIFIER_INIT)
+/* pre 2.6.17 and not patched */
+static inline int compat_unregister_netdevice_notifier(struct notifier_block *nb) {
+   int err;
+
+   rtnl_lock();
+   err = unregister_netdevice_notifier(nb);
+   rtnl_unlock();
+   return err;
+}
+#else
+/* post 2.6.17 or patched */
+#define compat_unregister_netdevice_notifier(_nb) \
+        unregister_netdevice_notifier(_nb);
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) || defined(__VMKLNX__)
+
+#   define compat_netif_napi_add(dev, napi, poll, quota) \
+      netif_napi_add(dev, napi, poll, quota)
+
+#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30) || \
+       defined VMW_NETIF_SINGLE_NAPI_PARM
+#      define compat_napi_complete(dev, napi) napi_complete(napi)
+#      define compat_napi_schedule(dev, napi) napi_schedule(napi)
+#   else
+#      define compat_napi_complete(dev, napi) netif_rx_complete(dev, napi)
+#      define compat_napi_schedule(dev, napi) netif_rx_schedule(dev, napi)
+#   endif
+
+#   define compat_napi_enable(dev, napi)  napi_enable(napi)
+#   define compat_napi_disable(dev, napi) napi_disable(napi)
+
+#else
+
+#   define compat_napi_complete(dev, napi) netif_rx_complete(dev)
+#   define compat_napi_schedule(dev, napi) netif_rx_schedule(dev)
+#   define compat_napi_enable(dev, napi)   netif_poll_enable(dev)
+#   define compat_napi_disable(dev, napi)  netif_poll_disable(dev)
+
+/* RedHat ported GRO to 2.6.18 bringing new napi_struct with it */
+#   if defined NETIF_F_GRO
+#      define compat_netif_napi_add(netdev, napi, pollcb, quota) \
+      do {                        \
+         (netdev)->poll = (pollcb);    \
+         (netdev)->weight = (quota);\
+         (napi)->dev = (netdev); \
+      } while (0)
+
+#   else
+       struct napi_struct {
+          int dummy;
+       };
+#      define compat_netif_napi_add(dev, napi, pollcb, quota) \
+       do {                        \
+          (dev)->poll = (pollcb);    \
+          (dev)->weight = (quota);\
+       } while (0)
+
+#   endif
+
+#endif
+
+#ifdef NETIF_F_TSO6
+#  define COMPAT_NETIF_F_TSO (NETIF_F_TSO6 | NETIF_F_TSO)
+#else
+#  define COMPAT_NETIF_F_TSO (NETIF_F_TSO)
+#endif
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
+#   define compat_netif_tx_lock(dev) netif_tx_lock(dev)
+#   define compat_netif_tx_unlock(dev) netif_tx_unlock(dev)
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
+#   define compat_netif_tx_lock(dev) spin_lock(&dev->xmit_lock)
+#   define compat_netif_tx_unlock(dev) spin_unlock(&dev->xmit_lock)
+#else
+/* Vendor backporting (SLES 10) has muddled the tx_lock situation. Pick whichever
+ * of the above works for you. */
+#   define compat_netif_tx_lock(dev) do {} while (0)
+#   define compat_netif_tx_unlock(dev) do {} while (0)
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+#   define COMPAT_VLAN_GROUP_ARRAY_LEN VLAN_N_VID
+#   define compat_flush_scheduled_work(work) cancel_work_sync(work)
+#else
+#   define COMPAT_VLAN_GROUP_ARRAY_LEN VLAN_GROUP_ARRAY_LEN
+#   define compat_flush_scheduled_work(work) flush_scheduled_work()
+#endif
+
+
+
+/*
+ * For kernel versions older than 2.6.29, where pci_msi_enabled is not
+ * available, check if
+ *	1. CONFIG_PCI_MSI is present
+ *	2. kernel version is newer than 2.6.25 (because multiqueue is not
+ *	   supporter) in kernels older than that)
+ *	3. msi can be enabled. If it fails it means that MSI is not available.
+ * When all the above are true, return non-zero so that multiple queues will be
+ * allowed in the driver.
+ */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
+#   define compat_multiqueue_allowed(dev) pci_msi_enabled()
+#else
+#   if defined CONFIG_PCI_MSI && LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
+static inline int
+compat_multiqueue_allowed(struct pci_dev *dev)
+{
+   int ret;
+
+   if (!pci_enable_msi(dev))
+      ret = 1;
+   else
+      ret = 0;
+
+   pci_disable_msi(dev);
+   return ret;
+}
+
+#   else
+#      define compat_multiqueue_allowed(dev) (0)
+#   endif
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+#   define compat_vlan_get_protocol(skb) vlan_get_protocol(skb)
+#else
+#   define compat_vlan_get_protocol(skb) (skb->protocol)
+#endif
+
+#endif /* __COMPAT_NETDEVICE_H__ */

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/vmciKernelAPI1.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/vmciKernelAPI1.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/vmciKernelAPI1.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,191 @@
+/*********************************************************
+ * Copyright (C) 2010 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
+ *
+ *********************************************************/
+
+/*
+ * vmciKernelAPI1.h --
+ *
+ *    Kernel API (v1) exported from the VMCI host and guest drivers.
+ */
+
+#ifndef __VMCI_KERNELAPI_1_H__
+#define __VMCI_KERNELAPI_1_H__
+
+#define INCLUDE_ALLOW_MODULE
+#define INCLUDE_ALLOW_VMK_MODULE
+#define INCLUDE_ALLOW_VMKERNEL
+#include "includeCheck.h"
+
+#include "vmci_defs.h"
+#include "vmci_call_defs.h"
+
+
+/* VMCI module namespace on vmkernel. */
+
+#define MOD_VMCI_NAMESPACE "com.vmware.vmci"
+
+/* Define version 1. */
+
+#undef  VMCI_KERNEL_API_VERSION
+#define VMCI_KERNEL_API_VERSION_1 1
+#define VMCI_KERNEL_API_VERSION   VMCI_KERNEL_API_VERSION_1
+
+/* Macros to operate on the driver version number. */
+
+#define VMCI_MAJOR_VERSION(v) (((v) >> 16) & 0xffff)
+#define VMCI_MINOR_VERSION(v) ((v) & 0xffff)
+
+/* VMCI Device Usage API. */
+
+typedef void (VMCI_DeviceShutdownFn)(void *deviceRegistration,
+                                     void *userData);
+
+Bool VMCI_DeviceGet(uint32 *apiVersion, VMCI_DeviceShutdownFn *deviceShutdownCB,
+                    void *userData, void **deviceRegistration);
+void VMCI_DeviceRelease(void *deviceRegistration);
+
+/* VMCI Datagram API. */
+
+int VMCIDatagram_CreateHnd(VMCIId resourceID, uint32 flags,
+                           VMCIDatagramRecvCB recvCB, void *clientData,
+                           VMCIHandle *outHandle);
+int VMCIDatagram_CreateHndPriv(VMCIId resourceID, uint32 flags,
+                               VMCIPrivilegeFlags privFlags,
+                               VMCIDatagramRecvCB recvCB, void *clientData,
+                               VMCIHandle *outHandle);
+int VMCIDatagram_DestroyHnd(VMCIHandle handle);
+int VMCIDatagram_Send(VMCIDatagram *msg);
+
+/* VMCI Utility API. */
+
+VMCIId VMCI_GetContextID(void);
+uint32 VMCI_Version(void);
+int VMCI_ContextID2HostVmID(VMCIId contextID, void *hostVmID,
+                            size_t hostVmIDLen);
+int VMCI_IsContextOwner(VMCIId contextID, void *hostUser);
+
+/* VMCI Event API. */
+
+typedef void (*VMCI_EventCB)(VMCIId subID, VMCI_EventData *ed,
+                             void *clientData);
+
+int VMCIEvent_Subscribe(VMCI_Event event, uint32 flags, VMCI_EventCB callback,
+                        void *callbackData, VMCIId *subID);
+int VMCIEvent_Unsubscribe(VMCIId subID);
+
+/* VMCI Context API */
+
+VMCIPrivilegeFlags VMCIContext_GetPrivFlags(VMCIId contextID);
+
+/* VMCI Queue Pair API. */
+
+typedef struct VMCIQPair VMCIQPair;
+
+int VMCIQPair_Alloc(VMCIQPair **qpair,
+                    VMCIHandle *handle,
+                    uint64 produceQSize,
+                    uint64 consumeQSize,
+                    VMCIId peer,
+                    uint32 flags,
+                    VMCIPrivilegeFlags privFlags);
+
+int VMCIQPair_Detach(VMCIQPair **qpair);
+
+int VMCIQPair_GetProduceIndexes(const VMCIQPair *qpair,
+                                uint64 *producerTail,
+                                uint64 *consumerHead);
+int VMCIQPair_GetConsumeIndexes(const VMCIQPair *qpair,
+                                uint64 *consumerTail,
+                                uint64 *producerHead);
+int64 VMCIQPair_ProduceFreeSpace(const VMCIQPair *qpair);
+int64 VMCIQPair_ProduceBufReady(const VMCIQPair *qpair);
+int64 VMCIQPair_ConsumeFreeSpace(const VMCIQPair *qpair);
+int64 VMCIQPair_ConsumeBufReady(const VMCIQPair *qpair);
+ssize_t VMCIQPair_Enqueue(VMCIQPair *qpair,
+                          const void *buf,
+                          size_t bufSize,
+                          int mode);
+ssize_t VMCIQPair_Dequeue(VMCIQPair *qpair,
+                          void *buf,
+                          size_t bufSize,
+                          int mode);
+ssize_t VMCIQPair_Peek(VMCIQPair *qpair,
+                       void *buf,
+                       size_t bufSize,
+                       int mode);
+
+#if defined (SOLARIS) || (defined(__APPLE__) && !defined (VMX86_TOOLS)) || \
+    (defined(__linux__) && defined(__KERNEL__)) || \
+    (defined(_WIN32) && defined(WINNT_DDK))
+/*
+ * Environments that support struct iovec
+ */
+
+ssize_t VMCIQPair_EnqueueV(VMCIQPair *qpair,
+                           void *iov,
+                           size_t iovSize,
+                           int mode);
+ssize_t VMCIQPair_DequeueV(VMCIQPair *qpair,
+                           void *iov,
+                           size_t iovSize,
+                           int mode);
+ssize_t VMCIQPair_PeekV(VMCIQPair *qpair,
+                        void *iov,
+                        size_t iovSize,
+                        int mode);
+#endif /* Systems that support struct iovec */
+
+
+/* Typedefs for all of the above, used by the IOCTLs and the kernel library. */
+
+typedef void (VMCI_DeviceReleaseFct)(void *);
+typedef int (VMCIDatagram_CreateHndFct)(VMCIId, uint32, VMCIDatagramRecvCB,
+                                        void *, VMCIHandle *);
+typedef int (VMCIDatagram_CreateHndPrivFct)(VMCIId, uint32, VMCIPrivilegeFlags,
+                                            VMCIDatagramRecvCB, void *,
+                                            VMCIHandle *);
+typedef int (VMCIDatagram_DestroyHndFct)(VMCIHandle);
+typedef int (VMCIDatagram_SendFct)(VMCIDatagram *);
+typedef VMCIId (VMCI_GetContextIDFct)(void);
+typedef uint32 (VMCI_VersionFct)(void);
+typedef int (VMCI_ContextID2HostVmIDFct)(VMCIId, void *, size_t);
+typedef int (VMCI_IsContextOwnerFct)(VMCIId, void *);
+typedef int (VMCIEvent_SubscribeFct)(VMCI_Event, uint32, VMCI_EventCB, void *,
+                                     VMCIId *);
+typedef int (VMCIEvent_UnsubscribeFct)(VMCIId);
+typedef VMCIPrivilegeFlags (VMCIContext_GetPrivFlagsFct)(VMCIId);
+typedef int (VMCIQPair_AllocFct)(VMCIQPair **, VMCIHandle *, uint64, uint64,
+                                 VMCIId, uint32, VMCIPrivilegeFlags);
+typedef int (VMCIQPair_DetachFct)(VMCIQPair **);
+typedef int (VMCIQPair_GetProduceIndexesFct)(const VMCIQPair *, uint64 *,
+                                             uint64 *);
+typedef int (VMCIQPair_GetConsumeIndexesFct)(const VMCIQPair *, uint64 *,
+                                             uint64 *);
+typedef int64 (VMCIQPair_ProduceFreeSpaceFct)(const VMCIQPair *);
+typedef int64 (VMCIQPair_ProduceBufReadyFct)(const VMCIQPair *);
+typedef int64 (VMCIQPair_ConsumeFreeSpaceFct)(const VMCIQPair *);
+typedef int64 (VMCIQPair_ConsumeBufReadyFct)(const VMCIQPair *);
+typedef ssize_t (VMCIQPair_EnqueueFct)(VMCIQPair *, const void *, size_t, int);
+typedef ssize_t (VMCIQPair_DequeueFct)(VMCIQPair *, void *, size_t, int);
+typedef ssize_t (VMCIQPair_PeekFct)(VMCIQPair *, void *, size_t, int);
+typedef ssize_t (VMCIQPair_EnqueueVFct)(VMCIQPair *qpair, void *, size_t, int);
+typedef ssize_t (VMCIQPair_DequeueVFct)(VMCIQPair *qpair, void *, size_t, int);
+typedef ssize_t (VMCIQPair_PeekVFct)(VMCIQPair *qpair, void *, size_t, int);
+
+
+#endif /* !__VMCI_KERNELAPI_1_H__ */
+

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_defs.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_defs.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_defs.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,831 @@
+/*********************************************************
+ * Copyright (C) 2005-2011 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 _VMCI_DEF_H_
+#define _VMCI_DEF_H_
+
+#define INCLUDE_ALLOW_USERLEVEL
+#define INCLUDE_ALLOW_VMMEXT
+#define INCLUDE_ALLOW_MODULE
+#define INCLUDE_ALLOW_VMMON
+#define INCLUDE_ALLOW_VMCORE
+#define INCLUDE_ALLOW_VMK_MODULE
+#define INCLUDE_ALLOW_VMKERNEL
+#define INCLUDE_ALLOW_DISTRIBUTE
+#include "includeCheck.h"
+
+#include "vm_basic_types.h"
+#include "vm_atomic.h"
+#include "vm_assert.h"
+
+/* Register offsets. */
+#define VMCI_STATUS_ADDR      0x00
+#define VMCI_CONTROL_ADDR     0x04
+#define VMCI_ICR_ADDR	      0x08
+#define VMCI_IMR_ADDR         0x0c
+#define VMCI_DATA_OUT_ADDR    0x10
+#define VMCI_DATA_IN_ADDR     0x14
+#define VMCI_CAPS_ADDR        0x18
+#define VMCI_RESULT_LOW_ADDR  0x1c
+#define VMCI_RESULT_HIGH_ADDR 0x20
+
+/* Max number of devices. */
+#define VMCI_MAX_DEVICES 1
+
+/* Status register bits. */
+#define VMCI_STATUS_INT_ON     0x1
+
+/* Control register bits. */
+#define VMCI_CONTROL_RESET        0x1
+#define VMCI_CONTROL_INT_ENABLE   0x2
+#define VMCI_CONTROL_INT_DISABLE  0x4
+
+/* Capabilities register bits. */
+#define VMCI_CAPS_HYPERCALL     0x1
+#define VMCI_CAPS_GUESTCALL     0x2
+#define VMCI_CAPS_DATAGRAM      0x4
+#define VMCI_CAPS_NOTIFICATIONS 0x8
+
+/* Interrupt Cause register bits. */
+#define VMCI_ICR_DATAGRAM      0x1
+#define VMCI_ICR_NOTIFICATION  0x2
+
+/* Interrupt Mask register bits. */
+#define VMCI_IMR_DATAGRAM      0x1
+#define VMCI_IMR_NOTIFICATION  0x2
+
+/* Interrupt type. */
+typedef enum VMCIIntrType {
+   VMCI_INTR_TYPE_INTX = 0,
+   VMCI_INTR_TYPE_MSI =  1,
+   VMCI_INTR_TYPE_MSIX = 2
+} VMCIIntrType;
+
+/*
+ * Maximum MSI/MSI-X interrupt vectors in the device.
+ */
+#define VMCI_MAX_INTRS 2
+
+/*
+ * Supported interrupt vectors.  There is one for each ICR value above,
+ * but here they indicate the position in the vector array/message ID.
+ */
+#define VMCI_INTR_DATAGRAM     0
+#define VMCI_INTR_NOTIFICATION 1
+
+
+/*
+ * A single VMCI device has an upper limit of 128MB on the amount of
+ * memory that can be used for queue pairs.
+ */
+#define VMCI_MAX_GUEST_QP_MEMORY (128 * 1024 * 1024)
+
+/*
+ * Queues with pre-mapped data pages must be small, so that we don't pin
+ * too much kernel memory (especially on vmkernel).  We limit a queuepair to
+ * 32 KB, or 16 KB per queue for symmetrical pairs.
+ */
+#define VMCI_MAX_PINNED_QP_MEMORY (32 * 1024)
+
+/*
+ * We have a fixed set of resource IDs available in the VMX.
+ * This allows us to have a very simple implementation since we statically
+ * know how many will create datagram handles. If a new caller arrives and
+ * we have run out of slots we can manually increment the maximum size of
+ * available resource IDs.
+ */
+
+typedef uint32 VMCI_Resource;
+
+/* VMCI reserved hypervisor datagram resource IDs. */
+#define VMCI_RESOURCES_QUERY      0
+#define VMCI_GET_CONTEXT_ID       1
+#define VMCI_SET_NOTIFY_BITMAP    2
+#define VMCI_DOORBELL_LINK        3
+#define VMCI_DOORBELL_UNLINK      4
+#define VMCI_DOORBELL_NOTIFY      5
+/*
+ * VMCI_DATAGRAM_REQUEST_MAP and VMCI_DATAGRAM_REMOVE_MAP are
+ * obsoleted by the removal of VM to VM communication.
+ */
+#define VMCI_DATAGRAM_REQUEST_MAP 6
+#define VMCI_DATAGRAM_REMOVE_MAP  7
+#define VMCI_EVENT_SUBSCRIBE      8
+#define VMCI_EVENT_UNSUBSCRIBE    9
+#define VMCI_QUEUEPAIR_ALLOC      10
+#define VMCI_QUEUEPAIR_DETACH     11
+/*
+ * VMCI_VSOCK_VMX_LOOKUP was assigned to 12 for Fusion 3.0/3.1,
+ * WS 7.0/7.1 and ESX 4.1
+ */
+#define VMCI_HGFS_TRANSPORT       13
+#define VMCI_UNITY_PBRPC_REGISTER 14
+/*
+ * The next two resources are for RPC calls from guest Tools, to replace the
+ * backdoor calls we used previously.  Privileged is for admin/root RPCs,
+ * unprivileged is for RPCs from any user.
+ */
+#define VMCI_RPC_PRIVILEGED       15
+#define VMCI_RPC_UNPRIVILEGED     16
+#define VMCI_RESOURCE_MAX         17
+
+/* VMCI Ids. */
+typedef uint32 VMCIId;
+
+typedef struct VMCIHandle {
+   VMCIId context;
+   VMCIId resource;
+} VMCIHandle;
+
+static INLINE
+VMCIHandle VMCI_MAKE_HANDLE(VMCIId cid,
+			    VMCIId rid)
+{
+   VMCIHandle h;
+   h.context = cid;
+   h.resource = rid;
+   return h;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCI_HANDLE_TO_UINT64 --
+ *
+ *     Helper for VMCI handle to uint64 conversion.
+ *
+ * Results:
+ *     The uint64 value.
+ *
+ * Side effects:
+ *     None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static INLINE uint64
+VMCI_HANDLE_TO_UINT64(VMCIHandle handle) // IN:
+{
+   uint64 handle64;
+
+   handle64 = handle.context;
+   handle64 <<= 32;
+   handle64 |= handle.resource;
+   return handle64;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCI_UINT64_TO_HANDLE --
+ *
+ *     Helper for uint64 to VMCI handle conversion.
+ *
+ * Results:
+ *     The VMCI handle value.
+ *
+ * Side effects:
+ *     None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static INLINE VMCIHandle
+VMCI_UINT64_TO_HANDLE(uint64 handle64) // IN:
+{
+   VMCIId context = (VMCIId)(handle64 >> 32);
+   VMCIId resource = (VMCIId)handle64;
+
+   return VMCI_MAKE_HANDLE(context, resource);
+}
+
+#define VMCI_HANDLE_TO_CONTEXT_ID(_handle) ((_handle).context)
+#define VMCI_HANDLE_TO_RESOURCE_ID(_handle) ((_handle).resource)
+#define VMCI_HANDLE_EQUAL(_h1, _h2) ((_h1).context == (_h2).context && \
+				     (_h1).resource == (_h2).resource)
+
+#define VMCI_INVALID_ID 0xFFFFFFFF
+static const VMCIHandle VMCI_INVALID_HANDLE = {VMCI_INVALID_ID,
+					       VMCI_INVALID_ID};
+
+#define VMCI_HANDLE_INVALID(_handle)   \
+   VMCI_HANDLE_EQUAL((_handle), VMCI_INVALID_HANDLE)
+
+/*
+ * The below defines can be used to send anonymous requests.
+ * This also indicates that no response is expected.
+ */
+#define VMCI_ANON_SRC_CONTEXT_ID   VMCI_INVALID_ID
+#define VMCI_ANON_SRC_RESOURCE_ID  VMCI_INVALID_ID
+#define VMCI_ANON_SRC_HANDLE       VMCI_MAKE_HANDLE(VMCI_ANON_SRC_CONTEXT_ID, \
+						    VMCI_ANON_SRC_RESOURCE_ID)
+
+/* The lowest 16 context ids are reserved for internal use. */
+#define VMCI_RESERVED_CID_LIMIT 16
+
+/*
+ * Hypervisor context id, used for calling into hypervisor
+ * supplied services from the VM.
+ */
+#define VMCI_HYPERVISOR_CONTEXT_ID 0
+
+/*
+ * Well-known context id, a logical context that contains a set of
+ * well-known services. This context ID is now obsolete.
+ */
+#define VMCI_WELL_KNOWN_CONTEXT_ID 1
+
+/*
+ * Context ID used by host endpoints.
+ */
+#define VMCI_HOST_CONTEXT_ID  2
+
+#define VMCI_CONTEXT_IS_VM(_cid) (VMCI_INVALID_ID != _cid && \
+                                  _cid > VMCI_HOST_CONTEXT_ID)
+
+/*
+ * The VMCI_CONTEXT_RESOURCE_ID is used together with VMCI_MAKE_HANDLE to make
+ * handles that refer to a specific context.
+ */
+#define VMCI_CONTEXT_RESOURCE_ID 0
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCI error codes.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#define VMCI_SUCCESS_QUEUEPAIR_ATTACH     5
+#define VMCI_SUCCESS_QUEUEPAIR_CREATE     4
+#define VMCI_SUCCESS_LAST_DETACH          3
+#define VMCI_SUCCESS_ACCESS_GRANTED       2
+#define VMCI_SUCCESS_ENTRY_DEAD           1
+#define VMCI_SUCCESS                      0LL
+#define VMCI_ERROR_INVALID_RESOURCE      (-1)
+#define VMCI_ERROR_INVALID_ARGS          (-2)
+#define VMCI_ERROR_NO_MEM                (-3)
+#define VMCI_ERROR_DATAGRAM_FAILED       (-4)
+#define VMCI_ERROR_MORE_DATA             (-5)
+#define VMCI_ERROR_NO_MORE_DATAGRAMS     (-6)
+#define VMCI_ERROR_NO_ACCESS             (-7)
+#define VMCI_ERROR_NO_HANDLE             (-8)
+#define VMCI_ERROR_DUPLICATE_ENTRY       (-9)
+#define VMCI_ERROR_DST_UNREACHABLE       (-10)
+#define VMCI_ERROR_PAYLOAD_TOO_LARGE     (-11)
+#define VMCI_ERROR_INVALID_PRIV          (-12)
+#define VMCI_ERROR_GENERIC               (-13)
+#define VMCI_ERROR_PAGE_ALREADY_SHARED   (-14)
+#define VMCI_ERROR_CANNOT_SHARE_PAGE     (-15)
+#define VMCI_ERROR_CANNOT_UNSHARE_PAGE   (-16)
+#define VMCI_ERROR_NO_PROCESS            (-17)
+#define VMCI_ERROR_NO_DATAGRAM           (-18)
+#define VMCI_ERROR_NO_RESOURCES          (-19)
+#define VMCI_ERROR_UNAVAILABLE           (-20)
+#define VMCI_ERROR_NOT_FOUND             (-21)
+#define VMCI_ERROR_ALREADY_EXISTS        (-22)
+#define VMCI_ERROR_NOT_PAGE_ALIGNED      (-23)
+#define VMCI_ERROR_INVALID_SIZE          (-24)
+#define VMCI_ERROR_REGION_ALREADY_SHARED (-25)
+#define VMCI_ERROR_TIMEOUT               (-26)
+#define VMCI_ERROR_DATAGRAM_INCOMPLETE   (-27)
+#define VMCI_ERROR_INCORRECT_IRQL        (-28)
+#define VMCI_ERROR_EVENT_UNKNOWN         (-29)
+#define VMCI_ERROR_OBSOLETE              (-30)
+#define VMCI_ERROR_QUEUEPAIR_MISMATCH    (-31)
+#define VMCI_ERROR_QUEUEPAIR_NOTSET      (-32)
+#define VMCI_ERROR_QUEUEPAIR_NOTOWNER    (-33)
+#define VMCI_ERROR_QUEUEPAIR_NOTATTACHED (-34)
+#define VMCI_ERROR_QUEUEPAIR_NOSPACE     (-35)
+#define VMCI_ERROR_QUEUEPAIR_NODATA      (-36)
+#define VMCI_ERROR_BUSMEM_INVALIDATION   (-37)
+#define VMCI_ERROR_MODULE_NOT_LOADED     (-38)
+#define VMCI_ERROR_DEVICE_NOT_FOUND      (-39)
+#define VMCI_ERROR_QUEUEPAIR_NOT_READY   (-40)
+#define VMCI_ERROR_WOULD_BLOCK           (-41)
+
+/* VMCI clients should return error code withing this range */
+#define VMCI_ERROR_CLIENT_MIN     (-500)
+#define VMCI_ERROR_CLIENT_MAX     (-550)
+
+/* Internal error codes. */
+#define VMCI_SHAREDMEM_ERROR_BAD_CONTEXT (-1000)
+
+#define VMCI_PATH_MAX 256
+
+/* VMCI reserved events. */
+typedef uint32 VMCI_Event;
+
+#define VMCI_EVENT_CTX_ID_UPDATE  0  // Only applicable to guest endpoints
+#define VMCI_EVENT_CTX_REMOVED    1  // Applicable to guest and host
+#define VMCI_EVENT_QP_RESUMED     2  // Only applicable to guest endpoints
+#define VMCI_EVENT_QP_PEER_ATTACH 3  // Applicable to guest and host
+#define VMCI_EVENT_QP_PEER_DETACH 4  // Applicable to guest and host
+#define VMCI_EVENT_MEM_ACCESS_ON  5  // Applicable to VMX and vmk.  On vmk,
+                                     // this event has the Context payload type.
+#define VMCI_EVENT_MEM_ACCESS_OFF 6  // Applicable to VMX and vmk.  Same as
+                                     // above for the payload type.
+#define VMCI_EVENT_MAX            7
+
+/*
+ * Of the above events, a few are reserved for use in the VMX, and
+ * other endpoints (guest and host kernel) should not use them. For
+ * the rest of the events, we allow both host and guest endpoints to
+ * subscribe to them, to maintain the same API for host and guest
+ * endpoints.
+ */
+
+#define VMCI_EVENT_VALID_VMX(_event) (_event == VMCI_EVENT_MEM_ACCESS_ON || \
+                                      _event == VMCI_EVENT_MEM_ACCESS_OFF)
+
+#if defined(VMX86_SERVER)
+#define VMCI_EVENT_VALID(_event) (_event < VMCI_EVENT_MAX)
+#else // VMX86_SERVER
+#define VMCI_EVENT_VALID(_event) (_event < VMCI_EVENT_MAX && \
+                                  !VMCI_EVENT_VALID_VMX(_event))
+#endif // VMX86_SERVER
+
+/* Reserved guest datagram resource ids. */
+#define VMCI_EVENT_HANDLER 0
+
+/* VMCI privileges. */
+typedef enum VMCIResourcePrivilegeType {
+   VMCI_PRIV_CH_PRIV,
+   VMCI_PRIV_DESTROY_RESOURCE,
+   VMCI_PRIV_ASSIGN_CLIENT,
+   VMCI_PRIV_DG_CREATE,
+   VMCI_PRIV_DG_SEND,
+   VMCI_PRIV_NOTIFY,
+   VMCI_NUM_PRIVILEGES,
+} VMCIResourcePrivilegeType;
+
+/*
+ * VMCI coarse-grained privileges (per context or host
+ * process/endpoint. An entity with the restricted flag is only
+ * allowed to interact with the hypervisor and trusted entities.
+ */
+typedef uint32 VMCIPrivilegeFlags;
+
+#define VMCI_PRIVILEGE_FLAG_RESTRICTED     0x01
+#define VMCI_PRIVILEGE_FLAG_TRUSTED        0x02
+#define VMCI_PRIVILEGE_ALL_FLAGS           (VMCI_PRIVILEGE_FLAG_RESTRICTED | \
+				            VMCI_PRIVILEGE_FLAG_TRUSTED)
+#define VMCI_NO_PRIVILEGE_FLAGS            0x00
+#define VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS  VMCI_NO_PRIVILEGE_FLAGS
+#define VMCI_LEAST_PRIVILEGE_FLAGS         VMCI_PRIVILEGE_FLAG_RESTRICTED
+#define VMCI_MAX_PRIVILEGE_FLAGS           VMCI_PRIVILEGE_FLAG_TRUSTED
+
+#define VMCI_PUBLIC_GROUP_NAME "vmci public group"
+/* 0 through VMCI_RESERVED_RESOURCE_ID_MAX are reserved. */
+#define VMCI_RESERVED_RESOURCE_ID_MAX 1023
+
+#define VMCI_DOMAIN_NAME_MAXLEN  32
+
+#define VMCI_LGPFX "VMCI: "
+
+
+/*
+ * VMCIQueueHeader
+ *
+ * A Queue cannot stand by itself as designed.  Each Queue's header
+ * contains a pointer into itself (the producerTail) and into its peer
+ * (consumerHead).  The reason for the separation is one of
+ * accessibility: Each end-point can modify two things: where the next
+ * location to enqueue is within its produceQ (producerTail); and
+ * where the next dequeue location is in its consumeQ (consumerHead).
+ *
+ * An end-point cannot modify the pointers of its peer (guest to
+ * guest; NOTE that in the host both queue headers are mapped r/w).
+ * But, each end-point needs read access to both Queue header
+ * structures in order to determine how much space is used (or left)
+ * in the Queue.  This is because for an end-point to know how full
+ * its produceQ is, it needs to use the consumerHead that points into
+ * the produceQ but -that- consumerHead is in the Queue header for
+ * that end-points consumeQ.
+ *
+ * Thoroughly confused?  Sorry.
+ *
+ * producerTail: the point to enqueue new entrants.  When you approach
+ * a line in a store, for example, you walk up to the tail.
+ *
+ * consumerHead: the point in the queue from which the next element is
+ * dequeued.  In other words, who is next in line is he who is at the
+ * head of the line.
+ *
+ * Also, producerTail points to an empty byte in the Queue, whereas
+ * consumerHead points to a valid byte of data (unless producerTail ==
+ * consumerHead in which case consumerHead does not point to a valid
+ * byte of data).
+ *
+ * For a queue of buffer 'size' bytes, the tail and head pointers will be in
+ * the range [0, size-1].
+ *
+ * If produceQHeader->producerTail == consumeQHeader->consumerHead
+ * then the produceQ is empty.
+ */
+
+typedef struct VMCIQueueHeader {
+   /* All fields are 64bit and aligned. */
+   VMCIHandle    handle;       /* Identifier. */
+   Atomic_uint64 producerTail; /* Offset in this queue. */
+   Atomic_uint64 consumerHead; /* Offset in peer queue. */
+} VMCIQueueHeader;
+
+
+/*
+ * If one client of a QueuePair is a 32bit entity, we restrict the QueuePair
+ * size to be less than 4GB, and use 32bit atomic operations on the head and
+ * tail pointers. 64bit atomic read on a 32bit entity involves cmpxchg8b which
+ * is an atomic read-modify-write. This will cause traces to fire when a 32bit
+ * consumer tries to read the producer's tail pointer, for example, because the
+ * consumer has read-only access to the producer's tail pointer.
+ *
+ * We provide the following macros to invoke 32bit or 64bit atomic operations
+ * based on the architecture the code is being compiled on.
+ */
+
+/* Architecture independent maximum queue size. */
+#define QP_MAX_QUEUE_SIZE_ARCH_ANY   CONST64U(0xffffffff)
+
+#ifdef __x86_64__
+#  define QP_MAX_QUEUE_SIZE_ARCH     CONST64U(0xffffffffffffffff)
+#  define QPAtomic_ReadOffset(x)     Atomic_Read64(x)
+#  define QPAtomic_WriteOffset(x, y) Atomic_Write64(x, y)
+#else
+   /*
+    * Wrappers below are being used to call Atomic_Read32 because of the
+    * 'type punned' compilation warning received when Atomic_Read32 is
+    * called with a Atomic_uint64 pointer typecasted to Atomic_uint32
+    * pointer from QPAtomic_ReadOffset. Ditto with QPAtomic_WriteOffset.
+    */
+
+   static INLINE uint32
+   TypeSafe_Atomic_Read32(void *var) // IN:
+   {
+      return Atomic_Read32((Atomic_uint32 *)(var));
+   }
+
+   static INLINE void
+   TypeSafe_Atomic_Write32(void *var, uint32 val) // IN:
+   {
+      Atomic_Write32((Atomic_uint32 *)(var), (uint32)(val));
+   }
+
+#  define QP_MAX_QUEUE_SIZE_ARCH  CONST64U(0xffffffff)
+#  define QPAtomic_ReadOffset(x)  TypeSafe_Atomic_Read32((void *)(x))
+#  define QPAtomic_WriteOffset(x, y) \
+          TypeSafe_Atomic_Write32((void *)(x), (uint32)(y))
+#endif	/* __x86_64__  */
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * QPAddPointer --
+ *
+ *      Helper to add a given offset to a head or tail pointer. Wraps the value
+ *      of the pointer around the max size of the queue.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+QPAddPointer(Atomic_uint64 *var, // IN:
+             size_t add,         // IN:
+             uint64 size)        // IN:
+{
+   uint64 newVal = QPAtomic_ReadOffset(var);
+
+   if (newVal >= size - add) {
+      newVal -= size;
+   }
+   newVal += add;
+
+   QPAtomic_WriteOffset(var, newVal);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_ProducerTail() --
+ *
+ *      Helper routine to get the Producer Tail from the supplied queue.
+ *
+ * Results:
+ *      The contents of the queue's producer tail.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE uint64
+VMCIQueueHeader_ProducerTail(const VMCIQueueHeader *qHeader) // IN:
+{
+   VMCIQueueHeader *qh = (VMCIQueueHeader *)qHeader;
+   return QPAtomic_ReadOffset(&qh->producerTail);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_ConsumerHead() --
+ *
+ *      Helper routine to get the Consumer Head from the supplied queue.
+ *
+ * Results:
+ *      The contents of the queue's consumer tail.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE uint64
+VMCIQueueHeader_ConsumerHead(const VMCIQueueHeader *qHeader) // IN:
+{
+   VMCIQueueHeader *qh = (VMCIQueueHeader *)qHeader;
+   return QPAtomic_ReadOffset(&qh->consumerHead);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_AddProducerTail() --
+ *
+ *      Helper routine to increment the Producer Tail.  Fundamentally,
+ *      QPAddPointer() is used to manipulate the tail itself.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIQueueHeader_AddProducerTail(VMCIQueueHeader *qHeader, // IN/OUT:
+                                size_t add,               // IN:
+                                uint64 queueSize)         // IN:
+{
+   QPAddPointer(&qHeader->producerTail, add, queueSize);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_AddConsumerHead() --
+ *
+ *      Helper routine to increment the Consumer Head.  Fundamentally,
+ *      QPAddPointer() is used to manipulate the head itself.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIQueueHeader_AddConsumerHead(VMCIQueueHeader *qHeader, // IN/OUT:
+                                size_t add,               // IN:
+                                uint64 queueSize)         // IN:
+{
+   QPAddPointer(&qHeader->consumerHead, add, queueSize);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_CheckAlignment --
+ *
+ *      Checks if the given queue is aligned to page boundary.  Returns TRUE if
+ *      the alignment is good.
+ *
+ * Results:
+ *      TRUE or FALSE.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE Bool
+VMCIQueueHeader_CheckAlignment(const VMCIQueueHeader *qHeader) // IN:
+{
+   uintptr_t hdr, offset;
+
+   hdr = (uintptr_t) qHeader;
+   offset = hdr & (PAGE_SIZE -1);
+
+   return offset == 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_GetPointers --
+ *
+ *      Helper routine for getting the head and the tail pointer for a queue.
+ *      Both the VMCIQueues are needed to get both the pointers for one queue.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIQueueHeader_GetPointers(const VMCIQueueHeader *produceQHeader, // IN:
+                            const VMCIQueueHeader *consumeQHeader, // IN:
+                            uint64 *producerTail,                  // OUT:
+                            uint64 *consumerHead)                  // OUT:
+{
+   if (producerTail) {
+      *producerTail = VMCIQueueHeader_ProducerTail(produceQHeader);
+   }
+
+   if (consumerHead) {
+      *consumerHead = VMCIQueueHeader_ConsumerHead(consumeQHeader);
+   }
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_ResetPointers --
+ *
+ *      Reset the tail pointer (of "this" queue) and the head pointer (of
+ *      "peer" queue).
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIQueueHeader_ResetPointers(VMCIQueueHeader *qHeader) // IN/OUT:
+{
+   QPAtomic_WriteOffset(&qHeader->producerTail, CONST64U(0));
+   QPAtomic_WriteOffset(&qHeader->consumerHead, CONST64U(0));
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_Init --
+ *
+ *      Initializes a queue's state (head & tail pointers).
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIQueueHeader_Init(VMCIQueueHeader *qHeader, // IN/OUT:
+                     const VMCIHandle handle)  // IN:
+{
+   qHeader->handle = handle;
+   VMCIQueueHeader_ResetPointers(qHeader);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_FreeSpace --
+ *
+ *      Finds available free space in a produce queue to enqueue more
+ *      data or reports an error if queue pair corruption is detected.
+ *
+ * Results:
+ *      Free space size in bytes or an error code.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE int64
+VMCIQueueHeader_FreeSpace(const VMCIQueueHeader *produceQHeader, // IN:
+                          const VMCIQueueHeader *consumeQHeader, // IN:
+                          const uint64 produceQSize)             // IN:
+{
+   uint64 tail;
+   uint64 head;
+   uint64 freeSpace;
+
+   tail = VMCIQueueHeader_ProducerTail(produceQHeader);
+   head = VMCIQueueHeader_ConsumerHead(consumeQHeader);
+
+   if (tail >= produceQSize || head >= produceQSize) {
+      return VMCI_ERROR_INVALID_SIZE;
+   }
+
+   /*
+    * Deduct 1 to avoid tail becoming equal to head which causes ambiguity. If
+    * head and tail are equal it means that the queue is empty.
+    */
+
+   if (tail >= head) {
+      freeSpace = produceQSize - (tail - head) - 1;
+   } else {
+      freeSpace = head - tail - 1;
+   }
+
+   return freeSpace;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIQueueHeader_BufReady --
+ *
+ *      VMCIQueueHeader_FreeSpace() does all the heavy lifting of
+ *      determing the number of free bytes in a Queue.  This routine,
+ *      then subtracts that size from the full size of the Queue so
+ *      the caller knows how many bytes are ready to be dequeued.
+ *
+ * Results:
+ *      On success, available data size in bytes (up to MAX_INT64).
+ *      On failure, appropriate error code.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE int64
+VMCIQueueHeader_BufReady(const VMCIQueueHeader *consumeQHeader, // IN:
+                         const VMCIQueueHeader *produceQHeader, // IN:
+                         const uint64 consumeQSize)             // IN:
+{
+   int64 freeSpace;
+
+   freeSpace = VMCIQueueHeader_FreeSpace(consumeQHeader,
+                                         produceQHeader,
+                                         consumeQSize);
+   if (freeSpace < VMCI_SUCCESS) {
+      return freeSpace;
+   } else {
+      return consumeQSize - freeSpace - 1;
+   }
+}
+
+
+#endif
+

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_iocontrols.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_iocontrols.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_iocontrols.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,752 @@
+/*********************************************************
+ * 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
+ *
+ *********************************************************/
+
+
+/*
+ * vmci_iocontrols.h
+ *
+ *        The VMCI driver io controls.
+ */
+
+#ifndef _VMCI_IOCONTROLS_H_
+#define _VMCI_IOCONTROLS_H_
+
+#define INCLUDE_ALLOW_USERLEVEL
+#define INCLUDE_ALLOW_VMCORE
+#define INCLUDE_ALLOW_MODULE
+#define INCLUDE_ALLOW_VMKERNEL
+#include "includeCheck.h"
+
+#include "vm_assert.h"
+#include "vmci_defs.h"
+
+#if defined(_WIN32) && defined(WINNT_DDK)
+/* We need to expose the API through an IOCTL on Windows.  Use latest API. */
+#include "vmciKernelAPI.h"
+#endif // _WIN32 && WINNT_DDK
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIVA64ToPtr --
+ *
+ *      Convert a VA64 to a pointer.
+ *
+ * Results:
+ *      Virtual address.
+ *
+ * Side effects:
+ *      None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE void *
+VMCIVA64ToPtr(VA64 va64) // IN
+{
+#ifdef VM_X86_64
+   ASSERT_ON_COMPILE(sizeof (void *) == 8);
+#else
+   ASSERT_ON_COMPILE(sizeof (void *) == 4);
+   // Check that nothing of value will be lost.
+   ASSERT(!(va64 >> 32));
+#endif
+   return (void *)(uintptr_t)va64;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIPtrToVA64 --
+ *
+ *      Convert a pointer to a VA64.
+ *
+ * Results:
+ *      Virtual address.
+ *
+ * Side effects:
+ *      None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE VA64
+VMCIPtrToVA64(void const *ptr) // IN
+{
+   ASSERT_ON_COMPILE(sizeof ptr <= sizeof (VA64));
+   return (VA64)(uintptr_t)ptr;
+}
+
+
+/*
+ * Driver version.
+ *
+ * Increment major version when you make an incompatible change.
+ * Compatibility goes both ways (old driver with new executable
+ * as well as new driver with old executable).
+ */
+
+#define VMCI_VERSION_SHIFT_WIDTH   16 /* Never change this. */
+#define VMCI_MAKE_VERSION(_major, _minor)    ((_major) <<                \
+                                              VMCI_VERSION_SHIFT_WIDTH | \
+                                              (uint16) (_minor))
+#define VMCI_VERSION_MAJOR(v)  ((uint32) (v) >> VMCI_VERSION_SHIFT_WIDTH)
+#define VMCI_VERSION_MINOR(v)  ((uint16) (v))
+
+/*
+ * VMCI_VERSION is always the current version.  Subsequently listed
+ * versions are ways of detecting previous versions of the connecting
+ * application (i.e., VMX).
+ *
+ * VMCI_VERSION_NOVMVM: This version removed support for VM to VM
+ * communication.
+ *
+ * VMCI_VERSION_NOTIFY: This version introduced doorbell notification
+ * support.
+ *
+ * VMCI_VERSION_HOSTQP: This version introduced host end point support
+ * for hosted products.
+ *
+ * VMCI_VERSION_PREHOSTQP: This is the version prior to the adoption of
+ * support for host end-points.
+ *
+ * VMCI_VERSION_PREVERS2: This fictional version number is intended to
+ * represent the version of a VMX which doesn't call into the driver
+ * with ioctl VERSION2 and thus doesn't establish its version with the
+ * driver.
+ */
+
+#define VMCI_VERSION                VMCI_VERSION_NOVMVM
+#define VMCI_VERSION_NOVMVM         VMCI_MAKE_VERSION(11, 0)
+#define VMCI_VERSION_NOTIFY         VMCI_MAKE_VERSION(10, 0)
+#define VMCI_VERSION_HOSTQP         VMCI_MAKE_VERSION(9, 0)
+#define VMCI_VERSION_PREHOSTQP      VMCI_MAKE_VERSION(8, 0)
+#define VMCI_VERSION_PREVERS2       VMCI_MAKE_VERSION(1, 0)
+
+/*
+ * VMCISockets driver version.  The version is platform-dependent and is
+ * embedded in vsock_version.h for each platform.  It can be obtained via
+ * VMCISock_Version() (which uses IOCTL_VMCI_SOCKETS_VERSION).  The
+ * following is simply for constructing an unsigned integer value from the
+ * comma-separated version in the header.  This must match the macros defined
+ * in vmci_sockets.h.  An example of using this is:
+ * uint16 parts[4] = { VSOCK_DRIVER_VERSION_COMMAS };
+ * uint32 version = VMCI_SOCKETS_MAKE_VERSION(parts);
+ */
+
+#define VMCI_SOCKETS_MAKE_VERSION(_p) \
+   ((((_p)[0] & 0xFF) << 24) | (((_p)[1] & 0xFF) << 16) | ((_p)[2]))
+
+#if defined(__linux__) || defined(SOLARIS) || defined(VMKERNEL)
+/*
+ * Linux defines _IO* macros, but the core kernel code ignore the encoded
+ * ioctl value. It is up to individual drivers to decode the value (for
+ * example to look at the size of a structure to determine which version
+ * of a specific command should be used) or not (which is what we
+ * currently do, so right now the ioctl value for a given command is the
+ * command itself).
+ *
+ * Hence, we just define the IOCTL_VMCI_foo values directly, with no
+ * intermediate IOCTLCMD_ representation.
+ */
+#  define IOCTLCMD(_cmd) IOCTL_VMCI_ ## _cmd
+#elif defined (__APPLE__)
+#include <sys/ioccom.h>
+#define IOCTLCMD(_cmd) IOCTL_VMCI_ ## _cmd
+#define IOCTLCMD_I(_cmd, _type) \
+   IOCTL_VMCI_MACOS_ ## _cmd = _IOW('V', IOCTL_VMCI_ ## _cmd, _type)
+#define IOCTLCMD_O(_cmd, _type) \
+   IOCTL_VMCI_MACOS_ ## _cmd = _IOR('V', IOCTL_VMCI_ ## _cmd, _type)
+#define IOCTLCMD_IO(_cmd, _type) \
+   IOCTL_VMCI_MACOS_ ## _cmd = _IOWR('V', IOCTL_VMCI_ ## _cmd, _type)
+#else // if defined(__linux__)
+/*
+ * On platforms other than Linux, IOCTLCMD_foo values are just numbers, and
+ * we build the IOCTL_VMCI_foo values around these using platform-specific
+ * format for encoding arguments and sizes.
+ */
+#  define IOCTLCMD(_cmd) IOCTLCMD_VMCI_ ## _cmd
+#endif
+
+
+enum IOCTLCmd_VMCI {
+   /*
+    * We need to bracket the range of values used for ioctls, because x86_64
+    * Linux forces us to explicitly register ioctl handlers by value for
+    * handling 32 bit ioctl syscalls.  Hence FIRST and LAST.  Pick something
+    * for FIRST that doesn't collide with vmmon (2001+).
+    */
+#if defined(__linux__)
+   IOCTLCMD(FIRST) = 1951,
+#else
+   /* Start at 0. */
+   IOCTLCMD(FIRST),
+#endif
+   IOCTLCMD(VERSION) = IOCTLCMD(FIRST),
+
+   /* BEGIN VMCI */
+   IOCTLCMD(INIT_CONTEXT),
+
+   /*
+    * The following two were used for process and datagram process creation.
+    * They are not used anymore and reserved for future use.
+    * They will fail if issued.
+    */
+   IOCTLCMD(RESERVED1),
+   IOCTLCMD(RESERVED2),
+
+   /*
+    * The following used to be for shared memory. It is now unused and and is
+    * reserved for future use. It will fail if issued.
+    */
+   IOCTLCMD(RESERVED3),
+
+   /*
+    * The follwoing three were also used to be for shared memory. An
+    * old WS6 user-mode client might try to use them with the new
+    * driver, but since we ensure that only contexts created by VMX'en
+    * of the appropriate version (VMCI_VERSION_NOTIFY or
+    * VMCI_VERSION_NEWQP) or higher use these ioctl, everything is
+    * fine.
+    */
+   IOCTLCMD(QUEUEPAIR_SETVA),
+   IOCTLCMD(NOTIFY_RESOURCE),
+   IOCTLCMD(NOTIFICATIONS_RECEIVE),
+   IOCTLCMD(VERSION2),
+   IOCTLCMD(QUEUEPAIR_ALLOC),
+   IOCTLCMD(QUEUEPAIR_SETPAGEFILE),
+   IOCTLCMD(QUEUEPAIR_DETACH),
+   IOCTLCMD(DATAGRAM_SEND),
+   IOCTLCMD(DATAGRAM_RECEIVE),
+   IOCTLCMD(DATAGRAM_REQUEST_MAP),
+   IOCTLCMD(DATAGRAM_REMOVE_MAP),
+   IOCTLCMD(CTX_ADD_NOTIFICATION),
+   IOCTLCMD(CTX_REMOVE_NOTIFICATION),
+   IOCTLCMD(CTX_GET_CPT_STATE),
+   IOCTLCMD(CTX_SET_CPT_STATE),
+   IOCTLCMD(GET_CONTEXT_ID),
+   /* END VMCI */
+
+   /*
+    * BEGIN VMCI SOCKETS
+    *
+    * We mark the end of the vmci commands and the start of the vmci sockets
+    * commands since they are used in separate modules on Linux.
+    * */
+   IOCTLCMD(LAST),
+   IOCTLCMD(SOCKETS_FIRST) = IOCTLCMD(LAST),
+
+   /*
+    * This used to be for accept() on Windows and Mac OS, which is now
+    * redundant (since we now use real handles).  It is used instead for
+    * getting the version.  This value is now public, so it cannot change.
+    */
+   IOCTLCMD(SOCKETS_VERSION) = IOCTLCMD(SOCKETS_FIRST),
+   IOCTLCMD(SOCKETS_BIND),
+
+   /*
+    * This used to be for close() on Windows and Mac OS, but is no longer
+    * used for the same reason as accept() above.  It is used instead for
+    * sending private symbols to the Mac OS driver.
+    */
+   IOCTLCMD(SOCKETS_SET_SYMBOLS),
+   IOCTLCMD(SOCKETS_CONNECT),
+
+   /*
+    * The next two values are public (vmci_sockets.h) and cannot be changed.
+    * That means the number of values above these cannot be changed either
+    * unless the base index (specified below) is updated accordingly.
+    */
+   IOCTLCMD(SOCKETS_GET_AF_VALUE),
+   IOCTLCMD(SOCKETS_GET_LOCAL_CID),
+   IOCTLCMD(SOCKETS_GET_SOCK_NAME),
+   IOCTLCMD(SOCKETS_GET_SOCK_OPT),
+   IOCTLCMD(SOCKETS_GET_VM_BY_NAME),
+   IOCTLCMD(SOCKETS_IOCTL),
+   IOCTLCMD(SOCKETS_LISTEN),
+   IOCTLCMD(SOCKETS_RECV),
+   IOCTLCMD(SOCKETS_RECV_FROM),
+   IOCTLCMD(SOCKETS_SELECT),
+   IOCTLCMD(SOCKETS_SEND),
+   IOCTLCMD(SOCKETS_SEND_TO),
+   IOCTLCMD(SOCKETS_SET_SOCK_OPT),
+   IOCTLCMD(SOCKETS_SHUTDOWN),
+   IOCTLCMD(SOCKETS_SOCKET), /* 1990 on Linux. */
+   /* END VMCI SOCKETS */
+
+   /*
+    * We reserve a range of 4 ioctls for VMCI Sockets to grow.  We cannot
+    * reserve many ioctls here since we are close to overlapping with vmmon
+    * ioctls.  Define a meta-ioctl if running out of this binary space.
+    */
+   // Must be last.
+   IOCTLCMD(SOCKETS_LAST) = IOCTLCMD(SOCKETS_SOCKET) + 4, /* 1994 on Linux. */
+   /*
+    * The VSockets ioctls occupy the block above.  We define a new range of
+    * VMCI ioctls to maintain binary compatibility between the user land and
+    * the kernel driver.  Careful, vmmon ioctls start from 2001, so this means
+    * we can add only 4 new VMCI ioctls.  Define a meta-ioctl if running out of
+    * this binary space.
+    */
+
+   IOCTLCMD(FIRST2),
+   IOCTLCMD(SET_NOTIFY) = IOCTLCMD(FIRST2), /* 1995 on Linux. */
+   IOCTLCMD(LAST2),
+};
+
+#if defined (__APPLE__)
+/*
+ * The size of this must match the size of VSockIoctlPrivSyms in
+ * modules/vsock/common/vsockIoctl.h.
+ */
+#include "vmware_pack_begin.h"
+struct IOCTLCmd_VMCIMacOS_PrivSyms {
+   char data[328];
+}
+#include "vmware_pack_end.h"
+;
+enum IOCTLCmd_VMCIMacOS {
+   IOCTLCMD_I(SOCKETS_SET_SYMBOLS, struct IOCTLCmd_VMCIMacOS_PrivSyms),
+   IOCTLCMD_O(SOCKETS_VERSION, unsigned int),
+   IOCTLCMD_O(SOCKETS_GET_AF_VALUE, int),
+   IOCTLCMD_O(SOCKETS_GET_LOCAL_CID, unsigned int),
+};
+#endif // __APPLE__
+
+
+#if defined _WIN32
+/*
+ * Windows VMCI ioctl definitions.
+ */
+
+/* PUBLIC: For VMCISockets user-mode clients that use CreateFile(). */
+#define VMCI_INTERFACE_VSOCK_PUBLIC_NAME TEXT("\\\\.\\VMCI")
+
+/* PUBLIC: For VMCISockets user-mode clients that use NtCreateFile(). */
+#define VMCI_INTERFACE_VSOCK_PUBLIC_NAME_NT L"\\??\\VMCI"
+
+/* PUBLIC: For the VMX, which uses CreateFile(). */
+#define VMCI_INTERFACE_VMX_PUBLIC_NAME TEXT("\\\\.\\VMCIDev\\VMX")
+
+/* PRIVATE NAMES */
+#define VMCI_DEVICE_VMCI_LINK_PATH  L"\\DosDevices\\VMCIDev"
+#define VMCI_DEVICE_VSOCK_LINK_PATH L"\\DosDevices\\vmci"
+#define VMCI_DEVICE_HOST_NAME_PATH  L"\\Device\\VMCIHostDev"
+#define VMCI_DEVICE_GUEST_NAME_PATH L"\\Device\\VMCIGuestDev"
+/* PRIVATE NAMES */
+
+/* These values cannot be changed since some of the ioctl values are public. */
+#define FILE_DEVICE_VMCI      0x8103
+#define VMCI_IOCTL_BASE_INDEX 0x801
+#define VMCIIOCTL_BUFFERED(name) \
+      CTL_CODE(FILE_DEVICE_VMCI, \
+	       VMCI_IOCTL_BASE_INDEX + IOCTLCMD_VMCI_ ## name, \
+	       METHOD_BUFFERED, \
+	       FILE_ANY_ACCESS)
+#define VMCIIOCTL_NEITHER(name) \
+      CTL_CODE(FILE_DEVICE_VMCI, \
+	       VMCI_IOCTL_BASE_INDEX + IOCTLCMD_VMCI_ ## name, \
+	       METHOD_NEITHER, \
+	       FILE_ANY_ACCESS)
+
+enum IOCTLCmd_VMCIWin32 {
+   IOCTLCMD(DEVICE_GET) = IOCTLCMD(LAST2) + 1,
+   IOCTLCMD(SOCKETS_SERVICE_GET),
+   IOCTLCMD(SOCKETS_STOP),
+};
+
+#define IOCTL_VMCI_VERSION VMCIIOCTL_BUFFERED(VERSION)
+
+/* BEGIN VMCI */
+#define IOCTL_VMCI_INIT_CONTEXT \
+               VMCIIOCTL_BUFFERED(INIT_CONTEXT)
+#define IOCTL_VMCI_HYPERCALL \
+               VMCIIOCTL_BUFFERED(HYPERCALL)
+#define IOCTL_VMCI_CREATE_DATAGRAM_HANDLE  \
+               VMCIIOCTL_BUFFERED(CREATE_DATAGRAM_HANDLE)
+#define IOCTL_VMCI_DESTROY_DATAGRAM_HANDLE  \
+               VMCIIOCTL_BUFFERED(DESTROY_DATAGRAM_HANDLE)
+#define IOCTL_VMCI_NOTIFY_RESOURCE    \
+               VMCIIOCTL_BUFFERED(NOTIFY_RESOURCE)
+#define IOCTL_VMCI_NOTIFICATIONS_RECEIVE    \
+               VMCIIOCTL_BUFFERED(NOTIFICATIONS_RECEIVE)
+#define IOCTL_VMCI_VERSION2 \
+               VMCIIOCTL_BUFFERED(VERSION2)
+#define IOCTL_VMCI_QUEUEPAIR_ALLOC  \
+               VMCIIOCTL_BUFFERED(QUEUEPAIR_ALLOC)
+#define IOCTL_VMCI_QUEUEPAIR_SETVA  \
+               VMCIIOCTL_BUFFERED(QUEUEPAIR_SETVA)
+#define IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE  \
+               VMCIIOCTL_BUFFERED(QUEUEPAIR_SETPAGEFILE)
+#define IOCTL_VMCI_QUEUEPAIR_DETACH  \
+               VMCIIOCTL_BUFFERED(QUEUEPAIR_DETACH)
+#define IOCTL_VMCI_DATAGRAM_SEND \
+               VMCIIOCTL_BUFFERED(DATAGRAM_SEND)
+#define IOCTL_VMCI_DATAGRAM_RECEIVE \
+               VMCIIOCTL_NEITHER(DATAGRAM_RECEIVE)
+#define IOCTL_VMCI_DATAGRAM_REQUEST_MAP \
+               VMCIIOCTL_BUFFERED(DATAGRAM_REQUEST_MAP)
+#define IOCTL_VMCI_DATAGRAM_REMOVE_MAP \
+               VMCIIOCTL_BUFFERED(DATAGRAM_REMOVE_MAP)
+#define IOCTL_VMCI_CTX_ADD_NOTIFICATION \
+               VMCIIOCTL_BUFFERED(CTX_ADD_NOTIFICATION)
+#define IOCTL_VMCI_CTX_REMOVE_NOTIFICATION \
+               VMCIIOCTL_BUFFERED(CTX_REMOVE_NOTIFICATION)
+#define IOCTL_VMCI_CTX_GET_CPT_STATE \
+               VMCIIOCTL_BUFFERED(CTX_GET_CPT_STATE)
+#define IOCTL_VMCI_CTX_SET_CPT_STATE \
+               VMCIIOCTL_BUFFERED(CTX_SET_CPT_STATE)
+#define IOCTL_VMCI_GET_CONTEXT_ID    \
+               VMCIIOCTL_BUFFERED(GET_CONTEXT_ID)
+#define IOCTL_VMCI_DEVICE_GET \
+               VMCIIOCTL_BUFFERED(DEVICE_GET)
+/* END VMCI */
+
+/* BEGIN VMCI SOCKETS */
+#define IOCTL_VMCI_SOCKETS_VERSION \
+               VMCIIOCTL_BUFFERED(SOCKETS_VERSION)
+#define IOCTL_VMCI_SOCKETS_BIND \
+               VMCIIOCTL_BUFFERED(SOCKETS_BIND)
+#define IOCTL_VMCI_SOCKETS_CONNECT \
+               VMCIIOCTL_BUFFERED(SOCKETS_CONNECT)
+#define IOCTL_VMCI_SOCKETS_GET_AF_VALUE \
+               VMCIIOCTL_BUFFERED(SOCKETS_GET_AF_VALUE)
+#define IOCTL_VMCI_SOCKETS_GET_LOCAL_CID \
+               VMCIIOCTL_BUFFERED(SOCKETS_GET_LOCAL_CID)
+#define IOCTL_VMCI_SOCKETS_GET_SOCK_NAME \
+               VMCIIOCTL_BUFFERED(SOCKETS_GET_SOCK_NAME)
+#define IOCTL_VMCI_SOCKETS_GET_SOCK_OPT \
+               VMCIIOCTL_BUFFERED(SOCKETS_GET_SOCK_OPT)
+#define IOCTL_VMCI_SOCKETS_GET_VM_BY_NAME \
+               VMCIIOCTL_BUFFERED(SOCKETS_GET_VM_BY_NAME)
+#define IOCTL_VMCI_SOCKETS_IOCTL \
+               VMCIIOCTL_BUFFERED(SOCKETS_IOCTL)
+#define IOCTL_VMCI_SOCKETS_LISTEN \
+               VMCIIOCTL_BUFFERED(SOCKETS_LISTEN)
+#define IOCTL_VMCI_SOCKETS_RECV_FROM \
+               VMCIIOCTL_BUFFERED(SOCKETS_RECV_FROM)
+#define IOCTL_VMCI_SOCKETS_SELECT \
+               VMCIIOCTL_BUFFERED(SOCKETS_SELECT)
+#define IOCTL_VMCI_SOCKETS_SEND_TO \
+               VMCIIOCTL_BUFFERED(SOCKETS_SEND_TO)
+#define IOCTL_VMCI_SOCKETS_SET_SOCK_OPT \
+               VMCIIOCTL_BUFFERED(SOCKETS_SET_SOCK_OPT)
+#define IOCTL_VMCI_SOCKETS_SHUTDOWN \
+               VMCIIOCTL_BUFFERED(SOCKETS_SHUTDOWN)
+#define IOCTL_VMCI_SOCKETS_SERVICE_GET \
+               VMCIIOCTL_BUFFERED(SOCKETS_SERVICE_GET)
+#define IOCTL_VMCI_SOCKETS_STOP \
+               VMCIIOCTL_NEITHER(SOCKETS_STOP)
+/* END VMCI SOCKETS */
+
+#endif // _WIN32
+
+
+/*
+ * VMCI driver initialization. This block can also be used to
+ * pass initial group membership etc.
+ */
+typedef struct VMCIInitBlock {
+   VMCIId             cid;
+   VMCIPrivilegeFlags flags;
+#ifdef _WIN32
+   uint64             event; /* Handle for signalling vmci calls on windows. */
+#endif // _WIN32
+} VMCIInitBlock;
+
+typedef struct VMCISharedMemInfo {
+   VMCIHandle handle;
+   uint32     size;
+   uint32     result;
+   VA64       va; /* Currently only used in the guest. */
+   char       pageFileName[VMCI_PATH_MAX];
+} VMCISharedMemInfo;
+
+typedef struct VMCIQueuePairAllocInfo_VMToVM {
+   VMCIHandle handle;
+   VMCIId     peer;
+   uint32     flags;
+   uint64     produceSize;
+   uint64     consumeSize;
+#if !defined(VMX86_SERVER) && !defined(VMKERNEL)
+   VA64       producePageFile; /* User VA. */
+   VA64       consumePageFile; /* User VA. */
+   uint64     producePageFileSize; /* Size of the file name array. */
+   uint64     consumePageFileSize; /* Size of the file name array. */
+#else
+   PPN *      PPNs;
+   uint64     numPPNs;
+#endif
+   int32      result;
+   uint32     _pad;
+} VMCIQueuePairAllocInfo_VMToVM;
+
+typedef struct VMCIQueuePairAllocInfo {
+   VMCIHandle handle;
+   VMCIId     peer;
+   uint32     flags;
+   uint64     produceSize;
+   uint64     consumeSize;
+#if !defined(VMX86_SERVER) && !defined(VMKERNEL)
+   VA64       ppnVA; /* Start VA of queue pair PPNs. */
+#else
+   PPN *      PPNs;
+#endif
+   uint64     numPPNs;
+   int32      result;
+   uint32     version;
+} VMCIQueuePairAllocInfo;
+
+typedef struct VMCIQueuePairSetVAInfo {
+   VMCIHandle handle;
+   VA64       va; /* Start VA of queue pair PPNs. */
+   uint64     numPPNs;
+   uint32     version;
+   int32      result;
+} VMCIQueuePairSetVAInfo;
+
+/*
+ * For backwards compatibility, here is a version of the
+ * VMCIQueuePairPageFileInfo before host support end-points was added.
+ * Note that the current version of that structure requires VMX to
+ * pass down the VA of the mapped file.  Before host support was added
+ * there was nothing of the sort.  So, when the driver sees the ioctl
+ * with a parameter that is the sizeof
+ * VMCIQueuePairPageFileInfo_NoHostQP then it can infer that the version
+ * of VMX running can't attach to host end points because it doesn't
+ * provide the VA of the mapped files.
+ *
+ * The Linux driver doesn't get an indication of the size of the
+ * structure passed down from user space.  So, to fix a long standing
+ * but unfiled bug, the _pad field has been renamed to version.
+ * Existing versions of VMX always initialize the PageFileInfo
+ * structure so that _pad, er, version is set to 0.
+ *
+ * A version value of 1 indicates that the size of the structure has
+ * been increased to include two UVA's: produceUVA and consumeUVA.
+ * These UVA's are of the mmap()'d queue contents backing files.
+ *
+ * In addition, if when VMX is sending down the
+ * VMCIQueuePairPageFileInfo structure it gets an error then it will
+ * try again with the _NoHostQP version of the file to see if an older
+ * VMCI kernel module is running.
+ */
+typedef struct VMCIQueuePairPageFileInfo_NoHostQP {
+   VMCIHandle handle;
+   VA64       producePageFile; /* User VA. */
+   VA64       consumePageFile; /* User VA. */
+   uint64     producePageFileSize; /* Size of the file name array. */
+   uint64     consumePageFileSize; /* Size of the file name array. */
+   int32      result;
+   uint32     version;         /* Was _pad. Must be 0. */
+} VMCIQueuePairPageFileInfo_NoHostQP;
+
+typedef struct VMCIQueuePairPageFileInfo {
+   VMCIHandle handle;
+#if !defined(VMX86_SERVER) && !defined(VMKERNEL)
+   VA64       producePageFile; /* User VA. */
+   VA64       consumePageFile; /* User VA. */
+   uint64     producePageFileSize; /* Size of the file name array. */
+   uint64     consumePageFileSize; /* Size of the file name array. */
+#endif
+   int32      result;
+   uint32     version;   /* Was _pad. */
+   VA64       produceVA; /* User VA of the mapped file. */
+   VA64       consumeVA; /* User VA of the mapped file. */
+} VMCIQueuePairPageFileInfo;
+
+typedef struct VMCIQueuePairDetachInfo {
+   VMCIHandle handle;
+   int32      result;
+   uint32     _pad;
+} VMCIQueuePairDetachInfo;
+
+typedef struct VMCIDatagramSendRecvInfo {
+   VA64   addr;
+   uint32 len;
+   int32  result;
+} VMCIDatagramSendRecvInfo;
+
+/* Used to add/remove well-known datagram mappings. */
+typedef struct VMCIDatagramMapInfo {
+   VMCIId      wellKnownID;
+   int         result;
+} VMCIDatagramMapInfo;
+
+/* Used to add/remove remote context notifications. */
+typedef struct VMCINotifyAddRemoveInfo {
+   VMCIId      remoteCID;
+   int         result;
+} VMCINotifyAddRemoveInfo;
+
+/* Used to set/get current context's checkpoint state. */
+typedef struct VMCICptBufInfo {
+   VA64        cptBuf;
+   uint32      cptType;
+   uint32      bufSize;
+   int32       result;
+   uint32      _pad;
+} VMCICptBufInfo;
+
+/* Used to pass notify flag's address to the host driver. */
+typedef struct VMCISetNotifyInfo {
+   VA64        notifyUVA;
+   int32       result;
+   uint32      _pad;
+} VMCISetNotifyInfo;
+
+#define VMCI_NOTIFY_RESOURCE_QUEUE_PAIR 0
+#define VMCI_NOTIFY_RESOURCE_DOOR_BELL  1
+
+#define VMCI_NOTIFY_RESOURCE_ACTION_NOTIFY  0
+#define VMCI_NOTIFY_RESOURCE_ACTION_CREATE  1
+#define VMCI_NOTIFY_RESOURCE_ACTION_DESTROY 2
+
+/*
+ * Used to create and destroy doorbells, and generate a notification
+ * for a doorbell or queue pair.
+ */
+
+typedef struct VMCINotifyResourceInfo {
+   VMCIHandle  handle;
+   uint16      resource;
+   uint16      action;
+   int32       result;
+} VMCINotifyResourceInfo;
+
+/*
+ * Used to recieve pending notifications for doorbells and queue
+ * pairs.
+ */
+
+typedef struct VMCINotificationReceiveInfo {
+   VA64        dbHandleBufUVA;
+   uint64      dbHandleBufSize;
+   VA64        qpHandleBufUVA;
+   uint64      qpHandleBufSize;
+   int32       result;
+   uint32      _pad;
+} VMCINotificationReceiveInfo;
+
+#if defined(_WIN32) && defined(WINNT_DDK)
+/*
+ * Used on Windows to expose the API calls that are no longer exported.  This
+ * is kernel-mode only, and both sides will have the same bitness, so we can
+ * use pointers directly.
+ */
+
+/* Version 1. */
+typedef struct VMCIDeviceGetInfoVer1 {
+   VMCI_DeviceReleaseFct *deviceRelease;
+   VMCIDatagram_CreateHndFct *dgramCreateHnd;
+   VMCIDatagram_CreateHndPrivFct *dgramCreateHndPriv;
+   VMCIDatagram_DestroyHndFct *dgramDestroyHnd;
+   VMCIDatagram_SendFct *dgramSend;
+   VMCI_GetContextIDFct *getContextId;
+   VMCI_VersionFct *version;
+   VMCIEvent_SubscribeFct *eventSubscribe;
+   VMCIEvent_UnsubscribeFct *eventUnsubscribe;
+   VMCIQPair_AllocFct *qpairAlloc;
+   VMCIQPair_DetachFct *qpairDetach;
+   VMCIQPair_GetProduceIndexesFct *qpairGetProduceIndexes;
+   VMCIQPair_GetConsumeIndexesFct *qpairGetConsumeIndexes;
+   VMCIQPair_ProduceFreeSpaceFct *qpairProduceFreeSpace;
+   VMCIQPair_ProduceBufReadyFct *qpairProduceBufReady;
+   VMCIQPair_ConsumeFreeSpaceFct *qpairConsumeFreeSpace;
+   VMCIQPair_ConsumeBufReadyFct *qpairConsumeBufReady;
+   VMCIQPair_EnqueueFct *qpairEnqueue;
+   VMCIQPair_DequeueFct *qpairDequeue;
+   VMCIQPair_PeekFct *qpairPeek;
+   VMCIQPair_EnqueueVFct *qpairEnqueueV;
+   VMCIQPair_DequeueVFct *qpairDequeueV;
+   VMCIQPair_PeekVFct *qpairPeekV;
+   VMCI_ContextID2HostVmIDFct *contextID2HostVmID;
+   VMCI_IsContextOwnerFct *isContextOwner;
+   VMCIContext_GetPrivFlagsFct *contextGetPrivFlags;
+} VMCIDeviceGetInfoVer1;
+
+/* Version 2. */
+typedef struct VMCIDeviceGetInfoVer2 {
+   VMCIDoorbell_CreateFct *doorbellCreate;
+   VMCIDoorbell_DestroyFct *doorbellDestroy;
+   VMCIDoorbell_NotifyFct *doorbellNotify;
+} VMCIDeviceGetInfoVer2;
+
+typedef struct VMCIDeviceGetInfoHdr {
+   /* Requested API version on input, supported version on output. */
+   uint32 apiVersion;
+   VMCI_DeviceShutdownFn *deviceShutdownCB;
+   void *userData;
+   void *deviceRegistration;
+} VMCIDeviceGetInfoHdr;
+
+/* Combination of all versions. */
+typedef struct VMCIDeviceGetInfo {
+   VMCIDeviceGetInfoHdr hdr;
+   VMCIDeviceGetInfoVer1 ver1;
+   VMCIDeviceGetInfoVer2 ver2;
+} VMCIDeviceGetInfo;
+#endif // _WIN32 && WINNT_DDK
+
+
+#ifdef __APPLE__
+/*
+ * Mac OS ioctl definitions.
+ *
+ * Mac OS defines _IO* macros, and the core kernel code uses the size encoded
+ * in the ioctl value to copy the memory back and forth (depending on the
+ * direction encoded in the ioctl value) between the user and kernel address
+ * spaces.
+ * See iocontrolsMacOS.h for details on how this is done. We use sockets only
+ * for vmci.
+ */
+
+#include <sys/ioccom.h>
+
+enum VMCrossTalkSockOpt {
+   VMCI_SO_VERSION = 0,
+   VMCI_SO_CONTEXT                  = IOCTL_VMCI_INIT_CONTEXT,
+   VMCI_SO_NOTIFY_RESOURCE          = IOCTL_VMCI_NOTIFY_RESOURCE,
+   VMCI_SO_NOTIFICATIONS_RECEIVE    = IOCTL_VMCI_NOTIFICATIONS_RECEIVE,
+   VMCI_SO_VERSION2                 = IOCTL_VMCI_VERSION2,
+   VMCI_SO_QUEUEPAIR_ALLOC          = IOCTL_VMCI_QUEUEPAIR_ALLOC,
+   VMCI_SO_QUEUEPAIR_SETVA          = IOCTL_VMCI_QUEUEPAIR_SETVA,
+   VMCI_SO_QUEUEPAIR_SETPAGEFILE    = IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE,
+   VMCI_SO_QUEUEPAIR_DETACH         = IOCTL_VMCI_QUEUEPAIR_DETACH,
+   VMCI_SO_DATAGRAM_SEND            = IOCTL_VMCI_DATAGRAM_SEND,
+   VMCI_SO_DATAGRAM_RECEIVE         = IOCTL_VMCI_DATAGRAM_RECEIVE,
+   VMCI_SO_DATAGRAM_REQUEST_MAP     = IOCTL_VMCI_DATAGRAM_REQUEST_MAP,
+   VMCI_SO_DATAGRAM_REMOVE_MAP      = IOCTL_VMCI_DATAGRAM_REMOVE_MAP,
+   VMCI_SO_CTX_ADD_NOTIFICATION     = IOCTL_VMCI_CTX_ADD_NOTIFICATION,
+   VMCI_SO_CTX_REMOVE_NOTIFICATION  = IOCTL_VMCI_CTX_REMOVE_NOTIFICATION,
+   VMCI_SO_CTX_GET_CPT_STATE        = IOCTL_VMCI_CTX_GET_CPT_STATE,
+   VMCI_SO_CTX_SET_CPT_STATE        = IOCTL_VMCI_CTX_SET_CPT_STATE,
+   VMCI_SO_GET_CONTEXT_ID           = IOCTL_VMCI_GET_CONTEXT_ID,
+   VMCI_SO_USERFD,
+};
+
+#define VMCI_MACOS_HOST_DEVICE "com.vmware.kext.vmci"
+
+#endif
+
+/* Clean up helper macros */
+#undef IOCTLCMD
+
+#endif // ifndef _VMCI_IOCONTROLS_H_

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_kernel_if.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_kernel_if.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/shared/vmci_kernel_if.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,462 @@
+/*********************************************************
+ * Copyright (C) 2006-2011 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
+ *
+ *********************************************************/
+
+/*
+ * vmci_kernel_if.h --
+ *
+ *      This file defines helper functions for VMCI host _and_ guest
+ *      kernel code. It must work for Windows, Mac OS, vmkernel, Linux and
+ *      Solaris kernels, i.e. using defines where necessary.
+ */
+
+#ifndef _VMCI_KERNEL_IF_H_
+#define _VMCI_KERNEL_IF_H_
+
+#if !defined(linux) && !defined(_WIN32) && !defined(__APPLE__) && \
+    !defined(VMKERNEL) && !defined(SOLARIS)
+#  error "Platform not supported."
+#endif
+
+#if defined(_WIN32)
+#  include <ntddk.h>
+#endif
+
+#if defined(linux) && !defined(VMKERNEL)
+#  include "driver-config.h"
+#  include "compat_cred.h"
+#  include "compat_module.h"
+#  include "compat_semaphore.h"
+#  include "compat_spinlock.h"
+#  include "compat_version.h"
+#  include <linux/wait.h>
+#endif // linux
+
+#ifdef __APPLE__
+#  include <IOKit/IOLib.h>
+#  include <mach/task.h>
+#  include <mach/semaphore.h>
+#  include <sys/kauth.h>
+#endif
+
+#ifdef VMKERNEL
+#  include "splock.h"
+#  include "semaphore_ext.h"
+#  include "vmkapi.h"
+#  include "world_dist.h"
+#endif
+
+#ifdef SOLARIS
+#  include <sys/ddi.h>
+#  include <sys/kmem.h>
+#  include <sys/mutex.h>
+#  include <sys/poll.h>
+#  include <sys/semaphore.h>
+#  include <sys/sunddi.h>
+#  include <sys/types.h>
+#endif
+
+#include "vm_basic_types.h"
+#include "vmci_defs.h"
+
+#if defined(VMKERNEL)
+#  include "list.h"
+#else
+#  include "dbllnklst.h"
+#endif
+
+/* Flags for specifying memory type. */
+#define VMCI_MEMORY_NORMAL   0x0
+#define VMCI_MEMORY_ATOMIC   0x1
+#define VMCI_MEMORY_NONPAGED 0x2
+
+/* Platform specific type definitions. */
+
+#if defined(VMKERNEL)
+#  define VMCI_EXPORT_SYMBOL(_SYMBOL)  VMK_MODULE_EXPORT_SYMBOL(_SYMBOL);
+#elif defined(linux)
+#  define VMCI_EXPORT_SYMBOL(_symbol)  EXPORT_SYMBOL(_symbol);
+#elif defined(__APPLE__)
+#  define VMCI_EXPORT_SYMBOL(_symbol)  __attribute__((visibility("default")))
+#else
+#  define VMCI_EXPORT_SYMBOL(_symbol)
+#endif
+
+#if defined(VMKERNEL)
+  typedef SP_SpinLock VMCILock;
+  typedef SP_IRQL VMCILockFlags;
+  typedef Semaphore VMCIEvent;
+  typedef Semaphore VMCIMutex;
+  typedef World_ID VMCIHostVmID;
+  typedef uint32 VMCIHostUser;
+  typedef PPN *VMCIQPGuestMem;
+#elif defined(linux)
+  typedef spinlock_t VMCILock;
+  typedef unsigned long VMCILockFlags;
+  typedef wait_queue_head_t VMCIEvent;
+  typedef struct semaphore VMCIMutex;
+  typedef PPN *VMCIPpnList; /* List of PPNs in produce/consume queue. */
+  typedef uid_t VMCIHostUser;
+  typedef VA64 VMCIQPGuestMem;
+#elif defined(__APPLE__)
+  typedef IOLock *VMCILock;
+  typedef unsigned long VMCILockFlags;
+  typedef struct {
+     IOLock *lock;
+     DblLnkLst_Links waiters;
+     int buffered;
+  } VMCIEvent;
+  typedef IOLock *VMCIMutex;
+  typedef void *VMCIPpnList; /* Actually a pointer to the C++ Object IOMemoryDescriptor */
+  typedef uid_t VMCIHostUser;
+  typedef VA64 *VMCIQPGuestMem;
+#elif defined(_WIN32)
+  typedef KSPIN_LOCK VMCILock;
+  typedef KIRQL VMCILockFlags;
+  typedef KEVENT VMCIEvent;
+  typedef FAST_MUTEX VMCIMutex;
+  typedef PMDL VMCIPpnList; /* MDL to map the produce/consume queue. */
+  typedef PSID VMCIHostUser;
+  typedef VA64 *VMCIQPGuestMem;
+#elif defined(SOLARIS)
+  typedef kmutex_t VMCILock;
+  typedef unsigned long VMCILockFlags;
+  typedef ksema_t VMCIEvent;
+  typedef kmutex_t VMCIMutex;
+  typedef PPN *VMCIPpnList; /* List of PPNs in produce/consume queue. */
+  typedef uid_t VMCIHostUser;
+  typedef VA64 VMCIQPGuestMem;
+#endif // VMKERNEL
+
+/* Callback needed for correctly waiting on events. */
+typedef int (*VMCIEventReleaseCB)(void *clientData);
+
+/*
+ * Internal locking dependencies within VMCI:
+ * * CONTEXTFIRE < CONTEXT, CONTEXTLIST, EVENT, HASHTABLE
+ * * DOORBELL < HASHTABLE
+ * * QPHIBERNATE < EVENT
+ */
+
+#ifdef VMKERNEL
+  typedef Lock_Rank VMCILockRank;
+  typedef SemaRank VMCISemaRank;
+
+  #define VMCI_SEMA_RANK_QPHEADER       (SEMA_RANK_FS - 1)
+
+  #define VMCI_LOCK_RANK_MAX            (MIN(SP_RANK_WAIT, \
+                                             SP_RANK_HEAPLOCK_DYNAMIC) - 1)
+#else
+  typedef unsigned long VMCILockRank;
+  typedef unsigned long VMCISemaRank;
+
+  #define VMCI_LOCK_RANK_MAX            0x0fff
+
+  #define VMCI_SEMA_RANK_QPHEADER       0x0fff
+#endif // VMKERNEL
+#define VMCI_LOCK_RANK_CONTEXT          VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_CONTEXTLIST      VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_DATAGRAMVMK      VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_EVENT            VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_HASHTABLE        VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_RESOURCE         VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_QPHEADER         VMCI_LOCK_RANK_MAX
+#define VMCI_LOCK_RANK_DOORBELL         (VMCI_LOCK_RANK_HASHTABLE - 1)
+#define VMCI_LOCK_RANK_CONTEXTFIRE      (MIN(VMCI_LOCK_RANK_CONTEXT, \
+                                         MIN(VMCI_LOCK_RANK_CONTEXTLIST, \
+                                         MIN(VMCI_LOCK_RANK_EVENT, \
+                                             VMCI_LOCK_RANK_HASHTABLE))) - 1)
+#define VMCI_LOCK_RANK_QPHIBERNATE      (VMCI_LOCK_RANK_EVENT - 1)
+#define VMCI_LOCK_RANK_PACKET_QP        (VMCI_LOCK_RANK_QPHEADER - 1)
+//#define VMCI_LOCK_RANK_PACKET_QP        0xffd /* For vVol */
+
+#define VMCI_SEMA_RANK_QUEUEPAIRLIST    (VMCI_SEMA_RANK_QPHEADER - 1)
+#define VMCI_SEMA_RANK_GUESTMEM         (VMCI_SEMA_RANK_QUEUEPAIRLIST - 1)
+#define VMCI_SEMA_RANK_PACKET_QP        (VMCI_SEMA_RANK_QPHEADER - 1)
+//#define VMCI_SEMA_RANK_PACKET_QP        0xffd /* For vVol */
+
+/*
+ * Host specific struct used for signalling.
+ */
+
+typedef struct VMCIHost {
+#if defined(VMKERNEL)
+   World_ID vmmWorldID[2];   /*
+                              * First one is the active one and the second
+                              * one is shadow world during FSR.
+                              */
+#elif defined(linux)
+   wait_queue_head_t  waitQueue;
+#elif defined(__APPLE__)
+   struct Socket *socket; /* vmci Socket object on Mac OS. */
+#elif defined(_WIN32)
+   KEVENT *callEvent; /* Ptr to userlevel event used when signalling
+                       * new pending guestcalls in kernel.
+                       */
+#elif defined(SOLARIS)
+   struct pollhead pollhead; /* Per datagram handle pollhead structure to
+                              * be treated as a black-box. None of its
+                              * fields should be referenced.
+                              */
+#endif
+} VMCIHost;
+
+/*
+ * Guest device port I/O.
+ */
+
+#if defined(linux)
+   typedef unsigned short int VMCIIoPort;
+   typedef int VMCIIoHandle;
+#elif defined(_WIN32)
+   typedef PUCHAR VMCIIoPort;
+   typedef int VMCIIoHandle;
+#elif defined(SOLARIS)
+   typedef uint8_t * VMCIIoPort;
+   typedef ddi_acc_handle_t VMCIIoHandle;
+#elif defined(__APPLE__)
+   typedef unsigned short int VMCIIoPort;
+   typedef void *VMCIIoHandle;
+#endif // __APPLE__
+
+void VMCI_ReadPortBytes(VMCIIoHandle handle, VMCIIoPort port, uint8 *buffer,
+                        size_t bufferLength);
+
+
+int VMCI_InitLock(VMCILock *lock, char *name, VMCILockRank rank);
+void VMCI_CleanupLock(VMCILock *lock);
+void VMCI_GrabLock(VMCILock *lock, VMCILockFlags *flags);
+void VMCI_ReleaseLock(VMCILock *lock, VMCILockFlags flags);
+void VMCI_GrabLock_BH(VMCILock *lock, VMCILockFlags *flags);
+void VMCI_ReleaseLock_BH(VMCILock *lock, VMCILockFlags flags);
+
+void VMCIHost_InitContext(VMCIHost *hostContext, uintptr_t eventHnd);
+void VMCIHost_ReleaseContext(VMCIHost *hostContext);
+void VMCIHost_SignalCall(VMCIHost *hostContext);
+void VMCIHost_ClearCall(VMCIHost *hostContext);
+Bool VMCIHost_WaitForCallLocked(VMCIHost *hostContext,
+                                VMCILock *lock,
+                                VMCILockFlags *flags,
+                                Bool useBH);
+#ifdef VMKERNEL
+int VMCIHost_ContextToHostVmID(VMCIHost *hostContext, VMCIHostVmID *hostVmID);
+void VMCIHost_SetActiveHnd(VMCIHost *hostContext, uintptr_t eventHnd);
+Bool VMCIHost_RemoveHnd(VMCIHost *hostContext, uintptr_t eventHnd);
+Bool VMCIHost_IsActiveHnd(VMCIHost *hostContext, uintptr_t eventHnd);
+void VMCIHost_SetInactiveHnd(VMCIHost *hostContext, uintptr_t eventHnd);
+uint32 VMCIHost_NumHnds(VMCIHost *hostContext);
+uintptr_t VMCIHost_GetActiveHnd(VMCIHost *hostContext);
+void VMCIHost_SignalBitmap(VMCIHost *hostContext);
+#endif
+
+#if defined(_WIN32)
+   /*
+    * On Windows, Driver Verifier will panic() if we leak memory when we are
+    * unloaded.  It dumps the leaked blocks for us along with callsites, which
+    * it handily tracks, but if we embed ExAllocate() inside a function, then
+    * the callsite is useless.  So make this a macro on this platform only.
+    */
+#  define VMCI_AllocKernelMem(_sz, _f)                       \
+      ExAllocatePoolWithTag((((_f) & VMCI_MEMORY_NONPAGED) ? \
+                             NonPagedPool : PagedPool),      \
+                            (_sz), 'MMTC')
+#else // _WIN32
+void *VMCI_AllocKernelMem(size_t size, int flags);
+#endif // _WIN32
+void VMCI_FreeKernelMem(void *ptr, size_t size);
+
+int VMCI_CopyToUser(VA64 dst, const void *src, size_t len);
+Bool VMCIWellKnownID_AllowMap(VMCIId wellKnownID,
+                              VMCIPrivilegeFlags privFlags);
+
+int VMCIHost_CompareUser(VMCIHostUser *user1, VMCIHostUser *user2);
+
+void VMCI_CreateEvent(VMCIEvent *event);
+void VMCI_DestroyEvent(VMCIEvent *event);
+void VMCI_SignalEvent(VMCIEvent *event);
+void VMCI_WaitOnEvent(VMCIEvent *event, VMCIEventReleaseCB releaseCB,
+		      void *clientData);
+#if (defined(__APPLE__) || defined(__linux__) || defined(_WIN32)) && !defined(VMKERNEL)
+Bool VMCI_WaitOnEventInterruptible(VMCIEvent *event,
+                                   VMCIEventReleaseCB releaseCB,
+                                   void *clientData);
+#endif
+
+#if !defined(VMKERNEL) && (defined(__linux__) || defined(_WIN32) || \
+                           defined(__APPLE__) || defined(SOLARIS))
+int VMCI_CopyFromUser(void *dst, VA64 src, size_t len);
+#endif
+
+typedef void (VMCIWorkFn)(void *data);
+Bool VMCI_CanScheduleDelayedWork(void);
+int VMCI_ScheduleDelayedWork(VMCIWorkFn *workFn, void *data);
+
+int VMCIMutex_Init(VMCIMutex *mutex, char *name, VMCILockRank rank);
+void VMCIMutex_Destroy(VMCIMutex *mutex);
+void VMCIMutex_Acquire(VMCIMutex *mutex);
+void VMCIMutex_Release(VMCIMutex *mutex);
+
+#if defined(SOLARIS) || defined(_WIN32) || defined(__APPLE__)
+int VMCIKernelIf_Init(void);
+void VMCIKernelIf_Exit(void);
+#if defined(_WIN32)
+void VMCIKernelIf_DrainDelayedWork(void);
+#endif // _WIN32
+#endif // SOLARIS || _WIN32 || __APPLE__
+
+#if !defined(VMKERNEL) && (defined(__linux__) || defined(_WIN32) || \
+                           defined(SOLARIS) || defined(__APPLE__))
+void *VMCI_AllocQueue(uint64 size, uint32 flags);
+void VMCI_FreeQueue(void *q, uint64 size);
+typedef struct PPNSet {
+  uint64      numProducePages;
+  uint64      numConsumePages;
+  VMCIPpnList producePPNs;
+  VMCIPpnList consumePPNs;
+  Bool        initialized;
+} PPNSet;
+int VMCI_AllocPPNSet(void *produceQ, uint64 numProducePages, void *consumeQ,
+                     uint64 numConsumePages, PPNSet *ppnSet);
+void VMCI_FreePPNSet(PPNSet *ppnSet);
+int VMCI_PopulatePPNList(uint8 *callBuf, const PPNSet *ppnSet);
+#endif
+
+struct VMCIQueue;
+
+struct PageStoreAttachInfo;
+struct VMCIQueue *VMCIHost_AllocQueue(uint64 queueSize);
+void VMCIHost_FreeQueue(struct VMCIQueue *queue, uint64 queueSize);
+
+#if defined(VMKERNEL)
+typedef World_Handle *VMCIGuestMemID;
+#define INVALID_VMCI_GUEST_MEM_ID  NULL
+#else
+typedef uint32 VMCIGuestMemID;
+#define INVALID_VMCI_GUEST_MEM_ID  0
+#endif
+
+#if defined(VMKERNEL) || defined(__linux__)  || defined(_WIN32) || \
+    defined(__APPLE__)
+  struct QueuePairPageStore;
+  int VMCIHost_RegisterUserMemory(struct QueuePairPageStore *pageStore,
+                                  struct VMCIQueue *produceQ,
+                                  struct VMCIQueue *consumeQ);
+  void VMCIHost_UnregisterUserMemory(struct VMCIQueue *produceQ,
+                                     struct VMCIQueue *consumeQ);
+  int VMCIHost_MapQueues(struct VMCIQueue *produceQ,
+                         struct VMCIQueue *consumeQ,
+                         uint32 flags);
+  int VMCIHost_UnmapQueues(VMCIGuestMemID gid,
+                           struct VMCIQueue *produceQ,
+                           struct VMCIQueue *consumeQ);
+  void VMCI_InitQueueMutex(struct VMCIQueue *produceQ,
+                           struct VMCIQueue *consumeQ);
+  void VMCI_CleanupQueueMutex(struct VMCIQueue *produceQ,
+                              struct VMCIQueue *consumeQ);
+  int VMCI_AcquireQueueMutex(struct VMCIQueue *queue, Bool canBlock);
+  void VMCI_ReleaseQueueMutex(struct VMCIQueue *queue);
+#else // Below are the guest OS'es without host side support.
+#  define VMCI_InitQueueMutex(_pq, _cq)
+#  define VMCI_CleanupQueueMutex(_pq, _cq)
+#  define VMCI_AcquireQueueMutex(_q, _cb) VMCI_SUCCESS
+#  define VMCI_ReleaseQueueMutex(_q)
+#  define VMCIHost_RegisterUserMemory(_ps, _pq, _cq) VMCI_ERROR_UNAVAILABLE
+#  define VMCIHost_UnregisterUserMemory(_pq, _cq)
+#  define VMCIHost_MapQueues(_pq, _cq, _f) VMCI_SUCCESS
+#  define VMCIHost_UnmapQueues(_gid, _pq, _cq) VMCI_SUCCESS
+#endif
+
+#if defined(VMKERNEL)
+  void VMCIHost_MarkQueuesAvailable(struct VMCIQueue *produceQ,
+                                    struct VMCIQueue *consumeQ);
+  void VMCIHost_MarkQueuesUnavailable(struct VMCIQueue *produceQ,
+                                      struct VMCIQueue *consumeQ);
+#else
+#  define VMCIHost_MarkQueuesAvailable(_q, _p) while(0) { }
+#  define VMCIHost_MarkQueuesUnavailable(_q, _p) while(0) { }
+#endif
+
+#if defined(VMKERNEL) || defined(__linux__)
+   void VMCI_LockQueueHeader(struct VMCIQueue *queue);
+   void VMCI_UnlockQueueHeader(struct VMCIQueue *queue);
+#else
+#  define VMCI_LockQueueHeader(_q) ASSERT_NOT_IMPLEMENTED(FALSE)
+#  define VMCI_UnlockQueueHeader(_q) ASSERT_NOT_IMPLEMENTED(FALSE)
+#endif
+
+#if (!defined(VMKERNEL) && defined(__linux__)) || defined(_WIN32) ||  \
+   defined(__APPLE__) || defined(SOLARIS)
+  int VMCIHost_GetUserMemory(VA64 produceUVA, VA64 consumeUVA,
+                             struct VMCIQueue *produceQ,
+                             struct VMCIQueue *consumeQ);
+  void VMCIHost_ReleaseUserMemory(struct VMCIQueue *produceQ,
+                                  struct VMCIQueue *consumeQ);
+#else
+#  define VMCIHost_GetUserMemory(_puva, _cuva, _pq, _cq) VMCI_ERROR_UNAVAILABLE
+#  define VMCIHost_ReleaseUserMemory(_pq, _cq) ASSERT_NOT_IMPLEMENTED(FALSE)
+#endif
+
+#if defined(_WIN32)
+    Bool VMCI_EnqueueToDevNull(struct VMCIQueue *queue);
+    int VMCI_ConvertToLocalQueue(struct VMCIQueue *queueInfo,
+                                 struct VMCIQueue *otherQueueInfo,
+                                 uint64 size, Bool keepContent,
+                                 void **oldQueue);
+    void VMCI_RevertToNonLocalQueue(struct VMCIQueue *queueInfo,
+                                    void *nonLocalQueue, uint64 size);
+    void VMCI_FreeQueueBuffer(void *queue, uint64 size);
+    Bool VMCI_CanCreate(void);
+#else // _WIN32
+#  define VMCI_EnqueueToDevNull(_q) FALSE
+#  define VMCI_ConvertToLocalQueue(_pq, _cq, _s, _oq, _kc) VMCI_ERROR_UNAVAILABLE
+#  define VMCI_RevertToNonLocalQueue(_q, _nlq, _s)
+#  define VMCI_FreeQueueBuffer(_q, _s)
+#  define VMCI_CanCreate() TRUE
+#endif // !_WIN32
+Bool VMCI_GuestPersonalityActive(void);
+Bool VMCI_HostPersonalityActive(void);
+
+
+#if defined(VMKERNEL)
+  typedef List_Links VMCIListItem;
+  typedef List_Links VMCIList;
+
+#  define VMCIList_Init(_l)   List_Init(_l)
+#  define VMCIList_InitEntry(_e)  List_InitElement(_e)
+#  define VMCIList_Empty(_l)   List_IsEmpty(_l)
+#  define VMCIList_Insert(_e, _l) List_Insert(_e, LIST_ATREAR(_l))
+#  define VMCIList_Remove(_e) List_Remove(_e)
+#  define VMCIList_Scan(_cur, _l) LIST_FORALL(_l, _cur)
+#  define VMCIList_ScanSafe(_cur, _next, _l) LIST_FORALL_SAFE(_l, _cur, _next)
+#  define VMCIList_Entry(_elem, _type, _field) List_Entry(_elem, _type, _field)
+#  define VMCIList_First(_l) (VMCIList_Empty(_l)?NULL:List_First(_l))
+#else
+  typedef DblLnkLst_Links VMCIListItem;
+  typedef DblLnkLst_Links VMCIList;
+
+#  define VMCIList_Init(_l)   DblLnkLst_Init(_l)
+#  define VMCIList_InitEntry(_e)   DblLnkLst_Init(_e)
+#  define VMCIList_Empty(_l)   (!DblLnkLst_IsLinked(_l))
+#  define VMCIList_Insert(_e, _l) DblLnkLst_LinkLast(_l, _e)
+#  define VMCIList_Remove(_e) DblLnkLst_Unlink1(_e)
+#  define VMCIList_Scan(_cur, _l) DblLnkLst_ForEach(_cur, _l)
+#  define VMCIList_ScanSafe(_cur, _next, _l) DblLnkLst_ForEachSafe(_cur, _next, _l)
+#  define VMCIList_Entry(_elem, _type, _field) DblLnkLst_Container(_elem, _type, _field)
+#  define VMCIList_First(_l) (VMCIList_Empty(_l)?NULL:(_l)->next)
+#endif
+
+#endif // _VMCI_KERNEL_IF_H_

=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/vmblock'
=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/vmblock/linux'
=== added file '.pc/04-quantal-module-backport.patch/modules/linux/vmblock/linux/filesystem.c'
--- .pc/04-quantal-module-backport.patch/modules/linux/vmblock/linux/filesystem.c	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/vmblock/linux/filesystem.c	2013-06-28 21:11:42 +0000
@@ -0,0 +1,626 @@
+/*********************************************************
+ * 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
+ *
+ *********************************************************/
+
+/*
+ * filesystem.c --
+ *
+ *   File system for the vmblock driver.
+ *
+ */
+
+#include "driver-config.h"
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/mount.h>
+#include <linux/fs.h>
+
+#include "compat_namei.h"
+
+#include "os.h"
+#include "vmblockInt.h"
+#include "filesystem.h"
+
+#define VMBLOCK_ROOT_INO  1
+#define GetRootInode(sb)  Iget(sb, NULL, NULL, VMBLOCK_ROOT_INO)
+
+static struct inode *GetInode(struct super_block *sb, ino_t ino);
+
+/* File system operations */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
+static struct dentry *FsOpMount(struct file_system_type *fsType, int flags,
+                                const char *devName, void *rawData);
+#elif defined(VMW_GETSB_2618)
+static int FsOpGetSb(struct file_system_type *fsType, int flags,
+                     const char *devName, void *rawData, struct vfsmount *mnt);
+#else
+static struct super_block *FsOpGetSb(struct file_system_type *fsType, int flags,
+                                     const char *devName, void *rawData);
+#endif
+static int FsOpReadSuper(struct super_block *sb, void *rawData, int flags);
+
+
+/* Utility */
+static compat_kmem_cache_ctor InodeCacheCtor;
+
+
+/* Variables */
+compat_kmem_cache *VMBlockInodeCache;
+
+/* Local variables */
+static char const *fsRoot;
+static size_t fsRootLen;
+static struct file_system_type fsType = {
+   .owner = THIS_MODULE,
+   .name = VMBLOCK_FS_NAME,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
+   .mount = FsOpMount,
+#else
+   .get_sb = FsOpGetSb,
+#endif
+   .kill_sb = kill_anon_super,
+};
+
+
+/*
+ * Public functions (with respect to the module)
+ */
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * VMBlockInitFileSystem --
+ *
+ *    Initializes the file system and registers it with the kernel.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+VMBlockInitFileSystem(char const *root)  // IN: directory redirecting to
+{
+   int ret;
+
+   if (!root) {
+      Warning("VMBlockInitFileSystem: root not provided "
+              "(missing module parameter?)\n");
+      return -EINVAL;
+   }
+
+   /*
+    * Here we assume that the provided root is valid so the module will load.
+    * The mount operation will fail if that is not the case.
+    */
+   fsRoot = root;
+   fsRootLen = strlen(fsRoot);
+
+   if (fsRootLen >= PATH_MAX) {
+      return -ENAMETOOLONG;
+   }
+
+   /* Initialize our inode slab allocator */
+   VMBlockInodeCache = os_kmem_cache_create("VMBlockInodeCache",
+                                            sizeof (VMBlockInodeInfo),
+                                            0,
+                                            InodeCacheCtor);
+   if (!VMBlockInodeCache) {
+      Warning("VMBlockInitFileSystem: could not initialize inode cache\n");
+      return -ENOMEM;
+   }
+
+   /* Tell the kernel about our file system */
+   ret = register_filesystem(&fsType);
+   if (ret < 0) {
+      Warning("VMBlockInitFileSystem: could not initialize file system\n");
+      kmem_cache_destroy(VMBlockInodeCache);
+      return ret;
+   }
+
+   LOG(4, "file system registered with root of [%s]\n", fsRoot);
+
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * VMBlockCleanupFileSystem --
+ *
+ *    Cleans up file system and unregisters it with the kernel.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+VMBlockCleanupFileSystem(void)
+{
+   int ret;
+
+   ret = unregister_filesystem(&fsType);
+   if (ret < 0) {
+      Warning("VMBlockCleanupFileSystem: could not unregister file system\n");
+      return ret;
+   }
+
+   kmem_cache_destroy(VMBlockInodeCache);
+
+   return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ *  VMBlockReadInode --
+ *
+ *    A filesystem wide function that is called to initialize a new inode.
+ *    This is called from two different places depending on the kernel version.
+ *    In older kernels that provide the iget() interface, this function is
+ *    called by the kernel as part of inode initialization (from
+ *    SuperOpReadInode). In newer kernels that call iget_locked(), this
+ *    function is called by filesystem code to initialize the new inode.
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+VMBlockReadInode(struct inode *inode)  // IN: Inode to initialize
+{
+   VMBlockInodeInfo *iinfo = INODE_TO_IINFO(inode);
+
+   iinfo->name[0] = '\0';
+   iinfo->nameLen = 0;
+   iinfo->actualDentry = NULL;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * GetNextIno --
+ *
+ *    Gets the next available inode number.
+ *
+ * Results:
+ *    The next available inode number.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+ino_t
+GetNextIno(void)
+{
+   static atomic_t nextIno = ATOMIC_INIT(VMBLOCK_ROOT_INO + 1);
+
+   return (ino_t) atomic_inc_return(&nextIno);
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * GetInode --
+ *
+ *    This function replaces iget() and should be called instead of it. In newer
+ *    kernels that have removed the iget() interface,  GetInode() obtains an inode
+ *    and if it is a new one, then initializes the inode by calling
+ *    VMBlockReadInode(). In older kernels that support the iget() interface,
+ *    VMBlockReadInode() is called by iget() internally by the superblock function
+ *    SuperOpReadInode.
+ *
+ * Results:
+ *    A new inode object on success, NULL on error.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static struct inode *
+GetInode(struct super_block *sb, // IN: file system superblock object
+	 ino_t ino)              // IN: inode number to assign to new inode
+{
+   struct inode *inode;
+
+   inode = iget_locked(sb, ino);
+   if (!inode) {
+      return NULL;
+   } else if (inode->i_state & I_NEW) {
+      VMBlockReadInode(inode);
+      unlock_new_inode(inode);
+   }
+   return inode;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Iget --
+ *
+ *    Lookup or create a new inode.
+ *
+ *    Inode creation in detail:
+ *    Throughout the file system, we call the VFS iget() function to get a new
+ *    inode.  This in turn invokes our file system's SuperOpAllocInode()
+ *    function, which allocates an inode info structure (VMBlockInodeInfo)
+ *    using the kernel's slab allocator.  When a new slab is created, each
+ *    object is initialized with the constructor (InodeCacheCtor()), but that
+ *    occurs only once per struct (e.g., when a struct from a slab is freed and
+ *    reused, the constructor is not invoked again).  SuperOpAllocInode() then
+ *    returns the address of the inode struct that is embedded within the inode
+ *    info we have allocated.  iget() also invokes our SuperOpReadInode()
+ *    function to do any further file system wide initialization to the inode,
+ *    then returns the inode to us (this function).
+ *
+ *    Note that in older kernels that don't have the alloc_inode operation
+ *    (where VMW_EMBED_INODE is undefined), the allocation is delayed until
+ *    this function and is contained within the INODE_TO_IINFO macro.  That
+ *    allocation is freed in the SuperOpClearInode() function.
+ *
+ *    This function then constructs the full path of the actual file name and
+ *    does a path_lookup() to see if it exists.  If it does, we save a pointer
+ *    to the actual dentry within our inode info for future use.  If it
+ *    doesn't, we still provide an inode but indicate that it doesn't exist by
+ *    setting the actual dentry to NULL.  Callers that need to handle this case
+ *    differently check for the existence of the actual dentry (and actual
+ *    inode) to ensure the actual file exists.
+ *
+ * Results:
+ *    A new inode object on success, NULL on error.
+ *
+ * Side effects:
+ *    A path lookup is done for the actual file.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+struct inode *
+Iget(struct super_block *sb,    // IN: file system superblock object
+     struct inode *dir,         // IN: containing directory
+     struct dentry *dentry,     // IN: dentry within directory
+     ino_t ino)                 // IN: inode number to assign to new inode
+{
+   VMBlockInodeInfo *iinfo;
+   struct inode *inode;
+   struct nameidata actualNd;
+
+   ASSERT(sb);
+
+   inode = GetInode(sb, ino);
+   if (!inode) {
+      return NULL;
+   }
+
+   iinfo = INODE_TO_IINFO(inode);
+   if (!iinfo) {
+      Warning("Iget: invalid inode provided, or unable to allocate inode info\n");
+      goto error_inode;
+   }
+
+   /* Populate iinfo->name with the full path of the target file */
+   if (MakeFullName(dir, dentry, iinfo->name, sizeof iinfo->name) < 0) {
+      Warning("Iget: could not make full name\n");
+      goto error_inode;
+   }
+
+   if (compat_path_lookup(iinfo->name, 0, &actualNd)) {
+      /*
+       * This file does not exist, so we create an inode that doesn't know
+       * about its underlying file.  Operations that create files and
+       * directories need an inode to operate on even if there is no actual
+       * file yet.
+       */
+      iinfo->actualDentry = NULL;
+      return inode;
+   }
+
+   iinfo->actualDentry = compat_vmw_nd_to_dentry(actualNd);
+   compat_path_release(&actualNd);
+
+   return inode;
+
+error_inode:
+   iput(inode);
+   return NULL;
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * InodeCacheCtor --
+ *
+ *    The constructor for inode info structs that occurs once at slab
+ *    allocation.  That is, this is called once for each piece of memory that
+ *    is used to satisfy inode info allocations; it should only be used to
+ *    initialized items that will naturally return to their initialized state
+ *    before deallocation (such as locks, list_heads).
+ *
+ *    We only invoke the inode's initialization routine since all of the inode
+ *    info members need to be initialized on each allocation (in
+ *    SuperOpReadInode()).
+ *
+ * Results:
+ *    None.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static void
+InodeCacheCtor(COMPAT_KMEM_CACHE_CTOR_ARGS(slabElem))  // IN: allocated slab item to initialize
+{
+   VMBlockInodeInfo *iinfo = slabElem;
+
+   inode_init_once(&iinfo->inode);
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * MakeFullName --
+ *
+ *    Constructs the full filename from the provided directory and a dentry
+ *    contained within it.
+ *
+ * Results:
+ *    Zero on success, negative error code on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+MakeFullName(struct inode *dir,       // IN : directory
+             struct dentry *dentry,   // IN : dentry in that directory
+             char *bufOut,            // OUT: output buffer
+             size_t bufOutSize)       // IN : size of output buffer
+{
+   ASSERT(bufOut);
+
+   /*
+    * If dir is supplied, contruct the full path of the actual file, otherwise
+    * it's the root directory.
+    */
+   if (dir == NULL) {
+      if (fsRootLen >= bufOutSize) {
+         Warning("MakeFullName: root path was too long.\n");
+         return -ENAMETOOLONG;
+      }
+      memcpy(bufOut, fsRoot, fsRootLen);
+      bufOut[fsRootLen] = '\0';
+   } else {
+      VMBlockInodeInfo *dirIinfo;
+      int ret;
+
+      ASSERT(dir);
+      ASSERT(dentry);
+
+      if (!dentry->d_name.name) {
+         Warning("MakeFullName: dentry name is empty\n");
+         return -EINVAL;
+      }
+
+      dirIinfo = INODE_TO_IINFO(dir);
+
+      /*
+       * If dirIinfo->name[1] is '\0', then it is "/" and we don't need
+       * another '/' between it and the additional name.
+       */
+      ret = snprintf(bufOut, bufOutSize,
+                     dirIinfo->name[1] == '\0' ? "%s%s" : "%s/%s",
+                     dirIinfo->name, dentry->d_name.name);
+      if (ret >= bufOutSize) {
+         Warning("MakeFullName: path was too long.\n");
+         return -ENAMETOOLONG;
+      }
+   }
+
+   return 0;
+}
+
+
+/* File system operations */
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * FsOpReadSuper --
+ *
+ *    The main entry point of the filesystem side of the driver. Called when
+ *    a userland process does a mount(2) of an hgfs filesystem. This makes the
+ *    whole driver transition from its initial state to state 1. Fill the
+ *    content of the uninitialized superblock provided by the kernel.
+ *
+ *    'rawData' is a pointer (that can be NULL) to a kernel buffer (whose
+ *    size is <= PAGE_SIZE) that corresponds to the filesystem-specific 'data'
+ *    argument passed to mount(2).
+ *
+ * Results:
+ *    zero and initialized superblock on success
+ *    negative value on failure
+ *
+ * Side effects:
+ *    None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+FsOpReadSuper(struct super_block *sb, // OUT: Superblock object
+              void *rawData,          // IN: Fs-specific mount data
+              int flags)              // IN: Mount flags
+{
+   struct inode *rootInode;
+   struct dentry *rootDentry;
+
+   if (!sb) {
+      Warning("FsOpReadSuper: invalid arg from kernel\n");
+      return -EINVAL;
+   }
+
+   sb->s_magic = VMBLOCK_SUPER_MAGIC;
+   sb->s_blocksize = 1024;
+   sb->s_op = &VMBlockSuperOps;
+
+   /*
+    * Make root inode and dentry.  Ensure that the directory we are redirecting
+    * to has an actual dentry and inode, and that it is in fact a directory.
+    */
+   rootInode = GetRootInode(sb);
+   if (!rootInode) {
+      return -EINVAL;
+   }
+
+   if (!INODE_TO_IINFO(rootInode) ||
+       !INODE_TO_ACTUALDENTRY(rootInode) ||
+       !INODE_TO_ACTUALINODE(rootInode) ||
+       !S_ISDIR(INODE_TO_ACTUALINODE(rootInode)->i_mode)) {
+      iput(rootInode);
+      return -EINVAL;
+   }
+
+   rootDentry = d_alloc_root(rootInode);
+   if (!rootDentry) {
+      iput(rootInode);
+      return -ENOMEM;
+   }
+   sb->s_root = rootDentry;
+
+   rootInode->i_op = &RootInodeOps;
+   rootInode->i_fop = &RootFileOps;
+   rootInode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
+
+   LOG(4, "%s file system mounted\n", VMBLOCK_FS_NAME);
+   return 0;
+}
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * FsOpMount --
+ *
+ *    Invokes generic kernel code to mount a deviceless filesystem.
+ *
+ * Results:
+ *    Mount's root dentry tructure on success
+ *    ERR_PTR()-encoded negative error code on failure
+ *
+ * Side effects:
+ *    None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+struct dentry *
+FsOpMount(struct file_system_type *fs_type, // IN: file system type of mount
+          int flags,                        // IN: mount flags
+          const char *dev_name,             // IN: device mounting on
+          void *rawData)                    // IN: mount arguments
+{
+   return mount_nodev(fs_type, flags, rawData, FsOpReadSuper);
+}
+#elif defined(VMW_GETSB_2618)
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * FsOpGetSb --
+ *
+ *    Invokes generic kernel code to prepare superblock for
+ *    deviceless filesystem.
+ *
+ * Results:
+ *    0 on success
+ *    negative error code on failure
+ *
+ * Side effects:
+ *    None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+FsOpGetSb(struct file_system_type *fs_type, // IN: file system type of mount
+          int flags,                        // IN: mount flags
+          const char *dev_name,             // IN: device mounting on
+          void *rawData,                    // IN: mount arguments
+          struct vfsmount *mnt)             // IN: vfs mount
+{
+   return get_sb_nodev(fs_type, flags, rawData, FsOpReadSuper, mnt);
+}
+#else
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * FsOpGetSb --
+ *
+ *    Invokes generic kernel code to prepare superblock for
+ *    deviceless filesystem.
+ *
+ * Results:
+ *    The initialized superblock on success
+ *    NULL on failure
+ *
+ * Side effects:
+ *    None
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static struct super_block *
+FsOpGetSb(struct file_system_type *fs_type, // IN: file system type of mount
+          int flags,                        // IN: mount flags
+          const char *dev_name,             // IN: device mounting on
+          void *rawData)                    // IN: mount arguments
+{
+   return get_sb_nodev(fs_type, flags, rawData, FsOpReadSuper);
+}
+#endif
+

=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/vmci'
=== added directory '.pc/04-quantal-module-backport.patch/modules/linux/vmci/common'
=== added file '.pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciCommonInt.h'
--- .pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciCommonInt.h	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciCommonInt.h	2013-06-28 21:11:42 +0000
@@ -0,0 +1,133 @@
+/*********************************************************
+ * Copyright (C) 2006-2011 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
+ *
+ *********************************************************/
+
+/*
+ * vmciCommonInt.h --
+ *
+ * Struct definitions for VMCI internal common code.
+ */
+
+#ifndef _VMCI_COMMONINT_H_
+#define _VMCI_COMMONINT_H_
+
+#define INCLUDE_ALLOW_MODULE
+#define INCLUDE_ALLOW_VMMON
+#define INCLUDE_ALLOW_VMCORE
+#define INCLUDE_ALLOW_VMKERNEL
+#include "includeCheck.h"
+
+#include "vm_atomic.h"
+#include "vmci_defs.h"
+#include "vmci_call_defs.h"
+#include "vmci_infrastructure.h"
+#include "vmci_handle_array.h"
+#include "vmci_kernel_if.h"
+
+
+/*
+ *  The DatagramQueueEntry is a queue header for the in-kernel VMCI
+ *  datagram queues. It is allocated in non-paged memory, as the
+ *  content is accessed while holding a spinlock. The pending datagram
+ *  itself may be allocated from paged memory. We shadow the size of
+ *  the datagram in the non-paged queue entry as this size is used
+ *  while holding the same spinlock as above.
+ */
+
+typedef struct DatagramQueueEntry {
+   VMCIListItem   listItem;  /* For queuing. */
+   size_t         dgSize;    /* Size of datagram. */
+   VMCIDatagram   *dg;       /* Pending datagram. */
+} DatagramQueueEntry;
+
+
+struct VMCIContext {
+   VMCIListItem       listItem;         /* For global VMCI list. */
+   VMCIId             cid;
+   Atomic_uint32      refCount;
+   VMCIList           datagramQueue;    /* Head of per VM queue. */
+   uint32             pendingDatagrams;
+   size_t             datagramQueueSize;/* Size of datagram queue in bytes. */
+   int                userVersion;      /*
+                                         * Version of the code that created
+                                         * this context; e.g., VMX.
+                                         */
+   VMCILock           lock;             /* Locks callQueue and handleArrays. */
+   VMCIHandleArray    *queuePairArray;  /*
+                                         * QueuePairs attached to.  The array of
+                                         * handles for queue pairs is accessed
+                                         * from the code for QP API, and there
+                                         * it is protected by the QP lock.  It
+                                         * is also accessed from the context
+                                         * clean up path, which does not
+                                         * require a lock.  VMCILock is not
+                                         * used to protect the QP array field.
+                                         */
+   VMCIHandleArray    *doorbellArray;   /* Doorbells created by context. */
+   VMCIHandleArray    *pendingDoorbellArray; /* Doorbells pending for context. */
+   VMCIHandleArray    *notifierArray;   /* Contexts current context is subscribing to. */
+   VMCIHost           hostContext;
+   VMCIPrivilegeFlags privFlags;
+   VMCIHostUser       user;
+   Bool               validUser;
+#ifdef VMKERNEL
+   Bool               isQuiesced;       /* Whether current VM is quiesced */
+   VMCIId             migrateCid;       /* The migrate cid if it is migrating */
+   VMCIMutex          guestMemMutex;    /*
+                                         * Coordinates guest memory
+                                         * registration/release during FSR.
+                                         */
+   VMCIGuestMemID     curGuestMemID;    /* ID of current registered guest mem */
+#endif
+#ifndef VMX86_SERVER
+   Bool               *notify;          /* Notify flag pointer - hosted only. */
+#  ifdef __linux__
+   struct page        *notifyPage;      /* Page backing the notify UVA. */
+#  endif
+#endif
+};
+
+
+/*
+ *------------------------------------------------------------------------------
+ *
+ *  VMCIDenyInteraction --
+ *
+ *     Utilility function that checks whether two entities are allowed
+ *     to interact. If one of them is restricted, the other one must
+ *     be trusted.
+ *
+ *  Result:
+ *     TRUE if the two entities are not allowed to interact. FALSE otherwise.
+ *
+ *  Side effects:
+ *     None.
+ *
+ *------------------------------------------------------------------------------
+ */
+
+static INLINE Bool
+VMCIDenyInteraction(VMCIPrivilegeFlags partOne,  // IN
+                    VMCIPrivilegeFlags partTwo)  // IN
+{
+   return (((partOne & VMCI_PRIVILEGE_FLAG_RESTRICTED) &&
+            !(partTwo & VMCI_PRIVILEGE_FLAG_TRUSTED)) ||
+           ((partTwo & VMCI_PRIVILEGE_FLAG_RESTRICTED) &&
+            !(partOne & VMCI_PRIVILEGE_FLAG_TRUSTED)));
+}
+
+#endif /* _VMCI_COMMONINT_H_ */

=== added file '.pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciContext.c'
--- .pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciContext.c	1970-01-01 00:00:00 +0000
+++ .pc/04-quantal-module-backport.patch/modules/linux/vmci/common/vmciContext.c	2013-06-28 21:11:42 +0000
@@ -0,0 +1,2542 @@
+/*********************************************************
+ * Copyright (C) 2006-2011 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
+ *
+ *********************************************************/
+
+/*
+ * vmciContext.c --
+ *
+ *     Platform independent routines for VMCI calls.
+ */
+
+#include "vmci_kernel_if.h"
+#include "vm_assert.h"
+#include "vmci_defs.h"
+#include "vmci_infrastructure.h"
+#include "vmciCommonInt.h"
+#include "vmciContext.h"
+#include "vmciDatagram.h"
+#include "vmciDoorbell.h"
+#include "vmciDriver.h"
+#include "vmciEvent.h"
+#include "vmciKernelAPI.h"
+#include "vmciQueuePair.h"
+#if defined(VMKERNEL)
+#  include "vmciVmkInt.h"
+#  include "vm_libc.h"
+#  include "helper_ext.h"
+#endif
+
+#define LGPFX "VMCIContext: "
+
+static void VMCIContextFreeContext(VMCIContext *context);
+static Bool VMCIContextExists(VMCIId cid);
+static int VMCIContextFireNotification(VMCIId contextID,
+                                       VMCIPrivilegeFlags privFlags);
+#if defined(VMKERNEL)
+static void VMCIContextReleaseGuestMemLocked(VMCIContext *context,
+                                             VMCIGuestMemID gid);
+#endif
+
+/*
+ * List of current VMCI contexts.
+ */
+
+static struct {
+   VMCIList head;
+   VMCILock lock;
+   VMCILock firingLock;
+} contextList;
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContextSignalNotify --
+ *
+ *      Sets the notify flag to TRUE.  Assumes that the context lock is
+ *      held.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIContextSignalNotify(VMCIContext *context) // IN:
+{
+#ifndef VMX86_SERVER
+   if (context->notify) {
+      *context->notify = TRUE;
+   }
+#endif
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContextClearNotify --
+ *
+ *      Sets the notify flag to FALSE.  Assumes that the context lock is
+ *      held.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIContextClearNotify(VMCIContext *context) // IN:
+{
+#ifndef VMX86_SERVER
+   if (context->notify) {
+      *context->notify = FALSE;
+   }
+#endif
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContextClearNotifyAndCall --
+ *
+ *      If nothing requires the attention of the guest, clears both
+ *      notify flag and call.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static INLINE void
+VMCIContextClearNotifyAndCall(VMCIContext *context) // IN:
+{
+   if (context->pendingDatagrams == 0 &&
+       VMCIHandleArray_GetSize(context->pendingDoorbellArray) == 0) {
+      VMCIHost_ClearCall(&context->hostContext);
+      VMCIContextClearNotify(context);
+   }
+}
+
+
+#ifndef VMX86_SERVER
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_CheckAndSignalNotify --
+ *
+ *      Sets the context's notify flag iff datagrams are pending for this
+ *      context.  Called from VMCISetupNotify().
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+VMCIContext_CheckAndSignalNotify(VMCIContext *context) // IN:
+{
+   VMCILockFlags flags;
+
+   ASSERT(context);
+   VMCI_GrabLock(&contextList.lock, &flags);
+   if (context->pendingDatagrams) {
+      VMCIContextSignalNotify(context);
+   }
+   VMCI_ReleaseLock(&contextList.lock, flags);
+}
+#endif
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_Init --
+ *
+ *      Initializes the VMCI context module.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+VMCIContext_Init(void)
+{
+   int err;
+
+   VMCIList_Init(&contextList.head);
+
+   err = VMCI_InitLock(&contextList.lock, "VMCIContextListLock",
+                       VMCI_LOCK_RANK_CONTEXTLIST);
+   if (err < VMCI_SUCCESS) {
+      return err;
+   }
+
+   err = VMCI_InitLock(&contextList.firingLock, "VMCIContextFiringLock",
+                       VMCI_LOCK_RANK_CONTEXTFIRE);
+   if (err < VMCI_SUCCESS) {
+      VMCI_CleanupLock(&contextList.lock);
+   }
+
+   return err;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_Exit --
+ *
+ *      Cleans up the contexts module.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+VMCIContext_Exit(void)
+{
+   VMCI_CleanupLock(&contextList.firingLock);
+   VMCI_CleanupLock(&contextList.lock);
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_InitContext --
+ *
+ *      Allocates and initializes a VMCI context.
+ *
+ * Results:
+ *      Returns 0 on success, appropriate error code otherwise.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+VMCIContext_InitContext(VMCIId cid,                   // IN
+                        VMCIPrivilegeFlags privFlags, // IN
+                        uintptr_t eventHnd,           // IN
+                        int userVersion,              // IN: User's vers no.
+                        VMCIHostUser *user,           // IN
+                        VMCIContext **outContext)     // OUT
+{
+   VMCILockFlags flags;
+   VMCIContext *context;
+   int result;
+
+   if (privFlags & ~VMCI_PRIVILEGE_ALL_FLAGS) {
+      VMCI_DEBUG_LOG(4, (LGPFX"Invalid flag (flags=0x%x) for VMCI context.\n",
+                         privFlags));
+      return VMCI_ERROR_INVALID_ARGS;
+   }
+
+   if (userVersion == 0) {
+      return VMCI_ERROR_INVALID_ARGS;
+   }
+
+   context = VMCI_AllocKernelMem(sizeof *context, VMCI_MEMORY_NONPAGED);
+   if (context == NULL) {
+      VMCI_WARNING((LGPFX"Failed to allocate memory for VMCI context.\n"));
+      return VMCI_ERROR_NO_MEM;
+   }
+   memset(context, 0, sizeof *context);
+
+   VMCIList_InitEntry(&context->listItem);
+   VMCIList_Init(&context->datagramQueue);
+
+   context->userVersion = userVersion;
+
+   context->queuePairArray = VMCIHandleArray_Create(0);
+   if (!context->queuePairArray) {
+      result = VMCI_ERROR_NO_MEM;
+      goto error;
+   }
+
+   context->doorbellArray = VMCIHandleArray_Create(0);
+   if (!context->doorbellArray) {
+      result = VMCI_ERROR_NO_MEM;
+      goto error;
+   }
+
+   context->pendingDoorbellArray = VMCIHandleArray_Create(0);
+   if (!context->pendingDoorbellArray) {
+      result = VMCI_ERROR_NO_MEM;
+      goto error;
+   }
+
+   context->notifierArray = VMCIHandleArray_Create(0);
+   if (context->notifierArray == NULL) {
+      result = VMCI_ERROR_NO_MEM;
+      goto error;
+   }
+
+   result = VMCI_InitLock(&context->lock, "VMCIContextLock",
+                          VMCI_LOCK_RANK_CONTEXT);
+   if (result < VMCI_SUCCESS) {
+      goto error;
+   }
+   Atomic_Write(&context->refCount, 1);
+
+#if defined(VMKERNEL)
+   result = VMCIMutex_Init(&context->guestMemMutex, "VMCIGuestMem",
+                           VMCI_SEMA_RANK_GUESTMEM);
+   if (result < VMCI_SUCCESS) {
+      VMCI_CleanupLock(&context->lock);
+      goto error;
+   }
+   context->curGuestMemID = INVALID_VMCI_GUEST_MEM_ID;
+#endif
+
+   /* Inititialize host-specific VMCI context. */
+   VMCIHost_InitContext(&context->hostContext, eventHnd);
+
+   context->privFlags = privFlags;
+
+   /*
+    * If we collide with an existing context we generate a new and use it
+    * instead. The VMX will determine if regeneration is okay. Since there
+    * isn't 4B - 16 VMs running on a given host, the below loop will terminate.
+    */
+   VMCI_GrabLock(&contextList.lock, &flags);
+   ASSERT(cid != VMCI_INVALID_ID);
+   while (VMCIContextExists(cid)) {
+
+      /*
+       * If the cid is below our limit and we collide we are creating duplicate
+       * contexts internally so we want to assert fail in that case.
+       */
+      ASSERT(cid >= VMCI_RESERVED_CID_LIMIT);
+
+      /* We reserve the lowest 16 ids for fixed contexts. */
+      cid = MAX(cid, VMCI_RESERVED_CID_LIMIT-1) + 1;
+      if (cid == VMCI_INVALID_ID) {
+         cid = VMCI_RESERVED_CID_LIMIT;
+      }
+   }
+   ASSERT(!VMCIContextExists(cid));
+   context->cid = cid;
+   context->validUser = user != NULL;
+   if (context->validUser) {
+      context->user = *user;
+   }
+   VMCIList_Insert(&context->listItem, &contextList.head);
+   VMCI_ReleaseLock(&contextList.lock, flags);
+
+#ifdef VMKERNEL
+   VMCIContext_SetFSRState(context, FALSE, VMCI_INVALID_ID, eventHnd, FALSE);
+#endif
+
+#ifndef VMX86_SERVER
+   context->notify = NULL;
+#  ifdef __linux__
+   context->notifyPage = NULL;
+#  endif
+#endif
+
+   *outContext = context;
+   return VMCI_SUCCESS;
+
+error:
+   if (context->notifierArray) {
+      VMCIHandleArray_Destroy(context->notifierArray);
+   }
+   if (context->queuePairArray) {
+      VMCIHandleArray_Destroy(context->queuePairArray);
+   }
+   if (context->doorbellArray) {
+      VMCIHandleArray_Destroy(context->doorbellArray);
+   }
+   if (context->pendingDoorbellArray) {
+      VMCIHandleArray_Destroy(context->pendingDoorbellArray);
+   }
+   VMCI_FreeKernelMem(context, sizeof *context);
+   return result;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_ReleaseContext --
+ *
+ *      Cleans up a VMCI context.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+VMCIContext_ReleaseContext(VMCIContext *context)   // IN
+{
+   VMCILockFlags flags;
+
+   /* Dequeue VMCI context. */
+
+   VMCI_GrabLock(&contextList.lock, &flags);
+   VMCIList_Remove(&context->listItem);
+   VMCI_ReleaseLock(&contextList.lock, flags);
+
+   VMCIContext_Release(context);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIContextFreeContext --
+ *
+ *      Deallocates all parts of a context datastructure. This
+ *      functions doesn't lock the context, because it assumes that
+ *      the caller is holding the last reference to context. As paged
+ *      memory may be freed as part of the call, the function must be
+ *      called without holding any spinlocks as this is not allowed on
+ *      Windows.
+ *
+ * Results:
+ *      None.
+ *
+ * Side effects:
+ *      Paged memory is freed.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VMCIContextFreeContext(VMCIContext *context)  // IN
+{
+   VMCIListItem *curr;
+   VMCIListItem *next;
+   DatagramQueueEntry *dqEntry;
+   VMCIHandle tempHandle;
+
+   /* Fire event to all contexts interested in knowing this context is dying. */
+   VMCIContextFireNotification(context->cid, context->privFlags);
+
+   /*
+    * Cleanup all queue pair resources attached to context.  If the VM dies
+    * without cleaning up, this code will make sure that no resources are
+    * leaked.
+    */
+
+   tempHandle = VMCIHandleArray_GetEntry(context->queuePairArray, 0);
+   while (!VMCI_HANDLE_EQUAL(tempHandle, VMCI_INVALID_HANDLE)) {
+      if (VMCIQPBroker_Detach(tempHandle, context) < VMCI_SUCCESS) {
+         /*
+          * When VMCIQPBroker_Detach() succeeds it removes the handle from the
+          * array.  If detach fails, we must remove the handle ourselves.
+          */
+         VMCIHandleArray_RemoveEntry(context->queuePairArray, tempHandle);
+      }
+      tempHandle = VMCIHandleArray_GetEntry(context->queuePairArray, 0);
+   }
+
+   /*
+    * It is fine to destroy this without locking the callQueue, as
+    * this is the only thread having a reference to the context.
+    */
+
+   VMCIList_ScanSafe(curr, next, &context->datagramQueue) {
+      dqEntry = VMCIList_Entry(curr, DatagramQueueEntry, listItem);
+      VMCIList_Remove(curr);
+      ASSERT(dqEntry && dqEntry->dg);
+      ASSERT(dqEntry->dgSize == VMCI_DG_SIZE(dqEntry->dg));
+      VMCI_FreeKernelMem(dqEntry->dg, dqEntry->dgSize);
+      VMCI_FreeKernelMem(dqEntry, sizeof *dqEntry);
+   }
+
+   VMCIHandleArray_Destroy(context->notifierArray);
+   VMCIHandleArray_Destroy(context->queuePairArray);
+   VMCIHandleArray_Destroy(context->doorbellArray);
+   VMCIHandleArray_Destroy(context->pendingDoorbellArray);
+   VMCI_CleanupLock(&context->lock);
+#if defined(VMKERNEL)
+   VMCIMutex_Destroy(&context->guestMemMutex);
+#endif
+   VMCIHost_ReleaseContext(&context->hostContext);
+#ifndef VMX86_SERVER
+#  ifdef __linux__
+   /* TODO Windows and Mac OS. */
+   VMCIUnsetNotify(context);
+#  endif
+#endif
+   VMCI_FreeKernelMem(context, sizeof *context);
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCIContext_PendingDatagrams --
+ *
+ *      Returns the current number of pending datagrams. The call may
+ *      also serve as a synchronization point for the datagram queue,
+ *      as no enqueue operations can occur concurrently.
+ *
+ * Results:
+ *      Length of datagram queue for the given context.
+ *
+ * Side effects:
+ *      Locks datagram queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int