Clustergröße bestimmen

[Torsten Bloth]

Hallo Leute!

Ich hätte mal eine Frage.
Gibt es eine zuverlässige Lösung, um die Clustergröße eines Datenträgers zu bestimmen?
Oder lässt sich die Clustergröße eventuell berechnen (Sektoren pro Cluster * Bytes pro Sektor)?

mfg

Torsten

[Hagen Reddmann]

Ja die gibt es. Ich weiß aber nicht mehr wie (
Auf jeden Fall ist die Cluster Größe allein von der Partitionierung abhängig. Unter NT/2000 müsste es mit CreateFile('\\PhysicalDrive0',...) gehen. Dann kann man direkt eins zu eins auf die Daten zugreifen. D.h. wir können die Paritionierungsgrößen auslesen.<br>

Aber wie gesagt: nichts genaues weis man nicht.

Gruß Hage

[Matthias Fichte]

Hallo,<BR>
Schau doch mal unter DeviceLoControl in dem Win API nach.<BR>
Könnte dir evtl. weiterhelfen.<BR>
Gruß<BR>
Matthias<BR&gt

[Torsten Bloth]

Moinsen!

Besten Dank für die Antworten.
Damit werde ich mich dann mal etwas auseinander setzen.

mfg

Torste

[Tim Henford]

...DeviceIOControl ist sehr umfangreich..

[Torsten Bloth]

Ja, musste ich auch feststellen.
Mal schauen, ob ich da durch komme.

mfg

Torste

[Andreas Kosch]

Hallo,

von <i>Steve Schafer</i> (TeamB) wurde vor einiger Zeit das folgende Beispiel in der Newsgroup <i>borland.public.delphi.winapi</i> gepostet. Ich habe es selbst jedoch nicht ausprobiert:
<pre>
unit uIdeDriveInfo;

interface

uses
Windows,
SysUtils,
Classes;

const
DFP_GET_VERSION = $00074080;
DFP_SEND_DRIVE_COMMAND = $0007C084;
DFP_RECEIVE_DRIVE_DATA = $0007C088;
IDE_IDENTIFY_DEVICE = $EC;

type
{$Z1}
TDevices = (dmIdePrimary0, dmIdePrimary1, dmIdeSecondary0,
dmIdeSecondary1, dmAtapiPrimary0, dmAtapiPrimary1,
dmAtapiSecondary0, dmAtapiSecondary1);

TDeviceMap = set of TDevices;

TCapability = (cpIdeIdentify, cpAtapiIdentify, cpSmart,
cpReserved03, cpReserved04, cpReserved05, cpReserved06,
cpReserved07, cpReserved08, cpReserved09, cpReserved10,
cpReserved11, cpReserved12, cpReserved13, cpReserved14,
cpReserved15, cpReserved16, cpReserved17, cpReserved18,
cpReserved19, cpReserved20, cpReserved21, cpReserved22,
cpReserved23, cpReserved24, cpReserved25, cpReserved26,
cpReserved27, cpReserved28, cpReserved29, cpReserved30,
cpReserved31);

TCapabilities = set of TCapability;

PGetVersionOutParams = ^TGetVersionOutParams;
TGetVersionOutParams = packed record
Version: Byte;
Revision: Byte;
Reserved1: Byte;
IdeDeviceMap: TDeviceMap;
Capabilities: TCapabilities;
Reserved2: array[0..3] of DWord end;

PIdeRegs = ^TIdeRegs;
TIdeRegs = packed record
FeaturesReg: Byte;
SectorCount: Byte;
SectorNumber: Byte;
CylLow: Byte;
CylHigh: Byte;
DriveHead: Byte;
Command: Byte;
Reserved: Byte end;

PSendCmdInParams = ^TSendCmdInParams;
TSendCmdInParams = packed record
BufferSize: DWord;
DriveRegs: TIdeRegs;
DriveNumber: Byte;
Reserved1: array[1..3] of Byte;
Reserved2: array[0..3] of DWord end;

PDriverStatus = ^TDriverStatus;
TDriverStatus = packed record
DriverError: Byte;
IdeStatus: Byte;
Reserved1: array[2..3] of Byte;
Reserved2: array[0..1] of DWord end;

PSendCmdOutParams = ^TSendCmdOutParams;
TSendCmdOutParams = packed record
BufferSize: DWord;
DriverStatus: TDriverStatus;
Buffer: array[0..255] of Word end;

const
DriveNumberMin = 0;
DriveNumberMax = 3;

type
TDriveNumber = DriveNumberMin..DriveNumberMax;

TIdeDriveInfo = class(TComponent)
private
FCylinders: array[TDriveNumber] of Integer;
FFirmwareRevision: array[TDriveNumber] of String;
FHeads: array[TDriveNumber] of Integer;
FModelNumber: array[TDriveNumber] of String;
FRemovableMedia: array[TDriveNumber] of Boolean;
FSectorsPerTrack: array[TDriveNumber] of Integer;
FSerialNumber: array[TDriveNumber] of String;
protected
procedure CheckDriveNumber(Drive: TDriveNumber); virtual;
function GetCylinders(Drive: TDriveNumber): Integer; virtual;
function GetFirmwareRevision(Drive: TDriveNumber): String;
virtual;
function GetHeads(Drive: TDriveNumber): Integer; virtual;
function GetModelNumber(Drive: TDriveNumber): String; virtual;
function GetRemovableMedia(Drive: TDriveNumber): Boolean;
virtual;
function GetSectorsPerTrack(Drive: TDriveNumber): Integer;
virtual;
function GetSerialNumber(Drive: TDriveNumber): String; virtual;
procedure QueryDrive(Drive: TDriveNumber); virtual;
public
constructor Create(AOwner: TComponent); override;
property Cylinders[Drive: TDriveNumber]: Integer
read GetCylinders;
property FirmwareRevision[Drive: TDriveNumber]: String
read GetFirmwareRevision;
property Heads[Drive: TDriveNumber]: Integer read GetHeads;
property ModelNumber[Drive: TDriveNumber]: String
read GetModelNumber;
property RemovableMedia[Drive: TDriveNumber]: Boolean
read GetRemovableMedia;
property SectorsPerTrack[Drive: TDriveNumber]: Integer
read GetSectorsPerTrack;
property SerialNumber[Drive: TDriveNumber]: String
read GetSerialNumber; end;

EIdeDriveInfo = class(Exception);

procedure Register;

implementation

procedure Register;
begin
RegisterComponents('Samples', [TIdeDriveInfo]) end;

constructor TIdeDriveInfo.Create(AOwner: TComponent);
var
I: TDriveNumber;
begin
inherited Create(AOwner);
for I := DriveNumberMin to DriveNumberMax do
QueryDrive(I) end;

procedure TIdeDriveInfo.CheckDriveNumber(Drive: TDriveNumber);
begin
if (Drive < DriveNumberMin) or (Drive > DriveNumberMax) then
raise EIdeDriveInfo.CreateFmt('The drive number (%d) is out ' +
'of range; the allowable range is %d to %d', [Drive,
DriveNumberMin, DriveNumberMax]) end;

function TIdeDriveInfo.GetCylinders(Drive: TDriveNumber): Integer;
begin
CheckDriveNumber(Drive);
Result := FCylinders[Drive] end;

function TIdeDriveInfo.GetFirmwareRevision(Drive: TDriveNumber):
String;
begin
CheckDriveNumber(Drive);
Result := FFirmwareRevision[Drive] end;

function TIdeDriveInfo.GetHeads(Drive: TDriveNumber): Integer;
begin
CheckDriveNumber(Drive);
Result := FHeads[Drive] end;

function TIdeDriveInfo.GetModelNumber(Drive: TDriveNumber): String;
begin
CheckDriveNumber(Drive);
Result := FModelNumber[Drive] end;

function TIdeDriveInfo.GetRemovableMedia(Drive: TDriveNumber):
Boolean;
begin
CheckDriveNumber(Drive);
Result := FRemovableMedia[Drive] end;

function TIdeDriveInfo.GetSectorsPerTrack(Drive: TDriveNumber):
Integer;
begin
CheckDriveNumber(Drive);
Result := FSectorsPerTrack[Drive] end;

function TIdeDriveInfo.GetSerialNumber(Drive: TDriveNumber): String;
begin
CheckDriveNumber(Drive);
Result := FSerialNumber[Drive] end;

procedure TIdeDriveInfo.QueryDrive(Drive: TDriveNumber);
var
BytesReturned: DWord;
CmdIn: TSendCmdInParams;
CmdOut: TSendCmdOutParams;
DriveName: String;
H: THandle;
I: Integer;
VersionInfo: TGetVersionOutParams;
begin
FCylinders[Drive] := 0;
FFirmwareRevision[Drive] := '';
FHeads[Drive] := 0;
FModelNumber[Drive] := '';
FRemovableMedia[Drive] := False;
FSectorsPerTrack[Drive] := 0;
FSerialNumber[Drive] := '';
DriveName := Format('\\.\PHYSICALDRIVE%d', [Drive]);
H := CreateFile(PChar(DriveName), GENERIC_READ or GENERIC_WRITE, 0,
nil, OPEN_EXISTING, 0, 0);
if H = INVALID_HANDLE_VALUE then
Exit;
try
FillChar(VersionInfo, SizeOf(VersionInfo), 0);
BytesReturned := 0;
if not DeviceIoControl(H, DFP_GET_VERSION, nil, 0, @VersionInfo,
SizeOf(VersionInfo), BytesReturned, nil) then
Exit;
if not (cpIdeIdentify in VersionInfo.Capabilities) then
Exit;
FillChar(CmdIn, SizeOf(CmdIn), 0);
CmdIn.BufferSize := 0;
CmdIn.DriveRegs.Command := IDE_IDENTIFY_DEVICE;
CmdIn.DriveNumber := Drive;
FillChar(CmdOut, SizeOf(CmdOut), 0);
CmdOut.BufferSize := SizeOf(CmdOut.Buffer);
BytesReturned := 0;
if not DeviceIoControl(H, DFP_RECEIVE_DRIVE_DATA, @CmdIn,
SizeOf(CmdIn), @CmdOut, SizeOf(CmdOut), BytesReturned,
nil) then
Exit;
with CmdOut do begin
for I := 10 to 19 do
Buffer[I] := (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);
for I := 23 to 46 do
Buffer[I] := (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);
FRemovableMedia[Drive] := (Buffer[0] and $80) <> 0;
FCylinders[Drive] := Buffer[1];
FHeads[Drive] := Buffer[3];
FSectorsPerTrack[Drive] := Buffer[6];
SetLength(FSerialNumber[Drive], 20);
Move(Buffer[10], FSerialNumber[Drive][1],
Length(FSerialNumber[Drive]));
FSerialNumber[Drive] := Trim(FSerialNumber[Drive]);
SetLength(FFirmwareRevision[Drive], 8);
Move(Buffer[23], FFirmwareRevision[Drive][1],
Length(FFirmwareRevision[Drive]));
FFirmwareRevision[Drive] := Trim(FFirmwareRevision[Drive]);
SetLength(FModelNumber[Drive], 40);
Move(Buffer[27], FModelNumber[Drive][1],
Length(FModelNumber[Drive]));
FModelNumber[Drive] := Trim(FModelNumber[Drive]) end;
finally
CloseHandle(H) end end;

end.
</pre&gt