renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-12 15:24:00 +08:00
Code

mm: remove rest of ACCESS_ONCE() usages

Browse Source 
We converted some of the usages of ACCESS_ONCE to READ_ONCE in the mm/
tree since it doesn't work reliably on non-scalar types.

This patch removes the rest of the usages of ACCESS_ONCE, and use the new
READ_ONCE API for the read accesses.  This makes things cleaner, instead
of using separate/multiple sets of APIs.

Signed-off-by: Jason Low <jason.low2@hp.com>
Acked-by: Michal Hocko <mhocko@suse.cz>
Acked-by: Davidlohr Bueso <dave@stgolabs.net>
Acked-by: Rik van Riel <riel@redhat.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jason Low 2015-04-15 16:14:08 -07:00 committed by Linus Torvalds
parent 9d8c47e4bb
commit 4db0c3c298
11 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mm/huge_memory.c
View File

@ -183,7 +183,7 @@ static struct page *get_huge_zero_page(void)
struct page *zero_page; struct page *zero_page;
retry: retry:
if (likely(atomic_inc_not_zero(&huge_zero_refcount))) if (likely(atomic_inc_not_zero(&huge_zero_refcount)))
return ACCESS_ONCE(huge_zero_page); return READ_ONCE(huge_zero_page);
zero_page = alloc_pages((GFP_TRANSHUGE | __GFP_ZERO) & ~__GFP_MOVABLE, zero_page = alloc_pages((GFP_TRANSHUGE | __GFP_ZERO) & ~__GFP_MOVABLE,
HPAGE_PMD_ORDER); HPAGE_PMD_ORDER);
@ -202,7 +202,7 @@ retry:
/* We take additional reference here. It will be put back by shrinker */ /* We take additional reference here. It will be put back by shrinker */
atomic_set(&huge_zero_refcount, 2); atomic_set(&huge_zero_refcount, 2);
preempt_enable(); preempt_enable();
return ACCESS_ONCE(huge_zero_page); return READ_ONCE(huge_zero_page);
} }
static void put_huge_zero_page(void) static void put_huge_zero_page(void)

4
mm/internal.h
View File

@ -224,13 +224,13 @@ static inline unsigned long page_order(struct page *page)
* PageBuddy() should be checked first by the caller to minimize race window, * PageBuddy() should be checked first by the caller to minimize race window,
* and invalid values must be handled gracefully. * and invalid values must be handled gracefully.
* *
* ACCESS_ONCE is used so that if the caller assigns the result into a local * READ_ONCE is used so that if the caller assigns the result into a local
* variable and e.g. tests it for valid range before using, the compiler cannot * variable and e.g. tests it for valid range before using, the compiler cannot
* decide to remove the variable and inline the page_private(page) multiple * decide to remove the variable and inline the page_private(page) multiple
* times, potentially observing different values in the tests and the actual * times, potentially observing different values in the tests and the actual
* use of the result. * use of the result.
*/ */
#define page_order_unsafe(page) ACCESS_ONCE(page_private(page)) #define page_order_unsafe(page) READ_ONCE(page_private(page))
static inline bool is_cow_mapping(vm_flags_t flags) static inline bool is_cow_mapping(vm_flags_t flags)
{ {

10
mm/ksm.c
View File

@ -542,7 +542,7 @@ static struct page *get_ksm_page(struct stable_node *stable_node, bool lock_it)
expected_mapping = (void *)stable_node + expected_mapping = (void *)stable_node +
(PAGE_MAPPING_ANON | PAGE_MAPPING_KSM); (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
again: again:
kpfn = ACCESS_ONCE(stable_node->kpfn); kpfn = READ_ONCE(stable_node->kpfn);
page = pfn_to_page(kpfn); page = pfn_to_page(kpfn);
/* /*
@ -551,7 +551,7 @@ again:
* but on Alpha we need to be more careful. * but on Alpha we need to be more careful.
*/ */
smp_read_barrier_depends(); smp_read_barrier_depends();
if (ACCESS_ONCE(page->mapping) != expected_mapping) if (READ_ONCE(page->mapping) != expected_mapping)
goto stale; goto stale;
/* /*
@ -577,14 +577,14 @@ again:
cpu_relax(); cpu_relax();
} }
if (ACCESS_ONCE(page->mapping) != expected_mapping) { if (READ_ONCE(page->mapping) != expected_mapping) {
put_page(page); put_page(page);
goto stale; goto stale;
} }
if (lock_it) { if (lock_it) {
lock_page(page); lock_page(page);
if (ACCESS_ONCE(page->mapping) != expected_mapping) { if (READ_ONCE(page->mapping) != expected_mapping) {
unlock_page(page); unlock_page(page);
put_page(page); put_page(page);
goto stale; goto stale;
@ -600,7 +600,7 @@ stale:
* before checking whether node->kpfn has been changed. * before checking whether node->kpfn has been changed.
*/ */
smp_rmb(); smp_rmb();
if (ACCESS_ONCE(stable_node->kpfn) != kpfn) if (READ_ONCE(stable_node->kpfn) != kpfn)
goto again; goto again;
remove_node_from_stable_tree(stable_node); remove_node_from_stable_tree(stable_node);
return NULL; return NULL;

18
mm/memcontrol.c
View File

@ -674,7 +674,7 @@ static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
static unsigned long soft_limit_excess(struct mem_cgroup *memcg) static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
{ {
unsigned long nr_pages = page_counter_read(&memcg->memory); unsigned long nr_pages = page_counter_read(&memcg->memory);
unsigned long soft_limit = ACCESS_ONCE(memcg->soft_limit); unsigned long soft_limit = READ_ONCE(memcg->soft_limit);
unsigned long excess = 0; unsigned long excess = 0;
if (nr_pages > soft_limit) if (nr_pages > soft_limit)
@ -1042,7 +1042,7 @@ struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
goto out_unlock; goto out_unlock;
do { do {
pos = ACCESS_ONCE(iter->position); pos = READ_ONCE(iter->position);
/* /*
* A racing update may change the position and * A racing update may change the position and
* put the last reference, hence css_tryget(), * put the last reference, hence css_tryget(),
@ -1359,13 +1359,13 @@ static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
unsigned long limit; unsigned long limit;
count = page_counter_read(&memcg->memory); count = page_counter_read(&memcg->memory);
limit = ACCESS_ONCE(memcg->memory.limit); limit = READ_ONCE(memcg->memory.limit);
if (count < limit) if (count < limit)
margin = limit - count; margin = limit - count;
if (do_swap_account) { if (do_swap_account) {
count = page_counter_read(&memcg->memsw); count = page_counter_read(&memcg->memsw);
limit = ACCESS_ONCE(memcg->memsw.limit); limit = READ_ONCE(memcg->memsw.limit);
if (count <= limit) if (count <= limit)
margin = min(margin, limit - count); margin = min(margin, limit - count);
} }
@ -2637,7 +2637,7 @@ struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep)
return cachep; return cachep;
memcg = get_mem_cgroup_from_mm(current->mm); memcg = get_mem_cgroup_from_mm(current->mm);
kmemcg_id = ACCESS_ONCE(memcg->kmemcg_id); kmemcg_id = READ_ONCE(memcg->kmemcg_id);
if (kmemcg_id < 0) if (kmemcg_id < 0)
goto out; goto out;
@ -5007,7 +5007,7 @@ static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
* tunable will only affect upcoming migrations, not the current one. * tunable will only affect upcoming migrations, not the current one.
* So we need to save it, and keep it going. * So we need to save it, and keep it going.
*/ */
move_flags = ACCESS_ONCE(memcg->move_charge_at_immigrate); move_flags = READ_ONCE(memcg->move_charge_at_immigrate);
if (move_flags) { if (move_flags) {
struct mm_struct *mm; struct mm_struct *mm;
struct mem_cgroup *from = mem_cgroup_from_task(p); struct mem_cgroup *from = mem_cgroup_from_task(p);
@ -5241,7 +5241,7 @@ static u64 memory_current_read(struct cgroup_subsys_state *css,
static int memory_low_show(struct seq_file *m, void *v) static int memory_low_show(struct seq_file *m, void *v)
{ {
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m)); struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
unsigned long low = ACCESS_ONCE(memcg->low); unsigned long low = READ_ONCE(memcg->low);
if (low == PAGE_COUNTER_MAX) if (low == PAGE_COUNTER_MAX)
seq_puts(m, "max\n"); seq_puts(m, "max\n");
@ -5271,7 +5271,7 @@ static ssize_t memory_low_write(struct kernfs_open_file *of,
static int memory_high_show(struct seq_file *m, void *v) static int memory_high_show(struct seq_file *m, void *v)
{ {
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m)); struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
unsigned long high = ACCESS_ONCE(memcg->high); unsigned long high = READ_ONCE(memcg->high);
if (high == PAGE_COUNTER_MAX) if (high == PAGE_COUNTER_MAX)
seq_puts(m, "max\n"); seq_puts(m, "max\n");
@ -5301,7 +5301,7 @@ static ssize_t memory_high_write(struct kernfs_open_file *of,
static int memory_max_show(struct seq_file *m, void *v) static int memory_max_show(struct seq_file *m, void *v)
{ {
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m)); struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
unsigned long max = ACCESS_ONCE(memcg->memory.limit); unsigned long max = READ_ONCE(memcg->memory.limit);
if (max == PAGE_COUNTER_MAX) if (max == PAGE_COUNTER_MAX)
seq_puts(m, "max\n"); seq_puts(m, "max\n");

2
mm/memory.c
View File

@ -2845,7 +2845,7 @@ static void do_fault_around(struct vm_area_struct *vma, unsigned long address,
struct vm_fault vmf; struct vm_fault vmf;
int off; int off;
nr_pages = ACCESS_ONCE(fault_around_bytes) >> PAGE_SHIFT; nr_pages = READ_ONCE(fault_around_bytes) >> PAGE_SHIFT;
mask = ~(nr_pages * PAGE_SIZE - 1) & PAGE_MASK; mask = ~(nr_pages * PAGE_SIZE - 1) & PAGE_MASK;
start_addr = max(address & mask, vma->vm_start); start_addr = max(address & mask, vma->vm_start);

8
mm/mmap.c
View File

@ -1133,7 +1133,7 @@ static int anon_vma_compatible(struct vm_area_struct *a, struct vm_area_struct *
* by another page fault trying to merge _that_. But that's ok: if it * by another page fault trying to merge _that_. But that's ok: if it
* is being set up, that automatically means that it will be a singleton * is being set up, that automatically means that it will be a singleton
* acceptable for merging, so we can do all of this optimistically. But * acceptable for merging, so we can do all of this optimistically. But
* we do that ACCESS_ONCE() to make sure that we never re-load the pointer. * we do that READ_ONCE() to make sure that we never re-load the pointer.
* *
* IOW: that the "list_is_singular()" test on the anon_vma_chain only * IOW: that the "list_is_singular()" test on the anon_vma_chain only
* matters for the 'stable anon_vma' case (ie the thing we want to avoid * matters for the 'stable anon_vma' case (ie the thing we want to avoid
@ -1147,7 +1147,7 @@ static int anon_vma_compatible(struct vm_area_struct *a, struct vm_area_struct *
static struct anon_vma *reusable_anon_vma(struct vm_area_struct *old, struct vm_area_struct *a, struct vm_area_struct *b) static struct anon_vma *reusable_anon_vma(struct vm_area_struct *old, struct vm_area_struct *a, struct vm_area_struct *b)
{ {
if (anon_vma_compatible(a, b)) { if (anon_vma_compatible(a, b)) {
struct anon_vma *anon_vma = ACCESS_ONCE(old->anon_vma); struct anon_vma *anon_vma = READ_ONCE(old->anon_vma);
if (anon_vma && list_is_singular(&old->anon_vma_chain)) if (anon_vma && list_is_singular(&old->anon_vma_chain))
return anon_vma; return anon_vma;
@ -2100,7 +2100,7 @@ static int acct_stack_growth(struct vm_area_struct *vma, unsigned long size, uns
actual_size = size; actual_size = size;
if (size && (vma->vm_flags & (VM_GROWSUP | VM_GROWSDOWN))) if (size && (vma->vm_flags & (VM_GROWSUP | VM_GROWSDOWN)))
actual_size -= PAGE_SIZE; actual_size -= PAGE_SIZE;
if (actual_size > ACCESS_ONCE(rlim[RLIMIT_STACK].rlim_cur)) if (actual_size > READ_ONCE(rlim[RLIMIT_STACK].rlim_cur))
return -ENOMEM; return -ENOMEM;
/* mlock limit tests */ /* mlock limit tests */
@ -2108,7 +2108,7 @@ static int acct_stack_growth(struct vm_area_struct *vma, unsigned long size, uns
unsigned long locked; unsigned long locked;
unsigned long limit; unsigned long limit;
locked = mm->locked_vm + grow; locked = mm->locked_vm + grow;
limit = ACCESS_ONCE(rlim[RLIMIT_MEMLOCK].rlim_cur); limit = READ_ONCE(rlim[RLIMIT_MEMLOCK].rlim_cur);
limit >>= PAGE_SHIFT; limit >>= PAGE_SHIFT;
if (locked > limit && !capable(CAP_IPC_LOCK)) if (locked > limit && !capable(CAP_IPC_LOCK))
return -ENOMEM; return -ENOMEM;

6
mm/page_alloc.c
View File

@ -1371,7 +1371,7 @@ void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp)
int to_drain, batch; int to_drain, batch;
local_irq_save(flags); local_irq_save(flags);
batch = ACCESS_ONCE(pcp->batch); batch = READ_ONCE(pcp->batch);
to_drain = min(pcp->count, batch); to_drain = min(pcp->count, batch);
if (to_drain > 0) { if (to_drain > 0) {
free_pcppages_bulk(zone, to_drain, pcp); free_pcppages_bulk(zone, to_drain, pcp);
@ -1570,7 +1570,7 @@ void free_hot_cold_page(struct page *page, bool cold)
list_add_tail(&page->lru, &pcp->lists[migratetype]); list_add_tail(&page->lru, &pcp->lists[migratetype]);
pcp->count++; pcp->count++;
if (pcp->count >= pcp->high) { if (pcp->count >= pcp->high) {
unsigned long batch = ACCESS_ONCE(pcp->batch); unsigned long batch = READ_ONCE(pcp->batch);
free_pcppages_bulk(zone, batch, pcp); free_pcppages_bulk(zone, batch, pcp);
pcp->count -= batch; pcp->count -= batch;
} }
@ -6207,7 +6207,7 @@ void set_pfnblock_flags_mask(struct page *page, unsigned long flags,
mask <<= (BITS_PER_LONG - bitidx - 1); mask <<= (BITS_PER_LONG - bitidx - 1);
flags <<= (BITS_PER_LONG - bitidx - 1); flags <<= (BITS_PER_LONG - bitidx - 1);
word = ACCESS_ONCE(bitmap[word_bitidx]); word = READ_ONCE(bitmap[word_bitidx]);
for (;;) { for (;;) {
old_word = cmpxchg(&bitmap[word_bitidx], word, (word & ~mask) | flags); old_word = cmpxchg(&bitmap[word_bitidx], word, (word & ~mask) | flags);
if (word == old_word) if (word == old_word)

6
mm/rmap.c
View File

@ -456,7 +456,7 @@ struct anon_vma *page_get_anon_vma(struct page *page)
unsigned long anon_mapping; unsigned long anon_mapping;
rcu_read_lock(); rcu_read_lock();
anon_mapping = (unsigned long) ACCESS_ONCE(page->mapping); anon_mapping = (unsigned long)READ_ONCE(page->mapping);
if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON) if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
goto out; goto out;
if (!page_mapped(page)) if (!page_mapped(page))
@ -500,14 +500,14 @@ struct anon_vma *page_lock_anon_vma_read(struct page *page)
unsigned long anon_mapping; unsigned long anon_mapping;
rcu_read_lock(); rcu_read_lock();
anon_mapping = (unsigned long) ACCESS_ONCE(page->mapping); anon_mapping = (unsigned long)READ_ONCE(page->mapping);
if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON) if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
goto out; goto out;
if (!page_mapped(page)) if (!page_mapped(page))
goto out; goto out;
anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON); anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
root_anon_vma = ACCESS_ONCE(anon_vma->root); root_anon_vma = READ_ONCE(anon_vma->root);
if (down_read_trylock(&root_anon_vma->rwsem)) { if (down_read_trylock(&root_anon_vma->rwsem)) {
/* /*
* If the page is still mapped, then this anon_vma is still * If the page is still mapped, then this anon_vma is still

4
mm/slub.c
View File

@ -4277,7 +4277,7 @@ static ssize_t show_slab_objects(struct kmem_cache *s,
int node; int node;
struct page *page; struct page *page;
page = ACCESS_ONCE(c->page); page = READ_ONCE(c->page);
if (!page) if (!page)
continue; continue;
@ -4292,7 +4292,7 @@ static ssize_t show_slab_objects(struct kmem_cache *s,
total += x; total += x;
nodes[node] += x; nodes[node] += x;
page = ACCESS_ONCE(c->partial); page = READ_ONCE(c->partial);
if (page) { if (page) {
node = page_to_nid(page); node = page_to_nid(page);
if (flags & SO_TOTAL) if (flags & SO_TOTAL)

2
mm/swap_state.c
View File

@ -390,7 +390,7 @@ static unsigned long swapin_nr_pages(unsigned long offset)
unsigned int pages, max_pages, last_ra; unsigned int pages, max_pages, last_ra;
static atomic_t last_readahead_pages; static atomic_t last_readahead_pages;
max_pages = 1 << ACCESS_ONCE(page_cluster); max_pages = 1 << READ_ONCE(page_cluster);
if (max_pages <= 1) if (max_pages <= 1)
return 1; return 1;

2
mm/swapfile.c
View File

@ -1312,7 +1312,7 @@ static unsigned int find_next_to_unuse(struct swap_info_struct *si,
else else
continue; continue;
} }
count = ACCESS_ONCE(si->swap_map[i]); count = READ_ONCE(si->swap_map[i]);
if (count && swap_count(count) != SWAP_MAP_BAD) if (count && swap_count(count) != SWAP_MAP_BAD)
break; break;
} }