Openwall GNU/*/Linux - a small security-enhanced Linux distro for servers
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date: Thu, 5 Jan 2017 09:56:19 +0000
From: "Reshetova, Elena" <elena.reshetova@...el.com>
To: AKASHI Takahiro <takahiro.akashi@...aro.org>,
	"kernel-hardening@...ts.openwall.com" <kernel-hardening@...ts.openwall.com>
CC: "keescook@...omium.org" <keescook@...omium.org>, "arnd@...db.de"
	<arnd@...db.de>, "tglx@...utronix.de" <tglx@...utronix.de>,
	"mingo@...hat.com" <mingo@...hat.com>, "Anvin, H Peter"
	<h.peter.anvin@...el.com>, "peterz@...radead.org" <peterz@...radead.org>,
	"will.deacon@....com" <will.deacon@....com>, "dwindsor@...il.com"
	<dwindsor@...il.com>, "gregkh@...uxfoundation.org"
	<gregkh@...uxfoundation.org>, "ishkamiel@...il.com" <ishkamiel@...il.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.

Thank you! I haven't tried to build on arm64 this yet (as well as on other arches). I am pretty sure there are more cases on other arches that are missed.
That's why I was hoping that we can run this series to the automatic build infra. 

@Kees, how did you do it before for previous patches? Who should be contacted to get a build-test on all arches?

Best Regards,
Elena


> 
> -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(&current->mm->mm_users) >
> max_users)
> > +		if (refcount_read(&current->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(&current->mm->mm_count);
> > +		refcount_inc(&current->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(&current->sighand->count);
> > +		refcount_inc(&current->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(&current->signal->live);
> > -			atomic_inc(&current->signal->sigcnt);
> > +			refcount_inc(&current->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(&current->sighand->count) > 1)
> > +		if (refcount_read(&current->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(&current->mm->mm_count);
> > +	refcount_inc(&current->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

Your e-mail address:

Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.