Merge branch 'linus' into sched/core, to pick up fixes

	Macbook Pro 17", iMac 20" :

		video=efifb:i20

Accepted options:

nowc	Don't map the framebuffer write combined. This can be used

	to workaround side-effects and slowdowns on other CPU cores

	when large amounts of console data are written.

--

Edgar Hucek <gimli@dark-green.com>

	bridge link set dev DEV learning on self

	bridge link set dev DEV learning_sync on self

Learning_sync attribute enables syncing of the learned/forgotton FDB entry to

Learning_sync attribute enables syncing of the learned/forgotten FDB entry to

the bridge's FDB.  It's possible, but not optimal, to enable learning on the

device port and on the bridge port, and disable learning_sync.

port device supports ageing, when the FDB entry expires, it will notify the

driver which in turn will notify the bridge with SWITCHDEV_FDB_DEL.  If the

device does not support ageing, the driver can simulate ageing using a

garbage collection timer to monitor FBD entries.  Expired entries will be

garbage collection timer to monitor FDB entries.  Expired entries will be

notified to the bridge using SWITCHDEV_FDB_DEL.  See rocker driver for

example of driver running ageing timer.

	%ps	versatile_init

	%pB	prev_fn_of_versatile_init+0x88/0x88

For printing symbols and function pointers. The ``S`` and ``s`` specifiers

result in the symbol name with (``S``) or without (``s``) offsets. Where

this is used on a kernel without KALLSYMS - the symbol address is

printed instead.

The ``F`` and ``f`` specifiers are for printing function pointers,

for example, f->func, &gettimeofday. They have the same result as

``S`` and ``s`` specifiers. But they do an extra conversion on

ia64, ppc64 and parisc64 architectures where the function pointers

are actually function descriptors.

The ``S`` and ``s`` specifiers can be used for printing symbols

from direct addresses, for example, __builtin_return_address(0),

(void *)regs->ip. They result in the symbol name with (``S``) or

without (``s``) offsets. If KALLSYMS are disabled then the symbol

address is printed instead.

The ``B`` specifier results in the symbol name with offsets and should be

used when printing stack backtraces. The specifier takes into

consideration the effect of compiler optimisations which may occur

when tail-call``s are used and marked with the noreturn GCC attribute.

On ia64, ppc64 and parisc64 architectures function pointers are

actually function descriptors which must first be resolved. The ``F`` and

``f`` specifiers perform this resolution and then provide the same

functionality as the ``S`` and ``s`` specifiers.

Kernel Pointers

===============

bpf_jit_enable

--------------

This enables Berkeley Packet Filter Just in Time compiler.

Currently supported on x86_64 architecture, bpf_jit provides a framework

to speed packet filtering, the one used by tcpdump/libpcap for example.

This enables the BPF Just in Time (JIT) compiler. BPF is a flexible

and efficient infrastructure allowing to execute bytecode at various

hook points. It is used in a number of Linux kernel subsystems such

as networking (e.g. XDP, tc), tracing (e.g. kprobes, uprobes, tracepoints)

and security (e.g. seccomp). LLVM has a BPF back end that can compile

restricted C into a sequence of BPF instructions. After program load

through bpf(2) and passing a verifier in the kernel, a JIT will then

translate these BPF proglets into native CPU instructions. There are

two flavors of JITs, the newer eBPF JIT currently supported on:

  - x86_64

  - arm64

  - ppc64

  - sparc64

  - mips64

  - s390x

And the older cBPF JIT supported on the following archs:

  - arm

  - mips

  - ppc

  - sparc

eBPF JITs are a superset of cBPF JITs, meaning the kernel will

migrate cBPF instructions into eBPF instructions and then JIT

compile them transparently. Older cBPF JITs can only translate

tcpdump filters, seccomp rules, etc, but not mentioned eBPF

programs loaded through bpf(2).

Values :

	0 - disable the JIT (default value)

	1 - enable the JIT

bpf_jit_harden

--------------

This enables hardening for the Berkeley Packet Filter Just in Time compiler.

Supported are eBPF JIT backends. Enabling hardening trades off performance,

but can mitigate JIT spraying.

This enables hardening for the BPF JIT compiler. Supported are eBPF

JIT backends. Enabling hardening trades off performance, but can

mitigate JIT spraying.

Values :

	0 - disable JIT hardening (default value)

	1 - enable JIT hardening for unprivileged users only

bpf_jit_kallsyms

----------------

When Berkeley Packet Filter Just in Time compiler is enabled, then compiled

images are unknown addresses to the kernel, meaning they neither show up in

traces nor in /proc/kallsyms. This enables export of these addresses, which

can be used for debugging/tracing. If bpf_jit_harden is enabled, this feature

is disabled.

When BPF JIT compiler is enabled, then compiled images are unknown

addresses to the kernel, meaning they neither show up in traces nor

in /proc/kallsyms. This enables export of these addresses, which can

be used for debugging/tracing. If bpf_jit_harden is enabled, this

feature is disabled.

Values :

	0 - disable JIT kallsyms export (default value)

	1 - enable JIT kallsyms export for privileged users only

L:	linux-kernel@vger.kernel.org

S:	Maintained

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core

T:	git git://git.infradead.org/users/jcooper/linux.git irqchip/core

F:	Documentation/devicetree/bindings/interrupt-controller/

F:	drivers/irqchip/

F:	include/linux/virtio*.h

F:	include/uapi/linux/virtio_*.h

F:	drivers/crypto/virtio/

F:	mm/balloon_compaction.c

VIRTIO CRYPTO DRIVER

M:	Gonglei <arei.gonglei@huawei.com>