2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* High memory handling common code and variables.
|
|
|
|
*
|
|
|
|
* (C) 1999 Andrea Arcangeli, SuSE GmbH, andrea@suse.de
|
|
|
|
* Gerhard Wichert, Siemens AG, Gerhard.Wichert@pdb.siemens.de
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Redesigned the x86 32-bit VM architecture to deal with
|
|
|
|
* 64-bit physical space. With current x86 CPUs this
|
|
|
|
* means up to 64 Gigabytes physical RAM.
|
|
|
|
*
|
|
|
|
* Rewrote high memory support to move the page cache into
|
|
|
|
* high memory. Implemented permanent (schedulable) kmaps
|
|
|
|
* based on Linus' idea.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/highmem.h>
|
2010-08-05 21:22:24 +07:00
|
|
|
#include <linux/kgdb.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
|
2010-10-28 05:32:57 +07:00
|
|
|
|
|
|
|
#if defined(CONFIG_HIGHMEM) || defined(CONFIG_X86_32)
|
|
|
|
DEFINE_PER_CPU(int, __kmap_atomic_idx);
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Virtual_count is not a pure "count".
|
|
|
|
* 0 means that it is not mapped, and has not been mapped
|
|
|
|
* since a TLB flush - it is usable.
|
|
|
|
* 1 means that there are no users, but it has been mapped
|
|
|
|
* since the last TLB flush - so we can't use it.
|
|
|
|
* n means that there are (n-1) current users of it.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
2005-10-21 14:22:44 +07:00
|
|
|
|
2006-09-26 13:31:11 +07:00
|
|
|
unsigned long totalhigh_pages __read_mostly;
|
2008-07-20 12:39:46 +07:00
|
|
|
EXPORT_SYMBOL(totalhigh_pages);
|
2006-09-26 13:31:11 +07:00
|
|
|
|
2010-10-27 04:21:51 +07:00
|
|
|
|
|
|
|
EXPORT_PER_CPU_SYMBOL(__kmap_atomic_idx);
|
|
|
|
|
2006-09-26 13:31:11 +07:00
|
|
|
unsigned int nr_free_highpages (void)
|
|
|
|
{
|
|
|
|
pg_data_t *pgdat;
|
|
|
|
unsigned int pages = 0;
|
|
|
|
|
2007-07-17 18:03:12 +07:00
|
|
|
for_each_online_pgdat(pgdat) {
|
2007-02-10 16:43:02 +07:00
|
|
|
pages += zone_page_state(&pgdat->node_zones[ZONE_HIGHMEM],
|
|
|
|
NR_FREE_PAGES);
|
2007-07-17 18:03:12 +07:00
|
|
|
if (zone_movable_is_highmem())
|
|
|
|
pages += zone_page_state(
|
|
|
|
&pgdat->node_zones[ZONE_MOVABLE],
|
|
|
|
NR_FREE_PAGES);
|
|
|
|
}
|
2006-09-26 13:31:11 +07:00
|
|
|
|
|
|
|
return pages;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int pkmap_count[LAST_PKMAP];
|
|
|
|
static unsigned int last_pkmap_nr;
|
|
|
|
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(kmap_lock);
|
|
|
|
|
|
|
|
pte_t * pkmap_page_table;
|
|
|
|
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(pkmap_map_wait);
|
|
|
|
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
/*
|
|
|
|
* Most architectures have no use for kmap_high_get(), so let's abstract
|
|
|
|
* the disabling of IRQ out of the locking in that case to save on a
|
|
|
|
* potential useless overhead.
|
|
|
|
*/
|
|
|
|
#ifdef ARCH_NEEDS_KMAP_HIGH_GET
|
|
|
|
#define lock_kmap() spin_lock_irq(&kmap_lock)
|
|
|
|
#define unlock_kmap() spin_unlock_irq(&kmap_lock)
|
|
|
|
#define lock_kmap_any(flags) spin_lock_irqsave(&kmap_lock, flags)
|
|
|
|
#define unlock_kmap_any(flags) spin_unlock_irqrestore(&kmap_lock, flags)
|
|
|
|
#else
|
|
|
|
#define lock_kmap() spin_lock(&kmap_lock)
|
|
|
|
#define unlock_kmap() spin_unlock(&kmap_lock)
|
|
|
|
#define lock_kmap_any(flags) \
|
|
|
|
do { spin_lock(&kmap_lock); (void)(flags); } while (0)
|
|
|
|
#define unlock_kmap_any(flags) \
|
|
|
|
do { spin_unlock(&kmap_lock); (void)(flags); } while (0)
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void flush_all_zero_pkmaps(void)
|
|
|
|
{
|
|
|
|
int i;
|
2008-08-01 08:15:21 +07:00
|
|
|
int need_flush = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
flush_cache_kmaps();
|
|
|
|
|
|
|
|
for (i = 0; i < LAST_PKMAP; i++) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* zero means we don't have anything to do,
|
|
|
|
* >1 means that it is still in use. Only
|
|
|
|
* a count of 1 means that it is free but
|
|
|
|
* needs to be unmapped
|
|
|
|
*/
|
|
|
|
if (pkmap_count[i] != 1)
|
|
|
|
continue;
|
|
|
|
pkmap_count[i] = 0;
|
|
|
|
|
|
|
|
/* sanity check */
|
2006-04-02 18:47:35 +07:00
|
|
|
BUG_ON(pte_none(pkmap_page_table[i]));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't need an atomic fetch-and-clear op here;
|
|
|
|
* no-one has the page mapped, and cannot get at
|
|
|
|
* its virtual address (and hence PTE) without first
|
|
|
|
* getting the kmap_lock (which is held here).
|
|
|
|
* So no dangers, even with speculative execution.
|
|
|
|
*/
|
|
|
|
page = pte_page(pkmap_page_table[i]);
|
|
|
|
pte_clear(&init_mm, (unsigned long)page_address(page),
|
|
|
|
&pkmap_page_table[i]);
|
|
|
|
|
|
|
|
set_page_address(page, NULL);
|
2008-08-01 08:15:21 +07:00
|
|
|
need_flush = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-08-01 08:15:21 +07:00
|
|
|
if (need_flush)
|
|
|
|
flush_tlb_kernel_range(PKMAP_ADDR(0), PKMAP_ADDR(LAST_PKMAP));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-03-20 07:00:42 +07:00
|
|
|
/**
|
|
|
|
* kmap_flush_unused - flush all unused kmap mappings in order to remove stray mappings
|
|
|
|
*/
|
2007-05-03 00:27:15 +07:00
|
|
|
void kmap_flush_unused(void)
|
|
|
|
{
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
lock_kmap();
|
2007-05-03 00:27:15 +07:00
|
|
|
flush_all_zero_pkmaps();
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
unlock_kmap();
|
2007-05-03 00:27:15 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline unsigned long map_new_virtual(struct page *page)
|
|
|
|
{
|
|
|
|
unsigned long vaddr;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
start:
|
|
|
|
count = LAST_PKMAP;
|
|
|
|
/* Find an empty entry */
|
|
|
|
for (;;) {
|
|
|
|
last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;
|
|
|
|
if (!last_pkmap_nr) {
|
|
|
|
flush_all_zero_pkmaps();
|
|
|
|
count = LAST_PKMAP;
|
|
|
|
}
|
|
|
|
if (!pkmap_count[last_pkmap_nr])
|
|
|
|
break; /* Found a usable entry */
|
|
|
|
if (--count)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sleep for somebody else to unmap their entries
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
|
|
|
__set_current_state(TASK_UNINTERRUPTIBLE);
|
|
|
|
add_wait_queue(&pkmap_map_wait, &wait);
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
unlock_kmap();
|
2005-04-17 05:20:36 +07:00
|
|
|
schedule();
|
|
|
|
remove_wait_queue(&pkmap_map_wait, &wait);
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
lock_kmap();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Somebody else might have mapped it while we slept */
|
|
|
|
if (page_address(page))
|
|
|
|
return (unsigned long)page_address(page);
|
|
|
|
|
|
|
|
/* Re-start */
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vaddr = PKMAP_ADDR(last_pkmap_nr);
|
|
|
|
set_pte_at(&init_mm, vaddr,
|
|
|
|
&(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));
|
|
|
|
|
|
|
|
pkmap_count[last_pkmap_nr] = 1;
|
|
|
|
set_page_address(page, (void *)vaddr);
|
|
|
|
|
|
|
|
return vaddr;
|
|
|
|
}
|
|
|
|
|
2008-03-20 07:00:42 +07:00
|
|
|
/**
|
|
|
|
* kmap_high - map a highmem page into memory
|
|
|
|
* @page: &struct page to map
|
|
|
|
*
|
|
|
|
* Returns the page's virtual memory address.
|
|
|
|
*
|
|
|
|
* We cannot call this from interrupts, as it may block.
|
|
|
|
*/
|
2008-02-05 13:29:26 +07:00
|
|
|
void *kmap_high(struct page *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long vaddr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For highmem pages, we can't trust "virtual" until
|
|
|
|
* after we have the lock.
|
|
|
|
*/
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
lock_kmap();
|
2005-04-17 05:20:36 +07:00
|
|
|
vaddr = (unsigned long)page_address(page);
|
|
|
|
if (!vaddr)
|
|
|
|
vaddr = map_new_virtual(page);
|
|
|
|
pkmap_count[PKMAP_NR(vaddr)]++;
|
2006-04-02 18:47:35 +07:00
|
|
|
BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 2);
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
unlock_kmap();
|
2005-04-17 05:20:36 +07:00
|
|
|
return (void*) vaddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(kmap_high);
|
|
|
|
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
#ifdef ARCH_NEEDS_KMAP_HIGH_GET
|
|
|
|
/**
|
|
|
|
* kmap_high_get - pin a highmem page into memory
|
|
|
|
* @page: &struct page to pin
|
|
|
|
*
|
|
|
|
* Returns the page's current virtual memory address, or NULL if no mapping
|
2010-01-26 03:38:09 +07:00
|
|
|
* exists. If and only if a non null address is returned then a
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
* matching call to kunmap_high() is necessary.
|
|
|
|
*
|
|
|
|
* This can be called from any context.
|
|
|
|
*/
|
|
|
|
void *kmap_high_get(struct page *page)
|
|
|
|
{
|
|
|
|
unsigned long vaddr, flags;
|
|
|
|
|
|
|
|
lock_kmap_any(flags);
|
|
|
|
vaddr = (unsigned long)page_address(page);
|
|
|
|
if (vaddr) {
|
|
|
|
BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 1);
|
|
|
|
pkmap_count[PKMAP_NR(vaddr)]++;
|
|
|
|
}
|
|
|
|
unlock_kmap_any(flags);
|
|
|
|
return (void*) vaddr;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-20 07:00:42 +07:00
|
|
|
/**
|
|
|
|
* kunmap_high - map a highmem page into memory
|
|
|
|
* @page: &struct page to unmap
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
*
|
|
|
|
* If ARCH_NEEDS_KMAP_HIGH_GET is not defined then this may be called
|
|
|
|
* only from user context.
|
2008-03-20 07:00:42 +07:00
|
|
|
*/
|
2008-02-05 13:29:26 +07:00
|
|
|
void kunmap_high(struct page *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long vaddr;
|
|
|
|
unsigned long nr;
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
int need_wakeup;
|
|
|
|
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
lock_kmap_any(flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
vaddr = (unsigned long)page_address(page);
|
2006-04-02 18:47:35 +07:00
|
|
|
BUG_ON(!vaddr);
|
2005-04-17 05:20:36 +07:00
|
|
|
nr = PKMAP_NR(vaddr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A count must never go down to zero
|
|
|
|
* without a TLB flush!
|
|
|
|
*/
|
|
|
|
need_wakeup = 0;
|
|
|
|
switch (--pkmap_count[nr]) {
|
|
|
|
case 0:
|
|
|
|
BUG();
|
|
|
|
case 1:
|
|
|
|
/*
|
|
|
|
* Avoid an unnecessary wake_up() function call.
|
|
|
|
* The common case is pkmap_count[] == 1, but
|
|
|
|
* no waiters.
|
|
|
|
* The tasks queued in the wait-queue are guarded
|
|
|
|
* by both the lock in the wait-queue-head and by
|
|
|
|
* the kmap_lock. As the kmap_lock is held here,
|
|
|
|
* no need for the wait-queue-head's lock. Simply
|
|
|
|
* test if the queue is empty.
|
|
|
|
*/
|
|
|
|
need_wakeup = waitqueue_active(&pkmap_map_wait);
|
|
|
|
}
|
highmem: atomic highmem kmap page pinning
Most ARM machines have a non IO coherent cache, meaning that the
dma_map_*() set of functions must clean and/or invalidate the affected
memory manually before DMA occurs. And because the majority of those
machines have a VIVT cache, the cache maintenance operations must be
performed using virtual
addresses.
When a highmem page is kunmap'd, its mapping (and cache) remains in place
in case it is kmap'd again. However if dma_map_page() is then called with
such a page, some cache maintenance on the remaining mapping must be
performed. In that case, page_address(page) is non null and we can use
that to synchronize the cache.
It is unlikely but still possible for kmap() to race and recycle the
virtual address obtained above, and use it for another page before some
on-going cache invalidation loop in dma_map_page() is done. In that case,
the new mapping could end up with dirty cache lines for another page,
and the unsuspecting cache invalidation loop in dma_map_page() might
simply discard those dirty cache lines resulting in data loss.
For example, let's consider this sequence of events:
- dma_map_page(..., DMA_FROM_DEVICE) is called on a highmem page.
--> - vaddr = page_address(page) is non null. In this case
it is likely that the page has valid cache lines
associated with vaddr. Remember that the cache is VIVT.
--> for (i = vaddr; i < vaddr + PAGE_SIZE; i += 32)
invalidate_cache_line(i);
*** preemption occurs in the middle of the loop above ***
- kmap_high() is called for a different page.
--> - last_pkmap_nr wraps to zero and flush_all_zero_pkmaps()
is called. The pkmap_count value for the page passed
to dma_map_page() above happens to be 1, so the page
is unmapped. But prior to that, flush_cache_kmaps()
cleared the cache for it. So far so good.
- A fresh pkmap entry is assigned for this kmap request.
The Murphy law says this pkmap entry will eventually
happen to use the same vaddr as the one which used to
belong to the other page being processed by
dma_map_page() in the preempted thread above.
- The kmap_high() caller start dirtying the cache using the
just assigned virtual mapping for its page.
*** the first thread is rescheduled ***
- The for(...) loop is resumed, but now cached
data belonging to a different physical page is
being discarded !
And this is not only a preemption issue as ARM can be SMP as well,
making the above scenario just as likely. Hence the need for some kind
of pkmap page pinning which can be used in any context, primarily for
the benefit of dma_map_page() on ARM.
This provides the necessary interface to cope with the above issue if
ARCH_NEEDS_KMAP_HIGH_GET is defined, otherwise the resulting code is
unchanged.
Signed-off-by: Nicolas Pitre <nico@marvell.com>
Reviewed-by: MinChan Kim <minchan.kim@gmail.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
2009-03-05 10:49:41 +07:00
|
|
|
unlock_kmap_any(flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* do wake-up, if needed, race-free outside of the spin lock */
|
|
|
|
if (need_wakeup)
|
|
|
|
wake_up(&pkmap_map_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(kunmap_high);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HASHED_PAGE_VIRTUAL)
|
|
|
|
|
|
|
|
#define PA_HASH_ORDER 7
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Describes one page->virtual association
|
|
|
|
*/
|
|
|
|
struct page_address_map {
|
|
|
|
struct page *page;
|
|
|
|
void *virtual;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* page_address_map freelist, allocated from page_address_maps.
|
|
|
|
*/
|
|
|
|
static struct list_head page_address_pool; /* freelist */
|
|
|
|
static spinlock_t pool_lock; /* protects page_address_pool */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hash table bucket
|
|
|
|
*/
|
|
|
|
static struct page_address_slot {
|
|
|
|
struct list_head lh; /* List of page_address_maps */
|
|
|
|
spinlock_t lock; /* Protect this bucket's list */
|
|
|
|
} ____cacheline_aligned_in_smp page_address_htable[1<<PA_HASH_ORDER];
|
|
|
|
|
2011-08-17 19:45:09 +07:00
|
|
|
static struct page_address_slot *page_slot(const struct page *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return &page_address_htable[hash_ptr(page, PA_HASH_ORDER)];
|
|
|
|
}
|
|
|
|
|
2008-03-20 07:00:42 +07:00
|
|
|
/**
|
|
|
|
* page_address - get the mapped virtual address of a page
|
|
|
|
* @page: &struct page to get the virtual address of
|
|
|
|
*
|
|
|
|
* Returns the page's virtual address.
|
|
|
|
*/
|
2011-08-17 19:45:09 +07:00
|
|
|
void *page_address(const struct page *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
void *ret;
|
|
|
|
struct page_address_slot *pas;
|
|
|
|
|
|
|
|
if (!PageHighMem(page))
|
|
|
|
return lowmem_page_address(page);
|
|
|
|
|
|
|
|
pas = page_slot(page);
|
|
|
|
ret = NULL;
|
|
|
|
spin_lock_irqsave(&pas->lock, flags);
|
|
|
|
if (!list_empty(&pas->lh)) {
|
|
|
|
struct page_address_map *pam;
|
|
|
|
|
|
|
|
list_for_each_entry(pam, &pas->lh, list) {
|
|
|
|
if (pam->page == page) {
|
|
|
|
ret = pam->virtual;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
spin_unlock_irqrestore(&pas->lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(page_address);
|
|
|
|
|
2008-03-20 07:00:42 +07:00
|
|
|
/**
|
|
|
|
* set_page_address - set a page's virtual address
|
|
|
|
* @page: &struct page to set
|
|
|
|
* @virtual: virtual address to use
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
void set_page_address(struct page *page, void *virtual)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct page_address_slot *pas;
|
|
|
|
struct page_address_map *pam;
|
|
|
|
|
|
|
|
BUG_ON(!PageHighMem(page));
|
|
|
|
|
|
|
|
pas = page_slot(page);
|
|
|
|
if (virtual) { /* Add */
|
|
|
|
BUG_ON(list_empty(&page_address_pool));
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pool_lock, flags);
|
|
|
|
pam = list_entry(page_address_pool.next,
|
|
|
|
struct page_address_map, list);
|
|
|
|
list_del(&pam->list);
|
|
|
|
spin_unlock_irqrestore(&pool_lock, flags);
|
|
|
|
|
|
|
|
pam->page = page;
|
|
|
|
pam->virtual = virtual;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pas->lock, flags);
|
|
|
|
list_add_tail(&pam->list, &pas->lh);
|
|
|
|
spin_unlock_irqrestore(&pas->lock, flags);
|
|
|
|
} else { /* Remove */
|
|
|
|
spin_lock_irqsave(&pas->lock, flags);
|
|
|
|
list_for_each_entry(pam, &pas->lh, list) {
|
|
|
|
if (pam->page == page) {
|
|
|
|
list_del(&pam->list);
|
|
|
|
spin_unlock_irqrestore(&pas->lock, flags);
|
|
|
|
spin_lock_irqsave(&pool_lock, flags);
|
|
|
|
list_add_tail(&pam->list, &page_address_pool);
|
|
|
|
spin_unlock_irqrestore(&pool_lock, flags);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&pas->lock, flags);
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct page_address_map page_address_maps[LAST_PKMAP];
|
|
|
|
|
|
|
|
void __init page_address_init(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&page_address_pool);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(page_address_maps); i++)
|
|
|
|
list_add(&page_address_maps[i].list, &page_address_pool);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(page_address_htable); i++) {
|
|
|
|
INIT_LIST_HEAD(&page_address_htable[i].lh);
|
|
|
|
spin_lock_init(&page_address_htable[i].lock);
|
|
|
|
}
|
|
|
|
spin_lock_init(&pool_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL) */
|