linux-toradex.git/include/linux/smp.h, branch v4.14-rc7

smp: Avoid using two cache lines for struct call_single_data

2017-08-29T13:14:38+00:00

struct call_single_data is used in IPIs to transfer information between
CPUs.  Its size is bigger than sizeof(unsigned long) and less than
cache line size.  Currently it is not allocated with any explicit alignment
requirements.  This makes it possible for allocated call_single_data to
cross two cache lines, which results in double the number of the cache lines
that need to be transferred among CPUs.

This can be fixed by requiring call_single_data to be aligned with the
size of call_single_data. Currently the size of call_single_data is the
power of 2.  If we add new fields to call_single_data, we may need to
add padding to make sure the size of new definition is the power of 2
as well.

Fortunately, this is enforced by GCC, which will report bad sizes.

To set alignment requirements of call_single_data to the size of
call_single_data, a struct definition and a typedef is used.

To test the effect of the patch, I used the vm-scalability multiple
thread swap test case (swap-w-seq-mt).  The test will create multiple
threads and each thread will eat memory until all RAM and part of swap
is used, so that huge number of IPIs are triggered when unmapping
memory.  In the test, the throughput of memory writing improves ~5%
compared with misaligned call_single_data, because of faster IPIs.

Suggested-by: Peter Zijlstra 
Signed-off-by: Huang, Ying 
[ Add call_single_data_t and align with size of call_single_data. ]
Signed-off-by: Peter Zijlstra (Intel) 
Cc: Aaron Lu 
Cc: Borislav Petkov 
Cc: Eric Dumazet 
Cc: Juergen Gross 
Cc: Linus Torvalds 
Cc: Michael Ellerman 
Cc: Thomas Gleixner 
Link: http://lkml.kernel.org/r/87bmnqd6lz.fsf@yhuang-mobile.sh.intel.com
Signed-off-by: Ingo Molnar

lockdep: Fix per-cpu static objects

2017-03-26T13:09:45+00:00

Since commit 383776fa7527 ("locking/lockdep: Handle statically initialized
PER_CPU locks properly") we try to collapse per-cpu locks into a single
class by giving them all the same key. For this key we choose the canonical
address of the per-cpu object, which would be the offset into the per-cpu
area.

This has two problems:

 - there is a case where we run !0 lock->key through static_obj() and
   expect this to pass; it doesn't for canonical pointers.

 - 0 is a valid canonical address.

Cure both issues by redefining the canonical address as the address of the
per-cpu variable on the boot CPU.

Since I didn't want to rely on CPU0 being the boot-cpu, or even existing at
all, track the boot CPU in a variable.

Fixes: 383776fa7527 ("locking/lockdep: Handle statically initialized PER_CPU locks properly")
Reported-by: kernel test robot 
Signed-off-by: Peter Zijlstra (Intel) 
Tested-by: Borislav Petkov 
Cc: Sebastian Andrzej Siewior 
Cc: linux-mm@kvack.org
Cc: wfg@linux.intel.com
Cc: kernel test robot 
Cc: LKP 
Link: http://lkml.kernel.org/r/20170320114108.kbvcsuepem45j5cr@hirez.programming.kicks-ass.net
Signed-off-by: Thomas Gleixner

smp: Add function to execute a function synchronously on a CPU

2016-09-05T11:52:39+00:00

On some hardware models (e.g. Dell Studio 1555 laptop) some hardware
related functions (e.g. SMIs) are to be executed on physical CPU 0
only. Instead of open coding such a functionality multiple times in
the kernel add a service function for this purpose. This will enable
the possibility to take special measures in virtualized environments
like Xen, too.

Signed-off-by: Juergen Gross 
Signed-off-by: Peter Zijlstra (Intel) 
Cc: Douglas_Warzecha@dell.com
Cc: Linus Torvalds 
Cc: Peter Zijlstra 
Cc: Thomas Gleixner 
Cc: akataria@vmware.com
Cc: boris.ostrovsky@oracle.com
Cc: chrisw@sous-sol.org
Cc: david.vrabel@citrix.com
Cc: hpa@zytor.com
Cc: jdelvare@suse.com
Cc: jeremy@goop.org
Cc: linux@roeck-us.net
Cc: pali.rohar@gmail.com
Cc: rusty@rustcorp.com.au
Cc: virtualization@lists.linux-foundation.org
Cc: xen-devel@lists.xenproject.org
Link: http://lkml.kernel.org/r/1472453327-19050-4-git-send-email-jgross@suse.com
Signed-off-by: Ingo Molnar

smp/cfd: Convert core to hotplug state machine

2016-07-15T08:41:43+00:00

Install the callbacks via the state machine. They are installed at runtime so
smpcfd_prepare_cpu() needs to be invoked by the boot-CPU.

Signed-off-by: Richard Weinberger 
[ Added the dropped CPU dying case back in. ]
Signed-off-by: Richard Cochran 
Signed-off-by: Anna-Maria Gleixner 
Reviewed-by: Sebastian Andrzej Siewior 
Cc: Davidlohr Bueso 
Cc: Linus Torvalds 
Cc: Mel Gorman 
Cc: Oleg Nesterov 
Cc: Peter Zijlstra 
Cc: Rasmus Villemoes 
Cc: Thomas Gleixner 
Cc: rt@linutronix.de
Link: http://lkml.kernel.org/r/20160713153337.818376366@linutronix.de
Signed-off-by: Ingo Molnar

smp: don't use 16-bit words for atomic accesses

2015-04-20T16:08:49+00:00

Yes, it should work, but it's a bad idea.  Not only did ARM64 not have
the 16-bit access code (there's a separate patch to add it), it's just
not a good atomic type.  Some architectures fundamentally don't do
atomic accesses in them (alpha), and it's not like it saves any space
here anyway because of structure packing issues.

We normally should aim for flags to be "unsigned int" or "unsigned
long".  And if space is at a premium, use a single byte (although that
causes problems on alpha again).  There might be very special cases
where a 16-byte entity is really wanted, but this is not one of them.

Signed-off-by: Linus Torvalds

init: Get rid of x86isms

2015-01-22T14:10:56+00:00

The UP local API support can be set up from an early initcall. No need
for horrible hackery in the init code.

Signed-off-by: Thomas Gleixner 
Cc: Jiang Liu 
Cc: Joerg Roedel 
Cc: Tony Luck 
Cc: Borislav Petkov 
Link: http://lkml.kernel.org/r/20150115211703.827943883@linutronix.de
Signed-off-by: Thomas Gleixner

smp: Add new wake_up_all_idle_cpus() function

2014-09-19T10:35:15+00:00

Currently kick_all_cpus_sync() can break non-polling idle cpus
thru IPI interrupts.

But sometimes we need to break the polling idle cpus immediately
to reselect the suitable c-state, also for non-idle cpus, we need
to do nothing if we try to wake up them.

Here adding one new function wake_up_all_idle_cpus() to let all cpus
out of idle based on function wake_up_if_idle().

Signed-off-by: Chuansheng Liu 
Signed-off-by: Peter Zijlstra (Intel) 
Cc: daniel.lezcano@linaro.org
Cc: rjw@rjwysocki.net
Cc: linux-pm@vger.kernel.org
Cc: changcheng.liu@intel.com
Cc: xiaoming.wang@intel.com
Cc: souvik.k.chakravarty@intel.com
Cc: luto@amacapital.net
Cc: Andrew Morton 
Cc: Christoph Hellwig 
Cc: Frederic Weisbecker 
Cc: Geert Uytterhoeven 
Cc: Jan Kara 
Cc: Jens Axboe 
Cc: Jens Axboe 
Cc: Linus Torvalds 
Cc: Michal Hocko 
Cc: Paul Gortmaker 
Cc: Roman Gushchin 
Cc: Srivatsa S. Bhat 
Link: http://lkml.kernel.org/r/1409815075-4180-2-git-send-email-chuansheng.liu@intel.com
Signed-off-by: Ingo Molnar

idle: remove cpu_idle() forward declarations

2014-06-06T23:08:18+00:00

After all architectures were converted to the generic idle framework,
commit d190e8195b90 ("idle: Remove GENERIC_IDLE_LOOP config switch")
removed the last caller of cpu_idle().  The forward declarations in
header files were forgotten.

Signed-off-by: Geert Uytterhoeven 
Cc: Thomas Gleixner 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

smp: Rename __smp_call_function_single() to smp_call_function_single_async()

2014-02-24T22:47:15+00:00

The name __smp_call_function_single() doesn't tell much about the
properties of this function, especially when compared to
smp_call_function_single().

The comments above the implementation are also misleading. The main
point of this function is actually not to be able to embed the csd
in an object. This is actually a requirement that result from the
purpose of this function which is to raise an IPI asynchronously.

As such it can be called with interrupts disabled. And this feature
comes at the cost of the caller who then needs to serialize the
IPIs on this csd.

Lets rename the function and enhance the comments so that they reflect
these properties.

Suggested-by: Christoph Hellwig 
Cc: Andrew Morton 
Cc: Christoph Hellwig 
Cc: Ingo Molnar 
Cc: Jan Kara 
Cc: Jens Axboe 
Signed-off-by: Frederic Weisbecker 
Signed-off-by: Jens Axboe

smp: Remove wait argument from __smp_call_function_single()

2014-02-24T22:47:09+00:00

The main point of calling __smp_call_function_single() is to send
an IPI in a pure asynchronous way. By embedding a csd in an object,
a caller can send the IPI without waiting for a previous one to complete
as is required by smp_call_function_single() for example. As such,
sending this kind of IPI can be safe even when irqs are disabled.

This flexibility comes at the expense of the caller who then needs to
synchronize the csd lifecycle by himself and make sure that IPIs on a
single csd are serialized.

This is how __smp_call_function_single() works when wait = 0 and this
usecase is relevant.

Now there don't seem to be any usecase with wait = 1 that can't be
covered by smp_call_function_single() instead, which is safer. Lets look
at the two possible scenario:

1) The user calls __smp_call_function_single(wait = 1) on a csd embedded
   in an object. It looks like a nice and convenient pattern at the first
   sight because we can then retrieve the object from the IPI handler easily.

   But actually it is a waste of memory space in the object since the csd
   can be allocated from the stack by smp_call_function_single(wait = 1)
   and the object can be passed an the IPI argument.

   Besides that, embedding the csd in an object is more error prone
   because the caller must take care of the serialization of the IPIs
   for this csd.

2) The user calls __smp_call_function_single(wait = 1) on a csd that
   is allocated on the stack. It's ok but smp_call_function_single()
   can do it as well and it already takes care of the allocation on the
   stack. Again it's more simple and less error prone.

Therefore, using the underscore prepend API version with wait = 1
is a bad pattern and a sign that the caller can do safer and more
simple.

There was a single user of that which has just been converted.
So lets remove this option to discourage further users.

Cc: Andrew Morton 
Cc: Christoph Hellwig 
Cc: Ingo Molnar 
Cc: Jan Kara 
Cc: Jens Axboe 
Signed-off-by: Frederic Weisbecker 
Signed-off-by: Jens Axboe