Übersetzung von CreateVirtualDisk

[paritycheck]

Hi,
ich versuche erfolglos seit einiger Zeit die Funktion CreateVirtualDisk aus der MSDN nach Delphi zu portieren.
Egal was ich auch mache, ich bekomme immer ERROR_INVALID_ARGUMENTS als Rückgabe. Vermutlich liegt es an irgendwas ganz banalem... aber ich seh den Wald vor lauter Bäumen nicht mehr.
Vielleicht hat ja jemand ne Idee.

<edit> Ich sollte noch dazuschreiben das es die VirtDisk.dll erst ab Windows 7 gibt </edit>

Delphi-Quellcode:

unit Unit2;

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;
//  CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE = $0;
  CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE = $200000;

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 =  record
    Version: _CREATE_VIRTUAL_DISK_VERSION;
    case Integer of
         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';

implementation

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

end.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  parameters: CREATE_VIRTUAL_DISK_PARAMETERS;
  storageType: VIRTUAL_STORAGE_TYPE;
  m_h: THandle;
  dwRet: Cardinal;
  path : PWideChar;
  securityDescriptor: TSecurityDescriptor;
begin
  storageType.DeviceId:= VIRTUAL_STORAGE_TYPE_DEVICE_VHD;
  storageType.VendorId:= VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT;

  parameters.Version:= CREATE_VIRTUAL_DISK_VERSION_1;
  parameters.Version1.BlockSizeInBytes:= CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE;
  parameters.Version1.SectorSizeInBytes:= CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_SECTOR_SIZE;
  parameters.Version1.MaximumSize:= 1024* 1024 * 512;
  parameters.Version1.ParentPath:= nil;
  parameters.Version1.SourcePath:= nil;
  parameters.Version1.UniqueId:= StringToGUid('{00000000-0000-0000-0000-000000000000}');

  path:= PWideChar(ExtractFilePath(Paramstr(0))+'test.vhd');
  showmessage(path);
  ///m_h:= 0;

  dwRet:= CreateVirtualDisk(@StorageType, path, VIRTUAL_DISK_ACCESS_ALL, nil,
                            CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION, 0, @parameters, nil, @m_h);
  if (dwRet <> ERROR_SUCCESS) then
     Showmessage(syserrormessage(dwRet))
  else
  begin
     Showmessage('Success.');
     closehandle(m_h);
  end;
end;

[SirThornberry]

Hast du irgendwo einen funktionierenden Beispielaufruf für C? Denn vielleicht liegt es gar nicht an der Übersetzung sondern wirklich am Aufruf.
Bevor man sich die Arbeit macht und Schritt für Schritt die Richtigkeit der Übersetzung prüft würde ich nach einem funktionierendem Beispielaufruf suchen.

[paritycheck]

Ja hab ich aber das müsste eigentlich so hinhauen.
Habe auch schon die Vermutung gehabt das vielleicht irgendwo ein const oder var fehlt.

Quelle

Code:

class VirtualDisk : public CHandle
{
public:

    DWORD CreateFixed(PCWSTR path,
                      ULONGLONG size,
                      VIRTUAL_DISK_ACCESS_MASK accessMask,
                      __in_opt PCWSTR source,
                      __in_opt PSECURITY_DESCRIPTOR securityDescriptor,
                      __in_opt OVERLAPPED* overlapped)
    {
        ASSERT(0 == m_h);
        ASSERT(0 != path);
        ASSERT(0 == size % 512);

        VIRTUAL_STORAGE_TYPE storageType =
        {
            VIRTUAL_STORAGE_TYPE_DEVICE_VHD,
            VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT
        };

        CREATE_VIRTUAL_DISK_PARAMETERS parameters =
        {
            CREATE_VIRTUAL_DISK_VERSION_1
        };

        parameters.Version1.MaximumSize = size;
        parameters.Version1.BlockSizeInBytes = CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_BLOCK_SIZE;
        parameters.Version1.SectorSizeInBytes = CREATE_VIRTUAL_DISK_PARAMETERS_DEFAULT_SECTOR_SIZE;
        parameters.Version1.SourcePath = source;

        return ::CreateVirtualDisk(&storageType,
                                   path,
                                   accessMask,
                                   securityDescriptor,
                                   CREATE_VIRTUAL_DISK_FLAG_FULL_PHYSICAL_ALLOCATION,
                                   0, // no provider-specific flags
                                   &parameters,
                                   overlapped,
                                   &m_h);
    }

[SirThornberry]

Was ich so beim ersten drüber fliegen sehe ist das beim C(++)-Beispiel keine UniqueID gesetzt wird.

[himitsu]

@SirThornberry: Ist diese auf 0 gesetzt, dann wird vom System (Windows) eine erstellt.
Eventuell wird in C++ ja dieser Speicherbereich automatisch mit Nullen initialisiert.


Auf die Schnelle würde ich erstmal dieses auspprobieren.

Delphi-Quellcode:

var path : WideString;

path := ExtractFilePath(Paramstr(0)) + 'test.vhd';

dwRet := CreateVirtualDisk(@StorageType, PWideChar(path), ...

Dieser Abschnitt (im MSDN) scheint auch nicht zuzutreffen?

Zitat:

Remarks

If the CreateVirtualDisk function fails with an error code value of ERROR_INVALID_PARAMETER, the cause may be due to any of the following conditions:

(ich glaub zwar, daß dort alles stimmt, aber vielleicht hab'sch ja doch was übersehn)

Die Signatur scheint eigentlich auch zu stimmen.
Als Alternative könnte ich aber dennoch sowas anbieten:

Delphi-Quellcode:

function CreateVirtualDisk(
  const VirtualStorageType: VIRTUAL_STORAGE_TYPE;
  Path: PWideChar; // man könnte sogar direkt "const Path: WideString" angeben
  VirtualDiskAccessMask: VIRTUAL_DISK_ACCESS_MASK;
  SecurityDescriptor: PSECURITY_DESCRIPTOR;
  Flags: CREATE_VIRTUAL_DISK_FLAG;
  ProviderSpecificFlags: LongWord;
  const Parameters: CREATE_VIRTUAL_DISK_PARAMETERS;
  Overlapped: POverlapped; 
  var Handle: THandle): LongWord; stdcall; 
external 'VirtDisk.dll';

Ansonsten könnte noch ein Problem in den Records liegen, also speziell in der Speicherausrichtung.
Aber bei den hier vorkommenden Feld-Typen sollte es eigentlich nahezu egal sein, selbst wenn eine falsche Record-Ausrichtung verwendet würde (fast Alles schön einheitliche 32-Bit-Werte). Sicherheitshalber könnte man mal versuchen rauszubekommen wie groß die Records in C++ wirklich sind, bzw. man schaut mal in die passenden C-Headerfiles und versucht da was zu finden.

[paritycheck]

@SirThornberry:
So wie ich das verstanden hab ist das setzen einer GUID Optional.

Zitat:

The Version1 structure also provides a UniqueId member, but if you leave this zeroed out, the CreateVirtualDisk function will generate a GUID for you.

@himitsu:

Funktioniert leider auch nicht

[himitsu]

Gut, dann scheint schonmal (laut den Definitionen, also falls diese stimmen) die Signatur zu stimmen.
Bleiben also nur noch die Records oder doch die Belegung der Parameter.


Hast du es auch schonmal als Overlappt-IO versucht?

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

[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?