Win32 API 日本語リファレンス
ホーム › Storage.VirtualDiskService › VDS_HINTS2

VDS_HINTS2

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 136 バイト / x86: 136 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド型サイズx64x86説明
ullHintMaskULONGLONG8+0+0

LUN のヒント マスクです。この構造体の各 BOOL メンバーには、このマスクに設定できる対応するヒント フラグがあります。 ヒント フラグが設定されている場合、対応するヒントが考慮されます。ヒント フラグが設定されていない場合、そのヒントは無視されます。 ヒント フラグを次の表に示します。

値 意味
VDS_HINT_FASTCRASHRECOVERYREQUIRED
0x0000000000000001L
 プロバイダーは回復に必要な時間を制限します。高速な回復をサポートするため、プロバイダーは変更ログを使用し、LUN の内容全体を比較することなく LUN を回復できるようにします。
VDS_HINT_MOSTLYREADS
0x0000000000000002L
 プロバイダーは、読み取りが大半を占める使用パターンに合わせて LUN を最適化します。通常は、パリティ ストライピングではなくミラーリングを使用します。
VDS_HINT_OPTIMIZEFORSEQUENTIALREADS
0x0000000000000004L
 プロバイダーは、シーケンシャル読み取りの使用パターンに合わせて LUN を最適化します。このフラグが設定されておらず、VDS_HINT_OPTIMIZEFORSEQUENTIALWRITES も設定されていない場合、LUN はランダム I/O 用に最適化されます。
VDS_HINT_OPTIMIZEFORSEQUENTIALWRITES
0x0000000000000008L
 プロバイダーは、シーケンシャル書き込みの使用パターンに合わせて LUN を最適化します。このフラグが設定されておらず、VDS_HINT_OPTIMIZEFORSEQUENTIALREADS も設定されていない場合、LUN はランダム I/O 用に最適化されます。
VDS_HINT_READBACKVERIFYENABLED
0x0000000000000010L
 プロバイダーは、読み戻し (readback) によって LUN への書き込みを検証します。
VDS_HINT_REMAPENABLED
0x0000000000000020L
 LUN エクステントからドライブ エクステントへのマッピングは、プロバイダーによって自動的に作成および更新されます。このフラグが設定されていない場合、ドライブ障害を回避するための予防的な処理が行われる場合を除き、構成後のマッピングは固定されたままになります。
VDS_HINT_WRITETHROUGHCACHINGENABLED
0x0000000000000040L
 プロバイダーは、LUN でライトスルー キャッシュ ポリシーを有効にします。
VDS_HINT_HARDWARECHECKSUMENABLED
0x0000000000000080L
 プロバイダーは、LUN でハードウェア チェックサムを有効にします。
VDS_HINT_ISYANKABLE
0x0000000000000100L
 プロバイダーは、LUN を構成するドライブをシステムへの影響を最小限に抑えて物理的に取り外せるように LUN を構成します。これは通常、LUN が使用するドライブの数をできるだけ少なくすることで実現されます。
VDS_HINT_ALLOCATEHOTSPARE
0x0000000000000200L
 プロバイダーは、LUN 用のホット スペアを割り当てます。詳細については、Hot Sparing、VDS_DRIVE_FLAG、および VDS_DISK_FLAG を参照してください。
VDS_HINT_BUSTYPE
0x0000000000000400L
 プロバイダーは、LUN で指定されたバスの種類を使用します。詳細については、VDS_STORAGE_BUS_TYPE を参照してください。
VDS_HINT_USEMIRROREDCACHE
0x0000000000000800L
 プロバイダーは、LUN でミラー化されたキャッシュを使用します。VDS_SUB_SYSTEM_FLAG 列挙型の VDS_SF_SUPPORTS_MIRRORED_CACHE 値を参照してください。
VDS_HINT_READCACHINGENABLED
0x0000000000001000L
 プロバイダーは、LUN で読み取りキャッシュを有効にします。VDS_LUN_FLAG 列挙型の VDS_LF_READ_CACHE_ENABLED 値、および VDS_SUB_SYSTEM_FLAG 列挙型の VDS_SF_READ_CACHING_CAPABLE 値を参照してください。
VDS_HINT_WRITECACHINGENABLED
0x0000000000002000L
 プロバイダーは、LUN で書き込みキャッシュを有効にします。VDS_LUN_FLAG 列挙型の VDS_LF_WRITE_CACHE_ENABLED 値、および VDS_SUB_SYSTEM_FLAG 列挙型の VDS_SF_WRITE_CACHING_CAPABLE 値を参照してください。
VDS_HINT_MEDIASCANENABLED
0x0000000000004000L
 プロバイダーは、LUN でメディア スキャンを有効にします。VDS_LUN_FLAG 列挙型の VDS_LF_MEDIA_SCAN_ENABLED 値、および VDS_SUB_SYSTEM_FLAG 列挙型の VDS_SF_MEDIA_SCAN_CAPABLE 値を参照してください。
VDS_HINT_CONSISTENCYCHECKENABLED
0x0000000000008000L
 プロバイダーは、LUN で整合性チェックを有効にします。VDS_LUN_FLAG 列挙型の VDS_LF_CONSISTENCY_CHECK_ENABLED 値、および VDS_SUB_SYSTEM_FLAG 列挙型の VDS_SF_CONSISTENCY_CHECK_CAPABLE 値を参照してください。
ullExpectedMaximumSizeULONGLONG8+8+8LUN が拡張されると見込まれる最大サイズ (バイト単位)。この値は、 IVdsHwProviderStoragePools::CreateLunInStoragePool メソッドの呼び出し時に ullSizeInBytes パラメーターで指定した値と等しくても、大きくても、小さくてもかまいません。 一部のプロバイダーは、この値を使用して LUN 用の領域を予約します。領域を予約できないプロバイダーは、 通常このパラメーターを無視します。
ulOptimalReadSizeDWORD4+16+16LUN の最適な読み取りサイズ (バイト単位)。0 は最適な読み取りサイズがないことを示します。
ulOptimalReadAlignmentDWORD4+20+20LUN の最初の論理ブロックを基準とした最適な読み取りアラインメント。0 は最適な読み取り アラインメントがないことを示します。
ulOptimalWriteSizeDWORD4+24+24LUN の最適な書き込みサイズ (バイト単位)。0 は最適な書き込みサイズがないことを示します。
ulOptimalWriteAlignmentDWORD4+28+28LUN の最初の論理ブロックを基準とした最適な書き込みアラインメント。0 は最適な 書き込みアラインメントがないことを示します。
ulMaximumDriveCountDWORD4+32+32LUN を構成するドライブの最大数。0 はドライブ数の上限がないことを示します。この値は、 ストライプ セット内のストライプ インターリーブ数を制限するために使用できます。
ulStripeSizeDWORD4+36+36ミラーまたはパリティのストライプ インターリーブ サイズ (バイト単位)。0 の場合、ストライプ サイズは指定されません。
ulReserved1DWORD4+40+40このメンバーは将来の使用のために予約済みです。使用しないでください。
ulReserved2DWORD4+44+44このメンバーは将来の使用のために予約済みです。使用しないでください。
ulReserved3DWORD4+48+48このメンバーは将来の使用のために予約済みです。使用しないでください。
bFastCrashRecoveryRequiredBOOL4+52+52このメンバーが TRUE の場合、回復時間が制限されます。このメンバーを考慮させるには、ullHintMask メンバーに VDS_HINT_FASTCRASHRECOVERYREQUIRED フラグを設定します。
bMostlyReadsBOOL4+56+56読み取りが大半を占める使用パターンに合わせて最適化する場合 (たとえば、パリティ ストライピングではなくミラーリングを使用する場合) は、 このメンバーを TRUE に設定します。それ以外の場合は FALSE に設定します。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_MOSTLYREADS フラグを設定します。
bOptimizeForSequentialReadsBOOL4+60+60シーケンシャル読み取りの使用パターンに合わせて最適化する場合は、このメンバーを TRUE に設定します。それ以外の場合は FALSE に設定します。 bOptimizeForSequentialReads メンバーと bOptimizeForSequentialWrites メンバーの両方を FALSE に設定すると、ランダム I/O 用に最適化されます。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_OPTIMIZEFORSEQUENTIALREADS フラグを設定します。
bOptimizeForSequentialWritesBOOL4+64+64シーケンシャル書き込みの使用パターンに合わせて最適化する場合は、このメンバーを TRUE に設定します。それ以外の場合は FALSE に設定します。 bOptimizeForSequentialReads メンバーと bOptimizeForSequentialWrites メンバーの両方を FALSE に設定すると、ランダム I/O 用に最適化されます。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_OPTIMIZEFORSEQUENTIALWRITES フラグを設定します。
bRemapEnabledBOOL4+68+68このメンバーが TRUE の場合、プロバイダーは LUN エクステントからドライブ エクステントへのマッピングを自動的に再マップします。FALSE の場合、LUN エクステントから ドライブ エクステントへのマッピングは、LUN の構成後は固定されたままになります (破損したブロックを回避するためにエクステントが明示的に再マップされる場合を除きます)。 このメンバーを考慮させるには、ullHintMask メンバーに VDS_HINT_REMAPENABLED フラグを設定します。
bReadBackVerifyEnabledBOOL4+72+72このメンバーが TRUE の場合、プロバイダーは読み戻しによって LUN への書き込みを検証します。FALSE の場合、プロバイダーは書き込みを検証しません。 このメンバーを考慮させるには、ullHintMask メンバーに VDS_HINT_READBACKVERIFYENABLED フラグを設定します。
bWriteThroughCachingEnabledBOOL4+76+76このメンバーが TRUE の場合、プロバイダーは LUN でライトスルー キャッシュを有効にします。FALSE の場合、プロバイダーは ライトスルー キャッシュを有効にしません。このメンバーを考慮させるには、ullHintMask メンバーに VDS_HINT_WRITETHROUGHCACHINGENABLED フラグを設定します。
bHardwareChecksumEnabledBOOL4+80+80このメンバーが TRUE の場合、プロバイダーは LUN でチェックサムを有効にします。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_HARDWARECHECKSUMENABLED フラグを設定します。
bIsYankableBOOL4+84+84このメンバーが TRUE の場合、LUN を構成するドライブを、システムに大きな影響を与えることなく物理的に取り外すことができます (通常、LUN がごく少数のドライブのエクステントで構成されている場合に該当します)。FALSE の場合、LUN は システムに大きな影響を与えずに取り外すことはできません。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_ISYANKABLE フラグを設定します。
bAllocateHotSpareBOOL4+88+88クライアントがこの LUN 用にホット スペア ドライブを割り当てることを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_ALLOCATEHOTSPARE フラグを設定します。
bUseMirroredCacheBOOL4+92+92クライアントがこの LUN でミラー化されたキャッシュを使用することを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_USEMIRROREDCACHE フラグを設定します。
bReadCachingEnabledBOOL4+96+96クライアントが LUN で読み取りキャッシュを使用することを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_READCACHINGENABLED フラグを設定します。
bWriteCachingEnabledBOOL4+100+100クライアントが LUN で書き込みキャッシュを使用することを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_WRITECACHINGENABLED フラグを設定します。
bMediaScanEnabledBOOL4+104+104クライアントがこの LUN でメディア スキャンを有効にすることを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_MEDIASCANENABLED フラグを設定します。
bConsistencyCheckEnabledBOOL4+108+108クライアントがこの LUN で整合性チェックを有効にすることを希望する場合は TRUE、それ以外の場合は FALSE です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_CONSISTENCYCHECKENABLED フラグを設定します。
BusTypeVDS_STORAGE_BUS_TYPE4+112+112LUN のバスの種類を指定する VDS_STORAGE_BUS_TYPE 列挙型の値です。このメンバーを考慮させるには、 ullHintMask メンバーに VDS_HINT_BUSTYPE フラグを設定します。
bReserved1BOOL4+116+116このメンバーは将来の使用のために予約済みです。使用しないでください。
bReserved2BOOL4+120+120このメンバーは将来の使用のために予約済みです。使用しないでください。
bReserved3BOOL4+124+124このメンバーは将来の使用のために予約済みです。使用しないでください。
sRebuildPrioritySHORT2+128+128LUN の再構築の優先度です。値の範囲は 0 (最低の優先度) から 15 (最高の優先度) までです。

公式ドキュメント

[Windows 8 および Windows Server 2012 以降、Virtual Disk Service COM インターフェイスは Windows Storage Management API に置き換えられています。]

記憶域プール内の LUN に対する自動構成 (automagic) ヒントを格納します。

解説(Remarks)

IVdsHwProviderStoragePools::CreateLunInStoragePool メソッドは、記憶域プール内に LUN を作成するためのヒントを提供するために、 この構造体をパラメーターとして渡します。また、LUN に新しいヒントのセットを適用するために、 IVdsLun2::ApplyHints2 メソッドのパラメーターとしても渡されます。さらに、LUN または LUN プレックスに現在適用されているヒントを報告するために、 IVdsLun2::QueryHints2 メソッドによって返されます。

ヒントは実装者に対する指示ではありません。実装者は一般にヒントを可能な限り考慮することが期待されますが、 それらに従う義務はありません。技術的な理由から指定されたヒントに従えない場合や、従うと構成が不適切になる場合には、 実装者は代替手段を選択できます。

出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での定義

#include <windows.h>

// VDS_HINTS2  (x64 136 / x86 136 バイト)
typedef struct VDS_HINTS2 {
    ULONGLONG ullHintMask;
    ULONGLONG ullExpectedMaximumSize;
    DWORD ulOptimalReadSize;
    DWORD ulOptimalReadAlignment;
    DWORD ulOptimalWriteSize;
    DWORD ulOptimalWriteAlignment;
    DWORD ulMaximumDriveCount;
    DWORD ulStripeSize;
    DWORD ulReserved1;
    DWORD ulReserved2;
    DWORD ulReserved3;
    BOOL bFastCrashRecoveryRequired;
    BOOL bMostlyReads;
    BOOL bOptimizeForSequentialReads;
    BOOL bOptimizeForSequentialWrites;
    BOOL bRemapEnabled;
    BOOL bReadBackVerifyEnabled;
    BOOL bWriteThroughCachingEnabled;
    BOOL bHardwareChecksumEnabled;
    BOOL bIsYankable;
    BOOL bAllocateHotSpare;
    BOOL bUseMirroredCache;
    BOOL bReadCachingEnabled;
    BOOL bWriteCachingEnabled;
    BOOL bMediaScanEnabled;
    BOOL bConsistencyCheckEnabled;
    VDS_STORAGE_BUS_TYPE BusType;
    BOOL bReserved1;
    BOOL bReserved2;
    BOOL bReserved3;
    SHORT sRebuildPriority;
} VDS_HINTS2;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VDS_HINTS2
{
    public ulong ullHintMask;
    public ulong ullExpectedMaximumSize;
    public uint ulOptimalReadSize;
    public uint ulOptimalReadAlignment;
    public uint ulOptimalWriteSize;
    public uint ulOptimalWriteAlignment;
    public uint ulMaximumDriveCount;
    public uint ulStripeSize;
    public uint ulReserved1;
    public uint ulReserved2;
    public uint ulReserved3;
    [MarshalAs(UnmanagedType.Bool)] public bool bFastCrashRecoveryRequired;
    [MarshalAs(UnmanagedType.Bool)] public bool bMostlyReads;
    [MarshalAs(UnmanagedType.Bool)] public bool bOptimizeForSequentialReads;
    [MarshalAs(UnmanagedType.Bool)] public bool bOptimizeForSequentialWrites;
    [MarshalAs(UnmanagedType.Bool)] public bool bRemapEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bReadBackVerifyEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bWriteThroughCachingEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bHardwareChecksumEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bIsYankable;
    [MarshalAs(UnmanagedType.Bool)] public bool bAllocateHotSpare;
    [MarshalAs(UnmanagedType.Bool)] public bool bUseMirroredCache;
    [MarshalAs(UnmanagedType.Bool)] public bool bReadCachingEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bWriteCachingEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bMediaScanEnabled;
    [MarshalAs(UnmanagedType.Bool)] public bool bConsistencyCheckEnabled;
    public int BusType;
    [MarshalAs(UnmanagedType.Bool)] public bool bReserved1;
    [MarshalAs(UnmanagedType.Bool)] public bool bReserved2;
    [MarshalAs(UnmanagedType.Bool)] public bool bReserved3;
    public short sRebuildPriority;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure VDS_HINTS2
    Public ullHintMask As ULong
    Public ullExpectedMaximumSize As ULong
    Public ulOptimalReadSize As UInteger
    Public ulOptimalReadAlignment As UInteger
    Public ulOptimalWriteSize As UInteger
    Public ulOptimalWriteAlignment As UInteger
    Public ulMaximumDriveCount As UInteger
    Public ulStripeSize As UInteger
    Public ulReserved1 As UInteger
    Public ulReserved2 As UInteger
    Public ulReserved3 As UInteger
    <MarshalAs(UnmanagedType.Bool)> Public bFastCrashRecoveryRequired As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bMostlyReads As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bOptimizeForSequentialReads As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bOptimizeForSequentialWrites As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bRemapEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bReadBackVerifyEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bWriteThroughCachingEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bHardwareChecksumEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bIsYankable As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bAllocateHotSpare As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bUseMirroredCache As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bReadCachingEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bWriteCachingEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bMediaScanEnabled As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bConsistencyCheckEnabled As Boolean
    Public BusType As Integer
    <MarshalAs(UnmanagedType.Bool)> Public bReserved1 As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bReserved2 As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bReserved3 As Boolean
    Public sRebuildPriority As Short
End Structure
import ctypes
from ctypes import wintypes

class VDS_HINTS2(ctypes.Structure):
    _fields_ = [
        ("ullHintMask", ctypes.c_ulonglong),
        ("ullExpectedMaximumSize", ctypes.c_ulonglong),
        ("ulOptimalReadSize", wintypes.DWORD),
        ("ulOptimalReadAlignment", wintypes.DWORD),
        ("ulOptimalWriteSize", wintypes.DWORD),
        ("ulOptimalWriteAlignment", wintypes.DWORD),
        ("ulMaximumDriveCount", wintypes.DWORD),
        ("ulStripeSize", wintypes.DWORD),
        ("ulReserved1", wintypes.DWORD),
        ("ulReserved2", wintypes.DWORD),
        ("ulReserved3", wintypes.DWORD),
        ("bFastCrashRecoveryRequired", wintypes.BOOL),
        ("bMostlyReads", wintypes.BOOL),
        ("bOptimizeForSequentialReads", wintypes.BOOL),
        ("bOptimizeForSequentialWrites", wintypes.BOOL),
        ("bRemapEnabled", wintypes.BOOL),
        ("bReadBackVerifyEnabled", wintypes.BOOL),
        ("bWriteThroughCachingEnabled", wintypes.BOOL),
        ("bHardwareChecksumEnabled", wintypes.BOOL),
        ("bIsYankable", wintypes.BOOL),
        ("bAllocateHotSpare", wintypes.BOOL),
        ("bUseMirroredCache", wintypes.BOOL),
        ("bReadCachingEnabled", wintypes.BOOL),
        ("bWriteCachingEnabled", wintypes.BOOL),
        ("bMediaScanEnabled", wintypes.BOOL),
        ("bConsistencyCheckEnabled", wintypes.BOOL),
        ("BusType", ctypes.c_int),
        ("bReserved1", wintypes.BOOL),
        ("bReserved2", wintypes.BOOL),
        ("bReserved3", wintypes.BOOL),
        ("sRebuildPriority", ctypes.c_short),
    ]
#[repr(C)]
pub struct VDS_HINTS2 {
    pub ullHintMask: u64,
    pub ullExpectedMaximumSize: u64,
    pub ulOptimalReadSize: u32,
    pub ulOptimalReadAlignment: u32,
    pub ulOptimalWriteSize: u32,
    pub ulOptimalWriteAlignment: u32,
    pub ulMaximumDriveCount: u32,
    pub ulStripeSize: u32,
    pub ulReserved1: u32,
    pub ulReserved2: u32,
    pub ulReserved3: u32,
    pub bFastCrashRecoveryRequired: i32,
    pub bMostlyReads: i32,
    pub bOptimizeForSequentialReads: i32,
    pub bOptimizeForSequentialWrites: i32,
    pub bRemapEnabled: i32,
    pub bReadBackVerifyEnabled: i32,
    pub bWriteThroughCachingEnabled: i32,
    pub bHardwareChecksumEnabled: i32,
    pub bIsYankable: i32,
    pub bAllocateHotSpare: i32,
    pub bUseMirroredCache: i32,
    pub bReadCachingEnabled: i32,
    pub bWriteCachingEnabled: i32,
    pub bMediaScanEnabled: i32,
    pub bConsistencyCheckEnabled: i32,
    pub BusType: i32,
    pub bReserved1: i32,
    pub bReserved2: i32,
    pub bReserved3: i32,
    pub sRebuildPriority: i16,
}
import "golang.org/x/sys/windows"

type VDS_HINTS2 struct {
	ullHintMask uint64
	ullExpectedMaximumSize uint64
	ulOptimalReadSize uint32
	ulOptimalReadAlignment uint32
	ulOptimalWriteSize uint32
	ulOptimalWriteAlignment uint32
	ulMaximumDriveCount uint32
	ulStripeSize uint32
	ulReserved1 uint32
	ulReserved2 uint32
	ulReserved3 uint32
	bFastCrashRecoveryRequired int32
	bMostlyReads int32
	bOptimizeForSequentialReads int32
	bOptimizeForSequentialWrites int32
	bRemapEnabled int32
	bReadBackVerifyEnabled int32
	bWriteThroughCachingEnabled int32
	bHardwareChecksumEnabled int32
	bIsYankable int32
	bAllocateHotSpare int32
	bUseMirroredCache int32
	bReadCachingEnabled int32
	bWriteCachingEnabled int32
	bMediaScanEnabled int32
	bConsistencyCheckEnabled int32
	BusType int32
	bReserved1 int32
	bReserved2 int32
	bReserved3 int32
	sRebuildPriority int16
}
type
  VDS_HINTS2 = record
    ullHintMask: UInt64;
    ullExpectedMaximumSize: UInt64;
    ulOptimalReadSize: DWORD;
    ulOptimalReadAlignment: DWORD;
    ulOptimalWriteSize: DWORD;
    ulOptimalWriteAlignment: DWORD;
    ulMaximumDriveCount: DWORD;
    ulStripeSize: DWORD;
    ulReserved1: DWORD;
    ulReserved2: DWORD;
    ulReserved3: DWORD;
    bFastCrashRecoveryRequired: BOOL;
    bMostlyReads: BOOL;
    bOptimizeForSequentialReads: BOOL;
    bOptimizeForSequentialWrites: BOOL;
    bRemapEnabled: BOOL;
    bReadBackVerifyEnabled: BOOL;
    bWriteThroughCachingEnabled: BOOL;
    bHardwareChecksumEnabled: BOOL;
    bIsYankable: BOOL;
    bAllocateHotSpare: BOOL;
    bUseMirroredCache: BOOL;
    bReadCachingEnabled: BOOL;
    bWriteCachingEnabled: BOOL;
    bMediaScanEnabled: BOOL;
    bConsistencyCheckEnabled: BOOL;
    BusType: Integer;
    bReserved1: BOOL;
    bReserved2: BOOL;
    bReserved3: BOOL;
    sRebuildPriority: Smallint;
  end;
const VDS_HINTS2 = extern struct {
    ullHintMask: u64,
    ullExpectedMaximumSize: u64,
    ulOptimalReadSize: u32,
    ulOptimalReadAlignment: u32,
    ulOptimalWriteSize: u32,
    ulOptimalWriteAlignment: u32,
    ulMaximumDriveCount: u32,
    ulStripeSize: u32,
    ulReserved1: u32,
    ulReserved2: u32,
    ulReserved3: u32,
    bFastCrashRecoveryRequired: i32,
    bMostlyReads: i32,
    bOptimizeForSequentialReads: i32,
    bOptimizeForSequentialWrites: i32,
    bRemapEnabled: i32,
    bReadBackVerifyEnabled: i32,
    bWriteThroughCachingEnabled: i32,
    bHardwareChecksumEnabled: i32,
    bIsYankable: i32,
    bAllocateHotSpare: i32,
    bUseMirroredCache: i32,
    bReadCachingEnabled: i32,
    bWriteCachingEnabled: i32,
    bMediaScanEnabled: i32,
    bConsistencyCheckEnabled: i32,
    BusType: i32,
    bReserved1: i32,
    bReserved2: i32,
    bReserved3: i32,
    sRebuildPriority: i16,
};
type
  VDS_HINTS2 {.bycopy.} = object
    ullHintMask: uint64
    ullExpectedMaximumSize: uint64
    ulOptimalReadSize: uint32
    ulOptimalReadAlignment: uint32
    ulOptimalWriteSize: uint32
    ulOptimalWriteAlignment: uint32
    ulMaximumDriveCount: uint32
    ulStripeSize: uint32
    ulReserved1: uint32
    ulReserved2: uint32
    ulReserved3: uint32
    bFastCrashRecoveryRequired: int32
    bMostlyReads: int32
    bOptimizeForSequentialReads: int32
    bOptimizeForSequentialWrites: int32
    bRemapEnabled: int32
    bReadBackVerifyEnabled: int32
    bWriteThroughCachingEnabled: int32
    bHardwareChecksumEnabled: int32
    bIsYankable: int32
    bAllocateHotSpare: int32
    bUseMirroredCache: int32
    bReadCachingEnabled: int32
    bWriteCachingEnabled: int32
    bMediaScanEnabled: int32
    bConsistencyCheckEnabled: int32
    BusType: int32
    bReserved1: int32
    bReserved2: int32
    bReserved3: int32
    sRebuildPriority: int16
struct VDS_HINTS2
{
    ulong ullHintMask;
    ulong ullExpectedMaximumSize;
    uint ulOptimalReadSize;
    uint ulOptimalReadAlignment;
    uint ulOptimalWriteSize;
    uint ulOptimalWriteAlignment;
    uint ulMaximumDriveCount;
    uint ulStripeSize;
    uint ulReserved1;
    uint ulReserved2;
    uint ulReserved3;
    int bFastCrashRecoveryRequired;
    int bMostlyReads;
    int bOptimizeForSequentialReads;
    int bOptimizeForSequentialWrites;
    int bRemapEnabled;
    int bReadBackVerifyEnabled;
    int bWriteThroughCachingEnabled;
    int bHardwareChecksumEnabled;
    int bIsYankable;
    int bAllocateHotSpare;
    int bUseMirroredCache;
    int bReadCachingEnabled;
    int bWriteCachingEnabled;
    int bMediaScanEnabled;
    int bConsistencyCheckEnabled;
    int BusType;
    int bReserved1;
    int bReserved2;
    int bReserved3;
    short sRebuildPriority;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; VDS_HINTS2 サイズ: 136 バイト(x64)
dim st, 34    ; 4byte整数×34(構造体サイズ 136 / 4 切り上げ)
; ullHintMask : ULONGLONG (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; ullExpectedMaximumSize : ULONGLONG (+8, 8byte)  qpoke st,8,値 / qpeek(st,8)  ※IronHSPのみ。3.7/3.8は lpoke st,8,下位 : lpoke st,12,上位
; ulOptimalReadSize : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; ulOptimalReadAlignment : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; ulOptimalWriteSize : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; ulOptimalWriteAlignment : DWORD (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; ulMaximumDriveCount : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; ulStripeSize : DWORD (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; ulReserved1 : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; ulReserved2 : DWORD (+44, 4byte)  st.11 = 値  /  値 = st.11   (lpoke/lpeek も可)
; ulReserved3 : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; bFastCrashRecoveryRequired : BOOL (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; bMostlyReads : BOOL (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; bOptimizeForSequentialReads : BOOL (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; bOptimizeForSequentialWrites : BOOL (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; bRemapEnabled : BOOL (+68, 4byte)  st.17 = 値  /  値 = st.17   (lpoke/lpeek も可)
; bReadBackVerifyEnabled : BOOL (+72, 4byte)  st.18 = 値  /  値 = st.18   (lpoke/lpeek も可)
; bWriteThroughCachingEnabled : BOOL (+76, 4byte)  st.19 = 値  /  値 = st.19   (lpoke/lpeek も可)
; bHardwareChecksumEnabled : BOOL (+80, 4byte)  st.20 = 値  /  値 = st.20   (lpoke/lpeek も可)
; bIsYankable : BOOL (+84, 4byte)  st.21 = 値  /  値 = st.21   (lpoke/lpeek も可)
; bAllocateHotSpare : BOOL (+88, 4byte)  st.22 = 値  /  値 = st.22   (lpoke/lpeek も可)
; bUseMirroredCache : BOOL (+92, 4byte)  st.23 = 値  /  値 = st.23   (lpoke/lpeek も可)
; bReadCachingEnabled : BOOL (+96, 4byte)  st.24 = 値  /  値 = st.24   (lpoke/lpeek も可)
; bWriteCachingEnabled : BOOL (+100, 4byte)  st.25 = 値  /  値 = st.25   (lpoke/lpeek も可)
; bMediaScanEnabled : BOOL (+104, 4byte)  st.26 = 値  /  値 = st.26   (lpoke/lpeek も可)
; bConsistencyCheckEnabled : BOOL (+108, 4byte)  st.27 = 値  /  値 = st.27   (lpoke/lpeek も可)
; BusType : VDS_STORAGE_BUS_TYPE (+112, 4byte)  st.28 = 値  /  値 = st.28   (lpoke/lpeek も可)
; bReserved1 : BOOL (+116, 4byte)  st.29 = 値  /  値 = st.29   (lpoke/lpeek も可)
; bReserved2 : BOOL (+120, 4byte)  st.30 = 値  /  値 = st.30   (lpoke/lpeek も可)
; bReserved3 : BOOL (+124, 4byte)  st.31 = 値  /  値 = st.31   (lpoke/lpeek も可)
; sRebuildPriority : SHORT (+128, 2byte)  wpoke st,128,値  /  値 = wpeek(st,128)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global VDS_HINTS2
    #field int64 ullHintMask
    #field int64 ullExpectedMaximumSize
    #field int ulOptimalReadSize
    #field int ulOptimalReadAlignment
    #field int ulOptimalWriteSize
    #field int ulOptimalWriteAlignment
    #field int ulMaximumDriveCount
    #field int ulStripeSize
    #field int ulReserved1
    #field int ulReserved2
    #field int ulReserved3
    #field bool bFastCrashRecoveryRequired
    #field bool bMostlyReads
    #field bool bOptimizeForSequentialReads
    #field bool bOptimizeForSequentialWrites
    #field bool bRemapEnabled
    #field bool bReadBackVerifyEnabled
    #field bool bWriteThroughCachingEnabled
    #field bool bHardwareChecksumEnabled
    #field bool bIsYankable
    #field bool bAllocateHotSpare
    #field bool bUseMirroredCache
    #field bool bReadCachingEnabled
    #field bool bWriteCachingEnabled
    #field bool bMediaScanEnabled
    #field bool bConsistencyCheckEnabled
    #field int BusType
    #field bool bReserved1
    #field bool bReserved2
    #field bool bReserved3
    #field short sRebuildPriority
#endstruct

stdim st, VDS_HINTS2        ; NSTRUCT 変数を確保
st->ullHintMask = 100
mes "ullHintMask=" + st->ullHintMask