mpsirql.c File Reference

#include <hal.h>
#include <debug.h>

Include dependency graph for mpsirql.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
KIRQL NTAPI	KeGetCurrentIrql (VOID)
VOID	KeSetCurrentIrql (KIRQL NewIrql)
VOID	HalpLowerIrql (KIRQL NewIrql, BOOLEAN FromHalEndSystemInterrupt)
VOID FASTCALL	KfLowerIrql (KIRQL NewIrql)
KIRQL FASTCALL	KfRaiseIrql (KIRQL NewIrql)
KIRQL NTAPI	KeRaiseIrqlToDpcLevel (VOID)
KIRQL NTAPI	KeRaiseIrqlToSynchLevel (VOID)
BOOLEAN NTAPI	HalBeginSystemInterrupt (KIRQL Irql, ULONG Vector, PKIRQL OldIrql)
VOID NTAPI	HalEndSystemInterrupt (KIRQL Irql, IN PKTRAP_FRAME TrapFrame)
VOID NTAPI	HalDisableSystemInterrupt (ULONG Vector, KIRQL Irql)
BOOLEAN NTAPI	HalEnableSystemInterrupt (ULONG Vector, KIRQL Irql, KINTERRUPT_MODE InterruptMode)
VOID FASTCALL	HalRequestSoftwareInterrupt (IN KIRQL Request)
VOID FASTCALL	HalClearSoftwareInterrupt (IN KIRQL Request)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 15 of file mpsirql.c.

Function Documentation

HalBeginSystemInterrupt()

BOOLEAN NTAPI HalBeginSystemInterrupt	(	KIRQL	Irql,
		ULONG	Vector,
		PKIRQL	OldIrql
	)

Definition at line 244 of file mpsirql.c.

{
  ULONG Flags;
  DPRINT("Vector (0x%X)  Irql (0x%X)\n", Vector, Irql);
 
  if (KeGetCurrentIrql () >= Irql)
  {
    DPRINT1("current irql %d, new irql %d\n", KeGetCurrentIrql(), Irql);
    ASSERT(FALSE);
  }
 
  Flags = __readeflags();
  if (Flags & EFLAGS_INTERRUPT_MASK)
  {
     DPRINT1("HalBeginSystemInterrupt was called with interrupt's enabled\n");
     ASSERT(FALSE);
  }
  APICWrite (APIC_TPR, IRQL2TPR (Irql) & APIC_TPR_PRI);
  *OldIrql = KeGetCurrentIrql ();
  KeSetCurrentIrql (Irql);
  return(TRUE);
}

HalClearSoftwareInterrupt()

VOID FASTCALL HalClearSoftwareInterrupt

(

IN KIRQL

Request

)

Definition at line 354 of file mpsirql.c.

{
  UNIMPLEMENTED;
}

HalDisableSystemInterrupt()

VOID NTAPI HalDisableSystemInterrupt	(	ULONG	Vector,
		KIRQL	Irql
	)

Definition at line 291 of file mpsirql.c.

{
  ULONG irq;
 
  DPRINT ("Vector (0x%X)\n", Vector);
 
  if (Vector < FIRST_DEVICE_VECTOR ||
      Vector >= FIRST_DEVICE_VECTOR + NUMBER_DEVICE_VECTORS)
  {
    DPRINT1("Not a device interrupt, vector=%x\n", Vector);
    ASSERT(FALSE);
    return;
  }
 
  irq = VECTOR2IRQ (Vector);
  IOAPICMaskIrq (irq);
 
  return;
}

HalEnableSystemInterrupt()

BOOLEAN NTAPI HalEnableSystemInterrupt	(	ULONG	Vector,
		KIRQL	Irql,
		KINTERRUPT_MODE	InterruptMode
	)

Definition at line 314 of file mpsirql.c.

{
  ULONG irq;
 
  if (Vector < FIRST_DEVICE_VECTOR ||
      Vector >= FIRST_DEVICE_VECTOR + NUMBER_DEVICE_VECTORS)
  {
    DPRINT("Not a device interrupt\n");
    return FALSE;
  }
 
  /* FIXME: We must check if the requested and the assigned interrupt mode is the same */
 
  irq = VECTOR2IRQ (Vector);
  IOAPICUnmaskIrq (irq);
 
  return TRUE;
}

HalEndSystemInterrupt()

VOID NTAPI HalEndSystemInterrupt	(	KIRQL	Irql,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 271 of file mpsirql.c.

{
  ULONG Flags;
  Flags = __readeflags();
 
  if (Flags & EFLAGS_INTERRUPT_MASK)
  {
     DPRINT1("HalEndSystemInterrupt was called with interrupt's enabled\n");
     ASSERT(FALSE);
  }
  APICSendEOI();
  HalpLowerIrql (Irql, TRUE);
}

HalpLowerIrql()

VOID HalpLowerIrql	(	KIRQL	NewIrql,
		BOOLEAN	FromHalEndSystemInterrupt
	)

Definition at line 72 of file mpsirql.c.

{
  ULONG Flags;
  UCHAR DpcRequested;
  if (NewIrql >= DISPATCH_LEVEL)
    {
      KeSetCurrentIrql (NewIrql);
      APICWrite(APIC_TPR, IRQL2TPR (NewIrql) & APIC_TPR_PRI);
      return;
    }
  Flags = __readeflags();
  if (KeGetCurrentIrql() > APC_LEVEL)
    {
      KeSetCurrentIrql (DISPATCH_LEVEL);
      APICWrite(APIC_TPR, IRQL2TPR (DISPATCH_LEVEL) & APIC_TPR_PRI);
      DpcRequested = __readfsbyte(FIELD_OFFSET(KPCR, HalReserved[HAL_DPC_REQUEST]));
      if (FromHalEndSystemInterrupt || DpcRequested)
        {
          __writefsbyte(FIELD_OFFSET(KPCR, HalReserved[HAL_DPC_REQUEST]), 0);
          _enable();
          KiDispatchInterrupt();
          if (!(Flags & EFLAGS_INTERRUPT_MASK))
            {
              _disable();
            }
    }
      KeSetCurrentIrql (APC_LEVEL);
    }
  if (NewIrql == APC_LEVEL)
    {
      return;
    }
  if (KeGetCurrentThread () != NULL &&
      KeGetCurrentThread ()->ApcState.KernelApcPending)
    {
      _enable();
      KiDeliverApc(KernelMode, NULL, NULL);
      if (!(Flags & EFLAGS_INTERRUPT_MASK))
        {
          _disable();
        }
    }
  KeSetCurrentIrql (PASSIVE_LEVEL);
}

Referenced by HalEndSystemInterrupt(), and KfLowerIrql().

HalRequestSoftwareInterrupt()

VOID FASTCALL HalRequestSoftwareInterrupt

(

IN KIRQL

Request

)

Definition at line 336 of file mpsirql.c.

{
  switch (Request)
  {
    case APC_LEVEL:
      __writefsbyte(FIELD_OFFSET(KPCR, HalReserved[HAL_APC_REQUEST]), 1);
      break;
 
    case DISPATCH_LEVEL:
      __writefsbyte(FIELD_OFFSET(KPCR, HalReserved[HAL_DPC_REQUEST]), 1);
      break;
 
    default:
      ASSERT(FALSE);
  }
}

KeGetCurrentIrql()

KIRQL NTAPI KeGetCurrentIrql

(

VOID

)

Definition at line 24 of file mpsirql.c.

{
  KIRQL irql;
  ULONG Flags;
 
  Flags = __readeflags();
  _disable();
 
  irql = __readfsbyte(FIELD_OFFSET(KPCR, Irql));
  if (irql > HIGH_LEVEL)
    {
      DPRINT1 ("CurrentIrql %x\n", irql);
      ASSERT(FALSE);
    }
  if (Flags & EFLAGS_INTERRUPT_MASK)
    {
      _enable();
    }
  return irql;
}

KeRaiseIrqlToDpcLevel()

KIRQL NTAPI KeRaiseIrqlToDpcLevel

(

VOID

)

Definition at line 213 of file mpsirql.c.

{
  return KfRaiseIrql (DISPATCH_LEVEL);
}

KeRaiseIrqlToSynchLevel()

KIRQL NTAPI KeRaiseIrqlToSynchLevel

(

VOID

)

Definition at line 237 of file mpsirql.c.

{
  return KfRaiseIrql (CLOCK2_LEVEL);
}

KeSetCurrentIrql()

VOID KeSetCurrentIrql

(

KIRQL

NewIrql

)

Definition at line 51 of file mpsirql.c.

{
  ULONG Flags;
  if (NewIrql > HIGH_LEVEL)
  {
    DPRINT1 ("NewIrql %x\n", NewIrql);
    ASSERT(FALSE);
  }
  Flags = __readeflags();
  _disable();
  __writefsbyte(FIELD_OFFSET(KPCR, Irql), NewIrql);
  if (Flags & EFLAGS_INTERRUPT_MASK)
    {
      _enable();
    }
}

Referenced by HalBeginSystemInterrupt(), HalpLowerIrql(), KfRaiseIrql(), and KiInitializeCpu().

KfLowerIrql()

VOID FASTCALL KfLowerIrql

(

KIRQL

NewIrql

)

Definition at line 135 of file mpsirql.c.

{
  KIRQL oldIrql = KeGetCurrentIrql();
  if (NewIrql > oldIrql)
    {
      DPRINT1 ("NewIrql %x CurrentIrql %x\n", NewIrql, oldIrql);
      ASSERT(FALSE);
    }
  HalpLowerIrql (NewIrql, FALSE);
}

KfRaiseIrql()

KIRQL FASTCALL KfRaiseIrql

(

KIRQL

NewIrql

)

Definition at line 165 of file mpsirql.c.

{
  KIRQL OldIrql;
  ULONG Flags;
 
  Flags = __readeflags();
  _disable();
 
  OldIrql = KeGetCurrentIrql ();
 
  if (NewIrql < OldIrql)
    {
      DPRINT1 ("CurrentIrql %x NewIrql %x\n", KeGetCurrentIrql (), NewIrql);
      ASSERT(FALSE);
    }
 
 
  if (NewIrql > DISPATCH_LEVEL)
    {
      APICWrite (APIC_TPR, IRQL2TPR(NewIrql) & APIC_TPR_PRI);
    }
  KeSetCurrentIrql (NewIrql);
  if (Flags & EFLAGS_INTERRUPT_MASK)
    {
      _enable();
    }
 
  return OldIrql;
}

Referenced by KeRaiseIrqlToDpcLevel(), and KeRaiseIrqlToSynchLevel().