estrutura DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE_START_CONTEXT (wdm.h)

A estrutura DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE_START_CONTEXT contém os parâmetros necessários para iniciar um thread de trabalho com troca frequente usando IoDriverProxyCreateHotSwappableWorkerThread.

Sintaxe

typedef struct _DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE_START_CONTEXT {
  PDRIVER_PROXY_HOTSWAP_WORKER_ROUTINE WorkerRoutine;
  PVOID                                Context;
  WAIT_TYPE                            WaitType;
  KWAIT_REASON                         WaitReason;
  KPROCESSOR_MODE                      WaitMode;
  BOOLEAN                              Altertable;
  BOOLEAN                              HasTimeout;
  LARGE_INTEGER                        Timeout;
  ULONG                                EventCount;
  PKEVENT                              Events[ANYSIZE_ARRAY];
} DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE_START_CONTEXT, *PDRIVER_PROXY_HOTSWAP_WORKER_ROUTINE_START_CONTEXT;

Members

WorkerRoutine

Um ponteiro para uma função de retorno de chamada DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE que será chamada quando o thread de trabalho acordar de aguardar os eventos especificados.

Context

Um ponteiro para informações de contexto definidas pelo driver que serão passadas para o retorno de chamada WorkerRoutine . Isso permite que o driver forneça dados adicionais necessários para a rotina de trabalho.

WaitType

O tipo de operação de espera a ser executada. Especifique WaitAll, indicando que todos os objetos especificados devem atingir um estado sinalizado antes que a espera seja atendida; ou WaitAny, indicando que qualquer um dos objetos deve atingir um estado sinalizado antes que a espera seja atendida.

WaitReason

O motivo da espera. Os drivers devem definir esse valor como Executivo ou, se o driver estiver trabalhando em nome de um usuário e estiver em execução no contexto de um thread de usuário, para UserRequest.

WaitMode

Se o chamador aguarda em KernelMode ou UserMode. Drivers intermediários e de nível mais baixo devem especificar KernelMode. Se o conjunto de objetos aguardados incluir um mutex, o chamador deverá especificar KernelMode.

Altertable

Um valor booliano que indica se o thread pode ser alertado enquanto está no estado de espera.

HasTimeout

Um valor booliano que indica se um valor de tempo limite é especificado. Se TRUE, o campo Tempo limite conterá um valor de tempo limite válido. Se FALSE, a operação de espera aguardará indefinidamente.

Timeout

Um ponteiro para um valor de tempo limite que especifica o tempo absoluto ou relativo, em unidades de 100 nanossegundos, em que a espera deve ser concluída.

Um valor positivo especifica um tempo absoluto em relação a 1º de janeiro de 1601. Um valor negativo especifica um intervalo relativo à hora atual. Os tempos de expiração absolutos acompanham as alterações na hora do sistema; os tempos de expiração relativos não são afetados pelas alterações de tempo do sistema.

Se *Tempo limite = 0, a rotina retornará sem esperar. Se o chamador fornecer um ponteiro NULL, a rotina aguardará indefinidamente até que qualquer um ou todos os objetos do dispatcher sejam definidos como o estado sinalizado.

EventCount

O número de eventos na matriz Eventos . Esse valor determina quantos objetos kernel o thread de trabalho aguardará.

Events[ANYSIZE_ARRAY]

Uma matriz de ponteiros para objetos KEVENT que o thread de trabalho aguardará. O tamanho da matriz é determinado pelo campo EventCount . O thread de trabalho aguardará esses eventos de acordo com a especificação WaitType .

Observações

Essa estrutura configura como o thread de trabalho aguardará os objetos kernel e define a rotina de retorno de chamada que será invocada quando a espera for concluída.

Essa estrutura é usada para configurar um thread de trabalho que pode ser encerrado e recriado com segurança durante operações de hot-swap do driver. A estrutura fornece todos os parâmetros necessários para as operações de espera de kernel subjacentes.

O thread de trabalho criado com essa estrutura aguardará repetidamente os eventos especificados e chamará o retorno de chamada de WorkerRoutine sempre que a espera for concluída. O retorno de chamada pode decidir se o thread deve continuar em execução ou terminar.

A natureza hot-swappable do thread de trabalho significa que ele pode ser interrompido e reiniciado com segurança como parte das operações de atualização do driver, mantendo a estabilidade do sistema durante substituições de driver de runtime.

Requirements

Consulte também

IoDriverProxyCreateHotSwappableWorkerThread

DRIVER_PROXY_HOTSWAP_WORKER_ROUTINE

KEVENT