Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 105613d7 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge 4.19.251 into android-4.19-stable 



Changes in 4.19.251
	nvdimm: Fix badblocks clear off-by-one error
	dm raid: fix accesses beyond end of raid member array
	dm raid: fix KASAN warning in raid5_add_disks
	s390/archrandom: simplify back to earlier design and initialize earlier
	SUNRPC: Fix READ_PLUS crasher
	net: rose: fix UAF bugs caused by timer handler
	net: usb: ax88179_178a: Fix packet receiving
	virtio-net: fix race between ndo_open() and virtio_device_ready()
	selftests/net: pass ipv6_args to udpgso_bench's IPv6 TCP test
	net: tun: unlink NAPI from device on destruction
	net: tun: stop NAPI when detaching queues
	RDMA/qedr: Fix reporting QP timeout attribute
	usbnet: fix memory allocation in helpers
	net: ipv6: unexport __init-annotated seg6_hmac_net_init()
	caif_virtio: fix race between virtio_device_ready() and ndo_open()
	netfilter: nft_dynset: restore set element counter when failing to update
	net: bonding: fix possible NULL deref in rlb code
	net: bonding: fix use-after-free after 802.3ad slave unbind
	nfc: nfcmrvl: Fix irq_of_parse_and_map() return value
	NFC: nxp-nci: Don't issue a zero length i2c_master_read()
	net: tun: avoid disabling NAPI twice
	xen/gntdev: Avoid blocking in unmap_grant_pages()
	hwmon: (ibmaem) don't call platform_device_del() if platform_device_add() fails
	net: dsa: bcm_sf2: force pause link settings
	sit: use min
	ipv6/sit: fix ipip6_tunnel_get_prl return value
	xen/blkfront: fix leaking data in shared pages
	xen/netfront: fix leaking data in shared pages
	xen/netfront: force data bouncing when backend is untrusted
	xen/blkfront: force data bouncing when backend is untrusted
	xen/arm: Fix race in RB-tree based P2M accounting
	net: usb: qmi_wwan: add Telit 0x1060 composition
	net: usb: qmi_wwan: add Telit 0x1070 composition
	Linux 4.19.251

Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
Change-Id: Ie9952c1de1287952d707e7b5aafef9f4d39cdd2d
parents b0e86f3e 2283d8a4

Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

VERSION = 4

PATCHLEVEL = 19

SUBLEVEL = 250

SUBLEVEL = 251

EXTRAVERSION =

NAME = "People's Front"

arch/arm/xen/p2m.c

+4 −2
Original line number Diff line number Diff line
@@ -61,11 +61,12 @@ static int xen_add_phys_to_mach_entry(struct xen_p2m_entry *new) 


unsigned long __pfn_to_mfn(unsigned long pfn)

{

	struct rb_node *n = phys_to_mach.rb_node;

	struct rb_node *n;

	struct xen_p2m_entry *entry;

	unsigned long irqflags;



	read_lock_irqsave(&p2m_lock, irqflags);

	n = phys_to_mach.rb_node;

	while (n) {

		entry = rb_entry(n, struct xen_p2m_entry, rbnode_phys);

		if (entry->pfn <= pfn &&
@@ -151,10 +152,11 @@ bool __set_phys_to_machine_multi(unsigned long pfn, 
	int rc;

	unsigned long irqflags;

	struct xen_p2m_entry *p2m_entry;

	struct rb_node *n = phys_to_mach.rb_node;

	struct rb_node *n;



	if (mfn == INVALID_P2M_ENTRY) {

		write_lock_irqsave(&p2m_lock, irqflags);

		n = phys_to_mach.rb_node;

		while (n) {

			p2m_entry = rb_entry(n, struct xen_p2m_entry, rbnode_phys);

			if (p2m_entry->pfn <= pfn &&

arch/s390/crypto/arch_random.c

+1 −110
Original line number Diff line number Diff line
@@ -2,126 +2,17 @@ 
/*

 * s390 arch random implementation.

 *

 * Copyright IBM Corp. 2017, 2018

 * Copyright IBM Corp. 2017, 2020

 * Author(s): Harald Freudenberger

 *

 * The s390_arch_random_generate() function may be called from random.c

 * in interrupt context. So this implementation does the best to be very

 * fast. There is a buffer of random data which is asynchronously checked

 * and filled by a workqueue thread.

 * If there are enough bytes in the buffer the s390_arch_random_generate()

 * just delivers these bytes. Otherwise false is returned until the

 * worker thread refills the buffer.

 * The worker fills the rng buffer by pulling fresh entropy from the

 * high quality (but slow) true hardware random generator. This entropy

 * is then spread over the buffer with an pseudo random generator PRNG.

 * As the arch_get_random_seed_long() fetches 8 bytes and the calling

 * function add_interrupt_randomness() counts this as 1 bit entropy the

 * distribution needs to make sure there is in fact 1 bit entropy contained

 * in 8 bytes of the buffer. The current values pull 32 byte entropy

 * and scatter this into a 2048 byte buffer. So 8 byte in the buffer

 * will contain 1 bit of entropy.

 * The worker thread is rescheduled based on the charge level of the

 * buffer but at least with 500 ms delay to avoid too much CPU consumption.

 * So the max. amount of rng data delivered via arch_get_random_seed is

 * limited to 4k bytes per second.

 */



#include <linux/kernel.h>

#include <linux/atomic.h>

#include <linux/random.h>

#include <linux/slab.h>

#include <linux/static_key.h>

#include <linux/workqueue.h>

#include <asm/cpacf.h>



DEFINE_STATIC_KEY_FALSE(s390_arch_random_available);



atomic64_t s390_arch_random_counter = ATOMIC64_INIT(0);

EXPORT_SYMBOL(s390_arch_random_counter);
 


#define ARCH_REFILL_TICKS (HZ/2)

#define ARCH_PRNG_SEED_SIZE 32

#define ARCH_RNG_BUF_SIZE 2048



static DEFINE_SPINLOCK(arch_rng_lock);

static u8 *arch_rng_buf;

static unsigned int arch_rng_buf_idx;



static void arch_rng_refill_buffer(struct work_struct *);

static DECLARE_DELAYED_WORK(arch_rng_work, arch_rng_refill_buffer);



bool s390_arch_random_generate(u8 *buf, unsigned int nbytes)

{

	/* max hunk is ARCH_RNG_BUF_SIZE */

	if (nbytes > ARCH_RNG_BUF_SIZE)

		return false;



	/* lock rng buffer */

	if (!spin_trylock(&arch_rng_lock))

		return false;



	/* try to resolve the requested amount of bytes from the buffer */

	arch_rng_buf_idx -= nbytes;

	if (arch_rng_buf_idx < ARCH_RNG_BUF_SIZE) {

		memcpy(buf, arch_rng_buf + arch_rng_buf_idx, nbytes);

		atomic64_add(nbytes, &s390_arch_random_counter);

		spin_unlock(&arch_rng_lock);

		return true;

	}



	/* not enough bytes in rng buffer, refill is done asynchronously */

	spin_unlock(&arch_rng_lock);



	return false;

}

EXPORT_SYMBOL(s390_arch_random_generate);



static void arch_rng_refill_buffer(struct work_struct *unused)

{

	unsigned int delay = ARCH_REFILL_TICKS;



	spin_lock(&arch_rng_lock);

	if (arch_rng_buf_idx > ARCH_RNG_BUF_SIZE) {

		/* buffer is exhausted and needs refill */

		u8 seed[ARCH_PRNG_SEED_SIZE];

		u8 prng_wa[240];

		/* fetch ARCH_PRNG_SEED_SIZE bytes of entropy */

		cpacf_trng(NULL, 0, seed, sizeof(seed));

		/* blow this entropy up to ARCH_RNG_BUF_SIZE with PRNG */

		memset(prng_wa, 0, sizeof(prng_wa));

		cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED,

			   &prng_wa, NULL, 0, seed, sizeof(seed));

		cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN,

			   &prng_wa, arch_rng_buf, ARCH_RNG_BUF_SIZE, NULL, 0);

		arch_rng_buf_idx = ARCH_RNG_BUF_SIZE;

	}

	delay += (ARCH_REFILL_TICKS * arch_rng_buf_idx) / ARCH_RNG_BUF_SIZE;

	spin_unlock(&arch_rng_lock);



	/* kick next check */

	queue_delayed_work(system_long_wq, &arch_rng_work, delay);

}



static int __init s390_arch_random_init(void)

{

	/* all the needed PRNO subfunctions available ? */

	if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG) &&

	    cpacf_query_func(CPACF_PRNO, CPACF_PRNO_SHA512_DRNG_GEN)) {



		/* alloc arch random working buffer */

		arch_rng_buf = kmalloc(ARCH_RNG_BUF_SIZE, GFP_KERNEL);

		if (!arch_rng_buf)

			return -ENOMEM;



		/* kick worker queue job to fill the random buffer */

		queue_delayed_work(system_long_wq,

				   &arch_rng_work, ARCH_REFILL_TICKS);



		/* enable arch random to the outside world */

		static_branch_enable(&s390_arch_random_available);

	}



	return 0;

}

arch_initcall(s390_arch_random_init);

arch/s390/include/asm/archrandom.h

+12 −9
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
/*

 * Kernel interface for the s390 arch_random_* functions

 *

 * Copyright IBM Corp. 2017

 * Copyright IBM Corp. 2017, 2020

 *

 * Author: Harald Freudenberger <freude@de.ibm.com>

 *
@@ -15,34 +15,37 @@ 


#include <linux/static_key.h>

#include <linux/atomic.h>

#include <asm/cpacf.h>



DECLARE_STATIC_KEY_FALSE(s390_arch_random_available);

extern atomic64_t s390_arch_random_counter;



bool s390_arch_random_generate(u8 *buf, unsigned int nbytes);



static inline bool arch_get_random_long(unsigned long *v)

static inline bool __must_check arch_get_random_long(unsigned long *v)

{

	return false;

}



static inline bool arch_get_random_int(unsigned int *v)

static inline bool __must_check arch_get_random_int(unsigned int *v)

{

	return false;

}



static inline bool arch_get_random_seed_long(unsigned long *v)

static inline bool __must_check arch_get_random_seed_long(unsigned long *v)

{

	if (static_branch_likely(&s390_arch_random_available)) {

		return s390_arch_random_generate((u8 *)v, sizeof(*v));

		cpacf_trng(NULL, 0, (u8 *)v, sizeof(*v));

		atomic64_add(sizeof(*v), &s390_arch_random_counter);

		return true;

	}

	return false;

}



static inline bool arch_get_random_seed_int(unsigned int *v)

static inline bool __must_check arch_get_random_seed_int(unsigned int *v)

{

	if (static_branch_likely(&s390_arch_random_available)) {

		return s390_arch_random_generate((u8 *)v, sizeof(*v));

		cpacf_trng(NULL, 0, (u8 *)v, sizeof(*v));

		atomic64_add(sizeof(*v), &s390_arch_random_counter);

		return true;

	}

	return false;

}

arch/s390/kernel/setup.c

+5 −0
Original line number Diff line number Diff line
@@ -851,6 +851,11 @@ static void __init setup_randomness(void) 
	if (stsi(vmms, 3, 2, 2) == 0 && vmms->count)

		add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count);

	memblock_free((unsigned long) vmms, PAGE_SIZE);



#ifdef CONFIG_ARCH_RANDOM

	if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))

		static_branch_enable(&s390_arch_random_available);

#endif

}



/*