This is the 4.19.281 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmRBDkEACgkQONu9yGCS
aT6QQRAAuMXhQqInTov+2CjNyHlBGEIdl4F+ydPRkJdr+3ISZ/ocqxXu5ta59RJW
ohyDRW7B/kHRomHxeh/g3fkR2EhfaigKgSdohUL1e1CUJgmAYqh3wWio8MH2NZKy
MdNOB5oYKk7BPSBY01v3jLAd1B4Lz5HrvlagbQ5onasnk4+pNQKxG+TjfVPthWX+
3PZRS4t7rlVXCqPt09fbpaxG2Xr7OjelmZe3KtUFYfy0f+bZyQcvY4wn/jSZL9uy
zIHQLCUevYwndgIpswjt6dJl1JittV/977hyEdu9nS1bcqVttLLRriLqpefjciza
jHNwrWBkFl7G+KeTA7baYW9k0TOmpIr4ROjyeto6u9TEIlULvGzApAZfm57/zSt/
CzRjkL9pSF9KP1VWDC4Wyx7JRUliBYB34esPVxqXUjW+idj4RII8ZxbacdzoICXT
U+Je93RR9gQ9Lsp6ESBj3CnkjqGGWsKGZ+JUw0XXzurKqg2SCcHmIkIQ+2EFNJ4P
28FTlfnISxhvmvJnLXbecKQvL0qacWD+5Y8JidqlB9QCzGhN+T+4CRe3rjL7TKv/
INzPF8h67VCA986vafDpUXLWRwhdWjea5gXOhukUsYfKbt1k1yjKNdr3dbkNMnsh
3tfJB7xgVcvd49sMDTwCN6fpJTLbj9kgVYpZcW0sHFQyLuztDZs=
=TJcb
-----END PGP SIGNATURE-----
Merge 4.19.281 into android-4.19-stable
Changes in 4.19.281
pinctrl: Added IRQF_SHARED flag for amd-pinctrl driver
pinctrl: amd: Use irqchip template
pinctrl: amd: disable and mask interrupts on probe
pinctrl: amd: Disable and mask interrupts on resume
NFSv4: Convert struct nfs4_state to use refcount_t
NFSv4: Check the return value of update_open_stateid()
NFSv4: Fix hangs when recovering open state after a server reboot
pwm: cros-ec: Explicitly set .polarity in .get_state()
wifi: mac80211: fix invalid drv_sta_pre_rcu_remove calls for non-uploaded sta
icmp: guard against too small mtu
net: don't let netpoll invoke NAPI if in xmit context
sctp: check send stream number after wait_for_sndbuf
ipv6: Fix an uninit variable access bug in __ip6_make_skb()
gpio: davinci: Add irq chip flag to skip set wake
USB: serial: cp210x: add Silicon Labs IFS-USB-DATACABLE IDs
USB: serial: option: add Telit FE990 compositions
USB: serial: option: add Quectel RM500U-CN modem
iio: dac: cio-dac: Fix max DAC write value check for 12-bit
tty: serial: sh-sci: Fix transmit end interrupt handler
tty: serial: sh-sci: Fix Rx on RZ/G2L SCI
nilfs2: fix potential UAF of struct nilfs_sc_info in nilfs_segctor_thread()
nilfs2: fix sysfs interface lifetime
ALSA: hda/realtek: Add quirk for Clevo X370SNW
perf/core: Fix the same task check in perf_event_set_output
ftrace: Mark get_lock_parent_ip() __always_inline
ring-buffer: Fix race while reader and writer are on the same page
mm/swap: fix swap_info_struct race between swapoff and get_swap_pages()
Revert "pinctrl: amd: Disable and mask interrupts on resume"
ALSA: emu10k1: fix capture interrupt handler unlinking
ALSA: hda/sigmatel: add pin overrides for Intel DP45SG motherboard
ALSA: i2c/cs8427: fix iec958 mixer control deactivation
ALSA: hda/sigmatel: fix S/PDIF out on Intel D*45* motherboards
Bluetooth: L2CAP: Fix use-after-free in l2cap_disconnect_{req,rsp}
Bluetooth: Fix race condition in hidp_session_thread
mtdblock: tolerate corrected bit-flips
9p/xen : Fix use after free bug in xen_9pfs_front_remove due to race condition
niu: Fix missing unwind goto in niu_alloc_channels()
qlcnic: check pci_reset_function result
sctp: fix a potential overflow in sctp_ifwdtsn_skip
net: macb: fix a memory corruption in extended buffer descriptor mode
udp6: fix potential access to stale information
power: supply: cros_usbpd: reclassify "default case!" as debug
i2c: imx-lpi2c: clean rx/tx buffers upon new message
efi: sysfb_efi: Add quirk for Lenovo Yoga Book X91F/L
verify_pefile: relax wrapper length check
scsi: ses: Handle enclosure with just a primary component gracefully
x86/PCI: Add quirk for AMD XHCI controller that loses MSI-X state in D3hot
ubi: Fix failure attaching when vid_hdr offset equals to (sub)page size
mtd: ubi: wl: Fix a couple of kernel-doc issues
ubi: Fix deadlock caused by recursively holding work_sem
cgroup/cpuset: Wake up cpuset_attach_wq tasks in cpuset_cancel_attach()
watchdog: sbsa_wdog: Make sure the timeout programming is within the limits
coresight-etm4: Fix for() loop drvdata->nr_addr_cmp range bug
KVM: nVMX: add missing consistency checks for CR0 and CR4
KVM: arm64: Factor out core register ID enumeration
KVM: arm64: Filter out invalid core register IDs in KVM_GET_REG_LIST
arm64: KVM: Fix system register enumeration
Linux 4.19.281
Change-Id: I1883ac62812715a59cfcef066451a70fa7803b2e
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
0b85669846
50 changed files with 349 additions and 128 deletions
|
|
@ -691,7 +691,7 @@ ref
|
|||
no-jd
|
||||
BIOS setup but without jack-detection
|
||||
intel
|
||||
Intel DG45* mobos
|
||||
Intel D*45* mobos
|
||||
dell-m6-amic
|
||||
Dell desktops/laptops with analog mics
|
||||
dell-m6-dmic
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 280
|
||||
SUBLEVEL = 281
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
|
|
|||
|
|
@ -57,9 +57,8 @@ static u64 core_reg_offset_from_id(u64 id)
|
|||
return id & ~(KVM_REG_ARCH_MASK | KVM_REG_SIZE_MASK | KVM_REG_ARM_CORE);
|
||||
}
|
||||
|
||||
static int validate_core_offset(const struct kvm_one_reg *reg)
|
||||
static int core_reg_size_from_offset(u64 off)
|
||||
{
|
||||
u64 off = core_reg_offset_from_id(reg->id);
|
||||
int size;
|
||||
|
||||
switch (off) {
|
||||
|
|
@ -89,11 +88,24 @@ static int validate_core_offset(const struct kvm_one_reg *reg)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (KVM_REG_SIZE(reg->id) == size &&
|
||||
IS_ALIGNED(off, size / sizeof(__u32)))
|
||||
return 0;
|
||||
if (!IS_ALIGNED(off, size / sizeof(__u32)))
|
||||
return -EINVAL;
|
||||
|
||||
return -EINVAL;
|
||||
return size;
|
||||
}
|
||||
|
||||
static int validate_core_offset(const struct kvm_one_reg *reg)
|
||||
{
|
||||
u64 off = core_reg_offset_from_id(reg->id);
|
||||
int size = core_reg_size_from_offset(off);
|
||||
|
||||
if (size < 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (KVM_REG_SIZE(reg->id) != size)
|
||||
return -EINVAL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
|
||||
|
|
@ -200,9 +212,51 @@ int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int kvm_arm_copy_core_reg_indices(u64 __user *uindices)
|
||||
{
|
||||
unsigned int i;
|
||||
int n = 0;
|
||||
|
||||
for (i = 0; i < sizeof(struct kvm_regs) / sizeof(__u32); i++) {
|
||||
u64 reg = KVM_REG_ARM64 | KVM_REG_ARM_CORE | i;
|
||||
int size = core_reg_size_from_offset(i);
|
||||
|
||||
if (size < 0)
|
||||
continue;
|
||||
|
||||
switch (size) {
|
||||
case sizeof(__u32):
|
||||
reg |= KVM_REG_SIZE_U32;
|
||||
break;
|
||||
|
||||
case sizeof(__u64):
|
||||
reg |= KVM_REG_SIZE_U64;
|
||||
break;
|
||||
|
||||
case sizeof(__uint128_t):
|
||||
reg |= KVM_REG_SIZE_U128;
|
||||
break;
|
||||
|
||||
default:
|
||||
WARN_ON(1);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (uindices) {
|
||||
if (put_user(reg, uindices))
|
||||
return -EFAULT;
|
||||
uindices++;
|
||||
}
|
||||
|
||||
n++;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
static unsigned long num_core_regs(void)
|
||||
{
|
||||
return sizeof(struct kvm_regs) / sizeof(__u32);
|
||||
return kvm_arm_copy_core_reg_indices(NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -276,23 +330,20 @@ unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu)
|
|||
*/
|
||||
int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
|
||||
{
|
||||
unsigned int i;
|
||||
const u64 core_reg = KVM_REG_ARM64 | KVM_REG_SIZE_U64 | KVM_REG_ARM_CORE;
|
||||
int ret;
|
||||
|
||||
for (i = 0; i < sizeof(struct kvm_regs) / sizeof(__u32); i++) {
|
||||
if (put_user(core_reg | i, uindices))
|
||||
return -EFAULT;
|
||||
uindices++;
|
||||
}
|
||||
ret = kvm_arm_copy_core_reg_indices(uindices);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
uindices += ret;
|
||||
|
||||
ret = kvm_arm_copy_fw_reg_indices(vcpu, uindices);
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
uindices += kvm_arm_get_fw_num_regs(vcpu);
|
||||
|
||||
ret = copy_timer_indices(vcpu, uindices);
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
uindices += NUM_TIMER_REGS;
|
||||
|
||||
|
|
|
|||
|
|
@ -273,6 +273,14 @@ static const struct dmi_system_id efifb_dmi_swap_width_height[] __initconst = {
|
|||
"IdeaPad Duet 3 10IGL5"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Lenovo Yoga Book X91F / X91L */
|
||||
.matches = {
|
||||
DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
||||
/* Non exact match to match F + L versions */
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X91"),
|
||||
},
|
||||
},
|
||||
{},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -12752,7 +12752,7 @@ static int nested_vmx_check_vmcs_link_ptr(struct kvm_vcpu *vcpu,
|
|||
static int check_vmentry_postreqs(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12,
|
||||
u32 *exit_qual)
|
||||
{
|
||||
bool ia32e;
|
||||
bool ia32e = !!(vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE);
|
||||
|
||||
*exit_qual = ENTRY_FAIL_DEFAULT;
|
||||
|
||||
|
|
@ -12765,6 +12765,13 @@ static int check_vmentry_postreqs(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12,
|
|||
return 1;
|
||||
}
|
||||
|
||||
if ((vmcs12->guest_cr0 & (X86_CR0_PG | X86_CR0_PE)) == X86_CR0_PG)
|
||||
return 1;
|
||||
|
||||
if ((ia32e && !(vmcs12->guest_cr4 & X86_CR4_PAE)) ||
|
||||
(ia32e && !(vmcs12->guest_cr0 & X86_CR0_PG)))
|
||||
return 1;
|
||||
|
||||
/*
|
||||
* If the load IA32_EFER VM-entry control is 1, the following checks
|
||||
* are performed on the field for the IA32_EFER MSR:
|
||||
|
|
@ -12776,7 +12783,6 @@ static int check_vmentry_postreqs(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12,
|
|||
*/
|
||||
if (to_vmx(vcpu)->nested.nested_run_pending &&
|
||||
(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER)) {
|
||||
ia32e = (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) != 0;
|
||||
if (!kvm_valid_efer(vcpu, vmcs12->guest_ia32_efer) ||
|
||||
ia32e != !!(vmcs12->guest_ia32_efer & EFER_LMA) ||
|
||||
((vmcs12->guest_cr0 & X86_CR0_PG) &&
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#include <linux/dmi.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/vgaarb.h>
|
||||
#include <asm/amd_nb.h>
|
||||
#include <asm/hpet.h>
|
||||
#include <asm/pci_x86.h>
|
||||
|
||||
|
|
@ -824,3 +825,23 @@ static void rs690_fix_64bit_dma(struct pci_dev *pdev)
|
|||
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7910, rs690_fix_64bit_dma);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_AMD_NB
|
||||
|
||||
#define AMD_15B8_RCC_DEV2_EPF0_STRAP2 0x10136008
|
||||
#define AMD_15B8_RCC_DEV2_EPF0_STRAP2_NO_SOFT_RESET_DEV2_F0_MASK 0x00000080L
|
||||
|
||||
static void quirk_clear_strap_no_soft_reset_dev2_f0(struct pci_dev *dev)
|
||||
{
|
||||
u32 data;
|
||||
|
||||
if (!amd_smn_read(0, AMD_15B8_RCC_DEV2_EPF0_STRAP2, &data)) {
|
||||
data &= ~AMD_15B8_RCC_DEV2_EPF0_STRAP2_NO_SOFT_RESET_DEV2_F0_MASK;
|
||||
if (amd_smn_write(0, AMD_15B8_RCC_DEV2_EPF0_STRAP2, data))
|
||||
pci_err(dev, "Failed to write data 0x%x\n", data);
|
||||
} else {
|
||||
pci_err(dev, "Failed to read data\n");
|
||||
}
|
||||
}
|
||||
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, 0x15b8, quirk_clear_strap_no_soft_reset_dev2_f0);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -139,11 +139,15 @@ static int pefile_strip_sig_wrapper(const void *pebuf,
|
|||
pr_debug("sig wrapper = { %x, %x, %x }\n",
|
||||
wrapper.length, wrapper.revision, wrapper.cert_type);
|
||||
|
||||
/* Both pesign and sbsign round up the length of certificate table
|
||||
* (in optional header data directories) to 8 byte alignment.
|
||||
/* sbsign rounds up the length of certificate table (in optional
|
||||
* header data directories) to 8 byte alignment. However, the PE
|
||||
* specification states that while entries are 8-byte aligned, this is
|
||||
* not included in their length, and as a result, pesign has not
|
||||
* rounded up since 0.110.
|
||||
*/
|
||||
if (round_up(wrapper.length, 8) != ctx->sig_len) {
|
||||
pr_debug("Signature wrapper len wrong\n");
|
||||
if (wrapper.length > ctx->sig_len) {
|
||||
pr_debug("Signature wrapper bigger than sig len (%x > %x)\n",
|
||||
ctx->sig_len, wrapper.length);
|
||||
return -ELIBBAD;
|
||||
}
|
||||
if (wrapper.revision != WIN_CERT_REVISION_2_0) {
|
||||
|
|
|
|||
|
|
@ -327,7 +327,7 @@ static struct irq_chip gpio_irqchip = {
|
|||
.irq_enable = gpio_irq_enable,
|
||||
.irq_disable = gpio_irq_disable,
|
||||
.irq_set_type = gpio_irq_type,
|
||||
.flags = IRQCHIP_SET_TYPE_MASKED,
|
||||
.flags = IRQCHIP_SET_TYPE_MASKED | IRQCHIP_SKIP_SET_WAKE,
|
||||
};
|
||||
|
||||
static void gpio_irq_handler(struct irq_desc *desc)
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ static int etm4_enable_hw(struct etmv4_drvdata *drvdata)
|
|||
writel_relaxed(config->ss_pe_cmp[i],
|
||||
drvdata->base + TRCSSPCICRn(i));
|
||||
}
|
||||
for (i = 0; i < drvdata->nr_addr_cmp; i++) {
|
||||
for (i = 0; i < drvdata->nr_addr_cmp * 2; i++) {
|
||||
writeq_relaxed(config->addr_val[i],
|
||||
drvdata->base + TRCACVRn(i));
|
||||
writeq_relaxed(config->addr_acc[i],
|
||||
|
|
|
|||
|
|
@ -468,6 +468,8 @@ static int lpi2c_imx_xfer(struct i2c_adapter *adapter,
|
|||
if (num == 1 && msgs[0].len == 0)
|
||||
goto stop;
|
||||
|
||||
lpi2c_imx->rx_buf = NULL;
|
||||
lpi2c_imx->tx_buf = NULL;
|
||||
lpi2c_imx->delivered = 0;
|
||||
lpi2c_imx->msglen = msgs[i].len;
|
||||
init_completion(&lpi2c_imx->complete);
|
||||
|
|
|
|||
|
|
@ -74,8 +74,8 @@ static int cio_dac_write_raw(struct iio_dev *indio_dev,
|
|||
if (mask != IIO_CHAN_INFO_RAW)
|
||||
return -EINVAL;
|
||||
|
||||
/* DAC can only accept up to a 16-bit value */
|
||||
if ((unsigned int)val > 65535)
|
||||
/* DAC can only accept up to a 12-bit value */
|
||||
if ((unsigned int)val > 4095)
|
||||
return -EINVAL;
|
||||
|
||||
priv->chan_out_states[chan->channel] = val;
|
||||
|
|
|
|||
|
|
@ -164,7 +164,7 @@ static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
|
|||
mtdblk->cache_state = STATE_EMPTY;
|
||||
ret = mtd_read(mtd, sect_start, sect_size,
|
||||
&retlen, mtdblk->cache_data);
|
||||
if (ret)
|
||||
if (ret && !mtd_is_bitflip(ret))
|
||||
return ret;
|
||||
if (retlen != sect_size)
|
||||
return -EIO;
|
||||
|
|
@ -199,8 +199,12 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
|
|||
pr_debug("mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",
|
||||
mtd->name, pos, len);
|
||||
|
||||
if (!sect_size)
|
||||
return mtd_read(mtd, pos, len, &retlen, buf);
|
||||
if (!sect_size) {
|
||||
ret = mtd_read(mtd, pos, len, &retlen, buf);
|
||||
if (ret && !mtd_is_bitflip(ret))
|
||||
return ret;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (len > 0) {
|
||||
unsigned long sect_start = (pos/sect_size)*sect_size;
|
||||
|
|
@ -220,7 +224,7 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
|
|||
memcpy (buf, mtdblk->cache_data + offset, size);
|
||||
} else {
|
||||
ret = mtd_read(mtd, pos, size, &retlen, buf);
|
||||
if (ret)
|
||||
if (ret && !mtd_is_bitflip(ret))
|
||||
return ret;
|
||||
if (retlen != size)
|
||||
return -EIO;
|
||||
|
|
|
|||
|
|
@ -657,12 +657,6 @@ static int io_init(struct ubi_device *ubi, int max_beb_per1024)
|
|||
ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
|
||||
ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
|
||||
|
||||
if (ubi->vid_hdr_offset && ((ubi->vid_hdr_offset + UBI_VID_HDR_SIZE) >
|
||||
ubi->vid_hdr_alsize)) {
|
||||
ubi_err(ubi, "VID header offset %d too large.", ubi->vid_hdr_offset);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dbg_gen("min_io_size %d", ubi->min_io_size);
|
||||
dbg_gen("max_write_size %d", ubi->max_write_size);
|
||||
dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
|
||||
|
|
@ -680,6 +674,21 @@ static int io_init(struct ubi_device *ubi, int max_beb_per1024)
|
|||
ubi->vid_hdr_aloffset;
|
||||
}
|
||||
|
||||
/*
|
||||
* Memory allocation for VID header is ubi->vid_hdr_alsize
|
||||
* which is described in comments in io.c.
|
||||
* Make sure VID header shift + UBI_VID_HDR_SIZE not exceeds
|
||||
* ubi->vid_hdr_alsize, so that all vid header operations
|
||||
* won't access memory out of bounds.
|
||||
*/
|
||||
if ((ubi->vid_hdr_shift + UBI_VID_HDR_SIZE) > ubi->vid_hdr_alsize) {
|
||||
ubi_err(ubi, "Invalid VID header offset %d, VID header shift(%d)"
|
||||
" + VID header size(%zu) > VID header aligned size(%d).",
|
||||
ubi->vid_hdr_offset, ubi->vid_hdr_shift,
|
||||
UBI_VID_HDR_SIZE, ubi->vid_hdr_alsize);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Similar for the data offset */
|
||||
ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
|
||||
ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
|
||||
|
|
|
|||
|
|
@ -568,6 +568,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
|
|||
* @vol_id: the volume ID that last used this PEB
|
||||
* @lnum: the last used logical eraseblock number for the PEB
|
||||
* @torture: if the physical eraseblock has to be tortured
|
||||
* @nested: denotes whether the work_sem is already held
|
||||
*
|
||||
* This function returns zero in case of success and a %-ENOMEM in case of
|
||||
* failure.
|
||||
|
|
@ -1046,8 +1047,6 @@ out_unlock:
|
|||
* __erase_worker - physical eraseblock erase worker function.
|
||||
* @ubi: UBI device description object
|
||||
* @wl_wrk: the work object
|
||||
* @shutdown: non-zero if the worker has to free memory and exit
|
||||
* because the WL sub-system is shutting down
|
||||
*
|
||||
* This function erases a physical eraseblock and perform torture testing if
|
||||
* needed. It also takes care about marking the physical eraseblock bad if
|
||||
|
|
@ -1097,7 +1096,7 @@ static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk)
|
|||
int err1;
|
||||
|
||||
/* Re-schedule the LEB for erasure */
|
||||
err1 = schedule_erase(ubi, e, vol_id, lnum, 0, false);
|
||||
err1 = schedule_erase(ubi, e, vol_id, lnum, 0, true);
|
||||
if (err1) {
|
||||
spin_lock(&ubi->wl_lock);
|
||||
wl_entry_destroy(ubi, e);
|
||||
|
|
|
|||
|
|
@ -707,6 +707,10 @@ static dma_addr_t macb_get_addr(struct macb *bp, struct macb_dma_desc *desc)
|
|||
}
|
||||
#endif
|
||||
addr |= MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));
|
||||
#ifdef CONFIG_MACB_USE_HWSTAMP
|
||||
if (bp->hw_dma_cap & HW_DMA_CAP_PTP)
|
||||
addr &= ~GEM_BIT(DMA_RXVALID);
|
||||
#endif
|
||||
return addr;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -629,7 +629,13 @@ int qlcnic_fw_create_ctx(struct qlcnic_adapter *dev)
|
|||
int i, err, ring;
|
||||
|
||||
if (dev->flags & QLCNIC_NEED_FLR) {
|
||||
pci_reset_function(dev->pdev);
|
||||
err = pci_reset_function(dev->pdev);
|
||||
if (err) {
|
||||
dev_err(&dev->pdev->dev,
|
||||
"Adapter reset failed (%d). Please reboot\n",
|
||||
err);
|
||||
return err;
|
||||
}
|
||||
dev->flags &= ~QLCNIC_NEED_FLR;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4505,7 +4505,7 @@ static int niu_alloc_channels(struct niu *np)
|
|||
|
||||
err = niu_rbr_fill(np, rp, GFP_KERNEL);
|
||||
if (err)
|
||||
return err;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
tx_rings = kcalloc(num_tx_rings, sizeof(struct tx_ring_info),
|
||||
|
|
|
|||
|
|
@ -774,6 +774,34 @@ static const struct pinconf_ops amd_pinconf_ops = {
|
|||
.pin_config_group_set = amd_pinconf_group_set,
|
||||
};
|
||||
|
||||
static void amd_gpio_irq_init(struct amd_gpio *gpio_dev)
|
||||
{
|
||||
struct pinctrl_desc *desc = gpio_dev->pctrl->desc;
|
||||
unsigned long flags;
|
||||
u32 pin_reg, mask;
|
||||
int i;
|
||||
|
||||
mask = BIT(WAKE_CNTRL_OFF_S0I3) | BIT(WAKE_CNTRL_OFF_S3) |
|
||||
BIT(INTERRUPT_MASK_OFF) | BIT(INTERRUPT_ENABLE_OFF) |
|
||||
BIT(WAKE_CNTRL_OFF_S4);
|
||||
|
||||
for (i = 0; i < desc->npins; i++) {
|
||||
int pin = desc->pins[i].number;
|
||||
const struct pin_desc *pd = pin_desc_get(gpio_dev->pctrl, pin);
|
||||
|
||||
if (!pd)
|
||||
continue;
|
||||
|
||||
raw_spin_lock_irqsave(&gpio_dev->lock, flags);
|
||||
|
||||
pin_reg = readl(gpio_dev->base + i * 4);
|
||||
pin_reg &= ~mask;
|
||||
writel(pin_reg, gpio_dev->base + i * 4);
|
||||
|
||||
raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static bool amd_gpio_should_save(struct amd_gpio *gpio_dev, unsigned int pin)
|
||||
{
|
||||
|
|
@ -858,6 +886,7 @@ static int amd_gpio_probe(struct platform_device *pdev)
|
|||
int irq_base;
|
||||
struct resource *res;
|
||||
struct amd_gpio *gpio_dev;
|
||||
struct gpio_irq_chip *girq;
|
||||
|
||||
gpio_dev = devm_kzalloc(&pdev->dev,
|
||||
sizeof(struct amd_gpio), GFP_KERNEL);
|
||||
|
|
@ -921,6 +950,18 @@ static int amd_gpio_probe(struct platform_device *pdev)
|
|||
return PTR_ERR(gpio_dev->pctrl);
|
||||
}
|
||||
|
||||
/* Disable and mask interrupts */
|
||||
amd_gpio_irq_init(gpio_dev);
|
||||
|
||||
girq = &gpio_dev->gc.irq;
|
||||
girq->chip = &amd_gpio_irqchip;
|
||||
/* This will let us handle the parent IRQ in the driver */
|
||||
girq->parent_handler = NULL;
|
||||
girq->num_parents = 0;
|
||||
girq->parents = NULL;
|
||||
girq->default_type = IRQ_TYPE_NONE;
|
||||
girq->handler = handle_simple_irq;
|
||||
|
||||
ret = gpiochip_add_data(&gpio_dev->gc, gpio_dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
|
@ -932,19 +973,8 @@ static int amd_gpio_probe(struct platform_device *pdev)
|
|||
goto out2;
|
||||
}
|
||||
|
||||
ret = gpiochip_irqchip_add(&gpio_dev->gc,
|
||||
&amd_gpio_irqchip,
|
||||
0,
|
||||
handle_simple_irq,
|
||||
IRQ_TYPE_NONE);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "could not add irqchip\n");
|
||||
ret = -ENODEV;
|
||||
goto out2;
|
||||
}
|
||||
|
||||
ret = devm_request_irq(&pdev->dev, irq_base, amd_gpio_irq_handler, 0,
|
||||
KBUILD_MODNAME, gpio_dev);
|
||||
ret = devm_request_irq(&pdev->dev, irq_base, amd_gpio_irq_handler,
|
||||
IRQF_SHARED, KBUILD_MODNAME, gpio_dev);
|
||||
if (ret)
|
||||
goto out2;
|
||||
|
||||
|
|
|
|||
|
|
@ -242,7 +242,7 @@ static int cros_usbpd_charger_get_power_info(struct port_data *port)
|
|||
port->psy_current_max = 0;
|
||||
break;
|
||||
default:
|
||||
dev_err(dev, "Port %d: default case!\n", port->port_number);
|
||||
dev_dbg(dev, "Port %d: default case!\n", port->port_number);
|
||||
port->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -125,6 +125,7 @@ static void cros_ec_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
|
|||
|
||||
state->enabled = (ret > 0);
|
||||
state->period = EC_PWM_MAX_DUTY;
|
||||
state->polarity = PWM_POLARITY_NORMAL;
|
||||
|
||||
/* Note that "disabled" and "duty cycle == 0" are treated the same */
|
||||
state->duty_cycle = ret;
|
||||
|
|
|
|||
|
|
@ -519,9 +519,6 @@ static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
|
|||
int i;
|
||||
struct ses_component *scomp;
|
||||
|
||||
if (!edev->component[0].scratch)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < edev->components; i++) {
|
||||
scomp = edev->component[i].scratch;
|
||||
if (scomp->addr != efd->addr)
|
||||
|
|
@ -612,8 +609,10 @@ static void ses_enclosure_data_process(struct enclosure_device *edev,
|
|||
components++,
|
||||
type_ptr[0],
|
||||
name);
|
||||
else
|
||||
else if (components < edev->components)
|
||||
ecomp = &edev->component[components++];
|
||||
else
|
||||
ecomp = ERR_PTR(-EINVAL);
|
||||
|
||||
if (!IS_ERR(ecomp)) {
|
||||
if (addl_desc_ptr) {
|
||||
|
|
@ -744,11 +743,6 @@ static int ses_intf_add(struct device *cdev,
|
|||
components += type_ptr[1];
|
||||
}
|
||||
|
||||
if (components == 0) {
|
||||
sdev_printk(KERN_WARNING, sdev, "enclosure has no enumerated components\n");
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
ses_dev->page1 = buf;
|
||||
ses_dev->page1_len = len;
|
||||
buf = NULL;
|
||||
|
|
@ -790,9 +784,11 @@ static int ses_intf_add(struct device *cdev,
|
|||
buf = NULL;
|
||||
}
|
||||
page2_not_supported:
|
||||
scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
|
||||
if (!scomp)
|
||||
goto err_free;
|
||||
if (components > 0) {
|
||||
scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
|
||||
if (!scomp)
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
|
||||
components, &ses_enclosure_callbacks);
|
||||
|
|
|
|||
|
|
@ -2908,6 +2908,13 @@ static int sci_init_single(struct platform_device *dev,
|
|||
for (i = 0; i < ARRAY_SIZE(sci_port->irqs); ++i)
|
||||
sci_port->irqs[i] = platform_get_irq(dev, i);
|
||||
|
||||
/*
|
||||
* The fourth interrupt on SCI port is transmit end interrupt, so
|
||||
* shuffle the interrupts.
|
||||
*/
|
||||
if (p->type == PORT_SCI)
|
||||
swap(sci_port->irqs[SCIx_BRI_IRQ], sci_port->irqs[SCIx_TEI_IRQ]);
|
||||
|
||||
/* The SCI generates several interrupts. They can be muxed together or
|
||||
* connected to different interrupt lines. In the muxed case only one
|
||||
* interrupt resource is specified as there is only one interrupt ID.
|
||||
|
|
@ -2973,7 +2980,7 @@ static int sci_init_single(struct platform_device *dev,
|
|||
port->flags = UPF_FIXED_PORT | UPF_BOOT_AUTOCONF | p->flags;
|
||||
port->fifosize = sci_port->params->fifosize;
|
||||
|
||||
if (port->type == PORT_SCI) {
|
||||
if (port->type == PORT_SCI && !dev->dev.of_node) {
|
||||
if (sci_port->reg_size >= 0x20)
|
||||
port->regshift = 2;
|
||||
else
|
||||
|
|
|
|||
|
|
@ -121,6 +121,7 @@ static const struct usb_device_id id_table[] = {
|
|||
{ USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
|
||||
{ USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */
|
||||
{ USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
|
||||
{ USB_DEVICE(0x10C4, 0x82AA) }, /* Silicon Labs IFS-USB-DATACABLE used with Quint UPS */
|
||||
{ USB_DEVICE(0x10C4, 0x82EF) }, /* CESINEL FALCO 6105 AC Power Supply */
|
||||
{ USB_DEVICE(0x10C4, 0x82F1) }, /* CESINEL MEDCAL EFD Earth Fault Detector */
|
||||
{ USB_DEVICE(0x10C4, 0x82F2) }, /* CESINEL MEDCAL ST Network Analyzer */
|
||||
|
|
|
|||
|
|
@ -1198,6 +1198,8 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM520N, 0xff, 0xff, 0x30) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM520N, 0xff, 0, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM520N, 0xff, 0, 0) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, 0x0900, 0xff, 0, 0), /* RM500U-CN */
|
||||
.driver_info = ZLP },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC200U, 0xff, 0, 0) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC200S_CN, 0xff, 0, 0) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC200T, 0xff, 0, 0) },
|
||||
|
|
@ -1300,6 +1302,14 @@ static const struct usb_device_id option_ids[] = {
|
|||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1075, 0xff), /* Telit FN990 (PCIe) */
|
||||
.driver_info = RSVD(0) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1080, 0xff), /* Telit FE990 (rmnet) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1081, 0xff), /* Telit FE990 (MBIM) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1082, 0xff), /* Telit FE990 (RNDIS) */
|
||||
.driver_info = NCTRL(2) | RSVD(3) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1083, 0xff), /* Telit FE990 (ECM) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910),
|
||||
.driver_info = NCTRL(0) | RSVD(1) | RSVD(3) },
|
||||
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910_DUAL_MODEM),
|
||||
|
|
|
|||
|
|
@ -130,6 +130,7 @@ static int sbsa_gwdt_set_timeout(struct watchdog_device *wdd,
|
|||
struct sbsa_gwdt *gwdt = watchdog_get_drvdata(wdd);
|
||||
|
||||
wdd->timeout = timeout;
|
||||
timeout = clamp_t(unsigned int, timeout, 1, wdd->max_hw_heartbeat_ms / 1000);
|
||||
|
||||
if (action)
|
||||
writel(gwdt->clk * timeout,
|
||||
|
|
|
|||
|
|
@ -190,7 +190,7 @@ struct nfs4_state {
|
|||
unsigned int n_wronly; /* Number of write-only references */
|
||||
unsigned int n_rdwr; /* Number of read/write references */
|
||||
fmode_t state; /* State on the server (R,W, or RW) */
|
||||
atomic_t count;
|
||||
refcount_t count;
|
||||
|
||||
wait_queue_head_t waitq;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1792,7 +1792,7 @@ static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
|
|||
out:
|
||||
return ERR_PTR(ret);
|
||||
out_return_state:
|
||||
atomic_inc(&state->count);
|
||||
refcount_inc(&state->count);
|
||||
return state;
|
||||
}
|
||||
|
||||
|
|
@ -1851,8 +1851,7 @@ _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
|
|||
if (!data->rpc_done) {
|
||||
if (data->rpc_status)
|
||||
return ERR_PTR(data->rpc_status);
|
||||
/* cached opens have already been processed */
|
||||
goto update;
|
||||
return nfs4_try_open_cached(data);
|
||||
}
|
||||
|
||||
ret = nfs_refresh_inode(inode, &data->f_attr);
|
||||
|
|
@ -1861,10 +1860,11 @@ _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
|
|||
|
||||
if (data->o_res.delegation_type != 0)
|
||||
nfs4_opendata_check_deleg(data, state);
|
||||
update:
|
||||
update_open_stateid(state, &data->o_res.stateid, NULL,
|
||||
data->o_arg.fmode);
|
||||
atomic_inc(&state->count);
|
||||
|
||||
if (!update_open_stateid(state, &data->o_res.stateid,
|
||||
NULL, data->o_arg.fmode))
|
||||
return ERR_PTR(-EAGAIN);
|
||||
refcount_inc(&state->count);
|
||||
|
||||
return state;
|
||||
}
|
||||
|
|
@ -1902,7 +1902,7 @@ nfs4_opendata_find_nfs4_state(struct nfs4_opendata *data)
|
|||
return ERR_CAST(inode);
|
||||
if (data->state != NULL && data->state->inode == inode) {
|
||||
state = data->state;
|
||||
atomic_inc(&state->count);
|
||||
refcount_inc(&state->count);
|
||||
} else
|
||||
state = nfs4_get_open_state(inode, data->owner);
|
||||
iput(inode);
|
||||
|
|
@ -1928,8 +1928,11 @@ _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
|
|||
|
||||
if (data->o_res.delegation_type != 0)
|
||||
nfs4_opendata_check_deleg(data, state);
|
||||
update_open_stateid(state, &data->o_res.stateid, NULL,
|
||||
data->o_arg.fmode);
|
||||
if (!update_open_stateid(state, &data->o_res.stateid,
|
||||
NULL, data->o_arg.fmode)) {
|
||||
nfs4_put_open_state(state);
|
||||
state = ERR_PTR(-EAGAIN);
|
||||
}
|
||||
out:
|
||||
nfs_release_seqid(data->o_arg.seqid);
|
||||
return state;
|
||||
|
|
@ -1975,7 +1978,7 @@ static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context
|
|||
if (opendata == NULL)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
opendata->state = state;
|
||||
atomic_inc(&state->count);
|
||||
refcount_inc(&state->count);
|
||||
return opendata;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -675,7 +675,7 @@ nfs4_alloc_open_state(void)
|
|||
state = kzalloc(sizeof(*state), GFP_NOFS);
|
||||
if (!state)
|
||||
return NULL;
|
||||
atomic_set(&state->count, 1);
|
||||
refcount_set(&state->count, 1);
|
||||
INIT_LIST_HEAD(&state->lock_states);
|
||||
spin_lock_init(&state->state_lock);
|
||||
seqlock_init(&state->seqlock);
|
||||
|
|
@ -709,7 +709,7 @@ __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
|
|||
continue;
|
||||
if (!nfs4_valid_open_stateid(state))
|
||||
continue;
|
||||
if (atomic_inc_not_zero(&state->count))
|
||||
if (refcount_inc_not_zero(&state->count))
|
||||
return state;
|
||||
}
|
||||
return NULL;
|
||||
|
|
@ -763,7 +763,7 @@ void nfs4_put_open_state(struct nfs4_state *state)
|
|||
struct inode *inode = state->inode;
|
||||
struct nfs4_state_owner *owner = state->owner;
|
||||
|
||||
if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
|
||||
if (!refcount_dec_and_lock(&state->count, &owner->so_lock))
|
||||
return;
|
||||
spin_lock(&inode->i_lock);
|
||||
list_del(&state->inode_states);
|
||||
|
|
@ -1596,7 +1596,7 @@ restart:
|
|||
continue;
|
||||
if (state->state == 0)
|
||||
continue;
|
||||
atomic_inc(&state->count);
|
||||
refcount_inc(&state->count);
|
||||
spin_unlock(&sp->so_lock);
|
||||
status = ops->recover_open(sp, state);
|
||||
if (status >= 0) {
|
||||
|
|
|
|||
|
|
@ -2609,11 +2609,10 @@ static int nilfs_segctor_thread(void *arg)
|
|||
goto loop;
|
||||
|
||||
end_thread:
|
||||
spin_unlock(&sci->sc_state_lock);
|
||||
|
||||
/* end sync. */
|
||||
sci->sc_task = NULL;
|
||||
wake_up(&sci->sc_wait_task); /* for nilfs_segctor_kill_thread() */
|
||||
spin_unlock(&sci->sc_state_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -484,6 +484,7 @@ static void nilfs_put_super(struct super_block *sb)
|
|||
up_write(&nilfs->ns_sem);
|
||||
}
|
||||
|
||||
nilfs_sysfs_delete_device_group(nilfs);
|
||||
iput(nilfs->ns_sufile);
|
||||
iput(nilfs->ns_cpfile);
|
||||
iput(nilfs->ns_dat);
|
||||
|
|
@ -1110,6 +1111,7 @@ nilfs_fill_super(struct super_block *sb, void *data, int silent)
|
|||
nilfs_put_root(fsroot);
|
||||
|
||||
failed_unload:
|
||||
nilfs_sysfs_delete_device_group(nilfs);
|
||||
iput(nilfs->ns_sufile);
|
||||
iput(nilfs->ns_cpfile);
|
||||
iput(nilfs->ns_dat);
|
||||
|
|
|
|||
|
|
@ -87,7 +87,6 @@ void destroy_nilfs(struct the_nilfs *nilfs)
|
|||
{
|
||||
might_sleep();
|
||||
if (nilfs_init(nilfs)) {
|
||||
nilfs_sysfs_delete_device_group(nilfs);
|
||||
brelse(nilfs->ns_sbh[0]);
|
||||
brelse(nilfs->ns_sbh[1]);
|
||||
}
|
||||
|
|
@ -275,6 +274,10 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
|
|||
goto failed;
|
||||
}
|
||||
|
||||
err = nilfs_sysfs_create_device_group(sb);
|
||||
if (unlikely(err))
|
||||
goto sysfs_error;
|
||||
|
||||
if (valid_fs)
|
||||
goto skip_recovery;
|
||||
|
||||
|
|
@ -336,6 +339,9 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
|
|||
goto failed;
|
||||
|
||||
failed_unload:
|
||||
nilfs_sysfs_delete_device_group(nilfs);
|
||||
|
||||
sysfs_error:
|
||||
iput(nilfs->ns_cpfile);
|
||||
iput(nilfs->ns_sufile);
|
||||
iput(nilfs->ns_dat);
|
||||
|
|
@ -668,10 +674,6 @@ int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data)
|
|||
if (err)
|
||||
goto failed_sbh;
|
||||
|
||||
err = nilfs_sysfs_create_device_group(sb);
|
||||
if (err)
|
||||
goto failed_sbh;
|
||||
|
||||
set_nilfs_init(nilfs);
|
||||
err = 0;
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -697,7 +697,7 @@ static inline void __ftrace_enabled_restore(int enabled)
|
|||
#define CALLER_ADDR5 ((unsigned long)ftrace_return_address(5))
|
||||
#define CALLER_ADDR6 ((unsigned long)ftrace_return_address(6))
|
||||
|
||||
static inline unsigned long get_lock_parent_ip(void)
|
||||
static __always_inline unsigned long get_lock_parent_ip(void)
|
||||
{
|
||||
unsigned long addr = CALLER_ADDR0;
|
||||
|
||||
|
|
|
|||
|
|
@ -1514,7 +1514,9 @@ static void cpuset_cancel_attach(struct cgroup_taskset *tset)
|
|||
cs = css_cs(css);
|
||||
|
||||
mutex_lock(&cpuset_mutex);
|
||||
css_cs(css)->attach_in_progress--;
|
||||
cs->attach_in_progress--;
|
||||
if (!cs->attach_in_progress)
|
||||
wake_up(&cpuset_attach_wq);
|
||||
mutex_unlock(&cpuset_mutex);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10407,7 +10407,7 @@ perf_event_set_output(struct perf_event *event, struct perf_event *output_event)
|
|||
/*
|
||||
* If its not a per-cpu rb, it must be the same task.
|
||||
*/
|
||||
if (output_event->cpu == -1 && output_event->ctx != event->ctx)
|
||||
if (output_event->cpu == -1 && output_event->hw.target != event->hw.target)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -2463,6 +2463,10 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
|
|||
if (RB_WARN_ON(cpu_buffer,
|
||||
rb_is_reader_page(cpu_buffer->tail_page)))
|
||||
return;
|
||||
/*
|
||||
* No need for a memory barrier here, as the update
|
||||
* of the tail_page did it for this page.
|
||||
*/
|
||||
local_set(&cpu_buffer->commit_page->page->commit,
|
||||
rb_page_write(cpu_buffer->commit_page));
|
||||
rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
|
||||
|
|
@ -2476,6 +2480,8 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
|
|||
while (rb_commit_index(cpu_buffer) !=
|
||||
rb_page_write(cpu_buffer->commit_page)) {
|
||||
|
||||
/* Make sure the readers see the content of what is committed. */
|
||||
smp_wmb();
|
||||
local_set(&cpu_buffer->commit_page->page->commit,
|
||||
rb_page_write(cpu_buffer->commit_page));
|
||||
RB_WARN_ON(cpu_buffer,
|
||||
|
|
@ -3841,7 +3847,12 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
|
|||
|
||||
/*
|
||||
* Make sure we see any padding after the write update
|
||||
* (see rb_reset_tail())
|
||||
* (see rb_reset_tail()).
|
||||
*
|
||||
* In addition, a writer may be writing on the reader page
|
||||
* if the page has not been fully filled, so the read barrier
|
||||
* is also needed to make sure we see the content of what is
|
||||
* committed by the writer (see rb_set_commit_to_write()).
|
||||
*/
|
||||
smp_rmb();
|
||||
|
||||
|
|
|
|||
|
|
@ -620,6 +620,7 @@ static void __del_from_avail_list(struct swap_info_struct *p)
|
|||
{
|
||||
int nid;
|
||||
|
||||
assert_spin_locked(&p->lock);
|
||||
for_each_node(nid)
|
||||
plist_del(&p->avail_lists[nid], &swap_avail_heads[nid]);
|
||||
}
|
||||
|
|
@ -2575,8 +2576,8 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
|
|||
spin_unlock(&swap_lock);
|
||||
goto out_dput;
|
||||
}
|
||||
del_from_avail_list(p);
|
||||
spin_lock(&p->lock);
|
||||
del_from_avail_list(p);
|
||||
if (p->prio < 0) {
|
||||
struct swap_info_struct *si = p;
|
||||
int nid;
|
||||
|
|
|
|||
|
|
@ -299,6 +299,10 @@ static void xen_9pfs_front_free(struct xen_9pfs_front_priv *priv)
|
|||
write_unlock(&xen_9pfs_lock);
|
||||
|
||||
for (i = 0; i < priv->num_rings; i++) {
|
||||
struct xen_9pfs_dataring *ring = &priv->rings[i];
|
||||
|
||||
cancel_work_sync(&ring->work);
|
||||
|
||||
if (!priv->rings[i].intf)
|
||||
break;
|
||||
if (priv->rings[i].irq > 0)
|
||||
|
|
|
|||
|
|
@ -428,7 +428,7 @@ static void hidp_set_timer(struct hidp_session *session)
|
|||
static void hidp_del_timer(struct hidp_session *session)
|
||||
{
|
||||
if (session->idle_to > 0)
|
||||
del_timer(&session->timer);
|
||||
del_timer_sync(&session->timer);
|
||||
}
|
||||
|
||||
static void hidp_process_report(struct hidp_session *session, int type,
|
||||
|
|
|
|||
|
|
@ -4350,33 +4350,27 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn,
|
|||
|
||||
BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
|
||||
|
||||
mutex_lock(&conn->chan_lock);
|
||||
|
||||
chan = __l2cap_get_chan_by_scid(conn, dcid);
|
||||
chan = l2cap_get_chan_by_scid(conn, dcid);
|
||||
if (!chan) {
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
cmd_reject_invalid_cid(conn, cmd->ident, dcid, scid);
|
||||
return 0;
|
||||
}
|
||||
|
||||
l2cap_chan_hold(chan);
|
||||
l2cap_chan_lock(chan);
|
||||
|
||||
rsp.dcid = cpu_to_le16(chan->scid);
|
||||
rsp.scid = cpu_to_le16(chan->dcid);
|
||||
l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
|
||||
|
||||
chan->ops->set_shutdown(chan);
|
||||
|
||||
mutex_lock(&conn->chan_lock);
|
||||
l2cap_chan_del(chan, ECONNRESET);
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
|
||||
chan->ops->close(chan);
|
||||
|
||||
l2cap_chan_unlock(chan);
|
||||
l2cap_chan_put(chan);
|
||||
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -4396,33 +4390,27 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn,
|
|||
|
||||
BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
|
||||
|
||||
mutex_lock(&conn->chan_lock);
|
||||
|
||||
chan = __l2cap_get_chan_by_scid(conn, scid);
|
||||
chan = l2cap_get_chan_by_scid(conn, scid);
|
||||
if (!chan) {
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
l2cap_chan_hold(chan);
|
||||
l2cap_chan_lock(chan);
|
||||
|
||||
if (chan->state != BT_DISCONN) {
|
||||
l2cap_chan_unlock(chan);
|
||||
l2cap_chan_put(chan);
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
mutex_lock(&conn->chan_lock);
|
||||
l2cap_chan_del(chan, 0);
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
|
||||
chan->ops->close(chan);
|
||||
|
||||
l2cap_chan_unlock(chan);
|
||||
l2cap_chan_put(chan);
|
||||
|
||||
mutex_unlock(&conn->chan_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,20 @@ static void queue_process(struct work_struct *work)
|
|||
}
|
||||
}
|
||||
|
||||
static int netif_local_xmit_active(struct net_device *dev)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < dev->num_tx_queues; i++) {
|
||||
struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
|
||||
|
||||
if (READ_ONCE(txq->xmit_lock_owner) == smp_processor_id())
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void poll_one_napi(struct napi_struct *napi)
|
||||
{
|
||||
int work;
|
||||
|
|
@ -182,7 +196,10 @@ void netpoll_poll_dev(struct net_device *dev)
|
|||
if (!ni || down_trylock(&ni->dev_lock))
|
||||
return;
|
||||
|
||||
if (!netif_running(dev)) {
|
||||
/* Some drivers will take the same locks in poll and xmit,
|
||||
* we can't poll if local CPU is already in xmit.
|
||||
*/
|
||||
if (!netif_running(dev) || netif_local_xmit_active(dev)) {
|
||||
up(&ni->dev_lock);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -759,6 +759,11 @@ void __icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info,
|
|||
room = 576;
|
||||
room -= sizeof(struct iphdr) + icmp_param.replyopts.opt.opt.optlen;
|
||||
room -= sizeof(struct icmphdr);
|
||||
/* Guard against tiny mtu. We need to include at least one
|
||||
* IP network header for this message to make any sense.
|
||||
*/
|
||||
if (room <= (int)sizeof(struct iphdr))
|
||||
goto ende;
|
||||
|
||||
icmp_param.data_len = skb_in->len - icmp_param.offset;
|
||||
if (icmp_param.data_len > room)
|
||||
|
|
|
|||
|
|
@ -1730,8 +1730,13 @@ struct sk_buff *__ip6_make_skb(struct sock *sk,
|
|||
IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
|
||||
if (proto == IPPROTO_ICMPV6) {
|
||||
struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
|
||||
u8 icmp6_type;
|
||||
|
||||
ICMP6MSGOUT_INC_STATS(net, idev, icmp6_hdr(skb)->icmp6_type);
|
||||
if (sk->sk_socket->type == SOCK_RAW && !inet_sk(sk)->hdrincl)
|
||||
icmp6_type = fl6->fl6_icmp_type;
|
||||
else
|
||||
icmp6_type = icmp6_hdr(skb)->icmp6_type;
|
||||
ICMP6MSGOUT_INC_STATS(net, idev, icmp6_type);
|
||||
ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1219,9 +1219,11 @@ int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
|
|||
msg->msg_name = &sin;
|
||||
msg->msg_namelen = sizeof(sin);
|
||||
do_udp_sendmsg:
|
||||
if (__ipv6_only_sock(sk))
|
||||
return -ENETUNREACH;
|
||||
return udp_sendmsg(sk, msg, len);
|
||||
err = __ipv6_only_sock(sk) ?
|
||||
-ENETUNREACH : udp_sendmsg(sk, msg, len);
|
||||
msg->msg_name = sin6;
|
||||
msg->msg_namelen = addr_len;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -969,7 +969,8 @@ static int __must_check __sta_info_destroy_part1(struct sta_info *sta)
|
|||
list_del_rcu(&sta->list);
|
||||
sta->removed = true;
|
||||
|
||||
drv_sta_pre_rcu_remove(local, sta->sdata, sta);
|
||||
if (sta->uploaded)
|
||||
drv_sta_pre_rcu_remove(local, sta->sdata, sta);
|
||||
|
||||
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
|
||||
rcu_access_pointer(sdata->u.vlan.sta) == sta)
|
||||
|
|
|
|||
|
|
@ -1953,6 +1953,10 @@ static int sctp_sendmsg_to_asoc(struct sctp_association *asoc,
|
|||
err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
|
||||
if (err)
|
||||
goto err;
|
||||
if (unlikely(sinfo->sinfo_stream >= asoc->stream.outcnt)) {
|
||||
err = -EINVAL;
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
if (sctp_state(asoc, CLOSED)) {
|
||||
|
|
|
|||
|
|
@ -1151,7 +1151,8 @@ static void sctp_generate_iftsn(struct sctp_outq *q, __u32 ctsn)
|
|||
|
||||
#define _sctp_walk_ifwdtsn(pos, chunk, end) \
|
||||
for (pos = chunk->subh.ifwdtsn_hdr->skip; \
|
||||
(void *)pos < (void *)chunk->subh.ifwdtsn_hdr->skip + (end); pos++)
|
||||
(void *)pos <= (void *)chunk->subh.ifwdtsn_hdr->skip + (end) - \
|
||||
sizeof(struct sctp_ifwdtsn_skip); pos++)
|
||||
|
||||
#define sctp_walk_ifwdtsn(pos, ch) \
|
||||
_sctp_walk_ifwdtsn((pos), (ch), ntohs((ch)->chunk_hdr->length) - \
|
||||
|
|
|
|||
|
|
@ -568,10 +568,13 @@ int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active)
|
|||
if (snd_BUG_ON(!cs8427))
|
||||
return -ENXIO;
|
||||
chip = cs8427->private_data;
|
||||
if (active)
|
||||
if (active) {
|
||||
memcpy(chip->playback.pcm_status,
|
||||
chip->playback.def_status, 24);
|
||||
chip->playback.pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
|
||||
chip->playback.pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
|
||||
} else {
|
||||
chip->playback.pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
|
||||
}
|
||||
snd_ctl_notify(cs8427->bus->card,
|
||||
SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
|
||||
&chip->playback.pcm_ctl->id);
|
||||
|
|
|
|||
|
|
@ -1258,7 +1258,7 @@ static int snd_emu10k1_capture_mic_close(struct snd_pcm_substream *substream)
|
|||
{
|
||||
struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
|
||||
|
||||
emu->capture_interrupt = NULL;
|
||||
emu->capture_mic_interrupt = NULL;
|
||||
emu->pcm_capture_mic_substream = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1366,7 +1366,7 @@ static int snd_emu10k1_capture_efx_close(struct snd_pcm_substream *substream)
|
|||
{
|
||||
struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
|
||||
|
||||
emu->capture_interrupt = NULL;
|
||||
emu->capture_efx_interrupt = NULL;
|
||||
emu->pcm_capture_efx_substream = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2556,6 +2556,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = {
|
|||
SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
|
||||
SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
|
||||
SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
|
||||
SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
|
||||
SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
|
||||
SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
|
||||
SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
|
||||
|
|
|
|||
|
|
@ -1723,6 +1723,7 @@ static const struct snd_pci_quirk stac925x_fixup_tbl[] = {
|
|||
};
|
||||
|
||||
static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
|
||||
// Port A-H
|
||||
{ 0x0a, 0x02214030 },
|
||||
{ 0x0b, 0x02a19040 },
|
||||
{ 0x0c, 0x01a19020 },
|
||||
|
|
@ -1731,9 +1732,12 @@ static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
|
|||
{ 0x0f, 0x01014010 },
|
||||
{ 0x10, 0x01014020 },
|
||||
{ 0x11, 0x01014030 },
|
||||
// CD in
|
||||
{ 0x12, 0x02319040 },
|
||||
// Digial Mic ins
|
||||
{ 0x13, 0x90a000f0 },
|
||||
{ 0x14, 0x90a000f0 },
|
||||
// Digital outs
|
||||
{ 0x22, 0x01452050 },
|
||||
{ 0x23, 0x01452050 },
|
||||
{}
|
||||
|
|
@ -1774,6 +1778,7 @@ static const struct hda_pintbl alienware_m17x_pin_configs[] = {
|
|||
};
|
||||
|
||||
static const struct hda_pintbl intel_dg45id_pin_configs[] = {
|
||||
// Analog outputs
|
||||
{ 0x0a, 0x02214230 },
|
||||
{ 0x0b, 0x02A19240 },
|
||||
{ 0x0c, 0x01013214 },
|
||||
|
|
@ -1781,6 +1786,9 @@ static const struct hda_pintbl intel_dg45id_pin_configs[] = {
|
|||
{ 0x0e, 0x01A19250 },
|
||||
{ 0x0f, 0x01011212 },
|
||||
{ 0x10, 0x01016211 },
|
||||
// Digital output
|
||||
{ 0x22, 0x01451380 },
|
||||
{ 0x23, 0x40f000f0 },
|
||||
{}
|
||||
};
|
||||
|
||||
|
|
@ -1971,6 +1979,8 @@ static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
|
|||
"DFI LanParty", STAC_92HD73XX_REF),
|
||||
SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
|
||||
"DFI LanParty", STAC_92HD73XX_REF),
|
||||
SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5001,
|
||||
"Intel DP45SG", STAC_92HD73XX_INTEL),
|
||||
SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
|
||||
"Intel DG45ID", STAC_92HD73XX_INTEL),
|
||||
SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
|
||||
|
|
|
|||
Loading…
Reference in a new issue