![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_mman.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to kern_mman.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)kern_mman.c 7.18 (Berkeley) 6/30/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "map.h"
26: #include "user.h"
27: #include "proc.h"
28: #include "buf.h"
29: #include "vnode.h"
30: #include "specdev.h"
31: #include "seg.h"
32: #include "acct.h"
33: #include "wait.h"
34: #include "vm.h"
35: #include "text.h"
36: #include "file.h"
37: #include "vadvise.h"
38: #include "cmap.h"
39: #include "trace.h"
40: #include "mman.h"
41: #include "mapmem.h"
42: #include "malloc.h"
43: #include "conf.h"
44:
45: #include "machine/cpu.h"
46: #include "machine/reg.h"
47: #include "machine/psl.h"
48: #include "machine/pte.h"
49: #include "machine/mtpr.h"
50:
51: /*
52: * The MMAP code here is temporary; it provides support
53: * only for mmaping devices such as frame buffers.
54: * All to be different next time...
55: */
56: #ifndef MAPMEM
57: #undef MMAP /* XXX */
58: #endif
59:
60: #ifdef MMAP
61: struct mapmemops mmapops = {
62: (int (*)())0, (int (*)())0, (int (*)())0, (int (*)())0
63: };
64: #endif
65:
66: /* ARGSUSED */
67: sbrk(p, uap, retval)
68: struct proc *p;
69: struct args {
70: int incr;
71: } *uap;
72: int *retval;
73: {
74:
75: /* Not yet implemented */
76: return (EOPNOTSUPP);
77: }
78:
79: /* ARGSUSED */
80: sstk(p, uap, retval)
81: struct proc *p;
82: struct args {
83: int incr;
84: } *uap;
85: int *retval;
86: {
87:
88: /* Not yet implemented */
89: return (EOPNOTSUPP);
90: }
91:
92: /* ARGSUSED */
93: getpagesize(p, uap, retval)
94: struct proc *p;
95: struct args *uap;
96: int *retval;
97: {
98:
99: *retval = NBPG * CLSIZE;
100: return (0);
101: }
102:
103: /* ARGSUSED */
104: smmap(p, uap, retval)
105: register struct proc *p;
106: register struct args {
107: caddr_t addr;
108: int len;
109: int prot;
110: int share;
111: int fd;
112: off_t pos;
113: } *uap;
114: int *retval;
115: {
116: #ifndef MMAP
117: return (EOPNOTSUPP);
118: #else
119: register struct file *fp;
120: struct mapmem *mp;
121: struct vnode *vp;
122: register struct pte *pte;
123: struct pte *dpte;
124: register int off;
125: int error, fv, lv, pm, (*mapfun)();
126: dev_t dev;
127:
128: if (error = getvnode(u.u_ofile, uap->fd, &fp))
129: return (error);
130: vp = (struct vnode *)fp->f_data;
131: if (vp->v_type != VCHR)
132: return (EINVAL);
133: dev = vp->v_rdev;
134: mapfun = cdevsw[major(dev)].d_mmap;
135: if (mapfun == NULL)
136: return (EINVAL);
137: if (((int)uap->addr & CLOFSET) || (uap->pos & CLOFSET) ||
138: uap->len <= 0 || (uap->len & CLOFSET))
139: return (EINVAL);
140: if ((uap->prot & PROT_WRITE) && (fp->f_flag&FWRITE) == 0)
141: return (EINVAL);
142: if ((uap->prot & PROT_READ) && (fp->f_flag&FREAD) == 0)
143: return (EINVAL);
144: if (uap->share != MAP_SHARED)
145: return (EINVAL);
146: for (off = 0; off < uap->len; off += NBPG)
147: if ((*mapfun)(dev, uap->pos+off, uap->prot) == -1)
148: return (EINVAL); /* Needs translation */
149: /*
150: * Allocate a descriptor for this region and expand page
151: * table to accomodate.
152: */
153: if (uap->prot & PROT_WRITE) {
154: pm = PG_UW|PG_FOD|PG_V;
155: off = MM_RW;
156: } else {
157: pm = PG_URKR|PG_FOD|PG_V;
158: off = MM_RO;
159: }
160: #if defined(hp300)
161: pm |= PG_CI;
162: off |= MM_CI;
163: #endif
164: error = mmalloc(p, uap->fd, &uap->addr, uap->len, off, &mmapops, &mp);
165: if (error)
166: return (error);
167: /*
168: * Now map it in.
169: * Can't use mmmapin() because of args to map function.
170: */
171: fv = btop(uap->addr);
172: pte = vtopte(p, fv);
173: dpte = dptopte(p, u.u_dsize);
174: for (off = 0; off < uap->len; off += NBPG) {
175: if ((off&CLOFSET) == 0 && pte < dpte)
176: p->p_rssize -= vmemfree(pte, CLSIZE);
177: *(int *)pte = pm;
178: pte->pg_pfnum = (*mapfun)(dev, uap->pos+off, uap->prot);
179: pte++;
180: }
181: newptes(vtopte(p, fv), fv, btoc(uap->len));
182: u.u_pofile[uap->fd] |= UF_MAPPED;
183: return (0);
184: #endif /* MMAP */
185: }
186:
187: /* ARGSUSED */
188: msync(p, uap, retval)
189: struct proc *p;
190: struct args {
191: char *addr;
192: int len;
193: } *uap;
194: int *retval;
195: {
196:
197: /* Not yet implemented */
198: return (EOPNOTSUPP);
199: }
200:
201: /* ARGSUSED */
202: munmap(p, uap, retval)
203: register struct proc *p;
204: register struct args {
205: caddr_t addr;
206: int len;
207: } *uap;
208: int *retval;
209: {
210: #ifndef MMAP
211: return (EOPNOTSUPP);
212: #else
213: register struct mapmem *mp;
214: register int fd;
215: caddr_t eaddr;
216: int error;
217:
218: if (((int)uap->addr & CLOFSET) ||
219: uap->len <= 0 || (uap->len & CLOFSET))
220: return (EINVAL);
221: /*
222: * Locate region mapping this range. If found, unmap it.
223: */
224: eaddr = uap->addr + uap->len - 1;
225: for (mp = u.u_mmap; mp; mp = mp->mm_next)
226: if (mp->mm_ops == &mmapops &&
227: uap->addr >= mp->mm_uva && eaddr < mp->mm_uva+mp->mm_size)
228: break;
229: if (mp == MMNIL)
230: return (EINVAL);
231: fd = mp->mm_id;
232: mmmapout(p, mp);
233: error = mmfree(mp);
234: /*
235: * If no other range has this descriptor mapped, mark it as unmapped.
236: */
237: for (mp = u.u_mmap; mp; mp = mp->mm_next)
238: if (mp->mm_id == fd)
239: break;
240: if (mp == MMNIL)
241: u.u_pofile[fd] &= ~UF_MAPPED;
242: return (error);
243: #endif /* MMAP */
244: }
245:
246: munmapfd(fd)
247: int fd;
248: {
249: int error = 0;
250: #ifdef MMAP
251: struct proc *p = u.u_procp; /* XXX */
252: register struct mapmem *mp, **mpp;
253:
254: if (p->p_flag & SVFORK)
255: return (0);
256: mpp = &u.u_mmap;
257: for (mp = *mpp; mp; mp = *mpp) {
258: if (mp->mm_ops == &mmapops && mp->mm_id == fd) {
259: mmmapout(p, mp);
260: error = mmfree(mp);
261: } else
262: mpp = &mp->mm_next;
263: }
264: #endif
265: u.u_pofile[fd] &= ~UF_MAPPED;
266: return (error);
267: }
268:
269: /* ARGSUSED */
270: mprotect(p, uap, retval)
271: struct proc *p;
272: struct args {
273: char *addr;
274: int len;
275: int prot;
276: } *uap;
277: int *retval;
278: {
279:
280: /* Not yet implemented */
281: return (EOPNOTSUPP);
282: }
283:
284: /* ARGSUSED */
285: madvise(p, uap, retval)
286: struct proc *p;
287: struct args {
288: char *addr;
289: int len;
290: int behav;
291: } *uap;
292: int *retval;
293: {
294:
295: /* Not yet implemented */
296: return (EOPNOTSUPP);
297: }
298:
299: /* ARGSUSED */
300: mincore(p, uap, retval)
301: struct proc *p;
302: struct args {
303: char *addr;
304: int len;
305: char *vec;
306: } *uap;
307: int *retval;
308: {
309:
310: /* Not yet implemented */
311: return (EOPNOTSUPP);
312: }
313:
314: /* BEGIN DEFUNCT */
315: /* ARGSUSED */
316: obreak(p, uap, retval)
317: struct proc *p;
318: struct args {
319: char *nsiz;
320: } *uap;
321: int *retval;
322: {
323: register segsz_t n, d, ds;
324: int error;
325:
326: /*
327: * set n to new data size
328: */
329: n = btoc(uap->nsiz) - dptov(p, 0);
330: if (n < 0)
331: n = 0;
332: /*
333: * since we can't pass a -ve argument for the difference to chksize,
334: * if d is negative, make ds equal to the final value and clear d.
335: * keep the real difference in n for later use in expand.
336: */
337: ds = u.u_dsize;
338: if ((n = d = clrnd(n - u.u_dsize)) < 0) {
339: ds += d;
340: d = 0;
341: }
342: if (ctob(ds + d) > u.u_rlimit[RLIMIT_DATA].rlim_cur)
343: return (ENOMEM);
344: if (error =
345: chksize((u_int)u.u_tsize, (u_int)ds, (u_int)d, (u_int)u.u_ssize))
346: return (error);
347: #ifdef MAPMEM
348: /*
349: * If change would conflict with any mapped memory segment
350: * return ENOMEM.
351: */
352: if (u.u_mmap && n != 0) {
353: caddr_t low, high;
354:
355: low = (caddr_t) ctob(dptov(p, ds));
356: high = low + ctob((n < 0) ? -n : n);
357: if (mmclash(u.u_mmap, low, high))
358: return (ENOMEM);
359: }
360: #endif
361: if (error = swpexpand(ds + d, u.u_ssize, &u.u_dmap, &u.u_smap))
362: return (error);
363: if (p->p_mmsize && (p->p_mmsize -= n) < 0)
364: p->p_mmsize = 0;
365: expand((int)n, 0);
366: return (0);
367: }
368:
369: /*
370: * Macros for clearing a page's reference bits.
371: */
372: #ifdef REFBIT
373: #if !defined(tahoe)
374: #define uncache(pte) /* XXX */
375: #endif
376:
377: #define CLRREF(pte, c, p, i) { \
378: if (!isatpte(p, pte)) \
379: uncache(pte); \
380: if (pte->pg_u) { \
381: c = &cmap[pgtocm(pte->pg_pfnum)]; \
382: if (c->c_lock) \
383: continue; \
384: pte->pg_u = 0; \
385: if (anycl(pte, pg_m)) \
386: pte->pg_m = 1; \
387: distcl(pte); \
388: if (isatpte(p, pte)) \
389: distpte(p->p_textp, i, pte); \
390: } \
391: }
392: #else
393: #define CLRREF(pte, c, p, i) { \
394: c = &cmap[pgtocm(pte->pg_pfnum)]; \
395: if (c->c_lock) \
396: continue; \
397: pte->pg_v = 0; \
398: if (anycl(pte, pg_m)) \
399: pte->pg_m = 1; \
400: distcl(pte); \
401: if (isatpte(p, pte)) \
402: distpte(p->p_textp, i, pte); \
403: }
404: #endif
405:
406: /* ARGSUSED */
407: ovadvise(rp, uap, retval)
408: register struct proc *rp;
409: struct args {
410: int anom;
411: } *uap;
412: int *retval;
413: {
414: int oanom = rp->p_flag & SUANOM;
415: register struct pte *pte;
416: register struct cmap *c;
417: register unsigned i;
418:
419: trace(TR_VADVISE, uap->anom, rp->p_pid);
420: rp->p_flag &= ~(SSEQL|SUANOM);
421: switch (uap->anom) {
422:
423: case VA_ANOM:
424: rp->p_flag |= SUANOM;
425: break;
426:
427: case VA_SEQL:
428: rp->p_flag |= SSEQL;
429: break;
430: }
431: if ((oanom && (rp->p_flag & SUANOM) == 0) || uap->anom == VA_FLUSH) {
432: for (i = 0; i < rp->p_dsize; i += CLSIZE) {
433: pte = dptopte(rp, i);
434: #ifdef MAPMEM
435: /* don't do mmap pages */
436: if (pte->pg_v && !pte->pg_fod)
437: #else
438: if (pte->pg_v)
439: #endif
440: CLRREF(pte, c, rp, i);
441: }
442: }
443: if (uap->anom == VA_FLUSH) { /* invalidate all pages */
444: for (i = 1; i < rp->p_ssize; i += CLSIZE) {
445: pte = sptopte(rp, i);
446: if (pte->pg_v)
447: CLRREF(pte, c, rp, i);
448: }
449: for (i = 0; i < rp->p_tsize; i += CLSIZE) {
450: pte = tptopte(rp, i);
451: if (pte->pg_v)
452: CLRREF(pte, c, rp, i);
453: }
454: }
455: #if defined(vax) || defined(tahoe)
456: mtpr(TBIA, 0);
457: #endif
458: #if defined(hp300)
459: TBIAU();
460: #endif
461: #if defined(i386)
462: tlbflush();
463: #endif
464: return (0);
465: }
466: /* END DEFUNCT */
467:
468: /*
469: * Grow the stack to include the SP; true return if successful.
470: * Clients do not care about the cause of the error.
471: */
472: grow(sp)
473: unsigned sp;
474: {
475: int si, error;
476:
477: if (sp >= USRSTACK-ctob(u.u_ssize))
478: return (0);
479: si = clrnd(btoc((USRSTACK-sp)) - u.u_ssize + SINCR);
480: if (ctob(si) > u.u_rlimit[RLIMIT_STACK].rlim_cur)
481: return (0);
482: if (error = chksize((u_int)u.u_tsize, (u_int)u.u_dsize, (u_int)0,
483: (u_int)u.u_ssize+si))
484: return (0);
485: if (error = swpexpand(u.u_dsize, u.u_ssize + si, &u.u_dmap, &u.u_smap))
486: return (0);
487: expand(si, 1);
488: return (1);
489: }
490:
491: #ifdef MAPMEM
492:
493: /*
494: * Called from vpassvm() after full context has been passed from fup to tup.
495: * Always called in the context of the parent. NOTE: routines should NOT
496: * destroy regions.
497: */
498: mmvfork(fup, tup)
499: struct user *fup, *tup;
500: {
501: register struct mapmem *mp;
502:
503: tup->u_mmap = fup->u_mmap;
504: fup->u_mmap = (struct mapmem *) 0;
505: for (mp = tup->u_mmap; mp; mp = mp->mm_next)
506: if (mp->mm_ops->mm_vfork)
507: (*mp->mm_ops->mm_vfork)(mp, fup, tup);
508: }
509:
510: /*
511: * Called from procdup() for both parent and child. If in parent
512: * we need to duplicate mapped memory regions. In both parent and
513: * child, we call object specific routine.
514: */
515: mmfork(pup, cup)
516: struct user *pup, *cup;
517: {
518: register struct mapmem *mp, **mpp;
519: int error = 0;
520:
521: if (pup) {
522: mmdup(pup, cup);
523: for (mp = pup->u_mmap; mp; mp = mp->mm_next)
524: if (mp->mm_ops->mm_fork)
525: (*mp->mm_ops->mm_fork)(mp, 0);
526: } else {
527: mpp = &u.u_mmap;
528: for (mp = *mpp; mp; mp = *mpp) {
529: if (mp->mm_ops->mm_fork)
530: (*mp->mm_ops->mm_fork)(mp, 1);
531: if (*mpp == mp)
532: mpp = &mp->mm_next;
533: }
534: error = mmexpand(u.u_procp);
535: }
536: return (error);
537: }
538:
539: /*
540: * Its not clear that having a seperate exec routine is useful since
541: * exec frees the address space immediately afterwards. We probably
542: * need a post-exec hook to reestablish any mappings that persist
543: * across execs.
544: */
545: mmexec(p)
546: struct proc *p;
547: {
548: register struct mapmem *mp, **mpp;
549: int error1, error = 0;
550:
551: mpp = &u.u_mmap;
552: for (mp = *mpp; mp; mp = *mpp) {
553: if (mp->mm_ops->mm_exec)
554: error = (*mp->mm_ops->mm_exec)(mp);
555: if (*mpp == mp) {
556: *mpp = mp->mm_next;
557: MMFREE(mp);
558: }
559: }
560: if (error1 = mmexpand(p))
561: return (error1);
562: if (p->p_mmsize)
563: panic("mmexec");
564: return (error);
565: }
566:
567: /*
568: * Called from exit just before releasing address space.
569: * We always reclaim resources regardless of what the object routine does.
570: */
571: mmexit(p)
572: struct proc *p;
573: {
574: register struct mapmem *mp, **mpp;
575: int error1, error = 0;
576:
577: mpp = &u.u_mmap;
578: for (mp = *mpp; mp; mp = *mpp) {
579: if (mp->mm_ops->mm_exit)
580: error = (*mp->mm_ops->mm_exit)(mp);
581: if (*mpp == mp) {
582: *mpp = mp->mm_next;
583: MMFREE(mp);
584: }
585: }
586: if (error1 = mmexpand(p))
587: return (error1);
588: if (p->p_mmsize)
589: panic("mmexit");
590: return (error);
591: }
592:
593: /*
594: * Called from core just before dumping process image to core file.
595: * Used to unmap regions which cannot be dumped; e.g. a region mapping
596: * hardware registers which are write-only or must be accessed as bytes.
597: */
598: mmcore(p)
599: struct proc *p;
600: {
601: register struct mapmem *mp, **mpp;
602: int error = 0, error1, changed = 0;
603:
604: mpp = &u.u_mmap;
605: for (mp = *mpp; mp; mp = *mpp) {
606: if ((mp->mm_prot & MM_NOCORE) == 0) {
607: mpp = &mp->mm_next;
608: continue;
609: }
610: if (mp->mm_ops->mm_exit)
611: error = (*mp->mm_ops->mm_exit)(mp);
612: if (*mpp == mp) {
613: *mpp = mp->mm_next;
614: MMFREE(mp);
615: }
616: changed++;
617: }
618: if (changed && (error1 = mmexpand(p)))
619: return (error1);
620: return (error);
621: }
622:
623: /*
624: * Duplicate mapped memory regions in a forked process.
625: * XXX child may wind up short a few regions if not enough resources.
626: */
627: mmdup(pu, cu)
628: struct user *pu, *cu;
629: {
630: register struct mapmem *pmp, *cmp;
631: register struct pte *ppte, *cpte;
632: register segsz_t count;
633:
634: /*
635: * First duplicate the mmap chain
636: */
637: MMALLOC(cu->u_mmap);
638: pmp = pu->u_mmap;
639: cmp = cu->u_mmap;
640: while (pmp && cmp) {
641: *cmp = *pmp;
642: if (pmp->mm_next)
643: MMALLOC(cmp->mm_next);
644: pmp = pmp->mm_next;
645: cmp = cmp->mm_next;
646: }
647: /*
648: * Now duplicate user address space that vmdup() won't do
649: * i.e. mapped regions outside of data segment.
650: */
651: ppte = dptopte(pu->u_procp, pu->u_procp->p_dsize);
652: cpte = dptopte(cu->u_procp, cu->u_procp->p_dsize);
653: for (count = pu->u_procp->p_mmsize; count; count--) {
654: if (ppte->pg_fod && ppte->pg_v)
655: *(int *)cpte = *(int *)ppte;
656: ppte++, cpte++;
657: }
658: cu->u_procp->p_flag |= SPTECHG;
659: }
660:
661: mmalloc(p, id, uvap, size, prot, ops, mpp)
662: struct proc *p;
663: caddr_t *uvap;
664: segsz_t size;
665: struct mapmemops *ops;
666: struct mapmem **mpp;
667: {
668: register struct mapmem *mp;
669: register u_int uva;
670: int error;
671:
672: /*
673: * Validate size first
674: */
675: if (size <= 0 || (size & CLOFSET))
676: return(EINVAL);
677: /*
678: * A uva of zero means to map at our discretion.
679: * Our strategy is to place the segment at the max of:
680: * - the current data + mapped memory size
681: * - the default data size limit
682: * (if it will fit within the MAXDSIZ limit)
683: * If this is the first mapped memory region beyond the data
684: * segment we round to a MMSEG boundary to allow for data
685: * segment growth.
686: */
687: uva = (u_int) *uvap;
688: if (uva == 0) {
689: register u_int uva2;
690:
691: uva = ctob(dptov(p, u.u_dsize + p->p_mmsize));
692: uva2 = ctob(dptov(p, btoc(DFLDSIZ)));
693: uva2 = ((uva2 + (MMSEG-1)) & ~(MMSEG-1));
694: if (uva < uva2 &&
695: uva2 + size < ctob(dptov(p, btoc(MAXDSIZ))))
696: uva = uva2;
697: else if (p->p_mmsize == 0)
698: uva = ((uva + (MMSEG-1)) & ~(MMSEG-1));
699: }
700: /*
701: * Impose necessary constraints on address.
702: */
703: if ((uva & CLOFSET) || uva < ctob(dptov(p, 0)) ||
704: uva+size >= ctob(sptov(p, u.u_ssize)))
705: return (EINVAL);
706: if (mmclash(u.u_mmap, (caddr_t)uva, (caddr_t)uva+size))
707: return (EINVAL);
708: /*
709: * Finally, allocate and initialize descriptor and expand
710: * user address space as necessary.
711: */
712: MMALLOC(mp);
713: if (mp == MMNIL)
714: return (ENOMEM);
715: mp->mm_next = u.u_mmap;
716: mp->mm_id = id;
717: mp->mm_uva = (caddr_t) uva;
718: mp->mm_size = size;
719: mp->mm_prot = prot;
720: mp->mm_ops = ops;
721: u.u_mmap = mp;
722: if (error = mmexpand(p)) {
723: u.u_mmap = mp->mm_next;
724: MMFREE(mp);
725: return(error);
726: }
727: *uvap = (caddr_t) uva;
728: *mpp = mp;
729: return(0);
730: }
731:
732: mmfree(p, mp)
733: struct proc *p;
734: register struct mapmem *mp;
735: {
736: register struct mapmem *cmp, **mpp;
737:
738: /*
739: * Remove region from chain
740: */
741: mpp = &u.u_mmap;
742: for (cmp = *mpp; cmp; cmp = *mpp) {
743: if (cmp == mp)
744: break;
745: mpp = &cmp->mm_next;
746: }
747: if (cmp == MMNIL)
748: panic("mmfree");
749: *mpp = mp->mm_next;
750: MMFREE(mp);
751: return (mmexpand(p));
752: }
753:
754: mmmapin(p, mp, mapfunc)
755: register struct proc *p;
756: register struct mapmem *mp;
757: int (*mapfunc)();
758: {
759: register struct pte *pte;
760: register int off;
761: struct pte *dpte;
762: int pm, fv, lv;
763:
764: /*
765: * Verify that range can be mapped
766: */
767: for (off = 0; off < mp->mm_size; off += NBPG)
768: if ((*mapfunc)(mp, off) == -1)
769: return (EINVAL);
770: /*
771: * Now verify that region is in range
772: */
773: fv = btop(mp->mm_uva);
774: lv = btop(mp->mm_uva + mp->mm_size - 1);
775: if (fv < dptov(p, 0) ||
776: lv >= dptov(p, u.u_dsize + p->p_mmsize))
777: return (ENOMEM);
778: /*
779: * Finally, do the mapping.
780: */
781: if (mp->mm_prot & MM_RO)
782: pm = PG_URKR|PG_FOD|PG_V;
783: else
784: pm = PG_UW|PG_FOD|PG_V;
785: #if defined(hp300)
786: if (mp->mm_prot & MM_CI)
787: pm |= PG_CI;
788: #endif
789: pte = vtopte(p, fv);
790: dpte = dptopte(p, u.u_dsize);
791: for (off = 0; off < mp->mm_size; off += NBPG) {
792: if ((off&CLOFSET) == 0 && pte < dpte)
793: p->p_rssize -= vmemfree(pte, CLSIZE);
794: *(int *)pte = pm;
795: pte->pg_pfnum = (*mapfunc)(mp, off);
796: pte++;
797: }
798: newptes(vtopte(p, fv), (u_int)fv, (int)btoc(mp->mm_size));
799: return (0);
800: }
801:
802: mmmapout(p, mp)
803: register struct proc *p;
804: register struct mapmem *mp;
805: {
806: register struct pte *pte;
807: register int off;
808: struct pte *dpte;
809: int fv, lv;
810:
811: fv = btop(mp->mm_uva);
812: lv = btop(mp->mm_uva + mp->mm_size - 1);
813: if (fv < dptov(p, 0) ||
814: lv >= dptov(p, u.u_dsize + p->p_mmsize))
815: panic("mmmapout");
816: pte = vtopte(p, fv);
817: dpte = dptopte(p, u.u_dsize);
818: for (off = 0; off < mp->mm_size; off += NBPG) {
819: if (pte < dpte) {
820: if ((off & CLOFSET) == 0)
821: p->p_rssize -= vmemfree(pte, CLSIZE);
822: *(int *)pte = (PG_UW|PG_FOD);
823: ((struct fpte *)pte)->pg_fileno = PG_FZERO;
824: } else
825: *(int *)pte = 0;
826: pte++;
827: }
828: newptes(vtopte(p, fv), (u_int)fv, (int)btoc(mp->mm_size));
829: }
830:
831: mmexpand(p)
832: struct proc *p;
833: {
834: register int szpt, change;
835: caddr_t high;
836: segsz_t nsize, oms;
837:
838: oms = p->p_mmsize;
839: /*
840: * Get new mmsize based on existing regions and use
841: * that to calculate change in page table size.
842: */
843: if (u.u_mmap) {
844: mmrange(u.u_mmap, (caddr_t *)0, &high);
845: nsize = btop(high) - dptov(p, u.u_dsize) + 1;
846: if (nsize < 0)
847: nsize = 0;
848: } else
849: nsize = 0;
850: change = nsize - oms;
851: if (change == 0)
852: return(0);
853:
854: /*
855: * Ensure data + mapped memory fits within maximum data limit.
856: * This is possibly a little restrictive, but it helps keep
857: * page table sizes down.
858: */
859: if (change > 0 &&
860: (ctob(oms+change) > u.u_rlimit[RLIMIT_DATA].rlim_max ||
861: ctob(u.u_dsize+oms+change) > u.u_rlimit[RLIMIT_DATA].rlim_max))
862: return(ENOMEM);
863: /*
864: * Expand page table if necessary.
865: * Note that ptexpand takes care of flushing the translation buffer.
866: */
867: p->p_mmsize += change;
868: #if defined(hp300) || defined(i386)
869: szpt = ptsize(p) - u.u_pcb.pcb_szpt;
870: if (szpt > 0)
871: ptexpand(szpt, u.u_dsize, oms, u.u_ssize);
872: setp0lr(u.u_pcb.pcb_p0lr + change);
873: #endif
874: #if defined(vax) || defined(tahoe)
875: #if defined(vax)
876: szpt = (u.u_pcb.pcb_p1br + (u.u_pcb.pcb_p1lr&~PME_CLR)) -
877: (u.u_pcb.pcb_p0br + (u.u_pcb.pcb_p0lr&~AST_CLR));
878: #else
879: szpt = (u.u_pcb.pcb_p2br + u.u_pcb.pcb_p2lr) -
880: (u.u_pcb.pcb_p0br + u.u_pcb.pcb_p0lr);
881: #endif
882: if (change > szpt)
883: ptexpand(clrnd(ctopt(change - szpt)), u.u_dsize, oms, u.u_ssize);
884: /*
885: * Clear new ptes.
886: * We need to do this because there may be bogus (yet technically
887: * valid) ptes above the old p0lr value. This can happen if the
888: * data segment has shrunk in the past leaving such ptes behind.
889: * There is no need to invalidate such ptes at that time since the
890: * length register will prevent their use. We are safe on the HPs
891: * because we do invalidate old ptes in setp0lr() when shrinking.
892: */
893: if (change > 0) {
894: struct pte *bpte;
895:
896: #if defined(vax)
897: bpte = u.u_pcb.pcb_p0br + (u.u_pcb.pcb_p0lr&~AST_CLR);
898: #else
899: bpte = u.u_pcb.pcb_p0br + u.u_pcb.pcb_p0lr;
900: #endif
901: bzero((caddr_t)bpte, change * sizeof(struct pte));
902: mtpr(TBIA, 0);
903: }
904: /* avoid side-effects of setp0lr */
905: #if defined(vax)
906: change += u.u_pcb.pcb_p0lr &~ AST_CLR;
907: #else
908: change += u.u_pcb.pcb_p0lr;
909: #endif
910: setp0lr(change);
911: #endif
912: return(0);
913: }
914:
915: mmrange(mp, lap, hap)
916: register struct mapmem *mp;
917: caddr_t *lap, *hap;
918: {
919: register caddr_t low, high, top;
920:
921: low = high = 0;
922: while (mp) {
923: if (low == 0 || mp->mm_uva < low)
924: low = mp->mm_uva;
925: top = mp->mm_uva + mp->mm_size - 1;
926: if (high == 0 || top > high)
927: high = top;
928: mp = mp->mm_next;
929: }
930: if (lap)
931: *lap = low;
932: if (hap)
933: *hap = high;
934: }
935:
936: mmclash(mp, la, ha)
937: register struct mapmem *mp;
938: caddr_t la, ha;
939: {
940: while (mp) {
941: if (ha > mp->mm_uva && la < mp->mm_uva + mp->mm_size)
942: return(1);
943: mp = mp->mm_next;
944: }
945: return(0);
946: }
947:
948: #endif /* MAPMEM */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.