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/vm/device_pager.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) 1990 University of Utah.
    3  * Copyright (c) 1991, 1993
    4  *      The Regents of the University of California.  All rights reserved.
    5  *
    6  * This code is derived from software contributed to Berkeley by
    7  * the Systems Programming Group of the University of Utah Computer
    8  * Science Department.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)device_pager.c      8.1 (Berkeley) 6/11/93
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD: releng/7.3/sys/vm/device_pager.c 198595 2009-10-29 15:10:38Z jhb $");
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/conf.h>
   43 #include <sys/lock.h>
   44 #include <sys/proc.h>
   45 #include <sys/mutex.h>
   46 #include <sys/mman.h>
   47 #include <sys/sx.h>
   48 
   49 #include <vm/vm.h>
   50 #include <vm/vm_object.h>
   51 #include <vm/vm_page.h>
   52 #include <vm/vm_pager.h>
   53 #include <vm/uma.h>
   54 
   55 static void dev_pager_init(void);
   56 static vm_object_t dev_pager_alloc(void *, vm_ooffset_t, vm_prot_t,
   57                 vm_ooffset_t);
   58 static void dev_pager_dealloc(vm_object_t);
   59 static int dev_pager_getpages(vm_object_t, vm_page_t *, int, int);
   60 static void dev_pager_putpages(vm_object_t, vm_page_t *, int, 
   61                 boolean_t, int *);
   62 static boolean_t dev_pager_haspage(vm_object_t, vm_pindex_t, int *,
   63                 int *);
   64 
   65 /* list of device pager objects */
   66 static struct pagerlst dev_pager_object_list;
   67 /* protect list manipulation */
   68 static struct mtx dev_pager_mtx;
   69 
   70 
   71 static uma_zone_t fakepg_zone;
   72 
   73 static vm_page_t dev_pager_getfake(vm_paddr_t, vm_memattr_t);
   74 static void dev_pager_putfake(vm_page_t);
   75 static void dev_pager_updatefake(vm_page_t, vm_paddr_t, vm_memattr_t);
   76 
   77 struct pagerops devicepagerops = {
   78         .pgo_init =     dev_pager_init,
   79         .pgo_alloc =    dev_pager_alloc,
   80         .pgo_dealloc =  dev_pager_dealloc,
   81         .pgo_getpages = dev_pager_getpages,
   82         .pgo_putpages = dev_pager_putpages,
   83         .pgo_haspage =  dev_pager_haspage,
   84 };
   85 
   86 static void
   87 dev_pager_init()
   88 {
   89         TAILQ_INIT(&dev_pager_object_list);
   90         mtx_init(&dev_pager_mtx, "dev_pager list", NULL, MTX_DEF);
   91         fakepg_zone = uma_zcreate("DP fakepg", sizeof(struct vm_page),
   92             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR,
   93             UMA_ZONE_NOFREE|UMA_ZONE_VM); 
   94 }
   95 
   96 static __inline int
   97 dev_mmap(struct cdevsw *csw, struct cdev *dev, vm_offset_t offset,
   98     vm_paddr_t *paddr, int nprot, vm_memattr_t *memattr)
   99 {
  100 
  101         if (csw->d_flags & D_MMAP2)
  102                 return (csw->d_mmap2(dev, offset, paddr, nprot, memattr));
  103         else
  104                 return (csw->d_mmap(dev, offset, paddr, nprot));
  105 }
  106 
  107 /*
  108  * MPSAFE
  109  */
  110 static vm_object_t
  111 dev_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot, vm_ooffset_t foff)
  112 {
  113         struct cdev *dev;
  114         vm_object_t object, object1;
  115         vm_pindex_t pindex;
  116         unsigned int npages;
  117         vm_paddr_t paddr;
  118         vm_offset_t off;
  119         vm_memattr_t dummy;
  120         struct cdevsw *csw;
  121 
  122         /*
  123          * Offset should be page aligned.
  124          */
  125         if (foff & PAGE_MASK)
  126                 return (NULL);
  127 
  128         size = round_page(size);
  129         pindex = OFF_TO_IDX(foff + size);
  130 
  131         /*
  132          * Make sure this device can be mapped.
  133          */
  134         dev = handle;
  135         csw = dev_refthread(dev);
  136         if (csw == NULL)
  137                 return (NULL);
  138 
  139         /*
  140          * Check that the specified range of the device allows the desired
  141          * protection.
  142          *
  143          * XXX assumes VM_PROT_* == PROT_*
  144          */
  145         npages = OFF_TO_IDX(size);
  146         for (off = foff; npages--; off += PAGE_SIZE)
  147                 if (dev_mmap(csw, dev, off, &paddr, (int)prot, &dummy) != 0) {
  148                         dev_relthread(dev);
  149                         return (NULL);
  150                 }
  151 
  152         mtx_lock(&dev_pager_mtx);
  153 
  154         /*
  155          * Look up pager, creating as necessary.
  156          */
  157         object1 = NULL;
  158         object = vm_pager_object_lookup(&dev_pager_object_list, handle);
  159         if (object == NULL) {
  160                 /*
  161                  * Allocate object and associate it with the pager.  Initialize
  162                  * the object's pg_color based upon the physical address of the
  163                  * device's memory.
  164                  */
  165                 mtx_unlock(&dev_pager_mtx);
  166                 object1 = vm_object_allocate(OBJT_DEVICE, pindex);
  167                 object1->flags |= OBJ_COLORED;
  168                 object1->pg_color = atop(paddr) - OFF_TO_IDX(off - PAGE_SIZE);
  169                 mtx_lock(&dev_pager_mtx);
  170                 object = vm_pager_object_lookup(&dev_pager_object_list, handle);
  171                 if (object != NULL) {
  172                         /*
  173                          * We raced with other thread while allocating object.
  174                          */
  175                         if (pindex > object->size)
  176                                 object->size = pindex;
  177                 } else {
  178                         object = object1;
  179                         object1 = NULL;
  180                         object->handle = handle;
  181                         TAILQ_INIT(&object->un_pager.devp.devp_pglist);
  182                         TAILQ_INSERT_TAIL(&dev_pager_object_list, object,
  183                             pager_object_list);
  184                 }
  185         } else {
  186                 if (pindex > object->size)
  187                         object->size = pindex;
  188         }
  189         mtx_unlock(&dev_pager_mtx);
  190         dev_relthread(dev);
  191         vm_object_deallocate(object1);
  192         return (object);
  193 }
  194 
  195 static void
  196 dev_pager_dealloc(object)
  197         vm_object_t object;
  198 {
  199         vm_page_t m;
  200 
  201         VM_OBJECT_UNLOCK(object);
  202         mtx_lock(&dev_pager_mtx);
  203         TAILQ_REMOVE(&dev_pager_object_list, object, pager_object_list);
  204         mtx_unlock(&dev_pager_mtx);
  205         VM_OBJECT_LOCK(object);
  206         /*
  207          * Free up our fake pages.
  208          */
  209         while ((m = TAILQ_FIRST(&object->un_pager.devp.devp_pglist)) != NULL) {
  210                 TAILQ_REMOVE(&object->un_pager.devp.devp_pglist, m, pageq);
  211                 dev_pager_putfake(m);
  212         }
  213 }
  214 
  215 static int
  216 dev_pager_getpages(object, m, count, reqpage)
  217         vm_object_t object;
  218         vm_page_t *m;
  219         int count;
  220         int reqpage;
  221 {
  222         vm_pindex_t offset;
  223         vm_paddr_t paddr;
  224         vm_page_t m_paddr, page;
  225         vm_memattr_t memattr;
  226         struct cdev *dev;
  227         int i, ret;
  228         struct cdevsw *csw;
  229         struct thread *td;
  230         struct file *fpop;
  231 
  232         VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);
  233         dev = object->handle;
  234         page = m[reqpage];
  235         offset = page->pindex;
  236         memattr = object->memattr;
  237         VM_OBJECT_UNLOCK(object);
  238         csw = dev_refthread(dev);
  239         if (csw == NULL)
  240                 panic("dev_pager_getpage: no cdevsw");
  241         td = curthread;
  242         fpop = td->td_fpop;
  243         td->td_fpop = NULL;
  244         ret = dev_mmap(csw, dev, (vm_offset_t)offset << PAGE_SHIFT, &paddr,
  245             PROT_READ, &memattr);
  246         KASSERT(ret == 0, ("dev_pager_getpage: map function returns error"));
  247         td->td_fpop = fpop;
  248         dev_relthread(dev);
  249         /* If "paddr" is a real page, perform a sanity check on "memattr". */
  250         if ((m_paddr = vm_phys_paddr_to_vm_page(paddr)) != NULL &&
  251             pmap_page_get_memattr(m_paddr) != memattr) {
  252                 memattr = pmap_page_get_memattr(m_paddr);
  253                 printf(
  254             "WARNING: A device driver has set \"memattr\" inconsistently.\n");
  255         }
  256         if ((page->flags & PG_FICTITIOUS) != 0) {
  257                 /*
  258                  * If the passed in reqpage page is a fake page, update it with
  259                  * the new physical address.
  260                  */
  261                 VM_OBJECT_LOCK(object);
  262                 dev_pager_updatefake(page, paddr, memattr);
  263                 if (count > 1) {
  264                         vm_page_lock_queues();
  265                         for (i = 0; i < count; i++) {
  266                                 if (i != reqpage)
  267                                         vm_page_free(m[i]);
  268                         }
  269                         vm_page_unlock_queues();
  270                 }
  271         } else {
  272                 /*
  273                  * Replace the passed in reqpage page with our own fake page and
  274                  * free up the all of the original pages.
  275                  */
  276                 page = dev_pager_getfake(paddr, memattr);
  277                 VM_OBJECT_LOCK(object);
  278                 TAILQ_INSERT_TAIL(&object->un_pager.devp.devp_pglist, page, pageq);
  279                 vm_page_lock_queues();
  280                 for (i = 0; i < count; i++)
  281                         vm_page_free(m[i]);
  282                 vm_page_unlock_queues();
  283                 vm_page_insert(page, object, offset);
  284                 m[reqpage] = page;
  285         }
  286         page->valid = VM_PAGE_BITS_ALL;
  287         return (VM_PAGER_OK);
  288 }
  289 
  290 static void
  291 dev_pager_putpages(object, m, count, sync, rtvals)
  292         vm_object_t object;
  293         vm_page_t *m;
  294         int count;
  295         boolean_t sync;
  296         int *rtvals;
  297 {
  298         panic("dev_pager_putpage called");
  299 }
  300 
  301 static boolean_t
  302 dev_pager_haspage(object, pindex, before, after)
  303         vm_object_t object;
  304         vm_pindex_t pindex;
  305         int *before;
  306         int *after;
  307 {
  308         if (before != NULL)
  309                 *before = 0;
  310         if (after != NULL)
  311                 *after = 0;
  312         return (TRUE);
  313 }
  314 
  315 /*
  316  * Create a fictitious page with the specified physical address and memory
  317  * attribute.  The memory attribute is the only the machine-dependent aspect
  318  * of a fictitious page that must be initialized.
  319  */
  320 static vm_page_t
  321 dev_pager_getfake(vm_paddr_t paddr, vm_memattr_t memattr)
  322 {
  323         vm_page_t m;
  324 
  325         m = uma_zalloc(fakepg_zone, M_WAITOK | M_ZERO);
  326         m->phys_addr = paddr;
  327         /* Fictitious pages don't use "segind". */
  328         m->flags = PG_FICTITIOUS;
  329         /* Fictitious pages don't use "order" or "pool". */
  330         m->oflags = VPO_BUSY;
  331         m->wire_count = 1;
  332         pmap_page_set_memattr(m, memattr);
  333         return (m);
  334 }
  335 
  336 /*
  337  * Release a fictitious page.
  338  */
  339 static void
  340 dev_pager_putfake(vm_page_t m)
  341 {
  342 
  343         if (!(m->flags & PG_FICTITIOUS))
  344                 panic("dev_pager_putfake: bad page");
  345         uma_zfree(fakepg_zone, m);
  346 }
  347 
  348 /*
  349  * Update the given fictitious page to the specified physical address and
  350  * memory attribute.
  351  */
  352 static void
  353 dev_pager_updatefake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr)
  354 {
  355 
  356         if (!(m->flags & PG_FICTITIOUS))
  357                 panic("dev_pager_updatefake: bad page");
  358         m->phys_addr = paddr;
  359         pmap_page_set_memattr(m, memattr);
  360 }

Cache object: 09164cbbb8afd002dd7a19cb164f0abe


[ 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.