The original definition of this variable seems to have been based on the retarded type in the serial.sys source sample, which defines it as:
extern PUCHAR *KdComPortInUse;
This, somehow, works in MSVC, but gcc complains about the lack of import specifier (KdComPortInUse is exported by HAL).
This was 'fixed' by adding the import specifier to ros.
So instead of: PUCHAR *KdComPortInUse;
We ended up with: NTHALAPI PUCHAR *KdComPortInUse;
Which becomes 3 dereferences instead of 2, which is incorrect. This was 'fixed' by hacking the variable in HAL too.
Use "extern PUCHAR NTHALAPI KdComPortInUse" to be compatible with both compilers, remove the HAL hacks, and fix the usage of the variable.
Fixes the serial.sys crash when booted with _WINKD_ + kdcom from Windows 2003, as kdcom would (due to the HAL hack) set the internal 'pointer' to the port value, and serial would end up dereferencing the port address
svn path=/trunk/; revision=38960
- Fixed HAL DMA problem that caused floppy driver not to work (the point was that function had to copy the read sector back to the MDL buffer and it was not doing that because of the problem with braces, broken in rev is 24464).
See issue #2287 for more details.
svn path=/trunk/; revision=37254
.pspec files are preprocessed now, while .spec files aren't. A change like this was already done in the amd64 branch before KJK rewrote the .spec stuff in rbuild.
- Renamed currently preprocessed .spec files to .pspec and changed that in the .rbuild files appropriately
- Renamed "IsWineModule" to "IsSpecDefinitionFile", the new name is more appropriate
- Removed some checks for uppercased file extensions, we neither use them in our tree nor it will totally work as we only support them in a few places
Commit dedicated to Timo ;-)
svn path=/trunk/; revision=37070
modified tools/rbuild/backend/mingw/modulehandler.h
modified tools/rbuild/module.cpp
Split rules for .spec files as input files vs import libraries. .spec files can now be specified independently as <file>s (to generate and compile a .stubs.c file) and <importlibrary> (to generate and compile a .spec.def file)
.spec files are now specified in <importlibrary>s directly (instead of pointing to the non-existing, generated .spec.def file. Whose idea was that? sounds like the doing of Arch Blackmann)
Allow multiple modules to share a single .spec file without using <importlibrary base="...">
Allow static libraries to use .spec files in <importlibrary>
Emit comments in makefile.auto so rules can be traced back to the code that generated them
deleted lib/debugsup/debugsup-ntos.def
added lib/debugsup/debugsup-ntos.spec
modified lib/debugsup/debugsup.rbuild
.def -> .spec
<<hundreds of rbuild files>>
Remove <file> entry for spec file if there are no stubs to compile
.spec.def -> .spec in <importlibrary> entries
Soon: making all keyboard layouts use a single .spec file
Dedicated to: Samuel Serapión, Stefan Ginsberg, and all the fellow team members who'll have an aneurysm at this commit
See issue #3746 for more details.
svn path=/trunk/; revision=36870
- Remove various dead stuff from headers, and move ASSERT_IRQL_LESS_OR_EQUAL, ASSERT_IRQL_EQUAL and ASSERT_IRQL_LESS to global debug.h
svn path=/trunk/; revision=35803
- For the first time, the entire ARM build of ReactOS builds (for the components we've defined)!
- Now the user-mode fun begins.
svn path=/trunk/; revision=34890
- Do not corrupt the stack anymore
- Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark)
- Use slower but more correct trap prolog/epilog code for now.
- Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code.
- Rewrite the system call interface from the ground up:
- System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack.
- Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit".
- Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use
a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki.
- This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching.
- The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level
backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance.
- Move timebase code from stubs.c to its own file, time.c.
- Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup.
svn path=/trunk/; revision=34366
- This means we actually load and parse drivers now!!! Some Mm work was required to support unloading and remapping: MmDeleteVirtualMapping is now implemented.
- We can now see scsiport.sys and atapi.sys strings displayed on the LCD.
- Implemented HalQuery/SetDisplayParameters, HalQuery/ReleaseDisplayOwnership and HalDisplayString just like on x86.
- Since we now load symbols for the drivers (or at least try to), stubbed DebugService2, which also shows us what's being loaded.
- Extended the Loader MemoryType array to include XIP/RAM Disk Memory.
svn path=/trunk/; revision=34210
- We use this in the clock ISR, that can now actually send the trap frame to KeUpdateSystemTime.
- Implement KeUpdateRunTime to handle time accounting and DPC rescheduling as well as Quantum End.
- Ignore quantum end for now.
- We now have a working timebase, and we're back to our earlier checkpoint around CmInitSystem1!.
svn path=/trunk/; revision=34088
- We do not yet handle all cases, most notably, timer expiration.
- There may still be some bugs to work out in the code, but it's a start.
- This regresses progress, but does not ignore time anymore.
svn path=/trunk/; revision=34084
- We do not attemp to build world anymore. We have handwritten a new ARM rbuild file that only builds what we need for our current ARM work.
- HAL and FreeLDR do not seem to have an "installpath"... why not? Added one at least for our ARM stuff, so that "make install" can drop the binaries.
- Fixed some ARM DDK macro inconsistencies, allow more drivers to build.
- It is now possible to use "make install -k" to drop a completely working ARM build onto an image due to all these changes.
svn path=/trunk/; revision=34055
- Implement KiInitMachineDependent -- this is only useful for x86 and has nothing relevant to ARM, so we just return.
- Implement HalAllProcessorsStarted (again, a no-op) and HalQueryRealTimeClock (uses the RTC on the board -- uboot must set it up first).
- Make sure we get the right Sp during a system call (this is still broken though).
- We need to fix our system call handler next.
svn path=/trunk/; revision=33977
- Don't hang in the clock interrupt anymore, for now we'll just ignore it (but it works! :D)
- Make all unimplemented bootvid functions hang the system, so we can better stop at progress-points.
- Implement VidInitialize:
- We allocate a 640x480@16bpp framebuffer using contiguous physical memory (our MMU code survives!).
- We setup the LCD controller timings and framebuffer address.
- We enable the LCD
- For debugging, we're also drawing a nice little test pattern... and it works! We have GUI Code :)
svn path=/trunk/; revision=33974
- Stub out all the bootvid functions for ARM, and add an infinite loop so we stop there.
- Remove the infinite loop from the HAL -- Hal Initialization is complete.
- We must now implement the LCD graphics functions.
svn path=/trunk/; revision=33973
- Since we have two timers (ha x86!!!), set the second one as the stall timer. It's a one-shot periodic timer, set to the exact number of microseconds being waited on.
- To fully emulate stalling, we don't use a clock interrupt for it (it supports not sending one!) and just busy-loop until the value reaches 0.
- Tried it with a 10 second (10000000 us) wait and it worked -perfectly-.
- Re-implemented KeStallExecutionProcessor and got rid of the other code. Back in HalInitSystem(phase1) now...
- Also killed some DPRINT1s getting on my nerves.
svn path=/trunk/; revision=33971
- Also written KeStallExecution.
- Now, we are back to where we hang before Phase 1 (so Phase 1 doesn't occur anymore).
- This hang is because we used to do a DPC here, which isn't good, since IRQL is already at dispatch.
- Instead, the correct course of action is to enter the idle loop, which will schedule the phase 1 thread.
- But, we don't have an idle loop yet ;-)
svn path=/trunk/; revision=33969
- Get rid of KeSwapIrql -- both lower and higher IRQL handling was treated the same!
- We can now re-activate the assert in the IRQL code
- Disable interrupts before changing the interrupt mask!!!
- And re-enable them solely if they were enabled.
- Clear interrupts mask before setting a new one -- raising isn't always additive!
- Fix KiInterruptHandler to perform operations in the right order.
- Finish implementing interrupt exit code.
- Code KeArmStatusRegisterGet to read CPSR and interrupt status.
- Make debug prints a lot more readable and dont trying to acquire the stack during pool allocations.
- Setup the clock interval timer!!!
- This code regresses progress but makes stuf fwork right. We'll get better after implementing the stall interrupt.
svn path=/trunk/; revision=33967
- _iob is already defined as a dll_import
- _rotl intrinsic is now implemented (should use rol instruction, but not sure on the syntax!)
- Add a stub psctx.h for ARM
- Added InterlockedEXchangePointers
- Fix uninitialized variable warning in ex/resource.c
- Start to implement interrupt handling:
- We now have a rudimentary interrupt handler that takes care of software interrupts
- We now have a rudimentary DPC handler which takes care of switching to the next thread, if any
- We now setup the HAL Interrupt Source -> IRQL Table (The IRQLMask Table).
- Implemented HalGetInterruptSource, which allows us to get the interrupt # that cause the IRQ.
Note: this wasn't needed on Alpha/PPC/MIPS NT ports, because that information is stored on the CPU,
and the kernel could read it -- we must abstract it through the HAL.
- Add the OldIrql to the TRAP_FRAME, we don't use it yet.
- We are now ready to context switch to the Phase 1 thread.
svn path=/trunk/; revision=33933
- Start coding HalInitSystem.
- Implement HalRequestSoftwareInterrupt for the PL190 VIC. The interrupt fires! (This interrupt is responsible for forcing DPC delivery, which should also force thread scheduling, which should force the switch to the phase 1 thread)
svn path=/trunk/; revision=32674
- Current status: we now make it all the way to the first system call at the end of Phase 0!
- We now make the IRQL routines modify the IRQL saved in the KPCR, to make some assertions work.
- Build mem.c and memgen.c from RTL in order to get non-optimized but portable Rtl*Memory routines and Rtl*Swap routines.
- Take the PPC non-optimized but portable Ex*Interlocked* routines and make them available for ARM as well. Play with the code a bit to get other routines in there too.
- Major TODO: Cleanup these routines, re-format them, make them compatible for all architectures, and later on, provided optimized ARM versions.
- Remove _all* _aull* MSVC-i386 helper exports from the kernel, as well as Exfi386* routines -- they're only for x86 kernels.
svn path=/trunk/; revision=32664
- There is no reason to implement the Interlocked* APIs in assembly in the kernel -- just have them call the intrinsics.
- Also fix the way we were overloading the exported APIs, we now use the intrinsics all the time.
- Convert loader block address to virtual, and parse the addresses inside it and convert them to virtual too, after we don't use them in FreeLDR anymore -- the kernel will delete the p->v identity mapping, and eventually still need to touch the loader block.
- Implement MmGetPhysicalAddress and MiGetUserPageDirectoryCount for ARM.
- We now reach the point where we start initializing the boot drivers' memory information.
svn path=/trunk/; revision=32654
Implemented KeAcquireInSTackQueuedSpinLock, KeAcquireInStackQueuedSpinLockRaiseToSYnc and KeReleaseInStackQueuedSpinLock based on x86 UP versions.
On ARM, the PCR is fully exposed, so some APIs are always-inlined direct-memory-access (unlike x86 which has the fs selector, and undocumented parts of the PCR). This means we can define several macros -- fixed the headers to allow this, by defining the previous stuff for x86 only.
Setup registry data in the ARM loader block.
The ARM port boots all the way through ExpInitializeExecutive until reaching MmInit1. The boot-registry is correctly loaded and parsed, as are NLS files!
svn path=/trunk/; revision=32379
Finished implementation of KiSystemStartup.
Copied KiInitializeKernel from x86 to ARM, removing irrelevant parts. This is our current checkpoint.
svn path=/trunk/; revision=32333
We now have HalSweepI/Dcache APIs exported and stubbed in the ARM HAL (great, since UNIMPLEMENTED macro now works).
We now setup more of the PCR, including all the cache values required, then we call the HAL sweep functions (TBD).
svn path=/trunk/; revision=32330
