The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/powerpc/powerpc/pmap_dispatch.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2005 Peter Grehan
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  */
   27 
   28 #include <sys/cdefs.h>
   29 __FBSDID("$FreeBSD: releng/9.2/sys/powerpc/powerpc/pmap_dispatch.c 251897 2013-06-18 05:21:40Z scottl $");
   30 
   31 /*
   32  * Dispatch MI pmap calls to the appropriate MMU implementation
   33  * through a previously registered kernel object.
   34  *
   35  * Before pmap_bootstrap() can be called, a CPU module must have
   36  * called pmap_mmu_install(). This may be called multiple times:
   37  * the highest priority call will be installed as the default
   38  * MMU handler when pmap_bootstrap() is called.
   39  *
   40  * It is required that mutex_init() be called before pmap_bootstrap(), 
   41  * as the PMAP layer makes extensive use of mutexes.
   42  */
   43 
   44 #include <sys/param.h>
   45 #include <sys/kernel.h>
   46 #include <sys/lock.h>
   47 #include <sys/ktr.h>
   48 #include <sys/mutex.h>
   49 #include <sys/systm.h>
   50 
   51 #include <vm/vm.h>
   52 #include <vm/vm_page.h>
   53 
   54 #include <machine/mmuvar.h>
   55 #include <machine/smp.h>
   56 
   57 #include "mmu_if.h"
   58 
   59 static mmu_def_t        *mmu_def_impl;
   60 static mmu_t            mmu_obj;
   61 static struct mmu_kobj  mmu_kernel_obj;
   62 static struct kobj_ops  mmu_kernel_kops;
   63 
   64 /*
   65  * pmap globals
   66  */
   67 struct pmap kernel_pmap_store;
   68 
   69 struct msgbuf *msgbufp;
   70 vm_offset_t    msgbuf_phys;
   71 
   72 vm_offset_t kernel_vm_end;
   73 vm_offset_t phys_avail[PHYS_AVAIL_SZ];
   74 vm_offset_t virtual_avail;
   75 vm_offset_t virtual_end;
   76 
   77 int pmap_bootstrapped;
   78 
   79 void
   80 pmap_change_wiring(pmap_t pmap, vm_offset_t va, boolean_t wired)
   81 {
   82 
   83         CTR4(KTR_PMAP, "%s(%p, %#x, %u)", __func__, pmap, va, wired);
   84         MMU_CHANGE_WIRING(mmu_obj, pmap, va, wired);
   85 }
   86 
   87 void
   88 pmap_clear_modify(vm_page_t m)
   89 {
   90 
   91         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
   92         MMU_CLEAR_MODIFY(mmu_obj, m);
   93 }
   94 
   95 void
   96 pmap_clear_reference(vm_page_t m)
   97 {
   98 
   99         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  100         MMU_CLEAR_REFERENCE(mmu_obj, m);
  101 }
  102 
  103 void
  104 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
  105     vm_size_t len, vm_offset_t src_addr)
  106 {
  107 
  108         CTR6(KTR_PMAP, "%s(%p, %p, %#x, %#x, %#x)", __func__, dst_pmap,
  109             src_pmap, dst_addr, len, src_addr);
  110         MMU_COPY(mmu_obj, dst_pmap, src_pmap, dst_addr, len, src_addr);
  111 }
  112 
  113 void
  114 pmap_copy_page(vm_page_t src, vm_page_t dst)
  115 {
  116 
  117         CTR3(KTR_PMAP, "%s(%p, %p)", __func__, src, dst);
  118         MMU_COPY_PAGE(mmu_obj, src, dst);
  119 }
  120 
  121 void
  122 pmap_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
  123     vm_offset_t b_offset, int xfersize)
  124 {
  125 
  126         CTR6(KTR_PMAP, "%s(%p, %#x, %p, %#x, %#x)", __func__, ma,
  127             a_offset, mb, b_offset, xfersize);
  128         MMU_COPY_PAGES(mmu_obj, ma, a_offset, mb, b_offset, xfersize);
  129 }
  130 
  131 void
  132 pmap_enter(pmap_t pmap, vm_offset_t va, vm_prot_t access, vm_page_t p,
  133     vm_prot_t prot, boolean_t wired)
  134 {
  135 
  136         CTR6(KTR_PMAP, "pmap_enter(%p, %#x, %#x, %p, %#x, %u)", pmap, va,
  137             access, p, prot, wired);
  138         MMU_ENTER(mmu_obj, pmap, va, p, prot, wired);
  139 }
  140 
  141 void
  142 pmap_enter_object(pmap_t pmap, vm_offset_t start, vm_offset_t end,
  143     vm_page_t m_start, vm_prot_t prot)
  144 {
  145 
  146         CTR6(KTR_PMAP, "%s(%p, %#x, %#x, %p, %#x)", __func__, pmap, start,
  147             end, m_start, prot);
  148         MMU_ENTER_OBJECT(mmu_obj, pmap, start, end, m_start, prot);
  149 }
  150 
  151 void
  152 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot)
  153 {
  154 
  155         CTR5(KTR_PMAP, "%s(%p, %#x, %p, %#x)", __func__, pmap, va, m, prot);
  156         MMU_ENTER_QUICK(mmu_obj, pmap, va, m, prot);
  157 }
  158 
  159 vm_paddr_t
  160 pmap_extract(pmap_t pmap, vm_offset_t va)
  161 {
  162 
  163         CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, va);
  164         return (MMU_EXTRACT(mmu_obj, pmap, va));
  165 }
  166 
  167 vm_page_t
  168 pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
  169 {
  170 
  171         CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pmap, va, prot);
  172         return (MMU_EXTRACT_AND_HOLD(mmu_obj, pmap, va, prot));
  173 }
  174 
  175 void
  176 pmap_growkernel(vm_offset_t va)
  177 {
  178 
  179         CTR2(KTR_PMAP, "%s(%#x)", __func__, va);
  180         MMU_GROWKERNEL(mmu_obj, va);
  181 }
  182 
  183 void
  184 pmap_init(void)
  185 {
  186 
  187         CTR1(KTR_PMAP, "%s()", __func__);
  188         MMU_INIT(mmu_obj);
  189 }
  190 
  191 boolean_t
  192 pmap_is_modified(vm_page_t m)
  193 {
  194 
  195         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  196         return (MMU_IS_MODIFIED(mmu_obj, m));
  197 }
  198 
  199 boolean_t
  200 pmap_is_prefaultable(pmap_t pmap, vm_offset_t va)
  201 {
  202 
  203         CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, va);
  204         return (MMU_IS_PREFAULTABLE(mmu_obj, pmap, va));
  205 }
  206 
  207 boolean_t
  208 pmap_is_referenced(vm_page_t m)
  209 {
  210 
  211         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  212         return (MMU_IS_REFERENCED(mmu_obj, m));
  213 }
  214 
  215 boolean_t
  216 pmap_ts_referenced(vm_page_t m)
  217 {
  218 
  219         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  220         return (MMU_TS_REFERENCED(mmu_obj, m));
  221 }
  222 
  223 vm_offset_t
  224 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
  225 {
  226 
  227         CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %#x)", __func__, virt, start, end,
  228             prot);
  229         return (MMU_MAP(mmu_obj, virt, start, end, prot));
  230 }
  231 
  232 void
  233 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_object_t object,
  234     vm_pindex_t pindex, vm_size_t size)
  235 {
  236 
  237         CTR6(KTR_PMAP, "%s(%p, %#x, %p, %u, %#x)", __func__, pmap, addr,
  238             object, pindex, size);
  239         MMU_OBJECT_INIT_PT(mmu_obj, pmap, addr, object, pindex, size);
  240 }
  241 
  242 boolean_t
  243 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
  244 {
  245 
  246         CTR3(KTR_PMAP, "%s(%p, %p)", __func__, pmap, m);
  247         return (MMU_PAGE_EXISTS_QUICK(mmu_obj, pmap, m));
  248 }
  249 
  250 void
  251 pmap_page_init(vm_page_t m)
  252 {
  253 
  254         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  255         MMU_PAGE_INIT(mmu_obj, m);
  256 }
  257 
  258 int
  259 pmap_page_wired_mappings(vm_page_t m)
  260 {
  261 
  262         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  263         return (MMU_PAGE_WIRED_MAPPINGS(mmu_obj, m));
  264 }
  265 
  266 int
  267 pmap_pinit(pmap_t pmap)
  268 {
  269 
  270         CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
  271         MMU_PINIT(mmu_obj, pmap);
  272         return (1);
  273 }
  274 
  275 void
  276 pmap_pinit0(pmap_t pmap)
  277 {
  278 
  279         CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
  280         MMU_PINIT0(mmu_obj, pmap);
  281 }
  282 
  283 void
  284 pmap_protect(pmap_t pmap, vm_offset_t start, vm_offset_t end, vm_prot_t prot)
  285 {
  286 
  287         CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %#x)", __func__, pmap, start, end,
  288             prot);
  289         MMU_PROTECT(mmu_obj, pmap, start, end, prot);
  290 }
  291 
  292 void
  293 pmap_qenter(vm_offset_t start, vm_page_t *m, int count)
  294 {
  295 
  296         CTR4(KTR_PMAP, "%s(%#x, %p, %d)", __func__, start, m, count);
  297         MMU_QENTER(mmu_obj, start, m, count);
  298 }
  299 
  300 void
  301 pmap_qremove(vm_offset_t start, int count)
  302 {
  303 
  304         CTR3(KTR_PMAP, "%s(%#x, %d)", __func__, start, count);
  305         MMU_QREMOVE(mmu_obj, start, count);
  306 }
  307 
  308 void
  309 pmap_release(pmap_t pmap)
  310 {
  311 
  312         CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
  313         MMU_RELEASE(mmu_obj, pmap);
  314 }
  315 
  316 void
  317 pmap_remove(pmap_t pmap, vm_offset_t start, vm_offset_t end)
  318 {
  319 
  320         CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pmap, start, end);
  321         MMU_REMOVE(mmu_obj, pmap, start, end);
  322 }
  323 
  324 void
  325 pmap_remove_all(vm_page_t m)
  326 {
  327 
  328         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  329         MMU_REMOVE_ALL(mmu_obj, m);
  330 }
  331 
  332 void
  333 pmap_remove_pages(pmap_t pmap)
  334 {
  335 
  336         CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
  337         MMU_REMOVE_PAGES(mmu_obj, pmap);
  338 }
  339 
  340 void
  341 pmap_remove_write(vm_page_t m)
  342 {
  343 
  344         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  345         MMU_REMOVE_WRITE(mmu_obj, m);
  346 }
  347 
  348 void
  349 pmap_zero_page(vm_page_t m)
  350 {
  351 
  352         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  353         MMU_ZERO_PAGE(mmu_obj, m);
  354 }
  355 
  356 void
  357 pmap_zero_page_area(vm_page_t m, int off, int size)
  358 {
  359 
  360         CTR4(KTR_PMAP, "%s(%p, %d, %d)", __func__, m, off, size);
  361         MMU_ZERO_PAGE_AREA(mmu_obj, m, off, size);
  362 }
  363 
  364 void
  365 pmap_zero_page_idle(vm_page_t m)
  366 {
  367 
  368         CTR2(KTR_PMAP, "%s(%p)", __func__, m);
  369         MMU_ZERO_PAGE_IDLE(mmu_obj, m);
  370 }
  371 
  372 int
  373 pmap_mincore(pmap_t pmap, vm_offset_t addr, vm_paddr_t *locked_pa)
  374 {
  375 
  376         CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, addr);
  377         return (MMU_MINCORE(mmu_obj, pmap, addr, locked_pa));
  378 }
  379 
  380 void
  381 pmap_activate(struct thread *td)
  382 {
  383 
  384         CTR2(KTR_PMAP, "%s(%p)", __func__, td);
  385         MMU_ACTIVATE(mmu_obj, td);
  386 }
  387 
  388 void
  389 pmap_deactivate(struct thread *td)
  390 {
  391 
  392         CTR2(KTR_PMAP, "%s(%p)", __func__, td);
  393         MMU_DEACTIVATE(mmu_obj, td);
  394 }
  395 
  396 /*
  397  *      Increase the starting virtual address of the given mapping if a
  398  *      different alignment might result in more superpage mappings.
  399  */
  400 void
  401 pmap_align_superpage(vm_object_t object, vm_ooffset_t offset,
  402     vm_offset_t *addr, vm_size_t size)
  403 {
  404 
  405         CTR5(KTR_PMAP, "%s(%p, %#x, %p, %#x)", __func__, object, offset, addr,
  406             size);
  407         MMU_ALIGN_SUPERPAGE(mmu_obj, object, offset, addr, size);
  408 }
  409 
  410 /*
  411  * Routines used in machine-dependent code
  412  */
  413 void
  414 pmap_bootstrap(vm_offset_t start, vm_offset_t end)
  415 {
  416         mmu_obj = &mmu_kernel_obj;
  417 
  418         /*
  419          * Take care of compiling the selected class, and
  420          * then statically initialise the MMU object
  421          */
  422         kobj_class_compile_static(mmu_def_impl, &mmu_kernel_kops);
  423         kobj_init_static((kobj_t)mmu_obj, mmu_def_impl);
  424 
  425         MMU_BOOTSTRAP(mmu_obj, start, end);
  426 }
  427 
  428 void
  429 pmap_cpu_bootstrap(int ap)
  430 {
  431         /*
  432          * No KTR here because our console probably doesn't work yet
  433          */
  434 
  435         return (MMU_CPU_BOOTSTRAP(mmu_obj, ap));
  436 }
  437 
  438 void *
  439 pmap_mapdev(vm_offset_t pa, vm_size_t size)
  440 {
  441 
  442         CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, pa, size);
  443         return (MMU_MAPDEV(mmu_obj, pa, size));
  444 }
  445 
  446 void *
  447 pmap_mapdev_attr(vm_offset_t pa, vm_size_t size, vm_memattr_t attr)
  448 {
  449 
  450         CTR4(KTR_PMAP, "%s(%#x, %#x, %#x)", __func__, pa, size, attr);
  451         return (MMU_MAPDEV_ATTR(mmu_obj, pa, size, attr));
  452 }
  453 
  454 void
  455 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
  456 {
  457 
  458         CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, m, ma);
  459         return (MMU_PAGE_SET_MEMATTR(mmu_obj, m, ma));
  460 }
  461 
  462 void
  463 pmap_unmapdev(vm_offset_t va, vm_size_t size)
  464 {
  465 
  466         CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, va, size);
  467         MMU_UNMAPDEV(mmu_obj, va, size);
  468 }
  469 
  470 vm_offset_t
  471 pmap_kextract(vm_offset_t va)
  472 {
  473 
  474         CTR2(KTR_PMAP, "%s(%#x)", __func__, va);
  475         return (MMU_KEXTRACT(mmu_obj, va));
  476 }
  477 
  478 void
  479 pmap_kenter(vm_offset_t va, vm_offset_t pa)
  480 {
  481 
  482         CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, va, pa);
  483         MMU_KENTER(mmu_obj, va, pa);
  484 }
  485 
  486 void
  487 pmap_kenter_attr(vm_offset_t va, vm_offset_t pa, vm_memattr_t ma)
  488 {
  489 
  490         CTR4(KTR_PMAP, "%s(%#x, %#x, %#x)", __func__, va, pa, ma);
  491         MMU_KENTER_ATTR(mmu_obj, va, pa, ma);
  492 }
  493 
  494 boolean_t
  495 pmap_dev_direct_mapped(vm_offset_t pa, vm_size_t size)
  496 {
  497 
  498         CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, pa, size);
  499         return (MMU_DEV_DIRECT_MAPPED(mmu_obj, pa, size));
  500 }
  501 
  502 void
  503 pmap_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
  504 {
  505  
  506         CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pm, va, sz);
  507         return (MMU_SYNC_ICACHE(mmu_obj, pm, va, sz));
  508 }
  509 
  510 vm_offset_t
  511 pmap_dumpsys_map(struct pmap_md *md, vm_size_t ofs, vm_size_t *sz)
  512 {
  513 
  514         CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, md, ofs, *sz);
  515         return (MMU_DUMPSYS_MAP(mmu_obj, md, ofs, sz));
  516 }
  517 
  518 void
  519 pmap_dumpsys_unmap(struct pmap_md *md, vm_size_t ofs, vm_offset_t va)
  520 {
  521 
  522         CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, md, ofs, va);
  523         return (MMU_DUMPSYS_UNMAP(mmu_obj, md, ofs, va));
  524 }
  525 
  526 struct pmap_md *
  527 pmap_scan_md(struct pmap_md *prev)
  528 {
  529 
  530         CTR2(KTR_PMAP, "%s(%p)", __func__, prev);
  531         return (MMU_SCAN_MD(mmu_obj, prev));
  532 }
  533 
  534 /*
  535  * MMU install routines. Highest priority wins, equal priority also
  536  * overrides allowing last-set to win.
  537  */
  538 SET_DECLARE(mmu_set, mmu_def_t);
  539 
  540 boolean_t
  541 pmap_mmu_install(char *name, int prio)
  542 {
  543         mmu_def_t       **mmupp, *mmup;
  544         static int      curr_prio = 0;
  545 
  546         /*
  547          * Try and locate the MMU kobj corresponding to the name
  548          */
  549         SET_FOREACH(mmupp, mmu_set) {
  550                 mmup = *mmupp;
  551 
  552                 if (mmup->name &&
  553                     !strcmp(mmup->name, name) &&
  554                     (prio >= curr_prio || mmu_def_impl == NULL)) {
  555                         curr_prio = prio;
  556                         mmu_def_impl = mmup;
  557                         return (TRUE);
  558                 }
  559         }
  560 
  561         return (FALSE);
  562 }
  563 
  564 int unmapped_buf_allowed;

Cache object: 497613d365d10ec87e402f9b34b6039e


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.