Função VirtualAlloc2 (memoryapi.h)

Reserva, confirma ou altera o estado de uma região de memória dentro do espaço de endereço virtual de um processo especificado (a memória alocada é inicializada como zero).

Sintaxe

PVOID VirtualAlloc2(
  [in, optional]      HANDLE                 Process,
  [in, optional]      PVOID                  BaseAddress,
  [in]                SIZE_T                 Size,
  [in]                ULONG                  AllocationType,
  [in]                ULONG                  PageProtection,
  [in, out, optional] MEM_EXTENDED_PARAMETER *ExtendedParameters,
  [in]                ULONG                  ParameterCount
);

Parâmetros

[in, optional] Process

O identificador de um processo. A função aloca memória dentro do espaço de endereço virtual desse processo.

O identificador deve ter o acesso PROCESS_VM_OPERATION correto. Para obter mais informações, consulte Process Security and Access Rights.

Se Process for NULL, a função alocará memória para o processo de chamada.

[in, optional] BaseAddress

O ponteiro que especifica um endereço inicial desejado para a região das páginas que você deseja alocar.

Se BaseAddress for NULL, a função determinará onde alocar a região.

Se BaseAddress não for NULL, qualquer estrutura de MEM_ADDRESS_REQUIREMENTS fornecida deverá consistir em todos os zeros e o endereço base deverá ser um múltiplo da granularidade de alocação do sistema. Para determinar a granularidade de alocação, use a função GetSystemInfo.

Se esse endereço estiver dentro de um enclave que você não inicializou chamando InitializeEnclave, VirtualAlloc2 alocará uma página de zeros para o enclave nesse endereço. A página deve ser não confirmada anteriormente e não será medida com a instrução EEXTEND do modelo de programação extensões do Intel Software Guard.

Se o endereço em um enclave que você inicializou, a operação de alocação falhará com o erro ERROR_INVALID_ADDRESS. Isso é verdade para enclaves que não dão suporte ao gerenciamento dinâmico de memória (ou seja, SGX1). Os enclaves SGX2 permitirão a alocação e a página deve ser aceita pelo enclave depois de alocada.

[in] Size

O tamanho da região da memória a ser alocada, em bytes.

O tamanho deve ser sempre um múltiplo do tamanho da página.

Se BaseAddress não for NULL, a função alocará todas as páginas que contêm um ou mais bytes no intervalo de BaseAddress a BaseAddress+Size. Isso significa, por exemplo, que um intervalo de 2 bytes que ultrapassa um limite de página faz com que a função aloque ambas as páginas.

[in] AllocationType

O tipo de alocação de memória. Esse parâmetro deve conter um dos valores a seguir.

Esse parâmetro também pode especificar os valores a seguir, conforme indicado.

[in] PageProtection

A proteção de memória para a região das páginas a ser alocada. Se as páginas estiverem sendo confirmadas, você poderá especificar qualquer uma das constantes de proteção de memória .

Se BaseAddress especificar um endereço dentro de um enclave, PageProtection não poderá ser nenhum dos seguintes valores:

• PAGE_NOACCESS
• PAGE_GUARD
• PAGE_NOCACHE
• PAGE_WRITECOMBINE

Ao alocar memória dinâmica para um enclave, o parâmetro PageProtection deve ser PAGE_READWRITE ou PAGE_EXECUTE_READWRITE.

[in, out, optional] ExtendedParameters

Um ponteiro opcional para um ou mais parâmetros estendidos do tipo MEM_EXTENDED_PARAMETER. Cada um desses valores de parâmetro estendidos pode ter um campo Type de MemExtendedParameterAddressRequirements ou MemExtendedParameterNumaNode. Se nenhum MemExtendedParameterNumaNode parâmetro estendido for fornecido, o comportamento será o mesmo das funções MapViewOfFile (ou seja, o nó NUMA preferencial para as páginas físicas é determinado com base no processador ideal do thread que primeiro acessa a memória).

[in] ParameterCount

O número de parâmetros estendidos apontados por ExtendedParameters.

Valor de retorno

Se a função for bem-sucedida, o valor retornado será o endereço base da região alocada de páginas.

Se a função falhar, o valor retornado será NULL. Para obter informações de erro estendidas, chame GetLastError.

Observações

Essa função permite que você especifique:

• um intervalo de espaço de endereço virtual e uma restrição de alinhamento de potência de 2 para novas alocações
• um número arbitrário de parâmetros estendidos
• um nó NUMA preferencial para a memória física como um parâmetro estendido (consulte o parâmetro ExtendedParameters)
• uma operação de espaço reservado (especificamente, substituição).

Essa API fornece técnicas especializadas para gerenciar a memória virtual em suporte a jogos de alto desempenho e aplicativos de servidor. Por exemplo, os espaços reservados permitem que um intervalo de memória reservado seja explicitamente particionado, sobreposto e mapeado novamente; isso pode ser usado para implementar regiões arbitrariamente extensíveis ou buffers de anel de memória virtual. VirtualAlloc2 também permite alocar memória com um alinhamento de memória específico.

Cada página tem um estado de página associado. A função VirtualAlloc2 pode executar as seguintes operações:

• Confirmar uma região de páginas reservadas
• Reservar uma região de páginas gratuitas
• Reservar e confirmar simultaneamente uma região de páginas gratuitas

VirtualAlloc2 podem confirmar páginas que já estão confirmadas, mas não podem reservar páginas que já estão reservadas. Isso significa que você pode confirmar um intervalo de páginas, independentemente de elas já terem sido confirmadas e a função não falhará. No entanto, em geral, apenas um intervalo mínimo de páginas não confirmadas deve ser especificado, pois a confirmação de um grande número de páginas já confirmadas pode fazer com que a chamada VirtualAlloc2 deva muito mais tempo.

Você pode usar VirtualAlloc2 para reservar um bloco de páginas e, em seguida, fazer chamadas adicionais para VirtualAlloc2 para confirmar páginas individuais do bloco reservado. Isso permite que um processo reserve um intervalo de seu espaço de endereço virtual sem consumir armazenamento físico até que seja necessário.

Se o parâmetro lpAddress não for NULL, a função usará os parâmetros lpAddress e dwSize para calcular a região das páginas a serem alocadas. O estado atual de todo o intervalo de páginas deve ser compatível com o tipo de alocação especificado pelo parâmetro flAllocationType. Caso contrário, a função falhará e nenhuma das páginas será alocada. Esse requisito de compatibilidade não impede a confirmação de uma página já confirmada; consulte a lista anterior.

Para executar código gerado dinamicamente, use VirtualAlloc2 para alocar memória e a função VirtualProtectEx para conceder acesso PAGE_EXECUTE.

A função VirtualAlloc2 pode ser usada para reservar uma região de memória de extensões de janela de endereço (AWE) dentro do espaço de endereço virtual de um processo especificado. Essa região de memória pode ser usada para mapear páginas físicas para dentro e para fora da memória virtual, conforme exigido pelo aplicativo. Os valores MEM_PHYSICAL e MEM_RESERVE devem ser definidos no parâmetro AllocationType. O valor MEM_COMMIT não deve ser definido. A proteção de página deve ser definida como PAGE_READWRITE.

A função VirtualFreeEx pode descompromissar uma página confirmada, liberar o armazenamento da página ou descompromissar e liberar simultaneamente uma página confirmada. Ele também pode liberar uma página reservada, tornando-a uma página gratuita.

Ao criar uma região que será executável, o programa de chamada é responsável por garantir a coerência do cache por meio de uma chamada apropriada para FlushInstructionCache depois que o código tiver sido definido em vigor. Caso contrário, as tentativas de executar código fora da região recém-executável podem produzir resultados imprevisíveis.

Exemplos

Cenário 1. Crie um buffer circular mapeando duas exibições adjacentes da mesma seção de memória compartilhada.

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

//
// This function creates a ring buffer by allocating a pagefile-backed section
// and mapping two views of that section next to each other. This way if the
// last record in the buffer wraps it can still be accessed in a linear fashion
// using its base VA.
//

void*
CreateRingBuffer (
    unsigned int bufferSize,
    _Outptr_ void** secondaryView
    )
{
    BOOL result;
    HANDLE section = nullptr;
    SYSTEM_INFO sysInfo;
    void* ringBuffer = nullptr;
    void* placeholder1 = nullptr;
    void* placeholder2 = nullptr;
    void* view1 = nullptr;
    void* view2 = nullptr;

    GetSystemInfo (&sysInfo);

    if ((bufferSize % sysInfo.dwAllocationGranularity) != 0) {
        return nullptr;
    }

    //
    // Reserve a placeholder region where the buffer will be mapped.
    //

    placeholder1 = (PCHAR) VirtualAlloc2 (
        nullptr,
        nullptr,
        2 * bufferSize,
        MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
        PAGE_NOACCESS,
        nullptr, 0
    );

    if (placeholder1 == nullptr) {
        printf ("VirtualAlloc2 failed, error %#x\n", GetLastError());
        goto Exit;
    }

    //
    // Split the placeholder region into two regions of equal size.
    //

    result = VirtualFree (
        placeholder1,
        bufferSize,
        MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER
    );

    if (result == FALSE) {
        printf ("VirtualFreeEx failed, error %#x\n", GetLastError());
        goto Exit;
    }

    placeholder2 = (void*) ((ULONG_PTR) placeholder1 + bufferSize);

    //
    // Create a pagefile-backed section for the buffer.
    //

    section = CreateFileMapping (
        INVALID_HANDLE_VALUE,
        nullptr,
        PAGE_READWRITE,
        0,
        bufferSize, nullptr
    );

    if (section == nullptr) {
        printf ("CreateFileMapping failed, error %#x\n", GetLastError());
        goto Exit;
    }

    //
    // Map the section into the first placeholder region.
    //

    view1 = MapViewOfFile3 (
        section,
        nullptr,
        placeholder1,
        0,
        bufferSize,
        MEM_REPLACE_PLACEHOLDER,
        PAGE_READWRITE,
        nullptr, 0
    );

    if (view1 == nullptr) {
        printf ("MapViewOfFile3 failed, error %#x\n", GetLastError());
        goto Exit;
    }

    //
    // Ownership transferred, don't free this now.
    //

    placeholder1 = nullptr;

    //
    // Map the section into the second placeholder region.
    //

    view2 = MapViewOfFile3 (
        section,
        nullptr,
        placeholder2,
        0,
        bufferSize,
        MEM_REPLACE_PLACEHOLDER,
        PAGE_READWRITE,
        nullptr, 0
    );

    if (view2 == nullptr) {
        printf ("MapViewOfFile3 failed, error %#x\n", GetLastError());
        goto Exit;
    }

    //
    // Success, return both mapped views to the caller.
    //

    ringBuffer = view1;
    *secondaryView = view2;

    placeholder2 = nullptr;
    view1 = nullptr;
    view2 = nullptr;

Exit:

    if (section != nullptr) {
        CloseHandle (section);
    }

    if (placeholder1 != nullptr) {
        VirtualFree (placeholder1, 0, MEM_RELEASE);
    }

    if (placeholder2 != nullptr) {
        VirtualFree (placeholder2, 0, MEM_RELEASE);
    }

    if (view1 != nullptr) {
        UnmapViewOfFileEx (view1, 0);
    }

    if (view2 != nullptr) {
        UnmapViewOfFileEx (view2, 0);
    }

    return ringBuffer;
}

int __cdecl wmain()
{
    char* ringBuffer;
    void* secondaryView;
    unsigned int bufferSize = 0x10000;

    ringBuffer = (char*) CreateRingBuffer (bufferSize, &secondaryView);

    if (ringBuffer == nullptr) {
        printf ("CreateRingBuffer failed\n");
        return 0;
    }

    //
    // Make sure the buffer wraps properly.
    //

    ringBuffer[0] = 'a';

    if (ringBuffer[bufferSize] == 'a') {
        printf ("The buffer wraps as expected\n");
    }

    UnmapViewOfFile (ringBuffer);
    UnmapViewOfFile (secondaryView);
}

Cenário 2. Especifique um nó NUMA preferencial ao alocar memória.

void*
AllocateWithPreferredNode (size_t size, unsigned int numaNode)
{
    MEM_EXTENDED_PARAMETER param = {0};

    param.Type = MemExtendedParameterNumaNode;
    param.ULong = numaNode;

    return VirtualAlloc2 (
        nullptr, nullptr,
        size,
        MEM_RESERVE | MEM_COMMIT,
        PAGE_READWRITE,
        &param, 1);
}

Cenário 3. Aloque memória em um intervalo de endereços virtual específico (abaixo de 4 GB, neste exemplo) e com alinhamento específico.

void*
AllocateAlignedBelow2GB (size_t size, size_t alignment)
{
    MEM_ADDRESS_REQUIREMENTS addressReqs = {0};
    MEM_EXTENDED_PARAMETER param = {0};

    addressReqs.Alignment = alignment;
    addressReqs.HighestEndingAddress = (PVOID)(ULONG_PTR) 0x7fffffff;

    param.Type = MemExtendedParameterAddressRequirements;
    param.Pointer = &addressReqs;

    return VirtualAlloc2 (
        nullptr, nullptr,
        size,
        MEM_RESERVE | MEM_COMMIT,
        PAGE_READWRITE,
        &param, 1);
}

Requisitos

Consulte também

Funções de gerenciamento de memória

ReadProcessMemory

Funções de memória virtual

VirtualAllocExNuma

VirtualFreeEx

virtualLock

virtualProtect

VirtualQuery

WriteProcessMemory