![[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 / kernel / USRSRC / coh|
Return to seg.c CVS log | Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / coh |
1.1 root 1: /* $Header: /newbits/kernel/USRSRC/coh/RCS/seg.c,v 1.4 91/07/24 07:51:50 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: * $Log: seg.c,v $
20: * Revision 1.4 91/07/24 07:51:50 bin
21: * update prov by hal
22: *
23: *
24: * Revision 1.1 88/03/24 16:14:20 src
25: * Initial revision
26: *
27: * 88/02/26 Allan Cornish /usr/src/sys/coh/seg.c
28: * swapio() now avoids 64 Kbyte page [dma] straddles.
29: *
30: * 88/01/22 Allan Cornish /usr/src/sys/coh/seg.c
31: * salloc() now invokes krunch(1000) if initial allocation fails.
32: * sfree() now invokes krunch(0).
33: *
34: * 88/01/21 Allan Cornish /usr/src/sys/coh/seg.c
35: * sfree() modified to eliminate critical race on ref cnts and segment gate.
36: * segfinm() now properly maintains segment reference counts.
37: *
38: * 87/11/13 Allan Cornish /usr/src/sys/coh/seg.c
39: * Support for protected mode segmentation added.
40: */
41: #include <sys/coherent.h>
42: #include <sys/buf.h>
43: #include <errno.h>
44: #include <sys/ino.h>
45: #include <sys/inode.h>
46: #include <sys/proc.h>
47: #include <sys/sched.h>
48: #include <sys/seg.h>
49: #include <sys/uproc.h>
50:
51: /*
52: * Initialisation code.
53: */
54: seginit()
55: {
56: /*
57: * Create empty circular-list of memory segments.
58: */
59: segmq.s_forw = &segmq;
60: segmq.s_back = &segmq;
61:
62: /*
63: * Create empty circular-list of disk segments.
64: */
65: segdq.s_forw = &segdq;
66: segdq.s_back = &segdq;
67:
68: if ( holebot != holetop ) {
69: /*
70: * Define the I/O mem hole between low memory and extended mem.
71: * NOTE: Setting lrefc to urefc+1 stopx segment from moving.
72: */
73: segiom.s_paddr = holebot;
74: segiom.s_size = holetop - holebot;
75: segiom.s_flags = SFCORE | SFSYST;
76: segiom.s_urefc = 1;
77: segiom.s_lrefc = 2;
78:
79: /*
80: * Insert I/O memory segment into memory list.
81: */
82: segiom.s_forw = &segmq;
83: segiom.s_back = &segmq;
84: segmq.s_forw = &segiom;
85: segmq.s_back = &segiom;
86: }
87: }
88:
89: /*
90: * Given an inode, `ip', and flags, `ff', describing a segment associated
91: * with the inode, see if the segment already exists and if so, return a
92: * copy. If the segment does not exists, allocate the segment having size
93: * `ss', and read the segment using the inode at seek offset `dq' with a
94: * size of `ds'.
95: */
96: SEG *
97: ssalloc(rp, ip, ff, ss, dq, ds)
98: int *rp;
99: register INODE *ip;
100: fsize_t ss;
101: fsize_t dq;
102: fsize_t ds;
103: {
104: register SEG *sp;
105: register int f;
106:
107: *rp = -1;
108: if (ss == 0) {
109: *rp = 1;
110: return (NULL);
111: }
112: lock(seglink);
113: f = ff & (SFSHRX|SFTEXT);
114:
115: /*
116: * Look for the segment in the memory queue.
117: */
118: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) {
119: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) {
120: unlock(seglink);
121: if ((sp = segdupl(sp)) != NULL) {
122: segfinm(sp);
123: *rp = 1;
124: }
125: return (sp);
126: }
127: }
128:
129: /*
130: * Look for the segment on the disk queue.
131: */
132: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) {
133: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) {
134: unlock(seglink);
135: if ((sp = segdupl(sp)) != NULL) {
136: segfinm(sp);
137: *rp = 1;
138: }
139: return (sp);
140: }
141: }
142: unlock(seglink);
143:
144: /*
145: * Allocate and create the segment.
146: */
147: if ((sp=salloc(ss, ff)) == NULL)
148: return (NULL);
149: if (exsread(sp, ip, ds, dq, (fsize_t)0) == 0) {
150: sfree(sp);
151: return (NULL);
152: }
153: if ((ff&SFSHRX) != 0) {
154: sp->s_ip = ip;
155: ip->i_refc++;
156: }
157: *rp = 0;
158: return (sp);
159: }
160:
161: /*
162: * Given a pointer to a newly created process, copy all of our segments
163: * into the given process.
164: */
165: segadup(cpp)
166: register PROC *cpp;
167: {
168: register SEG *sp;
169: register int n;
170: register PROC *pp;
171:
172: pp = SELF;
173: cpp->p_flags |= PFSWIO;
174: for (n=0; n<NUSEG; n++) {
175: if ((sp=pp->p_segp[n]) == NULL)
176: continue;
177: if ((sp=segdupl(sp)) == NULL)
178: break;
179: cpp->p_segp[n] = sp;
180: if ((sp->s_flags&SFCORE) == 0)
181: cpp->p_flags &= ~PFCORE;
182: }
183: if (n < NUSEG) {
184: while (n > 0) {
185: if ((sp=cpp->p_segp[--n]) != NULL) {
186: cpp->p_segp[n] = NULL;
187: sfree(sp);
188: }
189: }
190: }
191: cpp->p_flags &= ~PFSWIO;
192: return (n);
193: }
194:
195: /*
196: * Duplicate a segment.
197: */
198: SEG *
199: segdupl(sp)
200: register SEG *sp;
201: {
202: register SEG *sp1;
203:
204: if ((sp->s_flags&SFSHRX) != 0) {
205: sp->s_urefc++;
206: sp->s_lrefc++;
207: return (sp);
208: }
209: if ((sp->s_flags&SFCORE) == 0)
210: panic("Cannot duplicate non shared swapped segment");
211: if ((sp1=salloc(sp->s_size, sp->s_flags|SFNSWP|SFNCLR)) == NULL)
212: sp1 = segdupd(sp);
213: else {
214: sp1->s_flags = sp->s_flags;
215: plrcopy( sp->s_paddr, sp1->s_paddr, sp->s_size );
216: }
217: return (sp1);
218: }
219:
220: /*
221: * Allocate a segment `n' bytes long. `f' contains some pseudo flags.
222: */
223: SEG *
224: salloc(n, f)
225: fsize_t n;
226: {
227: register SEG *sp;
228: register int r;
229:
230: r = (f&(SFSYST|SFHIGH|SFTEXT|SFSHRX|SFDOWN)) | SFCORE;
231: n += (BSIZE-1);
232: n &= ~(BSIZE-1);
233:
234: lock(seglink);
235: sp = sxalloc(n, f);
236: unlock(seglink);
237:
238: if ( sp == NULL ) {
239: krunch(1000);
240: lock(seglink);
241: sp = sxalloc(n, f);
242: unlock(seglink);
243: }
244:
245: if (sp != NULL) {
246: sp->s_flags = r;
247: vremap( sp );
248: }
249: else {
250: if ((f&SFNSWP) != 0)
251: return (NULL);
252: if ((sp=kalloc(sizeof(SEG))) == NULL)
253: return (NULL);
254: sp->s_forw = sp;
255: sp->s_back = sp;
256: sp->s_flags = r;
257: sp->s_urefc = 1;
258: sp->s_lrefc = 1;
259: if (segsext(sp, n) == NULL) {
260: kfree(sp);
261: return (NULL);
262: }
263: }
264: if ((f&SFNCLR) == 0)
265: pclear( sp->s_paddr, n );
266: return (sp);
267: }
268:
269: /*
270: * Free the given segment pointer.
271: */
272: sfree(sp)
273: register SEG *sp;
274: {
275: register INODE *ip;
276:
277: if ( sp->s_urefc != 1 ) {
278: sp->s_urefc--;
279: sp->s_lrefc--;
280: return;
281: }
282:
283: lock(seglink);
284: --sp->s_lrefc;
285: if (--sp->s_urefc != 0) {
286: unlock(seglink);
287: return;
288: }
289:
290: sp->s_back->s_forw = sp->s_forw;
291: sp->s_forw->s_back = sp->s_back;
292: unlock(seglink);
293:
294: if (sp->s_lrefc != 0)
295: panic("Bad segment count");
296: if ((ip=sp->s_ip) != NULL)
297: ldetach(ip);
298: vrelse( sp->s_faddr );
299: kfree(sp);
300: krunch(0);
301: }
302:
303: /*
304: * Grow or shrink the segment `sp' so that it has size `n'.
305: */
306: seggrow(sp, n)
307: register SEG *sp;
308: fsize_t n;
309: {
310: register SEG *sp1;
311: register fsize_t d;
312: register paddr_t pb;
313: register paddr_t nb;
314: register int dowflag;
315:
316: dowflag = sp->s_flags&SFDOWN;
317:
318: /*
319: * Size of new segment is smaller or the same size as the old
320: * segment.
321: */
322: lock(seglink);
323: d = n - sp->s_size;
324: if (n <= sp->s_size) {
325: sp->s_size = n;
326: if (dowflag)
327: sp->s_paddr -= d;
328:
329: vremap( sp );
330: unlock(seglink);
331: return (1);
332: }
333:
334: if ((sp1=sp->s_back) == &segmq)
335: pb = corebot;
336: else
337: pb = sp1->s_paddr + sp1->s_size;
338:
339: if ((sp1=sp->s_forw) == &segmq)
340: nb = coretop;
341: else
342: nb = sp1->s_paddr;
343:
344: /*
345: * If the segment does not grow down, see if there is enough
346: * space after the segment.
347: */
348: if (dowflag==0 && nb-sp->s_paddr>=n) {
349: pclear(sp->s_paddr+sp->s_size, d);
350: sp->s_size = n;
351: vremap( sp );
352: unlock(seglink);
353: return (1);
354: }
355:
356: /*
357: * If the segment grows down, see if there is enough space
358: * before the segment.
359: */
360: if (dowflag!=0 && sp->s_paddr+sp->s_size-pb>=n) {
361: sp->s_paddr -= d;
362: sp->s_size = n;
363: pclear( sp->s_paddr, d );
364: vremap( sp );
365: unlock(seglink);
366: return (1);
367: }
368:
369: /*
370: * Is there enough space in total counting the gaps on either
371: * side of us?
372: */
373: if (nb-pb >= n) {
374: if (dowflag == 0) {
375: plrcopy(sp->s_paddr, pb, sp->s_size);
376: pclear(pb+sp->s_size, d);
377: sp->s_paddr = pb;
378: } else {
379: prlcopy( sp->s_paddr, nb-sp->s_size, sp->s_size );
380: pclear(nb-n, d);
381: sp->s_paddr = nb-n;
382: }
383: sp->s_size = n;
384: vremap( sp );
385: unlock(seglink);
386: return (1);
387: }
388:
389: /*
390: * Try to allocate a segment somewhere else on the segment queue
391: * and copy ourselves there.
392: */
393: unlock(seglink);
394: if ((sp1=salloc((fsize_t)n, sp->s_flags|SFNSWP|SFNCLR)) != NULL) {
395: if (dowflag == 0) {
396: plrcopy(sp->s_paddr, sp1->s_paddr, sp->s_size);
397: pclear(sp1->s_paddr+sp->s_size, d);
398: } else {
399: plrcopy(sp->s_paddr, sp1->s_paddr+d, sp->s_size);
400: pclear(sp1->s_paddr, d);
401: }
402: lock(seglink);
403: satcopy(sp, sp1);
404: unlock(seglink);
405: return (1);
406: }
407:
408: /*
409: * Last chance. Extend the segment by swapping it.
410: */
411: if (segsext(sp, n) != NULL) {
412: if (dowflag == 0)
413: pclear(sp->s_paddr+n-d, d);
414: else {
415: prlcopy(sp->s_paddr, sp->s_paddr+d, n-d);
416: pclear(sp->s_paddr, d);
417: }
418: return (1);
419: }
420:
421: /*
422: * At least we tried.
423: */
424: return (0);
425: }
426:
427: /*
428: * Given a segment pointer, `sp' and a segment size, grow the given segment
429: * to the given size.
430: */
431: segsize(sp, s2)
432: register SEG *sp;
433: vaddr_t s2;
434: {
435: register vaddr_t s1;
436:
437: s1 = (vaddr_t) sp->s_size;
438: if (seggrow(sp, (fsize_t)s2) == 0) {
439: u.u_error = ENOMEM;
440: return;
441: }
442: if (sproto() == 0)
443: if (seggrow(sp, (fsize_t)s1)==0 || sproto()==0)
444: sendsig(SIGSEGV, SELF);
445: segload();
446: }
447:
448: /*
449: * Grow the segment `sp1' to the size `s' in bytes by swapping it out
450: * and back in. The segment may not be locked.
451: */
452: SEG *
453: segsext(sp1, s)
454: register SEG *sp1;
455: register fsize_t s;
456: {
457: register SEG *sp2;
458:
459: #ifndef NOMONITOR
460: if (swmflag)
461: printf("Segsext(%p, %u)\n", SELF, SELF->p_pid);
462: #endif
463: if (sexflag == 0) {
464: u.u_error = ENOMEM;
465: return (NULL);
466: }
467: lock(seglink);
468: if ((sp2=sdalloc(s)) == NULL) {
469: unlock(seglink);
470: return (NULL);
471: }
472: unlock(seglink);
473: sp1->s_lrefc++;
474: if (sp1->s_size != 0)
475: swapio(1, sp1->s_paddr, sp2->s_daddr, sp1->s_size);
476: lock(seglink);
477: satcopy(sp1, sp2);
478: unlock(seglink);
479: sp1->s_flags &= ~SFCORE;
480: sp1->s_lrefc--;
481: vremap(sp1);
482: segfinm(sp1);
483: return (sp1);
484: }
485:
486: /*
487: * Force the given segment to be in memory. One can only force
488: * one segment to be in memory at a time.
489: */
490: segfinm(sp)
491: register SEG *sp;
492: {
493: register PROC *pp;
494: register int s;
495:
496: if ((sp->s_flags&SFCORE) != 0)
497: return;
498: pp = SELF;
499: sp->s_urefc++;
500: sp->s_lrefc++;
501: pp->p_segp[SIAUXIL] = sp;
502: pp->p_flags &= ~PFCORE;
503: #ifndef QWAKEUP
504: s = sphi();
505: #endif
506: setrun(pp);
507: dispatch();
508: #ifndef QWAKEUP
509: spl(s);
510: #endif
511: pp->p_segp[SIAUXIL] = NULL;
512: sfree(sp);
513: }
514:
515: /*
516: * Make a copy of the segment `sp1' which is in memory by writing
517: * it out to disk.
518: */
519: SEG *
520: segdupd(sp1)
521: register SEG *sp1;
522: {
523: register SEG *sp2;
524:
525: if (sexflag == 0)
526: return (NULL);
527: lock(seglink);
528: if ((sp2=sdalloc(sp1->s_size)) == NULL) {
529: unlock(seglink);
530: return (NULL);
531: }
532: sp1->s_lrefc++;
533: unlock(seglink);
534: swapio(1, sp1->s_paddr, sp2->s_daddr, sp1->s_size);
535: sp1->s_lrefc--;
536: sp2->s_flags = sp1->s_flags & ~SFCORE;
537: sp2->s_size = sp1->s_size;
538: vremap( sp2 );
539: return (sp2);
540: }
541:
542: /*
543: * Given a flag, a physical core address, a disk address and a count in
544: * bytes, perform an I/O operation between core and disk. If `flag' is
545: * set, the transfer is to the disk otherwise it is to memory. As you may
546: * have guessed, this is used by the swapper.
547: */
548: swapio(f, p, d, n)
549: paddr_t p;
550: daddr_t d;
551: fsize_t n;
552: {
553: register BUF * bp;
554: register SEG * sp;
555: register int s;
556: register int nb;
557: static SEG swapseg; /* NOTE: FP_SEL(swapseg.s_faddr) must stay */
558:
559: #ifndef NOMONITOR
560: if (swmflag > 1)
561: printf("swapio(%s,%x,%x,%x)\n",f?"out":"in",(int)p,(int)d,n);
562: #endif
563: if (d < swapbot || d+(n/BSIZE) > swaptop
564: || p < corebot || p+n > coretop)
565: panic("Swapio bad parameter");
566:
567: bp = &swapbuf;
568: sp = &swapseg;
569: lock(bp->b_gate);
570: SELF->p_flags |= PFSWIO;
571: sp->s_flags = SFCORE;
572: sp->s_paddr = p;
573: sp->s_size = n;
574: vremap( sp );
575: bp->b_faddr = sp->s_faddr;
576:
577: while (n != 0) {
578: nb = (n > SCHUNK) ? SCHUNK : n;
579: /*
580: * Prevent I/O transfer from crossing 64 Kbyte boundary.
581: */
582: if ( (p & 0xFFFF0000L) != ((p+nb) & 0xFFFF0000L) )
583: nb = 0x10000L - (p & 0x0000FFFFL);
584: bp->b_flag = BFNTP;
585: bp->b_req = f ? BWRITE : BREAD;
586: bp->b_dev = swapdev;
587: bp->b_bno = d;
588: bp->b_paddr = p;
589: bp->b_count = nb;
590: s = sphi();
591: dblock(swapdev, bp);
592: while ((bp->b_flag&BFNTP) != 0)
593: sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO);
594: spl(s);
595: if ((bp->b_flag&BFERR) != 0)
596: panic("Swapio error");
597: FP_OFF(bp->b_faddr) += nb;
598: p += nb;
599: d += nb / BSIZE;
600: n -= nb;
601: }
602: sp->s_flags = 0;
603: vremap( sp );
604: unlock(bp->b_gate);
605: SELF->p_flags &= ~PFSWIO;
606: }
607:
608: /*
609: * Make the segment descriptor pointed to by `sp1' have the attributes
610: * of `sp2' including it's position in the segment queue and release
611: * `sp2'. `seglink' must be locked when this routine is called.
612: */
613: satcopy(sp1, sp2)
614: register SEG *sp1;
615: register SEG *sp2;
616: {
617: if ( FP_SEL(sp2->s_faddr) != 0 )
618: vrelse( sp2->s_faddr );
619:
620: sp1->s_back->s_forw = sp1->s_forw;
621: sp1->s_forw->s_back = sp1->s_back;
622: sp2->s_back->s_forw = sp1;
623: sp1->s_back = sp2->s_back;
624: sp2->s_forw->s_back = sp1;
625: sp1->s_forw = sp2->s_forw;
626: sp1->s_size = sp2->s_size;
627: sp1->s_paddr = sp2->s_paddr;
628: sp1->s_daddr = sp2->s_daddr;
629: vremap(sp1);
630: kfree(sp2);
631: }
632:
633: /*
634: * Allocate a segment on disk that is `n' bytes long.
635: * The `seglink' gate should be locked before this routine is called.
636: */
637: SEG *
638: sdalloc( s )
639: fsize_t s;
640: {
641: register SEG *sp1;
642: register SEG *sp2;
643: register daddr_t d;
644: register daddr_t d1;
645: register daddr_t d2;
646:
647: d = s / BSIZE;
648: d1 = swapbot;
649: sp1 = &segdq;
650: do {
651: if (d1 >= swaptop)
652: return (NULL);
653: if ((sp1=sp1->s_forw) != &segdq)
654: d2 = sp1->s_daddr;
655: else
656: d2 = swaptop;
657: if (d2-d1 >= d) {
658: if ((sp2=kalloc(sizeof(SEG))) == NULL)
659: return (NULL);
660: sp1->s_back->s_forw = sp2;
661: sp2->s_back = sp1->s_back;
662: sp1->s_back = sp2;
663: sp2->s_forw = sp1;
664: sp2->s_urefc = 1;
665: sp2->s_lrefc = 1;
666: sp2->s_size = s;
667: sp2->s_daddr = d1;
668: return (sp2);
669: }
670: d1 = sp1->s_daddr + (sp1->s_size / BSIZE);
671: } while (sp1 != &segdq);
672: return (NULL);
673: }
674:
675: /*
676: * Allocate a segment in memory that is `n' bytes long.
677: * The `seglink' gate should be locked before this routine is called.
678: */
679: SEG *
680: smalloc(s)
681: fsize_t s;
682: {
683: register SEG *sp1;
684: register SEG *sp2;
685: paddr_t p1;
686: paddr_t p2;
687:
688: p1 = corebot;
689: sp1 = &segmq;
690: do {
691: if ((sp1=sp1->s_forw) != &segmq)
692: p2 = sp1->s_paddr;
693: else
694: p2 = coretop;
695:
696: if (p2-p1 >= s) {
697: if ((sp2=kalloc(sizeof (SEG))) == NULL)
698: return (NULL);
699: sp1->s_back->s_forw = sp2;
700: sp2->s_back = sp1->s_back;
701: sp1->s_back = sp2;
702: sp2->s_forw = sp1;
703: sp2->s_urefc = 1;
704: sp2->s_lrefc = 1;
705: sp2->s_size = s;
706: sp2->s_paddr = p1;
707: /* s_faddr = 0; */
708: /* s_flags = 0; */
709: vremap( sp2 );
710: return (sp2);
711: }
712: p1 = sp1->s_paddr + sp1->s_size;
713: } while (sp1 != &segmq);
714: return (NULL);
715: }
716:
717: /*
718: * Allocate a segment from the high end of memory that is `n' bytes long.
719: * The `seglink' gate should be locked before this routine is called.
720: */
721: SEG *
722: shalloc( s )
723: fsize_t s;
724: {
725: register SEG *sp1;
726: register SEG *sp2;
727: paddr_t p1;
728: paddr_t p2;
729:
730: sp1 = &segmq;
731: p2 = coretop;
732: do {
733: if ((sp1=sp1->s_back) != &segmq)
734: p1 = sp1->s_paddr + sp1->s_size;
735: else
736: p1 = corebot;
737:
738: if (p2-p1 >= s) {
739: if ((sp2=kalloc(sizeof (SEG))) == NULL)
740: return (NULL);
741: sp1->s_forw->s_back = sp2;
742: sp2->s_forw = sp1->s_forw;
743: sp1->s_forw = sp2;
744: sp2->s_back = sp1;
745: sp2->s_urefc = 1;
746: sp2->s_lrefc = 1;
747: sp2->s_size = s;
748: sp2->s_paddr = p2-s;
749: /* s_faddr = 0; */
750: /* s_flags = 0; */
751: vremap( sp2 );
752: return (sp2);
753: }
754: p2 = sp1->s_paddr;
755: } while (sp1 != &segmq);
756: return (NULL);
757: }
758:
759: /*
760: * Set up `SR' structure in user area from segments descriptors in
761: * process structure. Also set up the user segmentation registers.
762: */
763: sproto()
764: {
765: register int n;
766: register SEG *sp;
767:
768: kclear(u.u_segl, sizeof(u.u_segl));
769: for (n=0; n<NUSEG; n++) {
770: if ((sp=SELF->p_segp[n]) == NULL)
771: continue;
772: if (n == SIUSERP)
773: u.u_segl[n].sr_base = &u;
774: else
775: u.u_segl[n].sr_flag |= SRFPMAP;
776: if (n!=SISTEXT && n!=SISDATA)
777: u.u_segl[n].sr_flag |= SRFDUMP;
778: if (n!=SIUSERP && n!=SISTEXT && n!=SIPTEXT)
779: u.u_segl[n].sr_flag |= SRFDATA;
780: u.u_segl[n].sr_size = sp->s_size;
781: u.u_segl[n].sr_segp = sp;
782: }
783: return (mproto());
784: }
785:
786: /*
787: * Search for a busy text inode.
788: */
789: sbusy(ip)
790: register INODE *ip;
791: {
792: register SEG *sp;
793:
794: lock(seglink);
795: /*
796: * Look for the segment in the memory queue.
797: */
798: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) {
799: if (sp->s_ip==ip
800: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) {
801: unlock(seglink);
802: return (1);
803: }
804: }
805:
806: /*
807: * Look for the segment on the disk queue.
808: */
809: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) {
810: if (sp->s_ip==ip
811: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) {
812: unlock(seglink);
813: return (1);
814: }
815: }
816: unlock(seglink);
817: return (0);
818: }
819:
820: /*
821: * Segment consistency checks for the paranoid.
822: segchk()
823: {
824: register SEG *sp;
825: register int nbad;
826: fsize_t s;
827: daddr_t d;
828:
829: nbad = 0;
830: sp = &segmq;
831: s = corebot;
832: while ((sp=sp->s_forw) != &segmq) {
833: if (sp->s_paddr < s)
834: nbad += badseg("mem", sp->s_paddr, 0);
835: s = sp->s_paddr + sp->s_size;
836: }
837: if (coretop < s)
838: nbad += badseg("mem", sp->s_back->s_paddr, sp->s_back->s_size);
839: sp = &segdq;
840: d = swapbot;
841: while ((sp=sp->s_forw) != &segdq) {
842: if (sp->s_daddr < d)
843: nbad += badseg("disk", (int)sp->s_daddr, 0);
844: d = sp->s_daddr + (sp->s_size / BSIZE);
845: }
846: if (swaptop < d)
847: nbad += badseg("disk", sp->s_back->s_daddr, sp->s_back->s_size);
848: }
849:
850: badseg(t, b, s)
851: char *t;
852: daddr_t b;
853: fsize_t s;
854: {
855: printf( "Bad %s segment at %X of len %X\n", t, b, s );
856: return (1);
857: }
858: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.