?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE: Disk Fault Tolerance (23D)' ??
MODULE osm$disk_fault_tolerance_23d;
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc fsc$max_path_size
*copyc fst$path_size
*copyc gft$file_kind
*copyc osd$exception_policies
*copyc osd$integer_limits
*copyc osd$virtual_address
*copyc ose$disk_ft_exceptions
*copyc ost$heap
?? POP ??
*copyc avp$configuration_administrator
*copyc clp$build_pattern_for_wild_card
*copyc clp$convert_file_ref_to_string
*copyc clp$evaluate_file_reference
*copyc clp$match_string_pattern
*copyc clp$trimmed_string_size
*copyc ifp$invoke_pause_utility
*copyc mmp$create_scratch_segment
*copyc mmp$delete_scratch_segment
*copyc osp$begin_system_activity
*copyc osp$copy_exception_policies
*copyc osp$end_system_activity
*copyc osp$establish_condition_handler
*copyc osp$log_system_status_message
*copyc osp$r1_get_applicable_policy
*copyc osp$r1_get_installed_policies
*copyc osp$r1_install_exception_policy
*copyc osp$r1_lock_policies
*copyc osp$r1_unlock_policies
*copyc osp$set_status_condition
*copyc osp$set_status_from_condition
*copyc osp$verify_system_privilege
*copyc oss$task_private
*copyc osv$installed_policies
*copyc pmp$continue_to_cause
*copyc pmp$log_ascii
*copyc pmp$long_term_wait
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??
    VAR
      osv$ecp_sequence_headers: [XDCL, #GATE, oss$task_private] array [ost$ecp_sequence_index] of
            ^ost$ecp_header := [NIL, NIL];

?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$r3_get_applicable_policy', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$r3_get_applicable_policy
    (    criteria: ost$ecp_criteria;
     VAR applicable_actions: ost$ecp_actions;
     VAR polling_frequency: ost$ecp_polling_frequency;
     VAR status: ost$status);

?? NEWTITLE := 'exit_handler', EJECT ??

  PROCEDURE exit_handler
    (    condition: pmt$condition;
         condition_info: ^pmt$condition_information;
         save_area: ^ost$stack_frame_save_area;
     VAR condition_status: ost$status);

    VAR
      ignore_status: ost$status;

      case condition.selector of

      = pmc$block_exit_processing =
        osp$r1_unlock_policies;
        osp$end_system_activity;

    = ifc$interactive_condition =
      CASE condition.interactive_condition OF
      = ifc$terminate_break =
        osp$set_status_from_condition ('OS', condition, save_area, status,
              ignore_status);
        pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
        EXIT osp$r3_get_applicable_policy;
      = ifc$pause_break, ifc$job_reconnect =
        ifp$invoke_pause_utility (ignore_status);
      ELSE
        pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
      CASEND;
    ELSE
      pmp$continue_to_cause (pmc$execute_standard_procedure, condition_status);
    CASEND;

  PROCEND exit_handler;

?? OLDTITLE ??
*copy osi$find_applicable_policy

    CONST
      one_second = 1000;

    VAR
      ignore_status: ost$status,
      installed_header: ^ost$ecp_header,
      local_policy: ^ost$ecp_policy_header,
      policies: ^SEQ ( * );

    osp$verify_system_privilege;

    status.normal := TRUE;

    applicable_actions := $ost$ecp_actions [];
    polling_frequency.specified := FALSE;

    IF osv$installed_policies <> NIL THEN

    /lock_for_read/
      BEGIN
        osp$establish_condition_handler (^exit_handler, {block_exit=}TRUE);

        osp$begin_system_activity;
        REPEAT
          osp$r1_lock_policies (status);
          IF (NOT status.normal) AND (status.condition = ose$exception_policies_locked) THEN
            osp$end_system_activity;

            pmp$long_term_wait (one_second, one_second);

            osp$begin_system_activity;
          IFEND;
        UNTIL status.normal;

        policies := osv$installed_policies;

        IF policies <> NIL THEN
          RESET policies;
          NEXT installed_header IN policies;
          find_applicable_policy (criteria, installed_header, applicable_actions, local_policy, status);
          IF status.normal AND (local_policy <> NIL) THEN
            polling_frequency := local_policy^.polling_frequency;
          IFEND;
        IFEND;
      END /lock_for_read/;
    IFEND;

  PROCEND osp$r3_get_applicable_policy;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$r3_get_installed_policies', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$r3_get_installed_policies
    (VAR installed_policies {input, output} : ^SEQ ( * );
     VAR sequence_header: ^ost$ecp_header;
     VAR status: ost$status);

    VAR
      local_status: ost$status,
      segment_pointer: amt$segment_pointer;

    osp$verify_system_privilege;

    status.normal := TRUE;
    sequence_header := NIL;

    mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_sequential, segment_pointer, status);
    IF status.normal THEN
      RESET segment_pointer.sequence_pointer;
      osp$r1_get_installed_policies (segment_pointer.sequence_pointer, status);

      IF status.normal THEN
        osp$copy_exception_policies (segment_pointer.sequence_pointer, installed_policies, status);
        RESET installed_policies;
        NEXT sequence_header IN installed_policies;
      IFEND;

      mmp$delete_scratch_segment (segment_pointer, local_status);
      IF status.normal AND (NOT local_status.normal) THEN
        status := local_status;
      IFEND;
    IFEND;

  PROCEND osp$r3_get_installed_policies;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$r3_install_exception_policy', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$r3_install_exception_policy
    (    session_policies: ^SEQ ( * );
     VAR status: ost$status);

    VAR
      local_status: ost$status,
      segment_pointer: amt$segment_pointer;

    osp$verify_system_privilege;

    status.normal := TRUE;

    IF avp$configuration_administrator () THEN
      mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_sequential, segment_pointer, status);
      IF status.normal THEN
        RESET segment_pointer.sequence_pointer;
        osp$copy_exception_policies (session_policies, segment_pointer.sequence_pointer, status);

        IF status.normal THEN
          osp$r1_install_exception_policy (segment_pointer.sequence_pointer, status);
        IFEND;

        mmp$delete_scratch_segment (segment_pointer, local_status);
        IF status.normal AND (NOT local_status.normal) THEN
          status := local_status;
        IFEND;
      IFEND;
    ELSE
      osp$set_status_condition (ose$policies_require_privilege, status);
    IFEND;

  PROCEND osp$r3_install_exception_policy;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$log_executed_policy', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$log_executed_policy
    (    status: ost$status);

    VAR
      ignore_status: ost$status;

    osp$log_system_status_message ($pmt$ascii_logset [pmc$job_log, pmc$system_log], status, ignore_status);

  PROCEND osp$log_executed_policy;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$log_io_read_error ', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$log_io_read_error
    (    path: string ( * );
         file_kind: gft$file_kind;
         pva: ^cell);

    CONST
      account = 'Account ',
      binding = 'Binding ',
      catalog = 'Catalog ',
      code = 'Code ',
      data = 'Data ',
      device = 'Device ',
      engineering = 'Engineering ',
      file = 'File ',
      history = 'History ',
      job = 'Job ',
      literals = 'Literals ',
      log = 'Log',
      prefix = '**UNRECOVERED READ ERROR - ',
      pva_prefix = ' PVA=',
      security = 'Security ',
      segment = 'Segment',
      shared = 'Shared ',
      stack = 'Stack ',
      statistic = 'Statistic ',
      system = 'System ',
      task = 'Task ',
      transient = 'Transient ';

    VAR
      ignore_status: ost$status,
      length: integer,
      log_text: string (fsc$max_path_size + 27 {prefix} + 23 {system engineering log} + 5 { pva=} +
            13 {ost$virtual_address});

    CASE #SEGMENT (pva) OF {Pageable Segment Numbers Assigned by Convention}
    = osc$segnum_mainframe_paged = {#2}
      STRINGREP (log_text, length, prefix, system, data, segment, ' (1, 3)', pva_prefix, pva);
    = osc$segnum_job_pageable_heap = {#4}
      STRINGREP (log_text, length, prefix, job, data, segment, ' (2, 3)', pva_prefix, pva);
    = osc$segnum_task_private_heap = {#5}
      STRINGREP (log_text, length, prefix, task, data, segment, ' (3, 13)', pva_prefix, pva);
    = osc$segnum_task_shared_heap = {#6}
      STRINGREP (log_text, length, prefix, task, data, segment, ' (3, 13)', pva_prefix, pva);
    = osc$segnum_system_dayfile = {#8}
      STRINGREP (log_text, length, prefix, system, log, pva_prefix, pva);
    = osc$segnum_job_dayfile = {#9}
      STRINGREP (log_text, length, prefix, job, log, pva_prefix, pva);
    = 11 {0B(16)} =
      STRINGREP (log_text, length, prefix, system, literals, segment, ' (2, 13)', pva_prefix, pva);
    = 13 {013(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (1, 1, 3)', pva_prefix, pva);
    = 14 {0E(16)} =
      STRINGREP (log_text, length, prefix, system, binding, segment, ' (1, 13)', pva_prefix, pva);
    = 15 {0F(16)} =
      STRINGREP (log_text, length, prefix, job, stack, segment, ' (1, 1)', pva_prefix, pva);
    = 16 {10(16)} =
      STRINGREP (log_text, length, prefix, job, stack, segment, ' (2, 2)', pva_prefix, pva);
    = 17 {11(16)} =
      STRINGREP (log_text, length, prefix, job, stack, segment, ' (3, 3)', pva_prefix, pva);
    = 19 {13(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (1, 3, 13)', pva_prefix, pva);
    = 20 {14(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (1, 13, 13)', pva_prefix, pva);
    = 21 {15(16)} =
      STRINGREP (log_text, length, prefix, system, data, segment, ' (3, 3)', pva_prefix, pva);
    = 22 {16(16)} =
      STRINGREP (log_text, length, prefix, system, data, segment, ' (1, 1)', pva_prefix, pva);
    = 23 {17(16)} =
      STRINGREP (log_text, length, prefix, system, literals, segment, ' (11, 11)', pva_prefix, pva);
    = 26 {1A(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (2, 2, 3)', pva_prefix, pva);
    = 27 {1B(16)} =
      STRINGREP (log_text, length, prefix, system, binding, segment, ' (2, 13)', pva_prefix, pva);
    = 28 {1C(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (2, 3, 13)', pva_prefix, pva);
    = 29 {113(16)} =
      STRINGREP (log_text, length, prefix, system, code, segment, ' (2, 13, 13)', pva_prefix, pva);
    = osc$segnum_first_global_log = {#31, 01f(16)}
      STRINGREP (log_text, length, prefix, system, account, log, pva_prefix, pva);
    = osc$segnum_first_global_log - 6 = {#25, 019(16)}
      STRINGREP (log_text, length, prefix, system, engineering, log, pva_prefix, pva);
    = osc$segnum_first_global_log + 2 = {#33, 21f(16)}
      STRINGREP (log_text, length, prefix, system, job, history, log, pva_prefix, pva);
    = osc$segnum_first_global_log + 3 = {#34, 022(16)}
      STRINGREP (log_text, length, prefix, system, security, log, pva_prefix, pva);
    = osc$segnum_first_global_log + 4 = {#35, 023(16)}
      STRINGREP (log_text, length, prefix, system, statistic, log, pva_prefix, pva);
    ELSE
      CASE file_kind OF
      = gfc$fk_catalog =
        STRINGREP (log_text, length, prefix, catalog, path, pva_prefix, pva);
      = gfc$fk_device_file =
        STRINGREP (log_text, length, prefix, device, file, pva_prefix, pva);
      = gfc$fk_global_unnamed =
        STRINGREP (log_text, length, prefix, shared, transient, segment, pva_prefix, pva);
      = gfc$fk_job_local_file =
        STRINGREP (log_text, length, prefix, file, path, pva_prefix, pva);
      = gfc$fk_job_permanent_file =
        STRINGREP (log_text, length, prefix, file, path, pva_prefix, pva);
      = gfc$fk_unnamed_file =
        STRINGREP (log_text, length, prefix, job, transient, segment, pva_prefix, pva);
      ELSE {gfk$monitor_only_unnamed (wired segments), gfc$fk_save_2, gfc$fk_save_3}
        RETURN;
      CASEND;
    CASEND;

    pmp$log_ascii (log_text (1, length), $pmt$ascii_logset [pmc$job_log, pmc$system_log],
          pmc$msg_origin_system, ignore_status);

  PROCEND osp$log_io_read_error;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$store_sequence_headers', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$store_sequence_headers
    (    sequence_headers: array [ost$ecp_sequence_index] of ^ost$ecp_header;
     VAR status: ost$status);

    osp$verify_system_privilege;

    osv$ecp_sequence_headers := sequence_headers;

  PROCEND osp$store_sequence_headers;

?? OLDTITLE ??
MODEND osm$disk_fault_tolerance_23d;
