[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date: Thu, 5 Jan 2017 11:25:37 +0900
From: AKASHI Takahiro <takahiro.akashi@...aro.org>
To: kernel-hardening@...ts.openwall.com
Cc: keescook@...omium.org, arnd@...db.de, tglx@...utronix.de,
mingo@...hat.com, h.peter.anvin@...el.com, peterz@...radead.org,
will.deacon@....com, dwindsor@...il.com, gregkh@...uxfoundation.org,
ishkamiel@...il.com, Elena Reshetova <elena.reshetova@...el.com>
Subject: Re: [RFC PATCH 08/19] kernel, mm: convert from
atomic_t to refcount_t
On Thu, Dec 29, 2016 at 08:56:00AM +0200, Elena Reshetova wrote:
> refcount_t type and corresponding API should be
> used instead of atomic_t when the variable is used as
> a reference counter. Convert the cases found.
>
> Signed-off-by: Elena Reshetova <elena.reshetova@...el.com>
> Signed-off-by: Hans Liljestrand <ishkamiel@...il.com>
> ---
> arch/alpha/kernel/smp.c | 6 ++---
> arch/arc/kernel/smp.c | 2 +-
> arch/arc/mm/tlb.c | 2 +-
> arch/arm/kernel/smp.c | 2 +-
> arch/blackfin/mach-common/smp.c | 4 +--
> arch/frv/mm/mmu-context.c | 2 +-
> arch/ia64/include/asm/tlbflush.h | 2 +-
> arch/ia64/kernel/smp.c | 2 +-
> arch/ia64/sn/kernel/sn2/sn2_smp.c | 4 +--
> arch/metag/kernel/smp.c | 2 +-
> arch/mips/kernel/process.c | 2 +-
> arch/mips/kernel/smp.c | 6 ++---
> arch/parisc/include/asm/mmu_context.h | 2 +-
> arch/powerpc/mm/hugetlbpage.c | 2 +-
> arch/powerpc/mm/icswx.c | 4 +--
> arch/s390/include/asm/debug.h | 3 ++-
> arch/s390/kernel/debug.c | 6 ++---
> arch/sh/kernel/smp.c | 8 +++---
> arch/sparc/kernel/mdesc.c | 17 ++++++------
> arch/sparc/kernel/smp_64.c | 6 ++---
> arch/sparc/mm/srmmu.c | 2 +-
> arch/um/kernel/tlb.c | 2 +-
> arch/x86/include/asm/amd_nb.h | 3 ++-
> arch/x86/kernel/cpu/common.c | 4 +--
> arch/x86/kernel/cpu/mcheck/mce_amd.c | 6 ++---
> arch/x86/kernel/tboot.c | 4 +--
> arch/xtensa/kernel/smp.c | 2 +-
> drivers/firmware/efi/arm-runtime.c | 4 +--
> drivers/gpu/drm/i915/i915_gem_userptr.c | 4 +--
> drivers/iommu/intel-svm.c | 2 +-
> fs/coredump.c | 2 +-
> fs/exec.c | 4 +--
> fs/proc/base.c | 10 +++----
> fs/proc/task_mmu.c | 4 +--
> fs/proc/task_nommu.c | 2 +-
> fs/userfaultfd.c | 2 +-
> include/linux/backing-dev-defs.h | 3 ++-
> include/linux/backing-dev.h | 4 +--
> include/linux/cgroup-defs.h | 3 ++-
> include/linux/cgroup.h | 7 ++---
> include/linux/cred.h | 13 +++++-----
> include/linux/init_task.h | 7 ++---
> include/linux/kvm_host.h | 3 ++-
> include/linux/mm_types.h | 5 ++--
> include/linux/nsproxy.h | 6 ++---
> include/linux/perf_event.h | 3 ++-
> include/linux/rmap.h | 7 ++---
> include/linux/sched.h | 25 +++++++++---------
> kernel/audit_tree.c | 10 +++----
> kernel/audit_watch.c | 8 +++---
> kernel/cgroup.c | 23 ++++++++++-------
> kernel/cred.c | 46 ++++++++++++++++-----------------
> kernel/events/core.c | 16 ++++++------
> kernel/events/internal.h | 5 ++--
> kernel/events/ring_buffer.c | 8 +++---
> kernel/events/uprobes.c | 13 +++++-----
> kernel/exit.c | 4 +--
> kernel/fork.c | 40 ++++++++++++++--------------
> kernel/futex.c | 17 ++++++------
> kernel/groups.c | 2 +-
> kernel/kcov.c | 9 ++++---
> kernel/nsproxy.c | 6 ++---
> kernel/sched/core.c | 7 ++---
> kernel/sched/fair.c | 8 +++---
> kernel/user.c | 8 +++---
> lib/is_single_threaded.c | 2 +-
> mm/backing-dev.c | 11 ++++----
> mm/debug.c | 2 +-
> mm/huge_memory.c | 16 +++++++-----
> mm/init-mm.c | 4 +--
> mm/khugepaged.c | 4 +--
> mm/kmemleak.c | 16 ++++++------
> mm/ksm.c | 4 +--
> mm/memory.c | 2 +-
> mm/mmu_context.c | 2 +-
> mm/mmu_notifier.c | 12 ++++-----
> mm/mprotect.c | 2 +-
> mm/oom_kill.c | 6 ++---
> mm/rmap.c | 14 +++++-----
> mm/swapfile.c | 14 +++++-----
> mm/vmacache.c | 2 +-
> mm/zpool.c | 4 +--
> net/sunrpc/auth_null.c | 2 +-
> virt/kvm/async_pf.c | 2 +-
> virt/kvm/kvm_main.c | 10 +++----
> 85 files changed, 307 insertions(+), 281 deletions(-)
>
> diff --git a/arch/alpha/kernel/smp.c b/arch/alpha/kernel/smp.c
> index 46bf263..cc5aa0a 100644
> --- a/arch/alpha/kernel/smp.c
> +++ b/arch/alpha/kernel/smp.c
> @@ -653,7 +653,7 @@ flush_tlb_mm(struct mm_struct *mm)
>
> if (mm == current->active_mm) {
> flush_tlb_current(mm);
> - if (atomic_read(&mm->mm_users) <= 1) {
> + if (refcount_read(&mm->mm_users) <= 1) {
> int cpu, this_cpu = smp_processor_id();
> for (cpu = 0; cpu < NR_CPUS; cpu++) {
> if (!cpu_online(cpu) || cpu == this_cpu)
> @@ -702,7 +702,7 @@ flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
>
> if (mm == current->active_mm) {
> flush_tlb_current_page(mm, vma, addr);
> - if (atomic_read(&mm->mm_users) <= 1) {
> + if (refcount_read(&mm->mm_users) <= 1) {
> int cpu, this_cpu = smp_processor_id();
> for (cpu = 0; cpu < NR_CPUS; cpu++) {
> if (!cpu_online(cpu) || cpu == this_cpu)
> @@ -758,7 +758,7 @@ flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
>
> if (mm == current->active_mm) {
> __load_new_mm_context(mm);
> - if (atomic_read(&mm->mm_users) <= 1) {
> + if (refcount_read(&mm->mm_users) <= 1) {
> int cpu, this_cpu = smp_processor_id();
> for (cpu = 0; cpu < NR_CPUS; cpu++) {
> if (!cpu_online(cpu) || cpu == this_cpu)
> diff --git a/arch/arc/kernel/smp.c b/arch/arc/kernel/smp.c
> index 88674d9..8e22594 100644
> --- a/arch/arc/kernel/smp.c
> +++ b/arch/arc/kernel/smp.c
> @@ -124,7 +124,7 @@ void start_kernel_secondary(void)
> /* MMU, Caches, Vector Table, Interrupts etc */
> setup_processor();
>
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> atomic_inc(&mm->mm_count);
> current->active_mm = mm;
> cpumask_set_cpu(cpu, mm_cpumask(mm));
> diff --git a/arch/arc/mm/tlb.c b/arch/arc/mm/tlb.c
> index bdb295e..6dbdfe7 100644
> --- a/arch/arc/mm/tlb.c
> +++ b/arch/arc/mm/tlb.c
> @@ -297,7 +297,7 @@ noinline void local_flush_tlb_mm(struct mm_struct *mm)
> * Only for fork( ) do we need to move parent to a new MMU ctxt,
> * all other cases are NOPs, hence this check.
> */
> - if (atomic_read(&mm->mm_users) == 0)
> + if (refcount_read(&mm->mm_users) == 0)
> return;
>
> /*
> diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
> index 7dd14e8..1d59aca 100644
> --- a/arch/arm/kernel/smp.c
> +++ b/arch/arm/kernel/smp.c
> @@ -371,7 +371,7 @@ asmlinkage void secondary_start_kernel(void)
> * reference and switch to it.
> */
> cpu = smp_processor_id();
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> current->active_mm = mm;
> cpumask_set_cpu(cpu, mm_cpumask(mm));
>
If this is the case, arm64 has almost the same code.
-Takahiro AKASHI
> diff --git a/arch/blackfin/mach-common/smp.c b/arch/blackfin/mach-common/smp.c
> index 23c4ef5..d90422d 100644
> --- a/arch/blackfin/mach-common/smp.c
> +++ b/arch/blackfin/mach-common/smp.c
> @@ -307,7 +307,7 @@ void secondary_start_kernel(void)
> local_irq_disable();
>
> /* Attach the new idle task to the global mm. */
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> atomic_inc(&mm->mm_count);
> current->active_mm = mm;
>
> @@ -422,7 +422,7 @@ void cpu_die(void)
> {
> (void)cpu_report_death();
>
> - atomic_dec(&init_mm.mm_users);
> + refcount_dec(&init_mm.mm_users);
> atomic_dec(&init_mm.mm_count);
>
> local_irq_disable();
> diff --git a/arch/frv/mm/mmu-context.c b/arch/frv/mm/mmu-context.c
> index 81757d5..128cfd6 100644
> --- a/arch/frv/mm/mmu-context.c
> +++ b/arch/frv/mm/mmu-context.c
> @@ -188,7 +188,7 @@ int cxn_pin_by_pid(pid_t pid)
> task_lock(tsk);
> if (tsk->mm) {
> mm = tsk->mm;
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> ret = 0;
> }
> task_unlock(tsk);
> diff --git a/arch/ia64/include/asm/tlbflush.h b/arch/ia64/include/asm/tlbflush.h
> index 3be25df..650708a 100644
> --- a/arch/ia64/include/asm/tlbflush.h
> +++ b/arch/ia64/include/asm/tlbflush.h
> @@ -56,7 +56,7 @@ flush_tlb_mm (struct mm_struct *mm)
> set_bit(mm->context, ia64_ctx.flushmap);
> mm->context = 0;
>
> - if (atomic_read(&mm->mm_users) == 0)
> + if (refcount_read(&mm->mm_users) == 0)
> return; /* happens as a result of exit_mmap() */
>
> #ifdef CONFIG_SMP
> diff --git a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c
> index 7f706d4..dd7b680 100644
> --- a/arch/ia64/kernel/smp.c
> +++ b/arch/ia64/kernel/smp.c
> @@ -295,7 +295,7 @@ smp_flush_tlb_mm (struct mm_struct *mm)
> cpumask_var_t cpus;
> preempt_disable();
> /* this happens for the common case of a single-threaded fork(): */
> - if (likely(mm == current->active_mm && atomic_read(&mm->mm_users) == 1))
> + if (likely(mm == current->active_mm && refcount_read(&mm->mm_users) == 1))
> {
> local_finish_flush_tlb_mm(mm);
> preempt_enable();
> diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
> index c98dc96..1c801b3 100644
> --- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
> +++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
> @@ -122,7 +122,7 @@ void sn_migrate(struct task_struct *task)
> void sn_tlb_migrate_finish(struct mm_struct *mm)
> {
> /* flush_tlb_mm is inefficient if more than 1 users of mm */
> - if (mm == current->mm && mm && atomic_read(&mm->mm_users) == 1)
> + if (mm == current->mm && mm && refcount_read(&mm->mm_users) == 1)
> flush_tlb_mm(mm);
> }
>
> @@ -204,7 +204,7 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
> return;
> }
>
> - if (atomic_read(&mm->mm_users) == 1 && mymm) {
> + if (refcount_read(&mm->mm_users) == 1 && mymm) {
> flush_tlb_mm(mm);
> __this_cpu_inc(ptcstats.change_rid);
> preempt_enable();
> diff --git a/arch/metag/kernel/smp.c b/arch/metag/kernel/smp.c
> index bad1323..5a9835b 100644
> --- a/arch/metag/kernel/smp.c
> +++ b/arch/metag/kernel/smp.c
> @@ -344,7 +344,7 @@ asmlinkage void secondary_start_kernel(void)
> * All kernel threads share the same mm context; grab a
> * reference and switch to it.
> */
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> atomic_inc(&mm->mm_count);
> current->active_mm = mm;
> cpumask_set_cpu(cpu, mm_cpumask(mm));
> diff --git a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c
> index 9514e5f..64baeb8 100644
> --- a/arch/mips/kernel/process.c
> +++ b/arch/mips/kernel/process.c
> @@ -642,7 +642,7 @@ int mips_set_process_fp_mode(struct task_struct *task, unsigned int value)
> /* No need to send an IPI for the local CPU */
> max_users = (task->mm == current->mm) ? 1 : 0;
>
> - if (atomic_read(¤t->mm->mm_users) > max_users)
> + if (refcount_read(¤t->mm->mm_users) > max_users)
> smp_call_function(prepare_for_fp_mode_switch,
> (void *)current->mm, 1);
> }
> diff --git a/arch/mips/kernel/smp.c b/arch/mips/kernel/smp.c
> index 7ebb191..9017ff3 100644
> --- a/arch/mips/kernel/smp.c
> +++ b/arch/mips/kernel/smp.c
> @@ -510,7 +510,7 @@ void flush_tlb_mm(struct mm_struct *mm)
> {
> preempt_disable();
>
> - if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> + if ((refcount_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> smp_on_other_tlbs(flush_tlb_mm_ipi, mm);
> } else {
> unsigned int cpu;
> @@ -543,7 +543,7 @@ void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned l
> struct mm_struct *mm = vma->vm_mm;
>
> preempt_disable();
> - if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> + if ((refcount_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> struct flush_tlb_data fd = {
> .vma = vma,
> .addr1 = start,
> @@ -597,7 +597,7 @@ static void flush_tlb_page_ipi(void *info)
> void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
> {
> preempt_disable();
> - if ((atomic_read(&vma->vm_mm->mm_users) != 1) || (current->mm != vma->vm_mm)) {
> + if ((refcount_read(&vma->vm_mm->mm_users) != 1) || (current->mm != vma->vm_mm)) {
> struct flush_tlb_data fd = {
> .vma = vma,
> .addr1 = page,
> diff --git a/arch/parisc/include/asm/mmu_context.h b/arch/parisc/include/asm/mmu_context.h
> index 59be257..e64f398 100644
> --- a/arch/parisc/include/asm/mmu_context.h
> +++ b/arch/parisc/include/asm/mmu_context.h
> @@ -21,7 +21,7 @@ extern void free_sid(unsigned long);
> static inline int
> init_new_context(struct task_struct *tsk, struct mm_struct *mm)
> {
> - BUG_ON(atomic_read(&mm->mm_users) != 1);
> + BUG_ON(refcount_read(&mm->mm_users) != 1);
>
> mm->context = alloc_sid();
> return 0;
> diff --git a/arch/powerpc/mm/hugetlbpage.c b/arch/powerpc/mm/hugetlbpage.c
> index 289df38..f3db57b 100644
> --- a/arch/powerpc/mm/hugetlbpage.c
> +++ b/arch/powerpc/mm/hugetlbpage.c
> @@ -403,7 +403,7 @@ static void hugepd_free(struct mmu_gather *tlb, void *hugepte)
>
> batchp = &get_cpu_var(hugepd_freelist_cur);
>
> - if (atomic_read(&tlb->mm->mm_users) < 2 ||
> + if (refcount_read(&tlb->mm->mm_users) < 2 ||
> cpumask_equal(mm_cpumask(tlb->mm),
> cpumask_of(smp_processor_id()))) {
> kmem_cache_free(hugepte_cache, hugepte);
> diff --git a/arch/powerpc/mm/icswx.c b/arch/powerpc/mm/icswx.c
> index 915412e..2406ff8 100644
> --- a/arch/powerpc/mm/icswx.c
> +++ b/arch/powerpc/mm/icswx.c
> @@ -110,7 +110,7 @@ int use_cop(unsigned long acop, struct mm_struct *mm)
> * running. We need to send an IPI to force them to pick up any
> * change in PID and ACOP.
> */
> - if (atomic_read(&mm->mm_users) > 1)
> + if (refcount_read(&mm->mm_users) > 1)
> smp_call_function(sync_cop, mm, 1);
>
> out:
> @@ -150,7 +150,7 @@ void drop_cop(unsigned long acop, struct mm_struct *mm)
> * running. We need to send an IPI to force them to pick up any
> * change in PID and ACOP.
> */
> - if (atomic_read(&mm->mm_users) > 1)
> + if (refcount_read(&mm->mm_users) > 1)
> smp_call_function(sync_cop, mm, 1);
>
> if (free_pid != COP_PID_NONE)
> diff --git a/arch/s390/include/asm/debug.h b/arch/s390/include/asm/debug.h
> index 0206c80..df7b54e 100644
> --- a/arch/s390/include/asm/debug.h
> +++ b/arch/s390/include/asm/debug.h
> @@ -10,6 +10,7 @@
> #include <linux/spinlock.h>
> #include <linux/kernel.h>
> #include <linux/time.h>
> +#include <linux/refcount.h>
> #include <uapi/asm/debug.h>
>
> #define DEBUG_MAX_LEVEL 6 /* debug levels range from 0 to 6 */
> @@ -31,7 +32,7 @@ struct debug_view;
> typedef struct debug_info {
> struct debug_info* next;
> struct debug_info* prev;
> - atomic_t ref_count;
> + refcount_t ref_count;
> spinlock_t lock;
> int level;
> int nr_areas;
> diff --git a/arch/s390/kernel/debug.c b/arch/s390/kernel/debug.c
> index aa12de7..b4c1d2a 100644
> --- a/arch/s390/kernel/debug.c
> +++ b/arch/s390/kernel/debug.c
> @@ -277,7 +277,7 @@ debug_info_alloc(const char *name, int pages_per_area, int nr_areas,
> memset(rc->views, 0, DEBUG_MAX_VIEWS * sizeof(struct debug_view *));
> memset(rc->debugfs_entries, 0 ,DEBUG_MAX_VIEWS *
> sizeof(struct dentry*));
> - atomic_set(&(rc->ref_count), 0);
> + refcount_set(&(rc->ref_count), 0);
>
> return rc;
>
> @@ -416,7 +416,7 @@ static void
> debug_info_get(debug_info_t * db_info)
> {
> if (db_info)
> - atomic_inc(&db_info->ref_count);
> + refcount_inc(&db_info->ref_count);
> }
>
> /*
> @@ -431,7 +431,7 @@ debug_info_put(debug_info_t *db_info)
>
> if (!db_info)
> return;
> - if (atomic_dec_and_test(&db_info->ref_count)) {
> + if (refcount_dec_and_test(&db_info->ref_count)) {
> for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
> if (!db_info->views[i])
> continue;
> diff --git a/arch/sh/kernel/smp.c b/arch/sh/kernel/smp.c
> index 38e7860..f0aabeb 100644
> --- a/arch/sh/kernel/smp.c
> +++ b/arch/sh/kernel/smp.c
> @@ -179,7 +179,7 @@ asmlinkage void start_secondary(void)
>
> enable_mmu();
> atomic_inc(&mm->mm_count);
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> current->active_mm = mm;
> #ifdef CONFIG_MMU
> enter_lazy_tlb(mm, current);
> @@ -363,7 +363,7 @@ void flush_tlb_mm(struct mm_struct *mm)
> {
> preempt_disable();
>
> - if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> + if ((refcount_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> smp_call_function(flush_tlb_mm_ipi, (void *)mm, 1);
> } else {
> int i;
> @@ -395,7 +395,7 @@ void flush_tlb_range(struct vm_area_struct *vma,
> struct mm_struct *mm = vma->vm_mm;
>
> preempt_disable();
> - if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> + if ((refcount_read(&mm->mm_users) != 1) || (current->mm != mm)) {
> struct flush_tlb_data fd;
>
> fd.vma = vma;
> @@ -438,7 +438,7 @@ static void flush_tlb_page_ipi(void *info)
> void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
> {
> preempt_disable();
> - if ((atomic_read(&vma->vm_mm->mm_users) != 1) ||
> + if ((refcount_read(&vma->vm_mm->mm_users) != 1) ||
> (current->mm != vma->vm_mm)) {
> struct flush_tlb_data fd;
>
> diff --git a/arch/sparc/kernel/mdesc.c b/arch/sparc/kernel/mdesc.c
> index 8a6982d..111e3ce 100644
> --- a/arch/sparc/kernel/mdesc.c
> +++ b/arch/sparc/kernel/mdesc.c
> @@ -12,6 +12,7 @@
> #include <linux/miscdevice.h>
> #include <linux/bootmem.h>
> #include <linux/export.h>
> +#include <linux/refcount.h>
>
> #include <asm/cpudata.h>
> #include <asm/hypervisor.h>
> @@ -70,7 +71,7 @@ struct mdesc_handle {
> struct list_head list;
> struct mdesc_mem_ops *mops;
> void *self_base;
> - atomic_t refcnt;
> + refcount_t refcnt;
> unsigned int handle_size;
> struct mdesc_hdr mdesc;
> };
> @@ -84,7 +85,7 @@ static void mdesc_handle_init(struct mdesc_handle *hp,
> memset(hp, 0, handle_size);
> INIT_LIST_HEAD(&hp->list);
> hp->self_base = base;
> - atomic_set(&hp->refcnt, 1);
> + refcount_set(&hp->refcnt, 1);
> hp->handle_size = handle_size;
> }
>
> @@ -114,7 +115,7 @@ static void __init mdesc_memblock_free(struct mdesc_handle *hp)
> unsigned int alloc_size;
> unsigned long start;
>
> - BUG_ON(atomic_read(&hp->refcnt) != 0);
> + BUG_ON(refcount_read(&hp->refcnt) != 0);
> BUG_ON(!list_empty(&hp->list));
>
> alloc_size = PAGE_ALIGN(hp->handle_size);
> @@ -154,7 +155,7 @@ static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
>
> static void mdesc_kfree(struct mdesc_handle *hp)
> {
> - BUG_ON(atomic_read(&hp->refcnt) != 0);
> + BUG_ON(refcount_read(&hp->refcnt) != 0);
> BUG_ON(!list_empty(&hp->list));
>
> kfree(hp->self_base);
> @@ -193,7 +194,7 @@ struct mdesc_handle *mdesc_grab(void)
> spin_lock_irqsave(&mdesc_lock, flags);
> hp = cur_mdesc;
> if (hp)
> - atomic_inc(&hp->refcnt);
> + refcount_inc(&hp->refcnt);
> spin_unlock_irqrestore(&mdesc_lock, flags);
>
> return hp;
> @@ -205,7 +206,7 @@ void mdesc_release(struct mdesc_handle *hp)
> unsigned long flags;
>
> spin_lock_irqsave(&mdesc_lock, flags);
> - if (atomic_dec_and_test(&hp->refcnt)) {
> + if (refcount_dec_and_test(&hp->refcnt)) {
> list_del_init(&hp->list);
> hp->mops->free(hp);
> }
> @@ -344,7 +345,7 @@ void mdesc_update(void)
> if (status != HV_EOK || real_len > len) {
> printk(KERN_ERR "MD: mdesc reread fails with %lu\n",
> status);
> - atomic_dec(&hp->refcnt);
> + refcount_dec(&hp->refcnt);
> mdesc_free(hp);
> goto out;
> }
> @@ -357,7 +358,7 @@ void mdesc_update(void)
> mdesc_notify_clients(orig_hp, hp);
>
> spin_lock_irqsave(&mdesc_lock, flags);
> - if (atomic_dec_and_test(&orig_hp->refcnt))
> + if (refcount_dec_and_test(&orig_hp->refcnt))
> mdesc_free(orig_hp);
> else
> list_add(&orig_hp->list, &mdesc_zombie_list);
> diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
> index 8182f7c..582a085 100644
> --- a/arch/sparc/kernel/smp_64.c
> +++ b/arch/sparc/kernel/smp_64.c
> @@ -1063,7 +1063,7 @@ void smp_flush_tlb_mm(struct mm_struct *mm)
> u32 ctx = CTX_HWBITS(mm->context);
> int cpu = get_cpu();
>
> - if (atomic_read(&mm->mm_users) == 1) {
> + if (refcount_read(&mm->mm_users) == 1) {
> cpumask_copy(mm_cpumask(mm), cpumask_of(cpu));
> goto local_flush_and_out;
> }
> @@ -1101,7 +1101,7 @@ void smp_flush_tlb_pending(struct mm_struct *mm, unsigned long nr, unsigned long
> info.nr = nr;
> info.vaddrs = vaddrs;
>
> - if (mm == current->mm && atomic_read(&mm->mm_users) == 1)
> + if (mm == current->mm && refcount_read(&mm->mm_users) == 1)
> cpumask_copy(mm_cpumask(mm), cpumask_of(cpu));
> else
> smp_call_function_many(mm_cpumask(mm), tlb_pending_func,
> @@ -1117,7 +1117,7 @@ void smp_flush_tlb_page(struct mm_struct *mm, unsigned long vaddr)
> unsigned long context = CTX_HWBITS(mm->context);
> int cpu = get_cpu();
>
> - if (mm == current->mm && atomic_read(&mm->mm_users) == 1)
> + if (mm == current->mm && refcount_read(&mm->mm_users) == 1)
> cpumask_copy(mm_cpumask(mm), cpumask_of(cpu));
> else
> smp_cross_call_masked(&xcall_flush_tlb_page,
> diff --git a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c
> index c7f2a52..17941a8 100644
> --- a/arch/sparc/mm/srmmu.c
> +++ b/arch/sparc/mm/srmmu.c
> @@ -1662,7 +1662,7 @@ static void smp_flush_tlb_mm(struct mm_struct *mm)
> cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
> if (!cpumask_empty(&cpu_mask)) {
> xc1((smpfunc_t) local_ops->tlb_mm, (unsigned long) mm);
> - if (atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
> + if (refcount_read(&mm->mm_users) == 1 && current->active_mm == mm)
> cpumask_copy(mm_cpumask(mm),
> cpumask_of(smp_processor_id()));
> }
> diff --git a/arch/um/kernel/tlb.c b/arch/um/kernel/tlb.c
> index 3777b82..1da0463 100644
> --- a/arch/um/kernel/tlb.c
> +++ b/arch/um/kernel/tlb.c
> @@ -530,7 +530,7 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
> * Don't bother flushing if this address space is about to be
> * destroyed.
> */
> - if (atomic_read(&mm->mm_users) == 0)
> + if (refcount_read(&mm->mm_users) == 0)
> return;
>
> fix_range(mm, start, end, 0);
> diff --git a/arch/x86/include/asm/amd_nb.h b/arch/x86/include/asm/amd_nb.h
> index 00c88a0..da181ad 100644
> --- a/arch/x86/include/asm/amd_nb.h
> +++ b/arch/x86/include/asm/amd_nb.h
> @@ -3,6 +3,7 @@
>
> #include <linux/ioport.h>
> #include <linux/pci.h>
> +#include <linux/refcount.h>
>
> struct amd_nb_bus_dev_range {
> u8 bus;
> @@ -55,7 +56,7 @@ struct threshold_bank {
> struct threshold_block *blocks;
>
> /* initialized to the number of CPUs on the node sharing this bank */
> - atomic_t cpus;
> + refcount_t cpus;
> };
>
> struct amd_northbridge {
> diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
> index 1f6b50a..b92d07a 100644
> --- a/arch/x86/kernel/cpu/common.c
> +++ b/arch/x86/kernel/cpu/common.c
> @@ -1490,7 +1490,7 @@ void cpu_init(void)
> for (i = 0; i <= IO_BITMAP_LONGS; i++)
> t->io_bitmap[i] = ~0UL;
>
> - atomic_inc(&init_mm.mm_count);
> + refcount_inc(&init_mm.mm_count);
> me->active_mm = &init_mm;
> BUG_ON(me->mm);
> enter_lazy_tlb(&init_mm, me);
> @@ -1541,7 +1541,7 @@ void cpu_init(void)
> /*
> * Set up and load the per-CPU TSS and LDT
> */
> - atomic_inc(&init_mm.mm_count);
> + refcount_inc(&init_mm.mm_count);
> curr->active_mm = &init_mm;
> BUG_ON(curr->mm);
> enter_lazy_tlb(&init_mm, curr);
> diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd.c b/arch/x86/kernel/cpu/mcheck/mce_amd.c
> index ffacfdc..61a7a76 100644
> --- a/arch/x86/kernel/cpu/mcheck/mce_amd.c
> +++ b/arch/x86/kernel/cpu/mcheck/mce_amd.c
> @@ -1194,7 +1194,7 @@ static int threshold_create_bank(unsigned int cpu, unsigned int bank)
> goto out;
>
> per_cpu(threshold_banks, cpu)[bank] = b;
> - atomic_inc(&b->cpus);
> + refcount_inc(&b->cpus);
>
> err = __threshold_add_blocks(b);
>
> @@ -1217,7 +1217,7 @@ static int threshold_create_bank(unsigned int cpu, unsigned int bank)
> per_cpu(threshold_banks, cpu)[bank] = b;
>
> if (is_shared_bank(bank)) {
> - atomic_set(&b->cpus, 1);
> + refcount_set(&b->cpus, 1);
>
> /* nb is already initialized, see above */
> if (nb) {
> @@ -1281,7 +1281,7 @@ static void threshold_remove_bank(unsigned int cpu, int bank)
> goto free_out;
>
> if (is_shared_bank(bank)) {
> - if (!atomic_dec_and_test(&b->cpus)) {
> + if (!refcount_dec_and_test(&b->cpus)) {
> __threshold_remove_blocks(b);
> per_cpu(threshold_banks, cpu)[bank] = NULL;
> return;
> diff --git a/arch/x86/kernel/tboot.c b/arch/x86/kernel/tboot.c
> index 8402907..eb4b2bd 100644
> --- a/arch/x86/kernel/tboot.c
> +++ b/arch/x86/kernel/tboot.c
> @@ -102,8 +102,8 @@ static pgd_t *tboot_pg_dir;
> static struct mm_struct tboot_mm = {
> .mm_rb = RB_ROOT,
> .pgd = swapper_pg_dir,
> - .mm_users = ATOMIC_INIT(2),
> - .mm_count = ATOMIC_INIT(1),
> + .mm_users = REFCOUNT_INIT(2),
> + .mm_count = REFCOUNT_INIT(1),
> .mmap_sem = __RWSEM_INITIALIZER(init_mm.mmap_sem),
> .page_table_lock = __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock),
> .mmlist = LIST_HEAD_INIT(init_mm.mmlist),
> diff --git a/arch/xtensa/kernel/smp.c b/arch/xtensa/kernel/smp.c
> index fc4ad21..4e9ec31 100644
> --- a/arch/xtensa/kernel/smp.c
> +++ b/arch/xtensa/kernel/smp.c
> @@ -135,7 +135,7 @@ void secondary_start_kernel(void)
>
> /* All kernel threads share the same mm context. */
>
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> atomic_inc(&mm->mm_count);
> current->active_mm = mm;
> cpumask_set_cpu(cpu, mm_cpumask(mm));
> diff --git a/drivers/firmware/efi/arm-runtime.c b/drivers/firmware/efi/arm-runtime.c
> index 349dc3e..f0571f2 100644
> --- a/drivers/firmware/efi/arm-runtime.c
> +++ b/drivers/firmware/efi/arm-runtime.c
> @@ -32,8 +32,8 @@ extern u64 efi_system_table;
>
> static struct mm_struct efi_mm = {
> .mm_rb = RB_ROOT,
> - .mm_users = ATOMIC_INIT(2),
> - .mm_count = ATOMIC_INIT(1),
> + .mm_users = REFCOUNT_INIT(2),
> + .mm_count = REFCOUNT_INIT(1),
> .mmap_sem = __RWSEM_INITIALIZER(efi_mm.mmap_sem),
> .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
> .mmlist = LIST_HEAD_INIT(efi_mm.mmlist),
> diff --git a/drivers/gpu/drm/i915/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c
> index d068af2..430eeba 100644
> --- a/drivers/gpu/drm/i915/i915_gem_userptr.c
> +++ b/drivers/gpu/drm/i915/i915_gem_userptr.c
> @@ -334,7 +334,7 @@ i915_gem_userptr_init__mm_struct(struct drm_i915_gem_object *obj)
> mm->i915 = to_i915(obj->base.dev);
>
> mm->mm = current->mm;
> - atomic_inc(¤t->mm->mm_count);
> + refcount_inc(¤t->mm->mm_count);
>
> mm->mn = NULL;
>
> @@ -507,7 +507,7 @@ __i915_gem_userptr_get_pages_worker(struct work_struct *_work)
> flags |= FOLL_WRITE;
>
> ret = -EFAULT;
> - if (atomic_inc_not_zero(&mm->mm_users)) {
> + if (refcount_inc_not_zero(&mm->mm_users)) {
> down_read(&mm->mmap_sem);
> while (pinned < npages) {
> ret = get_user_pages_remote
> diff --git a/drivers/iommu/intel-svm.c b/drivers/iommu/intel-svm.c
> index cb72e00..d46eb3b 100644
> --- a/drivers/iommu/intel-svm.c
> +++ b/drivers/iommu/intel-svm.c
> @@ -579,7 +579,7 @@ static irqreturn_t prq_event_thread(int irq, void *d)
> if (!svm->mm)
> goto bad_req;
> /* If the mm is already defunct, don't handle faults. */
> - if (!atomic_inc_not_zero(&svm->mm->mm_users))
> + if (!refcount_inc_not_zero(&svm->mm->mm_users))
> goto bad_req;
> down_read(&svm->mm->mmap_sem);
> vma = find_extend_vma(svm->mm, address);
> diff --git a/fs/coredump.c b/fs/coredump.c
> index eb9c92c..5d3f725 100644
> --- a/fs/coredump.c
> +++ b/fs/coredump.c
> @@ -347,7 +347,7 @@ static int zap_threads(struct task_struct *tsk, struct mm_struct *mm,
> return nr;
>
> tsk->flags |= PF_DUMPCORE;
> - if (atomic_read(&mm->mm_users) == nr + 1)
> + if (refcount_read(&mm->mm_users) == nr + 1)
> goto done;
> /*
> * We should find and kill all tasks which use this mm, and we should
> diff --git a/fs/exec.c b/fs/exec.c
> index eadbf50..d463f17 100644
> --- a/fs/exec.c
> +++ b/fs/exec.c
> @@ -1174,7 +1174,7 @@ static int de_thread(struct task_struct *tsk)
> flush_itimer_signals();
> #endif
>
> - if (atomic_read(&oldsighand->count) != 1) {
> + if (refcount_read(&oldsighand->count) != 1) {
> struct sighand_struct *newsighand;
> /*
> * This ->sighand is shared with the CLONE_SIGHAND
> @@ -1184,7 +1184,7 @@ static int de_thread(struct task_struct *tsk)
> if (!newsighand)
> return -ENOMEM;
>
> - atomic_set(&newsighand->count, 1);
> + refcount_set(&newsighand->count, 1);
> memcpy(newsighand->action, oldsighand->action,
> sizeof(newsighand->action));
>
> diff --git a/fs/proc/base.c b/fs/proc/base.c
> index 5ea8363..ef0b7ae 100644
> --- a/fs/proc/base.c
> +++ b/fs/proc/base.c
> @@ -798,7 +798,7 @@ struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode)
>
> if (!IS_ERR_OR_NULL(mm)) {
> /* ensure this mm_struct can't be freed */
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> /* but do not pin its memory */
> mmput(mm);
> }
> @@ -845,7 +845,7 @@ static ssize_t mem_rw(struct file *file, char __user *buf,
> return -ENOMEM;
>
> copied = 0;
> - if (!atomic_inc_not_zero(&mm->mm_users))
> + if (!refcount_inc_not_zero(&mm->mm_users))
> goto free;
>
> /* Maybe we should limit FOLL_FORCE to actual ptrace users? */
> @@ -953,7 +953,7 @@ static ssize_t environ_read(struct file *file, char __user *buf,
> return -ENOMEM;
>
> ret = 0;
> - if (!atomic_inc_not_zero(&mm->mm_users))
> + if (!refcount_inc_not_zero(&mm->mm_users))
> goto free;
>
> down_read(&mm->mmap_sem);
> @@ -1094,9 +1094,9 @@ static int __set_oom_adj(struct file *file, int oom_adj, bool legacy)
> struct task_struct *p = find_lock_task_mm(task);
>
> if (p) {
> - if (atomic_read(&p->mm->mm_users) > 1) {
> + if (refcount_read(&p->mm->mm_users) > 1) {
> mm = p->mm;
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> }
> task_unlock(p);
> }
> diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
> index 958f325..cc65008 100644
> --- a/fs/proc/task_mmu.c
> +++ b/fs/proc/task_mmu.c
> @@ -167,7 +167,7 @@ static void *m_start(struct seq_file *m, loff_t *ppos)
> return ERR_PTR(-ESRCH);
>
> mm = priv->mm;
> - if (!mm || !atomic_inc_not_zero(&mm->mm_users))
> + if (!mm || !refcount_inc_not_zero(&mm->mm_users))
> return NULL;
>
> down_read(&mm->mmap_sem);
> @@ -1352,7 +1352,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
> unsigned long end_vaddr;
> int ret = 0, copied = 0;
>
> - if (!mm || !atomic_inc_not_zero(&mm->mm_users))
> + if (!mm || !refcount_inc_not_zero(&mm->mm_users))
> goto out;
>
> ret = -EINVAL;
> diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
> index 3717562..bf0b163 100644
> --- a/fs/proc/task_nommu.c
> +++ b/fs/proc/task_nommu.c
> @@ -219,7 +219,7 @@ static void *m_start(struct seq_file *m, loff_t *pos)
> return ERR_PTR(-ESRCH);
>
> mm = priv->mm;
> - if (!mm || !atomic_inc_not_zero(&mm->mm_users))
> + if (!mm || !refcount_inc_not_zero(&mm->mm_users))
> return NULL;
>
> down_read(&mm->mmap_sem);
> diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
> index d96e2f3..a866d9a 100644
> --- a/fs/userfaultfd.c
> +++ b/fs/userfaultfd.c
> @@ -1306,7 +1306,7 @@ static struct file *userfaultfd_file_create(int flags)
> ctx->released = false;
> ctx->mm = current->mm;
> /* prevent the mm struct to be freed */
> - atomic_inc(&ctx->mm->mm_count);
> + refcount_inc(&ctx->mm->mm_count);
>
> file = anon_inode_getfile("[userfaultfd]", &userfaultfd_fops, ctx,
> O_RDWR | (flags & UFFD_SHARED_FCNTL_FLAGS));
> diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h
> index e850e76..a123fe7 100644
> --- a/include/linux/backing-dev-defs.h
> +++ b/include/linux/backing-dev-defs.h
> @@ -4,6 +4,7 @@
> #include <linux/list.h>
> #include <linux/radix-tree.h>
> #include <linux/rbtree.h>
> +#include <linux/refcount.h>
> #include <linux/spinlock.h>
> #include <linux/percpu_counter.h>
> #include <linux/percpu-refcount.h>
> @@ -50,7 +51,7 @@ enum wb_stat_item {
> */
> struct bdi_writeback_congested {
> unsigned long state; /* WB_[a]sync_congested flags */
> - atomic_t refcnt; /* nr of attached wb's and blkg */
> + refcount_t refcnt; /* nr of attached wb's and blkg */
>
> #ifdef CONFIG_CGROUP_WRITEBACK
> struct backing_dev_info *bdi; /* the associated bdi */
> diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
> index 43b93a9..0c9f5ed 100644
> --- a/include/linux/backing-dev.h
> +++ b/include/linux/backing-dev.h
> @@ -422,13 +422,13 @@ static inline bool inode_cgwb_enabled(struct inode *inode)
> static inline struct bdi_writeback_congested *
> wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
> {
> - atomic_inc(&bdi->wb_congested->refcnt);
> + refcount_inc(&bdi->wb_congested->refcnt);
> return bdi->wb_congested;
> }
>
> static inline void wb_congested_put(struct bdi_writeback_congested *congested)
> {
> - if (atomic_dec_and_test(&congested->refcnt))
> + if (refcount_dec_and_test(&congested->refcnt))
> kfree(congested);
> }
>
> diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
> index 861b467..3556adb 100644
> --- a/include/linux/cgroup-defs.h
> +++ b/include/linux/cgroup-defs.h
> @@ -13,6 +13,7 @@
> #include <linux/wait.h>
> #include <linux/mutex.h>
> #include <linux/rcupdate.h>
> +#include <linux/refcount.h>
> #include <linux/percpu-refcount.h>
> #include <linux/percpu-rwsem.h>
> #include <linux/workqueue.h>
> @@ -149,7 +150,7 @@ struct cgroup_subsys_state {
> */
> struct css_set {
> /* Reference count */
> - atomic_t refcount;
> + refcount_t refcount;
>
> /*
> * List running through all cgroup groups in the same hash
> diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
> index c83c23f..9b0d3f4 100644
> --- a/include/linux/cgroup.h
> +++ b/include/linux/cgroup.h
> @@ -22,6 +22,7 @@
> #include <linux/ns_common.h>
> #include <linux/nsproxy.h>
> #include <linux/user_namespace.h>
> +#include <linux/refcount.h>
>
> #include <linux/cgroup-defs.h>
>
> @@ -640,7 +641,7 @@ static inline void cgroup_sk_free(struct sock_cgroup_data *skcd) {}
> #endif /* CONFIG_CGROUP_DATA */
>
> struct cgroup_namespace {
> - atomic_t count;
> + refcount_t count;
> struct ns_common ns;
> struct user_namespace *user_ns;
> struct ucounts *ucounts;
> @@ -675,12 +676,12 @@ copy_cgroup_ns(unsigned long flags, struct user_namespace *user_ns,
> static inline void get_cgroup_ns(struct cgroup_namespace *ns)
> {
> if (ns)
> - atomic_inc(&ns->count);
> + refcount_inc(&ns->count);
> }
>
> static inline void put_cgroup_ns(struct cgroup_namespace *ns)
> {
> - if (ns && atomic_dec_and_test(&ns->count))
> + if (ns && refcount_dec_and_test(&ns->count))
> free_cgroup_ns(ns);
> }
>
> diff --git a/include/linux/cred.h b/include/linux/cred.h
> index f0e70a1..25fdc87 100644
> --- a/include/linux/cred.h
> +++ b/include/linux/cred.h
> @@ -17,6 +17,7 @@
> #include <linux/key.h>
> #include <linux/selinux.h>
> #include <linux/atomic.h>
> +#include <linux/refcount.h>
> #include <linux/uidgid.h>
>
> struct user_struct;
> @@ -27,7 +28,7 @@ struct inode;
> * COW Supplementary groups list
> */
> struct group_info {
> - atomic_t usage;
> + refcount_t usage;
> int ngroups;
> kgid_t gid[0];
> };
> @@ -43,7 +44,7 @@ struct group_info {
> */
> static inline struct group_info *get_group_info(struct group_info *gi)
> {
> - atomic_inc(&gi->usage);
> + refcount_inc(&gi->usage);
> return gi;
> }
>
> @@ -53,7 +54,7 @@ static inline struct group_info *get_group_info(struct group_info *gi)
> */
> #define put_group_info(group_info) \
> do { \
> - if (atomic_dec_and_test(&(group_info)->usage)) \
> + if (refcount_dec_and_test(&(group_info)->usage)) \
> groups_free(group_info); \
> } while (0)
>
> @@ -107,7 +108,7 @@ extern bool may_setgroups(void);
> * same context as task->real_cred.
> */
> struct cred {
> - atomic_t usage;
> + refcount_t usage;
> #ifdef CONFIG_DEBUG_CREDENTIALS
> atomic_t subscribers; /* number of processes subscribed */
> void *put_addr;
> @@ -220,7 +221,7 @@ static inline bool cap_ambient_invariant_ok(const struct cred *cred)
> */
> static inline struct cred *get_new_cred(struct cred *cred)
> {
> - atomic_inc(&cred->usage);
> + refcount_inc(&cred->usage);
> return cred;
> }
>
> @@ -260,7 +261,7 @@ static inline void put_cred(const struct cred *_cred)
> struct cred *cred = (struct cred *) _cred;
>
> validate_creds(cred);
> - if (atomic_dec_and_test(&(cred)->usage))
> + if (refcount_dec_and_test(&(cred)->usage))
> __put_cred(cred);
> }
>
> diff --git a/include/linux/init_task.h b/include/linux/init_task.h
> index 325f649..9b84ce6 100644
> --- a/include/linux/init_task.h
> +++ b/include/linux/init_task.h
> @@ -12,6 +12,7 @@
> #include <linux/securebits.h>
> #include <linux/seqlock.h>
> #include <linux/rbtree.h>
> +#include <linux/refcount.h>
> #include <net/net_namespace.h>
> #include <linux/sched/rt.h>
>
> @@ -65,7 +66,7 @@ extern struct fs_struct init_fs;
> extern struct nsproxy init_nsproxy;
>
> #define INIT_SIGHAND(sighand) { \
> - .count = ATOMIC_INIT(1), \
> + .count = REFCOUNT_INIT(1), \
> .action = { { { .sa_handler = SIG_DFL, } }, }, \
> .siglock = __SPIN_LOCK_UNLOCKED(sighand.siglock), \
> .signalfd_wqh = __WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh), \
> @@ -188,7 +189,7 @@ extern struct task_group root_task_group;
> #ifdef CONFIG_THREAD_INFO_IN_TASK
> # define INIT_TASK_TI(tsk) \
> .thread_info = INIT_THREAD_INFO(tsk), \
> - .stack_refcount = ATOMIC_INIT(1),
> + .stack_refcount = REFCOUNT_INIT(1),
> #else
> # define INIT_TASK_TI(tsk)
> #endif
> @@ -202,7 +203,7 @@ extern struct task_group root_task_group;
> INIT_TASK_TI(tsk) \
> .state = 0, \
> .stack = init_stack, \
> - .usage = ATOMIC_INIT(2), \
> + .usage = REFCOUNT_INIT(2), \
> .flags = PF_KTHREAD, \
> .prio = MAX_PRIO-20, \
> .static_prio = MAX_PRIO-20, \
> diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
> index 1c5190d..865ec17 100644
> --- a/include/linux/kvm_host.h
> +++ b/include/linux/kvm_host.h
> @@ -26,6 +26,7 @@
> #include <linux/context_tracking.h>
> #include <linux/irqbypass.h>
> #include <linux/swait.h>
> +#include <linux/refcount.h>
> #include <asm/signal.h>
>
> #include <linux/kvm.h>
> @@ -403,7 +404,7 @@ struct kvm {
> #endif
> struct kvm_vm_stat stat;
> struct kvm_arch arch;
> - atomic_t users_count;
> + refcount_t users_count;
> #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
> struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
> spinlock_t ring_lock;
> diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
> index 808751d..f4b048f 100644
> --- a/include/linux/mm_types.h
> +++ b/include/linux/mm_types.h
> @@ -7,6 +7,7 @@
> #include <linux/list.h>
> #include <linux/spinlock.h>
> #include <linux/rbtree.h>
> +#include <linux/refcount.h>
> #include <linux/rwsem.h>
> #include <linux/completion.h>
> #include <linux/cpumask.h>
> @@ -407,8 +408,8 @@ struct mm_struct {
> unsigned long task_size; /* size of task vm space */
> unsigned long highest_vm_end; /* highest vma end address */
> pgd_t * pgd;
> - atomic_t mm_users; /* How many users with user space? */
> - atomic_t mm_count; /* How many references to "struct mm_struct" (users count as 1) */
> + refcount_t mm_users; /* How many users with user space? */
> + refcount_t mm_count; /* How many references to "struct mm_struct" (users count as 1) */
> atomic_long_t nr_ptes; /* PTE page table pages */
> #if CONFIG_PGTABLE_LEVELS > 2
> atomic_long_t nr_pmds; /* PMD page table pages */
> diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
> index ac0d65b..f862ba8 100644
> --- a/include/linux/nsproxy.h
> +++ b/include/linux/nsproxy.h
> @@ -28,7 +28,7 @@ struct fs_struct;
> * nsproxy is copied.
> */
> struct nsproxy {
> - atomic_t count;
> + refcount_t count;
> struct uts_namespace *uts_ns;
> struct ipc_namespace *ipc_ns;
> struct mnt_namespace *mnt_ns;
> @@ -74,14 +74,14 @@ int __init nsproxy_cache_init(void);
>
> static inline void put_nsproxy(struct nsproxy *ns)
> {
> - if (atomic_dec_and_test(&ns->count)) {
> + if (refcount_dec_and_test(&ns->count)) {
> free_nsproxy(ns);
> }
> }
>
> static inline void get_nsproxy(struct nsproxy *ns)
> {
> - atomic_inc(&ns->count);
> + refcount_inc(&ns->count);
> }
>
> #endif
> diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
> index 4741ecd..321a332 100644
> --- a/include/linux/perf_event.h
> +++ b/include/linux/perf_event.h
> @@ -54,6 +54,7 @@ struct perf_guest_info_callbacks {
> #include <linux/perf_regs.h>
> #include <linux/workqueue.h>
> #include <linux/cgroup.h>
> +#include <linux/refcount.h>
> #include <asm/local.h>
>
> struct perf_callchain_entry {
> @@ -741,7 +742,7 @@ struct perf_event_context {
> int nr_stat;
> int nr_freq;
> int rotate_disable;
> - atomic_t refcount;
> + refcount_t refcount;
> struct task_struct *task;
>
> /*
> diff --git a/include/linux/rmap.h b/include/linux/rmap.h
> index 15321fb..8c8f896 100644
> --- a/include/linux/rmap.h
> +++ b/include/linux/rmap.h
> @@ -9,6 +9,7 @@
> #include <linux/mm.h>
> #include <linux/rwsem.h>
> #include <linux/memcontrol.h>
> +#include <linux/refcount.h>
>
> /*
> * The anon_vma heads a list of private "related" vmas, to scan if
> @@ -34,7 +35,7 @@ struct anon_vma {
> * the reference is responsible for clearing up the
> * anon_vma if they are the last user on release
> */
> - atomic_t refcount;
> + refcount_t refcount;
>
> /*
> * Count of child anon_vmas and VMAs which points to this anon_vma.
> @@ -101,14 +102,14 @@ enum ttu_flags {
> #ifdef CONFIG_MMU
> static inline void get_anon_vma(struct anon_vma *anon_vma)
> {
> - atomic_inc(&anon_vma->refcount);
> + refcount_inc(&anon_vma->refcount);
> }
>
> void __put_anon_vma(struct anon_vma *anon_vma);
>
> static inline void put_anon_vma(struct anon_vma *anon_vma)
> {
> - if (atomic_dec_and_test(&anon_vma->refcount))
> + if (refcount_dec_and_test(&anon_vma->refcount))
> __put_anon_vma(anon_vma);
> }
>
> diff --git a/include/linux/sched.h b/include/linux/sched.h
> index 4d19052..4d7bd87 100644
> --- a/include/linux/sched.h
> +++ b/include/linux/sched.h
> @@ -43,6 +43,7 @@ struct sched_param {
> #include <linux/seccomp.h>
> #include <linux/rcupdate.h>
> #include <linux/rculist.h>
> +#include <linux/refcount.h>
> #include <linux/rtmutex.h>
>
> #include <linux/time.h>
> @@ -555,7 +556,7 @@ static inline int get_dumpable(struct mm_struct *mm)
> #define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK)
>
> struct sighand_struct {
> - atomic_t count;
> + refcount_t count;
> struct k_sigaction action[_NSIG];
> spinlock_t siglock;
> wait_queue_head_t signalfd_wqh;
> @@ -695,7 +696,7 @@ struct autogroup;
> * the locking of signal_struct.
> */
> struct signal_struct {
> - atomic_t sigcnt;
> + refcount_t sigcnt;
> atomic_t live;
> int nr_threads;
> struct list_head thread_head;
> @@ -865,7 +866,7 @@ static inline int signal_group_exit(const struct signal_struct *sig)
> * Some day this will be a full-fledged user tracking system..
> */
> struct user_struct {
> - atomic_t __count; /* reference count */
> + refcount_t __count; /* reference count */
> atomic_t processes; /* How many processes does this user have? */
> atomic_t sigpending; /* How many pending signals does this user have? */
> #ifdef CONFIG_INOTIFY_USER
> @@ -1508,7 +1509,7 @@ struct task_struct {
> #endif
> volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
> void *stack;
> - atomic_t usage;
> + refcount_t usage;
> unsigned int flags; /* per process flags, defined below */
> unsigned int ptrace;
>
> @@ -1986,7 +1987,7 @@ struct task_struct {
> #endif
> #ifdef CONFIG_THREAD_INFO_IN_TASK
> /* A live task holds one reference. */
> - atomic_t stack_refcount;
> + refcount_t stack_refcount;
> #endif
> /* CPU-specific state of this task */
> struct thread_struct thread;
> @@ -2237,13 +2238,13 @@ static inline int is_global_init(struct task_struct *tsk)
> extern struct pid *cad_pid;
>
> extern void free_task(struct task_struct *tsk);
> -#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
> +#define get_task_struct(tsk) do { refcount_inc(&(tsk)->usage); } while(0)
>
> extern void __put_task_struct(struct task_struct *t);
>
> static inline void put_task_struct(struct task_struct *t)
> {
> - if (atomic_dec_and_test(&t->usage))
> + if (refcount_dec_and_test(&t->usage))
> __put_task_struct(t);
> }
>
> @@ -2703,7 +2704,7 @@ extern struct task_struct *find_task_by_pid_ns(pid_t nr,
> extern struct user_struct * alloc_uid(kuid_t);
> static inline struct user_struct *get_uid(struct user_struct *u)
> {
> - atomic_inc(&u->__count);
> + refcount_inc(&u->__count);
> return u;
> }
> extern void free_uid(struct user_struct *);
> @@ -2918,7 +2919,7 @@ extern struct mm_struct * mm_alloc(void);
> extern void __mmdrop(struct mm_struct *);
> static inline void mmdrop(struct mm_struct *mm)
> {
> - if (unlikely(atomic_dec_and_test(&mm->mm_count)))
> + if (unlikely(refcount_dec_and_test(&mm->mm_count)))
> __mmdrop(mm);
> }
>
> @@ -2930,7 +2931,7 @@ static inline void mmdrop_async_fn(struct work_struct *work)
>
> static inline void mmdrop_async(struct mm_struct *mm)
> {
> - if (unlikely(atomic_dec_and_test(&mm->mm_count))) {
> + if (unlikely(refcount_dec_and_test(&mm->mm_count))) {
> INIT_WORK(&mm->async_put_work, mmdrop_async_fn);
> schedule_work(&mm->async_put_work);
> }
> @@ -2938,7 +2939,7 @@ static inline void mmdrop_async(struct mm_struct *mm)
>
> static inline bool mmget_not_zero(struct mm_struct *mm)
> {
> - return atomic_inc_not_zero(&mm->mm_users);
> + return refcount_inc_not_zero(&mm->mm_users);
> }
>
> /* mmput gets rid of the mappings and all user-space */
> @@ -3223,7 +3224,7 @@ static inline unsigned long *end_of_stack(struct task_struct *p)
> #ifdef CONFIG_THREAD_INFO_IN_TASK
> static inline void *try_get_task_stack(struct task_struct *tsk)
> {
> - return atomic_inc_not_zero(&tsk->stack_refcount) ?
> + return refcount_inc_not_zero(&tsk->stack_refcount) ?
> task_stack_page(tsk) : NULL;
> }
>
> diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
> index 8b1dde9..8a7533b 100644
> --- a/kernel/audit_tree.c
> +++ b/kernel/audit_tree.c
> @@ -9,7 +9,7 @@ struct audit_tree;
> struct audit_chunk;
>
> struct audit_tree {
> - atomic_t count;
> + refcount_t count;
> int goner;
> struct audit_chunk *root;
> struct list_head chunks;
> @@ -77,7 +77,7 @@ static struct audit_tree *alloc_tree(const char *s)
>
> tree = kmalloc(sizeof(struct audit_tree) + strlen(s) + 1, GFP_KERNEL);
> if (tree) {
> - atomic_set(&tree->count, 1);
> + refcount_set(&tree->count, 1);
> tree->goner = 0;
> INIT_LIST_HEAD(&tree->chunks);
> INIT_LIST_HEAD(&tree->rules);
> @@ -91,12 +91,12 @@ static struct audit_tree *alloc_tree(const char *s)
>
> static inline void get_tree(struct audit_tree *tree)
> {
> - atomic_inc(&tree->count);
> + refcount_inc(&tree->count);
> }
>
> static inline void put_tree(struct audit_tree *tree)
> {
> - if (atomic_dec_and_test(&tree->count))
> + if (refcount_dec_and_test(&tree->count))
> kfree_rcu(tree, head);
> }
>
> @@ -963,7 +963,7 @@ static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotify
> * We are guaranteed to have at least one reference to the mark from
> * either the inode or the caller of fsnotify_destroy_mark().
> */
> - BUG_ON(atomic_read(&entry->refcnt) < 1);
> + BUG_ON(refcount_read(&entry->refcnt) < 1);
> }
>
> static const struct fsnotify_ops audit_tree_ops = {
> diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
> index f79e465..8ca9e6c 100644
> --- a/kernel/audit_watch.c
> +++ b/kernel/audit_watch.c
> @@ -46,7 +46,7 @@
> */
>
> struct audit_watch {
> - atomic_t count; /* reference count */
> + refcount_t count; /* reference count */
> dev_t dev; /* associated superblock device */
> char *path; /* insertion path */
> unsigned long ino; /* associated inode number */
> @@ -111,12 +111,12 @@ static inline struct audit_parent *audit_find_parent(struct inode *inode)
>
> void audit_get_watch(struct audit_watch *watch)
> {
> - atomic_inc(&watch->count);
> + refcount_inc(&watch->count);
> }
>
> void audit_put_watch(struct audit_watch *watch)
> {
> - if (atomic_dec_and_test(&watch->count)) {
> + if (refcount_dec_and_test(&watch->count)) {
> WARN_ON(watch->parent);
> WARN_ON(!list_empty(&watch->rules));
> kfree(watch->path);
> @@ -178,7 +178,7 @@ static struct audit_watch *audit_init_watch(char *path)
> return ERR_PTR(-ENOMEM);
>
> INIT_LIST_HEAD(&watch->rules);
> - atomic_set(&watch->count, 1);
> + refcount_set(&watch->count, 1);
> watch->path = path;
> watch->dev = AUDIT_DEV_UNSET;
> watch->ino = AUDIT_INO_UNSET;
> diff --git a/kernel/cgroup.c b/kernel/cgroup.c
> index 2ee9ec3..bfed258 100644
> --- a/kernel/cgroup.c
> +++ b/kernel/cgroup.c
> @@ -223,7 +223,7 @@ static u16 have_free_callback __read_mostly;
>
> /* cgroup namespace for init task */
> struct cgroup_namespace init_cgroup_ns = {
> - .count = { .counter = 2, },
> + .count = REFCOUNT_INIT(2),
> .user_ns = &init_user_ns,
> .ns.ops = &cgroupns_operations,
> .ns.inum = PROC_CGROUP_INIT_INO,
> @@ -646,7 +646,7 @@ struct cgrp_cset_link {
> * haven't been created.
> */
> struct css_set init_css_set = {
> - .refcount = ATOMIC_INIT(1),
> + .refcount = REFCOUNT_INIT(1),
> .cgrp_links = LIST_HEAD_INIT(init_css_set.cgrp_links),
> .tasks = LIST_HEAD_INIT(init_css_set.tasks),
> .mg_tasks = LIST_HEAD_INIT(init_css_set.mg_tasks),
> @@ -816,7 +816,7 @@ static void put_css_set_locked(struct css_set *cset)
>
> lockdep_assert_held(&css_set_lock);
>
> - if (!atomic_dec_and_test(&cset->refcount))
> + if (!refcount_dec_and_test(&cset->refcount))
> return;
>
> /* This css_set is dead. unlink it and release cgroup and css refs */
> @@ -847,10 +847,13 @@ static void put_css_set(struct css_set *cset)
> * can see it. Similar to atomic_dec_and_lock(), but for an
> * rwlock
> */
> - if (atomic_add_unless(&cset->refcount, -1, 1))
> + spin_lock_irqsave(&css_set_lock, flags);
> + if (refcount_read(&cset->refcount) != 1) {
> + WARN_ON(refcount_dec_and_test(&cset->refcount));
> + spin_unlock_irqrestore(&css_set_lock, flags);
> return;
> + }
>
> - spin_lock_irqsave(&css_set_lock, flags);
> put_css_set_locked(cset);
> spin_unlock_irqrestore(&css_set_lock, flags);
> }
> @@ -860,7 +863,7 @@ static void put_css_set(struct css_set *cset)
> */
> static inline void get_css_set(struct css_set *cset)
> {
> - atomic_inc(&cset->refcount);
> + refcount_inc(&cset->refcount);
> }
>
> /**
> @@ -1094,7 +1097,7 @@ static struct css_set *find_css_set(struct css_set *old_cset,
> return NULL;
> }
>
> - atomic_set(&cset->refcount, 1);
> + refcount_set(&cset->refcount, 1);
> INIT_LIST_HEAD(&cset->cgrp_links);
> INIT_LIST_HEAD(&cset->tasks);
> INIT_LIST_HEAD(&cset->mg_tasks);
> @@ -3940,7 +3943,7 @@ static int cgroup_task_count(const struct cgroup *cgrp)
>
> spin_lock_irq(&css_set_lock);
> list_for_each_entry(link, &cgrp->cset_links, cset_link)
> - count += atomic_read(&link->cset->refcount);
> + count += refcount_read(&link->cset->refcount);
> spin_unlock_irq(&css_set_lock);
> return count;
> }
> @@ -6377,7 +6380,7 @@ static struct cgroup_namespace *alloc_cgroup_ns(void)
> kfree(new_ns);
> return ERR_PTR(ret);
> }
> - atomic_set(&new_ns->count, 1);
> + refcount_set(&new_ns->count, 1);
> new_ns->ns.ops = &cgroupns_operations;
> return new_ns;
> }
> @@ -6548,7 +6551,7 @@ static u64 current_css_set_refcount_read(struct cgroup_subsys_state *css,
> u64 count;
>
> rcu_read_lock();
> - count = atomic_read(&task_css_set(current)->refcount);
> + count = refcount_read(&task_css_set(current)->refcount);
> rcu_read_unlock();
> return count;
> }
> diff --git a/kernel/cred.c b/kernel/cred.c
> index 5f264fb..31ebce0 100644
> --- a/kernel/cred.c
> +++ b/kernel/cred.c
> @@ -35,13 +35,13 @@ do { \
> static struct kmem_cache *cred_jar;
>
> /* init to 2 - one for init_task, one to ensure it is never freed */
> -struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
> +struct group_info init_groups = { .usage = REFCOUNT_INIT(2) };
>
> /*
> * The initial credentials for the initial task
> */
> struct cred init_cred = {
> - .usage = ATOMIC_INIT(4),
> + .usage = REFCOUNT_INIT(4),
> #ifdef CONFIG_DEBUG_CREDENTIALS
> .subscribers = ATOMIC_INIT(2),
> .magic = CRED_MAGIC,
> @@ -100,17 +100,17 @@ static void put_cred_rcu(struct rcu_head *rcu)
>
> #ifdef CONFIG_DEBUG_CREDENTIALS
> if (cred->magic != CRED_MAGIC_DEAD ||
> - atomic_read(&cred->usage) != 0 ||
> + refcount_read(&cred->usage) != 0 ||
> read_cred_subscribers(cred) != 0)
> panic("CRED: put_cred_rcu() sees %p with"
> " mag %x, put %p, usage %d, subscr %d\n",
> cred, cred->magic, cred->put_addr,
> - atomic_read(&cred->usage),
> + refcount_read(&cred->usage),
> read_cred_subscribers(cred));
> #else
> - if (atomic_read(&cred->usage) != 0)
> + if (refcount_read(&cred->usage) != 0)
> panic("CRED: put_cred_rcu() sees %p with usage %d\n",
> - cred, atomic_read(&cred->usage));
> + cred, refcount_read(&cred->usage));
> #endif
>
> security_cred_free(cred);
> @@ -134,10 +134,10 @@ static void put_cred_rcu(struct rcu_head *rcu)
> void __put_cred(struct cred *cred)
> {
> kdebug("__put_cred(%p{%d,%d})", cred,
> - atomic_read(&cred->usage),
> + refcount_read(&cred->usage),
> read_cred_subscribers(cred));
>
> - BUG_ON(atomic_read(&cred->usage) != 0);
> + BUG_ON(refcount_read(&cred->usage) != 0);
> #ifdef CONFIG_DEBUG_CREDENTIALS
> BUG_ON(read_cred_subscribers(cred) != 0);
> cred->magic = CRED_MAGIC_DEAD;
> @@ -158,7 +158,7 @@ void exit_creds(struct task_struct *tsk)
> struct cred *cred;
>
> kdebug("exit_creds(%u,%p,%p,{%d,%d})", tsk->pid, tsk->real_cred, tsk->cred,
> - atomic_read(&tsk->cred->usage),
> + refcount_read(&tsk->cred->usage),
> read_cred_subscribers(tsk->cred));
>
> cred = (struct cred *) tsk->real_cred;
> @@ -193,7 +193,7 @@ const struct cred *get_task_cred(struct task_struct *task)
> do {
> cred = __task_cred((task));
> BUG_ON(!cred);
> - } while (!atomic_inc_not_zero(&((struct cred *)cred)->usage));
> + } while (!refcount_inc_not_zero(&((struct cred *)cred)->usage));
>
> rcu_read_unlock();
> return cred;
> @@ -211,7 +211,7 @@ struct cred *cred_alloc_blank(void)
> if (!new)
> return NULL;
>
> - atomic_set(&new->usage, 1);
> + refcount_set(&new->usage, 1);
> #ifdef CONFIG_DEBUG_CREDENTIALS
> new->magic = CRED_MAGIC;
> #endif
> @@ -257,7 +257,7 @@ struct cred *prepare_creds(void)
> old = task->cred;
> memcpy(new, old, sizeof(struct cred));
>
> - atomic_set(&new->usage, 1);
> + refcount_set(&new->usage, 1);
> set_cred_subscribers(new, 0);
> get_group_info(new->group_info);
> get_uid(new->user);
> @@ -334,7 +334,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)
> get_cred(p->cred);
> alter_cred_subscribers(p->cred, 2);
> kdebug("share_creds(%p{%d,%d})",
> - p->cred, atomic_read(&p->cred->usage),
> + p->cred, refcount_read(&p->cred->usage),
> read_cred_subscribers(p->cred));
> atomic_inc(&p->cred->user->processes);
> return 0;
> @@ -425,7 +425,7 @@ int commit_creds(struct cred *new)
> const struct cred *old = task->real_cred;
>
> kdebug("commit_creds(%p{%d,%d})", new,
> - atomic_read(&new->usage),
> + refcount_read(&new->usage),
> read_cred_subscribers(new));
>
> BUG_ON(task->cred != old);
> @@ -434,7 +434,7 @@ int commit_creds(struct cred *new)
> validate_creds(old);
> validate_creds(new);
> #endif
> - BUG_ON(atomic_read(&new->usage) < 1);
> + BUG_ON(refcount_read(&new->usage) < 1);
>
> get_cred(new); /* we will require a ref for the subj creds too */
>
> @@ -499,13 +499,13 @@ EXPORT_SYMBOL(commit_creds);
> void abort_creds(struct cred *new)
> {
> kdebug("abort_creds(%p{%d,%d})", new,
> - atomic_read(&new->usage),
> + refcount_read(&new->usage),
> read_cred_subscribers(new));
>
> #ifdef CONFIG_DEBUG_CREDENTIALS
> BUG_ON(read_cred_subscribers(new) != 0);
> #endif
> - BUG_ON(atomic_read(&new->usage) < 1);
> + BUG_ON(refcount_read(&new->usage) < 1);
> put_cred(new);
> }
> EXPORT_SYMBOL(abort_creds);
> @@ -522,7 +522,7 @@ const struct cred *override_creds(const struct cred *new)
> const struct cred *old = current->cred;
>
> kdebug("override_creds(%p{%d,%d})", new,
> - atomic_read(&new->usage),
> + refcount_read(&new->usage),
> read_cred_subscribers(new));
>
> validate_creds(old);
> @@ -533,7 +533,7 @@ const struct cred *override_creds(const struct cred *new)
> alter_cred_subscribers(old, -1);
>
> kdebug("override_creds() = %p{%d,%d}", old,
> - atomic_read(&old->usage),
> + refcount_read(&old->usage),
> read_cred_subscribers(old));
> return old;
> }
> @@ -551,7 +551,7 @@ void revert_creds(const struct cred *old)
> const struct cred *override = current->cred;
>
> kdebug("revert_creds(%p{%d,%d})", old,
> - atomic_read(&old->usage),
> + refcount_read(&old->usage),
> read_cred_subscribers(old));
>
> validate_creds(old);
> @@ -610,7 +610,7 @@ struct cred *prepare_kernel_cred(struct task_struct *daemon)
> validate_creds(old);
>
> *new = *old;
> - atomic_set(&new->usage, 1);
> + refcount_set(&new->usage, 1);
> set_cred_subscribers(new, 0);
> get_uid(new->user);
> get_user_ns(new->user_ns);
> @@ -734,7 +734,7 @@ static void dump_invalid_creds(const struct cred *cred, const char *label,
> printk(KERN_ERR "CRED: ->magic=%x, put_addr=%p\n",
> cred->magic, cred->put_addr);
> printk(KERN_ERR "CRED: ->usage=%d, subscr=%d\n",
> - atomic_read(&cred->usage),
> + refcount_read(&cred->usage),
> read_cred_subscribers(cred));
> printk(KERN_ERR "CRED: ->*uid = { %d,%d,%d,%d }\n",
> from_kuid_munged(&init_user_ns, cred->uid),
> @@ -808,7 +808,7 @@ void validate_creds_for_do_exit(struct task_struct *tsk)
> {
> kdebug("validate_creds_for_do_exit(%p,%p{%d,%d})",
> tsk->real_cred, tsk->cred,
> - atomic_read(&tsk->cred->usage),
> + refcount_read(&tsk->cred->usage),
> read_cred_subscribers(tsk->cred));
>
> __validate_process_creds(tsk, __FILE__, __LINE__);
> diff --git a/kernel/events/core.c b/kernel/events/core.c
> index ab15509..8c03c27 100644
> --- a/kernel/events/core.c
> +++ b/kernel/events/core.c
> @@ -1117,7 +1117,7 @@ static void perf_event_ctx_deactivate(struct perf_event_context *ctx)
>
> static void get_ctx(struct perf_event_context *ctx)
> {
> - WARN_ON(!atomic_inc_not_zero(&ctx->refcount));
> + WARN_ON(!refcount_inc_not_zero(&ctx->refcount));
> }
>
> static void free_ctx(struct rcu_head *head)
> @@ -1131,7 +1131,7 @@ static void free_ctx(struct rcu_head *head)
>
> static void put_ctx(struct perf_event_context *ctx)
> {
> - if (atomic_dec_and_test(&ctx->refcount)) {
> + if (refcount_dec_and_test(&ctx->refcount)) {
> if (ctx->parent_ctx)
> put_ctx(ctx->parent_ctx);
> if (ctx->task && ctx->task != TASK_TOMBSTONE)
> @@ -1209,7 +1209,7 @@ perf_event_ctx_lock_nested(struct perf_event *event, int nesting)
> again:
> rcu_read_lock();
> ctx = ACCESS_ONCE(event->ctx);
> - if (!atomic_inc_not_zero(&ctx->refcount)) {
> + if (!refcount_inc_not_zero(&ctx->refcount)) {
> rcu_read_unlock();
> goto again;
> }
> @@ -1337,7 +1337,7 @@ perf_lock_task_context(struct task_struct *task, int ctxn, unsigned long *flags)
> }
>
> if (ctx->task == TASK_TOMBSTONE ||
> - !atomic_inc_not_zero(&ctx->refcount)) {
> + !refcount_inc_not_zero(&ctx->refcount)) {
> raw_spin_unlock(&ctx->lock);
> ctx = NULL;
> } else {
> @@ -3639,7 +3639,7 @@ static void __perf_event_init_context(struct perf_event_context *ctx)
> INIT_LIST_HEAD(&ctx->pinned_groups);
> INIT_LIST_HEAD(&ctx->flexible_groups);
> INIT_LIST_HEAD(&ctx->event_list);
> - atomic_set(&ctx->refcount, 1);
> + refcount_set(&ctx->refcount, 1);
> }
>
> static struct perf_event_context *
> @@ -4934,7 +4934,7 @@ struct ring_buffer *ring_buffer_get(struct perf_event *event)
> rcu_read_lock();
> rb = rcu_dereference(event->rb);
> if (rb) {
> - if (!atomic_inc_not_zero(&rb->refcount))
> + if (!refcount_inc_not_zero(&rb->refcount))
> rb = NULL;
> }
> rcu_read_unlock();
> @@ -4944,7 +4944,7 @@ struct ring_buffer *ring_buffer_get(struct perf_event *event)
>
> void ring_buffer_put(struct ring_buffer *rb)
> {
> - if (!atomic_dec_and_test(&rb->refcount))
> + if (!refcount_dec_and_test(&rb->refcount))
> return;
>
> WARN_ON_ONCE(!list_empty(&rb->event_list));
> @@ -5009,7 +5009,7 @@ static void perf_mmap_close(struct vm_area_struct *vma)
>
> /* this has to be the last one */
> rb_free_aux(rb);
> - WARN_ON_ONCE(atomic_read(&rb->aux_refcount));
> + WARN_ON_ONCE(refcount_read(&rb->aux_refcount));
>
> mutex_unlock(&event->mmap_mutex);
> }
> diff --git a/kernel/events/internal.h b/kernel/events/internal.h
> index 486fd78..b36d917 100644
> --- a/kernel/events/internal.h
> +++ b/kernel/events/internal.h
> @@ -2,6 +2,7 @@
> #define _KERNEL_EVENTS_INTERNAL_H
>
> #include <linux/hardirq.h>
> +#include <linux/refcount.h>
> #include <linux/uaccess.h>
>
> /* Buffer handling */
> @@ -9,7 +10,7 @@
> #define RING_BUFFER_WRITABLE 0x01
>
> struct ring_buffer {
> - atomic_t refcount;
> + refcount_t refcount;
> struct rcu_head rcu_head;
> #ifdef CONFIG_PERF_USE_VMALLOC
> struct work_struct work;
> @@ -47,7 +48,7 @@ struct ring_buffer {
> atomic_t aux_mmap_count;
> unsigned long aux_mmap_locked;
> void (*free_aux)(void *);
> - atomic_t aux_refcount;
> + refcount_t aux_refcount;
> void **aux_pages;
> void *aux_priv;
>
> diff --git a/kernel/events/ring_buffer.c b/kernel/events/ring_buffer.c
> index 257fa46..c501d4e 100644
> --- a/kernel/events/ring_buffer.c
> +++ b/kernel/events/ring_buffer.c
> @@ -284,7 +284,7 @@ ring_buffer_init(struct ring_buffer *rb, long watermark, int flags)
> else
> rb->overwrite = 1;
>
> - atomic_set(&rb->refcount, 1);
> + refcount_set(&rb->refcount, 1);
>
> INIT_LIST_HEAD(&rb->event_list);
> spin_lock_init(&rb->event_lock);
> @@ -344,7 +344,7 @@ void *perf_aux_output_begin(struct perf_output_handle *handle,
> if (!atomic_read(&rb->aux_mmap_count))
> goto err;
>
> - if (!atomic_inc_not_zero(&rb->aux_refcount))
> + if (!refcount_inc_not_zero(&rb->aux_refcount))
> goto err;
>
> /*
> @@ -636,7 +636,7 @@ int rb_alloc_aux(struct ring_buffer *rb, struct perf_event *event,
> * we keep a refcount here to make sure either of the two can
> * reference them safely.
> */
> - atomic_set(&rb->aux_refcount, 1);
> + refcount_set(&rb->aux_refcount, 1);
>
> rb->aux_overwrite = overwrite;
> rb->aux_watermark = watermark;
> @@ -655,7 +655,7 @@ int rb_alloc_aux(struct ring_buffer *rb, struct perf_event *event,
>
> void rb_free_aux(struct ring_buffer *rb)
> {
> - if (atomic_dec_and_test(&rb->aux_refcount))
> + if (refcount_dec_and_test(&rb->aux_refcount))
> __rb_free_aux(rb);
> }
>
> diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
> index 215871b..afbb09f 100644
> --- a/kernel/events/uprobes.c
> +++ b/kernel/events/uprobes.c
> @@ -37,6 +37,7 @@
> #include <linux/percpu-rwsem.h>
> #include <linux/task_work.h>
> #include <linux/shmem_fs.h>
> +#include <linux/refcount.h>
>
> #include <linux/uprobes.h>
>
> @@ -64,7 +65,7 @@ static struct percpu_rw_semaphore dup_mmap_sem;
>
> struct uprobe {
> struct rb_node rb_node; /* node in the rb tree */
> - atomic_t ref;
> + refcount_t ref;
> struct rw_semaphore register_rwsem;
> struct rw_semaphore consumer_rwsem;
> struct list_head pending_list;
> @@ -363,13 +364,13 @@ set_orig_insn(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long v
>
> static struct uprobe *get_uprobe(struct uprobe *uprobe)
> {
> - atomic_inc(&uprobe->ref);
> + refcount_inc(&uprobe->ref);
> return uprobe;
> }
>
> static void put_uprobe(struct uprobe *uprobe)
> {
> - if (atomic_dec_and_test(&uprobe->ref))
> + if (refcount_dec_and_test(&uprobe->ref))
> kfree(uprobe);
> }
>
> @@ -451,7 +452,7 @@ static struct uprobe *__insert_uprobe(struct uprobe *uprobe)
> rb_link_node(&uprobe->rb_node, parent, p);
> rb_insert_color(&uprobe->rb_node, &uprobes_tree);
> /* get access + creation ref */
> - atomic_set(&uprobe->ref, 2);
> + refcount_set(&uprobe->ref, 2);
>
> return u;
> }
> @@ -741,7 +742,7 @@ build_map_info(struct address_space *mapping, loff_t offset, bool is_register)
> continue;
> }
>
> - if (!atomic_inc_not_zero(&vma->vm_mm->mm_users))
> + if (!refcount_inc_not_zero(&vma->vm_mm->mm_users))
> continue;
>
> info = prev;
> @@ -1115,7 +1116,7 @@ void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned lon
> if (no_uprobe_events() || !valid_vma(vma, false))
> return;
>
> - if (!atomic_read(&vma->vm_mm->mm_users)) /* called by mmput() ? */
> + if (!refcount_read(&vma->vm_mm->mm_users)) /* called by mmput() ? */
> return;
>
> if (!test_bit(MMF_HAS_UPROBES, &vma->vm_mm->flags) ||
> diff --git a/kernel/exit.c b/kernel/exit.c
> index aacff8e..9a646e8 100644
> --- a/kernel/exit.c
> +++ b/kernel/exit.c
> @@ -396,7 +396,7 @@ void mm_update_next_owner(struct mm_struct *mm)
> * candidates. Do not leave the mm pointing to a possibly
> * freed task structure.
> */
> - if (atomic_read(&mm->mm_users) <= 1) {
> + if (refcount_read(&mm->mm_users) <= 1) {
> mm->owner = NULL;
> return;
> }
> @@ -509,7 +509,7 @@ static void exit_mm(struct task_struct *tsk)
> __set_task_state(tsk, TASK_RUNNING);
> down_read(&mm->mmap_sem);
> }
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> BUG_ON(mm != tsk->active_mm);
> /* more a memory barrier than a real lock */
> task_lock(tsk);
> diff --git a/kernel/fork.c b/kernel/fork.c
> index 869b8cc..3e001e2 100644
> --- a/kernel/fork.c
> +++ b/kernel/fork.c
> @@ -330,7 +330,7 @@ static void release_task_stack(struct task_struct *tsk)
> #ifdef CONFIG_THREAD_INFO_IN_TASK
> void put_task_stack(struct task_struct *tsk)
> {
> - if (atomic_dec_and_test(&tsk->stack_refcount))
> + if (refcount_dec_and_test(&tsk->stack_refcount))
> release_task_stack(tsk);
> }
> #endif
> @@ -348,7 +348,7 @@ void free_task(struct task_struct *tsk)
> * If the task had a separate stack allocation, it should be gone
> * by now.
> */
> - WARN_ON_ONCE(atomic_read(&tsk->stack_refcount) != 0);
> + WARN_ON_ONCE(refcount_read(&tsk->stack_refcount) != 0);
> #endif
> rt_mutex_debug_task_free(tsk);
> ftrace_graph_exit_task(tsk);
> @@ -375,14 +375,14 @@ static inline void free_signal_struct(struct signal_struct *sig)
>
> static inline void put_signal_struct(struct signal_struct *sig)
> {
> - if (atomic_dec_and_test(&sig->sigcnt))
> + if (refcount_dec_and_test(&sig->sigcnt))
> free_signal_struct(sig);
> }
>
> void __put_task_struct(struct task_struct *tsk)
> {
> WARN_ON(!tsk->exit_state);
> - WARN_ON(atomic_read(&tsk->usage));
> + WARN_ON(refcount_read(&tsk->usage));
> WARN_ON(tsk == current);
>
> cgroup_free(tsk);
> @@ -501,7 +501,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
> tsk->stack_vm_area = stack_vm_area;
> #endif
> #ifdef CONFIG_THREAD_INFO_IN_TASK
> - atomic_set(&tsk->stack_refcount, 1);
> + refcount_set(&tsk->stack_refcount, 1);
> #endif
>
> if (err)
> @@ -530,7 +530,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
> * One for us, one for whoever does the "release_task()" (usually
> * parent)
> */
> - atomic_set(&tsk->usage, 2);
> + refcount_set(&tsk->usage, 2);
> #ifdef CONFIG_BLK_DEV_IO_TRACE
> tsk->btrace_seq = 0;
> #endif
> @@ -753,8 +753,8 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,
> mm->mmap = NULL;
> mm->mm_rb = RB_ROOT;
> mm->vmacache_seqnum = 0;
> - atomic_set(&mm->mm_users, 1);
> - atomic_set(&mm->mm_count, 1);
> + refcount_set(&mm->mm_users, 1);
> + refcount_set(&mm->mm_count, 1);
> init_rwsem(&mm->mmap_sem);
> INIT_LIST_HEAD(&mm->mmlist);
> mm->core_state = NULL;
> @@ -856,7 +856,7 @@ EXPORT_SYMBOL_GPL(__mmdrop);
>
> static inline void __mmput(struct mm_struct *mm)
> {
> - VM_BUG_ON(atomic_read(&mm->mm_users));
> + VM_BUG_ON(refcount_read(&mm->mm_users));
>
> uprobe_clear_state(mm);
> exit_aio(mm);
> @@ -883,7 +883,7 @@ void mmput(struct mm_struct *mm)
> {
> might_sleep();
>
> - if (atomic_dec_and_test(&mm->mm_users))
> + if (refcount_dec_and_test(&mm->mm_users))
> __mmput(mm);
> }
> EXPORT_SYMBOL_GPL(mmput);
> @@ -897,7 +897,7 @@ static void mmput_async_fn(struct work_struct *work)
>
> void mmput_async(struct mm_struct *mm)
> {
> - if (atomic_dec_and_test(&mm->mm_users)) {
> + if (refcount_dec_and_test(&mm->mm_users)) {
> INIT_WORK(&mm->async_put_work, mmput_async_fn);
> schedule_work(&mm->async_put_work);
> }
> @@ -994,7 +994,7 @@ struct mm_struct *get_task_mm(struct task_struct *task)
> if (task->flags & PF_KTHREAD)
> mm = NULL;
> else
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> }
> task_unlock(task);
> return mm;
> @@ -1096,7 +1096,7 @@ void mm_release(struct task_struct *tsk, struct mm_struct *mm)
> */
> if (tsk->clear_child_tid) {
> if (!(tsk->signal->flags & SIGNAL_GROUP_COREDUMP) &&
> - atomic_read(&mm->mm_users) > 1) {
> + refcount_read(&mm->mm_users) > 1) {
> /*
> * We don't check the error code - if userspace has
> * not set up a proper pointer then tough luck.
> @@ -1182,7 +1182,7 @@ static int copy_mm(unsigned long clone_flags, struct task_struct *tsk)
> vmacache_flush(tsk);
>
> if (clone_flags & CLONE_VM) {
> - atomic_inc(&oldmm->mm_users);
> + refcount_inc(&oldmm->mm_users);
> mm = oldmm;
> goto good_mm;
> }
> @@ -1279,7 +1279,7 @@ static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
> struct sighand_struct *sig;
>
> if (clone_flags & CLONE_SIGHAND) {
> - atomic_inc(¤t->sighand->count);
> + refcount_inc(¤t->sighand->count);
> return 0;
> }
> sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
> @@ -1287,14 +1287,14 @@ static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
> if (!sig)
> return -ENOMEM;
>
> - atomic_set(&sig->count, 1);
> + refcount_set(&sig->count, 1);
> memcpy(sig->action, current->sighand->action, sizeof(sig->action));
> return 0;
> }
>
> void __cleanup_sighand(struct sighand_struct *sighand)
> {
> - if (atomic_dec_and_test(&sighand->count)) {
> + if (refcount_dec_and_test(&sighand->count)) {
> signalfd_cleanup(sighand);
> /*
> * sighand_cachep is SLAB_DESTROY_BY_RCU so we can free it
> @@ -1337,7 +1337,7 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
>
> sig->nr_threads = 1;
> atomic_set(&sig->live, 1);
> - atomic_set(&sig->sigcnt, 1);
> + refcount_set(&sig->sigcnt, 1);
>
> /* list_add(thread_node, thread_head) without INIT_LIST_HEAD() */
> sig->thread_head = (struct list_head)LIST_HEAD_INIT(tsk->thread_node);
> @@ -1808,7 +1808,7 @@ static __latent_entropy struct task_struct *copy_process(
> } else {
> current->signal->nr_threads++;
> atomic_inc(¤t->signal->live);
> - atomic_inc(¤t->signal->sigcnt);
> + refcount_inc(¤t->signal->sigcnt);
> list_add_tail_rcu(&p->thread_group,
> &p->group_leader->thread_group);
> list_add_tail_rcu(&p->thread_node,
> @@ -2120,7 +2120,7 @@ static int check_unshare_flags(unsigned long unshare_flags)
> return -EINVAL;
> }
> if (unshare_flags & (CLONE_SIGHAND | CLONE_VM)) {
> - if (atomic_read(¤t->sighand->count) > 1)
> + if (refcount_read(¤t->sighand->count) > 1)
> return -EINVAL;
> }
> if (unshare_flags & CLONE_VM) {
> diff --git a/kernel/futex.c b/kernel/futex.c
> index 9246d9f..e794c0b 100644
> --- a/kernel/futex.c
> +++ b/kernel/futex.c
> @@ -65,6 +65,7 @@
> #include <linux/freezer.h>
> #include <linux/bootmem.h>
> #include <linux/fault-inject.h>
> +#include <linux/refcount.h>
>
> #include <asm/futex.h>
>
> @@ -207,7 +208,7 @@ struct futex_pi_state {
> struct rt_mutex pi_mutex;
>
> struct task_struct *owner;
> - atomic_t refcount;
> + refcount_t refcount;
>
> union futex_key key;
> };
> @@ -338,7 +339,7 @@ static inline bool should_fail_futex(bool fshared)
>
> static inline void futex_get_mm(union futex_key *key)
> {
> - atomic_inc(&key->private.mm->mm_count);
> + refcount_inc(&key->private.mm->mm_count);
> /*
> * Ensure futex_get_mm() implies a full barrier such that
> * get_futex_key() implies a full barrier. This is relied upon
> @@ -792,7 +793,7 @@ static int refill_pi_state_cache(void)
> INIT_LIST_HEAD(&pi_state->list);
> /* pi_mutex gets initialized later */
> pi_state->owner = NULL;
> - atomic_set(&pi_state->refcount, 1);
> + refcount_set(&pi_state->refcount, 1);
> pi_state->key = FUTEX_KEY_INIT;
>
> current->pi_state_cache = pi_state;
> @@ -821,7 +822,7 @@ static void put_pi_state(struct futex_pi_state *pi_state)
> if (!pi_state)
> return;
>
> - if (!atomic_dec_and_test(&pi_state->refcount))
> + if (!refcount_dec_and_test(&pi_state->refcount))
> return;
>
> /*
> @@ -845,7 +846,7 @@ static void put_pi_state(struct futex_pi_state *pi_state)
> * refcount is at 0 - put it back to 1.
> */
> pi_state->owner = NULL;
> - atomic_set(&pi_state->refcount, 1);
> + refcount_set(&pi_state->refcount, 1);
> current->pi_state_cache = pi_state;
> }
> }
> @@ -989,7 +990,7 @@ static int attach_to_pi_state(u32 uval, struct futex_pi_state *pi_state,
> if (unlikely(!pi_state))
> return -EINVAL;
>
> - WARN_ON(!atomic_read(&pi_state->refcount));
> + WARN_ON(!refcount_read(&pi_state->refcount));
>
> /*
> * Handle the owner died case:
> @@ -1040,7 +1041,7 @@ static int attach_to_pi_state(u32 uval, struct futex_pi_state *pi_state,
> if (pid != task_pid_vnr(pi_state->owner))
> return -EINVAL;
> out_state:
> - atomic_inc(&pi_state->refcount);
> + refcount_inc(&pi_state->refcount);
> *ps = pi_state;
> return 0;
> }
> @@ -1907,7 +1908,7 @@ static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
> * refcount on the pi_state and store the pointer in
> * the futex_q object of the waiter.
> */
> - atomic_inc(&pi_state->refcount);
> + refcount_inc(&pi_state->refcount);
> this->pi_state = pi_state;
> ret = rt_mutex_start_proxy_lock(&pi_state->pi_mutex,
> this->rt_waiter,
> diff --git a/kernel/groups.c b/kernel/groups.c
> index 2fcadd6..89ad6c6 100644
> --- a/kernel/groups.c
> +++ b/kernel/groups.c
> @@ -22,7 +22,7 @@ struct group_info *groups_alloc(int gidsetsize)
> if (!gi)
> return NULL;
>
> - atomic_set(&gi->usage, 1);
> + refcount_set(&gi->usage, 1);
> gi->ngroups = gidsetsize;
> return gi;
> }
> diff --git a/kernel/kcov.c b/kernel/kcov.c
> index 85e5546..b8506c3 100644
> --- a/kernel/kcov.c
> +++ b/kernel/kcov.c
> @@ -19,6 +19,7 @@
> #include <linux/debugfs.h>
> #include <linux/uaccess.h>
> #include <linux/kcov.h>
> +#include <linux/refcount.h>
> #include <asm/setup.h>
>
> /*
> @@ -35,7 +36,7 @@ struct kcov {
> * - opened file descriptor
> * - task with enabled coverage (we can't unwire it from another task)
> */
> - atomic_t refcount;
> + refcount_t refcount;
> /* The lock protects mode, size, area and t. */
> spinlock_t lock;
> enum kcov_mode mode;
> @@ -101,12 +102,12 @@ EXPORT_SYMBOL(__sanitizer_cov_trace_pc);
>
> static void kcov_get(struct kcov *kcov)
> {
> - atomic_inc(&kcov->refcount);
> + refcount_inc(&kcov->refcount);
> }
>
> static void kcov_put(struct kcov *kcov)
> {
> - if (atomic_dec_and_test(&kcov->refcount)) {
> + if (refcount_dec_and_test(&kcov->refcount)) {
> vfree(kcov->area);
> kfree(kcov);
> }
> @@ -182,7 +183,7 @@ static int kcov_open(struct inode *inode, struct file *filep)
> kcov = kzalloc(sizeof(*kcov), GFP_KERNEL);
> if (!kcov)
> return -ENOMEM;
> - atomic_set(&kcov->refcount, 1);
> + refcount_set(&kcov->refcount, 1);
> spin_lock_init(&kcov->lock);
> filep->private_data = kcov;
> return nonseekable_open(inode, filep);
> diff --git a/kernel/nsproxy.c b/kernel/nsproxy.c
> index 782102e..435a0f9 100644
> --- a/kernel/nsproxy.c
> +++ b/kernel/nsproxy.c
> @@ -30,7 +30,7 @@
> static struct kmem_cache *nsproxy_cachep;
>
> struct nsproxy init_nsproxy = {
> - .count = ATOMIC_INIT(1),
> + .count = REFCOUNT_INIT(1),
> .uts_ns = &init_uts_ns,
> #if defined(CONFIG_POSIX_MQUEUE) || defined(CONFIG_SYSVIPC)
> .ipc_ns = &init_ipc_ns,
> @@ -51,7 +51,7 @@ static inline struct nsproxy *create_nsproxy(void)
>
> nsproxy = kmem_cache_alloc(nsproxy_cachep, GFP_KERNEL);
> if (nsproxy)
> - atomic_set(&nsproxy->count, 1);
> + refcount_set(&nsproxy->count, 1);
> return nsproxy;
> }
>
> @@ -224,7 +224,7 @@ void switch_task_namespaces(struct task_struct *p, struct nsproxy *new)
> p->nsproxy = new;
> task_unlock(p);
>
> - if (ns && atomic_dec_and_test(&ns->count))
> + if (ns && refcount_dec_and_test(&ns->count))
> free_nsproxy(ns);
> }
>
> diff --git a/kernel/sched/core.c b/kernel/sched/core.c
> index 966556e..f60da66 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
> @@ -2231,7 +2231,7 @@ static void __sched_fork(unsigned long clone_flags, struct task_struct *p)
> #endif
>
> #ifdef CONFIG_NUMA_BALANCING
> - if (p->mm && atomic_read(&p->mm->mm_users) == 1) {
> + if (p->mm && refcount_read(&p->mm->mm_users) == 1) {
> p->mm->numa_next_scan = jiffies + msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
> p->mm->numa_scan_seq = 0;
> }
> @@ -2878,7 +2878,7 @@ context_switch(struct rq *rq, struct task_struct *prev,
>
> if (!mm) {
> next->active_mm = oldmm;
> - atomic_inc(&oldmm->mm_count);
> + refcount_inc(&oldmm->mm_count);
> enter_lazy_tlb(oldmm, next);
> } else
> switch_mm_irqs_off(oldmm, mm, next);
> @@ -6177,6 +6177,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
> cpumask_or(covered, covered, sg_span);
>
> sg->sgc = *per_cpu_ptr(sdd->sgc, i);
> +
> if (atomic_inc_return(&sg->sgc->ref) == 1)
> build_group_mask(sd, sg);
>
> @@ -7686,7 +7687,7 @@ void __init sched_init(void)
> /*
> * The boot idle thread does lazy MMU switching as well:
> */
> - atomic_inc(&init_mm.mm_count);
> + refcount_inc(&init_mm.mm_count);
> enter_lazy_tlb(&init_mm, current);
>
> /*
> diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> index 6559d19..8622d15 100644
> --- a/kernel/sched/fair.c
> +++ b/kernel/sched/fair.c
> @@ -1133,7 +1133,7 @@ static void account_numa_dequeue(struct rq *rq, struct task_struct *p)
> }
>
> struct numa_group {
> - atomic_t refcount;
> + refcount_t refcount;
>
> spinlock_t lock; /* nr_tasks, tasks */
> int nr_tasks;
> @@ -2181,12 +2181,12 @@ static void task_numa_placement(struct task_struct *p)
>
> static inline int get_numa_group(struct numa_group *grp)
> {
> - return atomic_inc_not_zero(&grp->refcount);
> + return refcount_inc_not_zero(&grp->refcount);
> }
>
> static inline void put_numa_group(struct numa_group *grp)
> {
> - if (atomic_dec_and_test(&grp->refcount))
> + if (refcount_dec_and_test(&grp->refcount))
> kfree_rcu(grp, rcu);
> }
>
> @@ -2207,7 +2207,7 @@ static void task_numa_group(struct task_struct *p, int cpupid, int flags,
> if (!grp)
> return;
>
> - atomic_set(&grp->refcount, 1);
> + refcount_set(&grp->refcount, 1);
> grp->active_nodes = 1;
> grp->max_faults_cpu = 0;
> spin_lock_init(&grp->lock);
> diff --git a/kernel/user.c b/kernel/user.c
> index b069ccb..d9dff8e 100644
> --- a/kernel/user.c
> +++ b/kernel/user.c
> @@ -89,7 +89,7 @@ static DEFINE_SPINLOCK(uidhash_lock);
>
> /* root_user.__count is 1, for init task cred */
> struct user_struct root_user = {
> - .__count = ATOMIC_INIT(1),
> + .__count = REFCOUNT_INIT(1),
> .processes = ATOMIC_INIT(1),
> .sigpending = ATOMIC_INIT(0),
> .locked_shm = 0,
> @@ -115,7 +115,7 @@ static struct user_struct *uid_hash_find(kuid_t uid, struct hlist_head *hashent)
>
> hlist_for_each_entry(user, hashent, uidhash_node) {
> if (uid_eq(user->uid, uid)) {
> - atomic_inc(&user->__count);
> + refcount_inc(&user->__count);
> return user;
> }
> }
> @@ -162,7 +162,7 @@ void free_uid(struct user_struct *up)
> return;
>
> local_irq_save(flags);
> - if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
> + if (refcount_dec_and_lock(&up->__count, &uidhash_lock))
> free_user(up, flags);
> else
> local_irq_restore(flags);
> @@ -183,7 +183,7 @@ struct user_struct *alloc_uid(kuid_t uid)
> goto out_unlock;
>
> new->uid = uid;
> - atomic_set(&new->__count, 1);
> + refcount_set(&new->__count, 1);
>
> /*
> * Before adding this, check whether we raced
> diff --git a/lib/is_single_threaded.c b/lib/is_single_threaded.c
> index 391fd23..295ddcf 100644
> --- a/lib/is_single_threaded.c
> +++ b/lib/is_single_threaded.c
> @@ -25,7 +25,7 @@ bool current_is_single_threaded(void)
> if (atomic_read(&task->signal->live) != 1)
> return false;
>
> - if (atomic_read(&mm->mm_users) == 1)
> + if (refcount_read(&mm->mm_users) == 1)
> return true;
>
> ret = false;
> diff --git a/mm/backing-dev.c b/mm/backing-dev.c
> index 3bfed5ab..103875d 100644
> --- a/mm/backing-dev.c
> +++ b/mm/backing-dev.c
> @@ -416,8 +416,10 @@ wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
> node = &parent->rb_left;
> else if (congested->blkcg_id > blkcg_id)
> node = &parent->rb_right;
> - else
> - goto found;
> + else {
> + refcount_inc(&congested->refcnt);
> + goto found;
> + }
> }
>
> if (new_congested) {
> @@ -436,13 +438,12 @@ wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
> if (!new_congested)
> return NULL;
>
> - atomic_set(&new_congested->refcnt, 0);
> + refcount_set(&new_congested->refcnt, 1);
> new_congested->bdi = bdi;
> new_congested->blkcg_id = blkcg_id;
> goto retry;
>
> found:
> - atomic_inc(&congested->refcnt);
> spin_unlock_irqrestore(&cgwb_lock, flags);
> kfree(new_congested);
> return congested;
> @@ -459,7 +460,7 @@ void wb_congested_put(struct bdi_writeback_congested *congested)
> unsigned long flags;
>
> local_irq_save(flags);
> - if (!atomic_dec_and_lock(&congested->refcnt, &cgwb_lock)) {
> + if (!refcount_dec_and_lock(&congested->refcnt, &cgwb_lock)) {
> local_irq_restore(flags);
> return;
> }
> diff --git a/mm/debug.c b/mm/debug.c
> index db1cd26..0866505 100644
> --- a/mm/debug.c
> +++ b/mm/debug.c
> @@ -134,7 +134,7 @@ void dump_mm(const struct mm_struct *mm)
> mm->get_unmapped_area,
> #endif
> mm->mmap_base, mm->mmap_legacy_base, mm->highest_vm_end,
> - mm->pgd, atomic_read(&mm->mm_users),
> + mm->pgd, refcount_read(&mm->mm_users),
> atomic_read(&mm->mm_count),
> atomic_long_read((atomic_long_t *)&mm->nr_ptes),
> mm_nr_pmds((struct mm_struct *)mm),
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index 10eedbf..5048e8f 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -30,6 +30,7 @@
> #include <linux/userfaultfd_k.h>
> #include <linux/page_idle.h>
> #include <linux/shmem_fs.h>
> +#include <linux/refcount.h>
>
> #include <asm/tlb.h>
> #include <asm/pgalloc.h>
> @@ -56,14 +57,14 @@ unsigned long transparent_hugepage_flags __read_mostly =
>
> static struct shrinker deferred_split_shrinker;
>
> -static atomic_t huge_zero_refcount;
> +static refcount_t huge_zero_refcount;
> struct page *huge_zero_page __read_mostly;
>
> static struct page *get_huge_zero_page(void)
> {
> struct page *zero_page;
> retry:
> - if (likely(atomic_inc_not_zero(&huge_zero_refcount)))
> + if (likely(refcount_inc_not_zero(&huge_zero_refcount)))
> return READ_ONCE(huge_zero_page);
>
> zero_page = alloc_pages((GFP_TRANSHUGE | __GFP_ZERO) & ~__GFP_MOVABLE,
> @@ -81,7 +82,7 @@ static struct page *get_huge_zero_page(void)
> }
>
> /* We take additional reference here. It will be put back by shrinker */
> - atomic_set(&huge_zero_refcount, 2);
> + refcount_set(&huge_zero_refcount, 2);
> preempt_enable();
> return READ_ONCE(huge_zero_page);
> }
> @@ -92,7 +93,7 @@ static void put_huge_zero_page(void)
> * Counter should never go to zero here. Only shrinker can put
> * last reference.
> */
> - BUG_ON(atomic_dec_and_test(&huge_zero_refcount));
> + BUG_ON(refcount_dec_and_test(&huge_zero_refcount));
> }
>
> struct page *mm_get_huge_zero_page(struct mm_struct *mm)
> @@ -119,13 +120,16 @@ static unsigned long shrink_huge_zero_page_count(struct shrinker *shrink,
> struct shrink_control *sc)
> {
> /* we can free zero page only if last reference remains */
> - return atomic_read(&huge_zero_refcount) == 1 ? HPAGE_PMD_NR : 0;
> + return refcount_read(&huge_zero_refcount) == 1 ? HPAGE_PMD_NR : 0;
> }
>
> static unsigned long shrink_huge_zero_page_scan(struct shrinker *shrink,
> struct shrink_control *sc)
> {
> - if (atomic_cmpxchg(&huge_zero_refcount, 1, 0) == 1) {
> + /* the below is probably not fully safe */
> + /* do we need to take a lock? */
> + if (refcount_read(&huge_zero_refcount) == 1) {
> + refcount_set(&huge_zero_refcount, 0);
> struct page *zero_page = xchg(&huge_zero_page, NULL);
> BUG_ON(zero_page == NULL);
> __free_pages(zero_page, compound_order(zero_page));
> diff --git a/mm/init-mm.c b/mm/init-mm.c
> index 975e49f..8de5267 100644
> --- a/mm/init-mm.c
> +++ b/mm/init-mm.c
> @@ -17,8 +17,8 @@
> struct mm_struct init_mm = {
> .mm_rb = RB_ROOT,
> .pgd = swapper_pg_dir,
> - .mm_users = ATOMIC_INIT(2),
> - .mm_count = ATOMIC_INIT(1),
> + .mm_users = REFCOUNT_INIT(2),
> + .mm_count = REFCOUNT_INIT(1),
> .mmap_sem = __RWSEM_INITIALIZER(init_mm.mmap_sem),
> .page_table_lock = __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock),
> .mmlist = LIST_HEAD_INIT(init_mm.mmlist),
> diff --git a/mm/khugepaged.c b/mm/khugepaged.c
> index e32389a..85f584a 100644
> --- a/mm/khugepaged.c
> +++ b/mm/khugepaged.c
> @@ -391,7 +391,7 @@ static void insert_to_mm_slots_hash(struct mm_struct *mm,
>
> static inline int khugepaged_test_exit(struct mm_struct *mm)
> {
> - return atomic_read(&mm->mm_users) == 0;
> + return refcount_read(&mm->mm_users) == 0;
> }
>
> int __khugepaged_enter(struct mm_struct *mm)
> @@ -420,7 +420,7 @@ int __khugepaged_enter(struct mm_struct *mm)
> list_add_tail(&mm_slot->mm_node, &khugepaged_scan.mm_head);
> spin_unlock(&khugepaged_mm_lock);
>
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> if (wakeup)
> wake_up_interruptible(&khugepaged_wait);
>
> diff --git a/mm/kmemleak.c b/mm/kmemleak.c
> index da34369..2e1167b 100644
> --- a/mm/kmemleak.c
> +++ b/mm/kmemleak.c
> @@ -105,7 +105,7 @@
>
> #include <asm/sections.h>
> #include <asm/processor.h>
> -#include <linux/atomic.h>
> +#include <linux/refcount.h>
>
> #include <linux/kasan.h>
> #include <linux/kmemcheck.h>
> @@ -154,7 +154,7 @@ struct kmemleak_object {
> struct rb_node rb_node;
> struct rcu_head rcu; /* object_list lockless traversal */
> /* object usage count; object freed when use_count == 0 */
> - atomic_t use_count;
> + refcount_t use_count;
> unsigned long pointer;
> size_t size;
> /* minimum number of a pointers found before it is considered leak */
> @@ -434,7 +434,7 @@ static struct kmemleak_object *lookup_object(unsigned long ptr, int alias)
> */
> static int get_object(struct kmemleak_object *object)
> {
> - return atomic_inc_not_zero(&object->use_count);
> + return refcount_inc_not_zero(&object->use_count);
> }
>
> /*
> @@ -467,7 +467,7 @@ static void free_object_rcu(struct rcu_head *rcu)
> */
> static void put_object(struct kmemleak_object *object)
> {
> - if (!atomic_dec_and_test(&object->use_count))
> + if (!refcount_dec_and_test(&object->use_count))
> return;
>
> /* should only get here after delete_object was called */
> @@ -556,7 +556,7 @@ static struct kmemleak_object *create_object(unsigned long ptr, size_t size,
> INIT_LIST_HEAD(&object->gray_list);
> INIT_HLIST_HEAD(&object->area_list);
> spin_lock_init(&object->lock);
> - atomic_set(&object->use_count, 1);
> + refcount_set(&object->use_count, 1);
> object->flags = OBJECT_ALLOCATED;
> object->pointer = ptr;
> object->size = size;
> @@ -629,7 +629,7 @@ static void __delete_object(struct kmemleak_object *object)
> unsigned long flags;
>
> WARN_ON(!(object->flags & OBJECT_ALLOCATED));
> - WARN_ON(atomic_read(&object->use_count) < 1);
> + WARN_ON(refcount_read(&object->use_count) < 1);
>
> /*
> * Locking here also ensures that the corresponding memory block
> @@ -1396,9 +1396,9 @@ static void kmemleak_scan(void)
> * With a few exceptions there should be a maximum of
> * 1 reference to any object at this point.
> */
> - if (atomic_read(&object->use_count) > 1) {
> + if (refcount_read(&object->use_count) > 1) {
> pr_debug("object->use_count = %d\n",
> - atomic_read(&object->use_count));
> + refcount_read(&object->use_count));
> dump_object_info(object);
> }
> #endif
> diff --git a/mm/ksm.c b/mm/ksm.c
> index 9ae6011..8076183 100644
> --- a/mm/ksm.c
> +++ b/mm/ksm.c
> @@ -352,7 +352,7 @@ static void insert_to_mm_slots_hash(struct mm_struct *mm,
> */
> static inline bool ksm_test_exit(struct mm_struct *mm)
> {
> - return atomic_read(&mm->mm_users) == 0;
> + return refcount_read(&mm->mm_users) == 0;
> }
>
> /*
> @@ -1813,7 +1813,7 @@ int __ksm_enter(struct mm_struct *mm)
> spin_unlock(&ksm_mmlist_lock);
>
> set_bit(MMF_VM_MERGEABLE, &mm->flags);
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
>
> if (needs_wakeup)
> wake_up_interruptible(&ksm_thread_wait);
> diff --git a/mm/memory.c b/mm/memory.c
> index 455c3e6..9e50d9c 100644
> --- a/mm/memory.c
> +++ b/mm/memory.c
> @@ -375,7 +375,7 @@ void tlb_remove_table(struct mmu_gather *tlb, void *table)
> * When there's less then two users of this mm there cannot be a
> * concurrent page-table walk.
> */
> - if (atomic_read(&tlb->mm->mm_users) < 2) {
> + if (refcount_read(&tlb->mm->mm_users) < 2) {
> __tlb_remove_table(table);
> return;
> }
> diff --git a/mm/mmu_context.c b/mm/mmu_context.c
> index 6f4d27c..b5071e3 100644
> --- a/mm/mmu_context.c
> +++ b/mm/mmu_context.c
> @@ -25,7 +25,7 @@ void use_mm(struct mm_struct *mm)
> task_lock(tsk);
> active_mm = tsk->active_mm;
> if (active_mm != mm) {
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> tsk->active_mm = mm;
> }
> tsk->mm = mm;
> diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
> index f4259e4..00c2833 100644
> --- a/mm/mmu_notifier.c
> +++ b/mm/mmu_notifier.c
> @@ -249,7 +249,7 @@ static int do_mmu_notifier_register(struct mmu_notifier *mn,
> struct mmu_notifier_mm *mmu_notifier_mm;
> int ret;
>
> - BUG_ON(atomic_read(&mm->mm_users) <= 0);
> + BUG_ON(refcount_read(&mm->mm_users) <= 0);
>
> /*
> * Verify that mmu_notifier_init() already run and the global srcu is
> @@ -275,7 +275,7 @@ static int do_mmu_notifier_register(struct mmu_notifier *mn,
> mm->mmu_notifier_mm = mmu_notifier_mm;
> mmu_notifier_mm = NULL;
> }
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
>
> /*
> * Serialize the update against mmu_notifier_unregister. A
> @@ -295,7 +295,7 @@ static int do_mmu_notifier_register(struct mmu_notifier *mn,
> up_write(&mm->mmap_sem);
> kfree(mmu_notifier_mm);
> out:
> - BUG_ON(atomic_read(&mm->mm_users) <= 0);
> + BUG_ON(refcount_read(&mm->mm_users) <= 0);
> return ret;
> }
>
> @@ -348,7 +348,7 @@ void __mmu_notifier_mm_destroy(struct mm_struct *mm)
> */
> void mmu_notifier_unregister(struct mmu_notifier *mn, struct mm_struct *mm)
> {
> - BUG_ON(atomic_read(&mm->mm_count) <= 0);
> + BUG_ON(refcount_read(&mm->mm_count) <= 0);
>
> if (!hlist_unhashed(&mn->hlist)) {
> /*
> @@ -381,7 +381,7 @@ void mmu_notifier_unregister(struct mmu_notifier *mn, struct mm_struct *mm)
> */
> synchronize_srcu(&srcu);
>
> - BUG_ON(atomic_read(&mm->mm_count) <= 0);
> + BUG_ON(refcount_read(&mm->mm_count) <= 0);
>
> mmdrop(mm);
> }
> @@ -401,7 +401,7 @@ void mmu_notifier_unregister_no_release(struct mmu_notifier *mn,
> hlist_del_init_rcu(&mn->hlist);
> spin_unlock(&mm->mmu_notifier_mm->lock);
>
> - BUG_ON(atomic_read(&mm->mm_count) <= 0);
> + BUG_ON(refcount_read(&mm->mm_count) <= 0);
> mmdrop(mm);
> }
> EXPORT_SYMBOL_GPL(mmu_notifier_unregister_no_release);
> diff --git a/mm/mprotect.c b/mm/mprotect.c
> index cc2459c..4c38b4c 100644
> --- a/mm/mprotect.c
> +++ b/mm/mprotect.c
> @@ -77,7 +77,7 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
>
> /* Get target node for single threaded private VMAs */
> if (prot_numa && !(vma->vm_flags & VM_SHARED) &&
> - atomic_read(&vma->vm_mm->mm_users) == 1)
> + refcount_read(&vma->vm_mm->mm_users) == 1)
> target_node = numa_node_id();
>
> arch_enter_lazy_mmu_mode();
> diff --git a/mm/oom_kill.c b/mm/oom_kill.c
> index ec9f11d..8a98e1b 100644
> --- a/mm/oom_kill.c
> +++ b/mm/oom_kill.c
> @@ -660,7 +660,7 @@ static void mark_oom_victim(struct task_struct *tsk)
>
> /* oom_mm is bound to the signal struct life time. */
> if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm))
> - atomic_inc(&tsk->signal->oom_mm->mm_count);
> + refcount_inc(&tsk->signal->oom_mm->mm_count);
>
> /*
> * Make sure that the task is woken up from uninterruptible sleep
> @@ -781,7 +781,7 @@ static bool task_will_free_mem(struct task_struct *task)
> if (test_bit(MMF_OOM_SKIP, &mm->flags))
> return false;
>
> - if (atomic_read(&mm->mm_users) <= 1)
> + if (refcount_read(&mm->mm_users) <= 1)
> return true;
>
> /*
> @@ -877,7 +877,7 @@ static void oom_kill_process(struct oom_control *oc, const char *message)
>
> /* Get a reference to safely compare mm after task_unlock(victim) */
> mm = victim->mm;
> - atomic_inc(&mm->mm_count);
> + refcount_inc(&mm->mm_count);
> /*
> * We should send SIGKILL before setting TIF_MEMDIE in order to prevent
> * the OOM victim from depleting the memory reserves from the user
> diff --git a/mm/rmap.c b/mm/rmap.c
> index 91619fd..47fbdfd 100644
> --- a/mm/rmap.c
> +++ b/mm/rmap.c
> @@ -77,7 +77,7 @@ static inline struct anon_vma *anon_vma_alloc(void)
>
> anon_vma = kmem_cache_alloc(anon_vma_cachep, GFP_KERNEL);
> if (anon_vma) {
> - atomic_set(&anon_vma->refcount, 1);
> + refcount_set(&anon_vma->refcount, 1);
> anon_vma->degree = 1; /* Reference for first vma */
> anon_vma->parent = anon_vma;
> /*
> @@ -92,7 +92,7 @@ static inline struct anon_vma *anon_vma_alloc(void)
>
> static inline void anon_vma_free(struct anon_vma *anon_vma)
> {
> - VM_BUG_ON(atomic_read(&anon_vma->refcount));
> + VM_BUG_ON(refcount_read(&anon_vma->refcount));
>
> /*
> * Synchronize against page_lock_anon_vma_read() such that
> @@ -421,7 +421,7 @@ static void anon_vma_ctor(void *data)
> struct anon_vma *anon_vma = data;
>
> init_rwsem(&anon_vma->rwsem);
> - atomic_set(&anon_vma->refcount, 0);
> + refcount_set(&anon_vma->refcount, 0);
> anon_vma->rb_root = RB_ROOT;
> }
>
> @@ -470,7 +470,7 @@ struct anon_vma *page_get_anon_vma(struct page *page)
> goto out;
>
> anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
> - if (!atomic_inc_not_zero(&anon_vma->refcount)) {
> + if (!refcount_inc_not_zero(&anon_vma->refcount)) {
> anon_vma = NULL;
> goto out;
> }
> @@ -529,7 +529,7 @@ struct anon_vma *page_lock_anon_vma_read(struct page *page)
> }
>
> /* trylock failed, we got to sleep */
> - if (!atomic_inc_not_zero(&anon_vma->refcount)) {
> + if (!refcount_inc_not_zero(&anon_vma->refcount)) {
> anon_vma = NULL;
> goto out;
> }
> @@ -544,7 +544,7 @@ struct anon_vma *page_lock_anon_vma_read(struct page *page)
> rcu_read_unlock();
> anon_vma_lock_read(anon_vma);
>
> - if (atomic_dec_and_test(&anon_vma->refcount)) {
> + if (refcount_dec_and_test(&anon_vma->refcount)) {
> /*
> * Oops, we held the last refcount, release the lock
> * and bail -- can't simply use put_anon_vma() because
> @@ -1711,7 +1711,7 @@ void __put_anon_vma(struct anon_vma *anon_vma)
> struct anon_vma *root = anon_vma->root;
>
> anon_vma_free(anon_vma);
> - if (root != anon_vma && atomic_dec_and_test(&root->refcount))
> + if (root != anon_vma && refcount_dec_and_test(&root->refcount))
> anon_vma_free(root);
> }
>
> diff --git a/mm/swapfile.c b/mm/swapfile.c
> index 1c6e032..6e870f7 100644
> --- a/mm/swapfile.c
> +++ b/mm/swapfile.c
> @@ -1401,7 +1401,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
> * that.
> */
> start_mm = &init_mm;
> - atomic_inc(&init_mm.mm_users);
> + refcount_inc(&init_mm.mm_users);
>
> /*
> * Keep on scanning until all entries have gone. Usually,
> @@ -1447,10 +1447,10 @@ int try_to_unuse(unsigned int type, bool frontswap,
> /*
> * Don't hold on to start_mm if it looks like exiting.
> */
> - if (atomic_read(&start_mm->mm_users) == 1) {
> + if (refcount_read(&start_mm->mm_users) == 1) {
> mmput(start_mm);
> start_mm = &init_mm;
> - atomic_inc(&init_mm.mm_users);
> + refcount_inc(&init_mm.mm_users);
> }
>
> /*
> @@ -1487,13 +1487,13 @@ int try_to_unuse(unsigned int type, bool frontswap,
> struct mm_struct *prev_mm = start_mm;
> struct mm_struct *mm;
>
> - atomic_inc(&new_start_mm->mm_users);
> - atomic_inc(&prev_mm->mm_users);
> + refcount_inc(&new_start_mm->mm_users);
> + refcount_inc(&prev_mm->mm_users);
> spin_lock(&mmlist_lock);
> while (swap_count(*swap_map) && !retval &&
> (p = p->next) != &start_mm->mmlist) {
> mm = list_entry(p, struct mm_struct, mmlist);
> - if (!atomic_inc_not_zero(&mm->mm_users))
> + if (!refcount_inc_not_zero(&mm->mm_users))
> continue;
> spin_unlock(&mmlist_lock);
> mmput(prev_mm);
> @@ -1511,7 +1511,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
>
> if (set_start_mm && *swap_map < swcount) {
> mmput(new_start_mm);
> - atomic_inc(&mm->mm_users);
> + refcount_inc(&mm->mm_users);
> new_start_mm = mm;
> set_start_mm = 0;
> }
> diff --git a/mm/vmacache.c b/mm/vmacache.c
> index 035fdeb..4747ee6 100644
> --- a/mm/vmacache.c
> +++ b/mm/vmacache.c
> @@ -26,7 +26,7 @@ void vmacache_flush_all(struct mm_struct *mm)
> * to worry about other threads' seqnum. Current's
> * flush will occur upon the next lookup.
> */
> - if (atomic_read(&mm->mm_users) == 1)
> + if (refcount_read(&mm->mm_users) == 1)
> return;
>
> rcu_read_lock();
> diff --git a/mm/zpool.c b/mm/zpool.c
> index fd3ff71..48ec64f 100644
> --- a/mm/zpool.c
> +++ b/mm/zpool.c
> @@ -56,11 +56,11 @@ EXPORT_SYMBOL(zpool_register_driver);
> */
> int zpool_unregister_driver(struct zpool_driver *driver)
> {
> - int ret = 0, refcount;
> + int ret = 0;
> + unsigned int refcount;
>
> spin_lock(&drivers_lock);
> refcount = atomic_read(&driver->refcount);
> - WARN_ON(refcount < 0);
> if (refcount > 0)
> ret = -EBUSY;
> else
> diff --git a/net/sunrpc/auth_null.c b/net/sunrpc/auth_null.c
> index 4d17376..8c2470b 100644
> --- a/net/sunrpc/auth_null.c
> +++ b/net/sunrpc/auth_null.c
> @@ -137,7 +137,7 @@ struct rpc_cred null_cred = {
> .cr_lru = LIST_HEAD_INIT(null_cred.cr_lru),
> .cr_auth = &null_auth,
> .cr_ops = &null_credops,
> - .cr_count = ATOMIC_INIT(1),
> + .cr_count = REFCOUNT_INIT(1),
> .cr_flags = 1UL << RPCAUTH_CRED_UPTODATE,
> #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
> .cr_magic = RPCAUTH_CRED_MAGIC,
> diff --git a/virt/kvm/async_pf.c b/virt/kvm/async_pf.c
> index 3815e94..8a298fc 100644
> --- a/virt/kvm/async_pf.c
> +++ b/virt/kvm/async_pf.c
> @@ -204,7 +204,7 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, unsigned long hva,
> work->addr = hva;
> work->arch = *arch;
> work->mm = current->mm;
> - atomic_inc(&work->mm->mm_users);
> + refcount_inc(&work->mm->mm_users);
> kvm_get_kvm(work->vcpu->kvm);
>
> /* this can't really happen otherwise gfn_to_pfn_async
> diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
> index de102ca..f0f27c7 100644
> --- a/virt/kvm/kvm_main.c
> +++ b/virt/kvm/kvm_main.c
> @@ -616,13 +616,13 @@ static struct kvm *kvm_create_vm(unsigned long type)
> return ERR_PTR(-ENOMEM);
>
> spin_lock_init(&kvm->mmu_lock);
> - atomic_inc(¤t->mm->mm_count);
> + refcount_inc(¤t->mm->mm_count);
> kvm->mm = current->mm;
> kvm_eventfd_init(kvm);
> mutex_init(&kvm->lock);
> mutex_init(&kvm->irq_lock);
> mutex_init(&kvm->slots_lock);
> - atomic_set(&kvm->users_count, 1);
> + refcount_set(&kvm->users_count, 1);
> INIT_LIST_HEAD(&kvm->devices);
>
> r = kvm_arch_init_vm(kvm, type);
> @@ -745,13 +745,13 @@ static void kvm_destroy_vm(struct kvm *kvm)
>
> void kvm_get_kvm(struct kvm *kvm)
> {
> - atomic_inc(&kvm->users_count);
> + refcount_inc(&kvm->users_count);
> }
> EXPORT_SYMBOL_GPL(kvm_get_kvm);
>
> void kvm_put_kvm(struct kvm *kvm)
> {
> - if (atomic_dec_and_test(&kvm->users_count))
> + if (refcount_dec_and_test(&kvm->users_count))
> kvm_destroy_vm(kvm);
> }
> EXPORT_SYMBOL_GPL(kvm_put_kvm);
> @@ -3640,7 +3640,7 @@ static int kvm_debugfs_open(struct inode *inode, struct file *file,
> * To avoid the race between open and the removal of the debugfs
> * directory we test against the users count.
> */
> - if (!atomic_add_unless(&stat_data->kvm->users_count, 1, 0))
> + if (!refcount_inc_not_zero(&stat_data->kvm->users_count))
> return -ENOENT;
>
> if (simple_attr_open(inode, file, get, set, fmt)) {
> --
> 2.7.4
>
Powered by blists - more mailing lists
Confused about mailing lists and their use?
Read about mailing lists on Wikipedia
and check out these
guidelines on proper formatting of your messages.
