Merge android-4.19-q.75 (cfe571e
) into msm-4.19
* refs/heads/tmp-cfe571e: Linux 4.19.75 media: technisat-usb2: break out of loop at end of buffer arm64: kpti: Whitelist Cortex-A CPUs that don't implement the CSV3 field binfmt_elf: move brk out of mmap when doing direct loader exec floppy: fix usercopy direction ovl: fix regression caused by overlapping layers detection PCI: kirin: Fix section mismatch warning iommu/amd: Fix race in increase_address_space() iommu/amd: Flush old domains in kdump kernel keys: Fix missing null pointer check in request_key_auth_describe() x86/hyper-v: Fix overflow bug in fill_gva_list() x86/uaccess: Don't leak the AC flags into __get_user() argument evaluation dmaengine: ti: omap-dma: Add cleanup in omap_dma_probe() dmaengine: ti: dma-crossbar: Fix a memory leak bug net: seeq: Fix the function used to release some memory in an error handling path net: aquantia: fix out of memory condition on rx side tools/power turbostat: fix buffer overrun tools/power x86_energy_perf_policy: Fix argument parsing tools/power x86_energy_perf_policy: Fix "uninitialized variable" warnings at -O2 amd-xgbe: Fix error path in xgbe_mod_init() perf/x86/amd/ibs: Fix sample bias for dispatched micro-ops perf/x86/intel: Restrict period on Nehalem i2c: designware: Synchronize IRQs when unregistering slave client sky2: Disable MSI on yet another ASUS boards (P6Xxxx) ibmvnic: Do not process reset during or after device removal ARM: 8901/1: add a criteria for pfn_valid of arm usb: host: xhci-tegra: Set DMA mask correctly cifs: Use kzfree() to zero out the password cifs: set domainName when a domain-key is used in multiuser kallsyms: Don't let kallsyms_lookup_size_offset() fail on retrieving the first symbol NFSv2: Fix write regression NFSv2: Fix eof handling netfilter: nf_conntrack_ftp: Fix debug output netfilter: xt_physdev: Fix spurious error message in physdev_mt_check x86/apic: Fix arch_dynirq_lower_bound() bug for DT enabled machines r8152: Set memory to all 0xFFs on failed reg reads bpf: allow narrow loads of some sk_reuseport_md fields with offset > 0 batman-adv: Only read OGM2 tvlv_len after buffer len check ARM: 8874/1: mm: only adjust sections of valid mm structures qed: Add cleanup in qed_slowpath_start() xdp: unpin xdp umem pages in error path Kconfig: Fix the reference to the IDT77105 Phy driver in the description of ATM_NICSTAR_USE_IDT77105 NFS: Fix initialisation of I/O result struct in nfs_pgio_rpcsetup NFSv4: Fix return value in nfs_finish_open() NFSv4: Fix return values for nfs4_file_open() netfilter: xt_nfacct: Fix alignment mismatch in xt_nfacct_match_info netfilter: nft_flow_offload: missing netlink attribute policy netfilter: ebtables: Fix argument order to ADD_COUNTER fpga: altera-ps-spi: Fix getting of optional confd gpio tools: bpftool: close prog FD before exit on showing a single program selftests/bpf: fix "bind{4, 6} deny specific IP & port" on s390 s390/bpf: use 32-bit index for tail calls bus: ti-sysc: Simplify cleanup upon failures in sysc_probe() ARM: OMAP1: ams-delta-fiq: Fix missing irq_ack ARM: dts: dra74x: Fix iodelay configuration for mmc3 ARM: OMAP2+: Fix omap4 errata warning on other SoCs s390/bpf: fix lcgr instruction encoding bus: ti-sysc: Fix using configured sysc mask value ARM: OMAP2+: Fix missing SYSC_HAS_RESET_STATUS for dra7 epwmss ARM: dts: am57xx: Disable voltage switching for SD card ieee802154: hwsim: unregister hw while hwsim_subscribe_all_others fails ieee802154: hwsim: Fix error handle path in hwsim_init_module nl80211: Fix possible Spectre-v1 for CQM RSSI thresholds mwifiex: Fix three heap overflow at parsing element in cfg80211_ap_settings tty/serial: atmel: reschedule TX after RX was started serial: sprd: correct the wrong sequence of arguments firmware: google: check if size is valid when decoding VPD data KVM: coalesced_mmio: add bounds checking net_sched: let qdisc_put() accept NULL pointer xen-netfront: do not assume sk_buff_head list is empty in error handling udp: correct reuseport selection with connected sockets ip6_gre: fix a dst leak in ip6erspan_tunnel_xmit phy: renesas: rcar-gen3-usb2: Disable clearing VBUS in over-current media: tm6000: double free if usb disconnect while streaming USB: usbcore: Fix slab-out-of-bounds bug during device reset powerpc/mm/radix: Use the right page size for vmemmap mapping Input: elan_i2c - remove Lenovo Legion Y7000 PnpID RDMA/restrack: Release task struct which was hold by CM_ID object HID: wacom: generic: read HID_DG_CONTACTMAX from any feature report netfilter: nf_flow_table: set default timeout after successful insertion Change-Id: Id15fbdb2fd66826ddff749ecbbfea6a565a43192 Signed-off-by: Ivaylo Georgiev <irgeorgiev@codeaurora.org>
This commit is contained in:
commit
c17fcf60d2
92 changed files with 563 additions and 291 deletions
|
@ -325,7 +325,7 @@ beneath or above the path of another overlay lower layer path.
|
|||
|
||||
Using an upper layer path and/or a workdir path that are already used by
|
||||
another overlay mount is not allowed and may fail with EBUSY. Using
|
||||
partially overlapping paths is not allowed but will not fail with EBUSY.
|
||||
partially overlapping paths is not allowed and may fail with EBUSY.
|
||||
If files are accessed from two overlayfs mounts which share or overlap the
|
||||
upper layer and/or workdir path the behavior of the overlay is undefined,
|
||||
though it will not result in a crash or deadlock.
|
||||
|
|
2
Makefile
2
Makefile
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 74
|
||||
SUBLEVEL = 75
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
|
|
@ -98,14 +98,9 @@
|
|||
};
|
||||
|
||||
&mmc1 {
|
||||
pinctrl-names = "default", "hs", "sdr12", "sdr25", "sdr50", "ddr50", "sdr104";
|
||||
pinctrl-names = "default", "hs";
|
||||
pinctrl-0 = <&mmc1_pins_default_no_clk_pu>;
|
||||
pinctrl-1 = <&mmc1_pins_hs>;
|
||||
pinctrl-2 = <&mmc1_pins_sdr12>;
|
||||
pinctrl-3 = <&mmc1_pins_sdr25>;
|
||||
pinctrl-4 = <&mmc1_pins_sdr50>;
|
||||
pinctrl-5 = <&mmc1_pins_ddr50_rev20 &mmc1_iodelay_ddr50_conf>;
|
||||
pinctrl-6 = <&mmc1_pins_sdr104 &mmc1_iodelay_sdr104_rev20_conf>;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
|
|
@ -20,14 +20,9 @@
|
|||
};
|
||||
|
||||
&mmc1 {
|
||||
pinctrl-names = "default", "hs", "sdr12", "sdr25", "sdr50", "ddr50", "sdr104";
|
||||
pinctrl-names = "default", "hs";
|
||||
pinctrl-0 = <&mmc1_pins_default_no_clk_pu>;
|
||||
pinctrl-1 = <&mmc1_pins_hs>;
|
||||
pinctrl-2 = <&mmc1_pins_sdr12>;
|
||||
pinctrl-3 = <&mmc1_pins_sdr25>;
|
||||
pinctrl-4 = <&mmc1_pins_sdr50>;
|
||||
pinctrl-5 = <&mmc1_pins_ddr50 &mmc1_iodelay_ddr_rev20_conf>;
|
||||
pinctrl-6 = <&mmc1_pins_sdr104 &mmc1_iodelay_sdr104_rev20_conf>;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
|
|
@ -24,14 +24,9 @@
|
|||
};
|
||||
|
||||
&mmc1 {
|
||||
pinctrl-names = "default", "hs", "sdr12", "sdr25", "sdr50", "ddr50", "sdr104";
|
||||
pinctrl-names = "default", "hs";
|
||||
pinctrl-0 = <&mmc1_pins_default_no_clk_pu>;
|
||||
pinctrl-1 = <&mmc1_pins_hs>;
|
||||
pinctrl-2 = <&mmc1_pins_default>;
|
||||
pinctrl-3 = <&mmc1_pins_hs>;
|
||||
pinctrl-4 = <&mmc1_pins_sdr50>;
|
||||
pinctrl-5 = <&mmc1_pins_ddr50 &mmc1_iodelay_ddr_conf>;
|
||||
pinctrl-6 = <&mmc1_pins_ddr50 &mmc1_iodelay_sdr104_conf>;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
|
|
@ -433,6 +433,7 @@
|
|||
|
||||
bus-width = <4>;
|
||||
cd-gpios = <&gpio6 27 GPIO_ACTIVE_LOW>; /* gpio 219 */
|
||||
no-1-8-v;
|
||||
};
|
||||
|
||||
&mmc2 {
|
||||
|
|
|
@ -19,14 +19,9 @@
|
|||
};
|
||||
|
||||
&mmc1 {
|
||||
pinctrl-names = "default", "hs", "sdr12", "sdr25", "sdr50", "ddr50", "sdr104";
|
||||
pinctrl-names = "default", "hs";
|
||||
pinctrl-0 = <&mmc1_pins_default>;
|
||||
pinctrl-1 = <&mmc1_pins_hs>;
|
||||
pinctrl-2 = <&mmc1_pins_sdr12>;
|
||||
pinctrl-3 = <&mmc1_pins_sdr25>;
|
||||
pinctrl-4 = <&mmc1_pins_sdr50>;
|
||||
pinctrl-5 = <&mmc1_pins_ddr50 &mmc1_iodelay_ddr_rev11_conf>;
|
||||
pinctrl-6 = <&mmc1_pins_sdr104 &mmc1_iodelay_sdr104_rev11_conf>;
|
||||
vmmc-supply = <&vdd_3v3>;
|
||||
vqmmc-supply = <&ldo1_reg>;
|
||||
};
|
||||
|
|
|
@ -19,14 +19,9 @@
|
|||
};
|
||||
|
||||
&mmc1 {
|
||||
pinctrl-names = "default", "hs", "sdr12", "sdr25", "sdr50", "ddr50", "sdr104";
|
||||
pinctrl-names = "default", "hs";
|
||||
pinctrl-0 = <&mmc1_pins_default>;
|
||||
pinctrl-1 = <&mmc1_pins_hs>;
|
||||
pinctrl-2 = <&mmc1_pins_sdr12>;
|
||||
pinctrl-3 = <&mmc1_pins_sdr25>;
|
||||
pinctrl-4 = <&mmc1_pins_sdr50>;
|
||||
pinctrl-5 = <&mmc1_pins_ddr50 &mmc1_iodelay_ddr_rev20_conf>;
|
||||
pinctrl-6 = <&mmc1_pins_sdr104 &mmc1_iodelay_sdr104_rev20_conf>;
|
||||
vmmc-supply = <&vdd_3v3>;
|
||||
vqmmc-supply = <&ldo1_reg>;
|
||||
};
|
||||
|
|
|
@ -32,7 +32,7 @@
|
|||
*
|
||||
* Datamanual Revisions:
|
||||
*
|
||||
* AM572x Silicon Revision 2.0: SPRS953B, Revised November 2016
|
||||
* AM572x Silicon Revision 2.0: SPRS953F, Revised May 2019
|
||||
* AM572x Silicon Revision 1.1: SPRS915R, Revised November 2016
|
||||
*
|
||||
*/
|
||||
|
@ -229,45 +229,45 @@
|
|||
|
||||
mmc3_pins_default: mmc3_pins_default {
|
||||
pinctrl-single,pins = <
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
>;
|
||||
};
|
||||
|
||||
mmc3_pins_hs: mmc3_pins_hs {
|
||||
pinctrl-single,pins = <
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
>;
|
||||
};
|
||||
|
||||
mmc3_pins_sdr12: mmc3_pins_sdr12 {
|
||||
pinctrl-single,pins = <
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
>;
|
||||
};
|
||||
|
||||
mmc3_pins_sdr25: mmc3_pins_sdr25 {
|
||||
pinctrl-single,pins = <
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
DRA7XX_CORE_IOPAD(0x377c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_clk.mmc3_clk */
|
||||
DRA7XX_CORE_IOPAD(0x3780, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_cmd.mmc3_cmd */
|
||||
DRA7XX_CORE_IOPAD(0x3784, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat0.mmc3_dat0 */
|
||||
DRA7XX_CORE_IOPAD(0x3788, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat1.mmc3_dat1 */
|
||||
DRA7XX_CORE_IOPAD(0x378c, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat2.mmc3_dat2 */
|
||||
DRA7XX_CORE_IOPAD(0x3790, (PIN_INPUT_PULLUP | MODE_SELECT | MUX_MODE0)) /* mmc3_dat3.mmc3_dat3 */
|
||||
>;
|
||||
};
|
||||
|
||||
|
|
|
@ -135,6 +135,8 @@ restart:
|
|||
orr r11, r11, r13 @ mask all requested interrupts
|
||||
str r11, [r12, #OMAP1510_GPIO_INT_MASK]
|
||||
|
||||
str r13, [r12, #OMAP1510_GPIO_INT_STATUS] @ ack all requested interrupts
|
||||
|
||||
ands r10, r13, #KEYBRD_CLK_MASK @ extract keyboard status - set?
|
||||
beq hksw @ no - try next source
|
||||
|
||||
|
@ -142,7 +144,6 @@ restart:
|
|||
@@@@@@@@@@@@@@@@@@@@@@
|
||||
@ Keyboard clock FIQ mode interrupt handler
|
||||
@ r10 now contains KEYBRD_CLK_MASK, use it
|
||||
str r10, [r12, #OMAP1510_GPIO_INT_STATUS] @ ack the interrupt
|
||||
bic r11, r11, r10 @ unmask it
|
||||
str r11, [r12, #OMAP1510_GPIO_INT_MASK]
|
||||
|
||||
|
|
|
@ -73,9 +73,7 @@ static irqreturn_t deferred_fiq(int irq, void *dev_id)
|
|||
* interrupts default to since commit 80ac93c27441
|
||||
* requires interrupt already acked and unmasked.
|
||||
*/
|
||||
if (irq_chip->irq_ack)
|
||||
irq_chip->irq_ack(d);
|
||||
if (irq_chip->irq_unmask)
|
||||
if (!WARN_ON_ONCE(!irq_chip->irq_unmask))
|
||||
irq_chip->irq_unmask(d);
|
||||
}
|
||||
for (; irq_counter[gpio] < fiq_count; irq_counter[gpio]++)
|
||||
|
|
|
@ -131,6 +131,9 @@ static int __init omap4_sram_init(void)
|
|||
struct device_node *np;
|
||||
struct gen_pool *sram_pool;
|
||||
|
||||
if (!soc_is_omap44xx() && !soc_is_omap54xx())
|
||||
return 0;
|
||||
|
||||
np = of_find_compatible_node(NULL, NULL, "ti,omap4-mpu");
|
||||
if (!np)
|
||||
pr_warn("%s:Unable to allocate sram needed to handle errata I688\n",
|
||||
|
|
|
@ -385,7 +385,8 @@ static struct omap_hwmod dra7xx_dcan2_hwmod = {
|
|||
static struct omap_hwmod_class_sysconfig dra7xx_epwmss_sysc = {
|
||||
.rev_offs = 0x0,
|
||||
.sysc_offs = 0x4,
|
||||
.sysc_flags = SYSC_HAS_SIDLEMODE | SYSC_HAS_SOFTRESET,
|
||||
.sysc_flags = SYSC_HAS_SIDLEMODE | SYSC_HAS_SOFTRESET |
|
||||
SYSC_HAS_RESET_STATUS,
|
||||
.idlemodes = (SIDLE_FORCE | SIDLE_NO | SIDLE_SMART),
|
||||
.sysc_fields = &omap_hwmod_sysc_type2,
|
||||
};
|
||||
|
|
|
@ -196,6 +196,11 @@ static void __init zone_sizes_init(unsigned long min, unsigned long max_low,
|
|||
#ifdef CONFIG_HAVE_ARCH_PFN_VALID
|
||||
int pfn_valid(unsigned long pfn)
|
||||
{
|
||||
phys_addr_t addr = __pfn_to_phys(pfn);
|
||||
|
||||
if (__phys_to_pfn(addr) != pfn)
|
||||
return 0;
|
||||
|
||||
return memblock_is_map_memory(__pfn_to_phys(pfn));
|
||||
}
|
||||
EXPORT_SYMBOL(pfn_valid);
|
||||
|
@ -713,7 +718,8 @@ static void update_sections_early(struct section_perm perms[], int n)
|
|||
if (t->flags & PF_KTHREAD)
|
||||
continue;
|
||||
for_each_thread(t, s)
|
||||
set_section_perms(perms, n, true, s->mm);
|
||||
if (s->mm)
|
||||
set_section_perms(perms, n, true, s->mm);
|
||||
}
|
||||
set_section_perms(perms, n, true, current->active_mm);
|
||||
set_section_perms(perms, n, true, &init_mm);
|
||||
|
|
|
@ -899,6 +899,12 @@ static bool unmap_kernel_at_el0(const struct arm64_cpu_capabilities *entry,
|
|||
static const struct midr_range kpti_safe_list[] = {
|
||||
MIDR_ALL_VERSIONS(MIDR_CAVIUM_THUNDERX2),
|
||||
MIDR_ALL_VERSIONS(MIDR_BRCM_VULCAN),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A35),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A53),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A55),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A73),
|
||||
{ /* sentinel */ }
|
||||
};
|
||||
char const *str = "command line option";
|
||||
|
|
|
@ -521,14 +521,6 @@ void __init radix__early_init_devtree(void)
|
|||
mmu_psize_defs[MMU_PAGE_64K].shift = 16;
|
||||
mmu_psize_defs[MMU_PAGE_64K].ap = 0x5;
|
||||
found:
|
||||
#ifdef CONFIG_SPARSEMEM_VMEMMAP
|
||||
if (mmu_psize_defs[MMU_PAGE_2M].shift) {
|
||||
/*
|
||||
* map vmemmap using 2M if available
|
||||
*/
|
||||
mmu_vmemmap_psize = MMU_PAGE_2M;
|
||||
}
|
||||
#endif /* CONFIG_SPARSEMEM_VMEMMAP */
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -567,7 +559,13 @@ void __init radix__early_init_mmu(void)
|
|||
|
||||
#ifdef CONFIG_SPARSEMEM_VMEMMAP
|
||||
/* vmemmap mapping */
|
||||
mmu_vmemmap_psize = mmu_virtual_psize;
|
||||
if (mmu_psize_defs[MMU_PAGE_2M].shift) {
|
||||
/*
|
||||
* map vmemmap using 2M if available
|
||||
*/
|
||||
mmu_vmemmap_psize = MMU_PAGE_2M;
|
||||
} else
|
||||
mmu_vmemmap_psize = mmu_virtual_psize;
|
||||
#endif
|
||||
/*
|
||||
* initialize page table size
|
||||
|
|
|
@ -841,7 +841,7 @@ static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i
|
|||
break;
|
||||
case BPF_ALU64 | BPF_NEG: /* dst = -dst */
|
||||
/* lcgr %dst,%dst */
|
||||
EMIT4(0xb9130000, dst_reg, dst_reg);
|
||||
EMIT4(0xb9030000, dst_reg, dst_reg);
|
||||
break;
|
||||
/*
|
||||
* BPF_FROM_BE/LE
|
||||
|
@ -1015,8 +1015,8 @@ static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i
|
|||
/* llgf %w1,map.max_entries(%b2) */
|
||||
EMIT6_DISP_LH(0xe3000000, 0x0016, REG_W1, REG_0, BPF_REG_2,
|
||||
offsetof(struct bpf_array, map.max_entries));
|
||||
/* clgrj %b3,%w1,0xa,label0: if %b3 >= %w1 goto out */
|
||||
EMIT6_PCREL_LABEL(0xec000000, 0x0065, BPF_REG_3,
|
||||
/* clrj %b3,%w1,0xa,label0: if (u32)%b3 >= (u32)%w1 goto out */
|
||||
EMIT6_PCREL_LABEL(0xec000000, 0x0077, BPF_REG_3,
|
||||
REG_W1, 0, 0xa);
|
||||
|
||||
/*
|
||||
|
@ -1042,8 +1042,10 @@ static noinline int bpf_jit_insn(struct bpf_jit *jit, struct bpf_prog *fp, int i
|
|||
* goto out;
|
||||
*/
|
||||
|
||||
/* sllg %r1,%b3,3: %r1 = index * 8 */
|
||||
EMIT6_DISP_LH(0xeb000000, 0x000d, REG_1, BPF_REG_3, REG_0, 3);
|
||||
/* llgfr %r1,%b3: %r1 = (u32) index */
|
||||
EMIT4(0xb9160000, REG_1, BPF_REG_3);
|
||||
/* sllg %r1,%r1,3: %r1 *= 8 */
|
||||
EMIT6_DISP_LH(0xeb000000, 0x000d, REG_1, REG_1, REG_0, 3);
|
||||
/* lg %r1,prog(%b2,%r1) */
|
||||
EMIT6_DISP_LH(0xe3000000, 0x0004, REG_1, BPF_REG_2,
|
||||
REG_1, offsetof(struct bpf_array, ptrs));
|
||||
|
|
|
@ -672,10 +672,17 @@ fail:
|
|||
|
||||
throttle = perf_event_overflow(event, &data, ®s);
|
||||
out:
|
||||
if (throttle)
|
||||
if (throttle) {
|
||||
perf_ibs_stop(event, 0);
|
||||
else
|
||||
perf_ibs_enable_event(perf_ibs, hwc, period >> 4);
|
||||
} else {
|
||||
period >>= 4;
|
||||
|
||||
if ((ibs_caps & IBS_CAPS_RDWROPCNT) &&
|
||||
(*config & IBS_OP_CNT_CTL))
|
||||
period |= *config & IBS_OP_CUR_CNT_RAND;
|
||||
|
||||
perf_ibs_enable_event(perf_ibs, hwc, period);
|
||||
}
|
||||
|
||||
perf_event_update_userpage(event);
|
||||
|
||||
|
|
|
@ -3319,6 +3319,11 @@ static u64 bdw_limit_period(struct perf_event *event, u64 left)
|
|||
return left;
|
||||
}
|
||||
|
||||
static u64 nhm_limit_period(struct perf_event *event, u64 left)
|
||||
{
|
||||
return max(left, 32ULL);
|
||||
}
|
||||
|
||||
PMU_FORMAT_ATTR(event, "config:0-7" );
|
||||
PMU_FORMAT_ATTR(umask, "config:8-15" );
|
||||
PMU_FORMAT_ATTR(edge, "config:18" );
|
||||
|
@ -4115,6 +4120,7 @@ __init int intel_pmu_init(void)
|
|||
x86_pmu.pebs_constraints = intel_nehalem_pebs_event_constraints;
|
||||
x86_pmu.enable_all = intel_pmu_nhm_enable_all;
|
||||
x86_pmu.extra_regs = intel_nehalem_extra_regs;
|
||||
x86_pmu.limit_period = nhm_limit_period;
|
||||
|
||||
x86_pmu.cpu_events = nhm_events_attrs;
|
||||
|
||||
|
|
|
@ -37,12 +37,14 @@ static inline int fill_gva_list(u64 gva_list[], int offset,
|
|||
* Lower 12 bits encode the number of additional
|
||||
* pages to flush (in addition to the 'cur' page).
|
||||
*/
|
||||
if (diff >= HV_TLB_FLUSH_UNIT)
|
||||
if (diff >= HV_TLB_FLUSH_UNIT) {
|
||||
gva_list[gva_n] |= ~PAGE_MASK;
|
||||
else if (diff)
|
||||
cur += HV_TLB_FLUSH_UNIT;
|
||||
} else if (diff) {
|
||||
gva_list[gva_n] |= (diff - 1) >> PAGE_SHIFT;
|
||||
cur = end;
|
||||
}
|
||||
|
||||
cur += HV_TLB_FLUSH_UNIT;
|
||||
gva_n++;
|
||||
|
||||
} while (cur < end);
|
||||
|
|
|
@ -209,16 +209,20 @@ struct x86_pmu_capability {
|
|||
#define IBSCTL_LVT_OFFSET_VALID (1ULL<<8)
|
||||
#define IBSCTL_LVT_OFFSET_MASK 0x0F
|
||||
|
||||
/* ibs fetch bits/masks */
|
||||
/* IBS fetch bits/masks */
|
||||
#define IBS_FETCH_RAND_EN (1ULL<<57)
|
||||
#define IBS_FETCH_VAL (1ULL<<49)
|
||||
#define IBS_FETCH_ENABLE (1ULL<<48)
|
||||
#define IBS_FETCH_CNT 0xFFFF0000ULL
|
||||
#define IBS_FETCH_MAX_CNT 0x0000FFFFULL
|
||||
|
||||
/* ibs op bits/masks */
|
||||
/* lower 4 bits of the current count are ignored: */
|
||||
#define IBS_OP_CUR_CNT (0xFFFF0ULL<<32)
|
||||
/*
|
||||
* IBS op bits/masks
|
||||
* The lower 7 bits of the current count are random bits
|
||||
* preloaded by hardware and ignored in software
|
||||
*/
|
||||
#define IBS_OP_CUR_CNT (0xFFF80ULL<<32)
|
||||
#define IBS_OP_CUR_CNT_RAND (0x0007FULL<<32)
|
||||
#define IBS_OP_CNT_CTL (1ULL<<19)
|
||||
#define IBS_OP_VAL (1ULL<<18)
|
||||
#define IBS_OP_ENABLE (1ULL<<17)
|
||||
|
|
|
@ -451,8 +451,10 @@ do { \
|
|||
({ \
|
||||
int __gu_err; \
|
||||
__inttype(*(ptr)) __gu_val; \
|
||||
__typeof__(ptr) __gu_ptr = (ptr); \
|
||||
__typeof__(size) __gu_size = (size); \
|
||||
__uaccess_begin_nospec(); \
|
||||
__get_user_size(__gu_val, (ptr), (size), __gu_err, -EFAULT); \
|
||||
__get_user_size(__gu_val, __gu_ptr, __gu_size, __gu_err, -EFAULT); \
|
||||
__uaccess_end(); \
|
||||
(x) = (__force __typeof__(*(ptr)))__gu_val; \
|
||||
__builtin_expect(__gu_err, 0); \
|
||||
|
|
|
@ -2432,7 +2432,13 @@ unsigned int arch_dynirq_lower_bound(unsigned int from)
|
|||
* dmar_alloc_hwirq() may be called before setup_IO_APIC(), so use
|
||||
* gsi_top if ioapic_dynirq_base hasn't been initialized yet.
|
||||
*/
|
||||
return ioapic_initialized ? ioapic_dynirq_base : gsi_top;
|
||||
if (!ioapic_initialized)
|
||||
return gsi_top;
|
||||
/*
|
||||
* For DT enabled machines ioapic_dynirq_base is irrelevant and not
|
||||
* updated. So simply return @from if ioapic_dynirq_base == 0.
|
||||
*/
|
||||
return ioapic_dynirq_base ? : from;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_X86_32
|
||||
|
|
|
@ -200,7 +200,7 @@ config ATM_NICSTAR_USE_SUNI
|
|||
make the card work).
|
||||
|
||||
config ATM_NICSTAR_USE_IDT77105
|
||||
bool "Use IDT77015 PHY driver (25Mbps)"
|
||||
bool "Use IDT77105 PHY driver (25Mbps)"
|
||||
depends on ATM_NICSTAR
|
||||
help
|
||||
Support for the PHYsical layer chip in ForeRunner LE25 cards. In
|
||||
|
|
|
@ -3791,7 +3791,7 @@ static int compat_getdrvprm(int drive,
|
|||
v.native_format = UDP->native_format;
|
||||
mutex_unlock(&floppy_mutex);
|
||||
|
||||
if (copy_from_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
|
||||
if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
@ -3827,7 +3827,7 @@ static int compat_getdrvstat(int drive, bool poll,
|
|||
v.bufblocks = UDRS->bufblocks;
|
||||
mutex_unlock(&floppy_mutex);
|
||||
|
||||
if (copy_from_user(arg, &v, sizeof(struct compat_floppy_drive_struct)))
|
||||
if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_struct)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
Eintr:
|
||||
|
|
|
@ -1022,10 +1022,7 @@ static int sysc_init_sysc_mask(struct sysc *ddata)
|
|||
if (error)
|
||||
return 0;
|
||||
|
||||
if (val)
|
||||
ddata->cfg.sysc_val = val & ddata->cap->sysc_mask;
|
||||
else
|
||||
ddata->cfg.sysc_val = ddata->cap->sysc_mask;
|
||||
ddata->cfg.sysc_val = val & ddata->cap->sysc_mask;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1688,7 +1685,7 @@ static int sysc_probe(struct platform_device *pdev)
|
|||
|
||||
error = sysc_init_dts_quirks(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_get_clocks(ddata);
|
||||
if (error)
|
||||
|
@ -1696,27 +1693,27 @@ static int sysc_probe(struct platform_device *pdev)
|
|||
|
||||
error = sysc_map_and_check_registers(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_init_sysc_mask(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_init_idlemodes(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_init_syss_mask(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_init_pdata(ddata);
|
||||
if (error)
|
||||
goto unprepare;
|
||||
return error;
|
||||
|
||||
error = sysc_init_resets(ddata);
|
||||
if (error)
|
||||
return error;
|
||||
goto unprepare;
|
||||
|
||||
pm_runtime_enable(ddata->dev);
|
||||
error = sysc_init_module(ddata);
|
||||
|
|
|
@ -395,8 +395,10 @@ static int ti_dra7_xbar_probe(struct platform_device *pdev)
|
|||
|
||||
ret = of_property_read_u32_array(node, pname, (u32 *)rsv_events,
|
||||
nelm * 2);
|
||||
if (ret)
|
||||
if (ret) {
|
||||
kfree(rsv_events);
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (i = 0; i < nelm; i++) {
|
||||
ti_dra7_xbar_reserve(rsv_events[i][0], rsv_events[i][1],
|
||||
|
|
|
@ -1543,8 +1543,10 @@ static int omap_dma_probe(struct platform_device *pdev)
|
|||
|
||||
rc = devm_request_irq(&pdev->dev, irq, omap_dma_irq,
|
||||
IRQF_SHARED, "omap-dma-engine", od);
|
||||
if (rc)
|
||||
if (rc) {
|
||||
omap_dma_free(od);
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
|
||||
if (omap_dma_glbl_read(od, CAPS_0) & CAPS_0_SUPPORT_LL123)
|
||||
|
|
|
@ -100,8 +100,8 @@ static int vpd_section_check_key_name(const u8 *key, s32 key_len)
|
|||
return VPD_OK;
|
||||
}
|
||||
|
||||
static int vpd_section_attrib_add(const u8 *key, s32 key_len,
|
||||
const u8 *value, s32 value_len,
|
||||
static int vpd_section_attrib_add(const u8 *key, u32 key_len,
|
||||
const u8 *value, u32 value_len,
|
||||
void *arg)
|
||||
{
|
||||
int ret;
|
||||
|
|
|
@ -19,8 +19,8 @@
|
|||
|
||||
#include "vpd_decode.h"
|
||||
|
||||
static int vpd_decode_len(const s32 max_len, const u8 *in,
|
||||
s32 *length, s32 *decoded_len)
|
||||
static int vpd_decode_len(const u32 max_len, const u8 *in,
|
||||
u32 *length, u32 *decoded_len)
|
||||
{
|
||||
u8 more;
|
||||
int i = 0;
|
||||
|
@ -40,18 +40,39 @@ static int vpd_decode_len(const s32 max_len, const u8 *in,
|
|||
} while (more);
|
||||
|
||||
*decoded_len = i;
|
||||
|
||||
return VPD_OK;
|
||||
}
|
||||
|
||||
int vpd_decode_string(const s32 max_len, const u8 *input_buf, s32 *consumed,
|
||||
static int vpd_decode_entry(const u32 max_len, const u8 *input_buf,
|
||||
u32 *_consumed, const u8 **entry, u32 *entry_len)
|
||||
{
|
||||
u32 decoded_len;
|
||||
u32 consumed = *_consumed;
|
||||
|
||||
if (vpd_decode_len(max_len - consumed, &input_buf[consumed],
|
||||
entry_len, &decoded_len) != VPD_OK)
|
||||
return VPD_FAIL;
|
||||
if (max_len - consumed < decoded_len)
|
||||
return VPD_FAIL;
|
||||
|
||||
consumed += decoded_len;
|
||||
*entry = input_buf + consumed;
|
||||
|
||||
/* entry_len is untrusted data and must be checked again. */
|
||||
if (max_len - consumed < *entry_len)
|
||||
return VPD_FAIL;
|
||||
|
||||
consumed += decoded_len;
|
||||
*_consumed = consumed;
|
||||
return VPD_OK;
|
||||
}
|
||||
|
||||
int vpd_decode_string(const u32 max_len, const u8 *input_buf, u32 *consumed,
|
||||
vpd_decode_callback callback, void *callback_arg)
|
||||
{
|
||||
int type;
|
||||
int res;
|
||||
s32 key_len;
|
||||
s32 value_len;
|
||||
s32 decoded_len;
|
||||
u32 key_len;
|
||||
u32 value_len;
|
||||
const u8 *key;
|
||||
const u8 *value;
|
||||
|
||||
|
@ -66,26 +87,14 @@ int vpd_decode_string(const s32 max_len, const u8 *input_buf, s32 *consumed,
|
|||
case VPD_TYPE_STRING:
|
||||
(*consumed)++;
|
||||
|
||||
/* key */
|
||||
res = vpd_decode_len(max_len - *consumed, &input_buf[*consumed],
|
||||
&key_len, &decoded_len);
|
||||
if (res != VPD_OK || *consumed + decoded_len >= max_len)
|
||||
if (vpd_decode_entry(max_len, input_buf, consumed, &key,
|
||||
&key_len) != VPD_OK)
|
||||
return VPD_FAIL;
|
||||
|
||||
*consumed += decoded_len;
|
||||
key = &input_buf[*consumed];
|
||||
*consumed += key_len;
|
||||
|
||||
/* value */
|
||||
res = vpd_decode_len(max_len - *consumed, &input_buf[*consumed],
|
||||
&value_len, &decoded_len);
|
||||
if (res != VPD_OK || *consumed + decoded_len > max_len)
|
||||
if (vpd_decode_entry(max_len, input_buf, consumed, &value,
|
||||
&value_len) != VPD_OK)
|
||||
return VPD_FAIL;
|
||||
|
||||
*consumed += decoded_len;
|
||||
value = &input_buf[*consumed];
|
||||
*consumed += value_len;
|
||||
|
||||
if (type == VPD_TYPE_STRING)
|
||||
return callback(key, key_len, value, value_len,
|
||||
callback_arg);
|
||||
|
|
|
@ -33,8 +33,8 @@ enum {
|
|||
};
|
||||
|
||||
/* Callback for vpd_decode_string to invoke. */
|
||||
typedef int vpd_decode_callback(const u8 *key, s32 key_len,
|
||||
const u8 *value, s32 value_len,
|
||||
typedef int vpd_decode_callback(const u8 *key, u32 key_len,
|
||||
const u8 *value, u32 value_len,
|
||||
void *arg);
|
||||
|
||||
/*
|
||||
|
@ -52,7 +52,7 @@ typedef int vpd_decode_callback(const u8 *key, s32 key_len,
|
|||
* If one entry is successfully decoded, sends it to callback and returns the
|
||||
* result.
|
||||
*/
|
||||
int vpd_decode_string(const s32 max_len, const u8 *input_buf, s32 *consumed,
|
||||
int vpd_decode_string(const u32 max_len, const u8 *input_buf, u32 *consumed,
|
||||
vpd_decode_callback callback, void *callback_arg);
|
||||
|
||||
#endif /* __VPD_DECODE_H */
|
||||
|
|
|
@ -207,7 +207,7 @@ static int altera_ps_write_complete(struct fpga_manager *mgr,
|
|||
return -EIO;
|
||||
}
|
||||
|
||||
if (!IS_ERR(conf->confd)) {
|
||||
if (conf->confd) {
|
||||
if (!gpiod_get_raw_value_cansleep(conf->confd)) {
|
||||
dev_err(&mgr->dev, "CONF_DONE is inactive!\n");
|
||||
return -EIO;
|
||||
|
@ -265,10 +265,13 @@ static int altera_ps_probe(struct spi_device *spi)
|
|||
return PTR_ERR(conf->status);
|
||||
}
|
||||
|
||||
conf->confd = devm_gpiod_get(&spi->dev, "confd", GPIOD_IN);
|
||||
conf->confd = devm_gpiod_get_optional(&spi->dev, "confd", GPIOD_IN);
|
||||
if (IS_ERR(conf->confd)) {
|
||||
dev_warn(&spi->dev, "Not using confd gpio: %ld\n",
|
||||
PTR_ERR(conf->confd));
|
||||
dev_err(&spi->dev, "Failed to get confd gpio: %ld\n",
|
||||
PTR_ERR(conf->confd));
|
||||
return PTR_ERR(conf->confd);
|
||||
} else if (!conf->confd) {
|
||||
dev_warn(&spi->dev, "Not using confd gpio");
|
||||
}
|
||||
|
||||
/* Register manager with unique name */
|
||||
|
|
|
@ -282,14 +282,16 @@ static void wacom_feature_mapping(struct hid_device *hdev,
|
|||
/* leave touch_max as is if predefined */
|
||||
if (!features->touch_max) {
|
||||
/* read manually */
|
||||
data = kzalloc(2, GFP_KERNEL);
|
||||
n = hid_report_len(field->report);
|
||||
data = hid_alloc_report_buf(field->report, GFP_KERNEL);
|
||||
if (!data)
|
||||
break;
|
||||
data[0] = field->report->id;
|
||||
ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
|
||||
data, 2, WAC_CMD_RETRIES);
|
||||
if (ret == 2) {
|
||||
features->touch_max = data[1];
|
||||
data, n, WAC_CMD_RETRIES);
|
||||
if (ret == n) {
|
||||
ret = hid_report_raw_event(hdev,
|
||||
HID_FEATURE_REPORT, data, n, 0);
|
||||
} else {
|
||||
features->touch_max = 16;
|
||||
hid_warn(hdev, "wacom_feature_mapping: "
|
||||
|
|
|
@ -2533,6 +2533,7 @@ static void wacom_wac_finger_event(struct hid_device *hdev,
|
|||
struct wacom *wacom = hid_get_drvdata(hdev);
|
||||
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
|
||||
unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
|
||||
struct wacom_features *features = &wacom->wacom_wac.features;
|
||||
|
||||
switch (equivalent_usage) {
|
||||
case HID_GD_X:
|
||||
|
@ -2553,6 +2554,9 @@ static void wacom_wac_finger_event(struct hid_device *hdev,
|
|||
case HID_DG_TIPSWITCH:
|
||||
wacom_wac->hid_data.tipswitch = value;
|
||||
break;
|
||||
case HID_DG_CONTACTMAX:
|
||||
features->touch_max = value;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -94,6 +94,7 @@ static int i2c_dw_unreg_slave(struct i2c_client *slave)
|
|||
|
||||
dev->disable_int(dev);
|
||||
dev->disable(dev);
|
||||
synchronize_irq(dev->irq);
|
||||
dev->slave = NULL;
|
||||
pm_runtime_put(dev->dev);
|
||||
|
||||
|
|
|
@ -1723,8 +1723,8 @@ void rdma_destroy_id(struct rdma_cm_id *id)
|
|||
mutex_lock(&id_priv->handler_mutex);
|
||||
mutex_unlock(&id_priv->handler_mutex);
|
||||
|
||||
rdma_restrack_del(&id_priv->res);
|
||||
if (id_priv->cma_dev) {
|
||||
rdma_restrack_del(&id_priv->res);
|
||||
if (rdma_cap_ib_cm(id_priv->id.device, 1)) {
|
||||
if (id_priv->cm_id.ib)
|
||||
ib_destroy_cm_id(id_priv->cm_id.ib);
|
||||
|
@ -3463,10 +3463,9 @@ int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
|
|||
|
||||
return 0;
|
||||
err2:
|
||||
if (id_priv->cma_dev) {
|
||||
rdma_restrack_del(&id_priv->res);
|
||||
rdma_restrack_del(&id_priv->res);
|
||||
if (id_priv->cma_dev)
|
||||
cma_release_dev(id_priv);
|
||||
}
|
||||
err1:
|
||||
cma_comp_exch(id_priv, RDMA_CM_ADDR_BOUND, RDMA_CM_IDLE);
|
||||
return ret;
|
||||
|
|
|
@ -209,7 +209,7 @@ void rdma_restrack_del(struct rdma_restrack_entry *res)
|
|||
struct ib_device *dev;
|
||||
|
||||
if (!res->valid)
|
||||
return;
|
||||
goto out;
|
||||
|
||||
dev = res_to_dev(res);
|
||||
if (!dev)
|
||||
|
@ -222,8 +222,10 @@ void rdma_restrack_del(struct rdma_restrack_entry *res)
|
|||
down_write(&dev->res.rwsem);
|
||||
hash_del(&res->node);
|
||||
res->valid = false;
|
||||
up_write(&dev->res.rwsem);
|
||||
|
||||
out:
|
||||
if (res->task)
|
||||
put_task_struct(res->task);
|
||||
up_write(&dev->res.rwsem);
|
||||
}
|
||||
EXPORT_SYMBOL(rdma_restrack_del);
|
||||
|
|
|
@ -1358,7 +1358,7 @@ static const struct acpi_device_id elan_acpi_id[] = {
|
|||
{ "ELAN0618", 0 },
|
||||
{ "ELAN0619", 0 },
|
||||
{ "ELAN061A", 0 },
|
||||
{ "ELAN061B", 0 },
|
||||
/* { "ELAN061B", 0 }, not working on the Lenovo Legion Y7000 */
|
||||
{ "ELAN061C", 0 },
|
||||
{ "ELAN061D", 0 },
|
||||
{ "ELAN061E", 0 },
|
||||
|
|
|
@ -1153,6 +1153,17 @@ static void amd_iommu_flush_tlb_all(struct amd_iommu *iommu)
|
|||
iommu_completion_wait(iommu);
|
||||
}
|
||||
|
||||
static void amd_iommu_flush_tlb_domid(struct amd_iommu *iommu, u32 dom_id)
|
||||
{
|
||||
struct iommu_cmd cmd;
|
||||
|
||||
build_inv_iommu_pages(&cmd, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
|
||||
dom_id, 1);
|
||||
iommu_queue_command(iommu, &cmd);
|
||||
|
||||
iommu_completion_wait(iommu);
|
||||
}
|
||||
|
||||
static void amd_iommu_flush_all(struct amd_iommu *iommu)
|
||||
{
|
||||
struct iommu_cmd cmd;
|
||||
|
@ -1329,18 +1340,21 @@ static void domain_flush_devices(struct protection_domain *domain)
|
|||
* another level increases the size of the address space by 9 bits to a size up
|
||||
* to 64 bits.
|
||||
*/
|
||||
static bool increase_address_space(struct protection_domain *domain,
|
||||
static void increase_address_space(struct protection_domain *domain,
|
||||
gfp_t gfp)
|
||||
{
|
||||
unsigned long flags;
|
||||
u64 *pte;
|
||||
|
||||
if (domain->mode == PAGE_MODE_6_LEVEL)
|
||||
spin_lock_irqsave(&domain->lock, flags);
|
||||
|
||||
if (WARN_ON_ONCE(domain->mode == PAGE_MODE_6_LEVEL))
|
||||
/* address space already 64 bit large */
|
||||
return false;
|
||||
goto out;
|
||||
|
||||
pte = (void *)get_zeroed_page(gfp);
|
||||
if (!pte)
|
||||
return false;
|
||||
goto out;
|
||||
|
||||
*pte = PM_LEVEL_PDE(domain->mode,
|
||||
iommu_virt_to_phys(domain->pt_root));
|
||||
|
@ -1348,7 +1362,10 @@ static bool increase_address_space(struct protection_domain *domain,
|
|||
domain->mode += 1;
|
||||
domain->updated = true;
|
||||
|
||||
return true;
|
||||
out:
|
||||
spin_unlock_irqrestore(&domain->lock, flags);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static u64 *alloc_pte(struct protection_domain *domain,
|
||||
|
@ -1838,6 +1855,7 @@ static void set_dte_entry(u16 devid, struct protection_domain *domain,
|
|||
{
|
||||
u64 pte_root = 0;
|
||||
u64 flags = 0;
|
||||
u32 old_domid;
|
||||
|
||||
if (domain->mode != PAGE_MODE_NONE)
|
||||
pte_root = iommu_virt_to_phys(domain->pt_root);
|
||||
|
@ -1887,8 +1905,20 @@ static void set_dte_entry(u16 devid, struct protection_domain *domain,
|
|||
flags &= ~DEV_DOMID_MASK;
|
||||
flags |= domain->id;
|
||||
|
||||
old_domid = amd_iommu_dev_table[devid].data[1] & DEV_DOMID_MASK;
|
||||
amd_iommu_dev_table[devid].data[1] = flags;
|
||||
amd_iommu_dev_table[devid].data[0] = pte_root;
|
||||
|
||||
/*
|
||||
* A kdump kernel might be replacing a domain ID that was copied from
|
||||
* the previous kernel--if so, it needs to flush the translation cache
|
||||
* entries for the old domain ID that is being overwritten
|
||||
*/
|
||||
if (old_domid) {
|
||||
struct amd_iommu *iommu = amd_iommu_rlookup_table[devid];
|
||||
|
||||
amd_iommu_flush_tlb_domid(iommu, old_domid);
|
||||
}
|
||||
}
|
||||
|
||||
static void clear_dte_entry(u16 devid)
|
||||
|
|
|
@ -607,10 +607,9 @@ static int technisat_usb2_frontend_attach(struct dvb_usb_adapter *a)
|
|||
static int technisat_usb2_get_ir(struct dvb_usb_device *d)
|
||||
{
|
||||
struct technisat_usb2_state *state = d->priv;
|
||||
u8 *buf = state->buf;
|
||||
u8 *b;
|
||||
int ret;
|
||||
struct ir_raw_event ev;
|
||||
u8 *buf = state->buf;
|
||||
int i, ret;
|
||||
|
||||
buf[0] = GET_IR_DATA_VENDOR_REQUEST;
|
||||
buf[1] = 0x08;
|
||||
|
@ -646,26 +645,25 @@ unlock:
|
|||
return 0; /* no key pressed */
|
||||
|
||||
/* decoding */
|
||||
b = buf+1;
|
||||
|
||||
#if 0
|
||||
deb_rc("RC: %d ", ret);
|
||||
debug_dump(b, ret, deb_rc);
|
||||
debug_dump(buf + 1, ret, deb_rc);
|
||||
#endif
|
||||
|
||||
ev.pulse = 0;
|
||||
while (1) {
|
||||
ev.pulse = !ev.pulse;
|
||||
ev.duration = (*b * FIRMWARE_CLOCK_DIVISOR * FIRMWARE_CLOCK_TICK) / 1000;
|
||||
ir_raw_event_store(d->rc_dev, &ev);
|
||||
|
||||
b++;
|
||||
if (*b == 0xff) {
|
||||
for (i = 1; i < ARRAY_SIZE(state->buf); i++) {
|
||||
if (buf[i] == 0xff) {
|
||||
ev.pulse = 0;
|
||||
ev.duration = 888888*2;
|
||||
ir_raw_event_store(d->rc_dev, &ev);
|
||||
break;
|
||||
}
|
||||
|
||||
ev.pulse = !ev.pulse;
|
||||
ev.duration = (buf[i] * FIRMWARE_CLOCK_DIVISOR *
|
||||
FIRMWARE_CLOCK_TICK) / 1000;
|
||||
ir_raw_event_store(d->rc_dev, &ev);
|
||||
}
|
||||
|
||||
ir_raw_event_handle(d->rc_dev);
|
||||
|
|
|
@ -105,6 +105,7 @@ static void tm6000_urb_received(struct urb *urb)
|
|||
printk(KERN_ERR "tm6000: error %s\n", __func__);
|
||||
kfree(urb->transfer_buffer);
|
||||
usb_free_urb(urb);
|
||||
dev->dvb->bulk_urb = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -135,6 +136,7 @@ static int tm6000_start_stream(struct tm6000_core *dev)
|
|||
dvb->bulk_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);
|
||||
if (!dvb->bulk_urb->transfer_buffer) {
|
||||
usb_free_urb(dvb->bulk_urb);
|
||||
dvb->bulk_urb = NULL;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
@ -161,6 +163,7 @@ static int tm6000_start_stream(struct tm6000_core *dev)
|
|||
|
||||
kfree(dvb->bulk_urb->transfer_buffer);
|
||||
usb_free_urb(dvb->bulk_urb);
|
||||
dvb->bulk_urb = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -469,13 +469,19 @@ static int __init xgbe_mod_init(void)
|
|||
|
||||
ret = xgbe_platform_init();
|
||||
if (ret)
|
||||
return ret;
|
||||
goto err_platform_init;
|
||||
|
||||
ret = xgbe_pci_init();
|
||||
if (ret)
|
||||
return ret;
|
||||
goto err_pci_init;
|
||||
|
||||
return 0;
|
||||
|
||||
err_pci_init:
|
||||
xgbe_platform_exit();
|
||||
err_platform_init:
|
||||
unregister_netdevice_notifier(&xgbe_netdev_notifier);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void __exit xgbe_mod_exit(void)
|
||||
|
|
|
@ -89,6 +89,7 @@ static int aq_vec_poll(struct napi_struct *napi, int budget)
|
|||
}
|
||||
}
|
||||
|
||||
err_exit:
|
||||
if (!was_tx_cleaned)
|
||||
work_done = budget;
|
||||
|
||||
|
@ -98,7 +99,7 @@ static int aq_vec_poll(struct napi_struct *napi, int budget)
|
|||
1U << self->aq_ring_param.vec_idx);
|
||||
}
|
||||
}
|
||||
err_exit:
|
||||
|
||||
return work_done;
|
||||
}
|
||||
|
||||
|
|
|
@ -1998,6 +1998,10 @@ static void __ibmvnic_reset(struct work_struct *work)
|
|||
|
||||
rwi = get_next_rwi(adapter);
|
||||
while (rwi) {
|
||||
if (adapter->state == VNIC_REMOVING ||
|
||||
adapter->state == VNIC_REMOVED)
|
||||
goto out;
|
||||
|
||||
if (adapter->force_reset_recovery) {
|
||||
adapter->force_reset_recovery = false;
|
||||
rc = do_hard_reset(adapter, rwi, reset_state);
|
||||
|
@ -2022,7 +2026,7 @@ static void __ibmvnic_reset(struct work_struct *work)
|
|||
netdev_dbg(adapter->netdev, "Reset failed\n");
|
||||
free_all_rwi(adapter);
|
||||
}
|
||||
|
||||
out:
|
||||
adapter->resetting = false;
|
||||
if (we_lock_rtnl)
|
||||
rtnl_unlock();
|
||||
|
|
|
@ -4954,6 +4954,13 @@ static const struct dmi_system_id msi_blacklist[] = {
|
|||
DMI_MATCH(DMI_BOARD_NAME, "P6T"),
|
||||
},
|
||||
},
|
||||
{
|
||||
.ident = "ASUS P6X",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "P6X"),
|
||||
},
|
||||
},
|
||||
{}
|
||||
};
|
||||
|
||||
|
|
|
@ -1150,7 +1150,7 @@ static int qed_slowpath_start(struct qed_dev *cdev,
|
|||
&drv_version);
|
||||
if (rc) {
|
||||
DP_NOTICE(cdev, "Failed sending drv version command\n");
|
||||
return rc;
|
||||
goto err4;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1158,6 +1158,8 @@ static int qed_slowpath_start(struct qed_dev *cdev,
|
|||
|
||||
return 0;
|
||||
|
||||
err4:
|
||||
qed_ll2_dealloc_if(cdev);
|
||||
err3:
|
||||
qed_hw_stop(cdev);
|
||||
err2:
|
||||
|
|
|
@ -793,15 +793,16 @@ static int sgiseeq_probe(struct platform_device *pdev)
|
|||
printk(KERN_ERR "Sgiseeq: Cannot register net device, "
|
||||
"aborting.\n");
|
||||
err = -ENODEV;
|
||||
goto err_out_free_page;
|
||||
goto err_out_free_attrs;
|
||||
}
|
||||
|
||||
printk(KERN_INFO "%s: %s %pM\n", dev->name, sgiseeqstr, dev->dev_addr);
|
||||
|
||||
return 0;
|
||||
|
||||
err_out_free_page:
|
||||
free_page((unsigned long) sp->srings);
|
||||
err_out_free_attrs:
|
||||
dma_free_attrs(&pdev->dev, sizeof(*sp->srings), sp->srings,
|
||||
sp->srings_dma, DMA_ATTR_NON_CONSISTENT);
|
||||
err_out_free_dev:
|
||||
free_netdev(dev);
|
||||
|
||||
|
|
|
@ -821,7 +821,7 @@ static int hwsim_add_one(struct genl_info *info, struct device *dev,
|
|||
err = hwsim_subscribe_all_others(phy);
|
||||
if (err < 0) {
|
||||
mutex_unlock(&hwsim_phys_lock);
|
||||
goto err_reg;
|
||||
goto err_subscribe;
|
||||
}
|
||||
}
|
||||
list_add_tail(&phy->list, &hwsim_phys);
|
||||
|
@ -831,6 +831,8 @@ static int hwsim_add_one(struct genl_info *info, struct device *dev,
|
|||
|
||||
return idx;
|
||||
|
||||
err_subscribe:
|
||||
ieee802154_unregister_hw(phy->hw);
|
||||
err_reg:
|
||||
kfree(pib);
|
||||
err_pib:
|
||||
|
@ -920,9 +922,9 @@ static __init int hwsim_init_module(void)
|
|||
return 0;
|
||||
|
||||
platform_drv:
|
||||
genl_unregister_family(&hwsim_genl_family);
|
||||
platform_dev:
|
||||
platform_device_unregister(mac802154hwsim_dev);
|
||||
platform_dev:
|
||||
genl_unregister_family(&hwsim_genl_family);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
|
@ -788,8 +788,11 @@ int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
|
|||
ret = usb_control_msg(tp->udev, usb_rcvctrlpipe(tp->udev, 0),
|
||||
RTL8152_REQ_GET_REGS, RTL8152_REQT_READ,
|
||||
value, index, tmp, size, 500);
|
||||
if (ret < 0)
|
||||
memset(data, 0xff, size);
|
||||
else
|
||||
memcpy(data, tmp, size);
|
||||
|
||||
memcpy(data, tmp, size);
|
||||
kfree(tmp);
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -241,6 +241,9 @@ static int mwifiex_update_vs_ie(const u8 *ies, int ies_len,
|
|||
}
|
||||
|
||||
vs_ie = (struct ieee_types_header *)vendor_ie;
|
||||
if (le16_to_cpu(ie->ie_length) + vs_ie->len + 2 >
|
||||
IEEE_MAX_IE_SIZE)
|
||||
return -EINVAL;
|
||||
memcpy(ie->ie_buffer + le16_to_cpu(ie->ie_length),
|
||||
vs_ie, vs_ie->len + 2);
|
||||
le16_unaligned_add_cpu(&ie->ie_length, vs_ie->len + 2);
|
||||
|
|
|
@ -265,6 +265,8 @@ mwifiex_set_uap_rates(struct mwifiex_uap_bss_param *bss_cfg,
|
|||
|
||||
rate_ie = (void *)cfg80211_find_ie(WLAN_EID_SUPP_RATES, var_pos, len);
|
||||
if (rate_ie) {
|
||||
if (rate_ie->len > MWIFIEX_SUPPORTED_RATES)
|
||||
return;
|
||||
memcpy(bss_cfg->rates, rate_ie + 1, rate_ie->len);
|
||||
rate_len = rate_ie->len;
|
||||
}
|
||||
|
@ -272,8 +274,11 @@ mwifiex_set_uap_rates(struct mwifiex_uap_bss_param *bss_cfg,
|
|||
rate_ie = (void *)cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES,
|
||||
params->beacon.tail,
|
||||
params->beacon.tail_len);
|
||||
if (rate_ie)
|
||||
if (rate_ie) {
|
||||
if (rate_ie->len > MWIFIEX_SUPPORTED_RATES - rate_len)
|
||||
return;
|
||||
memcpy(bss_cfg->rates + rate_len, rate_ie + 1, rate_ie->len);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -391,6 +396,8 @@ mwifiex_set_wmm_params(struct mwifiex_private *priv,
|
|||
params->beacon.tail_len);
|
||||
if (vendor_ie) {
|
||||
wmm_ie = vendor_ie;
|
||||
if (*(wmm_ie + 1) > sizeof(struct mwifiex_types_wmm_info))
|
||||
return;
|
||||
memcpy(&bss_cfg->wmm_info, wmm_ie +
|
||||
sizeof(struct ieee_types_header), *(wmm_ie + 1));
|
||||
priv->wmm_enabled = 1;
|
||||
|
|
|
@ -909,7 +909,7 @@ static RING_IDX xennet_fill_frags(struct netfront_queue *queue,
|
|||
__pskb_pull_tail(skb, pull_to - skb_headlen(skb));
|
||||
}
|
||||
if (unlikely(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS)) {
|
||||
queue->rx.rsp_cons = ++cons;
|
||||
queue->rx.rsp_cons = ++cons + skb_queue_len(list);
|
||||
kfree_skb(nskb);
|
||||
return ~0U;
|
||||
}
|
||||
|
|
|
@ -467,8 +467,8 @@ static int kirin_pcie_add_msi(struct dw_pcie *pci,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int __init kirin_add_pcie_port(struct dw_pcie *pci,
|
||||
struct platform_device *pdev)
|
||||
static int kirin_add_pcie_port(struct dw_pcie *pci,
|
||||
struct platform_device *pdev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
|
|
|
@ -66,6 +66,7 @@
|
|||
USB2_OBINT_IDDIGCHG)
|
||||
|
||||
/* VBCTRL */
|
||||
#define USB2_VBCTRL_OCCLREN BIT(16)
|
||||
#define USB2_VBCTRL_DRVVBUSSEL BIT(8)
|
||||
|
||||
/* LINECTRL1 */
|
||||
|
@ -289,6 +290,7 @@ static void rcar_gen3_init_otg(struct rcar_gen3_chan *ch)
|
|||
u32 val;
|
||||
|
||||
val = readl(usb2_base + USB2_VBCTRL);
|
||||
val &= ~USB2_VBCTRL_OCCLREN;
|
||||
writel(val | USB2_VBCTRL_DRVVBUSSEL, usb2_base + USB2_VBCTRL);
|
||||
writel(USB2_OBINT_BITS, usb2_base + USB2_OBINTSTA);
|
||||
val = readl(usb2_base + USB2_OBINTEN);
|
||||
|
|
|
@ -1270,7 +1270,6 @@ atmel_handle_transmit(struct uart_port *port, unsigned int pending)
|
|||
|
||||
atmel_port->hd_start_rx = false;
|
||||
atmel_start_rx(port);
|
||||
return;
|
||||
}
|
||||
|
||||
atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_tx);
|
||||
|
|
|
@ -232,7 +232,7 @@ static inline void sprd_rx(struct uart_port *port)
|
|||
|
||||
if (lsr & (SPRD_LSR_BI | SPRD_LSR_PE |
|
||||
SPRD_LSR_FE | SPRD_LSR_OE))
|
||||
if (handle_lsr_errors(port, &lsr, &flag))
|
||||
if (handle_lsr_errors(port, &flag, &lsr))
|
||||
continue;
|
||||
if (uart_handle_sysrq_char(port, ch))
|
||||
continue;
|
||||
|
|
|
@ -928,7 +928,7 @@ int usb_get_bos_descriptor(struct usb_device *dev)
|
|||
struct usb_bos_descriptor *bos;
|
||||
struct usb_dev_cap_header *cap;
|
||||
struct usb_ssp_cap_descriptor *ssp_cap;
|
||||
unsigned char *buffer;
|
||||
unsigned char *buffer, *buffer0;
|
||||
int length, total_len, num, i, ssac;
|
||||
__u8 cap_type;
|
||||
int ret;
|
||||
|
@ -973,10 +973,12 @@ int usb_get_bos_descriptor(struct usb_device *dev)
|
|||
ret = -ENOMSG;
|
||||
goto err;
|
||||
}
|
||||
|
||||
buffer0 = buffer;
|
||||
total_len -= length;
|
||||
buffer += length;
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
buffer += length;
|
||||
cap = (struct usb_dev_cap_header *)buffer;
|
||||
|
||||
if (total_len < sizeof(*cap) || total_len < cap->bLength) {
|
||||
|
@ -990,8 +992,6 @@ int usb_get_bos_descriptor(struct usb_device *dev)
|
|||
break;
|
||||
}
|
||||
|
||||
total_len -= length;
|
||||
|
||||
if (cap->bDescriptorType != USB_DT_DEVICE_CAPABILITY) {
|
||||
dev_warn(ddev, "descriptor type invalid, skip\n");
|
||||
continue;
|
||||
|
@ -1035,7 +1035,11 @@ int usb_get_bos_descriptor(struct usb_device *dev)
|
|||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
total_len -= length;
|
||||
buffer += length;
|
||||
}
|
||||
dev->bos->desc->wTotalLength = cpu_to_le16(buffer - buffer0);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -1148,6 +1148,16 @@ static int tegra_xusb_probe(struct platform_device *pdev)
|
|||
|
||||
tegra_xusb_ipfs_config(tegra, regs);
|
||||
|
||||
/*
|
||||
* The XUSB Falcon microcontroller can only address 40 bits, so set
|
||||
* the DMA mask accordingly.
|
||||
*/
|
||||
err = dma_set_mask_and_coherent(tegra->dev, DMA_BIT_MASK(40));
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "failed to set DMA mask: %d\n", err);
|
||||
goto put_rpm;
|
||||
}
|
||||
|
||||
err = tegra_xusb_load_firmware(tegra);
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "failed to load firmware: %d\n", err);
|
||||
|
|
|
@ -1137,6 +1137,17 @@ static int load_elf_binary(struct linux_binprm *bprm)
|
|||
current->mm->start_stack = bprm->p;
|
||||
|
||||
if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
|
||||
/*
|
||||
* For architectures with ELF randomization, when executing
|
||||
* a loader directly (i.e. no interpreter listed in ELF
|
||||
* headers), move the brk area out of the mmap region
|
||||
* (since it grows up, and may collide early with the stack
|
||||
* growing down), and into the unused ELF_ET_DYN_BASE region.
|
||||
*/
|
||||
if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) && !interpreter)
|
||||
current->mm->brk = current->mm->start_brk =
|
||||
ELF_ET_DYN_BASE;
|
||||
|
||||
current->mm->brk = current->mm->start_brk =
|
||||
arch_randomize_brk(current->mm);
|
||||
#ifdef compat_brk_randomized
|
||||
|
|
|
@ -2756,6 +2756,7 @@ static int
|
|||
cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
|
||||
{
|
||||
int rc = 0;
|
||||
int is_domain = 0;
|
||||
const char *delim, *payload;
|
||||
char *desc;
|
||||
ssize_t len;
|
||||
|
@ -2803,6 +2804,7 @@ cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
|
|||
rc = PTR_ERR(key);
|
||||
goto out_err;
|
||||
}
|
||||
is_domain = 1;
|
||||
}
|
||||
|
||||
down_read(&key->sem);
|
||||
|
@ -2860,6 +2862,26 @@ cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
|
|||
goto out_key_put;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we have a domain key then we must set the domainName in the
|
||||
* for the request.
|
||||
*/
|
||||
if (is_domain && ses->domainName) {
|
||||
vol->domainname = kstrndup(ses->domainName,
|
||||
strlen(ses->domainName),
|
||||
GFP_KERNEL);
|
||||
if (!vol->domainname) {
|
||||
cifs_dbg(FYI, "Unable to allocate %zd bytes for "
|
||||
"domain\n", len);
|
||||
rc = -ENOMEM;
|
||||
kfree(vol->username);
|
||||
vol->username = NULL;
|
||||
kzfree(vol->password);
|
||||
vol->password = NULL;
|
||||
goto out_key_put;
|
||||
}
|
||||
}
|
||||
|
||||
out_key_put:
|
||||
up_read(&key->sem);
|
||||
key_put(key);
|
||||
|
|
|
@ -1487,7 +1487,7 @@ static int nfs_finish_open(struct nfs_open_context *ctx,
|
|||
if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
|
||||
nfs_file_set_open_context(file, ctx);
|
||||
else
|
||||
err = -ESTALE;
|
||||
err = -EOPENSTALE;
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
|
|
@ -73,13 +73,13 @@ nfs4_file_open(struct inode *inode, struct file *filp)
|
|||
if (IS_ERR(inode)) {
|
||||
err = PTR_ERR(inode);
|
||||
switch (err) {
|
||||
case -EPERM:
|
||||
case -EACCES:
|
||||
case -EDQUOT:
|
||||
case -ENOSPC:
|
||||
case -EROFS:
|
||||
goto out_put_ctx;
|
||||
default:
|
||||
goto out_put_ctx;
|
||||
case -ENOENT:
|
||||
case -ESTALE:
|
||||
case -EISDIR:
|
||||
case -ENOTDIR:
|
||||
case -ELOOP:
|
||||
goto out_drop;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -567,7 +567,7 @@ static void nfs_pgio_rpcsetup(struct nfs_pgio_header *hdr,
|
|||
}
|
||||
|
||||
hdr->res.fattr = &hdr->fattr;
|
||||
hdr->res.count = count;
|
||||
hdr->res.count = 0;
|
||||
hdr->res.eof = 0;
|
||||
hdr->res.verf = &hdr->verf;
|
||||
nfs_fattr_init(&hdr->fattr);
|
||||
|
|
|
@ -594,7 +594,8 @@ static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
|
|||
/* Emulate the eof flag, which isn't normally needed in NFSv2
|
||||
* as it is guaranteed to always return the file attributes
|
||||
*/
|
||||
if (hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
|
||||
if ((hdr->res.count == 0 && hdr->args.count > 0) ||
|
||||
hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
|
||||
hdr->res.eof = 1;
|
||||
}
|
||||
return 0;
|
||||
|
@ -615,8 +616,10 @@ static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
|
|||
|
||||
static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
|
||||
{
|
||||
if (task->tk_status >= 0)
|
||||
if (task->tk_status >= 0) {
|
||||
hdr->res.count = hdr->args.count;
|
||||
nfs_writeback_update_inode(hdr);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -70,6 +70,7 @@ struct ovl_fs {
|
|||
bool workdir_locked;
|
||||
/* Traps in ovl inode cache */
|
||||
struct inode *upperdir_trap;
|
||||
struct inode *workbasedir_trap;
|
||||
struct inode *workdir_trap;
|
||||
struct inode *indexdir_trap;
|
||||
/* Inode numbers in all layers do not use the high xino_bits */
|
||||
|
|
|
@ -222,6 +222,7 @@ static void ovl_free_fs(struct ovl_fs *ofs)
|
|||
{
|
||||
unsigned i;
|
||||
|
||||
iput(ofs->workbasedir_trap);
|
||||
iput(ofs->indexdir_trap);
|
||||
iput(ofs->workdir_trap);
|
||||
iput(ofs->upperdir_trap);
|
||||
|
@ -1046,6 +1047,25 @@ static int ovl_setup_trap(struct super_block *sb, struct dentry *dir,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine how we treat concurrent use of upperdir/workdir based on the
|
||||
* index feature. This is papering over mount leaks of container runtimes,
|
||||
* for example, an old overlay mount is leaked and now its upperdir is
|
||||
* attempted to be used as a lower layer in a new overlay mount.
|
||||
*/
|
||||
static int ovl_report_in_use(struct ovl_fs *ofs, const char *name)
|
||||
{
|
||||
if (ofs->config.index) {
|
||||
pr_err("overlayfs: %s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n",
|
||||
name);
|
||||
return -EBUSY;
|
||||
} else {
|
||||
pr_warn("overlayfs: %s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n",
|
||||
name);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct path *upperpath)
|
||||
{
|
||||
|
@ -1083,14 +1103,12 @@ static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
|
|||
upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
|
||||
ofs->upper_mnt = upper_mnt;
|
||||
|
||||
err = -EBUSY;
|
||||
if (ovl_inuse_trylock(ofs->upper_mnt->mnt_root)) {
|
||||
ofs->upperdir_locked = true;
|
||||
} else if (ofs->config.index) {
|
||||
pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n");
|
||||
goto out;
|
||||
} else {
|
||||
pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
|
||||
err = ovl_report_in_use(ofs, "upperdir");
|
||||
if (err)
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
|
@ -1200,16 +1218,19 @@ static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs,
|
|||
|
||||
ofs->workbasedir = dget(workpath.dentry);
|
||||
|
||||
err = -EBUSY;
|
||||
if (ovl_inuse_trylock(ofs->workbasedir)) {
|
||||
ofs->workdir_locked = true;
|
||||
} else if (ofs->config.index) {
|
||||
pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n");
|
||||
goto out;
|
||||
} else {
|
||||
pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
|
||||
err = ovl_report_in_use(ofs, "workdir");
|
||||
if (err)
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap,
|
||||
"workdir");
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = ovl_make_workdir(sb, ofs, &workpath);
|
||||
|
||||
out:
|
||||
|
@ -1328,16 +1349,16 @@ static int ovl_get_lower_layers(struct super_block *sb, struct ovl_fs *ofs,
|
|||
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;
|
||||
|
||||
if (ovl_is_inuse(stack[i].dentry)) {
|
||||
err = ovl_report_in_use(ofs, "lowerdir");
|
||||
if (err)
|
||||
goto out;
|
||||
}
|
||||
|
||||
mnt = clone_private_mount(&stack[i]);
|
||||
err = PTR_ERR(mnt);
|
||||
if (IS_ERR(mnt)) {
|
||||
|
@ -1484,8 +1505,8 @@ out_err:
|
|||
* - 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)
|
||||
static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs,
|
||||
struct dentry *dentry, const char *name)
|
||||
{
|
||||
struct dentry *next = dentry, *parent;
|
||||
int err = 0;
|
||||
|
@ -1497,13 +1518,11 @@ static int ovl_check_layer(struct super_block *sb, struct dentry *dentry,
|
|||
|
||||
/* 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)) {
|
||||
if (ovl_lookup_trap_inode(sb, parent)) {
|
||||
err = -ELOOP;
|
||||
pr_err("overlayfs: overlapping %s path\n", name);
|
||||
} else if (ovl_is_inuse(parent)) {
|
||||
err = ovl_report_in_use(ofs, name);
|
||||
}
|
||||
next = parent;
|
||||
parent = dget_parent(next);
|
||||
|
@ -1524,7 +1543,8 @@ static int ovl_check_overlapping_layers(struct super_block *sb,
|
|||
int i, err;
|
||||
|
||||
if (ofs->upper_mnt) {
|
||||
err = ovl_check_layer(sb, ofs->upper_mnt->mnt_root, "upperdir");
|
||||
err = ovl_check_layer(sb, ofs, ofs->upper_mnt->mnt_root,
|
||||
"upperdir");
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
|
@ -1535,13 +1555,14 @@ static int ovl_check_overlapping_layers(struct super_block *sb,
|
|||
* 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");
|
||||
err = ovl_check_layer(sb, ofs, 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,
|
||||
err = ovl_check_layer(sb, ofs,
|
||||
ofs->lower_layers[i].mnt->mnt_root,
|
||||
"lowerdir");
|
||||
if (err)
|
||||
return err;
|
||||
|
|
|
@ -21,7 +21,8 @@ struct sock_reuseport {
|
|||
unsigned int synq_overflow_ts;
|
||||
/* ID stays the same even after the size of socks[] grows. */
|
||||
unsigned int reuseport_id;
|
||||
bool bind_inany;
|
||||
unsigned int bind_inany:1;
|
||||
unsigned int has_conns:1;
|
||||
struct bpf_prog __rcu *prog; /* optional BPF sock selector */
|
||||
struct sock *socks[0]; /* array of sock pointers */
|
||||
};
|
||||
|
@ -35,6 +36,24 @@ extern struct sock *reuseport_select_sock(struct sock *sk,
|
|||
struct sk_buff *skb,
|
||||
int hdr_len);
|
||||
extern int reuseport_attach_prog(struct sock *sk, struct bpf_prog *prog);
|
||||
|
||||
static inline bool reuseport_has_conns(struct sock *sk, bool set)
|
||||
{
|
||||
struct sock_reuseport *reuse;
|
||||
bool ret = false;
|
||||
|
||||
rcu_read_lock();
|
||||
reuse = rcu_dereference(sk->sk_reuseport_cb);
|
||||
if (reuse) {
|
||||
if (set)
|
||||
reuse->has_conns = 1;
|
||||
ret = reuse->has_conns;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int reuseport_get_id(struct sock_reuseport *reuse);
|
||||
|
||||
#endif /* _SOCK_REUSEPORT_H */
|
||||
|
|
|
@ -11,4 +11,9 @@ struct xt_nfacct_match_info {
|
|||
struct nf_acct *nfacct;
|
||||
};
|
||||
|
||||
struct xt_nfacct_match_info_v1 {
|
||||
char name[NFACCT_NAME_MAX];
|
||||
struct nf_acct *nfacct __attribute__((aligned(8)));
|
||||
};
|
||||
|
||||
#endif /* _XT_NFACCT_MATCH_H */
|
||||
|
|
|
@ -262,8 +262,10 @@ int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
|
|||
{
|
||||
char namebuf[KSYM_NAME_LEN];
|
||||
|
||||
if (is_ksym_addr(addr))
|
||||
return !!get_symbol_pos(addr, symbolsize, offset);
|
||||
if (is_ksym_addr(addr)) {
|
||||
get_symbol_pos(addr, symbolsize, offset);
|
||||
return 1;
|
||||
}
|
||||
return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf) ||
|
||||
!!__bpf_address_lookup(addr, symbolsize, offset, namebuf);
|
||||
}
|
||||
|
|
|
@ -643,17 +643,23 @@ batadv_v_ogm_process_per_outif(struct batadv_priv *bat_priv,
|
|||
* batadv_v_ogm_aggr_packet() - checks if there is another OGM aggregated
|
||||
* @buff_pos: current position in the skb
|
||||
* @packet_len: total length of the skb
|
||||
* @tvlv_len: tvlv length of the previously considered OGM
|
||||
* @ogm2_packet: potential OGM2 in buffer
|
||||
*
|
||||
* Return: true if there is enough space for another OGM, false otherwise.
|
||||
*/
|
||||
static bool batadv_v_ogm_aggr_packet(int buff_pos, int packet_len,
|
||||
__be16 tvlv_len)
|
||||
static bool
|
||||
batadv_v_ogm_aggr_packet(int buff_pos, int packet_len,
|
||||
const struct batadv_ogm2_packet *ogm2_packet)
|
||||
{
|
||||
int next_buff_pos = 0;
|
||||
|
||||
next_buff_pos += buff_pos + BATADV_OGM2_HLEN;
|
||||
next_buff_pos += ntohs(tvlv_len);
|
||||
/* check if there is enough space for the header */
|
||||
next_buff_pos += buff_pos + sizeof(*ogm2_packet);
|
||||
if (next_buff_pos > packet_len)
|
||||
return false;
|
||||
|
||||
/* check if there is enough space for the optional TVLV */
|
||||
next_buff_pos += ntohs(ogm2_packet->tvlv_len);
|
||||
|
||||
return (next_buff_pos <= packet_len) &&
|
||||
(next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
|
||||
|
@ -830,7 +836,7 @@ int batadv_v_ogm_packet_recv(struct sk_buff *skb,
|
|||
ogm_packet = (struct batadv_ogm2_packet *)skb->data;
|
||||
|
||||
while (batadv_v_ogm_aggr_packet(ogm_offset, skb_headlen(skb),
|
||||
ogm_packet->tvlv_len)) {
|
||||
ogm_packet)) {
|
||||
batadv_v_ogm_process(skb, ogm_offset, if_incoming);
|
||||
|
||||
ogm_offset += BATADV_OGM2_HLEN;
|
||||
|
|
|
@ -225,7 +225,7 @@ unsigned int ebt_do_table(struct sk_buff *skb,
|
|||
return NF_DROP;
|
||||
}
|
||||
|
||||
ADD_COUNTER(*(counter_base + i), 1, skb->len);
|
||||
ADD_COUNTER(*(counter_base + i), skb->len, 1);
|
||||
|
||||
/* these should only watch: not modify, nor tell us
|
||||
* what to do with the packet
|
||||
|
@ -963,8 +963,8 @@ static void get_counters(const struct ebt_counter *oldcounters,
|
|||
continue;
|
||||
counter_base = COUNTER_BASE(oldcounters, nentries, cpu);
|
||||
for (i = 0; i < nentries; i++)
|
||||
ADD_COUNTER(counters[i], counter_base[i].pcnt,
|
||||
counter_base[i].bcnt);
|
||||
ADD_COUNTER(counters[i], counter_base[i].bcnt,
|
||||
counter_base[i].pcnt);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1289,7 +1289,7 @@ static int do_update_counters(struct net *net, const char *name,
|
|||
|
||||
/* we add to the counters of the first cpu */
|
||||
for (i = 0; i < num_counters; i++)
|
||||
ADD_COUNTER(t->private->counters[i], tmp[i].pcnt, tmp[i].bcnt);
|
||||
ADD_COUNTER(t->private->counters[i], tmp[i].bcnt, tmp[i].pcnt);
|
||||
|
||||
write_unlock_bh(&t->lock);
|
||||
ret = 0;
|
||||
|
|
|
@ -7234,13 +7234,13 @@ sk_reuseport_is_valid_access(int off, int size,
|
|||
return size == size_default;
|
||||
|
||||
/* Fields that allow narrowing */
|
||||
case offsetof(struct sk_reuseport_md, eth_protocol):
|
||||
case bpf_ctx_range(struct sk_reuseport_md, eth_protocol):
|
||||
if (size < FIELD_SIZEOF(struct sk_buff, protocol))
|
||||
return false;
|
||||
/* fall through */
|
||||
case offsetof(struct sk_reuseport_md, ip_protocol):
|
||||
case offsetof(struct sk_reuseport_md, bind_inany):
|
||||
case offsetof(struct sk_reuseport_md, len):
|
||||
case bpf_ctx_range(struct sk_reuseport_md, ip_protocol):
|
||||
case bpf_ctx_range(struct sk_reuseport_md, bind_inany):
|
||||
case bpf_ctx_range(struct sk_reuseport_md, len):
|
||||
bpf_ctx_record_field_size(info, size_default);
|
||||
return bpf_ctx_narrow_access_ok(off, size, size_default);
|
||||
|
||||
|
|
|
@ -292,8 +292,19 @@ struct sock *reuseport_select_sock(struct sock *sk,
|
|||
|
||||
select_by_hash:
|
||||
/* no bpf or invalid bpf result: fall back to hash usage */
|
||||
if (!sk2)
|
||||
sk2 = reuse->socks[reciprocal_scale(hash, socks)];
|
||||
if (!sk2) {
|
||||
int i, j;
|
||||
|
||||
i = j = reciprocal_scale(hash, socks);
|
||||
while (reuse->socks[i]->sk_state == TCP_ESTABLISHED) {
|
||||
i++;
|
||||
if (i >= reuse->num_socks)
|
||||
i = 0;
|
||||
if (i == j)
|
||||
goto out;
|
||||
}
|
||||
sk2 = reuse->socks[i];
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
#include <net/sock.h>
|
||||
#include <net/route.h>
|
||||
#include <net/tcp_states.h>
|
||||
#include <net/sock_reuseport.h>
|
||||
|
||||
int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
|
||||
{
|
||||
|
@ -73,6 +74,7 @@ int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len
|
|||
}
|
||||
inet->inet_daddr = fl4->daddr;
|
||||
inet->inet_dport = usin->sin_port;
|
||||
reuseport_has_conns(sk, true);
|
||||
sk->sk_state = TCP_ESTABLISHED;
|
||||
sk_set_txhash(sk);
|
||||
inet->inet_id = jiffies;
|
||||
|
|
|
@ -449,12 +449,13 @@ static struct sock *udp4_lib_lookup2(struct net *net,
|
|||
score = compute_score(sk, net, saddr, sport,
|
||||
daddr, hnum, dif, sdif, exact_dif);
|
||||
if (score > badness) {
|
||||
if (sk->sk_reuseport) {
|
||||
if (sk->sk_reuseport &&
|
||||
sk->sk_state != TCP_ESTABLISHED) {
|
||||
hash = udp_ehashfn(net, daddr, hnum,
|
||||
saddr, sport);
|
||||
result = reuseport_select_sock(sk, hash, skb,
|
||||
sizeof(struct udphdr));
|
||||
if (result)
|
||||
if (result && !reuseport_has_conns(sk, false))
|
||||
return result;
|
||||
}
|
||||
badness = score;
|
||||
|
|
|
@ -31,6 +31,7 @@
|
|||
#include <net/ip6_route.h>
|
||||
#include <net/tcp_states.h>
|
||||
#include <net/dsfield.h>
|
||||
#include <net/sock_reuseport.h>
|
||||
|
||||
#include <linux/errqueue.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
@ -258,6 +259,7 @@ ipv4_connected:
|
|||
goto out;
|
||||
}
|
||||
|
||||
reuseport_has_conns(sk, true);
|
||||
sk->sk_state = TCP_ESTABLISHED;
|
||||
sk_set_txhash(sk);
|
||||
out:
|
||||
|
|
|
@ -988,7 +988,7 @@ static netdev_tx_t ip6erspan_tunnel_xmit(struct sk_buff *skb,
|
|||
if (unlikely(!tun_info ||
|
||||
!(tun_info->mode & IP_TUNNEL_INFO_TX) ||
|
||||
ip_tunnel_info_af(tun_info) != AF_INET6))
|
||||
return -EINVAL;
|
||||
goto tx_err;
|
||||
|
||||
key = &tun_info->key;
|
||||
memset(&fl6, 0, sizeof(fl6));
|
||||
|
|
|
@ -177,13 +177,14 @@ static struct sock *udp6_lib_lookup2(struct net *net,
|
|||
score = compute_score(sk, net, saddr, sport,
|
||||
daddr, hnum, dif, sdif, exact_dif);
|
||||
if (score > badness) {
|
||||
if (sk->sk_reuseport) {
|
||||
if (sk->sk_reuseport &&
|
||||
sk->sk_state != TCP_ESTABLISHED) {
|
||||
hash = udp6_ehashfn(net, daddr, hnum,
|
||||
saddr, sport);
|
||||
|
||||
result = reuseport_select_sock(sk, hash, skb,
|
||||
sizeof(struct udphdr));
|
||||
if (result)
|
||||
if (result && !reuseport_has_conns(sk, false))
|
||||
return result;
|
||||
}
|
||||
result = sk;
|
||||
|
|
|
@ -323,7 +323,7 @@ static int find_pattern(const char *data, size_t dlen,
|
|||
i++;
|
||||
}
|
||||
|
||||
pr_debug("Skipped up to `%c'!\n", skip);
|
||||
pr_debug("Skipped up to 0x%hhx delimiter!\n", skip);
|
||||
|
||||
*numoff = i;
|
||||
*numlen = getnum(data + i, dlen - i, cmd, term, numoff);
|
||||
|
|
|
@ -203,7 +203,7 @@ int flow_offload_add(struct nf_flowtable *flow_table, struct flow_offload *flow)
|
|||
return err;
|
||||
}
|
||||
|
||||
flow->timeout = (u32)jiffies;
|
||||
flow->timeout = (u32)jiffies + NF_FLOW_TIMEOUT;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(flow_offload_add);
|
||||
|
|
|
@ -149,6 +149,11 @@ static int nft_flow_offload_validate(const struct nft_ctx *ctx,
|
|||
return nft_chain_validate_hooks(ctx->chain, hook_mask);
|
||||
}
|
||||
|
||||
static const struct nla_policy nft_flow_offload_policy[NFTA_FLOW_MAX + 1] = {
|
||||
[NFTA_FLOW_TABLE_NAME] = { .type = NLA_STRING,
|
||||
.len = NFT_NAME_MAXLEN - 1 },
|
||||
};
|
||||
|
||||
static int nft_flow_offload_init(const struct nft_ctx *ctx,
|
||||
const struct nft_expr *expr,
|
||||
const struct nlattr * const tb[])
|
||||
|
@ -207,6 +212,7 @@ static const struct nft_expr_ops nft_flow_offload_ops = {
|
|||
static struct nft_expr_type nft_flow_offload_type __read_mostly = {
|
||||
.name = "flow_offload",
|
||||
.ops = &nft_flow_offload_ops,
|
||||
.policy = nft_flow_offload_policy,
|
||||
.maxattr = NFTA_FLOW_MAX,
|
||||
.owner = THIS_MODULE,
|
||||
};
|
||||
|
|
|
@ -57,25 +57,39 @@ nfacct_mt_destroy(const struct xt_mtdtor_param *par)
|
|||
nfnl_acct_put(info->nfacct);
|
||||
}
|
||||
|
||||
static struct xt_match nfacct_mt_reg __read_mostly = {
|
||||
.name = "nfacct",
|
||||
.family = NFPROTO_UNSPEC,
|
||||
.checkentry = nfacct_mt_checkentry,
|
||||
.match = nfacct_mt,
|
||||
.destroy = nfacct_mt_destroy,
|
||||
.matchsize = sizeof(struct xt_nfacct_match_info),
|
||||
.usersize = offsetof(struct xt_nfacct_match_info, nfacct),
|
||||
.me = THIS_MODULE,
|
||||
static struct xt_match nfacct_mt_reg[] __read_mostly = {
|
||||
{
|
||||
.name = "nfacct",
|
||||
.revision = 0,
|
||||
.family = NFPROTO_UNSPEC,
|
||||
.checkentry = nfacct_mt_checkentry,
|
||||
.match = nfacct_mt,
|
||||
.destroy = nfacct_mt_destroy,
|
||||
.matchsize = sizeof(struct xt_nfacct_match_info),
|
||||
.usersize = offsetof(struct xt_nfacct_match_info, nfacct),
|
||||
.me = THIS_MODULE,
|
||||
},
|
||||
{
|
||||
.name = "nfacct",
|
||||
.revision = 1,
|
||||
.family = NFPROTO_UNSPEC,
|
||||
.checkentry = nfacct_mt_checkentry,
|
||||
.match = nfacct_mt,
|
||||
.destroy = nfacct_mt_destroy,
|
||||
.matchsize = sizeof(struct xt_nfacct_match_info_v1),
|
||||
.usersize = offsetof(struct xt_nfacct_match_info_v1, nfacct),
|
||||
.me = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init nfacct_mt_init(void)
|
||||
{
|
||||
return xt_register_match(&nfacct_mt_reg);
|
||||
return xt_register_matches(nfacct_mt_reg, ARRAY_SIZE(nfacct_mt_reg));
|
||||
}
|
||||
|
||||
static void __exit nfacct_mt_exit(void)
|
||||
{
|
||||
xt_unregister_match(&nfacct_mt_reg);
|
||||
xt_unregister_matches(nfacct_mt_reg, ARRAY_SIZE(nfacct_mt_reg));
|
||||
}
|
||||
|
||||
module_init(nfacct_mt_init);
|
||||
|
|
|
@ -104,11 +104,9 @@ static int physdev_mt_check(const struct xt_mtchk_param *par)
|
|||
if (info->bitmask & (XT_PHYSDEV_OP_OUT | XT_PHYSDEV_OP_ISOUT) &&
|
||||
(!(info->bitmask & XT_PHYSDEV_OP_BRIDGED) ||
|
||||
info->invert & XT_PHYSDEV_OP_BRIDGED) &&
|
||||
par->hook_mask & ((1 << NF_INET_LOCAL_OUT) |
|
||||
(1 << NF_INET_FORWARD) | (1 << NF_INET_POST_ROUTING))) {
|
||||
par->hook_mask & (1 << NF_INET_LOCAL_OUT)) {
|
||||
pr_info_ratelimited("--physdev-out and --physdev-is-out only supported in the FORWARD and POSTROUTING chains with bridged traffic\n");
|
||||
if (par->hook_mask & (1 << NF_INET_LOCAL_OUT))
|
||||
return -EINVAL;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!brnf_probed) {
|
||||
|
|
|
@ -947,9 +947,13 @@ void qdisc_free(struct Qdisc *qdisc)
|
|||
|
||||
void qdisc_destroy(struct Qdisc *qdisc)
|
||||
{
|
||||
const struct Qdisc_ops *ops = qdisc->ops;
|
||||
const struct Qdisc_ops *ops;
|
||||
struct sk_buff *skb, *tmp;
|
||||
|
||||
if (!qdisc)
|
||||
return;
|
||||
ops = qdisc->ops;
|
||||
|
||||
if (qdisc->flags & TCQ_F_BUILTIN ||
|
||||
!refcount_dec_and_test(&qdisc->refcnt))
|
||||
return;
|
||||
|
|
|
@ -10311,9 +10311,11 @@ static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
|
|||
hyst = wdev->cqm_config->rssi_hyst;
|
||||
n = wdev->cqm_config->n_rssi_thresholds;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
for (i = 0; i < n; i++) {
|
||||
i = array_index_nospec(i, n);
|
||||
if (last < wdev->cqm_config->rssi_thresholds[i])
|
||||
break;
|
||||
}
|
||||
|
||||
low_index = i - 1;
|
||||
if (low_index >= 0) {
|
||||
|
|
|
@ -322,7 +322,7 @@ static int xdp_umem_reg(struct xdp_umem *umem, struct xdp_umem_reg *mr)
|
|||
umem->pages = kcalloc(umem->npgs, sizeof(*umem->pages), GFP_KERNEL);
|
||||
if (!umem->pages) {
|
||||
err = -ENOMEM;
|
||||
goto out_account;
|
||||
goto out_pin;
|
||||
}
|
||||
|
||||
for (i = 0; i < umem->npgs; i++)
|
||||
|
@ -330,6 +330,8 @@ static int xdp_umem_reg(struct xdp_umem *umem, struct xdp_umem_reg *mr)
|
|||
|
||||
return 0;
|
||||
|
||||
out_pin:
|
||||
xdp_umem_unpin_pages(umem);
|
||||
out_account:
|
||||
xdp_umem_unaccount_pages(umem);
|
||||
return err;
|
||||
|
|
|
@ -71,6 +71,9 @@ static void request_key_auth_describe(const struct key *key,
|
|||
{
|
||||
struct request_key_auth *rka = get_request_key_auth(key);
|
||||
|
||||
if (!rka)
|
||||
return;
|
||||
|
||||
seq_puts(m, "key:");
|
||||
seq_puts(m, key->description);
|
||||
if (key_is_positive(key))
|
||||
|
@ -88,6 +91,9 @@ static long request_key_auth_read(const struct key *key,
|
|||
size_t datalen;
|
||||
long ret;
|
||||
|
||||
if (!rka)
|
||||
return -EKEYREVOKED;
|
||||
|
||||
datalen = rka->callout_len;
|
||||
ret = datalen;
|
||||
|
||||
|
|
|
@ -381,7 +381,9 @@ static int do_show(int argc, char **argv)
|
|||
if (fd < 0)
|
||||
return -1;
|
||||
|
||||
return show_prog(fd);
|
||||
err = show_prog(fd);
|
||||
close(fd);
|
||||
return err;
|
||||
}
|
||||
|
||||
if (argc)
|
||||
|
|
|
@ -4953,7 +4953,7 @@ int initialize_counters(int cpu_id)
|
|||
|
||||
void allocate_output_buffer()
|
||||
{
|
||||
output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
|
||||
output_buffer = calloc(1, (1 + topo.num_cpus) * 2048);
|
||||
outp = output_buffer;
|
||||
if (outp == NULL)
|
||||
err(-1, "calloc output buffer");
|
||||
|
|
|
@ -546,7 +546,7 @@ void cmdline(int argc, char **argv)
|
|||
|
||||
progname = argv[0];
|
||||
|
||||
while ((opt = getopt_long_only(argc, argv, "+a:c:dD:E:e:f:m:M:rt:u:vw",
|
||||
while ((opt = getopt_long_only(argc, argv, "+a:c:dD:E:e:f:m:M:rt:u:vw:",
|
||||
long_options, &option_index)) != -1) {
|
||||
switch (opt) {
|
||||
case 'a':
|
||||
|
@ -1260,6 +1260,15 @@ void probe_dev_msr(void)
|
|||
if (system("/sbin/modprobe msr > /dev/null 2>&1"))
|
||||
err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
|
||||
}
|
||||
|
||||
static void get_cpuid_or_exit(unsigned int leaf,
|
||||
unsigned int *eax, unsigned int *ebx,
|
||||
unsigned int *ecx, unsigned int *edx)
|
||||
{
|
||||
if (!__get_cpuid(leaf, eax, ebx, ecx, edx))
|
||||
errx(1, "Processor not supported\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* early_cpuid()
|
||||
* initialize turbo_is_enabled, has_hwp, has_epb
|
||||
|
@ -1267,15 +1276,10 @@ void probe_dev_msr(void)
|
|||
*/
|
||||
void early_cpuid(void)
|
||||
{
|
||||
unsigned int eax, ebx, ecx, edx, max_level;
|
||||
unsigned int eax, ebx, ecx, edx;
|
||||
unsigned int fms, family, model;
|
||||
|
||||
__get_cpuid(0, &max_level, &ebx, &ecx, &edx);
|
||||
|
||||
if (max_level < 6)
|
||||
errx(1, "Processor not supported\n");
|
||||
|
||||
__get_cpuid(1, &fms, &ebx, &ecx, &edx);
|
||||
get_cpuid_or_exit(1, &fms, &ebx, &ecx, &edx);
|
||||
family = (fms >> 8) & 0xf;
|
||||
model = (fms >> 4) & 0xf;
|
||||
if (family == 6 || family == 0xf)
|
||||
|
@ -1289,7 +1293,7 @@ void early_cpuid(void)
|
|||
bdx_highest_ratio = msr & 0xFF;
|
||||
}
|
||||
|
||||
__get_cpuid(0x6, &eax, &ebx, &ecx, &edx);
|
||||
get_cpuid_or_exit(0x6, &eax, &ebx, &ecx, &edx);
|
||||
turbo_is_enabled = (eax >> 1) & 1;
|
||||
has_hwp = (eax >> 7) & 1;
|
||||
has_epb = (ecx >> 3) & 1;
|
||||
|
@ -1307,7 +1311,7 @@ void parse_cpuid(void)
|
|||
|
||||
eax = ebx = ecx = edx = 0;
|
||||
|
||||
__get_cpuid(0, &max_level, &ebx, &ecx, &edx);
|
||||
get_cpuid_or_exit(0, &max_level, &ebx, &ecx, &edx);
|
||||
|
||||
if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
|
||||
genuine_intel = 1;
|
||||
|
@ -1316,7 +1320,7 @@ void parse_cpuid(void)
|
|||
fprintf(stderr, "CPUID(0): %.4s%.4s%.4s ",
|
||||
(char *)&ebx, (char *)&edx, (char *)&ecx);
|
||||
|
||||
__get_cpuid(1, &fms, &ebx, &ecx, &edx);
|
||||
get_cpuid_or_exit(1, &fms, &ebx, &ecx, &edx);
|
||||
family = (fms >> 8) & 0xf;
|
||||
model = (fms >> 4) & 0xf;
|
||||
stepping = fms & 0xf;
|
||||
|
@ -1341,7 +1345,7 @@ void parse_cpuid(void)
|
|||
errx(1, "CPUID: no MSR");
|
||||
|
||||
|
||||
__get_cpuid(0x6, &eax, &ebx, &ecx, &edx);
|
||||
get_cpuid_or_exit(0x6, &eax, &ebx, &ecx, &edx);
|
||||
/* turbo_is_enabled already set */
|
||||
/* has_hwp already set */
|
||||
has_hwp_notify = eax & (1 << 8);
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
#include <bpf/bpf.h>
|
||||
|
||||
#include "cgroup_helpers.h"
|
||||
#include "bpf_endian.h"
|
||||
#include "bpf_rlimit.h"
|
||||
#include "bpf_util.h"
|
||||
|
||||
|
@ -231,7 +232,8 @@ static struct sock_test tests[] = {
|
|||
/* if (ip == expected && port == expected) */
|
||||
BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_6,
|
||||
offsetof(struct bpf_sock, src_ip6[3])),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x01000000, 4),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7,
|
||||
__bpf_constant_ntohl(0x00000001), 4),
|
||||
BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_6,
|
||||
offsetof(struct bpf_sock, src_port)),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x2001, 2),
|
||||
|
@ -260,7 +262,8 @@ static struct sock_test tests[] = {
|
|||
/* if (ip == expected && port == expected) */
|
||||
BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_6,
|
||||
offsetof(struct bpf_sock, src_ip4)),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x0100007F, 4),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7,
|
||||
__bpf_constant_ntohl(0x7F000001), 4),
|
||||
BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_6,
|
||||
offsetof(struct bpf_sock, src_port)),
|
||||
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x1002, 2),
|
||||
|
|
|
@ -40,7 +40,7 @@ static int coalesced_mmio_in_range(struct kvm_coalesced_mmio_dev *dev,
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev)
|
||||
static int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev, u32 last)
|
||||
{
|
||||
struct kvm_coalesced_mmio_ring *ring;
|
||||
unsigned avail;
|
||||
|
@ -52,7 +52,7 @@ static int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev)
|
|||
* there is always one unused entry in the buffer
|
||||
*/
|
||||
ring = dev->kvm->coalesced_mmio_ring;
|
||||
avail = (ring->first - ring->last - 1) % KVM_COALESCED_MMIO_MAX;
|
||||
avail = (ring->first - last - 1) % KVM_COALESCED_MMIO_MAX;
|
||||
if (avail == 0) {
|
||||
/* full */
|
||||
return 0;
|
||||
|
@ -67,24 +67,27 @@ static int coalesced_mmio_write(struct kvm_vcpu *vcpu,
|
|||
{
|
||||
struct kvm_coalesced_mmio_dev *dev = to_mmio(this);
|
||||
struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring;
|
||||
__u32 insert;
|
||||
|
||||
if (!coalesced_mmio_in_range(dev, addr, len))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
spin_lock(&dev->kvm->ring_lock);
|
||||
|
||||
if (!coalesced_mmio_has_room(dev)) {
|
||||
insert = READ_ONCE(ring->last);
|
||||
if (!coalesced_mmio_has_room(dev, insert) ||
|
||||
insert >= KVM_COALESCED_MMIO_MAX) {
|
||||
spin_unlock(&dev->kvm->ring_lock);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
/* copy data in first free entry of the ring */
|
||||
|
||||
ring->coalesced_mmio[ring->last].phys_addr = addr;
|
||||
ring->coalesced_mmio[ring->last].len = len;
|
||||
memcpy(ring->coalesced_mmio[ring->last].data, val, len);
|
||||
ring->coalesced_mmio[insert].phys_addr = addr;
|
||||
ring->coalesced_mmio[insert].len = len;
|
||||
memcpy(ring->coalesced_mmio[insert].data, val, len);
|
||||
smp_wmb();
|
||||
ring->last = (ring->last + 1) % KVM_COALESCED_MMIO_MAX;
|
||||
ring->last = (insert + 1) % KVM_COALESCED_MMIO_MAX;
|
||||
spin_unlock(&dev->kvm->ring_lock);
|
||||
return 0;
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue