MODULE iom$process_io_completions;
?? RIGHT := 110 ??

?? NEWTITLE := '  Global Declarations Referenced by this module' ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$mainframe_wired
*copyc oss$mainframe_wired_literal
*copyc ioc$unsolicited_response_codes
*copyc ioe$st_errors
*copyc amt$file_byte_address
*copyc amt$preset_value
*copyc cmt$controller_type
*copyc cmt$element_access
*copyc cmt$element_capabilities
*copyc cmt$signal_contents
*copyc dft$moved_fs_response_buffer
*copyc dmt$minimum_allocation_unit
*copyc dmt$ms_logical_device_address
*copyc gft$system_file_identifier
*copyc iot$completion_status
*copyc iot$cylinder
*copyc iot$disk_detailed_status_844
*copyc iot$disk_request
*copyc iot$disk_statistics
*copyc iot$disk_type_table
*copyc iot$disk_usage
*copyc iot$down_status
*copyc iot$io_function
*copyc iot$io_request
*copyc iot$logical_unit
*copyc iot$moved_response_buffer
*copyc iot$pp_interface_table
*copyc iot$pp_response
*copyc iot$pp_table
*copyc iot$request_heap_map
*copyc iot$unit_type
*copyc jmt$ijl_ordinal
*copyc mmt$io_identifier
*copyc mmt$rma_list
*copyc mtt$smu_communications_block
*copyc ost$simulated_disk_fault
*copyc syt$monitor_status
?? POP ??
*copyc i#fill
*copyc clp$trimmed_string_size
*copyc dfp$fetch_server_iocb
*copyc dfp$process_error_log_response
*copyc dmp$get_recorded_vsn
*copyc dmp$transfer_unit_completed
*copyc dmp$volume_down
*copyc dmp$volume_up
*copyc dpp$convert_int_to_str_dec
*copyc dpp$convert_int_to_str_hex
*copyc dpp$convert_int_to_str_octal
*copyc dpp$display_error
*copyc dsp$mtr_save_disk_error
*copyc dsp$report_system_message
*copyc iop$down_disk_channel
*copyc iop$down_disk_controller
*copyc iop$down_disk_unit
*copyc iop$tape_process_pp_response
*copyc mmp$determine_error_state
*copyc mmp$mtr_process_io_completion
*copyc mmp$mtr_process_server_complete
*copyc mmp$process_read_ahead_complete
*copyc mmp$unlock_rma_list
*copyc mtp$error_stop
*copyc tmp$send_signal
*copyc cmv$controller_address
*copyc cmv$enable_head_shift_message
*copyc cmv$logical_pp_table_p
*copyc cmv$logical_unit_table
*copyc cmv$max_number_of_pp
*copyc dfv$monitor_io_start_time
*copyc iov$disk_type_table
*copyc mtv$scb
*copyc tmv$system_job_monitor_gtid
*copyc i$real_memory_address

  VAR
    osv$debug: [XREF] array [0 .. 15] of integer;

?? OLDTITLE ??
?? NEWTITLE := '  Global Declarations Decalred by this module' ??

  VAR
    iov$stream_requests: [XDCL, #GATE, oss$mainframe_wired] array [0 .. 300] of ^iot$io_request,
    iov$invalid_2: [XDCL, #GATE, oss$mainframe_wired] integer := 0,
    iov$invalid_3: [XDCL, #GATE, oss$mainframe_wired] integer := 0,

    iov$start_ioc: [XDCL, #GATE, oss$mainframe_wired] integer := 0,
    iov$stop_ioc: [XDCL, #GATE, oss$mainframe_wired] integer := 0,


    iov$stream_requests_end: [XDCL, #GATE, oss$mainframe_wired] array [0 .. 300] of ^^iot$io_request,

    iov$empty_requests: [XREF] ^iot$io_request,

    iov$empty_requests_end: [XREF] ^^iot$io_request,

    iov$empty_request_count: [XREF] integer,

    iov$request_heap_map: [XREF] iot$request_heap_map,

    iov$command_heap_map: [XREF] iot$command_heap_map,

    iov$process_disk_response: [XDCL, #GATE, oss$mainframe_wired] iot$response_processor :=
          ^iop$process_disk_response,

    osv$simulated_disk_fault: [XDCL, #GATE] array [1 .. osc$max_simulated_faults] of
          ost$simulated_disk_fault := [REP 5 of [FALSE, * , * , * , * , * , * , * , * , * , * ]],

    osv$disk_fault_simulation: [XDCL, #GATE] boolean := FALSE,


    iov$disk_pp_usage_p: [XDCL, STATIC, #GATE, oss$mainframe_wired] ^iot$disk_pp_array := NIL,

    iov$disk_unit_usage_p: [XDCL, STATIC, #GATE, oss$mainframe_wired] ^iot$disk_unit_array := NIL;

  VAR
    iov$unrecovered_disk_errors: [XDCL, oss$mainframe_wired] integer := 0,

    iov$error_count: [XDCL, oss$mainframe_wired] integer := 0,

    iov$detailed_status_buffer: [XDCL, oss$mainframe_wired] array [1 .. 20] of iot$disk_log_data_full;

  VAR
    iov$accept_pico_statistics: [XDCL, #GATE, oss$mainframe_wired] boolean := FALSE,
    iov$pico_statistics_call_count: [XDCL, #GATE, oss$mainframe_wired] integer := 0,
    iov$pico_statistics_skip_count: [XDCL, #GATE, oss$mainframe_wired] integer := 0,
    iov$pico_unsolicited_msg_count: [XDCL, #GATE, oss$mainframe_wired] integer := 0;

  CONST
    c$max_pico_channels = 6, {we currently have 5 picos...
    c$pico_channel_index_max = c$max_pico_channels - 1,
    c$pico_status_message_count = 21,
    c$pico_status_msg_index_max = c$pico_status_message_count - 1,
    c$pico_status_msg_value_cnt_max = 64;

  TYPE
    t$channel_pico_status_messages = array [0 .. c$pico_channel_index_max] of t$pico_status_messages,
    t$pico_status_messages = array [0 .. c$pico_status_msg_index_max] of t$pico_status_message,
    t$pico_status_message = record
      request_clock: integer,
      response_clock: integer,
      ipi_channel_status_register: 0 .. 0ffff(16),
      ipi_channel_error_register: 0 .. 0ffff(16),
      ipi_dma_register: 0 .. 0ffff(16),
      operation_status_register: 0 .. 0ffff(16),
      values: array [1 .. c$pico_status_msg_value_cnt_max] of 0 .. 0ffff(16),
    recend;

  TYPE
    t$pico_channel_status_msg_index = array [0 .. c$pico_channel_index_max] of record
      iou: dst$iou_number,
      channel_number: ost$physical_channel_number,
      message_index: 0 .. 0ff(16),
      skipped_message_index: 0 .. 0ff(16),
    recend;

  TYPE
    t$channel_pico_status_counters = array [0 .. c$pico_channel_index_max] of t$channel_pico_status_counter,
    t$channel_pico_status_counter = array [0 .. 3] of t$pico_status_counters, {we have 4 counters
    t$pico_status_counters = array [0 .. 15] of integer;

  VAR
    iov$pico_channel_stat_msg_index: [XDCL, #GATE, oss$mainframe_wired] t$pico_channel_status_msg_index :=
          [REP c$max_pico_channels of [0, 0, c$pico_status_msg_index_max, c$pico_status_msg_index_max]],
    iov$pico_status_messages: [XDCL, #GATE, oss$mainframe_wired] t$channel_pico_status_messages :=
          [REP c$max_pico_channels of [REP c$pico_status_message_count of
          [0, 0, 0, 0, 0, 0, [REP c$pico_status_msg_value_cnt_max of 0]]]],
    iov$pico_status_counters: [XDCL, #GATE, oss$mainframe_wired] t$channel_pico_status_counters :=
          [REP c$max_pico_channels of [REP 4 of [REP 16 of 0]]],

    iov$skipped_pico_status_msgs: [XDCL, STATIC, #GATE, oss$mainframe_wired]
          t$channel_pico_status_messages := [REP c$max_pico_channels of
          [REP c$pico_status_message_count of [0, 0, 0, 0, 0, 0,
          [REP c$pico_status_msg_value_cnt_max of 0]]]],

    iov$pico_timed_request: [XDCL, STATIC, #GATE, oss$mainframe_wired] integer := 0;


?? TITLE := 'iop$process_io_completions', EJECT ??

  PROCEDURE [XDCL] iop$process_io_completions;

    VAR
      pp_response: [STATIC] iot$pp_response := [
{ FILL1                      } 0,
{ REQUEST                    } NIL,
{ FILL2                      } 0,
{ REQUEST_RMA                } 0,
{ RESPONSE_LENGTH            } 40,
{ LOGICAL_UNIT               } 0,
{ RECOVERY                   } ioc$attempt_recovery,
{ INTERRUPT                  } [FALSE, 1],
{ PRIORITY                   } 1,
{ ALERT_MASK                 } [FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, 0],
{ ABNORMAL_STATUS            } [FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 0],
{ INTERFACE_ERROR_CODE       } 0,
{ RESPONSE_CODE              } [ioc$normal_response, 0, 0],
{ UNSOLICITED_RESPONSE_CODE  } 0,
{ ALERT_CONDITIONS           } [FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 0],
{ TRANSFER_COUNT             } 0,
{ LAST_COMMAND               } 0];

    VAR
      cell_p: ^cell,
      current_response_p: ^cell,
      d_status: syt$monitor_status,
      detailed_length: 0 .. 0ffff(16),
      detailed_p: ^cell,
      detailed_seq_p: ^iot$detailed_seq,
      detailed_status_buffer: iot$detailed,
      detailed_status_buffer_p: ^iot$detailed,
      detailed_status_p: ^iot$detailed_status,
      handlers_p: ^cmt$logical_pp_handlers,
      in_pointer: iot$response_buffer_offset,
      moved_fs_response_buffer: dft$moved_fs_response_buffer,
      moved_response_buffer: iot$moved_response_buffer,
      new_out: iot$response_buffer_offset,
      p_fs_error_log_response: ^dft$fs_error_log_response,
      p_one_word_response: ^dft$fs_pp_response,
      pp: 1 .. ioc$pp_count,
      pp_interface_table_p: ^iot$pp_interface_table,
      pp_response_p: ^iot$pp_response,
      remain: integer,
      response_length: 0 .. 0ffff(16),
      response_p: ^array [0 .. ioc$response_buffer_length_b] of ost$byte,
      rest: integer,
      short_response_p: ^iot$short_response,
      special_response: boolean,
      total_response_length: iot$response_buffer_offset,
      valid_response: boolean;

?? NEWTITLE := 'MOVE_BYTES', EJECT ??

    PROCEDURE [INLINE] move_bytes
      (    source: ^cell;
           dest: ^cell;
           length: 0 .. ioc$response_buffer_length_b);

      VAR
        str1: ^string (ioc$response_buffer_length_b),
        str2: ^string (ioc$response_buffer_length_b);

?? PUSH (CHKRNG := OFF, CHKSUB := OFF) ??
      IF length <> 0 THEN
        str1 := source;
        str2 := dest;
        str2^ (1, length) := str1^ (1, length);
        #SPOIL (str2^);
      IFEND;
?? POP ??
    PROCEND move_bytes;
?? OLDTITLE ??
?? EJECT ??
    iov$start_ioc := iov$start_ioc + 1;

    IF cmv$logical_pp_table_p = NIL THEN
      RETURN; {----->
    IFEND;

    FOR pp := 1 TO cmv$max_number_of_pp DO
      IF cmv$logical_pp_table_p^ [pp].flags.configured THEN
        pp_interface_table_p := cmv$logical_pp_table_p^ [pp].pp_info.pp_interface_table_p;

        IF (pp_interface_table_p <> NIL) AND (pp_interface_table_p^.inn <> pp_interface_table_p^.out) THEN
          handlers_p := ^cmv$logical_pp_table_p^ [pp].handlers;

          {Note, pp_interface_table_p^.inn must be moved to a different
          {location because otherwise the pp can change the value, and
          {thereby, cause a problem.}
          in_pointer := pp_interface_table_p^.inn;
          IF in_pointer > pp_interface_table_p^.out THEN
            total_response_length := in_pointer - pp_interface_table_p^.out;
          ELSE
            total_response_length := pp_interface_table_p^.limit - pp_interface_table_p^.out + in_pointer;
          IFEND;

{get pp_response.}

        /loop1/
          WHILE total_response_length > 0 DO

            current_response_p := ^pp_interface_table_p^.response_buffer^ [pp_interface_table_p^.out];

{ Look for short disk responses.
            IF handlers_p^.response_handler_p = ^iop$process_disk_response THEN
              short_response_p := current_response_p;
              IF short_response_p^.flags.one_word_response THEN
                pp_response.request := short_response_p^.request;
                pp_response.request^.response_processor_p^ (^pp_response, NIL, pp, d_status);

                IF NOT d_status.normal THEN
                  EXIT /loop1/; {----->
                IFEND;

                pp_interface_table_p^.out := pp_interface_table_p^.out + 8;
                IF pp_interface_table_p^.out = pp_interface_table_p^.limit THEN
                  pp_interface_table_p^.out := 0;
                IFEND;
                total_response_length := total_response_length - 8;
                CYCLE /loop1/; {----->
              IFEND;
            IFEND;

{ Look for file server responses.
            special_response := FALSE;
            IF handlers_p^.one_word_response_allowed THEN
              dfv$monitor_io_start_time := #FREE_RUNNING_CLOCK (0);

              p_one_word_response := current_response_p;
              IF p_one_word_response^.response_flags.special_response THEN
                special_response := TRUE;
                response_length := p_one_word_response^.response_length;
                IF (response_length > dfc$max_fs_pp_response_length) OR
                      (response_length > total_response_length) THEN
                  mtp$error_stop ('IO01 - invalid pp response');
                IFEND;

                IF p_one_word_response^.response_flags.one_word_response THEN
                  handlers_p^.one_word_response_handler_p^ (p_one_word_response, pp, d_status);

                ELSEIF p_one_word_response^.response_flags.error_log_response THEN
                  response_p := current_response_p;
                  IF pp_interface_table_p^.limit - pp_interface_table_p^.out >= response_length THEN
                    cell_p := ^response_p^ [#SIZE (p_one_word_response^)];
                    p_fs_error_log_response := cell_p;
                  ELSE { Move necessary.
                    remain := ((pp_interface_table_p^.limit - pp_interface_table_p^.out) -
                          #SIZE (p_one_word_response^));
                    move_bytes (^response_p^ [#SIZE (p_one_word_response^)],
                          ^moved_fs_response_buffer.bytes [0], remain);
                    rest := response_length - #SIZE (p_one_word_response^) - remain;
                    move_bytes (pp_interface_table_p^.response_buffer, ^moved_fs_response_buffer.
                          bytes [remain], rest);
                    p_fs_error_log_response := ^moved_fs_response_buffer.response;
                  IFEND;
                  dfp$process_error_log_response (p_one_word_response, p_fs_error_log_response, pp, d_status);

                ELSE { Invalid special response.
                  mtp$error_stop ('IO01 - invalid pp response');
                IFEND;
              IFEND;
            IFEND;

{ General response format.
            IF NOT special_response THEN
              IF pp_interface_table_p^.limit - pp_interface_table_p^.out >= ioc$min_response_length THEN
                pp_response_p := current_response_p;
              ELSE { Move is necessary.
                remain := (pp_interface_table_p^.limit - pp_interface_table_p^.out);
                move_bytes (current_response_p, ^moved_response_buffer.bytes [0], remain);
                rest := ioc$min_response_length - remain;
                move_bytes (pp_interface_table_p^.response_buffer, ^moved_response_buffer.bytes [remain],
                      rest);
                pp_response_p := ^moved_response_buffer.response;
              IFEND;

              response_length := pp_response_p^.response_length;
              IF (response_length < ioc$min_response_length) OR (response_length > total_response_length) THEN
                mtp$error_stop ('IO01 - invalid pp response');
              IFEND;

{ Process detailed status.}
              IF response_length = ioc$min_response_length THEN
                detailed_status_p := NIL;

              ELSE
                new_out := pp_interface_table_p^.out + ioc$min_response_length;
                IF new_out >= pp_interface_table_p^.limit THEN
                  new_out := new_out - pp_interface_table_p^.limit;
                IFEND;
                detailed_p := ^pp_interface_table_p^.response_buffer^ [new_out];

                detailed_length := response_length - ioc$min_response_length;
                IF pp_interface_table_p^.limit - new_out >= detailed_length THEN
                  move_bytes (detailed_p, ^detailed_status_buffer.bytes [0], detailed_length);
                  detailed_status_p := ^detailed_status_buffer.detailed_status;
                ELSE
                  detailed_status_p := ^detailed_status_buffer.detailed_status;
                  remain := (pp_interface_table_p^.limit - new_out);
                  move_bytes (detailed_p, ^detailed_status_buffer.bytes [0], remain);
                  rest := detailed_length - remain;
                  move_bytes (pp_interface_table_p^.response_buffer, ^detailed_status_buffer.bytes [remain],
                        rest);
                IFEND;
                RESET detailed_status_p;
              IFEND;

              iov$stop_ioc := iov$stop_ioc + 1;

{ Call response processor for each io_type.

              valid_response := NOT pp_response_p^.abnormal_status.interface_error;
              IF NOT valid_response THEN

{ We can't call the response processor if there's an interface error
{ because the request address might be garbage.

                iov$invalid_2 := iov$invalid_2 + 1;
              IFEND;

              IF ((pp_response_p^.request_rma = 0) OR (pp_response_p^.request = NIL)) AND
                    (pp_response_p^.response_code.primary_response <> ioc$unsolicited_response) THEN

{ We can't call a zero or Nil response address without crashing.

                valid_response := FALSE;
                iov$invalid_3 := iov$invalid_3 + 1;
              IFEND;

              IF (pp_response_p^.response_code.primary_response <> ioc$unsolicited_response) AND
                    (valid_response) THEN
                pp_response_p^.request^.response_processor_p^ (pp_response_p, detailed_status_p, pp,
                      d_status);
              ELSE
                handlers_p^.response_handler_p^ (pp_response_p, detailed_status_p, pp, d_status);
              IFEND;
            IFEND { end NOT special_response } ;

            IF NOT d_status.normal THEN
              EXIT /loop1/; {----->
            IFEND;


{ Update out pointer for response buffer.}

            IF (pp_interface_table_p^.out + response_length) < pp_interface_table_p^.limit THEN
              pp_interface_table_p^.out := pp_interface_table_p^.out + response_length;
            ELSE
              pp_interface_table_p^.out := pp_interface_table_p^.out + response_length -
                    pp_interface_table_p^.limit;
            IFEND;

{ Loop if more requests to process.}

            total_response_length := total_response_length - response_length;
          WHILEND /loop1/;

        IFEND;
      IFEND;
    FOREND;

  PROCEND iop$process_io_completions;
?? TITLE := 'iop$process_disk_response', EJECT ??

  PROCEDURE [XDCL] iop$process_disk_response
    (    pp_response_p: ^iot$pp_response;
         detailed_status_p: ^iot$detailed_status;
         pp: 1 .. ioc$pp_count;
     VAR status: syt$monitor_status);

    VAR
      active_pp: ^iot$disk_pp_usage,
      active_unit: ^iot$disk_unit_usage,
      address_pair_count: mmt$rma_list_length,
      au_was_previously_written: boolean,
      byte_address: amt$file_byte_address,
      c_index: 0 .. ioc$command_map_count,
      c_status: syt$monitor_status,
      channel: cmt$physical_channel,
      completed_request_p: ^iot$disk_request,
      critical: boolean,
      cylinder: iot$cylinder,
      d_index: 0 .. 0ffff(16),
      data_and_preset_maus: dmt$mau_address,
      data_maus: dmt$mau_address,
      data_transfer_time: integer,
      down_status: iot$down_status,
      equipment: 0 .. 0ff(16),
      index: 0 .. ioc$request_heap_count,
      io_function: iot$io_function,
      iou_number: dst$iou_number,
      job_id: jmt$ijl_ordinal,
      list_p: ^mmt$rma_list,
      logical_unit: iot$logical_unit,
      lud: integer,
      m: 0 .. ioc$command_map_count,
      m_status: syt$monitor_status,
      mau_offset_in_cylinder: dmt$maus_per_position,
      media_error: boolean,
      normal: iot$io_error,
      physical_unit: 0 .. 0ff(16),
      port_index: 0 .. 1,
      power_failing: boolean,
      pp_interface_table_p: ^iot$pp_interface_table,
      qtime: integer,
      requested_cylinder: iot$cylinder,
      response_time: integer,
      sector: iot$sector,
      seek_and_latency_time: integer,
      server_iocb_p: ^mmt$server_iocb_entry,
      system_file_id: gft$system_file_identifier,
      t_status: syt$monitor_status,
      time: integer,
      track: iot$track,
      u: iot$logical_unit,
      ud: integer,
      write_tu_status: dmt$write_tu_status;

    iov$start_ioc := iov$start_ioc + 1;

    status.normal := TRUE;

    pp_interface_table_p := cmv$logical_pp_table_p^ [pp].pp_info.pp_interface_table_p;
    IF pp_response_p^.response_code.primary_response <> ioc$unsolicited_response THEN
      completed_request_p := pp_response_p^.request^.device_request_p;
      logical_unit := completed_request_p^.request.logical_unit;
      ud := logical_unit;
    ELSE
      completed_request_p := NIL;
      logical_unit := pp_response_p^.logical_unit;



    /find_ud/
      BEGIN
        FOR ud := UPPERBOUND (pp_interface_table_p^.unit_descriptors)
              DOWNTO LOWERBOUND (pp_interface_table_p^.unit_descriptors) DO
          IF pp_interface_table_p^.unit_descriptors [ud].logical_unit = logical_unit THEN
            EXIT /find_ud/; {----->
          IFEND;
        FOREND;
        logical_unit := pp_interface_table_p^.unit_descriptors [ud].logical_unit;
      END /find_ud/;
    IFEND;


    d_index := cmv$logical_unit_table^ [logical_unit].unit_interface_table^.unit_type - 100(16) + 1;
    iou_number := cmv$logical_pp_table_p^ [pp].pp_info.channel.iou_number;
    channel.number := pp_interface_table_p^.unit_descriptors [ud].physical_path.channel_number;
    channel.concurrent := cmv$logical_pp_table_p^ [pp].pp_info.channel_interlock_p^.
          channel_characteristics [channel.number].concurrent_channel;
    port_index := 0;
    channel.port := cmc$unspecified_port;
    IF channel.concurrent THEN
      IF (((d_index > (ioc$dt_msxmd_3 - 100(16))) AND (d_index < (ioc$dt_msntdd_6 - 100(16) + 2)))) OR
            (d_index = (ioc$dt_mshydra - 100(16) + 1)) THEN
        IF pp_interface_table_p^.unit_descriptors [ud].physical_path.port = 0 THEN
          channel.port := cmc$port_a;
        ELSE
          channel.port := cmc$port_b;
          port_index := 1;
        IFEND;
      IFEND;
    IFEND;
    equipment := pp_interface_table_p^.unit_descriptors [ud].physical_path.controller_number;
    physical_unit := pp_interface_table_p^.unit_descriptors [ud].physical_path.physical_unit_number;
    cylinder := 0;
    mau_offset_in_cylinder := 0;

    c_status.condition := 0;
    normal := ioc$no_error;
    media_error := FALSE;
    write_tu_status := dmc$tu_written;
*if false
    IF osv$disk_fault_simulation AND (completed_request_p <> NIL) THEN
      simulate_disk_fault (completed_request_p, normal);
      IF normal <> ioc$no_error THEN
        write_tu_status := dmc$tu_not_written;
        cylinder := completed_request_p^.request.cylinder;
        track := completed_request_p^.request.track;
        sector := completed_request_p^.request.sector;
        mau_offset_in_cylinder := (track * iov$disk_type_table [d_index].sectors_per_track + sector) DIV
              iov$disk_type_table [d_index].sectors_per_mau;
        IF normal = ioc$media_error THEN
          media_error := TRUE;
          c_status.condition := ioc$disk_media_error;
        ELSEIF normal = ioc$unrecovered_error_unit_down THEN
          c_status.condition := ioe$unit_disabled;
        ELSE
          c_status.condition := ioc$unrecovered_disk_error;
        IFEND;
      IFEND;
    IFEND;
*ifend
    power_failing := (mtv$scb.nos_180_status.idle_code = syc$ic_long_power);

{If the system is attempting to idle due to failing power then don't
{be concerned about errors on devices that don't have UPS power backup.
{We need all the CPU resources at this time just to get the processor
{idled down.

    IF (pp_response_p^.response_code.primary_response <> ioc$normal_response) OR
          (detailed_status_p <> NIL) AND (NOT power_failing) THEN

      IF NOT ((d_index >= ioc$dt_msntdd_1 - 100(16) + 1) AND (d_index <= ioc$dt_msntdd_6 - 100(16) + 1)) THEN
{Log error.
        iop$log_disk_error (pp_response_p, detailed_status_p, pp, iou_number, completed_request_p,
              logical_unit, channel, equipment, physical_unit, ud, mau_offset_in_cylinder, cylinder,
              down_status);

      ELSEIF (pp_response_p^.response_code.primary_response = ioc$unsolicited_response)
{   } AND (pp_response_p^.unsolicited_response_code = ioc$statistics_report) THEN
        IF NOT iov$accept_pico_statistics THEN
          iov$pico_statistics_skip_count := iov$pico_statistics_skip_count + 1;
          RETURN; {----->
        IFEND;

        iop$process_pico_statistics (pp_response_p, detailed_status_p, pp, iou_number, channel, equipment,
              logical_unit, down_status);

      ELSE {A Pico device but not one of this Pico statistics
        {Temporary count in case we crash
        iov$pico_unsolicited_msg_count := iov$pico_unsolicited_msg_count + 1;

        {We give it a try, now.
        iop$log_disk_error (pp_response_p, detailed_status_p, pp, iou_number, completed_request_p,
              logical_unit, channel, equipment, physical_unit, ud, mau_offset_in_cylinder, cylinder,
              down_status);
      IFEND;

      IF down_status <> ioc$no_change THEN
        CASE down_status OF
        = ioc$channel_down =
          iop$down_disk_channel (pp, channel, t_status);
          RETURN; {----->
        = ioc$controller_down =
          iop$down_disk_controller (pp, channel, equipment, t_status);
          RETURN; {----->
        = ioc$unit_down =
          iop$down_disk_unit (pp, channel, equipment, physical_unit, logical_unit, t_status);
          RETURN; {----->
{       = ioc$executing_diagnostics =
{         IF pp_response_p^.response_code.primary_response <>
{               ioc$unsolicited_response THEN
{           cmv$logical_unit_table^ [logical_unit].element_capability :=
{                 $cmt$element_capabilities [cmc$concurrent_maintenance];
{           dmp$volume_down (logical_unit, critical);
{         IFEND;
        ELSE
        CASEND;
      IFEND;


      IF (pp_response_p^.response_code.primary_response = ioc$intermediate_response) OR
            (pp_response_p^.response_code.primary_response = ioc$unsolicited_response) THEN
        RETURN; {----->
      IFEND;


      IF pp_response_p^.response_code.primary_response = ioc$abnormal_response THEN
        normal := ioc$unrecovered_error;
        write_tu_status := dmc$tu_not_written;
        c_status.condition := ioc$unrecovered_disk_error;
        IF (pp_response_p^.abnormal_status.recording_medium_error = TRUE) THEN
          normal := ioc$media_error;
          media_error := TRUE;
          c_status.condition := ioc$disk_media_error;
        IFEND;
        IF (completed_request_p^.request_info.request_type <> ioc$device_io) AND
              (NOT completed_request_p^.request_info.au_was_previously_written) THEN
          normal := ioc$error_on_init;
        IFEND;
        IF (iov$disk_unit_usage_p <> NIL) AND (iov$disk_unit_usage_p^ [logical_unit] <> NIL) THEN
          IF iov$disk_unit_usage_p^ [logical_unit]^.last_request_good THEN
            dsp$mtr_save_disk_error (dsc$ssr_sds_disk_request_bad, #FREE_RUNNING_CLOCK (0),
                  iov$disk_unit_usage_p^ [logical_unit]^.element_name);
            iov$disk_unit_usage_p^ [logical_unit]^.last_request_good := FALSE;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    IF (detailed_status_p <> NIL) AND (pp_response_p^.abnormal_status.recording_medium_error = TRUE) AND
       ((d_index = ioc$dt_ms5833_3p - 0ff(16)) OR (d_index = ioc$dt_ms5833_1p - 00ff(16)) OR
        (d_index = ioc$dt_ms5837_3p - 0ff(16)) OR (d_index = ioc$dt_ms5837_1p - 00ff(16)) OR
        (d_index = ioc$dt_ms5838_3p - 0ff(16)) OR (d_index = ioc$dt_ms5838_1p - 00ff(16)) OR
        (d_index = ioc$dt_ms47444_3p - 0ff(16)) OR (d_index = ioc$dt_ms47444_1p - 00ff(16))) THEN
      media_error := TRUE;
    IFEND;

    requested_cylinder := completed_request_p^.request.cylinder;
    data_maus := completed_request_p^.request_info.data_maus;
    data_and_preset_maus := completed_request_p^.request.mau_count;


{Unlock pages.

    IF completed_request_p^.request_info.list_length <> 0 THEN
      io_function := completed_request_p^.request_info.io_function;
      list_p := completed_request_p^.request_info.list_p;
      address_pair_count := completed_request_p^.request_info.list_length;
      system_file_id := completed_request_p^.request_info.system_file_id;
      mmp$unlock_rma_list (io_function, list_p, address_pair_count,
            completed_request_p^.request_info.io_identifier, (system_file_id.residence = gfc$tr_job), normal,
            m_status);
      IF m_status.normal = FALSE THEN
        mtp$error_stop ('IO12 - abnormal unlock status');
      IFEND;

{ It is possible that the job has terminated or the file deleted if this io completion is
{ for a local file write.  If it completed normally we are ok.  If there was an error we
{ do not want to try and flaw it in dmp$transfer_unit_completed. So, we will lie and say
{ write_tu_status is written.  Mmp$unlock_rma_list sets normal to ioc$no_error after
{ it has processed the error.  The error will not be processed if the page is in the
{ free queue (i.e. the job had terminated or the file deleted) and normal will not be
{ reset.

      IF (write_tu_status = dmc$tu_not_written) AND (completed_request_p^.request_info.system_file_id.
            residence = gfc$tr_job) AND ((io_function = ioc$write_page) OR
            (io_function = ioc$write_locked_page)) AND (normal <> ioc$no_error) THEN
        write_tu_status := dmc$tu_written;
      IFEND;
    IFEND;

{Call mmp$mtr_process_io_completion.
{ Possible file server completion handling is determined by IO_FUNCTION.

    IF completed_request_p^.request_info.io_identifier.specified THEN
      c_status.normal := normal = ioc$no_error;
      CASE io_function OF
      = ioc$read_for_server .. ioc$write_to_client =
        dfv$monitor_io_start_time := #FREE_RUNNING_CLOCK (0);
        dfp$fetch_server_iocb (completed_request_p^.request_info.io_identifier.queue_entry_location,
              server_iocb_p);
        mmp$mtr_process_server_complete (dfc$completing_previous_request,
              completed_request_p^.request_info.io_identifier, server_iocb_p, c_status);
      = ioc$read_ahead_on_server =
        mmp$process_read_ahead_complete (completed_request_p^.request_info.io_identifier, c_status);
      ELSE
        mmp$mtr_process_io_completion (completed_request_p^.request_info.io_identifier, io_function,
              c_status);
      CASEND;
    IFEND;

{check if transfer unit was previously written.}
    IF completed_request_p^.request_info.request_type <> ioc$device_io THEN
      job_id := completed_request_p^.request_info.job_id;
      system_file_id := completed_request_p^.request_info.system_file_id;
      byte_address := completed_request_p^.request_info.byte_address;
      au_was_previously_written := completed_request_p^.request_info.au_was_previously_written;
      dmp$transfer_unit_completed (job_id, system_file_id, byte_address, write_tu_status,
            au_was_previously_written, media_error, cylinder, mau_offset_in_cylinder, io_function, t_status);
      IF t_status.normal = FALSE THEN
        mtp$error_stop ('IO13 - abnormal dmp status');
      IFEND;

{If ioc$device_io request, return completion status.
    ELSE
      IF normal = ioc$no_error THEN
        completed_request_p^.request_info.completion^ := 1;
      ELSE
        completed_request_p^.request_info.completion^ := 2;
      IFEND;
    IFEND;

{ Put request on empty chain.
{ Clear request packet allocation.}

    completed_request_p^.link := NIL;

    IF NOT completed_request_p^.request.pp_switch THEN
      IF (iov$stream_requests [logical_unit] <> NIL) AND (cmv$logical_unit_table^ [logical_unit].
            unit_interface_table^.queue_count = 0) THEN
        iov$empty_requests_end^ := iov$stream_requests [logical_unit];
        iov$empty_requests_end := iov$stream_requests_end [logical_unit];
        iov$stream_requests_end [logical_unit] := ^iov$stream_requests [logical_unit];
        iov$stream_requests [logical_unit] := NIL;
      IFEND;

      iov$empty_requests_end^ := pp_response_p^.request;
      iov$empty_requests_end := ^completed_request_p^.link;
    ELSE
      iov$stream_requests_end [logical_unit]^ := pp_response_p^.request;
      iov$stream_requests_end [logical_unit] := ^completed_request_p^.link;
    IFEND;

    index := completed_request_p^.request_index;
    IF iov$request_heap_map [index] = FALSE THEN
      mtp$error_stop ('IO02 - invalid pp response');
    IFEND;
    iov$request_heap_map [index] := FALSE;
    iov$empty_request_count := iov$empty_request_count + 1;

    IF completed_request_p^.request_info.command_group_count <> 0 THEN
      c_index := completed_request_p^.request_info.command_index;
      FOR m := 0 TO completed_request_p^.request_info.command_group_count - 1 DO
        IF iov$command_heap_map [c_index + m] = FALSE THEN
          mtp$error_stop ('IO03 - invalid pp response');
        IFEND;
        iov$command_heap_map [c_index + m] := FALSE;
      FOREND;
    IFEND;

{Update usage counters.

    IF pp_response_p^.response_code.primary_response = ioc$normal_response THEN
      IF (iov$disk_unit_usage_p <> NIL) AND (iov$disk_pp_usage_p <> NIL) THEN
        active_pp := iov$disk_pp_usage_p^ [pp];
        active_unit := iov$disk_unit_usage_p^ [logical_unit];
        IF (active_pp <> NIL) AND (active_unit <> NIL) THEN
          active_unit^.unit_used := TRUE;
          active_pp^.path_usage [port_index] [equipment].path_used := TRUE;
          time := #FREE_RUNNING_CLOCK (0);
          qtime := time - completed_request_p^.request_info.time;
          IF completed_request_p^.request.command [1].command_code = ioc$cc_read_bytes THEN
            active_pp^.path_usage [port_index] [equipment].read_requests := active_pp^.
                  path_usage [port_index] [equipment].read_requests + 1;
            active_pp^.path_usage [port_index] [equipment].read_maus :=
                  active_pp^.path_usage [port_index] [equipment].read_maus + data_maus;
            IF completed_request_p^.request_info.io_function = ioc$swap_in THEN
              active_unit^.swap_in_requests := active_unit^.swap_in_requests + 1;
              active_unit^.swap_in_qtime := active_unit^.swap_in_qtime + qtime;
              active_unit^.swap_in_mau_count := active_unit^.swap_in_mau_count + data_maus;
            ELSE
              active_unit^.read_requests := active_unit^.read_requests + 1;
              active_unit^.read_qtime := active_unit^.read_qtime + qtime;
              active_unit^.read_mau_count := active_unit^.read_mau_count + data_maus;
            IFEND;
          ELSE
            active_pp^.path_usage [port_index] [equipment].write_requests := active_pp^.
                  path_usage [port_index] [equipment].write_requests + 1;
            active_pp^.path_usage [port_index] [equipment].written_and_preset_maus := active_pp^.
                  path_usage [port_index] [equipment].written_and_preset_maus + data_and_preset_maus;
            IF completed_request_p^.request_info.io_function = ioc$swap_out THEN
              active_unit^.swap_out_requests := active_unit^.swap_out_requests + 1;
              active_unit^.swap_out_qtime := active_unit^.swap_out_qtime + qtime;
              active_unit^.swap_out_data_mau_count := active_unit^.swap_out_data_mau_count + data_maus;
              active_unit^.swap_out_data_and_preset_maus := active_unit^.swap_out_data_and_preset_maus +
                    data_and_preset_maus;
            ELSE
              active_unit^.write_requests := active_unit^.write_requests + 1;
              active_unit^.write_qtime := active_unit^.write_qtime + qtime;
              active_unit^.write_data_mau_count := active_unit^.write_data_mau_count + data_maus;
              active_unit^.write_data_and_preset_maus := active_unit^.write_data_and_preset_maus +
                    data_and_preset_maus;
            IFEND;
          IFEND;
          active_pp^.path_usage [port_index] [equipment].total_request_qtime := active_pp^.
                path_usage [port_index] [equipment].total_request_qtime + qtime;
          IF requested_cylinder <> active_unit^.current_cylinder THEN
            active_unit^.requests_causing_skipped_cyl := active_unit^.requests_causing_skipped_cyl + 1;
            IF requested_cylinder > active_unit^.current_cylinder THEN
              active_unit^.total_cylinders_skipped := active_unit^.total_cylinders_skipped +
                    requested_cylinder - active_unit^.current_cylinder;
            ELSE
              active_unit^.total_cylinders_skipped := active_unit^.total_cylinders_skipped +
                    active_unit^.current_cylinder - requested_cylinder;
            IFEND;
            active_unit^.current_cylinder := requested_cylinder;
          IFEND;
          response_time := time - active_pp^.last_response_time;
          IF qtime < response_time THEN
            response_time := qtime;
          IFEND;
          active_pp^.last_response_time := time;
          data_transfer_time := data_and_preset_maus * iov$disk_type_table [d_index].mau_time;
          seek_and_latency_time := response_time - data_transfer_time;
          active_pp^.computed_data_transfer_time := active_pp^.computed_data_transfer_time +
                data_transfer_time;
          active_pp^.seek_and_latency_time := active_pp^.seek_and_latency_time + seek_and_latency_time;
          IF active_unit^.streamed_request_possible THEN
            IF seek_and_latency_time > 16000 THEN
              IF completed_request_p^.request.command [1].command_code = ioc$cc_read_bytes THEN
                active_unit^.streamed_req_failed_count_read := active_unit^.streamed_req_failed_count_read +
                      1;
                active_pp^.streamed_req_failed_count_read := active_pp^.streamed_req_failed_count_read + 1;
              ELSE
                active_unit^.streamed_req_failed_count_write :=
                      active_unit^.streamed_req_failed_count_write + 1;
                active_pp^.streamed_req_failed_count_write := active_pp^.streamed_req_failed_count_write + 1;
              IFEND;
            ELSE
              IF completed_request_p^.request.command [1].command_code = ioc$cc_read_bytes THEN
                active_unit^.streamed_req_count_read := active_unit^.streamed_req_count_read + 1;
                active_pp^.streamed_req_count_read := active_pp^.streamed_req_count_read + 1;
              ELSE
                active_unit^.streamed_req_count_write := active_unit^.streamed_req_count_write + 1;
                active_pp^.streamed_req_count_write := active_pp^.streamed_req_count_write + 1;
              IFEND;
            IFEND;
          IFEND;
          active_unit^.streamed_request_possible := completed_request_p^.request.pp_switch;
          IF NOT active_unit^.last_request_good THEN
            dsp$mtr_save_disk_error (dsc$ssr_sds_disk_request_good, 0, active_unit^.element_name);
            active_unit^.last_request_good := TRUE;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    iov$stop_ioc := iov$stop_ioc + 1;

  PROCEND iop$process_disk_response;
?? TITLE := 'iop$log_disk_error', EJECT ??

  PROCEDURE iop$log_disk_error
    (    pp_response_p: ^iot$pp_response;
         detailed_status_p: ^iot$detailed_status;
         pp: 1 .. ioc$pp_count;
         iou_number: dst$iou_number,
         completed_request_p: ^iot$disk_request;
         logical_unit: iot$logical_unit;
         channel: cmt$physical_channel,
         equipment: 0 .. 0ff(16);
         physical_unit: 0 .. 0ff(16);
         ud: integer;
     VAR mau_offset_in_cylinder: dmt$maus_per_position;
     VAR cylinder: iot$cylinder;
     VAR down_status: iot$down_status);

    TYPE
      t$enable_head_shift_message = cmc$enable_head_shift_msg_min .. cmc$enable_head_shift_msg_used,
      t$enable_head_shift_messages = set of t$enable_head_shift_message;

    VAR
      v$das_type: [READ, oss$mainframe_wired_literal] string (224) :=
            '5832_1  5832_2  5833_1  5833_1P 5833_2  5833_3P 5833_4  ' CAT
            '5838_1  5838_1P 5838_2  5838_3P 5838_4  47444_1 47444_1P47444_2 47444_3P47444_4 ' CAT
            '5837_1  5837_1P 5837_2  5837_3P 5837_4  NTDD_1  NTDD_2  NTDD_3  NTDD_4  NTDD_5  NTDD_6';

    VAR
      bi: integer,
      detail_status_p: ^SEQ ( * ),
      track: iot$track,
      sector: iot$sector,
      disk_type: iot$unit_type,
      controller_type: integer,
      loop: boolean,
      port_index: 0 .. 1,
      d_index: 1 .. ioc$disk_type_count,
      disk_status_p: ^iot$common_disk_status,
      disk_885_status_p: ^iot$disk_detailed_status_885,
      disk_status_844_p: ^iot$disk_detailed_status_844,
      isd_status_p: ^iot$isd_status,
      hydra_status_p: ^iot$hydra_status,
      disk_status_895_p: ^iot$895_detailed_status,
      disk_status_9836_1_p: ^iot$detailed_status_9836_1,
      response_packet: iot$9836_analyzed_response_pkt,
      disk_error_9836: boolean,
      msg_type: dst$system_logging_types,
      msg_level: dst$system_message_levels,
      msg_recorded: boolean,
      unrecovered_error: 0 .. 3,
      msg: string (65),
      msg1: string (65),
      msg2: string (65),
      msg3: string (65),
      disk_log_data_p: ^iot$disk_log_data,
      seq_p: ^SEQ ( * ),
      disk_log_seq: SEQ (REP ioc$disk_log_data_length of ost$word),
      status_bytes_p: ^array [1 .. ioc$disk_detailed_status_words] of 0 .. 0ffff(16),
      i: integer,
      j: integer,
      m: integer,
      packet_length: integer,
      line_index: integer,
      word1: 0 .. 0ffff(16),
      word_p: ^ost$word,
      message_found: boolean,
      manual_intervention_code: 0 .. 0ff(16),
      system_intervention_code: 0 .. 0ff(16),
      delay_status_code: 0 .. 0ff(16),
      adapter_diagnostic_code: integer,
      level_i_diagnostic_code: 0 .. 0ff(16),
      level_ii_diagnostic_code: 0 .. 0ff(16),
      display_message: boolean,
      cell_p: ^cell,
      error_status_p: ^iot$channel_error_status,
      previous_error: boolean,
      format_message: 0 .. 0ff(16),
      signal_contents: cmt$signal_contents,
      signal: pmt$signal,
      mtr_status: syt$monitor_status,
      send_ssd_battery_signal: boolean,
      new_head_shift_display_message: boolean,
      k: integer;

    VAR {so we do not log it or call MM
      pico_special_request: boolean;

?? NEWTITLE := 'P$ANALYZE_PICO_THROTTLING_BITS', EJECT ??

    PROCEDURE p$analyze_pico_throttling_bits
      (    detailed_status_p: ^iot$detailed_status_9836_1;
           channel_number: ost$physical_channel_number;
           iou: dst$iou_number;
           completed_request_p: ^iot$disk_request);

      TYPE
        t$set = set of 0 .. 63,
        t$converter1 = record
          case integer of
          = 0 =
            i: integer,
          = 1 =
            a: array [0 .. 3] of 0 .. 0ffff(16),
          = 2 =
            s: t$set,
          casend,
        recend;

      VAR
        converter1: t$converter1,
        converter2: t$converter1,
        i: integer,
        j: integer,
        l: integer,
        msg_p: ^t$pico_status_message,
        seq_p: ^SEQ ( * ),
        value_p: ^0 .. 0ffff(16);

      VAR
        stop_p: ^cell,
        kill: cell;

?? NEWTITLE := 'P$COUNT_BITS', EJECT ??

      PROCEDURE [INLINE] p$count_bits
        (    value: 0 .. 0ffff(16);
         VAR counters: t$pico_status_counters);

        TYPE
          t$converter = record
            case boolean of
            = FALSE =
              i: 0 .. 0ffff(16),
            = TRUE =
              a: packed array [0 .. 15] of 0 .. 1,
            casend,
          recend;

        VAR
          converter: t$converter,
          k: integer;

        converter.i := value;
        FOR k := 0 TO 15 DO
          counters [k] := counters [k] + converter.a [k];
        FOREND;

      PROCEND p$count_bits;
?? OLDTITLE ??
?? EJECT ??
      IF detailed_status_p = NIL THEN
        RETURN; {----->
      IFEND;


    /find_slot/
      FOR i := LOWERBOUND (iov$pico_channel_stat_msg_index) TO UPPERBOUND (iov$pico_channel_stat_msg_index) DO
        IF (iov$pico_channel_stat_msg_index [i].channel_number = channel_number) AND
              (iov$pico_channel_stat_msg_index [i].iou = iou) THEN
          EXIT /find_slot/ {----->
        ELSEIF iov$pico_channel_stat_msg_index [i].channel_number = 0 THEN
          iov$pico_channel_stat_msg_index [i].channel_number := channel_number;
          iov$pico_channel_stat_msg_index [i].iou := iou;
          EXIT /find_slot/ {----->
        IFEND;
      FOREND /find_slot/;

      IF (iov$pico_channel_stat_msg_index [i].channel_number <> channel_number) AND
            (iov$pico_channel_stat_msg_index [i].iou <> iou) THEN
        {no room
        RETURN; {----->
      IFEND;

{Put the detailed status into the circular buffer only when PP word 6, 8(16), 23(16) of the RP are <> 0
      IF (osv$debug [15] <> 0)
{   } OR (detailed_status_p^.response_packets [13] <> 0)
{   } OR (detailed_status_p^.response_packets [14] <> 0)
{   } OR (detailed_status_p^.response_packets [17] <> 0)
{   } OR (detailed_status_p^.response_packets [18] <> 0)
{   } OR (detailed_status_p^.response_packets [71] <> 0)
{   } OR (detailed_status_p^.response_packets [72] <> 0) THEN

        iov$pico_channel_stat_msg_index [i].message_index :=
              (iov$pico_channel_stat_msg_index [i].message_index + 1) MOD c$pico_status_message_count;
        j := iov$pico_channel_stat_msg_index [i].message_index;

        msg_p := ^iov$pico_status_messages [i] [j];
      ELSE
        iov$pico_channel_stat_msg_index [i].skipped_message_index :=
              (iov$pico_channel_stat_msg_index [i].skipped_message_index + 1) MOD c$pico_status_message_count;
        j := iov$pico_channel_stat_msg_index [i].skipped_message_index;

        msg_p := ^iov$skipped_pico_status_msgs [i] [j];
      IFEND;

      IF completed_request_p = NIL THEN
        msg_p^.request_clock := 0;
      ELSE
        msg_p^.request_clock := completed_request_p^.request_info.time;
      IFEND;

      msg_p^.response_clock := #FREE_RUNNING_CLOCK (0);
      msg_p^.ipi_channel_status_register := detailed_status_p^.ipi_channel_status_register;
      msg_p^.ipi_channel_error_register := detailed_status_p^.ipi_channel_error_register;
      msg_p^.ipi_dma_register := detailed_status_p^.ipi_dma_error_register;
      msg_p^.operation_status_register := detailed_status_p^.operational_status_register;
      seq_p := #SEQ (detailed_status_p^.response_packets);
      RESET seq_p;
      FOR l := 1 TO c$pico_status_msg_value_cnt_max DO
        NEXT value_p IN seq_p;
        IF value_p = NIL THEN
          msg_p^.values [l] := 0ffff(16);
        ELSE
          msg_p^.values [l] := value_p^;
        IFEND;
      FOREND;

      IF (msg_p^.request_clock <> 0) AND (msg_p^.response_clock - msg_p^.request_clock > 1000000) THEN
        iov$pico_timed_request := iov$pico_timed_request + 1;
      IFEND;

      {Now do the counter thing - even when we discard the status.
      p$count_bits (msg_p^.ipi_channel_status_register, iov$pico_status_counters [i] [0]);
      p$count_bits (msg_p^.ipi_channel_error_register, iov$pico_status_counters [i] [1]);
      p$count_bits (msg_p^.ipi_dma_register, iov$pico_status_counters [i] [2]);
      p$count_bits (msg_p^.operation_status_register, iov$pico_status_counters [i] [3]);

      {Check for a debug halt
      converter1.a [0] := msg_p^.operation_status_register;
      converter1.a [1] := msg_p^.ipi_dma_register;
      converter1.a [2] := msg_p^.ipi_channel_error_register;
      converter1.a [3] := msg_p^.ipi_channel_status_register;
      converter2.i := osv$debug [4];

{Check if we want to halt the system.
      IF (converter1.s * converter2.s) <> $t$set [] THEN
        stop_p := NIL;
        stop_p^ := kill;
      IFEND;

    PROCEND p$analyze_pico_throttling_bits;
?? OLDTITLE ??
?? EJECT ??
    pico_special_request := FALSE;

    down_status := ioc$no_change;
    new_head_shift_display_message := FALSE;

{Put disk_log_data in a sequence.

    seq_p := ^disk_log_seq;
    RESET seq_p;
    NEXT disk_log_data_p IN seq_p;
    RESET seq_p;

    disk_log_data_p^.pp_response := pp_response_p^;
    disk_log_data_p^.iou_number := iou_number;
    disk_log_data_p^.channel := channel;
    disk_log_data_p^.equipment := equipment;
    disk_log_data_p^.logical_unit := logical_unit;
    disk_log_data_p^.diagnostic_code := 0;
    port_index := 0;
    IF channel.port = cmc$port_b THEN
      port_index := 1;
    IFEND;
    IF logical_unit >= LOWERBOUND (cmv$logical_unit_table^) THEN
      IF cmv$logical_unit_table^ [logical_unit].configured THEN
        disk_type := cmv$logical_unit_table^ [logical_unit].unit_interface_table^.unit_type;
        d_index := disk_type - 100(16) + 1;
      IFEND;
    ELSE
      disk_type := 0;
      d_index := 1;
    IFEND;
    disk_log_data_p^.disk_type := disk_type;

{Make a status area if no detailed status was provided.
    IF detailed_status_p = NIL THEN
      PUSH detail_status_p: [[REP ioc$disk_detailed_status_length OF ost$word]];
      i#fill ($CHAR (0), detail_status_p, #SIZE (detail_status_p^));
    ELSEIF #SIZE (detailed_status_p^) < (ioc$disk_detailed_status_length * #SIZE (ost$word)) THEN
      PUSH detail_status_p: [[REP ioc$disk_detailed_status_length OF ost$word]];
      detail_status_p^ := detailed_status_p^;
    ELSE
      detail_status_p := detailed_status_p;
    IFEND;

    RESET detail_status_p;
    NEXT disk_status_p IN detail_status_p;
    RESET detail_status_p;

    CASE disk_type OF
    = ioc$dt_ms885_1x, ioc$dt_ms885_42 =
      NEXT disk_885_status_p IN detail_status_p;
      cylinder := disk_885_status_p^.general_status.starting_cylinder;
      track := disk_885_status_p^.general_status.failing_track;
      sector := disk_885_status_p^.general_status.failing_sector;
      IF disk_885_status_p^.general_status.detailed_status_present AND
            (cylinder = disk_885_status_p^.status_885.cylinder1 *
            16 + disk_885_status_p^.status_885.cylinder2) THEN
        track := disk_885_status_p^.status_885.track;
        sector := disk_885_status_p^.status_885.sector;
        IF ((sector - disk_885_status_p^.general_status.failing_sector) <= 3) AND
              ((sector - disk_885_status_p^.general_status.failing_sector) >= -4) THEN
          disk_885_status_p^.general_status.failing_sector := sector;
        IFEND;
      IFEND;

    = ioc$dt_ms844_4x =
      NEXT disk_status_844_p IN detail_status_p;
      RESET detail_status_p;
      NEXT disk_885_status_p IN detail_status_p;
      cylinder := disk_status_844_p^.general_status.starting_cylinder;
      track := disk_status_844_p^.general_status.failing_track;
      sector := disk_status_844_p^.general_status.failing_sector;
      IF disk_status_844_p^.general_status.detailed_status_present AND
            (cylinder = disk_status_844_p^.status_844.cylinder1 *
            512 + disk_status_844_p^.status_844.cylinder2) THEN
        track := disk_status_844_p^.status_844.track1 * 4 + disk_status_844_p^.status_844.track2;
        sector := disk_status_844_p^.status_844.sector;
      IFEND;

    = ioc$dt_ms834_2, ioc$dt_msfsd_2 =
      NEXT isd_status_p IN detail_status_p;

      cylinder := isd_status_p^.general_status.starting_cylinder;
      track := isd_status_p^.general_status.failing_track;
      sector := isd_status_p^.general_status.failing_sector;
      IF isd_status_p^.general_status.detailed_status_present AND
            (cylinder = isd_status_p^.detailed_status1.cylinder) THEN
        track := isd_status_p^.detailed_status1.track;
        sector := isd_status_p^.detailed_status1.sector1 * 16 + isd_status_p^.detailed_status1.sector2;
        isd_status_p^.general_status.failing_track := track;
        isd_status_p^.general_status.failing_sector := sector;
      IFEND;

    = ioc$dt_ms895_2 =
      NEXT disk_status_895_p IN detail_status_p;
      cylinder := disk_status_895_p^.general_status.starting_cylinder;
      track := disk_status_895_p^.general_status.failing_track;
      sector := disk_status_895_p^.general_status.failing_sector;

    = ioc$dt_mshydra =
      NEXT hydra_status_p IN detail_status_p;
      cylinder := hydra_status_p^.general_status.starting_cylinder;
      track := hydra_status_p^.general_status.failing_track;
      sector := hydra_status_p^.general_status.failing_sector;
      IF hydra_status_p^.general_status.device_status_present AND
            (cylinder = hydra_status_p^.device_status1.cylinder) THEN
        track := hydra_status_p^.device_status1.track;
        sector := hydra_status_p^.device_status1.sector;
        hydra_status_p^.general_status.failing_track := track;
        hydra_status_p^.general_status.failing_sector := sector;
      IFEND;

    = ioc$dt_ms9836_1, ioc$dt_msxmd_3, ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1, ioc$dt_ms5833_1p,
          ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5837_1, ioc$dt_ms5837_1p,
          ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4, ioc$dt_ms5838_1, ioc$dt_ms5838_1p,
          ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1, ioc$dt_ms47444_1p,
          ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =

      NEXT disk_status_9836_1_p IN detail_status_p;
      cylinder := disk_status_9836_1_p^.starting_cylinder;
      track := disk_status_9836_1_p^.failing_track;
      sector := disk_status_9836_1_p^.failing_sector;

{We use the same RP for now.
    = ioc$dt_msntdd_1, ioc$dt_msntdd_2, ioc$dt_msntdd_3, ioc$dt_msntdd_4, ioc$dt_msntdd_5, ioc$dt_msntdd_6 =
      NEXT disk_status_9836_1_p IN detail_status_p;
      cylinder := disk_status_9836_1_p^.starting_cylinder;
      track := disk_status_9836_1_p^.failing_track;
      sector := disk_status_9836_1_p^.failing_sector;

    ELSE
    CASEND;

    disk_log_data_p^.detailed_status := disk_status_p^;

{Compute mau_offset.

    IF disk_type <> 0 THEN
      mau_offset_in_cylinder := (track * iov$disk_type_table [d_index].sectors_per_track + sector) DIV
            iov$disk_type_table [d_index].sectors_per_mau;
    IFEND;

{Determine if unrecovered error.

    IF (pp_response_p^.response_code.primary_response = ioc$normal_response) OR
          (pp_response_p^.response_code.secondary_response = ioc$recovered_error) THEN
      unrecovered_error := 0;
    ELSE

    /unrecovered_error_block/
      BEGIN
        IF (disk_type >= ioc$dt_ms9836_1) AND (disk_type <= ioc$dt_msntdd_6) THEN
          IF (pp_response_p^.response_code.primary_response = ioc$abnormal_response) OR
                (disk_status_9836_1_p^.id = 1) OR (disk_status_9836_1_p^.id = 2) OR
                (disk_status_9836_1_p^.id = 3) THEN
            unrecovered_error := 1;
          ELSE
            unrecovered_error := 2;
            EXIT /unrecovered_error_block/; {----->
          IFEND;
        ELSE
          IF (pp_response_p^.response_code.primary_response = ioc$abnormal_response) OR
                disk_status_p^.general_status.channel_down OR disk_status_p^.general_status.
                control_module_down OR disk_status_p^.general_status.unit_down THEN
            unrecovered_error := 1;
          ELSE
            unrecovered_error := 2;
            EXIT /unrecovered_error_block/; {----->
          IFEND;
        IFEND;
        iov$unrecovered_disk_errors := iov$unrecovered_disk_errors + 1;
      END /unrecovered_error_block/;
    IFEND;
    disk_log_data_p^.failure_severity := unrecovered_error;
    msg_type := dsc$disk_errors;
    IF unrecovered_error = 0 THEN
      msg_level := dsc$recovered_error;
    ELSE
      msg_level := dsc$unrecovered_error;
    IFEND;

{Determine controller type.

    CASE cmv$logical_pp_table_p^ [pp].controller_info.controller_type OF
    = cmc$ms7154_x =
      disk_log_data_p^.controller_type := 1;
    = cmc$ms7155_1, cmc$ms7155_1x =
      disk_log_data_p^.controller_type := 2;
    = cmc$ms7255_1_1 =
      disk_log_data_p^.controller_type := 3;
    = cmc$ms7255_1_2 =
      disk_log_data_p^.controller_type := 4;
    = cmc$ms7165_2x =
      disk_log_data_p^.controller_type := 5;
    = cmc$mshydra_ct =
      disk_log_data_p^.controller_type := 6;
    = cmc$mscm3_ct =
      disk_log_data_p^.controller_type := 7;
    = cmc$ms5831_x =
      disk_log_data_p^.controller_type := 8;
      disk_log_data_p^.isolation_code := disk_status_9836_1_p^.id MOD 100(16);
    = cmc$msntdc_1, cmc$msntdc_2 =
      disk_log_data_p^.controller_type := 9;
      disk_log_data_p^.isolation_code := disk_status_9836_1_p^.id MOD 100(16);
    ELSE
      mtp$error_stop ('IO - invalid controller type');
    CASEND;


    IF pp_response_p^.response_code.primary_response <> ioc$unsolicited_response THEN
      CASE completed_request_p^.request.command [1].command_code OF
      = ioc$cc_read_bytes =
        disk_log_data_p^.logical_operation := ioc$log_read;
      = ioc$cc_write_bytes, ioc$cc_write_initialize =
        disk_log_data_p^.logical_operation := ioc$log_write;
      = ioc$cc_read_flaws =
        disk_log_data_p^.logical_operation := ioc$log_read_flaw_map;
      = ioc$cc_initialize_sectors =
        disk_log_data_p^.logical_operation := ioc$log_initialize_sectors;
      ELSE
        disk_log_data_p^.logical_operation := ioc$no_value;
      CASEND;
    ELSE
      disk_log_data_p^.logical_operation := ioc$no_value;
    IFEND;

{Determine physical unit, symptom code and MDD message.

    display_message := FALSE;
    msg := 'INDETERMINATE';
    CASE disk_type OF
    = ioc$dt_ms844_4x, ioc$dt_ms885_1x, ioc$dt_ms885_42 =
      disk_log_data_p^.physical_unit := disk_log_data_p^.equipment * 8 + physical_unit;
      disk_log_data_p^.equipment := 0;
      message_found := TRUE;
      IF pp_response_p^.abnormal_status.recording_medium_error THEN
        msg := 'MEDIA FAILURE';
        disk_log_data_p^.symptom_code := ioc$7155_media_error;
      ELSEIF disk_885_status_p^.general_status.confidence_cylinder_is_flawed THEN
        msg := 'CONFIDENCE CYLINDER IS FLAWED';
        disk_log_data_p^.symptom_code := ioc$conf_cylinder_is_flawed;
      ELSEIF (disk_885_status_p^.general_status.controller_reserved) OR
            (disk_885_status_p^.general_status.last_general_status = 2000(8)) THEN
        display_message := TRUE;
        msg := 'CONTROLLER RESERVED';
        disk_log_data_p^.symptom_code := ioc$controller_is_reserved;
      ELSEIF (disk_885_status_p^.general_status.unit_reserved) OR
            (disk_885_status_p^.general_status.last_general_status = 10(8)) THEN
        msg := 'UNIT RESERVED';
        disk_log_data_p^.symptom_code := ioc$unit_is_reserved;

      ELSEIF pp_response_p^.abnormal_status.interface_error THEN
        display_message := TRUE;
        msg := 'SOFTWARE FAILURE';
        disk_log_data_p^.symptom_code := ioc$7155_software_failure;
      ELSEIF pp_response_p^.abnormal_status.channel_error THEN
        msg := 'INPUT CHANNEL PARITY';
        disk_log_data_p^.symptom_code := ioc$input_channel_parity;
      ELSEIF pp_response_p^.abnormal_status.function_timeout THEN
        IF disk_885_status_p^.general_status.ram_parity_error THEN
          disk_log_data_p^.symptom_code := ioc$ram_parity;
          msg := 'CONTROLLER RAM PARITY';
        ELSE
          disk_log_data_p^.symptom_code := ioc$function_timeout;
          msg := 'FUNCTION TIMEOUT';
        IFEND;
      ELSEIF disk_885_status_p^.general_status.incomplete_sector_transfer THEN
        msg := 'INCOMPLETE SECTOR TRANSFER';
        disk_log_data_p^.symptom_code := ioc$incomplete_sector_transfer;
      ELSEIF pp_response_p^.abnormal_status.output_channel_parity THEN
        IF disk_885_status_p^.part3.channel_parity_error AND
              (cmv$logical_pp_table_p^ [pp].controller_info.controller_type <> cmc$ms7154_x) THEN
          msg := 'IOU OUTPUT PARITY';
          disk_log_data_p^.symptom_code := ioc$iou_output_parity;
        ELSE
          msg := 'INDETERMINATE OUTPUT PARITY';
          disk_log_data_p^.symptom_code := ioc$indeterminate_output_parity;
        IFEND;
      ELSEIF disk_885_status_p^.part3.channel_parity_error AND
            (cmv$logical_pp_table_p^ [pp].controller_info.controller_type <> cmc$ms7154_x) THEN
        msg := 'OUTPUT CHANNEL PARITY';
        disk_log_data_p^.symptom_code := ioc$output_channel_parity;
      ELSEIF disk_885_status_p^.part3.data_parity_error THEN
        msg := 'OUTPUT CHANNEL PARITY';
        disk_log_data_p^.symptom_code := ioc$output_channel_parity;

      ELSEIF disk_885_status_p^.general_status.host_if_integrity_error THEN
        msg := 'PP - CONTROLLER DATA INTEGRITY';
        disk_log_data_p^.symptom_code := ioc$host_if_integrity_error;
      ELSEIF disk_885_status_p^.general_status.drive_if_integrity_error THEN
        msg := 'PP - DRIVE DATA INTEGRITY';
        disk_log_data_p^.symptom_code := ioc$drive_if_integrity_error;


      ELSEIF disk_type = ioc$dt_ms844_4x THEN
        IF (disk_status_844_p^.status_844.unit_on_line = FALSE) AND
              disk_status_844_p^.general_status.detailed_status_present THEN
          msg := 'UNIT OFF LINE OR NOT CABLED';
          disk_log_data_p^.symptom_code := ioc$unit_off_line_or_not_cabled;
        ELSEIF (disk_status_844_p^.status_844.unit_selected = FALSE) AND
              disk_status_844_p^.general_status.detailed_status_present THEN
          msg := 'DRIVE NOT SELECTED';
          disk_log_data_p^.symptom_code := ioc$drive_not_selected;
        ELSEIF (disk_status_844_p^.status_844.unit_ready = FALSE) AND
              disk_status_844_p^.general_status.detailed_status_present THEN
          msg := 'UNIT NOT READY';
          disk_log_data_p^.symptom_code := ioc$unit_not_ready;
        ELSEIF disk_status_844_p^.status_844.seek_error THEN
          msg := 'SEEK FAILURE';
          disk_log_data_p^.symptom_code := ioc$seek_failure;
        ELSEIF disk_status_844_p^.status_844.pack_unsafe THEN
          msg := 'UNIT FAILURE';
          disk_log_data_p^.symptom_code := ioc$unit_failure;
        ELSEIF disk_status_844_p^.status_844.track_flaw_bit AND
              (disk_status_844_p^.part1.address_checkword_error = FALSE) AND
              disk_status_844_p^.general_status.detailed_status_present THEN
          msg := 'FLAWED TRACK';
          disk_log_data_p^.symptom_code := ioc$flawed_track;
        ELSEIF disk_status_844_p^.status_844.sector_flaw_bit AND
              (disk_status_844_p^.part1.address_checkword_error = FALSE) THEN
          msg := 'FLAWED SECTOR';
          disk_log_data_p^.symptom_code := ioc$flawed_sector;
        ELSE
          message_found := FALSE;
        IFEND;


      ELSEIF disk_885_status_p^.part3.status_not_valid THEN
        msg := 'CONTROLLER - DRIVE INTERFACE ERROR';
        disk_log_data_p^.symptom_code := ioc$controller_drive_interface;
      ELSEIF (disk_885_status_p^.status_885.selected_and_reserved = FALSE) AND
            disk_885_status_p^.general_status.detailed_status_present THEN
        IF disk_885_status_p^.part3.lost_dsu_clock THEN
          msg := 'CHAN ENABLE SWITCH OFF OR UNIT NOT CABLED';
          disk_log_data_p^.symptom_code := ioc$ch_enable_off_or_not_cabled;
        ELSE
          msg := 'DRIVE NOT SELECTED';
          disk_log_data_p^.symptom_code := ioc$drive_not_selected;
        IFEND;
      ELSEIF ((disk_885_status_p^.status_885.start_switch_on = FALSE) OR
            (disk_885_status_p^.status_885.motor_at_speed = FALSE)) AND
            disk_885_status_p^.status_885.selected_and_reserved AND
            (disk_885_status_p^.part3.status_not_valid = FALSE) THEN
        msg := 'UNIT NOT READY';
        disk_log_data_p^.symptom_code := ioc$unit_not_ready;
      ELSEIF (disk_885_status_p^.status_885.write_enable = FALSE) AND
            disk_885_status_p^.status_885.selected_and_reserved AND
            (disk_885_status_p^.part3.status_not_valid = FALSE) AND
            (disk_885_status_p^.part1.pp_command = 5) THEN
        msg := 'UNIT READ ONLY SWITCH ON';
        disk_log_data_p^.symptom_code := ioc$read_only_switch_on;
      ELSEIF disk_885_status_p^.status_885.drive_check_error OR
            disk_885_status_p^.status_885.read_write_error OR disk_885_status_p^.status_885.access_check THEN
        msg := 'UNIT FAILURE';
        disk_log_data_p^.symptom_code := ioc$unit_failure;
      ELSEIF (disk_885_status_p^.part1.pp_command = 1) AND (disk_885_status_p^.part3.word_address > 0) THEN
        msg := 'CONTROLLER - DRIVE INTERFACE ERROR';
        disk_log_data_p^.symptom_code := ioc$controller_drive_interface;
      ELSEIF disk_885_status_p^.status_885.track_flaw_bit AND
            (disk_885_status_p^.part1.address_checkword_error = FALSE) THEN
        msg := 'FLAWED TRACK';
        disk_log_data_p^.symptom_code := ioc$flawed_track;
      ELSE
        message_found := FALSE;
      IFEND;

      IF message_found = FALSE THEN
        IF disk_885_status_p^.part1.cylinder_number_error THEN
          msg := 'CYLINDER ADDRESS MISCOMPARE';
          disk_log_data_p^.symptom_code := ioc$cylinder_address_miscompare;
        ELSEIF disk_885_status_p^.part1.track_number_error THEN
          msg := 'TRACK ADDRESS MISCOMPARE';
          disk_log_data_p^.symptom_code := ioc$track_address_miscompare;
        ELSEIF disk_885_status_p^.part1.sector_number_error THEN
          msg := 'SECTOR ADDRESS MISCOMPARE';
          disk_log_data_p^.symptom_code := ioc$sector_address_miscompare;
        ELSEIF disk_885_status_p^.part1.address_error THEN
          msg := 'ADDRESS ERROR';
          disk_log_data_p^.symptom_code := ioc$address_error;
        ELSEIF disk_885_status_p^.part3.lost_control_word AND
              (cmv$logical_pp_table_p^ [pp].controller_info.controller_type <> cmc$ms7154_x) THEN
          msg := 'LOST CONTROL WORD';
          disk_log_data_p^.symptom_code := ioc$lost_control_word;
        ELSEIF disk_885_status_p^.part1.pp_command = ioc$seek_function THEN
          msg := 'SEEK FAILURE';
          disk_log_data_p^.symptom_code := ioc$seek_failure;
        ELSEIF (disk_885_status_p^.part1.address_checkword_error) OR
              ((disk_885_status_p^.part1.data_checkword_error) AND (disk_885_status_p^.part1.pp_command = 4))
              THEN
          msg := 'ERROR IN CHECKWORD';
          disk_log_data_p^.symptom_code := ioc$checkword_error;
        ELSEIF disk_885_status_p^.part3.write_buffer_to_disk_error THEN
          msg := 'WRITE BUFFER TO DISK ERROR';
          disk_log_data_p^.symptom_code := ioc$write_buffer_to_disk_error;
        ELSEIF disk_885_status_p^.part3.processor_instruction_timeout THEN
          msg := 'PROCESSOR INSTRUCTION TIMEOUT';
          disk_log_data_p^.symptom_code := ioc$processor_instruction_timeo;
        ELSEIF disk_885_status_p^.part3.bm_register_parity_error THEN
          msg := 'BM REGISTER PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$bm_register_parity_error;
        ELSEIF disk_885_status_p^.part3.write_verify_error THEN
          msg := 'WRITE VERIFY ERROR';
          disk_log_data_p^.symptom_code := ioc$write_verify_error;
        ELSEIF disk_885_status_p^.general_status.controlware_load_attempted THEN
          msg := 'LOADING CONTROLWARE';
          disk_log_data_p^.symptom_code := ioc$loading_controlware;
          disk_log_data_p^.failure_severity := 3;
        ELSE
          disk_log_data_p^.symptom_code := ioc$indeterminate;
        IFEND;
      IFEND;


{Determine ISD symptom message.}

    = ioc$dt_ms834_2, ioc$dt_msfsd_2 =
      disk_log_data_p^.physical_unit := physical_unit;
      manual_intervention_code := isd_status_p^.detailed_status1.manual_intervention_code;
      level_i_diagnostic_code := isd_status_p^.detailed_status1.level_i_diagnostic_code;
      level_ii_diagnostic_code := isd_status_p^.detailed_status1.level_ii_diagnostic_code_1 *
            10(16) + isd_status_p^.detailed_status1.level_ii_diagnostic_code_2;
      adapter_diagnostic_code := isd_status_p^.general_status.first_general_status - 5000(8);
      IF (adapter_diagnostic_code > 777(8)) OR (adapter_diagnostic_code < 0) THEN
        adapter_diagnostic_code := 0;
      IFEND;
      disk_log_data_p^.diagnostic_code := adapter_diagnostic_code;
      IF level_i_diagnostic_code > 0 THEN
        disk_log_data_p^.diagnostic_code := level_i_diagnostic_code;
      IFEND;
      IF level_ii_diagnostic_code > 0 THEN
        disk_log_data_p^.diagnostic_code := level_ii_diagnostic_code;
      IFEND;

      IF pp_response_p^.abnormal_status.recording_medium_error THEN
        msg := 'MEDIA FAILURE';
        disk_log_data_p^.symptom_code := ioc$media_failure;
      ELSEIF isd_status_p^.general_status.pp_timed_out_a_command THEN
        msg := 'PP TIMED OUT A COMMAND';
        disk_log_data_p^.symptom_code := ioc$pp_timed_out_a_command;
      ELSEIF isd_status_p^.general_status.adapter_controlware_error OR
            isd_status_p^.general_status.load_attention_delay_error OR
            isd_status_p^.general_status.bad_status_loading_controlware OR
            isd_status_p^.general_status.read_error OR isd_status_p^.general_status.input_channel_active OR
            isd_status_p^.general_status.output_channel_full THEN
        msg := 'ADAPTER CONTROLWARE ERROR';
        disk_log_data_p^.symptom_code := ioc$adapter_controlware_error;
      ELSEIF (isd_status_p^.general_status.controller_reserved) OR
            (isd_status_p^.general_status.last_general_status = 10(8)) THEN
        msg := 'CONTROL MODULE RESERVED';
        disk_log_data_p^.symptom_code := ioc$control_module_reserved;
      ELSEIF pp_response_p^.abnormal_status.interface_error THEN
        display_message := TRUE;
        msg := 'SOFTWARE FAILURE';
        disk_log_data_p^.symptom_code := ioc$isd_software_failure;
      ELSEIF isd_status_p^.general_status.power_up_spindle_started THEN
        CASE unrecovered_error OF
        = 1 =
          display_message := TRUE;
          msg := 'DRIVE NOT READY';
        = 2 =
          display_message := TRUE;
          msg := 'POWERING UP SPINDLE';
        ELSE
        CASEND;
        disk_log_data_p^.symptom_code := ioc$drive_not_ready;
      ELSEIF isd_status_p^.general_status.spindle_powered_up THEN
        display_message := TRUE;
        msg := 'SPINDLE POWERED UP';
        disk_log_data_p^.symptom_code := ioc$drive_not_ready;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF isd_status_p^.general_status.control_module_reload_started AND
            ((unrecovered_error = 2) OR (pp_response_p^.response_code.primary_response =
            ioc$unsolicited_response) AND (unrecovered_error <> 1)) THEN
        msg := 'RELOADING CONTROL MODULE';
        disk_log_data_p^.symptom_code := ioc$reloading_control_module;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF isd_status_p^.general_status.control_module_reload_completed THEN
        msg := 'CONTROL MODULE RELOADED';
        disk_log_data_p^.symptom_code := ioc$control_module_reloaded;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF isd_status_p^.general_status.level_2_diagnostics_started AND
            ((unrecovered_error = 2) OR (pp_response_p^.response_code.primary_response =
            ioc$unsolicited_response)) THEN
        display_message := TRUE;
        msg := 'EXECUTING LEVEL II DIAGNOSTICS';
        disk_log_data_p^.symptom_code := ioc$executing_level_ii;
        down_status := ioc$executing_diagnostics;
      ELSEIF isd_status_p^.general_status.level_2_diagnostics_passed THEN
        display_message := TRUE;
        msg := 'LEVEL II DIAGNOSTICS PASSED';
        disk_log_data_p^.symptom_code := ioc$level_ii_passed;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF manual_intervention_code = 0c3(16) THEN
        msg := 'DRIVE NOT PRESENT';
        disk_log_data_p^.symptom_code := ioc$drive_not_present;
      ELSEIF isd_status_p^.general_status.media_failure OR
            isd_status_p^.general_status.unrecovered_media_error THEN
        msg := 'MEDIA FAILURE';
        disk_log_data_p^.symptom_code := ioc$media_failure;
      ELSEIF (isd_status_p^.general_status.first_general_status = 5002(8)) OR
            (isd_status_p^.general_status.first_general_status = 5013(8)) THEN
        msg := 'ADAPTER RAM PARITY';
        disk_log_data_p^.symptom_code := ioc$adapter_ram_parity;
      ELSEIF pp_response_p^.abnormal_status.function_timeout THEN
        IF pp_response_p^.abnormal_status.output_channel_parity THEN
          msg := 'FUNCTION FAILURE CLASS 2';
          disk_log_data_p^.symptom_code := ioc$function_failure_class_2;
        ELSE
          msg := 'FUNCTION FAILURE CLASS 3';
          disk_log_data_p^.symptom_code := ioc$function_failure_class_3;
        IFEND;
      ELSEIF pp_response_p^.abnormal_status.channel_error THEN
        msg := 'INPUT ICI PARITY';
        disk_log_data_p^.symptom_code := ioc$input_ici_parity;
      ELSEIF pp_response_p^.abnormal_status.output_channel_parity THEN
        IF isd_status_p^.detailed_status1.ici_parity_error THEN
          msg := 'OUTPUT ICI PARITY CLASS 1';
          disk_log_data_p^.symptom_code := ioc$output_ici_parity_class_1;
        ELSE
          msg := 'OUTPUT ICI PARITY CLASS 2';
          disk_log_data_p^.symptom_code := ioc$output_ici_parity_class_2;
        IFEND;
      ELSEIF isd_status_p^.detailed_status1.ici_parity_error THEN
        msg := 'OUTPUT ICI PARITY CLASS 3';
        disk_log_data_p^.symptom_code := ioc$output_ici_parity_class_3;
      ELSEIF isd_status_p^.detailed_status1.buffer_memory_parity_error THEN
        msg := 'ADAPTER BUFFER PARITY';
        disk_log_data_p^.symptom_code := ioc$adapter_buffer_parity;
      ELSEIF isd_status_p^.general_status.first_general_status = 5014(8) THEN
        msg := 'ADAPTER ROM PARITY';
        disk_log_data_p^.symptom_code := ioc$adapter_rom_parity;
      ELSEIF isd_status_p^.detailed_status1.level_i_diagnostic_code = 90(16) THEN
        msg := 'START SWITCH NOT DEPRESSED';
        disk_log_data_p^.symptom_code := ioc$start_switch_not_depressed;
      ELSEIF isd_status_p^.detailed_status1.isi_parity_error THEN
        IF manual_intervention_code = 63(16) THEN
          msg := 'OUTPUT ISI PARITY CLASS 1';
          disk_log_data_p^.symptom_code := ioc$output_isi_parity_class_1;
        ELSE
          msg := 'ISI PARITY';
          disk_log_data_p^.symptom_code := ioc$isi_parity;
        IFEND;
      ELSEIF manual_intervention_code = 63(16) THEN
        msg := 'OUTPUT ISI PARITY CLASS 3';
        disk_log_data_p^.symptom_code := ioc$output_isi_parity_class_3;
      ELSEIF isd_status_p^.detailed_status1.system_intervention_code = 21(16) THEN
        msg := 'SEEK ERROR';
        disk_log_data_p^.symptom_code := ioc$seek_error;
      ELSEIF isd_status_p^.general_status.host_if_integrity_error THEN
        msg := 'PP - ADAPTER DATA INTEGRITY';
        disk_log_data_p^.symptom_code := ioc$i_host_if_integrity_error;
      ELSEIF isd_status_p^.general_status.drive_if_integrity_error THEN
        msg := 'PP - DRIVE DATA INTEGRITY';
        disk_log_data_p^.symptom_code := ioc$i_drive_if_integrity_error;
      ELSEIF isd_status_p^.detailed_status1.system_intervention_code = 41(16) THEN
        msg := 'UNABLE TO READ HEADER';
        disk_log_data_p^.symptom_code := ioc$unable_to_read_header;
      ELSEIF isd_status_p^.detailed_status1.system_intervention_code = 43(16) THEN
        msg := 'UNABLE TO READ DATA';
        disk_log_data_p^.symptom_code := ioc$unable_to_read_data;
      ELSEIF isd_status_p^.detailed_status1.isi_deadman_time_out THEN
        msg := 'ISI DEADMAN TIME-OUT';
        disk_log_data_p^.symptom_code := ioc$isi_deadman_time_out;
      ELSEIF manual_intervention_code = 64(16) THEN
        msg := 'CM SCHEDULER PARITY';
        disk_log_data_p^.symptom_code := ioc$cm_scheduler_parity;
      ELSEIF manual_intervention_code = 65(16) THEN
        msg := 'CM MPU PARITY';
        disk_log_data_p^.symptom_code := ioc$cm_mpu_parity;
      ELSEIF manual_intervention_code = 66(16) THEN
        msg := 'CM R/W HARDWARE FAULT';
        disk_log_data_p^.symptom_code := ioc$cm_rw_hardware_fault;
      ELSEIF manual_intervention_code = 67(16) THEN
        msg := 'DRIVE VOLTAGE FAULT';
        disk_log_data_p^.symptom_code := ioc$drive_voltage_fault;
      ELSEIF manual_intervention_code = 68(16) THEN
        msg := 'OVER TEMPERATURE FAULT';
        disk_log_data_p^.symptom_code := ioc$over_temperature_fault;
      ELSEIF manual_intervention_code = 69(16) THEN
        msg := 'INVALID BOOTSTRAP ERROR';
        disk_log_data_p^.symptom_code := ioc$invalid_bootstrap_error;
      ELSEIF (manual_intervention_code = 0c2(16)) OR (level_ii_diagnostic_code = 0dc(16)) OR
            (level_ii_diagnostic_code = 0dd(16)) THEN
        msg := 'DRIVE WRITE PROTECTED';
        disk_log_data_p^.symptom_code := ioc$drive_write_protected;
      ELSEIF isd_status_p^.general_status.incomplete_sector_transfer THEN
        msg := 'INCOMPLETE ICI TRANSFER';
        disk_log_data_p^.symptom_code := ioc$incomplete_ici_transfer;
      ELSEIF isd_status_p^.detailed_status1.cm_failure THEN
        CASE isd_status_p^.detailed_status1.failure_code OF
        = 1 =
          msg := 'LOOPBACK COMPARE ERROR';
          disk_log_data_p^.symptom_code := ioc$loopback_compare_error;
        = 2 =
          msg := 'LOOPBACK SELECT ACTIVE';
          disk_log_data_p^.symptom_code := ioc$loopback_select_active;
        = 3 =
          msg := 'LOOPBACK ATTENTION';
          disk_log_data_p^.symptom_code := ioc$loopback_attention;
        = 4 =
          msg := 'LOOPBACK CHECK FAILURE';
          disk_log_data_p^.symptom_code := ioc$loopback_check_failure;
        ELSE
          msg := 'CONTROL MODULE FAILURE     ';
          disk_log_data_p^.symptom_code := ioc$isd_controller_failure;
          IF level_ii_diagnostic_code > 0 THEN
            dpp$convert_int_to_str_hex (2, level_ii_diagnostic_code, msg (26, * ));
            disk_log_data_p^.diagnostic_code := level_ii_diagnostic_code;
          ELSEIF level_i_diagnostic_code > 0 THEN
            dpp$convert_int_to_str_hex (2, level_i_diagnostic_code, msg (26, * ));
            disk_log_data_p^.diagnostic_code := level_i_diagnostic_code;
          IFEND;
        CASEND;
      ELSEIF isd_status_p^.detailed_status1.adapter_failure THEN
        msg := 'ADAPTER FAILURE      ';
        disk_log_data_p^.symptom_code := ioc$adapter_failure;
        IF adapter_diagnostic_code > 0 THEN
          dpp$convert_int_to_str_hex (3, adapter_diagnostic_code, msg (19, * ));
          disk_log_data_p^.diagnostic_code := adapter_diagnostic_code;
        IFEND;
      ELSEIF isd_status_p^.detailed_status1.drive_failure THEN
        msg := 'DRIVE FAILURE     ';
        disk_log_data_p^.symptom_code := ioc$drive_failure;
        IF level_ii_diagnostic_code > 0 THEN
          dpp$convert_int_to_str_hex (2, level_ii_diagnostic_code, msg (17, * ));
          disk_log_data_p^.diagnostic_code := level_ii_diagnostic_code;
        ELSEIF level_i_diagnostic_code > 0 THEN
          dpp$convert_int_to_str_hex (2, level_i_diagnostic_code, msg (17, * ));
          disk_log_data_p^.diagnostic_code := level_i_diagnostic_code;
        IFEND;
      ELSE
        disk_log_data_p^.symptom_code := ioc$isd_indeterminate;
      IFEND;

{  Process 895 disk errors }

    = ioc$dt_ms895_2 =
      disk_log_data_p^.physical_unit := physical_unit;
      disk_log_data_p^.diagnostic_code := 0;

      IF pp_response_p^.abnormal_status.recording_medium_error THEN
        msg := 'MEDIA FAILURE';
        disk_log_data_p^.symptom_code := ioc$895_media_failure;

      ELSEIF (disk_status_895_p^.general_status.first_general_status = 900(16)) AND
            (detailed_status_p <> NIL) AND (disk_status_895_p^.controller_status_1.ccc_status_byte_error) AND
            (disk_status_895_p^.controller_status_1.bit_6) AND
            (disk_status_895_p^.controller_status_1.bit_3) AND
            (disk_status_895_p^.controller_status_1.bit_1) THEN
        disk_log_data_p^.symptom_code := ioc$895_storage_director_retry;
        msg := 'STORAGE DIRECTOR RETRY';

      ELSEIF ((disk_status_895_p^.general_status.first_general_status = 0a10(16)) AND
            (detailed_status_p <> NIL)) OR ((disk_status_895_p^.general_status.first_general_status =
            900(16)) AND (detailed_status_p <> NIL) AND (disk_status_895_p^.controller_status_1.
            ccc_status_byte_error) AND (disk_status_895_p^.controller_status_1.bit_1)) THEN
        format_message := disk_status_895_p^.detailed_status_1.format_code *
              16 + disk_status_895_p^.detailed_status_1.message_code;
        IF (format_message = 0) OR (format_message = 10(16)) OR (format_message = 28(16)) OR
              (format_message = 80(16)) OR (disk_status_895_p^.detailed_status_1.format_code = 6) THEN
          IF disk_status_895_p^.detailed_status_1.command_reject THEN
            msg := 'COMMAND REJECT';
            disk_log_data_p^.symptom_code := ioc$895_command_reject;
          ELSEIF disk_status_895_p^.detailed_status_1.intervention_required THEN
            msg := 'INTERVENTION REQUIRED';
            disk_log_data_p^.symptom_code := ioc$895_intervention_req;
          ELSEIF disk_status_895_p^.detailed_status_1.bus_out_parity THEN
            msg := 'BUS OUT PARITY';
            disk_log_data_p^.symptom_code := ioc$895_bus_out_parity;
          ELSEIF disk_status_895_p^.detailed_status_1.equipment_check THEN
            msg := 'EQUIPMENT CHECK';
            disk_log_data_p^.symptom_code := ioc$895_equipment_check;
          ELSEIF disk_status_895_p^.detailed_status_1.data_check THEN
            msg := 'DATA CHECK';
            disk_log_data_p^.symptom_code := ioc$895_data_check;
          ELSEIF disk_status_895_p^.detailed_status_1.overrun THEN
            msg := 'OVERRUN';
            disk_log_data_p^.symptom_code := ioc$895_overrun;
          ELSEIF disk_status_895_p^.detailed_status_1.permanent_device_error THEN
            msg := 'PERMANENT DEVICE ERROR';
            disk_log_data_p^.symptom_code := ioc$895_permanent_device_error;
          ELSEIF disk_status_895_p^.detailed_status_1.end_of_cylinder THEN
            msg := 'END OF CYLINDER';
            disk_log_data_p^.symptom_code := ioc$895_end_of_cylinder;
          ELSEIF disk_status_895_p^.detailed_status_1.message_to_operator THEN
            msg := 'MESSAGE TO OPERATOR';
            disk_log_data_p^.symptom_code := ioc$895_message_to_operator;
          ELSEIF disk_status_895_p^.detailed_status_1.no_record_found THEN
            msg := 'NO RECORD FOUND';
            disk_log_data_p^.symptom_code := ioc$895_no_record_found;
          ELSEIF disk_status_895_p^.detailed_status_1.file_protected THEN
            msg := 'FILE PROTECTED';
            disk_log_data_p^.symptom_code := ioc$895_file_protected;
          ELSEIF disk_status_895_p^.detailed_status_1.first_logged_error THEN
            msg := 'FIRST LOGGED ERROR';
            disk_log_data_p^.symptom_code := ioc$895_first_logged_error;
          ELSEIF disk_status_895_p^.detailed_status_1.environmental_data_present THEN
            msg := 'ENVIRONMENTAL DATA';
            disk_log_data_p^.symptom_code := ioc$895_environmental_data;
          ELSEIF disk_status_895_p^.detailed_status_1.path_error THEN
            msg := 'PATH ERROR';
            disk_log_data_p^.symptom_code := ioc$895_path_error;
          ELSEIF disk_status_895_p^.detailed_status_1.invalid_track_format THEN
            msg := 'INVALID TRACK FORMAT';
            disk_log_data_p^.symptom_code := ioc$895_invalid_track_format;
          ELSE
            disk_log_data_p^.symptom_code := ioc$895_undocumented_sd_resp;
            msg := 'UNDOCUMENTED STORAGE DIRECTOR RESPONSE';
          IFEND;
        ELSE
          CASE disk_status_895_p^.detailed_status_1.format_code OF
          = 0 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 1 =
              msg := 'INVALID COMMAND';
              disk_log_data_p^.symptom_code := ioc$895_invalid_command;
            = 2 =
              msg := 'INVALID COMMAND ISSUED TO 7165';
              disk_log_data_p^.symptom_code := ioc$895_invalid_command_to_7165;
            = 3 =
              msg := 'CCW COUNT TOO SMALL';
              disk_log_data_p^.symptom_code := ioc$895_ccw_count_too_small;
            = 4 =
              msg := 'INVALID DATA ARGUMENT';
              disk_log_data_p^.symptom_code := ioc$895_invalid_data_argument;
            = 6 =
              msg := 'CHAINING NOT INDICATED';
              disk_log_data_p^.symptom_code := ioc$895_chaining_not_indicated;
            = 7 =
              msg := 'COMMAND MISMATCH';
              disk_log_data_p^.symptom_code := ioc$895_command_mismatch;
            = 11 =
              msg := 'DEFECTIVE TRACK POINTER';
              disk_log_data_p^.symptom_code := ioc$895_defective_track_pointer;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 0 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
            CASEND;
          = 1 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 1 =
              msg := 'DEVICE STATUS 1 NOT EXPECTED';
              disk_log_data_p^.symptom_code := ioc$895_device_status_1_not_exp;
            = 3 =
              msg := 'INDEX MISSING';
              disk_log_data_p^.symptom_code := ioc$895_index_missing;
            = 4 =
              msg := 'UNRESETTABLE INTERRUPT';
              disk_log_data_p^.symptom_code := ioc$895_unresettable_interrupt;
            = 5 =
              msg := 'DEVICE DOES NOT RESPOND';
              disk_log_data_p^.symptom_code := ioc$895_device_does_not_respond;
            = 6 =
              msg := 'INCOMPLETE SET SECTOR';
              disk_log_data_p^.symptom_code := ioc$895_incomplete_set_sector;
            = 7 =
              msg := 'HEAD ADDRESS MISCOMPARE';
              disk_log_data_p^.symptom_code := ioc$895_head_address_miscompare;
            = 8 =
              msg := 'INVALID DEVICE STATUS 1';
              disk_log_data_p^.symptom_code := ioc$895_invalid_device_status_1;
            = 9 =
              msg := 'DEVICE NOT READY';
              disk_log_data_p^.symptom_code := ioc$895_device_not_ready;
            = 10 =
              msg := 'TRACK ADDRESS MISCOMPARE';
              disk_log_data_p^.symptom_code := ioc$895_track_addr_miscompare;
            = 12 =
              msg := 'DRIVE MOTOR OFF';
              disk_log_data_p^.symptom_code := ioc$895_drive_motor_off;
            = 13 =
              msg := 'SEEK INCOMPLETE';
              disk_log_data_p^.symptom_code := ioc$895_seek_incomplete;
            = 14 =
              msg := 'CYLINDER ADDRESS MISCOMPARE';
              disk_log_data_p^.symptom_code := ioc$895_cyl_addr_miscompare;
            = 15 =
              msg := 'UNRESETTABLE OFFSET ACTIVE';
              disk_log_data_p^.symptom_code := ioc$895_unresettable_offset;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 1 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 1;
            CASEND;
          = 2 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 9 =
              msg := 'SELECTIVE RESET WHILE SELECTED';
              disk_log_data_p^.symptom_code := ioc$895_selective_reset;
            = 10 =
              msg := 'SYNC LATCH FAILURE';
              disk_log_data_p^.symptom_code := ioc$895_sync_latch_failure;
            = 15 =
              msg := 'MICROCODE DETECTED CHECK';
              disk_log_data_p^.symptom_code := ioc$895_micro_detected_check;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 2 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 2;
            CASEND;
          = 3 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 8 =
              msg := 'CLOCK STOPPED CHECK 1';
              disk_log_data_p^.symptom_code := ioc$895_clock_stopped_check_1;
            = 9, 11, 12, 13, 14, 15 =
              msg := 'ALTERNATE STORAGE DIRECTOR FAILURE';
              disk_log_data_p^.symptom_code := ioc$895_alternate_sd_failure;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 3 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 3;
            CASEND;
          = 4 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 0, 1, 2, 3, 8, 9, 10, 11 =
              msg := 'ERROR UNCORRECTABLE BY ECC';
              disk_log_data_p^.symptom_code := ioc$895_error_uncorr_by_ecc;
            = 4, 5, 6, 7, 12, 13, 14, 15 =
              msg := 'DATA SYNCHRONIZATION UNSUCCESSFUL';
              disk_log_data_p^.symptom_code := ioc$895_data_sync_unsuccessful;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 4 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 4;
            CASEND;
          = 5 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 0, 1, 2, 3, 8, 9, 10, 11 =
              msg := 'ERROR CORRECTABLE BY ECC';
              disk_log_data_p^.symptom_code := ioc$895_error_corrected_by_ecc;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 5 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 5;
            CASEND;
          = 7 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 0 =
              msg := 'RCC INITIATED BY CCA';
              disk_log_data_p^.symptom_code := ioc$895_rcc_initiated_by_cca;
            = 1 =
              msg := 'RCC1 NOT SUCCESSFUL';
              disk_log_data_p^.symptom_code := ioc$895_rcc1_not_successful;
            = 2 =
              msg := 'RCC1 AND RCC2 NOT SUCCESSFUL';
              disk_log_data_p^.symptom_code := ioc$895_rcc1_rcc2_unsuccessful;
            = 3 =
              msg := 'INVALID DDC TAG SEQUENCE';
              disk_log_data_p^.symptom_code := ioc$895_invalid_ddc_tag_seq;
            = 4 =
              msg := 'EXTRA RCC REQUIRED';
              disk_log_data_p^.symptom_code := ioc$895_extra_rcc_required;
            = 5 =
              msg := 'INVALID DDC SELECTION';
              disk_log_data_p^.symptom_code := ioc$895_invalid_ddc_selection;
            = 6, 7 =
              msg := 'MISSING END OP';
              disk_log_data_p^.symptom_code := ioc$895_missing_end_op;
            = 8, 9 =
              msg := 'INVALID TAG';
              disk_log_data_p^.symptom_code := ioc$895_invalid_tag;
            = 10 =
              msg := 'DESELECTION';
              disk_log_data_p^.symptom_code := ioc$895_deselection;
            = 11 =
              msg := 'NO CONTROLLER RESPONSE';
              disk_log_data_p^.symptom_code := ioc$895_no_controller_response;
            = 12, 13 =
              msg := 'CONTROLLER NOT AVAILABLE';
              disk_log_data_p^.symptom_code := ioc$895_controller_unavailable;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 7 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 7;
            CASEND;
          = 8 =
            CASE disk_status_895_p^.detailed_status_1.message_code OF
            = 1 =
              msg := 'ECC HARDWARE FAILURE';
              disk_log_data_p^.symptom_code := ioc$895_ecc_hardware_failure;
            = 3 =
              msg := 'UNEXPECTED END OP';
              disk_log_data_p^.symptom_code := ioc$895_unexpected_end_op;
            = 4, 5 =
              msg := 'END OP ACTIVE';
              disk_log_data_p^.symptom_code := ioc$895_end_op_active;
            ELSE
              msg := 'UNDOCUMENTED FORMAT 8 MESSAGE';
              disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
              disk_log_data_p^.diagnostic_code := 8;
            CASEND;
          ELSE
            msg := 'UNDOCUMENTED FORMAT x MESSAGE';
            disk_log_data_p^.symptom_code := ioc$895_undocumented_format_msg;
            disk_log_data_p^.diagnostic_code := disk_status_895_p^.detailed_status_1.format_code;
            dpp$convert_int_to_str_hex (1, disk_log_data_p^.diagnostic_code, msg (21));
          CASEND;
        IFEND;

      ELSEIF (disk_status_895_p^.general_status.first_general_status = 0a00(16)) AND
            (detailed_status_p <> NIL) THEN
        IF (disk_status_895_p^.controller_status_1.controlware_detected_error) AND
              (disk_status_895_p^.controller_status_1.bit_4) THEN
          msg := 'REQUEST IN NOT RECEIVED DURING COMMAND RETRY';
          disk_log_data_p^.symptom_code := ioc$895_no_request_in_cmd;
        ELSEIF (disk_status_895_p^.controller_status_1.controlware_detected_error) AND
              (disk_status_895_p^.controller_status_1.bit_3) THEN
          msg := 'ILLEGAL WRITE';
          disk_log_data_p^.symptom_code := ioc$895_illegal_write;
        ELSEIF (disk_status_895_p^.controller_status_1.controlware_detected_error) AND
              ((disk_status_895_p^.controller_status_1.bit_2) OR
              (disk_status_895_p^.controller_status_1.bit_1)) THEN
          msg := 'CCC-STORAGE DIRECTOR INTERFACE ERROR';
          disk_log_data_p^.symptom_code := ioc$895_fips_error;
        ELSEIF (disk_status_895_p^.controller_status_1.controlware_detected_error) AND
              (disk_status_895_p^.controller_status_1.bit_0) THEN
          msg := 'FULL/EMPTY COUNT INCORRECT';
          disk_log_data_p^.symptom_code := ioc$895_full_empty_count;
        ELSEIF (disk_status_895_p^.controller_status_1.fsc_sequence_error) AND
              (disk_status_895_p^.controller_status_1.bit_2) THEN
          msg := 'ADDRESS MISCOMPARE ON SELECT SEQUENCE';
          disk_log_data_p^.symptom_code := ioc$895_address_miscompare;
        ELSEIF (disk_status_895_p^.controller_status_1.fsc_sequence_error) AND
              (disk_status_895_p^.controller_status_1.bit_1) THEN
          msg := 'NO REQUEST IN ON POLLING SEQUENCE';
          disk_log_data_p^.symptom_code := ioc$895_no_request_in_poll;
        ELSEIF (disk_status_895_p^.controller_status_1.fsc_sequence_error) AND
              (disk_status_895_p^.controller_status_1.bit_0) THEN
          msg := 'SELECT IN RECEIVED ON SELECT SEQUENCE';
          disk_log_data_p^.symptom_code := ioc$895_select_in_received;
        ELSEIF (disk_status_895_p^.controller_status_1.parity_error) AND
              (disk_status_895_p^.controller_status_1.bit_3) THEN
          msg := 'BUS IN PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_bus_in_parity;
        ELSEIF (disk_status_895_p^.controller_status_1.parity_error) AND
              (disk_status_895_p^.controller_status_1.bit_2) THEN
          msg := 'READ PATH PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_read_path_parity;
        ELSEIF (disk_status_895_p^.controller_status_1.parity_error) AND
              (disk_status_895_p^.controller_status_1.bit_0) THEN
          msg := 'WRITE PATH PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_write_path_parity;
        ELSEIF (disk_status_895_p^.controller_status_1.normal_end) AND
              (disk_status_895_p^.controller_status_1.transfer_indicator) THEN
          msg := 'INCOMPLETE DATA TRANSFER';
          disk_log_data_p^.symptom_code := ioc$895_incomplete_transfer;
        ELSEIF disk_status_895_p^.controller_status_1.channel_parity THEN
          msg := 'CHANNEL PARITY DURING PP OUTPUT';
          disk_log_data_p^.symptom_code := ioc$895_output_chan_parity;
        ELSEIF disk_status_895_p^.controller_status_1.memory_parity THEN
          msg := 'COUPLER MEMORY PARITY ERROR DURING PP INPUT';
          disk_log_data_p^.symptom_code := ioc$895_parity_err_on_input;
        ELSEIF disk_status_895_p^.controller_status_1.deadman_timeout THEN
          msg := 'DEADMAN TIMEOUT STATUS';
          disk_log_data_p^.symptom_code := ioc$895_deadman_timeout;
        ELSEIF (disk_status_895_p^.controller_status_1.coupler_memory_parity) OR
              ((disk_status_895_p^.controller_status_1.parity_error) AND
              (disk_status_895_p^.controller_status_1.bit_1)) THEN
          msg := 'COUPLER MEMORY PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_memory_parity;
        ELSEIF disk_status_895_p^.controller_status_1.transfer_indicator THEN
          msg := 'EXCESS DATA TRANSFERRED';
          disk_log_data_p^.symptom_code := ioc$895_excess_data_xfered;
        ELSEIF disk_status_895_p^.controller_status_1.character_fill THEN
          msg := 'DATA PACKING FOR CHANNEL DID NOT COME OUT EVEN';
          disk_log_data_p^.symptom_code := ioc$895_data_packing_wrong;
        ELSEIF NOT disk_status_895_p^.controller_status_1.normal_end THEN
          msg := 'NORMAL END NOT SET';
          disk_log_data_p^.symptom_code := ioc$895_normal_end_not_set;
        ELSE
          disk_log_data_p^.symptom_code := ioc$895_indeterminate;
        IFEND;
      ELSE
        IF pp_response_p^.abnormal_status.function_timeout THEN
          msg := 'FUNCTION TIMEOUT';
          disk_log_data_p^.symptom_code := ioc$895_function_timeout;
        ELSEIF disk_status_895_p^.general_status.soft_sectoring_started THEN
          display_message := TRUE;
          disk_log_data_p^.failure_severity := 3;
          msg := 'SOFT SECTORING UNIT';
          disk_log_data_p^.symptom_code := ioc$895_soft_sectoring;
        ELSEIF disk_status_895_p^.general_status.soft_sectoring_complete THEN
          display_message := TRUE;
          disk_log_data_p^.failure_severity := 3;
          msg := 'UNIT SOFT SECTORED';
          disk_log_data_p^.symptom_code := ioc$895_unit_soft_sectored;
        ELSEIF disk_status_895_p^.error_code = 1 THEN
          display_message := TRUE;
          msg := 'INTERFACE ERROR';
          disk_log_data_p^.symptom_code := ioc$895_interface_error;
        ELSEIF disk_status_895_p^.error_code = 2 THEN
          msg := 'KZ BOARD ERROR';
          disk_log_data_p^.symptom_code := ioc$895_kz_board_error;
        ELSEIF disk_status_895_p^.error_code = 3 THEN
          msg := 'KX BOARD ERROR';
          disk_log_data_p^.symptom_code := ioc$895_kx_board_error;
        ELSEIF disk_status_895_p^.error_code = 4 THEN
          msg := 'CHANNEL ERROR';
          disk_log_data_p^.symptom_code := ioc$895_channel_error;
        ELSEIF disk_status_895_p^.error_code = 5 THEN
          msg := 'INCOMPLETE CHANNEL TRANSFER';
          disk_log_data_p^.symptom_code := ioc$895_incomplete_chan_xfer;
        ELSEIF disk_status_895_p^.error_code = 9 THEN
          msg := 'CCC FAILURE';
          disk_log_data_p^.symptom_code := ioc$895_ccc_failure;
        ELSEIF disk_status_895_p^.error_code = 6 THEN
          msg := 'PP-CCC DATA INTEGRITY';
          disk_log_data_p^.symptom_code := ioc$895_pp_ccc_data_integrity;
        ELSEIF disk_status_895_p^.error_code = 7 THEN
          msg := 'PP-DRIVE DATA INTEGRITY';
          disk_log_data_p^.symptom_code := ioc$895_pp_drive_data_integrity;
        ELSEIF disk_status_895_p^.error_code = 8 THEN
          msg := 'SEEK COMMAND TIMEOUT';
          disk_log_data_p^.symptom_code := ioc$895_seek_command_timeout;
        ELSEIF disk_status_895_p^.error_code = 12 THEN
          msg := 'UNCORRECTED CM ERROR';
          disk_log_data_p^.symptom_code := ioc$895_uncorrected_cm_error;
        ELSEIF disk_status_895_p^.error_code = 13 THEN
          msg := 'CM REJECT';
          disk_log_data_p^.symptom_code := ioc$895_cm_reject;
        ELSEIF disk_status_895_p^.error_code = 14 THEN
          msg := 'INVALID CM RESPONSE';
          disk_log_data_p^.symptom_code := ioc$895_invalid_cm_response;
        ELSEIF disk_status_895_p^.error_code = 15 THEN
          msg := 'CM RESPONSE CODE PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_cm_response_pe;
        ELSEIF disk_status_895_p^.error_code = 16 THEN
          msg := 'CMI READ DATA PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$895_cmi_read_pe;
        ELSEIF disk_status_895_p^.error_code = 17 THEN
          msg := 'OVERFLOW ERROR';
          disk_log_data_p^.symptom_code := ioc$895_overflow_error;
        ELSEIF disk_status_895_p^.error_code = 18 THEN
          msg := 'JY BOARD ERROR';
          disk_log_data_p^.symptom_code := ioc$895_jy_board_error;
        ELSEIF disk_status_895_p^.error_code = 10 THEN
          msg := 'IOU FAILURE - OPERATIONAL STATUS WRONG';
          disk_log_data_p^.symptom_code := ioc$895_iou_failure_st_err;
        ELSEIF disk_status_895_p^.error_code = 11 THEN
          msg := 'IOU FAILURE - TEST MODE FAILURE';
          disk_log_data_p^.symptom_code := ioc$895_iou_failure_data_err;
        ELSEIF disk_status_895_p^.error_code = 19 THEN
          msg := 'TRANSFER IN PROGRESS DID NOT CLEAR';
          disk_log_data_p^.symptom_code := ioc$895_tip_not_clear;
        ELSEIF disk_status_895_p^.error_code = 20 THEN
          msg := 'T PRIME REGISTER NOT EMPTY';
          disk_log_data_p^.symptom_code := ioc$895_t_reg_not_empty;
        ELSE
          disk_log_data_p^.symptom_code := ioc$895_indeterminate;
        IFEND;
      IFEND;

{Determine Hydra symptom message.}

    = ioc$dt_mshydra =
      disk_log_data_p^.physical_unit := physical_unit;
      IF hydra_status_p^.cm_status1.manual_intervention_code_valid THEN
        manual_intervention_code := hydra_status_p^.cm_status1.manual_intervention_code;
      ELSE
        manual_intervention_code := 0;
      IFEND;
      IF hydra_status_p^.cm_status1.system_intervention_code_valid THEN
        system_intervention_code := hydra_status_p^.cm_status1.system_intervention_code;
      ELSE
        system_intervention_code := 0;
      IFEND;
      IF hydra_status_p^.cm_status1.delay_status_valid THEN
        delay_status_code := hydra_status_p^.cm_status1.delay_code;
      ELSE
        delay_status_code := 0;
      IFEND;
      IF hydra_status_p^.cm_status2.manual_intervention_code_valid THEN
        manual_intervention_code := hydra_status_p^.cm_status2.manual_intervention_code;
      ELSE
        manual_intervention_code := 0;
      IFEND;
      IF hydra_status_p^.cm_status2.system_intervention_code_valid THEN
        system_intervention_code := hydra_status_p^.cm_status2.system_intervention_code;
      ELSE
        system_intervention_code := 0;
      IFEND;
      IF hydra_status_p^.cm_status2.delay_status_valid THEN
        delay_status_code := hydra_status_p^.cm_status2.delay_code;
      ELSE
        delay_status_code := 0;
      IFEND;
      cell_p := ^hydra_status_p^.general_status.first_general_status;
      error_status_p := cell_p;

      IF hydra_status_p^.general_status.level_2_diagnostics_started AND
            ((unrecovered_error = 2) OR (pp_response_p^.response_code.primary_response =
            ioc$unsolicited_response)) THEN
        display_message := TRUE;
        msg := 'EXECUTING LEVEL II DIAGNOSTICS';
        disk_log_data_p^.symptom_code := ioc$h_exec_level_ii_diagnostics;
        down_status := ioc$executing_diagnostics;
      ELSEIF hydra_status_p^.general_status.level_2_diagnostics_passed THEN
        display_message := TRUE;
        msg := 'LEVEL II DIAGNOSTICS PASSED';
        disk_log_data_p^.symptom_code := ioc$h_lev_ii_diagnostics_passed;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF hydra_status_p^.general_status.level_1_diagnostics_started AND
            ((unrecovered_error = 2) OR (pp_response_p^.response_code.primary_response =
            ioc$unsolicited_response)) THEN
        display_message := TRUE;
        msg := 'EXECUTING LEVEL I DIAGNOSTICS';
        disk_log_data_p^.symptom_code := ioc$h_exec_level_i_diagnostics;
        down_status := ioc$executing_diagnostics;
      ELSEIF hydra_status_p^.general_status.level_1_diagnostics_passed THEN
        display_message := TRUE;
        msg := 'LEVEL I DIAGNOSTICS PASSED';
        disk_log_data_p^.symptom_code := ioc$h_lev_i_diagnostics_passed;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF hydra_status_p^.general_status.spindle_powered_up THEN
        display_message := TRUE;
        msg := 'SPINDLE POWERED UP';
        disk_log_data_p^.symptom_code := ioc$h_spindle_powered_up;
        disk_log_data_p^.failure_severity := 3;
      ELSEIF hydra_status_p^.general_status.sector_size_not_4096 THEN
        display_message := TRUE;
        msg := 'SECTOR SIZE IS NOT 4096';
        disk_log_data_p^.symptom_code := ioc$h_sector_size_not_4096;
      ELSEIF hydra_status_p^.general_status.not_same_host_id THEN
        display_message := TRUE;
        msg := 'HOST IDS ARE DIFFERENT';
        disk_log_data_p^.symptom_code := ioc$h_not_same_host_id;
      ELSEIF pp_response_p^.abnormal_status.recording_medium_error THEN
        msg := 'MEDIA FAILURE';
        disk_log_data_p^.symptom_code := ioc$h_media_failure;
      ELSEIF pp_response_p^.abnormal_status.function_timeout THEN
        msg := 'FUNCTION TIMEOUT';
        disk_log_data_p^.symptom_code := ioc$h_function_timeout;
      ELSEIF hydra_status_p^.general_status.output_channel_full THEN
        msg := 'CHANNEL DOESNT GO EMPTY';
        disk_log_data_p^.symptom_code := ioc$h_channel_doesnt_go_empty;
      ELSEIF hydra_status_p^.general_status.incomplete_sector_transfer THEN
        msg := 'INCOMPLETE I4 TRANSFER';
        disk_log_data_p^.symptom_code := ioc$h_incomplete_i4_transfer;
      ELSEIF hydra_status_p^.general_status.channel_initialization_error THEN
        msg := 'CHANNEL INITIALIZATION ERROR';
        disk_log_data_p^.symptom_code := ioc$h_channel_init_error;
      ELSEIF hydra_status_p^.general_status.cannot_select_controller THEN
        msg := 'CANNOT SELECT THE CONTROLLER';
        disk_log_data_p^.symptom_code := ioc$h_cannot_select_controller;
      ELSEIF hydra_status_p^.general_status.incorrect_controller_selected THEN
        msg := 'INCORRECT CONTROLLER WAS SELECTED';
        disk_log_data_p^.symptom_code := ioc$h_incorrect_controller;
      ELSEIF hydra_status_p^.general_status.pp_timed_out_a_command THEN
        msg := 'PP TIMED OUT A COMMAND';
        disk_log_data_p^.symptom_code := ioc$h_pp_timed_out_a_command;
      ELSEIF hydra_status_p^.general_status.controller_reserved THEN
        msg := 'CONTROLLER RESERVED';
        disk_log_data_p^.symptom_code := ioc$h_controller_reserved;
      ELSEIF pp_response_p^.abnormal_status.interface_error THEN
        display_message := TRUE;
        msg := 'SOFTWARE FAILURE';
        disk_log_data_p^.symptom_code := ioc$h_software_failure;
      ELSEIF manual_intervention_code = 0C1(16) THEN
        msg := 'DRIVE NOT READY - MIC1';
        disk_log_data_p^.symptom_code := ioc$h_drive_not_ready;
      ELSEIF error_status_p^.uncorrected_cm_error THEN
        msg := 'UNCORRECTED CM ERROR';
        disk_log_data_p^.symptom_code := ioc$h_uncorrected_cm_error;
      ELSEIF error_status_p^.cm_reject THEN
        msg := 'CM REJECT';
        disk_log_data_p^.symptom_code := ioc$h_cm_reject;
      ELSEIF error_status_p^.invalid_cm_response THEN
        msg := 'INVALID CM RESPONSE CODE';
        disk_log_data_p^.symptom_code := ioc$h_invalid_response_code;
      ELSEIF error_status_p^.response_code_parity_error THEN
        msg := 'CM RESPONSE CODE PARITY ERROR';
        disk_log_data_p^.symptom_code := ioc$h_cm_response_code_pe;
      ELSEIF error_status_p^.cmi_read_data_parity_error THEN
        msg := 'CMI READ DATA PARITY ERROR';
        disk_log_data_p^.symptom_code := ioc$h_cmi_read_data_pe;
      ELSEIF error_status_p^.overflow_error THEN
        msg := 'INPUT BUFFER OVERFLOW';
        disk_log_data_p^.symptom_code := ioc$h_input_buffer_overflow;
      ELSEIF error_status_p^.jp_jy_data_error THEN
        msg := 'JP/JY DATA PARITY ERROR';
        disk_log_data_p^.symptom_code := ioc$h_jp_jy_data_parity_error;
      ELSEIF error_status_p^.bas_parity_error THEN
        msg := 'BAS PARITY ERROR';
        disk_log_data_p^.symptom_code := ioc$h_bas_parity_error;
      ELSEIF error_status_p^.jz_error THEN
        IF manual_intervention_code = 63(16) THEN
          msg := 'OUTPUT ISI PARITY ERROR';
          disk_log_data_p^.symptom_code := ioc$h_output_isi_parity;
        ELSE
          msg := 'JZ ERROR';
          disk_log_data_p^.symptom_code := ioc$h_jz_error;
        IFEND;
      ELSEIF error_status_p^.jp_jy_error THEN
        msg := 'JP/JY ERROR';
        disk_log_data_p^.symptom_code := ioc$h_jp_jy_error;
      ELSEIF error_status_p^.jn_jx_error THEN
        msg := 'JN/JX ERROR';
        disk_log_data_p^.symptom_code := ioc$h_jn_jx_error;
      ELSEIF hydra_status_p^.general_status.timeout_tip_or_t_reg_not_empty THEN
        msg := 'INCOMPLETE DMA TRANSFER';
        disk_log_data_p^.symptom_code := ioc$h_incomplete_dma_transfer;
      ELSEIF hydra_status_p^.general_status.timeout_t_register_byte_count THEN
        msg := 'T REGISTER BYTE COUNT NONZERO';
        disk_log_data_p^.symptom_code := ioc$h_t_register_byte_count;
      ELSEIF hydra_status_p^.general_status.invalid_execution_status THEN
        msg := 'INVALID CONTROLLER STATUS';
        disk_log_data_p^.symptom_code := ioc$h_invalid_controller_status;
      ELSEIF hydra_status_p^.general_status.adapter_controlware_error THEN
        msg := 'CONTROLLER INTERFACE ERROR';
        disk_log_data_p^.symptom_code := ioc$h_controller_interface_err;
      ELSE
        CASE system_intervention_code OF
        = 21(16) =
          msg := 'SEEK ERROR - SI21';
          disk_log_data_p^.symptom_code := ioc$h_seek_error;
        = 41(16) =
          msg := 'UNABLE TO READ HEADER - SI41';
          disk_log_data_p^.symptom_code := ioc$h_unable_to_read_header;
        = 42(16) =
          msg := 'HEADER MISCOMPARE - SI42';
          disk_log_data_p^.symptom_code := ioc$h_header_miscompare;
        = 43(16) =
          msg := 'UNABLE TO READ DATA - SI43';
          disk_log_data_p^.symptom_code := ioc$h_unable_to_read_data;
        = 68(16) =
          msg := 'TRANSFER COUNT ERROR - SI68';
          disk_log_data_p^.symptom_code := ioc$h_transfer_count_error;
        = 82(16) =
          msg := 'DISK NOT FORMATTED - SI82';
          disk_log_data_p^.symptom_code := ioc$h_disk_not_formatted;
        = 0A6(16) =
          msg := 'DIAGNOSTIC FAULT DETECTED - SIA6';
          disk_log_data_p^.symptom_code := ioc$h_diagnostic_fault_detected;
        = 0C1(16) =
          msg := 'COMMAND BLOCK NEGATED - SIC1';
          disk_log_data_p^.symptom_code := ioc$h_command_block_negated;
        ELSE
          CASE manual_intervention_code OF
          = 21(16) =
            msg := 'COMMAND BLOCK OVERWRITE - MI21';
            disk_log_data_p^.symptom_code := ioc$h_command_block_overwrite;
          = 22(16) =
            msg := 'ILLEGAL COMMAND BYTE - MI22';
            disk_log_data_p^.symptom_code := ioc$h_illegal_command_byte;
          = 23(16) =
            msg := 'ILLEGAL SECONDARY SEEK ADDRESS - MI23';
            disk_log_data_p^.symptom_code := ioc$h_illegal_sec_seek_address;
          = 24(16) =
            msg := 'ILLEGAL PRIMARY SEEK ADDRESS - MI24';
            disk_log_data_p^.symptom_code := ioc$h_illegal_pri_seek_address;
          = 25(16) =
            msg := 'ILLEGAL COMMAND PARAMETER - MI25';
            disk_log_data_p^.symptom_code := ioc$h_illegal_command_parameter;
          = 27(16) =
            msg := 'I/O ILLEGAL WRITE ERROR - MI27';
            disk_log_data_p^.symptom_code := ioc$h_io_illegal_write_error;
          = 28(16) =
            msg := 'END OF DISK REACHED - MI28';
            disk_log_data_p^.symptom_code := ioc$h_end_of_disk_reached;
          = 29(16) =
            msg := 'ILLEGAL DEVICE NUMBER - MI29';
            disk_log_data_p^.symptom_code := ioc$h_illegal_device_number;
          = 2A(16) =
            msg := 'ILLEGAL CONTROL FIELD - MI2A';
            disk_log_data_p^.symptom_code := ioc$h_illegal_control_field;
          = 41(16) =
            msg := 'I/O ILLEGAL DISCONNECT - MI41';
            disk_log_data_p^.symptom_code := ioc$h_io_illegal_disconnect;
          = 63(16) =
            msg := 'ISI I/O PARITY ERROR - MI63';
            disk_log_data_p^.symptom_code := ioc$h_isi_io_parity_error;
          = 64(16) =
            msg := 'R/W SEQUENCER RAM PARITY ERROR - MI64';
            disk_log_data_p^.symptom_code := ioc$h_rw_sequencer_ram_parity;
          = 65(16) =
            msg := 'MPU PARITY ERROR - MI65';
            disk_log_data_p^.symptom_code := ioc$h_mpu_parity_error;
          = 66(16) =
            msg := 'ECC FAULT - MI66';
            disk_log_data_p^.symptom_code := ioc$h_ecc_fault;
          = 67(16) =
            msg := 'VOLTAGE FAULT - MI67';
            disk_log_data_p^.symptom_code := ioc$h_voltage_fault;
          = 68(16) =
            msg := 'WRITE TRANSFER COUNT ERROR - MI68';
            disk_log_data_p^.symptom_code := ioc$h_write_transfer_count;
          = 6A(16) =
            msg := 'DIAGNOSTIC FAULT DETECTED - MI6A';
            disk_log_data_p^.symptom_code := ioc$h_diagnostic_fault_detected;
          = 6B(16) =
            msg := 'OVER TEMPERATURE FAULT - MI6B';
            disk_log_data_p^.symptom_code := ioc$h_over_temperature_fault;
          = 6C(16) =
            msg := 'NO READ/WRITE SEQUENCER RESPONSE - MI6C';
            disk_log_data_p^.symptom_code := ioc$h_no_rw_sequencer_response;
          = 6D(16) =
            msg := 'INVALID READ/WRITE SEQUENCER RESPONSE - MI6D';
            disk_log_data_p^.symptom_code := ioc$h_invalid_rw_sequencer_rsp;
          = 6E(16) =
            msg := 'READ/WRITE SEQUENCER STATUS OVERWRITE - MI6E';
            disk_log_data_p^.symptom_code := ioc$h_rw_sequencer_status_overw;
          = 6F(16) =
            msg := 'HYDRA HARDWARE FAULT - MI6F';
            disk_log_data_p^.symptom_code := ioc$h_hydra_hardware_fault;
          = 70(16) =
            msg := 'READ/WRITE SEQUENCER FAULT - MI70';
            disk_log_data_p^.symptom_code := ioc$h_rw_sequencer_fault;
          = 71(16) =
            msg := 'ZEROFILL TIMEOUT - MI71';
            disk_log_data_p^.symptom_code := ioc$h_zerofill_timeout;
          = 72(16) =
            msg := 'FUNCTION BUFFER PARITY ERROR - MI72';
            disk_log_data_p^.symptom_code := ioc$h_function_buffer_pe;
          = 73(16) =
            msg := 'PARTIAL SECTOR ERROR - MI73';
            disk_log_data_p^.symptom_code := ioc$h_partial_sector_error;
          = 81(16) =
            msg := 'DISK FAULT - MI81';
            disk_log_data_p^.symptom_code := ioc$h_disk_fault;
          = 90(16) =
            msg := 'NO SECTOR PULSE - MI90';
            disk_log_data_p^.symptom_code := ioc$h_no_sector_pulse;
          = 91(16) =
            msg := 'NO INDEX PULSE - MI91';
            disk_log_data_p^.symptom_code := ioc$h_no_index_pulse;
          = 92(16) =
            msg := 'CYLINDER/HEAD/SECTOR WRAP ERROR - MI92';
            disk_log_data_p^.symptom_code := ioc$h_cyl_head_sec_wrap_error;
          = 0C3(16) =
            msg := 'NO DISK RESPONSE - MIC3';
            disk_log_data_p^.symptom_code := ioc$h_no_disk_response;
          ELSE
            IF hydra_status_p^.general_status.timeout_pause THEN
              msg := 'PAUSE TIME OUT';
              disk_log_data_p^.symptom_code := ioc$h_pause_timeout;
            ELSEIF hydra_status_p^.general_status.timeout_tip THEN
              msg := 'TRANSFER IN PROGRESS DID NOT CLEAR';
              disk_log_data_p^.symptom_code := ioc$h_tip_didnt_clear;
            ELSEIF hydra_status_p^.general_status.incomplete_command_block_xfer THEN
              msg := 'INCOMPLETE COMMAND BLOCK TRANSFER';
              disk_log_data_p^.symptom_code := ioc$h_incomplete_cb_xfer;
            ELSEIF hydra_status_p^.general_status.incomplete_status_transfer THEN
              msg := 'INCOMPLETE STATUS TRANSFER';
              disk_log_data_p^.symptom_code := ioc$h_incomplete_status_xfer;
            ELSEIF hydra_status_p^.general_status.sa_dropped_hydra_status THEN
              msg := 'SELECT ACTIVE DROPPED WHEN READING CONTROLLER STATUS';
              disk_log_data_p^.symptom_code := ioc$h_sa_dropped_hydra_status;
            ELSEIF hydra_status_p^.general_status.incomplete_device_status_xfer THEN
              msg := 'INCOMPLETE DEVICE STATUS TRANSFER';
              disk_log_data_p^.symptom_code := ioc$h_incomplete_device_st_xfer;
            ELSEIF hydra_status_p^.general_status.sa_dropped_device_status THEN
              msg := 'SELECT ACTIVE DROPPED WHEN READING DEVICE STATUS';
              disk_log_data_p^.symptom_code := ioc$h_sa_dropped_device_status;
            ELSEIF hydra_status_p^.general_status.incomplete_error_reg_image_xfer THEN
              msg := 'INCOMPLETE ERROR REGISTER IMAGE TRANSFER';
              disk_log_data_p^.symptom_code := ioc$h_incomplete_eri_xfer;
            ELSEIF hydra_status_p^.general_status.sa_dropped_error_register_image THEN
              msg := 'SELECT ACTIVE DROPPED WHEN READING ERROR REGISTER IMAGE';
              disk_log_data_p^.symptom_code := ioc$h_sa_dropped_err_reg_image;
            ELSEIF hydra_status_p^.general_status.incomplete_error_log_transfer THEN
              msg := 'INCOMPLETE ERROR LOG TRANSFER';
              disk_log_data_p^.symptom_code := ioc$h_incomplete_error_log_xfer;
            ELSEIF hydra_status_p^.general_status.select_active_dropped_error_log THEN
              msg := 'SELECT ACTIVE DROPPED WHEN READING ERROR LOG';
              disk_log_data_p^.symptom_code := ioc$h_sa_dropped_error_log;
            ELSEIF hydra_status_p^.general_status.select_active_dropped_data THEN
              msg := 'SELECT ACTIVE DROPPED WHEN TRANSFERRING DATA';
              disk_log_data_p^.symptom_code := ioc$h_sa_dropped_data;
            ELSEIF hydra_status_p^.general_status.host_if_integrity_error THEN
              msg := 'HOST I/F INTEGRITY ERROR';
              disk_log_data_p^.symptom_code := ioc$h_host_if_integrity_error;
            ELSEIF hydra_status_p^.general_status.drive_if_integrity_error THEN
              msg := 'DRIVE I/F INTEGRITY ERROR';
              disk_log_data_p^.symptom_code := ioc$h_drive_if_integrity_error;
            ELSEIF error_status_p^.isi_input_error THEN
              msg := 'ISI INPUT ERROR';
              disk_log_data_p^.symptom_code := ioc$h_isi_input_error;
            ELSEIF error_status_p^.isi_timeout THEN
              msg := 'ISI TIMEOUT';
              disk_log_data_p^.symptom_code := ioc$h_isi_timeout;
            ELSEIF hydra_status_p^.general_status.media_failure OR
                  hydra_status_p^.general_status.unrecovered_media_error THEN
              msg := 'MEDIA FAILURE';
              disk_log_data_p^.symptom_code := ioc$h_media_failure;



            ELSE
              CASE delay_status_code OF
              = 21(16) =
                msg := 'MEDIA FAILURE';
                disk_log_data_p^.symptom_code := ioc$h_media_failure;
              = 22(16) =
                msg := 'SEEK ERROR - DS22';
                disk_log_data_p^.symptom_code := ioc$h_seek_error_retried;
              = 23(16), 24(16), 25(16), 26(16), 27(16) =
                msg := 'MEDIA FAILURE';
                disk_log_data_p^.symptom_code := ioc$h_media_failure;
              = 42(16) =
                msg := 'MEDIA FAILURE';
                disk_log_data_p^.symptom_code := ioc$h_media_failure;
              = 81(16) =
                msg := 'POWER-UP INITIALIZATION COMPLETE - DS81';
                disk_log_data_p^.symptom_code := ioc$h_power_up_complete;
                disk_log_data_p^.failure_severity := 3;
              = 83(16) =
                msg := 'HOST-GENERATED RESET COMPLETE - DS83';
                disk_log_data_p^.symptom_code := ioc$h_reset_complete;
                disk_log_data_p^.failure_severity := 3;
              = 84(16) =
                msg := 'PRIORITY OVERRIDE COMPLETE - DS84';
                disk_log_data_p^.symptom_code := ioc$h_priority_override;
                disk_log_data_p^.failure_severity := 3;
              = 85(16) =
                msg := 'HYDRA ON LINE - DS85';
                disk_log_data_p^.symptom_code := ioc$h_hydra_on_line;
                disk_log_data_p^.failure_severity := 3;


              ELSE
                disk_log_data_p^.symptom_code := ioc$hydra_indeterminate;
              CASEND;
            IFEND;
          CASEND;
        CASEND;
      IFEND;

      { Determine 9836/9853/DAS Drives symptom code

    = ioc$dt_ms9836_1, ioc$dt_msxmd_3, ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1, ioc$dt_ms5833_1p,
          ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5837_1, ioc$dt_ms5837_1p,
          ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4, ioc$dt_ms5838_1, ioc$dt_ms5838_1p,
          ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1, ioc$dt_ms47444_1p,
          ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =

      { Process PP isolated symptom codes }
      disk_log_data_p^.diagnostic_code := 0;
      IF cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$ms5831_x THEN
        disk_log_data_p^.physical_unit := disk_status_9836_1_p^.unit MOD 40(8);
      ELSE
        disk_log_data_p^.physical_unit := physical_unit;
      IFEND;
      CASE disk_status_9836_1_p^.error_id OF
      = 1 =
        disk_log_data_p^.symptom_code := ioc$9836_1_function_timeout;
        msg := 'FUNCTION TIMEOUT';
      = 2 =
        disk_log_data_p^.symptom_code := ioc$9836_1_ch_empty_when_act;
        msg := 'CHANNEL EMPTY WHEN ACTIVATED';
      = 3 =
        disk_log_data_p^.symptom_code := ioc$9836_1_period_c_error;
        msg := 'PERIOD COUNTER ERROR';
      = 4, 5 =
        disk_log_data_p^.symptom_code := ioc$9836_1_upper_ici_parity;
        msg := 'PP-IPI PARITY ERROR';
      = 6 =
        disk_log_data_p^.symptom_code := ioc$9836_1_iou_error;
        msg := 'IOU ERROR';
      = 7 =
        disk_log_data_p^.symptom_code := ioc$9836_1_incomplete_i4_xfer;
        msg := 'INCOMPLETE I4 TRANSFER';
      = 8 =
        disk_log_data_p^.symptom_code := ioc$9836_1_channel_not_empty;
        msg := 'CHANNEL NOT EMPTY';
      = 9 =
        disk_log_data_p^.symptom_code := ioc$9836_1_central_memory_error;
        msg := 'CENTRAL MEMORY ERROR';
      = 10 =
        disk_log_data_p^.symptom_code := ioc$9836_1_invalid_cm_response;
        msg := 'INVALID CM RESPONSE CODE';
      = 11 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cm_response_error;
        msg := 'CM RESPONSE CODE ERROR';
      = 12 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cmi_read_parity;
        msg := 'CMI READ DATA PARITY ERROR';
      = 13 =
        disk_log_data_p^.symptom_code := ioc$9836_1_jy_data_error;
        msg := 'Y BOARD DATA ERROR';
      = 14 =
        disk_log_data_p^.symptom_code := ioc$9836_1_bas_parity_error;
        msg := 'BAS PARITY ERROR';
      = 15 =
        disk_log_data_p^.symptom_code := ioc$9836_1_lz_error;
        msg := 'Z BOARD ERROR';
      = 16 =
        disk_log_data_p^.symptom_code := ioc$9836_1_jy_error;
        msg := 'Y BOARD ERROR';
      = 17 =
        disk_log_data_p^.symptom_code := ioc$9836_1_lx_error;
        msg := 'X BOARD ERROR';
      = 18 =
        disk_log_data_p^.symptom_code := ioc$9836_1_dma_test_failure;
        msg := 'DMA TEST MODE FAILURE';
      = 19 =
        disk_log_data_p^.symptom_code := ioc$9836_1_count_overflow;
        msg := 'DMA COUNT OVERFLOW';
      = 20 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cant_select_cont;
        msg := 'CAN NOT SELECT CONTROLLER';
      = 21 =
        disk_log_data_p^.symptom_code := ioc$9836_1_bit_sig_response_err;
        msg := 'BIT SIGNIFICANT RESPONSE ERROR';
      = 22 =
        disk_log_data_p^.symptom_code := ioc$9836_1_no_sync_in;
        msg := 'NO SYNC IN';
      = 23 =
        disk_log_data_p^.symptom_code := ioc$9836_1_sync_in_did_not_drop;
        msg := 'SYNC IN DID NOT DROP';
      = 24 =
        disk_log_data_p^.symptom_code := ioc$9836_1_ipi_sequence_error;
        msg := 'IPI SEQUENCE ERROR';
      = 25, 26 =
        disk_log_data_p^.symptom_code := ioc$9836_1_upper_ipi_ch_parity;
        msg := 'IPI CHANNEL PARITY ERROR';
      = 27 =
        disk_log_data_p^.symptom_code := ioc$9836_1_slave_in_not_set;
        msg := 'SLAVE IN NOT SET';
      = 28 =
        disk_log_data_p^.symptom_code := ioc$9836_1_slave_in_not_drop;
        msg := 'SLAVE IN DID NOT DROP';
      = 29 =
        disk_log_data_p^.symptom_code := ioc$9836_1_incomplete_transfer;
        msg := 'INCOMPLETE TRANSFER';
      = 30 =
        disk_log_data_p^.symptom_code := ioc$9836_1_ch_stayed_active;
        msg := 'CHANNEL STAYED ACTIVE';
      = 31 =
        disk_log_data_p^.symptom_code := ioc$9836_1_buffer_counter_e;
        msg := 'BUFFER COUNTER_ERROR';
      = 32 =
        disk_log_data_p^.symptom_code := ioc$9836_1_sync_counter_error;
        msg := 'SYNC COUNTER ERROR';
      = 33 =
        disk_log_data_p^.symptom_code := ioc$9836_1_lost_data;
        msg := 'LOST DATA';
      = 34 =
        disk_log_data_p^.symptom_code := ioc$9836_1_bus_parity;
        msg := 'BUS PARITY';
      = 35 =
        disk_log_data_p^.symptom_code := ioc$9836_1_command_reject;
        msg := 'COMMAND REJECT';
      = 36 =
        disk_log_data_p^.symptom_code := ioc$9836_1_sync_out_not_sync_in;
        msg := 'SYNC OUTS NOT EQUAL SYNC INS';
      = 37 =
        disk_log_data_p^.symptom_code := ioc$9836_1_bus_b_ack_incorrect;
        msg := 'BUS B ACKNOWLEGE INCORRECT';
      = 38 =
        disk_log_data_p^.symptom_code := ioc$9836_1_no_cont_response;
        msg := 'NO CONTROLLER RESPONSE';
      = 39 =
        disk_log_data_p^.symptom_code := ioc$9836_1_ending_status_wrong;
        msg := 'ENDING STATUS WRONG';
      = 50 =
        disk_log_data_p^.symptom_code := ioc$9836_1_executing_cont_diag;
        msg := 'EXECUTING_CONTROLLER_DIAGNOSTICS';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
        down_status := ioc$executing_diagnostics;
      = 51 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cont_diag_passed;
        msg := 'CONTROLLER DIAGNOSTICS PASSED';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
      = 52 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cont_diag_passed_2;
        msg := 'CONTROLLER DIAGNOSTICS PASSED - LAST ERROR CODE IS     ';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
        IF cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$ms5831_x THEN
          dpp$convert_int_to_str_hex (4, disk_status_9836_1_p^.residual_word_count, msg (52, * ));
          disk_log_data_p^.diagnostic_code := disk_status_9836_1_p^.residual_word_count;
        ELSEIF (disk_status_9836_1_p^.response_packets [5] = 84(16)) AND
              (disk_status_9836_1_p^.response_packets [29] <> 0) THEN
          disk_log_data_p^.diagnostic_code := disk_status_9836_1_p^.response_packets [29] *
                100(16) + disk_status_9836_1_p^.response_packets [30];
          dpp$convert_int_to_str_hex (4, disk_log_data_p^.diagnostic_code, msg (52, * ));
        ELSE
          disk_log_data_p^.symptom_code := ioc$9836_1_cont_diag_passed;
          msg := 'CONTROLLER DIAGNOSTICS PASSED';
        IFEND;
      = 54 =
        disk_log_data_p^.symptom_code := ioc$9836_1_dr_alt_port_event;
        disk_log_data_p^.failure_severity := 3;
      = 55 =
        disk_log_data_p^.symptom_code := ioc$9836_1_restoring_drive;
        msg := 'RESTORING DRIVE';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
      = 56 =
        disk_log_data_p^.symptom_code := ioc$9836_1_restore_complete;
        msg := 'DRIVE RESTORATION COMPLETE';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
      = 57 =
        disk_log_data_p^.symptom_code := ioc$9836_1_formatting_drive;
        msg := 'FORMATTING DRIVE';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
      = 58 =
        disk_log_data_p^.symptom_code := ioc$9836_1_format_complete;
        msg := 'FORMAT COMPLETE';
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
      = 59 =
        disk_log_data_p^.symptom_code := ioc$9836_1_par_prot_disabled;
        display_message := TRUE;
        disk_log_data_p^.failure_severity := 3;
        CASE disk_type OF
        = 010c(16) =
          msg := '5833_1P PARITY PROTECTION DISABLED';
        = 010e(16) =
          msg := '5833_3P PARITY PROTECTION DISABLED';
        = 0111(16) =
          msg := '5838_1P PARITY PROTECTION DISABLED';
        = 0113(16) =
          msg := '5838_3P PARITY PROTECTION DISABLED';
        = 0116(16) =
          msg := '47444_1P PARITY PROTECTION DISABLED';
        = 0118(16) =
          msg := '47444_3P PARITY PROTECTION DISABLED';
        = 11b(16) =
          msg := '5837_1P PARITY PROTECTION DISABLED';
        = 11d(16) =
          msg := '5837_3P PARITY PROTECTION DISABLED';
        ELSE
          msg := '???????? PARITY PROTECTION DISABLED';
        CASEND;
        signal_contents.signal_type := cmc$parity_disabled_signal;
        signal_contents.parity_logical_unit := logical_unit;
        signal_contents.parity_physical_unit := disk_status_9836_1_p^.unit MOD 20(16);
        signal_contents.fill5 := ' ';
        signal.identifier := cmc$configuration_signal_id;
        #UNCHECKED_CONVERSION (signal_contents, signal.contents);
        tmp$send_signal (tmv$system_job_monitor_gtid, signal, mtr_status);
      = 61 =
        analyze_response_packets (disk_status_9836_1_p, pp_response_p^.response_length,
              disk_log_data_p^.controller_type, disk_log_data_p^.disk_type, response_packet);
        display_message := TRUE;
        disk_log_data_p^.symptom_code := ioc$9836_1_drive_failure;
        disk_log_data_p^.diagnostic_code := response_packet.id23_error_code;
        msg := 'DRIVE FAILURE';
        CASE disk_type OF
        = ioc$dt_ms5832_1, ioc$dt_ms5832_2 =
          IF (response_packet.id23_facility_status <> 0) AND (response_packet.id23_error_code = 0) THEN
            send_ssd_battery_signal := TRUE;
            IF response_packet.id23_facility_status = 83(16) THEN
              disk_log_data_p^.symptom_code := ioc$9836_1_ssd_battery_to_low;
              msg := 'SSD BATTERY TOO LOW FOR BACKUP';
            ELSEIF response_packet.id23_facility_status = 84(16) THEN
              disk_log_data_p^.symptom_code := ioc$9836_1_ssd_battery_test;
              msg := 'SSD BATTERY TEST FAILED';
            ELSEIF response_packet.id23_facility_status = 85(16) THEN
              disk_log_data_p^.symptom_code := ioc$9836_1_ssd_battery_old;
              msg := 'SSD BATTERY OLD - REPLACE';
            ELSE
              send_ssd_battery_signal := FALSE;
            IFEND;
            IF send_ssd_battery_signal = TRUE THEN
              disk_log_data_p^.failure_severity := 3;
              signal_contents.signal_type := cmc$ssd_battery_alert_signal;
              signal_contents.battery_alert_logical_unit := logical_unit;
              signal_contents.battery_alert_physical_unit := disk_status_9836_1_p^.unit MOD 20(16);
              signal_contents.battery_alert_condition := disk_log_data_p^.symptom_code;
              signal_contents.fill7 := ' ';
              signal.identifier := cmc$configuration_signal_id;
              #UNCHECKED_CONVERSION (signal_contents, signal.contents);
              tmp$send_signal (tmv$system_job_monitor_gtid, signal, mtr_status);
              send_ssd_battery_signal := FALSE;
            IFEND;
          IFEND;
        CASEND;
      = 62 =
        disk_log_data_p^.symptom_code := ioc$9836_1_media_failure;
        msg := 'MEDIA FAILURE';
      = 70 =
        disk_log_data_p^.symptom_code := ioc$9836_1_lrc_error;
        msg := 'LRC ERROR';
      = 71 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cont_intervention;
        msg := 'CONTROLLER INTERVENTION REQUIRED';
      = 72 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cont_machine_exc;
        msg := 'CONTROLLER MACHINE EXCEPTION';
      = 73 =
        disk_log_data_p^.symptom_code := ioc$9836_1_command_exception;
        msg := 'COMMAND EXCEPTION';
      = 60, 74 =
        disk_log_data_p^.symptom_code := ioc$9836_1_microcode_exec_error;
        msg := 'MICROCODE EXECUTION ERROR';
      = 53, 75 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cont_alt_port_event;
        disk_log_data_p^.failure_severity := 3;
      = 76 =
        disk_log_data_p^.symptom_code := ioc$9836_1_unexpected_response;
        msg := 'UNEXPECTED RESPONSE';
      = 77 =
        disk_log_data_p^.symptom_code := ioc$9836_1_drive_rsvd_other_p;
        msg := 'DRIVE RESERVED TO OTHER CONTROLLER PORT';
      = 78 =
        disk_log_data_p^.symptom_code := ioc$9836_1_controller_over_temp;
        msg := 'CONTROLLER OVER TEMPERATURE';
        display_message := TRUE;

        signal_contents.signal_type := cmc$controller_overtemp_signal;
        signal_contents.overtemp_element_address.address_specifier := cmv$controller_address;
        signal_contents.overtemp_element_address.channel := channel;
        signal_contents.overtemp_element_address.channel_address := equipment;
        signal_contents.overtemp_element_address.unit_address := 0;
        signal_contents.fill4 := ' ';
        signal.identifier := cmc$configuration_signal_id;
        #UNCHECKED_CONVERSION (signal_contents, signal.contents);
        tmp$send_signal (tmv$system_job_monitor_gtid, signal, mtr_status);
      = 95 =
        disk_log_data_p^.symptom_code := ioc$9836_1_no_unit_oper_resp;
        msg := 'NO UNIT OPERATIONAL RESPONSE';
      = 96 =
        disk_log_data_p^.symptom_code := ioc$9836_1_das_head_shift;
        msg := 'DAS HEAD SHIFT DETECTED';
        disk_log_data_p^.failure_severity := 3;
        IF cmv$enable_head_shift_message <> cmc$disable_head_shift_message THEN
          display_message := cmv$enable_head_shift_message IN
                $t$enable_head_shift_messages [cmc$cwl_new_head_shift_message, cmc$cwl_old_head_shift_message,
                cmc$full_new_head_shift_message, cmc$full_old_head_shift_message];
          new_head_shift_display_message := cmv$enable_head_shift_message IN
                $t$enable_head_shift_messages [cmc$cwl_new_head_shift_message,
                cmc$full_new_head_shift_message];

          IF new_head_shift_display_message THEN
            msg := 'HEAD SHIFT:';
          ELSE
            msg := 'DAS HEAD SHIFT DETECTED';
          IFEND;

          signal_contents.signal_type := cmc$das_head_shift_signal;
          signal_contents.hd_shift_logical_unit := logical_unit;
          signal_contents.hd_shift_physical_unit := disk_status_9836_1_p^.unit MOD 20(16);
          signal_contents.fill6 := ' ';
          signal.identifier := cmc$configuration_signal_id;
          #UNCHECKED_CONVERSION (signal_contents, signal.contents);
          IF cmv$enable_head_shift_message IN $t$enable_head_shift_messages
                [cmc$om_head_shift_message, cmc$full_new_head_shift_message, cmc$full_old_head_shift_message]
                THEN
            tmp$send_signal (tmv$system_job_monitor_gtid, signal, mtr_status);
          IFEND;
        IFEND;
      = 110 =
        disk_log_data_p^.symptom_code := ioc$9836_1_pp_cont_data_integ;
        msg := 'PP-CONTROLLER DATA INTEGRITY';
      = 111 =
        disk_log_data_p^.symptom_code := ioc$9836_1_cm_drive_data_integ;
        msg := 'CM-DRIVE DATA INTEGRITY';
      = 120 =
        disk_log_data_p^.symptom_code := ioc$9836_1_software_failure;
        IF disk_status_9836_1_p^.request_retry = 0 THEN
          display_message := TRUE;
        IFEND;
        msg := 'SOFTWARE FAILURE';
      = 121 =
        disk_log_data_p^.symptom_code := ioc$9836_1_wrong_drive_config;
        msg := 'WRONG DRIVE TYPE';
        display_message := TRUE;
      = 130 =
        disk_log_data_p^.symptom_code := ioc$9836_1_defect_mgmt_failure;
        IF disk_status_9836_1_p^.request_retry = 0 THEN
          display_message := TRUE;
        IFEND;
        msg := 'DEFECT MANAGEMENT FAILURE';
      = 140 =
        disk_log_data_p^.symptom_code := ioc$9836_1_wrong_drive_type;
        msg := '         CONFIGURED -          FOUND';
        disk_log_data_p^.actual_drive_type := disk_status_9836_1_p^.actual_drive_type MOD 17;
        j := (disk_status_9836_1_p^.actual_drive_type MOD 17) * 8;
        k := ((disk_type MOD 100(16)) - 9) * 8;
        FOR i := 1 TO 8 DO
          msg (i) := v$das_type (i + k);
          msg (i + 22) := v$das_type (i + j);
        FOREND;
      = 141 =
        disk_log_data_p^.symptom_code := ioc$9836_1_drive_init_required;
        msg := 'DRIVE INITIALIZATION REQUIRED';
      = 142 =
        disk_log_data_p^.symptom_code := ioc$9836_1_no_parallel_support;
        msg := 'CONTROLLER DOES NOT SUPPORT PARALLEL';
      = 0 =
        {Process CPU isolated symptom codes if none found in PP
        analyze_response_packets (disk_status_9836_1_p, pp_response_p^.response_length,
              disk_log_data_p^.controller_type, disk_log_data_p^.disk_type, response_packet);
        IF response_packet.id24_present THEN
          IF response_packet.id24_byte1_bit7 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_not_operable;
            msg := 'DRIVE NOT OPERATIONAL';
            IF pp_response_p^.response_code.primary_response = ioc$unsolicited_response THEN
              display_message := TRUE;
            IFEND;
          ELSEIF response_packet.id24_byte1_bit6 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_not_ready;
            msg := 'DRIVE NOT READY';
            IF pp_response_p^.response_code.primary_response = ioc$unsolicited_response THEN
              display_message := TRUE;
            IFEND;
          ELSEIF response_packet.id24_byte1_bit1 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_rsvd_other_c;
            msg := 'DRIVE RESERVED TO OTHER CONTROLLER';
          ELSE
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_intervention;
            msg := 'DRIVE INTERVENTION REQUIRED';
          IFEND;
        ELSEIF response_packet.id26_present THEN
          disk_log_data_p^.diagnostic_code := response_packet.id26_error_code;
          IF response_packet.id26_byte2_bit6 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_uncorr_data_ck;
            msg := 'UNCORRECTABLE DATA CHECK';
          ELSEIF response_packet.id26_byte2_bit4 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_hw_write_protect;
            msg := 'HARDWARE WRITE PROTECTED';
          ELSEIF response_packet.id26_byte10 = 11(16) THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_ecc_error;
            msg := 'DRIVE ECC ERROR';
          ELSEIF response_packet.id26_byte10 = 13(16) THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_missing_sync;
            msg := 'MISSING SYNC OCTET ON DRIVE';
          ELSEIF response_packet.id26_byte10 = 19(16) THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_sector_not_found;
            msg := 'SECTOR NOT FOUND';
          ELSEIF response_packet.id26_byte2_bit5 THEN
            IF response_packet.id26_byte10 = 0e1(16) THEN
              disk_log_data_p^.symptom_code := ioc$9836_1_drive_rsvd_other_c;
              msg := 'DRIVE RESERVED TO OTHER CONTROLLER';
            ELSE
              disk_log_data_p^.symptom_code := ioc$9836_1_drive_fatal_error;
              msg := 'DRIVE FATAL ERROR';
            IFEND;
          ELSE
            disk_log_data_p^.symptom_code := ioc$9836_1_drive_exception;
            msg := 'DRIVE MACHINE EXCEPTION';
          IFEND;
        ELSEIF response_packet.id29_present THEN
          disk_log_data_p^.diagnostic_code := response_packet.id29_error_code;
          IF response_packet.id29_byte2_bit6 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_error_retry;
          ELSEIF response_packet.id29_byte2_bit5 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_data_retry;
          ELSEIF response_packet.id29_byte2_bit4 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_motion_retry;
          ELSEIF response_packet.id29_byte2_bit3 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_data_correction;
          ELSEIF response_packet.id29_byte6_bit7 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_parity_dr_corr;
          ELSEIF response_packet.id29_byte2_bit2 THEN
            disk_log_data_p^.symptom_code := ioc$9836_1_soft_error;
          ELSE
            disk_log_data_p^.symptom_code := ioc$9836_1_indeterminate;
          IFEND;
        ELSE
          disk_log_data_p^.symptom_code := ioc$9836_1_indeterminate;
        IFEND;
      ELSE
        disk_log_data_p^.symptom_code := ioc$9836_1_indeterminate;
      CASEND;

{NTDD Symptoms, for now, just a debug message to find that data error
    = ioc$dt_msntdd_1, ioc$dt_msntdd_2, ioc$dt_msntdd_3, ioc$dt_msntdd_4, ioc$dt_msntdd_5, ioc$dt_msntdd_6 =

      { Process PP isolated symptom codes }
      disk_log_data_p^.diagnostic_code := 0;
      disk_log_data_p^.physical_unit := disk_status_9836_1_p^.unit MOD 40(8);

      CASE disk_status_9836_1_p^.error_id OF
      = 1 = {our throttling debug issue
        pico_special_request := TRUE;

        {we do not wanna count it in the disk statistik, as we will end up here for each transfer for
        { debugging
        disk_log_data_p^.failure_severity := 3;

        p$analyze_pico_throttling_bits (disk_status_9836_1_p, channel.number, iou_number,
              completed_request_p);
      ELSE
      CASEND;
    ELSE
      disk_log_data_p^.physical_unit := 0;
      CASE cmv$logical_pp_table_p^ [pp].controller_info.controller_type OF
      = cmc$ms7154_x, cmc$ms7155_1, cmc$ms7155_1x =
        disk_log_data_p^.symptom_code := ioc$indeterminate;
      = cmc$ms7255_1_1, cmc$ms7255_1_2 =
        disk_log_data_p^.symptom_code := ioc$isd_indeterminate;
      = cmc$ms7165_2x =
        disk_log_data_p^.symptom_code := ioc$895_indeterminate;
      = cmc$mshydra_ct =
        disk_log_data_p^.symptom_code := ioc$hydra_indeterminate;
      = cmc$mscm3_ct, cmc$ms5831_x, cmc$msntdc_1, cmc$msntdc_2 =
        disk_log_data_p^.symptom_code := ioc$9836_1_indeterminate;

      ELSE
      CASEND;
    CASEND;

{Save detailed status.

    bi := iov$error_count MOD (UPPERBOUND (iov$detailed_status_buffer) -
          LOWERBOUND (iov$detailed_status_buffer) + 1) + LOWERBOUND (iov$detailed_status_buffer);
    iov$error_count := iov$error_count + 1;
    IF completed_request_p <> NIL THEN
      iov$detailed_status_buffer [bi].request := completed_request_p^;
    IFEND;
    iov$detailed_status_buffer [bi].resp := disk_log_data_p^;
    iov$detailed_status_buffer [bi].msg := msg;

{Update error counters.

    IF (iov$disk_pp_usage_p <> NIL) AND (iov$disk_unit_usage_p <> NIL) THEN
      IF (pp <> 0) AND (logical_unit <> 0) THEN
        IF (iov$disk_pp_usage_p^ [pp] <> NIL) AND (iov$disk_unit_usage_p^ [logical_unit] <> NIL) THEN
          CASE disk_log_data_p^.failure_severity OF
          = 0 =
            iov$disk_unit_usage_p^ [logical_unit]^.recovered_errors :=
                  iov$disk_unit_usage_p^ [logical_unit]^.recovered_errors + 1;
            iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].recovered_errors :=
                  iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].recovered_errors + 1;
          = 1 =
            iov$disk_unit_usage_p^ [logical_unit]^.unrecovered_errors :=
                  iov$disk_unit_usage_p^ [logical_unit]^.unrecovered_errors + 1;
            iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].unrecovered_errors :=
                  iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].unrecovered_errors + 1;
          = 2 =
            iov$disk_unit_usage_p^ [logical_unit]^.intermediate_errors :=
                  iov$disk_unit_usage_p^ [logical_unit]^.intermediate_errors + 1;
            iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].intermediate_errors :=
                  iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].intermediate_errors + 1;
          ELSE;
          CASEND;
        IFEND;
      IFEND;
    IFEND;
{Display mdd message.

    IF pico_special_request THEN
      previous_error := TRUE; {do not emit te message
    ELSEIF (completed_request_p <> NIL) AND (completed_request_p^.request_info.list_length > 0) THEN
      mmp$determine_error_state (completed_request_p^.request_info.list_p,
            completed_request_p^.request_info.list_length, previous_error);
    ELSE
      previous_error := FALSE;
    IFEND;

    IF (((unrecovered_error = 1) OR display_message) AND (NOT previous_error)) OR
          (down_status <> ioc$no_change) THEN
      disk_log_data_p^.display_message := TRUE;

      IF new_head_shift_display_message THEN

{ HEAD SHIFT: <element_name>, <vsn>, UNIT <nr>(16)
        j := clp$trimmed_string_size (iov$disk_unit_usage_p^ [logical_unit]^.element_name);
        i := 13;
        msg (13, j) := iov$disk_unit_usage_p^ [logical_unit]^.element_name;
        i := i + j;
        msg (i, 2) := ', ';
        i := i + 2;
        dmp$get_recorded_vsn (logical_unit, msg (i, 6));
        i := i + 6;
        msg (i, 7) := ', UNIT ';
        i := i + 7;
        j := disk_status_9836_1_p^.unit MOD 40(8);
        dpp$convert_int_to_str_hex (2, j, msg (i, * ));
        msg (i + 2, * ) := '(16)';

        dpp$display_error (msg);

      ELSE
        msg1 := 'IOU   CH    C  U   -      -                     C     T   S  ';
        dpp$convert_int_to_str_dec (1, iou_number, msg1 (4, * ));
        dpp$convert_int_to_str_dec (2, channel.number, msg1 (9, * ));

        CASE channel.port OF
        = cmc$port_a =
          msg1 (6, 1) := 'C'; { CIO Channel }
          msg1 (11, 1) := 'A'; { Change to CIO channel PORT A }
        = cmc$port_b =
          msg1 (6, 1) := 'C'; { CIO Channel }
          msg1 (11, 1) := 'B'; { Change to CIO channel PORT B }
        ELSE
          IF channel.concurrent THEN
            msg1 (6, 1) := 'C' { CIO Channel }
          IFEND;
        CASEND;
        IF logical_unit <> 0 THEN
          dpp$convert_int_to_str_dec (1, disk_log_data_p^.equipment, msg1 (14, * ));
          dpp$convert_int_to_str_dec (2, disk_log_data_p^.physical_unit, msg1 (17, * ));
          dmp$get_recorded_vsn (logical_unit, msg1 (21, 6));
        IFEND;
        IF disk_type = ioc$dt_mshydra THEN
          msg1 (16, 3) := '   '; { Remove Unit field for HYDRA }
        IFEND;

        IF unrecovered_error = 1 THEN
          msg1 (29, 11) := 'UNRECOVERED';
        IFEND;

        CASE disk_log_data_p^.logical_operation OF
        = ioc$log_read =
          msg1 (41, 5) := 'READ,';
        = ioc$log_read_flaw_map =
          msg1 (41, 4) := 'RFM,';
        = ioc$log_write =
          msg1 (41, 6) := 'WRITE,';
        = ioc$log_initialize_sectors =
          IF disk_type = ioc$dt_ms9836_1 THEN
            CASE disk_status_9836_1_p^.error_id OF
            = 96 =
              msg1 (41, 7) := 'SCREEN,';
            ELSE
              msg1 (41, 7) := 'FORMAT,';
            CASEND;
          ELSE
            msg1 (41, 7) := 'FORMAT,';
          IFEND;
        ELSE
        CASEND;

        dpp$convert_int_to_str_dec (4, disk_status_p^.general_status.starting_cylinder, msg1 (50, * ));
        dpp$convert_int_to_str_dec (2, disk_status_p^.general_status.failing_track, msg1 (56, * ));
        dpp$convert_int_to_str_dec (2, disk_status_p^.general_status.failing_sector, msg1 (60, * ));

        dpp$display_error (msg1);

{Display symptom message.

        dpp$display_error (msg);
      IFEND;

{Display execution time for formatting disk or executing controller diagnostics.

      CASE cmv$logical_pp_table_p^ [pp].controller_info.controller_type OF
      = cmc$mscm3_ct =
        CASE disk_log_data_p^.symptom_code OF
        = ioc$9836_1_formatting_drive =
          dpp$display_error ('MAXIMUM EXECUTION TIME: 90 MINUTES');
        = ioc$9836_1_executing_cont_diag =
          dpp$display_error ('MAXIMUM EXECUTION TIME: 2 MINUTES');
        ELSE
        CASEND;
      = cmc$ms5831_x, cmc$msntdc_1, cmc$msntdc_2 =
        CASE disk_log_data_p^.symptom_code OF
        = ioc$9836_1_formatting_drive =
          CASE disk_type OF
          = ioc$dt_ms5833_1, ioc$dt_ms5833_1p, ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4 =
            dpp$display_error ('MAXIMUM EXECUTION TIME: 5 MINUTES');
          = ioc$dt_ms5837_1, ioc$dt_ms5837_1p, ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4 =
            dpp$display_error ('MAXIMUM EXECUTION TIME: 8.25 MINUTES');
          = ioc$dt_ms5838_1, ioc$dt_ms5838_1p, ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4 =
            dpp$display_error ('MAXIMUM EXECUTION TIME: 6.5 MINUTES');
          = ioc$dt_ms47444_1, ioc$dt_ms47444_1p, ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =
            dpp$display_error ('MAXIMUM EXECUTION TIME: 9 MINUTES');
          = ioc$dt_msntdd_1 .. ioc$dt_msntdd_6 =
            dpp$display_error ('MAXIMUM EXECUTION TIME: some MINUTES');
          ELSE
            dpp$display_error ('MAXIMUM EXECUTION TIME: 5 MINUTES');
          CASEND;
        = ioc$9836_1_executing_cont_diag =
          dpp$display_error ('MAXIMUM EXECUTION TIME: 12 MINUTES');
        ELSE
        CASEND;
      ELSE
      CASEND;

{Check if channel, control module, or unit was downed.}

      IF (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$mscm3_ct) OR
            (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$ms5831_x) OR
            (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_1) OR
            (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_2) THEN
        IF disk_status_9836_1_p^.id = 1 THEN
          msg := 'CHANNEL DISABLED';
          dpp$display_error (msg);
          down_status := ioc$channel_down;
        IFEND;
        IF disk_status_9836_1_p^.id = 2 THEN
          msg := 'CONTROLLER DISABLED';
          dpp$display_error (msg);
          down_status := ioc$controller_down;
        IFEND;
        IF disk_status_9836_1_p^.id = 3 THEN
          msg := 'DRIVE DISABLED';
          dpp$display_error (msg);
          down_status := ioc$unit_down;
        IFEND;
      ELSE
        IF disk_status_p^.general_status.channel_down THEN
          CASE disk_type OF
          = ioc$dt_ms844_4x, ioc$dt_ms885_1x, ioc$dt_ms885_42 =
            msg := 'CONTROLLER DISABLED';
          = ioc$dt_ms834_2, ioc$dt_msfsd_2 =
            msg := 'ADAPTER DISABLED';
          = ioc$dt_mshydra =
            msg := 'CHANNEL DISABLED';
          = ioc$dt_ms895_2 =
            msg := 'CYBER COUPLER DISABLED';
          ELSE
          CASEND;
          dpp$display_error (msg);
          down_status := ioc$channel_down;
        IFEND;
        IF disk_status_p^.general_status.control_module_down THEN
          CASE disk_type OF
          = ioc$dt_mshydra =
            msg := 'CONTROLLER DISABLED';
          = ioc$dt_ms895_2 =
            msg := 'STORAGE DIRECTOR DISABLED';
          ELSE
            msg := 'CONTROL MODULE DISABLED';
          CASEND;
          dpp$display_error (msg);
          down_status := ioc$controller_down;
        IFEND;
        IF disk_status_p^.general_status.unit_down THEN
          msg := 'DRIVE DISABLED';
          dpp$display_error (msg);
          down_status := ioc$unit_down;
        IFEND;
      IFEND;

{Display detailed status.

      CASE disk_type OF
      = ioc$dt_ms844_4x, ioc$dt_ms885_1x, ioc$dt_ms885_42, ioc$dt_ms834_2, ioc$dt_msfsd_2, ioc$dt_ms895_2 =
        IF disk_status_p^.general_status.detailed_status_present THEN
          msg2 := 'GS       , DS                                                  ';
          msg3 := '                                                               ';
          IF (channel.concurrent) AND (disk_type = ioc$dt_ms895_2) THEN
            msg3 := 'ES                                                             ';
          IFEND;
          RESET detail_status_p;
          NEXT status_bytes_p IN detail_status_p;

          CASE disk_type OF
          = ioc$dt_ms844_4x, ioc$dt_ms885_1x, ioc$dt_ms885_42 =
            IF unrecovered_error = 1 THEN
              dpp$convert_int_to_str_octal (4, status_bytes_p^ [14], msg2 (4, * ));
            ELSE
              dpp$convert_int_to_str_octal (4, status_bytes_p^ [13], msg2 (4, * ));
            IFEND;

            FOR i := 1 TO 10 DO
              k := i * 5 + 10;
              IF unrecovered_error = 1 THEN
                dpp$convert_int_to_str_octal (4, status_bytes_p^ [i + 36], msg2 (k, * ));
                dpp$convert_int_to_str_octal (4, status_bytes_p^ [i + 46], msg3 (k, * ));
              ELSE
                dpp$convert_int_to_str_octal (4, status_bytes_p^ [i + 16], msg2 (k, * ));
                dpp$convert_int_to_str_octal (4, status_bytes_p^ [i + 26], msg3 (k, * ));
              IFEND;
            FOREND;
          = ioc$dt_ms834_2, ioc$dt_msfsd_2 =
            IF unrecovered_error = 1 THEN
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [14], msg2 (4, * ));
            ELSE
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [13], msg2 (4, * ));
            IFEND;

            FOR i := 1 TO 10 DO
              k := i * 5 + 10;
              IF unrecovered_error = 1 THEN
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 36], msg2 (k, * ));
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 46], msg3 (k, * ));
              ELSE
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 16], msg2 (k, * ));
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 26], msg3 (k, * ));
              IFEND;
            FOREND;
          ELSE
            IF unrecovered_error = 1 THEN
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [14], msg2 (4, * ));
              IF channel.concurrent THEN
                dpp$convert_int_to_str_hex (4, status_bytes_p^ [18], msg3 (4, * ));
              IFEND;
            ELSE
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [13], msg2 (4, * ));
              IF channel.concurrent THEN
                dpp$convert_int_to_str_hex (4, status_bytes_p^ [17], msg3 (4, * ));
              IFEND;
            IFEND;

            FOR i := 1 TO 10 DO
              k := i * 5 + 10;
              IF unrecovered_error = 1 THEN
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 40], msg2 (k, * ));
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 50], msg3 (k, * ));
              ELSE
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 20], msg2 (k, * ));
                dpp$convert_int_to_str_hex (3, status_bytes_p^ [i + 30], msg3 (k, * ));
              IFEND;
            FOREND;
          CASEND;

          dpp$display_error (msg2);

          dpp$display_error (msg3);

        IFEND;

      = ioc$dt_mshydra =
        IF (system_intervention_code = 0A6(16)) OR (manual_intervention_code = 6A(16)) THEN
          msg := 'FAILING FRUS =           ';
          IF hydra_status_p^.cm_status2.fru1 <> 0 THEN
            dpp$convert_int_to_str_dec (1, hydra_status_p^.cm_status2.fru1, msg (16, * ));
          IFEND;
          IF hydra_status_p^.cm_status2.fru2 <> 0 THEN
            dpp$convert_int_to_str_dec (1, hydra_status_p^.cm_status2.fru2, msg (18, * ));
          IFEND;
          IF hydra_status_p^.cm_status2.fru3 <> 0 THEN
            dpp$convert_int_to_str_dec (1, hydra_status_p^.cm_status2.fru3, msg (20, * ));
          IFEND;
          IF hydra_status_p^.cm_status2.fru4 <> 0 THEN
            dpp$convert_int_to_str_dec (1, hydra_status_p^.cm_status2.fru4, msg (22, * ));
          IFEND;
          dpp$display_error (msg);
        IFEND;

        msg2 := 'CS                              ';
        msg3 := 'ES                              ';
        RESET detail_status_p;
        NEXT status_bytes_p IN detail_status_p;

        FOR i := 1 TO 6 DO
          k := i * 5 - 1;
          IF unrecovered_error = 1 THEN
            dpp$convert_int_to_str_hex (4, status_bytes_p^ [i + 34], msg2 (k, * ));
          ELSE
            dpp$convert_int_to_str_hex (4, status_bytes_p^ [i + 24], msg2 (k, * ));
          IFEND;
        FOREND;

        IF disk_status_p^.general_status.device_status_present THEN
          msg3 := 'ES        DS                    ';
          FOR i := 1 TO 4 DO
            k := i * 5 + 9;
            IF unrecovered_error = 1 THEN
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [i + 40], msg3 (k, * ));
            ELSE
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [i + 30], msg3 (k, * ));
            IFEND;
          FOREND;
        IFEND;

        dpp$convert_int_to_str_hex (4, status_bytes_p^ [13], msg3 (4, * ));

        IF disk_status_p^.general_status.detailed_status_present THEN
          dpp$display_error (msg2);
        IFEND;
        dpp$display_error (msg3);

        IF disk_status_p^.general_status.error_register_image_present AND
              ((manual_intervention_code = 27(16)) OR (manual_intervention_code = 41(16)) OR
              (manual_intervention_code = 63(16)) OR (manual_intervention_code = 64(16)) OR
              (manual_intervention_code = 65(16)) OR (manual_intervention_code = 66(16)) OR
              (manual_intervention_code = 67(16)) OR (manual_intervention_code = 6E(16)) OR
              (manual_intervention_code = 6F(16)) OR (manual_intervention_code = 70(16)) OR
              (manual_intervention_code = 72(16)) OR (manual_intervention_code = 81(16))) THEN
          msg3 := 'ERI                                                              ';
          FOR j := 1 TO 4 DO
            FOR i := 1 TO 12 DO
              k := i * 5;
              m := i + ((j - 1) * 12);
              dpp$convert_int_to_str_hex (4, status_bytes_p^ [m + 44], msg3 (k, * ));
            FOREND;
            dpp$display_error (msg3);
            msg3 := '                                                               ';
          FOREND;
        IFEND;

      = ioc$dt_ms9836_1, ioc$dt_msxmd_3, ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1, ioc$dt_ms5833_1p,
            ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5837_1, ioc$dt_ms5837_1p,
            ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4, ioc$dt_ms5838_1, ioc$dt_ms5838_1p,
            ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1, ioc$dt_ms47444_1p,
            ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =

        IF (new_head_shift_display_message = FALSE)
{     } AND (pp_response_p^.response_length > ioc$min_response_length) THEN
          msg := 'SR    ,  RP                                                  ';
          dpp$convert_int_to_str_hex (4, disk_status_9836_1_p^.ipi_channel_status_register, msg (3, * ));
          IF (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$ms5831_x)
{       } OR (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_1)
{       } OR (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_2) THEN
            msg (1, 8) := 'PU  (16)';
            i := disk_status_9836_1_p^.unit MOD 40(8);
            dpp$convert_int_to_str_hex (2, i, msg (3, * ));
          ELSE
            dpp$convert_int_to_str_hex (4, disk_status_9836_1_p^.ipi_channel_status_register, msg (3, * ));
          IFEND;
          packet_length := disk_status_9836_1_p^.response_packets [1] *
                100(16) + disk_status_9836_1_p^.response_packets [2];
          FOR i := 0 TO 3 DO
            line_index := 13;
            FOR j := 0 TO 9 DO
              IF packet_length > (i * 20 + j * 2 - 2) THEN
                word1 := disk_status_9836_1_p^.response_packets [i * 20 + j * 2 + 1] *
                      100(16) + disk_status_9836_1_p^.response_packets [i * 20 + j * 2 + 2];
                dpp$convert_int_to_str_hex (4, word1, msg (line_index, * ));
                line_index := line_index + 5;
              IFEND;
            FOREND;
            IF packet_length > (i * 20 - 2) THEN
              dpp$display_error (msg);
              msg := '                                                            ';
            IFEND;
          FOREND;
        IFEND;
      ELSE
      CASEND;
    IFEND;

{Call dsp$report_system_message.
    IF (NOT previous_error) OR (down_status <> ioc$no_change) THEN
      dsp$report_system_message (seq_p, msg_type, msg_level, msg_recorded);
    IFEND;

  PROCEND iop$log_disk_error;
?? TITLE := 'analyze_response_packets', EJECT ??

  PROCEDURE analyze_response_packets
    (    disk_status_9836_1_p: ^iot$detailed_status_9836_1;
         response_length: iot$response_length;
         controller_type: 0 .. 0ff(16);
         disk_type: iot$unit_type;
     VAR response_packet: iot$9836_analyzed_response_pkt);

    VAR
      base_index: integer,
      next_length: integer,
      next_response_code: integer,
      temp: integer,
      response_packet_length: integer;

    response_packet.id23_present := FALSE;
    response_packet.id23_error_code := 0;
    response_packet.id23_facility_status := 0;
    response_packet.id24_present := FALSE;
    response_packet.id24_byte1_bit7 := FALSE;
    response_packet.id24_byte1_bit6 := FALSE;
    response_packet.id24_byte1_bit1 := FALSE;
    response_packet.id24_byte1_not_bit7_or_6 := FALSE;
    response_packet.id26_present := FALSE;
    response_packet.id26_byte2_bit6 := FALSE;
    response_packet.id26_byte2_bit5 := FALSE;
    response_packet.id26_byte2_bit4 := FALSE;
    response_packet.id26_byte10 := 0;
    response_packet.id26_error_code := 0;
    response_packet.id29_present := FALSE;
    response_packet.id29_byte2_bit6 := FALSE;
    response_packet.id29_byte2_bit5 := FALSE;
    response_packet.id29_byte2_bit4 := FALSE;
    response_packet.id29_byte2_bit3 := FALSE;
    response_packet.id29_byte2_bit2 := FALSE;
    response_packet.id29_byte6_bit7 := FALSE;
    response_packet.id29_error_code := 0;

    response_packet_length := disk_status_9836_1_p^.response_packets [1] *
          100(16) + disk_status_9836_1_p^.response_packets [2] + 2;
    IF response_packet_length > response_length - 80 THEN
      RETURN; {----->
    IFEND;
    base_index := 11;

  /search_response_codes/
    WHILE base_index < response_packet_length DO
      next_length := disk_status_9836_1_p^.response_packets [base_index] + 1;
      next_response_code := disk_status_9836_1_p^.response_packets [base_index + 1];
      IF (base_index - 1 + next_length) > response_packet_length THEN
        EXIT /search_response_codes/; {----->
      IFEND;

    /process_response_code/
      BEGIN
        CASE next_response_code OF
        = 23(16) =
          IF response_packet.id23_present THEN
            EXIT /process_response_code/; {----->
          IFEND;
          IF next_length < 3b(16) THEN
            EXIT /process_response_code/; {----->
          IFEND;
          response_packet.id23_present := TRUE;

          CASE disk_type OF
          = ioc$dt_ms9836_1, ioc$dt_msxmd_3, ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1,
                ioc$dt_ms5833_1p, ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5837_1,
                ioc$dt_ms5837_1p, ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4, ioc$dt_ms5838_1,
                ioc$dt_ms5838_1p, ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1,
                ioc$dt_ms47444_1p, ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =

            IF (disk_status_9836_1_p^.response_packets [base_index + 1 + 1b(16)] MOD 80(16)) <> 0 THEN
              response_packet.id23_error_code := disk_status_9836_1_p^.
                    response_packets [base_index + 1 + 1b(16)] * 10000(16);
            ELSE
              response_packet.id23_error_code := disk_status_9836_1_p^.
                    response_packets [base_index + 1 + 38(16)];
            IFEND;
          ELSE
          CASEND;
          IF (disk_status_9836_1_p^.response_packets [base_index + 1 + 11(16)]) <> 0 THEN
            response_packet.id23_facility_status := disk_status_9836_1_p^.
                  response_packets [base_index + 1 + 11(16)];
          IFEND;
        = 24(16) =
          IF response_packet.id24_present THEN
            EXIT /process_response_code/; {----->
          IFEND;
          IF next_length < 2 THEN
            EXIT /process_response_code/; {----->
          IFEND;
          response_packet.id24_present := TRUE;
          IF (next_length > 8) AND (controller_type = 8) AND
                (disk_status_9836_1_p^.response_packets [base_index + 1 + 6] <> 0fe(16)) THEN
            IF disk_status_9836_1_p^.response_packets [base_index + 1 + 7] DIV 80(16) <> 0 THEN
              response_packet.id24_byte1_bit7 := TRUE;
              EXIT /process_response_code/; {----->
            IFEND;
            IF disk_status_9836_1_p^.response_packets [base_index + 1 + 7] DIV 40(16) <> 0 THEN
              response_packet.id24_byte1_bit6 := TRUE;
              EXIT /process_response_code/; {----->
            IFEND;
            response_packet.id24_byte1_not_bit7_or_6 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF disk_status_9836_1_p^.response_packets [base_index + 1 + 1] DIV 80(16) <> 0 THEN
            response_packet.id24_byte1_bit7 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF disk_status_9836_1_p^.response_packets [base_index + 1 + 1] DIV 40(16) <> 0 THEN
            response_packet.id24_byte1_bit6 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          temp := disk_status_9836_1_p^.response_packets [base_index + 1 + 1] MOD 4(16);
          IF temp DIV 2 <> 0 THEN
            response_packet.id24_byte1_bit1 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          response_packet.id24_byte1_not_bit7_or_6 := TRUE;
        = 26(16) =
          IF response_packet.id26_present THEN
            EXIT /process_response_code/; {----->
          IFEND;
          IF next_length < 5 THEN
            EXIT /process_response_code/; {----->
          IFEND;
          response_packet.id26_present := TRUE;
          temp := 0;
          IF controller_type = 8 THEN
            IF next_length > 11(16) THEN
              temp := disk_status_9836_1_p^.response_packets [base_index + 1 + 10(16)];
            IFEND;

            CASE disk_type OF
            = ioc$dt_ms9836_1, ioc$dt_msxmd_3, ioc$dt_ms5832_1, ioc$dt_ms5832_2, ioc$dt_ms5833_1,
                  ioc$dt_ms5833_1p, ioc$dt_ms5833_2, ioc$dt_ms5833_3p, ioc$dt_ms5833_4, ioc$dt_ms5837_1,
                  ioc$dt_ms5837_1p, ioc$dt_ms5837_2, ioc$dt_ms5837_3p, ioc$dt_ms5837_4, ioc$dt_ms5838_1,
                  ioc$dt_ms5838_1p, ioc$dt_ms5838_2, ioc$dt_ms5838_3p, ioc$dt_ms5838_4, ioc$dt_ms47444_1,
                  ioc$dt_ms47444_1p, ioc$dt_ms47444_2, ioc$dt_ms47444_3p, ioc$dt_ms47444_4 =
              IF next_length > 22(16) THEN
                response_packet.id26_error_code := disk_status_9836_1_p^.
                      response_packets [base_index + 1 + 21(16)] * 10000(16);
              IFEND;
            ELSE
            CASEND;
          ELSE
            IF next_length > 0b(16) THEN
              temp := disk_status_9836_1_p^.response_packets [base_index + 1 + 0a(16)];
            IFEND;
            IF next_length > 0c(16) THEN
              response_packet.id26_error_code := disk_status_9836_1_p^.
                    response_packets [base_index + 1 + 0b(16)] * 10000(16);
            IFEND;
          IFEND;
          response_packet.id26_byte10 := temp;
          temp := disk_status_9836_1_p^.response_packets [base_index + 1 + 2] MOD 80(16);
          IF temp DIV 40(16) <> 0 THEN
            response_packet.id26_byte2_bit6 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 20(16) <> 0 THEN
            response_packet.id26_byte2_bit5 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 10(16) <> 0 THEN
            response_packet.id26_byte2_bit4 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
        = 29(16) =
          IF response_packet.id29_present THEN
            EXIT /process_response_code/; {----->
          IFEND;
          IF next_length < 3 THEN
            EXIT /process_response_code/; {----->
          IFEND;
          response_packet.id29_present := TRUE;
          IF controller_type = 8 THEN
            IF next_length > 22(16) THEN
              response_packet.id29_error_code := disk_status_9836_1_p^.
                    response_packets [base_index + 1 + 21(16)] * 10000(16);
            IFEND;
            IF next_length > 6 THEN
              IF disk_status_9836_1_p^.response_packets [base_index + 1 + 6] DIV 40(16) <> 0 THEN
                response_packet.id29_byte6_bit7 := TRUE;
              IFEND;
            IFEND;
          ELSE
            IF next_length > 10(16) THEN
              response_packet.id29_error_code := disk_status_9836_1_p^.
                    response_packets [base_index + 1 + 0f(16)] * 10000(16);
            IFEND;
          IFEND;
          temp := disk_status_9836_1_p^.response_packets [base_index + 1 + 2] MOD 80(16);
          IF temp DIV 40(16) <> 0 THEN
            response_packet.id29_byte2_bit6 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 20(16) <> 0 THEN
            response_packet.id29_byte2_bit5 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 10(16) <> 0 THEN
            response_packet.id29_byte2_bit4 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 8 <> 0 THEN
            response_packet.id29_byte2_bit3 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
          IF temp DIV 4 <> 0 THEN
            response_packet.id29_byte2_bit2 := TRUE;
            EXIT /process_response_code/; {----->
          IFEND;
        ELSE
        CASEND;
      END /process_response_code/;
      IF next_length MOD 2 <> 0 THEN
        next_length := next_length + 1;
      IFEND;
      base_index := base_index + next_length;
    WHILEND /search_response_codes/;

  PROCEND analyze_response_packets;
*if false
?? TITLE := 'simulate_disk_fault', EJECT ??

  PROCEDURE simulate_disk_fault
    (    completed_request_p: ^iot$disk_request;
     VAR normal: iot$io_error);

    VAR
      disk_fault: integer;

    IF normal <> ioc$no_error THEN
      RETURN; {----->
    IFEND;
    FOR disk_fault := LOWERBOUND (osv$simulated_disk_fault) TO UPPERBOUND (osv$simulated_disk_fault) DO
      IF osv$simulated_disk_fault [disk_fault].in_use THEN
        IF osv$simulated_disk_fault [disk_fault].sfid = completed_request_p^.request_info.system_file_id THEN
          IF (osv$simulated_disk_fault [disk_fault].read_fault AND
                ((completed_request_p^.request_info.io_function = ioc$read_page) OR
                (completed_request_p^.request_info.io_function = ioc$swap_in) OR
                (completed_request_p^.request_info.io_function = ioc$read_for_server))) OR
                (osv$simulated_disk_fault [disk_fault].write_fault AND
                ((completed_request_p^.request_info.io_function = ioc$write_page) OR
                (completed_request_p^.request_info.io_function = ioc$write_locked_page) OR
                (completed_request_p^.request_info.io_function = ioc$swap_out) OR
                (completed_request_p^.request_info.io_function = ioc$write_for_server))) THEN
            IF (osv$simulated_disk_fault [disk_fault].first_byte <=
                  completed_request_p^.request_info.byte_address) AND
                  (osv$simulated_disk_fault [disk_fault].last_byte >=
                  completed_request_p^.request_info.byte_address) THEN
              IF osv$simulated_disk_fault [disk_fault].skip_count > 0 THEN
                osv$simulated_disk_fault [disk_fault].skip_count :=
                      osv$simulated_disk_fault [disk_fault].skip_count - 1;
              ELSE
                IF osv$simulated_disk_fault [disk_fault].count > 0 THEN
                  osv$simulated_disk_fault [disk_fault].count :=
                        osv$simulated_disk_fault [disk_fault].count - 1;
                  normal := osv$simulated_disk_fault [disk_fault].error_type;
                  RETURN; {----->
                IFEND;
              IFEND;
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

  PROCEND simulate_disk_fault;
*ifend
?? TITLE := 'IOP$PROCESS_PICO_STATISTICS', EJECT ??

  PROCEDURE iop$process_pico_statistics
    (    pp_response_p: ^iot$pp_response;
         detailed_status_p: ^iot$detailed_status;
         pp: 1 .. ioc$pp_count;
         iou_number: dst$iou_number,
         channel: cmt$physical_channel,
         equipment: 0 .. 0ff(16);
         logical_unit: iot$logical_unit;
     VAR down_status: iot$down_status);

    TYPE
      t$pico_statistics = record
        bus_control_error_count: 0 .. 0ffff(16),
        retry_reject_count: 0 .. 0ffff(16),
        transfer_complete_reject_count: 0 .. 0ffff(16),
        error_flag_encountered_count: 0 .. 0ffff(16), {channel errors
        resync_count: 0 .. 0ffff(16),
        parity_count: 0 .. 0ffff(16),
      recend;

    VAR
      detail_status_p: ^SEQ ( * ),
*if false
      error_count: integer,
*ifend
      pico_statistics_p: ^t$pico_statistics,
      pico_usage_p: ^iot$pico_usage,
      port_index: 0 .. 1;

    iov$pico_statistics_call_count := iov$pico_statistics_call_count + 1;
    port_index := 0;
    IF channel.port = cmc$port_b THEN
      port_index := 1;
    IFEND;

    IF pp_response_p^.unsolicited_response_code = ioc$statistics_report THEN
      down_status := ioc$no_change;

      detail_status_p := detailed_status_p;

      RESET detail_status_p;
      NEXT pico_statistics_p IN detail_status_p;
      IF pico_statistics_p = NIL THEN
        RETURN; {----->
      IFEND;

*if false
{Recovered Errors
      IF pico_statistics_p^.resync_count <> 0 THEN
        iov$disk_unit_usage_p^ [logical_unit]^.recovered_errors :=
              iov$disk_unit_usage_p^ [logical_unit]^.recovered_errors + pico_statistics_p^.resync_count;
        iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].recovered_errors :=
              iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].recovered_errors +
              pico_statistics_p^.resync_count;
      IFEND;

{Intermediate Errors
      error_count := pico_statistics_p^.parity_count + pico_statistics_p^.retry_reject_count +
            pico_statistics_p^.transfer_complete_reject_count + pico_statistics_p^.bus_control_error_count +
            pico_statistics_p^.error_flag_encountered_count;

      IF error_count > 0 THEN
        iov$disk_unit_usage_p^ [logical_unit]^.intermediate_errors :=
              iov$disk_unit_usage_p^ [logical_unit]^.intermediate_errors + error_count;
        iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].intermediate_errors :=
              iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].intermediate_errors +
              error_count;
      IFEND;
*ifend

{Update PICO statistics
      pico_usage_p := iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].pico_usage_p;
      IF pico_usage_p <> NIL THEN
        pico_usage_p^.resync_count := pico_usage_p^.resync_count + pico_statistics_p^.resync_count;
        pico_usage_p^.parity_count := pico_usage_p^.parity_count + pico_statistics_p^.parity_count;
        pico_usage_p^.retry_reject_count := pico_usage_p^.retry_reject_count +
              pico_statistics_p^.retry_reject_count;
        pico_usage_p^.transfer_complete_reject_count := pico_usage_p^.transfer_complete_reject_count +
              pico_statistics_p^.transfer_complete_reject_count;
        pico_usage_p^.bus_control_error_count := pico_usage_p^.bus_control_error_count +
              pico_statistics_p^.bus_control_error_count;
        pico_usage_p^.error_flag_encountered_count := pico_usage_p^.error_flag_encountered_count +
              pico_statistics_p^.error_flag_encountered_count;
      IFEND;
    ELSE

{Unrecovered Errors
      down_status := ioc$unit_down;
      iov$disk_unit_usage_p^ [logical_unit]^.unrecovered_errors :=
            iov$disk_unit_usage_p^ [logical_unit]^.unrecovered_errors + 1;
      iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].unrecovered_errors :=
            iov$disk_pp_usage_p^ [pp]^.path_usage [port_index] [equipment].unrecovered_errors + 1;
    IFEND;

  PROCEND iop$process_pico_statistics;

?? TITLE := 'IOP$ENABLE_PICO_STATISTICS', EJECT ??

  PROCEDURE [XDCL, #GATE] iop$enable_pico_statistics;

    iov$accept_pico_statistics := TRUE;

  PROCEND iop$enable_pico_statistics;

MODEND iom$process_io_completions;
