DataMuseum.dk

top - metrics - download

    Length: 9216 (0x2400)
    Types: TextFileVerbose
    Names: »tfs«

└─⟦da1afb338⟧ Bits:30008156 SW2020 - RC3502 - File system - Rel. 1.0
    └─⟦bcdac339f⟧ 
        └─⟦this⟧ »tfs« 

TextFileVerbose

process fs (var sysv: system_vector);
 
(**************************************************************)
(*                                                            *)
(* 861029 bb  pagebuffer split between dsm and the others     *)
(*            caused by buffer deadlock in RC-FS              *)
(* 870325 jkk wdd removed                                     *)
(*                                                            *)
(**************************************************************)

const
prio                  = stdpriority;
defaultstack          = 0;
fosm_stack            = 300 + max_fosm_ticket;
bfs_stack             = 300 + max_dsm + max_fosm * 5;
lfs_stack             = 375 + max_fosm_ticket * max_fosm * 5;
sai_start             = 12;
sai_set_event_mask    = 24;
adam_create_semaphore = 8;
writecode             = 2;
message               = 7;
no_of_opbuffers       = 1;
no_of_incarnations    = 3 (* lfs + bfs + fsevent*) 
+ max_fosm +  max_dsm + max_sai201;

first_data_byte       = 6 + fs_pageheader_size;
last_data_byte        = first_data_byte + fs_pagesize - 1;


fsevent_name = 'fsevent';
lfs_name     = 'lfs';
bfs_name     = 'bfs';
fosm_name    = 'fosm';
dsm_name     = 'dsm';
fssem_name   = 'fssem';
sai_name     = 'sai';

type

adamtype =
record
procname : alfa;
incname  : alfa;
aux      : integer;
end;

sai_range = 1..max_sai201;
dsm_range = 1..max_dsm;

sai_event = ( x,?,?,?,
sai_message_event,
sai_interrupt_event,
sai_phase_event,
sai_error_event,
?, ?, ?, ?, ?, ?, ?, ? );

sai_event_mask_type = set of sai_event;

var

z             : zone;
r             : reference;
shadows       : array (1..no_of_incarnations) of shadow;
next_shadow   : 1..no_of_incarnations+1 := 1;
procname      ,
incname       ,
s_name        : alfa;
sai201_number : array (dsm_range) of 0..max_sai201;
page_pool     : pool 2 of fs_pagebuffer_type;
 (* one for DSM and one for the others *)
start_pool    : pool 1 of adamtype;
oppool        : pool no_of_opbuffers of opbuffer;
cursem        ,
bfs_sem       , 
page_sem      ,
dsm_page_sem  ,
fstestsem     ,
fseventsem    : semaphore;
saimainsem    ,
saisubsem     : array (sai_range) of semaphore;
dsm_sem       : array (dsm_range) of semaphore;
saimainsemp   ,
saisubsemp    : array (sai_range) of ^ semaphore;
lfssem        ,
fstestsemp    ,
fseventsemp   : ^ semaphore;

function madd (a, b : integer) : integer;
external;

function fs_nameindex (var name : ! alfa; no, pos : integer) : alfa;
external;

process lfs
(var input_sem, bfs_sem, page_sem: semaphore;
max_fosm, max_fosm_ticket : integer);
external;

process bfs
(var input_sem, page_sem: semaphore;
max_dsm, max_fosm, max_fosm_ticket : integer);
external;

process fosm
(var bfs_sem, page_sem: semaphore;
max_fosm_ticket, id : integer);
external;

process dsm
(var input_sem, device_sem, page_sem, testsem: semaphore; cu, lun: integer);
external;

process saidriver(var mainsem, subsem, testsem: !^semaphore);
external;
 
process fsevent(var eventsem, emptysem, operator: !^semaphore);
external;

procedure increment_next_shadow;
begin
next_shadow := succ (next_shadow);
end; (* increment_next_shadow *)

function truncate (a : alfa) : alfa;
var
i : integer;
begin
i := alfalength;
while a(i) = sp do 
i := i-1;
if i <> alfalength then 
a(i+1) := "#";
truncate := a;
end; (* truncate *)

procedure ct (i, j, textno : integer);
const
max        = 2;
length     = 43;
top        = (max + 1) * length;
max_textno = 6;
type
string   = array (0..length-1) of char;
table_t  = array (1..max) of string;
index_t  = array (1..max_textno) of byte;
const
table =
table_t (' disc table overlap#0 name_semaphore#1 adam',  (* 1 *)
         '_create_semaphore#1 link#2 create#3 start#3'); (* 2 *)
index =
index_t (1*length + 0,  (* overlap *)
         1*length + 21, (* name_semaphore *)
         1*length + 38, (* adam_create_semaphore *)
         2*length + 19, (* link  *)
         2*length + 26, (* create *)
         2*length + 35); (* start *)
var
ch   : char;
step : integer;
name : alfa;
begin
if i <> 0 then
begin
outfill (z, "*", 3);
step := index (textno);
repeat
ch := table (step div length, step mod length);
if ch = "#" then
begin
outchar (z, sp);
ch := table ((step+1) div length, (step+1) mod length);
case ord (ch) - ord ("0") of
0: ;
1: begin
name := truncate (s_name);
outalfa (z, name);
end;
2: begin
name := truncate (procname);
outalfa (z, name);
end;
3: begin
name := truncate (incname);
outalfa (z, name);
end;
end;
step := top;
end
else
begin
outchar (z, ch);
step := step + 1;
end;
until step = top;
outalfa (z, ', result = #');
outinteger (z, i, 1);
if j >= 0 then
begin
outchar (z, ",");
outchar (z, sp );
outinteger (z, j, 1);
end;
outnl (z);
end;
end; (* check_and_trace *)

procedure check_disc_table;
var
errors             : integer := 0;
next_sai201_number : integer := 0; (* undefined *)
i, j               : integer;
entry_i            ,
entry_j            : disc_address;
begin
for i := 1 to max_dsm do
sai201_number (i) := next_sai201_number; (* undefined *)
for i := 1 to max_dsm do
begin
entry_i := disc_table (i);
if sai201_number (i) = 0 then
begin
next_sai201_number := next_sai201_number + 1;
sai201_number (i)  := next_sai201_number;
end;
for j := i+1 to max_dsm do
begin
entry_j := disc_table (j);
(* no two entries must match completely *)
if entry_i = entry_j then
errors := errors + 1;
(* the couple sai_no and sai_level must be unique *)
with entry_i do
if sai201_level = entry_j.sai201_level then
sai201_number (j) := sai201_number (i);
end;
end;
ct (errors, -1, 1);
end; (* check_disc_table *)

procedure run (
proc_name, inc_name : alfa;
proces : processrec;
stack : integer);
const
allready_linked = 6;
var
i : integer;
begin
procname := proc_name;
i := link (procname, proces.processref^);
if i <> allready_linked then
ct (i, -1, 4);
incname := inc_name;
ct (create (incname, proces, shadows (next_shadow), stack), -1, 5);
if not nil (shadows (next_shadow)) then
start (shadows (next_shadow), prio);
increment_next_shadow;
end; (* run *)

procedure run_sai (no : integer);
var
sai201no : integer;
begin
sai201no := sai201_number (no);
if nil (saimainsemp (sai201no)) then
begin
(* sai201 number sai201no is not started *)
saimainsemp (sai201no) := ref(saimainsem (sai201no));
saisubsemp  (sai201no) := ref(saisubsem  (sai201no));
run ('saidriver', fs_nameindex (sai_name, sai201no, 4),
saidriver (saimainsemp(sai201no), saisubsemp(sai201no), fstestsemp),
defaultstack);

if not nil (shadows (pred (next_shadow))) then
begin
alloc (r, start_pool, cursem);
r^.u1 := sai_start;
r^.u3 := disc_table (no).sai201_level;
signal (r, saimainsemp (sai201no)^);
wait (r, cursem);
ct (r^.u2, r^.u3, 6);
if r^.u2 = 0 then
begin
(* set error event bit in sai *)
lock r as p :
record
f,l,n        : integer;
mask1, mask2 : sai_event_mask_type 
end do
with p do
begin
f     := 6;
mask1 := (.sai_error_event.);
mask2 := mask1;
end;
r^.u1 := sai_set_event_mask;
signal (r, saimainsemp (sai201no)^);
wait (r, cursem);
end;
release (r);
end;
end;
end; (* runsai *)

procedure run_dsm;
var
  step, sai201_no: integer;
begin
for step:= 1 to max_dsm do
begin
sai201_no:= sai201_number(step);
run_sai (step);
s_name := fs_nameindex (dsm_name, step, 4);
ct (name_semaphore (dsm_sem (step), s_name), -1, 2);
run (dsm_name, s_name,
dsm (dsm_sem (step), saimainsem (sai201_no), dsm_page_sem, fstestsem,
     disc_table(step).wdd_cu, disc_table(step).wdd_lun ),
defaultstack);
end;
end; (* run_dsm *)

procedure run_fosm;
var
step : integer;
begin
for step := 1 to max_fosm do
run (fosm_name, fs_nameindex (fosm_name, step, 5),
fosm (bfs_sem, page_sem, max_fosm_ticket, step),
fosm_stack);
end; (* run_fosm *)

procedure prepare_buffers (no : integer; var answer : semaphore);
var
step : integer;
begin
for step := 1 to no do
begin
alloc (r, page_pool, answer);
lock r as p : fs_pagebuffer_type do
begin
p.first := first_data_byte;
p.last  := last_data_byte;
end;
return (r);
end;
end; (* prepare_buffers *)


begin  (* main program of file system master *)

openopzone (z, sysv(operatorsem),ref(z.free), no_of_opbuffers, oppool,
writecode, message, 0, 0);

check_disc_table;

fstestsemp  := ref (fstestsem);
fseventsemp := ref (fseventsem);

(* request adam to create a name_semaphore with name 'fssem' *)
alloc(r,start_pool,cursem);
s_name := fssem_name;
lock r as a : alfa do a := s_name;
r^.u1 := adam_create_semaphore;
signal (r, sysv(adamsem)^);
wait (r, cursem);
ct (r^.u2, -1, 3);
release (r);
(* get the addres of the created semaphore *)
lfssem := search_semaphore (s_name);

(* prepare common page buffer resource for rc_fs nucleus *)
prepare_buffers (1, page_sem);
prepare_buffers (1, dsm_page_sem);

run_dsm;

run (fsevent_name, fsevent_name,
fsevent (fseventsemp, fstestsemp, sysv (operatorsem)),
defaultstack);

run (lfs_name, lfs_name,
lfs (lfssem^, bfs_sem, page_sem, max_fosm, max_fosm_ticket),
lfs_stack);

run (bfs_name, bfs_name,
bfs (bfs_sem, page_sem, max_dsm, max_fosm, max_fosm_ticket),
bfs_stack);

run_fosm;

end;
.
«eof»