![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to as1.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / i286|
Return to as1.s CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / i286 |
1.1 root 1: / $Header: /kernel/kersrc/i286/RCS/as1.s,v 1.1 92/07/17 15:21:11 bin Exp Locker: bin $
2:
3: / (lgl-
4: / The information contained herein is a trade secret of Mark Williams
5: / Company, and is confidential information. It is provided under a
6: / license agreement, and may be copied or disclosed only under the
7: / terms of that agreement. Any reproduction or disclosure of this
8: / material without the express written authorization of Mark Williams
9: / Company or persuant to the license agreement is unlawful.
10: /
11: / COHERENT Version 2.3.37
12: / Copyright (c) 1982, 1983, 1984.
13: / An unpublished work by Mark Williams Company, Chicago.
14: / All rights reserved.
15: / -lgl)
16: ////////
17: /
18: / Machine language assist for
19: / 8086/8088 Coherent. This contains the parts
20: / that are common to all machines.
21: /
22: / Note that several of the following constants can be invalidated
23: / by changing the contents of ../h/*proc.h among others,
24: / or by changing the number of automatic variables in the functions
25: / called on the paths leading to consave or conrest. Tread with caution.
26: /
27: / $Log: as1.s,v $
28: / Revision 1.1 92/07/17 15:21:11 bin
29: / Initial revision
30: /
31: / Revision 1.2 91/06/20 14:07:20 hal
32: / I'm not sure what changed here.
33:
34: / Revision 1.3 88/08/05 08:32:09 src
35: / Kludges for AMD 286 bug have been removed.
36: /
37: / Revision 1.2 88/06/24 16:02:08 src
38: / Bug: inb/outb did not work properly in split stack/data operation.
39: / Fix: inb/outb now explicitly reference the stack segment.
40: /
41: / Revision 1.1 88/03/24 17:39:08 src
42: / Initial revision
43: /
44: / 88/03/10 Allan Cornish /usr/src/sys/i8086/src/as1.s
45: / Numerous temporary fixes due to AMD 286 chip being buggy in protected mode.
46: / These partial fixes will be removed once all CPU's are replaced.
47: /
48: / 88/03/04 Allan Cornish /usr/src/sys/i8086/src/as1.s
49: / tmpcs*/tmpds* temporary variables renamed to sav_*.
50: / usave/conrest/etc now handle odd byte alignment on stack.
51: / envrest/conrest now do interrupt return as last instruction.
52: /
53: / 87/12/21 Allan Cornish /usr/src/sys/i8086/src/as1.s
54: / fclear(f,n) function added.
55: /
56: / 87/12/04 Allan Cornish /usr/src/sys/i8086/src/as1.s
57: / kfcopy(k,f,n) and fkcopy(f,k,n) routines added.
58: /
59: / 87/12/03 Allan Cornish /usr/src/sys/i8086/src/as1.s
60: / popf replaced by 'push cs; mov ax,$0f; push ax; iret; 0:' due to popf int bug.
61: /
62: / 87/11/05 Allan Cornish /usr/src/sys/i8086/src/as1.s
63: / slrcopy/srlcopy/sclear renamed plrcopy/prlcopy/pclear and moved to ibm*/as2.s
64: /
65: / 87/10/27 Allan Cornish /usr/src/sys/i8086/src/as1.s
66: / System stack/data segments now setup in ibm/ibm_at as2.s
67: /
68: / 87/02/06 Allan Cornish
69: / Functions ffword and sfword added to fetch and set far memory.
70: /
71: ////////
72:
73: UPASIZE = 1024 / Size of uproc and stack
74: USIZE = 0x114 / sizeof(UPROC)
75: USZ1 = 140 / Word count for usave, uproc size
76: UMCSP = 0x06 / offset of sp in u_syscon
77: EFAULT = 14 / Bad argument
78: PFLAGS = 0x22 / Offset into PROC.
79: PFKERN = 0x80 / Kernel process flag bit.
80: SIDEV = 0x40 / Device interrupt trap code.
81:
82: ////////
83: /
84: / After performing machine specific
85: / trap vector setup, the startup code jumps
86: / here. The DS maps the vectors.
87: /
88: ////////
89:
90: .globl start
91:
92: start:
93: / Call the machine setup code.
94: / Call Coherent main.
95: / On return, send control off to the user
96: / at its entry point.
97:
98: mov sp, $u_+UPASIZE-32 / Stack pointer for init
99: call i8086_ / Do it.
100: sti / Interrupts on, and
101: call main_ / call Coherent mainline.
102: cli / Interrupts off.
103: incb depth_ / Set stack depth to user.
104: sub ax, ax / User mode IP.
105: mov bx, uds_ / User mode DS, ES, SS
106: mov cx, ucs_ / User mode CS.
107: mov dx, $0x0200 / User mode FL.
108:
109: mov ds, bx / Map data segment
110: mov es, bx / Map extra segment
111: mov ss, bx / Map stack segment
112:
113: mov sp, $sb-aicodep_ / User's stack
114: push dx / Flags
115: push cx / CS
116: push ax / IP
117: iret / Go to user state.
118:
119: ////////
120: /
121: / Trap and interrupt save.
122: / These routines will be very familiar to any
123: / RSX-11M hackers out there; it is just the ever
124: / common co-routine call. The caller is called back,
125: / with "bx" pointing to the saved "ax" on the stack,
126: / with interrupts enabled. The called routine must
127: / set 16(bx), which was initially the call back address,
128: / to something non zero in the high byte if it does
129: / not want an EOI sent to the 8259.
130: /
131: / ttsave, tksave, tisave, and tusave could be folded into a single routine
132: / with many tests and branches, but the frequency of passage through
133: / this code warrants a minimally branched execution, and special casing
134: / the interrupted context allows minimal memory references.
135: /
136: ////////
137:
138: .globl tsave
139:
140: tsave: / What level of interrupt ?
141: push ds / Save current data base
142: mov ds, cs:cds / remap to system data space.
143: pop sav_ds /
144: decb depth_ / Adjust stack depth.
145: je tkusave / If e, stack switch may be needed.
146: ttsave: / Interrupted within interrupt
147: cmp sp,$u_+USIZE+50 / Check for stack
148: jbe tabort / overflow
149: push ss / Fake save ss
150: push sp / Fake save sp
151: push sav_ds / Save ds
152: push bx / Save bx
153:
154: sti / More interrupts ok
155:
156: push ax / Save ax
157: push dx / and remainder
158: push cx / of machine
159: push es / state
160: mov ax,ds / Map es
161: mov es,ax / to system ds
162: mov bx,sp / Load index
163: icall 16(bx) / and call the caller
164: mov bx,sp / Load index
165: mov ax,16(bx) / fetch trap type
166: cmpb ah, $SIDEV / see if eoi
167: jne ttkdone / can be skipped
168:
169: cli / don't let eoi swamp us
170: call eoi / Dismiss interrupt
171: ttkdone: / Common ttsave/tksave finish
172: pop es / Restore
173: pop cx / the
174: pop dx / machine state
175: pop ax / state
176:
177: cli / No more interrupts
178:
179: incb depth_ / Reset stack level
180: pop bx / Restore the
181: pop ds / last parts
182: add sp,$6 / forget ss, sp, and ra.
183: iret / Done.
184:
185: tabort: / Uarea stack overflowed
186: add sp,$300 / Make room for death.
187: mov ax,$oops / Load
188: push ax / message
189: call panic_ / and die.
190:
191: tkusave: / Kernel or user process interrupted
192: mov sav_bx,bx / Save bx in temp
193: mov bx,cprocp_ / Load proc pointer
194: test PFLAGS(bx),$PFKERN / Kernel process ?
195: je tusave / Sorry, go do it all.
196: tksave: / Kernel process interrupted
197: push ss / Fake save ss
198: push sp / Fake save sp
199: push sav_ds / Save ds
200: push sav_bx / Save bx
201:
202: sti / More interrupts ok.
203:
204: cmp bx,iprocp_ / Is this the idle process ?
205: je tisave / Yes, very easy
206: push ax / Save the
207: push dx / rest of
208: push cx / the machine
209: push es / state
210: mov ax,ds / And map
211: mov es,ax / extra to system data
212: mov bx,sp / Load index
213: icall 16(bx) / and call the caller back.
214: mov bx,sp / Load index
215: mov ax,16(bx) / and pull trap type.
216: cmpb ah, $SIDEV / Machine trap?
217: jne ttkdone / Yes, skip dismiss
218: call eoi / Dismiss interrupt
219: jmp ttkdone / Finish above
220:
221: tisave: / Idle process interrupted, nothing to save
222: sub sp,$8 / Push junk
223: mov bx,sp / Load index
224: icall 16(bx) / and call the caller back.
225: mov bx,sp / Load index
226: mov ax,16(bx) / and pull trap type.
227: cmpb ah, $SIDEV / Machine trap ?
228: jne 0f / Yes, skip dismiss.
229: call eoi / Dismiss interrupt
230: 0:
231: call stand_ / Clock, part 2
232: cli / No more interrupts
233:
234: add sp,$18 / Pop everything
235: incb depth_ / Reset level
236: iret / Done
237:
238: tusave: / User process interrupted
239: mov bx, $u_+UPASIZE / Get base of user area and
240: pop -8(bx) / pop the data that
241: pop -6(bx) / was pushed onto the user
242: pop -4(bx) / stack onto the new
243: pop -2(bx) / system stack.
244: mov sav_ss, ss / Save the old stack segment
245: mov sav_sp, sp / and stack pointer, then
246: mov ss, sds_ / switch onto the
247: lea sp, -8(bx) / new stack in the user area.
248: push sav_ss / Push old ss
249: push sav_sp / Push old sp
250: push sav_ds / Push old ds and
251: push sav_bx / push old bx.
252:
253: sti / Allow more interrupts.
254:
255: push ax / Save the
256: push dx / remainder of
257: push cx / the machine
258: push es / state.
259: mov ax, ds / Map extra
260: mov es, ax / segment to system data.
261: mov bx, sp / Load up an index into the stack
262: icall 16(bx) / and call the caller back.
263: mov bx, sp / Load up stack index.
264: mov ax, 16(bx) / Pull trap type.
265: cmpb ah, $SIDEV / Is this a machine trap ?
266: jne 0f / Yes, skip dismiss.
267: call eoi / Do the dismiss.
268: 0: mov bx, cprocp_ / Have we become kernel?
269: test PFLAGS(bx), $PFKERN / If so, do kernel return.
270: jne ttkdone /
271:
272: call stand_ / Clock, part 2
273: pop es / Restore the
274: pop cx / easy part of the
275: pop dx / machine
276: pop ax / state.
277:
278: cli / Interrupts off.
279:
280: incb depth_ / Adjust stack depth and
281: pop sav_bx / Pop off the old bx and
282: pop sav_ds / ds into statics, then
283: pop bx / map DS:BX over top of what
284: pop ds / was the previous stack.
285: add sp, $2 / Pop ra.
286: pop -6(bx) / Copy the IP,
287: pop -4(bx) / the CS and the old
288: pop -2(bx) / FW onto the user's stack, then
289: lea sp, -6(bx) / switch back
290: mov bx, ds / to the
291: mov ss, bx / user's stack.
292: mov ds, cs:cds /
293: mov bx, sav_bx / Reload the bx and the
294: mov ds, sav_ds / ds, then
295: iret / exit interrupt.
296:
297: ////////
298: /
299: / This dummy routine is put in vector
300: / table slots that are unused. All it does is
301: / return to the caller.
302: /
303: ////////
304:
305: .globl vret_
306:
307: vret_: ret
308:
309: ////////
310: /
311: / Fetch a word from the user's data space.
312: /
313: / getuwd(u)
314: / char *u;
315: /
316: ////////
317:
318: .globl getuwd_
319: .globl getupd_
320:
321: getuwd_:
322: getupd_:
323: mov bx,sp / Base pointer
324: mov bx,2(bx) / Argument
325: cmp bx,udl_ / In range?
326: ja kuerr / No
327:
328: push es / Save extra map and
329: mov es, uds_ / remap over the user's data.
330: mov ax,es:(bx) / Get word
331: pop es / Restore es.
332: ret / Return
333:
334: ////////
335: /
336: / Fetch a word from the user's code space.
337: /
338: / getuwi(u)
339: / char *u;
340: /
341: ////////
342:
343: .globl getuwi_
344:
345: getuwi_:
346: mov bx,sp / Base pointer
347: mov bx,2(bx) / Argument
348: cmp bx,ucl_ / In range?
349: ja kuerr / No
350:
351: push es / Save extra.
352: mov es,ucs_ / Users data segment
353: mov ax,es:(bx) / Get word
354: pop es / Restore extra.
355: ret / Return
356:
357: ////////
358: /
359: / Fetch a byte from the user's data space.
360: /
361: / getubd(u)
362: / char *u;
363: /
364: ////////
365:
366: .globl getubd_
367:
368: getubd_:
369: mov bx,sp / Base pointer
370: mov bx,2(bx) / Argument
371: cmp bx,udl_ / In range?
372: ja kuerr / No
373:
374: push es / Save es.
375: mov es,uds_ / Users data segment
376: movb al,es:(bx) / Get word
377: pop es / Restore es.
378: subb ah,ah / Clear upper half
379: ret / Return
380:
381: ////////
382: /
383: / Store a word into the user's data space.
384: /
385: / putuwd(u, w)
386: / char *u;
387: / int w;
388: /
389: ////////
390:
391: .globl putuwd_
392:
393: putuwd_:
394: mov bx,sp / Base pointer
395: mov ax,4(bx) / New value
396: mov bx,2(bx) / Argument
397: cmp bx,udl_ / In range?
398: ja kuerr / No
399:
400: push es / Save es.
401: mov es,uds_ / Users data segment
402: mov es:(bx),ax / Set value
403: pop es / Restore es.
404: sub ax,ax / Succesful
405: ret / Return
406:
407: ////////
408: /
409: / Store a word into the user's code space.
410: /
411: / putuwi(u, w)
412: / char *u;
413: / int w;
414: /
415: ////////
416:
417: .globl putuwi_
418:
419: putuwi_:
420: mov bx,sp / Base pointer
421: mov ax,4(bx) / New value
422: mov bx,2(bx) / Argument
423: cmp bx,ucl_ / In range?
424: ja kuerr / No
425:
426: push ucs_ / Get physical address.
427: sub ax, ax / DX:AX = phy = vtop( ucs:0 );
428: push ax /
429: call vtop_ /
430: add sp, $4 /
431: /
432: sub bx, bx / Get writable virtual address.
433: push bx / DX:AX = fp = ptov( phy, ucl );
434: push ucl_ /
435: push dx /
436: push ax /
437: call ptov_ /
438: add sp, $8 /
439: /
440: mov bx, sp /
441: mov ax, 4(bx) / New value
442: mov bx, 2(bx) / Argument
443: push es / Save ES
444: mov es, dx / Users (writable) code segment
445: mov es:(bx), ax / Set value
446: pop es / Restore es
447: /
448: push dx / Release writable virtual address.
449: sub ax, ax / vrelse( fp );
450: push ax /
451: call vrelse_ /
452: add sp, $4 /
453: /
454: sub ax,ax / Succesful
455: ret / Return
456:
457: ////////
458: /
459: / Store a byte into the user's data space.
460: /
461: / putubd(u, w)
462: / char *u;
463: / int w;
464: /
465: ////////
466:
467: .globl putubd_
468:
469: putubd_:
470: mov bx,sp / Base pointer
471: mov ax,4(bx) / New value
472: mov bx,2(bx) / Argument
473: cmp bx,udl_ / In range?
474: ja kuerr / No
475:
476: push es / Save es.
477: mov es,uds_ / Users data segment
478: movb es:(bx),al / Set value
479: pop es / Restore es.
480: sub ax,ax / Succesful
481: ret / Return
482:
483: ////////
484: /
485: / Block transfer "n" bytes from location
486: / "k" in the system map to location "u" in the
487: / user's data space. Return the number of bytes
488: / transferred.
489: /
490: / kucopy(k, u, n)
491: / char *k;
492: / char *u;
493: / int n;
494: /
495: ////////
496:
497: .globl kucopy_
498:
499: kucopy_:
500: mov bx,sp / Base pointer
501: mov ax,4(bx) / User address
502: dec ax / Don't wrap too soon
503: add ax,6(bx) / Add count
504: jc kuerr / Out of bounds
505: cmp ax,udl_ / In range?
506: ja kuerr / No
507:
508: push si / Save si
509: push di / Save di
510: push es / Save es.
511:
512: mov si,2(bx) / Kernel address
513: mov di,4(bx) / User address
514: mov cx,6(bx) / Count
515: mov ax,cx / Move here to return
516: mov es,uds_ / Map extra segment to user
517:
518: cld / Auto increment
519: clc /
520: rcr cx, $1 / Calculate Word count
521: rep /
522: movsw / Move words.
523: rcl cx, $1
524: rep
525: movsb / Move odd byte.
526:
527: pop es / Restore es.
528: pop di / Restore di
529: pop si / Restore si
530: ret / Return
531:
532: ////////
533: /
534: / Block copy "n" bytes from location "u" in
535: / the user data space to location "k" in the system
536: / data space. Return the actual number of bytes
537: / moved.
538: /
539: / ukcopy(u, k, n)
540: / char *u;
541: / char *k;
542: / int n;
543: /
544: ////////
545:
546: .globl ukcopy_
547:
548: ukcopy_:
549: mov bx,sp / Base pointer
550: mov ax,2(bx) / User address
551: dec ax / Don't wrap too soon
552: add ax,6(bx) / Count
553: jc kuerr / Out of bounds
554: cmp ax,udl_ / In range?
555: ja kuerr / No
556:
557: push si / Save si
558: push di / Save di
559: push ds / Save ds
560:
561: mov si,2(bx) / User address
562: mov di,4(bx) / Kernel address
563: mov cx,6(bx) / Count
564: mov ax,cx / Move here to return
565: mov bx, uds_ / Map data segment
566: mov ds, bx / avoiding bug in 8088.
567:
568: cld / Auto increment
569: clc /
570: rcr cx, $1 / Word count, odd byte in carry.
571: rep /
572: movsw / Move words.
573: rcl cx, $1
574: rep / Move odd byte.
575: movsb
576:
577: pop ds / Restore ds
578: pop di / Restore di
579: pop si / Restore si
580: ret / Return
581:
582: ////////
583: /
584: / All of the above copy routines jump to
585: / "kuerr", with the stack untouched, if they detect
586: / a bounds error on a user address.
587: /
588: ////////
589:
590: kuerr:
591: mov bx,$u_ / Pointer to user area
592: movb (bx),$EFAULT / Bad parameter error
593: sub ax,ax / Didn't copy anything
594: ret / Return
595:
596: ////////
597: /
598: / sfbyte( fp, b ) -- set far byte
599: / int far * fp;
600: / int b;
601: /
602: ////////
603:
604: .globl sfbyte_
605:
606: sfbyte_:push es / sfbyte( fp, b )
607: push di / register int far * fp; /* ES:DI */
608: push bp / register int b; /* AX */
609: mov bp, sp / {
610: les di, 8(bp) /
611: mov ax, 12(bp) /
612: /
613: movb es:(di), al / *fp = b;
614: /
615: pop bp / }
616: pop di
617: pop es
618: ret
619:
620: ////////
621: /
622: / sfword( fp, w ) -- set far word
623: / int far * fp;
624: / int w;
625: /
626: ////////
627:
628: .globl sfword_
629:
630: sfword_:push es / sfword( fp, w )
631: push di / register int far * fp; /* ES:DI */
632: push bp / register int w; /* AX */
633: mov bp, sp / {
634: les di, 8(bp) /
635: mov ax, 12(bp) /
636: /
637: mov es:(di), ax / *fp = w;
638: /
639: pop bp / }
640: pop di
641: pop es
642: ret
643:
644: ////////
645: /
646: / ffbyte( fp ) -- fetch far byte
647: / int far * fp;
648: /
649: ////////
650:
651: .globl ffbyte_
652:
653: ffbyte_:push es / ffbyte( fp )
654: push di / register int far * fp; /* ES:DI */
655: push bp / {
656: mov bp, sp /
657: les di, 8(bp) /
658: /
659: sub ax, ax /
660: movb al, es:(di) / return *fp;
661: /
662: pop bp / }
663: pop di
664: pop es
665: ret
666:
667: ////////
668: /
669: / ffword( fp ) -- fetch far word
670: / int far * fp;
671: /
672: ////////
673:
674: .globl ffword_
675:
676: ffword_:push es / ffword( fp )
677: push di / register int far * fp; /* ES:DI */
678: push bp / {
679: mov bp, sp /
680: les di, 8(bp) /
681: /
682: mov ax, es:(di) / return *fp;
683: /
684: pop bp / }
685: pop di
686: pop es
687: ret
688:
689: ////////
690: /
691: / Block transfer "n" bytes from location
692: / "k" in the system map to location "f"
693: / in the virtual address space.
694: / Return the number of bytes / transferred.
695: /
696: / kfcopy(k, f, n)
697: / char *k;
698: / faddr_t f;
699: / int n;
700: /
701: ////////
702:
703: .globl kfcopy_
704:
705: kfcopy_:
706: push si / Save si
707: push di / Save di
708: push bp / Save bp
709: mov bp, sp / Base pointer
710: push es / Save es.
711:
712: mov si, 8(bp) / Kernel address
713: les di, 10(bp) / Far address
714: mov cx, 14(bp) / Count
715: mov ax, cx / Move here to return
716:
717: cld / Auto increment
718: clc /
719: rcr cx, $1 / Calculate Word count.
720: rep /
721: movsw / Move words.
722: rcl cx, $1 /
723: rep /
724: movsb / Move odd byte.
725: /
726: pop es / Restore es.
727: pop bp / Restore bp.
728: pop di / Restore di
729: pop si / Restore si
730: ret / Return
731:
732: ////////
733: /
734: / Block transfer "n" bytes from location
735: / "f" in the virtual addres sspace to
736: / location "f" in the system map.
737: / Return the number of bytes / transferred.
738: /
739: / fkcopy(f, k, n)
740: / faddr_t f;
741: / char *k;
742: / int n;
743: /
744: ////////
745:
746: .globl fkcopy_
747:
748: fkcopy_:
749: push si / Save si
750: push di / Save di
751: push bp / Save bp
752: mov bp, sp / Base pointer
753: push ds / Save ds.
754:
755: lds si, 8(bp) / Far address
756: mov di, 12(bp) / Kernel address
757: mov cx, 14(bp) / Count
758: mov ax, cx / Move here to return
759:
760: cld / Auto increment
761: clc /
762: rcr cx, $1 / Calculate Word count.
763: rep /
764: movsw / Move words.
765: rcl cx, $1 /
766: rep /
767: movsb / Move odd byte.
768: /
769: pop ds / Restore ds.
770: pop bp / Restore bp.
771: pop di / Restore di
772: pop si / Restore si
773: ret / Return
774:
775: ////////
776: /
777: / fclear( fp, n ) - Erase far memory.
778: / faddr_t fp;
779: / unsigned n;
780: /
781: ////////
782:
783: .globl fclear_
784:
785: fclear_:
786: push es / Save es
787: push di / Save di
788: push bp / Save bp
789: mov bp, sp / Base pointer
790:
791: les di, 8(bp) / Far address
792: mov cx, 12(bp) / Count
793: sub ax, ax /
794:
795: cld / Auto increment
796: clc /
797: rcr cx, $1 / Calculate Word count.
798: rep /
799: stosw / Clear words.
800: rcl cx, $1 /
801: rep /
802: stosb / Clear odd byte.
803: /
804: pop bp / Restore bp.
805: pop di / Restore di.
806: pop es / Restore es.
807: ret / Return
808:
809: ////////
810: /
811: / Profile scaling.
812: /
813: ////////
814:
815: .globl pscale_
816:
817: pscale_:
818: mov bx,sp / Base pointer
819: mov ax,2(bx) / Multiply
820: mul 4(bx) /
821: mov ax,dx / Get high half
822: ret / And return
823:
824: ////////
825: /
826: / Save the environment of a process
827: / envsave(p)
828: / MENV *p;
829: /
830: / Save the context of a process
831: / consave(p)
832: / MCON *p;
833: /
834: ////////
835:
836: .globl consave_
837: .globl envsave_
838:
839: envsave_:
840: consave_:
841: mov cx, di / Hide di.
842: mov bx, sp / Point bx at the stack and
843: mov di, 2(bx) / di at the MCON block.
844: cld / Ensure increment.
845: mov ax, cx / Save di
846: stosw
847: mov ax, si / Save si
848: stosw
849: mov ax, bp / Save bp
850: stosw
851: mov ax, sp / Save sp
852: stosw
853: mov ax, (bx) / Save ra as pc
854: stosw
855: pushf / Save fw
856: pop ax
857: stosw
858: movb al, depth_ / Save stack depth
859: cbw
860: stosw
861: mov di, cx / Put di back,
862: sub ax, ax / indicate a state save and
863: ret / return to caller.
864:
865: ////////
866: /
867: / Restore the environment of a process.
868: / envrest(p)
869: / MENV *p;
870: /
871: ////////
872:
873: .globl envrest_
874:
875: envrest_:
876: cli
877: cld
878: mov bx,sp / Base pointer
879: mov si,2(bx) / Pointer to context
880: lodsw / Restore di
881: mov di,ax /
882: lodsw / Restore si
883: mov cx,ax / Save for later
884: lodsw / Restore bp
885: mov bp,ax /
886: lodsw / Restore sp
887: mov sp,ax /
888: mov bx,ax / Our frame
889: push cs / Push current CS
890: lodsw / Restore pc
891: push ax /
892: lodsw / Restore flags
893: mov (bx),ax / Stack now in form PSW,CS,IP.
894: lodsw / Restore stack depth
895: cli / No more interrupts
896: movb depth_, al
897: mov si,cx / Restore si
898: mov ax,$1 / We are restoring
899: iret / Return through PSW,CS,IP.
900:
901: ////////
902: /
903: / Restore the context of a process.
904: / Called with interrupts disabled from dispatch.
905: / conrest(u, o)
906: / saddr_t u;
907: /
908: ////////
909:
910: .globl conrest_
911:
912: conrest_:
913: decb depth_ / Falsify user/system state
914: sti / Interrupts ok here
915: / Save current uarea
916: call usave_ / Save the uarea in its segment.
917: / Copy in new uarea
918: mov bx,sp / Base pointer
919: mov ax, 2(bx) / Fetch uarea saddr_t
920: mov bx, 4(bx) / Fetch syscon offset
921: mov uasa_, ax / Save uarea saddr_t
922: mov cx,$USZ1 / uproc size
923: / mov es,sds_ / system data segment
924: mov di,$u_ / system data uarea offset
925: mov ds,ax / uarea segment
926: sub si,si / uarea offset
927: mov sp,UMCSP(bx) / new stack
928: cld / increment
929: rep / repeat
930: movsw / copy uproc
931: mov di,sp / stack offset in system data
932: and di,$~1 / ensure word alignment
933: mov cx,$u_+UPASIZE / compute byte
934: sub cx,di / count
935: mov si,$UPASIZE / compute offset
936: sub si,cx / in segment
937: shr cx,$1 / make word count
938: rep / repeat
939: movsw / copy stack
940: / Clean up
941: mov ax, es / Restore data
942: mov ds, ax / segment
943: / Now restore context
944: add bx, $u_ / convert to address
945: mov si, bx / Get source index for restore
946: lodsw / Restore di
947: mov di,ax /
948: lodsw / Restore si
949: mov cx,ax / Save for later
950: lodsw / Restore bp
951: mov bp,ax /
952: lodsw / Restore sp
953: mov sp,ax /
954: mov bx,ax / Our frame
955: push cs / Push current CS
956: lodsw / Restore pc
957: push ax /
958: lodsw / Restore flags
959: mov (bx),ax / Stack now in form PSW,CS,IP.
960: lodsw / Restore stack depth
961: cli / No more interrupts
962: movb depth_, al
963: mov si,cx / Restore si
964: mov ax,$1 / We are restoring
965: iret / Return through PSW,CS,IP.
966:
967: ////////
968: / usave()
969: / Save uarea in segment.
970: / Knowing that ds points to the system data segment
971: / and that es should map there also.
972: / And guaranteed not to step on ax or bx for conrest
973: /
974: .globl usave_
975: 0: ret
976: usave_:
977: cmp uasa_, $0 /
978: je 0b
979: push es / Save es
980: push si / Save si
981: push di / Save di
982: mov cx,$USZ1 / count
983: sub di,di / uarea segment offset
984: mov es,uasa_ / uarea segment
985: mov si,$u_ / system data offset
986: / mov ds,sds_ / system data segment
987: cld / increment
988: rep / repeat
989: movsw / copy uproc
990: mov si,sp / stack offset in system data
991: and si,$~1 / ensure word alignment
992: mov cx,$u_+UPASIZE / compute byte
993: sub cx,si / count
994: mov di,$UPASIZE / compute offset
995: sub di,cx / in segment
996: shr cx,$1 / make word count
997: rep / repeat
998: movsw / copy stack
999: pop di / Restore di
1000: pop si / Restore si
1001: pop es / Restore extra
1002: ret
1003:
1004: / Save useful registers.
1005: /
1006: .globl msysgen_
1007: /
1008: / msysgen(p)
1009: / MGEN *p;
1010: /
1011: msysgen_:
1012: ret / Nothing useful to save
1013:
1014: / Disable interrupts. Previous value is returned.
1015: /
1016: .globl sphi_
1017:
1018: sphi_:
1019: pushf / Save flags
1020: pop ax / Return current value
1021: cli / Disable interrupts
1022: ret / And return
1023:
1024: / Enable interrupts. Previous value is returned.
1025: /
1026: .globl splo_
1027:
1028: splo_:
1029: pushf
1030: pop ax
1031: sti
1032: ret
1033:
1034: / Change interrupt flag. Previous value is returned.
1035: /
1036: .globl spl_
1037:
1038: spl_:
1039: pop ax / ip
1040: pop bx / psw
1041: push bx
1042: push bx / push psw, cs, ip for iret
1043: push cs
1044: push ax
1045: pushf / old psw
1046: pop ax
1047: iret
1048:
1049: ////////
1050: /
1051: / Idle routine.
1052: / Enable interupts, and wait for something to
1053: / happen. Does not do anything to the 8259, bacause
1054: / this will be set up correctly.
1055: /
1056: ////////
1057:
1058: .globl _idle_
1059:
1060: _idle_: sti / Interupts on.
1061: hlt / Wait for an interrupt
1062: ret / and return.
1063:
1064: ////////
1065: /
1066: / The world is indeed grim.
1067: / Halt. Keep the interrupts on so that the
1068: / keyboard can get int.
1069: /
1070: ////////
1071:
1072: .globl halt_
1073:
1074: halt_: sti / Be safe,
1075: 0:
1076: hlt / and halt.
1077: jmp 0b / Paranoid, yes sir.
1078:
1079: ////////
1080: /
1081: / Basic port level I/O.
1082: /
1083: / int inb(port);
1084: / int outb(port, data);
1085: /
1086: ////////
1087:
1088: .globl inb_
1089: .globl outb_
1090:
1091: inb_: mov bx, sp
1092: mov dx, ss:2(bx)
1093: sub ax, ax
1094: inb al, dx
1095: ret
1096:
1097: outb_: mov bx, sp
1098: mov dx, ss:2(bx)
1099: mov ax, ss:4(bx)
1100: outb dx, al
1101: ret
1102:
1103: ////////
1104: /
1105: / Routines to move data to and from
1106: / the system auxiliary segment.
1107: /
1108: ////////
1109:
1110: .globl ageti_
1111:
1112: ageti_:
1113: mov bx,sp / Base pointer
1114: mov bx,2(bx) / Pointer
1115: push es / Save extra mapping and
1116: mov es, sas_ / remap.
1117: mov ax,es:(bx) / Get value
1118: pop es / Restore es and
1119: ret / Return
1120:
1121: .globl aputp_
1122: .globl aputi_
1123:
1124: aputp_:
1125: aputi_:
1126: mov bx,sp / Base pointer
1127: mov ax,4(bx) / Value
1128: mov bx,2(bx) / Pointer
1129: push es / Save extra base and
1130: mov es, sas_ / remap.
1131: mov es:(bx),ax / Set value
1132: pop es / Restore extra base
1133: ret / Return
1134:
1135: .globl aputc_
1136:
1137: aputc_:
1138: mov bx,sp / Base pointer
1139: mov ax,4(bx) / Value
1140: mov bx,2(bx) / Pointer
1141: push es / Save es and
1142: mov es, sas_ / remap.
1143: movb es:(bx),al / Set value
1144: pop es / Restore es and
1145: ret / Return
1146:
1147: ////////
1148: /
1149: / Data.
1150: / A small number of variables must be
1151: / in the code segment. All of these variables have
1152: / something to do with the interrupt linkage; when you
1153: / get an interrupt the only thing that is valid is
1154: / the code segment.
1155: /
1156: ////////
1157:
1158: .globl cds
1159:
1160: .shri
1161: cds: .blkw 1 / Copy of "sds_".
1162:
1163: .globl u_
1164: .globl depth_, sas_, scs_, sds_, ucs_
1165: .globl ucl_, uds_, udl_
1166:
1167: .bssd
1168: .even
1169: u_: .blkb UPASIZE
1170:
1171: .prvd
1172: oops: .ascii "stack overflow"
1173: .byte 0
1174:
1175: depth_: .byte 0 / System state.
1176:
1177: .even
1178: sas_: .blkw 1 / System auxiliary segment.
1179: scs_: .blkw 1 / System code segment.
1180: sds_: .blkw 1 / System data segment.
1181: ucs_: .blkw 1 / User code segment.
1182: ucl_: .blkw 1 / User code limit.
1183: uds_: .blkw 1 / User data segment.
1184: udl_: .blkw 1 / User data limit.
1185: sav_ds: .blkw 1 / Four scratch words
1186: sav_bx: .blkw 1
1187: sav_ss: .blkw 1
1188: sav_sp: .blkw 1
1189:
1190: ////////
1191: /
1192: / This is the image of the init process.
1193: / It gets copied into a user segment when the system
1194: / is first brought up. It must be in the data segment, because
1195: / that is how it is used, and it must be dephased in a funny
1196: / way because it is executed at location 0.
1197: /
1198: ////////
1199:
1200: .globl aicodep_ / Position of code.
1201: .globl aicodes_ / Size of code.
1202: .globl aidatap_ / Position of data.
1203: .globl aidatas_ / Size of data.
1204:
1205: .shrd
1206: aicodep_:
1207: sub ax,ax / No environment
1208: push ax
1209: mov ax,$argl-aidatap_ / Argument list
1210: push ax
1211: mov ax,$fn-aidatap_ / File name
1212: push ax
1213: sub sp,$2 / Dummy word for exec
1214: sys 11 / Sys exec
1215: jmp . / This should not return
1216: aicodes_ = .-aicodep_
1217:
1218: aidatap_:
1219: .word 0 /
1220: .word 0 / Errno
1221: .word 0 /
1222: .word 0 /
1223: .word 0 /
1224: .word 0 /
1225: .word 0 /
1226: .word 0 /
1227: argl: .word fn-aidatap_ / argv[0] = "/etc/init";
1228: .word a1-aidatap_ / argv[1] = "";
1229: .word 0 / argv[2] = NULL;
1230:
1231: fn: .ascii "/etc/init\000"
1232: a1: .byte 0
1233:
1234: .even
1235: .blkb 64
1236: sb:
1237: aidatas_ = .-aidatap_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.