![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to seg.c 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 / coh.386|
Return to seg.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386 |
1.1 root 1: /* $Header: /v4a/coh/RCS/seg.c,v 1.2 92/01/06 12:00:15 hal Exp $ */
2: /* (lgl-
3: * The information contained herein is a trade secret of Mark Williams
4: * Company, and is confidential information. It is provided under a
5: * license agreement, and may be copied or disclosed only under the
6: * terms of that agreement. Any reproduction or disclosure of this
7: * material without the express written authorization of Mark Williams
8: * Company or persuant to the license agreement is unlawful.
9: *
10: * COHERENT Version 2.3.37
11: * Copyright (c) 1982, 1983, 1984.
12: * An unpublished work by Mark Williams Company, Chicago.
13: * All rights reserved.
14: -lgl) */
15: /*
16: * Coherent.
17: * Segment manipulation.
18: *
19: */
20: #include <sys/coherent.h>
21: #include <sys/buf.h>
22: #include <errno.h>
23: #include <sys/ino.h>
24: #include <sys/inode.h>
25: #include <sys/proc.h>
26: #include <sys/sched.h>
27: #include <sys/seg.h>
28: #include <a.out.h>
29:
30:
31: #define min(a, b) ((a) < (b) ? (a) : (b))
32:
33: /*
34: * Initialisation code.
35: */
36: seginit()
37: {
38: /*
39: * Create empty circular-list of memory segments.
40: */
41: segmq.s_forw = &segmq;
42: segmq.s_back = &segmq;
43:
44: /*
45: * Create empty circular-list of disk segments.
46: */
47: segdq.s_forw = &segdq;
48: segdq.s_back = &segdq;
49: }
50:
51: /*
52: * Given an inode, `ip', and flags, `ff', describing a segment associated
53: * with the inode, see if the segment already exists and if so, return a
54: * copy. If the segment does not exist, allocate the segment having size
55: * `ss', and read the segment using the inode at seek offset `dq' with a
56: * size of `ds'.
57: */
58: SEG *
59: ssalloc(ip, ff, ss)
60: register INODE *ip;
61: {
62: register SEG *sp;
63: register int f;
64:
65: lock(seglink);
66: f = ff & (SFSHRX|SFTEXT);
67:
68: /*
69: * Look for the segment in the memory queue.
70: */
71: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) {
72: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) {
73: unlock(seglink);
74: if ((sp = segdupl(sp)) != NULL)
75: segfinm(sp);
76: return (sp);
77: }
78: }
79:
80: /*
81: * Look for the segment on the disk queue.
82: */
83: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) {
84: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) {
85: unlock(seglink);
86: if ((sp = segdupl(sp)) != NULL)
87: segfinm(sp);
88: return (sp);
89: }
90: }
91: unlock(seglink);
92:
93: /*
94: * Allocate and create the segment.
95: */
96: return salloc(roundu(ss, NBPC), ff);
97: }
98:
99: /*
100: * Given a pointer to a newly created process, copy all of our segments
101: * into the given process.
102: */
103: segadup(cpp)
104: register PROC *cpp;
105: {
106: register SEG *sp;
107: register int n;
108: register PROC *pp;
109:
110: pp = SELF;
111: cpp->p_flags |= PFSWIO;
112: for (n=0; n<NUSEG; n++) {
113: if ((sp=pp->p_segp[n]) == NULL)
114: continue;
115: if ((sp=segdupl(sp)) == NULL)
116: break;
117: cpp->p_segp[n] = sp;
118: if ((sp->s_flags&SFCORE) == 0)
119: cpp->p_flags &= ~PFCORE;
120: }
121: if (n < NUSEG) {
122: while (n > 0) {
123: if ((sp=cpp->p_segp[--n]) != NULL) {
124: cpp->p_segp[n] = NULL;
125: sfree(sp);
126: }
127: }
128: }
129: cpp->p_flags &= ~PFSWIO;
130: return (n);
131: }
132:
133: /*
134: * Duplicate a segment.
135: */
136: SEG *
137: segdupl(sp)
138: register SEG *sp;
139: {
140: register SEG *sp1;
141:
142: if ((sp->s_flags&SFSHRX) != 0) {
143: sp->s_urefc++;
144: sp->s_lrefc++;
145: return (sp);
146: }
147: if ((sp->s_flags&SFCORE) == 0)
148: panic("Cannot duplicate non shared swapped segment");
149: if ((sp1=salloc(sp->s_size, sp->s_flags|SFNSWP|SFNCLR)) == NULL)
150: sp1 = segdupd(sp);
151: else {
152: sp1->s_flags = sp->s_flags;
153: dmacopy( btoc(sp->s_size), sp->s_vmem, sp1->s_vmem) ;
154: }
155: return sp1;
156: }
157:
158: /*
159: * Allocate a segment `bytes_wanted' bytes long.
160: * `flags' contains some pseudo flags.
161: */
162: SEG *
163: salloc(bytes_wanted, flags)
164: int bytes_wanted, flags;
165: {
166: register SEG *sp;
167: register int r;
168:
169: r = (flags & (SFSYST|SFTEXT|SFSHRX|SFDOWN)) | SFCORE;
170:
171: /*
172: #ifdef _I386
173: bytes_wanted += (sizeof(char *) - 1);
174: bytes_wanted &= ~(sizeof(char *) - 1);
175: #else
176: bytes_wanted += (BSIZE - 1);
177: bytes_wanted &= ~(BSIZE - 1);
178: #endif
179: */
180:
181: lock(seglink);
182: sp = smalloc(bytes_wanted);
183: unlock(seglink);
184:
185: if (sp) {
186: sp->s_flags = r;
187: } else {
188: #if 0
189: /* no room now - let the swapper try to grow it */
190: if (flags & SFNSWP)
191: return 0;
192: if ((sp=kalloc(sizeof(SEG))) == NULL)
193: return 0;
194: sp->s_forw = sp;
195: sp->s_back = sp;
196: sp->s_flags = r;
197: sp->s_urefc = 1;
198: sp->s_lrefc = 1;
199: if (segsext(sp, bytes_wanted) == NULL) {
200: kfree(sp);
201: return 0;
202: }
203: #else
204: return 0;
205: #endif
206: }
207: if ((flags&SFNCLR) == 0)
208: dmaclear(sp->s_size, MAPIO(sp->s_vmem, 0), 0L);
209: return sp;
210: }
211:
212: /*
213: * Free the given segment pointer.
214: */
215: sfree(sp)
216: register SEG *sp;
217: {
218: register INODE *ip;
219:
220: if ( sp->s_urefc != 1 ) {
221: sp->s_urefc--;
222: sp->s_lrefc--;
223: return;
224: }
225:
226: lock(seglink);
227: --sp->s_lrefc;
228: if (--sp->s_urefc != 0) {
229: unlock(seglink);
230: return;
231: }
232:
233: sp->s_back->s_forw = sp->s_forw;
234: sp->s_forw->s_back = sp->s_back;
235:
236: c_free(sp->s_vmem, btoc(sp->s_size));
237:
238: unlock(seglink);
239:
240: if (sp->s_lrefc != 0)
241: panic("Bad segment count");
242: if ((ip=sp->s_ip) != NULL)
243: ldetach(ip);
244: kfree(sp);
245: }
246:
247: /*
248: * Grow or shrink the segment `sp' so that it has size `new_bytes' bytes.
249: *
250: * downward growing segments not done yet!
251: */
252: seggrow(sp, new_bytes)
253: register SEG *sp;
254: unsigned int new_bytes;
255: {
256: register SEG *sp1;
257: register int dowflag;
258: unsigned int old_bytes, common_clicks;
259:
260: dowflag = sp->s_flags & SFDOWN;
261: old_bytes = sp->s_size;
262:
263: T_HAL(0x20, goto dont_c_grow);
264: /*
265: * If we want a larger segment AND c_grow() succeeds
266: * boost segment size to new_bytes
267: */
268: if (new_bytes >= old_bytes && c_grow(sp, new_bytes)==0) {
269: T_HAL(0x100, printf("c_grow(%d) ", new_bytes));
270: sp->s_size = new_bytes;
271: dmaclear(new_bytes - old_bytes,
272: MAPIO(sp->s_vmem, old_bytes), 0);
273: return 1;
274: }
275: dont_c_grow:
276:
277: if (sp1 = salloc(new_bytes, (sp->s_flags|SFNSWP|SFNCLR))) {
278: T_HAL(0x100, printf("salloc(%d) ", new_bytes));
279: if (dowflag == 0) {
280: common_clicks = btoc(min(new_bytes, old_bytes));
281: dmacopy(common_clicks, sp->s_vmem, sp1->s_vmem);
282: if (new_bytes > old_bytes) {
283: dmaclear(new_bytes - old_bytes,
284: MAPIO(sp1->s_vmem, old_bytes), 0);
285: }
286: } else
287: panic("downflag");
288: lock(seglink);
289: c_free(sp->s_vmem, btoc(old_bytes));
290: satcopy(sp, sp1);
291: unlock(seglink);
292:
293: return 1;
294: }
295:
296: #if 1
297: return 0;
298: #else
299: /*
300: * Last chance. Extend the segment by swapping it.
301: */
302: if (!segsext(sp, new_bytes))
303: return 0;
304:
305: if (dowflag == 0) {
306: if (new_bytes > old_bytes)
307: dmaclear(new_bytes - old_bytes, MAPIO(sp->s_vmem,old_bytes), 0);
308: } else
309: panic("downflag");
310:
311: return (1);
312: #endif
313: }
314:
315: /*
316: * Given a segment pointer, `sp' and a segment size, grow the given segment
317: * to the given size.
318: */
319: segsize(sp, s2)
320: register SEG *sp;
321: vaddr_t s2;
322: {
323: register vaddr_t s1;
324:
325: s1 = (vaddr_t) sp->s_size;
326: if (s2 == 0 || seggrow(sp, (off_t)s2) == 0) {
327: SET_U_ERROR( ENOMEM, "can not grow segment" );
328: return;
329: }
330: if (sproto(0) == 0) {
331: if (seggrow(sp, (off_t)s1)==0 || sproto(0)==0) {
332: T_PIGGY( 0x2000000, printf("auto SEGV\n"); );
333: sendsig(SIGSEGV, SELF);
334: }
335: }
336: segload();
337: }
338:
339: /*
340: * Grow the segment `sp1' to the size `s' in bytes by swapping it out
341: * and back in. The segment may not be locked.
342: */
343: SEG *
344: segsext(sp1, s)
345: register SEG *sp1;
346: register off_t s;
347: {
348: #if 0
349: register SEG *sp2;
350:
351: #if MONITOR
352: if (swmflag)
353: printf("Segsext(%p, %u)\n", SELF, SELF->p_pid);
354: #endif
355: if (sexflag == 0) {
356: SET_U_ERROR( ENOMEM, "can not extend, swapping is off" );
357: return (NULL);
358: }
359: lock(seglink);
360: if ((sp2=sdalloc(s)) == NULL) {
361: unlock(seglink);
362: return (NULL);
363: }
364: unlock(seglink);
365: sp1->s_lrefc++;
366: if (sp1->s_size != 0)
367: swapio(1, MAPIO(sp1->s_vmem, 0), sp2->s_daddr, sp1->s_size);
368: lock(seglink);
369: satcopy(sp1, sp2);
370: unlock(seglink);
371: sp1->s_flags &= ~SFCORE;
372: sp1->s_lrefc--;
373: segfinm(sp1);
374: return (sp1);
375: #else
376: return 0;
377: #endif
378: }
379:
380: /*
381: * Force the given segment to be in memory. One can only force
382: * one segment to be in memory at a time.
383: */
384: segfinm(sp)
385: register SEG *sp;
386: {
387: register PROC *pp;
388: register int s;
389:
390: if ((sp->s_flags&SFCORE) != 0)
391: return;
392: pp = SELF;
393: sp->s_urefc++;
394: sp->s_lrefc++;
395: pp->p_segp[SIAUXIL] = sp;
396: pp->p_flags &= ~PFCORE;
397: #ifndef QWAKEUP
398: s = sphi();
399: #endif
400: setrun(pp);
401: dispatch();
402: #ifndef QWAKEUP
403: spl(s);
404: #endif
405: pp->p_segp[SIAUXIL] = NULL;
406: sfree(sp);
407: }
408:
409: /*
410: * Make a copy of the segment `sp1' which is in memory by writing
411: * it out to disk.
412: */
413: SEG *
414: segdupd(sp1)
415: register SEG *sp1;
416: {
417: register SEG *sp2;
418:
419: if (sexflag == 0)
420: return (NULL);
421: lock(seglink);
422: if ((sp2=sdalloc(sp1->s_size)) == NULL) {
423: unlock(seglink);
424: return (NULL);
425: }
426: sp1->s_lrefc++;
427: unlock(seglink);
428: swapio(1, MAPIO(sp1->s_vmem, 0), sp2->s_daddr, sp1->s_size);
429: sp1->s_lrefc--;
430: sp2->s_flags = sp1->s_flags & ~SFCORE;
431: sp2->s_size = sp1->s_size;
432: return (sp2);
433: }
434:
435: /*
436: * Given a flag, a physical core address, a disk address and a count in
437: * bytes, perform an I/O operation between core and disk. If `flag' is
438: * set, the transfer is to the disk otherwise it is to memory. As you may
439: * have guessed, this is used by the swapper.
440: *
441: */
442: swapio(f, p, d, n)
443: paddr_t p;
444: daddr_t d;
445: off_t n;
446: {
447: register BUF * bp;
448: register SEG * sp;
449: register int s;
450: register int nb;
451:
452: #if MONITOR
453: if (swmflag > 1)
454: printf("swapio(%s,%x,%x,%x)\n",f?"out":"in",(int)p,(int)d,n);
455: #endif
456: if (d < swapbot || d+(n/BSIZE) > swaptop)
457: panic("Swapio bad parameter");
458:
459: bp = &swapbuf;
460: lock(bp->b_gate);
461: SELF->p_flags |= PFSWIO;
462: bp->b_paddr = p;
463:
464: while (n != 0) {
465: nb = (n > SCHUNK) ? SCHUNK : n;
466: /*
467: * Prevent I/O transfer from crossing 64 Kbyte boundary.
468: */
469: if ( (p & 0xFFFF0000L) != ((p+nb) & 0xFFFF0000L) )
470: nb = 0x10000L - (p & 0x0000FFFFL);
471: bp->b_flag = BFNTP;
472: bp->b_req = f ? BWRITE : BREAD;
473: bp->b_dev = swapdev;
474: bp->b_bno = d;
475: bp->b_paddr = p;
476: bp->b_count = nb;
477: s = sphi();
478: dblock(swapdev, bp);
479: while ((bp->b_flag&BFNTP) != 0) {
480: v_sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO, "swap");
481: /* Sleeping in the swapper. */
482: }
483: spl(s);
484: if ((bp->b_flag&BFERR) != 0)
485: panic("Swapio error");
486: bp->b_vaddr += nb;
487: p += nb;
488: d += nb / BSIZE;
489: n -= nb;
490: }
491: unlock(bp->b_gate);
492: SELF->p_flags &= ~PFSWIO;
493: }
494:
495: /*
496: * Make the segment descriptor pointed to by `sp1' have the attributes
497: * of `sp2' including it's position in the segment queue and release
498: * `sp2'. `seglink' must be locked when this routine is called.
499: */
500: satcopy(sp1, sp2)
501: register SEG *sp1;
502: register SEG *sp2;
503: {
504: sp1->s_back->s_forw = sp1->s_forw;
505: sp1->s_forw->s_back = sp1->s_back;
506: sp2->s_back->s_forw = sp1;
507: sp1->s_back = sp2->s_back;
508: sp2->s_forw->s_back = sp1;
509: sp1->s_forw = sp2->s_forw;
510: sp1->s_daddr = sp2->s_daddr;
511: sp1->s_size = sp2->s_size;
512: sp1->s_vmem = sp2->s_vmem;
513: kfree(sp2);
514: }
515:
516: /*
517: * Allocate a segment on disk that is `n' bytes long.
518: * The `seglink' gate should be locked before this routine is called.
519: */
520: SEG *
521: sdalloc( s )
522: off_t s;
523: {
524: register SEG *sp1;
525: register SEG *sp2;
526: register daddr_t d;
527: register daddr_t d1;
528: register daddr_t d2;
529:
530: d = s / BSIZE;
531: d1 = swapbot;
532: sp1 = &segdq;
533: do {
534: if (d1 >= swaptop)
535: return (NULL);
536: if ((sp1=sp1->s_forw) != &segdq)
537: d2 = sp1->s_daddr;
538: else
539: d2 = swaptop;
540: if (d2-d1 >= d) {
541: if ((sp2=kalloc(sizeof(SEG))) == NULL)
542: return (NULL);
543: sp1->s_back->s_forw = sp2;
544: sp2->s_back = sp1->s_back;
545: sp1->s_back = sp2;
546: sp2->s_forw = sp1;
547: sp2->s_urefc = 1;
548: sp2->s_lrefc = 1;
549: sp2->s_size = s;
550: sp2->s_daddr = d1;
551: return (sp2);
552: }
553: d1 = sp1->s_daddr + (sp1->s_size / BSIZE);
554: } while (sp1 != &segdq);
555: return (NULL);
556: }
557:
558: /*
559: * Allocate a segment in memory that is `bytes_wanted' bytes long.
560: * The `seglink' gate should be locked before this routine is called.
561: *
562: * if successful, return allocated SEG *
563: * else, return 0
564: */
565: SEG *
566: smalloc(bytes_wanted)
567: off_t bytes_wanted;
568: {
569: register SEG *sp1;
570: register SEG *new_seg;
571: unsigned clicks_wanted;
572:
573: clicks_wanted = btoc(bytes_wanted);
574:
575: /*
576: * Estimate space needed for new segment and its overhead.
577: * Fail if not enough free RAM available.
578: */
579: if (countsize(clicks_wanted) > allocno())
580: return 0;
581: /*
582: * Allocate a new SEG struct to keep track of the segment, if possible.
583: */
584: if ((new_seg = kalloc(sizeof (SEG))) == NULL)
585: return 0;
586:
587: if ((new_seg->s_vmem = c_alloc(clicks_wanted)) == 0) {
588: kfree(new_seg);
589: return 0;
590: }
591:
592: /* link new_seg in at start of segmq */
593: sp1 = segmq.s_forw;
594: sp1->s_back->s_forw = new_seg;
595: new_seg->s_back = sp1->s_back;
596: sp1->s_back = new_seg;
597: new_seg->s_forw = sp1;
598:
599: new_seg->s_urefc = 1;
600: new_seg->s_lrefc = 1;
601: new_seg->s_size = bytes_wanted;
602:
603: return new_seg;
604: }
605:
606: /*
607: * Set up `SR' structure in user area from segments descriptors in
608: * process structure. Also set up the user segmentation registers.
609: */
610: sproto(xhp)
611: struct xechdr *xhp;
612: {
613: register int n;
614: register SEG *sp;
615:
616: for (n=0; n<NUSEG; n++) {
617: u.u_segl[n].sr_flag = u.u_segl[n].sr_size = 0;
618: u.u_segl[n].sr_segp = 0;
619: if ((sp=SELF->p_segp[n]) == NULL)
620: continue;
621: if (n == SIUSERP)
622: u.u_segl[n].sr_base = &u;
623: else {
624: if (xhp)
625: u.u_segl[n].sr_base = xhp->segs[n].mbase;
626: u.u_segl[n].sr_flag |= SRFPMAP;
627: }
628: if (n!=SISTEXT)
629: u.u_segl[n].sr_flag |= SRFDUMP;
630: if (n!=SIUSERP && n!=SISTEXT)
631: u.u_segl[n].sr_flag |= SRFDATA;
632: u.u_segl[n].sr_size = sp->s_size;
633: u.u_segl[n].sr_segp = sp;
634: }
635: return (mproto());
636: }
637:
638: /*
639: * Search for a busy text inode.
640: */
641: sbusy(ip)
642: register INODE *ip;
643: {
644: register SEG *sp;
645:
646: lock(seglink);
647: /*
648: * Look for the segment in the memory queue.
649: */
650: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) {
651: if (sp->s_ip==ip
652: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) {
653: unlock(seglink);
654: return (1);
655: }
656: }
657:
658: /*
659: * Look for the segment on the disk queue.
660: */
661: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) {
662: if (sp->s_ip==ip
663: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) {
664: unlock(seglink);
665: return (1);
666: }
667: }
668: unlock(seglink);
669: return 0;
670: }
671:
672: /*
673: * Segment consistency checks for the paranoid.
674: segchk()
675: {
676: register SEG *sp;
677: register int nbad;
678: off_t s;
679: daddr_t d;
680:
681: nbad = 0;
682: sp = &segdq;
683: d = swapbot;
684: while ((sp=sp->s_forw) != &segdq) {
685: if (sp->s_daddr < d)
686: nbad += badseg("disk", (int)sp->s_daddr, 0);
687: d = sp->s_daddr + (sp->s_size / BSIZE);
688: }
689: if (swaptop < d)
690: nbad += badseg("disk", sp->s_back->s_daddr, sp->s_back->s_size);
691: }
692:
693: badseg(t, b, s)
694: char *t;
695: daddr_t b;
696: off_t s;
697: {
698: printf( "Bad %s segment at %X of len %X\n", t, b, s );
699: return (1);
700: }
701: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.