![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mmu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / i386|
Return to mmu.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / i386 |
1.1 root 1: /*
2: * MMU dependent code for Coherent 386
3: *
4: * Copyright (c) Ciaran O'Donnell, Bievres (FRANCE), 1991
5: */
6:
7: #include <kernel/alloc.h>
8:
9: #include <sys/coherent.h>
10: #include <sys/clist.h>
11: #include <sys/errno.h>
12: #include <sys/inode.h>
13: #include <sys/seg.h>
14: #include <signal.h>
15: #include <sys/buf.h>
16: #include <l.out.h>
17: #include <ieeefp.h>
18:
19: /* These defines belong somewhere else: */
20: #define LOMEM 0x15 /* CMOS address of size in K of memory below 1MB. */
21: #define EXTMEM 0x17 /* CMOS address of size in K of memory above 1MB. */
22: #define ONE_K 1024
23: #define ONE_MEG 1048576
24: #define USE_NDATA 1
25:
26: /*
27: * DMA will not work to memory above 16M, so limit the amount of memory
28: * above 1M to 15M. A much cleverer scheme should be implemented.
29: */
30: int HACK_LIMIT = (15*ONE_MEG);
31:
32: /*
33: * For 0 < i < 64, buddysize[i] is log(base 2) of nearest power of two
34: * which is greater than or equal to i.
35: */
36: char buddysize[64] = {
37: -1, 0, 1, 2, 2, 3, 3, 3,
38: 3, 4, 4, 4, 4, 4, 4, 4,
39: 4, 5, 5, 5, 5, 5, 5, 5,
40: 5, 5, 5, 5, 5, 5, 5, 5,
41: 5, 6, 6, 6, 6, 6, 6, 6,
42: 6, 6, 6, 6, 6, 6, 6, 6,
43: 6, 6, 6, 6, 6, 6, 6, 6,
44: 6, 6, 6, 6, 6, 6, 6, 6 };
45:
46: #define min(a, b) ((a) < (b) ? (a) : (b))
47:
48: /*
49: * Functions.
50: * Import.
51: * Export.
52: * Local.
53: */
54: void areacheck();
55: void areafree();
56: void areainit();
57: BLOCKLIST * arealloc();
58: int areasize();
59: cseg_t * c_alloc();
60: cseg_t * c_extend();
61: void c_free();
62: int c_grow();
63: int countsize();
64: void doload();
65: char * getPhysMem();
66: void i8086();
67: void idtinit();
68: void init_phy_seg();
69: void mchinit();
70: void msigend();
71: void physMemInit();
72: SR *loaded();
73: unsigned int read16_cmos();
74: void segload();
75: void sunload();
76: void unload();
77: void valloc();
78:
79:
80: /*
81: * "load" a handle "hp" to a segment into the space tree for a process
82: */
83: void
84: doload(srp)
85: register SR *srp;
86: {
87: register int n;
88: register cseg_t *pp;
89: register int base1, flags;
90: register int akey;
91:
92: pp = srp->sr_segp->s_vmem;
93: flags = srp->sr_segp->s_flags;
94: base1 = btocrd(srp->sr_base);
95: n = btoc(srp->sr_size);
96:
97: /*
98: * we load all pages
99: */
100: /* a shm segment ref may be Read-Write or Read-Only */
101: if (srp->sr_flag & SRFRODT)
102: akey = SEG_RO;
103: else {
104: switch (flags&(SFSYST|SFTEXT)) {
105: case SFTEXT: akey = SEG_RO; break;
106: case SFSYST: akey = SEG_SRW; break;
107: default: akey = SEG_RW; break;
108: }
109: }
110:
111: do
112: ptable1_v[base1++] = (*pp++ & ~SEG_NPL) | akey;
113: while (--n);
114: mmuupd();
115: }
116:
117: /*
118: * unload a handle key "key" to a segment from the MMU hardware
119: */
120: void
121: unload(srp)
122: register SR *srp;
123: {
124: register int n, base1;
125:
126: base1 = btocrd(srp->sr_base);
127:
128: n = btoc(srp->sr_size);
129: do {
130: ptable1_v[base1++] = SEG_ILL;
131: } while (--n);
132: mmuupd();
133: }
134:
135: /*
136: * Allocate 'clicks_wanted' clicks of core space.
137: * Returns physical segment descriptor if success, else NULL.
138: * The physical segment descriptor is a table of page table entries
139: * suitable for insertion into a page table.
140: */
141: cseg_t *
142: c_alloc(clicks_wanted)
143: unsigned clicks_wanted;
144: {
145: unsigned pno;
146: cseg_t *pp;
147: register cseg_t *qp;
148:
149: /* Do we have enough free physical clicks for this request? */
150: if (clicks_wanted > allocno())
151: goto no_c_alloc;
152:
153: /* Allocate some space for the table to return. */
154: if ((pp = (cseg_t *)arealloc(clicks_wanted)) == 0)
155: goto no_c_alloc;
156: qp = pp;
157:
158: /* fill in entries in the requested table */
159: do {
160: pno = *--sysmem.pfree;
161: if (!pvalid(pno))
162: panic("c_alloc");
163: *qp++ = (clickseg(pno) & ~SEG_BITS) | SEG_PRE;
164: } while (--clicks_wanted);
165: return pp;
166:
167: no_c_alloc:
168: return 0;
169: }
170:
171: /*
172: * Given an array "pp" containing "numClicks" click descriptors,
173: * if "pp" is the click list for a user segment currently loaded
174: * invalidate click entries for "pp" in the current page table
175: * return each click in "pp" to the sysmem pool, if it came from there.
176: * return the array "pp" to the buddy pool.
177: */
178: void
179: c_free(pp, numClicks)
180: cseg_t *pp;
181: unsigned numClicks;
182: {
183: unsigned pno;
184: register cseg_t *qp;
185: register int sz;
186: SR *srp;
187:
188: if (srp = loaded(pp)) {
189: unload(srp);
190: srp->sr_segp = 0;
191: }
192: sz = numClicks;
193: if (&sysmem.pfree[sz] > sysmem.efree)
194: panic("c_free - nalloc");
195: qp = pp;
196: do {
197: if ((*qp & SEG_NPL) == 0) {
198: pno = segclick(*qp);
199: if (!pvalid(pno))
200: panic("c_free");
201: *sysmem.pfree++ = pno;
202: } else {
203: T_HAL(0x40000, printf("c_free NPL %x ", *qp));
204: }
205: qp++;
206: } while (--sz);
207: areafree((BLOCKLIST *)pp, numClicks);
208: }
209:
210: /*
211: * Given a user virtual address, a physical address, and a byte
212: * count, map the specified virtual address into the user data
213: * page table for the current process.
214: *
215: * This is meant to be called from the console ioctl, KDMAPDISP.
216: * The user virtual address must be click aligned.
217: * The range of physical addresses must lie outside installed RAM
218: * or within the "PHYS_MEM" pool.
219: *
220: * Return 1 on success, else 0.
221: */
222: int
223: mapPhysUser(virtAddr, physAddr, numBytes)
224: {
225: int ret = 0;
226: SR * srp = u.u_segl + SIPDATA;
227: SEG * sp = srp->sr_segp;
228: cseg_t * pp = sp->s_vmem, * qp;
229: int pno, clickOffset, numClicks, i;
230:
231: /* Check alignment. */
232: if ((virtAddr & (NBPC-1)) || (physAddr & (NBPC-1))) {
233: T_HAL(0x40000, printf("mPU: failed alignment "));
234: goto mPUdone;
235: }
236:
237: /* Check validity of range of virtual addresses. */
238: if (virtAddr < srp->sr_base ||
239: (virtAddr + numBytes) >= (srp->sr_base + srp->sr_size)) {
240: T_HAL(0x40000, printf("mPU: bad vaddr "));
241: goto mPUdone;
242: }
243:
244: /* Check validity of range of physical addresses. */
245: /* if not in PHYS_MEM pool... */
246: if (!physValid(physAddr, numBytes)) {
247:
248: /* get installed RAM physical addresses */
249: unsigned int physLow = ctob((read16_cmos(LOMEM) + 3) >> 2);
250: unsigned int physHigh = ctob((read16_cmos(EXTMEM) + 3) >> 2)
251: + ONE_MEG;
252:
253: T_HAL(0x40000, printf("physLow=%x physHigh=%x ",
254: physLow, physHigh));
255:
256: /* Fail if physical range overlaps installed base RAM. */
257: if (physAddr < physLow) {
258: T_HAL(0x40000, printf("mPU: overlap base RAM "));
259: goto mPUdone;
260: }
261:
262: /* Fail if physical range overlaps installed extended RAM. */
263: if (physAddr < physHigh && (physAddr + numBytes) >= ONE_MEG) {
264: T_HAL(0x40000, printf("mPU: overlap extended RAM "));
265: goto mPUdone;
266: }
267: }
268:
269: /*
270: * For each click in user data segment which is to be remapped
271: * if current click was taken from sysmem pool
272: * return current click to sysmem pool
273: * write new physical address into current click entry
274: * mark current click as not coming from sysmem pool
275: * map current click into page table
276: */
277: clickOffset = btocrd(virtAddr - srp->sr_base);
278: numClicks = numBytes >> BPCSHIFT;
279: for (qp = pp + clickOffset, i = 0; i < numClicks; i++, qp++) {
280: if ((*qp & SEG_NPL) == 0) {
281: pno = segclick(*qp);
282: if (!pvalid(pno)) {
283: T_HAL(0x40000, printf("mPU: bad release "));
284: } else {
285: *sysmem.pfree++ = pno;
286: T_HAL(0x40000,
287: printf("mPU: freeing virtual click %x ",
288: virtAddr + ctob(i)));
289: }
290: } else {
291: T_HAL(0x40000,
292: printf("mPU: rewriting virtual NPL click %x ",
293: virtAddr + ctob(i)));
294: }
295: *qp = (physAddr + ctob(i)) | (SEG_RW | SEG_NPL);
296: ptable1_v[btocrd(virtAddr) + i] = *qp;
297: }
298: mmuupd();
299: ret = 1;
300:
301: mPUdone:
302: return ret;
303: }
304:
305: /*
306: * Add a click to a segment.
307: * Enlarge buddy table for segment, if needed.
308: *
309: * Arguments:
310: * pp points to segment reference table (segp->s_vmem, e.g.)
311: * osz is old segment size, in clicks
312: *
313: * Return pointer to enlarged segment reference table, or NULL if failed.
314: */
315: cseg_t *
316: c_extend(pp, osz)
317: register cseg_t *pp;
318: int osz;
319: {
320: register cseg_t *pp1;
321: register unsigned pno;
322: register int i;
323: SR *srp;
324:
325: /* Fail if no more free clicks available. */
326: if (sysmem.pfree < &sysmem.tfree[1])
327: goto no_c_extend;
328:
329: /* Don't grow segment beyond hardware segment size (4 megabytes). */
330: if (osz >= (NBPS/NBPC))
331: goto no_c_extend;
332:
333: if (srp = loaded(pp)) {
334: unload(srp);
335: srp->sr_segp = 0;
336: }
337:
338: /*
339: * If the old size was a power of 2, it has used up an entire
340: * buddy area, so we will need to allocate more space.
341: */
342: if (IS_POW2(osz)) {
343: if ((pp1 = (cseg_t*) arealloc(osz+1))==0)
344: goto no_c_extend;
345: for (i=0; i < osz; i++)
346: pp1[i] = pp[i];
347: areafree(pp, osz);
348: pp = pp1;
349: }
350:
351: for (i=osz; --i >= 0;)
352: pp[i+1] = pp[i];
353:
354: pno = *--sysmem.pfree;
355: if (!pvalid(pno))
356: panic("c_extend");
357: pp[0] = clickseg(pno) | SEG_RW;
358: return pp;
359:
360: no_c_extend:
361: return 0;
362: }
363:
364: /*
365: * Given segment size in bytes, estimate total space needed
366: * to keep track of the segment (I think - hws).
367: *
368: * return value is num_bytes plus some overhead...
369: */
370: int
371: countsize(num_bytes)
372: int num_bytes;
373: {
374: int ret;
375:
376: if (num_bytes <= NBPC/sizeof(long))
377: ret = num_bytes+1;
378: else
379: ret = num_bytes
380: + ((num_bytes + NBPC/sizeof(long) - 1) >> BPC1SHIFT) + 1;
381: return ret;
382: }
383:
384: /*
385: * buddy allocation
386: */
387:
388: /*
389: * Deallocate a segment descriptor area.
390: * "sp" is not really a BLOCKLIST*, rather a cseg_t *.
391: * "numClicks" is the number of clicks referenced in the area.
392: */
393: void
394: areafree(sp, numClicks)
395: BLOCKLIST *sp;
396: int numClicks;
397: {
398: register int n; /* adresse du buddy, taille du reste */
399: register int ix, nx;
400: register BLOCKLIST *buddy;
401:
402: areacheck(2, sp);
403:
404: /*
405: * Pointer "sp" points to an element in the sysmem table of
406: * free clicks.
407: * Integer "ix" is the index of "sp" into that table.
408: * Will use "ix" to index into one or more buddy tables.
409: */
410: ix = sp - sysmem.u.budtab;
411: n = areasize(numClicks);
412: do {
413: /* "nx" is index of buddy element to the one at "ix". */
414: nx = BUDDY(ix, n);
415: if (sysmem.budfree[nx>>WSHIFT] & 1<<(nx&(WCOUNT-1))) {
416: /* coalesce two buddies */
417: buddy = sysmem.u.budtab + nx;
418: if (buddy->kval != n)
419: break;
420: sysmem.budfree[nx>>WSHIFT] &= ~ (1<<(nx & (WCOUNT-1)));
421: DELETE2(buddy);
422: if (nx < ix)
423: ix = nx;
424: } else
425: break;
426: } while (++n < NBUDDY);
427: sysmem.budfree[ix>>WSHIFT] |= 1 << (ix & (WCOUNT-1));
428: buddy = sysmem.u.budtab + ix;
429: INSERT2(BLOCKLIST, buddy, &sysmem.bfree[n]);
430: buddy->kval = n;
431: areacheck(3, buddy);
432: }
433:
434: /*
435: * arealloc()
436: *
437: * Given size in "clicks" of a segment to manage,
438: * return pointer to an array of enough descriptors.
439: * If not enough free descriptors available, return 0.
440: */
441: BLOCKLIST *
442: arealloc(clicks)
443: register int clicks;
444: {
445: register BLOCKLIST *sp;
446: register BLOCKLIST *p, *q;
447: register int size;
448: BLOCKLIST *rsp;
449: register int nx;
450:
451: areacheck(0, 0);
452: size = areasize(clicks);
453: /*
454: * 1. Find little end, bloc p, free >= size
455: */
456: for (q = p = sysmem.bfree + size;p->forw == p; size++, p++)
457: if (p >= sysmem.bfree + NBUDDY - 1) {
458: return(0); /* y en a pas */
459: }
460:
461: rsp = p->forw;
462: DELETE2(rsp);
463: nx = rsp - sysmem.u.budtab;
464: sysmem.budfree[nx>>WSHIFT] &= ~(1 << (nx & (WCOUNT-1)));
465: size = 1<<size;
466: sp = rsp + size; /* buddy address */
467: while (p-- != q) {
468: /*
469: * 2.1 The block is too big, uncouple & free buddy
470: */
471: sp -= (size >>= 1);
472: nx = sp - sysmem.u.budtab;
473: sysmem.budfree[nx>>WSHIFT] |= 1 << (nx & (WCOUNT-1));
474: INSERT2(BLOCKLIST, sp, p);
475: sp->kval = p - sysmem.bfree;
476: }
477: areacheck(1, rsp);
478: return rsp;
479: }
480:
481: void
482: areainit(n)
483: {
484: extern char __end[];
485: register int i;
486:
487: for (i=0; i < (1<<(NBUDDY-WSHIFT)); i++)
488: sysmem.budfree[i] = 0;
489: for (i=0; i<NBUDDY; i++)
490: INIT2(&sysmem.bfree[i]);
491: sysmem.u.budtab = (BLOCKLIST *)__end;
492: n /= sizeof(BLOCKLIST);
493: if (n > (1 << NBUDDY))
494: panic("areainit");
495: for (i=0; i<n; i++)
496: areafree(&sysmem.u.budtab[i], sizeof(BLOCKLIST)/sizeof(long));
497: }
498:
499: /*
500: * areasize()
501: *
502: * Do a log(base 2) calculation on n.
503: * If n is zero, return -1.
504: *
505: * Else, consider the nearest power of two which is greater than or
506: * equal to n
507: * p/2 < n <= p
508: * Then set p = 4 * (2**x). Note BLKSZ is 2.
509: * Return max(x,0).
510: *
511: * If n is too large (more than 3F00), we will go beyond the limits of
512: * table buddysize[].
513: *
514: * In practice, n is the total number of clicks needed in a segment,
515: * and the return value will be used to access a buddy system list.
516: */
517: int
518: areasize(n)
519: register unsigned int n;
520: {
521: register int m;
522: #ifdef FROTZ
523: int ret, oldn = n;
524: #endif
525:
526: if (n > 0x3F00)
527: panic("areasize");
528:
529: n = (n + (1 << BLKSZ) - 1) >> BLKSZ;
530: m = n & 0x3F;
531: #ifdef FROTZ
532: if ((n >>= 6) == 0)
533: ret = buddysize[m];
534: else {
535: int index;
536:
537: index = n;
538: if (m)
539: index++;
540: ret = buddysize[index] + 6;
541: }
542: return ret;
543: #else
544: if ((n >>= 6) == 0)
545: return buddysize[m];
546: return buddysize[n + ((m!=0)?1:0)] + 6;
547: #endif
548: }
549:
550: #define MAXBUDDY 2048
551: #define CHECK(p) ((p>=&sysmem.bfree[0] && p<&sysmem.bfree[NBUDDY]) || \
552: (p>=sysmem.u.budtab && p<&sysmem.u.budtab[1<<NBUDDY]))
553: void
554: areacheck(flag, sp)
555: register BLOCKLIST *sp;
556: {
557: register BLOCKLIST *next, *start;
558: register int i, nx;
559:
560: if (sp) {
561: if (&sysmem.u.budtab[sp-sysmem.u.budtab] != sp)
562: printf("*check* %d %x %x\n", flag, sp, sysmem.u.budtab);
563: }
564:
565: for (i=0; i<NBUDDY; i++) {
566: start = next = &sysmem.bfree[i];
567: do {
568: next = next->forw;
569: if (!CHECK(next))
570: printf("next = %x (%d)\n", next, flag);
571: if (next->back != start)
572: printf("%x->forw->back != %x\n", next, start);
573: if (next != &sysmem.bfree[i]) {
574: if (next->kval != i)
575: printf("bad kval %x, %d (%d)\n",
576: next, next->kval, flag);
577: nx = next - sysmem.u.budtab;
578: if ((sysmem.budfree[nx>>WSHIFT] & (1 << (nx & (WCOUNT-1)))) == 0)
579: printf("in bfree but not budfree %x (%d)\n", next, flag);
580: }
581: start = next;
582: } while (next != &sysmem.bfree[i]);
583: }
584: }
585:
586: MAKESR(physMem, _physMem);
587: extern int PHYS_MEM; /* Number of bytes of contiguous RAM needed */
588:
589: /*
590: * A block of contiguous physical memory has been allocated for special
591: * i/o devices.
592: * Problem: clicks of physical memory are in reverse order in the
593: * page table.
594: * This routine reverses the page table entries for the pages
595: * involved. It relies *heavily* on all pages having virtual addresses
596: * in the FFCx xxxx segment.
597: *
598: * If all goes well, assign physAvailStart to the virtual address of
599: * the beginning of the region, and physAvailBytes to the number of bytes
600: * in the region. Otherwise, leave physAvailStart and physAvailBytes at 0.
601: *
602: * As memory is allocated, physAvailStart advances to point to the next
603: * available byte of contiguous memory, physAvailBytes is decremented,
604: * and physPoolStart remains set to the virtual address of the start of
605: * the contiguous pool.
606: */
607: static int physPoolStart; /* start of contiguous memory area */
608: static int physAvailStart; /* next free byte in contiguous memory area */
609: static int physAvailBytes; /* number of bytes in contiguous memory area */
610:
611: /*
612: * Check whether a range of physical addresses lies within the
613: * pool of contiguous physical memory.
614: */
615: int
616: physValid(base, numBytes)
617: unsigned int base, numBytes;
618: {
619: int vpool;
620: int ret = 0;
621:
622: if (PHYS_MEM) {
623: vpool = vtop(physPoolStart);
624: T_HAL(0x40000, printf("PHYS_MEM phys addrs %x to %x ",
625: vpool, vpool + PHYS_MEM));
626: if (base >= vpool && (base + numBytes) <= (vpool + PHYS_MEM))
627: ret = 1;
628: } else {
629: T_HAL(0x40000, printf("No PHYS_MEM "));
630: }
631:
632: T_HAL(0x40000, printf("physValid(%x, %x) = %d ", base, numBytes, ret));
633: return ret;
634: }
635:
636: void
637: physMemInit()
638: {
639: int m, vaddr;
640: int err = 0, num_clicks = btoc(PHYS_MEM);
641: int prevPaddr, paddr;
642:
643: /*
644: * Going half way into page table for physMem
645: * If entry and its complementary entry aren't both in top segment
646: * Error exit (no phys mem will be available).
647: * Get page table entries and swap them.
648: */
649: for (m = 0; m < num_clicks/2; m++) {
650: int m2 = num_clicks - 1 - m; /* complementary index */
651:
652: /* compute virtual addresses */
653: int lo_addr = physMem.sr_base + ctob(m);
654: int hi_addr = physMem.sr_base + ctob(m2);
655:
656: /* compute indices into page table (ptable1_v) */
657: int lo_p1ix = btocrd(lo_addr);
658: int hi_p1ix = btocrd(hi_addr);
659:
660: /* fetch physical addresses from page table */
661: int lo_paddr = ptable1_v[lo_p1ix];
662: int hi_paddr = ptable1_v[hi_p1ix];
663:
664: /* abort if either address is not in top segment */
665: if (btosrd(lo_addr) != 0x3FF) {
666: err = 1;
667: break;
668: }
669: if (btosrd(hi_addr) != 0x3FF) {
670: err = 1;
671: break;
672: }
673:
674: /* exchange page table entries */
675: ptable1_v[lo_p1ix] = hi_paddr;
676: ptable1_v[hi_p1ix] = lo_paddr;
677: }
678:
679: /*
680: * Final sanity check.
681: * In case someone gets creative with startup code, check
682: * again here that the memory is actually contiguous.
683: */
684: prevPaddr = vtop(physMem.sr_base);
685: for (m = 0; m < num_clicks - 1; m++) {
686: paddr = vtop(physMem.sr_base + ctob(m + 1));
687: if (paddr - prevPaddr != NBPC) {
688: err = 1;
689: break;
690: }
691: prevPaddr = paddr;
692: }
693:
694: if (!err) {
695: physPoolStart = physAvailStart = physMem.sr_base;
696: physAvailBytes = PHYS_MEM;
697: }
698: }
699:
700: /*
701: * Return virtual address of block of contiguous physical memory.
702: * If request cannot be granted, return 0.
703: *
704: * Expect physMem resource to be granted during load routine of device
705: * drivers. Once allocated, memory is not returned to the physMem pool.
706: */
707: char *
708: getPhysMem(numBytes)
709: unsigned int numBytes;
710: {
711: char * ret = NULL;
712:
713: if (numBytes <= physAvailBytes) {
714: ret = (char *)physAvailStart;
715: physAvailStart += numBytes;
716: physAvailBytes -= numBytes;
717: } else
718: printf("getPhysMem failed - %d additional bytes "
719: "PHYS_MEM needed\n", physAvailBytes - numBytes);
720: return ret;
721: }
722:
723: /*
724: * Return virtual address of aligned block of contiguous physical memory.
725: * Mainly for devices using the stupid Intel DMA hardware without
726: * scatter/gather.
727: * If request cannot be granted, return 0.
728: *
729: * Argument "align" says what physical boundary we need alignment on.
730: * It must be a power of 2.
731: * For 4k alignment, align = 4k, etc.
732: * Sorry, but will throw away memory to get to the next acceptable address.
733: *
734: * Once allocated, memory is not returned to the physMem pool.
735: */
736: char *
737: getDmaMem(numBytes, align)
738: unsigned int numBytes;
739: unsigned int align;
740: {
741: char * ret = NULL;
742: int wastedBytes, neededBytes;
743:
744: if (align == 0) {
745: printf("getDmaMem(0) (?)\n");
746: goto getDmaMemDone;
747: }
748:
749: if (!IS_POW2(align)) {
750: printf("getDmaMem(%x) (?)\n", align);
751: goto getDmaMemDone;
752: }
753:
754: /*
755: * Waste RAM from bottom of pool up to physical
756: * address with desired alignment.
757: */
758: wastedBytes = align - (vtop(physAvailStart) % align);
759: neededBytes = numBytes + wastedBytes;
760:
761: if (neededBytes <= physAvailBytes) {
762: ret = (char *)physAvailStart + wastedBytes;
763: physAvailStart += neededBytes;
764: physAvailBytes -= neededBytes;
765: } else
766: printf("getDmaMem failed - %d additional bytes "
767: "PHYS_MEM needed\n", physAvailBytes - neededBytes);
768:
769: getDmaMemDone:
770: return ret;
771: }
772: /***************/
773:
774: #undef ptable1_v
775:
776: /*
777: * pageDir is the physical address of the click in use for the page
778: * directory, offset by ctob(SBASE - PBASE)
779: */
780: #define pageDir ((long *)(&stext[ctob(-1)]))
781:
782: int total_clicks; /* How many clicks did we start with? */
783:
784: void
785: mchinit()
786: {
787: extern char __end[], __end_data[], stext[], __end_text[], sdata[];
788: extern int RAM0, RAMSIZE;
789:
790: int lo; /* Number of bytes of physical memory below 640K. */
791: int hi; /* Number of bytes of physical memory above 1M. */
792: register char *pe;
793: register int zero = 0;
794: register int i;
795: register long *ptable1_v;
796: register unsigned short base;
797: int sysseg, codeseg, stackseg, ramseg, ptable1;
798: int ptoff; /* An offset into pageDir[] */
799: #if USE_NDATA
800: int dataseg[NDATA];
801: #else
802: int dataseg;
803: #endif
804: int nalloc;
805: extern char digtab[];
806: static SEG uinit;
807: int budArenaBytes; /* number of bytes in buddy pool */
808: int kerBytes; /* number of bytes in kernel text and data */
809:
810: /*
811: * 1.
812: * a. Relocate the data on a page boundary (4K bytes) the
813: * bootstrap relocates it on a paragraph boundary (16 bytes)
814: *
815: * b. Verify that the data has been relocated correctly
816: */
817: pe = __end_data; /* 1.a */
818: i = (((unsigned)__end_text+15) & ~15) - (unsigned)sdata;
819: do {
820: pe--;
821: pe[0] = pe[i];
822: } while (pe != sdata); /* 1.b */
823:
824: /*
825: * Can now access the .data segment from C.
826: * If not, next loop will hang the kernel.
827: */
828: CHIRP('A');
829: while (digtab[0]!='0');
830: CHIRP('*');
831:
832: /* Zero the bss. */
833: pe = __end_data;
834: do
835: *pe++ = zero;
836: while (pe != __end);
837:
838: /*
839: * Zero the level 0 page directory, which occupies the click
840: * of virtual space immediately below kernel text.
841: */
842: pe = (char *) pageDir;
843: do
844: *pe++ = zero;
845: while (pe != stext);
846:
847: CHIRP('2');
848:
849: /*
850: * 3. Calculate total system memory.
851: * Count the space used by the system and the page
852: * descriptors, the interrupt stack, and the refresh work area
853: *
854: * a. initialize allocation area and adjust system size
855: * to take allocation area and free page area into account
856: */
857:
858: /*
859: * btoc(__end) - SBASE is the number of clicks in kernel text
860: * plus data, rounded up.
861: * PBASE is the starting physical click number of the kernel.
862: *
863: * Set sysmem.lo to the physical click address just past the kernel.
864: */
865: DV(__end);
866:
867: kerBytes = __end - ((SBASE - PBASE)<<BPCSHIFT);
868: DV(kerBytes);
869:
870: sysmem.lo = btoc(kerBytes);
871: DV(sysmem.lo);
872:
873: /*
874: * lo is the size in bytes of memory between the end of the kernel
875: * and the end of memory below 640K.
876: * hi is the size in bytes of memory over 1 Megabyte (Extended memory).
877: *
878: * Round the sizes from the CMOS down to the next click. This
879: * compensates for systems where the CMOS reports sizes that are
880: * not multiples of 4K.
881: */
882: DV(read16_cmos(LOMEM));
883: lo = ctob(read16_cmos(LOMEM) >> 2) - ctob(sysmem.lo);
884: DV(lo);
885:
886: DV(read16_cmos(EXTMEM));
887: hi = ctob(read16_cmos(EXTMEM) >> 2);
888: DV(hi);
889:
890: /*
891: * Sometimes, we die horribly if there is too much memory.
892: * Artificially limit hi to HACK_LIMIT.
893: */
894: if (hi > HACK_LIMIT)
895: hi = HACK_LIMIT;
896:
897: /* clear base memory above the kernel */
898: #if 0
899: CHIRP('z');
900: memset (ctob (sysmem.lo + SBASE - PBASE), 0, lo);
901: CHIRP('Z');
902:
903: /* clear extended memory */
904: memset (ONE_MEG + ctob (SBASE - PBASE), 0, hi);
905: CHIRP('Y');
906: #endif
907:
908: /* Record total memory for later use. */
909: total_mem = ctob(sysmem.lo) + lo + hi;
910: DV(total_mem);
911:
912: /*
913: * sysmem.pfree and relatives will keep track of a pool of 4k pages
914: * assigned to processes, hereinafter known as the sysmem pool.
915: * How many clicks can go into this pool? nalloc.
916: * Allow NBPC for the click itself, a short for the sysmem pointer,
917: * and SPLASH*sizeof(long) for buddy system overhead.
918: */
919: nalloc = (lo+hi) / (sizeof(short) + SPLASH*sizeof(long) + NBPC);
920: DV(nalloc);
921:
922: /*
923: * ASSERT:
924: * For the moment we want only to assure that the
925: * BUDDY arena and the stack of free pages will fit below
926: * 640K.
927: */
928: budArenaBytes = SPLASH*nalloc*sizeof(long);
929: DV(budArenaBytes);
930:
931: #define SIZEOF_FREE_PAGES ((btoc(hi) + btoc(lo))* sizeof(short))
932: T_PIGGY(0x800, budArenaBytes + SIZEOF_FREE_PAGES >= lo ?
933: panic("Too much memory") : 0);
934:
935: /*
936: * Initialize the buddy system arena. This memory is used
937: * for the compressed page tables.
938: */
939: areainit(budArenaBytes);
940:
941: /*
942: * Initialize the stack of free pages.
943: * __end is the virtual address just past kernel data
944: * Point sysmem.tfree to the lowest virtual address just above
945: * the buddy pool, and initialize sysmem.pfree there.
946: */
947: sysmem.tfree = sysmem.pfree =
948: (unsigned short *)(__end + budArenaBytes);
949: DV(sysmem.tfree);
950:
951: /* sysmem.hi is the physical click number just past high RAM */
952: sysmem.hi = btoc(hi+ONE_MEG);
953: DV(sysmem.hi);
954:
955: /* base is the physical click number just past base RAM */
956: base = sysmem.lo + (lo>>BPCSHIFT);
957: DV(base);
958:
959: /*
960: * Adjust sysmem.lo to be the physical click number just above
961: * not just the kernel, but above sysmem overhead as well.
962: */
963: sysmem.lo = btoc(kerBytes + budArenaBytes + nalloc*sizeof(short));
964: DV(sysmem.lo);
965:
966: /*
967: * sysmem.vaddre is the virtual address of the next click after the
968: * kernel.
969: */
970: sysmem.vaddre = ctob(sysmem.lo+SBASE-PBASE);
971: DV(sysmem.vaddre);
972:
973: /* include in system area pages for arena, free area */
974:
975: CHIRP('3');
976:
977: /*
978: * 4.
979: * Free the memory from [end, 640) kilobytes
980: * Free the memory from [1024, 16*1024) kilobytes
981: *
982: * We are building a stack of free pages bounded below
983: * by sysmem.tfree and above by sysmem.efree. sysmem.pfree
984: * is the top of the stack. The stack grows upwards.
985: */
986: total_clicks = 0;
987:
988: /*
989: * Initialize the sysmem table (phase 1 - base RAM).
990: * Put base RAM above the kernel and sysmem overhead area into
991: * sysmem pool.
992: */
993: while (base > sysmem.lo) {
994: *sysmem.pfree++ = --base;
995: ++total_clicks;
996: }
997:
998: /*
999: * Initialize the sysmem table (phase 2 - extended RAM).
1000: * Put all extended RAM into the sysmem pool.
1001: */
1002: base = btoc(ONE_MEG);
1003: while (base < sysmem.hi && total_clicks < nalloc) {
1004: *sysmem.pfree++ = base++;
1005: ++total_clicks;
1006: }
1007: DV(total_clicks);
1008:
1009: /*
1010: * Roundoff error may have made nalloc smaller than necessary.
1011: */
1012: while(base < sysmem.hi) {
1013: if (sysmem.pfree + 1 >= sysmem.vaddre)
1014: break;
1015: *sysmem.pfree++ = base++;
1016: ++total_clicks;
1017: nalloc++;
1018: }
1019: DV(total_clicks);
1020: DV(nalloc);
1021:
1022: /*
1023: * sysmem.efree points just past the last pointer in the sysmem
1024: * table.
1025: */
1026: sysmem.efree = sysmem.pfree;
1027: DV(sysmem.efree);
1028: DV(allocno());
1029:
1030: #if 0
1031: /*
1032: * NIGEL: Trace macros must now be given expressions. This one isn't
1033: * worth cleaning up.
1034: */
1035:
1036: T_PIGGY(0x800, {
1037: /*
1038: * ASSERT: The stack of free pages should end within a click
1039: * of the lowest available memory.
1040: */
1041: if ((cseg_t *)ctob(sysmem.lo+SBASE-PBASE) < sysmem.efree) {
1042: panic("sysmem.lo is too low");
1043: }
1044:
1045: if (sysmem.efree < (cseg_t *)ctob(sysmem.lo+SBASE-PBASE - 1)){
1046: panic("sysmem.efree is too low");
1047: }
1048:
1049: /*
1050: * ASSERT: There should be nalloc total_clicks.
1051: */
1052: if (nalloc != total_clicks) {
1053: panic("nalloc != total_clicks ");
1054: }
1055: });
1056: #endif
1057:
1058: CHIRP('4');
1059:
1060: /*
1061: * 5. allocate page entries and initialize level 0 ^'s
1062: * a. [ 00000000 .. 003FFFFF) user code segment
1063: * b. [ 00400000 .. 007FFFFF) user data & bss
1064: * c. [ 7FC00000 .. 7FFFFFFF) user stack
1065: *c.i.[ 80000000 .. 80FFFFFF) ram disk
1066: * d. [ FF800000 .. FFBFFFFF) pointers to level 1 page table
1067: * e. [ FFC00000 .. FFFFFFFF) system process addresses
1068: */
1069: codeseg = clickseg(*--sysmem.pfree); /* 5.a */
1070: pageDir[0x000] = codeseg | DIR_RW;
1071:
1072: #if USE_NDATA
1073: for (i = 0; i < NDATA; i++) {
1074: dataseg[i] = clickseg(*--sysmem.pfree); /* 5.b */
1075: pageDir[0x001+i] = dataseg[i] | DIR_RW;
1076: }
1077: #else
1078: dataseg = clickseg(*--sysmem.pfree); /* 5.b */
1079: pageDir[0x001] = dataseg | DIR_RW;
1080: #endif
1081:
1082: stackseg = clickseg(*--sysmem.pfree); /* 5.c */
1083: pageDir[0x1FF] = stackseg | DIR_RW;
1084:
1085: /*
1086: * ptable1 is a handle for the click containing page table
1087: * entries for the page table.
1088: *
1089: * allocate a click for ptable1
1090: * Then point at it from the page directory.
1091: */
1092: ptable1 = clickseg(*--sysmem.pfree); /* 5.d */
1093: pageDir[0x3FE] = ptable1 | DIR_RW;
1094:
1095: sysseg = clickseg(*--sysmem.pfree); /* 5.e */
1096: pageDir[0x3FF] = sysseg | DIR_RW;
1097:
1098: CHIRP('5');
1099:
1100: /*
1101: * 6. initialize level 2 ^'s to [5.d]
1102: */
1103:
1104: ptable1_v = (long *)(ptable1 + ctob(SBASE-PBASE));
1105: DV(pageDir);
1106: DV(ptable1_v);
1107: ptable1_v[0x000] = codeseg | SEG_SRW;
1108: #if USE_NDATA
1109: for (i = 0; i < NDATA; i++)
1110: ptable1_v[0x001+i] = dataseg[i] | SEG_SRW;
1111: #else
1112: ptable1_v[0x001] = dataseg | SEG_SRW;
1113: #endif
1114: ptable1_v[0x1FF] = stackseg| SEG_SRW;
1115:
1116: /*
1117: * This ram disk stuff should go away once the scheme
1118: * for allocating pieces of virtual memory space is in place.
1119: */
1120: for (ptoff = btosrd(RAM0) & 0x3ff;
1121: ptoff < (btosrd(RAM0 + 2 * RAMSIZE) & 0x3ff); ++ptoff) {
1122: ramseg = clickseg(*--sysmem.pfree); /* 5.c.i */
1123: pageDir[ptoff] = ramseg | DIR_RW;
1124: ptable1_v[ptoff] = ramseg | SEG_SRW;
1125: }
1126:
1127: ptable1_v[0x3FF] = sysseg | SEG_SRW;
1128:
1129: CHIRP('6');
1130:
1131: /*
1132: * 7.
1133: * b. map kernel code and data
1134: * map ^ to:
1135: * c. level 0 page table
1136: * d. level 1 page table
1137: * e. I/O segments (video RAM, ...)
1138: */
1139:
1140: ptable1_v = (long *)(sysseg + ctob(SBASE-PBASE)); /* 7.b */
1141: DV(ptable1_v);
1142: for (i = PBASE; i <sysmem.lo; i++)
1143: ptable1_v[i-PBASE] = clickseg(i) | SEG_SRW;
1144:
1145: ptable1_v[0x3FE] = clickseg(PTABLE0_P) | SEG_SRW; /* 7.c */
1146: ptable1_v[0x3FD] = ptable1 | SEG_SRW; /* 7.d */
1147:
1148: init_phy_seg(ptable1_v, ROM-SBASE, 0x0000F0000); /* 7.e. */
1149: init_phy_seg(ptable1_v, VIDEOa-SBASE,0x0000B0000);
1150: init_phy_seg(ptable1_v, VIDEOb-SBASE,0x0000B8000);
1151:
1152: CHIRP('7');
1153:
1154: /*
1155: * 8. allocate and map U area
1156: */
1157:
1158: uinit.s_flags = SFSYST|SFCORE;
1159: uinit.s_size = UPASIZE;
1160: uinit.s_vmem = c_alloc(btoc(UPASIZE));
1161: ptable1_v[0x3FF] = *uinit.s_vmem | SEG_SRW;
1162: procq.p_segp[SIUSERP] = &uinit;
1163:
1164: CHIRP('8');
1165:
1166: /*
1167: * 9. make FFC00000 and 00002000 map to the same address
1168: * to prevent the prefetch after the instruction turning on
1169: * paging from causing a page fault
1170: */
1171: ptable1_v = (long *)(codeseg + ctob(SBASE-PBASE));
1172: DV(ptable1_v);
1173: ptable1_v[PBASE] = clickseg(PBASE) | SEG_SRW;
1174:
1175: CHIRP('9');
1176:
1177: /*
1178: * 10. load page table base address into MMU
1179: * fix up the interrupt vectors
1180: */
1181: mmuupdnR0();
1182: CHIRP('U');
1183: idtinit();
1184: CHIRP('I');
1185: }
1186:
1187: typedef struct
1188: {
1189: unsigned short off_lo;
1190: unsigned short seg;
1191: unsigned short flags;
1192: unsigned short off_hi;
1193: } IDT;
1194:
1195: /*
1196: * ldtinit()
1197: *
1198: * Fix up descriptors which are hard to create properly at compile/link time.
1199: * Apply to idt and ldt.
1200: *
1201: * Swap 16-bit words at descriptor+2, descriptor+6.
1202: */
1203: void
1204: idtinit()
1205: {
1206: extern IDT idt[], idtend[];
1207: extern IDT ldt[], ldtend[];
1208: extern IDT gdtFixBegin[], gdtFixEnd[];
1209:
1210: register IDT *ip;
1211: register unsigned short tmp;
1212:
1213: for (ip = idt; ip < idtend; ip++) {
1214: tmp = ip->off_hi;
1215: ip->off_hi = ip->seg;
1216: ip->seg = tmp;
1217: }
1218:
1219: for (ip = ldt; ip < ldtend; ip++) {
1220: tmp = ip->off_hi;
1221: ip->off_hi = ip->seg;
1222: ip->seg = tmp;
1223: }
1224:
1225: for (ip = gdtFixBegin; ip < gdtFixEnd; ip++) {
1226: tmp = ip->off_hi;
1227: ip->off_hi = ip->seg;
1228: ip->seg = tmp;
1229: }
1230: }
1231:
1232: void
1233: init_phy_seg(ptable1_v, addr, base)
1234: long *ptable1_v;
1235: {
1236: register int i;
1237:
1238: for (i=0; i<btoc(0x10000); i++) {
1239: ptable1_v[addr+i] = base | SEG_SRW;
1240: base += NBPC;
1241: }
1242: }
1243:
1244: /*
1245: * Load up segmentation registers.
1246: */
1247: SR ugmtab[NUSEG];
1248:
1249: void
1250: segload()
1251: {
1252: register int i;
1253: register SR *start;
1254:
1255: /*
1256: * 1. unprogram the currently active UGM user segments
1257: * reset ugmtab
1258: */
1259: for (start = &ugmtab[1]; start < &ugmtab[NUSEG]; start++) {
1260: if (start->sr_segp)
1261: unload(start);
1262: start->sr_segp = 0;
1263: }
1264:
1265: /*
1266: * 2. Load each segment in the p->p_region list into the MMU
1267: * Remember values in ugmtab.
1268: */
1269: start = &ugmtab[1];
1270: for (i = 1; i < NUSEG; i++) {
1271: if (u.u_segl[i].sr_segp) {
1272: *start = u.u_segl[i];
1273: switch (i) {
1274: case SIPDATA:
1275: if (u.u_segl[SISTACK].sr_base)
1276: start->sr_size = min(start->sr_size,
1277: (long)u.u_segl[SISTACK].sr_base-
1278: u.u_segl[SISTACK].sr_size);
1279: break;
1280: case SISTACK:
1281: start->sr_base -= start->sr_size;
1282: break;
1283: }
1284:
1285: start->sr_segp = 0;
1286: if (SELF->p_segp[i]) {
1287: start->sr_segp = SELF->p_segp[i];
1288: doload(start);
1289: }
1290: start++;
1291: }
1292: }
1293:
1294: /* 3. Update shm segment information. */
1295: shmLoad();
1296: }
1297:
1298: SR *
1299: loaded(pp)
1300: register cseg_t *pp;
1301: {
1302: register SR *start;
1303:
1304: for (start = ugmtab; start < ugmtab + NUSEG; start++) {
1305: if (start->sr_segp && start->sr_segp->s_vmem == pp) {
1306: return start;
1307: }
1308: }
1309: return 0;
1310: }
1311:
1312: MAKESR(r0stk, _r0stk);
1313: extern int tss_sp0;
1314:
1315: /*
1316: * General initialization
1317: */
1318: void
1319: i8086()
1320: {
1321: unsigned csize, isize, ssize, allsize;
1322: caddr_t base;
1323: unsigned int calc_mem, boost;
1324:
1325: /* This is the first C code executed after paging is turned on. */
1326:
1327: workPoolInit();
1328:
1329: /*
1330: * Allocate contiguous physical memory if PHYS_MEM is patched
1331: * to a nonzero value.
1332: */
1333: if (PHYS_MEM) {
1334: physMem.sr_size = (PHYS_MEM+NBPC-1)&~(NBPC-1);
1335: valloc(&physMem);
1336: physMemInit();
1337: }
1338:
1339: /*
1340: * Allocate a click for ring 0 stack.
1341: */
1342: r0stk.sr_size = NBPC;
1343: valloc(&r0stk);
1344: tss_sp0 = r0stk.sr_base + NBPC;
1345:
1346: /*
1347: * calc_mem is used for autosizing buffer cache and kalloc pool.
1348: * It is total_mem, limited below by 1 meg and above by 12 meg.
1349: * The upper limit is a temporary move to allow booting on 16 Meg
1350: * systems.
1351: *
1352: * "boost" is used in autosizing buffer cache and kalloc pool.
1353: * It is the number of megabytes of calc_mem above 1 meg, i.e.,
1354: * a number between 0 and 11.
1355: */
1356: if (total_mem < ONE_MEG)
1357: calc_mem = ONE_MEG;
1358: else if (total_mem > 12 * ONE_MEG)
1359: calc_mem = 12 * ONE_MEG;
1360: else
1361: calc_mem = total_mem;
1362:
1363: boost = (calc_mem - ONE_MEG) / ONE_MEG;
1364:
1365: /*
1366: * If the number of cache buffers was not explicitly set (i.e., !0)
1367: * then calculate the number of buffers using the simple heuristic:
1368: * 128 minimum + 400 per MB of available RAM (i.e., after 1MB)
1369: */
1370: if (NBUF == 0)
1371: NBUF = 128 + (400 * boost);
1372:
1373: /*
1374: * Calculate NHASH as the next lower prime number from NBUF.
1375: */
1376: NHASH = nlp(NBUF);
1377:
1378: /*
1379: * If the amount of kalloc() space was not explicitly set (i.e., !0)
1380: * then calculate using the simple heuristic:
1381: * 64k minimum + 32k per MB of available RAM (i.e., after 1MB)
1382: */
1383: if (ALLSIZE == 0)
1384: ALLSIZE = 65536 + (32768 * boost);
1385:
1386: blockp.sr_size = NBUF*BSIZE;
1387: valloc(&blockp);
1388:
1389: allocp.sr_size= allsize = NBUF*sizeof(BUF) + ALLSIZE;
1390: #if USE_SLOT
1391: allocp.sr_size += ssize = NSLOT * (sizeof(int) + slotsz);
1392: #else
1393: ssize = 0;
1394: #endif
1395: allocp.sr_size += isize = NINODE* sizeof(INODE);
1396: allocp.sr_size += csize = NCLIST* sizeof(CLIST);
1397: valloc(&allocp);
1398: base = allocp.sr_base;
1399: allkp = setarena(base, allsize);
1400: base += allsize;
1401: #if USE_SLOT
1402: slotp = (int *)base;
1403: base += ssize;
1404: #endif
1405: inodep = (INODE*) base;
1406: base += isize;
1407: clistp = (paddr_t)base;
1408: }
1409:
1410: /*
1411: * Allocate srp->sr_size bytes of physical memory, and map it into
1412: * virtual memory space. At the end, the struct at srp will describe
1413: * the new segment.
1414: */
1415: void
1416: valloc(srp)
1417: SR *srp;
1418: {
1419: register int npage;
1420:
1421: /*
1422: * If we've run out of virtual memory space, panic().
1423: *
1424: * A more graceful solution is needed, but valloc() does
1425: * not provide a return value.
1426: */
1427: if (sysmem.vaddre + srp->sr_size > MAX_VADDR) {
1428: panic("valloc: out of virtual memory space");
1429: }
1430:
1431: npage = btoc(srp->sr_size);
1432:
1433: srp->sr_base = sysmem.vaddre;
1434: srp->sr_segp->s_size = srp->sr_size;
1435: srp->sr_segp->s_vmem = c_alloc(npage);
1436: srp->sr_segp->s_flags = SFSYST|SFCORE;
1437: doload(srp);
1438:
1439: sysmem.vaddre += ctob(npage);
1440: }
1441:
1442: /*
1443: * See if the given process may fit in core.
1444: */
1445: int
1446: testcore(pp)
1447: register PROC *pp;
1448: {
1449: return 1;
1450: }
1451:
1452: /*
1453: * Calculate segmentation for a
1454: * new program. If there is a stack segment
1455: * present merge it into the data segment and
1456: * relocate the argument list.
1457: * Make sure that the changes are reflected in the u.u_segl array
1458: * which sproto sets up.
1459: */
1460: int
1461: mproto()
1462: {
1463: return 1;
1464: }
1465:
1466: int
1467: accdata(base, count)
1468: unsigned base, count;
1469: {
1470: SR *srp;
1471:
1472: srp = &u.u_segl[SIPDATA];
1473: return base>=srp->sr_base && base+count <= srp->sr_base+srp->sr_size;
1474: }
1475:
1476: int
1477: accstack(base, count)
1478: unsigned base;
1479: {
1480: SR *srp;
1481:
1482: srp = &u.u_segl[SISTACK];
1483: return base>=srp->sr_base-srp->sr_size && base+count<=srp->sr_base;
1484: }
1485:
1486: int
1487: acctext(base, count)
1488: unsigned base;
1489: {
1490: SR *srp;
1491:
1492: srp = &u.u_segl[SISTEXT];
1493: return base>=srp->sr_base && base+count <= srp->sr_base+srp->sr_size;
1494: }
1495:
1496: printhex(v, max)
1497: unsigned long v;
1498: {
1499: register int i;
1500:
1501: for (i = max-1; i>=0; --i)
1502: putchar(digtab[(v >> (i*4)) & 0xF]);
1503: }
1504:
1505: /* Read a 16 byte number from the CMOS. */
1506: unsigned int
1507: read16_cmos(addr)
1508: unsigned int addr;
1509: {
1510: unsigned char read_cmos();
1511:
1512: return((read_cmos(addr+1)<<8) + read_cmos(addr));
1513: } /* read16_cmos() */
1514:
1515: int
1516: c_grow(sp, new_bytes)
1517: SEG *sp;
1518: int new_bytes;
1519: {
1520: register int i;
1521: register cseg_t *pp;
1522: int new_clicks, pno, nsize, old_clicks;
1523: SR *srp;
1524:
1525: T_PIGGY(0x8000000, printf("c_grow(sp: %x, new: %x)", sp, new_bytes));
1526:
1527: new_clicks = btoc(new_bytes);
1528: old_clicks = btoc(sp->s_size);
1529:
1530: if (new_clicks == old_clicks) {
1531: goto ok_c_grow;
1532: }
1533:
1534: if (new_clicks < old_clicks) {
1535: printf("%s:can't contract segment\n",u.u_comm);
1536: goto no_c_grow;
1537: }
1538:
1539: if (new_clicks - old_clicks > allocno()) {
1540: goto no_c_grow;
1541: }
1542:
1543: T_PIGGY(0x8000000, printf("nc: %x, oc: %x,",new_clicks,old_clicks));
1544:
1545: /*
1546: * Allocate a new descriptor vector if necessary.
1547: * pp is the element corresponding to the virtual address
1548: * "0"(sr_base)
1549: */
1550: pp = sp->s_vmem;
1551: nsize = areasize(new_clicks);
1552: if (nsize != areasize(old_clicks)
1553: && !(pp = (cseg_t*)arealloc(new_clicks))) {
1554: T_PIGGY(0x8000000,
1555: printf("Can not allocate new descriptor."));
1556: goto no_c_grow;
1557: }
1558:
1559: T_PIGGY(0x8000000, printf("new pp: %x", pp));
1560:
1561: if (0 != (srp = loaded(sp->s_vmem))) {
1562: T_PIGGY(0x8000000, printf("unloading srp: %x, ", srp));
1563: unload(srp);
1564: srp->sr_segp = 0;
1565: }
1566:
1567: /*
1568: * Allocate new descriptors.
1569: */
1570: T_PIGGY(0x8000000, printf("new desc: ["));
1571: for (i = old_clicks; i < new_clicks; i++) {
1572: pno = *--sysmem.pfree;
1573: pp[i] = clickseg(pno) | SEG_RW;
1574: T_PIGGY(0x8000000, printf("%x, ", pp[i]));
1575: }
1576: T_PIGGY(0x8000000, printf("]"));
1577:
1578: /*
1579: * Copy unchanged descriptors and free old vector if necessary.
1580: */
1581: if (pp != sp->s_vmem) {
1582: T_PIGGY(0x8000000, printf("old desc: ["));
1583: for (i = 0; i < old_clicks; i++) {
1584: pp[i] = sp->s_vmem[i];
1585: T_PIGGY(0x8000000, printf("%x, ", pp[i]));
1586: }
1587: T_PIGGY(0x8000000, printf("]"));
1588: areafree((BLOCKLIST*)sp->s_vmem, old_clicks);
1589: }
1590:
1591: sp->s_vmem = pp;
1592:
1593: /*
1594: * clear the added clicks
1595: *
1596: * MAPIO macro - convert array of page descriptors, offset
1597: * into system global address.
1598: */
1599: T_PIGGY(0x8000000, printf("dmaclear(%x, %x, 0)",
1600: ctob(new_clicks - old_clicks),
1601: MAPIO(sp->s_vmem, ctob(old_clicks))
1602: )); /* T_PIGGY() */
1603:
1604: dmaclear (ctob (new_clicks - old_clicks),
1605: MAPIO(sp->s_vmem, ctob(old_clicks)));
1606:
1607: ok_c_grow:
1608: return 0;
1609:
1610: no_c_grow:
1611: return -1;
1612: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.