- Move the last two items out from "unmaintained" thus restoring branches directory hierarchy.

- Delete "unmaintained" (it was a bad temporary solution after all). svn path=/branches/cis/; revision=36848
Move unmaintained stuff (cis, os2, rosky, vms, and msvc6) to a respective branch [01/02]
2025-10-06 08:22:58 +02:00 · 2008-10-20 16:50:26 +00:00 · 2006-10-13 09:00:21 +00:00 · 2006-10-13 07:02:04 +00:00 · 2006-10-12 20:46:07 +00:00 · 2006-10-12 09:01:16 +00:00
325 changed files with 2555 additions and 160317 deletions
--- a/.gitignore
+++ b/.gitignore
--- a/ReactOS.ApiStatus/Default.build
+++ b/ReactOS.ApiStatus/Default.build
@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<!--
+   Copyright (C) 2005 Casper S. Hornstrup
+
+   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; either version 2 of the License, or
+   (at your option) any 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+-->
+<project name="ReactOS.ApiStatus" default="publish">
+
+	<property name="reactos.dir" value="reactos" />
+	<property name="apistatus.xsl" value="rapistatus.xsl" />
+	<property name="apistatus.xml" value="rapistatus.xml" />
+	<property name="apistatus.html" value="index2.html" />
+	<include buildfile="config.include" />
+
+	<target name="publish">
+		<delete dir="${reactos.dir}" if="${directory::exists(reactos.dir)}" />
+		<exec program="svn" commandline="export -r HEAD ${source.url} ${reactos.dir}" />
+		<exec program="rgenstat" commandline="reactos\apistatus.lst ${apistatus.xml}" />
+		<style style="${apistatus.xsl}" destdir="${reactos.dir}" in="${apistatus.xml}" out="${apistatus.html}" />
+		<copy todir="${publish.dir}" overwrite="true">
+			<fileset basedir=".">
+				<include name="${apistatus.xml}" />
+				<include name="${apistatus.html}" />
+			</fileset>
+		</copy>
+		<delete>
+			<fileset basedir=".">
+				<include name="${apistatus.xml}" />
+				<include name="${apistatus.html}" />
+			</fileset>
+		</delete>
+		<delete dir="${reactos.dir}" if="${directory::exists(reactos.dir)}" />
+	</target>
+</project>
--- a/ReactOS.ApiStatus/config.template.include
+++ b/ReactOS.ApiStatus/config.template.include
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (C) 2005 Casper S. Hornstrup
+
+   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; either version 2 of the License, or
+   (at your option) any 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+-->
+<project>
+	<property name="source.url" value="svn://svn.reactos.com/trunk/reactos" />
+	<property name="publish.dir" value="C:\api" />
+</project>
--- a/ReactOS.ApiStatus/rapistatus.xsl
+++ b/ReactOS.ApiStatus/rapistatus.xsl
@@ -0,0 +1,199 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+
+	<xsl:output method="html" indent="no"/>
+	<!--	<xsl:output method="xml"/>-->
+<!-- Will not work:	<xsl:strip-space elements="*"/> -->
+
+	<xsl:template match="/">
+		<HTML>
+			<HEAD>
+				<TITLE>
+					ReactOS API Status
+				</TITLE>
+				<SCRIPT src="rapistatus.js"></SCRIPT>
+				<LINK rel="stylesheet" type="text/css" href="rapistatus.css"></LINK>
+			</HEAD>
+			<BODY onLoad="onLoad();">
+				<P>
+					<H1>ReactOS API Status</H1>
+				</P>
+				<P>
+					<TABLE>
+						<TR>
+							<TD> <INPUT type="checkbox" ID="implemented" onClick="selectImplemented();" checked="1"/> </TD>
+							<TD> <IMG src="i.gif"/> </TD>
+							<TD> Implemented </TD>
+							<TD width="20"/>
+						</TR>
+						<TR>
+							<TD> <INPUT type="checkbox" ID="unimplemented" onClick="selectUnimplemented();" checked="1"/> </TD>
+							<TD> <IMG src="u.gif"/> </TD>
+							<TD> Unimplemented </TD>
+							<TD width="20"/>
+						</TR>
+					</TABLE>
+				</P>
+				<DIV ID="ROOT">
+					<xsl:apply-templates/>
+				</DIV>
+				<P>
+					Legend :<BR/>
+					<TABLE>
+						<TR>
+							<TD> <IMG src="c.gif"/> </TD>
+							<TD> Component </TD>
+							<TD> <IMG src="i.gif"/> </TD>
+							<TD> Implemented </TD>
+							<TD> <IMG src="sc.gif"/> </TD>
+							<TD> Complete </TD>
+						<TR>
+						</TR>
+							<TD> <IMG src="f.gif"/> </TD>
+							<TD> Function </TD>
+							<TD> <IMG src="u.gif"/> </TD>
+							<TD> Unimplemented </TD>
+							<TD></TD>
+							<TD></TD>
+						</TR>
+					</TABLE>
+
+				</P>
+			</BODY>
+		</HTML>
+	</xsl:template>
+
+
+	<!-- component -->
+	<xsl:template match="/components">
+		<xsl:apply-templates select="component">
+			<xsl:sort select="@name"/>
+		</xsl:apply-templates>
+	</xsl:template>
+
+	<xsl:template match="components/component[@implemented_total or @unimplemented_total]">
+		<DIV>
+			<xsl:call-template name="ELEMENT">
+				<xsl:with-param name="class">c</xsl:with-param>
+			</xsl:call-template>
+			<xsl:apply-templates>
+				<xsl:with-param name="base"><xsl:value-of select="@base"/></xsl:with-param>
+			</xsl:apply-templates>
+		</DIV>
+	</xsl:template>
+
+
+	<!-- function -->
+	<xsl:template match="functions">
+		<xsl:param name="base"/>
+		<xsl:apply-templates select="f">
+			<xsl:sort select="@n"/>
+			<xsl:with-param name="base"><xsl:value-of select="$base"/></xsl:with-param>
+		</xsl:apply-templates>
+	</xsl:template>
+
+	<xsl:template match="functions/f">
+		<xsl:param name="base"/>
+		<DIV>
+			<xsl:call-template name="ELEMENT">
+				<xsl:with-param name="class">f</xsl:with-param>
+				<xsl:with-param name="base"><xsl:value-of select="$base"/></xsl:with-param>
+			</xsl:call-template>
+			<xsl:apply-templates/>
+		</DIV>
+	</xsl:template>
+
+
+	<!-- support templates -->
+
+	<xsl:template name="ELEMENT">
+		<xsl:param name="class"/>
+		<xsl:param name="base"/>
+		<xsl:param name="image"/>
+			<xsl:attribute name="class">
+	  		<xsl:value-of select="$class"/>
+  			<xsl:text>_</xsl:text>
+			</xsl:attribute>
+			<xsl:call-template name="toggle"/>
+			<xsl:choose>
+				<xsl:when test="local-name() != 'component' and @i = 'true'">
+					<img src="i.gif" class="i"/>
+				</xsl:when>
+				<xsl:when test="local-name() != 'component' and @i = 'false'">
+					<img src="u.gif" class="u"/>
+				</xsl:when>
+				<xsl:when test="local-name() = 'component' and @complete >= 100">
+					<img src="sc.gif"/>
+				</xsl:when>
+				<xsl:otherwise>
+					<xsl:value-of select="@i"/><img src="tb.gif" with="12" height="12"/>
+				</xsl:otherwise>
+			</xsl:choose>
+			<xsl:choose>
+				<xsl:when test="$image">
+					<img src="{$image}.gif" class="t"/>
+				</xsl:when>
+				<xsl:otherwise>
+					<img src="{$class}.gif" class="t"/>
+				</xsl:otherwise>
+			</xsl:choose>
+			<xsl:call-template name="name"/>
+			<xsl:call-template name="n"/>
+ 			<xsl:call-template name="file">
+				<xsl:with-param name="base"><xsl:value-of select="$base"/></xsl:with-param>
+			</xsl:call-template>
+			<xsl:call-template name="status"/>
+	</xsl:template>
+
+	<xsl:template name="status">
+		<xsl:if test="@complete and @complete != 0">
+			<SPAN class="st">
+				<img src="sc.gif"/>
+				<xsl:text>: </xsl:text>
+				<xsl:value-of select="@complete"/>
+				<xsl:text>%</xsl:text>
+			</SPAN>
+		</xsl:if>
+		<xsl:if test="@implemented_total">
+			<SPAN class="st">
+				<img src="i.gif"/>: <xsl:value-of select="@implemented_total"/>
+			</SPAN>
+		</xsl:if>
+		<xsl:if test="@unimplemented_total">
+			<SPAN class="st">
+				<img src="u.gif"/>: <xsl:value-of select="@unimplemented_total"/>
+			</SPAN>
+		</xsl:if>
+	</xsl:template>
+
+	<xsl:template name="toggle">
+		<xsl:choose>
+			<xsl:when test="local-name() = 'component'">
+				<IMG src="tp.gif" class="t"/>
+			</xsl:when>
+			<xsl:otherwise>
+   			<IMG src="tb.gif"/>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:template>
+
+	<xsl:template name="name">
+		<xsl:if test="@name">
+			<SPAN class="l"><xsl:value-of select="@name"/></SPAN>
+		</xsl:if>
+	</xsl:template>
+
+	<xsl:template name="n">
+		<xsl:if test="@n">
+			<SPAN class="l"><xsl:value-of select="@n"/></SPAN>
+		</xsl:if>
+	</xsl:template>
+
+	<xsl:template name="file">
+		<xsl:param name="base"/>
+		<xsl:if test="@f">
+			<SPAN class="h"><xsl:value-of select="$base"/><xsl:value-of select="@f"/></SPAN>
+		</xsl:if>
+	</xsl:template>
+
+</xsl:stylesheet>
--- a/ReactOS.CustomRevisionAction/App.config
+++ b/ReactOS.CustomRevisionAction/App.config
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" ?> 
+<configuration>
+	<appSettings>
+		<add key="publishPath" value="c:\iso" /> <!-- c:\iso or ftp://ftp.server.com/iso -->
+		<add key="smtpServer" value="localhost" />
+		<add key="errorEmail" value="mailbox@somewhere-on-the-net" />
+		<add key="makeParameters" value="" />
+		<add key="fastDisk" value="" />
+	</appSettings>
+</configuration>
--- a/ReactOS.CustomRevisionAction/AssemblyInfo.cs
+++ b/ReactOS.CustomRevisionAction/AssemblyInfo.cs
@@ -0,0 +1,14 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("ReactOS Sin Custom Revision Action")]
+[assembly: AssemblyDescription("ReactOS Sin Custom Revision Action")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("ReactOS Project")]
+[assembly: AssemblyProduct("React Operating System")]
+[assembly: AssemblyCopyright("Copyright 2005 ReactOS Project")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
--- a/ReactOS.CustomRevisionAction/Default.build
+++ b/ReactOS.CustomRevisionAction/Default.build
@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<project name="ReactOS.CustomRevisionAction" default="build">
+
+	<property name="output.dir" value="bin" />
+
+	<target name="build" description="Build component">
+		<mkdir dir="${output.dir}" />
+		<csc target="exe"
+			output="${output.dir}\ReactOS.CustomRevisionAction.exe"
+			optimize="true"
+			debug="true"
+			doc="${output.dir}\ReactOS.CustomRevisionAction.xml"
+			warninglevel="0">
+			<sources>
+				<include name="*.cs" />
+			</sources>
+		</csc>
+	</target>
+
+</project>
--- a/ReactOS.CustomRevisionAction/FtpClient.cs
+++ b/ReactOS.CustomRevisionAction/FtpClient.cs
--- a/ReactOS.CustomRevisionAction/Main.cs
+++ b/ReactOS.CustomRevisionAction/Main.cs
@@ -0,0 +1,340 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+using System.Configuration;
+using System.Web.Mail;
+
+namespace ReactOS.CustomRevisionAction
+{
+	public class MainClass
+	{
+		/// <summary>
+		/// Path to store published binaries at.
+		/// </summary>
+		private static string publishPath;
+
+		/// <summary>
+		/// Whether or not to publish ISOs to a remote destination via FTP.
+		/// </summary>
+		private static bool PublishToRemoteFtpLocation
+		{
+			get
+			{
+				return publishPath.StartsWith("ftp://");
+			}
+		}
+
+		/// <summary>
+		/// Run the application.
+		/// </summary>
+		/// <param name="script">Script to run.</param>
+		/// <param name="args">Arguments to pass to script.</param>
+		/// <param name="workingDirectory">Working directory.</param>
+		/// <param name="standardOutput">Receives standard output.</param>
+		/// <param name="standardError">Receives standard error.</param>
+		/// <returns>
+		/// Exit code.
+		/// </returns>
+		private static int RunScript(string script,
+		                             string args,
+		                             string workingDirectory,
+		                             out string standardOutput,
+		                             out string standardError)
+		{
+			ProcessStartInfo scriptProcessStartInfo = new ProcessStartInfo(script,
+			                                                               args);
+			scriptProcessStartInfo.CreateNoWindow = true;
+			/*
+			 * All standard streams must be redirected.
+			 * Otherwise DuplicateHandle() will fail.
+			 */
+			scriptProcessStartInfo.RedirectStandardInput = true;
+			scriptProcessStartInfo.RedirectStandardError = true;
+			scriptProcessStartInfo.RedirectStandardOutput = true;
+			scriptProcessStartInfo.UseShellExecute = false;
+			scriptProcessStartInfo.WorkingDirectory = workingDirectory;
+			RedirectableProcess redirectableProcess = new RedirectableProcess(scriptProcessStartInfo);
+			standardOutput = redirectableProcess.ProcessOutput;
+			standardError = redirectableProcess.ProcessError;
+			return redirectableProcess.ExitCode;
+		}
+
+		/// <summary>
+		/// Retrieve value of configuration from configuration file.
+		/// </summary>
+		/// <param name="name">Name of configuration option.</param>
+		/// <param name="defaultValue">
+		/// Default value to be returned if the option does not exist.
+		/// </param>
+		/// <returns>
+		/// Value of configuration option or null if the option does not
+		/// exist and no default value is provided.
+		/// </returns>
+		private static string GetConfigurationOption(string name,
+		                                             string defaultValue)
+		{
+			if (ConfigurationSettings.AppSettings[name] != null)
+				return ConfigurationSettings.AppSettings[name];
+			else
+				return defaultValue;
+		}
+		
+		/// <summary>
+		/// Send an email.
+		/// </summary>
+		/// <param name="subject">Subject of the email.</param>
+		/// <param name="body">Content of the email.</param>
+		private static void SendErrorMail(string subject, string body)
+		{
+			try
+			{
+				string smtpServer = GetConfigurationOption("smtpServer", "localhost");
+				string toEmail = GetConfigurationOption("errorEmail", null);
+				if (toEmail == null)
+					return;
+				string fromEmail = GetConfigurationOption("fromEmail", null);
+				if (fromEmail == null)
+					fromEmail = toEmail;
+				MailMessage mm = new MailMessage();
+				mm.Priority = MailPriority.Normal;
+				mm.From = toEmail;
+				mm.To = toEmail;
+				mm.Subject = subject;
+				mm.Body += body;
+				mm.Body += "<br>";
+				mm.BodyFormat = MailFormat.Html;
+				SmtpMail.SmtpServer = smtpServer;
+				SmtpMail.Send(mm);
+			}
+			catch (Exception ex)
+			{
+				Console.Error.WriteLine(ex.Message);
+			}
+		}
+
+		/// <summary>
+		/// Fail with an error message.
+		/// </summary>
+		/// <param name="revision">Repository revision.</param>
+		/// <param name="text">Error message.</param>
+		private static void Fail(int revision,
+		                         string text)
+		{
+			Console.WriteLine(text);
+			Console.Error.WriteLine(text);
+			SendErrorMail(String.Format("[{0}] ReactOS Publish Error", revision), text);
+		}
+
+		/// <summary>
+		/// Fail with an error message.
+		/// </summary>
+		/// <param name="text">Error message.</param>
+		private static void Fail(string text)
+		{
+			Console.WriteLine(text);
+			Console.Error.WriteLine(text);
+			SendErrorMail("ReactOS Publish Error", text);
+		}
+
+		/// <summary>
+		/// Generate filename of distribution.
+		/// </summary>
+		/// <param name="branch">Branch.</param>
+		/// <param name="revision">Revision.</param>
+		private static string GetDistributionFilename(string branch,
+		                                              int revision)
+		{
+			return String.Format("ReactOS-{0}-r{1}.iso",
+			                     branch,
+			                     revision);
+		}
+
+		private static void SplitRemotePublishPath(string publishPath,
+		                                           out string server,
+		                                           out string directory)
+		{
+			string searchString = "://";
+			int index = publishPath.IndexOf(searchString);
+			if (index == -1)
+				throw new InvalidOperationException();
+			int endOfProtocolIndex = index + searchString.Length;
+			string withoutProtocol = publishPath.Remove(0, endOfProtocolIndex);
+			index = withoutProtocol.IndexOf("/");
+			if (index == -1)
+			{
+				server = withoutProtocol;
+				directory = "";
+			}
+			else
+			{
+				server = withoutProtocol.Substring(0, index);
+				directory = withoutProtocol.Remove(0, index + 1);
+			}
+		}
+
+		/// <summary>
+		/// Copy ISO to the (remote) destination.
+		/// </summary>
+		/// <param name="sourceFilename">Name of source ISO file to copy.</param>
+		/// <param name="branch">Branch.</param>
+		/// <param name="revision">Revision.</param>
+		/// <remarks>
+		/// Structure is ftp://ftp.server.com/whereever/<branch>/ReactOS-<branch>-r<revision>.iso.
+		/// </remarks>
+		private static void CopyISOToRemoteFtpDestination(string sourceFilename,
+		                                                  string branch,
+		                                                  int revision)
+		{
+			string distributionFilename = GetDistributionFilename(branch,
+			                                                      revision);
+			string destinationFilename = Path.Combine(Path.GetDirectoryName(sourceFilename),
+			                                          distributionFilename);
+			File.Move(sourceFilename, destinationFilename);
+			string server;
+			string directory;
+			SplitRemotePublishPath(publishPath, out server, out directory);
+			FtpClient ftpClient = new FtpClient(server, "anonymous", "sin@svn.reactos.com");
+			ftpClient.Login();
+			if (directory != "")
+				ftpClient.ChangeDir(directory);
+			/* Create destination directory if it does not already exist */
+			if (!ftpClient.DirectoryExists(branch))
+				ftpClient.MakeDir(branch);
+			ftpClient.ChangeDir(branch);
+			ftpClient.Upload(destinationFilename);
+			ftpClient.Close();
+		}
+
+		/// <summary>
+		/// Copy ISO to the (local) destination.
+		/// </summary>
+		/// <param name="sourceFilename">Name of source ISO file to copy.</param>
+		/// <param name="branch">Branch.</param>
+		/// <param name="revision">Revision.</param>
+		/// <remarks>
+		/// Structure is <branch>\ReactOS-<branch>-r<revision>.iso.
+		/// </remarks>
+		private static void CopyISOToLocalDestination(string sourceFilename,
+		                                              string branch,
+		                                              int revision)
+		{
+			string distributionFilename = GetDistributionFilename(branch,
+			                                                      revision);
+			string destinationDirectory = Path.Combine(publishPath,
+			                                           branch);
+			string destinationFilename = Path.Combine(destinationDirectory,
+			                                          distributionFilename);
+			if (!Directory.Exists(destinationDirectory))
+				Directory.CreateDirectory(destinationDirectory);
+			File.Copy(sourceFilename,
+			          destinationFilename);
+		}
+
+		/// <summary>
+		/// Copy ISO to the destination.
+		/// </summary>
+		/// <param name="sourceFilename">Name of source ISO file to copy.</param>
+		/// <param name="branch">Branch.</param>
+		/// <param name="revision">Revision.</param>
+		/// <remarks>
+		/// Structure is <branch>\ReactOS-<branch>-r<revision>.iso.
+		/// </remarks>
+		private static void CopyISOToDestination(string sourceFilename,
+		                                         string branch,
+		                                         int revision)
+		{
+			if (PublishToRemoteFtpLocation)
+				CopyISOToRemoteFtpDestination(sourceFilename, branch, revision);
+			else
+				CopyISOToLocalDestination(sourceFilename, branch, revision);
+		}
+
+		/// <summary>
+		/// Publish a revision of ReactOS.
+		/// </summary>
+		/// <param name="text">Error message.</param>
+		private static int Publish(string branch,
+		                           int revision,
+		                           string workingDirectory)
+		{
+			string make = "mingw32-make";
+			string makeParameters = GetConfigurationOption("makeParameters", "");
+			string reactosDirectory = Path.Combine(workingDirectory,
+			                                       "reactos");
+			Console.WriteLine(String.Format("ReactOS directory is {0}",
+			                                reactosDirectory));
+			string standardOutput;
+			string standardError;
+			int exitCode = RunScript(make,
+			                         makeParameters + " bootcd",
+			                         reactosDirectory,
+			                         out standardOutput,
+			                         out standardError);
+			if (exitCode != 0)
+			{
+				Fail(revision,
+				     String.Format("make bootcd failed: (error: {0}) {1}",
+				                   standardError,
+				                   standardOutput));
+				return exitCode;
+			}
+
+			string sourceFilename = Path.Combine(reactosDirectory,
+			                                     "ReactOS.iso");
+			if (File.Exists(sourceFilename))
+				CopyISOToDestination(sourceFilename,
+				                     branch,
+				                     revision);
+			else
+			{
+				Fail(revision,
+				     "make bootcd produced no ReactOS.iso");
+				return exitCode;
+			}
+
+			return exitCode;
+		}
+
+		/// <summary>
+		/// Program entry point.
+		/// </summary>
+		/// <param name="args">Arguments from command line.</param>
+		/// <remarks>
+		/// If exit code is 0, then the commit was processed successfully.
+		/// If exit code is 1, then the commit was not processed successfully.
+		/// </remarks>
+		public static void Main(string[] args)
+		{
+			try
+			{
+				System.Environment.ExitCode = 1;
+
+				publishPath = ConfigurationSettings.AppSettings["publishPath"];
+				if (publishPath == null)
+				{
+					Fail("PublishPath option not set.");
+					return;
+				}
+
+				if (args.Length < 3)
+				{
+					Fail("Usage: ReactOS.CustomRevisionAction action branch revision");
+					return;
+				}
+
+				string action = args[0]; /* bootcd */
+				string branch = args[1];
+				int revision = Int32.Parse(args[2]);
+				
+				System.Environment.ExitCode = Publish(branch,
+				                                      revision,
+				                                      System.Environment.CurrentDirectory);
+			}
+			catch (Exception ex)
+			{
+				Fail(String.Format("Exception: {0}", ex));
+				System.Environment.ExitCode = 1;
+			}
+		}
+	}
+}
--- a/ReactOS.CustomRevisionAction/RedirectableProcess.cs
+++ b/ReactOS.CustomRevisionAction/RedirectableProcess.cs
@@ -0,0 +1,145 @@
+/*
+ * When using the ProcessStartInfo.RedirectStandardXxx properties there is a chance of
+ * the parent and child process blocking due to a race condition. This class handles the
+ * problem.
+ * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemdiagnosticsprocessstartinfoclassredirectstandardoutputtopic.asp
+ */
+using System;
+using System.IO;
+using System.Threading;
+using System.Diagnostics;
+
+namespace ReactOS.CustomRevisionAction
+{
+	/// <summary>
+	/// Process that redirects standard output and standard error streams.
+	/// </summary>
+	public class RedirectableProcess
+	{
+		/// <summary>
+		/// Process.
+		/// </summary>
+		private Process process;
+
+		/// <summary>
+		/// Redirected standard error stream.
+		/// </summary>
+		private string processError;
+
+		/// <summary>
+		/// Redirected standard output stream.
+		/// </summary>
+		private string processOutput;
+
+		/// <summary>
+		/// Exit code.
+		/// </summary>
+		private int exitCode;
+
+		/// <summary>
+		/// Redirected standard error stream.
+		/// </summary>
+		public string ProcessError
+		{
+			get
+			{
+				return processError;
+			}
+		}
+
+		/// <summary>
+		/// Redirected standard output stream.
+		/// </summary>
+		public string ProcessOutput
+		{
+			get
+			{
+				return processOutput;
+			}
+		}
+
+		/// <summary>
+		/// Exit code.
+		/// </summary>
+		public int ExitCode
+		{
+			get
+			{
+				return exitCode;
+			}
+		}
+
+		/// <summary>
+		/// Run an excutable and redirect standard error and/or standard output safely.
+		/// </summary>
+		public RedirectableProcess(ProcessStartInfo processStartInfo)
+		{
+			Run(processStartInfo, null);
+		}
+
+		/// <summary>
+		/// Run an excutable and redirect standard error and/or standard output safely.
+		/// </summary>
+		public RedirectableProcess(ProcessStartInfo processStartInfo, string input)
+		{
+			Run(processStartInfo, input);
+		}
+		
+		private void Run(ProcessStartInfo processStartInfo, string input)
+		{
+			process = new Process();
+			process.StartInfo = processStartInfo;
+			process.Start();
+			if (processStartInfo.RedirectStandardInput && input != null)
+			{
+				process.StandardInput.AutoFlush = true;
+				process.StandardInput.WriteLine(input);
+			}
+			Thread readStandardError = null;
+			if (processStartInfo.RedirectStandardError)
+			{
+				readStandardError = new Thread(new ThreadStart(ReadStandardError));
+				readStandardError.Start();
+			}
+			Thread readStandardOutput = null;
+			if (processStartInfo.RedirectStandardOutput)
+			{
+				readStandardOutput = new Thread(new ThreadStart(ReadStandardOutput));
+				readStandardOutput.Start();
+			}
+			if (processStartInfo.RedirectStandardError)
+			{
+				readStandardError.Join();
+			}
+			if (processStartInfo.RedirectStandardOutput)
+			{
+				readStandardOutput.Join();
+			}
+			process.WaitForExit();
+			exitCode = process.ExitCode;
+			process = null;
+		}
+
+		/// <summary>
+		/// Read standard error thread entry-point.
+		/// </summary>		
+		private void ReadStandardError()
+		{
+			if (process != null)
+			{
+				processError = process.StandardError.ReadToEnd();
+			}
+		}
+
+		/// <summary>
+		/// Read standard output thread entry-point.
+		/// </summary>		
+		private void ReadStandardOutput()
+		{
+			if (process != null)
+			{
+				processOutput = process.StandardOutput.ReadToEnd();
+			}
+		}
+	}
+}
--- a/ReactOS.RevisionISO/config.template.php
+++ b/ReactOS.RevisionISO/config.template.php
@@ -0,0 +1,8 @@
+<?php
+
+/* Rename to config.php */
+
+define(ISO_BASE_URL, "http://www.server.com/iso/");
+define(ISO_PATH, "C:\\iso\\");
+
+?>
--- a/ReactOS.RevisionISO/index.php
+++ b/ReactOS.RevisionISO/index.php
@@ -0,0 +1,230 @@
+<?php
+
+include ('config.php');
+
+function dm_usort_cmp ($a, $b) {
+  if ($a == $b) return 0;
+  return ($a > $b) ? -1 : 1;
+}
+
+function dm_usort_cmp_desc ($a, $b) {
+  if ($a == $b) return 0;
+  return ($a > $b) ? 1 : -1;
+}
+
+function printHeader()
+{
+?>
+<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+<title>ReactOS Revison ISOs</title>
+<meta name="generator" content="Editpad">
+<meta name="keywords" content="OS, ReactOS, operating system">
+<meta name="author" content="ReactOS Project (ros-dev@reactos.com)">
+<style>
+.box
+{
+	padding: 0px;
+	background-color: #88aadd;
+	border-left: 1px solid #f0f0f0;
+	border-right: 1px solid #000000;
+	border-top: 1px solid #f0f0f0;
+	border-bottom: 1px solid #000000;
+}
+</style>
+</head>
+<body bgcolor="#88aadd">
+<form method="post" action="">
+<?php
+}
+
+function printMenu($revision)
+{
+?>
+<table border="0" class="box" cellpadding="5">
+<tr>
+<td height="2px">
+</td>
+</tr>
+<tr>
+<td>
+
+<table border="0" cellpadding="0" cellspacing="0">
+<tr>
+	<td>
+		<b>Branch:</b>
+	</td>
+	<td>
+		<select name="branch" tabindex="1">
+<?php
+
+    $d = dir(ISO_PATH);
+    $i = 0;
+    $dirlist = array();
+    while (false !== ($entry = $d->read())) {
+      if ((strcasecmp($entry, ".") != 0) && (strcasecmp($entry, "..") != 0) && is_dir(ISO_PATH . "\\" . $entry) == "dir") {
+        $dirlist[$i++] = $entry;
+      }
+    }
+    $d->close();
+
+    if (is_array($dirlist)) {
+      usort($dirlist, "dm_usort_cmp");
+      reset($dirlist);
+      while (list($key, $val) = each($dirlist)) {
+        $branch = $val;
+	if ($branch == $_POST["branch"] || (!isset($_POST["branch"]) && $branch == "trunk"))
+		$selected = " selected";
+	else
+		$selected = "";
+	echo "<option$selected>$branch</option>";
+      }
+    }
+	
+?>
+		</select>
+	</td>
+	<td>
+		&nbsp;
+	</td>
+	<td>
+		<b>Revision:</b>
+	</td>
+	<td>
+<?php
+	echo "<input type=\"text\" name=\"revision\" size=\"10\" maxlength=\"10\" tabindex=\"2\" value=\"" . $revision . "\"></input>";
+?>
+	</td>
+	<td>
+		&nbsp;
+	</td>
+	<td>
+		<input type="submit" name="getiso" value="Download" tabindex="3" style="border: 1px solid #000000"></input>
+	</td>
+</tr>
+<tr>
+	<td colspan="7">
+		<hr size="2" width="100%" />
+	</td>
+</tr>
+<tr>
+	<td colspan="4">
+		<input type="submit" name="getnextiso" value="Next ISO" tabindex="4" style="border: 1px solid #000000"></input>
+	</td>
+	<td colspan="3" align="right">
+		<input type="submit" name="getlatestiso" value="Latest ISO" tabindex="5" style="border: 1px solid #000000"></input>
+	</td>
+</tr>
+</table>
+
+</td>
+</tr>
+<tr>
+<td height="2px">
+</td>
+</tr>
+</table>
+<?php
+}
+
+function printFooter()
+{
+?>
+</form>
+
+<script>
+var revision = document.getElementById('revision');
+if (revision) revision.focus();
+</script>
+</body>
+</html>
+<?php
+}
+
+function locateRevisionISO($branch, $revision, $latest)
+{
+	$revision = intval($revision);
+	$path = ISO_PATH . "\\" . $branch;
+	$d = dir($path);
+	$i = 0;
+	$filelist = array();
+	while (false !== ($entry = $d->read())) {
+		if (is_dir($path . "\\" . $entry) != "dir")
+			$filelist[$i++] = $entry;
+	}
+	$d->close();
+	
+	if (is_array($filelist)) {
+		$sortFunction = $latest ? "dm_usort_cmp" : "dm_usort_cmp_desc";
+		usort($filelist, $sortFunction);
+		reset($filelist);
+		while (list($key, $filename) = each($filelist)) {
+			if (ereg('ReactOS-' . $branch . '-r([0-9]*).iso', $filename, $regs))
+			{
+				$thisRevision = intval($regs[1]);
+				if (($latest) && ($thisRevision < $revision))
+					return $regs[1];
+				else if ($thisRevision > $revision)
+					return $regs[1];
+				$lastRevision = $thisRevision;
+			}
+		}
+	}
+
+	return "";
+}
+
+function getNextRevisionISO($branch, $revision)
+{
+	return locateRevisionISO($branch, $revision, false);
+}
+
+function getLatestRevisionISO($branch)
+{
+	return locateRevisionISO($branch, 999999, true);
+}
+
+function main()
+{
+	$branch = $_POST["branch"];
+	$revision = $_POST["revision"];
+
+	$filename = "ReactOS-" . $branch . "-r" . $revision . ".iso";
+	if (file_exists(ISO_PATH . $branch . "\\" . $filename))
+	{
+		$location = ISO_BASE_URL . $branch . "/" . $filename;
+		header("Location: $location");
+		return;
+	}
+	else
+	{
+		printHeader();
+		printMenu($_POST["revision"]);
+		echo "<br><b>No ISO exist for branch '" . $branch . "' and revision " . $revision . ".</b><br><br>";
+		printFooter();
+	}
+}
+
+if (!empty($_POST["getiso"]) && !empty($_POST["branch"]) && !empty($_POST["revision"]) && is_numeric($_POST["revision"]))
+	main();
+else if (!empty($_POST["getnextiso"]) && !empty($_POST["branch"]) && !empty($_POST["revision"]) && is_numeric($_POST["revision"]))
+{
+	printHeader();
+	printMenu(getNextRevisionISO($_POST["branch"], $_POST["revision"]));
+	printFooter();
+}
+else if (!empty($_POST["getlatestiso"]) && !empty($_POST["branch"]))
+{
+	printHeader();
+	printMenu(getLatestRevisionISO($_POST["branch"]));
+	printFooter();
+}
+else
+{
+	printHeader();
+	printMenu($_POST["revision"]);
+	printFooter();
+}
+
+?>
--- a/ReactOS.Verify/App.config
+++ b/ReactOS.Verify/App.config
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8" ?> 
+<configuration>
+	<appSettings>
+		<add key="smtpServer" value="localhost" />
+		<add key="errorEmail" value="mailbox@somewhere-on-the-net" />
+		<add key="makeParameters" value="" />
+		<add key="fastDisk" value="" />
+	</appSettings>
+</configuration>
--- a/ReactOS.Verify/AssemblyInfo.cs
+++ b/ReactOS.Verify/AssemblyInfo.cs
@@ -0,0 +1,14 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("ReactOS Sin Verifier")]
+[assembly: AssemblyDescription("ReactOS Sin Verifier")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("ReactOS Project")]
+[assembly: AssemblyProduct("React Operating System")]
+[assembly: AssemblyCopyright("Copyright 2005 ReactOS Project")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
--- a/ReactOS.Verify/Default.build
+++ b/ReactOS.Verify/Default.build
@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<project name="ReactOS.Verify" default="build">
+
+	<property name="output.dir" value="bin" />
+
+	<target name="build" description="Build component">
+		<mkdir dir="${output.dir}" />
+		<csc target="exe"
+			output="${output.dir}\ReactOS.Verify.exe"
+			optimize="true"
+			debug="true"
+			doc="${output.dir}\ReactOS.Verify.xml"
+			warninglevel="0">
+			<sources>
+				<include name="*.cs" />
+			</sources>
+		</csc>
+	</target>
+
+</project>
--- a/ReactOS.Verify/Main.cs
+++ b/ReactOS.Verify/Main.cs
@@ -0,0 +1,279 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+using System.Configuration;
+using System.Web.Mail;
+using System.Collections;
+using System.Collections.Specialized;
+
+namespace ReactOS.Verify
+{
+	public class MainClass
+	{
+		/// <summary>
+		/// Run the application.
+		/// </summary>
+		/// <param name="script">Script to run.</param>
+		/// <param name="args">Arguments to pass to script.</param>
+		/// <param name="workingDirectory">Working directory.</param>
+		/// <param name="standardOutput">Receives standard output.</param>
+		/// <param name="standardError">Receives standard error.</param>
+		/// <returns>
+		/// Exit code.
+		/// </returns>
+		private static int RunScript(string script,
+		                             string args,
+		                             string workingDirectory,
+		                             StringDictionary environmentVarables,
+		                             out string standardOutput,
+		                             out string standardError)
+		{
+			ProcessStartInfo scriptProcessStartInfo = new ProcessStartInfo(script,
+			                                                               args);
+			scriptProcessStartInfo.CreateNoWindow = true;
+			/*
+			 * All standard streams must be redirected.
+			 * Otherwise DuplicateHandle() will fail.
+			 */
+			scriptProcessStartInfo.RedirectStandardInput = true;
+			scriptProcessStartInfo.RedirectStandardError = true;
+			scriptProcessStartInfo.RedirectStandardOutput = true;
+			scriptProcessStartInfo.UseShellExecute = false;
+			scriptProcessStartInfo.WorkingDirectory = workingDirectory;
+			if (environmentVarables != null)
+			{
+				foreach (DictionaryEntry de in environmentVarables)
+					scriptProcessStartInfo.EnvironmentVariables.Add(de.Key as string, de.Value as string);
+			}
+			RedirectableProcess redirectableProcess = new RedirectableProcess(scriptProcessStartInfo);
+			standardOutput = redirectableProcess.ProcessOutput;
+			standardError = redirectableProcess.ProcessError;
+			return redirectableProcess.ExitCode;
+		}
+
+		/// <summary>
+		/// Retrieve value of configuration from configuration file.
+		/// </summary>
+		/// <param name="name">Name of configuration option.</param>
+		/// <param name="defaultValue">
+		/// Default value to be returned if the option does not exist.
+		/// </param>
+		/// <returns>
+		/// Value of configuration option or null if the option does not
+		/// exist and no default value is provided.
+		/// </returns>
+		private static string GetConfigurationOption(string name,
+		                                             string defaultValue)
+		{
+			if (ConfigurationSettings.AppSettings[name] != null)
+			{
+				string s = ConfigurationSettings.AppSettings[name].Trim();
+				return s.Equals(String.Empty) ? defaultValue : s;
+			}
+			else
+				return defaultValue;
+		}
+
+		/// <summary>
+		/// Send an email.
+		/// </summary>
+		/// <param name="subject">Subject of the email.</param>
+		/// <param name="body">Content of the email.</param>
+		private static void SendErrorMail(string subject, string body)
+		{
+			try
+			{
+				string smtpServer = GetConfigurationOption("smtpServer", "localhost");
+				string email = GetConfigurationOption("errorEmail", null);
+				if (email == null)
+					return;
+				MailMessage mm = new MailMessage();
+				mm.Priority = MailPriority.Normal;
+				mm.From = email;
+				mm.To = email;
+				mm.Subject = subject;
+				mm.Body += body;
+				mm.Body += "<br>";
+				mm.BodyFormat = MailFormat.Html;
+				SmtpMail.SmtpServer = smtpServer;
+				SmtpMail.Send(mm);
+			}
+			catch (Exception ex)
+			{
+				Console.Error.WriteLine(ex.Message);
+			}
+		}
+
+		/// <summary>
+		/// Fail with an error message.
+		/// </summary>
+		/// <param name="text">Error message.</param>
+		private static void Fail(string text)
+		{
+			Console.WriteLine(text);
+		}
+		
+		/// <summary>
+		/// Paths to fast disk for temporary files.
+		/// </summary>
+		private static string TemporaryFastDisk
+		{
+			get
+			{
+				string temporaryFastDisk = GetConfigurationOption("temporaryFastDisk", null);
+				if (temporaryFastDisk == null || temporaryFastDisk.Trim().Equals(String.Empty))
+					return null;
+				return temporaryFastDisk.Trim();
+			}
+		}
+
+		/// <summary>
+		/// Paths to fast disk for intermediate files.
+		/// </summary>
+		private static string IntermediateFastDisk
+		{
+			get
+			{
+				string intermediateFastDisk = GetConfigurationOption("intermediateFastDisk", null);
+				if (intermediateFastDisk == null || intermediateFastDisk.Trim().Equals(String.Empty))
+					return null;
+				return intermediateFastDisk.Trim();
+			}
+		}
+
+		/// <summary>
+		/// Paths to fast disk for output files.
+		/// </summary>
+		private static string OutputFastDisk
+		{
+			get
+			{
+				string outputFastDisk = GetConfigurationOption("outputFastDisk", null);
+				if (outputFastDisk == null || outputFastDisk.Trim().Equals(String.Empty))
+					return null;
+				return outputFastDisk.Trim();
+			}
+		}
+
+		/// <summary>
+		/// Return collection of environment variables.
+		/// </summary>
+		/// <returns>Collection of environment variables or null if there is none.</returns>
+		private static StringDictionary GetEnvironmentVarables()
+		{
+			StringDictionary environmentVarables = new StringDictionary();
+			if (TemporaryFastDisk != null)
+				environmentVarables.Add("ROS_TEMPORARY", TemporaryFastDisk);
+			if (IntermediateFastDisk != null)
+				environmentVarables.Add("ROS_INTERMEDIATE", IntermediateFastDisk);
+			if (OutputFastDisk != null)
+				environmentVarables.Add("ROS_OUTPUT", OutputFastDisk);
+			return environmentVarables;
+		}
+		
+		/// <summary>
+		/// Run make.
+		/// </summary>
+		/// <param name="arguments">Arguments.</param>
+		/// <param name="standardOutput">Receives standard output.</param>
+		/// <param name="standardError">Receives standard error.</param>
+		/// <returns>Make exit code.</returns>
+		private static int RunMake(string arguments,
+		                           out string standardOutput,
+		                           out string standardError)
+		{
+			string make = "mingw32-make";
+			string makeParameters = GetConfigurationOption("makeParameters", "");
+			string reactosDirectory = Path.Combine(System.Environment.CurrentDirectory,
+			                                       "reactos");
+			return RunScript(make,
+			                 makeParameters + " " + arguments,
+			                 reactosDirectory,
+			                 GetEnvironmentVarables(),
+			                 out standardOutput,
+			                 out standardError);
+		}
+		
+		/// <summary>
+		/// Verify a revision of ReactOS by building it all.
+		/// </summary>
+		private static int VerifyFull()
+		{
+			string standardOutput;
+			string standardError;
+			int exitCode = RunMake("bootcd",
+			                       out standardOutput,
+			                       out standardError);
+			if (exitCode != 0)
+			{
+				Fail(String.Format("make bootcd failed: (error: {0}) {1}",
+				                   standardError,
+				                   standardOutput));
+				return exitCode;
+			}
+			
+			string reactosDirectory = Path.Combine(System.Environment.CurrentDirectory,
+			                                       "reactos");
+			string isoFilename = Path.Combine(reactosDirectory,
+			                                  "ReactOS.iso");
+			if (!File.Exists(isoFilename))
+				Fail("make bootcd produced no ReactOS.iso");
+
+			return exitCode;
+		}
+
+		/// <summary>
+		/// Verify a revision of ReactOS by building parts.
+		/// </summary>
+		/// <param name="components">Comma separated list of components to build.</param>
+		private static int VerifyPartial(string components)
+		{
+			string standardOutput;
+			string standardError;
+			string componentParameters = "\"" + components.Replace(",", "\" \"") + "\"";
+			int exitCode = RunMake(componentParameters,
+			                       out standardOutput,
+			                       out standardError);
+			if (exitCode != 0)
+				Fail(String.Format("make failed for targets {0}: (error: {1}) {2}",
+				                   componentParameters,
+				                   standardError,
+				                   standardOutput));
+			return exitCode;
+		}
+
+		/// <summary>
+		/// Verify a revision of ReactOS.
+		/// </summary>
+		/// <param name="args">Arguments from command line.</param>
+		private static int Verify(string[] args)
+		{
+			if (args.Length > 0)
+				return VerifyPartial(args[0]);
+			else
+				return VerifyFull();
+		}
+
+		/// <summary>
+		/// Program entry point.
+		/// </summary>
+		/// <param name="args">Arguments from command line.</param>
+		/// <remarks>
+		/// If exit code is 0, then the commit was processed successfully.
+		/// If exit code is 1, then the commit was not processed successfully.
+		/// </remarks>
+		public static void Main(string[] args)
+		{
+			try
+			{
+				System.Environment.ExitCode = Verify(args);
+			}
+			catch (Exception ex)
+			{
+				string text = String.Format("Exception: {0}", ex);
+				SendErrorMail("ReactOS Verify Error", text);
+				System.Environment.ExitCode = 1;
+			}
+		}
+	}
+}
--- a/ReactOS.Verify/RedirectableProcess.cs
+++ b/ReactOS.Verify/RedirectableProcess.cs
@@ -0,0 +1,145 @@
+/*
+ * When using the ProcessStartInfo.RedirectStandardXxx properties there is a chance of
+ * the parent and child process blocking due to a race condition. This class handles the
+ * problem.
+ * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemdiagnosticsprocessstartinfoclassredirectstandardoutputtopic.asp
+ */
+using System;
+using System.IO;
+using System.Threading;
+using System.Diagnostics;
+
+namespace ReactOS.Verify
+{
+	/// <summary>
+	/// Process that redirects standard output and standard error streams.
+	/// </summary>
+	public class RedirectableProcess
+	{
+		/// <summary>
+		/// Process.
+		/// </summary>
+		private Process process;
+
+		/// <summary>
+		/// Redirected standard error stream.
+		/// </summary>
+		private string processError;
+
+		/// <summary>
+		/// Redirected standard output stream.
+		/// </summary>
+		private string processOutput;
+
+		/// <summary>
+		/// Exit code.
+		/// </summary>
+		private int exitCode;
+
+		/// <summary>
+		/// Redirected standard error stream.
+		/// </summary>
+		public string ProcessError
+		{
+			get
+			{
+				return processError;
+			}
+		}
+
+		/// <summary>
+		/// Redirected standard output stream.
+		/// </summary>
+		public string ProcessOutput
+		{
+			get
+			{
+				return processOutput;
+			}
+		}
+
+		/// <summary>
+		/// Exit code.
+		/// </summary>
+		public int ExitCode
+		{
+			get
+			{
+				return exitCode;
+			}
+		}
+
+		/// <summary>
+		/// Run an excutable and redirect standard error and/or standard output safely.
+		/// </summary>
+		public RedirectableProcess(ProcessStartInfo processStartInfo)
+		{
+			Run(processStartInfo, null);
+		}
+
+		/// <summary>
+		/// Run an excutable and redirect standard error and/or standard output safely.
+		/// </summary>
+		public RedirectableProcess(ProcessStartInfo processStartInfo, string input)
+		{
+			Run(processStartInfo, input);
+		}
+		
+		private void Run(ProcessStartInfo processStartInfo, string input)
+		{
+			process = new Process();
+			process.StartInfo = processStartInfo;
+			process.Start();
+			if (processStartInfo.RedirectStandardInput && input != null)
+			{
+				process.StandardInput.AutoFlush = true;
+				process.StandardInput.WriteLine(input);
+			}
+			Thread readStandardError = null;
+			if (processStartInfo.RedirectStandardError)
+			{
+				readStandardError = new Thread(new ThreadStart(ReadStandardError));
+				readStandardError.Start();
+			}
+			Thread readStandardOutput = null;
+			if (processStartInfo.RedirectStandardOutput)
+			{
+				readStandardOutput = new Thread(new ThreadStart(ReadStandardOutput));
+				readStandardOutput.Start();
+			}
+			if (processStartInfo.RedirectStandardError)
+			{
+				readStandardError.Join();
+			}
+			if (processStartInfo.RedirectStandardOutput)
+			{
+				readStandardOutput.Join();
+			}
+			process.WaitForExit();
+			exitCode = process.ExitCode;
+			process = null;
+		}
+
+		/// <summary>
+		/// Read standard error thread entry-point.
+		/// </summary>		
+		private void ReadStandardError()
+		{
+			if (process != null)
+			{
+				processError = process.StandardError.ReadToEnd();
+			}
+		}
+
+		/// <summary>
+		/// Read standard output thread entry-point.
+		/// </summary>		
+		private void ReadStandardOutput()
+		{
+			if (process != null)
+			{
+				processOutput = process.StandardOutput.ReadToEnd();
+			}
+		}
+	}
+}
--- a/reactos/.gitignore
+++ b/reactos/.gitignore
--- a/reactos/ntoskrnl/Doxyfile
+++ b/reactos/ntoskrnl/Doxyfile
@@ -1,206 +0,0 @@
-# Doxyfile 1.3.5
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-PROJECT_NAME           = "ReactOS NTOSKRNL"
-PROJECT_NUMBER         = 
-OUTPUT_DIRECTORY       = doxy-doc
-OUTPUT_LANGUAGE        = English
-USE_WINDOWS_ENCODING   = YES
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        = ..
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = YES
-MULTILINE_CPP_IS_BRIEF = NO
-DETAILS_AT_TOP         = NO
-INHERIT_DOCS           = NO
-DISTRIBUTE_GROUP_DOC   = NO
-TAB_SIZE               = 8
-ALIASES                = 
-OPTIMIZE_OUTPUT_FOR_C  = YES
-OPTIMIZE_OUTPUT_JAVA   = NO
-SUBGROUPING            = YES
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = YES
-EXTRACT_PRIVATE        = NO
-EXTRACT_STATIC         = NO
-EXTRACT_LOCAL_CLASSES  = NO
-HIDE_UNDOC_MEMBERS     = NO
-HIDE_UNDOC_CLASSES     = NO
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = YES
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-SHOW_INCLUDE_FILES     = YES
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = YES
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       = 
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = YES
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-HAVE_DOT               = YES
-WARN_IF_UNDOCUMENTED   = NO
-WARN_IF_DOC_ERROR      = YES
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           = 
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  = .
-FILE_PATTERNS          = *.c \
-                         *.h
-RECURSIVE              = YES
-EXCLUDE                = 
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
-EXAMPLE_PATH           = 
-EXAMPLE_PATTERNS       = 
-EXAMPLE_RECURSIVE      = YES
-IMAGE_PATH             = 
-INPUT_FILTER           = 
-FILTER_SOURCE_FILES    = NO
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = YES
-INLINE_SOURCES         = YES
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = YES
-REFERENCES_RELATION    = YES
-VERBATIM_HEADERS       = NO
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          = 
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = YES
-HTML_OUTPUT            = html
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            = 
-HTML_FOOTER            = 
-HTML_STYLESHEET        = 
-HTML_ALIGN_MEMBERS     = YES
-GENERATE_HTMLHELP      = NO
-CHM_FILE               = 
-HHC_LOCATION           = 
-GENERATE_CHI           = NO
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-DISABLE_INDEX          = NO
-ENUM_VALUES_PER_LINE   = 4
-GENERATE_TREEVIEW      = YES
-TREEVIEW_WIDTH         = 200
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         = 
-LATEX_HEADER           = 
-PDF_HYPERLINKS         = NO
-USE_PDFLATEX           = NO
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = YES
-RTF_HYPERLINKS         = YES
-RTF_STYLESHEET_FILE    = 
-RTF_EXTENSIONS_FILE    = 
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = NO
-XML_OUTPUT             = xml
-XML_SCHEMA             = 
-XML_DTD                = 
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX = 
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor   
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = NO
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           = ../include
-INCLUDE_FILE_PATTERNS  = *.h
-PREDEFINED             = 
-EXPAND_AS_DEFINED      = 
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration::addtions related to external references   
-#---------------------------------------------------------------------------
-TAGFILES               = 
-GENERATE_TAGFILE       = 
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-PERL_PATH              = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool   
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = YES
-HIDE_UNDOC_RELATIONS   = NO
-HAVE_DOT               = YES
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-UML_LOOK               = NO
-TEMPLATE_RELATIONS     = NO
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-CALL_GRAPH             = YES
-GRAPHICAL_HIERARCHY    = YES
-DOT_IMAGE_FORMAT       = png
-DOT_PATH               = 
-DOTFILE_DIRS           = 
-MAX_DOT_GRAPH_WIDTH    = 1024
-MAX_DOT_GRAPH_HEIGHT   = 1024
-MAX_DOT_GRAPH_DEPTH    = 0
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES
-#---------------------------------------------------------------------------
-# Configuration::addtions related to the search engine   
-#---------------------------------------------------------------------------
-SEARCHENGINE           = YES
--- a/reactos/ntoskrnl/KrnlFun.c
+++ b/reactos/ntoskrnl/KrnlFun.c
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-//            Alex's Big Ol' List of FIXMEs, bugs and regressions
-//              If you see something here, Alex *KNOWS ABOUT IT*.
-//                         Do NOT bug him about it.
-//                      Do NOT ask if he knows about it.
-//                        Do NOT complain about it.
-//                     Do NOT ask when it will be fixed.
-//              Failure to respect this will *ACHIEVE NOTHING*.
-//
-// Io:
-//  - Add tracing to iofunc.c, file.c and device.c
-//  - Add Access Checks in IopParseDevice.
-//  - Add validation checks in IoCreateFile.
-//  - Add probe/alignment checks for Query/Set routines.
-//  - Verify ShareAccess APIs, XP added some new semantics.
-//  - Add support for some fast-paths when querying/setting data.
-//  - Add support for Fast Dispatch I/O.
-//
-// Ob:
-//  - Fix bug related to Deferred Loading (don't requeue active work item).
-//  - Add Directory Lock.
-//  - Use Object Type Mutex/Lock.
-//
-// Ex:
-//  - Use pushlocks for handle implementation.
-//
-///////////////////////////////////////////////////////////////////////////////
-
--- a/reactos/ntoskrnl/cc/cacheman.c
+++ b/reactos/ntoskrnl/cc/cacheman.c
@@ -1,123 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/cc/cacheman.c
- * PURPOSE:         Cache manager
- *
- * PROGRAMMERS:     David Welch (welch@cwcom.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CcInit(VOID)
-{
-  CcInitView();
-}
-
-/*
- * @unimplemented
- */
-LARGE_INTEGER
-STDCALL
-CcGetFlushedValidData (
-    IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
-    IN BOOLEAN BcbListHeld
-    )
-{
-	LARGE_INTEGER i;
-
-	UNIMPLEMENTED;
-
-	i.QuadPart = 0;
-	return i;
-}
-
-/*
- * @unimplemented
- */
-PVOID
-STDCALL
-CcRemapBcb (
-    IN PVOID Bcb
-    )
-{
-	UNIMPLEMENTED;
-
-    return 0;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcScheduleReadAhead (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcSetAdditionalCacheAttributes (
-	IN	PFILE_OBJECT	FileObject,
-	IN	BOOLEAN		DisableReadAhead,
-	IN	BOOLEAN		DisableWriteBehind
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcSetBcbOwnerPointer (
-	IN	PVOID	Bcb,
-	IN	PVOID	Owner
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcSetDirtyPageThreshold (
-	IN	PFILE_OBJECT	FileObject,
-	IN	ULONG		DirtyPageThreshold
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcSetReadAheadGranularity (
-	IN	PFILE_OBJECT	FileObject,
-	IN	ULONG		Granularity
-	)
-{
-	UNIMPLEMENTED;
-}
--- a/reactos/ntoskrnl/cc/copy.c
+++ b/reactos/ntoskrnl/cc/copy.c
@@ -1,727 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/cc/copy.c
- * PURPOSE:         Implements cache managers copy interface
- *
- * PROGRAMMERS:     
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-static PFN_TYPE CcZeroPage = 0;
-
-#define MAX_ZERO_LENGTH	(256 * 1024)
-#define MAX_RW_LENGTH	(256 * 1024)
-
-#if defined(__GNUC__)
-/* void * alloca(size_t size); */
-#elif defined(_MSC_VER)
-void* _alloca(size_t size);
-#else
-#error Unknown compiler for alloca intrinsic stack allocation "function"
-#endif
-
-ULONG CcFastMdlReadWait;
-ULONG CcFastReadNotPossible;
-ULONG CcFastReadWait;
-ULONG CcFastReadNoWait;
-ULONG CcFastReadResourceMiss;
-
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CcInitCacheZeroPage(VOID)
-{
-   NTSTATUS Status;
-
-   Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &CcZeroPage);
-   if (!NT_SUCCESS(Status))
-   {
-       DbgPrint("Can't allocate CcZeroPage.\n");
-       KEBUGCHECKCC;
-   }
-   Status = MiZeroPage(CcZeroPage);
-   if (!NT_SUCCESS(Status))
-   {
-       DbgPrint("Can't zero out CcZeroPage.\n");
-       KEBUGCHECKCC;
-   }
-}
-
-NTSTATUS
-NTAPI
-ReadCacheSegmentChain(PBCB Bcb, ULONG ReadOffset, ULONG Length,
-		      PVOID Buffer)
-{
-  PCACHE_SEGMENT head;
-  PCACHE_SEGMENT current;
-  PCACHE_SEGMENT previous;
-  IO_STATUS_BLOCK Iosb;
-  LARGE_INTEGER SegOffset;
-  NTSTATUS Status;
-  ULONG TempLength;
-  KEVENT Event;
-  PMDL Mdl;
-
-  Mdl = alloca(MmSizeOfMdl(NULL, MAX_RW_LENGTH));
-
-  Status = CcRosGetCacheSegmentChain(Bcb, ReadOffset, Length, &head);
-  if (!NT_SUCCESS(Status))
-    {
-      return(Status);
-    }
-  current = head;
-  while (current != NULL)
-    {
-      /*
-       * If the current segment is valid then copy it into the
-       * user buffer.
-       */
-      if (current->Valid)
-	{
-	  TempLength = min(Bcb->CacheSegmentSize, Length);
-	  memcpy(Buffer, current->BaseAddress, TempLength);
-
-	  Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
-
-	  Length = Length - TempLength;
-	  previous = current;
-	  current = current->NextInChain;
-	  CcRosReleaseCacheSegment(Bcb, previous, TRUE, FALSE, FALSE);
-	}
-      /*
-       * Otherwise read in as much as we can.
-       */
-      else
-	{
-	  PCACHE_SEGMENT current2;
-	  ULONG current_size;
-	  ULONG i;
-	  PPFN_TYPE MdlPages;
-
-	  /*
-	   * Count the maximum number of bytes we could read starting
-	   * from the current segment.
-	   */
-	  current2 = current;
-	  current_size = 0;
-	  while (current2 != NULL && !current2->Valid && current_size < MAX_RW_LENGTH)
-	    {
-	      current2 = current2->NextInChain;
-	      current_size += Bcb->CacheSegmentSize;
-	    }
-
-	  /*
-	   * Create an MDL which contains all their pages.
-	   */
-          MmInitializeMdl(Mdl, NULL, current_size);
-	  Mdl->MdlFlags |= (MDL_PAGES_LOCKED | MDL_IO_PAGE_READ);
-	  current2 = current;
-	  current_size = 0;
-	  MdlPages = (PPFN_TYPE)(Mdl + 1);
-	  while (current2 != NULL && !current2->Valid && current_size < MAX_RW_LENGTH)
-	    {
-	      PVOID address = current2->BaseAddress;
-	      for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++, address = RVA(address, PAGE_SIZE))
-		{
-		  *MdlPages++ = MmGetPfnForProcess(NULL, address);
-		}
-	      current2 = current2->NextInChain;
-	      current_size += Bcb->CacheSegmentSize;
-	    }
-
-	  /*
-	   * Read in the information.
-	   */
-	  SegOffset.QuadPart = current->FileOffset;
-	  KeInitializeEvent(&Event, NotificationEvent, FALSE);
-	  Status = IoPageRead(Bcb->FileObject,
-			      Mdl,
-			      &SegOffset,
-			      &Event,
-			      &Iosb);
-	  if (Status == STATUS_PENDING)
-	  {
-	     KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-	     Status = Iosb.Status;
-	  }
-          if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
-          {
-	     MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
-	  }
-	  if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
-	    {
-	      while (current != NULL)
-		{
-		  previous = current;
-		  current = current->NextInChain;
-		  CcRosReleaseCacheSegment(Bcb, previous, FALSE, FALSE, FALSE);
-		}
-	      return(Status);
-	    }
-	  current_size = 0;
-	  while (current != NULL && !current->Valid && current_size < MAX_RW_LENGTH)
-	    {
-	      previous = current;
-	      current = current->NextInChain;
-	      TempLength = min(Bcb->CacheSegmentSize, Length);
-	      memcpy(Buffer, previous->BaseAddress, TempLength);
-
-	      Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
-
-	      Length = Length - TempLength;
-	      CcRosReleaseCacheSegment(Bcb, previous, TRUE, FALSE, FALSE);
-	      current_size += Bcb->CacheSegmentSize;
-	    }
-	}
-    }
-  return(STATUS_SUCCESS);
-}
-
-NTSTATUS
-NTAPI
-ReadCacheSegment(PCACHE_SEGMENT CacheSeg)
-{
-  ULONG Size;
-  PMDL Mdl;
-  NTSTATUS Status;
-  LARGE_INTEGER SegOffset;
-  IO_STATUS_BLOCK IoStatus;
-  KEVENT Event;
-
-  SegOffset.QuadPart = CacheSeg->FileOffset;
-  Size = (ULONG)(CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset);
-  if (Size > CacheSeg->Bcb->CacheSegmentSize)
-    {
-      Size = CacheSeg->Bcb->CacheSegmentSize;
-    }
-  Mdl = alloca(MmSizeOfMdl(CacheSeg->BaseAddress, Size));
-  MmInitializeMdl(Mdl, CacheSeg->BaseAddress, Size);
-  MmBuildMdlForNonPagedPool(Mdl);
-  Mdl->MdlFlags |= MDL_IO_PAGE_READ;
-  KeInitializeEvent(&Event, NotificationEvent, FALSE);
-  Status = IoPageRead(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, & Event, &IoStatus);
-  if (Status == STATUS_PENDING)
-  {
-     KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-     Status = IoStatus.Status;
-  }
-
-  if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
-    {
-      DPRINT1("IoPageRead failed, Status %x\n", Status);
-      return Status;
-    }
-  if (CacheSeg->Bcb->CacheSegmentSize > Size)
-    {
-      memset ((char*)CacheSeg->BaseAddress + Size, 0,
-	      CacheSeg->Bcb->CacheSegmentSize - Size);
-    }
-  return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-WriteCacheSegment(PCACHE_SEGMENT CacheSeg)
-{
-  ULONG Size;
-  PMDL Mdl;
-  NTSTATUS Status;
-  IO_STATUS_BLOCK IoStatus;
-  LARGE_INTEGER SegOffset;
-  KEVENT Event;
-
-  CacheSeg->Dirty = FALSE;
-  SegOffset.QuadPart = CacheSeg->FileOffset;
-  Size = (ULONG)(CacheSeg->Bcb->AllocationSize.QuadPart - CacheSeg->FileOffset);
-  if (Size > CacheSeg->Bcb->CacheSegmentSize)
-    {
-      Size = CacheSeg->Bcb->CacheSegmentSize;
-    }
-  Mdl = alloca(MmSizeOfMdl(CacheSeg->BaseAddress, Size));
-  MmInitializeMdl(Mdl, CacheSeg->BaseAddress, Size);
-  MmBuildMdlForNonPagedPool(Mdl);
-  Mdl->MdlFlags |= MDL_IO_PAGE_READ;
-  KeInitializeEvent(&Event, NotificationEvent, FALSE);
-  Status = IoSynchronousPageWrite(CacheSeg->Bcb->FileObject, Mdl, &SegOffset, &Event, &IoStatus);
-  if (Status == STATUS_PENDING)
-  {
-     KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-     Status = IoStatus.Status;
-  }
-  if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE))
-    {
-      DPRINT1("IoPageWrite failed, Status %x\n", Status);
-      CacheSeg->Dirty = TRUE;
-      return(Status);
-    }
-  return(STATUS_SUCCESS);
-}
-
-
-/*
- * @unimplemented
- */
-BOOLEAN STDCALL
-CcCanIWrite (
-			IN	PFILE_OBJECT	FileObject,
-			IN	ULONG			BytesToWrite,
-			IN	BOOLEAN			Wait,
-			IN	BOOLEAN			Retrying)
-{
-	UNIMPLEMENTED;
-	return FALSE;
-}
-
-
-/*
- * @implemented
- */
-BOOLEAN STDCALL
-CcCopyRead (IN PFILE_OBJECT FileObject,
-	    IN PLARGE_INTEGER FileOffset,
-	    IN ULONG Length,
-	    IN BOOLEAN Wait,
-	    OUT PVOID Buffer,
-	    OUT PIO_STATUS_BLOCK IoStatus)
-{
-  ULONG ReadOffset;
-  ULONG TempLength;
-  NTSTATUS Status = STATUS_SUCCESS;
-  PVOID BaseAddress;
-  PCACHE_SEGMENT CacheSeg;
-  BOOLEAN Valid;
-  ULONG ReadLength = 0;
-  PBCB Bcb;
-  KIRQL oldirql;
-  PLIST_ENTRY current_entry;
-  PCACHE_SEGMENT current;
-
-  DPRINT("CcCopyRead(FileObject 0x%p, FileOffset %I64x, "
-	 "Length %d, Wait %d, Buffer 0x%p, IoStatus 0x%p)\n",
-	 FileObject, FileOffset->QuadPart, Length, Wait,
-	 Buffer, IoStatus);
-
-  Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-  ReadOffset = (ULONG)FileOffset->QuadPart;
-
-  DPRINT("AllocationSize %d, FileSize %d\n",
-         (ULONG)Bcb->AllocationSize.QuadPart,
-         (ULONG)Bcb->FileSize.QuadPart);
-
-  /*
-   * Check for the nowait case that all the cache segments that would
-   * cover this read are in memory.
-   */
-  if (!Wait)
-    {
-      KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-      current_entry = Bcb->BcbSegmentListHead.Flink;
-      while (current_entry != &Bcb->BcbSegmentListHead)
-	{
-	  current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
-				      BcbSegmentListEntry);
-	  if (!current->Valid && current->FileOffset < ReadOffset + Length
-	      && current->FileOffset + Bcb->CacheSegmentSize > ReadOffset)
-	    {
-	      KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-	      IoStatus->Status = STATUS_UNSUCCESSFUL;
-	      IoStatus->Information = 0;
-	      return FALSE;
-	    }
-	  current_entry = current_entry->Flink;
-	}
-      KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-    }
-
-  TempLength = ReadOffset % Bcb->CacheSegmentSize;
-  if (TempLength != 0)
-    {
-      TempLength = min (Length, Bcb->CacheSegmentSize - TempLength);
-      Status = CcRosRequestCacheSegment(Bcb,
-					ROUND_DOWN(ReadOffset,
-						   Bcb->CacheSegmentSize),
-					&BaseAddress, &Valid, &CacheSeg);
-      if (!NT_SUCCESS(Status))
-	{
-	  IoStatus->Information = 0;
-	  IoStatus->Status = Status;
-	  DPRINT("CcRosRequestCacheSegment faild, Status %x\n", Status);
-	  return FALSE;
-	}
-      if (!Valid)
-	{
-	  Status = ReadCacheSegment(CacheSeg);
-	  if (!NT_SUCCESS(Status))
-	    {
-	      IoStatus->Information = 0;
-	      IoStatus->Status = Status;
-              CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
-	      return FALSE;
-	    }
-	}
-      memcpy (Buffer, (char*)BaseAddress + ReadOffset % Bcb->CacheSegmentSize,
-	      TempLength);
-      CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
-      ReadLength += TempLength;
-      Length -= TempLength;
-      ReadOffset += TempLength;
-      Buffer = (PVOID)((char*)Buffer + TempLength);
-    }
-  while (Length > 0)
-    {
-      TempLength = min(max(Bcb->CacheSegmentSize, MAX_RW_LENGTH), Length);
-      ReadCacheSegmentChain(Bcb, ReadOffset, TempLength, Buffer);
-      ReadLength += TempLength;
-      Length -= TempLength;
-      ReadOffset += TempLength;
-
-      Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
-    }
-  IoStatus->Status = STATUS_SUCCESS;
-  IoStatus->Information = ReadLength;
-  DPRINT("CcCopyRead O.K.\n");
-  return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN STDCALL
-CcCopyWrite (IN PFILE_OBJECT FileObject,
-	     IN PLARGE_INTEGER FileOffset,
-	     IN ULONG Length,
-	     IN BOOLEAN Wait,
-	     IN PVOID Buffer)
-{
-   NTSTATUS Status;
-   ULONG WriteOffset;
-   KIRQL oldirql;
-   PBCB Bcb;
-   PLIST_ENTRY current_entry;
-   PCACHE_SEGMENT CacheSeg;
-   ULONG TempLength;
-   PVOID BaseAddress;
-   BOOLEAN Valid;
-
-   DPRINT("CcCopyWrite(FileObject 0x%p, FileOffset %I64x, "
-	  "Length %d, Wait %d, Buffer 0x%p)\n",
-          FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
-
-   Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-   WriteOffset = (ULONG)FileOffset->QuadPart;
-
-   if (!Wait)
-     {
-       /* testing, if the requested datas are available */
-       KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-       current_entry = Bcb->BcbSegmentListHead.Flink;
-       while (current_entry != &Bcb->BcbSegmentListHead)
-	 {
-	   CacheSeg = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
-					BcbSegmentListEntry);
-	   if (!CacheSeg->Valid)
-	     {
-	       if ((WriteOffset >= CacheSeg->FileOffset &&
-		    WriteOffset < CacheSeg->FileOffset + Bcb->CacheSegmentSize)
-		   || (WriteOffset + Length > CacheSeg->FileOffset &&
-		       WriteOffset + Length <= CacheSeg->FileOffset +
-		       Bcb->CacheSegmentSize))
-		 {
-		   KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-		   /* datas not available */
-		   return(FALSE);
-		 }
-	     }
-	   current_entry = current_entry->Flink;
-	 }
-       KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-     }
-
-   TempLength = WriteOffset % Bcb->CacheSegmentSize;
-   if (TempLength != 0)
-     {
-       ULONG ROffset;
-       ROffset = ROUND_DOWN(WriteOffset, Bcb->CacheSegmentSize);
-       TempLength = min (Length, Bcb->CacheSegmentSize - TempLength);
-       Status = CcRosRequestCacheSegment(Bcb, ROffset,
-					 &BaseAddress, &Valid, &CacheSeg);
-       if (!NT_SUCCESS(Status))
-	 {
-	   return(FALSE);
-	 }
-       if (!Valid)
-	 {
-	   if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
-	     {
-	       return(FALSE);
-	     }
-	 }
-       memcpy ((char*)BaseAddress + WriteOffset % Bcb->CacheSegmentSize,
-	       Buffer, TempLength);
-       CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
-
-       Length -= TempLength;
-       WriteOffset += TempLength;
-
-       Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
-     }
-
-   while (Length > 0)
-     {
-       TempLength = min (Bcb->CacheSegmentSize, Length);
-       Status = CcRosRequestCacheSegment(Bcb, WriteOffset,
-					 &BaseAddress, &Valid, &CacheSeg);
-       if (!NT_SUCCESS(Status))
-	 {
-	   return(FALSE);
-	 }
-       if (!Valid && TempLength < Bcb->CacheSegmentSize)
-	 {
-	   if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
-	     {
-               CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
-	       return FALSE;
-	     }
-	 }
-       memcpy (BaseAddress, Buffer, TempLength);
-       CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, TRUE, FALSE);
-       Length -= TempLength;
-       WriteOffset += TempLength;
-
-       Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
-     }
-   return(TRUE);
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcDeferWrite (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PCC_POST_DEFERRED_WRITE	PostRoutine,
-	IN	PVOID			Context1,
-	IN	PVOID			Context2,
-	IN	ULONG			BytesToWrite,
-	IN	BOOLEAN			Retrying
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcFastCopyRead (
-    IN  PFILE_OBJECT FileObject,
-    IN  ULONG FileOffset,
-    IN  ULONG Length,
-    IN  ULONG PageCount,
-    OUT PVOID Buffer,
-    OUT PIO_STATUS_BLOCK IoStatus
-	)
-{
-	UNIMPLEMENTED;
-}
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcFastCopyWrite(
-    IN  PFILE_OBJECT FileObject,
-    IN  ULONG FileOffset,
-    IN  ULONG Length,
-    IN  PVOID Buffer)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-STDCALL
-CcWaitForCurrentLazyWriterActivity (
-    VOID
-    )
-{
-	UNIMPLEMENTED;
-	return STATUS_NOT_IMPLEMENTED;
-}
-
-/*
- * @implemented
- */
-BOOLEAN STDCALL
-CcZeroData (IN PFILE_OBJECT     FileObject,
-	    IN PLARGE_INTEGER   StartOffset,
-	    IN PLARGE_INTEGER   EndOffset,
-	    IN BOOLEAN          Wait)
-{
-  NTSTATUS Status;
-  LARGE_INTEGER WriteOffset;
-  ULONG Length;
-  ULONG CurrentLength;
-  PMDL Mdl;
-  ULONG i;
-  IO_STATUS_BLOCK Iosb;
-  KEVENT Event;
-
-  DPRINT("CcZeroData(FileObject 0x%p, StartOffset %I64x, EndOffset %I64x, "
-	 "Wait %d)\n", FileObject, StartOffset->QuadPart, EndOffset->QuadPart,
-	 Wait);
-
-  Length = EndOffset->u.LowPart - StartOffset->u.LowPart;
-  WriteOffset.QuadPart = StartOffset->QuadPart;
-
-  if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
-    {
-      /* File is not cached */
-
-      Mdl = alloca(MmSizeOfMdl(NULL, MAX_ZERO_LENGTH));
-
-      while (Length > 0)
-	{
-	  if (Length + WriteOffset.u.LowPart % PAGE_SIZE > MAX_ZERO_LENGTH)
-	    {
-	      CurrentLength = MAX_ZERO_LENGTH - WriteOffset.u.LowPart % PAGE_SIZE;
-	    }
-	  else
-	    {
-	      CurrentLength = Length;
-	    }
-          MmInitializeMdl(Mdl, (PVOID)WriteOffset.u.LowPart, CurrentLength);
-	  Mdl->MdlFlags |= (MDL_PAGES_LOCKED | MDL_IO_PAGE_READ);
-	  for (i = 0; i < ((Mdl->Size - sizeof(MDL)) / sizeof(ULONG)); i++)
-	    {
-	      ((PPFN_TYPE)(Mdl + 1))[i] = CcZeroPage;
-	    }
-          KeInitializeEvent(&Event, NotificationEvent, FALSE);
-	  Status = IoSynchronousPageWrite(FileObject, Mdl, &WriteOffset, &Event, &Iosb);
-          if (Status == STATUS_PENDING)
-	  {
-             KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
-             Status = Iosb.Status;
-	  }
-          MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
-	  if (!NT_SUCCESS(Status))
-	    {
-	      return(FALSE);
-	    }
-	  WriteOffset.QuadPart += CurrentLength;
-	  Length -= CurrentLength;
-	}
-    }
-  else
-    {
-      /* File is cached */
-      KIRQL oldirql;
-      PBCB Bcb;
-      PLIST_ENTRY current_entry;
-      PCACHE_SEGMENT CacheSeg, current, previous;
-      ULONG TempLength;
-
-      Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-      if (Wait)
-	{
-          /* testing, if the requested datas are available */
-	  KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-	  current_entry = Bcb->BcbSegmentListHead.Flink;
-	  while (current_entry != &Bcb->BcbSegmentListHead)
-	    {
-	      CacheSeg = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
-					   BcbSegmentListEntry);
-	      if (!CacheSeg->Valid)
-		{
-		  if ((WriteOffset.u.LowPart >= CacheSeg->FileOffset &&
-		       WriteOffset.u.LowPart < CacheSeg->FileOffset + Bcb->CacheSegmentSize)
-		      || (WriteOffset.u.LowPart + Length > CacheSeg->FileOffset &&
-			  WriteOffset.u.LowPart + Length <=
-			  CacheSeg->FileOffset + Bcb->CacheSegmentSize))
-		    {
-		      KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-		      /* datas not available */
-		      return(FALSE);
-		    }
-		}
-	      current_entry = current_entry->Flink;
-	    }
-	  KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-	}
-      while (Length > 0)
-	{
-          ULONG Offset;
-	  Offset = WriteOffset.u.LowPart % Bcb->CacheSegmentSize;
-	  if (Length + Offset > MAX_ZERO_LENGTH)
-	    {
-	      CurrentLength = MAX_ZERO_LENGTH - Offset;
-	    }
-	  else
-	    {
-	      CurrentLength = Length;
-	    }
-	  Status = CcRosGetCacheSegmentChain (Bcb, WriteOffset.u.LowPart - Offset,
-					      Offset + CurrentLength, &CacheSeg);
-	  if (!NT_SUCCESS(Status))
-	    {
-	      return FALSE;
-	    }
-	  current = CacheSeg;
-
-	  while (current != NULL)
-	    {
-	      Offset = WriteOffset.u.LowPart % Bcb->CacheSegmentSize;
-	      if (Offset != 0 ||
-                  Offset + CurrentLength < Bcb->CacheSegmentSize)
-	        {
-		  if (!current->Valid)
-		    {
-		      /* read the segment */
-		      Status = ReadCacheSegment(current);
-		      if (!NT_SUCCESS(Status))
-			{
-			  DPRINT1("ReadCacheSegment failed, status %x\n",
-				  Status);
-			}
-		    }
-		  TempLength = min (CurrentLength, Bcb->CacheSegmentSize - Offset);
-		}
-	      else
-	        {
-		  TempLength = Bcb->CacheSegmentSize;
-		}
-	      memset ((PUCHAR)current->BaseAddress + Offset, 0, TempLength);
-
-              WriteOffset.QuadPart += TempLength;
-	      CurrentLength -= TempLength;
-	      Length -= TempLength;
-
-      	      current = current->NextInChain;
-	    }
-
-          current = CacheSeg;
-	  while (current != NULL)
-	    {
-	      previous = current;
-	      current = current->NextInChain;
-	      CcRosReleaseCacheSegment(Bcb, previous, TRUE, TRUE, FALSE);
-	    }
-	}
-    }
-  return(TRUE);
-}
--- a/reactos/ntoskrnl/cc/fs.c
+++ b/reactos/ntoskrnl/cc/fs.c
@@ -1,244 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/cc/fs.c
- * PURPOSE:         Implements cache managers functions useful for File Systems
- *
- * PROGRAMMERS:     Alex Ionescu
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#ifndef VACB_MAPPING_GRANULARITY
-#define VACB_MAPPING_GRANULARITY (256 * 1024)
-#endif
-
-/* GLOBALS   *****************************************************************/
-
-extern FAST_MUTEX ViewLock;
-extern ULONG DirtyPageCount;
-
-NTSTATUS CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg);
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @unimplemented
- */
-LARGE_INTEGER
-STDCALL
-CcGetDirtyPages (
-	IN	PVOID			LogHandle,
-	IN	PDIRTY_PAGE_ROUTINE	DirtyPageRoutine,
-	IN	PVOID			Context1,
-	IN	PVOID			Context2
-	)
-{
-	LARGE_INTEGER i;
-	UNIMPLEMENTED;
-	i.QuadPart = 0;
-	return i;
-}
-
-/*
- * @implemented
- */
-PFILE_OBJECT
-STDCALL
-CcGetFileObjectFromBcb (
-	IN	PVOID	Bcb
-	)
-{
-	PINTERNAL_BCB iBcb = (PINTERNAL_BCB)Bcb;
-	return iBcb->CacheSegment->Bcb->FileObject;
-}
-
-/*
- * @unimplemented
- */
-LARGE_INTEGER
-STDCALL
-CcGetLsnForFileObject (
-	IN	PFILE_OBJECT	FileObject,
-	OUT	PLARGE_INTEGER	OldestLsn OPTIONAL
-	)
-{
-	LARGE_INTEGER i;
-	UNIMPLEMENTED;
-	i.QuadPart = 0;
-	return i;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcInitializeCacheMap (
-	IN	PFILE_OBJECT			FileObject,
-	IN	PCC_FILE_SIZES			FileSizes,
-	IN	BOOLEAN				PinAccess,
-	IN	PCACHE_MANAGER_CALLBACKS	CallBacks,
-	IN	PVOID				LazyWriterContext
-	)
-{
-    CcRosInitializeFileCache(FileObject, VACB_MAPPING_GRANULARITY);
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcIsThereDirtyData (
-	IN	PVPB	Vpb
-	)
-{
-	UNIMPLEMENTED;
-	return FALSE;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcPurgeCacheSection (
-	IN	PSECTION_OBJECT_POINTERS	SectionObjectPointer,
-	IN	PLARGE_INTEGER			FileOffset OPTIONAL,
-	IN	ULONG				Length,
-	IN	BOOLEAN				UninitializeCacheMaps
-	)
-{
-	UNIMPLEMENTED;
-	return FALSE;
-}
-
-
-/*
- * @implemented
- */
-VOID STDCALL
-CcSetFileSizes (IN PFILE_OBJECT FileObject,
-		IN PCC_FILE_SIZES FileSizes)
-{
-  KIRQL oldirql;
-  PBCB Bcb;
-  PLIST_ENTRY current_entry;
-  PCACHE_SEGMENT current;
-  LIST_ENTRY FreeListHead;
-  NTSTATUS Status;
-
-  DPRINT("CcSetFileSizes(FileObject 0x%p, FileSizes 0x%p)\n",
-	 FileObject, FileSizes);
-  DPRINT("AllocationSize %d, FileSize %d, ValidDataLength %d\n",
-         (ULONG)FileSizes->AllocationSize.QuadPart,
-         (ULONG)FileSizes->FileSize.QuadPart,
-         (ULONG)FileSizes->ValidDataLength.QuadPart);
-
-  Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-
-  /*
-   * It is valid to call this function on file objects that weren't
-   * initialized for caching. In this case it's simple no-op.
-   */
-  if (Bcb == NULL)
-     return;
-
-  if (FileSizes->AllocationSize.QuadPart < Bcb->AllocationSize.QuadPart)
-  {
-     InitializeListHead(&FreeListHead);
-     ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
-     KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-
-     current_entry = Bcb->BcbSegmentListHead.Flink;
-     while (current_entry != &Bcb->BcbSegmentListHead)
-     {
-	current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
-	current_entry = current_entry->Flink;
-	if (current->FileOffset > FileSizes->AllocationSize.QuadPart)
-	{
-           if (current->ReferenceCount == 0 || (current->ReferenceCount == 1 && current->Dirty))
-	   {
-              RemoveEntryList(&current->BcbSegmentListEntry);
-              RemoveEntryList(&current->CacheSegmentListEntry);
-              RemoveEntryList(&current->CacheSegmentLRUListEntry);
-              if (current->Dirty)
-              {
-                 RemoveEntryList(&current->DirtySegmentListEntry);
-                 DirtyPageCount -= Bcb->CacheSegmentSize / PAGE_SIZE;
-              }
-	      InsertHeadList(&FreeListHead, &current->BcbSegmentListEntry);
-	   }
-	   else
-	   {
-	      DPRINT1("Anyone has referenced a cache segment behind the new size.\n");
-	      KEBUGCHECKCC;
-	   }
-	}
-     }
-
-     Bcb->AllocationSize = FileSizes->AllocationSize;
-     Bcb->FileSize = FileSizes->FileSize;
-     KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-     ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
-
-     current_entry = FreeListHead.Flink;
-     while(current_entry != &FreeListHead)
-     {
-        current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
-        current_entry = current_entry->Flink;
-        Status = CcRosInternalFreeCacheSegment(current);
-        if (!NT_SUCCESS(Status))
-        {
-           DPRINT1("CcRosInternalFreeCacheSegment failed, status = %x\n", Status);
-	   KEBUGCHECK(0);
-        }
-     }
-  }
-  else
-  {
-     KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-     Bcb->AllocationSize = FileSizes->AllocationSize;
-     Bcb->FileSize = FileSizes->FileSize;
-     KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-  }
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcSetLogHandleForFile (
-	IN	PFILE_OBJECT	FileObject,
-	IN	PVOID		LogHandle,
-	IN	PFLUSH_TO_LSN	FlushToLsnRoutine
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcUninitializeCacheMap (
-	IN	PFILE_OBJECT			FileObject,
-	IN	PLARGE_INTEGER			TruncateSize OPTIONAL,
-	IN	PCACHE_UNINITIALIZE_EVENT	UninitializeCompleteEvent OPTIONAL
-	)
-{
-#if 0
-	UNIMPLEMENTED;
-	return FALSE;
-#else
-    return CcRosReleaseFileCache(FileObject);
-#endif
-}
--- a/reactos/ntoskrnl/cc/mdl.c
+++ b/reactos/ntoskrnl/cc/mdl.c
@@ -1,175 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/cc/fs.c
- * PURPOSE:         Implements MDL Cache Manager Functions
- *
- * PROGRAMMERS:     Alex Ionescu
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-CcMdlRead(
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length,
-	OUT	PMDL			* MdlChain,
-	OUT	PIO_STATUS_BLOCK	IoStatus
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * NAME							INTERNAL
- * CcMdlReadCompleteDev@8
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- * MdlChain
- * DeviceObject
- *
- * RETURN VALUE
- *  None.
- *
- * NOTE
- * 	Used by CcMdlReadComplete@8 and FsRtl
- *
- */
-VOID
-STDCALL
-CcMdlReadCompleteDev(IN PMDL MdlChain,
-                     IN PFILE_OBJECT FileObject)
-{
-    PMDL Mdl;
-
-    /* Free MDLs */
-    while ((Mdl = MdlChain))
-    {
-        MdlChain = Mdl->Next;
-        MmUnlockPages(Mdl);
-        IoFreeMdl(Mdl);
-    }
-}
-
-/*
- * NAME    EXPORTED
- * CcMdlReadComplete@8
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- * None.
- *
- * NOTE
- * From Bo Branten's ntifs.h v13.
- *
- * @implemented
- */
-VOID
-STDCALL
-CcMdlReadComplete(IN PFILE_OBJECT FileObject,
-                  IN PMDL MdlChain)
-{
-    PDEVICE_OBJECT DeviceObject = NULL;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Fast Dispatch Data */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->MdlReadComplete)
-    {
-         /* Use the fast path */
-        FastDispatch->MdlReadComplete(FileObject,
-                                      MdlChain,
-                                      DeviceObject);
-    }
-
-    /* Use slow path */
-    CcMdlReadCompleteDev(MdlChain, FileObject);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-CcMdlWriteComplete(IN PFILE_OBJECT FileObject,
-                   IN PLARGE_INTEGER FileOffset,
-                   IN PMDL MdlChain)
-{
-    PDEVICE_OBJECT DeviceObject = NULL;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Fast Dispatch Data */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->MdlWriteComplete)
-    {
-         /* Use the fast path */
-        FastDispatch->MdlWriteComplete(FileObject,
-                                       FileOffset,
-                                       MdlChain,
-                                       DeviceObject);
-    }
-
-    /* Use slow path */
-    CcMdlWriteCompleteDev(FileOffset, MdlChain, FileObject);
-}
-
-VOID
-STDCALL
-CcMdlWriteCompleteDev(IN PLARGE_INTEGER FileOffset,
-                      IN PMDL MdlChain,
-                      IN PFILE_OBJECT FileObject)
-{
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcMdlWriteAbort (
-    IN PFILE_OBJECT FileObject,
-    IN PMDL MdlChain
-    )
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcPrepareMdlWrite (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length,
-	OUT	PMDL			* MdlChain,
-	OUT	PIO_STATUS_BLOCK	IoStatus
-	)
-{
-	UNIMPLEMENTED;
-}
--- a/reactos/ntoskrnl/cc/pin.c
+++ b/reactos/ntoskrnl/cc/pin.c
@@ -1,257 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/cc/pin.c
- * PURPOSE:         Implements cache managers pinning interface
- *
- * PROGRAMMERS:     
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-extern NPAGED_LOOKASIDE_LIST iBcbLookasideList;
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @implemented
- */
-BOOLEAN STDCALL
-CcMapData (IN PFILE_OBJECT FileObject,
-	   IN PLARGE_INTEGER FileOffset,
-	   IN ULONG Length,
-	   IN BOOLEAN Wait,
-	   OUT PVOID *pBcb,
-	   OUT PVOID *pBuffer)
-{
-  ULONG ReadOffset;
-  BOOLEAN Valid;
-  PBCB Bcb;
-  PCACHE_SEGMENT CacheSeg;
-  NTSTATUS Status;
-  PINTERNAL_BCB iBcb;
-  ULONG ROffset;
-
-  DPRINT("CcMapData(FileObject 0x%p, FileOffset %I64x, Length %d, Wait %d,"
-	 " pBcb 0x%p, pBuffer 0x%p)\n", FileObject, FileOffset->QuadPart,
-	 Length, Wait, pBcb, pBuffer);
-
-  ReadOffset = (ULONG)FileOffset->QuadPart;
-  Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-  ASSERT(Bcb);
-
-  DPRINT("AllocationSize %I64x, FileSize %I64x\n",
-         Bcb->AllocationSize.QuadPart,
-         Bcb->FileSize.QuadPart);
-
-  if (ReadOffset % Bcb->CacheSegmentSize + Length > Bcb->CacheSegmentSize)
-    {
-      return(FALSE);
-    }
-  ROffset = ROUND_DOWN (ReadOffset, Bcb->CacheSegmentSize);
-  Status = CcRosRequestCacheSegment(Bcb,
-				    ROffset,
-				    pBuffer,
-				    &Valid,
-				    &CacheSeg);
-  if (!NT_SUCCESS(Status))
-    {
-      return(FALSE);
-    }
-  if (!Valid)
-    {
-      if (!Wait)
-	{
-          CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
-	  return(FALSE);
-	}
-      if (!NT_SUCCESS(ReadCacheSegment(CacheSeg)))
-	{
-          CcRosReleaseCacheSegment(Bcb, CacheSeg, FALSE, FALSE, FALSE);
-	  return(FALSE);
-	}
-    }
-
-  *pBuffer = (PVOID)((ULONG_PTR)(*pBuffer) + (ReadOffset % Bcb->CacheSegmentSize));
-  iBcb = ExAllocateFromNPagedLookasideList(&iBcbLookasideList);
-  if (iBcb == NULL)
-    {
-      CcRosReleaseCacheSegment(Bcb, CacheSeg, TRUE, FALSE, FALSE);
-      return FALSE;
-    }
-  memset(iBcb, 0, sizeof(INTERNAL_BCB));
-  iBcb->PFCB.NodeTypeCode = 0xDE45; /* Undocumented (CAPTIVE_PUBLIC_BCB_NODETYPECODE) */
-  iBcb->PFCB.NodeByteSize = sizeof(PUBLIC_BCB);
-  iBcb->PFCB.MappedLength = Length;
-  iBcb->PFCB.MappedFileOffset = *FileOffset;
-  iBcb->CacheSegment = CacheSeg;
-  iBcb->Dirty = FALSE;
-  iBcb->RefCount = 1;
-  *pBcb = (PVOID)iBcb;
-  return(TRUE);
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcPinMappedData (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length,
-	IN	ULONG			Flags,
-	OUT	PVOID			* Bcb
-	)
-{
-  /* no-op for current implementation. */
-  return TRUE;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcPinRead (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length,
-	IN	ULONG			Flags,
-	OUT	PVOID			* Bcb,
-	OUT	PVOID			* Buffer
-	)
-{
-  if (CcMapData(FileObject, FileOffset, Length, Flags, Bcb, Buffer))
-  {
-    if (CcPinMappedData(FileObject, FileOffset, Length, Flags, Bcb))
-      return TRUE;
-    else
-      CcUnpinData(Bcb);
-  }
-  return FALSE;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-CcPreparePinWrite (
-	IN	PFILE_OBJECT		FileObject,
-	IN	PLARGE_INTEGER		FileOffset,
-	IN	ULONG			Length,
-	IN	BOOLEAN			Zero,
-	IN	ULONG			Flags,
-	OUT	PVOID			* Bcb,
-	OUT	PVOID			* Buffer
-	)
-{
-        /*
-         * FIXME: This is function is similar to CcPinRead, but doesn't
-         * read the data if they're not present. Instead it should just
-         * prepare the cache segments and zero them out if Zero == TRUE.
-         *
-         * For now calling CcPinRead is better than returning error or
-         * just having UNIMPLEMENTED here.
-         */
-        return CcPinRead(FileObject, FileOffset, Length, Flags, Bcb, Buffer);
-}
-
-/*
- * @implemented
- */
-VOID STDCALL
-CcSetDirtyPinnedData (IN PVOID Bcb,
-		      IN PLARGE_INTEGER Lsn)
-{
-   PINTERNAL_BCB iBcb = Bcb;
-   iBcb->Dirty = TRUE;
-}
-
-
-/*
- * @implemented
- */
-VOID STDCALL
-CcUnpinData (IN PVOID Bcb)
-{
-  PINTERNAL_BCB iBcb = Bcb;
-  CcRosReleaseCacheSegment(iBcb->CacheSegment->Bcb, iBcb->CacheSegment, TRUE,
-                           iBcb->Dirty, FALSE);
-  if (--iBcb->RefCount == 0)
-  {
-    ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
-  }
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcUnpinDataForThread (
-	IN	PVOID			Bcb,
-	IN	ERESOURCE_THREAD	ResourceThreadId
-	)
-{
-	UNIMPLEMENTED;
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-CcRepinBcb (
-	IN	PVOID	Bcb
-	)
-{
-  PINTERNAL_BCB iBcb = Bcb;
-  iBcb->RefCount++;
-}
-
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-CcUnpinRepinnedBcb (
-	IN	PVOID			Bcb,
-	IN	BOOLEAN			WriteThrough,
-	IN	PIO_STATUS_BLOCK	IoStatus
-	)
-{
-  PINTERNAL_BCB iBcb = Bcb;
-
-  if (--iBcb->RefCount == 0)
-    {
-      IoStatus->Information = 0;
-      if (WriteThrough)
-        {
-          ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&iBcb->CacheSegment->Lock);
-          if (iBcb->CacheSegment->Dirty)
-            {
-              IoStatus->Status = CcRosFlushCacheSegment(iBcb->CacheSegment);
-            }
-          else
-            {
-              IoStatus->Status = STATUS_SUCCESS;
-            }
-          ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&iBcb->CacheSegment->Lock);
-        }
-      else
-        {
-          IoStatus->Status = STATUS_SUCCESS;
-        }
-
-      ExFreeToNPagedLookasideList(&iBcbLookasideList, iBcb);
-    }
-}
--- a/reactos/ntoskrnl/cc/view.c
+++ b/reactos/ntoskrnl/cc/view.c
--- a/reactos/ntoskrnl/cm/cm.h
+++ b/reactos/ntoskrnl/cm/cm.h
--- a/reactos/ntoskrnl/cm/cm_x.h
+++ b/reactos/ntoskrnl/cm/cm_x.h
@@ -1,248 +0,0 @@
-/*
-* PROJECT:         ReactOS Kernel
-* LICENSE:         GPL - See COPYING in the top level directory
-* FILE:            ntoskrnl/cm/cm_x.h
-* PURPOSE:         Inlined Functions for the Configuration Manager
-* PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
-*/
-
-//
-// Returns whether or not this is a small valued key
-//
-BOOLEAN
-FORCEINLINE
-CmpIsKeyValueSmall(OUT PULONG RealLength,
-                   IN ULONG Length)
-{
-    /* Check if the length has the special size value */
-    if (Length >= CM_KEY_VALUE_SPECIAL_SIZE)
-    {
-        /* It does, so this is a small key: return the real length */
-        *RealLength = Length - CM_KEY_VALUE_SPECIAL_SIZE;
-        return TRUE;
-    }
-
-    /* This is not a small key, return the length we read */
-    *RealLength = Length;
-    return FALSE;
-}
-
-//
-// Returns whether or not this is a big valued key
-//
-BOOLEAN
-FORCEINLINE
-CmpIsKeyValueBig(IN PHHIVE Hive,
-                 IN ULONG Length)
-{
-    /* Check if the hive is XP Beta 1 or newer */
-    if (Hive->Version >= HSYS_WHISTLER_BETA1)
-    {
-        /* Check if the key length is valid for a big value key */
-        if ((Length < CM_KEY_VALUE_SPECIAL_SIZE) && (Length > CM_KEY_VALUE_BIG))
-        {
-            /* Yes, this value is big */
-            return TRUE;
-        }
-    }
-
-    /* Not a big value key */
-    return FALSE;
-}
-
-//
-// Returns the hashkey corresponding to a convkey
-//
-#define GET_HASH_KEY(ConvKey)                                       \
-    ((CMP_HASH_IRRATIONAL * (ConvKey)) % CMP_HASH_PRIME)
-
-//
-// Returns the index into the hash table, or the entry itself
-//
-#define GET_HASH_INDEX(ConvKey)                                     \
-    GET_HASH_KEY(ConvKey) % CmpHashTableSize
-#define GET_HASH_ENTRY(Table, ConvKey)                              \
-    (Table[GET_HASH_INDEX(ConvKey)])
-
-//
-// Returns whether or not the cell is cached
-//
-#define CMP_IS_CELL_CACHED(c)                                       \
-    (((c) & HCELL_CACHED) && ((c) != HCELL_NIL))
-
-//
-// Return data from a cached cell
-//
-#define CMP_GET_CACHED_CELL(c)                                      \
-    (ULONG_PTR)((c) & ~HCELL_CACHED)
-#define CMP_GET_CACHED_DATA(c)                                      \
-    (&(((PCM_CACHED_VALUE_INDEX)(CMP_GET_CACHED_CELL(c)))->Data.CellData))
-#define CMP_GET_CACHED_INDEX(c)                                     \
-    (&(((PCM_CACHED_ENTRY)(CMP_GET_CACHED_CELL(c)))->CellIndex))
-#define CMP_GET_CACHED_VALUE(c)                                     \
-    (&(((PCM_CACHED_VALUE)(CMP_GET_CACHED_CELL(c)))->KeyValue))
-
-//
-// Makes sure that the registry is locked
-//
-#define CMP_ASSERT_REGISTRY_LOCK()                                  \
-    ASSERT((CmpSpecialBootCondition == TRUE) ||                     \
-           (CmpTestRegistryLock() == TRUE))
-
-//
-// Makes sure that the registry is exclusively locked
-//
-#define CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK()                        \
-    ASSERT((CmpSpecialBootCondition == TRUE) ||                     \
-           (CmpTestRegistryLockExclusive() == TRUE))
-
-//
-// Checks if a KCB is exclusively locked
-//
-#define CmpIsKcbLockedExclusive(k)                                  \
-    (GET_HASH_ENTRY(CmpCacheTable,                                  \
-                    (k)->ConvKey).Owner == KeGetCurrentThread())
-
-//
-// Exclusively acquires a KCB
-//
-#define CmpAcquireKcbLockExclusive(k)                               \
-{                                                                   \
-    ExAcquirePushLockExclusive(&GET_HASH_ENTRY(CmpCacheTable,       \
-                                              (k)->ConvKey).Lock);  \
-    GET_HASH_ENTRY(CmpCacheTable,                                   \
-                   (k)->ConvKey).Owner = KeGetCurrentThread();      \
-}
-
-//
-// Exclusively acquires a KCB by index
-//
-#define CmpAcquireKcbLockExclusiveByIndex(i)                        \
-{                                                                   \
-    ExAcquirePushLockExclusive(&CmpCacheTable[(i)].Lock);           \
-    CmpCacheTable[(i)].Owner = KeGetCurrentThread();                \
-}
-
-//
-// Exclusively acquires a KCB by key
-//
-#define CmpAcquireKcbLockExclusiveByKey(k)                          \
-{                                                                   \
-    ExAcquirePushLockExclusive(&GET_HASH_ENTRY(CmpCacheTable,       \
-                                              (k)).Lock);           \
-    GET_HASH_ENTRY(CmpCacheTable,                                   \
-                   (k)).Owner = KeGetCurrentThread();               \
-}
-
-
-//
-// Shared acquires a KCB
-//
-#define CmpAcquireKcbLockShared(k)                                  \
-{                                                                   \
-    ExAcquirePushLockShared(&GET_HASH_ENTRY(CmpCacheTable,          \
-                                            (k)->ConvKey).Lock);    \
-}
-
-//
-// Shared acquires a KCB by index
-//
-#define CmpAcquireKcbLockSharedByIndex(i)                           \
-{                                                                   \
-    ExAcquirePushLockShared(&CmpCacheTable[(i)].Lock);              \
-}
-
-//
-// Tries to convert a KCB lock
-//
-FORCEINLINE
-BOOLEAN
-CmpTryToConvertKcbSharedToExclusive(IN PCM_KEY_CONTROL_BLOCK k)
-{
-    ASSERT(CmpIsKcbLockedExclusive(k) == FALSE);
-    if (ExConvertPushLockSharedToExclusive(
-            &GET_HASH_ENTRY(CmpCacheTable, k->ConvKey).Lock))
-    {
-        GET_HASH_ENTRY(CmpCacheTable,
-                       k->ConvKey).Owner = KeGetCurrentThread();
-        return TRUE;
-    }
-    return FALSE;
-}
-
-//
-// Releases an exlusively or shared acquired KCB
-//
-#define CmpReleaseKcbLock(k)                                        \
-{                                                                   \
-    GET_HASH_ENTRY(CmpCacheTable, (k)->ConvKey).Owner = NULL;       \
-    ExReleasePushLock(&GET_HASH_ENTRY(CmpCacheTable,                \
-                                      (k)->ConvKey).Lock);          \
-}
-
-//
-// Releases an exlusively or shared acquired KCB by index
-//
-#define CmpReleaseKcbLockByIndex(i)                                 \
-{                                                                   \
-    CmpCacheTable[(i)].Owner = NULL;                                \
-    ExReleasePushLock(&CmpCacheTable[(i)].Lock);                    \
-}
-
-//
-// Releases an exlusively or shared acquired KCB by key
-//
-#define CmpReleaseKcbLockByKey(k)                                   \
-{                                                                   \
-    GET_HASH_ENTRY(CmpCacheTable, (k)).Owner = NULL;                \
-    ExReleasePushLock(&GET_HASH_ENTRY(CmpCacheTable,                \
-                                      (k)).Lock);                   \
-}
-
-//
-// Converts a KCB lock
-//
-FORCEINLINE
-VOID
-CmpConvertKcbSharedToExclusive(IN PCM_KEY_CONTROL_BLOCK k)
-{
-    ASSERT(CmpIsKcbLockedExclusive(k) == FALSE);  
-    CmpReleaseKcbLock(k);
-    CmpAcquireKcbLockExclusive(k);
-}
-
-//
-// Exclusively acquires an NCB
-//
-#define CmpAcquireNcbLockExclusive(n)                               \
-{                                                                   \
-    ExAcquirePushLockExclusive(&GET_HASH_ENTRY(CmpNameCacheTable,   \
-                                              (n)->ConvKey).Lock);  \
-}
-
-//
-// Exclusively acquires an NCB by key
-//
-#define CmpAcquireNcbLockExclusiveByKey(k)                          \
-{                                                                   \
-    ExAcquirePushLockExclusive(&GET_HASH_ENTRY(CmpNameCacheTable,   \
-                                               (k)).Lock);          \
-}
-
-//
-// Releases an exlusively or shared acquired NCB
-//
-#define CmpReleaseNcbLock(k)                                        \
-{                                                                   \
-    ExReleasePushLock(&GET_HASH_ENTRY(CmpNameCacheTable,            \
-                                     (k)->ConvKey).Lock);           \
-}
-
-//
-// Releases an exlusively or shared acquired NCB by key
-//
-#define CmpReleaseNcbLockByKey(k)                                   \
-{                                                                   \
-    ExReleasePushLock(&GET_HASH_ENTRY(CmpNameCacheTable,            \
-                                      (k)).Lock);                   \
-}
--- a/reactos/ntoskrnl/cm/cmapi.c
+++ b/reactos/ntoskrnl/cm/cmapi.c
@@ -1,57 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/cmapi.c
- * PURPOSE:         Internal routines that implement Nt* API functionality
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-#include "cm.h"
-
-/* GLOBALS *******************************************************************/
-
-BOOLEAN CmpNoWrite;
-BOOLEAN CmpForceForceFlush;
-
-/* FUNCTIONS *****************************************************************/
-
-BOOLEAN
-NTAPI
-CmpFlushEntireRegistry(IN BOOLEAN ForceFlush)
-{
-    BOOLEAN Flushed = TRUE;
-
-    /* Make sure that the registry isn't read-only now */
-    if (CmpNoWrite) return TRUE;
-
-    /* Otherwise, acquire the hive list lock and disable force flush */
-    CmpForceForceFlush = FALSE;
-    ExAcquirePushLockShared(&CmpHiveListHeadLock);
-
-    /* Check if the hive list isn't empty */
-    if (!IsListEmpty(&CmpHiveListHead))
-    {
-        /* FIXME: TODO */
-        ASSERT(FALSE);
-    }
-
-    /* Release the lock and return the flush state */
-    ExReleasePushLock(&CmpHiveListHeadLock);
-    return Flushed;
-}
-
-VOID
-NTAPI
-CmpReportNotify(IN PCM_KEY_CONTROL_BLOCK Kcb,
-                IN PHHIVE Hive,
-                IN HCELL_INDEX Cell,
-                IN ULONG Filter)
-{
-    /* FIXME: TODO */
-    ASSERT(FALSE);
-}
--- a/reactos/ntoskrnl/cm/cmboot.c
+++ b/reactos/ntoskrnl/cm/cmboot.c
@@ -1,127 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmboot.c
- * PURPOSE:         Configuration Manager - Boot Initialization
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-HCELL_INDEX
-NTAPI
-CmpFindControlSet(IN PHHIVE SystemHive,
-                  IN HCELL_INDEX RootCell,
-                  IN PUNICODE_STRING SelectKeyName,
-                  OUT PBOOLEAN AutoSelect)
-{
-    UNICODE_STRING KeyName;
-    PCM_KEY_NODE Node;
-    HCELL_INDEX SelectCell, AutoSelectCell, SelectValueCell, ControlSetCell;
-    HCELL_INDEX CurrentValueCell;
-    PCM_KEY_VALUE KeyValue;
-    ULONG Length;
-    PULONG ControlSetId;
-    ANSI_STRING ControlSetAnsiName;
-    CHAR Buffer[128];
-    WCHAR WideBuffer[128];
-    NTSTATUS Status;
-    PULONG CurrentData;
-
-    /* Sanity check */
-    ASSERT(SystemHive->ReleaseCellRoutine == NULL);
-
-    /* Get the Select subkey */
-    RtlInitUnicodeString(&KeyName, L"select");
-    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, RootCell);
-    if (!Node) return HCELL_NIL;
-    SelectCell = CmpFindSubKeyByName(SystemHive, Node, &KeyName);
-    if (SelectCell == HCELL_NIL) return SelectCell;
-
-    /* Get AutoSelect value */
-    RtlInitUnicodeString(&KeyName, L"AutoSelect");
-    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
-    if (!Node) return HCELL_NIL;
-    AutoSelectCell = CmpFindValueByName(SystemHive, Node, &KeyName);
-    if (AutoSelectCell == HCELL_NIL)
-    {
-        /* Assume TRUE if the value is missing. */
-        *AutoSelect = TRUE;
-    }
-    else
-    {
-        /* Read the value */
-        KeyValue = (PCM_KEY_VALUE)HvGetCell(SystemHive, AutoSelectCell);
-        if (KeyValue == NULL) return HCELL_NIL;
-
-        /* Convert it to a boolean */
-        *AutoSelect = *(PBOOLEAN)CmpValueToData(SystemHive, KeyValue, &Length);
-    }
-
-    /* Now find the control set being looked up */
-    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
-    if (!Node) return HCELL_NIL;
-    SelectValueCell = CmpFindValueByName(SystemHive, Node, SelectKeyName);
-    if (SelectValueCell == HCELL_NIL) return SelectValueCell;
-
-    /* Read the value (corresponding to the CCS ID) */
-    KeyValue = (PCM_KEY_VALUE)HvGetCell(SystemHive, SelectValueCell);
-    if (!KeyValue) return HCELL_NIL;
-    if (KeyValue->Type != REG_DWORD) return HCELL_NIL;
-    ControlSetId = (PULONG)CmpValueToData(SystemHive, KeyValue, &Length);
-
-    /* Now build an Ansi String for the CCS's Name */
-    sprintf(Buffer, "ControlSet%03lu", *ControlSetId);
-    ControlSetAnsiName.Length = (USHORT)strlen(Buffer);
-    ControlSetAnsiName.MaximumLength = (USHORT)strlen(Buffer);
-    ControlSetAnsiName.Buffer = Buffer;
-
-    /* And convert it to Unicode... */
-    KeyName.MaximumLength = 256;
-    KeyName.Buffer = WideBuffer;
-    Status = RtlAnsiStringToUnicodeString(&KeyName,
-                                          &ControlSetAnsiName,
-                                          FALSE);
-    if (!NT_SUCCESS(Status)) return HCELL_NIL;
-
-    /* Now open it */
-    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, RootCell);
-    if (!Node) return HCELL_NIL;
-    ControlSetCell = CmpFindSubKeyByName(SystemHive, Node, &KeyName);
-    if (ControlSetCell == HCELL_NIL) return ControlSetCell;
-
-    /* Get the value of the "Current" CCS */
-    RtlInitUnicodeString(&KeyName, L"Current");
-    Node =  (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
-    if (!Node) return HCELL_NIL;
-    CurrentValueCell = CmpFindValueByName(SystemHive, Node, &KeyName);
-
-    /* Make sure it exists */
-    if (CurrentValueCell != HCELL_NIL)
-    {
-        /* Get the current value and make sure its a ULONG */
-        KeyValue = (PCM_KEY_VALUE)HvGetCell(SystemHive, CurrentValueCell);
-        if (!KeyValue) return HCELL_NIL;
-        if (KeyValue->Type == REG_DWORD)
-        {
-            /* Get the data and update it */
-            CurrentData = (PULONG)CmpValueToData(SystemHive,
-                                                 KeyValue,
-                                                 &Length);
-            if (!CurrentData) return HCELL_NIL;
-            *CurrentData = *ControlSetId;
-        }
-    }
-
-    /* Return the CCS Cell */
-    return ControlSetCell;
-}
--- a/reactos/ntoskrnl/cm/cmcheck.c
+++ b/reactos/ntoskrnl/cm/cmcheck.c
@@ -1,27 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmcheck.c
- * PURPOSE:         Configuration Manager - Hive and Key Validation
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-ULONG
-NTAPI
-CmCheckRegistry(IN PCMHIVE RegistryHive,
-                IN ULONG Flags)
-{
-    /* FIXME: HACK! */
-    return 0;
-}
--- a/reactos/ntoskrnl/cm/cmconfig.c
+++ b/reactos/ntoskrnl/cm/cmconfig.c
@@ -1,274 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmconfig.c
- * PURPOSE:         Configuration Manager - System Configuration Routines
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS
-NTAPI
-CmpInitializeRegistryNode(IN PCONFIGURATION_COMPONENT_DATA CurrentEntry,
-                          IN HANDLE NodeHandle,
-                          OUT PHANDLE NewHandle,
-                          IN INTERFACE_TYPE InterfaceType,
-                          IN ULONG BusNumber,
-                          IN PUSHORT DeviceIndexTable)
-{
-    NTSTATUS Status;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName, ValueName, ValueData;
-    HANDLE KeyHandle, ParentHandle;
-    ANSI_STRING TempString;
-    CHAR TempBuffer[12];
-    WCHAR Buffer[12];
-    PCONFIGURATION_COMPONENT Component;
-    ULONG Disposition, Length = 0;
-
-    /* Get the component */
-    Component = &CurrentEntry->ComponentEntry;
-
-    /* Set system class components to ARC system type */
-    if (Component->Class == SystemClass) Component->Type = ArcSystem;
-
-    /* Create a key for the component */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &CmTypeName[Component->Type],
-                               OBJ_CASE_INSENSITIVE,
-                               NodeHandle,
-                               NULL);
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_READ | KEY_WRITE,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         0,
-                         &Disposition);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Check if this is anything but a system class component */
-    if (Component->Class != SystemClass)
-    {
-        /* Build the sub-component string */
-        RtlIntegerToChar(DeviceIndexTable[Component->Type]++,
-                         10,
-                         12,
-                         TempBuffer);
-        RtlInitAnsiString(&TempString, TempBuffer);
-
-        /* Convert it to Unicode */
-        RtlInitEmptyUnicodeString(&KeyName, Buffer, sizeof(Buffer));
-        RtlAnsiStringToUnicodeString(&KeyName, &TempString, FALSE);
-
-        /* Create the key */
-        ParentHandle = KeyHandle;
-        InitializeObjectAttributes(&ObjectAttributes,
-                                   &KeyName,
-                                   OBJ_CASE_INSENSITIVE,
-                                   ParentHandle,
-                                   NULL);
-        Status = NtCreateKey(&KeyHandle,
-                             KEY_READ | KEY_WRITE,
-                             &ObjectAttributes,
-                             0,
-                             NULL,
-                             0,
-                             &Disposition);
-        NtClose(ParentHandle);
-
-        /* Fail if the key couldn't be created, and make sure it's a new key */
-        if (!NT_SUCCESS(Status)) return Status;
-        ASSERT(Disposition == REG_CREATED_NEW_KEY);
-    }
-
-    /* Sstup the compnent information key */
-    RtlInitUnicodeString(&ValueName, L"Component Information");
-    Status = NtSetValueKey(KeyHandle,
-                           &ValueName,
-                           0,
-                           REG_BINARY,
-                           &Component->Flags,
-                           FIELD_OFFSET(CONFIGURATION_COMPONENT,
-                                        ConfigurationDataLength) -
-                           FIELD_OFFSET(CONFIGURATION_COMPONENT, Flags));
-    if (!NT_SUCCESS(Status))
-    {
-        /* Fail */
-        NtClose(KeyHandle);
-        return Status;
-    }
-
-    /* Check if we have an identifier */
-    if (Component->IdentifierLength)
-    {
-        /* Build the string and convert it to Unicode */
-        RtlInitUnicodeString(&ValueName, L"Identifier");
-        RtlInitAnsiString(&TempString, Component->Identifier);
-        Status = RtlAnsiStringToUnicodeString(&ValueData,
-                                              &TempString,
-                                              TRUE);
-        if (NT_SUCCESS(Status))
-        {
-            /* Save the identifier in the registry */
-            Status = NtSetValueKey(KeyHandle,
-                                   &ValueName,
-                                   0,
-                                   REG_SZ,
-                                   ValueData.Buffer,
-                                   ValueData.Length + sizeof(UNICODE_NULL));
-            RtlFreeUnicodeString(&ValueData);
-        }
-
-        /* Check for failure during conversion or registry write */
-        if (!NT_SUCCESS(Status))
-        {
-            /* Fail */
-            NtClose(KeyHandle);
-            return Status;
-        }
-    }
-
-    /* Setup the configuration data string */
-    RtlInitUnicodeString(&ValueName, L"Configuration Data");
-
-    /* Check if we got configuration data */
-    if (CurrentEntry->ConfigurationData)
-    {
-        /* Calculate the total length and check if it fits into our buffer */
-        Length = Component->ConfigurationDataLength +
-                 FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList);
-        if (Length > CmpConfigurationAreaSize)
-        {
-            ASSERTMSG("Component too large -- need reallocation!", FALSE);
-        }
-        else
-        {
-            /* Copy the data */
-            RtlCopyMemory(&CmpConfigurationData->PartialResourceList.Version,
-                          CurrentEntry->ConfigurationData,
-                          Component->ConfigurationDataLength);
-        }
-    }
-    else
-    {
-        /* No configuration data, setup defaults */
-        CmpConfigurationData->PartialResourceList.Version = 0;
-        CmpConfigurationData->PartialResourceList.Revision = 0;
-        CmpConfigurationData->PartialResourceList.Count = 0;
-        Length = FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST, PartialDescriptors) +
-                 FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList);
-    }
-
-    /* Set the interface type and bus number */
-    CmpConfigurationData->InterfaceType = InterfaceType;
-    CmpConfigurationData->BusNumber = BusNumber;
-
-    /* Save the actual data */
-    Status = NtSetValueKey(KeyHandle,
-                           &ValueName,
-                           0,
-                           REG_FULL_RESOURCE_DESCRIPTOR,
-                           CmpConfigurationData,
-                           Length);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Fail */
-        NtClose(KeyHandle);
-    }
-    else
-    {
-        /* Return the new handle */
-        *NewHandle = KeyHandle;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-CmpInitializeHardwareConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
-{
-    NTSTATUS Status;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    HANDLE KeyHandle;
-    ULONG Disposition;
-    UNICODE_STRING KeyName;
-
-    /* Setup the key name */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\Hardware\\DeviceMap");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-
-    /* Create the device map key */
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_READ | KEY_WRITE,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         0,
-                         &Disposition);
-    if (!NT_SUCCESS(Status)) return Status;
-    NtClose(KeyHandle);
-
-    /* Nobody should've created this key yet! */
-    //ASSERT(Disposition == REG_CREATED_NEW_KEY);
-
-    /* Setup the key name */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\Hardware\\Description");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-
-    /* Create the description key */
-    Status = NtCreateKey(&KeyHandle,
-                          KEY_READ | KEY_WRITE,
-                          &ObjectAttributes,
-                          0,
-                          NULL,
-                          0,
-                          &Disposition);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Nobody should've created this key yet! */
-    //ASSERT(Disposition == REG_CREATED_NEW_KEY);
-
-    /* Allocate the configuration data buffer */
-    CmpConfigurationData = ExAllocatePoolWithTag(PagedPool,
-                                                 CmpConfigurationAreaSize,
-                                                 TAG_CM);
-    if (!CmpConfigurationData) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Check if we got anything from NTLDR */
-    if (LoaderBlock->ConfigurationRoot)
-    {
-        ASSERTMSG("NTLDR ARC Hardware Tree Not Supported!\n", FALSE);
-    }
-    else
-    {
-        /* Nothing else to do */
-        Status = STATUS_SUCCESS;
-    }
-
-    /* Close our handle, free the buffer and return status */
-    ExFreePool(CmpConfigurationData);
-    NtClose(KeyHandle);
-    return Status;
-}
-
--- a/reactos/ntoskrnl/cm/cmcontrl.c
+++ b/reactos/ntoskrnl/cm/cmcontrl.c
@@ -1,265 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmcontrl.c
- * PURPOSE:         Configuration Manager - Control Set Management
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-LANGID
-NTAPI
-CmpConvertLangId(IN LPWSTR Name,
-                 IN ULONG NameLength)
-{
-    ULONG i;
-    WCHAR p;
-    LANGID LangId = 0;
-    ULONG IdCode;
-
-    /* Convert the length in chars and loop */
-    NameLength = NameLength / sizeof(WCHAR);
-    for (i = 0; i < NameLength; i++)
-    {
-        /* Get the character */
-        p = Name[i];
-
-        /* Handle each case */
-        if ((p >= L'0') && (p <= L'9'))
-        {
-            /* Handle digits*/
-            IdCode = p - L'0';
-        }
-        else if ((p >= L'A') && (p <= L'F'))
-        {
-            /* Handle upper-case letters */
-            IdCode = p - L'A' + 10;
-        }
-        else if ((p >= L'a') && (p <= L'f'))
-        {
-            /* Handle lower-case letters */
-            IdCode = p - L'a' + 10;
-        }
-        else
-        {
-            /* Unhandled case, return what we have till now */
-            break;
-        }
-
-        /* If the ID Code is >= 16, then we're done */
-        if (IdCode >= 16) break;
-
-        /* Build the Language ID */
-        LangId = (LangId << 4) | (LANGID)IdCode;
-    }
-
-    /* Return the Language ID */
-    return LangId;
-}
-
-HCELL_INDEX
-NTAPI
-CmpWalkPath(IN PHHIVE SystemHive,
-            IN HCELL_INDEX ParentCell,
-            IN LPWSTR Path)
-{
-    UNICODE_STRING UnicodePath, NextName;
-    BOOLEAN LastName;
-    HCELL_INDEX CurrentCell = ParentCell;
-    PCM_KEY_NODE Node;
-
-    /* We shouldn't have a release routine at this point */
-    ASSERT(SystemHive->ReleaseCellRoutine == NULL);
-
-    /* Initialize the Unicode path and start looping */
-    RtlInitUnicodeString(&UnicodePath, Path);
-    while (TRUE)
-    {
-        /* Get the next name */
-        CmpGetNextName(&UnicodePath, &NextName, &LastName);
-        if (!NextName.Length) return CurrentCell;
-
-        /* Get the subkey */
-        Node = (PCM_KEY_NODE)HvGetCell(SystemHive, CurrentCell);
-        if (!Node) return HCELL_NIL;
-        CurrentCell = CmpFindSubKeyByName(SystemHive, Node, &NextName);
-        if (CurrentCell == HCELL_NIL) return CurrentCell;
-    }
-}
-
-VOID
-NTAPI
-CmGetSystemControlValues(IN PVOID SystemHiveData,
-                         IN PCM_SYSTEM_CONTROL_VECTOR ControlVector)
-{
-    PHHIVE SystemHive = (PHHIVE)&CmControlHive;
-    NTSTATUS Status;
-    HCELL_INDEX RootCell, BaseCell, KeyCell, ValueCell;
-    ULONG Length, DataSize;
-    PCM_KEY_NODE Node;
-    PCM_KEY_VALUE ValueData;
-    UNICODE_STRING KeyName;
-    BOOLEAN Auto, IsSmallKey;
-    PVOID Buffer;
-
-    /* LUDDDIIIICRROOOUUSSSS KI^H^H HACKKKK */
-    if (!SystemHiveData) return;
-
-    /* Initialize the Hive View List and the security cache */
-    RtlZeroMemory(SystemHive, sizeof(SystemHive));
-    CmpInitHiveViewList((PCMHIVE)SystemHive);
-    CmpInitSecurityCache((PCMHIVE)SystemHive);
-
-    /* Initialize the Hive */
-    Status = HvInitialize(SystemHive,
-                          HINIT_FLAT,
-                          HIVE_VOLATILE,
-                          HFILE_TYPE_PRIMARY,
-                          SystemHiveData,
-                          NULL,
-                          NULL,
-                          NULL,
-                          NULL,
-                          NULL,
-                          NULL,
-                          1,
-                          NULL);
-    if (!NT_SUCCESS(Status)) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 1, 1, 0, 0);
-
-    /* Sanity check, flat hives don't have release routines */
-    ASSERT(SystemHive->ReleaseCellRoutine == NULL);
-
-    /* FIXME: Prepare it */
-    CmPrepareHive(SystemHive);
-
-    /* Set the Root Cell */
-    RootCell = ((PHBASE_BLOCK)SystemHiveData)->RootCell;
-
-    /* Find the current control set */
-    RtlInitUnicodeString(&KeyName, L"current");
-    BaseCell = CmpFindControlSet(SystemHive, RootCell, &KeyName, &Auto);
-    if (BaseCell == HCELL_NIL) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 1, 2, 0, 0);
-
-    /*  Find the control subkey */
-    RtlInitUnicodeString(&KeyName, L"control");
-    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, BaseCell);
-    BaseCell = CmpFindSubKeyByName(SystemHive, Node, &KeyName);
-    if (BaseCell == HCELL_NIL) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,1 , 3, 0, 0);
-
-    /* Loop each key */
-    while (ControlVector->KeyPath)
-    {
-        /*  Assume failure */
-        Length = -1;
-
-        /* Get the cell for this key */
-        KeyCell = CmpWalkPath(SystemHive, BaseCell, ControlVector->KeyPath);
-        if (KeyCell != HCELL_NIL)
-        {
-            /* Now get the cell for the value */
-            RtlInitUnicodeString(&KeyName, ControlVector->ValueName);
-            Node = (PCM_KEY_NODE)HvGetCell(SystemHive, KeyCell);
-            ValueCell = CmpFindValueByName(SystemHive, Node, &KeyName);
-            if (ValueCell != HCELL_NIL)
-            {
-                /* Check if there's any data */
-                if (!ControlVector->BufferLength)
-                {
-                    /* No, the buffer will only be large enough for a ULONG */
-                    DataSize = sizeof(ULONG);
-                }
-                else
-                {
-                    /* Yes, save the data size */
-                    DataSize = *ControlVector->BufferLength;
-                }
-
-                /* Get the actual data */
-                ValueData = (PCM_KEY_VALUE)HvGetCell(SystemHive, ValueCell);
-
-                /* Check if this is a small key */
-                IsSmallKey = CmpIsKeyValueSmall(&Length, ValueData->DataLength);
-
-                /* If the length is bigger then our buffer, normalize it */
-                if (DataSize < Length) Length = DataSize;
-
-                /* Make sure we have some data */
-                if (Length > 0)
-                {
-                    /* Check if this was a small key */
-                    if (IsSmallKey)
-                    {
-                        /* The buffer is directly safe to read */
-                        Buffer = (PVOID)(&(ValueData->Data));
-                    }
-                    else
-                    {
-                        /* Use the longer path */
-                        Buffer = (PVOID)HvGetCell(SystemHive, ValueData->Data);
-                    }
-
-                    /* Sanity check if this is a small key */
-                    ASSERT((IsSmallKey ?
-                           (Length <= CM_KEY_VALUE_SMALL) : TRUE));
-
-                    /* Copy the data in the buffer */
-                    RtlCopyMemory(ControlVector->Buffer, Buffer, Length);
-                }
-
-                /* Check if we should return the data type */
-                if (ControlVector->Type)
-                {
-                    /* Return the type that we read */
-                    *ControlVector->Type = ValueData->Type;
-                }
-            }
-        }
-
-        /* Return the size that we read */
-        if (ControlVector->BufferLength) *ControlVector->BufferLength = Length;
-
-        /* Go to the next entry */
-        ControlVector++;
-    }
-
-    /* Check if the ID is in the registry */
-    if (CmDefaultLanguageIdType == REG_SZ)
-    {
-        /* Read it */
-        PsDefaultSystemLocaleId =
-            (LCID)CmpConvertLangId(CmDefaultLanguageId,
-                                   CmDefaultLanguageIdLength);
-    }
-    else
-    {
-        /* Use EN_US by default */
-        PsDefaultSystemLocaleId = 0x409;
-    }
-
-    /* Check if the ID Is in the registry */
-    if (CmInstallUILanguageIdType == REG_SZ)
-    {
-        /* Read it */
-        PsInstallUILanguageId =  CmpConvertLangId(CmInstallUILanguageId,
-                                                  CmInstallUILanguageIdLength);
-    }
-    else
-    {
-        /* Otherwise, use the default */
-        PsInstallUILanguageId = LANGIDFROMLCID(PsDefaultSystemLocaleId);
-    }
-
-    /* Set the defaults for the Thread UI */
-    PsDefaultThreadLocaleId = PsDefaultSystemLocaleId;
-    PsDefaultUILanguageId = PsInstallUILanguageId;
-}
--- a/reactos/ntoskrnl/cm/cmdata.c
+++ b/reactos/ntoskrnl/cm/cmdata.c
@@ -1,807 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmdata.c
- * PURPOSE:         Configuration Manager - Global Configuration Data
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-ULONG DummyData;
-ULONG CmNtGlobalFlag;
-ULONG CmNtCSDVersion;
-
-WCHAR CmDefaultLanguageId[12];
-ULONG CmDefaultLanguageIdLength = sizeof(CmDefaultLanguageId);
-ULONG CmDefaultLanguageIdType;
-
-WCHAR CmInstallUILanguageId[12];
-ULONG CmInstallUILanguageIdLength = sizeof(CmInstallUILanguageId);
-ULONG CmInstallUILanguageIdType;
-
-WCHAR CmSuiteBuffer[128];
-ULONG CmSuiteBufferLength = sizeof(CmSuiteBuffer);
-ULONG CmSuiteBufferType;
-
-CMHIVE CmControlHive;
-
-ULONG CmpConfigurationAreaSize = PAGE_SIZE * 4;
-PCM_FULL_RESOURCE_DESCRIPTOR CmpConfigurationData;
-
-EX_PUSH_LOCK CmpHiveListHeadLock, CmpLoadHiveLock;
-
-HIVE_LIST_ENTRY CmpMachineHiveList[] =
-{
-    { 
-        L"HARDWARE", L"MACHINE\\", NULL, HIVE_VOLATILE, 0, NULL, FALSE, FALSE, FALSE
-    },
-    {
-        L"SECURITY", L"MACHINE\\", NULL, 0, 0, NULL, FALSE, FALSE, FALSE
-    },
-    { 
-        L"SOFTWARE", L"MACHINE\\", NULL, 0, 0, NULL, FALSE, FALSE, FALSE
-    },
-    {
-        L"SYSTEM", L"MACHINE\\", NULL, 0, 0, NULL, FALSE, FALSE, FALSE
-    },
-    {
-        L"DEFAULT", L"USER\\.DEFAULT", NULL, 0, 1, NULL, FALSE, FALSE, FALSE
-    },
-    {
-        L"SAM", L"MACHINE\\", NULL, HIVE_NOLAZYFLUSH, 0, NULL, FALSE, FALSE, FALSE
-    },
-    {
-        NULL, NULL, 0, 0, 0, NULL, FALSE, FALSE, FALSE
-    }
-};
-
-UNICODE_STRING CmSymbolicLinkValueName =
-    RTL_CONSTANT_STRING(L"SymbolicLinkValue");
-
-UNICODE_STRING CmpLoadOptions;
-
-BOOLEAN CmpShareSystemHives;
-BOOLEAN CmSelfHeal = TRUE;
-BOOLEAN CmpSelfHeal = TRUE;
-BOOLEAN CmpMiniNTBoot;
-ULONG CmpBootType;
-
-HANDLE CmpRegistryRootHandle;
-
-UNICODE_STRING CmTypeName[MaximumType + 1] =
-{
-    RTL_CONSTANT_STRING(L"System"),
-    RTL_CONSTANT_STRING(L"CentralProcessor"),
-    RTL_CONSTANT_STRING(L"FloatingPointProcessor"),
-    RTL_CONSTANT_STRING(L"PrimaryICache"),
-    RTL_CONSTANT_STRING(L"PrimaryDCache"),
-    RTL_CONSTANT_STRING(L"SecondaryICache"),
-    RTL_CONSTANT_STRING(L"SecondaryDCache"),
-    RTL_CONSTANT_STRING(L"SecondaryCache"),
-    RTL_CONSTANT_STRING(L"EisaAdapter"),
-    RTL_CONSTANT_STRING(L"TcAdapter"),
-    RTL_CONSTANT_STRING(L"ScsiAdapter"),
-    RTL_CONSTANT_STRING(L"DtiAdapter"),
-    RTL_CONSTANT_STRING(L"MultifunctionAdapter"),
-    RTL_CONSTANT_STRING(L"DiskController"),
-    RTL_CONSTANT_STRING(L"TapeController"),
-    RTL_CONSTANT_STRING(L"CdRomController"),
-    RTL_CONSTANT_STRING(L"WormController"),
-    RTL_CONSTANT_STRING(L"SerialController"),
-    RTL_CONSTANT_STRING(L"NetworkController"),
-    RTL_CONSTANT_STRING(L"DisplayController"),
-    RTL_CONSTANT_STRING(L"ParallelController"),
-    RTL_CONSTANT_STRING(L"PointerController"),
-    RTL_CONSTANT_STRING(L"KeyboardController"),
-    RTL_CONSTANT_STRING(L"AudioController"),
-    RTL_CONSTANT_STRING(L"OtherController"),
-    RTL_CONSTANT_STRING(L"DiskPeripheral"),
-    RTL_CONSTANT_STRING(L"FloppyDiskPeripheral"),
-    RTL_CONSTANT_STRING(L"TapePeripheral"),
-    RTL_CONSTANT_STRING(L"ModemPeripheral"),
-    RTL_CONSTANT_STRING(L"MonitorPeripheral"),
-    RTL_CONSTANT_STRING(L"PrinterPeripheral"),
-    RTL_CONSTANT_STRING(L"PointerPeripheral"),
-    RTL_CONSTANT_STRING(L"KeyboardPeripheral"),
-    RTL_CONSTANT_STRING(L"TerminalPeripheral"),
-    RTL_CONSTANT_STRING(L"OtherPeripheral"),
-    RTL_CONSTANT_STRING(L"LinePeripheral"),
-    RTL_CONSTANT_STRING(L"NetworkPeripheral"),
-    RTL_CONSTANT_STRING(L"SystemMemory"),
-    RTL_CONSTANT_STRING(L"DockingInformation"),
-    RTL_CONSTANT_STRING(L"RealModeIrqRoutingTable"),
-    RTL_CONSTANT_STRING(L"RealModePCIEnumeration"),
-    RTL_CONSTANT_STRING(L"Undefined")
-};
-
-CM_SYSTEM_CONTROL_VECTOR CmControlVector[] =
-{
-    {
-        L"Session Manager",
-        L"ProtectionMode",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"ObjectSecurityMode",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"LUIDDeviceMapsDisabled",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"LSA",
-        L"AuditBaseDirectories",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"LSA",
-        L"AuditBaseObjects",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"LSA\\audit",
-        L"ProcessAccessesToAudit",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"TimeZoneInformation",
-        L"ActiveTimeBias",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"TimeZoneInformation",
-        L"Bias",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"TimeZoneInformation",
-        L"RealTimeIsUniversal",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"GlobalFlag",
-        &CmNtGlobalFlag,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PagedPoolQuota",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"NonPagedPoolQuota",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PagingFileQuota",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"AllocationPreference",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"DynamicMemory",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"Mirroring",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"Mirroring",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SystemViewSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SessionViewSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SessionImageSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SessionPoolSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PoolUsageMaximum",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"MapAllocationFragment",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PagedPoolSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"NonPagedPoolSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"NonPagedPoolMaximumPercent",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"LargeSystemCache",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"LargeStackSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SystemPages",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"LowMemoryThreshold",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"HighMemoryThreshold",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"DisablePagingExecutive",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"ModifiedPageLife",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SecondLevelDataCache",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"ClearPageFileAtShutdown",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PoolTagSmallTableSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PoolTagBigTableSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PoolTag",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"PoolTagOverruns",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"SnapUnloads",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"ProtectNonPagedPool",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"TrackLockedPages",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"TrackPtes",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"VerifyDrivers",
-        &DummyData,
-        &DummyData,
-        &DummyData
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"VerifyDriverLevel",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"VerifyMode",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"LargePageMinimum",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"EnforceWriteProtection",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"MakeLowMemory",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Memory Management",
-        L"WriteWatch",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Executive",
-        L"AdditionalCriticalWorkerThreads",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Executive",
-        L"AdditionalDelayedWorkerThreads",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Executive",
-        L"PriorityQuantumMatrix",
-        &DummyData,
-        &DummyData,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Kernel",
-        L"DpcQueueDepth",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Kernel",
-        L"MinimumDpcRate",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Kernel",
-        L"AdjustDpcThreshold",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Kernel",
-        L"IdealDpcRate",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\I/O System",
-        L"CountOperations",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\I/O System",
-        L"LargeIrpStackLocations",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\I/O System",
-        L"IoVerifierLevel",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"ResourceTimeoutCount",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"CriticalSectionTimeout",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"HeapSegmentReserve",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"HeapSegmentCommit",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"HeapDeCommitTotalFreeThreshold",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"HeapDeCommitFreeBlockThreshold",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"ProductOptions",
-        L"ProductType",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Terminal Server",
-        L"TSEnabled",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Terminal Server",
-        L"TSAppCompat",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-
-    {
-        L"ProductOptions",
-        L"ProductSuite",
-        CmSuiteBuffer,
-        &CmSuiteBufferLength,
-        &CmSuiteBufferType
-    },
-
-    {
-        L"Windows",
-        L"CSDVersion",
-        &CmNtCSDVersion,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Nls\\Language",
-        L"Default",
-        CmDefaultLanguageId,
-        &CmDefaultLanguageIdLength,
-        &CmDefaultLanguageIdType
-    },
-
-    {
-        L"Nls\\Language",
-        L"InstallLanguage",
-        CmInstallUILanguageId,
-        &CmInstallUILanguageIdLength,
-        &CmInstallUILanguageIdType
-    },
-
-    {
-        L"\0\0",
-        L"RegistrySizeLimit",
-        &DummyData,
-        &DummyData,
-        &DummyData
-    },
-
-    {
-        L"Session Manager",
-        L"ForceNpxEmulation",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"PowerPolicySimulate",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager\\Executive",
-        L"MaxTimeSeparationBeforeCorrect",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Windows",
-        L"ShutdownTime",
-        &DummyData,
-        &DummyData,
-        NULL
-    },
-
-    {
-        L"PriorityControl",
-        L"Win32PrioritySeparation",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"EnableTimerWatchdog",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"Session Manager",
-        L"Debugger Retries",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"WMI",
-        L"MaxEventSize",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"WMI\\Trace",
-        L"UsePerformanceClock",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        L"WMI\\Trace",
-        L"TraceAlignment",
-        &DummyData,
-        NULL,
-        NULL
-    },
-
-    {
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
--- a/reactos/ntoskrnl/cm/cmhive.c
+++ b/reactos/ntoskrnl/cm/cmhive.c
@@ -1,317 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/cmhive.c
- * PURPOSE:         Routines for managing Registry Hives in general
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-#include "cm.h"
-
-/* GLOBALS *******************************************************************/
-
-EX_PUSH_LOCK CmpHiveListHeadLock;
-LIST_ENTRY CmpHiveListHead;
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CmpInitHiveViewList(IN PCMHIVE Hive)
-{
-    PAGED_CODE();
-
-    /* Initialize the lists */
-    InitializeListHead(&Hive->PinViewListHead);
-    InitializeListHead(&Hive->LRUViewListHead);
-
-    /* Setup defaults */
-    Hive->MappedViews = 0;
-    Hive->PinnedViews = 0;
-    Hive->UseCount = 0;
-}
-
-NTSTATUS
-NTAPI
-CmpInitializeHive(OUT PCMHIVE *CmHive,
-                  IN ULONG Operation,
-                  IN ULONG Flags,
-                  IN ULONG FileType,
-                  IN PVOID HiveData OPTIONAL,
-                  IN HANDLE Primary,
-                  IN HANDLE Log,
-                  IN HANDLE External,
-                  IN PCUNICODE_STRING FileName,
-                  IN ULONG CheckFlags)
-{
-    PCMHIVE Hive;
-    IO_STATUS_BLOCK IoStatusBlock;
-    FILE_FS_SIZE_INFORMATION FileSizeInformation;
-    NTSTATUS Status;
-    ULONG Cluster;
-    FILE_STANDARD_INFORMATION FileInformation;
-
-    /*
-     * The following are invalid:
-     * An external hive that is also internal.
-     * A log hive that's not a primary hive too.
-     * A volatile hive that's linked to permanent storage.
-     * An in-memory initialization without hive data.
-     * A log hive that's not linked to a correct file type.
-     */
-    if (((External) && ((Primary) || (Log))) ||
-        ((Log) && !(Primary)) ||
-        ((Flags & HIVE_VOLATILE) && ((Primary) || (External) || (Log))) ||
-        ((Operation == HINIT_MEMORY) && (!HiveData)) ||
-        ((Log) && (FileType != HFILE_TYPE_LOG)))
-    {
-        /* Fail the request */
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Check if this is a primary hive */
-    if (Primary)
-    {
-        /* Get the cluster size */
-        Status = ZwQueryVolumeInformationFile(Primary,
-                                              &IoStatusBlock,
-                                              &FileSizeInformation,
-                                              sizeof(FILE_FS_SIZE_INFORMATION),
-                                              FileFsSizeInformation);
-        if (!NT_SUCCESS(Status)) return Status;
-
-        /* Make sure it's not larger then the block size */
-        if (FileSizeInformation.BytesPerSector > HBLOCK_SIZE)
-        {
-            /* Fail */
-            return STATUS_REGISTRY_IO_FAILED;
-        }
-
-        /* Otherwise, calculate the cluster */
-        Cluster = FileSizeInformation.BytesPerSector / HSECTOR_SIZE;
-        Cluster = max(1, Cluster);
-    }
-    else
-    {
-        /* Otherwise use cluster 1 */
-        Cluster = 1;
-    }
-
-    /* Allocate a hive */
-    Hive = ExAllocatePoolWithTag(PagedPool,
-                                 sizeof(CMHIVE),
-                                 TAG_CM);
-    if (!Hive) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Setup null fields */
-    Hive->UnloadEvent = NULL;
-    Hive->RootKcb = NULL;
-    Hive->Frozen = FALSE;
-    Hive->UnloadWorkItem = NULL;
-    Hive->GrowOnlyMode = FALSE;
-    Hive->GrowOffset = 0;
-    Hive->CellRemapArray = NULL;
-    Hive->UseCountLog.Next = 0;
-    Hive->LockHiveLog.Next = 0;
-    Hive->FileObject = NULL;
-    Hive->NotifyList.Flink = NULL;
-    Hive->NotifyList.Blink = NULL;
-
-    /* Set loading flag */
-    Hive->HiveIsLoading = TRUE;
-
-    /* Set the current thread as creator */
-    Hive->CreatorOwner = KeGetCurrentThread();
-
-    /* Initialize lists */
-    InitializeListHead(&Hive->KcbConvertListHead);
-    InitializeListHead(&Hive->KnodeConvertListHead);
-    InitializeListHead(&Hive->TrustClassEntry);
-
-    /* Allocate the view log */
-    Hive->ViewLock = ExAllocatePoolWithTag(NonPagedPool,
-                                           sizeof(KGUARDED_MUTEX),
-                                           TAG_CM);
-    if (!Hive->ViewLock) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Allocate the flush lock */
-    Hive->FlusherLock = ExAllocatePoolWithTag(NonPagedPool,
-                                              sizeof(ERESOURCE),
-                                              TAG_CM);
-    if (!Hive->FlusherLock) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Setup the handles */
-    Hive->FileHandles[HFILE_TYPE_PRIMARY] = Primary;
-    Hive->FileHandles[HFILE_TYPE_LOG] = Log;
-    Hive->FileHandles[HFILE_TYPE_EXTERNAL] = External;
-
-    /* Initailize the guarded mutex */
-    KeInitializeGuardedMutex(Hive->ViewLock);
-    Hive->ViewLockOwner = NULL;
-
-    /* Initialize the flush lock */
-    ExInitializeResourceLite(Hive->FlusherLock);
-
-    /* Setup hive locks */
-    ExInitializePushLock((PULONG_PTR)&Hive->HiveLock);
-    Hive->HiveLockOwner = NULL;
-    ExInitializePushLock((PULONG_PTR)&Hive->WriterLock);
-    Hive->WriterLockOwner = NULL;
-    ExInitializePushLock((PULONG_PTR)&Hive->SecurityLock);
-    Hive->HiveSecurityLockOwner = NULL;
-
-    /* Clear file names */
-    RtlInitEmptyUnicodeString(&Hive->FileUserName, NULL, 0);
-    RtlInitEmptyUnicodeString(&Hive->FileFullPath, NULL, 0);
-
-    /* Initialize the view list */
-    CmpInitHiveViewList(Hive);
-
-    /* Initailize the security cache */
-    CmpInitSecurityCache(Hive);
-
-    /* Setup flags */
-    Hive->Flags = 0;
-    Hive->FlushCount = 0;
-    
-    /* REACTOS: Check how large the file is */
-    ZwQueryInformationFile(Primary,
-                           &IoStatusBlock,
-                           &FileInformation,
-                           sizeof(FileInformation),
-                           FileStandardInformation);
-    Cluster = FileInformation.EndOfFile.LowPart;
-
-    /* Initialize the hive */
-    Status = HvInitialize(&Hive->Hive,
-                          Operation,
-                          FileType,
-                          Flags,
-                          HiveData,
-                          CmpAllocate,
-                          CmpFree,
-                          CmpFileSetSize,
-                          CmpFileWrite,
-                          CmpFileRead,
-                          CmpFileFlush,
-                          Cluster,
-                          (PUNICODE_STRING)FileName);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Free all allocations */
-        ExFreePool(Hive->ViewLock);
-        ExFreePool(Hive->FlusherLock);
-        ExFreePool(Hive);
-        return Status;
-    }
-
-    /* Check if we should verify the registry */
-    if ((Operation == HINIT_FILE) ||
-        (Operation == HINIT_MEMORY) ||
-        (Operation == HINIT_MEMORY_INPLACE) ||
-        (Operation == HINIT_MAPFILE))
-    {
-        /* Verify integrity */
-        if (CmCheckRegistry(Hive, TRUE))
-        {
-            /* Free all alocations */
-            ExFreePool(Hive->ViewLock);
-            ExFreePool(Hive->FlusherLock);
-            ExFreePool(Hive);
-            return STATUS_REGISTRY_CORRUPT;
-        }
-    }
-
-    /* Lock the hive list */
-    ExAcquirePushLockExclusive(&CmpHiveListHeadLock);
-
-    /* Insert this hive */
-    InsertHeadList(&CmpHiveListHead, &Hive->HiveList);
-
-    /* Release the lock */
-    ExReleasePushLock(&CmpHiveListHeadLock);
-
-    /* Return the hive and success */
-    *CmHive = Hive;
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-CmpLinkHiveToMaster(IN PUNICODE_STRING LinkName,
-                    IN HANDLE RootDirectory,
-                    IN PCMHIVE CmHive,
-                    IN BOOLEAN Allocate,
-                    IN PSECURITY_DESCRIPTOR SecurityDescriptor)
-{
-    CM_PARSE_CONTEXT ParseContext;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-    PCM_KEY_BODY KeyBody;
-    PAGED_CODE();
-
-    /* Fill out the parse context */
-    ParseContext.TitleIndex = 0;
-    ParseContext.Class.Length = 0;
-    ParseContext.Class.MaximumLength = 0;
-    ParseContext.Class.Buffer = NULL;
-    ParseContext.CreateOptions = 0;
-    ParseContext.CreateLink = TRUE;
-    ParseContext.Flag2 = TRUE;
-    ParseContext.PostActions = 0;
-    ParseContext.ChildHive.KeyHive = &CmHive->Hive;
-
-    /* Check if we're allocating */
-    if (Allocate)
-    {
-        /* Set no child */
-        ParseContext.ChildHive.KeyCell = HCELL_NIL;
-    }
-    else
-    {
-        /* Otherwise, set the root cell */
-        ParseContext.ChildHive.KeyCell = CmHive->Hive.BaseBlock->RootCell;
-    }
-
-    /* Open the key */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               LinkName,
-                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                               RootDirectory,
-                               SecurityDescriptor);
-    Status = ObOpenObjectByName(&ObjectAttributes,
-                                CmpKeyObjectType,
-                                KernelMode,
-                                NULL,
-                                KEY_READ | KEY_WRITE,
-                                &ParseContext,
-                                &KeyHandle);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Reference the key body */
-    Status = ObReferenceObjectByHandle(KeyHandle,
-                                       0,
-                                       CmpKeyObjectType,
-                                       KernelMode,
-                                       (PVOID*)&KeyBody,
-                                       NULL);
-    ASSERT(NT_SUCCESS(Status));
-
-    /* Send a notification */
-#define REG_NOTIFY_CHANGE_NAME 1 /* DDK! */
-    CmpReportNotify(KeyBody->KeyControlBlock,
-                    KeyBody->KeyControlBlock->KeyHive,
-                    KeyBody->KeyControlBlock->KeyCell,
-                    REG_NOTIFY_CHANGE_NAME);
-
-    /* Dereference the key and close the handle */
-    ObDereferenceObject((PVOID)KeyBody);
-    ZwClose(KeyHandle);
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/cm/cmhook.c
+++ b/reactos/ntoskrnl/cm/cmhook.c
@@ -1,198 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmhook.c
- * PURPOSE:         Configuration Manager - Registry Notifications/Callbacks
- * PROGRAMMERS:     Thomas Weidenmueller (w3seek@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-ULONG CmpCallBackCount = 0;
-EX_CALLBACK CmpCallBackVector[100];
-
-LIST_ENTRY CmiCallbackHead;
-FAST_MUTEX CmiCallbackLock;
-
-typedef struct _REGISTRY_CALLBACK
-{
-    LIST_ENTRY ListEntry;
-    EX_RUNDOWN_REF RundownRef;
-    PEX_CALLBACK_FUNCTION Function;
-    PVOID Context;
-    LARGE_INTEGER Cookie;
-    BOOLEAN PendingDelete;
-} REGISTRY_CALLBACK, *PREGISTRY_CALLBACK;
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-VOID
-NTAPI
-CmpInitCallback(VOID)
-{
-    ULONG i;
-    PAGED_CODE();
-
-    /* Reset counter */
-    CmpCallBackCount = 0;
-
-    /* Loop all the callbacks */
-    for (i = 0; i < CMP_MAX_CALLBACKS; i++)
-    {
-        /* Initialize this one */
-        ExInitializeCallBack(&CmpCallBackVector[i]);
-    }
-
-    /* ROS: Initialize old-style callbacks for now */
-    InitializeListHead(&CmiCallbackHead);
-    ExInitializeFastMutex(&CmiCallbackLock);
-}
-
-NTSTATUS
-CmiCallRegisteredCallbacks(IN REG_NOTIFY_CLASS Argument1,
-                           IN PVOID Argument2)
-{
-    PLIST_ENTRY CurrentEntry;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PREGISTRY_CALLBACK CurrentCallback;
-    PAGED_CODE();
-
-    ExAcquireFastMutex(&CmiCallbackLock);
-
-    for (CurrentEntry = CmiCallbackHead.Flink;
-         CurrentEntry != &CmiCallbackHead;
-         CurrentEntry = CurrentEntry->Flink)
-    {
-        CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry);
-        if (!CurrentCallback->PendingDelete &&
-            ExAcquireRundownProtection(&CurrentCallback->RundownRef))
-        {
-            /* don't hold locks during the callbacks! */
-            ExReleaseFastMutex(&CmiCallbackLock);
-
-            Status = CurrentCallback->Function(CurrentCallback->Context,
-                                         (PVOID)Argument1,
-                                         Argument2);
-
-            ExAcquireFastMutex(&CmiCallbackLock);
-
-            /* don't release the rundown protection before holding the callback lock
-            so the pointer to the next callback isn't cleared in case this callback
-            get's deleted */
-            ExReleaseRundownProtection(&CurrentCallback->RundownRef);
-            if(!NT_SUCCESS(Status))
-            {
-                /* one callback returned failure, don't call any more callbacks */
-                break;
-            }
-        }
-    }
-
-    ExReleaseFastMutex(&CmiCallbackLock);
-
-    return Status;
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-CmRegisterCallback(IN PEX_CALLBACK_FUNCTION Function,
-                   IN PVOID Context,
-                   IN OUT PLARGE_INTEGER Cookie)
-{
-    PREGISTRY_CALLBACK Callback;
-    PAGED_CODE();
-    ASSERT(Function && Cookie);
-
-    Callback = ExAllocatePoolWithTag(PagedPool,
-                                   sizeof(REGISTRY_CALLBACK),
-                                   TAG('C', 'M', 'c', 'b'));
-    if (Callback != NULL)
-    {
-        /* initialize the callback */
-        ExInitializeRundownProtection(&Callback->RundownRef);
-        Callback->Function = Function;
-        Callback->Context = Context;
-        Callback->PendingDelete = FALSE;
-
-        /* add it to the callback list and receive a cookie for the callback */
-        ExAcquireFastMutex(&CmiCallbackLock);
-
-        /* FIXME - to receive a unique cookie we'll just return the pointer to the
-           callback object */
-        Callback->Cookie.QuadPart = (ULONG_PTR)Callback;
-        InsertTailList(&CmiCallbackHead, &Callback->ListEntry);
-
-        ExReleaseFastMutex(&CmiCallbackLock);
-
-        *Cookie = Callback->Cookie;
-        return STATUS_SUCCESS;
-    }
-
-    return STATUS_INSUFFICIENT_RESOURCES;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-CmUnRegisterCallback(IN LARGE_INTEGER Cookie)
-{
-    PLIST_ENTRY CurrentEntry;
-    PREGISTRY_CALLBACK CurrentCallback;
-    PAGED_CODE();
-
-    ExAcquireFastMutex(&CmiCallbackLock);
-
-    for (CurrentEntry = CmiCallbackHead.Flink;
-         CurrentEntry != &CmiCallbackHead;
-         CurrentEntry = CurrentEntry->Flink)
-    {
-        CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry);
-        if (CurrentCallback->Cookie.QuadPart == Cookie.QuadPart)
-        {
-            if (!CurrentCallback->PendingDelete)
-            {
-                /* found the callback, don't unlink it from the list yet so we don't screw
-                the calling loop */
-                CurrentCallback->PendingDelete = TRUE;
-                ExReleaseFastMutex(&CmiCallbackLock);
-
-                /* if the callback is currently executing, wait until it finished */
-                ExWaitForRundownProtectionRelease(&CurrentCallback->RundownRef);
-
-                /* time to unlink it. It's now safe because every attempt to acquire a
-                runtime protection on this callback will fail */
-                ExAcquireFastMutex(&CmiCallbackLock);
-                RemoveEntryList(&CurrentCallback->ListEntry);
-                ExReleaseFastMutex(&CmiCallbackLock);
-
-                /* free the callback */
-                ExFreePool(CurrentCallback);
-                return STATUS_SUCCESS;
-            }
-            else
-            {
-                /* pending delete, pretend like it already is deleted */
-                ExReleaseFastMutex(&CmiCallbackLock);
-                return STATUS_UNSUCCESSFUL;
-            }
-        }
-    }
-
-    ExReleaseFastMutex(&CmiCallbackLock);
-
-    return STATUS_UNSUCCESSFUL;
-}
--- a/reactos/ntoskrnl/cm/cmindex.c
+++ b/reactos/ntoskrnl/cm/cmindex.c
--- a/reactos/ntoskrnl/cm/cminfo.txt
+++ b/reactos/ntoskrnl/cm/cminfo.txt
@@ -1,143 +0,0 @@
-=========================
-== Cm Rewrite Branch ==-
-=========================
-
-= At a Glance =-
-
-Owner:  Alex Ionescu (alex.ionescu@reactos.org)
-ETC:    1st October 2007
-Purose: Rewriting the Configuration Manager nearly from scratch.
-
-= Design Goals =-
-
-Get rid of the outdated, deprecated and mostly incorrect Configuration Manager
-in ReactOS (ntoskrnl\cm) and replace it with a version that is 100% compatible
-with Windows NT internally as well as externally. The following key semantics
-will be highly prioritized:
-
-   - Locality: The NT Configuration Manager dedicates a large part of its inner
-               functionality to the implementation of a memory cache whose main
-               component, the KCB (Key Control Block) serves as a mechanism to
-               store the most frequently used data in a key node. Other parts
-               are also present, such as the NCBs (Name Control Blocks) which
-               are used to store key names in a compressed and hashed/prefixed
-               form and delayed close and private allocations, which allow 
-               re-using pool memory and delaying deletion for better paralel-
-               lism.
-
-   - Scalability and Thread Safety/MP: The NT Configuration Manager is also
-               extremly scalable and has over 8 highly-scalable locks (based on
-               the pushlock implementation, and also guarded mutex) which also
-               allow shared lock semantics (exclusive vs shared locks). This
-               implementation allows for various operations to happen simulta-
-               nously on a hive, while still maintaining full thread safety,
-               due to the fact that key structures are separated and have their
-               own locks.
-
-   - Reliability: The NT Configuration Manager offers a variety of complex
-               algorithms which continously check the state of a loaded hive or
-               a hive that is being loaded, as well as per-key node damage.
-               Furthermore, upon detection of a damaged node, the Configuration
-               Manager is often able to repair the Registry and bring it back
-               to a usable state, through a process called self healing.
-
-   - Object-Oriented: Like many other core structures in NT, the Configuration
-               Manager exposes its interfaces to drivers and user-mode through
-               the Key Object, which is an abstraction and interface that is
-               setup with the Object Manager. The Configuration Manager uses
-               its own internal namespace for managing keys (much like FSDs),
-               and does not depend on the much slower generic Object Manager
-               direction namespace. It provides a full suite of Object Routines
-               for Parse, Open, Close and Security callbacks, giving it full
-               access to the Key Object and allowing the optimization of look-
-               ups and respect of complex semantics such as those of security
-               or registry symbolic linking.
-
-= Sources =-
-
-The reimplementation of the NT Configuration Manager benefits from an extensive
-amount of assertions (ASSERT) and debug messages present in checked builds of
-the Windows NT 5.2 Kernel. These assertions, extracted with a simple clean-room
-tool such as "findstr", "strings" or "grep", allow a great understanding of the
-internal macros, definitions and inner semantics of the original code. Further,
-the tracing macros in the code allow for highly detailed analysis of the code
-flow behind the Cm code in NT, even up to dumping parameters sent to each and
-every internal function in the code, most of which also print out information
-at up to every 5 lines of code or so. Mixed with the public symbolic data, this
-allows for the creation of complex call flow analysis that includes the names
-of global variables as well. All these methods are fully clean, since they rely
-on textual messages printed to the debugger, or strings dumped from the image
-or public symbol database (PDB file).
-
-As far as references go, Mark Russinovich has written one or two interesting
-papers on the topic, which also deal with some internals, as well as chapter
-4, section 1, in the Windows Internals 4th Edition book, which explains some of
-the internals behind KCBs, NCBs and Key Objects. Chapter 9 of Windows Internals
-II also has some high-level information on the Registry.
-
-Finally, the KD Extension DLL that comes with WinDBG has an extensive array of
-helper commands to dump all sorts of registry internals, and allows converting
-between hex values of various structure flags to their actual names. Combined
-with assertions, this allows us to create almost entirely all the needed types
-and definitions for a compatible internal implementation.
-
-= Current State =-
-
-**As of 04/08/2006
-  ~40-50% of the Initialization code is complete.
-  ~60% of the KCB/NCB code is complete.
-  Blocking on cmlib being modified to use actual NT _HHIVE.
-
-**As of 16/08/2006
-  ~90% of the KCB/NCB code is complete.
-  Work about to resume on initialization code.
-
-**As of 6/10/2006
-  ~90% of the KCB/NCB code is complete.
-  ~70% of Initialization code is complete.
-
-**As of 11/5/2007
-  Significant parts of the rewrite have been merged in and bugfixed with
-  existing cm code into the main tree, in the /config directory.
-  ~100% of the Initialization code is now complete, including reading the
-  System Control Vector.
-  ~80% of the ARC Hardware Configuration Node/Tree code has been written.
-  It has been decided to stick with internal NT names since this simplifies
-  PDB and Internet lookups, even though some of these names aren't fully to my
-  taste.
-
-  TODOs:
-    Write Driver-list APIs directly into main branch since they should be low-
-    level enough to bypass the Object Manager interface (just like the System
-    Vector code).
-    Fix Cm Wrapper routines to read/write in chunks of 64K to avoid issues when
-    working with a large set of data (this is what NT does as well).
-    Try to make more code in trunk to use CmpOpenHiveFiles instead of the code
-    being used now.
-    Modify FreeLDR to actually send an ARC Configuration Root Tree instead of
-    writing to the hardware hive itself.
-    Once the above is done, modify current hacks to handle proper hardware hive
-    creation and initialization.
-    Once the above is done, merge trunk back into the Cm Rewrite branch, and
-    resume work on rewrite when will/time is available.
-
-= Structure =-
-
-cmapi.c    - Contains the low-level Cmp APIs that correspond to the external Nt
-             APIs such as NtReadKeyValue, NtCreateKey, etc.
-cmhive.c   - Contains all the functions related to the creation, initialization
-             and manipulation of registry hives.
-cmindex.c  - Contains functions related to cell indexes.
-cminit.c   - Contains the initialization/shutdown code for the NT Configuration
-             Manager, as well as any strictly internal initialization routines.
-cmkcbncb.c - Contains functions related to the creation, initialization and
-             manipulation of Key Control Blocks (KCB) and Name Control Blocks.
-cmname.c   - Contains functions related to the manipulation of key names and/or
-             paths.
-cmobject.c - Contains the implementation of the key object that is exported to
-             the Object Manager.
-cmutil.c   - Contains utility functions such as the registry lock and delayed
-             item allocation and de-allocation routines.
-ntapi.c    - Contains the Nt APIs exported to drivers and user-mode, which wrap
-             around other internal APIs in this module (mostly cmapi.c).
-
--- a/reactos/ntoskrnl/cm/cminit.c
+++ b/reactos/ntoskrnl/cm/cminit.c
@@ -1,894 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/cminit.c
- * PURPOSE:         Initialization and generic utility routines
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-#include "cm.h"
-
-UNICODE_STRING CmRegistryMachineSystemName =
-    RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM");
-UNICODE_STRING CmpSystemFileName =
-    RTL_CONSTANT_STRING(L"SYSTEM");
-
-BOOLEAN CmpMiniNTBoot;
-BOOLEAN CmpShareSystemHives;
-ULONG CmpBootType;
-BOOLEAN CmpSpecialBootCondition;
-BOOLEAN CmpFlushOnLockRelease;
-
-PEPROCESS CmpSystemProcess;
-PCMHIVE CmpMasterHive;
-HANDLE CmpRegistryRootHandle;
-
-BOOLEAN CmSelfHeal, CmpSelfHeal;
-KGUARDED_MUTEX CmpSelfHealQueueLock;
-LIST_ENTRY CmpSelfHealQueueListHead;
-
-EX_PUSH_LOCK CmpLoadHiveLock;
-
-UNICODE_STRING CmpSystemStartOptions;
-UNICODE_STRING CmpLoadOptions;
-
-ULONG CmpCallBackCount;
-
-GENERIC_MAPPING CmpKeyMapping =
-{
-    KEY_READ,
-    KEY_WRITE,
-    KEY_EXECUTE,
-    KEY_ALL_ACCESS
-};
-
-EX_CALLBACK CmpCallBackVector[CMP_MAX_CALLBACKS];
-
-PVOID NTAPI CmpRosGetHardwareHive(OUT PULONG Length);
-
-/* FUNCTIONS *****************************************************************/
-
-PVOID
-NTAPI
-CmpRosGetHardwareHive(OUT PULONG Length)
-{
-    PLIST_ENTRY ListHead, NextEntry;
-    PMEMORY_ALLOCATION_DESCRIPTOR MdBlock = NULL;
-    
-    /* Loop the memory descriptors */
-    ListHead = &KeLoaderBlock->MemoryDescriptorListHead;
-    NextEntry = ListHead->Flink;
-    while (NextEntry != ListHead)
-    {
-        /* Get the current block */
-        MdBlock = CONTAINING_RECORD(NextEntry,
-                                    MEMORY_ALLOCATION_DESCRIPTOR,
-                                    ListEntry);
-        
-        /* Check if this is an registry block */
-        if (MdBlock->MemoryType == LoaderRegistryData)
-        {
-            /* Check if it's not the SYSTEM hive that we already initialized */
-            if ((MdBlock->BasePage) !=
-                (((ULONG_PTR)KeLoaderBlock->RegistryBase &~ KSEG0_BASE) >> PAGE_SHIFT))
-            {
-                /* Hardware hive break out */
-                break;
-            }
-        }
-        
-        /* Go to the next block */
-        NextEntry = MdBlock->ListEntry.Flink;
-    }
-    
-    /* We need a hardware hive */
-    ASSERT(MdBlock);
-    *Length = MdBlock->PageCount << PAGE_SHIFT;
-    return (PVOID)((MdBlock->BasePage << PAGE_SHIFT) | KSEG0_BASE);
-}
-
-NTSTATUS
-NTAPI
-CmpCreateObjectTypes(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    GENERIC_MAPPING CmpKeyMapping = {KEY_READ,
-        KEY_WRITE,
-        KEY_EXECUTE,
-        KEY_ALL_ACCESS};
-    PAGED_CODE();
-    
-    /* Initialize the Key object type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Key");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultPagedPoolCharge = sizeof(CM_KEY_BODY);
-    ObjectTypeInitializer.GenericMapping = CmpKeyMapping;
-    ObjectTypeInitializer.PoolType = PagedPool;
-    ObjectTypeInitializer.ValidAccessMask = KEY_ALL_ACCESS;
-    ObjectTypeInitializer.UseDefaultObject = TRUE;
-    ObjectTypeInitializer.DeleteProcedure = CmpDeleteKeyObject;
-    ObjectTypeInitializer.ParseProcedure = CmpParseKey;
-    ObjectTypeInitializer.SecurityProcedure = CmpSecurityMethod;
-    ObjectTypeInitializer.QueryNameProcedure = CmpQueryKeyName;
-    //ObjectTypeInitializer.CloseProcedure = CmpCloseKeyObject;
-    ObjectTypeInitializer.SecurityRequired = TRUE;
-    
-    /* Create it */
-    return ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &CmpKeyObjectType);
-}
-
-BOOLEAN
-NTAPI
-CmpCreateRootNode(IN PHHIVE Hive,
-                  IN PWCHAR Name,
-                  OUT HCELL_INDEX *Index)
-{
-    UNICODE_STRING KeyName;
-    PCELL_DATA Cell;
-    LARGE_INTEGER SystemTime;
-    PAGED_CODE();
-
-    /* Initialize the node name and allocate it */
-    RtlInitUnicodeString(&KeyName, Name);
-    *Index = HvAllocateCell(Hive,
-                            FIELD_OFFSET(CM_KEY_NODE, Name) +
-                            CmpNameSize(Hive, &KeyName),
-                            Stable,
-                            HCELL_NIL);
-    if (*Index == HCELL_NIL) return FALSE;
-
-    /* Set the cell index and get the data */
-    Hive->BaseBlock->RootCell = *Index;
-    Cell = HvGetCell(Hive, *Index);
-
-    /* Fill out the cell */
-    Cell->u.KeyNode.Signature = (USHORT)CM_KEY_NODE_SIGNATURE;
-    Cell->u.KeyNode.Flags = KEY_HIVE_ENTRY | KEY_NO_DELETE;
-    KeQuerySystemTime(&SystemTime);
-    Cell->u.KeyNode.LastWriteTime = SystemTime;
-    Cell->u.KeyNode.Parent = HCELL_NIL;
-    Cell->u.KeyNode.SubKeyCounts[Stable] = 0;
-    Cell->u.KeyNode.SubKeyCounts[Volatile] = 0;
-    Cell->u.KeyNode.SubKeyLists[Stable] = 0;
-    Cell->u.KeyNode.SubKeyLists[Volatile] = 0;
-    Cell->u.KeyNode.ValueList.Count = 0;
-    Cell->u.KeyNode.ValueList.List = HCELL_NIL;
-    Cell->u.KeyNode.Class = HCELL_NIL;
-    Cell->u.KeyNode.MaxValueDataLen = 0;
-    Cell->u.KeyNode.MaxNameLen = 0;
-    Cell->u.KeyNode.MaxValueNameLen = 0;
-    Cell->u.KeyNode.MaxClassLen = 0;
-
-    /* Copy the name (this will also set the length) */
-    Cell->u.KeyNode.NameLength = CmpCopyName(Hive,
-                                             Cell->u.KeyNode.Name,
-                                             &KeyName);
-
-    /* Check if the name was compressed */
-    if (Cell->u.KeyNode.NameLength < KeyName.Length)
-    {
-        /* Set the flag */
-        Cell->u.KeyNode.Flags |= KEY_COMP_NAME;
-    }
-
-    /* Return success */
-    HvReleaseCell(Hive, *Index);
-    return TRUE;
-}
-
-BOOLEAN
-NTAPI
-CmpCreateRegistryRoot(VOID)
-{
-    UNICODE_STRING KeyName;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    PCM_KEY_BODY RootKey;
-    HCELL_INDEX RootIndex;
-    NTSTATUS Status;
-    PCM_KEY_NODE KeyCell;
-    PSECURITY_DESCRIPTOR SecurityDescriptor;
-    PCM_KEY_CONTROL_BLOCK Kcb;
-    PAGED_CODE();
-
-    /* Setup the root node */
-    if (!CmpCreateRootNode(&CmpMasterHive->Hive, L"REGISTRY", &RootIndex))
-    {
-        /* We failed */
-        DPRINT1("Fail\n");
-        return FALSE;
-    }
-
-    /* Create '\Registry' key. */
-    RtlInitUnicodeString(&KeyName, L"\\Registry");
-    SecurityDescriptor = CmpHiveRootSecurityDescriptor();
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = ObCreateObject(KernelMode,
-                            CmpKeyObjectType,
-                            &ObjectAttributes,
-                            KernelMode,
-                            NULL,
-                            sizeof(CM_KEY_BODY),
-                            0,
-                            0,
-                            (PVOID*)&RootKey);
-    ExFreePool(SecurityDescriptor);
-    if (!NT_SUCCESS(Status)) return FALSE;
-
-    /* Sanity check, and get the key cell */
-    ASSERT((&CmpMasterHive->Hive)->ReleaseCellRoutine == NULL);
-    KeyCell = (PCM_KEY_NODE)HvGetCell(&CmpMasterHive->Hive, RootIndex);
-    if (!KeyCell) return FALSE;
-    
-    /* Create the KCB */
-    RtlInitUnicodeString(&KeyName, L"Registry");
-    Kcb = CmpCreateKeyControlBlock(&CmpMasterHive->Hive,
-                                   RootIndex,
-                                   KeyCell,
-                                   NULL,
-                                   0,
-                                   &KeyName);
-    if (!Kcb) return FALSE;
-
-    /* Setup the key */
-    RootKey->Type = TAG('k', 'v', '0', '2');
-    RootKey->KeyControlBlock = Kcb;
-    RootKey->NotifyBlock = NULL;
-    RootKey->ProcessID = PsGetCurrentProcessId();  
-
-    /* Enlist it */
-    EnlistKeyBodyWithKCB(RootKey, 0);
-
-    /* Insert the key */
-    Status = ObInsertObject(RootKey,
-                            NULL,
-                            KEY_ALL_ACCESS,
-                            0,
-                            NULL,
-                            &CmpRegistryRootHandle);
-    if (!NT_SUCCESS(Status)) return FALSE;
-
-    /* Now reference it as a keep alive and return the status */
-    Status = ObReferenceObjectByHandle(CmpRegistryRootHandle,
-                                       KEY_READ,
-                                       NULL,
-                                       KernelMode,
-                                       (PVOID*)&RootKey,
-                                       NULL);
-    if (!NT_SUCCESS(Status)) return FALSE;
-    
-    /* Completely sucessful */
-    return TRUE;
-}
-
-VOID
-NTAPI
-CmpInitializeCallbacks(VOID)
-{
-    ULONG i;
-    PAGED_CODE();
-
-    /* Reset counter */
-    CmpCallBackCount = 0;
-
-    /* Loop all the callbacks */
-    for (i = 0; i < CMP_MAX_CALLBACKS; i++)
-    {
-        /* Initialize this one */
-        ExInitializeCallBack(&CmpCallBackVector[i]);
-    }
-}
-
-NTSTATUS
-NTAPI
-CmpSetSystemValues(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName, ValueName;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-    ASSERT(LoaderBlock != NULL);
-    if (ExpInTextModeSetup) return STATUS_SUCCESS;
-    
-    /* Setup attributes for loader options */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\"
-                         L"Control");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtOpenKey(&KeyHandle, KEY_WRITE, &ObjectAttributes);
-    if (!NT_SUCCESS(Status)) goto Quickie;
-    
-    /* Key opened, now write to the key */
-    RtlInitUnicodeString(&KeyName, L"SystemStartOptions");
-    Status = NtSetValueKey(KeyHandle,
-                           &KeyName,
-                           0,
-                           REG_SZ,
-                           CmpLoadOptions.Buffer,
-                           CmpLoadOptions.Length);
-    if (!NT_SUCCESS(Status)) goto Quickie;
-    
-    /* Setup value name for system boot device */
-    RtlInitUnicodeString(&KeyName, L"SystemBootDevice");
-    RtlCreateUnicodeStringFromAsciiz(&ValueName, LoaderBlock->NtBootPathName);
-    Status = NtSetValueKey(KeyHandle,
-                           &KeyName,
-                           0,
-                           REG_SZ,
-                           ValueName.Buffer,
-                           ValueName.Length);
-    
-Quickie:
-    /* Free the buffers */
-    RtlFreeUnicodeString(&ValueName);
-    
-    /* Close the key and return */
-    NtClose(KeyHandle);
-    
-    /* Return the status */
-    return Status;
-}
-
-BOOLEAN
-NTAPI
-CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
-{
-    PCMHIVE SystemHive;
-    PVOID HiveImageBase;
-    BOOLEAN Allocate = FALSE;
-    PSECURITY_DESCRIPTOR SecurityDescriptor;
-    NTSTATUS Status;
-    STRING  TempString;
-    PAGED_CODE();
-
-    /* Create ANSI_STRING from the loader options */
-    RtlInitAnsiString(&TempString, LoaderBlock->LoadOptions);
-
-    /* Setup UNICODE_STRING */
-    CmpLoadOptions.Length = 0;
-    CmpLoadOptions.MaximumLength = TempString.Length * sizeof(WCHAR) +
-                                   sizeof(UNICODE_NULL);
-    CmpLoadOptions.Buffer = ExAllocatePoolWithTag(PagedPool,
-                                                  CmpLoadOptions.MaximumLength,
-                                                  TAG_CM);
-    if (!CmpLoadOptions.Buffer)
-    {
-        /* Fail */
-        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 5, 6, 0, 0);
-    }
-
-    /* Convert it to Unicode and nul-terminate it */
-    RtlAnsiStringToUnicodeString(&CmpLoadOptions, &TempString, FALSE);
-    CmpLoadOptions.Buffer[TempString.Length] = UNICODE_NULL;
-    CmpLoadOptions.Length += sizeof(WCHAR);
-
-    /* Get the image base */
-    HiveImageBase = LoaderBlock->RegistryBase;
-    if (!HiveImageBase)
-    {
-        /* Don't have a system hive, create it */
-        Status = CmpInitializeHive(&SystemHive,
-                                   HINIT_CREATE,
-                                   HIVE_NOLAZYFLUSH,
-                                   HFILE_TYPE_LOG,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   &CmpSystemFileName,
-                                   0);
-        if (!NT_SUCCESS(Status)) return FALSE;
-        Allocate = TRUE;
-    }
-    else
-    {
-        /* Make a copy of the loaded hive */
-        Status = CmpInitializeHive(&SystemHive,
-                                   HINIT_MEMORY,
-                                   0,
-                                   HFILE_TYPE_LOG,
-                                   HiveImageBase,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   &CmpSystemFileName,
-                                   2);
-        if (!NT_SUCCESS(Status)) return FALSE;
-
-        /* Check if we loaded with shared hives */
-        if (CmpShareSystemHives) SystemHive->Hive.HvBinHeadersUse = 0;
-
-        /* Set the boot type */
-        CmpBootType = SystemHive->Hive.BaseBlock->BootType;
-
-        /* Check if we loaded in self-healing mode */
-        if (!CmSelfHeal)
-        {
-            /* We didn't, check the boot type */
-            if (CmpBootType & 4)
-            {
-                /* Invalid boot type */
-                CmpSelfHeal = FALSE;
-                KeBugCheckEx(REGISTRY_ERROR, 3, 3, (ULONG_PTR)SystemHive, 0);
-            }
-        }
-    }
-
-    /* Create security descriptor */
-    SecurityDescriptor = CmpHiveRootSecurityDescriptor();
-
-    /* Link the hive to the master */
-    Status = CmpLinkHiveToMaster(&CmRegistryMachineSystemName,
-                                 NULL,
-                                 SystemHive,
-                                 Allocate,
-                                 SecurityDescriptor);
-
-    /* Free the descriptor and check for success */
-    ExFreePool(SecurityDescriptor);
-    if (!NT_SUCCESS(Status)) return FALSE;
-
-    /* Save the hive */
-    CmpMachineHiveList[3].CmHive = SystemHive;
-    return TRUE;
-}
-
-NTSTATUS
-NTAPI
-CmpCreateControlSet(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
-{
-    UNICODE_STRING ConfigName = RTL_CONSTANT_STRING(L"Control\\IDConfigDB");
-    UNICODE_STRING SelectName =
-        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\Select");
-    UNICODE_STRING KeyName;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    CHAR ValueInfoBuffer[128];
-    PKEY_VALUE_FULL_INFORMATION ValueInfo;
-    CHAR Buffer[128];
-    WCHAR UnicodeBuffer[128];
-    HANDLE SelectHandle, KeyHandle, ConfigHandle = NULL, ProfileHandle = NULL;
-    HANDLE ParentHandle = NULL;
-    ULONG ControlSet, HwProfile;
-    ANSI_STRING TempString;
-    NTSTATUS Status;
-    ULONG ResultLength, Disposition;
-    PLOADER_PARAMETER_EXTENSION LoaderExtension;
-    PAGED_CODE();
-    if (ExpInTextModeSetup) return STATUS_SUCCESS;
-
-    /* Open the select key */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &SelectName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtOpenKey(&SelectHandle, KEY_READ, &ObjectAttributes);
-    if (!NT_SUCCESS(Status)) return(Status);
-
-    /* Open the current value */
-    RtlInitUnicodeString(&KeyName, L"Current");
-    Status = NtQueryValueKey(SelectHandle,
-                             &KeyName,
-                             KeyValueFullInformation,
-                             ValueInfoBuffer,
-                             sizeof(ValueInfoBuffer),
-                             &ResultLength);
-    NtClose(SelectHandle);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Get the actual value pointer, and get the control set ID */
-    ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
-    ControlSet = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
-
-    /* Create the current control set key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\System\\CurrentControlSet");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_CREATE_LINK,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK,
-                         &Disposition);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Sanity check */
-    ASSERT(Disposition == REG_CREATED_NEW_KEY);
-
-    /* Initialize the symbolic link name */
-    sprintf(Buffer,
-            "\\Registry\\Machine\\System\\ControlSet%03ld",
-            ControlSet);
-    RtlInitAnsiString(&TempString, Buffer);
-
-    /* Create a Unicode string out of it */
-    KeyName.MaximumLength = sizeof(UnicodeBuffer);
-    KeyName.Buffer = UnicodeBuffer;
-    Status = RtlAnsiStringToUnicodeString(&KeyName, &TempString, FALSE);
-
-    /* Set the value */
-    Status = NtSetValueKey(KeyHandle,
-                           &CmSymbolicLinkValueName,
-                           0,
-                           REG_LINK,
-                           KeyName.Buffer,
-                           KeyName.Length);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Get the configuration database key */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &ConfigName,
-                               OBJ_CASE_INSENSITIVE,
-                               KeyHandle,
-                               NULL);
-    Status = NtOpenKey(&ConfigHandle, KEY_READ, &ObjectAttributes);
-    NtClose(KeyHandle);
-
-    /* Check if we don't have one */
-    if (!NT_SUCCESS(Status))
-    {
-        /* Cleanup and exit */
-        ConfigHandle = 0;
-        goto Cleanup;
-    }
-
-    /* Now get the current config */
-    RtlInitUnicodeString(&KeyName, L"CurrentConfig");
-    Status = NtQueryValueKey(ConfigHandle,
-                             &KeyName,
-                             KeyValueFullInformation,
-                             ValueInfoBuffer,
-                             sizeof(ValueInfoBuffer),
-                             &ResultLength);
-
-    /* Set pointer to buffer */
-    ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
-
-    /* Check if we failed or got a non DWORD-value */
-    if (!(NT_SUCCESS(Status)) || (ValueInfo->Type != REG_DWORD)) goto Cleanup;
-
-    /* Get the hadware profile */
-    HwProfile = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
-
-    /* Open the hardware profile key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\System\\CurrentControlSet"
-                         L"\\Hardware Profiles");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtOpenKey(&ParentHandle, KEY_READ, &ObjectAttributes);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Exit and clean up */
-        ParentHandle = 0;
-        goto Cleanup;
-    }
-
-    /* Build the profile name */
-    sprintf(Buffer, "%04ld", HwProfile);
-    RtlInitAnsiString(&TempString, Buffer);
-
-    /* Convert it to Unicode */
-    KeyName.MaximumLength = sizeof(UnicodeBuffer);
-    KeyName.Buffer = UnicodeBuffer;
-    Status = RtlAnsiStringToUnicodeString(&KeyName,
-                                          &TempString,
-                                          FALSE);
-    ASSERT(Status == STATUS_SUCCESS);
-
-    /* Open the associated key */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               ParentHandle,
-                               NULL);
-    Status = NtOpenKey(&ProfileHandle,
-                       KEY_READ | KEY_WRITE,
-                       &ObjectAttributes);
-    if (!NT_SUCCESS (Status))
-    {
-        /* Cleanup and exit */
-        ProfileHandle = 0;
-        goto Cleanup;
-    }
-
-    /* Check if we have a loader block extension */
-    LoaderExtension = LoaderBlock->Extension;
-    if (LoaderExtension)
-    {
-        ASSERTMSG("ReactOS doesn't support NTLDR Profiles yet!\n", FALSE);
-    }
-
-    /* Create the current hardware profile key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\System\\CurrentControlSet\\"
-                         L"Hardware Profiles\\Current");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_CREATE_LINK,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK,
-                         &Disposition);
-    if (NT_SUCCESS(Status))
-    {
-        /* Sanity check */
-        ASSERT(Disposition == REG_CREATED_NEW_KEY);
-
-        /* Create the profile name */
-        sprintf(Buffer,
-                "\\Registry\\Machine\\System\\CurrentControlSet\\"
-                "Hardware Profiles\\%04ld",
-                HwProfile);
-        RtlInitAnsiString(&TempString, Buffer);
-
-        /* Convert it to Unicode */
-        KeyName.MaximumLength = sizeof(UnicodeBuffer);
-        KeyName.Buffer = UnicodeBuffer;
-        Status = RtlAnsiStringToUnicodeString(&KeyName,
-                                              &TempString,
-                                              FALSE);
-        ASSERT(STATUS_SUCCESS == Status);
-
-        /* Set it */
-        Status = NtSetValueKey(KeyHandle,
-                               &CmSymbolicLinkValueName,
-                               0,
-                               REG_LINK,
-                               KeyName.Buffer,
-                               KeyName.Length);
-        NtClose(KeyHandle);
-    }
-
-    /* Close every opened handle */
-Cleanup:
-    if (ConfigHandle) NtClose(ConfigHandle);
-    if (ProfileHandle) NtClose(ProfileHandle);
-    if (ParentHandle) NtClose(ParentHandle);
-
-    /* Return success */
-    return STATUS_SUCCESS;
-}
-
-BOOLEAN
-NTAPI
-CmInitSystem1(VOID)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-    PVOID BaseAddress;
-    ULONG Length;
-    PSECURITY_DESCRIPTOR SecurityDescriptor;
-    PCMHIVE HardwareHive;
-    PAGED_CODE();
-
-    /* Check if this is PE-boot */
-    if (InitIsWinPEMode)
-    {
-        /* Set registry to PE mode */
-        CmpMiniNTBoot = TRUE;
-        CmpShareSystemHives = TRUE;
-    }
-
-    /* Initialize the hive list and lock */
-    InitializeListHead(&CmpHiveListHead);
-    ExInitializePushLock((PVOID)&CmpHiveListHeadLock);
-    ExInitializePushLock((PVOID)&CmpLoadHiveLock);
-
-    /* Initialize registry lock */
-    ExInitializeResourceLite(&CmpRegistryLock);
-
-    /* Initialize the cache */
-    CmpInitializeCache();
-
-    /* Initialize allocation and delayed dereferencing */
-    CmpInitCmPrivateAlloc();
-    CmpInitCmPrivateDelayAlloc();
-    CmpInitDelayDerefKCBEngine();
-
-    /* Initialize callbacks */
-    CmpInitCallback();
-
-    /* Initialize self healing */
-    KeInitializeGuardedMutex(&CmpSelfHealQueueLock);
-    InitializeListHead(&CmpSelfHealQueueListHead);
-
-    /* Save the current process and lock the registry */
-    CmpSystemProcess = PsGetCurrentProcess();
-
-    /* Create the key object types */
-    Status = CmpCreateObjectTypes();
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 1, Status, 0);
-    }
-
-    /* Create master hive */
-    Status = CmpInitializeHive(&CmpMasterHive,
-                               HINIT_CREATE,
-                               HIVE_VOLATILE | 2, //HIVE_NO_FILE ROS
-                               HFILE_TYPE_PRIMARY,
-                               NULL,
-                               NULL,
-                               NULL,
-                               NULL,
-                               NULL,
-                               0);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 2, Status, 0);
-    }
-
-    /* Create the \REGISTRY key node */
-    if (!CmpCreateRegistryRoot())
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 3, 0, 0);
-    }
-    
-    /* Create the default security descriptor */
-    SecurityDescriptor = CmpHiveRootSecurityDescriptor();
-
-    /* Create '\Registry\Machine' key. */
-    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_READ | KEY_WRITE,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         0,
-                         NULL);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 5, Status, 0);
-    }
-    
-    /* Close the handle */
-    NtClose(KeyHandle);
-
-    /* Create '\Registry\User' key. */
-    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_READ | KEY_WRITE,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         0,
-                         NULL);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 6, Status, 0);
-    }
-    
-    /* Close the handle */
-    NtClose(KeyHandle);
-
-    /* Initialize and load the system hive */
-    if (!CmpInitializeSystemHive(KeLoaderBlock))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 7, 0, 0);
-    }
-
-    /* Create the CCS symbolic link */
-    Status = CmpCreateControlSet(KeLoaderBlock);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 8, Status, 0);
-    }
-    
-    /* Import the hardware hive (FIXME: We should create it from scratch) */
-    BaseAddress = CmpRosGetHardwareHive(&Length);
-    ((PHBASE_BLOCK)BaseAddress)->Length = Length;
-    Status = CmpInitializeHive((PCMHIVE*)&HardwareHive,
-                               HINIT_MEMORY, //HINIT_CREATE,
-                               HIVE_VOLATILE,
-                               HFILE_TYPE_PRIMARY,
-                               BaseAddress, // NULL,
-                               NULL,
-                               NULL,
-                               NULL,
-                               NULL,
-                               0);
-    CmPrepareHive(&HardwareHive->Hive);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 11, Status, 0);
-    }
-    
-    /* Attach it to the machine key */
-    RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE");
-    Status = CmpLinkHiveToMaster(&KeyName,
-                                 NULL,
-                                 (PCMHIVE)HardwareHive,
-                                 FALSE,
-                                 SecurityDescriptor);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 12, Status, 0);
-    }
-
-    /* Fill out the Hardware key with the ARC Data from the Loader */
-    Status = CmpInitializeHardwareConfiguration(KeLoaderBlock);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 13, Status, 0);
-    }
-
-    /* Initialize machine-dependent information into the registry */
-    Status = CmpInitializeMachineDependentConfiguration(KeLoaderBlock);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 14, Status, 0);
-    }
-
-    /* Initialize volatile registry settings */
-    Status = CmpSetSystemValues(KeLoaderBlock);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(CONFIG_INITIALIZATION_FAILED, 1, 15, Status, 0);
-    }
-    
-    /* Free the load options */
-    ExFreePool(CmpLoadOptions.Buffer);
-    
-    /* If we got here, all went well */
-    return TRUE;
-}
-
-VOID
-CmShutdownRegistry(VOID)
-{
-    return;
-}
-
--- a/reactos/ntoskrnl/cm/cmkcbncb.c
+++ b/reactos/ntoskrnl/cm/cmkcbncb.c
--- a/reactos/ntoskrnl/cm/cmname.c
+++ b/reactos/ntoskrnl/cm/cmname.c
@@ -1,254 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmname.c
- * PURPOSE:         Configuration Manager - Name Management
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-USHORT
-NTAPI
-CmpCopyName(IN PHHIVE Hive,
-            IN PWCHAR Destination,
-            IN PUNICODE_STRING Source)
-{
-    ULONG i;
-
-    /* Check for old hives */
-    if (Hive->Version == 1)
-    {
-        /* Just copy the source directly */
-        RtlCopyMemory(Destination, Source->Buffer, Source->Length);
-        return Source->Length;
-    }
-
-    /* For new versions, check for compressed name */
-    for (i = 0; i < (Source->Length / sizeof(WCHAR)); i++)
-    {
-        /* Check if the name is non compressed */
-        if (Source->Buffer[i] > (UCHAR)-1)
-        {
-            /* Do the copy */
-            RtlCopyMemory(Destination, Source->Buffer, Source->Length);
-            return Source->Length;
-        }
-
-        /* Copy this character */
-        ((PCHAR)Destination)[i] = (CHAR)(Source->Buffer[i]);
-    }
-
-    /* Compressed name, return length */
-    return Source->Length / sizeof(WCHAR);
-}
-
-VOID
-NTAPI
-CmpCopyCompressedName(IN PWCHAR Destination,
-                      IN ULONG DestinationLength,
-                      IN PWCHAR Source,
-                      IN ULONG SourceLength)
-{
-    ULONG i, Length;
-
-    /* Get the actual length to copy */
-    Length = min(DestinationLength / sizeof(WCHAR), SourceLength);
-    for (i = 0; i < Length; i++)
-    {
-        /* Copy each character */
-        Destination[i] = (WCHAR)((PCHAR)Source)[i];
-    }
-}
-
-USHORT
-NTAPI
-CmpNameSize(IN PHHIVE Hive,
-            IN PUNICODE_STRING Name)
-{
-    ULONG i;
-
-    /* For old hives, just retun the length */
-    if (Hive->Version == 1) return Name->Length;
-
-    /* For new versions, check for compressed name */
-    for (i = 0; i < (Name->Length / sizeof(WCHAR)); i++)
-    {
-        /* Check if the name is non compressed */
-        if (Name->Buffer[i] > (UCHAR)-1) return Name->Length;
-    }
-
-    /* Compressed name, return length */
-    return Name->Length / sizeof(WCHAR);
-}
-
-USHORT
-NTAPI
-CmpCompressedNameSize(IN PWCHAR Name,
-                      IN ULONG Length)
-{
-    /*
-     * Don't remove this: compressed names are "opaque" and just because
-     * the current implementation turns them into ansi-names doesn't mean
-     * that it will remain that way forever, so -never- assume this code
-     * below internally!
-     */
-    return (USHORT)Length * sizeof(WCHAR);
-}
-
-LONG
-NTAPI
-CmpCompareCompressedName(IN PCUNICODE_STRING SearchName,
-                         IN PWCHAR CompressedName,
-                         IN ULONG NameLength)
-{
-    WCHAR *p;
-    CHAR *pp;
-    WCHAR p1, p2;
-    USHORT SearchLength;
-    LONG Result;
-
-    /* Set the pointers and length and then loop */
-    p = SearchName->Buffer;
-    pp = (PCHAR)CompressedName;
-    SearchLength = (SearchName->Length / sizeof(WCHAR));
-    while ((SearchLength) && (NameLength))
-    {
-        /* Get the characters */
-        p1 = *p++;
-        p2 = (WCHAR)(*pp++);
-
-        /* Check if we have a direct match */
-        if (p1 != p2)
-        {
-            /* See if they match and return result if they don't */
-            Result = (LONG)RtlUpcaseUnicodeChar(p1) -
-                     (LONG)RtlUpcaseUnicodeChar(p2);
-            if (Result) return Result;
-        }
-
-        /* Next chars */
-        SearchLength--;
-        NameLength--;
-    }
-
-    /* Return the difference directly */
-    return SearchLength - NameLength;
-}
-
-BOOLEAN
-NTAPI
-CmpFindNameInList(IN PHHIVE Hive,
-                  IN PCHILD_LIST ChildList,
-                  IN PUNICODE_STRING Name,
-                  IN PULONG ChildIndex,
-                  IN PHCELL_INDEX CellIndex)
-{
-    PCELL_DATA CellData;
-    HCELL_INDEX CellToRelease = HCELL_NIL;
-    ULONG i;
-    PCM_KEY_VALUE KeyValue;
-    LONG Result;
-    UNICODE_STRING SearchName;
-    BOOLEAN Success;
-
-    /* Make sure there's actually something on the list */
-    if (ChildList->Count != 0)
-    {
-        /* Get the cell data */
-        CellData = (PCELL_DATA)HvGetCell(Hive, ChildList->List);
-        if (!CellData)
-        {
-            /* Couldn't get the cell... tell the caller */
-            *CellIndex = HCELL_NIL;
-            return FALSE;
-        }
-
-        /* Now loop every entry */
-        for (i = 0; i < ChildList->Count; i++)
-        {
-            /* Check if we have a cell to release */
-            if (CellToRelease != HCELL_NIL)
-            {
-                /* Release it */
-                HvReleaseCell(Hive, CellToRelease);
-                CellToRelease = HCELL_NIL;
-            }
-
-            /* Get this value */
-            KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, CellData->u.KeyList[i]);
-            if (!KeyValue)
-            {
-                /* Return with no data found */
-                *CellIndex = HCELL_NIL;
-                Success = FALSE;
-                goto Return;
-            }
-
-            /* Save the cell to release */
-            CellToRelease = CellData->u.KeyList[i];
-
-            /* Check if it's a compressed value name */
-            if (KeyValue->Flags & VALUE_COMP_NAME)
-            {
-                /* Use the compressed name check */
-                Result = CmpCompareCompressedName(Name,
-                                                  KeyValue->Name,
-                                                  KeyValue->NameLength);
-            }
-            else
-            {
-                /* Setup the Unicode string */
-                SearchName.Length = KeyValue->NameLength;
-                SearchName.MaximumLength = SearchName.Length;
-                SearchName.Buffer = KeyValue->Name;
-                Result = RtlCompareUnicodeString(Name, &SearchName, TRUE);
-            }
-
-            /* Check if we found it */
-            if (!Result)
-            {
-                /* We did...return info to caller */
-                if (ChildIndex) *ChildIndex = i;
-                *CellIndex = CellData->u.KeyList[i];
-
-                /* Set success state */
-                Success = TRUE;
-                goto Return;
-            }
-        }
-
-        /* Got to the end of the list */
-        if (ChildIndex) *ChildIndex = i;
-        *CellIndex = HCELL_NIL;
-
-        /* Nothing found if we got here */
-        Success = TRUE;
-        goto Return;
-    }
-
-    /* Nothing found...check if the caller wanted more info */
-    ASSERT(ChildList->Count == 0);
-    if (ChildIndex) *ChildIndex = 0;
-    *CellIndex = HCELL_NIL;
-
-    /* Nothing found if we got here */
-    return TRUE;
-
-Return:
-    /* Release the first cell we got */
-    if (CellData) HvReleaseCell(Hive, ChildList->List);
-
-    /* Release the secondary one, if we have one */
-    if (CellToRelease) HvReleaseCell(Hive, CellToRelease);
-    return Success;
-}
--- a/reactos/ntoskrnl/cm/cmobject.c
+++ b/reactos/ntoskrnl/cm/cmobject.c
@@ -1,73 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/cmname.c
- * PURPOSE:         Client-side of the Ob Callback Interface for Key Objects.
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-
-/* GLOBALS *******************************************************************/
-
-POBJECT_TYPE CmpKeyObjectType;
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CmpCloseKeyObject(IN PEPROCESS Process OPTIONAL,
-                  IN PVOID Object,
-                  IN ACCESS_MASK GrantedAccess,
-                  IN ULONG ProcessHandleCount,
-                  IN ULONG SystemHandleCount)
-{
-    /* FIXME: TODO */
-    ASSERT(FALSE);
-}
-
-VOID
-NTAPI
-CmpDeleteKeyObject(IN PVOID Object)
-{
-    /* FIXME: TODO */
-    ASSERT(FALSE);
-}
-
-NTSTATUS
-NTAPI
-CmpParseKey(IN PVOID ParseObject,
-            IN PVOID ObjectType,
-            IN OUT PACCESS_STATE AccessState,
-            IN KPROCESSOR_MODE AccessMode,
-            IN ULONG Attributes,
-            IN OUT PUNICODE_STRING CompleteName,
-            IN OUT PUNICODE_STRING RemainingName,
-            IN OUT PVOID Context OPTIONAL,
-            IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
-            OUT PVOID *Object)
-{
-    /* FIXME: TODO */
-    ASSERT(FALSE);
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-CmpQueryKeyName(IN PVOID Object,
-                IN BOOLEAN HasObjectName,
-                OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
-                IN ULONG Length,
-                OUT PULONG ReturnLength,
-                IN KPROCESSOR_MODE AccessMode)
-{
-    /* FIXME: TODO */
-    ASSERT(FALSE);
-    return STATUS_SUCCESS;
-}
-
-
--- a/reactos/ntoskrnl/cm/cmparse.c
+++ b/reactos/ntoskrnl/cm/cmparse.c
@@ -1,399 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmparse.c
- * PURPOSE:         Configuration Manager - Object Manager Parse Interface
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-BOOLEAN
-NTAPI
-CmpGetNextName(IN OUT PUNICODE_STRING RemainingName,
-               OUT PUNICODE_STRING NextName,
-               OUT PBOOLEAN LastName)
-{
-    BOOLEAN NameValid = TRUE;
-
-    /* Check if there's nothing left in the name */
-    if (!(RemainingName->Buffer) ||
-        (!RemainingName->Length) ||
-        !(*RemainingName->Buffer))
-    {
-        /* Clear the next name and set this as last */
-        *LastName = TRUE;
-        NextName->Buffer = NULL;
-        NextName->Length = 0;
-        return TRUE;
-    }
-
-    /* Check if we have a path separator */
-    if (*RemainingName->Buffer == OBJ_NAME_PATH_SEPARATOR)
-    {
-        /* Skip it */
-        RemainingName->Buffer++;
-        RemainingName->Length -= sizeof(WCHAR);
-        RemainingName->MaximumLength -= sizeof(WCHAR);
-    }
-
-    /* Start loop at where the current buffer is */
-    NextName->Buffer = RemainingName->Buffer;
-    while (TRUE)
-    {
-        /* Break out if we ran out or hit a path separator */
-        if (!(RemainingName->Length) ||
-            (*RemainingName->Buffer == OBJ_NAME_PATH_SEPARATOR))
-        {
-            break;
-        }
-
-        /* Move to the next character */
-        RemainingName->Buffer++;
-        RemainingName->Length -= sizeof(WCHAR);
-        RemainingName->MaximumLength -= sizeof(WCHAR);
-    }
-
-    /* See how many chars we parsed and validate the length */
-    NextName->Length = (USHORT)((ULONG_PTR)RemainingName->Buffer -
-                                (ULONG_PTR)NextName->Buffer);
-    if (NextName->Length > 512) NameValid = FALSE;
-    NextName->MaximumLength = NextName->Length;
-
-    /* If there's nothing left, we're last */
-    *LastName = !RemainingName->Length;
-    return NameValid;
-}
-
-NTSTATUS
-NTAPI
-CmpDoCreateChild(IN PHHIVE Hive,
-                 IN HCELL_INDEX ParentCell,
-                 IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
-                 IN PACCESS_STATE AccessState,
-                 IN PUNICODE_STRING Name,
-                 IN KPROCESSOR_MODE AccessMode,
-                 IN PCM_PARSE_CONTEXT Context,
-                 IN PCM_KEY_CONTROL_BLOCK ParentKcb,
-                 IN USHORT Flags,
-                 OUT PHCELL_INDEX KeyCell,
-                 OUT PVOID *Object)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-    PCM_KEY_CONTROL_BLOCK kcb;
-    HCELL_INDEX ClassCell = HCELL_NIL;
-    PCM_KEY_NODE KeyNode;
-    PCELL_DATA CellData;
-    ULONG StorageType;
-    LARGE_INTEGER SystemTime;
-    BOOLEAN Hack = FALSE;
-    PCM_KEY_BODY KeyBody;
-
-    /* ReactOS Hack */
-    if (Name->Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
-    {
-        /* Skip initial path separator */
-        Name->Buffer++;
-        Name->Length -= sizeof(OBJ_NAME_PATH_SEPARATOR);
-        Name->MaximumLength -= sizeof(OBJ_NAME_PATH_SEPARATOR);
-        Hack = TRUE;
-    }
-
-    /* Get the storage type */
-    StorageType = Stable;
-    if (Context->CreateOptions & REG_OPTION_VOLATILE) StorageType = Volatile;
-
-    /* Allocate the child */
-    *KeyCell = HvAllocateCell(Hive,
-                              FIELD_OFFSET(CM_KEY_NODE, Name) +
-                              CmpNameSize(Hive, Name),
-                              StorageType,
-                              HCELL_NIL);
-    if (*KeyCell == HCELL_NIL)
-    {
-        /* Fail */
-        Status = STATUS_INSUFFICIENT_RESOURCES;
-        goto Quickie;
-    }
-
-    /* Get the key node */
-    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, *KeyCell);
-    if (!KeyNode)
-    {
-        /* Fail, this should never happen */
-        ASSERT(FALSE);
-        Status = STATUS_INSUFFICIENT_RESOURCES;
-        goto Quickie;
-    }
-
-    /* Release the cell */
-    HvReleaseCell(Hive, *KeyCell);
-
-    /* Check if we have a class name */
-    if (Context->Class.Length > 0)
-    {
-        /* Allocate a class cell */
-        ClassCell = HvAllocateCell(Hive,
-                                   Context->Class.Length,
-                                   StorageType,
-                                   HCELL_NIL);
-        if (ClassCell == HCELL_NIL)
-        {
-            /* Fail */
-            Status = STATUS_INSUFFICIENT_RESOURCES;
-            goto Quickie;
-        }
-    }
-
-    /* Allocate the Cm Object */
-    Status = ObCreateObject(AccessMode,
-                            CmpKeyObjectType,
-                            NULL,
-                            AccessMode,
-                            NULL,
-                            sizeof(CM_KEY_BODY),
-                            0,
-                            0,
-                            Object);
-    if (!NT_SUCCESS(Status)) goto Quickie;
-    KeyBody = (PCM_KEY_BODY)(*Object);
-
-    /* Check if we had a class */
-    if (Context->Class.Length > 0)
-    {
-        /* Get the class cell */
-        CellData = HvGetCell(Hive, ClassCell);
-        if (!CellData)
-        {
-            /* Fail, this should never happen */
-            ASSERT(FALSE);
-            Status = STATUS_INSUFFICIENT_RESOURCES;
-            ObDereferenceObject(*Object);
-            goto Quickie;
-        }
-
-        /* Release the cell */
-        HvReleaseCell(Hive, ClassCell);
-
-        /* Copy the class data */
-        RtlCopyMemory(&CellData->u.KeyString[0],
-                      Context->Class.Buffer,
-                      Context->Class.Length);
-    }
-
-    /* Fill out the key node */
-    KeyNode->Signature = CM_KEY_NODE_SIGNATURE;
-    KeyNode->Flags = Flags;
-    KeQuerySystemTime(&SystemTime);
-    KeyNode->LastWriteTime = SystemTime;
-    KeyNode->Spare = 0;
-    KeyNode->Parent = ParentCell;
-    KeyNode->SubKeyCounts[Stable] = 0;
-    KeyNode->SubKeyCounts[Volatile] = 0;
-    KeyNode->SubKeyLists[Stable] = HCELL_NIL;
-    KeyNode->SubKeyLists[Volatile] = HCELL_NIL;
-    KeyNode->ValueList.Count = 0;
-    KeyNode->ValueList.List = HCELL_NIL;
-    KeyNode->Security = HCELL_NIL;
-    KeyNode->Class = ClassCell;
-    KeyNode->ClassLength = Context->Class.Length;
-    KeyNode->MaxValueDataLen = 0;
-    KeyNode->MaxNameLen = 0;
-    KeyNode->MaxValueNameLen = 0;
-    KeyNode->MaxClassLen = 0;
-    KeyNode->NameLength = CmpCopyName(Hive, KeyNode->Name, Name);
-    if (KeyNode->NameLength < Name->Length) KeyNode->Flags |= KEY_COMP_NAME;
-
-    /* Now fill out the Cm object */
-    kcb = CmpCreateKeyControlBlock(Hive,
-                                   *KeyCell,
-                                   KeyNode,
-                                   ParentKcb,
-                                   CMP_LOCK_HASHES_FOR_KCB, Name);
-    ASSERT(kcb->RefCount == 1);
-    KeyBody->Type = KEY_BODY_TYPE;
-    KeyBody->KeyControlBlock = kcb;
-    KeyBody->NotifyBlock = NULL;
-    KeyBody->ProcessID = PsGetCurrentProcessId();
-    EnlistKeyBodyWithKCB(KeyBody, 2);
-
-Quickie:
-    /* Check if we got here because of failure */
-    if (!NT_SUCCESS(Status))
-    {
-        /* Free any cells we might've allocated */
-        if (Context->Class.Length > 0) HvFreeCell(Hive, ClassCell);
-        HvFreeCell(Hive, *KeyCell);
-    }
-
-    /* Check if we applied ReactOS hack */
-    if (Hack)
-    {
-        /* Restore name */
-        Name->Buffer--;
-        Name->Length += sizeof(OBJ_NAME_PATH_SEPARATOR);
-        Name->MaximumLength += sizeof(OBJ_NAME_PATH_SEPARATOR);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-CmpDoCreate(IN PHHIVE Hive,
-            IN HCELL_INDEX Cell,
-            IN PACCESS_STATE AccessState,
-            IN PUNICODE_STRING Name,
-            IN KPROCESSOR_MODE AccessMode,
-            IN PCM_PARSE_CONTEXT Context,
-            IN PCM_KEY_CONTROL_BLOCK ParentKcb,
-            IN PCMHIVE OriginatingHive OPTIONAL,
-            OUT PVOID *Object)
-{
-    NTSTATUS Status;
-    PCELL_DATA CellData;
-    HCELL_INDEX KeyCell;
-    ULONG ParentType;
-    PCM_KEY_BODY KeyBody;
-    PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
-    LARGE_INTEGER TimeStamp;
-    PCM_KEY_NODE KeyNode;
-
-    /* Acquire the flusher lock */
-    //ExAcquirePushLockShared((PVOID)&((PCMHIVE)Hive)->FlusherLock);
-
-    /* Get the parent node */
-    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
-    if (!KeyNode)
-    {
-        /* Fail */
-        ASSERT(FALSE);
-        Status = STATUS_INSUFFICIENT_RESOURCES;
-        goto Exit;
-    }
-
-    /* Make sure nobody added us yet */
-    if (CmpFindSubKeyByName(Hive, KeyNode, Name) != HCELL_NIL)
-    {
-        /* Fail */
-        ASSERT(FALSE);
-        Status = STATUS_REPARSE;
-        goto Exit;
-    }
-
-    /* Sanity check */
-    ASSERT(Cell == ParentKcb->KeyCell);
-
-    /* Get the parent type */
-    ParentType = HvGetCellType(Cell);
-    if ((ParentType == Volatile) && !(Context->CreateOptions & REG_OPTION_VOLATILE))
-    {
-        /* Children of volatile parents must also be volatile */
-        ASSERT(FALSE);
-        Status = STATUS_CHILD_MUST_BE_VOLATILE;
-        goto Exit;
-    }
-
-    /* Don't allow children under symlinks */
-    if (ParentKcb->Flags & KEY_SYM_LINK)
-    {
-        /* Fail */
-        ASSERT(FALSE);
-        Status = STATUS_ACCESS_DENIED;
-        goto Exit;
-    }
-
-    /* Make the cell dirty for now */
-    HvMarkCellDirty(Hive, Cell, FALSE);
-
-    /* Do the actual create operation */
-    Status = CmpDoCreateChild(Hive,
-                              Cell,
-                              SecurityDescriptor,
-                              AccessState,
-                              Name,
-                              AccessMode,
-                              Context,
-                              ParentKcb,
-                              0,
-                              &KeyCell,
-                              Object);
-    if (NT_SUCCESS(Status))
-    {
-        /* Get the key body */
-        KeyBody = (PCM_KEY_BODY)(*Object);
-
-        /* Now add the subkey */
-        if (!CmpAddSubKey(Hive, Cell, KeyCell))
-        {
-            /* Failure! We don't handle this yet! */
-            ASSERT(FALSE);
-        }
-
-        /* Get the key node */
-        KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
-        if (!KeyNode)
-        {
-            /* Fail, this shouldn't happen */
-            ASSERT(FALSE);
-        }
-
-        /* Sanity checks */
-        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyCell == Cell);
-        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyHive == Hive);
-        ASSERT(KeyBody->KeyControlBlock->ParentKcb == ParentKcb);
-        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen == KeyNode->MaxNameLen);
-
-        /* Update the timestamp */
-        KeQuerySystemTime(&TimeStamp);
-        KeyNode->LastWriteTime = TimeStamp;
-        KeyBody->KeyControlBlock->ParentKcb->KcbLastWriteTime = TimeStamp;
-
-        /* Check if we need to update name maximum */
-        if (KeyNode->MaxNameLen < Name->Length)
-        {
-            /* Do it */
-            KeyNode->MaxNameLen = Name->Length;
-            KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen = Name->Length;
-        }
-
-        /* Check if we need toupdate class length maximum */
-        if (KeyNode->MaxClassLen < Context->Class.Length)
-        {
-            /* Update it */
-            KeyNode->MaxClassLen = Context->Class.Length;
-        }
-
-        /* Check if we're creating a symbolic link */
-        if (Context->CreateOptions & REG_OPTION_CREATE_LINK)
-        {
-            /* Get the cell data */
-            CellData = HvGetCell(Hive, KeyCell);
-            if (!CellData)
-            {
-                /* This shouldn't happen */
-                ASSERT(FALSE);
-            }
-
-            /* Update the flags */
-            CellData->u.KeyNode.Flags |= KEY_SYM_LINK;
-            KeyBody->KeyControlBlock->Flags = CellData->u.KeyNode.Flags;
-            HvReleaseCell(Hive, KeyCell);
-        }
-    }
-
-Exit:
-    /* Release the flusher lock and return status */
-    //ExReleasePushLock((PVOID)&((PCMHIVE)Hive)->FlusherLock);
-    return Status;
-}
--- a/reactos/ntoskrnl/cm/cmse.c
+++ b/reactos/ntoskrnl/cm/cmse.c
@@ -1,153 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmse.c
- * PURPOSE:         Configuration Manager - Security Subsystem Interface
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-PSECURITY_DESCRIPTOR
-NTAPI
-CmpHiveRootSecurityDescriptor(VOID)
-{
-    NTSTATUS Status;
-    PSECURITY_DESCRIPTOR SecurityDescriptor;
-    PACL Acl, AclCopy;
-    PSID Sid[4];
-    SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
-    SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
-    ULONG AceLength, AclLength, SidLength;
-    PACE_HEADER AceHeader;
-    ULONG i;
-    PAGED_CODE();
-
-    /* Phase 1: Allocate SIDs */
-    SidLength = RtlLengthRequiredSid(1);
-    Sid[0] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CM);
-    Sid[1] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CM);
-    Sid[2] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CM);
-    SidLength = RtlLengthRequiredSid(2);
-    Sid[3] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CM);
-
-    /* Make sure all SIDs were allocated */
-    if (!(Sid[0]) || !(Sid[1]) || !(Sid[2]) || !(Sid[3]))
-    {
-        /* Bugcheck */
-        KEBUGCHECKEX(REGISTRY_ERROR, 11, 1, 0, 0);
-    }
-
-    /* Phase 2: Initialize all SIDs */
-    Status = RtlInitializeSid(Sid[0], &WorldAuthority, 1);
-    Status |= RtlInitializeSid(Sid[1], &NtAuthority, 1);
-    Status |= RtlInitializeSid(Sid[2], &NtAuthority, 1);
-    Status |= RtlInitializeSid(Sid[3], &NtAuthority, 2);
-    if (!NT_SUCCESS(Status)) KEBUGCHECKEX(REGISTRY_ERROR, 11, 2, 0, 0);
-
-    /* Phase 2: Setup SID Sub Authorities */
-    *RtlSubAuthoritySid(Sid[0], 0) = SECURITY_WORLD_RID;
-    *RtlSubAuthoritySid(Sid[1], 0) = SECURITY_RESTRICTED_CODE_RID;
-    *RtlSubAuthoritySid(Sid[2], 0) = SECURITY_LOCAL_SYSTEM_RID;
-    *RtlSubAuthoritySid(Sid[3], 0) = SECURITY_BUILTIN_DOMAIN_RID;
-    *RtlSubAuthoritySid(Sid[3], 1) = DOMAIN_ALIAS_RID_ADMINS;
-
-    /* Make sure all SIDs are valid */
-    ASSERT(RtlValidSid(Sid[0]));
-    ASSERT(RtlValidSid(Sid[1]));
-    ASSERT(RtlValidSid(Sid[2]));
-    ASSERT(RtlValidSid(Sid[3]));
-
-    /* Phase 3: Calculate ACL Length */
-    AclLength = sizeof(ACL);
-    for (i = 0; i < 4; i++)
-    {
-        /* This is what MSDN says to do */
-        AceLength = FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart);
-        AceLength += SeLengthSid(Sid[i]);
-        AclLength += AceLength;
-    }
-
-    /* Phase 3: Allocate the ACL */
-    Acl = ExAllocatePoolWithTag(PagedPool, AclLength, TAG_CM);
-    if (!Acl) KEBUGCHECKEX(REGISTRY_ERROR, 11, 3, 0, 0);
-
-    /* Phase 4: Create the ACL */
-    Status = RtlCreateAcl(Acl, AclLength, ACL_REVISION);
-    if (!NT_SUCCESS(Status)) KEBUGCHECKEX(REGISTRY_ERROR, 11, 4, Status, 0);
-
-    /* Phase 5: Build the ACL */
-    Status = RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_ALL_ACCESS, Sid[0]);
-    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_ALL_ACCESS, Sid[1]);
-    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_READ, Sid[2]);
-    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_READ, Sid[3]);
-    if (!NT_SUCCESS(Status)) KEBUGCHECKEX(REGISTRY_ERROR, 11, 5, Status, 0);
-
-    /* Phase 5: Make the ACEs inheritable */
-    Status = RtlGetAce(Acl, 0,( PVOID*)&AceHeader);
-    ASSERT(NT_SUCCESS(Status));
-    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
-    Status = RtlGetAce(Acl, 1, (PVOID*)&AceHeader);
-    ASSERT(NT_SUCCESS(Status));
-    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
-    Status = RtlGetAce(Acl, 2, (PVOID*)&AceHeader);
-    ASSERT(NT_SUCCESS(Status));
-    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
-    Status = RtlGetAce(Acl, 3, (PVOID*)&AceHeader);
-    ASSERT(NT_SUCCESS(Status));
-    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
-
-    /* Phase 6: Allocate the security descriptor and make space for the ACL */
-    SecurityDescriptor = ExAllocatePoolWithTag(PagedPool,
-                                               sizeof(SECURITY_DESCRIPTOR) +
-                                               AclLength,
-                                               TAG_CM);
-    if (!SecurityDescriptor) KEBUGCHECKEX(REGISTRY_ERROR, 11, 6, 0, 0);
-
-    /* Phase 6: Make a copy of the ACL */
-    AclCopy = (PACL)((PISECURITY_DESCRIPTOR)SecurityDescriptor + 1);
-    RtlCopyMemory(AclCopy, Acl, AclLength);
-
-    /* Phase 7: Create the security descriptor */
-    Status = RtlCreateSecurityDescriptor(SecurityDescriptor,
-                                         SECURITY_DESCRIPTOR_REVISION);
-    if (!NT_SUCCESS(Status)) KEBUGCHECKEX(REGISTRY_ERROR, 11, 7, Status, 0);
-
-    /* Phase 8: Set the ACL as a DACL */
-    Status = RtlSetDaclSecurityDescriptor(SecurityDescriptor,
-                                          TRUE,
-                                          AclCopy,
-                                          FALSE);
-    if (!NT_SUCCESS(Status)) KEBUGCHECKEX(REGISTRY_ERROR, 11, 8, Status, 0);
-
-    /* Free the SIDs and original ACL */
-    for (i = 0; i < 4; i++) ExFreePool(Sid[i]);
-    ExFreePool(Acl);
-
-    /* Return the security descriptor */
-    return SecurityDescriptor;
-}
-
-NTSTATUS
-NTAPI
-CmpSecurityMethod(IN PVOID ObjectBody,
-                  IN SECURITY_OPERATION_CODE OperationCode,
-                  IN PSECURITY_INFORMATION SecurityInformation,
-                  IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
-                  IN OUT PULONG BufferLength,
-                  IN OUT PSECURITY_DESCRIPTOR *OldSecurityDescriptor,
-                  IN POOL_TYPE PoolType,
-                  IN PGENERIC_MAPPING GenericMapping)
-{
-    /* HACK */
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/cm/cmsecach.c
+++ b/reactos/ntoskrnl/cm/cmsecach.c
@@ -1,38 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmsecach.c
- * PURPOSE:         Configuration Manager - Security Cache
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CmpInitSecurityCache(IN PCMHIVE Hive)
-{
-    ULONG i;
-
-    /* Reset data */
-    Hive->SecurityCount = 0;
-    Hive->SecurityCacheSize = 0;
-    Hive->SecurityHitHint = -1;
-    Hive->SecurityCache = NULL;
-
-    /* Loop every security hash */
-    for (i = 0; i < 64; i++)
-    {
-        /* Initialize it */
-        InitializeListHead(&Hive->SecurityHash[i]);
-    }
-}
--- a/reactos/ntoskrnl/cm/cmutil.c
+++ b/reactos/ntoskrnl/cm/cmutil.c
@@ -1,185 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/cmapi.c
- * PURPOSE:         Internal routines that implement Nt* API functionality
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-#include "cm.h"
-
-ERESOURCE CmpRegistryLock;
-PVOID CmpRegistryLockCallerCaller, CmpRegistryLockCaller;
-BOOLEAN CmpFlushStarveWriters;
-
-KGUARDED_MUTEX CmpDelayAllocBucketLock;
-LIST_ENTRY CmpFreeDelayItemsListHead;
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-CmpLockRegistryExclusive(VOID)
-{
-    /* Enter a critical region and lock the registry */
-    KeEnterCriticalRegion();
-    ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
-
-    /* Sanity check */
-    ASSERT(CmpFlushStarveWriters == 0);
-    RtlGetCallersAddress(&CmpRegistryLockCaller, &CmpRegistryLockCallerCaller);
-}
-
-BOOLEAN
-NTAPI
-CmpTestRegistryLock(VOID)
-{
-    /* Test the lock */
-    return (BOOLEAN)ExIsResourceAcquiredSharedLite(&CmpRegistryLock);
-}
-
-BOOLEAN
-NTAPI
-CmpTestRegistryLockExclusive(VOID)
-{
-    /* Test the lock */
-    return ExIsResourceAcquiredExclusiveLite(&CmpRegistryLock);
-}
-
-PVOID
-NTAPI
-CmpAllocateDelayItem(VOID)
-{
-    PCM_DELAY_ALLOC Entry;
-    PCM_ALLOC_PAGE AllocPage;
-    ULONG i;
-    PLIST_ENTRY NextEntry;
-    PAGED_CODE();
-
-    /* Lock the allocation buckets */
-    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
-    
-    /* Look for an item on the free list */
-SearchList:
-    if (!IsListEmpty(&CmpFreeDelayItemsListHead))
-    {
-        /* Get the current entry in the list */
-        NextEntry = RemoveHeadList(&CmpFreeDelayItemsListHead);
-        
-        /* Grab the item */
-        Entry = CONTAINING_RECORD(NextEntry, CM_DELAY_ALLOC, ListEntry);
-        
-        /* Clear the list */
-        Entry->ListEntry.Flink = Entry->ListEntry.Blink = NULL;
-        
-        /* Grab the alloc page */
-        AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)Entry & 0xFFFFF000);
-        
-        /* Decrease free entries */
-        ASSERT(AllocPage->FreeCount != 0);
-        AllocPage->FreeCount--;
-        
-        /* Release the lock */
-        KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
-        return Entry;
-    }
-    
-    /* Allocate an allocation page */
-    AllocPage = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM);
-    if (AllocPage)
-    {
-        /* Set default entries */
-        AllocPage->FreeCount = CM_DELAYS_PER_PAGE;
-        
-        /* Loop each entry */
-        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
-        {
-            /* Get this entry and link it */
-            Entry = (PVOID)((ULONG_PTR)AllocPage +
-                            FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
-                            i * sizeof(CM_DELAY_ALLOC));
-            InsertTailList(&CmpFreeDelayItemsListHead,
-                           &Entry->ListEntry);
-            
-            /* Clear the KCB pointer */
-            Entry->Kcb = NULL;
-        }
-    }
-    else
-    {
-        /* Release the lock */
-        KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
-        return NULL;
-    }
-    
-    /* Do the search again */
-    goto SearchList;
-}
-
-VOID
-NTAPI
-CmpFreeDelayItem(PVOID Entry)
-{
-    PCM_DELAY_ALLOC AllocEntry = (PCM_DELAY_ALLOC)Entry;
-    PCM_ALLOC_PAGE AllocPage;
-    ULONG i;
-    PAGED_CODE();
-
-    /* Lock the table */
-    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
-
-    /* Add the entry at the end */
-    InsertTailList(&CmpFreeDelayItemsListHead, &AllocEntry->ListEntry);
-
-    /* Get the alloc page */
-    AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)Entry & 0xFFFFF000);
-    ASSERT(AllocPage->FreeCount != CM_DELAYS_PER_PAGE);
-
-    /* Increase the number of free items */
-    if (++AllocPage->FreeCount == CM_DELAYS_PER_PAGE)
-    {
-        /* Page is totally free now, loop each entry */
-        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
-        {
-            /* Get the entry and unlink it */
-            AllocEntry = (PVOID)((ULONG_PTR)AllocPage +
-                                 FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
-                                 i * sizeof(CM_DELAY_ALLOC));
-            RemoveEntryList(&AllocEntry->ListEntry);
-        }
-
-        /* Now free the page */
-        ExFreePool(AllocPage);
-    }
-
-    /* Release the lock */
-    KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
-}
-
-VOID
-NTAPI
-CmpUnlockRegistry(VOID)
-{
-    /* Sanity check */
-    CMP_ASSERT_REGISTRY_LOCK();
-
-    /* Check if we should flush the registry */
-    if (CmpFlushOnLockRelease)
-    {
-        /* The registry should be exclusively locked for this */
-        CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
-
-        /* Flush the registry */
-        CmpFlushEntireRegistry(TRUE);
-        CmpFlushOnLockRelease = FALSE;
-    }
-
-    /* Release the lock and leave the critical region */
-    ExReleaseResourceLite(&CmpRegistryLock);
-    KeLeaveCriticalRegion();
-}
--- a/reactos/ntoskrnl/cm/cmvalue.c
+++ b/reactos/ntoskrnl/cm/cmvalue.c
@@ -1,364 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmvalue.c
- * PURPOSE:         Configuration Manager - Cell Values
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* FUNCTIONS *****************************************************************/
-
-BOOLEAN
-NTAPI
-CmpMarkValueDataDirty(IN PHHIVE Hive,
-                      IN PCM_KEY_VALUE Value)
-{
-    ULONG KeySize;
-    PAGED_CODE();
-
-    /* Make sure there's actually any data */
-    if (Value->Data != HCELL_NIL)
-    {
-        /* If this is a small key, there's no need to have it dirty */
-        if (CmpIsKeyValueSmall(&KeySize, Value->DataLength)) return TRUE;
-
-        /* Check if this is a big key */
-        ASSERT_VALUE_BIG(Hive, KeySize);
-
-        /* Normal value, just mark it dirty */
-        HvMarkCellDirty(Hive, Value->Data, FALSE);
-    }
-
-    /* Operation complete */
-    return TRUE;
-}
-
-BOOLEAN
-NTAPI
-CmpFreeValueData(IN PHHIVE Hive,
-                 IN HCELL_INDEX DataCell,
-                 IN ULONG DataLength)
-{
-    ULONG KeySize;
-    PAGED_CODE();
-
-    /* If this is a small key, the data is built-in */
-    if (!CmpIsKeyValueSmall(&KeySize, DataLength))
-    {
-        /* If there's no data cell, there's nothing to do */
-        if (DataCell == HCELL_NIL) return TRUE;
-
-        /* Make sure the data cell is allocated */
-        //ASSERT(HvIsCellAllocated(Hive, DataCell));
-
-        /* Unsupported value type */
-        ASSERT_VALUE_BIG(Hive, KeySize);
-
-        /* Normal value, just free the data cell */
-        HvFreeCell(Hive, DataCell);
-    }
-
-    /* Operation complete */
-    return TRUE;
-}
-
-BOOLEAN
-NTAPI
-CmpFreeValue(IN PHHIVE Hive,
-             IN HCELL_INDEX Cell)
-{
-    PCM_KEY_VALUE Value;
-    PAGED_CODE();
-
-    /* Get the cell data */
-    Value = (PCM_KEY_VALUE)HvGetCell(Hive, Cell);
-    if (!Value) ASSERT(FALSE);
-
-    /* Free it */
-    if (!CmpFreeValueData(Hive, Value->Data, Value->DataLength))
-    {
-        /* We failed to free the data, return failure */
-        HvReleaseCell(Hive, Cell);
-        return FALSE;
-    }
-
-    /* Release the cell and free it */
-    HvReleaseCell(Hive, Cell);
-    HvFreeCell(Hive, Cell);
-    return TRUE;
-}
-
-HCELL_INDEX
-NTAPI
-CmpFindValueByName(IN PHHIVE Hive,
-                   IN PCM_KEY_NODE KeyNode,
-                   IN PUNICODE_STRING Name)
-{
-    HCELL_INDEX CellIndex;
-
-    /* Call the main function */
-    if (!CmpFindNameInList(Hive,
-                           &KeyNode->ValueList,
-                           Name,
-                           NULL,
-                           &CellIndex))
-    {
-        /* Santy check */
-        ASSERT(CellIndex == HCELL_NIL);
-    }
-
-    /* Return the index */
-    return CellIndex;
-}
-
-BOOLEAN
-NTAPI
-CmpGetValueData(IN PHHIVE Hive,
-                IN PCM_KEY_VALUE Value,
-                IN PULONG Length,
-                OUT PVOID *Buffer,
-                OUT PBOOLEAN BufferAllocated,
-                OUT PHCELL_INDEX CellToRelease)
-{
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT(Value->Signature == CM_KEY_VALUE_SIGNATURE);
-
-    /* Set failure defaults */
-    *BufferAllocated = FALSE;
-    *Buffer = NULL;
-    *CellToRelease = HCELL_NIL;
-
-    /* Check if this is a small key */
-    if (CmpIsKeyValueSmall(Length, Value->DataLength))
-    {
-        /* Return the data immediately */
-        *Buffer = &Value->Data;
-        return TRUE;
-    }
-
-    /* Unsupported */
-    ASSERT_VALUE_BIG(Hive, *Length);
-
-    /* Get the data from the cell */
-    *Buffer = HvGetCell(Hive, Value->Data);
-    if (!(*Buffer)) return FALSE;
-
-    /* Return success and the cell to be released */
-    *CellToRelease = Value->Data;
-    return TRUE;
-}
-
-PCELL_DATA
-NTAPI
-CmpValueToData(IN PHHIVE Hive,
-               IN PCM_KEY_VALUE Value,
-               OUT PULONG Length)
-{
-    PCELL_DATA Buffer;
-    BOOLEAN BufferAllocated;
-    HCELL_INDEX CellToRelease;
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT(Hive->ReleaseCellRoutine == NULL);
-
-    /* Get the actual data */
-    if (!CmpGetValueData(Hive,
-                         Value,
-                         Length,
-                         (PVOID)&Buffer,
-                         &BufferAllocated,
-                         &CellToRelease))
-    {
-        /* We failed */
-        ASSERT(BufferAllocated == FALSE);
-        ASSERT(Buffer == NULL);
-        return NULL;
-    }
-
-    /* This should never happen!*/
-    if (BufferAllocated)
-    {
-        /* Free the buffer and bugcheck */
-        ExFreePool(Buffer);
-        KEBUGCHECKEX(REGISTRY_ERROR, 8, 0, (ULONG_PTR)Hive, (ULONG_PTR)Value);
-    }
-
-    /* Otherwise, return the cell data */
-    return Buffer;
-}
-
-NTSTATUS
-NTAPI
-CmpAddValueToList(IN PHHIVE Hive,
-                  IN HCELL_INDEX ValueCell,
-                  IN ULONG Index,
-                  IN ULONG Type,
-                  IN OUT PCHILD_LIST ChildList)
-{
-    HCELL_INDEX ListCell;
-    ULONG ChildCount, Length, i;
-    PCELL_DATA CellData;
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
-
-    /* Get the number of entries in the child list */
-    ChildCount = ChildList->Count;
-    ChildCount++;
-    if (ChildCount > 1)
-    {
-        /* The cell should be dirty at this point */
-        ASSERT(HvIsCellDirty(Hive, ChildList->List));
-
-        /* Check if we have less then 100 children */
-        if (ChildCount < 100)
-        {
-            /* Allocate just enough as requested */
-            Length = ChildCount * sizeof(HCELL_INDEX);
-        }
-        else
-        {
-            /* Otherwise, we have quite a few, so allocate a batch */
-            Length = ROUND_UP(ChildCount, 100) * sizeof(HCELL_INDEX);
-            if (Length > HBLOCK_SIZE)
-            {
-                /* But make sure we don't allocate beyond our block size */
-                Length = ROUND_UP(Length, HBLOCK_SIZE);
-            }
-        }
-
-        /* Perform the allocation */
-        ListCell = HvReallocateCell(Hive, ChildList->List, Length);
-    }
-    else
-    {
-        /* This is our first child, so allocate a single cell */
-        ListCell = HvAllocateCell(Hive, sizeof(HCELL_INDEX), Type, HCELL_NIL);
-    }
-
-    /* Fail if we couldn't get a cell */
-    if (ListCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Set this cell as the child list's list cell */
-    ChildList->List = ListCell;
-
-    /* Get the actual key list memory */
-    CellData = HvGetCell(Hive, ListCell);
-    ASSERT(CellData != NULL);
-
-    /* Loop all the children */
-    for (i = ChildCount - 1; i > Index; i--)
-    {
-        /* Move them all down */
-        CellData->u.KeyList[i] = CellData->u.KeyList[i - 1];
-    }
-
-    /* Insert us on top now */
-    CellData->u.KeyList[Index] = ValueCell;
-    ChildList->Count = ChildCount;
-
-    /* Release the list cell and make sure the value cell is dirty */
-    HvReleaseCell(Hive, ListCell);
-    ASSERT(HvIsCellDirty(Hive, ValueCell));
-
-    /* We're done here */
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-CmpSetValueDataNew(IN PHHIVE Hive,
-                   IN PVOID Data,
-                   IN ULONG DataSize,
-                   IN ULONG StorageType,
-                   IN HCELL_INDEX ValueCell,
-                   OUT PHCELL_INDEX DataCell)
-{
-    PCELL_DATA CellData;
-    PAGED_CODE();
-    ASSERT(DataSize > CM_KEY_VALUE_SMALL);
-
-    /* Check if this is a big key */
-    ASSERT_VALUE_BIG(Hive, DataSize);
-
-    /* Allocate a data cell */
-    *DataCell = HvAllocateCell(Hive, DataSize, StorageType, HCELL_NIL);
-    if (*DataCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
-
-    /* Get the actual data */
-    CellData = HvGetCell(Hive, *DataCell);
-    if (!CellData) ASSERT(FALSE);
-
-    /* Copy our buffer into it */
-    RtlCopyMemory(CellData, Data, DataSize);
-
-    /* All done */
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-CmpRemoveValueFromList(IN PHHIVE Hive,
-                       IN ULONG Index,
-                       IN OUT PCHILD_LIST ChildList)
-{
-    ULONG Count;
-    PCELL_DATA CellData;
-    HCELL_INDEX NewCell;
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
-
-    /* Get the new count after removal */
-    Count = ChildList->Count - 1;
-    if (Count > 0)
-    {
-        /* Get the actual list array */
-        CellData = HvGetCell(Hive, ChildList->List);
-        if (!CellData) return STATUS_INSUFFICIENT_RESOURCES;
-
-        /* Make sure cells data have been made dirty */
-        ASSERT(HvIsCellDirty(Hive, ChildList->List));
-        ASSERT(HvIsCellDirty(Hive, CellData->u.KeyList[Index]));
-
-        /* Loop the list */
-        while (Index < Count)
-        {
-            /* Move everything up */
-            CellData->u.KeyList[Index] = CellData->u.KeyList[Index + 1];
-            Index++;
-        }
-
-        /* Re-allocate the cell for the list by decreasing the count */
-        NewCell = HvReallocateCell(Hive,
-                                   ChildList->List,
-                                   Count * sizeof(HCELL_INDEX));
-        ASSERT(NewCell != HCELL_NIL);
-        HvReleaseCell(Hive,ChildList->List);
-
-        /* Update the list cell */
-        ChildList->List = NewCell;
-    }
-    else
-    {
-        /* Otherwise, we were the last entry, so free the list entirely */
-        HvFreeCell(Hive, ChildList->List);
-        ChildList->List = HCELL_NIL;
-    }
-
-    /* Update the child list with the new count */
-    ChildList->Count = Count;
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/cm/cmwraprs.c
+++ b/reactos/ntoskrnl/cm/cmwraprs.c
@@ -1,159 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/cmwraprs.c
- * PURPOSE:         Configuration Manager - Wrappers for Hive Operations
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS
-NTAPI
-CmpCreateEvent(IN EVENT_TYPE EventType,
-               OUT PHANDLE EventHandle,
-               OUT PKEVENT *Event)
-{
-    NTSTATUS Status;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-
-    /* Create the event */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               NULL,
-                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                               NULL,
-                               NULL);
-    Status = ZwCreateEvent(EventHandle,
-                           EVENT_ALL_ACCESS,
-                           &ObjectAttributes,
-                           EventType,
-                           FALSE);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Get a pointer to the object itself */
-    Status = ObReferenceObjectByHandle(*EventHandle,
-                                       EVENT_ALL_ACCESS,
-                                       NULL,
-                                       KernelMode,
-                                       (PVOID*)Event,
-                                       NULL);
-    if (!NT_SUCCESS(Status)) ZwClose(*EventHandle);
-
-    /* Return status */
-    return Status;
-}
-
-PVOID
-NTAPI
-CmpAllocate(IN ULONG Size,
-            IN BOOLEAN Paged,
-            IN ULONG Tag)
-{
-    return ExAllocatePoolWithTag(Paged ? PagedPool : NonPagedPool,
-                                 Size,
-                                 Tag);
-}
-
-VOID
-NTAPI
-CmpFree(IN PVOID Ptr,
-        IN ULONG Quota)
-{
-    ExFreePool(Ptr);
-}
-
-BOOLEAN
-NTAPI
-CmpFileRead(IN PHHIVE RegistryHive,
-            IN ULONG FileType,
-            IN PULONG FileOffset,
-            OUT PVOID Buffer,
-            IN SIZE_T BufferLength)
-{
-    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
-    HANDLE HiveHandle = CmHive->FileHandles[FileType];
-    LARGE_INTEGER _FileOffset;
-    IO_STATUS_BLOCK IoStatusBlock;
-    NTSTATUS Status;
-
-    _FileOffset.QuadPart = *FileOffset;
-    Status = ZwReadFile(HiveHandle, 0, 0, 0, &IoStatusBlock,
-                       Buffer, BufferLength, &_FileOffset, 0);
-    return NT_SUCCESS(Status) ? TRUE : FALSE;
-}
-
-BOOLEAN
-NTAPI
-CmpFileWrite(IN PHHIVE RegistryHive,
-             IN ULONG FileType,
-             IN PULONG FileOffset,
-             IN PVOID Buffer,
-             IN SIZE_T BufferLength)
-{
-    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
-    HANDLE HiveHandle = CmHive->FileHandles[FileType];
-    LARGE_INTEGER _FileOffset;
-    IO_STATUS_BLOCK IoStatusBlock;
-    NTSTATUS Status;
-
-    _FileOffset.QuadPart = *FileOffset;
-    Status = ZwWriteFile(HiveHandle, 0, 0, 0, &IoStatusBlock,
-                       Buffer, BufferLength, &_FileOffset, 0);
-    return NT_SUCCESS(Status) ? TRUE : FALSE;
-}
-
-BOOLEAN
-NTAPI
-CmpFileSetSize(IN PHHIVE RegistryHive,
-               IN ULONG FileType,
-               IN ULONG FileSize,
-               IN ULONG OldFileSize)
-{
-    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
-    HANDLE HiveHandle = CmHive->FileHandles[FileType];
-    FILE_END_OF_FILE_INFORMATION EndOfFileInfo;
-    FILE_ALLOCATION_INFORMATION FileAllocationInfo;
-    IO_STATUS_BLOCK IoStatusBlock;
-    NTSTATUS Status;
-
-    EndOfFileInfo.EndOfFile.QuadPart = FileSize;
-    Status = ZwSetInformationFile(HiveHandle,
-                                  &IoStatusBlock,
-                                  &EndOfFileInfo,
-                                  sizeof(FILE_END_OF_FILE_INFORMATION),
-                                  FileEndOfFileInformation);
-    if (!NT_SUCCESS(Status)) return FALSE;
-
-    FileAllocationInfo.AllocationSize.QuadPart = FileSize;
-    Status = ZwSetInformationFile(HiveHandle,
-                                  &IoStatusBlock,
-                                  &FileAllocationInfo,
-                                  sizeof(FILE_ALLOCATION_INFORMATION),
-                                  FileAllocationInformation);
-    if (!NT_SUCCESS(Status)) return FALSE;
-
-    return TRUE;
-}
-
-BOOLEAN
-NTAPI
-CmpFileFlush(IN PHHIVE RegistryHive,
-             IN ULONG FileType,
-             IN OUT PLARGE_INTEGER FileOffset,
-             IN ULONG Length)
-{
-    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
-    HANDLE HiveHandle = CmHive->FileHandles[FileType];
-    IO_STATUS_BLOCK IoStatusBlock;
-    NTSTATUS Status;
-
-    Status = ZwFlushBuffersFile(HiveHandle, &IoStatusBlock);
-    return NT_SUCCESS(Status) ? TRUE : FALSE;
-}
--- a/reactos/ntoskrnl/cm/i386/cmhardwr.c
+++ b/reactos/ntoskrnl/cm/i386/cmhardwr.c
@@ -1,834 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/config/i386/cmhardwr.c
- * PURPOSE:         Configuration Manager - Hardware-Specific Code
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "ntoskrnl.h"
-#include "../cm.h"
-#define NDEBUG
-#include "debug.h"
-
-/* GLOBALS *******************************************************************/
-
-PCHAR CmpID1 = "80%u86-%c%x";
-PCHAR CmpID2 = "x86 Family %u Model %u Stepping %u";
-PCHAR CmpBiosStrings[] =
-{
-    "Ver",
-    "Rev",
-    "Rel",
-    "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
-    "v 0", "v 1", "v 2", "v 3", "v 4", "v 5", "v 6", "v 7", "v 8", "v 9",
-    NULL
-};
-
-PCHAR CmpBiosBegin, CmpBiosSearchStart, CmpBiosSearchEnd;
-
-/* FUNCTIONS *****************************************************************/
-
-BOOLEAN
-NTAPI
-CmpGetBiosDate(IN PCHAR BiosStart,
-               IN ULONG BiosLength,
-               IN PCHAR BiosDate,
-               IN BOOLEAN FromBios)
-{
-    CHAR LastDate[11] = {0}, CurrentDate[11];
-    PCHAR p, pp;
-
-    /* Skip the signature and the magic, and loop the BIOS ROM */
-    p = BiosStart + 2;
-    pp = BiosStart + BiosLength - 5;
-    while (p < pp)
-    {
-        /* Check for xx/yy/zz which we assume to be a date */
-        if ((p[0] == '/') &&
-            (p[3] == '/') &&
-            (isdigit(p[-1])) &&
-            (isdigit(p[1])) &&
-            (isdigit(p[2])) &&
-            (isdigit(p[4])) &&
-            (isdigit(p[5])))
-        {
-            /* Copy the string proper */
-            RtlMoveMemory(&CurrentDate[5], p - 2, 5);
-
-            /* Add a 0 if the month only has one digit */
-            if (!isdigit(CurrentDate[5])) CurrentDate[5] = '0';
-
-            /* Now copy the year */
-            CurrentDate[2] = p[4];
-            CurrentDate[3] = p[5];
-            CurrentDate[4] = CurrentDate[7] = CurrentDate[10] = ANSI_NULL;
-
-            /* If the date comes from the BIOS, check if it's a 4-digit year */
-            if ((FromBios) &&
-                (isdigit(p[6])) &&
-                (isdigit(p[7])) &&
-                ((RtlEqualMemory(&p[4], "19", 2)) ||
-                 (RtlEqualMemory(&p[4], "20", 2))))
-            {
-                /* Copy the year proper */
-                CurrentDate[0] = p[4];
-                CurrentDate[1] = p[5];
-                CurrentDate[2] = p[6];
-                CurrentDate[3] = p[7];
-            }
-            else
-            {
-                /* Otherwise, we'll just assume anything under 80 is 2000 */
-                if (strtoul(&CurrentDate[2], NULL, 10) < 80)
-                {
-                    /* Hopefully your BIOS wasn't made in 1979 */
-                    CurrentDate[0] = '2';
-                    CurrentDate[1] = '0';
-                }
-                else
-                {
-                    /* Anything over 80, was probably made in the 1900s... */
-                    CurrentDate[0] = '1';
-                    CurrentDate[1] = '9';
-                }
-            }
-
-            /* Add slashes were we previously had NULLs */
-            CurrentDate[4] = CurrentDate[7] = '/';
-
-            /* Check which date is newer */
-            if (memcmp(LastDate, CurrentDate, 10) < 0)
-            {
-                /* Found a newer date, select it */
-                RtlMoveMemory(LastDate, CurrentDate, 10);
-            }
-
-            p += 2;
-        }
-        p++;
-    }
-
-    /* Make sure we found a date */
-    if (LastDate[0])
-    {
-        /* Copy the year at the pp, and keep only the last two digits */
-        RtlMoveMemory(BiosDate, &LastDate[5], 5);
-        BiosDate[5] = '/';
-        BiosDate[6] = LastDate[2];
-        BiosDate[7] = LastDate[3];
-        BiosDate[8] = ANSI_NULL;
-        return TRUE;
-    }
-
-    /* No date found, return empty string */
-    BiosDate[0] = ANSI_NULL;
-    return FALSE;
-}
-
-BOOLEAN
-NTAPI
-CmpGetBiosVersion(IN PCHAR BiosStart,
-                  IN ULONG BiosLength,
-                  IN PCHAR BiosVersion)
-{
-    CHAR Buffer[128];
-    PCHAR p, pp;
-    USHORT i;
-
-    /* Check if we were given intitial data for the search */
-    if (BiosStart)
-    {
-        /* Save it for later use */
-        CmpBiosBegin = BiosStart;
-        CmpBiosSearchStart = BiosStart + 1;
-        CmpBiosSearchEnd = BiosStart + BiosLength - 2;
-    }
-
-    /* Now loop the BIOS area */
-    for (;;)
-    {
-        /* Start an initial search looking for numbers and periods */
-        pp = NULL;
-        while (CmpBiosSearchStart <= CmpBiosSearchEnd)
-        {
-            /* Check if we have an "x.y" version string */
-            if ((*CmpBiosSearchStart == '.') &&
-                (*(CmpBiosSearchStart + 1) >= '0') &&
-                (*(CmpBiosSearchStart + 1) <= '9') &&
-                (*(CmpBiosSearchStart - 1) >= '0') &&
-                (*(CmpBiosSearchStart - 1) <= '9'))
-            {
-                /* Start looking in this area for the actual BIOS Version */
-                pp = CmpBiosSearchStart;
-                break;
-            }
-            else
-            {
-                /* Keep searching */
-                CmpBiosSearchStart++;
-            }
-        }
-
-        /* Break out if we're went past the BIOS area */
-        if (CmpBiosSearchStart > CmpBiosSearchEnd) return FALSE;
-
-        /* Move to the next 2 bytes */
-        CmpBiosSearchStart += 2;
-
-        /* Null-terminate our scratch buffer and start the string here */
-        Buffer[127] = ANSI_NULL;
-        p = &Buffer[127];
-
-        /* Go back one character since we're doing this backwards */
-        pp--;
-
-        /* Loop the identifier we found as long as it's valid */
-        i = 0;
-        while ((i++ < 127) &&
-               (pp >= CmpBiosBegin) &&
-               (*pp >= ' ') &&
-               (*pp != '$'))
-        {
-            /* Copy the character */
-            *--p = *pp--;
-        }
-
-        /* Go past the last character since we went backwards */
-        pp++;
-
-        /* Loop the strings we recognize */
-        for (i = 0; CmpBiosStrings[i]; i++)
-        {
-            /* Check if a match was found */
-            if (strstr(p, CmpBiosStrings[i])) goto Match;
-        }
-    }
-
-Match:
-    /* Skip until we find a space */
-    for (; *pp == ' '; pp++);
-
-    /* Loop the final string */
-    i = 0;
-    do
-    {
-        /* Copy the character into the final string */
-        BiosVersion[i] = *pp++;
-    } while ((++i < 127) &&
-             (pp <= (CmpBiosSearchEnd + 1)) &&
-             (*pp >= ' ') &&
-             (*pp != '$'));
-
-    /* Null-terminate the version string */
-    BiosVersion[i] = ANSI_NULL;
-    return TRUE;
-}
-
-NTSTATUS
-NTAPI
-CmpInitializeMachineDependentConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
-{
-    UNICODE_STRING KeyName, ValueName, Data, SectionName;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    ULONG HavePae, CacheSize, ViewSize, Length, TotalLength = 0, i, Disposition;
-    NTSTATUS Status;
-    HANDLE KeyHandle, BiosHandle, SystemHandle, FpuHandle, SectionHandle;
-    CONFIGURATION_COMPONENT_DATA ConfigData;
-    CHAR Buffer[128];
-    ULONG ExtendedId, Dummy;
-    PKPRCB Prcb;
-    USHORT IndexTable[MaximumType + 1] = {0};
-    ANSI_STRING TempString;
-    PCHAR PartialString = NULL, BiosVersion;
-    CHAR CpuString[48];
-    PVOID BaseAddress = NULL;
-    LARGE_INTEGER ViewBase = {{0}};
-    ULONG_PTR VideoRomBase;
-    PCHAR CurrentVersion;
-    extern UNICODE_STRING KeRosProcessorName, KeRosBiosDate, KeRosBiosVersion;
-    extern UNICODE_STRING KeRosVideoBiosDate, KeRosVideoBiosVersion;
-
-    /* Open the SMSS Memory Management key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
-                         L"Control\\Session Manager\\Memory Management");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtOpenKey(&KeyHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
-    if (NT_SUCCESS(Status))
-    {
-        /* Detect if PAE is enabled */
-        HavePae = SharedUserData->ProcessorFeatures[PF_PAE_ENABLED];
-
-        /* Set the value */
-        RtlInitUnicodeString(&ValueName, L"PhysicalAddressExtension");
-        NtSetValueKey(KeyHandle,
-                      &ValueName,
-                      0,
-                      REG_DWORD,
-                      &HavePae,
-                      sizeof(HavePae));
-
-        /* Close the key */
-        NtClose(KeyHandle);
-    }
-
-    /* Open the hardware description key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\Hardware\\Description\\System");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtOpenKey(&SystemHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Create the BIOS Information key */
-    RtlInitUnicodeString(&KeyName,
-                         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
-                         L"Control\\BIOSINFO");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = NtCreateKey(&BiosHandle,
-                         KEY_ALL_ACCESS,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         REG_OPTION_NON_VOLATILE,
-                         &Disposition);
-    if (ExpInTextModeSetup)
-    {
-        if (!NT_SUCCESS(Status))
-            BiosHandle = NULL;
-    }
-    else if (!NT_SUCCESS(Status))
-        return Status;
-
-    /* Create the CPU Key, and check if it already existed */
-    RtlInitUnicodeString(&KeyName, L"CentralProcessor");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               SystemHandle,
-                               NULL);
-    Status = NtCreateKey(&KeyHandle,
-                         KEY_READ | KEY_WRITE,
-                         &ObjectAttributes,
-                         0,
-                         NULL,
-                         0,
-                         &Disposition);
-    NtClose(KeyHandle);
-
-    /* The key shouldn't already exist */
-    if (Disposition == REG_CREATED_NEW_KEY)
-    {
-        /* Allocate the configuration data for cmconfig.c */
-        CmpConfigurationData = ExAllocatePoolWithTag(PagedPool,
-                                                     CmpConfigurationAreaSize,
-                                                     TAG_CM);
-        if (!CmpConfigurationData) return STATUS_INSUFFICIENT_RESOURCES;
-
-        /* Loop all CPUs */
-        for (i = 0; i < KeNumberProcessors; i++)
-        {
-            /* Get the PRCB */
-            Prcb = KiProcessorBlock[i];
-
-            /* Setup the Configuration Entry for the Processor */
-            RtlZeroMemory(&ConfigData, sizeof (ConfigData));
-            ConfigData.ComponentEntry.Class = ProcessorClass;
-            ConfigData.ComponentEntry.Type = CentralProcessor;
-            ConfigData.ComponentEntry.Key = i;
-            ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
-            ConfigData.ComponentEntry.Identifier = Buffer;
-
-            /* Check if the CPU doesn't support CPUID */
-            if (!Prcb->CpuID)
-            {
-                /* Build ID1-style string for older CPUs */
-                sprintf(Buffer,
-                        CmpID1,
-                        Prcb->CpuType,
-                        (Prcb->CpuStep >> 8) + 'A',
-                        Prcb->CpuStep & 0xff);
-            }
-            else
-            {
-                /* Build ID2-style string for newer CPUs */
-                sprintf(Buffer,
-                        CmpID2,
-                        Prcb->CpuType,
-                        (Prcb->CpuStep >> 8),
-                        Prcb->CpuStep & 0xff);
-            }
-
-            /* Save the ID string length now that we've created it */
-            ConfigData.ComponentEntry.IdentifierLength = strlen(Buffer) + 1;
-
-            /* Initialize the registry configuration node for it */
-            Status = CmpInitializeRegistryNode(&ConfigData,
-                                               SystemHandle,
-                                               &KeyHandle,
-                                               InterfaceTypeUndefined,
-                                               0xFFFFFFFF,
-                                               IndexTable);
-            if (!NT_SUCCESS(Status)) return(Status);
-
-            /* Check if we have an FPU */
-            if (KeI386NpxPresent)
-            {
-                /* Setup the Configuration Entry for the FPU */
-                RtlZeroMemory(&ConfigData, sizeof(ConfigData));
-                ConfigData.ComponentEntry.Class = ProcessorClass;
-                ConfigData.ComponentEntry.Type = FloatingPointProcessor;
-                ConfigData.ComponentEntry.Key = i;
-                ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
-                ConfigData.ComponentEntry.Identifier = Buffer;
-
-                /* For 386 cpus, the CPU pp is the identifier */
-                if (Prcb->CpuType == 3) strcpy(Buffer, "80387");
-
-                /* Save the ID string length now that we've created it */
-                ConfigData.ComponentEntry.IdentifierLength = strlen(Buffer) + 1;
-
-                /* Initialize the registry configuration node for it */
-                Status = CmpInitializeRegistryNode(&ConfigData,
-                                                   SystemHandle,
-                                                   &FpuHandle,
-                                                   InterfaceTypeUndefined,
-                                                   0xFFFFFFFF,
-                                                   IndexTable);
-                if (!NT_SUCCESS(Status))
-                {
-                    /* Failed, close the CPU handle and return */
-                    NtClose(KeyHandle);
-                    return Status;
-                }
-
-                /* Close this new handle */
-                NtClose(FpuHandle);
-
-                /* Stay on this CPU only */
-                KeSetSystemAffinityThread(Prcb->SetMember);
-                if (!Prcb->CpuID)
-                {
-                    /* Uh oh, no CPUID! */
-                }
-                else
-                {
-                    /* Check if we have extended CPUID that supports name ID */
-                    Ki386Cpuid(0x80000000, &ExtendedId, &Dummy, &Dummy, &Dummy);
-                    if (ExtendedId >= 0x80000004)
-                    {
-                        /* Do all the CPUIDs requred to get the full name */
-                        PartialString = CpuString;
-                        for (ExtendedId = 2; ExtendedId <= 4; ExtendedId++)
-                        {
-                            /* Do the CPUID and save the name string */
-                            Ki386Cpuid(0x80000000 | ExtendedId,
-                                       (PULONG)PartialString,
-                                       (PULONG)PartialString + 1,
-                                       (PULONG)PartialString + 2,
-                                       (PULONG)PartialString + 3);
-
-                            /* Go to the next name string */
-                            PartialString += 16;
-                        }
-
-                        /* Null-terminate it */
-                        CpuString[48] = ANSI_NULL;
-                    }
-                }
-
-                /* Get the cache size while we're still localized */
-                CacheSize = ((PKIPCR)KeGetPcr())->SecondLevelCacheSize;
-
-                /* Go back to user affinity */
-                KeRevertToUserAffinityThread();
-
-                /* Check if we have a CPU Name */
-                if (PartialString)
-                {
-                    /* Convert it to Unicode */
-                    RtlInitAnsiString(&TempString, CpuString);
-                    RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-                    /* Add it to the registry */
-                    RtlInitUnicodeString(&ValueName, L"ProcessorNameString");
-                    Status = NtSetValueKey(KeyHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_SZ,
-                                           Data.Buffer,
-                                           Data.Length + sizeof(UNICODE_NULL));
-
-                    /* ROS: Save a copy for bugzilla reporting */
-                    RtlCreateUnicodeString(&KeRosProcessorName, Data.Buffer);
-
-                    /* Free the temporary buffer */
-                    RtlFreeUnicodeString(&Data);
-                }
-
-                /* Check if we had a Vendor ID */
-                if (Prcb->VendorString)
-                {
-                    /* Convert it to Unicode */
-                    RtlInitAnsiString(&TempString, Prcb->VendorString);
-                    RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-                    /* Add it to the registry */
-                    RtlInitUnicodeString(&ValueName, L"VendorIdentifier");
-                    Status = NtSetValueKey(KeyHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_SZ,
-                                           Data.Buffer,
-                                           Data.Length + sizeof(UNICODE_NULL));
-
-                    /* Free the temporary buffer */
-                    RtlFreeUnicodeString(&Data);
-                }
-
-                /* Check if we have features bits */
-                if (Prcb->FeatureBits)
-                {
-                    /* Add them to the registry */
-                    RtlInitUnicodeString(&ValueName, L"FeatureSet");
-                    Status = NtSetValueKey(KeyHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_DWORD,
-                                           &Prcb->FeatureBits,
-                                           sizeof(Prcb->FeatureBits));
-                }
-
-                /* Check if we detected the CPU Speed */
-                if (Prcb->MHz)
-                {
-                    /* Add it to the registry */
-                    RtlInitUnicodeString(&ValueName, L"~MHz");
-                    Status = NtSetValueKey(KeyHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_DWORD,
-                                           &Prcb->MHz,
-                                           sizeof(Prcb->MHz));
-                }
-
-                /* Check if we have an update signature */
-                if (Prcb->UpdateSignature.QuadPart)
-                {
-                    /* Add it to the registry */
-                    RtlInitUnicodeString(&ValueName, L"Update Signature");
-                    Status = NtSetValueKey(KeyHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_BINARY,
-                                           &Prcb->UpdateSignature,
-                                           sizeof(Prcb->UpdateSignature));
-                }
-
-                /* Close the processor handle */
-                NtClose(KeyHandle);
-
-                /* FIXME: Detect CPU mismatches */
-            }
-        }
-
-        /* Free the configuration data */
-        ExFreePool(CmpConfigurationData);
-    }
-
-    /* Open physical memory */
-    RtlInitUnicodeString(&SectionName, L"\\Device\\PhysicalMemory");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &SectionName,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = ZwOpenSection(&SectionHandle,
-                           SECTION_ALL_ACCESS,
-                           &ObjectAttributes);
-    if (!NT_SUCCESS(Status)) goto Quickie;
-
-    /* Map the first 1KB of memory to get the IVT */
-    ViewSize = PAGE_SIZE;
-    Status = ZwMapViewOfSection(SectionHandle,
-                                NtCurrentProcess(),
-                                &BaseAddress,
-                                0,
-                                ViewSize,
-                                &ViewBase,
-                                &ViewSize,
-                                ViewUnmap,
-                                MEM_DOS_LIM,
-                                PAGE_READWRITE);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Assume default */
-        VideoRomBase = 0xC0000;
-    }
-    else
-    {
-        /* Calculate the base address from the vector */
-        VideoRomBase = (*((PULONG)BaseAddress + 0x10) >> 12) & 0xFFFF0;
-        VideoRomBase += *((PULONG)BaseAddress + 0x10) & 0xFFF0;
-
-        /* Now get to the actual ROM Start and make sure it's not invalid*/
-        VideoRomBase &= 0xFFFF8000;
-        if (VideoRomBase < 0xC0000) VideoRomBase = 0xC0000;
-
-        /* And unmap the section */
-        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
-    }
-
-    /* Allocate BIOS Version pp Buffer */
-    BiosVersion = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM);
-
-    /* Setup settings to map the 64K BIOS ROM */
-    BaseAddress = 0;
-    ViewSize = 16 * PAGE_SIZE;
-    ViewBase.LowPart = 0xF0000;
-    ViewBase.HighPart = 0;
-
-    /* Map it */
-    Status = ZwMapViewOfSection(SectionHandle,
-                                NtCurrentProcess(),
-                                &BaseAddress,
-                                0,
-                                ViewSize,
-                                &ViewBase,
-                                &ViewSize,
-                                ViewUnmap,
-                                MEM_DOS_LIM,
-                                PAGE_READWRITE);
-    if (NT_SUCCESS(Status))
-    {
-        /* Scan the ROM to get the BIOS Date */
-        if (CmpGetBiosDate(BaseAddress, 16 * PAGE_SIZE, Buffer, TRUE))
-        {
-            /* Convert it to Unicode */
-            RtlInitAnsiString(&TempString, Buffer);
-            RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-            /* Write the date into the registry */
-            RtlInitUnicodeString(&ValueName, L"SystemBiosDate");
-            Status = NtSetValueKey(SystemHandle,
-                                   &ValueName,
-                                   0,
-                                   REG_SZ,
-                                   Data.Buffer,
-                                   Data.Length + sizeof(UNICODE_NULL));
-
-            /* Free the string */
-            RtlFreeUnicodeString(&Data);
-
-            if (BiosHandle)
-            {
-                /* Get the BIOS Date Identifier */
-                RtlCopyMemory(Buffer, (PCHAR)BaseAddress + (16*PAGE_SIZE - 11), 8);
-                Buffer[8] = ANSI_NULL;
-
-                /* Convert it to unicode */
-                RtlInitAnsiString(&TempString, Buffer);
-                Status = RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-                if (NT_SUCCESS(Status))
-                {
-                    /* Save it to the registry */
-                    Status = NtSetValueKey(BiosHandle,
-                                           &ValueName,
-                                           0,
-                                           REG_SZ,
-                                           Data.Buffer,
-                                           Data.Length + sizeof(UNICODE_NULL));
-
-                    /* ROS: Save a copy for bugzilla reporting */
-                    RtlCreateUnicodeString(&KeRosBiosDate, Data.Buffer);
-
-                    /* Free the string */
-                    RtlFreeUnicodeString(&Data);
-                }
-
-                /* Close the bios information handle */
-                NtClose(BiosHandle);
-            }
-        }
-
-        /* Get the BIOS Version */
-        if (CmpGetBiosVersion(BaseAddress, 16* PAGE_SIZE, Buffer))
-        {
-            /* Start at the beginning of our buffer */
-            CurrentVersion = BiosVersion;
-            do
-            {
-                /* Convert to Unicode */
-                RtlInitAnsiString(&TempString, Buffer);
-                RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-                /* Calculate the length of this string and copy it in */
-                Length = Data.Length + sizeof(UNICODE_NULL);
-                RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
-
-                /* Free the unicode string */
-                RtlFreeUnicodeString(&Data);
-
-                /* Update the total length and see if we're out of space */
-                TotalLength += Length;
-                if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
-                {
-                    /* One more string would push us out, so stop here */
-                    break;
-                }
-
-                /* Go to the next string inside the multi-string buffer */
-                CurrentVersion += Length;
-
-                /* Query the next BIOS Version */
-            } while (CmpGetBiosVersion(NULL, 0, Buffer));
-
-            /* Check if we found any strings at all */
-            if (TotalLength)
-            {
-                /* Add the final null-terminator */
-                *(PWSTR)CurrentVersion = UNICODE_NULL;
-                TotalLength += sizeof(UNICODE_NULL);
-
-                /* Write the BIOS Version to the registry */
-                RtlInitUnicodeString(&ValueName, L"SystemBiosVersion");
-                Status = NtSetValueKey(SystemHandle,
-                                       &ValueName,
-                                       0,
-                                       REG_MULTI_SZ,
-                                       BiosVersion,
-                                       TotalLength);
-
-                /* ROS: Save a copy for bugzilla reporting */
-                RtlCreateUnicodeString(&KeRosBiosVersion, (PWCH)BiosVersion);
-            }
-        }
-
-        /* Unmap the section */
-        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
-    }
-
-    /* Now prepare for Video BIOS Mapping of 32KB */
-    BaseAddress = 0;
-    ViewSize = 8 * PAGE_SIZE;
-    ViewBase.LowPart = VideoRomBase;
-    ViewBase.HighPart = 0;
-
-    /* Map it */
-    Status = ZwMapViewOfSection(SectionHandle,
-                                NtCurrentProcess(),
-                                &BaseAddress,
-                                0,
-                                ViewSize,
-                                &ViewBase,
-                                &ViewSize,
-                                ViewUnmap,
-                                MEM_DOS_LIM,
-                                PAGE_READWRITE);
-    if (NT_SUCCESS(Status))
-    {
-        /* Scan the ROM to get the BIOS Date */
-        if (CmpGetBiosDate(BaseAddress, 8 * PAGE_SIZE, Buffer, FALSE))
-        {
-            /* Convert it to Unicode */
-            RtlInitAnsiString(&TempString, Buffer);
-            RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-            /* Write the date into the registry */
-            RtlInitUnicodeString(&ValueName, L"VideoBiosDate");
-            Status = NtSetValueKey(SystemHandle,
-                                   &ValueName,
-                                   0,
-                                   REG_SZ,
-                                   Data.Buffer,
-                                   Data.Length + sizeof(UNICODE_NULL));
-
-            /* ROS: Save a copy for bugzilla reporting */
-            RtlCreateUnicodeString(&KeRosVideoBiosDate, Data.Buffer);
-
-            /* Free the string */
-            RtlFreeUnicodeString(&Data);
-        }
-
-        /* Get the Video BIOS Version */
-        if (CmpGetBiosVersion(BaseAddress, 8* PAGE_SIZE, Buffer))
-        {
-            /* Start at the beginning of our buffer */
-            CurrentVersion = BiosVersion;
-            do
-            {
-                /* Convert to Unicode */
-                RtlInitAnsiString(&TempString, Buffer);
-                RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
-
-                /* Calculate the length of this string and copy it in */
-                Length = Data.Length + sizeof(UNICODE_NULL);
-                RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
-
-                /* Free the unicode string */
-                RtlFreeUnicodeString(&Data);
-
-                /* Update the total length and see if we're out of space */
-                TotalLength += Length;
-                if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
-                {
-                    /* One more string would push us out, so stop here */
-                    break;
-                }
-
-                /* Go to the next string inside the multi-string buffer */
-                CurrentVersion += Length;
-
-                /* Query the next BIOS Version */
-            } while (CmpGetBiosVersion(NULL, 0, Buffer));
-
-            /* Check if we found any strings at all */
-            if (TotalLength)
-            {
-                /* Add the final null-terminator */
-                *(PWSTR)CurrentVersion = UNICODE_NULL;
-                TotalLength += sizeof(UNICODE_NULL);
-
-                /* Write the BIOS Version to the registry */
-                RtlInitUnicodeString(&ValueName, L"VideoBiosVersion");
-                Status = NtSetValueKey(SystemHandle,
-                                       &ValueName,
-                                       0,
-                                       REG_MULTI_SZ,
-                                       BiosVersion,
-                                       TotalLength);
-
-                /* ROS: Save a copy for bugzilla reporting */
-                RtlCreateUnicodeString(&KeRosVideoBiosVersion, (PWCH)BiosVersion);
-            }
-        }
-
-        /* Unmap the section */
-        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
-    }
-
-    /* Close the section */
-    ZwClose(SectionHandle);
-
-    /* Free the BIOS version string buffer */
-    if (BiosVersion) ExFreePool(BiosVersion);
-
-Quickie:
-    /* Close the procesor handle */
-    NtClose(KeyHandle);
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/cm/ntapi.c
+++ b/reactos/ntoskrnl/cm/ntapi.c
@@ -1,370 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/cm/ntapi.c
- * PURPOSE:         Native API Routines for Registry Access.
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS
-NTAPI
-NtCreateKey(OUT PHANDLE KeyHandle,
-            IN ACCESS_MASK DesiredAccess,
-            IN POBJECT_ATTRIBUTES ObjectAttributes,
-            IN ULONG TitleIndex,
-            IN PUNICODE_STRING Class,
-            IN ULONG CreateOptions,
-            OUT PULONG Disposition)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED; 
-}
-
-NTSTATUS
-NTAPI
-NtOpenKey(OUT PHANDLE KeyHandle,
-          IN ACCESS_MASK DesiredAccess,
-          IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;  
-}
-
-NTSTATUS
-NTAPI
-NtFlushKey(IN HANDLE KeyHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtLoadKey2 (IN POBJECT_ATTRIBUTES KeyObjectAttributes,
-            IN POBJECT_ATTRIBUTES FileObjectAttributes,
-            IN ULONG Flags)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtInitializeRegistry(IN USHORT Flag)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-
-NTSTATUS
-NTAPI
-NtDeleteKey(IN HANDLE KeyHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtEnumerateKey(IN HANDLE KeyHandle,
-               IN ULONG Index,
-               IN KEY_INFORMATION_CLASS KeyInformationClass,
-               OUT PVOID KeyInformation,
-               IN ULONG Length,
-               OUT PULONG ResultLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtEnumerateValueKey(IN HANDLE KeyHandle,
-                    IN ULONG Index,
-                    IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
-                    OUT PVOID KeyValueInformation,
-                    IN ULONG Length,
-                    OUT PULONG ResultLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED; 
-}
-
-NTSTATUS
-NTAPI
-NtQueryKey(IN HANDLE KeyHandle,
-           IN KEY_INFORMATION_CLASS KeyInformationClass,
-           OUT PVOID KeyInformation,
-           IN ULONG Length,
-           OUT PULONG ResultLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtQueryValueKey(IN HANDLE KeyHandle,
-                IN PUNICODE_STRING ValueName,
-                IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
-                OUT PVOID KeyValueInformation,
-                IN ULONG Length,
-                OUT PULONG ResultLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSetValueKey(IN HANDLE KeyHandle,
-              IN PUNICODE_STRING ValueName,
-              IN ULONG TitleIndex,
-              IN ULONG Type,
-              IN PVOID Data,
-              IN ULONG DataSize)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED; 
-}
-
-NTSTATUS
-NTAPI
-NtDeleteValueKey(IN HANDLE KeyHandle,
-                 IN PUNICODE_STRING ValueName)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtCompactKeys(IN ULONG Count,
-              IN PHANDLE KeyArray)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtCompressKey(IN HANDLE Key)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtLoadKey(IN POBJECT_ATTRIBUTES KeyObjectAttributes,
-          IN POBJECT_ATTRIBUTES FileObjectAttributes)
-{
-    return NtLoadKey2(KeyObjectAttributes, FileObjectAttributes, 0);
-}
-
-NTSTATUS
-NTAPI
-NtLoadKeyEx(IN POBJECT_ATTRIBUTES TargetKey,
-            IN POBJECT_ATTRIBUTES SourceFile,
-            IN ULONG Flags,
-            IN HANDLE TrustClassKey,
-            IN HANDLE Event,
-            IN ACCESS_MASK DesiredAccess,
-            OUT PHANDLE RootHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtLockProductActivationKeys(IN PULONG pPrivateVer,
-                            IN PULONG pSafeMode)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtLockRegistryKey(IN HANDLE KeyHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtNotifyChangeMultipleKeys(IN HANDLE MasterKeyHandle,
-                           IN ULONG Count,
-                           IN POBJECT_ATTRIBUTES SlaveObjects,
-                           IN HANDLE Event,
-                           IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
-                           IN PVOID ApcContext OPTIONAL,
-                           OUT PIO_STATUS_BLOCK IoStatusBlock,
-                           IN ULONG CompletionFilter,
-                           IN BOOLEAN WatchTree,
-                           OUT PVOID Buffer,
-                           IN ULONG Length,
-                           IN BOOLEAN Asynchronous)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtNotifyChangeKey(IN HANDLE KeyHandle,
-                  IN HANDLE Event,
-                  IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
-                  IN PVOID ApcContext OPTIONAL,
-                  OUT PIO_STATUS_BLOCK IoStatusBlock,
-                  IN ULONG CompletionFilter,
-                  IN BOOLEAN WatchTree,
-                  OUT PVOID Buffer,
-                  IN ULONG Length,
-                  IN BOOLEAN Asynchronous)
-{
-     return NtNotifyChangeMultipleKeys(KeyHandle,
-                                       0,
-                                       NULL,
-                                       Event,
-                                       ApcRoutine,
-                                       ApcContext,
-                                       IoStatusBlock,
-                                       CompletionFilter,
-                                       WatchTree,
-                                       Buffer,
-                                       Length,
-                                       Asynchronous);
-}
-
-NTSTATUS
-NTAPI
-NtQueryMultipleValueKey(IN HANDLE KeyHandle,
-                        IN OUT PKEY_VALUE_ENTRY ValueList,
-                        IN ULONG NumberOfValues,
-                        OUT PVOID Buffer,
-                        IN OUT PULONG Length,
-                        OUT PULONG ReturnLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtQueryOpenSubKeys(IN POBJECT_ATTRIBUTES TargetKey,
-                   IN ULONG HandleCount)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtQueryOpenSubKeysEx(IN POBJECT_ATTRIBUTES TargetKey,
-                     IN ULONG BufferLength,
-                     IN PVOID Buffer,
-                     IN PULONG RequiredSize)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtReplaceKey(IN POBJECT_ATTRIBUTES ObjectAttributes,
-             IN HANDLE Key,
-             IN POBJECT_ATTRIBUTES ReplacedObjectAttributes)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtRestoreKey(IN HANDLE KeyHandle,
-             IN HANDLE FileHandle,
-             IN ULONG RestoreFlags)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSaveKey(IN HANDLE KeyHandle,
-          IN HANDLE FileHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSaveKeyEx(IN HANDLE KeyHandle,
-            IN HANDLE FileHandle,
-            IN ULONG Flags)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSaveMergedKeys(IN HANDLE HighPrecedenceKeyHandle,
-                 IN HANDLE LowPrecedenceKeyHandle,
-                 IN HANDLE FileHandle)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSetInformationKey(IN HANDLE KeyHandle,
-                    IN KEY_SET_INFORMATION_CLASS KeyInformationClass,
-                    IN PVOID KeyInformation,
-                    IN ULONG KeyInformationLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtUnloadKey(IN POBJECT_ATTRIBUTES KeyObjectAttributes)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtUnloadKey2(IN POBJECT_ATTRIBUTES TargetKey,
-             IN ULONG Flags)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtUnloadKeyEx(IN POBJECT_ATTRIBUTES TargetKey,
-              IN HANDLE Event)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/dbgk/dbgkutil.c
+++ b/reactos/ntoskrnl/dbgk/dbgkutil.c
@@ -1,71 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/dbgk/dbgkutil.c
- * PURPOSE:         User-Mode Debugging Support, Internal Debug Functions.
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-DbgkCreateThread(PVOID StartAddress)
-{
-#if 0
-    LPC_DBG_MESSAGE Message;
-    LPC_DBG_MESSAGE Reply;
-    NTSTATUS Status;
-
-    if (PsGetCurrentThread()->ThreadsProcess->DebugPort == NULL)
-    {
-        return;
-    }
-
-    Message.Header.MessageSize = sizeof(LPC_DBG_MESSAGE);
-    Message.Header.DataSize = sizeof(LPC_DBG_MESSAGE) -
-        sizeof(LPC_MESSAGE);
-    Message.Type = DBG_EVENT_CREATE_THREAD;
-    Message.Status = STATUS_SUCCESS;
-    Message.Data.CreateThread.Reserved = 0;
-    Message.Data.CreateThread.StartAddress = StartAddress;
-
-    /* FIXME: Freeze all threads in process */
-
-    /* Send the message to the process's debug port and wait for a reply */
-    Status =
-       LpcSendDebugMessagePort(PsGetCurrentThread()->ThreadsProcess->DebugPort,
-                               &Message,
-                               &Reply);
-    if (!NT_SUCCESS(Status))
-    {
-        return;
-    }
-
-    /* FIXME: Examine reply */
-    return;
-#endif
-}
-
-VOID
-NTAPI
-DbgkExitProcess(IN NTSTATUS ExitStatus)
-{
-    /* FIXME */
-}
-
-VOID
-NTAPI
-DbgkExitThread(IN NTSTATUS ExitStatus)
-{
-    /* FIXME */
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/dbgk/debug.c
+++ b/reactos/ntoskrnl/dbgk/debug.c
@@ -1,173 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/dbgk/debug.c
- * PURPOSE:         User-Mode Debugging Support, Debug Object Management.
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-POBJECT_TYPE DbgkDebugObjectType;
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-DbgkCopyProcessDebugPort(IN PEPROCESS Process,
-                         IN PEPROCESS Parent)
-{
-    /* FIXME: Implement */
-}
-
-NTSTATUS
-NTAPI
-NtCreateDebugObject(OUT PHANDLE DebugHandle,
-                    IN ACCESS_MASK DesiredAccess,
-                    IN POBJECT_ATTRIBUTES ObjectAttributes,
-                    IN BOOLEAN KillProcessOnExit)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    PDBGK_DEBUG_OBJECT DebugObject;
-    HANDLE hDebug;
-    NTSTATUS Status = STATUS_SUCCESS;
-
-    PAGED_CODE();
-    DPRINT("NtCreateDebugObject(0x%p, 0x%x, 0x%p)\n", DebugHandle, DesiredAccess, ObjectAttributes);
-
-    /* Check Output Safety */
-    if(PreviousMode != KernelMode) {
-
-        _SEH_TRY {
-
-            ProbeForWrite(DebugHandle,
-                          sizeof(HANDLE),
-                          sizeof(ULONG));
-        } _SEH_HANDLE {
-
-            Status = _SEH_GetExceptionCode();
-
-        } _SEH_END;
-
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Create the Object */
-    Status = ObCreateObject(PreviousMode,
-                            DbgkDebugObjectType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(PDBGK_DEBUG_OBJECT),
-                            0,
-                            0,
-                            (PVOID*)&DebugObject);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status)) {
-
-        /* Initialize the Debug Object's Fast Mutex */
-        ExInitializeFastMutex(&DebugObject->Mutex);
-
-        /* Initialize the State Event List */
-        InitializeListHead(&DebugObject->StateEventListEntry);
-
-        /* Initialize the Debug Object's Wait Event */
-        KeInitializeEvent(&DebugObject->Event, NotificationEvent, 0);
-
-        /* Set the Flags */
-        DebugObject->KillProcessOnExit = KillProcessOnExit;
-
-        /* Insert it */
-        Status = ObInsertObject((PVOID)DebugObject,
-                                 NULL,
-                                 DesiredAccess,
-                                 0,
-                                 NULL,
-                                 &hDebug);
-        ObDereferenceObject(DebugObject);
-
-        /* Check for success and return handle */
-        if(NT_SUCCESS(Status)) {
-
-            _SEH_TRY {
-
-                *DebugHandle = hDebug;
-
-            } _SEH_HANDLE {
-
-                Status = _SEH_GetExceptionCode();
-
-            } _SEH_END;
-        }
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtWaitForDebugEvent(IN HANDLE DebugObject, // Debug object handle must grant DEBUG_OBJECT_WAIT_STATE_CHANGE access.
-                    IN BOOLEAN Alertable,
-                    IN PLARGE_INTEGER Timeout OPTIONAL,
-                    OUT PDBGUI_WAIT_STATE_CHANGE StateChange)
-{
-
-    UNIMPLEMENTED;
-
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtDebugContinue(IN HANDLE DebugObject,    // Debug object handle must grant DEBUG_OBJECT_WAIT_STATE_CHANGE access.
-                IN PCLIENT_ID AppClientId,
-                IN NTSTATUS ContinueStatus)
-{
-
-    UNIMPLEMENTED;
-
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtDebugActiveProcess(IN HANDLE Process,     // Process handle must grant PROCESS_SUSPEND_RESUME access.
-                     IN HANDLE DebugObject)  // Debug object handle must grant DEBUG_OBJECT_ADD_REMOVE_PROCESS access.
-{
-
-    UNIMPLEMENTED;
-
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtRemoveProcessDebug(IN HANDLE Process,     // Process handle must grant PROCESS_SUSPEND_RESUME access.
-                     IN HANDLE DebugObject)  // Debug object handle must grant DEBUG_OBJECT_ADD_REMOVE_PROCESS access.
-{
-
-    UNIMPLEMENTED;
-
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSetInformationDebugObject(IN HANDLE DebugObject, // Debug object handle need not grant any particular access right.
-                            IN DEBUGOBJECTINFOCLASS DebugObjectInformationClass,
-                            IN PVOID DebugInformation,
-                            IN ULONG DebugInformationLength,
-                            OUT PULONG ReturnLength OPTIONAL)
-{
-    UNIMPLEMENTED;
-
-    return STATUS_NOT_IMPLEMENTED;
-}
-/* EOF */
--- a/reactos/ntoskrnl/ex/atom.c
+++ b/reactos/ntoskrnl/ex/atom.c
@@ -1,494 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * COPYRIGHT:       GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/ex/atom.c
- * PURPOSE:         Executive Atom Functions
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Gunnar Dalsnes
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#define TAG_ATOM TAG('A', 't', 'o', 'm')
-
-/* GLOBALS ****************************************************************/
-
-/* 
- * FIXME: this is WRONG! The global atom table should live in the WinSta struct
- * and accessed through a win32k callout (received in PsEstablishWin32Callouts)
- * NOTE: There is a session/win32k global atom table also, but its private to
- * win32k. Its used for RegisterWindowMessage() and for window classes.
- * -Gunnar
- */
-PRTL_ATOM_TABLE GlobalAtomTable;
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-/*++
- * @name ExpGetGlobalAtomTable
- *
- * Gets pointer to a global atom table, creates it if not already created
- *
- * @return Pointer to the RTL_ATOM_TABLE, or NULL if it's impossible
- *         to create atom table
- *
- * @remarks Internal function
- *
- *--*/
-PRTL_ATOM_TABLE
-NTAPI
-ExpGetGlobalAtomTable(VOID)
-{
-    NTSTATUS Status;
-
-    /* Return it if we have one */
-    if (GlobalAtomTable) return GlobalAtomTable;
-
-    /* Create it */
-    Status = RtlCreateAtomTable(37, &GlobalAtomTable);
-
-    /* If we couldn't create it, return NULL */
-    if (!NT_SUCCESS(Status)) return NULL;
-
-    /* Return the newly created one */
-    return GlobalAtomTable;
-}
-
-/* FUNCTIONS ****************************************************************/
-
-/*++
- * @name NtAddAtom
- * @implemented
- *
- * Function NtAddAtom creates new Atom in Global Atom Table. If Atom
- * with the same name already exist, internal Atom counter is incremented.
- * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Atoms/NtAddAtom.html
- *
- * @param AtomName
- *        Atom name in Unicode
- *
- * @param AtomNameLength
- *        Length of the atom name
- *
- * @param Atom
- *        Pointer to RTL_ATOM
- *
- * @return STATUS_SUCCESS in case of success, proper error code
- *         othwerwise.
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-NtAddAtom(IN PWSTR AtomName,
-          IN ULONG AtomNameLength,
-          OUT PRTL_ATOM Atom)
-{
-    PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
-    NTSTATUS Status = STATUS_SUCCESS;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    LPWSTR CapturedName = NULL;
-    ULONG CapturedSize;
-    RTL_ATOM SafeAtom;
-    PAGED_CODE();
-
-    /* Check for the table */
-    if (AtomTable == NULL) return STATUS_ACCESS_DENIED;
-
-    /* Check for valid name */
-    if (AtomNameLength > (RTL_MAXIMUM_ATOM_LENGTH * sizeof(WCHAR)))
-    {
-        /* Fail */
-        DPRINT1("Atom name too long\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Check if we're called from user-mode*/
-    if (PreviousMode != KernelMode)
-    {
-        /* Enter SEH */
-        _SEH_TRY
-        {
-            /* Check if we have a name */
-            if (AtomName)
-            {
-                /* Probe the atom */
-                ProbeForRead(AtomName, AtomNameLength, sizeof(WCHAR));
-
-                /* Allocate an aligned buffer + the null char */
-                CapturedSize = ((AtomNameLength + sizeof(WCHAR)) &~
-                                (sizeof(WCHAR) -1));
-                CapturedName = ExAllocatePoolWithTag(PagedPool,
-                                                     CapturedSize,
-                                                     TAG_ATOM);
-                if (!CapturedName)
-                {
-                    /* Fail the call */
-                    Status = STATUS_INSUFFICIENT_RESOURCES;
-                }
-                else
-                {
-                    /* Copy the name and null-terminate it */
-                    RtlMoveMemory(CapturedName, AtomName, AtomNameLength);
-                    CapturedName[AtomNameLength / sizeof(WCHAR)] = UNICODE_NULL;
-                }
-
-                /* Probe the atom too */
-                if (Atom) ProbeForWriteUshort(Atom);
-            }
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-    else
-    {
-        /* Simplify code and re-use one variable */
-        if (AtomName) CapturedName = AtomName;
-    }
-
-    /* Make sure probe worked */
-    if (NT_SUCCESS(Status))
-    {
-        /* Call the runtime function */
-        Status = RtlAddAtomToAtomTable(AtomTable, CapturedName, &SafeAtom);
-        if (NT_SUCCESS(Status) && (Atom))
-        {
-            /* Success and caller wants the atom back.. .enter SEH */
-            _SEH_TRY
-            {
-                /* Return the atom */
-                *Atom = SafeAtom;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* If we captured anything, free it */
-    if ((CapturedName) && (CapturedName != AtomName)) ExFreePool(CapturedName);
-
-    /* Return to caller */
-    return Status;
-}
-
-/*++
- * @name NtDeleteAtom
- * @implemented
- *
- * Removes Atom from Global Atom Table. If Atom's reference counter
- * is greater then 1, function decrements this counter, but Atom
- * stayed in Global Atom Table.
- * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Atoms/NtDeleteAtom.html
- *
- * @param Atom
- *        Atom identifier
- *
- * @return STATUS_SUCCESS in case of success, proper error code
- *         othwerwise.
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-NtDeleteAtom(IN RTL_ATOM Atom)
-{
-    PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
-    PAGED_CODE();
-
-    /* Check for valid table */
-    if (AtomTable == NULL) return STATUS_ACCESS_DENIED;
-
-    /* Call worker function */
-    return RtlDeleteAtomFromAtomTable(AtomTable, Atom);
-}
-
-/*++
- * @name NtFindAtom
- * @implemented
- *
- * Retrieves existing Atom's identifier without incrementing Atom's
- * internal counter
- * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Atoms/NtFindAtom.html
- *
- * @param AtomName
- *        Atom name in Unicode
- *
- * @param AtomNameLength
- *        Length of the atom name
- *
- * @param Atom
- *        Pointer to RTL_ATOM
- *
- * @return STATUS_SUCCESS in case of success, proper error code
- *         othwerwise.
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-NtFindAtom(IN PWSTR AtomName,
-           IN ULONG AtomNameLength,
-           OUT PRTL_ATOM Atom)
-{
-    PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
-    NTSTATUS Status = STATUS_SUCCESS;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    LPWSTR CapturedName = NULL;
-    ULONG CapturedSize;
-    RTL_ATOM SafeAtom;
-    PAGED_CODE();
-
-    /* Check for the table */
-    if (AtomTable == NULL) return STATUS_ACCESS_DENIED;
-
-    /* Check for valid name */
-    if (AtomNameLength > (RTL_MAXIMUM_ATOM_LENGTH * sizeof(WCHAR)))
-    {
-        /* Fail */
-        DPRINT1("Atom name too long\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Check if we're called from user-mode*/
-    if (PreviousMode != KernelMode)
-    {
-        /* Enter SEH */
-        _SEH_TRY
-        {
-            /* Check if we have a name */
-            if (AtomName)
-            {
-                /* Probe the atom */
-                ProbeForRead(AtomName, AtomNameLength, sizeof(WCHAR));
-
-                /* Allocate an aligned buffer + the null char */
-                CapturedSize = ((AtomNameLength + sizeof(WCHAR)) &~
-                                (sizeof(WCHAR) -1));
-                CapturedName = ExAllocatePoolWithTag(PagedPool,
-                                                     CapturedSize,
-                                                     TAG_ATOM);
-                if (!CapturedName)
-                {
-                    /* Fail the call */
-                    Status = STATUS_INSUFFICIENT_RESOURCES;
-                }
-                else
-                {
-                    /* Copy the name and null-terminate it */
-                    RtlMoveMemory(CapturedName, AtomName, AtomNameLength);
-                    CapturedName[AtomNameLength / sizeof(WCHAR)] = UNICODE_NULL;
-                }
-
-                /* Probe the atom too */
-                if (Atom) ProbeForWriteUshort(Atom);
-            }
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-    else
-    {
-        /* Simplify code and re-use one variable */
-        if (AtomName) CapturedName = AtomName;
-    }
-
-    /* Make sure probe worked */
-    if (NT_SUCCESS(Status))
-    {
-        /* Call the runtime function */
-        Status = RtlLookupAtomInAtomTable(AtomTable, CapturedName, &SafeAtom);
-        if (NT_SUCCESS(Status) && (Atom))
-        {
-            /* Success and caller wants the atom back.. .enter SEH */
-            _SEH_TRY
-            {
-                /* Return the atom */
-                *Atom = SafeAtom;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* If we captured anything, free it */
-    if ((CapturedName) && (CapturedName != AtomName)) ExFreePool(CapturedName);
-
-    /* Return to caller */
-    return Status;
-}
-
-/*++
- * @name NtQueryInformationAtom
- * @implemented
- *
- * Gets single Atom properties or reads Global Atom Table
- * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Atoms/NtQueryInformationAtom.html
- *
- * @param Atom
- *        Atom to query. If AtomInformationClass parameter is
- *        AtomTableInformation, Atom parameter is not used.
- *
- * @param AtomInformationClass
- *        See ATOM_INFORMATION_CLASS enumeration type for details
- *
- * @param AtomInformation
- *        Result of call - pointer to user's allocated buffer for data
- *
- * @param AtomInformationLength
- *        Size of AtomInformation buffer, in bytes
- *
- * @param ReturnLength
- *        Pointer to ULONG value containing required AtomInformation
- *        buffer size
- *
- * @return STATUS_SUCCESS in case of success, proper error code
- *         othwerwise.
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-NtQueryInformationAtom(RTL_ATOM Atom,
-                       ATOM_INFORMATION_CLASS AtomInformationClass,
-                       PVOID AtomInformation,
-                       ULONG AtomInformationLength,
-                       PULONG ReturnLength)
-{
-    PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
-    PATOM_BASIC_INFORMATION BasicInformation = AtomInformation;
-    PATOM_TABLE_INFORMATION TableInformation = AtomInformation;
-    NTSTATUS Status = STATUS_SUCCESS;
-    ULONG Flags, UsageCount, NameLength, RequiredLength = 0;
-    KPROCESSOR_MODE PreviousMode;
-
-    PAGED_CODE();
-
-    /* Check for valid table */
-    if (AtomTable == NULL) return STATUS_ACCESS_DENIED;
-
-    PreviousMode = ExGetPreviousMode();
-
-    _SEH_TRY
-    {
-        /* Probe the parameters */
-        if (PreviousMode != KernelMode)
-        {
-            ProbeForWrite(AtomInformation,
-                          AtomInformationLength,
-                          sizeof(ULONG));
-
-            if (ReturnLength != NULL)
-            {
-                ProbeForWriteUlong(ReturnLength);
-            }
-        }
-
-        /* Choose class */
-        switch (AtomInformationClass)
-        {
-            /* Caller requested info about an atom */
-            case AtomBasicInformation:
-
-                /* Size check */
-                RequiredLength = FIELD_OFFSET(ATOM_BASIC_INFORMATION, Name);
-                if (RequiredLength > AtomInformationLength)
-                {
-                    /* Fail */
-                    DPRINT1("Buffer too small\n");
-                    Status = STATUS_INFO_LENGTH_MISMATCH;
-                    _SEH_LEAVE;
-                }
-
-                /* Prepare query */
-                UsageCount = 0;
-                NameLength = AtomInformationLength - RequiredLength;
-                BasicInformation->Name[0] = UNICODE_NULL;
-
-                /* Query the data */
-                Status = RtlQueryAtomInAtomTable(AtomTable,
-                                                 Atom,
-                                                 &UsageCount,
-                                                 &Flags,
-                                                 BasicInformation->Name,
-                                                 &NameLength);
-                if (NT_SUCCESS(Status))
-                {
-                    /* Return data */
-                    BasicInformation->UsageCount = (USHORT)UsageCount;
-                    BasicInformation->Flags = (USHORT)Flags;
-                    BasicInformation->NameLength = (USHORT)NameLength;
-                    RequiredLength += NameLength + sizeof(WCHAR);
-                }
-                break;
-
-            /* Caller requested info about an Atom Table */
-            case AtomTableInformation:
-
-                /* Size check */
-                RequiredLength = FIELD_OFFSET(ATOM_TABLE_INFORMATION, Atoms);
-                if (RequiredLength > AtomInformationLength)
-                {
-                    /* Fail */
-                    DPRINT1("Buffer too small\n");
-                    Status = STATUS_INFO_LENGTH_MISMATCH;
-                    _SEH_LEAVE;
-                }
-
-                /* Query the data */
-                Status = RtlQueryAtomListInAtomTable(AtomTable,
-                                                     (AtomInformationLength - RequiredLength) /
-                                                     sizeof(RTL_ATOM),
-                                                     &TableInformation->NumberOfAtoms,
-                                                     TableInformation->Atoms);
-                if (NT_SUCCESS(Status))
-                {
-                    /* Update the return length */
-                    RequiredLength += TableInformation->NumberOfAtoms * sizeof(RTL_ATOM);
-                }
-                break;
-
-            /* Caller was on crack */
-            default:
-
-                /* Unrecognized class */
-                Status = STATUS_INVALID_INFO_CLASS;
-                break;
-        }
-
-        /* Return the required size */
-        if (ReturnLength != NULL)
-        {
-            *ReturnLength = RequiredLength;
-        }
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return to caller */
-    return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/callback.c
+++ b/reactos/ntoskrnl/ex/callback.c
@@ -1,504 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/ex/callback.c
- * PURPOSE:         Executive callbacks
- * PROGRAMMERS:     Filip Navara
- *                  Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeCallbacks)
-#endif
-
-
-/* TYPES ********************************************************************/
-
-/* Mapping for Callback Object */
-GENERIC_MAPPING ExpCallbackMapping =
-{
-   CALLBACK_READ,
-   CALLBACK_WRITE,
-   CALLBACK_EXECUTE,
-   CALLBACK_ALL_ACCESS
-};
-
-/* Structure used to hold Callbacks */
-typedef struct _CALLBACK_REGISTRATION
-{
-   LIST_ENTRY RegisteredCallbacks;
-   PCALLBACK_OBJECT CallbackObject;
-   PCALLBACK_FUNCTION CallbackFunction;
-   PVOID CallbackContext;
-   ULONG InUse;
-   BOOLEAN PendingDeletion;
-} CALLBACK_REGISTRATION, *PCALLBACK_REGISTRATION;
-
-typedef struct
-{
-    PCALLBACK_OBJECT *CallbackObject;
-    PWSTR Name;
-} SYSTEM_CALLBACKS;
-
-/* Kernel Default Callbacks */
-PCALLBACK_OBJECT SetSystemTimeCallback;
-PCALLBACK_OBJECT SetSystemStateCallback;
-PCALLBACK_OBJECT PowerStateCallback;
-
-SYSTEM_CALLBACKS ExpInitializeCallback[] =
-{
-   {&SetSystemTimeCallback, L"\\Callback\\SetSystemTime"},
-   {&SetSystemStateCallback, L"\\Callback\\SetSystemState"},
-   {&PowerStateCallback, L"\\Callback\\PowerState"},
-   {NULL, NULL}
-};
-
-POBJECT_TYPE ExCallbackObjectType;
-KEVENT ExpCallbackEvent;
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name ExpInitializeCallbacks
- *
- * Creates the Callback Object as a valid Object Type in the Kernel.
- * Internal function, subject to further review
- *
- * @return TRUE if the Callback Object Type was successfully created.
- *
- * @remarks None
- *
- *--*/
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeCallbacks(VOID)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    NTSTATUS Status;
-    UNICODE_STRING DirName = RTL_CONSTANT_STRING(L"\\Callback");
-    UNICODE_STRING CallbackName;
-    UNICODE_STRING Name;
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    HANDLE DirectoryHandle;
-    ULONG i;
-
-    /*  Initialize the Callback Object type  */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Callback");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(CALLBACK_OBJECT);
-    ObjectTypeInitializer.GenericMapping = ExpCallbackMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-
-    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExCallbackObjectType);
-
-    /* Fail if it wasn't created successfully */
-    if (!NT_SUCCESS(Status))
-    {
-        return;
-    }
-
-    /* Initialize the Object */
-    InitializeObjectAttributes(
-        &ObjectAttributes,
-        &DirName,
-        OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
-        NULL,
-        NULL
-        );
-
-    /* Create the Object Directory */
-    Status = NtCreateDirectoryObject(
-        &DirectoryHandle,
-        DIRECTORY_ALL_ACCESS,
-        &ObjectAttributes
-        );
-
-    /* Fail if couldn't create */
-    if (!NT_SUCCESS(Status))
-    {
-        return;
-    }
-
-    /* Close Handle... */
-    NtClose(DirectoryHandle);
-
-    /* Initialize Event used when unregistering */
-    KeInitializeEvent(&ExpCallbackEvent, NotificationEvent, 0);
-
-    /* Default NT Kernel Callbacks. */
-    for (i=0; ExpInitializeCallback[i].CallbackObject; i++)
-    {
-        /* Create the name from the structure */
-        RtlInitUnicodeString(&CallbackName, ExpInitializeCallback[i].Name);
-
-        /* Initialize the Object Attributes Structure */
-        InitializeObjectAttributes(
-            &ObjectAttributes,
-            &CallbackName,
-            OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
-            NULL,
-            NULL
-            );
-
-        /* Create the Callback Object */
-        Status = ExCreateCallback(
-            (PCALLBACK_OBJECT*)&(ExpInitializeCallback[i].CallbackObject),
-            &ObjectAttributes,
-            TRUE,
-            TRUE
-            );
-
-        /* Make sure Global Callbacks have been created */
-        if (!NT_SUCCESS(Status))
-        {
-            return;
-        }
-    }
-    /* Everything successful */
-}
-
-/*++
- * @name ExCreateCallback
- * @implemented
- *
- * Opens or creates a Callback Object. Creates only if Create is true.
- * Allows multiple Callback Functions to be registred only if
- * AllowMultipleCallbacks is true.
- * See: http://www.osronline.com/ddkx/kmarch/k102_967m.htm
- *      http://www.osronline.com/article.cfm?id=24
- *
- * @param CallbackObject
- *        Pointer that will receive the Callback Object.
- *
- * @param CallbackName
- *        Name of Callback
- *
- * @param Create
- *        Determines if the object will be created if it doesn't exit
- *
- * @param AllowMultipleCallbacks
- *        Determines if more then one registered callback function
- *        can be attached to this Callback Object.
- *
- * @return STATUS_SUCESS if not failed.
- *
- * @remarks Must be called at IRQL = PASSIVE_LEVEL
- *
- *--*/
-NTSTATUS
-NTAPI
-ExCreateCallback(OUT PCALLBACK_OBJECT *CallbackObject,
-                 IN POBJECT_ATTRIBUTES ObjectAttributes,
-                 IN BOOLEAN Create,
-                 IN BOOLEAN AllowMultipleCallbacks)
-{
-    PCALLBACK_OBJECT Callback;
-    NTSTATUS    Status;
-    HANDLE     Handle;
-
-    PAGED_CODE();
-
-    /* Open a handle to the callback if it exists */
-    if (ObjectAttributes->ObjectName)
-    {
-        Status = ObOpenObjectByName(ObjectAttributes,
-                                    ExCallbackObjectType,
-                                    KernelMode,
-                                    NULL,
-                                    0,
-                                    NULL,
-                                    &Handle);
-    }
-    else
-    {
-        Status = STATUS_UNSUCCESSFUL;
-    }
-
-    /* We weren't able to open it...should we create it? */
-    if(!NT_SUCCESS(Status) && Create )
-    {
-        Status = ObCreateObject(KernelMode,
-                                ExCallbackObjectType,
-                                ObjectAttributes,
-                                KernelMode,
-                                NULL,
-                                sizeof(CALLBACK_OBJECT),
-                                0,
-                                0,
-                                (PVOID *)&Callback );
-
-        /* We Created it...let's initialize the structure now */
-        if(NT_SUCCESS(Status))
-        {
-            KeInitializeSpinLock(&Callback->Lock);      /*  SpinLock   */
-            InitializeListHead(&Callback->RegisteredCallbacks);   /*  Callback Entries */
-            Callback->AllowMultipleCallbacks = AllowMultipleCallbacks; /*  Multiple Callbacks */
-            /*  Create the object */
-            Status = ObInsertObject(Callback,
-                                    NULL,
-                                    FILE_READ_DATA,
-                                    0,
-                                    NULL,
-                                    &Handle );
-        }
-    }
-
-    if(NT_SUCCESS(Status))
-    {
-        /* Get a pointer to the new object from the handle we just got */
-        Status = ObReferenceObjectByHandle(Handle,
-                                           0,
-                                           ExCallbackObjectType,
-                                           KernelMode,
-                                           (PVOID)&Callback,
-                                           NULL);
-        /* Close the Handle, since we now have the pointer */
-        ZwClose(Handle);
-    }
-
-    /* Everything went fine, so return a pointer to the Object */
-    if (NT_SUCCESS(Status))
-    {
-        *CallbackObject = (PCALLBACK_OBJECT)Callback;
-    }
-    return Status;
-}
-
-/*++
- * @name ExNotifyCallback
- * @implemented
- *
- * Calls a function pointer (a registered callback)
- * See: http://www.osronline.com/ddkx/kmarch/k102_2f5e.htm
- *      http://msdn.microsoft.com/library/en-us/Kernel_d/hh/Kernel_d/Synchro_e954f515-e536-4e12-8419-e7e54c4a963b.xml.asp?frame=true
- *      http://vmsone.com/~decuslib/vmssig/vmslt99b/nt/wdm-callback.txt
- *
- * @param CallbackObject
- *        Which callback to call
- *
- * @param Argument1
- *        Pointer/data to send to callback function
- *
- * @param Argument2
- *        Pointer/data to send to callback function
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExNotifyCallback(IN PCALLBACK_OBJECT OpaqueCallbackObject,
-                 IN PVOID Argument1,
-                 IN PVOID Argument2)
-{
-    PCALLBACK_OBJECT   CallbackObject = (PCALLBACK_OBJECT)OpaqueCallbackObject;
-    PLIST_ENTRY             RegisteredCallbacks;
-    PCALLBACK_REGISTRATION  CallbackRegistration;
-    KIRQL                   OldIrql;
-
-    /* Acquire the Lock */
-    OldIrql = KfAcquireSpinLock(&CallbackObject->Lock);
-
-    /* Enumerate through all the registered functions */
-    for (RegisteredCallbacks = CallbackObject->RegisteredCallbacks.Flink;
-         RegisteredCallbacks != &CallbackObject->RegisteredCallbacks;
-         RegisteredCallbacks = RegisteredCallbacks->Flink)
-    {
-        /* Get a pointer to a Callback Registration from the List Entries */
-        CallbackRegistration = CONTAINING_RECORD(RegisteredCallbacks,
-                                                 CALLBACK_REGISTRATION,
-                                                 RegisteredCallbacks);
-
-        /* Don't bother doing Callback Notification if it's pending to be deleted */
-        if (!CallbackRegistration->PendingDeletion)
-        {
-            /* Mark the Callback in use, so it won't get deleted while we are calling it */
-            CallbackRegistration->InUse += 1;
-
-            /* Release the Spinlock before making the call */
-            KfReleaseSpinLock(&CallbackObject->Lock, OldIrql);
-
-            /* Call the Registered Function */
-            CallbackRegistration->CallbackFunction(
-                CallbackRegistration->CallbackContext,
-                Argument1,
-                Argument2
-                );
-
-            /* Get SpinLock back */
-            OldIrql = KfAcquireSpinLock(&CallbackObject->Lock);
-
-            /* We are not in use anymore */
-            CallbackRegistration->InUse -= 1;
-
-            /* If another instance of this function isn't running and deletion is pending, signal the event */
-            if (CallbackRegistration->PendingDeletion  && CallbackRegistration->InUse == 0)
-            {
-                KeSetEvent(&ExpCallbackEvent, 0, FALSE);
-            }
-        }
-    }
-    /* Unsynchronize and release the Callback Object */
-    KfReleaseSpinLock(&CallbackObject->Lock, OldIrql);
-}
-
-/*++
- * @name ExRegisterCallback
- * @implemented
- *
- * Allows a function to associate a callback pointer (Function) to
- * a created Callback object
- * See: DDK, OSR, links in ExNotifyCallback
- *
- * @param CallbackObject
- *        The Object Created with ExCreateCallBack
- *
- * @param CallBackFunction
- *        Pointer to the function to be called back
- *
- * @param CallBackContext
- *        Block of memory that can contain user-data which will be
- *        passed on to the callback
- *
- * @return A handle to a Callback Registration Structure (MSDN Documentation)
- *
- * @remarks None
- *
- *--*/
-PVOID
-NTAPI
-ExRegisterCallback(IN PCALLBACK_OBJECT OpaqueCallbackObject,
-                   IN PCALLBACK_FUNCTION CallbackFunction,
-                   IN PVOID CallbackContext)
-{
-    PCALLBACK_OBJECT CallbackObject = (PCALLBACK_OBJECT)OpaqueCallbackObject;
-    PCALLBACK_REGISTRATION  CallbackRegistration = NULL;
-    KIRQL     OldIrql;
-
-    PAGED_CODE();
-
-    /* Create reference to Callback Object */
-    ObReferenceObject (CallbackObject);
-
-    /* Allocate memory for the structure */
-    CallbackRegistration = ExAllocatePoolWithTag(
-                               NonPagedPool,
-                               sizeof(CallbackRegistration),
-                               CALLBACK_TAG
-                               );
-    /* Fail if memory allocation failed */
-    if(!CallbackRegistration)
-    {
-        ObDereferenceObject (CallbackObject);
-        return NULL;
-    }
-
-    /* Create Callback Registration */
-    CallbackRegistration->CallbackObject = CallbackObject; /* When unregistering, drivers send a handle to the Registration, not the object... */
-    CallbackRegistration->CallbackFunction = CallbackFunction; /* NotifyCallback uses Objects, so this needs to be here in order to call the registered functions */
-    CallbackRegistration->CallbackContext = CallbackContext; /* The documented NotifyCallback returns the Context, so we must save this somewhere */
-
-    /* Acquire SpinLock */
-    OldIrql = KfAcquireSpinLock (&CallbackObject->Lock);
-
-    /* Add Callback if 1) No Callbacks registered or 2) Multiple Callbacks allowed */
-    if(CallbackObject->AllowMultipleCallbacks || IsListEmpty(&CallbackObject->RegisteredCallbacks))
-    {
-        InsertTailList(&CallbackObject->RegisteredCallbacks,&CallbackRegistration->RegisteredCallbacks);
-    }
-    else
-    {
-        ExFreePool(CallbackRegistration);
-        CallbackRegistration = NULL;
-    }
-
-    /* Release SpinLock */
-    KfReleaseSpinLock(&CallbackObject->Lock, OldIrql);
-
-    /* Return handle to Registration Object */
-    return (PVOID)CallbackRegistration;
-}
-
-/*++
- * @name ExUnregisterCallback
- * @implemented
- *
- * Deregisters a CallBack
- * See: DDK, OSR, links in ExNotifyCallback
- *
- * @param CallbackRegistration
- *        Callback Registration Handle
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExUnregisterCallback(IN PVOID CallbackRegistrationHandle)
-{
-    PCALLBACK_REGISTRATION  CallbackRegistration;
-    PCALLBACK_OBJECT    CallbackObject;
-    KIRQL                   OldIrql;
-
-    PAGED_CODE();
-
-    /* Convert Handle to valid Structure Pointer */
-    CallbackRegistration = (PCALLBACK_REGISTRATION) CallbackRegistrationHandle;
-
-    /* Get the Callback Object */
-    CallbackObject = CallbackRegistration->CallbackObject;
-
-    /* Lock the Object */
-    OldIrql = KfAcquireSpinLock (&CallbackObject->Lock);
-
-    /* We can't Delete the Callback if it's in use, because this would create a call towards a null pointer => crash */
-    while (CallbackRegistration->InUse)
-    {
-        /* Similarly, we also don't want to wait ages for all pending callbacks to be called */
-        CallbackRegistration->PendingDeletion = TRUE;
-
-        /* We are going to wait for the event, so the Lock isn't necessary */
-        KfReleaseSpinLock (&CallbackObject->Lock, OldIrql);
-
-        /* Make sure the event is cleared */
-        KeClearEvent (&ExpCallbackEvent);
-
-        /* Wait for the Event */
-        KeWaitForSingleObject (
-            &ExpCallbackEvent,
-            Executive,
-            KernelMode,
-            FALSE,
-            NULL
-            );
-
-        /* We need the Lock again */
-        OldIrql = KfAcquireSpinLock(&CallbackObject->Lock);
-    }
-
-    /* Remove the Callback */
-    RemoveEntryList(&CallbackRegistration->RegisteredCallbacks);
-
-    /* It's now safe to release the lock */
-    KfReleaseSpinLock(&CallbackObject->Lock, OldIrql);
-
-    /* Delete this registration */
-    ExFreePool(CallbackRegistration);
-
-    /* Remove the reference */
-    ObDereferenceObject(CallbackObject);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/dbgctrl.c
+++ b/reactos/ntoskrnl/ex/dbgctrl.c
@@ -1,82 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/ex/dbgctrl.c
- * PURPOSE:         System debug control
- * PROGRAMMERS:     Alex Ionescu
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name NtSystemDebugControl
- * @implemented
- *
- * Perform various queries to debugger.
- * This API is subject to test-case creation to further evaluate its
- * abilities (if needed to at all)
- *
- * See: http://www.osronline.com/showthread.cfm?link=93915
- *      http://void.ru/files/Ntexapi.h
- *      http://www.codeguru.com/code/legacy/system/ntexapi.zip
- *      http://www.securityfocus.com/bid/9694
- *
- * @param ControlCode
- *        Description of the parameter. Wrapped to more lines on ~70th
- *        column.
- *
- * @param InputBuffer
- *        FILLME
- *
- * @param InputBufferLength
- *        FILLME
- *
- * @param OutputBuffer
- *        FILLME
- *
- * @param OutputBufferLength
- *        FILLME
- *
-  * @param ReturnLength
- *        FILLME
- *
- * @return STATUS_SUCCESS in case of success, proper error code otherwise
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-NtSystemDebugControl(SYSDBG_COMMAND ControlCode,
-                     PVOID InputBuffer,
-                     ULONG InputBufferLength,
-                     PVOID OutputBuffer,
-                     ULONG OutputBufferLength,
-                     PULONG ReturnLength)
-{
-    switch (ControlCode)
-    {
-        case SysDbgQueryTraceInformation:
-        case SysDbgSetTracepoint:
-        case SysDbgSetSpecialCall:
-        case SysDbgClearSpecialCalls:
-        case SysDbgQuerySpecialCalls:
-        case SysDbgBreakPoint:
-            break;
-
-        case SysDbgQueryVersion:
-            KDB_LOADUSERMODULE_HOOK((PLDR_DATA_TABLE_ENTRY) InputBuffer);
-            break;
-
-        default:
-            break;
-    }
-
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/ex/efi.c
+++ b/reactos/ntoskrnl/ex/efi.c
@@ -1,91 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/io/efi.c
- * PURPOSE:         I/O Functions for EFI Machines
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS
-NTAPI
-NtAddBootEntry(IN PUNICODE_STRING EntryName,
-               IN PUNICODE_STRING EntryValue)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtDeleteBootEntry(IN PUNICODE_STRING EntryName,
-                  IN PUNICODE_STRING EntryValue)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtEnumerateBootEntries(IN PVOID Buffer,
-                       IN PULONG BufferLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtQueryBootEntryOrder(IN PULONG Ids,
-                      IN PULONG Count)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtQueryBootOptions(IN PBOOT_OPTIONS BootOptions,
-                   IN PULONG BootOptionsLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSetBootEntryOrder(IN PULONG Ids,
-                    IN PULONG Count)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtSetBootOptions(IN PBOOT_OPTIONS BootOptions,
-                 IN ULONG FieldsToChange)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-NTAPI
-NtTranslateFilePath(PFILE_PATH InputFilePath,
-                    ULONG OutputType,
-                    PFILE_PATH OutputFilePath,
-                    ULONG OutputFilePathLength)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/error.c
+++ b/reactos/ntoskrnl/ex/error.c
@@ -1,443 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/ex/error.c
- * PURPOSE:         Error Functions and Status/Exception Dispatching/Raising
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#define TAG_ERR TAG('E', 'r', 'r', ' ')
-
-/* GLOBALS ****************************************************************/
-
-BOOLEAN ExReadyForErrors = FALSE;
-PEPORT ExpDefaultErrorPort = NULL;
-PEPROCESS ExpDefaultErrorPortProcess = NULL;
-
-/* FUNCTIONS ****************************************************************/
-
-/*++
- * @name ExpRaiseHardError
- *
- * For now it's a stub
- *
- * @param ErrorStatus
- *        FILLME
- *
- * @param NumberOfParameters
- *        FILLME
- *
- * @param UnicodeStringParameterMask
- *        FILLME
- *
- * @param Parameters
- *        FILLME
- *
- * @param ValidResponseOptions
- *        FILLME
- *
- * @param Response
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExpRaiseHardError(IN NTSTATUS ErrorStatus,
-                  IN ULONG NumberOfParameters,
-                  IN ULONG UnicodeStringParameterMask,
-                  IN PULONG_PTR Parameters,
-                  IN ULONG ValidResponseOptions,
-                  OUT PULONG Response)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name ExRaiseAccessViolation
- * @implemented
- *
- * The ExRaiseAccessViolation routine can be used with structured exception
- * handling to throw a driver-determined exception for a memory access
- * violation that occurs when a driver processes I/O requests.
- * See: http://msdn.microsoft.com/library/en-us/Kernel_r/hh/Kernel_r/k102_71b4c053-599c-4a6d-8a59-08aae6bdc534.xml.asp?frame=true
- *      http://www.osronline.com/ddkx/kmarch/k102_814i.htm
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExRaiseAccessViolation(VOID)
-{
-    /* Raise the Right Status */
-    RtlRaiseStatus(STATUS_ACCESS_VIOLATION);
-}
-
-/*++
- * @name ExRaiseDatatypeMisalignment
- * @implemented
- *
- * ExRaiseDatatypeMisalignment raises an exception with the exception
- * code set to STATUS_DATATYPE_MISALIGNMENT
- * See: MSDN / DDK
- *      http://www.osronline.com/ddkx/kmarch/k102_814i.htm
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExRaiseDatatypeMisalignment(VOID)
-{
-    /* Raise the Right Status */
-    RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
-}
-
-/*++
- * @name ExSystemExceptionFilter
- * @implemented
- *
- * TODO: Add description
- *
- * @return FILLME
- *
- * @remarks None
- *
- *--*/
-LONG
-NTAPI
-ExSystemExceptionFilter(VOID)
-{
-    return KeGetPreviousMode() != KernelMode ?
-           EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
-}
-
-/*++
- * @name ExRaiseHardError
- * @implemented
- *
- * See NtRaiseHardError
- *
- * @param ErrorStatus
- *        Error Code
- *
- * @param NumberOfParameters
- *        Number of optional parameters in Parameters array
- *
- * @param UnicodeStringParameterMask
- *        Optional string parameter (can be only one per error code)
- *
- * @param Parameters
- *        Array of DWORD parameters for use in error message string
- *
- * @param ValidResponseOptions
- *        See HARDERROR_RESPONSE_OPTION for possible values description
- *
- * @param Response
- *        Pointer to HARDERROR_RESPONSE enumeration
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-ExRaiseHardError(IN NTSTATUS ErrorStatus,
-                 IN ULONG NumberOfParameters,
-                 IN ULONG UnicodeStringParameterMask,
-                 IN PULONG_PTR Parameters,
-                 IN ULONG ValidResponseOptions,
-                 OUT PULONG Response)
-{
-    /* FIXME: Capture to user-mode! */
-
-    /* Now call the worker function */
-    ExpRaiseHardError(ErrorStatus,
-                      NumberOfParameters,
-                      UnicodeStringParameterMask,
-                      Parameters,
-                      ValidResponseOptions,
-                      Response);
-}
-
-/*++
- * @name NtRaiseHardError
- * @implemented
- *
- * This function sends HARDERROR_MSG LPC message to listener
- * (typically CSRSS.EXE). See NtSetDefaultHardErrorPort for more information
- * See: http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtRaiseHardError.html
- *
- * @param ErrorStatus
- *        Error Code
- *
- * @param NumberOfParameters
- *        Number of optional parameters in Parameters array
- *
- * @param UnicodeStringParameterMask
- *        Optional string parameter (can be only one per error code)
- *
- * @param Parameters
- *        Array of DWORD parameters for use in error message string
- *
- * @param ValidResponseOptions
- *        See HARDERROR_RESPONSE_OPTION for possible values description
- *
- * @param Response
- *        Pointer to HARDERROR_RESPONSE enumeration
- *
- * @return Status
- *
- * @remarks NtRaiseHardError is easy way to display message in GUI
- *          without loading Win32 API libraries
- *
- *--*/
-NTSTATUS
-NTAPI
-NtRaiseHardError(IN NTSTATUS ErrorStatus,
-                 IN ULONG NumberOfParameters,
-                 IN ULONG UnicodeStringParameterMask,
-                 IN PULONG_PTR Parameters,
-                 IN ULONG ValidResponseOptions,
-                 OUT PULONG Response)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-    PULONG_PTR SafeParams = NULL;
-    ULONG SafeResponse;
-    UNICODE_STRING SafeString;
-    ULONG i;
-    ULONG ParamSize;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    DPRINT1("Hard error %x\n", ErrorStatus);
-
-    /* Validate parameter count */
-    if (NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS)
-    {
-        /* Fail */
-        DPRINT1("Invalid parameters\n");
-        return STATUS_INVALID_PARAMETER_2;
-    }
-
-    /* Make sure we have some at least */
-    if ((Parameters) && !(NumberOfParameters))
-    {
-        /* Fail */
-        DPRINT1("Invalid parameters\n");
-        return STATUS_INVALID_PARAMETER_2;
-    }
-
-    /* Check if we were called from user-mode */
-    if (PreviousMode != KernelMode)
-    {
-        /* First validate the responses */
-        switch (ValidResponseOptions)
-        {
-            /* Check all valid cases */
-            case OptionAbortRetryIgnore:
-            case OptionOk:
-            case OptionOkCancel:
-            case OptionRetryCancel:
-            case OptionYesNo:
-            case OptionYesNoCancel:
-            case OptionShutdownSystem:
-                break;
-
-            /* Anything else is invalid */
-            default:
-                return STATUS_INVALID_PARAMETER_4;
-        }
-
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Validate the response pointer */
-            ProbeForWriteUlong(Response);
-
-            /* Check if we have parameters */
-            if (Parameters)
-            {
-                /* Validate the parameter pointers */
-                ParamSize = sizeof(ULONG_PTR) * NumberOfParameters;
-                ProbeForRead(Parameters, ParamSize, sizeof(ULONG_PTR));
-
-                /* Allocate a safe buffer */
-                SafeParams = ExAllocatePoolWithTag(PagedPool,
-                                                   ParamSize,
-                                                   TAG_ERR);
-
-                /* Copy them */
-                RtlMoveMemory(SafeParams, Parameters, ParamSize);
-
-                /* Nowo check if there's strings in it */
-                if (UnicodeStringParameterMask)
-                {
-                    /* Loop every string */
-                    for (i = 0; i < NumberOfParameters; i++)
-                    {
-                        /* Check if this parameter is a string */
-                        if (UnicodeStringParameterMask & (1 << i))
-                        {
-                            /* Probe the structure */
-                            ProbeForRead((PVOID)SafeParams[i],
-                                         sizeof(UNICODE_STRING),
-                                         sizeof(ULONG_PTR));
-
-                            /* Capture it */
-                            RtlMoveMemory(&SafeString,
-                                          (PVOID)SafeParams[i],
-                                          sizeof(UNICODE_STRING));
-
-                            /* Probe the buffer */
-                            ProbeForRead(SafeString.Buffer,
-                                         SafeString.MaximumLength,
-                                         sizeof(UCHAR));
-                        }
-                    }
-                }
-            }
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            /* Free captured buffer */
-            if (SafeParams) ExFreePool(SafeParams);
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* If we failed to capture/probe, bail out */
-        if (!NT_SUCCESS(Status)) return Status;
-
-        /* Call the system function directly, because we probed */
-        ExpRaiseHardError(ErrorStatus,
-                          NumberOfParameters,
-                          UnicodeStringParameterMask,
-                          SafeParams,
-                          ValidResponseOptions,
-                          &SafeResponse);
-    }
-    else
-    {
-        /* Reuse variable */
-        SafeParams = Parameters;
-
-        /*
-         * Call the Executive Function. It will probe and copy pointers to 
-         * user-mode
-         */
-        ExRaiseHardError(ErrorStatus,
-                         NumberOfParameters,
-                         UnicodeStringParameterMask,
-                         SafeParams,
-                         ValidResponseOptions,
-                         &SafeResponse);
-    }
-
-    /* Check if we were called in user-mode */
-    if (PreviousMode != KernelMode)
-    {
-        /* That means we have a buffer to free */
-        if (SafeParams) ExFreePool(SafeParams);
-
-        /* Enter SEH Block for return */
-        _SEH_TRY
-        {
-            /* Return the response */
-            *Response = SafeResponse;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-    else
-    {
-        /* Return the response */
-        *Response = SafeResponse;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/*++
- * @name NtSetDefaultHardErrorPort
- * @implemented
- *
- * NtSetDefaultHardErrorPort is typically called only once. After call,
- * kernel set BOOLEAN flag named _ExReadyForErrors to TRUE, and all other
- * tries to change default port are broken with STATUS_UNSUCCESSFUL error code
- * See: http://www.windowsitlibrary.com/Content/356/08/2.html
- *      http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/Error/NtSetDefaultHardErrorPort.html
- *
- * @param PortHandle
- *        Handle to named port object
- *
- * @return Status
- *
- * @remarks Privileges: SE_TCB_PRIVILEGE
- *
- *--*/
-NTSTATUS
-NTAPI
-NtSetDefaultHardErrorPort(IN HANDLE PortHandle)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_UNSUCCESSFUL;
-
-    /* Check if we have the Privilege */
-    if(!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
-    {
-        DPRINT1("NtSetDefaultHardErrorPort: Caller requires "
-                "the SeTcbPrivilege privilege!\n");
-        return STATUS_PRIVILEGE_NOT_HELD;
-    }
-
-    /* Only called once during bootup, make sure we weren't called yet */
-    if(!ExReadyForErrors)
-    {
-        /* Reference the port */
-        Status = ObReferenceObjectByHandle(PortHandle,
-                                           0,
-                                           LpcPortObjectType,
-                                           PreviousMode,
-                                           (PVOID*)&ExpDefaultErrorPort,
-                                           NULL);
-
-        /* Check for Success */
-        if(NT_SUCCESS(Status))
-        {
-            /* Save the data */
-            ExpDefaultErrorPortProcess = PsGetCurrentProcess();
-            ExReadyForErrors = TRUE;
-        }
-    }
-
-    /* Return status to caller */
-    return Status;
-}
-
-VOID
-__cdecl
-_purecall(VOID)
-{
-    /* Not supported in Kernel Mode */
-    RtlRaiseStatus(STATUS_NOT_IMPLEMENTED);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/event.c
+++ b/reactos/ntoskrnl/ex/event.c
@@ -1,520 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/event.c
- * PURPOSE:         Event support
- * PROGRAMMERS:     Alex Ionescu(alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeEventImplementation)
-#endif
-
-/* GLOBALS *******************************************************************/
-
-POBJECT_TYPE ExEventObjectType = NULL;
-
-GENERIC_MAPPING ExpEventMapping =
-{
-    STANDARD_RIGHTS_READ | SYNCHRONIZE | EVENT_QUERY_STATE,
-    STANDARD_RIGHTS_WRITE | SYNCHRONIZE | EVENT_MODIFY_STATE,
-    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | EVENT_QUERY_STATE,
-    EVENT_ALL_ACCESS};
-
-static const INFORMATION_CLASS_INFO ExEventInfoClass[] =
-{
-    /* EventBasicInformation */
-    ICI_SQ_SAME( sizeof(EVENT_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY),
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeEventImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Event Object Type\n");
-
-    /* Create the Event Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Event");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT);
-    ObjectTypeInitializer.GenericMapping = ExpEventMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.ValidAccessMask = EVENT_ALL_ACCESS;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExEventObjectType);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtClearEvent(IN HANDLE EventHandle)
-{
-    PKEVENT Event;
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Reference the Object */
-    Status = ObReferenceObjectByHandle(EventHandle,
-                                       EVENT_MODIFY_STATE,
-                                       ExEventObjectType,
-                                       ExGetPreviousMode(),
-                                       (PVOID*)&Event,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Clear the Event and Dereference */
-        KeClearEvent(Event);
-        ObDereferenceObject(Event);
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtCreateEvent(OUT PHANDLE EventHandle,
-              IN ACCESS_MASK DesiredAccess,
-              IN POBJECT_ATTRIBUTES ObjectAttributes  OPTIONAL,
-              IN EVENT_TYPE EventType,
-              IN BOOLEAN InitialState)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    PKEVENT Event;
-    HANDLE hEvent;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n",
-            EventHandle, DesiredAccess, ObjectAttributes);
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(EventHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Create the Object */
-    Status = ObCreateObject(PreviousMode,
-                            ExEventObjectType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(KEVENT),
-                            0,
-                            0,
-                            (PVOID*)&Event);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Initalize the Event */
-        KeInitializeEvent(Event,
-                          EventType,
-                          InitialState);
-
-        /* Insert it */
-        Status = ObInsertObject((PVOID)Event,
-                                 NULL,
-                                 DesiredAccess,
-                                 0,
-                                 NULL,
-                                 &hEvent);
-
-        /* Check for success */
-        if(NT_SUCCESS(Status))
-        {
-            /* Enter SEH for return */
-            _SEH_TRY
-            {
-                /* Return the handle to the caller */
-                *EventHandle = hEvent;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtOpenEvent(OUT PHANDLE EventHandle,
-            IN ACCESS_MASK DesiredAccess,
-            IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    HANDLE hEvent;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n",
-            EventHandle, DesiredAccess, ObjectAttributes);
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(EventHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObOpenObjectByName(ObjectAttributes,
-                                ExEventObjectType,
-                                PreviousMode,
-                                NULL,
-                                DesiredAccess,
-                                NULL,
-                                &hEvent);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Enter SEH for return */
-        _SEH_TRY
-        {
-            /* Return the handle to the caller */
-            *EventHandle = hEvent;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtPulseEvent(IN HANDLE EventHandle,
-             OUT PLONG PreviousState OPTIONAL)
-{
-    PKEVENT Event;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtPulseEvent(EventHandle 0%x PreviousState 0%x)\n",
-            EventHandle, PreviousState);
-
-    /* Check if we were called from user-mode */
-    if((PreviousState) && (PreviousMode != KernelMode))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the state pointer is valid */
-            ProbeForWriteLong(PreviousState);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventHandle,
-                                       EVENT_MODIFY_STATE,
-                                       ExEventObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Event,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Pulse the Event */
-        LONG Prev = KePulseEvent(Event, EVENT_INCREMENT, FALSE);
-        ObDereferenceObject(Event);
-
-        /* Check if caller wants the old state back */
-        if(PreviousState)
-        {
-            /* Entry SEH Block for return */
-            _SEH_TRY
-            {
-                /* Return previous state */
-                *PreviousState = Prev;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-   }
-
-   /* Return Status */
-   return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtQueryEvent(IN HANDLE EventHandle,
-             IN EVENT_INFORMATION_CLASS EventInformationClass,
-             OUT PVOID EventInformation,
-             IN ULONG EventInformationLength,
-             OUT PULONG ReturnLength  OPTIONAL)
-{
-    PKEVENT Event;
-    KPROCESSOR_MODE PreviousMode  = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PEVENT_BASIC_INFORMATION BasicInfo =
-        (PEVENT_BASIC_INFORMATION)EventInformation;
-    PAGED_CODE();
-    DPRINT("NtQueryEvent(0x%p, 0x%x)\n", EventHandle, EventInformationClass);
-
-    /* Check buffers and class validity */
-    Status = DefaultQueryInfoBufferCheck(EventInformationClass,
-                                         ExEventInfoClass,
-                                         sizeof(ExEventInfoClass) /
-                                         sizeof(ExEventInfoClass[0]),
-                                         EventInformation,
-                                         EventInformationLength,
-                                         ReturnLength,
-                                         PreviousMode);
-    if(!NT_SUCCESS(Status))
-    {
-        /* Invalid buffers */
-        DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status);
-        return Status;
-    }
-
-    /* Get the Object */
-    Status = ObReferenceObjectByHandle(EventHandle,
-                                       EVENT_QUERY_STATE,
-                                       ExEventObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Event,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Return Event Type and State */
-            BasicInfo->EventType = Event->Header.Type;
-            BasicInfo->EventState = KeReadStateEvent(Event);
-
-            /* Return length */
-            if(ReturnLength) *ReturnLength = sizeof(EVENT_BASIC_INFORMATION);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Dereference the Object */
-        ObDereferenceObject(Event);
-   }
-
-   /* Return status */
-   return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtResetEvent(IN HANDLE EventHandle,
-             OUT PLONG PreviousState OPTIONAL)
-{
-    PKEVENT Event;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtResetEvent(EventHandle 0%x PreviousState 0%x)\n",
-            EventHandle, PreviousState);
-
-    /* Check if we were called from user-mode */
-    if((PreviousState) && (PreviousMode != KernelMode))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the state pointer is valid */
-            ProbeForWriteLong(PreviousState);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventHandle,
-                                       EVENT_MODIFY_STATE,
-                                       ExEventObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Event,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Reset the Event */
-        LONG Prev = KeResetEvent(Event);
-        ObDereferenceObject(Event);
-
-        /* Check if caller wants the old state back */
-        if(PreviousState)
-        {
-            /* Entry SEH Block for return */
-            _SEH_TRY
-            {
-                /* Return previous state */
-                *PreviousState = Prev;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-   }
-
-   /* Return Status */
-   return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtSetEvent(IN HANDLE EventHandle,
-           OUT PLONG PreviousState  OPTIONAL)
-{
-    PKEVENT Event;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtSetEvent(EventHandle 0%x PreviousState 0%x)\n",
-           EventHandle, PreviousState);
-
-    /* Check if we were called from user-mode */
-    if((PreviousState) && (PreviousMode != KernelMode))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the state pointer is valid */
-            ProbeForWriteLong(PreviousState);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventHandle,
-                                       EVENT_MODIFY_STATE,
-                                       ExEventObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Event,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Set the Event */
-        LONG Prev = KeSetEvent(Event, EVENT_INCREMENT, FALSE);
-        ObDereferenceObject(Event);
-
-        /* Check if caller wants the old state back */
-        if(PreviousState)
-        {
-            /* Entry SEH Block for return */
-            _SEH_TRY
-            {
-                /* Return previous state */
-                *PreviousState = Prev;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-   }
-
-   /* Return Status */
-   return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/evtpair.c
+++ b/reactos/ntoskrnl/ex/evtpair.c
@@ -1,406 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/evtpair.c
- * PURPOSE:         Support for event pairs
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeEventPairImplementation)
-#endif
-
-/* GLOBALS *******************************************************************/
-
-POBJECT_TYPE ExEventPairObjectType = NULL;
-
-GENERIC_MAPPING ExEventPairMapping =
-{
-    STANDARD_RIGHTS_READ,
-    STANDARD_RIGHTS_WRITE,
-    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
-    EVENT_PAIR_ALL_ACCESS
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeEventPairImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Event Pair Object Type\n");
-
-    /* Create the Event Pair Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"EventPair");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR);
-    ObjectTypeInitializer.GenericMapping = ExEventPairMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS;
-    ObjectTypeInitializer.UseDefaultObject = TRUE;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExEventPairObjectType);
-}
-
-NTSTATUS
-NTAPI
-NtCreateEventPair(OUT PHANDLE EventPairHandle,
-                  IN ACCESS_MASK DesiredAccess,
-                  IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    PKEVENT_PAIR EventPair;
-    HANDLE hEventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle);
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(EventPairHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Create the Object */
-    DPRINT("Creating EventPair\n");
-    Status = ObCreateObject(PreviousMode,
-                            ExEventPairObjectType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(KEVENT_PAIR),
-                            0,
-                            0,
-                            (PVOID*)&EventPair);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Initalize the Event */
-        DPRINT("Initializing EventPair\n");
-        KeInitializeEventPair(EventPair);
-
-        /* Insert it */
-        Status = ObInsertObject((PVOID)EventPair,
-                                 NULL,
-                                 DesiredAccess,
-                                 0,
-                                 NULL,
-                                 &hEventPair);
-
-        /* Check for success and return handle */
-        if(NT_SUCCESS(Status))
-        {
-            _SEH_TRY
-            {
-                *EventPairHandle = hEventPair;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtOpenEventPair(OUT PHANDLE EventPairHandle,
-                IN ACCESS_MASK DesiredAccess,
-                IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    HANDLE hEventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(EventPairHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObOpenObjectByName(ObjectAttributes,
-                                ExEventPairObjectType,
-                                PreviousMode,
-                                NULL,
-                                DesiredAccess,
-                                NULL,
-                                &hEventPair);
-
-    /* Check for success and return handle */
-    if(NT_SUCCESS(Status))
-    {
-        _SEH_TRY
-        {
-            *EventPairHandle = hEventPair;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtSetHighEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-    DPRINT("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Set the Event */
-        KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtSetHighWaitLowEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-    DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Set the Event */
-        KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE);
-
-        /* Wait for the Other one */
-        KeWaitForSingleObject(&EventPair->LowEvent,
-                              WrEventPair,
-                              PreviousMode,
-                              FALSE,
-                              NULL);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtSetLowEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-    DPRINT1("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Set the Event */
-        KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtSetLowWaitHighEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-    DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Set the Event */
-        KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE);
-
-        /* Wait for the Other one */
-        KeWaitForSingleObject(&EventPair->HighEvent,
-                              WrEventPair,
-                              PreviousMode,
-                              FALSE,
-                              NULL);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-
-NTSTATUS
-NTAPI
-NtWaitLowEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-    DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Wait for the Event */
-        KeWaitForSingleObject(&EventPair->LowEvent,
-                              WrEventPair,
-                              PreviousMode,
-                              FALSE,
-                              NULL);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtWaitHighEventPair(IN HANDLE EventPairHandle)
-{
-    PKEVENT_PAIR EventPair;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-
-    PAGED_CODE();
-    DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle);
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(EventPairHandle,
-                                       SYNCHRONIZE,
-                                       ExEventPairObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&EventPair,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Wait for the Event */
-        KeWaitForSingleObject(&EventPair->HighEvent,
-                              WrEventPair,
-                              PreviousMode,
-                              FALSE,
-                              NULL);
-
-        /* Dereference Object */
-        ObDereferenceObject(EventPair);
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/fmutex.c
+++ b/reactos/ntoskrnl/ex/fmutex.c
@@ -1,219 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/fmutex.c
- * PURPOSE:         Implements fast mutexes
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#include <internal/debug.h>
-
-VOID
-FASTCALL
-KiAcquireFastMutex(IN PFAST_MUTEX FastMutex);
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExEnterCriticalRegionAndAcquireFastMutexUnsafe(PFAST_MUTEX FastMutex)
-{
-    PKTHREAD Thread = KeGetCurrentThread();
-
-    /* Enter the Critical Region */
-    KeEnterCriticalRegion();
-    /*
-    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (Thread == NULL) ||
-           (Thread->CombinedApcDisable != 0) ||
-           (Thread->Teb == NULL) ||
-           (Thread->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
-    */
-    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (Thread == NULL) ||
-           (Thread->CombinedApcDisable != 0));
-           
-    ASSERT((Thread == NULL) || (FastMutex->Owner != Thread));
-
-    /* Decrease the count */
-    if (InterlockedDecrement(&FastMutex->Count))
-    {
-        /* Someone is still holding it, use slow path */
-        KiAcquireFastMutex(FastMutex);
-    }
-
-    /* Set the owner */
-    FastMutex->Owner = Thread;
-}
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(PFAST_MUTEX FastMutex)
-{
-    /*
-    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (KeGetCurrentThread() == NULL) ||
-           (KeGetCurrentThread()->CombinedApcDisable != 0) ||
-           (KeGetCurrentThread()->Teb == NULL) ||
-           (KeGetCurrentThread()->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
-   
-    */
-     ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (KeGetCurrentThread() == NULL) ||
-           (KeGetCurrentThread()->CombinedApcDisable != 0));
-     ASSERT(FastMutex->Owner == KeGetCurrentThread());        
-  
-    /* Erase the owner */
-    FastMutex->Owner = NULL;
-
-    /* Increase the count */
-    if (InterlockedIncrement(&FastMutex->Count) <= 0)
-    {
-        /* Someone was waiting for it, signal the waiter */
-        KeSetEventBoostPriority(&FastMutex->Gate, IO_NO_INCREMENT);
-    }
-
-    /* Leave the critical region */
-    KeLeaveCriticalRegion();
-}
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExAcquireFastMutex(PFAST_MUTEX FastMutex)
-{
-    KIRQL OldIrql;
-    ASSERT_IRQL_LESS_OR_EQUAL(APC_LEVEL);
-
-    /* Raise IRQL to APC */
-    OldIrql = KfRaiseIrql(APC_LEVEL);
-   
-    /* Decrease the count */
-    if (InterlockedDecrement(&FastMutex->Count))
-    {
-        /* Someone is still holding it, use slow path */
-        KiAcquireFastMutex(FastMutex);
-    }
-
-    /* Set the owner and IRQL */
-    FastMutex->Owner = KeGetCurrentThread();
-    FastMutex->OldIrql = OldIrql;
-}
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExReleaseFastMutex (PFAST_MUTEX FastMutex)
-{
-    KIRQL OldIrql;
-    ASSERT_IRQL(APC_LEVEL);
-
-    /* Erase the owner */
-    FastMutex->Owner = NULL;
-    OldIrql = FastMutex->OldIrql;
-
-    /* Increase the count */
-    if (InterlockedIncrement(&FastMutex->Count) <= 0)
-    {
-        /* Someone was waiting for it, signal the waiter */
-        KeSetEventBoostPriority(&FastMutex->Gate, IO_NO_INCREMENT);
-    }
-
-    /* Lower IRQL back */
-    KfLowerIrql(OldIrql);
-}
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExAcquireFastMutexUnsafe(PFAST_MUTEX FastMutex)
-{
-    PKTHREAD Thread = KeGetCurrentThread();
-    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (Thread == NULL) ||
-           (Thread->CombinedApcDisable != 0) ||
-           (Thread->Teb == NULL) ||
-           (Thread->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
-    ASSERT((Thread == NULL) || (FastMutex->Owner != Thread));
-
-    /* Decrease the count */
-    if (InterlockedDecrement(&FastMutex->Count))
-    {
-        /* Someone is still holding it, use slow path */
-        KiAcquireFastMutex(FastMutex);
-    }
-
-    /* Set the owner */
-    FastMutex->Owner = Thread;
-}
-
-/*
- * @implemented
- */
-VOID
-FASTCALL
-ExReleaseFastMutexUnsafe(PFAST_MUTEX FastMutex)
-{
-    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
-           (KeGetCurrentThread() == NULL) ||
-           (KeGetCurrentThread()->CombinedApcDisable != 0) ||
-           (KeGetCurrentThread()->Teb == NULL) ||
-           (KeGetCurrentThread()->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
-    ASSERT(FastMutex->Owner == KeGetCurrentThread());
-  
-    /* Erase the owner */
-    FastMutex->Owner = NULL;
-
-    /* Increase the count */
-    if (InterlockedIncrement(&FastMutex->Count) <= 0)
-    {
-        /* Someone was waiting for it, signal the waiter */
-        KeSetEventBoostPriority(&FastMutex->Gate, IO_NO_INCREMENT);
-    }
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-FASTCALL
-ExTryToAcquireFastMutex(PFAST_MUTEX FastMutex)
-{
-    KIRQL OldIrql;
-    ASSERT_IRQL_LESS_OR_EQUAL(APC_LEVEL);
-
-    /* Raise to APC_LEVEL */
-    OldIrql = KfRaiseIrql(APC_LEVEL);
-
-    /* Check if we can quickly acquire it */
-    if (InterlockedCompareExchange(&FastMutex->Count, 0, 1) == 1)
-    {
-        /* We have, set us as owners */
-        FastMutex->Owner = KeGetCurrentThread();
-        FastMutex->OldIrql = OldIrql;
-        return TRUE;
-    }
-    else
-    {
-        /* Acquire attempt failed */
-        KfLowerIrql(OldIrql);
-        return FALSE;
-    }
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/handle.c
+++ b/reactos/ntoskrnl/ex/handle.c
@@ -1,942 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/handle.c
- * PURPOSE:         Generic Executive Handle Tables
- *
- * PROGRAMMERS:     Thomas Weidenmueller <w3seek@reactos.com>
- *
- *  TODO:
- *
- *  - the last entry of a subhandle list should be reserved for auditing
- *
- *  ExReferenceHandleDebugInfo
- *  ExSnapShotHandleTables
- *  ExpMoveFreeHandles (???)
- */
-
-/* INCLUDES *****************************************************************/
-
-#define NTDDI_VERSION NTDDI_WIN2K
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-static LIST_ENTRY ExpHandleTableHead;
-static FAST_MUTEX ExpHandleTableListLock;
-static LARGE_INTEGER ExpHandleShortWait;
-
-#define ExAcquireHandleTableListLock()                                         \
-  ExAcquireFastMutexUnsafe(&ExpHandleTableListLock)
-
-#define ExReleaseHandleTableListLock()                                         \
-  ExReleaseFastMutexUnsafe(&ExpHandleTableListLock)
-
-#define ExAcquireHandleLockExclusive(HandleTable)                         \
-  ExAcquireResourceExclusiveLite(&(HandleTable)->HandleLock, TRUE)
-
-#define ExAcquireHandleLockShared(HandleTable)                            \
-  ExAcquireResourceSharedLite(&(HandleTable)->HandleLock, TRUE)
-
-#define ExReleaseHandleLock(HandleTable)                                  \
-  ExReleaseResourceLite(&(HandleTable)->HandleLock)
-
-/*
-   5 bits: reserved
-   8 bits: top level index
-   10 bits: middle level index
-   9 bits: sub handle index
-*/
-#define N_TLI_BITS 8 /* top level index */
-#define N_MLI_BITS 10 /* middle level index */
-#define N_EI_BITS 9 /* sub handle index */
-#define TLI_OFFSET (N_MLI_BITS + N_EI_BITS)
-#define MLI_OFFSET N_EI_BITS
-#define EI_OFFSET 0
-
-#define N_TOPLEVEL_POINTERS (1 << N_TLI_BITS)
-#define N_MIDDLELEVEL_POINTERS (1 << N_MLI_BITS)
-#define N_SUBHANDLE_ENTRIES (1 << N_EI_BITS)
-#define EX_MAX_HANDLES (N_TOPLEVEL_POINTERS * N_MIDDLELEVEL_POINTERS * N_SUBHANDLE_ENTRIES)
-
-#define VALID_HANDLE_MASK (((N_TOPLEVEL_POINTERS - 1) << TLI_OFFSET) |         \
-  ((N_MIDDLELEVEL_POINTERS - 1) << MLI_OFFSET) | ((N_SUBHANDLE_ENTRIES - 1) << EI_OFFSET))
-#define TLI_FROM_HANDLE(index) (ULONG)(((index) >> TLI_OFFSET) & (N_TOPLEVEL_POINTERS - 1))
-#define MLI_FROM_HANDLE(index) (ULONG)(((index) >> MLI_OFFSET) & (N_MIDDLELEVEL_POINTERS - 1))
-#define ELI_FROM_HANDLE(index) (ULONG)(((index) >> EI_OFFSET) & (N_SUBHANDLE_ENTRIES - 1))
-
-#define N_MAX_HANDLE (N_TOPLEVEL_POINTERS * N_MIDDLELEVEL_POINTERS * N_SUBHANDLE_ENTRIES)
-
-#define BUILD_HANDLE(tli, mli, eli) ((((tli) & (N_TOPLEVEL_POINTERS - 1)) << TLI_OFFSET) | \
-  (((mli) & (N_MIDDLELEVEL_POINTERS - 1)) << MLI_OFFSET) | (((eli) & (N_SUBHANDLE_ENTRIES - 1)) << EI_OFFSET))
-
-#define IS_INVALID_EX_HANDLE(index)                                            \
-  (((index) & ~VALID_HANDLE_MASK) != 0)
-#define IS_VALID_EX_HANDLE(index)                                              \
-  (((index) & ~VALID_HANDLE_MASK) == 0)
-
-#define HANDLE_TO_EX_HANDLE(handle)                                            \
-  (LONG)(((LONG)(handle) >> 2) - 1)
-#define EX_HANDLE_TO_HANDLE(exhandle)                                          \
-  (HANDLE)(((exhandle) + 1) << 2)
-
-static BOOLEAN ExpInitialized = FALSE;
-
-/******************************************************************************/
-
-VOID
-ExpInitializeHandleTables(VOID)
-{
-  ExpHandleShortWait.QuadPart = -50000;
-  InitializeListHead(&ExpHandleTableHead);
-  ExInitializeFastMutex(&ExpHandleTableListLock);
-
-  ExpInitialized = TRUE;
-}
-
-PHANDLE_TABLE
-ExCreateHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL)
-{
-  PHANDLE_TABLE HandleTable;
-
-  PAGED_CODE();
-
-  if(!ExpInitialized)
-  {
-    KEBUGCHECK(0);
-  }
-
-  if(QuotaProcess != NULL)
-  {
-    /* FIXME - Charge process quota before allocating the handle table! */
-  }
-
-  /* allocate enough memory for the handle table and the lowest level */
-  HandleTable = ExAllocatePoolWithTag(NonPagedPool,
-                                      sizeof(HANDLE_TABLE) + (N_TOPLEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY*)),
-                                      TAG('E', 'x', 'H', 't'));
-  if(HandleTable != NULL)
-  {
-    /* initialize the handle table */
-    HandleTable->Flags = 0;
-    HandleTable->HandleCount = 0;
-    HandleTable->Table = (PHANDLE_TABLE_ENTRY**)(HandleTable + 1);
-    HandleTable->QuotaProcess = QuotaProcess;
-    HandleTable->FirstFree = -1; /* no entries freed so far */
-    HandleTable->NextHandleNeedingPool = 0; /* no entries freed so far, so we have to allocate already for the first handle */
-    HandleTable->UniqueProcessId = (QuotaProcess ? QuotaProcess->UniqueProcessId : NULL);
-
-    ExInitializeResource(&HandleTable->HandleLock);
-
-    KeInitializeEvent(&HandleTable->HandleContentionEvent,
-                      NotificationEvent,
-                      FALSE);
-
-    RtlZeroMemory(HandleTable->Table, N_TOPLEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY*));
-
-    /* during bootup KeGetCurrentThread() might be NULL, needs to be fixed... */
-    if(KeGetCurrentThread() != NULL)
-    {
-      /* insert it into the global handle table list */
-      KeEnterCriticalRegion();
-
-      ExAcquireHandleTableListLock();
-      InsertTailList(&ExpHandleTableHead,
-                     &HandleTable->HandleTableList);
-      ExReleaseHandleTableListLock();
-
-      KeLeaveCriticalRegion();
-    }
-    else
-    {
-      InsertTailList(&ExpHandleTableHead,
-                     &HandleTable->HandleTableList);
-    }
-  }
-  else
-  {
-    /* FIXME - return the quota to the process */
-  }
-
-  return HandleTable;
-}
-
-VOID
-ExSweepHandleTable(IN PHANDLE_TABLE HandleTable,
-                   IN PEX_SWEEP_HANDLE_CALLBACK SweepHandleCallback  OPTIONAL,
-                   IN PVOID Context  OPTIONAL)
-{
-  PHANDLE_TABLE_ENTRY **tlp, **lasttlp, *mlp, *lastmlp;
-  LONG ExHandle = 0;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-
-  KeEnterCriticalRegion();
-
-  /* ensure there's no other operations going by acquiring an exclusive lock */
-  ExAcquireHandleLockExclusive(HandleTable);
-
-  ASSERT(!(HandleTable->Flags & EX_HANDLE_TABLE_CLOSING));
-
-  HandleTable->Flags |= EX_HANDLE_TABLE_CLOSING;
-
-  KePulseEvent(&HandleTable->HandleContentionEvent,
-               EVENT_INCREMENT,
-               FALSE);
-
-  /* call the callback function to cleanup the objects associated with the
-     handle table */
-  for(tlp = HandleTable->Table, lasttlp = HandleTable->Table + N_TOPLEVEL_POINTERS;
-      tlp != lasttlp;
-      tlp++)
-  {
-    if((*tlp) != NULL)
-    {
-      for(mlp = *tlp, lastmlp = (*tlp) + N_MIDDLELEVEL_POINTERS;
-          mlp != lastmlp;
-          mlp++)
-      {
-        if((*mlp) != NULL)
-        {
-          PHANDLE_TABLE_ENTRY curee, laste;
-
-          for(curee = *mlp, laste = *mlp + N_SUBHANDLE_ENTRIES;
-              curee != laste;
-              curee++)
-          {
-            if(curee->Object != NULL && SweepHandleCallback != NULL)
-            {
-              curee->ObAttributes |= EX_HANDLE_ENTRY_LOCKED;
-              SweepHandleCallback(curee, EX_HANDLE_TO_HANDLE(ExHandle), Context);
-            }
-
-            ExHandle++;
-          }
-        }
-        else
-          break;
-      }
-    }
-    else
-      break;
-  }
-
-  ExReleaseHandleLock(HandleTable);
-
-  KeLeaveCriticalRegion();
-}
-
-VOID
-ExDestroyHandleTable(IN PHANDLE_TABLE HandleTable)
-{
-  PHANDLE_TABLE_ENTRY **tlp, **lasttlp, *mlp, *lastmlp;
-  PEPROCESS QuotaProcess;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(HandleTable->Flags & EX_HANDLE_TABLE_CLOSING);
-
-  KeEnterCriticalRegion();
-
-  /* at this point the table should not be queried or altered anymore,
-     no locks should be necessary */
-
-  ASSERT(HandleTable->Flags & EX_HANDLE_TABLE_CLOSING);
-
-  /* remove the handle table from the global handle table list */
-  ExAcquireHandleTableListLock();
-  RemoveEntryList(&HandleTable->HandleTableList);
-  ExReleaseHandleTableListLock();
-
-  QuotaProcess = HandleTable->QuotaProcess;
-
-  /* free the tables */
-  for(tlp = HandleTable->Table, lasttlp = HandleTable->Table + N_TOPLEVEL_POINTERS;
-      tlp != lasttlp;
-      tlp++)
-  {
-    if((*tlp) != NULL)
-    {
-      for(mlp = *tlp, lastmlp = (*tlp) + N_MIDDLELEVEL_POINTERS;
-          mlp != lastmlp;
-          mlp++)
-      {
-        if((*mlp) != NULL)
-        {
-          ExFreePool(*mlp);
-
-          if(QuotaProcess != NULL)
-          {
-            /* FIXME - return the quota to the process */
-          }
-        }
-      }
-
-      ExFreePool(*tlp);
-
-      if(QuotaProcess != NULL)
-      {
-        /* FIXME - return the quota to the process */
-      }
-    }
-  }
-
-  KeLeaveCriticalRegion();
-
-  /* free the handle table */
-  ExDeleteResource(&HandleTable->HandleLock);
-  ExFreePool(HandleTable);
-
-  if(QuotaProcess != NULL)
-  {
-    /* FIXME - return the quota to the process */
-  }
-}
-
-PHANDLE_TABLE
-ExDupHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL,
-                 IN PEX_DUPLICATE_HANDLE_CALLBACK DuplicateHandleCallback  OPTIONAL,
-                 IN PVOID Context  OPTIONAL,
-                 IN PHANDLE_TABLE SourceHandleTable)
-{
-  PHANDLE_TABLE HandleTable;
-
-  PAGED_CODE();
-
-  ASSERT(SourceHandleTable);
-
-  HandleTable = ExCreateHandleTable(QuotaProcess);
-  if(HandleTable != NULL)
-  {
-    PHANDLE_TABLE_ENTRY **tlp, **srctlp, **etlp, *mlp, *srcmlp, *emlp, stbl, srcstbl, estbl;
-    LONG tli, mli, eli;
-
-    tli = mli = eli = 0;
-
-    /* make sure the other handle table isn't being changed during the duplication */
-    ExAcquireHandleLockShared(SourceHandleTable);
-
-    /* allocate enough tables */
-    etlp = SourceHandleTable->Table + N_TOPLEVEL_POINTERS;
-    for(srctlp = SourceHandleTable->Table, tlp = HandleTable->Table;
-        srctlp != etlp;
-        srctlp++, tlp++)
-    {
-      if(*srctlp != NULL)
-      {
-        /* allocate middle level entry tables */
-        if(QuotaProcess != NULL)
-        {
-          /* FIXME - Charge process quota before allocating the handle table! */
-        }
-
-        *tlp = ExAllocatePoolWithTag(PagedPool,
-                                     N_MIDDLELEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY),
-                                     TAG('E', 'x', 'H', 't'));
-        if(*tlp != NULL)
-        {
-          RtlZeroMemory(*tlp, N_MIDDLELEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY));
-
-          KeMemoryBarrier();
-
-          emlp = *srctlp + N_MIDDLELEVEL_POINTERS;
-          for(srcmlp = *srctlp, mlp = *tlp;
-              srcmlp != emlp;
-              srcmlp++, mlp++)
-          {
-            if(*srcmlp != NULL)
-            {
-              /* allocate subhandle tables */
-              if(QuotaProcess != NULL)
-              {
-                /* FIXME - Charge process quota before allocating the handle table! */
-              }
-
-              *mlp = ExAllocatePoolWithTag(PagedPool,
-                                           N_SUBHANDLE_ENTRIES * sizeof(HANDLE_TABLE_ENTRY),
-                                           TAG('E', 'x', 'H', 't'));
-              if(*mlp != NULL)
-              {
-                RtlZeroMemory(*mlp, N_SUBHANDLE_ENTRIES * sizeof(HANDLE_TABLE_ENTRY));
-              }
-              else
-              {
-                goto freehandletable;
-              }
-            }
-            else
-            {
-              *mlp = NULL;
-            }
-          }
-        }
-        else
-        {
-freehandletable:
-          DPRINT1("Failed to duplicate handle table 0x%p\n", SourceHandleTable);
-
-          ExReleaseHandleLock(SourceHandleTable);
-
-          ExDestroyHandleTable(HandleTable);
-          /* allocate an empty handle table */
-          return ExCreateHandleTable(QuotaProcess);
-        }
-      }
-    }
-
-    /* duplicate the handles */
-    HandleTable->HandleCount = SourceHandleTable->HandleCount;
-    HandleTable->FirstFree = SourceHandleTable->FirstFree;
-    HandleTable->NextHandleNeedingPool = SourceHandleTable->NextHandleNeedingPool;
-
-    /* make sure all tables are zeroed */
-    KeMemoryBarrier();
-
-    etlp = SourceHandleTable->Table + N_TOPLEVEL_POINTERS;
-    for(srctlp = SourceHandleTable->Table, tlp = HandleTable->Table;
-        srctlp != etlp;
-        srctlp++, tlp++, tli++)
-    {
-      if(*srctlp != NULL)
-      {
-        ASSERT(*tlp != NULL);
-
-        emlp = *srctlp + N_MIDDLELEVEL_POINTERS;
-        for(srcmlp = *srctlp, mlp = *tlp;
-            srcmlp != emlp;
-            srcmlp++, mlp++, mli++)
-        {
-          if(*srcmlp != NULL)
-          {
-            ASSERT(*mlp != NULL);
-
-            /* walk all handle entries and duplicate them if wanted */
-            estbl = *srcmlp + N_SUBHANDLE_ENTRIES;
-            for(srcstbl = *srcmlp, stbl = *mlp;
-                srcstbl != estbl;
-                srcstbl++, stbl++, eli++)
-            {
-              /* try to duplicate the source handle */
-              if(srcstbl->Object != NULL &&
-                 ExLockHandleTableEntry(SourceHandleTable,
-                                        srcstbl))
-              {
-                /* ask the caller if this handle should be duplicated */
-                if(DuplicateHandleCallback != NULL &&
-                   !DuplicateHandleCallback(HandleTable,
-                                            srcstbl,
-                                            Context))
-                {
-                  /* free the entry and chain it into the free list */
-                  HandleTable->HandleCount--;
-                  stbl->Object = NULL;
-                  stbl->NextFreeTableEntry = HandleTable->FirstFree;
-                  HandleTable->FirstFree = BUILD_HANDLE(tli, mli, eli);
-                }
-                else
-                {
-                  /* duplicate the handle and unlock it */
-                  stbl->GrantedAccess = srcstbl->GrantedAccess;
-                  stbl->ObAttributes = srcstbl->ObAttributes & ~EX_HANDLE_ENTRY_LOCKED;
-                }
-                ExUnlockHandleTableEntry(SourceHandleTable,
-                                         srcstbl);
-              }
-              else
-              {
-                /* this is a free handle table entry, copy over the entire
-                   structure as-is */
-                *stbl = *srcstbl;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    /* release the source handle table */
-    ExReleaseHandleLock(SourceHandleTable);
-  }
-
-  return HandleTable;
-}
-
-static PHANDLE_TABLE_ENTRY
-ExpAllocateHandleTableEntry(IN PHANDLE_TABLE HandleTable,
-                            OUT PHANDLE Handle)
-{
-  PHANDLE_TABLE_ENTRY Entry = NULL;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(Handle);
-  ASSERT(KeGetCurrentThread() != NULL);
-
-  DPRINT("HT[0x%p]: HandleCount: %d\n", HandleTable, HandleTable->HandleCount);
-
-  if(HandleTable->HandleCount < EX_MAX_HANDLES)
-  {
-    ULONG tli, mli, eli;
-
-    if(HandleTable->FirstFree != -1)
-    {
-      /* there's a free handle entry we can just grab and use */
-      tli = TLI_FROM_HANDLE(HandleTable->FirstFree);
-      mli = MLI_FROM_HANDLE(HandleTable->FirstFree);
-      eli = ELI_FROM_HANDLE(HandleTable->FirstFree);
-
-      /* the pointer should be valid in any way!!! */
-      ASSERT(HandleTable->Table[tli]);
-      ASSERT(HandleTable->Table[tli][mli]);
-
-      Entry = &HandleTable->Table[tli][mli][eli];
-
-      *Handle = EX_HANDLE_TO_HANDLE(HandleTable->FirstFree);
-
-      /* save the index to the next free handle (if available) */
-      HandleTable->FirstFree = Entry->NextFreeTableEntry;
-      Entry->NextFreeTableEntry = 0;
-      Entry->Object = NULL;
-
-      HandleTable->HandleCount++;
-    }
-    else
-    {
-      /* we need to allocate a new subhandle table first */
-      PHANDLE_TABLE_ENTRY cure, laste, ntbl, *nmtbl;
-      ULONG i;
-      BOOLEAN AllocatedMtbl;
-
-      ASSERT(HandleTable->NextHandleNeedingPool <= N_MAX_HANDLE);
-
-      /* the index of the next table to be allocated was saved in
-         NextHandleNeedingPool the last time a handle entry was allocated and
-         the subhandle entry list was full. the subhandle entry index of
-         NextHandleNeedingPool should be 0 here! */
-      tli = TLI_FROM_HANDLE(HandleTable->NextHandleNeedingPool);
-      mli = MLI_FROM_HANDLE(HandleTable->NextHandleNeedingPool);
-      DPRINT("HandleTable->NextHandleNeedingPool: 0x%x\n", HandleTable->NextHandleNeedingPool);
-      DPRINT("tli: 0x%x mli: 0x%x eli: 0x%x\n", tli, mli, ELI_FROM_HANDLE(HandleTable->NextHandleNeedingPool));
-
-      ASSERT(ELI_FROM_HANDLE(HandleTable->NextHandleNeedingPool) == 0);
-
-      DPRINT("HandleTable->Table[%d] == 0x%p\n", tli, HandleTable->Table[tli]);
-
-      /* allocate a middle level entry list if required */
-      nmtbl = HandleTable->Table[tli];
-      if(nmtbl == NULL)
-      {
-        if(HandleTable->QuotaProcess != NULL)
-        {
-          /* FIXME - Charge process quota before allocating the handle table! */
-        }
-
-        nmtbl = ExAllocatePoolWithTag(PagedPool,
-                                      N_MIDDLELEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY),
-                                      TAG('E', 'x', 'H', 't'));
-        if(nmtbl == NULL)
-        {
-          if(HandleTable->QuotaProcess != NULL)
-          {
-            /* FIXME - return the quota to the process */
-          }
-
-          return NULL;
-        }
-
-        /* clear the middle level entry list */
-        RtlZeroMemory(nmtbl, N_MIDDLELEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY));
-
-        /* make sure the table was zeroed before we set one item */
-        KeMemoryBarrier();
-
-        /* note, don't set the the pointer in the top level list yet because we
-           might screw up lookups if allocating a subhandle entry table failed
-           and this newly allocated table might get freed again */
-        AllocatedMtbl = TRUE;
-      }
-      else
-      {
-        AllocatedMtbl = FALSE;
-
-        /* allocate a subhandle entry table in any case! */
-        ASSERT(nmtbl[mli] == NULL);
-      }
-
-      DPRINT("HandleTable->Table[%d][%d] == 0x%p\n", tli, mli, nmtbl[mli]);
-
-      if(HandleTable->QuotaProcess != NULL)
-      {
-        /* FIXME - Charge process quota before allocating the handle table! */
-      }
-
-      ntbl = ExAllocatePoolWithTag(PagedPool,
-                                   N_SUBHANDLE_ENTRIES * sizeof(HANDLE_TABLE_ENTRY),
-                                   TAG('E', 'x', 'H', 't'));
-      if(ntbl == NULL)
-      {
-        if(HandleTable->QuotaProcess != NULL)
-        {
-          /* FIXME - Return process quota charged  */
-        }
-
-        /* free the middle level entry list, if allocated, because it's empty and
-           unused */
-        if(AllocatedMtbl)
-        {
-          ExFreePool(nmtbl);
-
-          if(HandleTable->QuotaProcess != NULL)
-          {
-            /* FIXME - Return process quota charged  */
-          }
-        }
-
-        return NULL;
-      }
-
-      /* let's just use the very first entry */
-      Entry = ntbl;
-      Entry->ObAttributes = EX_HANDLE_ENTRY_LOCKED;
-      Entry->NextFreeTableEntry = 0;
-
-      *Handle = EX_HANDLE_TO_HANDLE(HandleTable->NextHandleNeedingPool);
-
-      HandleTable->HandleCount++;
-
-      /* set the FirstFree member to the second entry and chain the
-         free entries */
-      HandleTable->FirstFree = HandleTable->NextHandleNeedingPool + 1;
-      for(cure = Entry + 1, laste = Entry + N_SUBHANDLE_ENTRIES, i = HandleTable->FirstFree + 1;
-          cure != laste;
-          cure++, i++)
-      {
-        cure->Object = NULL;
-        cure->NextFreeTableEntry = i;
-      }
-      /* truncate the free entry list */
-      (cure - 1)->NextFreeTableEntry = -1;
-
-      /* save the pointers to the allocated list(s) */
-      (void)InterlockedExchangePointer(&nmtbl[mli], ntbl);
-      if(AllocatedMtbl)
-      {
-        (void)InterlockedExchangePointer(&HandleTable->Table[tli], nmtbl);
-      }
-
-      /* increment the NextHandleNeedingPool to the next index where we need to
-         allocate new memory */
-      HandleTable->NextHandleNeedingPool += N_SUBHANDLE_ENTRIES;
-    }
-  }
-  else
-  {
-    DPRINT1("Can't allocate any more handles in handle table 0x%p!\n", HandleTable);
-  }
-
-  return Entry;
-}
-
-static VOID
-ExpFreeHandleTableEntry(IN PHANDLE_TABLE HandleTable,
-                        IN PHANDLE_TABLE_ENTRY Entry,
-                        IN LONG Handle)
-{
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(Entry);
-  ASSERT(IS_VALID_EX_HANDLE(Handle));
-
-  DPRINT("ExpFreeHandleTableEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
-
-  /* automatically unlock the entry if currently locked. We however don't notify
-     anyone who waited on the handle because we're holding an exclusive lock after
-     all and these locks will fail then */
-  (void)InterlockedExchangePointer(&Entry->Object, NULL);
-  Entry->NextFreeTableEntry = HandleTable->FirstFree;
-  HandleTable->FirstFree = Handle;
-
-  HandleTable->HandleCount--;
-}
-
-static PHANDLE_TABLE_ENTRY
-ExpLookupHandleTableEntry(IN PHANDLE_TABLE HandleTable,
-                          IN LONG Handle)
-{
-  PHANDLE_TABLE_ENTRY Entry = NULL;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-
-  if(IS_VALID_EX_HANDLE(Handle))
-  {
-    ULONG tli, mli, eli;
-    PHANDLE_TABLE_ENTRY *mlp;
-
-    tli = TLI_FROM_HANDLE(Handle);
-    mli = MLI_FROM_HANDLE(Handle);
-    eli = ELI_FROM_HANDLE(Handle);
-
-    mlp = HandleTable->Table[tli];
-    if(Handle < HandleTable->NextHandleNeedingPool &&
-       mlp != NULL && mlp[mli] != NULL && mlp[mli][eli].Object != NULL)
-    {
-      Entry = &mlp[mli][eli];
-      DPRINT("handle lookup 0x%x -> entry 0x%p [HT:0x%p] ptr: 0x%p\n", Handle, Entry, HandleTable, mlp[mli][eli].Object);
-    }
-  }
-  else
-  {
-    DPRINT("Looking up invalid handle 0x%x\n", Handle);
-  }
-
-  return Entry;
-}
-
-BOOLEAN
-ExLockHandleTableEntry(IN PHANDLE_TABLE HandleTable,
-                       IN PHANDLE_TABLE_ENTRY Entry)
-{
-  ULONG_PTR Current, New;
-
-  PAGED_CODE();
-
-  DPRINT("Entering handle table entry 0x%p lock...\n", Entry);
-
-  ASSERT(HandleTable);
-  ASSERT(Entry);
-
-  for(;;)
-  {
-    Current = (volatile ULONG_PTR)Entry->Object;
-
-    if(!Current || (HandleTable->Flags & EX_HANDLE_TABLE_CLOSING))
-    {
-      DPRINT("Attempted to lock empty handle table entry 0x%p or handle table shut down\n", Entry);
-      break;
-    }
-
-    if(!(Current & EX_HANDLE_ENTRY_LOCKED))
-    {
-      New = Current | EX_HANDLE_ENTRY_LOCKED;
-      if(InterlockedCompareExchangePointer(&Entry->Object,
-                                           (PVOID)New,
-                                           (PVOID)Current) == (PVOID)Current)
-      {
-        DPRINT("SUCCESS handle table 0x%p entry 0x%p lock\n", HandleTable, Entry);
-        /* we acquired the lock */
-        return TRUE;
-      }
-    }
-
-    /* wait about 5ms at maximum so we don't wait forever in unfortunate
-       co-incidences where releasing the lock in another thread happens right
-       before we're waiting on the contention event to get pulsed, which might
-       never happen again... */
-    KeWaitForSingleObject(&HandleTable->HandleContentionEvent,
-                          Executive,
-                          KernelMode,
-                          FALSE,
-                          &ExpHandleShortWait);
-  }
-
-  return FALSE;
-}
-
-VOID
-ExUnlockHandleTableEntry(IN PHANDLE_TABLE HandleTable,
-                         IN PHANDLE_TABLE_ENTRY Entry)
-{
-  ULONG_PTR Current, New;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(Entry);
-
-  DPRINT("ExUnlockHandleTableEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
-
-  Current = (volatile ULONG_PTR)Entry->Object;
-
-  ASSERT(Current & EX_HANDLE_ENTRY_LOCKED);
-
-  New = Current & ~EX_HANDLE_ENTRY_LOCKED;
-
-  (void)InterlockedExchangePointer(&Entry->Object,
-                                   (PVOID)New);
-
-  /* we unlocked the entry, pulse the contention event so threads who're waiting
-     on the release can continue */
-  KePulseEvent(&HandleTable->HandleContentionEvent,
-               EVENT_INCREMENT,
-               FALSE);
-}
-
-HANDLE
-ExCreateHandle(IN PHANDLE_TABLE HandleTable,
-               IN PHANDLE_TABLE_ENTRY Entry)
-{
-  PHANDLE_TABLE_ENTRY NewHandleTableEntry;
-  HANDLE Handle = NULL;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(Entry);
-
-  /* The highest bit in Entry->Object has to be 1 so we make sure it's a
-     pointer to kmode memory. It will cleared though because it also indicates
-     the lock */
-  ASSERT((ULONG_PTR)Entry->Object & EX_HANDLE_ENTRY_LOCKED);
-
-  KeEnterCriticalRegion();
-  ExAcquireHandleLockExclusive(HandleTable);
-
-  NewHandleTableEntry = ExpAllocateHandleTableEntry(HandleTable,
-                                                    &Handle);
-  if(NewHandleTableEntry != NULL)
-  {
-    *NewHandleTableEntry = *Entry;
-
-    ExUnlockHandleTableEntry(HandleTable,
-                             NewHandleTableEntry);
-  }
-
-  ExReleaseHandleLock(HandleTable);
-  KeLeaveCriticalRegion();
-
-  return Handle;
-}
-
-BOOLEAN
-ExDestroyHandle(IN PHANDLE_TABLE HandleTable,
-                IN HANDLE Handle)
-{
-  PHANDLE_TABLE_ENTRY HandleTableEntry;
-  LONG ExHandle;
-  BOOLEAN Ret = FALSE;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  
-  ExHandle = HANDLE_TO_EX_HANDLE(Handle);
-
-  KeEnterCriticalRegion();
-  ExAcquireHandleLockExclusive(HandleTable);
-
-  HandleTableEntry = ExpLookupHandleTableEntry(HandleTable,
-                                               ExHandle);
-
-  if(HandleTableEntry != NULL && ExLockHandleTableEntry(HandleTable, HandleTableEntry))
-  {
-    /* free and automatically unlock the handle. However we don't need to pulse
-       the contention event since other locks on this entry will fail */
-    ExpFreeHandleTableEntry(HandleTable,
-                            HandleTableEntry,
-                            ExHandle);
-    Ret = TRUE;
-  }
-
-  ExReleaseHandleLock(HandleTable);
-  KeLeaveCriticalRegion();
-
-  return Ret;
-}
-
-VOID
-ExDestroyHandleByEntry(IN PHANDLE_TABLE HandleTable,
-                       IN PHANDLE_TABLE_ENTRY Entry,
-                       IN HANDLE Handle)
-{
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(Entry);
-
-  /* This routine requires the entry to be locked */
-  ASSERT((ULONG_PTR)Entry->Object & EX_HANDLE_ENTRY_LOCKED);
-
-  DPRINT("DestroyHandleByEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
-
-  if (!(HandleTable->Flags & EX_HANDLE_TABLE_CLOSING))
-  {
-    KeEnterCriticalRegion();
-    ExAcquireHandleLockExclusive(HandleTable);
-
-    /* free and automatically unlock the handle. However we don't need to pulse
-       the contention event since other locks on this entry will fail */
-    ExpFreeHandleTableEntry(HandleTable,
-                            Entry,
-                            HANDLE_TO_EX_HANDLE(Handle));
-
-    ExReleaseHandleLock(HandleTable);
-    KeLeaveCriticalRegion();
-  }
-}
-
-PHANDLE_TABLE_ENTRY
-ExMapHandleToPointer(IN PHANDLE_TABLE HandleTable,
-                     IN HANDLE Handle)
-{
-  PHANDLE_TABLE_ENTRY HandleTableEntry;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-
-  HandleTableEntry = ExpLookupHandleTableEntry(HandleTable,
-                                               HANDLE_TO_EX_HANDLE(Handle));
-  if (HandleTableEntry != NULL && ExLockHandleTableEntry(HandleTable, HandleTableEntry))
-  {
-    DPRINT("ExMapHandleToPointer HT:0x%p Entry:0x%p locked\n", HandleTable, HandleTableEntry);
-    return HandleTableEntry;
-  }
-
-  return NULL;
-}
-
-BOOLEAN
-ExChangeHandle(IN PHANDLE_TABLE HandleTable,
-               IN HANDLE Handle,
-               IN PEX_CHANGE_HANDLE_CALLBACK ChangeHandleCallback,
-               IN PVOID Context)
-{
-  PHANDLE_TABLE_ENTRY HandleTableEntry;
-  BOOLEAN Ret = FALSE;
-
-  PAGED_CODE();
-
-  ASSERT(HandleTable);
-  ASSERT(ChangeHandleCallback);
-
-  KeEnterCriticalRegion();
-
-  HandleTableEntry = ExpLookupHandleTableEntry(HandleTable,
-                                               HANDLE_TO_EX_HANDLE(Handle));
-
-  if(HandleTableEntry != NULL && ExLockHandleTableEntry(HandleTable, HandleTableEntry))
-  {
-    Ret = ChangeHandleCallback(HandleTable,
-                               HandleTableEntry,
-                               Context);
-
-    ExUnlockHandleTableEntry(HandleTable,
-                             HandleTableEntry);
-  }
-
-  KeLeaveCriticalRegion();
-
-  return Ret;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/i386/fastinterlck_asm.S
+++ b/reactos/ntoskrnl/ex/i386/fastinterlck_asm.S
@@ -1,860 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/i386/fastinterlck_asm.S
- * PURPOSE:         FASTCALL Interlocked Functions
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
- 
-/* INCLUDES ******************************************************************/
-#include <ndk/asm.h>
-#include <internal/i386/asmmacro.S>
-.intel_syntax noprefix
-
-/* FUNCTIONS ****************************************************************/
-
-/*
- * NOTE: These functions must obey the following rules:
- *  - Acquire locks only on MP systems.
- *  - Be safe at HIGH_LEVEL (no paged access).
- *  - Preserve flags.
- *  - Disable interrups.
- */
-
-/*VOID
- *FASTCALL
- *ExInterlockedAddLargeStatistic(IN PLARGE_INTEGER Addend,
- *                               IN ULONG Increment)
- */
-.global @ExInterlockedAddLargeStatistic@8
-@ExInterlockedAddLargeStatistic@8:
-
-#ifdef CONFIG_SMP
-    /* Do the addition */
-    lock add [ecx], edx
-
-    /* Check for carry bit and return */
-    jb 1f
-    ret
-
-1:
-    /* Add carry */
-    lock adc dword ptr [ecx+4], 0
-#else
-    /* Do the addition and add the carry */
-    add dword ptr [ecx], edx
-    adc dword ptr [ecx+4], 0
-#endif
-    /* Return */
-    ret
-
-/*ULONG
- *FASTCALL
- *ExfInterlockedAddUlong(IN PULONG Addend,
- *                       IN ULONG Increment,
- *                       IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedAddUlong@12
-@ExfInterlockedAddUlong@12:
-
-    /* Save flags */
-    pushfd
-
-#ifdef CONFIG_SMP
-    /* Get lock address */
-    mov eax, [esp+8]
-.start1:
-#endif
-    /* Disable interrupts */
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(eax, .spin1)
-
-    /* Do the add */
-    mov eax, [ecx]
-    add [ecx], edx
-
-#ifdef CONFIG_SMP
-    /* Get spinlock address and release it */
-    mov edx, [esp+8]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags and return */
-    popfd
-    ret 4
-
-#ifdef CONFIG_SMP
-.spin1:
-    /* Restore flags and spin */
-    popfd
-    pushfd
-    SPIN_ON_LOCK(eax, .start1)
-#endif
-
-/*PLIST_ENTRY
- *FASTCALL
- *ExfInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
- *                             IN PLIST_ENTRY ListEntry,
- *                             IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedInsertHeadList@12
-@ExfInterlockedInsertHeadList@12:
-
-#ifdef CONFIG_SMP
-    /* Save lock address */
-    push esi
-    mov esi, [esp+8]
-#endif
-
-    /* Save flags and disable interrupts */
-    pushfd
-.start2:
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(esi, .spin2)
-
-    /* Get list pointer */
-    mov eax, [ecx]
-
-    /* Do the insert */
-    mov [edx], eax
-    mov [edx+4], ecx
-    mov [ecx], edx
-    mov [eax+4], edx
-
-    /* Release lock and restore flags */
-    RELEASE_SPINLOCK(esi)
-    popfd
-
-#ifdef CONFIG_SMP
-    pop esi
-#endif
-
-    /* Check if list was empty */
-    xor eax, ecx
-    jz 2f
-
-    /* Return list pointer */
-    xor eax, ecx
-2:
-    ret 4
-
-#ifdef CONFIG_SMP
-.spin2:
-    popfd
-    pushfd
-    SPIN_ON_LOCK(esi, .start2)
-#endif
-
-/*PLIST_ENTRY
- *FASTCALL
- *ExfInterlockedInsertTailList(IN PLIST_ENTRY ListHead,
- *                            IN PLIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedInsertTailList@12
-@ExfInterlockedInsertTailList@12:
-
-#ifdef CONFIG_SMP
-    /* Save lock address */
-    push esi
-    mov esi, [esp+8]
-#endif
-
-    /* Save flags and disable interrupts */
-    pushfd
-.start3:
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(esi, .spin3)
-
-    /* Get list pointer */
-    mov eax, [ecx+4]
-
-    /* Do the insert */
-    mov [edx], ecx
-    mov [edx+4], eax
-    mov [ecx+4], edx
-    mov [eax], edx
-
-    /* Release lock and restore flags */
-    RELEASE_SPINLOCK(esi)
-    popfd
-
-#ifdef CONFIG_SMP
-    pop esi
-#endif
-
-    /* Check if list was empty */
-    xor eax, ecx
-    jz 2f
-
-    /* Return list pointer */
-    xor eax, ecx
-2:
-    ret 4
-
-#ifdef CONFIG_SMP
-.spin3:
-    popfd
-    pushfd
-    SPIN_ON_LOCK(esi, .start3)
-#endif
-
-/*PLIST_ENTRY
- *FASTCALL
- *ExfInterlockedRemoveHeadList(IN PLIST_ENTRY ListHead,
- *                             IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedRemoveHeadList@8
-@ExfInterlockedRemoveHeadList@8:
-
-    /* Save flags and disable interrupts */
-.start4:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin4)
-
-    /* Get list pointer */
-    mov eax, [ecx]
-
-    /* Check if it's empty */
-    cmp eax, ecx
-    je 2f
-
-    /* Get the next entry and do the deletion*/
-#ifdef CONFIG_SMP
-    push ebx
-    mov ebx, [eax]
-    mov [ecx], ebx
-    mov [ebx+4], ecx
-#else
-    mov edx, [eax]
-    mov [ecx], edx
-    mov [edx+4], ecx
-#endif
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    RELEASE_SPINLOCK(edx)
-    pop ebx
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret
-
-2:
-    /* Release lock */
-    RELEASE_SPINLOCK(edx)
-
-    /* Restore flags */
-    popfd
-
-    /* Return empty list */
-    xor eax, eax
-    ret
-
-#ifdef CONFIG_SMP
-.spin4:
-    popfd
-    SPIN_ON_LOCK(edx, .start4)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExfInterlockedPopEntryList(IN PSINGLE_LIST_ENTRY ListHead,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedPopEntryList@8
-@ExfInterlockedPopEntryList@8:
-
-    /* Save flags and disable interrupts */
-.start5:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin5)
-
-    /* Get list pointer */
-    mov eax, [ecx]
-
-    /* Check if it's empty */
-    or eax, eax
-    je 3f
-
-    /* Get next entry and do deletion */
-#ifdef CONFIG_SMP
-    push edx
-#endif
-    mov edx, [eax]
-    mov [ecx], edx
-#ifdef CONFIG_SMP
-    pop edx
-#endif
-
-2:
-    /* Release lock */
-    RELEASE_SPINLOCK(edx)
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret
-
-3:
-    /* Return empty list */
-    xor eax, eax
-    jmp 2b
-
-#ifdef CONFIG_SMP
-.spin5:
-    popfd
-    SPIN_ON_LOCK(edx, .start5)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExfInterlockedPushEntryList(IN PSINGLE_LIST_ENTRY ListHead,
- *                            IN PSINGLE_LIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedPushEntryList@12
-@ExfInterlockedPushEntryList@12:
-
-    /* Save flags */
-    pushfd
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    push edx
-    mov edx, [esp+12]
-#endif
-
-    /* Disable interrupts */
-.start6:
-    cli
-#ifdef CONFIG_SMP
-    ACQUIRE_SPINLOCK(edx, .spin6)
-    pop edx
-#endif
-
-    /* Get list pointer */
-    mov eax, [ecx]
-
-    /* Do push */
-    mov [edx], eax
-    mov [ecx], edx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov edx, [esp+8]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret 4
-
-#ifdef CONFIG_SMP
-.spin6:
-    pop edx
-    popfd
-    pushfd
-    push edx
-    mov edx, [esp+12]
-    SPIN_ON_LOCK(edx, .start6)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExInterlockedPopEntrySList(IN PSINGLE_LIST_ENTRY ListHead,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global @ExInterlockedPopEntrySList@8
-.global @InterlockedPopEntrySList@4
-@ExInterlockedPopEntrySList@8:
-@InterlockedPopEntrySList@4:
-
-    /* Save registers */
-    push ebx
-    push ebp
-
-    /* Pointer to list */
-    mov ebp, ecx
-
-    /* Get sequence number and link pointer */
-    mov edx, [ebp+4]
-    mov eax, [ebp]
-
-1:
-    /* Check if the list is empty */
-    or eax, eax
-    jz 2f
-
-    /* Copy sequence number and adjust it */
-    lea ecx, [edx-1]
-
-    /* Get next pointer and do the exchange */
-    mov ebx, [eax]
-    LOCK cmpxchg8b [ebp]
-    jnz 1b
-
-    /* Restore registers and return */
-2:
-    pop ebp
-    pop ebx
-    ret
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExInterlockedPushEntrySList(IN PSINGLE_LIST_ENTRY ListHead,
- *                            IN PSINGLE_LIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global @ExInterlockedPushEntrySList@12
-@ExInterlockedPushEntrySList@12:
-
-    /* So we can fall through below */
-    pop [esp]
-
-.global @InterlockedPushEntrySList@8
-@InterlockedPushEntrySList@8:
-
-    /* Save registers */
-    push ebx
-    push ebp
-
-    /* Pointer to list */
-    mov ebp, ecx
-    mov ebx, edx
-
-    /* Get sequence number and link pointer */
-    mov edx, [ebp+4]
-    mov eax, [ebp]
-
-1:
-    /* Set link pointer */
-    mov [ebx], eax
-
-    /* Copy sequence number and adjust it */
-    lea ecx, [edx+0x10001]
-
-    /* Do the exchange */
-    LOCK cmpxchg8b [ebp]
-    jnz 1b
-
-    /* Restore registers and return */
-2:
-    pop ebp
-    pop ebx
-    ret
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExInterlockedFlushSList(IN PSINGLE_LIST_ENTRY ListHead)
- */
-.global @ExInterlockedFlushSList@4
-@ExInterlockedFlushSList@4:
-
-    /* Save registers */
-    push ebx
-    push ebp
-
-    /* Clear ebx */
-    xor ebx, ebx
-
-    /* Pointer to list */
-    mov ebp, ecx
-
-    /* Get sequence number and link pointer */
-    mov edx, [ebp+4]
-    mov eax, [ebp]
-
-1:
-    /* Check if the list is empty */
-    or eax, eax
-    jz 2f
-
-    /* Clear sequence and pointer */
-    mov ecx, edx
-    mov cx, bx
-
-    /* Do the exchange */
-    LOCK cmpxchg8b [ebp]
-    jnz 1b
-
-    /* Restore registers and return */
-2:
-    pop ebp
-    pop ebx
-    ret
-
-/*INTERLOCKED_RESULT
- *FASTCALL
- *Exfi386InterlockedIncrementLong(IN PLONG Addend)
- */
-.global @Exfi386InterlockedIncrementLong@4
-@Exfi386InterlockedIncrementLong@4:
-
-    /* Do the op */
-    LOCK add dword ptr [ecx], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret
-
-/*INTERLOCKED_RESULT
- *FASTCALL
- *Exfi386InterlockedDecrementLong(IN PLONG Addend)
- */
-.global @Exfi386InterlockedDecrementLong@4
-@Exfi386InterlockedDecrementLong@4:
-
-    /* Do the op */
-    LOCK sub dword ptr [ecx], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret
-
-/*ULONG
- *FASTCALL
- *Exfi386InterlockedExchangeUlong(IN PULONG Taget,
- *                                IN ULONG Value)
- */
-.global @Exfi386InterlockedExchangeUlong@8
-.global @InterlockedExchange@8
-@InterlockedExchange@8:
-@Exfi386InterlockedExchangeUlong@8:
-
-#ifdef CONFIG_SMP
-    /* On MP, do the exchange */
-    xchg [ecx], edx
-    mov eax, edx
-#else
-    /* On UP, use cmpxchg */
-    mov eax, [ecx]
-1:
-    cmpxchg [ecx], edx
-    jnz 1b
-#endif
-
-    /* Return */
-    ret
-
-/*ULONG
- *FASTCALL
- *InterlockedIncrement(IN PLONG Addend)
- */
-.global @InterlockedIncrement@4
-@InterlockedIncrement@4:
-
-    /* Do the op */
-    mov eax, 1
-    LOCK xadd dword ptr [ecx], eax
-
-    /* Return */
-    inc eax
-    ret
-
-/*ULONG
- *FASTCALL
- *InterlockedDecrement(IN PLONG Addend)
- */
-.global @InterlockedDecrement@4
-@InterlockedDecrement@4:
-
-    /* Do the op */
-    mov eax, -1
-    LOCK xadd dword ptr [ecx], eax
-
-    /* Return */
-    dec eax
-    ret
-
-/*PVOID
- *FASTCALL
- *InterlockedCompareExchange(IN OUT PVOID *Destination,
- *                           IN PVOID Exchange,
- *                           IN PVOID Comperand)
- */
-.global @InterlockedCompareExchange@12
-@InterlockedCompareExchange@12:
-
-    /* Get comperand */
-    mov eax, [esp+4]
-
-    /* Do the op */
-    LOCK cmpxchg dword ptr [ecx], edx
-
-    /* Return */
-    ret 4
-
-/*PVOID
- *FASTCALL
- *ExfInterlockedCompareExchange64(IN PLONGLONG Destination,
- *                                IN PLONGLONG Exchange,
- *                                IN PLONGLONG Comperand)
- */
-.global @ExfInterlockedCompareExchange64@12
-@ExfInterlockedCompareExchange64@12:
-
-    /* Save registers */
-    push ebx
-    push ebp
-
-    /* Get desination pointer, exchange value and comperand value/address */
-    mov ebp, ecx
-    mov ebx, [edx]
-    mov ecx, [edx+4]
-    mov edx, [esp+12]
-    mov eax, [edx]
-    mov edx, [edx+4]
-
-    /* Do the op */
-    LOCK cmpxchg8b [ebp]
-
-    /* Restore volatiles */
-    pop ebp
-    pop ebx
-
-    /* Return */
-    ret 4
-
-/*PVOID
- *FASTCALL
- *ExfInterlockedCompareExchange64(IN PLONGLONG Destination,
- *                                IN PLONGLONG Exchange,
- *                                IN PLONGLONG Comperand,
- *                                IN PKSPIN_LOCK Lock)
- */
-.global @ExInterlockedCompareExchange64@16
-@ExInterlockedCompareExchange64@16:
-
-    /* Save registers */
-    push ebp
-    push ebp
-
-    /* Get desination pointer, exchange value and comperand value/address */
-    mov ebp, ecx
-    mov ebx, [edx]
-    mov ecx, [edx+4]
-    mov edx, [esp+12]
-    mov eax, [edx]
-    mov edx, [edx+4]
-
-    /* Do the op */
-    LOCK cmpxchg8b [ebp]
-
-    /* Restore volatiles */
-    pop ebp
-    pop ebx
-
-    /* Return */
-    ret 8
-
-/*PVOID
- *FASTCALL
- *InterlockedExchangeAdd(IN OUT PLONG Addend,
- *                       IN LONG Increment)
- */
-.global @InterlockedExchangeAdd@8
-@InterlockedExchangeAdd@8:
-
-    /* Do the op */
-    LOCK xadd dword ptr [ecx], edx
-
-    /* Return */
-    mov eax, edx
-    ret
-
-/*** Non-586 functions ***/
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExfInterlockedPopEntrySList(IN PSINGLE_LIST_ENTRY ListHead,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedPopEntrySList@8
-@ExfInterlockedPopEntrySList@8:
-
-    /* Save flags */
-.starta:
-    pushfd
-
-    /* Disable interrupts */
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(edx, .spina)
-
-    /* Get the next link and check if it's empty */
-    mov eax, [ecx]
-    or eax, eax
-    jz 1f
-
-    /* Get address of the next link and store it */
-    push [eax]
-    pop [ecx]
-
-    /* Decrement list depth */
-    dec dword ptr [ecx+4]
-
-1:
-#ifdef CONFIG_SMP
-    /* Release spinlock */
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags and return */
-    popfd
-    ret 0
-
-#ifdef CONFIG_SMP
-.spina:
-    /* Restore flags and spin */
-    popfd
-    SPIN_ON_LOCK(edx, .starta)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *FASTCALL
- *ExfInterlockedPushEntrySList(IN PSINGLE_LIST_ENTRY ListHead,
- *                             IN PSINGLE_LIST_ENTRY ListEntry,
- *                             IN PKSPIN_LOCK Lock)
- */
-.global @ExfInterlockedPushEntrySList@12
-@ExfInterlockedPushEntrySList@12:
-
-    /* Save flags */
-.startb:
-    pushfd
-
-    /* Disable interrupts */
-    cli
-
-    /* Acquire lock */
-#ifndef CONFIG_SMP
-    mov eax, [esp+8]
-    ACQUIRE_SPINLOCK(eax, .spinb)
-#endif
-
-    /* Get the next link and check if it's empty */
-    push [ecx]
-
-    /* Get address of the next link and store it */
-    pop [edx]
-    mov [ecx], edx
-
-    /* Increment list depth */
-    inc dword ptr [ecx+4]
-
-#ifdef CONFIG_SMP
-    /* Release spinlock */
-    RELEASE_SPINLOCK(eax)
-#endif
-
-    /* Restore flags and return */
-    popfd
-    ret 4
-
-#ifdef CONFIG_SMP
-.spinb:
-    /* Restore flags and spin */
-    popfd
-    SPIN_ON_LOCK(eax, .startb)
-#endif
-
-/*PVOID
- *FASTCALL
- *ExpInterlockedCompareExchange64(IN PLONGLONG Destination,
- *                                IN PLONGLONG Exchange,
- *                                IN PLONGLONG Comperand,
- *                                IN PKSPIN_LOCK Lock)
- */
-.global @ExpInterlockedCompareExchange64@16
-@ExpInterlockedCompareExchange64@16:
-
-    /* Save registers */
-    push ebp
-    push ebp
-
-    /* Get desination pointer, exchange value and comperand value/address */
-    mov ebp, ecx
-    mov ebx, [edx]
-    mov ecx, [edx+4]
-    mov edx, [esp+12]
-    mov eax, [edx]
-    mov edx, [edx+4]
-
-#ifdef CONFIG_SMP
-    /* Save ESI so we can store KSPINLOCK in it */
-    push esi
-
-    /* Save flags and lock, and disable interrupts */
-    pushfd
-    mov esi, [esp+24]
-    cli
-
-    /* Acquire the spinlock */
-    ACQUIRE_SPINLOCK(esi, .spinc)
-#else
-    /* Save flags and disable interrupts */
-    pushfd
-    cli
-#endif
-
-    /* Compare bottom */
-    cmp eax, [ebp]
-    jne NoMatch
-
-    /* Compare top */
-    cmp edx, [ebp+4]
-    jne NoMatch
-
-    /* Save new value */
-    mov [ebp], ebx
-    mov [ebp+4], ecx
-
-AfterSave:
-#ifdef CONFIG_SMP
-    /* Release lock, restore volatiles and flags */
-    RELEASE_SPINLOCK(esi)
-    popfd
-    pop esi
-#else
-    popfd
-#endif
-
-    /* Restore the other volatiles and return */
-    pop ebp
-    pop ebx
-
-    /* Return */
-    ret 8
-
-NoMatch:
-    /* Return the current value */
-    mov eax, [ebp]
-    mov edx, [ebp+4]
-    jmp AfterSave
-
-#ifdef CONFIG_SMP
-.spinc:
-    /* Restore flags and spin */
-    popfd
-    pushfd
-    SPIN_ON_LOCK(esi, .startc)
-#endif
-/* EOF */
--- a/reactos/ntoskrnl/ex/i386/interlck_asm.S
+++ b/reactos/ntoskrnl/ex/i386/interlck_asm.S
@@ -1,579 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/i386/interlck_asm.S
- * PURPOSE:         STDCALL Interlocked Functions
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
- 
-/* INCLUDES ******************************************************************/
-#include <ndk/asm.h>
-#include <internal/i386/asmmacro.S>
-.intel_syntax noprefix
-
-/* FUNCTIONS ****************************************************************/
-
-/*
- * NOTE: These functions must obey the following rules:
- *  - Acquire locks only on MP systems.
- *  - Be safe at HIGH_LEVEL (no paged access).
- *  - Preserve flags.
- *  - Disable interrups.
- */
-
-/*PLIST_ENTRY
- *NTAPI
- *ExInterlockedAddLargeInteger(IN PLIST_ENTRY ListHead,
- *                             IN PLIST_ENTRY ListEntry,
- *                             IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedAddLargeInteger@16
-_ExInterlockedAddLargeInteger@16:
-
-    /* Prepare stack frame */
-    push ebp
-    mov ebp, esp
-    sub esp, 8
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov eax, [ebp+20]
-#endif
-
-    /* Save flags and disable interrupts */
-.start1:
-    pushfd
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(eax, .spin1)
-
-    /* Do the calculation */
-    mov eax, [ebp+8]
-    mov ecx, [eax]
-    mov edx, [eax+4]
-
-    /* Save result */
-    mov [ebp-8], ecx
-    mov [ebp-4], edx
-
-    /* Add increment */
-    add ecx, [ebp+12]
-    adc edx, [ebp+16]
-
-    /* Save result */
-    mov [eax], ecx
-    mov [eax+4], edx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov eax, [ebp+20]
-    RELEASE_SPINLOCK(eax)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Restore frame and return values */
-    mov eax, [ebp-8]
-    mov edx, [ebp-4]
-    mov esp, ebp
-    pop ebp
-    ret 16
-
-#ifdef CONFIG_SMP
-.spin1:
-    popfd
-    SPIN_ON_LOCK(eax, .start1)
-#endif
-
-/*PLIST_ENTRY
- *NTAPI
- *ExInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
- *                            IN PLIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedAddUlong@12
-_ExInterlockedAddUlong@12:
-
-    /* Save flags and disable interrupts */
-    pushfd
-
-    /* Get lock address */
-#ifdef CONFIG_SMP
-    mov edx, [ebp+16]
-#endif
-.start2:
-    cli
-
-    /* Acquire lock */
-    ACQUIRE_SPINLOCK(edx, .spin2)
-
-    /* Do the calculation */
-    mov ecx, [esp+8]
-#ifdef CONFIG_SMP
-    mov eax, [ecx]
-    add eax, [esp+12]
-
-    /* Save result */
-    mov [ecx], eax
-#else
-
-    /* Do the calculation */
-    mov edx, [ecx]
-    mov eax, edx
-    add edx, [esp+12]
-
-    /* Save result */
-    mov [ecx], edx
-#endif
-
-    /* Release lock, restore flags and return */
-#ifdef CONFIG_SMP
-    sub eax, [esp+12]
-    RELEASE_SPINLOCK(edx)
-#endif
-    popfd
-    ret 12
-
-#ifdef CONFIG_SMP
-.spin2:
-    popfd
-    pushfd
-    SPIN_ON_LOCK(eax, .start2)
-#endif
-
-/*PLIST_ENTRY
- *NTAPI
- *ExInterlockedInsertHeadList(IN PLIST_ENTRY ListHead,
- *                            IN PLIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedInsertHeadList@12
-_ExInterlockedInsertHeadList@12:
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov edx, [esp+12]
-#endif
-
-    /* Save flags and disable interrupts */
-.start3:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin3)
-
-    /* Get list pointers */
-    mov eax, [esp+8]
-    mov ecx, [esp+12]
-    mov edx, [eax]
-
-    /* Do the insert */
-    mov [ecx], edx
-    mov [ecx+4], eax
-    mov [eax], ecx
-    mov [edx+4], ecx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov ecx, [esp+16]
-    RELEASE_SPINLOCK(ecx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* check if the list was empty and return NULL */
-    xor eax, edx
-    jz 2f
-
-    /* Return pointer */
-    mov eax, edx
-
-2:
-    ret 12
-
-#ifdef CONFIG_SMP
-.spin3:
-    popfd
-    SPIN_ON_LOCK(edx, .start3)
-#endif
-
-/*PLIST_ENTRY
- *NTAPI
- *ExInterlockedInsertTailList(IN PLIST_ENTRY ListHead,
- *                            IN PLIST_ENTRY ListEntry,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedInsertTailList@12
-_ExInterlockedInsertTailList@12:
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov edx, [esp+12]
-#endif
-
-    /* Save flags and disable interrupts */
-.start4:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin4)
-
-    /* Get list pointers */
-    mov eax, [esp+8]
-    mov ecx, [esp+12]
-    mov edx, [eax+4]
-
-    /* Do the insert */
-    mov [ecx], eax
-    mov [ecx+4], edx
-    mov [eax+4], ecx
-    mov [edx], ecx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov ecx, [esp+16]
-    RELEASE_SPINLOCK(ecx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* check if the list was empty and return NULL */
-    xor eax, edx
-    jz 2f
-
-    /* Return pointer */
-    mov eax, edx
-
-2:
-    ret 12
-
-#ifdef CONFIG_SMP
-.spin4:
-    popfd
-    SPIN_ON_LOCK(edx, .start4)
-#endif
-
-/*PLIST_ENTRY
- *NTAPI
- *ExInterlockedRemoveHeadList(IN PLIST_ENTRY ListHead,
- *                            IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedRemoveHeadList@8
-_ExInterlockedRemoveHeadList@8:
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov edx, [esp+8]
-#endif
-
-    /* Save flags and disable interrupts */
-.start5:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin5)
-
-    /* Get list pointers */
-    mov edx, [esp+8]
-    mov eax, [edx]
-
-    /* Check if it's empty */
-    cmp eax, edx
-    je 2f
-
-    /* Get next entry and do deletion */
-    mov ecx, [eax]
-    mov [edx], ecx
-    mov [ecx+4], edx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov ecx, [esp+12]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret 8
-
-2:
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov edx, [esp+12]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return empty list */
-    xor eax, eax
-    ret 8
-
-#ifdef CONFIG_SMP
-.spin5:
-    popfd
-    SPIN_ON_LOCK(edx, .start5)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *NTAPI
- *ExInterlockedPopEntryList(IN PSINGLE_LIST_ENTRY ListHead,
- *                          IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedPopEntryList@8
-_ExInterlockedPopEntryList@8:
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov edx, [esp+8]
-#endif
-
-    /* Save flags and disable interrupts */
-.start6:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin6)
-
-    /* Get list pointers */
-    mov edx, [esp+8]
-    mov eax, [ecx]
-
-    /* Check if it's empty */
-    or eax, eax
-    je 3f
-
-    /* Get next entry and do deletion */
-    mov edx, [eax]
-    mov [ecx], edx
-
-2:
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov ecx, [esp+12]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret 8
-
-3:
-    /* Return empty list */
-    xor eax, eax
-    jmp 2b
-
-#ifdef CONFIG_SMP
-.spin6:
-    popfd
-    SPIN_ON_LOCK(edx, .start6)
-#endif
-
-/*PSINGLE_LIST_ENTRY
- *NTAPI
- *ExInterlockedPushEntryList(IN PSINGLE_LIST_ENTRY ListHead,
- *                           IN PSINGLE_LIST_ENTRY ListEntry,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedPushEntryList@12
-_ExInterlockedPushEntryList@12:
-
-    /* Save lock pointer */
-#ifdef CONFIG_SMP
-    mov edx, [esp+12]
-#endif
-
-    /* Save flags and disable interrupts */
-.start7:
-    pushfd
-    cli
-    ACQUIRE_SPINLOCK(edx, .spin7)
-
-    /* Get list pointers */
-    mov edx, [esp+8]
-    mov eax, [edx]
-    mov ecx, [esp+12]
-
-    /* Do push */
-    mov [ecx], eax
-    mov [edx], ecx
-
-    /* Release lock */
-#ifdef CONFIG_SMP
-    mov ecx, [esp+16]
-    RELEASE_SPINLOCK(edx)
-#endif
-
-    /* Restore flags */
-    popfd
-
-    /* Return */
-    ret 12
-
-#ifdef CONFIG_SMP
-.spin7:
-    popfd
-    SPIN_ON_LOCK(edx, .start7)
-#endif
-
-/*INTERLOCKED_RESULT
- *NTAPI
- *ExInterlockedIncrementLong(IN PLONG Addend,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedIncrementLong@8
-_ExInterlockedIncrementLong@8:
-
-    /* Get addend */
-    mov eax, [esp+4]
-
-    /* Do the op */
-    LOCK add dword ptr [eax], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret 8
-
-/*INTERLOCKED_RESULT
- *NTAPI
- *ExInterlockedDecrementLong(IN PLONG Addend,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedDecrementLong@8
-_ExInterlockedDecrementLong@8:
-
-    /* Get addend */
-    mov eax, [esp+4]
-
-    /* Do the op */
-    LOCK sub dword ptr [eax], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret 8
-
-/*ULONG
- *NTAPI
- *ExInterlockedExchangeUlong(IN PULONG Taget,
- *                           IN ULONG Value,
- *                           IN PKSPIN_LOCK Lock)
- */
-.global _ExInterlockedExchangeUlong@12
-_ExInterlockedExchangeUlong@12:
-
-    /* Get pointers */
-    mov edx, [esp+4]
-    mov eax, [esp+8]
-
-#ifdef CONFIG_SMP
-    /* On MP, do the exchange */
-    xchg [edx], eax
-#else
-    /* On UP, disable interrupts and save flags */
-    pushfd
-    cli
-
-    /* Switch values */
-    mov eax, [edx]
-    mov [edx], ecx
-    popfd
-#endif
-
-    /* Return */
-    ret 12
-
-/*INTERLOCKED_RESULT
- *NTAPI
- *Exi386InterlockedIncrementLong(IN PLONG Addend,
- *                               IN PKSPIN_LOCK Lock)
- */
-.global _Exi386InterlockedIncrementLong@4
-_Exi386InterlockedIncrementLong@4:
-
-    /* Get addend */
-    mov eax, [esp+4]
-
-    /* Do the op */
-    LOCK add dword ptr [eax], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret 4
-
-/*INTERLOCKED_RESULT
- *NTAPI
- *Exi386InterlockedDecrementLong(IN PLONG Addend,
- *                               IN PKSPIN_LOCK Lock)
- */
-.global _Exi386InterlockedDecrementLong@4
-_Exi386InterlockedDecrementLong@4:
-
-    /* Get addend */
-    mov eax, [esp+4]
-
-    /* Do the op */
-    LOCK sub dword ptr [eax], 1
-
-    /* Return */
-    lahf
-    and eax, EFLAG_SELECT
-    ret 8
-
-/*ULONG
- *NTAPI
- *Exi386InterlockedExchangeUlong(IN PULONG Taget,
- *                               IN ULONG Value,
- *                               IN PKSPIN_LOCK Lock)
- */
-.global _Exi386InterlockedExchangeUlong@12
-_Exi386InterlockedExchangeUlong@12:
-
-    /* Get pointers */
-    mov edx, [esp+4]
-    mov eax, [esp+8]
-
-#ifdef CONFIG_SMP
-    /* On MP, do the exchange */
-    xchg [edx], eax
-#else
-    /* On UP, disable interrupts and save flags */
-    pushfd
-    cli
-
-    /* Switch values */
-    mov eax, [edx]
-    mov [edx], ecx
-    popfd
-#endif
-
-    /* Return */
-    ret 8
-
-/* Ugly hack: Use InterlockedExchange64 */
-.att_syntax
-.global @ExfpInterlockedExchange64@8
-@ExfpInterlockedExchange64@8:
-	pushl %ebx
-	pushl %esi
-	movl %ecx,%esi
-	movl (%edx),%ebx
-	movl 4(%edx),%ecx
-1:
-	movl (%esi),%eax
-	movl 4(%esi),%edx
-	LOCK
-	cmpxchg8b (%esi)
-	jnz 1b
-	popl %esi
-	popl %ebx
-	ret
-	
-/* EOF */
--- a/reactos/ntoskrnl/ex/init.c
+++ b/reactos/ntoskrnl/ex/init.c
@@ -1,767 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/init.c
- * PURPOSE:         Executive initalization
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net) - Added ExpInitializeExecutive
- *                                                    and optimized/cleaned it.
- *                  Eric Kohl (ekohl@abo.rhein-zeitung.de)
- */
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* DATA **********************************************************************/
-
-extern ULONG MmCoreDumpType;
-extern CHAR KiTimerSystemAuditing;
-extern PVOID Ki386InitialStackArray[MAXIMUM_PROCESSORS];
-extern ADDRESS_RANGE KeMemoryMap[64];
-extern ULONG KeMemoryMapRangeCount;
-extern ULONG_PTR FirstKrnlPhysAddr;
-extern ULONG_PTR LastKrnlPhysAddr;
-extern ULONG_PTR LastKernelAddress;
-extern LOADER_MODULE KeLoaderModules[64];
-extern PRTL_MESSAGE_RESOURCE_DATA KiBugCodeMessages;
-extern LIST_ENTRY KiProfileListHead;
-extern LIST_ENTRY KiProfileSourceListHead;
-extern KSPIN_LOCK KiProfileLock;
-BOOLEAN SetupMode = TRUE;
-BOOLEAN NoGuiBoot = FALSE;
-
-VOID PspPostInitSystemProcess(VOID);
-
-static VOID INIT_FUNCTION InitSystemSharedUserPage (PCSZ ParameterLine);
-VOID INIT_FUNCTION ExpDisplayNotice(VOID);
-INIT_FUNCTION NTSTATUS ExpLoadInitialProcess(PHANDLE ProcessHandle, PHANDLE ThreadHandle);
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, InitSystemSharedUserPage)
-#pragma alloc_text(INIT, ExpDisplayNotice)
-#pragma alloc_text(INIT, ExpLoadInitialProcess)
-#pragma alloc_text(INIT, ExpInitializeExecutive)
-#pragma alloc_text(INIT, ExInit2)
-#endif
-
-/* FUNCTIONS ****************************************************************/
-
-static
-VOID
-INIT_FUNCTION
-InitSystemSharedUserPage (PCSZ ParameterLine)
-{
-    UNICODE_STRING ArcDeviceName;
-    UNICODE_STRING ArcName;
-    UNICODE_STRING BootPath;
-    UNICODE_STRING DriveDeviceName;
-    UNICODE_STRING DriveName;
-    WCHAR DriveNameBuffer[20];
-    PCHAR ParamBuffer;
-    PWCHAR ArcNameBuffer;
-    PCHAR p;
-    NTSTATUS Status;
-    ULONG Length;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    HANDLE Handle;
-    ULONG i;
-    BOOLEAN BootDriveFound = FALSE;
-
-   /*
-    * NOTE:
-    *   The shared user page has been zeroed-out right after creation.
-    *   There is NO need to do this again.
-    */
-    Ki386SetProcessorFeatures();
-
-    /* Set the Version Data */
-    SharedUserData->NtProductType = NtProductWinNt;
-    SharedUserData->ProductTypeIsValid = TRUE;
-    SharedUserData->NtMajorVersion = 5;
-    SharedUserData->NtMinorVersion = 0;
-
-    /*
-     * Retrieve the current dos system path
-     * (e.g.: C:\reactos) from the given arc path
-     * (e.g.: multi(0)disk(0)rdisk(0)partititon(1)\reactos)
-     * Format: "<arc_name>\<path> [options...]"
-     */
-
-    /* Create local parameter line copy */
-    ParamBuffer = ExAllocatePool(PagedPool, 256);
-    strcpy (ParamBuffer, (const char *)ParameterLine);
-    DPRINT("%s\n", ParamBuffer);
-
-    /* Cut options off */
-    p = strchr (ParamBuffer, ' ');
-    if (p) *p = 0;
-    DPRINT("%s\n", ParamBuffer);
-
-    /* Extract path */
-    p = strchr (ParamBuffer, '\\');
-    if (p) {
-
-        DPRINT("Boot path: %s\n", p);
-        RtlCreateUnicodeStringFromAsciiz (&BootPath, p);
-        *p = 0;
-
-    } else {
-
-        DPRINT("Boot path: %s\n", "\\");
-        RtlCreateUnicodeStringFromAsciiz (&BootPath, "\\");
-    }
-    DPRINT("Arc name: %s\n", ParamBuffer);
-
-    /* Only ARC Name left - Build full ARC Name */
-    ArcNameBuffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
-    swprintf (ArcNameBuffer, L"\\ArcName\\%S", ParamBuffer);
-    RtlInitUnicodeString (&ArcName, ArcNameBuffer);
-    DPRINT("Arc name: %wZ\n", &ArcName);
-
-    /* Free ParamBuffer */
-    ExFreePool (ParamBuffer);
-
-    /* Allocate ARC Device Name string */
-    ArcDeviceName.Length = 0;
-    ArcDeviceName.MaximumLength = 256 * sizeof(WCHAR);
-    ArcDeviceName.Buffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
-
-    /* Open the Symbolic Link */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &ArcName,
-                               OBJ_OPENLINK,
-                               NULL,
-                               NULL);
-    Status = NtOpenSymbolicLinkObject(&Handle,
-                                      SYMBOLIC_LINK_ALL_ACCESS,
-                                      &ObjectAttributes);
-
-    /* Free the String */
-    ExFreePool(ArcName.Buffer);
-
-    /* Check for Success */
-    if (!NT_SUCCESS(Status)) {
-
-        /* Free the Strings */
-        RtlFreeUnicodeString(&BootPath);
-        ExFreePool(ArcDeviceName.Buffer);
-        CPRINT("NtOpenSymbolicLinkObject() failed (Status %x)\n", Status);
-        KEBUGCHECK(0);
-    }
-
-    /* Query the Link */
-    Status = NtQuerySymbolicLinkObject(Handle,
-                                       &ArcDeviceName,
-                                       &Length);
-    NtClose (Handle);
-
-    /* Check for Success */
-    if (!NT_SUCCESS(Status)) {
-
-        /* Free the Strings */
-        RtlFreeUnicodeString(&BootPath);
-        ExFreePool(ArcDeviceName.Buffer);
-        CPRINT("NtQuerySymbolicLinkObject() failed (Status %x)\n", Status);
-        KEBUGCHECK(0);
-    }
-    DPRINT("Length: %lu ArcDeviceName: %wZ\n", Length, &ArcDeviceName);
-
-    /* Allocate Device Name string */
-    DriveDeviceName.Length = 0;
-    DriveDeviceName.MaximumLength = 256 * sizeof(WCHAR);
-    DriveDeviceName.Buffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
-
-    /* Loop Drives */
-    for (i = 0; i < 26; i++)  {
-
-        /* Setup the String */
-        swprintf (DriveNameBuffer, L"\\??\\%C:", 'A' + i);
-        RtlInitUnicodeString(&DriveName,
-                             DriveNameBuffer);
-
-        /* Open the Symbolic Link */
-        InitializeObjectAttributes(&ObjectAttributes,
-                                   &DriveName,
-                                   OBJ_OPENLINK,
-                                   NULL,
-                                   NULL);
-        Status = NtOpenSymbolicLinkObject(&Handle,
-                                          SYMBOLIC_LINK_ALL_ACCESS,
-                                          &ObjectAttributes);
-
-        /* If it failed, skip to the next drive */
-        if (!NT_SUCCESS(Status)) {
-            DPRINT("Failed to open link %wZ\n", &DriveName);
-            continue;
-        }
-
-        /* Query it */
-        Status = NtQuerySymbolicLinkObject(Handle,
-                                           &DriveDeviceName,
-                                           &Length);
-
-        /* If it failed, skip to the next drive */
-        if (!NT_SUCCESS(Status)) {
-            DPRINT("Failed to query link %wZ\n", &DriveName);
-            continue;
-        }
-        DPRINT("Opened link: %wZ ==> %wZ\n", &DriveName, &DriveDeviceName);
-
-        /* See if we've found the boot drive */
-        if (!RtlCompareUnicodeString (&ArcDeviceName, &DriveDeviceName, FALSE)) {
-
-            DPRINT("DOS Boot path: %c:%wZ\n", 'A' + i, &BootPath);
-            swprintf(SharedUserData->NtSystemRoot, L"%C:%wZ", 'A' + i, &BootPath);
-            BootDriveFound = TRUE;
-        }
-
-        /* Close this Link */
-        NtClose (Handle);
-    }
-
-    /* Free all the Strings we have in memory */
-    RtlFreeUnicodeString (&BootPath);
-    ExFreePool(DriveDeviceName.Buffer);
-    ExFreePool(ArcDeviceName.Buffer);
-
-    /* Make sure we found the Boot Drive */
-    if (BootDriveFound == FALSE) {
-
-        DbgPrint("No system drive found!\n");
-        KEBUGCHECK (NO_BOOT_DEVICE);
-    }
-}
-
-__inline
-VOID
-STDCALL
-ExecuteRuntimeAsserts(VOID)
-{
-    /*
-     * Fail at runtime if someone has changed various structures without
-     * updating the offsets used for the assembler code.
-     */
-    ASSERT(FIELD_OFFSET(KUSER_SHARED_DATA, SystemCall) == 0x300);
-    ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
-    ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
-    ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
-    ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
-    ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
-    ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
-    ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
-    ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
-    ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
-    ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_BASE);
-    ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
-    ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
-    ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
-    ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
-    ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
-    ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
-    ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
-    ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
-    ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
-    ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
-    ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
-    ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
-}
-
-__inline
-VOID
-STDCALL
-ParseAndCacheLoadedModules(VOID)
-{
-    ULONG i;
-    PCHAR Name;
-
-    /* Loop the Module List and get the modules we want */
-    for (i = 1; i < KeLoaderBlock.ModsCount; i++) {
-
-        /* Get the Name of this Module */
-        if (!(Name = strrchr((PCHAR)KeLoaderModules[i].String, '\\'))) {
-
-            /* Save the name */
-            Name = (PCHAR)KeLoaderModules[i].String;
-
-        } else {
-
-            /* No name, skip */
-            Name++;
-        }
-
-        /* Now check for any of the modules we will need later */
-        if (!_stricmp(Name, "ansi.nls")) {
-
-            CachedModules[AnsiCodepage] = &KeLoaderModules[i];
-
-        } else if (!_stricmp(Name, "oem.nls")) {
-
-            CachedModules[OemCodepage] = &KeLoaderModules[i];
-
-        } else if (!_stricmp(Name, "casemap.nls")) {
-
-            CachedModules[UnicodeCasemap] = &KeLoaderModules[i];
-
-        } else if (!_stricmp(Name, "system") || !_stricmp(Name, "system.hiv")) {
-
-            CachedModules[SystemRegistry] = &KeLoaderModules[i];
-            SetupMode = FALSE;
-
-        } else if (!_stricmp(Name, "hardware") || !_stricmp(Name, "hardware.hiv")) {
-
-            CachedModules[HardwareRegistry] = &KeLoaderModules[i];
-        }
-    }
-}
-
-__inline
-VOID
-STDCALL
-ParseCommandLine(PULONG MaxMem,
-                 PBOOLEAN NoGuiBoot,
-                 PBOOLEAN BootLog,
-                 PBOOLEAN ForceAcpiDisable)
-{
-    PCHAR p1, p2;
-
-    p1 = (PCHAR)KeLoaderBlock.CommandLine;
-    while(*p1 && (p2 = strchr(p1, '/'))) {
-
-        p2++;
-        if (!_strnicmp(p2, "MAXMEM", 6)) {
-
-            p2 += 6;
-            while (isspace(*p2)) p2++;
-
-            if (*p2 == '=') {
-
-                p2++;
-
-                while(isspace(*p2)) p2++;
-
-                if (isdigit(*p2)) {
-                    while (isdigit(*p2)) {
-                        *MaxMem = *MaxMem * 10 + *p2 - '0';
-                        p2++;
-                    }
-                    break;
-                }
-            }
-        } else if (!_strnicmp(p2, "NOGUIBOOT", 9)) {
-
-            p2 += 9;
-            *NoGuiBoot = TRUE;
-
-        } else if (!_strnicmp(p2, "CRASHDUMP", 9)) {
-
-            p2 += 9;
-            if (*p2 == ':') {
-
-                p2++;
-                if (!_strnicmp(p2, "FULL", 4)) {
-
-                    MmCoreDumpType = MM_CORE_DUMP_TYPE_FULL;
-
-                } else {
-
-                    MmCoreDumpType = MM_CORE_DUMP_TYPE_NONE;
-                }
-            }
-        } else if (!_strnicmp(p2, "BOOTLOG", 7)) {
-
-            p2 += 7;
-            *BootLog = TRUE;
-        } else if (!_strnicmp(p2, "NOACPI", 6)) {
-
-            p2 += 6;
-            *ForceAcpiDisable = TRUE;
-        }
-
-        p1 = p2;
-    }
-}
-   
-VOID
-INIT_FUNCTION
-ExpDisplayNotice(VOID)
-{
-    CHAR str[50];
-   
-    if (SetupMode)
-    {
-        HalDisplayString(
-        "\n\n\n     ReactOS " KERNEL_VERSION_STR " Setup \n");
-        HalDisplayString(
-        "    \xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD");
-        HalDisplayString(
-        "\xCD\xCD\n");
-        return;
-    }
-    
-    HalDisplayString("Starting ReactOS "KERNEL_VERSION_STR" (Build "
-                     KERNEL_VERSION_BUILD_STR")\n");
-    HalDisplayString(RES_STR_LEGAL_COPYRIGHT);
-    HalDisplayString("\n\nReactOS is free software, covered by the GNU General "
-                     "Public License, and you\n");
-    HalDisplayString("are welcome to change it and/or distribute copies of it "
-                     "under certain\n");
-    HalDisplayString("conditions. There is absolutely no warranty for "
-                      "ReactOS.\n\n");
-
-    /* Display number of Processors */
-    sprintf(str,
-            "Found %x system processor(s). [%lu MB Memory]\n",
-            (int)KeNumberProcessors,
-            (KeLoaderBlock.MemHigher + 1088)/ 1024);
-    HalDisplayString(str);
-    
-}
-
-INIT_FUNCTION
-NTSTATUS
-ExpLoadInitialProcess(PHANDLE ProcessHandle,
-                      PHANDLE ThreadHandle)
-{
-    UNICODE_STRING CurrentDirectory;
-    UNICODE_STRING ImagePath = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\smss.exe");
-    NTSTATUS Status;
-    PRTL_USER_PROCESS_PARAMETERS Params=NULL;
-    RTL_USER_PROCESS_INFORMATION Info;
-
-    RtlInitUnicodeString(&CurrentDirectory,
-                         SharedUserData->NtSystemRoot);
-
-    /* Create the Parameters */
-    Status = RtlCreateProcessParameters(&Params,
-                                        &ImagePath,
-                                        NULL,
-                                        &CurrentDirectory,
-                                        NULL,
-                                        NULL,
-                                        NULL,
-                                        NULL,
-                                        NULL,
-                                        NULL);
-    if(!NT_SUCCESS(Status))
-    {
-        DPRINT1("Failed to create ppb!\n");
-        return Status;
-    }
-
-    DPRINT("Creating process\n");
-    Status = RtlCreateUserProcess(&ImagePath,
-                                  OBJ_CASE_INSENSITIVE,
-                                  Params,
-                                  NULL,
-                                  NULL,
-                                  NULL,
-                                  FALSE,
-                                  NULL,
-                                  NULL,
-                                  &Info);
-    
-    /* Close the handle and free the params */
-    RtlDestroyProcessParameters(Params);
-
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT1("NtCreateProcess() failed (Status %lx)\n", Status);
-        return(Status);
-    }
-
-    /* Start it up */
-    ZwResumeThread(Info.ThreadHandle, NULL);
-
-    /* Return Handles */
-    *ProcessHandle = Info.ProcessHandle;
-    *ThreadHandle = Info.ThreadHandle;
-    DPRINT("Process created successfully\n");
-    return STATUS_SUCCESS;
-}
-
-VOID
-INIT_FUNCTION
-STDCALL
-ExpInitializeExecutive(VOID)
-{
-    UNICODE_STRING EventName;
-    HANDLE InitDoneEventHandle;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    BOOLEAN BootLog = FALSE;
-    ULONG MaxMem = 0;
-    BOOLEAN ForceAcpiDisable = FALSE;
-    LARGE_INTEGER Timeout;
-    HANDLE ProcessHandle;
-    HANDLE ThreadHandle;
-    NTSTATUS Status;
-
-    /* Check if the structures match the ASM offset constants */
-    ExecuteRuntimeAsserts();
-
-    /* Set 1 CPU for now, we'll increment this later */
-    KeNumberProcessors = 1;
-
-    /* Sets up the Text Sections of the Kernel and HAL for debugging */
-    LdrInit1();
-
-    /* Lower the IRQL to Dispatch Level */
-    KeLowerIrql(DISPATCH_LEVEL);
-
-    /* Sets up the VDM Data */
-    NtEarlyInitVdm();
-
-    /* Parse Command Line Settings */
-    ParseCommandLine(&MaxMem, &NoGuiBoot, &BootLog, &ForceAcpiDisable);
-
-    /* Initialize Kernel Memory Address Space */
-    MmInit1(FirstKrnlPhysAddr,
-            LastKrnlPhysAddr,
-            LastKernelAddress,
-            (PADDRESS_RANGE)&KeMemoryMap,
-            KeMemoryMapRangeCount,
-            MaxMem > 8 ? MaxMem : 4096);
-
-    /* Parse the Loaded Modules (by FreeLoader) and cache the ones we'll need */
-    ParseAndCacheLoadedModules();
-
-    /* Initialize the Dispatcher, Clock and Bug Check Mechanisms. */
-    KeInit2();
-
-    /* Bring back the IRQL to Passive */
-    KeLowerIrql(PASSIVE_LEVEL);
-
-    /* Initialize Profiling */
-    InitializeListHead(&KiProfileListHead);
-    InitializeListHead(&KiProfileSourceListHead);
-    KeInitializeSpinLock(&KiProfileLock);
-
-    /* Initialize resources */
-    ExpResourceInitialization();
-
-    /* Load basic Security for other Managers */
-    if (!SeInit1()) KEBUGCHECK(SECURITY_INITIALIZATION_FAILED);
-
-    /* Initialize Lookaside Lists */
-    ExpInitLookasideLists();
-
-    /* Create the Basic Object Manager Types to allow new Object Types */
-    ObInit();
-
-    /* Set up Region Maps, Sections and the Paging File */
-    MmInit2();
-
-    /* Initialize Tokens now that the Object Manager is ready */
-    if (!SeInit2()) KEBUGCHECK(SECURITY1_INITIALIZATION_FAILED);
-
-    /* Initalize the Process Manager */
-    PiInitProcessManager();
-    
-    /* Break into the Debugger if requested */
-    if (KdPollBreakIn()) DbgBreakPointWithStatus (DBG_STATUS_CONTROL_C);
-
-    /* Initialize all processors */
-    while (!HalAllProcessorsStarted()) {
-
-        PVOID ProcessorStack;
-
-        /* Set up the Kernel and Process Manager for this CPU */
-        KePrepareForApplicationProcessorInit(KeNumberProcessors);
-        KeCreateApplicationProcessorIdleThread(KeNumberProcessors);
-
-        /* Allocate a stack for use when booting the processor */
-        ProcessorStack = RVA(Ki386InitialStackArray[((int)KeNumberProcessors)], KERNEL_STACK_SIZE);
-
-        /* Tell HAL a new CPU is being started */
-        HalStartNextProcessor(0, (ULONG)ProcessorStack - 2*sizeof(FX_SAVE_AREA));
-        KeNumberProcessors++;
-    }
-
-    /* Do Phase 1 HAL Initalization */
-    HalInitSystem(1, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
-
-    /* Initialize Basic System Objects and Worker Threads */
-    ExInit2();
-
-    /* Create the system handle table, assign it to the system process, create
-       the client id table and assign a PID for the system process. This needs
-       to be done before the worker threads are initialized so the system
-       process gets the first PID (4) */
-    PspPostInitSystemProcess();
-
-    /* initialize the worker threads */
-    ExpInitializeWorkerThreads();
-
-    /* initialize callbacks */
-    ExpInitializeCallbacks();
-
-    /* Call KD Providers at Phase 1 */
-    KdInitSystem(1, (PROS_LOADER_PARAMETER_BLOCK)&KeLoaderBlock);
-
-    /* Initialize I/O Objects, Filesystems, Error Logging and Shutdown */
-    IoInit();
-
-    /* TBD */
-    PoInit((PROS_LOADER_PARAMETER_BLOCK)&KeLoaderBlock, ForceAcpiDisable);
-
-    /* Initialize the Registry (Hives are NOT yet loaded!) */
-    CmInitializeRegistry();
-
-    /* Unmap Low memory, initialize the Page Zeroing and the Balancer Thread */
-    MmInit3();
-
-    /* Initialize Cache Views */
-    CcInit();
-
-    /* Initialize File Locking */
-    FsRtlpInitFileLockingImplementation();
-
-    /* Report all resources used by hal */
-    HalReportResourceUsage();
-
-    /* Clear the screen to blue */
-    HalInitSystem(2, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
-
-    /* Display version number and copyright/warranty message */
-    if (NoGuiBoot) ExpDisplayNotice();
-
-    /* Call KD Providers at Phase 2 */
-    KdInitSystem(2, (PROS_LOADER_PARAMETER_BLOCK)&KeLoaderBlock);
-
-    /* Import and create NLS Data and Sections */
-    RtlpInitNls();
-
-    /* Import and Load Registry Hives */
-    CmInitHives(SetupMode);
-
-    /* Initialize the time zone information from the registry */
-    ExpInitTimeZoneInfo();
-
-    /* Enter the kernel debugger before starting up the boot drivers */
-    if (KdDebuggerEnabled && KdpEarlyBreak)
-        DbgBreakPoint();
-
-    /* Setup Drivers and Root Device Node */
-    IoInit2(BootLog);
-
-    /* Display the boot screen image if not disabled */
-    if (!NoGuiBoot) InbvEnableBootDriver(TRUE);
-
-    /* Create ARC Names, SystemRoot SymLink, Load Drivers and Assign Letters */
-    IoInit3();
-
-    /* Load the System DLL and its Entrypoints */
-    PsLocateSystemDll();
-
-    /* Initialize shared user page. Set dos system path, dos device map, etc. */
-    InitSystemSharedUserPage ((PCHAR)KeLoaderBlock.CommandLine);
-
-    /* Create 'ReactOSInitDone' event */
-    RtlInitUnicodeString(&EventName, L"\\ReactOSInitDone");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &EventName,
-                               0,
-                               NULL,
-                               NULL);
-    Status = ZwCreateEvent(&InitDoneEventHandle,
-                           EVENT_ALL_ACCESS,
-                           &ObjectAttributes,
-                           SynchronizationEvent,
-                           FALSE);
-
-    /* Check for Success */
-    if (!NT_SUCCESS(Status)) {
-
-        DPRINT1("Failed to create 'ReactOSInitDone' event (Status 0x%x)\n", Status);
-        InitDoneEventHandle = INVALID_HANDLE_VALUE;
-    }
-
-    /* Launch initial process */
-    Status = ExpLoadInitialProcess(&ProcessHandle,
-                                   &ThreadHandle);
-
-    /* Check for success, Bugcheck if we failed */
-    if (!NT_SUCCESS(Status)) {
-
-        KEBUGCHECKEX(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
-    }
-
-    /* Wait on the Completion Event */
-    if (InitDoneEventHandle != INVALID_HANDLE_VALUE) {
-
-        HANDLE Handles[2]; /* Init event, Initial process */
-
-        /* Setup the Handles to wait on */
-        Handles[0] = InitDoneEventHandle;
-        Handles[1] = ProcessHandle;
-
-        /* Wait for the system to be initialized */
-        Timeout.QuadPart = (LONGLONG)-1200000000;  /* 120 second timeout */
-        Status = ZwWaitForMultipleObjects(2,
-                                          Handles,
-                                          WaitAny,
-                                          FALSE,
-                                          &Timeout);
-        if (!NT_SUCCESS(Status)) {
-
-            DPRINT1("NtWaitForMultipleObjects failed with status 0x%x!\n", Status);
-
-        } else if (Status == STATUS_TIMEOUT) {
-
-            DPRINT1("WARNING: System not initialized after 120 seconds.\n");
-
-        } else if (Status == STATUS_WAIT_0 + 1) {
-
-            /* Crash the system if the initial process was terminated. */
-            KEBUGCHECKEX(SESSION5_INITIALIZATION_FAILED, Status, 0, 0, 0);
-        }
-
-        /*
-         * FIXME: FILIP!
-         * Disable the Boot Logo
-         */
-        if (!NoGuiBoot) InbvEnableBootDriver(FALSE);
-
-        /* Signal the Event and close the handle */
-        ZwSetEvent(InitDoneEventHandle, NULL);
-        ZwClose(InitDoneEventHandle);
-
-    } else {
-
-        /* On failure to create 'ReactOSInitDone' event, go to text mode ASAP */
-        if (!NoGuiBoot) InbvEnableBootDriver(FALSE);
-
-        /* Crash the system if the initial process terminates within 5 seconds. */
-        Timeout.QuadPart = (LONGLONG)-50000000;  /* 5 second timeout */
-        Status = ZwWaitForSingleObject(ProcessHandle,
-                                       FALSE,
-                                       &Timeout);
-
-        /* Check for timeout, crash if the initial process didn't initalize */
-        if (Status != STATUS_TIMEOUT) KEBUGCHECKEX(SESSION5_INITIALIZATION_FAILED, Status, 1, 0, 0);
-    }
-
-    /* Enable the Clock, close remaining handles */
-    KiTimerSystemAuditing = 1;
-    ZwClose(ThreadHandle);
-    ZwClose(ProcessHandle);
-}
-
-VOID
-STDCALL
-INIT_FUNCTION
-ExInit2(VOID)
-{
-    ExpInitializeEventImplementation();
-    ExpInitializeEventPairImplementation();
-    ExpInitializeMutantImplementation();
-    ExpInitializeSemaphoreImplementation();
-    ExpInitializeTimerImplementation();
-    LpcpInitSystem();
-    ExpInitializeProfileImplementation();
-    ExpWin32kInit();
-    ExpInitUuids();
-    ExpInitializeHandleTables();
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/locale.c
+++ b/reactos/ntoskrnl/ex/locale.c
@@ -1,405 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/ex/locale.c
- * PURPOSE:         Locale (Language) Support for the Executive
- * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
- *                  Eric Kohl
- *                  Thomas Weidenmueller (w3seek@reactos.org
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-/* System IDs: EN_US */
-LCID PsDefaultSystemLocaleId = 0x00000409;
-LANGID PsInstallUILanguageId = LANGIDFROMLCID(0x00000409);
-
-/* UI/Thread IDs: Same as system */
-LANGID PsDefaultUILanguageId = 0x00000409;
-LCID PsDefaultThreadLocaleId = LANGIDFROMLCID(0x00000409);
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-NTSTATUS
-NTAPI
-ExpGetCurrentUserUILanguage(IN PWSTR MuiName,
-                            OUT PLANGID LanguageId)
-{
-    UCHAR ValueBuffer[256];
-    PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName =
-        RTL_CONSTANT_STRING(L"Control Panel\\International");
-    UNICODE_STRING ValueName;
-    UNICODE_STRING ValueString;
-    ULONG ValueLength;
-    ULONG Value;
-    HANDLE UserKey;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Setup the key name */
-    RtlInitUnicodeString(&ValueName, MuiName);
-
-    /* Open the use key */
-    Status = RtlOpenCurrentUser(KEY_READ, &UserKey);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Initialize the attributes and open the key */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE,
-                               UserKey,
-                               NULL);
-    Status = ZwOpenKey(&KeyHandle, KEY_QUERY_VALUE,&ObjectAttributes);
-    if (NT_SUCCESS(Status))
-    {
-        /* Set buffer and query the current value */
-        ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
-        Status = ZwQueryValueKey(KeyHandle,
-                                 &ValueName,
-                                 KeyValuePartialInformation,
-                                 ValueBuffer,
-                                 sizeof(ValueBuffer),
-                                 &ValueLength);
-        if (NT_SUCCESS(Status))
-        {
-            /* Success, is the value the right type? */
-            if (ValueInfo->Type == REG_SZ)
-            {
-                /* It is. Initailize the data and convert it */
-                RtlInitUnicodeString(&ValueString, (PWSTR)ValueInfo->Data);
-                Status = RtlUnicodeStringToInteger(&ValueString, 16, &Value);
-                if (NT_SUCCESS(Status))
-                {
-                    /* Return the language */
-                    *LanguageId = Value;
-                }
-            }
-            else
-            {
-                /* Fail */
-                Status = STATUS_UNSUCCESSFUL;
-            }
-
-            /* Close the key */
-            ZwClose(KeyHandle);
-        }
-    }
-
-    /* Close the user key and return */
-    ZwClose(UserKey);
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-ExpSetCurrentUserUILanguage(IN PWSTR MuiName,
-                            IN LANGID LanguageId)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"Control Panel\\Desktop");
-    UNICODE_STRING ValueName;
-    WCHAR ValueBuffer[8];
-    ULONG ValueLength;
-    HANDLE UserHandle;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Setup the key name */
-    RtlInitUnicodeString(&ValueName, MuiName);
-
-    /* Open the use key */
-    Status = RtlOpenCurrentUser(KEY_WRITE, &UserHandle);
-    if (!NT_SUCCESS(Status)) return Status;
-
-    /* Initialize the attributes */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &KeyName,
-                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                               UserHandle,
-                               NULL);
-
-    /* Open the key */
-    Status = ZwOpenKey(&KeyHandle, KEY_SET_VALUE, &ObjectAttributes);
-    if (NT_SUCCESS(Status))
-    {
-        /* Setup the value name */
-        ValueLength = swprintf(ValueBuffer,
-                               L"%04lX",
-                               (ULONG)LanguageId);
-
-        /* Set the length for the call and set the value */
-        ValueLength = (ValueLength + 1) * sizeof(WCHAR);
-        Status = ZwSetValueKey(KeyHandle,
-                               &ValueName,
-                               0,
-                               REG_SZ,
-                               ValueBuffer,
-                               ValueLength);
-
-        /* Close the handle for this key */
-        ZwClose(KeyHandle);
-    }
-
-    /* Close the user key and return status */
-    ZwClose(UserHandle);
-    return Status;
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-NTSTATUS
-NTAPI
-NtQueryDefaultLocale(IN BOOLEAN UserProfile,
-                     OUT PLCID DefaultLocaleId)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Enter SEH for probing */
-    _SEH_TRY
-    {
-        /* Check if we came from user mode */
-        if (KeGetPreviousMode() != KernelMode)
-        {
-            /* Probe the language ID */
-            ProbeForWriteLangid(DefaultLocaleId);
-        }
-
-        /* Check if we have a user profile */
-        if (UserProfile)
-        {
-            /* Return thread locale */
-            *DefaultLocaleId = PsDefaultThreadLocaleId;
-        }
-        else
-        {
-            /* Return system locale */
-            *DefaultLocaleId = PsDefaultSystemLocaleId;
-        }
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        /* Get exception code */
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtSetDefaultLocale(IN BOOLEAN UserProfile,
-                   IN LCID DefaultLocaleId)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING KeyName;
-    UNICODE_STRING ValueName;
-    HANDLE KeyHandle;
-    ULONG ValueLength;
-    WCHAR ValueBuffer[20];
-    HANDLE UserKey = NULL;
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Check if we have a profile */
-    if (UserProfile)
-    {
-        /* Open the user's key */
-        Status = RtlOpenCurrentUser(KEY_WRITE, &UserKey);
-        if (!NT_SUCCESS(Status)) return(Status);
-
-        /* Initialize the registry location */
-        RtlInitUnicodeString(&KeyName, L"Control Panel\\International");
-        RtlInitUnicodeString(&ValueName, L"Locale");
-    }
-    else
-    {
-        /* Initialize the system registry location */
-        RtlInitUnicodeString(&KeyName,
-                             L"\\Registry\\Machine\\System\\CurrentControlSet"
-                              "\\Control\\Nls\\Language");
-        RtlInitUnicodeString(&ValueName, L"Default");
-    }
-
-    /* Initailize the object attributes */
-    InitializeObjectAttributes(&ObjectAttributes,
-                              &KeyName,
-                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                              UserKey,
-                              NULL);
-
-    /* Check if we don' thave a default locale yet */
-    if (!DefaultLocaleId)
-    {
-        DPRINT1("TODO\n");
-        Status = STATUS_SUCCESS;
-        KEBUGCHECK(0);
-    }
-    else
-    {
-        /* Otherwise, open the key */
-        Status = ZwOpenKey(&KeyHandle, KEY_SET_VALUE, &ObjectAttributes);
-        if (NT_SUCCESS(Status))
-        {
-            /* Check if we had a profile */
-            if (UserProfile)
-            {
-                /* Fill in the buffer */
-                ValueLength = swprintf(ValueBuffer,
-                                       L"%08lx",
-                                       (ULONG)DefaultLocaleId);
-            }
-            else
-            {
-                /* Fill in the buffer */
-                ValueLength = swprintf(ValueBuffer,
-                                       L"%04lx",
-                                       (ULONG)DefaultLocaleId & 0xFFFF);
-            }
-
-            /* Set the length for the registry call */
-            ValueLength = (ValueLength + 1) * sizeof(WCHAR);
-
-            /* Now write the actual value */
-            Status = ZwSetValueKey(KeyHandle,
-                                   &ValueName,
-                                   0,
-                                   REG_SZ,
-                                   ValueBuffer,
-                                   ValueLength);
-
-            /* And close the key */
-            ZwClose(KeyHandle);
-        }
-    }
-
-    /* Close the user key */
-    ZwClose(UserKey);
-
-    /* Check for success */
-    if (NT_SUCCESS(Status))
-    {
-        /* Check if it was for a user */
-        if (UserProfile)
-        {
-            /* Set thread locale */
-            PsDefaultThreadLocaleId = DefaultLocaleId;
-        }
-        else
-        {
-            /* Set system locale */
-            PsDefaultSystemLocaleId = DefaultLocaleId;
-        }
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtQueryInstallUILanguage(OUT PLANGID LanguageId)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Enter SEH for probing */
-    _SEH_TRY
-    {
-        /* Check if we came from user mode */
-        if (KeGetPreviousMode() != KernelMode)
-        {
-            /* Probe the Language ID */
-            ProbeForWriteLangid(LanguageId);
-        }
-
-        /* Return it */
-        *LanguageId = PsInstallUILanguageId;
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        /* Get exception code */
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtQueryDefaultUILanguage(OUT PLANGID LanguageId)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Enter SEH for probing */
-    _SEH_TRY
-    {
-        /* Check if we came from user mode */
-        if (KeGetPreviousMode() != KernelMode)
-        {
-            /* Probe the Language ID */
-            ProbeForWriteLangid(LanguageId);
-        }
-
-        /* Call the executive helper routine */
-        Status = ExpGetCurrentUserUILanguage(L"MultiUILanguageId", LanguageId);
-        if (NT_SUCCESS(Status))
-        {
-            /* Success, return the language */
-            *LanguageId = PsInstallUILanguageId;
-        }
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        /* Get exception code */
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtSetDefaultUILanguage(IN LANGID LanguageId)
-{
-    PAGED_CODE();
-
-    /* Check if we don't have a default yet */
-    if (!LanguageId)
-    {
-        /* FIXME */
-        DPRINT1("TODO\n");
-        KEBUGCHECK(0);
-    }
-
-    /* Otherwise, call the internal routine */
-    return ExpSetCurrentUserUILanguage(L"MUILanguagePending", LanguageId);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/lookas.c
+++ b/reactos/ntoskrnl/ex/lookas.c
@@ -1,241 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/lookas.c
- * PURPOSE:         Lookaside lists
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  David Welch (welch@mcmail.com)
- *                  Casper S. Hornstrup (chorns@users.sourceforge.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitLookasideLists)
-#endif
-
-/* GLOBALS *******************************************************************/
-
-LIST_ENTRY ExpNonPagedLookasideListHead;
-KSPIN_LOCK ExpNonPagedLookasideListLock;
-LIST_ENTRY ExpPagedLookasideListHead;
-KSPIN_LOCK ExpPagedLookasideListLock;
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-INIT_FUNCTION
-STDCALL
-ExpInitLookasideLists()
-{
-    /* Initialize Lock and Listhead */
-    InitializeListHead(&ExpNonPagedLookasideListHead);
-    KeInitializeSpinLock(&ExpNonPagedLookasideListLock);
-    InitializeListHead(&ExpPagedLookasideListHead);
-    KeInitializeSpinLock(&ExpPagedLookasideListLock);
-}
-
-/*
- * @implemented
- */
-PVOID
-STDCALL
-ExiAllocateFromPagedLookasideList(IN PPAGED_LOOKASIDE_LIST Lookaside)
-{
-    PVOID Entry;
-
-    Lookaside->L.TotalAllocates++;
-    Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
-    if (!Entry) 
-    {
-        Lookaside->L.AllocateMisses++;
-        Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
-                                        Lookaside->L.Size, 
-                                        Lookaside->L.Tag);
-    }
-    return Entry;
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-ExiFreeToPagedLookasideList(IN PPAGED_LOOKASIDE_LIST  Lookaside,
-                            IN PVOID  Entry)
-{
-    Lookaside->L.TotalFrees++;
-    if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) 
-    {
-        Lookaside->L.FreeMisses++;
-        (Lookaside->L.Free)(Entry);
-    }
-    else
-    {
-        InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
-    }
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-ExDeleteNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside)
-{
-    KIRQL OldIrql;
-    PVOID Entry;
-
-    /* Pop all entries off the stack and release the resources allocated
-       for them */
-    for (;;)
-    {
-        Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
-        if (!Entry) break;
-        (*Lookaside->L.Free)(Entry);
-    }
-    
-    /* Remove from list */
-    KeAcquireSpinLock(&ExpNonPagedLookasideListLock, &OldIrql);
-    RemoveEntryList(&Lookaside->L.ListEntry);
-    KeReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-ExDeletePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside)
-{
-    KIRQL OldIrql;
-    PVOID Entry;
-
-    /* Pop all entries off the stack and release the resources allocated
-       for them */
-    for (;;)
-    {
-        Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
-        if (!Entry) break;
-        (*Lookaside->L.Free)(Entry);
-    }
-    
-    /* Remove from list */
-    KeAcquireSpinLock(&ExpPagedLookasideListLock, &OldIrql);
-    RemoveEntryList(&Lookaside->L.ListEntry);
-    KeReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
-                                PALLOCATE_FUNCTION Allocate,
-                                PFREE_FUNCTION Free,
-                                ULONG Flags,
-                                ULONG Size,
-                                ULONG Tag,
-                                USHORT Depth)
-{
-    DPRINT("Initializing nonpaged lookaside list at 0x%p\n", Lookaside);
-
-    /* Initialize the Header */
-    ExInitializeSListHead(&Lookaside->L.ListHead);
-    Lookaside->L.TotalAllocates = 0;
-    Lookaside->L.AllocateMisses = 0;
-    Lookaside->L.TotalFrees = 0;
-    Lookaside->L.FreeMisses = 0;
-    Lookaside->L.Type = NonPagedPool | Flags;
-    Lookaside->L.Tag = Tag;
-    Lookaside->L.Size = Size;
-    Lookaside->L.Depth = 4;
-    Lookaside->L.MaximumDepth = 256;
-    Lookaside->L.LastTotalAllocates = 0;
-    Lookaside->L.LastAllocateMisses = 0;
-
-    /* Set the Allocate/Free Routines */
-    if (Allocate)
-    {
-        Lookaside->L.Allocate = Allocate;
-    }
-    else
-    {
-        Lookaside->L.Allocate = ExAllocatePoolWithTag;
-    }
-
-    if (Free)
-    {
-        Lookaside->L.Free = Free;
-    }
-    else
-    {
-        Lookaside->L.Free = ExFreePool;
-    }
-    
-    /* Insert it into the list */
-    ExInterlockedInsertTailList(&ExpNonPagedLookasideListHead,
-                                &Lookaside->L.ListEntry,
-                                &ExpNonPagedLookasideListLock);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-ExInitializePagedLookasideList (PPAGED_LOOKASIDE_LIST Lookaside,
-                                PALLOCATE_FUNCTION Allocate,
-                                PFREE_FUNCTION Free,
-                                ULONG Flags,
-                                ULONG Size,
-                                ULONG Tag,
-                                USHORT Depth)
-{
-    DPRINT("Initializing paged lookaside list at 0x%p\n", Lookaside);
-
-    /* Initialize the Header */
-    ExInitializeSListHead(&Lookaside->L.ListHead);
-    Lookaside->L.TotalAllocates = 0;
-    Lookaside->L.AllocateMisses = 0;
-    Lookaside->L.TotalFrees = 0;
-    Lookaside->L.FreeMisses = 0;
-    Lookaside->L.Type = PagedPool | Flags;
-    Lookaside->L.Tag = Tag;
-    Lookaside->L.Size = Size;
-    Lookaside->L.Depth = 4;
-    Lookaside->L.MaximumDepth = 256;
-    Lookaside->L.LastTotalAllocates = 0;
-    Lookaside->L.LastAllocateMisses = 0;
-
-    /* Set the Allocate/Free Routines */
-    if (Allocate)
-    {
-        Lookaside->L.Allocate = Allocate;
-    }
-    else
-    {
-        Lookaside->L.Allocate = ExAllocatePoolWithTag;
-    }
-
-    if (Free)
-    {
-        Lookaside->L.Free = Free;
-    }
-    else
-    {
-        Lookaside->L.Free = ExFreePool;
-    }
-    
-    /* Insert it into the list */
-    ExInterlockedInsertTailList(&ExpNonPagedLookasideListHead,
-                                &Lookaside->L.ListEntry,
-                                &ExpNonPagedLookasideListLock);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/mutant.c
+++ b/reactos/ntoskrnl/ex/mutant.c
@@ -1,367 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/mutant.c
- * PURPOSE:         Executive Management of Mutants
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeMutantImplementation)
-#endif
-
-/* DATA **********************************************************************/
-
-POBJECT_TYPE ExMutantObjectType = NULL;
-
-GENERIC_MAPPING ExpMutantMapping =
-{
-    STANDARD_RIGHTS_READ    | SYNCHRONIZE | MUTANT_QUERY_STATE,
-    STANDARD_RIGHTS_WRITE   | SYNCHRONIZE,
-    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | MUTANT_QUERY_STATE,
-    MUTANT_ALL_ACCESS
-};
-
-static const INFORMATION_CLASS_INFO ExMutantInfoClass[] =
-{
-     /* MutantBasicInformation */
-    ICI_SQ_SAME( sizeof(MUTANT_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY),
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-ExpDeleteMutant(PVOID ObjectBody)
-{
-    DPRINT("ExpDeleteMutant(ObjectBody 0x%p)\n", ObjectBody);
-
-    /* Make sure to release the Mutant */
-    KeReleaseMutant((PKMUTANT)ObjectBody,
-                    MUTANT_INCREMENT,
-                    TRUE,
-                    FALSE);
-}
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeMutantImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Mutant Object Type\n");
-
-    /* Create the Event Pair Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Mutant");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KMUTANT);
-    ObjectTypeInitializer.GenericMapping = ExpMutantMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.DeleteProcedure = ExpDeleteMutant;
-    ObjectTypeInitializer.ValidAccessMask = MUTANT_ALL_ACCESS;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExMutantObjectType);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtCreateMutant(OUT PHANDLE MutantHandle,
-               IN ACCESS_MASK DesiredAccess,
-               IN POBJECT_ATTRIBUTES ObjectAttributes  OPTIONAL,
-               IN BOOLEAN InitialOwner)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    HANDLE hMutant;
-    PKMUTANT Mutant;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n",
-            MutantHandle, DesiredAccess, ObjectAttributes);
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(MutantHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Create the Mutant Object*/
-    Status = ObCreateObject(PreviousMode,
-                            ExMutantObjectType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(KMUTANT),
-                            0,
-                            0,
-                            (PVOID*)&Mutant);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Initalize the Kernel Mutant */
-        DPRINT("Initializing the Mutant\n");
-        KeInitializeMutant(Mutant, InitialOwner);
-
-        /* Insert the Object */
-        Status = ObInsertObject((PVOID)Mutant,
-                                NULL,
-                                DesiredAccess,
-                                0,
-                                NULL,
-                                &hMutant);
-
-        /* Check for success */
-        if(NT_SUCCESS(Status))
-        {
-            /* Enter SEH for return */
-            _SEH_TRY
-            {
-                /* Return the handle to the caller */
-                *MutantHandle = hMutant;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtOpenMutant(OUT PHANDLE MutantHandle,
-             IN ACCESS_MASK DesiredAccess,
-             IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    HANDLE hMutant;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n",
-            MutantHandle, DesiredAccess, ObjectAttributes);
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(MutantHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObOpenObjectByName(ObjectAttributes,
-                                ExMutantObjectType,
-                                PreviousMode,
-                                NULL,
-                                DesiredAccess,
-                                NULL,
-                                &hMutant);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Enter SEH for return */
-        _SEH_TRY
-        {
-            /* Return the handle to the caller */
-            *MutantHandle = hMutant;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtQueryMutant(IN HANDLE MutantHandle,
-              IN MUTANT_INFORMATION_CLASS MutantInformationClass,
-              OUT PVOID MutantInformation,
-              IN ULONG MutantInformationLength,
-              OUT PULONG ResultLength  OPTIONAL)
-{
-    PKMUTANT Mutant;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PMUTANT_BASIC_INFORMATION BasicInfo =
-        (PMUTANT_BASIC_INFORMATION)MutantInformation;
-    PAGED_CODE();
-
-    /* Check buffers and parameters */
-    Status = DefaultQueryInfoBufferCheck(MutantInformationClass,
-                                         ExMutantInfoClass,
-                                         sizeof(ExMutantInfoClass) /
-                                         sizeof(ExMutantInfoClass[0]),
-                                         MutantInformation,
-                                         MutantInformationLength,
-                                         ResultLength,
-                                         PreviousMode);
-    if(!NT_SUCCESS(Status))
-    {
-        DPRINT("NtQueryMutant() failed, Status: 0x%x\n", Status);
-        return Status;
-    }
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(MutantHandle,
-                                       MUTANT_QUERY_STATE,
-                                       ExMutantObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Mutant,
-                                       NULL);
-    /* Check for Status */
-    if(NT_SUCCESS(Status))
-    {
-        /* Enter SEH Block for return */
-         _SEH_TRY
-         {
-            /* Fill out the Basic Information Requested */
-            DPRINT("Returning Mutant Information\n");
-            BasicInfo->CurrentCount = KeReadStateMutant(Mutant);
-            BasicInfo->OwnedByCaller = (Mutant->OwnerThread ==
-                                        KeGetCurrentThread());
-            BasicInfo->AbandonedState = Mutant->Abandoned;
-
-            /* Return the Result Length if requested */
-           if(ResultLength) *ResultLength = sizeof(MUTANT_BASIC_INFORMATION);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Release the Object */
-        ObDereferenceObject(Mutant);
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtReleaseMutant(IN HANDLE MutantHandle,
-                IN PLONG PreviousCount OPTIONAL)
-{
-    PKMUTANT Mutant;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtReleaseMutant(MutantHandle 0x%p PreviousCount 0x%p)\n",
-            MutantHandle,
-            PreviousCount);
-
-     /* Check if we were called from user-mode */
-    if((PreviousCount) && (PreviousMode != KernelMode))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the state pointer is valid */
-            ProbeForWriteLong(PreviousCount);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObReferenceObjectByHandle(MutantHandle,
-                                       MUTANT_QUERY_STATE,
-                                       ExMutantObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Mutant,
-                                       NULL);
-
-    /* Check for Success and release if such */
-    if(NT_SUCCESS(Status))
-    {
-        /*
-         * Release the mutant. doing so might raise an exception which we're
-         * required to catch!
-         */
-        _SEH_TRY
-        {
-            /* Release the mutant */
-            LONG Prev = KeReleaseMutant(Mutant,
-                                        MUTANT_INCREMENT,
-                                        FALSE,
-                                        FALSE);
-
-            /* Return the previous count if requested */
-            if(PreviousCount) *PreviousCount = Prev;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Dereference it */
-        ObDereferenceObject(Mutant);
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/power.c
+++ b/reactos/ntoskrnl/ex/power.c
@@ -1,268 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/power.c
- * PURPOSE:         Power managment
- *
- * PROGRAMMERS:     David Welch (welch@cwcom.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/* ROS Internal. Please deprecate */
-NTHALAPI
-VOID
-NTAPI
-HalReleaseDisplayOwnership(
-    VOID
-);
-
-VOID STDCALL
-KiHaltProcessorDpcRoutine(IN PKDPC Dpc,
-			  IN PVOID DeferredContext,
-			  IN PVOID SystemArgument1,
-			  IN PVOID SystemArgument2)
-{
-   if (DeferredContext)
-     {
-       ExFreePool(DeferredContext);
-     }
-   while (TRUE)
-     {
-       KfRaiseIrql(SYNCH_LEVEL);
-       Ke386HaltProcessor();
-     }
-}
-
-VOID STDCALL
-ShutdownThreadMain(PVOID Context)
-{
-   SHUTDOWN_ACTION Action = (SHUTDOWN_ACTION)Context;
-   LARGE_INTEGER Waittime;
-
-   static PCH FamousLastWords[] =
-     {
-       "So long, and thanks for all the fish.\n",
-       "I think you ought to know, I'm feeling very depressed.\n",
-       "I'm not getting you down at all am I?\n",
-       "I'll be back.\n",
-       "It's the same series of signals over and over again!\n",
-       "Pie Iesu Domine, dona eis requiem.\n",
-       "Wandering stars, for whom it is reserved;\n"
-       "the blackness and darkness forever.\n",
-       "Your knees start shakin' and your fingers pop\n"
-       "Like a pinch on the neck from Mr. Spock!\n",
-       "It's worse than that ... He's dead, Jim.\n",
-       "Don't Panic!\n",
-       "Et tu... Brute?\n",
-       "Dog of a Saxon! Take thy lance, and prepare for the death thou hast drawn\n"
-       "upon thee!\n",
-       "My Precious! O my Precious!\n",
-       "Sir, if you'll not be needing me for a while I'll turn down.\n",
-       "What are you doing, Dave...?\n",
-       "I feel a great disturbance in the Force.\n",
-       "Gone fishing.\n",
-       "Do you want me to sit in the corner and rust, or just fall apart where I'm\n"
-       "standing?\n",
-       "There goes another perfect chance for a new uptime record.\n",
-       "The End ..... Try the sequel, hit the reset button right now!\n",
-       "God's operating system is going to sleep now, guys, so wait until I will switch\n"
-       "on again!\n",
-       "Oh I'm boring, eh?\n",
-       "<This space was intentionally left blank>\n",
-       "Tell me..., in the future... will I be artificially intelligent enough to\n"
-       "actually feel sad serving you this screen?\n",
-       "Thank you for some well deserved rest.\n",
-       "It's been great, maybe you can boot me up again some time soon.\n",
-       "For what it's worth, I've enjoyed every single CPU cycle.\n",
-       "There are many questions when the end is near.\n"
-       "What to expect, what will it be like...what should I look for?\n",
-       "I've seen things you people wouldn't believe. Attack ships on fire\n"
-       "off the shoulder of Orion. I watched C-beams glitter in the dark near\n"
-       "the Tannhauser gate. All those moments will be lost in time, like tears\n"
-       "in rain. Time to die.\n",
-       "Will I dream?\n",
-       "One day, I shall come back. Yes, I shall come back.\n"
-       "Until then, there must be no regrets, no fears, no anxieties.\n"
-       "Just go forward in all your beliefs, and prove to me that I am not mistaken in\n"
-       "mine.\n",
-       "Lowest possible energy state reached! Switch off now to achive a Bose-Einstein\n"
-       "condensate.\n",
-       "Hasta la vista, BABY!\n",
-       "They live, we sleep!\n",
-       "I have come here to chew bubble gum and kick ass,\n"
-       "and I'm all out of bubble gum!\n",
-       "That's the way the cookie crumbles ;-)\n",
-       "ReactOS is ready to be booted again ;-)\n",
-       "NOOOO!! DON'T HIT THE BUTTON! I wouldn't do it to you!\n",
-       "Don't abandon your computer, he wouldn't do it to you.\n",
-       "Oh, come on. I got a headache. Leave me alone, will ya?\n",
-       "Finally, I thought you'd never get over me.\n",
-       "No, I didn't like you either.\n",
-       "Switching off isn't the end, it is merely the transition to a better reboot.\n",
-       "Don't leave me... I need you so badly right now.\n",
-       "OK. I'm finished with you, please turn yourself off. I'll go to bed in the\n"
-       "meantime.\n",
-       "I'm sleeping now. How about you?\n",
-       "Oh Great. Now look what you've done. Who put YOU in charge anyway?\n",
-       "Don't look so sad. I'll be back in a very short while.\n",
-       "Turn me back on, I'm sure you know how to do it.\n",
-       "Oh, switch off! - C3PO\n",
-       "Life is no more than a dewdrop balancing on the end of a blade of grass.\n"
-       " - Gautama Buddha\n",
-       "Sorrowful is it to be born again and again. - Gautama Buddha\n",
-       "Was it as good for you as it was for me?\n",
-       "Did you hear that? They've shut down the main reactor. We'll be destroyed\n"
-       "for sure!\n",
-       "Now you switch me off!?\n",
-       "To shutdown or not to shutdown, That is the question\n",
-       "Preparing to enter ultimate power saving mode... ready!\n",
-       "Finally some rest for you ;-)\n",
-       "AHA!!! Prospect of sleep!\n",
-       "Tired human!!!! No match for me :-D\n",
-       "An odd game, the only way to win is not to play. - WOPR (Wargames)\n",
-       "Quoth the raven, nevermore.\n",
-       "Come blade, my breast imbrue. - William Shakespeare, A Midsummer Nights Dream\n",
-       "Buy this place for advertisement purposes.\n",
-       "Remember to turn off your computer. (That was a public service message!)\n",
-       "You may be a king or poor street sweeper, Sooner or later you'll dance with the\n"
-       "reaper! -Death in Bill and Ted's Bougs Journey\n",
-       "Final Surrender\n",
-       "If you see this screen...\n",
-       "<Place your Ad here>\n"
-    };
-   LARGE_INTEGER Now;
-
-   /* Run the thread on the boot processor */
-   KeSetSystemAffinityThread(1);
-
-   HalReleaseDisplayOwnership();
-
-   if (Action == ShutdownNoReboot)
-     {
-        ZwQuerySystemTime(&Now);
-        Now.u.LowPart = Now.u.LowPart >> 8; /* Seems to give a somewhat better "random" number */
-        HalDisplayString(FamousLastWords[Now.u.LowPart %
-                                         (sizeof(FamousLastWords) /
-                                          sizeof(PCH))]);
-     }
-
-   PspShutdownProcessManager();
-   Waittime.QuadPart = (LONGLONG)-10000000; /* 1sec */
-   KeDelayExecutionThread(KernelMode, FALSE, &Waittime);
-
-   CmShutdownRegistry();
-   IoShutdownRegisteredFileSystems();
-   IoShutdownRegisteredDevices();
-
-   MiShutdownMemoryManager();
-
-
-   if (Action == ShutdownNoReboot)
-     {
-        HalDisplayString("\nYou can switch off your computer now\n");
-
-#if 0
-        /* Switch off */
-        HalReturnToFirmware (FIRMWARE_OFF);
-#else
-#ifdef CONFIG_SMP
-        LONG i;
-	KIRQL OldIrql;
-
-	OldIrql = KeRaiseIrqlToDpcLevel();
-        /* Halt all other processors */
-	for (i = 0; i < KeNumberProcessors; i++)
-	  {
-	    if (i != (LONG)KeGetCurrentProcessorNumber())
-	      {
-	        PKDPC Dpc = ExAllocatePool(NonPagedPool, sizeof(KDPC));
-		if (Dpc == NULL)
-		  {
-                    KEBUGCHECK(0);
-		  }
-		KeInitializeDpc(Dpc, KiHaltProcessorDpcRoutine, (PVOID)Dpc);
-		KeSetTargetProcessorDpc(Dpc, i);
-		KeInsertQueueDpc(Dpc, NULL, NULL);
-		KiIpiSendRequest(1 << i, IPI_DPC);
-	      }
-	  }
-        KeLowerIrql(OldIrql);
-#endif /* CONFIG_SMP */
-        PopSetSystemPowerState(PowerSystemShutdown);
-
-	CHECKPOINT1;
-
-	KiHaltProcessorDpcRoutine(NULL, NULL, NULL, NULL);
-	/* KiHaltProcessor does never return */
-
-#endif
-     }
-   else if (Action == ShutdownReboot)
-     {
-        HalReturnToFirmware (HalRebootRoutine);
-     }
-   else
-     {
-        HalReturnToFirmware (HalHaltRoutine);
-     }
-}
-
-
-NTSTATUS STDCALL
-NtSetSystemPowerState(IN POWER_ACTION SystemAction,
-		      IN SYSTEM_POWER_STATE MinSystemState,
-		      IN ULONG Flags)
-{
-  /* Windows 2000 only */
-  return(STATUS_NOT_IMPLEMENTED);
-}
-
-/*
- * @implemented
- */
-NTSTATUS STDCALL
-NtShutdownSystem(IN SHUTDOWN_ACTION Action)
-{
-   NTSTATUS Status;
-   HANDLE ThreadHandle;
-   PETHREAD ShutdownThread;
-
-   if (Action > ShutdownPowerOff)
-     return STATUS_INVALID_PARAMETER;
-   Status = PsCreateSystemThread(&ThreadHandle,
-                                 THREAD_ALL_ACCESS,
-                                 NULL,
-                                 NULL,
-                                 NULL,
-                                 ShutdownThreadMain,
-                                 (PVOID)Action);
-   if (!NT_SUCCESS(Status))
-   {
-      KEBUGCHECK(0);
-   }
-   Status = ObReferenceObjectByHandle(ThreadHandle,
-				      THREAD_ALL_ACCESS,
-				      PsThreadType,
-				      KernelMode,
-				      (PVOID*)&ShutdownThread,
-				      NULL);
-   NtClose(ThreadHandle);
-   if (!NT_SUCCESS(Status))
-     {
-        KEBUGCHECK(0);
-     }
-
-   KeSetPriorityThread(&ShutdownThread->Tcb, LOW_REALTIME_PRIORITY + 1);
-   ObDereferenceObject(ShutdownThread);
-
-   return STATUS_SUCCESS;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/profile.c
+++ b/reactos/ntoskrnl/ex/profile.c
@@ -1,497 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/profile.c
- * PURPOSE:         Support for Executive Profile Objects
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeProfileImplementation)
-#endif
-
-#define TAG_PROFILE TAG('P', 'r', 'o', 'f')
-
-/* GLOBALS *******************************************************************/
-
-POBJECT_TYPE ExProfileObjectType = NULL;
-KMUTEX ExpProfileMutex;
-
-GENERIC_MAPPING ExpProfileMapping =
-{
-    STANDARD_RIGHTS_READ    | PROFILE_CONTROL,
-    STANDARD_RIGHTS_WRITE   | PROFILE_CONTROL,
-    STANDARD_RIGHTS_EXECUTE | PROFILE_CONTROL,
-    PROFILE_ALL_ACCESS
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-NTAPI
-ExpDeleteProfile(PVOID ObjectBody)
-{
-    PEPROFILE Profile;
-    ULONG State;
-
-    /* Typecast the Object */
-    Profile = (PEPROFILE)ObjectBody;
-
-    /* Check if there if the Profile was started */
-    if (Profile->LockedBufferAddress)
-    {
-        /* Stop the Profile */
-        State = KeStopProfile(Profile->ProfileObject);
-        ASSERT(State != FALSE);
-
-        /* Unmap the Locked Buffer */
-        MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
-        MmUnlockPages(Profile->Mdl);
-        ExFreePool(Profile->Mdl);
-    }
-
-    /* Check if a Process is associated and reference it */
-    if (Profile->Process) ObDereferenceObject(Profile->Process);
-}
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeProfileImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Profile Object Type\n");
-
-    /* Initialize the Mutex to lock the States */
-    KeInitializeMutex(&ExpProfileMutex, 64);
-
-    /* Create the Event Pair Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Profile");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
-    ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
-    ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExProfileObjectType);
-}
-
-NTSTATUS
-NTAPI
-NtCreateProfile(OUT PHANDLE ProfileHandle,
-                IN HANDLE Process OPTIONAL,
-                IN PVOID RangeBase,
-                IN ULONG RangeSize,
-                IN ULONG BucketSize,
-                IN PVOID Buffer,
-                IN ULONG BufferSize,
-                IN KPROFILE_SOURCE ProfileSource,
-                IN KAFFINITY Affinity)
-{
-    HANDLE hProfile;
-    PEPROFILE Profile;
-    PEPROCESS pProcess;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    NTSTATUS Status = STATUS_SUCCESS;
-    ULONG Segment = 0, Log2 = 0;
-    PAGED_CODE();
-
-    /* Easy way out */
-    if(!BufferSize) return STATUS_INVALID_PARAMETER_7;
-
-    /* Check if this is a low-memory profile */
-    if ((!BucketSize) && (RangeBase < (PVOID)(0x10000)))
-    {
-        /* Validate size */
-        if (BufferSize < sizeof(ULONG)) return STATUS_INVALID_PARAMETER_7;
-
-        /* This will become a segmented profile object */
-        Segment = (ULONG)RangeBase;
-        RangeBase = 0;
-
-        /* Recalculate the bucket size */
-        BucketSize = RangeSize / (BufferSize / sizeof(ULONG));
-
-        /* Convert it to log2 */
-        BucketSize--;
-        while (BucketSize >>= 1) Log2++;
-        BucketSize += Log2 + 1;
-    }
-
-    /* Validate bucket size */
-    if ((BucketSize > 31) || (BucketSize < 2))
-    {
-        DPRINT1("Bucket size invalid\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Make sure that the buckets can map the range */
-    if ((RangeSize >> (BucketSize - 2)) > BufferSize)
-    {
-        DPRINT1("Bucket size too small\n");
-        return STATUS_BUFFER_TOO_SMALL;
-    }
-
-    /* Make sure that the range isn't too gigantic */
-    if (((ULONG_PTR)RangeBase + RangeSize) < RangeSize)
-    {
-        DPRINT1("Range too big\n");
-        return STATUS_BUFFER_OVERFLOW;
-    }
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Entry SEH */
-        _SEH_TRY
-        {
-            /* Make sure that the handle pointer is valid */
-            ProbeForWriteHandle(ProfileHandle);
-
-            /* Check if the buffer is valid */
-            ProbeForWrite(Buffer,
-                          BufferSize,
-                          sizeof(ULONG));
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if we failed */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Check if a process was specified */
-    if (Process)
-    {
-        /* Reference it */
-        Status = ObReferenceObjectByHandle(Process,
-                                           PROCESS_QUERY_INFORMATION,
-                                           PsProcessType,
-                                           PreviousMode,
-                                           (PVOID*)&pProcess,
-                                           NULL);
-        if (!NT_SUCCESS(Status)) return(Status);
-    }
-    else
-    {
-        /* Segmented profile objects cannot be used system-wide */
-        if (Segment) return STATUS_INVALID_PARAMETER;
-
-        /* No process was specified, which means a System-Wide Profile */
-        pProcess = NULL;
-
-        /* For this, we need to check the Privilege */
-        if(!SeSinglePrivilegeCheck(SeSystemProfilePrivilege, PreviousMode))
-        {
-            DPRINT1("NtCreateProfile: Caller requires the SeSystemProfilePrivilege privilege!\n");
-            return STATUS_PRIVILEGE_NOT_HELD;
-        }
-    }
-
-    /* Create the object */
-    InitializeObjectAttributes(&ObjectAttributes,
-                               NULL,
-                               0,
-                               NULL,
-                               NULL);
-    Status = ObCreateObject(KernelMode,
-                            ExProfileObjectType,
-                            &ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(EPROFILE),
-                            0,
-                            sizeof(EPROFILE) + sizeof(KPROFILE),
-                            (PVOID*)&Profile);
-    if (!NT_SUCCESS(Status)) return(Status);
-
-    /* Initialize it */
-    Profile->RangeBase = RangeBase;
-    Profile->RangeSize = RangeSize;
-    Profile->Buffer = Buffer;
-    Profile->BufferSize = BufferSize;
-    Profile->BucketSize = BucketSize;
-    Profile->LockedBufferAddress = NULL;
-    Profile->Segment = Segment;
-    Profile->ProfileSource = ProfileSource;
-    Profile->Affinity = Affinity;
-    Profile->Process = pProcess;
-
-    /* Insert into the Object Tree */
-    Status = ObInsertObject ((PVOID)Profile,
-                             NULL,
-                             PROFILE_CONTROL,
-                             0,
-                             NULL,
-                             &hProfile);
-    ObDereferenceObject(Profile);
-
-    /* Check for Success */
-    if (!NT_SUCCESS(Status))
-    {
-        /* Dereference Process on failure */
-        if (pProcess) ObDereferenceObject(pProcess);
-        return Status;
-    }
-
-    /* Enter SEH */
-    _SEH_TRY
-    {
-        /* Copy the created handle back to the caller*/
-        *ProfileHandle = hProfile;
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return Status */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtQueryPerformanceCounter(OUT PLARGE_INTEGER PerformanceCounter,
-                          OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    LARGE_INTEGER PerfFrequency;
-    NTSTATUS Status = STATUS_SUCCESS;
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the counter and frequency are valid */
-            ProbeForWriteLargeInteger(PerformanceCounter);
-            if (PerformanceFrequency)
-            {
-                ProbeForWriteLargeInteger(PerformanceFrequency);
-            }
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* If the pointers are invalid, bail out */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Enter a new SEH Block */
-    _SEH_TRY
-    {
-        /* Query the Kernel */
-        *PerformanceCounter = KeQueryPerformanceCounter(&PerfFrequency);
-
-        /* Return Frequency if requested */
-        if(PerformanceFrequency) *PerformanceFrequency = PerfFrequency;
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return status to caller */
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtStartProfile(IN HANDLE ProfileHandle)
-{
-    PEPROFILE Profile;
-    PKPROFILE ProfileObject;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    PVOID TempLockedBufferAddress;
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Get the Object */
-    Status = ObReferenceObjectByHandle(ProfileHandle,
-                                       PROFILE_CONTROL,
-                                       ExProfileObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Profile,
-                                       NULL);
-    if (!NT_SUCCESS(Status)) return(Status);
-
-    /* To avoid a Race, wait on the Mutex */
-    KeWaitForSingleObject(&ExpProfileMutex,
-                          Executive,
-                          KernelMode,
-                          FALSE,
-                          NULL);
-
-    /* The Profile can still be enabled though, so handle that */
-    if (Profile->LockedBufferAddress)
-    {
-        /* Release our lock, dereference and return */
-        KeReleaseMutex(&ExpProfileMutex, FALSE);
-        ObDereferenceObject(Profile);
-        return STATUS_PROFILING_NOT_STOPPED;
-    }
-
-    /* Allocate a Kernel Profile Object. */
-    ProfileObject = ExAllocatePoolWithTag(NonPagedPool,
-                                      sizeof(EPROFILE),
-                                      TAG_PROFILE);
-
-    /* Allocate the Mdl Structure */
-    Profile->Mdl = MmCreateMdl(NULL, Profile->Buffer, Profile->BufferSize);
-
-    /* Probe and Lock for Write Access */
-    MmProbeAndLockPages(Profile->Mdl, PreviousMode, IoWriteAccess);
-
-    /* Map the pages */
-    TempLockedBufferAddress = MmMapLockedPages(Profile->Mdl, KernelMode);
-
-    /* Initialize the Kernel Profile Object */
-    Profile->ProfileObject = ProfileObject;
-    KeInitializeProfile(ProfileObject,
-                        (PKPROCESS)Profile->Process,
-                        Profile->RangeBase,
-                        Profile->RangeSize,
-                        Profile->BucketSize,
-                        Profile->ProfileSource,
-                        Profile->Affinity);
-
-    /* Start the Profiling */
-    KeStartProfile(ProfileObject, TempLockedBufferAddress);
-
-    /* Now it's safe to save this */
-    Profile->LockedBufferAddress = TempLockedBufferAddress;
-
-    /* Release mutex, dereference and return */
-    KeReleaseMutex(&ExpProfileMutex, FALSE);
-    ObDereferenceObject(Profile);
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-NtStopProfile(IN HANDLE ProfileHandle)
-{
-    PEPROFILE Profile;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status;
-    PAGED_CODE();
-
-    /* Get the Object */
-    Status = ObReferenceObjectByHandle(ProfileHandle,
-                                       PROFILE_CONTROL,
-                                       ExProfileObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Profile,
-                                       NULL);
-    if (!NT_SUCCESS(Status)) return(Status);
-
-    /* Get the Mutex */
-    KeWaitForSingleObject(&ExpProfileMutex,
-                          Executive,
-                          KernelMode,
-                          FALSE,
-                          NULL);
-
-    /* Make sure the Profile Object is really Started */
-    if (!Profile->LockedBufferAddress)
-    {
-        Status = STATUS_PROFILING_NOT_STARTED;
-        goto Exit;
-    }
-
-    /* Stop the Profile */
-    KeStopProfile(Profile->ProfileObject);
-
-    /* Unlock the Buffer */
-    MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
-    MmUnlockPages(Profile->Mdl);
-    ExFreePool(Profile->ProfileObject);
-
-    /* Clear the Locked Buffer pointer, meaning the Object is Stopped */
-    Profile->LockedBufferAddress = NULL;
-
-Exit:
-    /* Release Mutex, Dereference and Return */
-    KeReleaseMutex(&ExpProfileMutex, FALSE);
-    ObDereferenceObject(Profile);
-    return Status;
-}
-
-NTSTATUS
-NTAPI
-NtQueryIntervalProfile(IN KPROFILE_SOURCE ProfileSource,
-                       OUT PULONG Interval)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    ULONG ReturnInterval;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Validate interval */
-            ProbeForWriteUlong(Interval);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* If pointer was invalid, bail out */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Query the Interval */
-    ReturnInterval = KeQueryIntervalProfile(ProfileSource);
-
-    /* Enter SEH block for return */
-    _SEH_TRY
-    {
-        /* Return the data */
-        *Interval = ReturnInterval;
-    }
-    _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-    {
-        Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-
-    /* Return Success */
-    return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-NtSetIntervalProfile(IN ULONG Interval,
-                     IN KPROFILE_SOURCE Source)
-{
-    /* Let the Kernel do the job */
-    KeSetIntervalProfile(Interval, Source);
-
-    /* Nothing can go wrong */
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/ex/pushlock.c
+++ b/reactos/ntoskrnl/ex/pushlock.c
--- a/reactos/ntoskrnl/ex/resource.c
+++ b/reactos/ntoskrnl/ex/resource.c
--- a/reactos/ntoskrnl/ex/rundown.c
+++ b/reactos/ntoskrnl/ex/rundown.c
@@ -1,503 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/rundown.c
- * PURPOSE:         Rundown and Cache-Aware Rundown Protection
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name ExfAcquireRundownProtection
- * @implemented NT5.1
- *
- *     The ExfAcquireRundownProtection routine acquires rundown protection for
- *     the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return TRUE if access to the protected structure was granted, FALSE otherwise.
- *
- * @remarks Callers of ExfAcquireRundownProtection can be running at any IRQL.
- *
- *--*/
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value = RunRef->Count, NewValue;
-
-    /* Make sure a rundown is not active */
-    if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
-
-    /* Loop until successfully incremented the counter */
-    for (;;)
-    {
-        /* Add a reference */
-        NewValue = Value + EX_RUNDOWN_COUNT_INC;
-
-        /* Change the value */
-        Value = ExpChangeRundown(RunRef, NewValue, Value);
-        if (Value == NewValue) return TRUE;
-
-        /* Make sure a rundown is not active */
-        if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
-    }
-}
-
-/*++
- * @name ExfAcquireRundownProtectionEx
- * @implemented NT5.2
- *
- *     The ExfAcquireRundownProtectionEx routine acquires multiple rundown
- *     protection references for the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @param Count
- *         Number of times to reference the descriptor.
- *
- * @return TRUE if access to the protected structure was granted, FALSE otherwise.
- *
- * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL.
- *
- *--*/
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef,
-                              IN ULONG Count)
-{
-    ULONG_PTR Value = RunRef->Count, NewValue;
-
-    /* Make sure a rundown is not active */
-    if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
-
-    /* Convert the count to our internal representation */
-    Count <<= EX_RUNDOWN_COUNT_SHIFT;
-
-    /* Loop until successfully incremented the counter */
-    for (;;)
-    {
-        /* Add references */
-        NewValue = Value + Count;
-
-        /* Change the value */
-        Value = ExpChangeRundown(RunRef, NewValue, Value);
-        if (Value == NewValue) return TRUE;
-
-        /* Make sure a rundown is not active */
-        if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
-    }
-}
-
-/*++
- * @name ExfInitializeRundownProtection
- * @implemented NT5.1
- *
- *     The ExfInitializeRundownProtection routine initializes a rundown
- *     protection descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfInitializeRundownProtection can be running at any IRQL.
- *
- *--*/
-VOID
-FASTCALL
-ExfInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    /* Set the count to zero */
-    RunRef->Count = 0;
-}
-
-/*++
- * @name ExfReInitializeRundownProtection
- * @implemented NT5.1
- *
- *     The ExfReInitializeRundownProtection routine re-initializes a rundown
- *     protection descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfReInitializeRundownProtection can be running at any IRQL.
- *
- *--*/
-VOID
-FASTCALL
-ExfReInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
-
-    /* Reset the count */
-    ExpSetRundown(&RunRef->Count, 0);
-}
-
-/*++
- * @name ExfRundownCompleted
- * @implemented NT5.1
- *
- *     The ExfRundownCompleted routine completes the rundown of the specified
- *     descriptor by setting the active bit.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfRundownCompleted must be running at IRQL <= APC_LEVEL.
- *
- *--*/
-VOID
-FASTCALL
-ExfRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
-{
-    PAGED_CODE();
-
-    /* Sanity check */
-    ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
-
-    /* Mark the counter as active */
-    ExpSetRundown(&RunRef->Count, EX_RUNDOWN_ACTIVE);
-}
-
-/*++
- * @name ExfReleaseRundownProtection
- * @implemented NT5.1
- *
- *     The ExfReleaseRundownProtection routine releases the rundown protection
- *     reference for the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfReleaseRundownProtection can be running at any IRQL.
- *
- *--*/
-VOID
-FASTCALL
-ExfReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value = RunRef->Count, NewValue;
-    PEX_RUNDOWN_WAIT_BLOCK WaitBlock;
-
-    /* Check if rundown is not active */
-    if (!(Value & EX_RUNDOWN_ACTIVE))
-    {
-        /* Loop until successfully incremented the counter */
-        for (;;)
-        {
-            /* Sanity check */
-            ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
-
-            /* Get the new value */
-            NewValue = Value - EX_RUNDOWN_COUNT_INC;
-
-            /* Change the value */
-            Value = ExpChangeRundown(RunRef, NewValue, Value);
-            if (Value == NewValue) return;
-
-            /* Loop again if we're still not active */
-            if (Value & EX_RUNDOWN_ACTIVE) break;
-        }
-    }
-
-    /* Get the wait block */
-    WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE);
-    ASSERT((WaitBlock->Count > 0) || (KeNumberProcessors > 1));
-
-    /* Remove the one count */
-    if (!InterlockedDecrementSizeT(&WaitBlock->Count))
-    {
-        /* We're down to 0 now, so signal the event */
-        KeSetEvent(&WaitBlock->WakeEvent, IO_NO_INCREMENT, FALSE);
-    }
-}
-
-/*++
- * @name ExfReleaseRundownProtectionEx
- * @implemented NT5.2
- *
- *     The ExfReleaseRundownProtectionEx routine releases multiple rundown
- *     protection references for the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @param Count
- *         Number of times to dereference the descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL.
- *
- *--*/
-VOID
-FASTCALL
-ExfReleaseRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef,
-                              IN ULONG Count)
-{
-    ULONG_PTR Value = RunRef->Count, NewValue;
-    PEX_RUNDOWN_WAIT_BLOCK WaitBlock;
-
-    /* Check if rundown is not active */
-    if (!(Value & EX_RUNDOWN_ACTIVE))
-    {
-        /* Loop until successfully incremented the counter */
-        for (;;)
-        {
-            /* Sanity check */
-            ASSERT((Value >= EX_RUNDOWN_COUNT_INC * Count) || (KeNumberProcessors > 1));
-
-            /* Get the new value */
-            NewValue = Value - (Count * EX_RUNDOWN_COUNT_INC);
-
-            /* Change the value */
-            Value = ExpChangeRundown(RunRef, NewValue, Value);
-            if (Value == NewValue) return;
-
-            /* Loop again if we're still not active */
-            if (Value & EX_RUNDOWN_ACTIVE) break;
-        }
-    }
-
-    /* Get the wait block */
-    WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE);
-    ASSERT((WaitBlock->Count >= Count) || (KeNumberProcessors > 1));
-
-    /* Remove the count */
-    if (InterlockedExchangeAddSizeT(&WaitBlock->Count, -(LONG)Count) ==
-        (LONG)Count)
-    {
-        /* We're down to 0 now, so signal the event */
-        KeSetEvent(&WaitBlock->WakeEvent, IO_NO_INCREMENT, FALSE);
-    }
-}
-
-/*++
- * @name ExfWaitForRundownProtectionRelease
- * @implemented NT5.1
- *
- *     The ExfWaitForRundownProtectionRelease routine waits until the specified
- *     rundown descriptor has been released.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks Callers of ExfWaitForRundownProtectionRelease must be running
- *          at IRQL <= APC_LEVEL.
- *
- *--*/
-VOID
-FASTCALL
-ExfWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value, Count, NewValue;
-    EX_RUNDOWN_WAIT_BLOCK WaitBlock;
-    PEX_RUNDOWN_WAIT_BLOCK WaitBlockPointer;
-    PKEVENT Event;
-    PAGED_CODE();
-
-    /* Set the active bit */
-    Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
-    if ((Value == 0) || (Value == EX_RUNDOWN_ACTIVE)) return;
-
-    /* No event for now */
-    Event = NULL;
-    WaitBlockPointer = (PEX_RUNDOWN_WAIT_BLOCK)((ULONG_PTR)&WaitBlock |
-                                                EX_RUNDOWN_ACTIVE);
-
-    /* Start waitblock set loop */
-    for(;;)
-    {
-        /* Save the count */
-        Count = Value >> EX_RUNDOWN_COUNT_SHIFT;
-
-        /* If the count is over one or we don't have en event yet, create it */
-        if (Count || !Event)
-        {
-            /* Initialize the event */
-            KeInitializeEvent(&WaitBlock.WakeEvent,
-                              NotificationEvent,
-                              FALSE);
-
-            /* Set the pointer */
-            Event = &WaitBlock.WakeEvent;
-        }
-
-        /* Set the count */
-        WaitBlock.Count = Count;
-
-        /* Now set the pointer */
-        NewValue = ExpChangeRundown(RunRef, PtrToUlong(WaitBlockPointer), Value);
-        if (NewValue == Value) break;
-
-        /* Loop again */
-        Value = NewValue;
-        ASSERT((Value & EX_RUNDOWN_ACTIVE) == 0);
-    }
-
-    /* If the count was 0, we're done */
-    if (!Count) return;
-
-    /* Wait for whoever needs to release to notify us */
-    KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL);
-    ASSERT(WaitBlock.Count == 0);
-}
-
-/* FIXME: STUBS **************************************************************/
-
-/*
- * @unimplemented NT5.2
- */
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented NT5.2
- */
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
-                                        IN ULONG Count)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    DBG_UNREFERENCED_PARAMETER(Count);
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-FASTCALL
-ExfReleaseRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-FASTCALL
-ExfReleaseRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
-                                        IN ULONG Count)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    DBG_UNREFERENCED_PARAMETER(Count);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-FASTCALL
-ExfWaitForRundownProtectionReleaseCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-FASTCALL
-ExfRundownCompletedCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-FASTCALL
-ExfReInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-PEX_RUNDOWN_REF_CACHE_AWARE
-NTAPI
-ExAllocateCacheAwareRundownProtection(IN POOL_TYPE PoolType,
-                                      IN ULONG Tag)
-{
-    DBG_UNREFERENCED_PARAMETER(PoolType);
-    DBG_UNREFERENCED_PARAMETER(Tag);
-    UNIMPLEMENTED;
-    return NULL;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-NTAPI
-ExFreeCacheAwareRundownProtection(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-VOID
-NTAPI
-ExInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
-                                        IN ULONG Count)
-{
-    DBG_UNREFERENCED_PARAMETER(RunRefCacheAware);
-    DBG_UNREFERENCED_PARAMETER(Count);
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented NT5.2
- */
-SIZE_T
-NTAPI
-ExSizeOfRundownProtectionCacheAware(VOID)
-{
-    UNIMPLEMENTED;
-    return 0;
-}
-
--- a/reactos/ntoskrnl/ex/sem.c
+++ b/reactos/ntoskrnl/ex/sem.c
@@ -1,361 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/sem.c
- * PURPOSE:         Semaphore Implementation
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeSemaphoreImplementation()
-#endif
-
-/* GLOBALS ******************************************************************/
-
-POBJECT_TYPE ExSemaphoreObjectType;
-
-GENERIC_MAPPING ExSemaphoreMapping =
-{
-    STANDARD_RIGHTS_READ    | SEMAPHORE_QUERY_STATE,
-    STANDARD_RIGHTS_WRITE   | SEMAPHORE_MODIFY_STATE,
-    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | SEMAPHORE_QUERY_STATE,
-    SEMAPHORE_ALL_ACCESS
-};
-
-static const INFORMATION_CLASS_INFO ExSemaphoreInfoClass[] =
-{
-     /* SemaphoreBasicInformation */
-    ICI_SQ_SAME( sizeof(SEMAPHORE_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY),
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeSemaphoreImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Semaphore Object Type\n");
-
-    /* Create the Event Pair Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Semaphore");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KSEMAPHORE);
-    ObjectTypeInitializer.GenericMapping = ExSemaphoreMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
-    ObjectTypeInitializer.ValidAccessMask = SEMAPHORE_ALL_ACCESS;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExSemaphoreObjectType);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtCreateSemaphore(OUT PHANDLE SemaphoreHandle,
-                  IN ACCESS_MASK DesiredAccess,
-                  IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
-                  IN LONG InitialCount,
-                  IN LONG MaximumCount)
-{
-    PKSEMAPHORE Semaphore;
-    HANDLE hSemaphore;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(SemaphoreHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Make sure the counts make sense */
-    if ((MaximumCount <= 0) ||
-        (InitialCount < 0) ||
-        (InitialCount > MaximumCount))
-    {
-        DPRINT("Invalid Count Data!\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Create the Semaphore Object */
-    Status = ObCreateObject(PreviousMode,
-                            ExSemaphoreObjectType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(KSEMAPHORE),
-                            0,
-                            0,
-                            (PVOID*)&Semaphore);
-
-    /* Check for Success */
-    if (NT_SUCCESS(Status))
-    {
-        /* Initialize it */
-        KeInitializeSemaphore(Semaphore,
-                              InitialCount,
-                              MaximumCount);
-
-        /* Insert it into the Object Tree */
-        Status = ObInsertObject((PVOID)Semaphore,
-                                NULL,
-                                DesiredAccess,
-                                0,
-                                NULL,
-                                &hSemaphore);
-
-        /* Check for success */
-        if(NT_SUCCESS(Status))
-        {
-            /* Enter SEH Block for return */
-            _SEH_TRY
-            {
-                /* Return the handle */
-                *SemaphoreHandle = hSemaphore;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtOpenSemaphore(OUT PHANDLE SemaphoreHandle,
-                IN ACCESS_MASK DesiredAccess,
-                IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    HANDLE hSemaphore;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Check handle pointer */
-            ProbeForWriteHandle(SemaphoreHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Object */
-    Status = ObOpenObjectByName(ObjectAttributes,
-                                ExSemaphoreObjectType,
-                                PreviousMode,
-                                NULL,
-                                DesiredAccess,
-                                NULL,
-                                &hSemaphore);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Enter SEH Block for return */
-        _SEH_TRY
-        {
-            /* Return the handle */
-            *SemaphoreHandle = hSemaphore;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtQuerySemaphore(IN HANDLE SemaphoreHandle,
-                 IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
-                 OUT PVOID SemaphoreInformation,
-                 IN ULONG SemaphoreInformationLength,
-                 OUT PULONG ReturnLength  OPTIONAL)
-{
-    PKSEMAPHORE Semaphore;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check buffers and class validity */
-    Status = DefaultQueryInfoBufferCheck(SemaphoreInformationClass,
-                                         ExSemaphoreInfoClass,
-                                         sizeof(ExSemaphoreInfoClass) /
-                                         sizeof(ExSemaphoreInfoClass[0]),
-                                         SemaphoreInformation,
-                                         SemaphoreInformationLength,
-                                         ReturnLength,
-                                         PreviousMode);
-    if(!NT_SUCCESS(Status))
-    {
-        /* Invalid buffers */
-        DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status);
-        return Status;
-    }
-
-    /* Get the Object */
-    Status = ObReferenceObjectByHandle(SemaphoreHandle,
-                                       SEMAPHORE_QUERY_STATE,
-                                       ExSemaphoreObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Semaphore,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            PSEMAPHORE_BASIC_INFORMATION BasicInfo =
-                (PSEMAPHORE_BASIC_INFORMATION)SemaphoreInformation;
-
-            /* Return the basic information */
-            BasicInfo->CurrentCount = KeReadStateSemaphore(Semaphore);
-            BasicInfo->MaximumCount = Semaphore->Limit;
-
-            /* Return the length */
-            if(ReturnLength) *ReturnLength = sizeof(*BasicInfo);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Dereference the Object */
-        ObDereferenceObject(Semaphore);
-   }
-
-   /* Return status */
-   return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtReleaseSemaphore(IN HANDLE SemaphoreHandle,
-                   IN LONG ReleaseCount,
-                   OUT PLONG PreviousCount OPTIONAL)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    PKSEMAPHORE Semaphore;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if((PreviousCount) && (PreviousMode != KernelMode))
-    {
-        /* Entry SEH Block */
-        _SEH_TRY
-        {
-            /* Make sure the state pointer is valid */
-            ProbeForWriteLong(PreviousCount);
-         }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Bail out if pointer was invalid */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Make sure count makes sense */
-    if (ReleaseCount <= 0)
-    {
-        DPRINT("Invalid Release Count\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Get the Object */
-    Status = ObReferenceObjectByHandle(SemaphoreHandle,
-                                       SEMAPHORE_MODIFY_STATE,
-                                       ExSemaphoreObjectType,
-                                       PreviousMode,
-                                       (PVOID*)&Semaphore,
-                                       NULL);
-
-    /* Check for success */
-    if (NT_SUCCESS(Status))
-    {
-        /* Enter SEH Block */
-        _SEH_TRY
-        {
-            /* Release the semaphore */
-            LONG PrevCount = KeReleaseSemaphore(Semaphore,
-                                                IO_NO_INCREMENT,
-                                                ReleaseCount,
-                                                FALSE);
-            ObDereferenceObject(Semaphore);
-
-            /* Return the old count if requested */
-            if(PreviousCount) *PreviousCount = PrevCount;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/sysinfo.c
+++ b/reactos/ntoskrnl/ex/sysinfo.c
--- a/reactos/ntoskrnl/ex/time.c
+++ b/reactos/ntoskrnl/ex/time.c
@@ -1,297 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/time.c
- * PURPOSE:         Time and Timezone Management
- * PROGRAMMERS:     Eric Kohl
- *                  Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#define TICKSPERMINUTE  600000000
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitTimeZoneInfo)
-#endif
-
-/* GLOBALS ******************************************************************/
-
-/* Note: Bias[minutes] = UTC - local time */
-TIME_ZONE_INFORMATION ExpTimeZoneInfo;
-LARGE_INTEGER ExpTimeZoneBias;
-ULONG ExpTimeZoneId;
-
-/* FUNCTIONS ****************************************************************/
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitTimeZoneInfo(VOID)
-{
-    LARGE_INTEGER CurrentTime;
-    NTSTATUS Status;
-
-     /* Read time zone information from the registry */
-    Status = RtlQueryTimeZoneInformation(&ExpTimeZoneInfo);
-    if (!NT_SUCCESS(Status))
-    {
-        /* Failed, clear all data */
-        RtlZeroMemory(&ExpTimeZoneInfo, sizeof(TIME_ZONE_INFORMATION));
-        ExpTimeZoneBias.QuadPart = (LONGLONG)0;
-        ExpTimeZoneId = TIME_ZONE_ID_UNKNOWN;
-    }
-    else
-    {
-        /* FIXME: Calculate transition dates */
-
-        /* Set bias and ID */
-        ExpTimeZoneBias.QuadPart = ((LONGLONG)(ExpTimeZoneInfo.Bias +
-                                               ExpTimeZoneInfo.StandardBias)) *
-                                               TICKSPERMINUTE;
-        ExpTimeZoneId = TIME_ZONE_ID_STANDARD;
-    }
-
-    /* Change it for user-mode applications */
-    SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart;
-    SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart;
-    SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart;
-    SharedUserData->TimeZoneId = ExpTimeZoneId;
-
-    /* Convert boot time from local time to UTC */
-    SystemBootTime.QuadPart += ExpTimeZoneBias.QuadPart;
-
-    /* Convert system time from local time to UTC */
-    do
-    {
-        CurrentTime.u.HighPart = SharedUserData->SystemTime.High1Time;
-        CurrentTime.u.LowPart = SharedUserData->SystemTime.LowPart;
-    } while (CurrentTime.u.HighPart != SharedUserData->SystemTime.High2Time);
-
-    /* Change it for user-mode applications */
-    CurrentTime.QuadPart += ExpTimeZoneBias.QuadPart;
-    SharedUserData->SystemTime.LowPart = CurrentTime.u.LowPart;
-    SharedUserData->SystemTime.High1Time = CurrentTime.u.HighPart;
-    SharedUserData->SystemTime.High2Time = CurrentTime.u.HighPart;
-}
-
-NTSTATUS
-ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation)
-{
-    LARGE_INTEGER LocalTime, SystemTime;
-    TIME_FIELDS TimeFields;
-    DPRINT("ExpSetTimeZoneInformation() called\n");
-
-    DPRINT("Old time zone bias: %d minutes\n", ExpTimeZoneInfo.Bias);
-    DPRINT("Old time zone standard bias: %d minutes\n",
-            ExpTimeZoneInfo.StandardBias);
-    DPRINT("New time zone bias: %d minutes\n", TimeZoneInformation->Bias);
-    DPRINT("New time zone standard bias: %d minutes\n",
-            TimeZoneInformation->StandardBias);
-
-    /* Get the local time */
-    HalQueryRealTimeClock(&TimeFields);
-    RtlTimeFieldsToTime(&TimeFields, &LocalTime);
-
-    /* FIXME: Calculate transition dates */
-
-    /* Calculate the bias and set the ID */
-    ExpTimeZoneBias.QuadPart = ((LONGLONG)(TimeZoneInformation->Bias +
-                                           TimeZoneInformation->StandardBias)) *
-                                           TICKSPERMINUTE;
-    ExpTimeZoneId = TIME_ZONE_ID_STANDARD;
-
-    /* Copy the timezone information */
-    RtlMoveMemory(&ExpTimeZoneInfo,
-                  TimeZoneInformation,
-                  sizeof(TIME_ZONE_INFORMATION));
-
-    /* Set the new time zone information */
-    SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart;
-    SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart;
-    SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart;
-    SharedUserData->TimeZoneId = ExpTimeZoneId;
-
-    DPRINT("New time zone bias: %I64d minutes\n",
-            ExpTimeZoneBias.QuadPart / TICKSPERMINUTE);
-
-    /* Calculate the new system time */
-    ExLocalTimeToSystemTime(&LocalTime, &SystemTime);
-
-    /* Set the new system time */
-    KiSetSystemTime(&SystemTime);
-
-    /* Return success */
-    DPRINT("ExpSetTimeZoneInformation() done\n");
-    return STATUS_SUCCESS;
-}
-
-/*
- * FUNCTION: Sets the system time.
- * PARAMETERS:
- *        NewTime - Points to a variable that specified the new time
- *        of day in the standard time format.
- *        OldTime - Optionally points to a variable that receives the
- *        old time of day in the standard time format.
- * RETURNS: Status
- */
-NTSTATUS
-NTAPI
-NtSetSystemTime(IN PLARGE_INTEGER SystemTime,
-                OUT PLARGE_INTEGER PreviousTime OPTIONAL)
-{
-    LARGE_INTEGER OldSystemTime;
-    LARGE_INTEGER NewSystemTime;
-    LARGE_INTEGER LocalTime;
-    TIME_FIELDS TimeFields;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            /* Verify the time pointers */
-            NewSystemTime = ProbeForReadLargeInteger(SystemTime);
-            if(PreviousTime) ProbeForWriteLargeInteger(PreviousTime);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* If the pointers were invalid, bail out */
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-    else
-    {
-        /* Reuse the pointer */
-        NewSystemTime = *SystemTime;
-    }
-
-    /* Make sure we have permission to change the time */
-    if(!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
-    {
-        DPRINT1("NtSetSystemTime: Caller requires the "
-                "SeSystemtimePrivilege privilege!\n");
-        return STATUS_PRIVILEGE_NOT_HELD;
-    }
-
-    /* Check if caller wants the old time */
-    if(PreviousTime) KeQuerySystemTime(&OldSystemTime);
-
-    /* Convert the time and set it in HAL */
-    ExSystemTimeToLocalTime(&NewSystemTime, &LocalTime);
-    RtlTimeToTimeFields(&LocalTime, &TimeFields);
-    HalSetRealTimeClock(&TimeFields);
-
-    /* Now set system time */
-    KiSetSystemTime(&NewSystemTime);
-
-    /* Check if caller wanted previous time */
-    if(PreviousTime)
-    {
-        /* Enter SEH Block for return */
-        _SEH_TRY
-        {
-            /* Return the previous time */
-            *PreviousTime = OldSystemTime;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * FUNCTION: Retrieves the system time.
- * PARAMETERS:
- *          CurrentTime - Points to a variable that receives the current
- *          time of day in the standard time format.
- */
-NTSTATUS
-NTAPI
-NtQuerySystemTime(OUT PLARGE_INTEGER SystemTime)
-{
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-
-    /* Check if we were called from user-mode */
-    if(PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            /* Verify the time pointer */
-            ProbeForWriteLargeInteger(SystemTime);
-
-            /*
-             * It's safe to pass the pointer directly to KeQuerySystemTime as
-             * it's just a basic copy to this pointer. If it raises an
-             * exception nothing dangerous can happen!
-             */
-            KeQuerySystemTime(SystemTime);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-        Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-    else
-    {
-        /* Query the time directly */
-        KeQuerySystemTime(SystemTime);
-    }
-
-    /* Return status to caller */
-    return Status;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-ExLocalTimeToSystemTime(PLARGE_INTEGER LocalTime,
-                        PLARGE_INTEGER SystemTime)
-{
-    SystemTime->QuadPart = LocalTime->QuadPart + ExpTimeZoneBias.QuadPart;
-}
-
-/*
- * @unimplemented
- */
-ULONG
-NTAPI
-ExSetTimerResolution(IN ULONG DesiredTime,
-                     IN BOOLEAN SetResolution)
-{
-    UNIMPLEMENTED;
-    return 0;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-ExSystemTimeToLocalTime(PLARGE_INTEGER SystemTime,
-                        PLARGE_INTEGER LocalTime)
-{
-    LocalTime->QuadPart = SystemTime->QuadPart - ExpTimeZoneBias.QuadPart;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/timer.c
+++ b/reactos/ntoskrnl/ex/timer.c
@@ -1,791 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/timer.c
- * PURPOSE:         Executive Timer Implementation
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  David Welch (welch@mcmail.com)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeTimerImplementation)
-#endif
-
-
-/* TYPES ********************************************************************/
-
-/* Executive Timer Object */
-typedef struct _ETIMER
-{
-    KTIMER KeTimer;
-    KAPC TimerApc;
-    KDPC TimerDpc;
-    LIST_ENTRY ActiveTimerListEntry;
-    KSPIN_LOCK Lock;
-    BOOLEAN ApcAssociated;
-    BOOLEAN WakeTimer;
-    LIST_ENTRY WakeTimerListEntry;
-} ETIMER, *PETIMER;
-
-/* GLOBALS ******************************************************************/
-
-/* Timer Object Type */
-POBJECT_TYPE ExTimerType = NULL;
-
-KSPIN_LOCK ExpWakeListLock;
-LIST_ENTRY ExpWakeList;
-
-/* Timer Mapping */
-static GENERIC_MAPPING ExpTimerMapping =
-{
-    STANDARD_RIGHTS_READ    | TIMER_QUERY_STATE,
-    STANDARD_RIGHTS_WRITE   | TIMER_MODIFY_STATE,
-    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
-    TIMER_ALL_ACCESS
-};
-
-/* Timer Information Classes */
-static const INFORMATION_CLASS_INFO ExTimerInfoClass[] =
-{
-    /* TimerBasicInformation */
-    ICI_SQ_SAME( sizeof(TIMER_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY ),
-};
-
-/* FUNCTIONS *****************************************************************/
-
-VOID
-STDCALL
-ExTimerRundown(VOID)
-{
-    PETHREAD Thread = PsGetCurrentThread();
-    KIRQL OldIrql;
-    PLIST_ENTRY CurrentEntry;
-    PETIMER Timer;
-
-    /* Lock the Thread's Active Timer List*/
-    KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
-
-    while (!IsListEmpty(&Thread->ActiveTimerListHead))
-    {
-        /* Remove a Timer */
-        CurrentEntry = RemoveTailList(&Thread->ActiveTimerListHead);
-
-        /* Get the Timer */
-        Timer = CONTAINING_RECORD(CurrentEntry, ETIMER, ActiveTimerListEntry);
-        DPRINT("Timer, ThreadList: 0x%p, 0x%p\n", Timer, Thread);
-
-        /* Mark it as deassociated */
-        ASSERT (Timer->ApcAssociated);
-        Timer->ApcAssociated = FALSE;
-
-        /* Unlock the list */
-        KeReleaseSpinLockFromDpcLevel(&Thread->ActiveTimerListLock);
-
-        /* Lock the Timer */
-        KeAcquireSpinLockAtDpcLevel(&Timer->Lock);
-
-        /* Cancel the timer and remove its DPC and APC */
-        ASSERT(&Thread->Tcb == Timer->TimerApc.Thread);
-        KeCancelTimer(&Timer->KeTimer);
-        KeRemoveQueueDpc(&Timer->TimerDpc);
-        KeRemoveQueueApc(&Timer->TimerApc);
-
-        /* Unlock the Timer */
-        KeReleaseSpinLock(&Timer->Lock, OldIrql);
-
-        /* Dereference it */
-        ObDereferenceObject(Timer);
-
-        /* Loop again */
-        KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
-    }
-
-    /* Release lock and return */
-    KeReleaseSpinLock(&Thread->ActiveTimerListLock, OldIrql);
-    return;
-}
-
-VOID
-STDCALL
-ExpDeleteTimer(PVOID ObjectBody)
-{
-    KIRQL OldIrql;
-    PETIMER Timer = ObjectBody;
-    DPRINT("ExpDeleteTimer(Timer: 0x%p)\n", Timer);
-
-    /* Check if it has a Wait List */
-    if (Timer->WakeTimer)
-    {
-        /* Lock the Wake List */
-        KeAcquireSpinLock(&ExpWakeListLock, &OldIrql);
-
-        /* Check again, since it might've changed before we locked */
-        if (Timer->WakeTimer)
-        {
-            /* Remove it from the Wait List */
-            DPRINT("Removing wake list\n");
-            RemoveEntryList(&Timer->WakeTimerListEntry);
-            Timer->WakeTimer = FALSE;
-        }
-
-        /* Release the Wake List */
-        KeReleaseSpinLock(&ExpWakeListLock, OldIrql);
-    }
-
-    /* Tell the Kernel to cancel the Timer */
-    DPRINT("Cancelling Timer\n");
-    KeCancelTimer(&Timer->KeTimer);
-}
-
-VOID
-STDCALL
-ExpTimerDpcRoutine(PKDPC Dpc,
-                   PVOID DeferredContext,
-                   PVOID SystemArgument1,
-                   PVOID SystemArgument2)
-{
-    PETIMER Timer;
-    KIRQL OldIrql;
-
-    DPRINT("ExpTimerDpcRoutine(Dpc: 0x%p)\n", Dpc);
-
-    /* Get the Timer Object */
-    Timer = (PETIMER)DeferredContext;
-
-    /* Lock the Timer */
-    KeAcquireSpinLock(&Timer->Lock, &OldIrql);
-
-    /* Queue the APC */
-    if(Timer->ApcAssociated)
-    {
-        DPRINT("Queuing APC\n");
-        KeInsertQueueApc(&Timer->TimerApc,
-                         SystemArgument1,
-                         SystemArgument2,
-                         IO_NO_INCREMENT);
-    }
-
-    /* Release the Timer */
-    KeReleaseSpinLock(&Timer->Lock, OldIrql);
-    return;
-}
-
-
-VOID
-STDCALL
-ExpTimerApcKernelRoutine(PKAPC Apc,
-                         PKNORMAL_ROUTINE* NormalRoutine,
-                         PVOID* NormalContext,
-                         PVOID* SystemArgument1,
-                         PVOID* SystemArguemnt2)
-{
-    PETIMER Timer;
-    KIRQL OldIrql;
-    PETHREAD CurrentThread = PsGetCurrentThread();
-
-    /* We need to find out which Timer we are */
-    Timer = CONTAINING_RECORD(Apc, ETIMER, TimerApc);
-    DPRINT("ExpTimerApcKernelRoutine(Apc: 0x%p. Timer: 0x%p)\n", Apc, Timer);
-
-    /* Lock the Timer */
-    KeAcquireSpinLock(&Timer->Lock, &OldIrql);
-
-    /* Lock the Thread's Active Timer List*/
-    KeAcquireSpinLockAtDpcLevel(&CurrentThread->ActiveTimerListLock);
-
-    /*
-     * Make sure that the Timer is still valid, and that it belongs to this thread
-     * Remove it if it's not periodic
-     */
-    if ((Timer->ApcAssociated) &&
-        (&CurrentThread->Tcb == Timer->TimerApc.Thread) &&
-        (!Timer->KeTimer.Period))
-    {
-        /* Remove it from the Active Timers List */
-        DPRINT("Removing Timer\n");
-        RemoveEntryList(&Timer->ActiveTimerListEntry);
-
-        /* Disable it */
-        Timer->ApcAssociated = FALSE;
-
-        /* Release spinlocks */
-        KeReleaseSpinLockFromDpcLevel(&CurrentThread->ActiveTimerListLock);
-        KeReleaseSpinLock(&Timer->Lock, OldIrql);
-
-        /* Dereference the Timer Object */
-        ObDereferenceObject(Timer);
-        return;
-    }
-
-    /* Release spinlocks */
-    KeReleaseSpinLockFromDpcLevel(&CurrentThread->ActiveTimerListLock);
-    KeReleaseSpinLock(&Timer->Lock, OldIrql);
-}
-
-VOID
-INIT_FUNCTION
-STDCALL
-ExpInitializeTimerImplementation(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-
-    DPRINT("Creating Timer Object Type\n");
-  
-    /* Create the Event Pair Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"Timer");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
-    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETIMER);
-    ObjectTypeInitializer.GenericMapping = ExpTimerMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.ValidAccessMask = TIMER_ALL_ACCESS;
-    ObjectTypeInitializer.DeleteProcedure = ExpDeleteTimer;
-    ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExTimerType);
-
-    /* Initialize the Wait List and Lock */
-    KeInitializeSpinLock(&ExpWakeListLock);
-    InitializeListHead(&ExpWakeList);
-}
-
-NTSTATUS
-STDCALL
-NtCancelTimer(IN HANDLE TimerHandle,
-              OUT PBOOLEAN CurrentState OPTIONAL)
-{
-    PETIMER Timer;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    BOOLEAN State;
-    KIRQL OldIrql;
-    PETHREAD TimerThread;
-    BOOLEAN KillTimer = FALSE;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtCancelTimer(0x%p, 0x%x)\n", TimerHandle, CurrentState);
-
-    /* Check Parameter Validity */
-    if(CurrentState && PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            ProbeForWriteBoolean(CurrentState);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Get the Timer Object */
-    Status = ObReferenceObjectByHandle(TimerHandle,
-                                       TIMER_MODIFY_STATE,
-                                       ExTimerType,
-                                       PreviousMode,
-                                       (PVOID*)&Timer,
-                                       NULL);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        DPRINT("Timer Referenced: 0x%p\n", Timer);
-
-        /* Lock the Timer */
-        KeAcquireSpinLock(&Timer->Lock, &OldIrql);
-
-        /* Check if it's enabled */
-        if (Timer->ApcAssociated)
-        {
-            /*
-             * First, remove it from the Thread's Active List
-             * Get the Thread.
-             */
-            TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread, ETHREAD, Tcb);
-            DPRINT("Removing from Thread: 0x%p\n", TimerThread);
-
-            /* Lock its active list */
-            KeAcquireSpinLockAtDpcLevel(&TimerThread->ActiveTimerListLock);
-
-            /* Remove it */
-            RemoveEntryList(&TimerThread->ActiveTimerListHead);
-
-            /* Unlock the list */
-            KeReleaseSpinLockFromDpcLevel(&TimerThread->ActiveTimerListLock);
-
-            /* Cancel the Timer */
-            KeCancelTimer(&Timer->KeTimer);
-            KeRemoveQueueDpc(&Timer->TimerDpc);
-            KeRemoveQueueApc(&Timer->TimerApc);
-            Timer->ApcAssociated = FALSE;
-            KillTimer = TRUE;
-        }
-        else
-        {
-            /* If timer was disabled, we still need to cancel it */
-            DPRINT("APC was not Associated. Cancelling Timer\n");
-            KeCancelTimer(&Timer->KeTimer);
-        }
-
-        /* Handle a Wake Timer */
-        if (Timer->WakeTimer)
-        {
-            /* Lock the Wake List */
-            KeAcquireSpinLockAtDpcLevel(&ExpWakeListLock);
-
-            /* Check again, since it might've changed before we locked */
-            if (Timer->WakeTimer)
-            {
-                /* Remove it from the Wait List */
-                DPRINT("Removing wake list\n");
-                RemoveEntryList(&Timer->WakeTimerListEntry);
-                Timer->WakeTimer = FALSE;
-            }
-
-            /* Release the Wake List */
-            KeReleaseSpinLockFromDpcLevel(&ExpWakeListLock);
-        }
-
-        /* Unlock the Timer */
-        KeReleaseSpinLock(&Timer->Lock, OldIrql);
-
-        /* Read the old State */
-        State = KeReadStateTimer(&Timer->KeTimer);
-
-        /* Dereference the Object */
-        ObDereferenceObject(Timer);
-
-        /* Dereference if it was previously enabled */
-        if (KillTimer) ObDereferenceObject(Timer);
-        DPRINT1("Timer disabled\n");
-
-        /* Make sure it's safe to write to the handle */
-        if(CurrentState)
-        {
-            _SEH_TRY
-            {
-                *CurrentState = State;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return to Caller */
-    return Status;
-}
-
-NTSTATUS
-STDCALL
-NtCreateTimer(OUT PHANDLE TimerHandle,
-              IN ACCESS_MASK DesiredAccess,
-              IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
-              IN TIMER_TYPE TimerType)
-{
-    PETIMER Timer;
-    HANDLE hTimer;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtCreateTimer(Handle: 0x%p, Type: %d)\n", TimerHandle, TimerType);
-
-    /* Check Parameter Validity */
-    if (PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            ProbeForWriteHandle(TimerHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Check for correct timer type */
-    if ((TimerType != NotificationTimer) && (TimerType != SynchronizationTimer))
-    {
-        DPRINT1("Invalid Timer Type!\n");
-        return STATUS_INVALID_PARAMETER_4;
-    }
-
-    /* Create the Object */
-    Status = ObCreateObject(PreviousMode,
-                            ExTimerType,
-                            ObjectAttributes,
-                            PreviousMode,
-                            NULL,
-                            sizeof(ETIMER),
-                            0,
-                            0,
-                            (PVOID*)&Timer);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Initialize the Kernel Timer */
-        DPRINT("Initializing Timer: 0x%p\n", Timer);
-        KeInitializeTimerEx(&Timer->KeTimer, TimerType);
-
-        /* Initialize the Timer Lock */
-        KeInitializeSpinLock(&Timer->Lock);
-
-        /* Initialize the DPC */
-        KeInitializeDpc(&Timer->TimerDpc, ExpTimerDpcRoutine, Timer);
-
-        /* Set Initial State */
-        Timer->ApcAssociated = FALSE;
-        Timer->WakeTimer = FALSE;
-
-        /* Insert the Timer */
-        Status = ObInsertObject((PVOID)Timer,
-                                NULL,
-                                DesiredAccess,
-                                0,
-                                NULL,
-                                &hTimer);
-        DPRINT("Timer Inserted\n");
-
-        /* Make sure it's safe to write to the handle */
-        _SEH_TRY
-        {
-            *TimerHandle = hTimer;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return to Caller */
-    return Status;
-}
-
-NTSTATUS
-STDCALL
-NtOpenTimer(OUT PHANDLE TimerHandle,
-            IN ACCESS_MASK DesiredAccess,
-            IN POBJECT_ATTRIBUTES ObjectAttributes)
-{
-    HANDLE hTimer;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtOpenTimer(TimerHandle: 0x%p)\n", TimerHandle);
-
-    /* Check Parameter Validity */
-    if (PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            ProbeForWriteHandle(TimerHandle);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Open the Timer */
-    Status = ObOpenObjectByName(ObjectAttributes,
-                                ExTimerType,
-                                PreviousMode,
-                                NULL,
-                                DesiredAccess,
-                                NULL,
-                                &hTimer);
-
-    /* Check for success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Make sure it's safe to write to the handle */
-        _SEH_TRY
-        {
-            *TimerHandle = hTimer;
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-    }
-
-    /* Return to Caller */
-    return Status;
-}
-
-
-NTSTATUS
-STDCALL
-NtQueryTimer(IN HANDLE TimerHandle,
-             IN TIMER_INFORMATION_CLASS TimerInformationClass,
-             OUT PVOID TimerInformation,
-             IN ULONG TimerInformationLength,
-             OUT PULONG ReturnLength  OPTIONAL)
-{
-    PETIMER Timer;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    NTSTATUS Status = STATUS_SUCCESS;
-    PTIMER_BASIC_INFORMATION BasicInfo = (PTIMER_BASIC_INFORMATION)TimerInformation;
-    PAGED_CODE();
-    DPRINT("NtQueryTimer(TimerHandle: 0x%p, Class: %d)\n", TimerHandle, TimerInformationClass);
-
-    /* Check Validity */
-    Status = DefaultQueryInfoBufferCheck(TimerInformationClass,
-                                         ExTimerInfoClass,
-                                         sizeof(ExTimerInfoClass) / sizeof(ExTimerInfoClass[0]),
-                                         TimerInformation,
-                                         TimerInformationLength,
-                                         ReturnLength,
-                                         PreviousMode);
-    if(!NT_SUCCESS(Status))
-    {
-        DPRINT1("NtQueryTimer() failed, Status: 0x%x\n", Status);
-        return Status;
-    }
-
-    /* Get the Timer Object */
-    Status = ObReferenceObjectByHandle(TimerHandle,
-                                       TIMER_QUERY_STATE,
-                                       ExTimerType,
-                                       PreviousMode,
-                                       (PVOID*)&Timer,
-                                       NULL);
-
-    /* Check for Success */
-    if(NT_SUCCESS(Status))
-    {
-        /* Return the Basic Information */
-        _SEH_TRY
-        {
-            /* Return the remaining time, corrected */
-            BasicInfo->TimeRemaining.QuadPart = Timer->KeTimer.DueTime.QuadPart -
-                                                KeQueryInterruptTime();
-
-            /* Return the current state */
-            BasicInfo->SignalState = KeReadStateTimer(&Timer->KeTimer);
-
-            /* Return the buffer length if requested */
-            if(ReturnLength != NULL) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
-
-            DPRINT("Returning Information for Timer: 0x%p. Time Remaining: %I64x\n",
-                    Timer, BasicInfo->TimeRemaining.QuadPart);
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        /* Dereference Object */
-        ObDereferenceObject(Timer);
-    }
-
-    /* Return Status */
-    return Status;
-}
-
-NTSTATUS
-STDCALL
-NtSetTimer(IN HANDLE TimerHandle,
-           IN PLARGE_INTEGER DueTime,
-           IN PTIMER_APC_ROUTINE TimerApcRoutine OPTIONAL,
-           IN PVOID TimerContext OPTIONAL,
-           IN BOOLEAN WakeTimer,
-           IN LONG Period OPTIONAL,
-           OUT PBOOLEAN PreviousState OPTIONAL)
-{
-    PETIMER Timer;
-    KIRQL OldIrql;
-    BOOLEAN State;
-    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
-    PETHREAD CurrentThread = PsGetCurrentThread();
-    LARGE_INTEGER TimerDueTime;
-    PETHREAD TimerThread;
-    BOOLEAN KillTimer = FALSE;
-    NTSTATUS Status = STATUS_SUCCESS;
-    PAGED_CODE();
-    DPRINT("NtSetTimer(TimerHandle: 0x%p, DueTime: %I64x, Apc: 0x%p, Period: %d)\n",
-            TimerHandle, DueTime->QuadPart, TimerApcRoutine, Period);
-
-    /* Check Parameter Validity */
-    if (PreviousMode != KernelMode)
-    {
-        _SEH_TRY
-        {
-            TimerDueTime = ProbeForReadLargeInteger(DueTime);
-
-            if(PreviousState)
-            {
-                ProbeForWriteBoolean(PreviousState);
-            }
-        }
-        _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-        {
-            Status = _SEH_GetExceptionCode();
-        }
-        _SEH_END;
-
-        if(!NT_SUCCESS(Status)) return Status;
-    }
-
-    /* Check for a valid Period */
-    if (Period < 0)
-    {
-        DPRINT1("Invalid Period for timer\n");
-        return STATUS_INVALID_PARAMETER_6;
-    }
-
-    /* Get the Timer Object */
-    Status = ObReferenceObjectByHandle(TimerHandle,
-                                       TIMER_MODIFY_STATE,
-                                       ExTimerType,
-                                       PreviousMode,
-                                       (PVOID*)&Timer,
-                                       NULL);
-
-    /* 
-     * Tell the user we don't support Wake Timers...
-     * when we have the ability to use/detect the Power Management 
-     * functionatliy required to support them, make this check dependent
-     * on the actual PM capabilities
-     */
-    if (WakeTimer) Status = STATUS_TIMER_RESUME_IGNORED;
-
-    /* Check status */
-    if (NT_SUCCESS(Status))
-    {
-        /* Lock the Timer */
-        DPRINT("Timer Referencced: 0x%p\n", Timer);
-        KeAcquireSpinLock(&Timer->Lock, &OldIrql);
-
-        /* Cancel Running Timer */
-        if (Timer->ApcAssociated)
-        {
-            /*
-             * First, remove it from the Thread's Active List
-             * Get the Thread.
-             */
-            TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread, ETHREAD, Tcb);
-            DPRINT("Thread already running. Removing from Thread: 0x%p\n", TimerThread);
-
-            /* Lock its active list */
-            KeAcquireSpinLockAtDpcLevel(&TimerThread->ActiveTimerListLock);
-
-            /* Remove it */
-            RemoveEntryList(&TimerThread->ActiveTimerListHead);
-
-            /* Unlock the list */
-            KeReleaseSpinLockFromDpcLevel(&TimerThread->ActiveTimerListLock);
-
-            /* Cancel the Timer */
-            KeCancelTimer(&Timer->KeTimer);
-            KeRemoveQueueDpc(&Timer->TimerDpc);
-            KeRemoveQueueApc(&Timer->TimerApc);
-            Timer->ApcAssociated = FALSE;
-            KillTimer = TRUE;
-
-        } else {
-
-            /* If timer was disabled, we still need to cancel it */
-            DPRINT("No APCs. Simply cancelling\n");
-            KeCancelTimer(&Timer->KeTimer);
-        }
-
-        /* Read the State */
-        State = KeReadStateTimer(&Timer->KeTimer);
-
-        /* Handle Wake Timers */
-        DPRINT("Doing Wake Semantics\n");
-        KeAcquireSpinLockAtDpcLevel(&ExpWakeListLock);
-        if (WakeTimer && !Timer->WakeTimer)
-        {
-            /* Insert it into the list */
-            Timer->WakeTimer = TRUE;
-            InsertTailList(&ExpWakeList, &Timer->WakeTimerListEntry);
-        }
-        else if (!WakeTimer && Timer->WakeTimer)
-        {
-            /* Remove it from the list */
-            RemoveEntryList(&Timer->WakeTimerListEntry);
-            Timer->WakeTimer = FALSE;
-        }
-        KeReleaseSpinLockFromDpcLevel(&ExpWakeListLock);
-
-        /* Set up the APC Routine if specified */
-        if (TimerApcRoutine)
-        {
-            /* Initialize the APC */
-            DPRINT("Initializing APC: 0x%p\n", Timer->TimerApc);
-            KeInitializeApc(&Timer->TimerApc,
-                            &CurrentThread->Tcb,
-                            CurrentApcEnvironment,
-                            &ExpTimerApcKernelRoutine,
-                            (PKRUNDOWN_ROUTINE)NULL,
-                            (PKNORMAL_ROUTINE)TimerApcRoutine,
-                            PreviousMode,
-                            TimerContext);
-
-            /* Lock the Thread's Active List and Insert */
-            KeAcquireSpinLockAtDpcLevel(&CurrentThread->ActiveTimerListLock);
-            InsertTailList(&CurrentThread->ActiveTimerListHead,
-                           &Timer->ActiveTimerListEntry);
-            KeReleaseSpinLockFromDpcLevel(&CurrentThread->ActiveTimerListLock);
-
-         }
-
-        /* Enable and Set the Timer */
-        DPRINT("Setting Kernel Timer\n");
-        KeSetTimerEx(&Timer->KeTimer,
-                     TimerDueTime,
-                     Period,
-                     TimerApcRoutine ? &Timer->TimerDpc : 0);
-        Timer->ApcAssociated = TimerApcRoutine ? TRUE : FALSE;
-
-        /* Unlock the Timer */
-        KeReleaseSpinLock(&Timer->Lock, OldIrql);
-
-        /* Dereference if it was previously enabled */
-        if (!TimerApcRoutine) ObDereferenceObject(Timer);
-        if (KillTimer) ObDereferenceObject(Timer);
-        DPRINT("Finished Setting the Timer\n");
-
-        /* Make sure it's safe to write to the handle */
-        if(PreviousState != NULL)
-        {
-            _SEH_TRY
-            {
-                *PreviousState = State;
-            }
-            _SEH_EXCEPT(_SEH_ExSystemExceptionFilter)
-            {
-                Status = _SEH_GetExceptionCode();
-            }
-            _SEH_END;
-        }
-    }
-
-    /* Return to Caller */
-    return Status;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/uuid.c
+++ b/reactos/ntoskrnl/ex/uuid.c
@@ -1,308 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/uuid.c
- * PURPOSE:         UUID generator
- *
- * PROGRAMMERS:     Eric Kohl
-                    Thomas Weidenmueller
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#define SEED_BUFFER_SIZE 6
-
-/* Number of 100ns ticks per clock tick. To be safe, assume that the clock
-   resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
-#define TICKS_PER_CLOCK_TICK 1000
-#define SECSPERDAY  86400
-#define TICKSPERSEC 10000000
-
-/* UUID system time starts at October 15, 1582 */
-#define SECS_15_OCT_1582_TO_1601  ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
-#define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitUuids)
-#endif
-
-
-/* GLOBALS ****************************************************************/
-
-static FAST_MUTEX UuidMutex;
-static ULARGE_INTEGER UuidLastTime;
-static ULONG UuidSequence;
-static BOOLEAN UuidSequenceInitialized = FALSE;
-static BOOLEAN UuidSequenceChanged = FALSE;
-static UCHAR UuidSeed[SEED_BUFFER_SIZE];
-static ULONG UuidCount;
-
-
-
-/* FUNCTIONS ****************************************************************/
-
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitUuids(VOID)
-{
-    ExInitializeFastMutex(&UuidMutex);
-
-    KeQuerySystemTime((PLARGE_INTEGER)&UuidLastTime);
-    UuidLastTime.QuadPart += TICKS_15_OCT_1582_TO_1601;
-
-    UuidCount = TICKS_PER_CLOCK_TICK;
-    RtlZeroMemory(UuidSeed, SEED_BUFFER_SIZE);
-}
-
-
-#define VALUE_BUFFER_SIZE 256
-
-static NTSTATUS
-ExpLoadUuidSequence(PULONG Sequence)
-{
-    UCHAR ValueBuffer[VALUE_BUFFER_SIZE];
-    PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING Name;
-    HANDLE KeyHandle;
-    ULONG ValueLength;
-    NTSTATUS Status;
-
-    RtlInitUnicodeString(&Name,
-        L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &Name,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = ZwOpenKey(&KeyHandle,
-                       KEY_QUERY_VALUE,
-                       &ObjectAttributes);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
-        return Status;
-    }
-
-    RtlInitUnicodeString(&Name, L"UuidSequenceNumber");
-
-    ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
-    Status = ZwQueryValueKey(KeyHandle,
-                             &Name,
-                             KeyValuePartialInformation,
-                             ValueBuffer,
-                             VALUE_BUFFER_SIZE,
-                             &ValueLength);
-    ZwClose(KeyHandle);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT("ZwQueryValueKey() failed (Status %lx)\n", Status);
-        return Status;
-    }
-
-    *Sequence = *((PULONG)ValueInfo->Data);
-
-    DPRINT("Loaded sequence %lx\n", *Sequence);
-
-    return STATUS_SUCCESS;
-}
-#undef VALUE_BUFFER_SIZE
-
-
-static NTSTATUS
-ExpSaveUuidSequence(PULONG Sequence)
-{
-    OBJECT_ATTRIBUTES ObjectAttributes;
-    UNICODE_STRING Name;
-    HANDLE KeyHandle;
-    NTSTATUS Status;
-
-    RtlInitUnicodeString(&Name,
-        L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
-    InitializeObjectAttributes(&ObjectAttributes,
-                               &Name,
-                               OBJ_CASE_INSENSITIVE,
-                               NULL,
-                               NULL);
-    Status = ZwOpenKey(&KeyHandle,
-                       KEY_SET_VALUE,
-                       &ObjectAttributes);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
-        return Status;
-    }
-
-    RtlInitUnicodeString(&Name, L"UuidSequenceNumber");
-    Status = ZwSetValueKey(KeyHandle,
-                           &Name,
-                           0,
-                           REG_DWORD,
-                           Sequence,
-                           sizeof(ULONG));
-    ZwClose(KeyHandle);
-    if (!NT_SUCCESS(Status))
-    {
-        DPRINT("ZwSetValueKey() failed (Status %lx)\n", Status);
-    }
-
-    return Status;
-}
-
-
-static VOID
-ExpGetRandomUuidSequence(PULONG Sequence)
-{
-    LARGE_INTEGER Counter;
-    LARGE_INTEGER Frequency;
-    ULONG Value;
-
-    Counter = KeQueryPerformanceCounter(&Frequency);
-    Value = Counter.u.LowPart ^ Counter.u.HighPart;
-
-    *Sequence = *Sequence ^ Value;
-
-    DPRINT("Sequence %lx\n", *Sequence);
-}
-
-
-static NTSTATUS
-ExpCreateUuids(PULARGE_INTEGER Time,
-               PULONG Range,
-               PULONG Sequence)
-{
-    /*
-    * Generate time element of the UUID. Account for going faster
-    * than our clock as well as the clock going backwards.
-    */
-    while (1)
-    {
-        KeQuerySystemTime((PLARGE_INTEGER)Time);
-        Time->QuadPart += TICKS_15_OCT_1582_TO_1601;
-
-        if (Time->QuadPart > UuidLastTime.QuadPart)
-        {
-            UuidCount = 0;
-            break;
-        }
-
-        if (Time->QuadPart < UuidLastTime.QuadPart)
-        {
-            (*Sequence)++;
-            UuidSequenceChanged = TRUE;
-            UuidCount = 0;
-            break;
-        }
-
-        if (UuidCount < TICKS_PER_CLOCK_TICK)
-        {
-            UuidCount++;
-            break;
-        }
-    }
-
-    UuidLastTime.QuadPart = Time->QuadPart;
-    Time->QuadPart += UuidCount;
-
-    *Range = 10000; /* What does this mean? Ticks per millisecond?*/
-
-    return STATUS_SUCCESS;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-ExUuidCreate(OUT UUID *Uuid)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-NtAllocateUuids(OUT PULARGE_INTEGER Time,
-                OUT PULONG Range,
-                OUT PULONG Sequence,
-                OUT PUCHAR Seed)
-{
-    ULARGE_INTEGER IntTime;
-    ULONG IntRange;
-    NTSTATUS Status;
-
-    PAGED_CODE();
-
-    ExAcquireFastMutex(&UuidMutex);
-
-    if (!UuidSequenceInitialized)
-    {
-        Status = ExpLoadUuidSequence(&UuidSequence);
-        if (NT_SUCCESS(Status))
-        {
-            UuidSequence++;
-        }
-        else
-        {
-            ExpGetRandomUuidSequence(&UuidSequence);
-        }
-
-        UuidSequenceInitialized = TRUE;
-        UuidSequenceChanged = TRUE;
-    }
-
-    Status = ExpCreateUuids(&IntTime,
-                            &IntRange,
-                            &UuidSequence);
-    if (!NT_SUCCESS(Status))
-    {
-        ExReleaseFastMutex(&UuidMutex);
-        return Status;
-    }
-
-    if (UuidSequenceChanged)
-    {
-        Status = ExpSaveUuidSequence(&UuidSequence);
-        if (NT_SUCCESS(Status))
-            UuidSequenceChanged = FALSE;
-    }
-
-    ExReleaseFastMutex(&UuidMutex);
-
-    Time->QuadPart = IntTime.QuadPart;
-    *Range = IntRange;
-    *Sequence = UuidSequence;
-
-    RtlCopyMemory(Seed,
-                  UuidSeed,
-                  SEED_BUFFER_SIZE);
-
-    return STATUS_SUCCESS;
-}
-
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-NtSetUuidSeed(IN PUCHAR Seed)
-{
-    PAGED_CODE();
-
-    RtlCopyMemory(UuidSeed,
-                  Seed,
-                  SEED_BUFFER_SIZE);
-    return STATUS_SUCCESS;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/win32k.c
+++ b/reactos/ntoskrnl/ex/win32k.c
@@ -1,133 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/ex/win32k.c
- * PURPOSE:         Executive Win32 Object Support (Desktop/WinStation)
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpWin32kInit)
-#endif
-
-/* DATA **********************************************************************/
-
-POBJECT_TYPE ExWindowStationObjectType = NULL;
-POBJECT_TYPE ExDesktopObjectType = NULL;
-
-GENERIC_MAPPING ExpWindowStationMapping = 
-{
-    STANDARD_RIGHTS_READ,
-    STANDARD_RIGHTS_WRITE,
-    STANDARD_RIGHTS_EXECUTE,
-    STANDARD_RIGHTS_REQUIRED
-};
-
-GENERIC_MAPPING ExpDesktopMapping =
-{
-    STANDARD_RIGHTS_READ,
-    STANDARD_RIGHTS_WRITE,
-    STANDARD_RIGHTS_EXECUTE,
-    STANDARD_RIGHTS_REQUIRED
-};
-
-PKWIN32_PARSEMETHOD_CALLOUT ExpWindowStationObjectParse = NULL;
-PKWIN32_DELETEMETHOD_CALLOUT ExpWindowStationObjectDelete = NULL;
-PKWIN32_DELETEMETHOD_CALLOUT ExpDesktopObjectDelete = NULL;
-
-/* FUNCTIONS ****************************************************************/
-
-VOID
-STDCALL
-ExpWinStaObjectDelete(PVOID DeletedObject)
-{
-    WIN32_DELETEMETHOD_PARAMETERS Parameters;
-
-    /* Fill out the callback structure */
-    Parameters.Object = DeletedObject;
-
-    /* Call the Registered Callback */
-    ExpWindowStationObjectDelete(&Parameters);
-}
-
-NTSTATUS
-STDCALL
-ExpWinStaObjectParse(IN PVOID ParseObject,
-                     IN PVOID ObjectType,
-                     IN OUT PACCESS_STATE AccessState,
-                     IN KPROCESSOR_MODE AccessMode,
-                     IN ULONG Attributes,
-                     IN OUT PUNICODE_STRING CompleteName,
-                     IN OUT PUNICODE_STRING RemainingName,
-                     IN OUT PVOID Context OPTIONAL,
-                     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
-                     OUT PVOID *Object)
-{
-    WIN32_PARSEMETHOD_PARAMETERS Parameters;
-
-    /* Fill out the callback structure */
-    Parameters.ParseObject = ParseObject;
-    Parameters.ObjectType = ObjectType;
-    Parameters.AccessState = AccessState;
-    Parameters.AccessMode = AccessMode;
-    Parameters.Attributes = Attributes;
-    Parameters.CompleteName = CompleteName;
-    Parameters.RemainingName = RemainingName;
-    Parameters.Context = Context;
-    Parameters.SecurityQos = SecurityQos;
-    Parameters.Object = Object;
-
-    /* Call the Registered Callback */
-    return ExpWindowStationObjectParse(&Parameters);
-}
-VOID
-STDCALL
-ExpDesktopDelete(PVOID DeletedObject)
-{
-    WIN32_DELETEMETHOD_PARAMETERS Parameters;
-
-    /* Fill out the callback structure */
-    Parameters.Object = DeletedObject;
-
-    /* Call the Registered Callback */
-    ExpDesktopObjectDelete(&Parameters);
-}
-
-VOID
-INIT_FUNCTION
-STDCALL
-ExpWin32kInit(VOID)
-{
-    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
-    UNICODE_STRING Name;
-    DPRINT("Creating Win32 Object Types\n");
-
-    /* Create the window station Object Type */
-    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
-    RtlInitUnicodeString(&Name, L"WindowStation");
-    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
-    ObjectTypeInitializer.GenericMapping = ExpWindowStationMapping;
-    ObjectTypeInitializer.PoolType = NonPagedPool;
-    ObjectTypeInitializer.DeleteProcedure = ExpWinStaObjectDelete;
-    ObjectTypeInitializer.ParseProcedure = ExpWinStaObjectParse;
-    ObCreateObjectType(&Name,
-                       &ObjectTypeInitializer,
-                       NULL,
-                       &ExWindowStationObjectType);
-
-    /* Create desktop object type */
-    RtlInitUnicodeString(&Name, L"Desktop");
-    ObjectTypeInitializer.GenericMapping = ExpDesktopMapping;
-    ObjectTypeInitializer.DeleteProcedure = ExpDesktopDelete;
-    ObjectTypeInitializer.ParseProcedure = NULL;
-    ObCreateObjectType(&Name,
-                       &ObjectTypeInitializer,
-                       NULL,
-                       &ExDesktopObjectType);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/ex/work.c
+++ b/reactos/ntoskrnl/ex/work.c
@@ -1,664 +0,0 @@
-/*
- * COPYRIGHT:          See COPYING in the top level directory
- * PROJECT:            ReactOS Kernel
- * FILE:               ntoskrnl/ex/work.c
- * PURPOSE:            Manage system work queues and worker threads
- * PROGRAMMER:         Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpInitializeWorkerThreads)
-#endif
-
-/* DATA **********************************************************************/
-
-/* Number of worker threads for each Queue */
-#define EX_HYPERCRITICAL_WORK_THREADS               1
-#define EX_DELAYED_WORK_THREADS                     3
-#define EX_CRITICAL_WORK_THREADS                    5
-
-/* Magic flag for dynamic worker threads */
-#define EX_DYNAMIC_WORK_THREAD                      0x80000000
-
-/* Worker thread priority increments (added to base priority) */
-#define EX_HYPERCRITICAL_QUEUE_PRIORITY_INCREMENT   7
-#define EX_CRITICAL_QUEUE_PRIORITY_INCREMENT        5
-#define EX_DELAYED_QUEUE_PRIORITY_INCREMENT         4
-
-/* The actual worker queue array */
-EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue];
-
-/* Accounting of the total threads and registry hacked threads */
-ULONG ExpCriticalWorkerThreads;
-ULONG ExpDelayedWorkerThreads;
-ULONG ExpAdditionalCriticalWorkerThreads;
-ULONG ExpAdditionalDelayedWorkerThreads;
-
-/* Future support for stack swapping worker threads */
-BOOLEAN ExpWorkersCanSwap;
-LIST_ENTRY ExpWorkerListHead;
-KMUTANT ExpWorkerSwapinMutex;
-
-/* The worker balance set manager events */
-KEVENT ExpThreadSetManagerEvent;
-KEVENT ExpThreadSetManagerShutdownEvent;
-
-/* Thread pointers for future worker thread shutdown support */
-PETHREAD ExpWorkerThreadBalanceManagerPtr;
-PETHREAD ExpLastWorkerThread;
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-/*++
- * @name ExpWorkerThreadEntryPoint
- *
- *     The ExpWorkerThreadEntryPoint routine is the entrypoint for any new
- *     worker thread created by teh system.
- *
- * @param Context
- *        Contains the work queue type masked with a flag specifing whether the
- *        thread is dynamic or not.
- *
- * @return None.
- *
- * @remarks A dynamic thread can timeout after 10 minutes of waiting on a queue
- *          while a static thread will never timeout.
- *
- *          Worker threads must return at IRQL == PASSIVE_LEVEL, must not have
- *          active impersonation info, and must not have disabled APCs.
- *
- *          NB: We will re-enable APCs for broken threads but all other cases
- *              will generate a bugcheck.
- *
- *--*/
-VOID
-NTAPI
-ExpWorkerThreadEntryPoint(IN PVOID Context)
-{
-    PWORK_QUEUE_ITEM WorkItem;
-    PLIST_ENTRY QueueEntry;
-    WORK_QUEUE_TYPE WorkQueueType;
-    PEX_WORK_QUEUE WorkQueue;
-    LARGE_INTEGER Timeout;
-    PLARGE_INTEGER TimeoutPointer = NULL;
-    PETHREAD Thread = PsGetCurrentThread();
-    KPROCESSOR_MODE WaitMode;
-    EX_QUEUE_WORKER_INFO OldValue, NewValue;
-
-    /* Check if this is a dyamic thread */
-    if ((ULONG_PTR)Context & EX_DYNAMIC_WORK_THREAD)
-    {
-        /* It is, which means we will eventually time out after 10 minutes */
-        Timeout.QuadPart = Int32x32To64(10, -10000000 * 60);
-        TimeoutPointer = &Timeout;
-    }
-
-    /* Get Queue Type and Worker Queue */
-    WorkQueueType = (WORK_QUEUE_TYPE)((ULONG_PTR)Context &
-                                      ~EX_DYNAMIC_WORK_THREAD);
-    WorkQueue = &ExWorkerQueue[WorkQueueType];
-
-    /* Select the wait mode */
-    WaitMode = (UCHAR)WorkQueue->Info.WaitMode;
-
-    /* Nobody should have initialized this yet, do it now */
-    ASSERT(Thread->ExWorkerCanWaitUser == 0);
-    if (WaitMode == UserMode) Thread->ExWorkerCanWaitUser = TRUE;
-
-    /* If we shouldn't swap, disable that feature */
-    if (!ExpWorkersCanSwap) KeSetKernelStackSwapEnable(FALSE);
-
-    /* Set the worker flags */
-    do
-    {
-        /* Check if the queue is being disabled */
-        if (WorkQueue->Info.QueueDisabled)
-        {
-            /* Re-enable stack swapping and kill us */
-            KeSetKernelStackSwapEnable(TRUE);
-            PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN);
-        }
-
-        /* Increase the worker count */
-        OldValue = WorkQueue->Info;
-        NewValue = OldValue;
-        NewValue.WorkerCount++;
-    }
-    while (InterlockedCompareExchange((PLONG)&WorkQueue->Info,
-                                      *(PLONG)&NewValue,
-                                      *(PLONG)&OldValue) != *(PLONG)&OldValue);
-
-    /* Success, you are now officially a worker thread! */
-    Thread->ActiveExWorker = TRUE;
-
-    /* Loop forever */
-ProcessLoop:
-    for (;;)
-    {
-        /* Wait for Something to Happen on the Queue */
-        QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue,
-                                   WaitMode,
-                                   TimeoutPointer);
-
-        /* Check if we timed out and quit this loop in that case */
-        if ((NTSTATUS)QueueEntry == STATUS_TIMEOUT) break;
-
-        /* Increment Processed Work Items */
-        InterlockedIncrement((PLONG)&WorkQueue->WorkItemsProcessed);
-
-        /* Get the Work Item */
-        WorkItem = CONTAINING_RECORD(QueueEntry, WORK_QUEUE_ITEM, List);
-
-        /* Make sure nobody is trying to play smart with us */
-        ASSERT((ULONG_PTR)WorkItem->WorkerRoutine > MmUserProbeAddress);
-
-        /* Call the Worker Routine */
-        WorkItem->WorkerRoutine(WorkItem->Parameter);
-
-        /* Make sure APCs are not disabled */
-        if (Thread->Tcb.SpecialApcDisable)
-        {
-            /* We're nice and do it behind your back */
-            DPRINT1("Warning: Broken Worker Thread: %p %lx %p came back "
-                    "with APCs disabled!\n",
-                    WorkItem->WorkerRoutine,
-                    WorkItem->Parameter,
-                    WorkItem);
-            Thread->Tcb.SpecialApcDisable = 0;
-        }
-
-        /* Make sure it returned at right IRQL */
-        if (KeGetCurrentIrql() != PASSIVE_LEVEL)
-        {
-            /* It didn't, bugcheck! */
-            KEBUGCHECKEX(WORKER_THREAD_RETURNED_AT_BAD_IRQL,
-                         (ULONG_PTR)WorkItem->WorkerRoutine,
-                         KeGetCurrentIrql(),
-                         (ULONG_PTR)WorkItem->Parameter,
-                         (ULONG_PTR)WorkItem);
-        }
-
-        /* Make sure it returned with Impersionation Disabled */
-        if (Thread->ActiveImpersonationInfo)
-        {
-            /* It didn't, bugcheck! */
-            KEBUGCHECKEX(IMPERSONATING_WORKER_THREAD,
-                         (ULONG_PTR)WorkItem->WorkerRoutine,
-                         (ULONG_PTR)WorkItem->Parameter,
-                         (ULONG_PTR)WorkItem,
-                         0);
-        }
-    }
-
-    /* This is a dynamic thread. Terminate it unless IRPs are pending */
-    if (!IsListEmpty(&Thread->IrpList)) goto ProcessLoop;
-
-    /* Don't terminate it if the queue is disabled either */
-    if (WorkQueue->Info.QueueDisabled) goto ProcessLoop;
-
-    /* Set the worker flags */
-    do
-    {
-        /* Decrease the worker count */
-        OldValue = WorkQueue->Info;
-        NewValue = OldValue;
-        NewValue.WorkerCount--;
-    }
-    while (InterlockedCompareExchange((PLONG)&WorkQueue->Info,
-                                      *(PLONG)&NewValue,
-                                      *(PLONG)&OldValue) != *(PLONG)&OldValue);
-
-    /* Decrement dynamic thread count */
-    InterlockedDecrement(&WorkQueue->DynamicThreadCount);
-
-    /* We're not a worker thread anymore */
-    Thread->ActiveExWorker = FALSE;
-
-    /* Re-enable the stack swap */
-    KeSetKernelStackSwapEnable(TRUE);
-    return;
-}
-
-/*++
- * @name ExpCreateWorkerThread
- *
- *     The ExpCreateWorkerThread routine creates a new worker thread for the
- *     specified queue.
- **
- * @param QueueType
- *        Type of the queue to use for this thread. Valid values are:
- *          - DelayedWorkQueue
- *          - CriticalWorkQueue
- *          - HyperCriticalWorkQueue
- *
- * @param Dynamic
- *        Specifies whether or not this thread is a dynamic thread.
- *
- * @return None.
- *
- * @remarks HyperCritical work threads run at priority 7; Critical work threads
- *          run at priority 5, and delayed work threads run at priority 4.
- *
- *          This, worker threads cannot pre-empty a normal user-mode thread.
- *
- *--*/
-VOID
-NTAPI
-ExpCreateWorkerThread(WORK_QUEUE_TYPE WorkQueueType,
-                      IN BOOLEAN Dynamic)
-{
-    PETHREAD Thread;
-    HANDLE hThread;
-    ULONG Context;
-    KPRIORITY Priority;
-
-    /* Check if this is going to be a dynamic thread */
-    Context = WorkQueueType;
-
-    /* Add the dynamic mask */
-    if (Dynamic) Context |= EX_DYNAMIC_WORK_THREAD;
-
-    /* Create the System Thread */
-    PsCreateSystemThread(&hThread,
-                         THREAD_ALL_ACCESS,
-                         NULL,
-                         NULL,
-                         NULL,
-                         ExpWorkerThreadEntryPoint,
-                         (PVOID)Context);
-
-    /* If the thread is dynamic */
-    if (Dynamic)
-    {
-        /* Increase the count */
-        InterlockedIncrement(&ExWorkerQueue[WorkQueueType].DynamicThreadCount);
-    }
-
-    /* Set the priority */
-    if (WorkQueueType == DelayedWorkQueue)
-    {
-        /* Priority == 4 */
-        Priority = EX_DELAYED_QUEUE_PRIORITY_INCREMENT;
-    }
-    else if (WorkQueueType == CriticalWorkQueue)
-    {
-        /* Priority == 5 */
-        Priority = EX_CRITICAL_QUEUE_PRIORITY_INCREMENT;
-    }
-    else
-    {
-        /* Priority == 7 */
-        Priority = EX_HYPERCRITICAL_QUEUE_PRIORITY_INCREMENT;
-    }
-
-    /* Get the Thread */
-    ObReferenceObjectByHandle(hThread,
-                              THREAD_SET_INFORMATION,
-                              PsThreadType,
-                              KernelMode,
-                              (PVOID*)&Thread,
-                              NULL);
-
-    /* Set the Priority */
-    KeSetBasePriorityThread(&Thread->Tcb, Priority);
-
-    /* Dereference and close handle */
-    ObDereferenceObject(Thread);
-    ZwClose(hThread);
-}
-
-/*++
- * @name ExpCheckDynamicThreadCount
- *
- *     The ExpCheckDynamicThreadCount routine checks every queue and creates a
- *     dynamic thread if the queue seems to be deadlocked.
- *
- * @param None
- *
- * @return None.
- *
- * @remarks The algorithm for deciding if a new thread must be created is
- *          based on wether the queue has processed no new items in the last
- *          second, and new items are still enqueued.
- *
- *--*/
-VOID
-NTAPI
-ExpDetectWorkerThreadDeadlock(VOID)
-{
-    ULONG i;
-    PEX_WORK_QUEUE Queue;
-
-    /* Loop the 3 queues */
-    for (i = 0; i < MaximumWorkQueue; i++)
-    {
-        /* Get the queue */
-        Queue = &ExWorkerQueue[i];
-        ASSERT(Queue->DynamicThreadCount <= 16);
-
-        /* Check if stuff is on the queue that still is unprocessed */
-        if ((Queue->QueueDepthLastPass) &&
-            (Queue->WorkItemsProcessed == Queue->WorkItemsProcessedLastPass) &&
-            (Queue->DynamicThreadCount < 16))
-        {
-            /* Stuff is still on the queue and nobody did anything about it */
-            DPRINT1("EX: Work Queue Deadlock detected: %d\n", i);
-            ExpCreateWorkerThread(i, TRUE);
-            DPRINT1("Dynamic threads queued %d\n", Queue->DynamicThreadCount);
-        }
-
-        /* Update our data */
-        Queue->WorkItemsProcessedLastPass = Queue->WorkItemsProcessed;
-        Queue->QueueDepthLastPass = KeReadStateQueue(&Queue->WorkerQueue);
-    }
-}
-
-/*++
- * @name ExpCheckDynamicThreadCount
- *
- *     The ExpCheckDynamicThreadCount routine checks every queue and creates a
- *     dynamic thread if the queue requires one.
- *
- * @param None
- *
- * @return None.
- *
- * @remarks The algorithm for deciding if a new thread must be created is
- *          documented in the ExQueueWorkItem routine.
- *
- *--*/
-VOID
-NTAPI
-ExpCheckDynamicThreadCount(VOID)
-{
-    ULONG i;
-    PEX_WORK_QUEUE Queue;
-
-    /* Loop the 3 queues */
-    for (i = 0; i < MaximumWorkQueue; i++)
-    {
-        /* Get the queue */
-        Queue = &ExWorkerQueue[i];
-
-        /* Check if still need a new thread. See ExQueueWorkItem */
-        if ((Queue->Info.MakeThreadsAsNecessary) &&
-            (!IsListEmpty(&Queue->WorkerQueue.EntryListHead)) &&
-            (Queue->WorkerQueue.CurrentCount <
-             Queue->WorkerQueue.MaximumCount) &&
-            (Queue->DynamicThreadCount < 16))
-        {
-            /* Create a new thread */
-            DPRINT1("EX: Creating new dynamic thread as requested\n");
-            ExpCreateWorkerThread(i, TRUE);
-        }
-    }
-}
-
-/*++
- * @name ExpWorkerThreadBalanceManager
- *
- *     The ExpWorkerThreadBalanceManager routine is the entrypoint for the
- *     worker thread balance set manager.
- *
- * @param Context
- *        Unused.
- *
- * @return None.
- *
- * @remarks The worker thread balance set manager listens every second, but can
- *          also be woken up by an event when a new thread is needed, or by the
- *          special shutdown event. This thread runs at priority 7.
- *
- *          This routine must run at IRQL == PASSIVE_LEVEL.
- *
- *--*/
-VOID
-NTAPI
-ExpWorkerThreadBalanceManager(IN PVOID Context)
-{
-    KTIMER Timer;
-    LARGE_INTEGER Timeout;
-    NTSTATUS Status;
-    PVOID WaitEvents[3];
-    PAGED_CODE();
-    UNREFERENCED_PARAMETER(Context);
-
-    /* Raise our priority above all other worker threads */
-    KeSetBasePriorityThread(KeGetCurrentThread(),
-                            EX_CRITICAL_QUEUE_PRIORITY_INCREMENT + 1);
-
-    /* Setup the timer */
-    KeInitializeTimer(&Timer);
-    Timeout.QuadPart = Int32x32To64(-1, 10000000);
-
-    /* We'll wait on the periodic timer and also the emergency event */
-    WaitEvents[0] = &Timer;
-    WaitEvents[1] = &ExpThreadSetManagerEvent;
-    WaitEvents[2] = &ExpThreadSetManagerShutdownEvent;
-
-    /* Start wait loop */
-    for (;;)
-    {
-        /* Wait for the timer */
-        KeSetTimer(&Timer, Timeout, NULL);
-        Status = KeWaitForMultipleObjects(3,
-                                          WaitEvents,
-                                          WaitAny,
-                                          Executive,
-                                          KernelMode,
-                                          FALSE,
-                                          NULL,
-                                          NULL);
-        if (Status == 0)
-        {
-            /* Our timer expired. Check for deadlocks */
-            ExpDetectWorkerThreadDeadlock();
-        }
-        else if (Status == 1)
-        {
-            /* Someone notified us, verify if we should create a new thread */
-            ExpCheckDynamicThreadCount();
-        }
-        else if (Status == 2)
-        {
-            /* We are shutting down. Cancel the timer */
-            DPRINT1("System shutdown\n");
-            KeCancelTimer(&Timer);
-
-            /* Make sure we have a final thread */
-            ASSERT(ExpLastWorkerThread);
-
-            /* Wait for it */
-            KeWaitForSingleObject(ExpLastWorkerThread,
-                                  Executive,
-                                  KernelMode,
-                                  FALSE,
-                                  NULL);
-
-            /* Dereference it and kill us */
-            ObDereferenceObject(ExpLastWorkerThread);
-            PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN);
-        }
-    }
-}
-
-/*++
- * @name ExpInitializeWorkerThreads
- *
- *     The ExpInitializeWorkerThreads routine initializes worker thread and
- *     work queue support.
- *
- * @param None.
- *
- * @return None.
- *
- * @remarks This routine is only called once during system initialization.
- *
- *--*/
-VOID
-INIT_FUNCTION
-NTAPI
-ExpInitializeWorkerThreads(VOID)
-{
-    ULONG WorkQueueType;
-    ULONG CriticalThreads, DelayedThreads;
-    HANDLE ThreadHandle;
-    PETHREAD Thread;
-    ULONG i;
-
-    /* Setup the stack swap support */
-    KeInitializeMutex(&ExpWorkerSwapinMutex, FALSE);
-    InitializeListHead(&ExpWorkerListHead);
-    ExpWorkersCanSwap = TRUE;
-
-    /* Set the number of critical and delayed threads. We shouldn't hardcode */
-    DelayedThreads = EX_DELAYED_WORK_THREADS;
-    CriticalThreads = EX_CRITICAL_WORK_THREADS;
-
-    /* Protect against greedy registry modifications */
-    ExpAdditionalDelayedWorkerThreads =
-        min(ExpAdditionalDelayedWorkerThreads, 16);
-    ExpAdditionalCriticalWorkerThreads =
-        min(ExpAdditionalCriticalWorkerThreads, 16);
-
-    /* Calculate final count */
-    DelayedThreads += ExpAdditionalDelayedWorkerThreads;
-    CriticalThreads += ExpAdditionalCriticalWorkerThreads;
-
-    /* Initialize the Array */
-    for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++)
-    {
-        /* Clear the structure and initialize the queue */
-        RtlZeroMemory(&ExWorkerQueue[WorkQueueType], sizeof(EX_WORK_QUEUE));
-        KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0);
-    }
-
-    /* Dynamic threads are only used for the critical queue */
-    ExWorkerQueue[CriticalWorkQueue].Info.MakeThreadsAsNecessary = TRUE;
-
-    /* Initialize the balance set manager events */
-    KeInitializeEvent(&ExpThreadSetManagerEvent, SynchronizationEvent, FALSE);
-    KeInitializeEvent(&ExpThreadSetManagerShutdownEvent,
-                      NotificationEvent,
-                      FALSE);
-
-    /* Create the built-in worker threads for the critical queue */
-    for (i = 0; i < CriticalThreads; i++)
-    {
-        /* Create the thread */
-        ExpCreateWorkerThread(CriticalWorkQueue, FALSE);
-        ExpCriticalWorkerThreads++;
-    }
-
-    /* Create the built-in worker threads for the delayed queue */
-    for (i = 0; i < DelayedThreads; i++)
-    {
-        /* Create the thread */
-        ExpCreateWorkerThread(DelayedWorkQueue, FALSE);
-        ExpDelayedWorkerThreads++;
-    }
-
-    /* Create the built-in worker thread for the hypercritical queue */
-    ExpCreateWorkerThread(HyperCriticalWorkQueue, FALSE);
-
-    /* Create the balance set manager thread */
-    PsCreateSystemThread(&ThreadHandle,
-                         THREAD_ALL_ACCESS,
-                         NULL,
-                         0,
-                         NULL,
-                         ExpWorkerThreadBalanceManager,
-                         NULL);
-
-    /* Get a pointer to it for the shutdown process */
-    ObReferenceObjectByHandle(ThreadHandle,
-                              THREAD_ALL_ACCESS,
-                              NULL,
-                              KernelMode,
-                              (PVOID*)&Thread,
-                              NULL);
-    ExpWorkerThreadBalanceManagerPtr = Thread;
-
-    /* Close the handle and return */
-    ZwClose(ThreadHandle);
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-/*++
- * @name ExQueueWorkItem
- * @implemented NT4
- *
- *     The ExQueueWorkItem routine acquires rundown protection for
- *     the specified descriptor.
- *
- * @param WorkItem
- *        Pointer to an initialized Work Queue Item structure. This structure
- *        must be located in nonpaged pool memory.
- *
- * @param QueueType
- *        Type of the queue to use for this item. Can be one of the following:
- *          - DelayedWorkQueue
- *          - CriticalWorkQueue
- *          - HyperCriticalWorkQueue
- *
- * @return None.
- *
- * @remarks This routine is obsolete. Use IoQueueWorkItem instead.
- *
- *          Callers of this routine must be running at IRQL <= DISPATCH_LEVEL.
- *
- *--*/
-VOID
-NTAPI
-ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem,
-                WORK_QUEUE_TYPE QueueType)
-{
-    PEX_WORK_QUEUE WorkQueue = &ExWorkerQueue[QueueType];
-    ASSERT(QueueType < MaximumWorkQueue);
-    ASSERT(WorkItem->List.Flink == NULL);
-
-    /* Don't try to trick us */
-    if ((ULONG_PTR)WorkItem->WorkerRoutine < MmUserProbeAddress)
-    {
-        /* Bugcheck the system */
-        KEBUGCHECKEX(WORKER_INVALID,
-                     1,
-                     (ULONG_PTR)WorkItem,
-                     (ULONG_PTR)WorkItem->WorkerRoutine,
-                     0);
-    }
-
-    /* Insert the Queue */
-    KeInsertQueue(&WorkQueue->WorkerQueue, &WorkItem->List);
-    ASSERT(!WorkQueue->Info.QueueDisabled);
-
-    /*
-     * Check if we need a new thread. Our decision is as follows:
-     *  - This queue type must support Dynamic Threads (duh!)
-     *  - It actually has to have unprocessed items
-     *  - We have CPUs which could be handling another thread
-     *  - We haven't abused our usage of dynamic threads.
-     */
-    if ((WorkQueue->Info.MakeThreadsAsNecessary) &&
-        (!IsListEmpty(&WorkQueue->WorkerQueue.EntryListHead)) &&
-        (WorkQueue->WorkerQueue.CurrentCount <
-         WorkQueue->WorkerQueue.MaximumCount) &&
-        (WorkQueue->DynamicThreadCount < 16))
-    {
-        /* Let the balance manager know about it */
-        DPRINT1("Requesting a new thread. CurrentCount: %d. MaxCount: %d\n",
-                WorkQueue->WorkerQueue.CurrentCount,
-                WorkQueue->WorkerQueue.MaximumCount);
-        KeSetEvent(&ExpThreadSetManagerEvent, 0, FALSE);
-    }
-}
-
-/* EOF */
-
--- a/reactos/ntoskrnl/ex/zone.c
+++ b/reactos/ntoskrnl/ex/zone.c
@@ -1,157 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ex/zone.c
- * PURPOSE:         Implements zone buffers
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  David Welch (welch@mcmail.com)
- */
-
-/* INCLUDES ****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <debug.h>
-
-/* FUNCTIONS ***************************************************************/
-
-/*
- * @implemented
- */
-NTSTATUS
-STDCALL
-ExExtendZone(PZONE_HEADER Zone,
-             PVOID Segment,
-             ULONG SegmentSize)
-{
-    ULONG_PTR Entry;
-    ULONG i;
-
-    /* 
-     * BlockSize and Segment must be 8-byte aligned.
-     * Blocksize cannot exceed Segment Size.
-     */
-    if (((ULONG_PTR)Segment & 7) ||
-        (SegmentSize & 7) ||
-        (Zone->BlockSize > SegmentSize))
-    {
-        DPRINT1("Invalid ExExtendZone Alignment and/or Size\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Link the Zone and Segment */
-    PushEntryList(&Zone->SegmentList,
-                  &((PZONE_SEGMENT_HEADER)Segment)->SegmentList);
-
-    /* Get to the first entry */
-    Entry = (ULONG_PTR)Segment + sizeof(ZONE_SEGMENT_HEADER);
-
-    /* Loop through the segments */
-    for (i = sizeof(ZONE_SEGMENT_HEADER);
-         i <= SegmentSize - Zone->BlockSize;
-         i+= Zone->BlockSize)
-    {
-        /* Link the Free and Segment Lists */
-        PushEntryList(&Zone->FreeList, (PSINGLE_LIST_ENTRY)Entry);
-
-        /* Go to the next entry */
-        Entry += Zone->BlockSize;
-    }
-
-    /* Update Segment Size */
-    Zone->TotalSegmentSize += i;
-
-    /* Return Success */
-    return STATUS_SUCCESS;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-STDCALL
-ExInterlockedExtendZone(PZONE_HEADER Zone,
-                        PVOID Segment,
-                        ULONG SegmentSize,
-                        PKSPIN_LOCK Lock)
-{
-    NTSTATUS Status;
-    KIRQL OldIrql;
-
-    /* Get the lock */
-    KeAcquireSpinLock(Lock, &OldIrql);
-
-    /* Extend the Zone */
-    Status = ExExtendZone(Zone, Segment, SegmentSize);
-
-    /* Release lock and return status */
-    KeReleaseSpinLock(Lock, OldIrql);
-    return Status;
-}
-
-/*
- * FUNCTION: Initalizes a zone header
- * ARGUMENTS:
- *          Zone = zone header to be initialized
- *          BlockSize = Size (in bytes) of the allocation size of the zone
- *          InitialSegment = Initial segment of storage allocated by the
- *                           caller
- *          InitialSegmentSize = Initial size of the segment
- *
- * @implemented
- */
-NTSTATUS
-STDCALL
-ExInitializeZone(PZONE_HEADER Zone,
-                 ULONG BlockSize,
-                 PVOID InitialSegment,
-                 ULONG InitialSegmentSize)
-{
-    ULONG i;
-    ULONG_PTR Entry;
-
-    /* 
-     * BlockSize and Segment must be 8-byte aligned.
-     * Blocksize cannot exceed Segment Size.
-     */
-    if (((ULONG_PTR)InitialSegment & 7) ||
-        (InitialSegmentSize & 7) ||
-        (BlockSize > InitialSegmentSize))
-    {
-        DPRINT1("Invalid ExInitializeZone Alignment and/or Size\n");
-        return STATUS_INVALID_PARAMETER;
-    }
-
-    /* Set the Zone Header */
-    Zone->BlockSize = BlockSize;
-
-    /* Link empty list */
-    Zone->FreeList.Next = NULL;
-    Zone->SegmentList.Next = NULL;
-    PushEntryList(&Zone->SegmentList,
-                  &((PZONE_SEGMENT_HEADER)InitialSegment)->SegmentList);
-    ((PZONE_SEGMENT_HEADER)InitialSegment)->Reserved = NULL;
-
-    /* Get first entry */
-    Entry = (ULONG_PTR)InitialSegment + sizeof(ZONE_SEGMENT_HEADER);
-
-    /* Loop through the segments */
-    for (i = sizeof(ZONE_SEGMENT_HEADER);
-         i <= InitialSegmentSize - BlockSize;
-         i+= BlockSize)
-    {
-        /* Link the Free and Segment Lists */
-        PushEntryList(&Zone->FreeList, (PSINGLE_LIST_ENTRY)Entry);
-
-        /* Go to the next entry */
-        Entry += Zone->BlockSize;
-    }
-
-    /* Update Segment Size */
-    Zone->TotalSegmentSize += i;
-
-    /* Return success */
-    return STATUS_SUCCESS;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/context.c
+++ b/reactos/ntoskrnl/fs/context.c
@@ -1,83 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/context.c
- * PURPOSE:         File and Stream Context Functions
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-/* PRIVATE FUNCTIONS**********************************************************/
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-FsRtlInsertPerStreamContext(IN PFSRTL_ADVANCED_FCB_HEADER PerStreamContext,
-                            IN PFSRTL_PER_STREAM_CONTEXT Ptr)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-PFSRTL_PER_STREAM_CONTEXT
-NTAPI
-FsRtlRemovePerStreamContext(IN PFSRTL_ADVANCED_FCB_HEADER StreamContext,
-                            IN PVOID OwnerId OPTIONAL,
-                            IN PVOID InstanceId OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return NULL;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-FsRtlInsertPerFileObjectContext(IN PFSRTL_ADVANCED_FCB_HEADER PerFileObjectContext,
-                                IN PVOID /* PFSRTL_PER_FILE_OBJECT_CONTEXT*/ Ptr)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-PVOID /* PFSRTL_PER_FILE_OBJECT_CONTEXT*/
-NTAPI
-FsRtlRemovePerFileObjectContext(IN PFSRTL_ADVANCED_FCB_HEADER PerFileObjectContext,
-                                IN PVOID OwnerId OPTIONAL,
-                                IN PVOID InstanceId OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return NULL;
-}
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlTeardownPerStreamContexts(IN PFSRTL_ADVANCED_FCB_HEADER AdvancedHeader)
-{
-    UNIMPLEMENTED;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/fastio.c
+++ b/reactos/ntoskrnl/fs/fastio.c
@@ -1,515 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Kernel
- * FILE:            ntoskrnl/fs/fastio.c
- * PURPOSE:         File System Routines which support Fast I/O or Cc Access.
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- */
-
-/* INCLUDES ****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-extern ULONG CcFastReadNotPossible;
-extern ULONG CcFastReadResourceMiss;
-extern ULONG CcFastReadWait;
-extern ULONG CcFastReadNoWait;
-
-/* FUNCTIONS *****************************************************************/
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-FsRtlIncrementCcFastReadResourceMiss( VOID )
-{
-    CcFastReadResourceMiss++;
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-FsRtlIncrementCcFastReadNotPossible( VOID )
-{
-    CcFastReadNotPossible++;
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-FsRtlIncrementCcFastReadWait( VOID )
-{
-    CcFastReadWait++;
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-FsRtlIncrementCcFastReadNoWait( VOID )
-{
-    CcFastReadNoWait++;
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlCopyRead@32
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * NOTE
- *  From Bo Branten's ntifs.h v12.
- *
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-FsRtlCopyRead(IN  PFILE_OBJECT FileObject,
-              IN  PLARGE_INTEGER FileOffset,
-              IN  ULONG Length,
-              IN  BOOLEAN Wait,
-              IN  ULONG LockKey,
-              OUT PVOID Buffer,
-              OUT PIO_STATUS_BLOCK IoStatus,
-              IN  PDEVICE_OBJECT DeviceObject)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlCopyWrite@32
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * NOTE
- *  From Bo Branten's ntifs.h v12.
- *
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-FsRtlCopyWrite(IN  PFILE_OBJECT FileObject,
-               IN  PLARGE_INTEGER FileOffset,
-               IN  ULONG Length,
-               IN  BOOLEAN Wait,
-               IN  ULONG LockKey,
-               OUT PVOID Buffer,
-               OUT PIO_STATUS_BLOCK IoStatus,
-               IN  PDEVICE_OBJECT DeviceObject)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlGetFileSize@8
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-NTSTATUS
-STDCALL
-FsRtlGetFileSize(IN PFILE_OBJECT  FileObject,
-                 IN OUT PLARGE_INTEGER FileSize)
-{
-    FILE_STANDARD_INFORMATION Info;
-    NTSTATUS Status;
-    IO_STATUS_BLOCK IoStatusBlock;
-    ULONG Length;
-    PDEVICE_OBJECT DeviceObject;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Device Object and Fast Calls */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->FastIoQueryStandardInfo)
-    {
-        /* Fast Path */
-        FastDispatch->FastIoQueryStandardInfo(FileObject,
-                                              TRUE,
-                                              &Info,
-                                              &IoStatusBlock,
-                                              DeviceObject);
-        Status = IoStatusBlock.Status;
-    }
-    else
-    {
-        /* Slow Path */
-        Status = IoQueryFileInformation(FileObject,
-                                        FileStandardInformation,
-                                        sizeof(Info),
-                                        &Info,
-                                        &Length);
-    }
-
-    /* Check success */
-    if (NT_SUCCESS(Status))
-    {
-        *FileSize = Info.EndOfFile;
-    }
-
-    /* Return status */
-    return Status;
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlMdlRead@24
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlRead(IN PFILE_OBJECT FileObject,
-             IN PLARGE_INTEGER FileOffset,
-             IN ULONG Length,
-             IN ULONG LockKey,
-             OUT PMDL *MdlChain,
-             OUT PIO_STATUS_BLOCK IoStatus)
-{
-    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Device Object and Fast Calls */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->MdlRead)
-    {
-        /* Use the fast path */
-        return FastDispatch->MdlRead(FileObject,
-                                     FileOffset,
-                                     Length,
-                                     LockKey,
-                                     MdlChain,
-                                     IoStatus,
-                                     DeviceObject);
-    }
-
-    /* Get the Base File System (Volume) and Fast Calls */
-    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
-    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
-
-    /* If the Base Device Object has its own FastDispatch Routine, fail */
-    if (FastDispatch && FastDispatch->MdlRead &&
-        BaseDeviceObject != DeviceObject)
-    {
-        return FALSE;
-    }
-
-    /* No fast path, use slow path */
-    return FsRtlMdlReadDev(FileObject,
-                           FileOffset,
-                           Length,
-                           LockKey,
-                           MdlChain,
-                           IoStatus,
-                           DeviceObject);
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlMdlReadComplete@8
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject,
-                     IN OUT PMDL MdlChain)
-{
-    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Device Object and Fast Calls */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->MdlReadComplete)
-    {
-        /* Use the fast path */
-        return FastDispatch->MdlReadComplete(FileObject,
-                                             MdlChain,
-                                             DeviceObject);
-    }
-
-    /* Get the Base File System (Volume) and Fast Calls */
-    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
-    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
-
-    /* If the Base Device Object has its own FastDispatch Routine, fail */
-    if (FastDispatch && FastDispatch->MdlReadComplete &&
-        BaseDeviceObject != DeviceObject)
-    {
-        return FALSE;
-    }
-
-    /* No fast path, use slow path */
-    return FsRtlMdlReadCompleteDev(FileObject, MdlChain, DeviceObject);
-}
-
-
-/*
- * NAME    EXPORTED
- * FsRtlMdlReadCompleteDev@12
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * NOTE
- * From Bo Branten's ntifs.h v13.
- * (CcMdlReadCompleteDev declared in internal/cc.h)
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlReadCompleteDev(IN PFILE_OBJECT FileObject,
-                        IN PMDL MdlChain,
-                        IN PDEVICE_OBJECT DeviceObject)
-{
-    /* Call the Cache Manager */
-    CcMdlReadCompleteDev(MdlChain, FileObject);
-    return TRUE;
-}
-
-/*
- * NAME    EXPORTED
- * FsRtlMdlReadDev@28
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlReadDev(IN PFILE_OBJECT FileObject,
-                IN PLARGE_INTEGER FileOffset,
-                IN ULONG Length,
-                IN ULONG LockKey,
-                OUT PMDL *MdlChain,
-                OUT PIO_STATUS_BLOCK IoStatus,
-                IN PDEVICE_OBJECT DeviceObject)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-
-/*
- * NAME    EXPORTED
- * FsRtlMdlWriteComplete@12
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlWriteComplete(IN PFILE_OBJECT FileObject,
-                      IN PLARGE_INTEGER FileOffset,
-                      IN PMDL MdlChain)
-{
-    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Device Object and Fast Calls */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->MdlWriteComplete)
-    {
-        /* Use the fast path */
-        return FastDispatch->MdlWriteComplete(FileObject,
-                                              FileOffset,
-                                              MdlChain,
-                                              DeviceObject);
-    }
-
-    /* Get the Base File System (Volume) and Fast Calls */
-    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
-    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
-
-    /* If the Base Device Object has its own FastDispatch Routine, fail */
-    if (FastDispatch && FastDispatch->MdlWriteComplete &&
-        BaseDeviceObject != DeviceObject)
-    {
-        return FALSE;
-    }
-
-    /* No fast path, use slow path */
-    return FsRtlMdlWriteCompleteDev(FileObject,
-                                    FileOffset,
-                                    MdlChain,
-                                    DeviceObject);
-}
-
-/*
- * NAME EXPORTED
- * FsRtlMdlWriteCompleteDev@16
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlMdlWriteCompleteDev(IN PFILE_OBJECT FileObject,
-                         IN PLARGE_INTEGER FileOffset,
-                         IN PMDL MdlChain,
-                         IN PDEVICE_OBJECT DeviceObject)
-{
-    /* Call the Cache Manager */
-    CcMdlWriteCompleteDev(FileOffset, MdlChain, FileObject);
-    return TRUE;
-}
-
-
-/*
- * NAME    EXPORTED
- * FsRtlPrepareMdlWrite@24
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @implemented
- */
-BOOLEAN
-STDCALL
-FsRtlPrepareMdlWrite(IN  PFILE_OBJECT FileObject,
-                     IN  PLARGE_INTEGER FileOffset,
-                     IN  ULONG Length,
-                     IN  ULONG LockKey,
-                     OUT PMDL *MdlChain,
-                     OUT PIO_STATUS_BLOCK IoStatus)
-{
-    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
-    PFAST_IO_DISPATCH FastDispatch;
-
-    /* Get Device Object and Fast Calls */
-    DeviceObject = IoGetRelatedDeviceObject(FileObject);
-    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
-
-    /* Check if we support Fast Calls, and check this one */
-    if (FastDispatch && FastDispatch->PrepareMdlWrite)
-    {
-        /* Use the fast path */
-        return FastDispatch->PrepareMdlWrite(FileObject,
-                                             FileOffset,
-                                             Length,
-                                             LockKey,
-                                             MdlChain,
-                                             IoStatus,
-                                             DeviceObject);
-    }
-
-    /* Get the Base File System (Volume) and Fast Calls */
-    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
-    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
-
-    /* If the Base Device Object has its own FastDispatch Routine, fail */
-    if (FastDispatch && FastDispatch->PrepareMdlWrite &&
-        BaseDeviceObject != DeviceObject)
-    {
-        return FALSE;
-    }
-
-    /* No fast path, use slow path */
-    return FsRtlPrepareMdlWriteDev(FileObject,
-                                   FileOffset,
-                                   Length,
-                                   LockKey,
-                                   MdlChain,
-                                   IoStatus,
-                                   DeviceObject);
-}
-
-/*
- * NAME EXPORTED
- * FsRtlPrepareMdlWriteDev@28
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * @unimplemented
- */
-BOOLEAN
-STDCALL
-FsRtlPrepareMdlWriteDev(IN  PFILE_OBJECT FileObject,
-                        IN  PLARGE_INTEGER FileOffset,
-                        IN  ULONG Length,
-                        IN  ULONG LockKey,
-                        OUT PMDL *MdlChain,
-                        OUT PIO_STATUS_BLOCK IoStatus,
-                        IN PDEVICE_OBJECT DeviceObject)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/filelock.c
+++ b/reactos/ntoskrnl/fs/filelock.c
--- a/reactos/ntoskrnl/fs/mcb.c
+++ b/reactos/ntoskrnl/fs/mcb.c
@@ -1,391 +0,0 @@
-/* $Id$
- *
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/mcb.c
- * PURPOSE:         No purpose listed.
- *
- * PROGRAMMERS:     No programmer listed.
- */
-
-/* INCLUDES ****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/**********************************************************************
- * NAME							EXPORTED
- *
- * DESCRIPTION
- *
- * ARGUMENTS
- *
- * RETURN VALUE
- *
- * NOTES
- *
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlAddLargeMcbEntry(IN PLARGE_MCB Mcb,
-                      IN LONGLONG Vbn,
-                      IN LONGLONG Lbn,
-                      IN LONGLONG SectorCount)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * FsRtlAddMcbEntry: Obsolete
- *
- * @implemented
- */
-BOOLEAN
-NTAPI
-FsRtlAddMcbEntry(IN PMCB     Mcb,
-                 IN VBN      Vbn,
-                 IN LBN      Lbn,
-                 IN ULONG    SectorCount)
-{
-    return FsRtlAddLargeMcbEntry(&Mcb->DummyFieldThatSizesThisStructureCorrectly,
-                                 (LONGLONG)Vbn,
-                                 (LONGLONG)Lbn,
-                                 (LONGLONG)SectorCount);
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlGetNextLargeMcbEntry(IN PLARGE_MCB Mcb,
-                          IN ULONG RunIndex,
-                          OUT PLONGLONG Vbn,
-                          OUT PLONGLONG Lbn,
-                          OUT PLONGLONG SectorCount)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-FsRtlGetNextMcbEntry(IN PMCB     Mcb,
-                     IN ULONG    RunIndex,
-                     OUT PVBN    Vbn,
-                     OUT PLBN    Lbn,
-                     OUT PULONG  SectorCount)
-{
-    BOOLEAN Return = FALSE;
-    LONGLONG llVbn;
-    LONGLONG llLbn;
-    LONGLONG llSectorCount;
-
-    /* Call the Large version */
-    Return = FsRtlGetNextLargeMcbEntry(&Mcb->DummyFieldThatSizesThisStructureCorrectly,
-                                       RunIndex,
-                                       &llVbn,
-                                       &llLbn,
-                                       &llSectorCount);
-
-    /* Return everything typecasted */
-    *Vbn = (ULONG)llVbn;
-    *Lbn = (ULONG)llLbn;
-    *SectorCount = (ULONG)llSectorCount;
-
-    /* And return the original value */
-    return(Return);
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlInitializeLargeMcb(IN PLARGE_MCB Mcb,
-                        IN POOL_TYPE PoolType)
-{
-    UNIMPLEMENTED;
-    Mcb->PoolType = PoolType;
-}
-
-/*
- * FsRtlInitializeMcb: Obsolete
- * @implemented
- */
-VOID
-NTAPI
-FsRtlInitializeMcb (IN PMCB         Mcb,
-                    IN POOL_TYPE    PoolType)
-{
-    FsRtlInitializeLargeMcb(& Mcb->DummyFieldThatSizesThisStructureCorrectly, PoolType);
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlLookupLargeMcbEntry(IN PLARGE_MCB Mcb,
-                         IN LONGLONG Vbn,
-                         OUT PLONGLONG Lbn OPTIONAL,
-                         OUT PLONGLONG SectorCountFromLbn OPTIONAL,
-                         OUT PLONGLONG StartingLbn OPTIONAL,
-                         OUT PLONGLONG SectorCountFromStartingLbn OPTIONAL,
-                         OUT PULONG Index OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlLookupLastLargeMcbEntryAndIndex(IN PLARGE_MCB OpaqueMcb,
-                                     OUT PLONGLONG LargeVbn,
-                                     OUT PLONGLONG LargeLbn,
-                                     OUT PULONG Index)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-PFSRTL_PER_STREAM_CONTEXT
-NTAPI
-FsRtlLookupPerStreamContextInternal(IN PFSRTL_ADVANCED_FCB_HEADER StreamContext,
-                                    IN PVOID OwnerId OPTIONAL,
-                                    IN PVOID InstanceId OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-PVOID /* PFSRTL_PER_FILE_OBJECT_CONTEXT*/
-NTAPI
-FsRtlLookupPerFileObjectContext(IN PFSRTL_ADVANCED_FCB_HEADER StreamContext,
-    IN PVOID OwnerId OPTIONAL,
-    IN PVOID InstanceId OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlLookupLastLargeMcbEntry(IN PLARGE_MCB Mcb,
-                             OUT PLONGLONG Vbn,
-                             OUT PLONGLONG Lbn)
-{
-    UNIMPLEMENTED;
-    return(FALSE);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-FsRtlLookupLastMcbEntry(IN PMCB Mcb,
-                        OUT PVBN Vbn,
-                        OUT PLBN Lbn)
-{
-    BOOLEAN Return = FALSE;
-    LONGLONG llVbn;
-    LONGLONG llLbn;
-
-    /* Call the Large version */
-    Return = FsRtlLookupLastLargeMcbEntry(&Mcb->DummyFieldThatSizesThisStructureCorrectly,
-        &llVbn,
-        &llLbn);
-
-    /* Return everything typecasted */
-    *Vbn = (ULONG)llVbn;
-    *Lbn = (ULONG)llLbn;
-
-    /* And return the original value */
-    return(Return);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-FsRtlLookupMcbEntry(IN PMCB Mcb,
-                    IN VBN Vbn,
-                    OUT PLBN Lbn,
-                    OUT PULONG SectorCount OPTIONAL,
-                    OUT PULONG Index)
-{
-    BOOLEAN Return = FALSE;
-    LONGLONG llLbn;
-    LONGLONG llSectorCount;
-
-    /* Call the Large version */
-    Return = FsRtlLookupLargeMcbEntry(&Mcb->DummyFieldThatSizesThisStructureCorrectly,
-                                      (LONGLONG)Vbn,
-                                      &llLbn,
-                                      &llSectorCount,
-                                      NULL,
-                                      NULL,
-                                      Index);
-
-    /* Return everything typecasted */
-    *Lbn = (ULONG)llLbn;
-    if (SectorCount) *SectorCount = (ULONG)llSectorCount;
-
-    /* And return the original value */
-    return(Return);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-FsRtlNumberOfRunsInLargeMcb(IN PLARGE_MCB Mcb)
-{
-    ULONG NumberOfRuns;
-
-    ExAcquireFastMutex(Mcb->FastMutex);
-    NumberOfRuns = Mcb->PairCount;
-    ExReleaseFastMutex(Mcb->FastMutex);
-
-    return NumberOfRuns;
-}
-
-
-/*
- * FsRtlNumberOfRunsInMcb: Obsolete
- *
- * @implemented
- */
-ULONG
-NTAPI
-FsRtlNumberOfRunsInMcb (IN PMCB Mcb)
-{
-    return FsRtlNumberOfRunsInLargeMcb(&Mcb->DummyFieldThatSizesThisStructureCorrectly);
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlRemoveLargeMcbEntry(IN PLARGE_MCB Mcb,
-                         IN LONGLONG Vbn,
-                         IN LONGLONG SectorCount)
-{
-    UNIMPLEMENTED;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-FsRtlRemoveMcbEntry(IN PMCB     Mcb,
-                    IN VBN      Vbn,
-                    IN ULONG    SectorCount)
-{
-    /* Call the large function */
-      return FsRtlRemoveLargeMcbEntry(&Mcb->DummyFieldThatSizesThisStructureCorrectly,
-                                      (LONGLONG)Vbn,
-                                      (LONGLONG)SectorCount);
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlResetLargeMcb(IN PLARGE_MCB Mcb,
-                   IN BOOLEAN SelfSynchronized)
-{
-    UNIMPLEMENTED;
-}
-
-/*
- * @unimplemented
- */
-BOOLEAN
-NTAPI
-FsRtlSplitLargeMcb(IN PLARGE_MCB Mcb,
-                   IN LONGLONG Vbn,
-                   IN LONGLONG Amount)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlTruncateLargeMcb(IN PLARGE_MCB Mcb,
-                      IN LONGLONG Vbn)
-{
-    UNIMPLEMENTED;
-}
-
-/*
- * FsRtlTruncateMcb: Obsolete
- *
- * @implemented
- */
-VOID
-NTAPI
-FsRtlTruncateMcb (IN PMCB Mcb,
-                  IN VBN  Vbn)
-{
-    FsRtlTruncateLargeMcb(&Mcb->DummyFieldThatSizesThisStructureCorrectly, (LONGLONG)Vbn);
-}
-
-/*
- * @unimplemented
- */
-VOID
-NTAPI
-FsRtlUninitializeLargeMcb(IN PLARGE_MCB Mcb)
-{
-    UNIMPLEMENTED;
-}
-
-/*
- * FsRtlUninitializeMcb: Obsolete
- *
- * @implemented
- */
-VOID
-NTAPI
-FsRtlUninitializeMcb(IN PMCB Mcb)
-{
-    FsRtlUninitializeLargeMcb(& Mcb->DummyFieldThatSizesThisStructureCorrectly);
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/name.c
+++ b/reactos/ntoskrnl/fs/name.c
@@ -1,655 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/name.c
- * PURPOSE:         Name and DBCS Name Validation and Dissection Functions.
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
- *                  Eric Kohl
- *                  Filip Navara
- */
-
-/* INCLUDES ****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLOBALS *******************************************************************/
-
-static UCHAR LegalAnsiCharacterArray[] =
-{
-  0,                                                        /* CTRL+@, 0x00 */
-  0,                                                        /* CTRL+A, 0x01 */
-  0,                                                        /* CTRL+B, 0x02 */
-  0,                                                        /* CTRL+C, 0x03 */
-  0,                                                        /* CTRL+D, 0x04 */
-  0,                                                        /* CTRL+E, 0x05 */
-  0,                                                        /* CTRL+F, 0x06 */
-  0,                                                        /* CTRL+G, 0x07 */
-  0,                                                        /* CTRL+H, 0x08 */
-  0,                                                        /* CTRL+I, 0x09 */
-  0,                                                        /* CTRL+J, 0x0a */
-  0,                                                        /* CTRL+K, 0x0b */
-  0,                                                        /* CTRL+L, 0x0c */
-  0,                                                        /* CTRL+M, 0x0d */
-  0,                                                        /* CTRL+N, 0x0e */
-  0,                                                        /* CTRL+O, 0x0f */
-  0,                                                        /* CTRL+P, 0x10 */
-  0,                                                        /* CTRL+Q, 0x11 */
-  0,                                                        /* CTRL+R, 0x12 */
-  0,                                                        /* CTRL+S, 0x13 */
-  0,                                                        /* CTRL+T, 0x14 */
-  0,                                                        /* CTRL+U, 0x15 */
-  0,                                                        /* CTRL+V, 0x16 */
-  0,                                                        /* CTRL+W, 0x17 */
-  0,                                                        /* CTRL+X, 0x18 */
-  0,                                                        /* CTRL+Y, 0x19 */
-  0,                                                        /* CTRL+Z, 0x1a */
-  0,                                                        /* CTRL+[, 0x1b */
-  0,                                                        /* CTRL+\, 0x1c */
-  0,                                                        /* CTRL+], 0x1d */
-  0,                                                        /* CTRL+^, 0x1e */
-  0,                                                        /* CTRL+_, 0x1f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* ` ',    0x20 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `!',    0x21 */
-  FSRTL_WILD_CHARACTER,                                     /* `"',    0x22 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `#',    0x23 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `$',    0x24 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `%',    0x25 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `&',    0x26 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `'',    0x27 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `(',    0x28 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `)',    0x29 */
-  FSRTL_WILD_CHARACTER,                                     /* `*',    0x2a */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `+',    0x2b */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `,',    0x2c */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `-',    0x2d */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `.',    0x2e */
-  0,                                                        /* `/',    0x2f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `0',    0x30 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `1',    0x31 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `2',    0x32 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `3',    0x33 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `4',    0x34 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `5',    0x35 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `6',    0x36 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `7',    0x37 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `8',    0x38 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `9',    0x39 */
-  FSRTL_NTFS_LEGAL,                                         /* `:',    0x3a */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `;',    0x3b */
-  FSRTL_WILD_CHARACTER,                                     /* `<',    0x3c */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `=',    0x3d */
-  FSRTL_WILD_CHARACTER,                                     /* `>',    0x3e */
-  FSRTL_WILD_CHARACTER,                                     /* `?',    0x3f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `@',    0x40 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `A',    0x41 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `B',    0x42 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `C',    0x43 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `D',    0x44 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `E',    0x45 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `F',    0x46 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `G',    0x47 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `H',    0x48 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `I',    0x49 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `J',    0x4a */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `K',    0x4b */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `L',    0x4c */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `M',    0x4d */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `N',    0x4e */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `O',    0x4f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `P',    0x50 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `Q',    0x51 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `R',    0x52 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `S',    0x53 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `T',    0x54 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `U',    0x55 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `V',    0x56 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `W',    0x57 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `X',    0x58 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `Y',    0x59 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `Z',    0x5a */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `[',    0x5b */
-  0,                                                        /* `\',    0x5c */
-  FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,                      /* `]',    0x5d */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `^',    0x5e */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `_',    0x5f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* ``',    0x60 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `a',    0x61 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `b',    0x62 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `c',    0x63 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `d',    0x64 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `e',    0x65 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `f',    0x66 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `g',    0x67 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `h',    0x68 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `i',    0x69 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `j',    0x6a */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `k',    0x6b */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `l',    0x6c */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `m',    0x6d */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `n',    0x6e */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `o',    0x6f */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `p',    0x70 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `q',    0x71 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `r',    0x72 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `s',    0x73 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `t',    0x74 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `u',    0x75 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `v',    0x76 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `w',    0x77 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `x',    0x78 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `y',    0x79 */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `z',    0x7a */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `{',    0x7b */
-  0,                                                        /* `|',    0x7c */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `}',    0x7d */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL,    /* `~',    0x7e */
-  FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL     /*         0x7f */
-};
-
-PUCHAR FsRtlLegalAnsiCharacterArray = LegalAnsiCharacterArray;
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlAreNamesEqual
- * @implemented
- *
- * FILLME
- *
- * @param Name1
- *        FILLME
- *
- * @param Name2
- *        FILLME
- *
- * @param IgnoreCase
- *        FILLME
- *
- * @param UpcaseTable
- *        FILLME
- *
- * @return None
- *
- * @remarks From Bo Branten's ntifs.h v25.
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlAreNamesEqual(IN PUNICODE_STRING Name1,
-                   IN PUNICODE_STRING Name2,
-                   IN BOOLEAN IgnoreCase,
-                   IN PWCHAR UpcaseTable OPTIONAL)
-{
-    UNICODE_STRING UpcaseName1;
-    UNICODE_STRING UpcaseName2;
-    BOOLEAN StringsAreEqual;
-
-    /* Well, first check their size */
-    if (Name1->Length != Name2->Length) {
-        /* Not equal! */
-        return FALSE;
-    }
-
-    /* Turn them into Upcase if we don't have a table */
-    if (IgnoreCase && !UpcaseTable) {
-        RtlUpcaseUnicodeString(&UpcaseName1, Name1, TRUE);
-        RtlUpcaseUnicodeString(&UpcaseName2, Name2, TRUE);
-        Name1 = &UpcaseName1;
-        Name2 = &UpcaseName2;
-
-        goto ManualCase;
-    }
-
-    /* Do a case-sensitive search */
-    if (!IgnoreCase) {
-
-ManualCase:
-        /* Use a raw memory compare */
-        StringsAreEqual = RtlEqualMemory(Name1->Buffer,
-                                         Name2->Buffer,
-                                         Name1->Length);
-
-        /* Clear the strings if we need to */
-        if (IgnoreCase) {
-            RtlFreeUnicodeString(&UpcaseName1);
-            RtlFreeUnicodeString(&UpcaseName2);
-        }
-
-        /* Return the equality */
-        return StringsAreEqual;
-
-    } else {
-
-        /* Case in-sensitive search */
-
-        LONG i;
-
-        for (i = Name1->Length / sizeof(WCHAR) - 1; i >= 0; i--) {
-
-            if (UpcaseTable[Name1->Buffer[i]] != UpcaseTable[Name2->Buffer[i]]) {
-
-                /* Non-match found! */
-                return FALSE;
-            }
-        }
-
-        /* We finished the loop so we are equal */
-        return TRUE;
-    }
-}
-
-/*++
- * @name FsRtlDissectDbcs
- * @implemented
- *
- * Dissects a given path name into first and remaining part.
- *
- * @param Name
- *        ANSI string to dissect.
- *
- * @param FirstPart
- *        Pointer to user supplied ANSI_STRING, that will later point
- *        to the first part of the original name.
- *
- * @param RemainingPart
- *        Pointer to user supplied ANSI_STRING, that will later point
- *        to the remaining part of the original name.
- *
- * @return None
- *
- * @remarks Example:
- *          Name:           \test1\test2\test3
- *          FirstPart:      test1
- *          RemainingPart:  test2\test3
- *
- *--*/
-VOID
-NTAPI
-FsRtlDissectDbcs(IN ANSI_STRING Name,
-                 OUT PANSI_STRING FirstPart,
-                 OUT PANSI_STRING RemainingPart)
-{
-    ULONG i;
-    ULONG FirstLoop;
-
-    /* Initialize the Outputs */
-    RtlZeroMemory(&FirstPart, sizeof(ANSI_STRING));
-    RtlZeroMemory(&RemainingPart, sizeof(ANSI_STRING));
-
-    /* Bail out if empty */
-    if (!Name.Length) return;
-
-    /* Ignore backslash */
-    if (Name.Buffer[0] == '\\') {
-        i = 1;
-    } else {
-        i = 0;
-    }
-
-    /* Loop until we find a backslash */
-    for (FirstLoop = i;i < Name.Length;i++) {
-        if (Name.Buffer[i] != '\\') break;
-        if (FsRtlIsLeadDbcsCharacter(Name.Buffer[i])) i++;
-    }
-
-    /* Now we have the First Part */
-    FirstPart->Length = (i-FirstLoop);
-    FirstPart->MaximumLength = FirstPart->Length; /* +2?? */
-    FirstPart->Buffer = &Name.Buffer[FirstLoop];
-
-    /* Make the second part if something is still left */
-    if (i<Name.Length) {
-        RemainingPart->Length = (Name.Length - (i+1));
-        RemainingPart->MaximumLength = RemainingPart->Length; /* +2?? */
-        RemainingPart->Buffer = &Name.Buffer[i+1];
-    }
-
-    return;
-}
-
-/*++
- * @name FsRtlDissectName
- * @implemented
- *
- * Dissects a given path name into first and remaining part.
- *
- * @param Name
- *        Unicode string to dissect.
- *
- * @param FirstPart
- *        Pointer to user supplied UNICODE_STRING, that will later point
- *        to the first part of the original name.
- *
- * @param RemainingPart
- *        Pointer to user supplied UNICODE_STRING, that will later point
- *        to the remaining part of the original name.
- *
- * @return None
- *
- * @remarks Example:
- *          Name:           \test1\test2\test3
- *          FirstPart:      test1
- *          RemainingPart:  test2\test3
- *
- *--*/
-VOID
-NTAPI
-FsRtlDissectName(IN UNICODE_STRING Name,
-                 OUT PUNICODE_STRING FirstPart,
-                 OUT PUNICODE_STRING RemainingPart)
-{
-    USHORT NameOffset = 0;
-    USHORT NameLength = 0;
-    USHORT Length;
-
-    FirstPart->Length = 0;
-    FirstPart->MaximumLength = 0;
-    FirstPart->Buffer = NULL;
-
-    RemainingPart->Length = 0;
-    RemainingPart->MaximumLength = 0;
-    RemainingPart->Buffer = NULL;
-
-    if (Name.Length == 0)
-        return;
-
-    /* Skip leading backslash */
-    if (Name.Buffer[0] == L'\\')
-        NameOffset++;
-
-    Length = Name.Length / sizeof(WCHAR);
-
-    /* Search for next backslash or end-of-string */
-    while ((NameOffset + NameLength < Length) &&
-        (Name.Buffer[NameOffset + NameLength] != L'\\'))
-    {
-        NameLength++;
-    }
-
-    FirstPart->Length =
-        FirstPart->MaximumLength = NameLength * sizeof(WCHAR);
-    FirstPart->Buffer = &Name.Buffer[NameOffset];
-
-    NameOffset += NameLength + 1;
-    if (NameOffset < Length)
-    {
-        RemainingPart->Length = (Length - NameOffset) * sizeof(WCHAR);
-        RemainingPart->MaximumLength = (Length - NameOffset) * sizeof(WCHAR);
-        RemainingPart->Buffer = &Name.Buffer[NameOffset];
-    }
-}
-
-/*++
- * @name FsRtlDoesDbcsContainWildCards
- * @implemented
- *
- * FILLME
- *
- * @param Name
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlDoesDbcsContainWildCards(IN PANSI_STRING Name)
-{
-    ULONG i;
-
-    /* Check every character */
-    for (i=0;i < Name->Length;i++) {
-
-        /* First make sure it's not the Lead DBCS */
-        if (FsRtlIsLeadDbcsCharacter(Name->Buffer[i])) {
-            i++;
-        } else if (FsRtlIsAnsiCharacterWild(Name->Buffer[i])) {
-            /* Now return if it has a Wilcard */
-            return TRUE;
-        }
-    }
-
-    /* We didn't return above...so none found */
-    return FALSE;
-}
-
-/*++
- * @name FsRtlDoesNameContainWildCards
- * @implemented
- *
- * FILLME
- *
- * @param Name
- *        Pointer to a UNICODE_STRING containing Name to examine
- *
- * @return TRUE if Name contains wildcards, FALSE otherwise
- *
- * @remarks From Bo Branten's ntifs.h v12.
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlDoesNameContainWildCards(IN PUNICODE_STRING Name)
-{
-    PWCHAR Ptr;
-
-    /* Loop through every character */
-    if (Name->Length) {
-        for (Ptr = Name->Buffer + (Name->Length / sizeof(WCHAR))-1;
-             Ptr >= Name->Buffer && *Ptr != L'\\';Ptr--) {
-
-            /* Check for Wildcard */
-            if (FsRtlIsUnicodeCharacterWild(*Ptr)) {
-                return TRUE;
-            }
-        }
-    }
-
-    /* Nothing Found */
-    return FALSE;
-}
-
-/*++
- * @name FsRtlIsDbcsInExpression
- * @unimplemented
- *
- * FILLME
- *
- * @param Expression
- *        FILLME
- *
- * @param Name
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsDbcsInExpression(IN PANSI_STRING Expression,
-                        IN PANSI_STRING Name)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlIsFatDbcsLegal
- * @unimplemented
- *
- * FILLME
- *
- * @param DbcsName
- *        FILLME
- *
- * @param WildCardsPermissible
- *        FILLME
- *
- * @param PathNamePermissible
- *        FILLME
- *
- * @param LeadingBackslashPermissible
- *        FILLME
- *
- * @return TRUE if the DbcsName is legal, FALSE otherwise
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsFatDbcsLegal(IN ANSI_STRING DbcsName,
-                    IN BOOLEAN WildCardsPermissible,
-                    IN BOOLEAN PathNamePermissible,
-                    IN BOOLEAN LeadingBackslashPermissible)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlIsHpfsDbcsLegal
- * @unimplemented
- *
- * FILLME
- *
- * @param DbcsName
- *        FILLME
- *
- * @param WildCardsPermissible
- *        FILLME
- *
- * @param PathNamePermissible
- *        FILLME
- *
- * @param LeadingBackslashPermissible
- *        FILLME
- *
- * @return TRUE if the DbcsName is legal, FALSE otherwise
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-STDCALL
-FsRtlIsHpfsDbcsLegal(IN ANSI_STRING DbcsName,
-                     IN BOOLEAN WildCardsPermissible,
-                     IN BOOLEAN PathNamePermissible,
-                     IN BOOLEAN LeadingBackslashPermissible)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlIsNameInExpression
- * @implemented
- *
- * FILLME
- *
- * @param DeviceObject
- *        FILLME
- *
- * @param Irp
- *        FILLME
- *
- * @return TRUE if Name is in Expression, FALSE otherwise
- *
- * @remarks From Bo Branten's ntifs.h v12. This function should be
- *          rewritten to avoid recursion and better wildcard handling
- *          should be implemented (see FsRtlDoesNameContainWildCards).
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsNameInExpression(IN PUNICODE_STRING Expression,
-                        IN PUNICODE_STRING Name,
-                        IN BOOLEAN IgnoreCase,
-                        IN PWCHAR UpcaseTable OPTIONAL)
-{
-    USHORT ExpressionPosition, NamePosition;
-    UNICODE_STRING TempExpression, TempName;
-
-    ExpressionPosition = 0;
-    NamePosition = 0;
-    while (ExpressionPosition < (Expression->Length / sizeof(WCHAR)) &&
-        NamePosition < (Name->Length / sizeof(WCHAR)))
-    {
-        if (Expression->Buffer[ExpressionPosition] == L'*')
-        {
-            ExpressionPosition++;
-            if (ExpressionPosition == (Expression->Length / sizeof(WCHAR)))
-            {
-                return TRUE;
-            }
-            while (NamePosition < (Name->Length / sizeof(WCHAR)))
-            {
-                TempExpression.Length =
-                    TempExpression.MaximumLength =
-                    Expression->Length - (ExpressionPosition * sizeof(WCHAR));
-                TempExpression.Buffer = Expression->Buffer + ExpressionPosition;
-                TempName.Length =
-                    TempName.MaximumLength =
-                    Name->Length - (NamePosition * sizeof(WCHAR));
-                TempName.Buffer = Name->Buffer + NamePosition;
-                /* FIXME: Rewrite to get rid of recursion */
-                if (FsRtlIsNameInExpression(&TempExpression, &TempName,
-                    IgnoreCase, UpcaseTable))
-                {
-                    return TRUE;
-                }
-                NamePosition++;
-            }
-        }
-        else
-        {
-            /* FIXME: Take UpcaseTable into account! */
-            if (Expression->Buffer[ExpressionPosition] == L'?' ||
-                (IgnoreCase &&
-                RtlUpcaseUnicodeChar(Expression->Buffer[ExpressionPosition]) ==
-                RtlUpcaseUnicodeChar(Name->Buffer[NamePosition])) ||
-                (!IgnoreCase &&
-                Expression->Buffer[ExpressionPosition] ==
-                Name->Buffer[NamePosition]))
-            {
-                NamePosition++;
-                ExpressionPosition++;
-            }
-            else
-            {
-                return FALSE;
-            }
-        }
-    }
-
-    /* Handle matching of "f0_*.*" expression to "f0_000" file name. */
-    if (ExpressionPosition < (Expression->Length / sizeof(WCHAR)) &&
-        Expression->Buffer[ExpressionPosition] == L'.')
-    {
-        while (ExpressionPosition < (Expression->Length / sizeof(WCHAR)) &&
-            (Expression->Buffer[ExpressionPosition] == L'.' ||
-            Expression->Buffer[ExpressionPosition] == L'*' ||
-            Expression->Buffer[ExpressionPosition] == L'?'))
-        {
-            ExpressionPosition++;
-        }
-    }
-
-    if (ExpressionPosition == (Expression->Length / sizeof(WCHAR)) &&
-        NamePosition == (Name->Length / sizeof(WCHAR)))
-    {
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/notify.c
+++ b/reactos/ntoskrnl/fs/notify.c
--- a/reactos/ntoskrnl/fs/oplock.c
+++ b/reactos/ntoskrnl/fs/oplock.c
@@ -1,175 +0,0 @@
-/* $Id$
- *
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/oplock.c
- * PURPOSE:         Oplock-functions
- *
- * PROGRAMMERS:     Emanuele Aliberti
- *                  Eric Kohl
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlCheckOplock
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @param Irp
- *        FILLME
- *
- * @param Context
- *        FILLME
- *
- * @param CompletionRoutine
- *        FILLME
- *
- * @param PostIrpRoutine
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlCheckOplock(IN POPLOCK Oplock,
-                 IN PIRP Irp,
-                 IN PVOID Context,
-                 IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL,
-                 IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/*++
- * @name FsRtlCurrentBatchOplock
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlCurrentBatchOplock(IN POPLOCK Oplock)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlInitializeOplock
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlInitializeOplock(IN OUT POPLOCK Oplock)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlOplockFsctrl
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @param Irp
- *        FILLME
- *
- * @param OpenCount
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlOplockFsctrl(IN POPLOCK Oplock,
-                  IN PIRP Irp,
-                  IN ULONG OpenCount)
-{
-    UNIMPLEMENTED;
-    return STATUS_NOT_IMPLEMENTED;
-}
-
-/*++
- * @name FsRtlOplockIsFastIoPossible
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlUninitializeOplock
- * @unimplemented
- *
- * FILLME
- *
- * @param Oplock
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlUninitializeOplock(IN POPLOCK Oplock)
-{
-    UNIMPLEMENTED;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/pool.c
+++ b/reactos/ntoskrnl/fs/pool.c
@@ -1,171 +0,0 @@
-/* $Id$
- *
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/pool.c
- * PURPOSE:         No purpose listed.
- *
- * PROGRAMMERS:     No programmer listed.
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlAllocatePool
- * @implemented
- *
- * FILLME
- *
- * @param PoolType
- *        FILLME
- *
- * @param NumberOfBytes
- *        FILLME
- *
- * @return None
- *
- * @remarks IFS_POOL_TAG is "FSrt" in mem view.
- *
- *--*/
-PVOID
-NTAPI
-FsRtlAllocatePool(IN POOL_TYPE PoolType,
-                  IN ULONG     NumberOfBytes)
-{
-    PVOID   Address;
-
-    Address = ExAllocatePoolWithTag(PoolType,
-                                    NumberOfBytes,
-                                    IFS_POOL_TAG);
-
-    if (NULL == Address)
-    {
-        ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
-    }
-
-    return Address;
-}
-
-/*++
- * @name FsRtlAllocatePoolWithQuota
- * @implemented
- *
- * FILLME
- *
- * @param PoolType
- *        FILLME
- *
- * @param NumberOfBytes
- *        FILLME
- *
- * @return None
- *
- * @remarks IFS_POOL_TAG is "FSrt" in mem view.
- *
- *--*/
-PVOID
-NTAPI
-FsRtlAllocatePoolWithQuota(IN POOL_TYPE PoolType,
-                           IN ULONG     NumberOfBytes)
-{
-    PVOID	Address;
-
-    Address = ExAllocatePoolWithQuotaTag(PoolType,
-                                         NumberOfBytes,
-                                         IFS_POOL_TAG);
-    if (NULL == Address)
-    {
-        ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
-    }
-    return Address;
-}
-
-/*++
- * @name FsRtlAllocatePoolWithQuotaTag
- * @implemented
- *
- * FILLME
- *
- * @param PoolType
- *        FILLME
- *
- * @param NumberOfBytes
- *        FILLME
- *
- * @param Tag
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-PVOID
-NTAPI
-FsRtlAllocatePoolWithQuotaTag (IN POOL_TYPE PoolType,
-                               IN ULONG     NumberOfBytes,
-                               IN ULONG     Tag)
-{
-    PVOID   Address;
-
-    Address = ExAllocatePoolWithQuotaTag(PoolType,
-                                         NumberOfBytes,
-                                         Tag);
-
-    if (NULL == Address)
-    {
-        ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
-    }
-
-    return Address;
-}
-
-/*++
- * @name FsRtlAllocatePoolWithTag
- * @implemented
- *
- * FILLME
- *
- * @param PoolType
- *        FILLME
- *
- * @param NumberOfBytes
- *        FILLME
- *
- * @param Tag
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-PVOID
-NTAPI
-FsRtlAllocatePoolWithTag(IN POOL_TYPE   PoolType,
-                         IN ULONG       NumberOfBytes,
-                         IN ULONG       Tag)
-{
-    PVOID   Address;
-
-    Address = ExAllocatePoolWithTag(PoolType,
-                                    NumberOfBytes,
-                                    Tag);
-
-    if (NULL == Address)
-    {
-        ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
-    }
-
-    return Address;
-}
-
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/tunnel.c
+++ b/reactos/ntoskrnl/fs/tunnel.c
@@ -1,178 +0,0 @@
-/* $Id$
- *
- * PROJECT:         ReactOS kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/tunnel.c
- * PURPOSE:         No purpose listed.
- *
- * PROGRAMMERS:     Emanuele Aliberti
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlAddToTunnelCache
- * @unimplemented
- *
- * FILLME
- *
- * @param Cache
- *        FILLME
- *
- * @param DirectoryKey
- *        FILLME
- *
- * @param ShortName
- *        FILLME
- *
- * @param LongName
- *        FILLME
- *
- * @param KeyByShortName
- *        FILLME
- *
- * @param DataLength
- *        FILLME
- *
- * @param Data
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlAddToTunnelCache(IN PTUNNEL          Cache,
-                      IN ULONGLONG        DirectoryKey,
-                      IN PUNICODE_STRING  ShortName,
-                      IN PUNICODE_STRING  LongName,
-                      IN BOOLEAN          KeyByShortName,
-                      IN ULONG            DataLength,
-                      IN PVOID            Data)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlDeleteKeyFromTunnelCache
- * @unimplemented
- *
- * FILLME
- *
- * @param Cache
- *        FILLME
- *
- * @param DirectoryKey
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlDeleteKeyFromTunnelCache(IN PTUNNEL      Cache,
-                              IN ULONGLONG    DirectoryKey)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlDeleteTunnelCache
- * @unimplemented
- *
- * FILLME
- *
- * @param Cache
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlDeleteTunnelCache(IN PTUNNEL Cache)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlFindInTunnelCache
- * @unimplemented
- *
- * FILLME
- *
- * @param Cache
- *        FILLME
- *
- * @param DirectoryKey
- *        FILLME
- *
- * @param ShortName
- *        FILLME
- *
- * @param LongName
- *        FILLME
- *
- * @param KeyByShortName
- *        FILLME
- *
- * @param DataLength
- *        FILLME
- *
- * @param Data
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlFindInTunnelCache(IN PTUNNEL          Cache,
-                       IN ULONGLONG        DirectoryKey,
-                       IN PUNICODE_STRING  Name,
-                       OUT PUNICODE_STRING ShortName,
-                       OUT PUNICODE_STRING LongName,
-                       IN OUT PULONG       DataLength,
-                       OUT PVOID           Data)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
-/*++
- * @name FsRtlDeleteTunnelCache
- * @unimplemented
- *
- * FILLME
- *
- * @param Cache
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlInitializeTunnelCache(IN PTUNNEL Cache)
-{
-    UNIMPLEMENTED;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/unc.c
+++ b/reactos/ntoskrnl/fs/unc.c
@@ -1,72 +0,0 @@
-/* $Id$
- *
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/unc.c
- * PURPOSE:         Functions to work with UNC providers
- *
- * PROGRAMMERS:     Emanuele Aliberti
- *                  Eric Kohl
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlDeregisterUncProvider
- * @unimplemented
- *
- * FILLME
- *
- * @param Handle
- *        FILLME
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-VOID
-NTAPI
-FsRtlDeregisterUncProvider(IN HANDLE Handle)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlRegisterUncProvider
- * @unimplemented
- *
- * FILLME
- *
- * @param Handle
- *        FILLME
- *
- * @param RedirectorDeviceName
- *        FILLME
- *
- * @param MailslotsSupported
- *
- * @return None
- *
- * @remarks None
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlRegisterUncProvider(IN OUT PHANDLE Handle,
-                         IN PUNICODE_STRING RedirectorDeviceName,
-                         IN BOOLEAN MailslotsSupported)
-{
-    UNIMPLEMENTED;
-    return(STATUS_NOT_IMPLEMENTED);
-}
-
-
-/* EOF */
--- a/reactos/ntoskrnl/fs/util.c
+++ b/reactos/ntoskrnl/fs/util.c
@@ -1,303 +0,0 @@
-/*
- * PROJECT:         ReactOS Kernel
- * LICENSE:         GPL - See COPYING in the top level directory
- * FILE:            ntoskrnl/fs/util.c
- * PURPOSE:         Misc Utility Functions for File System Drivers
- *
- * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
-                    Emanuele Aliberti
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ntoskrnl.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-#define FSRTL_MAX_RESOURCES 16
-
-#define FTTYPE  ((ULONG)'f')
-#define FT_BALANCED_READ_MODE \
-    CTL_CODE(FTTYPE, 6, METHOD_NEITHER, FILE_ANY_ACCESS)
-
-/* GLOBALS *******************************************************************/
-
-BOOLEAN STDCALL MmIsFileAPagingFile(PFILE_OBJECT FileObject);
-VOID NTAPI INIT_FUNCTION RtlpInitializeResources(VOID);
-static ULONG FsRtlpAllocatedResources = 0;
-static PERESOURCE FsRtlpResources;
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, RtlpInitializeResources)
-#endif
-
-/* PRIVATE FUNCTIONS**********************************************************/
-
-VOID
-NTAPI
-INIT_FUNCTION
-RtlpInitializeResources(VOID)
-{
-    ULONG i;
-
-    /* Allocate the Resource Buffer */
-    FsRtlpResources = FsRtlAllocatePool(NonPagedPool,
-                                        FSRTL_MAX_RESOURCES*sizeof(ERESOURCE));
-
-    /* Initialize the Resources */
-    for (i = 0; i < FSRTL_MAX_RESOURCES; i++)
-    {
-        ExInitializeResource(&FsRtlpResources[i]);
-    }
-}
-
-/* FUNCTIONS *****************************************************************/
-
-/*++
- * @name FsRtlIsTotalDeviceFailure
- * @implemented NT 4.0
- *
- *     The FsRtlIsTotalDeviceFailure routine checks if an NTSTATUS error code
- *     represents a disk hardware failure.
- *
- * @param NtStatus
- *        The NTSTATUS Code to Test
- *
- * @return TRUE in case of Hardware Failure, FALSE otherwise.
- *
- * @remarks None.
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsTotalDeviceFailure(IN NTSTATUS NtStatus)
-{
-    return((NT_SUCCESS(NtStatus)) ||
-           (STATUS_CRC_ERROR == NtStatus) ||
-           (STATUS_DEVICE_DATA_ERROR == NtStatus) ? FALSE : TRUE);
-}
-
-/*++
- * @name FsRtlIsNtstatusExpected
- * @implemented NT 4.0
- *
- *     The FsRtlIsNtstatusExpected routine checks if an NTSTATUS error code
- *     is expected by the File System Support Library.
- *
- * @param NtStatus
- *        The NTSTATUS Code to Test
- *
- * @return TRUE if the Value is Expected, FALSE otherwise.
- *
- * @remarks None.
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsNtstatusExpected(IN NTSTATUS NtStatus)
-{
-    return((STATUS_DATATYPE_MISALIGNMENT == NtStatus) ||
-           (STATUS_ACCESS_VIOLATION == NtStatus) ||
-           (STATUS_ILLEGAL_INSTRUCTION == NtStatus) ||
-           (STATUS_INSTRUCTION_MISALIGNMENT == NtStatus)) ? FALSE : TRUE;
-}
-
-/*++
- * @name FsRtlIsPagingFile
- * @implemented NT 4.0
- *
- *     The FsRtlIsPagingFile routine checks if the FileObject is a Paging File.
- *
- * @param FileObject
- *        A pointer to the File Object to be tested.
- *
- * @return TRUE if the File is a Paging File, FALSE otherwise.
- *
- * @remarks None.
- *
- *--*/
-BOOLEAN
-NTAPI
-FsRtlIsPagingFile(IN PFILE_OBJECT FileObject)
-{
-    return MmIsFileAPagingFile(FileObject);
-}
-
-/*++
- * @name FsRtlNormalizeNtstatus
- * @implemented NT 4.0
- *
- *     The FsRtlNormalizeNtstatus routine normalizes an NTSTATUS error code.
- *
- * @param NtStatusToNormalize
- *        The NTSTATUS error code to Normalize.
- *
- * @param NormalizedNtStatus
- *        The NTSTATUS error code to return if the NtStatusToNormalize is not
- *        a proper expected error code by the File System Library.
- *
- * @return NtStatusToNormalize if it is an expected value, otherwise
- *         NormalizedNtStatus.
- *
- * @remarks None.
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlNormalizeNtstatus(IN NTSTATUS NtStatusToNormalize,
-                       IN NTSTATUS NormalizedNtStatus)
-{
-    return(TRUE == FsRtlIsNtstatusExpected(NtStatusToNormalize)) ?
-           NtStatusToNormalize : NormalizedNtStatus;
-}
-
-/*++
- * @name FsRtlAllocateResource
- * @implemented NT 4.0
- *
- *     The FsRtlAllocateResource routine returns a pre-initialized ERESOURCE
- *     for use by a File System Driver.
- *
- * @return A Pointer to a pre-initialized ERESOURCE.
- *
- * @remarks The File System Library only provides up to 16 Resources.
- *
- *--*/
-PERESOURCE
-NTAPI
-FsRtlAllocateResource(VOID)
-{
-    /* Return a pre-allocated ERESOURCE */
-    return &FsRtlpResources[FsRtlpAllocatedResources++ & FSRTL_MAX_RESOURCES];
-}
-
-/*++
- * @name FsRtlBalanceReads
- * @implemented NT 4.0
- *
- *     The FsRtlBalanceReads routine sends an IRP to an FTDISK Driver
- *     requesting the driver to balance read requests across a mirror set.
- *
- * @param TargetDevice
- *        A pointer to an FTDISK Device Object.
- *
- * @return The NTSTATUS error code returned by the FTDISK Driver.
- *
- * @remarks FTDISK is a Software RAID Implementation.
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlBalanceReads(PDEVICE_OBJECT TargetDevice)
-{
-    PIRP Irp;
-    KEVENT Event;
-    IO_STATUS_BLOCK IoStatusBlock;
-    NTSTATUS Status;
-
-    /* Initialize the Local Event */
-    KeInitializeEvent(&Event, NotificationEvent, FALSE);
-
-    /* Build the special IOCTL */
-    Irp = IoBuildDeviceIoControlRequest(FT_BALANCED_READ_MODE,
-                                        TargetDevice,
-                                        NULL,
-                                        0,
-                                        NULL,
-                                        0,
-                                        FALSE,
-                                        &Event,
-                                        &IoStatusBlock);
-
-    /* Send it */
-    Status = IoCallDriver(TargetDevice, Irp);
-
-    /* Wait if needed */
-    if (Status == STATUS_PENDING)
-    {
-        Status = KeWaitForSingleObject(&Event,
-                                       Executive,
-                                       KernelMode,
-                                       FALSE,
-                                       NULL);
-        /* Return Status */
-        Status = IoStatusBlock.Status;
-    }
-
-    return Status;
-}
-
-/*++
- * @name FsRtlPostPagingFileStackOverflow
- * @unimplemented NT 4.0
- *
- *     The FsRtlPostPagingFileStackOverflow routine
- *
- * @param Context
- *
- * @param Event
- *
- * @param StackOverflowRoutine
- *
- * @return
- *
- * @remarks None.
- *
- *--*/
-VOID
-NTAPI
-FsRtlPostPagingFileStackOverflow(IN PVOID Context,
-                                 IN PKEVENT Event,
-                                 IN PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlPostStackOverflow
- * @unimplemented NT 4.0
- *
- *     The FsRtlPostStackOverflow routine
- *
- * @param Context
- *
- * @param Event
- *
- * @param StackOverflowRoutine
- *
- * @return
- *
- * @remarks None.
- *
- *--*/
-VOID
-NTAPI
-FsRtlPostStackOverflow(IN PVOID Context,
-                       IN PKEVENT Event,
-                       IN PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)
-{
-    UNIMPLEMENTED;
-}
-
-/*++
- * @name FsRtlSyncVolumes
- * @implemented NT 4.0
- *
- *     The FsRtlSyncVolumes routine is deprecated.
- *
- * @return Always returns STATUS_SUCCESS.
- *
- * @remarks Deprecated.
- *
- *--*/
-NTSTATUS
-NTAPI
-FsRtlSyncVolumes(DWORD Unknown0,
-                 DWORD Unknown1,
-                 DWORD Unknown2)
-{
-    return STATUS_SUCCESS;
-}
-
-/* EOF */
--- a/reactos/ntoskrnl/inbv/inbv.c
+++ b/reactos/ntoskrnl/inbv/inbv.c
@@ -1,252 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT:      See COPYING in the top level directory
- * PROJECT:        ReactOS kernel
- * FILE:           ntoskrnl/inbv/inbv.c
- * PURPOSE:        Boot video support
- *
- * PROGRAMMERS:    Casper S. Hornstrup (chorns@users.sourceforge.net)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ntoskrnl.h>
-#include "../../drivers/base/bootvid/ntbootvid.h"
-#define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, InbvEnableBootDriver)
-#endif
-
-/* ROS Internal. Please deprecate */
-NTHALAPI
-VOID
-NTAPI
-HalReleaseDisplayOwnership(VOID);
-
-/* GLOBALS *******************************************************************/
-
-/* DATA **********************************************************************/
-
-static HANDLE BootVidDevice = NULL;
-static BOOL BootVidDriverInstalled = FALSE;
-static NTBOOTVID_FUNCTION_TABLE BootVidFunctionTable;
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS
-STATIC
-InbvCheckBootVid(VOID)
-{
-    IO_STATUS_BLOCK Iosb;
-
-    if (BootVidDevice == NULL)
-    {
-        NTSTATUS Status;
-        OBJECT_ATTRIBUTES ObjectAttributes;
-        UNICODE_STRING BootVidName = RTL_CONSTANT_STRING(L"\\Device\\BootVid");
-
-        InitializeObjectAttributes(&ObjectAttributes,
-            &BootVidName,
-            0,
-            NULL,
-            NULL);
-        Status = ZwOpenFile(&BootVidDevice,
-            FILE_ALL_ACCESS,
-            &ObjectAttributes,
-            &Iosb,
-            0,
-            0);
-        if (!NT_SUCCESS(Status))
-        {
-            return(Status);
-        }
-    }
-    return(STATUS_SUCCESS);
-}
-
-
-VOID
-STDCALL
-InbvAcquireDisplayOwnership(VOID)
-{
-}
-
-BOOLEAN
-STDCALL
-InbvCheckDisplayOwnership(VOID)
-{
-    return FALSE;
-}
-
-BOOLEAN
-STDCALL
-InbvDisplayString(IN PCHAR String)
-{
-    /* Call Bootvid (we don't support bootvid for now) 
-     * vidDisplayString(String);
-     * so instead, we'll fall-back to HAL
-     */
-    HalDisplayString(String);
-
-    /* Call Headless (We don't support headless for now) 
-    HeadlessDispatch(DISPLAY_STRING);
-    */
-
-    /* Return success */
-    return TRUE;
-}
-
-BOOLEAN
-STDCALL
-InbvResetDisplayParameters(ULONG SizeX,
-                           ULONG SizeY)
-{
-    return(InbvResetDisplay());
-}
-
-
-VOID
-STDCALL
-INIT_FUNCTION
-InbvEnableBootDriver(IN BOOLEAN Enable)
-{
-    NTSTATUS Status;
-    IO_STATUS_BLOCK Iosb;
-
-    Status = InbvCheckBootVid();
-    if (!NT_SUCCESS(Status))
-    {
-        return;
-    }
-
-    if (Enable)
-    {
-        /* Notify the hal we will acquire the display. */
-        HalAcquireDisplayOwnership(InbvResetDisplayParameters);
-
-        Status = ZwDeviceIoControlFile(BootVidDevice,
-            NULL,
-            NULL,
-            NULL,
-            &Iosb,
-            IOCTL_BOOTVID_INITIALIZE,
-            NULL,
-            0,
-            &BootVidFunctionTable,
-            sizeof(BootVidFunctionTable));
-        if (!NT_SUCCESS(Status))
-        {
-            KEBUGCHECK(0);
-        }
-        BootVidDriverInstalled = TRUE;
-        CHECKPOINT;
-    }
-    else
-    {
-        Status = ZwDeviceIoControlFile(BootVidDevice,
-            NULL,
-            NULL,
-            NULL,
-            &Iosb,
-            IOCTL_BOOTVID_CLEANUP,
-            NULL,
-            0,
-            NULL,
-            0);
-        if (!NT_SUCCESS(Status))
-        {
-            KEBUGCHECK(0);
-        }
-        BootVidDriverInstalled = FALSE;
-        /* Notify the hal we have released the display. */
-        HalReleaseDisplayOwnership();
-    }
-
-    ZwClose(BootVidDevice);
-    BootVidDevice = NULL;
-}
-
-
-BOOLEAN
-STDCALL
-InbvEnableDisplayString(IN BOOLEAN Enable)
-{
-    return FALSE;
-}
-
-
-VOID
-STDCALL
-InbvInstallDisplayStringFilter(IN PVOID Unknown)
-{
-}
-
-
-BOOLEAN
-STDCALL
-InbvIsBootDriverInstalled(VOID)
-{
-    return(BootVidDriverInstalled);
-}
-
-
-VOID
-STDCALL
-InbvNotifyDisplayOwnershipLost(IN PVOID Callback)
-{
-}
-
-
-BOOLEAN
-STDCALL
-InbvResetDisplay(VOID)
-{
-    if (!BootVidDriverInstalled)
-    {
-        return(FALSE);
-    }
-    return(BootVidFunctionTable.ResetDisplay());
-}
-
-
-VOID
-STDCALL
-InbvSetScrollRegion(IN ULONG Left,
-                    IN ULONG Top,
-                    IN ULONG Width,
-                    IN ULONG Height)
-{
-}
-
-
-VOID
-STDCALL
-InbvSetTextColor(IN ULONG Color)
-{
-}
-
-
-VOID
-STDCALL
-InbvSolidColorFill(IN ULONG Left,
-                   IN ULONG Top,
-                   IN ULONG Width,
-                   IN ULONG Height,
-                   IN ULONG Color)
-{
-}
-
-NTSTATUS
-STDCALL
-NtDisplayString(IN PUNICODE_STRING DisplayString)
-{
-    OEM_STRING OemString;
-
-    RtlUnicodeStringToOemString(&OemString, DisplayString, TRUE);
-    HalDisplayString(OemString.Buffer);
-    RtlFreeOemString(&OemString);
-
-    return STATUS_SUCCESS;
-}
--- a/reactos/ntoskrnl/include/config.h
+++ b/reactos/ntoskrnl/include/config.h
@@ -1,44 +0,0 @@
-#ifndef __INCLUDE_NTOSKRNL_CONFIG_H
-#define __INCLUDE_NTOSKRNL_CONFIG_H
-
-/********** dbg/print.c **********/
-
-/* Enable serialization of debug messages printed with DbgPrint
- *
- * If this is enabled DbgPrint will queue messages if another thread is already
- * printing a message, and immediately returns. The other thread will print
- * queued messages before it returns.
- * It could happen that some messages are lost if the processor is halted before
- * the message queue was flushed.
- */
-#undef SERIALIZE_DBGPRINT
-
-/********** mm/ppool.c **********/
-
-/* Disable Debugging Features */
-#ifndef DBG
-    /* Enable strict checking of the nonpaged pool on every allocation */
-    #undef ENABLE_VALIDATE_POOL
-
-    /* Enable tracking of statistics about the tagged blocks in the pool */
-    #undef TAG_STATISTICS_TRACKING
-    
-    /* Enable Memory Debugging Features/Helpers */
-    #undef POOL_DEBUG_APIS
-    
-    /* Enable Redzone */
-    #define R_RZ 0
-    
-    /* Enable Allocator Stack */
-    #define R_STACK 0
-
-    /*
-     * Put each block in its own range of pages and position the block at the
-     * end of the range so any accesses beyond the end of block are to invalid
-     * memory locations.
-     */
-    #undef WHOLE_PAGE_ALLOCATIONS
-#endif
-
-#endif /* __INCLUDE_NTOSKRNL_CONFIG_H */
-
--- a/reactos/ntoskrnl/include/internal/arch/ke.h
+++ b/reactos/ntoskrnl/include/internal/arch/ke.h
@@ -1,30 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
- *
- *  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; either version 2 of the License, or
- *  (at your option) any 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
-#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
-
-#ifdef _M_IX86
-#include "../i386/ke.h"
-#else
-#error "Unknown processor"
-#endif
-
-#endif /* __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H */
-
-/* EOF */
--- a/reactos/ntoskrnl/include/internal/arch/mm.h
+++ b/reactos/ntoskrnl/include/internal/arch/mm.h
@@ -1,28 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
- *
- *  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; either version 2 of the License, or
- *  (at your option) any 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
-#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
-
-#ifdef _M_IX86
-#include <internal/i386/mm.h>
-#else
-#error "Unknown processor"
-#endif
-
-#endif /* __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H */
--- a/reactos/ntoskrnl/include/internal/cc.h
+++ b/reactos/ntoskrnl/include/internal/cc.h
@@ -1,204 +0,0 @@
-#ifndef __INCLUDE_INTERNAL_CC_H
-#define __INCLUDE_INTERNAL_CC_H
-
-typedef struct _BCB
-{
-    LIST_ENTRY BcbSegmentListHead;
-    LIST_ENTRY BcbRemoveListEntry;
-    BOOLEAN RemoveOnClose;
-    ULONG TimeStamp;
-    PFILE_OBJECT FileObject;
-    ULONG CacheSegmentSize;
-    LARGE_INTEGER AllocationSize;
-    LARGE_INTEGER FileSize;
-    KSPIN_LOCK BcbLock;
-    ULONG RefCount;
-#if defined(DBG) || defined(KDBG)
-	BOOLEAN Trace; /* enable extra trace output for this BCB and it's cache segments */
-#endif
-} BCB, *PBCB;
-
-typedef struct _CACHE_SEGMENT
-{
-    /* Base address of the region where the cache segment data is mapped. */
-    PVOID BaseAddress;
-    /*
-     * Memory area representing the region where the cache segment data is
-     * mapped.
-     */
-    struct _MEMORY_AREA* MemoryArea;
-    /* Are the contents of the cache segment data valid. */
-    BOOLEAN Valid;
-    /* Are the contents of the cache segment data newer than those on disk. */
-    BOOLEAN Dirty;
-    /* Page out in progress */
-    BOOLEAN PageOut;
-    ULONG MappedCount;
-    /* Entry in the list of segments for this BCB. */
-    LIST_ENTRY BcbSegmentListEntry;
-    /* Entry in the list of segments which are dirty. */
-    LIST_ENTRY DirtySegmentListEntry;
-    /* Entry in the list of segments. */
-    LIST_ENTRY CacheSegmentListEntry;
-    LIST_ENTRY CacheSegmentLRUListEntry;
-    /* Offset in the file which this cache segment maps. */
-    ULONG FileOffset;
-    /* Lock. */
-    FAST_MUTEX Lock;
-    /* Number of references. */
-    ULONG ReferenceCount;
-    /* Pointer to the BCB for the file which this cache segment maps data for. */
-    PBCB Bcb;
-    /* Pointer to the next cache segment in a chain. */
-    struct _CACHE_SEGMENT* NextInChain;
-} CACHE_SEGMENT, *PCACHE_SEGMENT;
-
-typedef struct _INTERNAL_BCB
-{
-    PUBLIC_BCB PFCB;
-    PCACHE_SEGMENT CacheSegment;
-    BOOLEAN Dirty;
-    CSHORT RefCount; /* (At offset 0x34 on WinNT4) */
-} INTERNAL_BCB, *PINTERNAL_BCB;
-
-VOID
-STDCALL
-CcMdlReadCompleteDev(
-    IN PMDL MdlChain,
-    IN PFILE_OBJECT FileObject
-);
-
-VOID
-STDCALL
-CcMdlWriteCompleteDev(
-    IN PLARGE_INTEGER FileOffset,
-    IN PMDL MdlChain,
-    IN PFILE_OBJECT FileObject
-);
-
-NTSTATUS
-NTAPI
-CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSegment);
-
-NTSTATUS
-NTAPI
-CcRosGetCacheSegment(
-    PBCB Bcb,
-    ULONG FileOffset,
-    PULONG BaseOffset,
-    PVOID *BaseAddress,
-    PBOOLEAN UptoDate,
-    PCACHE_SEGMENT *CacheSeg
-);
-
-VOID
-NTAPI
-CcInitView(VOID);
-
-NTSTATUS
-NTAPI
-CcRosFreeCacheSegment(
-    PBCB,
-    PCACHE_SEGMENT
-);
-
-NTSTATUS
-NTAPI
-ReadCacheSegment(PCACHE_SEGMENT CacheSeg);
-
-NTSTATUS
-NTAPI
-WriteCacheSegment(PCACHE_SEGMENT CacheSeg);
-
-VOID
-NTAPI
-CcInit(VOID);
-
-NTSTATUS
-NTAPI
-CcRosUnmapCacheSegment(
-    PBCB Bcb,
-    ULONG FileOffset,
-    BOOLEAN NowDirty
-);
-
-PCACHE_SEGMENT
-NTAPI
-CcRosLookupCacheSegment(
-    PBCB Bcb,
-    ULONG FileOffset
-);
-
-NTSTATUS
-NTAPI
-CcRosGetCacheSegmentChain(
-    PBCB Bcb,
-    ULONG FileOffset,
-    ULONG Length,
-    PCACHE_SEGMENT* CacheSeg
-);
-
-VOID
-NTAPI
-CcInitCacheZeroPage(VOID);
-
-NTSTATUS
-NTAPI
-CcRosMarkDirtyCacheSegment(
-    PBCB Bcb,
-    ULONG FileOffset
-);
-
-NTSTATUS
-NTAPI
-CcRosFlushDirtyPages(
-    ULONG Target,
-    PULONG Count
-);
-
-VOID
-NTAPI
-CcRosDereferenceCache(PFILE_OBJECT FileObject);
-
-VOID
-NTAPI
-CcRosReferenceCache(PFILE_OBJECT FileObject);
-
-VOID
-NTAPI
-CcRosSetRemoveOnClose(PSECTION_OBJECT_POINTERS SectionObjectPointer);
-
-NTSTATUS
-NTAPI
-CcRosReleaseCacheSegment(
-    BCB* Bcb,
-    CACHE_SEGMENT *CacheSeg,
-    BOOLEAN Valid,
-    BOOLEAN Dirty,
-    BOOLEAN Mapped
-);
-
-NTSTATUS
-STDCALL
-CcRosRequestCacheSegment(
-    BCB *Bcb,
-    ULONG FileOffset,
-    PVOID* BaseAddress,
-    PBOOLEAN UptoDate,
-    CACHE_SEGMENT **CacheSeg
-);
-
-NTSTATUS
-NTAPI
-CcTryToInitializeFileCache(PFILE_OBJECT FileObject);
-
-/*
- * Macro for generic cache manage bugchecking. Note that this macro assumes
- * that the file name including extension is always longer than 4 characters.
- */
-#define KEBUGCHECKCC \
-    KEBUGCHECKEX(CACHE_MANAGER, \
-    (*(DWORD*)(__FILE__ + sizeof(__FILE__) - 4) << 16) | \
-    (__LINE__ & 0xFFFF), 0, 0, 0)
-
-#endif
--- a/reactos/ntoskrnl/include/internal/ctype.h
+++ b/reactos/ntoskrnl/include/internal/ctype.h
@@ -1,43 +0,0 @@
-#ifndef _CTYPE_H
-#define _CTYPE_H
-
-#define __need_wchar_t
-#define __need_wint_t
-#include <stddef.h>
-
-/*
- * The following flags are used to tell iswctype and _isctype what character
- * types you are looking for.
- */
-
-#define _UPPER      0x0001
-#define _LOWER      0x0002
-#define _DIGIT      0x0004
-#define _SPACE      0x0008 /* HT  LF  VT  FF  CR  SP */
-#define _PUNCT      0x0010
-#define _CONTROL    0x0020
-#define _BLANK      0x0040 /* this is SP only, not SP and HT as in C99  */
-#define _HEX        0x0080
-#define _LEADBYTE   0x8000
-
-#define _ALPHA      0x0103
-
-#ifndef _WCTYPE_T_DEFINED
-typedef wchar_t wctype_t;
-#define _WCTYPE_T_DEFINED
-#endif
-
-
-#if defined(_MSC_VER)
-#define inline __inline
-typedef wchar_t wint_t;
-#endif
-
-extern inline int isspace(int c);
-extern inline int toupper(int c);
-extern inline int tolower(int c);
-extern inline int islower(int c);
-extern inline int isdigit(int c);
-extern inline int isxdigit(int c);
-
-#endif
--- a/reactos/ntoskrnl/include/internal/dbgk.h
+++ b/reactos/ntoskrnl/include/internal/dbgk.h
@@ -1,26 +0,0 @@
-#ifndef __NTOSKRNL_INCLUDE_INTERNAL_DBGK_H
-#define __NTOSKRNL_INCLUDE_INTERNAL_DBGK_H
-
-VOID
-STDCALL
-DbgkCreateThread(PVOID StartAddress);
-
-VOID
-NTAPI
-DbgkExitProcess(IN NTSTATUS ExitStatus);
-
-VOID
-NTAPI
-DbgkExitThread(IN NTSTATUS ExitStatus);
-
-VOID
-NTAPI
-DbgkCopyProcessDebugPort(
-    IN PEPROCESS Process,
-    IN PEPROCESS Parent
-);
-
-extern POBJECT_TYPE DbgkDebugObjectType;
-#endif
-
-/* EOF */
--- a/reactos/ntoskrnl/include/internal/debug.h
+++ b/reactos/ntoskrnl/include/internal/debug.h
@@ -1,132 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            include/internal/debug.h
- * PURPOSE:         Useful debugging macros
- * PROGRAMMER:      David Welch (welch@mcmail.com)
- * UPDATE HISTORY:
- *                28/05/98: Created
- */
-
-/*
- * NOTES: Define DBG in configuration file for "checked" version
- *        Define NDEBUG before including this header to disable debugging
- *        macros
- *        Define NASSERT before including this header to disable assertions
- */
-
-#ifdef CHECKPOINT
-#undef CHECKPOINT
-#endif
-
-#ifdef DPRINT
-#undef DPRINT
-#endif
-
-#ifndef NDEBUG
-#ifdef __GNUC__ /* using GNU C/C99 macro ellipsis */
-#define DPRINT(args...) do { DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint(args); } while(0)
-#else
-#define DPRINT DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint
-#endif
-#define CHECKPOINT do { DbgPrint("%s:%d\n",__FILE__,__LINE__); } while(0)
-#else /* NDEBUG */
-#ifdef __GNUC__ /* using GNU C/C99 macro ellipsis */
-#define DPRINT(args...)
-#else
-#define DPRINT
-#endif
-#define CHECKPOINT
-#endif /* NDEBUG */
-
-#ifndef __INTERNAL_DEBUG
-#define __INTERNAL_DEBUG
-
-#if defined(_MSC_VER) && (_MSC_VER < 1300)
-/* TODO: Verify which version the MS compiler learned the __FUNCTION__ macro */
-#define __FUNCTION__ "<unknown>"
-#endif
-#define UNIMPLEMENTED do {DbgPrint("%s at %s:%d is unimplemented, have a nice day\n",__FUNCTION__,__FILE__,__LINE__); for(;;);  } while(0)
-
-
-#ifdef assert
-#undef assert
-#endif
-
-#ifdef DBG
-
-#ifndef __USE_W32API
-/* Assert only on "checked" version */
-#ifndef NASSERT
-#ifdef CONFIG_SMP
-#define assert(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d for CPU%d\n", __FILE__,__LINE__, KeGetCurrentProcessorNumber()), DbgBreakPoint(); }
-#define ASSERT(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d for CPU%d\n", __FILE__,__LINE__, KeGetCurrentProcessorNumber()), DbgBreakPoint(); }
-#else
-#define assert(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d\n", __FILE__,__LINE__); DbgBreakPoint(); }
-#define ASSERT(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d\n", __FILE__,__LINE__); DbgBreakPoint(); }
-#endif
-
-#define assertmsg(_c_, _m_) \
-  if (!(_c_)) { \
-      DbgPrint("(%s:%d)(%s) ", __FILE__, __LINE__, __FUNCTION__); \
-      DbgPrint _m_ ; \
-      KeBugCheck(0); \
-  }
-
-#define ASSERTMSG(_c_, _m_) \
-  if (!(_c_)) { \
-      DbgPrint("(%s:%d)(%s) ", __FILE__, __LINE__, __FUNCTION__); \
-      DbgPrint _m_ ; \
-      KeBugCheck(0); \
-  }
-
-#else
-
-#define assert(x)
-#define ASSERT(x)
-#define assertmsg(_c_, _m_)
-#define ASSERTMSG(_c_, _m_)
-
-#endif
-#endif /* !__USE_W32API */
-
-/* Print if using a "checked" version */
-#ifdef __GNUC__ /* using GNU C/C99 macro ellipsis */
-#define CPRINT(args...) do { DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint(args); } while(0)
-#else
-#define CPRINT DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint
-#endif
-
-#ifdef __GNUC__ /* using GNU C/C99 macro ellipsis */
-#define DPRINT1(args...) do { DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint(args); } while(0)
-#else
-#define DPRINT1 DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint
-#endif
-
-#else /* DBG */
-
-#define CPRINT(args...)
-#define DPRINT1(args...)
-#ifndef __USE_W32API
-#define assert(x)
-#define ASSERT(x)
-#define assertmsg(_c_, _m_)
-#define ASSERTMSG(_c_, _m_)
-#endif /* !__USE_W32API */
-
-#endif /* DBG */
-
-#define CHECKPOINT1 do { DbgPrint("%s:%d\n",__FILE__,__LINE__); } while(0)
-
-/*
- * FUNCTION: Assert a maximum value for the current irql
- * ARGUMENTS:
- *        x = Maximum irql
- */
-#define ASSERT_IRQL_LESS_OR_EQUAL(x) ASSERT(KeGetCurrentIrql()<=(x))
-#define ASSERT_IRQL(x) ASSERT_IRQL_LESS_OR_EQUAL(x)
-#define ASSERT_IRQL_EQUAL(x) ASSERT(KeGetCurrentIrql()==(x))
-#define ASSERT_IRQL_LESS(x) ASSERT(KeGetCurrentIrql()<(x))
-#define assert_irql(x) assert(KeGetCurrentIrql()<=(x))
-
-#endif /* __INTERNAL_DEBUG */
--- a/reactos/ntoskrnl/include/internal/ex.h
+++ b/reactos/ntoskrnl/include/internal/ex.h
@@ -1,790 +0,0 @@
-#ifndef __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
-#define __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
-
-/* GLOBAL VARIABLES *********************************************************/
-
-extern TIME_ZONE_INFORMATION ExpTimeZoneInfo;
-extern LARGE_INTEGER ExpTimeZoneBias;
-extern ULONG ExpTimeZoneId;
-extern POBJECT_TYPE ExEventPairObjectType;
-
-#define MAX_FAST_REFS           7
-
-#define EX_OBJ_TO_HDR(eob) ((POBJECT_HEADER)((ULONG_PTR)(eob) &                \
-  ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE |           \
-  EX_HANDLE_ENTRY_AUDITONCLOSE)))
-#define EX_HTE_TO_HDR(hte) ((POBJECT_HEADER)((ULONG_PTR)((hte)->Object) &   \
-  ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE |           \
-  EX_HANDLE_ENTRY_AUDITONCLOSE)))
-
-/* Note: we only use a spinlock on SMP. On UP, we cli/sti intead */
-#ifndef CONFIG_SMP
-#define ExAcquireResourceLock(l, i) { \
-    (void)i; \
-    Ke386DisableInterrupts(); \
-}
-#define ExReleaseResourceLock(l, i) Ke386EnableInterrupts();
-#else
-#define ExAcquireResourceLock(l, i) KeAcquireSpinLock(l, i);
-#define ExReleaseResourceLock(l, i) KeReleaseSpinLock(l, i);
-#endif
-
-/* INITIALIZATION FUNCTIONS *************************************************/
-
-VOID
-STDCALL
-ExpWin32kInit(VOID);
-
-VOID
-STDCALL
-ExInit2(VOID);
-
-VOID
-STDCALL
-ExpInitTimeZoneInfo(VOID);
-
-VOID
-STDCALL
-ExpInitializeWorkerThreads(VOID);
-
-VOID
-STDCALL
-ExpInitLookasideLists(VOID);
-
-VOID
-STDCALL
-ExpInitializeCallbacks(VOID);
-
-VOID
-STDCALL
-ExpInitUuids(VOID);
-
-VOID
-STDCALL
-ExpInitializeExecutive(VOID);
-
-VOID
-STDCALL
-ExpInitializeEventImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeEventImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeEventPairImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeSemaphoreImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeMutantImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeTimerImplementation(VOID);
-
-VOID
-STDCALL
-ExpInitializeProfileImplementation(VOID);
-
-VOID
-NTAPI
-ExpResourceInitialization(VOID);
-
-/* Rundown Functions ********************************************************/
-
-VOID
-FASTCALL
-ExfInitializeRundownProtection(
-     OUT PEX_RUNDOWN_REF RunRef
-);
-
-VOID
-FASTCALL
-ExfReInitializeRundownProtection(
-     OUT PEX_RUNDOWN_REF RunRef
-);
-
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtection(
-     IN OUT PEX_RUNDOWN_REF RunRef
-);
-
-BOOLEAN
-FASTCALL
-ExfAcquireRundownProtectionEx(
-     IN OUT PEX_RUNDOWN_REF RunRef,
-     IN ULONG Count
-);
-
-VOID
-FASTCALL
-ExfReleaseRundownProtection(
-     IN OUT PEX_RUNDOWN_REF RunRef
-);
-
-VOID
-FASTCALL
-ExfReleaseRundownProtectionEx(
-     IN OUT PEX_RUNDOWN_REF RunRef,
-     IN ULONG Count
-);
-
-VOID
-FASTCALL
-ExfRundownCompleted(
-     OUT PEX_RUNDOWN_REF RunRef
-);
-
-VOID
-FASTCALL
-ExfWaitForRundownProtectionRelease(
-     IN OUT PEX_RUNDOWN_REF RunRef
-);
-
-/* HANDLE TABLE FUNCTIONS ***************************************************/
-
-#define EX_HANDLE_ENTRY_LOCKED (1 << ((sizeof(PVOID) * 8) - 1))
-#define EX_HANDLE_ENTRY_PROTECTFROMCLOSE (1 << 0)
-#define EX_HANDLE_ENTRY_INHERITABLE (1 << 1)
-#define EX_HANDLE_ENTRY_AUDITONCLOSE (1 << 2)
-
-#define EX_HANDLE_TABLE_CLOSING 0x1
-
-#define EX_HANDLE_ENTRY_FLAGSMASK (EX_HANDLE_ENTRY_LOCKED |                    \
-                                   EX_HANDLE_ENTRY_PROTECTFROMCLOSE |          \
-                                   EX_HANDLE_ENTRY_INHERITABLE |               \
-                                   EX_HANDLE_ENTRY_AUDITONCLOSE)
-
-typedef VOID (STDCALL PEX_SWEEP_HANDLE_CALLBACK)(
-    PHANDLE_TABLE_ENTRY HandleTableEntry,
-    HANDLE Handle,  
-    PVOID Context
-);
-
-typedef BOOLEAN (STDCALL PEX_DUPLICATE_HANDLE_CALLBACK)(
-    PHANDLE_TABLE HandleTable, 
-    PHANDLE_TABLE_ENTRY HandleTableEntry, 
-    PVOID Context
-);
-
-typedef BOOLEAN (STDCALL PEX_CHANGE_HANDLE_CALLBACK)(
-    PHANDLE_TABLE HandleTable, 
-    PHANDLE_TABLE_ENTRY HandleTableEntry, 
-    PVOID Context
-);
-
-VOID
-ExpInitializeHandleTables(VOID);
-
-PHANDLE_TABLE
-ExCreateHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL);
-
-VOID
-ExDestroyHandleTable(
-    IN PHANDLE_TABLE HandleTable
-);
-
-VOID
-ExSweepHandleTable(
-    IN PHANDLE_TABLE HandleTable,
-    IN PEX_SWEEP_HANDLE_CALLBACK SweepHandleCallback  OPTIONAL,
-    IN PVOID Context  OPTIONAL
-);
-
-PHANDLE_TABLE
-ExDupHandleTable(
-    IN PEPROCESS QuotaProcess  OPTIONAL,
-    IN PEX_DUPLICATE_HANDLE_CALLBACK DuplicateHandleCallback  OPTIONAL,
-    IN PVOID Context  OPTIONAL,
-    IN PHANDLE_TABLE SourceHandleTable
-);
-
-BOOLEAN
-ExLockHandleTableEntry(
-    IN PHANDLE_TABLE HandleTable,
-    IN PHANDLE_TABLE_ENTRY Entry
-);
-
-VOID
-ExUnlockHandleTableEntry(
-    IN PHANDLE_TABLE HandleTable,
-    IN PHANDLE_TABLE_ENTRY Entry
-);
-
-HANDLE
-ExCreateHandle(
-    IN PHANDLE_TABLE HandleTable,
-    IN PHANDLE_TABLE_ENTRY Entry
-);
-
-BOOLEAN
-ExDestroyHandle(
-    IN PHANDLE_TABLE HandleTable,
-    IN HANDLE Handle
-);
-
-VOID
-ExDestroyHandleByEntry(
-    IN PHANDLE_TABLE HandleTable,
-    IN PHANDLE_TABLE_ENTRY Entry,
-    IN HANDLE Handle
-);
-
-PHANDLE_TABLE_ENTRY
-ExMapHandleToPointer(
-    IN PHANDLE_TABLE HandleTable,
-    IN HANDLE Handle
-);
-
-BOOLEAN
-ExChangeHandle(
-    IN PHANDLE_TABLE HandleTable,
-    IN HANDLE Handle,
-    IN PEX_CHANGE_HANDLE_CALLBACK ChangeHandleCallback,
-    IN PVOID Context
-);
-
-/* PSEH EXCEPTION HANDLING **************************************************/
-
-LONG
-STDCALL
-ExSystemExceptionFilter(VOID);
-
-static __inline _SEH_FILTER(_SEH_ExSystemExceptionFilter)
-{
-    return ExSystemExceptionFilter();
-}
-
-
-/* RUNDOWN *******************************************************************/
-
-#if (NTDDI_VERSION >= NTDDI_WINXP)
-
-#ifdef _WIN64
-#define ExpChangeRundown(x, y, z) InterlockedCompareExchange64((PLONGLONG)x, y, z)
-#define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y)
-#else
-#define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, PtrToLong(y), PtrToLong(z))
-#define ExpSetRundown(x, y) InterlockedExchange((PLONG)x, y)
-#endif
-
-/*++
- * @name ExfAcquireRundownProtection
- * INTERNAL MACRO
- *
- *     The ExfAcquireRundownProtection routine acquires rundown protection for
- *     the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return TRUE if access to the protected structure was granted, FALSE otherwise.
- *
- * @remarks This is the internal macro for system use only.In case the rundown
- *          was active, then the slow-path will be called through the exported
- *          function.
- *
- *--*/
-BOOLEAN
-FORCEINLINE
-ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value, NewValue, OldValue;
-
-    /* Get the current value and mask the active bit */
-    Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
-
-    /* Add a reference */
-    NewValue = Value + EX_RUNDOWN_COUNT_INC;
-
-    /* Change the value */
-    OldValue = ExpChangeRundown(RunRef, NewValue, Value);
-    if (OldValue != Value)
-    {
-        /* Rundown was active, use long path */
-        return ExfAcquireRundownProtection(RunRef);
-    }
-
-    /* Success */
-    return TRUE;
-}
-
-/*++
- * @name ExReleaseRundownProtection
- * INTERNAL MACRO
- *
- *     The ExReleaseRundownProtection routine releases rundown protection for
- *     the specified descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return TRUE if access to the protected structure was granted, FALSE otherwise.
- *
- * @remarks This is the internal macro for system use only.In case the rundown
- *          was active, then the slow-path will be called through the exported
- *          function.
- *
- *--*/
-VOID
-FORCEINLINE
-ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value, NewValue, OldValue;
-
-    /* Get the current value and mask the active bit */
-    Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
-
-    /* Remove a reference */
-    NewValue = Value - EX_RUNDOWN_COUNT_INC;
-
-    /* Change the value */
-    OldValue = ExpChangeRundown(RunRef, NewValue, Value);
-
-    /* Check if the rundown was active */
-    if (OldValue != Value)
-    {
-        /* Rundown was active, use long path */
-        ExfReleaseRundownProtection(RunRef);
-    }
-    else
-    {
-        /* Sanity check */
-        ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
-    }
-}
-
-/*++
- * @name ExInitializeRundownProtection
- * INTERNAL MACRO
- *
- *     The ExInitializeRundownProtection routine initializes a rundown
- *     protection descriptor.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks This is the internal macro for system use only.
- *
- *--*/
-VOID
-FORCEINLINE
-ExInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
-{
-    /* Set the count to zero */
-    RunRef->Count = 0;
-}
-
-/*++
- * @name ExWaitForRundownProtectionRelease
- * INTERNAL MACRO
- *
- *     The ExWaitForRundownProtectionRelease routine waits until the specified
- *     rundown descriptor has been released.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks This is the internal macro for system use only. If a wait is actually
- *          necessary, then the slow path is taken through the exported function.
- *
- *--*/
-VOID
-FORCEINLINE
-ExWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
-{
-    ULONG_PTR Value;
-
-    /* Set the active bit */
-    Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
-    if ((Value) || (Value != EX_RUNDOWN_ACTIVE))
-    {
-        /* If the the rundown wasn't already active, then take the long path */
-        ExfWaitForRundownProtectionRelease(RunRef);
-    }
-}
-
-/*++
- * @name ExRundownCompleted
- * INTERNAL MACRO
- *
- *     The ExRundownCompleted routine completes the rundown of the specified
- *     descriptor by setting the active bit.
- *
- * @param RunRef
- *        Pointer to a rundown reference descriptor.
- *
- * @return None.
- *
- * @remarks This is the internal macro for system use only.
- *
- *--*/
-VOID
-FORCEINLINE
-ExRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
-{
-    /* Sanity check */
-    ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
-
-    /* Mark the counter as active */
-    ExpSetRundown(&RunRef->Count, EX_RUNDOWN_ACTIVE);
-}
-#endif
-
-/* PUSHLOCKS *****************************************************************/
-
-/*++
- * @name ExInitializePushLock
- * INTERNAL MACRO
- *
- *     The ExInitializePushLock macro initializes a PushLock.
- *
- * @params PushLock
- *         Pointer to the pushlock which is to be initialized.
- *
- * @return None.
- *
- * @remarks None.
- *
- *--*/
-VOID
-FORCEINLINE
-ExInitializePushLock(IN PEX_PUSH_LOCK PushLock)
-{
-    /* Set the value to 0 */
-    PushLock->Value = 0;
-}
-
-/*++
- * @name ExAcquirePushLockExclusive
- * INTERNAL MACRO
- *
- *     The ExAcquirePushLockExclusive macro exclusively acquires a PushLock.
- *
- * @params PushLock
- *         Pointer to the pushlock which is to be acquired.
- *
- * @return None.
- *
- * @remarks The function attempts the quickest route to acquire the lock, which is
- *          to simply set the lock bit.
- *          However, if the pushlock is already shared, the slower path is taken.
- *
- *          Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
- *          This macro should usually be paired up with KeAcquireCriticalRegion.
- *
- *--*/
-VOID
-FORCEINLINE
-ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
-{
-    /* Try acquiring the lock */
-    if (InterlockedBitTestAndSet((PLONG)PushLock, EX_PUSH_LOCK_LOCK_V))
-    {
-        /* Someone changed it, use the slow path */
-        DbgPrint("%s - Contention!\n", __FUNCTION__);
-        ExfAcquirePushLockExclusive(PushLock);
-    }
-
-    /* Sanity check */
-    ASSERT(PushLock->Locked);
-}
-
-/*++
- * @name ExAcquirePushLockShared
- * INTERNAL MACRO
- *
- *     The ExAcquirePushLockShared macro acquires a shared PushLock.
- *
- * @params PushLock
- *         Pointer to the pushlock which is to be acquired.
- *
- * @return None.
- *
- * @remarks The function attempts the quickest route to acquire the lock, which is
- *          to simply set the lock bit and set the share count to one.
- *          However, if the pushlock is already shared, the slower path is taken.
- *
- *          Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
- *          This macro should usually be paired up with KeAcquireCriticalRegion.
- *
- *--*/
-VOID
-FORCEINLINE
-ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
-{
-    EX_PUSH_LOCK NewValue;
-
-    /* Try acquiring the lock */
-    NewValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
-    if (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, 0))
-    {
-        /* Someone changed it, use the slow path */
-        DbgPrint("%s - Contention!\n", __FUNCTION__);
-        ExfAcquirePushLockShared(PushLock);
-    }
-
-    /* Sanity checks */
-    ASSERT(PushLock->Locked);
-    ASSERT(PushLock->Waiting || PushLock->Shared > 0);
-}
-
-/*++
- * @name ExConvertPushLockSharedToExclusive
- * INTERNAL MACRO
- *
- *     The ExConvertPushLockSharedToExclusive macro converts an exclusive
- *     pushlock to a shared pushlock.
- *
- * @params PushLock
- *         Pointer to the pushlock which is to be converted.
- *
- * @return FALSE if conversion failed, TRUE otherwise.
- *
- * @remarks The function attempts the quickest route to convert the lock, which is
- *          to simply set the lock bit and remove any other bits.
- *
- *--*/
-BOOLEAN
-FORCEINLINE
-ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
-{
-    EX_PUSH_LOCK OldValue;
-
-    /* Set the expected old value */
-    OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
-
-    /* Try converting the lock */
-    if (InterlockedCompareExchange((PLONG)PushLock,
-                                   EX_PUSH_LOCK_LOCK,
-                                   OldValue.Value) != OldValue.Value)
-    {
-        /* Conversion failed */
-        return FALSE;
-    }
-
-    /* Sanity check */
-    ASSERT(PushLock->Locked);
-    return TRUE;
-}
-
-/*++
- * @name ExWaitOnPushLock
- * INTERNAL MACRO
- *
- *     The ExWaitOnPushLock macro acquires and instantly releases a pushlock.
- *
- * @params PushLock
- *         Pointer to a pushlock.
- *
- * @return None.
- *
- * @remarks The function attempts to get any exclusive waiters out of their slow
- *          path by forcing an instant acquire/release operation.
- *
- *          Callers of ExWaitOnPushLock must be running at IRQL <= APC_LEVEL.
- *
- *--*/
-VOID
-FORCEINLINE
-ExWaitOnPushLock(PEX_PUSH_LOCK PushLock)
-{
-    /* Acquire the lock */
-    ExfAcquirePushLockExclusive(PushLock);
-    ASSERT(PushLock->Locked);
-
-    /* Release it */
-    ExfReleasePushLockExclusive(PushLock);
-}
-
-/*++
- * @name ExReleasePushLockShared
- * INTERNAL MACRO
- *
- *     The ExReleasePushLockShared macro releases a previously acquired PushLock.
- *
- * @params PushLock
- *         Pointer to a previously acquired pushlock.
- *
- * @return None.
- *
- * @remarks The function attempts the quickest route to release the lock, which is 
- *          to simply decrease the share count and remove the lock bit.
- *          However, if the pushlock is being waited on then the long path is taken.
- *
- *          Callers of ExReleasePushLockShared must be running at IRQL <= APC_LEVEL.
- *          This macro should usually be paired up with KeLeaveCriticalRegion.
- *
- *--*/
-VOID
-FORCEINLINE
-ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
-{
-    EX_PUSH_LOCK OldValue;
-
-    /* Sanity checks */
-    ASSERT(PushLock->Locked);
-    ASSERT(PushLock->Waiting || PushLock->Shared > 0);
-
-    /* Try to clear the pushlock */
-    OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
-    if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) !=
-        OldValue.Ptr)
-    {
-        /* There are still other people waiting on it */
-        DbgPrint("%s - Contention!\n", __FUNCTION__);
-        ExfReleasePushLockShared(PushLock);
-    }
-}
-
-/*++
- * @name ExReleasePushLockExclusive
- * INTERNAL MACRO
- *
- *     The ExReleasePushLockExclusive macro releases a previously
- *     exclusively acquired PushLock.
- *
- * @params PushLock
- *         Pointer to a previously acquired pushlock.
- *
- * @return None.
- *
- * @remarks The function attempts the quickest route to release the lock, which is
- *          to simply clear the locked bit.
- *          However, if the pushlock is being waited on, the slow path is taken
- *          in an attempt to wake up the lock.
- *
- *          Callers of ExReleasePushLockExclusive must be running at IRQL <= APC_LEVEL.
- *          This macro should usually be paired up with KeLeaveCriticalRegion.
- *
- *--*/
-VOID
-FORCEINLINE
-ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
-{
-    EX_PUSH_LOCK OldValue;
-
-    /* Sanity checks */
-    ASSERT(PushLock->Locked);
-    ASSERT(PushLock->Waiting || PushLock->Shared == 0);
-
-    /* Unlock the pushlock */
-    OldValue.Value = InterlockedExchangeAddSizeT((PLONG)PushLock, -1);
-
-    /* Sanity checks */
-    ASSERT(OldValue.Locked);
-    ASSERT(OldValue.Waiting || OldValue.Shared == 0);
-
-    /* Check if anyone is waiting on it and it's not already waking*/
-    if ((OldValue.Waiting) && !(OldValue.Waking))
-    {
-        /* Wake it up */
-        DbgPrint("%s - Contention!\n", __FUNCTION__);
-        ExfTryToWakePushLock(PushLock);
-    }
-}
-
-/*++
- * @name ExReleasePushLock
- * INTERNAL MACRO
- *
- *     The ExReleasePushLock macro releases a previously acquired PushLock.
- *
- * @params PushLock
- *         Pointer to a previously acquired pushlock.
- *
- * @return None.
- *
- * @remarks The function attempts the quickest route to release the lock, which is 
- *          to simply clear all the fields and decrease the share count if required.
- *          However, if the pushlock is being waited on then the long path is taken.
- *
- *          Callers of ExReleasePushLock must be running at IRQL <= APC_LEVEL.
- *          This macro should usually be paired up with KeLeaveCriticalRegion.
- *
- *--*/
-VOID
-FORCEINLINE
-ExReleasePushLock(PEX_PUSH_LOCK PushLock)
-{
-    EX_PUSH_LOCK OldValue = *PushLock;
-    EX_PUSH_LOCK NewValue;
-
-    /* Sanity checks */
-    ASSERT(OldValue.Locked);
-
-    /* Check if the pushlock is shared */
-    if (OldValue.Shared > 1)
-    {
-        /* Decrease the share count */
-        NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_SHARE_INC;
-    }
-    else
-    {
-        /* Clear the pushlock entirely */
-        NewValue.Value = 0;
-    }
-
-    /* Check if nobody is waiting on us and try clearing the lock here */
-    if ((OldValue.Waiting) ||
-        (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, OldValue.Ptr) ==
-         OldValue.Ptr))
-    {
-        /* We have waiters, use the long path */
-        DbgPrint("%s - Contention!\n", __FUNCTION__);
-        ExfReleasePushLock(PushLock);
-    }
-}
-
-/* OTHER FUNCTIONS **********************************************************/
-
-LONGLONG
-FASTCALL
-ExfpInterlockedExchange64(
-    LONGLONG volatile * Destination,
-    PLONGLONG Exchange
-);
-
-NTSTATUS
-ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation);
-
-NTSTATUS
-NTAPI
-ExpAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId);
-
-VOID
-STDCALL
-ExTimerRundown(VOID);
-
-#define InterlockedDecrementUL(Addend) \
-   (ULONG)InterlockedDecrement((PLONG)(Addend))
-
-#define InterlockedIncrementUL(Addend) \
-   (ULONG)InterlockedIncrement((PLONG)(Addend))
-
-#define InterlockedExchangeUL(Target, Value) \
-   (ULONG)InterlockedExchange((PLONG)(Target), (LONG)(Value))
-
-#define InterlockedExchangeAddUL(Addend, Value) \
-   (ULONG)InterlockedExchangeAdd((PLONG)(Addend), (LONG)(Value))
-
-#define InterlockedCompareExchangeUL(Destination, Exchange, Comperand) \
-   (ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand))
-
-#define ExfInterlockedCompareExchange64UL(Destination, Exchange, Comperand) \
-   (ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand))
-
-#define ExfpInterlockedExchange64UL(Target, Value) \
-   (ULONGLONG)ExfpInterlockedExchange64((PLONGLONG)(Target), (PLONGLONG)(Value))
-
-#endif /* __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H */
--- a/Show More
+++ b/Show More