mirror of
https://github.com/rd-stuffs/msm-4.14.git
synced 2025-02-20 11:45:48 +08:00
This is the 4.14.130 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl0RltcACgkQONu9yGCS
aT413Q//SMNo706VZdtx9QyN9HSSWb+c2PF6jD//zCqrgctYq80qneU8r45FEh/c
Ppafe2dsZHNXdZBo3LJIuOG6ZF/9i4TQQd5V4xEZlAcMv/VQDXiDagxI7ItlL3tW
9n0Ok4Sw/rHR2OZj0jD2dJdfaGgntU8BhqT5xMSKxOIdGgfst/nRhNcQ3OxVwlSp
t5N8gDpPGXclQty+dKJFpiCBg/4nTvlf4B3K4kDH/fPn6dlPy84uJDq6PPz5Pe4c
gWyfSixvFUPZZsEfKgkK/kLVv1+vVXeLzI/JjwG2/Z6Ah7Vaw/c2kRQp6HZOMe4G
6PuD4TK+0VZkgv2Eptn2h/3Y0iRr+n/SRZ/K5sG97lyPm5MvtEN11FTaVxb5hh+u
SobRIpkdwXLLqkHBtEGwbXEOPfBgONDqNuYAc8vYRWh99pGHnF4xbadfT/rSPkpp
X9xzbFQsFbwf56WLXOaydnXtSOhUYd0gJkxeK7tU37aQ2pmFxe1Q0yP7a1DIYQqE
Wu2i6w6EreatmpEpjBiEoxhmGavt3E6WpkeetethHVE9hhv0VFzEojBCwC7JClql
jXTQa7GQ7Ih43qPuGJ4Fh9wLghauJ/sWdCQeNbdjU0284UG4IsD/It+T3O0btPZz
dnzTsr3jlSaMlW5eoZRXFY9lmntjW4olYUc8XCYsa/U6v9Bd/Gs=
=MdHH
-----END PGP SIGNATURE-----
Merge 4.14.130 into android-4.14
Changes in 4.14.130
tracing: Silence GCC 9 array bounds warning
objtool: Support per-function rodata sections
gcc-9: silence 'address-of-packed-member' warning
net: phy: broadcom: Use strlcpy() for ethtool::get_strings
mmc: core: Prevent processing SDIO IRQs when the card is suspended
scsi: ufs: Avoid runtime suspend possibly being blocked forever
usb: chipidea: udc: workaround for endpoint conflict issue
IB/hfi1: Silence txreq allocation warnings
Input: synaptics - enable SMBus on ThinkPad E480 and E580
Input: uinput - add compat ioctl number translation for UI_*_FF_UPLOAD
apparmor: enforce nullbyte at end of tag string
ARC: fix build warnings
ARC: [plat-hsdk]: Add missing multicast filter bins number to GMAC node
ARC: [plat-hsdk]: Add missing FIFO size entry in GMAC node
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
IB/hfi1: Validate page aligned for a given virtual address
MIPS: uprobes: remove set but not used variable 'epc'
xtensa: Fix section mismatch between memblock_reserve and mem_reserve
net: dsa: mv88e6xxx: avoid error message on remove from VLAN 0
net: hns: Fix loopback test failed at copper ports
mdesc: fix a missing-check bug in get_vdev_port_node_info()
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: Actually validate CRTC modes
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
scsi: smartpqi: unlock on error in pqi_submit_raid_request_synchronous()
net: ipvlan: Fix ipvlan device tso disabled while NETIF_F_IP_CSUM is set
s390/qeth: fix VLAN attribute in bridge_hostnotify udev event
hwmon: (core) add thermal sensors only if dev->of_node is present
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
ARM: dts: am57xx-idk: Remove support for voltage switching for SD card
Bluetooth: Align minimum encryption key size for LE and BR/EDR connections
Bluetooth: Fix regression with minimum encryption key size alignment
SMB3: retry on STATUS_INSUFFICIENT_RESOURCES instead of failing write
cfg80211: fix memory leak of wiphy device name
mac80211: drop robust management frames from unknown TA
mac80211: handle deauthentication/disassociation from TDLS peer
mac80211: Do not use stack memory with scatterlist for GMAC
Linux 4.14.130
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
fe57a37b3f
4
Makefile
4
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 14
|
||||
SUBLEVEL = 129
|
||||
SUBLEVEL = 130
|
||||
EXTRAVERSION =
|
||||
NAME = Petit Gorille
|
||||
|
||||
@ -671,6 +671,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_CC_OPTIMIZE_FOR_SIZE
|
||||
@ -737,7 +738,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)
|
||||
|
||||
@ -163,12 +163,16 @@
|
||||
interrupt-names = "macirq";
|
||||
phy-mode = "rgmii";
|
||||
snps,pbl = <32>;
|
||||
snps,multicast-filter-bins = <256>;
|
||||
clocks = <&gmacclk>;
|
||||
clock-names = "stmmaceth";
|
||||
phy-handle = <&phy0>;
|
||||
resets = <&cgu_rst HSDK_ETH_RESET>;
|
||||
reset-names = "stmmaceth";
|
||||
|
||||
tx-fifo-depth = <4096>;
|
||||
rx-fifo-depth = <4096>;
|
||||
|
||||
mdio {
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
|
||||
@ -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 */
|
||||
|
||||
|
||||
@ -902,9 +902,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);
|
||||
|
||||
@ -912,9 +914,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);
|
||||
@ -928,14 +931,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;
|
||||
|
||||
|
||||
@ -405,6 +405,7 @@
|
||||
vqmmc-supply = <&ldo1_reg>;
|
||||
bus-width = <4>;
|
||||
cd-gpios = <&gpio6 27 GPIO_ACTIVE_LOW>; /* gpio 219 */
|
||||
no-1-8-v;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -112,9 +112,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;
|
||||
|
||||
@ -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) \
|
||||
|
||||
@ -324,6 +324,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))
|
||||
|
||||
@ -415,12 +415,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 */
|
||||
@ -448,7 +448,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],
|
||||
@ -456,7 +456,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;
|
||||
}
|
||||
|
||||
@ -355,6 +355,8 @@ static int get_vdev_port_node_info(struct mdesc_handle *md, u64 node,
|
||||
|
||||
node_info->vdev_port.id = *idp;
|
||||
node_info->vdev_port.name = kstrdup_const(name, GFP_KERNEL);
|
||||
if (!node_info->vdev_port.name)
|
||||
return -1;
|
||||
node_info->vdev_port.parent_cfg_hdl = *parent_cfg_hdlp;
|
||||
|
||||
return 0;
|
||||
|
||||
@ -891,6 +891,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);
|
||||
|
||||
@ -310,7 +310,8 @@ extern char _SecondaryResetVector_text_start;
|
||||
extern char _SecondaryResetVector_text_end;
|
||||
#endif
|
||||
|
||||
static inline int mem_reserve(unsigned long start, unsigned long end)
|
||||
static inline int __init_memblock mem_reserve(unsigned long start,
|
||||
unsigned long end)
|
||||
{
|
||||
return memblock_reserve(start, end - start);
|
||||
}
|
||||
|
||||
@ -186,20 +186,20 @@ static void hdlcd_crtc_atomic_disable(struct drm_crtc *crtc,
|
||||
clk_disable_unprepare(hdlcd->clk);
|
||||
}
|
||||
|
||||
static int hdlcd_crtc_atomic_check(struct drm_crtc *crtc,
|
||||
struct drm_crtc_state *state)
|
||||
static enum drm_mode_status hdlcd_crtc_mode_valid(struct drm_crtc *crtc,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
struct hdlcd_drm_private *hdlcd = crtc_to_hdlcd_priv(crtc);
|
||||
struct drm_display_mode *mode = &state->adjusted_mode;
|
||||
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;
|
||||
return MODE_NOCLOCK;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return MODE_OK;
|
||||
}
|
||||
|
||||
static void hdlcd_crtc_atomic_begin(struct drm_crtc *crtc,
|
||||
@ -220,7 +220,7 @@ static void hdlcd_crtc_atomic_begin(struct drm_crtc *crtc,
|
||||
}
|
||||
|
||||
static const struct drm_crtc_helper_funcs hdlcd_crtc_helper_funcs = {
|
||||
.atomic_check = hdlcd_crtc_atomic_check,
|
||||
.mode_valid = hdlcd_crtc_mode_valid,
|
||||
.atomic_begin = hdlcd_crtc_atomic_begin,
|
||||
.atomic_enable = hdlcd_crtc_atomic_enable,
|
||||
.atomic_disable = hdlcd_crtc_atomic_disable,
|
||||
|
||||
@ -608,7 +608,7 @@ __hwmon_device_register(struct device *dev, const char *name, void *drvdata,
|
||||
if (err)
|
||||
goto free_hwmon;
|
||||
|
||||
if (dev && chip && chip->ops->read &&
|
||||
if (dev && dev->of_node && chip && chip->ops->read &&
|
||||
chip->info[0]->type == hwmon_chip &&
|
||||
(chip->info[0]->config[0] & HWMON_C_REGISTER_TZ)) {
|
||||
const struct hwmon_channel_info **info = chip->info;
|
||||
|
||||
@ -1055,7 +1055,8 @@ 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;
|
||||
bool upper = !!(attr->gbit & 0xff00); /* need to check STATUS_WORD */
|
||||
@ -1063,7 +1064,7 @@ static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
|
||||
|
||||
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;
|
||||
}
|
||||
@ -1096,6 +1097,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,
|
||||
@ -1109,14 +1134,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++;
|
||||
|
||||
@ -9823,6 +9823,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)
|
||||
|
||||
@ -324,6 +324,9 @@ int hfi1_user_exp_rcv_setup(struct hfi1_filedata *fd,
|
||||
u32 *tidlist = NULL;
|
||||
struct tid_user_buf *tidbuf;
|
||||
|
||||
if (!PAGE_ALIGNED(tinfo->vaddr))
|
||||
return -EINVAL;
|
||||
|
||||
tidbuf = kzalloc(sizeof(*tidbuf), GFP_KERNEL);
|
||||
if (!tidbuf)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -1400,8 +1400,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;
|
||||
|
||||
@ -72,6 +72,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)
|
||||
@ -79,7 +80,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);
|
||||
|
||||
@ -1495,8 +1495,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;
|
||||
|
||||
@ -96,6 +96,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;
|
||||
}
|
||||
|
||||
|
||||
@ -412,7 +412,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);
|
||||
}
|
||||
|
||||
|
||||
@ -1012,13 +1012,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));
|
||||
}
|
||||
|
||||
@ -179,6 +179,8 @@ static const char * const smbus_pnp_ids[] = {
|
||||
"LEN0096", /* X280 */
|
||||
"LEN0097", /* X280 -> ALPS trackpoint */
|
||||
"LEN200f", /* T450s */
|
||||
"LEN2054", /* E480 */
|
||||
"LEN2055", /* E580 */
|
||||
"SYN3052", /* HP EliteBook 840 G4 */
|
||||
"SYN3221", /* HP 15-ay000 */
|
||||
NULL
|
||||
|
||||
@ -927,6 +927,10 @@ static int mmc_sdio_pre_suspend(struct mmc_host *host)
|
||||
*/
|
||||
static int mmc_sdio_suspend(struct mmc_host *host)
|
||||
{
|
||||
/* Prevent processing of SDIO IRQs in suspended state. */
|
||||
mmc_card_set_suspended(host->card);
|
||||
cancel_delayed_work_sync(&host->sdio_irq_work);
|
||||
|
||||
mmc_claim_host(host);
|
||||
|
||||
if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host))
|
||||
@ -982,13 +986,20 @@ static int mmc_sdio_resume(struct mmc_host *host)
|
||||
err = sdio_enable_4bit_bus(host->card);
|
||||
}
|
||||
|
||||
if (!err && host->sdio_irqs) {
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
/* Allow SDIO IRQs to be processed again. */
|
||||
mmc_card_clr_suspended(host->card);
|
||||
|
||||
if (host->sdio_irqs) {
|
||||
if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD))
|
||||
wake_up_process(host->sdio_irq_thread);
|
||||
else if (host->caps & MMC_CAP_SDIO_IRQ)
|
||||
host->ops->enable_sdio_irq(host, 1);
|
||||
}
|
||||
|
||||
out:
|
||||
mmc_release_host(host);
|
||||
|
||||
host->pm_flags &= ~MMC_PM_KEEP_POWER;
|
||||
|
||||
@ -38,6 +38,10 @@ static int process_sdio_pending_irqs(struct mmc_host *host)
|
||||
unsigned char pending;
|
||||
struct sdio_func *func;
|
||||
|
||||
/* Don't process SDIO IRQs if the card is suspended. */
|
||||
if (mmc_card_suspended(card))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Optimization, if there is only 1 function interrupt registered
|
||||
* and we know an IRQ was signaled then call irq handler directly.
|
||||
|
||||
@ -177,7 +177,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
|
||||
*
|
||||
|
||||
@ -1075,7 +1075,7 @@ static int mv88e6xxx_vtu_get(struct mv88e6xxx_chip *chip, u16 vid,
|
||||
int err;
|
||||
|
||||
if (!vid)
|
||||
return -EINVAL;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
entry->vid = vid - 1;
|
||||
entry->valid = false;
|
||||
|
||||
@ -338,6 +338,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;
|
||||
@ -364,6 +365,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;
|
||||
}
|
||||
|
||||
|
||||
@ -1788,6 +1788,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);
|
||||
@ -1804,7 +1805,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);
|
||||
|
||||
@ -2304,13 +2305,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;
|
||||
@ -2318,11 +2319,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;
|
||||
@ -2339,11 +2340,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:
|
||||
|
||||
@ -188,7 +188,7 @@ static void ipvlan_port_destroy(struct net_device *dev)
|
||||
}
|
||||
|
||||
#define IPVLAN_FEATURES \
|
||||
(NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
|
||||
(NETIF_F_SG | NETIF_F_CSUM_MASK | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
|
||||
NETIF_F_GSO | NETIF_F_TSO | NETIF_F_GSO_ROBUST | \
|
||||
NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
|
||||
NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
|
||||
|
||||
@ -341,8 +341,8 @@ void bcm_phy_get_strings(struct phy_device *phydev, u8 *data)
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(bcm_phy_hw_stats); i++)
|
||||
memcpy(data + i * ETH_GSTRING_LEN,
|
||||
bcm_phy_hw_stats[i].string, ETH_GSTRING_LEN);
|
||||
strlcpy(data + i * ETH_GSTRING_LEN,
|
||||
bcm_phy_hw_stats[i].string, ETH_GSTRING_LEN);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bcm_phy_get_strings);
|
||||
|
||||
|
||||
@ -2477,7 +2477,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;
|
||||
}
|
||||
|
||||
@ -1998,7 +1998,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,
|
||||
|
||||
@ -3686,8 +3686,10 @@ static int pqi_submit_raid_request_synchronous(struct pqi_ctrl_info *ctrl_info,
|
||||
return -ETIMEDOUT;
|
||||
msecs_blocked =
|
||||
jiffies_to_msecs(jiffies - start_jiffies);
|
||||
if (msecs_blocked >= timeout_msecs)
|
||||
return -ETIMEDOUT;
|
||||
if (msecs_blocked >= timeout_msecs) {
|
||||
rc = -ETIMEDOUT;
|
||||
goto out;
|
||||
}
|
||||
timeout_msecs -= msecs_blocked;
|
||||
}
|
||||
}
|
||||
|
||||
@ -340,24 +340,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:
|
||||
|
||||
@ -1788,7 +1788,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;
|
||||
|
||||
@ -1620,6 +1620,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)
|
||||
@ -1633,6 +1652,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)
|
||||
|
||||
@ -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);
|
||||
@ -770,6 +771,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;
|
||||
|
||||
@ -456,7 +456,7 @@ static const struct status_to_posix_error smb2_error_map_table[] = {
|
||||
{STATUS_FILE_INVALID, -EIO, "STATUS_FILE_INVALID"},
|
||||
{STATUS_ALLOTTED_SPACE_EXCEEDED, -EIO,
|
||||
"STATUS_ALLOTTED_SPACE_EXCEEDED"},
|
||||
{STATUS_INSUFFICIENT_RESOURCES, -EREMOTEIO,
|
||||
{STATUS_INSUFFICIENT_RESOURCES, -EAGAIN,
|
||||
"STATUS_INSUFFICIENT_RESOURCES"},
|
||||
{STATUS_DFS_EXIT_PATH_FOUND, -EIO, "STATUS_DFS_EXIT_PATH_FOUND"},
|
||||
{STATUS_DEVICE_DATA_ERROR, -EIO, "STATUS_DEVICE_DATA_ERROR"},
|
||||
|
||||
@ -178,6 +178,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)
|
||||
|
||||
|
||||
@ -8249,12 +8249,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;
|
||||
|
||||
@ -1871,4 +1871,22 @@ static inline int tracing_alloc_snapshot_instance(struct trace_array *tr)
|
||||
|
||||
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 */
|
||||
|
||||
@ -41,12 +41,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) {
|
||||
|
||||
@ -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;
|
||||
@ -7455,7 +7478,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);
|
||||
@ -7464,7 +7487,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;
|
||||
|
||||
@ -105,6 +105,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)
|
||||
|
||||
@ -2150,6 +2150,9 @@ void ieee80211_tdls_cancel_channel_switch(struct wiphy *wiphy,
|
||||
const u8 *addr);
|
||||
void ieee80211_teardown_tdls_peers(struct ieee80211_sub_if_data *sdata);
|
||||
void ieee80211_tdls_chsw_work(struct work_struct *wk);
|
||||
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
||||
const u8 *peer, u16 reason);
|
||||
const char *ieee80211_get_reason_code_string(u16 reason_code);
|
||||
|
||||
extern const struct ethtool_ops ieee80211_ethtool_ops;
|
||||
|
||||
|
||||
@ -2744,7 +2744,7 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
|
||||
#define case_WLAN(type) \
|
||||
case WLAN_REASON_##type: return #type
|
||||
|
||||
static const char *ieee80211_get_reason_code_string(u16 reason_code)
|
||||
const char *ieee80211_get_reason_code_string(u16 reason_code)
|
||||
{
|
||||
switch (reason_code) {
|
||||
case_WLAN(UNSPECIFIED);
|
||||
@ -2809,6 +2809,11 @@ static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
|
||||
if (len < 24 + 2)
|
||||
return;
|
||||
|
||||
if (!ether_addr_equal(mgmt->bssid, mgmt->sa)) {
|
||||
ieee80211_tdls_handle_disconnect(sdata, mgmt->sa, reason_code);
|
||||
return;
|
||||
}
|
||||
|
||||
if (ifmgd->associated &&
|
||||
ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid)) {
|
||||
const u8 *bssid = ifmgd->associated->bssid;
|
||||
@ -2858,6 +2863,11 @@ static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
|
||||
|
||||
reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
|
||||
|
||||
if (!ether_addr_equal(mgmt->bssid, mgmt->sa)) {
|
||||
ieee80211_tdls_handle_disconnect(sdata, mgmt->sa, reason_code);
|
||||
return;
|
||||
}
|
||||
|
||||
sdata_info(sdata, "disassociated from %pM (Reason: %u=%s)\n",
|
||||
mgmt->sa, reason_code,
|
||||
ieee80211_get_reason_code_string(reason_code));
|
||||
|
||||
@ -3589,6 +3589,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);
|
||||
|
||||
@ -1988,3 +1988,26 @@ void ieee80211_tdls_chsw_work(struct work_struct *wk)
|
||||
}
|
||||
rtnl_unlock();
|
||||
}
|
||||
|
||||
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
||||
const u8 *peer, u16 reason)
|
||||
{
|
||||
struct ieee80211_sta *sta;
|
||||
|
||||
rcu_read_lock();
|
||||
sta = ieee80211_find_sta(&sdata->vif, peer);
|
||||
if (!sta || !sta->tdls) {
|
||||
rcu_read_unlock();
|
||||
return;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
tdls_dbg(sdata, "disconnected from TDLS peer %pM (Reason: %u=%s)\n",
|
||||
peer, reason,
|
||||
ieee80211_get_reason_code_string(reason));
|
||||
|
||||
ieee80211_tdls_oper_request(&sdata->vif, peer,
|
||||
NL80211_TDLS_TEARDOWN,
|
||||
WLAN_REASON_TDLS_TEARDOWN_UNREACHABLE,
|
||||
GFP_ATOMIC);
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -498,7 +498,7 @@ use_default_name:
|
||||
&rdev->rfkill_ops, rdev);
|
||||
|
||||
if (!rdev->rfkill) {
|
||||
kfree(rdev);
|
||||
wiphy_free(&rdev->wiphy);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
@ -45,7 +45,7 @@ my (@stack, $re, $dre, $x, $xs, $funcre);
|
||||
$x = "[0-9a-f]"; # hex character
|
||||
$xs = "[0-9a-f ]"; # hex character or space
|
||||
$funcre = qr/^$x* <(.*)>:$/;
|
||||
if ($arch eq 'aarch64') {
|
||||
if ($arch =~ '^(aarch|arm)64$') {
|
||||
#ffffffc0006325cc: a9bb7bfd stp x29, x30, [sp, #-80]!
|
||||
$re = qr/^.*stp.*sp, \#-([0-9]{1,8})\]\!/o;
|
||||
} elsif ($arch eq 'arm') {
|
||||
|
||||
@ -259,7 +259,7 @@ static bool unpack_nameX(struct aa_ext *e, enum aa_code code, const char *name)
|
||||
char *tag = NULL;
|
||||
size_t size = unpack_u16_chunk(e, &tag);
|
||||
/* if a name is specified it must match. otherwise skip tag */
|
||||
if (name && (!size || strcmp(name, tag)))
|
||||
if (name && (!size || tag[size-1] != '\0' || strcmp(name, tag)))
|
||||
goto fail;
|
||||
} else if (name) {
|
||||
/* if a name is specified and there is no name tag fail */
|
||||
|
||||
@ -814,7 +814,7 @@ static int add_switch_table(struct objtool_file *file, struct instruction *insn,
|
||||
struct symbol *pfunc = insn->func->pfunc;
|
||||
unsigned int prev_offset = 0;
|
||||
|
||||
list_for_each_entry_from(rela, &file->rodata->rela->rela_list, list) {
|
||||
list_for_each_entry_from(rela, &table->rela_sec->rela_list, list) {
|
||||
if (rela == next_table)
|
||||
break;
|
||||
|
||||
@ -904,6 +904,7 @@ static struct rela *find_switch_table(struct objtool_file *file,
|
||||
{
|
||||
struct rela *text_rela, *rodata_rela;
|
||||
struct instruction *orig_insn = insn;
|
||||
struct section *rodata_sec;
|
||||
unsigned long table_offset;
|
||||
|
||||
/*
|
||||
@ -931,10 +932,13 @@ static struct rela *find_switch_table(struct objtool_file *file,
|
||||
/* look for a relocation which references .rodata */
|
||||
text_rela = find_rela_by_dest_range(insn->sec, insn->offset,
|
||||
insn->len);
|
||||
if (!text_rela || text_rela->sym != file->rodata->sym)
|
||||
if (!text_rela || text_rela->sym->type != STT_SECTION ||
|
||||
!text_rela->sym->sec->rodata)
|
||||
continue;
|
||||
|
||||
table_offset = text_rela->addend;
|
||||
rodata_sec = text_rela->sym->sec;
|
||||
|
||||
if (text_rela->type == R_X86_64_PC32)
|
||||
table_offset += 4;
|
||||
|
||||
@ -942,10 +946,10 @@ static struct rela *find_switch_table(struct objtool_file *file,
|
||||
* Make sure the .rodata address isn't associated with a
|
||||
* symbol. gcc jump tables are anonymous data.
|
||||
*/
|
||||
if (find_symbol_containing(file->rodata, table_offset))
|
||||
if (find_symbol_containing(rodata_sec, table_offset))
|
||||
continue;
|
||||
|
||||
rodata_rela = find_rela_by_dest(file->rodata, table_offset);
|
||||
rodata_rela = find_rela_by_dest(rodata_sec, table_offset);
|
||||
if (rodata_rela) {
|
||||
/*
|
||||
* Use of RIP-relative switch jumps is quite rare, and
|
||||
@ -1030,7 +1034,7 @@ static int add_switch_table_alts(struct objtool_file *file)
|
||||
struct symbol *func;
|
||||
int ret;
|
||||
|
||||
if (!file->rodata || !file->rodata->rela)
|
||||
if (!file->rodata)
|
||||
return 0;
|
||||
|
||||
for_each_sec(file, sec) {
|
||||
@ -1175,10 +1179,33 @@ static int read_retpoline_hints(struct objtool_file *file)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mark_rodata(struct objtool_file *file)
|
||||
{
|
||||
struct section *sec;
|
||||
bool found = false;
|
||||
|
||||
/*
|
||||
* This searches for the .rodata section or multiple .rodata.func_name
|
||||
* sections if -fdata-sections is being used. The .str.1.1 and .str.1.8
|
||||
* rodata sections are ignored as they don't contain jump tables.
|
||||
*/
|
||||
for_each_sec(file, sec) {
|
||||
if (!strncmp(sec->name, ".rodata", 7) &&
|
||||
!strstr(sec->name, ".str1.")) {
|
||||
sec->rodata = true;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
file->rodata = found;
|
||||
}
|
||||
|
||||
static int decode_sections(struct objtool_file *file)
|
||||
{
|
||||
int ret;
|
||||
|
||||
mark_rodata(file);
|
||||
|
||||
ret = decode_instructions(file);
|
||||
if (ret)
|
||||
return ret;
|
||||
@ -2150,7 +2177,6 @@ int check(const char *_objname, bool orc)
|
||||
INIT_LIST_HEAD(&file.insn_list);
|
||||
hash_init(file.insn_hash);
|
||||
file.whitelist = find_section_by_name(file.elf, ".discard.func_stack_frame_non_standard");
|
||||
file.rodata = find_section_by_name(file.elf, ".rodata");
|
||||
file.c_file = find_section_by_name(file.elf, ".comment");
|
||||
file.ignore_unreachables = no_unreachable;
|
||||
file.hints = false;
|
||||
|
||||
@ -60,8 +60,8 @@ struct objtool_file {
|
||||
struct elf *elf;
|
||||
struct list_head insn_list;
|
||||
DECLARE_HASHTABLE(insn_hash, 16);
|
||||
struct section *rodata, *whitelist;
|
||||
bool ignore_unreachables, c_file, hints;
|
||||
struct section *whitelist;
|
||||
bool ignore_unreachables, c_file, hints, rodata;
|
||||
};
|
||||
|
||||
int check(const char *objname, bool orc);
|
||||
|
||||
@ -390,6 +390,7 @@ static int read_relas(struct elf *elf)
|
||||
rela->offset = rela->rela.r_offset;
|
||||
symndx = GELF_R_SYM(rela->rela.r_info);
|
||||
rela->sym = find_symbol_by_index(elf, symndx);
|
||||
rela->rela_sec = sec;
|
||||
if (!rela->sym) {
|
||||
WARN("can't find rela entry symbol %d for %s",
|
||||
symndx, sec->name);
|
||||
|
||||
@ -48,7 +48,7 @@ struct section {
|
||||
char *name;
|
||||
int idx;
|
||||
unsigned int len;
|
||||
bool changed, text;
|
||||
bool changed, text, rodata;
|
||||
};
|
||||
|
||||
struct symbol {
|
||||
@ -68,6 +68,7 @@ struct rela {
|
||||
struct list_head list;
|
||||
struct hlist_node hash;
|
||||
GElf_Rela rela;
|
||||
struct section *rela_sec;
|
||||
struct symbol *sym;
|
||||
unsigned int type;
|
||||
unsigned long offset;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user