![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_glue.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / vm|
Return to vm_glue.c CVS log | Up to [Net/2] / Net2 / vm |
1.1 ! root 1: /* ! 2: * Copyright (c) 1991 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * The Mach Operating System project at Carnegie-Mellon University. ! 7: * ! 8: * Redistribution and use in source and binary forms, with or without ! 9: * modification, are permitted provided that the following conditions ! 10: * are met: ! 11: * 1. Redistributions of source code must retain the above copyright ! 12: * notice, this list of conditions and the following disclaimer. ! 13: * 2. Redistributions in binary form must reproduce the above copyright ! 14: * notice, this list of conditions and the following disclaimer in the ! 15: * documentation and/or other materials provided with the distribution. ! 16: * 3. All advertising materials mentioning features or use of this software ! 17: * must display the following acknowledgement: ! 18: * This product includes software developed by the University of ! 19: * California, Berkeley and its contributors. ! 20: * 4. Neither the name of the University nor the names of its contributors ! 21: * may be used to endorse or promote products derived from this software ! 22: * without specific prior written permission. ! 23: * ! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 34: * SUCH DAMAGE. ! 35: * ! 36: * @(#)vm_glue.c 7.8 (Berkeley) 5/15/91 ! 37: * ! 38: * ! 39: * Copyright (c) 1987, 1990 Carnegie-Mellon University. ! 40: * All rights reserved. ! 41: * ! 42: * Permission to use, copy, modify and distribute this software and ! 43: * its documentation is hereby granted, provided that both the copyright ! 44: * notice and this permission notice appear in all copies of the ! 45: * software, derivative works or modified versions, and any portions ! 46: * thereof, and that both notices appear in supporting documentation. ! 47: * ! 48: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 49: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND ! 50: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 51: * ! 52: * Carnegie Mellon requests users of this software to return to ! 53: * ! 54: * Software Distribution Coordinator or [email protected] ! 55: * School of Computer Science ! 56: * Carnegie Mellon University ! 57: * Pittsburgh PA 15213-3890 ! 58: * ! 59: * any improvements or extensions that they make and grant Carnegie the ! 60: * rights to redistribute these changes. ! 61: */ ! 62: ! 63: #include "param.h" ! 64: #include "systm.h" ! 65: #include "proc.h" ! 66: #include "resourcevar.h" ! 67: #include "buf.h" ! 68: #include "user.h" ! 69: ! 70: #include "vm.h" ! 71: #include "vm_page.h" ! 72: #include "vm_kern.h" ! 73: ! 74: int avefree = 0; /* XXX */ ! 75: unsigned maxdmap = MAXDSIZ; /* XXX */ ! 76: int readbuffers = 0; /* XXX allow kgdb to read kernel buffer pool */ ! 77: ! 78: kernacc(addr, len, rw) ! 79: caddr_t addr; ! 80: int len, rw; ! 81: { ! 82: boolean_t rv; ! 83: vm_offset_t saddr, eaddr; ! 84: vm_prot_t prot = rw == B_READ ? VM_PROT_READ : VM_PROT_WRITE; ! 85: ! 86: saddr = trunc_page(addr); ! 87: eaddr = round_page(addr+len-1); ! 88: rv = vm_map_check_protection(kernel_map, saddr, eaddr, prot); ! 89: /* ! 90: * XXX there are still some things (e.g. the buffer cache) that ! 91: * are managed behind the VM system's back so even though an ! 92: * address is accessible in the mind of the VM system, there may ! 93: * not be physical pages where the VM thinks there is. This can ! 94: * lead to bogus allocation of pages in the kernel address space ! 95: * or worse, inconsistencies at the pmap level. We only worry ! 96: * about the buffer cache for now. ! 97: */ ! 98: if (!readbuffers && rv && (eaddr > (vm_offset_t)buffers && ! 99: saddr < (vm_offset_t)buffers + MAXBSIZE * nbuf)) ! 100: rv = FALSE; ! 101: return(rv == TRUE); ! 102: } ! 103: ! 104: useracc(addr, len, rw) ! 105: caddr_t addr; ! 106: int len, rw; ! 107: { ! 108: boolean_t rv; ! 109: vm_prot_t prot = rw == B_READ ? VM_PROT_READ : VM_PROT_WRITE; ! 110: ! 111: rv = vm_map_check_protection(&curproc->p_vmspace->vm_map, ! 112: trunc_page(addr), round_page(addr+len-1), prot); ! 113: return(rv == TRUE); ! 114: } ! 115: ! 116: #ifdef KGDB ! 117: /* ! 118: * Change protections on kernel pages from addr to addr+len ! 119: * (presumably so debugger can plant a breakpoint). ! 120: * All addresses are assumed to reside in the Sysmap, ! 121: */ ! 122: chgkprot(addr, len, rw) ! 123: register caddr_t addr; ! 124: int len, rw; ! 125: { ! 126: vm_prot_t prot = rw == B_READ ? VM_PROT_READ : VM_PROT_WRITE; ! 127: ! 128: vm_map_protect(kernel_map, trunc_page(addr), ! 129: round_page(addr+len-1), prot, FALSE); ! 130: } ! 131: #endif ! 132: ! 133: vslock(addr, len) ! 134: caddr_t addr; ! 135: u_int len; ! 136: { ! 137: vm_map_pageable(&curproc->p_vmspace->vm_map, trunc_page(addr), ! 138: round_page(addr+len-1), FALSE); ! 139: } ! 140: ! 141: vsunlock(addr, len, dirtied) ! 142: caddr_t addr; ! 143: u_int len; ! 144: int dirtied; ! 145: { ! 146: #ifdef lint ! 147: dirtied++; ! 148: #endif lint ! 149: vm_map_pageable(&curproc->p_vmspace->vm_map, trunc_page(addr), ! 150: round_page(addr+len-1), TRUE); ! 151: } ! 152: ! 153: /* ! 154: * Implement fork's actions on an address space. ! 155: * Here we arrange for the address space to be copied or referenced, ! 156: * allocate a user struct (pcb and kernel stack), then call the ! 157: * machine-dependent layer to fill those in and make the new process ! 158: * ready to run. ! 159: * NOTE: the kernel stack may be at a different location in the child ! 160: * process, and thus addresses of automatic variables may be invalid ! 161: * after cpu_fork returns in the child process. We do nothing here ! 162: * after cpu_fork returns. ! 163: */ ! 164: vm_fork(p1, p2, isvfork) ! 165: register struct proc *p1, *p2; ! 166: int isvfork; ! 167: { ! 168: register struct user *up; ! 169: vm_offset_t addr; ! 170: ! 171: #ifdef i386 ! 172: /* ! 173: * avoid copying any of the parent's pagetables or other per-process ! 174: * objects that reside in the map by marking all of them non-inheritable ! 175: */ ! 176: (void)vm_map_inherit(&p1->p_vmspace->vm_map, ! 177: UPT_MIN_ADDRESS-UPAGES*NBPG, VM_MAX_ADDRESS, VM_INHERIT_NONE); ! 178: #endif ! 179: p2->p_vmspace = vmspace_fork(p1->p_vmspace); ! 180: ! 181: #ifdef SYSVSHM ! 182: if (p1->p_vmspace->vm_shm) ! 183: shmfork(p1, p2, isvfork); ! 184: #endif ! 185: ! 186: /* ! 187: * Allocate a wired-down (for now) pcb and kernel stack for the process ! 188: */ ! 189: addr = kmem_alloc_pageable(kernel_map, ctob(UPAGES)); ! 190: vm_map_pageable(kernel_map, addr, addr + ctob(UPAGES), FALSE); ! 191: up = (struct user *)addr; ! 192: p2->p_addr = up; ! 193: ! 194: /* ! 195: * p_stats and p_sigacts currently point at fields ! 196: * in the user struct but not at &u, instead at p_addr. ! 197: * Copy p_sigacts and parts of p_stats; zero the rest ! 198: * of p_stats (statistics). ! 199: */ ! 200: p2->p_stats = &up->u_stats; ! 201: p2->p_sigacts = &up->u_sigacts; ! 202: up->u_sigacts = *p1->p_sigacts; ! 203: bzero(&up->u_stats.pstat_startzero, ! 204: (unsigned) ((caddr_t)&up->u_stats.pstat_endzero - ! 205: (caddr_t)&up->u_stats.pstat_startzero)); ! 206: bcopy(&p1->p_stats->pstat_startcopy, &up->u_stats.pstat_startcopy, ! 207: ((caddr_t)&up->u_stats.pstat_endcopy - ! 208: (caddr_t)&up->u_stats.pstat_startcopy)); ! 209: ! 210: #ifdef i386 ! 211: { u_int addr = UPT_MIN_ADDRESS - UPAGES*NBPG; struct vm_map *vp; ! 212: ! 213: vp = &p2->p_vmspace->vm_map; ! 214: (void)vm_map_pageable(vp, addr, 0xfe000000 - addr, TRUE); ! 215: (void)vm_deallocate(vp, addr, 0xfe000000 - addr); ! 216: (void)vm_allocate(vp, &addr, UPT_MAX_ADDRESS - addr, FALSE); ! 217: (void)vm_map_inherit(vp, addr, UPT_MAX_ADDRESS, VM_INHERIT_NONE); ! 218: } ! 219: #endif ! 220: /* ! 221: * cpu_fork will copy and update the kernel stack and pcb, ! 222: * and make the child ready to run. It marks the child ! 223: * so that it can return differently than the parent. ! 224: * It returns twice, once in the parent process and ! 225: * once in the child. ! 226: */ ! 227: return (cpu_fork(p1, p2)); ! 228: } ! 229: ! 230: /* ! 231: * Set default limits for VM system. ! 232: * Called for proc 0, and then inherited by all others. ! 233: */ ! 234: vm_init_limits(p) ! 235: register struct proc *p; ! 236: { ! 237: ! 238: /* ! 239: * Set up the initial limits on process VM. ! 240: * Set the maximum resident set size to be all ! 241: * of (reasonably) available memory. This causes ! 242: * any single, large process to start random page ! 243: * replacement once it fills memory. ! 244: */ ! 245: p->p_rlimit[RLIMIT_STACK].rlim_cur = DFLSSIZ; ! 246: p->p_rlimit[RLIMIT_STACK].rlim_max = MAXSSIZ; ! 247: p->p_rlimit[RLIMIT_DATA].rlim_cur = DFLDSIZ; ! 248: p->p_rlimit[RLIMIT_DATA].rlim_max = MAXDSIZ; ! 249: p->p_rlimit[RLIMIT_RSS].rlim_cur = p->p_rlimit[RLIMIT_RSS].rlim_max = ! 250: ptoa(vm_page_free_count); ! 251: } ! 252: ! 253: #include "../vm/vm_pageout.h" ! 254: ! 255: #ifdef DEBUG ! 256: int enableswap = 1; ! 257: int swapdebug = 0; ! 258: #define SDB_FOLLOW 1 ! 259: #define SDB_SWAPIN 2 ! 260: #define SDB_SWAPOUT 4 ! 261: #endif ! 262: ! 263: /* ! 264: * Brutally simple: ! 265: * 1. Attempt to swapin every swaped-out, runnable process in ! 266: * order of priority. ! 267: * 2. If not enough memory, wake the pageout daemon and let it ! 268: * clear some space. ! 269: */ ! 270: sched() ! 271: { ! 272: register struct proc *p; ! 273: register int pri; ! 274: struct proc *pp; ! 275: int ppri; ! 276: vm_offset_t addr; ! 277: vm_size_t size; ! 278: ! 279: loop: ! 280: #ifdef DEBUG ! 281: if (!enableswap) { ! 282: pp = NULL; ! 283: goto noswap; ! 284: } ! 285: #endif ! 286: pp = NULL; ! 287: ppri = INT_MIN; ! 288: for (p = allproc; p != NULL; p = p->p_nxt) ! 289: if (p->p_stat == SRUN && (p->p_flag & SLOAD) == 0) { ! 290: pri = p->p_time + p->p_slptime - p->p_nice * 8; ! 291: if (pri > ppri) { ! 292: pp = p; ! 293: ppri = pri; ! 294: } ! 295: } ! 296: #ifdef DEBUG ! 297: if (swapdebug & SDB_FOLLOW) ! 298: printf("sched: running, procp %x pri %d\n", pp, ppri); ! 299: noswap: ! 300: #endif ! 301: /* ! 302: * Nothing to do, back to sleep ! 303: */ ! 304: if ((p = pp) == NULL) { ! 305: sleep((caddr_t)&proc0, PVM); ! 306: goto loop; ! 307: } ! 308: ! 309: /* ! 310: * We would like to bring someone in. ! 311: * This part is really bogus cuz we could deadlock on memory ! 312: * despite our feeble check. ! 313: */ ! 314: size = round_page(ctob(UPAGES)); ! 315: addr = (vm_offset_t) p->p_addr; ! 316: if (vm_page_free_count > atop(size)) { ! 317: #ifdef DEBUG ! 318: if (swapdebug & SDB_SWAPIN) ! 319: printf("swapin: pid %d(%s)@%x, pri %d free %d\n", ! 320: p->p_pid, p->p_comm, p->p_addr, ! 321: ppri, vm_page_free_count); ! 322: #endif ! 323: vm_map_pageable(kernel_map, addr, addr+size, FALSE); ! 324: (void) splclock(); ! 325: if (p->p_stat == SRUN) ! 326: setrq(p); ! 327: p->p_flag |= SLOAD; ! 328: (void) spl0(); ! 329: p->p_time = 0; ! 330: goto loop; ! 331: } ! 332: /* ! 333: * Not enough memory, jab the pageout daemon and wait til the ! 334: * coast is clear. ! 335: */ ! 336: #ifdef DEBUG ! 337: if (swapdebug & SDB_FOLLOW) ! 338: printf("sched: no room for pid %d(%s), free %d\n", ! 339: p->p_pid, p->p_comm, vm_page_free_count); ! 340: #endif ! 341: (void) splhigh(); ! 342: VM_WAIT; ! 343: (void) spl0(); ! 344: #ifdef DEBUG ! 345: if (swapdebug & SDB_FOLLOW) ! 346: printf("sched: room again, free %d\n", vm_page_free_count); ! 347: #endif ! 348: goto loop; ! 349: } ! 350: ! 351: #define swappable(p) \ ! 352: (((p)->p_flag & (SSYS|SLOAD|SKEEP|SWEXIT|SPHYSIO)) == SLOAD) ! 353: ! 354: /* ! 355: * Swapout is driven by the pageout daemon. Very simple, we find eligible ! 356: * procs and unwire their u-areas. We try to always "swap" at least one ! 357: * process in case we need the room for a swapin. ! 358: * If any procs have been sleeping/stopped for at least maxslp seconds, ! 359: * they are swapped. Else, we swap the longest-sleeping or stopped process, ! 360: * if any, otherwise the longest-resident process. ! 361: */ ! 362: swapout_threads() ! 363: { ! 364: register struct proc *p; ! 365: struct proc *outp, *outp2; ! 366: int outpri, outpri2; ! 367: int didswap = 0; ! 368: extern int maxslp; ! 369: ! 370: #ifdef DEBUG ! 371: if (!enableswap) ! 372: return; ! 373: #endif ! 374: outp = outp2 = NULL; ! 375: outpri = outpri2 = 0; ! 376: for (p = allproc; p != NULL; p = p->p_nxt) { ! 377: if (!swappable(p)) ! 378: continue; ! 379: switch (p->p_stat) { ! 380: case SRUN: ! 381: if (p->p_time > outpri2) { ! 382: outp2 = p; ! 383: outpri2 = p->p_time; ! 384: } ! 385: continue; ! 386: ! 387: case SSLEEP: ! 388: case SSTOP: ! 389: if (p->p_slptime > maxslp) { ! 390: swapout(p); ! 391: didswap++; ! 392: } else if (p->p_slptime > outpri) { ! 393: outp = p; ! 394: outpri = p->p_slptime; ! 395: } ! 396: continue; ! 397: } ! 398: } ! 399: /* ! 400: * If we didn't get rid of any real duds, toss out the next most ! 401: * likely sleeping/stopped or running candidate. We only do this ! 402: * if we are real low on memory since we don't gain much by doing ! 403: * it (UPAGES pages). ! 404: */ ! 405: if (didswap == 0 && ! 406: vm_page_free_count <= atop(round_page(ctob(UPAGES)))) { ! 407: if ((p = outp) == 0) ! 408: p = outp2; ! 409: #ifdef DEBUG ! 410: if (swapdebug & SDB_SWAPOUT) ! 411: printf("swapout_threads: no duds, try procp %x\n", p); ! 412: #endif ! 413: if (p) ! 414: swapout(p); ! 415: } ! 416: } ! 417: ! 418: swapout(p) ! 419: register struct proc *p; ! 420: { ! 421: vm_offset_t addr; ! 422: vm_size_t size; ! 423: ! 424: #ifdef DEBUG ! 425: if (swapdebug & SDB_SWAPOUT) ! 426: printf("swapout: pid %d(%s)@%x, stat %x pri %d free %d\n", ! 427: p->p_pid, p->p_comm, p->p_addr, p->p_stat, ! 428: p->p_slptime, vm_page_free_count); ! 429: #endif ! 430: size = round_page(ctob(UPAGES)); ! 431: addr = (vm_offset_t) p->p_addr; ! 432: #ifdef hp300 ! 433: /* ! 434: * Ugh! u-area is double mapped to a fixed address behind the ! 435: * back of the VM system and accesses are usually through that ! 436: * address rather than the per-process address. Hence reference ! 437: * and modify information are recorded at the fixed address and ! 438: * lost at context switch time. We assume the u-struct and ! 439: * kernel stack are always accessed/modified and force it to be so. ! 440: */ ! 441: { ! 442: register int i; ! 443: volatile long tmp; ! 444: ! 445: for (i = 0; i < UPAGES; i++) { ! 446: tmp = *(long *)addr; *(long *)addr = tmp; ! 447: addr += NBPG; ! 448: } ! 449: addr = (vm_offset_t) p->p_addr; ! 450: } ! 451: #endif ! 452: vm_map_pageable(kernel_map, addr, addr+size, TRUE); ! 453: pmap_collect(vm_map_pmap(&p->p_vmspace->vm_map)); ! 454: (void) splhigh(); ! 455: p->p_flag &= ~SLOAD; ! 456: if (p->p_stat == SRUN) ! 457: remrq(p); ! 458: (void) spl0(); ! 459: p->p_time = 0; ! 460: } ! 461: ! 462: /* ! 463: * The rest of these routines fake thread handling ! 464: */ ! 465: ! 466: void ! 467: assert_wait(event, ruptible) ! 468: int event; ! 469: boolean_t ruptible; ! 470: { ! 471: #ifdef lint ! 472: ruptible++; ! 473: #endif ! 474: curproc->p_thread = event; ! 475: } ! 476: ! 477: void ! 478: thread_block() ! 479: { ! 480: int s = splhigh(); ! 481: ! 482: if (curproc->p_thread) ! 483: sleep((caddr_t)curproc->p_thread, PVM); ! 484: splx(s); ! 485: } ! 486: ! 487: thread_sleep(event, lock, ruptible) ! 488: int event; ! 489: simple_lock_t lock; ! 490: boolean_t ruptible; ! 491: { ! 492: #ifdef lint ! 493: ruptible++; ! 494: #endif ! 495: int s = splhigh(); ! 496: ! 497: curproc->p_thread = event; ! 498: simple_unlock(lock); ! 499: if (curproc->p_thread) ! 500: sleep((caddr_t)event, PVM); ! 501: splx(s); ! 502: } ! 503: ! 504: thread_wakeup(event) ! 505: int event; ! 506: { ! 507: int s = splhigh(); ! 508: ! 509: wakeup((caddr_t)event); ! 510: splx(s); ! 511: } ! 512: ! 513: /* ! 514: * DEBUG stuff ! 515: */ ! 516: ! 517: int indent = 0; ! 518: ! 519: /*ARGSUSED2*/ ! 520: iprintf(a, b, c, d, e, f, g, h) ! 521: char *a; ! 522: { ! 523: register int i; ! 524: ! 525: i = indent; ! 526: while (i >= 8) { ! 527: printf("\t"); ! 528: i -= 8; ! 529: } ! 530: for (; i > 0; --i) ! 531: printf(" "); ! 532: printf(a, b, c, d, e, f, g, h); ! 533: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.