Получаю цепочку кластеров файлика с NTFS раздела. Копирую на винт все замечательно.
Пытаюсь проделать тоже самое с файликом на fat32, часть файла является мусором
Опытным путем выяснил, что смещение верхушки в результирующем файле составляет 4096 байта.
В чем может быть проблема при работе с FAT32?
размер таблицы фат? и как это пофиксить. Ниже представлен код копирующий файл.

//функция для получения цепочки кластеров по имени файла.
ULONGLONG *GetFileClusters(
                    PCHAR lpFileName,
                    ULONG ClusterSize, 
                    ULONG *ClCount,
                    ULONG *FileSize 
                    )
{
    HANDLE  hFile;
    ULONG   OutSize;
    ULONG   Bytes, Cls, CnCount, r;
    ULONGLONG *Clusters = NULL;
    BOOLEAN Result = FALSE;
    LARGE_INTEGER PrevVCN, Lcn;
    STARTING_VCN_INPUT_BUFFER  InBuf;
    PRETRIEVAL_POINTERS_BUFFER OutBuf;

    hFile = CreateFile(lpFileName, FILE_READ_ATTRIBUTES,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       NULL, OPEN_EXISTING, 0, 0);

    if (hFile != INVALID_HANDLE_VALUE)
    {
        *FileSize = GetFileSize(hFile, NULL);

        OutSize = sizeof(RETRIEVAL_POINTERS_BUFFER) + (*FileSize / ClusterSize) * sizeof(OutBuf->Extents);

        OutBuf = (PRETRIEVAL_POINTERS_BUFFER)malloc( OutSize );

        InBuf.StartingVcn.QuadPart = 0;
        
        if (DeviceIoControl(hFile, FSCTL_GET_RETRIEVAL_POINTERS, &InBuf, 
                            sizeof(InBuf), OutBuf, OutSize, &Bytes, NULL))
        {
            *ClCount = (*FileSize + ClusterSize - 1) / ClusterSize;

            Clusters = (ULONGLONG*)malloc(*ClCount * sizeof(ULONGLONG));

            PrevVCN = OutBuf->StartingVcn;

            for (r = 0, Cls = 0; r < OutBuf->ExtentCount; r++)
            {
                Lcn = OutBuf->Extents[r].Lcn;

                for (CnCount = (ULONG)(OutBuf->Extents[r].NextVcn.QuadPart - PrevVCN.QuadPart);
                     CnCount; CnCount--, Cls++, Lcn.QuadPart++) Clusters[Cls] = Lcn.QuadPart;

                PrevVCN = OutBuf->Extents[r].NextVcn;
            }
        }
    
        free(OutBuf);    

        CloseHandle(hFile);
    }
    return Clusters;
}

//непосредственно копиривание файла
        hDrive = CreateFile(Name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);

        if (hDrive != INVALID_HANDLE_VALUE)
        {
            hFile = CreateFile(lpDstName, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);

            if (hFile != INVALID_HANDLE_VALUE)
            {
                Buff_Read = malloc(ClusterSize);       

                for (r = 0; r < ClCount; r++, FileSize -= BlockSize)
                {
            Offset.QuadPart = (ClusterSize * Clusters[r]);
            printf( "%d\n", Offset.QuadPart );

            SetFilePointer(hDrive, Offset.LowPart, &Offset.HighPart, FILE_BEGIN);
            ReadFile(hDrive, Buff_Read, ClusterSize, &Bytes, NULL);

            BlockSize = FileSize < ClusterSize ? FileSize : ClusterSize;
            WriteFile(hFile, Buff_Read, BlockSize, &Bytes, NULL);

                }//end_ for_ r

                free(Buff_Read);
                //free(Buff);

                CloseHandle(hFile);
            }
            CloseHandle(hDrive);
        }

первоисточник: http://www.wasm.ru/article.php?article=lockfileswork