You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3487 lines
122 KiB
3487 lines
122 KiB
/*++ BUILD Version: 0015 // Increment this if a change has global effects
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
winioctl.h
|
|
|
|
Abstract:
|
|
|
|
This module defines the 32-Bit Windows Device I/O control codes.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
//
|
|
// Device interface class GUIDs.
|
|
//
|
|
// need these GUIDs outside conditional includes so that user can
|
|
// #include <winioctl.h> in precompiled header
|
|
// #include <initguid.h> in a single source file
|
|
// #include <winioctl.h> in that source file a second time to instantiate the GUIDs
|
|
//
|
|
#ifdef DEFINE_GUID
|
|
//
|
|
// Make sure FAR is defined...
|
|
//
|
|
#ifndef FAR
|
|
#ifdef _WIN32
|
|
#define FAR
|
|
#else
|
|
#define FAR _far
|
|
#endif
|
|
#endif
|
|
|
|
DEFINE_GUID(GUID_DEVINTERFACE_DISK, 0x53f56307L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_CDROM, 0x53f56308L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_PARTITION, 0x53f5630aL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_TAPE, 0x53f5630bL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_WRITEONCEDISK, 0x53f5630cL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_VOLUME, 0x53f5630dL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_MEDIUMCHANGER, 0x53f56310L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_FLOPPY, 0x53f56311L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_CDCHANGER, 0x53f56312L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_STORAGEPORT, 0x2accfe60L, 0xc130, 0x11d2, 0xb0, 0x82, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_COMPORT, 0x86e0d1e0L, 0x8089, 0x11d0, 0x9c, 0xe4, 0x08, 0x00, 0x3e, 0x30, 0x1f, 0x73);
|
|
DEFINE_GUID(GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR, 0x4D36E978L, 0xE325, 0x11CE, 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18);
|
|
|
|
//
|
|
// Obsolete device interface class GUID names.
|
|
// (use of above GUID_DEVINTERFACE_* names is recommended).
|
|
//
|
|
#define DiskClassGuid GUID_DEVINTERFACE_DISK
|
|
#define CdRomClassGuid GUID_DEVINTERFACE_CDROM
|
|
#define PartitionClassGuid GUID_DEVINTERFACE_PARTITION
|
|
#define TapeClassGuid GUID_DEVINTERFACE_TAPE
|
|
#define WriteOnceDiskClassGuid GUID_DEVINTERFACE_WRITEONCEDISK
|
|
#define VolumeClassGuid GUID_DEVINTERFACE_VOLUME
|
|
#define MediumChangerClassGuid GUID_DEVINTERFACE_MEDIUMCHANGER
|
|
#define FloppyClassGuid GUID_DEVINTERFACE_FLOPPY
|
|
#define CdChangerClassGuid GUID_DEVINTERFACE_CDCHANGER
|
|
#define StoragePortClassGuid GUID_DEVINTERFACE_STORAGEPORT
|
|
#define GUID_CLASS_COMPORT GUID_DEVINTERFACE_COMPORT
|
|
#define GUID_SERENUM_BUS_ENUMERATOR GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR
|
|
|
|
#endif // DEFINE_GUID
|
|
|
|
#ifndef _WINIOCTL_
|
|
#define _WINIOCTL_
|
|
|
|
|
|
#ifndef _DEVIOCTL_
|
|
#define _DEVIOCTL_
|
|
|
|
// begin_ntddk begin_wdm begin_nthal begin_ntifs
|
|
//
|
|
// Define the various device type values. Note that values used by Microsoft
|
|
// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
|
|
// by customers.
|
|
//
|
|
|
|
#define DEVICE_TYPE DWORD
|
|
|
|
#define FILE_DEVICE_BEEP 0x00000001
|
|
#define FILE_DEVICE_CD_ROM 0x00000002
|
|
#define FILE_DEVICE_CD_ROM_FILE_SYSTEM 0x00000003
|
|
#define FILE_DEVICE_CONTROLLER 0x00000004
|
|
#define FILE_DEVICE_DATALINK 0x00000005
|
|
#define FILE_DEVICE_DFS 0x00000006
|
|
#define FILE_DEVICE_DISK 0x00000007
|
|
#define FILE_DEVICE_DISK_FILE_SYSTEM 0x00000008
|
|
#define FILE_DEVICE_FILE_SYSTEM 0x00000009
|
|
#define FILE_DEVICE_INPORT_PORT 0x0000000a
|
|
#define FILE_DEVICE_KEYBOARD 0x0000000b
|
|
#define FILE_DEVICE_MAILSLOT 0x0000000c
|
|
#define FILE_DEVICE_MIDI_IN 0x0000000d
|
|
#define FILE_DEVICE_MIDI_OUT 0x0000000e
|
|
#define FILE_DEVICE_MOUSE 0x0000000f
|
|
#define FILE_DEVICE_MULTI_UNC_PROVIDER 0x00000010
|
|
#define FILE_DEVICE_NAMED_PIPE 0x00000011
|
|
#define FILE_DEVICE_NETWORK 0x00000012
|
|
#define FILE_DEVICE_NETWORK_BROWSER 0x00000013
|
|
#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
|
|
#define FILE_DEVICE_NULL 0x00000015
|
|
#define FILE_DEVICE_PARALLEL_PORT 0x00000016
|
|
#define FILE_DEVICE_PHYSICAL_NETCARD 0x00000017
|
|
#define FILE_DEVICE_PRINTER 0x00000018
|
|
#define FILE_DEVICE_SCANNER 0x00000019
|
|
#define FILE_DEVICE_SERIAL_MOUSE_PORT 0x0000001a
|
|
#define FILE_DEVICE_SERIAL_PORT 0x0000001b
|
|
#define FILE_DEVICE_SCREEN 0x0000001c
|
|
#define FILE_DEVICE_SOUND 0x0000001d
|
|
#define FILE_DEVICE_STREAMS 0x0000001e
|
|
#define FILE_DEVICE_TAPE 0x0000001f
|
|
#define FILE_DEVICE_TAPE_FILE_SYSTEM 0x00000020
|
|
#define FILE_DEVICE_TRANSPORT 0x00000021
|
|
#define FILE_DEVICE_UNKNOWN 0x00000022
|
|
#define FILE_DEVICE_VIDEO 0x00000023
|
|
#define FILE_DEVICE_VIRTUAL_DISK 0x00000024
|
|
#define FILE_DEVICE_WAVE_IN 0x00000025
|
|
#define FILE_DEVICE_WAVE_OUT 0x00000026
|
|
#define FILE_DEVICE_8042_PORT 0x00000027
|
|
#define FILE_DEVICE_NETWORK_REDIRECTOR 0x00000028
|
|
#define FILE_DEVICE_BATTERY 0x00000029
|
|
#define FILE_DEVICE_BUS_EXTENDER 0x0000002a
|
|
#define FILE_DEVICE_MODEM 0x0000002b
|
|
#define FILE_DEVICE_VDM 0x0000002c
|
|
#define FILE_DEVICE_MASS_STORAGE 0x0000002d
|
|
#define FILE_DEVICE_SMB 0x0000002e
|
|
#define FILE_DEVICE_KS 0x0000002f
|
|
#define FILE_DEVICE_CHANGER 0x00000030
|
|
#define FILE_DEVICE_SMARTCARD 0x00000031
|
|
#define FILE_DEVICE_ACPI 0x00000032
|
|
#define FILE_DEVICE_DVD 0x00000033
|
|
#define FILE_DEVICE_FULLSCREEN_VIDEO 0x00000034
|
|
#define FILE_DEVICE_DFS_FILE_SYSTEM 0x00000035
|
|
#define FILE_DEVICE_DFS_VOLUME 0x00000036
|
|
#define FILE_DEVICE_SERENUM 0x00000037
|
|
#define FILE_DEVICE_TERMSRV 0x00000038
|
|
#define FILE_DEVICE_KSEC 0x00000039
|
|
#define FILE_DEVICE_FIPS 0x0000003A
|
|
#define FILE_DEVICE_INFINIBAND 0x0000003B
|
|
|
|
//
|
|
// Macro definition for defining IOCTL and FSCTL function control codes. Note
|
|
// that function codes 0-2047 are reserved for Microsoft Corporation, and
|
|
// 2048-4095 are reserved for customers.
|
|
//
|
|
|
|
#define CTL_CODE( DeviceType, Function, Method, Access ) ( \
|
|
((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
|
|
)
|
|
|
|
//
|
|
// Macro to extract device type out of the device io control code
|
|
//
|
|
#define DEVICE_TYPE_FROM_CTL_CODE(ctrlCode) (((DWORD)(ctrlCode & 0xffff0000)) >> 16)
|
|
|
|
//
|
|
// Define the method codes for how buffers are passed for I/O and FS controls
|
|
//
|
|
|
|
#define METHOD_BUFFERED 0
|
|
#define METHOD_IN_DIRECT 1
|
|
#define METHOD_OUT_DIRECT 2
|
|
#define METHOD_NEITHER 3
|
|
|
|
//
|
|
// Define some easier to comprehend aliases:
|
|
// METHOD_DIRECT_TO_HARDWARE (writes, aka METHOD_IN_DIRECT)
|
|
// METHOD_DIRECT_FROM_HARDWARE (reads, aka METHOD_OUT_DIRECT)
|
|
//
|
|
|
|
#define METHOD_DIRECT_TO_HARDWARE METHOD_IN_DIRECT
|
|
#define METHOD_DIRECT_FROM_HARDWARE METHOD_OUT_DIRECT
|
|
|
|
//
|
|
// Define the access check value for any access
|
|
//
|
|
//
|
|
// The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
|
|
// ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
|
|
// constants *MUST* always be in sync.
|
|
//
|
|
//
|
|
// FILE_SPECIAL_ACCESS is checked by the NT I/O system the same as FILE_ANY_ACCESS.
|
|
// The file systems, however, may add additional access checks for I/O and FS controls
|
|
// that use this value.
|
|
//
|
|
|
|
|
|
#define FILE_ANY_ACCESS 0
|
|
#define FILE_SPECIAL_ACCESS (FILE_ANY_ACCESS)
|
|
#define FILE_READ_ACCESS ( 0x0001 ) // file & pipe
|
|
#define FILE_WRITE_ACCESS ( 0x0002 ) // file & pipe
|
|
|
|
// end_ntddk end_wdm end_nthal end_ntifs
|
|
|
|
#endif // _DEVIOCTL_
|
|
|
|
|
|
#ifndef _NTDDSTOR_H_
|
|
#define _NTDDSTOR_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
//
|
|
// IoControlCode values for storage devices
|
|
//
|
|
|
|
#define IOCTL_STORAGE_BASE FILE_DEVICE_MASS_STORAGE
|
|
|
|
//
|
|
// The following device control codes are common for all class drivers. They
|
|
// should be used in place of the older IOCTL_DISK, IOCTL_CDROM and IOCTL_TAPE
|
|
// common codes
|
|
//
|
|
|
|
#define IOCTL_STORAGE_CHECK_VERIFY CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_CHECK_VERIFY2 CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_MEDIA_REMOVAL CTL_CODE(IOCTL_STORAGE_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_EJECT_MEDIA CTL_CODE(IOCTL_STORAGE_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_LOAD_MEDIA CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_LOAD_MEDIA2 CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_RESERVE CTL_CODE(IOCTL_STORAGE_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_RELEASE CTL_CODE(IOCTL_STORAGE_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_FIND_NEW_DEVICES CTL_CODE(IOCTL_STORAGE_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
|
|
#define IOCTL_STORAGE_EJECTION_CONTROL CTL_CODE(IOCTL_STORAGE_BASE, 0x0250, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_MCN_CONTROL CTL_CODE(IOCTL_STORAGE_BASE, 0x0251, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
#define IOCTL_STORAGE_GET_MEDIA_TYPES CTL_CODE(IOCTL_STORAGE_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_GET_MEDIA_TYPES_EX CTL_CODE(IOCTL_STORAGE_BASE, 0x0301, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER CTL_CODE(IOCTL_STORAGE_BASE, 0x0304, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_GET_HOTPLUG_INFO CTL_CODE(IOCTL_STORAGE_BASE, 0x0305, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_SET_HOTPLUG_INFO CTL_CODE(IOCTL_STORAGE_BASE, 0x0306, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
#define IOCTL_STORAGE_RESET_BUS CTL_CODE(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_RESET_DEVICE CTL_CODE(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_STORAGE_BREAK_RESERVATION CTL_CODE(IOCTL_STORAGE_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
|
|
#define IOCTL_STORAGE_GET_DEVICE_NUMBER CTL_CODE(IOCTL_STORAGE_BASE, 0x0420, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_STORAGE_PREDICT_FAILURE CTL_CODE(IOCTL_STORAGE_BASE, 0x0440, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
|
|
//
|
|
// These ioctl codes are obsolete. They are defined here to avoid resuing them
|
|
// and to allow class drivers to respond to them more easily.
|
|
//
|
|
|
|
#define OBSOLETE_IOCTL_STORAGE_RESET_BUS CTL_CODE(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define OBSOLETE_IOCTL_STORAGE_RESET_DEVICE CTL_CODE(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
|
|
//
|
|
// IOCTL_STORAGE_GET_HOTPLUG_INFO
|
|
//
|
|
|
|
typedef struct _STORAGE_HOTPLUG_INFO {
|
|
DWORD Size; // version
|
|
BOOLEAN MediaRemovable; // ie. zip, jaz, cdrom, mo, etc. vs hdd
|
|
BOOLEAN MediaHotplug; // ie. does the device succeed a lock even though its not lockable media?
|
|
BOOLEAN DeviceHotplug; // ie. 1394, USB, etc.
|
|
BOOLEAN WriteCacheEnableOverride; // This field should not be relied upon because it is no longer used
|
|
} STORAGE_HOTPLUG_INFO, *PSTORAGE_HOTPLUG_INFO;
|
|
|
|
//
|
|
// IOCTL_STORAGE_GET_DEVICE_NUMBER
|
|
//
|
|
// input - none
|
|
//
|
|
// output - STORAGE_DEVICE_NUMBER structure
|
|
// The values in the STORAGE_DEVICE_NUMBER structure are guaranteed
|
|
// to remain unchanged until the system is rebooted. They are not
|
|
// guaranteed to be persistant across boots.
|
|
//
|
|
|
|
typedef struct _STORAGE_DEVICE_NUMBER {
|
|
|
|
//
|
|
// The FILE_DEVICE_XXX type for this device.
|
|
//
|
|
|
|
DEVICE_TYPE DeviceType;
|
|
|
|
//
|
|
// The number of this device
|
|
//
|
|
|
|
DWORD DeviceNumber;
|
|
|
|
//
|
|
// If the device is partitionable, the partition number of the device.
|
|
// Otherwise -1
|
|
//
|
|
|
|
DWORD PartitionNumber;
|
|
} STORAGE_DEVICE_NUMBER, *PSTORAGE_DEVICE_NUMBER;
|
|
|
|
//
|
|
// Define the structures for scsi resets
|
|
//
|
|
|
|
typedef struct _STORAGE_BUS_RESET_REQUEST {
|
|
BYTE PathId;
|
|
} STORAGE_BUS_RESET_REQUEST, *PSTORAGE_BUS_RESET_REQUEST;
|
|
|
|
//
|
|
// Break reservation is sent to the Adapter/FDO with the given lun information.
|
|
//
|
|
|
|
typedef struct STORAGE_BREAK_RESERVATION_REQUEST {
|
|
DWORD Length;
|
|
BYTE _unused;
|
|
BYTE PathId;
|
|
BYTE TargetId;
|
|
BYTE Lun;
|
|
} STORAGE_BREAK_RESERVATION_REQUEST, *PSTORAGE_BREAK_RESERVATION_REQUEST;
|
|
|
|
|
|
//
|
|
// IOCTL_STORAGE_MEDIA_REMOVAL disables the mechanism
|
|
// on a storage device that ejects media. This function
|
|
// may or may not be supported on storage devices that
|
|
// support removable media.
|
|
//
|
|
// TRUE means prevent media from being removed.
|
|
// FALSE means allow media removal.
|
|
//
|
|
|
|
typedef struct _PREVENT_MEDIA_REMOVAL {
|
|
BOOLEAN PreventMediaRemoval;
|
|
} PREVENT_MEDIA_REMOVAL, *PPREVENT_MEDIA_REMOVAL;
|
|
|
|
|
|
|
|
//
|
|
// This is the format of TARGET_DEVICE_CUSTOM_NOTIFICATION.CustomDataBuffer
|
|
// passed to applications by the classpnp autorun code (via IoReportTargetDeviceChangeAsynchronous).
|
|
//
|
|
typedef struct _CLASS_MEDIA_CHANGE_CONTEXT {
|
|
DWORD MediaChangeCount;
|
|
DWORD NewState; // see MEDIA_CHANGE_DETECTION_STATE enum in classpnp.h in DDK
|
|
} CLASS_MEDIA_CHANGE_CONTEXT, *PCLASS_MEDIA_CHANGE_CONTEXT;
|
|
|
|
|
|
// begin_ntminitape
|
|
|
|
|
|
typedef struct _TAPE_STATISTICS {
|
|
DWORD Version;
|
|
DWORD Flags;
|
|
LARGE_INTEGER RecoveredWrites;
|
|
LARGE_INTEGER UnrecoveredWrites;
|
|
LARGE_INTEGER RecoveredReads;
|
|
LARGE_INTEGER UnrecoveredReads;
|
|
BYTE CompressionRatioReads;
|
|
BYTE CompressionRatioWrites;
|
|
} TAPE_STATISTICS, *PTAPE_STATISTICS;
|
|
|
|
#define RECOVERED_WRITES_VALID 0x00000001
|
|
#define UNRECOVERED_WRITES_VALID 0x00000002
|
|
#define RECOVERED_READS_VALID 0x00000004
|
|
#define UNRECOVERED_READS_VALID 0x00000008
|
|
#define WRITE_COMPRESSION_INFO_VALID 0x00000010
|
|
#define READ_COMPRESSION_INFO_VALID 0x00000020
|
|
|
|
typedef struct _TAPE_GET_STATISTICS {
|
|
DWORD Operation;
|
|
} TAPE_GET_STATISTICS, *PTAPE_GET_STATISTICS;
|
|
|
|
#define TAPE_RETURN_STATISTICS 0L
|
|
#define TAPE_RETURN_ENV_INFO 1L
|
|
#define TAPE_RESET_STATISTICS 2L
|
|
|
|
//
|
|
// IOCTL_STORAGE_GET_MEDIA_TYPES_EX will return an array of DEVICE_MEDIA_INFO
|
|
// structures, one per supported type, embedded in the GET_MEDIA_TYPES struct.
|
|
//
|
|
|
|
typedef enum _STORAGE_MEDIA_TYPE {
|
|
//
|
|
// Following are defined in ntdddisk.h in the MEDIA_TYPE enum
|
|
//
|
|
// Unknown, // Format is unknown
|
|
// F5_1Pt2_512, // 5.25", 1.2MB, 512 bytes/sector
|
|
// F3_1Pt44_512, // 3.5", 1.44MB, 512 bytes/sector
|
|
// F3_2Pt88_512, // 3.5", 2.88MB, 512 bytes/sector
|
|
// F3_20Pt8_512, // 3.5", 20.8MB, 512 bytes/sector
|
|
// F3_720_512, // 3.5", 720KB, 512 bytes/sector
|
|
// F5_360_512, // 5.25", 360KB, 512 bytes/sector
|
|
// F5_320_512, // 5.25", 320KB, 512 bytes/sector
|
|
// F5_320_1024, // 5.25", 320KB, 1024 bytes/sector
|
|
// F5_180_512, // 5.25", 180KB, 512 bytes/sector
|
|
// F5_160_512, // 5.25", 160KB, 512 bytes/sector
|
|
// RemovableMedia, // Removable media other than floppy
|
|
// FixedMedia, // Fixed hard disk media
|
|
// F3_120M_512, // 3.5", 120M Floppy
|
|
// F3_640_512, // 3.5" , 640KB, 512 bytes/sector
|
|
// F5_640_512, // 5.25", 640KB, 512 bytes/sector
|
|
// F5_720_512, // 5.25", 720KB, 512 bytes/sector
|
|
// F3_1Pt2_512, // 3.5" , 1.2Mb, 512 bytes/sector
|
|
// F3_1Pt23_1024, // 3.5" , 1.23Mb, 1024 bytes/sector
|
|
// F5_1Pt23_1024, // 5.25", 1.23MB, 1024 bytes/sector
|
|
// F3_128Mb_512, // 3.5" MO 128Mb 512 bytes/sector
|
|
// F3_230Mb_512, // 3.5" MO 230Mb 512 bytes/sector
|
|
// F8_256_128, // 8", 256KB, 128 bytes/sector
|
|
// F3_200Mb_512, // 3.5", 200M Floppy (HiFD)
|
|
//
|
|
|
|
DDS_4mm = 0x20, // Tape - DAT DDS1,2,... (all vendors)
|
|
MiniQic, // Tape - miniQIC Tape
|
|
Travan, // Tape - Travan TR-1,2,3,...
|
|
QIC, // Tape - QIC
|
|
MP_8mm, // Tape - 8mm Exabyte Metal Particle
|
|
AME_8mm, // Tape - 8mm Exabyte Advanced Metal Evap
|
|
AIT1_8mm, // Tape - 8mm Sony AIT
|
|
DLT, // Tape - DLT Compact IIIxt, IV
|
|
NCTP, // Tape - Philips NCTP
|
|
IBM_3480, // Tape - IBM 3480
|
|
IBM_3490E, // Tape - IBM 3490E
|
|
IBM_Magstar_3590, // Tape - IBM Magstar 3590
|
|
IBM_Magstar_MP, // Tape - IBM Magstar MP
|
|
STK_DATA_D3, // Tape - STK Data D3
|
|
SONY_DTF, // Tape - Sony DTF
|
|
DV_6mm, // Tape - 6mm Digital Video
|
|
DMI, // Tape - Exabyte DMI and compatibles
|
|
SONY_D2, // Tape - Sony D2S and D2L
|
|
CLEANER_CARTRIDGE, // Cleaner - All Drive types that support Drive Cleaners
|
|
CD_ROM, // Opt_Disk - CD
|
|
CD_R, // Opt_Disk - CD-Recordable (Write Once)
|
|
CD_RW, // Opt_Disk - CD-Rewriteable
|
|
DVD_ROM, // Opt_Disk - DVD-ROM
|
|
DVD_R, // Opt_Disk - DVD-Recordable (Write Once)
|
|
DVD_RW, // Opt_Disk - DVD-Rewriteable
|
|
MO_3_RW, // Opt_Disk - 3.5" Rewriteable MO Disk
|
|
MO_5_WO, // Opt_Disk - MO 5.25" Write Once
|
|
MO_5_RW, // Opt_Disk - MO 5.25" Rewriteable (not LIMDOW)
|
|
MO_5_LIMDOW, // Opt_Disk - MO 5.25" Rewriteable (LIMDOW)
|
|
PC_5_WO, // Opt_Disk - Phase Change 5.25" Write Once Optical
|
|
PC_5_RW, // Opt_Disk - Phase Change 5.25" Rewriteable
|
|
PD_5_RW, // Opt_Disk - PhaseChange Dual Rewriteable
|
|
ABL_5_WO, // Opt_Disk - Ablative 5.25" Write Once Optical
|
|
PINNACLE_APEX_5_RW, // Opt_Disk - Pinnacle Apex 4.6GB Rewriteable Optical
|
|
SONY_12_WO, // Opt_Disk - Sony 12" Write Once
|
|
PHILIPS_12_WO, // Opt_Disk - Philips/LMS 12" Write Once
|
|
HITACHI_12_WO, // Opt_Disk - Hitachi 12" Write Once
|
|
CYGNET_12_WO, // Opt_Disk - Cygnet/ATG 12" Write Once
|
|
KODAK_14_WO, // Opt_Disk - Kodak 14" Write Once
|
|
MO_NFR_525, // Opt_Disk - Near Field Recording (Terastor)
|
|
NIKON_12_RW, // Opt_Disk - Nikon 12" Rewriteable
|
|
IOMEGA_ZIP, // Mag_Disk - Iomega Zip
|
|
IOMEGA_JAZ, // Mag_Disk - Iomega Jaz
|
|
SYQUEST_EZ135, // Mag_Disk - Syquest EZ135
|
|
SYQUEST_EZFLYER, // Mag_Disk - Syquest EzFlyer
|
|
SYQUEST_SYJET, // Mag_Disk - Syquest SyJet
|
|
AVATAR_F2, // Mag_Disk - 2.5" Floppy
|
|
MP2_8mm, // Tape - 8mm Hitachi
|
|
DST_S, // Ampex DST Small Tapes
|
|
DST_M, // Ampex DST Medium Tapes
|
|
DST_L, // Ampex DST Large Tapes
|
|
VXATape_1, // Ecrix 8mm Tape
|
|
VXATape_2, // Ecrix 8mm Tape
|
|
STK_9840, // STK 9840
|
|
LTO_Ultrium, // IBM, HP, Seagate LTO Ultrium
|
|
LTO_Accelis, // IBM, HP, Seagate LTO Accelis
|
|
DVD_RAM, // Opt_Disk - DVD-RAM
|
|
AIT_8mm, // AIT2 or higher
|
|
ADR_1, // OnStream ADR Mediatypes
|
|
ADR_2,
|
|
STK_9940 // STK 9940
|
|
} STORAGE_MEDIA_TYPE, *PSTORAGE_MEDIA_TYPE;
|
|
|
|
#define MEDIA_ERASEABLE 0x00000001
|
|
#define MEDIA_WRITE_ONCE 0x00000002
|
|
#define MEDIA_READ_ONLY 0x00000004
|
|
#define MEDIA_READ_WRITE 0x00000008
|
|
|
|
#define MEDIA_WRITE_PROTECTED 0x00000100
|
|
#define MEDIA_CURRENTLY_MOUNTED 0x80000000
|
|
|
|
//
|
|
// Define the different storage bus types
|
|
// Bus types below 128 (0x80) are reserved for Microsoft use
|
|
//
|
|
|
|
typedef enum _STORAGE_BUS_TYPE {
|
|
BusTypeUnknown = 0x00,
|
|
BusTypeScsi,
|
|
BusTypeAtapi,
|
|
BusTypeAta,
|
|
BusType1394,
|
|
BusTypeSsa,
|
|
BusTypeFibre,
|
|
BusTypeUsb,
|
|
BusTypeRAID,
|
|
BusTypeMaxReserved = 0x7F
|
|
} STORAGE_BUS_TYPE, *PSTORAGE_BUS_TYPE;
|
|
|
|
typedef struct _DEVICE_MEDIA_INFO {
|
|
union {
|
|
struct {
|
|
LARGE_INTEGER Cylinders;
|
|
STORAGE_MEDIA_TYPE MediaType;
|
|
DWORD TracksPerCylinder;
|
|
DWORD SectorsPerTrack;
|
|
DWORD BytesPerSector;
|
|
DWORD NumberMediaSides;
|
|
DWORD MediaCharacteristics; // Bitmask of MEDIA_XXX values.
|
|
} DiskInfo;
|
|
|
|
struct {
|
|
LARGE_INTEGER Cylinders;
|
|
STORAGE_MEDIA_TYPE MediaType;
|
|
DWORD TracksPerCylinder;
|
|
DWORD SectorsPerTrack;
|
|
DWORD BytesPerSector;
|
|
DWORD NumberMediaSides;
|
|
DWORD MediaCharacteristics; // Bitmask of MEDIA_XXX values.
|
|
} RemovableDiskInfo;
|
|
|
|
struct {
|
|
STORAGE_MEDIA_TYPE MediaType;
|
|
DWORD MediaCharacteristics; // Bitmask of MEDIA_XXX values.
|
|
DWORD CurrentBlockSize;
|
|
STORAGE_BUS_TYPE BusType;
|
|
|
|
//
|
|
// Bus specific information describing the medium supported.
|
|
//
|
|
|
|
union {
|
|
struct {
|
|
BYTE MediumType;
|
|
BYTE DensityCode;
|
|
} ScsiInformation;
|
|
} BusSpecificData;
|
|
|
|
} TapeInfo;
|
|
} DeviceSpecific;
|
|
} DEVICE_MEDIA_INFO, *PDEVICE_MEDIA_INFO;
|
|
|
|
typedef struct _GET_MEDIA_TYPES {
|
|
DWORD DeviceType; // FILE_DEVICE_XXX values
|
|
DWORD MediaInfoCount;
|
|
DEVICE_MEDIA_INFO MediaInfo[1];
|
|
} GET_MEDIA_TYPES, *PGET_MEDIA_TYPES;
|
|
|
|
|
|
//
|
|
// IOCTL_STORAGE_PREDICT_FAILURE
|
|
//
|
|
// input - none
|
|
//
|
|
// output - STORAGE_PREDICT_FAILURE structure
|
|
// PredictFailure returns zero if no failure predicted and non zero
|
|
// if a failure is predicted.
|
|
//
|
|
// VendorSpecific returns 512 bytes of vendor specific information
|
|
// if a failure is predicted
|
|
//
|
|
typedef struct _STORAGE_PREDICT_FAILURE
|
|
{
|
|
DWORD PredictFailure;
|
|
BYTE VendorSpecific[512];
|
|
} STORAGE_PREDICT_FAILURE, *PSTORAGE_PREDICT_FAILURE;
|
|
|
|
// end_ntminitape
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // _NTDDSTOR_H_
|
|
|
|
//
|
|
// IoControlCode values for disk devices.
|
|
//
|
|
|
|
#define IOCTL_DISK_BASE FILE_DEVICE_DISK
|
|
#define IOCTL_DISK_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_DISK_BASE, 0x0000, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_GET_PARTITION_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_SET_PARTITION_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_GET_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_SET_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_FORMAT_TRACKS CTL_CODE(IOCTL_DISK_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_REASSIGN_BLOCKS CTL_CODE(IOCTL_DISK_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_PERFORMANCE CTL_CODE(IOCTL_DISK_BASE, 0x0008, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_IS_WRITABLE CTL_CODE(IOCTL_DISK_BASE, 0x0009, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_LOGGING CTL_CODE(IOCTL_DISK_BASE, 0x000a, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_FORMAT_TRACKS_EX CTL_CODE(IOCTL_DISK_BASE, 0x000b, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_HISTOGRAM_STRUCTURE CTL_CODE(IOCTL_DISK_BASE, 0x000c, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_HISTOGRAM_DATA CTL_CODE(IOCTL_DISK_BASE, 0x000d, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_HISTOGRAM_RESET CTL_CODE(IOCTL_DISK_BASE, 0x000e, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_REQUEST_STRUCTURE CTL_CODE(IOCTL_DISK_BASE, 0x000f, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_REQUEST_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0010, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_PERFORMANCE_OFF CTL_CODE(IOCTL_DISK_BASE, 0x0018, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
#define IOCTL_DISK_CONTROLLER_NUMBER CTL_CODE(IOCTL_DISK_BASE, 0x0011, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// IOCTL support for SMART drive fault prediction.
|
|
//
|
|
|
|
#define SMART_GET_VERSION CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define SMART_SEND_DRIVE_COMMAND CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define SMART_RCV_DRIVE_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if (_WIN32_WINNT >= 0x500)
|
|
|
|
//
|
|
// New IOCTLs for GUID Partition tabled disks.
|
|
//
|
|
|
|
#define IOCTL_DISK_GET_PARTITION_INFO_EX CTL_CODE(IOCTL_DISK_BASE, 0x0012, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_SET_PARTITION_INFO_EX CTL_CODE(IOCTL_DISK_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_GET_DRIVE_LAYOUT_EX CTL_CODE(IOCTL_DISK_BASE, 0x0014, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_DISK_SET_DRIVE_LAYOUT_EX CTL_CODE(IOCTL_DISK_BASE, 0x0015, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_CREATE_DISK CTL_CODE(IOCTL_DISK_BASE, 0x0016, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_GET_LENGTH_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0017, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
#define IOCTL_DISK_UPDATE_DRIVE_SIZE CTL_CODE(IOCTL_DISK_BASE, 0x0032, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_GROW_PARTITION CTL_CODE(IOCTL_DISK_BASE, 0x0034, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
#define IOCTL_DISK_GET_CACHE_INFORMATION CTL_CODE(IOCTL_DISK_BASE, 0x0035, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_SET_CACHE_INFORMATION CTL_CODE(IOCTL_DISK_BASE, 0x0036, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define OBSOLETE_DISK_GET_WRITE_CACHE_STATE CTL_CODE(IOCTL_DISK_BASE, 0x0037, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
|
|
#define IOCTL_DISK_DELETE_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0040, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
//
|
|
// Called to flush cached information that the driver may have about this
|
|
// device's characteristics. Not all drivers cache characteristics, and not
|
|
// cached properties can be flushed. This simply serves as an update to the
|
|
// driver that it may want to do an expensive reexamination of the device's
|
|
// characteristics now (fixed media size, partition table, etc...)
|
|
//
|
|
|
|
#define IOCTL_DISK_UPDATE_PROPERTIES CTL_CODE(IOCTL_DISK_BASE, 0x0050, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// Special IOCTLs needed to support PC-98 machines in Japan
|
|
//
|
|
|
|
#define IOCTL_DISK_FORMAT_DRIVE CTL_CODE(IOCTL_DISK_BASE, 0x00f3, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_DISK_SENSE_DEVICE CTL_CODE(IOCTL_DISK_BASE, 0x00f8, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
//
|
|
// The following device control codes are common for all class drivers. The
|
|
// functions codes defined here must match all of the other class drivers.
|
|
//
|
|
// Warning: these codes will be replaced in the future by equivalent
|
|
// IOCTL_STORAGE codes
|
|
//
|
|
|
|
#define IOCTL_DISK_CHECK_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_MEDIA_REMOVAL CTL_CODE(IOCTL_DISK_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_EJECT_MEDIA CTL_CODE(IOCTL_DISK_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_LOAD_MEDIA CTL_CODE(IOCTL_DISK_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_RESERVE CTL_CODE(IOCTL_DISK_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_RELEASE CTL_CODE(IOCTL_DISK_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_FIND_NEW_DEVICES CTL_CODE(IOCTL_DISK_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_DISK_GET_MEDIA_TYPES CTL_CODE(IOCTL_DISK_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// Define the partition types returnable by known disk drivers.
|
|
//
|
|
|
|
#define PARTITION_ENTRY_UNUSED 0x00 // Entry unused
|
|
#define PARTITION_FAT_12 0x01 // 12-bit FAT entries
|
|
#define PARTITION_XENIX_1 0x02 // Xenix
|
|
#define PARTITION_XENIX_2 0x03 // Xenix
|
|
#define PARTITION_FAT_16 0x04 // 16-bit FAT entries
|
|
#define PARTITION_EXTENDED 0x05 // Extended partition entry
|
|
#define PARTITION_HUGE 0x06 // Huge partition MS-DOS V4
|
|
#define PARTITION_IFS 0x07 // IFS Partition
|
|
#define PARTITION_OS2BOOTMGR 0x0A // OS/2 Boot Manager/OPUS/Coherent swap
|
|
#define PARTITION_FAT32 0x0B // FAT32
|
|
#define PARTITION_FAT32_XINT13 0x0C // FAT32 using extended int13 services
|
|
#define PARTITION_XINT13 0x0E // Win95 partition using extended int13 services
|
|
#define PARTITION_XINT13_EXTENDED 0x0F // Same as type 5 but uses extended int13 services
|
|
#define PARTITION_PREP 0x41 // PowerPC Reference Platform (PReP) Boot Partition
|
|
#define PARTITION_LDM 0x42 // Logical Disk Manager partition
|
|
#define PARTITION_UNIX 0x63 // Unix
|
|
|
|
#define VALID_NTFT 0xC0 // NTFT uses high order bits
|
|
|
|
//
|
|
// The high bit of the partition type code indicates that a partition
|
|
// is part of an NTFT mirror or striped array.
|
|
//
|
|
|
|
#define PARTITION_NTFT 0x80 // NTFT partition
|
|
|
|
//
|
|
// The following macro is used to determine which partitions should be
|
|
// assigned drive letters.
|
|
//
|
|
|
|
//++
|
|
//
|
|
// BOOLEAN
|
|
// IsRecognizedPartition(
|
|
// IN DWORD PartitionType
|
|
// )
|
|
//
|
|
// Routine Description:
|
|
//
|
|
// This macro is used to determine to which partitions drive letters
|
|
// should be assigned.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// PartitionType - Supplies the type of the partition being examined.
|
|
//
|
|
// Return Value:
|
|
//
|
|
// The return value is TRUE if the partition type is recognized,
|
|
// otherwise FALSE is returned.
|
|
//
|
|
//--
|
|
|
|
#define IsRecognizedPartition( PartitionType ) ( \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT_12)) || \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_IFS)) || \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_HUGE)) || \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32)) || \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32_XINT13)) || \
|
|
((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_XINT13)) || \
|
|
((PartitionType) == PARTITION_FAT_12) || \
|
|
((PartitionType) == PARTITION_FAT_16) || \
|
|
((PartitionType) == PARTITION_IFS) || \
|
|
((PartitionType) == PARTITION_HUGE) || \
|
|
((PartitionType) == PARTITION_FAT32) || \
|
|
((PartitionType) == PARTITION_FAT32_XINT13) || \
|
|
((PartitionType) == PARTITION_XINT13) )
|
|
|
|
//++
|
|
//
|
|
// BOOLEAN
|
|
// IsContainerPartition(
|
|
// IN DWORD PartitionType
|
|
// )
|
|
//
|
|
// Routine Description:
|
|
//
|
|
// This macro is used to determine to which partition types are actually
|
|
// containers for other partitions (ie, extended partitions).
|
|
//
|
|
// Arguments:
|
|
//
|
|
// PartitionType - Supplies the type of the partition being examined.
|
|
//
|
|
// Return Value:
|
|
//
|
|
// The return value is TRUE if the partition type is a container,
|
|
// otherwise FALSE is returned.
|
|
//
|
|
//--
|
|
|
|
#define IsContainerPartition( PartitionType ) \
|
|
((PartitionType == PARTITION_EXTENDED) || (PartitionType == PARTITION_XINT13_EXTENDED))
|
|
|
|
//++
|
|
//
|
|
// BOOLEAN
|
|
// IsFTPartition(
|
|
// IN DWORD PartitionType
|
|
// )
|
|
//
|
|
// Routine Description:
|
|
//
|
|
// This macro is used to determine if the given partition is an FT
|
|
// partition.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// PartitionType - Supplies the type of the partition being examined.
|
|
//
|
|
// Return Value:
|
|
//
|
|
// The return value is TRUE if the partition type is an FT partition,
|
|
// otherwise FALSE is returned.
|
|
//
|
|
//--
|
|
|
|
#define IsFTPartition( PartitionType ) \
|
|
(((PartitionType)&PARTITION_NTFT) && IsRecognizedPartition(PartitionType))
|
|
|
|
//
|
|
// Define the media types supported by the driver.
|
|
//
|
|
|
|
typedef enum _MEDIA_TYPE {
|
|
Unknown, // Format is unknown
|
|
F5_1Pt2_512, // 5.25", 1.2MB, 512 bytes/sector
|
|
F3_1Pt44_512, // 3.5", 1.44MB, 512 bytes/sector
|
|
F3_2Pt88_512, // 3.5", 2.88MB, 512 bytes/sector
|
|
F3_20Pt8_512, // 3.5", 20.8MB, 512 bytes/sector
|
|
F3_720_512, // 3.5", 720KB, 512 bytes/sector
|
|
F5_360_512, // 5.25", 360KB, 512 bytes/sector
|
|
F5_320_512, // 5.25", 320KB, 512 bytes/sector
|
|
F5_320_1024, // 5.25", 320KB, 1024 bytes/sector
|
|
F5_180_512, // 5.25", 180KB, 512 bytes/sector
|
|
F5_160_512, // 5.25", 160KB, 512 bytes/sector
|
|
RemovableMedia, // Removable media other than floppy
|
|
FixedMedia, // Fixed hard disk media
|
|
F3_120M_512, // 3.5", 120M Floppy
|
|
F3_640_512, // 3.5" , 640KB, 512 bytes/sector
|
|
F5_640_512, // 5.25", 640KB, 512 bytes/sector
|
|
F5_720_512, // 5.25", 720KB, 512 bytes/sector
|
|
F3_1Pt2_512, // 3.5" , 1.2Mb, 512 bytes/sector
|
|
F3_1Pt23_1024, // 3.5" , 1.23Mb, 1024 bytes/sector
|
|
F5_1Pt23_1024, // 5.25", 1.23MB, 1024 bytes/sector
|
|
F3_128Mb_512, // 3.5" MO 128Mb 512 bytes/sector
|
|
F3_230Mb_512, // 3.5" MO 230Mb 512 bytes/sector
|
|
F8_256_128, // 8", 256KB, 128 bytes/sector
|
|
F3_200Mb_512, // 3.5", 200M Floppy (HiFD)
|
|
F3_240M_512, // 3.5", 240Mb Floppy (HiFD)
|
|
F3_32M_512 // 3.5", 32Mb Floppy
|
|
} MEDIA_TYPE, *PMEDIA_TYPE;
|
|
|
|
//
|
|
// Define the input buffer structure for the driver, when
|
|
// it is called with IOCTL_DISK_FORMAT_TRACKS.
|
|
//
|
|
|
|
typedef struct _FORMAT_PARAMETERS {
|
|
MEDIA_TYPE MediaType;
|
|
DWORD StartCylinderNumber;
|
|
DWORD EndCylinderNumber;
|
|
DWORD StartHeadNumber;
|
|
DWORD EndHeadNumber;
|
|
} FORMAT_PARAMETERS, *PFORMAT_PARAMETERS;
|
|
|
|
//
|
|
// Define the BAD_TRACK_NUMBER type. An array of elements of this type is
|
|
// returned by the driver on IOCTL_DISK_FORMAT_TRACKS requests, to indicate
|
|
// what tracks were bad during formatting. The length of that array is
|
|
// reported in the `Information' field of the I/O Status Block.
|
|
//
|
|
|
|
typedef WORD BAD_TRACK_NUMBER;
|
|
typedef WORD *PBAD_TRACK_NUMBER;
|
|
|
|
//
|
|
// Define the input buffer structure for the driver, when
|
|
// it is called with IOCTL_DISK_FORMAT_TRACKS_EX.
|
|
//
|
|
|
|
typedef struct _FORMAT_EX_PARAMETERS {
|
|
MEDIA_TYPE MediaType;
|
|
DWORD StartCylinderNumber;
|
|
DWORD EndCylinderNumber;
|
|
DWORD StartHeadNumber;
|
|
DWORD EndHeadNumber;
|
|
WORD FormatGapLength;
|
|
WORD SectorsPerTrack;
|
|
WORD SectorNumber[1];
|
|
} FORMAT_EX_PARAMETERS, *PFORMAT_EX_PARAMETERS;
|
|
|
|
//
|
|
// The following structure is returned on an IOCTL_DISK_GET_DRIVE_GEOMETRY
|
|
// request and an array of them is returned on an IOCTL_DISK_GET_MEDIA_TYPES
|
|
// request.
|
|
//
|
|
|
|
typedef struct _DISK_GEOMETRY {
|
|
LARGE_INTEGER Cylinders;
|
|
MEDIA_TYPE MediaType;
|
|
DWORD TracksPerCylinder;
|
|
DWORD SectorsPerTrack;
|
|
DWORD BytesPerSector;
|
|
} DISK_GEOMETRY, *PDISK_GEOMETRY;
|
|
|
|
|
|
|
|
//
|
|
// This wmi guid returns a DISK_GEOMETRY structure
|
|
//
|
|
#define WMI_DISK_GEOMETRY_GUID { 0x25007f51, 0x57c2, 0x11d1, { 0xa5, 0x28, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0x10 } }
|
|
|
|
|
|
|
|
//
|
|
// The following structure is returned on an IOCTL_DISK_GET_PARTITION_INFO
|
|
// and an IOCTL_DISK_GET_DRIVE_LAYOUT request. It is also used in a request
|
|
// to change the drive layout, IOCTL_DISK_SET_DRIVE_LAYOUT.
|
|
//
|
|
|
|
typedef struct _PARTITION_INFORMATION {
|
|
LARGE_INTEGER StartingOffset;
|
|
LARGE_INTEGER PartitionLength;
|
|
DWORD HiddenSectors;
|
|
DWORD PartitionNumber;
|
|
BYTE PartitionType;
|
|
BOOLEAN BootIndicator;
|
|
BOOLEAN RecognizedPartition;
|
|
BOOLEAN RewritePartition;
|
|
} PARTITION_INFORMATION, *PPARTITION_INFORMATION;
|
|
|
|
//
|
|
// The following structure is used to change the partition type of a
|
|
// specified disk partition using an IOCTL_DISK_SET_PARTITION_INFO
|
|
// request.
|
|
//
|
|
|
|
typedef struct _SET_PARTITION_INFORMATION {
|
|
BYTE PartitionType;
|
|
} SET_PARTITION_INFORMATION, *PSET_PARTITION_INFORMATION;
|
|
|
|
//
|
|
// The following structures is returned on an IOCTL_DISK_GET_DRIVE_LAYOUT
|
|
// request and given as input to an IOCTL_DISK_SET_DRIVE_LAYOUT request.
|
|
//
|
|
|
|
typedef struct _DRIVE_LAYOUT_INFORMATION {
|
|
DWORD PartitionCount;
|
|
DWORD Signature;
|
|
PARTITION_INFORMATION PartitionEntry[1];
|
|
} DRIVE_LAYOUT_INFORMATION, *PDRIVE_LAYOUT_INFORMATION;
|
|
|
|
//
|
|
// The following structure is passed in on an IOCTL_DISK_VERIFY request.
|
|
// The offset and length parameters are both given in bytes.
|
|
//
|
|
|
|
typedef struct _VERIFY_INFORMATION {
|
|
LARGE_INTEGER StartingOffset;
|
|
DWORD Length;
|
|
} VERIFY_INFORMATION, *PVERIFY_INFORMATION;
|
|
|
|
//
|
|
// The following structure is passed in on an IOCTL_DISK_REASSIGN_BLOCKS
|
|
// request.
|
|
//
|
|
|
|
typedef struct _REASSIGN_BLOCKS {
|
|
WORD Reserved;
|
|
WORD Count;
|
|
DWORD BlockNumber[1];
|
|
} REASSIGN_BLOCKS, *PREASSIGN_BLOCKS;
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x500)
|
|
|
|
//
|
|
// Support for GUID Partition Table (GPT) disks.
|
|
//
|
|
|
|
//
|
|
// There are currently two ways a disk can be partitioned. With a traditional
|
|
// AT-style master boot record (PARTITION_STYLE_MBR) and with a new, GPT
|
|
// partition table (PARTITION_STYLE_GPT). RAW is for an unrecognizable
|
|
// partition style. There are a very limited number of things you can
|
|
// do with a RAW partititon.
|
|
//
|
|
|
|
typedef enum _PARTITION_STYLE {
|
|
PARTITION_STYLE_MBR,
|
|
PARTITION_STYLE_GPT,
|
|
PARTITION_STYLE_RAW
|
|
} PARTITION_STYLE;
|
|
|
|
|
|
//
|
|
// The following structure defines information in a GPT partition that is
|
|
// not common to both GPT and MBR partitions.
|
|
//
|
|
|
|
typedef struct _PARTITION_INFORMATION_GPT {
|
|
GUID PartitionType; // Partition type. See table 16-3.
|
|
GUID PartitionId; // Unique GUID for this partition.
|
|
DWORD64 Attributes; // See table 16-4.
|
|
WCHAR Name [36]; // Partition Name in Unicode.
|
|
} PARTITION_INFORMATION_GPT, *PPARTITION_INFORMATION_GPT;
|
|
|
|
//
|
|
// The following are GPT partition attributes applicable for any
|
|
// partition type. These attributes are not OS-specific
|
|
//
|
|
|
|
#define GPT_ATTRIBUTE_PLATFORM_REQUIRED (0x0000000000000001)
|
|
|
|
//
|
|
// The following are GPT partition attributes applicable when the
|
|
// PartitionType is PARTITION_BASIC_DATA_GUID.
|
|
//
|
|
|
|
#define GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER (0x8000000000000000)
|
|
#define GPT_BASIC_DATA_ATTRIBUTE_HIDDEN (0x4000000000000000)
|
|
#define GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY (0x1000000000000000)
|
|
|
|
//
|
|
// The following structure defines information in an MBR partition that is not
|
|
// common to both GPT and MBR partitions.
|
|
//
|
|
|
|
typedef struct _PARTITION_INFORMATION_MBR {
|
|
BYTE PartitionType;
|
|
BOOLEAN BootIndicator;
|
|
BOOLEAN RecognizedPartition;
|
|
DWORD HiddenSectors;
|
|
} PARTITION_INFORMATION_MBR, *PPARTITION_INFORMATION_MBR;
|
|
|
|
|
|
//
|
|
// The structure SET_PARTITION_INFO_EX is used with the ioctl
|
|
// IOCTL_SET_PARTITION_INFO_EX to set information about a specific
|
|
// partition. Note that for MBR partitions, you can only set the partition
|
|
// signature, whereas GPT partitions allow setting of all fields that
|
|
// you can get.
|
|
//
|
|
|
|
typedef SET_PARTITION_INFORMATION SET_PARTITION_INFORMATION_MBR;
|
|
typedef PARTITION_INFORMATION_GPT SET_PARTITION_INFORMATION_GPT;
|
|
|
|
|
|
typedef struct _SET_PARTITION_INFORMATION_EX {
|
|
PARTITION_STYLE PartitionStyle;
|
|
union {
|
|
SET_PARTITION_INFORMATION_MBR Mbr;
|
|
SET_PARTITION_INFORMATION_GPT Gpt;
|
|
};
|
|
} SET_PARTITION_INFORMATION_EX, *PSET_PARTITION_INFORMATION_EX;
|
|
|
|
|
|
//
|
|
// The structure CREATE_DISK_GPT with the ioctl IOCTL_DISK_CREATE_DISK
|
|
// to initialize an virgin disk with an empty GPT partition table.
|
|
//
|
|
|
|
typedef struct _CREATE_DISK_GPT {
|
|
GUID DiskId; // Unique disk id for the disk.
|
|
DWORD MaxPartitionCount; // Maximim number of partitions allowable.
|
|
} CREATE_DISK_GPT, *PCREATE_DISK_GPT;
|
|
|
|
//
|
|
// The structure CREATE_DISK_MBR with the ioctl IOCTL_DISK_CREATE_DISK
|
|
// to initialize an virgin disk with an empty MBR partition table.
|
|
//
|
|
|
|
typedef struct _CREATE_DISK_MBR {
|
|
DWORD Signature;
|
|
} CREATE_DISK_MBR, *PCREATE_DISK_MBR;
|
|
|
|
|
|
typedef struct _CREATE_DISK {
|
|
PARTITION_STYLE PartitionStyle;
|
|
union {
|
|
CREATE_DISK_MBR Mbr;
|
|
CREATE_DISK_GPT Gpt;
|
|
};
|
|
} CREATE_DISK, *PCREATE_DISK;
|
|
|
|
|
|
//
|
|
// The structure GET_LENGTH_INFORMATION is used with the ioctl
|
|
// IOCTL_DISK_GET_LENGTH_INFO to obtain the length, in bytes, of the
|
|
// disk, partition, or volume.
|
|
//
|
|
|
|
typedef struct _GET_LENGTH_INFORMATION {
|
|
LARGE_INTEGER Length;
|
|
} GET_LENGTH_INFORMATION, *PGET_LENGTH_INFORMATION;
|
|
|
|
//
|
|
// The PARTITION_INFORMATION_EX structure is used with the
|
|
// IOCTL_DISK_GET_DRIVE_LAYOUT_EX, IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
|
|
// IOCTL_DISK_GET_PARTITION_INFO_EX and IOCTL_DISK_GET_PARTITION_INFO_EX calls.
|
|
//
|
|
|
|
typedef struct _PARTITION_INFORMATION_EX {
|
|
PARTITION_STYLE PartitionStyle;
|
|
LARGE_INTEGER StartingOffset;
|
|
LARGE_INTEGER PartitionLength;
|
|
DWORD PartitionNumber;
|
|
BOOLEAN RewritePartition;
|
|
union {
|
|
PARTITION_INFORMATION_MBR Mbr;
|
|
PARTITION_INFORMATION_GPT Gpt;
|
|
};
|
|
} PARTITION_INFORMATION_EX, *PPARTITION_INFORMATION_EX;
|
|
|
|
|
|
//
|
|
// GPT specific drive layout information.
|
|
//
|
|
|
|
typedef struct _DRIVE_LAYOUT_INFORMATION_GPT {
|
|
GUID DiskId;
|
|
LARGE_INTEGER StartingUsableOffset;
|
|
LARGE_INTEGER UsableLength;
|
|
DWORD MaxPartitionCount;
|
|
} DRIVE_LAYOUT_INFORMATION_GPT, *PDRIVE_LAYOUT_INFORMATION_GPT;
|
|
|
|
|
|
//
|
|
// MBR specific drive layout information.
|
|
//
|
|
|
|
typedef struct _DRIVE_LAYOUT_INFORMATION_MBR {
|
|
DWORD Signature;
|
|
} DRIVE_LAYOUT_INFORMATION_MBR, *PDRIVE_LAYOUT_INFORMATION_MBR;
|
|
|
|
//
|
|
// The structure DRIVE_LAYOUT_INFORMATION_EX is used with the
|
|
// IOCTL_SET_DRIVE_LAYOUT_EX and IOCTL_GET_DRIVE_LAYOUT_EX calls.
|
|
//
|
|
|
|
typedef struct _DRIVE_LAYOUT_INFORMATION_EX {
|
|
DWORD PartitionStyle;
|
|
DWORD PartitionCount;
|
|
union {
|
|
DRIVE_LAYOUT_INFORMATION_MBR Mbr;
|
|
DRIVE_LAYOUT_INFORMATION_GPT Gpt;
|
|
};
|
|
PARTITION_INFORMATION_EX PartitionEntry[1];
|
|
} DRIVE_LAYOUT_INFORMATION_EX, *PDRIVE_LAYOUT_INFORMATION_EX;
|
|
|
|
|
|
#endif // (_WIN32_WINNT >= 0x0500)
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
|
|
//
|
|
// The DISK_GEOMETRY_EX structure is returned on issuing an
|
|
// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX ioctl.
|
|
//
|
|
|
|
typedef enum _DETECTION_TYPE {
|
|
DetectNone,
|
|
DetectInt13,
|
|
DetectExInt13
|
|
} DETECTION_TYPE;
|
|
|
|
typedef struct _DISK_INT13_INFO {
|
|
WORD DriveSelect;
|
|
DWORD MaxCylinders;
|
|
WORD SectorsPerTrack;
|
|
WORD MaxHeads;
|
|
WORD NumberDrives;
|
|
} DISK_INT13_INFO, *PDISK_INT13_INFO;
|
|
|
|
typedef struct _DISK_EX_INT13_INFO {
|
|
WORD ExBufferSize;
|
|
WORD ExFlags;
|
|
DWORD ExCylinders;
|
|
DWORD ExHeads;
|
|
DWORD ExSectorsPerTrack;
|
|
DWORD64 ExSectorsPerDrive;
|
|
WORD ExSectorSize;
|
|
WORD ExReserved;
|
|
} DISK_EX_INT13_INFO, *PDISK_EX_INT13_INFO;
|
|
|
|
typedef struct _DISK_DETECTION_INFO {
|
|
DWORD SizeOfDetectInfo;
|
|
DETECTION_TYPE DetectionType;
|
|
union {
|
|
struct {
|
|
|
|
//
|
|
// If DetectionType == DETECTION_INT13 then we have just the Int13
|
|
// information.
|
|
//
|
|
|
|
DISK_INT13_INFO Int13;
|
|
|
|
//
|
|
// If DetectionType == DETECTION_EX_INT13, then we have the
|
|
// extended int 13 information.
|
|
//
|
|
|
|
DISK_EX_INT13_INFO ExInt13; // If DetectionType == DetectExInt13
|
|
};
|
|
};
|
|
} DISK_DETECTION_INFO, *PDISK_DETECTION_INFO;
|
|
|
|
|
|
typedef struct _DISK_PARTITION_INFO {
|
|
DWORD SizeOfPartitionInfo;
|
|
PARTITION_STYLE PartitionStyle; // PartitionStyle = RAW, GPT or MBR
|
|
union {
|
|
struct { // If PartitionStyle == MBR
|
|
DWORD Signature; // MBR Signature
|
|
DWORD CheckSum; // MBR CheckSum
|
|
} Mbr;
|
|
struct { // If PartitionStyle == GPT
|
|
GUID DiskId;
|
|
} Gpt;
|
|
};
|
|
} DISK_PARTITION_INFO, *PDISK_PARTITION_INFO;
|
|
|
|
|
|
//
|
|
// The Geometry structure is a variable length structure composed of a
|
|
// DISK_GEOMETRY_EX structure followed by a DISK_PARTITION_INFO structure
|
|
// followed by a DISK_DETECTION_DATA structure.
|
|
//
|
|
|
|
#define DiskGeometryGetPartition(Geometry)\
|
|
((PDISK_PARTITION_INFO)((Geometry)->Data))
|
|
|
|
#define DiskGeometryGetDetect(Geometry)\
|
|
((PDISK_DETECTION_INFO)(((DWORD_PTR)DiskGeometryGetPartition(Geometry)+\
|
|
DiskGeometryGetPartition(Geometry)->SizeOfPartitionInfo)))
|
|
|
|
typedef struct _DISK_GEOMETRY_EX {
|
|
DISK_GEOMETRY Geometry; // Standard disk geometry: may be faked by driver.
|
|
LARGE_INTEGER DiskSize; // Must always be correct
|
|
BYTE Data[1]; // Partition, Detect info
|
|
} DISK_GEOMETRY_EX, *PDISK_GEOMETRY_EX;
|
|
|
|
#endif // (_WIN32_WINNT > 0x0500)
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// IOCTL_DISK_CONTROLLER_NUMBER returns the controller and disk
|
|
// number for the handle. This is used to determine if a disk
|
|
// is attached to the primary or secondary IDE controller.
|
|
//
|
|
|
|
typedef struct _DISK_CONTROLLER_NUMBER {
|
|
DWORD ControllerNumber;
|
|
DWORD DiskNumber;
|
|
} DISK_CONTROLLER_NUMBER, *PDISK_CONTROLLER_NUMBER;
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
|
|
|
|
//
|
|
// IOCTL_DISK_SET_CACHE allows the caller to get or set the state of the disk
|
|
// read/write caches.
|
|
//
|
|
// If the structure is provided as the input buffer for the ioctl the read &
|
|
// write caches will be enabled or disabled depending on the parameters
|
|
// provided.
|
|
//
|
|
// If the structure is provided as an output buffer for the ioctl the state
|
|
// of the read & write caches will be returned. If both input and outut buffers
|
|
// are provided the output buffer will contain the cache state BEFORE any
|
|
// changes are made
|
|
//
|
|
|
|
typedef enum {
|
|
EqualPriority,
|
|
KeepPrefetchedData,
|
|
KeepReadData
|
|
} DISK_CACHE_RETENTION_PRIORITY;
|
|
|
|
typedef struct _DISK_CACHE_INFORMATION {
|
|
|
|
//
|
|
// on return indicates that the device is capable of saving any parameters
|
|
// in non-volatile storage. On send indicates that the device should
|
|
// save the state in non-volatile storage.
|
|
//
|
|
|
|
BOOLEAN ParametersSavable;
|
|
|
|
//
|
|
// Indicates whether the write and read caches are enabled.
|
|
//
|
|
|
|
BOOLEAN ReadCacheEnabled;
|
|
BOOLEAN WriteCacheEnabled;
|
|
|
|
//
|
|
// Controls the likelyhood of data remaining in the cache depending on how
|
|
// it got there. Data cached from a READ or WRITE operation may be given
|
|
// higher, lower or equal priority to data entered into the cache for other
|
|
// means (like prefetch)
|
|
//
|
|
|
|
DISK_CACHE_RETENTION_PRIORITY ReadRetentionPriority;
|
|
DISK_CACHE_RETENTION_PRIORITY WriteRetentionPriority;
|
|
|
|
//
|
|
// Requests for a larger number of blocks than this may have prefetching
|
|
// disabled. If this value is set to 0 prefetch will be disabled.
|
|
//
|
|
|
|
WORD DisablePrefetchTransferLength;
|
|
|
|
//
|
|
// If TRUE then ScalarPrefetch (below) will be valid. If FALSE then
|
|
// the minimum and maximum values should be treated as a block count
|
|
// (BlockPrefetch)
|
|
//
|
|
|
|
BOOLEAN PrefetchScalar;
|
|
|
|
//
|
|
// Contains the minimum and maximum amount of data which will be
|
|
// will be prefetched into the cache on a disk operation. This value
|
|
// may either be a scalar multiplier of the transfer length of the request,
|
|
// or an abolute number of disk blocks. PrefetchScalar (above) indicates
|
|
// which interpretation is used.
|
|
//
|
|
|
|
union {
|
|
struct {
|
|
WORD Minimum;
|
|
WORD Maximum;
|
|
|
|
//
|
|
// The maximum number of blocks which will be prefetched - useful
|
|
// with the scalar limits to set definite upper limits.
|
|
//
|
|
|
|
WORD MaximumBlocks;
|
|
} ScalarPrefetch;
|
|
|
|
struct {
|
|
WORD Minimum;
|
|
WORD Maximum;
|
|
} BlockPrefetch;
|
|
};
|
|
|
|
} DISK_CACHE_INFORMATION, *PDISK_CACHE_INFORMATION;
|
|
|
|
//
|
|
// IOCTL_DISK_GROW_PARTITION will update the size of a partition
|
|
// by adding sectors to the length. The number of sectors must be
|
|
// predetermined by examining PARTITION_INFORMATION.
|
|
//
|
|
|
|
typedef struct _DISK_GROW_PARTITION {
|
|
DWORD PartitionNumber;
|
|
LARGE_INTEGER BytesToGrow;
|
|
} DISK_GROW_PARTITION, *PDISK_GROW_PARTITION;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
///////////////////////////////////////////////////////
|
|
// //
|
|
// The following structures define disk performance //
|
|
// statistics: specifically the locations of all the //
|
|
// reads and writes which have occured on the disk. //
|
|
// //
|
|
// To use these structures, you must issue an IOCTL_ //
|
|
// DISK_HIST_STRUCTURE (with a DISK_HISTOGRAM) to //
|
|
// obtain the basic histogram information. The //
|
|
// number of buckets which must allocated is part of //
|
|
// this structure. Allocate the required number of //
|
|
// buckets and call an IOCTL_DISK_HIST_DATA to fill //
|
|
// in the data //
|
|
// //
|
|
///////////////////////////////////////////////////////
|
|
|
|
#define HIST_NO_OF_BUCKETS 24
|
|
|
|
typedef struct _HISTOGRAM_BUCKET {
|
|
DWORD Reads;
|
|
DWORD Writes;
|
|
} HISTOGRAM_BUCKET, *PHISTOGRAM_BUCKET;
|
|
|
|
#define HISTOGRAM_BUCKET_SIZE sizeof(HISTOGRAM_BUCKET)
|
|
|
|
typedef struct _DISK_HISTOGRAM {
|
|
LARGE_INTEGER DiskSize;
|
|
LARGE_INTEGER Start;
|
|
LARGE_INTEGER End;
|
|
LARGE_INTEGER Average;
|
|
LARGE_INTEGER AverageRead;
|
|
LARGE_INTEGER AverageWrite;
|
|
DWORD Granularity;
|
|
DWORD Size;
|
|
DWORD ReadCount;
|
|
DWORD WriteCount;
|
|
PHISTOGRAM_BUCKET Histogram;
|
|
} DISK_HISTOGRAM, *PDISK_HISTOGRAM;
|
|
|
|
#define DISK_HISTOGRAM_SIZE sizeof(DISK_HISTOGRAM)
|
|
|
|
///////////////////////////////////////////////////////
|
|
// //
|
|
// The following structures define disk debugging //
|
|
// capabilities. The IOCTLs are directed to one of //
|
|
// the two disk filter drivers. //
|
|
// //
|
|
// DISKPERF is a utilty for collecting disk request //
|
|
// statistics. //
|
|
// //
|
|
// SIMBAD is a utility for injecting faults in //
|
|
// IO requests to disks. //
|
|
// //
|
|
///////////////////////////////////////////////////////
|
|
|
|
//
|
|
// The following structure is exchanged on an IOCTL_DISK_GET_PERFORMANCE
|
|
// request. This ioctl collects summary disk request statistics used
|
|
// in measuring performance.
|
|
//
|
|
|
|
typedef struct _DISK_PERFORMANCE {
|
|
LARGE_INTEGER BytesRead;
|
|
LARGE_INTEGER BytesWritten;
|
|
LARGE_INTEGER ReadTime;
|
|
LARGE_INTEGER WriteTime;
|
|
LARGE_INTEGER IdleTime;
|
|
DWORD ReadCount;
|
|
DWORD WriteCount;
|
|
DWORD QueueDepth;
|
|
DWORD SplitCount;
|
|
LARGE_INTEGER QueryTime;
|
|
DWORD StorageDeviceNumber;
|
|
WCHAR StorageManagerName[8];
|
|
} DISK_PERFORMANCE, *PDISK_PERFORMANCE;
|
|
|
|
//
|
|
// This structure defines the disk logging record. When disk logging
|
|
// is enabled, one of these is written to an internal buffer for each
|
|
// disk request.
|
|
//
|
|
|
|
typedef struct _DISK_RECORD {
|
|
LARGE_INTEGER ByteOffset;
|
|
LARGE_INTEGER StartTime;
|
|
LARGE_INTEGER EndTime;
|
|
PVOID VirtualAddress;
|
|
DWORD NumberOfBytes;
|
|
BYTE DeviceNumber;
|
|
BOOLEAN ReadRequest;
|
|
} DISK_RECORD, *PDISK_RECORD;
|
|
|
|
//
|
|
// The following structure is exchanged on an IOCTL_DISK_LOG request.
|
|
// Not all fields are valid with each function type.
|
|
//
|
|
|
|
typedef struct _DISK_LOGGING {
|
|
BYTE Function;
|
|
PVOID BufferAddress;
|
|
DWORD BufferSize;
|
|
} DISK_LOGGING, *PDISK_LOGGING;
|
|
|
|
//
|
|
// Disk logging functions
|
|
//
|
|
// Start disk logging. Only the Function and BufferSize fields are valid.
|
|
//
|
|
|
|
#define DISK_LOGGING_START 0
|
|
|
|
//
|
|
// Stop disk logging. Only the Function field is valid.
|
|
//
|
|
|
|
#define DISK_LOGGING_STOP 1
|
|
|
|
//
|
|
// Return disk log. All fields are valid. Data will be copied from internal
|
|
// buffer to buffer specified for the number of bytes requested.
|
|
//
|
|
|
|
#define DISK_LOGGING_DUMP 2
|
|
|
|
//
|
|
// DISK BINNING
|
|
//
|
|
// DISKPERF will keep counters for IO that falls in each of these ranges.
|
|
// The application determines the number and size of the ranges.
|
|
// Joe Lin wanted me to keep it flexible as possible, for instance, IO
|
|
// sizes are interesting in ranges like 0-4096, 4097-16384, 16385-65536, 65537+.
|
|
//
|
|
|
|
#define DISK_BINNING 3
|
|
|
|
//
|
|
// Bin types
|
|
//
|
|
|
|
typedef enum _BIN_TYPES {
|
|
RequestSize,
|
|
RequestLocation
|
|
} BIN_TYPES;
|
|
|
|
//
|
|
// Bin ranges
|
|
//
|
|
|
|
typedef struct _BIN_RANGE {
|
|
LARGE_INTEGER StartValue;
|
|
LARGE_INTEGER Length;
|
|
} BIN_RANGE, *PBIN_RANGE;
|
|
|
|
//
|
|
// Bin definition
|
|
//
|
|
|
|
typedef struct _PERF_BIN {
|
|
DWORD NumberOfBins;
|
|
DWORD TypeOfBin;
|
|
BIN_RANGE BinsRanges[1];
|
|
} PERF_BIN, *PPERF_BIN ;
|
|
|
|
//
|
|
// Bin count
|
|
//
|
|
|
|
typedef struct _BIN_COUNT {
|
|
BIN_RANGE BinRange;
|
|
DWORD BinCount;
|
|
} BIN_COUNT, *PBIN_COUNT;
|
|
|
|
//
|
|
// Bin results
|
|
//
|
|
|
|
typedef struct _BIN_RESULTS {
|
|
DWORD NumberOfBins;
|
|
BIN_COUNT BinCounts[1];
|
|
} BIN_RESULTS, *PBIN_RESULTS;
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Data structures for SMART drive fault prediction.
|
|
//
|
|
// GETVERSIONINPARAMS contains the data returned from the
|
|
// Get Driver Version function.
|
|
//
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct _GETVERSIONINPARAMS {
|
|
BYTE bVersion; // Binary driver version.
|
|
BYTE bRevision; // Binary driver revision.
|
|
BYTE bReserved; // Not used.
|
|
BYTE bIDEDeviceMap; // Bit map of IDE devices.
|
|
DWORD fCapabilities; // Bit mask of driver capabilities.
|
|
DWORD dwReserved[4]; // For future use.
|
|
} GETVERSIONINPARAMS, *PGETVERSIONINPARAMS, *LPGETVERSIONINPARAMS;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// Bits returned in the fCapabilities member of GETVERSIONINPARAMS
|
|
//
|
|
|
|
#define CAP_ATA_ID_CMD 1 // ATA ID command supported
|
|
#define CAP_ATAPI_ID_CMD 2 // ATAPI ID command supported
|
|
#define CAP_SMART_CMD 4 // SMART commannds supported
|
|
|
|
//
|
|
// IDE registers
|
|
//
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct _IDEREGS {
|
|
BYTE bFeaturesReg; // Used for specifying SMART "commands".
|
|
BYTE bSectorCountReg; // IDE sector count register
|
|
BYTE bSectorNumberReg; // IDE sector number register
|
|
BYTE bCylLowReg; // IDE low order cylinder value
|
|
BYTE bCylHighReg; // IDE high order cylinder value
|
|
BYTE bDriveHeadReg; // IDE drive/head register
|
|
BYTE bCommandReg; // Actual IDE command.
|
|
BYTE bReserved; // reserved for future use. Must be zero.
|
|
} IDEREGS, *PIDEREGS, *LPIDEREGS;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// Valid values for the bCommandReg member of IDEREGS.
|
|
//
|
|
|
|
#define ATAPI_ID_CMD 0xA1 // Returns ID sector for ATAPI.
|
|
#define ID_CMD 0xEC // Returns ID sector for ATA.
|
|
#define SMART_CMD 0xB0 // Performs SMART cmd.
|
|
// Requires valid bFeaturesReg,
|
|
// bCylLowReg, and bCylHighReg
|
|
|
|
//
|
|
// Cylinder register defines for SMART command
|
|
//
|
|
|
|
#define SMART_CYL_LOW 0x4F
|
|
#define SMART_CYL_HI 0xC2
|
|
|
|
|
|
//
|
|
// SENDCMDINPARAMS contains the input parameters for the
|
|
// Send Command to Drive function.
|
|
//
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct _SENDCMDINPARAMS {
|
|
DWORD cBufferSize; // Buffer size in bytes
|
|
IDEREGS irDriveRegs; // Structure with drive register values.
|
|
BYTE bDriveNumber; // Physical drive number to send
|
|
// command to (0,1,2,3).
|
|
BYTE bReserved[3]; // Reserved for future expansion.
|
|
DWORD dwReserved[4]; // For future use.
|
|
BYTE bBuffer[1]; // Input buffer.
|
|
} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// Status returned from driver
|
|
//
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct _DRIVERSTATUS {
|
|
BYTE bDriverError; // Error code from driver,
|
|
// or 0 if no error.
|
|
BYTE bIDEError; // Contents of IDE Error register.
|
|
// Only valid when bDriverError
|
|
// is SMART_IDE_ERROR.
|
|
BYTE bReserved[2]; // Reserved for future expansion.
|
|
DWORD dwReserved[2]; // Reserved for future expansion.
|
|
} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// bDriverError values
|
|
//
|
|
|
|
#define SMART_NO_ERROR 0 // No error
|
|
#define SMART_IDE_ERROR 1 // Error from IDE controller
|
|
#define SMART_INVALID_FLAG 2 // Invalid command flag
|
|
#define SMART_INVALID_COMMAND 3 // Invalid command byte
|
|
#define SMART_INVALID_BUFFER 4 // Bad buffer (null, invalid addr..)
|
|
#define SMART_INVALID_DRIVE 5 // Drive number not valid
|
|
#define SMART_INVALID_IOCTL 6 // Invalid IOCTL
|
|
#define SMART_ERROR_NO_MEM 7 // Could not lock user's buffer
|
|
#define SMART_INVALID_REGISTER 8 // Some IDE Register not valid
|
|
#define SMART_NOT_SUPPORTED 9 // Invalid cmd flag set
|
|
#define SMART_NO_IDE_DEVICE 10 // Cmd issued to device not present
|
|
// although drive number is valid
|
|
//
|
|
// SMART sub commands for execute offline diags
|
|
//
|
|
#define SMART_OFFLINE_ROUTINE_OFFLINE 0
|
|
#define SMART_SHORT_SELFTEST_OFFLINE 1
|
|
#define SMART_EXTENDED_SELFTEST_OFFLINE 2
|
|
#define SMART_ABORT_OFFLINE_SELFTEST 127
|
|
#define SMART_SHORT_SELFTEST_CAPTIVE 129
|
|
#define SMART_EXTENDED_SELFTEST_CAPTIVE 130
|
|
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct _SENDCMDOUTPARAMS {
|
|
DWORD cBufferSize; // Size of bBuffer in bytes
|
|
DRIVERSTATUS DriverStatus; // Driver status structure.
|
|
BYTE bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the // drive.
|
|
} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
|
|
#include <poppack.h>
|
|
|
|
|
|
#define READ_ATTRIBUTE_BUFFER_SIZE 512
|
|
#define IDENTIFY_BUFFER_SIZE 512
|
|
#define READ_THRESHOLD_BUFFER_SIZE 512
|
|
#define SMART_LOG_SECTOR_SIZE 512
|
|
|
|
//
|
|
// Feature register defines for SMART "sub commands"
|
|
//
|
|
|
|
#define READ_ATTRIBUTES 0xD0
|
|
#define READ_THRESHOLDS 0xD1
|
|
#define ENABLE_DISABLE_AUTOSAVE 0xD2
|
|
#define SAVE_ATTRIBUTE_VALUES 0xD3
|
|
#define EXECUTE_OFFLINE_DIAGS 0xD4
|
|
#define SMART_READ_LOG 0xD5
|
|
#define SMART_WRITE_LOG 0xd6
|
|
#define ENABLE_SMART 0xD8
|
|
#define DISABLE_SMART 0xD9
|
|
#define RETURN_SMART_STATUS 0xDA
|
|
#define ENABLE_DISABLE_AUTO_OFFLINE 0xDB
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
|
|
#define IOCTL_CHANGER_BASE FILE_DEVICE_CHANGER
|
|
|
|
#define IOCTL_CHANGER_GET_PARAMETERS CTL_CODE(IOCTL_CHANGER_BASE, 0x0000, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_GET_STATUS CTL_CODE(IOCTL_CHANGER_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_GET_PRODUCT_DATA CTL_CODE(IOCTL_CHANGER_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_SET_ACCESS CTL_CODE(IOCTL_CHANGER_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_CHANGER_GET_ELEMENT_STATUS CTL_CODE(IOCTL_CHANGER_BASE, 0x0005, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
#define IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS CTL_CODE(IOCTL_CHANGER_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_SET_POSITION CTL_CODE(IOCTL_CHANGER_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_EXCHANGE_MEDIUM CTL_CODE(IOCTL_CHANGER_BASE, 0x0008, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_MOVE_MEDIUM CTL_CODE(IOCTL_CHANGER_BASE, 0x0009, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_REINITIALIZE_TRANSPORT CTL_CODE(IOCTL_CHANGER_BASE, 0x000A, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
#define IOCTL_CHANGER_QUERY_VOLUME_TAGS CTL_CODE(IOCTL_CHANGER_BASE, 0x000B, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
|
|
|
|
|
|
|
|
#define MAX_VOLUME_ID_SIZE 36
|
|
#define MAX_VOLUME_TEMPLATE_SIZE 40
|
|
|
|
#define VENDOR_ID_LENGTH 8
|
|
#define PRODUCT_ID_LENGTH 16
|
|
#define REVISION_LENGTH 4
|
|
#define SERIAL_NUMBER_LENGTH 32
|
|
|
|
//
|
|
// Common structures describing elements.
|
|
//
|
|
|
|
typedef enum _ELEMENT_TYPE {
|
|
AllElements, // As defined by SCSI
|
|
ChangerTransport, // As defined by SCSI
|
|
ChangerSlot, // As defined by SCSI
|
|
ChangerIEPort, // As defined by SCSI
|
|
ChangerDrive, // As defined by SCSI
|
|
ChangerDoor, // Front panel, used to access internal of cabinet.
|
|
ChangerKeypad, // Keypad/input on front panel.
|
|
ChangerMaxElement // Placeholder only. Not a valid type.
|
|
} ELEMENT_TYPE, *PELEMENT_TYPE;
|
|
|
|
typedef struct _CHANGER_ELEMENT {
|
|
ELEMENT_TYPE ElementType;
|
|
DWORD ElementAddress;
|
|
} CHANGER_ELEMENT, *PCHANGER_ELEMENT;
|
|
|
|
typedef struct _CHANGER_ELEMENT_LIST {
|
|
CHANGER_ELEMENT Element;
|
|
DWORD NumberOfElements;
|
|
} CHANGER_ELEMENT_LIST , *PCHANGER_ELEMENT_LIST;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_GET_PARAMETERS
|
|
//
|
|
|
|
//
|
|
// Definitions for Features0 of GET_CHANGER_PARAMETERS
|
|
//
|
|
|
|
#define CHANGER_BAR_CODE_SCANNER_INSTALLED 0x00000001 // The medium-changer has a bar code scanner installed.
|
|
#define CHANGER_INIT_ELEM_STAT_WITH_RANGE 0x00000002 // The medium-changer has the ability to initialize elements within a specified range.
|
|
#define CHANGER_CLOSE_IEPORT 0x00000004 // The medium-changer has the ability to close the i/e port door.
|
|
#define CHANGER_OPEN_IEPORT 0x00000008 // The medium-changer can open the i/e port door.
|
|
|
|
#define CHANGER_STATUS_NON_VOLATILE 0x00000010 // The medium-changer uses non-volatile memory for element status information.
|
|
#define CHANGER_EXCHANGE_MEDIA 0x00000020 // The medium-changer supports exchange operations.
|
|
#define CHANGER_CLEANER_SLOT 0x00000040 // The medium-changer has a fixed slot designated for cleaner cartridges.
|
|
#define CHANGER_LOCK_UNLOCK 0x00000080 // The medium-changer can be (un)secured to (allow)prevent media removal.
|
|
|
|
#define CHANGER_CARTRIDGE_MAGAZINE 0x00000100 // The medium-changer uses cartridge magazines for some storage slots.
|
|
#define CHANGER_MEDIUM_FLIP 0x00000200 // The medium-changer can flip medium.
|
|
#define CHANGER_POSITION_TO_ELEMENT 0x00000400 // The medium-changer can position the transport to a particular element.
|
|
#define CHANGER_REPORT_IEPORT_STATE 0x00000800 // The medium-changer can determine whether media is present
|
|
// in the IE Port.
|
|
|
|
#define CHANGER_STORAGE_DRIVE 0x00001000 // The medium-changer can use a drive as an independent storage element.
|
|
#define CHANGER_STORAGE_IEPORT 0x00002000 // The medium-changer can use a i/e port as an independent storage element.
|
|
#define CHANGER_STORAGE_SLOT 0x00004000 // The medium-changer can use a slot as an independent storage element.
|
|
#define CHANGER_STORAGE_TRANSPORT 0x00008000 // The medium-changer can use a transport as an independent storage element.
|
|
|
|
#define CHANGER_DRIVE_CLEANING_REQUIRED 0x00010000 // The drives controlled by the medium changer require periodic cleaning
|
|
// initiated by an application.
|
|
#define CHANGER_PREDISMOUNT_EJECT_REQUIRED 0x00020000 // The medium-changer requires a drive eject command to be issued, before a changer
|
|
// move / exchange command can be issued to the drive.
|
|
|
|
#define CHANGER_CLEANER_ACCESS_NOT_VALID 0x00040000 // The access bit in GES isn't valid for cleaner cartridges.
|
|
#define CHANGER_PREMOUNT_EJECT_REQUIRED 0x00080000 // The medium-changer requires a drive eject command to be issued
|
|
// before a move / exchange command can be issued with the drive as src/dst.
|
|
|
|
#define CHANGER_VOLUME_IDENTIFICATION 0x00100000 // The medium-changer supports volume identification.
|
|
#define CHANGER_VOLUME_SEARCH 0x00200000 // The medium-changer can search for volume information.
|
|
#define CHANGER_VOLUME_ASSERT 0x00400000 // The medium-changer can verify volume information.
|
|
#define CHANGER_VOLUME_REPLACE 0x00800000 // The medium-changer can replace volume information.
|
|
#define CHANGER_VOLUME_UNDEFINE 0x01000000 // The medium-changer can undefine volume information.
|
|
|
|
#define CHANGER_SERIAL_NUMBER_VALID 0x04000000 // The serial number reported in GetProductData is valid
|
|
// and unique.
|
|
|
|
#define CHANGER_DEVICE_REINITIALIZE_CAPABLE 0x08000000 // The medium-changer can be issued a ChangerReinitializeUnit.
|
|
#define CHANGER_KEYPAD_ENABLE_DISABLE 0x10000000 // Indicates that the keypad can be enabled/disabled.
|
|
#define CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS 0x20000000 // Drives must be empty before access via the door is possible.
|
|
|
|
#define CHANGER_RESERVED_BIT 0x80000000 // Will be used to indicate Features1 capability bits.
|
|
|
|
|
|
//
|
|
// Definitions for Features1 of GET_CHANGER_PARAMETERS
|
|
//
|
|
|
|
#define CHANGER_PREDISMOUNT_ALIGN_TO_SLOT 0x80000001 // The transport must be prepositioned to the slot prior to ejecting the media.
|
|
#define CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE 0x80000002 // The transport must be prepositioned to the drive prior to ejecting the media.
|
|
#define CHANGER_CLEANER_AUTODISMOUNT 0x80000004 // The device will move the cleaner cartridge back into the slot when cleaning has completed.
|
|
#define CHANGER_TRUE_EXCHANGE_CAPABLE 0x80000008 // Device can do src -> dest2 exchanges.
|
|
#define CHANGER_SLOTS_USE_TRAYS 0x80000010 // Slots have removable trays, requiring multiple moves for inject/eject.
|
|
#define CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR 0x80000020 // Media must be returned to the slot from which it originated after a move to another element.
|
|
#define CHANGER_CLEANER_OPS_NOT_SUPPORTED 0x80000040 // Automated cleaning operations are not supported on this device.
|
|
#define CHANGER_IEPORT_USER_CONTROL_OPEN 0x80000080 // Indicates that user action is necessary to open a closed ieport.
|
|
#define CHANGER_IEPORT_USER_CONTROL_CLOSE 0x80000100 // Indicates that user action is necessary to close an opened ieport.
|
|
#define CHANGER_MOVE_EXTENDS_IEPORT 0x80000200 // Indicates that a move media to the ieport extends the tray.
|
|
#define CHANGER_MOVE_RETRACTS_IEPORT 0x80000400 // Indicates that a move media from the ieport retracts the tray.
|
|
|
|
|
|
//
|
|
// Definitions for MoveFrom, ExchangeFrom, and PositionCapabilities
|
|
//
|
|
|
|
#define CHANGER_TO_TRANSPORT 0x01 // The device can carry out the operation to a transport from the specified element.
|
|
#define CHANGER_TO_SLOT 0x02 // The device can carry out the operation to a slot from the specified element.
|
|
#define CHANGER_TO_IEPORT 0x04 // The device can carry out the operation to an IE Port from the specified element.
|
|
#define CHANGER_TO_DRIVE 0x08 // The device can carry out the operation to a drive from the specified element.
|
|
|
|
//
|
|
// Definitions for LockUnlockCapabilities
|
|
//
|
|
|
|
#define LOCK_UNLOCK_IEPORT 0x01 // The device can lock/unlock the ieport(s).
|
|
#define LOCK_UNLOCK_DOOR 0x02 // The device can lock/unlock the door(s).
|
|
#define LOCK_UNLOCK_KEYPAD 0x04 // The device can lock/unlock the keypad.
|
|
|
|
typedef struct _GET_CHANGER_PARAMETERS {
|
|
|
|
//
|
|
// Size of the structure. Can be used for versioning.
|
|
//
|
|
|
|
DWORD Size;
|
|
|
|
//
|
|
// Number of N element(s) as defined by the Element Address Page (or equivalent...).
|
|
//
|
|
|
|
WORD NumberTransportElements;
|
|
WORD NumberStorageElements; // for data cartridges only
|
|
WORD NumberCleanerSlots; // for cleaner cartridges
|
|
WORD NumberIEElements;
|
|
WORD NumberDataTransferElements;
|
|
|
|
//
|
|
// Number of doors/front panels (allows user entry into the cabinet).
|
|
//
|
|
|
|
WORD NumberOfDoors;
|
|
|
|
//
|
|
// The device-specific address (from user manual of the device) of the first N element. Used
|
|
// by the UI to relate the various elements to the user.
|
|
//
|
|
|
|
WORD FirstSlotNumber;
|
|
WORD FirstDriveNumber;
|
|
WORD FirstTransportNumber;
|
|
WORD FirstIEPortNumber;
|
|
WORD FirstCleanerSlotAddress;
|
|
|
|
//
|
|
// Indicates the capacity of each magazine, if they exist.
|
|
//
|
|
|
|
WORD MagazineSize;
|
|
|
|
//
|
|
// Specifies the approximate number of seconds for when a cleaning should be completed.
|
|
// Only applicable if drive cleaning is supported. See Features0.
|
|
//
|
|
|
|
DWORD DriveCleanTimeout;
|
|
|
|
//
|
|
// See features bits, above.
|
|
//
|
|
|
|
DWORD Features0;
|
|
DWORD Features1;
|
|
|
|
//
|
|
// Bitmask defining Move from N element to element. Defined by Device Capabilities Page (or equivalent).
|
|
// AND-masking with the TO_XXX values will indicate legal destinations.
|
|
//
|
|
|
|
BYTE MoveFromTransport;
|
|
BYTE MoveFromSlot;
|
|
BYTE MoveFromIePort;
|
|
BYTE MoveFromDrive;
|
|
|
|
//
|
|
// Bitmask defining Exchange from N element to element. Defined by Device Capabilities Page (or equivalent).
|
|
// AND-masking with the TO_XXX values will indicate legal destinations.
|
|
//
|
|
|
|
BYTE ExchangeFromTransport;
|
|
BYTE ExchangeFromSlot;
|
|
BYTE ExchangeFromIePort;
|
|
BYTE ExchangeFromDrive;
|
|
|
|
//
|
|
// Bitmask defining which elements are capable of lock/unlock. Valid only if
|
|
// CHANGER_LOCK_UNLOCK is set in Features0.
|
|
//
|
|
|
|
BYTE LockUnlockCapabilities;
|
|
|
|
//
|
|
// Bitmask defining which elements valid for positioning operations. Valid only if
|
|
// CHANGER_POSITION_TO_ELEMENT is set in Features0.
|
|
//
|
|
|
|
BYTE PositionCapabilities;
|
|
|
|
//
|
|
// For future expansion.
|
|
//
|
|
|
|
BYTE Reserved1[2];
|
|
DWORD Reserved2[2];
|
|
|
|
} GET_CHANGER_PARAMETERS, * PGET_CHANGER_PARAMETERS;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_GET_PRODUCT_DATA
|
|
//
|
|
|
|
typedef struct _CHANGER_PRODUCT_DATA {
|
|
|
|
//
|
|
// Device manufacturer's name - based on inquiry data
|
|
//
|
|
|
|
BYTE VendorId[VENDOR_ID_LENGTH];
|
|
|
|
//
|
|
// Product identification as defined by the vendor - based on Inquiry data
|
|
//
|
|
|
|
BYTE ProductId[PRODUCT_ID_LENGTH];
|
|
|
|
//
|
|
// Product revision as defined by the vendor.
|
|
//
|
|
|
|
BYTE Revision[REVISION_LENGTH];
|
|
|
|
//
|
|
// Vendor unique value used to globally identify this device. Can
|
|
// be from Vital Product Data, for example.
|
|
//
|
|
|
|
BYTE SerialNumber[SERIAL_NUMBER_LENGTH];
|
|
|
|
//
|
|
// Indicates device type of data transports, as defined by SCSI-2.
|
|
//
|
|
|
|
BYTE DeviceType;
|
|
|
|
} CHANGER_PRODUCT_DATA, *PCHANGER_PRODUCT_DATA;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_SET_ACCESS
|
|
//
|
|
|
|
#define LOCK_ELEMENT 0
|
|
#define UNLOCK_ELEMENT 1
|
|
#define EXTEND_IEPORT 2
|
|
#define RETRACT_IEPORT 3
|
|
|
|
typedef struct _CHANGER_SET_ACCESS {
|
|
|
|
//
|
|
// Element can be ChangerIEPort, ChangerDoor, ChangerKeypad
|
|
//
|
|
|
|
CHANGER_ELEMENT Element;
|
|
|
|
//
|
|
// See above for possible operations.
|
|
//
|
|
|
|
DWORD Control;
|
|
} CHANGER_SET_ACCESS, *PCHANGER_SET_ACCESS;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_GET_ELEMENT_STATUS
|
|
//
|
|
|
|
//
|
|
// Input buffer.
|
|
//
|
|
|
|
typedef struct _CHANGER_READ_ELEMENT_STATUS {
|
|
|
|
//
|
|
// List describing the elements and range on which to return information.
|
|
//
|
|
|
|
CHANGER_ELEMENT_LIST ElementList;
|
|
|
|
//
|
|
// Indicates whether volume tag information is to be returned.
|
|
//
|
|
|
|
BOOLEAN VolumeTagInfo;
|
|
} CHANGER_READ_ELEMENT_STATUS, *PCHANGER_READ_ELEMENT_STATUS;
|
|
|
|
//
|
|
// Output buffer.
|
|
//
|
|
|
|
typedef struct _CHANGER_ELEMENT_STATUS {
|
|
|
|
//
|
|
// Element to which this structure refers.
|
|
//
|
|
|
|
CHANGER_ELEMENT Element;
|
|
|
|
//
|
|
// Address of the element from which the media was originally moved.
|
|
// Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
|
|
// Needs to be converted to a zero-based offset from the device-unique value.
|
|
//
|
|
|
|
CHANGER_ELEMENT SrcElementAddress;
|
|
|
|
//
|
|
// See below.
|
|
//
|
|
|
|
DWORD Flags;
|
|
|
|
//
|
|
// See below for possible values.
|
|
//
|
|
|
|
DWORD ExceptionCode;
|
|
|
|
//
|
|
// Scsi Target Id of this element.
|
|
// Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
|
|
//
|
|
|
|
BYTE TargetId;
|
|
|
|
//
|
|
// LogicalUnitNumber of this element.
|
|
// Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
|
|
//
|
|
|
|
BYTE Lun;
|
|
WORD Reserved;
|
|
|
|
//
|
|
// Primary volume identification for the media.
|
|
// Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
|
|
//
|
|
|
|
BYTE PrimaryVolumeID[MAX_VOLUME_ID_SIZE];
|
|
|
|
//
|
|
// Alternate volume identification for the media.
|
|
// Valid for two-sided media only, and pertains to the id. of the inverted side.
|
|
// Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
|
|
//
|
|
|
|
BYTE AlternateVolumeID[MAX_VOLUME_ID_SIZE];
|
|
|
|
} CHANGER_ELEMENT_STATUS, *PCHANGER_ELEMENT_STATUS;
|
|
|
|
//
|
|
// Output buffer. This is same as CHANGER_ELEMENT_STATUS with
|
|
// the addition of product info fields. New applications should
|
|
// use this struct instead of the older CHANGER_ELEMENT_STATUS
|
|
//
|
|
|
|
typedef struct _CHANGER_ELEMENT_STATUS_EX {
|
|
|
|
//
|
|
// Element to which this structure refers.
|
|
//
|
|
|
|
CHANGER_ELEMENT Element;
|
|
|
|
//
|
|
// Address of the element from which the media was originally moved.
|
|
// Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
|
|
// Needs to be converted to a zero-based offset from the device-unique value.
|
|
//
|
|
|
|
CHANGER_ELEMENT SrcElementAddress;
|
|
|
|
//
|
|
// See below.
|
|
//
|
|
|
|
DWORD Flags;
|
|
|
|
//
|
|
// See below for possible values.
|
|
//
|
|
|
|
DWORD ExceptionCode;
|
|
|
|
//
|
|
// Scsi Target Id of this element.
|
|
// Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
|
|
//
|
|
|
|
BYTE TargetId;
|
|
|
|
//
|
|
// LogicalUnitNumber of this element.
|
|
// Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
|
|
//
|
|
|
|
BYTE Lun;
|
|
WORD Reserved;
|
|
|
|
//
|
|
// Primary volume identification for the media.
|
|
// Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
|
|
//
|
|
|
|
BYTE PrimaryVolumeID[MAX_VOLUME_ID_SIZE];
|
|
|
|
//
|
|
// Alternate volume identification for the media.
|
|
// Valid for two-sided media only, and pertains to the id. of the inverted side.
|
|
// Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
|
|
//
|
|
|
|
BYTE AlternateVolumeID[MAX_VOLUME_ID_SIZE];
|
|
|
|
//
|
|
// Vendor ID
|
|
//
|
|
BYTE VendorIdentification[VENDOR_ID_LENGTH];
|
|
|
|
//
|
|
// Product ID
|
|
//
|
|
BYTE ProductIdentification[PRODUCT_ID_LENGTH];
|
|
|
|
//
|
|
// Serial number
|
|
//
|
|
BYTE SerialNumber[SERIAL_NUMBER_LENGTH];
|
|
|
|
} CHANGER_ELEMENT_STATUS_EX, *PCHANGER_ELEMENT_STATUS_EX;
|
|
|
|
//
|
|
// Possible flag values
|
|
//
|
|
|
|
#define ELEMENT_STATUS_FULL 0x00000001 // Element contains a unit of media.
|
|
#define ELEMENT_STATUS_IMPEXP 0x00000002 // Media in i/e port was placed there by an operator.
|
|
#define ELEMENT_STATUS_EXCEPT 0x00000004 // Element is in an abnormal state; check ExceptionCode field for more information.
|
|
#define ELEMENT_STATUS_ACCESS 0x00000008 // Access to the i/e port from the medium changer is allowed.
|
|
#define ELEMENT_STATUS_EXENAB 0x00000010 // Export of media is supported.
|
|
#define ELEMENT_STATUS_INENAB 0x00000020 // Import of media is supported.
|
|
|
|
#define ELEMENT_STATUS_PRODUCT_DATA 0x00000040 // Serial number valid for the drive
|
|
|
|
#define ELEMENT_STATUS_LUN_VALID 0x00001000 // Lun information is valid.
|
|
#define ELEMENT_STATUS_ID_VALID 0x00002000 // SCSI Id information is valid.
|
|
#define ELEMENT_STATUS_NOT_BUS 0x00008000 // Lun and SCSI Id fields are not on same bus as medium changer.
|
|
#define ELEMENT_STATUS_INVERT 0x00400000 // Media in element was inverted (valid only if ELEMENT_STATUS_SVALID bit is set)
|
|
#define ELEMENT_STATUS_SVALID 0x00800000 // SourceElementAddress field and ELEMENT_STATUS_INVERT bit are valid.
|
|
|
|
#define ELEMENT_STATUS_PVOLTAG 0x10000000 // Primary volume information is valid.
|
|
#define ELEMENT_STATUS_AVOLTAG 0x20000000 // Alternate volume information is valid.
|
|
|
|
//
|
|
// ExceptionCode values.
|
|
//
|
|
|
|
#define ERROR_LABEL_UNREADABLE 0x00000001 // Bar code scanner could not read bar code label.
|
|
#define ERROR_LABEL_QUESTIONABLE 0x00000002 // Label could be invalid due to unit attention condition.
|
|
#define ERROR_SLOT_NOT_PRESENT 0x00000004 // Slot is currently not addressable in the device.
|
|
#define ERROR_DRIVE_NOT_INSTALLED 0x00000008 // Drive is not installed.
|
|
#define ERROR_TRAY_MALFUNCTION 0x00000010 // Media tray is malfunctioning/broken.
|
|
#define ERROR_INIT_STATUS_NEEDED 0x00000011 // An Initialize Element Status command is needed.
|
|
#define ERROR_UNHANDLED_ERROR 0xFFFFFFFF // Unknown error condition
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS
|
|
//
|
|
|
|
typedef struct _CHANGER_INITIALIZE_ELEMENT_STATUS {
|
|
|
|
//
|
|
// List describing the elements and range on which to initialize.
|
|
//
|
|
|
|
CHANGER_ELEMENT_LIST ElementList;
|
|
|
|
//
|
|
// Indicates whether a bar code scan should be used. Only applicable if
|
|
// CHANGER_BAR_CODE_SCANNER_INSTALLED is set in Features0 of CHANGER_GET_PARAMETERS.
|
|
//
|
|
|
|
BOOLEAN BarCodeScan;
|
|
} CHANGER_INITIALIZE_ELEMENT_STATUS, *PCHANGER_INITIALIZE_ELEMENT_STATUS;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_SET_POSITION
|
|
//
|
|
|
|
typedef struct _CHANGER_SET_POSITION {
|
|
|
|
|
|
//
|
|
// Indicates which transport to move.
|
|
//
|
|
|
|
CHANGER_ELEMENT Transport;
|
|
|
|
//
|
|
// Indicates the final destination of the transport.
|
|
//
|
|
|
|
CHANGER_ELEMENT Destination;
|
|
|
|
//
|
|
// Indicates whether the media currently carried by Transport, should be flipped.
|
|
//
|
|
|
|
BOOLEAN Flip;
|
|
} CHANGER_SET_POSITION, *PCHANGER_SET_POSITION;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_EXCHANGE_MEDIUM
|
|
//
|
|
|
|
typedef struct _CHANGER_EXCHANGE_MEDIUM {
|
|
|
|
//
|
|
// Indicates which transport to use for the exchange operation.
|
|
//
|
|
|
|
CHANGER_ELEMENT Transport;
|
|
|
|
//
|
|
// Indicates the source for the media that is to be moved.
|
|
//
|
|
|
|
CHANGER_ELEMENT Source;
|
|
|
|
//
|
|
// Indicates the final destination of the media originally at Source.
|
|
//
|
|
|
|
CHANGER_ELEMENT Destination1;
|
|
|
|
//
|
|
// Indicates the destination of the media moved from Destination1.
|
|
//
|
|
|
|
CHANGER_ELEMENT Destination2;
|
|
|
|
//
|
|
// Indicates whether the medium should be flipped.
|
|
//
|
|
|
|
BOOLEAN Flip1;
|
|
BOOLEAN Flip2;
|
|
} CHANGER_EXCHANGE_MEDIUM, *PCHANGER_EXCHANGE_MEDIUM;
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_CHANGER_MOVE_MEDIUM
|
|
//
|
|
|
|
typedef struct _CHANGER_MOVE_MEDIUM {
|
|
|
|
//
|
|
// Indicates which transport to use for the move operation.
|
|
//
|
|
|
|
CHANGER_ELEMENT Transport;
|
|
|
|
//
|
|
// Indicates the source for the media that is to be moved.
|
|
//
|
|
|
|
CHANGER_ELEMENT Source;
|
|
|
|
//
|
|
// Indicates the destination of the media originally at Source.
|
|
//
|
|
|
|
CHANGER_ELEMENT Destination;
|
|
|
|
//
|
|
// Indicates whether the media should be flipped.
|
|
//
|
|
|
|
BOOLEAN Flip;
|
|
} CHANGER_MOVE_MEDIUM, *PCHANGER_MOVE_MEDIUM;
|
|
|
|
|
|
|
|
//
|
|
// Definitions for IOCTL_QUERY_VOLUME_TAGS
|
|
//
|
|
|
|
//
|
|
// Input buffer.
|
|
//
|
|
|
|
typedef struct _CHANGER_SEND_VOLUME_TAG_INFORMATION {
|
|
|
|
//
|
|
// Describes the starting element for which to return information.
|
|
//
|
|
|
|
CHANGER_ELEMENT StartingElement;
|
|
|
|
//
|
|
// Indicates the specific action to perform. See below.
|
|
//
|
|
|
|
DWORD ActionCode;
|
|
|
|
//
|
|
// Template used by the device to search for volume ids.
|
|
//
|
|
|
|
BYTE VolumeIDTemplate[MAX_VOLUME_TEMPLATE_SIZE];
|
|
} CHANGER_SEND_VOLUME_TAG_INFORMATION, *PCHANGER_SEND_VOLUME_TAG_INFORMATION;
|
|
|
|
|
|
//
|
|
// Output buffer.
|
|
//
|
|
|
|
typedef struct _READ_ELEMENT_ADDRESS_INFO {
|
|
|
|
//
|
|
// Number of elements matching criteria set forth by ActionCode.
|
|
//
|
|
|
|
DWORD NumberOfElements;
|
|
|
|
//
|
|
// Array of CHANGER_ELEMENT_STATUS structures, one for each element that corresponded
|
|
// with the information passed in with the CHANGER_SEND_VOLUME_TAG_INFORMATION structure.
|
|
//
|
|
|
|
CHANGER_ELEMENT_STATUS ElementStatus[1];
|
|
} READ_ELEMENT_ADDRESS_INFO, *PREAD_ELEMENT_ADDRESS_INFO;
|
|
|
|
//
|
|
// Possible ActionCode values. See Features0 of CHANGER_GET_PARAMETERS for compatibility with
|
|
// the current device.
|
|
//
|
|
|
|
#define SEARCH_ALL 0x0 // Translate - search all defined volume tags.
|
|
#define SEARCH_PRIMARY 0x1 // Translate - search only primary volume tags.
|
|
#define SEARCH_ALTERNATE 0x2 // Translate - search only alternate volume tags.
|
|
#define SEARCH_ALL_NO_SEQ 0x4 // Translate - search all defined volume tags but ignore sequence numbers.
|
|
#define SEARCH_PRI_NO_SEQ 0x5 // Translate - search only primary volume tags but ignore sequence numbers.
|
|
#define SEARCH_ALT_NO_SEQ 0x6 // Translate - search only alternate volume tags but ignore sequence numbers.
|
|
|
|
#define ASSERT_PRIMARY 0x8 // Assert - as the primary volume tag - if tag now undefined.
|
|
#define ASSERT_ALTERNATE 0x9 // Assert - as the alternate volume tag - if tag now undefined.
|
|
|
|
#define REPLACE_PRIMARY 0xA // Replace - the primary volume tag - current tag ignored.
|
|
#define REPLACE_ALTERNATE 0xB // Replace - the alternate volume tag - current tag ignored.
|
|
|
|
#define UNDEFINE_PRIMARY 0xC // Undefine - the primary volume tag - current tag ignored.
|
|
#define UNDEFINE_ALTERNATE 0xD // Undefine - the alternate volume tag - current tag ignored.
|
|
|
|
|
|
//
|
|
// Changer diagnostic test related definitions
|
|
//
|
|
typedef enum _CHANGER_DEVICE_PROBLEM_TYPE {
|
|
DeviceProblemNone,
|
|
DeviceProblemHardware,
|
|
DeviceProblemCHMError,
|
|
DeviceProblemDoorOpen,
|
|
DeviceProblemCalibrationError,
|
|
DeviceProblemTargetFailure,
|
|
DeviceProblemCHMMoveError,
|
|
DeviceProblemCHMZeroError,
|
|
DeviceProblemCartridgeInsertError,
|
|
DeviceProblemPositionError,
|
|
DeviceProblemSensorError,
|
|
DeviceProblemCartridgeEjectError,
|
|
DeviceProblemGripperError,
|
|
DeviceProblemDriveError
|
|
} CHANGER_DEVICE_PROBLEM_TYPE, *PCHANGER_DEVICE_PROBLEM_TYPE;
|
|
|
|
|
|
#define IOCTL_SERIAL_LSRMST_INSERT CTL_CODE(FILE_DEVICE_SERIAL_PORT,31,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
|
|
#define IOCTL_SERENUM_EXPOSE_HARDWARE CTL_CODE(FILE_DEVICE_SERENUM,128,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
#define IOCTL_SERENUM_REMOVE_HARDWARE CTL_CODE(FILE_DEVICE_SERENUM,129,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
#define IOCTL_SERENUM_PORT_DESC CTL_CODE(FILE_DEVICE_SERENUM,130,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
#define IOCTL_SERENUM_GET_PORT_NAME CTL_CODE(FILE_DEVICE_SERENUM,131,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
|
|
|
|
//
|
|
// The following values follow the escape designator in the
|
|
// data stream if the LSRMST_INSERT mode has been turned on.
|
|
//
|
|
#define SERIAL_LSRMST_ESCAPE ((BYTE )0x00)
|
|
|
|
//
|
|
// Following this value is the contents of the line status
|
|
// register, and then the character in the RX hardware when
|
|
// the line status register was encountered.
|
|
//
|
|
#define SERIAL_LSRMST_LSR_DATA ((BYTE )0x01)
|
|
|
|
//
|
|
// Following this value is the contents of the line status
|
|
// register. No error character follows
|
|
//
|
|
#define SERIAL_LSRMST_LSR_NODATA ((BYTE )0x02)
|
|
|
|
//
|
|
// Following this value is the contents of the modem status
|
|
// register.
|
|
//
|
|
#define SERIAL_LSRMST_MST ((BYTE )0x03)
|
|
|
|
//
|
|
// Bit values for FIFO Control Register
|
|
//
|
|
|
|
#define SERIAL_IOC_FCR_FIFO_ENABLE ((DWORD)0x00000001)
|
|
#define SERIAL_IOC_FCR_RCVR_RESET ((DWORD)0x00000002)
|
|
#define SERIAL_IOC_FCR_XMIT_RESET ((DWORD)0x00000004)
|
|
#define SERIAL_IOC_FCR_DMA_MODE ((DWORD)0x00000008)
|
|
#define SERIAL_IOC_FCR_RES1 ((DWORD)0x00000010)
|
|
#define SERIAL_IOC_FCR_RES2 ((DWORD)0x00000020)
|
|
#define SERIAL_IOC_FCR_RCVR_TRIGGER_LSB ((DWORD)0x00000040)
|
|
#define SERIAL_IOC_FCR_RCVR_TRIGGER_MSB ((DWORD)0x00000080)
|
|
|
|
//
|
|
// Bit values for Modem Control Register
|
|
//
|
|
|
|
#define SERIAL_IOC_MCR_DTR ((DWORD)0x00000001)
|
|
#define SERIAL_IOC_MCR_RTS ((DWORD)0x00000002)
|
|
#define SERIAL_IOC_MCR_OUT1 ((DWORD)0x00000004)
|
|
#define SERIAL_IOC_MCR_OUT2 ((DWORD)0x00000008)
|
|
#define SERIAL_IOC_MCR_LOOP ((DWORD)0x00000010)
|
|
|
|
#ifndef _FILESYSTEMFSCTL_
|
|
#define _FILESYSTEMFSCTL_
|
|
|
|
//
|
|
// The following is a list of the native file system fsctls followed by
|
|
// additional network file system fsctls. Some values have been
|
|
// decommissioned.
|
|
//
|
|
|
|
#define FSCTL_REQUEST_OPLOCK_LEVEL_1 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_REQUEST_OPLOCK_LEVEL_2 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_REQUEST_BATCH_OPLOCK CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_OPLOCK_BREAK_ACKNOWLEDGE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 3, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_OPBATCH_ACK_CLOSE_PENDING CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 4, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_OPLOCK_BREAK_NOTIFY CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 5, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_UNLOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_DISMOUNT_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
// decommissioned fsctl value 9
|
|
#define FSCTL_IS_VOLUME_MOUNTED CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 10, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_IS_PATHNAME_VALID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 11, METHOD_BUFFERED, FILE_ANY_ACCESS) // PATHNAME_BUFFER,
|
|
#define FSCTL_MARK_VOLUME_DIRTY CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
// decommissioned fsctl value 13
|
|
#define FSCTL_QUERY_RETRIEVAL_POINTERS CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 14, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#define FSCTL_GET_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 15, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_SET_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 16, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
|
|
// decommissioned fsctl value 17
|
|
// decommissioned fsctl value 18
|
|
#define FSCTL_MARK_AS_SYSTEM_HIVE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 19, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#define FSCTL_OPLOCK_BREAK_ACK_NO_2 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 20, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_INVALIDATE_VOLUMES CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 21, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_QUERY_FAT_BPB CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 22, METHOD_BUFFERED, FILE_ANY_ACCESS) // FSCTL_QUERY_FAT_BPB_BUFFER
|
|
#define FSCTL_REQUEST_FILTER_OPLOCK CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 23, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_FILESYSTEM_GET_STATISTICS CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 24, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILESYSTEM_STATISTICS
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
#define FSCTL_GET_NTFS_VOLUME_DATA CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 25, METHOD_BUFFERED, FILE_ANY_ACCESS) // NTFS_VOLUME_DATA_BUFFER
|
|
#define FSCTL_GET_NTFS_FILE_RECORD CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 26, METHOD_BUFFERED, FILE_ANY_ACCESS) // NTFS_FILE_RECORD_INPUT_BUFFER, NTFS_FILE_RECORD_OUTPUT_BUFFER
|
|
#define FSCTL_GET_VOLUME_BITMAP CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 27, METHOD_NEITHER, FILE_ANY_ACCESS) // STARTING_LCN_INPUT_BUFFER, VOLUME_BITMAP_BUFFER
|
|
#define FSCTL_GET_RETRIEVAL_POINTERS CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 28, METHOD_NEITHER, FILE_ANY_ACCESS) // STARTING_VCN_INPUT_BUFFER, RETRIEVAL_POINTERS_BUFFER
|
|
#define FSCTL_MOVE_FILE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 29, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // MOVE_FILE_DATA,
|
|
#define FSCTL_IS_VOLUME_DIRTY CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 30, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
// decomissioned fsctl value 31
|
|
#define FSCTL_ALLOW_EXTENDED_DASD_IO CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 32, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
// decommissioned fsctl value 33
|
|
// decommissioned fsctl value 34
|
|
#define FSCTL_FIND_FILES_BY_SID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 35, METHOD_NEITHER, FILE_ANY_ACCESS) // FIND_BY_SID_DATA, FIND_BY_SID_OUTPUT
|
|
// decommissioned fsctl value 36
|
|
// decommissioned fsctl value 37
|
|
#define FSCTL_SET_OBJECT_ID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 38, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // FILE_OBJECTID_BUFFER
|
|
#define FSCTL_GET_OBJECT_ID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 39, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILE_OBJECTID_BUFFER
|
|
#define FSCTL_DELETE_OBJECT_ID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 40, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
|
|
#define FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER,
|
|
#define FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
|
|
#define FSCTL_DELETE_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER,
|
|
#define FSCTL_ENUM_USN_DATA CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 44, METHOD_NEITHER, FILE_ANY_ACCESS) // MFT_ENUM_DATA,
|
|
#define FSCTL_SECURITY_ID_CHECK CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 45, METHOD_NEITHER, FILE_READ_DATA) // BULK_SECURITY_TEST_DATA,
|
|
#define FSCTL_READ_USN_JOURNAL CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 46, METHOD_NEITHER, FILE_ANY_ACCESS) // READ_USN_JOURNAL_DATA, USN
|
|
#define FSCTL_SET_OBJECT_ID_EXTENDED CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 47, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
|
|
#define FSCTL_CREATE_OR_GET_OBJECT_ID CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 48, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILE_OBJECTID_BUFFER
|
|
#define FSCTL_SET_SPARSE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
|
|
#define FSCTL_SET_ZERO_DATA CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 50, METHOD_BUFFERED, FILE_WRITE_DATA) // FILE_ZERO_DATA_INFORMATION,
|
|
#define FSCTL_QUERY_ALLOCATED_RANGES CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 51, METHOD_NEITHER, FILE_READ_DATA) // FILE_ALLOCATED_RANGE_BUFFER, FILE_ALLOCATED_RANGE_BUFFER
|
|
// decommissioned fsctl value 52
|
|
#define FSCTL_SET_ENCRYPTION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 53, METHOD_NEITHER, FILE_ANY_ACCESS) // ENCRYPTION_BUFFER, DECRYPTION_STATUS_BUFFER
|
|
#define FSCTL_ENCRYPTION_FSCTL_IO CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 54, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#define FSCTL_WRITE_RAW_ENCRYPTED CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 55, METHOD_NEITHER, FILE_SPECIAL_ACCESS) // ENCRYPTED_DATA_INFO,
|
|
#define FSCTL_READ_RAW_ENCRYPTED CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 56, METHOD_NEITHER, FILE_SPECIAL_ACCESS) // REQUEST_RAW_ENCRYPTED_DATA, ENCRYPTED_DATA_INFO
|
|
#define FSCTL_CREATE_USN_JOURNAL CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 57, METHOD_NEITHER, FILE_ANY_ACCESS) // CREATE_USN_JOURNAL_DATA,
|
|
#define FSCTL_READ_FILE_USN_DATA CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 58, METHOD_NEITHER, FILE_ANY_ACCESS) // Read the Usn Record for a file
|
|
#define FSCTL_WRITE_USN_CLOSE_RECORD CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 59, METHOD_NEITHER, FILE_ANY_ACCESS) // Generate Close Usn Record
|
|
#define FSCTL_EXTEND_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 60, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_QUERY_USN_JOURNAL CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 61, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_DELETE_USN_JOURNAL CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 62, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_MARK_HANDLE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 63, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_SIS_COPYFILE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 64, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_SIS_LINK_FILES CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 65, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
|
|
#define FSCTL_HSM_MSG CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 66, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
|
|
// decommissioned fsctl value 67
|
|
#define FSCTL_HSM_DATA CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 68, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
|
|
#define FSCTL_RECALL_FILE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 69, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
// decommissioned fsctl value 70
|
|
#define FSCTL_READ_FROM_PLEX CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 71, METHOD_OUT_DIRECT, FILE_READ_DATA)
|
|
#define FSCTL_FILE_PREFETCH CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 72, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // FILE_PREFETCH
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
//
|
|
// The following long list of structs are associated with the preceeding
|
|
// file system fsctls.
|
|
//
|
|
|
|
//
|
|
// Structure for FSCTL_IS_PATHNAME_VALID
|
|
//
|
|
|
|
typedef struct _PATHNAME_BUFFER {
|
|
|
|
DWORD PathNameLength;
|
|
WCHAR Name[1];
|
|
|
|
} PATHNAME_BUFFER, *PPATHNAME_BUFFER;
|
|
|
|
//
|
|
// Structure for FSCTL_QUERY_BPB_INFO
|
|
//
|
|
|
|
typedef struct _FSCTL_QUERY_FAT_BPB_BUFFER {
|
|
|
|
BYTE First0x24BytesOfBootSector[0x24];
|
|
|
|
} FSCTL_QUERY_FAT_BPB_BUFFER, *PFSCTL_QUERY_FAT_BPB_BUFFER;
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Structures for FSCTL_GET_NTFS_VOLUME_DATA.
|
|
// The user must pass the basic buffer below. Ntfs
|
|
// will return as many fields as available in the extended
|
|
// buffer which follows immediately after the VOLUME_DATA_BUFFER.
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER VolumeSerialNumber;
|
|
LARGE_INTEGER NumberSectors;
|
|
LARGE_INTEGER TotalClusters;
|
|
LARGE_INTEGER FreeClusters;
|
|
LARGE_INTEGER TotalReserved;
|
|
DWORD BytesPerSector;
|
|
DWORD BytesPerCluster;
|
|
DWORD BytesPerFileRecordSegment;
|
|
DWORD ClustersPerFileRecordSegment;
|
|
LARGE_INTEGER MftValidDataLength;
|
|
LARGE_INTEGER MftStartLcn;
|
|
LARGE_INTEGER Mft2StartLcn;
|
|
LARGE_INTEGER MftZoneStart;
|
|
LARGE_INTEGER MftZoneEnd;
|
|
|
|
} NTFS_VOLUME_DATA_BUFFER, *PNTFS_VOLUME_DATA_BUFFER;
|
|
|
|
typedef struct {
|
|
|
|
DWORD ByteCount;
|
|
|
|
WORD MajorVersion;
|
|
WORD MinorVersion;
|
|
|
|
} NTFS_EXTENDED_VOLUME_DATA, *PNTFS_EXTENDED_VOLUME_DATA;
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Structure for FSCTL_GET_VOLUME_BITMAP
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER StartingLcn;
|
|
|
|
} STARTING_LCN_INPUT_BUFFER, *PSTARTING_LCN_INPUT_BUFFER;
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER StartingLcn;
|
|
LARGE_INTEGER BitmapSize;
|
|
BYTE Buffer[1];
|
|
|
|
} VOLUME_BITMAP_BUFFER, *PVOLUME_BITMAP_BUFFER;
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Structure for FSCTL_GET_RETRIEVAL_POINTERS
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER StartingVcn;
|
|
|
|
} STARTING_VCN_INPUT_BUFFER, *PSTARTING_VCN_INPUT_BUFFER;
|
|
|
|
typedef struct RETRIEVAL_POINTERS_BUFFER {
|
|
|
|
DWORD ExtentCount;
|
|
LARGE_INTEGER StartingVcn;
|
|
struct {
|
|
LARGE_INTEGER NextVcn;
|
|
LARGE_INTEGER Lcn;
|
|
} Extents[1];
|
|
|
|
} RETRIEVAL_POINTERS_BUFFER, *PRETRIEVAL_POINTERS_BUFFER;
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Structures for FSCTL_GET_NTFS_FILE_RECORD
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER FileReferenceNumber;
|
|
|
|
} NTFS_FILE_RECORD_INPUT_BUFFER, *PNTFS_FILE_RECORD_INPUT_BUFFER;
|
|
|
|
typedef struct {
|
|
|
|
LARGE_INTEGER FileReferenceNumber;
|
|
DWORD FileRecordLength;
|
|
BYTE FileRecordBuffer[1];
|
|
|
|
} NTFS_FILE_RECORD_OUTPUT_BUFFER, *PNTFS_FILE_RECORD_OUTPUT_BUFFER;
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0400)
|
|
//
|
|
// Structure for FSCTL_MOVE_FILE
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
HANDLE FileHandle;
|
|
LARGE_INTEGER StartingVcn;
|
|
LARGE_INTEGER StartingLcn;
|
|
DWORD ClusterCount;
|
|
|
|
} MOVE_FILE_DATA, *PMOVE_FILE_DATA;
|
|
|
|
#if defined(_WIN64)
|
|
//
|
|
// 32/64 Bit thunking support structure
|
|
//
|
|
|
|
typedef struct _MOVE_FILE_DATA32 {
|
|
|
|
UINT32 FileHandle;
|
|
LARGE_INTEGER StartingVcn;
|
|
LARGE_INTEGER StartingLcn;
|
|
DWORD ClusterCount;
|
|
|
|
} MOVE_FILE_DATA32, *PMOVE_FILE_DATA32;
|
|
#endif
|
|
#endif /* _WIN32_WINNT >= 0x0400 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structures for FSCTL_FIND_FILES_BY_SID
|
|
//
|
|
|
|
typedef struct {
|
|
DWORD Restart;
|
|
SID Sid;
|
|
} FIND_BY_SID_DATA, *PFIND_BY_SID_DATA;
|
|
|
|
typedef struct {
|
|
DWORD NextEntryOffset;
|
|
DWORD FileIndex;
|
|
DWORD FileNameLength;
|
|
WCHAR FileName[1];
|
|
} FIND_BY_SID_OUTPUT, *PFIND_BY_SID_OUTPUT;
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// The following structures apply to Usn operations.
|
|
//
|
|
|
|
//
|
|
// Structure for FSCTL_ENUM_USN_DATA
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORDLONG StartFileReferenceNumber;
|
|
USN LowUsn;
|
|
USN HighUsn;
|
|
|
|
} MFT_ENUM_DATA, *PMFT_ENUM_DATA;
|
|
|
|
//
|
|
// Structure for FSCTL_CREATE_USN_JOURNAL
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORDLONG MaximumSize;
|
|
DWORDLONG AllocationDelta;
|
|
|
|
} CREATE_USN_JOURNAL_DATA, *PCREATE_USN_JOURNAL_DATA;
|
|
|
|
//
|
|
// Structure for FSCTL_READ_USN_JOURNAL
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
USN StartUsn;
|
|
DWORD ReasonMask;
|
|
DWORD ReturnOnlyOnClose;
|
|
DWORDLONG Timeout;
|
|
DWORDLONG BytesToWaitFor;
|
|
DWORDLONG UsnJournalID;
|
|
|
|
} READ_USN_JOURNAL_DATA, *PREAD_USN_JOURNAL_DATA;
|
|
|
|
//
|
|
// The initial Major.Minor version of the Usn record will be 2.0.
|
|
// In general, the MinorVersion may be changed if fields are added
|
|
// to this structure in such a way that the previous version of the
|
|
// software can still correctly the fields it knows about. The
|
|
// MajorVersion should only be changed if the previous version of
|
|
// any software using this structure would incorrectly handle new
|
|
// records due to structure changes.
|
|
//
|
|
// The first update to this will force the structure to version 2.0.
|
|
// This will add the extended information about the source as
|
|
// well as indicate the file name offset within the structure.
|
|
//
|
|
// The following structure is returned with these fsctls.
|
|
//
|
|
// FSCTL_READ_USN_JOURNAL
|
|
// FSCTL_READ_FILE_USN_DATA
|
|
// FSCTL_ENUM_USN_DATA
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORD RecordLength;
|
|
WORD MajorVersion;
|
|
WORD MinorVersion;
|
|
DWORDLONG FileReferenceNumber;
|
|
DWORDLONG ParentFileReferenceNumber;
|
|
USN Usn;
|
|
LARGE_INTEGER TimeStamp;
|
|
DWORD Reason;
|
|
DWORD SourceInfo;
|
|
DWORD SecurityId;
|
|
DWORD FileAttributes;
|
|
WORD FileNameLength;
|
|
WORD FileNameOffset;
|
|
WCHAR FileName[1];
|
|
|
|
} USN_RECORD, *PUSN_RECORD;
|
|
|
|
#define USN_PAGE_SIZE (0x1000)
|
|
|
|
#define USN_REASON_DATA_OVERWRITE (0x00000001)
|
|
#define USN_REASON_DATA_EXTEND (0x00000002)
|
|
#define USN_REASON_DATA_TRUNCATION (0x00000004)
|
|
#define USN_REASON_NAMED_DATA_OVERWRITE (0x00000010)
|
|
#define USN_REASON_NAMED_DATA_EXTEND (0x00000020)
|
|
#define USN_REASON_NAMED_DATA_TRUNCATION (0x00000040)
|
|
#define USN_REASON_FILE_CREATE (0x00000100)
|
|
#define USN_REASON_FILE_DELETE (0x00000200)
|
|
#define USN_REASON_EA_CHANGE (0x00000400)
|
|
#define USN_REASON_SECURITY_CHANGE (0x00000800)
|
|
#define USN_REASON_RENAME_OLD_NAME (0x00001000)
|
|
#define USN_REASON_RENAME_NEW_NAME (0x00002000)
|
|
#define USN_REASON_INDEXABLE_CHANGE (0x00004000)
|
|
#define USN_REASON_BASIC_INFO_CHANGE (0x00008000)
|
|
#define USN_REASON_HARD_LINK_CHANGE (0x00010000)
|
|
#define USN_REASON_COMPRESSION_CHANGE (0x00020000)
|
|
#define USN_REASON_ENCRYPTION_CHANGE (0x00040000)
|
|
#define USN_REASON_OBJECT_ID_CHANGE (0x00080000)
|
|
#define USN_REASON_REPARSE_POINT_CHANGE (0x00100000)
|
|
#define USN_REASON_STREAM_CHANGE (0x00200000)
|
|
|
|
#define USN_REASON_CLOSE (0x80000000)
|
|
|
|
//
|
|
// Structure for FSCTL_QUERY_USN_JOUNAL
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORDLONG UsnJournalID;
|
|
USN FirstUsn;
|
|
USN NextUsn;
|
|
USN LowestValidUsn;
|
|
USN MaxUsn;
|
|
DWORDLONG MaximumSize;
|
|
DWORDLONG AllocationDelta;
|
|
|
|
} USN_JOURNAL_DATA, *PUSN_JOURNAL_DATA;
|
|
|
|
//
|
|
// Structure for FSCTL_DELETE_USN_JOURNAL
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORDLONG UsnJournalID;
|
|
DWORD DeleteFlags;
|
|
|
|
} DELETE_USN_JOURNAL_DATA, *PDELETE_USN_JOURNAL_DATA;
|
|
|
|
#define USN_DELETE_FLAG_DELETE (0x00000001)
|
|
#define USN_DELETE_FLAG_NOTIFY (0x00000002)
|
|
|
|
#define USN_DELETE_VALID_FLAGS (0x00000003)
|
|
|
|
//
|
|
// Structure for FSCTL_MARK_HANDLE
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORD UsnSourceInfo;
|
|
HANDLE VolumeHandle;
|
|
DWORD HandleInfo;
|
|
|
|
} MARK_HANDLE_INFO, *PMARK_HANDLE_INFO;
|
|
|
|
#if defined(_WIN64)
|
|
//
|
|
// 32/64 Bit thunking support structure
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
DWORD UsnSourceInfo;
|
|
UINT32 VolumeHandle;
|
|
DWORD HandleInfo;
|
|
|
|
} MARK_HANDLE_INFO32, *PMARK_HANDLE_INFO32;
|
|
#endif
|
|
|
|
//
|
|
// Flags for the additional source information above.
|
|
//
|
|
// USN_SOURCE_DATA_MANAGEMENT - Service is not modifying the external view
|
|
// of any part of the file. Typical case is HSM moving data to
|
|
// and from external storage.
|
|
//
|
|
// USN_SOURCE_AUXILIARY_DATA - Service is not modifying the external view
|
|
// of the file with regard to the application that created this file.
|
|
// Can be used to add private data streams to a file.
|
|
//
|
|
// USN_SOURCE_REPLICATION_MANAGEMENT - Service is modifying a file to match
|
|
// the contents of the same file which exists in another member of the
|
|
// replica set.
|
|
//
|
|
|
|
#define USN_SOURCE_DATA_MANAGEMENT (0x00000001)
|
|
#define USN_SOURCE_AUXILIARY_DATA (0x00000002)
|
|
#define USN_SOURCE_REPLICATION_MANAGEMENT (0x00000004)
|
|
|
|
//
|
|
// Flags for the HandleInfo field above
|
|
//
|
|
// MARK_HANDLE_PROTECT_CLUSTERS - disallow any defragmenting (FSCTL_MOVE_FILE) until the
|
|
// the handle is closed
|
|
//
|
|
|
|
#define MARK_HANDLE_PROTECT_CLUSTERS (0x00000001)
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structure for FSCTL_SECURITY_ID_CHECK
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
ACCESS_MASK DesiredAccess;
|
|
DWORD SecurityIds[1];
|
|
|
|
} BULK_SECURITY_TEST_DATA, *PBULK_SECURITY_TEST_DATA;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Output flags for the FSCTL_IS_VOLUME_DIRTY
|
|
//
|
|
|
|
#define VOLUME_IS_DIRTY (0x00000001)
|
|
#define VOLUME_UPGRADE_SCHEDULED (0x00000002)
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
//
|
|
// Structures for FSCTL_FILE_PREFETCH
|
|
//
|
|
|
|
typedef struct _FILE_PREFETCH {
|
|
DWORD Type;
|
|
DWORD Count;
|
|
DWORDLONG Prefetch[1];
|
|
} FILE_PREFETCH, *PFILE_PREFETCH;
|
|
|
|
#define FILE_PREFETCH_TYPE_FOR_CREATE 0x1
|
|
|
|
// Structures for FSCTL_FILESYSTEM_GET_STATISTICS
|
|
//
|
|
// Filesystem performance counters
|
|
//
|
|
|
|
typedef struct _FILESYSTEM_STATISTICS {
|
|
|
|
WORD FileSystemType;
|
|
WORD Version; // currently version 1
|
|
|
|
DWORD SizeOfCompleteStructure; // must by a mutiple of 64 bytes
|
|
|
|
DWORD UserFileReads;
|
|
DWORD UserFileReadBytes;
|
|
DWORD UserDiskReads;
|
|
DWORD UserFileWrites;
|
|
DWORD UserFileWriteBytes;
|
|
DWORD UserDiskWrites;
|
|
|
|
DWORD MetaDataReads;
|
|
DWORD MetaDataReadBytes;
|
|
DWORD MetaDataDiskReads;
|
|
DWORD MetaDataWrites;
|
|
DWORD MetaDataWriteBytes;
|
|
DWORD MetaDataDiskWrites;
|
|
|
|
//
|
|
// The file system's private structure is appended here.
|
|
//
|
|
|
|
} FILESYSTEM_STATISTICS, *PFILESYSTEM_STATISTICS;
|
|
|
|
// values for FS_STATISTICS.FileSystemType
|
|
|
|
#define FILESYSTEM_STATISTICS_TYPE_NTFS 1
|
|
#define FILESYSTEM_STATISTICS_TYPE_FAT 2
|
|
|
|
//
|
|
// File System Specific Statistics Data
|
|
//
|
|
|
|
typedef struct _FAT_STATISTICS {
|
|
DWORD CreateHits;
|
|
DWORD SuccessfulCreates;
|
|
DWORD FailedCreates;
|
|
|
|
DWORD NonCachedReads;
|
|
DWORD NonCachedReadBytes;
|
|
DWORD NonCachedWrites;
|
|
DWORD NonCachedWriteBytes;
|
|
|
|
DWORD NonCachedDiskReads;
|
|
DWORD NonCachedDiskWrites;
|
|
} FAT_STATISTICS, *PFAT_STATISTICS;
|
|
|
|
typedef struct _NTFS_STATISTICS {
|
|
|
|
DWORD LogFileFullExceptions;
|
|
DWORD OtherExceptions;
|
|
|
|
//
|
|
// Other meta data io's
|
|
//
|
|
|
|
DWORD MftReads;
|
|
DWORD MftReadBytes;
|
|
DWORD MftWrites;
|
|
DWORD MftWriteBytes;
|
|
struct {
|
|
WORD Write;
|
|
WORD Create;
|
|
WORD SetInfo;
|
|
WORD Flush;
|
|
} MftWritesUserLevel;
|
|
|
|
WORD MftWritesFlushForLogFileFull;
|
|
WORD MftWritesLazyWriter;
|
|
WORD MftWritesUserRequest;
|
|
|
|
DWORD Mft2Writes;
|
|
DWORD Mft2WriteBytes;
|
|
struct {
|
|
WORD Write;
|
|
WORD Create;
|
|
WORD SetInfo;
|
|
WORD Flush;
|
|
} Mft2WritesUserLevel;
|
|
|
|
WORD Mft2WritesFlushForLogFileFull;
|
|
WORD Mft2WritesLazyWriter;
|
|
WORD Mft2WritesUserRequest;
|
|
|
|
DWORD RootIndexReads;
|
|
DWORD RootIndexReadBytes;
|
|
DWORD RootIndexWrites;
|
|
DWORD RootIndexWriteBytes;
|
|
|
|
DWORD BitmapReads;
|
|
DWORD BitmapReadBytes;
|
|
DWORD BitmapWrites;
|
|
DWORD BitmapWriteBytes;
|
|
|
|
WORD BitmapWritesFlushForLogFileFull;
|
|
WORD BitmapWritesLazyWriter;
|
|
WORD BitmapWritesUserRequest;
|
|
|
|
struct {
|
|
WORD Write;
|
|
WORD Create;
|
|
WORD SetInfo;
|
|
} BitmapWritesUserLevel;
|
|
|
|
DWORD MftBitmapReads;
|
|
DWORD MftBitmapReadBytes;
|
|
DWORD MftBitmapWrites;
|
|
DWORD MftBitmapWriteBytes;
|
|
|
|
WORD MftBitmapWritesFlushForLogFileFull;
|
|
WORD MftBitmapWritesLazyWriter;
|
|
WORD MftBitmapWritesUserRequest;
|
|
|
|
struct {
|
|
WORD Write;
|
|
WORD Create;
|
|
WORD SetInfo;
|
|
WORD Flush;
|
|
} MftBitmapWritesUserLevel;
|
|
|
|
DWORD UserIndexReads;
|
|
DWORD UserIndexReadBytes;
|
|
DWORD UserIndexWrites;
|
|
DWORD UserIndexWriteBytes;
|
|
|
|
//
|
|
// Additions for NT 5.0
|
|
//
|
|
|
|
DWORD LogFileReads;
|
|
DWORD LogFileReadBytes;
|
|
DWORD LogFileWrites;
|
|
DWORD LogFileWriteBytes;
|
|
|
|
struct {
|
|
DWORD Calls; // number of individual calls to allocate clusters
|
|
DWORD Clusters; // number of clusters allocated
|
|
DWORD Hints; // number of times a hint was specified
|
|
|
|
DWORD RunsReturned; // number of runs used to satisify all the requests
|
|
|
|
DWORD HintsHonored; // number of times the hint was useful
|
|
DWORD HintsClusters; // number of clusters allocated via the hint
|
|
DWORD Cache; // number of times the cache was useful other than the hint
|
|
DWORD CacheClusters; // number of clusters allocated via the cache other than the hint
|
|
DWORD CacheMiss; // number of times the cache wasn't useful
|
|
DWORD CacheMissClusters; // number of clusters allocated without the cache
|
|
} Allocate;
|
|
|
|
} NTFS_STATISTICS, *PNTFS_STATISTICS;
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structure for FSCTL_SET_OBJECT_ID, FSCTL_GET_OBJECT_ID, and FSCTL_CREATE_OR_GET_OBJECT_ID
|
|
//
|
|
|
|
#if _MSC_VER >= 1200
|
|
#pragma warning(push)
|
|
#endif
|
|
#pragma warning(disable:4201) // unnamed struct
|
|
|
|
typedef struct _FILE_OBJECTID_BUFFER {
|
|
|
|
//
|
|
// This is the portion of the object id that is indexed.
|
|
//
|
|
|
|
BYTE ObjectId[16];
|
|
|
|
//
|
|
// This portion of the object id is not indexed, it's just
|
|
// some metadata for the user's benefit.
|
|
//
|
|
|
|
union {
|
|
struct {
|
|
BYTE BirthVolumeId[16];
|
|
BYTE BirthObjectId[16];
|
|
BYTE DomainId[16];
|
|
} ;
|
|
BYTE ExtendedInfo[48];
|
|
};
|
|
|
|
} FILE_OBJECTID_BUFFER, *PFILE_OBJECTID_BUFFER;
|
|
|
|
#if _MSC_VER >= 1200
|
|
#pragma warning(pop)
|
|
#else
|
|
#pragma warning( default : 4201 )
|
|
#endif
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structure for FSCTL_SET_SPARSE
|
|
//
|
|
|
|
typedef struct _FILE_SET_SPARSE_BUFFER {
|
|
BOOLEAN SetSparse;
|
|
} FILE_SET_SPARSE_BUFFER, *PFILE_SET_SPARSE_BUFFER;
|
|
|
|
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structure for FSCTL_SET_ZERO_DATA
|
|
//
|
|
|
|
typedef struct _FILE_ZERO_DATA_INFORMATION {
|
|
|
|
LARGE_INTEGER FileOffset;
|
|
LARGE_INTEGER BeyondFinalZero;
|
|
|
|
} FILE_ZERO_DATA_INFORMATION, *PFILE_ZERO_DATA_INFORMATION;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structure for FSCTL_QUERY_ALLOCATED_RANGES
|
|
//
|
|
|
|
//
|
|
// Querying the allocated ranges requires an output buffer to store the
|
|
// allocated ranges and an input buffer to specify the range to query.
|
|
// The input buffer contains a single entry, the output buffer is an
|
|
// array of the following structure.
|
|
//
|
|
|
|
typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
|
|
|
|
LARGE_INTEGER FileOffset;
|
|
LARGE_INTEGER Length;
|
|
|
|
} FILE_ALLOCATED_RANGE_BUFFER, *PFILE_ALLOCATED_RANGE_BUFFER;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// Structures for FSCTL_SET_ENCRYPTION, FSCTL_WRITE_RAW_ENCRYPTED, and FSCTL_READ_RAW_ENCRYPTED
|
|
//
|
|
|
|
//
|
|
// The input buffer to set encryption indicates whether we are to encrypt/decrypt a file
|
|
// or an individual stream.
|
|
//
|
|
|
|
typedef struct _ENCRYPTION_BUFFER {
|
|
|
|
DWORD EncryptionOperation;
|
|
BYTE Private[1];
|
|
|
|
} ENCRYPTION_BUFFER, *PENCRYPTION_BUFFER;
|
|
|
|
#define FILE_SET_ENCRYPTION 0x00000001
|
|
#define FILE_CLEAR_ENCRYPTION 0x00000002
|
|
#define STREAM_SET_ENCRYPTION 0x00000003
|
|
#define STREAM_CLEAR_ENCRYPTION 0x00000004
|
|
|
|
#define MAXIMUM_ENCRYPTION_VALUE 0x00000004
|
|
|
|
//
|
|
// The optional output buffer to set encryption indicates that the last encrypted
|
|
// stream in a file has been marked as decrypted.
|
|
//
|
|
|
|
typedef struct _DECRYPTION_STATUS_BUFFER {
|
|
|
|
BOOLEAN NoEncryptedStreams;
|
|
|
|
} DECRYPTION_STATUS_BUFFER, *PDECRYPTION_STATUS_BUFFER;
|
|
|
|
#define ENCRYPTION_FORMAT_DEFAULT (0x01)
|
|
|
|
#define COMPRESSION_FORMAT_SPARSE (0x4000)
|
|
|
|
//
|
|
// Request Encrypted Data structure. This is used to indicate
|
|
// the range of the file to read. It also describes the
|
|
// output buffer used to return the data.
|
|
//
|
|
|
|
typedef struct _REQUEST_RAW_ENCRYPTED_DATA {
|
|
|
|
//
|
|
// Requested file offset and requested length to read.
|
|
// The fsctl will round the starting offset down
|
|
// to a file system boundary. It will also
|
|
// round the length up to a file system boundary.
|
|
//
|
|
|
|
LONGLONG FileOffset;
|
|
DWORD Length;
|
|
|
|
} REQUEST_RAW_ENCRYPTED_DATA, *PREQUEST_RAW_ENCRYPTED_DATA;
|
|
|
|
//
|
|
// Encrypted Data Information structure. This structure
|
|
// is used to return raw encrypted data from a file in
|
|
// order to perform off-line recovery. The data will be
|
|
// encrypted or encrypted and compressed. The off-line
|
|
// service will need to use the encryption and compression
|
|
// format information to recover the file data. In the
|
|
// event that the data is both encrypted and compressed then
|
|
// the decryption must occur before decompression. All
|
|
// the data units below must be encrypted and compressed
|
|
// with the same format.
|
|
//
|
|
// The data will be returned in units. The data unit size
|
|
// will be fixed per request. If the data is compressed
|
|
// then the data unit size will be the compression unit size.
|
|
//
|
|
// This structure is at the beginning of the buffer used to
|
|
// return the encrypted data. The actual raw bytes from
|
|
// the file will follow this buffer. The offset of the
|
|
// raw bytes from the beginning of this structure is
|
|
// specified in the REQUEST_RAW_ENCRYPTED_DATA structure
|
|
// described above.
|
|
//
|
|
|
|
typedef struct _ENCRYPTED_DATA_INFO {
|
|
|
|
//
|
|
// This is the file offset for the first entry in the
|
|
// data block array. The file system will round
|
|
// the requested start offset down to a boundary
|
|
// that is consistent with the format of the file.
|
|
//
|
|
|
|
DWORDLONG StartingFileOffset;
|
|
|
|
//
|
|
// Data offset in output buffer. The output buffer
|
|
// begins with an ENCRYPTED_DATA_INFO structure.
|
|
// The file system will then store the raw bytes from
|
|
// disk beginning at the following offset within the
|
|
// output buffer.
|
|
//
|
|
|
|
DWORD OutputBufferOffset;
|
|
|
|
//
|
|
// The number of bytes being returned that are within
|
|
// the size of the file. If this value is less than
|
|
// (NumberOfDataBlocks << DataUnitShift), it means the
|
|
// end of the file occurs within this transfer. Any
|
|
// data beyond file size is invalid and was never
|
|
// passed to the encryption driver.
|
|
//
|
|
|
|
DWORD BytesWithinFileSize;
|
|
|
|
//
|
|
// The number of bytes being returned that are below
|
|
// valid data length. If this value is less than
|
|
// (NumberOfDataBlocks << DataUnitShift), it means the
|
|
// end of the valid data occurs within this transfer.
|
|
// After decrypting the data from this transfer, any
|
|
// byte(s) beyond valid data length must be zeroed.
|
|
//
|
|
|
|
DWORD BytesWithinValidDataLength;
|
|
|
|
//
|
|
// Code for the compression format as defined in
|
|
// ntrtl.h. Note that COMPRESSION_FORMAT_NONE
|
|
// and COMPRESSION_FORMAT_DEFAULT are invalid if
|
|
// any of the described chunks are compressed.
|
|
//
|
|
|
|
WORD CompressionFormat;
|
|
|
|
//
|
|
// The DataUnit is the granularity used to access the
|
|
// disk. It will be the same as the compression unit
|
|
// size for a compressed file. For an uncompressed
|
|
// file, it will be some cluster-aligned power of 2 that
|
|
// the file system deems convenient. A caller should
|
|
// not expect that successive calls will have the
|
|
// same data unit shift value as the previous call.
|
|
//
|
|
// Since chunks and compression units are expected to be
|
|
// powers of 2 in size, we express them log2. So, for
|
|
// example (1 << ChunkShift) == ChunkSizeInBytes. The
|
|
// ClusterShift indicates how much space must be saved
|
|
// to successfully compress a compression unit - each
|
|
// successfully compressed data unit must occupy
|
|
// at least one cluster less in bytes than an uncompressed
|
|
// data block unit.
|
|
//
|
|
|
|
BYTE DataUnitShift;
|
|
BYTE ChunkShift;
|
|
BYTE ClusterShift;
|
|
|
|
//
|
|
// The format for the encryption.
|
|
//
|
|
|
|
BYTE EncryptionFormat;
|
|
|
|
//
|
|
// This is the number of entries in the data block size
|
|
// array.
|
|
//
|
|
|
|
WORD NumberOfDataBlocks;
|
|
|
|
//
|
|
// This is an array of sizes in the data block array. There
|
|
// must be one entry in this array for each data block
|
|
// read from disk. The size has a different meaning
|
|
// depending on whether the file is compressed.
|
|
//
|
|
// A size of zero always indicates that the final data consists entirely
|
|
// of zeroes. There is no decryption or decompression to
|
|
// perform.
|
|
//
|
|
// If the file is compressed then the data block size indicates
|
|
// whether this block is compressed. A size equal to
|
|
// the block size indicates that the corresponding block did
|
|
// not compress. Any other non-zero size indicates the
|
|
// size of the compressed data which needs to be
|
|
// decrypted/decompressed.
|
|
//
|
|
// If the file is not compressed then the data block size
|
|
// indicates the amount of data within the block that
|
|
// needs to be decrypted. Any other non-zero size indicates
|
|
// that the remaining bytes in the data unit within the file
|
|
// consists of zeros. An example of this is when the
|
|
// the read spans the valid data length of the file. There
|
|
// is no data to decrypt past the valid data length.
|
|
//
|
|
|
|
DWORD DataBlockSize[ANYSIZE_ARRAY];
|
|
|
|
} ENCRYPTED_DATA_INFO;
|
|
typedef ENCRYPTED_DATA_INFO *PENCRYPTED_DATA_INFO;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// FSCTL_READ_FROM_PLEX support
|
|
// Request Plex Read Data structure. This is used to indicate
|
|
// the range of the file to read. It also describes
|
|
// which plex to perform the read from.
|
|
//
|
|
|
|
typedef struct _PLEX_READ_DATA_REQUEST {
|
|
|
|
//
|
|
// Requested offset and length to read.
|
|
// The offset can be the virtual offset (vbo) in to a file,
|
|
// or a volume. In the case of a file offset,
|
|
// the fsd will round the starting offset down
|
|
// to a file system boundary. It will also
|
|
// round the length up to a file system boundary and
|
|
// enforce any other applicable limits.
|
|
//
|
|
|
|
LARGE_INTEGER ByteOffset;
|
|
DWORD ByteLength;
|
|
DWORD PlexNumber;
|
|
|
|
} PLEX_READ_DATA_REQUEST, *PPLEX_READ_DATA_REQUEST;
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#if(_WIN32_WINNT >= 0x0500)
|
|
//
|
|
// FSCTL_SIS_COPYFILE support
|
|
// Source and destination file names are passed in the FileNameBuffer.
|
|
// Both strings are null terminated, with the source name starting at
|
|
// the beginning of FileNameBuffer, and the destination name immediately
|
|
// following. Length fields include terminating nulls.
|
|
//
|
|
|
|
typedef struct _SI_COPYFILE {
|
|
DWORD SourceFileNameLength;
|
|
DWORD DestinationFileNameLength;
|
|
DWORD Flags;
|
|
WCHAR FileNameBuffer[1];
|
|
} SI_COPYFILE, *PSI_COPYFILE;
|
|
|
|
#define COPYFILE_SIS_LINK 0x0001 // Copy only if source is SIS
|
|
#define COPYFILE_SIS_REPLACE 0x0002 // Replace destination if it exists, otherwise don't.
|
|
#define COPYFILE_SIS_FLAGS 0x0003
|
|
#endif /* _WIN32_WINNT >= 0x0500 */
|
|
|
|
#endif // _FILESYSTEMFSCTL_
|
|
|
|
|
|
//
|
|
// These IOCTLs are handled by hard disk volumes.
|
|
//
|
|
|
|
#define IOCTL_VOLUME_BASE ((DWORD) 'V')
|
|
|
|
#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_VOLUME_IS_CLUSTERED CTL_CODE(IOCTL_VOLUME_BASE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// Disk extent definition.
|
|
//
|
|
|
|
typedef struct _DISK_EXTENT {
|
|
DWORD DiskNumber;
|
|
LARGE_INTEGER StartingOffset;
|
|
LARGE_INTEGER ExtentLength;
|
|
} DISK_EXTENT, *PDISK_EXTENT;
|
|
|
|
//
|
|
// Output structure for IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS.
|
|
//
|
|
|
|
typedef struct _VOLUME_DISK_EXTENTS {
|
|
DWORD NumberOfDiskExtents;
|
|
DISK_EXTENT Extents[1];
|
|
} VOLUME_DISK_EXTENTS, *PVOLUME_DISK_EXTENTS;
|
|
|
|
|
|
#endif // _WINIOCTL_
|
|
|