Lesen der Datei in der Pre-Cleanup-Phase in einem verzögerten Workitem

Question

Ich schreibe einen Windows-Minifiltertreiber, der die gesamte Datei (nur Dateien mit einer Größe bis zu einem bestimmten Schwellenwert) auf IRP_MJ_CLEANUP lesen muss. Da FltReadFile nicht vom Preop-Callback aus aufgerufen werden kann, habe ich den Job in eine Arbeitswarteschlange eingereiht und dort ausgeführt. Wenn ich mit dem Lesen der Datei fertig bin, rufe ich FltCompletePendedPreOperation auf und rufe den Post-Cleanup-Callback auf, der auch die Nachbearbeitung als verzögerte Arbeit behandelt. Hier sind Schnipsel meines Codes:

static NTSTATUS HandlePreCleanup(_In_ PFLT_CALLBACK_DATA Data, 
           _Out_ PVOID *Context) 
{ 
    NTSTATUS Status = STATUS_SUCCESS; 
    PFLT_INSTANCE Instance; 
    PFILE_OBJECT FileObject; 
    PVOID Buffer = NULL; 
    LARGE_INTEGER FileOffset; 

    FileObject = Data->Iopb->TargetFileObject; 
    Instance = Data->Iopb->TargetInstance; 

    Buffer = ExAllocatePoolWithTag(PagedPool, 
            (ULONG) FILE_CHUNK_SIZE, 
            PPFILTER_FILE_POOLTAG); 
    if (Buffer == NULL) { 
     PPERROR("Failed allocating file chunk\n"); 
     Status = STATUS_MEMORY_NOT_ALLOCATED; 
     goto out; 
    } 

    FileOffset.QuadPart = 0; 
    for (;;) { 
     ULONG BytesRead; 

     Status = FltReadFile(
      Instance, FileObject, &FileOffset, 
      (ULONG) FILE_CHUNK_SIZE, Buffer, 
      FLTFL_IO_OPERATION_DO_NOT_UPDATE_BYTE_OFFSET, 
      &BytesRead, NULL, NULL 
     ); 
     if (!NT_SUCCESS(Status)) { 
      if (Status == STATUS_END_OF_FILE) { 
       Status = STATUS_SUCCESS; 
       break; 
      } 

      PPERROR("Failed reading from file %wZ: error %d\n", 
        &FileObject->FileName, Status); 
      goto out; 
     } 

     FileOffset.QuadPart += BytesRead; 
    } 

out: 
    if (Buffer != NULL) { 
     ExFreePoolWithTag(Buffer, PPFILTER_FILE_POOLTAG); 
    } 

    return Status; 
} 

static VOID DeferredPreCallback(_In_ PFLT_DEFERRED_IO_WORKITEM WorkItem, 
           _In_ PFLT_CALLBACK_DATA Data, 
           _In_opt_ PVOID Context) 
{ 
    NTSTATUS Status = STATUS_SUCCESS; 
    PVOID PostContext = NULL; 

    UNREFERENCED_PARAMETER(Context); 

    switch (Data->Iopb->MajorFunction) { 
    case IRP_MJ_CLEANUP: 
     Status = HandlePreCleanup(Data, &PostContext); 
     break; 
    default: 
     NT_ASSERTMSG("Unexpected deferred pre callback operation", 
        FALSE); 
     break; 
    } 

    FltCompletePendedPreOperation(Data, 
            FLT_PREOP_SUCCESS_WITH_CALLBACK, 
            PostContext); 
    FltFreeDeferredIoWorkItem(WorkItem); 
} 


static NTSTATUS QueueWork(_Inout_ PFLT_CALLBACK_DATA Data, 
          _In_ PFLT_DEFERRED_IO_WORKITEM_ROUTINE WorkRoutine, 
          _In_ PVOID Context) 
{ 
    NTSTATUS Status = STATUS_SUCCESS; 
    PFLT_DEFERRED_IO_WORKITEM WorkItem = NULL; 

    WorkItem = FltAllocateDeferredIoWorkItem(); 
    if (WorkItem == NULL) { 
     Status = STATUS_MEMORY_NOT_ALLOCATED; 
     PPERROR("Failed allocating work item\n"); 
     goto failed; 
    } 

    Status = FltQueueDeferredIoWorkItem(WorkItem, Data, WorkRoutine, 
             CriticalWorkQueue, Context); 
    if (!NT_SUCCESS(Status)) { 
     PPERROR("Failed queuing work item to queue: error %d\n", 
       Status); 
     goto failed; 
    } 

    return STATUS_SUCCESS; 

failed: 
    if (WorkItem != NULL) { 
     FltFreeDeferredIoWorkItem(WorkItem); 
    } 

    return Status; 
} 

static FLT_PREOP_CALLBACK_STATUS DeferPreCallback(
    _Inout_ PFLT_CALLBACK_DATA Data, 
    _In_ PCFLT_RELATED_OBJECTS FltObjects, 
    _Out_ PVOID *CompletionContext 
) 
{ 
    NTSTATUS Status = STATUS_SUCCESS; 

    UNREFERENCED_PARAMETER(FltObjects); 
    UNREFERENCED_PARAMETER(CompletionContext); 

    Status = QueueWork(Data, DeferredPreCallback, NULL); 
    if (!NT_SUCCESS(Status)) { 
     return FLT_PREOP_SUCCESS_NO_CALLBACK; 
    } 

    return FLT_PREOP_PENDING; 
} 

CONST FLT_OPERATION_REGISTRATION OperationRegistrations[] = { 
    { 
     IRP_MJ_CLEANUP, 
     0, 
     DeferPreCallback, 
     DeferPostCallback, 
     NULL 
    }, 
    { IRP_MJ_OPERATION_END }, 
}; 

Dies beweist, für eine Weile zu arbeiten, aber das System scheint (Deadlock?) Zu hängen nach einer Weile. Das Problem scheint mit dem Aufruf von FltReadFile zu sein, da der Hang nicht auftritt, wenn dieser Aufruf entfernt wird. Irgendwelche Ideen, warum das passieren könnte oder wie man es weiter debuggt?

Answer 1

Nun, anscheinend war das Problem, dass FltReadFile ein FileOffset gegeben wurde, das nicht mit der Volume-Sektor-Größe ausgerichtet war. Dies ist offensichtlich ein Problem, wenn FileObject für nicht zwischengespeicherte IO erstellt wurde (Siehe den Abschnitt "Hinweise" in https://msdn.microsoft.com/en-us/library/windows/hardware/ff544286(v=vs.85).aspx). Da ich keine Kontrolle darüber habe, wie das betreffende FileObject erstellt wurde, kann es Fälle geben, in denen es tatsächlich für nicht zwischengespeicherte IO erstellt wurde. Um dies zu beheben ich die folgende Kontrolle am Ende der addierte für (;;) Schleife:

if (BytesRead < FILE_CHUNK_SIZE) { 
     break; 
} 

Dies sollte funktionieren, wenn FILE_CHUNK_SIZE ein Vielfaches des Volumens Sektorgröße ist.