Merge android-4.19.56 (e5304c6
) into msm-4.19
* refs/heads/tmp-e5304c6: Linux 4.19.56 powerpc/mm/64s/hash: Reallocate context ids on fork x86/resctrl: Don't stop walking closids when a locksetup group is found mac80211: Do not use stack memory with scatterlist for GMAC nl80211: fix station_info pertid memory leak mac80211: handle deauthentication/disassociation from TDLS peer {nl,mac}80211: allow 4addr AP operation on crypto controlled devices mac80211: drop robust management frames from unknown TA cfg80211: fix memory leak of wiphy device name SMB3: retry on STATUS_INSUFFICIENT_RESOURCES instead of failing write Bluetooth: Fix regression with minimum encryption key size alignment Bluetooth: Align minimum encryption key size for LE and BR/EDR connections staging: erofs: add requirements field in superblock drm/vmwgfx: Use the backdoor port if the HB port is not available arm64: ssbd: explicitly depend on <linux/prctl.h> arm64/sve: <uapi/asm/ptrace.h> should not depend on <uapi/linux/prctl.h> ARM: dts: am57xx-idk: Remove support for voltage switching for SD card ARM: dts: dra76x: Update MMC2_HS200_MANUAL1 iodelay values ARM: imx: cpuidle-imx6sx: Restrict the SW2ISO increase to i.MX6SX powerpc/bpf: use unsigned division instruction for 64-bit operations riscv: mm: synchronize MMU after pte change can: purge socket error queue on sock destruct can: flexcan: fix timeout when set small bitrate can: xilinx_can: use correct bittiming_const for CAN FD core btrfs: start readahead also in seed devices nvme: Fix u32 overflow in the number of namespace list calculation arm64: Silence gcc warnings about arch ABI drift hwmon: (pmbus/core) Treat parameters as paged if on multiple pages hwmon: (core) add thermal sensors only if dev->of_node is present s390/qeth: fix VLAN attribute in bridge_hostnotify udev event net: ipvlan: Fix ipvlan device tso disabled while NETIF_F_IP_CSUM is set scsi: smartpqi: unlock on error in pqi_submit_raid_request_synchronous() scsi: ufs: Check that space was properly alloced in copy_query_response scripts/checkstack.pl: Fix arm64 wrong or unknown architecture nvmet: fix data_len to 0 for bdev-backed write_zeroes drm/arm/hdlcd: Allow a bit of clock tolerance drm/arm/hdlcd: Actually validate CRTC modes drm/arm/mali-dp: Add a loop around the second set CVAL and try 5 times net: ethernet: mediatek: Use NET_IP_ALIGN to judge if HW RX_2BYTE_OFFSET is enabled net: ethernet: mediatek: Use hw_feature to judge if HWLRO is supported sparc: perf: fix updated event period in response to PERF_EVENT_IOC_PERIOD mdesc: fix a missing-check bug in get_vdev_port_node_info() net: hns: Fix loopback test failed at copper ports net: dsa: mv88e6xxx: avoid error message on remove from VLAN 0 selftests: vm: install test_vmalloc.sh for run_vmtests kselftest/cgroup: fix incorrect test_core skip kselftest/cgroup: fix unexpected testing failure on test_core kselftest/cgroup: fix unexpected testing failure on test_memcontrol xtensa: Fix section mismatch between memblock_reserve and mem_reserve MIPS: uprobes: remove set but not used variable 'epc' IB/hfi1: Validate page aligned for a given virtual address IB/{qib, hfi1, rdmavt}: Correct ibv_devinfo max_mr value IB/hfi1: Insure freeze_work work_struct is canceled on shutdown IB/rdmavt: Fix alloc_qpn() WARN_ON() parisc: Fix compiler warnings in float emulation code parport: Fix mem leak in parport_register_dev_model fpga: dfl: Add lockdep classes for pdata->lock fpga: dfl: afu: Pass the correct device to dma_mapping_error() ARC: [plat-hsdk]: Add missing FIFO size entry in GMAC node ARC: [plat-hsdk]: Add missing multicast filter bins number to GMAC node dmaengine: sprd: Fix block length overflow dmaengine: dw-axi-dmac: fix null dereference when pointer first is null ARC: fix build warnings brcmfmac: sdio: Don't tune while the card is off brcmfmac: sdio: Disable auto-tuning around commands expected to fail apparmor: enforce nullbyte at end of tag string apparmor: fix PROFILE_MEDIATES for untrusted input Input: silead - add MSSL0017 to acpi_device_id Input: uinput - add compat ioctl number translation for UI_*_FF_UPLOAD Input: synaptics - enable SMBus on ThinkPad E480 and E580 iio: temperature: mlx90632 Relax the compatibility check IB/hfi1: Silence txreq allocation warnings IB/hfi1: Validate fault injection opcode user input usb: xhci: Don't try to recover an endpoint if port is in error state. xhci: detect USB 3.2 capable host controllers correctly usb: chipidea: udc: workaround for endpoint conflict issue scsi: ufs: Avoid runtime suspend possibly being blocked forever mmc: core: Prevent processing SDIO IRQs when the card is suspended mmc: core: Add sdio_retune_hold_now() and sdio_retune_release() mmc: core: API to temporarily disable retuning for SDIO CRC errors mmc: sdhci: sdhci-pci-o2micro: Correctly set bus width when tuning s390/ap: rework assembler functions to use unions for in/out register variables s390/jump_label: Use "jdd" constraint on gcc9 ovl: fix bogus -Wmaybe-unitialized warning ovl: don't fail with disconnected lower NFS ovl: detect overlapping layers ovl: make i_ino consistent with st_ino in more cases ovl: fix wrong flags check in FS_IOC_FS[SG]ETXATTR ioctls ovl: support the FS_IOC_FS[SG]ETXATTR ioctls gcc-9: silence 'address-of-packed-member' warning objtool: Support per-function rodata sections tracing: Silence GCC 9 array bounds warning Conflicts: Makefile drivers/mmc/core/sdio.c drivers/scsi/ufs/ufshcd-pltfrm.c Change-Id: I236ed854cc550b2953d984f4e6686ab871e42f45 Signed-off-by: Ivaylo Georgiev <irgeorgiev@codeaurora.org>
This commit is contained in:
commit
d355c0141d
4
Makefile
4
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 55
|
||||
SUBLEVEL = 56
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
@ -670,6 +670,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)
|
||||
|
||||
ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
|
||||
KBUILD_CFLAGS += -Os $(call cc-disable-warning,maybe-uninitialized,)
|
||||
@ -730,7 +731,6 @@ KBUILD_AFLAGS += $(CLANG_TARGET) $(CLANG_GCC_TC)
|
||||
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)
|
||||
KBUILD_CFLAGS += -Wno-asm-operand-widths
|
||||
KBUILD_CFLAGS += -Wno-initializer-overrides
|
||||
|
@ -175,6 +175,7 @@
|
||||
interrupt-names = "macirq";
|
||||
phy-mode = "rgmii";
|
||||
snps,pbl = <32>;
|
||||
snps,multicast-filter-bins = <256>;
|
||||
clocks = <&gmacclk>;
|
||||
clock-names = "stmmaceth";
|
||||
phy-handle = <&phy0>;
|
||||
@ -183,6 +184,9 @@
|
||||
mac-address = [00 00 00 00 00 00]; /* Filled in by U-Boot */
|
||||
dma-coherent;
|
||||
|
||||
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 */
|
||||
|
||||
|
@ -911,9 +911,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);
|
||||
|
||||
@ -921,9 +923,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);
|
||||
@ -937,14 +940,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;
|
||||
|
||||
|
@ -410,6 +410,7 @@
|
||||
vqmmc-supply = <&ldo1_reg>;
|
||||
bus-width = <4>;
|
||||
cd-gpios = <&gpio6 27 GPIO_ACTIVE_LOW>; /* gpio 219 */
|
||||
no-1-8-v;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
@ -22,7 +22,7 @@
|
||||
*
|
||||
* Datamanual Revisions:
|
||||
*
|
||||
* DRA76x Silicon Revision 1.0: SPRS993A, Revised July 2017
|
||||
* DRA76x Silicon Revision 1.0: SPRS993E, Revised December 2018
|
||||
*
|
||||
*/
|
||||
|
||||
@ -169,25 +169,25 @@
|
||||
/* Corresponds to MMC2_HS200_MANUAL1 in datamanual */
|
||||
mmc2_iodelay_hs200_conf: mmc2_iodelay_hs200_conf {
|
||||
pinctrl-pin-array = <
|
||||
0x190 A_DELAY_PS(384) G_DELAY_PS(0) /* CFG_GPMC_A19_OEN */
|
||||
0x194 A_DELAY_PS(0) G_DELAY_PS(174) /* CFG_GPMC_A19_OUT */
|
||||
0x1a8 A_DELAY_PS(410) G_DELAY_PS(0) /* CFG_GPMC_A20_OEN */
|
||||
0x1ac A_DELAY_PS(85) G_DELAY_PS(0) /* CFG_GPMC_A20_OUT */
|
||||
0x1b4 A_DELAY_PS(468) G_DELAY_PS(0) /* CFG_GPMC_A21_OEN */
|
||||
0x1b8 A_DELAY_PS(139) G_DELAY_PS(0) /* CFG_GPMC_A21_OUT */
|
||||
0x1c0 A_DELAY_PS(676) G_DELAY_PS(0) /* CFG_GPMC_A22_OEN */
|
||||
0x1c4 A_DELAY_PS(69) G_DELAY_PS(0) /* CFG_GPMC_A22_OUT */
|
||||
0x1d0 A_DELAY_PS(1062) G_DELAY_PS(154) /* CFG_GPMC_A23_OUT */
|
||||
0x1d8 A_DELAY_PS(640) G_DELAY_PS(0) /* CFG_GPMC_A24_OEN */
|
||||
0x1dc A_DELAY_PS(0) G_DELAY_PS(0) /* CFG_GPMC_A24_OUT */
|
||||
0x1e4 A_DELAY_PS(356) G_DELAY_PS(0) /* CFG_GPMC_A25_OEN */
|
||||
0x1e8 A_DELAY_PS(0) G_DELAY_PS(0) /* CFG_GPMC_A25_OUT */
|
||||
0x1f0 A_DELAY_PS(579) G_DELAY_PS(0) /* CFG_GPMC_A26_OEN */
|
||||
0x1f4 A_DELAY_PS(0) G_DELAY_PS(0) /* CFG_GPMC_A26_OUT */
|
||||
0x1fc A_DELAY_PS(435) G_DELAY_PS(0) /* CFG_GPMC_A27_OEN */
|
||||
0x200 A_DELAY_PS(36) G_DELAY_PS(0) /* CFG_GPMC_A27_OUT */
|
||||
0x364 A_DELAY_PS(759) G_DELAY_PS(0) /* CFG_GPMC_CS1_OEN */
|
||||
0x368 A_DELAY_PS(72) G_DELAY_PS(0) /* CFG_GPMC_CS1_OUT */
|
||||
0x190 A_DELAY_PS(384) G_DELAY_PS(0) /* CFG_GPMC_A19_OEN */
|
||||
0x194 A_DELAY_PS(350) G_DELAY_PS(174) /* CFG_GPMC_A19_OUT */
|
||||
0x1a8 A_DELAY_PS(410) G_DELAY_PS(0) /* CFG_GPMC_A20_OEN */
|
||||
0x1ac A_DELAY_PS(335) G_DELAY_PS(0) /* CFG_GPMC_A20_OUT */
|
||||
0x1b4 A_DELAY_PS(468) G_DELAY_PS(0) /* CFG_GPMC_A21_OEN */
|
||||
0x1b8 A_DELAY_PS(339) G_DELAY_PS(0) /* CFG_GPMC_A21_OUT */
|
||||
0x1c0 A_DELAY_PS(676) G_DELAY_PS(0) /* CFG_GPMC_A22_OEN */
|
||||
0x1c4 A_DELAY_PS(219) G_DELAY_PS(0) /* CFG_GPMC_A22_OUT */
|
||||
0x1d0 A_DELAY_PS(1062) G_DELAY_PS(154) /* CFG_GPMC_A23_OUT */
|
||||
0x1d8 A_DELAY_PS(640) G_DELAY_PS(0) /* CFG_GPMC_A24_OEN */
|
||||
0x1dc A_DELAY_PS(150) G_DELAY_PS(0) /* CFG_GPMC_A24_OUT */
|
||||
0x1e4 A_DELAY_PS(356) G_DELAY_PS(0) /* CFG_GPMC_A25_OEN */
|
||||
0x1e8 A_DELAY_PS(150) G_DELAY_PS(0) /* CFG_GPMC_A25_OUT */
|
||||
0x1f0 A_DELAY_PS(579) G_DELAY_PS(0) /* CFG_GPMC_A26_OEN */
|
||||
0x1f4 A_DELAY_PS(200) G_DELAY_PS(0) /* CFG_GPMC_A26_OUT */
|
||||
0x1fc A_DELAY_PS(435) G_DELAY_PS(0) /* CFG_GPMC_A27_OEN */
|
||||
0x200 A_DELAY_PS(236) G_DELAY_PS(0) /* CFG_GPMC_A27_OUT */
|
||||
0x364 A_DELAY_PS(759) G_DELAY_PS(0) /* CFG_GPMC_CS1_OEN */
|
||||
0x368 A_DELAY_PS(372) G_DELAY_PS(0) /* CFG_GPMC_CS1_OUT */
|
||||
>;
|
||||
};
|
||||
|
||||
|
@ -15,6 +15,7 @@
|
||||
|
||||
#include "common.h"
|
||||
#include "cpuidle.h"
|
||||
#include "hardware.h"
|
||||
|
||||
static int imx6sx_idle_finish(unsigned long val)
|
||||
{
|
||||
@ -110,7 +111,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);
|
||||
|
@ -56,6 +56,9 @@ KBUILD_CFLAGS += -mgeneral-regs-only
|
||||
endif
|
||||
KBUILD_CFLAGS += $(lseinstr) $(brokengasinst)
|
||||
KBUILD_CFLAGS += -fno-asynchronous-unwind-tables
|
||||
ifeq ($(cc-name),gcc)
|
||||
KBUILD_CFLAGS += -Wno-psabi
|
||||
endif
|
||||
KBUILD_AFLAGS += $(lseinstr) $(brokengasinst)
|
||||
|
||||
KBUILD_CFLAGS += $(call cc-option,-mabi=lp64)
|
||||
|
@ -65,8 +65,6 @@
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
||||
#include <linux/prctl.h>
|
||||
|
||||
/*
|
||||
* User structures for general purpose, floating point and debug registers.
|
||||
*/
|
||||
@ -113,10 +111,10 @@ struct user_sve_header {
|
||||
|
||||
/*
|
||||
* Common SVE_PT_* flags:
|
||||
* These must be kept in sync with prctl interface in <linux/ptrace.h>
|
||||
* These must be kept in sync with prctl interface in <linux/prctl.h>
|
||||
*/
|
||||
#define SVE_PT_VL_INHERIT (PR_SVE_VL_INHERIT >> 16)
|
||||
#define SVE_PT_VL_ONEXEC (PR_SVE_SET_VL_ONEXEC >> 16)
|
||||
#define SVE_PT_VL_INHERIT ((1 << 17) /* PR_SVE_VL_INHERIT */ >> 16)
|
||||
#define SVE_PT_VL_ONEXEC ((1 << 18) /* PR_SVE_SET_VL_ONEXEC */ >> 16)
|
||||
|
||||
|
||||
/*
|
||||
|
@ -5,6 +5,7 @@
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/prctl.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/sched/task_stack.h>
|
||||
#include <linux/thread_info.h>
|
||||
|
@ -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) \
|
||||
|
@ -336,6 +336,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
|
||||
|
@ -53,14 +53,48 @@ int hash__alloc_context_id(void)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(hash__alloc_context_id);
|
||||
|
||||
static int realloc_context_ids(mm_context_t *ctx)
|
||||
{
|
||||
int i, id;
|
||||
|
||||
/*
|
||||
* id 0 (aka. ctx->id) is special, we always allocate a new one, even if
|
||||
* there wasn't one allocated previously (which happens in the exec
|
||||
* case where ctx is newly allocated).
|
||||
*
|
||||
* We have to be a bit careful here. We must keep the existing ids in
|
||||
* the array, so that we can test if they're non-zero to decide if we
|
||||
* need to allocate a new one. However in case of error we must free the
|
||||
* ids we've allocated but *not* any of the existing ones (or risk a
|
||||
* UAF). That's why we decrement i at the start of the error handling
|
||||
* loop, to skip the id that we just tested but couldn't reallocate.
|
||||
*/
|
||||
for (i = 0; i < ARRAY_SIZE(ctx->extended_id); i++) {
|
||||
if (i == 0 || ctx->extended_id[i]) {
|
||||
id = hash__alloc_context_id();
|
||||
if (id < 0)
|
||||
goto error;
|
||||
|
||||
ctx->extended_id[i] = id;
|
||||
}
|
||||
}
|
||||
|
||||
/* The caller expects us to return id */
|
||||
return ctx->id;
|
||||
|
||||
error:
|
||||
for (i--; i >= 0; i--) {
|
||||
if (ctx->extended_id[i])
|
||||
ida_free(&mmu_context_ida, ctx->extended_id[i]);
|
||||
}
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
static int hash__init_new_context(struct mm_struct *mm)
|
||||
{
|
||||
int index;
|
||||
|
||||
index = hash__alloc_context_id();
|
||||
if (index < 0)
|
||||
return index;
|
||||
|
||||
/*
|
||||
* The old code would re-promote on fork, we don't do that when using
|
||||
* slices as it could cause problem promoting slices that have been
|
||||
@ -78,6 +112,10 @@ static int hash__init_new_context(struct mm_struct *mm)
|
||||
if (mm->context.id == 0)
|
||||
slice_init_new_context_exec(mm);
|
||||
|
||||
index = realloc_context_ids(&mm->context);
|
||||
if (index < 0)
|
||||
return index;
|
||||
|
||||
subpage_prot_init_new_context(mm);
|
||||
|
||||
pkey_mm_init(mm);
|
||||
|
@ -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))
|
||||
|
@ -372,12 +372,12 @@ static int bpf_jit_build_body(struct bpf_prog *fp, u32 *image,
|
||||
case BPF_ALU64 | BPF_DIV | BPF_X: /* dst /= src */
|
||||
case BPF_ALU64 | BPF_MOD | BPF_X: /* dst %= src */
|
||||
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 */
|
||||
@ -405,7 +405,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],
|
||||
@ -413,7 +413,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;
|
||||
}
|
||||
|
@ -29,6 +29,7 @@
|
||||
|
||||
#include <asm/pgalloc.h>
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/tlbflush.h>
|
||||
|
||||
/*
|
||||
* This routine handles page faults. It determines the address and the
|
||||
@ -281,6 +282,18 @@ vmalloc_fault:
|
||||
pte_k = pte_offset_kernel(pmd_k, addr);
|
||||
if (!pte_present(*pte_k))
|
||||
goto no_context;
|
||||
|
||||
/*
|
||||
* The kernel assumes that TLBs don't cache invalid
|
||||
* entries, but in RISC-V, SFENCE.VMA specifies an
|
||||
* ordering constraint, not a cache flush; it is
|
||||
* necessary even after writing invalid entries.
|
||||
* Relying on flush_tlb_fix_spurious_fault would
|
||||
* suffice, but the extra traps reduce
|
||||
* performance. So, eagerly SFENCE.VMA.
|
||||
*/
|
||||
local_flush_tlb_page(addr);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -221,16 +221,22 @@ static inline struct ap_queue_status ap_aqic(ap_qid_t qid,
|
||||
void *ind)
|
||||
{
|
||||
register unsigned long reg0 asm ("0") = qid | (3UL << 24);
|
||||
register struct ap_qirq_ctrl reg1_in asm ("1") = qirqctrl;
|
||||
register struct ap_queue_status reg1_out asm ("1");
|
||||
register union {
|
||||
unsigned long value;
|
||||
struct ap_qirq_ctrl qirqctrl;
|
||||
struct ap_queue_status status;
|
||||
} reg1 asm ("1");
|
||||
register void *reg2 asm ("2") = ind;
|
||||
|
||||
reg1.qirqctrl = qirqctrl;
|
||||
|
||||
asm volatile(
|
||||
".long 0xb2af0000" /* PQAP(AQIC) */
|
||||
: "=d" (reg1_out)
|
||||
: "d" (reg0), "d" (reg1_in), "d" (reg2)
|
||||
: "+d" (reg1)
|
||||
: "d" (reg0), "d" (reg2)
|
||||
: "cc");
|
||||
return reg1_out;
|
||||
|
||||
return reg1.status;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -264,17 +270,21 @@ static inline struct ap_queue_status ap_qact(ap_qid_t qid, int ifbit,
|
||||
{
|
||||
register unsigned long reg0 asm ("0") = qid | (5UL << 24)
|
||||
| ((ifbit & 0x01) << 22);
|
||||
register unsigned long reg1_in asm ("1") = apinfo->val;
|
||||
register struct ap_queue_status reg1_out asm ("1");
|
||||
register union {
|
||||
unsigned long value;
|
||||
struct ap_queue_status status;
|
||||
} reg1 asm ("1");
|
||||
register unsigned long reg2 asm ("2");
|
||||
|
||||
reg1.value = apinfo->val;
|
||||
|
||||
asm volatile(
|
||||
".long 0xb2af0000" /* PQAP(QACT) */
|
||||
: "+d" (reg1_in), "=d" (reg1_out), "=d" (reg2)
|
||||
: "+d" (reg1), "=d" (reg2)
|
||||
: "d" (reg0)
|
||||
: "cc");
|
||||
apinfo->val = reg2;
|
||||
return reg1_out;
|
||||
return reg1.status;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -10,6 +10,12 @@
|
||||
#define JUMP_LABEL_NOP_SIZE 6
|
||||
#define JUMP_LABEL_NOP_OFFSET 2
|
||||
|
||||
#if __GNUC__ < 9
|
||||
#define JUMP_LABEL_STATIC_KEY_CONSTRAINT "X"
|
||||
#else
|
||||
#define JUMP_LABEL_STATIC_KEY_CONSTRAINT "jdd"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* We use a brcl 0,2 instruction for jump labels at compile time so it
|
||||
* can be easily distinguished from a hotpatch generated instruction.
|
||||
@ -19,9 +25,9 @@ static __always_inline bool arch_static_branch(struct static_key *key, bool bran
|
||||
asm_volatile_goto("0: brcl 0,"__stringify(JUMP_LABEL_NOP_OFFSET)"\n"
|
||||
".pushsection __jump_table, \"aw\"\n"
|
||||
".balign 8\n"
|
||||
".quad 0b, %l[label], %0\n"
|
||||
".quad 0b, %l[label], %0+%1\n"
|
||||
".popsection\n"
|
||||
: : "X" (&((char *)key)[branch]) : : label);
|
||||
: : JUMP_LABEL_STATIC_KEY_CONSTRAINT (key), "i" (branch) : : label);
|
||||
|
||||
return false;
|
||||
label:
|
||||
@ -33,9 +39,9 @@ static __always_inline bool arch_static_branch_jump(struct static_key *key, bool
|
||||
asm_volatile_goto("0: brcl 15, %l[label]\n"
|
||||
".pushsection __jump_table, \"aw\"\n"
|
||||
".balign 8\n"
|
||||
".quad 0b, %l[label], %0\n"
|
||||
".quad 0b, %l[label], %0+%1\n"
|
||||
".popsection\n"
|
||||
: : "X" (&((char *)key)[branch]) : : label);
|
||||
: : JUMP_LABEL_STATIC_KEY_CONSTRAINT (key), "i" (branch) : : label);
|
||||
|
||||
return false;
|
||||
label:
|
||||
|
@ -357,6 +357,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);
|
||||
|
@ -2379,7 +2379,7 @@ static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp)
|
||||
if (closid_allocated(i) && i != closid) {
|
||||
mode = rdtgroup_mode_by_closid(i);
|
||||
if (mode == RDT_MODE_PSEUDO_LOCKSETUP)
|
||||
break;
|
||||
continue;
|
||||
used_b |= *ctrl;
|
||||
if (mode == RDT_MODE_SHAREABLE)
|
||||
d->new_ctrl |= *ctrl;
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -512,7 +512,8 @@ dma_chan_prep_dma_memcpy(struct dma_chan *dchan, dma_addr_t dst_adr,
|
||||
return vchan_tx_prep(&chan->vc, &first->vd, flags);
|
||||
|
||||
err_desc_get:
|
||||
axi_desc_put(first);
|
||||
if (first)
|
||||
axi_desc_put(first);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -663,7 +663,7 @@ static int sprd_dma_fill_desc(struct dma_chan *chan,
|
||||
temp |= slave_cfg->src_maxburst & SPRD_DMA_FRG_LEN_MASK;
|
||||
hw->frg_len = temp;
|
||||
|
||||
hw->blk_len = len & SPRD_DMA_BLK_LEN_MASK;
|
||||
hw->blk_len = slave_cfg->src_maxburst & SPRD_DMA_BLK_LEN_MASK;
|
||||
hw->trsc_len = len & SPRD_DMA_TRSC_LEN_MASK;
|
||||
|
||||
temp = (dst_step & SPRD_DMA_TRSF_STEP_MASK) << SPRD_DMA_DEST_TRSF_STEP_OFFSET;
|
||||
|
@ -399,7 +399,7 @@ int afu_dma_map_region(struct dfl_feature_platform_data *pdata,
|
||||
region->pages[0], 0,
|
||||
region->length,
|
||||
DMA_BIDIRECTIONAL);
|
||||
if (dma_mapping_error(&pdata->dev->dev, region->iova)) {
|
||||
if (dma_mapping_error(dfl_fpga_pdata_to_parent(pdata), region->iova)) {
|
||||
dev_err(&pdata->dev->dev, "failed to map for dma\n");
|
||||
ret = -EFAULT;
|
||||
goto unpin_pages;
|
||||
|
@ -40,6 +40,13 @@ enum dfl_fpga_devt_type {
|
||||
DFL_FPGA_DEVT_MAX,
|
||||
};
|
||||
|
||||
static struct lock_class_key dfl_pdata_keys[DFL_ID_MAX];
|
||||
|
||||
static const char *dfl_pdata_key_strings[DFL_ID_MAX] = {
|
||||
"dfl-fme-pdata",
|
||||
"dfl-port-pdata",
|
||||
};
|
||||
|
||||
/**
|
||||
* dfl_dev_info - dfl feature device information.
|
||||
* @name: name string of the feature platform device.
|
||||
@ -443,11 +450,16 @@ static int build_info_commit_dev(struct build_feature_devs_info *binfo)
|
||||
struct platform_device *fdev = binfo->feature_dev;
|
||||
struct dfl_feature_platform_data *pdata;
|
||||
struct dfl_feature_info *finfo, *p;
|
||||
enum dfl_id_type type;
|
||||
int ret, index = 0;
|
||||
|
||||
if (!fdev)
|
||||
return 0;
|
||||
|
||||
type = feature_dev_id_type(fdev);
|
||||
if (WARN_ON_ONCE(type >= DFL_ID_MAX))
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* we do not need to care for the memory which is associated with
|
||||
* the platform device. After calling platform_device_unregister(),
|
||||
@ -463,6 +475,8 @@ static int build_info_commit_dev(struct build_feature_devs_info *binfo)
|
||||
pdata->num = binfo->feature_num;
|
||||
pdata->dfl_cdev = binfo->cdev;
|
||||
mutex_init(&pdata->lock);
|
||||
lockdep_set_class_and_name(&pdata->lock, &dfl_pdata_keys[type],
|
||||
dfl_pdata_key_strings[type]);
|
||||
|
||||
/*
|
||||
* the count should be initialized to 0 to make sure
|
||||
@ -497,7 +511,7 @@ static int build_info_commit_dev(struct build_feature_devs_info *binfo)
|
||||
|
||||
ret = platform_device_add(binfo->feature_dev);
|
||||
if (!ret) {
|
||||
if (feature_dev_id_type(binfo->feature_dev) == PORT_ID)
|
||||
if (type == PORT_ID)
|
||||
dfl_fpga_cdev_add_port_dev(binfo->cdev,
|
||||
binfo->feature_dev);
|
||||
else
|
||||
|
@ -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,
|
||||
|
@ -190,6 +190,7 @@ static void malidp_atomic_commit_hw_done(struct drm_atomic_state *state)
|
||||
{
|
||||
struct drm_device *drm = state->dev;
|
||||
struct malidp_drm *malidp = drm->dev_private;
|
||||
int loop = 5;
|
||||
|
||||
malidp->event = malidp->crtc.state->event;
|
||||
malidp->crtc.state->event = NULL;
|
||||
@ -204,8 +205,18 @@ static void malidp_atomic_commit_hw_done(struct drm_atomic_state *state)
|
||||
drm_crtc_vblank_get(&malidp->crtc);
|
||||
|
||||
/* only set config_valid if the CRTC is enabled */
|
||||
if (malidp_set_and_wait_config_valid(drm) < 0)
|
||||
if (malidp_set_and_wait_config_valid(drm) < 0) {
|
||||
/*
|
||||
* make a loop around the second CVAL setting and
|
||||
* try 5 times before giving up.
|
||||
*/
|
||||
while (loop--) {
|
||||
if (!malidp_set_and_wait_config_valid(drm))
|
||||
break;
|
||||
}
|
||||
DRM_DEBUG_DRIVER("timed out waiting for updated configuration\n");
|
||||
}
|
||||
|
||||
} else if (malidp->event) {
|
||||
/* CRTC inactive means vblank IRQ is disabled, send event directly */
|
||||
spin_lock_irq(&drm->event_lock);
|
||||
|
@ -136,6 +136,114 @@ static int vmw_close_channel(struct rpc_channel *channel)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* vmw_port_hb_out - Send the message payload either through the
|
||||
* high-bandwidth port if available, or through the backdoor otherwise.
|
||||
* @channel: The rpc channel.
|
||||
* @msg: NULL-terminated message.
|
||||
* @hb: Whether the high-bandwidth port is available.
|
||||
*
|
||||
* Return: The port status.
|
||||
*/
|
||||
static unsigned long vmw_port_hb_out(struct rpc_channel *channel,
|
||||
const char *msg, bool hb)
|
||||
{
|
||||
unsigned long si, di, eax, ebx, ecx, edx;
|
||||
unsigned long msg_len = strlen(msg);
|
||||
|
||||
if (hb) {
|
||||
unsigned long bp = channel->cookie_high;
|
||||
|
||||
si = (uintptr_t) msg;
|
||||
di = channel->cookie_low;
|
||||
|
||||
VMW_PORT_HB_OUT(
|
||||
(MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
|
||||
msg_len, si, di,
|
||||
VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC, bp,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
return ebx;
|
||||
}
|
||||
|
||||
/* HB port not available. Send the message 4 bytes at a time. */
|
||||
ecx = MESSAGE_STATUS_SUCCESS << 16;
|
||||
while (msg_len && (HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS)) {
|
||||
unsigned int bytes = min_t(size_t, msg_len, 4);
|
||||
unsigned long word = 0;
|
||||
|
||||
memcpy(&word, msg, bytes);
|
||||
msg_len -= bytes;
|
||||
msg += bytes;
|
||||
si = channel->cookie_high;
|
||||
di = channel->cookie_low;
|
||||
|
||||
VMW_PORT(VMW_PORT_CMD_MSG | (MSG_TYPE_SENDPAYLOAD << 16),
|
||||
word, si, di,
|
||||
VMW_HYPERVISOR_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
}
|
||||
|
||||
return ecx;
|
||||
}
|
||||
|
||||
/**
|
||||
* vmw_port_hb_in - Receive the message payload either through the
|
||||
* high-bandwidth port if available, or through the backdoor otherwise.
|
||||
* @channel: The rpc channel.
|
||||
* @reply: Pointer to buffer holding reply.
|
||||
* @reply_len: Length of the reply.
|
||||
* @hb: Whether the high-bandwidth port is available.
|
||||
*
|
||||
* Return: The port status.
|
||||
*/
|
||||
static unsigned long vmw_port_hb_in(struct rpc_channel *channel, char *reply,
|
||||
unsigned long reply_len, bool hb)
|
||||
{
|
||||
unsigned long si, di, eax, ebx, ecx, edx;
|
||||
|
||||
if (hb) {
|
||||
unsigned long bp = channel->cookie_low;
|
||||
|
||||
si = channel->cookie_high;
|
||||
di = (uintptr_t) reply;
|
||||
|
||||
VMW_PORT_HB_IN(
|
||||
(MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
|
||||
reply_len, si, di,
|
||||
VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC, bp,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
return ebx;
|
||||
}
|
||||
|
||||
/* HB port not available. Retrieve the message 4 bytes at a time. */
|
||||
ecx = MESSAGE_STATUS_SUCCESS << 16;
|
||||
while (reply_len) {
|
||||
unsigned int bytes = min_t(unsigned long, reply_len, 4);
|
||||
|
||||
si = channel->cookie_high;
|
||||
di = channel->cookie_low;
|
||||
|
||||
VMW_PORT(VMW_PORT_CMD_MSG | (MSG_TYPE_RECVPAYLOAD << 16),
|
||||
MESSAGE_STATUS_SUCCESS, si, di,
|
||||
VMW_HYPERVISOR_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0)
|
||||
break;
|
||||
|
||||
memcpy(reply, &ebx, bytes);
|
||||
reply_len -= bytes;
|
||||
reply += bytes;
|
||||
}
|
||||
|
||||
return ecx;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
@ -148,11 +256,10 @@ static int vmw_close_channel(struct rpc_channel *channel)
|
||||
*/
|
||||
static int vmw_send_msg(struct rpc_channel *channel, const char *msg)
|
||||
{
|
||||
unsigned long eax, ebx, ecx, edx, si, di, bp;
|
||||
unsigned long eax, ebx, ecx, edx, si, di;
|
||||
size_t msg_len = strlen(msg);
|
||||
int retries = 0;
|
||||
|
||||
|
||||
while (retries < RETRIES) {
|
||||
retries++;
|
||||
|
||||
@ -166,23 +273,14 @@ static int vmw_send_msg(struct rpc_channel *channel, const char *msg)
|
||||
VMW_HYPERVISOR_MAGIC,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 ||
|
||||
(HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) {
|
||||
/* Expected success + high-bandwidth. Give up. */
|
||||
if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) {
|
||||
/* Expected success. Give up. */
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Send msg */
|
||||
si = (uintptr_t) msg;
|
||||
di = channel->cookie_low;
|
||||
bp = channel->cookie_high;
|
||||
|
||||
VMW_PORT_HB_OUT(
|
||||
(MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
|
||||
msg_len, si, di,
|
||||
VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC, bp,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
ebx = vmw_port_hb_out(channel, msg,
|
||||
!!(HIGH_WORD(ecx) & MESSAGE_STATUS_HB));
|
||||
|
||||
if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) != 0) {
|
||||
return 0;
|
||||
@ -211,7 +309,7 @@ STACK_FRAME_NON_STANDARD(vmw_send_msg);
|
||||
static int vmw_recv_msg(struct rpc_channel *channel, void **msg,
|
||||
size_t *msg_len)
|
||||
{
|
||||
unsigned long eax, ebx, ecx, edx, si, di, bp;
|
||||
unsigned long eax, ebx, ecx, edx, si, di;
|
||||
char *reply;
|
||||
size_t reply_len;
|
||||
int retries = 0;
|
||||
@ -233,8 +331,7 @@ static int vmw_recv_msg(struct rpc_channel *channel, void **msg,
|
||||
VMW_HYPERVISOR_MAGIC,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 ||
|
||||
(HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) {
|
||||
if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) {
|
||||
DRM_ERROR("Failed to get reply size for host message.\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
@ -252,17 +349,8 @@ static int vmw_recv_msg(struct rpc_channel *channel, void **msg,
|
||||
|
||||
|
||||
/* Receive buffer */
|
||||
si = channel->cookie_high;
|
||||
di = (uintptr_t) reply;
|
||||
bp = channel->cookie_low;
|
||||
|
||||
VMW_PORT_HB_IN(
|
||||
(MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
|
||||
reply_len, si, di,
|
||||
VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
|
||||
VMW_HYPERVISOR_MAGIC, bp,
|
||||
eax, ebx, ecx, edx, si, di);
|
||||
|
||||
ebx = vmw_port_hb_in(channel, reply, reply_len,
|
||||
!!(HIGH_WORD(ecx) & MESSAGE_STATUS_HB));
|
||||
if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) == 0) {
|
||||
kfree(reply);
|
||||
|
||||
|
@ -619,7 +619,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;
|
||||
|
@ -1230,7 +1230,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 */
|
||||
@ -1238,7 +1239,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;
|
||||
}
|
||||
@ -1271,6 +1272,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,
|
||||
@ -1284,14 +1309,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++;
|
||||
|
@ -81,6 +81,8 @@
|
||||
/* Magic constants */
|
||||
#define MLX90632_ID_MEDICAL 0x0105 /* EEPROM DSPv5 Medical device id */
|
||||
#define MLX90632_ID_CONSUMER 0x0205 /* EEPROM DSPv5 Consumer device id */
|
||||
#define MLX90632_DSP_VERSION 5 /* DSP version */
|
||||
#define MLX90632_DSP_MASK GENMASK(7, 0) /* DSP version in EE_VERSION */
|
||||
#define MLX90632_RESET_CMD 0x0006 /* Reset sensor (address or global) */
|
||||
#define MLX90632_REF_12 12LL /**< ResCtrlRef value of Ch 1 or Ch 2 */
|
||||
#define MLX90632_REF_3 12LL /**< ResCtrlRef value of Channel 3 */
|
||||
@ -666,10 +668,13 @@ static int mlx90632_probe(struct i2c_client *client,
|
||||
} else if (read == MLX90632_ID_CONSUMER) {
|
||||
dev_dbg(&client->dev,
|
||||
"Detected Consumer EEPROM calibration %x\n", read);
|
||||
} else if ((read & MLX90632_DSP_MASK) == MLX90632_DSP_VERSION) {
|
||||
dev_dbg(&client->dev,
|
||||
"Detected Unknown EEPROM calibration %x\n", read);
|
||||
} else {
|
||||
dev_err(&client->dev,
|
||||
"EEPROM version mismatch %x (expected %x or %x)\n",
|
||||
read, MLX90632_ID_CONSUMER, MLX90632_ID_MEDICAL);
|
||||
"Wrong DSP version %x (expected %x)\n",
|
||||
read, MLX90632_DSP_VERSION);
|
||||
return -EPROTONOSUPPORT;
|
||||
}
|
||||
|
||||
|
@ -9849,6 +9849,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)
|
||||
|
@ -153,6 +153,7 @@ static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
|
||||
char *dash;
|
||||
unsigned long range_start, range_end, i;
|
||||
bool remove = false;
|
||||
unsigned long bound = 1U << BITS_PER_BYTE;
|
||||
|
||||
end = strchr(ptr, ',');
|
||||
if (end)
|
||||
@ -178,6 +179,10 @@ static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
|
||||
BITS_PER_BYTE);
|
||||
break;
|
||||
}
|
||||
/* Check the inputs */
|
||||
if (range_start >= bound || range_end >= bound)
|
||||
break;
|
||||
|
||||
for (i = range_start; i <= range_end; i++) {
|
||||
if (remove)
|
||||
clear_bit(i, fault->opcodes);
|
||||
|
@ -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;
|
||||
|
@ -1418,8 +1418,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);
|
||||
}
|
||||
|
||||
|
@ -1051,13 +1051,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
|
||||
|
@ -604,6 +604,7 @@ static const struct acpi_device_id silead_ts_acpi_match[] = {
|
||||
{ "MSSL1680", 0 },
|
||||
{ "MSSL0001", 0 },
|
||||
{ "MSSL0002", 0 },
|
||||
{ "MSSL0017", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(acpi, silead_ts_acpi_match);
|
||||
|
@ -1015,8 +1015,9 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
|
||||
mmc_clk_scaling_stop_busy(host, true);
|
||||
|
||||
/* Flag re-tuning needed on CRC errors */
|
||||
if ((cmd->opcode != MMC_SEND_TUNING_BLOCK &&
|
||||
cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200) &&
|
||||
if (cmd->opcode != MMC_SEND_TUNING_BLOCK &&
|
||||
cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200 &&
|
||||
!host->retune_crc_disable &&
|
||||
(err == -EILSEQ || (mrq->sbc && mrq->sbc->error == -EILSEQ) ||
|
||||
(mrq->data && mrq->data->error == -EILSEQ) ||
|
||||
(mrq->stop && mrq->stop->error == -EILSEQ)))
|
||||
|
@ -935,6 +935,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);
|
||||
mmc_log_string(host, "Enter\n");
|
||||
|
||||
@ -986,13 +990,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_log_string(host, "Exit err: %d\n", err);
|
||||
mmc_release_host(host);
|
||||
|
||||
|
@ -18,6 +18,7 @@
|
||||
#include "sdio_ops.h"
|
||||
#include "core.h"
|
||||
#include "card.h"
|
||||
#include "host.h"
|
||||
|
||||
/**
|
||||
* sdio_claim_host - exclusively claim a bus for a certain SDIO function
|
||||
@ -725,3 +726,79 @@ int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags)
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sdio_set_host_pm_flags);
|
||||
|
||||
/**
|
||||
* sdio_retune_crc_disable - temporarily disable retuning on CRC errors
|
||||
* @func: SDIO function attached to host
|
||||
*
|
||||
* If the SDIO card is known to be in a state where it might produce
|
||||
* CRC errors on the bus in response to commands (like if we know it is
|
||||
* transitioning between power states), an SDIO function driver can
|
||||
* call this function to temporarily disable the SD/MMC core behavior of
|
||||
* triggering an automatic retuning.
|
||||
*
|
||||
* This function should be called while the host is claimed and the host
|
||||
* should remain claimed until sdio_retune_crc_enable() is called.
|
||||
* Specifically, the expected sequence of calls is:
|
||||
* - sdio_claim_host()
|
||||
* - sdio_retune_crc_disable()
|
||||
* - some number of calls like sdio_writeb() and sdio_readb()
|
||||
* - sdio_retune_crc_enable()
|
||||
* - sdio_release_host()
|
||||
*/
|
||||
void sdio_retune_crc_disable(struct sdio_func *func)
|
||||
{
|
||||
func->card->host->retune_crc_disable = true;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sdio_retune_crc_disable);
|
||||
|
||||
/**
|
||||
* sdio_retune_crc_enable - re-enable retuning on CRC errors
|
||||
* @func: SDIO function attached to host
|
||||
*
|
||||
* This is the compement to sdio_retune_crc_disable().
|
||||
*/
|
||||
void sdio_retune_crc_enable(struct sdio_func *func)
|
||||
{
|
||||
func->card->host->retune_crc_disable = false;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sdio_retune_crc_enable);
|
||||
|
||||
/**
|
||||
* sdio_retune_hold_now - start deferring retuning requests till release
|
||||
* @func: SDIO function attached to host
|
||||
*
|
||||
* This function can be called if it's currently a bad time to do
|
||||
* a retune of the SDIO card. Retune requests made during this time
|
||||
* will be held and we'll actually do the retune sometime after the
|
||||
* release.
|
||||
*
|
||||
* This function could be useful if an SDIO card is in a power state
|
||||
* where it can respond to a small subset of commands that doesn't
|
||||
* include the retuning command. Care should be taken when using
|
||||
* this function since (presumably) the retuning request we might be
|
||||
* deferring was made for a good reason.
|
||||
*
|
||||
* This function should be called while the host is claimed.
|
||||
*/
|
||||
void sdio_retune_hold_now(struct sdio_func *func)
|
||||
{
|
||||
mmc_retune_hold_now(func->card->host);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sdio_retune_hold_now);
|
||||
|
||||
/**
|
||||
* sdio_retune_release - signal that it's OK to retune now
|
||||
* @func: SDIO function attached to host
|
||||
*
|
||||
* This is the complement to sdio_retune_hold_now(). Calling this
|
||||
* function won't make a retune happen right away but will allow
|
||||
* them to be scheduled normally.
|
||||
*
|
||||
* This function should be called while the host is claimed.
|
||||
*/
|
||||
void sdio_retune_release(struct sdio_func *func)
|
||||
{
|
||||
mmc_retune_release(func->card->host);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sdio_retune_release);
|
||||
|
@ -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.
|
||||
|
@ -117,6 +117,7 @@ static int sdhci_o2_execute_tuning(struct mmc_host *mmc, u32 opcode)
|
||||
*/
|
||||
if (mmc->ios.bus_width == MMC_BUS_WIDTH_8) {
|
||||
current_bus_width = mmc->ios.bus_width;
|
||||
mmc->ios.bus_width = MMC_BUS_WIDTH_4;
|
||||
sdhci_set_bus_width(host, MMC_BUS_WIDTH_4);
|
||||
}
|
||||
|
||||
@ -128,8 +129,10 @@ static int sdhci_o2_execute_tuning(struct mmc_host *mmc, u32 opcode)
|
||||
|
||||
sdhci_end_tuning(host);
|
||||
|
||||
if (current_bus_width == MMC_BUS_WIDTH_8)
|
||||
if (current_bus_width == MMC_BUS_WIDTH_8) {
|
||||
mmc->ios.bus_width = MMC_BUS_WIDTH_8;
|
||||
sdhci_set_bus_width(host, current_bus_width);
|
||||
}
|
||||
|
||||
host->flags &= ~SDHCI_HS400_TUNING;
|
||||
return 0;
|
||||
|
@ -165,7 +165,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
|
||||
*
|
||||
|
@ -1424,7 +1424,7 @@ static const struct xcan_devtype_data xcan_canfd_data = {
|
||||
XCAN_FLAG_RXMNF |
|
||||
XCAN_FLAG_TX_MAILBOXES |
|
||||
XCAN_FLAG_RX_FIFO_MULTI,
|
||||
.bittiming_const = &xcan_bittiming_const,
|
||||
.bittiming_const = &xcan_bittiming_const_canfd,
|
||||
.btr_ts2_shift = XCAN_BTR_TS2_SHIFT_CANFD,
|
||||
.btr_sjw_shift = XCAN_BTR_SJW_SHIFT_CANFD,
|
||||
.bus_clk_name = "s_axi_aclk",
|
||||
|
@ -1484,7 +1484,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;
|
||||
|
@ -339,6 +339,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;
|
||||
@ -365,6 +366,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;
|
||||
}
|
||||
|
||||
|
@ -1784,6 +1784,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);
|
||||
@ -1800,7 +1801,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:
|
||||
|
@ -178,7 +178,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)
|
||||
|
@ -667,6 +667,12 @@ brcmf_sdio_kso_control(struct brcmf_sdio *bus, bool on)
|
||||
|
||||
brcmf_dbg(TRACE, "Enter: on=%d\n", on);
|
||||
|
||||
sdio_retune_crc_disable(bus->sdiodev->func1);
|
||||
|
||||
/* Cannot re-tune if device is asleep; defer till we're awake */
|
||||
if (on)
|
||||
sdio_retune_hold_now(bus->sdiodev->func1);
|
||||
|
||||
wr_val = (on << SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT);
|
||||
/* 1st KSO write goes to AOS wake up core if device is asleep */
|
||||
brcmf_sdiod_writeb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, wr_val, &err);
|
||||
@ -719,6 +725,11 @@ brcmf_sdio_kso_control(struct brcmf_sdio *bus, bool on)
|
||||
if (try_cnt > MAX_KSO_ATTEMPTS)
|
||||
brcmf_err("max tries: rd_val=0x%x err=%d\n", rd_val, err);
|
||||
|
||||
if (on)
|
||||
sdio_retune_release(bus->sdiodev->func1);
|
||||
|
||||
sdio_retune_crc_enable(bus->sdiodev->func1);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
|
@ -3228,7 +3228,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(NVME_IDENTIFY_DATA_SIZE, GFP_KERNEL);
|
||||
|
@ -239,6 +239,7 @@ u16 nvmet_bdev_parse_io_cmd(struct nvmet_req *req)
|
||||
return 0;
|
||||
case nvme_cmd_write_zeroes:
|
||||
req->execute = nvmet_bdev_execute_write_zeroes;
|
||||
req->data_len = 0;
|
||||
return 0;
|
||||
default:
|
||||
pr_err("unhandled cmd %d on qid %d\n", cmd->common.opcode,
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -1901,7 +1901,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,
|
||||
|
@ -3697,8 +3697,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;
|
||||
}
|
||||
}
|
||||
|
@ -533,6 +533,7 @@ int ufshcd_pltfrm_init(struct platform_device *pdev,
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
|
||||
dealloc_host:
|
||||
ufshcd_dealloc_host(hba);
|
||||
out:
|
||||
|
@ -3072,7 +3072,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;
|
||||
|
@ -17,10 +17,16 @@
|
||||
#define EROFS_SUPER_MAGIC_V1 0xE0F5E1E2
|
||||
#define EROFS_SUPER_OFFSET 1024
|
||||
|
||||
/*
|
||||
* Any bits that aren't in EROFS_ALL_REQUIREMENTS should be
|
||||
* incompatible with this kernel version.
|
||||
*/
|
||||
#define EROFS_ALL_REQUIREMENTS 0
|
||||
|
||||
struct erofs_super_block {
|
||||
/* 0 */__le32 magic; /* in the little endian */
|
||||
/* 4 */__le32 checksum; /* crc32c(super_block) */
|
||||
/* 8 */__le32 features;
|
||||
/* 8 */__le32 features; /* (aka. feature_compat) */
|
||||
/* 12 */__u8 blkszbits; /* support block_size == PAGE_SIZE only */
|
||||
/* 13 */__u8 reserved;
|
||||
|
||||
@ -34,9 +40,10 @@ struct erofs_super_block {
|
||||
/* 44 */__le32 xattr_blkaddr;
|
||||
/* 48 */__u8 uuid[16]; /* 128-bit uuid for volume */
|
||||
/* 64 */__u8 volume_name[16]; /* volume name */
|
||||
/* 80 */__le32 requirements; /* (aka. feature_incompat) */
|
||||
|
||||
/* 80 */__u8 reserved2[48]; /* 128 bytes */
|
||||
} __packed;
|
||||
/* 84 */__u8 reserved2[44];
|
||||
} __packed; /* 128 bytes */
|
||||
|
||||
#define __EROFS_BIT(_prefix, _cur, _pre) enum { \
|
||||
_prefix ## _cur ## _BIT = _prefix ## _pre ## _BIT + \
|
||||
|
@ -111,6 +111,8 @@ struct erofs_sb_info {
|
||||
|
||||
u8 uuid[16]; /* 128-bit uuid for volume */
|
||||
u8 volume_name[16]; /* volume name */
|
||||
u32 requirements;
|
||||
|
||||
char *dev_name;
|
||||
|
||||
unsigned int mount_opt;
|
||||
|
@ -75,6 +75,22 @@ static void destroy_inode(struct inode *inode)
|
||||
call_rcu(&inode->i_rcu, i_callback);
|
||||
}
|
||||
|
||||
static bool check_layout_compatibility(struct super_block *sb,
|
||||
struct erofs_super_block *layout)
|
||||
{
|
||||
const unsigned int requirements = le32_to_cpu(layout->requirements);
|
||||
|
||||
EROFS_SB(sb)->requirements = requirements;
|
||||
|
||||
/* check if current kernel meets all mandatory requirements */
|
||||
if (requirements & (~EROFS_ALL_REQUIREMENTS)) {
|
||||
errln("unidentified requirements %x, please upgrade kernel version",
|
||||
requirements & ~EROFS_ALL_REQUIREMENTS);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static int superblock_read(struct super_block *sb)
|
||||
{
|
||||
struct erofs_sb_info *sbi;
|
||||
@ -108,6 +124,9 @@ static int superblock_read(struct super_block *sb)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!check_layout_compatibility(sb, layout))
|
||||
goto out;
|
||||
|
||||
sbi->blocks = le32_to_cpu(layout->blocks);
|
||||
sbi->meta_blkaddr = le32_to_cpu(layout->meta_blkaddr);
|
||||
#ifdef CONFIG_EROFS_FS_XATTR
|
||||
|
@ -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)
|
||||
|
@ -1604,8 +1604,13 @@ static void handle_port_status(struct xhci_hcd *xhci,
|
||||
usb_hcd_resume_root_hub(hcd);
|
||||
}
|
||||
|
||||
if (hcd->speed >= HCD_USB3 && (portsc & PORT_PLS_MASK) == XDEV_INACTIVE)
|
||||
if (hcd->speed >= HCD_USB3 &&
|
||||
(portsc & PORT_PLS_MASK) == XDEV_INACTIVE) {
|
||||
slot_id = xhci_find_slot_id_by_port(hcd, xhci, hcd_portnum + 1);
|
||||
if (slot_id && xhci->devs[slot_id])
|
||||
xhci->devs[slot_id]->flags |= VDEV_PORT_ERROR;
|
||||
bus_state->port_remote_wakeup &= ~(1 << hcd_portnum);
|
||||
}
|
||||
|
||||
if ((portsc & PORT_PLC) && (portsc & PORT_PLS_MASK) == XDEV_RESUME) {
|
||||
xhci_dbg(xhci, "port resume event for port %d\n", port_id);
|
||||
@ -1793,6 +1798,14 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
|
||||
{
|
||||
struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
|
||||
struct xhci_command *command;
|
||||
|
||||
/*
|
||||
* Avoid resetting endpoint if link is inactive. Can cause host hang.
|
||||
* Device will be reset soon to recover the link so don't do anything
|
||||
*/
|
||||
if (xhci->devs[slot_id]->flags & VDEV_PORT_ERROR)
|
||||
return;
|
||||
|
||||
command = xhci_alloc_command(xhci, false, GFP_ATOMIC);
|
||||
if (!command)
|
||||
return;
|
||||
|
@ -1470,6 +1470,10 @@ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flag
|
||||
xhci_dbg(xhci, "urb submitted during PCI suspend\n");
|
||||
return -ESHUTDOWN;
|
||||
}
|
||||
if (xhci->devs[slot_id]->flags & VDEV_PORT_ERROR) {
|
||||
xhci_dbg(xhci, "Can't queue urb, port error, link inactive\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
if (usb_endpoint_xfer_isoc(&urb->ep->desc))
|
||||
num_tds = urb->number_of_packets;
|
||||
@ -3753,6 +3757,7 @@ static int xhci_discover_or_reset_device(struct usb_hcd *hcd,
|
||||
}
|
||||
/* If necessary, update the number of active TTs on this root port */
|
||||
xhci_update_tt_active_eps(xhci, virt_dev, old_active_eps);
|
||||
virt_dev->flags = 0;
|
||||
ret = 0;
|
||||
|
||||
command_cleanup:
|
||||
@ -5059,16 +5064,26 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
|
||||
} else {
|
||||
/*
|
||||
* Some 3.1 hosts return sbrn 0x30, use xhci supported protocol
|
||||
* minor revision instead of sbrn
|
||||
* minor revision instead of sbrn. Minor revision is a two digit
|
||||
* BCD containing minor and sub-minor numbers, only show minor.
|
||||
*/
|
||||
minor_rev = xhci->usb3_rhub.min_rev;
|
||||
if (minor_rev) {
|
||||
minor_rev = xhci->usb3_rhub.min_rev / 0x10;
|
||||
|
||||
switch (minor_rev) {
|
||||
case 2:
|
||||
hcd->speed = HCD_USB32;
|
||||
hcd->self.root_hub->speed = USB_SPEED_SUPER_PLUS;
|
||||
hcd->self.root_hub->rx_lanes = 2;
|
||||
hcd->self.root_hub->tx_lanes = 2;
|
||||
break;
|
||||
case 1:
|
||||
hcd->speed = HCD_USB31;
|
||||
hcd->self.root_hub->speed = USB_SPEED_SUPER_PLUS;
|
||||
break;
|
||||
}
|
||||
xhci_info(xhci, "Host supports USB 3.%x %s SuperSpeed\n",
|
||||
xhci_info(xhci, "Host supports USB 3.%x %sSuperSpeed\n",
|
||||
minor_rev,
|
||||
minor_rev ? "Enhanced" : "");
|
||||
minor_rev ? "Enhanced " : "");
|
||||
|
||||
xhci->usb3_rhub.hcd = hcd;
|
||||
/* xHCI private pointer was set in xhci_pci_probe for the second
|
||||
|
@ -1010,6 +1010,15 @@ struct xhci_virt_device {
|
||||
u8 real_port;
|
||||
struct xhci_interval_bw_table *bw_table;
|
||||
struct xhci_tt_bw_info *tt_info;
|
||||
/*
|
||||
* flags for state tracking based on events and issued commands.
|
||||
* Software can not rely on states from output contexts because of
|
||||
* latency between events and xHC updating output context values.
|
||||
* See xhci 1.1 section 4.8.3 for more details
|
||||
*/
|
||||
unsigned long flags;
|
||||
#define VDEV_PORT_ERROR BIT(0) /* Port error, link inactive */
|
||||
|
||||
/* The current max exit latency for the enabled USB3 link states. */
|
||||
u16 current_mel;
|
||||
/* Used for the debugfs interfaces. */
|
||||
|
@ -745,6 +745,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);
|
||||
@ -756,6 +757,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;
|
||||
|
@ -457,7 +457,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"},
|
||||
|
@ -409,36 +409,16 @@ static long ovl_real_ioctl(struct file *file, unsigned int cmd,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static unsigned int ovl_get_inode_flags(struct inode *inode)
|
||||
{
|
||||
unsigned int flags = READ_ONCE(inode->i_flags);
|
||||
unsigned int ovl_iflags = 0;
|
||||
|
||||
if (flags & S_SYNC)
|
||||
ovl_iflags |= FS_SYNC_FL;
|
||||
if (flags & S_APPEND)
|
||||
ovl_iflags |= FS_APPEND_FL;
|
||||
if (flags & S_IMMUTABLE)
|
||||
ovl_iflags |= FS_IMMUTABLE_FL;
|
||||
if (flags & S_NOATIME)
|
||||
ovl_iflags |= FS_NOATIME_FL;
|
||||
|
||||
return ovl_iflags;
|
||||
}
|
||||
|
||||
static long ovl_ioctl_set_flags(struct file *file, unsigned long arg)
|
||||
static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd,
|
||||
unsigned long arg, unsigned int iflags)
|
||||
{
|
||||
long ret;
|
||||
struct inode *inode = file_inode(file);
|
||||
unsigned int flags;
|
||||
unsigned int old_flags;
|
||||
unsigned int old_iflags;
|
||||
|
||||
if (!inode_owner_or_capable(inode))
|
||||
return -EACCES;
|
||||
|
||||
if (get_user(flags, (int __user *) arg))
|
||||
return -EFAULT;
|
||||
|
||||
ret = mnt_want_write_file(file);
|
||||
if (ret)
|
||||
return ret;
|
||||
@ -447,8 +427,8 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned long arg)
|
||||
|
||||
/* Check the capability before cred override */
|
||||
ret = -EPERM;
|
||||
old_flags = ovl_get_inode_flags(inode);
|
||||
if (((flags ^ old_flags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) &&
|
||||
old_iflags = READ_ONCE(inode->i_flags);
|
||||
if (((iflags ^ old_iflags) & (S_APPEND | S_IMMUTABLE)) &&
|
||||
!capable(CAP_LINUX_IMMUTABLE))
|
||||
goto unlock;
|
||||
|
||||
@ -456,7 +436,7 @@ static long ovl_ioctl_set_flags(struct file *file, unsigned long arg)
|
||||
if (ret)
|
||||
goto unlock;
|
||||
|
||||
ret = ovl_real_ioctl(file, FS_IOC_SETFLAGS, arg);
|
||||
ret = ovl_real_ioctl(file, cmd, arg);
|
||||
|
||||
ovl_copyflags(ovl_inode_real(inode), inode);
|
||||
unlock:
|
||||
@ -468,17 +448,79 @@ unlock:
|
||||
|
||||
}
|
||||
|
||||
static unsigned int ovl_fsflags_to_iflags(unsigned int flags)
|
||||
{
|
||||
unsigned int iflags = 0;
|
||||
|
||||
if (flags & FS_SYNC_FL)
|
||||
iflags |= S_SYNC;
|
||||
if (flags & FS_APPEND_FL)
|
||||
iflags |= S_APPEND;
|
||||
if (flags & FS_IMMUTABLE_FL)
|
||||
iflags |= S_IMMUTABLE;
|
||||
if (flags & FS_NOATIME_FL)
|
||||
iflags |= S_NOATIME;
|
||||
|
||||
return iflags;
|
||||
}
|
||||
|
||||
static long ovl_ioctl_set_fsflags(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
unsigned int flags;
|
||||
|
||||
if (get_user(flags, (int __user *) arg))
|
||||
return -EFAULT;
|
||||
|
||||
return ovl_ioctl_set_flags(file, cmd, arg,
|
||||
ovl_fsflags_to_iflags(flags));
|
||||
}
|
||||
|
||||
static unsigned int ovl_fsxflags_to_iflags(unsigned int xflags)
|
||||
{
|
||||
unsigned int iflags = 0;
|
||||
|
||||
if (xflags & FS_XFLAG_SYNC)
|
||||
iflags |= S_SYNC;
|
||||
if (xflags & FS_XFLAG_APPEND)
|
||||
iflags |= S_APPEND;
|
||||
if (xflags & FS_XFLAG_IMMUTABLE)
|
||||
iflags |= S_IMMUTABLE;
|
||||
if (xflags & FS_XFLAG_NOATIME)
|
||||
iflags |= S_NOATIME;
|
||||
|
||||
return iflags;
|
||||
}
|
||||
|
||||
static long ovl_ioctl_set_fsxflags(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
struct fsxattr fa;
|
||||
|
||||
memset(&fa, 0, sizeof(fa));
|
||||
if (copy_from_user(&fa, (void __user *) arg, sizeof(fa)))
|
||||
return -EFAULT;
|
||||
|
||||
return ovl_ioctl_set_flags(file, cmd, arg,
|
||||
ovl_fsxflags_to_iflags(fa.fsx_xflags));
|
||||
}
|
||||
|
||||
static long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
long ret;
|
||||
|
||||
switch (cmd) {
|
||||
case FS_IOC_GETFLAGS:
|
||||
case FS_IOC_FSGETXATTR:
|
||||
ret = ovl_real_ioctl(file, cmd, arg);
|
||||
break;
|
||||
|
||||
case FS_IOC_SETFLAGS:
|
||||
ret = ovl_ioctl_set_flags(file, arg);
|
||||
ret = ovl_ioctl_set_fsflags(file, cmd, arg);
|
||||
break;
|
||||
|
||||
case FS_IOC_FSSETXATTR:
|
||||
ret = ovl_ioctl_set_fsxflags(file, cmd, arg);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -553,15 +553,15 @@ static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev,
|
||||
int xinobits = ovl_xino_bits(inode->i_sb);
|
||||
|
||||
/*
|
||||
* When NFS export is enabled and d_ino is consistent with st_ino
|
||||
* (samefs or i_ino has enough bits to encode layer), set the same
|
||||
* value used for d_ino to i_ino, because nfsd readdirplus compares
|
||||
* d_ino values to i_ino values of child entries. When called from
|
||||
* When d_ino is consistent with st_ino (samefs or i_ino has enough
|
||||
* bits to encode layer), set the same value used for st_ino to i_ino,
|
||||
* so inode number exposed via /proc/locks and a like will be
|
||||
* consistent with d_ino and st_ino values. An i_ino value inconsistent
|
||||
* with d_ino also causes nfsd readdirplus to fail. When called from
|
||||
* ovl_new_inode(), ino arg is 0, so i_ino will be updated to real
|
||||
* upper inode i_ino on ovl_inode_init() or ovl_inode_update().
|
||||
*/
|
||||
if (inode->i_sb->s_export_op &&
|
||||
(ovl_same_sb(inode->i_sb) || xinobits)) {
|
||||
if (ovl_same_sb(inode->i_sb) || xinobits) {
|
||||
inode->i_ino = ino;
|
||||
if (xinobits && fsid && !(ino >> (64 - xinobits)))
|
||||
inode->i_ino |= (unsigned long)fsid << (64 - xinobits);
|
||||
@ -777,6 +777,54 @@ struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real,
|
||||
return inode;
|
||||
}
|
||||
|
||||
bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir)
|
||||
{
|
||||
struct inode *key = d_inode(dir);
|
||||
struct inode *trap;
|
||||
bool res;
|
||||
|
||||
trap = ilookup5(sb, (unsigned long) key, ovl_inode_test, key);
|
||||
if (!trap)
|
||||
return false;
|
||||
|
||||
res = IS_DEADDIR(trap) && !ovl_inode_upper(trap) &&
|
||||
!ovl_inode_lower(trap);
|
||||
|
||||
iput(trap);
|
||||
return res;
|
||||
}
|
||||
|
||||
/*
|
||||
* Create an inode cache entry for layer root dir, that will intentionally
|
||||
* fail ovl_verify_inode(), so any lookup that will find some layer root
|
||||
* will fail.
|
||||
*/
|
||||
struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir)
|
||||
{
|
||||
struct inode *key = d_inode(dir);
|
||||
struct inode *trap;
|
||||
|
||||
if (!d_is_dir(dir))
|
||||
return ERR_PTR(-ENOTDIR);
|
||||
|
||||
trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test,
|
||||
ovl_inode_set, key);
|
||||
if (!trap)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
if (!(trap->i_state & I_NEW)) {
|
||||
/* Conflicting layer roots? */
|
||||
iput(trap);
|
||||
return ERR_PTR(-ELOOP);
|
||||
}
|
||||
|
||||
trap->i_mode = S_IFDIR;
|
||||
trap->i_flags = S_DEAD;
|
||||
unlock_new_inode(trap);
|
||||
|
||||
return trap;
|
||||
}
|
||||
|
||||
/*
|
||||
* Does overlay inode need to be hashed by lower inode?
|
||||
*/
|
||||
|
@ -18,6 +18,7 @@
|
||||
#include "overlayfs.h"
|
||||
|
||||
struct ovl_lookup_data {
|
||||
struct super_block *sb;
|
||||
struct qstr name;
|
||||
bool is_dir;
|
||||
bool opaque;
|
||||
@ -244,6 +245,12 @@ static int ovl_lookup_single(struct dentry *base, struct ovl_lookup_data *d,
|
||||
if (!d->metacopy || d->last)
|
||||
goto out;
|
||||
} else {
|
||||
if (ovl_lookup_trap_inode(d->sb, this)) {
|
||||
/* Caught in a trap of overlapping layers */
|
||||
err = -ELOOP;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
if (last_element)
|
||||
d->is_dir = true;
|
||||
if (d->last)
|
||||
@ -819,6 +826,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
|
||||
int err;
|
||||
bool metacopy = false;
|
||||
struct ovl_lookup_data d = {
|
||||
.sb = dentry->d_sb,
|
||||
.name = dentry->d_name,
|
||||
.is_dir = false,
|
||||
.opaque = false,
|
||||
|
@ -271,6 +271,7 @@ void ovl_clear_flag(unsigned long flag, struct inode *inode);
|
||||
bool ovl_test_flag(unsigned long flag, struct inode *inode);
|
||||
bool ovl_inuse_trylock(struct dentry *dentry);
|
||||
void ovl_inuse_unlock(struct dentry *dentry);
|
||||
bool ovl_is_inuse(struct dentry *dentry);
|
||||
bool ovl_need_index(struct dentry *dentry);
|
||||
int ovl_nlink_start(struct dentry *dentry, bool *locked);
|
||||
void ovl_nlink_end(struct dentry *dentry, bool locked);
|
||||
@ -367,6 +368,8 @@ struct ovl_inode_params {
|
||||
struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev);
|
||||
struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real,
|
||||
bool is_upper);
|
||||
bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir);
|
||||
struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir);
|
||||
struct inode *ovl_get_inode(struct super_block *sb,
|
||||
struct ovl_inode_params *oip);
|
||||
static inline void ovl_copyattr(struct inode *from, struct inode *to)
|
||||
|
@ -30,6 +30,8 @@ struct ovl_sb {
|
||||
|
||||
struct ovl_layer {
|
||||
struct vfsmount *mnt;
|
||||
/* Trap in ovl inode cache */
|
||||
struct inode *trap;
|
||||
struct ovl_sb *fs;
|
||||
/* Index of this layer in fs root (upper idx == 0) */
|
||||
int idx;
|
||||
@ -66,6 +68,10 @@ struct ovl_fs {
|
||||
/* Did we take the inuse lock? */
|
||||
bool upperdir_locked;
|
||||
bool workdir_locked;
|
||||
/* Traps in ovl inode cache */
|
||||
struct inode *upperdir_trap;
|
||||
struct inode *workdir_trap;
|
||||
struct inode *indexdir_trap;
|
||||
/* Inode numbers in all layers do not use the high xino_bits */
|
||||
unsigned int xino_bits;
|
||||
};
|
||||
|
@ -222,6 +222,9 @@ static void ovl_free_fs(struct ovl_fs *ofs)
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
iput(ofs->indexdir_trap);
|
||||
iput(ofs->workdir_trap);
|
||||
iput(ofs->upperdir_trap);
|
||||
dput(ofs->indexdir);
|
||||
dput(ofs->workdir);
|
||||
if (ofs->workdir_locked)
|
||||
@ -230,8 +233,10 @@ static void ovl_free_fs(struct ovl_fs *ofs)
|
||||
if (ofs->upperdir_locked)
|
||||
ovl_inuse_unlock(ofs->upper_mnt->mnt_root);
|
||||
mntput(ofs->upper_mnt);
|
||||
for (i = 0; i < ofs->numlower; i++)
|
||||
for (i = 0; i < ofs->numlower; i++) {
|
||||
iput(ofs->lower_layers[i].trap);
|
||||
mntput(ofs->lower_layers[i].mnt);
|
||||
}
|
||||
for (i = 0; i < ofs->numlowerfs; i++)
|
||||
free_anon_bdev(ofs->lower_fs[i].pseudo_dev);
|
||||
kfree(ofs->lower_layers);
|
||||
@ -1005,7 +1010,26 @@ static const struct xattr_handler *ovl_xattr_handlers[] = {
|
||||
NULL
|
||||
};
|
||||
|
||||
static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath)
|
||||
static int ovl_setup_trap(struct super_block *sb, struct dentry *dir,
|
||||
struct inode **ptrap, const char *name)
|
||||
{
|
||||
struct inode *trap;
|
||||
int err;
|
||||
|
||||
trap = ovl_get_trap_inode(sb, dir);
|
||||
err = PTR_ERR_OR_ZERO(trap);
|
||||
if (err) {
|
||||
if (err == -ELOOP)
|
||||
pr_err("overlayfs: conflicting %s path\n", name);
|
||||
return err;
|
||||
}
|
||||
|
||||
*ptrap = trap;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct path *upperpath)
|
||||
{
|
||||
struct vfsmount *upper_mnt;
|
||||
int err;
|
||||
@ -1025,6 +1049,11 @@ static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath)
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = ovl_setup_trap(sb, upperpath->dentry, &ofs->upperdir_trap,
|
||||
"upperdir");
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
upper_mnt = clone_private_mount(upperpath);
|
||||
err = PTR_ERR(upper_mnt);
|
||||
if (IS_ERR(upper_mnt)) {
|
||||
@ -1051,7 +1080,8 @@ out:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath)
|
||||
static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct path *workpath)
|
||||
{
|
||||
struct vfsmount *mnt = ofs->upper_mnt;
|
||||
struct dentry *temp;
|
||||
@ -1066,6 +1096,10 @@ static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath)
|
||||
if (!ofs->workdir)
|
||||
goto out;
|
||||
|
||||
err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir");
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* Upper should support d_type, else whiteouts are visible. Given
|
||||
* workdir and upper are on same fs, we can do iterate_dir() on
|
||||
@ -1126,7 +1160,8 @@ out:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath)
|
||||
static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct path *upperpath)
|
||||
{
|
||||
int err;
|
||||
struct path workpath = { };
|
||||
@ -1157,19 +1192,16 @@ static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath)
|
||||
pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
|
||||
}
|
||||
|
||||
err = ovl_make_workdir(ofs, &workpath);
|
||||
if (err)
|
||||
goto out;
|
||||
err = ovl_make_workdir(sb, ofs, &workpath);
|
||||
|
||||
err = 0;
|
||||
out:
|
||||
path_put(&workpath);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe,
|
||||
struct path *upperpath)
|
||||
static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct ovl_entry *oe, struct path *upperpath)
|
||||
{
|
||||
struct vfsmount *mnt = ofs->upper_mnt;
|
||||
int err;
|
||||
@ -1188,6 +1220,11 @@ static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe,
|
||||
|
||||
ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true);
|
||||
if (ofs->indexdir) {
|
||||
err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap,
|
||||
"indexdir");
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* Verify upper root is exclusively associated with index dir.
|
||||
* Older kernels stored upper fh in "trusted.overlay.origin"
|
||||
@ -1247,8 +1284,8 @@ static int ovl_get_fsid(struct ovl_fs *ofs, struct super_block *sb)
|
||||
return ofs->numlowerfs;
|
||||
}
|
||||
|
||||
static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack,
|
||||
unsigned int numlower)
|
||||
static int ovl_get_lower_layers(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct path *stack, unsigned int numlower)
|
||||
{
|
||||
int err;
|
||||
unsigned int i;
|
||||
@ -1266,16 +1303,28 @@ static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack,
|
||||
|
||||
for (i = 0; i < numlower; i++) {
|
||||
struct vfsmount *mnt;
|
||||
struct inode *trap;
|
||||
int fsid;
|
||||
|
||||
err = fsid = ovl_get_fsid(ofs, stack[i].mnt->mnt_sb);
|
||||
if (err < 0)
|
||||
goto out;
|
||||
|
||||
err = -EBUSY;
|
||||
if (ovl_is_inuse(stack[i].dentry)) {
|
||||
pr_err("overlayfs: lowerdir is in-use as upperdir/workdir\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir");
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
mnt = clone_private_mount(&stack[i]);
|
||||
err = PTR_ERR(mnt);
|
||||
if (IS_ERR(mnt)) {
|
||||
pr_err("overlayfs: failed to clone lowerpath\n");
|
||||
iput(trap);
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -1285,6 +1334,7 @@ static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack,
|
||||
*/
|
||||
mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
|
||||
|
||||
ofs->lower_layers[ofs->numlower].trap = trap;
|
||||
ofs->lower_layers[ofs->numlower].mnt = mnt;
|
||||
ofs->lower_layers[ofs->numlower].idx = i + 1;
|
||||
ofs->lower_layers[ofs->numlower].fsid = fsid;
|
||||
@ -1379,7 +1429,7 @@ static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb,
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
err = ovl_get_lower_layers(ofs, stack, numlower);
|
||||
err = ovl_get_lower_layers(sb, ofs, stack, numlower);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
@ -1411,6 +1461,77 @@ out_err:
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check if this layer root is a descendant of:
|
||||
* - another layer of this overlayfs instance
|
||||
* - upper/work dir of any overlayfs instance
|
||||
*/
|
||||
static int ovl_check_layer(struct super_block *sb, struct dentry *dentry,
|
||||
const char *name)
|
||||
{
|
||||
struct dentry *next = dentry, *parent;
|
||||
int err = 0;
|
||||
|
||||
if (!dentry)
|
||||
return 0;
|
||||
|
||||
parent = dget_parent(next);
|
||||
|
||||
/* Walk back ancestors to root (inclusive) looking for traps */
|
||||
while (!err && parent != next) {
|
||||
if (ovl_is_inuse(parent)) {
|
||||
err = -EBUSY;
|
||||
pr_err("overlayfs: %s path overlapping in-use upperdir/workdir\n",
|
||||
name);
|
||||
} else if (ovl_lookup_trap_inode(sb, parent)) {
|
||||
err = -ELOOP;
|
||||
pr_err("overlayfs: overlapping %s path\n", name);
|
||||
}
|
||||
next = parent;
|
||||
parent = dget_parent(next);
|
||||
dput(next);
|
||||
}
|
||||
|
||||
dput(parent);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check if any of the layers or work dirs overlap.
|
||||
*/
|
||||
static int ovl_check_overlapping_layers(struct super_block *sb,
|
||||
struct ovl_fs *ofs)
|
||||
{
|
||||
int i, err;
|
||||
|
||||
if (ofs->upper_mnt) {
|
||||
err = ovl_check_layer(sb, ofs->upper_mnt->mnt_root, "upperdir");
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/*
|
||||
* Checking workbasedir avoids hitting ovl_is_inuse(parent) of
|
||||
* this instance and covers overlapping work and index dirs,
|
||||
* unless work or index dir have been moved since created inside
|
||||
* workbasedir. In that case, we already have their traps in
|
||||
* inode cache and we will catch that case on lookup.
|
||||
*/
|
||||
err = ovl_check_layer(sb, ofs->workbasedir, "workdir");
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
for (i = 0; i < ofs->numlower; i++) {
|
||||
err = ovl_check_layer(sb, ofs->lower_layers[i].mnt->mnt_root,
|
||||
"lowerdir");
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
{
|
||||
struct path upperpath = { };
|
||||
@ -1450,17 +1571,20 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
if (ofs->config.xino != OVL_XINO_OFF)
|
||||
ofs->xino_bits = BITS_PER_LONG - 32;
|
||||
|
||||
/* alloc/destroy_inode needed for setting up traps in inode cache */
|
||||
sb->s_op = &ovl_super_operations;
|
||||
|
||||
if (ofs->config.upperdir) {
|
||||
if (!ofs->config.workdir) {
|
||||
pr_err("overlayfs: missing 'workdir'\n");
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
err = ovl_get_upper(ofs, &upperpath);
|
||||
err = ovl_get_upper(sb, ofs, &upperpath);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
err = ovl_get_workdir(ofs, &upperpath);
|
||||
err = ovl_get_workdir(sb, ofs, &upperpath);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
@ -1481,7 +1605,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
sb->s_flags |= SB_RDONLY;
|
||||
|
||||
if (!(ovl_force_readonly(ofs)) && ofs->config.index) {
|
||||
err = ovl_get_indexdir(ofs, oe, &upperpath);
|
||||
err = ovl_get_indexdir(sb, ofs, oe, &upperpath);
|
||||
if (err)
|
||||
goto out_free_oe;
|
||||
|
||||
@ -1494,6 +1618,10 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
|
||||
}
|
||||
|
||||
err = ovl_check_overlapping_layers(sb, ofs);
|
||||
if (err)
|
||||
goto out_free_oe;
|
||||
|
||||
/* Show index=off in /proc/mounts for forced r/o mount */
|
||||
if (!ofs->indexdir) {
|
||||
ofs->config.index = false;
|
||||
@ -1515,7 +1643,6 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
|
||||
cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);
|
||||
|
||||
sb->s_magic = OVERLAYFS_SUPER_MAGIC;
|
||||
sb->s_op = &ovl_super_operations;
|
||||
sb->s_xattr = ovl_xattr_handlers;
|
||||
sb->s_fs_info = ofs;
|
||||
sb->s_flags |= SB_POSIXACL;
|
||||
|
@ -661,6 +661,18 @@ void ovl_inuse_unlock(struct dentry *dentry)
|
||||
}
|
||||
}
|
||||
|
||||
bool ovl_is_inuse(struct dentry *dentry)
|
||||
{
|
||||
struct inode *inode = d_inode(dentry);
|
||||
bool inuse;
|
||||
|
||||
spin_lock(&inode->i_lock);
|
||||
inuse = (inode->i_state & I_OVL_INUSE);
|
||||
spin_unlock(&inode->i_lock);
|
||||
|
||||
return inuse;
|
||||
}
|
||||
|
||||
/*
|
||||
* Does this overlay dentry need to be indexed on copy up?
|
||||
*/
|
||||
|
@ -529,6 +529,7 @@ struct mmc_host {
|
||||
unsigned int retune_now:1; /* do re-tuning at next req */
|
||||
unsigned int retune_paused:1; /* re-tuning is temporarily disabled */
|
||||
unsigned int use_blk_mq:1; /* use blk-mq */
|
||||
unsigned int retune_crc_disable:1; /* don't trigger retune upon crc */
|
||||
|
||||
int rescan_disable; /* disable card detection */
|
||||
int rescan_entered; /* used with nonremovable devices */
|
||||
|
@ -159,4 +159,10 @@ extern void sdio_f0_writeb(struct sdio_func *func, unsigned char b,
|
||||
extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func);
|
||||
extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags);
|
||||
|
||||
extern void sdio_retune_crc_disable(struct sdio_func *func);
|
||||
extern void sdio_retune_crc_enable(struct sdio_func *func);
|
||||
|
||||
extern void sdio_retune_hold_now(struct sdio_func *func);
|
||||
extern void sdio_retune_release(struct sdio_func *func);
|
||||
|
||||
#endif /* LINUX_MMC_SDIO_FUNC_H */
|
||||
|
@ -182,6 +182,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)
|
||||
|
||||
|
@ -3546,7 +3546,8 @@ struct cfg80211_ops {
|
||||
* on wiphy_new(), but can be changed by the driver if it has a good
|
||||
* reason to override the default
|
||||
* @WIPHY_FLAG_4ADDR_AP: supports 4addr mode even on AP (with a single station
|
||||
* on a VLAN interface)
|
||||
* on a VLAN interface). This flag also serves an extra purpose of
|
||||
* supporting 4ADDR AP mode on devices which do not support AP/VLAN iftype.
|
||||
* @WIPHY_FLAG_4ADDR_STATION: supports 4addr mode even as a station
|
||||
* @WIPHY_FLAG_CONTROL_PORT_PROTOCOL: This device supports setting the
|
||||
* control port protocol ethertype. The device also honours the
|
||||
|
@ -8357,12 +8357,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;
|
||||
|
@ -1901,4 +1901,22 @@ static inline void tracer_hardirqs_off(unsigned long a0, unsigned long a1) { }
|
||||
|
||||
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) {
|
||||
|
@ -1392,8 +1392,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)
|
||||
|
@ -2183,6 +2183,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;
|
||||
|
||||
|
@ -2868,7 +2868,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);
|
||||
@ -2933,6 +2933,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;
|
||||
@ -2982,6 +2987,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));
|
||||
|
@ -3752,6 +3752,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);
|
||||
|
@ -1992,3 +1992,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);
|
||||
}
|
||||
|
@ -3523,7 +3523,9 @@ int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
|
||||
}
|
||||
|
||||
/* Always allow software iftypes */
|
||||
if (local->hw.wiphy->software_iftypes & BIT(iftype)) {
|
||||
if (local->hw.wiphy->software_iftypes & BIT(iftype) ||
|
||||
(iftype == NL80211_IFTYPE_AP_VLAN &&
|
||||
local->hw.wiphy->flags & WIPHY_FLAG_4ADDR_AP)) {
|
||||
if (radar_detect)
|
||||
return -EINVAL;
|
||||
return 0;
|
||||
|
@ -1175,7 +1175,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))
|
||||
@ -1206,13 +1206,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;
|
||||
}
|
||||
|
||||
@ -1335,8 +1335,12 @@ static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
|
||||
}
|
||||
break;
|
||||
case NETDEV_PRE_UP:
|
||||
if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
|
||||
if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)) &&
|
||||
!(wdev->iftype == NL80211_IFTYPE_AP_VLAN &&
|
||||
rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP &&
|
||||
wdev->use_4addr))
|
||||
return notifier_from_errno(-EOPNOTSUPP);
|
||||
|
||||
if (rfkill_blocked(rdev->rfkill))
|
||||
return notifier_from_errno(-ERFKILL);
|
||||
break;
|
||||
|
@ -3192,8 +3192,7 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!rdev->ops->add_virtual_intf ||
|
||||
!(rdev->wiphy.interface_modes & (1 << type)))
|
||||
if (!rdev->ops->add_virtual_intf)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
|
||||
@ -3212,6 +3211,11 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!(rdev->wiphy.interface_modes & (1 << type)) &&
|
||||
!(type == NL80211_IFTYPE_AP_VLAN && params.use_4addr &&
|
||||
rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
|
||||
if (err < 0)
|
||||
return err;
|
||||
@ -4611,8 +4615,10 @@ static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
|
||||
struct nlattr *sinfoattr, *bss_param;
|
||||
|
||||
hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
|
||||
if (!hdr)
|
||||
if (!hdr) {
|
||||
cfg80211_sinfo_release_content(sinfo);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
|
||||
nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
|
||||
|
@ -46,7 +46,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') {
|
||||
|
@ -214,7 +214,16 @@ static inline struct aa_profile *aa_get_newest_profile(struct aa_profile *p)
|
||||
return labels_profile(aa_get_newest_label(&p->label));
|
||||
}
|
||||
|
||||
#define PROFILE_MEDIATES(P, T) ((P)->policy.start[(unsigned char) (T)])
|
||||
static inline unsigned int PROFILE_MEDIATES(struct aa_profile *profile,
|
||||
unsigned char class)
|
||||
{
|
||||
if (class <= AA_CLASS_LAST)
|
||||
return profile->policy.start[class];
|
||||
else
|
||||
return aa_dfa_match_len(profile->policy.dfa,
|
||||
profile->policy.start[0], &class, 1);
|
||||
}
|
||||
|
||||
static inline unsigned int PROFILE_MEDIATES_AF(struct aa_profile *profile,
|
||||
u16 AF) {
|
||||
unsigned int state = PROFILE_MEDIATES(profile, AA_CLASS_NET);
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user