[BACK]Return to uvm_page.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / uvm

Annotation of src/sys/uvm/uvm_page.h, Revision 1.52.2.1

1.52.2.1! yamt        1: /*     $NetBSD: uvm_page.h,v 1.52 2008/02/27 19:38:57 matt Exp $       */
1.1       mrg         2:
1.26      chs         3: /*
1.1       mrg         4:  * Copyright (c) 1997 Charles D. Cranor and Washington University.
1.26      chs         5:  * Copyright (c) 1991, 1993, The Regents of the University of California.
1.1       mrg         6:  *
                      7:  * All rights reserved.
                      8:  *
                      9:  * This code is derived from software contributed to Berkeley by
                     10:  * The Mach Operating System project at Carnegie-Mellon University.
                     11:  *
                     12:  * Redistribution and use in source and binary forms, with or without
                     13:  * modification, are permitted provided that the following conditions
                     14:  * are met:
                     15:  * 1. Redistributions of source code must retain the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer.
                     17:  * 2. Redistributions in binary form must reproduce the above copyright
                     18:  *    notice, this list of conditions and the following disclaimer in the
                     19:  *    documentation and/or other materials provided with the distribution.
                     20:  * 3. All advertising materials mentioning features or use of this software
                     21:  *    must display the following acknowledgement:
                     22:  *     This product includes software developed by Charles D. Cranor,
1.26      chs        23:  *      Washington University, the University of California, Berkeley and
1.1       mrg        24:  *      its contributors.
                     25:  * 4. Neither the name of the University nor the names of its contributors
                     26:  *    may be used to endorse or promote products derived from this software
                     27:  *    without specific prior written permission.
                     28:  *
                     29:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     30:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     31:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     32:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     33:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     34:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     35:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     36:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     37:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     38:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     39:  * SUCH DAMAGE.
                     40:  *
                     41:  *     @(#)vm_page.h   7.3 (Berkeley) 4/21/91
1.3       mrg        42:  * from: Id: uvm_page.h,v 1.1.2.6 1998/02/04 02:31:42 chuck Exp
1.1       mrg        43:  *
                     44:  *
                     45:  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
                     46:  * All rights reserved.
1.26      chs        47:  *
1.1       mrg        48:  * Permission to use, copy, modify and distribute this software and
                     49:  * its documentation is hereby granted, provided that both the copyright
                     50:  * notice and this permission notice appear in all copies of the
                     51:  * software, derivative works or modified versions, and any portions
                     52:  * thereof, and that both notices appear in supporting documentation.
1.26      chs        53:  *
                     54:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
                     55:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
1.1       mrg        56:  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
1.26      chs        57:  *
1.1       mrg        58:  * Carnegie Mellon requests users of this software to return to
                     59:  *
                     60:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
                     61:  *  School of Computer Science
                     62:  *  Carnegie Mellon University
                     63:  *  Pittsburgh PA 15213-3890
                     64:  *
                     65:  * any improvements or extensions that they make and grant Carnegie the
                     66:  * rights to redistribute these changes.
                     67:  */
                     68:
1.4       perry      69: #ifndef _UVM_UVM_PAGE_H_
                     70: #define _UVM_UVM_PAGE_H_
                     71:
1.1       mrg        72: /*
                     73:  * uvm_page.h
                     74:  */
                     75:
1.16      mrg        76: /*
                     77:  *     Resident memory system definitions.
                     78:  */
                     79:
                     80: /*
                     81:  *     Management of resident (logical) pages.
                     82:  *
                     83:  *     A small structure is kept for each resident
                     84:  *     page, indexed by page number.  Each structure
                     85:  *     is an element of several lists:
                     86:  *
                     87:  *             A hash table bucket used to quickly
                     88:  *             perform object/offset lookups
                     89:  *
                     90:  *             A list of all pages for a given object,
                     91:  *             so they can be quickly deactivated at
                     92:  *             time of deallocation.
                     93:  *
                     94:  *             An ordered list of pages due for pageout.
                     95:  *
                     96:  *     In addition, the structure contains the object
                     97:  *     and offset to which this page belongs (for pageout),
                     98:  *     and sundry status bits.
                     99:  *
                    100:  *     Fields in this structure are locked either by the lock on the
                    101:  *     object that the page belongs to (O) or by the lock on the page
                    102:  *     queues (P) [or both].
                    103:  */
                    104:
                    105: /*
                    106:  * locking note: the mach version of this data structure had bit
                    107:  * fields for the flags, and the bit fields were divided into two
                    108:  * items (depending on who locked what).  some time, in BSD, the bit
                    109:  * fields were dumped and all the flags were lumped into one short.
                    110:  * that is fine for a single threaded uniprocessor OS, but bad if you
1.51      ad        111:  * want to actual make use of locking.  so, we've separated things
                    112:  * back out again.
1.16      mrg       113:  *
                    114:  * note the page structure has no lock of its own.
                    115:  */
                    116:
                    117: #include <uvm/uvm_extern.h>
                    118: #include <uvm/uvm_pglist.h>
                    119:
                    120: struct vm_page {
1.18      chs       121:        TAILQ_ENTRY(vm_page)    pageq;          /* queue info for FIFO
                    122:                                                 * queue or free list (P) */
                    123:        TAILQ_ENTRY(vm_page)    hashq;          /* hash table links (O)*/
                    124:        TAILQ_ENTRY(vm_page)    listq;          /* pages in same object (O)*/
                    125:
                    126:        struct vm_anon          *uanon;         /* anon (O,P) */
                    127:        struct uvm_object       *uobject;       /* object (O,P) */
                    128:        voff_t                  offset;         /* offset into object (O,P) */
1.31      chs       129:        uint16_t                flags;          /* object flags [O] */
                    130:        uint16_t                loan_count;     /* number of active loans
1.18      chs       131:                                                 * to read: [O or P]
                    132:                                                 * to modify: [O _and_ P] */
1.31      chs       133:        uint16_t                wire_count;     /* wired down map refs [P] */
                    134:        uint16_t                pqflags;        /* page queue flags [P] */
1.18      chs       135:        paddr_t                 phys_addr;      /* physical address of page */
1.21      thorpej   136:
1.22      thorpej   137: #ifdef __HAVE_VM_PAGE_MD
                    138:        struct vm_page_md       mdpage;         /* pmap-specific data */
                    139: #endif
1.21      thorpej   140:
1.16      mrg       141: #if defined(UVM_PAGE_TRKOWN)
1.18      chs       142:        /* debugging fields to track page ownership */
                    143:        pid_t                   owner;          /* proc that set PG_BUSY */
1.48      perseant  144:        lwpid_t                 lowner;         /* lwp that set PG_BUSY */
1.40      chs       145:        const char              *owner_tag;     /* why it was set busy */
1.16      mrg       146: #endif
                    147: };
                    148:
                    149: /*
                    150:  * These are the flags defined for vm_page.
                    151:  */
                    152:
                    153: /*
                    154:  * locking rules:
                    155:  *   PG_ ==> locked by object lock
1.26      chs       156:  *   PQ_ ==> lock by page queue lock
1.16      mrg       157:  *   PQ_FREE is locked by free queue lock and is mutex with all other PQs
                    158:  *
                    159:  * PG_ZERO is used to indicate that a page has been pre-zero'd.  This flag
                    160:  * is only set when the page is on no queues, and is cleared when the page
                    161:  * is placed on the free list.
                    162:  */
1.18      chs       163:
                    164: #define        PG_BUSY         0x0001          /* page is locked */
                    165: #define        PG_WANTED       0x0002          /* someone is waiting for page */
                    166: #define        PG_TABLED       0x0004          /* page is in VP table  */
1.16      mrg       167: #define        PG_CLEAN        0x0008          /* page has not been modified */
1.31      chs       168: #define        PG_PAGEOUT      0x0010          /* page to be freed for pagedaemon */
                    169: #define PG_RELEASED    0x0020          /* page to be freed when unbusied */
1.18      chs       170: #define        PG_FAKE         0x0040          /* page is not yet initialized */
1.31      chs       171: #define        PG_RDONLY       0x0080          /* page must be mapped read-only */
                    172: #define        PG_ZERO         0x0100          /* page is pre-zero'd */
1.18      chs       173:
                    174: #define PG_PAGER1      0x1000          /* pager-specific flag */
1.16      mrg       175:
1.46      yamt      176: #define        UVM_PGFLAGBITS \
                    177:        "\20\1BUSY\2WANTED\3TABLED\4CLEAN\5PAGEOUT\6RELEASED\7FAKE\10RDONLY" \
                    178:        "\11ZERO\15PAGER1"
                    179:
                    180: #define PQ_FREE                0x0001          /* page is on free list */
                    181: #define PQ_ANON                0x0002          /* page is part of an anon, rather
1.16      mrg       182:                                           than an uvm_object */
1.46      yamt      183: #define PQ_AOBJ                0x0004          /* page is part of an anonymous
1.16      mrg       184:                                           uvm_object */
                    185: #define PQ_SWAPBACKED  (PQ_ANON|PQ_AOBJ)
1.46      yamt      186: #define PQ_READAHEAD   0x0008  /* read-ahead but has not been "hit" yet */
                    187:
                    188: #define PQ_PRIVATE1    0x0100
                    189: #define PQ_PRIVATE2    0x0200
                    190: #define PQ_PRIVATE3    0x0400
                    191: #define PQ_PRIVATE4    0x0800
                    192: #define PQ_PRIVATE5    0x1000
                    193: #define PQ_PRIVATE6    0x2000
                    194: #define PQ_PRIVATE7    0x4000
                    195: #define PQ_PRIVATE8    0x8000
                    196:
                    197: #define        UVM_PQFLAGBITS \
                    198:        "\20\1FREE\2ANON\3AOBJ\4READAHEAD" \
                    199:        "\11PRIVATE1\12PRIVATE2\13PRIVATE3\14PRIVATE4" \
                    200:        "\15PRIVATE5\16PRIVATE6\17PRIVATE7\20PRIVATE8"
1.16      mrg       201:
                    202: /*
                    203:  * physical memory layout structure
                    204:  *
                    205:  * MD vmparam.h must #define:
                    206:  *   VM_PHYSEG_MAX = max number of physical memory segments we support
                    207:  *                (if this is "1" then we revert to a "contig" case)
                    208:  *   VM_PHYSSEG_STRAT: memory sort/search options (for VM_PHYSEG_MAX > 1)
                    209:  *     - VM_PSTRAT_RANDOM:   linear search (random order)
                    210:  *     - VM_PSTRAT_BSEARCH:  binary search (sorted by address)
                    211:  *     - VM_PSTRAT_BIGFIRST: linear search (sorted by largest segment first)
                    212:  *      - others?
1.17      mrg       213:  *   XXXCDC: eventually we should purge all left-over global variables...
1.16      mrg       214:  */
                    215: #define VM_PSTRAT_RANDOM       1
                    216: #define VM_PSTRAT_BSEARCH      2
                    217: #define VM_PSTRAT_BIGFIRST     3
                    218:
                    219: /*
1.45      uebayasi  220:  * vm_physseg: describes one segment of physical memory
1.16      mrg       221:  */
                    222: struct vm_physseg {
                    223:        paddr_t start;                  /* PF# of first page in segment */
                    224:        paddr_t end;                    /* (PF# of last page in segment) + 1 */
                    225:        paddr_t avail_start;            /* PF# of first free page in segment */
                    226:        paddr_t avail_end;              /* (PF# of last free page in segment) +1  */
                    227:        int     free_list;              /* which free list they belong on */
                    228:        struct  vm_page *pgs;           /* vm_page structures (from start) */
                    229:        struct  vm_page *lastpg;        /* vm_page structure for end */
1.22      thorpej   230: #ifdef __HAVE_PMAP_PHYSSEG
1.16      mrg       231:        struct  pmap_physseg pmseg;     /* pmap specific (MD) data */
1.21      thorpej   232: #endif
1.16      mrg       233: };
                    234:
1.13      thorpej   235: #ifdef _KERNEL
                    236:
1.1       mrg       237: /*
1.15      thorpej   238:  * globals
                    239:  */
                    240:
1.47      thorpej   241: extern bool vm_page_zero_enable;
1.15      thorpej   242:
                    243: /*
1.16      mrg       244:  * physical memory config is stored in vm_physmem.
                    245:  */
1.1       mrg       246:
1.16      mrg       247: extern struct vm_physseg vm_physmem[VM_PHYSSEG_MAX];
                    248: extern int vm_nphysseg;
1.15      thorpej   249:
1.1       mrg       250: /*
1.8       chuck     251:  * prototypes: the following prototypes define the interface to pages
1.1       mrg       252:  */
                    253:
1.37      junyoung  254: void uvm_page_init(vaddr_t *, vaddr_t *);
1.1       mrg       255: #if defined(UVM_PAGE_TRKOWN)
1.40      chs       256: void uvm_page_own(struct vm_page *, const char *);
1.1       mrg       257: #endif
1.8       chuck     258: #if !defined(PMAP_STEAL_MEMORY)
1.47      thorpej   259: bool uvm_page_physget(paddr_t *);
1.8       chuck     260: #endif
1.37      junyoung  261: void uvm_page_rehash(void);
                    262: void uvm_page_recolor(int);
                    263: void uvm_pageidlezero(void);
                    264:
1.43      yamt      265: void uvm_pageactivate(struct vm_page *);
1.37      junyoung  266: vaddr_t uvm_pageboot_alloc(vsize_t);
1.43      yamt      267: void uvm_pagecopy(struct vm_page *, struct vm_page *);
                    268: void uvm_pagedeactivate(struct vm_page *);
                    269: void uvm_pagedequeue(struct vm_page *);
1.46      yamt      270: void uvm_pageenqueue(struct vm_page *);
1.37      junyoung  271: void uvm_pagefree(struct vm_page *);
                    272: void uvm_page_unbusy(struct vm_page **, int);
1.43      yamt      273: struct vm_page *uvm_pagelookup(struct uvm_object *, voff_t);
                    274: void uvm_pageunwire(struct vm_page *);
                    275: void uvm_pagewait(struct vm_page *, int);
                    276: void uvm_pagewake(struct vm_page *);
                    277: void uvm_pagewire(struct vm_page *);
                    278: void uvm_pagezero(struct vm_page *);
1.9       thorpej   279:
1.43      yamt      280: int uvm_page_lookup_freelist(struct vm_page *);
1.16      mrg       281:
1.37      junyoung  282: static struct vm_page *PHYS_TO_VM_PAGE(paddr_t);
                    283: static int vm_physseg_find(paddr_t, int *);
1.16      mrg       284:
                    285: /*
                    286:  * macros
                    287:  */
1.31      chs       288:
                    289: #define UVM_PAGE_HASH_PENALTY  4       /* XXX: a guess */
1.16      mrg       290:
                    291: #define uvm_pagehash(obj,off) \
                    292:        (((unsigned long)obj+(unsigned long)atop(off)) & uvm.page_hashmask)
                    293:
1.52.2.1! yamt      294: #define        UVM_PAGEZERO_LOWAT      (uvmexp.free >> 1)
        !           295: #define        UVM_PAGEZERO_HIWAT      (uvmexp.free * 10 / 9)
1.16      mrg       296:
                    297: #define VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr)
1.20      thorpej   298:
                    299: /*
                    300:  * Compute the page color bucket for a given page.
                    301:  */
                    302: #define        VM_PGCOLOR_BUCKET(pg) \
1.24      thorpej   303:        (atop(VM_PAGE_TO_PHYS((pg))) & uvmexp.colormask)
1.16      mrg       304:
                    305: /*
                    306:  * when VM_PHYSSEG_MAX is 1, we can simplify these functions
                    307:  */
                    308:
                    309: /*
                    310:  * vm_physseg_find: find vm_physseg structure that belongs to a PA
                    311:  */
1.44      perry     312: static __inline int
1.52      matt      313: vm_physseg_find(paddr_t pframe, int *offp)
1.16      mrg       314: {
                    315: #if VM_PHYSSEG_MAX == 1
                    316:
                    317:        /* 'contig' case */
                    318:        if (pframe >= vm_physmem[0].start && pframe < vm_physmem[0].end) {
                    319:                if (offp)
                    320:                        *offp = pframe - vm_physmem[0].start;
                    321:                return(0);
                    322:        }
                    323:        return(-1);
                    324:
                    325: #elif (VM_PHYSSEG_STRAT == VM_PSTRAT_BSEARCH)
                    326:        /* binary search for it */
1.36      rearnsha  327:        u_int   start, len, try;
1.16      mrg       328:
                    329:        /*
1.32      enami     330:         * if try is too large (thus target is less than try) we reduce
1.16      mrg       331:         * the length to trunc(len/2) [i.e. everything smaller than "try"]
                    332:         *
                    333:         * if the try is too small (thus target is greater than try) then
                    334:         * we set the new start to be (try + 1).   this means we need to
                    335:         * reduce the length to (round(len/2) - 1).
                    336:         *
                    337:         * note "adjust" below which takes advantage of the fact that
                    338:         *  (round(len/2) - 1) == trunc((len - 1) / 2)
                    339:         * for any value of len we may have
                    340:         */
                    341:
                    342:        for (start = 0, len = vm_nphysseg ; len != 0 ; len = len / 2) {
                    343:                try = start + (len / 2);        /* try in the middle */
                    344:
                    345:                /* start past our try? */
                    346:                if (pframe >= vm_physmem[try].start) {
                    347:                        /* was try correct? */
                    348:                        if (pframe < vm_physmem[try].end) {
                    349:                                if (offp)
                    350:                                        *offp = pframe - vm_physmem[try].start;
                    351:                                return(try);            /* got it */
                    352:                        }
                    353:                        start = try + 1;        /* next time, start here */
                    354:                        len--;                  /* "adjust" */
                    355:                } else {
                    356:                        /*
                    357:                         * pframe before try, just reduce length of
                    358:                         * region, done in "for" loop
                    359:                         */
                    360:                }
                    361:        }
                    362:        return(-1);
                    363:
                    364: #else
                    365:        /* linear search for it */
                    366:        int     lcv;
                    367:
                    368:        for (lcv = 0; lcv < vm_nphysseg; lcv++) {
                    369:                if (pframe >= vm_physmem[lcv].start &&
                    370:                    pframe < vm_physmem[lcv].end) {
                    371:                        if (offp)
                    372:                                *offp = pframe - vm_physmem[lcv].start;
                    373:                        return(lcv);               /* got it */
                    374:                }
                    375:        }
                    376:        return(-1);
                    377:
                    378: #endif
                    379: }
                    380:
                    381:
                    382: /*
                    383:  * IS_VM_PHYSADDR: only used my mips/pmax/pica trap/pmap.
                    384:  */
                    385:
                    386: #define IS_VM_PHYSADDR(PA) (vm_physseg_find(atop(PA), NULL) != -1)
                    387:
                    388: /*
                    389:  * PHYS_TO_VM_PAGE: find vm_page for a PA.   used by MI code to get vm_pages
                    390:  * back from an I/O mapping (ugh!).   used in some MD code as well.
                    391:  */
1.44      perry     392: static __inline struct vm_page *
1.52      matt      393: PHYS_TO_VM_PAGE(paddr_t pa)
1.16      mrg       394: {
                    395:        paddr_t pf = atop(pa);
                    396:        int     off;
                    397:        int     psi;
                    398:
                    399:        psi = vm_physseg_find(pf, &off);
                    400:        if (psi != -1)
                    401:                return(&vm_physmem[psi].pgs[off]);
                    402:        return(NULL);
                    403: }
                    404:
                    405: #define VM_PAGE_IS_FREE(entry)  ((entry)->pqflags & PQ_FREE)
1.35      yamt      406:
                    407: #ifdef DEBUG
                    408: void uvm_pagezerocheck(struct vm_page *);
                    409: #endif /* DEBUG */
1.13      thorpej   410:
                    411: #endif /* _KERNEL */
1.1       mrg       412:
1.4       perry     413: #endif /* _UVM_UVM_PAGE_H_ */

CVSweb <webmaster@jp.NetBSD.org>