1844 lines
75 KiB
Plaintext
1844 lines
75 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: IoSystem.sg
|
|
//
|
|
// Note:
|
|
//
|
|
|
|
//#define DEBUG_DISPATCH_IO
|
|
//#define VERBOSE
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Threading;
|
|
|
|
using Microsoft.SingSharp;
|
|
using Microsoft.Singularity;
|
|
using Microsoft.Singularity.Hal;
|
|
using Microsoft.Singularity.Directory;
|
|
using Microsoft.Singularity.Channels;
|
|
using Microsoft.Singularity.Loader;
|
|
using Microsoft.Singularity.Extending;
|
|
using Microsoft.Singularity.Memory;
|
|
using Microsoft.Singularity.FileSystem;
|
|
using Microsoft.Singularity.Memory;
|
|
|
|
using Microsoft.Singularity.Xml;
|
|
|
|
namespace Microsoft.Singularity.Io
|
|
{
|
|
internal sealed class VerboseOut
|
|
{
|
|
[ System.Diagnostics.Conditional("VERBOSE") ]
|
|
internal static void Print(string format, __arglist)
|
|
{
|
|
DebugStub.Print(format, new ArgIterator(__arglist));
|
|
}
|
|
|
|
[ System.Diagnostics.Conditional("VERBOSE") ]
|
|
internal static void Print(string message)
|
|
{
|
|
DebugStub.Print(message);
|
|
}
|
|
|
|
[ System.Diagnostics.Conditional("VERBOSE") ]
|
|
internal static void WriteLine(string format, __arglist)
|
|
{
|
|
DebugStub.WriteLine(format, new ArgIterator(__arglist));
|
|
}
|
|
|
|
[ System.Diagnostics.Conditional("VERBOSE") ]
|
|
internal static void WriteLine(string message)
|
|
{
|
|
DebugStub.WriteLine(message);
|
|
}
|
|
}
|
|
|
|
[CLSCompliant(false)]
|
|
public delegate IDevice! IoDeviceCreate(IoConfig! config,
|
|
String! instanceName);
|
|
|
|
internal class ExtensionDevice
|
|
{
|
|
// endpoint tags:
|
|
public const string EndpointSetXmlTag = "endpoints";
|
|
public const string ServiceEndpointXmlTag = "serviceProvider";
|
|
public const string ExtensionEndpointXmlTag = "extension";
|
|
public const string GenericEndpointXmlTag = "endpoint";
|
|
public const string ContractXmlAttribute = "contractName";
|
|
public const string EndpointEndXmlAttribute = "endpointEnd";
|
|
public const string IndexXmlAttribute = "id";
|
|
|
|
private readonly Driver! driver;
|
|
private readonly DeviceNode! device;
|
|
private String instance;
|
|
private Process process;
|
|
private TRef<ExtensionContract.Imp:Ready> channel;
|
|
|
|
// invariant driver.imagePath != null;
|
|
|
|
public ExtensionDevice(Driver! driver, DeviceNode! device)
|
|
requires driver.imagePath != null;
|
|
{
|
|
VerboseOut.Print(" ExtensionDevice({0})",
|
|
__arglist(driver.name));
|
|
|
|
this.driver = driver;
|
|
this.device = device;
|
|
this.instance = null;
|
|
base();
|
|
}
|
|
|
|
public void Finalize()
|
|
{
|
|
VerboseOut.Print("Finalizing {0} (channel = {1})\n",
|
|
__arglist(driver.name, channel != null));
|
|
if (channel == null) {
|
|
return;
|
|
}
|
|
|
|
ExtensionContract.Imp imp = channel.Acquire();
|
|
VerboseOut.Print("Requesting shutdown...");
|
|
|
|
imp.SendShutdown();
|
|
switch receive {
|
|
case imp.RecvAckShutdown():
|
|
Tracing.Log(Tracing.Audit, "Driver shutdown!");
|
|
break;
|
|
case imp.RecvNakShutdown():
|
|
Tracing.Log(Tracing.Audit, "Driver won't shutdown!");
|
|
break;
|
|
case unsatisfiable:
|
|
Tracing.Log(Tracing.Audit, "Child aborted!");
|
|
break;
|
|
case timeout(TimeSpan.FromSeconds(5)):
|
|
DebugStub.Break();
|
|
break;
|
|
}
|
|
delete imp;
|
|
VerboseOut.WriteLine("done");
|
|
|
|
channel = null;
|
|
}
|
|
|
|
// Activate a device driver
|
|
// NB: this method assumes that the device has already been checked, and
|
|
// its dependencies are all satisfied/satisfiable
|
|
public bool Activate()
|
|
{
|
|
// Update the /hardware namespace
|
|
if (driver.directoryRoot == null || device.directoryRoot == null) {
|
|
// The /hardware tree is incomplete for this device
|
|
DebugStub.Break();
|
|
return false;
|
|
}
|
|
|
|
// Create an instance name for this driver
|
|
for (int i = 0;; i++) {
|
|
string inst = driver.directoryRoot + "/instance" + i;
|
|
if (DirectoryService.FindDirectory(inst, false) == null) {
|
|
instance = inst;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Create the child process.
|
|
Manifest manifest;
|
|
|
|
// from invariant
|
|
assume driver.imagePath != null;
|
|
|
|
IoMemory memory = Binder.LoadImage(Process.KernelProcess,
|
|
driver.imagePath,
|
|
out manifest);
|
|
if (null == memory && manifest == null) {
|
|
return false;
|
|
}
|
|
|
|
// The instance argument in the
|
|
// process arguments gets replaced by the service
|
|
// endpoint path if present in the manifest before
|
|
// we call process.Start(). This is a little ugly,
|
|
// but some services need to be able to pass their
|
|
// endpoint name to other services (e.g. disk driver
|
|
// to volume manager).
|
|
string [] processArgs = new String[] {
|
|
driver.imagePath,
|
|
"-instance",
|
|
instance, // Value overwritten below (do not reorder)
|
|
"-signature",
|
|
device.MatchingDeviceId
|
|
};
|
|
|
|
process = new Process(Process.KernelProcess, memory, null,
|
|
processArgs, manifest);
|
|
if (null == process) {
|
|
return false;
|
|
}
|
|
process.IoConfig = device.config;
|
|
|
|
// the order here is a little bit funny; we need to create the
|
|
// endpoints before we start the driver. We must also build the
|
|
// pieces of the /hardware tree that store the real endpoints.
|
|
// However, we cannot create the public names (i.e. those in the
|
|
// /dev namespace) until after the driver is started.
|
|
|
|
// [TODO] If the activation fails, there is no rollback,
|
|
// and so we'll end up with a polluted namespace
|
|
|
|
// since we can't create the public names until after driver
|
|
// activation, we need a place to store the string names as we
|
|
// generate them
|
|
|
|
SortedList publicServiceProviderNames = new SortedList();
|
|
|
|
// do the accounting, NS bindings, and endpoint creation:
|
|
|
|
// get the image node and device node, create the instance node
|
|
DirNode devImageNode = DirectoryService.FindDirectory(
|
|
driver.directoryRoot + "/image", false);
|
|
DirNode driverNode = DirectoryService.FindDirectory(instance, true);
|
|
DirNode! deviceNode = (!)DirectoryService.FindDirectory(
|
|
device.directoryRoot, false);
|
|
|
|
VerboseOut.Print("DriverName: {0}\n",
|
|
__arglist(driver.directoryRoot));
|
|
VerboseOut.Print("DeviceName: {0}\n",
|
|
__arglist(device.directoryRoot));
|
|
|
|
// build the symlinks:
|
|
DirectoryService.CreateSymbolicLink(driverNode, "device",
|
|
device.directoryRoot);
|
|
DirectoryService.CreateSymbolicLink(deviceNode, "driver",
|
|
instance);
|
|
if (devImageNode != null) {
|
|
DirectoryService.CreateSymbolicLink(driverNode, "image",
|
|
driver.directoryRoot);
|
|
}
|
|
|
|
// Now create and link all of the ServiceProvider endpoints
|
|
// that this driver provides:
|
|
XmlNode! endpoints
|
|
= (!)driver.metadata.GetChild(EndpointSetXmlTag);
|
|
|
|
// [TODO] this will not work correctly if there
|
|
// are non-endpoint declarations in the <endpoints> set
|
|
int endpointCount = endpoints.GetAttribute("length", 0);
|
|
process.SetEndpointCount(endpointCount);
|
|
|
|
int extensionIndex = -1; // we only support one extension
|
|
// Make all endpoints
|
|
foreach (XmlNode! endpoint in endpoints.Children) {
|
|
string! contract = (!)endpoint.GetAttribute(
|
|
ContractXmlAttribute, "");
|
|
bool created = false;
|
|
|
|
int index = endpoint.GetAttribute(IndexXmlAttribute, -1);
|
|
|
|
if (endpoint.Name == ExtensionEndpointXmlTag &&
|
|
extensionIndex == -1) {
|
|
extensionIndex = index;
|
|
created = true;
|
|
}
|
|
else if (endpoint.Name == ServiceEndpointXmlTag) {
|
|
// create the /hardware name (private name)
|
|
string privateName = instance + "/endpoint" + index;
|
|
|
|
string! publicName;
|
|
|
|
// now tell the ResourceTracker to connect this private
|
|
// name and use the policy to create a public name
|
|
Binder.SetEndpoint(process, index,
|
|
Binder.BindServiceProvider(
|
|
contract, privateName,
|
|
out created, out publicName));
|
|
|
|
VerboseOut.Print("privateName: {0}\n",
|
|
__arglist(privateName));
|
|
VerboseOut.Print("publicName: {0}\n",
|
|
__arglist(publicName));
|
|
processArgs[2] = privateName;
|
|
|
|
publicServiceProviderNames.Add(privateName, publicName);
|
|
}
|
|
else if (endpoint.Name == GenericEndpointXmlTag) {
|
|
// get a pre-bound generic endpoint to a service from the
|
|
// resource tracker
|
|
created = Binder.BindServiceUser(process, index, contract, endpoint);
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("Invalid tag {0} in Metadata",
|
|
__arglist(endpoint.Name));
|
|
DebugStub.Break();
|
|
}
|
|
|
|
// [TODO] how should we handle errors? Can we do
|
|
// a roll-back?
|
|
if (!created) {
|
|
DebugStub.Break();
|
|
// we might have dangling endpoints and a polluted
|
|
// /hardware namespace
|
|
return false;
|
|
}
|
|
}
|
|
if (extensionIndex == -1) {
|
|
DebugStub.WriteLine("Driver is missing extension endpoint.");
|
|
DebugStub.Break();
|
|
}
|
|
|
|
// Add all endpoints that we created.
|
|
VerboseOut.Print(
|
|
"Activate Device {0} {1} [{2}]\n",
|
|
__arglist(device.location, driver.name, instance)
|
|
);
|
|
|
|
ExtensionContract.Imp! imp;
|
|
ExtensionContract.Exp! exp;
|
|
ExtensionContract.NewChannel(out imp, out exp);
|
|
|
|
Binder.SetEndpoint(process, extensionIndex, exp);
|
|
process.Start();
|
|
|
|
Tracing.Log(Tracing.Audit, "Waiting for driver {0:x8} to init.",
|
|
Kernel.AddressOf(process));
|
|
|
|
bool success = false;
|
|
switch receive {
|
|
case imp.RecvSuccess():
|
|
Tracing.Log(Tracing.Audit, "Driver initialized!");
|
|
success = true;
|
|
break;
|
|
case unsatisfiable:
|
|
Tracing.Log(Tracing.Audit, "Driver failed to initialize!");
|
|
break;
|
|
}
|
|
|
|
if (success) {
|
|
channel = new TRef<ExtensionContract.Imp:Ready>(imp);
|
|
}
|
|
else {
|
|
delete imp;
|
|
}
|
|
|
|
// update the public namespace
|
|
foreach (DictionaryEntry de in publicServiceProviderNames) {
|
|
string! privateName = (!)(de.Key as string);
|
|
string! publicName = (!)(de.Value as string);
|
|
Binder.CreatePublicSymlink(publicName, privateName);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Driver encapsulates known device drivers.
|
|
internal class Driver
|
|
{
|
|
// Instance fields:
|
|
/// <summary>
|
|
/// Friendly name used in debugging.
|
|
/// This comes from the Name property of the System.Type instance.
|
|
/// </summary>
|
|
public readonly String! name;
|
|
|
|
/// <summary>
|
|
/// The PNP device ID (hardware, model, class, etc.) that this device driver definition binds to.
|
|
/// </summary>
|
|
public readonly String! pnpSignature;
|
|
|
|
/// <summary>
|
|
/// root node in directory.
|
|
/// </summary>
|
|
public readonly String! directoryRoot;
|
|
|
|
/// <summary>
|
|
/// The XML metadata for this driver. -XXX- Which element?
|
|
/// </summary>
|
|
public readonly XmlNode! metadata;
|
|
|
|
/// <summary>
|
|
/// Creation delegate for internal (in-kernel) drivers.
|
|
/// </summary>
|
|
public readonly IoDeviceCreate factory;
|
|
|
|
/// <summary>
|
|
/// The binary / image path for the executable.
|
|
/// This field is only non-null for process drivers (not in-kernel drivers).
|
|
/// </summary>
|
|
public readonly String imagePath;
|
|
|
|
public override string! ToString()
|
|
{
|
|
if (factory != null)
|
|
return "<kernel driver '" + this.name + "'>";
|
|
if (imagePath != null)
|
|
return "<process driver '" + this.name + "' image=" + this.imagePath + "'>";
|
|
return "<hal driver '" + this.name + "'>";
|
|
}
|
|
|
|
/// <summary>
|
|
/// The number of instances of this device driver.
|
|
/// </summary>
|
|
private int instanceCount;
|
|
|
|
// Static fields:
|
|
|
|
/// <summary>
|
|
/// Key: string! PNP device ID
|
|
/// Value: Driver! driver
|
|
///
|
|
/// List of registered drivers. A given driver can be in this list more than once,
|
|
/// if that driver can match more than one device ID.
|
|
/// </summary>
|
|
private static SortedList DriversTable;
|
|
|
|
// Constructor for external drivers.
|
|
private Driver(String! pnpSignature,
|
|
String! directoryRoot,
|
|
String! imagePath,
|
|
XmlNode! metadata)
|
|
{
|
|
this.name = imagePath;
|
|
this.pnpSignature = pnpSignature;
|
|
this.directoryRoot = directoryRoot;
|
|
this.metadata = metadata;
|
|
this.imagePath = imagePath;
|
|
this.factory = null;
|
|
base();
|
|
}
|
|
|
|
// Constructor for internal drivers.
|
|
private Driver(String! pnpSignature,
|
|
String! directoryRoot,
|
|
Type! type,
|
|
IoDeviceCreate! factory,
|
|
XmlNode! metadata)
|
|
{
|
|
this.name = (!)type.Name;
|
|
this.pnpSignature = pnpSignature;
|
|
this.directoryRoot = directoryRoot;
|
|
this.metadata = metadata;
|
|
this.imagePath = null;
|
|
this.factory = factory;
|
|
base();
|
|
}
|
|
|
|
// Constructor for HAL drivers.
|
|
private Driver(String! pnpSignature,
|
|
String! directoryRoot,
|
|
Type! type,
|
|
XmlNode! metadata)
|
|
{
|
|
this.name = (!)type.Name;
|
|
this.pnpSignature = pnpSignature;
|
|
this.directoryRoot = directoryRoot;
|
|
this.metadata = metadata;
|
|
this.imagePath = null;
|
|
this.factory = null;
|
|
base();
|
|
}
|
|
|
|
// Generic helper function for driver registration.
|
|
private static void Add(Driver! driver)
|
|
{
|
|
if (DriversTable == null) {
|
|
DriversTable = new SortedList();
|
|
}
|
|
|
|
string canonical_device_id = GetCanonicalDeviceId(driver.pnpSignature);
|
|
|
|
Driver existingDriver = (Driver)DriversTable[canonical_device_id];
|
|
if (existingDriver != null) {
|
|
DebugStub.WriteLine("WARNING: Two drivers match the same PNP signature!");
|
|
DebugStub.WriteLine(" PNP signature: " + canonical_device_id);
|
|
DebugStub.WriteLine(" Existing driver: " + existingDriver.imagePath);
|
|
DebugStub.WriteLine(" Second driver: " + driver.imagePath);
|
|
DebugStub.WriteLine(" The second driver will be IGNORED.");
|
|
return;
|
|
}
|
|
|
|
DriversTable.Add(canonical_device_id, driver);
|
|
VerboseOut.Print(
|
|
"Adding driver map: device id {0,-25} -> {1}\n",
|
|
__arglist(driver.pnpSignature, driver.ToString())
|
|
);
|
|
}
|
|
|
|
static Driver FindDriverByDeviceId(string! deviceId)
|
|
{
|
|
if (DriversTable == null)
|
|
return null;
|
|
|
|
deviceId = GetCanonicalDeviceId(deviceId);
|
|
Driver driver = (Driver)DriversTable[deviceId];
|
|
return driver;
|
|
}
|
|
|
|
static string! GetCanonicalDeviceId(string! id)
|
|
{
|
|
return id.ToLower();
|
|
}
|
|
|
|
// Register an external driver.
|
|
public static Driver! Register(String! pnpSignature,
|
|
String! directoryRoot,
|
|
String! imagePath,
|
|
XmlNode! metadata)
|
|
{
|
|
Driver! driver
|
|
= new Driver(pnpSignature, directoryRoot, imagePath, metadata);
|
|
Add(driver);
|
|
return driver;
|
|
}
|
|
|
|
// Register an internal driver.
|
|
public static Driver! Register(String! pnpSignature,
|
|
String! directoryRoot,
|
|
Type! type,
|
|
IoDeviceCreate! factory,
|
|
XmlNode! metadata)
|
|
{
|
|
Driver! driver
|
|
= new Driver(pnpSignature, directoryRoot, type, factory, metadata);
|
|
Add(driver);
|
|
return driver;
|
|
}
|
|
|
|
// Register a HAL driver.
|
|
public static Driver! Register(String! pnpSignature,
|
|
String! directoryRoot,
|
|
Type! type,
|
|
XmlNode! metadata)
|
|
{
|
|
Driver! driver
|
|
= new Driver(pnpSignature, directoryRoot, type, metadata);
|
|
Add(driver);
|
|
return driver;
|
|
}
|
|
|
|
// Searches a list of PNP signatures for the best driver (closest match).
|
|
public static Driver FindBest(string[]! deviceIds, out string! matchingDeviceId)
|
|
{
|
|
VerboseOut.Print(
|
|
"Driver.FindBest: checking these signatures: " +
|
|
String.Join(", ", deviceIds) + "\n"
|
|
);
|
|
|
|
foreach (string deviceId in deviceIds)
|
|
{
|
|
assert deviceId != null;
|
|
VerboseOut.Print(
|
|
" checking signature: {0}\n", __arglist(deviceId)
|
|
);
|
|
|
|
Driver driver = FindBest(deviceId);
|
|
if (driver != null) {
|
|
VerboseOut.Print(
|
|
" Found matching driver: {0}\n", __arglist(driver)
|
|
);
|
|
matchingDeviceId = deviceId;
|
|
return driver;
|
|
}
|
|
}
|
|
|
|
matchingDeviceId = "";
|
|
return null;
|
|
}
|
|
|
|
// Find the best driver for this PNP signature via prefix match.
|
|
public static Driver FindBest(string! deviceId)
|
|
{
|
|
Driver driver = FindDriverByDeviceId(deviceId);
|
|
return driver;
|
|
}
|
|
|
|
// Dump the list of know drivers.
|
|
public static void DumpAll()
|
|
{
|
|
if (DriversTable == null) return;
|
|
#if false
|
|
DebugStub.WriteLine("\nDrivers:");
|
|
foreach (Driver driver in DriversTable.Values) {
|
|
if (driver == null)
|
|
continue;
|
|
DebugStub.WriteLine(" " + driver);
|
|
}
|
|
#endif
|
|
|
|
DebugStub.WriteLine("\nDevice ID mappings:");
|
|
foreach (DictionaryEntry entry in DriversTable) {
|
|
string! deviceId = (string)entry.Key;
|
|
Driver! driver = (!)(Driver)entry.Value;
|
|
DebugStub.WriteLine(" {0,-36} -> {1}", __arglist(deviceId, driver.name));
|
|
}
|
|
|
|
DebugStub.WriteLine("");
|
|
|
|
|
|
Tracing.Log(Tracing.Audit, "Drivers:");
|
|
foreach (Driver driver in DriversTable.Values) {
|
|
if (driver == null)
|
|
continue;
|
|
Tracing.Log(Tracing.Audit, "{0}:{1}", driver.pnpSignature, driver.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
// DeviceNodes are the single mechanism for initializing device drivers.
|
|
// DeviceNodes will never be fully populated, but once certain fields are
|
|
// populated correctly, the DeviceNode can move into a new list, signifying
|
|
// that it has moved into a new state of execution
|
|
internal class DeviceNode
|
|
{
|
|
public readonly String! location; // location on a bus
|
|
|
|
// This is the hardware ID (PNP signature) that we actually matched when
|
|
// locating a device driver. This value is null if we have not associated
|
|
// a function driver.
|
|
public string MatchingDeviceId;
|
|
|
|
public readonly IoConfig! config; // Io resource container
|
|
|
|
public Driver driver; // associated device driver
|
|
public ExtensionDevice extdev; // external device.
|
|
public IDevice intdev; // internal device.
|
|
public String directoryRoot; // in the /Hardware namespace
|
|
public int startOrder; // > zero when activated
|
|
|
|
public static int lastStartOrder;
|
|
|
|
public DeviceNode(String! location, String! matchingDeviceId, IoConfig! config)
|
|
{
|
|
this.location = location;
|
|
this.MatchingDeviceId = matchingDeviceId;
|
|
this.config = config;
|
|
this.startOrder = -1;
|
|
base();
|
|
}
|
|
|
|
public override string! ToString()
|
|
{
|
|
if (MatchingDeviceId != null) {
|
|
return "[Device: location='" + this.location + "' MatchingDeviceId='" + this.MatchingDeviceId + "']";
|
|
} else {
|
|
return "[Device: location='" + this.location + " (not associated)]";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[CLSCompliant(false)]
|
|
public class IoSystem
|
|
{
|
|
//
|
|
// consts for accessing Xml tags and attributes
|
|
//
|
|
|
|
// tags describing the IoSystem config xml tree
|
|
public const string DriverRegistrationXmlTag = "driver";
|
|
public const string DriverNameXmlAttribute = "name";
|
|
public const string DeviceSignatureXmlAttribute = "signature";
|
|
public const string DriverPathXmlAttribute = "path";
|
|
public const string DriverClassXmlAttribute = "class";
|
|
|
|
// endpoint tags:
|
|
public const string EndpointSetXmlTag = "endpoints";
|
|
public const string ServiceEndpointXmlTag = "serviceProvider";
|
|
public const string ExtensionEndpointXmlTag = "extension";
|
|
public const string GenericEndpointXmlTag = "endpoint";
|
|
public const string ContractXmlAttribute = "contractName";
|
|
public const string EndpointEndXmlAttribute = "endpointEnd";
|
|
|
|
// Io resource tags
|
|
public const string FixedHardwareSetXmlTag = "fixedHardware";
|
|
public const string DynamicHardwareSetXmlTag = "dynamicHardware";
|
|
public const string PortRangeXmlTag = "ioPortRange";
|
|
public const string DmaRangeXmlTag = "ioDmaRange";
|
|
public const string IrqRangeXmlTag = "ioIrqRange";
|
|
public const string MemoryRangeXmlTag = "ioMemoryRange";
|
|
public const string AddressBitsXmlAttribute = "addressBits";
|
|
public const string AlignmentXmlAttribute = "alignment";
|
|
public const string BaseAddressXmlAttribute = "baseAddress";
|
|
public const string RangeLengthXmlAttribute = "rangeLength";
|
|
public const string ReadableXmlAttribute = "allowRead";
|
|
public const string WritableXmlAttribute = "allowWrite";
|
|
public const string SharedXmlAttribute = "shared";
|
|
public const string IndexXmlAttribute = "id";
|
|
|
|
// follows/provides tags
|
|
public const string FollowsXmlTag = "follows";
|
|
public const string ProvidesXmlTag = "provides";
|
|
public const string FollowsNameXmlAttribute = "name";
|
|
|
|
// xml config for the IoSystem
|
|
private static XmlNode! config;
|
|
|
|
// a device instance consists (full signature, Dynamic IoConfig,
|
|
// location) and is created only during device enumeration.
|
|
private static SortedList! instances;
|
|
|
|
// when a device instance is matched to a driver, we have an
|
|
// association. This is an activatable object, if its dependencies
|
|
// are met.
|
|
private static SortedList! associations;
|
|
|
|
// an instance that is successfully paired with a driver becomes
|
|
// an activatable entity. Upon activation, it moves into this list.
|
|
private static SortedList! activations;
|
|
|
|
// the entire "follows" tracking can be handled with one SortedList
|
|
private static SortedList! followsList;
|
|
|
|
// to speed up LoadImage we need to cache a ref to the directory service root
|
|
// this is initialized in InitializeDirectoryService and used in FindFileImage
|
|
// and FindManifest
|
|
private static TRef<DirectoryServiceContract.Imp:Start> nsRootRef;
|
|
|
|
// In order to have unified accounting even for devices who do not have
|
|
// a Pnp signature (such as the hal console), we need a private,
|
|
// concrete IoConfig object
|
|
private class FixedIoConfig : IoConfig
|
|
{
|
|
public FixedIoConfig (string[] ids)
|
|
{
|
|
this.Ids = ids;
|
|
this.DynamicRanges = new IoRange[0];
|
|
this.FixedRanges = new IoRange[0];
|
|
}
|
|
|
|
public override string ToPrint()
|
|
{
|
|
return String.Join(",", this.Ids);
|
|
}
|
|
}
|
|
|
|
private static void StartProcess(string! name,
|
|
string! executable)
|
|
{
|
|
Process process = null;
|
|
Manifest manifest;
|
|
|
|
IoMemory memory = Binder.LoadImage(Thread.CurrentProcess,
|
|
executable,
|
|
out manifest);
|
|
|
|
if (memory != null && memory.Length > 0 && manifest != null) {
|
|
process = new Process(Thread.CurrentProcess,
|
|
memory,
|
|
null,
|
|
new string[1] {name},
|
|
manifest);
|
|
if (process != null) {
|
|
VerboseOut.Print("I/O: Starting {0} process\n",
|
|
__arglist(name));
|
|
process.Start();
|
|
}
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("I/O: unable to find {0}",
|
|
__arglist(executable));
|
|
}
|
|
}
|
|
|
|
// VolumeManager initialization should be managed just
|
|
// like drivers, but currently isn't
|
|
public static void InitializeVolumeManager()
|
|
{
|
|
StartProcess("volmgr", "volmgr.x86");
|
|
}
|
|
|
|
|
|
// This configuration should move to DirectoryService.Initialize() and should
|
|
// involve xml
|
|
public static void InitializeDirectoryService()
|
|
{
|
|
// initialize IoMemory FileSystem
|
|
IoMemoryFS ioFS = new IoMemoryFS();
|
|
IoMemFSContract.Imp fsImp = ioFS.Start();
|
|
if (fsImp != null) {
|
|
Directory.DirectoryService.SetIoFS(fsImp);
|
|
}
|
|
// create "/dev" namespace and link it into the root
|
|
#if true
|
|
DirectoryServiceContract.Imp! rootNS = DirectoryService.NewClientEndpoint();
|
|
|
|
DirectoryServiceContract.Imp! dirImp;
|
|
DirectoryServiceContract.Exp! dirExp;
|
|
DirectoryServiceContract.NewChannel(out dirImp, out dirExp);
|
|
rootNS.SendBind((!)Bitter.FromString("/"), dirExp);
|
|
|
|
switch receive {
|
|
case rootNS.NakBind(rejected, error):
|
|
delete rejected;
|
|
DebugStub.Break();
|
|
break;
|
|
case rootNS.AckBind():
|
|
break;
|
|
}
|
|
|
|
dirImp.RecvSuccess();
|
|
nsRootRef = new TRef<DirectoryServiceContract.Imp:Start> (rootNS);
|
|
|
|
dirImp.SendCreateDirectory((!)Bitter.FromString("dev"));
|
|
switch receive {
|
|
case dirImp.AckCreateDirectory() :
|
|
break;
|
|
case dirImp.NakCreateDirectory(error) :
|
|
DebugStub.Break();
|
|
break;
|
|
}
|
|
|
|
delete dirImp;
|
|
#endif
|
|
}
|
|
|
|
public static unsafe void InitializeServiceManager(XmlNode !config)
|
|
{
|
|
const string Name = "sms";
|
|
const string Executable = "sms.x86";
|
|
|
|
|
|
ArrayList args = new ArrayList();
|
|
|
|
args.Add(Name);
|
|
|
|
if (config != null) {
|
|
foreach (XmlNode! service in config.Children) {
|
|
if (service.Name != "service") {
|
|
continue;
|
|
}
|
|
|
|
// Should be separated to avoid type ambiguity.
|
|
string name = service.GetAttribute("name", "");
|
|
string binary = service.GetAttribute("binary", "");
|
|
string option = service.GetAttribute("mode", "managed");
|
|
args.Add(name);
|
|
args.Add(binary);
|
|
args.Add(option);
|
|
|
|
DebugStub.Print("SMS: Found " + name +
|
|
"(" + binary + ": " + option + ")\n");
|
|
}
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("SMS:No Configuration");
|
|
}
|
|
|
|
String [] stringArgs = (string []) args.ToArray(typeof(string));
|
|
Process process = null;
|
|
Manifest manifest = null;
|
|
|
|
IoMemory memory = Binder.LoadImage(Thread.CurrentProcess,
|
|
Executable,
|
|
out manifest);
|
|
|
|
if (memory != null && memory.Length > 0 && manifest != null) {
|
|
DirectoryServiceContract.Imp! ds = DirectoryService.NewClientEndpoint();
|
|
if (ds == null) {
|
|
DebugStub.Break();
|
|
}
|
|
|
|
process = new Process(Thread.CurrentProcess,
|
|
memory,
|
|
null,
|
|
stringArgs,
|
|
manifest);
|
|
if (process != null) {
|
|
SharedHeap.Allocation *ep = (SharedHeap.Allocation *)ds;
|
|
|
|
process.SetEndpointCount(1);
|
|
process.SetEndpoint(0, ref ep);
|
|
DebugStub.WriteLine("Starting SMS");
|
|
process.Start();
|
|
}
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("Unable to find {0}",
|
|
__arglist(Executable));
|
|
DebugStub.Break();
|
|
}
|
|
}
|
|
// initialize all variables
|
|
static public void Initialize(XmlNode! _config)
|
|
{
|
|
Tracing.Log(Tracing.Debug, "IoSystem.Initialize()");
|
|
|
|
// store the xml config:
|
|
// don't store the nsConfig, since we don't use it locally
|
|
config = _config;
|
|
|
|
// create all lists
|
|
instances = new SortedList();
|
|
activations = new SortedList();
|
|
associations = new SortedList();
|
|
followsList = new SortedList();
|
|
|
|
// initialize the resource tracker.
|
|
ResourceTracker.Initialize();
|
|
|
|
Tracing.Log(Tracing.Debug, "IoSystem.Initialized");
|
|
}
|
|
|
|
public static void Finalize()
|
|
{
|
|
Tracing.Log(Tracing.Debug, "IoSystem.Finalize()");
|
|
FinalizeOldDevices();
|
|
}
|
|
|
|
public static byte GetMaximumIrq()
|
|
{
|
|
return HalDevices.GetMaximumIrq();
|
|
}
|
|
|
|
// all sorted tracking is handled here:
|
|
// check if a follows name has been provided yet
|
|
public static bool CheckFollows(string followName)
|
|
{
|
|
return followsList.ContainsKey(followName);
|
|
}
|
|
|
|
// mark a follows name as being provided
|
|
public static void SetFollows(string! followName)
|
|
{
|
|
if (!followsList.ContainsKey(followName)) {
|
|
followsList.Add(followName, followName);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Device Management Code: The kernel has 2 stages of device management.
|
|
//
|
|
// Stage 1: there are no interrupts, and the Hal isn't even started.
|
|
//
|
|
// In this stage, we use Drivers\register.cs to create a pnpbus,
|
|
// and then we pass it to a custom method in IoSystem which
|
|
// associates and activates the bus (the bus is not a process).
|
|
// Then we start the Hal, and we use another custom method to
|
|
// simulate association and activation of the hal devices (in this
|
|
// case, we don't actually activate, we just mark the devices as
|
|
// activated and give their resources to the Hal)
|
|
//
|
|
// Stage 2: we can run any process whose dependencies are satisfied.
|
|
//
|
|
// In this stage, we can start any driver, and so we use general
|
|
// mechanisms. We also pre-bind endpoints and generally do our
|
|
// best to make everything nice and clean. There is a hack in here
|
|
// to let us register the drivers who haven't migrated to separate
|
|
// processes.
|
|
|
|
// Parse the driverRegistry metadata to register drivers.
|
|
public static void RegisterDrivers()
|
|
{
|
|
foreach (XmlNode! driver in config.Children) {
|
|
if (driver.Name != DriverRegistrationXmlTag) {
|
|
continue;
|
|
}
|
|
string! drivername
|
|
= (!)driver.GetAttribute(DriverNameXmlAttribute, "");
|
|
string! image
|
|
= (!)driver.GetAttribute(DriverPathXmlAttribute, "");
|
|
string! signature
|
|
= (!)driver.GetAttribute(DeviceSignatureXmlAttribute, "");
|
|
|
|
// add the driver to /hardware/drivers
|
|
drivername = "/hardware/drivers/" + drivername;
|
|
DirNode! driverNode = (!)DirectoryService.FindDirectory(drivername,
|
|
true);
|
|
|
|
// if this is an external driver, create a symlink for the
|
|
// executable image of the driver. Since this is at boot
|
|
// time, we know the image should go to /init
|
|
if (image != "") {
|
|
// we only work with .x86 images for now:
|
|
if (image.EndsWith(".x86")) {
|
|
image = "/init/" + image.Remove(image.Length-4, 4);
|
|
DirectoryService.CreateSymbolicLink(driverNode, "image",
|
|
image);
|
|
}
|
|
}
|
|
|
|
// [TODO] - if there is no device signature, what
|
|
// should we do? We need some way to register the volume
|
|
// manager.
|
|
if (signature != "") {
|
|
if (image != "") {
|
|
Driver.Register(signature, drivername, image, driver);
|
|
}
|
|
// add the device to /hardware/registrations
|
|
string! registration_path;
|
|
if (signature.StartsWith("/"))
|
|
registration_path = "/hardware/registrations" + signature;
|
|
else
|
|
registration_path = "/hardware/registrations/" + signature;
|
|
DirNode! deviceNode =
|
|
(!)DirectoryService.FindDirectory(registration_path, true);
|
|
// create a symlink to the driver
|
|
DirectoryService.CreateSymbolicLink(deviceNode, "driver",
|
|
drivername);
|
|
}
|
|
}
|
|
}
|
|
|
|
// There are a few devices that aren't processes but who don't start
|
|
// until after interrupts are up. Once all drivers become processes,
|
|
// this should go away.
|
|
// The key problem is that we haven't figured out, yet, how
|
|
// to move bus drivers out of the kernel.
|
|
public static bool RegisterKernelDriver(Type type,
|
|
IoDeviceCreate creator)
|
|
{
|
|
string iclass = ((!)type).FullName;
|
|
VerboseOut.Print(" Registering class: {0}\n",
|
|
__arglist(iclass));
|
|
|
|
// Find any signatures in the metadata for this class.
|
|
bool match = false;
|
|
foreach (XmlNode! driver in config.Children) {
|
|
if (driver.Name != DriverRegistrationXmlTag) {
|
|
continue;
|
|
}
|
|
|
|
string mclass = driver.GetAttribute(DriverClassXmlAttribute, "");
|
|
if (mclass != iclass) {
|
|
continue;
|
|
}
|
|
|
|
match = true;
|
|
string! signature = (!)driver.GetAttribute(DeviceSignatureXmlAttribute, "");
|
|
VerboseOut.Print(" Registering signature: {0}\n",
|
|
__arglist(signature));
|
|
|
|
string! drivername = "/hardware/drivers/" +
|
|
driver.GetAttribute(DriverNameXmlAttribute, "");
|
|
|
|
// Caution: we already added this to /hardware during the general
|
|
// registration process, but we need to give this node its name in
|
|
// /hardware
|
|
Driver.Register(signature, drivername, type, (!)creator, driver);
|
|
}
|
|
|
|
if (!match) {
|
|
DebugStub.WriteLine("Error: No metadata for class {0}",
|
|
__arglist(iclass));
|
|
DebugStub.Break();
|
|
}
|
|
return match;
|
|
}
|
|
|
|
|
|
// given a piece of metadata, generate an IoRange array
|
|
// the input is the <fixedHardware> or <dynamicHardware> node of a
|
|
// registered device's metadata
|
|
private static IoRange[] CreateIoRangesFromMetadata(XmlNode resources)
|
|
{
|
|
if (resources == null) {
|
|
return new IoRange[0];
|
|
}
|
|
|
|
// see if there are any resources in the metadata
|
|
int numitems = resources.GetAttribute("length", 0);
|
|
|
|
// Create all of the fixed resources in one IoRange array
|
|
IoRange[] ranges = new IoRange[numitems];
|
|
int i = 0;
|
|
foreach (XmlNode! res in resources.Children) {
|
|
if (res.Name == PortRangeXmlTag) {
|
|
ushort fixedBase
|
|
= (ushort)res.GetAttribute(BaseAddressXmlAttribute, 0);
|
|
ushort fixedSize
|
|
= (ushort)res.GetAttribute(RangeLengthXmlAttribute, 0);
|
|
bool read = res.GetAttribute(ReadableXmlAttribute, true);
|
|
bool write = res.GetAttribute(WritableXmlAttribute, true);
|
|
|
|
ranges[i++] = new IoPortRange(fixedBase, fixedSize,
|
|
read, write);
|
|
}
|
|
else if (res.Name == IrqRangeXmlTag) {
|
|
byte fixedBase
|
|
= (byte)res.GetAttribute(BaseAddressXmlAttribute, 0);
|
|
byte fixedSize
|
|
= (byte)res.GetAttribute(RangeLengthXmlAttribute, 1);
|
|
ranges[i++] = new IoIrqRange(fixedBase, fixedSize);
|
|
}
|
|
else if (res.Name == DmaRangeXmlTag) {
|
|
byte fixedBase
|
|
= (byte)res.GetAttribute(BaseAddressXmlAttribute, 0);
|
|
byte fixedSize
|
|
= (byte)res.GetAttribute(RangeLengthXmlAttribute, 1);
|
|
|
|
ranges[i++] = new IoDmaRange(fixedBase, fixedSize);
|
|
}
|
|
else if (res.Name == MemoryRangeXmlTag) {
|
|
UIntPtr fixedBase
|
|
= res.GetAttributeAsUIntPtr(BaseAddressXmlAttribute, 0);
|
|
UIntPtr fixedSize
|
|
= res.GetAttributeAsUIntPtr(RangeLengthXmlAttribute, 0);
|
|
byte addressBits
|
|
= (byte)res.GetAttribute(AddressBitsXmlAttribute, 24);
|
|
UIntPtr alignment
|
|
= res.GetAttributeAsUIntPtr(AlignmentXmlAttribute, 4);
|
|
|
|
bool read = res.GetAttribute(ReadableXmlAttribute, true);
|
|
bool write = res.GetAttribute(WritableXmlAttribute, true);
|
|
|
|
if (fixedBase == 0) {
|
|
IoMemory mem = null;
|
|
|
|
// [TODO] This only supports 24-bit addressing right
|
|
// now. We need support for the rest of the possible regions
|
|
// eventually
|
|
if (addressBits == 24) {
|
|
mem = IoMemory.AllocatePhysBelow16MB(fixedSize, alignment);
|
|
}
|
|
if (mem == null) {
|
|
DebugStub.WriteLine("Failed for addressBits={0}",
|
|
__arglist(addressBits));
|
|
DebugStub.Break();
|
|
continue;
|
|
}
|
|
DebugStub.Assert(mem.PhysicalAddress.Value != 0);
|
|
ranges[i++] = new IoMemoryRange((UIntPtr)mem.PhysicalAddress.Value,
|
|
(UIntPtr)mem.Length,
|
|
read, write);
|
|
}
|
|
else {
|
|
ranges[i++] = new IoMemoryRange(fixedBase, fixedSize,
|
|
read, write);
|
|
}
|
|
}
|
|
else {
|
|
// this should never happen
|
|
i++;
|
|
DebugStub.Break();
|
|
}
|
|
}
|
|
return ranges;
|
|
}
|
|
|
|
// The root device does not have a Pnp configuration via enumeration,
|
|
// which is why we require the devConfig parameter. Also, we need to
|
|
// enumerate the root before we can start the Hal, but we don't want to
|
|
// let anything else start running yet (since there is no threading yet)
|
|
public static void AddRootDevice(String! path,
|
|
IBusDevice! bus,
|
|
IoConfig! config)
|
|
{
|
|
String! signature = "/root" + path;
|
|
|
|
// Simulate association: we don't have a true registered driver.
|
|
XmlNode metadata = GetMetaData(signature);
|
|
if (metadata == null) {
|
|
DebugStub.WriteLine("No configuration found for root device {0}\n",
|
|
__arglist(path));
|
|
DebugStub.Break();
|
|
return;
|
|
}
|
|
if (!ResourceTracker.AreResourcesValid(config, metadata)) {
|
|
DebugStub.WriteLine("Invalid configuration for root device {0}\n",
|
|
__arglist(path));
|
|
DebugStub.Break();
|
|
return;
|
|
}
|
|
|
|
Driver! driver = Driver.Register(signature,
|
|
path,
|
|
bus.GetType(),
|
|
metadata);
|
|
|
|
// create a device instance of the root:
|
|
DeviceNode! device = new DeviceNode(path, signature, config);
|
|
|
|
// Simulate activation: we don't need to make an
|
|
// IDevice because we already have one
|
|
device.driver = driver;
|
|
device.intdev = bus;
|
|
|
|
// make sure the resources are available, and claim them.
|
|
VerboseOut.Print("AddRootDevice Device: {0}\n",
|
|
__arglist(path));
|
|
if (ResourceTracker.FindResourceConflicts(device) == null) {
|
|
ResourceTracker.AddResources(device);
|
|
}
|
|
else {
|
|
// somehow the needed root resources are unavailable.
|
|
DebugStub.Break();
|
|
return;
|
|
}
|
|
|
|
// Manually initialize the root bus, but don't
|
|
// associate devices we find
|
|
VerboseOut.Print("Activate root device {0} {1}\n",
|
|
__arglist(device.location,
|
|
device.driver.name)
|
|
);
|
|
bus.Initialize();
|
|
EnumerateDevice(bus, device.location, false);
|
|
}
|
|
|
|
static DeviceNode FindSingletonDeviceBySignature(string! signature)
|
|
{
|
|
DeviceNode device;
|
|
if (signature == "") {
|
|
string[]! ids = { "" };
|
|
FixedIoConfig! config = new FixedIoConfig(ids);
|
|
device = new DeviceNode("/hal0", signature, config);
|
|
return device;
|
|
} else {
|
|
device = null;
|
|
|
|
foreach (DictionaryEntry de in instances) {
|
|
DeviceNode! node = (DeviceNode!) de.Value;
|
|
foreach (string sig in node.config.Ids) {
|
|
if (sig == signature) {
|
|
if (device != null) {
|
|
DebugStub.WriteLine("WARNING! Found more than one device with signature '" + signature + "' while searching for singleton device!");
|
|
continue;
|
|
}
|
|
device = node;
|
|
// break;
|
|
}
|
|
}
|
|
|
|
// Keep looping so we can find duplicates.
|
|
// This is just for debugging / paranoia.
|
|
//if (device != null)
|
|
// break;
|
|
}
|
|
|
|
return device;
|
|
}
|
|
}
|
|
|
|
bool PnpSignaturesAreEqual(string! sig1, string! sig2)
|
|
{
|
|
return String.Compare(sig1, sig2, true) == 0;
|
|
}
|
|
|
|
// The Hal activates its own devices, but we need to do the accounting
|
|
// for them and move them from instances to activations.
|
|
// NB - for the hal screen resources, the signature will be ""
|
|
public static IoConfig YieldResources(string! signature, Type! type)
|
|
{
|
|
// do pseudo-registration by getting metadata directly
|
|
XmlNode metadata = GetMetaData(signature);
|
|
if (metadata == null) {
|
|
DebugStub.WriteLine("IoSystem.YieldResources: Failed to find driver metadata for signature: " + signature);
|
|
DebugStub.Break(); // Couldn't find info in manifest!
|
|
return null;
|
|
}
|
|
|
|
string path = (signature == "") ? "/hal0" : ("/hardware/drivers" + signature);
|
|
|
|
Driver! driver = Driver.Register(signature,
|
|
path,
|
|
type,
|
|
metadata);
|
|
|
|
// first get a device instance (or if signature=="", create an
|
|
// instance with an empty IoConfig)
|
|
DeviceNode device = FindSingletonDeviceBySignature(signature);
|
|
if (device == null) {
|
|
DebugStub.WriteLine("IoSystem.YieldResources: Failed to find singleton device node for PNP signature: " + signature);
|
|
DebugStub.Break();
|
|
for (;;) {
|
|
FindSingletonDeviceBySignature(signature);
|
|
}
|
|
return null; // Couldn't find hardware.
|
|
}
|
|
|
|
device.driver = driver;
|
|
|
|
// use the XML to get fixed resources
|
|
XmlNode fixedResNode
|
|
= driver.metadata.GetChild(FixedHardwareSetXmlTag);
|
|
device.config.FixedRanges
|
|
= CreateIoRangesFromMetadata(fixedResNode);
|
|
|
|
// This device is now associated. Now do all of the
|
|
// accounting, but don't activate it
|
|
VerboseOut.WriteLine("YieldResources Signature: {0}",
|
|
__arglist(signature));
|
|
|
|
if (ResourceTracker.AreResourcesValid(device.config, metadata) &&
|
|
ResourceTracker.FindResourceConflicts(device) == null) {
|
|
ResourceTracker.AddResources(device);
|
|
}
|
|
else {
|
|
// somehow the resources the Hal needs have already been taken!
|
|
DebugStub.Break();
|
|
return null;
|
|
}
|
|
|
|
// now move the device from instances to activations and return the
|
|
// dynamic config
|
|
VerboseOut.WriteLine("YieldResources Remove({0})",
|
|
__arglist(device.location));
|
|
instances.Remove(device.location);
|
|
activations.Add(device.location, device);
|
|
return device.config;
|
|
}
|
|
|
|
//
|
|
// Irq Rerouting code - this lets us keep our accounting clean when
|
|
// kernel-only devices reroute IRQs
|
|
//
|
|
|
|
// [TODO] if multiple devices exist, all of whom have the same
|
|
// Id, this is going to break. How can we fix it? The caller doesn't
|
|
// understand hardware locations, so the problem is his, but this code
|
|
// suffers from his lack of information
|
|
|
|
// Public hook for well-behaved devices that reroute IRQs to request
|
|
// permission before doing the rerouting. This has the side effect of
|
|
// updating the ResourceTracker with the new IoIrqRange values
|
|
public static bool RequestRerouteIrq(string name, int irqNum,
|
|
byte irqVal)
|
|
{
|
|
// In order to allow a rerouting, two conditions must be met
|
|
// 1 - the device "name" must not be in activations
|
|
// 2 - there must be an irqNum'th IoIrq object
|
|
foreach (DictionaryEntry de in instances) {
|
|
DeviceNode! device = (DeviceNode!) de.Value;
|
|
if (device.MatchingDeviceId == name) {
|
|
return RerouteIrq(device, irqNum, irqVal);
|
|
}
|
|
}
|
|
|
|
foreach (DictionaryEntry de in associations) {
|
|
DeviceNode! device = (DeviceNode!) de.Value;
|
|
if (device.MatchingDeviceId == name) {
|
|
return RerouteIrq(device, irqNum, irqVal);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// private code that actually changes the IoConfig object
|
|
private static bool RerouteIrq(DeviceNode! device, int irqNum,
|
|
byte irqVal)
|
|
{
|
|
int irqCounter = 0;
|
|
int targetPosition = -1;
|
|
IoRange[] ranges = device.config.DynamicRanges;
|
|
|
|
for (int i = 0; i < ranges.Length; i++) {
|
|
if (device.config.DynamicRanges[i] is IoIrqRange) {
|
|
irqCounter++;
|
|
}
|
|
if (irqCounter == irqNum) {
|
|
targetPosition = i;
|
|
break;
|
|
}
|
|
}
|
|
if (targetPosition == -1) {
|
|
return false;
|
|
}
|
|
|
|
ranges[targetPosition] = new IoIrqRange(irqVal, 1);
|
|
return true;
|
|
}
|
|
|
|
// Enumerate an IBusDevice (create instances):
|
|
// - Find devices and add them to the devices list
|
|
// - Add each device to the /hardware namespace
|
|
//
|
|
// NB: When we get rid of non-process drivers, then this will only be
|
|
// used by the root device; all other buses will be separate processes
|
|
// who will announce new config to the IoSystem over a channel
|
|
public static bool EnumerateDevice(IBusDevice! bus, string busLocation,
|
|
bool associate)
|
|
{
|
|
Tracing.Log(Tracing.Debug, "Enumerating Bus");
|
|
|
|
SortedList found = bus.Enumerate();
|
|
|
|
if (found != null) {
|
|
foreach (DictionaryEntry n in found) {
|
|
// get the IoConfig for this device
|
|
IoConfig! config = (IoConfig!)n.Value;
|
|
|
|
// set the IoConfig's FixedRange to an empty list
|
|
config.FixedRanges = new IoRange[0];
|
|
|
|
assume config.Ids != null;
|
|
|
|
// now set up the /hardware namespace
|
|
string! location = busLocation + n.Key;
|
|
string! device = (!)config.Ids[0];
|
|
// -XXX- Need to do something smarter, now that we support lists of IDs.
|
|
|
|
// create a DeviceNode for this device
|
|
DeviceNode! node = new DeviceNode(location, device, config);
|
|
|
|
// add this location and device to the /hardware tree
|
|
location = JoinForwardSlashPath("/hardware/locations", location);
|
|
DirNode locationNode = DirectoryService.FindDirectory(location, true);
|
|
|
|
// This needs to be reconsidered. What's the point of registering the
|
|
// device ID, now that doing so is ambiguous? We'll register the first
|
|
// device ID, anyway, until we figure this out.
|
|
string! hardware_devices_path = JoinForwardSlashPath("/hardware/devices", device);
|
|
DirNode deviceNode = DirectoryService.FindDirectory(hardware_devices_path, true);
|
|
|
|
// create a device instance in the namespace:
|
|
string instname;
|
|
for (int i = 0;; i++) { // find next available instance num
|
|
instname = hardware_devices_path + "/instance" + i.ToString();
|
|
if (DirectoryService.FindDirectory(instname, false) == null) {
|
|
break;
|
|
}
|
|
}
|
|
deviceNode = DirectoryService.FindDirectory(instname, true);
|
|
|
|
// symlink the instance and location
|
|
DirectoryService.CreateSymbolicLink(locationNode, "device",
|
|
instname);
|
|
DirectoryService.CreateSymbolicLink(deviceNode, "location",
|
|
location);
|
|
|
|
node.directoryRoot = instname;
|
|
|
|
// try to associate the instance, and if we can't, then put
|
|
// it in the instance list:
|
|
if (!associate || !Associate(node)) {
|
|
instances.Add(node.location, node);
|
|
}
|
|
}
|
|
}
|
|
return (found != null);
|
|
}
|
|
|
|
static string! JoinForwardSlashPath(string! container, string! path)
|
|
{
|
|
bool container_ends_with_slash = container.EndsWith("/");
|
|
bool path_starts_with_slash = path.StartsWith("/");
|
|
|
|
if (container_ends_with_slash && path_starts_with_slash)
|
|
return container + path.Substring(1, path.Length - 1);
|
|
|
|
if (!container_ends_with_slash && !path_starts_with_slash)
|
|
return container + "/" + path;
|
|
|
|
return container + path;
|
|
}
|
|
|
|
// the association step does not care about dependencies and does not
|
|
// touch the namespace. All it does is resolve an instance of a device
|
|
// with the appropriate registration of a driver for that device, and
|
|
// creates the fixed Io resources:
|
|
private static bool Associate(DeviceNode! device)
|
|
{
|
|
string! matchingDeviceId;
|
|
Driver driver = Driver.FindBest(device.config.Ids, out matchingDeviceId);
|
|
if (driver == null) {
|
|
VerboseOut.WriteLine("{0}: no driver found for this device.",
|
|
__arglist(device.location));
|
|
VerboseOut.Print(device.config.ToPrint());
|
|
return false;
|
|
}
|
|
|
|
if (driver.factory == null && driver.imagePath == null) {
|
|
DebugStub.WriteLine("Error: Attempt to associate HAL driver {0} with {1} ",
|
|
__arglist(driver.name,
|
|
device.location));
|
|
DebugStub.Break();
|
|
return false;
|
|
}
|
|
|
|
VerboseOut.WriteLine(
|
|
"{0}: now associated with driver {1}, on device id {2}",
|
|
__arglist(device.location, driver.name, matchingDeviceId)
|
|
);
|
|
|
|
// now attached the driver.
|
|
device.driver = driver;
|
|
device.MatchingDeviceId = matchingDeviceId;
|
|
|
|
// create the fixed config.
|
|
XmlNode fixedResNode
|
|
= driver.metadata.GetChild(FixedHardwareSetXmlTag);
|
|
device.config.FixedRanges
|
|
= CreateIoRangesFromMetadata(fixedResNode);
|
|
|
|
// if the hardware resources are available, copy the device to associations
|
|
if (!ResourceTracker.AreResourcesValid(device.config, driver.metadata)) {
|
|
DebugStub.WriteLine("Error: Can't associate a device without resources.");
|
|
DebugStub.Break();
|
|
return false;
|
|
}
|
|
|
|
VerboseOut.WriteLine(device.location +
|
|
": Device associated -> driver "
|
|
+ driver.name + " using signature " +
|
|
matchingDeviceId);
|
|
|
|
associations.Add(device.location, device);
|
|
return true;
|
|
}
|
|
|
|
// The root bus and hal need to be associated before the registration
|
|
// list is ready. Use this method to associate directly from Xml.
|
|
private static XmlNode GetMetaData(String! pnpSignature)
|
|
{
|
|
// a matched driver must not have an image (that is, it shouldn't be
|
|
// an external driver). Otherwise, anything that matches is good:
|
|
|
|
int bestlength = 0;
|
|
XmlNode bestNode = null;
|
|
|
|
// check each driver
|
|
foreach (XmlNode! driver in config.Children) {
|
|
if (driver.Name != DriverRegistrationXmlTag) {
|
|
continue;
|
|
}
|
|
string! devicename =
|
|
(!)driver.GetAttribute(DeviceSignatureXmlAttribute, "");
|
|
string! image =
|
|
(!)driver.GetAttribute(DriverPathXmlAttribute, "");
|
|
|
|
if (image == "" &&
|
|
pnpSignature.StartsWith(devicename) &&
|
|
devicename.Length > bestlength) {
|
|
bestNode = driver;
|
|
bestlength = devicename.Length;
|
|
}
|
|
// special code for the Hal console, which has no signature
|
|
else if (image == "" &&
|
|
pnpSignature == "" &&
|
|
devicename == "" &&
|
|
bestlength == 0) {
|
|
bestNode = driver;
|
|
bestlength = 1;
|
|
}
|
|
}
|
|
return bestNode;
|
|
}
|
|
|
|
// check if we can start a driver
|
|
// RequireFollows--> treat "follows" tags as firm requirements
|
|
private static bool CheckDependencies(Driver! driver,
|
|
bool RequireFollows)
|
|
{
|
|
// Check all <follows> rules
|
|
if (RequireFollows) {
|
|
foreach (XmlNode! follows in driver.metadata.Children) {
|
|
if (follows.Name != FollowsXmlTag) {
|
|
continue;
|
|
}
|
|
|
|
string tagName =
|
|
follows.GetAttribute(FollowsNameXmlAttribute, "");
|
|
if (!CheckFollows(tagName)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure that ServiceProvider endpoint names aren't exhausted,
|
|
// and that the ServiceContracts are satisfiable
|
|
XmlNode! endpointset
|
|
= (!)driver.metadata.GetChild(EndpointSetXmlTag);
|
|
foreach (XmlNode! endpoint in endpointset.Children) {
|
|
string contract = endpoint.GetAttribute(
|
|
ContractXmlAttribute, "");
|
|
|
|
if (endpoint.Name == ServiceEndpointXmlTag) {
|
|
if (!Binder.IsServiceContractStartable(contract)) {
|
|
return false;
|
|
}
|
|
}
|
|
else if (endpoint.Name == GenericEndpointXmlTag) {
|
|
if (!Binder.IsServiceContractAvailable(contract)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Return the next device that should be activated, according to the
|
|
// following priority:
|
|
// 1 - if all dependencies of an bus device are satisfied, return it
|
|
// 2 - else return the first device with all dependencies satisfied
|
|
// 3 - else return the first bus device who only lacks "follows"
|
|
// 4 - else return the first device who only lacks "follows"
|
|
// 5 - else return null
|
|
private static DeviceNode GetActivatableDriver()
|
|
{
|
|
DeviceNode device = null;
|
|
DeviceNode busWithoutFollows = null;
|
|
DeviceNode deviceWithoutFollows = null;
|
|
|
|
VerboseOut.Print("GetActivatableDriver:[");
|
|
foreach (DictionaryEntry de in associations) {
|
|
DeviceNode! dev = (DeviceNode!)de.Value;
|
|
VerboseOut.Print(dev.ToString());
|
|
VerboseOut.Print(" ");
|
|
}
|
|
VerboseOut.Print("] ");
|
|
|
|
// we need only look in the associations list, as it holds the only
|
|
// device instances that are matched to drivers:
|
|
foreach (DictionaryEntry de in associations) {
|
|
DeviceNode! dev = (DeviceNode!) de.Value;
|
|
|
|
// device has already been associated
|
|
assert dev.driver != null;
|
|
assert dev.MatchingDeviceId != null;
|
|
|
|
Driver! driver = dev.driver;
|
|
|
|
// First do the hard test - all <follows> must be satisfied
|
|
if (CheckDependencies(driver, true)) {
|
|
// prioritize buses - if we find one, return it immediately
|
|
if (dev.intdev is IBusDevice) {
|
|
VerboseOut.WriteLine("-> {0} [bus]",
|
|
__arglist(dev.MatchingDeviceId));
|
|
return dev;
|
|
}
|
|
else {
|
|
if (device == null) {
|
|
device = dev;
|
|
}
|
|
}
|
|
}
|
|
// then try without the <follows>
|
|
else if (CheckDependencies(driver, false)) {
|
|
if (dev.intdev is IBusDevice) {
|
|
if (busWithoutFollows == null) {
|
|
busWithoutFollows = dev;
|
|
}
|
|
}
|
|
else {
|
|
if (deviceWithoutFollows == null) {
|
|
deviceWithoutFollows = dev;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (device != null) {
|
|
VerboseOut.WriteLine("-> {0}",
|
|
__arglist(device.MatchingDeviceId));
|
|
return device;
|
|
}
|
|
else if (busWithoutFollows != null) {
|
|
VerboseOut.WriteLine(
|
|
"-> {0} [bus w/o]",
|
|
__arglist(busWithoutFollows.MatchingDeviceId)
|
|
);
|
|
return busWithoutFollows;
|
|
}
|
|
else {
|
|
if (deviceWithoutFollows == null) {
|
|
VerboseOut.WriteLine("-> null");
|
|
}
|
|
else {
|
|
VerboseOut.WriteLine(
|
|
"-> {0} [w/o]",
|
|
__arglist(deviceWithoutFollows.MatchingDeviceId)
|
|
);
|
|
}
|
|
return deviceWithoutFollows; // may be null, but that's ok...
|
|
}
|
|
}
|
|
|
|
// [TODO] non-device services (i.e. volmgr) should start
|
|
// through this mechanism, but don't yet
|
|
// Activate any drivers whose needs can be fully satisfied:
|
|
public static void ActivateDrivers()
|
|
{
|
|
// since enumeration now associates whatever it can, we can pull
|
|
// the association step out of the loop.
|
|
foreach (DictionaryEntry d in instances) {
|
|
Associate((DeviceNode!) d.Value);
|
|
}
|
|
|
|
// we can't remove items from the instances list during the previous
|
|
// step, so we need a second loop to remove instances that have been
|
|
// associated:
|
|
foreach (DictionaryEntry d in associations) {
|
|
String key = (String) d.Key;
|
|
if (instances.ContainsKey(key)) {
|
|
instances.Remove(key);
|
|
}
|
|
}
|
|
|
|
// [TODO] once VolMgr is started through this method,
|
|
// remove the following line (we need it in order for the DiskDrive
|
|
// to run, as it depends on having a volmgr):
|
|
Binder.ClaimServiceContract(
|
|
"Microsoft.Singularity.Io.VolumeManagerContract");
|
|
|
|
// now activate devices whose dependencies are satisfied:
|
|
for (DeviceNode device; (device = GetActivatableDriver()) != null;) {
|
|
// first, check that the device's resources are valid.
|
|
Driver! driver = device.driver;
|
|
|
|
// Do the accounting for all Io Resources
|
|
if (ResourceTracker.AreResourcesValid(device.config, driver.metadata) &&
|
|
ResourceTracker.FindResourceConflicts(device) == null) {
|
|
ResourceTracker.AddResources(device);
|
|
}
|
|
else {
|
|
// somehow the resources the device needs are unavailable
|
|
DebugStub.Break();
|
|
continue;
|
|
}
|
|
|
|
// Next activate it by factory if needed.
|
|
bool activated = false;
|
|
if (driver.factory != null) {
|
|
device.intdev = driver.factory(device.config, device.location);
|
|
|
|
// initialize the device, conditional on whether it is a bus or not.
|
|
// If it is a bus, be sure to enumerate it.
|
|
if (device.intdev is IBusDevice) {
|
|
VerboseOut.WriteLine(
|
|
"Activate Device {0} {1} [w/ Enumerate]",
|
|
__arglist(device.location, device.driver.name)
|
|
);
|
|
IBusDevice bus = (IBusDevice)device.intdev;
|
|
bus.Initialize();
|
|
activated = true;
|
|
EnumerateDevice(bus, device.location, true);
|
|
}
|
|
else if (device.intdev is IDevice) {
|
|
VerboseOut.WriteLine("Activate Device {0} {1}",
|
|
__arglist(device.location,
|
|
device.driver.name));
|
|
device.intdev.Initialize();
|
|
activated = true;
|
|
}
|
|
}
|
|
else if (driver.imagePath != null) {
|
|
device.extdev = new ExtensionDevice(driver, device);
|
|
activated = device.extdev.Activate();
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("Driver appears to be incorrectly initialized.");
|
|
DebugStub.Break();
|
|
}
|
|
|
|
if (activated) {
|
|
// mark the device as loaded
|
|
device.startOrder = ++DeviceNode.lastStartOrder;
|
|
activations.Add(device.location, device);
|
|
associations.Remove(device.location);
|
|
|
|
// update the follows listing:
|
|
foreach (XmlNode! follows in driver.metadata.Children) {
|
|
if (follows.Name != ProvidesXmlTag) {
|
|
continue;
|
|
}
|
|
string tagName =
|
|
(!)follows.GetAttribute(FollowsNameXmlAttribute, "");
|
|
SetFollows(tagName);
|
|
}
|
|
}
|
|
else {
|
|
DebugStub.WriteLine("Driver failed to activate.");
|
|
DebugStub.Break();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finalize only deals with drivers that have been activated
|
|
private static void FinalizeOldDevices()
|
|
{
|
|
bool removed;
|
|
|
|
// Disable all of the devices in the order initialized.
|
|
do {
|
|
removed = false;
|
|
int highest = 0;
|
|
string highestDevice = null;
|
|
|
|
foreach (DictionaryEntry d in activations) {
|
|
DeviceNode! dev = (DeviceNode!)d.Value;
|
|
|
|
if (highest < dev.startOrder) {
|
|
highest = dev.startOrder;
|
|
highestDevice = (string)d.Key;
|
|
}
|
|
}
|
|
|
|
if (highest != 0 && highestDevice != null) {
|
|
DeviceNode! dev = (DeviceNode!)activations[highestDevice];
|
|
|
|
Tracing.Log(Tracing.Audit, "Finalizing {0}\n", dev.location);
|
|
if (dev.intdev != null) {
|
|
dev.intdev.Finalize();
|
|
}
|
|
else if (dev.extdev != null) {
|
|
dev.extdev.Finalize();
|
|
}
|
|
activations.Remove(highestDevice);
|
|
removed = true;
|
|
}
|
|
} while (removed);
|
|
}
|
|
|
|
// Print device config to debug console and to the log
|
|
public static void Dump(bool detailed)
|
|
{
|
|
Driver.DumpAll();
|
|
|
|
DebugStub.WriteLine("\nDevices found but not associated:");
|
|
Tracing.Log(Tracing.Audit, "Devices found but not associated:");
|
|
foreach (DictionaryEntry de in instances) {
|
|
DeviceNode! dev = (DeviceNode!)de.Value;
|
|
DumpDeviceNode(dev, detailed);
|
|
}
|
|
|
|
|
|
DebugStub.WriteLine("\n\nDevices associated but not initialized:");
|
|
Tracing.Log(Tracing.Audit,
|
|
"Devices associated but not initialized:");
|
|
foreach (DictionaryEntry de in associations) {
|
|
DeviceNode! dev = (DeviceNode!)de.Value;
|
|
DumpDeviceNode(dev, detailed);
|
|
}
|
|
|
|
DebugStub.WriteLine("\n\nDevices initialized:");
|
|
Tracing.Log(Tracing.Audit, "Devices initialized:");
|
|
foreach (DictionaryEntry de in activations) {
|
|
DeviceNode! dev = (DeviceNode!)de.Value;
|
|
|
|
if ((dev.intdev != null || dev.extdev != null) && dev.startOrder != 0) {
|
|
DumpDeviceNode(dev, detailed);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void DumpDeviceNode(DeviceNode! device, bool detailed)
|
|
{
|
|
DebugStub.WriteLine("device at " + device.location + ":");
|
|
Tracing.Log(Tracing.Audit, "device at " + device.location);
|
|
|
|
if (device.driver != null) {
|
|
DebugStub.WriteLine(" associated driver: " + device.driver.name);
|
|
Tracing.Log(Tracing.Audit, " associated driver: " + device.driver.name);
|
|
}
|
|
|
|
if (device.MatchingDeviceId != null) {
|
|
DebugStub.WriteLine(" matching device id: " + device.MatchingDeviceId);
|
|
Tracing.Log(Tracing.Audit, " matching device id: " + device.MatchingDeviceId);
|
|
}
|
|
|
|
if (detailed) {
|
|
if (device.config != null) {
|
|
DebugStub.WriteLine(device.config.ToPrint());
|
|
}
|
|
}
|
|
DebugStub.WriteLine("");
|
|
}
|
|
|
|
}
|
|
} // namespace Microsoft.Singularity.Io
|