Übersetzung von CreateVirtualDisk

[paritycheck]

Hast du es auch schonmal als Overlappt-IO versucht? Ja gleiches Ergebnis

Und das auskommentierte m_h := 0; wurde auch schonmal verwendet? Ja

Einen kleinen Erfolg hatte ich dennoch...wenn ich einen Securitydescriptor angebe gibt die Funktion ERROR_SUCCESS zurück, aber eine Datei wird dennoch nicht erstellt...

[Remko]

It seems you are passing an enum as a parameter(s), did you set {$MINENUMSIZE 4}?

[Assarbad]

Zitat von Remko:

It seems you are passing an enum as a parameter(s), did you set {$MINENUMSIZE 4}?

How would that matter? Shouldn't it still be 4 Bytes on the stack for a 32bit machine?

[Remko]

Zitat von Assarbad:

How would that matter? Shouldn't it still be 4 Bytes on the stack for a 32bit machine?

Yes, you are are right indeed (the argument is indeed passed as 4 bytes)

[himitsu]

Ach stimmt ja, den Enum hab'sch übersehn.

Leider gibt es in Delphi nix Vergleichbares,
da es in C++ eher eine Bitmaske ist, bzw. der Enum in Delphi anders funktioniert, wo er mehr einen Bit-Index (für nur ein einziges Bit) für ein SET darstellt.

Delphi-Quellcode:

type
  _VIRTUAL_DISK_ACCESS_MASK = Cardinal;
const
  VIRTUAL_DISK_ACCESS_ATTACH_RO = $00010000;
  VIRTUAL_DISK_ACCESS_ATTACH_RW = $00020000;
  VIRTUAL_DISK_ACCESS_DETACH = $00040000;
  VIRTUAL_DISK_ACCESS_GET_INFO = $00080000;
  VIRTUAL_DISK_ACCESS_CREATE = $00100000;
  VIRTUAL_DISK_ACCESS_METAOPS = $00200000;
  VIRTUAL_DISK_ACCESS_READ = $000d0000;
  VIRTUAL_DISK_ACCESS_WRITABLE = $00320000;
  VIRTUAL_DISK_ACCESS_ALL = $003f0000;

oder

Delphi-Quellcode:

type
  _VIRTUAL_DISK_ACCESS_MASK = set of (
    VIRTUAL_DISK_ACCESS_ATTACH_RO = 16,
    VIRTUAL_DISK_ACCESS_ATTACH_RW = 17,
    VIRTUAL_DISK_ACCESS_DETACH = 18,
    VIRTUAL_DISK_ACCESS_GET_INFO = 19,
    VIRTUAL_DISK_ACCESS_CREATE = 20,
    VIRTUAL_DISK_ACCESS_METAOPS = 21
  );
const
  VIRTUAL_DISK_ACCESS_READ = [VIRTUAL_DISK_ACCESS_ATTACH_RO,
    VIRTUAL_DISK_ACCESS_DETACH, VIRTUAL_DISK_ACCESS_GET_INFO];
  VIRTUAL_DISK_ACCESS_WRITABLE = [VIRTUAL_DISK_ACCESS_ATTACH_RW,
    VIRTUAL_DISK_ACCESS_CREATE, VIRTUAL_DISK_ACCESS_METAOPS];
  VIRTUAL_DISK_ACCESS_ALL = [VIRTUAL_DISK_ACCESS_ATTACH_RO..VIRTUAL_DISK_ACCESS_METAOPS];

[Remko]

But it does mean that the recordsize of the CREATE_VIRTUAL_DISK_PARAMETERS might be wrong.

[Remko]

SizeOf(CREATE_VIRTUAL_DISK_PARAMETERS) = 44 and I think it should be 48 since the Union is not anonymous, try:

Delphi-Quellcode:

  CREATE_VIRTUAL_DISK_PARAMETERS = record
  case Version1: Integer of
    0: (
      UniqueId: TGUID;
      MaximumSize: ULONGLONG;
      BlockSizeInBytes: ULONG;
      ParentPath: PWideChar;
      SourcePath: PWideChar);
  end;

[Luckie]

Ist in Delphi2009 nicht schon komplett Unicode implementiert?

[paritycheck]

Danke für Eure Tipps und Anregungen ich habs mittlerweile hinbekommen

Es war scheinbar eine Kombination aus _CREATE_VIRTUAL_DISK_PARAMETERS und der Konstante CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE letztere ist nämlich 0 und nich $200000.

Delphi-Quellcode:

unit createvhd;

interface

uses Sysutils, Windows;

{$ALIGN ON}
{$MINENUMSIZE 4}

const
  VirtDisk_dll = 'VirtDisk.dll';

  VIRTUAL_STORAGE_TYPE_DEVICE_UNKNOWN = 0; //Device type is unknown or not valid.
  VIRTUAL_STORAGE_TYPE_DEVICE_ISO = 1; //Internal use only. Not supported.
  VIRTUAL_STORAGE_TYPE_DEVICE_VHD = 2; //Virtual hard disk device type.

  CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_SECTOR_SIZE = $200;
  [COLOR="Red"]CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE = $0;
[/COLOR]
var
  VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT: TGUID; // '{EC984AEC-A0F9-47e9-901F-71415A66345B}';
  VIRTUAL_STORAGE_TYPE_VENDOR_UNKNOWN  : TGUID; //= 0;

type
/////////////////////////////////////////////////////////
// typedef struct _VIRTUAL_STORAGE_TYPE {
//   ULONG DeviceId;
//   GUID  VendorId;
// } VIRTUAL_STORAGE_TYPE, *PVIRTUAL_STORAGE_TYPE;

  _VIRTUAL_STORAGE_TYPE = record
    DeviceId: ULONG;
    VendorId: TGUID;
  end;
  VIRTUAL_STORAGE_TYPE = _VIRTUAL_STORAGE_TYPE;
  PVIRTUAL_STORAGE_TYPE = ^_VIRTUAL_STORAGE_TYPE;

////////////////////////////////////////////////////////
//  typedef enum _VIRTUAL_DISK_ACCESS_MASK {
//   VIRTUAL_DISK_ACCESS_ATTACH_RO   = 0x00010000,
//   VIRTUAL_DISK_ACCESS_ATTACH_RW   = 0x00020000,
//   VIRTUAL_DISK_ACCESS_DETACH      = 0x00040000,
//   VIRTUAL_DISK_ACCESS_GET_INFO    = 0x00080000,
//   VIRTUAL_DISK_ACCESS_CREATE      = 0x00100000,
//   VIRTUAL_DISK_ACCESS_METAOPS     = 0x00200000,
//   VIRTUAL_DISK_ACCESS_READ        = 0x000d0000,
//   VIRTUAL_DISK_ACCESS_ALL         = 0x003f0000,
//   VIRTUAL_DISK_ACCESS_WRITABLE    = 0x00320000
// } VIRTUAL_DISK_ACCESS_MASK;

  _VIRTUAL_DISK_ACCESS_MASK = (
    VIRTUAL_DISK_ACCESS_ATTACH_RO   = $00010000,
    VIRTUAL_DISK_ACCESS_ATTACH_RW   = $00020000,
    VIRTUAL_DISK_ACCESS_DETACH      = $00040000,
    VIRTUAL_DISK_ACCESS_GET_INFO    = $00080000,
    VIRTUAL_DISK_ACCESS_CREATE      = $00100000,
    VIRTUAL_DISK_ACCESS_METAOPS     = $00200000,
    VIRTUAL_DISK_ACCESS_READ        = $000d0000,
    VIRTUAL_DISK_ACCESS_ALL         = $003f0000,
    VIRTUAL_DISK_ACCESS_WRITABLE    = $00320000
  );
  VIRTUAL_DISK_ACCESS_MASK = _VIRTUAL_DISK_ACCESS_MASK;
  PVIRTUAL_DISK_ACCESS_MASK = ^_VIRTUAL_DISK_ACCESS_MASK;

/////////////////////////////////////////////////////////////////////////
//  typedef enum _CREATE_VIRTUAL_DISK_FLAG {
//    CREATE_VIRTUAL_DISK_FLAG_NONE                       = 0x00000000,
//    CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION   = 0x00000001
//  } CREATE_VIRTUAL_DISK_FLAG;

  _CREATE_VIRTUAL_DISK_FLAG = (
    CREATE_VIRTUAL_DISK_FLAG_NONE                       = $00000000,
    CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION   = $00000001
  );
  CREATE_VIRTUAL_DISK_FLAG = _CREATE_VIRTUAL_DISK_FLAG;
  PCREATE_VIRTUAL_DISK_FLAG = ^_CREATE_VIRTUAL_DISK_FLAG;

////////////////////////////////////////////////////////////////
//  typedef enum _CREATE_VIRTUAL_DISK_VERSION {
//    CREATE_VIRTUAL_DISK_VERSION_UNSPECIFIED   = 0,
//    CREATE_VIRTUAL_DISK_VERSION_1             = 1
//  } CREATE_VIRTUAL_DISK_VERSION;

  _CREATE_VIRTUAL_DISK_VERSION = (
    CREATE_VIRTUAL_DISK_VERSION_UNSPECIFIED   = 0,
    CREATE_VIRTUAL_DISK_VERSION_1             = 1
  );
  CREATE_VIRTUAL_DISK_VERSION = _CREATE_VIRTUAL_DISK_VERSION;
  PCREATE_VIRTUAL_DISK_VERSION= ^_CREATE_VIRTUAL_DISK_VERSION;

////////////////////////////////////////////////////////////////////////////////
//  typedef struct _CREATE_VIRTUAL_DISK_PARAMETERS {
//  CREATE_VIRTUAL_DISK_VERSION Version;
//  union {
//    struct {
//      GUID      UniqueId;
//      ULONGLONG MaximumSize;
//      ULONG     BlockSizeInBytes;
//      ULONG     SectorSizeInBytes;
//      PCWSTR    ParentPath;
//      PCWSTR    SourcePath;
//    } Version1;
//  } ;
//} CREATE_VIRTUAL_DISK_PARAMETERS, *PCREATE_VIRTUAL_DISK_PARAMETERS;

  TCreateVirtualDiskVersion1 = packed record
    UniqueId: TGUID;
    MaximumSize: ULONGLONG;
    BlockSizeInBytes: ULONG;
    SectorSizeInBytes: ULONG;
    ParentPath: Pointer;
    SourcePath: Pointer;
  end;

  _CREATE_VIRTUAL_DISK_PARAMETERS = packed record
    Version: _CREATE_VIRTUAL_DISK_VERSION;
   [COLOR="Red"] case V1:DWORD of[/COLOR]
         0: (Version1: TCreateVirtualDiskVersion1);
  end;
  CREATE_VIRTUAL_DISK_PARAMETERS = _CREATE_VIRTUAL_DISK_PARAMETERS;
  PCREATE_VIRTUAL_DISK_PARAMETERS = ^_CREATE_VIRTUAL_DISK_PARAMETERS;

{
DWORD CreateVirtualDisk(
  __in   PVIRTUAL_STORAGE_TYPE VirtualStorageType,
  __in   PCWSTR Path,
  __in   VIRTUAL_DISK_ACCESS_MASK VirtualDiskAccessMask,
  __in   PSECURITY_DESCRIPTOR SecurityDescriptor,
  __in   CREATE_VIRTUAL_DISK_FLAG Flags,
  __in   ULONG ProviderSpecificFlags,
  __in   PCREATE_VIRTUAL_DISK_PARAMETERS Parameters,
  __in   LPOVERLAPPED Overlapped,
  __out  PHANDLE Handle
);
}

function CreateVirtualDisk(VirtualStorageType: PVIRTUAL_STORAGE_TYPE;
                           Path: PWideChar;
                           VirtualDiskAccessMask: VIRTUAL_DISK_ACCESS_MASK;
                           SecurityDescriptor: PSECURITY_DESCRIPTOR;
                           Flags: CREATE_VIRTUAL_DISK_FLAG;
                           ProviderSpecificFlags: ULong;
                           Parameters: PCREATE_VIRTUAL_DISK_PARAMETERS;
                           Overlapped: POverlapped; Handle: PHandle): Cardinal;
                           stdcall external 'VirtDisk.dll' name 'CreateVirtualDisk';

function CreateFixed(path: PWideChar; size: ULONGLONG; accessMask: _VIRTUAL_DISK_ACCESS_MASK; var AHandle: THandle;
                     source: PWideChar; securityDescriptor: Pointer; overlapped: POverlapped): Cardinal;

implementation

function CreateFixed(path: PWideChar; size: ULONGLONG; accessMask: _VIRTUAL_DISK_ACCESS_MASK; var AHandle: THandle;
                     source: PWideChar; securityDescriptor: Pointer; overlapped: POverlapped): Cardinal;
var
  pParam: PCREATE_VIRTUAL_DISK_PARAMETERS;
  pst: PVIRTUAL_STORAGE_TYPE;
  m_h: THandle;
begin
  pParam:= nil;
  pst:= nil;

  pst:= AllocMem(sizeof(VIRTUAL_STORAGE_TYPE));
  pst.DeviceId:= VIRTUAL_STORAGE_TYPE_DEVICE_VHD;
  pst.VendorId:= VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT;

  pParam:= AllocMem(sizeof(CREATE_VIRTUAL_DISK_PARAMETERS));
  pParam.Version:= CREATE_VIRTUAL_DISK_VERSION_1;
  pParam.Version1.BlockSizeInBytes:= CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE;
  pParam.Version1.SectorSizeInBytes:= CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_SECTOR_SIZE;
  pParam.Version1.MaximumSize:= size;
  pParam.Version1.ParentPath:= nil;
  pParam.Version1.SourcePath:= nil;
  pParam.Version1.UniqueId:= StringToGUid('{00000000-0000-0000-0000-000000000000}');

  Result:= CreateVirtualDisk(pst,
                             path,
                             accessMask,
                             securityDescriptor,
                             CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION,
                             0,
                             pParam,
                             overlapped,
                             @m_h);

  if Result = ERROR_SUCCESS then
     AHandle:= m_h
  else
     AHandle:= INVALID_HANDLE_VALUE;


  if Assigned(pParam) then FreeMem(pParam);
  if Assigned(pst) then FreeMem(pst);
end;

initialization
  VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT:= StringToGUid('{EC984AEC-A0F9-47e9-901F-71415A66345B}');
  VIRTUAL_STORAGE_TYPE_VENDOR_UNKNOWN  := StringToGuid('{00000000-0000-0000-0000-000000000000}');

end.

Und der Aufruf

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  dwRet: Cardinal;
  H: THandle;
const
  DriveSize = 5242880;
begin
  dwRet:= CreateFixed('D:\Workdir\test.vhd', DriveSize, VIRTUAL_DISK_ACCESS_ALL, H, nil, nil, nil);
  if dwRet = ERROR_SUCCESS then
     Showmessage('OK')
  else
     Showmessage(SysErrorMessage(dwRet));
end;

Dann mach ich mich jetzt mal an die anderen VHD API Sachen