ntoskrnl/ke/i386/usercall_asm.S

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/ke/i386/usercall_asm.S
   5  * PURPOSE:         User-Mode callbacks and return.
   6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <asm.inc>
  12 #include <ks386.inc>
  13 #include <internal/i386/asmmacro.S>
  14
  15 EXTERN _MmGrowKernelStack@4:PROC
  16 EXTERN _KeUserCallbackDispatcher:PROC
  17 EXTERN @KiServiceExit@8:PROC
  18
  19 /* FUNCTIONS ****************************************************************/
  20 .code
  21
  22 PUBLIC _KiGetUserModeStackAddress@0
  23 _KiGetUserModeStackAddress@0:
  24
  25     /* Get the current thread's trapframe and return the esp */
  26     mov eax, fs:[KPCR_CURRENT_THREAD]
  27     mov eax, [eax+KTHREAD_TRAP_FRAME]
  28     lea eax, [eax+KTRAP_FRAME_ESP]
  29     ret
  30
  31
  32 /*++
  33  * @name KiCallUserMode
  34  *
  35  *     The KiSwitchToUserMode routine sets up a Trap Frame and a Callback stack
  36  *     for the purpose of switching to user mode. The actual final jump is done
  37  *     by KiServiceExit which will treat this as a syscall return.
  38  *
  39  * @param OutputBuffer
  40  *        Pointer to a caller-allocated buffer where to receive the return data
  41  *        from the user-mode function
  42  *
  43  * @param OutputLength
  44  *        Size of the Output Buffer described above.
  45  *
  46  * @return None. Jumps into KiServiceExit.
  47  *
  48  * @remark If there is not enough Kernel Stack space, the routine will increase the
  49  *         Kernel Stack.
  50  *
  51  *         User mode execution resumes at ntdll!KiUserCallbackDispatcher.
  52  *
  53  *         This call MUST be paired by interrupt 0x2B or NtCallbackReturn.
  54  *
  55  *--*/
  56 PUBLIC _KiCallUserMode@8
  57 _KiCallUserMode@8:
  58
  59     /* Save volatile registers */
  60     push ebp
  61     push ebx
  62     push esi
  63     push edi
  64
  65     /* Get the current thread */
  66     mov ebx, fs:[KPCR_CURRENT_THREAD]
  67
  68     /* Make sure we're at passive */
  69 #if DBG
  70     call _KeGetCurrentIrql@0
  71     or al, al
  72     jz AtPassive
  73
  74     /* We're not, bugcheck! */
  75     push 0
  76     push 0
  77     push eax
  78     push 0
  79     push IRQL_GT_ZERO_AT_SYSTEM_SERVICE
  80     call _KeBugCheckEx@20
  81
  82 AtPassive:
  83
  84     /* Make sure that we are not attached and that APCs are not disabled */
  85     movzx eax, byte ptr [ebx+KTHREAD_APC_STATE_INDEX]
  86     mov edx, [ebx+KTHREAD_COMBINED_APC_DISABLE]
  87     or eax, eax
  88     jnz InvalidIndex
  89     or edx, edx
  90     jz ApcsEnabled
  91
  92 InvalidIndex:
  93
  94     push 0
  95     push edx
  96     push eax
  97     push 0
  98     push APC_INDEX_MISMATCH
  99     call _KeBugCheckEx@20
 100 ApcsEnabled:
 101 #endif
 102
 103     /* Get the lowest stack limit and check if we can handle it */
 104     lea eax, [esp-HEX(3000)]
 105     cmp eax, [ebx+KTHREAD_STACK_LIMIT]
 106     jnb StackOk
 107
 108     /* We can't, we'll have to grow our stack */
 109     push esp
 110     call _MmGrowKernelStack@4
 111
 112     /* Quit if we failed */
 113     or eax, eax
 114     jnz GrowFailed
 115
 116     /* Save the current callback stack */
 117 StackOk:
 118     push [ebx+KTHREAD_CALLBACK_STACK]
 119
 120     /* Get and save the trap frame */
 121     mov edx, [ebx+KTHREAD_TRAP_FRAME]
 122     push edx
 123
 124     /* Get and save the initial stack */
 125     mov esi, [ebx+KTHREAD_INITIAL_STACK]
 126     push esi
 127
 128     /* Set the new callback stack */
 129     mov [ebx+KTHREAD_CALLBACK_STACK], esp
 130
 131     /* Align stack on 16-byte boundary */
 132     and esp, NOT 15
 133     mov edi, esp
 134
 135     /* Set destination and origin NPX Areas */
 136     sub esp, NPX_FRAME_LENGTH
 137     sub esi, NPX_FRAME_LENGTH
 138
 139     /* Disable interrupts so we can fill the NPX State */
 140     cli
 141
 142     /* Now copy the NPX State */
 143     mov ecx, [esi+FP_CONTROL_WORD]
 144     mov [esp+FP_CONTROL_WORD], ecx
 145     mov ecx, [esi+FP_STATUS_WORD]
 146     mov [esp+FP_STATUS_WORD], ecx
 147     mov ecx, [esi+FP_TAG_WORD]
 148     mov [esp+FP_TAG_WORD], ecx
 149     mov ecx, [esi+FP_DATA_SELECTOR]
 150     mov [esp+FP_DATA_SELECTOR], ecx
 151     mov ecx, [esi+FN_CR0_NPX_STATE]
 152     mov [esp+FN_CR0_NPX_STATE], ecx
 153
 154     /* Get TSS */
 155     mov esi, fs:[KPCR_TSS]
 156
 157     /* Set the stack address */
 158     mov [ebx+KTHREAD_INITIAL_STACK], edi
 159
 160     /* Bias the stack for V86 mode */
 161     mov ecx, esp
 162     sub esp, 16
 163     test dword ptr [edx+KTRAP_FRAME_EFLAGS], EFLAGS_V86_MASK
 164     jnz DontBias
 165     mov ecx, esp
 166
 167 DontBias:
 168     /* Set new stack address in TSS */
 169     mov [esi+KTSS_ESP0], ecx
 170
 171     /* Allocate the trap frame and set it */
 172     sub esp, KTRAP_FRAME_V86_ES
 173     mov ebp, esp
 174
 175     /* Set copy iterator and dest/origin parameters and do the copy */
 176     mov ecx, (KTRAP_FRAME_V86_ES - KTRAP_FRAME_FS) / 4
 177     lea edi, [esp+KTRAP_FRAME_FS]
 178     lea esi, [edx+KTRAP_FRAME_FS]
 179     rep movsd
 180
 181     /* Copy DR7 */
 182     mov edi, [edx+KTRAP_FRAME_DR7]
 183     test edi, NOT DR7_RESERVED_MASK
 184     mov [esp+KTRAP_FRAME_DR7], edi
 185
 186     /* Check if we need to save debug registers */
 187     jnz SaveDebug
 188
 189     /* Get user-mode dispatcher address and set it as EIP */
 190 SetEip:
 191     mov eax, _KeUserCallbackDispatcher
 192     mov [esp+KTRAP_FRAME_EIP], eax
 193
 194     /* Set the exception list */
 195     mov eax, fs:[KPCR_EXCEPTION_LIST]
 196     mov [esp+KTRAP_FRAME_EXCEPTION_LIST], eax
 197
 198     /* Set the previous mode */
 199     mov eax, [edx+KTRAP_FRAME_PREVIOUS_MODE]
 200     mov [esp+KTRAP_FRAME_PREVIOUS_MODE], eax
 201
 202     /* Bring interrupts back */
 203     sti
 204
 205     /* Exit to user-mode */
 206     mov ecx, esp
 207     jmp @KiServiceExit@8
 208
 209 SaveDebug:
 210
 211     /* Copy all 5 DRs */
 212     mov ecx, 5
 213     lea edi, [esp+KTRAP_FRAME_DR0]
 214     lea esi, [edx+KTRAP_FRAME_DR0]
 215     rep movsd
 216     jmp SetEip
 217
 218 GrowFailed:
 219     /* Restore registers */
 220     pop edi
 221     pop esi
 222     pop ebx
 223     pop ebp
 224
 225     /* Return */
 226     ret 8
 227
 228
 229 /*++
 230  * @name NtCallbackReturn
 231  *
 232  *     The NtCallbackReturn routine returns to kernel mode after a user-mode
 233  *     callback was done through KeUserModeCallback. It uses the callback frame
 234  *     which was setup in order to return the information, restores the stack,
 235  *     and resumes execution where it was left off.
 236  *
 237  * @param Result
 238  *        Pointer to a caller-allocated buffer where the return data
 239  *               from the user-mode function is located.
 240  *
 241  * @param ResultLength
 242  *        Size of the Output Buffer described above.
 243  *
 244  * @param CallbackStatus
 245  *        Status code of the callback operation.
 246  *
 247  * @return Status code of the callback operation.
 248  *
 249  * @remark This call MUST be paired with KeUserModeCallback.
 250  *
 251  *--*/
 252 PUBLIC _NtCallbackReturn@12
 253 _NtCallbackReturn@12:
 254
 255     /* Get the current thread and make sure we have a callback stack */
 256     mov eax, fs:[KPCR_CURRENT_THREAD]
 257     mov ecx, [eax+KTHREAD_CALLBACK_STACK]
 258     test ecx, ecx
 259     jz NoStack
 260
 261     /* Get the trap frame */
 262     mov ebx, [eax+KTHREAD_TRAP_FRAME]
 263
 264     /* Restore the exception list */
 265     mov edx, [ebx+KTRAP_FRAME_EXCEPTION_LIST]
 266     mov fs:[KPCR_EXCEPTION_LIST], edx
 267
 268     /* Get the result, the result length and the status */
 269     mov edi, [esp+4]
 270     mov esi, [esp+8]
 271     mov ebp, [esp+12]
 272
 273     /* Store the results in the callback stack */
 274     mov ebx, [ecx+CBSTACK_RESULT]
 275     mov [ebx], edi
 276     mov ebx, [ecx+CBSTACK_RESULT_LENGTH]
 277     mov [ebx], esi
 278
 279     /* Get the previous stack */
 280     mov ebx, [ecx]
 281
 282     /* Disable interrupts for NPX save and stack switch */
 283     cli
 284
 285     /* Get the initial stack and restore it */
 286     mov esi, [eax+KTHREAD_INITIAL_STACK]
 287     mov [eax+KTHREAD_INITIAL_STACK], ebx
 288
 289     /* Set desination and origin NPX Frames */
 290     sub esi, NPX_FRAME_LENGTH
 291     sub ebx, NPX_FRAME_LENGTH
 292
 293     /* Copy NPX Data */
 294     mov edx, [esi+FP_CONTROL_WORD]
 295     mov [ebx+FP_CONTROL_WORD], edx
 296     mov edx, [esi+FP_STATUS_WORD]
 297     mov [ebx+FP_STATUS_WORD], edx
 298     mov edx, [esi+FP_TAG_WORD]
 299     mov [ebx+FP_TAG_WORD], edx
 300     mov edx, [esi+FP_DATA_SELECTOR]
 301     mov [ebx+FP_DATA_SELECTOR], edx
 302     mov edx, [esi+FN_CR0_NPX_STATE]
 303     mov [ebx+FN_CR0_NPX_STATE], edx
 304
 305     /* Check if we failed in user mode */
 306     cmp ebp, STATUS_CALLBACK_POP_STACK
 307     mov edi, [ecx+CBSTACK_TRAP_FRAME]
 308     jz UserFault
 309
 310 CheckDebug:
 311
 312     /* Clear DR7 */
 313     and dword ptr [edi+KTRAP_FRAME_DR7], 0
 314
 315     /* Check if debugging was active */
 316     test byte ptr [eax+KTHREAD_DEBUG_ACTIVE], HEX(0FF)
 317     jnz RestoreDebug
 318
 319 RestoreStack:
 320
 321     /* Get TSS */
 322     mov edx, fs:[KPCR_TSS]
 323
 324     /* Restore stack pointer */
 325     lea esp, [ecx+CBSTACK_CALLBACK_STACK]
 326
 327     /* Check if we were in V86 mode */
 328     test dword ptr [edi+KTRAP_FRAME_EFLAGS], EFLAGS_V86_MASK
 329     jnz V86Ret
 330     sub ebx, 16
 331
 332 V86Ret:
 333     /* Restore the ESP in TSS */
 334     mov [edx+KTSS_ESP0], ebx
 335
 336     /* Restore the trap frame */
 337     mov [eax+KTHREAD_TRAP_FRAME], edi
 338
 339     /* Bring interrupts back */
 340     sti
 341
 342     /* Restore the callback stack*/
 343     pop [eax+KTHREAD_CALLBACK_STACK]
 344
 345     /* Set status and return */
 346     mov eax, ebp
 347     pop edi
 348     pop esi
 349     pop ebx
 350     pop ebp
 351     pop edx
 352
 353     /* Clean stack and jump back */
 354     add esp, 8
 355     jmp edx
 356
 357 UserFault:
 358     /* Set size to copy */
 359     mov ecx, (KTRAP_FRAME_V86_ES - KTRAP_FRAME_FS) / 4
 360
 361     /* Check if this was V86 mode */
 362     mov esi, [eax+KTHREAD_TRAP_FRAME]
 363     test dword ptr [esi+KTRAP_FRAME_EFLAGS], EFLAGS_V86_MASK
 364
 365     /* Save EDI and load destination */
 366     mov edx, edi
 367     lea edi, [edi+KTRAP_FRAME_FS]
 368     jz NotV86
 369     add ecx, 16 / 4
 370
 371 NotV86:
 372     /* Set source and copy */
 373     lea esi, [esi+KTRAP_FRAME_FS]
 374     rep movsd
 375
 376     /* Restore ECX and ECX */
 377     mov ecx, [eax+KTHREAD_CALLBACK_STACK]
 378     mov edi, edx
 379     jmp CheckDebug
 380
 381 RestoreDebug:
 382     /* Get a pointer to thread's trap frame */
 383     mov esi, [eax+KTHREAD_TRAP_FRAME]
 384
 385     /* Copy debug registers data from it */
 386     mov edx, [esi+KTRAP_FRAME_DR0]
 387     mov [edi+KTRAP_FRAME_DR0], edx
 388     mov edx, [esi+KTRAP_FRAME_DR1]
 389     mov [edi+KTRAP_FRAME_DR1], edx
 390     mov edx, [esi+KTRAP_FRAME_DR2]
 391     mov [edi+KTRAP_FRAME_DR2], edx
 392     mov edx, [esi+KTRAP_FRAME_DR3]
 393     mov [edi+KTRAP_FRAME_DR3], edx
 394     mov edx, [esi+KTRAP_FRAME_DR6]
 395     mov [edi+KTRAP_FRAME_DR6], edx
 396     mov edx, [esi+KTRAP_FRAME_DR7]
 397     mov [edi+KTRAP_FRAME_DR7], edx
 398
 399     /* Jump back */
 400     jmp RestoreStack
 401
 402 NoStack:
 403
 404     /* Return failure */
 405     mov eax, STATUS_NO_CALLBACK_ACTIVE
 406     ret 12
 407
 408 /*++
 409  * @name KeSwitchKernelStack
 410  *
 411  *     The KeSwitchKernelStack routine switches from the current thread's stack
 412  *     to the new specified base and limit.
 413  *
 414  * @param StackBase
 415  *        Pointer to the new Stack Base of the thread.
 416  *
 417  * @param StackLimit
 418  *        Pointer to the new Stack Limit of the thread.
 419  *
 420  * @return The previous Stack Base of the thread.
 421  *
 422  * @remark This routine should typically only be used when converting from a
 423  *         non-GUI to a GUI Thread. The caller is responsible for freeing the
 424  *         previous stack. The new stack values MUST be valid before calling
 425  *         this routine.
 426  *
 427  *--*/
 428 PUBLIC _KeSwitchKernelStack@8
 429 _KeSwitchKernelStack@8:
 430
 431     /* Save volatiles */
 432     push esi
 433     push edi
 434
 435     /* Get current thread */
 436     mov edx, fs:[KPCR_CURRENT_THREAD]
 437
 438     /* Get new and current base */
 439     mov edi, [esp+12]
 440     mov ecx, [edx+KTHREAD_STACK_BASE]
 441
 442     /* Fixup the frame pointer */
 443     sub ebp, ecx
 444     add ebp, edi
 445
 446     /* Fixup the trap frame */
 447     mov eax, [edx+KTHREAD_TRAP_FRAME]
 448     sub eax, ecx
 449     add eax, edi
 450     mov [edx+KTHREAD_TRAP_FRAME], eax
 451
 452     /* Calculate stack size */
 453     sub ecx, esp
 454
 455     /* Get desination and origin */
 456     sub edi, ecx
 457     mov esi, esp
 458
 459     /* Save stack pointer */
 460     push edi
 461
 462     /* Copy stack */
 463     rep movsb
 464
 465     /* Restore stack pointer */
 466     pop edi
 467
 468     /* Save old stack base and get new limit/base */
 469     mov eax, [edx+KTHREAD_STACK_BASE]
 470     mov ecx, [esp+12]
 471     mov esi, [esp+16]
 472
 473     /* Disable interrupts for stack switch */
 474     cli
 475
 476     /* Set new base/limit */
 477     mov [edx+KTHREAD_STACK_BASE], ecx
 478     mov [edx+KTHREAD_STACK_LIMIT], esi
 479
 480     /* Set LargeStack */
 481     mov byte ptr [edx+KTHREAD_LARGE_STACK], 1
 482
 483     /* Set new initial stack */
 484     mov [edx+KTHREAD_INITIAL_STACK], ecx
 485
 486     /* Get trap frame */
 487     mov esi, [edx+KTHREAD_TRAP_FRAME]
 488
 489     /* Get TSS */
 490     mov edx, fs:[KPCR_TSS]
 491
 492     /* Check if we came from V86 mode */
 493     test dword ptr [esi+KTRAP_FRAME_EFLAGS], EFLAGS_V86_MASK
 494
 495     /* Bias for NPX Area */
 496     lea ecx, [ecx-NPX_FRAME_LENGTH]
 497     jnz V86Switch
 498     sub ecx, 16
 499
 500 V86Switch:
 501
 502     /* Update ESP in TSS */
 503     mov [edx+KTSS_ESP0], ecx
 504
 505     /* Update stack pointer */
 506     mov esp, edi
 507
 508     /* Bring back interrupts and return */
 509     sti
 510     pop edi
 511     pop esi
 512     ret 8
 513
 514 END