sys/arch/alpha/include/pmap.h

   1 /* $NetBSD: pmap.h,v 1.74 2009/03/15 22:19:15 cegger Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1998, 1999, 2000, 2001, 2007 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center and by Chris G. Demetriou.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Copyright (c) 1991, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  *
  37  * This code is derived from software contributed to Berkeley by
  38  * the Systems Programming Group of the University of Utah Computer
  39  * Science Department.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. Neither the name of the University nor the names of its contributors
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  63  * SUCH DAMAGE.
  64  *
  65  *      @(#)pmap.h      8.1 (Berkeley) 6/10/93
  66  */
  67
  68 /*
  69  * Copyright (c) 1987 Carnegie-Mellon University
  70  *
  71  * This code is derived from software contributed to Berkeley by
  72  * the Systems Programming Group of the University of Utah Computer
  73  * Science Department.
  74  *
  75  * Redistribution and use in source and binary forms, with or without
  76  * modification, are permitted provided that the following conditions
  77  * are met:
  78  * 1. Redistributions of source code must retain the above copyright
  79  *    notice, this list of conditions and the following disclaimer.
  80  * 2. Redistributions in binary form must reproduce the above copyright
  81  *    notice, this list of conditions and the following disclaimer in the
  82  *    documentation and/or other materials provided with the distribution.
  83  * 3. All advertising materials mentioning features or use of this software
  84  *    must display the following acknowledgement:
  85  *      This product includes software developed by the University of
  86  *      California, Berkeley and its contributors.
  87  * 4. Neither the name of the University nor the names of its contributors
  88  *    may be used to endorse or promote products derived from this software
  89  *    without specific prior written permission.
  90  *
  91  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  92  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  93  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  94  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  95  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  96  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  97  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  98  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  99  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 100  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 101  * SUCH DAMAGE.
 102  *
 103  *      @(#)pmap.h      8.1 (Berkeley) 6/10/93
 104  */
 105
 106 #ifndef _PMAP_MACHINE_
 107 #define _PMAP_MACHINE_
 108
 109 #if defined(_KERNEL_OPT)
 110 #include "opt_multiprocessor.h"
 111 #endif
 112
 113 #include <sys/mutex.h>
 114 #include <sys/queue.h>
 115
 116 #include <machine/pte.h>
 117
 118 /*
 119  * Machine-dependent virtual memory state.
 120  *
 121  * If we ever support processor numbers higher than 63, we'll have to
 122  * rethink the CPU mask.
 123  *
 124  * Note pm_asn and pm_asngen are arrays allocated in pmap_create().
 125  * Their size is based on the PCS count from the HWRPB, and indexed
 126  * by processor ID (from `whami').
 127  *
 128  * The kernel pmap is a special case; it gets statically-allocated
 129  * arrays which hold enough for ALPHA_MAXPROCS.
 130  */
 131 struct pmap_asn_info {
 132         unsigned int            pma_asn;        /* address space number */
 133         unsigned long           pma_asngen;     /* ASN generation number */
 134 };
 135
 136 struct pmap {
 137         TAILQ_ENTRY(pmap)       pm_list;        /* list of all pmaps */
 138         pt_entry_t              *pm_lev1map;    /* level 1 map */
 139         int                     pm_count;       /* pmap reference count */
 140         kmutex_t                pm_lock;        /* lock on pmap */
 141         struct pmap_statistics  pm_stats;       /* pmap statistics */
 142         unsigned long           pm_cpus;        /* mask of CPUs using pmap */
 143         unsigned long           pm_needisync;   /* mask of CPUs needing isync */
 144         struct pmap_asn_info    pm_asni[1];     /* ASN information */
 145                         /*      variable length         */
 146 };
 147
 148 /*
 149  * Compute the sizeof of a pmap structure.  Subtract one because one
 150  * ASN info structure is already included in the pmap structure itself.
 151  */
 152 #define PMAP_SIZEOF(x)                                                  \
 153         (ALIGN(sizeof(struct pmap) +                                    \
 154                (sizeof(struct pmap_asn_info) * ((x) - 1))))
 155
 156 #define PMAP_ASN_RESERVED       0       /* reserved for Lev1map users */
 157
 158 /*
 159  * For each struct vm_page, there is a list of all currently valid virtual
 160  * mappings of that page.  An entry is a pv_entry_t, the list is pv_table.
 161  */
 162 typedef struct pv_entry {
 163         struct pv_entry *pv_next;       /* next pv_entry on list */
 164         struct pmap     *pv_pmap;       /* pmap where mapping lies */
 165         vaddr_t         pv_va;          /* virtual address for mapping */
 166         pt_entry_t      *pv_pte;        /* PTE that maps the VA */
 167 } *pv_entry_t;
 168
 169 /* pvh_attrs */
 170 #define PGA_MODIFIED            0x01            /* modified */
 171 #define PGA_REFERENCED          0x02            /* referenced */
 172
 173 /* pvh_usage */
 174 #define PGU_NORMAL              0               /* free or normal use */
 175 #define PGU_PVENT               1               /* PV entries */
 176 #define PGU_L1PT                2               /* level 1 page table */
 177 #define PGU_L2PT                3               /* level 2 page table */
 178 #define PGU_L3PT                4               /* level 3 page table */
 179
 180 #ifdef _KERNEL
 181
 182 #include <sys/atomic.h>
 183
 184 #ifdef _KERNEL_OPT
 185 #include "opt_dec_kn8ae.h"                      /* XXX */
 186 #if defined(DEC_KN8AE)
 187 #define _PMAP_MAY_USE_PROM_CONSOLE
 188 #endif
 189 #else
 190 #define _PMAP_MAY_USE_PROM_CONSOLE
 191 #endif
 192
 193 #ifndef _LKM
 194 #if defined(MULTIPROCESSOR)
 195 struct cpu_info;
 196 struct trapframe;
 197
 198 void    pmap_tlb_shootdown(pmap_t, vaddr_t, pt_entry_t, u_long *);
 199 void    pmap_tlb_shootnow(u_long);
 200 void    pmap_do_tlb_shootdown(struct cpu_info *, struct trapframe *);
 201 #define PMAP_TLB_SHOOTDOWN_CPUSET_DECL          u_long shootset = 0;
 202 #define PMAP_TLB_SHOOTDOWN(pm, va, pte)                                 \
 203         pmap_tlb_shootdown((pm), (va), (pte), &shootset)
 204 #define PMAP_TLB_SHOOTNOW()                                             \
 205         pmap_tlb_shootnow(shootset)
 206 #else
 207 #define PMAP_TLB_SHOOTDOWN_CPUSET_DECL          /* nothing */
 208 #define PMAP_TLB_SHOOTDOWN(pm, va, pte)         /* nothing */
 209 #define PMAP_TLB_SHOOTNOW()                     /* nothing */
 210 #endif /* MULTIPROCESSOR */
 211 #endif /* _LKM */
 212
 213 #define pmap_resident_count(pmap)       ((pmap)->pm_stats.resident_count)
 214 #define pmap_wired_count(pmap)          ((pmap)->pm_stats.wired_count)
 215
 216 #define pmap_copy(dp, sp, da, l, sa)    /* nothing */
 217 #define pmap_update(pmap)               /* nothing (yet) */
 218
 219 static __inline void
 220 pmap_remove_all(struct pmap *pmap)
 221 {
 222         /* Nothing. */
 223 }
 224
 225 #define pmap_is_referenced(pg)                                          \
 226         (((pg)->mdpage.pvh_attrs & PGA_REFERENCED) != 0)
 227 #define pmap_is_modified(pg)                                            \
 228         (((pg)->mdpage.pvh_attrs & PGA_MODIFIED) != 0)
 229
 230 #define PMAP_STEAL_MEMORY               /* enable pmap_steal_memory() */
 231 #define PMAP_GROWKERNEL                 /* enable pmap_growkernel() */
 232
 233 /*
 234  * Alternate mapping hooks for pool pages.  Avoids thrashing the TLB.
 235  */
 236 #define PMAP_MAP_POOLPAGE(pa)           ALPHA_PHYS_TO_K0SEG((pa))
 237 #define PMAP_UNMAP_POOLPAGE(va)         ALPHA_K0SEG_TO_PHYS((va))
 238
 239 /*
 240  * Other hooks for the pool allocator.
 241  */
 242 #define POOL_VTOPHYS(va)                ALPHA_K0SEG_TO_PHYS((vaddr_t) (va))
 243
 244 bool    pmap_pageidlezero(paddr_t);
 245 #define PMAP_PAGEIDLEZERO(pa)   pmap_pageidlezero((pa))
 246
 247 paddr_t vtophys(vaddr_t);
 248
 249 /* Machine-specific functions. */
 250 void    pmap_bootstrap(paddr_t, u_int, u_long);
 251 int     pmap_emulate_reference(struct lwp *, vaddr_t, int, int);
 252 #ifdef _PMAP_MAY_USE_PROM_CONSOLE
 253 int     pmap_uses_prom_console(void);
 254 #endif
 255
 256 #define pmap_pte_pa(pte)        (PG_PFNUM(*(pte)) << PGSHIFT)
 257 #define pmap_pte_prot(pte)      (*(pte) & PG_PROT)
 258 #define pmap_pte_w(pte)         (*(pte) & PG_WIRED)
 259 #define pmap_pte_v(pte)         (*(pte) & PG_V)
 260 #define pmap_pte_pv(pte)        (*(pte) & PG_PVLIST)
 261 #define pmap_pte_asm(pte)       (*(pte) & PG_ASM)
 262 #define pmap_pte_exec(pte)      (*(pte) & PG_EXEC)
 263
 264 #define pmap_pte_set_w(pte, v)                                          \
 265 do {                                                                    \
 266         if (v)                                                          \
 267                 *(pte) |= PG_WIRED;                                     \
 268         else                                                            \
 269                 *(pte) &= ~PG_WIRED;                                    \
 270 } while (0)
 271
 272 #define pmap_pte_w_chg(pte, nw) ((nw) ^ pmap_pte_w(pte))
 273
 274 #define pmap_pte_set_prot(pte, np)                                      \
 275 do {                                                                    \
 276         *(pte) &= ~PG_PROT;                                             \
 277         *(pte) |= (np);                                                 \
 278 } while (0)
 279
 280 #define pmap_pte_prot_chg(pte, np) ((np) ^ pmap_pte_prot(pte))
 281
 282 static __inline pt_entry_t *pmap_l2pte(pmap_t, vaddr_t, pt_entry_t *);
 283 static __inline pt_entry_t *pmap_l3pte(pmap_t, vaddr_t, pt_entry_t *);
 284
 285 #define pmap_l1pte(pmap, v)                                             \
 286         (&(pmap)->pm_lev1map[l1pte_index((vaddr_t)(v))])
 287
 288 static __inline pt_entry_t *
 289 pmap_l2pte(pmap_t pmap, vaddr_t v, pt_entry_t *l1pte)
 290 {
 291         pt_entry_t *lev2map;
 292
 293         if (l1pte == NULL) {
 294                 l1pte = pmap_l1pte(pmap, v);
 295                 if (pmap_pte_v(l1pte) == 0)
 296                         return (NULL);
 297         }
 298
 299         lev2map = (pt_entry_t *)ALPHA_PHYS_TO_K0SEG(pmap_pte_pa(l1pte));
 300         return (&lev2map[l2pte_index(v)]);
 301 }
 302
 303 static __inline pt_entry_t *
 304 pmap_l3pte(pmap_t pmap, vaddr_t v, pt_entry_t *l2pte)
 305 {
 306         pt_entry_t *l1pte, *lev2map, *lev3map;
 307
 308         if (l2pte == NULL) {
 309                 l1pte = pmap_l1pte(pmap, v);
 310                 if (pmap_pte_v(l1pte) == 0)
 311                         return (NULL);
 312
 313                 lev2map = (pt_entry_t *)ALPHA_PHYS_TO_K0SEG(pmap_pte_pa(l1pte));
 314                 l2pte = &lev2map[l2pte_index(v)];
 315                 if (pmap_pte_v(l2pte) == 0)
 316                         return (NULL);
 317         }
 318
 319         lev3map = (pt_entry_t *)ALPHA_PHYS_TO_K0SEG(pmap_pte_pa(l2pte));
 320         return (&lev3map[l3pte_index(v)]);
 321 }
 322
 323 /*
 324  * Macros for locking pmap structures.
 325  *
 326  * Note that we if we access the kernel pmap in interrupt context, it
 327  * is only to update statistics.  Since stats are updated using atomic
 328  * operations, locking the kernel pmap is not necessary.  Therefore,
 329  * it is not necessary to block interrupts when locking pmap strucutres.
 330  */
 331 #define PMAP_LOCK(pmap)         mutex_enter(&(pmap)->pm_lock)
 332 #define PMAP_UNLOCK(pmap)       mutex_exit(&(pmap)->pm_lock)
 333
 334 /*
 335  * Macro for processing deferred I-stream synchronization.
 336  *
 337  * The pmap module may defer syncing the user I-stream until the
 338  * return to userspace, since the IMB PALcode op can be quite
 339  * expensive.  Since user instructions won't be executed until
 340  * the return to userspace, this can be deferred until userret().
 341  */
 342 #define PMAP_USERRET(pmap)                                              \
 343 do {                                                                    \
 344         u_long cpu_mask = (1UL << cpu_number());                        \
 345                                                                         \
 346         if ((pmap)->pm_needisync & cpu_mask) {                          \
 347                 atomic_and_ulong(&(pmap)->pm_needisync, ~cpu_mask);     \
 348                 alpha_pal_imb();                                        \
 349         }                                                               \
 350 } while (0)
 351
 352 #endif /* _KERNEL */
 353
 354 #endif /* _PMAP_MACHINE_ */