commit: 516a9e00306527e226708dafdd5012629e65d623 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Sun Jun 9 16:19:55 2019 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Sun Jun 9 16:19:55 2019 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=516a9e00
Linux patch 5.1.8 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1007_linux-5.1.8.patch | 3548 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 3552 insertions(+) diff --git a/0000_README b/0000_README index 7c0827d..c561860 100644 --- a/0000_README +++ b/0000_README @@ -71,6 +71,10 @@ Patch: 1006_linux-5.1.7.patch From: http://www.kernel.org Desc: Linux 5.1.7 +Patch: 1007_linux-5.1.8.patch +From: http://www.kernel.org +Desc: Linux 5.1.8 + 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/1007_linux-5.1.8.patch b/1007_linux-5.1.8.patch new file mode 100644 index 0000000..b0a6865 --- /dev/null +++ b/1007_linux-5.1.8.patch @@ -0,0 +1,3548 @@ +diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admin-guide/cgroup-v2.rst +index 20f92c16ffbf..26b3a3e7daf6 100644 +--- a/Documentation/admin-guide/cgroup-v2.rst ++++ b/Documentation/admin-guide/cgroup-v2.rst +@@ -177,6 +177,15 @@ cgroup v2 currently supports the following mount options. + ignored on non-init namespace mounts. Please refer to the + Delegation section for details. + ++ memory_localevents ++ ++ Only populate memory.events with data for the current cgroup, ++ and not any subtrees. This is legacy behaviour, the default ++ behaviour without this option is to include subtree counts. ++ This option is system wide and can only be set on mount or ++ modified through remount from the init namespace. The mount ++ option is ignored on non-init namespace mounts. ++ + + Organizing Processes and Threads + -------------------------------- +diff --git a/Documentation/conf.py b/Documentation/conf.py +index 72647a38b5c2..7ace3f8852bd 100644 +--- a/Documentation/conf.py ++++ b/Documentation/conf.py +@@ -37,7 +37,7 @@ needs_sphinx = '1.3' + extensions = ['kerneldoc', 'rstFlatTable', 'kernel_include', 'cdomain', 'kfigure', 'sphinx.ext.ifconfig'] + + # The name of the math extension changed on Sphinx 1.4 +-if major == 1 and minor > 3: ++if (major == 1 and minor > 3) or (major > 1): + extensions.append("sphinx.ext.imgmath") + else: + extensions.append("sphinx.ext.pngmath") +diff --git a/Documentation/sphinx/kerneldoc.py b/Documentation/sphinx/kerneldoc.py +index 9d0a7f08f93b..1159405cb920 100644 +--- a/Documentation/sphinx/kerneldoc.py ++++ b/Documentation/sphinx/kerneldoc.py +@@ -37,7 +37,19 @@ import glob + from docutils import nodes, statemachine + from docutils.statemachine import ViewList + from docutils.parsers.rst import directives, Directive +-from sphinx.ext.autodoc import AutodocReporter ++ ++# ++# AutodocReporter is only good up to Sphinx 1.7 ++# ++import sphinx ++ ++Use_SSI = sphinx.__version__[:3] >= '1.7' ++if Use_SSI: ++ from sphinx.util.docutils import switch_source_input ++else: ++ from sphinx.ext.autodoc import AutodocReporter ++ ++import kernellog + + __version__ = '1.0' + +@@ -90,7 +102,8 @@ class KernelDocDirective(Directive): + cmd += [filename] + + try: +- env.app.verbose('calling kernel-doc \'%s\'' % (" ".join(cmd))) ++ kernellog.verbose(env.app, ++ 'calling kernel-doc \'%s\'' % (" ".join(cmd))) + + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() +@@ -100,7 +113,8 @@ class KernelDocDirective(Directive): + if p.returncode != 0: + sys.stderr.write(err) + +- env.app.warn('kernel-doc \'%s\' failed with return code %d' % (" ".join(cmd), p.returncode)) ++ kernellog.warn(env.app, ++ 'kernel-doc \'%s\' failed with return code %d' % (" ".join(cmd), p.returncode)) + return [nodes.error(None, nodes.paragraph(text = "kernel-doc missing"))] + elif env.config.kerneldoc_verbosity > 0: + sys.stderr.write(err) +@@ -121,20 +135,28 @@ class KernelDocDirective(Directive): + lineoffset += 1 + + node = nodes.section() +- buf = self.state.memo.title_styles, self.state.memo.section_level, self.state.memo.reporter ++ self.do_parse(result, node) ++ ++ return node.children ++ ++ except Exception as e: # pylint: disable=W0703 ++ kernellog.warn(env.app, 'kernel-doc \'%s\' processing failed with: %s' % ++ (" ".join(cmd), str(e))) ++ return [nodes.error(None, nodes.paragraph(text = "kernel-doc missing"))] ++ ++ def do_parse(self, result, node): ++ if Use_SSI: ++ with switch_source_input(self.state, result): ++ self.state.nested_parse(result, 0, node, match_titles=1) ++ else: ++ save = self.state.memo.title_styles, self.state.memo.section_level, self.state.memo.reporter + self.state.memo.reporter = AutodocReporter(result, self.state.memo.reporter) + self.state.memo.title_styles, self.state.memo.section_level = [], 0 + try: + self.state.nested_parse(result, 0, node, match_titles=1) + finally: +- self.state.memo.title_styles, self.state.memo.section_level, self.state.memo.reporter = buf ++ self.state.memo.title_styles, self.state.memo.section_level, self.state.memo.reporter = save + +- return node.children +- +- except Exception as e: # pylint: disable=W0703 +- env.app.warn('kernel-doc \'%s\' processing failed with: %s' % +- (" ".join(cmd), str(e))) +- return [nodes.error(None, nodes.paragraph(text = "kernel-doc missing"))] + + def setup(app): + app.add_config_value('kerneldoc_bin', None, 'env') +diff --git a/Documentation/sphinx/kernellog.py b/Documentation/sphinx/kernellog.py +new file mode 100644 +index 000000000000..af924f51a7dc +--- /dev/null ++++ b/Documentation/sphinx/kernellog.py +@@ -0,0 +1,28 @@ ++# SPDX-License-Identifier: GPL-2.0 ++# ++# Sphinx has deprecated its older logging interface, but the replacement ++# only goes back to 1.6. So here's a wrapper layer to keep around for ++# as long as we support 1.4. ++# ++import sphinx ++ ++if sphinx.__version__[:3] >= '1.6': ++ UseLogging = True ++ from sphinx.util import logging ++ logger = logging.getLogger('kerneldoc') ++else: ++ UseLogging = False ++ ++def warn(app, message): ++ if UseLogging: ++ logger.warning(message) ++ else: ++ app.warn(message) ++ ++def verbose(app, message): ++ if UseLogging: ++ logger.verbose(message) ++ else: ++ app.verbose(message) ++ ++ +diff --git a/Documentation/sphinx/kfigure.py b/Documentation/sphinx/kfigure.py +index b97228d2cc0e..fbfe6693bb60 100644 +--- a/Documentation/sphinx/kfigure.py ++++ b/Documentation/sphinx/kfigure.py +@@ -60,6 +60,8 @@ import sphinx + from sphinx.util.nodes import clean_astext + from six import iteritems + ++import kernellog ++ + PY3 = sys.version_info[0] == 3 + + if PY3: +@@ -171,20 +173,20 @@ def setupTools(app): + This function is called once, when the builder is initiated. + """ + global dot_cmd, convert_cmd # pylint: disable=W0603 +- app.verbose("kfigure: check installed tools ...") ++ kernellog.verbose(app, "kfigure: check installed tools ...") + + dot_cmd = which('dot') + convert_cmd = which('convert') + + if dot_cmd: +- app.verbose("use dot(1) from: " + dot_cmd) ++ kernellog.verbose(app, "use dot(1) from: " + dot_cmd) + else: +- app.warn("dot(1) not found, for better output quality install " +- "graphviz from http://www.graphviz.org";) ++ kernellog.warn(app, "dot(1) not found, for better output quality install " ++ "graphviz from http://www.graphviz.org";) + if convert_cmd: +- app.verbose("use convert(1) from: " + convert_cmd) ++ kernellog.verbose(app, "use convert(1) from: " + convert_cmd) + else: +- app.warn( ++ kernellog.warn(app, + "convert(1) not found, for SVG to PDF conversion install " + "ImageMagick (https://www.imagemagick.org)") + +@@ -220,12 +222,13 @@ def convert_image(img_node, translator, src_fname=None): + + # in kernel builds, use 'make SPHINXOPTS=-v' to see verbose messages + +- app.verbose('assert best format for: ' + img_node['uri']) ++ kernellog.verbose(app, 'assert best format for: ' + img_node['uri']) + + if in_ext == '.dot': + + if not dot_cmd: +- app.verbose("dot from graphviz not available / include DOT raw.") ++ kernellog.verbose(app, ++ "dot from graphviz not available / include DOT raw.") + img_node.replace_self(file2literal(src_fname)) + + elif translator.builder.format == 'latex': +@@ -252,7 +255,8 @@ def convert_image(img_node, translator, src_fname=None): + + if translator.builder.format == 'latex': + if convert_cmd is None: +- app.verbose("no SVG to PDF conversion available / include SVG raw.") ++ kernellog.verbose(app, ++ "no SVG to PDF conversion available / include SVG raw.") + img_node.replace_self(file2literal(src_fname)) + else: + dst_fname = path.join(translator.builder.outdir, fname + '.pdf') +@@ -265,18 +269,19 @@ def convert_image(img_node, translator, src_fname=None): + _name = dst_fname[len(translator.builder.outdir) + 1:] + + if isNewer(dst_fname, src_fname): +- app.verbose("convert: {out}/%s already exists and is newer" % _name) ++ kernellog.verbose(app, ++ "convert: {out}/%s already exists and is newer" % _name) + + else: + ok = False + mkdir(path.dirname(dst_fname)) + + if in_ext == '.dot': +- app.verbose('convert DOT to: {out}/' + _name) ++ kernellog.verbose(app, 'convert DOT to: {out}/' + _name) + ok = dot2format(app, src_fname, dst_fname) + + elif in_ext == '.svg': +- app.verbose('convert SVG to: {out}/' + _name) ++ kernellog.verbose(app, 'convert SVG to: {out}/' + _name) + ok = svg2pdf(app, src_fname, dst_fname) + + if not ok: +@@ -305,7 +310,8 @@ def dot2format(app, dot_fname, out_fname): + with open(out_fname, "w") as out: + exit_code = subprocess.call(cmd, stdout = out) + if exit_code != 0: +- app.warn("Error #%d when calling: %s" % (exit_code, " ".join(cmd))) ++ kernellog.warn(app, ++ "Error #%d when calling: %s" % (exit_code, " ".join(cmd))) + return bool(exit_code == 0) + + def svg2pdf(app, svg_fname, pdf_fname): +@@ -322,7 +328,7 @@ def svg2pdf(app, svg_fname, pdf_fname): + # use stdout and stderr from parent + exit_code = subprocess.call(cmd) + if exit_code != 0: +- app.warn("Error #%d when calling: %s" % (exit_code, " ".join(cmd))) ++ kernellog.warn(app, "Error #%d when calling: %s" % (exit_code, " ".join(cmd))) + return bool(exit_code == 0) + + +@@ -415,15 +421,15 @@ def visit_kernel_render(self, node): + app = self.builder.app + srclang = node.get('srclang') + +- app.verbose('visit kernel-render node lang: "%s"' % (srclang)) ++ kernellog.verbose(app, 'visit kernel-render node lang: "%s"' % (srclang)) + + tmp_ext = RENDER_MARKUP_EXT.get(srclang, None) + if tmp_ext is None: +- app.warn('kernel-render: "%s" unknown / include raw.' % (srclang)) ++ kernellog.warn(app, 'kernel-render: "%s" unknown / include raw.' % (srclang)) + return + + if not dot_cmd and tmp_ext == '.dot': +- app.verbose("dot from graphviz not available / include raw.") ++ kernellog.verbose(app, "dot from graphviz not available / include raw.") + return + + literal_block = node[0] +diff --git a/Makefile b/Makefile +index 299578ce385a..3027a0ce7a02 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 1 +-SUBLEVEL = 7 ++SUBLEVEL = 8 + EXTRAVERSION = + NAME = Shy Crocodile + +diff --git a/arch/arm64/kernel/sys.c b/arch/arm64/kernel/sys.c +index 6f91e8116514..162a95ed0881 100644 +--- a/arch/arm64/kernel/sys.c ++++ b/arch/arm64/kernel/sys.c +@@ -50,7 +50,7 @@ SYSCALL_DEFINE1(arm64_personality, unsigned int, personality) + /* + * Wrappers to pass the pt_regs argument. + */ +-#define sys_personality sys_arm64_personality ++#define __arm64_sys_personality __arm64_sys_arm64_personality + + asmlinkage long sys_ni_syscall(const struct pt_regs *); + #define __arm64_sys_ni_syscall sys_ni_syscall +diff --git a/arch/arm64/kernel/traps.c b/arch/arm64/kernel/traps.c +index 29755989f616..3102685a6cd7 100644 +--- a/arch/arm64/kernel/traps.c ++++ b/arch/arm64/kernel/traps.c +@@ -256,7 +256,10 @@ void arm64_force_sig_fault(int signo, int code, void __user *addr, + const char *str) + { + arm64_show_signal(signo, str); +- force_sig_fault(signo, code, addr, current); ++ if (signo == SIGKILL) ++ force_sig(SIGKILL, current); ++ else ++ force_sig_fault(signo, code, addr, current); + } + + void arm64_force_sig_mceerr(int code, void __user *addr, short lsb, +diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c +index 6d0517ac18e5..0369f26ab96d 100644 +--- a/arch/mips/kvm/mips.c ++++ b/arch/mips/kvm/mips.c +@@ -1122,6 +1122,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) + case KVM_CAP_MAX_VCPUS: + r = KVM_MAX_VCPUS; + break; ++ case KVM_CAP_MAX_VCPU_ID: ++ r = KVM_MAX_VCPU_ID; ++ break; + case KVM_CAP_MIPS_FPU: + /* We don't handle systems with inconsistent cpu_has_fpu */ + r = !!raw_cpu_has_fpu; +diff --git a/arch/powerpc/kernel/kexec_elf_64.c b/arch/powerpc/kernel/kexec_elf_64.c +index ba4f18a43ee8..52a29fc73730 100644 +--- a/arch/powerpc/kernel/kexec_elf_64.c ++++ b/arch/powerpc/kernel/kexec_elf_64.c +@@ -547,6 +547,7 @@ static int elf_exec_load(struct kimage *image, struct elfhdr *ehdr, + kbuf.memsz = phdr->p_memsz; + kbuf.buf_align = phdr->p_align; + kbuf.buf_min = phdr->p_paddr + base; ++ kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + ret = kexec_add_buffer(&kbuf); + if (ret) + goto out; +@@ -581,7 +582,8 @@ static void *elf64_load(struct kimage *image, char *kernel_buf, + struct kexec_buf kbuf = { .image = image, .buf_min = 0, + .buf_max = ppc64_rma_size }; + struct kexec_buf pbuf = { .image = image, .buf_min = 0, +- .buf_max = ppc64_rma_size, .top_down = true }; ++ .buf_max = ppc64_rma_size, .top_down = true, ++ .mem = KEXEC_BUF_MEM_UNKNOWN }; + + ret = build_elf_exec_info(kernel_buf, kernel_len, &ehdr, &elf_info); + if (ret) +@@ -606,6 +608,7 @@ static void *elf64_load(struct kimage *image, char *kernel_buf, + kbuf.bufsz = kbuf.memsz = initrd_len; + kbuf.buf_align = PAGE_SIZE; + kbuf.top_down = false; ++ kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + ret = kexec_add_buffer(&kbuf); + if (ret) + goto out; +@@ -638,6 +641,7 @@ static void *elf64_load(struct kimage *image, char *kernel_buf, + kbuf.bufsz = kbuf.memsz = fdt_size; + kbuf.buf_align = PAGE_SIZE; + kbuf.top_down = true; ++ kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + ret = kexec_add_buffer(&kbuf); + if (ret) + goto out; +diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c +index b2b29d4f9842..bd68b3e59de5 100644 +--- a/arch/powerpc/kvm/book3s_hv.c ++++ b/arch/powerpc/kvm/book3s_hv.c +@@ -3624,6 +3624,7 @@ int kvmhv_p9_guest_entry(struct kvm_vcpu *vcpu, u64 time_limit, + vc->in_guest = 0; + + mtspr(SPRN_DEC, local_paca->kvm_hstate.dec_expires - mftb()); ++ mtspr(SPRN_SPRG_VDSO_WRITE, local_paca->sprg_vdso); + + kvmhv_load_host_pmu(); + +@@ -4048,16 +4049,20 @@ int kvmhv_run_single_vcpu(struct kvm_run *kvm_run, + if (cpu_has_feature(CPU_FTR_HVMODE)) + kvmppc_radix_check_need_tlb_flush(kvm, pcpu, nested); + +- trace_hardirqs_on(); + guest_enter_irqoff(); + + srcu_idx = srcu_read_lock(&kvm->srcu); + + this_cpu_disable_ftrace(); + ++ /* Tell lockdep that we're about to enable interrupts */ ++ trace_hardirqs_on(); ++ + trap = kvmhv_p9_guest_entry(vcpu, time_limit, lpcr); + vcpu->arch.trap = trap; + ++ trace_hardirqs_off(); ++ + this_cpu_enable_ftrace(); + + srcu_read_unlock(&kvm->srcu, srcu_idx); +@@ -4067,7 +4072,6 @@ int kvmhv_run_single_vcpu(struct kvm_run *kvm_run, + isync(); + } + +- trace_hardirqs_off(); + set_irq_happened(trap); + + kvmppc_set_host_core(pcpu); +diff --git a/arch/powerpc/kvm/book3s_xive.c b/arch/powerpc/kvm/book3s_xive.c +index f78d002f0fe0..1ad950af7b7b 100644 +--- a/arch/powerpc/kvm/book3s_xive.c ++++ b/arch/powerpc/kvm/book3s_xive.c +@@ -1786,7 +1786,6 @@ static void kvmppc_xive_cleanup_irq(u32 hw_num, struct xive_irq_data *xd) + { + xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_01); + xive_native_configure_irq(hw_num, 0, MASKED, 0); +- xive_cleanup_irq_data(xd); + } + + static void kvmppc_xive_free_sources(struct kvmppc_xive_src_block *sb) +@@ -1800,9 +1799,10 @@ static void kvmppc_xive_free_sources(struct kvmppc_xive_src_block *sb) + continue; + + kvmppc_xive_cleanup_irq(state->ipi_number, &state->ipi_data); ++ xive_cleanup_irq_data(&state->ipi_data); + xive_native_free_irq(state->ipi_number); + +- /* Pass-through, cleanup too */ ++ /* Pass-through, cleanup too but keep IRQ hw data */ + if (state->pt_number) + kvmppc_xive_cleanup_irq(state->pt_number, state->pt_data); + +diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c +index 8885377ec3e0..d2e800e27f03 100644 +--- a/arch/powerpc/kvm/powerpc.c ++++ b/arch/powerpc/kvm/powerpc.c +@@ -650,6 +650,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) + case KVM_CAP_MAX_VCPUS: + r = KVM_MAX_VCPUS; + break; ++ case KVM_CAP_MAX_VCPU_ID: ++ r = KVM_MAX_VCPU_ID; ++ break; + #ifdef CONFIG_PPC_BOOK3S_64 + case KVM_CAP_PPC_GET_SMMU_INFO: + r = 1; +diff --git a/arch/powerpc/perf/core-book3s.c b/arch/powerpc/perf/core-book3s.c +index b0723002a396..8eb5dc5df62b 100644 +--- a/arch/powerpc/perf/core-book3s.c ++++ b/arch/powerpc/perf/core-book3s.c +@@ -1846,6 +1846,7 @@ static int power_pmu_event_init(struct perf_event *event) + int n; + int err; + struct cpu_hw_events *cpuhw; ++ u64 bhrb_filter; + + if (!ppmu) + return -ENOENT; +@@ -1951,13 +1952,14 @@ static int power_pmu_event_init(struct perf_event *event) + err = power_check_constraints(cpuhw, events, cflags, n + 1); + + if (has_branch_stack(event)) { +- cpuhw->bhrb_filter = ppmu->bhrb_filter_map( ++ bhrb_filter = ppmu->bhrb_filter_map( + event->attr.branch_sample_type); + +- if (cpuhw->bhrb_filter == -1) { ++ if (bhrb_filter == -1) { + put_cpu_var(cpu_hw_events); + return -EOPNOTSUPP; + } ++ cpuhw->bhrb_filter = bhrb_filter; + } + + put_cpu_var(cpu_hw_events); +diff --git a/arch/powerpc/perf/power8-pmu.c b/arch/powerpc/perf/power8-pmu.c +index d12a2db26353..d10feef93b6b 100644 +--- a/arch/powerpc/perf/power8-pmu.c ++++ b/arch/powerpc/perf/power8-pmu.c +@@ -29,6 +29,7 @@ enum { + #define POWER8_MMCRA_IFM1 0x0000000040000000UL + #define POWER8_MMCRA_IFM2 0x0000000080000000UL + #define POWER8_MMCRA_IFM3 0x00000000C0000000UL ++#define POWER8_MMCRA_BHRB_MASK 0x00000000C0000000UL + + /* + * Raw event encoding for PowerISA v2.07 (Power8): +@@ -243,6 +244,8 @@ static u64 power8_bhrb_filter_map(u64 branch_sample_type) + + static void power8_config_bhrb(u64 pmu_bhrb_filter) + { ++ pmu_bhrb_filter &= POWER8_MMCRA_BHRB_MASK; ++ + /* Enable BHRB filter in PMU */ + mtspr(SPRN_MMCRA, (mfspr(SPRN_MMCRA) | pmu_bhrb_filter)); + } +diff --git a/arch/powerpc/perf/power9-pmu.c b/arch/powerpc/perf/power9-pmu.c +index 030544e35959..f3987915cadc 100644 +--- a/arch/powerpc/perf/power9-pmu.c ++++ b/arch/powerpc/perf/power9-pmu.c +@@ -92,6 +92,7 @@ enum { + #define POWER9_MMCRA_IFM1 0x0000000040000000UL + #define POWER9_MMCRA_IFM2 0x0000000080000000UL + #define POWER9_MMCRA_IFM3 0x00000000C0000000UL ++#define POWER9_MMCRA_BHRB_MASK 0x00000000C0000000UL + + /* Nasty Power9 specific hack */ + #define PVR_POWER9_CUMULUS 0x00002000 +@@ -300,6 +301,8 @@ static u64 power9_bhrb_filter_map(u64 branch_sample_type) + + static void power9_config_bhrb(u64 pmu_bhrb_filter) + { ++ pmu_bhrb_filter &= POWER9_MMCRA_BHRB_MASK; ++ + /* Enable BHRB filter in PMU */ + mtspr(SPRN_MMCRA, (mfspr(SPRN_MMCRA) | pmu_bhrb_filter)); + } +diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c +index dd456725189f..d00f84add5f4 100644 +--- a/arch/s390/crypto/aes_s390.c ++++ b/arch/s390/crypto/aes_s390.c +@@ -27,14 +27,14 @@ + #include <linux/module.h> + #include <linux/cpufeature.h> + #include <linux/init.h> +-#include <linux/spinlock.h> ++#include <linux/mutex.h> + #include <linux/fips.h> + #include <linux/string.h> + #include <crypto/xts.h> + #include <asm/cpacf.h> + + static u8 *ctrblk; +-static DEFINE_SPINLOCK(ctrblk_lock); ++static DEFINE_MUTEX(ctrblk_lock); + + static cpacf_mask_t km_functions, kmc_functions, kmctr_functions, + kma_functions; +@@ -698,7 +698,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, unsigned long modifier, + unsigned int n, nbytes; + int ret, locked; + +- locked = spin_trylock(&ctrblk_lock); ++ locked = mutex_trylock(&ctrblk_lock); + + ret = blkcipher_walk_virt_block(desc, walk, AES_BLOCK_SIZE); + while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) { +@@ -716,7 +716,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, unsigned long modifier, + ret = blkcipher_walk_done(desc, walk, nbytes - n); + } + if (locked) +- spin_unlock(&ctrblk_lock); ++ mutex_unlock(&ctrblk_lock); + /* + * final block may be < AES_BLOCK_SIZE, copy only nbytes + */ +@@ -826,19 +826,45 @@ static int gcm_aes_setauthsize(struct crypto_aead *tfm, unsigned int authsize) + return 0; + } + +-static void gcm_sg_walk_start(struct gcm_sg_walk *gw, struct scatterlist *sg, +- unsigned int len) ++static void gcm_walk_start(struct gcm_sg_walk *gw, struct scatterlist *sg, ++ unsigned int len) + { + memset(gw, 0, sizeof(*gw)); + gw->walk_bytes_remain = len; + scatterwalk_start(&gw->walk, sg); + } + +-static int gcm_sg_walk_go(struct gcm_sg_walk *gw, unsigned int minbytesneeded) ++static inline unsigned int _gcm_sg_clamp_and_map(struct gcm_sg_walk *gw) ++{ ++ struct scatterlist *nextsg; ++ ++ gw->walk_bytes = scatterwalk_clamp(&gw->walk, gw->walk_bytes_remain); ++ while (!gw->walk_bytes) { ++ nextsg = sg_next(gw->walk.sg); ++ if (!nextsg) ++ return 0; ++ scatterwalk_start(&gw->walk, nextsg); ++ gw->walk_bytes = scatterwalk_clamp(&gw->walk, ++ gw->walk_bytes_remain); ++ } ++ gw->walk_ptr = scatterwalk_map(&gw->walk); ++ return gw->walk_bytes; ++} ++ ++static inline void _gcm_sg_unmap_and_advance(struct gcm_sg_walk *gw, ++ unsigned int nbytes) ++{ ++ gw->walk_bytes_remain -= nbytes; ++ scatterwalk_unmap(&gw->walk); ++ scatterwalk_advance(&gw->walk, nbytes); ++ scatterwalk_done(&gw->walk, 0, gw->walk_bytes_remain); ++ gw->walk_ptr = NULL; ++} ++ ++static int gcm_in_walk_go(struct gcm_sg_walk *gw, unsigned int minbytesneeded) + { + int n; + +- /* minbytesneeded <= AES_BLOCK_SIZE */ + if (gw->buf_bytes && gw->buf_bytes >= minbytesneeded) { + gw->ptr = gw->buf; + gw->nbytes = gw->buf_bytes; +@@ -851,13 +877,11 @@ static int gcm_sg_walk_go(struct gcm_sg_walk *gw, unsigned int minbytesneeded) + goto out; + } + +- gw->walk_bytes = scatterwalk_clamp(&gw->walk, gw->walk_bytes_remain); +- if (!gw->walk_bytes) { +- scatterwalk_start(&gw->walk, sg_next(gw->walk.sg)); +- gw->walk_bytes = scatterwalk_clamp(&gw->walk, +- gw->walk_bytes_remain); ++ if (!_gcm_sg_clamp_and_map(gw)) { ++ gw->ptr = NULL; ++ gw->nbytes = 0; ++ goto out; + } +- gw->walk_ptr = scatterwalk_map(&gw->walk); + + if (!gw->buf_bytes && gw->walk_bytes >= minbytesneeded) { + gw->ptr = gw->walk_ptr; +@@ -869,51 +893,90 @@ static int gcm_sg_walk_go(struct gcm_sg_walk *gw, unsigned int minbytesneeded) + n = min(gw->walk_bytes, AES_BLOCK_SIZE - gw->buf_bytes); + memcpy(gw->buf + gw->buf_bytes, gw->walk_ptr, n); + gw->buf_bytes += n; +- gw->walk_bytes_remain -= n; +- scatterwalk_unmap(&gw->walk); +- scatterwalk_advance(&gw->walk, n); +- scatterwalk_done(&gw->walk, 0, gw->walk_bytes_remain); +- ++ _gcm_sg_unmap_and_advance(gw, n); + if (gw->buf_bytes >= minbytesneeded) { + gw->ptr = gw->buf; + gw->nbytes = gw->buf_bytes; + goto out; + } +- +- gw->walk_bytes = scatterwalk_clamp(&gw->walk, +- gw->walk_bytes_remain); +- if (!gw->walk_bytes) { +- scatterwalk_start(&gw->walk, sg_next(gw->walk.sg)); +- gw->walk_bytes = scatterwalk_clamp(&gw->walk, +- gw->walk_bytes_remain); ++ if (!_gcm_sg_clamp_and_map(gw)) { ++ gw->ptr = NULL; ++ gw->nbytes = 0; ++ goto out; + } +- gw->walk_ptr = scatterwalk_map(&gw->walk); + } + + out: + return gw->nbytes; + } + +-static void gcm_sg_walk_done(struct gcm_sg_walk *gw, unsigned int bytesdone) ++static int gcm_out_walk_go(struct gcm_sg_walk *gw, unsigned int minbytesneeded) + { +- int n; ++ if (gw->walk_bytes_remain == 0) { ++ gw->ptr = NULL; ++ gw->nbytes = 0; ++ goto out; ++ } + ++ if (!_gcm_sg_clamp_and_map(gw)) { ++ gw->ptr = NULL; ++ gw->nbytes = 0; ++ goto out; ++ } ++ ++ if (gw->walk_bytes >= minbytesneeded) { ++ gw->ptr = gw->walk_ptr; ++ gw->nbytes = gw->walk_bytes; ++ goto out; ++ } ++ ++ scatterwalk_unmap(&gw->walk); ++ gw->walk_ptr = NULL; ++ ++ gw->ptr = gw->buf; ++ gw->nbytes = sizeof(gw->buf); ++ ++out: ++ return gw->nbytes; ++} ++ ++static int gcm_in_walk_done(struct gcm_sg_walk *gw, unsigned int bytesdone) ++{ + if (gw->ptr == NULL) +- return; ++ return 0; + + if (gw->ptr == gw->buf) { +- n = gw->buf_bytes - bytesdone; ++ int n = gw->buf_bytes - bytesdone; + if (n > 0) { + memmove(gw->buf, gw->buf + bytesdone, n); +- gw->buf_bytes -= n; ++ gw->buf_bytes = n; + } else + gw->buf_bytes = 0; +- } else { +- gw->walk_bytes_remain -= bytesdone; +- scatterwalk_unmap(&gw->walk); +- scatterwalk_advance(&gw->walk, bytesdone); +- scatterwalk_done(&gw->walk, 0, gw->walk_bytes_remain); +- } ++ } else ++ _gcm_sg_unmap_and_advance(gw, bytesdone); ++ ++ return bytesdone; ++} ++ ++static int gcm_out_walk_done(struct gcm_sg_walk *gw, unsigned int bytesdone) ++{ ++ int i, n; ++ ++ if (gw->ptr == NULL) ++ return 0; ++ ++ if (gw->ptr == gw->buf) { ++ for (i = 0; i < bytesdone; i += n) { ++ if (!_gcm_sg_clamp_and_map(gw)) ++ return i; ++ n = min(gw->walk_bytes, bytesdone - i); ++ memcpy(gw->walk_ptr, gw->buf + i, n); ++ _gcm_sg_unmap_and_advance(gw, n); ++ } ++ } else ++ _gcm_sg_unmap_and_advance(gw, bytesdone); ++ ++ return bytesdone; + } + + static int gcm_aes_crypt(struct aead_request *req, unsigned int flags) +@@ -926,7 +989,7 @@ static int gcm_aes_crypt(struct aead_request *req, unsigned int flags) + unsigned int pclen = req->cryptlen; + int ret = 0; + +- unsigned int len, in_bytes, out_bytes, ++ unsigned int n, len, in_bytes, out_bytes, + min_bytes, bytes, aad_bytes, pc_bytes; + struct gcm_sg_walk gw_in, gw_out; + u8 tag[GHASH_DIGEST_SIZE]; +@@ -963,14 +1026,14 @@ static int gcm_aes_crypt(struct aead_request *req, unsigned int flags) + *(u32 *)(param.j0 + ivsize) = 1; + memcpy(param.k, ctx->key, ctx->key_len); + +- gcm_sg_walk_start(&gw_in, req->src, len); +- gcm_sg_walk_start(&gw_out, req->dst, len); ++ gcm_walk_start(&gw_in, req->src, len); ++ gcm_walk_start(&gw_out, req->dst, len); + + do { + min_bytes = min_t(unsigned int, + aadlen > 0 ? aadlen : pclen, AES_BLOCK_SIZE); +- in_bytes = gcm_sg_walk_go(&gw_in, min_bytes); +- out_bytes = gcm_sg_walk_go(&gw_out, min_bytes); ++ in_bytes = gcm_in_walk_go(&gw_in, min_bytes); ++ out_bytes = gcm_out_walk_go(&gw_out, min_bytes); + bytes = min(in_bytes, out_bytes); + + if (aadlen + pclen <= bytes) { +@@ -997,8 +1060,11 @@ static int gcm_aes_crypt(struct aead_request *req, unsigned int flags) + gw_in.ptr + aad_bytes, pc_bytes, + gw_in.ptr, aad_bytes); + +- gcm_sg_walk_done(&gw_in, aad_bytes + pc_bytes); +- gcm_sg_walk_done(&gw_out, aad_bytes + pc_bytes); ++ n = aad_bytes + pc_bytes; ++ if (gcm_in_walk_done(&gw_in, n) != n) ++ return -ENOMEM; ++ if (gcm_out_walk_done(&gw_out, n) != n) ++ return -ENOMEM; + aadlen -= aad_bytes; + pclen -= pc_bytes; + } while (aadlen + pclen > 0); +diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c +index 0d15383d0ff1..d64531cc9623 100644 +--- a/arch/s390/crypto/des_s390.c ++++ b/arch/s390/crypto/des_s390.c +@@ -14,6 +14,7 @@ + #include <linux/cpufeature.h> + #include <linux/crypto.h> + #include <linux/fips.h> ++#include <linux/mutex.h> + #include <crypto/algapi.h> + #include <crypto/des.h> + #include <asm/cpacf.h> +@@ -21,7 +22,7 @@ + #define DES3_KEY_SIZE (3 * DES_KEY_SIZE) + + static u8 *ctrblk; +-static DEFINE_SPINLOCK(ctrblk_lock); ++static DEFINE_MUTEX(ctrblk_lock); + + static cpacf_mask_t km_functions, kmc_functions, kmctr_functions; + +@@ -387,7 +388,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, unsigned long fc, + unsigned int n, nbytes; + int ret, locked; + +- locked = spin_trylock(&ctrblk_lock); ++ locked = mutex_trylock(&ctrblk_lock); + + ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE); + while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { +@@ -404,7 +405,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, unsigned long fc, + ret = blkcipher_walk_done(desc, walk, nbytes - n); + } + if (locked) +- spin_unlock(&ctrblk_lock); ++ mutex_unlock(&ctrblk_lock); + /* final block may be < DES_BLOCK_SIZE, copy only nbytes */ + if (nbytes) { + cpacf_kmctr(fc, ctx->key, buf, walk->src.virt.addr, +diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c +index 4638303ba6a8..c4180ecfbb2a 100644 +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -507,6 +507,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) + break; + case KVM_CAP_NR_VCPUS: + case KVM_CAP_MAX_VCPUS: ++ case KVM_CAP_MAX_VCPU_ID: + r = KVM_S390_BSCA_CPU_SLOTS; + if (!kvm_s390_use_sca_entries()) + r = KVM_MAX_VCPUS; +diff --git a/arch/sparc/mm/ultra.S b/arch/sparc/mm/ultra.S +index d245f89d1395..d220b6848746 100644 +--- a/arch/sparc/mm/ultra.S ++++ b/arch/sparc/mm/ultra.S +@@ -587,7 +587,7 @@ xcall_flush_tlb_kernel_range: /* 44 insns */ + sub %g7, %g1, %g3 + srlx %g3, 18, %g2 + brnz,pn %g2, 2f +- add %g2, 1, %g2 ++ sethi %hi(PAGE_SIZE), %g2 + sub %g3, %g2, %g3 + or %g1, 0x20, %g1 ! Nucleus + 1: stxa %g0, [%g1 + %g3] ASI_DMMU_DEMAP +@@ -751,7 +751,7 @@ __cheetah_xcall_flush_tlb_kernel_range: /* 44 insns */ + sub %g7, %g1, %g3 + srlx %g3, 18, %g2 + brnz,pn %g2, 2f +- add %g2, 1, %g2 ++ sethi %hi(PAGE_SIZE), %g2 + sub %g3, %g2, %g3 + or %g1, 0x20, %g1 ! Nucleus + 1: stxa %g0, [%g1 + %g3] ASI_DMMU_DEMAP +diff --git a/arch/x86/kernel/ima_arch.c b/arch/x86/kernel/ima_arch.c +index e47cd9390ab4..2a2e87717bad 100644 +--- a/arch/x86/kernel/ima_arch.c ++++ b/arch/x86/kernel/ima_arch.c +@@ -17,6 +17,11 @@ static enum efi_secureboot_mode get_sb_mode(void) + + size = sizeof(secboot); + ++ if (!efi_enabled(EFI_RUNTIME_SERVICES)) { ++ pr_info("ima: secureboot mode unknown, no efi\n"); ++ return efi_secureboot_mode_unknown; ++ } ++ + /* Get variable contents into buffer */ + status = efi.get_variable(efi_SecureBoot_name, &efi_variable_guid, + NULL, &size, &secboot); +diff --git a/arch/x86/kernel/kprobes/core.c b/arch/x86/kernel/kprobes/core.c +index fed46ddb1eef..06058c44ab57 100644 +--- a/arch/x86/kernel/kprobes/core.c ++++ b/arch/x86/kernel/kprobes/core.c +@@ -431,8 +431,20 @@ void *alloc_insn_page(void) + void *page; + + page = module_alloc(PAGE_SIZE); +- if (page) +- set_memory_ro((unsigned long)page & PAGE_MASK, 1); ++ if (!page) ++ return NULL; ++ ++ /* ++ * First make the page read-only, and only then make it executable to ++ * prevent it from being W+X in between. ++ */ ++ set_memory_ro((unsigned long)page, 1); ++ ++ /* ++ * TODO: Once additional kernel code protection mechanisms are set, ensure ++ * that the page was not maliciously altered and it is still zeroed. ++ */ ++ set_memory_x((unsigned long)page, 1); + + return page; + } +@@ -440,8 +452,12 @@ void *alloc_insn_page(void) + /* Recover page to RW mode before releasing it */ + void free_insn_page(void *page) + { +- set_memory_nx((unsigned long)page & PAGE_MASK, 1); +- set_memory_rw((unsigned long)page & PAGE_MASK, 1); ++ /* ++ * First make the page non-executable, and only then make it writable to ++ * prevent it from being W+X in between. ++ */ ++ set_memory_nx((unsigned long)page, 1); ++ set_memory_rw((unsigned long)page, 1); + module_memfree(page); + } + +diff --git a/arch/x86/kernel/vmlinux.lds.S b/arch/x86/kernel/vmlinux.lds.S +index 834659288ba9..a5127b2c195f 100644 +--- a/arch/x86/kernel/vmlinux.lds.S ++++ b/arch/x86/kernel/vmlinux.lds.S +@@ -141,10 +141,10 @@ SECTIONS + *(.text.__x86.indirect_thunk) + __indirect_thunk_end = .; + #endif +- } :text = 0x9090 + +- /* End of text section */ +- _etext = .; ++ /* End of text section */ ++ _etext = .; ++ } :text = 0x9090 + + NOTES :text :note + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 6b8575c547ee..efc8adf7ca0e 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -3090,6 +3090,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) + case KVM_CAP_MAX_VCPUS: + r = KVM_MAX_VCPUS; + break; ++ case KVM_CAP_MAX_VCPU_ID: ++ r = KVM_MAX_VCPU_ID; ++ break; + case KVM_CAP_NR_MEMSLOTS: + r = KVM_USER_MEM_SLOTS; + break; +diff --git a/drivers/clk/imx/clk-imx8mm.c b/drivers/clk/imx/clk-imx8mm.c +index 1ef8438e3d6d..122a81ab8e48 100644 +--- a/drivers/clk/imx/clk-imx8mm.c ++++ b/drivers/clk/imx/clk-imx8mm.c +@@ -449,12 +449,12 @@ static int __init imx8mm_clocks_init(struct device_node *ccm_node) + clks[IMX8MM_AUDIO_PLL2_OUT] = imx_clk_gate("audio_pll2_out", "audio_pll2_bypass", base + 0x14, 13); + clks[IMX8MM_VIDEO_PLL1_OUT] = imx_clk_gate("video_pll1_out", "video_pll1_bypass", base + 0x28, 13); + clks[IMX8MM_DRAM_PLL_OUT] = imx_clk_gate("dram_pll_out", "dram_pll_bypass", base + 0x50, 13); +- clks[IMX8MM_GPU_PLL_OUT] = imx_clk_gate("gpu_pll_out", "gpu_pll_bypass", base + 0x64, 13); +- clks[IMX8MM_VPU_PLL_OUT] = imx_clk_gate("vpu_pll_out", "vpu_pll_bypass", base + 0x74, 13); +- clks[IMX8MM_ARM_PLL_OUT] = imx_clk_gate("arm_pll_out", "arm_pll_bypass", base + 0x84, 13); +- clks[IMX8MM_SYS_PLL1_OUT] = imx_clk_gate("sys_pll1_out", "sys_pll1_bypass", base + 0x94, 13); +- clks[IMX8MM_SYS_PLL2_OUT] = imx_clk_gate("sys_pll2_out", "sys_pll2_bypass", base + 0x104, 13); +- clks[IMX8MM_SYS_PLL3_OUT] = imx_clk_gate("sys_pll3_out", "sys_pll3_bypass", base + 0x114, 13); ++ clks[IMX8MM_GPU_PLL_OUT] = imx_clk_gate("gpu_pll_out", "gpu_pll_bypass", base + 0x64, 11); ++ clks[IMX8MM_VPU_PLL_OUT] = imx_clk_gate("vpu_pll_out", "vpu_pll_bypass", base + 0x74, 11); ++ clks[IMX8MM_ARM_PLL_OUT] = imx_clk_gate("arm_pll_out", "arm_pll_bypass", base + 0x84, 11); ++ clks[IMX8MM_SYS_PLL1_OUT] = imx_clk_gate("sys_pll1_out", "sys_pll1_bypass", base + 0x94, 11); ++ clks[IMX8MM_SYS_PLL2_OUT] = imx_clk_gate("sys_pll2_out", "sys_pll2_bypass", base + 0x104, 11); ++ clks[IMX8MM_SYS_PLL3_OUT] = imx_clk_gate("sys_pll3_out", "sys_pll3_bypass", base + 0x114, 11); + + /* SYS PLL fixed output */ + clks[IMX8MM_SYS_PLL1_40M] = imx_clk_fixed_factor("sys_pll1_40m", "sys_pll1_out", 1, 20); +diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c +index 0aabd401d3ca..0ceda7c14915 100644 +--- a/drivers/gpu/drm/drm_atomic_uapi.c ++++ b/drivers/gpu/drm/drm_atomic_uapi.c +@@ -512,8 +512,8 @@ drm_atomic_crtc_get_property(struct drm_crtc *crtc, + } + + static int drm_atomic_plane_set_property(struct drm_plane *plane, +- struct drm_plane_state *state, struct drm_property *property, +- uint64_t val) ++ struct drm_plane_state *state, struct drm_file *file_priv, ++ struct drm_property *property, uint64_t val) + { + struct drm_device *dev = plane->dev; + struct drm_mode_config *config = &dev->mode_config; +@@ -521,7 +521,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, + int ret; + + if (property == config->prop_fb_id) { +- struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, NULL, val); ++ struct drm_framebuffer *fb; ++ fb = drm_framebuffer_lookup(dev, file_priv, val); + drm_atomic_set_fb_for_plane(state, fb); + if (fb) + drm_framebuffer_put(fb); +@@ -537,7 +538,7 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, + return -EINVAL; + + } else if (property == config->prop_crtc_id) { +- struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val); ++ struct drm_crtc *crtc = drm_crtc_find(dev, file_priv, val); + return drm_atomic_set_crtc_for_plane(state, crtc); + } else if (property == config->prop_crtc_x) { + state->crtc_x = U642I64(val); +@@ -681,14 +682,14 @@ static int drm_atomic_set_writeback_fb_for_connector( + } + + static int drm_atomic_connector_set_property(struct drm_connector *connector, +- struct drm_connector_state *state, struct drm_property *property, +- uint64_t val) ++ struct drm_connector_state *state, struct drm_file *file_priv, ++ struct drm_property *property, uint64_t val) + { + struct drm_device *dev = connector->dev; + struct drm_mode_config *config = &dev->mode_config; + + if (property == config->prop_crtc_id) { +- struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val); ++ struct drm_crtc *crtc = drm_crtc_find(dev, file_priv, val); + return drm_atomic_set_crtc_for_connector(state, crtc); + } else if (property == config->dpms_property) { + /* setting DPMS property requires special handling, which +@@ -747,8 +748,10 @@ static int drm_atomic_connector_set_property(struct drm_connector *connector, + } + state->content_protection = val; + } else if (property == config->writeback_fb_id_property) { +- struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, NULL, val); +- int ret = drm_atomic_set_writeback_fb_for_connector(state, fb); ++ struct drm_framebuffer *fb; ++ int ret; ++ fb = drm_framebuffer_lookup(dev, file_priv, val); ++ ret = drm_atomic_set_writeback_fb_for_connector(state, fb); + if (fb) + drm_framebuffer_put(fb); + return ret; +@@ -943,6 +946,7 @@ out: + } + + int drm_atomic_set_property(struct drm_atomic_state *state, ++ struct drm_file *file_priv, + struct drm_mode_object *obj, + struct drm_property *prop, + uint64_t prop_value) +@@ -965,7 +969,8 @@ int drm_atomic_set_property(struct drm_atomic_state *state, + } + + ret = drm_atomic_connector_set_property(connector, +- connector_state, prop, prop_value); ++ connector_state, file_priv, ++ prop, prop_value); + break; + } + case DRM_MODE_OBJECT_CRTC: { +@@ -993,7 +998,8 @@ int drm_atomic_set_property(struct drm_atomic_state *state, + } + + ret = drm_atomic_plane_set_property(plane, +- plane_state, prop, prop_value); ++ plane_state, file_priv, ++ prop, prop_value); + break; + } + default: +@@ -1365,8 +1371,8 @@ retry: + goto out; + } + +- ret = drm_atomic_set_property(state, obj, prop, +- prop_value); ++ ret = drm_atomic_set_property(state, file_priv, ++ obj, prop, prop_value); + if (ret) { + drm_mode_object_put(obj); + goto out; +diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c +index 7dabbaf033a1..790ba5941954 100644 +--- a/drivers/gpu/drm/drm_crtc.c ++++ b/drivers/gpu/drm/drm_crtc.c +@@ -559,6 +559,10 @@ int drm_mode_setcrtc(struct drm_device *dev, void *data, + + plane = crtc->primary; + ++ /* allow disabling with the primary plane leased */ ++ if (crtc_req->mode_valid && !drm_lease_held(file_priv, plane->base.id)) ++ return -EACCES; ++ + mutex_lock(&crtc->dev->mode_config.mutex); + DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, + DRM_MODESET_ACQUIRE_INTERRUPTIBLE, ret); +diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h +index 216f2a9ee3d4..0719a235d6cc 100644 +--- a/drivers/gpu/drm/drm_crtc_internal.h ++++ b/drivers/gpu/drm/drm_crtc_internal.h +@@ -214,6 +214,7 @@ int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state, + struct drm_connector *connector, + int mode); + int drm_atomic_set_property(struct drm_atomic_state *state, ++ struct drm_file *file_priv, + struct drm_mode_object *obj, + struct drm_property *prop, + uint64_t prop_value); +diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c +index af2ab640cadb..4a5b2d2bc508 100644 +--- a/drivers/gpu/drm/drm_fb_helper.c ++++ b/drivers/gpu/drm/drm_fb_helper.c +@@ -3317,8 +3317,6 @@ int drm_fbdev_generic_setup(struct drm_device *dev, unsigned int preferred_bpp) + return ret; + } + +- drm_client_add(&fb_helper->client); +- + if (!preferred_bpp) + preferred_bpp = dev->mode_config.preferred_depth; + if (!preferred_bpp) +@@ -3329,6 +3327,8 @@ int drm_fbdev_generic_setup(struct drm_device *dev, unsigned int preferred_bpp) + if (ret) + DRM_DEV_DEBUG(dev->dev, "client hotplug ret=%d\n", ret); + ++ drm_client_add(&fb_helper->client); ++ + return 0; + } + EXPORT_SYMBOL(drm_fbdev_generic_setup); +diff --git a/drivers/gpu/drm/drm_gem_cma_helper.c b/drivers/gpu/drm/drm_gem_cma_helper.c +index cc26625b4b33..e01ceed09e67 100644 +--- a/drivers/gpu/drm/drm_gem_cma_helper.c ++++ b/drivers/gpu/drm/drm_gem_cma_helper.c +@@ -186,13 +186,13 @@ void drm_gem_cma_free_object(struct drm_gem_object *gem_obj) + + cma_obj = to_drm_gem_cma_obj(gem_obj); + +- if (cma_obj->vaddr) { +- dma_free_wc(gem_obj->dev->dev, cma_obj->base.size, +- cma_obj->vaddr, cma_obj->paddr); +- } else if (gem_obj->import_attach) { ++ if (gem_obj->import_attach) { + if (cma_obj->vaddr) + dma_buf_vunmap(gem_obj->import_attach->dmabuf, cma_obj->vaddr); + drm_prime_gem_destroy(gem_obj, cma_obj->sgt); ++ } else if (cma_obj->vaddr) { ++ dma_free_wc(gem_obj->dev->dev, cma_obj->base.size, ++ cma_obj->vaddr, cma_obj->paddr); + } + + drm_gem_object_release(gem_obj); +diff --git a/drivers/gpu/drm/drm_mode_config.c b/drivers/gpu/drm/drm_mode_config.c +index 4a1c2023ccf0..1a346ae1599d 100644 +--- a/drivers/gpu/drm/drm_mode_config.c ++++ b/drivers/gpu/drm/drm_mode_config.c +@@ -297,8 +297,9 @@ static int drm_mode_create_standard_properties(struct drm_device *dev) + return -ENOMEM; + dev->mode_config.prop_crtc_id = prop; + +- prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, "FB_DAMAGE_CLIPS", +- 0); ++ prop = drm_property_create(dev, ++ DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB, ++ "FB_DAMAGE_CLIPS", 0); + if (!prop) + return -ENOMEM; + dev->mode_config.prop_fb_damage_clips = prop; +diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c +index a9005c1c2384..f32507e65b79 100644 +--- a/drivers/gpu/drm/drm_mode_object.c ++++ b/drivers/gpu/drm/drm_mode_object.c +@@ -451,6 +451,7 @@ static int set_property_legacy(struct drm_mode_object *obj, + } + + static int set_property_atomic(struct drm_mode_object *obj, ++ struct drm_file *file_priv, + struct drm_property *prop, + uint64_t prop_value) + { +@@ -477,7 +478,7 @@ retry: + obj_to_connector(obj), + prop_value); + } else { +- ret = drm_atomic_set_property(state, obj, prop, prop_value); ++ ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value); + if (ret) + goto out; + ret = drm_atomic_commit(state); +@@ -520,7 +521,7 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, + goto out_unref; + + if (drm_drv_uses_atomic_modeset(property->dev)) +- ret = set_property_atomic(arg_obj, property, arg->value); ++ ret = set_property_atomic(arg_obj, file_priv, property, arg->value); + else + ret = set_property_legacy(arg_obj, property, arg->value); + +diff --git a/drivers/gpu/drm/drm_plane.c b/drivers/gpu/drm/drm_plane.c +index 4cfb56893b7f..d6ad60ab0d38 100644 +--- a/drivers/gpu/drm/drm_plane.c ++++ b/drivers/gpu/drm/drm_plane.c +@@ -960,6 +960,11 @@ retry: + if (ret) + goto out; + ++ if (!drm_lease_held(file_priv, crtc->cursor->base.id)) { ++ ret = -EACCES; ++ goto out; ++ } ++ + ret = drm_mode_cursor_universal(crtc, req, file_priv, &ctx); + goto out; + } +@@ -1062,6 +1067,9 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev, + + plane = crtc->primary; + ++ if (!drm_lease_held(file_priv, plane->base.id)) ++ return -EACCES; ++ + if (crtc->funcs->page_flip_target) { + u32 current_vblank; + int r; +diff --git a/drivers/gpu/drm/imx/ipuv3-plane.c b/drivers/gpu/drm/imx/ipuv3-plane.c +index d7a727a6e3d7..91edfe2498a6 100644 +--- a/drivers/gpu/drm/imx/ipuv3-plane.c ++++ b/drivers/gpu/drm/imx/ipuv3-plane.c +@@ -605,7 +605,6 @@ static void ipu_plane_atomic_update(struct drm_plane *plane, + active = ipu_idmac_get_current_buffer(ipu_plane->ipu_ch); + ipu_cpmem_set_buffer(ipu_plane->ipu_ch, !active, eba); + ipu_idmac_select_buffer(ipu_plane->ipu_ch, !active); +- ipu_plane->next_buf = !active; + if (ipu_plane_separate_alpha(ipu_plane)) { + active = ipu_idmac_get_current_buffer(ipu_plane->alpha_ch); + ipu_cpmem_set_buffer(ipu_plane->alpha_ch, !active, +@@ -710,7 +709,6 @@ static void ipu_plane_atomic_update(struct drm_plane *plane, + ipu_cpmem_set_buffer(ipu_plane->ipu_ch, 1, eba); + ipu_idmac_lock_enable(ipu_plane->ipu_ch, num_bursts); + ipu_plane_enable(ipu_plane); +- ipu_plane->next_buf = -1; + } + + static const struct drm_plane_helper_funcs ipu_plane_helper_funcs = { +@@ -732,10 +730,15 @@ bool ipu_plane_atomic_update_pending(struct drm_plane *plane) + + if (ipu_state->use_pre) + return ipu_prg_channel_configure_pending(ipu_plane->ipu_ch); +- else if (ipu_plane->next_buf >= 0) +- return ipu_idmac_get_current_buffer(ipu_plane->ipu_ch) != +- ipu_plane->next_buf; + ++ /* ++ * Pretend no update is pending in the non-PRE/PRG case. For this to ++ * happen, an atomic update would have to be deferred until after the ++ * start of the next frame and simultaneously interrupt latency would ++ * have to be high enough to let the atomic update finish and issue an ++ * event before the previous end of frame interrupt handler can be ++ * executed. ++ */ + return false; + } + int ipu_planes_assign_pre(struct drm_device *dev, +diff --git a/drivers/gpu/drm/imx/ipuv3-plane.h b/drivers/gpu/drm/imx/ipuv3-plane.h +index 15e85e15d35c..ffacbcdd2f98 100644 +--- a/drivers/gpu/drm/imx/ipuv3-plane.h ++++ b/drivers/gpu/drm/imx/ipuv3-plane.h +@@ -27,7 +27,6 @@ struct ipu_plane { + int dp_flow; + + bool disabling; +- int next_buf; + }; + + struct ipu_plane *ipu_plane_init(struct drm_device *dev, struct ipu_soc *ipu, +diff --git a/drivers/gpu/drm/nouveau/include/nvkm/subdev/i2c.h b/drivers/gpu/drm/nouveau/include/nvkm/subdev/i2c.h +index eef54e9b5d77..7957eafa5f0e 100644 +--- a/drivers/gpu/drm/nouveau/include/nvkm/subdev/i2c.h ++++ b/drivers/gpu/drm/nouveau/include/nvkm/subdev/i2c.h +@@ -38,6 +38,7 @@ struct nvkm_i2c_bus { + struct mutex mutex; + struct list_head head; + struct i2c_adapter i2c; ++ u8 enabled; + }; + + int nvkm_i2c_bus_acquire(struct nvkm_i2c_bus *); +@@ -57,6 +58,7 @@ struct nvkm_i2c_aux { + struct mutex mutex; + struct list_head head; + struct i2c_adapter i2c; ++ u8 enabled; + + u32 intr; + }; +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.c +index 4c1f547da463..b4e7404fe660 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.c +@@ -105,9 +105,15 @@ nvkm_i2c_aux_acquire(struct nvkm_i2c_aux *aux) + { + struct nvkm_i2c_pad *pad = aux->pad; + int ret; ++ + AUX_TRACE(aux, "acquire"); + mutex_lock(&aux->mutex); +- ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_AUX); ++ ++ if (aux->enabled) ++ ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_AUX); ++ else ++ ret = -EIO; ++ + if (ret) + mutex_unlock(&aux->mutex); + return ret; +@@ -145,6 +151,24 @@ nvkm_i2c_aux_del(struct nvkm_i2c_aux **paux) + } + } + ++void ++nvkm_i2c_aux_init(struct nvkm_i2c_aux *aux) ++{ ++ AUX_TRACE(aux, "init"); ++ mutex_lock(&aux->mutex); ++ aux->enabled = true; ++ mutex_unlock(&aux->mutex); ++} ++ ++void ++nvkm_i2c_aux_fini(struct nvkm_i2c_aux *aux) ++{ ++ AUX_TRACE(aux, "fini"); ++ mutex_lock(&aux->mutex); ++ aux->enabled = false; ++ mutex_unlock(&aux->mutex); ++} ++ + int + nvkm_i2c_aux_ctor(const struct nvkm_i2c_aux_func *func, + struct nvkm_i2c_pad *pad, int id, +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.h b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.h +index 7d56c4ba693c..08f6b2ee64ab 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.h ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.h +@@ -16,6 +16,8 @@ int nvkm_i2c_aux_ctor(const struct nvkm_i2c_aux_func *, struct nvkm_i2c_pad *, + int nvkm_i2c_aux_new_(const struct nvkm_i2c_aux_func *, struct nvkm_i2c_pad *, + int id, struct nvkm_i2c_aux **); + void nvkm_i2c_aux_del(struct nvkm_i2c_aux **); ++void nvkm_i2c_aux_init(struct nvkm_i2c_aux *); ++void nvkm_i2c_aux_fini(struct nvkm_i2c_aux *); + int nvkm_i2c_aux_xfer(struct nvkm_i2c_aux *, bool retry, u8 type, + u32 addr, u8 *data, u8 *size); + +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c +index 4f197b15acf6..ecacb22834d7 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c +@@ -160,8 +160,18 @@ nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend) + { + struct nvkm_i2c *i2c = nvkm_i2c(subdev); + struct nvkm_i2c_pad *pad; ++ struct nvkm_i2c_bus *bus; ++ struct nvkm_i2c_aux *aux; + u32 mask; + ++ list_for_each_entry(aux, &i2c->aux, head) { ++ nvkm_i2c_aux_fini(aux); ++ } ++ ++ list_for_each_entry(bus, &i2c->bus, head) { ++ nvkm_i2c_bus_fini(bus); ++ } ++ + if ((mask = (1 << i2c->func->aux) - 1), i2c->func->aux_stat) { + i2c->func->aux_mask(i2c, NVKM_I2C_ANY, mask, 0); + i2c->func->aux_stat(i2c, &mask, &mask, &mask, &mask); +@@ -180,6 +190,7 @@ nvkm_i2c_init(struct nvkm_subdev *subdev) + struct nvkm_i2c *i2c = nvkm_i2c(subdev); + struct nvkm_i2c_bus *bus; + struct nvkm_i2c_pad *pad; ++ struct nvkm_i2c_aux *aux; + + list_for_each_entry(pad, &i2c->pad, head) { + nvkm_i2c_pad_init(pad); +@@ -189,6 +200,10 @@ nvkm_i2c_init(struct nvkm_subdev *subdev) + nvkm_i2c_bus_init(bus); + } + ++ list_for_each_entry(aux, &i2c->aux, head) { ++ nvkm_i2c_aux_init(aux); ++ } ++ + return 0; + } + +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.c +index 807a2b67bd64..ed50cc3736b9 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.c +@@ -110,6 +110,19 @@ nvkm_i2c_bus_init(struct nvkm_i2c_bus *bus) + BUS_TRACE(bus, "init"); + if (bus->func->init) + bus->func->init(bus); ++ ++ mutex_lock(&bus->mutex); ++ bus->enabled = true; ++ mutex_unlock(&bus->mutex); ++} ++ ++void ++nvkm_i2c_bus_fini(struct nvkm_i2c_bus *bus) ++{ ++ BUS_TRACE(bus, "fini"); ++ mutex_lock(&bus->mutex); ++ bus->enabled = false; ++ mutex_unlock(&bus->mutex); + } + + void +@@ -126,9 +139,15 @@ nvkm_i2c_bus_acquire(struct nvkm_i2c_bus *bus) + { + struct nvkm_i2c_pad *pad = bus->pad; + int ret; ++ + BUS_TRACE(bus, "acquire"); + mutex_lock(&bus->mutex); +- ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_I2C); ++ ++ if (bus->enabled) ++ ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_I2C); ++ else ++ ret = -EIO; ++ + if (ret) + mutex_unlock(&bus->mutex); + return ret; +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.h b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.h +index bea0dd33961e..465464bba58b 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.h ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bus.h +@@ -18,6 +18,7 @@ int nvkm_i2c_bus_new_(const struct nvkm_i2c_bus_func *, struct nvkm_i2c_pad *, + int id, struct nvkm_i2c_bus **); + void nvkm_i2c_bus_del(struct nvkm_i2c_bus **); + void nvkm_i2c_bus_init(struct nvkm_i2c_bus *); ++void nvkm_i2c_bus_fini(struct nvkm_i2c_bus *); + + int nvkm_i2c_bit_xfer(struct nvkm_i2c_bus *, struct i2c_msg *, int); + +diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c +index d7fa17f12769..8ddb0c0e4bff 100644 +--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c ++++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c +@@ -448,6 +448,14 @@ static int rockchip_drm_platform_remove(struct platform_device *pdev) + return 0; + } + ++static void rockchip_drm_platform_shutdown(struct platform_device *pdev) ++{ ++ struct drm_device *drm = platform_get_drvdata(pdev); ++ ++ if (drm) ++ drm_atomic_helper_shutdown(drm); ++} ++ + static const struct of_device_id rockchip_drm_dt_ids[] = { + { .compatible = "rockchip,display-subsystem", }, + { /* sentinel */ }, +@@ -457,6 +465,7 @@ MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids); + static struct platform_driver rockchip_drm_platform_driver = { + .probe = rockchip_drm_platform_probe, + .remove = rockchip_drm_platform_remove, ++ .shutdown = rockchip_drm_platform_shutdown, + .driver = { + .name = "rockchip-drm", + .of_match_table = rockchip_drm_dt_ids, +diff --git a/drivers/gpu/drm/sun4i/sun8i_hdmi_phy.c b/drivers/gpu/drm/sun4i/sun8i_hdmi_phy.c +index 66ea3a902e36..43643ad31730 100644 +--- a/drivers/gpu/drm/sun4i/sun8i_hdmi_phy.c ++++ b/drivers/gpu/drm/sun4i/sun8i_hdmi_phy.c +@@ -293,7 +293,8 @@ static int sun8i_hdmi_phy_config_h3(struct dw_hdmi *hdmi, + SUN8I_HDMI_PHY_ANA_CFG2_REG_BIGSW | + SUN8I_HDMI_PHY_ANA_CFG2_REG_SLV(4); + ana_cfg3_init |= SUN8I_HDMI_PHY_ANA_CFG3_REG_AMPCK(9) | +- SUN8I_HDMI_PHY_ANA_CFG3_REG_AMP(13); ++ SUN8I_HDMI_PHY_ANA_CFG3_REG_AMP(13) | ++ SUN8I_HDMI_PHY_ANA_CFG3_REG_EMP(3); + } + + regmap_update_bits(phy->regs, SUN8I_HDMI_PHY_ANA_CFG1_REG, +@@ -672,22 +673,13 @@ int sun8i_hdmi_phy_probe(struct sun8i_dw_hdmi *hdmi, struct device_node *node) + goto err_put_clk_pll0; + } + } +- +- ret = sun8i_phy_clk_create(phy, dev, +- phy->variant->has_second_pll); +- if (ret) { +- dev_err(dev, "Couldn't create the PHY clock\n"); +- goto err_put_clk_pll1; +- } +- +- clk_prepare_enable(phy->clk_phy); + } + + phy->rst_phy = of_reset_control_get_shared(node, "phy"); + if (IS_ERR(phy->rst_phy)) { + dev_err(dev, "Could not get phy reset control\n"); + ret = PTR_ERR(phy->rst_phy); +- goto err_disable_clk_phy; ++ goto err_put_clk_pll1; + } + + ret = reset_control_deassert(phy->rst_phy); +@@ -708,18 +700,29 @@ int sun8i_hdmi_phy_probe(struct sun8i_dw_hdmi *hdmi, struct device_node *node) + goto err_disable_clk_bus; + } + ++ if (phy->variant->has_phy_clk) { ++ ret = sun8i_phy_clk_create(phy, dev, ++ phy->variant->has_second_pll); ++ if (ret) { ++ dev_err(dev, "Couldn't create the PHY clock\n"); ++ goto err_disable_clk_mod; ++ } ++ ++ clk_prepare_enable(phy->clk_phy); ++ } ++ + hdmi->phy = phy; + + return 0; + ++err_disable_clk_mod: ++ clk_disable_unprepare(phy->clk_mod); + err_disable_clk_bus: + clk_disable_unprepare(phy->clk_bus); + err_deassert_rst_phy: + reset_control_assert(phy->rst_phy); + err_put_rst_phy: + reset_control_put(phy->rst_phy); +-err_disable_clk_phy: +- clk_disable_unprepare(phy->clk_phy); + err_put_clk_pll1: + clk_put(phy->clk_pll1); + err_put_clk_pll0: +diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c +index 4f80100ff5f3..4cce11fd8836 100644 +--- a/drivers/gpu/drm/tegra/gem.c ++++ b/drivers/gpu/drm/tegra/gem.c +@@ -204,7 +204,7 @@ static void tegra_bo_free(struct drm_device *drm, struct tegra_bo *bo) + { + if (bo->pages) { + dma_unmap_sg(drm->dev, bo->sgt->sgl, bo->sgt->nents, +- DMA_BIDIRECTIONAL); ++ DMA_FROM_DEVICE); + drm_gem_put_pages(&bo->gem, bo->pages, true, true); + sg_free_table(bo->sgt); + kfree(bo->sgt); +@@ -230,7 +230,7 @@ static int tegra_bo_get_pages(struct drm_device *drm, struct tegra_bo *bo) + } + + err = dma_map_sg(drm->dev, bo->sgt->sgl, bo->sgt->nents, +- DMA_BIDIRECTIONAL); ++ DMA_FROM_DEVICE); + if (err == 0) { + err = -EFAULT; + goto free_sgt; +diff --git a/drivers/gpu/drm/vmwgfx/ttm_object.c b/drivers/gpu/drm/vmwgfx/ttm_object.c +index 36990b80e790..16077785ad47 100644 +--- a/drivers/gpu/drm/vmwgfx/ttm_object.c ++++ b/drivers/gpu/drm/vmwgfx/ttm_object.c +@@ -174,7 +174,7 @@ int ttm_base_object_init(struct ttm_object_file *tfile, + kref_init(&base->refcount); + idr_preload(GFP_KERNEL); + spin_lock(&tdev->object_lock); +- ret = idr_alloc(&tdev->idr, base, 0, 0, GFP_NOWAIT); ++ ret = idr_alloc(&tdev->idr, base, 1, 0, GFP_NOWAIT); + spin_unlock(&tdev->object_lock); + idr_preload_end(); + if (ret < 0) +diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c +index 1bfa353d995c..9d2e1ce5c0a6 100644 +--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c ++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c +@@ -1240,7 +1240,13 @@ static int vmw_master_set(struct drm_device *dev, + } + + dev_priv->active_master = vmaster; +- drm_sysfs_hotplug_event(dev); ++ ++ /* ++ * Inform a new master that the layout may have changed while ++ * it was gone. ++ */ ++ if (!from_open) ++ drm_sysfs_hotplug_event(dev); + + return 0; + } +diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c +index 88b8178d4687..c0231a817d3b 100644 +--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c ++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c +@@ -2129,6 +2129,11 @@ static int vmw_cmd_set_shader(struct vmw_private *dev_priv, + return 0; + + if (cmd->body.shid != SVGA3D_INVALID_ID) { ++ /* ++ * This is the compat shader path - Per device guest-backed ++ * shaders, but user-space thinks it's per context host- ++ * backed shaders. ++ */ + res = vmw_shader_lookup(vmw_context_res_man(ctx), + cmd->body.shid, + cmd->body.type); +@@ -2137,6 +2142,14 @@ static int vmw_cmd_set_shader(struct vmw_private *dev_priv, + ret = vmw_execbuf_res_noctx_val_add(sw_context, res); + if (unlikely(ret != 0)) + return ret; ++ ++ ret = vmw_resource_relocation_add ++ (sw_context, res, ++ vmw_ptr_diff(sw_context->buf_start, ++ &cmd->body.shid), ++ vmw_res_rel_normal); ++ if (unlikely(ret != 0)) ++ return ret; + } + } + +diff --git a/drivers/i2c/busses/i2c-mlxcpld.c b/drivers/i2c/busses/i2c-mlxcpld.c +index 745ed43a22d6..2fd717d8dd30 100644 +--- a/drivers/i2c/busses/i2c-mlxcpld.c ++++ b/drivers/i2c/busses/i2c-mlxcpld.c +@@ -503,6 +503,7 @@ static int mlxcpld_i2c_probe(struct platform_device *pdev) + platform_set_drvdata(pdev, priv); + + priv->dev = &pdev->dev; ++ priv->base_addr = MLXPLAT_CPLD_LPC_I2C_BASE_ADDR; + + /* Register with i2c layer */ + mlxcpld_i2c_adapter.timeout = usecs_to_jiffies(MLXCPLD_I2C_XFER_TO); +@@ -518,7 +519,6 @@ static int mlxcpld_i2c_probe(struct platform_device *pdev) + mlxcpld_i2c_adapter.nr = pdev->id; + priv->adap = mlxcpld_i2c_adapter; + priv->adap.dev.parent = &pdev->dev; +- priv->base_addr = MLXPLAT_CPLD_LPC_I2C_BASE_ADDR; + i2c_set_adapdata(&priv->adap, priv); + + err = i2c_add_numbered_adapter(&priv->adap); +diff --git a/drivers/i2c/busses/i2c-synquacer.c b/drivers/i2c/busses/i2c-synquacer.c +index f14d4b3fab44..f724c8e6b360 100644 +--- a/drivers/i2c/busses/i2c-synquacer.c ++++ b/drivers/i2c/busses/i2c-synquacer.c +@@ -351,7 +351,7 @@ static int synquacer_i2c_doxfer(struct synquacer_i2c *i2c, + /* wait 2 clock periods to ensure the stop has been through the bus */ + udelay(DIV_ROUND_UP(2 * 1000, i2c->speed_khz)); + +- return 0; ++ return ret; + } + + static irqreturn_t synquacer_i2c_isr(int irq, void *dev_id) +diff --git a/drivers/iio/adc/npcm_adc.c b/drivers/iio/adc/npcm_adc.c +index 9e25bbec9c70..193b3b81de4d 100644 +--- a/drivers/iio/adc/npcm_adc.c ++++ b/drivers/iio/adc/npcm_adc.c +@@ -149,7 +149,7 @@ static int npcm_adc_read_raw(struct iio_dev *indio_dev, + } + return IIO_VAL_INT; + case IIO_CHAN_INFO_SCALE: +- if (info->vref) { ++ if (!IS_ERR(info->vref)) { + vref_uv = regulator_get_voltage(info->vref); + *val = vref_uv / 1000; + } else { +diff --git a/drivers/iio/adc/ti-ads124s08.c b/drivers/iio/adc/ti-ads124s08.c +index 53f17e4f2f23..552c2be8d87a 100644 +--- a/drivers/iio/adc/ti-ads124s08.c ++++ b/drivers/iio/adc/ti-ads124s08.c +@@ -202,7 +202,7 @@ static int ads124s_read(struct iio_dev *indio_dev, unsigned int chan) + }; + + priv->data[0] = ADS124S08_CMD_RDATA; +- memset(&priv->data[1], ADS124S08_CMD_NOP, sizeof(priv->data)); ++ memset(&priv->data[1], ADS124S08_CMD_NOP, sizeof(priv->data) - 1); + + ret = spi_sync_transfer(priv->spi, t, ARRAY_SIZE(t)); + if (ret < 0) +diff --git a/drivers/iio/adc/ti-ads8688.c b/drivers/iio/adc/ti-ads8688.c +index 8b4568edd5cb..7f16c77b99fb 100644 +--- a/drivers/iio/adc/ti-ads8688.c ++++ b/drivers/iio/adc/ti-ads8688.c +@@ -397,7 +397,7 @@ static irqreturn_t ads8688_trigger_handler(int irq, void *p) + } + + iio_push_to_buffers_with_timestamp(indio_dev, buffer, +- pf->timestamp); ++ iio_get_time_ns(indio_dev)); + + iio_trigger_notify_done(indio_dev->trig); + +diff --git a/drivers/iio/dac/ds4424.c b/drivers/iio/dac/ds4424.c +index 883a47562055..714a97f91319 100644 +--- a/drivers/iio/dac/ds4424.c ++++ b/drivers/iio/dac/ds4424.c +@@ -166,7 +166,7 @@ static int ds4424_verify_chip(struct iio_dev *indio_dev) + { + int ret, val; + +- ret = ds4424_get_value(indio_dev, &val, DS4424_DAC_ADDR(0)); ++ ret = ds4424_get_value(indio_dev, &val, 0); + if (ret < 0) + dev_err(&indio_dev->dev, + "%s failed. ret: %d\n", __func__, ret); +diff --git a/drivers/media/usb/siano/smsusb.c b/drivers/media/usb/siano/smsusb.c +index 4fc03ec8a4f1..e39f3f40dfdd 100644 +--- a/drivers/media/usb/siano/smsusb.c ++++ b/drivers/media/usb/siano/smsusb.c +@@ -400,6 +400,7 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id) + struct smsusb_device_t *dev; + void *mdev; + int i, rc; ++ int align = 0; + + /* create device object */ + dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL); +@@ -411,6 +412,24 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id) + dev->udev = interface_to_usbdev(intf); + dev->state = SMSUSB_DISCONNECTED; + ++ for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { ++ struct usb_endpoint_descriptor *desc = ++ &intf->cur_altsetting->endpoint[i].desc; ++ ++ if (desc->bEndpointAddress & USB_DIR_IN) { ++ dev->in_ep = desc->bEndpointAddress; ++ align = usb_endpoint_maxp(desc) - sizeof(struct sms_msg_hdr); ++ } else { ++ dev->out_ep = desc->bEndpointAddress; ++ } ++ } ++ ++ pr_debug("in_ep = %02x, out_ep = %02x\n", dev->in_ep, dev->out_ep); ++ if (!dev->in_ep || !dev->out_ep || align < 0) { /* Missing endpoints? */ ++ smsusb_term_device(intf); ++ return -ENODEV; ++ } ++ + params.device_type = sms_get_board(board_id)->type; + + switch (params.device_type) { +@@ -425,24 +444,12 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id) + /* fall-thru */ + default: + dev->buffer_size = USB2_BUFFER_SIZE; +- dev->response_alignment = +- le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) - +- sizeof(struct sms_msg_hdr); ++ dev->response_alignment = align; + + params.flags |= SMS_DEVICE_FAMILY2; + break; + } + +- for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) { +- if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN) +- dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress; +- else +- dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress; +- } +- +- pr_debug("in_ep = %02x, out_ep = %02x\n", +- dev->in_ep, dev->out_ep); +- + params.device = &dev->udev->dev; + params.usb_device = dev->udev; + params.buffer_size = dev->buffer_size; +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.c +index 73d3c1a0a7c9..98b168736df0 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.c +@@ -490,11 +490,18 @@ fail: + return -ENOMEM; + } + +-void brcmf_proto_bcdc_detach(struct brcmf_pub *drvr) ++void brcmf_proto_bcdc_detach_pre_delif(struct brcmf_pub *drvr) ++{ ++ struct brcmf_bcdc *bcdc = drvr->proto->pd; ++ ++ brcmf_fws_detach_pre_delif(bcdc->fws); ++} ++ ++void brcmf_proto_bcdc_detach_post_delif(struct brcmf_pub *drvr) + { + struct brcmf_bcdc *bcdc = drvr->proto->pd; + + drvr->proto->pd = NULL; +- brcmf_fws_detach(bcdc->fws); ++ brcmf_fws_detach_post_delif(bcdc->fws); + kfree(bcdc); + } +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.h b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.h +index 3b0e9eff21b5..4bc52240ccea 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.h ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcdc.h +@@ -18,14 +18,16 @@ + + #ifdef CONFIG_BRCMFMAC_PROTO_BCDC + int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr); +-void brcmf_proto_bcdc_detach(struct brcmf_pub *drvr); ++void brcmf_proto_bcdc_detach_pre_delif(struct brcmf_pub *drvr); ++void brcmf_proto_bcdc_detach_post_delif(struct brcmf_pub *drvr); + void brcmf_proto_bcdc_txflowblock(struct device *dev, bool state); + void brcmf_proto_bcdc_txcomplete(struct device *dev, struct sk_buff *txp, + bool success); + struct brcmf_fws_info *drvr_to_fws(struct brcmf_pub *drvr); + #else + static inline int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr) { return 0; } +-static inline void brcmf_proto_bcdc_detach(struct brcmf_pub *drvr) {} ++static void brcmf_proto_bcdc_detach_pre_delif(struct brcmf_pub *drvr) {}; ++static inline void brcmf_proto_bcdc_detach_post_delif(struct brcmf_pub *drvr) {} + #endif + + #endif /* BRCMFMAC_BCDC_H */ +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c +index 24ed19ed116e..52da307087e1 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c +@@ -1303,6 +1303,8 @@ void brcmf_detach(struct device *dev) + + brcmf_bus_change_state(bus_if, BRCMF_BUS_DOWN); + ++ brcmf_proto_detach_pre_delif(drvr); ++ + /* make sure primary interface removed last */ + for (i = BRCMF_MAX_IFS-1; i > -1; i--) + brcmf_remove_interface(drvr->iflist[i], false); +@@ -1312,7 +1314,7 @@ void brcmf_detach(struct device *dev) + + brcmf_bus_stop(drvr->bus_if); + +- brcmf_proto_detach(drvr); ++ brcmf_proto_detach_post_delif(drvr); + + bus_if->drvr = NULL; + wiphy_free(drvr->wiphy); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c +index d48b8b2d946f..c22c49ae552e 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.c +@@ -2443,17 +2443,25 @@ struct brcmf_fws_info *brcmf_fws_attach(struct brcmf_pub *drvr) + return fws; + + fail: +- brcmf_fws_detach(fws); ++ brcmf_fws_detach_pre_delif(fws); ++ brcmf_fws_detach_post_delif(fws); + return ERR_PTR(rc); + } + +-void brcmf_fws_detach(struct brcmf_fws_info *fws) ++void brcmf_fws_detach_pre_delif(struct brcmf_fws_info *fws) + { + if (!fws) + return; +- +- if (fws->fws_wq) ++ if (fws->fws_wq) { + destroy_workqueue(fws->fws_wq); ++ fws->fws_wq = NULL; ++ } ++} ++ ++void brcmf_fws_detach_post_delif(struct brcmf_fws_info *fws) ++{ ++ if (!fws) ++ return; + + /* cleanup */ + brcmf_fws_lock(fws); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.h b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.h +index 4e6835766d5d..749c06dcdc17 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.h ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwsignal.h +@@ -19,7 +19,8 @@ + #define FWSIGNAL_H_ + + struct brcmf_fws_info *brcmf_fws_attach(struct brcmf_pub *drvr); +-void brcmf_fws_detach(struct brcmf_fws_info *fws); ++void brcmf_fws_detach_pre_delif(struct brcmf_fws_info *fws); ++void brcmf_fws_detach_post_delif(struct brcmf_fws_info *fws); + void brcmf_fws_debugfs_create(struct brcmf_pub *drvr); + bool brcmf_fws_queue_skbs(struct brcmf_fws_info *fws); + bool brcmf_fws_fc_active(struct brcmf_fws_info *fws); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.c +index 024c643052bc..c7964ccdda69 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.c +@@ -67,16 +67,22 @@ fail: + return -ENOMEM; + } + +-void brcmf_proto_detach(struct brcmf_pub *drvr) ++void brcmf_proto_detach_post_delif(struct brcmf_pub *drvr) + { + brcmf_dbg(TRACE, "Enter\n"); + + if (drvr->proto) { + if (drvr->bus_if->proto_type == BRCMF_PROTO_BCDC) +- brcmf_proto_bcdc_detach(drvr); ++ brcmf_proto_bcdc_detach_post_delif(drvr); + else if (drvr->bus_if->proto_type == BRCMF_PROTO_MSGBUF) + brcmf_proto_msgbuf_detach(drvr); + kfree(drvr->proto); + drvr->proto = NULL; + } + } ++ ++void brcmf_proto_detach_pre_delif(struct brcmf_pub *drvr) ++{ ++ if (drvr->proto && drvr->bus_if->proto_type == BRCMF_PROTO_BCDC) ++ brcmf_proto_bcdc_detach_pre_delif(drvr); ++} +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.h b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.h +index d3c3b9a815ad..72355aea9028 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.h ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/proto.h +@@ -54,7 +54,8 @@ struct brcmf_proto { + + + int brcmf_proto_attach(struct brcmf_pub *drvr); +-void brcmf_proto_detach(struct brcmf_pub *drvr); ++void brcmf_proto_detach_pre_delif(struct brcmf_pub *drvr); ++void brcmf_proto_detach_post_delif(struct brcmf_pub *drvr); + + static inline int brcmf_proto_hdrpull(struct brcmf_pub *drvr, bool do_fws, + struct sk_buff *skb, +diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h +index c6acca521ffe..31e8a7240fd7 100644 +--- a/drivers/s390/scsi/zfcp_ext.h ++++ b/drivers/s390/scsi/zfcp_ext.h +@@ -167,6 +167,7 @@ extern const struct attribute_group *zfcp_port_attr_groups[]; + extern struct mutex zfcp_sysfs_port_units_mutex; + extern struct device_attribute *zfcp_sysfs_sdev_attrs[]; + extern struct device_attribute *zfcp_sysfs_shost_attrs[]; ++bool zfcp_sysfs_port_is_removing(const struct zfcp_port *const port); + + /* zfcp_unit.c */ + extern int zfcp_unit_add(struct zfcp_port *, u64); +diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c +index 221d0dfb8493..e9ded2befa0d 100644 +--- a/drivers/s390/scsi/zfcp_scsi.c ++++ b/drivers/s390/scsi/zfcp_scsi.c +@@ -129,6 +129,15 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev) + + zfcp_sdev->erp_action.port = port; + ++ mutex_lock(&zfcp_sysfs_port_units_mutex); ++ if (zfcp_sysfs_port_is_removing(port)) { ++ /* port is already gone */ ++ mutex_unlock(&zfcp_sysfs_port_units_mutex); ++ put_device(&port->dev); /* undo zfcp_get_port_by_wwpn() */ ++ return -ENXIO; ++ } ++ mutex_unlock(&zfcp_sysfs_port_units_mutex); ++ + unit = zfcp_unit_find(port, zfcp_scsi_dev_lun(sdev)); + if (unit) + put_device(&unit->dev); +diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c +index b277be6f7611..af197e2b3e69 100644 +--- a/drivers/s390/scsi/zfcp_sysfs.c ++++ b/drivers/s390/scsi/zfcp_sysfs.c +@@ -235,6 +235,53 @@ static ZFCP_DEV_ATTR(adapter, port_rescan, S_IWUSR, NULL, + + DEFINE_MUTEX(zfcp_sysfs_port_units_mutex); + ++static void zfcp_sysfs_port_set_removing(struct zfcp_port *const port) ++{ ++ lockdep_assert_held(&zfcp_sysfs_port_units_mutex); ++ atomic_set(&port->units, -1); ++} ++ ++bool zfcp_sysfs_port_is_removing(const struct zfcp_port *const port) ++{ ++ lockdep_assert_held(&zfcp_sysfs_port_units_mutex); ++ return atomic_read(&port->units) == -1; ++} ++ ++static bool zfcp_sysfs_port_in_use(struct zfcp_port *const port) ++{ ++ struct zfcp_adapter *const adapter = port->adapter; ++ unsigned long flags; ++ struct scsi_device *sdev; ++ bool in_use = true; ++ ++ mutex_lock(&zfcp_sysfs_port_units_mutex); ++ if (atomic_read(&port->units) > 0) ++ goto unlock_port_units_mutex; /* zfcp_unit(s) under port */ ++ ++ spin_lock_irqsave(adapter->scsi_host->host_lock, flags); ++ __shost_for_each_device(sdev, adapter->scsi_host) { ++ const struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev); ++ ++ if (sdev->sdev_state == SDEV_DEL || ++ sdev->sdev_state == SDEV_CANCEL) ++ continue; ++ if (zsdev->port != port) ++ continue; ++ /* alive scsi_device under port of interest */ ++ goto unlock_host_lock; ++ } ++ ++ /* port is about to be removed, so no more unit_add or slave_alloc */ ++ zfcp_sysfs_port_set_removing(port); ++ in_use = false; ++ ++unlock_host_lock: ++ spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags); ++unlock_port_units_mutex: ++ mutex_unlock(&zfcp_sysfs_port_units_mutex); ++ return in_use; ++} ++ + static ssize_t zfcp_sysfs_port_remove_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +@@ -257,15 +304,11 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev, + else + retval = 0; + +- mutex_lock(&zfcp_sysfs_port_units_mutex); +- if (atomic_read(&port->units) > 0) { ++ if (zfcp_sysfs_port_in_use(port)) { + retval = -EBUSY; +- mutex_unlock(&zfcp_sysfs_port_units_mutex); ++ put_device(&port->dev); /* undo zfcp_get_port_by_wwpn() */ + goto out; + } +- /* port is about to be removed, so no more unit_add */ +- atomic_set(&port->units, -1); +- mutex_unlock(&zfcp_sysfs_port_units_mutex); + + write_lock_irq(&adapter->port_list_lock); + list_del(&port->list); +diff --git a/drivers/s390/scsi/zfcp_unit.c b/drivers/s390/scsi/zfcp_unit.c +index 1bf0a0984a09..e67bf7388cae 100644 +--- a/drivers/s390/scsi/zfcp_unit.c ++++ b/drivers/s390/scsi/zfcp_unit.c +@@ -124,7 +124,7 @@ int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun) + int retval = 0; + + mutex_lock(&zfcp_sysfs_port_units_mutex); +- if (atomic_read(&port->units) == -1) { ++ if (zfcp_sysfs_port_is_removing(port)) { + /* port is already gone */ + retval = -ENODEV; + goto out; +@@ -168,8 +168,14 @@ int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun) + write_lock_irq(&port->unit_list_lock); + list_add_tail(&unit->list, &port->unit_list); + write_unlock_irq(&port->unit_list_lock); ++ /* ++ * lock order: shost->scan_mutex before zfcp_sysfs_port_units_mutex ++ * due to zfcp_unit_scsi_scan() => zfcp_scsi_slave_alloc() ++ */ ++ mutex_unlock(&zfcp_sysfs_port_units_mutex); + + zfcp_unit_scsi_scan(unit); ++ return retval; + + out: + mutex_unlock(&zfcp_sysfs_port_units_mutex); +diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c +index eb1e5dcb0d52..a9cc01e8e6c5 100644 +--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c ++++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c +@@ -398,9 +398,18 @@ create_pagelist(char __user *buf, size_t count, unsigned short type) + int dma_buffers; + dma_addr_t dma_addr; + ++ if (count >= INT_MAX - PAGE_SIZE) ++ return NULL; ++ + offset = ((unsigned int)(unsigned long)buf & (PAGE_SIZE - 1)); + num_pages = DIV_ROUND_UP(count + offset, PAGE_SIZE); + ++ if (num_pages > (SIZE_MAX - sizeof(struct pagelist) - ++ sizeof(struct vchiq_pagelist_info)) / ++ (sizeof(u32) + sizeof(pages[0]) + ++ sizeof(struct scatterlist))) ++ return NULL; ++ + pagelist_size = sizeof(struct pagelist) + + (num_pages * sizeof(u32)) + + (num_pages * sizeof(pages[0]) + +diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c +index 6261881e9bcd..e359855ff2ad 100644 +--- a/drivers/staging/wlan-ng/hfa384x_usb.c ++++ b/drivers/staging/wlan-ng/hfa384x_usb.c +@@ -3119,7 +3119,9 @@ static void hfa384x_usbin_callback(struct urb *urb) + break; + } + ++ /* Save values from the RX URB before reposting overwrites it. */ + urb_status = urb->status; ++ usbin = (union hfa384x_usbin *)urb->transfer_buffer; + + if (action != ABORT) { + /* Repost the RX URB */ +@@ -3136,7 +3138,6 @@ static void hfa384x_usbin_callback(struct urb *urb) + /* Note: the check of the sw_support field, the type field doesn't + * have bit 12 set like the docs suggest. + */ +- usbin = (union hfa384x_usbin *)urb->transfer_buffer; + type = le16_to_cpu(usbin->type); + if (HFA384x_USB_ISRXFRM(type)) { + if (action == HANDLE) { +diff --git a/drivers/tty/serial/max310x.c b/drivers/tty/serial/max310x.c +index 450ba6d7996c..e5aebbf5f302 100644 +--- a/drivers/tty/serial/max310x.c ++++ b/drivers/tty/serial/max310x.c +@@ -581,7 +581,7 @@ static int max310x_set_ref_clk(struct device *dev, struct max310x_port *s, + } + + /* Configure clock source */ +- clksrc = xtal ? MAX310X_CLKSRC_CRYST_BIT : MAX310X_CLKSRC_EXTCLK_BIT; ++ clksrc = MAX310X_CLKSRC_EXTCLK_BIT | (xtal ? MAX310X_CLKSRC_CRYST_BIT : 0); + + /* Configure PLL */ + if (pllcfg) { +diff --git a/drivers/tty/serial/msm_serial.c b/drivers/tty/serial/msm_serial.c +index 109096033bb1..23833ad952ba 100644 +--- a/drivers/tty/serial/msm_serial.c ++++ b/drivers/tty/serial/msm_serial.c +@@ -860,6 +860,7 @@ static void msm_handle_tx(struct uart_port *port) + struct circ_buf *xmit = &msm_port->uart.state->xmit; + struct msm_dma *dma = &msm_port->tx_dma; + unsigned int pio_count, dma_count, dma_min; ++ char buf[4] = { 0 }; + void __iomem *tf; + int err = 0; + +@@ -869,10 +870,12 @@ static void msm_handle_tx(struct uart_port *port) + else + tf = port->membase + UART_TF; + ++ buf[0] = port->x_char; ++ + if (msm_port->is_uartdm) + msm_reset_dm_count(port, 1); + +- iowrite8_rep(tf, &port->x_char, 1); ++ iowrite32_rep(tf, buf, 1); + port->icount.tx++; + port->x_char = 0; + return; +diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c +index 3cd139752d3f..abc705716aa0 100644 +--- a/drivers/tty/serial/sh-sci.c ++++ b/drivers/tty/serial/sh-sci.c +@@ -1557,6 +1557,13 @@ static void sci_request_dma(struct uart_port *port) + + dev_dbg(port->dev, "%s: port %d\n", __func__, port->line); + ++ /* ++ * DMA on console may interfere with Kernel log messages which use ++ * plain putchar(). So, simply don't use it with a console. ++ */ ++ if (uart_console(port)) ++ return; ++ + if (!port->dev->of_node) + return; + +diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c +index 693b3b4176f5..9d8aaf9941f9 100644 +--- a/drivers/tty/vt/vt.c ++++ b/drivers/tty/vt/vt.c +@@ -1056,6 +1056,13 @@ static void visual_init(struct vc_data *vc, int num, int init) + vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row; + } + ++ ++static void visual_deinit(struct vc_data *vc) ++{ ++ vc->vc_sw->con_deinit(vc); ++ module_put(vc->vc_sw->owner); ++} ++ + int vc_allocate(unsigned int currcons) /* return 0 on success */ + { + struct vt_notifier_param param; +@@ -1103,6 +1110,7 @@ int vc_allocate(unsigned int currcons) /* return 0 on success */ + + return 0; + err_free: ++ visual_deinit(vc); + kfree(vc); + vc_cons[currcons].d = NULL; + return -ENOMEM; +@@ -1331,9 +1339,8 @@ struct vc_data *vc_deallocate(unsigned int currcons) + param.vc = vc = vc_cons[currcons].d; + atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, ¶m); + vcs_remove_sysfs(currcons); +- vc->vc_sw->con_deinit(vc); ++ visual_deinit(vc); + put_pid(vc->vt_pid); +- module_put(vc->vc_sw->owner); + vc_uniscr_set(vc, NULL); + kfree(vc->vc_screenbuf); + vc_cons[currcons].d = NULL; +diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c +index 20ff036b4c22..9d6cb709ca7b 100644 +--- a/drivers/usb/core/config.c ++++ b/drivers/usb/core/config.c +@@ -932,8 +932,8 @@ int usb_get_bos_descriptor(struct usb_device *dev) + + /* Get BOS descriptor */ + ret = usb_get_descriptor(dev, USB_DT_BOS, 0, bos, USB_DT_BOS_SIZE); +- if (ret < USB_DT_BOS_SIZE) { +- dev_err(ddev, "unable to get BOS descriptor\n"); ++ if (ret < USB_DT_BOS_SIZE || bos->bLength < USB_DT_BOS_SIZE) { ++ dev_err(ddev, "unable to get BOS descriptor or descriptor too short\n"); + if (ret >= 0) + ret = -ENOMSG; + kfree(bos); +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index 8bc35d53408b..6082b008969b 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -209,6 +209,9 @@ static const struct usb_device_id usb_quirk_list[] = { + /* Microsoft LifeCam-VX700 v2.0 */ + { USB_DEVICE(0x045e, 0x0770), .driver_info = USB_QUIRK_RESET_RESUME }, + ++ /* Microsoft Surface Dock Ethernet (RTL8153 GigE) */ ++ { USB_DEVICE(0x045e, 0x07c6), .driver_info = USB_QUIRK_NO_LPM }, ++ + /* Cherry Stream G230 2.0 (G85-231) and 3.0 (G85-232) */ + { USB_DEVICE(0x046a, 0x0023), .driver_info = USB_QUIRK_RESET_RESUME }, + +diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c +index 9215a28dad40..765ef5f1ffb8 100644 +--- a/drivers/usb/host/xhci-ring.c ++++ b/drivers/usb/host/xhci-ring.c +@@ -656,6 +656,7 @@ static void xhci_unmap_td_bounce_buffer(struct xhci_hcd *xhci, + struct device *dev = xhci_to_hcd(xhci)->self.controller; + struct xhci_segment *seg = td->bounce_seg; + struct urb *urb = td->urb; ++ size_t len; + + if (!ring || !seg || !urb) + return; +@@ -666,11 +667,14 @@ static void xhci_unmap_td_bounce_buffer(struct xhci_hcd *xhci, + return; + } + +- /* for in tranfers we need to copy the data from bounce to sg */ +- sg_pcopy_from_buffer(urb->sg, urb->num_mapped_sgs, seg->bounce_buf, +- seg->bounce_len, seg->bounce_offs); + dma_unmap_single(dev, seg->bounce_dma, ring->bounce_buf_len, + DMA_FROM_DEVICE); ++ /* for in tranfers we need to copy the data from bounce to sg */ ++ len = sg_pcopy_from_buffer(urb->sg, urb->num_sgs, seg->bounce_buf, ++ seg->bounce_len, seg->bounce_offs); ++ if (len != seg->bounce_len) ++ xhci_warn(xhci, "WARN Wrong bounce buffer read length: %zu != %d\n", ++ len, seg->bounce_len); + seg->bounce_len = 0; + seg->bounce_offs = 0; + } +@@ -3123,6 +3127,7 @@ static int xhci_align_td(struct xhci_hcd *xhci, struct urb *urb, u32 enqd_len, + unsigned int unalign; + unsigned int max_pkt; + u32 new_buff_len; ++ size_t len; + + max_pkt = usb_endpoint_maxp(&urb->ep->desc); + unalign = (enqd_len + *trb_buff_len) % max_pkt; +@@ -3153,8 +3158,12 @@ static int xhci_align_td(struct xhci_hcd *xhci, struct urb *urb, u32 enqd_len, + + /* create a max max_pkt sized bounce buffer pointed to by last trb */ + if (usb_urb_dir_out(urb)) { +- sg_pcopy_to_buffer(urb->sg, urb->num_mapped_sgs, ++ len = sg_pcopy_to_buffer(urb->sg, urb->num_sgs, + seg->bounce_buf, new_buff_len, enqd_len); ++ if (len != seg->bounce_len) ++ xhci_warn(xhci, ++ "WARN Wrong bounce buffer write length: %zu != %d\n", ++ len, seg->bounce_len); + seg->bounce_dma = dma_map_single(dev, seg->bounce_buf, + max_pkt, DMA_TO_DEVICE); + } else { +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index 7fa58c99f126..448e3f812833 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -9,6 +9,7 @@ + */ + + #include <linux/pci.h> ++#include <linux/iopoll.h> + #include <linux/irq.h> + #include <linux/log2.h> + #include <linux/module.h> +@@ -52,7 +53,6 @@ static bool td_on_ring(struct xhci_td *td, struct xhci_ring *ring) + return false; + } + +-/* TODO: copied from ehci-hcd.c - can this be refactored? */ + /* + * xhci_handshake - spin reading hc until handshake completes or fails + * @ptr: address of hc register to be read +@@ -69,18 +69,16 @@ static bool td_on_ring(struct xhci_td *td, struct xhci_ring *ring) + int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, int usec) + { + u32 result; ++ int ret; + +- do { +- result = readl(ptr); +- if (result == ~(u32)0) /* card removed */ +- return -ENODEV; +- result &= mask; +- if (result == done) +- return 0; +- udelay(1); +- usec--; +- } while (usec > 0); +- return -ETIMEDOUT; ++ ret = readl_poll_timeout_atomic(ptr, result, ++ (result & mask) == done || ++ result == U32_MAX, ++ 1, usec); ++ if (result == U32_MAX) /* card removed */ ++ return -ENODEV; ++ ++ return ret; + } + + /* +@@ -4289,7 +4287,6 @@ static int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd, + pm_addr = ports[port_num]->addr + PORTPMSC; + pm_val = readl(pm_addr); + hlpm_addr = ports[port_num]->addr + PORTHLPMC; +- field = le32_to_cpu(udev->bos->ext_cap->bmAttributes); + + xhci_dbg(xhci, "%s port %d USB2 hardware LPM\n", + enable ? "enable" : "disable", port_num + 1); +@@ -4301,6 +4298,7 @@ static int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd, + * default one which works with mixed HIRD and BESL + * systems. See XHCI_DEFAULT_BESL definition in xhci.h + */ ++ field = le32_to_cpu(udev->bos->ext_cap->bmAttributes); + if ((field & USB_BESL_SUPPORT) && + (field & USB_BESL_BASELINE_VALID)) + hird = USB_GET_BESL_BASELINE(field); +diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c +index 7b9adeb3e7aa..a32d61a79ab8 100644 +--- a/drivers/usb/misc/rio500.c ++++ b/drivers/usb/misc/rio500.c +@@ -86,9 +86,22 @@ static int close_rio(struct inode *inode, struct file *file) + { + struct rio_usb_data *rio = &rio_instance; + +- rio->isopen = 0; ++ /* against disconnect() */ ++ mutex_lock(&rio500_mutex); ++ mutex_lock(&(rio->lock)); + +- dev_info(&rio->rio_dev->dev, "Rio closed.\n"); ++ rio->isopen = 0; ++ if (!rio->present) { ++ /* cleanup has been delayed */ ++ kfree(rio->ibuf); ++ kfree(rio->obuf); ++ rio->ibuf = NULL; ++ rio->obuf = NULL; ++ } else { ++ dev_info(&rio->rio_dev->dev, "Rio closed.\n"); ++ } ++ mutex_unlock(&(rio->lock)); ++ mutex_unlock(&rio500_mutex); + return 0; + } + +@@ -447,15 +460,23 @@ static int probe_rio(struct usb_interface *intf, + { + struct usb_device *dev = interface_to_usbdev(intf); + struct rio_usb_data *rio = &rio_instance; +- int retval; ++ int retval = 0; + +- dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum); ++ mutex_lock(&rio500_mutex); ++ if (rio->present) { ++ dev_info(&intf->dev, "Second USB Rio at address %d refused\n", dev->devnum); ++ retval = -EBUSY; ++ goto bail_out; ++ } else { ++ dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum); ++ } + + retval = usb_register_dev(intf, &usb_rio_class); + if (retval) { + dev_err(&dev->dev, + "Not able to get a minor for this device.\n"); +- return -ENOMEM; ++ retval = -ENOMEM; ++ goto bail_out; + } + + rio->rio_dev = dev; +@@ -464,7 +485,8 @@ static int probe_rio(struct usb_interface *intf, + dev_err(&dev->dev, + "probe_rio: Not enough memory for the output buffer\n"); + usb_deregister_dev(intf, &usb_rio_class); +- return -ENOMEM; ++ retval = -ENOMEM; ++ goto bail_out; + } + dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf); + +@@ -473,7 +495,8 @@ static int probe_rio(struct usb_interface *intf, + "probe_rio: Not enough memory for the input buffer\n"); + usb_deregister_dev(intf, &usb_rio_class); + kfree(rio->obuf); +- return -ENOMEM; ++ retval = -ENOMEM; ++ goto bail_out; + } + dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf); + +@@ -481,8 +504,10 @@ static int probe_rio(struct usb_interface *intf, + + usb_set_intfdata (intf, rio); + rio->present = 1; ++bail_out: ++ mutex_unlock(&rio500_mutex); + +- return 0; ++ return retval; + } + + static void disconnect_rio(struct usb_interface *intf) +diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c +index 9560fde621ee..ea06f1fed6fa 100644 +--- a/drivers/usb/misc/sisusbvga/sisusb.c ++++ b/drivers/usb/misc/sisusbvga/sisusb.c +@@ -3029,6 +3029,13 @@ static int sisusb_probe(struct usb_interface *intf, + + mutex_init(&(sisusb->lock)); + ++ sisusb->sisusb_dev = dev; ++ sisusb->vrambase = SISUSB_PCI_MEMBASE; ++ sisusb->mmiobase = SISUSB_PCI_MMIOBASE; ++ sisusb->mmiosize = SISUSB_PCI_MMIOSIZE; ++ sisusb->ioportbase = SISUSB_PCI_IOPORTBASE; ++ /* Everything else is zero */ ++ + /* Register device */ + retval = usb_register_dev(intf, &usb_sisusb_class); + if (retval) { +@@ -3039,13 +3046,7 @@ static int sisusb_probe(struct usb_interface *intf, + goto error_1; + } + +- sisusb->sisusb_dev = dev; +- sisusb->minor = intf->minor; +- sisusb->vrambase = SISUSB_PCI_MEMBASE; +- sisusb->mmiobase = SISUSB_PCI_MMIOBASE; +- sisusb->mmiosize = SISUSB_PCI_MMIOSIZE; +- sisusb->ioportbase = SISUSB_PCI_IOPORTBASE; +- /* Everything else is zero */ ++ sisusb->minor = intf->minor; + + /* Allocate buffers */ + sisusb->ibufsize = SISUSB_IBUF_SIZE; +diff --git a/drivers/usb/usbip/stub_dev.c b/drivers/usb/usbip/stub_dev.c +index c0d6ff1baa72..7931e6cecc70 100644 +--- a/drivers/usb/usbip/stub_dev.c ++++ b/drivers/usb/usbip/stub_dev.c +@@ -301,9 +301,17 @@ static int stub_probe(struct usb_device *udev) + const char *udev_busid = dev_name(&udev->dev); + struct bus_id_priv *busid_priv; + int rc = 0; ++ char save_status; + + dev_dbg(&udev->dev, "Enter probe\n"); + ++ /* Not sure if this is our device. Allocate here to avoid ++ * calling alloc while holding busid_table lock. ++ */ ++ sdev = stub_device_alloc(udev); ++ if (!sdev) ++ return -ENOMEM; ++ + /* check we should claim or not by busid_table */ + busid_priv = get_busid_priv(udev_busid); + if (!busid_priv || (busid_priv->status == STUB_BUSID_REMOV) || +@@ -318,6 +326,9 @@ static int stub_probe(struct usb_device *udev) + * See driver_probe_device() in driver/base/dd.c + */ + rc = -ENODEV; ++ if (!busid_priv) ++ goto sdev_free; ++ + goto call_put_busid_priv; + } + +@@ -337,12 +348,6 @@ static int stub_probe(struct usb_device *udev) + goto call_put_busid_priv; + } + +- /* ok, this is my device */ +- sdev = stub_device_alloc(udev); +- if (!sdev) { +- rc = -ENOMEM; +- goto call_put_busid_priv; +- } + + dev_info(&udev->dev, + "usbip-host: register new device (bus %u dev %u)\n", +@@ -352,9 +357,16 @@ static int stub_probe(struct usb_device *udev) + + /* set private data to usb_device */ + dev_set_drvdata(&udev->dev, sdev); ++ + busid_priv->sdev = sdev; + busid_priv->udev = udev; + ++ save_status = busid_priv->status; ++ busid_priv->status = STUB_BUSID_ALLOC; ++ ++ /* release the busid_lock */ ++ put_busid_priv(busid_priv); ++ + /* + * Claim this hub port. + * It doesn't matter what value we pass as owner +@@ -372,10 +384,8 @@ static int stub_probe(struct usb_device *udev) + dev_err(&udev->dev, "stub_add_files for %s\n", udev_busid); + goto err_files; + } +- busid_priv->status = STUB_BUSID_ALLOC; + +- rc = 0; +- goto call_put_busid_priv; ++ return 0; + + err_files: + usb_hub_release_port(udev->parent, udev->portnum, +@@ -384,23 +394,30 @@ err_port: + dev_set_drvdata(&udev->dev, NULL); + usb_put_dev(udev); + ++ /* we already have busid_priv, just lock busid_lock */ ++ spin_lock(&busid_priv->busid_lock); + busid_priv->sdev = NULL; +- stub_device_free(sdev); ++ busid_priv->status = save_status; ++ spin_unlock(&busid_priv->busid_lock); ++ /* lock is released - go to free */ ++ goto sdev_free; + + call_put_busid_priv: ++ /* release the busid_lock */ + put_busid_priv(busid_priv); ++ ++sdev_free: ++ stub_device_free(sdev); ++ + return rc; + } + + static void shutdown_busid(struct bus_id_priv *busid_priv) + { +- if (busid_priv->sdev && !busid_priv->shutdown_busid) { +- busid_priv->shutdown_busid = 1; +- usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED); ++ usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED); + +- /* wait for the stop of the event handler */ +- usbip_stop_eh(&busid_priv->sdev->ud); +- } ++ /* wait for the stop of the event handler */ ++ usbip_stop_eh(&busid_priv->sdev->ud); + } + + /* +@@ -427,11 +444,16 @@ static void stub_disconnect(struct usb_device *udev) + /* get stub_device */ + if (!sdev) { + dev_err(&udev->dev, "could not get device"); +- goto call_put_busid_priv; ++ /* release busid_lock */ ++ put_busid_priv(busid_priv); ++ return; + } + + dev_set_drvdata(&udev->dev, NULL); + ++ /* release busid_lock before call to remove device files */ ++ put_busid_priv(busid_priv); ++ + /* + * NOTE: rx/tx threads are invoked for each usb_device. + */ +@@ -442,27 +464,36 @@ static void stub_disconnect(struct usb_device *udev) + (struct usb_dev_state *) udev); + if (rc) { + dev_dbg(&udev->dev, "unable to release port\n"); +- goto call_put_busid_priv; ++ return; + } + + /* If usb reset is called from event handler */ + if (usbip_in_eh(current)) +- goto call_put_busid_priv; ++ return; ++ ++ /* we already have busid_priv, just lock busid_lock */ ++ spin_lock(&busid_priv->busid_lock); ++ if (!busid_priv->shutdown_busid) ++ busid_priv->shutdown_busid = 1; ++ /* release busid_lock */ ++ spin_unlock(&busid_priv->busid_lock); + + /* shutdown the current connection */ + shutdown_busid(busid_priv); + + usb_put_dev(sdev->udev); + ++ /* we already have busid_priv, just lock busid_lock */ ++ spin_lock(&busid_priv->busid_lock); + /* free sdev */ + busid_priv->sdev = NULL; + stub_device_free(sdev); + + if (busid_priv->status == STUB_BUSID_ALLOC) + busid_priv->status = STUB_BUSID_ADDED; +- +-call_put_busid_priv: +- put_busid_priv(busid_priv); ++ /* release busid_lock */ ++ spin_unlock(&busid_priv->busid_lock); ++ return; + } + + #ifdef CONFIG_PM +diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c +index cd059a801662..c59b23f6e9ba 100644 +--- a/drivers/video/fbdev/core/fbcon.c ++++ b/drivers/video/fbdev/core/fbcon.c +@@ -1248,7 +1248,7 @@ finished: + if (free_font) + vc->vc_font.data = NULL; + +- if (vc->vc_hi_font_mask) ++ if (vc->vc_hi_font_mask && vc->vc_screenbuf) + set_vc_hi_font(vc, false); + + if (!con_is_bound(&fb_con)) +diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c +index 2973608824ec..adb660669ff5 100644 +--- a/fs/btrfs/inode.c ++++ b/fs/btrfs/inode.c +@@ -6396,8 +6396,18 @@ int btrfs_add_link(struct btrfs_trans_handle *trans, + btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size + + name_len * 2); + inode_inc_iversion(&parent_inode->vfs_inode); +- parent_inode->vfs_inode.i_mtime = parent_inode->vfs_inode.i_ctime = +- current_time(&parent_inode->vfs_inode); ++ /* ++ * If we are replaying a log tree, we do not want to update the mtime ++ * and ctime of the parent directory with the current time, since the ++ * log replay procedure is responsible for setting them to their correct ++ * values (the ones it had when the fsync was done). ++ */ ++ if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) { ++ struct timespec64 now = current_time(&parent_inode->vfs_inode); ++ ++ parent_inode->vfs_inode.i_mtime = now; ++ parent_inode->vfs_inode.i_ctime = now; ++ } + ret = btrfs_update_inode(trans, root, &parent_inode->vfs_inode); + if (ret) + btrfs_abort_transaction(trans, ret); +diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c +index e659d9d61107..3ecaab8cca06 100644 +--- a/fs/btrfs/qgroup.c ++++ b/fs/btrfs/qgroup.c +@@ -3831,7 +3831,13 @@ int btrfs_qgroup_add_swapped_blocks(struct btrfs_trans_handle *trans, + subvol_slot); + block->last_snapshot = last_snapshot; + block->level = level; +- if (bg->flags & BTRFS_BLOCK_GROUP_DATA) ++ ++ /* ++ * If we have bg == NULL, we're called from btrfs_recover_relocation(), ++ * no one else can modify tree blocks thus we qgroup will not change ++ * no matter the value of trace_leaf. ++ */ ++ if (bg && bg->flags & BTRFS_BLOCK_GROUP_DATA) + block->trace_leaf = true; + else + block->trace_leaf = false; +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 1d82ee4883eb..b0f9cca8e8d4 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -2161,22 +2161,30 @@ static int clean_dirty_subvols(struct reloc_control *rc) + struct btrfs_root *root; + struct btrfs_root *next; + int ret = 0; ++ int ret2; + + list_for_each_entry_safe(root, next, &rc->dirty_subvol_roots, + reloc_dirty_list) { +- struct btrfs_root *reloc_root = root->reloc_root; ++ if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) { ++ /* Merged subvolume, cleanup its reloc root */ ++ struct btrfs_root *reloc_root = root->reloc_root; + +- clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state); +- list_del_init(&root->reloc_dirty_list); +- root->reloc_root = NULL; +- if (reloc_root) { +- int ret2; ++ clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state); ++ list_del_init(&root->reloc_dirty_list); ++ root->reloc_root = NULL; ++ if (reloc_root) { + +- ret2 = btrfs_drop_snapshot(reloc_root, NULL, 0, 1); ++ ret2 = btrfs_drop_snapshot(reloc_root, NULL, 0, 1); ++ if (ret2 < 0 && !ret) ++ ret = ret2; ++ } ++ btrfs_put_fs_root(root); ++ } else { ++ /* Orphan reloc tree, just clean it up */ ++ ret2 = btrfs_drop_snapshot(root, NULL, 0, 1); + if (ret2 < 0 && !ret) + ret = ret2; + } +- btrfs_put_fs_root(root); + } + return ret; + } +@@ -2464,6 +2472,9 @@ again: + } + } else { + list_del_init(&reloc_root->root_list); ++ /* Don't forget to queue this reloc root for cleanup */ ++ list_add_tail(&reloc_root->reloc_dirty_list, ++ &rc->dirty_subvol_roots); + } + } + +diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c +index 19b00b1668ed..67b9feb72e03 100644 +--- a/fs/btrfs/send.c ++++ b/fs/btrfs/send.c +@@ -5017,6 +5017,12 @@ static int send_hole(struct send_ctx *sctx, u64 end) + if (offset >= sctx->cur_inode_size) + return 0; + ++ /* ++ * Don't go beyond the inode's i_size due to prealloc extents that start ++ * after the i_size. ++ */ ++ end = min_t(u64, end, sctx->cur_inode_size); ++ + if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA) + return send_update_extent(sctx, offset, end - offset); + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 60aac95be54b..fc93e0d6e48d 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -3095,6 +3095,12 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, + root->log_transid++; + log->log_transid = root->log_transid; + root->log_start_pid = 0; ++ /* ++ * Update or create log root item under the root's log_mutex to prevent ++ * races with concurrent log syncs that can lead to failure to update ++ * log root item because it was not created yet. ++ */ ++ ret = update_log_root(trans, log); + /* + * IO has been started, blocks of the log tree have WRITTEN flag set + * in their headers. new modifications of the log will be written to +@@ -3114,8 +3120,6 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, + + mutex_unlock(&log_root_tree->log_mutex); + +- ret = update_log_root(trans, log); +- + mutex_lock(&log_root_tree->log_mutex); + if (atomic_dec_and_test(&log_root_tree->log_writers)) { + /* atomic_dec_and_test implies a barrier */ +@@ -5465,7 +5469,6 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans, + { + int ret = 0; + struct dentry *old_parent = NULL; +- struct btrfs_inode *orig_inode = inode; + + /* + * for regular files, if its inode is already on disk, we don't +@@ -5485,16 +5488,6 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans, + } + + while (1) { +- /* +- * If we are logging a directory then we start with our inode, +- * not our parent's inode, so we need to skip setting the +- * logged_trans so that further down in the log code we don't +- * think this inode has already been logged. +- */ +- if (inode != orig_inode) +- inode->logged_trans = trans->transid; +- smp_mb(); +- + if (btrfs_must_commit_transaction(trans, inode)) { + ret = 1; + break; +@@ -6223,7 +6216,6 @@ void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans, + * if this directory was already logged any new + * names for this file/dir will get recorded + */ +- smp_mb(); + if (dir->logged_trans == trans->transid) + return; + +diff --git a/fs/btrfs/zstd.c b/fs/btrfs/zstd.c +index 6b9e29d050f3..f828b8870178 100644 +--- a/fs/btrfs/zstd.c ++++ b/fs/btrfs/zstd.c +@@ -102,10 +102,10 @@ static void zstd_reclaim_timer_fn(struct timer_list *timer) + unsigned long reclaim_threshold = jiffies - ZSTD_BTRFS_RECLAIM_JIFFIES; + struct list_head *pos, *next; + +- spin_lock(&wsm.lock); ++ spin_lock_bh(&wsm.lock); + + if (list_empty(&wsm.lru_list)) { +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + return; + } + +@@ -134,7 +134,7 @@ static void zstd_reclaim_timer_fn(struct timer_list *timer) + if (!list_empty(&wsm.lru_list)) + mod_timer(&wsm.timer, jiffies + ZSTD_BTRFS_RECLAIM_JIFFIES); + +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + } + + /* +@@ -195,7 +195,7 @@ static void zstd_cleanup_workspace_manager(void) + struct workspace *workspace; + int i; + +- spin_lock(&wsm.lock); ++ spin_lock_bh(&wsm.lock); + for (i = 0; i < ZSTD_BTRFS_MAX_LEVEL; i++) { + while (!list_empty(&wsm.idle_ws[i])) { + workspace = container_of(wsm.idle_ws[i].next, +@@ -205,7 +205,7 @@ static void zstd_cleanup_workspace_manager(void) + wsm.ops->free_workspace(&workspace->list); + } + } +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + + del_timer_sync(&wsm.timer); + } +@@ -227,7 +227,7 @@ static struct list_head *zstd_find_workspace(unsigned int level) + struct workspace *workspace; + int i = level - 1; + +- spin_lock(&wsm.lock); ++ spin_lock_bh(&wsm.lock); + for_each_set_bit_from(i, &wsm.active_map, ZSTD_BTRFS_MAX_LEVEL) { + if (!list_empty(&wsm.idle_ws[i])) { + ws = wsm.idle_ws[i].next; +@@ -239,11 +239,11 @@ static struct list_head *zstd_find_workspace(unsigned int level) + list_del(&workspace->lru_list); + if (list_empty(&wsm.idle_ws[i])) + clear_bit(i, &wsm.active_map); +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + return ws; + } + } +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + + return NULL; + } +@@ -302,7 +302,7 @@ static void zstd_put_workspace(struct list_head *ws) + { + struct workspace *workspace = list_to_workspace(ws); + +- spin_lock(&wsm.lock); ++ spin_lock_bh(&wsm.lock); + + /* A node is only taken off the lru if we are the corresponding level */ + if (workspace->req_level == workspace->level) { +@@ -322,7 +322,7 @@ static void zstd_put_workspace(struct list_head *ws) + list_add(&workspace->list, &wsm.idle_ws[workspace->level - 1]); + workspace->req_level = 0; + +- spin_unlock(&wsm.lock); ++ spin_unlock_bh(&wsm.lock); + + if (workspace->level == ZSTD_BTRFS_MAX_LEVEL) + cond_wake_up(&wsm.wait); +diff --git a/fs/cifs/file.c b/fs/cifs/file.c +index 7037a137fa53..9a1db37b303a 100644 +--- a/fs/cifs/file.c ++++ b/fs/cifs/file.c +@@ -3221,7 +3221,9 @@ cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages) + } + + if (rc) { +- for (i = 0; i < nr_pages; i++) { ++ unsigned int nr_page_failed = i; ++ ++ for (i = 0; i < nr_page_failed; i++) { + put_page(rdata->pages[i]); + rdata->pages[i] = NULL; + } +diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c +index a37774a55f3a..d2d8708f5e1a 100644 +--- a/fs/cifs/smb2pdu.c ++++ b/fs/cifs/smb2pdu.c +@@ -1013,7 +1013,8 @@ int smb3_validate_negotiate(const unsigned int xid, struct cifs_tcon *tcon) + * not supported error. Client should accept it. + */ + cifs_dbg(VFS, "Server does not support validate negotiate\n"); +- return 0; ++ rc = 0; ++ goto out_free_inbuf; + } else if (rc != 0) { + cifs_dbg(VFS, "validate protocol negotiate failed: %d\n", rc); + rc = -EIO; +diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c +index 9846f7e95282..7147e4aebecc 100644 +--- a/fs/lockd/xdr.c ++++ b/fs/lockd/xdr.c +@@ -127,7 +127,7 @@ nlm_decode_lock(__be32 *p, struct nlm_lock *lock) + + locks_init_lock(fl); + fl->fl_owner = current->files; +- fl->fl_pid = current->tgid; ++ fl->fl_pid = (pid_t)lock->svid; + fl->fl_flags = FL_POSIX; + fl->fl_type = F_RDLCK; /* as good as anything else */ + start = ntohl(*p++); +@@ -269,7 +269,7 @@ nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p) + memset(lock, 0, sizeof(*lock)); + locks_init_lock(&lock->fl); + lock->svid = ~(u32) 0; +- lock->fl.fl_pid = current->tgid; ++ lock->fl.fl_pid = (pid_t)lock->svid; + + if (!(p = nlm_decode_cookie(p, &argp->cookie)) + || !(p = xdr_decode_string_inplace(p, &lock->caller, +diff --git a/fs/lockd/xdr4.c b/fs/lockd/xdr4.c +index 70154f376695..7ed9edf9aed4 100644 +--- a/fs/lockd/xdr4.c ++++ b/fs/lockd/xdr4.c +@@ -119,7 +119,7 @@ nlm4_decode_lock(__be32 *p, struct nlm_lock *lock) + + locks_init_lock(fl); + fl->fl_owner = current->files; +- fl->fl_pid = current->tgid; ++ fl->fl_pid = (pid_t)lock->svid; + fl->fl_flags = FL_POSIX; + fl->fl_type = F_RDLCK; /* as good as anything else */ + p = xdr_decode_hyper(p, &start); +@@ -266,7 +266,7 @@ nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p) + memset(lock, 0, sizeof(*lock)); + locks_init_lock(&lock->fl); + lock->svid = ~(u32) 0; +- lock->fl.fl_pid = current->tgid; ++ lock->fl.fl_pid = (pid_t)lock->svid; + + if (!(p = nlm4_decode_cookie(p, &argp->cookie)) + || !(p = xdr_decode_string_inplace(p, &lock->caller, +diff --git a/include/linux/bitops.h b/include/linux/bitops.h +index 602af23b98c7..cf074bce3eb3 100644 +--- a/include/linux/bitops.h ++++ b/include/linux/bitops.h +@@ -60,7 +60,7 @@ static __always_inline unsigned long hweight_long(unsigned long w) + */ + static inline __u64 rol64(__u64 word, unsigned int shift) + { +- return (word << shift) | (word >> (64 - shift)); ++ return (word << (shift & 63)) | (word >> ((-shift) & 63)); + } + + /** +@@ -70,7 +70,7 @@ static inline __u64 rol64(__u64 word, unsigned int shift) + */ + static inline __u64 ror64(__u64 word, unsigned int shift) + { +- return (word >> shift) | (word << (64 - shift)); ++ return (word >> (shift & 63)) | (word << ((-shift) & 63)); + } + + /** +@@ -80,7 +80,7 @@ static inline __u64 ror64(__u64 word, unsigned int shift) + */ + static inline __u32 rol32(__u32 word, unsigned int shift) + { +- return (word << shift) | (word >> ((-shift) & 31)); ++ return (word << (shift & 31)) | (word >> ((-shift) & 31)); + } + + /** +@@ -90,7 +90,7 @@ static inline __u32 rol32(__u32 word, unsigned int shift) + */ + static inline __u32 ror32(__u32 word, unsigned int shift) + { +- return (word >> shift) | (word << (32 - shift)); ++ return (word >> (shift & 31)) | (word << ((-shift) & 31)); + } + + /** +@@ -100,7 +100,7 @@ static inline __u32 ror32(__u32 word, unsigned int shift) + */ + static inline __u16 rol16(__u16 word, unsigned int shift) + { +- return (word << shift) | (word >> (16 - shift)); ++ return (word << (shift & 15)) | (word >> ((-shift) & 15)); + } + + /** +@@ -110,7 +110,7 @@ static inline __u16 rol16(__u16 word, unsigned int shift) + */ + static inline __u16 ror16(__u16 word, unsigned int shift) + { +- return (word >> shift) | (word << (16 - shift)); ++ return (word >> (shift & 15)) | (word << ((-shift) & 15)); + } + + /** +@@ -120,7 +120,7 @@ static inline __u16 ror16(__u16 word, unsigned int shift) + */ + static inline __u8 rol8(__u8 word, unsigned int shift) + { +- return (word << shift) | (word >> (8 - shift)); ++ return (word << (shift & 7)) | (word >> ((-shift) & 7)); + } + + /** +@@ -130,7 +130,7 @@ static inline __u8 rol8(__u8 word, unsigned int shift) + */ + static inline __u8 ror8(__u8 word, unsigned int shift) + { +- return (word >> shift) | (word << (8 - shift)); ++ return (word >> (shift & 7)) | (word << ((-shift) & 7)); + } + + /** +diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h +index 7d57890cec67..96398d8d4fd8 100644 +--- a/include/linux/cgroup-defs.h ++++ b/include/linux/cgroup-defs.h +@@ -83,6 +83,11 @@ enum { + * Enable cpuset controller in v1 cgroup to use v2 behavior. + */ + CGRP_ROOT_CPUSET_V2_MODE = (1 << 4), ++ ++ /* ++ * Enable legacy local memory.events. ++ */ ++ CGRP_ROOT_MEMORY_LOCAL_EVENTS = (1 << 5), + }; + + /* cftype->flags */ +diff --git a/include/linux/list_lru.h b/include/linux/list_lru.h +index aa5efd9351eb..d5ceb2839a2d 100644 +--- a/include/linux/list_lru.h ++++ b/include/linux/list_lru.h +@@ -54,6 +54,7 @@ struct list_lru { + #ifdef CONFIG_MEMCG_KMEM + struct list_head list; + int shrinker_id; ++ bool memcg_aware; + #endif + }; + +diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h +index dbb6118370c1..28525c7a8ab0 100644 +--- a/include/linux/memcontrol.h ++++ b/include/linux/memcontrol.h +@@ -777,8 +777,14 @@ static inline void count_memcg_event_mm(struct mm_struct *mm, + static inline void memcg_memory_event(struct mem_cgroup *memcg, + enum memcg_memory_event event) + { +- atomic_long_inc(&memcg->memory_events[event]); +- cgroup_file_notify(&memcg->events_file); ++ do { ++ atomic_long_inc(&memcg->memory_events[event]); ++ cgroup_file_notify(&memcg->events_file); ++ ++ if (cgrp_dfl_root.flags & CGRP_ROOT_MEMORY_LOCAL_EVENTS) ++ break; ++ } while ((memcg = parent_mem_cgroup(memcg)) && ++ !mem_cgroup_is_root(memcg)); + } + + static inline void memcg_memory_event_mm(struct mm_struct *mm, +diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c +index 9fcf6338ea5f..4e2d82eea2cd 100644 +--- a/kernel/cgroup/cgroup.c ++++ b/kernel/cgroup/cgroup.c +@@ -1775,11 +1775,13 @@ int cgroup_show_path(struct seq_file *sf, struct kernfs_node *kf_node, + + enum cgroup2_param { + Opt_nsdelegate, ++ Opt_memory_localevents, + nr__cgroup2_params + }; + + static const struct fs_parameter_spec cgroup2_param_specs[] = { +- fsparam_flag ("nsdelegate", Opt_nsdelegate), ++ fsparam_flag("nsdelegate", Opt_nsdelegate), ++ fsparam_flag("memory_localevents", Opt_memory_localevents), + {} + }; + +@@ -1802,6 +1804,9 @@ static int cgroup2_parse_param(struct fs_context *fc, struct fs_parameter *param + case Opt_nsdelegate: + ctx->flags |= CGRP_ROOT_NS_DELEGATE; + return 0; ++ case Opt_memory_localevents: ++ ctx->flags |= CGRP_ROOT_MEMORY_LOCAL_EVENTS; ++ return 0; + } + return -EINVAL; + } +@@ -1813,6 +1818,11 @@ static void apply_cgroup_root_flags(unsigned int root_flags) + cgrp_dfl_root.flags |= CGRP_ROOT_NS_DELEGATE; + else + cgrp_dfl_root.flags &= ~CGRP_ROOT_NS_DELEGATE; ++ ++ if (root_flags & CGRP_ROOT_MEMORY_LOCAL_EVENTS) ++ cgrp_dfl_root.flags |= CGRP_ROOT_MEMORY_LOCAL_EVENTS; ++ else ++ cgrp_dfl_root.flags &= ~CGRP_ROOT_MEMORY_LOCAL_EVENTS; + } + } + +@@ -1820,6 +1830,8 @@ static int cgroup_show_options(struct seq_file *seq, struct kernfs_root *kf_root + { + if (cgrp_dfl_root.flags & CGRP_ROOT_NS_DELEGATE) + seq_puts(seq, ",nsdelegate"); ++ if (cgrp_dfl_root.flags & CGRP_ROOT_MEMORY_LOCAL_EVENTS) ++ seq_puts(seq, ",memory_localevents"); + return 0; + } + +@@ -6122,7 +6134,7 @@ static struct kobj_attribute cgroup_delegate_attr = __ATTR_RO(delegate); + static ssize_t features_show(struct kobject *kobj, struct kobj_attribute *attr, + char *buf) + { +- return snprintf(buf, PAGE_SIZE, "nsdelegate\n"); ++ return snprintf(buf, PAGE_SIZE, "nsdelegate\nmemory_localevents\n"); + } + static struct kobj_attribute cgroup_features_attr = __ATTR_RO(features); + +diff --git a/kernel/signal.c b/kernel/signal.c +index 227ba170298e..429f5663edd9 100644 +--- a/kernel/signal.c ++++ b/kernel/signal.c +@@ -2441,6 +2441,8 @@ relock: + if (signal_group_exit(signal)) { + ksig->info.si_signo = signr = SIGKILL; + sigdelset(¤t->pending.signal, SIGKILL); ++ trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO, ++ &sighand->action[SIGKILL - 1]); + recalc_sigpending(); + goto fatal; + } +diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c +index 05a66493a164..8cea61795a7e 100644 +--- a/kernel/trace/trace_events_filter.c ++++ b/kernel/trace/trace_events_filter.c +@@ -427,7 +427,7 @@ predicate_parse(const char *str, int nr_parens, int nr_preds, + op_stack = kmalloc_array(nr_parens, sizeof(*op_stack), GFP_KERNEL); + if (!op_stack) + return ERR_PTR(-ENOMEM); +- prog_stack = kmalloc_array(nr_preds, sizeof(*prog_stack), GFP_KERNEL); ++ prog_stack = kcalloc(nr_preds, sizeof(*prog_stack), GFP_KERNEL); + if (!prog_stack) { + parse_error(pe, -ENOMEM, 0); + goto out_free; +@@ -578,7 +578,11 @@ predicate_parse(const char *str, int nr_parens, int nr_preds, + out_free: + kfree(op_stack); + kfree(inverts); +- kfree(prog_stack); ++ if (prog_stack) { ++ for (i = 0; prog_stack[i].pred; i++) ++ kfree(prog_stack[i].pred); ++ kfree(prog_stack); ++ } + return ERR_PTR(ret); + } + +diff --git a/mm/compaction.c b/mm/compaction.c +index 444029da4e9d..368445cc71cf 100644 +--- a/mm/compaction.c ++++ b/mm/compaction.c +@@ -1397,7 +1397,7 @@ fast_isolate_freepages(struct compact_control *cc) + page = pfn_to_page(highest); + cc->free_pfn = highest; + } else { +- if (cc->direct_compaction) { ++ if (cc->direct_compaction && pfn_valid(min_pfn)) { + page = pfn_to_page(min_pfn); + cc->free_pfn = min_pfn; + } +diff --git a/mm/kasan/common.c b/mm/kasan/common.c +index 80bbe62b16cd..94d3c83c0fa8 100644 +--- a/mm/kasan/common.c ++++ b/mm/kasan/common.c +@@ -472,7 +472,7 @@ static void *__kasan_kmalloc(struct kmem_cache *cache, const void *object, + { + unsigned long redzone_start; + unsigned long redzone_end; +- u8 tag; ++ u8 tag = 0xff; + + if (gfpflags_allow_blocking(flags)) + quarantine_reduce(); +diff --git a/mm/list_lru.c b/mm/list_lru.c +index 0730bf8ff39f..d3b538146efd 100644 +--- a/mm/list_lru.c ++++ b/mm/list_lru.c +@@ -37,11 +37,7 @@ static int lru_shrinker_id(struct list_lru *lru) + + static inline bool list_lru_memcg_aware(struct list_lru *lru) + { +- /* +- * This needs node 0 to be always present, even +- * in the systems supporting sparse numa ids. +- */ +- return !!lru->node[0].memcg_lrus; ++ return lru->memcg_aware; + } + + static inline struct list_lru_one * +@@ -451,6 +447,8 @@ static int memcg_init_list_lru(struct list_lru *lru, bool memcg_aware) + { + int i; + ++ lru->memcg_aware = memcg_aware; ++ + if (!memcg_aware) + return 0; + +diff --git a/scripts/gcc-plugins/gcc-common.h b/scripts/gcc-plugins/gcc-common.h +index 552d5efd7cb7..17f06079a712 100644 +--- a/scripts/gcc-plugins/gcc-common.h ++++ b/scripts/gcc-plugins/gcc-common.h +@@ -150,8 +150,12 @@ void print_gimple_expr(FILE *, gimple, int, int); + void dump_gimple_stmt(pretty_printer *, gimple, int, int); + #endif + ++#ifndef __unused + #define __unused __attribute__((__unused__)) ++#endif ++#ifndef __visible + #define __visible __attribute__((visibility("default"))) ++#endif + + #define DECL_NAME_POINTER(node) IDENTIFIER_POINTER(DECL_NAME(node)) + #define DECL_NAME_LENGTH(node) IDENTIFIER_LENGTH(DECL_NAME(node)) +diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c +index c37d08118af5..ab3ab654363d 100644 +--- a/security/integrity/evm/evm_crypto.c ++++ b/security/integrity/evm/evm_crypto.c +@@ -89,6 +89,9 @@ static struct shash_desc *init_desc(char type, uint8_t hash_algo) + tfm = &hmac_tfm; + algo = evm_hmac; + } else { ++ if (hash_algo >= HASH_ALGO__LAST) ++ return ERR_PTR(-EINVAL); ++ + tfm = &evm_tfm[hash_algo]; + algo = hash_algo_name[hash_algo]; + } +diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c +index e0cc323f948f..1cc822a59054 100644 +--- a/security/integrity/ima/ima_policy.c ++++ b/security/integrity/ima/ima_policy.c +@@ -498,10 +498,11 @@ static void add_rules(struct ima_rule_entry *entries, int count, + + list_add_tail(&entry->list, &ima_policy_rules); + } +- if (entries[i].action == APPRAISE) ++ if (entries[i].action == APPRAISE) { + temp_ima_appraise |= ima_appraise_flag(entries[i].func); +- if (entries[i].func == POLICY_CHECK) +- temp_ima_appraise |= IMA_APPRAISE_POLICY; ++ if (entries[i].func == POLICY_CHECK) ++ temp_ima_appraise |= IMA_APPRAISE_POLICY; ++ } + } + } + +@@ -1146,10 +1147,10 @@ enum { + }; + + static const char *const mask_tokens[] = { +- "MAY_EXEC", +- "MAY_WRITE", +- "MAY_READ", +- "MAY_APPEND" ++ "^MAY_EXEC", ++ "^MAY_WRITE", ++ "^MAY_READ", ++ "^MAY_APPEND" + }; + + #define __ima_hook_stringify(str) (#str), +@@ -1209,6 +1210,7 @@ int ima_policy_show(struct seq_file *m, void *v) + struct ima_rule_entry *entry = v; + int i; + char tbuf[64] = {0,}; ++ int offset = 0; + + rcu_read_lock(); + +@@ -1232,15 +1234,17 @@ int ima_policy_show(struct seq_file *m, void *v) + if (entry->flags & IMA_FUNC) + policy_func_show(m, entry->func); + +- if (entry->flags & IMA_MASK) { ++ if ((entry->flags & IMA_MASK) || (entry->flags & IMA_INMASK)) { ++ if (entry->flags & IMA_MASK) ++ offset = 1; + if (entry->mask & MAY_EXEC) +- seq_printf(m, pt(Opt_mask), mt(mask_exec)); ++ seq_printf(m, pt(Opt_mask), mt(mask_exec) + offset); + if (entry->mask & MAY_WRITE) +- seq_printf(m, pt(Opt_mask), mt(mask_write)); ++ seq_printf(m, pt(Opt_mask), mt(mask_write) + offset); + if (entry->mask & MAY_READ) +- seq_printf(m, pt(Opt_mask), mt(mask_read)); ++ seq_printf(m, pt(Opt_mask), mt(mask_read) + offset); + if (entry->mask & MAY_APPEND) +- seq_printf(m, pt(Opt_mask), mt(mask_append)); ++ seq_printf(m, pt(Opt_mask), mt(mask_append) + offset); + seq_puts(m, " "); + } + +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index fc99a5a6f7e1..239697421118 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -6166,13 +6166,15 @@ static const struct hda_fixup alc269_fixups[] = { + .chain_id = ALC269_FIXUP_THINKPAD_ACPI, + }, + [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { +- .type = HDA_FIXUP_PINS, +- .v.pins = (const struct hda_pintbl[]) { +- { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ +- { } ++ .type = HDA_FIXUP_VERBS, ++ .v.verbs = (const struct hda_verb[]) { ++ /* Enable the Mic */ ++ { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, ++ { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, ++ {} + }, + .chained = true, +- .chain_id = ALC255_FIXUP_HEADSET_MODE ++ .chain_id = ALC269_FIXUP_LIFEBOOK_EXTMIC + }, + [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { + .type = HDA_FIXUP_PINS, +@@ -7217,6 +7219,10 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + {0x18, 0x02a11030}, + {0x19, 0x0181303F}, + {0x21, 0x0221102f}), ++ SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, ++ {0x12, 0x90a60140}, ++ {0x14, 0x90170120}, ++ {0x21, 0x02211030}), + SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, + {0x12, 0x90a601c0}, + {0x14, 0x90171120}, +@@ -7654,7 +7660,7 @@ static int patch_alc269(struct hda_codec *codec) + + spec = codec->spec; + spec->gen.shared_mic_vref_pin = 0x18; +- codec->power_save_node = 1; ++ codec->power_save_node = 0; + + #ifdef CONFIG_PM + codec->patch_ops.suspend = alc269_suspend; +diff --git a/sound/usb/line6/driver.c b/sound/usb/line6/driver.c +index b61f65bed4e4..2b57854335b3 100644 +--- a/sound/usb/line6/driver.c ++++ b/sound/usb/line6/driver.c +@@ -720,6 +720,15 @@ static int line6_init_cap_control(struct usb_line6 *line6) + return 0; + } + ++static void line6_startup_work(struct work_struct *work) ++{ ++ struct usb_line6 *line6 = ++ container_of(work, struct usb_line6, startup_work.work); ++ ++ if (line6->startup) ++ line6->startup(line6); ++} ++ + /* + Probe USB device. + */ +@@ -755,6 +764,7 @@ int line6_probe(struct usb_interface *interface, + line6->properties = properties; + line6->usbdev = usbdev; + line6->ifcdev = &interface->dev; ++ INIT_DELAYED_WORK(&line6->startup_work, line6_startup_work); + + strcpy(card->id, properties->id); + strcpy(card->driver, driver_name); +@@ -825,6 +835,8 @@ void line6_disconnect(struct usb_interface *interface) + if (WARN_ON(usbdev != line6->usbdev)) + return; + ++ cancel_delayed_work(&line6->startup_work); ++ + if (line6->urb_listen != NULL) + line6_stop_listen(line6); + +diff --git a/sound/usb/line6/driver.h b/sound/usb/line6/driver.h +index 61425597eb61..650d909c9c4f 100644 +--- a/sound/usb/line6/driver.h ++++ b/sound/usb/line6/driver.h +@@ -178,11 +178,15 @@ struct usb_line6 { + fifo; + } messages; + ++ /* Work for delayed PCM startup */ ++ struct delayed_work startup_work; ++ + /* If MIDI is supported, buffer_message contains the pre-processed data; + * otherwise the data is only in urb_listen (buffer_incoming). + */ + void (*process_message)(struct usb_line6 *); + void (*disconnect)(struct usb_line6 *line6); ++ void (*startup)(struct usb_line6 *line6); + }; + + extern char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, +diff --git a/sound/usb/line6/toneport.c b/sound/usb/line6/toneport.c +index 325b07b98b3c..7e39083f8f76 100644 +--- a/sound/usb/line6/toneport.c ++++ b/sound/usb/line6/toneport.c +@@ -54,9 +54,6 @@ struct usb_line6_toneport { + /* Firmware version (x 100) */ + u8 firmware_version; + +- /* Work for delayed PCM startup */ +- struct delayed_work pcm_work; +- + /* Device type */ + enum line6_device_type type; + +@@ -241,12 +238,8 @@ static int snd_toneport_source_put(struct snd_kcontrol *kcontrol, + return 1; + } + +-static void toneport_start_pcm(struct work_struct *work) ++static void toneport_startup(struct usb_line6 *line6) + { +- struct usb_line6_toneport *toneport = +- container_of(work, struct usb_line6_toneport, pcm_work.work); +- struct usb_line6 *line6 = &toneport->line6; +- + line6_pcm_acquire(line6->line6pcm, LINE6_STREAM_MONITOR, true); + } + +@@ -394,7 +387,7 @@ static int toneport_setup(struct usb_line6_toneport *toneport) + if (toneport_has_led(toneport)) + toneport_update_led(toneport); + +- schedule_delayed_work(&toneport->pcm_work, ++ schedule_delayed_work(&toneport->line6.startup_work, + msecs_to_jiffies(TONEPORT_PCM_DELAY * 1000)); + return 0; + } +@@ -407,8 +400,6 @@ static void line6_toneport_disconnect(struct usb_line6 *line6) + struct usb_line6_toneport *toneport = + (struct usb_line6_toneport *)line6; + +- cancel_delayed_work_sync(&toneport->pcm_work); +- + if (toneport_has_led(toneport)) + toneport_remove_leds(toneport); + } +@@ -424,9 +415,9 @@ static int toneport_init(struct usb_line6 *line6, + struct usb_line6_toneport *toneport = (struct usb_line6_toneport *) line6; + + toneport->type = id->driver_info; +- INIT_DELAYED_WORK(&toneport->pcm_work, toneport_start_pcm); + + line6->disconnect = line6_toneport_disconnect; ++ line6->startup = toneport_startup; + + /* initialize PCM subsystem: */ + err = line6_init_pcm(line6, &toneport_pcm_properties); +diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c +index f412ebc90610..8e2a5eb38bc0 100644 +--- a/virt/kvm/arm/arm.c ++++ b/virt/kvm/arm/arm.c +@@ -224,6 +224,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) + case KVM_CAP_MAX_VCPUS: + r = KVM_MAX_VCPUS; + break; ++ case KVM_CAP_MAX_VCPU_ID: ++ r = KVM_MAX_VCPU_ID; ++ break; + case KVM_CAP_NR_MEMSLOTS: + r = KVM_USER_MEM_SLOTS; + break; +diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c +index 2b2a460c6252..48c549a88486 100644 +--- a/virt/kvm/kvm_main.c ++++ b/virt/kvm/kvm_main.c +@@ -3062,8 +3062,6 @@ static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg) + case KVM_CAP_MULTI_ADDRESS_SPACE: + return KVM_ADDRESS_SPACE_NUM; + #endif +- case KVM_CAP_MAX_VCPU_ID: +- return KVM_MAX_VCPU_ID; + default: + break; + }
