commit: bb6bcd3f28d96ebb52cf4915c8a2a793218fdc3b Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Jan 6 14:15:28 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Jan 6 14:15:28 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=bb6bcd3f
Linux patch 4.19.165 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1164_linux-4.19.165.patch | 1169 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1173 insertions(+) diff --git a/0000_README b/0000_README index 5ffa36c..8c285e2 100644 --- a/0000_README +++ b/0000_README @@ -695,6 +695,10 @@ Patch: 1163_linux-4.19.164.patch From: https://www.kernel.org Desc: Linux 4.19.164 +Patch: 1164_linux-4.19.165.patch +From: https://www.kernel.org +Desc: Linux 4.19.165 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1164_linux-4.19.165.patch b/1164_linux-4.19.165.patch new file mode 100644 index 0000000..b530c04 --- /dev/null +++ b/1164_linux-4.19.165.patch @@ -0,0 +1,1169 @@ +diff --git a/Makefile b/Makefile +index d02af6881a5fe..e636c21432951 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 164 ++SUBLEVEL = 165 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/powerpc/include/asm/bitops.h b/arch/powerpc/include/asm/bitops.h +index ff71566dadee5..76db1c5000bd6 100644 +--- a/arch/powerpc/include/asm/bitops.h ++++ b/arch/powerpc/include/asm/bitops.h +@@ -221,15 +221,34 @@ static __inline__ void __clear_bit_unlock(int nr, volatile unsigned long *addr) + */ + static __inline__ int fls(unsigned int x) + { +- return 32 - __builtin_clz(x); ++ int lz; ++ ++ if (__builtin_constant_p(x)) ++ return x ? 32 - __builtin_clz(x) : 0; ++ asm("cntlzw %0,%1" : "=r" (lz) : "r" (x)); ++ return 32 - lz; + } + + #include <asm-generic/bitops/builtin-__fls.h> + ++/* ++ * 64-bit can do this using one cntlzd (count leading zeroes doubleword) ++ * instruction; for 32-bit we use the generic version, which does two ++ * 32-bit fls calls. ++ */ ++#ifdef CONFIG_PPC64 + static __inline__ int fls64(__u64 x) + { +- return 64 - __builtin_clzll(x); ++ int lz; ++ ++ if (__builtin_constant_p(x)) ++ return x ? 64 - __builtin_clzll(x) : 0; ++ asm("cntlzd %0,%1" : "=r" (lz) : "r" (x)); ++ return 64 - lz; + } ++#else ++#include <asm-generic/bitops/fls64.h> ++#endif + + #ifdef CONFIG_PPC64 + unsigned int __arch_hweight8(unsigned int w); +diff --git a/arch/powerpc/sysdev/mpic_msgr.c b/arch/powerpc/sysdev/mpic_msgr.c +index 280e964e1aa88..497e86cfb12e0 100644 +--- a/arch/powerpc/sysdev/mpic_msgr.c ++++ b/arch/powerpc/sysdev/mpic_msgr.c +@@ -196,7 +196,7 @@ static int mpic_msgr_probe(struct platform_device *dev) + + /* IO map the message register block. */ + of_address_to_resource(np, 0, &rsrc); +- msgr_block_addr = ioremap(rsrc.start, resource_size(&rsrc)); ++ msgr_block_addr = devm_ioremap(&dev->dev, rsrc.start, resource_size(&rsrc)); + if (!msgr_block_addr) { + dev_err(&dev->dev, "Failed to iomap MPIC message registers"); + return -EFAULT; +diff --git a/arch/x86/kvm/cpuid.h b/arch/x86/kvm/cpuid.h +index d78a61408243f..7dec43b2c4205 100644 +--- a/arch/x86/kvm/cpuid.h ++++ b/arch/x86/kvm/cpuid.h +@@ -154,6 +154,20 @@ static inline int guest_cpuid_stepping(struct kvm_vcpu *vcpu) + return x86_stepping(best->eax); + } + ++static inline bool guest_has_spec_ctrl_msr(struct kvm_vcpu *vcpu) ++{ ++ return (guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL) || ++ guest_cpuid_has(vcpu, X86_FEATURE_AMD_STIBP) || ++ guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBRS) || ++ guest_cpuid_has(vcpu, X86_FEATURE_AMD_SSBD)); ++} ++ ++static inline bool guest_has_pred_cmd_msr(struct kvm_vcpu *vcpu) ++{ ++ return (guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL) || ++ guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBPB)); ++} ++ + static inline bool supports_cpuid_fault(struct kvm_vcpu *vcpu) + { + return vcpu->arch.msr_platform_info & MSR_PLATFORM_INFO_CPUID_FAULT; +diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c +index a0c3d1b4b295b..d2dc734f5bd0d 100644 +--- a/arch/x86/kvm/svm.c ++++ b/arch/x86/kvm/svm.c +@@ -4209,8 +4209,7 @@ static int svm_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + break; + case MSR_IA32_SPEC_CTRL: + if (!msr_info->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBRS) && +- !guest_cpuid_has(vcpu, X86_FEATURE_AMD_SSBD)) ++ !guest_has_spec_ctrl_msr(vcpu)) + return 1; + + msr_info->data = svm->spec_ctrl; +@@ -4312,8 +4311,7 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) + break; + case MSR_IA32_SPEC_CTRL: + if (!msr->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBRS) && +- !guest_cpuid_has(vcpu, X86_FEATURE_AMD_SSBD)) ++ !guest_has_spec_ctrl_msr(vcpu)) + return 1; + + /* The STIBP bit doesn't fault even if it's not advertised */ +@@ -4340,12 +4338,11 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) + break; + case MSR_IA32_PRED_CMD: + if (!msr->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBPB)) ++ !guest_has_pred_cmd_msr(vcpu)) + return 1; + + if (data & ~PRED_CMD_IBPB) + return 1; +- + if (!data) + break; + +diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c +index d6bcbce6c15cb..77b9ed5223f37 100644 +--- a/arch/x86/kvm/vmx.c ++++ b/arch/x86/kvm/vmx.c +@@ -4066,7 +4066,7 @@ static int vmx_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + return kvm_get_msr_common(vcpu, msr_info); + case MSR_IA32_SPEC_CTRL: + if (!msr_info->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL)) ++ !guest_has_spec_ctrl_msr(vcpu)) + return 1; + + msr_info->data = to_vmx(vcpu)->spec_ctrl; +@@ -4180,7 +4180,7 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + break; + case MSR_IA32_SPEC_CTRL: + if (!msr_info->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL)) ++ !guest_has_spec_ctrl_msr(vcpu)) + return 1; + + /* The STIBP bit doesn't fault even if it's not advertised */ +@@ -4210,7 +4210,7 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) + break; + case MSR_IA32_PRED_CMD: + if (!msr_info->host_initiated && +- !guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL)) ++ !guest_has_pred_cmd_msr(vcpu)) + return 1; + + if (data & ~PRED_CMD_IBPB) +diff --git a/drivers/block/null_blk_zoned.c b/drivers/block/null_blk_zoned.c +index d1725ac636c04..079ed33fd8067 100644 +--- a/drivers/block/null_blk_zoned.c ++++ b/drivers/block/null_blk_zoned.c +@@ -1,9 +1,9 @@ + // SPDX-License-Identifier: GPL-2.0 + #include <linux/vmalloc.h> ++#include <linux/sizes.h> + #include "null_blk.h" + +-/* zone_size in MBs to sectors. */ +-#define ZONE_SIZE_SHIFT 11 ++#define MB_TO_SECTS(mb) (((sector_t)mb * SZ_1M) >> SECTOR_SHIFT) + + static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect) + { +@@ -12,7 +12,7 @@ static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect) + + int null_zone_init(struct nullb_device *dev) + { +- sector_t dev_size = (sector_t)dev->size * 1024 * 1024; ++ sector_t dev_capacity_sects; + sector_t sector = 0; + unsigned int i; + +@@ -25,9 +25,12 @@ int null_zone_init(struct nullb_device *dev) + return -EINVAL; + } + +- dev->zone_size_sects = dev->zone_size << ZONE_SIZE_SHIFT; +- dev->nr_zones = dev_size >> +- (SECTOR_SHIFT + ilog2(dev->zone_size_sects)); ++ dev_capacity_sects = MB_TO_SECTS(dev->size); ++ dev->zone_size_sects = MB_TO_SECTS(dev->zone_size); ++ dev->nr_zones = dev_capacity_sects >> ilog2(dev->zone_size_sects); ++ if (dev_capacity_sects & (dev->zone_size_sects - 1)) ++ dev->nr_zones++; ++ + dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct blk_zone), + GFP_KERNEL | __GFP_ZERO); + if (!dev->zones) +@@ -37,7 +40,10 @@ int null_zone_init(struct nullb_device *dev) + struct blk_zone *zone = &dev->zones[i]; + + zone->start = zone->wp = sector; +- zone->len = dev->zone_size_sects; ++ if (zone->start + dev->zone_size_sects > dev_capacity_sects) ++ zone->len = dev_capacity_sects - zone->start; ++ else ++ zone->len = dev->zone_size_sects; + zone->type = BLK_ZONE_TYPE_SEQWRITE_REQ; + zone->cond = BLK_ZONE_COND_EMPTY; + +diff --git a/drivers/bluetooth/hci_h5.c b/drivers/bluetooth/hci_h5.c +index 7ffeb37e8f202..a017322dba82b 100644 +--- a/drivers/bluetooth/hci_h5.c ++++ b/drivers/bluetooth/hci_h5.c +@@ -263,8 +263,12 @@ static int h5_close(struct hci_uart *hu) + if (h5->vnd && h5->vnd->close) + h5->vnd->close(h5); + +- if (!hu->serdev) +- kfree(h5); ++ if (hu->serdev) ++ serdev_device_close(hu->serdev); ++ ++ kfree_skb(h5->rx_skb); ++ kfree(h5); ++ h5 = NULL; + + return 0; + } +diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c +index e3599b43f9eb9..599be2d2b0ae9 100644 +--- a/drivers/md/dm-verity-target.c ++++ b/drivers/md/dm-verity-target.c +@@ -533,6 +533,15 @@ static int verity_verify_io(struct dm_verity_io *io) + return 0; + } + ++/* ++ * Skip verity work in response to I/O error when system is shutting down. ++ */ ++static inline bool verity_is_system_shutting_down(void) ++{ ++ return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF ++ || system_state == SYSTEM_RESTART; ++} ++ + /* + * End one "io" structure with a given error. + */ +@@ -560,7 +569,8 @@ static void verity_end_io(struct bio *bio) + { + struct dm_verity_io *io = bio->bi_private; + +- if (bio->bi_status && !verity_fec_is_enabled(io->v)) { ++ if (bio->bi_status && ++ (!verity_fec_is_enabled(io->v) || verity_is_system_shutting_down())) { + verity_finish_io(io, bio->bi_status); + return; + } +diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c +index 02c5e390f89f3..8e0f936b3e378 100644 +--- a/drivers/md/raid10.c ++++ b/drivers/md/raid10.c +@@ -1138,7 +1138,7 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio, + struct md_rdev *err_rdev = NULL; + gfp_t gfp = GFP_NOIO; + +- if (r10_bio->devs[slot].rdev) { ++ if (slot >= 0 && r10_bio->devs[slot].rdev) { + /* + * This is an error retry, but we cannot + * safely dereference the rdev in the r10_bio, +@@ -1547,6 +1547,7 @@ static void __make_request(struct mddev *mddev, struct bio *bio, int sectors) + r10_bio->mddev = mddev; + r10_bio->sector = bio->bi_iter.bi_sector; + r10_bio->state = 0; ++ r10_bio->read_slot = -1; + memset(r10_bio->devs, 0, sizeof(r10_bio->devs[0]) * conf->copies); + + if (bio_data_dir(bio) == READ) +diff --git a/drivers/media/usb/dvb-usb/gp8psk.c b/drivers/media/usb/dvb-usb/gp8psk.c +index 13e96b0aeb0fc..d97eab01cb8c7 100644 +--- a/drivers/media/usb/dvb-usb/gp8psk.c ++++ b/drivers/media/usb/dvb-usb/gp8psk.c +@@ -185,7 +185,7 @@ out_rel_fw: + + static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff) + { +- u8 status, buf; ++ u8 status = 0, buf; + int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct); + + if (onoff) { +diff --git a/drivers/misc/vmw_vmci/vmci_context.c b/drivers/misc/vmw_vmci/vmci_context.c +index bc089e634a751..26e20b091160a 100644 +--- a/drivers/misc/vmw_vmci/vmci_context.c ++++ b/drivers/misc/vmw_vmci/vmci_context.c +@@ -751,7 +751,7 @@ static int vmci_ctx_get_chkpt_doorbells(struct vmci_ctx *context, + return VMCI_ERROR_MORE_DATA; + } + +- dbells = kmalloc(data_size, GFP_ATOMIC); ++ dbells = kzalloc(data_size, GFP_ATOMIC); + if (!dbells) + return VMCI_ERROR_NO_MEM; + +diff --git a/drivers/rtc/rtc-sun6i.c b/drivers/rtc/rtc-sun6i.c +index 2cd5a7b1a2e30..e85abe8056064 100644 +--- a/drivers/rtc/rtc-sun6i.c ++++ b/drivers/rtc/rtc-sun6i.c +@@ -232,7 +232,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + 300000000); + if (IS_ERR(rtc->int_osc)) { + pr_crit("Couldn't register the internal oscillator\n"); +- return; ++ goto err; + } + + parents[0] = clk_hw_get_name(rtc->int_osc); +@@ -248,7 +248,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + rtc->losc = clk_register(NULL, &rtc->hw); + if (IS_ERR(rtc->losc)) { + pr_crit("Couldn't register the LOSC clock\n"); +- return; ++ goto err_register; + } + + of_property_read_string_index(node, "clock-output-names", 1, +@@ -259,7 +259,7 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + &rtc->lock); + if (IS_ERR(rtc->ext_losc)) { + pr_crit("Couldn't register the LOSC external gate\n"); +- return; ++ goto err_register; + } + + clk_data->num = 2; +@@ -268,6 +268,8 @@ static void __init sun6i_rtc_clk_init(struct device_node *node) + of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data); + return; + ++err_register: ++ clk_hw_unregister_fixed_rate(rtc->int_osc); + err: + kfree(clk_data); + } +diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c +index 5e23e4aa5b0a3..c48e1d84efb6b 100644 +--- a/drivers/vfio/pci/vfio_pci.c ++++ b/drivers/vfio/pci/vfio_pci.c +@@ -118,8 +118,6 @@ static void vfio_pci_probe_mmaps(struct vfio_pci_device *vdev) + int bar; + struct vfio_pci_dummy_resource *dummy_res; + +- INIT_LIST_HEAD(&vdev->dummy_resources_list); +- + for (bar = PCI_STD_RESOURCES; bar <= PCI_STD_RESOURCE_END; bar++) { + res = vdev->pdev->resource + bar; + +@@ -1522,6 +1520,7 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) + mutex_init(&vdev->igate); + spin_lock_init(&vdev->irqlock); + mutex_init(&vdev->ioeventfds_lock); ++ INIT_LIST_HEAD(&vdev->dummy_resources_list); + INIT_LIST_HEAD(&vdev->ioeventfds_list); + mutex_init(&vdev->vma_lock); + INIT_LIST_HEAD(&vdev->vma_list); +diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c +index 9d8e02cfd4803..3cfbec482efb9 100644 +--- a/drivers/xen/gntdev.c ++++ b/drivers/xen/gntdev.c +@@ -842,17 +842,18 @@ struct gntdev_copy_batch { + s16 __user *status[GNTDEV_COPY_BATCH]; + unsigned int nr_ops; + unsigned int nr_pages; ++ bool writeable; + }; + + static int gntdev_get_page(struct gntdev_copy_batch *batch, void __user *virt, +- bool writeable, unsigned long *gfn) ++ unsigned long *gfn) + { + unsigned long addr = (unsigned long)virt; + struct page *page; + unsigned long xen_pfn; + int ret; + +- ret = get_user_pages_fast(addr, 1, writeable, &page); ++ ret = get_user_pages_fast(addr, 1, batch->writeable, &page); + if (ret < 0) + return ret; + +@@ -868,9 +869,13 @@ static void gntdev_put_pages(struct gntdev_copy_batch *batch) + { + unsigned int i; + +- for (i = 0; i < batch->nr_pages; i++) ++ for (i = 0; i < batch->nr_pages; i++) { ++ if (batch->writeable && !PageDirty(batch->pages[i])) ++ set_page_dirty_lock(batch->pages[i]); + put_page(batch->pages[i]); ++ } + batch->nr_pages = 0; ++ batch->writeable = false; + } + + static int gntdev_copy(struct gntdev_copy_batch *batch) +@@ -959,8 +964,9 @@ static int gntdev_grant_copy_seg(struct gntdev_copy_batch *batch, + virt = seg->source.virt + copied; + off = (unsigned long)virt & ~XEN_PAGE_MASK; + len = min(len, (size_t)XEN_PAGE_SIZE - off); ++ batch->writeable = false; + +- ret = gntdev_get_page(batch, virt, false, &gfn); ++ ret = gntdev_get_page(batch, virt, &gfn); + if (ret < 0) + return ret; + +@@ -978,8 +984,9 @@ static int gntdev_grant_copy_seg(struct gntdev_copy_batch *batch, + virt = seg->dest.virt + copied; + off = (unsigned long)virt & ~XEN_PAGE_MASK; + len = min(len, (size_t)XEN_PAGE_SIZE - off); ++ batch->writeable = true; + +- ret = gntdev_get_page(batch, virt, true, &gfn); ++ ret = gntdev_get_page(batch, virt, &gfn); + if (ret < 0) + return ret; + +diff --git a/fs/crypto/hooks.c b/fs/crypto/hooks.c +index 042d5b44f4ed9..aa86cb2db8236 100644 +--- a/fs/crypto/hooks.c ++++ b/fs/crypto/hooks.c +@@ -58,8 +58,8 @@ int __fscrypt_prepare_link(struct inode *inode, struct inode *dir, + if (err) + return err; + +- /* ... in case we looked up ciphertext name before key was added */ +- if (dentry->d_flags & DCACHE_ENCRYPTED_NAME) ++ /* ... in case we looked up no-key name before key was added */ ++ if (fscrypt_is_nokey_name(dentry)) + return -ENOKEY; + + if (!fscrypt_has_permitted_context(dir, inode)) +@@ -83,9 +83,9 @@ int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry, + if (err) + return err; + +- /* ... in case we looked up ciphertext name(s) before key was added */ +- if ((old_dentry->d_flags | new_dentry->d_flags) & +- DCACHE_ENCRYPTED_NAME) ++ /* ... in case we looked up no-key name(s) before key was added */ ++ if (fscrypt_is_nokey_name(old_dentry) || ++ fscrypt_is_nokey_name(new_dentry)) + return -ENOKEY; + + if (old_dir != new_dir) { +diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c +index 4191552880bd7..3c238006870d3 100644 +--- a/fs/ext4/namei.c ++++ b/fs/ext4/namei.c +@@ -2106,6 +2106,9 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry, + if (!dentry->d_name.len) + return -EINVAL; + ++ if (fscrypt_is_nokey_name(dentry)) ++ return -ENOKEY; ++ + retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname); + if (retval) + return retval; +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index ee96f504ed782..e9e9f09f5370d 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -454,19 +454,17 @@ static bool system_going_down(void) + + static void ext4_handle_error(struct super_block *sb) + { ++ journal_t *journal = EXT4_SB(sb)->s_journal; ++ + if (test_opt(sb, WARN_ON_ERROR)) + WARN_ON_ONCE(1); + +- if (sb_rdonly(sb)) ++ if (sb_rdonly(sb) || test_opt(sb, ERRORS_CONT)) + return; + +- if (!test_opt(sb, ERRORS_CONT)) { +- journal_t *journal = EXT4_SB(sb)->s_journal; +- +- EXT4_SB(sb)->s_mount_flags |= EXT4_MF_FS_ABORTED; +- if (journal) +- jbd2_journal_abort(journal, -EIO); +- } ++ EXT4_SB(sb)->s_mount_flags |= EXT4_MF_FS_ABORTED; ++ if (journal) ++ jbd2_journal_abort(journal, -EIO); + /* + * We force ERRORS_RO behavior when system is rebooting. Otherwise we + * could panic during 'reboot -f' as the underlying device got already +diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h +index 53ffa6fe207a3..aacd8e11758ca 100644 +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -2857,6 +2857,8 @@ bool f2fs_empty_dir(struct inode *dir); + + static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode) + { ++ if (fscrypt_is_nokey_name(dentry)) ++ return -ENOKEY; + return f2fs_do_add_link(d_inode(dentry->d_parent), &dentry->d_name, + inode, inode->i_ino, inode->i_mode); + } +diff --git a/fs/fcntl.c b/fs/fcntl.c +index 4137d96534a6c..e039af1872ab2 100644 +--- a/fs/fcntl.c ++++ b/fs/fcntl.c +@@ -779,9 +779,10 @@ void send_sigio(struct fown_struct *fown, int fd, int band) + { + struct task_struct *p; + enum pid_type type; ++ unsigned long flags; + struct pid *pid; + +- read_lock(&fown->lock); ++ read_lock_irqsave(&fown->lock, flags); + + type = fown->pid_type; + pid = fown->pid; +@@ -802,7 +803,7 @@ void send_sigio(struct fown_struct *fown, int fd, int band) + read_unlock(&tasklist_lock); + } + out_unlock_fown: +- read_unlock(&fown->lock); ++ read_unlock_irqrestore(&fown->lock, flags); + } + + static void send_sigurg_to_task(struct task_struct *p, +@@ -817,9 +818,10 @@ int send_sigurg(struct fown_struct *fown) + struct task_struct *p; + enum pid_type type; + struct pid *pid; ++ unsigned long flags; + int ret = 0; + +- read_lock(&fown->lock); ++ read_lock_irqsave(&fown->lock, flags); + + type = fown->pid_type; + pid = fown->pid; +@@ -842,7 +844,7 @@ int send_sigurg(struct fown_struct *fown) + read_unlock(&tasklist_lock); + } + out_unlock_fown: +- read_unlock(&fown->lock); ++ read_unlock_irqrestore(&fown->lock, flags); + return ret; + } + +diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c +index 6fb7cb6b3f4b0..e7a10f5f54057 100644 +--- a/fs/nfs/nfs4super.c ++++ b/fs/nfs/nfs4super.c +@@ -95,7 +95,7 @@ static void nfs4_evict_inode(struct inode *inode) + nfs_inode_return_delegation_noreclaim(inode); + /* Note that above delegreturn would trigger pnfs return-on-close */ + pnfs_return_layout(inode); +- pnfs_destroy_layout(NFS_I(inode)); ++ pnfs_destroy_layout_final(NFS_I(inode)); + /* First call standard NFS clear_inode() code */ + nfs_clear_inode(inode); + } +diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c +index 2b9e139a29975..a253384a4710b 100644 +--- a/fs/nfs/pnfs.c ++++ b/fs/nfs/pnfs.c +@@ -294,6 +294,7 @@ void + pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo) + { + struct inode *inode; ++ unsigned long i_state; + + if (!lo) + return; +@@ -304,8 +305,12 @@ pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo) + if (!list_empty(&lo->plh_segs)) + WARN_ONCE(1, "NFS: BUG unfreed layout segments.\n"); + pnfs_detach_layout_hdr(lo); ++ i_state = inode->i_state; + spin_unlock(&inode->i_lock); + pnfs_free_layout_hdr(lo); ++ /* Notify pnfs_destroy_layout_final() that we're done */ ++ if (i_state & (I_FREEING | I_CLEAR)) ++ wake_up_var(lo); + } + } + +@@ -713,8 +718,7 @@ pnfs_free_lseg_list(struct list_head *free_me) + } + } + +-void +-pnfs_destroy_layout(struct nfs_inode *nfsi) ++static struct pnfs_layout_hdr *__pnfs_destroy_layout(struct nfs_inode *nfsi) + { + struct pnfs_layout_hdr *lo; + LIST_HEAD(tmp_list); +@@ -732,9 +736,34 @@ pnfs_destroy_layout(struct nfs_inode *nfsi) + pnfs_put_layout_hdr(lo); + } else + spin_unlock(&nfsi->vfs_inode.i_lock); ++ return lo; ++} ++ ++void pnfs_destroy_layout(struct nfs_inode *nfsi) ++{ ++ __pnfs_destroy_layout(nfsi); + } + EXPORT_SYMBOL_GPL(pnfs_destroy_layout); + ++static bool pnfs_layout_removed(struct nfs_inode *nfsi, ++ struct pnfs_layout_hdr *lo) ++{ ++ bool ret; ++ ++ spin_lock(&nfsi->vfs_inode.i_lock); ++ ret = nfsi->layout != lo; ++ spin_unlock(&nfsi->vfs_inode.i_lock); ++ return ret; ++} ++ ++void pnfs_destroy_layout_final(struct nfs_inode *nfsi) ++{ ++ struct pnfs_layout_hdr *lo = __pnfs_destroy_layout(nfsi); ++ ++ if (lo) ++ wait_var_event(lo, pnfs_layout_removed(nfsi, lo)); ++} ++ + static bool + pnfs_layout_add_bulk_destroy_list(struct inode *inode, + struct list_head *layout_list) +diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h +index 3ba44819a88ae..80fafa29e567a 100644 +--- a/fs/nfs/pnfs.h ++++ b/fs/nfs/pnfs.h +@@ -254,6 +254,7 @@ struct pnfs_layout_segment *pnfs_layout_process(struct nfs4_layoutget *lgp); + void pnfs_layoutget_free(struct nfs4_layoutget *lgp); + void pnfs_free_lseg_list(struct list_head *tmp_list); + void pnfs_destroy_layout(struct nfs_inode *); ++void pnfs_destroy_layout_final(struct nfs_inode *); + void pnfs_destroy_all_layouts(struct nfs_client *); + int pnfs_destroy_layouts_byfsid(struct nfs_client *clp, + struct nfs_fsid *fsid, +@@ -645,6 +646,10 @@ static inline void pnfs_destroy_layout(struct nfs_inode *nfsi) + { + } + ++static inline void pnfs_destroy_layout_final(struct nfs_inode *nfsi) ++{ ++} ++ + static inline struct pnfs_layout_segment * + pnfs_get_lseg(struct pnfs_layout_segment *lseg) + { +diff --git a/fs/quota/quota_tree.c b/fs/quota/quota_tree.c +index bb3f59bcfcf5b..656f9ff63edda 100644 +--- a/fs/quota/quota_tree.c ++++ b/fs/quota/quota_tree.c +@@ -61,7 +61,7 @@ static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) + + memset(buf, 0, info->dqi_usable_bs); + return sb->s_op->quota_read(sb, info->dqi_type, buf, +- info->dqi_usable_bs, blk << info->dqi_blocksize_bits); ++ info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits); + } + + static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) +@@ -70,7 +70,7 @@ static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) + ssize_t ret; + + ret = sb->s_op->quota_write(sb, info->dqi_type, buf, +- info->dqi_usable_bs, blk << info->dqi_blocksize_bits); ++ info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits); + if (ret != info->dqi_usable_bs) { + quota_error(sb, "dquota write failed"); + if (ret >= 0) +@@ -283,7 +283,7 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info, + blk); + goto out_buf; + } +- dquot->dq_off = (blk << info->dqi_blocksize_bits) + ++ dquot->dq_off = ((loff_t)blk << info->dqi_blocksize_bits) + + sizeof(struct qt_disk_dqdbheader) + + i * info->dqi_entry_size; + kfree(buf); +@@ -558,7 +558,7 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, + ret = -EIO; + goto out_buf; + } else { +- ret = (blk << info->dqi_blocksize_bits) + sizeof(struct ++ ret = ((loff_t)blk << info->dqi_blocksize_bits) + sizeof(struct + qt_disk_dqdbheader) + i * info->dqi_entry_size; + } + out_buf: +diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c +index 2946713cb00d6..5229038852ca1 100644 +--- a/fs/reiserfs/stree.c ++++ b/fs/reiserfs/stree.c +@@ -454,6 +454,12 @@ static int is_leaf(char *buf, int blocksize, struct buffer_head *bh) + "(second one): %h", ih); + return 0; + } ++ if (is_direntry_le_ih(ih) && (ih_item_len(ih) < (ih_entry_count(ih) * IH_SIZE))) { ++ reiserfs_warning(NULL, "reiserfs-5093", ++ "item entry count seems wrong %h", ++ ih); ++ return 0; ++ } + prev_location = ih_location(ih); + } + +diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c +index 10aab5dccaee4..8fe2ee5462a0b 100644 +--- a/fs/ubifs/dir.c ++++ b/fs/ubifs/dir.c +@@ -290,6 +290,15 @@ done: + return d_splice_alias(inode, dentry); + } + ++static int ubifs_prepare_create(struct inode *dir, struct dentry *dentry, ++ struct fscrypt_name *nm) ++{ ++ if (fscrypt_is_nokey_name(dentry)) ++ return -ENOKEY; ++ ++ return fscrypt_setup_filename(dir, &dentry->d_name, 0, nm); ++} ++ + static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode, + bool excl) + { +@@ -313,7 +322,7 @@ static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode, + if (err) + return err; + +- err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm); ++ err = ubifs_prepare_create(dir, dentry, &nm); + if (err) + goto out_budg; + +@@ -977,7 +986,7 @@ static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) + if (err) + return err; + +- err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm); ++ err = ubifs_prepare_create(dir, dentry, &nm); + if (err) + goto out_budg; + +@@ -1062,7 +1071,7 @@ static int ubifs_mknod(struct inode *dir, struct dentry *dentry, + return err; + } + +- err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm); ++ err = ubifs_prepare_create(dir, dentry, &nm); + if (err) { + kfree(dev); + goto out_budg; +@@ -1146,7 +1155,7 @@ static int ubifs_symlink(struct inode *dir, struct dentry *dentry, + if (err) + return err; + +- err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm); ++ err = ubifs_prepare_create(dir, dentry, &nm); + if (err) + goto out_budg; + +diff --git a/include/linux/fscrypt_notsupp.h b/include/linux/fscrypt_notsupp.h +index 24b261e49dc14..93304cfeb6016 100644 +--- a/include/linux/fscrypt_notsupp.h ++++ b/include/linux/fscrypt_notsupp.h +@@ -24,6 +24,11 @@ static inline bool fscrypt_dummy_context_enabled(struct inode *inode) + return false; + } + ++static inline bool fscrypt_is_nokey_name(const struct dentry *dentry) ++{ ++ return false; ++} ++ + /* crypto.c */ + static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work) + { +diff --git a/include/linux/fscrypt_supp.h b/include/linux/fscrypt_supp.h +index 8641e20694ce9..0409c14ae1de4 100644 +--- a/include/linux/fscrypt_supp.h ++++ b/include/linux/fscrypt_supp.h +@@ -58,6 +58,35 @@ static inline bool fscrypt_dummy_context_enabled(struct inode *inode) + inode->i_sb->s_cop->dummy_context(inode); + } + ++/** ++ * fscrypt_is_nokey_name() - test whether a dentry is a no-key name ++ * @dentry: the dentry to check ++ * ++ * This returns true if the dentry is a no-key dentry. A no-key dentry is a ++ * dentry that was created in an encrypted directory that hasn't had its ++ * encryption key added yet. Such dentries may be either positive or negative. ++ * ++ * When a filesystem is asked to create a new filename in an encrypted directory ++ * and the new filename's dentry is a no-key dentry, it must fail the operation ++ * with ENOKEY. This includes ->create(), ->mkdir(), ->mknod(), ->symlink(), ++ * ->rename(), and ->link(). (However, ->rename() and ->link() are already ++ * handled by fscrypt_prepare_rename() and fscrypt_prepare_link().) ++ * ++ * This is necessary because creating a filename requires the directory's ++ * encryption key, but just checking for the key on the directory inode during ++ * the final filesystem operation doesn't guarantee that the key was available ++ * during the preceding dentry lookup. And the key must have already been ++ * available during the dentry lookup in order for it to have been checked ++ * whether the filename already exists in the directory and for the new file's ++ * dentry not to be invalidated due to it incorrectly having the no-key flag. ++ * ++ * Return: %true if the dentry is a no-key name ++ */ ++static inline bool fscrypt_is_nokey_name(const struct dentry *dentry) ++{ ++ return dentry->d_flags & DCACHE_ENCRYPTED_NAME; ++} ++ + /* crypto.c */ + extern void fscrypt_enqueue_decrypt_work(struct work_struct *); + extern struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *, gfp_t); +diff --git a/include/linux/of.h b/include/linux/of.h +index d4f14b0302b63..6429f00341d14 100644 +--- a/include/linux/of.h ++++ b/include/linux/of.h +@@ -1258,6 +1258,7 @@ static inline int of_get_available_child_count(const struct device_node *np) + #define _OF_DECLARE(table, name, compat, fn, fn_type) \ + static const struct of_device_id __of_table_##name \ + __used __section(__##table##_of_table) \ ++ __aligned(__alignof__(struct of_device_id)) \ + = { .compatible = compat, \ + .data = (fn == (fn_type)NULL) ? fn : fn } + #else +diff --git a/include/uapi/linux/const.h b/include/uapi/linux/const.h +index 5ed721ad5b198..af2a44c08683d 100644 +--- a/include/uapi/linux/const.h ++++ b/include/uapi/linux/const.h +@@ -28,4 +28,9 @@ + #define _BITUL(x) (_UL(1) << (x)) + #define _BITULL(x) (_ULL(1) << (x)) + ++#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) ++#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask)) ++ ++#define __KERNEL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) ++ + #endif /* _UAPI_LINUX_CONST_H */ +diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h +index dc69391d2bbae..fc21d3726b591 100644 +--- a/include/uapi/linux/ethtool.h ++++ b/include/uapi/linux/ethtool.h +@@ -14,7 +14,7 @@ + #ifndef _UAPI_LINUX_ETHTOOL_H + #define _UAPI_LINUX_ETHTOOL_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/if_ether.h> + +diff --git a/include/uapi/linux/kernel.h b/include/uapi/linux/kernel.h +index 0ff8f7477847c..fadf2db71fe8a 100644 +--- a/include/uapi/linux/kernel.h ++++ b/include/uapi/linux/kernel.h +@@ -3,13 +3,6 @@ + #define _UAPI_LINUX_KERNEL_H + + #include <linux/sysinfo.h> +- +-/* +- * 'kernel.h' contains some often-used function prototypes etc +- */ +-#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) +-#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask)) +- +-#define __KERNEL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) ++#include <linux/const.h> + + #endif /* _UAPI_LINUX_KERNEL_H */ +diff --git a/include/uapi/linux/lightnvm.h b/include/uapi/linux/lightnvm.h +index f9a1be7fc6962..ead2e72e5c88e 100644 +--- a/include/uapi/linux/lightnvm.h ++++ b/include/uapi/linux/lightnvm.h +@@ -21,7 +21,7 @@ + #define _UAPI_LINUX_LIGHTNVM_H + + #ifdef __KERNEL__ +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/ioctl.h> + #else /* __KERNEL__ */ + #include <stdio.h> +diff --git a/include/uapi/linux/mroute6.h b/include/uapi/linux/mroute6.h +index 9999cc006390d..1617eb9949a5d 100644 +--- a/include/uapi/linux/mroute6.h ++++ b/include/uapi/linux/mroute6.h +@@ -2,7 +2,7 @@ + #ifndef _UAPI__LINUX_MROUTE6_H + #define _UAPI__LINUX_MROUTE6_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/sockios.h> + #include <linux/in6.h> /* For struct sockaddr_in6. */ +diff --git a/include/uapi/linux/netfilter/x_tables.h b/include/uapi/linux/netfilter/x_tables.h +index a8283f7dbc519..b8c6bb233ac1c 100644 +--- a/include/uapi/linux/netfilter/x_tables.h ++++ b/include/uapi/linux/netfilter/x_tables.h +@@ -1,7 +1,7 @@ + /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ + #ifndef _UAPI_X_TABLES_H + #define _UAPI_X_TABLES_H +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + + #define XT_FUNCTION_MAXNAMELEN 30 +diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h +index 776bc92e91180..3481cde43a841 100644 +--- a/include/uapi/linux/netlink.h ++++ b/include/uapi/linux/netlink.h +@@ -2,7 +2,7 @@ + #ifndef _UAPI__LINUX_NETLINK_H + #define _UAPI__LINUX_NETLINK_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/socket.h> /* for __kernel_sa_family_t */ + #include <linux/types.h> + +diff --git a/include/uapi/linux/sysctl.h b/include/uapi/linux/sysctl.h +index d71013fffaf65..d3393a6571ba3 100644 +--- a/include/uapi/linux/sysctl.h ++++ b/include/uapi/linux/sysctl.h +@@ -23,7 +23,7 @@ + #ifndef _UAPI_LINUX_SYSCTL_H + #define _UAPI_LINUX_SYSCTL_H + +-#include <linux/kernel.h> ++#include <linux/const.h> + #include <linux/types.h> + #include <linux/compiler.h> + +diff --git a/kernel/module.c b/kernel/module.c +index d05e1bfdd3559..429769605871d 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -1806,7 +1806,6 @@ static int mod_sysfs_init(struct module *mod) + if (err) + mod_kobject_put(mod); + +- /* delay uevent until full sysfs population */ + out: + return err; + } +@@ -1843,7 +1842,6 @@ static int mod_sysfs_setup(struct module *mod, + add_sect_attrs(mod, info); + add_notes_attrs(mod, info); + +- kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD); + return 0; + + out_unreg_modinfo_attrs: +@@ -3499,6 +3497,9 @@ static noinline int do_init_module(struct module *mod) + blocking_notifier_call_chain(&module_notify_list, + MODULE_STATE_LIVE, mod); + ++ /* Delay uevent until module has finished its init routine */ ++ kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD); ++ + /* + * We need to finish all async code before the module init sequence + * is done. This has potential to deadlock. For example, a newly +@@ -3841,6 +3842,7 @@ static int load_module(struct load_info *info, const char __user *uargs, + MODULE_STATE_GOING, mod); + klp_module_going(mod); + bug_cleanup: ++ mod->state = MODULE_STATE_GOING; + /* module_bug_cleanup needs module_mutex protection */ + mutex_lock(&module_mutex); + module_bug_cleanup(mod); +diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c +index 7c12b0deb4eb5..db62dbe7eaa8a 100644 +--- a/sound/core/pcm_native.c ++++ b/sound/core/pcm_native.c +@@ -753,8 +753,13 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream, + runtime->boundary *= 2; + + /* clear the buffer for avoiding possible kernel info leaks */ +- if (runtime->dma_area && !substream->ops->copy_user) +- memset(runtime->dma_area, 0, runtime->dma_bytes); ++ if (runtime->dma_area && !substream->ops->copy_user) { ++ size_t size = runtime->dma_bytes; ++ ++ if (runtime->info & SNDRV_PCM_INFO_MMAP) ++ size = PAGE_ALIGN(size); ++ memset(runtime->dma_area, 0, size); ++ } + + snd_pcm_timer_resolution_change(substream); + snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP); +diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c +index 9b26973fe697a..f4f855d7a7910 100644 +--- a/sound/core/rawmidi.c ++++ b/sound/core/rawmidi.c +@@ -87,11 +87,21 @@ static inline unsigned short snd_rawmidi_file_flags(struct file *file) + } + } + +-static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream) ++static inline bool __snd_rawmidi_ready(struct snd_rawmidi_runtime *runtime) ++{ ++ return runtime->avail >= runtime->avail_min; ++} ++ ++static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream) + { + struct snd_rawmidi_runtime *runtime = substream->runtime; ++ unsigned long flags; ++ bool ready; + +- return runtime->avail >= runtime->avail_min; ++ spin_lock_irqsave(&runtime->lock, flags); ++ ready = __snd_rawmidi_ready(runtime); ++ spin_unlock_irqrestore(&runtime->lock, flags); ++ return ready; + } + + static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream, +@@ -960,7 +970,7 @@ int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, + if (result > 0) { + if (runtime->event) + schedule_work(&runtime->event_work); +- else if (snd_rawmidi_ready(substream)) ++ else if (__snd_rawmidi_ready(runtime)) + wake_up(&runtime->sleep); + } + spin_unlock_irqrestore(&runtime->lock, flags); +@@ -1039,7 +1049,7 @@ static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t coun + result = 0; + while (count > 0) { + spin_lock_irq(&runtime->lock); +- while (!snd_rawmidi_ready(substream)) { ++ while (!__snd_rawmidi_ready(runtime)) { + wait_queue_entry_t wait; + + if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { +@@ -1056,9 +1066,11 @@ static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t coun + return -ENODEV; + if (signal_pending(current)) + return result > 0 ? result : -ERESTARTSYS; +- if (!runtime->avail) +- return result > 0 ? result : -EIO; + spin_lock_irq(&runtime->lock); ++ if (!runtime->avail) { ++ spin_unlock_irq(&runtime->lock); ++ return result > 0 ? result : -EIO; ++ } + } + spin_unlock_irq(&runtime->lock); + count1 = snd_rawmidi_kernel_read1(substream, +@@ -1196,7 +1208,7 @@ int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int coun + runtime->avail += count; + substream->bytes += count; + if (count > 0) { +- if (runtime->drain || snd_rawmidi_ready(substream)) ++ if (runtime->drain || __snd_rawmidi_ready(runtime)) + wake_up(&runtime->sleep); + } + return count; +@@ -1363,9 +1375,11 @@ static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, + return -ENODEV; + if (signal_pending(current)) + return result > 0 ? result : -ERESTARTSYS; +- if (!runtime->avail && !timeout) +- return result > 0 ? result : -EIO; + spin_lock_irq(&runtime->lock); ++ if (!runtime->avail && !timeout) { ++ spin_unlock_irq(&runtime->lock); ++ return result > 0 ? result : -EIO; ++ } + } + spin_unlock_irq(&runtime->lock); + count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count); +@@ -1445,6 +1459,7 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, + struct snd_rawmidi *rmidi; + struct snd_rawmidi_substream *substream; + struct snd_rawmidi_runtime *runtime; ++ unsigned long buffer_size, avail, xruns; + + rmidi = entry->private_data; + snd_iprintf(buffer, "%s\n\n", rmidi->name); +@@ -1463,13 +1478,16 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, + " Owner PID : %d\n", + pid_vnr(substream->pid)); + runtime = substream->runtime; ++ spin_lock_irq(&runtime->lock); ++ buffer_size = runtime->buffer_size; ++ avail = runtime->avail; ++ spin_unlock_irq(&runtime->lock); + snd_iprintf(buffer, + " Mode : %s\n" + " Buffer size : %lu\n" + " Avail : %lu\n", + runtime->oss ? "OSS compatible" : "native", +- (unsigned long) runtime->buffer_size, +- (unsigned long) runtime->avail); ++ buffer_size, avail); + } + } + } +@@ -1487,13 +1505,16 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, + " Owner PID : %d\n", + pid_vnr(substream->pid)); + runtime = substream->runtime; ++ spin_lock_irq(&runtime->lock); ++ buffer_size = runtime->buffer_size; ++ avail = runtime->avail; ++ xruns = runtime->xruns; ++ spin_unlock_irq(&runtime->lock); + snd_iprintf(buffer, + " Buffer size : %lu\n" + " Avail : %lu\n" + " Overruns : %lu\n", +- (unsigned long) runtime->buffer_size, +- (unsigned long) runtime->avail, +- (unsigned long) runtime->xruns); ++ buffer_size, avail, xruns); + } + } + } +diff --git a/sound/core/seq/seq_queue.h b/sound/core/seq/seq_queue.h +index e006fc8e3a366..6b634cfb42ed0 100644 +--- a/sound/core/seq/seq_queue.h ++++ b/sound/core/seq/seq_queue.h +@@ -40,10 +40,10 @@ struct snd_seq_queue { + + struct snd_seq_timer *timer; /* time keeper for this queue */ + int owner; /* client that 'owns' the timer */ +- unsigned int locked:1, /* timer is only accesibble by owner if set */ +- klocked:1, /* kernel lock (after START) */ +- check_again:1, +- check_blocked:1; ++ bool locked; /* timer is only accesibble by owner if set */ ++ bool klocked; /* kernel lock (after START) */ ++ bool check_again; /* concurrent access happened during check */ ++ bool check_blocked; /* queue being checked */ + + unsigned int flags; /* status flags */ + unsigned int info_flags; /* info for sync */
