home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lvmtlk12.zip / doc / lvmapi1.INF (.txt) next >
OS/2 Help File  |  2002-06-04  |  87KB  |  4,713 lines
  1.  
  2. ΓòÉΓòÉΓòÉ 1. About the LVM API Reference ΓòÉΓòÉΓòÉ
  3.  
  4. This documentation is derived from the contents of four C header files which 
  5. define the LVM programming interface. 
  6.  
  7.  lvm_intr.h 
  8.            This file is also referred to (in some of IBM's LVM source code, not 
  9.            reproduced here) as 'LVM_Interface.h'.  It defines the programming 
  10.            interface to LVM.DLL, the actual LVM engine.  LVMAPI1.INF describes 
  11.            this file. 
  12.  
  13.  lvm_cons.h 
  14.            This file defines a number of additional constants used throughout 
  15.            the LVM code.  LVMAPI2.INF describes this file. 
  16.  
  17.  lvm_gbls.h 
  18.            This file defines a number of additional type and macro definitions 
  19.            used throughout the LVM code.  LVMAPI3.INF describes this file. 
  20.  
  21.  lvm_type.h 
  22.            This file contains some additional type definitions used in the 
  23.            declarations of disk structures, and also contains definitions used 
  24.            for LVM plugins and other extensions.  Most of this file is specific 
  25.            to LVM version 2 (see note below), and is not likely to be of 
  26.            interest to application developers.  LVMAPI4.INF describes this 
  27.            file. 
  28.  
  29.  A fifth header file, lvm_list.h, is used internally by certain LVM functions; 
  30.  however, it does not seem to be useful to API programmers and so it is not 
  31.  documented here. 
  32.  
  33.  The source for this information is the OS/2 Reference Code which IBM has made 
  34.  available through the Enterprise Volume Management System project 
  35.  (http://evms.sourceforge.net). 
  36.  
  37.  Note about LVM versions 
  38.  
  39.  There is a distinction made between LVM Version 1 and LVM Version 2. All 
  40.  existing versions of LVM for OS/2 (including those found in the Convenience 
  41.  Packages) seem to be LVM Version 1. 
  42.  
  43.  However, this documentation -- and the published EVMS reference code -- 
  44.  describe LVM Version 2. 
  45.  
  46.  There are some features specific to Version 2 which are unusable on OS/2 and 
  47.  other platforms which use LVM Version 1 (at least until such a day as LVM 
  48.  Version 2 is released for these platforms). 
  49.  
  50.  Specifically, the following functions (both 16- and 32-bit versions) are 
  51.  unavailable: 
  52.  
  53.     Open_LVM_Engine2
  54.     Set_Java_Call_Back
  55.     Issue_Feature_Command
  56.     Parse_Feature_Parameters
  57.     Create_Volume2
  58.     Convert_Volumes_To_V1
  59.     Get_Child_Handles
  60.     Get_Parent_Handle
  61.     Get_Features
  62.     Allocate_Engine_Memory
  63.  
  64.  These functions include the notice LVM Version 2 only under their 
  65.  descriptions. 
  66.  
  67.  There is a function in Version 1 called Export_Configuration (and a 
  68.  corresponding EXPORT_CONFIGURATION16) which does not occur in Version 2.  No 
  69.  documentation is available for this function, as it is not referenced anywhere 
  70.  in the EVMS source code. 
  71.  
  72.  
  73. ΓòÉΓòÉΓòÉ 1.1. Changes ΓòÉΓòÉΓòÉ
  74.  
  75. All descriptions have been taken (verbatim) from the source code, and should be 
  76. considered copyright IBM Corporation.  They have not been altered (with the 
  77. exception that some typos have been corrected), but some additions have been 
  78. made: 
  79.  
  80.      Some editorial comments have been added where deemed appropriate. 
  81.  
  82.      Some additional headings and/or section labels have been added to the IBM 
  83.       comments for the sake of improving clarity. 
  84.  
  85.      Function prototypes and descriptions have been re-ordered slightly in the 
  86.       process of converting C code comments into API reference format. 
  87.  
  88.      Document formatting has been added in the process of converting ASCII 
  89.       source code into on-line documentation. 
  90.  
  91.  All of this material is licensed by IBM under the GNU General Public License. 
  92.  The LVM source code is available through CVS on the SourceForge website under 
  93.  the name EVMS. 
  94.  
  95.  Change History: 
  96.  
  97.  2002-06-02 
  98.  
  99.      Removed the separate section on 16-bit functions, and consolidated all 
  100.       the function headers into one entry format. 
  101.  
  102.      Moved structure field descriptions out of code-comments and into 
  103.       footnotes. This should make reading easier, and is more consistent with 
  104.       the standard OS/2 API reference format. 
  105.  
  106.      Set window coordinates so resizing is friendlier. 
  107.  
  108.      Reorganized the lvm_type.h documentation and added some notes. 
  109.  
  110.  2002-02-17 
  111.  
  112.      Added notes on LVM Version 1 versus LVM Version 2. 
  113.  
  114.      Reorganized the About and Notices sections. 
  115.  
  116.      Some formatting changes. 
  117.  
  118.  2001-09-15 
  119.  
  120.      Initial release. 
  121.  
  122.  
  123. ΓòÉΓòÉΓòÉ 2. Notices ΓòÉΓòÉΓòÉ
  124.  
  125. Copyright (c) International Business Machines  Corp., 2000 
  126.  
  127. Formatting and editorial content is Copyright (c) 2002 Alexander Taylor. 
  128.  
  129. This program is free software;  you can redistribute it and/or modify it under 
  130. the terms of the GNU General Public License as published by the Free Software 
  131. Foundation; either version 2 of the License, or (at your option) any later 
  132. version. 
  133.  
  134. This program is distributed in the hope that it will be useful, but WITHOUT ANY 
  135. WARRANTY;  without even the implied warranty of MERCHANTABILITY or FITNESS FOR 
  136. A PARTICULAR PURPOSE.  See the GNU General Public License for more details. 
  137.  
  138. You should have received a copy of the GNU General Public License along with 
  139. this program;  if not, write to the Free Software Foundation, Inc., 59 Temple 
  140. Place, Suite 330, Boston, MA 02111-1307 USA 
  141.  
  142.  
  143. ΓòÉΓòÉΓòÉ 3. LVM Interface (lvm_intr.h) ΓòÉΓòÉΓòÉ
  144.  
  145. Module: lvm_intr.h 
  146.  
  147. Description 
  148.  
  149. This module defines the interface to LVM.DLL, which is the engine that performs 
  150. all of the disk partitioning & volume creation work.
  151.  
  152. Header files included by lvm_intr.h: 
  153.  
  154.  lvm_gbls.h     BYTE, CARDINAL32, ADDRESS, BOOLEAN, BYTE 
  155.  
  156.  lvm_cons.h     DISK_NAME_SIZE, PARTITION_NAME_SIZE, VOLUME_NAME_SIZE, 
  157.                 FILESYSTEM_NAME_SIZE 
  158.  
  159.  lvm_type.h     DoubleWord 
  160.  
  161.  Functions: 
  162.  
  163.  void                            Open_LVM_Engine 
  164.  void                            Open_LVM_Engine2 
  165.  void                            Close_LVM_Engine 
  166.  Drive_Control_Array             Get_Drive_Control_Data 
  167.  Drive_Information_Record        Get_Drive_Status 
  168.  Partition_Information_Array     Get_Partitions 
  169.  Partition_Information_Record    Get_Partition_Information 
  170.  void                            Create_Partition 
  171.  void                            Delete_Partition 
  172.  void                            Set_Active_Flag 
  173.  void                            Set_OS_Flag 
  174.  Volume_Control_Array            Get_Volume_Control_Data 
  175.  Volume_Information_Record       Get_Volume_Information 
  176.  void                            Create_Volume 
  177.  void                            Create_Volume2 
  178.  void                            Hide_Volume 
  179.  void                            Expand_Volume 
  180.  void                            Assign_Drive_Letter 
  181.  void                            Set_Installable 
  182.  void                            Set_Name 
  183.  CARDINAL32                      Get_Valid_Options 
  184.  BOOLEAN                         Boot_Manager_Is_Installed 
  185.  void                            Add_To_Boot_Manager 
  186.  void                            Remove_From_Boot_Manager 
  187.  Boot_Manager_Menu               Get_Boot_Manager_Menu 
  188.  void                            Install_Boot_Manager 
  189.  void                            Remove_Boot_Manager 
  190.  void                            Set_Boot_Manager_Options 
  191.  void                            Get_Boot_Manager_Options 
  192.  void                            New_MBR 
  193.  CARDINAL32                      Get_Available_Drive_Letters 
  194.  BOOLEAN                         Reboot_Required 
  195.  void                            Set_Reboot_Flag 
  196.  BOOLEAN                         Get_Reboot_Flag 
  197.  void                            Set_Min_Install_Size 
  198.  void                            Start_Logging 
  199.  void                            Stop_Logging 
  200.  
  201.  
  202. ΓòÉΓòÉΓòÉ 3.1. Constants ΓòÉΓòÉΓòÉ
  203.  
  204. The following sections describe constants defined in lvm_intr.h. 
  205.  
  206.  
  207. ΓòÉΓòÉΓòÉ 3.1.1. Partition_Type constants ΓòÉΓòÉΓòÉ
  208.  
  209. The following defines are for use with the Partition_Type field in the 
  210. Partition_Information_Record. 
  211.  
  212. #define FREE_SPACE_PARTITION     0
  213. #define LVM_PARTITION            1
  214. #define COMPATIBILITY_PARTITION  2
  215.  
  216.  
  217. ΓòÉΓòÉΓòÉ 3.1.2. Partition_Status constants ΓòÉΓòÉΓòÉ
  218.  
  219. The following defines are for use with the Partition_Status field in the 
  220. Partition_Information_Record. 
  221.  
  222. #define PARTITION_IS_IN_USE      1
  223. #define PARTITION_IS_AVAILABLE   2
  224. #define PARTITION_IS_FREE_SPACE  0
  225.  
  226.  
  227. ΓòÉΓòÉΓòÉ 3.1.3. Device_Type constants ΓòÉΓòÉΓòÉ
  228.  
  229. The following define the device types used in the Device_Type field of the 
  230. Volume_Control_Record. 
  231.  
  232. #define LVM_HARD_DRIVE  0
  233. #define LVM_PRM         1
  234. #define NON_LVM_CDROM   2
  235. #define NETWORK_DRIVE   3
  236. #define NON_LVM_DEVICE  4
  237.  
  238.  
  239. ΓòÉΓòÉΓòÉ 3.1.4. Get_Valid_Options constants ΓòÉΓòÉΓòÉ
  240.  
  241. The following preprocessor directives define the operations that can be 
  242. performed on a partition, volume, or a block of free space.  These definitions 
  243. represent bits in a 32 bit value returned by the Get_Valid_Options function. 
  244.  
  245. #define CREATE_PRIMARY_PARTITION        1
  246. #define CREATE_LOGICAL_DRIVE            2
  247. #define DELETE_PARTITION                4
  248. #define SET_ACTIVE_PRIMARY              8
  249. #define SET_PARTITION_ACTIVE           0x10
  250. #define SET_PARTITION_INACTIVE         0x20
  251. #define SET_STARTABLE                  0x40
  252. #define INSTALL_BOOT_MANAGER           0x80
  253. #define REMOVE_BOOT_MANAGER            0x100
  254. #define SET_BOOT_MANAGER_DEFAULTS      0x200
  255. #define ADD_TO_BOOT_MANAGER_MENU       0x400
  256. #define REMOVE_FROM_BOOT_MANAGER_MENU  0x800
  257. #define DELETE_VOLUME                  0x1000
  258. #define HIDE_VOLUME                    0x2000
  259. #define EXPAND_VOLUME                  0x4000
  260. #define SET_VOLUME_INSTALLABLE         0x8000
  261. #define ASSIGN_DRIVE_LETTER            0x10000
  262. #define CAN_BOOT_PRIMARY               0x20000
  263. #define CAN_BOOT_LOGICAL               0x40000
  264. #define CAN_SET_NAME                   0x80000
  265. #define SET_BOOT_MANAGER_STARTABLE     0x100000
  266.  
  267.  
  268. ΓòÉΓòÉΓòÉ 3.1.5. Error codes returned by the LVM Engine. ΓòÉΓòÉΓòÉ
  269.  
  270. Error codes returned by the LVM Engine: 
  271.  
  272. #define LVM_ENGINE_NO_ERROR                            0
  273. #define LVM_ENGINE_OUT_OF_MEMORY                       1
  274. #define LVM_ENGINE_IO_ERROR                            2
  275. #define LVM_ENGINE_BAD_HANDLE                          3
  276. #define LVM_ENGINE_INTERNAL_ERROR                      4
  277. #define LVM_ENGINE_ALREADY_OPEN                        5
  278. #define LVM_ENGINE_NOT_OPEN                            6
  279. #define LVM_ENGINE_NAME_TOO_BIG                        7
  280. #define LVM_ENGINE_OPERATION_NOT_ALLOWED               8
  281. #define LVM_ENGINE_DRIVE_OPEN_FAILURE                  9
  282. #define LVM_ENGINE_BAD_PARTITION                      10
  283. #define LVM_ENGINE_CAN_NOT_MAKE_PRIMARY_PARTITION     11
  284. #define LVM_ENGINE_TOO_MANY_PRIMARY_PARTITIONS        12
  285. #define LVM_ENGINE_CAN_NOT_MAKE_LOGICAL_DRIVE         13
  286. #define LVM_ENGINE_REQUESTED_SIZE_TOO_BIG             14
  287. #define LVM_ENGINE_1024_CYLINDER_LIMIT                15
  288. #define LVM_ENGINE_PARTITION_ALIGNMENT_ERROR          16
  289. #define LVM_ENGINE_REQUESTED_SIZE_TOO_SMALL           17
  290. #define LVM_ENGINE_NOT_ENOUGH_FREE_SPACE              18
  291. #define LVM_ENGINE_BAD_ALLOCATION_ALGORITHM           19
  292. #define LVM_ENGINE_DUPLICATE_NAME                     20
  293. #define LVM_ENGINE_BAD_NAME                           21
  294. #define LVM_ENGINE_BAD_DRIVE_LETTER_PREFERENCE        22
  295. #define LVM_ENGINE_NO_DRIVES_FOUND                    23
  296. #define LVM_ENGINE_WRONG_VOLUME_TYPE                  24
  297. #define LVM_ENGINE_VOLUME_TOO_SMALL                   25
  298. #define LVM_ENGINE_BOOT_MANAGER_ALREADY_INSTALLED     26
  299. #define LVM_ENGINE_BOOT_MANAGER_NOT_FOUND             27
  300. #define LVM_ENGINE_INVALID_PARAMETER                  28
  301. #define LVM_ENGINE_BAD_FEATURE_SET                    29
  302. #define LVM_ENGINE_TOO_MANY_PARTITIONS_SPECIFIED      30
  303. #define LVM_ENGINE_LVM_PARTITIONS_NOT_BOOTABLE        31
  304. #define LVM_ENGINE_PARTITION_ALREADY_IN_USE           32
  305. #define LVM_ENGINE_SELECTED_PARTITION_NOT_BOOTABLE    33
  306. #define LVM_ENGINE_VOLUME_NOT_FOUND                   34
  307. #define LVM_ENGINE_DRIVE_NOT_FOUND                    35
  308. #define LVM_ENGINE_PARTITION_NOT_FOUND                36
  309. #define LVM_ENGINE_TOO_MANY_FEATURES_ACTIVE           37
  310. #define LVM_ENGINE_PARTITION_TOO_SMALL                38
  311. #define LVM_ENGINE_MAX_PARTITIONS_ALREADY_IN_USE      39
  312. #define LVM_ENGINE_IO_REQUEST_OUT_OF_RANGE            40
  313. #define LVM_ENGINE_SPECIFIED_PARTITION_NOT_STARTABLE  41
  314. #define LVM_ENGINE_SELECTED_VOLUME_NOT_STARTABLE      42
  315. #define LVM_ENGINE_EXTENDFS_FAILED                    43
  316. #define LVM_ENGINE_REBOOT_REQUIRED                    44
  317. #define LVM_ENGINE_CAN_NOT_OPEN_LOG_FILE              45
  318. #define LVM_ENGINE_CAN_NOT_WRITE_TO_LOG_FILE          46
  319. #define LVM_ENGINE_REDISCOVER_FAILED                  47
  320. #define LVM_ENGINE_INTERNAL_VERSION_FAILURE           48
  321. #define LVM_ENGINE_PLUGIN_OPERATION_INCOMPLETE        49
  322. #define LVM_ENGINE_BAD_FEATURE_ID                     50
  323. #define LVM_ENGINE_NO_INIT_DATA                       51
  324. #define LVM_ENGINE_NO_CONTEXT_DATA                    52
  325. #define LVM_ENGINE_WRONG_CLASS_FOR_FEATURE            53
  326. #define LVM_ENGINE_INCOMPATIBLE_FEATURES_SELECTED     54
  327. #define LVM_ENGINE_NO_CHILDREN                        55
  328. #define LVM_ENGINE_FEATURE_NOT_SUPPORTED_BY_INTERFACE 56
  329. #define LVM_ENGINE_NO_PARENT                          57
  330. #define LVM_ENGINE_VOLUME_HAS_NOT_BEEN_COMMITTED_YET  58
  331. #define LVM_ENGINE_UNABLE_TO_REFERENCE_VOLUME         59
  332. #define LVM_ENGINE_PARSING_ERROR                      60
  333. #define LVM_ENGINE_INTERNAL_FEATURE_ERROR             61
  334. #define LVM_ENGINE_VOLUME_NOT_CONVERTED               62
  335.  
  336.  
  337. ΓòÉΓòÉΓòÉ 3.2. Data structures ΓòÉΓòÉΓòÉ
  338.  
  339. The follow sections define data structures defined in lvm_intr.h. 
  340.  
  341.  
  342. ΓòÉΓòÉΓòÉ 3.2.1. Drive_Control_Record ΓòÉΓòÉΓòÉ
  343.  
  344. The following are invariant for a disk drive. 
  345.  
  346. typedef struct _Drive_Control_Record {
  347.     CARDINAL32   Drive_Number;
  348.     CARDINAL32   Drive_Size;
  349.     DoubleWord   Drive_Serial_Number;
  350.     ADDRESS      Drive_Handle;
  351.     CARDINAL32   Cylinder_Count;
  352.     CARDINAL32   Heads_Per_Cylinder;
  353.     CARDINAL32   Sectors_Per_Track;
  354.     BOOLEAN      Drive_Is_PRM;
  355.     BYTE         Reserved[ 3 ];
  356. } Drive_Control_Record;
  357.  
  358.  
  359. ΓòÉΓòÉΓòÉ 3.2.2. Drive_Control_Array ΓòÉΓòÉΓòÉ
  360.  
  361. The following structure is returned by the Get_Drive_Control_Data function. 
  362.  
  363. typedef struct _Drive_Control_Array {
  364.     Drive_Control_Record *   Drive_Control_Data;
  365.     CARDINAL32               Count;
  366. } Drive_Control_Array;
  367.  
  368.  
  369. ΓòÉΓòÉΓòÉ 3.2.3. Drive_Information_Record ΓòÉΓòÉΓòÉ
  370.  
  371. The following structure defines the information that can be changed for a 
  372. specific disk drive. 
  373.  
  374. typedef struct _Drive_Information_Record {
  375.     CARDINAL32   Total_Available_Sectors;
  376.     CARDINAL32   Largest_Free_Block_Of_Sectors;
  377.     BOOLEAN      Corrupt_Partition_Table;
  378.     BOOLEAN      Unusable;
  379.     BOOLEAN      IO_Error;
  380.     BOOLEAN      Is_Big_Floppy;
  381.     char         Drive_Name[ DISK_NAME_SIZE ];
  382. } Drive_Information_Record;
  383.  
  384.  
  385. ΓòÉΓòÉΓòÉ 3.2.4. Partition_Information_Record ΓòÉΓòÉΓòÉ
  386.  
  387.  
  388. typedef struct _Partition_Information_Record {
  389.     ADDRESS      Partition_Handle;
  390.     ADDRESS      Volume_Handle;
  391.     ADDRESS      Drive_Handle;
  392.     DoubleWord   Partition_Serial_Number;
  393.     CARDINAL32   Partition_Start;
  394.     CARDINAL32   True_Partition_Size;
  395.     CARDINAL32   Usable_Partition_Size;
  396.     CARDINAL32   Boot_Limit;
  397.     BOOLEAN      Spanned_Volume;
  398.     BOOLEAN      Primary_Partition;
  399.     BYTE         Active_Flag;
  400.     BYTE         OS_Flag;
  401.     BYTE         Partition_Type;
  402.     BYTE         Partition_Status;
  403.     BOOLEAN      On_Boot_Manager_Menu;
  404.     BYTE         Reserved;
  405.     char         Volume_Drive_Letter;
  406.     char         Drive_Name[ DISK_NAME_SIZE ];
  407.     char         File_System_Name[ FILESYSTEM_NAME_SIZE ];
  408.     char         Partition_Name[ PARTITION_NAME_SIZE ];
  409.     char         Volume_Name[ VOLUME_NAME_SIZE ];
  410. } Partition_Information_Record;
  411.  
  412.  
  413. ΓòÉΓòÉΓòÉ 3.2.5. Partition_Information_Array ΓòÉΓòÉΓòÉ
  414.  
  415. The following structure is returned by various functions in the LVM Engine. 
  416.  
  417. typedef struct _Partition_Information_Array {
  418.     Partition_Information_Record * Partition_Array;
  419.     CARDINAL32                     Count;
  420. } Partition_Information_Array;
  421.  
  422.  
  423. ΓòÉΓòÉΓòÉ 3.2.6. Volume_Control_Record ΓòÉΓòÉΓòÉ
  424.  
  425. The following items are invariant for a volume. 
  426.  
  427. typedef struct _Volume_Control_Record {
  428.     DoubleWord Volume_Serial_Number;
  429.     ADDRESS    Volume_Handle;
  430.     BOOLEAN    Compatibility_Volume;
  431.     BYTE       Device_Type;
  432.     BYTE       Reserved[ 2 ];
  433. } Volume_Control_Record;
  434.  
  435.  
  436. ΓòÉΓòÉΓòÉ 3.2.7. Volume_Control_Array ΓòÉΓòÉΓòÉ
  437.  
  438. The following structure is returned by the Get_Volume_Control_Data function. 
  439.  
  440. typedef struct _Volume_Control_Array {
  441.     Volume_Control_Record *  Volume_Control_Data;
  442.     CARDINAL32               Count;
  443. } Volume_Control_Array;
  444.  
  445.  
  446. ΓòÉΓòÉΓòÉ 3.2.8. Volume_Information_Record ΓòÉΓòÉΓòÉ
  447.  
  448. The following information about a volume can (and often does) vary. 
  449.  
  450. typedef struct _Volume_Information_Record {
  451.     CARDINAL32 Volume_Size;
  452.     CARDINAL32 Partition_Count;
  453.     CARDINAL32 Drive_Letter_Conflict;
  454.     BOOLEAN    Compatibility_Volume;
  455.     BOOLEAN    Bootable;
  456.     char       Drive_Letter_Preference;
  457.     char       Current_Drive_Letter;
  458.     char       Initial_Drive_Letter;
  459.     BOOLEAN    New_Volume;
  460.     BYTE       Status;
  461.     BYTE       Reserved_1;
  462.     char       Volume_Name[ VOLUME_NAME_SIZE ];
  463.     char       File_System_Name[ FILESYSTEM_NAME_SIZE ];
  464. } Volume_Information_Record;
  465.  
  466.  
  467. ΓòÉΓòÉΓòÉ 3.2.9. Feature_Information_Array ΓòÉΓòÉΓòÉ
  468.  
  469. The following structure is used to return the feature information for the 
  470. installed features, or the features on a volume. 
  471.  
  472. typedef struct _Feature_Information_Array {
  473.     CARDINAL32        Count;
  474.     Feature_ID_Data * Feature_Data;
  475. } Feature_Information_Array;
  476.  
  477.  
  478. ΓòÉΓòÉΓòÉ 3.2.10. Boot_Manager_Menu_Item ΓòÉΓòÉΓòÉ
  479.  
  480. The following structure defines an item on the Boot Manager Menu. 
  481.  
  482. typedef struct _Boot_Manager_Menu_Item {
  483.     ADDRESS     Handle;
  484.     BOOLEAN     Volume;
  485. } Boot_Manager_Menu_Item;
  486.  
  487.  
  488. ΓòÉΓòÉΓòÉ 3.2.11. Boot_Manager_Menu ΓòÉΓòÉΓòÉ
  489.  
  490. The following structure is used to get a list of the items on the partition 
  491. manager menu. 
  492.  
  493. typedef struct _Boot_Manager_Menu {
  494.     Boot_Manager_Menu_Item *  Menu_Items;
  495.     CARDINAL32                Count;
  496. } Boot_Manager_Menu;
  497.  
  498.  
  499. ΓòÉΓòÉΓòÉ 3.2.12. LVM_Feature_Specification_Record ΓòÉΓòÉΓòÉ
  500.  
  501. The following structure is used to specify an LVM Feature when creating a 
  502. volume. Since LVM Features may be part of more than one LVM Class, the specific 
  503. class to be used with the feature must also be specified. 
  504.  
  505. typedef struct _LVM_Feature_Specification_Record {
  506.     CARDINAL32       Feature_ID;
  507.     LVM_Classes      Actual_Class;
  508.     ADDRESS          Init_Data;
  509. } LVM_Feature_Specification_Record;
  510.  
  511.  
  512. ΓòÉΓòÉΓòÉ 3.2.13. LVM_Handle_Array_Record ΓòÉΓòÉΓòÉ
  513.  
  514. The following structure is used with the Get_Child_Handles function. 
  515.  
  516. typedef struct {
  517.     CARDINAL32   Count;
  518.     ADDRESS *    Handles;
  519. } LVM_Handle_Array_Record;
  520.  
  521.  
  522. ΓòÉΓòÉΓòÉ 3.2.14. Allocation_Algorithm ΓòÉΓòÉΓòÉ
  523.  
  524. The following enumeration defines the allocation strategies used by the 
  525. Create_Partition function. 
  526.  
  527. typedef enum _Allocation_Algorithm {
  528.     Automatic,
  529.     Best_Fit,
  530.     First_Fit,
  531.     Last_Fit,
  532.     From_Largest,
  533.     From_Smallest,
  534.     All
  535. } Allocation_Algorithm;
  536.  
  537.  
  538. ΓòÉΓòÉΓòÉ 3.3. Functions ΓòÉΓòÉΓòÉ
  539.  
  540. Function prototypes exported by LVM.DLL. 
  541.  
  542. The function prototype shown at the top of each page is the standard, 32-bit 
  543. version of the function.  All of these prototypes are included under the 
  544. preprocessor directive 
  545.  
  546. #ifndef USE_16_BIT_FUNCTIONS
  547.  
  548. If 'USE_16_BIT_FUNCTIONS' is defined, then 16-bit function prototypes will be 
  549. enabled instead. 
  550.  
  551. 16 Bit Functions 
  552.  
  553. Many LVM functions have equivalent 16-bit versions.  The function prototypes 
  554. for these are listed at the bottom of the page. 
  555.  
  556. There are two 16-bit function prototypes given.  The first is for use with IBM 
  557. VisualAge C/C++, and is included under the preprocessor directive 
  558.  
  559. #ifdef BUILD_LVM_ENGINE
  560.  
  561. The second 16-bit function prototype is for use with other 16-bit compilers. 
  562.  
  563.  
  564. ΓòÉΓòÉΓòÉ 3.3.1. Functions relating to the LVM Engine itself ΓòÉΓòÉΓòÉ
  565.  
  566. Functions relating to the LVM Engine itself. 
  567.  
  568.  
  569. ΓòÉΓòÉΓòÉ 3.3.1.1. Open_LVM_Engine ΓòÉΓòÉΓòÉ
  570.  
  571. void _System Open_LVM_Engine(
  572.  
  573.         BOOLEAN      Ignore_CHS,
  574.         CARDINAL32 * Error_Code
  575.  
  576. );
  577.  
  578. Description: 
  579.  
  580. Opens the LVM Engine and readies it for use. 
  581.  
  582. Input: 
  583.  
  584.  BOOLEAN Ignore_CHS 
  585.            If TRUE, then the LVM engine will not check the CHS values in the 
  586.            MBR/EBR partition tables for validity.  This is useful if there are 
  587.            drive geometry problems, such as the drive was partitioned and 
  588.            formatted with one geometry and then moved to a different machine 
  589.            which uses a different geometry for the drive.  This would cause the 
  590.            starting and ending CHS values in the partition tables to be 
  591.            inconsistent with the size and partition offset entries in the 
  592.            partition tables.  Setting Ignore_CHS to TRUE will disable the LVM 
  593.            Engine's CHS consistency checks, thereby allowing the drive to be 
  594.            partitioned. 
  595.  
  596.  CARDINAL32 * Error_Code 
  597.            The address of a CARDINAL32 in which to store an error code should 
  598.            an error occur. 
  599.  
  600.  Output: 
  601.  
  602.  *Error_Code will be 0 if this function completes successfully.  If an error 
  603.  occurs, *Error_Code will contain a non-zero error code. 
  604.  
  605.  Error Handling: 
  606.  
  607.  If this function aborts with an error, all memory allocated during the course 
  608.  of this function will be released.  Disk read errors will be reported to the 
  609.  user via pop-up error messages.  Disk read errors will only cause this 
  610.  function to abort if none of the disk drives in the system could be 
  611.  successfully read. 
  612.  
  613.  Side Effects: 
  614.  
  615.  The LVM Engine will be initialized.  The partition tables for all OS2DASD 
  616.  controlled disk drives will be read into memory.  Memory will be allocated for 
  617.  the data structures used by the LVM Engine. 
  618.  
  619.  Notes: 
  620.  
  621.  This is provided for programs that used LVM Version 1.  This function assumes 
  622.  an LVM_Interface_Type of VIO_Interface. 
  623.  
  624.  16 Bit Versions: 
  625.  
  626.   void _Far16 _Pascal _loadds OPEN_LVM_ENGINE16(
  627.           BOOLEAN             Ignore_CHS,
  628.           CARDINAL32 * _Seg16 Error_Code
  629.   );
  630.  
  631.   void far pascal _loadds OPEN_LVM_ENGINE16(
  632.           BOOLEAN          Ignore_CHS,
  633.           CARDINAL32 far * Error_Code
  634.   );
  635.  
  636.  
  637. ΓòÉΓòÉΓòÉ 3.3.1.2. Open_LVM_Engine2 ΓòÉΓòÉΓòÉ
  638.  
  639. LVM Version 2 only 
  640.  
  641. void _System Open_LVM_Engine2(
  642.  
  643.         BOOLEAN             Ignore_CHS,
  644.         LVM_Interface_Types Interface_Type,
  645.         CARDINAL32 *        Error_Code
  646.  
  647. );
  648.  
  649. Description: 
  650.  
  651. Opens the LVM Engine and readies it for use. 
  652.  
  653. Input: 
  654.  
  655.  BOOLEAN Ignore_CHS 
  656.            If TRUE, then the LVM engine will not check the CHS values in the 
  657.            MBR/EBR partition tables for validity.  This is useful if there are 
  658.            drive geometry problems, such as the drive was partitioned and 
  659.            formatted with one geometry and then moved to a different machine 
  660.            which uses a different geometry for the drive.  This would cause the 
  661.            starting and ending CHS values in the partition tables to be 
  662.            inconsistent with the size and partition offset entries in the 
  663.            partition tables.  Setting Ignore_CHS to TRUE will disable the LVM 
  664.            Engine's CHS consistency checks, thereby allowing the drive to be 
  665.            partitioned. 
  666.  
  667.  LVM_Interface_Types Interface_Type 
  668.            Indicate the type of user interface being used:  PM_Interface, 
  669.            VIO_Interface, or Java_Interface.  This lets the LVM Engine know 
  670.            which interface support routines to call in any plugin modules which 
  671.            may be loaded. 
  672.  
  673.  CARDINAL32 * Error_Code 
  674.            The address of a CARDINAL32 in which to store an error code should 
  675.            an error occur. 
  676.  
  677.  Output: 
  678.  
  679.  *Error_Code will be 0 if this function completes successfully.  If an error 
  680.  occurs, *Error_Code will contain a non-zero error code. 
  681.  
  682.  Error Handling: 
  683.  
  684.  If this function aborts with an error, all memory allocated during the course 
  685.  of this function will be released.  Disk read errors will be reported to the 
  686.  user via pop-up error messages.  Disk read errors will only cause this 
  687.  function to abort if none of the disk drives in the system could be 
  688.  successfully read. 
  689.  
  690.  Side Effects: 
  691.  
  692.  The LVM Engine will be initialized.  The partition tables for all OS2DASD 
  693.  controlled disk drives will be read into memory.  Memory will be allocated for 
  694.  the data structures used by the LVM Engine. 
  695.  
  696.  Notes: 
  697.  
  698.  None. 
  699.  
  700.  16 Bit Versions: 
  701.  
  702.   void _Far16 _Pascal _loadds OPEN_LVM_ENGINE216(
  703.           BOOLEAN             Ignore_CHS,
  704.           LVM_Interface_Types Interface_Type,
  705.           CARDINAL32 *        _Seg16 Error_Code
  706.   );
  707.  
  708.   void far pascal _loadds OPEN_LVM_ENGINE216(
  709.           BOOLEAN          Ignore_CHS,
  710.           CARDINAL32 far * Error_Code
  711.   );
  712.  
  713.  
  714. ΓòÉΓòÉΓòÉ 3.3.1.3. Commit_Changes ΓòÉΓòÉΓòÉ
  715.  
  716. BOOLEAN _System Commit_Changes( CARDINAL32 * Error_Code );
  717.  
  718. Description 
  719.  
  720. Saves any changes made to the partitioning information of the OS2DASD 
  721. controlled disk drives in the system. 
  722.  
  723. Input 
  724.  
  725.  CARDINAL32 * Error_Code 
  726.            The address of a CARDINAL32 in in which to store an error code 
  727.            should an error occur. 
  728.  
  729.  Output 
  730.  
  731.  The function return value will be TRUE if all of the partitioning/volume 
  732.  changes made were successfully written to disk.  Also, *Error_Code will be 0 
  733.  if no errors occur. 
  734.  
  735.  If an error occurs, then the furnction return value will be FALSE and 
  736.  *Error_Code will contain a non-zero error code. 
  737.  
  738.  Error Handling 
  739.  
  740.  If an error occurs, the function return value will be false and *Error_Code 
  741.  will be > 0. 
  742.  
  743.  Disk read and write errors will be indicated by setting the IO_Error field of 
  744.  the Drive_Information_Record to TRUE.  Thus, if the function return value is 
  745.  FALSE, and *Error_Code indicates an I/O error, the caller of this function 
  746.  should call the Get_Drive_Status function on each drive to determine which 
  747.  drives had I/O errors. 
  748.  
  749.  If a read or write error occurs, then the engine may not have been able to 
  750.  create a partition or volume.  Thus, the caller may want to refresh all 
  751.  partition and volume data to see what the engine was and was not able to 
  752.  create. 
  753.  
  754.  Side Effects 
  755.  
  756.  The partitioning information of the disk drives in the system may be altered. 
  757.  
  758.  Notes 
  759.  
  760.  None. 
  761.  
  762.  16 Bit Versions: 
  763.  
  764.   BOOLEAN _Far16 _Pascal _loadds COMMIT_CHANGES16( CARDINAL32 * _Seg16 Error_Code );
  765.  
  766.   BOOLEAN far pascal _loadds COMMIT_CHANGES16( CARDINAL32 far * Error_Code );
  767.  
  768.  
  769. ΓòÉΓòÉΓòÉ 3.3.1.4. Set_Java_Call_Back ΓòÉΓòÉΓòÉ
  770.  
  771. LVM Version 2 only 
  772.  
  773. void _System Set_Java_Call_Back(
  774.  
  775.         void (* _System Execute_Java_Class) ( char * Class_Name,
  776.                                               ADDRESS      InputBuffer,
  777.                                               CARDINAL32   InputBufferSize,
  778.                                               ADDRESS    * OutputBuffer,
  779.                                               CARDINAL32 * OutputBufferSize,
  780.                                               CARDINAL32 * Error_Code),
  781.         CARDINAL32 * Error_Code
  782.  
  783. );
  784.  
  785. Description: 
  786.  
  787. This function allows the calling Java program to set the call back address. The 
  788. call back address is used when the LVM Engine or one of its plug-ins, needs to 
  789. run a Java class to gather information from the user. 
  790.  
  791. Input: 
  792.  
  793.  void (* Execute_Java_Class) ... 
  794.            The address of a function that the LVM engine may call when it needs 
  795.            a Java class to be executed.  This is only required if the user 
  796.            interface being used is written in Java 
  797.  
  798.  CARDINAL32 * Error_Code 
  799.            The address of a CARDINAL32 in which to store an error code should 
  800.            an error occur. 
  801.  
  802.  Output: 
  803.  
  804.  If the function completes successfully, then *Error_Code will be set to 
  805.  LVM_ENGINE_NO_ERROR.  Otherwise, *Error_Code will be set to a non-zero error 
  806.  code. 
  807.  
  808.  Error Handling: 
  809.  
  810.  If an error occurs, the function will abort and *Error_Code will be set to a 
  811.  non-zero error code. 
  812.  
  813.  Side Effects: 
  814.  
  815.  The Java call back address is set to point to the specified function.  Once 
  816.  the Java call back address is set, LVM plug-ins which require the Java call 
  817.  back will be enabled and can be used during the creation of LVM Volumes. 
  818.  
  819.  Notes: 
  820.  
  821.  If a Java interface is in use (as specified on the Open_LVM_Engine call), then 
  822.  this function must be called in order to enable those LVM plug-ins which 
  823.  require initialization information during the creation of an LVM Volume.  If 
  824.  these plug-ins are not enabled, then they will not be reported by the 
  825.  Get_Available_Features API, nor can they be used or accessed by any other LVM 
  826.  Engine APIs.  Thus, this function should be called immediately after the 
  827.  Open_LVM_Engine API is called. 
  828.  
  829.  
  830. ΓòÉΓòÉΓòÉ 3.3.1.5. Close_LVM_Engine ΓòÉΓòÉΓòÉ
  831.  
  832. void _System Close_LVM_Engine ( void );
  833.  
  834. Description 
  835.  
  836. Closes the LVM Engine and frees any memory held by the LVM Engine. 
  837.  
  838. Input 
  839.  
  840. None. 
  841.  
  842. Output 
  843.  
  844. None. 
  845.  
  846. Error Handling 
  847.  
  848. N/A 
  849.  
  850. Side Effects 
  851.  
  852. Any memory held by the LVM Engine is released. 
  853.  
  854. Notes 
  855.  
  856. None. 
  857.  
  858. 16 Bit Versions: 
  859.  
  860. void _Far16 _Pascal _loadds CLOSE_LVM_ENGINE16( void );
  861.  
  862. void far pascal _loadds CLOSE_LVM_ENGINE16( void );
  863.  
  864.  
  865. ΓòÉΓòÉΓòÉ 3.3.1.6. Get_Available_Features ΓòÉΓòÉΓòÉ
  866.  
  867. Feature_Information_Array _System Get_Available_Features( CARDINAL32 * Error_Code );
  868.  
  869. Description 
  870.  
  871. Returns the feature ID information for each of the features that the LVM Engine 
  872. knows about. 
  873.  
  874. Input 
  875.  
  876.  CARDINAL32 * Error_Code 
  877.            The address of a CARDINAL32 in which to store an error code should 
  878.            an error occur. 
  879.  
  880.  Output 
  881.  
  882.  If successful, a Feature_Information_Array structure is returned with a 
  883.  non-zero Count.  Also, *Error_Code will be set to LVM_ENGINE_NO_ERROR.  If an 
  884.  error occurs, then the Count field in the structure will be 0 and 
  885.  (*Error_Code) will contain a non-zero error code. 
  886.  
  887.  Error Handling 
  888.  
  889.  The only expected error is if this function is called while the LVM Engine is 
  890.  not open.  This should be the only error condition. 
  891.  
  892.  Side Effects 
  893.  
  894.  Memory is allocated using the LVM Engine's memory manager for the array of 
  895.  Feature_ID_Data items being returned. 
  896.  
  897.  Notes 
  898.  
  899.  None. 
  900.  
  901.  
  902. ΓòÉΓòÉΓòÉ 3.3.1.7. Issue_Feature_Command ΓòÉΓòÉΓòÉ
  903.  
  904. LVM Version 2 only 
  905.  
  906. void _System Issue_Feature_Command(
  907.  
  908.         CARDINAL32   Feature_ID,
  909.         ADDRESS      Handle,
  910.         BOOLEAN      Ring0,
  911.         ADDRESS      InputBuffer,
  912.         CARDINAL32   InputSize,
  913.         ADDRESS *    OutputBuffer,
  914.         CARDINAL32 * OutputSize,
  915.         CARDINAL32 * Error_Code
  916. );
  917.  
  918. Description 
  919.  
  920. Issues a feature specific command to either the Ring 0 or Ring 3 portion of the 
  921. feature. 
  922.  
  923. Input 
  924.  
  925.  CARDINAL32 Feature_ID 
  926.            The numeric ID assigned to the feature which is to receive the 
  927.            command being issued. 
  928.  
  929.  ADDRESS Handle 
  930.            The handle of the volume, partition, or aggregate to which the 
  931.            feature command is to be directed. 
  932.  
  933.  BOOLEAN Ring0 
  934.            If TRUE, then the command will be sent to the Ring 0 portion of the 
  935.            feature. 
  936.            If FALSE, then the command will be sent to the Ring 3 portion of the 
  937.            feature. 
  938.  
  939.  ADDRESS InputBuffer 
  940.            A buffer containing the command and any necessary information for 
  941.            the feature to process the command. 
  942.  
  943.  CARDINAL32 InputSize 
  944.            The number of bytes in the InputBuffer. 
  945.  
  946.  ADDRESS * OutputBuffer 
  947.            The address of a variable used to hold the location of the output 
  948.            buffer created by the feature in response to the command in 
  949.            InputBuffer. 
  950.  
  951.  CARDINAL32 * OutputSize 
  952.            The address of a variable used to hold the number of bytes in 
  953.            *OutputBuffer. 
  954.  
  955.  CARDINAL32 * Error_Code 
  956.            The address of a CARDINAL32 in which to store an error code should 
  957.            an error occur. 
  958.  
  959.  Output 
  960.  
  961.  If successful, then *Error_Code will be set to LVM_ENGINE_NO_ERROR.  If 
  962.  unsuccessful, then *Error_Code will be set to a non-zero error code. 
  963.  *OutputBuffer and *OutputSize are set by the feature.  If the feature 
  964.  specified does not exist, then *OutputBuffer will be NULL and *Outputsize will 
  965.  be 0.  If the feature does exist, then the value of *OutputBuffer and 
  966.  *OutputSize depend upon the feature. 
  967.  
  968.  Error Handling 
  969.  
  970.  If the specified feature does not exist, then *Error_Code will contain a 
  971.  non-zero error code, *OutputBuffer will be NULL, and *OutputSize will be set 
  972.  to 0.  All other error conditions are feature dependent. 
  973.  
  974.  Side Effects 
  975.  
  976.  Side effects are feature dependent. 
  977.  
  978.  Notes 
  979.  
  980.  None. 
  981.  
  982.  
  983. ΓòÉΓòÉΓòÉ 3.3.1.8. Parse_Feature_Parameters ΓòÉΓòÉΓòÉ
  984.  
  985. LVM Version 2 only 
  986.  
  987. void _System Parse_Feature_Parameters(
  988.  
  989.         DLIST                              Tokens,
  990.         LVM_Feature_Specification_Record * Feature_Data,
  991.         char **                            Error_Message,
  992.         CARDINAL32 *                       Error_Code
  993.  
  994. );
  995.  
  996. Description 
  997.  
  998. This function allows access to the parsing function of an LVM Plug-in Feature. 
  999. The specified feature will be passed a list of tokens to parse, and, if it 
  1000. parses the tokens successfully, will produce a buffer containing initialization 
  1001. data that can be used with the Create_Volume API.  If it encounters an error, 
  1002. the current item in the Tokens list will be the offending item, and a pointer 
  1003. to an error message will be returned. 
  1004.  
  1005. Input 
  1006.  
  1007.  DLIST Tokens 
  1008.            A DLIST of tokens to parse.  Parsing will begin with the current 
  1009.            entry in the list and proceed until there is an error or until the 
  1010.            specified feature has found a complete command.  Each feature 
  1011.            defines what commands it will accept. 
  1012.  
  1013.  LVM_Feature_Specification_Record * Feature_Data 
  1014.            A pointer to a record which contains the ID of the feature which is 
  1015.            to parse the DLIST of Tokens.  The other fields in this record will 
  1016.            be filled in by the feature if it successfully parses the tokens. 
  1017.  
  1018.  char ** Error_Message 
  1019.            The address of a pointer to char. This will be set to NULL if the 
  1020.            feature successfully parses the list of tokens, or it will be set to 
  1021.            point to an error message if an error occurs. 
  1022.  
  1023.  CARDINAL32 * Error_Code 
  1024.            The address of a CARDINAL32 variable into which an error code may be 
  1025.            placed.  The error code will be LVM_ENGINE_NO_ERROR if this function 
  1026.            completes successfully, or a non-zero error code if an error occurs. 
  1027.  
  1028.  Output 
  1029.  
  1030.  If there are no errors, the Actual_Class and Init_Data fields of *Feature_Data 
  1031.  will be set, *Error_Message will be set to NULL, and Error_Code will be set to 
  1032.  LVM_ENGINE_NO_ERROR.  The current item in the Tokens list will be the first 
  1033.  token that was not parsed by the feature (i.e. the first token after the 
  1034.  command accepted by the plug-in). 
  1035.  
  1036.  If an error occurs, the values of Actual_Class and Init_Data in *Feature_Data 
  1037.  are undefined.  *Error_Code will be set to LVM_ENGINE_PARSING_ERROR if the 
  1038.  error is parsing related, or some other non-zero value if the error is not 
  1039.  parsing related.  If the error is parsing related, then *Error_Message will 
  1040.  point to an error message which can be displayed for the user.  The current 
  1041.  item in the Tokens list will be the token which failed. 
  1042.  
  1043.  Error Handling 
  1044.  
  1045.  If an parsing related error occurs, i.e. the tokens in the Tokens list do not 
  1046.  form a valid command accepted by the specified feature, then the current item 
  1047.  in the Tokens list will be the offending token, *Error_Message will be set to 
  1048.  point to an error message, and *Error_Code will be set to 
  1049.  LVM_ENGINE_PARSING_ERROR. 
  1050.  
  1051.  If any other error occurs, the current item in the Tokens list will be the 
  1052.  token that was being processed when the error occurs, and *Error_Code will be 
  1053.  set to a non-zero value. 
  1054.  
  1055.  Side Effects 
  1056.  
  1057.  The current item in the Tokens list may change. 
  1058.  
  1059.  Notes 
  1060.  
  1061.  Each feature defines which commands it will accept, and therefore which 
  1062.  commands it will successfully parse. 
  1063.  
  1064.  
  1065. ΓòÉΓòÉΓòÉ 3.3.1.9. Refresh_LVM_Engine ΓòÉΓòÉΓòÉ
  1066.  
  1067. void _System  Refresh_LVM_Engine( CARDINAL32 * Error_Code );
  1068.  
  1069. Description 
  1070.  
  1071. This function causes the LVM Engine to look for changes in the current system 
  1072. configuration and update its internal tables accordingly. 
  1073.  
  1074. Input 
  1075.  
  1076.  CARDINAL32 * Error_Code 
  1077.            The address of a CARDINAL32 in which to store an error code should 
  1078.            an error occur. 
  1079.  
  1080.  Output 
  1081.  
  1082.  None. 
  1083.  
  1084.  Error Handling 
  1085.  
  1086.  If an error occurs, *Error_Code will be set to a non-zero value. 
  1087.  
  1088.  Side Effects 
  1089.  
  1090.  Volumes which represent non-LVM devices may have their handles changed! 
  1091.  
  1092.  Notes 
  1093.  
  1094.  After calling this function, Get_Volume_Control_Data should be called to get 
  1095.  the updated list of volumes.  This is necessary as the handles of some volumes 
  1096.  may have changed. 
  1097.  
  1098.  16 Bit Versions: 
  1099.  
  1100.   void _Far16 _Pascal _loadds REFRESH_LVM_ENGINE16( CARDINAL32 * _Seg16 Error_Code );
  1101.  
  1102.   void far pascal _loadds REFRESH_LVM_ENGINE16( CARDINAL32 far * Error_Code );
  1103.  
  1104.  
  1105. ΓòÉΓòÉΓòÉ 3.3.2. Functions relating to Drives ΓòÉΓòÉΓòÉ
  1106.  
  1107. Functions relating to drives. 
  1108.  
  1109.  
  1110. ΓòÉΓòÉΓòÉ 3.3.2.1. Get_Drive_Control_Data ΓòÉΓòÉΓòÉ
  1111.  
  1112. Drive_Control_Array _System Get_Drive_Control_Data( CARDINAL32 * Error_Code );
  1113.  
  1114. Description 
  1115.  
  1116. This function returns an array of Drive_Control_Records.  These records provide 
  1117. important information about the drives in the system and provide the handles 
  1118. required to access them. 
  1119.  
  1120. Input 
  1121.  
  1122.  CARDINAL32 * Error_Code 
  1123.            The address of a CARDINAL32 in which to store an error code should 
  1124.            an error occur. 
  1125.  
  1126.  Output 
  1127.  
  1128.  A Drive_Control_Array structure is returned.  If no errors occur, 
  1129.  Drive_Control_Data will be non-NULL, Count will be greater than zero, and 
  1130.  *Error_Code will  be 0. 
  1131.  
  1132.  Error Handling 
  1133.  
  1134.  If an error occurs, the Drive_Control_Array returned by this function will 
  1135.  have NULL for Drive_Control_Data, and 0 for Count. *Error_Code will be greater 
  1136.  than 0. 
  1137.  
  1138.  Side Effects 
  1139.  
  1140.  None. 
  1141.  
  1142.  Notes 
  1143.  
  1144.  The caller becomes responsible for the memory allocated for the array of 
  1145.  Drive_Control_Records pointed to by Drive_Control_Data pointer in the 
  1146.  Drive_Control_Array structure returned by this function.  The caller should 
  1147.  free this memory when they are done using it. 
  1148.  
  1149.  16 Bit Versions: 
  1150.  
  1151.   void _Far16 _Pascal _loadds GET_DRIVE_CONTROL_DATA16(
  1152.           Drive_Control_Record * _Seg16 * _Seg16 Drive_Control_Data,
  1153.           CARDINAL32 *                    _Seg16 Count,
  1154.           CARDINAL32 *                    _Seg16 Error_Code
  1155.   );
  1156.  
  1157.   void far pascal _loadds GET_DRIVE_CONTROL_DATA16(
  1158.           Drive_Control_Record far ** Drive_Control_Data,
  1159.           CARDINAL32 far *            Count,
  1160.           CARDINAL32 far *            Error_Code
  1161.   );
  1162.  
  1163.  
  1164. ΓòÉΓòÉΓòÉ 3.3.2.2. Get_Drive_Status ΓòÉΓòÉΓòÉ
  1165.  
  1166. Drive_Information_Record _System Get_Drive_Status(
  1167.  
  1168.         ADDRESS      Drive_Handle,
  1169.         CARDINAL32 * Error_Code
  1170.  
  1171. );
  1172.  
  1173. Description 
  1174.  
  1175. Returns the Drive_Information_Record for the drive specified by Drive_Handle. 
  1176.  
  1177. Input 
  1178.  
  1179.  ADDRESS Drive_Handle 
  1180.            The handle of the drive to use.  Drive handles are obtained through 
  1181.            the Get_Drive_Control_Data function. 
  1182.  
  1183.  CARDINAL32 * Error_Code 
  1184.            The address of a CARDINAL32 in which to store an error code should 
  1185.            an error occur. 
  1186.  
  1187.  Output 
  1188.  
  1189.  This function returns the Drive_Information_Record for the drive associated 
  1190.  with the specified Drive_Handle.  If no errors occur, *Error_Code will be set 
  1191.  to 0.  If an error does occur, then *Error_Code will be non-zero. 
  1192.  
  1193.  Error Handling 
  1194.  
  1195.  If an error occurs, then *Error_Code will be non-zero. 
  1196.  
  1197.  Side Effects 
  1198.  
  1199.  None. 
  1200.  
  1201.  Notes 
  1202.  
  1203.  None. 
  1204.  
  1205.  16 Bit Versions: 
  1206.  
  1207.   void _Far16 _Pascal _loadds GET_DRIVE_STATUS16(
  1208.           CARDINAL32                          Drive_Handle,
  1209.           Drive_Information_Record *   _Seg16 Drive_Status,
  1210.           CARDINAL32 *                 _Seg16 Error_Code
  1211.   );
  1212.  
  1213.   void far pascal _loadds GET_DRIVE_STATUS16(
  1214.           CARDINAL32                      Drive_Handle,
  1215.           Drive_Information_Record far *  Drive_Status,
  1216.           CARDINAL32 *                    Error_Code
  1217.   );
  1218.  
  1219.  
  1220. ΓòÉΓòÉΓòÉ 3.3.3. Functions relating to Partitions ΓòÉΓòÉΓòÉ
  1221.  
  1222. Functions relating to partitions. 
  1223.  
  1224.  
  1225. ΓòÉΓòÉΓòÉ 3.3.3.1. Get_Partitions ΓòÉΓòÉΓòÉ
  1226.  
  1227. Partition_Information_Array _System Get_Partitions(
  1228.  
  1229.         ADDRESS      Handle,
  1230.         CARDINAL32 * Error_Code
  1231.  
  1232. );
  1233.  
  1234. Description 
  1235.  
  1236. Returns an array of partitions associated with the object specified by Handle. 
  1237.  
  1238. Input 
  1239.  
  1240.  ADDRESS Handle 
  1241.            This is the handle of a drive or volume.  Drive handles are obtained 
  1242.            through the Get_Drive_Control_Data function.  Volume handles are 
  1243.            obtained through the Get_Volume_Control_Data function. 
  1244.  
  1245.  CARDINAL32 * Error_Code 
  1246.            The address of a CARDINAL32 in which to store an error code should 
  1247.            an error occur. 
  1248.  
  1249.  Output 
  1250.  
  1251.  This function returns a structure.  The structure has two components: an array 
  1252.  of partition information records and the number of entries in the array. If 
  1253.  Handle is the handle of a disk drive, then the returned array will contain a 
  1254.  partition information record for each partition and block of free space on 
  1255.  that drive.  If Handle is the handle of a volume, then the returned array will 
  1256.  contain a partition information record for each partition which is part of the 
  1257.  specified volume.  If no errors occur, then *Error_Code will be 0.  If an 
  1258.  error does occur, then *Error_Code will be non-zero. 
  1259.  
  1260.  Error Handling 
  1261.  
  1262.  Any memory allocated for the return value will be freed.  The 
  1263.  Partition_Information_Array returned by this function will contain a NULL 
  1264.  pointer for Partition_Array, and have a Count of 0.  *Error_Code will be 
  1265.  non-zero. 
  1266.  
  1267.  If Handle is non-NULL and is invalid, a trap is likely. 
  1268.  
  1269.  Side Effects 
  1270.  
  1271.  Memory will be allocated to hold the array returned by this function. 
  1272.  
  1273.  Notes 
  1274.  
  1275.  The caller becomes responsible for the memory allocated for the array of 
  1276.  Partition_Information_Records pointed to by Partition_Array pointer in the 
  1277.  Partition_Information_Array structure returned by this function.  The caller 
  1278.  should free this memory when they are done using it. 
  1279.  
  1280.  16 Bit Versions: 
  1281.  
  1282.   void _Far16 _Pascal _loadds GET_PARTITIONS16(
  1283.           CARDINAL32                                     Handle,
  1284.           Partition_Information_Record * _Seg16 * _Seg16 Partition_Array,
  1285.           CARDINAL32 *                            _Seg16 Count,
  1286.           CARDINAL32 *                            _Seg16 Error_Code
  1287.   );
  1288.  
  1289.   void far pascal _loadds GET_PARTITIONS16(
  1290.           CARDINAL32                           Handle,
  1291.           Partition_Information_Record far * * Partition_Array,
  1292.           CARDINAL32 far *                     Count,
  1293.           CARDINAL32 far *                     Error_Code
  1294.   );
  1295.  
  1296.  
  1297. ΓòÉΓòÉΓòÉ 3.3.3.2. Get_Partition_Handle ΓòÉΓòÉΓòÉ
  1298.  
  1299. ADDRESS _System Get_Partition_Handle(
  1300.  
  1301.         CARDINAL32   Serial_Number,
  1302.         CARDINAL32 * Error_Code
  1303.  
  1304. );
  1305.  
  1306. Description 
  1307.  
  1308. Returns the handle of the partition whose serial number matches the one 
  1309. provided. 
  1310.  
  1311. Input 
  1312.  
  1313.  CARDINAL32 Serial_Number 
  1314.            This is the serial number to look for.  If a partition with a 
  1315.            matching serial number is found, its handle will be returned. 
  1316.  
  1317.  CARDINAL32 * Error_Code 
  1318.            The address of a CARDINAL32 in which to store an error code should 
  1319.            an error occur. 
  1320.  
  1321.  Output 
  1322.  
  1323.  If a partition with a matching serial number is found, then the function 
  1324.  return value will be the handle of the partition found.  If no matching 
  1325.  partition is found, then the function return value will be NULL. 
  1326.  
  1327.  Error Handling 
  1328.  
  1329.  If no errors occur, *Error_Code will be LVM_ENGINE_NO_ERROR.  If an error 
  1330.  occurs, then *Error_Code will be a non-zero error code. 
  1331.  
  1332.  Side Effects 
  1333.  
  1334.  None. 
  1335.  
  1336.  Notes 
  1337.  
  1338.  None. 
  1339.  
  1340.  16 Bit Versions: 
  1341.  
  1342.   void _Far16 _Pascal _loadds GET_PARTITION_HANDLE16(
  1343.           CARDINAL32          Serial_Number,
  1344.           CARDINAL32 * _Seg16 Handle,
  1345.           CARDINAL32 * _Seg16 Error_Code
  1346.   );
  1347.  
  1348.   void far pascal _loadds GET_PARTITION_HANDLE16(
  1349.           CARDINAL32       Serial_Number,
  1350.           CARDINAL32 far * Handle,
  1351.           CARDINAL32 far * Error_Code
  1352.   );
  1353.  
  1354.  
  1355. ΓòÉΓòÉΓòÉ 3.3.3.3. Get_Partition_Information ΓòÉΓòÉΓòÉ
  1356.  
  1357. Partition_Information_Record  _System Get_Partition_Information(
  1358.  
  1359.         ADDRESS      Partition_Handle,
  1360.         CARDINAL32 * Error_Code
  1361.  
  1362. );
  1363.  
  1364. Description 
  1365.  
  1366. Returns the Partition_Information_Record for the partition specified by 
  1367. Partition_Handle. 
  1368.  
  1369. Input 
  1370.  
  1371.  ADDRESS Partition_Handle 
  1372.            The handle associated with the partition for which the 
  1373.            Partition_Information_Record is desired. 
  1374.  
  1375.  CARDINAL32 * Error_Code 
  1376.            The address of a CARDINAL32 in which to store an error code should 
  1377.            an error occur. 
  1378.  
  1379.  Output 
  1380.  
  1381.  A Partition_Information_Record is returned.  If there is no error, then 
  1382.  *Error_Code will be 0.  If an error occurs, *Error_Code will be non-zero. 
  1383.  
  1384.  Error Handling 
  1385.  
  1386.  If the Partition_Handle is not a valid handle, a trap could result.  If it is 
  1387.  a handle for something other than a partition, an error code will be returned 
  1388.  in *Error_Code. 
  1389.  
  1390.  Side Effects 
  1391.  
  1392.  None. 
  1393.  
  1394.  Notes 
  1395.  
  1396.  None. 
  1397.  
  1398.  16 Bit Versions: 
  1399.  
  1400.   void _Far16 _Pascal _loadds  GET_PARTITION_INFORMATION16(
  1401.           CARDINAL32                            Partition_Handle,
  1402.           Partition_Information_Record * _Seg16 Partition_Information,
  1403.           CARDINAL32 *                   _Seg16 Error_Code
  1404.   );
  1405.  
  1406.   void far pascal _loadds  GET_PARTITION_INFORMATION16(
  1407.           CARDINAL32                         Partition_Handle,
  1408.           Partition_Information_Record far * Partition_Information,
  1409.           CARDINAL32 far *                   Error_Code
  1410.   );
  1411.  
  1412.  
  1413. ΓòÉΓòÉΓòÉ 3.3.3.4. Create_Partition ΓòÉΓòÉΓòÉ
  1414.  
  1415. ADDRESS _System Create_Partition(
  1416.  
  1417.         ADDRESS               Handle,
  1418.         CARDINAL32            Size,
  1419.         char                  Name[ PARTITION_NAME_SIZE ],
  1420.         Allocation_Algorithm  algorithm,
  1421.         BOOLEAN               Bootable,
  1422.         BOOLEAN               Primary_Partition,
  1423.         BOOLEAN               Allocate_From_Start,
  1424.         CARDINAL32 *          Error_Code
  1425.  
  1426. );
  1427.  
  1428. Description 
  1429.  
  1430. Creates a partition on a disk drive. 
  1431.  
  1432. Input 
  1433.  
  1434.  ADDRESS Handle 
  1435.            The handle of a disk drive or a block of free space. 
  1436.  
  1437.  CARDINAL32 Size 
  1438.            The size, in sectors, of the partition to create. 
  1439.  
  1440.  char Name[] 
  1441.            The name to give to the newly created partition. 
  1442.  
  1443.  Allocation_Algorithm algorithm 
  1444.            If Handle is a drive, then the engine will find a block of free 
  1445.            space to use to create the partition.  This tells the engine which 
  1446.            memory management algorithm to use. 
  1447.  
  1448.  BOOLEAN Bootable 
  1449.            If TRUE, then the engine will only create the partition if it can be 
  1450.            booted from.  If Primary_Partition is FALSE, then it is assumed that 
  1451.            OS/2 is the operating system that will be booted. 
  1452.  
  1453.  BOOLEAN Primary_Partition 
  1454.            If TRUE, then the engine will create a primary partition. 
  1455.            If FALSE, then the engine will create a logical drive. 
  1456.  
  1457.  BOOLEAN Allocate_From_Start 
  1458.            If TRUE, then the engine will allocate the new partition from the 
  1459.            beginning of the selected block of free space.  If FALSE, then the 
  1460.            partition will be allocated from the end of the selected block of 
  1461.            free space. 
  1462.  
  1463.  CARDINAL32 * Error_Code 
  1464.            The address of a CARDINAL32 in which to store an error code should 
  1465.            an error occur. 
  1466.  
  1467.  Output 
  1468.  
  1469.  The function return value will be the handle of the partition created.  If the 
  1470.  partition could not be created, then NULL will be returned. 
  1471.  
  1472.  *Error_Code will be 0 if the partition was created. 
  1473.  *Error_Code will be > 0 if the partition could not be created. 
  1474.  
  1475.  Error Handling 
  1476.  
  1477.  If the partition can not be created, then any memory allocated by this 
  1478.  function will be freed and the partitioning of the disk in question will be 
  1479.  unchanged. 
  1480.  
  1481.  If Handle is not a valid handle, then a trap may result. 
  1482.  
  1483.  If Handle represents a partition or volume, then the function will abort and 
  1484.  set *Error_Code to a non-zero value. 
  1485.  
  1486.  Side Effects 
  1487.  
  1488.  A partition may be created on a disk drive. 
  1489.  
  1490.  Notes 
  1491.  
  1492.  None. 
  1493.  
  1494.  16 Bit Versions: 
  1495.  
  1496.   CARDINAL32 _Far16 _Pascal _loadds CREATE_PARTITION16(
  1497.           CARDINAL32           Handle,
  1498.           CARDINAL32           Size,
  1499.           char  *     _Seg16   Name,
  1500.           Allocation_Algorithm algorithm,
  1501.           BOOLEAN              Bootable,
  1502.           BOOLEAN              Primary_Partition,
  1503.           BOOLEAN              Allocate_From_Start,
  1504.           CARDINAL32 * _Seg16  Error_Code
  1505.   );
  1506.  
  1507.   CARDINAL32 far pascal _loadds CREATE_PARTITION16(
  1508.           CARDINAL32           Handle,
  1509.           CARDINAL32           Size,
  1510.           char far             Name[ PARTITION_NAME_SIZE ],
  1511.           Allocation_Algorithm algorithm,
  1512.           BOOLEAN              Bootable,
  1513.           BOOLEAN              Primary_Partition,
  1514.           BOOLEAN              Allocate_From_Start,
  1515.           CARDINAL32 far *     Error_Code
  1516.   );
  1517.  
  1518.  
  1519. ΓòÉΓòÉΓòÉ 3.3.3.5. Delete_Partition ΓòÉΓòÉΓòÉ
  1520.  
  1521. void _System Delete_Partition(
  1522.  
  1523.         ADDRESS      Partition_Handle,
  1524.         CARDINAL32 * Error_Code
  1525.  
  1526. );
  1527.  
  1528. Description 
  1529.  
  1530. Deletes the partition specified by Partition_Handle. 
  1531.  
  1532. Input 
  1533.  
  1534.  ADDRESS Partition_Handle 
  1535.            The handle associated with the partition to be deleted. 
  1536.  
  1537.  CARDINAL32 * Error_Code 
  1538.            The address of a CARDINAL32 in which to store an error code should 
  1539.            an error occur. 
  1540.  
  1541.  Output 
  1542.  
  1543.  *Error_Code will be 0 if the partition was deleted successfully. *Error_Code 
  1544.  will be > 0 if the partition could not be deleted. 
  1545.  
  1546.  Error Handling 
  1547.  
  1548.  If the partition can not be deleted, then *Error_Code will be > 0. 
  1549.  
  1550.  If Partition_Handle is not a valid handle, a trap may result. 
  1551.  
  1552.  If Partition_Handle is a volume or drive handle, then this function will abort 
  1553.  and set *Error_Code to a non-zero value. 
  1554.  
  1555.  Side Effects 
  1556.  
  1557.  A partition on a disk drive may be deleted. 
  1558.  
  1559.  Notes 
  1560.  
  1561.  A partition can not be deleted if it is part of a volume! 
  1562.  
  1563.  16 Bit Versions: 
  1564.  
  1565.   void _Far16 _Pascal _loadds DELETE_PARTITION16(
  1566.           CARDINAL32          Partition_Handle,
  1567.           CARDINAL32 * _Seg16 Error_Code
  1568.   );
  1569.  
  1570.   void far pascal _loadds DELETE_PARTITION16(
  1571.           CARDINAL32       Partition_Handle,
  1572.           CARDINAL32 far * Error_Code
  1573.   );
  1574.  
  1575.  
  1576. ΓòÉΓòÉΓòÉ 3.3.3.6. Set_Active_Flag ΓòÉΓòÉΓòÉ
  1577.  
  1578. void _System Set_Active_Flag (
  1579.  
  1580.         ADDRESS      Partition_Handle,
  1581.         BYTE         Active_Flag,
  1582.         CARDINAL32 * Error_Code
  1583.  
  1584. );
  1585.  
  1586. Description 
  1587.  
  1588. Sets the Active Flag field for a partition. 
  1589.  
  1590. Input 
  1591.  
  1592.  ADDRESS Partition_Handle 
  1593.            The handle of the partition whose Active Flag is to be set 
  1594.  
  1595.  BYTE Active_Flag 
  1596.            The new value for the Active Flag. 
  1597.  
  1598.  CARDINAL32 * Error_Code 
  1599.            The address of a CARDINAL32 in which to store an error code should 
  1600.            an error occur. 
  1601.  
  1602.  Output 
  1603.  
  1604.  *Error_Code will be 0 if the Active Flag was successfully set, otherwise 
  1605.  *Error_Code will contain a non-zero error code indicating what went wrong. 
  1606.  
  1607.  Error Handling 
  1608.  
  1609.  If the Active Flag can not be set, this function will abort without changing 
  1610.  any disk structures. 
  1611.  
  1612.  If Partition_Handle is not a valid handle, a trap may result. 
  1613.  
  1614.  If Partition_Handle is a volume or drive handle, then this function will abort 
  1615.  and set *Error_Code to a non-zero value. 
  1616.  
  1617.  Side Effects 
  1618.  
  1619.  The Active Flag for a partition may be modified. 
  1620.  
  1621.  Notes 
  1622.  
  1623.  None. 
  1624.  
  1625.  16 Bit Versions: 
  1626.  
  1627.   void _Far16 _Pascal _loadds SET_ACTIVE_FLAG16(
  1628.           CARDINAL32          Partition_Handle,
  1629.           BYTE                Active_Flag,
  1630.           CARDINAL32 * _Seg16 Error_Code
  1631.   );
  1632.  
  1633.   void far pascal _loadds SET_ACTIVE_FLAG16(
  1634.           CARDINAL32       Partition_Handle,
  1635.           BYTE             Active_Flag,
  1636.           CARDINAL32 far * Error_Code
  1637.   );
  1638.  
  1639.  
  1640. ΓòÉΓòÉΓòÉ 3.3.3.7. Set_OS_Flag ΓòÉΓòÉΓòÉ
  1641.  
  1642. void _System Set_OS_Flag (
  1643.  
  1644.         ADDRESS      Partition_Handle,
  1645.         BYTE         OS_Flag,
  1646.         CARDINAL32 * Error_Code
  1647.  
  1648. );
  1649.  
  1650. Description 
  1651.  
  1652. Sets the OS Flag field for a partition.  This field is typically used to 
  1653. indicate the filesystem used on the partition, which generally gives an 
  1654. indication of which OS is using that partition. 
  1655.  
  1656. Input 
  1657.  
  1658.  ADDRESS Partition_Handle 
  1659.            The handle of the partition whose Active Flag is to be set 
  1660.  
  1661.  BYTE OS_Flag 
  1662.            The new value for the OS Flag. 
  1663.  
  1664.  CARDINAL32 * Error_Code 
  1665.            The address of a CARDINAL32 in in which to store an error code 
  1666.            should an error occur. 
  1667.  
  1668.  Output 
  1669.  
  1670.  *Error_Code will be 0 if the OS Flag was successfully set, otherwise 
  1671.  *Error_Code will contain a non-zero error code indicating what went wrong. 
  1672.  
  1673.  Error Handling 
  1674.  
  1675.  If the OS Flag can not be set, this function will abort without changing any 
  1676.  disk structures. 
  1677.  
  1678.  If Partition_Handle is not a valid handle, a trap may result. 
  1679.  
  1680.  If Partition_Handle is a volume or drive handle, then this function will abort 
  1681.  and set *Error_Code to a non-zero value. 
  1682.  
  1683.  Side Effects 
  1684.  
  1685.  The OS Flag for a partition may be modified. 
  1686.  
  1687.  Notes 
  1688.  
  1689.  None. 
  1690.  
  1691.  16 Bit Versions: 
  1692.  
  1693.   void _Far16 _Pascal _loadds SET_OS_FLAG16(
  1694.           CARDINAL32          Partition_Handle,
  1695.           BYTE                OS_Flag,
  1696.           CARDINAL32 * _Seg16 Error_Code
  1697.   );
  1698.  
  1699.   void far pascal _loadds SET_OS_FLAG16(
  1700.           CARDINAL32       Partition_Handle,
  1701.           BYTE             OS_Flag,
  1702.           CARDINAL32 far * Error_Code
  1703.   );
  1704.  
  1705.  
  1706. ΓòÉΓòÉΓòÉ 3.3.4. Functions relating to Volumes ΓòÉΓòÉΓòÉ
  1707.  
  1708. Functions relating to volumes. 
  1709.  
  1710.  
  1711. ΓòÉΓòÉΓòÉ 3.3.4.1. Get_Volume_Control_Data ΓòÉΓòÉΓòÉ
  1712.  
  1713. Volume_Control_Array _System Get_Volume_Control_Data( CARDINAL32 * Error_Code );
  1714.  
  1715. Description 
  1716.  
  1717. This function returns a structure containing an array of 
  1718. Volume_Control_Records.  These records contain information about volumes which 
  1719. is invariant - i.e. will not change for as long as the volume exists.  One of 
  1720. the items in the Volume_Control_Record is the handle for the volume.  This 
  1721. handle must be used on all accesses to the volume. 
  1722.  
  1723. Input 
  1724.  
  1725.  CARDINAL32 * Error_Code 
  1726.            The address of a CARDINAL32 in which to store an error code should 
  1727.            an error occur. 
  1728.  
  1729.  Output 
  1730.  
  1731.  A Volume_Control_Array structure is returned. 
  1732.  
  1733.  If there are no errors, then the Volume_Control_Data pointer in the 
  1734.  Volume_Control_Array will be non-NULL, the Count field of the 
  1735.  Volume_Control_Array will be >= 0, and *Error_Code will be 0. 
  1736.  
  1737.  If an error does occur, then the Volume_Control_Data pointer in the the 
  1738.  Volume_Control_Array will be NULL, the Count field of the Volume_Control_Array 
  1739.  will be 0, and *Error_Code will be > 0. 
  1740.  
  1741.  Error Handling 
  1742.  
  1743.  If an error occurs, then any memory allocated by this function will be freed. 
  1744.  
  1745.  Side Effects 
  1746.  
  1747.  Memory for the returned array is allocated. 
  1748.  
  1749.  Notes 
  1750.  
  1751.  The caller becomes responsible for the memory allocated for the array of 
  1752.  Volume_Control_Records pointed to by Volume_Control_Data pointer in the 
  1753.  Volume_Control_Array structure returned by this function.  The caller should 
  1754.  free this memory when they are done using it. 
  1755.  
  1756.  16 Bit Versions: 
  1757.  
  1758.   void _Far16 _Pascal _loadds GET_VOLUME_CONTROL_DATA16(
  1759.           Volume_Control_Record * _Seg16 * _Seg16 Volume_Control_Data,
  1760.           CARDINAL32 *                     _Seg16 Count,
  1761.           CARDINAL32 *                     _Seg16 Error_Code
  1762.   );
  1763.  
  1764.   void far pascal _loadds GET_VOLUME_CONTROL_DATA16(
  1765.           Volume_Control_Record far ** Volume_Control_Data,
  1766.           CARDINAL32 far *             Count,
  1767.           CARDINAL32 far *             Error_Code
  1768.   );
  1769.  
  1770.  
  1771. ΓòÉΓòÉΓòÉ 3.3.4.2. Get_Volume_Information ΓòÉΓòÉΓòÉ
  1772.  
  1773. Volume_Information_Record _System Get_Volume_Information(
  1774.  
  1775.         ADDRESS      Volume_Handle,
  1776.         CARDINAL32 * Error_Code
  1777.  
  1778. );
  1779.  
  1780. Description 
  1781.  
  1782. This function returns the Volume_Information_Record for the volume associated 
  1783. with Volume_Handle. 
  1784.  
  1785. Input 
  1786.  
  1787.  ADDRESS Volume_Handle 
  1788.            The handle of the volume about which information is desired. 
  1789.  
  1790.  CARDINAL32 * Error_Code 
  1791.            The address of a CARDINAL32 in which to store an error code should 
  1792.            an error occur. 
  1793.  
  1794.  Output 
  1795.  
  1796.  This function returns a Volume_Information_Record. 
  1797.  
  1798.  If this function is successful, then *Error_Code will be 0. 
  1799.  
  1800.  If this function fails, then *Error_Code will be > 0. 
  1801.  
  1802.  Error Handling 
  1803.  
  1804.  If Volume_Handle is not a valid handle, a trap will be likely.  If 
  1805.  Volume_Handle is a drive or partition handle, *Error_Code will be > 0. 
  1806.  
  1807.  Side Effects 
  1808.  
  1809.  None. 
  1810.  
  1811.  Notes 
  1812.  
  1813.  None. 
  1814.  
  1815.  16 Bit Versions: 
  1816.  
  1817.   void _Far16 _Pascal _loadds GET_VOLUME_INFORMATION16(
  1818.           CARDINAL32                         Volume_Handle,
  1819.           Volume_Information_Record * _Seg16 Volume_Information,
  1820.           CARDINAL32 *                _Seg16 Error_Code
  1821.  
  1822.   );
  1823.  
  1824.   void far pascal _loadds GET_VOLUME_INFORMATION16(
  1825.           CARDINAL32                      Volume_Handle,
  1826.           Volume_Information_Record far * Volume_Information,
  1827.           CARDINAL32 far *                Error_Code
  1828.   );
  1829.  
  1830.  
  1831. ΓòÉΓòÉΓòÉ 3.3.4.3. Create_Volume ΓòÉΓòÉΓòÉ
  1832.  
  1833. void _System Create_Volume(
  1834.  
  1835.         char         Name[ VOLUME_NAME_SIZE ],
  1836.         BOOLEAN      Create_LVM_Volume,
  1837.         BOOLEAN      Bootable,
  1838.         char         Drive_Letter_Preference,
  1839.         CARDINAL32   FeaturesToUse,
  1840.         CARDINAL32   Partition_Count,
  1841.         ADDRESS      Partition_Handles[ ],
  1842.         CARDINAL32 * Error_Code
  1843.  
  1844. );
  1845.  
  1846. Description 
  1847.  
  1848. This function creates a volume from a list of partitions.  The partitions are 
  1849. specified by their corresponding handles. 
  1850.  
  1851. Input 
  1852.  
  1853.  char Name[] 
  1854.            The name to assign to the newly created volume. 
  1855.  
  1856.  BOOLEAN Create_LVM_Volume 
  1857.            If TRUE, then an LVM volume is created, otherwise a compatibility 
  1858.            volume is created. 
  1859.  
  1860.  BOOLEAN Bootable 
  1861.            If TRUE, the volume will not be created unless OS/2 can be booted 
  1862.            from it. 
  1863.  
  1864.  char Drive_Letter_Preference 
  1865.            This is the drive letter to use for accessing the newly created 
  1866.            volume. 
  1867.  
  1868.  CARDINAL32 FeaturesToUse 
  1869.            This is currently reserved for future use and should always be set 
  1870.            to 0. 
  1871.  
  1872.  CARDINAL32 Partition_Count 
  1873.            The number of partitions to link together to form the volume being 
  1874.            created. 
  1875.  
  1876.  ADDRESS Partition_Handles[] 
  1877.            An array of partition handles with one entry for each partition that 
  1878.            is to become part of the volume being created. 
  1879.  
  1880.  CARDINAL32 * Error_Code 
  1881.            The address of a CARDINAL32 in which to store an error code should 
  1882.            an error occur. 
  1883.  
  1884.  Output 
  1885.  
  1886.  *Error_Code will be 0 if the volume was created. 
  1887.  *Error_Code will be > 0 if the volume could not be created. 
  1888.  
  1889.  Error Handling 
  1890.  
  1891.  If any of the handles in the partition handles array is not valid, then a trap 
  1892.  is likely.  If Partition_Count is greater than the number of entries in the 
  1893.  partition handles array, then a trap is likely.  If any of the handles in the 
  1894.  partition array are not partition handles, then *Error_Code will be > 0. If 
  1895.  the volume can NOT be created, then *Error_Code will be > 0 and any memory 
  1896.  allocated by this function will be freed.  If the volume can NOT be created, 
  1897.  then the existing partition/volume structure of the disk will be unchanged. 
  1898.  
  1899.  Side Effects 
  1900.  
  1901.  A volume may be created. 
  1902.  
  1903.  Notes 
  1904.  
  1905.  (This note applies when the LVM Engine is LVM Version 2.) 
  1906.  
  1907.  This function provides limited compatibility for programs written to use the 
  1908.  LVM Version 1 interface.  Specifically, this function will only allow the 
  1909.  creation of compatibility volumes.  Any attempt to create an LVM volume will 
  1910.  result in an error code being returned. 
  1911.  
  1912.  16 Bit Versions: 
  1913.  
  1914.   void _Far16 _Pascal _loadds CREATE_VOLUME16(
  1915.           char   *     _Seg16 Name,
  1916.           BOOLEAN             Create_LVM_Volume,
  1917.           BOOLEAN             Bootable,
  1918.           char                Drive_Letter_Preference,
  1919.           CARDINAL32          FeaturesToUse,
  1920.           CARDINAL32          Partition_Count,
  1921.           CARDINAL32 * _Seg16 Partition_Handles,
  1922.           CARDINAL32 * _Seg16 Error_Code
  1923.   );
  1924.  
  1925.   void far pascal _loadds CREATE_VOLUME16(
  1926.           char far         Name[VOLUME_NAME_SIZE],
  1927.           BOOLEAN          Create_LVM_Volume,
  1928.           BOOLEAN          Bootable,
  1929.           char             Drive_Letter_Preference,
  1930.           CARDINAL32       FeaturesToUse,
  1931.           CARDINAL32       Partition_Count,
  1932.           CARDINAL32       Partition_Handles[],
  1933.           CARDINAL32 far * Error_Code
  1934.   );
  1935.  
  1936.  
  1937. ΓòÉΓòÉΓòÉ 3.3.4.4. Create_Volume2 ΓòÉΓòÉΓòÉ
  1938.  
  1939. LVM Version 2 only 
  1940.  
  1941. void _System Create_Volume2(
  1942.  
  1943.         char                               Name[ VOLUME_NAME_SIZE ],
  1944.         BOOLEAN                            Create_LVM_Volume,
  1945.         BOOLEAN                            Bootable,
  1946.         char                               Drive_Letter_Preference,
  1947.         CARDINAL32                         Feature_Count,
  1948.         LVM_Feature_Specification_Record   FeaturesToUse[ ],
  1949.         CARDINAL32                         Partition_Count,
  1950.         ADDRESS                            Partition_Handles[ ],
  1951.         CARDINAL32 *                       Error_Code
  1952.  
  1953. );
  1954.  
  1955. Description 
  1956.  
  1957. This function creates a volume from a list of partitions.  The partitions are 
  1958. specified by their corresponding handles. 
  1959.  
  1960. Input 
  1961.  
  1962.  char Name[] 
  1963.            The name to assign to the newly created volume. 
  1964.  
  1965.  BOOLEAN Create_LVM_Volume 
  1966.            If TRUE, then an LVM volume is created, otherwise a compatibility 
  1967.            volume is created. 
  1968.  
  1969.  BOOLEAN Bootable 
  1970.            If TRUE, the volume will not be created unless OS/2 can be booted 
  1971.            from it. 
  1972.  
  1973.  char Drive_Letter_Preference 
  1974.            This is the drive letter to use for accessing the newly created 
  1975.            volume. 
  1976.  
  1977.  CARDINAL32 Feature_Count 
  1978.            The number of features to install on the volume being created.  This 
  1979.            field is ignored if Create_LVM_Volume is FALSE. 
  1980.  
  1981.  LVM_Feature_Specification_Record FeaturesToUse[] 
  1982.            An array of feature IDs and their associated LVM classes used to 
  1983.            designate which features to install on the volume being created and 
  1984.            the order in which to install them.  This field is ignored if 
  1985.            Create_LVM_Volume is FALSE. 
  1986.  
  1987.  CARDINAL32 Partition_Count 
  1988.            The number of partitions to link together to form the volume being 
  1989.            created. 
  1990.  
  1991.  ADDRESS Partition_Handles[] 
  1992.            An array of partition handles with one entry for each partition that 
  1993.            is to become part of the volume being created. 
  1994.  
  1995.  CARDINAL32 * Error_Code 
  1996.            The address of a CARDINAL32 in which to store an error code should 
  1997.            an error occur. 
  1998.  
  1999.  Output 
  2000.  
  2001.  *Error_Code will be 0 if the volume was created. 
  2002.  *Error_Code will be > 0 if the volume could not be created. 
  2003.  
  2004.  Error Handling 
  2005.  
  2006.  If any of the handles in the partition handles array is not valid, then a trap 
  2007.  is likely.  If Partition_Count is greater than the number of entries in the 
  2008.  partition handles array, then a trap is likely.  If any of the handles in the 
  2009.  partition array are not partition handles, then *Error_Code will be > 0. If 
  2010.  the volume can NOT be created, then *Error_Code will be > 0 and any memory 
  2011.  allocated by this function will be freed.  If the volume can NOT be created, 
  2012.  then the existing partition/volume structure of the disk will be unchanged. 
  2013.  
  2014.  Side Effects 
  2015.  
  2016.  A volume may be created. 
  2017.  
  2018.  Notes 
  2019.  
  2020.  None. 
  2021.  
  2022.  16 Bit Versions: 
  2023.  
  2024.   void _Far16 _Pascal _loadds  CREATE_VOLUME216(
  2025.           char   * _Seg16                           Name,
  2026.           BOOLEAN                                   Create_LVM_Volume,
  2027.           BOOLEAN                                   Bootable,
  2028.           char                                      Drive_Letter_Preference,
  2029.           CARDINAL32                                Feature_Count,
  2030.           LVM_Feature_Specification_Record * _Seg16 FeaturesToUse,
  2031.           CARDINAL32                                Partition_Count,
  2032.           CARDINAL32 * _Seg16                       Partition_Handles,
  2033.           CARDINAL32 * _Seg16                       Error_Code
  2034.   );
  2035.  
  2036.   void far pascal _loadds CREATE_VOLUME216(
  2037.           char far  *                            Name,
  2038.           BOOLEAN                                Create_LVM_Volume,
  2039.           BOOLEAN                                Bootable,
  2040.           char                                   Drive_Letter_Preference,
  2041.           CARDINAL32                             Feature_Count,
  2042.           LVM_Feature_Specification_Record far * FeaturesToUse,
  2043.           CARDINAL32                             Partition_Count,
  2044.           CARDINAL32 far *                       Partition_Handles,
  2045.           CARDINAL32 far *                       Error_Code
  2046.   );
  2047.  
  2048.  
  2049. ΓòÉΓòÉΓòÉ 3.3.4.5. Delete_Volume ΓòÉΓòÉΓòÉ
  2050.  
  2051. void _System Delete_Volume(
  2052.  
  2053.         ADDRESS      Volume_Handle,
  2054.         CARDINAL32 * Error_Code
  2055.  
  2056. );
  2057.  
  2058. Description 
  2059.  
  2060. Deletes the volume specified by Volume_Handle. 
  2061.  
  2062. Input 
  2063.  
  2064.  ADDRESS Volume_Handle 
  2065.            The handle of the volume to delete.  All partitions which are part 
  2066.            of the specified volume will be deleted also. 
  2067.  
  2068.  CARDINAL32 * Error_Code 
  2069.            The address of a CARDINAL32 in which to store an error code should 
  2070.            an error occur. 
  2071.  
  2072.  Output 
  2073.  
  2074.  *Error_Code will be 0 if the volume and its partitions are successfully 
  2075.  deleted.  Otherwise, *Error_Code will be > 0. 
  2076.  
  2077.  Error Handling 
  2078.  
  2079.  *Error_Code will be > 0 if an error occurs.  If the volume or any of its 
  2080.  partitions can not be deleted, then any changes made by this function will be 
  2081.  undone. 
  2082.  
  2083.  If Volume_Handle is not a valid handle, a trap may result. 
  2084.  
  2085.  If Volume_Handle is a partition or drive handle, then this function will abort 
  2086.  and set *Error_Code to a non-zero value. 
  2087.  
  2088.  Side Effects 
  2089.  
  2090.  A volume and its partitions may be deleted.  System memory may be freed as the 
  2091.  internal structures used to track the deleted volume are no longer required. 
  2092.  
  2093.  Notes 
  2094.  
  2095.  None. 
  2096.  
  2097.  16 Bit Versions: 
  2098.  
  2099.   void _Far16 _Pascal _loadds DELETE_VOLUME16(
  2100.           CARDINAL32          Volume_Handle,
  2101.           CARDINAL32 * _Seg16 Error_Code
  2102.   );
  2103.  
  2104.   void far pascal _loadds DELETE_VOLUME16(
  2105.           CARDINAL32       Volume_Handle,
  2106.           CARDINAL32 far * Error_Code
  2107.   );
  2108.  
  2109.  
  2110. ΓòÉΓòÉΓòÉ 3.3.4.6. Hide_Volume ΓòÉΓòÉΓòÉ
  2111.  
  2112. void _System Hide_Volume(
  2113.  
  2114.         ADDRESS      Volume_Handle,
  2115.         CARDINAL32 * Error_Code
  2116.  
  2117. );
  2118.  
  2119. Description 
  2120.  
  2121. Hide volume "hides" a volume from OS/2 by removing its drive letter assignment. 
  2122. Without a drive letter assignment, OS/2 can not access (or "see") the volume. 
  2123.  
  2124. Input 
  2125.  
  2126.  ADDRESS Volume_Handle 
  2127.            The handle of the volume to hide. 
  2128.  
  2129.  CARDINAL32 * Error_Code 
  2130.            The address of a CARDINAL32 in which to store an error code should 
  2131.            an error occur. 
  2132.  
  2133.  Output 
  2134.  
  2135.  *Error_Code will be 0 if the volume was successfully hidden.  If the volume 
  2136.  could not be hidden, then *Error_Code will be > 0. 
  2137.  
  2138.  Error Handling 
  2139.  
  2140.  *Error_Code will be > 0 if the volume can not be hidden.  If the volume can 
  2141.  not be hidden, then nothing will be altered. 
  2142.  
  2143.  If Volume_Handle is not a valid handle, a trap may result. 
  2144.  
  2145.  If Volume_Handle is a partition or drive handle, then this function will abort 
  2146.  and set *Error_Code to a non-zero value. 
  2147.  
  2148.  Side Effects 
  2149.  
  2150.  None. 
  2151.  
  2152.  Notes 
  2153.  
  2154.  None. 
  2155.  
  2156.  16 Bit Versions: 
  2157.  
  2158.   void _Far16 _Pascal _loadds HIDE_VOLUME16(
  2159.           CARDINAL32          Volume_Handle,
  2160.           CARDINAL32 * _Seg16 Error_Code
  2161.   );
  2162.  
  2163.   void far pascal _loadds HIDE_VOLUME16(
  2164.           CARDINAL32       Volume_Handle,
  2165.           CARDINAL32 far * Error_Code
  2166.   );
  2167.  
  2168.  
  2169. ΓòÉΓòÉΓòÉ 3.3.4.7. Expand_Volume ΓòÉΓòÉΓòÉ
  2170.  
  2171. void _System Expand_Volume(
  2172.  
  2173.         ADDRESS         Volume_Handle,
  2174.         CARDINAL32      Partition_Count,
  2175.         ADDRESS         Partition_Handles[ ],
  2176.         CARDINAL32 *    Error_Code
  2177.  
  2178. );
  2179.  
  2180. Description 
  2181.  
  2182. This function expands an existing volume by linking additional partitions to 
  2183. it. 
  2184.  
  2185. Input 
  2186.  
  2187.  ADDRESS Volume_Handle 
  2188.            The handle of the volume to be expanded. 
  2189.  
  2190.  CARDINAL32 Partition_Count 
  2191.            The number of partitions or volumes to be added to the volume being 
  2192.            expanded. 
  2193.  
  2194.  ADDRESS Partition_Handles[] 
  2195.            An array of handles.  Each handle in the array is the handle of a 
  2196.            partition which is to be added to the volume being expanded. 
  2197.  
  2198.  CARDINAL32 * Error_Code 
  2199.            The address of a CARDINAL32 in which to store an error code should 
  2200.            an error occur. 
  2201.  
  2202.  Output 
  2203.  
  2204.  *Error_Code will be 0 if the volume is successfully expanded.  If the volume 
  2205.  can not be expanded, *Error_Code will be > 0. 
  2206.  
  2207.  Error Handling 
  2208.  
  2209.  If the volume can not be expanded, the state of the volume is unchanged and 
  2210.  any memory allocated by this function is freed. 
  2211.  
  2212.  If Volume_Handle is not a valid handle, a trap may result. 
  2213.  
  2214.  If Volume_Handle is a partition or drive handle, then this function will abort 
  2215.  and set *Error_Code to a non-zero value. 
  2216.  
  2217.  If any of the partition handles in the Partition_handles array are not valid 
  2218.  handles, then a trap may result. 
  2219.  
  2220.  If any of the partition handles in the Partition_Handles array are actually 
  2221.  drive handles, then this function will abort and set *Error_Code to a non-zero 
  2222.  value. 
  2223.  
  2224.  If Partition_Count is greater than the number of entries in the 
  2225.  Partition_Handles array, a trap may result. 
  2226.  
  2227.  Side Effects 
  2228.  
  2229.  A volume may be expanded.  If the volume is expanded using another volume, the 
  2230.  partitions on the second volume will be linked to those of the first volume 
  2231.  and all data on the second volume will be lost. 
  2232.  
  2233.  Notes 
  2234.  
  2235.  None. 
  2236.  
  2237.  16 Bit Versions: 
  2238.  
  2239.   void _Far16 _Pascal _loadds EXPAND_VOLUME16(
  2240.           CARDINAL32          Volume_Handle,
  2241.           CARDINAL32          Partition_Count,
  2242.           CARDINAL32 * _Seg16 Partition_Handles,
  2243.           CARDINAL32 * _Seg16 Error_Code
  2244.   );
  2245.  
  2246.   void far pascal _loadds EXPAND_VOLUME16(
  2247.           CARDINAL32       Volume_Handle,
  2248.           CARDINAL32       Partition_Count,
  2249.           CARDINAL32 far   Partition_Handles[],
  2250.           CARDINAL32 far * Error_Code
  2251.   );
  2252.  
  2253.  
  2254. ΓòÉΓòÉΓòÉ 3.3.4.8. Assign_Drive_Letter ΓòÉΓòÉΓòÉ
  2255.  
  2256. void _System Assign_Drive_Letter(
  2257.  
  2258.         ADDRESS      Volume_Handle,
  2259.         char         New_Drive_Preference,
  2260.         CARDINAL32 * Error_Code
  2261.  
  2262. );
  2263.  
  2264. Description 
  2265.  
  2266. Assigns a drive letter to a volume. 
  2267.  
  2268. Input 
  2269.  
  2270.  ADDRESS Volume_Handle 
  2271.            The handle of the volume which is to have its assigned drive letter 
  2272.            changed. 
  2273.  
  2274.  char New_Drive_Preference 
  2275.            The new drive letter to assign to the volume. 
  2276.  
  2277.  CARDINAL32 * Error_Code 
  2278.            The address of a CARDINAL32 in which to store an error code should 
  2279.            an error occur. 
  2280.  
  2281.  Output 
  2282.  
  2283.  *Error_Code will be 0 if the drive letter was assigned successfully; otherwise 
  2284.  *Error_Code will be > 0. 
  2285.  
  2286.  Error Handling 
  2287.  
  2288.  If the drive letter assignment can not be made, the volume will not be 
  2289.  altered. 
  2290.  
  2291.  If Volume_Handle is not a valid handle, a trap may result. 
  2292.  
  2293.  If Volume_Handle is a partition or drive handle, then this function will abort 
  2294.  and set *Error_Code to a non-zero value. 
  2295.  
  2296.  Side Effects 
  2297.  
  2298.  A volume may have its drive letter assignment changed. 
  2299.  
  2300.  Notes 
  2301.  
  2302.  If the drive letter being assigned is already in use by volume which does not 
  2303.  lie on removable media, then the drive assignment will NOT be made. 
  2304.  
  2305.  16 Bit Versions: 
  2306.  
  2307.   void _Far16 _Pascal _loadds ASSIGN_DRIVE_LETTER16(
  2308.           CARDINAL32          Volume_Handle,
  2309.           char                New_Drive_Preference,
  2310.           CARDINAL32 * _Seg16 Error_Code
  2311.   );
  2312.  
  2313.   void far pascal _loadds ASSIGN_DRIVE_LETTER16(
  2314.           CARDINAL32       Volume_Handle,
  2315.           char             New_Drive_Preference,
  2316.           CARDINAL32 far * Error_Code
  2317.   );
  2318.  
  2319.  
  2320. ΓòÉΓòÉΓòÉ 3.3.4.9. Set_Installable ΓòÉΓòÉΓòÉ
  2321.  
  2322. void _System Set_Installable (
  2323.  
  2324.         ADDRESS      Volume_Handle,
  2325.         CARDINAL32 * Error_Code
  2326.  
  2327. );
  2328.  
  2329. Description 
  2330.  
  2331. Marks a volume as being the volume to install OS/2 on. 
  2332.  
  2333. Input 
  2334.  
  2335.  ADDRESS Volume_Handle 
  2336.            The handle of the volume to which OS/2 should be installed. 
  2337.  
  2338.  CARDINAL32 * Error_Code 
  2339.            The address of a CARDINAL32 in which to store an error code should 
  2340.            an error occur. 
  2341.  
  2342.  Output 
  2343.  
  2344.  If the volume is successfully marked as installable, *Error_Code will be 0; 
  2345.  otherwise *Error_Code will be > 0. 
  2346.  
  2347.  Error Handling 
  2348.  
  2349.  If Volume_Handle is not a valid handle, a trap may result. 
  2350.  
  2351.  If Volume_Handle is a partition or drive handle, then this function will abort 
  2352.  and set *Error_Code to a non-zero value. 
  2353.  
  2354.  Side Effects 
  2355.  
  2356.  The specified volume may be marked as installable. 
  2357.  
  2358.  Notes 
  2359.  
  2360.  None. 
  2361.  
  2362.  16 Bit Versions: 
  2363.  
  2364.   void _Far16 _Pascal _loadds SET_INSTALLABLE16(
  2365.           CARDINAL32          Volume_Handle,
  2366.           CARDINAL32 * _Seg16 Error_Code
  2367.   );
  2368.  
  2369.   void far pascal _loadds SET_INSTALLABLE16(
  2370.           CARDINAL32       Volume_Handle,
  2371.           CARDINAL32 far * Error_Code
  2372.   );
  2373.  
  2374.  
  2375. ΓòÉΓòÉΓòÉ 3.3.4.10. Get_Installable_Volume ΓòÉΓòÉΓòÉ
  2376.  
  2377. Volume_Information_Record _System Get_Installable_Volume ( CARDINAL32 * Error_Code );
  2378.  
  2379. Description 
  2380.  
  2381. Marks a volume as being the volume to install OS/2 on. 
  2382.  
  2383. Input 
  2384.  
  2385.  CARDINAL32 * Error_Code 
  2386.            The address of a CARDINAL32 in which to store an error code should 
  2387.            an error occur. 
  2388.  
  2389.  Output 
  2390.  
  2391.  If a volume is mared installable, its information will be returned and 
  2392.  *Error_Code will be LVM_ENGINE_NO_ERROR. If there is no volume marked 
  2393.  installable, then *Error_Code will be > 0. 
  2394.  
  2395.  Error Handling 
  2396.  
  2397.  An error code is returned if there is an error. 
  2398.  
  2399.  Side Effects 
  2400.  
  2401.  None. 
  2402.  
  2403.  Notes 
  2404.  
  2405.  None. 
  2406.  
  2407.  16 Bit Versions: 
  2408.  
  2409.   void _Far16 _Pascal _loadds GET_INSTALLABLE_VOLUME16(
  2410.           Volume_Information_Record * _Seg16  Volume_Information,
  2411.           CARDINAL32 *                _Seg16  Error_Code
  2412.   );
  2413.  
  2414.   void far pascal _loadds GET_INSTALLABLE_VOLUME16(
  2415.           Volume_Information_Record * Volume_Information,
  2416.           CARDINAL32 far *            Error_Code
  2417.   );
  2418.  
  2419.  
  2420. ΓòÉΓòÉΓòÉ 3.3.4.11. Convert_Volumes_To_V1 ΓòÉΓòÉΓòÉ
  2421.  
  2422. LVM Version 2 only 
  2423.  
  2424. CARDINAL32 _System Convert_Volumes_To_V1 (
  2425.  
  2426.     BOOLEAN *    Hidden_Volume_Conversion_Failure,
  2427.     CARDINAL32 * Error_Code
  2428.  
  2429. );
  2430.  
  2431. Description 
  2432.  
  2433. This function attempts to convert all LVM volumes in the system into a format 
  2434. that can be used by LVM Version 1, which was shipped with Warp Server for 
  2435. e-business.  This function returns a bitmap of the drive letters corresponding 
  2436. to Volumes that can not be converted. 
  2437.  
  2438. Input 
  2439.  
  2440.  BOOLEAN * Hidden_Volume_Conversion_Failure 
  2441.            The address of a BOOLEAN variable in which to store a flag 
  2442.            indicating if there were hidden volumes that could not be converted. 
  2443.            If *Hidden_Volume_Conversion_Failure is TRUE, then there were hidden 
  2444.            volumes that could not be converted.  If FALSE, then there were no 
  2445.            hidden volumes, or the hidden volumes that existed were converted 
  2446.            successfully. 
  2447.  
  2448.  CARDINAL32 * Error_Code 
  2449.            The address of a CARDINAL32 in which to store an error code should 
  2450.            an error occur. 
  2451.  
  2452.  Output 
  2453.  
  2454.  This function returns a bitmap of the drive letters corresponding to volumes 
  2455.  that could not be converted to LVM Version 1 format.  If this function is 
  2456.  successful and all volumes were converted, then *Error_Code will be set to 
  2457.  LVM_ENGINE_NO_ERROR and the bitmap returned will have no bits set.  If this 
  2458.  function failes, *Error_Code will contain a non-zero error code and the bitmap 
  2459.  returned by this function may be non-zero. 
  2460.  
  2461.  Error Handling 
  2462.  
  2463.  If an error occurs, *Error_Code will be > 0. 
  2464.  
  2465.  Side Effects 
  2466.  
  2467.  All LVM volumes that can be converted to LVM Version 1 format will be. 
  2468.  
  2469.  Notes 
  2470.  
  2471.  Bit 0 in the bitmap returned by this function represents drive letter 'A'. 
  2472.  
  2473.  
  2474. ΓòÉΓòÉΓòÉ 3.3.5. Functions relating to Partitions, Drives, and Volumes. ΓòÉΓòÉΓòÉ
  2475.  
  2476. Functions relating to partitions, drives, and volumes. 
  2477.  
  2478.  
  2479. ΓòÉΓòÉΓòÉ 3.3.5.1. Set_Name ΓòÉΓòÉΓòÉ
  2480.  
  2481. void _System Set_Name (
  2482.  
  2483.         ADDRESS      Handle,
  2484.         char         New_Name[],
  2485.         CARDINAL32 * Error_Code
  2486.  
  2487. );
  2488.  
  2489. Description 
  2490.  
  2491. Sets the name of a volume, drive, or partition 
  2492.  
  2493. Input 
  2494.  
  2495.  ADDRESS Handle 
  2496.            The handle of the drive, partition, or volume which is to have its 
  2497.            name set. 
  2498.  
  2499.  char New_Name[] 
  2500.            The new name for the drive/partition/volume. 
  2501.  
  2502.  CARDINAL32 * Error_Code 
  2503.            The address of a CARDINAL32 in which to store an error code should 
  2504.            an error occur. 
  2505.  
  2506.  Output 
  2507.  
  2508.  *Error_Code will be 0 if the name is set as specified. If the name can not be 
  2509.  set, *Error_Code will be > 0. 
  2510.  
  2511.  Error Handling 
  2512.  
  2513.  If the name can not be set, then drive/volume/partition is not modified. 
  2514.  
  2515.  If Handle is not a valid handle, a trap may result. 
  2516.  
  2517.  Side Effects 
  2518.  
  2519.  A drive/volume/partition may have its name set. 
  2520.  
  2521.  Notes 
  2522.  
  2523.  None. 
  2524.  
  2525.  16 Bit Versions: 
  2526.  
  2527.   void _Far16 _Pascal _loadds SET_NAME16(
  2528.           CARDINAL32          Handle,
  2529.           char       * _Seg16 New_Name,
  2530.           CARDINAL32 * _Seg16 Error_Code
  2531.   );
  2532.  
  2533.   void far pascal _loadds SET_NAME16(
  2534.           CARDINAL32       Handle,
  2535.           char  far        New_Name[ ],
  2536.           CARDINAL32 far * Error_Code
  2537.   );
  2538.  
  2539.  
  2540. ΓòÉΓòÉΓòÉ 3.3.5.2. Set_Startable ΓòÉΓòÉΓòÉ
  2541.  
  2542. void _System Set_Startable(
  2543.  
  2544.         ADDRESS      Handle,
  2545.         CARDINAL32 * Error_Code
  2546.  
  2547. );
  2548.  
  2549. Description 
  2550.  
  2551. Sets the specified volume or partition startable.  If a volume is specified, it 
  2552. must be a compatibility volume whose partition is a primary partition on the 
  2553. first drive.  If a partition is specified, it must be a primary partition on 
  2554. the first drive in the system. 
  2555.  
  2556. Input 
  2557.  
  2558.  ADDRESS Handle 
  2559.            The handle of the partition or volume which is to be set startable. 
  2560.  
  2561.  CARDINAL32 * Error_Code 
  2562.            The address of a CARDINAL32 in which to store an error code should 
  2563.            an error occur. 
  2564.  
  2565.  Output 
  2566.  
  2567.  *Error_Code will be 0 if the specified volume or partition was set startable. 
  2568.  If the name can not be set, *Error_Code will be > 0. 
  2569.  
  2570.  Error Handling 
  2571.  
  2572.  If the volume or partition could not be set startable, then nothing in the 
  2573.  system is changed. 
  2574.  
  2575.  If Handle is not a valid handle, a trap may result. 
  2576.  
  2577.  Side Effects 
  2578.  
  2579.  Any other partition or volume which is marked startable will have its 
  2580.  startable flag cleared. 
  2581.  
  2582.  Notes 
  2583.  
  2584.  None. 
  2585.  
  2586.  16 Bit Versions: 
  2587.  
  2588.   void  _Far16 _Pascal _loadds SET_STARTABLE16(
  2589.           CARDINAL32          Handle,
  2590.           CARDINAL32 * _Seg16 Error_Code
  2591.   );
  2592.  
  2593.   void far pascal _loadds SET_STARTABLE16(
  2594.           CARDINAL32       Handle,
  2595.           CARDINAL32 far * Error_Code
  2596.   );
  2597.  
  2598.  
  2599. ΓòÉΓòÉΓòÉ 3.3.5.3. Get_Valid_Options ΓòÉΓòÉΓòÉ
  2600.  
  2601. CARDINAL32 _System Get_Valid_Options(
  2602.  
  2603.         ADDRESS      Handle,
  2604.         CARDINAL32 * Error_Code
  2605.  
  2606. );
  2607.  
  2608. Description 
  2609.  
  2610. Returns a bitmap where each bit in the bitmap corresponds to a possible 
  2611. operation that the LVM Engine can perform.  Those bits which are 1 represent 
  2612. operations which can be performed on the item specified by Handle.  Those bits 
  2613. which are 0 are not allowed on the item specified by Handle. 
  2614.  
  2615. Input 
  2616.  
  2617.  ADDRESS Handle 
  2618.            This is any valid drive, volume, or partition handle. 
  2619.  
  2620.  CARDINAL32 * Error_Code 
  2621.            The address of a CARDINAL32 in which to store an error code should 
  2622.            an error occur. 
  2623.  
  2624.  Output 
  2625.  
  2626.  A bitmap indicating which operations are valid on the item specified by 
  2627.  Handle. 
  2628.  
  2629.  If no errors occur, *Error_Code will be 0, otherwise *Error_Code will be > 0. 
  2630.  
  2631.  Error Handling 
  2632.  
  2633.  If Handle is not valid, a trap will be likely. 
  2634.  
  2635.  Side Effects 
  2636.  
  2637.  None. 
  2638.  
  2639.  Notes 
  2640.  
  2641.  The values of the various bits in the bitmap returned by this function are 
  2642.  defined near the beginning of this file, immediately after all of the 
  2643.  structure definitions. 
  2644.  
  2645.  16 Bit Versions: 
  2646.  
  2647.   CARDINAL32 _Far16 _Pascal _loadds GET_VALID_OPTIONS16(
  2648.           CARDINAL32          Handle,
  2649.           CARDINAL32 * _Seg16 Error_Code
  2650.   );
  2651.  
  2652.   CARDINAL32 far pascal _loadds GET_VALID_OPTIONS16(
  2653.           CARDINAL32       Handle,
  2654.           CARDINAL32 far * Error_Code
  2655.   );
  2656.  
  2657.  
  2658. ΓòÉΓòÉΓòÉ 3.3.5.4. Get_Child_Handles ΓòÉΓòÉΓòÉ
  2659.  
  2660. LVM Version 2 only 
  2661.  
  2662. LVM_Handle_Array_Record  _System Get_Child_Handles(
  2663.  
  2664.         ADDRESS      Handle,
  2665.         CARDINAL32 * Error_Code
  2666.  
  2667. );
  2668.  
  2669. Description 
  2670.  
  2671. Given the handle of a volume or aggregate, this function will return the 
  2672. handles of the children of the volume or aggregate.  This allows the entire 
  2673. tree representation of a volume to be traversed, a level at a time. 
  2674.  
  2675. Input 
  2676.  
  2677.  ADDRESS Handle 
  2678.            The handle of the volume or aggregate whose children are required. 
  2679.  
  2680.  CARDINAL32 * Error_Code 
  2681.            The address of a CARDINAL32 in which to store an error code should 
  2682.            an error occur. 
  2683.  
  2684.  Output 
  2685.  
  2686.  If successful, an LVM_Handle_Array_Record is returned with a non-zero Count. 
  2687.  Also, *Error_Code will be set to LVM_ENGINE_NO_ERROR.  If an error occurs, 
  2688.  then the Count field will be 0 and *Error_Code will contain a non-zero error 
  2689.  code. 
  2690.  
  2691.  Error Handling 
  2692.  
  2693.  If Handle is not a valid handle, then a trap is likely.  If Handle is the 
  2694.  handle of partition, then *Error_Code will be set to LVM_ENGINE_NO_CHILDREN. 
  2695.  If Handle is not a volume or aggregate handle, then *Error_Code will be set to 
  2696.  LVM_ENGINE_BAD_HANDLE. 
  2697.  
  2698.  Side Effects 
  2699.  
  2700.  None. 
  2701.  
  2702.  Notes 
  2703.  
  2704.  None. 
  2705.  
  2706.  
  2707. ΓòÉΓòÉΓòÉ 3.3.5.5. Get_Parent_Handle ΓòÉΓòÉΓòÉ
  2708.  
  2709. LVM Version 2 only 
  2710.  
  2711. ADDRESS _System Get_Parent_Handle(
  2712.  
  2713.         ADDRESS      Handle,
  2714.         CARDINAL32 * Error_Code
  2715.  
  2716. );
  2717.  
  2718. Description 
  2719.  
  2720. Given the handle of a partition or aggregate, this function will return the 
  2721. handle of the parent of the partition or aggregate. 
  2722.  
  2723. Input 
  2724.  
  2725.  ADDRESS Handle 
  2726.            The handle of the partition or aggregate whose parent is required. 
  2727.  
  2728.  CARDINAL32 * Error_Code 
  2729.            The address of a CARDINAL32 in which to store an error code should 
  2730.            an error occur. 
  2731.  
  2732.  Output 
  2733.  
  2734.  If successful, the handle of the parent is returned as the function result and 
  2735.  *Error_Code will be set to LVM_ENGINE_NO_ERROR. If an error occurs, then NULL 
  2736.  will be the function result and *Error_Code will contain a non-zero error 
  2737.  code. 
  2738.  
  2739.  Error Handling 
  2740.  
  2741.  If Handle is not a valid handle, then a trap is likely.  If Handle is the 
  2742.  handle of volume, then *Error_Code will be set to LVM_ENGINE_NO_PARENT.  If 
  2743.  Handle is not the handle of a volume, partition, or aggregate then *Error_Code 
  2744.  will be set to LVM_ENGINE_BAD_HANDLE. 
  2745.  
  2746.  Side Effects 
  2747.  
  2748.  None. 
  2749.  
  2750.  Notes 
  2751.  
  2752.  None. 
  2753.  
  2754.  
  2755. ΓòÉΓòÉΓòÉ 3.3.5.6. Get_Features ΓòÉΓòÉΓòÉ
  2756.  
  2757. LVM Version 2 only 
  2758.  
  2759. Feature_Information_Array _System Get_Features(
  2760.  
  2761.         ADDRESS      Handle,
  2762.         CARDINAL32 * Error_Code
  2763.  
  2764. );
  2765.  
  2766. Description 
  2767.  
  2768. Returns the feature ID information for each of the features that are installed 
  2769. on the item specified by Handle. 
  2770.  
  2771. Input 
  2772.  
  2773.  ADDRESS Handle 
  2774.            The handle of the object to use. 
  2775.  
  2776.  CARDINAL32 * Error_Code 
  2777.            The address of a CARDINAL32 in which to store an error code should 
  2778.            an error occur. 
  2779.  
  2780.  Output 
  2781.  
  2782.  If successful, a Feature_Information_Array structure is returned with a 
  2783.  non-zero Count.  Also, *Error_Code will be set to LVM_ENGINE_NO_ERROR.  If an 
  2784.  error occurs, then the Count field in the structure will be 0 and 
  2785.  (*Error_Code) will contain a non-zero error code. 
  2786.  
  2787.  Error Handling 
  2788.  
  2789.  If Handle is not a valid handle, a trap will be likely. 
  2790.  
  2791.  Side Effects 
  2792.  
  2793.  Memory is allocated using the LVM Engine's memory manager for the array of 
  2794.  Feature_ID_Data items being returned. 
  2795.  
  2796.  Notes 
  2797.  
  2798.  None. 
  2799.  
  2800.  
  2801. ΓòÉΓòÉΓòÉ 3.3.6. Functions relating to Boot Manager ΓòÉΓòÉΓòÉ
  2802.  
  2803. Functions relating to Boot Manager. 
  2804.  
  2805.  
  2806. ΓòÉΓòÉΓòÉ 3.3.6.1. Boot_Manager_Is_Installed ΓòÉΓòÉΓòÉ
  2807.  
  2808. BOOLEAN _System Boot_Manager_Is_Installed(
  2809.  
  2810.         BOOLEAN *    Active,
  2811.         CARDINAL32 * Error_Code
  2812.  
  2813. );
  2814.  
  2815. Description 
  2816.  
  2817. Indicates whether or not Boot Manager is installed on the first or second hard 
  2818. drives in the system. 
  2819.  
  2820. Input 
  2821.  
  2822.  BOOLEAN * Active 
  2823.            *Active is set to TRUE if LVM found an active copy of Boot Manager 
  2824.            on the system.  If LVM could not find an active copy of Boot Manager 
  2825.            on the system, but did find an inactive copy of Boot Manager, then 
  2826.            *Active will be set to FALSE. 
  2827.  
  2828.  CARDINAL32 * Error_Code 
  2829.            The address of a CARDINAL32 in which to store an error code should 
  2830.            an error occur. 
  2831.  
  2832.  Output 
  2833.  
  2834.  TRUE is returned if Boot Manager is found.  If this copy of Boot Manager is 
  2835.  Active, then *Active will be set to TRUE.  If the copy of Boot Manager is not 
  2836.  currently active, then *Active will be set to FALSE. 
  2837.  
  2838.  FALSE is returned if Boot Manager is not found or if an error occurs.  In this 
  2839.  case, *Active is undefined. 
  2840.  
  2841.  *Error_Code will be 0 if no errors occur; otherwise it will be > 0. 
  2842.  
  2843.  Error Handling 
  2844.  
  2845.  If an error occurs, *Error_Code will be > 0. 
  2846.  
  2847.  Side Effects 
  2848.  
  2849.  None. 
  2850.  
  2851.  Notes 
  2852.  
  2853.  None. 
  2854.  
  2855.  16 Bit Versions: 
  2856.  
  2857.   BOOLEAN _Far16 _Pascal _loadds BOOT_MANAGER_IS_INSTALLED16(
  2858.           BOOLEAN * _Seg16    Active,
  2859.           CARDINAL32 * _Seg16 Error_Code
  2860.   );
  2861.  
  2862.   BOOLEAN far pascal _loadds BOOT_MANAGER_IS_INSTALLED16(
  2863.           BOOLEAN far *    Active,
  2864.           CARDINAL32 far * Error_Code
  2865.   );
  2866.  
  2867.  
  2868. ΓòÉΓòÉΓòÉ 3.3.6.2. Get_Boot_Manager_Handle ΓòÉΓòÉΓòÉ
  2869.  
  2870. ADDRESS _System Get_Boot_Manager_Handle( CARDINAL32 * Error_Code);
  2871.  
  2872. Description 
  2873.  
  2874. Returns the handle of the partition containing Boot Manager. 
  2875.  
  2876. Input 
  2877.  
  2878.  CARDINAL32 * Error_Code 
  2879.            The address of a CARDINAL32 in which to store an error code should 
  2880.            an error occur. 
  2881.  
  2882.  Output 
  2883.  
  2884.  If Boot Manager is NOT installed, NULL is returned. If Boot Manager is 
  2885.  installed, whether it is active or not, the handle of the partition it resides 
  2886.  in is returned. 
  2887.  
  2888.  Error Handling 
  2889.  
  2890.  If an error occurs, *Error_Code will be > 0. 
  2891.  
  2892.  Side Effects 
  2893.  
  2894.  None. 
  2895.  
  2896.  Notes 
  2897.  
  2898.  16 Bit Versions: 
  2899.  
  2900.   ADDRESS _Far16 _Pascal _loadds GET_BOOT_MANAGER_HANDLE16( CARDINAL32 * _Seg16 Error_Code);
  2901.  
  2902.   ADDRESS far _pascal _loadds GET_BOOT_MANAGER_HANDLE16( CARDINAL32 far * Error_Code);
  2903.  
  2904.  
  2905. ΓòÉΓòÉΓòÉ 3.3.6.3. Add_To_Boot_Manager ΓòÉΓòÉΓòÉ
  2906.  
  2907. void _System Add_To_Boot_Manager(
  2908.  
  2909.         ADDRESS Handle,
  2910.         CARDINAL32 * Error_Code
  2911.  
  2912. );
  2913.  
  2914. Description 
  2915.  
  2916. Adds the volume/partition to the Boot Manager menu. 
  2917.  
  2918. Input 
  2919.  
  2920.  ADDRESS Handle 
  2921.            The handle of a partition or volume that is to be added to the Boot 
  2922.            Manager menu. 
  2923.  
  2924.  CARDINAL32 * Error_Code 
  2925.            The address of a CARDINAL32 in which to store an error code should 
  2926.            an error occur. 
  2927.  
  2928.  Output 
  2929.  
  2930.  *Error_Code will be 0 if the partition or volume was successfully added to the 
  2931.  Boot Manager menu; otherwise *Error_Code will be > 0. 
  2932.  
  2933.  Error Handling 
  2934.  
  2935.  If the partition/volume can not be added to the Boot Manager menu, no action 
  2936.  is taken and *Error_Code will contain a non-zero error code. 
  2937.  
  2938.  If Handle is not a valid handle, a trap may result. 
  2939.  
  2940.  If Handle represents a drive, then this function will abort and set 
  2941.  *Error_Code to a non-zero value. 
  2942.  
  2943.  Side Effects 
  2944.  
  2945.  The Boot Manager menu may be altered. 
  2946.  
  2947.  Notes 
  2948.  
  2949.  None. 
  2950.  
  2951.  16 Bit Versions: 
  2952.  
  2953.   void _Far16 _Pascal _loadds ADD_TO_BOOT_MANAGER16(
  2954.           CARDINAL32          Handle,
  2955.           CARDINAL32 * _Seg16 Error_Code
  2956.   );
  2957.  
  2958.   void far pascal _loadds ADD_TO_BOOT_MANAGER16(
  2959.           CARDINAL32       Handle,
  2960.           CARDINAL32 far * Error_Code
  2961.   );
  2962.  
  2963.  
  2964. ΓòÉΓòÉΓòÉ 3.3.6.4. Remove_From_Boot_Manager ΓòÉΓòÉΓòÉ
  2965.  
  2966. void _System Remove_From_Boot_Manager(
  2967.  
  2968.         ADDRESS Handle,
  2969.         CARDINAL32 * Error_Code
  2970.  
  2971. );
  2972.  
  2973. Description 
  2974.  
  2975. Removes the specified partition or volume from the Boot Manager menu. 
  2976.  
  2977. Input 
  2978.  
  2979.  CARDINAL32 * Error_Code 
  2980.            The address of a CARDINAL32 in which to store an error code should 
  2981.            an error occur. 
  2982.  
  2983.  Output 
  2984.  
  2985.  *Error_Code will be 0 if the partition or volume was successfully removed to 
  2986.  the Boot Manager menu; otherwise *Error_Code will be > 0. 
  2987.  
  2988.  Error Handling 
  2989.  
  2990.  If Handle is not a valid handle, a trap may result. 
  2991.  
  2992.  If Handle represents a drive, or if Handle represents a volume or partition 
  2993.  which is NOT on the boot manager menu, then this function will abort and set 
  2994.  *Error_Code to a non-zero value. 
  2995.  
  2996.  Side Effects 
  2997.  
  2998.  The Boot Manager menu may be altered. 
  2999.  
  3000.  Notes 
  3001.  
  3002.  None. 
  3003.  
  3004.  16 Bit Versions: 
  3005.  
  3006.   void _Far16 _Pascal _loadds REMOVE_FROM_BOOT_MANAGER16(
  3007.           CARDINAL32          Handle,
  3008.           CARDINAL32 * _Seg16 Error_Code
  3009.   );
  3010.  
  3011.   void far pascal _loadds REMOVE_FROM_BOOT_MANAGER16(
  3012.           CARDINAL32       Handle,
  3013.           CARDINAL32 far * Error_Code
  3014.   );
  3015.  
  3016.  
  3017. ΓòÉΓòÉΓòÉ 3.3.6.5. Get_Boot_Manager_Menu ΓòÉΓòÉΓòÉ
  3018.  
  3019. Boot_Manager_Menu  _System Get_Boot_Manager_Menu( CARDINAL32 * Error_Code );
  3020.  
  3021. Description 
  3022.  
  3023. Returns an array containing the handles of the partitions and volumes appearing 
  3024. on the Boot Manager menu. 
  3025.  
  3026. Input 
  3027.  
  3028.  CARDINAL32 * Error_Code 
  3029.            The address of a CARDINAL32 in which to store an error code should 
  3030.            an error occur. 
  3031.  
  3032.  Output 
  3033.  
  3034.  The function returns a Boot_Manager_Menu structure. This structure contains 
  3035.  two items: a pointer to an array of Boot_Manager_Menu_Items and a count of how 
  3036.  many items are in the array.  Each Boot_Manager_Menu_Item contains a handle 
  3037.  and a BOOLEAN variable to indicate whether the handle is for a partition or a 
  3038.  volume. 
  3039.  
  3040.  If this function is successful, then *Error_Code will be 0. 
  3041.  
  3042.  If an error occurs, the Count field in the Boot_Manager_Menu will be 0 and the 
  3043.  corresponding pointer will be NULL.  *Error_Code will be > 0. 
  3044.  
  3045.  Error Handling 
  3046.  
  3047.  If an error occurs, *Error_Code will be > 0. any memory allocated by this 
  3048.  function will be freed. 
  3049.  
  3050.  Side Effects 
  3051.  
  3052.  None. 
  3053.  
  3054.  Notes 
  3055.  
  3056.  None. 
  3057.  
  3058.  16 Bit Versions: 
  3059.  
  3060.   void _Far16 _Pascal _loadds GET_BOOT_MANAGER_MENU16(
  3061.           Boot_Manager_Menu_Item * _Seg16 * _Seg16 Menu_Items,
  3062.           CARDINAL32 *                      _Seg16 Count,
  3063.           CARDINAL32 *                      _Seg16 Error_Code
  3064.   );
  3065.  
  3066.   void far pascal _loadds GET_BOOT_MANAGER_MENU16(
  3067.           Boot_Manager_Menu_Item ** Menu_Items,
  3068.           CARDINAL32 *              Count,
  3069.           CARDINAL32 *              Error_Code
  3070.   );
  3071.  
  3072.  
  3073. ΓòÉΓòÉΓòÉ 3.3.6.6. Install_Boot_Manager ΓòÉΓòÉΓòÉ
  3074.  
  3075. void _System Install_Boot_Manager (
  3076.  
  3077.         CARDINAL32   Drive_Number,  /* Only drives 0 and 1 are acceptable. */
  3078.         CARDINAL32 * Error_Code
  3079.  
  3080. );
  3081.  
  3082. Description 
  3083.  
  3084. This function installs Boot Manager.  It can be used to replace an existing 
  3085. Boot Manager as well. 
  3086.  
  3087. Input 
  3088.  
  3089.  CARDINAL32  Drive_Number 
  3090.            The number of the drive to install Boot Manager on.  Must be 1 or 2. 
  3091.  
  3092.  CARDINAL32 * Error_Code 
  3093.            The address of a CARDINAL32 in which to store an error code should 
  3094.            an error occur. 
  3095.  
  3096.  Output 
  3097.  
  3098.  If this function is successful, then *Error_Code will be 0; otherwise it will 
  3099.  be > 0. 
  3100.  
  3101.  Error Handling 
  3102.  
  3103.  If an error occurs, *Error_Code will be set to a non-zero value.  Depending 
  3104.  upon the error, it is possible that the Boot Manager partition can be left in 
  3105.  an unusuable state (such as for a write error). 
  3106.  
  3107.  Side Effects 
  3108.  
  3109.  Boot Manager may be installed on drive 1 or 2. The MBR for drive 1 may be 
  3110.  altered. 
  3111.  
  3112.  Notes 
  3113.  
  3114.  None. 
  3115.  
  3116.  16 Bit Versions: 
  3117.  
  3118.   void _Far16 _Pascal _loadds INSTALL_BOOT_MANAGER16(
  3119.           CARDINAL32          Drive_Number,
  3120.           CARDINAL32 * _Seg16 Error_Code
  3121.   );
  3122.  
  3123.   void far pascal _loadds INSTALL_BOOT_MANAGER16(
  3124.           CARDINAL32       Drive_Number,
  3125.           CARDINAL32 far * Error_Code
  3126.   );
  3127.  
  3128.  
  3129. ΓòÉΓòÉΓòÉ 3.3.6.7. Remove_Boot_Manager ΓòÉΓòÉΓòÉ
  3130.  
  3131. void _System Remove_Boot_Manager( CARDINAL32 * Error_Code );
  3132.  
  3133. Description 
  3134.  
  3135. Removes Boot Manager from the system. 
  3136.  
  3137. Input 
  3138.  
  3139.  CARDINAL32 * Error_Code 
  3140.            The address of a CARDINAL32 in which to store an error code should 
  3141.            an error occur. 
  3142.  
  3143.  Output 
  3144.  
  3145.  *Error_Code will be 0 if Boot Manager was successfully removed from the 
  3146.  system; otherwise *Error_Code will be 0. 
  3147.  
  3148.  Error Handling 
  3149.  
  3150.  If an error occurs, *Error_Code will be > 0. 
  3151.  
  3152.  Side Effects 
  3153.  
  3154.  Boot Manager will be removed from the system. 
  3155.  
  3156.  Notes 
  3157.  
  3158.  None. 
  3159.  
  3160.  16 Bit Versions: 
  3161.  
  3162.   void _Far16 _Pascal _loadds REMOVE_BOOT_MANAGER16( CARDINAL32 * _Seg16 Error_Code );
  3163.  
  3164.   void far pascal _loadds REMOVE_BOOT_MANAGER16( CARDINAL32 far * Error_Code );
  3165.  
  3166.  
  3167. ΓòÉΓòÉΓòÉ 3.3.6.8. Set_Boot_Manager_Options ΓòÉΓòÉΓòÉ
  3168.  
  3169. void _System Set_Boot_Manager_Options(
  3170.  
  3171.         ADDRESS      Handle,
  3172.         BOOLEAN      Timer_Active,
  3173.         CARDINAL32   Time_Out_Value,
  3174.         BOOLEAN      Advanced_Mode,
  3175.         CARDINAL32 * Error_Code
  3176.  
  3177. );
  3178.  
  3179. Description 
  3180.  
  3181. Sets the Boot Managers Options.  The options that can be set are: whether or 
  3182. not the time- out timer is active, how long the timer-out is, the partition to 
  3183. boot by default, and whether or not Boot Manager should display its menu using 
  3184. default mode or advanced mode. 
  3185.  
  3186. Input 
  3187.  
  3188.  ADDRESS Handle 
  3189.            The handle of the partition or volume to boot if the time-out timer 
  3190.            is active and the time-out value is reached. 
  3191.  
  3192.  BOOLEAN Timer_Active 
  3193.            If TRUE, then the time-out timer is active. 
  3194.  
  3195.  CARDINAL32 Time_Out_Value 
  3196.            If the time-out timer is active, this is the time-out value, in 
  3197.            seconds. 
  3198.  
  3199.  BOOLEAN Advanced_Mode 
  3200.            If TRUE, then Boot Manager will operate in advanced mode.  If FALSE, 
  3201.            then normal mode will be in effect. 
  3202.  
  3203.  CARDINAL32 * Error_Code 
  3204.            The address of a CARDINAL32 in which to store an error code should 
  3205.            an error occur. 
  3206.  
  3207.  Output 
  3208.  
  3209.  *Error_Code will be 0 if no errors occur.  If an error does occur, then 
  3210.  *Error_Code will be > 0. 
  3211.  
  3212.  Error Handling 
  3213.  
  3214.  If an error occurs, no changes will be made to Boot Manager and *Error_Code 
  3215.  will be set a non-zero error code. 
  3216.  
  3217.  Side Effects 
  3218.  
  3219.  Boot Manager may be modified. 
  3220.  
  3221.  Notes 
  3222.  
  3223.  None. 
  3224.  
  3225.  16 Bit Versions: 
  3226.  
  3227.   void _Far16 _Pascal _loadds SET_BOOT_MANAGER_OPTIONS16(
  3228.           CARDINAL32          Handle,
  3229.           BOOLEAN             Timer_Active,
  3230.           CARDINAL32          Time_Out_Value,
  3231.           BOOLEAN             Advanced_Mode,
  3232.           CARDINAL32 * _Seg16 Error_Code
  3233.   );
  3234.  
  3235.   void far pascal _loadds SET_BOOT_MANAGER_OPTIONS16(
  3236.           CARDINAL32       Handle,
  3237.           BOOLEAN          Timer_Active,
  3238.           CARDINAL32       Time_Out_Value,
  3239.           BOOLEAN          Advanced_Mode,
  3240.           CARDINAL32 far * Error_Code
  3241.   );
  3242.  
  3243.  
  3244. ΓòÉΓòÉΓòÉ 3.3.6.9. Get_Boot_Manager_Options ΓòÉΓòÉΓòÉ
  3245.  
  3246. void _System Get_Boot_Manager_Options(
  3247.  
  3248.         ADDRESS    * Handle,
  3249.         BOOLEAN    * Handle_Is_Volume,
  3250.         BOOLEAN    * Timer_Active,
  3251.         CARDINAL32 * Time_Out_Value,
  3252.         BOOLEAN    * Advanced_Mode,
  3253.         CARDINAL32 * Error_Code
  3254.  
  3255. );
  3256.  
  3257. Description 
  3258.  
  3259. This function returns the current Boot Manager settings for the various Boot 
  3260. Manager options. 
  3261.  
  3262. Input 
  3263.  
  3264.  ADDRESS * Handle 
  3265.            The handle for the default boot volume or partition. 
  3266.  
  3267.  BOOLEAN * Handle_Is_Volume 
  3268.            If TRUE, then Handle represents a volume.  If FALSE, then Handle 
  3269.            represents a partition. 
  3270.  
  3271.  BOOLEAN * Timer_Active 
  3272.            If TRUE, then the time-out timer is active.  If FALSE, then the 
  3273.            time-out timer is not active. 
  3274.  
  3275.  CARDINAL32 * Time_Out_Value 
  3276.            If the time-out timer is active, then this is the number of seconds 
  3277.            that Boot Manager will wait for user input before booting the 
  3278.            default volume/partition. 
  3279.  
  3280.  BOOLEAN * Advanced_Mode 
  3281.            If TRUE, the Boot Manager is operating in advanced mode.  If FALSE, 
  3282.            then Boot Manager is operating in normal mode. 
  3283.  
  3284.  CARDINAL32 * Error_Code 
  3285.            The address of a CARDINAL32 in which to store an error code should 
  3286.            an error occur. 
  3287.  
  3288.  Output 
  3289.  
  3290.  *Handle, *Handle_Is_Volume, *Timer_Active, *Time_out_value, *Advanced_Mode, 
  3291.  and *Error_Code are all set by this function.  If there are no errors, then 
  3292.  *Error_Code will be set to 0.  If any errors occur, then *Error_Code will be > 
  3293.  0. 
  3294.  
  3295.  Error Handling 
  3296.  
  3297.  If any of the parameters are invalid, then a trap is likely.  If Boot Manager 
  3298.  is not installed, then *Error_Code will be > 0. 
  3299.  
  3300.  Side Effects 
  3301.  
  3302.  None. 
  3303.  
  3304.  Notes 
  3305.  
  3306.  None. 
  3307.  
  3308.  16 Bit Versions: 
  3309.  
  3310.   void _Far16 _Pascal _loadds GET_BOOT_MANAGER_OPTIONS16(
  3311.           CARDINAL32 * _Seg16 Handle,
  3312.           BOOLEAN    * _Seg16 Handle_Is_Volume,
  3313.           BOOLEAN    * _Seg16 Timer_Active,
  3314.           CARDINAL32 * _Seg16 Time_Out_Value,
  3315.           BOOLEAN    * _Seg16 Advanced_Mode,
  3316.           CARDINAL32 * _Seg16 Error_Code
  3317.   );
  3318.  
  3319.   void far pascal _loadds GET_BOOT_MANAGER_OPTIONS16(
  3320.           CARDINAL32 far * Handle,
  3321.           BOOLEAN    far * Handle_Is_Volume,
  3322.           BOOLEAN    far * Timer_Active,
  3323.           CARDINAL32 far * Time_Out_Value,
  3324.           BOOLEAN    far * Advanced_Mode,
  3325.           CARDINAL32 far * Error_Code
  3326.   );
  3327.  
  3328.  
  3329. ΓòÉΓòÉΓòÉ 3.3.7. Other Functions ΓòÉΓòÉΓòÉ
  3330.  
  3331. Other functions. 
  3332.  
  3333.  
  3334. ΓòÉΓòÉΓòÉ 3.3.7.1. Allocate_Engine_Memory ΓòÉΓòÉΓòÉ
  3335.  
  3336. LVM Version 2 only 
  3337.  
  3338. ADDRESS _System Allocate_Engine_Memory( CARDINAL32 Size );
  3339.  
  3340. Description 
  3341.  
  3342. Allocates a block of memory using LVM.DLL's memory management functions. 
  3343.  
  3344. Input 
  3345.  
  3346.  CARDINAL32 Size 
  3347.            The number of bytes of memory to allocate. 
  3348.  
  3349.  Output 
  3350.  
  3351.  The address of the block of memory which was allocated, or NULL if the 
  3352.  requested amount of memory could not be allocated. 
  3353.  
  3354.  Error Handling 
  3355.  
  3356.  None. 
  3357.  
  3358.  Side Effects 
  3359.  
  3360.  The specified number of bytes is allocated from the memory manager imbedded in 
  3361.  LVM.DLL.  Memory allocated by this function must be freed using 
  3362.  Free_Engine_Memory function.  The use of any memory manager to free the memory 
  3363.  could result in Bad Things Happening! 
  3364.  
  3365.  Notes 
  3366.  
  3367.  None. 
  3368.  
  3369.  
  3370. ΓòÉΓòÉΓòÉ 3.3.7.2. Free_Engine_Memory ΓòÉΓòÉΓòÉ
  3371.  
  3372. void _System Free_Engine_Memory( ADDRESS Object );
  3373.  
  3374. Description 
  3375.  
  3376. Frees a memory object created by LVM.DLL and returned to a user of LVM.DLL. 
  3377.  
  3378. Input 
  3379.  
  3380.  ADDRESS Object 
  3381.            The address of the memory object to free.  This could be the 
  3382.            Drive_Control_Data field of a Drive_Control_Record, the 
  3383.            Partition_Array field of a Partition_Information_Array structure, or 
  3384.            any other dynamically allocated memory object created by LVM.DLL and 
  3385.            returned by a function in LVM.DLL. 
  3386.  
  3387.  Output 
  3388.  
  3389.  None. 
  3390.  
  3391.  Error Handling 
  3392.  
  3393.  None. 
  3394.  
  3395.  Side Effects 
  3396.  
  3397.  None. 
  3398.  
  3399.  Notes 
  3400.  
  3401.  A trap or exception could occur if a bad address is passed into this function. 
  3402.  
  3403.  16 Bit Versions: 
  3404.  
  3405.   void _Far16 _Pascal _loadds FREE_ENGINE_MEMORY16( ADDRESS _Seg16 Object );
  3406.  
  3407.   void far pascal _loadds FREE_ENGINE_MEMORY16( CARDINAL32 Object );
  3408.  
  3409.  
  3410. ΓòÉΓòÉΓòÉ 3.3.7.3. New_MBR ΓòÉΓòÉΓòÉ
  3411.  
  3412. void _System New_MBR(
  3413.  
  3414.     ADDRESS      Drive_Handle,
  3415.     CARDINAL32 * Error_Code
  3416.  
  3417. );
  3418.  
  3419. Description 
  3420.  
  3421. This function lays down a new MBR on the specified drive. 
  3422.  
  3423. Input 
  3424.  
  3425.  ADDRESS Drive_Handle 
  3426.            The handle of the drive on which the new MBR is to be placed. 
  3427.  
  3428.  CARDINAL32 * Error_Code 
  3429.            The address of a CARDINAL32 in which to store an error code should 
  3430.            an error occur. 
  3431.  
  3432.  Output 
  3433.  
  3434.  *Error_Code will be 0 if the new MBR was successfully placed on the specified 
  3435.  drive.  If the operation failed for any reason, then *Error_Code will contain 
  3436.  a non-zero error code. 
  3437.  
  3438.  Error Handling 
  3439.  
  3440.  If an error occurs, then the existing MBR is not altered and *Error_Code will 
  3441.  be > 0. 
  3442.  
  3443.  Side Effects 
  3444.  
  3445.  A new MBR may be placed on the specified drive. 
  3446.  
  3447.  Notes 
  3448.  
  3449.  None. 
  3450.  
  3451.  16 Bit Versions: 
  3452.  
  3453.   void _Far16 _Pascal _loadds NEW_MBR16(
  3454.           CARDINAL32          Drive_Handle,
  3455.           CARDINAL32 * _Seg16 Error_Code
  3456.   );
  3457.  
  3458.   void far pascal _loadds NEW_MBR16(
  3459.           CARDINAL32       Drive_Handle,
  3460.           CARDINAL32 far * Error_Code
  3461.   );
  3462.  
  3463.  
  3464. ΓòÉΓòÉΓòÉ 3.3.7.4. Get_Available_Drive_Letters ΓòÉΓòÉΓòÉ
  3465.  
  3466. CARDINAL32 _System Get_Available_Drive_Letters ( CARDINAL32 * Error_Code );
  3467.  
  3468. Description 
  3469.  
  3470. This function returns a bitmap indicating which drive letters are available for 
  3471. use. 
  3472.  
  3473. Drive letter A is represented by the right-most bit. 
  3474.  
  3475. Input 
  3476.  
  3477.  CARDINAL32 * Error_Code 
  3478.            The address of a CARDINAL32 in which to store an error code should 
  3479.            an error occur. 
  3480.  
  3481.  Output 
  3482.  
  3483.  This function returns a bitmap of the available drive letters.  If this 
  3484.  function is successful, then *Error_Code will be set to 0.  Otherwise, 
  3485.  *Error_Code will be > 0 and the bitmap returned will have all bits set to 0. 
  3486.  
  3487.  Error Handling 
  3488.  
  3489.  If an error occurs, *Error_Code will be > 0. 
  3490.  
  3491.  Side Effects 
  3492.  
  3493.  None. 
  3494.  
  3495.  Notes 
  3496.  
  3497.  A drive letter is available if it is not associated with a volume located on a 
  3498.  disk drive controlled by OS2DASD. 
  3499.  
  3500.  16 Bit Versions: 
  3501.  
  3502.   CARDINAL32 _Far16 _Pascal _loadds GET_AVAILABLE_DRIVE_LETTERS16( CARDINAL32 * _Seg16 Error_Code );
  3503.  
  3504.   CARDINAL32 far pascal _loadds GET_AVAILABLE_DRIVE_LETTERS16( CARDINAL32 far * Error_Code ) ;
  3505.  
  3506.  
  3507. ΓòÉΓòÉΓòÉ 3.3.7.5. Get_Reserved_Drive_Letters ΓòÉΓòÉΓòÉ
  3508.  
  3509. CARDINAL32 _System Get_Reserved_Drive_Letters ( CARDINAL32 * Error_Code );
  3510.  
  3511. Description 
  3512.  
  3513. This function returns a bitmap indicating which drive letters are reserved for 
  3514. use by devices NOT under the control of LVM. 
  3515.  
  3516. Drive letter A is represented by the right-most bit. 
  3517.  
  3518. Input 
  3519.  
  3520.  CARDINAL32 * Error_Code 
  3521.            The address of a CARDINAL32 in which to store an error code should 
  3522.            an error occur. 
  3523.  
  3524.  Output 
  3525.  
  3526.  This function returns a bitmap of the drive letters which are being used by 
  3527.  devices which are NOT controlled by LVM.  While a Volume CAN be assigned a 
  3528.  drive letter from this list, a reboot will almost always be required in order 
  3529.  for the assignment to take place. 
  3530.  
  3531.  If this function is successful, then *Error_Code will be set to 0.  Otherwise, 
  3532.  *Error_Code will be > 0 and the bitmap returned will have all bits set to 0. 
  3533.  
  3534.  Error Handling 
  3535.  
  3536.  If an error occurs, *Error_Code will be > 0. 
  3537.  
  3538.  Side Effects 
  3539.  
  3540.  None. 
  3541.  
  3542.  Notes 
  3543.  
  3544.  Devices which are assigned drive letters but which are NOT under LVM control 
  3545.  include:  CD-ROM, Network drives, parallel port attached devices, and any DASD 
  3546.  devices not controlled by OS2DASD. 
  3547.  
  3548.  16 Bit Versions: 
  3549.  
  3550.   CARDINAL32 _Far16 _Pascal _loadds GET_RESERVED_DRIVE_LETTERS16( CARDINAL32 * _Seg16 Error_Code );
  3551.  
  3552.   CARDINAL32 far pascal _loadds GET_RESERVED_DRIVE_LETTERS16( CARDINAL32 far * Error_Code ) ;
  3553.  
  3554.  
  3555. ΓòÉΓòÉΓòÉ 3.3.7.6. Reboot_Required ΓòÉΓòÉΓòÉ
  3556.  
  3557. BOOLEAN _System Reboot_Required ( void );
  3558.  
  3559. Description 
  3560.  
  3561. This function indicates whether or not any changes were made to the 
  3562. partitioning of the disks in the system which would require a reboot to make 
  3563. functional. 
  3564.  
  3565. Input 
  3566.  
  3567. None. 
  3568.  
  3569. Output 
  3570.  
  3571. The function return value will be TRUE if the system must be rebooted as a 
  3572. result of disk partitioning changes. 
  3573.  
  3574. Error Handling 
  3575.  
  3576. None required. 
  3577.  
  3578. Side Effects 
  3579.  
  3580. None. 
  3581.  
  3582. Notes 
  3583.  
  3584. None. 
  3585.  
  3586. 16 Bit Versions: 
  3587.  
  3588. BOOLEAN _Far16 _Pascal _loadds REBOOT_REQUIRED16( void );
  3589.  
  3590. BOOLEAN far pascal _loadds REBOOT_REQUIRED16( void );
  3591.  
  3592.  
  3593. ΓòÉΓòÉΓòÉ 3.3.7.7. Changes_Pending ΓòÉΓòÉΓòÉ
  3594.  
  3595. BOOLEAN _System Changes_Pending ( void );
  3596.  
  3597. Description 
  3598.  
  3599. This function indicates whether or not any changes were made to the 
  3600. partitioning of the disks in the system which have not yet been comitted to 
  3601. disk. 
  3602.  
  3603. Input 
  3604.  
  3605. None. 
  3606.  
  3607. Output 
  3608.  
  3609. The function return value will be TRUE if there are uncomitted changes to the 
  3610. partitioning of one or more of the drives in the system. 
  3611.  
  3612. Error Handling 
  3613.  
  3614. None required. 
  3615.  
  3616. Side Effects 
  3617.  
  3618. None. 
  3619.  
  3620. Notes 
  3621.  
  3622. None. 
  3623.  
  3624. 16 Bit Versions: 
  3625.  
  3626. BOOLEAN _Far16 _Pascal _loadds CHANGES_PENDING16( void );
  3627.  
  3628. BOOLEAN far pascal _loadds CHANGES_PENDING16( void );
  3629.  
  3630.  
  3631. ΓòÉΓòÉΓòÉ 3.3.7.8. Set_Reboot_Flag ΓòÉΓòÉΓòÉ
  3632.  
  3633. void _System Set_Reboot_Flag(
  3634.  
  3635.     BOOLEAN      Reboot,
  3636.     CARDINAL32 * Error_Code
  3637.  
  3638. );
  3639.  
  3640. Description 
  3641.  
  3642. This function sets the Reboot Flag.  The Reboot Flag is a special flag on the 
  3643. boot disk used by the install program to keep track of whether or not the 
  3644. system was just rebooted.  It is used by the various phases of install. 
  3645.  
  3646. Input 
  3647.  
  3648.  BOOLEAN Reboot 
  3649.            The new value for the Reboot Flag.  If TRUE, then the reboot flag 
  3650.            will be set. If FALSE, then the reboot flag will be cleared. 
  3651.  
  3652.  CARDINAL32 * Error_Code 
  3653.            The address of a CARDINAL32 in which to store an error code should 
  3654.            an error occur. 
  3655.  
  3656.  Output 
  3657.  
  3658.  *Error_Code will be set to 0 if there are no errors. *Error_Code will be > 0 
  3659.  if an error occurs. 
  3660.  
  3661.  Error Handling 
  3662.  
  3663.  If an error occurs, then the value of the Reboot Flag will be unchanged. 
  3664.  
  3665.  Side Effects 
  3666.  
  3667.  The value of the Reboot Flag may be changed. 
  3668.  
  3669.  Notes 
  3670.  
  3671.  None. 
  3672.  
  3673.  16 Bit Versions: 
  3674.  
  3675.   void _Far16 _Pascal _loadds SET_REBOOT_FLAG16(
  3676.           BOOLEAN             Reboot,
  3677.           CARDINAL32 * _Seg16 Error_Code
  3678.   );
  3679.  
  3680.   void far pascal _loadds SET_REBOOT_FLAG16(
  3681.           BOOLEAN          Reboot,
  3682.           CARDINAL32 far * Error_Code
  3683.   );
  3684.  
  3685.  
  3686. ΓòÉΓòÉΓòÉ 3.3.7.9. Get_Reboot_Flag ΓòÉΓòÉΓòÉ
  3687.  
  3688. BOOLEAN _System Get_Reboot_Flag( CARDINAL32 * Error_Code );
  3689.  
  3690. Description 
  3691.  
  3692. This function returns the value of the Reboot Flag.  The Reboot Flag is a 
  3693. special flag on the boot disk used by the install program to keep track of 
  3694. whether or not the system was just rebooted.  It is used by the various phases 
  3695. of install. 
  3696.  
  3697. Input 
  3698.  
  3699.  CARDINAL32 * Error_Code 
  3700.            The address of a CARDINAL32 in which to store an error code should 
  3701.            an error occur. 
  3702.  
  3703.  Output 
  3704.  
  3705.  The function return value will be TRUE if no errors occur and the Reboot Flag 
  3706.  is set.  *Error_Code will be 0 under these conditions.  If an error occurs, 
  3707.  the function return value will be FALSE and *Error_Code will be > 0. 
  3708.  
  3709.  Error Handling 
  3710.  
  3711.  If an error occurs, *Error_Code will be > 0. The value of the reboot flag will 
  3712.  be unchanged. 
  3713.  
  3714.  Side Effects 
  3715.  
  3716.  None. 
  3717.  
  3718.  Notes 
  3719.  
  3720.  None. 
  3721.  
  3722.  16 Bit Versions: 
  3723.  
  3724.   BOOLEAN _Far16 _Pascal _loadds GET_REBOOT_FLAG16( CARDINAL32 * _Seg16 Error_Code );
  3725.  
  3726.   BOOLEAN far pascal _loadds GET_REBOOT_FLAG16( CARDINAL32 far * Error_Code );
  3727.  
  3728.  
  3729. ΓòÉΓòÉΓòÉ 3.3.7.10. Set_Install_Flags ΓòÉΓòÉΓòÉ
  3730.  
  3731. void _System Set_Install_Flags(
  3732.  
  3733.     CARDINAL32   Install_Flags,
  3734.     CARDINAL32 * Error_Code
  3735.  
  3736. );
  3737.  
  3738. Description 
  3739.  
  3740. This function sets the value of the Install Flags.  The Install Flags reside in 
  3741. a 32 bit field in the LVM dataspace.  These flags are not used by LVM, thereby 
  3742. leaving Install free to use them for whatever it wants. 
  3743.  
  3744. Input 
  3745.  
  3746.  CARDINAL32 Install_Flags 
  3747.            The new value for the Install Flags. 
  3748.  
  3749.  CARDINAL32 * Error_Code 
  3750.            The address of a CARDINAL32 in which to store an error code should 
  3751.            an error occur. 
  3752.  
  3753.  Output 
  3754.  
  3755.  *Error_Code will be set to 0 if there are no errors. *Error_Code will be > 0 
  3756.  if an error occurs. 
  3757.  
  3758.  Error Handling 
  3759.  
  3760.  If an error occurs, then the value of the Install Flags will be unchanged. 
  3761.  
  3762.  Side Effects 
  3763.  
  3764.  The value of the Install Flags may be changed. 
  3765.  
  3766.  Notes 
  3767.  
  3768.  None. 
  3769.  
  3770.  16 Bit Versions: 
  3771.  
  3772.   void _Far16 _Pascal _loadds Set_Install_Flags16(
  3773.           CARDINAL32          Install_Flags,
  3774.           CARDINAL32 * _Seg16 Error_Code
  3775.   );
  3776.  
  3777.   void far pascal _loadds SET_INSTALL_FLAGS16(
  3778.           CARDINAL32       Install_Flags,
  3779.           CARDINAL32 far * Error_Code
  3780.   );
  3781.  
  3782.  
  3783. ΓòÉΓòÉΓòÉ 3.3.7.11. Get_Install_Flags ΓòÉΓòÉΓòÉ
  3784.  
  3785. CARDINAL32 _System Get_Install_Flags( CARDINAL32 * Error_Code );
  3786.  
  3787. Description 
  3788.  
  3789. This function returns the value of the Install Flags.  The Install Flags reside 
  3790. in a 32 bit field in the LVM dataspace.  These flags are not used by LVM, 
  3791. thereby leaving Install free to use them for whatever it wants. 
  3792.  
  3793. Input 
  3794.  
  3795.  CARDINAL32 * Error_Code 
  3796.            The address of a CARDINAL32 in which to store an error code should 
  3797.            an error occur. 
  3798.  
  3799.  Output 
  3800.  
  3801.  The function returns the current value of the Install Flags stored in the LVM 
  3802.  Dataspace. *Error_Code will be LVM_ENGINE_NO_ERROR if the function is 
  3803.  successful.  If an error occurs, the function will return 0 and *Error_Code 
  3804.  will be > 0. 
  3805.  
  3806.  Error Handling 
  3807.  
  3808.  If an error occurs, *Error_Code will be > 0. 
  3809.  
  3810.  Side Effects 
  3811.  
  3812.  None. 
  3813.  
  3814.  Notes 
  3815.  
  3816.  None. 
  3817.  
  3818.  16 Bit Versions: 
  3819.  
  3820.   void _Far16 _Pascal _loadds Get_Install_Flags16(
  3821.           CARDINAL32 * _Seg16 Install_Flags,
  3822.           CARDINAL32 * _Seg16 Error_Code
  3823.   );
  3824.  
  3825.   void far pascal _loadds GET_INSTALL_FLAGS16(
  3826.           CARDINAL32 far * Install_Flags,
  3827.           CARDINAL32 far * Error_Code
  3828.   );
  3829.  
  3830.  
  3831. ΓòÉΓòÉΓòÉ 3.3.7.12. Set_Min_Install_Size ΓòÉΓòÉΓòÉ
  3832.  
  3833. void _System Set_Min_Install_Size ( CARDINAL32  Min_Sectors );
  3834.  
  3835. Description 
  3836.  
  3837. This function tells the LVM Engine how big a partition/volume must be in order 
  3838. for it to marked installable.  If this function is not used to set the minimum 
  3839. size for an installable partition/volume, the LVM Engine will use a default 
  3840. value of 300 MB. 
  3841.  
  3842. Input 
  3843.  
  3844.  CARDINAL32 Min_Sectors 
  3845.            The minimum size, in sectors, that a partition must be in order for 
  3846.            it to be marked as installable. 
  3847.  
  3848.  Output 
  3849.  
  3850.  None. 
  3851.  
  3852.  Error Handling 
  3853.  
  3854.  None required. 
  3855.  
  3856.  Side Effects 
  3857.  
  3858.  None. 
  3859.  
  3860.  Notes 
  3861.  
  3862.  None. 
  3863.  
  3864.  16 Bit Versions: 
  3865.  
  3866.   void _Far16 _Pascal _loadds SET_MIN_INSTALL_SIZE16( CARDINAL32 Min_Sectors );
  3867.  
  3868.   void far pascal _loadds SET_MIN_INSTALL_SIZE16( CARDINAL32 Min_Sectors );
  3869.  
  3870.  
  3871. ΓòÉΓòÉΓòÉ 3.3.7.13. Set_Free_Space_Threshold ΓòÉΓòÉΓòÉ
  3872.  
  3873. void _System Set_Free_Space_Threshold( CARDINAL32  Min_Sectors );
  3874.  
  3875. Description 
  3876.  
  3877. This function tells the LVM Engine not to report blocks of free space which are 
  3878. less than the size specified.  The engine defaults to not reporting blocks of 
  3879. free space which are smaller than 2048 sectors (1 MB). 
  3880.  
  3881. Input 
  3882.  
  3883.  CARDINAL32 Min_Sectors 
  3884.            The minimum size, in sectors, that a block of free space must be in 
  3885.            order for the LVM engine to report it. 
  3886.  
  3887.  Output 
  3888.  
  3889.  None. 
  3890.  
  3891.  Error Handling 
  3892.  
  3893.  None required. 
  3894.  
  3895.  Side Effects 
  3896.  
  3897.  None. 
  3898.  
  3899.  Notes 
  3900.  
  3901.  None. 
  3902.  
  3903.  16 Bit Versions: 
  3904.  
  3905.   void _Far16 _Pascal _loadds SET_FREE_SPACE_THRESHOLD16( CARDINAL32 Min_Sectors );
  3906.  
  3907.   void far pascal _loadds SET_FREE_SPACE_THRESHOLD16( CARDINAL32 Min_Sectors );
  3908.  
  3909.  
  3910. ΓòÉΓòÉΓòÉ 3.3.7.14. Read_Sectors ΓòÉΓòÉΓòÉ
  3911.  
  3912. void _System Read_Sectors (
  3913.  
  3914.     CARDINAL32   Drive_Number,
  3915.     LBA          Starting_Sector,
  3916.     CARDINAL32   Sectors_To_Read,
  3917.     ADDRESS      Buffer,
  3918.     CARDINAL32 * Error
  3919.  
  3920. );
  3921.  
  3922. Description 
  3923.  
  3924. This function reads one or more sectors from the specified drive and places the 
  3925. data read in Buffer. 
  3926.  
  3927. Input 
  3928.  
  3929.  CARDINAL32 Drive_Number 
  3930.            The number of the hard drive to read from.  The drives in the system 
  3931.            are numbered from 1 to n, where n is the total number of hard drives 
  3932.            in the system. 
  3933.  
  3934.  LBA Starting_Sector 
  3935.            The first sector to read from. 
  3936.  
  3937.  CARDINAL32 Sectors_To_Read 
  3938.            The number of sectors to read into memory. 
  3939.  
  3940.  ADDRESS Buffer 
  3941.            The location to put the data read into. 
  3942.  
  3943.  CARDINAL32 * Error 
  3944.            The address of a variable to hold the error return code. 
  3945.  
  3946.  Output 
  3947.  
  3948.  If Successful, then the data read will be placed in memory starting at Buffer, 
  3949.  and *Error will be LVM_ENGINE_NO_ERROR. 
  3950.  
  3951.  If Unsuccessful, then *Error will be > 0 and the contents of memory starting 
  3952.  at Buffer is undefined. 
  3953.  
  3954.  Error Handling 
  3955.  
  3956.  *Error will be > 0 if an error occurs. 
  3957.  
  3958.  Side Effects 
  3959.  
  3960.  Data may be read into memory starting at Buffer. 
  3961.  
  3962.  Notes 
  3963.  
  3964.  None. 
  3965.  
  3966.  16 Bit Versions: 
  3967.  
  3968.   void _Far16 _Pascal _loadds READ_SECTORS16(
  3969.           CARDINAL32          Drive_Number,
  3970.           LBA                 Starting_Sector,
  3971.           CARDINAL32          Sectors_To_Read,
  3972.           ADDRESS      _Seg16 Buffer,
  3973.           CARDINAL32 * _Seg16 Error
  3974.   );
  3975.  
  3976.   void far pascal _loadds READ_SECTORS16(
  3977.           CARDINAL32       Drive_Number,
  3978.           LBA              Starting_Sector,
  3979.           CARDINAL32       Sectors_To_Read,
  3980.           void far *       Buffer,
  3981.           CARDINAL32 far * Error
  3982.   );
  3983.  
  3984.  
  3985. ΓòÉΓòÉΓòÉ 3.3.7.15. Write_Sectors ΓòÉΓòÉΓòÉ
  3986.  
  3987. void _System Write_Sectors (
  3988.  
  3989.     CARDINAL32   Drive_Number,
  3990.     LBA          Starting_Sector,
  3991.     CARDINAL32   Sectors_To_Write,
  3992.     ADDRESS      Buffer,
  3993.     CARDINAL32 * Error
  3994.  
  3995. );
  3996.  
  3997. Description 
  3998.  
  3999. This function writes data from memory to one or more sectors on the specified 
  4000. drive. 
  4001.  
  4002. Input 
  4003.  
  4004.  CARDINAL32 Drive_Number 
  4005.            The number of the hard drive to write to.  The drives in the system 
  4006.            are numbered from 1 to n, where n is the total number of hard drives 
  4007.            in the system. 
  4008.  
  4009.  LBA Starting_Sector 
  4010.            The first sector to write to. 
  4011.  
  4012.  CARDINAL32 Sectors_To_Read 
  4013.            The number of sectors to be written. 
  4014.  
  4015.  ADDRESS Buffer 
  4016.            The location of the data to be written to disk. 
  4017.  
  4018.  CARDINAL32 * Error 
  4019.            The address of a variable to hold the error return code. 
  4020.  
  4021.  Output 
  4022.  
  4023.  If Successful, then the data at Buffer will be placed on the disk starting at 
  4024.  the sector specified, and *Error will be LVM_ENGINE_NO_ERROR. 
  4025.  
  4026.  If Unsuccessful, then *Error will be > 0 and the contents of the disk starting 
  4027.  at sector Starting_Sector is undefined. 
  4028.  
  4029.  Error Handling 
  4030.  
  4031.  *Error will be > 0 if an error occurs. 
  4032.  
  4033.  Side Effects 
  4034.  
  4035.  Data may be written to disk. 
  4036.  
  4037.  Notes 
  4038.  
  4039.  None. 
  4040.  
  4041.  16 Bit Versions: 
  4042.  
  4043.   void _Far16 _Pascal _loadds WRITE_SECTORS16(
  4044.           CARDINAL32          Drive_Number,
  4045.           LBA                 Starting_Sector,
  4046.           CARDINAL32          Sectors_To_Write,
  4047.           ADDRESS      _Seg16 Buffer,
  4048.           CARDINAL32 * _Seg16 Error
  4049.   );
  4050.  
  4051.   void far pascal _loadds WRITE_SECTORS16(
  4052.           CARDINAL32       Drive_Number,
  4053.           LBA              Starting_Sector,
  4054.           CARDINAL32       Sectors_To_Write,
  4055.           void far *       Buffer,
  4056.           CARDINAL32 far * Error
  4057.   );
  4058.  
  4059.  
  4060. ΓòÉΓòÉΓòÉ 3.3.7.16. Rediscover_PRMs ΓòÉΓòÉΓòÉ
  4061.  
  4062. void _System Rediscover_PRMs( CARDINAL32 * Error_Code );
  4063.  
  4064. Description 
  4065.  
  4066. Causes OS2LVM and OS2DASD to check PRMs for new or changed media. 
  4067.  
  4068. Input 
  4069.  
  4070.  CARDINAL32 * Error_Code 
  4071.            The address of a CARDINAL32 in which to store an error code should 
  4072.            an error occur. 
  4073.  
  4074.  Output 
  4075.  
  4076.  If the Rediscover PRM operation was successful, then *Error_Code will be 
  4077.  LVM_ENGINE_NO_ERROR.  If there was an error, then *Error_Code will be > 0. 
  4078.  
  4079.  Error Handling 
  4080.  
  4081.  None. 
  4082.  
  4083.  Side Effects 
  4084.  
  4085.  New volumes may be discovered and assigned drive letters by OS2LVM and 
  4086.  OS2DASD. 
  4087.  
  4088.  Notes 
  4089.  
  4090.  The LVM Engine must be CLOSED when this function is called as this function is 
  4091.  disabled while it is open! 
  4092.  
  4093.  16 Bit Versions: 
  4094.  
  4095.   void _Far16 _Pascal _loadds REDISCOVER_PRMS16( CARDINAL32 * _Seg16 Error_Code );
  4096.  
  4097.   void far pascal _loadds REDISCOVER_PRMS16( CARDINAL32 far * Error_Code );
  4098.  
  4099.  
  4100. ΓòÉΓòÉΓòÉ 3.3.7.17. Get_LVM_View ΓòÉΓòÉΓòÉ
  4101.  
  4102. BOOLEAN _System Get_LVM_View(
  4103.  
  4104.     char         IFSM_Drive_Letter,
  4105.     CARDINAL32 * Drive_Number,
  4106.     CARDINAL32 * Partition_LBA,
  4107.     char *       LVM_Drive_Letter,
  4108.     BYTE *       UnitID
  4109.  
  4110. );
  4111.  
  4112. Description 
  4113.  
  4114. This function gets the OS2LVM data for the specified drive letter.  The intent 
  4115. is to allow the determination of what drive letter a volume really has given 
  4116. the possibilities of conflict or a drive preference of '*'. 
  4117.  
  4118. Input 
  4119.  
  4120.  char IFSM_Drive_Letter 
  4121.            The drive letter for which the OS2LVM data is requested. 
  4122.  
  4123.  CARDINAL32 * Drive_Number 
  4124.            The address of a variable to hold the OS/2 drive number of the drive 
  4125.            containing the first partition of the volume currently assigned to 
  4126.            the requested drive letter. 
  4127.  
  4128.  CARDINAL32 * Partition_LBA 
  4129.            The address of a variable to hold the LBA of the first partition of 
  4130.            the volume currently assigned to the requested drive letter. 
  4131.  
  4132.  char * LVM_Drive_Letter 
  4133.            The address of a variable to hold the drive letter that OS2LVM 
  4134.            thinks the volume assigned to the requested drive letter should 
  4135.            have. 
  4136.  
  4137.  BYTE * UnitID 
  4138.            The address of a variable to hold the OS2LVM unit ID for the volume 
  4139.            associated with the requested drive letter. 
  4140.  
  4141.  Output 
  4142.  
  4143.  The function return value will be TRUE if the function completed successfully. 
  4144.  
  4145.  Error Handling 
  4146.  
  4147.  If this function fails, the specified drive letter is either not in use, or is 
  4148.  in use by a device not controlled by OS2LVM. 
  4149.  
  4150.  Side Effects 
  4151.  
  4152.  None. 
  4153.  
  4154.  Notes 
  4155.  
  4156.  This function can be used with the LVM Engine open or closed. 
  4157.  
  4158.  16 Bit Versions: 
  4159.  
  4160.   BOOLEAN _Far16 _Pascal _loadds GET_LVM_VIEW16(
  4161.           char                IFSM_Drive_Letter,
  4162.           CARDINAL32 * _Seg16 Drive_Number,
  4163.           CARDINAL32 * _Seg16 Partition_LBA,
  4164.           char *       _Seg16 LVM_Drive_Letter,
  4165.           BYTE *       _Seg16 UnitID
  4166.   );
  4167.  
  4168.   BOOLEAN far pascal _loadds GET_LVM_VIEW16(
  4169.           char             IFSM_Drive_Letter,
  4170.           CARDINAL32 far * Drive_Number,
  4171.           CARDINAL32 far * Partition_LBA,
  4172.           char far *       LVM_Drive_Letter,
  4173.           BYTE far *       UnitID
  4174.   );
  4175.  
  4176.  
  4177. ΓòÉΓòÉΓòÉ 3.3.7.18. Start_Logging ΓòÉΓòÉΓòÉ
  4178.  
  4179. void _System Start_Logging(
  4180.  
  4181.     char *       Filename,
  4182.     CARDINAL32 * Error_Code
  4183.  
  4184. );
  4185.  
  4186. Description 
  4187.  
  4188. Enables the LVM Engine logging.  Once enabled, the LVM Engine logging function 
  4189. will log all LVM Engine activity to the specified log file. The data is logged 
  4190. in a binary format for compactness and speed. 
  4191.  
  4192. Input 
  4193.  
  4194.  char * Filename 
  4195.            The filename of the file to use as the log file. 
  4196.  
  4197.  CARDINAL32 * Error_Code 
  4198.            The address of a CARDINAL32 in which to store an error code should 
  4199.            an error occur. 
  4200.  
  4201.  Output 
  4202.  
  4203.  If the logging file was successfully created, then *Error_Code will be 0.  If 
  4204.  the log file could not be created, then *Error_Code will be > 0. 
  4205.  
  4206.  Error Handling 
  4207.  
  4208.  If the log file can not be created, then *Error_Code will be > 0. 
  4209.  
  4210.  Side Effects 
  4211.  
  4212.  A file may be created/opened for logging of LVM Engine actions. 
  4213.  
  4214.  Notes 
  4215.  
  4216.  None. 
  4217.  
  4218.  16 Bit Versions: 
  4219.  
  4220.   void _Far16 _Pascal _loadds START_LOGGING16(
  4221.           char *       _Seg16 Filename,
  4222.           CARDINAL32 * _Seg16 Error_Code
  4223.   );
  4224.  
  4225.   void far pascal _loadds START_LOGGING16(
  4226.           char far *       Filename,
  4227.           CARDINAL32 far * Error_Code
  4228.   );
  4229.  
  4230.  
  4231. ΓòÉΓòÉΓòÉ 3.3.7.19. Stop_Logging ΓòÉΓòÉΓòÉ
  4232.  
  4233. void _System Stop_Logging ( CARDINAL32 * Error_Code );
  4234.  
  4235. Description 
  4236.  
  4237. This function ends LVM Engine logging and closes the log file. 
  4238.  
  4239. Input 
  4240.  
  4241.  CARDINAL32 * Error_Code 
  4242.            The address of a CARDINAL32 in which to store an error code should 
  4243.            an error occur. 
  4244.  
  4245.  Output 
  4246.  
  4247.  *Error_Code will be 0 if this function completes successfully; otherwise it 
  4248.  will be > 0. 
  4249.  
  4250.  Error Handling 
  4251.  
  4252.  If the log file is not currently opened, or if the close operation fails on 
  4253.  the log file, then *Error_Code will be > 0. 
  4254.  
  4255.  Side Effects 
  4256.  
  4257.  The log file may be closed. 
  4258.  
  4259.  Notes 
  4260.  
  4261.  None. 
  4262.  
  4263.  16 Bit Versions: 
  4264.  
  4265.   void _Far16 _Pascal _loadds STOP_LOGGING16( CARDINAL32 * _Seg16 Error_Code );
  4266.  
  4267.   void far pascal _loadds STOP_LOGGING16( CARDINAL32 far * Error_Code );
  4268.  
  4269.  
  4270. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4271.  
  4272. If a primary is created from this block of free space, then it can be made 
  4273. bootable. 
  4274.  
  4275.  
  4276. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4277.  
  4278. If a logical drive is created from this block of free space, then OS/2 can boot 
  4279. from it by adding it to the boot manager menu. 
  4280.  
  4281.  
  4282. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4283.  
  4284. OS/2 Drive Number for this drive. 
  4285.  
  4286.  
  4287. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4288.  
  4289. The total number of sectors on the drive. 
  4290.  
  4291.  
  4292. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4293.  
  4294. The serial number assigned to this drive.  For info. purposes only. 
  4295.  
  4296.  
  4297. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4298.  
  4299. Handle used for operations on the disk that this record corresponds to. 
  4300.  
  4301.  
  4302. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4303.  
  4304. The number of cylinders on the drive. 
  4305.  
  4306.  
  4307. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4308.  
  4309. The number of heads per cylinder for this drive. 
  4310.  
  4311.  
  4312. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4313.  
  4314. The number of sectors per track for this drive. 
  4315.  
  4316.  
  4317. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4318.  
  4319. Set to TRUE if this drive is a PRM. 
  4320.  
  4321.  
  4322. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4323.  
  4324. Alignment. 
  4325.  
  4326.  
  4327. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4328.  
  4329. An array of drive control records. 
  4330.  
  4331.  
  4332. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4333.  
  4334. The number of entries in the array of drive control records. 
  4335.  
  4336.  
  4337. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4338.  
  4339. The number of sectors on the disk which are not currently assigned to a 
  4340. partition. 
  4341.  
  4342.  
  4343. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4344.  
  4345. The number of sectors in the largest contiguous block of available sectors. 
  4346.  
  4347.  
  4348. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4349.  
  4350. If TRUE, then the partitioning information found on the drive is incorrect! 
  4351.  
  4352.  
  4353. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4354.  
  4355. If TRUE, the drive's MBR is not accessible and the drive can not be 
  4356. partitioned. 
  4357.  
  4358.  
  4359. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4360.  
  4361. If TRUE, then the last I/O operation on this drive failed! 
  4362.  
  4363.  
  4364. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4365.  
  4366. If TRUE, then the drive is a PRM formatted as a big floppy (i.e. the old style 
  4367. removable media support). 
  4368.  
  4369.  
  4370. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4371.  
  4372. User assigned name for this disk drive. 
  4373.  
  4374.  
  4375. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4376.  
  4377. The handle used to perform operations on this partition. 
  4378.  
  4379.  
  4380. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4381.  
  4382. If this partition is part of a volume, this will be the handle of the volume. 
  4383. If this partition is NOT part of a volume, then this handle will be 0. 
  4384.  
  4385.  
  4386. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4387.  
  4388. The handle for the drive this partition resides on. 
  4389.  
  4390.  
  4391. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4392.  
  4393. The serial number assigned to this partition. 
  4394.  
  4395.  
  4396. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4397.  
  4398. The LBA of the first sector of the partition. 
  4399.  
  4400.  
  4401. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4402.  
  4403. The total number of sectors comprising the partition. 
  4404.  
  4405.  
  4406. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4407.  
  4408. The size of the partition as reported to the IFSM.  This is the size of the 
  4409. partition less any LVM overhead. 
  4410.  
  4411.  
  4412. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4413.  
  4414. The maximum number of sectors from this block of free space that can be used to 
  4415. create a bootable partition if you allocate from the beginning of the block of 
  4416. free space. 
  4417.  
  4418.  
  4419. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4420.  
  4421. TRUE if this partition is part of a multi-partition volume. 
  4422.  
  4423.  
  4424. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4425.  
  4426. True or False.  Any non-zero value here indicates that this partition is a 
  4427. primary partition.  Zero here indicates that this partition is a "logical 
  4428. drive" - i.e. it resides inside of an extended partition. 
  4429.  
  4430.  
  4431. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4432.  
  4433. 80 = Partition is marked as being active. 
  4434. 0 = Partition is not active. 
  4435.  
  4436.  
  4437. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4438.  
  4439. This field is from the partition table.  It is known as the OS flag, the 
  4440. Partition Type Field, Filesystem Type, and various other names. 
  4441.  
  4442. Values of interest 
  4443.  
  4444. If this field is: (values are in hex) 
  4445.  
  4446.  07 =  The partition is a compatibility partition formatted for use with an 
  4447.        installable filesystem, such as HPFS or JFS. 
  4448.  00 =  Unformatted partition 
  4449.  01 =  FAT12 filesystem is in use on this partition. 
  4450.  04 =  FAT16 filesystem is in use on this partition. 
  4451.  0A =  OS/2 Boot Manager Partition 
  4452.  35 =  LVM partition 
  4453.  84 =  OS/2 FAT16 partition which has been relabeled by Boot Manager to "Hide" 
  4454.        it. 
  4455.  
  4456.  
  4457. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4458.  
  4459.  0 =  Free Space 
  4460.  1 =  LVM Partition (Part of an LVM Volume.) 
  4461.  2 =  Compatibility Partition 
  4462.  
  4463.  All other values are reserved for future use. 
  4464.  
  4465.  
  4466. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4467.  
  4468.  0 =  Free Space 
  4469.  1 =  In Use - i.e. already assigned to a volume. 
  4470.  2 =  Available - i.e. not currently assigned to a volume. 
  4471.  
  4472.  
  4473. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4474.  
  4475. Set to TRUE if this partition is not part of a Volume yet is on the Boot 
  4476. Manager Menu. 
  4477.  
  4478.  
  4479. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4480.  
  4481. Alignment. 
  4482.  
  4483.  
  4484. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4485.  
  4486. The drive letter assigned to the volume that this partition is a part of. 
  4487.  
  4488.  
  4489. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4490.  
  4491. User assigned name for this disk drive. 
  4492.  
  4493.  
  4494. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4495.  
  4496. The name of the filesystem in use on this partition, if it is known. 
  4497.  
  4498.  
  4499. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4500.  
  4501. The user assigned name for this partition. 
  4502.  
  4503.  
  4504. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4505.  
  4506. If this partition is part of a volume, then this will be the name of the volume 
  4507. that this partition is a part of.  If this record represents free space, then 
  4508. the Volume_Name will be "FREE SPACE xx", where xx is a unique numeric ID 
  4509. generated by LVM.DLL.  Otherwise it will be an empty string. 
  4510.  
  4511.  
  4512. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4513.  
  4514. An array of Partition_Information_Records. 
  4515.  
  4516.  
  4517. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4518.  
  4519. The number of entries in the Partition_Array. 
  4520.  
  4521.  
  4522. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4523.  
  4524. The serial number assigned to this volume. 
  4525.  
  4526.  
  4527. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4528.  
  4529. The handle used to perform operations on this volume. 
  4530.  
  4531.  
  4532. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4533.  
  4534. TRUE indicates that this volume is compatible with older versions of OS/2. 
  4535.  
  4536. FALSE indicates that this is an LVM specific volume and can not be used without 
  4537. OS2LVM.DMD. 
  4538.  
  4539.  
  4540. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4541.  
  4542. Indicates what type of device the Volume resides on: 
  4543.  
  4544.  0 =  Hard Drive under LVM Control 
  4545.  1 =  PRM under LVM Control 
  4546.  2 =  CD-ROM 
  4547.  3 =  Network drive 
  4548.  4 =  Unknown device NOT under LVM Control 
  4549.  
  4550.  
  4551. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4552.  
  4553. Alignment. 
  4554.  
  4555.  
  4556. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4557.  
  4558. An array of volume control records. 
  4559.  
  4560.  
  4561. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4562.  
  4563. The number of entries in the array of volume control records. 
  4564.  
  4565.  
  4566. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4567.  
  4568. The number of sectors comprising the volume. 
  4569.  
  4570.  
  4571. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4572.  
  4573. The number of partitions which comprise this volume. 
  4574.  
  4575.  
  4576. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4577.  
  4578.  0  indicates that the drive letter preference for this volume is unique. 
  4579.  1  indicates that the drive letter preference for this volume is not unique, 
  4580.     but this volume got its preferred drive letter anyway. 
  4581.  2  indicates that the drive letter preference for this volume is not unique, 
  4582.     and this volume did NOT get its preferred drive letter. 
  4583.  4  indicates that this volume is currently "hidden" - i.e. it has no drive 
  4584.     letter preference at the current time. 
  4585.  
  4586.  
  4587. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4588.  
  4589. TRUE if this is for a compatibility volume, FALSE otherwise. 
  4590.  
  4591.  
  4592. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4593.  
  4594. Set to TRUE if this volume appears on the Boot Manager menu, or if it is a 
  4595. compatibility volume and its corresponding partition is the first active 
  4596. primary partition on the first drive. 
  4597.  
  4598.  
  4599. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4600.  
  4601. The drive letter that this volume desires to be. 
  4602.  
  4603.  
  4604. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4605.  
  4606. The drive letter currently used to access this volume.  May be different than 
  4607. Drive_Letter_Preference if there was a conflict ( i.e. Drive_Letter_Preference 
  4608. is already in use by another volume ). 
  4609.  
  4610.  
  4611. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4612.  
  4613. The drive letter assigned to this volume by the operating system when LVM was 
  4614. started. This may be different from the Drive_Letter_Preference if there were 
  4615. conflicts, and may be different from the Current_Drive_Letter.  This will be 
  4616. 0x0 if the Volume did not exist when the LVM Engine was opened (i.e. it was 
  4617. created during this LVM session). 
  4618.  
  4619.  
  4620. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4621.  
  4622. Set to FALSE if this volume existed before the LVM Engine was opened.  Set to 
  4623. TRUE if this volume was created after the LVM Engine was opened. 
  4624.  
  4625.  
  4626. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4627.  
  4628.  0 =  None. 
  4629.  1 =  Bootable 
  4630.  2 =  Startable 
  4631.  3 =  Installable. 
  4632.  
  4633.  
  4634. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4635.  
  4636. The user assigned name for this volume. 
  4637.  
  4638.  
  4639. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4640.  
  4641. The name of the filesystem in use on this partition, if it is known. 
  4642.  
  4643. [Known values include 'HPFS', 'JFS', 'FAT16', 'FAT32', 'NTFS', 'UDF', 'CDFS', 
  4644. 'Linux' and '????'.  Note that there is an apparent bug in the current LVM.DLL 
  4645. which causes partition type 0x83 (Linux native) to be reported as '????' while 
  4646. type 0x82 (Linux swap) is be reported as 'Linux'.] 
  4647.  
  4648.  
  4649. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4650.  
  4651. A Volume or Partition handle. 
  4652.  
  4653.  
  4654. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4655.  
  4656. If TRUE, then Handle is the handle of a Volume.  Otherwise, Handle is the 
  4657. handle of a partition. 
  4658.  
  4659.  
  4660. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4661.  
  4662. The feature ID of the feature to use. 
  4663.  
  4664.  
  4665. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4666.  
  4667. The LVM Class (supported by the specified feature) to use. 
  4668.  
  4669.  
  4670. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4671.  
  4672. The address of a buffer containing initialization data for this feature. NULL 
  4673. if there is no initialization data being provided for this feature. 
  4674.  
  4675.  
  4676. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4677.  
  4678. Let LVM decide which block of free space to use to create the partition. 
  4679.  
  4680.  
  4681. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4682.  
  4683. Use the block of free space which is closest in size to the partition being 
  4684. created. 
  4685.  
  4686.  
  4687. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4688.  
  4689. Use the first block of free space on the disk which is large enough to hold a 
  4690. partition of the specified size. 
  4691.  
  4692.  
  4693. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4694.  
  4695. Use the last block of free space on the disk which is large enough to hold a 
  4696. partition of the specified size. 
  4697.  
  4698.  
  4699. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4700.  
  4701. Find the largest block of free space and allocate the partition from that block 
  4702. of free space. 
  4703.  
  4704.  
  4705. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4706.  
  4707. Find the smallest block of free space that can accommodate a partition of the 
  4708. size specified. 
  4709.  
  4710.  
  4711. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  4712.  
  4713. Turn the specified drive or block of free space into a single partition.