|
|
@@ -0,0 +1,5246 @@
|
|
|
+{
|
|
|
+ $Id$
|
|
|
+ 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 */
|
|
|
+//* usefull 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 */
|
|
|
+//* usefull 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.
|
|
|
+
|
|
|
+{No info about following:
|
|
|
+
|
|
|
+ Export_Configuration
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+{
|
|
|
+$Log$
|
|
|
+Revision 1.1 2003-08-11 07:26:43 yuri
|
|
|
++ Initial import
|
|
|
+
|
|
|
+}
|
yuri