
  CONST
*IF $true(osv$unix)
    mmc$ = (($INTEGER ('M') * 100(16)) + $INTEGER ('M')) * 10000(16);
*ELSE
    mmc$ = (($INTEGER ('M') * 100(16)) + $INTEGER ('M')) * 1000000(16);
*IFEND

?? NEWTITLE := 'MMDERR : ERROR CODES FOR MEM MGR  0 .. 5999', EJECT ??
?? FMT (FORMAT := OFF) ??

  CONST
    mme$invalid_sfid = mmc$ + 1,
    {F The specified SFID is invalid.}

    mme$page_table_full = mmc$ + 2,
    {F Page table is full.}

    mme$no_free_pages = mmc$ + 3,
    {F There are no free pages.}

    mme$job_file_tables_full = mmc$ + 4,
    {F There are not any free entries in the job file table.}

    mme$page_not_in_page_table = mmc$ + 5,
    {F Page was not found in the page table.}

    mme$invalid_pva = mmc$ + 6,
    {F Invalid PVA specified on the request.}

    mme$unable_to_get_fde_fomp = mmc$ + 7,
    {F Unable to get the file descriptor entry during the
    {   FETCH_OFFSET_MODIFIED_PAGES request.}

    mme$page_frame_not_assigned = mmc$ + 8,
    {F Page frame was not assigned to a page being locked.}

    mme$read_beyond_eoi = mmc$ + 9,
    {F Tried to read beyond EOI on read only segment - PVA = +P, P = +P.}

    mme$io_read_error = mmc$ + 10,
    {F Uncorrected IO error - PVA = +P, P = +P.}

    mme$read_write_beyond_msl = mmc$ + 11,
    {F Tried to read/write beyond maximum segment length - PVA = +P, P = +P.}

    mme$segment_access_error  = mmc$ + 12,
    {F Attempt to access segment with access not granted - PVA = +P, P = +P.}

    mme$computed_asti_out_of_range = mmc$ + 13,
    {F The computed ASTI (+P1) was out of the range of the image AST (<=+P2).}

    mme$ring_violation = mmc$ + 14,
    {F Not validated to access a segment from the present ring,
    { PVA = +P, P = +P.}

    mme$invalid_ring_brackets = mmc$ + 15,
    {F Invalid ring brackets in the SDTE.}

    mme$binding_attribute_invalid = mmc$ + 16,
    {F Attempt to set the binding attribute from above ring 3.}

    mme$execute_global_invalid = mmc$ + 17,
    {F Execute_global attribute can not be specified.}

    mme$software_attribute_invalid = mmc$ + 18,
    {F Attempt to specify software attribute from beyond ring 3.}

    mme$site_shared_queues_active = mmc$ + 19,
    {E The number of active site shared queues cannot be reduced because
    { at least one site shared queue with an ordinal greater than the
    { specified value has pages assigned.

    mme$invalid_close_segment_req = mmc$ + 20,
    {F Attempt to close/delete segment that is not in callers write bracket
    {  or segment that is not a user segment.}

    mme$caller_not_in_read_bracket = mmc$ + 21,
    {F Caller not in read bracket of segment specified.}

    mme$caller_not_in_write_bracket = mmc$ + 22,
    {F Caller not in write bracket of segment specified.}

    mme$execute_local_invalid = mmc$ + 23,
    {F Attempt to set EXECUTE_LOCAL attribute from above ring 3.}

    mme$set_unmodifiable_attribute = mmc$ + 24,
    {F Attempt to change segment attribute that can not be modified.}

    mme$segment_table_is_full = mmc$ + 25,
    {F Segment table is full.}

    mme$segment_number_is_in_use = mmc$ + 26,
    {F Segment number specified is already in use.}

    mme$segment_number_not_in_use = mmc$ + 27,
    {F Segment number specified is not in use.}

    mme$segment_number_too_big = mmc$ + 28,
    {F Segment number is beyond the range of the segment table.}

    mme$unsupported_keyword = mmc$ + 29,
    {F Keyword specified for the segment attributes is invalid.}

    mme$sdt_or_sdtx_exist = mmc$ + 30,
    {F Attempt to create inherited SDT and SDT or SDTX already exists.}

    mme$no_pages_found_for_move = mmc$ + 31,
    {F No pages which could be moved were found. }

    mme$asid_specified = mmc$ + 32,
    {F ASID specified as attribute and segment manager not called from ring 1.}

    mme$invalid_asid_specified = mmc$ + 33,
    {F The specified ASID is not one of the reserved ASID's.}

    mme$write_uncontrolled_invalid = mmc$ + 34,
    {F Attempt to set WRITE_UNCONTROLLED attribute not allowed.}

    mme$page_already_locked = mmc$ + 35,
    {F Attempt to lock a page that is already locked.}

    mme$segment_not_assigned_device = mmc$ + 36,
    {F Attempt to do IO on a segment with no backing file.}

    mme$unused_error_condition_37 = mmc$ + 37,
    {F Unused}

    mme$not_valid_in_page_table = mmc$ +38,
    {F Page in memory but valid bit not set in page table.}

    mme$stack_overflow_on_push = mmc$ + 39,
    {F Stack overflow on PUSH.}

    mme$invalid_task_id = mmc$ + 40,
    {F The taskid specified on the call is invalid.}

    mme$no_matching_offset = mmc$ + 41,
    {F On subsequent MMP$FETCH_UNWRITTEN_PAGES request, the matching
    {  offset could not be found in the page frame table.}

    mme$invalid_request = mmc$ + 42,
    {F Invalid request code.}

    mme$io_write_error = mmc$ + 43,
    {F Io error on trying to write a page to disk.}

    mme$segment_not_pageable = mmc$ + 44,
    {F Attempt to age out a page in a non pageable segment.}

    mme$segment_origin_invalid = mmc$ + 45,
    {F Attempt to set segment origin from above ring 1.}

    mme$segment_origin_change = mmc$ + 46,
    {F Attempt to modify segment origin.}

    mme$lock_unlock_invalid_length = mmc$ + 47,
    {F Lock/unlock request and length + offset > maximum segment length.}

    mme$unused_error_condition_48 = mmc$ + 48,
    {F Unused}

    mme$page_not_locked = mmc$ + 49,
    {F Request to clear lock and page not locked.}

    mme$exceeds_max_lock_page_count = mmc$ + 50,
    {F Lock page request will exceed maximum locked pages allowed.}

    mme$no_write_access = mmc$ + 51,
    {F Set segment length on segment without write access.}

    mme$lock_ring_1_stack_from_r1 = mmc$ + 52,
    {F Monitor request to lock ring 1 stack issued from ring 1.}

    mme$write_beyond_eoi_no_append = mmc$ + 53,
    {F Write beyond segment eoi with no append permission - PVA = +P, P = +P.}

    mme$unused_error_condition_54 = mmc$ + 54,
    {F Unused}

    mme$segment_locked_by_task = mmc$ + 55,
    {F Segment already locked by current task}

    mme$segment_locked_another_task = mmc$ + 56,
    {F Segment locked by another task}

    mme$segment_not_locked = mmc$ + 57,
    {F Segment not locked by current task}

    mme$temporary_reject = mmc$ + 58,
    {F Resources required to process request are temporarily unavailable}

    mme$nil_io_control_block = mmc$ + 59,
    {F The io control block has not been allocated.}

    mme$full_io_control_block = mmc$ + 60,
    {F The io control block is full.}

    mme$page_found_in_memory = mmc$ + 61,
    {F Page found in memory.}

    mme$pf_space_limit_exceeded = mmc$ + 62,
    {F The maximum permanent file space limit has been exceeded -
    { PVA = +P, P = +P.}

    mme$tf_space_limit_exceeded = mmc$ + 63,
    {F The maximum temporary file space limit has been exceeded -
    { PVA = +P, P = +P.}

    mme$disk_flaws = mmc$ + 64,
    {F Page could not be written to disk because of disk flaws.}

    mme$invalid_io_status_ptrs = mmc$ + 65,
    {F Attempt to check status of io with pointers for which no io
    { has been requested.}

    mme$write_status_complete = mmc$ + 66,
    {F Status of the write request is complete.}

    mme$stack_overflow = mmc$ + 67,
    {F Stack overflow - PVA = +P, P = +P.}

    mme$request_length_too_long = mmc$ + 68,
    {F Length on read/write request exceeds 65536 bytes.}

    mme$invalid_pva_formed = mmc$ + 69,
    {F Offset plus length created an invalid pva.}

    mme$ref_to_unrecovered_file = mmc$ + 70,
    {F The file backing the segment being referenced has not been recovered.}

    mme$length_not_0_mod_16384 = mmc$ + 71,
    {F The length of the shadow file must be a multiple of 16384.}

    mme$address_not_0_mod_16384 = mmc$ + 72,
    {F The starting address of the shadow file must be a multiple of 16384.}

    mme$invalid_shadow_segment = mmc$ + 73,
    {F The specified shadow file is not valid.}

    mme$init_shadow_improper_seg = mmc$ + 74,
    {F The segment specified is not appropriate for shadowing.}

    mme$unused_error_condition_75 = mmc$ + 75,
    {F Unused}

    mme$wired_or_fixed_segs_illegal = mmc$ + 76,
    {F The use of wired or fixed segments prohibited with this request.}

    mme$unused_error_condition_77 = mmc$ + 77,
    {F Unused}

    mme$memory_not_avail_for_assign = mmc$ + 78,
    {F Memory is not currently available for assign_pages request.}

    mme$dm_assign_active = mmc$ + 79,
    {F Backing file is being assigned for the segment.}

    mme$assign_length_too_long = mmc$ + 80,
    {F The length requested would cause the working set to get too large.}

    mme$length_must_be_positive = mmc$ + 81,
    {F The requested length must be positive.}

    mme$wait_so_other_tasks_can_run = mmc$ + 82,
    {F Cause task to wait so other tasks can execute.}

    mme$cannot_wait_for_memory = mmc$ + 83,
    {F Job is non swappable -- cannot wait to assign memory. }

    mme$illegal_segment_origin_chg = mmc$ + 84,
    {F An illegal attempt was made to change the segment origin.}

    mme$invalid_shared_taskid = mmc$ + 85,
    {F An illegal taskid was found either opening or closing a
    { shared stack segment.}

    mme$volume_unavailable = mmc$ + 86,
    {F A reference has been made to a segment on a volume +P1 that is
    { not available.}

    mme$unused_error_condition_87 = mmc$ + 87,
    {F Unused}

    mme$wired_seg_length_too_large = mmc$ + 88,
    {F The requested length of the wired segment exceeds 65536 bytes.}

    mme$length_not_page_size_mult = mmc$ + 90,
    {F The requested length on mmp$move_pages must be a page size multiple.}

    mme$pva_not_on_page_boundary = mmc$ + 91,
    {F The specified pvas on mmp$move_pages must be on a page boundary.}

    mme$unused_error_condition_92 = mmc$ + 92,
    {F Unused}

    mme$modified_source_page_reject = mmc$ + 93,
    {F Source page was modified on mmp$move_pages_request.}

    mme$source_page_not_in_memory = mmc$ + 94,
    {F Source page not in memory on mmp$move_pages request.}

    mme$invalid_length_requested = mmc$ + 95,
    {F Length is greater than maximum allowed or less than minimum allowed.}

    mme$io_active_on_move_page = mmc$ + 96,
    {F Source page had io active om mmp$move_pages request.}

    mme$unsupported_segment_kind = mmc$ + 97,
    {F Interface does not support segments of this kind--must be mmc$sk_file.}

    mme$unused_error_condition_98 = mmc$ + 98,
    {F Unused}

    mme$invalid_seg_for_prealloc = mmc$ + 99,
    {F The segment must be assigned a file for preallocation to occur.}

    mme$contig_mem_seg_violation = mmc$ + 100,
    {F Segment must be either wired or job_fixed to assign contiguous memory.}

    mme$unable_to_assign_contig_mem = mmc$ + 101,
    {F Unable to allocate the requested amount of contiguous memory.}

    mme$pages_already_assigned = mmc$ + 102,
    {F Pages within the range (PVA-->PVA+length) are already assigned.}

    mme$update_req_write_permission = mmc$ + 103,
    {F Updating the passive segment requires write permission.}

    mme$unused_error_condition_104 = mmc$ + 104,
    {F Unused}

    mme$cant_shadow_transient_segs = mmc$ + 105,
    {F Transient segments can not be shadowed.}

    mme$file_server_terminated = mmc$ + 106,
    {F The segment is located on a terminated file_server and therefore it..
    {  cannot be accessed - PVA = +P, P = +P.}

    mme$preallocate_failed = mmc$ + 107,
    {F The mmp$preallocate_file_space request could not be completed normally.

    mme$unable_to_assign_fde = mmc$ + 108,
    {F A file descriptor entry could not be assigned for this segment.

    mme$no_io_active = mmc$ + 109,
    {F The task has no asynchronous io active.

    mme$runaway_write = mmc$ + 110,
    {F Tried to write beyond Maximum_Write_Span - PVA = +P, P = +P.}

    mme$min_shared_q_size_exceeded = mmc$ + 111,
{E The Number of +P1 Pages (+P3) of +P2 exceeds the Maximum of +P4.

    mme$last_error_code = mmc$ + 5998;
    {F Dummy error code to eliminate feature conflicts. }
?? FMT (FORMAT := ON) ??
?? OLDTITLE ??
