Funzione KeSetKernelStackSwapEnable (ntifs.h)

La routine KeSetKernelStackSwapEnable abilita e disabilita lo scambio dello stack del chiamante su disco.

Sintassi

BOOLEAN KeSetKernelStackSwapEnable(
  [in] BOOLEAN Enable
);

Parametri

[in] Enable

Specifica se abilitare lo scambio dello stack appartenente al thread chiamante. Se TRUE, lo scambio è abilitato e il contenuto dello stack può essere impaginato e non disponibile in memoria. Se FALSE, lo scambio è disabilitato e lo stack è residente in memoria.

Valore restituito

KeSetKernelStackSwapEnable restituisce un valore BOOLEAN che indica se lo scambio dello stack è stato abilitato al momento dell'avvio della chiamata. Questo valore è TRUE se lo scambio di stack è stato abilitato in precedenza ed è FALSE se è stato disabilitato.

Commenti

Un driver in modalità kernel può chiamare questa routine per controllare se lo stack è impaginabile o bloccato in memoria.

Lo scambio di stack può verificarsi solo se il thread si trova in uno stato di attesa causato da una richiesta da un'applicazione in modalità utente. Lo scambio dello stack non si verifica mai per gli stati di attesa avviati dai componenti in modalità kernel, indipendentemente dal fatto che lo scambio di stack sia abilitato.

Non è in genere necessario disabilitare lo scambio dello stack. Farlo solo in rari casi. Per un esempio che illustra le alternative alla disabilitazione dello scambio dello stack, vedere la sezione Esempio seguente.

In una chiamata a una routine di attesa in modalità kernel, ad esempio KeWaitForSingleObject, il chiamante specifica un parametro WaitMode per indicare se il chiamante attende in modalità kernel o in modalità utente. SeWaitMode UserMode = e se la durata di attesa è sufficientemente lunga, la gestione memoria potrebbe uscire dalle sezioni dello stack che appartiene al thread in attesa. Tuttavia, se lo stack contiene elementi di dati che devono rimanere residenti nella memoria per la durata dell'attesa, il thread può impedire la pagina dello stack chiamando KeSetKernelStackSwapEnable e specificando Abilita = FALSE.

Un thread non deve uscire (termina) mentre lo scambio dello stack è disabilitato o si verificherà un controllo di bug di sistema.

Esempio

Nell'esempio di codice seguente un thread driver alloca un evento nello stack e chiama KeSetKernelStackSwap per bloccare temporaneamente lo stack in memoria finché l'evento non viene segnalato. Il driver chiama KeWaitForSingleObject con waitReason di UserRequest per indicare che il relativo thread si trova in uno stato di attesa causato da una richiesta da un'applicazione in modalità utente e WaitMode impostata su KernelMode per indicare che l'attesa si sta verificando in modalità kernel. Al termine dell'attesa, il thread chiama di nuovo KeSetKernelStackSwap , se necessario, per ripristinare lo stato di scambio dello stack originale del thread.

KEVENT event;
BOOLEAN oldSwapEnable;
NTSTATUS status;

oldSwapEnable = KeSetKernelStackSwapEnable(FALSE);

KeInitializeEvent(&event, SynchronizationEvent, FALSE);

//
// TO DO: Insert code here to pass the event to another thread
// that will set the event to the signaled state.
//
...

status = KeWaitForSingleObject(&event, UserRequest, KernelMode, FALSE, NULL);

if (oldSwapEnable)
{
    KeSetKernelStackSwapEnable(TRUE);
}

Un oggetto evento deve essere residente in memoria mentre può essere impostato su uno stato segnalato o non firmato oppure mentre un thread attende l'evento. Per altre informazioni, vedere Definizione e uso di un oggetto evento.

Spesso, l'uso della routine KeSetKernelStackSwap non è necessario ed è possibile evitare di allocare solo elementi di dati impaginabili nello stack. Nell'esempio precedente, il thread del driver deve bloccare lo stack perché l'oggetto evento viene allocato nello stack. Un'alternativa migliore potrebbe essere quella di allocare semplicemente l'evento dal pool non a pagina.

Requisiti

Vedi anche

KeInitializeEvent

KeWaitForSingleObject