lkml.org 
[lkml]   [2017]   [Dec]   [12]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[tip:locking/urgent] tools/include: Remove ACCESS_ONCE()
    Commit-ID:  2a22f692bbe0a7933acbd50045479ffc0fdf11f7
    Gitweb: https://git.kernel.org/tip/2a22f692bbe0a7933acbd50045479ffc0fdf11f7
    Author: Mark Rutland <mark.rutland@arm.com>
    AuthorDate: Mon, 27 Nov 2017 10:38:22 +0000
    Committer: Ingo Molnar <mingo@kernel.org>
    CommitDate: Tue, 12 Dec 2017 13:22:10 +0100

    tools/include: Remove ACCESS_ONCE()

    There are no longer any usersapce uses of ACCESS_ONCE(), so we can
    remove the definition from our userspace <linux/compiler.h>, which is
    only used by tools in the kernel directory (i.e. it isn't a uapi
    header).

    This patch removes the ACCESS_ONCE() definition, and updates comments
    which referred to it. At the same time, some inconsistent and redundant
    whitespace is removed from comments.

    Tested-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
    Signed-off-by: Mark Rutland <mark.rutland@arm.com>
    Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
    Cc: Joe Perches <joe@perches.com>
    Cc: Linus Torvalds <torvalds@linux-foundation.org>
    Cc: Peter Zijlstra <peterz@infradead.org>
    Cc: Thomas Gleixner <tglx@linutronix.de>
    Cc: apw@canonical.com
    Link: http://lkml.kernel.org/r/20171127103824.36526-3-mark.rutland@arm.com
    Signed-off-by: Ingo Molnar <mingo@kernel.org>
    ---
    tools/include/linux/compiler.h | 21 +++++++++------------
    1 file changed, 9 insertions(+), 12 deletions(-)

    diff --git a/tools/include/linux/compiler.h b/tools/include/linux/compiler.h
    index 07fd03c..04e32f9 100644
    --- a/tools/include/linux/compiler.h
    +++ b/tools/include/linux/compiler.h
    @@ -84,8 +84,6 @@

    #define uninitialized_var(x) x = *(&(x))

    -#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
    -
    #include <linux/types.h>

    /*
    @@ -135,20 +133,19 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
    /*
    * Prevent the compiler from merging or refetching reads or writes. The
    * compiler is also forbidden from reordering successive instances of
    - * READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), but only when the
    - * compiler is aware of some particular ordering. One way to make the
    - * compiler aware of ordering is to put the two invocations of READ_ONCE,
    - * WRITE_ONCE or ACCESS_ONCE() in different C statements.
    + * READ_ONCE and WRITE_ONCE, but only when the compiler is aware of some
    + * particular ordering. One way to make the compiler aware of ordering is to
    + * put the two invocations of READ_ONCE or WRITE_ONCE in different C
    + * statements.
    *
    - * In contrast to ACCESS_ONCE these two macros will also work on aggregate
    - * data types like structs or unions. If the size of the accessed data
    - * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
    - * READ_ONCE() and WRITE_ONCE() will fall back to memcpy and print a
    - * compile-time warning.
    + * These two macros will also work on aggregate data types like structs or
    + * unions. If the size of the accessed data type exceeds the word size of
    + * the machine (e.g., 32 bits or 64 bits) READ_ONCE() and WRITE_ONCE() will
    + * fall back to memcpy and print a compile-time warning.
    *
    * Their two major use cases are: (1) Mediating communication between
    * process-level code and irq/NMI handlers, all running on the same CPU,
    - * and (2) Ensuring that the compiler does not fold, spindle, or otherwise
    + * and (2) Ensuring that the compiler does not fold, spindle, or otherwise
    * mutilate accesses that either do not require ordering or that interact
    * with an explicit memory barrier or atomic instruction that provides the
    * required ordering.
    \
     
     \ /
      Last update: 2017-12-12 16:10    [W:5.681 / U:1.140 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site