/*      $NetBSD: pmap_pvt.c,v 1.15 2022/05/08 22:03:02 rin Exp $        */

/*-
* Copyright (c) 2014, 2020 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Taylor R. Campbell.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__RCSID("$NetBSD: pmap_pvt.c,v 1.15 2022/05/08 22:03:02 rin Exp $");

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/pserialize.h>

#include <uvm/uvm.h>
#include <uvm/pmap/pmap_pvt.h>

#if !defined(PMAP_PV_TRACK_ONLY_STUBS)
/*
* unmanaged pv-tracked ranges
*
* This is a linear list for now because the only user are the DRM
* graphics drivers, with a single tracked range per device, for the
* graphics aperture, so there are expected to be few of them.
*
* This is used only after the VM system is initialized well enough
* that we can use kmem_alloc.
*/

struct pv_track {
       paddr_t                 pvt_start;
       psize_t                 pvt_size;
       struct pv_track         *pvt_next;
       struct pmap_page        pvt_pages[];
};

static struct {
       kmutex_t        lock;
       pserialize_t    psz;
       struct pv_track *list;
} pv_unmanaged __cacheline_aligned;

void
pmap_pv_init(void)
{

       mutex_init(&pv_unmanaged.lock, MUTEX_DEFAULT, IPL_NONE);
       pv_unmanaged.psz = pserialize_create();
       pv_unmanaged.list = NULL;
}

void
pmap_pv_track(paddr_t start, psize_t size)
{
       struct pv_track *pvt;
       size_t npages;

       KASSERT(start == trunc_page(start));
       KASSERT(size == trunc_page(size));

       /* We may sleep for allocation.  */
       ASSERT_SLEEPABLE();

       npages = size >> PAGE_SHIFT;
       pvt = kmem_zalloc(offsetof(struct pv_track, pvt_pages[npages]),
           KM_SLEEP);
       pvt->pvt_start = start;
       pvt->pvt_size = size;

#ifdef PMAP_PAGE_INIT
       for (size_t i = 0; i < npages; i++)
               PMAP_PAGE_INIT(&pvt->pvt_pages[i]);
#endif

       mutex_enter(&pv_unmanaged.lock);
       pvt->pvt_next = pv_unmanaged.list;
       atomic_store_release(&pv_unmanaged.list, pvt);
       mutex_exit(&pv_unmanaged.lock);
}

void
pmap_pv_untrack(paddr_t start, psize_t size)
{
       struct pv_track **pvtp, *pvt;
       size_t npages;

       KASSERT(start == trunc_page(start));
       KASSERT(size == trunc_page(size));

       /* We may sleep for pserialize_perform.  */
       ASSERT_SLEEPABLE();

       mutex_enter(&pv_unmanaged.lock);
       for (pvtp = &pv_unmanaged.list;
            (pvt = *pvtp) != NULL;
            pvtp = &pvt->pvt_next) {
               if (pvt->pvt_start != start)
                       continue;
               if (pvt->pvt_size != size)
                       panic("pmap_pv_untrack: pv-tracking at 0x%"PRIxPADDR
                           ": 0x%"PRIxPSIZE" bytes, not 0x%"PRIxPSIZE" bytes",
                           pvt->pvt_start, pvt->pvt_size, size);

               /*
                * Remove from list.  Readers can safely see the old
                * and new states of the list.
                */
               atomic_store_relaxed(pvtp, pvt->pvt_next);

               /* Wait for readers who can see the old state to finish.  */
               pserialize_perform(pv_unmanaged.psz);

               /*
                * We now have exclusive access to pvt and can destroy
                * it.  Poison it to catch bugs.
                */
               explicit_memset(&pvt->pvt_next, 0x1a, sizeof pvt->pvt_next);
               goto out;
       }
       panic("pmap_pv_untrack: pages not pv-tracked at 0x%"PRIxPADDR
           " (0x%"PRIxPSIZE" bytes)",
           start, size);
out:    mutex_exit(&pv_unmanaged.lock);

       npages = size >> PAGE_SHIFT;
       kmem_free(pvt, offsetof(struct pv_track, pvt_pages[npages]));
}

struct pmap_page *
pmap_pv_tracked(paddr_t pa)
{
       struct pv_track *pvt;
       size_t pgno;
       int s;

       KASSERT(pa == trunc_page(pa));

       s = pserialize_read_enter();
       for (pvt = atomic_load_consume(&pv_unmanaged.list);
            pvt != NULL;
            pvt = pvt->pvt_next) {
               if ((pvt->pvt_start <= pa) &&
                   ((pa - pvt->pvt_start) < pvt->pvt_size))
                       break;
       }
       pserialize_read_exit(s);

       if (pvt == NULL)
               return NULL;
       KASSERT(pvt->pvt_start <= pa);
       KASSERT((pa - pvt->pvt_start) < pvt->pvt_size);
       pgno = (pa - pvt->pvt_start) >> PAGE_SHIFT;
       return &pvt->pvt_pages[pgno];
}

#else /* PMAP_PV_TRACK_ONLY_STUBS */
/*
* Provide empty stubs just for MODULAR kernels.
*/

void
pmap_pv_init(void)
{

}

struct pmap_page *
pmap_pv_tracked(paddr_t pa)
{

       return NULL;
}

#if notdef
/*
* pmap_pv_{,un}track() are intentionally commented out. If modules
* call these functions, the result should be an inconsistent state.
*
* Such modules require real PV-tracking support. Let us make the
* two symbols undefined, and prevent these modules from loaded.
*/
void
pmap_pv_track(paddr_t start, psize_t size)
{

       panic("PV-tracking not supported");
}

void
pmap_pv_untrack(paddr_t start, psize_t size)
{

       panic("PV-tracking not supported");
}
#endif /* notdef */

#endif /* PMAP_PV_TRACK_ONLY_STUBS */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.