?? RIGHT := 110 ??
?? TITLE := 'NOS/VE File Server : Server :  Remote Procedure Call' ??
MODULE dfm$server_remote_procedur_call;
{
{  This module contains the server side of the remote procedure call
{  processing. The client initiates the request, and the server determines
{  what to do based on information passed to it, and the state recorded in the
{  cpu queue.
{  A few notes about the server side processing:
{  - The server always prompts for data.
{  - The server frees all receive data only after it has called the
{    user procedure.  The server frees send pages as it goes.  If a request
{    is not restartable the server leaves the last four pages of send data,
{    wired down until the next request.  These pages are used on retransmission.
{  - The server waits following a prompt for data.
{  - If the server detects a need to restart the request the status
{    dfe$restart_server_request or dfe$bad_client_job_id is returned to the client.
{  - If the incoming request is a permanent file call the clone tasks
{    environment is made to appear as if it is running on behalf of the
{    users job on the client.
{ -  In the effect of certain errors, the request will stop processing to
{    allow the timeout processing to timeout the request, and retransmit.
{
{  When adding procedures to the procedure list, it must be determined if the request
{  on the server may be re-issued in the event of a need for retransmission,
{  and if the request should run on behalf of the user making the request or
{  run on behalf of the system user.  The XREF to the remote procedure should
{  be added here, to the appropriate area.
{
?? NEWTITLE := '  Global Declarations Referenced by this module' ??
?? PUSH (LISTEXT := ON) ??
*copyc dfc$client_pause_break
*copyc dfc$client_terminate_break
*copyc dfc$remote_core_call
*copyc dfc$test_jr_constants
*copyc dfd$driver_queue_types
*copyc dfd$request_package
*copyc dfe$error_condition_codes
*copyc dfk$keypoints
*copyc dft$action_for_server
*copyc dft$cpu_queue
*copyc dft$procedure_address_ordinal
*copyc dft$procedure_address_range
*copyc dft$procedure_version
*copyc dft$rpc_buffer_header
*copyc dft$rpc_parameters
*copyc dft$rpc_procedure_address_list
*copyc dft$rpc_queue_entry_location
*copyc dft$server_location
*copyc oss$job_paged_literal
*copyc ost$status
?? POP ??
?? EJECT ??
*copyc dfi$console_display
*copyc dfi$display
*copyc dfp$await_server_subsystem
*copyc dfp$clear_server_driver_flags
*copyc dfp$delete_server_rpc_segment
*copyc dfp$initialize_rma_list
*copyc dfp$page_count
*copyc dfp$pop_job_unrecoverable
*copyc dfp$push_job_unrecoverable
*copyc dfp$queue_server_task_request
*copyc dfp$set_client_job_environment
*copyc dfp$touch_pages
*copyc dfp$validate_client_job_id
*copyc dfp$word_boundary
*copyc dfv$file_server_debug_enabled
*copyc dfv$p_client_mainframe_file
*copyc dfv$p_proc_addresses
*copyc dfv$send_command_and_data_flags
*copyc dfv$send_command_flags
*copyc dfv$send_ready_for_data_flags
*copyc dfv$test_retransmission_count
*copyc dfv$test_retransmit_retransmit
*copyc i#current_sequence_position
*copyc mmp$free_pages
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$establish_condition_handler
*copyc osp$recoverable_system_error
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
*copyc osp$system_error
*copyc pfp$log_error
*copyc pfp$r2_df_server_get_obj_info
*copyc pfp$reset_task_environment
*copyc pmp$continue_to_cause
*copyc syp$hang_if_job_jrt_set
*copyc syp$invoke_system_debugger
?? TITLE := '  Global Declarations Declared by this module', EJECT ??
{
{   Currently the checksums are arbitrarily assigned.
{
?? FMT (FORMAT := OFF) ??
  VAR
    {debug_display, procedure_address, procedure_class, request_restartable
    {  job_recovery_location, recover_job_on_server_call, version, checksum
    dfv$procedure_address_list: [XDCL, READ, oss$job_paged_literal]
          dft$rpc_procedure_address_list := [
          {} ['', NIL, * , * , * , * , * , *, *, *, *, *],
          {} ['receive_test_rpc-restart', ^dfp$receive_test_rpc, dfc$task_services_call,
               dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 145788882, *, *, *,
               *],
          {} ['receive_test_rpc-unrestart', ^dfp$receive_test_rpc, dfc$task_services_call,
               dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 145788882, *, *,
                   *, *],
          {} ['receive_remote_command_line r', ^dfp$receive_remote_command_line,
               dfc$permanent_file_call, dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait,
               TRUE,  'AAAA', 143458882, *, *, *, *],
          {} ['receive_remote_command_line u', ^dfp$receive_remote_command_line,
               dfc$task_services_call, dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,
              'AAAA', 777777772, *, *, *, *],
          {} ['receive_remote_message', ^dfp$receive_remote_message, dfc$task_services_call,
              dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 155555552, *, *, *, *],

         {} ['send_mmio_data', ^dfp$send_mmio_data, dfc$task_services_call, dfc$request_restartable,
              dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 1948683618228002372, *, *, *, *],
         {} [' perf test 1', NIL, * , * , * , * , * , *, *, *, *, *],
         {} [' perf test 2', NIL, * , * , * , * , * , *, *, *, *, *],

         {} ['dfp$send_server_rpc_segment', ^dfp$send_server_rpc_segment, dfc$task_services_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 8073468973, *, *, *, *],

        {} ['dfp$delete_client_job', ^dfp$delete_client_job, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 234567891, *, *, *,
             *],
        {} ['dfp$establish_client_job', ^dfp$establish_client_job, dfc$task_services_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 8675309, *, *, *, *],

        {} [' Initiate job recovery', ^dfp$start_client_job_recovery, dfc$task_services_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 234567891, *, *, *,
             *],
        {} [' complete_job_recovery', ^dfp$end_client_job_recovery, dfc$task_services_call,
              dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 234567891, *, *, *,
              *],
        {} [' relink file to client', ^pfp$relink_file_to_client, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE,  'AAAA', 234567891, *, *, *,
             *],
        {} [' verify_jobs', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' flush image file', ^dfp$server_flush_image_file, dfc$task_services_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE,  'AAAA', 278967891, *, *, *,
             *],
        {} [' get_client_job_list', ^dfp$get_client_job_list, dfc$task_services_call,
              dfc$request_restartable, dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 234567891, *, *, *, *],
        {} [' remove_unknown_jobs', ^dfp$remove_unknown_jobs, dfc$task_services_call,
              dfc$request_restartable, dfc$job_rec_in_unavailable_wait, FALSE,  'AAAA', 234567891, *, *, *,
              *],
        {} [' Reserved job recovery 3', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 4', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 5', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 6', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 7', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 8', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Reserved job recovery 9', NIL, * , * , * , * , * , *, *, *, *, *],


        {} ['allocate_space', ^dmp$r1_df_server_allocate_space, dfc$system_core_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait,
             TRUE,  dfc$system_core_version, dfc$system_core_checksum, *, *, *, *],
        {} ['reallocate_space', ^dfp$reallocate_filespace_server, dfc$system_core_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait,
            TRUE,  dfc$system_core_version, dfc$system_core_checksum, *, *, *, *],

        {} ['get_server_fmd', ^dmp$server_get_fmd, dfc$task_services_call, dfc$request_not_restartable,
             dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 777777772, *, *, *, *],
        {} ['set_eoi', ^dmp$df_server_set_eoi, dfc$task_services_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123456023, *, *, *, *],

        {} ['append_rem_media_vsn', ^pfp$r2_df_server_app_rem_me_vsn, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450010, *, *, *,
             *],
        {} ['attach', ^pfp$r2_df_server_attach, dfc$permanent_file_call, dfc$request_not_restartable,
             dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 123450011, *, *, *, *],
        {} ['attach_or_create', ^pfp$r2_df_server_attach_or_cref, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 123450012, *, *, *,
             *],
        {} ['change', ^pfp$r2_df_server_change, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450013, *, *, *,
             *],
        {} ['change_cycle_damage', ^pfp$r2_df_server_change_cy_dam, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450014, *, *, *, *],
        {} ['change_cycle_date_time', ^pfp$r2_df_server_change_cy_dt, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450015, *, *, *, *],
        {} ['change_residence_to_releasable', ^pfp$r2_df_server_change_res_rel, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450016, *, *, *, *],
        {} ['clear_cycle_attachmments', ^pfp$r2_df_server_clear_cy_att, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450017, *, *, *, *],
        {} ['create_catalog', ^pfp$r2_df_server_define_catalog, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450018, *, *, *,
             *],
        {} ['define', ^pfp$r2_df_server_define, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 123450019, *, *, *,
             *],
        {} ['define_data', ^pfp$r2_df_server_define_data, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 123450020, *, *, *,
             *],
        {} ['delete_catalog', ^pfp$r2_df_server_purge_catalog, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450021, *, *, *,
             *],
        {} ['delete_permit', ^pfp$r2_df_server_delete_permit, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450022, *, *, *,
             *],
        {} ['get_family_set ', ^pfp$r2_df_server_get_family_set, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450023, *, *, *, *],
        {} ['get family item info ', ^pfp$r2_df_server_get_famit_info, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450024, *, *, *, *],
        {} ['get_info', ^pfp$r2_df_server_get_info, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450025, *, *, *, *],
        {} ['get_mcat_info', ^pfp$r2_df_server_get_mcat_info, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450026, *, *, *, *],
        {} ['get object info ', ^pfp$r2_df_server_get_obj_info, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450027, *, *, *, *],
        {} ['permit', ^pfp$r2_df_server_permit, dfc$permanent_file_call, dfc$request_restartable,
            dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450028, *, *, *, *],
        {} ['purge', ^pfp$r2_df_server_purge, dfc$permanent_file_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450029, *, *, *,
            *],
        {} ['put_cycle_info', ^pfp$r2_df_server_put_cycle_info, dfc$permanent_file_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450030, *, *, *,
            *],
        {} ['put_info', ^pfp$r2_df_server_put_item_info, dfc$permanent_file_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450031,  *, *, *,
            *],
        {} ['replace_rem_media_fmd', ^pfp$r2_df_server_rep_rem_me_fmd, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450032, *, *, *, *],
        {} ['resolve', ^pfp$r2_df_server_resolve, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450033, *, *, *, *],
        {} ['return', ^pfp$r2_df_server_return, dfc$permanent_file_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, FALSE, 'AAAA', 123450034, *, *, *,
            *],
        {} ['save_label', ^pfp$r2_df_server_save_label, dfc$permanent_file_call,
            dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450035, *, *, *,
            *],
        {} ['validate_password', ^pfp$r2_df_server_validate_pw, dfc$permanent_file_call,
            dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 123450036, *, *, *, *],
        {} ['get_vol_condition_list', ^pfp$r2_df_server_get_vol_cl, dfc$permanent_file_call,
             dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 010203043, *, *, *, *],
        {} ['change_file', ^pfp$r2_df_server_change_file, dfc$permanent_file_call,
             dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE, 'AAAA', 010203044, *, *, *,
             *],
        {} ['change login pw ', NIL, * , * , * , *, * , *,  *, *, *, *],
        {} ['prevalidate_job', ^avp$server_prevalidate_job, dfc$task_services_call,
          dfc$request_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 123456789, *, *, *, *],
        {} ['get_val_info', ^avp$server_get_val_info, dfc$task_services_call,
          dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 123456789, *, *, *, *],

    { Site reserved
        {} [' Site 1', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Site 2', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Site 3', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Site 4', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' Site 5', NIL, * , * , * , * , * , *, *, *, *, *],

    {Vxve reserved
        {} ['vxve 1  ', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['vxve 2 ', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['vxve 3', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['vxve 4', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['vxve 5', NIL, * , * , * , * , * , *, *, *, *, *],

        { Reserved for NOS/VE
        {} ['ready_universal_task ', ^osp$server_ready_task, dfc$task_services_call,
          dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300008, *, *, *, *],
        {} ['change_job_validation_info ', ^dfp$change_client_job_validaton,
            dfc$permanent_file_call, dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,
            'AAAA', 2078959908, *, *, *, *],
        {} ['send_client_rpc_segment ', ^dfp$receive_part_client_segment, dfc$task_services_call,
          dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300008, *, *, *, *],
        {} ['send_remote_app_info', ^dfp$send_remote_app_info, dfc$task_services_call,
          dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300008, *, *, *, *],
        {} ['OS 4 ', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['OS 5 ', NIL, * , * , * , * , * , *, *, *, *, *],

    { Reserved for nos/ve load leveling and queue file management
       {} [' Job_leveler_server  ', ^jmp$job_leveler_server, dfc$task_services_call,
          dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' Submit_job  ', ^jmp$server_submit_job, dfc$task_services_call,
        dfc$request_not_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' JM_General_Purpose ', ^jmp$server_general_purpose_rpc, dfc$task_services_call,
        dfc$request_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' Terminate_job  ', ^jmp$server_terminate_job, dfc$task_services_call,
        dfc$request_not_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' Job_begin  ', ^jmp$server_job_begin, dfc$task_services_call,
        dfc$request_not_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' Send_job_message  ', ^jmp$server_send_job_message, dfc$task_services_call,
        dfc$request_restartable, dfc$job_rec_started_by_caller, TRUE,  'AAAA', 42, *, *, *, *],
        {} [' LEVELER 7', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' LEVELER 8', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' LEVELER 9', NIL, * , * , * , * , * , *, *, *, *, *],
        {} [' LEVELER 10', NIL, * , * , * , * , * , *, *, *, *, *],

    { Reserved for archiving}
        {} ['delete_all_archive_entries', ^pfp$r2_df_server_del_all_arc_en, dfc$permanent_file_call,
        dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300001, *, *, *, *],
        {} ['delete_archive_entry', ^pfp$r2_df_server_del_arch_entry, dfc$permanent_file_call,
        dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300002, *, *, *, *],
        {} ['mark_release_candidate ', ^pfp$r2_df_server_mark_rel_cand, dfc$permanent_file_call,
        dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300003, *, *, *, *],
        {} ['put_archive_entry ', ^pfp$r2_df_server_put_arch_entry, dfc$permanent_file_call,
        dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300004, *, *, *, *],
        {} ['put_archive_info ', ^pfp$r2_df_server_put_arch_info, dfc$permanent_file_call,
        dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300005, *, *, *, *],
        {} ['replace_archive_entry ', ^pfp$r2_df_server_release_data, dfc$permanent_file_call,
        dfc$request_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300006, *, *, *, *],
        {} ['release_data ', ^pfp$r2_df_server_rep_arch_entry, dfc$permanent_file_call,
        dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait, TRUE,  'AAAA', 2074300007, *, *, *, *],
        {} ['save_released_file_label ', ^pfp$r2_df_server_save_rel_label,
        dfc$permanent_file_call, dfc$request_not_restartable, dfc$job_rec_in_unavailable_wait,
        TRUE,  'AAAA', 2074300009, *, *, *, *],

        {} ['Last job proceedure', NIL, * , * , * , * , * , *, *, *, *, *],

        {} ['Poll', NIL, * , * , * , * , * , *, *, *, *, *],

        {} ['monitor procedure', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['read pages', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['write pages', NIL, * , * , * , * , * , *, *, *, *, *],
        {} ['allocate', NIL, * , * , * , * , * , *, *, *, *, *],

        {} ['last procedure', NIL, * , * , * , * , * , *, *, *, * , *]];
?? FMT (FORMAT := ON) ??
?? PUSH (LISTEXT := ON) ??
  PROCEDURE [XREF] avp$server_prevalidate_job
    (VAR p_params_received_from_client: dft$p_receive_parameters;
     VAR p_data_received_from_client: dft$p_receive_data;
     VAR p_params_to_send_to_client: dft$p_send_parameters;
     VAR p_data_to_send_to_client: dft$p_send_data;
     VAR params_size_to_send_to_client: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] avp$server_get_val_info
    (VAR p_params_received_from_client: dft$p_receive_parameters;
     VAR p_data_received_from_client: dft$p_receive_data;
     VAR p_params_to_send_to_client: dft$p_send_parameters;
     VAR p_data_to_send_to_client: dft$p_send_data;
     VAR params_size_to_send_to_client: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$delete_client_job
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$establish_client_job
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$change_client_job_validaton
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$send_server_rpc_segment
    (VAR p_params_received_from_client: dft$p_receive_parameters;
     VAR p_data_received_from_client: dft$p_receive_data;
     VAR p_params_to_send_to_client: dft$p_send_parameters;
     VAR p_data_to_send_to_client: dft$p_send_data;
     VAR params_size_to_send_to_client: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$receive_part_client_segment
    (VAR p_params_received_from_client: dft$p_receive_parameters;
     VAR p_data_received_from_client: dft$p_receive_data;
     VAR p_params_to_send_to_client: dft$p_send_parameters;
     VAR p_data_to_send_to_client: dft$p_send_data;
     VAR params_size_to_send_to_client: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$receive_test_rpc
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$receive_remote_command_line
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$receive_remote_message
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$send_mmio_data
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$start_client_job_recovery
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$end_client_job_recovery
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$get_client_job_list
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$remove_unknown_jobs
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$server_flush_image_file
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dmp$df_server_set_eoi
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dmp$r1_df_server_allocate_space
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dfp$reallocate_filespace_server
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_app_rem_me_vsn
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_attach
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_attach_or_cref
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_change
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_change_cy_dam
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_change_cy_dt
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_change_file
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_change_res_rel
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_clear_cy_att
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_define
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_define_catalog
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_define_data
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_delete_permit
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_get_family_set
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_get_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_get_mcat_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_get_famit_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_get_vol_cl
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_permit
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_purge
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_purge_catalog
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_put_cycle_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_put_item_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_rep_rem_me_fmd
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_resolve
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_return
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_save_label
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$relink_file_to_client
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_validate_pw
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] dmp$server_get_fmd
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

{
{ RESERVED FOR SITE XREFS


{  END SITE XREFS
{

{
{ RESERVED FOR VXVE XREFS


{ END XXVE XREFS
{

{
{ RESERVED FOR VE XREFS


  PROCEDURE [XREF] osp$server_ready_task
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);


  PROCEDURE [XREF] dfp$send_remote_app_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

{END VE XREFS
{

{
{ RESERVED FOR VE LOAD LEVELING XREFS

*copyc jmp$job_leveler_server
*copyc jmp$server_general_purpose_rpc
*copyc jmp$server_job_begin
*copyc jmp$server_send_job_message
*copyc jmp$server_submit_job
*copyc jmp$server_terminate_job

{ END LOAD LEVELING XREFS
{

{ RESERVED FOR VE ARCHIVING


  PROCEDURE [XREF] pfp$r2_df_server_del_all_arc_en
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_del_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_mark_rel_cand
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_put_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_put_arch_info
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_release_data
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_rep_arch_entry
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

  PROCEDURE [XREF] pfp$r2_df_server_save_rel_label
    (VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_send_to_client_data {^Output} : dft$p_send_data;
     VAR send_parameters_size: dft$send_parameter_size;
     VAR send_data_size: dft$send_data_size;
     VAR status: ost$status);

{ END ARCHIVING XREFS
{
?? POP ??
?? TITLE := ' [XDCL] dfp$receive_remote_call ', EJECT ??
{
{   This procedure receives the remote request from the client.  This procedure
{ assumes that the caller (dfp$process_task_request) has determined the
{ action for the server, and has done the movement of retransmission count
{ from the receive buffer to the cpu queue.
{   This procedure acts differently whether this is a new transaction or a
{ retransmittal.  If this a new transaction this procedure determines whether
{ this is a new remote procedure call request, or an ongoing remote procedure
{ call request.  If the request is a retransmittal the procedure determines
{ the state of the request - whether the buffers or data may just be sent
{ back to the client or whether the client must restart the request.

  PROCEDURE [XDCL] dfp$receive_remote_call
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         action_for_server: dft$action_for_server;
     VAR status: ost$status);

    CASE action_for_server OF
    = dfc$new_request =
      { Free any pages saved from a previous request }
      IF p_cpu_queue_entry^.p_last_wired_data <> NIL THEN
        mmp$free_pages (p_cpu_queue_entry^.p_last_wired_data, p_cpu_queue_entry^.last_wired_length, osc$wait,
              status);
        p_cpu_queue_entry^.p_last_wired_data := NIL;
        p_cpu_queue_entry^.last_wired_length := 0;
      IFEND;

      receive_new_request (p_queue_interface_table, queue_index, queue_entry_index, p_driver_queue_entry,
            p_cpu_queue_entry, status);

    = dfc$retransmitted_request =
      IF dfv$file_server_debug_enabled THEN
        display_integer_to_console (' DF - SERVER- RECEIVE RETRANSMITTAL - QUEUE INDEX ', queue_index);
        display_integer_to_console (' DF - SERVER- QUEUE ENTRY INDEX', queue_entry_index);
        display_integer (' DF - SERVER- RECEIVE RETRANSMITTAL - QUEUE INDEX ', queue_index);
        display_integer (' DF - SERVER- QUEUE ENTRY INDEX', queue_entry_index);
      IFEND;
      receive_retransmittal (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry, status);

    = dfc$complete_request_on_error, dfc$transaction_out_of_sequence =
      IF dfv$file_server_debug_enabled THEN
        display_to_console (' DF - SERVER  dfc$complete_request_on_error');
        display (' DF - SERVER  dfc$complete_request_on_error');
        {  Report error
        {       DO nothing - Let request time out
        {       Note: Complete request on error should not come through here
      IFEND;
    ELSE
      IF dfv$file_server_debug_enabled THEN
        display_to_console (' DF - SERVER unexpected action for server ');
        display (' DF - SERVER unexpected action for server ');
        osp$system_error (' DF - SERVER unexpected action ', NIL);
      IFEND;
    CASEND;
  PROCEND dfp$receive_remote_call;
?? TITLE := '  call_procedure ', EJECT ??
  PROCEDURE call_procedure
    (    current_rpc_entry: dft$rpc_procedure_address_entry;
     VAR p_param_received_from_client {Input} : dft$p_receive_parameters;
     VAR p_data_from_client {Input} : dft$p_receive_data;
     VAR p_send_to_client_params {^Output} : dft$p_send_parameters;
     VAR p_data_to_client {^Output} : dft$p_send_data;
     VAR send_parameters_length: dft$send_parameter_size;
     VAR data_size_to_send_to_client: dft$send_data_size;
     VAR status: ost$status);

    PROCEDURE condition_handler
      (    condition: pmt$condition;
           p_condition_info: ^pmt$condition_information;
           p_sfsa: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        local_status: ost$status;

      IF (condition.selector = pmc$system_conditions) OR
            (condition.selector = mmc$segment_access_condition) THEN
        osp$set_status_from_condition (dfc$file_server_id, condition, p_sfsa, status,
              local_status);
        IF local_status.normal THEN
          pfp$log_error (status, - $pmt$ascii_logset [], pmc$msg_origin_system, TRUE);
        ELSE
          pfp$log_error (local_status, - $pmt$ascii_logset [], pmc$msg_origin_system, TRUE);
          status := local_status;
        IFEND;
        IF dfv$file_server_debug_enabled THEN
          syp$invoke_system_debugger ('', 0, local_status);
          display_trace_back;
        IFEND;
        EXIT call_procedure;
      ELSEIF (condition.selector = pmc$user_defined_condition) AND (
            condition.user_condition_name = dfc$client_terminate_break) THEN
        osp$set_status_abnormal (dfc$file_server_id, dfe$client_terminate_break,
              current_rpc_entry.debug_display, status);
        EXIT call_procedure;
      ELSEIF (condition.selector = pmc$user_defined_condition) AND (
            condition.user_condition_name = dfc$client_pause_break) THEN
        osp$set_status_abnormal (dfc$file_server_id, dfe$client_pause_break,
              current_rpc_entry.debug_display, status);
        EXIT call_procedure;
      ELSE
        {
        { Ignore the condition.
        {
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
      IFEND;
    PROCEND condition_handler;


    osp$establish_condition_handler (^condition_handler, { block_exit = } FALSE);

    status.normal := TRUE;

    IF current_rpc_entry.procedure_address<> NIL THEN

      send_parameters_length := 0;
      data_size_to_send_to_client := 0;
      current_rpc_entry.procedure_address^
            (p_param_received_from_client, p_data_from_client, p_send_to_client_params, p_data_to_client,
            send_parameters_length, data_size_to_send_to_client, status);

      IF status.normal THEN
        IF (send_parameters_length > dfc$maximum_user_buffer_area) OR
              (send_parameters_length < 0) THEN
          osp$set_status_abnormal (dfc$file_server_id, dfe$out_of_range_value,
                'SEND_PARAMETERS_LENGTH', status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'received from REMOTE_PROCEDURE', status);
          osp$append_status_integer (osc$status_parameter_delimiter, send_parameters_length,
                10, FALSE, status);
          osp$append_status_integer (osc$status_parameter_delimiter, 0, 10, FALSE, status);
          osp$append_status_integer (osc$status_parameter_delimiter, dfc$maximum_user_buffer_area,
                10, FALSE, status);
        IFEND;
        IF (data_size_to_send_to_client > dfc$maximum_user_data_area) OR
              (data_size_to_send_to_client < 0) THEN
          osp$set_status_abnormal (dfc$file_server_id, dfe$out_of_range_value,
                'DATA_SIZE_TO_SEND_TO_CLIENT', status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'received from REMOTE_PROCEDURE', status);
          osp$append_status_integer (osc$status_parameter_delimiter,
                data_size_to_send_to_client, 10, FALSE, status);
          osp$append_status_integer (osc$status_parameter_delimiter, 0, 10, FALSE, status);
          osp$append_status_integer (osc$status_parameter_delimiter, dfc$maximum_user_data_area,
                10, FALSE, status);
        IFEND;
      IFEND;

    ELSE
      osp$set_status_abnormal (dfc$file_server_id, dfe$remote_proc_load_failure,
            current_rpc_entry.debug_display, status);
    IFEND;
    IF dfv$file_server_debug_enabled AND (NOT status.normal) THEN
      display_integer (' Abnormal status condition ', status.condition);
    IFEND;
  PROCEND call_procedure;
?? TITLE := '  call_remote_procedure ', EJECT ??
{
{   This procedure makes the actual call to the users procedure.
{ Prior to making the call the receive parameters and receive data have
{ all been received, and this routine establishing the pointers to that
{ area for the user.  After calling the users procedure this routine
{ builds the appropriate status, and determines whether there is data
{ to be sent back to the server.  If data was sent over with the request
{ no data is returned to the server on this initial response.  If data
{ is returned to the server, the procedure waits until the data is moved.
{

  PROCEDURE call_remote_procedure
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         current_rpc_entry: dft$rpc_procedure_address_entry;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header);

    VAR
      actual_length: integer,
      p_send_buffer_header: ^dft$buffer_header,
      p_send_mtr_status: ^syt$monitor_status,
      p_send_os_status: ^ost$status,
      p_send_rpc_buffer_header: ^dft$rpc_response_buffer_header,
      p_user_receive_data: dft$p_receive_data,
      p_user_receive_parameters: dft$p_receive_parameters,
      p_user_send_data: dft$p_send_data,
      p_user_send_parameters: dft$p_send_parameters,
      request_status: ost$status,
      send_data_length: dft$send_data_size,
      send_parameters_length: dft$send_parameter_size,
      status: ost$status,
      status_size: integer;

    { Establish pointers to user send and  receive buffer, and data.
    IF p_receive_rpc_buffer_header^.call_progress.user_buffer_length_sent > 0 THEN
      NEXT p_user_receive_parameters: [[REP p_receive_rpc_buffer_header^.call_progress.
            user_buffer_length_sent OF cell]] IN p_cpu_queue_entry^.p_receive_buffer;
      RESET p_user_receive_parameters;
    ELSE
      p_user_receive_parameters := NIL;
    IFEND;
    IF p_receive_rpc_buffer_header^.call_progress.user_data_length_sent > 0 THEN
      RESET p_cpu_queue_entry^.p_receive_data;
      NEXT p_user_receive_data: [[REP p_receive_rpc_buffer_header^.call_progress.user_data_length_sent OF
            cell]] IN p_cpu_queue_entry^.p_receive_data;
      RESET p_user_receive_data;
    ELSE
      p_user_receive_data := NIL;
    IFEND;
    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_mtr_status IN p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_rpc_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    NEXT p_user_send_parameters IN p_cpu_queue_entry^.p_send_buffer;
    RESET p_user_send_parameters;
    RESET p_cpu_queue_entry^.p_send_data;
    { Since the input parameters are VAR (for convenience of users doing NEXTS
    { a copy is made of the pointer.
    p_user_send_data := p_cpu_queue_entry^.p_send_data;

    { Call the procedure.
    p_cpu_queue_entry^.remote_procedure_called := TRUE;
    IF (current_rpc_entry.class
           = dfc$permanent_file_call) AND
           NOT current_rpc_entry.
            recover_job_on_server_call THEN
      dfp$push_job_unrecoverable (p_receive_rpc_buffer_header^.client_job_id);
    IFEND;

    call_procedure (current_rpc_entry, p_user_receive_parameters,
           p_user_receive_data, p_user_send_parameters,
          p_user_send_data, send_parameters_length, send_data_length, request_status);

    IF (current_rpc_entry.class
           = dfc$permanent_file_call) AND
           NOT current_rpc_entry.
          recover_job_on_server_call THEN
      dfp$pop_job_unrecoverable (p_receive_rpc_buffer_header^.client_job_id);
    IFEND;

    syp$hang_if_job_jrt_set (dfc$tjr_server_rpc_after_call);
    { Set the status in the send buffer.
    IF request_status.normal THEN
      status_size := 0;
      p_send_mtr_status^.normal := TRUE;
    ELSE
      p_send_mtr_status^.normal := FALSE;
      { IF status is abnormal should we also free the send data in case the
      { caller has touched the pages?
      status_size := #SIZE (ost$status);
      { No parameters or data is returned if status is abnormal .
      send_parameters_length := 0;
      send_data_length := 0;
      p_send_mtr_status^.condition := request_status.condition;
      RESET p_cpu_queue_entry^.p_send_buffer TO p_send_rpc_buffer_header;
      NEXT p_send_os_status IN p_cpu_queue_entry^.p_send_buffer;
      p_send_os_status^ := request_status;
      NEXT p_send_rpc_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    IFEND;

    IF p_receive_rpc_buffer_header^.call_progress.user_data_length_sent > 0 THEN
      { We are done with the receive buffer.
      mmp$free_pages (p_cpu_queue_entry^.p_receive_data, p_receive_rpc_buffer_header^.call_progress.
            user_data_length_sent, osc$wait, status);
    IFEND;

    { Initialize send buffer header.
    p_send_buffer_header^.version := dfc$status_buffer_version;
    p_send_buffer_header^.transaction_count := p_cpu_queue_entry^.transaction_count;
    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    p_send_buffer_header^.remote_processor := p_receive_buffer_header^.remote_processor;

    { Determine size of send buffer and data length to send to client.
    IF send_data_length = 0 THEN
      { No data is being sent to the client
      p_send_buffer_header^.data_length_sent := 0;
      p_driver_queue_entry^.send_buffer_descriptor.actual_length :=
            dfp$word_boundary (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) +
            #SIZE (dft$rpc_response_buffer_header) + status_size + send_parameters_length);
    ELSEIF p_cpu_queue_entry^.call_progress.total_data_received > 0 THEN
      { Data has both been received and is being sent.
      { Data is not send back with this request.
      { With retransmission if we update the rma list,
      { with the send area, And we get a retransmittal we are in trouble as
      { the rma points to the wrong data.
      p_send_buffer_header^.data_length_sent := 0;
      p_driver_queue_entry^.send_buffer_descriptor.actual_length :=
            dfp$word_boundary (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) +
            #SIZE (dft$rpc_response_buffer_header));
    ELSE { Data to send AND no data has been received
      IF send_data_length > p_queue_interface_table^.maximum_data_bytes THEN
        { There is more data to send than can fit in a single request.
        {Only send parameters back with the final piece of data.
        p_send_buffer_header^.data_length_sent := p_queue_interface_table^.maximum_data_bytes;
        p_driver_queue_entry^.send_buffer_descriptor.actual_length :=
              dfp$word_boundary (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) +
              #SIZE (dft$rpc_response_buffer_header));
        dfp$initialize_rma_list (p_cpu_queue_entry^.p_send_data, { Offset = } 0,
              p_queue_interface_table^.maximum_data_bytes, p_cpu_queue_entry^.p_data_rma_list,
              p_driver_queue_entry^.data_descriptor, status);
      ELSE { All data will fit in this single request.
        dfp$initialize_rma_list (p_cpu_queue_entry^.p_send_data, { Offset = } 0, send_data_length,
              p_cpu_queue_entry^.p_data_rma_list, p_driver_queue_entry^.data_descriptor, status);
        p_send_buffer_header^.data_length_sent := osv$page_size *
              (p_driver_queue_entry^.data_descriptor.actual_length DIV 8);
        p_driver_queue_entry^.send_buffer_descriptor.actual_length :=
              dfp$word_boundary (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) +
              #SIZE (dft$rpc_response_buffer_header) + send_parameters_length);
      IFEND;
    IFEND;
    p_send_buffer_header^.buffer_length_sent := p_driver_queue_entry^.send_buffer_descriptor.actual_length;

    {  Update call progress
    p_cpu_queue_entry^.call_progress.total_data_sent := p_send_buffer_header^.data_length_sent;
    p_cpu_queue_entry^.call_progress.user_data_length_sent := send_data_length;
    p_cpu_queue_entry^.call_progress.user_buffer_length_sent := send_parameters_length;

    { Initialize sending remote procedure call buffer header.
    p_send_rpc_buffer_header^.call_progress := p_cpu_queue_entry^.call_progress;

    IF p_send_buffer_header^.data_length_sent > 0 THEN
      p_driver_queue_entry^.flags := dfv$send_command_and_data_flags;
    ELSE
      p_driver_queue_entry^.flags := dfv$send_command_flags;
    IFEND;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('CALL_REMOTE_PROCEDURE', p_cpu_queue_entry, p_driver_queue_entry);
      IF p_send_buffer_header^.data_length_sent > 0 THEN
        display_to_console ('force RETRANSMIT of DATA SENDING ');
        wakeup_after_sending_data (p_send_buffer_header, queue_index, queue_entry_index, p_driver_queue_entry,
             current_rpc_entry, p_cpu_queue_entry);
      IFEND;
    ELSE
      dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
      IF p_send_buffer_header^.data_length_sent > 0 THEN
        dfp$await_server_subsystem (p_queue_interface_table, queue_index, p_driver_queue_entry);
        wakeup_after_sending_data (p_send_buffer_header, queue_index, queue_entry_index, p_driver_queue_entry,
              current_rpc_entry, p_cpu_queue_entry);
      IFEND;
    IFEND;
  PROCEND call_remote_procedure;
?? TITLE := ' force_retransmission ', EJECT ??

  PROCEDURE force_retransmission
    (    message: string (*);
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry);

    p_cpu_queue_entry^.transaction_state := dfc$message_content_error;
    display_integer_to_console (' DF - SERVER - FORCING RETRANSMISSION : TRANSACTION ',
          p_cpu_queue_entry^.transaction_count);
    display_integer (' DF - SERVER - FORCING RETRANSMISSION : TRANSACTION ',
          p_cpu_queue_entry^.transaction_count);
    display_to_console (message);
    display (message);
    dfp$clear_server_driver_flags (p_driver_queue_entry);
  PROCEND force_retransmission;

?? TITLE := '  get_current_rpc_entry', EJECT ??

{ PURPOSE:
{   The purpose of this request is to validate the procedure ordinal and to
{   return the associated procedure address list entry.

  PROCEDURE get_current_rpc_entry
    (    procedure_ordinal: dft$procedure_address_ordinal;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header;
         p_cpu_queue_header: ^dft$cpu_queue_header;
     VAR current_rpc_entry: dft$rpc_procedure_address_entry);

    VAR
      local_status: ost$status;

    IF (procedure_ordinal <= UPPERVALUE (dft$procedure_address_ordinal)) AND
          (procedure_ordinal >= LOWERVALUE (dft$procedure_address_ordinal)) THEN
      IF procedure_ordinal <= dfc$last_system_procedure THEN
        current_rpc_entry := dfv$procedure_address_list [procedure_ordinal];
      ELSE
        current_rpc_entry := p_cpu_queue_header^.p_application_rpc_list^
              [$INTEGER (procedure_ordinal) - $INTEGER (dfc$last_system_procedure)];
        current_rpc_entry.procedure_address := dfv$p_proc_addresses^
              [$INTEGER (procedure_ordinal) - $INTEGER (dfc$last_system_procedure)];
      IFEND;
      IF (current_rpc_entry.procedure_name_checksum <> p_receive_rpc_buffer_header^.
            procedure_name_checksum) OR (current_rpc_entry.procedure_version <>
            p_receive_rpc_buffer_header^.procedure_version) THEN
        osp$system_error ('DF - SERVER - PROCEDURE ADDRESS MISMATCH ', NIL);
      IFEND;
    ELSE
      osp$system_error ('DF - SERVER - PROCEDURE NOT LOCATED ', NIL);
    IFEND;

  PROCEND get_current_rpc_entry;
?? TITLE := ' initialize_new_call ', EJECT ??
{
{  This procedure initializes the cpu queue and valides the incoming
{ parameters on the initial transaction of a remote procedure call request.

  PROCEDURE initialize_new_call
    (    p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header;
         current_rpc_entry: dft$rpc_procedure_address_entry;
     VAR valid_client_job_id: boolean);

    VAR
      page_count: ost$non_negative_integers,
      status: ost$status;

    p_cpu_queue_entry^.total_data_to_receive := p_receive_rpc_buffer_header^.call_progress.
          user_data_length_sent;
    p_cpu_queue_entry^.call_progress.transaction_per_rpc_request := 1;
    p_cpu_queue_entry^.call_progress.total_data_sent := 0;
    p_cpu_queue_entry^.call_progress.user_data_length_sent := 0;
    p_cpu_queue_entry^.call_progress.total_data_received := 0;
    p_cpu_queue_entry^.call_progress.user_buffer_length_sent := 0;
    p_cpu_queue_entry^.remote_procedure_called := FALSE;
    valid_client_job_id := TRUE;

    IF current_rpc_entry.class =
          dfc$permanent_file_call THEN
      { Make the task look like its running on behalf of the user job
      dfp$validate_client_job_id (p_receive_rpc_buffer_header^.client_job_id,
            p_receive_rpc_buffer_header^.system_supplied_job_name,
            dfv$p_client_mainframe_file^.mainframe_header.client_job_list_root, status);
      valid_client_job_id := status.normal;
      { Is there any problem if the task terminates with its permanent
      { files table pointing TO 'another' job
      IF valid_client_job_id THEN
        dfp$set_client_job_environment (p_receive_rpc_buffer_header^.client_job_id,
              p_receive_rpc_buffer_header^.system_administrator,
              p_receive_rpc_buffer_header^.family_administrator, status);
      IFEND;
    ELSE { Task services or system core
      { Set the task to point to its native tables.
      { All permanent file requests will be on behalf of the system job.
      pfp$reset_task_environment;
    IFEND;
    IF p_cpu_queue_entry^.total_data_to_receive > 0 THEN
      { There is data to receive from the client, get all the pages wired
      { down .
      dfp$touch_pages (p_cpu_queue_entry^.p_receive_data, p_cpu_queue_entry^.total_data_to_receive,
            page_count);
    IFEND;

    IF (p_receive_buffer_header^.remote_processor <> dfc$receive_server_rpc_segment) AND
       (p_receive_buffer_header^.remote_processor <> dfc$change_job_validation_info) AND
       (p_receive_buffer_header^.remote_processor <> dfc$establish_client_job) THEN
      dfp$delete_server_rpc_segment;
    IFEND;
  PROCEND initialize_new_call;
?? TITLE := ' receive_data ', EJECT ??

{ Still more data to receive, prompt for it.

  PROCEDURE receive_data
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header;
     VAR driver_error_alert: boolean);

    VAR
      status: ost$status;


    driver_error_alert := FALSE;
    dfp$initialize_rma_list (p_cpu_queue_entry^.p_receive_data,
          {offset = } p_cpu_queue_entry^.call_progress.total_data_received,
          { Length = } p_receive_buffer_header^.data_length_sent, p_cpu_queue_entry^.p_data_rma_list,
          p_driver_queue_entry^.data_descriptor, status);

    p_driver_queue_entry^.flags := dfv$send_ready_for_data_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('RECEIVE_DATA', p_cpu_queue_entry, p_driver_queue_entry);
      driver_error_alert := TRUE;
    ELSE
      dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
      dfp$await_server_subsystem (p_queue_interface_table, queue_index, p_driver_queue_entry);
      IF p_driver_queue_entry^.flags.driver_error_alert THEN
        { Allow the request to be retransmitted
        { No need to free pages, since retransmittal will re-send pages
        report_driver_error_alert (queue_index, queue_entry_index, p_driver_queue_entry);
        driver_error_alert := TRUE;
      ELSE
        {Update total data received
        p_cpu_queue_entry^.call_progress.total_data_received :=
              p_cpu_queue_entry^.call_progress.total_data_received +
              p_receive_buffer_header^.data_length_sent;
      IFEND;
    IFEND;
    dfp$clear_server_driver_flags (p_driver_queue_entry);
  PROCEND receive_data;
?? TITLE := ' receive_new_request', EJECT ??

{  This procedure determines the state of the newly received transaction, that
{ is, whether this is a brand new remote procedure call request or a request
{ in  progress (receiving more data, or sending more data).

  PROCEDURE receive_new_request
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
     VAR status: ost$status);

    VAR
      current_rpc_entry: dft$rpc_procedure_address_entry,
      driver_error_alert: boolean,
      p_receive_buffer_header: ^dft$buffer_header,
      p_receive_rpc_buffer_header: ^dft$rpc_buffer_header,
      prompt_for_data: boolean,
      valid_client_job_id: boolean;

    status.normal := TRUE;
    RESET p_cpu_queue_entry^.p_receive_buffer;
    NEXT p_receive_buffer_header IN p_cpu_queue_entry^.p_receive_buffer;
    NEXT p_receive_rpc_buffer_header IN p_cpu_queue_entry^.p_receive_buffer;
    get_current_rpc_entry (p_receive_buffer_header^.remote_processor,
          p_receive_rpc_buffer_header, ^p_queue_interface_table^.queue_directory
          .cpu_queue_pva_directory [queue_index].p_cpu_queue^.queue_header,
          current_rpc_entry);
    IF p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request = 1 THEN
      initialize_new_call (p_cpu_queue_entry, p_receive_buffer_header, p_receive_rpc_buffer_header,
            current_rpc_entry, valid_client_job_id);
      IF NOT valid_client_job_id THEN
        send_restart_request_status (p_queue_interface_table, queue_index, queue_entry_index,
              p_cpu_queue_entry, p_driver_queue_entry, p_receive_buffer_header,
              dfe$bad_client_job_id);
        RETURN;
      IFEND;
    ELSE
      validate_call_progress (p_cpu_queue_entry, p_receive_buffer_header, p_receive_rpc_buffer_header);
      p_cpu_queue_entry^.call_progress.transaction_per_rpc_request :=
            p_cpu_queue_entry^.call_progress.transaction_per_rpc_request + 1;
    IFEND;

{ Determine whether receiving, or sending more data, or ready to call
{ procedure.

    IF p_receive_buffer_header^.data_length_sent > 0 THEN
      prompt_for_data := FALSE;
      IF p_driver_queue_entry^.data_descriptor.actual_length <> 0 THEN

{ Design glitch (unless preallocated page data space is intended); rma_list is supposed to be initialized in
{ call to RECEIVE_DATA further down...

        IF dfv$file_server_debug_enabled THEN
          display_integer_to_console (' DF - SERVER- DRIVER Q ENTRY DD ACTUAL LENGTH <> 0, = ',
                p_driver_queue_entry^.data_descriptor.actual_length);
          display_integer (' DF - SERVER- DRIVER Q ENTRY DD ACTUAL LENGTH <> 0, = ',
                p_driver_queue_entry^.data_descriptor.actual_length);
        IFEND;

        IF p_driver_queue_entry^.flags.data_received THEN

{ Data was already delivered; don't prompt for data.

          IF dfv$file_server_debug_enabled THEN
            display_to_console (' DF - SERVER- DRIVER Q ENTRY DATA_RECEIVED = TRUE');
            display (' DF - SERVER- DRIVER Q ENTRY DATA_RECEIVED = TRUE');
          IFEND;

        ELSE {page buffer space already set up, but no data in STORNET}

{ Error: The data word_count sent was zero (0), or the driver's STORNET header info was bashed.

          IF dfv$file_server_debug_enabled THEN
            display_to_console (' DF - SERVER- DRIVER Q ENTRY DATA_RECEIVED = FALSE');
            display (' DF - SERVER- DRIVER Q ENTRY DATA_RECEIVED = FALSE');
          IFEND;
        IFEND;

        IF dfv$file_server_debug_enabled THEN
          display_integer_to_console (' DF - SERVER- DRIVER Q INDEX = ', queue_index);
          display_integer (' DF - SERVER- DRIVER Q INDEX = ', queue_index);
          display_integer_to_console (' DF - SERVER- DRIVER Q ENTRY INDEX = ', queue_entry_index);
          display_integer (' DF - SERVER- DRIVER Q ENTRY INDEX = ', queue_entry_index);
          display_to_console (' DF - SERVER- IGNORING PROMPT FOR DATA');
          display (' DF - SERVER- IGNORING PROMPT FOR DATA');
        IFEND;

      ELSE {indirect address list not set up yet}

{ This is the normal case.

        IF p_driver_queue_entry^.held_over_cm_word_count = 0 THEN

{ Error: The data word_count sent was zero (0), or the driver's STORNET header info was bashed.

          IF dfv$file_server_debug_enabled THEN
            display_to_console (' DF - SERVER- DRIVER Q ENTRY HELD_OVER_CM_WORD_COUNT = 0 ');
            display (' DF - SERVER- DRIVER Q ENTRY HELD_OVER_CM_WORD_COUNT = 0 ');
            display_integer_to_console (' DF - SERVER- DRIVER Q INDEX = ', queue_index);
            display_integer (' DF - SERVER- DRIVER Q INDEX = ', queue_index);
            display_integer_to_console (' DF - SERVER- DRIVER Q ENTRY INDEX = ', queue_entry_index);
            display_integer (' DF - SERVER- DRIVER Q ENTRY INDEX = ', queue_entry_index);
            display_to_console (' DF - SERVER- IGNORING PROMPT FOR DATA');
            display (' DF - SERVER- IGNORING PROMPT FOR DATA');
          IFEND;

        ELSE

{ OK to prompt for data

          prompt_for_data := TRUE;
        IFEND;
      IFEND;

      IF prompt_for_data THEN
        { Data really has been sent from the client to the server.
        receive_data (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
              p_driver_queue_entry, p_receive_buffer_header, p_receive_rpc_buffer_header,
              driver_error_alert);
        IF driver_error_alert THEN
          { Allow time out and retransmission
          { On the next retransmission, the retransmission code will treat this
          { like a request that was not previously seen, based upon the
          { transaction_per_rpc_request.
          { This works because no other fields have been changed up to this point.
           p_cpu_queue_entry^.call_progress.transaction_per_rpc_request :=
                p_cpu_queue_entry^.call_progress.transaction_per_rpc_request - 1;
          RETURN;
        IFEND;
        IF p_cpu_queue_entry^.call_progress.total_data_received >=
              p_cpu_queue_entry^.total_data_to_receive THEN
          { All data has been received;
          call_remote_procedure (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
                p_driver_queue_entry, p_receive_buffer_header, current_rpc_entry,
                p_receive_rpc_buffer_header);
        ELSE { More data to receive.
          send_normal_status (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
                p_driver_queue_entry, p_receive_buffer_header);
        IFEND;
      IFEND; {prompt for data}
    ELSEIF (p_cpu_queue_entry^.call_progress.user_data_length_sent >
          p_receive_rpc_buffer_header^.call_progress.total_data_received) THEN
      {Still more data to send to client
      send_data (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry, p_receive_buffer_header, current_rpc_entry, p_receive_rpc_buffer_header);
    ELSE { Buffer only received
      call_remote_procedure (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry, p_receive_buffer_header, current_rpc_entry, p_receive_rpc_buffer_header);
    IFEND;

  PROCEND receive_new_request;
?? TITLE := ' receive_retransmittal ', EJECT ??

{ The server has seen this request before but the client has not
{ received  a response.  Determine the state of the transaction, whether the
{ server is receiving data from the client, sending data to the client, or
{ if no data movement is involved the send buffer is merely sent back to the
{ client.  This also checks if the previous request errored when prompting for
{ data.

  PROCEDURE receive_retransmittal
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
     VAR status: ost$status);

    VAR
      current_rpc_entry: dft$rpc_procedure_address_entry,
      p_receive_buffer_header: ^dft$buffer_header,
      p_receive_rpc_buffer_header: ^dft$rpc_buffer_header;

    status.normal := TRUE;
    dfp$clear_server_driver_flags (p_driver_queue_entry);
    RESET p_cpu_queue_entry^.p_receive_buffer;
    NEXT p_receive_buffer_header IN p_cpu_queue_entry^.p_receive_buffer;
    NEXT p_receive_rpc_buffer_header IN p_cpu_queue_entry^.p_receive_buffer;
    get_current_rpc_entry (p_receive_buffer_header^.remote_processor,
          p_receive_rpc_buffer_header, ^p_queue_interface_table^.queue_directory
          .cpu_queue_pva_directory [queue_index].p_cpu_queue^.queue_header,
          current_rpc_entry);

    { Determine if the error occurred prompting for data on the
    { previous request.  If so, nothing had been done on the previous request
    { so allow the request to be viewed as a new request.
    IF (p_receive_buffer_header^.data_length_sent > 0) AND
       ((p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request = 1) OR
       (p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request  =
        (p_cpu_queue_entry^.call_progress.transaction_per_rpc_request + 1))) THEN
      IF dfv$file_server_debug_enabled THEN
        display_integer_to_console (' RETRANS AFTER RECEIVE DATA PROMPT',
             p_receive_buffer_header^.data_length_sent);
      IFEND;
       receive_new_request (p_queue_interface_table, queue_index, queue_entry_index,
            p_driver_queue_entry, p_cpu_queue_entry, status);
       RETURN;
    IFEND;
    validate_progress_retransmittal (p_cpu_queue_entry, p_receive_buffer_header, p_receive_rpc_buffer_header);
    IF p_receive_buffer_header^.data_length_sent > 0 { From client} THEN
      { receiving data  from client
      IF dfv$file_server_debug_enabled THEN
        display_integer_to_console (' DF - SERVER- RECEIVE RETRANSMITTED DATA',
              p_receive_buffer_header^.data_length_sent);
        display_integer (' DF - SERVER- RECEIVE RETRANSMITTED DATA',
              p_receive_buffer_header^.data_length_sent);
      IFEND;
      receive_retransmitted_data (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry, p_receive_buffer_header);
    ELSEIF (p_cpu_queue_entry^.call_progress.user_data_length_sent > 0) THEN
      { Sending_data - Server TO Client }
      { Because we first check that we are not receiving data, we know this is
      { not a remote procedure call request with data movement in both
      { directions.
      IF current_rpc_entry.request_restartable =
            dfc$request_restartable THEN
        IF dfv$file_server_debug_enabled THEN
          display_to_console (' DF - SERVER- REQUEST RESTARTABLE ');
          display (' DF - SERVER- REQUEST RESTARTABLE ');
        IFEND;
        send_restart_request_status (p_queue_interface_table, queue_index, queue_entry_index,
              p_cpu_queue_entry, p_driver_queue_entry, p_receive_buffer_header,
              dfe$restart_server_request);
      ELSE { Data has been saved.
        IF dfv$file_server_debug_enabled THEN
          display_to_console ('DF -  SERVER- RE_SEND_SAVED_DATA ');
          display ('DF -  SERVER- RE_SEND_SAVED_DATA ');
        IFEND;
        re_send_saved_data (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
              p_driver_queue_entry);
      IFEND;
    ELSE { No Data movement - buffer only }
      {Send response buffer back
      IF dfv$file_server_debug_enabled THEN
        display_to_console (' DF -SERVER-  RE_SEND_BUFFER ');
        display (' DF -SERVER-  RE_SEND_BUFFER ');
      IFEND;
      re_send_buffer (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry);
    IFEND;

  PROCEND receive_retransmittal;
?? TITLE := ' receive_retransmitted_data ', EJECT ??
{
{  This procedure promtps for the data, and sends the response buffer
{  back to the client. Since we are receiving data, we know that we do not
{  need to send data back with this request.

  PROCEDURE receive_retransmitted_data
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header);

    VAR
      p_re_received_data: ^cell,
      page_count: ost$non_negative_integers,
      status: ost$status;

    { Re-receive the transmitted data
    p_re_received_data := #ADDRESS (#RING (p_cpu_queue_entry^.p_receive_data),
          #SEGMENT (p_cpu_queue_entry^.p_receive_data), #OFFSET (p_cpu_queue_entry^.p_receive_data) +
          p_cpu_queue_entry^.call_progress.total_data_received - p_receive_buffer_header^.data_length_sent);
    IF p_cpu_queue_entry^.remote_procedure_called THEN
      { All data has been received already, and the data has already been
      { freed, force the pages to be wired down again.
      dfp$touch_pages (p_re_received_data, p_receive_buffer_header^.data_length_sent, page_count);
    IFEND;

    dfp$initialize_rma_list (p_re_received_data, { Offset = } 0, p_receive_buffer_header^.data_length_sent,
          p_cpu_queue_entry^.p_data_rma_list, p_driver_queue_entry^.data_descriptor, status);

    p_driver_queue_entry^.flags := dfv$send_ready_for_data_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('RECEIVE_RETRANSMITTED_DATA', p_cpu_queue_entry, p_driver_queue_entry);
      RETURN;
    IFEND;
    dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
    dfp$await_server_subsystem (p_queue_interface_table, queue_index, p_driver_queue_entry);
    IF p_driver_queue_entry^.flags.driver_error_alert THEN
      { Allow the request to be retransmitted
      { No need to free pages, since retransmittal will re-send pages
      report_driver_error_alert (queue_index, queue_entry_index, p_driver_queue_entry);
      dfp$clear_server_driver_flags (p_driver_queue_entry);
    ELSE
      dfp$clear_server_driver_flags (p_driver_queue_entry);
      re_send_buffer (p_queue_interface_table, queue_index, queue_entry_index, p_cpu_queue_entry,
            p_driver_queue_entry);
    IFEND;
  PROCEND receive_retransmitted_data;
?? TITLE := ' report_driver_error_alert ', EJECT ??

  PROCEDURE report_driver_error_alert
    (    queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_driver_queue_entry: ^dft$driver_queue_entry);

    IF dfv$file_server_debug_enabled THEN
      display_integer_to_console (' DF - SERVER -DRIVER ERROR ', p_driver_queue_entry^.error_condition);
      display_integer_to_console (' DF - SERVER - QUEUE ', queue_index);
      display_integer_to_console (' DF - SERVER - QUEUE ENTRY', queue_entry_index);
      display_integer (' DF - SERVER -DRIVER ERROR ', p_driver_queue_entry^.error_condition);
      display_integer (' DF - SERVER - QUEUE ', queue_index);
      display_integer (' DF - SERVER - QUEUE ENTRY', queue_entry_index);
    IFEND;
  PROCEND report_driver_error_alert;
?? TITLE := ' re_send_buffer ', EJECT ??

  PROCEDURE re_send_buffer
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry);

    VAR
      p_send_buffer_header: ^dft$buffer_header;

    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    { All other fields should remain valid from the previous request.

    p_driver_queue_entry^.flags := dfv$send_command_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('RE_SEND_BUFFER',p_cpu_queue_entry, p_driver_queue_entry);
    ELSE
      dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
     IFEND;
  PROCEND re_send_buffer;
?? TITLE := ' re_send_saved_data', EJECT ??

{  The request is not restartable so data has been left wired.  Send back the
{  saved data area.

  PROCEDURE re_send_saved_data
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry);

    VAR
      p_send_buffer_header: ^dft$buffer_header,
      status: ost$status;

    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;

    dfp$initialize_rma_list (p_cpu_queue_entry^.p_last_wired_data, {offset = } 0,
          p_cpu_queue_entry^.last_wired_length, p_cpu_queue_entry^.p_data_rma_list,
          p_driver_queue_entry^.data_descriptor, status);
    IF NOT status.normal THEN
      osp$system_error ('DF - SERVER - DATA NOT WIRED ON RETRANSMITTAL', ^status);
    IFEND;

    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    p_driver_queue_entry^.flags := dfv$send_command_and_data_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('RE_SEND_SAVED_DATA', p_cpu_queue_entry, p_driver_queue_entry);
      RETURN;
    IFEND;
    dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
    dfp$await_server_subsystem (p_queue_interface_table, queue_index, p_driver_queue_entry);
    IF p_driver_queue_entry^.flags.driver_error_alert THEN
      { Allow the request to be retransmitted
      { No need to free pages, since retransmittal will re-send pages
      report_driver_error_alert (queue_index, queue_entry_index, p_driver_queue_entry);
    IFEND;
    { Do nothing on wakeup - pages are already saved
    dfp$clear_server_driver_flags (p_driver_queue_entry);
  PROCEND re_send_saved_data;
?? TITLE := '  send_data ', EJECT ??

  PROCEDURE send_data
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         current_rpc_entry: dft$rpc_procedure_address_entry;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header);

    VAR
      data_send_this_request: dft$send_data_size,
      data_size_left_to_send: dft$send_data_size,
      p_current_data: ^cell,
      p_mtr_status: ^syt$monitor_status,
      p_send_buffer_header: ^dft$buffer_header,
      p_send_rpc_buffer_header: ^dft$rpc_response_buffer_header,
      status: ost$status;

    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;

    { Compute remaining data left to sent.
    data_size_left_to_send := p_cpu_queue_entry^.call_progress.user_data_length_sent -
          p_cpu_queue_entry^.call_progress.total_data_sent;
    IF data_size_left_to_send > p_queue_interface_table^.maximum_data_bytes THEN
      { All the remaining  data won't fit in this request
      data_send_this_request := p_queue_interface_table^.maximum_data_bytes;
      p_send_buffer_header^.buffer_length_sent := dfp$word_boundary
            (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) + #SIZE (dft$rpc_response_buffer_header));
    ELSE { Last send request
      { Only send all of the parameters over with the final piece of
      { data.  Note: The user parameters have already been nexted into
      { send buffer by the call_remote_procedure routine.
      data_send_this_request := data_size_left_to_send;
      p_send_buffer_header^.buffer_length_sent := dfp$word_boundary
            (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) + #SIZE (dft$rpc_response_buffer_header) +
            p_cpu_queue_entry^.call_progress.user_buffer_length_sent);
    IFEND;
    dfp$initialize_rma_list (p_cpu_queue_entry^.p_send_data,
          {offset = } p_cpu_queue_entry^.call_progress.total_data_sent, { Length = } data_send_this_request,
          p_cpu_queue_entry^.p_data_rma_list, p_driver_queue_entry^.data_descriptor, status);

    { Initialize send buffer
    p_send_buffer_header^.version := dfc$status_buffer_version;
    p_send_buffer_header^.transaction_count := p_cpu_queue_entry^.transaction_count;
    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    p_send_buffer_header^.remote_processor := p_receive_buffer_header^.remote_processor;
    p_send_buffer_header^.data_length_sent := (p_driver_queue_entry^.data_descriptor.actual_length DIV 8) *
          osv$page_size;

    NEXT p_mtr_status IN p_cpu_queue_entry^.p_send_buffer;
    p_mtr_status^.normal := TRUE;

    p_cpu_queue_entry^.call_progress.total_data_sent := p_cpu_queue_entry^.call_progress.total_data_sent +
          p_send_buffer_header^.data_length_sent;
    { Initialize send remote procedure call
    NEXT p_send_rpc_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_rpc_buffer_header^.call_progress := p_cpu_queue_entry^.call_progress;

    p_driver_queue_entry^.send_buffer_descriptor.actual_length := p_send_buffer_header^.buffer_length_sent;
    p_driver_queue_entry^.flags := dfv$send_command_and_data_flags;

    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('SEND_DATA', p_cpu_queue_entry, p_driver_queue_entry);
    ELSE
      dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
      dfp$await_server_subsystem (p_queue_interface_table, queue_index, p_driver_queue_entry);
    IFEND;
    wakeup_after_sending_data (p_send_buffer_header, queue_index, queue_entry_index, p_driver_queue_entry,
          current_rpc_entry, p_cpu_queue_entry);
  PROCEND send_data;
?? TITLE := '  send_normal_status ', EJECT ??

  PROCEDURE send_normal_status
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header);

    VAR
      p_send_buffer_header: ^dft$buffer_header,
      p_send_mtr_status: ^syt$monitor_status,
      p_send_rpc_buffer_header: ^dft$rpc_response_buffer_header;

    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_buffer_header^.version := dfc$status_buffer_version;
    p_send_buffer_header^.transaction_count := p_cpu_queue_entry^.transaction_count;
    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    p_send_buffer_header^.remote_processor := p_receive_buffer_header^.remote_processor;
    p_send_buffer_header^.buffer_length_sent := dfp$word_boundary
          (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) + #SIZE (dft$rpc_response_buffer_header));
    p_send_buffer_header^.data_length_sent := 0;

    NEXT p_send_mtr_status IN p_cpu_queue_entry^.p_send_buffer;
    p_send_mtr_status^.normal := TRUE;

    NEXT p_send_rpc_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_rpc_buffer_header^.call_progress := p_cpu_queue_entry^.call_progress;

    p_driver_queue_entry^.send_buffer_descriptor.actual_length := p_send_buffer_header^.buffer_length_sent;
    p_driver_queue_entry^.flags := dfv$send_command_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('SEND_NORMAL_STATUS', p_cpu_queue_entry, p_driver_queue_entry);
    ELSE
      dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
    IFEND;
  PROCEND send_normal_status;
?? TITLE := ' send_restart_request_status ', EJECT ??

  PROCEDURE send_restart_request_status
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         status_condition: ost$status_condition_code);

    VAR
      free_status: ost$status,
      p_mtr_status: ^syt$monitor_status,
      p_send_buffer_header: ^dft$buffer_header,
      p_send_rpc_buffer_header: ^dft$rpc_response_buffer_header,
      p_status: ^ost$status;

    IF p_cpu_queue_entry^.call_progress.total_data_sent > 0 THEN
      mmp$free_pages (p_cpu_queue_entry^.p_send_data, p_cpu_queue_entry^.call_progress.total_data_sent,
            osc$wait, free_status);
    IFEND;

    RESET p_cpu_queue_entry^.p_send_buffer;

    { Initialize send buffer.
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_buffer_header^.version := dfc$status_buffer_version;
    p_send_buffer_header^.transaction_count := p_cpu_queue_entry^.transaction_count;
    p_send_buffer_header^.retransmission_count := p_cpu_queue_entry^.retransmission_count;
    p_send_buffer_header^.remote_processor := p_receive_buffer_header^.remote_processor;
    p_send_buffer_header^.buffer_length_sent := dfp$word_boundary
          (#SIZE (dft$buffer_header) + #SIZE (syt$monitor_status) + #SIZE (ost$status) +
          #SIZE (dft$rpc_response_buffer_header));
    p_send_buffer_header^.data_length_sent := 0;

    { Initialize status
    NEXT p_mtr_status IN p_cpu_queue_entry^.p_send_buffer;
    p_mtr_status^.normal := FALSE;
    p_mtr_status^.condition := status_condition;
    NEXT p_status IN p_cpu_queue_entry^.p_send_buffer;
    osp$set_status_abnormal (dfc$file_server_id, status_condition, '', p_status^);

{ Initialize remote procedure call header.
    NEXT p_send_rpc_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    p_send_rpc_buffer_header^.call_progress.total_data_sent := 0;
    p_send_rpc_buffer_header^.call_progress.total_data_received := 0;
    p_send_rpc_buffer_header^.call_progress.transaction_per_rpc_request :=
          p_cpu_queue_entry^.call_progress.transaction_per_rpc_request;
    p_send_rpc_buffer_header^.call_progress.total_data_received := 0;
    p_send_rpc_buffer_header^.call_progress.user_buffer_length_sent := 0;
    p_send_rpc_buffer_header^.call_progress.user_data_length_sent := 0;

    p_driver_queue_entry^.send_buffer_descriptor.actual_length := p_send_buffer_header^.buffer_length_sent;
    p_driver_queue_entry^.flags := dfv$send_command_flags;
    IF time_to_test_retransmission (p_cpu_queue_entry) THEN
      force_retransmission ('SEND_RESTART_REQUEST_STATUS', p_cpu_queue_entry, p_driver_queue_entry);
      RETURN;
    IFEND;
    dfp$queue_server_task_request (p_queue_interface_table, queue_index, queue_entry_index);
  PROCEND send_restart_request_status;
?? TITLE := ' time_to_test_retransmission ', EJECT ??

{ This function is controlled by two variables that may be changed by use of
{ the system core debugger.
{ dfv$test_retransmission_count (2 bytes) controls how often (in terms of
{   transactions) a  retransmittal will be forced. The default is zero.
{ dfv$test_retransmit_retransmit (1 byte) controls whether to force retransmist
{   during replying to a retransmittal.  The value indicates how many times
{   the retransmittal will fail. The default is to have the retransmittals
{   succeed.

  FUNCTION [INLINE] time_to_test_retransmission
    (    p_cpu_queue_entry: ^dft$cpu_queue_entry): boolean;

    time_to_test_retransmission := (dfv$test_retransmission_count > 0) AND
          (((p_cpu_queue_entry^.transaction_count DIV dfv$test_retransmission_count) *
          dfv$test_retransmission_count) = p_cpu_queue_entry^.transaction_count) AND
          (p_cpu_queue_entry^.retransmission_count <= dfv$test_retransmit_retransmit);
  FUNCEND time_to_test_retransmission;

?? TITLE := ' validate_call_progress', EJECT ??

{  This procedure verifies the progress of an ongoing remote procedure
{  call request.

  PROCEDURE validate_call_progress
    (    p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header);

    VAR
      status: ost$status;

    status.normal := TRUE;

    IF p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request <>
          (p_cpu_queue_entry^.call_progress.transaction_per_rpc_request + 1) THEN
      osp$set_status_abnormal (dfc$file_server_id, dfe$protocol_error_sequence, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter,
            p_cpu_queue_entry^.call_progress.transaction_per_rpc_request, 10, FALSE, status);
      osp$append_status_integer (osc$status_parameter_delimiter,
            p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request, 10, FALSE, status);
      osp$system_error (' DF- SERVER- RPC TRANSACTION COUNT MISMATCH ', ^status);
    IFEND;
    IF p_receive_rpc_buffer_header^.call_progress.user_data_length_sent <>
          p_cpu_queue_entry^.total_data_to_receive THEN
      osp$system_error ('DF - SERVER  - DATA TO RECEIVE MISMATCH ', NIL);
    IFEND;
    IF (p_receive_buffer_header^.data_length_sent > 0) AND
          (p_receive_buffer_header^.data_length_sent + p_cpu_queue_entry^.call_progress.total_data_received <>
          p_receive_rpc_buffer_header^.call_progress.total_data_sent) THEN
      osp$system_error ('DF - SERVER  - DATA RECEIVED MISMATCH ', NIL);
    IFEND;
    IF p_receive_rpc_buffer_header^.call_progress.total_data_received <>
          p_cpu_queue_entry^.call_progress.total_data_sent THEN
      osp$system_error ('DF - SERVER  - DATA SENT MISMATCH ', NIL);
    IFEND;
  PROCEND validate_call_progress;

?? TITLE := ' validate_procedure_address ', EJECT ??

  PROCEDURE validate_procedure_address
    (    p_receive_buffer_header: ^dft$buffer_header;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header);

    IF (p_receive_buffer_header^.remote_processor > UPPERVALUE (dft$procedure_address_ordinal)) OR
          {} (p_receive_buffer_header^.remote_processor < LOWERVALUE (dft$procedure_address_ordinal)) OR
          (dfv$procedure_address_list [p_receive_buffer_header^.remote_processor].procedure_name_checksum <>
          p_receive_rpc_buffer_header^.procedure_name_checksum) OR
          (dfv$procedure_address_list [p_receive_buffer_header^.remote_processor].procedure_version <>
          p_receive_rpc_buffer_header^.procedure_version) THEN

      osp$system_error ('DF - SERVER - PROCEDURE ADDRESS MISMATCH ', NIL);
    IFEND;
  PROCEND validate_procedure_address;
?? TITLE := ' validate_progress_retransmittal ', EJECT ??

  PROCEDURE validate_progress_retransmittal
    (    p_cpu_queue_entry: ^dft$cpu_queue_entry;
         p_receive_buffer_header: ^dft$buffer_header;
         p_receive_rpc_buffer_header: ^dft$rpc_buffer_header);

    VAR
      p_send_buffer_header: ^dft$buffer_header;

    IF p_receive_rpc_buffer_header^.call_progress.transaction_per_rpc_request <>
          p_cpu_queue_entry^.call_progress.transaction_per_rpc_request THEN
      osp$system_error ('DF - SERVER - TRANSACTION MISMATCH ON RETRANSMITAL', NIL);
    IFEND;
    IF p_receive_rpc_buffer_header^.call_progress.total_data_sent <>
          (p_cpu_queue_entry^.call_progress.total_data_received +
           p_receive_buffer_header^.data_length_sent) THEN
      osp$system_error ('DF - SERVER - DATA RECEIVED MISMATCH ON RETRANSMITAL', NIL);
    IFEND;
    IF p_receive_rpc_buffer_header^.call_progress.user_data_length_sent <>
          p_cpu_queue_entry^.total_data_to_receive THEN
      osp$system_error ('DF - SERVER - DATA TO RECEIVED MISMATCH ON RETRANSMITAL', NIL);
    IFEND;
    RESET p_cpu_queue_entry^.p_send_buffer;
    NEXT p_send_buffer_header IN p_cpu_queue_entry^.p_send_buffer;
    IF p_receive_rpc_buffer_header^.call_progress.total_data_received <>
          (p_cpu_queue_entry^.call_progress.total_data_sent - p_send_buffer_header^.data_length_sent) THEN
      osp$system_error ('DF - SERVER - DATA SEND MISMATCH ON RETRANSMITAL', NIL);
    IFEND;

  PROCEND validate_progress_retransmittal;
?? TITLE := ' wakeup_after_sending_data ', EJECT ??
{
{  After sending data to the client, determine whether the data should be
{  saved or not.  If the request is restartable data is not saved.

  PROCEDURE wakeup_after_sending_data
    (    p_send_buffer_header: ^dft$buffer_header;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
         p_driver_queue_entry: ^dft$driver_queue_entry;
         current_rpc_entry: dft$rpc_procedure_address_entry;
         p_cpu_queue_entry: ^dft$cpu_queue_entry);

    VAR
      p_current_data: ^cell,
      status: ost$status;

    IF p_driver_queue_entry^.flags.driver_error_alert THEN
      report_driver_error_alert (queue_index, queue_entry_index, p_driver_queue_entry);
    ELSE
      p_current_data := #ADDRESS (#RING (p_cpu_queue_entry^.p_send_data),
            #SEGMENT (p_cpu_queue_entry^.p_send_data), #OFFSET (p_cpu_queue_entry^.p_send_data) +
            p_cpu_queue_entry^.call_progress.total_data_sent - p_send_buffer_header^.data_length_sent);
      IF current_rpc_entry.request_restartable =
            dfc$request_restartable THEN
        mmp$free_pages (p_current_data, p_send_buffer_header^.data_length_sent, osc$wait, status);
      ELSE
        p_cpu_queue_entry^.p_last_wired_data := p_current_data;
        p_cpu_queue_entry^.last_wired_length := p_send_buffer_header^.data_length_sent;
      IFEND;
    IFEND;
    dfp$clear_server_driver_flags (p_driver_queue_entry);

  PROCEND wakeup_after_sending_data;


MODEND dfm$server_remote_procedur_call;

