?? NEWTITLE := 'NOS/VE Device Management' ??
MODULE dmm$device_manager_setup;
?? RIGHT := 110 ??

{ PURPOSE:
{  The purpose of this module is to provide access to the system device.
{  The system device is always brought online, but will be initialized
{  during an installation deadstart.

?? NEWTITLE := 'Global Declarations Referenced By This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_fixed
*copyc oss$mainframe_wired
*copyc osc$processor_defined_registers
*copyc rmd$volume_declarations
*copyc cmt$logical_unit_attributes
*copyc cmt$product_identification
*copyc dmt$error_condition_codes
*copyc dmt$file_table_lock
*copyc dmt$logical_device_attributes
*copyc dmt$physical_device_attributes
*copyc dst$log_ms_volume_init
*copyc iot$logical_unit
*copyc ost$hardware_subranges
*copyc ost$heap
*copyc ost$page_size
*copyc ost$status
?? POP ??
*copyc cmp$get_element_name_via_lun
*copyc cmp$get_unit_type
*copyc cmp$pc_get_logical_unit
*copyc dmp$get_logical_attributes
*copyc dmp$get_physical_attributes
*copyc dmp$initialize_ms_volume
*copyc dmp$search_avt_by_lun
*copyc dmp$volume_online
*copyc dsp$log_sys_msg_help
*copyc osp$set_status_abnormal
*copyc dmv$active_volume_table
*copyc osv$deadstart_phase
*copyc osv$mainframe_wired_heap
*copyc cml$ms_volume_initialization
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared By This Module', EJECT ??

  VAR
    dmv$retain_system_device_flaws: [STATIC, XDCL, #GATE] boolean := TRUE,

    dmv$system_device_lun: [STATIC, XDCL, #GATE] iot$logical_unit := 6,

    dmv$system_device_product_id: [STATIC, XDCL, #GATE] cmt$product_identification := ['  885', '$', '41'],

    dmv$system_device_recorded_vsn: [STATIC, XDCL, #GATE] rmt$recorded_vsn := 'VSN006';

?? OLDTITLE ??
?? NEWTITLE := '  dmp$system_initialization', EJECT ??

  PROCEDURE [XDCL] dmp$system_initialization
    (VAR status: ost$status);

    VAR
      unit_type: cmt$unit_type,
      io_type: iot$unit_type,
      unit_class: cmt$unit_class,
      found: boolean,
      initialization_options: dmt$initialize_ms_vol_options,
      init_status_info: dmt$initialize_status_info,
      p_physical_attributes: ^dmt$physical_device_attributes,
      p_logical_attributes: ^dmt$logical_device_attributes,
      p_label_attributes: ^dmt$volume_label_attributes,
      access_code: ost$name,
      owner_id: ost$user_identification,
      avt_index: dmt$active_volume_table_index,
      avt_entry_found: boolean;

    status.normal := TRUE;
    ALLOCATE dmv$active_volume_table.table_p: [1 .. 1] IN osv$mainframe_wired_heap^;
    dmv$active_volume_table.table_p^ [1].entry_available := TRUE;
    dmv$active_volume_table.table_p^ [1].lock.lock_id := 0;
    dmv$active_volume_table.table_p^ [1].logical_unit_number := 0;

    PUSH p_physical_attributes: [1 .. 8];
    p_physical_attributes^ [1].keyword := dmc$bytes_per_mau;
    p_physical_attributes^ [2].keyword := dmc$cylinders_per_device;
    p_physical_attributes^ [3].keyword := dmc$maus_per_cylinder;
    p_physical_attributes^ [4].keyword := dmc$maus_per_dau;
    p_physical_attributes^ [5].keyword := dmc$sectors_per_mau;
    p_physical_attributes^ [6].keyword := dmc$sectors_per_track;
    p_physical_attributes^ [7].keyword := dmc$flaw_map_locations;
    p_physical_attributes^ [8].keyword := dmc$pda_max_label_size;

    dmp$get_physical_attributes (dmv$system_device_product_id, p_physical_attributes, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF (osv$deadstart_phase = osc$installation_deadstart) THEN

      PUSH p_label_attributes: [1 .. 3];
      p_label_attributes^ [1].keyword := dmc$label_access_code;
      p_label_attributes^ [1].access_code := dmc$default_vol_access_code;
      p_label_attributes^ [2].keyword := dmc$label_expiration_days;
      p_label_attributes^ [2].expiration_days := dmc$max_expiration_days;
      p_label_attributes^ [3].keyword := dmc$label_recorded_vsn;
      p_label_attributes^ [3].recorded_vsn := dmv$system_device_recorded_vsn;

      PUSH p_logical_attributes: [1 .. 3];
      p_logical_attributes^ [1].keyword := dmc$volume_dfl_entries;
      p_logical_attributes^ [2].keyword := dmc$volume_directory_entries;
      p_logical_attributes^ [3].keyword := dmc$logical_flaws;

      dmp$get_logical_attributes (dmv$system_device_product_id, p_logical_attributes, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      cmp$get_unit_type (dmv$system_device_product_id, unit_type, io_type, unit_class, found);
      IF NOT found THEN
        osp$set_status_abnormal (dmc$device_manager_ident, dme$reject_r1,
              'Unknown system device product identifier - dmp$system_initialization.', status);
        RETURN; {----->
      IFEND;

      access_code := dmc$default_vol_access_code;
      owner_id.family := '$SYSTEM';
      owner_id.user := '$SYSTEM';
      initialization_options.allowed_to_overwrite_volume := TRUE;
      initialization_options.retain_device_flaws := dmv$retain_system_device_flaws;
      IF dmv$retain_system_device_flaws THEN
        initialization_options.format_option := dmc$fmvo_no_format;
      ELSE
        initialization_options.format_option := dmc$fmvo_force_format;
      IFEND;

      dmp$initialize_ms_volume (access_code, owner_id, unit_type, p_physical_attributes, p_logical_attributes,
            p_label_attributes, dmv$system_device_lun, initialization_options, init_status_info, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    dmp$volume_online (dmv$system_device_lun, p_physical_attributes, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    dmp$search_avt_by_lun (dmv$system_device_lun, avt_index, avt_entry_found);
    IF NOT avt_entry_found THEN
      osp$set_status_abnormal (dmc$device_manager_ident, dme$volume_not_online, 'dmp$system_initialization',
            status);
      RETURN; {----->
    IFEND;

    dmv$system_device_recorded_vsn := dmv$active_volume_table.table_p^ [avt_index].mass_storage.recorded_vsn;

    IF (osv$deadstart_phase = osc$installation_deadstart) THEN
      log_system_device_init;
    IFEND;

  PROCEND dmp$system_initialization;
?? TITLE := '  log_system_device_init', EJECT ??

  PROCEDURE log_system_device_init;

    VAR
      element_def: ^cmt$element_definition,
      logging_data: dst$log_ms_volume_init,
      logging_data_p: ^SEQ ( * ),
      status: ost$status;

    cmp$get_element_name_via_lun (dmv$system_device_lun, logging_data.element_name, status);
    IF status.normal THEN
      cmp$pc_get_logical_unit (dmv$system_device_lun, element_def, status);
    IFEND;

    IF status.normal THEN
      logging_data.recorded_vsn := dmv$system_device_recorded_vsn;
      IF element_def^.element_type = cmc$storage_device_element THEN
        logging_data.physical_unit_number := element_def^.storage_device.physical_unit_number;
      IFEND;
      logging_data_p := #SEQ (logging_data);
      dsp$log_sys_msg_help (cml$ms_volume_initialization, logging_data_p);
    IFEND;

  PROCEND log_system_device_init;
MODEND dmm$device_manager_setup;
