{
{ dmt$ms_device_allocation_table
{

  TYPE
    dmt$ms_device_allocation_unit = record
      case dau_status: dmt$dau_status of

      = dmc$dau_assigned_to_mainframe, dmc$dau_ass_to_mf_swr_flawed =
        mainframe_id: dmt$mainframe_assigned,

      = dmc$dau_assigned_to_file, dmc$dau_ass_to_file_swr_flawed =
        file_hash: dmt$file_hash,
        data_status: dmt$dau_data_status,
        case allocation_chain_position: dmt$allocation_chain_position of

        = dmc$first_and_last_allocation, dmc$last_allocation =
          low_dfl_index: dmt$old_dfl_index,
          pad: 0 .. 0ff(16),
          high_dfl_index: 0 .. 0ff(16),

        = dmc$first_allocation, dmc$middle_allocation =
          next_allocation_unit_dau: dmt$dau_address,
        casend,
      casend,
    recend;

  TYPE
    dmt$ms_device_alloc_table_head = record
      unused: array [0 .. 2] of 0 .. 0ffffffffffff(16),
      default_allocation_size: dmt$allocation_size,
      default_transfer_size: dmt$transfer_size,
      bytes_per_dau: dmt$bytes_per_dau,
      bytes_per_mau: dmt$bytes_per_mau,
      daus_per_position: dmt$daus_per_position,
      maus_per_dau: dmt$maus_per_dau,
      positions_per_device: dmt$device_position,
      number_of_entries: dmt$dau_address,
      case version_number: dmt$ms_dat_version_number of

      = dmc$dat_0_0 =
        pad1: array [1 .. 6] of 0 .. 0ffff(16),
        daus_per_allocation_style: array [dmt$allocation_styles] of
          dmt$daus_per_position,
        alloc_style_padding: array [1 .. 2] of dmt$daus_per_position,
        pad2: array [1 .. 9] of dmt$dau_address,
        available: dmt$dau_address,
        pad3: array [1 .. 10] of dmt$dau_address,
        recovery_threshold: dmt$dau_address,
        warning_threshold: dmt$dau_address,

      = dmc$dat_1_0 =
        largest_variant: SEQ (REP dmc$largest_dat_header_variant of cell),
      casend,
    recend;

  TYPE
    dmt$ms_device_allocation_table = record
      header: dmt$ms_device_alloc_table_head,
      body: ALIGNED [0 MOD 8] array [0 .. * ] of dmt$ms_device_allocation_unit,
    recend;

  TYPE
    dmt$dau_data_status = (dmc$dau_data_initialized,
      dmc$dau_data_not_initialized),

    dmt$ms_dat_version_number = (dmc$dat_0_0, dmc$dat_1_0),

    dmt$dau_status = (dmc$dau_usable, dmc$dau_hardware_flawed,
      dmc$dau_software_flawed, dmc$dau_assigned_to_mainframe,
      dmc$dau_assigned_to_file, dmc$dau_ass_to_mf_swr_flawed,
      dmc$dau_ass_to_file_swr_flawed),

    dmt$dau_states = set of dmt$dau_status;

  TYPE
    dmt$dat_lock = record
      status: ALIGNED [0 MOD 8] ost$compare_swap_lock,
    recend;

  TYPE
    dmt$dau_status_counts = array [dmt$dau_status] of dmt$dau_address;

  CONST
    dmc$largest_dat_header_variant = 2048, {bytes}

    dmc$dat_allocation_size = dmc$default_req_alloc_size,

    dmc$dat_transfer_size = dmc$default_transfer_size;

  { As a means of validating allocation chains, the last allocation unit DAU
  { of each file contains the DFL index for that file.  The DFL index is now
  { three bytes long but is stored in two pieces in order to provide file
  { compatibility with system levels having a two byte value.  The high order
  { piece is stored in a byte that has never been used by older systems, and
  { therefore is zero.
  {
  { The constant dmc$dfl_index_converter is used to convert back and forth
  { between the two versions of a DFL index.

  CONST
    dmc$dfl_index_converter = 10000(16);

?? PUSH (LISTEXT := ON) ??
*copyc dmt$allocation_chain_position
*copyc dmt$allocation_size
*copyc dmt$device_allocation_unit
*copyc dmt$device_file_list_index
*copyc dmt$device_position
*copyc dmt$file_hash
*copyc dmt$mainframe_assigned
*copyc dmt$minimum_allocation_unit
*copyc dmt$transfer_size
*copyc ost$signature_lock
?? POP ??


