On 03/02/2017 10:45 PM, Arnd Bergmann wrote:
On Thu, Mar 2, 2017 at 8:00 PM, Christian Borntraeger
[off-list ref] wrote:
quoted
On 03/02/2017 06:55 PM, Arnd Bergmann wrote:
quoted
On Thu, Mar 2, 2017 at 5:51 PM, Christian Borntraeger
[off-list ref] wrote:
quoted
On 03/02/2017 05:38 PM, Arnd Bergmann wrote:
quoted
This attempts a rewrite of the two macros, using a simpler implementation
for the most common case of having a naturally aligned 1, 2, 4, or (on
64-bit architectures) 8 byte object that can be accessed with a single
instruction. For these, we go back to a volatile pointer dereference
that we had with the ACCESS_ONCE macro.
We had changed that back then because gcc 4.6 and 4.7 had a bug that could
removed the volatile statement on aggregate types like the following one
union ipte_control {
unsigned long val;
struct {
unsigned long k : 1;
unsigned long kh : 31;
unsigned long kg : 32;
};
};
See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145
If I see that right, your __ALIGNED_WORD(x)
macro would say that for above structure sizeof(x) == sizeof(long)) is true,
so it would fall back to the old volatile cast and might reintroduce the
old compiler bug?
Oh dear, I should double check my sentences in emails before sending...anyway
the full story is referenced in
commit 60815cf2e05057db5b78e398d9734c493560b11e
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/borntraeger/linux
which has a pointer to
http://marc.info/?i=54611D86.4040306%40de.ibm.com
which contains the full story.
Ok, got it. So I guess the behavior of forcing aligned accesses on aligned
data is accidental, and allowing non-power-of-two arguments is also not
the main purpose.
Right. The main purpose is to read/write _ONCE_. You can assume a somewhat
atomic access for sizes <= word size. And there are certainly places that
rely on that. But the *ONCE thing is mostly used for things where we used
barrier() 10 years ago.
Maybe we could just bail out on new compilers if we get
either of those? That might catch code that accidentally does something
that is inherently non-atomic or that causes a trap when the intention was
to have a simple atomic access.
I think Linus stated that its ok to assume that the compiler is smart enough
to uses a single instruction to access aligned and properly sized scalar types
for *ONCE.
Back then when I changed ACCESS_ONCE there were many places that did use it
for non-atomic, > word size accesses. For example on some architectures a pmd_t
is a typedef to an array, for which there is no way to read that atomically.
So the focus must be on the "ONCE" part.
If some code uses a properly aligned, word sized object we can also assume
atomic access. If the access is not properly sized/aligned we do not get
atomicity, but we do get the "ONCE".
But adding a check for alignment/size would break the compilation of some
code.