VOID
KeEnterGuardedRegionThread (
    IN PKTHREAD Thread
    )
{
    ...
    ...
    Thread->SpecialApcDisable -= 1;  // Her türlü APC işlenmesi itinayla engellendi
    ...
    ...
    return;
}

VOID
KeEnterCriticalRegionThread (
    PKTHREAD Thread
    )
{
    ...
    ...
    Thread->KernelApcDisable -= 1; // Normal çekirdek modu APC işlenmesi engellendi
    ....
    return;
}

union
{
    struct
    {
        SHORT KernelApcDisable;   // Normal çekirdek APCleri durumu
        SHORT SpecialApcDisable;  // Özel çekirdek APCleri durumu
    };
    ULONG CombinedApcDisable;
};

VOID
KeLeaveGuardedRegionThread (
    IN PKTHREAD Thread
    )
{
    ...
    ...
    if ((Thread->SpecialApcDisable += 1) == 0) { 
        if (Thread->ApcState.ApcListHead[KernelMode].Flink != &Thread->ApcState.ApcListHead[KernelMode]) {
            KiCheckForKernelApcDelivery();
        }                                                             
    }                                                                 
    return;
}

typedef struct _KAPC_STATE
{
     LIST_ENTRY ApcListHead[2];  // Çekirdek ve kullanıcı modu APCleri için ayrı 2 liste
     PKPROCESS Process;          // APCnin hedefi olan işlemin nesnesi
     UCHAR KernelApcInProgress;  // Şu anda bir çekirdek modu APCsi işleniyor bayrağı
     UCHAR KernelApcPending;     // Çekirdek modu APCsi işlenmeyi bekliyor bayrağı
     UCHAR UserApcPending;       // Kullanıcı modu APCsi işlenmeyi bekliyor bayrağı
} KAPC_STATE, *PKAPC_STATE;

...
...
Thread = KeGetCurrentThread();             // Mevcut işlemcik nesnesini al
if (Thread->SpecialApcDisable == 0) {      // Özel çekirdek APCleri işleyebilir durumda mıyız?
    // Hmm, çekirdek APC listesi boş olmadığı sürece işle bakalım 
    while (IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE) { 

        //
        // (Hâlâ) Boş değilll. O zaman IRQL'yi DISPATCHER_LEVEL seviyesine çıkarıp 
        // APC listesini kitleyelim, ve işleyebileceğimiz bir çekirdek modu 
        // APC var mı bakalım.
        //
        // Eğer bu liste boş ise, aşağıda kullanıcı modu APClerini işleyeceğiz
        //

        KeAcquireInStackQueuedSpinLock(&Thread->ApcQueueLock, &LockHandle); // APC listesini kilitle
        NextEntry = Thread->ApcState.ApcListHead[KernelMode].Flink;         // Listeden girdi al
        if (NextEntry == &Thread->ApcState.ApcListHead[KernelMode]) {       // sahi girdi var mı?
            KeReleaseInStackQueuedSpinLock(&LockHandle);                    // yok. çık o zaman
            break;
        }

        //
        // Çekirdek APC beklemede bayrağını temizle, APC nesnesini al,
        // ardından tipini belirleyip çalıştır.
        //

        Thread->ApcState.KernelApcPending = FALSE;              // Artık çekirdek APCsi beklemiyor
        Apc = CONTAINING_RECORD(NextEntry, KAPC, ApcListEntry); // KAPC yapısı alınıyor
        ReadForWriteAccess(Apc);
        KernelRoutine = Apc->KernelRoutine;  // Çalışacak olan APC rutinleri KAPC yapısından alınıyor
        NormalRoutine = Apc->NormalRoutine;  // bunların işlevleri için önceki yazıya bakabilirsiniz
        NormalContext = Apc->NormalContext;
        SystemArgument1 = Apc->SystemArgument1;
        SystemArgument2 = Apc->SystemArgument2;
        if (NormalRoutine == (PKNORMAL_ROUTINE)NULL) {  // Normal rutin değeri var mı? Eğer 
                                                        // yoksa demek ki özel çekirdek APCsi
            //
            // Ah, evet yokmuş. Demek ki bu sahiden özel bir çekirdek APCsi.
            // O zaman APC listesinden bu APCyi silelim, APCnin listeye eklendiği
            // bilgisini (Inserted) eklenmedi olarak değiştirip, kilidi açalım 
            // ve APCyi çalıştıralım
            // 

            RemoveEntryList(NextEntry);                  // APC listeden siliniyor
            Apc->Inserted = FALSE;                       // Listeye eklenmiş bilgisini temizleyelim
            KeReleaseInStackQueuedSpinLock(&LockHandle); // Liste kilidini açabiliriz artık
            (KernelRoutine)(Apc,                         // APC çekirdek modu rutini çağrılıyor
                            &NormalRoutine,
                            &NormalContext,
                            &SystemArgument1,
                            &SystemArgument2);


        } else {

            // 
            // Hmm, o zaman listedeki ilk girdi normal çekirdek APCsi.
            // Eğer şu an çalışan başka bir normal çekirdek APCsi yoksa
            // ayrıca çekirdek APCleri devre dışı değilse APCyi listeden 
            // alalım, listeye ekli bilgisini temizleyelim ve APCyi işleyelim
            //

            if ((Thread->ApcState.KernelApcInProgress == FALSE) && // Başka çekirdek APCsi çalışmıyor di mi?
               (Thread->KernelApcDisable == 0)) {       // Peki çekirdek APCsi işleyebilir miyiz?

                RemoveEntryList(NextEntry);                  // Evet, evet. Bu liste girdisini sil,
                Apc->Inserted = FALSE;                       // listeye eklendi bayrağını temizle,
                KeReleaseInStackQueuedSpinLock(&LockHandle); // APC listesi kilidini aç,
                (KernelRoutine)(Apc,                         // APCnin çekirdek rutinini çağır.
                                &NormalRoutine, 
                                &NormalContext,
                                &SystemArgument1,
                                &SystemArgument2);

                if (NormalRoutine != (PKNORMAL_ROUTINE)NULL) {   // Normal rutine sahip miyiz peki?
                    Thread->ApcState.KernelApcInProgress = TRUE; // hee, çekirdek APCsi işlenmekte bayrağını kaldır,
                    KeLowerIrql(0);                  // IRQL'yi PASSIVE_LEVEL'e al 
                    (NormalRoutine)(NormalContext,   // ve normal rutini çağır.
                                    SystemArgument1,
                                    SystemArgument2);

                    KeRaiseIrql(APC_LEVEL, &LockHandle.OldIrql); // Tekrar APC_LEVEL seviyesine gel
                }

                Thread->ApcState.KernelApcInProgress = FALSE;  // Çekirdek APCsi işlendi, artık 
                                                               // işleniyor bayrağını temizleyebiliriz

            } else { 
                // Başka bir çekirdek APCsi çalışıyor, veya çekirdek APCleri devre dışı... 
                // APC listesinin kilidini aç ve bi kontrol yap bakalım.
                KeReleaseInStackQueuedSpinLock(&LockHandle);
                goto CheckProcess;
            }
        }
    }

    //
    // Hmm, çekirdek APC listesi boş çıktı. O halde bak bakalım
    // önceki mod değeri kullanıcı modu mu, kullanıcı modu APCsi 
    // beklemede bayrağı aktif mi ve kullanıcı modu APC listesi boş mu? 
    // Eğer öyleyse APC listesinden ilk APCyi al, APCnin listeye eklendi
    // bayrağını HAYIR olarak güncelle, kullanıcı APCsi bekliyor bayrağını
    // temizle, ve verilen çekirdek rutinini çalıştır.
    // Eğer çekirden rutininden döndüğünde normal rutin adresi varsa,
    // kullanıcı modu APC bağlam alanını hazırla ve geri dön.(return)
    // Tersi durumda ise başka bir kullanıcı modu APCsi işlenebilir mi onu kontrol et.
    //

    if ((PreviousMode == UserMode) &&                                  // Önceki mod kullanıcı mı,
        (IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]) == FALSE) && // APC listesinde bişiy var mı,
        (Thread->ApcState.UserApcPending != FALSE)) {    // ve kullanıcı mod APCsi beklemiyor di mi?

        //
        // Evet öyle, o zaman IRQL'yi yükselt, APC listesini kilitle 
        // ve APCyi işle. 
        //

        KeAcquireInStackQueuedSpinLock(&Thread->ApcQueueLock, &LockHandle);

        Thread->ApcState.UserApcPending = FALSE;                    // Artık kullanıcı APCleri beklemiyor, 
        NextEntry = Thread->ApcState.ApcListHead[UserMode].Flink;   // listeden girdi al,
        if (NextEntry == &Thread->ApcState.ApcListHead[UserMode]) { // sahi listede girdi var mı?
            KeReleaseInStackQueuedSpinLock(&LockHandle);            // Yok, bi sıkıntı var. 
            goto CheckProcess;                                      // kilidi aç ve kontrol et
        }

        Apc = CONTAINING_RECORD(NextEntry, KAPC, ApcListEntry); // Girdi var, o zaman KAPC yapısını al
        ReadForWriteAccess(Apc);                                
        KernelRoutine = Apc->KernelRoutine;         // Gerekli olan rutinleri KAPC yapısından al
        NormalRoutine = Apc->NormalRoutine;
        NormalContext = Apc->NormalContext;
        SystemArgument1 = Apc->SystemArgument1;
        SystemArgument2 = Apc->SystemArgument2;
        RemoveEntryList(NextEntry);                          // Bu APCyi listeden sil
        Apc->Inserted = FALSE;                               // Listede değil diye işaretle
        KeReleaseInStackQueuedSpinLock(&LockHandle);         // APC listesinin kilidini aç
        (KernelRoutine)(Apc,                                 // Önce çekirdekde çalışacak rutini çalıştır
                        &NormalRoutine,
                        &NormalContext,
                        &SystemArgument1,
                        &SystemArgument2);

        if (NormalRoutine == (PKNORMAL_ROUTINE)NULL) {   // Peki şu an bir normal rutine sahip miyiz?
            KeTestAlertThread(UserMode);                 // hayır değiliz. O zaman bak bi başka kullanıcı
                                                         // modu APC işleyebilir miyiz..
        } else {
            KiInitializeUserApc(ExceptionFrame,          // Normal rutin var, demek ki kullanıcı
                                TrapFrame,               // modunda bişeyler çalışcak. Onu işle.
                                NormalRoutine,
                                NormalContext,
                                SystemArgument1,
                                SystemArgument2);
        }
    }
}
...
...

VOID
KeInitializeApc (
    __out PRKAPC Apc,
    __in PRKTHREAD Thread,
    __in KAPC_ENVIRONMENT Environment,
    __in PKKERNEL_ROUTINE KernelRoutine,
    __in_opt PKRUNDOWN_ROUTINE RundownRoutine,
    __in_opt PKNORMAL_ROUTINE NormalRoutine,
    __in_opt KPROCESSOR_MODE ApcMode,
    __in_opt PVOID NormalContext
    );

PKTHREAD thread;     // Hedeflediğimiz işlemciğin nesnesine gösterici
PKAPC    Apc;        // APC nesnemize gösterici

//
// Burası çok çok önemli. Burada aldığımız işlemcik nesnesi
// APC yollamak istediğimiz işlemcik olmalı. Bunu garanti etmenin 
// çeşitli yolları var. Şunu unutmayın ki bu örneğe göre, buradaki 
// kodlar çalışırken o işlemciğin bağlam alanında olmanız gerekiyor, 
// mesela ben burda bildirim rutinlerinde çalıştırdığım için istediğim
// işlemciğin bağlam alanında olduğuma emin olabiliyorum siz de bu veya 
// diğer yöntemleri kullanarak hedef işlemciğinizin nesnesine gösterici almalısınız
// 
thread = KeGetCurrentThread(); 

Apc = (PKAPC) ExAllocatePoolWithTag(NonPagedPool,     // APC nesnemiz için hafıza alanı alalım
                                    sizeof(KAPC),
                                    BEK_MALW_TAG);

if (!Apc)
{
    LOG("Apc yapısı için alan ayıramıyorum :((");
    return FALSE;
}

//
// Alan ayırabildik, o halde APC nesnemizi işlemciğin listesine göndermek için hazırlayalım 
//
KeInitializeApc(Apc,                   // APC nesnemiz
                thread,                // Hedef işlemcik
                OriginalApcEnvironment,// Hangi Apc ortamı alanını kullanıcaz?
                &KernelApcRoutine,     // Çekirdekte çalışacak olan rutinimiz
                NULL,                  // Rundown rutini, APC listesinin boş verileceği durumunda çalışacak rutin
                &NormalRutinim,        // Bu da işlemcik içinde çalışacak olan rutinimiz
                UserMode,              // Kullanıcı modunu hedefliyoruz
                Context);              // APC rutinimize parametre olarak gidecek

{
    //
    // Öncelikle yapıdaki ilk iki alanı ayarlıyoruz
    // Biri nesne tipini diğeri de boyutunu veriyor
    //
    Apc->Type = ApcObject;
    Apc->Size = sizeof(KAPC);

    if (Environment == CurrentApcEnvironment) {     // Mevcut olan APC ortamı mı kullanıcak?
        Apc->ApcStateIndex = Thread->ApcStateIndex; // Evet, o zaman mevcut KAPC_STATE'yi gösteren 
                                                    // ApcStateIndex değerini kullan, bu değer bize 
                                                    // KTHREAD.ApcStatePointer[] gösterici dizisiyle
                                                    // asıl KTHREAD.ApcState alanını verecek

    } else { 
        //
        // Hmm, şu an kullanımda olanı değil başka bir taneyi istiyor
        //
        Apc->ApcStateIndex = (CCHAR)Environment;
    }

    Apc->Thread = Thread;                   // Hedef işlemcik
    Apc->KernelRoutine = KernelRoutine;     // Çekirdekte çalışacak rutin
    Apc->RundownRoutine = RundownRoutine;   // APCler boş verildiğinde çalışacak rutin(örn: işlem sonlanırken)
    Apc->NormalRoutine = NormalRoutine;     // İşlemcikte çalışacak olan rutin
    
    if (ARGUMENT_PRESENT(NormalRoutine)) {  // Bak bakalım normal rutini var mı?
        Apc->ApcMode = ApcMode;             // Evet, var o zaman argüman olarak gelen modu kullan 
        Apc->NormalContext = NormalContext; // NormalRoutine&KernelRoutine'e gidecek olan NormalContext'i ayarla

    } else {                                // Ah, hayır NormalRoutine yok, hmm bu bir kernel APCsi
        Apc->ApcMode = KernelMode;          // O zaman ApcMode ne diyo boşver, direkt KernelMode yap modu
        Apc->NormalContext = NULL;          // Eh, normal rutin yoksa bu da NULL olcak demektir
    }

    Apc->Inserted = FALSE;                  // APC henüz işlemciğin APC listesine eklenmedi, onu da belirtelim
    return;
}

BOOLEAN
KeInsertQueueApc (
    __inout PRKAPC Apc,
    __in_opt PVOID SystemArgument1,
    __in_opt PVOID SystemArgument2,
    __in KPRIORITY Increment
    );

//
// APC yapımız hazır olduğuna göre artık APC'yi gönderebiliriz
//
if (!KeInsertQueueApc(Apc, NULL, NULL, 0))
{
    LOG("Queue KAPC başarısız oldu ya :((");
    ExFreePoolWithTag(Apc, BEK_MALW_TAG);      // Ayırdığımız alanı bırakmayı unutmayalım tabi.
    return FALSE;
}

NtQueueApcThread(
    __in HANDLE ThreadHandle,
    __in PPS_APC_ROUTINE ApcRoutine,
    __in_opt PVOID ApcArgument1,
    __in_opt PVOID ApcArgument2,
    __in_opt PVOID ApcArgument3
    );