?? RIGHT := 110 ??
?? TITLE := ' NOS/VE File Server: recovery_control ', EJECT ??
MODULE dfm$recovery_control;

{
{  This module contains those processes responsible for controlling the
{ sequence of events on a continuation deadstart so that file server recovery
{ will occur correctly.
{ The sequence on continuation deadstart is as follows:
{        phase2_normal - osm$Job_template_initialization
{          recover_mainframe
{             dmp$recover_mainframe - dmm$recover_mainframe
{             DFP$RECOVER_SERVER_MAINFRAMES
{               dfp$rebuild_served_family_table
{               for all servers in served family table
{                  dfp$save_server_image
{                    for all of this servers files in old system file table
{                      copy pages from the old image to the server image file
{          * POINT of commitment
{          DFP$RECOVER_CLIENT_MAINFRAMES
{            dfp$rebuild_client_mainframes
{              for all client mainframes
{                for all client jobs using this server
{                  re-attach all permanent files
{            dfp$flush_served_family_table
{
{ NOTE:
{    dfv$family_access_enabled is used to prevent permanent file access
{    to the served family till later in deadstart.  This is really a
{    minor kludge so that in loopback the process that determines
{    valid families will work despite this rebuilt process.
{    This is set to FALSE in dfp$recover_server_mainframes
{    This is set to TRUE in dfp$recover_client_mainframes.

?? PUSH (LISTEXT := ON) ??
*copyc clp$operator_intervention
*copyc dfc$esm_allocation_constants
*copyc dfe$error_condition_codes
*copyc dfi$display
*copyc dfi$log_display
*copyc dfp$change_family_server_state
*copyc dfp$delete_client_mainframes
*copyc dfp$flush_served_family_table
*copyc dfp$free_image_file
*copyc dfp$get_server_mainframe_list
*copyc dfp$purge_all_image_files
*copyc dfp$purge_preserved_family_file
*copyc dfp$rebuild_client_mainframes
*copyc dfp$rebuild_served_family_table
*copyc dfp$save_server_image
*copyc dfv$family_access_enabled
*copyc dfv$job_recovery_enabled
*copyc osv$emergency_intervention
*copyc pmp$convert_binary_mainframe_id
*copyc pmp$execute
*copyc syv$job_recovery_option
?? POP ??

?? NEWTITLE := '  Client: [XDCL] dfp$recover_server_mainframes ', EJECT ??

{
{   This procedure is responsible for saving the pages for all server mainframes
{ This procedure executes before the point of commitment.
{ The served family table is rebuilt first in order to obtain a list of server
{ mainframes and also so that if saving of the server pages does not work, the
{ served family table is used to mark the server as terminated to prevent
{ subsequent recovery.
{

  PROCEDURE [XDCL] dfp$recover_server_mainframes
    (VAR status: ost$status);

    VAR
      mainframe_name: pmt$mainframe_id,
      p_server_mainframes: ^dft$partner_mainframe_list,
      server: dft$partner_mainframe_count,
      server_count: dft$partner_mainframe_count;

    IF osv$emergency_intervention THEN
      display (' Emergency intervention in dfp$recover_server_mainframes ');
      clp$operator_intervention (status);
    IFEND;

    IF dfv$job_recovery_enabled AND (syv$job_recovery_option = syc$jre_enabled) THEN
      log_display ($pmt$ascii_logset [pmc$system_log], 'Recover server mainframes ');

      dfp$rebuild_served_family_table (status);

      dfv$family_access_enabled := FALSE;
      IF NOT status.normal THEN
        display (' Unable to rebuild served families ');
        log_display ($pmt$ascii_logset [pmc$system_log], ' Unable to rebuild served families ');
        display_status (status);
        log_display_status ($pmt$ascii_logset [pmc$system_log], TRUE, status);
        RETURN;
      IFEND;

      PUSH p_server_mainframes: [1 .. dfc$max_number_of_mainframes];
      dfp$get_server_mainframe_list ($dft$server_states [dfc$active, dfc$inactive, dfc$awaiting_recovery,
            dfc$deactivated, dfc$recovering], p_server_mainframes^, server_count);

    /save_servers_image/
      FOR server := 1 TO server_count DO
        pmp$convert_binary_mainframe_id (p_server_mainframes^ [server].mainframe_id, mainframe_name, status);
        dfp$save_server_image (mainframe_name, status);
        IF NOT status.normal THEN
          display (mainframe_name);
          log_display ($pmt$ascii_logset [pmc$system_log], mainframe_name);
          display_status (status);
          log_display_status ($pmt$ascii_logset [pmc$system_log], TRUE, status);
          IF status.condition = dfe$no_space_for_server_pages THEN
            display (' Insufficient mass storage space for server pages ');
            log_display ($pmt$ascii_logset [pmc$system_log],
                  ' Insufficient mass storage space for server pages ');
          IFEND;
          dfp$change_family_server_state (dfc$terminated, p_server_mainframes^ [server].mainframe_id);
          dfp$free_image_file (p_server_mainframes^ [server].mainframe_id, status);
        IFEND;
      FOREND /save_servers_image/;

      log_display ($pmt$ascii_logset [pmc$system_log], 'Recover server mainframes complete');
    ELSE
      display (' File server recovery disabled ');
      log_display ($pmt$ascii_logset [pmc$system_log], ' File server recovery disabled ');
    IFEND;

  PROCEND dfp$recover_server_mainframes;
?? OLDTITLE ??
?? NEWTITLE := '  [XDCL] dfp$recover_client_mainframes ', EJECT ??

{
{    This procedure is primarily involved with recovery of the client mainframes.
{  This means that all of the client mainframe files are rebuilt and the
{  permanent files are re-attached on behalf of each user job on the client.
{  This process may only be called after the point of commitment, because
{  catalogs are updated.
{    This procedure is also involved with completing any process involved
{  with recovering server mainframes. This involves flushing any changes
{  to the served family table that were made prior to the point of
{  commitment by the process dfp$recover_server_mainframes.
{    If recovery is disabled then the server image files, the client mainframe
{  files and the preserved family table are all deleted.
{

  PROCEDURE [XDCL] dfp$recover_client_mainframes
    (VAR status: ost$status);

    IF osv$emergency_intervention THEN
      display (' Emergency intervention in recover_client_mainframes ');
      clp$operator_intervention (status);
    IFEND;

    IF dfv$job_recovery_enabled AND (syv$job_recovery_option = syc$jre_enabled) THEN
      dfp$rebuild_client_mainframes;
      dfp$flush_served_family_table (status);
    ELSE
      dfp$purge_all_image_files;
      dfp$delete_client_mainframes;
      dfp$purge_preserved_family_file (status);
    IFEND;
    status.normal := TRUE;
    dfv$family_access_enabled := TRUE;

  PROCEND dfp$recover_client_mainframes;
?? OLDTITLE, OLDTITLE ??
MODEND dfm$recovery_control;

