?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE: Disk Fault Tolerance (2DD)' ??
MODULE osm$file_access_conditions;
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc ame$put_program_actions
*copyc dfe$error_condition_codes
*copyc dmt$error_condition_codes
*copyc fsc$file_access_conditions_max
*copyc fsc$internal_conditions_max
*copyc fsc$wait_cycle_busy
*copyc fsc$wait_data_restoration
*copyc fsc$wait_for_retrieval
*copyc fsc$wait_for_space
*copyc fsc$wait_server_inactive
*copyc fsc$wait_volume_missing
*copyc fsc$wait_volume_unavailable
*copyc fst$access_condition_entry
*copyc fst$file_access_condition
*copyc fst$file_reference
*copyc ioe$st_errors
*copyc mme$condition_codes
*copyc osc$cycle_busy_cond
*copyc osc$data_restoration_cond
*copyc osc$data_retrieval_req_cond
*copyc osc$space_unavailable_condition
*copyc osc$volume_unavailable_cond
*copyc osd$integer_limits
*copyc oss$mainframe_paged_literal
*copyc ost$condition_information
*copyc ost$status
*copyc ost$status_condition_code
*copyc pfe$error_condition_codes
*copyc ste$error_condition_codes
*copyc pmt$condition_information
?? POP ??
*copyc osp$set_status_condition
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    one_second = 1000 {milliseconds} ;

?? NEWTITLE := '[XDCL], condition_mapping_table' ??

?? FMT (FORMAT := OFF) ??
  VAR
    condition_mapping_table: [READ,  oss$mainframe_paged_literal]
     array [1 .. fsc$internal_conditions_max] of record
           internal_status_condition: ost$status_condition_code,
           file_access_condition: fst$file_access_condition,
         recend := [
         [ame$space_unavailable,          fsc$space_unavailable          ],
         [dfe$server_not_active,          fsc$file_server_inactive       ],
         [dfe$server_request_terminated,  fsc$file_server_inactive       ],
         [dme$some_volumes_not_online,    fsc$media_missing              ],
         [dme$unable_to_alloc_all_space,  fsc$space_unavailable          ],
         [dme$volume_unavailable,         fsc$volume_unavailable         ],
         [ioe$unit_disabled ,             fsc$volume_unavailable         ],
         [mme$volume_unavailable,         fsc$volume_unavailable         ],
         [pfe$catalog_full,               fsc$space_unavailable          ],
         [pfe$catalog_volume_not_online,  fsc$catalog_media_missing      ],
         [pfe$catalog_volume_unavailable, fsc$catalog_volume_unavailable ],
         [pfe$cycle_busy,                 fsc$cycle_busy                 ],
         [pfe$cycle_data_resides_offline, fsc$data_retrieval_required    ],
         [pfe$undefined_data,             fsc$data_restoration_required  ],
         [pfe$volume_not_online,          fsc$media_missing              ],
         [pfe$volume_unavailable,         fsc$volume_unavailable         ],
         [ste$master_not_active,          fsc$media_missing              ],
         [ste$vol_not_found,              fsc$media_missing              ]
        ];
?? OLDTITLE ??
?? NEWTITLE := '[XDCL], file_access_conditions', EJECT ??
  VAR
    file_access_conditions: [XDCL,  READ,  oss$mainframe_paged_literal]
     array [1 .. fsc$file_access_conditions_max] of fst$access_condition_entry := [

         [fsc$catalog_media_missing,
            osc$volume_unavailable_cond,
            60 * one_second,
            pfe$catalog_volume_not_online,
            fsc$wait_volume_missing],
         [fsc$catalog_volume_unavailable,
            osc$volume_unavailable_cond,
            60 * one_second,
            pfe$catalog_volume_unavailable,
            fsc$wait_volume_unavailable],
         [fsc$cycle_busy,
            osc$cycle_busy_cond,
            7 * one_second,
            pfe$cycle_busy,
            fsc$wait_cycle_busy],
         [fsc$data_restoration_required,
            osc$data_restoration_cond,
            60 * one_second,
            pfe$undefined_data,
            fsc$wait_data_restoration],
         [fsc$data_retrieval_required,
            osc$data_retrieval_req_cond,
            35 * one_second,
            pfe$cycle_data_resides_offline,
            fsc$wait_for_retrieval],
         [fsc$file_server_inactive,
            osc$volume_unavailable_cond,
            30 * one_second,
            dfe$server_not_active,
            fsc$wait_server_inactive],
         [fsc$media_missing,
            osc$volume_unavailable_cond,
            60 * one_second,
            pfe$volume_not_online,
            fsc$wait_volume_missing],
         [fsc$space_unavailable,
            osc$space_unavailable_condition,
            10 * one_second,
            ame$space_unavailable,
            fsc$wait_for_space],
         [fsc$volume_unavailable,
            osc$volume_unavailable_cond,
            60 * one_second,
            pfe$volume_unavailable,
            fsc$wait_volume_unavailable]
                                      ];
?? FMT (FORMAT := ON) ??
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$file_access_condition', EJECT ??

  FUNCTION [XDCL, #GATE] osp$file_access_condition
    (    status: ost$status): boolean;

    VAR
      i: integer;

    osp$file_access_condition := FALSE;
    IF NOT status.normal THEN
      FOR i := LOWERBOUND (condition_mapping_table) TO UPPERBOUND (condition_mapping_table) DO
        IF condition_mapping_table [i].internal_status_condition = status.condition THEN
          osp$file_access_condition := TRUE;
          RETURN;
        IFEND;
      FOREND;
    IFEND;

  FUNCEND osp$file_access_condition;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] osp$find_access_condition_entry', EJECT ??

  PROCEDURE [XDCL, #GATE] osp$find_access_condition_entry
    (    file_access_condition: fst$file_access_condition;
     VAR access_condition_entry: fst$access_condition_entry;
     VAR entry_found: boolean);

    VAR
      i: ost$positive_integers;

    entry_found := FALSE;
    FOR i := LOWERBOUND (file_access_conditions) TO UPPERBOUND (file_access_conditions) DO
      IF file_access_conditions [i].file_access_condition = file_access_condition THEN
        access_condition_entry := file_access_conditions [i];
        entry_found := TRUE;
        RETURN;
      IFEND;
    FOREND;

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

  PROCEDURE [XDCL, #GATE] osp$get_access_condition_entry
    (VAR status {input, output} : ost$status;
     VAR access_condition_entry: fst$access_condition_entry;
     VAR entry_found: boolean);

    VAR
      i: integer,
      local_status: ost$status;

    entry_found := FALSE;

    FOR i := LOWERBOUND (condition_mapping_table) TO UPPERBOUND (condition_mapping_table) DO
      IF condition_mapping_table [i].internal_status_condition = status.condition THEN
        osp$find_access_condition_entry (condition_mapping_table [i].file_access_condition,
              access_condition_entry, entry_found);

        IF (access_condition_entry.status_condition <> status.condition) THEN
          status.condition := access_condition_entry.status_condition;
        IFEND;
        RETURN;
      IFEND;
    FOREND;

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

  PROCEDURE [XDCL, #GATE] osp$get_condition_status
    (    condition_information: ^pmt$condition_information;
     VAR condition_status: ost$status);

{Purpose: This interface returns the abnormal status associated with a raised
{user-defined condition.

{Design:

{ When a user-defined file access exception condition is raised, a record of
{ TYPE ost$condition_information is implicitly passed to a condition handler
{ via the condition_information parameter.  The first field of this record is
{ the status of the condition which is NORMAL.  The remainder of the record
{ is assumed to follow this first field.  As a precaution, we check for the
{ validity of the input record by verifying that the status is normal and the
{ condition_status is in fact a file access exception condition.

    VAR
      exception_context: ^ost$condition_information;

    exception_context := condition_information;

    osp$set_status_condition (pfe$volume_not_online, condition_status);
    IF exception_context <> NIL THEN
      IF exception_context^.when_handler_status AND osp$file_access_condition
            (exception_context^.exception_status) THEN
        condition_status := exception_context^.exception_status;
      IFEND;
    IFEND;

  PROCEND osp$get_condition_status;
?? OLDTITLE ??
MODEND osm$file_access_conditions;

