?? RIGHT := 110 ??
*copyc osd$default_pragmats
?? NEWTITLE := ' NOS/VE File Server : monitor_process', EJECT ??
MODULE dfm$monitor_process;
{
{  This module contains code used by the monitor.
{  Also included in this module, are variables that must be available to
{  monitor.
{
?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc cmt$element_name
*copyc dfd$driver_queue_types
*copyc dfp$clear_task_inhibit_access
*copyc dfp$process_server_response_a
*copyc dfp$set_task_segment_state
*copyc dfs$server_wired
*copyc dft$client_job_id
*copyc dft$defined_server_translation
*copyc dft$esm_definition_table
*copyc dft$mainframe_task_status
*copyc dft$poll_header
*copyc dft$queue_interface_directory
*copyc dft$rb_file_server_request
*copyc dfp$process_request_timeout
*copyc dfp$verify_segments_recovered
*copyc jmv$ijl_p
*copyc jmv$null_ijl_ordinal
*copyc jmf$ijle_p
*copyc mmp$restart_server_request
*copyc mtp$error_stop
*copyc oss$mainframe_wired_literal
*copyc ost$cpu_state_table
*copyc ost$heap
*copyc ost$signature_lock
*copyc tmp$check_taskid
*copyc pmt$task_status
?? POP ??
?? TITLE := '     Global Variables', EJECT ??

  VAR
    dfv$job_recovery_enabled: [XDCL, #GATE, dfs$server_wired] boolean := TRUE,
    dfv$rebuild_client_tasks_stat_p: [XDCL, #GATE, dfs$server_wired] ^array [ * ] of
         dft$mainframe_task_status := NIL,
    dfv$family_access_enabled: [XDCL, #GATE, dfs$server_wired] boolean := TRUE;

*copyc dfc$queue_request_constants

{ This variable defines the amount of time a request can "block" the request buffer before task services
{ queueing is suspended and the "blocking" mainframe is timed out.  It is initialized to the constant
{ computed above.
  VAR
    dfv$task_queue_timeout_interval: [XDCL, #GATE, dfs$server_wired] integer := dfc$maximum_delay_time;

  VAR
    dfv$file_server_debug_enabled : [XDCL, #GATE, dfs$server_wired] boolean := FALSE;

  VAR
    dfv$defined_server_translation: [XDCL, #GATE, dfs$server_wired]
          dft$defined_server_translation :=
          [REP dfc$max_number_of_mainframes of [osc$cyber_180_model_unknown, 0]];

  VAR
    { This is an integer to allow use with sym$system_constant_manager.
    { The true value range is 1 .. dfc$max_job_list_p_array_size
    dfv$maximum_client_job_lists: [XDCL, #GATE, dfs$server_wired] integer := 12;

  VAR
    dfv$monitor_io_start_time: [XDCL, dfs$server_wired] integer;

  VAR
    dfv$p_queue_interface_directory: [XDCL, #GATE, dfs$server_wired]
         dft$p_queue_interface_directory := NIL;

  VAR
    { This lock is to insure that two queues are not being initialized
    {simultaneously.
    dfv$queue_initialization_lock: [XDCL, #GATE, dfs$server_wired] ost$signature_lock := [0];

  VAR
    { This lock is to insure that application is not being added and deleted
    {simultaneously.
    dfv$application_info_lock: [XDCL, #GATE, dfs$server_wired] ost$signature_lock := [0];

  VAR
    { This lock is used to prevent the display manager from attempting to
    { display a mainframe file being created.
    dfv$client_mainframe_file_lock: [XDCL, #GATE, dfs$server_wired] ost$signature_lock := [0];


  VAR
    dfv$server_wired_heap: [XDCL, #GATE, dfs$server_wired] ^ost$heap;

  VAR
    dfv$test_retransmission_count: [XDCL, #GATE, dfs$server_wired] 0 .. 0ffff(16) := 0,
    dfv$test_retransmit_retransmit: [XDCL, #GATE, dfs$server_wired] 0 .. 0ff(16) := 0,
    dfv$trace_count : [XDCL, #GATE, dfs$server_wired] integer := 0;


  VAR
   { This variable allows testing of all of the permanent file requests
   { without the memory manager code.
    dfv$use_server_io: [XDCL, #GATE, dfs$server_wired] boolean := TRUE;

  VAR
    dfv$p_esm_definition_table: [XDCL, #GATE, dfs$server_wired]
         ^dft$esm_definition_table_entry := NIL;

  VAR
    dfv$false_queue_entry_flags: [XDCL, #GATE, READ, oss$mainframe_wired_literal] dft$queue_entry_flags :=
          [FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
          FALSE, FALSE];

  VAR
    dfv$active_queue_entry_flags: [XDCL, #GATE, READ, oss$mainframe_wired_literal] dft$queue_entry_flags :=
          [TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
          FALSE, FALSE];
  VAR
    dfv$send_command_flags: [XDCL, #GATE, READ, oss$mainframe_wired_literal] dft$queue_entry_flags :=
          [TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
          FALSE, FALSE];

  VAR
    dfv$send_command_and_data_flags: [XDCL, #GATE, READ, oss$mainframe_wired_literal] dft$queue_entry_flags :=
          [TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
          FALSE, FALSE];

  VAR
    dfv$send_ready_for_data_flags: [XDCL, #GATE, READ, oss$mainframe_wired_literal] dft$queue_entry_flags :=
          [TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
          FALSE, FALSE];

  VAR
    dfv$null_request_buffer_entry: [XDCL, #GATE, READ, oss$mainframe_wired_literal]
          dft$request_buffer_entry :=
          [[FALSE, FALSE, 0], 0, [[0, 0], dfc$null_state], 0, 0];
  VAR
    dfv$server_state_string: [XDCL, READ, #GATE, oss$mainframe_wired_literal] array
          [dfc$active .. dfc$deleted] of string (17) := ['ACTIVE', 'DEACTIVATED', 'INACTIVE',
          'AWAITING_RECOVERY', 'RECOVERING', 'TERMINATED', 'DELETED'];



  VAR
    dfv$display_poll : [XDCL, #GATE, dfs$server_wired] boolean := FALSE,
    dfv$poll_type_string: [XDCL, READ, #GATE, oss$mainframe_wired_literal] array
          [dfc$normal_poll .. dfc$recovery_complete_reply] of string (24) := ['normal_poll',
          'verify_served_family', 'verify_queue', 'deactivate_complete', 'recovery_complete',
          'deactivate_server', 'poll_reply', 'verify_family_reply', 'verify_queue_reply',
          'deactivate_reply', 'req_verify_served_family', 'recovery_complete_reply'];


?? TITLE := '  [XDCL] dfp$mtr_file_server_request ', EJECT ??
   PROCEDURE [XDCL] dfp$mtr_file_server_request (
     VAR rb: dft$rb_file_server_request;
         cst_p: ^ost$cpu_state_table);

   rb.status.normal := TRUE;
   CASE rb.request OF
   = dfc$fsr_restart_server_request =
    mmp$restart_server_request (rb.p_cpu_queue_entry, rb.remote_request);

   = dfc$fsr_term_client_tasks =
     IF rb.cpu_queue_entry_p^.processor_type = dfc$task_services THEN
       tmp$check_taskid (rb.cpu_queue_entry_p^.global_task_id, tmc$opt_return, rb.status);
     IFEND;
     IF rb.status.normal THEN
       dfp$process_server_response_a (^rb.one_word_response, rb.queue_interface_table_p, rb.status);
     IFEND;

   = dfc$fsr_request_timeout =
     dfp$process_request_timeout (rb.p_queue_interface_table, rb.queue_index, rb.queue_entry_index);
   = dfc$fsr_set_task_segment_state =
     dfp$set_task_segment_state (tmc$fnx_system, {ijle_p} NIL, jmv$null_ijl_ordinal,
        rb.inhibit_access_work, rb.terminate_access_work);
   = dfc$fsr_set_job_segment_state =
     dfp$set_task_segment_state (tmc$fnx_job, jmf$ijle_p (rb.ijl_ordinal), rb.ijl_ordinal,
           rb.job_inhibit_access_work, rb.job_terminate_access_work);
   = dfc$fsr_verify_sdtx_recovery =
     dfp$verify_segments_recovered (tmc$fnx_job, jmf$ijle_p (rb.recovered_job_ijl_ordinal),
        rb.recovered_job_ijl_ordinal, rb.recovered_mainframe);
   = dfc$fsr_clear_inhibit_access =
     dfp$clear_task_inhibit_access (tmc$fnx_job, jmf$ijle_p (rb.clear_ijl_ordinal), rb.clear_ijl_ordinal,
           rb.clear_inhibit_work);
   ELSE
     mtp$error_stop ('UNKNOWN SERVER MTR REQUEST');
   CASEND;
  PROCEND dfp$mtr_file_server_request;
MODEND dfm$monitor_process;
