?? RIGHT := 110 ??
?? NEWTITLE := ' NOS/VE File Server: Client ', EJECT ??
MODULE dfm$set_server_eoi;

{ PURPOSE:
{   This client module serves to act as an interface between Memory Manager
{   and the server mainframe when setting EOI for a file on that mainframe.

?? NEWTITLE := '   Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc dfc$test_jr_constants
*copyc dfk$keypoints
*copyc dmt$keypoints
*copyc osk$keypoints
*copyc dfe$error_condition_codes
*copyc dmt$df_set_eoi
*copyc dft$server_descriptor
*copyc ost$status
?? POP ??
*copyc dfp$get_served_file_desc_p
*copyc dfp$send_remote_procedure_call
*copyc dfp$fetch_served_family_entry
*copyc gfp$get_fde_p
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
*copyc syp$hang_if_system_jrt_set
*copyc syp$pop_inhibit_job_recovery
*copyc syp$push_inhibit_job_recovery
?? TITLE := '    [XDCL, #GATE] dfp$set_server_eoi', EJECT ??
    { The setting of eoi on the server is just a curtesy the next page fault
    {    will move the eoi over.
    { The eoi has aready been set in the system file table on the client.

  PROCEDURE [XDCL, #GATE] dfp$set_server_eoi
    (    sfid: gft$system_file_identifier;
         segment_length: ost$segment_length;
     VAR status: ost$status);

?? NEWTITLE := 'dfp$remote_procedure_call_ch', EJECT ??

{ PURPOSE:
{   This procedure is a condition handler established to call a routine to clear the assignment of a task
{   services queue_entry if a task aborts with a queue_entry assigned to it.  The queue_entry must be clear
{   before the task can safely exit.

    PROCEDURE dfp$remote_procedure_call_ch
      (    condition: pmt$condition;
           cond_desc: ^pmt$condition_information;
           save: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      dfp$ch_cleanup;
      osp$set_status_from_condition (dfc$file_server_id, condition, save, status, handler_status);
      EXIT dfp$set_server_eoi;

    PROCEND dfp$remote_procedure_call_ch;
*block
*copyc dfp$begin_ch_remote_proc_call
*copyc dfp$end_ch_remote_proc_call
*blockend
?? OLDTITLE, EJECT ??
    VAR
      able_to_locate_fde: boolean,
      fde_p: gft$file_desc_entry_p,
      local_status: ost$status,
      p_receive_data: dft$p_receive_data,
      p_receive_from_server_params: dft$p_receive_parameters,
      p_send_data: dft$p_send_data,
      p_send_parameters: ^dmt$df_set_eoi_inp,
      p_send_to_server_params: dft$p_send_parameters,
      p_served_family_entry: ^dft$served_family_table_entry,
      p_server_descriptor: dft$server_descriptor_p,
      queue_entry_location: dft$rpc_queue_entry_location,
      remote_sfid: gft$system_file_identifier,
      served_family_table_index: dft$served_family_table_index,
      server_location: dft$server_location;

    status.normal := TRUE;
    syp$push_inhibit_job_recovery;

    gfp$get_fde_p (sfid, fde_p);
    IF fde_p = NIL THEN
      osp$set_status_abnormal (dfc$file_server_id, dfe$server_has_terminated, ' Set eoi ', status);
    IFEND;

    IF status.normal THEN
      dfp$get_served_file_desc_p (fde_p, p_server_descriptor);
      served_family_table_index := p_server_descriptor^.header.served_family_table_index;
      remote_sfid := p_server_descriptor^.header.remote_sfid;

      dfp$fetch_served_family_entry (served_family_table_index, p_served_family_entry, status);
      IF NOT status.normal THEN
        osp$set_status_abnormal (dfc$file_server_id, dfe$server_has_terminated, ' Set eoi ', status);
      IFEND;

      IF status.normal THEN
        IF (p_server_descriptor^.header.file_state = dfc$terminated) OR
              (p_served_family_entry^.server_state = dfc$terminated) THEN
          osp$set_status_abnormal (dfc$file_server_id, dfe$server_has_terminated, ' Set eoi ', status);
        IFEND;

        IF status.normal THEN
          IF p_server_descriptor^.header.file_state = dfc$active THEN
            server_location.server_location_selector := dfc$served_family_table_index;
            server_location.served_family_table_index := served_family_table_index;

            dfp$begin_ch_remote_proc_call (server_location, {send_if_deactivated=} FALSE,
                  queue_entry_location, p_send_to_server_params, p_send_data, status);
            IF status.normal THEN
              syp$hang_if_system_jrt_set (dfc$tjr_server_set_eoi);
              NEXT p_send_parameters IN p_send_to_server_params;
              p_send_parameters^.sfid := remote_sfid;
              p_send_parameters^.segment_length := segment_length;

              dfp$send_remote_procedure_call (queue_entry_location, dfc$df_server_set_eoi,
                     #SIZE (p_send_parameters^), { Data to send =} 0, p_receive_from_server_params,
                     p_receive_data, status);
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

    dfp$end_ch_remote_proc_call (queue_entry_location, local_status);
    syp$pop_inhibit_job_recovery;
    #KEYPOINT (osk$exit, 0, dmk$df_client_set_eoi);

  PROCEND dfp$set_server_eoi;

MODEND dfm$set_server_eoi;

