Dela via

Livscykel för virtualiseringsinstans

Providerprogrammet underhåller en eller flera virtualiseringsinstanser. Varje virtualiseringsinstans genomgår fyra steg i sin livscykel:

  1. Skapelse
  2. Start
  3. Runtime
  4. Avstängning

Observera att efter att ha stängt av en virtualiseringsinstans behöver providern inte återskapa den för att återanvända den. Det kan helt enkelt starta upp det igen.

Obs: Det här avsnittet visar exempel på ProjFS-API:er. Varje exempel är avsett att illustrera grundläggande API-användning. Dokumentation om alternativ som inte används i dessa exempel finns i referensen ProjFS API.

Skapa en virtualiseringsrot

Innan en provider kan starta virtualiseringsinstansen som projicerar objekt i det lokala filsystemet måste den skapa virtualiseringsroten. Virtualiseringsroten är den katalog under vilken providern projicerar ett träd med kataloger och filer.

För att skapa en virtualiseringsrot måste providern:

  1. Skapa en katalog som ska fungera som virtualiseringsrot.

    Providern skapar en katalog som ska fungera som virtualiseringsrot med hjälp av till exempel CreateDirectory:

    HRESULT hr;
const wchar_t* rootName = LR"(C:\virtRoot)";
if (!CreateDirectoryW(rootName, nullptr))
{
    hr = HRESULT_FROM_WIN32(GetLastError());
    wprintf(L"Failed to create virtualization root (0x%08x)\n", hr);
    return;
}

  2. Skapa ett virtualiseringsinstans-ID.

    Varje virtualiseringsinstans har ett unikt ID som kallas virtualiseringsinstans-ID. Systemet använder det här värdet för att identifiera vilken virtualiseringsinstans dess innehåll är associerat med.

    GUID instanceId;
hr = CoCreateGuid(&instanceId);
if (FAILED(hr))
{
    wprintf(L"Failed to create instance ID (0x%08x)\n", hr);
    return;
}

  3. Markera den nya katalogen som virtualiseringsroten.

    Providern anropar PrjMarkDirectoryAsPlaceholder för att markera den nya katalogen som virtualiseringsroten och tilldela den till virtualiseringsinstansen.

    hr = PrjMarkDirectoryAsPlaceholder(rootName,
                                   nullptr,
                                   nullptr,
                                   &instanceId);
if (FAILED(hr))
{
    wprintf(L"Failed to mark virtualization root (0x%08x)\n", hr);
    return;
}

Providern behöver bara skapa virtualiseringsroten en gång för varje virtualiseringsinstans. När en rot har skapats kan dess associerade instans startas upprepade gånger och stoppas utan att roten återskapas.

Starta en virtualiseringsinstans

När virtualiseringsroten har skapats måste providern starta virtualiseringsinstansen. Detta signalerar ProjFS att providern är redo att ta emot återanrop och tillhandahålla data.

För att starta virtualiseringsinstansen måste providern:

  1. Konfigurera återanropstabellen.

    ProjFS kommunicerar med providern genom att anropa återanropsrutiner som implementeras av providern. Providern fyller i en PRJ_CALLBACKS struct med pekare till dess återanropsrutiner.

    PRJ_CALLBACKS callbackTable;

// Supply required callbacks.
callbackTable.StartDirectoryEnumerationCallback = MyStartEnumCallback;
callbackTable.EndDirectoryEnumerationCallback = MyEndEnumCallback;
callbackTable.GetDirectoryEnumerationCallback = MyGetEnumCallback;
callbackTable.GetPlaceholderInfoCallback = MyGetPlaceholderInfoCallback;
callbackTable.GetFileDataCallback = MyGetFileDataCallback;

// The rest of the callbacks are optional.
callbackTable.QueryFileNameCallback = nullptr;
callbackTable.NotificationCallback = nullptr;
callbackTable.CancelCommandCallback = nullptr;

  2. Starta instansen.

    Providern anropar PrjStartVirtualizing för att starta virtualiseringsinstansen.

    PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT instanceHandle;
hr = PrjStartVirtualizing(rootName,
                          &callbackTable,
                          nullptr,
                          nullptr,
                          &instanceHandle);
if (FAILED(hr))
{
    wprintf(L"Failed to start the virtualization instance (0x%08x)\n", hr);
    return;
}

    PrjStartVirtualizingparametern instanceHandle returnerar ett handtag till virtualiseringsinstansen. Providern använder den här handtaget när den anropar andra ProjFS-API:er.

Körning av virtualiseringsinstanser

När anropet till PrjStartVirtualizing returnerar anropar ProjFS providerns återanropsrutiner som svar på filsystemåtgärder i virtualiseringsinstansen. Information om hur providern kan hantera olika filsystemåtgärder finns i följande avsnitt:

Stänga av en virtualiseringsinstans

För att signalera ProjFS att providern vill sluta ta emot återanrop och tillhandahålla data måste providern stoppa virtualiseringsinstansen. För att göra detta anropar providern PrjStopVirtualizingoch skickar handtaget till den virtualiseringsinstans som den tog emot från anropet till PrjStartVirtualizing.

PrjStopVirtualizing(instanceHandle);

Observera att ProjFS kan fortsätta att anropa leverantörens återanropsrutiner tills det här anropet returneras.

  • Last updated on