?? NEWTITLE := '  NOS/VE Set Management ' ??
MODULE stm$volume_active;
?? RIGHT := 110 ??

{  PURPOSE:
{    This procedure is the compilation module for the code for
{    stp$disk_volume_active.  For a design
{    look at the entry point stp$disk_volume_active.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$mainframe_pageable
*copyc jmc$system_family
*copyc pft$root
*copyc ste$error_condition_codes
*copyc dmt$active_volume_table_index
*copyc dmt$internal_vsn
*copyc gft$system_file_identifier
*copyc ost$status
*copyc stt$dm_packet
*copyc stt$number_of_members
?? POP ??
*copyc osp$add_family
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc stp$add_member_in_ast
*copyc stp$add_member_in_master_vst
*copyc stp$build_member_list_pointer
*copyc stp$clear_exclusive_access
*copyc stp$create_ast_entry
*copyc stp$get_root_recreated
*copyc stp$get_unused_entry_in_ast
*copyc stp$get_unused_mel_entry
*copyc stp$insert_member_into_mel
*copyc stp$obtain_ast_entry
*copyc stp$obtain_ast_member_list
*copyc stp$obtain_master_vst_info
*copyc stp$obtain_member_vst_info
*copyc stp$obtain_vst_header
*copyc stp$obtain_vst_pf_root
*copyc stp$open_vst
*copyc stp$remove_member_from_master
*copyc stp$remove_set_from_ast
*copyc stp$remove_set_from_vst
*copyc stp$return_opened_vst
*copyc stp$search_ast_by_set
*copyc stp$search_mel_for_vol
*copyc stp$search_mvl_for_vol
*copyc stp$set_exclusive_access
*copyc stp$store_ast_master_header
*copyc stp$store_ast_pf_root
*copyc stp$store_dm_packet_in_mel
*copyc stp$store_inactive_master
*copyc stp$store_master_dm_packet
*copyc stp$store_member_dm_packet
*copyc stp$store_vst_being_modified
*copyc syp$process_deadstart_status
*copyc syp$trace_deadstart_message
*copyc dmv$system_device_information
*copyc osv$deadstart_phase
*copyc osv$recover_system_set_phase
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  VAR
    stv$system_set_name: [XDCL, #GATE, oss$mainframe_pageable] stt$set_name := osc$null_name;

?? NEWTITLE := '  [XDCL, #GATE] stp$disk_volume_active ', EJECT ??
*copyc sth$disk_volume_active

  PROCEDURE [XDCL, #GATE] stp$disk_volume_active
    (    active_volume: rmt$recorded_vsn;
         internal_vsn: dmt$internal_vsn;
         active_volume_table_index: dmt$active_volume_table_index;
     VAR set_name: stt$set_name;
     VAR status: ost$status);

    VAR
      first_volume: [STATIC, oss$mainframe_pageable] boolean := TRUE;

    VAR
      active_volumes_segment_pointer: mmt$segment_pointer,
      active_volumes_sfid: gft$system_file_identifier,
      ast_entry: stt$active_set_entry,
      ast_index: stt$ast_index,
      ignore_status: ost$status,
      local_status: ost$status,
      p_vol_set_table: ^stt$vol_set_table,
      root_recreated: boolean,
      set_found_in_ast: boolean,
      stl: integer,
      str: string (80),
      volume_belongs_to_set: boolean,
      volume_status_in_set: stt$vol_status_in_set,
      vst_internal_vsn: dmt$internal_vsn,
      vst_set: stt$set_name,
      vst_unique_set: stt$unique_set_name,
      vst_volume: rmt$recorded_vsn;

    status.normal := TRUE;
    root_recreated := FALSE;
    set_name := osc$null_name;
    stp$set_exclusive_access;

  /exclusive_access/
    BEGIN
      stp$open_vst (active_volume, FALSE, active_volumes_sfid, active_volumes_segment_pointer, status);
      IF NOT status.normal THEN
        IF status.condition = ste$vol_not_in_set THEN
          status.normal := TRUE;
        IFEND;
        EXIT /exclusive_access/; {----->
      IFEND;

    /vst_open/
      BEGIN
        p_vol_set_table := active_volumes_segment_pointer.cell_pointer;
        stp$obtain_vst_header (p_vol_set_table, vst_volume, vst_internal_vsn, volume_belongs_to_set, vst_set,
              vst_unique_set, volume_status_in_set);
        IF NOT volume_belongs_to_set THEN
          osp$set_status_abnormal (stc$set_management_id, ste$vst_exists_not_in_set, active_volume, status);
          EXIT /vst_open/; {----->
        IFEND;

        IF internal_vsn <> vst_internal_vsn THEN
          osp$set_status_abnormal (stc$set_management_id, ste$internal_vsn_mismatch, active_volume, status);
          EXIT /vst_open/; {----->
        IFEND;

        stp$search_ast_by_set (vst_set, ast_entry, ast_index, set_found_in_ast);
        IF set_found_in_ast THEN
          IF ast_entry.unique_set_name = vst_unique_set THEN
            IF volume_status_in_set = stc$master_vol THEN
              activate_master_volume (active_volume, internal_vsn, active_volume_table_index, p_vol_set_table,
                    ast_index, status);
            ELSE {member volume}
              activate_member_volume (active_volume, internal_vsn, active_volume_table_index, p_vol_set_table,
                    ast_index, ast_entry, status);
            IFEND;
            IF status.normal THEN
              set_name := vst_set;
            IFEND;
          ELSE
{
{ A volume has become active, with the same set name as one that
{ is currently active, but has a different unique set name.
{ If the master volume of a system set or a non-system set is
{ being initialized then we recover the set member.
{
            stp$get_root_recreated (vst_set, root_recreated, ignore_status);
            IF ((osv$recover_system_set_phase = osc$reinitialize_system_device) AND
                  (vst_set = stv$system_set_name)) OR root_recreated THEN
              STRINGREP (str, stl, 'Recovering member: ', active_volume, ' for set: ', vst_set);
              syp$trace_deadstart_message (str (1, stl));
              recover_set_member (vst_set, active_volume, internal_vsn, active_volume_table_index, ast_entry,
                    ast_index, status);
              IF status.normal THEN
                set_name := vst_set;
              ELSE
                STRINGREP (str, stl, 'Unable to recover member: ', active_volume, ' for set: ', vst_set);
                syp$process_deadstart_status (str (1, stl), {fatal = } FALSE, status);
              IFEND;
            ELSE
              osp$set_status_abnormal (stc$set_management_id, ste$diff_unique_set_active, active_volume,
                    status);
              osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
            IFEND;
          IFEND;
        ELSE
          {
          { create a new active set table entry.
          {
          IF first_volume THEN
            first_volume := FALSE;
            IF osv$deadstart_phase <> osc$installation_deadstart THEN
              stv$system_set_name := vst_set;
              osp$add_family (jmc$system_family, stv$system_set_name, local_status);
            IFEND;
          IFEND;
          IF volume_status_in_set = stc$master_vol THEN
            create_new_entry_w_master (active_volume, internal_vsn, active_volume_table_index, vst_set,
                  vst_unique_set, p_vol_set_table, stc$deny_access, ast_index, status);
          ELSE
            create_new_entry_w_member (active_volume, internal_vsn, active_volume_table_index, vst_set,
                  vst_unique_set, p_vol_set_table, stc$deny_access, ast_index, status);
          IFEND;
          IF status.normal THEN
            set_name := vst_set;
          IFEND;
        IFEND;
      END /vst_open/;

      stp$return_opened_vst (active_volumes_sfid, active_volumes_segment_pointer, local_status);
    END /exclusive_access/;

    stp$clear_exclusive_access;

  PROCEND stp$disk_volume_active;
?? OLDTITLE ??
?? NEWTITLE := '  stp$active_master_volume', EJECT ??

  PROCEDURE activate_master_volume
    (    master_volume: rmt$recorded_vsn;
         master_internal_vsn: dmt$internal_vsn;
         avt_index: dmt$active_volume_table_index;
         p_master_vst: ^stt$vol_set_table;
         ast_index: stt$ast_index;
     VAR status: ost$status);

{  PURPOSE:
{    This routine updates an existing active set entry table entry when
{    a master volume becomes active.  This includes verifying the content
{    of the active set table, transferring all members from the master
{    volume set table to the active set table, and storing information
{    from the volume set table into the active set table.
{
{      CONDITIONS:
{        ste$mel_mvl_mismatch
{        ose$mainframe_pageable_full

    VAR
      size_of_vst_member_list: stt$number_of_members,
      dm_packet_storage: stt$dm_packet_storage,
      mel_entry: stt$member_entry,
      dummy_avt_index: dmt$active_volume_table_index,
      ast_member_entry: stt$member_entry,
      vst_member_entry: stt$member_vsn_entry,
      set_owner: ost$user_identification,
      pf_root_stored_in_vst: boolean,
      pf_root_size: pft$root_size,
      p_pf_root: ^pft$root,
      pf_root_locator: stt$pf_root_locator,
      ast_entry: stt$active_set_entry,
      p_vst_member_list: ^stt$member_vsn_list,
      vst_index: integer,
      p_ast_member_list: ^stt$member_entry_list,
      ast_member_list_size: integer,
      mel_index: integer,
      vst_modified: boolean,
      volume_found_in_vst: boolean,
      volume_found_in_ast: boolean;

    status.normal := TRUE;
    vst_modified := FALSE;

    {
    { Verify that all volumes in the active set table are in the master volume
    { set table.
    { Store the dm_packet of volumes from the active set table into
    { the master volume set table. (The dm_packet in the ast may be more up
    { to date. For example.
    { member a initially active
    { member b becomes active
    { member a becomes inactive - dm_packet stored in ast
    { master becomes active )

    PUSH p_vst_member_list: [1 .. stc$max_num_members_on_set];
    stp$obtain_master_vst_info (p_master_vst, set_owner, dm_packet_storage, p_vst_member_list^,
          size_of_vst_member_list, pf_root_stored_in_vst, pf_root_size, pf_root_locator);

    PUSH p_ast_member_list: [1 .. stc$max_num_members_on_set];
    stp$obtain_ast_member_list (ast_index, p_ast_member_list^, ast_member_list_size);

  /loop_through_ast/
    FOR mel_index := 1 TO ast_member_list_size DO
      ast_member_entry := p_ast_member_list^ [mel_index];
      IF ast_member_entry.entry_type = stc$valid THEN

        {are all members that are in the ast in the vst ?}
        volume_found_in_vst := FALSE;
        vst_index := 1;
        REPEAT
          IF (p_vst_member_list^ [vst_index].entry_type = stc$valid) AND
                (p_vst_member_list^ [vst_index].member_vsn = ast_member_entry.member_vsn) THEN
            volume_found_in_vst := TRUE;
          IFEND;
          vst_index := vst_index + 1;
        UNTIL volume_found_in_vst OR (vst_index > UPPERBOUND (p_vst_member_list^)) OR
              (vst_index > size_of_vst_member_list);

        IF NOT volume_found_in_vst THEN
          stp$obtain_ast_entry (ast_index, ast_entry, status);
          osp$set_status_abnormal (stc$set_management_id, ste$mel_mvl_mismatch, ast_member_entry.member_vsn,
                status);
          osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
          EXIT /loop_through_ast/; {----->
        IFEND;
        IF ast_member_entry.member_dm_packet_storage.dm_packet_ever_stored THEN
          IF NOT vst_modified THEN
            stp$store_vst_being_modified (p_master_vst, status);
            vst_modified := TRUE;
          IFEND;
          stp$store_member_dm_packet (p_master_vst, ast_member_entry.member_vsn,
                ast_member_entry.member_dm_packet_storage, status);
        IFEND;
      IFEND;
    FOREND /loop_through_ast/;

{ Transfer all members from the master volume set table to the active set table.
    IF status.normal THEN
      FOR vst_index := 1 TO size_of_vst_member_list DO
        vst_member_entry := p_vst_member_list^ [vst_index];
        IF vst_member_entry.entry_type = stc$valid THEN
          stp$search_mel_for_vol (vst_member_entry.member_vsn, ast_index, mel_entry, mel_index,
                volume_found_in_ast);
          IF volume_found_in_ast THEN
            IF NOT mel_entry.member_dm_packet_storage.dm_packet_ever_stored THEN
              stp$store_dm_packet_in_mel (ast_index, mel_index, vst_member_entry.member_dm_packet_storage);
            IFEND;
          ELSE
            stp$add_member_in_ast (vst_member_entry.member_vsn, vst_member_entry.member_internal_vsn,
                  stc$inactive, dummy_avt_index, ast_index, vst_member_entry.member_dm_packet_storage);
          IFEND;
        IFEND;
      FOREND;
    IFEND;


    IF status.normal THEN
      stp$obtain_ast_entry (ast_index, ast_entry, status);
      IF (ast_entry.master_ever_up) AND (ast_entry.master_dm_packet_storage.dm_packet_ever_stored) THEN
        IF NOT vst_modified THEN
          stp$store_vst_being_modified (p_master_vst, status);
          vst_modified := TRUE;
        IFEND;
        dm_packet_storage := ast_entry.master_dm_packet_storage;
        stp$store_master_dm_packet (p_master_vst, dm_packet_storage);
      IFEND;
      IF pf_root_stored_in_vst THEN
        PUSH p_pf_root: [[REP pf_root_size OF cell]];
        stp$obtain_vst_pf_root (p_master_vst, p_pf_root^, status);
      ELSE
        PUSH p_pf_root: [[REP 1 OF cell]];
      IFEND;
      IF status.normal THEN
        stp$store_ast_master_header (ast_index, avt_index, set_owner, dm_packet_storage,
              pf_root_stored_in_vst, p_pf_root^, status);
      IFEND;
    IFEND;

  PROCEND activate_master_volume;
?? OLDTITLE ??
?? NEWTITLE := 'ACTIVATE_MEMBER_VOLUME', EJECT ??

  PROCEDURE activate_member_volume
    (    member_volume: rmt$recorded_vsn;
         member_internal_vsn: dmt$internal_vsn;
         members_avt_index: dmt$active_volume_table_index;
         p_member_vst: ^stt$vol_set_table;
         ast_index: stt$ast_index;
         ast_entry: stt$active_set_entry;
     VAR status: ost$status);

{  PURPOSE:
{    This routine updates an existing active set table entry when a member
{    volume becomes active.  This involves adding the member into the
{    active set table.
{  CONDITIONS:
{    ste$ast_vst_master_mis
{    ste$bad_mel_generated
{    ose$mainframe_pageable_full
{    ste$internal_vsn_mismatch

    VAR
      master_vsn: rmt$recorded_vsn,
      dm_packet_storage: stt$dm_packet_storage,
      masters_internal_vsn: dmt$internal_vsn,
      mel_entry: stt$member_entry,
      mel_index: stt$mel_index,
      member_found_in_ast: boolean;

    status.normal := TRUE;
    stp$obtain_member_vst_info (p_member_vst, master_vsn, masters_internal_vsn);
    IF master_vsn <> ast_entry.master_vsn THEN
      osp$set_status_abnormal (stc$set_management_id, ste$ast_vst_master_mis, member_volume, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, master_vsn, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.master_vsn, status);
      RETURN; {----->
    IFEND;

    IF masters_internal_vsn <> ast_entry.master_internal_vsn THEN
      osp$set_status_abnormal (stc$set_management_id, ste$internal_vsn_mismatch, master_vsn, status);
      RETURN; {----->
    IFEND;

    stp$search_mel_for_vol (member_volume, ast_index, mel_entry, mel_index, member_found_in_ast);
    IF member_found_in_ast THEN
      dm_packet_storage := mel_entry.member_dm_packet_storage;
    ELSEIF ast_entry.master_ever_up THEN
      { if the master is active. the ast should know about the member
      osp$set_status_abnormal (stc$set_management_id, ste$bad_mel_generated, member_volume, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
      RETURN; {----->
    ELSE
      stp$get_unused_mel_entry (ast_index, mel_index);
      dm_packet_storage.dm_packet_ever_stored := FALSE;
    IFEND;

    stp$insert_member_into_mel (ast_index, mel_index, member_volume, member_internal_vsn, stc$active,
          members_avt_index, dm_packet_storage);

  PROCEND activate_member_volume;
?? OLDTITLE ??
?? NEWTITLE := '  create_new_entry_w_master', EJECT ??

  PROCEDURE create_new_entry_w_master
    (    master_vsn: rmt$recorded_vsn;
         masters_internal_vsn: dmt$internal_vsn;
         masters_avt_index: dmt$active_volume_table_index;
         set_name: stt$set_name;
         unique_set_name: stt$unique_set_name;
         p_master_vst: ^stt$vol_set_table;
         access_status: stt$access_status;
     VAR ast_index: stt$ast_index;
     VAR status: ost$status);

{
{  PURPOSE:
{    This routine creates a new active set table entry when the master volume
{    is the first volume active in the set.

{  CONDITIONS: ose$mainframe_pageable_full

    VAR
      size_of_vst_member_list: stt$number_of_members,
      master_dm_packet_storage: stt$dm_packet_storage,
      dummy_avt_index: dmt$active_volume_table_index,
      set_owner: ost$user_identification,
      member_vst_entry: stt$member_vsn_entry,
      local_status: ost$status,
      pf_root_stored_in_vst: boolean,
      pf_root_size: pft$root_size,
      pf_root_locator: stt$pf_root_locator,
      p_pf_root: ^pft$root,
      p_vst_member_list: ^stt$member_vsn_list,
      vst_index: integer;

    PUSH p_vst_member_list: [1 .. stc$max_num_members_on_set];
    stp$obtain_master_vst_info (p_master_vst, set_owner, master_dm_packet_storage, p_vst_member_list^,
          size_of_vst_member_list, pf_root_stored_in_vst, pf_root_size, pf_root_locator);

    stp$create_ast_entry (set_name, unique_set_name, master_vsn, masters_internal_vsn, masters_avt_index,
          set_owner, access_status, master_dm_packet_storage, ast_index, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

{ Transfer the information about all volumes in the master volume set table to the active set table.
    FOR vst_index := 1 TO size_of_vst_member_list DO
      member_vst_entry := p_vst_member_list^ [vst_index];
      IF member_vst_entry.entry_type = stc$valid THEN
        stp$add_member_in_ast (member_vst_entry.member_vsn, member_vst_entry.member_internal_vsn,
              stc$inactive, dummy_avt_index, ast_index, member_vst_entry.member_dm_packet_storage);
      IFEND;
    FOREND;

    IF pf_root_stored_in_vst THEN
      PUSH p_pf_root: [[REP pf_root_size OF cell]];
      stp$obtain_vst_pf_root (p_master_vst, p_pf_root^, status);
      IF status.normal THEN
        stp$store_ast_pf_root (ast_index, p_pf_root^, status);
      IFEND;
    IFEND;

    IF NOT status.normal THEN
      stp$remove_set_from_ast (ast_index, local_status);
    IFEND;

  PROCEND create_new_entry_w_master;
?? OLDTITLE ??
?? NEWTITLE := '  create_new_entry_w_member', EJECT ??

  PROCEDURE create_new_entry_w_member
    (    member_vsn: rmt$recorded_vsn;
         member_internal_vsn: dmt$internal_vsn;
         members_avt_index: dmt$active_volume_table_index;
         set_name: stt$set_name;
         unique_set_name: stt$unique_set_name;
         p_member_vst: ^stt$vol_set_table;
         access_status: stt$access_status;
     VAR ast_index: stt$ast_index;
     VAR status: ost$status);

{  PURPOSE:
{    This routine creates a new active set table entry when the first volume
{    active in the set is a member.
{
{ CONDITIONS: ose$mainframe_pageable_full

    VAR
      master_vsn: rmt$recorded_vsn,
      dm_packet_storage: stt$dm_packet_storage,
      local_status: ost$status,
      masters_internal_vsn: dmt$internal_vsn;

    stp$obtain_member_vst_info (p_member_vst, master_vsn, masters_internal_vsn);
    stp$get_unused_entry_in_ast (ast_index, status);
    IF status.normal THEN
      stp$store_inactive_master (set_name, unique_set_name, master_vsn, masters_internal_vsn, access_status,
            ast_index);
      dm_packet_storage.dm_packet_ever_stored := FALSE;
      stp$add_member_in_ast (member_vsn, member_internal_vsn, stc$active, members_avt_index, ast_index,
            dm_packet_storage);
    IFEND;

  PROCEND create_new_entry_w_member;
?? OLDTITLE ??
?? NEWTITLE := '  recover_set_member', EJECT ??

  PROCEDURE recover_set_member
    (    set_name: stt$set_name;
         member_vol: rmt$recorded_vsn;
         member_internal_vsn: dmt$internal_vsn;
         members_avt_index: dmt$active_volume_table_index;
         ast_entry: stt$active_set_entry;
         ast_index: stt$ast_index;
     VAR status: ost$status);

    VAR
      dm_packet_storage: stt$dm_packet_storage,
      local_status: ost$status,
      master_vst_segment_pointer: mmt$segment_pointer,
      masters_sfid: gft$system_file_identifier,
      member_vst_segment_pointer: mmt$segment_pointer,
      members_set_name: stt$set_name,
      members_sfid: gft$system_file_identifier,
      p_master_vst: ^stt$vol_set_table,
      p_member_vst: ^stt$vol_set_table;

    stp$open_vst (ast_entry.master_vsn, TRUE, masters_sfid, master_vst_segment_pointer, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    p_master_vst := master_vst_segment_pointer.cell_pointer;
    verify_unique_member (member_vol, ast_entry, ast_index, p_master_vst, status);
    IF status.normal THEN
      stp$open_vst (member_vol, {write_access = } TRUE, members_sfid, member_vst_segment_pointer, status);
      IF status.normal THEN
        p_member_vst := member_vst_segment_pointer.cell_pointer;
        IF p_member_vst^.vol_status_in_set = stc$member_vol THEN
          dm_packet_storage.dm_packet_ever_stored := FALSE;
          stp$add_member_in_master_vst (p_master_vst, member_vol, member_internal_vsn, dm_packet_storage,
                status);
          IF status.normal THEN
            stp$add_member_in_ast (member_vol, member_internal_vsn, stc$active, members_avt_index, ast_index,
                  dm_packet_storage);
            p_member_vst^.unique_set_name := ast_entry.unique_set_name;
            p_member_vst^.master_internal_vsn := ast_entry.master_internal_vsn;
            p_member_vst^.master_vsn := ast_entry.master_vsn;
          IFEND;
        ELSE
          osp$set_status_abnormal (stc$set_management_id, ste$duplicate_master_initdd, member_vol, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.master_vsn, status);
        IFEND;
        stp$return_opened_vst (members_sfid, member_vst_segment_pointer, local_status);
      IFEND;
    IFEND;
    stp$return_opened_vst (masters_sfid, master_vst_segment_pointer, local_status);

  PROCEND recover_set_member;
?? OLDTITLE ??
?? NEWTITLE := ' verify_unique_member ', EJECT ??

{ This procedure verifies that the requested member volume is not already defined in the active set table, or
{ in the master volume set table.

  PROCEDURE verify_unique_member
    (    member_vol: rmt$recorded_vsn;
         ast_entry: stt$active_set_entry;
         ast_index: stt$ast_index;
         p_master_vst: ^stt$vol_set_table;
     VAR status: ost$status);

    VAR
      mel_index: stt$mel_index,
      member_entry: stt$member_entry,
      member_found: boolean,
      mvl_index: stt$mvl_index,
      p_new_member_vsn_list: ^stt$member_vsn_list;

    stp$search_mel_for_vol (member_vol, ast_index, member_entry, mel_index, member_found);
    IF member_found THEN
      osp$set_status_abnormal (stc$set_management_id, ste$member_vol_in_set, member_vol, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
    ELSE
      stp$build_member_list_pointer (p_master_vst^.member_vsn_list_locator, p_master_vst,
            p_new_member_vsn_list);
      stp$search_mvl_for_vol (member_vol, p_new_member_vsn_list, mvl_index, member_found);
      IF member_found THEN
        osp$set_status_abnormal (stc$set_management_id, ste$member_vol_in_set, member_vol, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, ast_entry.set_name, status);
      ELSE
        status.normal := TRUE;
      IFEND;
    IFEND;

  PROCEND verify_unique_member;
?? OLDTITLE ??
MODEND stm$volume_active;

