out_diff

diff --git a/.gitignore b/.gitignore
index 7e9932e..cfe64a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -92,3 +92,6 @@ extra_certificates
 signing_key.priv
 signing_key.x509
 x509.genkey
+
+# kdev files
+*.kdev4
diff --git a/README b/README
index a24ec89..a4f831b 100644
--- a/README
+++ b/README
@@ -1,412 +1,9 @@
-        Linux kernel release 3.x <http://kernel.org/>
+nitro-ng_kmod
+----------------------------------------
 
-These are the release notes for Linux version 3.  Read them carefully,
-as they tell you what this is all about, explain how to install the
-kernel, and what to do if something goes wrong. 
-
-WHAT IS LINUX?
-
-  Linux is a clone of the operating system Unix, written from scratch by
-  Linus Torvalds with assistance from a loosely-knit team of hackers across
-  the Net. It aims towards POSIX and Single UNIX Specification compliance.
-
-  It has all the features you would expect in a modern fully-fledged Unix,
-  including true multitasking, virtual memory, shared libraries, demand
-  loading, shared copy-on-write executables, proper memory management,
-  and multistack networking including IPv4 and IPv6.
-
-  It is distributed under the GNU General Public License - see the
-  accompanying COPYING file for more details. 
-
-ON WHAT HARDWARE DOES IT RUN?
-
-  Although originally developed first for 32-bit x86-based PCs (386 or higher),
-  today Linux also runs on (at least) the Compaq Alpha AXP, Sun SPARC and
-  UltraSPARC, Motorola 68000, PowerPC, PowerPC64, ARM, Hitachi SuperH, Cell,
-  IBM S/390, MIPS, HP PA-RISC, Intel IA-64, DEC VAX, AMD x86-64, AXIS CRIS,
-  Xtensa, Tilera TILE, AVR32 and Renesas M32R architectures.
-
-  Linux is easily portable to most general-purpose 32- or 64-bit architectures
-  as long as they have a paged memory management unit (PMMU) and a port of the
-  GNU C compiler (gcc) (part of The GNU Compiler Collection, GCC). Linux has
-  also been ported to a number of architectures without a PMMU, although
-  functionality is then obviously somewhat limited.
-  Linux has also been ported to itself. You can now run the kernel as a
-  userspace application - this is called UserMode Linux (UML).
-
-DOCUMENTATION:
-
- - There is a lot of documentation available both in electronic form on
-   the Internet and in books, both Linux-specific and pertaining to
-   general UNIX questions.  I'd recommend looking into the documentation
-   subdirectories on any Linux FTP site for the LDP (Linux Documentation
-   Project) books.  This README is not meant to be documentation on the
-   system: there are much better sources available.
-
- - There are various README files in the Documentation/ subdirectory:
-   these typically contain kernel-specific installation notes for some 
-   drivers for example. See Documentation/00-INDEX for a list of what
-   is contained in each file.  Please read the Changes file, as it
-   contains information about the problems, which may result by upgrading
-   your kernel.
-
- - The Documentation/DocBook/ subdirectory contains several guides for
-   kernel developers and users.  These guides can be rendered in a
-   number of formats:  PostScript (.ps), PDF, HTML, & man-pages, among others.
-   After installation, "make psdocs", "make pdfdocs", "make htmldocs",
-   or "make mandocs" will render the documentation in the requested format.
-
-INSTALLING the kernel source:
-
- - If you install the full sources, put the kernel tarball in a
-   directory where you have permissions (eg. your home directory) and
-   unpack it:
-
-     gzip -cd linux-3.X.tar.gz | tar xvf -
-
-   or
-
-     bzip2 -dc linux-3.X.tar.bz2 | tar xvf -
-
-   Replace "X" with the version number of the latest kernel.
-
-   Do NOT use the /usr/src/linux area! This area has a (usually
-   incomplete) set of kernel headers that are used by the library header
-   files.  They should match the library, and not get messed up by
-   whatever the kernel-du-jour happens to be.
-
- - You can also upgrade between 3.x releases by patching.  Patches are
-   distributed in the traditional gzip and the newer bzip2 format.  To
-   install by patching, get all the newer patch files, enter the
-   top level directory of the kernel source (linux-3.X) and execute:
-
-     gzip -cd ../patch-3.x.gz | patch -p1
-
-   or
-
-     bzip2 -dc ../patch-3.x.bz2 | patch -p1
-
-   Replace "x" for all versions bigger than the version "X" of your current
-   source tree, _in_order_, and you should be ok.  You may want to remove
-   the backup files (some-file-name~ or some-file-name.orig), and make sure
-   that there are no failed patches (some-file-name# or some-file-name.rej).
-   If there are, either you or I have made a mistake.
-
-   Unlike patches for the 3.x kernels, patches for the 3.x.y kernels
-   (also known as the -stable kernels) are not incremental but instead apply
-   directly to the base 3.x kernel.  For example, if your base kernel is 3.0
-   and you want to apply the 3.0.3 patch, you must not first apply the 3.0.1
-   and 3.0.2 patches. Similarly, if you are running kernel version 3.0.2 and
-   want to jump to 3.0.3, you must first reverse the 3.0.2 patch (that is,
-   patch -R) _before_ applying the 3.0.3 patch. You can read more on this in
-   Documentation/applying-patches.txt
-
-   Alternatively, the script patch-kernel can be used to automate this
-   process.  It determines the current kernel version and applies any
-   patches found.
-
-     linux/scripts/patch-kernel linux
-
-   The first argument in the command above is the location of the
-   kernel source.  Patches are applied from the current directory, but
-   an alternative directory can be specified as the second argument.
-
- - Make sure you have no stale .o files and dependencies lying around:
-
-     cd linux
-     make mrproper
-
-   You should now have the sources correctly installed.
-
-SOFTWARE REQUIREMENTS
-
-   Compiling and running the 3.x kernels requires up-to-date
-   versions of various software packages.  Consult
-   Documentation/Changes for the minimum version numbers required
-   and how to get updates for these packages.  Beware that using
-   excessively old versions of these packages can cause indirect
-   errors that are very difficult to track down, so don't assume that
-   you can just update packages when obvious problems arise during
-   build or operation.
-
-BUILD directory for the kernel:
-
-   When compiling the kernel, all output files will per default be
-   stored together with the kernel source code.
-   Using the option "make O=output/dir" allow you to specify an alternate
-   place for the output files (including .config).
-   Example:
-
-     kernel source code: /usr/src/linux-3.X
-     build directory:    /home/name/build/kernel
-
-   To configure and build the kernel, use:
-
-     cd /usr/src/linux-3.X
-     make O=/home/name/build/kernel menuconfig
-     make O=/home/name/build/kernel
-     sudo make O=/home/name/build/kernel modules_install install
-
-   Please note: If the 'O=output/dir' option is used, then it must be
-   used for all invocations of make.
-
-CONFIGURING the kernel:
-
-   Do not skip this step even if you are only upgrading one minor
-   version.  New configuration options are added in each release, and
-   odd problems will turn up if the configuration files are not set up
-   as expected.  If you want to carry your existing configuration to a
-   new version with minimal work, use "make oldconfig", which will
-   only ask you for the answers to new questions.
-
- - Alternative configuration commands are:
-
-     "make config"      Plain text interface.
-
-     "make menuconfig"  Text based color menus, radiolists & dialogs.
-
-     "make nconfig"     Enhanced text based color menus.
-
-     "make xconfig"     X windows (Qt) based configuration tool.
-
-     "make gconfig"     X windows (Gtk) based configuration tool.
-
-     "make oldconfig"   Default all questions based on the contents of
-                        your existing ./.config file and asking about
-                        new config symbols.
-
-     "make silentoldconfig"
-                        Like above, but avoids cluttering the screen
-                        with questions already answered.
-                        Additionally updates the dependencies.
-
-     "make olddefconfig"
-                        Like above, but sets new symbols to their default
-                        values without prompting.
-
-     "make defconfig"   Create a ./.config file by using the default
-                        symbol values from either arch/$ARCH/defconfig
-                        or arch/$ARCH/configs/${PLATFORM}_defconfig,
-                        depending on the architecture.
-
-     "make ${PLATFORM}_defconfig"
-                        Create a ./.config file by using the default
-                        symbol values from
-                        arch/$ARCH/configs/${PLATFORM}_defconfig.
-                        Use "make help" to get a list of all available
-                        platforms of your architecture.
-
-     "make allyesconfig"
-                        Create a ./.config file by setting symbol
-                        values to 'y' as much as possible.
-
-     "make allmodconfig"
-                        Create a ./.config file by setting symbol
-                        values to 'm' as much as possible.
-
-     "make allnoconfig" Create a ./.config file by setting symbol
-                        values to 'n' as much as possible.
-
-     "make randconfig"  Create a ./.config file by setting symbol
-                        values to random values.
-
-     "make localmodconfig" Create a config based on current config and
-                           loaded modules (lsmod). Disables any module
-                           option that is not needed for the loaded modules.
-
-                           To create a localmodconfig for another machine,
-                           store the lsmod of that machine into a file
-                           and pass it in as a LSMOD parameter.
-
-                   target$ lsmod > /tmp/mylsmod
-                   target$ scp /tmp/mylsmod host:/tmp
-
-                   host$ make LSMOD=/tmp/mylsmod localmodconfig
-
-                           The above also works when cross compiling.
-
-     "make localyesconfig" Similar to localmodconfig, except it will convert
-                           all module options to built in (=y) options.
-
-   You can find more information on using the Linux kernel config tools
-   in Documentation/kbuild/kconfig.txt.
-
- - NOTES on "make config":
-
-    - Having unnecessary drivers will make the kernel bigger, and can
-      under some circumstances lead to problems: probing for a
-      nonexistent controller card may confuse your other controllers
-
-    - Compiling the kernel with "Processor type" set higher than 386
-      will result in a kernel that does NOT work on a 386.  The
-      kernel will detect this on bootup, and give up.
-
-    - A kernel with math-emulation compiled in will still use the
-      coprocessor if one is present: the math emulation will just
-      never get used in that case.  The kernel will be slightly larger,
-      but will work on different machines regardless of whether they
-      have a math coprocessor or not.
-
-    - The "kernel hacking" configuration details usually result in a
-      bigger or slower kernel (or both), and can even make the kernel
-      less stable by configuring some routines to actively try to
-      break bad code to find kernel problems (kmalloc()).  Thus you
-      should probably answer 'n' to the questions for "development",
-      "experimental", or "debugging" features.
-
-COMPILING the kernel:
-
- - Make sure you have at least gcc 3.2 available.
-   For more information, refer to Documentation/Changes.
-
-   Please note that you can still run a.out user programs with this kernel.
-
- - Do a "make" to create a compressed kernel image. It is also
-   possible to do "make install" if you have lilo installed to suit the
-   kernel makefiles, but you may want to check your particular lilo setup first.
-
-   To do the actual install, you have to be root, but none of the normal
-   build should require that. Don't take the name of root in vain.
-
- - If you configured any of the parts of the kernel as `modules', you
-   will also have to do "make modules_install".
-
- - Verbose kernel compile/build output:
-
-   Normally, the kernel build system runs in a fairly quiet mode (but not
-   totally silent).  However, sometimes you or other kernel developers need
-   to see compile, link, or other commands exactly as they are executed.
-   For this, use "verbose" build mode.  This is done by inserting
-   "V=1" in the "make" command.  E.g.:
-
-     make V=1 all
-
-   To have the build system also tell the reason for the rebuild of each
-   target, use "V=2".  The default is "V=0".
-
- - Keep a backup kernel handy in case something goes wrong.  This is 
-   especially true for the development releases, since each new release
-   contains new code which has not been debugged.  Make sure you keep a
-   backup of the modules corresponding to that kernel, as well.  If you
-   are installing a new kernel with the same version number as your
-   working kernel, make a backup of your modules directory before you
-   do a "make modules_install".
-
-   Alternatively, before compiling, use the kernel config option
-   "LOCALVERSION" to append a unique suffix to the regular kernel version.
-   LOCALVERSION can be set in the "General Setup" menu.
-
- - In order to boot your new kernel, you'll need to copy the kernel
-   image (e.g. .../linux/arch/i386/boot/bzImage after compilation)
-   to the place where your regular bootable kernel is found. 
-
- - Booting a kernel directly from a floppy without the assistance of a
-   bootloader such as LILO, is no longer supported.
-
-   If you boot Linux from the hard drive, chances are you use LILO, which
-   uses the kernel image as specified in the file /etc/lilo.conf.  The
-   kernel image file is usually /vmlinuz, /boot/vmlinuz, /bzImage or
-   /boot/bzImage.  To use the new kernel, save a copy of the old image
-   and copy the new image over the old one.  Then, you MUST RERUN LILO
-   to update the loading map!! If you don't, you won't be able to boot
-   the new kernel image.
-
-   Reinstalling LILO is usually a matter of running /sbin/lilo. 
-   You may wish to edit /etc/lilo.conf to specify an entry for your
-   old kernel image (say, /vmlinux.old) in case the new one does not
-   work.  See the LILO docs for more information. 
-
-   After reinstalling LILO, you should be all set.  Shutdown the system,
-   reboot, and enjoy!
-
-   If you ever need to change the default root device, video mode,
-   ramdisk size, etc.  in the kernel image, use the 'rdev' program (or
-   alternatively the LILO boot options when appropriate).  No need to
-   recompile the kernel to change these parameters. 
-
- - Reboot with the new kernel and enjoy. 
-
-IF SOMETHING GOES WRONG:
-
- - If you have problems that seem to be due to kernel bugs, please check
-   the file MAINTAINERS to see if there is a particular person associated
-   with the part of the kernel that you are having trouble with. If there
-   isn't anyone listed there, then the second best thing is to mail
-   them to me ([email protected]), and possibly to any other
-   relevant mailing-list or to the newsgroup.
-
- - In all bug-reports, *please* tell what kernel you are talking about,
-   how to duplicate the problem, and what your setup is (use your common
-   sense).  If the problem is new, tell me so, and if the problem is
-   old, please try to tell me when you first noticed it.
-
- - If the bug results in a message like
-
-     unable to handle kernel paging request at address C0000010
-     Oops: 0002
-     EIP:   0010:XXXXXXXX
-     eax: xxxxxxxx   ebx: xxxxxxxx   ecx: xxxxxxxx   edx: xxxxxxxx
-     esi: xxxxxxxx   edi: xxxxxxxx   ebp: xxxxxxxx
-     ds: xxxx  es: xxxx  fs: xxxx  gs: xxxx
-     Pid: xx, process nr: xx
-     xx xx xx xx xx xx xx xx xx xx
-
-   or similar kernel debugging information on your screen or in your
-   system log, please duplicate it *exactly*.  The dump may look
-   incomprehensible to you, but it does contain information that may
-   help debugging the problem.  The text above the dump is also
-   important: it tells something about why the kernel dumped code (in
-   the above example, it's due to a bad kernel pointer). More information
-   on making sense of the dump is in Documentation/oops-tracing.txt
-
- - If you compiled the kernel with CONFIG_KALLSYMS you can send the dump
-   as is, otherwise you will have to use the "ksymoops" program to make
-   sense of the dump (but compiling with CONFIG_KALLSYMS is usually preferred).
-   This utility can be downloaded from
-   ftp://ftp.<country>.kernel.org/pub/linux/utils/kernel/ksymoops/ .
-   Alternatively, you can do the dump lookup by hand:
-
- - In debugging dumps like the above, it helps enormously if you can
-   look up what the EIP value means.  The hex value as such doesn't help
-   me or anybody else very much: it will depend on your particular
-   kernel setup.  What you should do is take the hex value from the EIP
-   line (ignore the "0010:"), and look it up in the kernel namelist to
-   see which kernel function contains the offending address.
-
-   To find out the kernel function name, you'll need to find the system
-   binary associated with the kernel that exhibited the symptom.  This is
-   the file 'linux/vmlinux'.  To extract the namelist and match it against
-   the EIP from the kernel crash, do:
-
-     nm vmlinux | sort | less
-
-   This will give you a list of kernel addresses sorted in ascending
-   order, from which it is simple to find the function that contains the
-   offending address.  Note that the address given by the kernel
-   debugging messages will not necessarily match exactly with the
-   function addresses (in fact, that is very unlikely), so you can't
-   just 'grep' the list: the list will, however, give you the starting
-   point of each kernel function, so by looking for the function that
-   has a starting address lower than the one you are searching for but
-   is followed by a function with a higher address you will find the one
-   you want.  In fact, it may be a good idea to include a bit of
-   "context" in your problem report, giving a few lines around the
-   interesting one. 
-
-   If you for some reason cannot do the above (you have a pre-compiled
-   kernel image or similar), telling me as much about your setup as
-   possible will help.  Please read the REPORTING-BUGS document for details.
-
- - Alternatively, you can use gdb on a running kernel. (read-only; i.e. you
-   cannot change values or set break points.) To do this, first compile the
-   kernel with -g; edit arch/i386/Makefile appropriately, then do a "make
-   clean". You'll also need to enable CONFIG_PROC_FS (via "make config").
-
-   After you've rebooted with the new kernel, do "gdb vmlinux /proc/kcore".
-   You can now use all the usual gdb commands. The command to look up the
-   point where your system crashed is "l *0xXXXXXXXX". (Replace the XXXes
-   with the EIP value.)
-
-   gdb'ing a non-running kernel currently fails because gdb (wrongly)
-   disregards the starting offset for which the kernel is compiled.
+This repository is only for development.  If you want to compile the modules see: 
+https://github.com/pfohjo/nitro-ng_kmod_build
 
+Upstream Repo
+----------------------------------------
+git://git.kernel.org/pub/scm/virt/kvm/kvm.git
\ No newline at end of file
diff --git a/README.KVM b/README.KVM
new file mode 100644
index 0000000..a24ec89
--- /dev/null
+++ b/README.KVM
@@ -0,0 +1,412 @@
+        Linux kernel release 3.x <http://kernel.org/>
+
+These are the release notes for Linux version 3.  Read them carefully,
+as they tell you what this is all about, explain how to install the
+kernel, and what to do if something goes wrong. 
+
+WHAT IS LINUX?
+
+  Linux is a clone of the operating system Unix, written from scratch by
+  Linus Torvalds with assistance from a loosely-knit team of hackers across
+  the Net. It aims towards POSIX and Single UNIX Specification compliance.
+
+  It has all the features you would expect in a modern fully-fledged Unix,
+  including true multitasking, virtual memory, shared libraries, demand
+  loading, shared copy-on-write executables, proper memory management,
+  and multistack networking including IPv4 and IPv6.
+
+  It is distributed under the GNU General Public License - see the
+  accompanying COPYING file for more details. 
+
+ON WHAT HARDWARE DOES IT RUN?
+
+  Although originally developed first for 32-bit x86-based PCs (386 or higher),
+  today Linux also runs on (at least) the Compaq Alpha AXP, Sun SPARC and
+  UltraSPARC, Motorola 68000, PowerPC, PowerPC64, ARM, Hitachi SuperH, Cell,
+  IBM S/390, MIPS, HP PA-RISC, Intel IA-64, DEC VAX, AMD x86-64, AXIS CRIS,
+  Xtensa, Tilera TILE, AVR32 and Renesas M32R architectures.
+
+  Linux is easily portable to most general-purpose 32- or 64-bit architectures
+  as long as they have a paged memory management unit (PMMU) and a port of the
+  GNU C compiler (gcc) (part of The GNU Compiler Collection, GCC). Linux has
+  also been ported to a number of architectures without a PMMU, although
+  functionality is then obviously somewhat limited.
+  Linux has also been ported to itself. You can now run the kernel as a
+  userspace application - this is called UserMode Linux (UML).
+
+DOCUMENTATION:
+
+ - There is a lot of documentation available both in electronic form on
+   the Internet and in books, both Linux-specific and pertaining to
+   general UNIX questions.  I'd recommend looking into the documentation
+   subdirectories on any Linux FTP site for the LDP (Linux Documentation
+   Project) books.  This README is not meant to be documentation on the
+   system: there are much better sources available.
+
+ - There are various README files in the Documentation/ subdirectory:
+   these typically contain kernel-specific installation notes for some 
+   drivers for example. See Documentation/00-INDEX for a list of what
+   is contained in each file.  Please read the Changes file, as it
+   contains information about the problems, which may result by upgrading
+   your kernel.
+
+ - The Documentation/DocBook/ subdirectory contains several guides for
+   kernel developers and users.  These guides can be rendered in a
+   number of formats:  PostScript (.ps), PDF, HTML, & man-pages, among others.
+   After installation, "make psdocs", "make pdfdocs", "make htmldocs",
+   or "make mandocs" will render the documentation in the requested format.
+
+INSTALLING the kernel source:
+
+ - If you install the full sources, put the kernel tarball in a
+   directory where you have permissions (eg. your home directory) and
+   unpack it:
+
+     gzip -cd linux-3.X.tar.gz | tar xvf -
+
+   or
+
+     bzip2 -dc linux-3.X.tar.bz2 | tar xvf -
+
+   Replace "X" with the version number of the latest kernel.
+
+   Do NOT use the /usr/src/linux area! This area has a (usually
+   incomplete) set of kernel headers that are used by the library header
+   files.  They should match the library, and not get messed up by
+   whatever the kernel-du-jour happens to be.
+
+ - You can also upgrade between 3.x releases by patching.  Patches are
+   distributed in the traditional gzip and the newer bzip2 format.  To
+   install by patching, get all the newer patch files, enter the
+   top level directory of the kernel source (linux-3.X) and execute:
+
+     gzip -cd ../patch-3.x.gz | patch -p1
+
+   or
+
+     bzip2 -dc ../patch-3.x.bz2 | patch -p1
+
+   Replace "x" for all versions bigger than the version "X" of your current
+   source tree, _in_order_, and you should be ok.  You may want to remove
+   the backup files (some-file-name~ or some-file-name.orig), and make sure
+   that there are no failed patches (some-file-name# or some-file-name.rej).
+   If there are, either you or I have made a mistake.
+
+   Unlike patches for the 3.x kernels, patches for the 3.x.y kernels
+   (also known as the -stable kernels) are not incremental but instead apply
+   directly to the base 3.x kernel.  For example, if your base kernel is 3.0
+   and you want to apply the 3.0.3 patch, you must not first apply the 3.0.1
+   and 3.0.2 patches. Similarly, if you are running kernel version 3.0.2 and
+   want to jump to 3.0.3, you must first reverse the 3.0.2 patch (that is,
+   patch -R) _before_ applying the 3.0.3 patch. You can read more on this in
+   Documentation/applying-patches.txt
+
+   Alternatively, the script patch-kernel can be used to automate this
+   process.  It determines the current kernel version and applies any
+   patches found.
+
+     linux/scripts/patch-kernel linux
+
+   The first argument in the command above is the location of the
+   kernel source.  Patches are applied from the current directory, but
+   an alternative directory can be specified as the second argument.
+
+ - Make sure you have no stale .o files and dependencies lying around:
+
+     cd linux
+     make mrproper
+
+   You should now have the sources correctly installed.
+
+SOFTWARE REQUIREMENTS
+
+   Compiling and running the 3.x kernels requires up-to-date
+   versions of various software packages.  Consult
+   Documentation/Changes for the minimum version numbers required
+   and how to get updates for these packages.  Beware that using
+   excessively old versions of these packages can cause indirect
+   errors that are very difficult to track down, so don't assume that
+   you can just update packages when obvious problems arise during
+   build or operation.
+
+BUILD directory for the kernel:
+
+   When compiling the kernel, all output files will per default be
+   stored together with the kernel source code.
+   Using the option "make O=output/dir" allow you to specify an alternate
+   place for the output files (including .config).
+   Example:
+
+     kernel source code: /usr/src/linux-3.X
+     build directory:    /home/name/build/kernel
+
+   To configure and build the kernel, use:
+
+     cd /usr/src/linux-3.X
+     make O=/home/name/build/kernel menuconfig
+     make O=/home/name/build/kernel
+     sudo make O=/home/name/build/kernel modules_install install
+
+   Please note: If the 'O=output/dir' option is used, then it must be
+   used for all invocations of make.
+
+CONFIGURING the kernel:
+
+   Do not skip this step even if you are only upgrading one minor
+   version.  New configuration options are added in each release, and
+   odd problems will turn up if the configuration files are not set up
+   as expected.  If you want to carry your existing configuration to a
+   new version with minimal work, use "make oldconfig", which will
+   only ask you for the answers to new questions.
+
+ - Alternative configuration commands are:
+
+     "make config"      Plain text interface.
+
+     "make menuconfig"  Text based color menus, radiolists & dialogs.
+
+     "make nconfig"     Enhanced text based color menus.
+
+     "make xconfig"     X windows (Qt) based configuration tool.
+
+     "make gconfig"     X windows (Gtk) based configuration tool.
+
+     "make oldconfig"   Default all questions based on the contents of
+                        your existing ./.config file and asking about
+                        new config symbols.
+
+     "make silentoldconfig"
+                        Like above, but avoids cluttering the screen
+                        with questions already answered.
+                        Additionally updates the dependencies.
+
+     "make olddefconfig"
+                        Like above, but sets new symbols to their default
+                        values without prompting.
+
+     "make defconfig"   Create a ./.config file by using the default
+                        symbol values from either arch/$ARCH/defconfig
+                        or arch/$ARCH/configs/${PLATFORM}_defconfig,
+                        depending on the architecture.
+
+     "make ${PLATFORM}_defconfig"
+                        Create a ./.config file by using the default
+                        symbol values from
+                        arch/$ARCH/configs/${PLATFORM}_defconfig.
+                        Use "make help" to get a list of all available
+                        platforms of your architecture.
+
+     "make allyesconfig"
+                        Create a ./.config file by setting symbol
+                        values to 'y' as much as possible.
+
+     "make allmodconfig"
+                        Create a ./.config file by setting symbol
+                        values to 'm' as much as possible.
+
+     "make allnoconfig" Create a ./.config file by setting symbol
+                        values to 'n' as much as possible.
+
+     "make randconfig"  Create a ./.config file by setting symbol
+                        values to random values.
+
+     "make localmodconfig" Create a config based on current config and
+                           loaded modules (lsmod). Disables any module
+                           option that is not needed for the loaded modules.
+
+                           To create a localmodconfig for another machine,
+                           store the lsmod of that machine into a file
+                           and pass it in as a LSMOD parameter.
+
+                   target$ lsmod > /tmp/mylsmod
+                   target$ scp /tmp/mylsmod host:/tmp
+
+                   host$ make LSMOD=/tmp/mylsmod localmodconfig
+
+                           The above also works when cross compiling.
+
+     "make localyesconfig" Similar to localmodconfig, except it will convert
+                           all module options to built in (=y) options.
+
+   You can find more information on using the Linux kernel config tools
+   in Documentation/kbuild/kconfig.txt.
+
+ - NOTES on "make config":
+
+    - Having unnecessary drivers will make the kernel bigger, and can
+      under some circumstances lead to problems: probing for a
+      nonexistent controller card may confuse your other controllers
+
+    - Compiling the kernel with "Processor type" set higher than 386
+      will result in a kernel that does NOT work on a 386.  The
+      kernel will detect this on bootup, and give up.
+
+    - A kernel with math-emulation compiled in will still use the
+      coprocessor if one is present: the math emulation will just
+      never get used in that case.  The kernel will be slightly larger,
+      but will work on different machines regardless of whether they
+      have a math coprocessor or not.
+
+    - The "kernel hacking" configuration details usually result in a
+      bigger or slower kernel (or both), and can even make the kernel
+      less stable by configuring some routines to actively try to
+      break bad code to find kernel problems (kmalloc()).  Thus you
+      should probably answer 'n' to the questions for "development",
+      "experimental", or "debugging" features.
+
+COMPILING the kernel:
+
+ - Make sure you have at least gcc 3.2 available.
+   For more information, refer to Documentation/Changes.
+
+   Please note that you can still run a.out user programs with this kernel.
+
+ - Do a "make" to create a compressed kernel image. It is also
+   possible to do "make install" if you have lilo installed to suit the
+   kernel makefiles, but you may want to check your particular lilo setup first.
+
+   To do the actual install, you have to be root, but none of the normal
+   build should require that. Don't take the name of root in vain.
+
+ - If you configured any of the parts of the kernel as `modules', you
+   will also have to do "make modules_install".
+
+ - Verbose kernel compile/build output:
+
+   Normally, the kernel build system runs in a fairly quiet mode (but not
+   totally silent).  However, sometimes you or other kernel developers need
+   to see compile, link, or other commands exactly as they are executed.
+   For this, use "verbose" build mode.  This is done by inserting
+   "V=1" in the "make" command.  E.g.:
+
+     make V=1 all
+
+   To have the build system also tell the reason for the rebuild of each
+   target, use "V=2".  The default is "V=0".
+
+ - Keep a backup kernel handy in case something goes wrong.  This is 
+   especially true for the development releases, since each new release
+   contains new code which has not been debugged.  Make sure you keep a
+   backup of the modules corresponding to that kernel, as well.  If you
+   are installing a new kernel with the same version number as your
+   working kernel, make a backup of your modules directory before you
+   do a "make modules_install".
+
+   Alternatively, before compiling, use the kernel config option
+   "LOCALVERSION" to append a unique suffix to the regular kernel version.
+   LOCALVERSION can be set in the "General Setup" menu.
+
+ - In order to boot your new kernel, you'll need to copy the kernel
+   image (e.g. .../linux/arch/i386/boot/bzImage after compilation)
+   to the place where your regular bootable kernel is found. 
+
+ - Booting a kernel directly from a floppy without the assistance of a
+   bootloader such as LILO, is no longer supported.
+
+   If you boot Linux from the hard drive, chances are you use LILO, which
+   uses the kernel image as specified in the file /etc/lilo.conf.  The
+   kernel image file is usually /vmlinuz, /boot/vmlinuz, /bzImage or
+   /boot/bzImage.  To use the new kernel, save a copy of the old image
+   and copy the new image over the old one.  Then, you MUST RERUN LILO
+   to update the loading map!! If you don't, you won't be able to boot
+   the new kernel image.
+
+   Reinstalling LILO is usually a matter of running /sbin/lilo. 
+   You may wish to edit /etc/lilo.conf to specify an entry for your
+   old kernel image (say, /vmlinux.old) in case the new one does not
+   work.  See the LILO docs for more information. 
+
+   After reinstalling LILO, you should be all set.  Shutdown the system,
+   reboot, and enjoy!
+
+   If you ever need to change the default root device, video mode,
+   ramdisk size, etc.  in the kernel image, use the 'rdev' program (or
+   alternatively the LILO boot options when appropriate).  No need to
+   recompile the kernel to change these parameters. 
+
+ - Reboot with the new kernel and enjoy. 
+
+IF SOMETHING GOES WRONG:
+
+ - If you have problems that seem to be due to kernel bugs, please check
+   the file MAINTAINERS to see if there is a particular person associated
+   with the part of the kernel that you are having trouble with. If there
+   isn't anyone listed there, then the second best thing is to mail
+   them to me ([email protected]), and possibly to any other
+   relevant mailing-list or to the newsgroup.
+
+ - In all bug-reports, *please* tell what kernel you are talking about,
+   how to duplicate the problem, and what your setup is (use your common
+   sense).  If the problem is new, tell me so, and if the problem is
+   old, please try to tell me when you first noticed it.
+
+ - If the bug results in a message like
+
+     unable to handle kernel paging request at address C0000010
+     Oops: 0002
+     EIP:   0010:XXXXXXXX
+     eax: xxxxxxxx   ebx: xxxxxxxx   ecx: xxxxxxxx   edx: xxxxxxxx
+     esi: xxxxxxxx   edi: xxxxxxxx   ebp: xxxxxxxx
+     ds: xxxx  es: xxxx  fs: xxxx  gs: xxxx
+     Pid: xx, process nr: xx
+     xx xx xx xx xx xx xx xx xx xx
+
+   or similar kernel debugging information on your screen or in your
+   system log, please duplicate it *exactly*.  The dump may look
+   incomprehensible to you, but it does contain information that may
+   help debugging the problem.  The text above the dump is also
+   important: it tells something about why the kernel dumped code (in
+   the above example, it's due to a bad kernel pointer). More information
+   on making sense of the dump is in Documentation/oops-tracing.txt
+
+ - If you compiled the kernel with CONFIG_KALLSYMS you can send the dump
+   as is, otherwise you will have to use the "ksymoops" program to make
+   sense of the dump (but compiling with CONFIG_KALLSYMS is usually preferred).
+   This utility can be downloaded from
+   ftp://ftp.<country>.kernel.org/pub/linux/utils/kernel/ksymoops/ .
+   Alternatively, you can do the dump lookup by hand:
+
+ - In debugging dumps like the above, it helps enormously if you can
+   look up what the EIP value means.  The hex value as such doesn't help
+   me or anybody else very much: it will depend on your particular
+   kernel setup.  What you should do is take the hex value from the EIP
+   line (ignore the "0010:"), and look it up in the kernel namelist to
+   see which kernel function contains the offending address.
+
+   To find out the kernel function name, you'll need to find the system
+   binary associated with the kernel that exhibited the symptom.  This is
+   the file 'linux/vmlinux'.  To extract the namelist and match it against
+   the EIP from the kernel crash, do:
+
+     nm vmlinux | sort | less
+
+   This will give you a list of kernel addresses sorted in ascending
+   order, from which it is simple to find the function that contains the
+   offending address.  Note that the address given by the kernel
+   debugging messages will not necessarily match exactly with the
+   function addresses (in fact, that is very unlikely), so you can't
+   just 'grep' the list: the list will, however, give you the starting
+   point of each kernel function, so by looking for the function that
+   has a starting address lower than the one you are searching for but
+   is followed by a function with a higher address you will find the one
+   you want.  In fact, it may be a good idea to include a bit of
+   "context" in your problem report, giving a few lines around the
+   interesting one. 
+
+   If you for some reason cannot do the above (you have a pre-compiled
+   kernel image or similar), telling me as much about your setup as
+   possible will help.  Please read the REPORTING-BUGS document for details.
+
+ - Alternatively, you can use gdb on a running kernel. (read-only; i.e. you
+   cannot change values or set break points.) To do this, first compile the
+   kernel with -g; edit arch/i386/Makefile appropriately, then do a "make
+   clean". You'll also need to enable CONFIG_PROC_FS (via "make config").
+
+   After you've rebooted with the new kernel, do "gdb vmlinux /proc/kcore".
+   You can now use all the usual gdb commands. The command to look up the
+   point where your system crashed is "l *0xXXXXXXXX". (Replace the XXXes
+   with the EIP value.)
+
+   gdb'ing a non-running kernel currently fails because gdb (wrongly)
+   disregards the starting offset for which the kernel is compiled.
+
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 07ffca0..413b9af 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <asm/kvm_emulate.h>
 #include <linux/stringify.h>
+#include <linux/nitro_main.h>
 
 #include "x86.h"
 #include "tss.h"
@@ -2153,6 +2154,7 @@ static int em_syscall(struct x86_emulate_ctxt *ctxt)
 	u64 msr_data;
 	u16 cs_sel, ss_sel;
 	u64 efer = 0;
+	struct kvm_vcpu *vcpu = container_of(ctxt, struct kvm_vcpu, arch.emulate_ctxt);
 
 	/* syscall is not available in real mode */
 	if (ctxt->mode == X86EMUL_MODE_REAL ||
@@ -2165,7 +2167,7 @@ static int em_syscall(struct x86_emulate_ctxt *ctxt)
 	ops->get_msr(ctxt, MSR_EFER, &efer);
 	setup_syscalls_segments(ctxt, &cs, &ss);
 
-	if (!(efer & EFER_SCE))
+	if (!(efer & EFER_SCE) && !vcpu->kvm->nitro.trap_syscall)
 		return emulate_ud(ctxt);
 
 	ops->get_msr(ctxt, MSR_STAR, &msr_data);
@@ -2201,6 +2203,76 @@ static int em_syscall(struct x86_emulate_ctxt *ctxt)
 		ctxt->eflags &= ~(EFLG_VM | EFLG_IF | EFLG_RF);
 	}
 
+	if(vcpu->kvm->nitro.trap_syscall)
+	  vcpu->nitro.trap_syscall_hit = 1;
+	
+	return X86EMUL_CONTINUE;
+}
+
+static int em_sysret(struct x86_emulate_ctxt *ctxt)
+{
+	const struct x86_emulate_ops *ops = ctxt->ops;
+	struct desc_struct cs, ss;
+	u64 msr_data, rcx;
+	u16 cs_sel, ss_sel;
+	u64 efer = 0;
+	struct kvm_vcpu *vcpu = container_of(ctxt, struct kvm_vcpu, arch.emulate_ctxt);
+
+	/* syscall is not available in real mode */
+	if (ctxt->mode == X86EMUL_MODE_REAL ||
+	    ctxt->mode == X86EMUL_MODE_VM86)
+		return emulate_ud(ctxt);
+
+	if (!(em_syscall_is_enabled(ctxt)))
+		return emulate_ud(ctxt);
+	
+	if(ctxt->ops->cpl(ctxt) != 0){
+		return emulate_gp(ctxt,0);
+	}
+	
+	//check if RCX is in canonical form
+	rcx = reg_read(ctxt, VCPU_REGS_RCX);
+	if(( (rcx & 0xFFFF800000000000) != 0xFFFF800000000000) &&
+	  ( (rcx & 0x00007FFFFFFFFFFF) != rcx)){
+		return emulate_gp(ctxt,0);
+	}
+
+	ops->get_msr(ctxt, MSR_EFER, &efer);
+	setup_syscalls_segments(ctxt, &cs, &ss);
+
+	if (!(efer & EFER_SCE) && !vcpu->kvm->nitro.trap_syscall)
+		return emulate_ud(ctxt);
+
+
+	ops->get_msr(ctxt, MSR_STAR, &msr_data);
+	msr_data >>= 48;
+	
+	//setup code segment, atleast what is left to do.  
+	//setup_syscalls_segments does most of the work for us
+	if (ctxt->mode == X86EMUL_MODE_PROT64){ //if longmode
+	  cs_sel = (u16)((msr_data + 0x10) | 0x3);
+	  cs.l = 1;
+	  cs.d = 0;
+	}
+	else{
+	  cs_sel = (u16)(msr_data | 0x3);
+	  cs.l = 0;
+	  cs.d = 1;
+	}
+	cs.dpl = 0x3;
+	
+	//setup stack segment, atleast what is left to do.  
+	//setup_syscalls_segments does most of the work for us
+	ss_sel = (u16)((msr_data + 0x8) | 0x3);
+	ss.dpl = 0x3;
+	
+	ops->set_segment(ctxt, cs_sel, &cs, 0, VCPU_SREG_CS);
+	ops->set_segment(ctxt, ss_sel, &ss, 0, VCPU_SREG_SS);
+	
+	ctxt->eflags = (reg_read(ctxt, VCPU_REGS_R11) & 0x3c7fd7) | 0x2;
+
+	ctxt->_eip = reg_read(ctxt, VCPU_REGS_RCX);
+
 	return X86EMUL_CONTINUE;
 }
 
@@ -3038,8 +3110,13 @@ static int em_wrmsr(struct x86_emulate_ctxt *ctxt)
 static int em_rdmsr(struct x86_emulate_ctxt *ctxt)
 {
 	u64 msr_data;
+	u32 msr_index;
+	
+	msr_index = reg_read(ctxt, VCPU_REGS_RCX);
+	
+	printk(KERN_INFO "nitro: rdmsr: 0x%x\n", msr_index);
 
-	if (ctxt->ops->get_msr(ctxt, reg_read(ctxt, VCPU_REGS_RCX), &msr_data))
+	if (ctxt->ops->get_msr(ctxt, msr_index, &msr_data))
 		return emulate_gp(ctxt, 0);
 
 	*reg_write(ctxt, VCPU_REGS_RAX) = (u32)msr_data;
@@ -3858,7 +3935,7 @@ static const struct opcode twobyte_table[256] = {
 	/* 0x00 - 0x0F */
 	G(0, group6), GD(0, &group7), N, N,
 	N, I(ImplicitOps | EmulateOnUD, em_syscall),
-	II(ImplicitOps | Priv, em_clts, clts), N,
+	II(ImplicitOps | Priv, em_clts, clts), I(ImplicitOps | EmulateOnUD | Priv, em_sysret),
 	DI(ImplicitOps | Priv, invd), DI(ImplicitOps | Priv, wbinvd), N, N,
 	N, D(ImplicitOps | ModRM), N, N,
 	/* 0x10 - 0x1F */
diff --git a/arch/x86/kvm/nitro_x86.c b/arch/x86/kvm/nitro_x86.c
new file mode 100644
index 0000000..1884671
--- /dev/null
+++ b/arch/x86/kvm/nitro_x86.c
@@ -0,0 +1,115 @@
+#include "nitro_x86.h"
+
+#include "x86.h"
+
+#include <linux/nitro_main.h>
+#include <linux/kernel.h>
+#include <linux/completion.h>
+
+extern int kvm_set_msr_common(struct kvm_vcpu*, struct msr_data*);
+
+int nitro_set_syscall_trap(struct kvm *kvm,unsigned long *bitmap,int max_syscall){
+  int i;
+  struct kvm_vcpu *vcpu;
+  u64 efer;
+  struct msr_data msr_info;
+  
+  printk(KERN_INFO "nitro: set syscall trap\n");
+  
+  kvm->nitro.syscall_bitmap = bitmap;
+  kvm->nitro.max_syscall = max_syscall;
+  
+  kvm->nitro.trap_syscall = 1;
+  
+  kvm_for_each_vcpu(i, vcpu, kvm){
+    //vcpu_load(vcpu);
+    nitro_vcpu_load(vcpu);
+    
+    kvm_get_msr_common(vcpu, MSR_EFER, &efer);
+    msr_info.index = MSR_EFER;
+    msr_info.data = efer & ~EFER_SCE;
+    msr_info.host_initiated = true;
+    kvm_set_msr_common(vcpu, &msr_info);
+    
+    init_completion(&vcpu->nitro.k_wait_cv);
+    
+    vcpu_put(vcpu);
+  }
+  
+  return 0;
+}
+
+int nitro_unset_syscall_trap(struct kvm *kvm){
+  int i;
+  struct kvm_vcpu *vcpu;
+  u64 efer;
+  struct msr_data msr_info;
+  
+  printk(KERN_INFO "nitro: unset syscall trap\n");
+  
+  kvm_for_each_vcpu(i, vcpu, kvm){
+    //vcpu_load(vcpu);
+    
+    vcpu->nitro.trap_syscall_hit = 0;
+    //if waiters, wake up
+    //if(completion_done(&(vcpu->nitro.k_wait_cv)) == 0)
+    complete_all(&(vcpu->nitro.k_wait_cv));
+    
+    
+    nitro_vcpu_load(vcpu);
+    
+    kvm_get_msr_common(vcpu, MSR_EFER, &efer);
+    msr_info.index = MSR_EFER;
+    msr_info.data = efer | EFER_SCE;
+    msr_info.host_initiated = true;
+    kvm_set_msr_common(vcpu, &msr_info);
+    
+
+    
+    vcpu_put(vcpu);
+  }
+  
+  kvm->nitro.trap_syscall = 0;
+  if(kvm->nitro.syscall_bitmap != NULL){
+    kfree(kvm->nitro.syscall_bitmap);
+    kvm->nitro.syscall_bitmap = NULL;
+  }
+  kvm->nitro.max_syscall = 0;
+
+  return 0;
+}
+
+int nitro_handle_syscall_trap(struct kvm_vcpu *vcpu){
+  unsigned long syscall_nr;
+  long rv;
+  struct kvm *kvm;
+  
+  kvm = vcpu->kvm;
+  
+  vcpu->nitro.trap_syscall_hit = 0;
+  
+  if(kvm->nitro.max_syscall > 0){
+    syscall_nr = kvm_register_read(vcpu, VCPU_REGS_RAX);
+    
+    if(syscall_nr > INT_MAX || syscall_nr > kvm->nitro.max_syscall || !test_bit((int)syscall_nr,kvm->nitro.syscall_bitmap))
+      return 1;
+  }
+  
+  
+  vcpu->nitro.event = KVM_NITRO_SYSCALL_TRAPPED;
+  
+  up(&(vcpu->nitro.n_wait_sem));
+  //vcpu_put(vcpu);
+  rv = wait_for_completion_interruptible_timeout(&(vcpu->nitro.k_wait_cv),msecs_to_jiffies(30000));
+  
+  if (rv == 0)
+    printk(KERN_INFO "nitro: %s: wait timed out\n",__FUNCTION__);
+  else if (rv < 0)
+    printk(KERN_INFO "nitro: %s: wait interrupted\n",__FUNCTION__);
+  
+  //vcpu_load(vcpu);
+
+  //returning 0 will give control back to qemu
+  return 1;
+}
+
diff --git a/arch/x86/kvm/nitro_x86.h b/arch/x86/kvm/nitro_x86.h
new file mode 100644
index 0000000..c037750
--- /dev/null
+++ b/arch/x86/kvm/nitro_x86.h
@@ -0,0 +1,11 @@
+#ifndef NITRO_X86_H_
+#define NITRO_X86_H_
+
+#include <linux/kvm_host.h>
+
+int nitro_set_syscall_trap(struct kvm*,unsigned long*,int);
+int nitro_unset_syscall_trap(struct kvm*);
+
+int nitro_handle_syscall_trap(struct kvm_vcpu*);
+
+#endif //NITRO_X86_H_
\ No newline at end of file
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 5d004da..b109fae 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -64,6 +64,10 @@
 #include <asm/pvclock.h>
 #include <asm/div64.h>
 
+#include <linux/nitro.h>
+#include <linux/nitro_main.h>
+#include "nitro_x86.h"
+
 #define MAX_IO_MSRS 256
 #define KVM_MAX_MCE_BANKS 32
 #define KVM_MCE_CAP_SUPPORTED (MCG_CTL_P | MCG_SER_P)
@@ -3860,6 +3864,61 @@ long kvm_arch_vm_ioctl(struct file *filp,
 		r = 0;
 		break;
 	}
+	case KVM_NITRO_SET_SYSCALL_TRAP: {
+		struct nitro_syscall_trap user_sct;
+		int *syscalls;
+		int max_syscall, i, bm_size;
+		long unsigned *bitmap;
+
+		r = -EFAULT;
+		if (copy_from_user(&user_sct, argp, sizeof(struct nitro_syscall_trap)))
+			goto out;
+		
+		if(user_sct.size > 0){
+			r = -ENOMEM;
+			syscalls = kmalloc(user_sct.size * sizeof(int), GFP_KERNEL);
+			if (syscalls == NULL)
+				goto out;
+			
+			r = -EFAULT;
+			if (copy_from_user(syscalls, user_sct.syscalls, user_sct.size * sizeof(int))){
+				kfree(syscalls);
+				goto out;
+			}
+			
+			max_syscall = 0;
+			for(i=0;i<user_sct.size;i++)
+				if(syscalls[i] > max_syscall)
+					max_syscall = syscalls[i];
+				
+			bm_size = ((max_syscall / (sizeof(unsigned long) * 8)) + 1) * (sizeof(unsigned long) * 8);
+  
+			r = -ENOMEM;
+			bitmap = kmalloc(bm_size / 8, GFP_KERNEL);
+			if (bitmap == NULL){
+				kfree(syscalls);
+				goto out;
+			}
+			
+			bitmap_zero(bitmap,bm_size);
+			
+			for(i=0;i<user_sct.size;i++)
+			  set_bit(syscalls[i],bitmap);
+			
+			kfree(syscalls);
+		}
+		else{
+			bitmap = NULL;
+			max_syscall = 0;
+		}
+	  
+		r = nitro_set_syscall_trap(kvm,bitmap,max_syscall);
+		break;
+	}
+	case KVM_NITRO_UNSET_SYSCALL_TRAP: {
+		r = nitro_unset_syscall_trap(kvm);
+		break;
+	}
 
 	default:
 		;
@@ -6021,6 +6080,7 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
 		kvm_lapic_sync_from_vapic(vcpu);
 
 	r = kvm_x86_ops->handle_exit(vcpu);
+	
 	return r;
 
 cancel_injection:
@@ -6044,6 +6104,10 @@ static int __vcpu_run(struct kvm_vcpu *vcpu)
 		if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE &&
 		    !vcpu->arch.apf.halted)
 			r = vcpu_enter_guest(vcpu);
+	
+			if(r > 0 && vcpu->nitro.trap_syscall_hit)
+				//r = nitro_handle_syscall_trap(vcpu);
+				nitro_handle_syscall_trap(vcpu);
 		else {
 			srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx);
 			kvm_vcpu_block(vcpu);
@@ -6705,6 +6769,8 @@ void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
 	kvm_mmu_unload(vcpu);
 	vcpu_put(vcpu);
 
+	nitro_destroy_vcpu_hook(vcpu);
+	
 	fx_free(vcpu);
 	kvm_x86_ops->vcpu_free(vcpu);
 }
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 9523d2a..b27ffe8 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -33,6 +33,8 @@
 
 #include <asm/kvm_host.h>
 
+#include <linux/nitro_main.h>
+
 #ifndef KVM_MMIO_SIZE
 #define KVM_MMIO_SIZE 8
 #endif
@@ -271,6 +273,8 @@ struct kvm_vcpu {
 #endif
 	bool preempted;
 	struct kvm_vcpu_arch arch;
+	
+	struct nitro_vcpu nitro;
 };
 
 static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
@@ -405,6 +409,8 @@ struct kvm {
 #endif
 	long tlbs_dirty;
 	struct list_head devices;
+	
+	struct nitro nitro;
 };
 
 #define kvm_err(fmt, ...) \
diff --git a/include/linux/nitro.h b/include/linux/nitro.h
new file mode 100644
index 0000000..5c751a8
--- /dev/null
+++ b/include/linux/nitro.h
@@ -0,0 +1,39 @@
+#ifndef NITRO_H_
+#define NITRO_H_
+
+#include <linux/ioctl.h>
+#include <linux/kvm.h>
+#include <linux/types.h>
+
+#define NITRO_MAX_VCPUS 64
+
+struct nitro_vcpus{
+  int num_vcpus;
+  int ids[NITRO_MAX_VCPUS];
+  int fds[NITRO_MAX_VCPUS];
+};
+
+struct nitro_syscall_trap{
+  int *syscalls;
+  int size;
+};
+
+//return reasons
+#define KVM_NITRO_ERROR			0
+#define KVM_NITRO_TIMEOUT		1
+#define KVM_NITRO_SYSCALL_TRAPPED	2
+
+//KVM functions
+#define KVM_NITRO_NUM_VMS  	_IO(KVMIO, 0xE0)
+#define KVM_NITRO_ATTACH_VM  	_IOW(KVMIO, 0xE1, pid_t)
+
+//VM functions
+#define KVM_NITRO_ATTACH_VCPUS	_IOR(KVMIO, 0xE2, struct nitro_vcpus)
+#define KVM_NITRO_SET_SYSCALL_TRAP _IOW(KVMIO, 0xE3, struct nitro_syscall_trap)
+#define KVM_NITRO_UNSET_SYSCALL_TRAP _IO(KVMIO, 0xE4)
+
+//VCPU functions
+#define KVM_NITRO_GET_EVENT	_IO(KVMIO, 0xE5)
+#define KVM_NITRO_CONTINUE	_IO(KVMIO, 0xE6)
+
+#endif //NITRO_H_
diff --git a/include/linux/nitro_main.h b/include/linux/nitro_main.h
new file mode 100644
index 0000000..22a2ae7
--- /dev/null
+++ b/include/linux/nitro_main.h
@@ -0,0 +1,39 @@
+#ifndef NITRO_MAIN_H_
+#define NITRO_MAIN_H_
+
+#include <linux/list.h>
+#include <linux/types.h>
+#include <linux/kvm_host.h>
+#include <linux/nitro.h>
+
+
+struct nitro{
+  int trap_syscall; //determines whether the syscall trap is globally set
+  unsigned long *syscall_bitmap;
+  unsigned int max_syscall;
+};
+
+struct nitro_vcpu{
+  int trap_syscall_hit;
+  struct completion k_wait_cv;
+  struct semaphore n_wait_sem;
+  int event;
+};
+  
+int nitro_vcpu_load(struct kvm_vcpu*);
+
+struct kvm* nitro_get_vm_by_creator(pid_t);
+
+int nitro_iotcl_num_vms(void);
+int nitro_iotcl_attach_vcpus(struct kvm*, struct nitro_vcpus*);
+
+
+void nitro_create_vm_hook(struct kvm*);
+void nitro_destroy_vm_hook(struct kvm*);
+void nitro_create_vcpu_hook(struct kvm_vcpu*);
+void nitro_destroy_vcpu_hook(struct kvm_vcpu*);
+
+int nitro_ioctl_get_event(struct kvm_vcpu*);
+int nitro_ioctl_continue(struct kvm_vcpu*);
+
+#endif //NITRO_MAIN_H_
\ No newline at end of file
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 4f588bc..6bf72af 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -61,6 +61,9 @@
 #define CREATE_TRACE_POINTS
 #include <trace/events/kvm.h>
 
+#include <linux/nitro.h>
+#include <linux/nitro_main.h>
+
 MODULE_AUTHOR("Qumranet");
 MODULE_LICENSE("GPL");
 
@@ -581,6 +584,8 @@ static void kvm_destroy_vm(struct kvm *kvm)
 {
 	int i;
 	struct mm_struct *mm = kvm->mm;
+	
+	nitro_destroy_vm_hook(kvm);
 
 	kvm_arch_sync_events(kvm);
 	spin_lock(&kvm_lock);
@@ -1885,7 +1890,7 @@ static struct file_operations kvm_vcpu_fops = {
 /*
  * Allocates an inode for the vcpu.
  */
-static int create_vcpu_fd(struct kvm_vcpu *vcpu)
+int create_vcpu_fd(struct kvm_vcpu *vcpu)
 {
 	return anon_inode_getfd("kvm-vcpu", &kvm_vcpu_fops, vcpu, O_RDWR | O_CLOEXEC);
 }
@@ -1940,6 +1945,8 @@ static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
 	kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
 	smp_wmb();
 	atomic_inc(&kvm->online_vcpus);
+	
+	nitro_create_vcpu_hook(vcpu);
 
 	mutex_unlock(&kvm->lock);
 	kvm_arch_vcpu_postcreate(vcpu);
@@ -1972,18 +1979,38 @@ static long kvm_vcpu_ioctl(struct file *filp,
 	struct kvm_fpu *fpu = NULL;
 	struct kvm_sregs *kvm_sregs = NULL;
 
-	if (vcpu->kvm->mm != current->mm)
-		return -EIO;
-
+	//asynchronous calls that dont require vcpu_load()
+	switch(ioctl){
+	case KVM_NITRO_GET_EVENT:
+		return nitro_ioctl_get_event(vcpu);
+		break;
+	case KVM_NITRO_CONTINUE:
+		return nitro_ioctl_continue(vcpu);
+		break;
 #if defined(CONFIG_S390) || defined(CONFIG_PPC) || defined(CONFIG_MIPS)
-	/*
+	case KVM_S390_INTERRUPT:
+	case KVM_INTERRUPT:
+		return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
+		break;
+#endif
+	}
+/*
+#if defined(CONFIG_S390) || defined(CONFIG_PPC) || defined(CONFIG_MIPS)
+	*
 	 * Special cases: vcpu ioctls that are asynchronous to vcpu execution,
 	 * so vcpu_load() would break it.
-	 */
+	 *
 	if (ioctl == KVM_S390_INTERRUPT || ioctl == KVM_INTERRUPT)
 		return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
 #endif
-
+	
+	//asynchronous nitro calls
+	if (ioctl == KVM_NITRO_GET_EVENT)
+		return nitro_ioctl_get_event(vcpu);
+	else if(ioctl == KVM_NITRO_CONTINUE)
+		return nitro_ioctl_continue(vcpu);
+*/
+	
 
 	r = vcpu_load(vcpu);
 	if (r)
@@ -2323,8 +2350,8 @@ static long kvm_vm_ioctl(struct file *filp,
 	void __user *argp = (void __user *)arg;
 	int r;
 
-	if (kvm->mm != current->mm)
-		return -EIO;
+	//if (kvm->mm != current->mm)
+	//	return -EIO;
 	switch (ioctl) {
 	case KVM_CREATE_VCPU:
 		r = kvm_vm_ioctl_create_vcpu(kvm, arg);
@@ -2479,6 +2506,24 @@ static long kvm_vm_ioctl(struct file *filp,
 		r = 0;
 		break;
 	}
+	case KVM_NITRO_ATTACH_VCPUS: {
+		int i;
+		struct nitro_vcpus nvcpus;
+
+		r = nitro_iotcl_attach_vcpus(kvm,&nvcpus);
+		if (r)
+			goto out;
+
+		r = -EFAULT;
+		if (copy_to_user(argp, &nvcpus, sizeof(nvcpus))){
+			for(i=0;i<nvcpus.num_vcpus;i++)
+				kvm_put_kvm(kvm);
+			goto out;
+		}
+
+		r = 0;
+		break;
+	}
 	default:
 		r = kvm_arch_vm_ioctl(filp, ioctl, arg);
 		if (r == -ENOTTY)
@@ -2556,7 +2601,11 @@ static int kvm_dev_ioctl_create_vm(unsigned long type)
 		return r;
 	}
 #endif
+
+	nitro_create_vm_hook(kvm);
+
 	r = anon_inode_getfd("kvm-vm", &kvm_vm_fops, kvm, O_RDWR | O_CLOEXEC);
+
 	if (r < 0)
 		kvm_put_kvm(kvm);
 
@@ -2593,6 +2642,7 @@ static long kvm_dev_ioctl_check_extension_generic(long arg)
 static long kvm_dev_ioctl(struct file *filp,
 			  unsigned int ioctl, unsigned long arg)
 {
+	void __user *argp = (void __user *)arg;
 	long r = -EINVAL;
 
 	switch (ioctl) {
@@ -2625,6 +2675,28 @@ static long kvm_dev_ioctl(struct file *filp,
 	case KVM_TRACE_DISABLE:
 		r = -EOPNOTSUPP;
 		break;
+	case KVM_NITRO_NUM_VMS:
+		r = nitro_iotcl_num_vms();
+		break;
+	case KVM_NITRO_ATTACH_VM: {
+		pid_t creator;
+		struct kvm *kvm;
+		
+		r = -EFAULT;
+		if (copy_from_user(&creator, argp, sizeof(pid_t)))
+			goto out;
+		
+		r = -ESRCH;
+		kvm = nitro_get_vm_by_creator(creator);
+		if(kvm == NULL)
+			goto out;
+		
+		kvm_get_kvm(kvm);
+		r = anon_inode_getfd("kvm-vm", &kvm_vm_fops, kvm, O_RDWR | O_CLOEXEC);
+		if(r<0)
+			kvm_put_kvm(kvm);
+		break;
+	}
 	default:
 		return kvm_arch_dev_ioctl(filp, ioctl, arg);
 	}
diff --git a/virt/kvm/nitro_main.c b/virt/kvm/nitro_main.c
new file mode 100644
index 0000000..eafe76d
--- /dev/null
+++ b/virt/kvm/nitro_main.c
@@ -0,0 +1,149 @@
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/pid.h>
+#include <linux/slab.h>
+#include <linux/stddef.h>
+#include <linux/compiler.h>
+#include <asm/current.h>
+#include <asm-generic/errno-base.h>
+#include <linux/preempt.h>
+
+#include <linux/kvm_host.h>
+
+#include <linux/nitro_main.h>
+
+extern int create_vcpu_fd(struct kvm_vcpu*);
+
+int nitro_vcpu_load(struct kvm_vcpu *vcpu)
+{
+	int cpu;
+
+	if (mutex_lock_killable(&vcpu->mutex))
+		return -EINTR;
+	cpu = get_cpu();
+	preempt_notifier_register(&vcpu->preempt_notifier);
+	kvm_arch_vcpu_load(vcpu, cpu);
+	put_cpu();
+	return 0;
+}
+
+struct kvm* nitro_get_vm_by_creator(pid_t creator){
+  struct kvm *rv;
+  struct kvm *kvm;
+  
+  rv = NULL;
+  
+  spin_lock(&kvm_lock);
+  list_for_each_entry(kvm,&vm_list,vm_list)
+    if(kvm->mm->owner->pid == creator){
+      rv = kvm;
+      break;
+    }
+  spin_unlock(&kvm_lock);
+  
+  return rv;
+}
+
+void nitro_create_vm_hook(struct kvm *kvm){
+  pid_t pid;
+  
+  //get current pid
+  pid = pid_nr(get_task_pid(current, PIDTYPE_PID));
+  printk(KERN_INFO "nitro: new VM created, creating process: %d\n", pid);
+  
+  //init nitro
+  kvm->nitro.trap_syscall = 0;
+  kvm->nitro.syscall_bitmap = NULL;
+  kvm->nitro.max_syscall = 0;
+}
+
+void nitro_destroy_vm_hook(struct kvm *kvm){
+  
+  //deinit nitro
+  kvm->nitro.trap_syscall = 0;
+  if(kvm->nitro.syscall_bitmap != NULL){
+    kfree(kvm->nitro.syscall_bitmap);
+    kvm->nitro.syscall_bitmap = NULL;
+  }
+  kvm->nitro.max_syscall = 0;
+  
+}
+
+void nitro_create_vcpu_hook(struct kvm_vcpu *vcpu){
+  vcpu->nitro.trap_syscall_hit = 0;
+  init_completion(&(vcpu->nitro.k_wait_cv));
+  sema_init(&(vcpu->nitro.n_wait_sem),0);
+  vcpu->nitro.event = 0;
+}
+
+void nitro_destroy_vcpu_hook(struct kvm_vcpu *vcpu){
+  vcpu->nitro.trap_syscall_hit = 0;
+  vcpu->nitro.event = 0;
+}
+
+int nitro_iotcl_num_vms(void){
+  struct kvm *kvm;
+  int rv = 0;
+  
+  spin_lock(&kvm_lock);
+  list_for_each_entry(kvm, &vm_list, vm_list)
+    rv++;
+  spin_unlock(&kvm_lock);
+  
+  return rv;
+}
+
+int nitro_iotcl_attach_vcpus(struct kvm *kvm, struct nitro_vcpus *nvcpus){
+  int r,i;
+  struct kvm_vcpu *v;
+  
+  mutex_lock(&kvm->lock);
+  
+  nvcpus->num_vcpus = atomic_read(&kvm->online_vcpus);
+  if(unlikely(nvcpus->num_vcpus > NITRO_MAX_VCPUS)){
+    goto error_out;
+  }
+  
+  kvm_for_each_vcpu(r, v, kvm){
+    nvcpus->ids[r] = v->vcpu_id;
+    kvm_get_kvm(kvm);
+    nvcpus->fds[r] = create_vcpu_fd(v);
+    if(nvcpus->fds[r]<0){
+      for(i=r;r>=0;i--){
+	nvcpus->ids[r] = 0;
+	nvcpus->fds[i] = 0;
+	kvm_put_kvm(kvm);
+      }
+      goto error_out;
+    }
+  }
+  
+  mutex_unlock(&kvm->lock);
+  return 0;
+  
+error_out:
+  mutex_unlock(&kvm->lock);
+  return -1;
+}
+
+int nitro_ioctl_get_event(struct kvm_vcpu *vcpu){
+  int rv;
+  
+  //vcpu_put(vcpu);
+  rv = down_interruptible(&(vcpu->nitro.n_wait_sem));
+  
+  if (rv == 0)
+    rv = vcpu->nitro.event;
+  
+  return rv;
+}
+
+int nitro_ioctl_continue(struct kvm_vcpu *vcpu){
+  
+  //if no waiters
+  if(completion_done(&(vcpu->nitro.k_wait_cv)))
+    return -1;
+  
+  complete(&(vcpu->nitro.k_wait_cv));
+  return 0;
+}