/packages/os2units/src/lvm.pas
Pascal | 5232 lines | 723 code | 189 blank | 4320 comment | 0 complexity | 28c7140800a34d5da5d8fd98da9400c0 MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, LGPL-3.0
- {
- Copyright (c) International Business Machines Corp., 2000
- Copyright (c) 2003 Yuri Prokushev
- This module defines the interface to LVM.DLL, which is the
- engine that performs all of the disk partitioning/volume
- creation work.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
- the GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- }
- Unit LVM;
- {$PACKRECORDS C}
- Interface
- {$ifdef os2}
- {$define lvm1}
- {$endif}
- {$ifdef linux}
- {$define lvm2}
- {$endif}
- // The number of bytes in a sector on the disk.
- const
- BYTES_PER_SECTOR=512;
- //The maximum number of cylinders, heads, and sectors that a partition table entry can accomodate.
- //Cylinders are numbered 0 - 1023, for a maximum of 1024 cylinders.
- //eads are numbered 0 - 255, for a maximum of 256 heads.
- //Sectors are numbered 1 - 63, for a maximum of 63 sectors per track.
- const
- MAX_CYLINDERS= 1024;
- MAX_HEADS = 256;
- MAX_SECTORS = 63;
- // The following define the values used to indicate that a partition table entry is for an EBR, not a partition.
- const
- EBR_BOOT_INDICATOR = 0;
- EBR_FORMAT_INDICATOR = 5;
- // The following define is used as the default Format_Indicator for new non-primary partitions.
- const
- NEW_LOGICAL_DRIVE_FORMAT_INDICATOR = $6;
- // The following define is used as the default Format_Indicator for a new non-active primary partitions.
- const
- NEW_PRIMARY_PARTITION_FORMAT_INDICATOR = $16;
- // The following define is used as the default Format_Indicator for a new active primary partition.
- const
- NEW_ACTIVE_PRIMARY_PARTITION_FORMAT_INDICATOR = $06;
- // The following define is used to hold the value of the Boot_Indicator for active partitions.
- const
- ACTIVE_PARTITION = $80;
- // Define the size of a Partition Name. Partition Names are user defined names given to a partition.
- const
- PARTITION_NAME_SIZE = 20;
- // Define the size of a volume name. Volume Names are user defined names given to a volume.
- const
- VOLUME_NAME_SIZE = 20;
- // Define the size of a disk name. Disk Names are user defined names given to physical disk drives in the system.
- const
- DISK_NAME_SIZE = 20;
- // The name of the filesystem in use on a partition. This name may be up to 12 ( + NULL terminator) characters long.
- const
- FILESYSTEM_NAME_SIZE = 20;
- // The comment field is reserved but is not currently used. This is for future expansion and use.
- const
- COMMENT_SIZE = 81;
- // Define the minimum number of sectors to reserve on the disk for Boot Manager.
- const
- BOOT_MANAGER_SIZE = 2048;
- // An INTEGER number is a whole number, either + or -.
- //The number appended to the INTEGER key word indicates the number of bits
- //used to represent an INTEGER of that type.
- type
- INTEGER16=SmallInt;
- INTEGER32=LongInt;
- INTEGER=LongInt;
- // A CARDINAL number is a positive integer >= 0.
- //The number appended to the CARDINAL key word indicates the number of bits
- //used to represent a CARDINAL of that type.
- type
- CARDINAL16=Word;
- CARDINAL32 = Cardinal;
- (*
- /* A REAL number is a floating point number. */
- typedef float REAL32;
- typedef double REAL64;
- *)
- REAL32 = double;
- REAL64 = double;
- // An ADDRESS variable is one which holds an address. The address can contain
- //anything, or even be invalid. It is just an address which is presumed to
- //hold some kind of data.
- Type
- ADDRESS=Pointer;
- Type
- pSTRING=PChar;
- // 4 bytes
- Type
- DoubleWord=Cardinal;
- //* The following types are used in the declaration of disk structures. Disk structures
- //have a defined size and internal structure which must be matched exactly. */
- //* 8 bytes. */
- type
- QuadWord=QWord;
- // The following types are used internally by LVM. */
- // Define a Partition Sector Number. A Partition Sector Number is relative to the start of a partition.
- //The first sector in a partition is PSN 0.
- type
- PSN=Cardinal;
- // Define a Logical Sector Number. A Logical Sector Number is relative to the start of a volume.
- //The first sector in a volume is LSN 0.
- type
- LSN=Cardinal;
- // Define a Logical Block Address. A Logical Block Address is relative to the start of a
- //physical device - a disk drive. The first sector on a disk drive is LBA 0.
- type
- LBA=Cardinal;
- // The following define sets the maximum number of LVM classes for which structures and storage will be reserved.
- const
- MAXIMUM_LVM_CLASSES = 3;
- // The following enum defines the various LVM classes to which a "feature" may belong.
- // An LVM Plugin is used to implement a "feature", so "plugin" and "feature" are really synonyms.
- type
- _LVM_Classes = (
- Partition_Class, // For "features" which must operate on a partition level - i.e. Bad Block Relocation.
- Aggregate_Class, // For "features" which combine partitions into a single logical entity - i.e. Drive Linking.
- Volume_Class // For "features" which operate best on a volume level - i.e. encryption, mirroring etc.
- );
- LVM_Classes = _LVM_Classes;
- // An LVM plugin may belong to one or more classes. For each class to which it belongs, certain attributes must be defined.
- //This structure tracks those attributes for a class.
- type
- _LVM_Class_Attributes=record
- ClassMember: BOOLEAN; // TRUE if a member of this class, FALSE otherwise.
- GlobalExclusive: BOOLEAN; // TRUE if this plugin can not work with any other plugin - i.e. it
- //must be the only "feature" on the volume, besides the built in feature of BBR.
- TopExclusive: BOOLEAN; // TRUE if this plugin must be the topmost plugin in this class.
- BottomExclusive: BOOLEAN; // TRUE if this plugin must be the bottommost plugin in this class.
- ClassExclusive: BOOLEAN; // TRUE if this plugin will not work with any other plugin in this class.
- Weight_Factor: CARDINAL32; // A value between 1 and 100 which is used to guide the LVM interfaces when attempting to
- //establish a default ordering for plugins within this class. A value of 1
- //indicates that this plugin wants to be as close to the bottom of the plugins
- //in this class as possible. A value of 100 means that this plugin wants to
- //be as close to being the topmost plugin in this class as possible. This value
- //is only used if none of the "exclusive" flags are set.
- end;
- LVM_Class_Attributes=_LVM_Class_Attributes;
- // The following enum specifies the interface types that LVM supports, and hence any plugin must support.
- _LVM_Interface_Types= (
- PM_Interface,
- VIO_Interface, // LVM.EXE is a VIO app. since it is used during install, and during recovery scenarios where PM/Java may not be available.
- Java_Interface // The LVM GUI is written in Java.
- );
- LVM_Interface_Types=_LVM_Interface_Types;
- const
- MAXIMUM_LVM_INTERFACE_TYPES = 3;
- //* The following structures define what functions must be supported for each interface type.
- type
- PADDRESS=^ADDRESS;
- PCARDINAL32=^CARDINAL32;
- _LVM_OS2_Native_Support=record
- //void (* _System Create_and_Configure) ( CARDINAL32 ID, ADDRESS InputBuffer, CARDINAL32 InputBufferSize, ADDRESS * OutputBuffer, CARDINAL32 * OutputBufferSize, CARDINAL32 * Error_Code);
- Create_and_Configure: procedure(ID: CARDINAL32; InputBuffer: ADDRESS; InputBufferSize: CARDINAL32; OutputBuffer: PADDRESS; OutputBufferSize: PCARDINAL32; Error_Code: PCARDINAL32);
- //void (* _System Display_Status) ( ADDRESS Volume_Handle, CARDINAL32 * Error_Code );
- Display_Status: procedure(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32 );
- //void (* _System Control_Panel) (ADDRESS Volume_Handle, CARDINAL32 * Error_Code );
- Control_Panel: procedure(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32 );
- //void (* _System Help_Panel) (CARDINAL32 Help_Index, CARDINAL32 * Error_Code);
- Help_Panel: procedure(Help_Index: CARDINAL32; Error_Code: PCARDINAL32);
- end;
- LVM_OS2_Native_Support=_LVM_OS2_Native_Support;
- type
- _LVM_Interface_Support=record
- Interface_Supported: BOOLEAN;
- case longint of
- 0 : ( Java_Interface_Class : ^char );
- 1 : ( VIO_PM_Calls : LVM_OS2_Native_Support );
- end;
- LVM_Interface_Support=_LVM_Interface_Support;
- //* The following define the default help indicies which must be supported by the Help_Panel function. NOTE: Index
- //values from 0 to 100 are reserved by LVM. The Plugin may, for its own use, use any values above 100.
- const
- HELP_PLUGIN_DESCRIPTION = 0;
- // The following define the maximum length of the names which can be used to represent a feature in LVM. The
- //maximum name length for a feature is 30 characters plus the trailing NULL character. For command line parsing,
- //though, a shorter name is preferable! Thus, the "short" name for a feature will be limited to 10 characters
- //plus the trailing NULL character. The "short" name will be used for command line purposes, while the regular
- //name will be used by all other interfaces.
- const
- MAX_FEATURE_NAME_LENGTH = 31;
- MAX_FEATURE_SHORT_NAME_LENGTH = 11;
- MAX_OEM_INFO_LENGTH =255;
- // The following definitions are used to control and access the various "features" available through the LVM Engine, such as Drive Linking and BBR.
- type
- _Feature_ID_Data=record
- Name: Array[0..MAX_FEATURE_NAME_LENGTH-1] of char; // Feature Name, for use in menus and command line parsing.
- Short_Name: Array[0..MAX_FEATURE_SHORT_NAME_LENGTH-1] of char; // The name/code used to represent this feature during command line parsing.
- OEM_Info: Array[0..MAX_OEM_INFO_LENGTH-1] of char; // Name and copyright info. of the manufacturer, i.e. IBM, Vinca, etc.
- ID: CARDINAL32; // Numeric Feature ID.
- Major_Version_Number: CARDINAL32; // The version number of this feature.
- Minor_Version_Number: CARDINAL32; // The version number of this feature.
- LVM_Major_Version_Number: CARDINAL32; // The version of LVM that this feature was designed to work with.
- LVM_Minor_Version_Number: CARDINAL32; // The version of LVM that this feature was designed to work with.
- Preferred_Class: LVM_Classes; // The class from which this "feature" prefers to be chosen. Encryption can be performed
- //at the partition level or the volume level, and may therefore belong to both the
- //Partition_Class and the Volume_Class. However, it is preferrable for it to be used
- //on the volume level instead of at the partition level. Thus, its perferred class would
- //be the Volume_Class, but it would still be a member of both the Volume_Class and the
- //Partition_Class.
- ClassData: Array[0..MAXIMUM_LVM_CLASSES-1] of LVM_Class_Attributes; // The attributes for each of the LVM classes that this "feature" is in.
- Interface_Support: Array[0..MAXIMUM_LVM_INTERFACE_TYPES-1] of LVM_Interface_Support; // The functions and classes for each of the video modes that LVM can run it.
- end;
- Feature_ID_Data=_Feature_ID_Data;
- // The following defines the TAG value used to identify an item of type Feature_ID_Data in a DLIST.
- const
- FEATURE_ID_DATA_TAG = 354385972;
- // The following are invariant for a disk drive.
- Type
- Drive_Control_Record = record
- Drive_Number: CARDINAL32; // OS/2 Drive Number for this drive.
- Drive_Size: CARDINAL32; // The total number of sectors on the drive.
- Drive_Serial_Number: DoubleWord; // The serial number assigned to this drive. For info. purposes only.
- Drive_Handle: ADDRESS; // Handle used for operations on the disk that this record corresponds to.
- Cylinder_Count: CARDINAL32; // The number of cylinders on the drive.
- Heads_Per_Cylinder: CARDINAL32; // The number of heads per cylinder for this drive.
- Sectors_Per_Track: CARDINAL32; // The number of sectors per track for this drive.
- Drive_Is_PRM: BOOLEAN; // Set to TRUE if this drive is a PRM.
- Reserved: Array[0..3-1] of BYTE; // Alignment.
- end;
- // The following structure is returned by the Get_Drive_Control_Data function.
- Drive_Control_Array=record
- Drive_Control_Data: ^Drive_Control_Record; // An array of drive control records.
- Count: CARDINAL32; // The number of entries in the array of drive control records.
- end;
- // The following structure defines the information that can be changed for a specific disk drive.
- Drive_Information_Record=record
- Total_Available_Sectors: CARDINAL32; // The number of sectors on the disk which are not currently assigned to a partition.
- Largest_Free_Block_Of_Sectors: CARDINAL32; // The number of sectors in the largest contiguous block of available sectors.
- Corrupt_Partition_Table: BOOLEAN; // If TRUE, then the partitioning information found on the drive is incorrect!
- Unusable: BOOLEAN; // If TRUE, the drive's MBR is not accessible and the drive can not be partitioned.
- IO_Error: BOOLEAN; // If TRUE, then the last I/O operation on this drive failed!
- Is_Big_Floppy: BOOLEAN; // If TRUE, then the drive is a PRM formatted as a big floppy (i.e. the old style removable media support).
- Drive_Name: Array[0..DISK_NAME_SIZE-1] of Char; // User assigned name for this disk drive.
- end;
- Partition_Information_Record=record
- Partition_Handle: ADDRESS; // The handle used to perform operations on this partition.
- Volume_Handle: ADDRESS; // If this partition is part of a volume, this will be the handle of
- //the volume. If this partition is NOT part of a volume, then this
- //handle will be 0.
- Drive_Handle: ADDRESS; // The handle for the drive this partition resides on.
- Partition_Serial_Number: DoubleWord; // The serial number assigned to this partition.
- Partition_Start: CARDINAL32; // The LBA of the first sector of the partition.
- True_Partition_Size: CARDINAL32; // The total number of sectors comprising the partition.
- Usable_Partition_Size: CARDINAL32; // The size of the partition as reported to the IFSM. This is the
- //size of the partition less any LVM overhead.
- Boot_Limit: CARDINAL32; // The maximum number of sectors from this block of free space that can be used to
- //create a bootable partition if you allocate from the beginning of the block of
- //free space.
- Spanned_Volume: BOOLEAN; // TRUE if this partition is part of a multi-partition volume.
- Primary_Partition: BOOLEAN; // True or False. Any non-zero value here indicates that
- //this partition is a primary partition. Zero here indicates
- //that this partition is a "logical drive" - i.e. it resides
- //inside of an extended partition.
- Active_Flag: BYTE; // 80 = Partition is marked as being active.
- // 0 = Partition is not active.
- OS_Flag: BYTE; // This field is from the partition table. It is known as the
- //OS flag, the Partition Type Field, Filesystem Type, and
- //various other names.
- //Values of interest
- //If this field is: (values are in hex)
- //07 = The partition is a compatibility partition formatted for use
- //with an installable filesystem, such as HPFS or JFS.
- //00 = Unformatted partition
- //01 = FAT12 filesystem is in use on this partition.
- //04 = FAT16 filesystem is in use on this partition.
- //0A = OS/2 Boot Manager Partition
- //35 = LVM partition
- //84 = OS/2 FAT16 partition which has been relabeled by Boot Manager to "Hide" it.
- Partition_Type: BYTE; // 0 = Free Space
- //1 = LVM Partition (Part of an LVM Volume.)
- //2 = Compatibility Partition
- //All other values are reserved for future use.
- Partition_Status: BYTE; // 0 = Free Space
- //1 = In Use - i.e. already assigned to a volume.
- //2 = Available - i.e. not currently assigned to a volume.
- On_Boot_Manager_Menu: BOOLEAN; // Set to TRUE if this partition is not part of a Volume yet is on the Boot Manager Menu.
- Reserved: BYTE; // Alignment.
- Volume_Drive_Letter: char; // The drive letter assigned to the volume that this partition is a part of.
- Drive_Name: Array[0..DISK_NAME_SIZE-1] of char; // User assigned name for this disk drive.
- File_System_Name: Array[0..FILESYSTEM_NAME_SIZE-1] of char;// The name of the filesystem in use on this partition, if it is known.
- Partition_Name: Array[0..PARTITION_NAME_SIZE-1] of char; // The user assigned name for this partition.
- Volume_Name: Array[0..VOLUME_NAME_SIZE-1] of char; // If this partition is part of a volume, then this will be the
- //name of the volume that this partition is a part of. If this
- //record represents free space, then the Volume_Name will be
- //"FREE SPACE xx", where xx is a unique numeric ID generated by
- //LVM.DLL. Otherwise it will be an empty string.
- end;
- // The following defines are for use with the Partition_Type field in the Partition_Information_Record.
- const
- pt_FREE_SPACE_PARTITION = 0;
- pt_LVM_PARTITION = 1;
- pt_COMPATIBILITY_PARTITION = 2;
- // The following defines are for use with the Partition_Status field in the Partition_Information_Record.
- const
- PARTITION_IS_IN_USE = 1;
- PARTITION_IS_AVAILABLE = 2;
- PARTITION_IS_FREE_SPACE = 0;
- // The following structure is returned by various functions in the LVM Engine.
- type
- Partition_Information_Array=record
- Partition_Array: ^Partition_Information_Record; // An array of Partition_Information_Records.
- Count: CARDINAL32; // The number of entries in the Partition_Array.
- end;
- // The following items are invariant for a volume.
- type
- Volume_Control_Record=record
- Volume_Serial_Number: DoubleWord; // The serial number assigned to this volume.
- Volume_Handle: ADDRESS; // The handle used to perform operations on this volume.
- Compatibility_Volume: BOOLEAN; // TRUE indicates that this volume is compatible with older versions of OS/2.
- //FALSE indicates that this is an LVM specific volume and can not be used without OS2LVM.DMD.
- Device_Type: BYTE; // Indicates what type of device the Volume resides on:
- //0 = Hard Drive under LVM Control
- //1 = PRM under LVM Control
- //2 = CD-ROM
- //3 = Network drive
- //4 = Unknown device NOT under LVM Control
- Reserved: Array[0..2-1] of BYTE; // Alignment.
- end;
- // The following define the device types used in the Device_Type field of the Volume_Control_Record.
- const
- LVM_HARD_DRIVE = 0;
- LVM_PRM = 1;
- NON_LVM_CDROM = 2;
- NETWORK_DRIVE = 3;
- NON_LVM_DEVICE = 4;
- // The following structure is returned by the Get_Volume_Control_Data function.
- type
- Volume_Control_Array=record
- Volume_Control_Data: ^Volume_Control_Record; // An array of volume control records.
- Count: CARDINAL32; // The number of entries in the array of volume control records.
- end;
- // The following information about a volume can (and often does) vary.
- type
- Volume_Information_Record=record
- Volume_Size: CARDINAL32; // The number of sectors comprising the volume.
- Partition_Count: CARDINAL32; // The number of partitions which comprise this volume.
- Drive_Letter_Conflict: CARDINAL32; // 0 indicates that the drive letter preference for this volume is unique.
- //1 indicates that the drive letter preference for this volume
- //is not unique, but this volume got its preferred drive letter anyway.
- //2 indicates that the drive letter preference for this volume
- //is not unique, and this volume did NOT get its preferred drive letter.
- //4 indicates that this volume is currently "hidden" - i.e. it has
- //no drive letter preference at the current time.
- Compatibility_Volume: BOOLEAN; // TRUE if this is for a compatibility volume, FALSE otherwise.
- Bootable: BOOLEAN; // Set to TRUE if this volume appears on the Boot Manager menu, or if it is
- //a compatibility volume and its corresponding partition is the first active
- //primary partition on the first drive.
- Drive_Letter_Preference: char; // The drive letter that this volume desires to be.
- Current_Drive_Letter: char; // The drive letter currently used to access this volume. May be different than
- //Drive_Letter_Preference if there was a conflict ( i.e. Drive_Letter_Preference
- //is already in use by another volume ).
- Initial_Drive_Letter: char; // The drive letter assigned to this volume by the operating system when LVM was started.
- //This may be different from the Drive_Letter_Preference if there were conflicts, and
- //may be different from the Current_Drive_Letter. This will be 0x0 if the Volume did
- //not exist when the LVM Engine was opened (i.e. it was created during this LVM session).
- New_Volume: BOOLEAN; // Set to FALSE if this volume existed before the LVM Engine was opened. Set to
- //TRUE if this volume was created after the LVM Engine was opened.
- Status: BYTE; // 0 = None.
- //1 = Bootable
- //2 = Startable
- //3 = Installable.
- Reserved_1: BYTE;
- Volume_Name: Array[0..VOLUME_NAME_SIZE-1] of char; // The user assigned name for this volume.
- File_System_Name: Array[0..FILESYSTEM_NAME_SIZE-1] of char;// The name of the filesystem in use on this partition, if it is known.
- end;
- // The following structure is used to return the feature information for the installed features, or the features on a volume.
- type
- Feature_Information_Array=record
- Count: CARDINAL32;
- Feature_Data: ^Feature_ID_Data;
- end;
- // The following structure defines an item on the Boot Manager Menu.
- type
- Boot_Manager_Menu_Item=record
- Handle: ADDRESS; // A Volume or Partition handle.
- Volume: BOOLEAN; // If TRUE, then Handle is the handle of a Volume. Otherwise, Handle is the handle of a partition.
- end;
- // The following structure is used to get a list of the items on the partition manager menu.
- type
- Boot_Manager_Menu=record
- Menu_Items: ^Boot_Manager_Menu_Item;
- Count: CARDINAL32;
- end;
- // The following structure is used to specify an LVM Feature when creating a volume. Since LVM Features may be part of
- //more than one LVM Class, the specific class to be used with the feature must also be specified.
- type
- LVM_Feature_Specification_Record=record
- Feature_ID: CARDINAL32; // The feature ID of the feature to use.
- Actual_Class: LVM_Classes; // The LVM Class (supported by the specified feature) to use.
- Init_Data: ADDRESS; // The address of a buffer containing initialization data for this feature.
- //NULL if there is no initialization data being provided for this feature.
- end;
- // The following structure is used with the Get_Child_Handles function.
- Type
- LVM_Handle_Array_Record=record
- Count: CARDINAL32;
- Handles: ^ADDRESS;
- end;
- // The following preprocessor directives define the operations that can be performed on a partition, volume, or a block of free space.
- // These definitions represent bits in a 32 bit value returned by the Get_Valid_Options function.
- const
- CREATE_PRIMARY_PARTITION = 1;
- CREATE_LOGICAL_DRIVE = 2;
- DELETEPARTITION = 4;
- SET_ACTIVE_PRIMARY = 8;
- SET_PARTITION_ACTIVE = $10;
- SET_PARTITION_INACTIVE = $20;
- SETSTARTABLE = $40;
- INSTALLBOOTMANAGER = $80;
- REMOVEBOOTMANAGER = $100;
- SET_BOOT_MANAGER_DEFAULTS = $200;
- ADD_TO_BOOT_MANAGER_MENU = $400;
- REMOVE_FROM_BOOT_MANAGER_MENU = $800;
- DELETEVOLUME = $1000;
- HIDEVOLUME = $2000;
- EXPANDVOLUME = $4000;
- SET_VOLUME_INSTALLABLE = $8000;
- ASSIGNDRIVELETTER = $10000;
- CAN_BOOT_PRIMARY = $20000; // If a primary is created from this block of free space, then it can be made bootable.
- CAN_BOOT_LOGICAL = $40000; // If a logical drive is created from this block of free space, then OS/2 can boot from it by adding it to the boot manager menu.
- CAN_SET_NAME = $80000;
- SET_BOOT_MANAGER_STARTABLE = $100000;
- // The following enumeration defines the allocation strategies used by the Create_Partition function.
- type
- _Allocation_Algorithm =(
- Automatic, // Let LVM decide which block of free space to use to create the partition.
- Best_Fit, // Use the block of free space which is closest in size to the partition being created.
- First_Fit, // Use the first block of free space on the disk which is large enough to hold a partition of the specified size.
- Last_Fit, // Use the last block of free space on the disk which is large enough to hold a partition of the specified size.
- From_Largest, // Find the largest block of free space and allocate the partition from that block of free space.
- From_Smallest, // Find the smallest block of free space that can accommodate a partition of the size specified.
- All // Turn the specified drive or block of free space into a single partition.
- );
- Allocation_Algorithm=_Allocation_Algorithm;
- // Error codes returned by the LVM Engine.
- const
- LVM_ENGINE_NO_ERROR = 0;
- LVM_ENGINE_OUT_OF_MEMORY = 1;
- LVM_ENGINE_IO_ERROR = 2;
- LVM_ENGINE_BAD_HANDLE = 3;
- LVM_ENGINE_INTERNAL_ERROR = 4;
- LVM_ENGINE_ALREADY_OPEN = 5;
- LVM_ENGINE_NOT_OPEN = 6;
- LVM_ENGINE_NAME_TOO_BIG = 7;
- LVM_ENGINE_OPERATION_NOT_ALLOWED = 8;
- LVM_ENGINE_DRIVE_OPEN_FAILURE = 9;
- LVM_ENGINE_BAD_PARTITION = 10;
- LVM_ENGINE_CAN_NOT_MAKE_PRIMARY_PARTITION = 11;
- LVM_ENGINE_TOO_MANY_PRIMARY_PARTITIONS = 12;
- LVM_ENGINE_CAN_NOT_MAKE_LOGICAL_DRIVE = 13;
- LVM_ENGINE_REQUESTED_SIZE_TOO_BIG = 14;
- LVM_ENGINE_1024_CYLINDER_LIMIT = 15;
- LVM_ENGINE_PARTITION_ALIGNMENT_ERROR = 16;
- LVM_ENGINE_REQUESTED_SIZE_TOO_SMALL = 17;
- LVM_ENGINE_NOT_ENOUGH_FREE_SPACE = 18;
- LVM_ENGINE_BAD_ALLOCATION_ALGORITHM = 19;
- LVM_ENGINE_DUPLICATE_NAME = 20;
- LVM_ENGINE_BAD_NAME = 21;
- LVM_ENGINE_BAD_DRIVE_LETTER_PREFERENCE = 22;
- LVM_ENGINE_NO_DRIVES_FOUND = 23;
- LVM_ENGINE_WRONG_VOLUME_TYPE = 24;
- LVM_ENGINE_VOLUME_TOO_SMALL = 25;
- LVM_ENGINE_BOOT_MANAGER_ALREADY_INSTALLED = 26;
- LVM_ENGINE_BOOT_MANAGER_NOT_FOUND = 27;
- LVM_ENGINE_INVALID_PARAMETER = 28;
- LVM_ENGINE_BAD_FEATURE_SET = 29;
- LVM_ENGINE_TOO_MANY_PARTITIONS_SPECIFIED = 30;
- LVM_ENGINE_LVM_PARTITIONS_NOT_BOOTABLE = 31;
- LVM_ENGINE_PARTITION_ALREADY_IN_USE = 32;
- LVM_ENGINE_SELECTED_PARTITION_NOT_BOOTABLE = 33;
- LVM_ENGINE_VOLUME_NOT_FOUND = 34;
- LVM_ENGINE_DRIVE_NOT_FOUND = 35;
- LVM_ENGINE_PARTITION_NOT_FOUND = 36;
- LVM_ENGINE_TOO_MANY_FEATURES_ACTIVE = 37;
- LVM_ENGINE_PARTITION_TOO_SMALL = 38;
- LVM_ENGINE_MAX_PARTITIONS_ALREADY_IN_USE = 39;
- LVM_ENGINE_IO_REQUEST_OUT_OF_RANGE = 40;
- LVM_ENGINE_SPECIFIED_PARTITION_NOT_STARTABLE = 41;
- LVM_ENGINE_SELECTED_VOLUME_NOT_STARTABLE = 42;
- LVM_ENGINE_EXTENDFS_FAILED = 43;
- LVM_ENGINE_REBOOT_REQUIRED = 44;
- LVM_ENGINE_CAN_NOT_OPEN_LOG_FILE = 45;
- LVM_ENGINE_CAN_NOT_WRITE_TO_LOG_FILE = 46;
- LVM_ENGINE_REDISCOVER_FAILED = 47;
- LVM_ENGINE_INTERNAL_VERSION_FAILURE = 48;
- LVM_ENGINE_PLUGIN_OPERATION_INCOMPLETE = 49;
- LVM_ENGINE_BAD_FEATURE_ID = 50;
- LVM_ENGINE_NO_INIT_DATA = 51;
- LVM_ENGINE_NO_CONTEXT_DATA = 52;
- LVM_ENGINE_WRONG_CLASS_FOR_FEATURE = 53;
- LVM_ENGINE_INCOMPATIBLE_FEATURES_SELECTED = 54;
- LVM_ENGINE_NO_CHILDREN = 55;
- LVM_ENGINE_FEATURE_NOT_SUPPORTED_BY_INTERFACE= 56;
- LVM_ENGINE_NO_PARENT = 57;
- LVM_ENGINE_VOLUME_HAS_NOT_BEEN_COMMITTED_YET = 58;
- LVM_ENGINE_UNABLE_TO_REFERENCE_VOLUME = 59;
- LVM_ENGINE_PARSING_ERROR = 60;
- LVM_ENGINE_INTERNAL_FEATURE_ERROR = 61;
- LVM_ENGINE_VOLUME_NOT_CONVERTED = 62;
- // The following definitions are used for command line processing. As the command line is processed,
- //the command line is first broken up into tokens. Each token has a "characterization", which indicates
- //what the token is thought to be.
- type
- Token_Characterizations=(
- LVM_AcceptableCharsStr,
- LVM_All,
- LVM_BestFit,
- LVM_BootDOS,
- LVM_BootOS2,
- LVM_Bootable,
- LVM_CR,
- LVM_CRI,
- LVM_Compatibility,
- LVM_Drive,
- LVM_Existing,
- LVM_Expand,
- LVM_FS,
- LVM_FirstFit,
- LVM_Freespace,
- LVM_FromEnd,
- LVM_FromLargest,
- LVM_FromSmallest,
- LVM_FromStart,
- LVM_LVM,
- LVM_LastFit,
- LVM_Logical,
- LVM_New,
- LVM_NoBoot,
- LVM_NonBootable,
- LVM_NotBootable,
- LVM_Partition,
- LVM_Primary,
- LVM_RB,
- LVM_Size,
- LVM_Unusable,
- LVM_Unused,
- LVM_Volume,
- LVM_Volumes,
- LVM_Comma,
- LVM_Number,
- LVM_Colon,
- LVM_Space,
- LVM_Tab,
- LVM_MultiSpace,
- LVM_MultiTab,
- LVM_String,
- LVM_FileNameStr,
- LVM_SemiColon,
- LVM_Eof,
- LVM_Separator,
- LVM_Open_Paren, //* ( */
- LVM_Close_Paren, //* ) */
- LVM_Open_Bracket, //* [ */
- LVM_Close_Bracket, //* ] */
- LVM_Open_Brace, //* { */
- LVM_Close_Brace, //* } */
- LVM_EQ_Sign, //* = */
- LVM_Bootmgr,
- LVM_Create,
- LVM_Delete,
- LVM_DriveLetter,
- LVM_File,
- LVM_Hide,
- LVM_Install,
- LVM_NewMBR,
- LVM_Query,
- LVM_RediscoverPRM,
- LVM_SetName,
- LVM_SetStartable,
- LVM_SI,
- LVM_SlashSize,
- LVM_StartLog
- );
- type
- _LVM_Token=record
- TokenText: PChar; // The actual text of the token.
- TokenType: Token_Characterizations; // What the token is thought to be.
- Position: CARDINAL32; // The position of the first character of the token on the command line.
- end;
- LVM_Token=_LVM_Token;
- const
- LVM_TOKEN_TAG = 28387473;
- // Function Prototypes
- //***************************************************************************
- //
- // Functions relating to the LVM Engine itself
- //
- //***************************************************************************
- //****************************************************************************************************/
- //* */
- //* Function Name: Open_LVM_Engine */
- //* */
- //* Descriptive Name: Opens the LVM Engine and readies it for use. */
- //* */
- //* Input: BOOLEAN Ignore_CHS : If TRUE, then the LVM engine will not check the CHS values in the */
- //* MBR/EBR partition tables for validity. This is useful if there */
- //* are drive geometry problems, such as the drive was partitioned and */
- //* formatted with one geometry and then moved to a different machine */
- //* which uses a different geometry for the drive. This would cause */
- //* the starting and ending CHS values in the partition tables to */
- //* be inconsistent with the size and partition offset entries in the */
- //* partition tables. Setting Ignore_CHS to TRUE will disable the */
- //* LVM Engine's CHS consistency checks, thereby allowing the drive */
- //* to be partitioned. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if this function completes successfully. If an error occurs, */
- //* *Error_Code will contain a non-zero error code. */
- //* */
- //* Error Handling: If this function aborts with an error, all memory allocated during the course */
- //* of this function will be released. Disk read errors will be reported to the */
- //* user via pop-up error messages. Disk read errors will only cause this */
- //* function to abort if none of the disk drives in the system could be */
- //* successfully read. */
- //* */
- //* Side Effects: The LVM Engine will be initialized. The partition tables for all OS2DASD */
- //* controlled disk drives will be read into memory. Memory will be allocated for */
- //* the data structures used by the LVM Engine. */
- //* */
- //* Notes: This is provided for programs that used LVM Version 1. This function assumes an */
- //* LVM_Interface_Type of VIO_Interface. */
- //* */
- //****************************************************************************************************/
- procedure Open_LVM_Engine(Ignore_CHS: BOOLEAN; Error_Code: PCARDINAL32); external 'lvm' name 'Open_LVM_Engine';
- //****************************************************************************************************/
- //* */
- //* Function Name: Open_LVM_Engine2 */
- //* */
- //* Descriptive Name: Opens the LVM Engine and readies it for use. */
- //* */
- //* Input: BOOLEAN Ignore_CHS : If TRUE, then the LVM engine will not check the CHS values in the */
- //* MBR/EBR partition tables for validity. This is useful if there */
- //* are drive geometry problems, such as the drive was partitioned and */
- //* formatted with one geometry and then moved to a different machine */
- //* which uses a different geometry for the drive. This would cause */
- //* the starting and ending CHS values in the partition tables to */
- //* be inconsistent with the size and partition offset entries in the */
- //* partition tables. Setting Ignore_CHS to TRUE will disable the */
- //* LVM Engine's CHS consistency checks, thereby allowing the drive */
- //* to be partitioned. */
- //* LVM_Interface_Types Interface_Type - Indicate the type of user interface being used: */
- //* PM_Interface, VIO_Interface, or Java_Interface. This lets the */
- //* LVM Engine know which interface support routines to call in any */
- //* plugin modules which may be loaded. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if this function completes successfully. If an error occurs, */
- //* *Error_Code will contain a non-zero error code. */
- //* */
- //* Error Handling: If this function aborts with an error, all memory allocated during the course */
- //* of this function will be released. Disk read errors will be reported to the */
- //* user via pop-up error messages. Disk read errors will only cause this */
- //* function to abort if none of the disk drives in the system could be */
- //* successfully read. */
- //* */
- //* Side Effects: The LVM Engine will be initialized. The partition tables for all OS2DASD */
- //* controlled disk drives will be read into memory. Memory will be allocated for */
- //* the data structures used by the LVM Engine. */
- //* */
- //* Notes: New in LVM Version 2 */
- //* */
- //****************************************************************************************************/
- {$ifdef lvm2}
- procedure Open_LVM_Engine2(Ignore_CHS: BOOLEAN; Interface_Type: LVM_Interface_Types; Error_Code: PCARDINAL32); external 'lvm' name 'Open_LVM_Engine2';
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Commit_Changes */
- //* */
- //* Descriptive Name: Saves any changes made to the partitioning */
- //* information of the OS2DASD controlled disk */
- //* drives in the system. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: The function return value will be TRUE if all of the */
- //* partitioning/volume changes made were successfully */
- //* written to disk. Also, *Error_Code will be 0 if no */
- //* errors occur. */
- //* */
- //* If an error occurs, then the furnction return value */
- //* will be FALSE and *Error_Code will contain a non-zero */
- //* error code. */
- //* */
- //* Error Handling: If an error occurs, the function return value */
- //* will be false and *Error_Code will be > 0. */
- //* */
- //* Disk read and write errors will be indicated by*/
- //* setting the IO_Error field of the */
- //* Drive_Information_Record to TRUE. Thus, if */
- //* the function return value is FALSE, and */
- //* *Error_Code indicates an I/O error, the caller */
- //* of this function should call the */
- //* Get_Drive_Status function on each drive to */
- //* determine which drives had I/O errors. */
- //* */
- //* If a read or write error occurs, then the */
- //* engine may not have been able to create a */
- //* partition or volume. Thus, the caller */
- //* may want to refresh all partition and volume */
- //* data to see what the engine was and was not */
- //* able to create. */
- //* */
- //* Side Effects: The partitioning information of the disk drives */
- //* in the system may be altered. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Commit_Changes(Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Commit_Changes';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Java_Call_Back */
- //* */
- //* Descriptive Name: This function allows the calling Java program */
- //* to set the call back address. The call back */
- //* address is used when the LVM Engine or one of */
- //* its plug-ins, needs to run a Java class to */
- //* gather information from the user. */
- //* */
- //* Input: void ( * Execute_Java_Class) ... - The address of a */
- //* function that the LVM */
- //* engine may call when */
- //* it needs a Java class */
- //* to be executed. This */
- //* is only required if the*/
- //* user interface being */
- //* used is written in Java*/
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If the function completes successfully, then *Error_Code*/
- //* will be set to LVM_ENGINE_NO_ERROR. Otherwise, */
- //* *Error_Code will be set to a non-zero error code. */
- //* */
- //* Error Handling: If an error occurs, the function will abort and*/
- //* *Error_Code will be set to a non-zero error */
- //* code. */
- //* */
- //* Side Effects: The Java call back address is set to point to the*/
- //* specified function. Once the Java call back */
- //* address is set, LVM plug-ins which require the */
- //* Java call back will be enabled and can be used */
- //* during the creation of LVM Volumes. */
- //* */
- //* Notes: If a Java interface is in use (as specified on the */
- //* Open_LVM_Engine call), then this function must be called*/
- //* in order to enable those LVM plug-ins which require */
- //* initialization information during the creation of an */
- //* LVM Volume. If these plug-ins are not enabled, then */
- //* they will not be reported by the Get_Available_Features */
- //* API, nor can they be used or accessed by any other LVM */
- //* Engine APIs. Thus, this function should be called */
- //* immediately after the Open_LVM_Engine API is called. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- type
- TJavaExecProc=procedure(
- Class_Name: PChar;
- InputBuffer: ADDRESS;
- InputBufferSize: CARDINAL32;
- OutputBuffer: PADDRESS;
- OutputBufferSize,
- Error_Code: PCARDINAL32);
- procedure Set_Java_Call_Back(
- Execute_Java_Class: TJAvaExecProc;
- Error_Code: PCARDINAL32); external 'lvm' name 'Set_Java_Call_Back';
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Close_LVM_Engine */
- //* */
- //* Descriptive Name: Closes the LVM Engine and frees any memory */
- //* held by the LVM Engine. */
- //* */
- //* Input: None. */
- //* */
- //* Output: None. */
- //* */
- //* Error Handling: N/A */
- //* */
- //* Side Effects: Any memory held by the LVM Engine is released. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Close_LVM_Engine; external 'lvm' name 'Close_LVM_Engine';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Available_Features */
- //* */
- //* Descriptive Name: Returns the feature ID information for each of*/
- //* the features that the LVM Engine knows about. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If successful, a Feature_Information_Array structure is */
- //* returned with a non-zero Count. Also, *Error_Code will */
- //* be set to LVM_ENGINE_NO_ERROR. If an error occurs, */
- //* then the Count field in the structure will be 0 and */
- //* ( *Error_Code) will contain a non-zero error code. */
- //* */
- //* Error Handling: The only expected error is if this function is */
- //* called while the LVM Engine is not open. This */
- //* should be the only error condition. */
- //* */
- //* Side Effects: Memory is allocated using the LVM Engine's memory*/
- //* manager for the array of Feature_ID_Data items */
- //* being returned. */
- //* */
- //* Notes: This function seems to be presented since LVM Version 2 */
- //* */
- //*********************************************************************/
- {$ifdef LVM2}
- function Get_Available_Features(Error_Code: PCARDINAL32): Feature_Information_Array; external 'lvm' name 'Get_Available_Features';
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Issue_Feature_Command */
- //* */
- //* Descriptive Name: Issues a feature specific command to either */
- //* the Ring 0 or Ring 3 portion of the feature. */
- //* */
- //* Input: CARDINAL32 Feature_ID - The numeric ID assigned to the */
- //* feature which is to receive the */
- //* command being issued. */
- //* ADDRESS Handle - The handle of the volume, partition, or */
- //* aggregate to which the feature command */
- //* is to be directed. */
- //* BOOLEAN Ring0 - If TRUE, then the command will be sent */
- //* to the Ring 0 portion of the feature. */
- //* If FALSE, then the command will be sent */
- //* to the Ring 3 portion of the feature. */
- //* ADDRESS InputBuffer - A buffer containing the command and*/
- //* any necessary information for the */
- //* feature to process the command. */
- //* CARDINAL32 InputSize - The number of bytes in the */
- //* InputBuffer. */
- //* ADDRESS * OutputBuffer - The address of a variable used */
- //* to hold the location of the */
- //* output buffer created by the */
- //* feature in response to the */
- //* command in InputBuffer. */
- //* CARDINAL32 * OutputSize - The address of a variable used */
- //* to hold the number of bytes in */
- //* *OutputBuffer. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If successful, then *Error_Code will be set to */
- //* LVM_ENGINE_NO_ERROR. If unsuccessful, then *Error_Code */
- //* will be set to a non-zero error code. *OutputBuffer and*/
- //* *OutputSize are set by the feature. If the feature */
- //* specified does not exist, then *OutputBuffer will be */
- //* NULL and *Outputsize will be 0. If the feature does */
- //* exist, then the value of *OutputBuffer and *OutputSize */
- //* depend upon the feature. */
- //* */
- //* Error Handling: If the specified feature does not exist, then */
- //* *Error_Code will contain a non-zero error code, */
- //* *OutputBuffer will be NULL, and *OutputSize will*/
- //* be set to 0. All other error conditions are */
- //* feature dependent. */
- //* */
- //* Side Effects: Side effects are feature dependent. */
- //* */
- //* Notes: New in LVM Version 2 */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- void _System Issue_Feature_Command( CARDINAL32 Feature_ID,
- ADDRESS Handle,
- BOOLEAN Ring0,
- ADDRESS InputBuffer,
- CARDINAL32 InputSize,
- ADDRESS * OutputBuffer,
- CARDINAL32 * OutputSize,
- CARDINAL32 * Error_Code );
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Parse_Feature_Parameters */
- //* */
- //* Descriptive Name: This function allows access to the parsing */
- //* function of an LVM Plug-in Feature. The */
- //* specified feature will be passed a list of */
- //* tokens to parse, and, if it parses the tokens */
- //* successfully, will produce a buffer containing*/
- //* initialization data that can be used with the */
- //* Create_Volume API. If it encounters an error,*/
- //* the current item in the Tokens list will be */
- //* the offending item, and a pointer to an error */
- //* message will be returned. */
- //* */
- //* Input: DLIST Tokens - A DLIST of tokens to parse. Parsing will*/
- //* begin with the current entry in the list */
- //* and proceed until there is an error or */
- //* until the specified feature has found a */
- //* complete command. Each feature defines */
- //* what commands it will accept. */
- //* LVM_Feature_Specification_Record * Feature_Data - A */
- //* pointer to a record which contains the */
- //* ID of the feature which is to parse the */
- //* DLIST of Tokens. The other fields in */
- //* this record will be filled in by the */
- //* feature if it successfully parses the */
- //* tokens. */
- //* char ** Error_Message - The address of a pointer to char.*/
- //* This will be set to NULL if the feature */
- //* successfully parses the list of tokens, */
- //* or it will be set to point to an error */
- //* message if an error occurs. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 */
- //* variable into which an error code may */
- //* be placed. The error code will be */
- //* LVM_ENGINE_NO_ERROR if this function */
- //* completes successfully, or a non-zero */
- //* error code if an error occurs. */
- //* */
- //* Output: If there are no errors, the Actual_Class and Init_Data */
- //* fields of *Feature_Data will be set, *Error_Message will*/
- //* be set to NULL, and Error_Code will be set to */
- //* LVM_ENGINE_NO_ERROR. The current item in the Tokens */
- //* list will be the first token that was not parsed by the */
- //* feature (i.e. the first token after the command accepted*/
- //* by the plug-in). */
- //* */
- //* If an error occurs, the values of Actual_Class and */
- //* Init_Data in *Feature_Data are undefined. *Error_Code */
- //* will be set to LVM_ENGINE_PARSING_ERROR if the error is */
- //* parsing related, or some other non-zero value if the */
- //* error is not parsing related. If the error is parsing */
- //* related, then *Error_Message will point to an error */
- //* message which can be displayed for the user. The */
- //* current item in the Tokens list will be the token which */
- //* failed. */
- //* */
- //* Error Handling: If an parsing related error occurs, i.e. the */
- //* tokens in the Tokens list do not form a valid */
- //* command accepted by the specified feature, then */
- //* the current item in the Tokens list will be the */
- //* offending token, *Error_Message will be set to */
- //* point to an error message, and *Error_Code will */
- //* be set to LVM_ENGINE_PARSING_ERROR. */
- //* If any other error occurs, the current item in */
- //* the Tokens list will be the token that was being*/
- //* processed when the error occurs, and *Error_Code*/
- //* will be set to a non-zero value. */
- //* */
- //* Side Effects: The current item in the Tokens list may change. */
- //* */
- //* Notes: Each feature defines which commands it will accept, and */
- //* therefore which commands it will successfully parse. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- void _System Parse_Feature_Parameters( DLIST Tokens,
- LVM_Feature_Specification_Record * Feature_Data,
- char ** Error_Message,
- CARDINAL32 * Error_Code);
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Refresh_LVM_Engine */
- //* */
- //* Descriptive Name: This function causes the LVM Engine to look */
- //* for changes in the current system */
- //* configuration and update its internal tables */
- //* accordingly. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: None. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be set to */
- //* a non-zero value. */
- //* */
- //* Side Effects: Volumes which represent non-LVM devices may have */
- //* their handles changed! */
- //* */
- //* Notes: After calling this function, Get_Volume_Control_Data */
- //* should be called to get the updated list of volumes. */
- //* This is necessary as the handles of some volumes may */
- //* have changed. */
- //* */
- //*********************************************************************/
- procedure Refresh_LVM_Engine(Error_Code: PCARDINAL32); external 'lvm' name 'Refresh_LVM_Engine';
- //****************************************************************************
- //
- // Functions relating to Drives
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Get_Drive_Control_Data */
- //* */
- //* Descriptive Name: This function returns an array of */
- //* Drive_Control_Records. These records provide*/
- //* important information about the drives in the*/
- //* system and provide the handles required to */
- //* access them. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: A Drive_Control_Array structure is returned. If no */
- //* errors occur, Drive_Control_Data will be non-NULL, */
- //* Count will be greater than zero, and *Error_Code will */
- //* be 0. */
- //* */
- //* Error Handling: If an error occurs, the Drive_Control_Array */
- //* returned by this function will have NULL for */
- //* Drive_Control_Data, and 0 for Count. */
- //* *Error_Code will be greater than 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The caller becomes responsible for the memory allocated */
- //* for the array of Drive_Control_Records pointed to by */
- //* Drive_Control_Data pointer in the Drive_Control_Array */
- //* structure returned by this function. The caller should */
- //* free this memory when they are done using it. */
- //* */
- //*********************************************************************/
- function Get_Drive_Control_Data(Error_Code: PCARDINAL32): Drive_Control_Array; external 'lvm' name 'Get_Drive_Control_Data';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Drive_Status */
- //* */
- //* Descriptive Name: Returns the Drive_Information_Record for the */
- //* drive specified by Drive_Handle. */
- //* */
- //* Input: ADDRESS Drive_Handle - The handle of the drive to use. */
- //* Drive handles are obtained through the*/
- //* Get_Drive_Control_Data function. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: This function returns the Drive_Information_Record for */
- //* the drive associated with the specified Drive_Handle. */
- //* If no errors occur, *Error_Code will be set to 0. If an*/
- //* error does occur, then *Error_Code will be non-zero. */
- //* */
- //* Error Handling: If an error occurs, then *Error_Code will be */
- //* non-zero. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Drive_Status(Drive_Handle: ADDRESS; Error_Code: PCARDINAL32): Drive_Information_Record; external 'lvm' name 'Get_Drive_Status';
- //****************************************************************************
- //
- // Functions relating to Partitions
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Get_Partitions */
- //* */
- //* Descriptive Name: Returns an array of partitions associated */
- //* with the object specified by Handle. */
- //* */
- //* Input:ADDRESS Handle - This is the handle of a drive or volume. */
- //* Drive handles are obtained through the */
- //* Get_Drive_Control_Data function. Volume */
- //* handles are obtained through the */
- //* Get_Volume_Control_Data function. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: This function returns a structure. The structure has */
- //* two components: an array of partition information */
- //* records and the number of entries in the array. If */
- //* Handle is the handle of a disk drive, then the returned */
- //* array will contain a partition information record for */
- //* each partition and block of free space on that drive. */
- //* If Handle is the handle of a volume, then the returned */
- //* array will contain a partition information record for */
- //* each partition which is part of the specified volume. */
- //* If no errors occur, then *Error_Code will be 0. If an */
- //* error does occur, then *Error_Code will be non-zero. */
- //* */
- //* Error Handling: Any memory allocated for the return value will */
- //* be freed. The Partition_Information_Array */
- //* returned by this function will contain a NULL */
- //* pointer for Partition_Array, and have a Count of*/
- //* 0. *Error_Code will be non-zero. */
- //* */
- //* If Handle is non-NULL and is invalid, a trap */
- //* is likely. */
- //* */
- //* Side Effects: Memory will be allocated to hold the array */
- //* returned by this function. */
- //* */
- //* Notes: The caller becomes responsible for the memory allocated */
- //* for the array of Partition_Information_Records pointed */
- //* to by Partition_Array pointer in the */
- //* Partition_Information_Array structure returned by this */
- //* function. The caller should free this memory when they */
- //* are done using it. */
- //* */
- //*********************************************************************/
- function Get_Partitions(Handle: ADDRESS; Error_Code: PCARDINAL32): Partition_Information_Array; external 'lvm' name 'Get_Partitions';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Partition_Handle */
- //* */
- //* Descriptive Name: Returns the handle of the partition whose */
- //* serial number matches the one provided. */
- //* */
- //* Input: CARDINAL32 Serial_Number - This is the serial number to */
- //* look for. If a partition with*/
- //* a matching serial number is */
- //* found, its handle will be */
- //* returned. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If a partition with a matching serial number is found, */
- //* then the function return value will be the handle */
- //* of the partition found. If no matching partition is */
- //* found, then the function return value will be NULL. */
- //* */
- //* Error Handling: If no errors occur, *Error_Code will be */
- //* LVM_ENGINE_NO_ERROR. If an error occurs, then */
- //* *Error_Code will be a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Partition_Handle(Serial_Number: CARDINAL32; Error_Code: PCARDINAL32): ADDRESS; external 'lvm' name 'Get_Partition_Handle';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Partition_Information */
- //* */
- //* Descriptive Name: Returns the Partition_Information_Record for */
- //* the partition specified by Partition_Handle. */
- //* */
- //* Input: ADDRESS Partition_Handle - The handle associated with the*/
- //* partition for which the */
- //* Partition_Information_Record */
- //* is desired. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: A Partition_Information_Record is returned. If there */
- //* is no error, then *Error_Code will be 0. If an error */
- //* occurs, *Error_Code will be non-zero. */
- //* */
- //* Error Handling: If the Partition_Handle is not a valid handle, */
- //* a trap could result. If it is a handle for */
- //* something other than a partition, an error code*/
- //* will be returned in *Error_Code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Partition_Information(Partition_Handle: ADDRESS; Error_Code: PCARDINAL32): Partition_Information_Record; external 'lvm' name 'Get_Partition_Information';
- //*********************************************************************/
- //* */
- //* Function Name: Create_Partition */
- //* */
- //* Descriptive Name: Creates a partition on a disk drive. */
- //* */
- //* Input: ADDRESS Handle - The handle of a disk drive or */
- //* a block of free space. */
- //* CARDINAL32 Size - The size, in sectors, of the */
- //* partition to create. */
- //* char Name[] - The name to give to the newly */
- //* created partition. */
- //* Allocation_Algorithm algorithm - If Handle is a drive, */
- //* then the engine will */
- //* find a block of free */
- //* space to use to create */
- //* the partition. This */
- //* tells the engine which */
- //* memory management */
- //* algorithm to use. */
- //* BOOLEAN Bootable - If TRUE, then the engine will */
- //* only create the partition if */
- //* it can be booted from. If */
- //* Primary_Partition is FALSE, */
- //* then it is assumed that OS/2 */
- //* is the operating system that */
- //* will be booted. */
- //* BOOLEAN Primary_Partition - If TRUE, then the */
- //* engine will create */
- //* a primary partition. */
- //* If FALSE, then the */
- //* engine will create a */
- //* logical drive. */
- //* BOOLEAN Allocate_From_Start - If TRUE, then the */
- //* engine will */
- //* allocate the new */
- //* partition from the */
- //* beginning of the */
- //* selected block of */
- //* free space. If */
- //* FALSE, then the */
- //* partition will be */
- //* allocated from the */
- //* end of the selected*/
- //* block of free */
- //* space. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: The function return value will be the handle of the */
- //* partition created. If the partition could not be */
- //* created, then NULL will be returned. */
- //* *Error_Code will be 0 if the partition was created. */
- //* *Error_Code will be > 0 if the partition could not be */
- //* created. */
- //* */
- //* Error Handling: If the partition can not be created, then any */
- //* memory allocated by this function will be */
- //* freed and the partitioning of the disk in */
- //* question will be unchanged. */
- //* */
- //* If Handle is not a valid handle, then a trap */
- //* may result. */
- //* */
- //* If Handle represents a partition or volume, */
- //* then the function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: A partition may be created on a disk drive. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- type
- TPartitionName=Array[0..PARTITION_NAME_SIZE-1] of char;
- function Create_Partition(Handle: ADDRESS;
- Size: CARDINAL32;
- Name: TPartitionName;
- algorithm: Allocation_Algorithm;
- Bootable: BOOLEAN;
- Primary_Partition: BOOLEAN;
- Allocate_From_Start: BOOLEAN;
- Error_Code: PCARDINAL32
- ): ADDRESS; external 'lvm' name 'Create_Partition';
- //*********************************************************************/
- //* */
- //* Function Name: Delete_Partition */
- //* */
- //* Descriptive Name: Deletes the partition specified by */
- //* Partition_Handle. */
- //* */
- //* Input: ADDRESS Partition_Handle - The handle associated with the*/
- //* partition to be deleted. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the partition was deleted */
- //* successfully. *Error_Code will be > 0 if the partition */
- //* could not be deleted. */
- //* */
- //* Error Handling: If the partition can not be deleted, then */
- //* *Error_Code will be > 0. */
- //* */
- //* If Partition_Handle is not a valid handle, a */
- //* trap may result. */
- //* */
- //* If Partition_Handle is a volume or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: A partition on a disk drive may be deleted. */
- //* */
- //* Notes: A partition can not be deleted if it is part of a */
- //* volume! */
- //* */
- //*********************************************************************/
- procedure Delete_Partition(Partition_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Delete_Partition';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Active_Flag */
- //* */
- //* Descriptive Name: Sets the Active Flag field for a partition. */
- //* */
- //* Input: ADDRESS Partition_Handle - The handle of the partition */
- //* whose Active Flag is to be set*/
- //* BYTE Active_Flag - The new value for the Active Flag. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the Active Flag was */
- //* successfully set, otherwise *Error_Code will contain a */
- //* non-zero error code indicating what went wrong. */
- //* */
- //* Error Handling: If the Active Flag can not be set, this function*/
- //* will abort without changing any disk structures.*/
- //* */
- //* If Partition_Handle is not a valid handle, a */
- //* trap may result. */
- //* */
- //* If Partition_Handle is a volume or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* */
- //* Side Effects: The Active Flag for a partition may be modified. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Active_Flag(Partition_Handle: ADDRESS;
- Active_Flag: BYTE;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Set_Active_Flag';
- //*********************************************************************/
- //* */
- //* Function Name: Set_OS_Flag */
- //* */
- //* Descriptive Name: Sets the OS Flag field for a partition. This */
- //* field is typically used to indicate the */
- //* filesystem used on the partition, which */
- //* generally gives an indication of which OS is */
- //* using that partition. */
- //* */
- //* Input: ADDRESS Partition_Handle - The handle of the partition */
- //* whose Active Flag is to be set*/
- //* BYTE OS_Flag - The new value for the OS Flag. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the OS Flag was successfully */
- //* set, otherwise *Error_Code will contain a non-zero error*/
- //* code indicating what went wrong. */
- //* */
- //* Error Handling: If the OS Flag can not be set, this function */
- //* will abort without changing any disk structures.*/
- //* */
- //* If Partition_Handle is not a valid handle, a */
- //* trap may result. */
- //* */
- //* If Partition_Handle is a volume or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* */
- //* Side Effects: The OS Flag for a partition may be modified. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_OS_Flag(Partition_Handle: ADDRESS;
- OS_Flag: BYTE;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Set_OS_Flag';
- //****************************************************************************
- //
- // Functions relating to Volumes
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Get_Volume_Control_Data */
- //* */
- //* Descriptive Name: This function returns a structure containing */
- //* an array of Volume_Control_Records. These */
- //* records contain information about volumes */
- //* which is invariant - i.e. will not change for */
- //* as long as the volume exists. One of the */
- //* items in the Volume_Control_Record is the */
- //* handle for the volume. This handle must be */
- //* used on all accesses to the volume. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: A Volume_Control_Array structure is returned. */
- //* */
- //* If there are no errors, then the Volume_Control_Data */
- //* pointer in the Volume_Control_Array will be non-NULL, */
- //* the Count field of the Volume_Control_Array will be */
- //* >= 0, and *Error_Code will be 0. */
- //* */
- //* If an error does occur, then the Volume_Control_Data */
- //* pointer in the the Volume_Control_Array will be NULL, */
- //* the Count field of the Volume_Control_Array will be 0, */
- //* and *Error_Code will be > 0. */
- //* */
- //* Error Handling: If an error occurs, then any memory allocated by*/
- //* this function will be freed. */
- //* */
- //* Side Effects: Memory for the returned array is allocated. */
- //* */
- //* Notes: The caller becomes responsible for the memory allocated */
- //* for the array of Volume_Control_Records pointed to by */
- //* Volume_Control_Data pointer in the Volume_Control_Array */
- //* structure returned by this function. The caller should */
- //* free this memory when they are done using it. */
- //* */
- //*********************************************************************/
- function Get_Volume_Control_Data(Error_Code: PCARDINAL32): Volume_Control_Array; external 'lvm' name 'Get_Volume_Control_Data';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Volume_Information */
- //* */
- //* Descriptive Name: This function returns the */
- //* Volume_Information_Record for the volume */
- //* associated with Volume_Handle. */
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume about */
- //* which information is desired. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: This function returns a Volume_Information_Record. */
- //* */
- //* If this function is successful, then *Error_Code will be*/
- //* 0. */
- //* */
- //* If this function fails, then *Error_Code will be > 0. */
- //* */
- //* Error Handling: If Volume_Handle is not a valid handle, a trap */
- //* will be likely. If Volume_Handle is a drive or*/
- //* partition handle, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Volume_Information(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32): Volume_Information_Record; external 'lvm' name 'Get_Volume_Information';
- //*********************************************************************/
- //* */
- //* Function Name: Create_Volume */
- //* */
- //* Descriptive Name: This function creates a volume from a list of*/
- //* partitions. The partitions are specified by */
- //* their corresponding handles. */
- //* */
- //* Input: char Name[] - The name to assign to the newly */
- //* created volume. */
- //* BOOLEAN Create_LVM_Volume - If TRUE, then an LVM */
- //* volume is created, */
- //* otherwise a */
- //* compatibility volume is */
- //* created. */
- //* BOOLEAN Bootable - If TRUE, the volume will not be */
- //* created unless OS/2 can be booted*/
- //* from it. */
- //* char Drive_Letter_Preference - This is the drive */
- //* letter to use for */
- //* accessing the */
- //* newly created */
- //* volume. */
- //* CARDINAL32 FeaturesToUse - This is currently reserved */
- //* for future use and should */
- //* always be set to 0. */
- //* CARDINAL32 Partition_Count - The number of partitions */
- //* to link together to form */
- //* the volume being created. */
- //* ADDRESS Partition_Handles[] - An array of partition */
- //* handles with one entry*/
- //* for each partition */
- //* that is to become part*/
- //* of the volume being */
- //* created. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the volume was created. */
- //* *Error_Code will be > 0 if the volume could not be */
- //* created. */
- //* */
- //* Error Handling: If any of the handles in the partition handles */
- //* array is not valid, then a trap is likely. If */
- //* Partition_Count is greater than the number of */
- //* entries in the partition handles array, then a */
- //* trap is likely. If any of the handles in the */
- //* partition array are not partition handles, then */
- //* *Error_Code will be > 0. If the volume can NOT */
- //* be created, then *Error_Code will be > 0 and any*/
- //* memory allocated by this function will be freed.*/
- //* If the volume can NOT be created, then the */
- //* existing partition/volume structure of the disk */
- //* will be unchanged. */
- //* */
- //* Side Effects: A volume may be created. */
- //* */
- //* Notes: This function provides limited compatibility for */
- //* programs written to use the LVM Version 1 interface. */
- //* Specifically, this function will only allow the */
- //* creation of compatibility volumes. Any attempt to */
- //* create an LVM volume will result in an error code being */
- //* returned. */
- //* */
- //*********************************************************************/
- type
- TVolumeName=Array[0..VOLUME_NAME_SIZE-1] of char;
- procedure Create_Volume(Name: TVolumeName;
- Create_LVM_Volume: BOOLEAN;
- Bootable: BOOLEAN;
- Drive_Letter_Preference: char;
- FeaturesToUse: CARDINAL32;
- Partition_Count: CARDINAL32;
- Partition_Handles: Array of ADDRESS;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Create_Volume';
- //*********************************************************************/
- //* */
- //* Function Name: Create_Volume2 */
- //* */
- //* Descriptive Name: This function creates a volume from a list of*/
- //* partitions. The partitions are specified by */
- //* their corresponding handles. */
- //* */
- //* Input: char Name[] - The name to assign to the newly */
- //* created volume. */
- //* BOOLEAN Create_LVM_Volume - If TRUE, then an LVM */
- //* volume is created, */
- //* otherwise a */
- //* compatibility volume is */
- //* created. */
- //* BOOLEAN Bootable - If TRUE, the volume will not be */
- //* created unless OS/2 can be booted*/
- //* from it. */
- //* char Drive_Letter_Preference - This is the drive */
- //* letter to use for */
- //* accessing the */
- //* newly created */
- //* volume. */
- //* CARDINAL32 Feature_Count - The number of features to */
- //* install on the volume being */
- //* created. This field is */
- //* ignored if Create_LVM_Volume*/
- //* is FALSE. */
- //* LVM_Feature_Specification_Record FeaturesToUse[] - An */
- //* array of feature IDs and */
- //* their associated LVM */
- //* classes used to designate */
- //* which features to install */
- //* on the volume being */
- //* created and the order in */
- //* which to install them. */
- //* This field is ignored if */
- //* Create_LVM_Volume is */
- //* FALSE. */
- //* CARDINAL32 Partition_Count - The number of partitions */
- //* to link together to form */
- //* the volume being created. */
- //* ADDRESS Partition_Handles[] - An array of partition */
- //* handles with one entry*/
- //* for each partition */
- //* that is to become part*/
- //* of the volume being */
- //* created. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the volume was created. */
- //* *Error_Code will be > 0 if the volume could not be */
- //* created. */
- //* */
- //* Error Handling: If any of the handles in the partition handles */
- //* array is not valid, then a trap is likely. If */
- //* Partition_Count is greater than the number of */
- //* entries in the partition handles array, then a */
- //* trap is likely. If any of the handles in the */
- //* partition array are not partition handles, then */
- //* *Error_Code will be > 0. If the volume can NOT */
- //* be created, then *Error_Code will be > 0 and any*/
- //* memory allocated by this function will be freed.*/
- //* If the volume can NOT be created, then the */
- //* existing partition/volume structure of the disk */
- //* will be unchanged. */
- //* */
- //* Side Effects: A volume may be created. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- void _System Create_Volume2( char Name[VOLUME_NAME_SIZE],
- BOOLEAN Create_LVM_Volume,
- BOOLEAN Bootable,
- char Drive_Letter_Preference,
- CARDINAL32 Feature_Count,
- LVM_Feature_Specification_Record FeaturesToUse[],
- CARDINAL32 Partition_Count,
- ADDRESS Partition_Handles[],
- CARDINAL32 * Error_Code
- );
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Delete_Volume */
- //* */
- //* Descriptive Name: Deletes the volume specified by Volume_Handle.*/
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume to */
- //* delete. All partitions which are*/
- //* part of the specified volume will*/
- //* be deleted also. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the volume and its partitions */
- //* are successfully deleted. Otherwise, *Error_Code will */
- //* be > 0. */
- //* */
- //* Error Handling: *Error_Code will be > 0 if an error occurs. If */
- //* the volume or any of its partitions can not be */
- //* deleted, then any changes made by this function */
- //* will be undone. */
- //* */
- //* If Volume_Handle is not a valid handle, a trap */
- //* may result. */
- //* */
- //* If Volume_Handle is a partition or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: A volume and its partitions may be deleted. */
- //* System memory may be freed as the internal */
- //* structures used to track the deleted volume */
- //* are no longer required. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Delete_Volume(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Delete_Volume';
- //*********************************************************************/
- //* */
- //* Function Name: Hide_Volume */
- //* */
- //* Descriptive Name: Hide volume "hides" a volume from OS/2 by */
- //* removing its drive letter assignment. Without*/
- //* a drive letter assignment, OS/2 can not access*/
- //* (or "see") the volume. */
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume to hide.*/
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the volume was successfully */
- //* hidden. If the volume could not be hidden, then */
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: *Error_Code will be > 0 if the volume can not be*/
- //* hidden. If the volume can not be hidden, then */
- //* nothing will be altered. */
- //* */
- //* If Volume_Handle is not a valid handle, a trap */
- //* may result. */
- //* */
- //* If Volume_Handle is a partition or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Hide_Volume(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Hide_Volume';
- //*********************************************************************/
- //* */
- //* Function Name: Expand_Volume */
- //* */
- //* Descriptive Name: This function expands an existing volume by */
- //* linking additional partitions to it. */
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume to be */
- //* expanded. */
- //* CARDINAL32 Partition_Count - The number of partitions or */
- //* volumes to be added to the */
- //* volume being expanded. */
- //* ADDRESS Partition_Handles[] - An array of handles. Each */
- //* handle in the array is the */
- //* handle of a partition */
- //* which is to be added to */
- //* the volume being expanded. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the volume is successfully */
- //* expanded. If the volume can not be expanded, */
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the volume can not be expanded, the state of */
- //* the volume is unchanged and any memory allocated*/
- //* by this function is freed. */
- //* */
- //* If Volume_Handle is not a valid handle, a trap */
- //* may result. */
- //* */
- //* If Volume_Handle is a partition or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* If any of the partition handles in the */
- //* Partition_handles array are not valid handles, */
- //* then a trap may result. */
- //* */
- //* If any of the partition handles in the */
- //* Partition_Handles array are actually drive */
- //* handles, then this function will abort and */
- //* set *Error_Code to a non-zero value. */
- //* */
- //* If Partition_Count is greater than the number of*/
- //* entries in the Partition_Handles array, a trap */
- //* may result. */
- //* */
- //* Side Effects: A volume may be expanded. If the volume is */
- //* expanded using another volume, the partitions */
- //* on the second volume will be linked to those of */
- //* the first volume and all data on the second */
- //* volume will be lost. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Expand_Volume(Volume_Handle: ADDRESS;
- Partition_Count: CARDINAL32;
- Partition_Handles: Array of ADDRESS;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Expand_Volume';
- //*********************************************************************/
- //* */
- //* Function Name: Assign_Drive_Letter */
- //* */
- //* Descriptive Name: Assigns a drive letter to a volume. */
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume which */
- //* is to have its assigned drive */
- //* letter changed. */
- //* char New_Drive_Preference - The new drive letter to */
- //* assign to the volume. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the drive letter was assigned */
- //* successfully; otherwise *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the drive letter assignment can not be made, */
- //* the volume will not be altered. */
- //* */
- //* If Volume_Handle is not a valid handle, a trap */
- //* may result. */
- //* */
- //* If Volume_Handle is a partition or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: A volume may have its drive letter assignment */
- //* changed. */
- //* */
- //* Notes: If the drive letter being assigned is already in use by */
- //* volume which does not lie on removable media, then the */
- //* drive assignment will NOT be made. */
- //* */
- //*********************************************************************/
- procedure Assign_Drive_Letter(Volume_Handle: ADDRESS;
- New_Drive_Preference: char;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Assign_Drive_Letter';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Installable */
- //* */
- //* Descriptive Name: Marks a volume as being the volume to install */
- //* OS/2 on. */
- //* */
- //* Input: ADDRESS Volume_Handle - The handle of the volume to which*/
- //* OS/2 should be installed. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If the volume is successfully marked as installable, */
- //* *Error_Code will be 0; otherwise *Error_Code will */
- //* be > 0. */
- //* */
- //* Error Handling: If Volume_Handle is not a valid handle, a trap */
- //* may result. */
- //* */
- //* If Volume_Handle is a partition or drive handle,*/
- //* then this function will abort and set */
- //* *Error_Code to a non-zero value. */
- //* */
- //* Side Effects: The specified volume may be marked as */
- //* installable. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Installable(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Installable';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Installable_Volume */
- //* */
- //* Descriptive Name: Marks a volume as being the volume to install */
- //* OS/2 on. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If a volume is mared installable, its information will */
- //* be returned and *Error_Code will be LVM_ENGINE_NO_ERROR.*/
- //* If there is no volume marked installable, then */
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: An error code is returned if there is an error. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Installable_Volume(Error_Code: PCARDINAL32): Volume_Information_Record; external 'lvm' name 'Get_Installable_Volume';
- //*********************************************************************/
- //* */
- //* Function Name: Convert_Volumes_To_V1 */
- //* */
- //* Descriptive Name: This function attempts to convert all LVM */
- //* volumes in the system into a format that can */
- //* be used by LVM Version 1, which was shipped */
- //* with Warp Server for e-business. This */
- //* function returns a bitmap of the drive letters*/
- //* corresponding to Volumes that can not be */
- //* converted. */
- //* */
- //* Input: BOOLEAN * Hidden_Volume_Conversion_Failure - The address */
- //* of a BOOLEAN variable in which */
- //* to store a flag indicating if */
- //* there were hidden volumes that */
- //* could not be converted. If */
- //* *Hidden_Volume_Conversion_Failure */
- //* is TRUE, then there were hidden */
- //* volumes that could not be */
- //* converted. If FALSE, then there */
- //* were no hidden volumes, or the */
- //* hidden volumes that existed were */
- //* converted successfully. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: This function returns a bitmap of the drive letters */
- //* corresponding to volumes that could not be converted to */
- //* LVM Version 1 format. If this function is successful */
- //* and all volumes were converted, then *Error_Code will be*/
- //* set to LVM_ENGINE_NO_ERROR and the bitmap returned will */
- //* have no bits set. If this function failes, *Error_Code */
- //* will contain a non-zero error code and the bitmap */
- //* returned by this function may be non-zero. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: All LVM volumes that can be converted to LVM */
- //* Version 1 format will be. */
- //* */
- //* Notes: Bit 0 in the bitmap returned by this function represents*/
- //* drive letter 'A'. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- CARDINAL32 _System Convert_Volumes_To_V1 ( BOOLEAN * Hidden_Volume_Conversion_Failure,
- CARDINAL32 * Error_Code ) ;
- {$endif}
- //***************************************************************************
- //
- // Functions relating to Partitions, Drives, and Volumes.
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Set_Name */
- //* */
- //* Descriptive Name: Sets the name of a volume, drive, or partition*/
- //* */
- //* Input: ADDRESS Handle - The handle of the drive, partition, or */
- //* volume which is to have its name set. */
- //* char New_Name[] - The new name for the drive/partition/ */
- //* volume. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the name is set as specified. */
- //* If the name can not be set, *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the name can not be set, then drive/volume/ */
- //* partition is not modified. */
- //* */
- //* If Handle is not a valid handle, a trap may */
- //* result. */
- //* */
- //* Side Effects: A drive/volume/partition may have its name set. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Name(Handle: ADDRESS;
- New_Name: Array of char;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Set_Name';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Startable */
- //* */
- //* Descriptive Name: Sets the specified volume or partition */
- //* startable. If a volume is specified, it must */
- //* be a compatibility volume whose partition is */
- //* a primary partition on the first drive. If a */
- //* partition is specified, it must be a primary */
- //* partition on the first drive in the system. */
- //* */
- //* Input: ADDRESS Handle - The handle of the partition or volume */
- //* which is to be set startable. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the specified volume or */
- //* partition was set startable. */
- //* If the name can not be set, *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the volume or partition could not be set */
- //* startable, then nothing in the system is */
- //* changed. */
- //* */
- //* If Handle is not a valid handle, a trap may */
- //* result. */
- //* */
- //* Side Effects: Any other partition or volume which is marked */
- //* startable will have its startable flag cleared. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Startable(Handle: ADDRESS;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Set_Startable';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Valid_Options */
- //* */
- //* Descriptive Name: Returns a bitmap where each bit in the bitmap */
- //* corresponds to a possible operation that the */
- //* LVM Engine can perform. Those bits which are */
- //* 1 represent operations which can be performed */
- //* on the item specified by Handle. Those bits */
- //* which are 0 are not allowed on the item */
- //* specified by Handle. */
- //* */
- //* Input: ADDRESS Handle - This is any valid drive, volume, or */
- //* partition handle. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: A bitmap indicating which operations are valid on the */
- //* item specified by Handle. */
- //* */
- //* If no errors occur, *Error_Code will be 0, otherwise */
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: If Handle is not valid, a trap will be likely. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The values of the various bits in the bitmap returned */
- //* by this function are defined near the beginning of this */
- //* file, immediately after all of the structure */
- //* definitions. */
- //* */
- //*********************************************************************/
- function Get_Valid_Options(Handle: ADDRESS; Error_Code: PCARDINAL32): CARDINAL32; external 'lvm' name 'Get_Valid_Options';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Child_Handles */
- //* */
- //* Descriptive Name: Given the handle of a volume or aggregate, */
- //* this function will return the handles of the */
- //* children of the volume or aggregate. This */
- //* allows the entire tree representation of a */
- //* volume to be traversed, a level at a time. */
- //* */
- //* Input: ADDRESS Handle - The handle of the volume or aggregate */
- //* whose children are required. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If successful, an LVM_Handle_Array_Record is returned */
- //* with a non-zero Count. Also, *Error_Code will be set */
- //* to LVM_ENGINE_NO_ERROR. If an error occurs, then */
- //* the Count field will be 0 and *Error_Code will contain */
- //* a non-zero error code. */
- //* */
- //* Error Handling: If Handle is not a valid handle, then a trap is */
- //* likely. If Handle is the handle of partition, */
- //* then *Error_Code will be set to */
- //* LVM_ENGINE_NO_CHILDREN. If Handle is not a */
- //* volume or aggregate handle, then *Error_Code */
- //* will be set to LVM_ENGINE_BAD_HANDLE. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- LVM_Handle_Array_Record _System Get_Child_Handles( ADDRESS Handle, CARDINAL32 * Error_Code);
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Get_Parent_Handle */
- //* */
- //* Descriptive Name: Given the handle of a partition or aggregate, */
- //* this function will return the handle of the */
- //* parent of the partition or aggregate. */
- //* */
- //* Input: ADDRESS Handle - The handle of the partition or aggregate*/
- //* whose parent is required. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If successful, the handle of the parent is returned */
- //* as the function result and *Error_Code will be set to */
- //* LVM_ENGINE_NO_ERROR. */
- //* If an error occurs, then NULL will be the function */
- //* result and *Error_Code will contain a non-zero error */
- //* code. */
- //* */
- //* Error Handling: If Handle is not a valid handle, then a trap is */
- //* likely. If Handle is the handle of volume, */
- //* then *Error_Code will be set to */
- //* LVM_ENGINE_NO_PARENT. If Handle is not the */
- //* handle of a volume, partition, or aggregate */
- //* then *Error_Code will be set to */
- //* LVM_ENGINE_BAD_HANDLE. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- ADDRESS _System Get_Parent_Handle( ADDRESS Handle, CARDINAL32 * Error_Code);
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Get_Features */
- //* */
- //* Descriptive Name: Returns the feature ID information for each of*/
- //* the features that are installed on the */
- //* item specified by Handle. */
- //* */
- //* Input: ADDRESS Handle - The handle of the object to use. */
- //* */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code */
- //* should an error occur. */
- //* */
- //* Output: If successful, a Feature_Information_Array structure is */
- //* returned with a non-zero Count. Also, *Error_Code will */
- //* be set to LVM_ENGINE_NO_ERROR. If an error occurs, */
- //* then the Count field in the structure will be 0 and */
- //* ( *Error_Code) will contain a non-zero error code. */
- //* */
- //* Error Handling: If Handle is not a valid handle, a trap */
- //* will be likely. */
- //* */
- //* Side Effects: Memory is allocated using the LVM Engine's memory*/
- //* manager for the array of Feature_ID_Data items */
- //* being returned. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- Feature_Information_Array _System Get_Features( ADDRESS Handle, CARDINAL32 * Error_Code );
- {$endif}
- //***************************************************************************
- //
- // Functions relating to Boot Manager
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Boot_Manager_Is_Installed */
- //* */
- //* Descriptive Name: Indicates whether or not Boot Manager is */
- //* installed on the first or second hard drives */
- //* in the system. */
- //* */
- //* Input: BOOLEAN * Active - *Active is set to TRUE if LVM found an*/
- //* active copy of Boot Manager on the */
- //* system. If LVM could not find an */
- //* active copy of Boot Manager on the */
- //* system, but did find an inactive copy */
- //* of Boot Manager, then *Active will be */
- //* set to FALSE. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: TRUE is returned if Boot Manager is found. If this */
- //* copy of Boot Manager is Active, then *Active will be set*/
- //* to TRUE. If the copy of Boot Manager is not currently */
- //* active, then *Active will be set to FALSE. */
- //* */
- //* FALSE is returned if Boot Manager is not found or if an */
- //* error occurs. In this case, *Active is undefined. */
- //* */
- //* *Error_Code will be 0 if no errors occur; otherwise it */
- //* will be > 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- type
- PBOOLEAN=^BOOLEAN;
- function Boot_Manager_Is_Installed(Active: PBOOLEAN; Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Boot_Manager_Is_Installed';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Boot_Manager_Handle */
- //* */
- //* Descriptive Name: Returns the handle of the partition containing*/
- //* Boot Manager. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If Boot Manager is NOT installed, NULL is returned. */
- //* If Boot Manager is installed, whether it is active or */
- //* not, the handle of the partition it resides in is */
- //* returned. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: */
- //* */
- //*********************************************************************/
- function Get_Boot_Manager_Handle(Error_Code: PCARDINAL32): ADDRESS; external 'lvm' name 'Get_Boot_Manager_Handle';
- //*********************************************************************/
- //* */
- //* Function Name: Add_To_Boot_Manager */
- //* */
- //* Descriptive Name: Adds the volume/partition to the Boot Manager */
- //* menu. */
- //* */
- //* Input: ADDRESS Handle - The handle of a partition or volume that*/
- //* is to be added to the Boot Manager menu.*/
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the partition or volume was */
- //* successfully added to the Boot Manager menu; otherwise */
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the partition/volume can not be added to the */
- //* Boot Manager menu, no action is taken and */
- //* *Error_Code will contain a non-zero error code. */
- //* */
- //* If Handle is not a valid handle, a trap may */
- //* result. */
- //* */
- //* If Handle represents a drive, then this function*/
- //* will abort and set *Error_Code to a non-zero */
- //* value. */
- //* */
- //* Side Effects: The Boot Manager menu may be altered. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Add_To_Boot_Manager(Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Add_To_Boot_Manager';
- //*********************************************************************/
- //* */
- //* Function Name: Remove_From_Boot_Manager */
- //* */
- //* Descriptive Name: Removes the specified partition or volume */
- //* from the Boot Manager menu. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* */
- //* Output: *Error_Code will be 0 if the partition or volume was */
- //* successfully removed to the Boot Manager menu; */
- //* otherwise *Error_Code will be > 0. */
- //* */
- //* Error Handling: If Handle is not a valid handle, a trap may */
- //* result. */
- //* */
- //* If Handle represents a drive, or if Handle */
- //* represents a volume or partition which is NOT on*/
- //* the boot manager menu, then this function */
- //* will abort and set *Error_Code to a non-zero */
- //* value. */
- //* */
- //* Side Effects: The Boot Manager menu may be altered. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Remove_From_Boot_Manager(Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Remove_From_Boot_Manager';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Boot_Manager_Menu */
- //* */
- //* Descriptive Name: Returns an array containing the handles of the*/
- //* partitions and volumes appearing on the */
- //* Boot Manager menu. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: The function returns a Boot_Manager_Menu structure. */
- //* This structure contains two items: a pointer to an array*/
- //* of Boot_Manager_Menu_Items and a count of how many items*/
- //* are in the array. Each Boot_Manager_Menu_Item contains */
- //* a handle and a BOOLEAN variable to indicate whether the */
- //* handle is for a partition or a volume. */
- //* */
- //* If this function is successful, then *Error_Code will */
- //* be 0. */
- //* */
- //* If an error occurs, the Count field in the */
- //* Boot_Manager_Menu will be 0 and the corresponding */
- //* pointer will be NULL. *Error_Code will be > 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* any memory allocated by this function will be */
- //* freed. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Boot_Manager_Menu(Error_Code: PCARDINAL32): Boot_Manager_Menu; external 'lvm' name 'Get_Boot_Manager_Menu';
- //*********************************************************************/
- //* */
- //* Function Name: Install_Boot_Manager */
- //* */
- //* Descriptive Name: This function installs Boot Manager. It can */
- //* be used to replace an existing Boot Manager */
- //* as well. */
- //* */
- //* Input: CARDINAL32 Drive_Number - The number of the drive to */
- //* install Boot Manager on. Must*/
- //* be 1 or 2. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If this function is successful, then *Error_Code will be*/
- //* 0; otherwise it will be > 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be set to a*/
- //* non-zero value. Depending upon the error, it */
- //* is possible that the Boot Manager partition can */
- //* be left in an unusuable state (such as for a */
- //* write error). */
- //* */
- //* Side Effects: Boot Manager may be installed on drive 1 or 2. */
- //* The MBR for drive 1 may be altered. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- // Only drives 0 and 1 are acceptable.
- procedure Install_Boot_Manager(Drive_Number: CARDINAL32; Error_Code: PCARDINAL32); external 'lvm' name 'Install_Boot_Manager';
- //*********************************************************************/
- //* */
- //* Function Name: Remove_Boot_Manager */
- //* */
- //* Descriptive Name: Removes Boot Manager from the system. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if Boot Manager was successfully */
- //* removed from the system; otherwise *Error_Code will */
- //* be 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: Boot Manager will be removed from the system. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Remove_Boot_Manager(Error_Code: PCARDINAL32); external 'lvm' name 'Remove_Boot_Manager';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Boot_Manager_Options */
- //* */
- //* Descriptive Name: Sets the Boot Managers Options. The options */
- //* that can be set are: whether or not the time- */
- //* out timer is active, how long the timer-out */
- //* is, the partition to boot by default, and */
- //* whether or not Boot Manager should display its*/
- //* menu using default mode or advanced mode. */
- //* */
- //* Input: ADDRESS Handle - The handle of the partition or volume */
- //* to boot if the time-out timer is active */
- //* and the time-out value is reached. */
- //* BOOLEAN Timer_Active - If TRUE, then the time-out timer */
- //* is active. */
- //* CARDINAL32 Time_Out_Value - If the time-out timer is */
- //* active, this is the time-out */
- //* value, in seconds. */
- //* BOOLEAN Advanced_Mode - If TRUE, then Boot Manager will */
- //* operate in advanced mode. If */
- //* FALSE, then normal mode will be */
- //* in effect. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if no errors occur. If an error */
- //* does occur, then *Error_Code will be > 0. */
- //* */
- //* Error Handling: If an error occurs, no changes will be made to */
- //* Boot Manager and *Error_Code will be set a */
- //* non-zero error code. */
- //* */
- //* Side Effects: Boot Manager may be modified. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Boot_Manager_Options(Handle: ADDRESS;
- Timer_Active: BOOLEAN;
- Time_Out_Value: CARDINAL32;
- Advanced_Mode: BOOLEAN;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Set_Boot_Manager_Options';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Boot_Manager_Options */
- //* */
- //* Descriptive Name: This function returns the current Boot Manager*/
- //* settings for the various Boot Manager options.*/
- //* */
- //* Input: ADDRESS * Handle - The handle for the default boot volume*/
- //* or partition. */
- //* BOOLEAN * Handle_Is_Volume - If TRUE, then Handle */
- //* represents a volume. If */
- //* FALSE, then Handle */
- //* represents a partition. */
- //* BOOLEAN * Timer_Active - If TRUE, then the time-out timer*/
- //* is active. If FALSE, then the */
- //* time-out timer is not active. */
- //* CARDINAL32 * Time_Out_Value - If the time-out timer is */
- //* active, then this is the */
- //* number of seconds that Boot*/
- //* Manager will wait for user */
- //* input before booting the */
- //* default volume/partition. */
- //* BOOLEAN * Advanced_Mode - If TRUE, the Boot Manager is */
- //* operating in advanced mode. If*/
- //* FALSE, then Boot Manager is */
- //* operating in normal mode. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Handle, *Handle_Is_Volume, *Timer_Active, */
- //* *Time_out_value, *Advanced_Mode, and *Error_Code are all*/
- //* set by this function. If there are no errors, then */
- //* *Error_Code will be set to 0. If any errors occur, then*/
- //* *Error_Code will be > 0. */
- //* */
- //* Error Handling: If any of the parameters are invalid, then a */
- //* trap is likely. If Boot Manager is not */
- //* installed, then *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Get_Boot_Manager_Options(Handle: PADDRESS;
- Handle_Is_Volume: PBOOLEAN;
- Timer_Active: PBOOLEAN;
- Time_Out_Value: PCARDINAL32;
- Advanced_Mode: PBOOLEAN;
- Error_Code: PCARDINAL32
- ); external 'lvm' name 'Get_Boot_Manager_Options';
- //****************************************************************************
- //
- // Other Functions
- //
- //***************************************************************************
- //*********************************************************************/
- //* */
- //* Function Name: Allocate_Engine_Memory */
- //* */
- //* Descriptive Name: Allocates a block of memory using LVM.DLL's */
- //* memory management functions. */
- //* */
- //* Input: CARDINAL32 Size - The number of bytes of memory to */
- //* allocate. */
- //* */
- //* Output: The address of the block of memory which was allocated, */
- //* or NULL if the requested amount of memory could not be */
- //* allocated. */
- //* */
- //* Error Handling: None. */
- //* */
- //* Side Effects: The specified number of bytes is allocated from */
- //* the memory manager imbedded in LVM.DLL. Memory */
- //* allocated by this function must be freed using */
- //* Free_Engine_Memory function. The use of any */
- //* memory manager to free the memory could result in*/
- //* Bad Things Happening! */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- {$ifdef lvm2}
- ADDRESS _System Allocate_Engine_Memory( CARDINAL32 Size );
- {$endif}
- //*********************************************************************/
- //* */
- //* Function Name: Free_Engine_Memory */
- //* */
- //* Descriptive Name: Frees a memory object created by LVM.DLL and */
- //* returned to a user of LVM.DLL. */
- //* */
- //* Input: ADDRESS Object : The address of the memory object to */
- //* free. This could be the */
- //* Drive_Control_Data field of a */
- //* Drive_Control_Record, the */
- //* Partition_Array field of a */
- //* Partition_Information_Array structure, */
- //* or any other dynamically allocated */
- //* memory object created by LVM.DLL and */
- //* returned by a function in LVM.DLL. */
- //* */
- //* Output: None. */
- //* */
- //* Error Handling: None. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: A trap or exception could occur if a bad address is */
- //* passed into this function. */
- //* */
- //*********************************************************************/
- procedure Free_Engine_Memory(Object_: ADDRESS); external 'lvm' name 'Free_Engine_Memory';
- //*********************************************************************/
- //* */
- //* Function Name: New_MBR */
- //* */
- //* Descriptive Name: This function lays down a new MBR on the */
- //* specified drive. */
- //* */
- //* Input: ADDRESS Drive_Handle - The handle of the drive on which */
- //* the new MBR is to be placed. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if the new MBR was successfully */
- //* placed on the specified drive. If the operation failed */
- //* for any reason, then *Error_Code will contain a non-zero*/
- //* error code. */
- //* */
- //* Error Handling: If an error occurs, then the existing MBR is not*/
- //* altered and *Error_Code will be > 0. */
- //* */
- //* Side Effects: A new MBR may be placed on the specified drive. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure New_MBR(Drive_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'New_MBR';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Available_Drive_Letters */
- //* */
- //* Descriptive Name: This function returns a bitmap indicating */
- //* which drive letters are available for use. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: This function returns a bitmap of the available drive */
- //* letters. If this function is successful, then */
- //* *Error_Code will be set to 0. Otherwise, *Error_Code */
- //* will be > 0 and the bitmap returned will have all bits */
- //* set to 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: A drive letter is available if it is not associated */
- //* with a volume located on a disk drive controlled */
- //* by OS2DASD. */
- //* */
- //*********************************************************************/
- function Get_Available_Drive_Letters(Error_Code: PCARDINAL32): CARDINAL32; external 'lcm' name 'Get_Available_Drive_Letters';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Reserved_Drive_Letters */
- //* */
- //* Descriptive Name: This function returns a bitmap indicating */
- //* which drive letters are reserved for use by */
- //* devices NOT under the control of LVM. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: This function returns a bitmap of the drive letters */
- //* which are being used by devices which are NOT controlled*/
- //* by LVM. While a Volume CAN be assigned a drive letter */
- //* from this list, a reboot will almost always be required */
- //* in order for the assignment to take place. */
- //* If this function is successful, then *Error_Code will be*/
- //* set to 0. Otherwise, *Error_Code will be > 0 and the */
- //* bitmap returned will have all bits set to 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: Devices which are assigned drive letters but which are */
- //* NOT under LVM control include: CD-ROM, Network drives, */
- //* parallel port attached devices, and any DASD devices */
- //* not controlled by OS2DASD. */
- //* */
- //*********************************************************************/
- function Get_Reserved_Drive_Letters(Error_Code: CARDINAL32): CARDINAL32; external 'lvm' name 'Get_Reserved_Drive_Letters';
- //*********************************************************************/
- //* */
- //* Function Name: Reboot_Required */
- //* */
- //* Descriptive Name: This function indicates whether or not any */
- //* changes were made to the partitioning of the */
- //* disks in the system which would require a */
- //* reboot to make functional. */
- //* */
- //* Input: None. */
- //* */
- //* Output: The function return value will be TRUE if the system */
- //* must be rebooted as a result of disk partitioning */
- //* changes. */
- //* */
- //* Error Handling: None required. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Reboot_Required: BOOLEAN; external 'lvm' name 'Reboot_Required';
- //*********************************************************************/
- //* */
- //* Function Name: Changes_Pending */
- //* */
- //* Descriptive Name: This function indicates whether or not any */
- //* changes were made to the partitioning of the */
- //* disks in the system which have not yet been */
- //* comitted to disk. */
- //* */
- //* Input: None. */
- //* */
- //* Output: The function return value will be TRUE if there are */
- //* uncomitted changes to the partitioning of one or more of*/
- //* the drives in the system. */
- //* */
- //* Error Handling: None required. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Changes_Pending: BOOLEAN; external 'lvm' name 'Changes_Pending';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Reboot_Flag */
- //* */
- //* Descriptive Name: This function sets the Reboot Flag. The */
- //* Reboot Flag is a special flag on the boot */
- //* disk used by the install program to keep */
- //* track of whether or not the system was just */
- //* rebooted. It is used by the various phases */
- //* of install. */
- //* */
- //* Input: BOOLEAN Reboot - The new value for the Reboot Flag. If */
- //* TRUE, then the reboot flag will be set. */
- //* If FALSE, then the reboot flag will be */
- //* cleared. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be set to 0 if there are no errors. */
- //* *Error_Code will be > 0 if an error occurs. */
- //* */
- //* Error Handling: If an error occurs, then the value of the Reboot*/
- //* Flag will be unchanged. */
- //* */
- //* Side Effects: The value of the Reboot Flag may be changed. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Reboot_Flag(Reboot: BOOLEAN; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Reboot_Flag';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Reboot_Flag */
- //* */
- //* Descriptive Name: This function returns the value of the Reboot */
- //* Flag. The Reboot Flag is a special flag on */
- //* the boot disk used by the install program to */
- //* keep track of whether or not the system was */
- //* just rebooted. It is used by the various */
- //* phases of install. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: The function return value will be TRUE if no errors */
- //* occur and the Reboot Flag is set. *Error_Code will be */
- //* 0 under these conditions. If an error occurs, the */
- //* function return value will be FALSE and *Error_Code */
- //* will be > 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* The value of the reboot flag will be unchanged. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Reboot_Flag(Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Get_Reboot_Flag';
- //*********************************************************************/
- //* */
- //* */
- //* Function Name: Set_Install_Flags */
- //* */
- //* Descriptive Name: This function sets the value of the Install */
- //* Flags. The Install Flags reside in a 32 bit */
- //* field in the LVM dataspace. These flags are */
- //* not used by LVM, thereby leaving Install free */
- //* to use them for whatever it wants. */
- //* */
- //* Input: CARDINAL32 Install_Flags - The new value for the Install */
- //* Flags. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be set to 0 if there are no errors. */
- //* *Error_Code will be > 0 if an error occurs. */
- //* */
- //* Error Handling: If an error occurs, then the value of the */
- //* Install Flags will be unchanged. */
- //* */
- //* Side Effects: The value of the Install Flags may be changed. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Install_Flags(Install_Flags: CARDINAL32; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Install_Flags';
- //*********************************************************************/
- //* */
- //* Function Name: Get_Install_Flags */
- //* */
- //* Descriptive Name: This function returns the value of the Install*/
- //* Flags. The Install Flags reside in a 32 bit */
- //* field in the LVM dataspace. These flags are */
- //* not used by LVM, thereby leaving Install free */
- //* to use them for whatever it wants. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: The function returns the current value of the Install */
- //* Flags stored in the LVM Dataspace. */
- //* *Error_Code will be LVM_ENGINE_NO_ERROR if the function */
- //* is successful. If an error occurs, the function will */
- //* return 0 and *Error_Code will be > 0. */
- //* */
- //* Error Handling: If an error occurs, *Error_Code will be > 0. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- function Get_Install_Flags(Error_Code: PCARDINAL32): CARDINAL32; external 'lvm' name 'Get_Install_Flags';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Min_Install_Size */
- //* */
- //* Descriptive Name: This function tells the LVM Engine how big a */
- //* partition/volume must be in order for it to */
- //* marked installable. If this function is not */
- //* used to set the minimum size for an */
- //* installable partition/volume, the LVM Engine */
- //* will use a default value of 300 MB. */
- //* */
- //* Input: CARDINAL32 Min_Sectors - The minimum size, in sectors, */
- //* that a partition must be in */
- //* order for it to be marked as */
- //* installable. */
- //* */
- //* Output: None. */
- //* */
- //* Error Handling: None required. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Min_Install_Size(Min_Sectors: CARDINAL32); external 'lvm' name 'Set_Min_Install_Size';
- //*********************************************************************/
- //* */
- //* Function Name: Set_Free_Space_Threshold */
- //* */
- //* Descriptive Name: This function tells the LVM Engine not to */
- //* report blocks of free space which are less */
- //* than the size specified. The engine defaults */
- //* to not reporting blocks of free space which */
- //* are smaller than 2048 sectors (1 MB). */
- //* */
- //* Input: CARDINAL32 Min_Sectors - The minimum size, in sectors, */
- //* that a block of free space must */
- //* be in order for the LVM engine */
- //* to report it. */
- //* */
- //* Output: None. */
- //* */
- //* Error Handling: None required. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Set_Free_Space_Threshold(Min_Sectors: CARDINAL32); external 'lvm' name 'Set_Free_Space_Threshold';
- //*********************************************************************/
- //* */
- //* Function Name: Read_Sectors */
- //* */
- //* Descriptive Name: This function reads one or more sectors from */
- //* the specified drive and places the data read */
- //* in Buffer. */
- //* */
- //* Input: CARDINAL32 Drive_Number : The number of the hard drive to*/
- //* read from. The drives in the */
- //* system are numbered from 1 to */
- //* n, where n is the total number */
- //* of hard drives in the system. */
- //* LBA Starting_Sector : The first sector to read from. */
- //* CARDINAL32 Sectors_To_Read : The number of sectors to */
- //* read into memory. */
- //* ADDRESS Buffer : The location to put the data read into. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful, then the data read will be placed in */
- //* memory starting at Buffer, and *Error will be */
- //* LVM_ENGINE_NO_ERROR. */
- //* If Unsuccessful, then *Error will be > 0 and the */
- //* contents of memory starting at Buffer is undefined. */
- //* */
- //* Error Handling: *Error will be > 0 if an error occurs. */
- //* */
- //* Side Effects: Data may be read into memory starting at Buffer. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Read_Sectors(Drive_Number: CARDINAL32;
- Starting_Sector: LBA;
- Sectors_To_Read: CARDINAL32;
- Buffer: ADDRESS;
- Error: PCARDINAL32); external 'lvm' name 'Read_Sectors';
- //*********************************************************************/
- //* */
- //* Function Name: Write_Sectors */
- //* */
- //* Descriptive Name: This function writes data from memory to one */
- //* or more sectors on the specified drive. */
- //* */
- //* Input: CARDINAL32 Drive_Number : The number of the hard drive to*/
- //* write to. The drives in the */
- //* system are numbered from 1 to */
- //* n, where n is the total number */
- //* of hard drives in the system. */
- //* LBA Starting_Sector : The first sector to write to. */
- //* CARDINAL32 Sectors_To_Read : The number of sectors to */
- //* be written. */
- //* ADDRESS Buffer : The location of the data to be written */
- //* to disk. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful, then the data at Buffer will be placed */
- //* on the disk starting at the sector specified, and */
- //* *Error will be LVM_ENGINE_NO_ERROR. */
- //* If Unsuccessful, then *Error will be > 0 and the */
- //* contents of the disk starting at sector */
- //* Starting_Sector is undefined. */
- //* */
- //* Error Handling: *Error will be > 0 if an error occurs. */
- //* */
- //* Side Effects: Data may be written to disk. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Write_Sectors(Drive_Number: CARDINAL32;
- Starting_Sector: LBA;
- Sectors_To_Write: CARDINAL32;
- Buffer: ADDRESS;
- Error: PCARDINAL32); external 'lvm' name 'Write_Sectors';
- //*********************************************************************/
- //* */
- //* Function Name: Rediscover_PRMs */
- //* */
- //* Descriptive Name: Causes OS2LVM and OS2DASD to check PRMs for */
- //* new or changed media. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If the Rediscover PRM operation was successful, then */
- //* *Error_Code will be LVM_ENGINE_NO_ERROR. If there */
- //* was an error, then *Error_Code will be > 0. */
- //* */
- //* Error Handling: None. */
- //* */
- //* Side Effects: New volumes may be discovered and assigned drive */
- //* letters by OS2LVM and OS2DASD. */
- //* */
- //* Notes: The LVM Engine must be CLOSED when this function is */
- //* called as this function is disabled while it is open! */
- //* */
- //*********************************************************************/
- procedure Rediscover_PRMs(Error_Code: PCARDINAL32); external 'lvm' name 'Rediscover_PRMs';
- //*********************************************************************/
- //* */
- //* Function Name: Get_LVM_View */
- //* */
- //* Descriptive Name: This function gets the OS2LVM data for the */
- //* specified drive letter. The intent is to */
- //* allow the determination of what drive letter */
- //* a volume really has given the possibilities */
- //* of conflict or a drive preference of '*'. */
- //* */
- //* Input: char IFSM_Drive_Letter : The drive letter for which the*/
- //* OS2LVM data is requested. */
- //* CARDINAL32 * Drive_Number : The address of a variable */
- //* to hold the OS/2 drive */
- //* number of the drive */
- //* containing the first */
- //* partition of the volume */
- //* currently assigned to the */
- //* requested drive letter. */
- //* CARDINAL32 * Partition_LBA : The address of a variable */
- //* to hold the LBA of the */
- //* first partition of the */
- //* volume currently assigned */
- //* to the requested drive */
- //* letter. */
- //* char * LVM_Drive_Letter : The address of a variable to */
- //* hold the drive letter that */
- //* OS2LVM thinks the volume */
- //* assigned to the requested */
- //* drive letter should have. */
- //* BYTE * UnitID : The address of a variable to hold the */
- //* OS2LVM unit ID for the volume associated*/
- //* with the requested drive letter. */
- //* */
- //* Output: The function return value will be TRUE if the function */
- //* completed successfully. */
- //* */
- //* Error Handling: If this function fails, the specified drive */
- //* letter is either not in use, or is in use by a */
- //* device not controlled by OS2LVM. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: This function can be used with the LVM Engine open or */
- //* closed. */
- //* */
- //*********************************************************************/
- function Get_LVM_View(IFSM_Drive_Letter: char;
- Drive_Number: PCARDINAL32;
- Partition_LBA: PCARDINAL32;
- LVM_Drive_Letter: Pchar;
- UnitID: PBYTE): BOOLEAN; external 'lvm' name 'Get_LVM_View';
- //*********************************************************************/
- //* */
- //* Function Name: Start_Logging */
- //* */
- //* Descriptive Name: Enables the LVM Engine logging. Once enabled,*/
- //* the LVM Engine logging function will log all */
- //* LVM Engine activity to the specified log file.*/
- //* The data is logged in a binary format for */
- //* compactness and speed. */
- //* */
- //* Input: char * Filename - The filename of the file to use as the */
- //* log file. */
- //* CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: If the logging file was successfully created, then */
- //* *Error_Code will be 0. If the log file could not be */
- //* created, then *Error_Code will be > 0. */
- //* */
- //* Error Handling: If the log file can not be created, then */
- //* *Error_Code will be > 0. */
- //* */
- //* Side Effects: A file may be created/opened for logging of */
- //* LVM Engine actions. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Start_Logging(Filename: Pchar; Error_Code: PCARDINAL32); external 'lvm' name 'Start_Logging';
- //*********************************************************************/
- //* */
- //* Function Name: Stop_Logging */
- //* */
- //* Descriptive Name: This function ends LVM Engine logging and */
- //* closes the log file. */
- //* */
- //* Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
- //* in which to store an error code*/
- //* should an error occur. */
- //* */
- //* Output: *Error_Code will be 0 if this function completes */
- //* successfully; otherwise it will be > 0. */
- //* */
- //* Error Handling: If the log file is not currently opened, or if */
- //* the close operation fails on the log file, then */
- //* *Error_Code will be > 0. */
- //* */
- //* Side Effects: The log file may be closed. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- procedure Stop_Logging(Error_Code: PCARDINAL32); external 'lvm' name 'Stop_Logging';
- {$ifdef lists}
- (*
- * Description: This module implements a simple, generic, doubly linked list.
- * Data objects of any type can be placed into a linked list
- * created by this module. Futhermore, data objects of different
- * types may be placed into the same linked list.
- *
- * Notes: This linked list implementation makes use of the concept of the
- * current item. In any non-empty list, one item in the list will
- * be designated as the current item. When any of the following
- * functions are called, they will operate upon the current item
- * only: GetItem, ReplaceItem, DeleteItem, GetTag, NextItem,
- * PreviousItem, GetObject, ExtractItem, and ExtractObject. The
- * user of this module may set the current item through the use of
- * the GoToStartOfList, GoToEndOfList, NextItem, PreviousItem,
- * and GoToSpecifiedItem functions.
- *
- * Since a linked list created by this module may contain items
- * of different types, the user will need a way to identify items
- * of different types which may be in the same list. To allow users
- * to do this, the concept of an item tag is used. When an item is
- * added to the list, the user must enter an item tag. The item
- * tag is merely some identifier that the user wishes to associate
- * with the item being placed into the list. When used as intended,
- * each type of data item will have a unique tag associated with it.
- * This way, all data items of the same type will have the same tag
- * while data items of different types will have different tags.
- * Thus, by using the GetTag function, the user can get the item
- * tag for the current item without having to get the item from the
- * list. This allows the user to differentiate between items of
- * different types which reside in the same list.
- *
- * This module is single threaded. If used in a multi-threaded
- * environment, the user must implement appropriate access controls.
- *
- * When an item is inserted or appended to a list, this module
- * allocates memory on the heap to hold the item and then copies
- * the item to the memory that it allocated. This allows local
- * variables to be safely inserted or appended to a list. However,
- * it should be noted that under certain circumstances a copy of the
- * entire data item will NOT be made. Specifically, if the data item
- * is a structure or array containing pointers, then the data pointed
- * to by the pointers will NOT be copied even though the structure or
- * array is! This results from the fact that, when an item is being
- * inserted or appended to a list, the user provides just an address
- * and size. This module assumes that the item to inserted or append
- * lies in a contiguous block of memory at the address provided by the
- * user. This module has no way of knowing the structure of the data
- * at the specified address, and therefore can not know about any
- * embedded pointers which may lie within that block of memory.
- *
- * This module now employs the concept of a handle. A handle is a
- * reference to a specific item in a list which allows that item to
- * be made the current item in the list quickly. Example: If you
- * use the GetHandle function to get a handle for the current item
- * (lets call the item B1), then, regardless of where you are in the
- * list (or any reodering of the items in the list), you can make item
- * B1 the current item by passing its handle to the GoToSpecifiedItem
- * function. Alternatively, you could operate directly on B1 using
- * the other handle based functions, such as GetItem_By_Handle, for
- * example. GetItem_By_Handle gets the item associated with the
- * specified handle without changing which item in the list is the
- * current item in the list.
- *
- * The functions of this module refer to user data as either items or
- * objects. The difference between the two is simple, yet subtle. It
- * deals with who is responsible for the memory used to hold the data.
- * In the case of an item, this module is responsible for the memory
- * used to hold the user data. In the case of an object, the user
- * is responsible for the memory used to hold the data.
- *
- * What this means is that, for functions adding ITEMS to a list,
- * this module will be responsible for allocating memory to hold
- * the user data and then copying the user data into the memory
- * that was allocated. For functions which return items, this
- * module will COPY the user data from the LIST into a buffer
- * specified by the user. For functions which add objects to a
- * list, the user provides a pointer to a block of memory holding
- * user data. This block of memory was allocated by the user, and
- * becomes the "property" of this module once it has been added to
- * a LIST. For functions which return objects, a pointer to the
- * memory where the data is stored is returned. As long as an item/object
- * is in a LIST, this module will be responsible for the memory that
- * is used to store the data associated with that item. This means that
- * users of this module should not call free on an object returned by this
- * module as long as that object is still within a list.
- *
- *
- *)
- typedef unsigned long TAG;
- typedef ADDRESS DLIST;
- //*--------------------------------------------------
- //* Type definitions
- //--------------------------------------------------*/
- typedef enum _Insertion_Modes {
- InsertAtStart,
- InsertBefore,
- InsertAfter,
- AppendToList
- } Insertion_Modes;
- //************************************************
- //* Functions Available *
- //************************************************/
- //*
- //* The parameter *Error is set by every function in this module. It
- //* will be set to 0 to indicate success, and will be > 0 if an
- //* error occurs. The following table lists the possible error codes:
- //* 0 : No error.
- //* 1 : Out of memory
- //* 2 : Memory has been corrupted!
- //* 3 : Bad List Record!
- //* 4 : List Record not initialized yet!
- //* 5 : List is empty!
- //* 6 : Item size mismatch!
- //* 7 : Bad item pointer!
- //* 8 : Item has zero size!
- //* 9 : Item tag mismatch!
- //* 10 : Already at end of list!
- //* 11 : Already at start of list!
- //* 12 : Bad Handle!
- //* 13 : Invalid Insertion Mode!
- //*/
- const
- DLIST_SUCCESS = 0;
- DLIST_OUT_OF_MEMORY = 1;
- DLIST_CORRUPTED = 2;
- DLIST_BAD = 3;
- DLIST_NOT_INITIALIZED = 4;
- DLIST_EMPTY = 5;
- DLIST_ITEM_SIZE_WRONG = 6;
- DLIST_BAD_ITEM_POINTER = 7;
- DLIST_ITEM_SIZE_ZERO = 8;
- DLIST_ITEM_TAG_WRONG = 9;
- DLIST_END_OF_LIST =10;
- DLIST_ALREADY_AT_START =11;
- DLIST_BAD_HANDLE =12;
- DLIST_INVALID_INSERTION_MODE =13;
- ///* The following code is special. It is for use with the PruneList and ForEachItem functions. Basically, these functions
- //can be thought of as "searching" a list. They present each item in the list to a user supplied function which can then
- //operate on the items. If the user supplied function returns a non-zero error code, ForEachItem and PruneList abort and
- //return an error to the caller. This may be undesirable. If the user supplied function used with PruneList and ForEachItem
- //returns the code below, PruneList/ForEachItem will abort and return DLIST_SUCCESS. This allows PruneList and ForEachItem
- //to be used to search a list and terminate the search when the desired item is found without having to traverse the
- //remaining items in the list. */
- #define DLIST_SEARCH_COMPLETE 0xFF
- #ifdef USE_POOLMAN
- //*********************************************************************/
- //* */
- //* Function Name: CreateList */
- //* */
- //* Descriptive Name: This function allocates and initializes the */
- //* data structures associated with a list and */
- //* then returns a pointer to these structures. */
- //* */
- //* Input: CARDINAL32 InitialPoolSize - Each List gets a pool of */
- //* link nodes. When items are */
- //* added to the List, a link node*/
- //* is removed from the pool. */
- //* When an item is removed from */
- //* the List, the link node used */
- //* for that item is returned to */
- //* the pool. InitialPoolSize is */
- //* the number of link nodes to */
- //* place in the pool when the */
- //* pool is created. */
- //* CARDINAL32 MaximumPoolSize - When the pool runs out of */
- //* link nodes, new nodes are */
- //* allocated by the pool. When */
- //* these links start being */
- //* returned to the pool, the pool*/
- //* will grow. This parameter */
- //* puts a limit on how big the */
- //* pool may grow to. Once the */
- //* pool reaches this size, any */
- //* link nodes being returned to */
- //* the pool will be deallocated. */
- //* CARDINAL32 PoolIncrement - When the pool runs out of link*/
- //* nodes and more are required, */
- //* the pool will allocate one or */
- //* more link nodes. This tells the*/
- //* pool how many link nodes to */
- //* allocate at one time. */
- //* */
- //* Output: If Success : The function return value will be non-NULL */
- //* */
- //* If Failure : The function return value will be NULL. */
- //* */
- //* Error Handling: The function will only fail if it can not */
- //* allocate enough memory to create the new list */
- //* and its associated pool of link nodes. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- DLIST _System CreateList(CARDINAL32 InitialPoolSize,
- CARDINAL32 MaximumPoolSize,
- CARDINAL32 PoolIncrement);
- #else
- //*********************************************************************/
- //* */
- //* Function Name: CreateList */
- //* */
- //* Descriptive Name: This function allocates and initializes the */
- //* data structures associated with a list and */
- //* then returns a pointer to these structures. */
- //* */
- //* Input: None. */
- //* */
- //* Output: If Success : The function return value will be non-NULL */
- //* */
- //* If Failure : The function return value will be NULL. */
- //* */
- //* Error Handling: The function will only fail if it can not */
- //* allocate enough memory to create the new list. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- DLIST _System CreateList( void );
- #endif
- //*********************************************************************/
- //* */
- //* Function Name: InsertItem */
- //* */
- //* Descriptive Name: This function inserts an item into a DLIST. */
- //* The item can be placed either before or */
- //* after the current item in the DLIST. */
- //* */
- //* Input: DLIST ListToAddTo : The list to which the */
- //* data item is to be */
- //* added. */
- //* CARDINAL32 ItemSize : The size of the data item, in */
- //* bytes. */
- //* ADDRESS ItemLocation : The address of the data */
- //* to append to the list */
- //* TAG ItemTag : The item tag to associate with */
- //* item being appended to the list */
- //* ADDRESS TargetHandle : The item in ListToAddTo which */
- //* is used to determine where */
- //* the item being transferred will */
- //* be placed. If this is NULL, */
- //* then the current item in */
- //* ListToAddTo will be used. */
- //* Insertion_Modes InsertMode : This indicates where, */
- //* relative to the item in */
- //* ListToAddTo specified by */
- //* Target_Handle, the item being */
- //* inserted can be placed. */
- //* BOOLEAN MakeCurrent : If TRUE, the item being inserted */
- //* into ListToAddTo becomes the */
- //* current item in ListToAddTo. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If the operation is successful, then *Error will be */
- //* set to 0 and the function return value will be the */
- //* handle for the item that was appended to the list. */
- //* If the operation fails, then *Error will contain an */
- //* error code and the function return value will be NULL. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToAddTo does not point to a valid */
- //* list */
- //* ItemSize is 0 */
- //* ItemLocation is NULL */
- //* The memory required to hold a copy of the */
- //* item can not be allocated. */
- //* The memory required to create a LINK NODE */
- //* can not be allocated. */
- //* TargetHandle is invalid or is for an item */
- //* in another list. */
- //* If this routine fails, an error code is returned*/
- //* and any memory allocated by this function is */
- //* freed. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The item to add is copied to the heap to */
- //* avoid possible conflicts with the usage of */
- //* local variables in functions which process */
- //* DLISTs. However, a pointer to a local variable */
- //* should not be appended to the DLIST. */
- //* */
- //* It is assumed that TargetHandle is valid, or is at least*/
- //* the address of an accessible block of storage. If */
- //* TargetHandle is invalid, or is not the address of an */
- //* accessible block of storage, then a trap or exception */
- //* may occur. */
- //* */
- //* It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* */
- //*********************************************************************/
- ADDRESS _System InsertItem ( DLIST ListToAddTo,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- ADDRESS TargetHandle,
- Insertion_Modes Insert_Mode,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: InsertObject */
- //* */
- //* Descriptive Name: This function inserts an object into a DLIST.*/
- //* The object can be inserted before or after */
- //* the current item in the list. */
- //* */
- //* Input: DLIST ListToAddTo : The list to which the */
- //* data object is to be */
- //* inserted. */
- //* CARDINAL32 ItemSize : The size of the data item, in */
- //* bytes. */
- //* ADDRESS ItemLocation : The address of the data */
- //* to append to the list */
- //* TAG ItemTag : The item tag to associate with */
- //* the item being appended to the */
- //* list */
- //* ADDRESS TargetHandle : The item in ListToAddTo which */
- //* is used to determine where */
- //* the item being transferred will */
- //* be placed. If this is NULL, */
- //* then the current item in */
- //* ListToAddTo will be used. */
- //* Insertion_Modes InsertMode : This indicates where, */
- //* relative to the item in */
- //* ListToAddTo specified by */
- //* Target_Handle, the item being */
- //* inserted can be placed. */
- //* BOOLEAN MakeCurrent : If TRUE, the item being inserted */
- //* into ListToAddTo becomes the */
- //* current item in ListToAddTo. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If the operation is successful, then *Error will be */
- //* set to 0 and the function return value will be the */
- //* handle for the item that was appended to the list. */
- //* If the operation fails, then *Error will contain an */
- //* error code and the function return value will be NULL. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToAddTo does not point to a valid */
- //* list */
- //* ItemSize is 0 */
- //* ItemLocation is NULL */
- //* The memory required for a LINK NODE can not */
- //* be allocated. */
- //* TargetHandle is invalid or is for an item */
- //* in another list. */
- //* If this routine fails, an error code is returned*/
- //* and any memory allocated by this function is */
- //* freed. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The item to insert is NOT copied to the heap. Instead, */
- //* the location of the item is stored in the list. This */
- //* is the major difference between InsertObject and */
- //* InsertItem. InsertItem allocates memory on the heap, */
- //* copies the item to the memory it allocated, and stores */
- //* the address of the memory it allocated in the list. */
- //* InsertObject stores the address provided by the user. */
- //* */
- //* It is assumed that TargetHandle is valid, or is at least*/
- //* the address of an accessible block of storage. If */
- //* TargetHandle is invalid, or is not the address of an */
- //* accessible block of storage, then a trap or exception */
- //* may occur. */
- //* */
- //* It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* */
- //*********************************************************************/
- ADDRESS _System InsertObject ( DLIST ListToAddTo,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- ADDRESS TargetHandle,
- Insertion_Modes Insert_Mode,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: DeleteItem */
- //* */
- //* Descriptive Name: This function removes the specified item from*/
- //* the list and optionally frees the memory */
- //* associated with it. */
- //* */
- //* Input: DLIST ListToDeleteFrom : The list whose current */
- //* item is to be deleted. */
- //* BOOLEAN FreeMemory : If TRUE, then the memory */
- //* associated with the current */
- //* item will be freed. If FALSE */
- //* then the current item will be */
- //* removed from the list but its */
- //* memory will not be freed. */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides*/
- //* in ListToDeleteFrom, or NULL. If */
- //* NULL is used, then the current item */
- //* in ListToDeleteFrom will be deleted. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If the operation is successful, then *Error will be */
- //* set to 0. If the operation fails, then *Error will */
- //* contain an error code. */
- //* */
- //* Error Handling: This function will fail if ListToDeleteFrom is */
- //* not a valid list, or if ListToDeleteFrom is */
- //* empty, or if Handle is invalid. */
- //* If this routine fails, an error code is returned*/
- //* in *Error. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: Items in a list can be accessed in two ways: A copy of */
- //* the item can be obtained using GetItem and its related */
- //* calls, or a pointer to the item can be obtained using */
- //* GetObject and its related calls. If you have a copy of */
- //* the data and wish to remove the item from the list, set */
- //* FreeMemory to TRUE. This will remove the item from the */
- //* list and deallocate the memory used to hold it. If you */
- //* have a pointer to the item in the list (from one of the */
- //* GetObject style functions) and wish to remove the item */
- //* from the list, set FreeMemory to FALSE. This removes */
- //* the item from the list without freeing its memory, so */
- //* that the pointer obtained with the GetObject style */
- //* functions is still useable. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is considered a valid */
- //* handle which refers to the current item in */
- //* ListToDeleteFrom. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list, unless the handle specified belongs */
- //* to the current item in the list, in which case the */
- //* item following the current item becomes the current */
- //* item in the list. If there is no item following the */
- //* current item in the list, then the item preceeding the */
- //* current item will become the current item in the list. */
- //* */
- //*********************************************************************/
- void _System DeleteItem (DLIST ListToDeleteFrom,
- BOOLEAN FreeMemory,
- ADDRESS Handle,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: DeleteAllItems */
- //* */
- //* Descriptive Name: This function deletes all of the items in the*/
- //* specified list and optionally frees the */
- //* memory associated with each item deleted. */
- //* */
- //* Input: DLIST ListToDeleteFrom : The list whose items */
- //* are to be deleted. */
- //* BOOLEAN FreeMemory : If TRUE, then the memory */
- //* associated with each item in the*/
- //* list will be freed. If FALSE */
- //* then the each item will be */
- //* removed from the list but its */
- //* memory will not be freed. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If the operation is successful, then *Error will be */
- //* set to 0. If the operation fails, then *Error will */
- //* contain an error code. */
- //* */
- //* Error Handling: This function will fail if ListToDeleteFrom is */
- //* not a valid list, or if ListToDeleteFrom is */
- //* empty. */
- //* If this routine fails, an error code is returned*/
- //* in *Error. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: Items in a list can be accessed in two ways: A copy of */
- //* the item can be obtained using GetItem and its related */
- //* calls, or a pointer to the item can be obtained using */
- //* GetObject and its related calls. If you have a copy of */
- //* the data and wish to remove the item from the list, set */
- //* FreeMemory to TRUE. This will remove the item from the */
- //* list and deallocate the memory used to hold it. If you */
- //* have a pointer to the item in the list (from one of the */
- //* GetObject style functions) and wish to remove the item */
- //* from the list, set FreeMemory to FALSE. This removes */
- //* the item from the list without freeing its memory, so */
- //* that the pointer obtained with the GetObject style */
- //* functions is still useable. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System DeleteAllItems (DLIST ListToDeleteFrom,
- BOOLEAN FreeMemory,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetItem */
- //* */
- //* Descriptive Name: This function copies the specified item in */
- //* the list to a buffer provided by the caller. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* ADDRESS ItemLocation : This is the location of the */
- //* buffer into which the current*/
- //* item is to be copied. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides*/
- //* in ListToGetItemFrom, or NULL. If */
- //* NULL, then the current item in the list*/
- //* will be used. */
- //* BOOLEAN MakeCurrent : If TRUE, the item to get will */
- //* become the current item in the */
- //* list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The buffer at ItemLocation will contain a copy of */
- //* the current item from ListToGetItemFrom. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemLocation is NULL */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is considered a valid */
- //* handle corresponding to the current item in the */
- //* list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list. */
- //* */
- //*********************************************************************/
- void _System GetItem( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- ADDRESS Handle,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetNextItem */
- //* */
- //* Descriptive Name: This function advances the current item */
- //* pointer and then copies the current item in */
- //* the list to a buffer provided by the caller. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* ADDRESS ItemLocation : This is the location of the */
- //* buffer into which the current*/
- //* item is to be copied. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The buffer at ItemLocation will contain a copy of */
- //* the current item from ListToGetItemFrom. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The current item pointer will NOT be advanced. */
- //* The current item in the list will be the same */
- //* as before the call to this function. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemLocation is NULL */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* The current item in the list before this */
- //* function is called is the last item */
- //* item in the list. */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System GetNextItem( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetPreviousItem */
- //* */
- //* Descriptive Name: This function makes the previous item in the */
- //* list the current item in the list and then */
- //* copies that item to a buffer provided by the */
- //* user. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* ADDRESS ItemLocation : This is the location of the */
- //* buffer into which the current*/
- //* item is to be copied. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The buffer at ItemLocation will contain a copy of */
- //* the current item from ListToGetItemFrom. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The current item pointer will NOT be advanced. */
- //* The current item in the list will be the same */
- //* as before the call to this function. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemLocation is NULL */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* The current item in the list before this */
- //* function is called is the last item */
- //* item in the list. */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System GetPreviousItem( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetObject */
- //* */
- //* Descriptive Name: This function returns the address of the data*/
- //* associated with the specified item in the */
- //* list. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to have its address */
- //* returned to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides*/
- //* in ListToGetItemFrom, or NULL. If */
- //* NULL, then the current item in the list*/
- //* BOOLEAN MakeCurrent : If TRUE, the item to get will */
- //* become the current item in the */
- //* list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The function return value will be the address of */
- //* the data associated with the current item in the */
- //* list. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The function return value will be NULL. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The user should not free the memory associated with */
- //* the address returned by this function as the object is */
- //* still in the list. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap may */
- //* occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is considered a valid */
- //* handle designating the current item in the list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list. */
- //* */
- //*********************************************************************/
- ADDRESS _System GetObject( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- TAG ItemTag,
- ADDRESS Handle,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetNextObject */
- //* */
- //* Descriptive Name: This function advances the current item */
- //* pointer and then returns the address of the */
- //* data associated with the current item in the */
- //* list. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The function return value will be the address of */
- //* the data associated with the current item in the */
- //* list. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The function return value will be NULL. */
- //* The current item pointer will NOT be advanced. */
- //* The current item in the list will be the same */
- //* as before the call to this function. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* The current item in the list before this */
- //* function is called is the last item */
- //* item in the list. */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The user should not free the memory associated with */
- //* the address returned by this function as the object is */
- //* still in the list. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption are violated, an exception or trap may */
- //* occur. */
- //* */
- //*********************************************************************/
- ADDRESS _System GetNextObject( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- TAG ItemTag,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetPreviousObject */
- //* */
- //* Descriptive Name: This function makes the previous item in the */
- //* list the current item and then returns the */
- //* address of the data associated with the */
- //* current item in the list. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The function return value will be the address of */
- //* the data associated with the current item in the */
- //* list. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The function return value will be NULL. */
- //* The current item pointer will NOT be advanced. */
- //* The current item in the list will be the same */
- //* as before the call to this function. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* The current item in the list before this */
- //* function is called is the last item */
- //* item in the list. */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The user should not free the memory associated with */
- //* the address returned by this function as the object is */
- //* still in the list. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption are violated, an exception or trap may */
- //* occur. */
- //* */
- //*********************************************************************/
- ADDRESS _System GetPreviousObject( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- TAG ItemTag,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ExtractItem */
- //* */
- //* Descriptive Name: This function copies the specified item in */
- //* the list to a buffer provided by the caller */
- //* and removes the item from the list. */
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* ADDRESS ItemLocation : This is the location of the */
- //* buffer into which the current*/
- //* item is to be copied. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides*/
- //* in ListToGetItemFrom, or NULL. If */
- //* NULL, then the current item in the list*/
- //* will be used. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The buffer at ItemLocation will contain a copy of */
- //* the current item from ListToGetItemFrom. */
- //* The item will have been removed from the list and */
- //* its memory deallocated. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemLocation is NULL */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is considered a valid */
- //* handle which refers to the current item in the */
- //* list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list, unless the handle specified belongs */
- //* to the current item in the list, in which case the */
- //* item following the current item becomes the current */
- //* item in the list. If there is no item following the */
- //* current item in the list, then the item preceeding the */
- //* current item will become the current item in the list. */
- //* */
- //*********************************************************************/
- void _System ExtractItem( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- ADDRESS Handle,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ExtractObject */
- //* */
- //* Descriptive Name: This function returns the address of the data*/
- //* associated with the specified item in the */
- //* list and then removes that item from the list*/
- //* */
- //* Input: DLIST ListToGetItemFrom : The list whose current item */
- //* is to be copied and returned */
- //* to the caller. */
- //* CARDINAL32 ItemSize : What the caller thinks the size of*/
- //* the current item is. */
- //* TAG ItemTag : What the caller thinks the item tag */
- //* of the current item is. */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides*/
- //* in ListToGetItemFrom, or NULL. If */
- //* NULL, then the current item in the */
- //* list will be used. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code. */
- //* */
- //* Output: If Successful : */
- //* *Error will be set to 0. */
- //* The function return value will be the address of */
- //* the data associated with the current item in the */
- //* list. */
- //* The current item is removed from the list. */
- //* If Failure : */
- //* *Error will contain an error code. */
- //* The function return value will be NULL. */
- //* */
- //* Error Handling: This function will fail under any of the */
- //* following conditions: */
- //* ListToGetItemFrom is not a valid list */
- //* ItemSize does not match the size of the */
- //* current item in the list */
- //* ItemTag does not match the item tag */
- //* of the current item in the list */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occur, *Error will */
- //* contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The user is responsible for the memory associated with */
- //* the address returned by this function since this */
- //* function removes that object from the list. This means */
- //* that, when the user is through with the object, they */
- //* should free it. */
- //* */
- //* It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap may */
- //* occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is considered a valid */
- //* handle which refers to the current item in the */
- //* list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list, unless the handle specified belongs */
- //* to the current item in the list, in which case the */
- //* item following the current item becomes the current */
- //* item in the list. If there is no item following the */
- //* current item in the list, then the item preceeding the */
- //* current item will become the current item in the list. */
- //* */
- //*********************************************************************/
- ADDRESS _System ExtractObject( DLIST ListToGetItemFrom,
- CARDINAL32 ItemSize,
- TAG ItemTag,
- ADDRESS Handle,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ReplaceItem */
- //* */
- //* Descriptive Name: This function replaces the specified item in */
- //* the list with the one provided as its */
- //* argument. */
- //* */
- //* Input: DLIST ListToReplaceItemIn : The list whose current item*/
- //* is to be replaced */
- //* CARDINAL32 ItemSize : The size, in bytes, of the */
- //* replacement item */
- //* ADDRESS ItemLocation : The address of the replacement*/
- //* item */
- //* TAG ItemTag : The item tag that the user wishes to */
- //* associate with the replacement item */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides */
- //* in ListToGetItemFrom, or NULL. If NULL */
- //* then the current item in the list will */
- //* used. */
- //* BOOLEAN MakeCurrent : If TRUE, the item to get will */
- //* become the current item in the */
- //* list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If Successful then *Error will be set to 0. */
- //* If Unsuccessful, then *Error will be set to a non-zero */
- //* error code. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToReplaceItemIn is empty */
- //* ItemSize is 0 */
- //* ItemLocation is NULL */
- //* The memory required can not be allocated. */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occurs, *Error */
- //* will contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is a valid handle which */
- //* refers to the current item in the list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list. */
- //* */
- //*********************************************************************/
- void _System ReplaceItem( DLIST ListToReplaceItemIn,
- CARDINAL32 ItemSize,
- ADDRESS ItemLocation,
- TAG ItemTag,
- ADDRESS Handle,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ReplaceObject */
- //* */
- //* Descriptive Name: This function replaces the specified object */
- //* in the list with the one provided as its */
- //* argument. */
- //* */
- //* Input: DLIST ListToReplaceItemIn : The list whose current */
- //* object is to be replaced */
- //* CARDINAL32 ItemSize : The size, in bytes, of the */
- //* replacement object */
- //* ADDRESS ItemLocation : The address of the replacement*/
- //* item */
- //* TAG ItemTag : The item tag that the user wishes to */
- //* associate with the replacement item */
- //* ADDRESS Handle : The handle of the item to get. This */
- //* handle must be of an item which resides */
- //* in ListToGetItemFrom, or NULL. If NULL */
- //* then the current item in the list will */
- //* be used. */
- //* BOOLEAN MakeCurrent : If TRUE, the item to get will */
- //* become the current item in the */
- //* list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If Successful then *Error will be set to 0 and the */
- //* return value of the function will be the address */
- //* of the object that was replaced. */
- //* If Unsuccessful, then *Error will be set to a non-zero */
- //* error code and the function return value will be */
- //* NULL. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToReplaceItemIn is empty */
- //* ItemSize is 0 */
- //* ItemLocation is NULL */
- //* The memory required can not be allocated. */
- //* Handle is invalid, or is for an item */
- //* which is not in ListToGetItemFrom */
- //* If any of these conditions occurs, *Error */
- //* will contain a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: The user is responsible for the memory associated with */
- //* the object returned by this function as that object is */
- //* removed from the list. This means that, when the user */
- //* is through with the object returned by this function, */
- //* they should free it. */
- //* */
- //* It is assumed that Error contains a valid address. It */
- //* is also assumed that if ItemLocation is not NULL, then */
- //* it is a valid address that can be dereferenced. If */
- //* these assumptions are violated, an exception or trap */
- //* may occur. */
- //* */
- //* It is assumed that Handle is valid, or is at least the */
- //* address of an accessible block of storage. If Handle */
- //* is invalid, or is not the address of an accessible block*/
- //* of storage, then a trap or exception may occur. */
- //* NOTE: For this function, NULL is a valid handle for the */
- //* current item in the list. */
- //* */
- //* This function does not alter which item is the current */
- //* item in the list. */
- //* */
- //*********************************************************************/
- ADDRESS _System ReplaceObject( DLIST ListToReplaceItemIn,
- CARDINAL32 * ItemSize, /* On input - size of new object. On return = size of old object. */
- ADDRESS ItemLocation,
- TAG * ItemTag, /* On input - TAG of new object. On return = TAG of old object. */
- ADDRESS Handle,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetTag */
- //* */
- //* Descriptive Name: This function returns the item tag associated*/
- //* with the current item in the list. */
- //* */
- //* Input: DLIST ListToGetTagFrom : The list from which the item */
- //* tag of the current item is to */
- //* be returned */
- //* ADDRESS Handle : The handle of the item whose TAG and */
- //* size we are to get. This handle must */
- //* be of an item which resides in */
- //* in ListToGetTagFrom, or NULL. If NULL */
- //* then the current item in the list will */
- //* be used. */
- //* CARDINAL32 * ItemSize : The size, in bytes, of the */
- //* current item in the list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns the item tag & size*/
- //* associated with the current item in ListToGetTagFrom*/
- //* and *Error is set to 0. */
- //* If unsuccessful, the function returns 0 and *Error is */
- //* set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToGetTagFrom is */
- //* not a valid list or is an empty list. In either*/
- //* of these cases, *Error is set to a non-zero */
- //* error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //* */
- //*********************************************************************/
- TAG _System GetTag( DLIST ListToGetTagFrom,
- ADDRESS Handle,
- CARDINAL32 * ItemSize,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetHandle */
- //* */
- //* Descriptive Name: This function returns a handle for the */
- //* current item in the list. This handle is */
- //* then associated with that item regardless of */
- //* its position in the list. This handle can be*/
- //* used to make its associated item the current */
- //* item in the list. */
- //* */
- //* Input: DLIST ListToGetHandleFrom : The list from which a */
- //* handle is needed. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns a handle for the */
- //* the current item in ListToGetHandleFrom, and *Error */
- //* is set to 0. */
- //* If unsuccessful, the function returns 0 and *Error is */
- //* set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToGetHandleFrom */
- //* is not a valid list or is an empty list. In */
- //* either of these cases, *Error is set to a */
- //* non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //* The handle returned is a pointer to an internal */
- //* structure within the list. If the item associated */
- //* with this handle is removed from the list, the handle */
- //* will be invalid and should not be used as the internal */
- //* structure it points to will nolonger exist! */
- //* */
- //*********************************************************************/
- ADDRESS _System GetHandle ( DLIST ListToGetHandleFrom, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GetListSize */
- //* */
- //* Descriptive Name: This function returns the number of items in */
- //* a list. */
- //* */
- //* Input: DLIST ListToGetSizeOf : The list whose size we wish to*/
- //* know */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns the a count of the */
- //* number of items in the list, and *Error is set to 0.*/
- //* If unsuccessful, the function returns 0 and *Error is */
- //* set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToGetSizeOf is */
- //* not a valid list. If this happens, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- CARDINAL32 _System GetListSize( DLIST ListToGetSizeOf, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ListEmpty */
- //* */
- //* Descriptive Name: This function returns TRUE if the */
- //* specified list is empty, otherwise it returns*/
- //* FALSE. */
- //* */
- //* Input: DLIST ListToCheck : The list to check to see if it*/
- //* is empty */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns TRUE if the */
- //* number of items in the list is 0, otherwise it */
- //* returns FALSE. Also, *Error is set to 0. */
- //* If unsuccessful, the function returns TRUE and */
- //* *Error is set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToCheck is not */
- //* a valid list. If this happens, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- BOOLEAN _System ListEmpty( DLIST ListToCheck, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: AtEndOfList */
- //* */
- //* Descriptive Name: This function returns TRUE if the */
- //* current item in the list is the last item */
- //* in the list. Returns FALSE otherwise. */
- //* */
- //* Input: DLIST ListToCheck : The list to check. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns TRUE if the */
- //* current item in the list is the last item in the */
- //* list. If it is not the last item in the list, */
- //* FALSE is returned. *Error_Code is set to */
- //* DLIST_SUCCESS. */
- //* If unsuccessful, the function returns FALSE and */
- //* *Error is set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToCheck is not */
- //* a valid list. If this happens, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- BOOLEAN _System AtEndOfList( DLIST ListToCheck, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: AtStartOfList */
- //* */
- //* Descriptive Name: This function returns TRUE if the */
- //* current item in the list is the first item */
- //* in the list. Returns FALSE otherwise. */
- //* */
- //* Input: DLIST ListToCheck : The list to check. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, the function returns TRUE if the */
- //* current item in the list is the first item in the */
- //* list. If it is not the first item in the list, */
- //* FALSE is returned. *Error_Code is set to */
- //* DLIST_SUCCESS. */
- //* If unsuccessful, the function returns FALSE and */
- //* *Error is set to a non-zero error code. */
- //* */
- //* Error Handling: This function will fail if ListToCheck is not */
- //* a valid list. If this happens, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- BOOLEAN _System AtStartOfList( DLIST ListToCheck, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: DestroyList */
- //* */
- //* Descriptive Name: This function releases the memory associated */
- //* with the internal data structures of a DLIST.*/
- //* Once a DLIST has been eliminated by this */
- //* function, it must be reinitialized before it */
- //* can be used again. */
- //* */
- //* Input: DLIST ListToDestroy : The list to be eliminated */
- //* from memory. */
- //* BOOLEAN FreeItemMemory : If TRUE, all items in the list */
- //* will be freed. If FALSE, all */
- //* items in the list are not */
- //* freed, only the list structures*/
- //* associated with them are. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail if ListToDestroy is not */
- //* a valid list. If this happens, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //* If FreeItemMemory is TRUE, then this function will try */
- //* to delete any items which may be in the list. However, */
- //* since this function has no way of knowing the internal */
- //* structure of an item, items which contain embedded */
- //* pointers will not be entirely freed. This can lead to */
- //* memory leaks. The programmer should ensure that any */
- //* list passed to this function when the FreeItemMemory */
- //* parameter is TRUE is empty or does not contain any */
- //* items with embedded pointers. */
- //* */
- //*********************************************************************/
- void _System DestroyList( DLIST * ListToDestroy, BOOLEAN FreeItemMemory, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: NextItem */
- //* */
- //* Descriptive Name: This function makes the next item in the list*/
- //* the current item in the list (i.e. it */
- //* advances the current item pointer). */
- //* */
- //* Input: DLIST ListToAdvance : The list whose current item */
- //* pointer is to be advanced */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToAdvance is not a valid list */
- //* ListToAdvance is empty */
- //* The current item is the last item in the */
- //* list */
- //* If any of these conditions occurs, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System NextItem( DLIST ListToAdvance, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: PreviousItem */
- //* */
- //* Descriptive Name: This function makes the previous item in the */
- //* list the current item in the list. */
- //* */
- //* Input: DLIST ListToChange : The list whose current item */
- //* pointer is to be changed */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail under the following */
- //* conditions: */
- //* ListToChange is not a valid list */
- //* ListToChange is empty */
- //* The current item is the first item in the */
- //* list */
- //* If any of these conditions occurs, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System PreviousItem( DLIST ListToChange, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GoToStartOfList */
- //* */
- //* Descriptive Name: This function makes the first item in the */
- //* list the current item in the list. */
- //* */
- //* Input: DLIST ListToReset : The list whose current item */
- //* is to be set to the first item */
- //* in the list */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail if ListToReset is not */
- //* a valid list. If this occurs, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System GoToStartOfList( DLIST ListToReset, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GoToEndOfList */
- //* */
- //* Descriptive Name: This function makes the last item in the */
- //* list the current item in the list. */
- //* */
- //* Input: DLIST ListToSet : The list whose current item */
- //* is to be set to the last item */
- //* in the list */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail if ListToSet is not */
- //* a valid list. If this occurs, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System GoToEndOfList( DLIST ListToSet, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: GoToSpecifiedItem */
- //* */
- //* Descriptive Name: This function makes the item associated with */
- //* Handle the current item in the list. */
- //* */
- //* Input: DLIST ListToReposition: The list whose current item */
- //* is to be set to the item */
- //* associated with Handle. */
- //* ADDRESS Handle : A handle obtained by using the */
- //* GetHandle function. This handle */
- //* identifies a unique item in the list. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return code */
- //* */
- //* Output: If successful, *Error will be set to 0. */
- //* If unsuccessful, *Error will be set to a non-zero error*/
- //* code. */
- //* */
- //* Error Handling: This function will fail if ListToReposition is */
- //* not a valid list. If this occurs, then *Error */
- //* is set to a non-zero error code. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //* */
- //* It is assumed that Handle is a valid handle and that */
- //* the item associated with Handle is still in the list. */
- //* If these conditions are not met, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System GoToSpecifiedItem( DLIST ListToReposition, ADDRESS Handle, CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: SortList */
- //* */
- //* Descriptive Name: This function sorts the contents of a list. */
- //* The sorting algorithm used is a stable sort */
- //* whose performance is not dependent upon the */
- //* initial order of the items in the list. */
- //* */
- //* Input: DLIST ListToSort : The DLIST that is to be sorted. */
- //* */
- //* INTEGER32 ( *Compare) ( ... ) */
- //* */
- //* This is a pointer to a function that can compare any */
- //* two items in the list. It should return -1 if */
- //* Object1 is less than Object2, 0 if Object1 is equal */
- //* to Object2, and 1 if Object1 is greater than Object2.*/
- //* This function will be called during the sort whenever*/
- //* the sorting algorithm needs to compare two objects. */
- //* */
- //* The Compare function takes the following parameters: */
- //* */
- //* ADDRESS Object1 : The address of the data for the */
- //* first object to be compared. */
- //* TAG Object1Tag : The user assigned TAG value for the */
- //* first object to be compared. */
- //* ADDRESS Object2 : The address of the data for the */
- //* second object to be compared. */
- //* TAG Object2Tag : The user assigned TAG value for the */
- //* second object to be compared. */
- //* CARDINAL32 * Error : The address of a variable to */
- //* hold the error return value. */
- //* */
- //* If this function ever sets *Error to a non-zero value*/
- //* the sort will terminate and the error code will be */
- //* returned to the caller of the SortList function. */
- //* */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return value. */
- //* */
- //* Output: If successful, this function will set *Error to */
- //* DLIST_SUCCESS and ListToSort will have been sorted. */
- //* If unsuccessful, *Error will contain an error code. */
- //* The order of the items in ListToSort is undefined */
- //* and may have changed. */
- //* */
- //* Error Handling: This function will terminate if *Compare sets */
- //* *Error to a non-zero value, or if ListToSort */
- //* is invalid. If this function does terminate in */
- //* the middle of a sort, the order of the items in */
- //* ListToSort may be different than it was before */
- //* the function was called. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: It is assumed that Error contains a valid address. If */
- //* this assumption is violated, an exception or trap */
- //* may occur. */
- //* */
- //*********************************************************************/
- void _System SortList(DLIST ListToSort,
- INTEGER32 ( * _System Compare) (ADDRESS Object1, TAG Object1Tag, ADDRESS Object2, TAG Object2Tag,CARDINAL32 * Error),
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: ForEachItem */
- //* */
- //* Descriptive Name: This function passes a pointer to each item */
- //* in a list to a user provided function for */
- //* processing by the user provided function. */
- //* */
- //* Input: DLIST ListToProcess : The DLIST whose items are to be */
- //* processed by the user provided */
- //* function. */
- //* */
- //* void ( * ProcessItem) (...) */
- //* */
- //* This is a pointer to the user provided function. */
- //* This user provided function takes the following */
- //* parameters: */
- //* */
- //* ADDRESS Object : A pointer to an item in */
- //* ListToProcess. */
- //* TAG Object1Tag : The user assigned TAG value for */
- //* the item pointed to by Object. */
- //* ADDRESS Parameter : The address of a block of */
- //* memory containing any */
- //* parameters that the user */
- //* wishes to have passed to this*/
- //* function. */
- //* CARDINAL32 * Error : The address of a variable to*/
- //* hold the error return value.*/
- //* */
- //* ADDRESS Parameters : This field is passed through to */
- //* *ProcessItem. This function does */
- //* not even look at the contents of */
- //* this field. This field is here to */
- //* provide the user a way to pass */
- //* additional data to *ProcessItem */
- //* that *ProcessItem may need to */
- //* function correctly. */
- //* */
- //* BOOLEAN Forward : If TRUE, then the list is traversed */
- //* from the start of the list to the end */
- //* of the list. If FALSE, then the list */
- //* is traversed from the end of the list */
- //* to the beginning. */
- //* */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return value. */
- //* */
- //* Output: If successful, this function will set *Error to */
- //* DLIST_SUCCESS. */
- //* If unsuccessful, then this function will set *Error to */
- //* a non-zero error code. */
- //* */
- //* Error Handling: This function aborts immediately when an error */
- //* is detected, and any remaining items in the list*/
- //* will not be processed. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: This function allows the user to access all of the items */
- //* in a list and perform an operation on them. The */
- //* operation performed must not free any items in the list, */
- //* or perform any list operations on the list being */
- //* processed. */
- //* */
- //* As an example of when this would be useful, consider a */
- //* a list of graphic objects (rectangles, triangles, circles*/
- //* etc.) which comprise a drawing. To draw the picture */
- //* that these graphic objects represent, one could build a */
- //* loop which gets and draws each item. Another way to */
- //* do this would be to build a drawing function which can */
- //* draw any of the graphic objects, and then use that */
- //* function as the ProcessItem function in a call to */
- //* ForEachItem. */
- //* */
- //* If the ProcessItem function sets *Error to something */
- //* other than DLIST_SUCCESS, then ForEachItem will terminate*/
- //* and return an error to whoever called it. The single */
- //* exception to this is if ProcessItem sets *Error to */
- //* DLIST_SEARCH_COMPLETE, in which case ForEachItem */
- //* terminates and sets *Error to DLIST_SUCCESS. This is */
- //* useful for using ForEachItem to search a list and then */
- //* terminating the search once the desired item is found. */
- //* */
- //* A word about the Parameters parameter. This parameter */
- //* is passed through to *ProcessItem and is never looked at */
- //* by this function. This means that the user can put any */
- //* value they desire into Parameters as long as it is the */
- //* same size (in bytes) as Parameters. The intended use of */
- //* Parameters is to allow the user to pass information to */
- //* *ProcessItem that *ProcessItem may need. Either way, */
- //* how Parameters is used is literally up to the user. */
- //* */
- //*********************************************************************/
- void _System ForEachItem(DLIST ListToProcess,
- void ( * _System ProcessItem) (ADDRESS Object, TAG ObjectTag, CARDINAL32 ObjectSize, ADDRESS ObjectHandle, ADDRESS Parameters, CARDINAL32 * Error),
- ADDRESS Parameters,
- BOOLEAN Forward,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: PruneList */
- //* */
- //* Descriptive Name: This function allows the caller to examine */
- //* each item in a list and optionally delete */
- //* it from the list. */
- //* */
- //* Input: DLIST ListToProcess : The DLIST to be pruned. */
- //* */
- //* BOOLEAN ( * KillItem) (...) */
- //* */
- //* This is a pointer to a user provided function. */
- //* This user provided function takes the following */
- //* parameters: */
- //* */
- //* ADDRESS Object : A pointer to an item in */
- //* ListToProcess. */
- //* TAG Object1Tag : The user assigned TAG value for */
- //* the item pointed to by Object. */
- //* ADDRESS Parameter : The address of a block of */
- //* memory containing any */
- //* parameters that the user */
- //* wishes to have passed to this*/
- //* function. */
- //* BOOLEAN * FreeMemory : The address of a BOOLEAN */
- //* variable which this */
- //* function will set to */
- //* either TRUE or FALSE. */
- //* If the function return */
- //* value is TRUE, then the */
- //* value in *FreeMemory will */
- //* be examined. If it is */
- //* TRUE, then PruneList will */
- //* free the memory associated*/
- //* with the item being */
- //* deleted. If *FreeMemory */
- //* is FALSE, then the item */
- //* being removed from the */
- //* DLIST will not be freed, */
- //* and it is up to the user */
- //* to ensure that this memory*/
- //* is handled properly. */
- //* CARDINAL32 * Error : The address of a variable to*/
- //* hold the error return value.*/
- //* */
- //* ADDRESS Parameters : This field is passed through to */
- //* *ProcessItem. This function does */
- //* not even look at the contents of */
- //* this field. This field is here to */
- //* provide the user a way to pass */
- //* additional data to *ProcessItem */
- //* that *ProcessItem may need to */
- //* function correctly. */
- //* */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return value. */
- //* */
- //* Output: If successful, this function will set *Error to */
- //* DLIST_SUCCESS. */
- //* If unsuccessful, then this function will set *Error to */
- //* a non-zero error code. */
- //* */
- //* Error Handling: This function aborts immediately when an error */
- //* is detected, and any remaining items in the list*/
- //* will not be processed. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: This function allows the user to access all of the items */
- //* in a list, perform an operation on them, and then */
- //* optionally delete ("remove") them from the DLIST. The */
- //* operation performed must not free any items in the list, */
- //* or perform any list operations on the list being */
- //* processed. */
- //* */
- //* If the KillItem function sets *Error to something other */
- //* than DLIST_SUCCESS, then PruneList will terminate and */
- //* return an error to whoever called it. The single */
- //* exception to this is if KillItem sets *Error to */
- //* DLIST_SEARCH_COMPLETE, in which case KillItem */
- //* terminates and sets *Error to DLIST_SUCCESS. This is */
- //* useful for using KillItem to search a list and then */
- //* terminating the search once the desired item is found. */
- //* */
- //* A word about the Parameters parameter. This parameter */
- //* is passed through to *ProcessItem and is never looked at */
- //* by this function. This means that the user can put any */
- //* value they desire into Parameters as long as it is the */
- //* same size (in bytes) as Parameters. The intended use of */
- //* Parameters is to allow the user to pass information to */
- //* *ProcessItem that *ProcessItem may need. Either way, */
- //* how Parameters is used is literally up to the user. */
- //* */
- //*********************************************************************/
- void _System PruneList(DLIST ListToProcess,
- BOOLEAN ( * _System KillItem) (ADDRESS Object, TAG ObjectTag, CARDINAL32 ObjectSize, ADDRESS ObjectHandle, ADDRESS Parameters, BOOLEAN * FreeMemory, CARDINAL32 * Error),
- ADDRESS Parameters,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: AppendList */
- //* */
- //* Descriptive Name: Removes the items in SourceList and appends */
- //* them to TargetList. */
- //* */
- //* Input: DLIST TargetList : The DLIST which is to have the items */
- //* from SourceList appended to it. */
- //* DLIST SourceList : The DLIST whose items are to be */
- //* removed and appended to TargetList. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return value. */
- //* */
- //* Output: If successful, *Error will be set to DLIST_SUCCESS, */
- //* SourceList will be empty, and TargetList will contain*/
- //* all of its original items and all of the items that */
- //* were in SourceList. */
- //* If unsuccessful, *Error will be set to a non-zero value */
- //* and SourceList and TargetList will be unmodified. */
- //* */
- //* Error Handling: This function will abort immediately upon */
- //* detection of an error. All errors that can be */
- //* detected are detected before the contents of */
- //* SourceList are appended to TargetList, so if an*/
- //* error is detected and the function aborts, */
- //* SourceList and TargetList are unaltered. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- void _System AppendList(DLIST TargetList,
- DLIST SourceList,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: TransferItem */
- //* */
- //* Descriptive Name: Removes an item in SourceList and places in */
- //* TargetList. */
- //* */
- //* Input: DLIST SourceList : The DLIST containing the item which */
- //* is to be transferred. */
- //* ADDRESS SourceHandle : The handle of the item in */
- //* SourceList which is to be */
- //* transferred to another DLIST. */
- //* If this is NULL, then the */
- //* current item in SourceList will */
- //* be used. */
- //* DLIST TargetList : The DLIST which is to receive the */
- //* item being transferred. */
- //* ADDRESS TargetHandle : The item in TargetList which */
- //* is used to determine where */
- //* the item being transferred will */
- //* be placed. If this is NULL, */
- //* then the current item in */
- //* TargetList will be used. */
- //* Insertion_Modes TransferMode : This indicates where, */
- //* relative to the item in */
- //* TargetList specified by */
- //* Target_Handle, the item being */
- //* transferred can be placed. */
- //* BOOLEAN MakeCurrent : If TRUE, the item transferred to */
- //* TargetList becomes the current */
- //* item in TargetList. */
- //* CARDINAL32 * Error : The address of a variable to hold */
- //* the error return value. */
- //* */
- //* Output: If successful, *Error will be set to DLIST_SUCCESS, */
- //* SourceList will be empty, and TargetList will contain*/
- //* all of its original items and all of the items that */
- //* were in SourceList. */
- //* If unsuccessful, *Error will be set to a non-zero value */
- //* and SourceList and TargetList will be unmodified. */
- //* */
- //* Error Handling: This function will abort immediately upon */
- //* detection of an error. All errors that can be */
- //* detected are detected before the contents of */
- //* SourceList are appended to TargetList, so if an*/
- //* error is detected and the function aborts, */
- //* SourceList and TargetList are unaltered. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- void _System TransferItem(DLIST SourceList,
- ADDRESS SourceHandle,
- DLIST TargetList,
- ADDRESS TargetHandle,
- Insertion_Modes TransferMode,
- BOOLEAN MakeCurrent,
- CARDINAL32 * Error);
- //*********************************************************************/
- //* */
- //* Function Name: CheckListIntegrity */
- //* */
- //* Descriptive Name: Checks the integrity of a DLIST. All link */
- //* nodes in the list are checked, as are all */
- //* fields in the list control block. */
- //* */
- //* Input: DLIST ListToCheck - The list whose integrity is to be */
- //* checked. */
- //* */
- //* Output: The function return value will be TRUE if all of the */
- //* elements in the DLIST are correct. If this function */
- //* returns FALSE, then the DLIST being checked has been */
- //* corrupted! */
- //* */
- //* Error Handling: If this function encounters an error in a DLIST,*/
- //* it will return FALSE. */
- //* */
- //* Side Effects: None. */
- //* */
- //* Notes: None. */
- //* */
- //*********************************************************************/
- BOOLEAN _System CheckListIntegrity(DLIST ListToCheck);
- {$endif}
- Implementation
- End.