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