]> pd.if.org Git - mmurtl/blob - ossource/jobcode.asm
autocommit for file dated 1995-02-09 16:00:32
[mmurtl] / ossource / jobcode.asm
1 ;   MMURTL Operating System Source Code\r
2 ;   Copyright 1991,1992,1993,1994 Richard A. Burgess\r
3 ;   ALL RIGHTS RESERVED\r
4 ;   Version 1.0\r
5 \r
6 .DATA\r
7 .INCLUDE MOSEDF.INC\r
8 .INCLUDE JOB.INC\r
9 .INCLUDE TSS.INC\r
10 \r
11 PUBLIC pFreeJCB         DD 0                            ; Ptr to free Job Control Blocks\r
12 PUBLIC pJCBs            DD 0                            ; JCBs are in allocated memory\r
13 PUBLIC _nJCBLeft        DD nJCBs                        ; For Monitor stats\r
14 \r
15 EXTRN MonJCB  DB        ; Monitor JCB reference\r
16 EXTRN _BootDrive DD ; From Main.asm\r
17 \r
18 ;======= End data,Begin Code ==================\r
19 \r
20 .CODE\r
21 ;================================================================\r
22 ;InitNewJCB is used initially by the OS to fill in the first two\r
23 ;jobs (Monitor & Debugger)\r
24 ;\r
25 PUBLIC InitNewJCB:\r
26 ; INPUT :       EAX -- Ptr to JCB that is to be filled in\r
27 ;                       EBX -- Linear Ptr to Page Directory for Job\r
28 ;                       ESI -- pbJobName\r
29 ;                       ECX -- cbJobName\r
30 ;                       EDX -- Pointer to Job Virtual Video Buffer (all jobs have one!)\r
31 ;\r
32 ; OUTPUT :      JOB Number in EAX\r
33 ; USED :        EAX, EBX, ECX, EDX, EDI, ESI, EFlags\r
34 ; MODIFIES : JCB pointed to in EBX\r
35 ;\r
36 ; This fills in a JCB with new information.  This is used to initilaize\r
37 ; a new JCB during OS init and when a new Job is loaded and run.\r
38 ;\r
39                 MOV [EAX+JcbPD],EBX                     ;Put Ptr to PD into JCB\r
40                 MOV EDI, EAX                                    ;EDI points to JCB\r
41                 ADD EDI, sbJobName                              ;Now to JobName\r
42                 MOV BYTE PTR [EDI], CL                  ;size is filled in\r
43                 INC EDI                                                 ;first byte of name\r
44                 REP MOVSB                                               ;Move it in\r
45                 MOV [EAX+pVirtVid], EDX                 ;Video number is in JCB\r
46                 MOV DWORD PTR [EAX+nCols], 80   ;\r
47                 MOV DWORD PTR [EAX+nLines], 25  ;\r
48                 MOV DWORD PTR [EAX+NormAttr], 7 ;\r
49                 MOV EAX, [EAX+JobNum]\r
50                 RETN\r
51 \r
52 \r
53 ;=============================================================================\r
54 ; InitFreeJCB\r
55 ; INPUT :       EAX - Address of JCBs to be initialized\r
56 ;                       ECX - Count of JCBs\r
57 ;                       EDX - Size of JCBs\r
58 ; OUTPUT :      NONE\r
59 ; USED:         EAX,EBX,ECX,EDX,ESI EFLAGS\r
60 ; MODIFIES: pFreeJCB, pJCBs\r
61 ;\r
62 ; This routine will initialize the free pool of Job Control Blocks (JCBs).\r
63 ; EAX points to the first JCB,\r
64 ; ECX is count of JCBs,\r
65 ; EDX is size of each JCB.\r
66 ;\r
67 ; The pFreeJCB pointer is set to address the first element in rgJCBs.\r
68 ; Each element of rgJCBs is set to point to the next element of rgJCBs.\r
69 ; The last element of rgJCBs is set to point to nothing (NIL).\r
70 ; The JCBs are also sequentially numbered. We can't use it's position\r
71 ; in the array because some JCBs are static (Mon and Debugger), while\r
72 ; others (the ones we are initializing now) are dynamicly allocated.\r
73 ;\r
74 PUBLIC InitFreeJCB:\r
75                 MOV pFreeJCB,EAX        ;Set up OS pointer to list\r
76                 MOV pJCBs, EAX                  ;Set up global ptr to first JCB\r
77                 MOV EBX, 3                              ;1st number for Dynamic JCBs\r
78 JCB_Loop:\r
79             MOV ESI,EAX             ;EBX has pointer to current one\r
80                 ADD EAX,EDX             ;EAX points to next one\r
81                 MOV [ESI+NextJCB],EAX   ;Make current point to next\r
82                 MOV [ESI+JobNum], EBX   ;Number it\r
83                 INC EBX\r
84                 LOOP JCB_Loop           ;Go back till done\r
85                 MOV DWORD PTR [ESI+NextJCB], 0   ;Make last one NIL\r
86                 RETN                    ;\r
87 \r
88 ;================================================================\r
89 ; Allocate 4 pages (16384 bytes) for 32 Job Control Blocks (structures).\r
90 ; Then call InitFreeJCB\r
91 \r
92 PUBLIC InitDynamicJCBs:\r
93                 PUSH 4                                          ; 4 pages for 32 JCBs (16384 bytes)\r
94                 MOV EAX, OFFSET pJCBs           ; Returns ptr to allocated mem in pJCBs\r
95                 PUSH EAX                                        ;\r
96                 CALL FWORD PTR _AllocOSPage     ; Get 'em!\r
97 \r
98                 XOR EAX, EAX                            ; Clear allocated memory for JCBs\r
99                 MOV ECX, 4096                           ; (4*4096=16384 - DWORDS!)\r
100                 MOV EDI, pJCBs                          ; where to store 0s\r
101                 REP STOSD                                       ; Do it\r
102 \r
103                 MOV EAX, pJCBs                          ; Ptr to JCBs\r
104                 MOV ECX, nJCBs                          ; Count of Job Control Blocks\r
105                 MOV EDX, sJCB                           ; EDX is size of a JCB\r
106                 CALL InitFreeJCB                ; Init the array of JCBs\r
107                 RETN\r
108 \r
109 ;=============================================================================\r
110 \r
111 PUBLIC NewJCB:\r
112 ; INPUT : NONE\r
113 ; OUTPUT : EAX\r
114 ; REGISTERS : EAX,EBX,FLAGS\r
115 ; MODIFIES : pFreeJCB\r
116 ;\r
117 ; This routine will return to the caller a pointer to the next free jcb.\r
118 ; The data used in this algorithm is the free jcb pointer (pFreeJCB).\r
119 ; This routine will return in EAX register the address of the next free jcb.\r
120 ; If none exists, then EAX will contain NIL (0). This routine will also\r
121 ; update the value of pFreeJCB to point to the next "unused" JCB in\r
122 ; the free pool.\r
123 ;\r
124                 MOV EAX,pFreeJCB        ;Get OS pointer to JCBs\r
125                 CMP EAX,0                   ;IF pFreeJCB=NIL THEN Return;\r
126                 JE NewJCBDone           ;\r
127                 MOV EBX,[EAX+NextJCB]   ;Get pointer to next free one\r
128                 MOV pFreeJCB,EBX        ;Put it in OS pointer\r
129                 DEC DWORD PTR _nJCBLeft                 ;\r
130 NewJCBDone:\r
131             RETN                    ;\r
132 \r
133 ;=============================================================================\r
134 \r
135 PUBLIC DisposeJCB:\r
136 ; INPUT : EAX\r
137 ; OUTPUT : NONE\r
138 ; REGISTERS : EBX,FLAGS\r
139 ; MODIFIES : pFreeJCB\r
140 ;\r
141 ; This routine will place the jcb pointed to by EAX back into the free\r
142 ; pool of JCBs pointed to by (pFreeJCB) if EAX is not NIL.\r
143 ; This invalidates the JCB by placing 0 in JcbPD.\r
144 ;\r
145                 CMP EAX, 0                              ; If pJCBin = NIL THEN Return;\r
146                 JE DispJCBDone                          ;\r
147                 MOV DWORD PTR [EAX+JcbPD], 0    ;Invalidate JCB\r
148                 MOV EBX,pFreeJCB                        ;EBX has OS ptr to free list\r
149                 MOV [EAX+NextJCB],EBX                   ;Move it into newly freed JCB\r
150                 MOV pFreeJCB,EAX                        ;Move ptr to newly frred JCB to OS\r
151                 INC DWORD PTR _nJCBLeft                                 ;\r
152 DispJCBDone:\r
153             RETN                    ;\r
154 \r
155 ;============================================================\r
156 ;\r
157 ; GetpCrntJCB\r
158 ; Returns a pointer to the current Job Control Block in EAX.\r
159 ; This is based on which Task is executing.  All TSSs are\r
160 ; assigned to a Job.  A Job may have more than one Task.\r
161 ;\r
162 ; INPUT:        Nothing\r
163 ; OUTPUT:       EAX -- Linear Address of current JCB\r
164 ; USED:         EAX, EFlags\r
165 ;\r
166 PUBLIC GetpCrntJCB:\r
167                 MOV EAX, pRunTSS                ;Current Task State Segment\r
168                 MOV EAX, [EAX+TSS_pJCB] ;Pointer to JCB\r
169                 RETN\r
170 \r
171 ;============================================================\r
172 ;\r
173 ; GetCrntJobNum\r
174 ; Many OS functions deal with the Job number. The Job number\r
175 ; is a field in the JCB structure.\r
176 ; Returns the Job number for the currently executing task.\r
177 ; This is based on which Task is executing.  All TSSs are\r
178 ; assigned to a Job!  A Job may have more than one Task.\r
179 ;\r
180 ; INPUT:        Nothing\r
181 ; OUTPUT:       EAX -- Current Job Number\r
182 ; USED:         EAX, EFlags\r
183 ;\r
184 PUBLIC GetCrntJobNum:\r
185                 CALL GetpCrntJCB\r
186                 MOV EAX, [EAX+JobNum]                   ;Current JCB\r
187                 RETN\r
188 \r
189 ;============================================================\r
190 ;\r
191 ; GetpJCB\r
192 ; Returns a pointer to a Job Control Block identified by number\r
193 ; in EAX.  All TSSs are assigned to a Job.\r
194 ;\r
195 ; INPUT:        EAX -- Job Number of desired pJCB\r
196 ; OUTPUT:       EAX -- Linear Address of the JCB or 0 for invalid number\r
197 ; USED:         EAX, EFlags\r
198 ;\r
199 PUBLIC GetpJCB:\r
200                 PUSH EDX\r
201                 CMP EAX, 1\r
202                 JNE GetpJCB1\r
203                 MOV EAX, OFFSET MonJCB\r
204                 POP EDX\r
205                 RETN\r
206 GetpJCB1:\r
207                 CMP EAX, 2\r
208                 JNE GetpJCB2\r
209                 MOV EAX, OFFSET DbgJCB\r
210                 POP EDX\r
211                 RETN\r
212 GetpJCB2:\r
213                 CMP     EAX, nJCBs+2            ;Add in two static JCBs\r
214                 JLE GetpJCB3                    ;Within range of JCBs\r
215                 XOR EAX, EAX\r
216                 POP EDX\r
217                 RETN\r
218 GetpJCB3:\r
219                 SUB EAX, 3                              ;Take off static JCBs+1 (make it an offset)\r
220                 MOV EDX, sJCB\r
221                 MUL EDX                                 ;Times size of JCB\r
222                 ADD EAX, pJCBs                  ;Now points to desired JCB\r
223                 POP EDX\r
224                 RETN                                    ;\r
225 \r
226 ;============================================================\r
227 ;\r
228 ; GetJobNum\r
229 ; Many OS functions deal with the Job number. The Job number\r
230 ; is a field in the JCB structure.\r
231 ; Returns the Job number for the pJCB in EAX in EAX.\r
232 ;\r
233 ; INPUT:        EAX pJCB we want job number from.\r
234 ; OUTPUT:       EAX -- Current Job Number\r
235 ; USED:         EAX, EFlags\r
236 ;\r
237 PUBLIC GetJobNum:\r
238                 MOV EAX, [EAX+JobNum]                   ;Current JCB\r
239                 RETN\r
240 \r
241 ;============================================================\r
242 ;\r
243 ; AllocJCB  (NEAR)\r
244 ; This allocates a new JCB (from the pool).  This is a NEAR\r
245 ; call to support the public job management calls in high level\r
246 ; languages.\r
247 ;\r
248 ; Procedureal Interface :\r
249 ;\r
250 ;               AllocJCB(pdJobNumRet, ppJCBRet):ercType\r
251 ;\r
252 ;   pdJobNumRet is the number of the new JCB.\r
253 ;       pJCBRet is a pointer where you want the pointer to the new JCB is returned.\r
254 ;\r
255 ;   ErcNoMoreJCBs will be returned if no more JCBs are avaialble.\r
256 ;\r
257 ; pdJobNum                      EQU [EBP+12]\r
258 ; pJCBRet                       EQU [EBP+8]\r
259 \r
260 PUBLIC _AllocJCB:               ;\r
261                 PUSH EBP                ;\r
262                 MOV EBP,ESP             ;\r
263 \r
264                 CALL NewJCB                             ; Get a new JCB\r
265                 OR EAX, EAX                             ;\r
266                 JNZ SHORT AJCB01                ; We got one!\r
267                 MOV EAX, ErcNoMoreJCBs  ; Sorry, out of them!\r
268                 MOV ESP,EBP             ;\r
269                 POP EBP                 ;\r
270                 RETN 8                  ;\r
271 \r
272 AJCB01:\r
273                 MOV ESI, [EBP+8]                ;pJCBRet\r
274                 MOV [ESI], EAX\r
275                 MOV ESI, [EBP+12]               ;Job Num\r
276                 CALL GetJobNum                  ;\r
277                 MOV [ESI], EAX                  ;\r
278                 XOR EAX, EAX                    ;No error\r
279                 MOV ESP,EBP             ;\r
280                 POP EBP                 ;\r
281                 RETN 8                  ;\r
282 \r
283 ;============================================================\r
284 ;\r
285 ; DeAllocJCB  (NEAR)\r
286 ; This Deallocates a JCB (returns it to the pool).  This is a NEAR\r
287 ; call to support the public job management calls in high level\r
288 ; languages in the OS code.\r
289 ;\r
290 ; Procedureal Interface :\r
291 ;\r
292 ;               DeAllocJCB(pJCB):ercType\r
293 ;\r
294 ;       pJCB is a pointer the JCB to be deallocated.\r
295 ;\r
296 ;   ErcNoMoreJCBs will be returned if no more JCBs are avaialble.\r
297 ;\r
298 ; pJCB                  EQU [EBP+8]\r
299 \r
300 PUBLIC _DeAllocJCB:                     ;\r
301                 PUSH EBP                ;\r
302                 MOV EBP,ESP             ;\r
303 \r
304                 MOV EAX, [EBP+8]                ; pJCB\r
305                 CALL DisposeJCB                 ; Get a new JCB\r
306                 XOR EAX, EAX                    ;\r
307                 MOV ESP,EBP             ;\r
308                 POP EBP                 ;\r
309                 RETN 4                  ;\r
310 \r
311 ;============================================================\r
312 ;===== BEGIN PUBLIC FAR JOB CALLS ===========================\r
313 ;============================================================\r
314 ;\r
315 ; GetpJCB\r
316 ; This PUBLIC returns a pointer to the JCB for the JobNum\r
317 ; you specifiy.\r
318 ;\r
319 ; Procedureal Interface :\r
320 ;\r
321 ;               GetpJCB(dJobNum, pJCBRet):ercType\r
322 ;\r
323 ;   dJobNum is the number of the JCB you want.\r
324 ;       pJCBRet is a pointer where you want the JCB returned.\r
325 ;\r
326 ;   ErcBadJobNum will be returned if dJobNum is out of range\r
327 ;\r
328 ;   ErcBadJobNum will be returned if dJobNum is invalid\r
329 ;   or 0 will be returned with the data.\r
330 ;\r
331 ; dJobNum                       EQU [EBP+16]\r
332 ; pJCBRet                       EQU [EBP+12]\r
333 \r
334 PUBLIC __GetpJCB:               ;\r
335                 PUSH EBP                ;\r
336                 MOV EBP,ESP             ;\r
337 \r
338                 MOV EAX, [EBP+16]               ;Job Num\r
339                 OR EAX, EAX\r
340                 JZ GetpJcbBad                   ;0 is invalid\r
341                 CMP EAX, nJCBs + 2;             ;Dynamic + 2 static\r
342                 JBE GetpJcbOK\r
343 GetpJcbBad:\r
344                 MOV EAX, ErcBadJobNum   ;\r
345                 MOV ESP,EBP             ;\r
346                 POP EBP                 ;\r
347                 RETF 8                  ;\r
348 GetpJcbOk:\r
349                 CALL GetpJCB                    ;puts address of JCB in EAX\r
350                 MOV ESI, [EBP+12]               ;pJCBRet\r
351                 MOV [ESI], EAX\r
352                 CMP DWORD PTR [EAX+JcbPD], 0            ;Is this a valid JCB\r
353                 JNE GetpJCBOk1\r
354         MOV EAX, ErcInvalidJCB  ;JCB we are pointing to is unused\r
355                 MOV ESP,EBP             ;\r
356                 POP EBP                 ;\r
357                 RETF 8                  ;\r
358 GetpJcbOk1:\r
359                 XOR EAX, EAX\r
360                 MOV ESP,EBP             ;\r
361                 POP EBP                 ;\r
362                 RETF 8                  ;\r
363 \r
364 ;============================================================\r
365 ;\r
366 ; GetJobNum\r
367 ; This PUBLIC returns the number for the current Job. This is\r
368 ; the job that the task that called this belongs to.\r
369 ;\r
370 ; Procedureal Interface :\r
371 ;\r
372 ;               GetJobNum(pJobNumRet):ercType\r
373 ;\r
374 ;       pJCBRet is a pointer where you want the JCB returned.\r
375 ;\r
376 ; pJobNumRet    EQU [EBP+12]\r
377 \r
378 PUBLIC __GetJobNum:             ;\r
379                 PUSH EBP                ;\r
380                 MOV EBP,ESP             ;\r
381         CALL GetCrntJobNum              ;Leave jobnum in EAX\r
382                 MOV ESI, [EBP+12]               ;pJobNumRet\r
383                 MOV [ESI], EAX                  ;\r
384                 XOR EAX, EAX                    ;No Error\r
385                 POP EBP                 ;\r
386                 RETF 4                  ;\r
387 \r
388 \r
389 ;============================================================\r
390 ;\r
391 ; GetSystemDisk\r
392 ; This PUBLIC returns a single byte which represents the\r
393 ; disk that the system booted from. This is from the public\r
394 ; variable _BootDrive defined in Main.asm.\r
395 ; It return 0-n (which corresponds to A-x)\r
396 ; This code is here for lack of a better place.\r
397 ; It's really not a filesystem function either. And will\r
398 ; still be needed if a loadable filesystem is installed.\r
399 ;\r
400 ; Procedureal Interface :\r
401 ;\r
402 ;               GetSystemDisk(pSysDiskRet):ercType\r
403 ;\r
404 ;           pSysDiskRet is a pointer to a byte where\r
405 ;           the number representing the system disk is returned.\r
406 ;\r
407 ;  pSysDiskRet  EQU [EBP+12]\r
408 \r
409 PUBLIC __GetSystemDisk          ;\r
410                 PUSH EBP                ;\r
411                 MOV EBP,ESP             ;\r
412         MOV EAX, _BootDrive\r
413         AND EAX, 7Fh                    ;get rid of high bits\r
414                 MOV ESI, [EBP+12]               ;pJobNumRet\r
415                 MOV [ESI], AL                   ;\r
416                 XOR EAX, EAX                    ;No Error\r
417                 POP EBP                 ;\r
418                 RETF 4                  ;\r
419 \r
420 \r
421 ;================= MODULE END =================================\r