COMPILATION LISTING OF SEGMENT amu_slt_search_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 07/28/87 0931.6 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 /****^ HISTORY COMMENTS: 11* 1) change(86-12-08,Farley), approve(87-07-09,MCR7746), 12* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 13* Corrected get_init_seg_ptr entry to only check the segnam array when 14* the slte.names_ptr is non-zero. 15* END HISTORY COMMENTS */ 16 17 18 amu_slt_search_: 19 proc; 20 21 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 22 23 /* Modified 17 Oct 84 by BLB to add the get_init_seg_ptr entry */ 24 /* Modified 10 Jan 85 by BLB to correct the dcl of code to be fixed bin(35) */ 25 26 /* Parameters */ 27 28 dcl P_sltp ptr; 29 dcl P_names_ptr ptr; 30 dcl P_name char (32); 31 dcl P_segp ptr; 32 dcl P_code fixed bin (35); 33 dcl P_segno fixed bin; 34 35 /* Automatic */ 36 37 dcl code fixed bin (35); 38 dcl found bit (1); 39 dcl (i, j) fixed bin; 40 dcl name char (32); 41 dcl segno fixed bin (18); 42 dcl segp ptr; 43 44 /* Entries */ 45 46 dcl ring0_get_$segptr_given_slt entry (char (*), char (*), ptr, fixed bin (35), ptr, ptr); 47 48 /* Builtins */ 49 50 dcl (addr, addrel, baseno, baseptr, fixed, hbound, min, null) builtin; 51 52 /* External static */ 53 54 dcl error_table_$action_not_performed ext static fixed bin (35); 55 56 amu_slt_search_$get_seg_ptr: 57 entry (P_sltp, P_names_ptr, P_name, P_segp, P_code); 58 code = 0; 59 sltp = P_sltp; 60 names_ptr = P_names_ptr; 61 name = P_name; 62 call ring0_get_$segptr_given_slt ("", name, segp, code, sltp, names_ptr); 63 if code = 0 then P_segp = segp; 64 P_code = code; 65 return; 66 67 /**** ********************************************************************* ****/ 68 69 amu_slt_search_$get_init_seg_ptr: 70 entry (P_sltp, P_names_ptr, P_name, P_segp, P_code); 71 72 /* 73* This entrypoint is used to find the segno and pointer given a name. Called only when looking at an 74* early dump. 75**/ 76 77 code = 0; 78 sltp = P_sltp; 79 P_segp = null (); 80 names_ptr = P_names_ptr; 81 name = P_name; 82 found = "0"b; 83 do i = 0 to min (slt.last_init_seg, hbound (slt.seg, 1)) while (^found); 84 sltep = addr (slt.seg (i)); 85 if slte.names_ptr ^= ""b then do; /* only valid if non-zero */ 86 namep = addrel (names_ptr, slte.names_ptr); 87 do j = 1 to namep -> segnam.count while (^found); 88 if name = namep -> segnam.names (j).name then do; 89 found = "1"b; 90 segno = fixed (namep -> segnam.names (j).segno, 18); 91 end; 92 end; 93 end; 94 end; 95 if ^found then 96 code = error_table_$action_not_performed; 97 else P_segp = baseptr (segno); 98 99 P_code = code; 100 return; 101 102 amu_slt_search_$get_seg_num: 103 entry (P_sltp, P_names_ptr, P_name, P_segno, P_code); 104 code = 0; 105 sltp = P_sltp; 106 names_ptr = P_names_ptr; 107 name = P_name; 108 call ring0_get_$segptr_given_slt ("", name, segp, code, sltp, names_ptr); 109 if code = 0 then P_segno = fixed (baseno (segp), 17); 110 P_code = code; 111 return; 112 113 114 amu_slt_search_$get_first_sup_seg: 115 entry (P_sltp, P_segno); 116 sltp = P_sltp; 117 P_segno = slt.first_sup_seg; 118 return; 119 120 121 amu_slt_search_$get_last_sup_seg: 122 entry (P_sltp, P_segno); 123 sltp = P_sltp; 124 P_segno = slt.last_sup_seg; 125 return; 126 1 1 /* BEGIN INCLUDE FILE slt.incl.pl1 --- Last modified 2/76 SHW */ 1 2 1 3 /* Declarations for Segment Loading Table header and array. 1 4* 1 5* Used by Initialization and MST Checker subroutines */ 1 6 1 7 dcl sltp ptr, /* pointer to base of SLT segment */ 1 8 names_ptr ptr, /* pointer to base of SLT names segment */ 1 9 namep ptr, /* pointer to segment name list block */ 1 10 pathp ptr, /* pointer to segment's directory path name */ 1 11 aclp ptr; /* pointer to acl structure */ 1 12 1 13 declare 1 slt based (sltp) aligned, /* declaration of Segment Loading Table (SLT) */ 1 14 2 name_seg_ptr ptr, /* words 0-1, pointer (ITS pair) to name segment */ 1 15 2 free_core_start fixed bin (24), /* word 2, start of free core after perm-wired */ 1 16 2 first_sup_seg fixed bin (18), /* word 3, first supervisor segment number */ 1 17 2 last_sup_seg fixed bin (18), /* word 4, last supervisor segment number */ 1 18 2 first_init_seg fixed bin (18), /* word 5, first initializer segment number */ 1 19 2 last_init_seg fixed bin (18), /* word 6, last initializer segment number */ 1 20 2 free_core_size fixed bin (24), /* size (in words) of free core after perm-wired */ 1 21 2 seg (0:8191) aligned, /* segment entries (4 words each) */ 1 22 3 slte (4) fixed bin (35); /* Space for SLT entries */ 1 23 1 24 /* auxiliary segment of SLT for storing of segment names and directory path names */ 1 25 1 26 declare 1 name_seg based (names_ptr) aligned, /* name segment header */ 1 27 2 pad bit (18) unal, 1 28 2 next_loc bit (18) unal, /* Next available free location in name seg */ 1 29 2 ht (0:127) bit (18) aligned; /* Names hash table */ 1 30 1 31 declare 1 segnam based (namep) aligned, /* declaration for segment name block */ 1 32 2 count fixed bin (17), /* number of segment names in this block */ 1 33 2 names (50 refer (segnam.count)), /* segment name array */ 1 34 3 hp bit (18) unal, /* hash thread pointer */ 1 35 3 ref bit (1) unal, /* "1"b if name referenced */ 1 36 3 pad bit (5) unal, 1 37 3 segno bit (12) unal, /* segment number associated with this name */ 1 38 3 name char (32) unal; /* space for name (max 32 characters) */ 1 39 1 40 declare 1 path based (pathp) aligned, /* declaration for directory path name */ 1 41 2 size fixed bin (17), /* length of pathname */ 1 42 2 name char (168 refer (path.size)) unal, /* directory path name */ 1 43 2 acls fixed bin; /* ACL list starts here */ 1 44 1 45 declare 1 acls based (aclp) aligned, /* declaration for acl list */ 1 46 2 count fixed bin, /* number of entries in acl list */ 1 47 2 acl (50 refer (acls.count)), /* array of acl entries */ 1 48 3 userid char (32), /* user specification */ 1 49 3 mode bit (36) aligned, /* mode for the specified user */ 1 50 3 pad bit (36) aligned, 1 51 3 code fixed bin; 1 52 1 53 1 54 /* END INCLUDE FILE slt.incl.pl1 */ 127 128 2 1 /* BEGIN INCLUDE FILE slte.incl.pl1 */ 2 2 /* Declaration for Segment Loading Table Entry structure. 2 3* Used by Initialization, MST Generation, and MST Checker subroutines */ 2 4 /* modified 5/4/76 by Noel I. Morris */ 2 5 /* last modified 12/12/83 by Keith Loepere for breakpointable */ 2 6 /* format: style3 */ 2 7 2 8 dcl sltep ptr; 2 9 2 10 dcl 1 slte_uns based (sltep) aligned, 2 11 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 2 12 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 2 13 /**** End of word 1 */ 2 14 2 access bit (4), /* SDW access bit (REWP) */ 2 15 2 cache bit (1), /* Segment to be allowed in cache */ 2 16 2 abs_seg bit (1), /* segment is an abs seg if ON */ 2 17 2 firmware_seg bit (1), /* load in low 256 */ 2 18 2 layout_seg bit (1), /* mailbox & such */ 2 19 2 breakpointable bit (1), /* includes breakpoint_page */ 2 20 2 pad1 bit (3), /* unused */ 2 21 2 wired bit (1), /* segment is wired if ON */ 2 22 2 paged bit (1), /* segment is paged if ON */ 2 23 2 per_process bit (1), /* segment is per-process if ON */ 2 24 2 pad3 bit (2), 2 25 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 2 26 /**** End of 1st half of word 2 */ 2 27 2 pad4 bit (3), 2 28 2 branch_required bit (1), /* path name supplied if ON */ 2 29 2 init_seg bit (1), /* segment is init_seg if ON */ 2 30 2 temp_seg bit (1), /* segment is temp_seg if ON */ 2 31 2 link_provided bit (1), /* linkage segment provided if ON */ 2 32 2 link_sect bit (1), /* segment is linkage segment if ON */ 2 33 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 2 34 2 combine_link bit (1), /* linkage is combined if ON */ 2 35 2 pre_linked bit (1), /* lot entry has been made if ON */ 2 36 2 defs bit (1), /* segment is definitions segment if ON */ 2 37 /***** End of word 2 */ 2 38 2 pad5 bit (6), 2 39 2 cur_length fixed bin (9) uns, /* current length of segment (in 1024 word blocks) */ 2 40 2 ringbrack (3) fixed bin (3) uns, /* ringbrackets */ 2 41 2 segno fixed bin (18) uns, /* text/link segment number */ 2 42 /***** End of word 3 */ 2 43 2 pad7 bit (3), 2 44 2 max_length fixed bin (9) uns, /* maximum length for segment */ 2 45 2 bit_count fixed bin (24) uns 2 46 ) unaligned; /* bitcount of segment */ 2 47 2 48 dcl 1 slte based (sltep) aligned, 2 49 ( 2 names_ptr bit (18), /* rel pointer to thread of names */ 2 50 2 path_ptr bit (18), /* rel pointer to pathname (if present) */ 2 51 2 access bit (4), /* SDW access bit (REWP) */ 2 52 2 cache bit (1), /* Segment to be allowed in cache */ 2 53 2 abs_seg bit (1), /* segment is an abs seg if ON */ 2 54 2 firmware_seg bit (1), 2 55 2 layout_seg bit (1), 2 56 2 breakpointable bit (1), 2 57 2 pad2 bit (3), 2 58 2 wired bit (1), /* segment is wired if ON */ 2 59 2 paged bit (1), /* segment is paged if ON */ 2 60 2 per_process bit (1), /* segment is per-process if ON */ 2 61 2 pad3 bit (2), 2 62 2 acl_provided bit (1), /* ON if acl structure follows path_name on MST */ 2 63 2 pad4 bit (3), 2 64 2 branch_required bit (1), /* path name supplied if ON */ 2 65 2 init_seg bit (1), /* segment is init_seg if ON */ 2 66 2 temp_seg bit (1), /* segment is temp_seg if ON */ 2 67 2 link_provided bit (1), /* linkage segment provided if ON */ 2 68 2 link_sect bit (1), /* segment is linkage segment if ON */ 2 69 2 link_sect_wired bit (1), /* linkage segment is wired if ON */ 2 70 2 combine_link bit (1), /* linkage is combined if ON */ 2 71 2 pre_linked bit (1), /* lot entry has been made if ON */ 2 72 2 defs bit (1), /* segment is definitions segment if ON */ 2 73 2 pad5 bit (6), 2 74 2 cur_length bit (9), /* current length of segment (in 1024 word blocks) */ 2 75 2 ringbrack (3) bit (3), /* ringbrackets */ 2 76 2 segno bit (18), /* text/link segment number */ 2 77 2 pad6 bit (3), 2 78 2 max_length bit (9), /* maximum length for segment */ 2 79 2 bit_count bit (24) 2 80 ) unaligned; /* bitcount of segment */ 2 81 2 82 /* END INCLUDE FILE slte.incl.pl1 */ 129 130 131 end amu_slt_search_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/28/87 0930.0 amu_slt_search_.pl1 >spec>install>MR12.1-1049>amu_slt_search_.pl1 127 1 05/24/82 1005.0 slt.incl.pl1 >ldd>include>slt.incl.pl1 129 2 07/11/84 0937.3 slte.incl.pl1 >ldd>include>slte.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. P_code parameter fixed bin(35,0) dcl 32 set ref 56 64* 69 99* 102 110* P_name parameter char(32) unaligned dcl 30 ref 56 61 69 81 102 107 P_names_ptr parameter pointer dcl 29 ref 56 60 69 80 102 106 P_segno parameter fixed bin(17,0) dcl 33 set ref 102 109* 114 117* 121 124* P_segp parameter pointer dcl 31 set ref 56 63* 69 79* 97* P_sltp parameter pointer dcl 28 ref 56 59 69 78 102 105 114 116 121 123 addr builtin function dcl 50 ref 84 addrel builtin function dcl 50 ref 86 baseno builtin function dcl 50 ref 109 baseptr builtin function dcl 50 ref 97 code 000100 automatic fixed bin(35,0) dcl 37 set ref 58* 62* 63 64 77* 95* 99 104* 108* 109 110 count based fixed bin(17,0) level 2 dcl 1-31 ref 87 error_table_$action_not_performed 000012 external static fixed bin(35,0) dcl 54 ref 95 first_sup_seg 3 based fixed bin(18,0) level 2 dcl 1-13 ref 117 fixed builtin function dcl 50 ref 90 109 found 000101 automatic bit(1) unaligned dcl 38 set ref 82* 83 87 89* 95 hbound builtin function dcl 50 ref 83 i 000102 automatic fixed bin(17,0) dcl 39 set ref 83* 84* j 000103 automatic fixed bin(17,0) dcl 39 set ref 87* 88 90* last_init_seg 6 based fixed bin(18,0) level 2 dcl 1-13 ref 83 last_sup_seg 4 based fixed bin(18,0) level 2 dcl 1-13 ref 124 min builtin function dcl 50 ref 83 name 2 based char(32) array level 3 in structure "segnam" packed unaligned dcl 1-31 in procedure "amu_slt_search_" ref 88 name 000104 automatic char(32) unaligned dcl 40 in procedure "amu_slt_search_" set ref 61* 62* 81* 88 107* 108* namep 000124 automatic pointer dcl 1-7 set ref 86* 87 88 90 names 1 based structure array level 2 dcl 1-31 names_ptr 000122 automatic pointer dcl 1-7 in procedure "amu_slt_search_" set ref 60* 62* 80* 86 106* 108* names_ptr based bit(18) level 2 in structure "slte" packed unaligned dcl 2-48 in procedure "amu_slt_search_" ref 85 86 null builtin function dcl 50 ref 79 ring0_get_$segptr_given_slt 000010 constant entry external dcl 46 ref 62 108 seg 10 based structure array level 2 dcl 1-13 set ref 83 84 segnam based structure level 1 dcl 1-31 segno 000114 automatic fixed bin(18,0) dcl 41 in procedure "amu_slt_search_" set ref 90* 97 segno 1(24) based bit(12) array level 3 in structure "segnam" packed unaligned dcl 1-31 in procedure "amu_slt_search_" ref 90 segp 000116 automatic pointer dcl 42 set ref 62* 63 108* 109 slt based structure level 1 dcl 1-13 slte based structure level 1 dcl 2-48 sltep 000126 automatic pointer dcl 2-8 set ref 84* 85 86 sltp 000120 automatic pointer dcl 1-7 set ref 59* 62* 78* 83 83 84 105* 108* 116* 117 123* 124 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. aclp automatic pointer dcl 1-7 acls based structure level 1 dcl 1-45 name_seg based structure level 1 dcl 1-26 path based structure level 1 dcl 1-40 pathp automatic pointer dcl 1-7 slte_uns based structure level 1 dcl 2-10 NAMES DECLARED BY EXPLICIT CONTEXT. amu_slt_search_ 000011 constant entry external dcl 18 amu_slt_search_$get_first_sup_seg 000340 constant entry external dcl 114 amu_slt_search_$get_init_seg_ptr 000111 constant entry external dcl 69 amu_slt_search_$get_last_sup_seg 000361 constant entry external dcl 121 amu_slt_search_$get_seg_num 000243 constant entry external dcl 102 amu_slt_search_$get_seg_ptr 000024 constant entry external dcl 56 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 612 626 400 622 Length 1044 400 14 201 211 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_slt_search_ 120 external procedure is an external procedure. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_slt_search_ 000100 code amu_slt_search_ 000101 found amu_slt_search_ 000102 i amu_slt_search_ 000103 j amu_slt_search_ 000104 name amu_slt_search_ 000114 segno amu_slt_search_ 000116 segp amu_slt_search_ 000120 sltp amu_slt_search_ 000122 names_ptr amu_slt_search_ 000124 namep amu_slt_search_ 000126 sltep amu_slt_search_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. ring0_get_$segptr_given_slt THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000010 56 000016 58 000031 59 000032 60 000036 61 000041 62 000045 63 000077 64 000104 65 000106 69 000107 77 000116 78 000117 79 000123 80 000125 81 000130 82 000134 83 000135 84 000151 85 000155 86 000160 87 000163 88 000175 89 000205 90 000207 92 000213 94 000215 95 000217 97 000225 99 000232 100 000235 102 000236 104 000253 105 000254 106 000260 107 000263 108 000267 109 000322 110 000330 111 000333 114 000334 116 000350 117 000354 118 000356 121 000357 123 000371 124 000375 125 000377 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved