
{    DECK: RFT$CONFIGURATION_DEFS
{
{    The following definitions define the status table for the remote host
{    facility access method (RHFAM).  These definitions include the
{    hardware configuration, the mainframe identifiers, and the current status
{    information of the loosely coupled network (LCN) as viewed from the
{    local host.


TYPE

     {    The RHFAM/VE status table is broken up in to the various
     {    LCN components.  An additional break-down is made to isolate
     {    by field accessibility.
     {
     {    1)  Read only fields.  Can be read while the reader has the
     {        global lock, while the reader has the display lock, and
     {        while the reader has incremented an active connection count.
     {        (the system task can read at any time).
     {
     {    2)  System task only.  These fields are read or written at any
     {        instant while the system task is up.  Can be read by
     {        other tasks satisfying rule 1.
     {
     {    3)  Read/write fields.  These fields require the status table
     {        lock to be set prior to access.  (NOTE - if the user only
     {        wants to read the value, rule 1 applies).
     {
     {    4)  Special read/write fields.  These fields are only
     {        accessible while the user has obtained the corresponding
     {        special lock.  (NOTE - these fields are nested within the
     {        status table, therefore the user must have satisfied the
     {        the requirements of rule 1 prior to setting a special lock).

     rft$status_table = RECORD
       lock: ost$signature_lock,

       {  Read.

       location: ^SEQ(*),
       local_nads: ^rft$local_nad_table,
       remote_nads: ^rft$remote_nad_table,
       local_host: ^rft$local_host_definition,
       remote_hosts: ^rft$remote_host_definition,

       {  Read/write.

       system_task_is_up: BOOLEAN,
       display_active: ost$global_task_id,
       install_in_progress_id: ost$global_task_id,
     RECEND;

TYPE
     rft$local_nad_table = ARRAY [1..*] of rft$local_nad_entry;

TYPE
     rft$local_nad_entry = RECORD

       {  Read.

       name: ALIGNED [0 MOD 8] rft$component_name,
       channel_ordinal: cmt$channel_ordinal,
       channel_number: ost$physical_channel_number,
       concurrent_channel: boolean,
       trunk_control_units: rft$trunk_control_units,
       defined_address: rft$nad_address,
       address: rft$nad_address,              { Initialized by system task }
       access_codes: rft$nad_access_codes,
       logical_unit_number: iot$logical_unit, { Initialized by system task }
       pp_drivers: 1..2,

       {  System task.

       pp: ARRAY [1..2] OF rft$pp_attributes,
       maintenance_selections: rft$maintenance_selections,
       maintenance_status: rft$maintenance_status,
       processing_out_control_mess: BOOLEAN,
       processing_in_control_mess: BOOLEAN,
       status_change_available: BOOLEAN,
       status_posted: BOOLEAN,
       incoming_connect_pending: BOOLEAN,
       current_max_connect_id: rft$concurrent_connections,
       last_status_change: INTEGER,
       last_status_seq_number: INTEGER,

       {  Read/write.

       current_status: ALIGNED [0 MOD 8] rft$nad_state,
       statistics: rft$nad_statistics,
       requests_posted: rft$concurrent_requests,
       connections_established: rft$concurrent_connections,

       {  Special read/write.

       outgoing_cm_queue: rft$outgoing_control_messages,

       {  Special read/write.

       connection_table_lock: ost$signature_lock,
       connection_table: ^rft$connections,
     RECEND;

TYPE
     rft$connections = ARRAY [0..*] OF rft$connection_table_entry;

TYPE
     rft$connection_table_entry = RECORD
       connection_state: rft$path_state,
       connection_clarifier: rft$path_clarifier,
       input_available: BOOLEAN,
       output_below_threshold: BOOLEAN,
       processing_incoming_connect: BOOLEAN,
       connection_table_entry: ^rft$connection_entry,
     RECEND;

TYPE
     rft$remote_nad_table = array [1..*] of rft$remote_nad_entry;

TYPE
     rft$remote_nad_entry = RECORD

       {  Read.

       name: ALIGNED [0 MOD 8] rft$component_name,
       microcode_type: rft$microcode_types,
       host_connections: rft$host_connections,
       address: rft$nad_address,
       trunk_control_units: rft$trunk_control_units,
       access_codes: rft$nad_access_codes,

       {  Read/write.

       current_status: ALIGNED [0 MOD 8] rft$nad_state,
       last_connect_time: ost$date_time,
     RECEND;

TYPE
     rft$local_host_definition = RECORD

       {  Read/write.

       disabled: ALIGNED [0 MOD 8] BOOLEAN,

       {  Read.

       physical_identifier: rft$physical_identifier,
       connection_password: rft$connection_password,
       subsystem_identifier: rft$subsystem_identifier,
       connection_timeout: rft$connection_timeout,
       data_transfer_timeout: rft$transfer_timeout,

       {  Check nested type definition for access information.

       associated_paths: ^rft$lcn_paths,
       logical_identifiers: array [1..*] of rft$lids,
     recend;

TYPE
     rft$lids = RECORD

       {  Read/write.

       disabled: BOOLEAN,

       {  Read.

       map_lid_to_pid: BOOLEAN,
       logical_id: rft$logical_identifier,
     RECEND;

TYPE
     rft$remote_host_definition = RECORD

       {  Read/write.

       disabled: ALIGNED [0 MOD 8] BOOLEAN,

       {  Read.

       next_entry: ^rft$remote_host_definition,
       physical_identifier: rft$physical_identifier,

       {  Check nested type definition for access information.

       associated_paths: ^rft$lcn_paths,
       logical_identifiers: array [1..*] of rft$lids,
     RECEND;

TYPE
     rft$lcn_paths = array [1..*] of rft$lcn_path_definition;

TYPE
     rft$lcn_path_definition = RECORD

       {  Read/write.

       disabled: ALIGNED [0 MOD 8] BOOLEAN,
       time_disabled: INTEGER,
       last_network_break_rc: rft$network_break_reason_code,
       failure_count: INTEGER,
       last_attempted_connect: INTEGER,

       {  Read.

       local_tcu_mask: rft$tcu_mask,
       remote_tcu_mask: rft$tcu_mask,
       access_code: rft$nad_access_code,
       destination_device: rft$destination_device,
       logical_network: rft$logical_network,
       logical_nad: rft$logical_nad,
       local_nad: rft$local_nads,
       CASE  loopback : boolean  OF
       = TRUE =
         destination_nad: rft$local_nads,
       = FALSE =
         remote_nad: rft$remote_nads,
       CASEND,
     RECEND;

TYPE
     rft$trunk_control_units = array [rfc$min_tcu..rfc$max_tcu] of
       rft$component_name;

TYPE
     rft$pp_attributes = RECORD
       pp_number: iot$pp_number,
       pp_state: rft$pp_state,
       pp_id: cmt$pp_identification,
     RECEND;

TYPE
     rft$pp_state = (rfc$pps_released, rfc$pps_reserved, rfc$pps_idle,
                     rfc$pps_normal);

TYPE
     rft$nad_state = record
       device_status: rft$element_state,
       tcu_status: array [rfc$min_tcu..rfc$max_tcu] of rft$element_state,
     recend;

TYPE
     rft$nad_statistics = record
       connections_established: rft$number_of_connects,
       bytes_sent: rft$bytes_transferred,
       bytes_received: rft$bytes_transferred,
     recend;

TYPE
     rft$maintenance_selections = record
       perform_auto_reload: boolean,
       reload_threshold: rft$microcode_reloads,
       dump_disposition: rft$dump_disposition,
       load_parameters: rft$load_parameters,
     recend;

TYPE

     rft$load_parameters = record
       maximum_connections: rft$concurrent_connections,
       maximum_nad_entries: rft$rnads_per_lnad,
       send_queue_limit: rft$nad_queue_limit,
       receive_queue_limit: rft$nad_queue_limit,
       monitor_trace: rft$nad_trace_parameter,
       trunk_trace: rft$nad_trace_parameter,
       device_trace: rft$nad_trace_parameter,
     recend;

TYPE

     rft$maintenance_status = record
       reload_in_progress: boolean,
       reloads_performed: rft$microcode_reloads,
       reload_failed: boolean,
       test_requested: boolean,
     recend;

TYPE
     rft$nad_status_entries = PACKED ARRAY [1..*] OF rft$nad_status_entry,

     rft$nad_status_entry = PACKED RECORD
       path_state: rft$path_state,
       path_clarifier: rft$path_clarifier,
       input_available: boolean,
       output_below_threshold: boolean,
       fill: 0..03f(16),
       path_identifier: rft$path_id,
     RECEND;

TYPE
     rft$path_state = 0..0ff(16),
     rft$path_clarifier = 0..0ff(16),
     rft$path_id = 0..0ff(16);

TYPE

     rft$component_name = ost$name,
     rft$host_connections = array [rfc$min_host_connect..rfc$max_host_connect]
       of rft$physical_identifier,
     rft$element_state = (rfc$es_on,rfc$es_off,rfc$es_down),
     rft$microcode_reloads = 0..rfc$max_microcode_reloads,
     rft$dump_disposition = (rfc$dd_discard,rfc$dd_save_last,
       rfc$dd_save_all),
     rft$rnads_per_lnad = 0..rfc$max_rnads_per_lnad,
     rft$number_of_connects = INTEGER,
     rft$request_count = INTEGER,
     rft$concurrent_requests = 0..rfc$max_concurrent_requests,
     rft$concurrent_connections = 0..rfc$max_connections,
     rft$nad_address = rfc$min_nad_address..rfc$max_nad_address,
     rft$nad_access_codes = array [rfc$min_tcu..rfc$max_tcu] of
       rft$nad_access_code,
     rft$nad_access_code = rfc$min_nad_access_code..rfc$max_nad_access_code,
     rft$microcode_types = (rfc$mc_type_180,rfc$mc_type_170,rfc$mc_type_vax,
       rfc$mc_type_ibm, rfc$mc_type_205, rfc$mc_type_inet, rfc$mc_type_ntn),
     rft$nad_queue_limit = 0..rfc$max_nad_queue_limit,
     rft$nad_trace_parameter = 0..rfc$max_trace_size,
     rft$connection_password = string(rfc$connection_pw_length),
     rft$subsystem_identifier = string(rfc$subsystem_id_length),
     rft$logical_ids_per_host = 0..rfc$max_logical_ids_per_host,
     rft$paths_per_host = 0..rfc$max_paths_per_host,
     rft$tcu_mask = packed array [rfc$min_tcu..rfc$max_tcu] of boolean,
     rft$logical_network = rfc$min_logical_network..rfc$max_logical_network,
     rft$logical_nad = rfc$min_logical_nad..rfc$max_logical_nad,
     rft$local_nads = 0..rfc$max_local_nads,
     rft$remote_nads = 0..rfc$max_remote_nads,
     rft$network_break_reason_code = rfc$min_network_reason_code..
       rfc$max_network_reason_code,
     rft$destination_device_address = rfc$min_destination_device_addr..
       rfc$max_destination_device_addr,
     rft$destination_device = rfc$min_host_connect..rfc$max_host_connect;

{    End of RHFAM/VE status table entries........

?? PUSH (LISTEXT := ON) ??
*copyc cmt$channel_ordinal
*copyc cmt$pp_identification
*copyc iot$logical_unit
*copyc iot$pp_number
*copyc ost$name
*copyc ost$physical_channel_number
*copyc ost$signature_lock
*copyc ost$date_time
*copyc rfc$configuration_defs
*copyc rft$host_identifier
*copyc rft$outgoing_control_messages
*copyc rft$connection_entry
?? POP ??
