static Mmu() { ttb = GetTTB(); // NB Table is 1MB section and 1MB aligned to avoid modifying page table entries on // page containing pool of l2TablePool = IoMemory.AllocatePhysical(L1SectionSize, L1SectionSize); DebugStub.Assert(RangeIsPageAligned(l2TablePool.VirtualAddress, (uint)l2TablePool.Length, L1SectionSize)); MaxL2Tables = L1SectionSize / L2TableSize; l2UsedBitmap = new uint [MaxL2Tables / 32]; }
private static AmlParser.ParseSuccess ParseAndLoadRegion(IoMemory region, AcpiObject.IOperationRegionAccessor operationRegionAccessor) { AmlParser.AMLCode result; int offset = 0; AmlParser parser = new AmlParser(new IoMemoryAmlStreamAdapter(region), null, null); AmlParser.ParseSuccess parseSuccess = parser.ParseAMLCode(out result, ref offset, region.Length); if (parseSuccess == AmlParser.ParseSuccess.Success) { AmlLoader loader = new AmlLoader(acpiNamespace, operationRegionAccessor); loader.Load(result); } return(parseSuccess); }
internal static MpIoApicEntry Parse(IoMemory region, int length, ref int offset) { Debug.Assert(length >= offset + Length); Debug.Assert(region.Read8(offset + 0) == EntryType); MpIoApicEntry e = new MpIoApicEntry(); e.Id = region.Read8(offset + 1); e.Version = region.Read8(offset + 2); e.Flags = region.Read8(offset + 3); e.BaseAddress = region.Read32(offset + 4); e.DebugPrint(); offset += Length; return(e); }
public static Rsdp Parse(UIntPtr regionAddress, uint regionBytes) { if (regionBytes >= 20) { IoMemory region = IoMemory.MapPhysicalMemory(regionAddress, regionBytes, true, false); if (AcpiChecksum.Compute(region, 0, 20) == 0 && region.ReadAsciiZeroString(0, 8) == Rsdp.Id) { return(new Rsdp(region)); } } return(null); }
static public PnpBiosInfo GetPnpBiosInfo() { Platform bi = Platform.ThePlatform; PnpBiosInfo pbi = new PnpBiosInfo(); if (bi.PnpNodesAddr32 != UIntPtr.Zero) { Tracing.Log(Tracing.Debug, "PnpBiosRegion {0:x8}..{1:x8}", bi.PnpNodesAddr32, bi.PnpNodesAddr32 + bi.PnpNodesSize32); pbi.pnpRegion = IoMemory.MapPhysicalMemory( bi.PnpNodesAddr32, bi.PnpNodesSize32, true, false); } pbi.isaReadPort = new IoPort((ushort)bi.IsaReadPort, 1, Access.Read);; pbi.isaCsns = bi.IsaCsns; return(pbi); }
public IoApic(UIntPtr memoryBase, uint interruptBase) { ioRegSel = IoMemory.MapPhysicalMemory(memoryBase, new UIntPtr(4u), true, true); ioWin = IoMemory.MapPhysicalMemory(memoryBase + new UIntPtr(0x10u), new UIntPtr(4u), true, true); entries = ((ReadRegister(1) & 0xff0000u) >> 16) + 1; for (uint i = 0; i < entries; i++) { SetEntryMask(i, true); } ioLock = new SpinLock(SpinLock.Types.IoApic); this.interruptBase = interruptBase; }
public static void InitializeMpAbi() { // Note: When mapping the abi stub (MpSyscalls.x86), we must // map it with writable flag! as we want to resolve the stub's // imports IoMemory mpPages = IoMemory.MapPhysicalMemory(Platform.MP_ABI_BASE, 4096, true, true); mpAbi = new PEImage(mpPages); mpPages = IoMemory.MapPhysicalMemory(Platform.MP_ABI_BASE, mpAbi.loadedSize, true, true); mpAbiExports = mpAbi.GetExportTable(mpPages); // Resolve imports in abi shim dll with the kernel exports // which are the real stub that will do IPI stuffs ImportTable mpAbiIt = mpAbi.GetImportTable(mpPages); DebugStub.WriteLine("HSG: ** Resolving Imports"); mpAbiIt.ResolveImports(kernelExports); }
// Constructor internal Tpm(/*TpmResources! res*/) { Tracing.Log(Tracing.Debug, "Tpm: Initialize() called\n"); DebugStub.WriteLine("Tpm: Initialize() called"); tpmIoMemory = IoMemory.MapPhysicalMemory(new UIntPtr(0xfed40000), new UIntPtr(0x4000), true, true); if (tpmIoMemory == null) { DebugStub.WriteLine("Tpm: Initialize(), MapPhysicalMemory failed"); } minResponse = new byte[minResponseLen]; }
internal static MpProcessorEntry Parse(IoMemory region, int length, ref int offset) { Debug.Assert(length >= offset + Length); Debug.Assert(region.Read8(offset + 0) == EntryType); MpProcessorEntry e = new MpProcessorEntry(); e.LocalApicId = region.Read8(offset + 1); e.LocalApicVersion = region.Read8(offset + 2); e.CpuFlags = region.Read8(offset + 3); e.CpuSignature = region.Read32(offset + 4); e.FeatureFlags = region.Read32(offset + 8); e.DebugPrint(); offset += Length; return(e); }
uint flags; // Values per MadtFlags private Madt(IoMemory region, SystemTableHeader header) { this.region = region; this.header = header; localApicAddress = region.Read32(0); flags = region.Read32(4); // XXX Just for debugging GetLocalApics(); GetIoApics(); GetInterruptSourceOverrides(); GetNmis(); GetApicNmis(); GetLocalApicAddressOverrides(); GetIoSApics(); GetLocalSApics(); GetPlatformInterruptSources(); }
public Vga() { IoPortRange dev = new IoPortRange(0x3c0, 0x20, Access.ReadWrite); atcAddrPort = dev.PortAtOffset(ATC_ADDR_PORT, 2, Access.ReadWrite); miscOutputRegWritePort = dev.PortAtOffset(MISC_OUTPUT_REG_WRITE_PORT, 2, Access.ReadWrite); seqAddrPort = dev.PortAtOffset(SEQ_ADDR_PORT, 2, Access.Write); seqDataPort = dev.PortAtOffset(SEQ_DATA_PORT, 2, Access.ReadWrite); dacPixelMaskPort = dev.PortAtOffset(DAC_PIXEL_MASK_PORT, 2, Access.Write); dacAddressWritePort = dev.PortAtOffset(DAC_ADDR_WRITE_PORT, 2, Access.Write); dacDataRegPort = dev.PortAtOffset(DAC_DATA_REG_PORT, 2, Access.Write); graphAddrPort = dev.PortAtOffset(GRAPH_ADDR_PORT, 2, Access.Write); graphDataPort = dev.PortAtOffset(GRAPH_DATA_PORT, 2, Access.ReadWrite); crtcAddressColorPort = dev.PortAtOffset(CRTC_ADDR_COLOR_PORT, 2, Access.ReadWrite); inputStatusColorPort = dev.PortAtOffset(INPUT_STATUS_COLOR_PORT, 2, Access.ReadWrite); screenBuffer = IoMemory.AllocateIo(0xa0000, 0x20000, true, true); textBuffer = IoMemory.AllocateIo(0xb8000, 0x8000, true, true); }
internal LocalSApic(IoMemory region, int offset) { Debug.Assert(region.Read8(offset + 0) == TypeId); byte length = region.Read8(offset + 1); Debug.Assert(length >= MinLength); AcpiProcessorId = region.Read8(offset + 2); LocalSApicId = region.Read8(offset + 3); LocalSApicEid = region.Read8(offset + 4); // reserved = region.Read24(offset + 5); Flags = region.Read32(offset + 8); AcpiProcessorUidValue = region.Read32(offset + 12); AcpiProcessorUidString = region.ReadString(offset + 16, (int)length - 17); // DebugStub.Print("{0:x04}:{1:x04} type {2:x01} AcpiProcId {3:x02} LocalSApicId {4:x02} LocalSApicEid {5:x02} Flags {6:x08} AcpiProcUid {7:x04} AcpiProcUid \"{8}\" (LocalSApic)\n", __arglist(offset, offset + length, TypeId, AcpiProcessorId, LocalSApicId, LocalSApicEid, Flags, AcpiProcessorUidValue, AcpiProcessorUidString)); }
internal static void Parse(IoMemory region, int length, uint entryCount) { int offset = 0; for (int i = 0; i < entryCount; i++) { switch (region.Read8(offset)) { case MpProcessorEntry.EntryType: ProcessorEntries.Add( MpProcessorEntry.Parse(region, length, ref offset) ); break; case MpBusEntry.EntryType: BusEntries.Add( MpBusEntry.Parse(region, length, ref offset) ); break; case MpIoApicEntry.EntryType: IoApicEntries.Add( MpIoApicEntry.Parse(region, length, ref offset) ); break; case MpInterruptEntry.IoEntryType: IoInterruptEntries.Add( MpInterruptEntry.Parse(region, length, ref offset) ); break; case MpInterruptEntry.LocalEntryType: LocalInterruptEntries.Add( MpInterruptEntry.Parse(region, length, ref offset) ); break; } } }
internal readonly uint AddressOfOrdinals; // RVA from base of image internal ExportDirectory(IoMemory mem, int offset) { if (offset + 40 > mem.Length) { Error.AccessOutOfRange(); } Characteristics = mem.Read32Unchecked(offset + 0); NumberOfFunctions = mem.Read32Unchecked(offset + 20); NumberOfNames = mem.Read32Unchecked(offset + 24); AddressOfFunctions = mem.Read32Unchecked(offset + 28); AddressOfNames = mem.Read32Unchecked(offset + 32); AddressOfOrdinals = mem.Read32Unchecked(offset + 36); if (AddressOfFunctions + 4 * NumberOfFunctions > mem.Length || AddressOfOrdinals + 2 * NumberOfFunctions > mem.Length || AddressOfNames + 4 * NumberOfFunctions > mem.Length) { Error.AccessOutOfRange(); } }
private static void UuencodeDumpRegion(string filename, IoMemory region) { DebugStub.Print("\nbegin 777 {0}\n", __arglist(filename)); StringBuilder line = new StringBuilder(); int inputBytesOnLine = 0; for (int i = 0; i < region.Length; i += 3) { byte b1 = (byte)0, b2 = (byte)0, b3 = (byte)0; b1 = region.Read8(i); inputBytesOnLine++; if (i + 1 < region.Length) { b2 = region.Read8(i + 1); inputBytesOnLine++; } if (i + 2 < region.Length) { b3 = region.Read8(i + 2); inputBytesOnLine++; } line.Append((char)(32 + (b1 >> 2))); line.Append((char)(32 + (((b1 << 4) | (b2 >> 4)) & 0x3F))); line.Append((char)(32 + (((b2 << 2) | (b3 >> 6)) & 0x3F))); line.Append((char)(32 + (b3 & 0x3F))); if (line.Length >= 60 || i + 3 >= region.Length) { DebugStub.Print("{0}{1}\n", __arglist((char)(inputBytesOnLine + 32), line.ToString())); line.Remove(0, line.Length); inputBytesOnLine = 0; } } DebugStub.Print("end\n\n"); }
internal static MpFloatingPointer Parse(IoMemory region) { uint signature = region.Read32(0); if (signature != Signature) { return(null); } int length = region.Read8(8) * 16; if (length != 16) { return(null); } byte checksum = 0; for (int i = 0; i < length; i++) { checksum += region.Read8((int)i); } if (checksum != 0) { return(null); } MpFloatingPointer m = new MpFloatingPointer(); m.ConfTableBase = region.Read32(4); m.Revision = region.Read8(9); m.Feature = new byte [5]; for (int i = 0; i < m.Feature.Length; i++) { m.Feature[i] = region.Read8(0xb + i); } return(m); }
internal static MpInterruptEntry Parse(IoMemory region, int length, ref int offset) { Debug.Assert(length >= offset + Length); byte entry = region.Read8(offset + 0); Debug.Assert(entry == IoEntryType || entry == LocalEntryType); MpInterruptEntry e = new MpInterruptEntry(); e.EntryType = entry; e.Interrupt = region.Read8(offset + 1); e.Flags = region.Read16(offset + 2); e.BusId = region.Read8(offset + 4); e.BusIrq = region.Read8(offset + 5); e.ApicId = region.Read8(offset + 6); e.ApicLine = region.Read8(offset + 7); e.DebugPrint(); offset += Length; return(e); }
// Constructor internal TimerOmap3430(PnpConfig config, Pic pic) { #if VERBOSE DebugStub.WriteLine("TimerOmap3430: create"); #endif TimerResources tr = new TimerResources(config); this.config = config; this.pic = pic; this.irq = tr.irq.Irq; IoMemory timerRegisters = tr.registers .MemoryAtOffset(0, Omap3430_TIMER1_RegisterSize, Access.ReadWrite); tisr = timerRegisters.MappedPortAtOffset(Omap3430_TISR, 4, Access.ReadWrite); tier = timerRegisters.MappedPortAtOffset(Omap3430_TIER, 4, Access.ReadWrite); tclr = timerRegisters.MappedPortAtOffset(Omap3430_TCLR, 4, Access.ReadWrite); tcrr = timerRegisters.MappedPortAtOffset(Omap3430_TCRR, 4, Access.ReadWrite); tldr = timerRegisters.MappedPortAtOffset(Omap3430_TLDR, 4, Access.ReadWrite); // _ARM_ERRATA problem with how functional clock is unstuck tcrr.Write32(0, 0); }
internal ExportTable(IoMemory mem, UIntPtr imageBase, DirectoryEntry entry) { this.mem = mem; this.entry = entry; try { exports = new ExportDirectory(mem, (int)entry.virtualAddress); if (exports.NumberOfFunctions > 0) { addresses = new UIntPtr[exports.NumberOfFunctions]; for (uint i = 0; i < exports.NumberOfFunctions; i++) { addresses[i] = imageBase + mem.Read32Unchecked((int)(exports.AddressOfFunctions + 4 * i)); } } if (exports.NumberOfNames > 0) { names = new string[exports.NumberOfNames]; ordinals = new ushort[exports.NumberOfNames]; for (uint i = 0; i < exports.NumberOfNames; i++) { ordinals[i] = mem.Read16Unchecked((int)(exports.AddressOfOrdinals + 2 * i)); uint addrOfName = mem.Read32Unchecked((int)(exports.AddressOfNames + 4 * i)); names[i] = mem.ReadAsciiZeroString((int)addrOfName); } } } catch (Exception e) { DebugStub.Print("Caught exception: {0}\n", __arglist(e.ToString())); } }
internal static MpConfTable Parse(IoMemory region) { if (region.Read32(0) != Signature) { return(null); } int length = region.Read16(4); DebugStub.Print("MP Conf Table length {0}\n", __arglist(length)); #if NOTYET byte checksum = 0; for (int i = 0; i < length; i++) { checksum += region.Read8(i); } if (checksum != 0) { return(null); } #endif MpConfTable confTable = new MpConfTable(); confTable.BaseTableLength = region.Read16(4); confTable.Revision = region.Read8(7); confTable.OemTableBase = region.Read32(0x1c); confTable.OemTableSize = region.Read16(0x20); confTable.EntryCount = region.Read16(0x22); confTable.LocalApicBase = region.Read32(0x24); confTable.ExtendedTableLength = region.Read16(0x28); confTable.ExtendedTableChecksum = region.Read8(0x2a); confTable.OemId = region.ReadAsciiZeroString(8, 8); confTable.ProductId = region.ReadAsciiZeroString(0x10, 0x0c); return(confTable); }
////////////////////////////////////////////////////// Static Methods. // public static unsafe void Initialize() { Platform p = Platform.ThePlatform; IoMemory pages = IoMemory.MapPhysicalMemory((UIntPtr)p.KernelDllFirstPage, 4096, true, false); kernel = new PEImage(pages); pages = IoMemory.MapPhysicalMemory((UIntPtr)p.KernelDllBase, kernel.loadedSize, true, false); kernelExports = kernel.GetExportTable(pages); DebugStub.WriteLine("PEImage.Initialize: Notify KD of kernel load."); DebugStub.LoadedBinary(pages.VirtualAddress, kernel.sizeOfImage, #if ISA_ARM "kernel.arm", #elif ISA_IX64 "kernel.x64", #elif ISA_IX86 "kernel.x86", #endif kernel.checkSum, kernel.timeDateStamp, false); // This breakpoint is triggered by a "-d" to windbg. if (DebugStub.PollForBreak()) { DebugStub.Break(); } #if GENERATE_ABI_SHIM DebugStub.WriteLine(" InitializeMpAbi() *****"); InitializeMpAbi(); #endif }
protected Rsdt(IoMemory region, SystemTableHeader header) { this.region = region; this.header = header; }
public Ssdt(IoMemory region, SystemTableHeader header) { this.region = region; this.header = header; }
private Xsdt(IoMemory region, SystemTableHeader header) : base(region, header) { // Nothing to do }
// // Someone must arrange to call this from *within* the // Protection Domain for us to have an opportunity to finish // initializing. // internal unsafe void InitHook() { // If paging is disabled then just return immediately if (!MemoryManager.UseAddressTranslation) { return; } DebugStub.Assert(AddressSpace.CurrentAddressSpace == this.AddressSpace); if (this.initialized) { // Someone else has already set up the space return; } bool iflag = initSpin.Lock(); try { if (this.initialized) { // Someone else snuck in and initialized return; } // // We're first into this space, so set it up. // #if VERBOSE DebugStub.WriteLine("Setting up protection domain \"{0}\"", __arglist(this.name)); #endif userRange = new VirtualMemoryRange(VMManager.UserHeapBase, VMManager.UserHeapLimit, this); #if PAGING if (kernelMode) { // This will be a ring-0, trusted domain, so just // point the userSharedHeap at the kernel's comm heap. userSharedHeap = SharedHeap.KernelSharedHeap; this.initialized = true; } else { // Create a new shared heap that lives in // user-land. userSharedHeap = new SharedHeap(this, userRange); #if VERBOSE DebugStub.WriteLine(" ...Created a shared heap"); #endif // // N.B.: this is kind of tricky. Loading an // executable image involves allocating memory, // which goes through this object. So, before // attempting the load, mark ourselves as initialized. // // ---- DON'T PUT GENUINE INITIALIZATION // CODE BELOW HERE! --------- this.initialized = true; // Load our own, protection-domain-private copy of the // ABI stubs. These will get shared by all apps in // this domain. IoMemory syscallsMemory = Binder.LoadRawImage("/init", "syscalls.dll"); IoMemory loadedMemory; // Load the stubs library into the user range, but make // the kernel process the logical owner. This seems like // the only sensible approach since the stubs do not // belong to any particular process but must be in the // user range of memory. // N.B.: RE-ENTERS this object! ring3AbiImage = PEImage.Load(Process.kernelProcess, syscallsMemory, out loadedMemory, false, // isForMp false // inKernelSpace ); ring3AbiExports = ring3AbiImage.GetExportTable(loadedMemory); #if VERBOSE DebugStub.WriteLine(" ...Loaded ring-3 ABI stubs"); #endif } #else // PAGING this.initialized = true; #endif // PAGING } finally { DebugStub.Assert(this.initialized); initSpin.Unlock(iflag); } }
internal static object Create(IoMemory region, int offset) { return(new PlatformInterruptSource(region, offset)); }
internal static object Create(IoMemory region, int offset) { return(new LocalSApic(region, offset)); }
internal static object Create(IoMemory region, int offset) { return(new InterruptSourceOverride(region, offset)); }
internal static object Create(IoMemory region, int offset) { return(new LocalApicAddressOverride(region, offset)); }
internal static object Create(IoMemory region, int offset) { return(new Nmi(region, offset)); }