Delphi-PRAXiS

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)
-   Win32/Win64 API (native code) (https://www.delphipraxis.net/17-win32-win64-api-native-code/)
-   -   Delphi Übersetzung von CreateVirtualDisk (https://www.delphipraxis.net/155447-uebersetzung-von-createvirtualdisk.html)

paritycheck 24. Okt 2010 08:59
Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 10:47
AW: Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 10:53
AW: Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 11:00
AW: Übersetzung von CreateVirtualDisk
 
Was ich so beim ersten drüber fliegen sehe ist das beim C(++)-Beispiel keine UniqueID gesetzt wird.

himitsu 24. Okt 2010 11:02
AW: Übersetzung von CreateVirtualDisk
 
@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.

:gruebel:

paritycheck 24. Okt 2010 11:09
AW: Übersetzung von CreateVirtualDisk
 
@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 24. Okt 2010 11:18
AW: Übersetzung von CreateVirtualDisk
 
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
Delphi-Quellcode:
m_h := 0;
wurde auch schonmal verwendet?

paritycheck 24. Okt 2010 11:34
AW: Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 20:28
AW: Übersetzung von CreateVirtualDisk
 
It seems you are passing an enum as a parameter(s), did you set {$MINENUMSIZE 4}?

Assarbad 24. Okt 2010 20:58
AW: Übersetzung von CreateVirtualDisk
 
Zitat:
Zitat von Remko (Beitrag 1057589)
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 24. Okt 2010 21:58
AW: Übersetzung von CreateVirtualDisk
 
Zitat:
Zitat von Assarbad (Beitrag 1057595)
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 24. Okt 2010 21:59
AW: Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 22:12
AW: Übersetzung von CreateVirtualDisk
 
But it does mean that the recordsize of the CREATE_VIRTUAL_DISK_PARAMETERS might be wrong.

Remko 24. Okt 2010 22:23
AW: Übersetzung von CreateVirtualDisk
 
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 24. Okt 2010 22:56
AW: Übersetzung von CreateVirtualDisk
 
Ist in Delphi2009 nicht schon komplett Unicode implementiert?

paritycheck 25. Okt 2010 09:31
AW: Übersetzung von CreateVirtualDisk
 
Danke für Eure Tipps und Anregungen :thumb: ich habs mittlerweile hinbekommen :-D

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. :oops:

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 ;)

Dezipaitor 25. Okt 2010 13:03
AW: Übersetzung von CreateVirtualDisk
 
Würdest du das vielleicht an die JEDI API überarbeitet spenden?

paritycheck 25. Okt 2010 13:25
AW: Übersetzung von CreateVirtualDisk
 
Sicher doch :wink: Wenn ich den Rest übersetzt habe "spende" ich auch gerne die ganze unit.

paritycheck 27. Okt 2010 14:49
AW: Übersetzung von CreateVirtualDisk
 
Liste der Anhänge anzeigen (Anzahl: 1)
So dann lade ich mal wie versprochen die fertige Unit hoch.

Der eigentliche Header ist die virtdisk.pas. Alles andere diente nur dazu zu sehen ob die Funktion was ausspuckt und sollte daher nicht zu streng bewertet werden. 8-)

Eigentlich sollte alles soweit funktionieren. Ich übernehme natürlich keinerle Garantie oder Gewährleistung dafür. Sollte also irgendwem die Bude abfackeln oder der PC explodieren...selbst schuld. :stupid:

Getestet hab ich das ganze mit Delphi 2009 evtl könnten also noch kleine Änderungen unter älteren Versionen nötig sein.


Alle Zeitangaben in WEZ +1. Es ist jetzt 22:01 Uhr.

Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz