1 /****^  ***********************************************************
  2         *                                                         *
  3         * Copyright, (C) Honeywell Bull Inc., 1987                *
  4         *                                                         *
  5         * Copyright, (C) Honeywell Information Systems Inc., 1983 *
  6         *                                                         *
  7         * Copyright (c) 1972 by Massachusetts Institute of        *
  8         * Technology and Honeywell Information Systems, Inc.      *
  9         *                                                         *
 10         *********************************************************** */
 11 
 12 /* format: style4,indattr,ifthenstmt,ifthen,idind35,^indcomtxt */
 13 
 14 seg_fault: proc (a_mcptr);
 15 
 16 
 17 /****^  HISTORY COMMENTS:
 18   1) change(86-08-09,GDixon), approve(86-08-09,MCR7388),
 19      audit(86-09-02,Farley), install(86-09-08,MR12.0-1150):
 20      Document restrictions placed upon future callers of
 21      seg_fault$makeknown_activate.
 22                                                    END HISTORY COMMENTS */
 23 
 24 /*
 25     1/85 by Keith Loepere to audit logical volume full conditions.
 26    10/84 by Keith Loepere to move access computations into dc_find, also to
 27          avoid dir unlocking/locking during makeknown_activates.
 28    07/84 by Keith Loepere for the new dc_find.
 29    09/83 by E. N. Kittlitz to ignore per-process 256K switch for dirs.
 30    02/83 by E. N. Kittlitz for 256K segments.
 31    02/82 by J. Bongiovanni to eliminate use of FSDCT.
 32    01/82 by Benson I. Margulies, to give initializer segbusteds.
 33    08/81 by W. Olin Sibert, for use of validate_entryp by makeknown_activate,
 34      to fix confusion caused by (you guessed it) the directory rebuild salvager.
 35    07/81 by J. Bongiovanni for seg_fault call metering
 36    04/81 by W. Olin Sibert, for ADP SDWs
 37    02/81 by E. N. Kittlitz for makeknown_activate entry
 38    04/77 by THVV for damaged switch and messages
 39    09/76 by R. Bratt to meter per-process seg_faults
 40    05/76 by Greenberg for signalling out_of_bounds for 0 max length seg
 41    03/76 by R. Bratt for gtpd, initiated mode, and user deactivate
 42    03/76 by R. Bratt to fix kst access setting bug
 43    02/76 by R. Bratt for private LV stuff
 44    04/75 by E. Stone to put access info in kst
 45    04/75 by Andre Bensoussan for the new storage system
 46    04/75 by R. Bratt for new kst (merge by tvv)
 47    07/74 by Kobziar to check for security out-of-service
 48    04/74 by Greenberg for 2 cpu cache
 49    04/74 by Greenberg for full entry bound mechanism
 50    02/74 by Greenberg for 6180 cache
 51    12/73 by Kobziar to set bound only on basis of max_length (drop "a" bit requirement to grow page)
 52    10/73 by Steve Webber to add KLUDGE for hardcore gate entry bounds.
 53    08/73 by R.B.Snyder to put in check for illegal segfaults.
 54 
 55 
 56    seg_fault: Handles all missing segment faults in the system. The segment
 57    must alreay have a KST entry and seg_fault will as necessary do the following:
 58    1. Create an AST entry.
 59    2. Compute the access for the SDW.
 60    3. Compute the bounds field for the SDW.
 61    4. Create the trailer for the segment.
 62 
 63    USAGE: call seg_fault(mc_ptr);
 64 
 65    1. machine_conditions_ptr pointer              an ITS pointer to the machine conditions
 66    in which the missing segment fault occured.
 67 
 68 
 69    makeknown_activate: Called by makeknown_ to activate and connect directories
 70    rather than deferring this until first reference (as is the case with
 71    non-directory segments).  This allows activation errors such as
 72    connection failure to be indicated by status code, causing a
 73    makeknown_ failure, rather than eventually causing a crawlout due
 74    to segment fault error.
 75 
 76    Currently makeknown_ is the only caller of this entrypoint.  Should other
 77    procedures need to call it in the future, they must meet the following
 78    requirements:
 79 
 80       The caller must have called sum$getbranch or sum$getbranch_root_my to
 81       obtain a pointer to the directory entry corresponding to the segment
 82       (identified by a_kstep) to be activated.  This will lock the directory
 83       and validate that a_kstep->kste.entryp properly points to the directory
 84       entry for the segment.  The directory must remain locked until seg_fault
 85       returns, since seg_fault used kste.entryp.  If the directory were
 86       unlocked, another processor could move or delete the directory entry out
 87       from under seg_fault.
 88 
 89    USAGE: call seg_fault$makeknown_activate (a_kstep, a_code);
 90 
 91    1. a_kstep pointer to KST entry (input)
 92    2. a_code status error code (output)
 93    */
 94 
 95 /* Parameters */
 96 
 97 dcl  a_code                             fixed bin (35) parameter;
 98 dcl  a_kstep                            pointer parameter;
 99 dcl  a_mcptr                            pointer parameter;
100 
101 /* Variables */
102 
103 dcl  activated_sw                       bit (1) aligned;
104 dcl  audit_eventflags                   bit (36) aligned;
105 dcl  branch_entrypt_bound               bit (14);
106 dcl  branch_entrypt_sw                  bit (1);
107 dcl  code                               fixed bin (35);
108 dcl  esw                                fixed bin;
109 dcl  lsw                                bit (1) aligned;
110 dcl  lvx                                fixed bin (8);
111 dcl  mode                               bit (36) aligned;
112 dcl  offset                             fixed bin (18);
113 dcl  1 orig_sdwi                        aligned like sdw_info automatic;
114 dcl  pts                                fixed bin;
115 dcl  pw1                                fixed bin (17);
116 dcl  pw2                                fixed bin (17);
117 dcl  ringno                             fixed bin;
118 dcl  sdw_address                        fixed bin (26);
119 dcl  sdw_valid                          bit (1) aligned;
120 dcl  1 sdwi                             aligned like sdw_info automatic;
121 dcl  segno                              fixed bin (17);
122 dcl  segptr                             pointer;
123 dcl  time1                              fixed bin (71);
124 dcl  time2                              fixed bin (71);
125 dcl  tsdw                               fixed bin (71);
126 
127 /* External */
128 
129 dcl  access_operations_$log_vol_full    bit (36) aligned external static;
130 dcl  active_all_rings_data$stack_base_segno fixed bin (18) external static;
131 dcl  dseg$                              (0:4095) fixed bin (71) external static;
132 dcl  error_table_$big_seg               fixed bin (35) external static;
133 dcl  error_table_$boundviol             fixed bin (35) external static;
134 dcl  error_table_$log_vol_full          fixed bin (35) external static;
135 dcl  error_table_$mylock                fixed bin (35) external static;
136 dcl  error_table_$oosw                  fixed bin (35) external static;
137 dcl  error_table_$seg_busted            fixed bin (35) external static;
138 dcl  error_table_$seg_deleted           fixed bin (35) external static;
139 dcl  pds$access_authorization           bit (72) aligned ext;
140 dcl  pds$dstep                          bit (18) external static;
141 dcl  pds$segment_faults                 fixed bin (35) external static;
142 dcl  pds$stacks                         (0:7) ptr external static;
143 dcl  pvt$root_lvid                      bit (36) aligned external static;
144 dcl  sst$cpu_sf_time                    fixed bin (71) external static;
145 dcl  sst$makeknown_activations          fixed bin (35) external static;
146 dcl  sst$pts                            (0:3) fixed bin external static;
147 dcl  sst$root_astep                     pointer external static;
148 dcl  sst$tfreep                         pointer external static;
149 dcl  sst$total_sf_pf                    fixed bin (35) external static;
150 dcl  sst$total_sf                       fixed bin (35) external static;
151 dcl  sst$seg_fault_calls                fixed bin (35) external static;
152 dcl  sys_info$seg_size_256K             fixed bin (19) external static;
153 
154 /* Entries */
155 
156 dcl  access_audit_$log_general          entry (char (*), fixed bin, bit (36) aligned, bit (36) aligned, char (*), fixed bin (35), ptr, fixed bin (18), char (*));
157 dcl  activate$activate_long             entry (ptr, bit (1) aligned, fixed bin (35)) returns (ptr);
158 dcl  get_kstep                          entry (fixed bin (17), ptr, fixed bin (35));
159 dcl  get_ptrs_$given_astep              entry (pointer) returns (fixed bin (71));
160 dcl  level$get                          entry () returns (fixed bin);
161 dcl  lock$dir_unlock                    entry (pointer);
162 dcl  lock$lock_ast                      entry;
163 dcl  lock$unlock_ast                    entry;
164 dcl  logical_volume_manager$lvtep       entry (bit (36) aligned, ptr, fixed bin (35));
165 dcl  makestack                          entry (fixed bin);
166 dcl  page$enter_data                    entry (fixed bin (17), fixed bin);
167 dcl  private_logical_volume$lvx         entry (bit (36) aligned, fixed bin (8), fixed bin (35));
168 dcl  sdw_util_$construct                entry (pointer, pointer);
169 dcl  sdw_util_$dissect                  entry (pointer, pointer);
170 dcl  sdw_util_$get_address              entry (pointer, fixed bin (26));
171 dcl  sdw_util_$get_valid                entry (pointer, bit (1) aligned);
172 dcl  segment_mover                      entry (fixed bin (18), ptr, ptr, fixed bin, fixed bin (35));
173 dcl  setfaults$cache                    entry (pointer, bit (1) aligned);
174 dcl  sum$getbranch_root_my              entry (pointer, bit (36) aligned, pointer, fixed bin (35));
175 dcl  syserr                             entry options (variable);
176 dcl  thread$lin                         entry (pointer, bit (18)); /* Requires bit (18) unal in upper halfword only */
177 dcl  usage_values                       entry (fixed bin (17), fixed bin (71));
178 
179 /* Constants */
180 
181 dcl  FAULT                              fixed bin static internal options (constant) init (0);
182 dcl  MAKEKNOWN                          fixed bin static internal options (constant) init (1);
183 
184 /* Miscelaneous */
185 
186 dcl  (addr, baseptr, bin, binary, bit, min, null, ptr, rel, string, substr) builtin;
187 %page;
188 
189 /* set initial pointer values */
190 
191           call usage_values (pw1, time1);                   /* start metering of seg faults */
192           esw = FAULT;
193           code = 0;
194           kstp = pds$kstp;
195           mcp = a_mcptr;
196           scup = addr (mc.scu (0));
197           mc.errcode = 0;
198           ringno = bin (scu.ppr.prr, 3);
199 
200 
201 /* NOW FIND OUT THE SEGMENT NUMBER OF THE FAULTING SEGMENT - IF THE RESTART BIT IN THE SCU
202    DATA IS "ON", THE FAULTING SDW IS FOR THE PROCEDURE SEGMENT AND HENCE PSR SHOULD BE USED -
203    OTHERWISE, TSR SHOULD BE USED */
204 
205           if scu.cu.if then segno = bin (scu.ppr.psr, 15);
206           else segno = bin (scu.tpr.tsr, 15);
207 
208           call sdw_util_$get_valid (addr (dseg$ (segno)), sdw_valid);
209           if sdw_valid then do;                             /* Fault is a fraud */
210                call syserr (0, "seg_fault: illegal segfault on cpu ^a",
211                     substr ("ABCDEFGH", bin (scu.cpu_no, 3) + 1, 1)); /* log it and maybe crash */
212                return;                                      /* rcu the data and try again */
213           end;
214 
215           call page$enter_data (segno, (seg_fault_start));  /* enter start of seg_fault in trace */
216 
217           offset = bin (scu.ca, 18);                        /* get computed address */
218 
219 
220 /* CHECK FOR FAULT ON STACK SEGMENT */
221 
222           if segno >= active_all_rings_data$stack_base_segno then
223                if segno <= active_all_rings_data$stack_base_segno + 7 then
224                     if pds$stacks (segno - active_all_rings_data$stack_base_segno) = null then do;
225                          call makestack (segno - active_all_rings_data$stack_base_segno); /* Will cause recursive segfault on stack */
226                          go to finish;
227                     end;
228 
229 
230 /* GET KST ENTRY POINTER */
231 
232           segptr = baseptr (segno);                         /* make a seg pointer */
233           call get_kstep (segno, kstep, code);
234           if code ^= 0 then go to err;
235 
236 /* GET THE ASTE POINTER - IF IT IS THE ROOT, IT IS ALWAYS ACTIVE AND ITS ASTE POINTER IS IN THE SST -
237    IF IT IS NOT THE ROOT, ONE HAS TO FIND THE BRANCH, LOCK THE PARENT AND GET AN ASTE FOR THE SEGMENT IF IT
238    DOES NOT HAVE ONE ALREADY. */
239 
240 
241 COMMON:
242           if kste.uid = (36)"1"b then do;                   /* is this the root */
243 
244 /* ROOT */
245 
246                lsw = "0"b;                                  /* we won't lock the parent */
247                call lock$lock_ast;
248                if code ^= 0 then go to err;
249                astep = sst$root_astep;                      /* this is easy */
250           end;
251 
252 /* NOT THE ROOT */
253 
254           else do;
255                if esw = MAKEKNOWN then lsw = "0"b;          /* guaranteed to be a locked directory */
256 
257                else do;                                     /* normal seg_fault */
258 
259 /* sum must be called here, not in dc_find.  This is because sum may take a
260 (recursive) seg_fault on the parent directory.  dc_find has too big a stack
261 frame to allow it to come into play in these recursive seg_fault occurences. */
262 
263                     lsw = "0"b;
264                     call sum$getbranch_root_my (segptr, "0"b, ep, code);
265                     if code = 0 then lsw = "1"b;
266                     else if code = error_table_$mylock then code = 0;
267                     else if code = error_table_$seg_deleted then do;
268                          dp, ep = null;
269                          go to seg_audit;
270                     end;
271                     else go to err;
272                     dp = ptr (ep, 0);
273 
274 /* Parent is guaranteed to be in service if we got this far.
275    Make sure the entry is still in service. */
276 
277                     if entry.security_oosw then
278                          if ^addr (pds$access_authorization) -> aim_template.privileges.soos then do;
279                               code = error_table_$oosw;
280                               go to err1;
281                          end;
282 
283                     if ^entry.dirsw then do;                /* compute access (dirs are special cased later) */
284 seg_audit:               call dc_find$seg_fault (kstep, ep, code);
285                          if code ^= 0 then go to err1;
286                     end;
287                end;
288 
289                if ^kste.dirsw then do;
290 
291 /* COPY FROM BRANCH THOSE ITEMS THAT WILL BE NEEDED AFTER AST IS LOCKED
292    SO THAT DIRECTORIES ARE NEVER REFERENCED WHILE THE AST IS LOCKED */
293 
294                     branch_entrypt_bound = entry.entrypt_bound;
295                     branch_entrypt_sw = entry.entrypt_sw;
296 
297                end;
298 
299 /* MAKE SURE ITS LOGICALLY MOUNTED FOR THIS PROCESS (NOT NECESSARILY PHYSICALLY MOUNTED)
300    TO AVOID PAGE FAULTS ON DIR HEADER AND LVT SEVERAL TESTS ARE MADE WHERE ONE WOULD DO */
301 
302                if ^kste.dirsw then                          /* not a dir which would be on RLV and hence public */
303                     if kste.infcount = 0 then               /* not marked as privately mounted */
304                          if (entry.sons_lvid ^= pvt$root_lvid) |
305                               entry.master_dir then do;     /* cant prove its on RLV and hence public */
306                                                             /* oh well, time for the definitive test */
307                               call logical_volume_manager$lvtep (dir.sons_lvid, lvtep, code);
308                               if code ^= 0 then goto err1;  /* sorry, no such LV */
309                               if ^lvte.public then do;      /* LV not public so check for private mount */
310                                    call private_logical_volume$lvx (dir.sons_lvid, lvx, code);
311                                    if code ^= 0 then goto err1; /* sorry, not privately mounted */
312                                    kste.infcount = lvx;     /* remember that it was privately mounted */
313                               end;
314                          end;
315 
316                astep = activate$activate_long (ep, activated_sw, code); /* Returns with AST locked if OK */
317                if code ^= 0 then go to err1;
318 
319                if esw = MAKEKNOWN then                      /* meter ? */
320                     if activated_sw then
321                          sst$makeknown_activations = sst$makeknown_activations + 1;
322           end;
323 
324 /* ARE THERE PAGE_CONTROL INDUCED EXCEPTION CONDITIONS ON SEGMENT ? */
325 
326           if aste.damaged & ^kste.dirsw then do;
327                code = error_table_$seg_busted;
328                go to err0;
329           end;
330 
331 /* IS THERE A PER-PROCESS SIZE LIMITATION (256K) ? */
332 
333           if ^kst.allow_256K_connect & ^kste.dirsw then     /* dir should never be 256K, but don't enforce it here */
334                if bin (aste.msl, 9) * 1024 >= sys_info$seg_size_256K then do;
335                     code = error_table_$big_seg;
336                     go to err0;
337                end;
338 
339 /* MAKE SURE THE REFERENCE IS NOT OUT OF BOUNDS */
340 
341           if offset >= bin (aste.msl, 9) * 1024 then do;    /* NEVER for MAKENOWN, remember */
342                code = error_table_$boundviol;
343                mc.resignal = "1"b;                          /* New signal code */
344                mc.fcode = bit (bin (out_of_bounds_sct_index, 17), 17);
345                go to err0;
346           end;
347 
348 
349 /* SEE IF SEG MUST BE MOVED TO ANOTHER PV. CALL SEG MOVER IF SO.
350    If this is MAKEKNOWN entry, then makeknown_ will either (horrors) get
351    a segment_mover error, or the process will just take a typical seg_fault */
352 
353           if aste.pack_ovfl then do;                        /* Out of PV */
354                call segment_mover (offset, astep, ep, segno, code);
355                if code = error_table_$log_vol_full then do;
356                     audit_eventflags = "0"b;
357                     addr (audit_eventflags) -> audit_event_flags.cc_1_10 = "1"b;
358                     call access_audit_$log_general ("seg_fault", level$get (), audit_eventflags, access_operations_$log_vol_full, "", code, null, 0, "");
359                end;
360                go to err1;                                  /* He unlocked the AST. Signal or retry */
361                                                             /* as code is or is not 0 */
362           end;
363 
364 
365 
366 /* DOES THE PROCESS ALREADY HAVE A TRAILER FOR THIS SEGMENT */
367 
368 MAKE_TRAILER:
369           pts = sst$pts (bin (aste.ptsi, 3));               /* get page table size actually awarded */
370 
371           call sdw_util_$get_address (addr (dseg$ (segno)), sdw_address);
372           if sdw_address = 0 then do;                       /* Add a trailer if not connected */
373                if rel (sst$tfreep) = ""b then
374                     call syserr (1, "seg_fault: trailer storage area exhausted");
375 
376                strp = sst$tfreep;                           /* Get pointer to first free trailer */
377                if str.fp = "0"b then call syserr (1, "seg_fault: trailer list trap"); /* TRAP */
378                sst$tfreep = ptr (strp, str.fp);             /* (setq tfreep (cdr tfreep)) */
379                str.segno = bit (bin (segno, 18), 18);       /* Fill in the new trailer */
380                str.dstep = pds$dstep;                       /* ditto */
381                str.fp, str.bp = "0"b;                       /* ditto */
382                call thread$lin (strp, aste.strp);           /* Thread the new trailer in */
383 
384                aste.gtus = aste.gtus & kste.tus;
385                aste.gtms = aste.gtms & kste.tms;
386                aste.explicit_deact_ok = aste.explicit_deact_ok & kste.explicit_deact_ok;
387           end;
388 
389 
390 /* PREPARE A COPY OF THE SDW FOR THIS SEGMENT */
391 
392           tsdw = get_ptrs_$given_astep (astep);             /* get sdw for this astep */
393           call sdw_util_$dissect (addr (tsdw), addr (sdwi));/* and prepare to modify it appropriately */
394 
395           if kste.dirsw then do;
396 
397 /* DIR */
398 
399                string (sdwi.access) = "1010"b;              /* access in ring 0 RW with rb of 0,0,0 */
400                sdwi.cache = "0"b;                           /* directories not allowed in cache due to
401                                                                use of abs-segs at deactivation time */
402           end;
403 
404 /* SEG */
405 
406           else do;
407                call sdw_util_$dissect (addr (dseg$ (segno)), addr (orig_sdwi)); /* Get info from the current SDW */
408                                                             /* This is where access & rings are stored betweentimes */
409 
410 /* COMPUTE ACCESS FIELD */
411 
412                string (sdwi.access) = string (orig_sdwi.access);
413                mode = substr (string (orig_sdwi.access), 1, 3);
414                string (sdwi.rings) = string (orig_sdwi.rings);
415                if branch_entrypt_sw then                    /* Set the entry bound */
416                     sdwi.gate_entry_bound = binary (branch_entrypt_bound) + 1;
417                                                             /* sdw_info is # of entrypoints, not max offset */
418 
419 /* COMPUTE ENCACHEABILITY OF SEGMENT - ASTEP IS VALID SINCE AST IS LOCKED */
420 
421                sdwi.cache = "1"b;                           /* assume encacheability at first */
422                                                             /* This will be ignored on the ADP */
423                if aste.any_access_on then                   /* if there is either one SDW or only
424                                                                read-permit SDW's */
425                     if substr (mode, 3, 1) |                /* and we are adding write access */
426                          aste.write_access_on then do;      /* or there is 1 write SDW */
427                                                             /* We mut take seg out of cache */
428                          call setfaults$cache (astep, "0"b);/* hit cache bits */
429                          sdwi.cache = "0"b;                 /* we will not encache either */
430                          aste.any_access_on = "0"b;         /* inhibit further checks */
431                     end;
432                     else ;                                  /* adding 1 more read-only SDW */
433                                                             /* any_access_on is off -
434                                                                could already be out of cache */
435                else if aste.write_access_on then            /* is out of cache */
436                     sdwi.cache = "0"b;
437                else aste.any_access_on = "1"b;
438 
439                aste.write_access_on = aste.write_access_on | substr (mode, 3, 1);
440                                                             /* indicate write access on */
441           end;
442 
443           sdwi.size = min (pts, bin (aste.msl, 9)) * 1024;  /* set bound */
444 
445 /* STORE THE COPY OF THE SDW IN THE REAL SDW - UNLOCK THE AST - UNLOCK THE PARENT IF REQUIRED */
446 
447           call sdw_util_$construct (addr (dseg$ (segno)), addr (sdwi)); /* Put the SDW back */
448 
449 err0:     call lock$unlock_ast;
450 
451 err1:     if lsw then call lock$dir_unlock (dp);            /* Unlock the directory */
452 
453 err:
454 
455           call usage_values (pw2, time2);                   /* get final value for seg fault metering */
456           sst$cpu_sf_time = sst$cpu_sf_time + time2 - time1;
457           sst$total_sf_pf = sst$total_sf_pf + pw2 - pw1;
458           sst$total_sf = sst$total_sf + 1;
459           pds$segment_faults = pds$segment_faults + 1;
460           if esw = MAKEKNOWN then do;
461                sst$seg_fault_calls = sst$seg_fault_calls + 1;
462                a_code = code;
463                return;
464           end;
465 
466           mc.errcode = code;
467 
468 finish:   call page$enter_data (segno, (seg_fault_end));    /* enter finish of seg_fault in trace */
469           return;
470 %page;
471 makeknown_activate: entry (a_kstep, a_code);
472 
473           call usage_values (pw1, time1);
474           esw = MAKEKNOWN;                                  /* our humble beginnings */
475           kstp = pds$kstp;
476           code = 0;
477           mcp = null;                                       /* trap bad reference */
478           scup = null;                                      /* ... */
479           ringno = 0;                                       /* why not ? */
480           offset = -1;                                      /* lower than lowest max seg length */
481           kstep = a_kstep;                                  /* do quick what takes normal entry sooo long */
482           ep = kste.entryp;
483           dp = ptr (ep, 0);
484           segno = kste.segno;
485           segptr = baseptr (segno);
486           go to COMMON;
487 %page; %include access_audit_eventflags;
488 %page; %include aim_template;
489 %page; %include aste;
490 %page; %include dc_find_dcls;
491 %page; %include dir_entry;
492 %page; %include dir_header;
493 %page; %include kst;
494 %page; %include lvt;
495 %page; %include mc;
496 %page; %include sdw_info;
497 %page; %include static_handlers;
498 %page; %include str;
499 %page; %include trace_types;
500 %page;
501 
502 /* BEGIN MESSAGE DOCUMENTATION
503 
504    Message:
505    seg_fault: illegal segfault on cpu X
506 
507    S:     $info
508 
509    T:     $run
510 
511    M:     The SCU data
512    stored by processor X
513    indicates that
514    a segment fault has occurred
515    but the SDW indicated by the SCU data
516    has no directed fault indicator.
517    $err
518    The system attempts to retry the faulting instruction.
519 
520    A:     Inform field engineering personnel.
521    If this message persists, attempt to delete the CPU.
522 
523 
524    Message:
525    seg_fault: trailer storage area exhausted
526 
527    S:     $crash
528 
529    T:     $run
530 
531    M:     There are no more free entries available in the system trailer
532    segment, str_seg. This may be indicative of software- or hardware-induced
533    damage to the SST or str_seg, or may be indicative of a number of
534    logged-in processes which is vastly too large. A more likely cause is
535    insufficiently large str_seg. The size of the str_seg can be changed
536    by the TBLS STR card in the config deck.
537    $err
538    $crashes
539 
540    A:     $recover
541    It may be necessary to increase the size of the str_seg by the TBLS STR
542    card in the config deck.
543    Be sure to get a dump.
544 
545 
546    Message:
547    seg_fault: trailer list trap
548 
549    S:     $crash
550 
551    T:     $run
552 
553    M:     An attempt was made to
554    set sst$tfreep to zero.
555    The supervisor checks for this
556    situation and crashes here
557    when one entry remains in the trailer segment
558    in order to trap an elusive bug
559    which used to cause "trailer storage area exhausted" crashes
560    when the trailer segment was not full.
561    $err
562    $crashes
563 
564    A:     $recover
565    Be sure to get a dump.
566 
567    END MESSAGE DOCUMENTATION */
568 
569      end seg_fault;