?? NEWTITLE := 'NOS/VE :  INPUT OUTPUT MANAGER' ??
MODULE iom$process_idle_response;
?? RIGHT := 110 ??

?? NEWTITLE := 'Global Declarations Referenced By This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ioe$st_errors
*copyc iot$disk_request
*copyc iot$pp_interface_table
*copyc iot$pp_response
*copyc iot$pp_table
*copyc iot$request_heap_map
*copyc syt$monitor_status

  VAR
    iov$unrecovered_disk_errors: [XREF] integer,
    iov$request_heap_map: [XREF] iot$request_heap_map,
    iov$empty_requests: [XREF] ^iot$io_request,
    iov$empty_requests_end: [XREF] ^^iot$io_request,
    iov$empty_request_count: [XREF] integer;

?? POP ??
*copyc i#test_set_bit
*copyc mtp$error_stop
*copyc cmv$logical_pp_table_p
?? OLDTITLE ??
?? NEWTITLE := '  [XDCL] IOP$PROCESS_IDLE_RESPONSE', EJECT ??

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

    VAR
      completed_request_p: ^iot$disk_request,
      pp_interface_table_p: ^iot$pp_interface_table,
      count: integer,
      time: integer,
      timeout: integer,
      previously_set: boolean,
      index: 0 .. ioc$request_heap_count;

    status.normal := TRUE;
    IF pp_response_p^.response_code.primary_response = ioc$intermediate_response THEN
      RETURN; {----->
    IFEND;

    completed_request_p := pp_response_p^.request^.device_request_p;

{Check for unrecovered disk errors.

    IF pp_response_p^.response_code.primary_response = ioc$abnormal_response THEN
      IF iov$unrecovered_disk_errors < 0ffffffffffff(16) THEN
        iov$unrecovered_disk_errors := iov$unrecovered_disk_errors + 1;
      IFEND;
    IFEND;

{Set idle_status flag in pp_interface_table.}

    pp_interface_table_p := cmv$logical_pp_table_p^ [pp].pp_info.pp_interface_table_p;

{  Interlock the pp_interface_table.

    time := #FREE_RUNNING_CLOCK (0);
    timeout := time + 2000000;
    count := 0;

    REPEAT
      i#test_set_bit (^pp_interface_table_p^, ioc$pp_interface_table_lock_bit, previously_set);
      count := count + 1;
      IF count >= 100 THEN
        time := #FREE_RUNNING_CLOCK (0);
        count := 0;
      IFEND;
    UNTIL (NOT previously_set) OR (time > timeout);

    IF NOT previously_set THEN
      CASE completed_request_p^.request.command [1].command_code OF
      = ioc$cc_idle =
        pp_interface_table_p^.idle_status := TRUE;
      = ioc$cc_resume =
        pp_interface_table_p^.idle_status := FALSE;
      ELSE
      CASEND;

      pp_interface_table_p^.lock := FALSE;
    ELSE
      status.normal := FALSE;
      status.condition := ioc$pp_interlock_set;
    IFEND;

{Clear request packet allocation.}

    completed_request_p^.link := NIL;
    iov$empty_requests_end^ := pp_response_p^.request;
    iov$empty_requests_end := ^completed_request_p^.link;
    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;


  PROCEND iop$process_idle_response;
MODEND iom$process_idle_response;
