/*++ Copyright (c) 1990 Microsoft Corporation Module Name: thredini.c Abstract: This module implements the machine dependent function to set the initial context and data alignment handling mode for a process or thread object. Author: David N. Cutler (davec) 31-Mar-1990 Environment: Kernel mode only. Revision History: 3 April 90 bryan willman This version ported to 386. --*/ #include "ki.h" // // The following assert macros are used to check that an input object is // really the proper type. // #define ASSERT_PROCESS(E) { \ ASSERT((E)->Header.Type == ProcessObject); \ } #define ASSERT_THREAD(E) { \ ASSERT((E)->Header.Type == ThreadObject); \ } // // Our notion of alignment is different, so force use of ours // #undef ALIGN_UP #undef ALIGN_DOWN #define ALIGN_DOWN(address,amt) ((ULONG)(address) & ~(( amt ) - 1)) #define ALIGN_UP(address,amt) (ALIGN_DOWN( (address + (amt) - 1), (amt) )) // // The function prototype for the special APC we use to set the // hardware alignment state for a thread // VOID KepSetAlignmentSpecialApc( IN PKAPC Apc, IN PKNORMAL_ROUTINE *NormalRoutine, IN PVOID *NormalContext, IN PVOID *SystemArgument1, IN PVOID *SystemArgument2 ); VOID KiInitializeContextThread ( IN PKTHREAD Thread, IN PKSYSTEM_ROUTINE SystemRoutine, IN PKSTART_ROUTINE StartRoutine OPTIONAL, IN PVOID StartContext OPTIONAL, IN PCONTEXT ContextFrame OPTIONAL ) /*++ Routine Description: This function initializes the machine dependent context of a thread object. N.B. This function does not check the accessibility of the context record. It is assumed the the caller of this routine is either prepared to handle access violations or has probed and copied the context record as appropriate. Arguments: Thread - Supplies a pointer to a dispatcher object of type thread. SystemRoutine - Supplies a pointer to the system function that is to be called when the thread is first scheduled for execution. StartRoutine - Supplies an optional pointer to a function that is to be called after the system has finished initializing the thread. This parameter is specified if the thread is a system thread and will execute totally in kernel mode. StartContext - Supplies an optional pointer to an arbitrary data structure which will be passed to the StartRoutine as a parameter. This parameter is specified if the thread is a system thread and will execute totally in kernel mode. ContextFrame - Supplies an optional pointer a context frame which contains the initial user mode state of the thread. This parameter is specified if the thread is a user thread and will execute in user mode. If this parameter is not specified, then the Teb parameter is ignored. Return Value: None. --*/ { PFX_SAVE_AREA NpxFrame; PKSWITCHFRAME SwitchFrame; PKTRAP_FRAME TrFrame; PULONG PSystemRoutine; PULONG PStartRoutine; PULONG PStartContext; PULONG PUserContextFlag; ULONG ContextFlags; CONTEXT Context2; PCONTEXT ContextFrame2 = NULL; PFXSAVE_FORMAT PFxSaveArea; // // If a context frame is specified, then initialize a trap frame and // and an exception frame with the specified user mode context. // if (ARGUMENT_PRESENT(ContextFrame)) { RtlCopyMemory(&Context2, ContextFrame, sizeof(CONTEXT)); ContextFrame2 = &Context2; ContextFlags = CONTEXT_CONTROL; // // The 80387 save area is at the very base of the kernel stack. // NpxFrame = (PFX_SAVE_AREA)(((ULONG)(Thread->InitialStack) - sizeof(FX_SAVE_AREA))); // // Load up an initial NPX state. // if (KeI386FxsrPresent == TRUE) { PFxSaveArea = (PFXSAVE_FORMAT)ContextFrame2->ExtendedRegisters; PFxSaveArea->ControlWord = 0x27f; // like fpinit but 64bit mode PFxSaveArea->StatusWord = 0; PFxSaveArea->TagWord = 0; PFxSaveArea->ErrorOffset = 0; PFxSaveArea->ErrorSelector = 0; PFxSaveArea->DataOffset = 0; PFxSaveArea->DataSelector = 0; PFxSaveArea->MXCsr = 0x1f80; // mask all the exceptions } else { ContextFrame2->FloatSave.ControlWord = 0x27f; // like fpinit but 64bit mode ContextFrame2->FloatSave.StatusWord = 0; ContextFrame2->FloatSave.TagWord = 0xffff; ContextFrame2->FloatSave.ErrorOffset = 0; ContextFrame2->FloatSave.ErrorSelector = 0; ContextFrame2->FloatSave.DataOffset = 0; ContextFrame2->FloatSave.DataSelector = 0; } if (KeI386NpxPresent) { ContextFrame2->FloatSave.Cr0NpxState = 0; NpxFrame->Cr0NpxState = 0; NpxFrame->NpxSavedCpu = 0; if (KeI386FxsrPresent == TRUE) { ContextFlags |= CONTEXT_EXTENDED_REGISTERS; } else { ContextFlags |= CONTEXT_FLOATING_POINT; } // // Threads NPX state is not in the coprocessor. // Thread->NpxState = NPX_STATE_NOT_LOADED; Thread->NpxIrql = PASSIVE_LEVEL; } else { NpxFrame->Cr0NpxState = CR0_EM; // // Threads NPX state is not in the coprocessor. // In the emulator case, do not set the CR0_EM bit as their // emulators may not want exceptions on FWAIT instructions. // Thread->NpxState = NPX_STATE_NOT_LOADED & ~CR0_MP; } // // Force debug registers off. They won't work anyway from an // initial frame, debuggers must set a hard breakpoint in the target // ContextFrame2->Dr0 = 0; ContextFrame2->Dr1 = 0; ContextFrame2->Dr2 = 0; ContextFrame2->Dr3 = 0; ContextFrame2->Dr6 = 0; ContextFrame2->Dr7 = 0; ContextFrame2->ContextFlags &= ~(CONTEXT_DEBUG_REGISTERS); #if 0 // // If AutoAlignment is FALSE, we want to set the Alignment Check bit // in Eflags, so we will get alignment faults. // if (Thread->AutoAlignment == FALSE) { ContextFrame2->EFlags |= EFLAGS_ALIGN_CHECK; } #endif // // If the thread is set TrFrame = (PKTRAP_FRAME)(((ULONG)NpxFrame - KTRAP_FRAME_LENGTH)); // Space for arguments to KiThreadStartup. Order is important, // Since args are passed on stack through KiThreadStartup to // PStartRoutine with PStartContext as an argument. PUserContextFlag = (PULONG)TrFrame - 1; PStartContext = PUserContextFlag - 1; PStartRoutine = PStartContext - 1; PSystemRoutine = PStartRoutine - 1; SwitchFrame = (PKSWITCHFRAME)((PUCHAR)PSystemRoutine - sizeof(KSWITCHFRAME)); // // Copy information from the specified context frame to the trap and // exception frames. // KeContextToKframes(TrFrame, NULL, ContextFrame2, ContextFrame2->ContextFlags | ContextFlags, UserMode); TrFrame->HardwareSegSs |= RPL_MASK; TrFrame->SegDs |= RPL_MASK; TrFrame->SegEs |= RPL_MASK; #if DBG TrFrame->DbgArgMark = 0xBADB0D00; #endif // // Tell KiThreadStartup that a user context is present. // *PUserContextFlag = 1; // // Initialize the kernel mode ExceptionList pointer // TrFrame->ExceptionList = EXCEPTION_CHAIN_END; // // Initialize the saved previous processor mode. // TrFrame->PreviousPreviousMode = UserMode; // // Set the previous mode in thread object to user. // Thread->PreviousMode = UserMode; } else { // // Dummy floating save area. Kernel threads don't have or use // the floating point - the dummy save area is make the stacks // consistent. // NpxFrame = (PFX_SAVE_AREA)(((ULONG)(Thread->InitialStack) - sizeof(FX_SAVE_AREA))); // // Load up an initial NPX state. // RtlZeroMemory((PVOID)NpxFrame, sizeof(FX_SAVE_AREA)); if (KeI386FxsrPresent == TRUE) { NpxFrame->U.FxArea.ControlWord = 0x27f;//like fpinit but 64bit mode NpxFrame->U.FxArea.MXCsr = 0x1f80;// mask all the exceptions } else { NpxFrame->U.FnArea.ControlWord = 0x27f;//like fpinit but 64bit mode NpxFrame->U.FnArea.TagWord = 0xffff; } // // Threads NPX state is not in the coprocessor. // Thread->NpxState = NPX_STATE_NOT_LOADED; // // Space for arguments to KiThreadStartup. // Order of fields in the switchframe is important, // Since args are passed on stack through KiThreadStartup to // PStartRoutine with PStartContext as an argument. // PUserContextFlag = (PULONG)((ULONG)NpxFrame) - 1; PStartContext = PUserContextFlag - 1; PStartRoutine = PStartContext - 1; PSystemRoutine = PStartRoutine - 1; SwitchFrame = (PKSWITCHFRAME)((PUCHAR)PSystemRoutine - sizeof(KSWITCHFRAME)); // // Tell KiThreadStartup that a user context is NOT present. // *PUserContextFlag = 0; // // Set the previous mode in thread object to kernel. // Thread->PreviousMode = KernelMode; } // // Set up thread start parameters. // (UserContextFlag set above) // *PStartContext = (ULONG)StartContext; *PStartRoutine = (ULONG)StartRoutine; *PSystemRoutine = (ULONG)SystemRoutine; // // Set up switch frame. Assume the thread doesn't use the 80387; // if it ever does (and there is one), these flags will get reset. // Each thread starts with these same flags set, regardless of // whether the hardware exists or not. // SwitchFrame->RetAddr = (ULONG)KiThreadStartup; SwitchFrame->Eflags = EFLAGS_INTERRUPT_MASK; #if 0 // // If AutoAlignment is FALSE, we want to set the Alignment Check bit // in Eflags, so we will get alignment faults. // if (Thread->AutoAlignment == FALSE) { SwitchFrame->Eflags |= EFLAGS_ALIGN_CHECK; } #endif SwitchFrame->ExceptionList = (ULONG)(EXCEPTION_CHAIN_END); // // Set the initial kernel stack pointer. // //DbgPrint("KiInitializeContextThread Thread %08x SwitchFrame %08x\n", Thread, SwitchFrame); //DbgPrint("PSystemRoutine %08x PStartRoutine %08x PStartContext %08x\n", *PSystemRoutine, *PStartRoutine, *PStartContext); Thread->KernelStack = (PVOID)SwitchFrame; return; } BOOLEAN KeSetAutoAlignmentProcess ( IN PKPROCESS Process, IN BOOLEAN Enable ) /*++ Routine Description: This function sets the data alignment handling mode for the specified process and returns the previous data alignment handling mode. Arguments: Process - Supplies a pointer to a dispatcher object of type process. Enable - Supplies a boolean value that determines the handling of data alignment exceptions for the process. A value of TRUE causes all data alignment exceptions to be automatically handled by the kernel. A value of FALSE causes all data alignment exceptions to be actually raised as exceptions. Return Value: A value of TRUE is returned if data alignment exceptions were previously automatically handled by the kernel. Otherwise, a value of FALSE is returned. --*/ { KIRQL OldIrql; BOOLEAN Previous; ASSERT_PROCESS(Process); // // Raise IRQL to dispatcher level and lock dispatcher database. // KiLockDispatcherDatabase(&OldIrql); // // Capture the previous data alignment handling mode and set the // specified data alignment mode. // Previous = Process->AutoAlignment; Process->AutoAlignment = Enable; // // Unlock dispatcher database, lower IRQL to its previous value, and // return the previous data alignment mode. // KiUnlockDispatcherDatabase(OldIrql); return Previous; } BOOLEAN KeSetAutoAlignmentThread ( IN PKTHREAD Thread, IN BOOLEAN Enable ) /*++ Routine Description: This function sets the data alignment handling mode for the specified thread and returns the previous data alignment handling mode. Arguments: Thread - Supplies a pointer to a dispatcher object of type thread. Enable - Supplies a boolean value that determines the handling of data alignment exceptions for the specified thread. A value of TRUE causes all data alignment exceptions to be automatically handled by the kernel. A value of FALSE causes all data alignment exceptions to be actually raised as exceptions. Return Value: A value of TRUE is returned if data alignment exceptions were previously automatically handled by the kernel. Otherwise, a value of FALSE is returned. --*/ { BOOLEAN Previous; PKAPC Apc; PKEVENT Event; KIRQL OldIrql; ASSERT_THREAD(Thread); // // Raise IRQL to dispatcher level and lock dispatcher database. // KiLockDispatcherDatabase(&OldIrql); // // Capture the previous data alignment handling mode and set the // specified data alignment mode. // Previous = Thread->AutoAlignment; Thread->AutoAlignment = Enable; // // Unlock dispatcher database and lower IRQL to its previous value. // KiUnlockDispatcherDatabase(OldIrql); #if 0 Apc = ExAllocatePool(NonPagedPoolMustSucceed, sizeof(KAPC)); Event = ExAllocatePool(NonPagedPoolMustSucceed, sizeof(KEVENT)); KeInitializeEvent(Event, NotificationEvent, FALSE); if ( Thread == KeGetCurrentThread() ) { Apc->SystemArgument1 = Thread; Apc->SystemArgument2 = Event; KeRaiseIrql(APC_LEVEL, &Irql); KepSetAlignmentSpecialApc( Apc, NULL, NULL, &Apc->SystemArgument1, &Apc->SystemArgument2 ); KeLowerIrql(Irql); } else { KeInitializeApc( Apc, Thread, CurrentApcEnvironment, KepSetAlignmentSpecialApc, NULL, NULL, KernelMode, NULL ); if (!KeInsertQueueApc( Apc, Thread, Event, 2 ) ) { // // We couldn't queue the APC, so we will not be able to change // the AutoAlignment. Update the thread object so that it // stays in sync with the hardware state. // #if DBG DbgPrint("KeSetAutoAlignmentThread: unable to change thread's context\n"); #endif Thread->AutoAlignment = Previous; } KeWaitForSingleObject( Event, Executive, KernelMode, FALSE, NULL ); } ExFreePool(Apc); ExFreePool(Event); #endif return(Previous); } #if 0 VOID KepSetAlignmentSpecialApc( IN PKAPC Apc, IN PKNORMAL_ROUTINE *NormalRoutine, IN PVOID *NormalContext, IN PVOID *SystemArgument1, IN PVOID *SystemArgument2 ) /*++ Routine Description: This function updates the alignment check bit of the current thread's EFLAGS to reflect the AutoAlignment setting of the thread object. Arguments: Apc - Supplies a pointer to the APC control object that caused entry into this routine. NormalRoutine - Supplies a pointer to a pointer to the normal routine function that was specifed when the APC was initialized. NormalContext - Supplies a pointer to a pointer to an arbitrary data structure that was specified when the APC was initialized. SystemArgument1 - Supplies a pointer to a PKTHREAD SystemArgument2 - Supplies a pointer to a PKEVENT Return Value: None. --*/ { PKTHREAD Thread; PKEVENT Event; PKTRAP_FRAME TrapFrame; CONTEXT ContextFrame; Thread = *(PKTHREAD *)SystemArgument1; Event = *(PKEVENT *)SystemArgument2; ASSERT( Thread == KeGetCurrentThread() ); // // Find the trap frame on the stack, so we can get the thread context // TrapFrame = (PKTRAP_FRAME)((PUCHAR)Thread->InitialStack - ALIGN_UP(sizeof(KTRAP_FRAME),KTRAP_FRAME_ALIGN) - sizeof(FX_SAVE_AREA)); ContextFrame.ContextFlags = CONTEXT_CONTROL; KeContextFromKframes( TrapFrame, NULL, &ContextFrame ); // // If AutoAlignment is TRUE, we want the processor to transparently fixup // all alignment faults, so we clear the Alignment Check bit. If // AutoAlignment is FALSE, we set the bit, so 486 processors will // give us alignment faults. // if (Thread->AutoAlignment) { ContextFrame.EFlags &= (~EFLAGS_ALIGN_CHECK); } else { ContextFrame.EFlags |= EFLAGS_ALIGN_CHECK; } // // Replace the modified EFlags in the trap frame. When the thread returns // to user mode, it will be running with the new alignment setting. // KeContextToKframes( TrapFrame, NULL, &ContextFrame, CONTEXT_CONTROL, KeGetPreviousMode() ); KeSetEvent(Event,0,FALSE); } #endif