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