This is the 4.9.185 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl0lmgMACgkQONu9yGCS
aT6xqhAAtn87S6SThYc2y6eQP/svHHCy7PGabWQm4RjnWnO2JAZkfJ3iIj+mgnqF
umL7zINXVtkZ3G4BiQzOdMcuKE9cBDpHIJTicOEa/lHKLuDw5FscDeW8SGsR7T4/
1OR1/55JA0R90Lew+Bzs8A9O1b525/35RQtxyOzFxZvl4xAgxUMrTJtSctMCJhSU
MhzpxuIkvRCfWnlqbxLGKimv8UEcs9JwZlZKmAt+oTkbBeit2JWNJy5+w7Ln4g2N
SVASZDg1/oad+jGzIHrT5fJs6ZC8EtH111xIUaS8Got/E5GCxG4qOMKOWFxf6Mag
jy+YvzsAw06yIY7IxZbKpS1LJNTkNekH+8hKpTgf4wuWaUkakIJchnw+att4QpVz
P8g/BG85DvrTzCIiKmYBEvsw9l9+Utb7iTpKeGvlw1+KmJnF1fu8ZEQQ9tOOr5VB
w5HaqeMDRBz3twg/tf/SpEzI6PJgSQxLS4fwEYLkGEWrEBY9VqZ+sRtjIbWay2rG
JeFFwiIDcF3pXrE7MtpTvYTYUGcxvtbAj49KViSs0BtWkhszcMgTEwLFSYL0LoYF
La1NhfL7GnkZtyTEworvr7NXU7x/yMfvvSSdoVTpimkGUuGyD3VMILe11b6QDGzu
CBfr09uJAtEGtAn59ZSXJvmqwAYwKrmcfvTqQ3S3lZsxXWV2CLw=
=WDg7
-----END PGP SIGNATURE-----
Merge 4.9.185 into android-4.9
Changes in 4.9.185
tracing: Silence GCC 9 array bounds warning
gcc-9: silence 'address-of-packed-member' warning
scsi: ufs: Avoid runtime suspend possibly being blocked forever
usb: chipidea: udc: workaround for endpoint conflict issue
IB/hfi1: Silence txreq allocation warnings
Input: uinput - add compat ioctl number translation for UI_*_FF_UPLOAD
apparmor: enforce nullbyte at end of tag string
ARC: fix build warnings with !CONFIG_KPROBES
parport: Fix mem leak in parport_register_dev_model
parisc: Fix compiler warnings in float emulation code
IB/rdmavt: Fix alloc_qpn() WARN_ON()
IB/hfi1: Insure freeze_work work_struct is canceled on shutdown
IB/{qib, hfi1, rdmavt}: Correct ibv_devinfo max_mr value
MIPS: uprobes: remove set but not used variable 'epc'
net: dsa: mv88e6xxx: avoid error message on remove from VLAN 0
net: hns: Fix loopback test failed at copper ports
sparc: perf: fix updated event period in response to PERF_EVENT_IOC_PERIOD
net: ethernet: mediatek: Use hw_feature to judge if HWLRO is supported
net: ethernet: mediatek: Use NET_IP_ALIGN to judge if HW RX_2BYTE_OFFSET is enabled
drm/arm/hdlcd: Allow a bit of clock tolerance
scripts/checkstack.pl: Fix arm64 wrong or unknown architecture
scsi: ufs: Check that space was properly alloced in copy_query_response
s390/qeth: fix VLAN attribute in bridge_hostnotify udev event
hwmon: (pmbus/core) Treat parameters as paged if on multiple pages
nvme: Fix u32 overflow in the number of namespace list calculation
btrfs: start readahead also in seed devices
can: flexcan: fix timeout when set small bitrate
can: purge socket error queue on sock destruct
powerpc/bpf: use unsigned division instruction for 64-bit operations
ARM: imx: cpuidle-imx6sx: Restrict the SW2ISO increase to i.MX6SX
Bluetooth: Align minimum encryption key size for LE and BR/EDR connections
Bluetooth: Fix regression with minimum encryption key size alignment
cfg80211: fix memory leak of wiphy device name
mac80211: drop robust management frames from unknown TA
mac80211: Do not use stack memory with scatterlist for GMAC
IB/hfi1: Avoid hardlockup with flushlist_lock
perf ui helpline: Use strlcpy() as a shorter form of strncpy() + explicit set nul
perf help: Remove needless use of strncpy()
perf header: Fix unchecked usage of strncpy()
9p/rdma: do not disconnect on down_interruptible EAGAIN
9p: acl: fix uninitialized iattr access
9p/rdma: remove useless check in cm_event_handler
9p: p9dirent_read: check network-provided name length
net/9p: include trans_common.h to fix missing prototype warning.
fs/proc/array.c: allow reporting eip/esp for all coredumping threads
fs/binfmt_flat.c: make load_flat_shared_library() work
mm/page_idle.c: fix oops because end_pfn is larger than max_pfn
scsi: vmw_pscsi: Fix use-after-free in pvscsi_queue_lck()
x86/speculation: Allow guests to use SSBD even if host does not
NFS/flexfiles: Use the correct TCP timeout for flexfiles I/O
cpu/speculation: Warn on unsupported mitigations= parameter
af_packet: Block execution of tasks waiting for transmit to complete in AF_PACKET
net: stmmac: fixed new system time seconds value calculation
sctp: change to hold sk after auth shkey is created successfully
tipc: change to use register_pernet_device
tipc: check msg->req data len in tipc_nl_compat_bearer_disable
tun: wake up waitqueues after IFF_UP is set
team: Always enable vlan tx offload
bonding: Always enable vlan tx offload
ipv4: Use return value of inet_iif() for __raw_v4_lookup in the while loop
net: check before dereferencing netdev_ops during busy poll
bpf: udp: Avoid calling reuseport's bpf_prog from udp_gro
bpf: udp: ipv6: Avoid running reuseport's bpf_prog from __udp6_lib_err
tipc: pass tunnel dev as NULL to udp_tunnel(6)_xmit_skb
Bluetooth: Fix faulty expression for minimum encryption key size check
ASoC : cs4265 : readable register too low
ASoC: soc-pcm: BE dai needs prepare when pause release after resume
spi: bitbang: Fix NULL pointer dereference in spi_unregister_master
drm/mediatek: fix unbind functions
ASoC: max98090: remove 24-bit format support if RJ is 0
usb: gadget: fusb300_udc: Fix memory leak of fusb300->ep[i]
usb: gadget: udc: lpc32xx: allocate descriptor with GFP_ATOMIC
scsi: hpsa: correct ioaccel2 chaining
scripts/decode_stacktrace.sh: prefix addr2line with $CROSS_COMPILE
mm/mlock.c: change count_mm_mlocked_page_nr return type
MIPS: math-emu: do not use bools for arithmetic
MIPS: netlogic: xlr: Remove erroneous check in nlm_fmn_send()
mfd: omap-usb-tll: Fix register offsets
ARC: fix allnoconfig build warning
bug.h: work around GCC PR82365 in BUG()
ARC: handle gcc generated __builtin_trap for older compiler
clk: sunxi: fix uninitialized access
KVM: x86: degrade WARN to pr_warn_ratelimited
drm/i915/dmc: protect against reading random memory
MIPS: Workaround GCC __builtin_unreachable reordering bug
ptrace: Fix ->ptracer_cred handling for PTRACE_TRACEME
crypto: user - prevent operating on larval algorithms
ALSA: seq: fix incorrect order of dest_client/dest_ports arguments
ALSA: firewire-lib/fireworks: fix miss detection of received MIDI messages
ALSA: line6: Fix write on zero-sized buffer
ALSA: usb-audio: fix sign unintended sign extension on left shifts
lib/mpi: Fix karactx leak in mpi_powm
drm/imx: notify drm core before sending event during crtc disable
drm/imx: only send event on crtc disable if kept disabled
btrfs: Ensure replaced device doesn't have pending chunk allocation
tty: rocket: fix incorrect forward declaration of 'rp_init()'
arm64, vdso: Define vdso_{start,end} as array
KVM: LAPIC: Fix pending interrupt in IRR blocked by software disable LAPIC
IB/hfi1: Close PSM sdma_progress sleep window
MIPS: Add missing EHB in mtc0 -> mfc0 sequence.
dmaengine: imx-sdma: remove BD_INTR for channel0
arm64: kaslr: keep modules inside module region when KASAN is enabled
Linux 4.9.185
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
70d52cb2bb
4
Makefile
4
Makefile
|
|
@ -1,6 +1,6 @@
|
|||
VERSION = 4
|
||||
PATCHLEVEL = 9
|
||||
SUBLEVEL = 184
|
||||
SUBLEVEL = 185
|
||||
EXTRAVERSION =
|
||||
NAME = Roaring Lionus
|
||||
|
||||
|
|
@ -668,6 +668,7 @@ KBUILD_CFLAGS += $(call cc-disable-warning,frame-address,)
|
|||
KBUILD_CFLAGS += $(call cc-disable-warning, format-truncation)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, format-overflow)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, int-in-bool-context)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, attribute-alias)
|
||||
|
||||
ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION
|
||||
|
|
@ -786,7 +787,6 @@ ifeq ($(cc-name),clang)
|
|||
KBUILD_CPPFLAGS += $(call cc-option,-Qunused-arguments,)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, gnu)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, duplicate-decl-specifier)
|
||||
# Quiet clang warning: comparison of unsigned expression < 0 is always false
|
||||
KBUILD_CFLAGS += $(call cc-disable-warning, tautological-compare)
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ config ARC
|
|||
select GENERIC_SMP_IDLE_THREAD
|
||||
select HAVE_ARCH_KGDB
|
||||
select HAVE_ARCH_TRACEHOOK
|
||||
select HAVE_FUTEX_CMPXCHG
|
||||
select HAVE_FUTEX_CMPXCHG if FUTEX
|
||||
select HAVE_IOREMAP_PROT
|
||||
select HAVE_KPROBES
|
||||
select HAVE_KRETPROBES
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ void die(const char *str, struct pt_regs *regs, unsigned long address);
|
|||
|
||||
#define BUG() do { \
|
||||
pr_warn("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
|
||||
dump_stack(); \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_trap(); \
|
||||
} while (0)
|
||||
|
||||
#define HAVE_ARCH_BUG
|
||||
|
|
|
|||
|
|
@ -92,8 +92,11 @@ __cmpxchg(volatile void *ptr, unsigned long expected, unsigned long new)
|
|||
|
||||
#endif /* CONFIG_ARC_HAS_LLSC */
|
||||
|
||||
#define cmpxchg(ptr, o, n) ((typeof(*(ptr)))__cmpxchg((ptr), \
|
||||
(unsigned long)(o), (unsigned long)(n)))
|
||||
#define cmpxchg(ptr, o, n) ({ \
|
||||
(typeof(*(ptr)))__cmpxchg((ptr), \
|
||||
(unsigned long)(o), \
|
||||
(unsigned long)(n)); \
|
||||
})
|
||||
|
||||
/*
|
||||
* atomic_cmpxchg is same as cmpxchg
|
||||
|
|
@ -198,8 +201,11 @@ static inline unsigned long __xchg(unsigned long val, volatile void *ptr,
|
|||
return __xchg_bad_pointer();
|
||||
}
|
||||
|
||||
#define xchg(ptr, with) ((typeof(*(ptr)))__xchg((unsigned long)(with), (ptr), \
|
||||
sizeof(*(ptr))))
|
||||
#define xchg(ptr, with) ({ \
|
||||
(typeof(*(ptr)))__xchg((unsigned long)(with), \
|
||||
(ptr), \
|
||||
sizeof(*(ptr))); \
|
||||
})
|
||||
|
||||
#endif /* CONFIG_ARC_PLAT_EZNPS */
|
||||
|
||||
|
|
|
|||
|
|
@ -155,3 +155,11 @@ void do_insterror_or_kprobe(unsigned long address, struct pt_regs *regs)
|
|||
|
||||
insterror_is_error(address, regs);
|
||||
}
|
||||
|
||||
/*
|
||||
* abort() call generated by older gcc for __builtin_trap()
|
||||
*/
|
||||
void abort(void)
|
||||
{
|
||||
__asm__ __volatile__("trap_s 5\n");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -890,9 +890,11 @@ void do_tlb_overlap_fault(unsigned long cause, unsigned long address,
|
|||
struct pt_regs *regs)
|
||||
{
|
||||
struct cpuinfo_arc_mmu *mmu = &cpuinfo_arc700[smp_processor_id()].mmu;
|
||||
unsigned int pd0[mmu->ways];
|
||||
unsigned long flags;
|
||||
int set;
|
||||
int set, n_ways = mmu->ways;
|
||||
|
||||
n_ways = min(n_ways, 4);
|
||||
BUG_ON(mmu->ways > 4);
|
||||
|
||||
local_irq_save(flags);
|
||||
|
||||
|
|
@ -900,9 +902,10 @@ void do_tlb_overlap_fault(unsigned long cause, unsigned long address,
|
|||
for (set = 0; set < mmu->sets; set++) {
|
||||
|
||||
int is_valid, way;
|
||||
unsigned int pd0[4];
|
||||
|
||||
/* read out all the ways of current set */
|
||||
for (way = 0, is_valid = 0; way < mmu->ways; way++) {
|
||||
for (way = 0, is_valid = 0; way < n_ways; way++) {
|
||||
write_aux_reg(ARC_REG_TLBINDEX,
|
||||
SET_WAY_TO_IDX(mmu, set, way));
|
||||
write_aux_reg(ARC_REG_TLBCOMMAND, TLBRead);
|
||||
|
|
@ -916,14 +919,14 @@ void do_tlb_overlap_fault(unsigned long cause, unsigned long address,
|
|||
continue;
|
||||
|
||||
/* Scan the set for duplicate ways: needs a nested loop */
|
||||
for (way = 0; way < mmu->ways - 1; way++) {
|
||||
for (way = 0; way < n_ways - 1; way++) {
|
||||
|
||||
int n;
|
||||
|
||||
if (!pd0[way])
|
||||
continue;
|
||||
|
||||
for (n = way + 1; n < mmu->ways; n++) {
|
||||
for (n = way + 1; n < n_ways; n++) {
|
||||
if (pd0[way] != pd0[n])
|
||||
continue;
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
|
||||
#include "common.h"
|
||||
#include "cpuidle.h"
|
||||
#include "hardware.h"
|
||||
|
||||
static int imx6sx_idle_finish(unsigned long val)
|
||||
{
|
||||
|
|
@ -108,7 +109,7 @@ int __init imx6sx_cpuidle_init(void)
|
|||
* except for power up sw2iso which need to be
|
||||
* larger than LDO ramp up time.
|
||||
*/
|
||||
imx_gpc_set_arm_power_up_timing(0xf, 1);
|
||||
imx_gpc_set_arm_power_up_timing(cpu_is_imx6sx() ? 0xf : 0x2, 1);
|
||||
imx_gpc_set_arm_power_down_timing(1, 1);
|
||||
|
||||
return cpuidle_register(&imx6sx_cpuidle_driver, NULL);
|
||||
|
|
|
|||
|
|
@ -33,10 +33,14 @@
|
|||
void *module_alloc(unsigned long size)
|
||||
{
|
||||
void *p;
|
||||
u64 module_alloc_end = module_alloc_base + MODULES_VSIZE;
|
||||
|
||||
if (IS_ENABLED(CONFIG_KASAN))
|
||||
/* don't exceed the static module region - see below */
|
||||
module_alloc_end = MODULES_END;
|
||||
|
||||
p = __vmalloc_node_range(size, MODULE_ALIGN, module_alloc_base,
|
||||
module_alloc_base + MODULES_VSIZE,
|
||||
GFP_KERNEL, PAGE_KERNEL_EXEC, 0,
|
||||
module_alloc_end, GFP_KERNEL, PAGE_KERNEL_EXEC, 0,
|
||||
NUMA_NO_NODE, __builtin_return_address(0));
|
||||
|
||||
if (!p && IS_ENABLED(CONFIG_ARM64_MODULE_PLTS) &&
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
#include <asm/vdso.h>
|
||||
#include <asm/vdso_datapage.h>
|
||||
|
||||
extern char vdso_start, vdso_end;
|
||||
extern char vdso_start[], vdso_end[];
|
||||
static unsigned long vdso_pages __ro_after_init;
|
||||
|
||||
/*
|
||||
|
|
@ -125,14 +125,14 @@ static int __init vdso_init(void)
|
|||
struct page **vdso_pagelist;
|
||||
unsigned long pfn;
|
||||
|
||||
if (memcmp(&vdso_start, "\177ELF", 4)) {
|
||||
if (memcmp(vdso_start, "\177ELF", 4)) {
|
||||
pr_err("vDSO is not a valid ELF object!\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
vdso_pages = (&vdso_end - &vdso_start) >> PAGE_SHIFT;
|
||||
vdso_pages = (vdso_end - vdso_start) >> PAGE_SHIFT;
|
||||
pr_info("vdso: %ld pages (%ld code @ %p, %ld data @ %p)\n",
|
||||
vdso_pages + 1, vdso_pages, &vdso_start, 1L, vdso_data);
|
||||
vdso_pages + 1, vdso_pages, vdso_start, 1L, vdso_data);
|
||||
|
||||
/* Allocate the vDSO pagelist, plus a page for the data. */
|
||||
vdso_pagelist = kcalloc(vdso_pages + 1, sizeof(struct page *),
|
||||
|
|
@ -145,7 +145,7 @@ static int __init vdso_init(void)
|
|||
|
||||
|
||||
/* Grab the vDSO code pages. */
|
||||
pfn = sym_to_pfn(&vdso_start);
|
||||
pfn = sym_to_pfn(vdso_start);
|
||||
|
||||
for (i = 0; i < vdso_pages; i++)
|
||||
vdso_pagelist[i + 1] = pfn_to_page(pfn + i);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,11 @@
|
|||
|
||||
#ifdef CONFIG_BUG
|
||||
#define ia64_abort() __builtin_trap()
|
||||
#define BUG() do { printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); ia64_abort(); } while (0)
|
||||
#define BUG() do { \
|
||||
printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
|
||||
barrier_before_unreachable(); \
|
||||
ia64_abort(); \
|
||||
} while (0)
|
||||
|
||||
/* should this BUG be made generic? */
|
||||
#define HAVE_ARCH_BUG
|
||||
|
|
|
|||
|
|
@ -7,16 +7,19 @@
|
|||
#ifndef CONFIG_SUN3
|
||||
#define BUG() do { \
|
||||
printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_trap(); \
|
||||
} while (0)
|
||||
#else
|
||||
#define BUG() do { \
|
||||
printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
|
||||
barrier_before_unreachable(); \
|
||||
panic("BUG!"); \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define BUG() do { \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_trap(); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ config MIPS
|
|||
select HAVE_OPROFILE
|
||||
select HAVE_PERF_EVENTS
|
||||
select PERF_USE_VMALLOC
|
||||
select HAVE_ARCH_COMPILER_H
|
||||
select HAVE_ARCH_KGDB
|
||||
select HAVE_ARCH_SECCOMP_FILTER
|
||||
select HAVE_ARCH_TRACEHOOK
|
||||
|
|
|
|||
|
|
@ -8,6 +8,41 @@
|
|||
#ifndef _ASM_COMPILER_H
|
||||
#define _ASM_COMPILER_H
|
||||
|
||||
/*
|
||||
* With GCC 4.5 onwards we can use __builtin_unreachable to indicate to the
|
||||
* compiler that a particular code path will never be hit. This allows it to be
|
||||
* optimised out of the generated binary.
|
||||
*
|
||||
* Unfortunately at least GCC 4.6.3 through 7.3.0 inclusive suffer from a bug
|
||||
* that can lead to instructions from beyond an unreachable statement being
|
||||
* incorrectly reordered into earlier delay slots if the unreachable statement
|
||||
* is the only content of a case in a switch statement. This can lead to
|
||||
* seemingly random behaviour, such as invalid memory accesses from incorrectly
|
||||
* reordered loads or stores. See this potential GCC fix for details:
|
||||
*
|
||||
* https://gcc.gnu.org/ml/gcc-patches/2015-09/msg00360.html
|
||||
*
|
||||
* It is unclear whether GCC 8 onwards suffer from the same issue - nothing
|
||||
* relevant is mentioned in GCC 8 release notes and nothing obviously relevant
|
||||
* stands out in GCC commit logs, but these newer GCC versions generate very
|
||||
* different code for the testcase which doesn't exhibit the bug.
|
||||
*
|
||||
* GCC also handles stack allocation suboptimally when calling noreturn
|
||||
* functions or calling __builtin_unreachable():
|
||||
*
|
||||
* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82365
|
||||
*
|
||||
* We work around both of these issues by placing a volatile asm statement,
|
||||
* which GCC is prevented from reordering past, prior to __builtin_unreachable
|
||||
* calls.
|
||||
*
|
||||
* The .insn statement is required to ensure that any branches to the
|
||||
* statement, which sadly must be kept due to the asm statement, are known to
|
||||
* be branches to code and satisfy linker requirements for microMIPS kernels.
|
||||
*/
|
||||
#undef barrier_before_unreachable
|
||||
#define barrier_before_unreachable() asm volatile(".insn")
|
||||
|
||||
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
|
||||
#define GCC_IMM_ASM() "n"
|
||||
#define GCC_REG_ACCUM "$0"
|
||||
|
|
|
|||
|
|
@ -301,8 +301,6 @@ static inline int nlm_fmn_send(unsigned int size, unsigned int code,
|
|||
for (i = 0; i < 8; i++) {
|
||||
nlm_msgsnd(dest);
|
||||
status = nlm_read_c2_status0();
|
||||
if ((status & 0x2) == 1)
|
||||
pr_info("Send pending fail!\n");
|
||||
if ((status & 0x4) == 0)
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -111,9 +111,6 @@ int arch_uprobe_pre_xol(struct arch_uprobe *aup, struct pt_regs *regs)
|
|||
*/
|
||||
aup->resume_epc = regs->cp0_epc + 4;
|
||||
if (insn_has_delay_slot((union mips_instruction) aup->insn[0])) {
|
||||
unsigned long epc;
|
||||
|
||||
epc = regs->cp0_epc;
|
||||
__compute_return_epc_for_insn(regs,
|
||||
(union mips_instruction) aup->insn[0]);
|
||||
aup->resume_epc = regs->cp0_epc;
|
||||
|
|
|
|||
|
|
@ -828,12 +828,12 @@ do { \
|
|||
} while (0)
|
||||
|
||||
#define DIFROMREG(di, x) \
|
||||
((di) = get_fpr64(&ctx->fpr[(x) & ~(cop1_64bit(xcp) == 0)], 0))
|
||||
((di) = get_fpr64(&ctx->fpr[(x) & ~(cop1_64bit(xcp) ^ 1)], 0))
|
||||
|
||||
#define DITOREG(di, x) \
|
||||
do { \
|
||||
unsigned fpr, i; \
|
||||
fpr = (x) & ~(cop1_64bit(xcp) == 0); \
|
||||
fpr = (x) & ~(cop1_64bit(xcp) ^ 1); \
|
||||
set_fpr64(&ctx->fpr[fpr], 0, di); \
|
||||
for (i = 1; i < ARRAY_SIZE(ctx->fpr[x].val64); i++) \
|
||||
set_fpr64(&ctx->fpr[fpr], i, 0); \
|
||||
|
|
|
|||
|
|
@ -386,6 +386,7 @@ static struct work_registers build_get_work_registers(u32 **p)
|
|||
static void build_restore_work_registers(u32 **p)
|
||||
{
|
||||
if (scratch_reg >= 0) {
|
||||
uasm_i_ehb(p);
|
||||
UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
|
||||
return;
|
||||
}
|
||||
|
|
@ -674,10 +675,12 @@ static void build_restore_pagemask(u32 **p, struct uasm_reloc **r,
|
|||
uasm_i_mtc0(p, 0, C0_PAGEMASK);
|
||||
uasm_il_b(p, r, lid);
|
||||
}
|
||||
if (scratch_reg >= 0)
|
||||
if (scratch_reg >= 0) {
|
||||
uasm_i_ehb(p);
|
||||
UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
|
||||
else
|
||||
} else {
|
||||
UASM_i_LW(p, 1, scratchpad_offset(0), 0);
|
||||
}
|
||||
} else {
|
||||
/* Reset default page size */
|
||||
if (PM_DEFAULT_MASK >> 16) {
|
||||
|
|
@ -935,10 +938,12 @@ build_get_pgd_vmalloc64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
|
|||
uasm_i_jr(p, ptr);
|
||||
|
||||
if (mode == refill_scratch) {
|
||||
if (scratch_reg >= 0)
|
||||
if (scratch_reg >= 0) {
|
||||
uasm_i_ehb(p);
|
||||
UASM_i_MFC0(p, 1, c0_kscratch(), scratch_reg);
|
||||
else
|
||||
} else {
|
||||
UASM_i_LW(p, 1, scratchpad_offset(0), 0);
|
||||
}
|
||||
} else {
|
||||
uasm_i_nop(p);
|
||||
}
|
||||
|
|
@ -1238,6 +1243,7 @@ build_fast_tlb_refill_handler (u32 **p, struct uasm_label **l,
|
|||
UASM_i_MTC0(p, odd, C0_ENTRYLO1); /* load it */
|
||||
|
||||
if (c0_scratch_reg >= 0) {
|
||||
uasm_i_ehb(p);
|
||||
UASM_i_MFC0(p, scratch, c0_kscratch(), c0_scratch_reg);
|
||||
build_tlb_write_entry(p, l, r, tlb_random);
|
||||
uasm_l_leave(l, *p);
|
||||
|
|
@ -1592,15 +1598,17 @@ static void build_setup_pgd(void)
|
|||
uasm_i_dinsm(&p, a0, 0, 29, 64 - 29);
|
||||
uasm_l_tlbl_goaround1(&l, p);
|
||||
UASM_i_SLL(&p, a0, a0, 11);
|
||||
uasm_i_jr(&p, 31);
|
||||
UASM_i_MTC0(&p, a0, C0_CONTEXT);
|
||||
uasm_i_jr(&p, 31);
|
||||
uasm_i_ehb(&p);
|
||||
} else {
|
||||
/* PGD in c0_KScratch */
|
||||
uasm_i_jr(&p, 31);
|
||||
if (cpu_has_ldpte)
|
||||
UASM_i_MTC0(&p, a0, C0_PWBASE);
|
||||
else
|
||||
UASM_i_MTC0(&p, a0, c0_kscratch(), pgd_reg);
|
||||
uasm_i_jr(&p, 31);
|
||||
uasm_i_ehb(&p);
|
||||
}
|
||||
#else
|
||||
#ifdef CONFIG_SMP
|
||||
|
|
@ -1614,13 +1622,16 @@ static void build_setup_pgd(void)
|
|||
UASM_i_LA_mostly(&p, a2, pgdc);
|
||||
UASM_i_SW(&p, a0, uasm_rel_lo(pgdc), a2);
|
||||
#endif /* SMP */
|
||||
uasm_i_jr(&p, 31);
|
||||
|
||||
/* if pgd_reg is allocated, save PGD also to scratch register */
|
||||
if (pgd_reg != -1)
|
||||
if (pgd_reg != -1) {
|
||||
UASM_i_MTC0(&p, a0, c0_kscratch(), pgd_reg);
|
||||
else
|
||||
uasm_i_jr(&p, 31);
|
||||
uasm_i_ehb(&p);
|
||||
} else {
|
||||
uasm_i_jr(&p, 31);
|
||||
uasm_i_nop(&p);
|
||||
}
|
||||
#endif
|
||||
if (p >= tlbmiss_handler_setup_pgd_end)
|
||||
panic("tlbmiss_handler_setup_pgd space exceeded");
|
||||
|
|
|
|||
|
|
@ -60,19 +60,19 @@
|
|||
((exponent < (SGL_P - 1)) ? \
|
||||
(Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) : FALSE)
|
||||
|
||||
#define Int_isinexact_to_sgl(int_value) (int_value << 33 - SGL_EXP_LENGTH)
|
||||
#define Int_isinexact_to_sgl(int_value) ((int_value << 33 - SGL_EXP_LENGTH) != 0)
|
||||
|
||||
#define Sgl_roundnearest_from_int(int_value,sgl_value) \
|
||||
if (int_value & 1<<(SGL_EXP_LENGTH - 2)) /* round bit */ \
|
||||
if ((int_value << 34 - SGL_EXP_LENGTH) || Slow(sgl_value)) \
|
||||
if (((int_value << 34 - SGL_EXP_LENGTH) != 0) || Slow(sgl_value)) \
|
||||
Sall(sgl_value)++
|
||||
|
||||
#define Dint_isinexact_to_sgl(dint_valueA,dint_valueB) \
|
||||
((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) || Dintp2(dint_valueB))
|
||||
(((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) != 0) || Dintp2(dint_valueB))
|
||||
|
||||
#define Sgl_roundnearest_from_dint(dint_valueA,dint_valueB,sgl_value) \
|
||||
if (Dintp1(dint_valueA) & 1<<(SGL_EXP_LENGTH - 2)) \
|
||||
if ((Dintp1(dint_valueA) << 34 - SGL_EXP_LENGTH) || \
|
||||
if (((Dintp1(dint_valueA) << 34 - SGL_EXP_LENGTH) != 0) || \
|
||||
Dintp2(dint_valueB) || Slow(sgl_value)) Sall(sgl_value)++
|
||||
|
||||
#define Dint_isinexact_to_dbl(dint_value) \
|
||||
|
|
|
|||
|
|
@ -261,6 +261,7 @@
|
|||
#define PPC_INST_MULLI 0x1c000000
|
||||
#define PPC_INST_DIVWU 0x7c000396
|
||||
#define PPC_INST_DIVD 0x7c0003d2
|
||||
#define PPC_INST_DIVDU 0x7c000392
|
||||
#define PPC_INST_RLWINM 0x54000000
|
||||
#define PPC_INST_RLWIMI 0x50000000
|
||||
#define PPC_INST_RLDICL 0x78000000
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@
|
|||
___PPC_RA(a) | IMM_L(i))
|
||||
#define PPC_DIVWU(d, a, b) EMIT(PPC_INST_DIVWU | ___PPC_RT(d) | \
|
||||
___PPC_RA(a) | ___PPC_RB(b))
|
||||
#define PPC_DIVD(d, a, b) EMIT(PPC_INST_DIVD | ___PPC_RT(d) | \
|
||||
#define PPC_DIVDU(d, a, b) EMIT(PPC_INST_DIVDU | ___PPC_RT(d) | \
|
||||
___PPC_RA(a) | ___PPC_RB(b))
|
||||
#define PPC_AND(d, a, b) EMIT(PPC_INST_AND | ___PPC_RA(d) | \
|
||||
___PPC_RS(a) | ___PPC_RB(b))
|
||||
|
|
|
|||
|
|
@ -419,12 +419,12 @@ static int bpf_jit_build_body(struct bpf_prog *fp, u32 *image,
|
|||
PPC_LI(b2p[BPF_REG_0], 0);
|
||||
PPC_JMP(exit_addr);
|
||||
if (BPF_OP(code) == BPF_MOD) {
|
||||
PPC_DIVD(b2p[TMP_REG_1], dst_reg, src_reg);
|
||||
PPC_DIVDU(b2p[TMP_REG_1], dst_reg, src_reg);
|
||||
PPC_MULD(b2p[TMP_REG_1], src_reg,
|
||||
b2p[TMP_REG_1]);
|
||||
PPC_SUB(dst_reg, dst_reg, b2p[TMP_REG_1]);
|
||||
} else
|
||||
PPC_DIVD(dst_reg, dst_reg, src_reg);
|
||||
PPC_DIVDU(dst_reg, dst_reg, src_reg);
|
||||
break;
|
||||
case BPF_ALU | BPF_MOD | BPF_K: /* (u32) dst %= (u32) imm */
|
||||
case BPF_ALU | BPF_DIV | BPF_K: /* (u32) dst /= (u32) imm */
|
||||
|
|
@ -452,7 +452,7 @@ static int bpf_jit_build_body(struct bpf_prog *fp, u32 *image,
|
|||
break;
|
||||
case BPF_ALU64:
|
||||
if (BPF_OP(code) == BPF_MOD) {
|
||||
PPC_DIVD(b2p[TMP_REG_2], dst_reg,
|
||||
PPC_DIVDU(b2p[TMP_REG_2], dst_reg,
|
||||
b2p[TMP_REG_1]);
|
||||
PPC_MULD(b2p[TMP_REG_1],
|
||||
b2p[TMP_REG_1],
|
||||
|
|
@ -460,7 +460,7 @@ static int bpf_jit_build_body(struct bpf_prog *fp, u32 *image,
|
|||
PPC_SUB(dst_reg, dst_reg,
|
||||
b2p[TMP_REG_1]);
|
||||
} else
|
||||
PPC_DIVD(dst_reg, dst_reg,
|
||||
PPC_DIVDU(dst_reg, dst_reg,
|
||||
b2p[TMP_REG_1]);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,10 +8,14 @@
|
|||
void do_BUG(const char *file, int line);
|
||||
#define BUG() do { \
|
||||
do_BUG(__FILE__, __LINE__); \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_trap(); \
|
||||
} while (0)
|
||||
#else
|
||||
#define BUG() __builtin_trap()
|
||||
#define BUG() do { \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_trap(); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#define HAVE_ARCH_BUG
|
||||
|
|
|
|||
|
|
@ -889,6 +889,10 @@ static int sparc_perf_event_set_period(struct perf_event *event,
|
|||
s64 period = hwc->sample_period;
|
||||
int ret = 0;
|
||||
|
||||
/* The period may have been changed by PERF_EVENT_IOC_PERIOD */
|
||||
if (unlikely(period != hwc->last_period))
|
||||
left = period - (hwc->last_period - left);
|
||||
|
||||
if (unlikely(left <= -period)) {
|
||||
left = period;
|
||||
local64_set(&hwc->period_left, left);
|
||||
|
|
|
|||
|
|
@ -828,6 +828,16 @@ static enum ssb_mitigation __init __ssb_select_mitigation(void)
|
|||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If SSBD is controlled by the SPEC_CTRL MSR, then set the proper
|
||||
* bit in the mask to allow guests to use the mitigation even in the
|
||||
* case where the host does not enable it.
|
||||
*/
|
||||
if (static_cpu_has(X86_FEATURE_SPEC_CTRL_SSBD) ||
|
||||
static_cpu_has(X86_FEATURE_AMD_SSBD)) {
|
||||
x86_spec_ctrl_mask |= SPEC_CTRL_SSBD;
|
||||
}
|
||||
|
||||
/*
|
||||
* We have three CPU feature flags that are in play here:
|
||||
* - X86_BUG_SPEC_STORE_BYPASS - CPU is susceptible.
|
||||
|
|
@ -845,7 +855,6 @@ static enum ssb_mitigation __init __ssb_select_mitigation(void)
|
|||
x86_amd_ssb_disable();
|
||||
} else {
|
||||
x86_spec_ctrl_base |= SPEC_CTRL_SSBD;
|
||||
x86_spec_ctrl_mask |= SPEC_CTRL_SSBD;
|
||||
wrmsrl(MSR_IA32_SPEC_CTRL, x86_spec_ctrl_base);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1992,7 +1992,7 @@ int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
|
|||
struct kvm_lapic *apic = vcpu->arch.apic;
|
||||
int highest_irr;
|
||||
|
||||
if (!apic_enabled(apic))
|
||||
if (!kvm_apic_hw_enabled(apic))
|
||||
return -1;
|
||||
|
||||
apic_update_ppr(apic);
|
||||
|
|
|
|||
|
|
@ -1365,7 +1365,7 @@ static int set_tsc_khz(struct kvm_vcpu *vcpu, u32 user_tsc_khz, bool scale)
|
|||
vcpu->arch.tsc_always_catchup = 1;
|
||||
return 0;
|
||||
} else {
|
||||
WARN(1, "user requested TSC rate below hardware speed\n");
|
||||
pr_warn_ratelimited("user requested TSC rate below hardware speed\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
|
@ -1375,8 +1375,8 @@ static int set_tsc_khz(struct kvm_vcpu *vcpu, u32 user_tsc_khz, bool scale)
|
|||
user_tsc_khz, tsc_khz);
|
||||
|
||||
if (ratio == 0 || ratio >= kvm_max_tsc_scaling_ratio) {
|
||||
WARN_ONCE(1, "Invalid TSC scaling ratio - virtual-tsc-khz=%u\n",
|
||||
user_tsc_khz);
|
||||
pr_warn_ratelimited("Invalid TSC scaling ratio - virtual-tsc-khz=%u\n",
|
||||
user_tsc_khz);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -55,6 +55,9 @@ static struct crypto_alg *crypto_alg_match(struct crypto_user_alg *p, int exact)
|
|||
list_for_each_entry(q, &crypto_alg_list, cra_list) {
|
||||
int match = 0;
|
||||
|
||||
if (crypto_is_larval(q))
|
||||
continue;
|
||||
|
||||
if ((q->cra_flags ^ p->cru_type) & p->cru_mask)
|
||||
continue;
|
||||
|
||||
|
|
|
|||
|
|
@ -78,6 +78,10 @@ static void __init sun8i_h3_bus_gates_init(struct device_node *node)
|
|||
clk_parent = APB1;
|
||||
else if (index >= 96 && index <= 127)
|
||||
clk_parent = APB2;
|
||||
else {
|
||||
WARN_ON(true);
|
||||
continue;
|
||||
}
|
||||
|
||||
clk_reg = reg + 4 * (index / 32);
|
||||
clk_bit = index % 32;
|
||||
|
|
|
|||
|
|
@ -632,7 +632,7 @@ static int sdma_load_script(struct sdma_engine *sdma, void *buf, int size,
|
|||
spin_lock_irqsave(&sdma->channel_0_lock, flags);
|
||||
|
||||
bd0->mode.command = C0_SETPM;
|
||||
bd0->mode.status = BD_DONE | BD_INTR | BD_WRAP | BD_EXTD;
|
||||
bd0->mode.status = BD_DONE | BD_WRAP | BD_EXTD;
|
||||
bd0->mode.count = size / 2;
|
||||
bd0->buffer_addr = buf_phys;
|
||||
bd0->ext_buffer_addr = address;
|
||||
|
|
@ -909,7 +909,7 @@ static int sdma_load_context(struct sdma_channel *sdmac)
|
|||
context->gReg[7] = sdmac->watermark_level;
|
||||
|
||||
bd0->mode.command = C0_SETDM;
|
||||
bd0->mode.status = BD_DONE | BD_INTR | BD_WRAP | BD_EXTD;
|
||||
bd0->mode.status = BD_DONE | BD_WRAP | BD_EXTD;
|
||||
bd0->mode.count = sizeof(*context) / 4;
|
||||
bd0->buffer_addr = sdma->context_phys;
|
||||
bd0->ext_buffer_addr = 2048 + (sizeof(*context) / 4) * channel;
|
||||
|
|
|
|||
|
|
@ -170,7 +170,8 @@ static int hdlcd_crtc_atomic_check(struct drm_crtc *crtc,
|
|||
long rate, clk_rate = mode->clock * 1000;
|
||||
|
||||
rate = clk_round_rate(hdlcd->clk, clk_rate);
|
||||
if (rate != clk_rate) {
|
||||
/* 0.1% seems a close enough tolerance for the TDA19988 on Juno */
|
||||
if (abs(rate - clk_rate) * 1000 > clk_rate) {
|
||||
/* clock required by mode not supported by hardware */
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -280,10 +280,17 @@ static uint32_t *parse_csr_fw(struct drm_i915_private *dev_priv,
|
|||
uint32_t i;
|
||||
uint32_t *dmc_payload;
|
||||
uint32_t required_version;
|
||||
size_t fsize;
|
||||
|
||||
if (!fw)
|
||||
return NULL;
|
||||
|
||||
fsize = sizeof(struct intel_css_header) +
|
||||
sizeof(struct intel_package_header) +
|
||||
sizeof(struct intel_dmc_header);
|
||||
if (fsize > fw->size)
|
||||
goto error_truncated;
|
||||
|
||||
/* Extract CSS Header information*/
|
||||
css_header = (struct intel_css_header *)fw->data;
|
||||
if (sizeof(struct intel_css_header) !=
|
||||
|
|
@ -349,6 +356,9 @@ static uint32_t *parse_csr_fw(struct drm_i915_private *dev_priv,
|
|||
return NULL;
|
||||
}
|
||||
readcount += dmc_offset;
|
||||
fsize += dmc_offset;
|
||||
if (fsize > fw->size)
|
||||
goto error_truncated;
|
||||
|
||||
/* Extract dmc_header information. */
|
||||
dmc_header = (struct intel_dmc_header *)&fw->data[readcount];
|
||||
|
|
@ -379,6 +389,10 @@ static uint32_t *parse_csr_fw(struct drm_i915_private *dev_priv,
|
|||
|
||||
/* fw_size is in dwords, so multiplied by 4 to convert into bytes. */
|
||||
nbytes = dmc_header->fw_size * 4;
|
||||
fsize += nbytes;
|
||||
if (fsize > fw->size)
|
||||
goto error_truncated;
|
||||
|
||||
if (nbytes > CSR_MAX_FW_SIZE) {
|
||||
DRM_ERROR("CSR firmware too big (%u) bytes\n", nbytes);
|
||||
return NULL;
|
||||
|
|
@ -392,6 +406,10 @@ static uint32_t *parse_csr_fw(struct drm_i915_private *dev_priv,
|
|||
}
|
||||
|
||||
return memcpy(dmc_payload, &fw->data[readcount], nbytes);
|
||||
|
||||
error_truncated:
|
||||
DRM_ERROR("Truncated DMC firmware, rejecting.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void csr_load_work_fn(struct work_struct *work)
|
||||
|
|
|
|||
|
|
@ -76,14 +76,14 @@ static void ipu_crtc_atomic_disable(struct drm_crtc *crtc,
|
|||
drm_atomic_helper_disable_planes_on_crtc(old_crtc_state, false);
|
||||
ipu_dc_disable(ipu);
|
||||
|
||||
drm_crtc_vblank_off(crtc);
|
||||
|
||||
spin_lock_irq(&crtc->dev->event_lock);
|
||||
if (crtc->state->event) {
|
||||
if (crtc->state->event && !crtc->state->active) {
|
||||
drm_crtc_send_vblank_event(crtc, crtc->state->event);
|
||||
crtc->state->event = NULL;
|
||||
}
|
||||
spin_unlock_irq(&crtc->dev->event_lock);
|
||||
|
||||
drm_crtc_vblank_off(crtc);
|
||||
}
|
||||
|
||||
static void imx_drm_crtc_reset(struct drm_crtc *crtc)
|
||||
|
|
|
|||
|
|
@ -720,6 +720,8 @@ static void mtk_dsi_destroy_conn_enc(struct mtk_dsi *dsi)
|
|||
/* Skip connector cleanup if creation was delegated to the bridge */
|
||||
if (dsi->conn.dev)
|
||||
drm_connector_cleanup(&dsi->conn);
|
||||
if (dsi->panel)
|
||||
drm_panel_detach(dsi->panel);
|
||||
}
|
||||
|
||||
static void mtk_dsi_ddp_start(struct mtk_ddp_comp *comp)
|
||||
|
|
|
|||
|
|
@ -1028,14 +1028,15 @@ static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
|
|||
const struct pmbus_driver_info *info,
|
||||
const char *name,
|
||||
int index, int page,
|
||||
const struct pmbus_sensor_attr *attr)
|
||||
const struct pmbus_sensor_attr *attr,
|
||||
bool paged)
|
||||
{
|
||||
struct pmbus_sensor *base;
|
||||
int ret;
|
||||
|
||||
if (attr->label) {
|
||||
ret = pmbus_add_label(data, name, index, attr->label,
|
||||
attr->paged ? page + 1 : 0);
|
||||
paged ? page + 1 : 0);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1067,6 +1068,30 @@ static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info,
|
||||
const struct pmbus_sensor_attr *attr)
|
||||
{
|
||||
int p;
|
||||
|
||||
if (attr->paged)
|
||||
return true;
|
||||
|
||||
/*
|
||||
* Some attributes may be present on more than one page despite
|
||||
* not being marked with the paged attribute. If that is the case,
|
||||
* then treat the sensor as being paged and add the page suffix to the
|
||||
* attribute name.
|
||||
* We don't just add the paged attribute to all such attributes, in
|
||||
* order to maintain the un-suffixed labels in the case where the
|
||||
* attribute is only on page 0.
|
||||
*/
|
||||
for (p = 1; p < info->pages; p++) {
|
||||
if (info->func[p] & attr->func)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static int pmbus_add_sensor_attrs(struct i2c_client *client,
|
||||
struct pmbus_data *data,
|
||||
const char *name,
|
||||
|
|
@ -1080,14 +1105,15 @@ static int pmbus_add_sensor_attrs(struct i2c_client *client,
|
|||
index = 1;
|
||||
for (i = 0; i < nattrs; i++) {
|
||||
int page, pages;
|
||||
bool paged = pmbus_sensor_is_paged(info, attrs);
|
||||
|
||||
pages = attrs->paged ? info->pages : 1;
|
||||
pages = paged ? info->pages : 1;
|
||||
for (page = 0; page < pages; page++) {
|
||||
if (!(info->func[page] & attrs->func))
|
||||
continue;
|
||||
ret = pmbus_add_sensor_attrs_one(client, data, info,
|
||||
name, index, page,
|
||||
attrs);
|
||||
attrs, paged);
|
||||
if (ret)
|
||||
return ret;
|
||||
index++;
|
||||
|
|
|
|||
|
|
@ -9620,6 +9620,7 @@ void hfi1_quiet_serdes(struct hfi1_pportdata *ppd)
|
|||
|
||||
/* disable the port */
|
||||
clear_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
|
||||
cancel_work_sync(&ppd->freeze_work);
|
||||
}
|
||||
|
||||
static inline int init_cpu_counters(struct hfi1_devdata *dd)
|
||||
|
|
|
|||
|
|
@ -410,10 +410,7 @@ static void sdma_flush(struct sdma_engine *sde)
|
|||
sdma_flush_descq(sde);
|
||||
spin_lock_irqsave(&sde->flushlist_lock, flags);
|
||||
/* copy flush list */
|
||||
list_for_each_entry_safe(txp, txp_next, &sde->flushlist, list) {
|
||||
list_del_init(&txp->list);
|
||||
list_add_tail(&txp->list, &flushlist);
|
||||
}
|
||||
list_splice_init(&sde->flushlist, &flushlist);
|
||||
spin_unlock_irqrestore(&sde->flushlist_lock, flags);
|
||||
/* flush from flush list */
|
||||
list_for_each_entry_safe(txp, txp_next, &flushlist, list)
|
||||
|
|
@ -2406,7 +2403,7 @@ unlock_noconn:
|
|||
wait->tx_count++;
|
||||
wait->count += tx->num_desc;
|
||||
}
|
||||
schedule_work(&sde->flush_worker);
|
||||
queue_work_on(sde->cpu, system_highpri_wq, &sde->flush_worker);
|
||||
ret = -ECOMM;
|
||||
goto unlock;
|
||||
nodesc:
|
||||
|
|
@ -2504,7 +2501,7 @@ unlock_noconn:
|
|||
}
|
||||
}
|
||||
spin_unlock(&sde->flushlist_lock);
|
||||
schedule_work(&sde->flush_worker);
|
||||
queue_work_on(sde->cpu, system_highpri_wq, &sde->flush_worker);
|
||||
ret = -ECOMM;
|
||||
goto update_tail;
|
||||
nodesc:
|
||||
|
|
|
|||
|
|
@ -260,7 +260,6 @@ struct user_sdma_txreq {
|
|||
struct list_head list;
|
||||
struct user_sdma_request *req;
|
||||
u16 flags;
|
||||
unsigned busycount;
|
||||
u64 seqnum;
|
||||
};
|
||||
|
||||
|
|
@ -323,25 +322,22 @@ static int defer_packet_queue(
|
|||
struct hfi1_user_sdma_pkt_q *pq =
|
||||
container_of(wait, struct hfi1_user_sdma_pkt_q, busy);
|
||||
struct hfi1_ibdev *dev = &pq->dd->verbs_dev;
|
||||
struct user_sdma_txreq *tx =
|
||||
container_of(txreq, struct user_sdma_txreq, txreq);
|
||||
|
||||
if (sdma_progress(sde, seq, txreq)) {
|
||||
if (tx->busycount++ < MAX_DEFER_RETRY_COUNT)
|
||||
goto eagain;
|
||||
}
|
||||
write_seqlock(&dev->iowait_lock);
|
||||
if (sdma_progress(sde, seq, txreq))
|
||||
goto eagain;
|
||||
/*
|
||||
* We are assuming that if the list is enqueued somewhere, it
|
||||
* is to the dmawait list since that is the only place where
|
||||
* it is supposed to be enqueued.
|
||||
*/
|
||||
xchg(&pq->state, SDMA_PKT_Q_DEFERRED);
|
||||
write_seqlock(&dev->iowait_lock);
|
||||
if (list_empty(&pq->busy.list))
|
||||
list_add_tail(&pq->busy.list, &sde->dmawait);
|
||||
write_sequnlock(&dev->iowait_lock);
|
||||
return -EBUSY;
|
||||
eagain:
|
||||
write_sequnlock(&dev->iowait_lock);
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
|
|
@ -925,7 +921,6 @@ static int user_sdma_send_pkts(struct user_sdma_request *req, unsigned maxpkts)
|
|||
|
||||
tx->flags = 0;
|
||||
tx->req = req;
|
||||
tx->busycount = 0;
|
||||
INIT_LIST_HEAD(&tx->list);
|
||||
|
||||
if (req->seqnum == req->info.npkts - 1)
|
||||
|
|
|
|||
|
|
@ -1344,8 +1344,6 @@ static void hfi1_fill_device_attr(struct hfi1_devdata *dd)
|
|||
rdi->dparms.props.max_cq = hfi1_max_cqs;
|
||||
rdi->dparms.props.max_ah = hfi1_max_ahs;
|
||||
rdi->dparms.props.max_cqe = hfi1_max_cqes;
|
||||
rdi->dparms.props.max_mr = rdi->lkey_table.max;
|
||||
rdi->dparms.props.max_fmr = rdi->lkey_table.max;
|
||||
rdi->dparms.props.max_map_per_fmr = 32767;
|
||||
rdi->dparms.props.max_pd = hfi1_max_pds;
|
||||
rdi->dparms.props.max_qp_rd_atom = HFI1_MAX_RDMA_ATOMIC;
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
|
|||
if (ib_rvt_state_ops[qp->state] & RVT_PROCESS_RECV_OK) {
|
||||
struct hfi1_qp_priv *priv;
|
||||
|
||||
tx = kmem_cache_alloc(dev->verbs_txreq_cache, GFP_ATOMIC);
|
||||
tx = kmem_cache_alloc(dev->verbs_txreq_cache, VERBS_TXREQ_GFP);
|
||||
if (tx)
|
||||
goto out;
|
||||
priv = qp->priv;
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ struct hfi1_ibdev;
|
|||
struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
|
||||
struct rvt_qp *qp);
|
||||
|
||||
#define VERBS_TXREQ_GFP (GFP_ATOMIC | __GFP_NOWARN)
|
||||
static inline struct verbs_txreq *get_txreq(struct hfi1_ibdev *dev,
|
||||
struct rvt_qp *qp)
|
||||
__must_hold(&qp->slock)
|
||||
|
|
@ -78,7 +79,7 @@ static inline struct verbs_txreq *get_txreq(struct hfi1_ibdev *dev,
|
|||
struct verbs_txreq *tx;
|
||||
struct hfi1_qp_priv *priv = qp->priv;
|
||||
|
||||
tx = kmem_cache_alloc(dev->verbs_txreq_cache, GFP_ATOMIC);
|
||||
tx = kmem_cache_alloc(dev->verbs_txreq_cache, VERBS_TXREQ_GFP);
|
||||
if (unlikely(!tx)) {
|
||||
/* call slow path to get the lock */
|
||||
tx = __get_txreq(dev, qp);
|
||||
|
|
|
|||
|
|
@ -1568,8 +1568,6 @@ static void qib_fill_device_attr(struct qib_devdata *dd)
|
|||
rdi->dparms.props.max_cq = ib_qib_max_cqs;
|
||||
rdi->dparms.props.max_cqe = ib_qib_max_cqes;
|
||||
rdi->dparms.props.max_ah = ib_qib_max_ahs;
|
||||
rdi->dparms.props.max_mr = rdi->lkey_table.max;
|
||||
rdi->dparms.props.max_fmr = rdi->lkey_table.max;
|
||||
rdi->dparms.props.max_map_per_fmr = 32767;
|
||||
rdi->dparms.props.max_qp_rd_atom = QIB_MAX_RDMA_ATOMIC;
|
||||
rdi->dparms.props.max_qp_init_rd_atom = 255;
|
||||
|
|
|
|||
|
|
@ -94,6 +94,8 @@ int rvt_driver_mr_init(struct rvt_dev_info *rdi)
|
|||
for (i = 0; i < rdi->lkey_table.max; i++)
|
||||
RCU_INIT_POINTER(rdi->lkey_table.table[i], NULL);
|
||||
|
||||
rdi->dparms.props.max_mr = rdi->lkey_table.max;
|
||||
rdi->dparms.props.max_fmr = rdi->lkey_table.max;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -370,7 +370,8 @@ static int alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
|
|||
offset = qpt->incr | ((offset & 1) ^ 1);
|
||||
}
|
||||
/* there can be no set bits in low-order QoS bits */
|
||||
WARN_ON(offset & (BIT(rdi->dparms.qos_shift) - 1));
|
||||
WARN_ON(rdi->dparms.qos_shift > 1 &&
|
||||
offset & ((BIT(rdi->dparms.qos_shift - 1) - 1) << 1));
|
||||
qpn = mk_qpn(qpt, map, offset);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -991,13 +991,31 @@ static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|||
|
||||
#ifdef CONFIG_COMPAT
|
||||
|
||||
#define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
|
||||
/*
|
||||
* These IOCTLs change their size and thus their numbers between
|
||||
* 32 and 64 bits.
|
||||
*/
|
||||
#define UI_SET_PHYS_COMPAT \
|
||||
_IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
|
||||
#define UI_BEGIN_FF_UPLOAD_COMPAT \
|
||||
_IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload_compat)
|
||||
#define UI_END_FF_UPLOAD_COMPAT \
|
||||
_IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload_compat)
|
||||
|
||||
static long uinput_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
if (cmd == UI_SET_PHYS_COMPAT)
|
||||
switch (cmd) {
|
||||
case UI_SET_PHYS_COMPAT:
|
||||
cmd = UI_SET_PHYS;
|
||||
break;
|
||||
case UI_BEGIN_FF_UPLOAD_COMPAT:
|
||||
cmd = UI_BEGIN_FF_UPLOAD;
|
||||
break;
|
||||
case UI_END_FF_UPLOAD_COMPAT:
|
||||
cmd = UI_END_FF_UPLOAD;
|
||||
break;
|
||||
}
|
||||
|
||||
return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -131,12 +131,12 @@ static inline u32 usbtll_read(void __iomem *base, u32 reg)
|
|||
return readl_relaxed(base + reg);
|
||||
}
|
||||
|
||||
static inline void usbtll_writeb(void __iomem *base, u8 reg, u8 val)
|
||||
static inline void usbtll_writeb(void __iomem *base, u32 reg, u8 val)
|
||||
{
|
||||
writeb_relaxed(val, base + reg);
|
||||
}
|
||||
|
||||
static inline u8 usbtll_readb(void __iomem *base, u8 reg)
|
||||
static inline u8 usbtll_readb(void __iomem *base, u32 reg)
|
||||
{
|
||||
return readb_relaxed(base + reg);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4241,12 +4241,12 @@ void bond_setup(struct net_device *bond_dev)
|
|||
bond_dev->features |= NETIF_F_NETNS_LOCAL;
|
||||
|
||||
bond_dev->hw_features = BOND_VLAN_FEATURES |
|
||||
NETIF_F_HW_VLAN_CTAG_TX |
|
||||
NETIF_F_HW_VLAN_CTAG_RX |
|
||||
NETIF_F_HW_VLAN_CTAG_FILTER;
|
||||
|
||||
bond_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
|
||||
bond_dev->features |= bond_dev->hw_features;
|
||||
bond_dev->features |= NETIF_F_HW_VLAN_CTAG_TX;
|
||||
}
|
||||
|
||||
/* Destroy a bonding device.
|
||||
|
|
|
|||
|
|
@ -171,7 +171,7 @@
|
|||
#define FLEXCAN_MB_CNT_LENGTH(x) (((x) & 0xf) << 16)
|
||||
#define FLEXCAN_MB_CNT_TIMESTAMP(x) ((x) & 0xffff)
|
||||
|
||||
#define FLEXCAN_TIMEOUT_US (50)
|
||||
#define FLEXCAN_TIMEOUT_US (250)
|
||||
|
||||
/* FLEXCAN hardware feature flags
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1742,7 +1742,7 @@ static int _mv88e6xxx_vtu_get(struct mv88e6xxx_chip *chip, u16 vid,
|
|||
int err;
|
||||
|
||||
if (!vid)
|
||||
return -EINVAL;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
err = _mv88e6xxx_vtu_vid_write(chip, vid - 1);
|
||||
if (err)
|
||||
|
|
|
|||
|
|
@ -367,6 +367,7 @@ static int __lb_setup(struct net_device *ndev,
|
|||
static int __lb_up(struct net_device *ndev,
|
||||
enum hnae_loop loop_mode)
|
||||
{
|
||||
#define NIC_LB_TEST_WAIT_PHY_LINK_TIME 300
|
||||
struct hns_nic_priv *priv = netdev_priv(ndev);
|
||||
struct hnae_handle *h = priv->ae_handle;
|
||||
int speed, duplex;
|
||||
|
|
@ -393,6 +394,9 @@ static int __lb_up(struct net_device *ndev,
|
|||
|
||||
h->dev->ops->adjust_link(h, speed, duplex);
|
||||
|
||||
/* wait adjust link done and phy ready */
|
||||
msleep(NIC_LB_TEST_WAIT_PHY_LINK_TIME);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1700,6 +1700,7 @@ static void mtk_poll_controller(struct net_device *dev)
|
|||
|
||||
static int mtk_start_dma(struct mtk_eth *eth)
|
||||
{
|
||||
u32 rx_2b_offset = (NET_IP_ALIGN == 2) ? MTK_RX_2B_OFFSET : 0;
|
||||
int err;
|
||||
|
||||
err = mtk_dma_init(eth);
|
||||
|
|
@ -1714,7 +1715,7 @@ static int mtk_start_dma(struct mtk_eth *eth)
|
|||
MTK_QDMA_GLO_CFG);
|
||||
|
||||
mtk_w32(eth,
|
||||
MTK_RX_DMA_EN | MTK_RX_2B_OFFSET |
|
||||
MTK_RX_DMA_EN | rx_2b_offset |
|
||||
MTK_RX_BT_32DWORDS | MTK_MULTI_EN,
|
||||
MTK_PDMA_GLO_CFG);
|
||||
|
||||
|
|
@ -2175,13 +2176,13 @@ static int mtk_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
|
|||
|
||||
switch (cmd->cmd) {
|
||||
case ETHTOOL_GRXRINGS:
|
||||
if (dev->features & NETIF_F_LRO) {
|
||||
if (dev->hw_features & NETIF_F_LRO) {
|
||||
cmd->data = MTK_MAX_RX_RING_NUM;
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
case ETHTOOL_GRXCLSRLCNT:
|
||||
if (dev->features & NETIF_F_LRO) {
|
||||
if (dev->hw_features & NETIF_F_LRO) {
|
||||
struct mtk_mac *mac = netdev_priv(dev);
|
||||
|
||||
cmd->rule_cnt = mac->hwlro_ip_cnt;
|
||||
|
|
@ -2189,11 +2190,11 @@ static int mtk_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
|
|||
}
|
||||
break;
|
||||
case ETHTOOL_GRXCLSRULE:
|
||||
if (dev->features & NETIF_F_LRO)
|
||||
if (dev->hw_features & NETIF_F_LRO)
|
||||
ret = mtk_hwlro_get_fdir_entry(dev, cmd);
|
||||
break;
|
||||
case ETHTOOL_GRXCLSRLALL:
|
||||
if (dev->features & NETIF_F_LRO)
|
||||
if (dev->hw_features & NETIF_F_LRO)
|
||||
ret = mtk_hwlro_get_fdir_all(dev, cmd,
|
||||
rule_locs);
|
||||
break;
|
||||
|
|
@ -2210,11 +2211,11 @@ static int mtk_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
|
|||
|
||||
switch (cmd->cmd) {
|
||||
case ETHTOOL_SRXCLSRLINS:
|
||||
if (dev->features & NETIF_F_LRO)
|
||||
if (dev->hw_features & NETIF_F_LRO)
|
||||
ret = mtk_hwlro_add_ipaddr(dev, cmd);
|
||||
break;
|
||||
case ETHTOOL_SRXCLSRLDEL:
|
||||
if (dev->features & NETIF_F_LRO)
|
||||
if (dev->hw_features & NETIF_F_LRO)
|
||||
ret = mtk_hwlro_del_ipaddr(dev, cmd);
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ static int stmmac_adjust_systime(void __iomem *ioaddr, u32 sec, u32 nsec,
|
|||
* programmed with (2^32 – <new_sec_value>)
|
||||
*/
|
||||
if (gmac4)
|
||||
sec = (100000000ULL - sec);
|
||||
sec = -sec;
|
||||
|
||||
value = readl(ioaddr + PTP_TCR);
|
||||
if (value & PTP_TCR_TSCTRLSSR)
|
||||
|
|
|
|||
|
|
@ -2136,12 +2136,12 @@ static void team_setup(struct net_device *dev)
|
|||
dev->features |= NETIF_F_NETNS_LOCAL;
|
||||
|
||||
dev->hw_features = TEAM_VLAN_FEATURES |
|
||||
NETIF_F_HW_VLAN_CTAG_TX |
|
||||
NETIF_F_HW_VLAN_CTAG_RX |
|
||||
NETIF_F_HW_VLAN_CTAG_FILTER;
|
||||
|
||||
dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
|
||||
dev->features |= dev->hw_features;
|
||||
dev->features |= NETIF_F_HW_VLAN_CTAG_TX;
|
||||
}
|
||||
|
||||
static int team_newlink(struct net *src_net, struct net_device *dev,
|
||||
|
|
|
|||
|
|
@ -828,18 +828,8 @@ static void tun_net_uninit(struct net_device *dev)
|
|||
/* Net device open. */
|
||||
static int tun_net_open(struct net_device *dev)
|
||||
{
|
||||
struct tun_struct *tun = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
netif_tx_start_all_queues(dev);
|
||||
|
||||
for (i = 0; i < tun->numqueues; i++) {
|
||||
struct tun_file *tfile;
|
||||
|
||||
tfile = rtnl_dereference(tun->tfiles[i]);
|
||||
tfile->socket.sk->sk_write_space(tfile->socket.sk);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -2540,6 +2530,7 @@ static int tun_device_event(struct notifier_block *unused,
|
|||
{
|
||||
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
||||
struct tun_struct *tun = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
if (dev->rtnl_link_ops != &tun_link_ops)
|
||||
return NOTIFY_DONE;
|
||||
|
|
@ -2549,6 +2540,14 @@ static int tun_device_event(struct notifier_block *unused,
|
|||
if (tun_queue_resize(tun))
|
||||
return NOTIFY_BAD;
|
||||
break;
|
||||
case NETDEV_UP:
|
||||
for (i = 0; i < tun->numqueues; i++) {
|
||||
struct tun_file *tfile;
|
||||
|
||||
tfile = rtnl_dereference(tun->tfiles[i]);
|
||||
tfile->socket.sk->sk_write_space(tfile->socket.sk);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1765,7 +1765,8 @@ static int nvme_scan_ns_list(struct nvme_ctrl *ctrl, unsigned nn)
|
|||
{
|
||||
struct nvme_ns *ns;
|
||||
__le32 *ns_list;
|
||||
unsigned i, j, nsid, prev = 0, num_lists = DIV_ROUND_UP(nn, 1024);
|
||||
unsigned i, j, nsid, prev = 0;
|
||||
unsigned num_lists = DIV_ROUND_UP_ULL((u64)nn, 1024);
|
||||
int ret = 0;
|
||||
|
||||
ns_list = kzalloc(0x1000, GFP_KERNEL);
|
||||
|
|
|
|||
|
|
@ -895,6 +895,7 @@ parport_register_dev_model(struct parport *port, const char *name,
|
|||
par_dev->devmodel = true;
|
||||
ret = device_register(&par_dev->dev);
|
||||
if (ret) {
|
||||
kfree(par_dev->state);
|
||||
put_device(&par_dev->dev);
|
||||
goto err_put_port;
|
||||
}
|
||||
|
|
@ -912,6 +913,7 @@ parport_register_dev_model(struct parport *port, const char *name,
|
|||
spin_unlock(&port->physport->pardevice_lock);
|
||||
pr_debug("%s: cannot grant exclusive access for device %s\n",
|
||||
port->name, name);
|
||||
kfree(par_dev->state);
|
||||
device_unregister(&par_dev->dev);
|
||||
goto err_put_port;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2124,7 +2124,7 @@ static void qeth_bridgeport_an_set_cb(void *priv,
|
|||
|
||||
l2entry = (struct qdio_brinfo_entry_l2 *)entry;
|
||||
code = IPA_ADDR_CHANGE_CODE_MACADDR;
|
||||
if (l2entry->addr_lnid.lnid)
|
||||
if (l2entry->addr_lnid.lnid < VLAN_N_VID)
|
||||
code |= IPA_ADDR_CHANGE_CODE_VLANID;
|
||||
qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
|
||||
(struct net_if_token *)&l2entry->nit,
|
||||
|
|
|
|||
|
|
@ -4815,7 +4815,7 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
|
|||
curr_sg->reserved[0] = 0;
|
||||
curr_sg->reserved[1] = 0;
|
||||
curr_sg->reserved[2] = 0;
|
||||
curr_sg->chain_indicator = 0x80;
|
||||
curr_sg->chain_indicator = IOACCEL2_CHAIN;
|
||||
|
||||
curr_sg = h->ioaccel2_cmd_sg_list[c->cmdindex];
|
||||
}
|
||||
|
|
@ -4832,6 +4832,11 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
|
|||
curr_sg++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set the last s/g element bit
|
||||
*/
|
||||
(curr_sg - 1)->chain_indicator = IOACCEL2_LAST_SG;
|
||||
|
||||
switch (cmd->sc_data_direction) {
|
||||
case DMA_TO_DEVICE:
|
||||
cp->direction &= ~IOACCEL2_DIRECTION_MASK;
|
||||
|
|
|
|||
|
|
@ -516,6 +516,7 @@ struct ioaccel2_sg_element {
|
|||
u8 reserved[3];
|
||||
u8 chain_indicator;
|
||||
#define IOACCEL2_CHAIN 0x80
|
||||
#define IOACCEL2_LAST_SG 0x40
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -342,24 +342,21 @@ int ufshcd_pltfrm_init(struct platform_device *pdev,
|
|||
goto dealloc_host;
|
||||
}
|
||||
|
||||
pm_runtime_set_active(&pdev->dev);
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
|
||||
ufshcd_init_lanes_per_dir(hba);
|
||||
|
||||
err = ufshcd_init(hba, mmio_base, irq);
|
||||
if (err) {
|
||||
dev_err(dev, "Initialization failed\n");
|
||||
goto out_disable_rpm;
|
||||
goto dealloc_host;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, hba);
|
||||
|
||||
pm_runtime_set_active(&pdev->dev);
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
|
||||
out_disable_rpm:
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
pm_runtime_set_suspended(&pdev->dev);
|
||||
dealloc_host:
|
||||
ufshcd_dealloc_host(hba);
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -942,7 +942,8 @@ int ufshcd_copy_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
|
|||
memcpy(&query_res->upiu_res, &lrbp->ucd_rsp_ptr->qr, QUERY_OSF_SIZE);
|
||||
|
||||
/* Get the descriptor */
|
||||
if (lrbp->ucd_rsp_ptr->qr.opcode == UPIU_QUERY_OPCODE_READ_DESC) {
|
||||
if (hba->dev_cmd.query.descriptor &&
|
||||
lrbp->ucd_rsp_ptr->qr.opcode == UPIU_QUERY_OPCODE_READ_DESC) {
|
||||
u8 *descp = (u8 *)lrbp->ucd_rsp_ptr +
|
||||
GENERAL_UPIU_REQUEST_SIZE;
|
||||
u16 resp_len;
|
||||
|
|
|
|||
|
|
@ -766,6 +766,7 @@ static int pvscsi_queue_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd
|
|||
struct pvscsi_adapter *adapter = shost_priv(host);
|
||||
struct pvscsi_ctx *ctx;
|
||||
unsigned long flags;
|
||||
unsigned char op;
|
||||
|
||||
spin_lock_irqsave(&adapter->hw_lock, flags);
|
||||
|
||||
|
|
@ -778,13 +779,14 @@ static int pvscsi_queue_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd
|
|||
}
|
||||
|
||||
cmd->scsi_done = done;
|
||||
op = cmd->cmnd[0];
|
||||
|
||||
dev_dbg(&cmd->device->sdev_gendev,
|
||||
"queued cmd %p, ctx %p, op=%x\n", cmd, ctx, cmd->cmnd[0]);
|
||||
"queued cmd %p, ctx %p, op=%x\n", cmd, ctx, op);
|
||||
|
||||
spin_unlock_irqrestore(&adapter->hw_lock, flags);
|
||||
|
||||
pvscsi_kick_io(adapter, cmd->cmnd[0]);
|
||||
pvscsi_kick_io(adapter, op);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -392,7 +392,7 @@ int spi_bitbang_start(struct spi_bitbang *bitbang)
|
|||
if (ret)
|
||||
spi_master_put(master);
|
||||
|
||||
return 0;
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(spi_bitbang_start);
|
||||
|
||||
|
|
|
|||
|
|
@ -279,7 +279,7 @@ MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc1
|
|||
module_param_array(pc104_4, ulong, NULL, 0);
|
||||
MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
|
||||
|
||||
static int rp_init(void);
|
||||
static int __init rp_init(void);
|
||||
static void rp_cleanup_module(void);
|
||||
|
||||
module_init(rp_init);
|
||||
|
|
|
|||
|
|
@ -1621,6 +1621,25 @@ static int ci_udc_pullup(struct usb_gadget *_gadget, int is_on)
|
|||
static int ci_udc_start(struct usb_gadget *gadget,
|
||||
struct usb_gadget_driver *driver);
|
||||
static int ci_udc_stop(struct usb_gadget *gadget);
|
||||
|
||||
/* Match ISOC IN from the highest endpoint */
|
||||
static struct usb_ep *ci_udc_match_ep(struct usb_gadget *gadget,
|
||||
struct usb_endpoint_descriptor *desc,
|
||||
struct usb_ss_ep_comp_descriptor *comp_desc)
|
||||
{
|
||||
struct ci_hdrc *ci = container_of(gadget, struct ci_hdrc, gadget);
|
||||
struct usb_ep *ep;
|
||||
|
||||
if (usb_endpoint_xfer_isoc(desc) && usb_endpoint_dir_in(desc)) {
|
||||
list_for_each_entry_reverse(ep, &ci->gadget.ep_list, ep_list) {
|
||||
if (ep->caps.dir_in && !ep->claimed)
|
||||
return ep;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Device operations part of the API to the USB controller hardware,
|
||||
* which don't involve endpoints (or i/o)
|
||||
|
|
@ -1634,6 +1653,7 @@ static const struct usb_gadget_ops usb_gadget_ops = {
|
|||
.vbus_draw = ci_udc_vbus_draw,
|
||||
.udc_start = ci_udc_start,
|
||||
.udc_stop = ci_udc_stop,
|
||||
.match_ep = ci_udc_match_ep,
|
||||
};
|
||||
|
||||
static int init_eps(struct ci_hdrc *ci)
|
||||
|
|
|
|||
|
|
@ -1345,12 +1345,15 @@ static const struct usb_gadget_ops fusb300_gadget_ops = {
|
|||
static int fusb300_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct fusb300 *fusb300 = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
|
||||
usb_del_gadget_udc(&fusb300->gadget);
|
||||
iounmap(fusb300->reg);
|
||||
free_irq(platform_get_irq(pdev, 0), fusb300);
|
||||
|
||||
fusb300_free_request(&fusb300->ep[0]->ep, fusb300->ep0_req);
|
||||
for (i = 0; i < FUSB300_MAX_NUM_EP; i++)
|
||||
kfree(fusb300->ep[i]);
|
||||
kfree(fusb300);
|
||||
|
||||
return 0;
|
||||
|
|
@ -1494,6 +1497,8 @@ clean_up:
|
|||
if (fusb300->ep0_req)
|
||||
fusb300_free_request(&fusb300->ep[0]->ep,
|
||||
fusb300->ep0_req);
|
||||
for (i = 0; i < FUSB300_MAX_NUM_EP; i++)
|
||||
kfree(fusb300->ep[i]);
|
||||
kfree(fusb300);
|
||||
}
|
||||
if (reg)
|
||||
|
|
|
|||
|
|
@ -935,8 +935,7 @@ static struct lpc32xx_usbd_dd_gad *udc_dd_alloc(struct lpc32xx_udc *udc)
|
|||
dma_addr_t dma;
|
||||
struct lpc32xx_usbd_dd_gad *dd;
|
||||
|
||||
dd = (struct lpc32xx_usbd_dd_gad *) dma_pool_alloc(
|
||||
udc->dd_cache, (GFP_KERNEL | GFP_DMA), &dma);
|
||||
dd = dma_pool_alloc(udc->dd_cache, GFP_ATOMIC | GFP_DMA, &dma);
|
||||
if (dd)
|
||||
dd->this_dma = dma;
|
||||
|
||||
|
|
|
|||
|
|
@ -276,7 +276,7 @@ static int v9fs_xattr_set_acl(const struct xattr_handler *handler,
|
|||
switch (handler->flags) {
|
||||
case ACL_TYPE_ACCESS:
|
||||
if (acl) {
|
||||
struct iattr iattr;
|
||||
struct iattr iattr = { 0 };
|
||||
struct posix_acl *old_acl = acl;
|
||||
|
||||
retval = posix_acl_update_mode(inode, &iattr.ia_mode, &acl);
|
||||
|
|
|
|||
|
|
@ -859,9 +859,14 @@ err:
|
|||
|
||||
static int load_flat_shared_library(int id, struct lib_info *libs)
|
||||
{
|
||||
/*
|
||||
* This is a fake bprm struct; only the members "buf", "file" and
|
||||
* "filename" are actually used.
|
||||
*/
|
||||
struct linux_binprm bprm;
|
||||
int res;
|
||||
char buf[16];
|
||||
loff_t pos = 0;
|
||||
|
||||
memset(&bprm, 0, sizeof(bprm));
|
||||
|
||||
|
|
@ -875,25 +880,11 @@ static int load_flat_shared_library(int id, struct lib_info *libs)
|
|||
if (IS_ERR(bprm.file))
|
||||
return res;
|
||||
|
||||
bprm.cred = prepare_exec_creds();
|
||||
res = -ENOMEM;
|
||||
if (!bprm.cred)
|
||||
goto out;
|
||||
res = kernel_read(bprm.file, pos, bprm.buf, BINPRM_BUF_SIZE);
|
||||
|
||||
/* We don't really care about recalculating credentials at this point
|
||||
* as we're past the point of no return and are dealing with shared
|
||||
* libraries.
|
||||
*/
|
||||
bprm.cred_prepared = 1;
|
||||
|
||||
res = prepare_binprm(&bprm);
|
||||
|
||||
if (!res)
|
||||
if (res >= 0)
|
||||
res = load_flat_file(&bprm, libs, id, NULL);
|
||||
|
||||
abort_creds(bprm.cred);
|
||||
|
||||
out:
|
||||
allow_write_access(bprm.file);
|
||||
fput(bprm.file);
|
||||
|
||||
|
|
|
|||
|
|
@ -511,18 +511,27 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
|
|||
}
|
||||
btrfs_wait_ordered_roots(root->fs_info, -1, 0, (u64)-1);
|
||||
|
||||
trans = btrfs_start_transaction(root, 0);
|
||||
if (IS_ERR(trans)) {
|
||||
mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
||||
return PTR_ERR(trans);
|
||||
while (1) {
|
||||
trans = btrfs_start_transaction(root, 0);
|
||||
if (IS_ERR(trans)) {
|
||||
mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
||||
return PTR_ERR(trans);
|
||||
}
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
WARN_ON(ret);
|
||||
mutex_lock(&uuid_mutex);
|
||||
/* keep away write_all_supers() during the finishing procedure */
|
||||
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
||||
mutex_lock(&root->fs_info->chunk_mutex);
|
||||
if (src_device->has_pending_chunks) {
|
||||
mutex_unlock(&root->fs_info->chunk_mutex);
|
||||
mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
||||
mutex_unlock(&uuid_mutex);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
WARN_ON(ret);
|
||||
|
||||
mutex_lock(&uuid_mutex);
|
||||
/* keep away write_all_supers() during the finishing procedure */
|
||||
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
||||
mutex_lock(&root->fs_info->chunk_mutex);
|
||||
btrfs_dev_replace_lock(dev_replace, 1);
|
||||
dev_replace->replace_state =
|
||||
scrub_ret ? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
|
||||
|
|
|
|||
|
|
@ -759,6 +759,7 @@ static void __reada_start_machine(struct btrfs_fs_info *fs_info)
|
|||
u64 total = 0;
|
||||
int i;
|
||||
|
||||
again:
|
||||
do {
|
||||
enqueued = 0;
|
||||
mutex_lock(&fs_devices->device_list_mutex);
|
||||
|
|
@ -771,6 +772,10 @@ static void __reada_start_machine(struct btrfs_fs_info *fs_info)
|
|||
mutex_unlock(&fs_devices->device_list_mutex);
|
||||
total += enqueued;
|
||||
} while (enqueued && total < 10000);
|
||||
if (fs_devices->seed) {
|
||||
fs_devices = fs_devices->seed;
|
||||
goto again;
|
||||
}
|
||||
|
||||
if (enqueued == 0)
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -4876,6 +4876,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
|
|||
for (i = 0; i < map->num_stripes; i++) {
|
||||
num_bytes = map->stripes[i].dev->bytes_used + stripe_size;
|
||||
btrfs_device_set_bytes_used(map->stripes[i].dev, num_bytes);
|
||||
map->stripes[i].dev->has_pending_chunks = true;
|
||||
}
|
||||
|
||||
spin_lock(&extent_root->fs_info->free_chunk_lock);
|
||||
|
|
@ -7250,6 +7251,7 @@ void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
|
|||
for (i = 0; i < map->num_stripes; i++) {
|
||||
dev = map->stripes[i].dev;
|
||||
dev->commit_bytes_used = dev->bytes_used;
|
||||
dev->has_pending_chunks = false;
|
||||
}
|
||||
}
|
||||
unlock_chunks(root);
|
||||
|
|
|
|||
|
|
@ -62,6 +62,11 @@ struct btrfs_device {
|
|||
|
||||
spinlock_t io_lock ____cacheline_aligned;
|
||||
int running_pending;
|
||||
/* When true means this device has pending chunk alloc in
|
||||
* current transaction. Protected by chunk_mutex.
|
||||
*/
|
||||
bool has_pending_chunks;
|
||||
|
||||
/* regular prio bios */
|
||||
struct btrfs_pending_bios pending_bios;
|
||||
/* WRITE_SYNC bios */
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
#define NFSDBG_FACILITY NFSDBG_PNFS_LD
|
||||
|
||||
static unsigned int dataserver_timeo = NFS_DEF_TCP_RETRANS;
|
||||
static unsigned int dataserver_timeo = NFS_DEF_TCP_TIMEO;
|
||||
static unsigned int dataserver_retrans;
|
||||
|
||||
void nfs4_ff_layout_put_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
|
||||
|
|
|
|||
|
|
@ -448,7 +448,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
|
|||
* a program is not able to use ptrace(2) in that case. It is
|
||||
* safe because the task has stopped executing permanently.
|
||||
*/
|
||||
if (permitted && (task->flags & PF_DUMPCORE)) {
|
||||
if (permitted && (task->flags & (PF_EXITING|PF_DUMPCORE))) {
|
||||
if (try_get_task_stack(task)) {
|
||||
eip = KSTK_EIP(task);
|
||||
esp = KSTK_ESP(task);
|
||||
|
|
|
|||
|
|
@ -47,6 +47,7 @@ struct bug_entry {
|
|||
#ifndef HAVE_ARCH_BUG
|
||||
#define BUG() do { \
|
||||
printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
|
||||
barrier_before_unreachable(); \
|
||||
panic("BUG!"); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -233,6 +233,15 @@
|
|||
#define annotate_unreachable()
|
||||
#endif
|
||||
|
||||
/*
|
||||
* calling noreturn functions, __builtin_unreachable() and __builtin_trap()
|
||||
* confuse the stack allocation in gcc, leading to overly large stack
|
||||
* frames, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82365
|
||||
*
|
||||
* Adding an empty inline assembly before it works around the problem
|
||||
*/
|
||||
#define barrier_before_unreachable() asm volatile("")
|
||||
|
||||
/*
|
||||
* Mark a position in code as unreachable. This can be used to
|
||||
* suppress control flow warnings after asm blocks that transfer
|
||||
|
|
@ -243,7 +252,11 @@
|
|||
* unreleased. Really, we need to have autoconf for the kernel.
|
||||
*/
|
||||
#define unreachable() \
|
||||
do { annotate_unreachable(); __builtin_unreachable(); } while (0)
|
||||
do { \
|
||||
annotate_unreachable(); \
|
||||
barrier_before_unreachable(); \
|
||||
__builtin_unreachable(); \
|
||||
} while (0)
|
||||
|
||||
/* Mark a function definition as prohibited from being cloned. */
|
||||
#define __noclone __attribute__((__noclone__, __optimize__("no-tracer")))
|
||||
|
|
|
|||
|
|
@ -177,6 +177,11 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
|
|||
# define barrier_data(ptr) barrier()
|
||||
#endif
|
||||
|
||||
/* workaround for GCC PR82365 if needed */
|
||||
#ifndef barrier_before_unreachable
|
||||
# define barrier_before_unreachable() do { } while (0)
|
||||
#endif
|
||||
|
||||
/* Unreachable code */
|
||||
#ifndef unreachable
|
||||
# define unreachable() do { } while (1)
|
||||
|
|
|
|||
|
|
@ -176,6 +176,9 @@ struct adv_info {
|
|||
|
||||
#define HCI_MAX_SHORT_NAME_LENGTH 10
|
||||
|
||||
/* Min encryption key size to match with SMP */
|
||||
#define HCI_MIN_ENC_KEY_SIZE 7
|
||||
|
||||
/* Default LE RPA expiry time, 15 minutes */
|
||||
#define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
|
||||
|
||||
|
|
|
|||
|
|
@ -2252,6 +2252,9 @@ static int __init mitigations_parse_cmdline(char *arg)
|
|||
cpu_mitigations = CPU_MITIGATIONS_AUTO;
|
||||
else if (!strcmp(arg, "auto,nosmt"))
|
||||
cpu_mitigations = CPU_MITIGATIONS_AUTO_NOSMT;
|
||||
else
|
||||
pr_crit("Unsupported mitigations=%s, system may still be vulnerable\n",
|
||||
arg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -74,9 +74,7 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
|
|||
*/
|
||||
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
|
||||
{
|
||||
rcu_read_lock();
|
||||
__ptrace_link(child, new_parent, __task_cred(new_parent));
|
||||
rcu_read_unlock();
|
||||
__ptrace_link(child, new_parent, current_cred());
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -7767,12 +7767,8 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
|
|||
|
||||
cnt++;
|
||||
|
||||
/* reset all but tr, trace, and overruns */
|
||||
memset(&iter.seq, 0,
|
||||
sizeof(struct trace_iterator) -
|
||||
offsetof(struct trace_iterator, seq));
|
||||
trace_iterator_reset(&iter);
|
||||
iter.iter_flags |= TRACE_FILE_LAT_FMT;
|
||||
iter.pos = -1;
|
||||
|
||||
if (trace_find_next_entry_inc(&iter) != NULL) {
|
||||
int ret;
|
||||
|
|
|
|||
|
|
@ -1675,4 +1675,22 @@ static inline void trace_event_enum_update(struct trace_enum_map **map, int len)
|
|||
|
||||
extern struct trace_iterator *tracepoint_print_iter;
|
||||
|
||||
/*
|
||||
* Reset the state of the trace_iterator so that it can read consumed data.
|
||||
* Normally, the trace_iterator is used for reading the data when it is not
|
||||
* consumed, and must retain state.
|
||||
*/
|
||||
static __always_inline void trace_iterator_reset(struct trace_iterator *iter)
|
||||
{
|
||||
const size_t offset = offsetof(struct trace_iterator, seq);
|
||||
|
||||
/*
|
||||
* Keep gcc from complaining about overwriting more than just one
|
||||
* member in the structure.
|
||||
*/
|
||||
memset((char *)iter + offset, 0, sizeof(struct trace_iterator) - offset);
|
||||
|
||||
iter->pos = -1;
|
||||
}
|
||||
|
||||
#endif /* _LINUX_KERNEL_TRACE_H */
|
||||
|
|
|
|||
|
|
@ -40,12 +40,8 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
|
|||
|
||||
kdb_printf("Dumping ftrace buffer:\n");
|
||||
|
||||
/* reset all but tr, trace, and overruns */
|
||||
memset(&iter.seq, 0,
|
||||
sizeof(struct trace_iterator) -
|
||||
offsetof(struct trace_iterator, seq));
|
||||
trace_iterator_reset(&iter);
|
||||
iter.iter_flags |= TRACE_FILE_LAT_FMT;
|
||||
iter.pos = -1;
|
||||
|
||||
if (cpu_file == RING_BUFFER_ALL_CPUS) {
|
||||
for_each_tracing_cpu(cpu) {
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@
|
|||
int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
|
||||
{
|
||||
mpi_ptr_t mp_marker = NULL, bp_marker = NULL, ep_marker = NULL;
|
||||
struct karatsuba_ctx karactx = {};
|
||||
mpi_ptr_t xp_marker = NULL;
|
||||
mpi_ptr_t tspace = NULL;
|
||||
mpi_ptr_t rp, ep, mp, bp;
|
||||
|
|
@ -164,13 +165,11 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
|
|||
int c;
|
||||
mpi_limb_t e;
|
||||
mpi_limb_t carry_limb;
|
||||
struct karatsuba_ctx karactx;
|
||||
|
||||
xp = xp_marker = mpi_alloc_limb_space(2 * (msize + 1));
|
||||
if (!xp)
|
||||
goto enomem;
|
||||
|
||||
memset(&karactx, 0, sizeof karactx);
|
||||
negative_result = (ep[0] & 1) && base->sign;
|
||||
|
||||
i = esize - 1;
|
||||
|
|
@ -295,8 +294,6 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
|
|||
if (mod_shift_cnt)
|
||||
mpihelp_rshift(rp, rp, rsize, mod_shift_cnt);
|
||||
MPN_NORMALIZE(rp, rsize);
|
||||
|
||||
mpihelp_release_karatsuba_ctx(&karactx);
|
||||
}
|
||||
|
||||
if (negative_result && rsize) {
|
||||
|
|
@ -313,6 +310,7 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
|
|||
leave:
|
||||
rc = 0;
|
||||
enomem:
|
||||
mpihelp_release_karatsuba_ctx(&karactx);
|
||||
if (assign_rp)
|
||||
mpi_assign_limb_space(res, rp, size);
|
||||
if (mp_marker)
|
||||
|
|
|
|||
|
|
@ -630,11 +630,11 @@ static int apply_vma_lock_flags(unsigned long start, size_t len,
|
|||
* is also counted.
|
||||
* Return value: previously mlocked page counts
|
||||
*/
|
||||
static int count_mm_mlocked_page_nr(struct mm_struct *mm,
|
||||
static unsigned long count_mm_mlocked_page_nr(struct mm_struct *mm,
|
||||
unsigned long start, size_t len)
|
||||
{
|
||||
struct vm_area_struct *vma;
|
||||
int count = 0;
|
||||
unsigned long count = 0;
|
||||
|
||||
if (mm == NULL)
|
||||
mm = current->mm;
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ static ssize_t page_idle_bitmap_read(struct file *file, struct kobject *kobj,
|
|||
|
||||
end_pfn = pfn + count * BITS_PER_BYTE;
|
||||
if (end_pfn > max_pfn)
|
||||
end_pfn = ALIGN(max_pfn, BITMAP_CHUNK_BITS);
|
||||
end_pfn = max_pfn;
|
||||
|
||||
for (; pfn < end_pfn; pfn++) {
|
||||
bit = pfn % BITMAP_CHUNK_BITS;
|
||||
|
|
@ -176,7 +176,7 @@ static ssize_t page_idle_bitmap_write(struct file *file, struct kobject *kobj,
|
|||
|
||||
end_pfn = pfn + count * BITS_PER_BYTE;
|
||||
if (end_pfn > max_pfn)
|
||||
end_pfn = ALIGN(max_pfn, BITMAP_CHUNK_BITS);
|
||||
end_pfn = max_pfn;
|
||||
|
||||
for (; pfn < end_pfn; pfn++) {
|
||||
bit = pfn % BITMAP_CHUNK_BITS;
|
||||
|
|
|
|||
|
|
@ -622,13 +622,19 @@ int p9dirent_read(struct p9_client *clnt, char *buf, int len,
|
|||
if (ret) {
|
||||
p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
|
||||
trace_9p_protocol_dump(clnt, &fake_pdu);
|
||||
goto out;
|
||||
return ret;
|
||||
}
|
||||
|
||||
strcpy(dirent->d_name, nameptr);
|
||||
ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
|
||||
if (ret < 0) {
|
||||
p9_debug(P9_DEBUG_ERROR,
|
||||
"On the wire dirent name too long: %s\n",
|
||||
nameptr);
|
||||
kfree(nameptr);
|
||||
return ret;
|
||||
}
|
||||
kfree(nameptr);
|
||||
|
||||
out:
|
||||
return fake_pdu.offset;
|
||||
}
|
||||
EXPORT_SYMBOL(p9dirent_read);
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
|
||||
#include <linux/mm.h>
|
||||
#include <linux/module.h>
|
||||
#include "trans_common.h"
|
||||
|
||||
/**
|
||||
* p9_release_req_pages - Release pages after the transaction.
|
||||
|
|
|
|||
|
|
@ -254,8 +254,7 @@ p9_cm_event_handler(struct rdma_cm_id *id, struct rdma_cm_event *event)
|
|||
case RDMA_CM_EVENT_DISCONNECTED:
|
||||
if (rdma)
|
||||
rdma->state = P9_RDMA_CLOSED;
|
||||
if (c)
|
||||
c->status = Disconnected;
|
||||
c->status = Disconnected;
|
||||
break;
|
||||
|
||||
case RDMA_CM_EVENT_TIMEWAIT_EXIT:
|
||||
|
|
@ -454,7 +453,7 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req)
|
|||
|
||||
err = post_recv(client, rpl_context);
|
||||
if (err) {
|
||||
p9_debug(P9_DEBUG_FCALL, "POST RECV failed\n");
|
||||
p9_debug(P9_DEBUG_ERROR, "POST RECV failed: %d\n", err);
|
||||
goto recv_error;
|
||||
}
|
||||
/* remove posted receive buffer from request structure */
|
||||
|
|
@ -523,7 +522,7 @@ dont_need_post_recv:
|
|||
recv_error:
|
||||
kfree(rpl_context);
|
||||
spin_lock_irqsave(&rdma->req_lock, flags);
|
||||
if (rdma->state < P9_RDMA_CLOSING) {
|
||||
if (err != -EINTR && rdma->state < P9_RDMA_CLOSING) {
|
||||
rdma->state = P9_RDMA_CLOSING;
|
||||
spin_unlock_irqrestore(&rdma->req_lock, flags);
|
||||
rdma_disconnect(rdma->cm_id);
|
||||
|
|
|
|||
|
|
@ -1281,8 +1281,16 @@ auth:
|
|||
return 0;
|
||||
|
||||
encrypt:
|
||||
if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
|
||||
if (test_bit(HCI_CONN_ENCRYPT, &conn->flags)) {
|
||||
/* Ensure that the encryption key size has been read,
|
||||
* otherwise stall the upper layer responses.
|
||||
*/
|
||||
if (!conn->enc_key_size)
|
||||
return 0;
|
||||
|
||||
/* Nothing else needed, all requirements are met */
|
||||
return 1;
|
||||
}
|
||||
|
||||
hci_conn_encrypt(conn);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -1340,6 +1340,21 @@ static void l2cap_request_info(struct l2cap_conn *conn)
|
|||
sizeof(req), &req);
|
||||
}
|
||||
|
||||
static bool l2cap_check_enc_key_size(struct hci_conn *hcon)
|
||||
{
|
||||
/* The minimum encryption key size needs to be enforced by the
|
||||
* host stack before establishing any L2CAP connections. The
|
||||
* specification in theory allows a minimum of 1, but to align
|
||||
* BR/EDR and LE transports, a minimum of 7 is chosen.
|
||||
*
|
||||
* This check might also be called for unencrypted connections
|
||||
* that have no key size requirements. Ensure that the link is
|
||||
* actually encrypted before enforcing a key size.
|
||||
*/
|
||||
return (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags) ||
|
||||
hcon->enc_key_size >= HCI_MIN_ENC_KEY_SIZE);
|
||||
}
|
||||
|
||||
static void l2cap_do_start(struct l2cap_chan *chan)
|
||||
{
|
||||
struct l2cap_conn *conn = chan->conn;
|
||||
|
|
@ -1357,9 +1372,14 @@ static void l2cap_do_start(struct l2cap_chan *chan)
|
|||
if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
|
||||
return;
|
||||
|
||||
if (l2cap_chan_check_security(chan, true) &&
|
||||
__l2cap_no_conn_pending(chan))
|
||||
if (!l2cap_chan_check_security(chan, true) ||
|
||||
!__l2cap_no_conn_pending(chan))
|
||||
return;
|
||||
|
||||
if (l2cap_check_enc_key_size(conn->hcon))
|
||||
l2cap_start_connection(chan);
|
||||
else
|
||||
__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
|
||||
}
|
||||
|
||||
static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
|
||||
|
|
@ -1438,7 +1458,10 @@ static void l2cap_conn_start(struct l2cap_conn *conn)
|
|||
continue;
|
||||
}
|
||||
|
||||
l2cap_start_connection(chan);
|
||||
if (l2cap_check_enc_key_size(conn->hcon))
|
||||
l2cap_start_connection(chan);
|
||||
else
|
||||
l2cap_chan_close(chan, ECONNREFUSED);
|
||||
|
||||
} else if (chan->state == BT_CONNECT2) {
|
||||
struct l2cap_conn_rsp rsp;
|
||||
|
|
@ -7447,7 +7470,7 @@ static void l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
|
|||
}
|
||||
|
||||
if (chan->state == BT_CONNECT) {
|
||||
if (!status)
|
||||
if (!status && l2cap_check_enc_key_size(hcon))
|
||||
l2cap_start_connection(chan);
|
||||
else
|
||||
__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
|
||||
|
|
@ -7456,7 +7479,7 @@ static void l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
|
|||
struct l2cap_conn_rsp rsp;
|
||||
__u16 res, stat;
|
||||
|
||||
if (!status) {
|
||||
if (!status && l2cap_check_enc_key_size(hcon)) {
|
||||
if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
|
||||
res = L2CAP_CR_PEND;
|
||||
stat = L2CAP_CS_AUTHOR_PEND;
|
||||
|
|
|
|||
|
|
@ -113,6 +113,7 @@ EXPORT_SYMBOL(can_ioctl);
|
|||
static void can_sock_destruct(struct sock *sk)
|
||||
{
|
||||
skb_queue_purge(&sk->sk_receive_queue);
|
||||
skb_queue_purge(&sk->sk_error_queue);
|
||||
}
|
||||
|
||||
static const struct can_proto *can_get_proto(int protocol)
|
||||
|
|
|
|||
|
|
@ -5083,7 +5083,10 @@ bool sk_busy_loop(struct sock *sk, int nonblock)
|
|||
goto out;
|
||||
|
||||
/* Note: ndo_busy_poll method is optional in linux-4.5 */
|
||||
busy_poll = napi->dev->netdev_ops->ndo_busy_poll;
|
||||
if (napi->dev->netdev_ops)
|
||||
busy_poll = napi->dev->netdev_ops->ndo_busy_poll;
|
||||
else
|
||||
busy_poll = NULL;
|
||||
|
||||
do {
|
||||
rc = 0;
|
||||
|
|
|
|||
|
|
@ -197,7 +197,7 @@ static int raw_v4_input(struct sk_buff *skb, const struct iphdr *iph, int hash)
|
|||
}
|
||||
sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
|
||||
iph->saddr, iph->daddr,
|
||||
skb->dev->ifindex);
|
||||
dif);
|
||||
}
|
||||
out:
|
||||
read_unlock(&raw_v4_hashinfo.lock);
|
||||
|
|
|
|||
|
|
@ -569,7 +569,11 @@ static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
|
|||
struct sock *udp4_lib_lookup_skb(struct sk_buff *skb,
|
||||
__be16 sport, __be16 dport)
|
||||
{
|
||||
return __udp4_lib_lookup_skb(skb, sport, dport, &udp_table);
|
||||
const struct iphdr *iph = ip_hdr(skb);
|
||||
|
||||
return __udp4_lib_lookup(dev_net(skb->dev), iph->saddr, sport,
|
||||
iph->daddr, dport, inet_iif(skb),
|
||||
&udp_table, NULL);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(udp4_lib_lookup_skb);
|
||||
|
||||
|
|
|
|||
|
|
@ -294,7 +294,7 @@ struct sock *udp6_lib_lookup_skb(struct sk_buff *skb,
|
|||
|
||||
return __udp6_lib_lookup(dev_net(skb->dev), &iph->saddr, sport,
|
||||
&iph->daddr, dport, inet6_iif(skb),
|
||||
&udp_table, skb);
|
||||
&udp_table, NULL);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(udp6_lib_lookup_skb);
|
||||
|
||||
|
|
@ -479,7 +479,7 @@ void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
|
|||
struct net *net = dev_net(skb->dev);
|
||||
|
||||
sk = __udp6_lib_lookup(net, daddr, uh->dest, saddr, uh->source,
|
||||
inet6_iif(skb), udptable, skb);
|
||||
inet6_iif(skb), udptable, NULL);
|
||||
if (!sk) {
|
||||
__ICMP6_INC_STATS(net, __in6_dev_get(skb->dev),
|
||||
ICMP6_MIB_INERRORS);
|
||||
|
|
|
|||
|
|
@ -3568,6 +3568,8 @@ static bool ieee80211_accept_frame(struct ieee80211_rx_data *rx)
|
|||
case NL80211_IFTYPE_STATION:
|
||||
if (!bssid && !sdata->u.mgd.use_4addr)
|
||||
return false;
|
||||
if (ieee80211_is_robust_mgmt_frame(skb) && !rx->sta)
|
||||
return false;
|
||||
if (multicast)
|
||||
return true;
|
||||
return ether_addr_equal(sdata->vif.addr, hdr->addr1);
|
||||
|
|
|
|||
|
|
@ -1169,7 +1169,7 @@ ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx)
|
|||
struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
|
||||
struct ieee80211_key *key = rx->key;
|
||||
struct ieee80211_mmie_16 *mmie;
|
||||
u8 aad[GMAC_AAD_LEN], mic[GMAC_MIC_LEN], ipn[6], nonce[GMAC_NONCE_LEN];
|
||||
u8 aad[GMAC_AAD_LEN], *mic, ipn[6], nonce[GMAC_NONCE_LEN];
|
||||
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
||||
|
||||
if (!ieee80211_is_mgmt(hdr->frame_control))
|
||||
|
|
@ -1200,13 +1200,18 @@ ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx)
|
|||
memcpy(nonce, hdr->addr2, ETH_ALEN);
|
||||
memcpy(nonce + ETH_ALEN, ipn, 6);
|
||||
|
||||
mic = kmalloc(GMAC_MIC_LEN, GFP_ATOMIC);
|
||||
if (!mic)
|
||||
return RX_DROP_UNUSABLE;
|
||||
if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
|
||||
skb->data + 24, skb->len - 24,
|
||||
mic) < 0 ||
|
||||
crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
|
||||
key->u.aes_gmac.icverrors++;
|
||||
kfree(mic);
|
||||
return RX_DROP_UNUSABLE;
|
||||
}
|
||||
kfree(mic);
|
||||
}
|
||||
|
||||
memcpy(key->u.aes_gmac.rx_pn, ipn, 6);
|
||||
|
|
|
|||
|
|
@ -2399,6 +2399,9 @@ static void tpacket_destruct_skb(struct sk_buff *skb)
|
|||
|
||||
ts = __packet_set_timestamp(po, ph, skb);
|
||||
__packet_set_status(po, ph, TP_STATUS_AVAILABLE | ts);
|
||||
|
||||
if (!packet_read_pending(&po->tx_ring))
|
||||
complete(&po->skb_completion);
|
||||
}
|
||||
|
||||
sock_wfree(skb);
|
||||
|
|
@ -2629,7 +2632,7 @@ static int tpacket_parse_header(struct packet_sock *po, void *frame,
|
|||
|
||||
static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
struct sk_buff *skb = NULL;
|
||||
struct net_device *dev;
|
||||
struct virtio_net_hdr *vnet_hdr = NULL;
|
||||
struct sockcm_cookie sockc;
|
||||
|
|
@ -2644,6 +2647,7 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
|
|||
int len_sum = 0;
|
||||
int status = TP_STATUS_AVAILABLE;
|
||||
int hlen, tlen, copylen = 0;
|
||||
long timeo = 0;
|
||||
|
||||
mutex_lock(&po->pg_vec_lock);
|
||||
|
||||
|
|
@ -2690,12 +2694,21 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
|
|||
if ((size_max > dev->mtu + reserve + VLAN_HLEN) && !po->has_vnet_hdr)
|
||||
size_max = dev->mtu + reserve + VLAN_HLEN;
|
||||
|
||||
reinit_completion(&po->skb_completion);
|
||||
|
||||
do {
|
||||
ph = packet_current_frame(po, &po->tx_ring,
|
||||
TP_STATUS_SEND_REQUEST);
|
||||
if (unlikely(ph == NULL)) {
|
||||
if (need_wait && need_resched())
|
||||
schedule();
|
||||
if (need_wait && skb) {
|
||||
timeo = sock_sndtimeo(&po->sk, msg->msg_flags & MSG_DONTWAIT);
|
||||
timeo = wait_for_completion_interruptible_timeout(&po->skb_completion, timeo);
|
||||
if (timeo <= 0) {
|
||||
err = !timeo ? -ETIMEDOUT : -ERESTARTSYS;
|
||||
goto out_put;
|
||||
}
|
||||
}
|
||||
/* check for additional frames */
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -3249,6 +3262,7 @@ static int packet_create(struct net *net, struct socket *sock, int protocol,
|
|||
sock_init_data(sock, sk);
|
||||
|
||||
po = pkt_sk(sk);
|
||||
init_completion(&po->skb_completion);
|
||||
sk->sk_family = PF_PACKET;
|
||||
po->num = proto;
|
||||
po->xmit = dev_queue_xmit;
|
||||
|
|
|
|||
|
|
@ -125,6 +125,7 @@ struct packet_sock {
|
|||
unsigned int tp_hdrlen;
|
||||
unsigned int tp_reserve;
|
||||
unsigned int tp_tstamp;
|
||||
struct completion skb_completion;
|
||||
struct net_device __rcu *cached_dev;
|
||||
int (*xmit)(struct sk_buff *skb);
|
||||
struct packet_type prot_hook ____cacheline_aligned_in_smp;
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue