commit: 26c5b0bcb48671f84a02d4f62590131aa4566f9b Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Thu Apr 28 18:56:12 2016 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Thu Apr 28 18:56:12 2016 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=26c5b0bc
Linux patch 4.1.23 0000_README | 4 + 1022_linux-4.1.23.patch | 2721 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2725 insertions(+) diff --git a/0000_README b/0000_README index 3075177..a797069 100644 --- a/0000_README +++ b/0000_README @@ -131,6 +131,10 @@ Patch: 1021_linux-4.1.22.patch From: http://www.kernel.org Desc: Linux 4.1.22 +Patch: 1022_linux-4.1.23.patch +From: http://www.kernel.org +Desc: Linux 4.1.23 + 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/1022_linux-4.1.23.patch b/1022_linux-4.1.23.patch new file mode 100644 index 0000000..68a28a4 --- /dev/null +++ b/1022_linux-4.1.23.patch @@ -0,0 +1,2721 @@ +diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt +index cd03a0faca8f..7bcd7a26f885 100644 +--- a/Documentation/kernel-parameters.txt ++++ b/Documentation/kernel-parameters.txt +@@ -3808,6 +3808,8 @@ bytes respectively. Such letter suffixes can also be entirely omitted. + sector if the number is odd); + i = IGNORE_DEVICE (don't bind to this + device); ++ j = NO_REPORT_LUNS (don't use report luns ++ command, uas only); + l = NOT_LOCKABLE (don't try to lock and + unlock ejectable media); + m = MAX_SECTORS_64 (don't transfer more +diff --git a/Makefile b/Makefile +index 7f4a4039fdd9..9956129bb106 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 1 +-SUBLEVEL = 22 ++SUBLEVEL = 23 + EXTRAVERSION = + NAME = Series 4800 + +diff --git a/arch/arm/mach-omap2/omap_hwmod.c b/arch/arm/mach-omap2/omap_hwmod.c +index 9185bb958503..dee6831c0434 100644 +--- a/arch/arm/mach-omap2/omap_hwmod.c ++++ b/arch/arm/mach-omap2/omap_hwmod.c +@@ -1402,9 +1402,7 @@ static void _enable_sysc(struct omap_hwmod *oh) + (sf & SYSC_HAS_CLOCKACTIVITY)) + _set_clockactivity(oh, oh->class->sysc->clockact, &v); + +- /* If the cached value is the same as the new value, skip the write */ +- if (oh->_sysc_cache != v) +- _write_sysconfig(v, oh); ++ _write_sysconfig(v, oh); + + /* + * Set the autoidle bit only after setting the smartidle bit +@@ -1467,7 +1465,9 @@ static void _idle_sysc(struct omap_hwmod *oh) + _set_master_standbymode(oh, idlemode, &v); + } + +- _write_sysconfig(v, oh); ++ /* If the cached value is the same as the new value, skip the write */ ++ if (oh->_sysc_cache != v) ++ _write_sysconfig(v, oh); + } + + /** +diff --git a/arch/parisc/include/asm/uaccess.h b/arch/parisc/include/asm/uaccess.h +index 0abdd4c607ed..1960b87c1c8b 100644 +--- a/arch/parisc/include/asm/uaccess.h ++++ b/arch/parisc/include/asm/uaccess.h +@@ -76,6 +76,7 @@ struct exception_table_entry { + */ + struct exception_data { + unsigned long fault_ip; ++ unsigned long fault_gp; + unsigned long fault_space; + unsigned long fault_addr; + }; +diff --git a/arch/parisc/kernel/asm-offsets.c b/arch/parisc/kernel/asm-offsets.c +index 59001cea13f9..c972e6550f56 100644 +--- a/arch/parisc/kernel/asm-offsets.c ++++ b/arch/parisc/kernel/asm-offsets.c +@@ -291,6 +291,7 @@ int main(void) + DEFINE(ASM_PT_INITIAL, PT_INITIAL); + BLANK(); + DEFINE(EXCDATA_IP, offsetof(struct exception_data, fault_ip)); ++ DEFINE(EXCDATA_GP, offsetof(struct exception_data, fault_gp)); + DEFINE(EXCDATA_SPACE, offsetof(struct exception_data, fault_space)); + DEFINE(EXCDATA_ADDR, offsetof(struct exception_data, fault_addr)); + BLANK(); +diff --git a/arch/parisc/kernel/parisc_ksyms.c b/arch/parisc/kernel/parisc_ksyms.c +index 568b2c61ea02..3cad8aadc69e 100644 +--- a/arch/parisc/kernel/parisc_ksyms.c ++++ b/arch/parisc/kernel/parisc_ksyms.c +@@ -47,11 +47,11 @@ EXPORT_SYMBOL(__cmpxchg_u64); + EXPORT_SYMBOL(lclear_user); + EXPORT_SYMBOL(lstrnlen_user); + +-/* Global fixups */ +-extern void fixup_get_user_skip_1(void); +-extern void fixup_get_user_skip_2(void); +-extern void fixup_put_user_skip_1(void); +-extern void fixup_put_user_skip_2(void); ++/* Global fixups - defined as int to avoid creation of function pointers */ ++extern int fixup_get_user_skip_1; ++extern int fixup_get_user_skip_2; ++extern int fixup_put_user_skip_1; ++extern int fixup_put_user_skip_2; + EXPORT_SYMBOL(fixup_get_user_skip_1); + EXPORT_SYMBOL(fixup_get_user_skip_2); + EXPORT_SYMBOL(fixup_put_user_skip_1); +diff --git a/arch/parisc/kernel/traps.c b/arch/parisc/kernel/traps.c +index 7f67c4c96a7a..bbf22658d1a3 100644 +--- a/arch/parisc/kernel/traps.c ++++ b/arch/parisc/kernel/traps.c +@@ -798,6 +798,9 @@ void notrace handle_interruption(int code, struct pt_regs *regs) + + if (fault_space == 0 && !in_atomic()) + { ++ /* Clean up and return if in exception table. */ ++ if (fixup_exception(regs)) ++ return; + pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC); + parisc_terminate("Kernel Fault", regs, code, fault_address); + } +diff --git a/arch/parisc/lib/fixup.S b/arch/parisc/lib/fixup.S +index 536ef66bb94b..1052b747e011 100644 +--- a/arch/parisc/lib/fixup.S ++++ b/arch/parisc/lib/fixup.S +@@ -26,6 +26,7 @@ + + #ifdef CONFIG_SMP + .macro get_fault_ip t1 t2 ++ loadgp + addil LT%__per_cpu_offset,%r27 + LDREG RT%__per_cpu_offset(%r1),\t1 + /* t2 = smp_processor_id() */ +@@ -40,14 +41,19 @@ + LDREG RT%exception_data(%r1),\t1 + /* t1 = this_cpu_ptr(&exception_data) */ + add,l \t1,\t2,\t1 ++ /* %r27 = t1->fault_gp - restore gp */ ++ LDREG EXCDATA_GP(\t1), %r27 + /* t1 = t1->fault_ip */ + LDREG EXCDATA_IP(\t1), \t1 + .endm + #else + .macro get_fault_ip t1 t2 ++ loadgp + /* t1 = this_cpu_ptr(&exception_data) */ + addil LT%exception_data,%r27 + LDREG RT%exception_data(%r1),\t2 ++ /* %r27 = t2->fault_gp - restore gp */ ++ LDREG EXCDATA_GP(\t2), %r27 + /* t1 = t2->fault_ip */ + LDREG EXCDATA_IP(\t2), \t1 + .endm +diff --git a/arch/parisc/mm/fault.c b/arch/parisc/mm/fault.c +index e5120e653240..50d64a7fc672 100644 +--- a/arch/parisc/mm/fault.c ++++ b/arch/parisc/mm/fault.c +@@ -151,6 +151,7 @@ int fixup_exception(struct pt_regs *regs) + struct exception_data *d; + d = this_cpu_ptr(&exception_data); + d->fault_ip = regs->iaoq[0]; ++ d->fault_gp = regs->gr[27]; + d->fault_space = regs->isr; + d->fault_addr = regs->ior; + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index c228d8da1f8c..75eb9603ed29 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -680,7 +680,6 @@ static int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) + if ((xcr0 & XSTATE_AVX512) != XSTATE_AVX512) + return 1; + } +- kvm_put_guest_xcr0(vcpu); + vcpu->arch.xcr0 = xcr0; + + if ((xcr0 ^ old_xcr0) & XSTATE_EXTEND_MASK) +@@ -6115,12 +6114,10 @@ static int inject_pending_event(struct kvm_vcpu *vcpu, bool req_int_win) + } + + /* try to inject new event if pending */ +- if (vcpu->arch.nmi_pending) { +- if (kvm_x86_ops->nmi_allowed(vcpu)) { +- --vcpu->arch.nmi_pending; +- vcpu->arch.nmi_injected = true; +- kvm_x86_ops->set_nmi(vcpu); +- } ++ if (vcpu->arch.nmi_pending && kvm_x86_ops->nmi_allowed(vcpu)) { ++ --vcpu->arch.nmi_pending; ++ vcpu->arch.nmi_injected = true; ++ kvm_x86_ops->set_nmi(vcpu); + } else if (kvm_cpu_has_injectable_intr(vcpu)) { + /* + * Because interrupts can be injected asynchronously, we are +@@ -6290,10 +6287,12 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + if (inject_pending_event(vcpu, req_int_win) != 0) + req_immediate_exit = true; + /* enable NMI/IRQ window open exits if needed */ +- else if (vcpu->arch.nmi_pending) +- kvm_x86_ops->enable_nmi_window(vcpu); +- else if (kvm_cpu_has_injectable_intr(vcpu) || req_int_win) +- kvm_x86_ops->enable_irq_window(vcpu); ++ else { ++ if (vcpu->arch.nmi_pending) ++ kvm_x86_ops->enable_nmi_window(vcpu); ++ if (kvm_cpu_has_injectable_intr(vcpu) || req_int_win) ++ kvm_x86_ops->enable_irq_window(vcpu); ++ } + + if (kvm_lapic_enabled(vcpu)) { + /* +@@ -6318,8 +6317,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + kvm_x86_ops->prepare_guest_switch(vcpu); + if (vcpu->fpu_active) + kvm_load_guest_fpu(vcpu); +- kvm_load_guest_xcr0(vcpu); +- + vcpu->mode = IN_GUEST_MODE; + + srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); +@@ -6342,6 +6339,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + goto cancel_injection; + } + ++ kvm_load_guest_xcr0(vcpu); ++ + if (req_immediate_exit) + smp_send_reschedule(vcpu->cpu); + +@@ -6392,6 +6391,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + vcpu->mode = OUTSIDE_GUEST_MODE; + smp_wmb(); + ++ kvm_put_guest_xcr0(vcpu); ++ + /* Interrupt is enabled by handle_external_intr() */ + kvm_x86_ops->handle_external_intr(vcpu); + +@@ -7040,7 +7041,6 @@ void kvm_load_guest_fpu(struct kvm_vcpu *vcpu) + * and assume host would use all available bits. + * Guest xcr0 would be loaded later. + */ +- kvm_put_guest_xcr0(vcpu); + vcpu->guest_fpu_loaded = 1; + __kernel_fpu_begin(); + fpu_restore_checking(&vcpu->arch.guest_fpu); +@@ -7049,8 +7049,6 @@ void kvm_load_guest_fpu(struct kvm_vcpu *vcpu) + + void kvm_put_guest_fpu(struct kvm_vcpu *vcpu) + { +- kvm_put_guest_xcr0(vcpu); +- + if (!vcpu->guest_fpu_loaded) + return; + +diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c +index 09138ceba046..89ecec13c567 100644 +--- a/drivers/block/rbd.c ++++ b/drivers/block/rbd.c +@@ -1934,7 +1934,7 @@ static struct ceph_osd_request *rbd_osd_req_create( + + osdc = &rbd_dev->rbd_client->client->osdc; + osd_req = ceph_osdc_alloc_request(osdc, snapc, num_ops, false, +- GFP_ATOMIC); ++ GFP_NOIO); + if (!osd_req) + return NULL; /* ENOMEM */ + +@@ -1983,7 +1983,7 @@ rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request) + rbd_dev = img_request->rbd_dev; + osdc = &rbd_dev->rbd_client->client->osdc; + osd_req = ceph_osdc_alloc_request(osdc, snapc, num_osd_ops, +- false, GFP_ATOMIC); ++ false, GFP_NOIO); + if (!osd_req) + return NULL; /* ENOMEM */ + +@@ -2482,7 +2482,7 @@ static int rbd_img_request_fill(struct rbd_img_request *img_request, + bio_chain_clone_range(&bio_list, + &bio_offset, + clone_size, +- GFP_ATOMIC); ++ GFP_NOIO); + if (!obj_request->bio_list) + goto out_unwind; + } else if (type == OBJ_REQUEST_PAGES) { +diff --git a/drivers/dma/dw/core.c b/drivers/dma/dw/core.c +index ebffc744cb1b..5ec92ce0e5ac 100644 +--- a/drivers/dma/dw/core.c ++++ b/drivers/dma/dw/core.c +@@ -130,26 +130,14 @@ static void dwc_desc_put(struct dw_dma_chan *dwc, struct dw_desc *desc) + static void dwc_initialize(struct dw_dma_chan *dwc) + { + struct dw_dma *dw = to_dw_dma(dwc->chan.device); +- struct dw_dma_slave *dws = dwc->chan.private; + u32 cfghi = DWC_CFGH_FIFO_MODE; + u32 cfglo = DWC_CFGL_CH_PRIOR(dwc->priority); + + if (dwc->initialized == true) + return; + +- if (dws) { +- /* +- * We need controller-specific data to set up slave +- * transfers. +- */ +- BUG_ON(!dws->dma_dev || dws->dma_dev != dw->dma.dev); +- +- cfghi |= DWC_CFGH_DST_PER(dws->dst_id); +- cfghi |= DWC_CFGH_SRC_PER(dws->src_id); +- } else { +- cfghi |= DWC_CFGH_DST_PER(dwc->dst_id); +- cfghi |= DWC_CFGH_SRC_PER(dwc->src_id); +- } ++ cfghi |= DWC_CFGH_DST_PER(dwc->dst_id); ++ cfghi |= DWC_CFGH_SRC_PER(dwc->src_id); + + channel_writel(dwc, CFG_LO, cfglo); + channel_writel(dwc, CFG_HI, cfghi); +@@ -936,7 +924,7 @@ bool dw_dma_filter(struct dma_chan *chan, void *param) + struct dw_dma_chan *dwc = to_dw_dma_chan(chan); + struct dw_dma_slave *dws = param; + +- if (!dws || dws->dma_dev != chan->device->dev) ++ if (dws->dma_dev != chan->device->dev) + return false; + + /* We have to copy data since dws can be temporary storage */ +@@ -1160,6 +1148,14 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan) + * doesn't mean what you think it means), and status writeback. + */ + ++ /* ++ * We need controller-specific data to set up slave transfers. ++ */ ++ if (chan->private && !dw_dma_filter(chan, chan->private)) { ++ dev_warn(chan2dev(chan), "Wrong controller-specific data\n"); ++ return -EINVAL; ++ } ++ + /* Enable controller here if needed */ + if (!dw->in_use) + dw_dma_on(dw); +@@ -1221,6 +1217,14 @@ static void dwc_free_chan_resources(struct dma_chan *chan) + spin_lock_irqsave(&dwc->lock, flags); + list_splice_init(&dwc->free_list, &list); + dwc->descs_allocated = 0; ++ ++ /* Clear custom channel configuration */ ++ dwc->src_id = 0; ++ dwc->dst_id = 0; ++ ++ dwc->src_master = 0; ++ dwc->dst_master = 0; ++ + dwc->initialized = false; + + /* Disable interrupts */ +diff --git a/drivers/dma/hsu/hsu.c b/drivers/dma/hsu/hsu.c +index f42f71e37e73..b863b685d2d5 100644 +--- a/drivers/dma/hsu/hsu.c ++++ b/drivers/dma/hsu/hsu.c +@@ -143,7 +143,7 @@ static u32 hsu_dma_chan_get_sr(struct hsu_dma_chan *hsuc) + sr = hsu_chan_readl(hsuc, HSU_CH_SR); + spin_unlock_irqrestore(&hsuc->lock, flags); + +- return sr; ++ return sr & ~(HSU_CH_SR_DESCE_ANY | HSU_CH_SR_CDESC_ANY); + } + + irqreturn_t hsu_dma_irq(struct hsu_dma_chip *chip, unsigned short nr) +diff --git a/drivers/dma/hsu/hsu.h b/drivers/dma/hsu/hsu.h +index 0275233cf550..6a54f351df90 100644 +--- a/drivers/dma/hsu/hsu.h ++++ b/drivers/dma/hsu/hsu.h +@@ -41,6 +41,9 @@ + #define HSU_CH_SR_DESCTO(x) BIT(8 + (x)) + #define HSU_CH_SR_DESCTO_ANY (BIT(11) | BIT(10) | BIT(9) | BIT(8)) + #define HSU_CH_SR_CHE BIT(15) ++#define HSU_CH_SR_DESCE(x) BIT(16 + (x)) ++#define HSU_CH_SR_DESCE_ANY (BIT(19) | BIT(18) | BIT(17) | BIT(16)) ++#define HSU_CH_SR_CDESC_ANY (BIT(31) | BIT(30)) + + /* Bits in HSU_CH_CR */ + #define HSU_CH_CR_CHA BIT(0) +diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c +index e2da64abbccd..16f7c4f2d8c8 100644 +--- a/drivers/gpio/gpio-pca953x.c ++++ b/drivers/gpio/gpio-pca953x.c +@@ -21,6 +21,7 @@ + #ifdef CONFIG_OF_GPIO + #include <linux/of_platform.h> + #endif ++#include <asm/unaligned.h> + + #define PCA953X_INPUT 0 + #define PCA953X_OUTPUT 1 +@@ -154,7 +155,7 @@ static int pca953x_write_regs(struct pca953x_chip *chip, int reg, u8 *val) + switch (chip->chip_type) { + case PCA953X_TYPE: + ret = i2c_smbus_write_word_data(chip->client, +- reg << 1, (u16) *val); ++ reg << 1, cpu_to_le16(get_unaligned((u16 *)val))); + break; + case PCA957X_TYPE: + ret = i2c_smbus_write_byte_data(chip->client, reg << 1, +diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c +index b103773df2a3..56323732c748 100644 +--- a/drivers/gpu/drm/i915/intel_display.c ++++ b/drivers/gpu/drm/i915/intel_display.c +@@ -5609,10 +5609,6 @@ static void intel_connector_check_state(struct intel_connector *connector) + connector->base.base.id, + connector->base.name); + +- /* there is no real hw state for MST connectors */ +- if (connector->mst_port) +- return; +- + I915_STATE_WARN(connector->base.dpms == DRM_MODE_DPMS_OFF, + "wrong connector dpms state\n"); + I915_STATE_WARN(connector->base.encoder != &encoder->base, +@@ -11225,13 +11221,6 @@ check_encoder_state(struct drm_device *dev) + if (connector->base.dpms != DRM_MODE_DPMS_OFF) + active = true; + } +- /* +- * for MST connectors if we unplug the connector is gone +- * away but the encoder is still connected to a crtc +- * until a modeset happens in response to the hotplug. +- */ +- if (!enabled && encoder->base.encoder_type == DRM_MODE_ENCODER_DPMST) +- continue; + + I915_STATE_WARN(!!encoder->base.crtc != enabled, + "encoder's enabled state mismatch " +diff --git a/drivers/gpu/drm/i915/intel_dp_mst.c b/drivers/gpu/drm/i915/intel_dp_mst.c +index 88c557551b89..8266a8d8b9df 100644 +--- a/drivers/gpu/drm/i915/intel_dp_mst.c ++++ b/drivers/gpu/drm/i915/intel_dp_mst.c +@@ -451,14 +451,23 @@ static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr, + { + struct intel_connector *intel_connector = to_intel_connector(connector); + struct drm_device *dev = connector->dev; +- /* need to nuke the connector */ +- drm_modeset_lock_all(dev); +- intel_connector_dpms(connector, DRM_MODE_DPMS_OFF); +- drm_modeset_unlock_all(dev); + + intel_connector->unregister(intel_connector); + ++ /* need to nuke the connector */ + drm_modeset_lock_all(dev); ++ if (connector->state->crtc) { ++ struct drm_mode_set set; ++ int ret; ++ ++ memset(&set, 0, sizeof(set)); ++ set.crtc = connector->state->crtc, ++ ++ ret = drm_atomic_helper_set_config(&set); ++ ++ WARN(ret, "Disabling mst crtc failed with %i\n", ret); ++ } ++ + intel_connector_remove_from_fbdev(intel_connector); + drm_connector_cleanup(connector); + drm_modeset_unlock_all(dev); +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index 52921a871230..18484301fc3e 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -367,10 +367,15 @@ static int qxl_crtc_cursor_set2(struct drm_crtc *crtc, + + qxl_bo_kunmap(user_bo); + ++ qcrtc->cur_x += qcrtc->hot_spot_x - hot_x; ++ qcrtc->cur_y += qcrtc->hot_spot_y - hot_y; ++ qcrtc->hot_spot_x = hot_x; ++ qcrtc->hot_spot_y = hot_y; ++ + cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release); + cmd->type = QXL_CURSOR_SET; +- cmd->u.set.position.x = qcrtc->cur_x; +- cmd->u.set.position.y = qcrtc->cur_y; ++ cmd->u.set.position.x = qcrtc->cur_x + qcrtc->hot_spot_x; ++ cmd->u.set.position.y = qcrtc->cur_y + qcrtc->hot_spot_y; + + cmd->u.set.shape = qxl_bo_physical_address(qdev, cursor_bo, 0); + +@@ -433,8 +438,8 @@ static int qxl_crtc_cursor_move(struct drm_crtc *crtc, + + cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release); + cmd->type = QXL_CURSOR_MOVE; +- cmd->u.position.x = qcrtc->cur_x; +- cmd->u.position.y = qcrtc->cur_y; ++ cmd->u.position.x = qcrtc->cur_x + qcrtc->hot_spot_x; ++ cmd->u.position.y = qcrtc->cur_y + qcrtc->hot_spot_y; + qxl_release_unmap(qdev, release, &cmd->release_info); + + qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false); +diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h +index e66143cc1a7a..eef66769245f 100644 +--- a/drivers/gpu/drm/qxl/qxl_drv.h ++++ b/drivers/gpu/drm/qxl/qxl_drv.h +@@ -135,6 +135,8 @@ struct qxl_crtc { + int index; + int cur_x; + int cur_y; ++ int hot_spot_x; ++ int hot_spot_y; + }; + + struct qxl_output { +diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c +index 1764a168888c..49a259fc610e 100644 +--- a/drivers/hid/usbhid/hid-core.c ++++ b/drivers/hid/usbhid/hid-core.c +@@ -950,14 +950,6 @@ static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count) + return ret; + } + +-static void usbhid_restart_queues(struct usbhid_device *usbhid) +-{ +- if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)) +- usbhid_restart_out_queue(usbhid); +- if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) +- usbhid_restart_ctrl_queue(usbhid); +-} +- + static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) + { + struct usbhid_device *usbhid = hid->driver_data; +@@ -1403,6 +1395,37 @@ static void hid_cease_io(struct usbhid_device *usbhid) + usb_kill_urb(usbhid->urbout); + } + ++static void hid_restart_io(struct hid_device *hid) ++{ ++ struct usbhid_device *usbhid = hid->driver_data; ++ int clear_halt = test_bit(HID_CLEAR_HALT, &usbhid->iofl); ++ int reset_pending = test_bit(HID_RESET_PENDING, &usbhid->iofl); ++ ++ spin_lock_irq(&usbhid->lock); ++ clear_bit(HID_SUSPENDED, &usbhid->iofl); ++ usbhid_mark_busy(usbhid); ++ ++ if (clear_halt || reset_pending) ++ schedule_work(&usbhid->reset_work); ++ usbhid->retry_delay = 0; ++ spin_unlock_irq(&usbhid->lock); ++ ++ if (reset_pending || !test_bit(HID_STARTED, &usbhid->iofl)) ++ return; ++ ++ if (!clear_halt) { ++ if (hid_start_in(hid) < 0) ++ hid_io_error(hid); ++ } ++ ++ spin_lock_irq(&usbhid->lock); ++ if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)) ++ usbhid_restart_out_queue(usbhid); ++ if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) ++ usbhid_restart_ctrl_queue(usbhid); ++ spin_unlock_irq(&usbhid->lock); ++} ++ + /* Treat USB reset pretty much the same as suspend/resume */ + static int hid_pre_reset(struct usb_interface *intf) + { +@@ -1452,14 +1475,14 @@ static int hid_post_reset(struct usb_interface *intf) + return 1; + } + ++ /* No need to do another reset or clear a halted endpoint */ + spin_lock_irq(&usbhid->lock); + clear_bit(HID_RESET_PENDING, &usbhid->iofl); ++ clear_bit(HID_CLEAR_HALT, &usbhid->iofl); + spin_unlock_irq(&usbhid->lock); + hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0); +- status = hid_start_in(hid); +- if (status < 0) +- hid_io_error(hid); +- usbhid_restart_queues(usbhid); ++ ++ hid_restart_io(hid); + + return 0; + } +@@ -1482,25 +1505,9 @@ void usbhid_put_power(struct hid_device *hid) + #ifdef CONFIG_PM + static int hid_resume_common(struct hid_device *hid, bool driver_suspended) + { +- struct usbhid_device *usbhid = hid->driver_data; +- int status; +- +- spin_lock_irq(&usbhid->lock); +- clear_bit(HID_SUSPENDED, &usbhid->iofl); +- usbhid_mark_busy(usbhid); +- +- if (test_bit(HID_CLEAR_HALT, &usbhid->iofl) || +- test_bit(HID_RESET_PENDING, &usbhid->iofl)) +- schedule_work(&usbhid->reset_work); +- usbhid->retry_delay = 0; +- +- usbhid_restart_queues(usbhid); +- spin_unlock_irq(&usbhid->lock); +- +- status = hid_start_in(hid); +- if (status < 0) +- hid_io_error(hid); ++ int status = 0; + ++ hid_restart_io(hid); + if (driver_suspended && hid->driver && hid->driver->resume) + status = hid->driver->resume(hid); + return status; +@@ -1569,12 +1576,8 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message) + static int hid_resume(struct usb_interface *intf) + { + struct hid_device *hid = usb_get_intfdata (intf); +- struct usbhid_device *usbhid = hid->driver_data; + int status; + +- if (!test_bit(HID_STARTED, &usbhid->iofl)) +- return 0; +- + status = hid_resume_common(hid, true); + dev_dbg(&intf->dev, "resume status %d\n", status); + return 0; +@@ -1583,10 +1586,8 @@ static int hid_resume(struct usb_interface *intf) + static int hid_reset_resume(struct usb_interface *intf) + { + struct hid_device *hid = usb_get_intfdata(intf); +- struct usbhid_device *usbhid = hid->driver_data; + int status; + +- clear_bit(HID_SUSPENDED, &usbhid->iofl); + status = hid_post_reset(intf); + if (status >= 0 && hid->driver && hid->driver->reset_resume) { + int ret = hid->driver->reset_resume(hid); +diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c +index 082ae6ba492f..1741c33674c3 100644 +--- a/drivers/media/usb/au0828/au0828-core.c ++++ b/drivers/media/usb/au0828/au0828-core.c +@@ -159,7 +159,7 @@ static void au0828_usb_disconnect(struct usb_interface *interface) + Set the status so poll routines can check and avoid + access after disconnect. + */ +- dev->dev_state = DEV_DISCONNECTED; ++ set_bit(DEV_DISCONNECTED, &dev->dev_state); + + au0828_rc_unregister(dev); + /* Digital TV */ +diff --git a/drivers/media/usb/au0828/au0828-input.c b/drivers/media/usb/au0828/au0828-input.c +index b0f067971979..3d6687f0407d 100644 +--- a/drivers/media/usb/au0828/au0828-input.c ++++ b/drivers/media/usb/au0828/au0828-input.c +@@ -130,7 +130,7 @@ static int au0828_get_key_au8522(struct au0828_rc *ir) + bool first = true; + + /* do nothing if device is disconnected */ +- if (ir->dev->dev_state == DEV_DISCONNECTED) ++ if (test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) + return 0; + + /* Check IR int */ +@@ -260,7 +260,7 @@ static void au0828_rc_stop(struct rc_dev *rc) + cancel_delayed_work_sync(&ir->work); + + /* do nothing if device is disconnected */ +- if (ir->dev->dev_state != DEV_DISCONNECTED) { ++ if (!test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) { + /* Disable IR */ + au8522_rc_clear(ir, 0xe0, 1 << 4); + } +diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c +index 1a362a041ab3..0605c0f35059 100644 +--- a/drivers/media/usb/au0828/au0828-video.c ++++ b/drivers/media/usb/au0828/au0828-video.c +@@ -104,14 +104,13 @@ static inline void print_err_status(struct au0828_dev *dev, + + static int check_dev(struct au0828_dev *dev) + { +- if (dev->dev_state & DEV_DISCONNECTED) { ++ if (test_bit(DEV_DISCONNECTED, &dev->dev_state)) { + pr_info("v4l2 ioctl: device not present\n"); + return -ENODEV; + } + +- if (dev->dev_state & DEV_MISCONFIGURED) { +- pr_info("v4l2 ioctl: device is misconfigured; " +- "close and open it again\n"); ++ if (test_bit(DEV_MISCONFIGURED, &dev->dev_state)) { ++ pr_info("v4l2 ioctl: device is misconfigured; close and open it again\n"); + return -EIO; + } + return 0; +@@ -519,8 +518,8 @@ static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb) + if (!dev) + return 0; + +- if ((dev->dev_state & DEV_DISCONNECTED) || +- (dev->dev_state & DEV_MISCONFIGURED)) ++ if (test_bit(DEV_DISCONNECTED, &dev->dev_state) || ++ test_bit(DEV_MISCONFIGURED, &dev->dev_state)) + return 0; + + if (urb->status < 0) { +@@ -761,10 +760,10 @@ static int au0828_stream_interrupt(struct au0828_dev *dev) + int ret = 0; + + dev->stream_state = STREAM_INTERRUPT; +- if (dev->dev_state == DEV_DISCONNECTED) ++ if (test_bit(DEV_DISCONNECTED, &dev->dev_state)) + return -ENODEV; + else if (ret) { +- dev->dev_state = DEV_MISCONFIGURED; ++ set_bit(DEV_MISCONFIGURED, &dev->dev_state); + dprintk(1, "%s device is misconfigured!\n", __func__); + return ret; + } +@@ -952,7 +951,7 @@ static int au0828_v4l2_open(struct file *filp) + int ret; + + dprintk(1, +- "%s called std_set %d dev_state %d stream users %d users %d\n", ++ "%s called std_set %d dev_state %ld stream users %d users %d\n", + __func__, dev->std_set_in_tuner_core, dev->dev_state, + dev->streaming_users, dev->users); + +@@ -971,7 +970,7 @@ static int au0828_v4l2_open(struct file *filp) + au0828_analog_stream_enable(dev); + au0828_analog_stream_reset(dev); + dev->stream_state = STREAM_OFF; +- dev->dev_state |= DEV_INITIALIZED; ++ set_bit(DEV_INITIALIZED, &dev->dev_state); + } + dev->users++; + mutex_unlock(&dev->lock); +@@ -985,7 +984,7 @@ static int au0828_v4l2_close(struct file *filp) + struct video_device *vdev = video_devdata(filp); + + dprintk(1, +- "%s called std_set %d dev_state %d stream users %d users %d\n", ++ "%s called std_set %d dev_state %ld stream users %d users %d\n", + __func__, dev->std_set_in_tuner_core, dev->dev_state, + dev->streaming_users, dev->users); + +@@ -1001,7 +1000,7 @@ static int au0828_v4l2_close(struct file *filp) + del_timer_sync(&dev->vbi_timeout); + } + +- if (dev->dev_state == DEV_DISCONNECTED) ++ if (test_bit(DEV_DISCONNECTED, &dev->dev_state)) + goto end; + + if (dev->users == 1) { +@@ -1030,7 +1029,7 @@ static void au0828_init_tuner(struct au0828_dev *dev) + .type = V4L2_TUNER_ANALOG_TV, + }; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + if (dev->std_set_in_tuner_core) +@@ -1102,7 +1101,7 @@ static int vidioc_querycap(struct file *file, void *priv, + struct video_device *vdev = video_devdata(file); + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + strlcpy(cap->driver, "au0828", sizeof(cap->driver)); +@@ -1145,7 +1144,7 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + f->fmt.pix.width = dev->width; +@@ -1164,7 +1163,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + return au0828_set_format(dev, VIDIOC_TRY_FMT, f); +@@ -1176,7 +1175,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, + struct au0828_dev *dev = video_drvdata(file); + int rc; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + rc = check_dev(dev); +@@ -1198,7 +1197,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm) + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + if (norm == dev->std) +@@ -1230,7 +1229,7 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm) + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + *norm = dev->std; +@@ -1253,7 +1252,7 @@ static int vidioc_enum_input(struct file *file, void *priv, + [AU0828_VMUX_DEBUG] = "tv debug" + }; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + tmp = input->index; +@@ -1283,7 +1282,7 @@ static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + *i = dev->ctrl_input; +@@ -1294,7 +1293,7 @@ static void au0828_s_input(struct au0828_dev *dev, int index) + { + int i; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + switch (AUVI_INPUT(index).type) { +@@ -1379,7 +1378,7 @@ static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + a->index = dev->ctrl_ainput; +@@ -1399,7 +1398,7 @@ static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio + if (a->index != dev->ctrl_ainput) + return -EINVAL; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + return 0; + } +@@ -1411,7 +1410,7 @@ static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) + if (t->index != 0) + return -EINVAL; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + strcpy(t->name, "Auvitek tuner"); +@@ -1431,7 +1430,7 @@ static int vidioc_s_tuner(struct file *file, void *priv, + if (t->index != 0) + return -EINVAL; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + au0828_init_tuner(dev); +@@ -1453,7 +1452,7 @@ static int vidioc_g_frequency(struct file *file, void *priv, + + if (freq->tuner != 0) + return -EINVAL; +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + freq->frequency = dev->ctrl_freq; + return 0; +@@ -1468,7 +1467,7 @@ static int vidioc_s_frequency(struct file *file, void *priv, + if (freq->tuner != 0) + return -EINVAL; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + au0828_init_tuner(dev); +@@ -1494,7 +1493,7 @@ static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + format->fmt.vbi.samples_per_line = dev->vbi_width; +@@ -1520,7 +1519,7 @@ static int vidioc_cropcap(struct file *file, void *priv, + if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + cc->bounds.left = 0; +@@ -1542,7 +1541,7 @@ static int vidioc_g_register(struct file *file, void *priv, + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + reg->val = au0828_read(dev, reg->reg); +@@ -1555,7 +1554,7 @@ static int vidioc_s_register(struct file *file, void *priv, + { + struct au0828_dev *dev = video_drvdata(file); + +- dprintk(1, "%s called std_set %d dev_state %d\n", __func__, ++ dprintk(1, "%s called std_set %d dev_state %ld\n", __func__, + dev->std_set_in_tuner_core, dev->dev_state); + + return au0828_writereg(dev, reg->reg, reg->val); +diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h +index 3b480005ce3b..42a5379c6aa3 100644 +--- a/drivers/media/usb/au0828/au0828.h ++++ b/drivers/media/usb/au0828/au0828.h +@@ -21,6 +21,7 @@ + + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + ++#include <linux/bitops.h> + #include <linux/usb.h> + #include <linux/i2c.h> + #include <linux/i2c-algo-bit.h> +@@ -121,9 +122,9 @@ enum au0828_stream_state { + + /* device state */ + enum au0828_dev_state { +- DEV_INITIALIZED = 0x01, +- DEV_DISCONNECTED = 0x02, +- DEV_MISCONFIGURED = 0x04 ++ DEV_INITIALIZED = 0, ++ DEV_DISCONNECTED = 1, ++ DEV_MISCONFIGURED = 2 + }; + + struct au0828_dev; +@@ -247,7 +248,7 @@ struct au0828_dev { + int input_type; + int std_set_in_tuner_core; + unsigned int ctrl_input; +- enum au0828_dev_state dev_state; ++ long unsigned int dev_state; /* defined at enum au0828_dev_state */; + enum au0828_stream_state stream_state; + wait_queue_head_t open; + +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index c66fd23b3c13..1a82a8552182 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -1260,18 +1260,19 @@ static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo) + struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk); + struct scsi_device *sdp = sdkp->device; + struct Scsi_Host *host = sdp->host; ++ sector_t capacity = logical_to_sectors(sdp, sdkp->capacity); + int diskinfo[4]; + + /* default to most commonly used values */ +- diskinfo[0] = 0x40; /* 1 << 6 */ +- diskinfo[1] = 0x20; /* 1 << 5 */ +- diskinfo[2] = sdkp->capacity >> 11; +- ++ diskinfo[0] = 0x40; /* 1 << 6 */ ++ diskinfo[1] = 0x20; /* 1 << 5 */ ++ diskinfo[2] = capacity >> 11; ++ + /* override with calculated, extended default, or driver values */ + if (host->hostt->bios_param) +- host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo); ++ host->hostt->bios_param(sdp, bdev, capacity, diskinfo); + else +- scsicam_bios_param(bdev, sdkp->capacity, diskinfo); ++ scsicam_bios_param(bdev, capacity, diskinfo); + + geo->heads = diskinfo[0]; + geo->sectors = diskinfo[1]; +@@ -2230,14 +2231,6 @@ got_data: + } else + sdkp->max_xfer_blocks = SD_DEF_XFER_BLOCKS; + +- /* Rescale capacity to 512-byte units */ +- if (sector_size == 4096) +- sdkp->capacity <<= 3; +- else if (sector_size == 2048) +- sdkp->capacity <<= 2; +- else if (sector_size == 1024) +- sdkp->capacity <<= 1; +- + blk_queue_physical_block_size(sdp->request_queue, + sdkp->physical_block_size); + sdkp->device->sector_size = sector_size; +@@ -2773,7 +2766,7 @@ static int sd_revalidate_disk(struct gendisk *disk) + sdkp->disk->queue->limits.max_sectors = + min_not_zero(queue_max_hw_sectors(sdkp->disk->queue), max_xfer); + +- set_capacity(disk, sdkp->capacity); ++ set_capacity(disk, logical_to_sectors(sdp, sdkp->capacity)); + sd_config_write_same(sdkp); + kfree(buffer); + +diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h +index 63ba5ca7f9a1..0264936a855a 100644 +--- a/drivers/scsi/sd.h ++++ b/drivers/scsi/sd.h +@@ -65,7 +65,7 @@ struct scsi_disk { + struct device dev; + struct gendisk *disk; + atomic_t openers; +- sector_t capacity; /* size in 512-byte sectors */ ++ sector_t capacity; /* size in logical blocks */ + u32 max_xfer_blocks; + u32 max_ws_blocks; + u32 max_unmap_blocks; +@@ -145,6 +145,11 @@ static inline int scsi_medium_access_command(struct scsi_cmnd *scmd) + return 0; + } + ++static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks) ++{ ++ return blocks << (ilog2(sdev->sector_size) - 9); ++} ++ + /* + * A DIF-capable target device can be formatted with different + * protection schemes. Currently 0 through 3 are defined: +diff --git a/drivers/thermal/thermal_core.c b/drivers/thermal/thermal_core.c +index 09f1e5f2f013..a61386ce41ee 100644 +--- a/drivers/thermal/thermal_core.c ++++ b/drivers/thermal/thermal_core.c +@@ -1491,7 +1491,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type, + { + struct thermal_zone_device *tz; + enum thermal_trip_type trip_type; +- int trip_temp; ++ unsigned long trip_temp; + int result; + int count; + int passive = 0; +diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c +index 9eb1cff28bd4..b8b580e5ae6e 100644 +--- a/drivers/usb/core/hcd-pci.c ++++ b/drivers/usb/core/hcd-pci.c +@@ -74,6 +74,15 @@ static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd, + if (companion->bus != pdev->bus || + PCI_SLOT(companion->devfn) != slot) + continue; ++ ++ /* ++ * Companion device should be either UHCI,OHCI or EHCI host ++ * controller, otherwise skip. ++ */ ++ if (companion->class != CL_UHCI && companion->class != CL_OHCI && ++ companion->class != CL_EHCI) ++ continue; ++ + companion_hcd = pci_get_drvdata(companion); + if (!companion_hcd || !companion_hcd->self.root_hub) + continue; +diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c +index 41f841fa6c4d..5ab70afd5624 100644 +--- a/drivers/usb/host/xhci-mem.c ++++ b/drivers/usb/host/xhci-mem.c +@@ -1879,6 +1879,12 @@ no_bw: + kfree(xhci->rh_bw); + kfree(xhci->ext_caps); + ++ xhci->usb2_ports = NULL; ++ xhci->usb3_ports = NULL; ++ xhci->port_array = NULL; ++ xhci->rh_bw = NULL; ++ xhci->ext_caps = NULL; ++ + xhci->page_size = 0; + xhci->page_shift = 0; + xhci->bus_state[0].bus_suspended = 0; +diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c +index 3ff5fcc7c94b..c6027acb6263 100644 +--- a/drivers/usb/host/xhci-pci.c ++++ b/drivers/usb/host/xhci-pci.c +@@ -48,6 +48,7 @@ + #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI 0xa12f + #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI 0x9d2f + #define PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI 0x0aa8 ++#define PCI_DEVICE_ID_INTEL_BROXTON_B_XHCI 0x1aa8 + + static const char hcd_name[] = "xhci_hcd"; + +@@ -149,7 +150,8 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci) + (pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI || + pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI || + pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI || +- pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI)) { ++ pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI || ++ pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_B_XHCI)) { + xhci->quirks |= XHCI_PME_STUCK_QUIRK; + } + if (pdev->vendor == PCI_VENDOR_ID_INTEL && +@@ -296,6 +298,7 @@ static void xhci_pci_remove(struct pci_dev *dev) + struct xhci_hcd *xhci; + + xhci = hcd_to_xhci(pci_get_drvdata(dev)); ++ xhci->xhc_state |= XHCI_STATE_REMOVING; + if (xhci->shared_hcd) { + usb_remove_hcd(xhci->shared_hcd); + usb_put_hcd(xhci->shared_hcd); +diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c +index e6d858a49d04..6fe0377ec5cf 100644 +--- a/drivers/usb/host/xhci-ring.c ++++ b/drivers/usb/host/xhci-ring.c +@@ -3823,8 +3823,12 @@ static int queue_command(struct xhci_hcd *xhci, struct xhci_command *cmd, + { + int reserved_trbs = xhci->cmd_ring_reserved_trbs; + int ret; +- if (xhci->xhc_state & XHCI_STATE_DYING) ++ ++ if ((xhci->xhc_state & XHCI_STATE_DYING) || ++ (xhci->xhc_state & XHCI_STATE_HALTED)) { ++ xhci_dbg(xhci, "xHCI dying or halted, can't queue_command\n"); + return -ESHUTDOWN; ++ } + + if (!command_must_succeed) + reserved_trbs++; +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index 910f7fac031f..896b928f7412 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -146,7 +146,8 @@ static int xhci_start(struct xhci_hcd *xhci) + "waited %u microseconds.\n", + XHCI_MAX_HALT_USEC); + if (!ret) +- xhci->xhc_state &= ~(XHCI_STATE_HALTED | XHCI_STATE_DYING); ++ /* clear state flags. Including dying, halted or removing */ ++ xhci->xhc_state = 0; + + return ret; + } +@@ -1113,8 +1114,8 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) + /* Resume root hubs only when have pending events. */ + status = readl(&xhci->op_regs->status); + if (status & STS_EINT) { +- usb_hcd_resume_root_hub(hcd); + usb_hcd_resume_root_hub(xhci->shared_hcd); ++ usb_hcd_resume_root_hub(hcd); + } + } + +@@ -1129,10 +1130,10 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) + + /* Re-enable port polling. */ + xhci_dbg(xhci, "%s: starting port polling.\n", __func__); +- set_bit(HCD_FLAG_POLL_RH, &hcd->flags); +- usb_hcd_poll_rh_status(hcd); + set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); + usb_hcd_poll_rh_status(xhci->shared_hcd); ++ set_bit(HCD_FLAG_POLL_RH, &hcd->flags); ++ usb_hcd_poll_rh_status(hcd); + + return retval; + } +@@ -2763,7 +2764,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev) + if (ret <= 0) + return ret; + xhci = hcd_to_xhci(hcd); +- if (xhci->xhc_state & XHCI_STATE_DYING) ++ if ((xhci->xhc_state & XHCI_STATE_DYING) || ++ (xhci->xhc_state & XHCI_STATE_REMOVING)) + return -ENODEV; + + xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev); +@@ -3812,7 +3814,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev, + + mutex_lock(&xhci->mutex); + +- if (xhci->xhc_state) /* dying or halted */ ++ if (xhci->xhc_state) /* dying, removing or halted */ + goto out; + + if (!udev->slot_id) { +@@ -4939,6 +4941,16 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks) + goto error; + xhci_dbg(xhci, "Reset complete\n"); + ++ /* ++ * On some xHCI controllers (e.g. R-Car SoCs), the AC64 bit (bit 0) ++ * of HCCPARAMS1 is set to 1. However, the xHCs don't support 64-bit ++ * address memory pointers actually. So, this driver clears the AC64 ++ * bit of xhci->hcc_params to call dma_set_coherent_mask(dev, ++ * DMA_BIT_MASK(32)) in this xhci_gen_setup(). ++ */ ++ if (xhci->quirks & XHCI_NO_64BIT_SUPPORT) ++ xhci->hcc_params &= ~BIT(0); ++ + /* Set dma_mask and coherent_dma_mask to 64-bits, + * if xHC supports 64-bit addressing */ + if (HCC_64BIT_ADDR(xhci->hcc_params) && +diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h +index f18cdf0ec795..c5d6963e9cbe 100644 +--- a/drivers/usb/host/xhci.h ++++ b/drivers/usb/host/xhci.h +@@ -1536,6 +1536,7 @@ struct xhci_hcd { + */ + #define XHCI_STATE_DYING (1 << 0) + #define XHCI_STATE_HALTED (1 << 1) ++#define XHCI_STATE_REMOVING (1 << 2) + /* Statistics */ + int error_bitmask; + unsigned int quirks; +@@ -1571,6 +1572,7 @@ struct xhci_hcd { + #define XHCI_BROKEN_STREAMS (1 << 19) + #define XHCI_PME_STUCK_QUIRK (1 << 20) + #define XHCI_SSIC_PORT_UNUSED (1 << 22) ++#define XHCI_NO_64BIT_SUPPORT (1 << 23) + unsigned int num_active_eps; + unsigned int limit_active_eps; + /* There are two roothubs to keep track of bus suspend info for */ +diff --git a/drivers/usb/renesas_usbhs/fifo.c b/drivers/usb/renesas_usbhs/fifo.c +index c0f5c652d272..f1893e08e51a 100644 +--- a/drivers/usb/renesas_usbhs/fifo.c ++++ b/drivers/usb/renesas_usbhs/fifo.c +@@ -190,7 +190,8 @@ static int usbhsf_pkt_handler(struct usbhs_pipe *pipe, int type) + goto __usbhs_pkt_handler_end; + } + +- ret = func(pkt, &is_done); ++ if (likely(func)) ++ ret = func(pkt, &is_done); + + if (is_done) + __usbhsf_pkt_del(pkt); +@@ -889,6 +890,7 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done) + + pkt->trans = len; + ++ usbhsf_tx_irq_ctrl(pipe, 0); + INIT_WORK(&pkt->work, xfer_work); + schedule_work(&pkt->work); + +diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c +index dc2aa3261202..046529656465 100644 +--- a/drivers/usb/renesas_usbhs/mod_gadget.c ++++ b/drivers/usb/renesas_usbhs/mod_gadget.c +@@ -154,10 +154,14 @@ static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt) + struct usbhs_pipe *pipe = pkt->pipe; + struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe); + struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt); ++ unsigned long flags; + + ureq->req.actual = pkt->actual; + +- usbhsg_queue_pop(uep, ureq, 0); ++ usbhs_lock(priv, flags); ++ if (uep) ++ __usbhsg_queue_pop(uep, ureq, 0); ++ usbhs_unlock(priv, flags); + } + + static void usbhsg_queue_push(struct usbhsg_uep *uep, +diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c +index 7a76fe4c2f9e..bdc0f2f24f19 100644 +--- a/drivers/usb/serial/cp210x.c ++++ b/drivers/usb/serial/cp210x.c +@@ -164,6 +164,7 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x18EF, 0xE025) }, /* ELV Marble Sound Board 1 */ + { USB_DEVICE(0x1901, 0x0190) }, /* GE B850 CP2105 Recorder interface */ + { USB_DEVICE(0x1901, 0x0193) }, /* GE B650 CP2104 PMC interface */ ++ { USB_DEVICE(0x1901, 0x0194) }, /* GE Healthcare Remote Alarm Box */ + { USB_DEVICE(0x19CF, 0x3000) }, /* Parrot NMEA GPS Flight Recorder */ + { USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */ + { USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */ +diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c +index 01bf53392819..244acb1299a9 100644 +--- a/drivers/usb/serial/cypress_m8.c ++++ b/drivers/usb/serial/cypress_m8.c +@@ -447,6 +447,11 @@ static int cypress_generic_port_probe(struct usb_serial_port *port) + struct usb_serial *serial = port->serial; + struct cypress_private *priv; + ++ if (!port->interrupt_out_urb || !port->interrupt_in_urb) { ++ dev_err(&port->dev, "required endpoint is missing\n"); ++ return -ENODEV; ++ } ++ + priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL); + if (!priv) + return -ENOMEM; +@@ -606,12 +611,6 @@ static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port) + cypress_set_termios(tty, port, &priv->tmp_termios); + + /* setup the port and start reading from the device */ +- if (!port->interrupt_in_urb) { +- dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n", +- __func__); +- return -1; +- } +- + usb_fill_int_urb(port->interrupt_in_urb, serial->dev, + usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress), + port->interrupt_in_urb->transfer_buffer, +diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c +index 12b0e67473ba..3df7b7ec178e 100644 +--- a/drivers/usb/serial/digi_acceleport.c ++++ b/drivers/usb/serial/digi_acceleport.c +@@ -1251,8 +1251,27 @@ static int digi_port_init(struct usb_serial_port *port, unsigned port_num) + + static int digi_startup(struct usb_serial *serial) + { ++ struct device *dev = &serial->interface->dev; + struct digi_serial *serial_priv; + int ret; ++ int i; ++ ++ /* check whether the device has the expected number of endpoints */ ++ if (serial->num_port_pointers < serial->type->num_ports + 1) { ++ dev_err(dev, "OOB endpoints missing\n"); ++ return -ENODEV; ++ } ++ ++ for (i = 0; i < serial->type->num_ports + 1 ; i++) { ++ if (!serial->port[i]->read_urb) { ++ dev_err(dev, "bulk-in endpoint missing\n"); ++ return -ENODEV; ++ } ++ if (!serial->port[i]->write_urb) { ++ dev_err(dev, "bulk-out endpoint missing\n"); ++ return -ENODEV; ++ } ++ } + + serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL); + if (!serial_priv) +diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c +index 8c660ae401d8..b61f12160d37 100644 +--- a/drivers/usb/serial/ftdi_sio.c ++++ b/drivers/usb/serial/ftdi_sio.c +@@ -1004,6 +1004,10 @@ static const struct usb_device_id id_table_combined[] = { + { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_DISPLAY_PID) }, + { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_LITE_PID) }, + { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_ANALOG_PID) }, ++ /* ICP DAS I-756xU devices */ ++ { USB_DEVICE(ICPDAS_VID, ICPDAS_I7560U_PID) }, ++ { USB_DEVICE(ICPDAS_VID, ICPDAS_I7561U_PID) }, ++ { USB_DEVICE(ICPDAS_VID, ICPDAS_I7563U_PID) }, + { } /* Terminating entry */ + }; + +diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h +index 7850071c0ae1..334bc600282d 100644 +--- a/drivers/usb/serial/ftdi_sio_ids.h ++++ b/drivers/usb/serial/ftdi_sio_ids.h +@@ -872,6 +872,14 @@ + #define NOVITUS_BONO_E_PID 0x6010 + + /* ++ * ICPDAS I-756*U devices ++ */ ++#define ICPDAS_VID 0x1b5c ++#define ICPDAS_I7560U_PID 0x0103 ++#define ICPDAS_I7561U_PID 0x0104 ++#define ICPDAS_I7563U_PID 0x0105 ++ ++/* + * RT Systems programming cables for various ham radios + */ + #define RTSYSTEMS_VID 0x2100 /* Vendor ID */ +diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c +index fd707d6a10e2..89726f702202 100644 +--- a/drivers/usb/serial/mct_u232.c ++++ b/drivers/usb/serial/mct_u232.c +@@ -376,14 +376,21 @@ static void mct_u232_msr_to_state(struct usb_serial_port *port, + + static int mct_u232_port_probe(struct usb_serial_port *port) + { ++ struct usb_serial *serial = port->serial; + struct mct_u232_private *priv; + ++ /* check first to simplify error handling */ ++ if (!serial->port[1] || !serial->port[1]->interrupt_in_urb) { ++ dev_err(&port->dev, "expected endpoint missing\n"); ++ return -ENODEV; ++ } ++ + priv = kzalloc(sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + /* Use second interrupt-in endpoint for reading. */ +- priv->read_urb = port->serial->port[1]->interrupt_in_urb; ++ priv->read_urb = serial->port[1]->interrupt_in_urb; + priv->read_urb->context = port; + + spin_lock_init(&priv->lock); +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index ce3d6af977b7..94e520de6404 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -1830,6 +1830,8 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d02, 0xff, 0x00, 0x00) }, + { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x02, 0x01) }, + { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x00, 0x00) }, ++ { USB_DEVICE_INTERFACE_CLASS(0x2001, 0x7e19, 0xff), /* D-Link DWM-221 B1 */ ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, + { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */ + { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */ + { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x4000, 0xff) }, /* OLICARD300 - MT6225 */ +diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c +index 637ee7754ad5..546bb2b1ffc2 100644 +--- a/drivers/usb/storage/uas.c ++++ b/drivers/usb/storage/uas.c +@@ -2,7 +2,7 @@ + * USB Attached SCSI + * Note that this is not the same as the USB Mass Storage driver + * +- * Copyright Hans de Goede <[email protected]> for Red Hat, Inc. 2013 - 2014 ++ * Copyright Hans de Goede <[email protected]> for Red Hat, Inc. 2013 - 2016 + * Copyright Matthew Wilcox for Intel Corp, 2010 + * Copyright Sarah Sharp for Intel Corp, 2010 + * +@@ -757,6 +757,17 @@ static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd) + return SUCCESS; + } + ++static int uas_target_alloc(struct scsi_target *starget) ++{ ++ struct uas_dev_info *devinfo = (struct uas_dev_info *) ++ dev_to_shost(starget->dev.parent)->hostdata; ++ ++ if (devinfo->flags & US_FL_NO_REPORT_LUNS) ++ starget->no_report_luns = 1; ++ ++ return 0; ++} ++ + static int uas_slave_alloc(struct scsi_device *sdev) + { + struct uas_dev_info *devinfo = +@@ -808,6 +819,7 @@ static struct scsi_host_template uas_host_template = { + .module = THIS_MODULE, + .name = "uas", + .queuecommand = uas_queuecommand, ++ .target_alloc = uas_target_alloc, + .slave_alloc = uas_slave_alloc, + .slave_configure = uas_slave_configure, + .eh_abort_handler = uas_eh_abort_handler, +diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h +index ccc113e83d88..53341a77d89f 100644 +--- a/drivers/usb/storage/unusual_uas.h ++++ b/drivers/usb/storage/unusual_uas.h +@@ -64,6 +64,13 @@ UNUSUAL_DEV(0x0bc2, 0x3312, 0x0000, 0x9999, + USB_SC_DEVICE, USB_PR_DEVICE, NULL, + US_FL_NO_ATA_1X), + ++/* Reported-by: David Webb <[email protected]> */ ++UNUSUAL_DEV(0x0bc2, 0x331a, 0x0000, 0x9999, ++ "Seagate", ++ "Expansion Desk", ++ USB_SC_DEVICE, USB_PR_DEVICE, NULL, ++ US_FL_NO_REPORT_LUNS), ++ + /* Reported-by: Hans de Goede <[email protected]> */ + UNUSUAL_DEV(0x0bc2, 0x3320, 0x0000, 0x9999, + "Seagate", +diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c +index 6c10c888f35f..ba8f759e723f 100644 +--- a/drivers/usb/storage/usb.c ++++ b/drivers/usb/storage/usb.c +@@ -480,7 +480,7 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags) + US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 | + US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE | + US_FL_NO_ATA_1X | US_FL_NO_REPORT_OPCODES | +- US_FL_MAX_SECTORS_240); ++ US_FL_MAX_SECTORS_240 | US_FL_NO_REPORT_LUNS); + + p = quirks; + while (*p) { +@@ -530,6 +530,9 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags) + case 'i': + f |= US_FL_IGNORE_DEVICE; + break; ++ case 'j': ++ f |= US_FL_NO_REPORT_LUNS; ++ break; + case 'l': + f |= US_FL_NOT_LOCKABLE; + break; +diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c +index e88e0997a889..6652258048df 100644 +--- a/drivers/virtio/virtio_pci_modern.c ++++ b/drivers/virtio/virtio_pci_modern.c +@@ -17,6 +17,7 @@ + * + */ + ++#include <linux/delay.h> + #define VIRTIO_PCI_NO_LEGACY + #include "virtio_pci_common.h" + +@@ -271,9 +272,13 @@ static void vp_reset(struct virtio_device *vdev) + struct virtio_pci_device *vp_dev = to_vp_device(vdev); + /* 0 status means a reset. */ + vp_iowrite8(0, &vp_dev->common->device_status); +- /* Flush out the status write, and flush in device writes, +- * including MSI-X interrupts, if any. */ +- vp_ioread8(&vp_dev->common->device_status); ++ /* After writing 0 to device_status, the driver MUST wait for a read of ++ * device_status to return 0 before reinitializing the device. ++ * This will flush out the status write, and flush in device writes, ++ * including MSI-X interrupts, if any. ++ */ ++ while (vp_ioread8(&vp_dev->common->device_status)) ++ msleep(1); + /* Flush pending VQ/configuration callbacks. */ + vp_synchronize_vectors(vdev); + } +diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c +index 38387950490e..511aab3b9206 100644 +--- a/drivers/xen/events/events_base.c ++++ b/drivers/xen/events/events_base.c +@@ -483,9 +483,19 @@ static void eoi_pirq(struct irq_data *data) + struct physdev_eoi eoi = { .irq = pirq_from_irq(data->irq) }; + int rc = 0; + +- irq_move_irq(data); ++ if (!VALID_EVTCHN(evtchn)) ++ return; + +- if (VALID_EVTCHN(evtchn)) ++ if (unlikely(irqd_is_setaffinity_pending(data))) { ++ int masked = test_and_set_mask(evtchn); ++ ++ clear_evtchn(evtchn); ++ ++ irq_move_masked_irq(data); ++ ++ if (!masked) ++ unmask_evtchn(evtchn); ++ } else + clear_evtchn(evtchn); + + if (pirq_needs_eoi(data->irq)) { +@@ -1360,9 +1370,19 @@ static void ack_dynirq(struct irq_data *data) + { + int evtchn = evtchn_from_irq(data->irq); + +- irq_move_irq(data); ++ if (!VALID_EVTCHN(evtchn)) ++ return; + +- if (VALID_EVTCHN(evtchn)) ++ if (unlikely(irqd_is_setaffinity_pending(data))) { ++ int masked = test_and_set_mask(evtchn); ++ ++ clear_evtchn(evtchn); ++ ++ irq_move_masked_irq(data); ++ ++ if (!masked) ++ unmask_evtchn(evtchn); ++ } else + clear_evtchn(evtchn); + } + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 4920fceffacb..5c222f3c4841 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -4123,6 +4123,308 @@ static int logged_inode_size(struct btrfs_root *log, struct inode *inode, + return 0; + } + ++/* ++ * At the moment we always log all xattrs. This is to figure out at log replay ++ * time which xattrs must have their deletion replayed. If a xattr is missing ++ * in the log tree and exists in the fs/subvol tree, we delete it. This is ++ * because if a xattr is deleted, the inode is fsynced and a power failure ++ * happens, causing the log to be replayed the next time the fs is mounted, ++ * we want the xattr to not exist anymore (same behaviour as other filesystems ++ * with a journal, ext3/4, xfs, f2fs, etc). ++ */ ++static int btrfs_log_all_xattrs(struct btrfs_trans_handle *trans, ++ struct btrfs_root *root, ++ struct inode *inode, ++ struct btrfs_path *path, ++ struct btrfs_path *dst_path) ++{ ++ int ret; ++ struct btrfs_key key; ++ const u64 ino = btrfs_ino(inode); ++ int ins_nr = 0; ++ int start_slot = 0; ++ ++ key.objectid = ino; ++ key.type = BTRFS_XATTR_ITEM_KEY; ++ key.offset = 0; ++ ++ ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); ++ if (ret < 0) ++ return ret; ++ ++ while (true) { ++ int slot = path->slots[0]; ++ struct extent_buffer *leaf = path->nodes[0]; ++ int nritems = btrfs_header_nritems(leaf); ++ ++ if (slot >= nritems) { ++ if (ins_nr > 0) { ++ u64 last_extent = 0; ++ ++ ret = copy_items(trans, inode, dst_path, path, ++ &last_extent, start_slot, ++ ins_nr, 1, 0); ++ /* can't be 1, extent items aren't processed */ ++ ASSERT(ret <= 0); ++ if (ret < 0) ++ return ret; ++ ins_nr = 0; ++ } ++ ret = btrfs_next_leaf(root, path); ++ if (ret < 0) ++ return ret; ++ else if (ret > 0) ++ break; ++ continue; ++ } ++ ++ btrfs_item_key_to_cpu(leaf, &key, slot); ++ if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY) ++ break; ++ ++ if (ins_nr == 0) ++ start_slot = slot; ++ ins_nr++; ++ path->slots[0]++; ++ cond_resched(); ++ } ++ if (ins_nr > 0) { ++ u64 last_extent = 0; ++ ++ ret = copy_items(trans, inode, dst_path, path, ++ &last_extent, start_slot, ++ ins_nr, 1, 0); ++ /* can't be 1, extent items aren't processed */ ++ ASSERT(ret <= 0); ++ if (ret < 0) ++ return ret; ++ } ++ ++ return 0; ++} ++ ++/* ++ * If the no holes feature is enabled we need to make sure any hole between the ++ * last extent and the i_size of our inode is explicitly marked in the log. This ++ * is to make sure that doing something like: ++ * ++ * 1) create file with 128Kb of data ++ * 2) truncate file to 64Kb ++ * 3) truncate file to 256Kb ++ * 4) fsync file ++ * 5) <crash/power failure> ++ * 6) mount fs and trigger log replay ++ * ++ * Will give us a file with a size of 256Kb, the first 64Kb of data match what ++ * the file had in its first 64Kb of data at step 1 and the last 192Kb of the ++ * file correspond to a hole. The presence of explicit holes in a log tree is ++ * what guarantees that log replay will remove/adjust file extent items in the ++ * fs/subvol tree. ++ * ++ * Here we do not need to care about holes between extents, that is already done ++ * by copy_items(). We also only need to do this in the full sync path, where we ++ * lookup for extents from the fs/subvol tree only. In the fast path case, we ++ * lookup the list of modified extent maps and if any represents a hole, we ++ * insert a corresponding extent representing a hole in the log tree. ++ */ ++static int btrfs_log_trailing_hole(struct btrfs_trans_handle *trans, ++ struct btrfs_root *root, ++ struct inode *inode, ++ struct btrfs_path *path) ++{ ++ int ret; ++ struct btrfs_key key; ++ u64 hole_start; ++ u64 hole_size; ++ struct extent_buffer *leaf; ++ struct btrfs_root *log = root->log_root; ++ const u64 ino = btrfs_ino(inode); ++ const u64 i_size = i_size_read(inode); ++ ++ if (!btrfs_fs_incompat(root->fs_info, NO_HOLES)) ++ return 0; ++ ++ key.objectid = ino; ++ key.type = BTRFS_EXTENT_DATA_KEY; ++ key.offset = (u64)-1; ++ ++ ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); ++ ASSERT(ret != 0); ++ if (ret < 0) ++ return ret; ++ ++ ASSERT(path->slots[0] > 0); ++ path->slots[0]--; ++ leaf = path->nodes[0]; ++ btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); ++ ++ if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY) { ++ /* inode does not have any extents */ ++ hole_start = 0; ++ hole_size = i_size; ++ } else { ++ struct btrfs_file_extent_item *extent; ++ u64 len; ++ ++ /* ++ * If there's an extent beyond i_size, an explicit hole was ++ * already inserted by copy_items(). ++ */ ++ if (key.offset >= i_size) ++ return 0; ++ ++ extent = btrfs_item_ptr(leaf, path->slots[0], ++ struct btrfs_file_extent_item); ++ ++ if (btrfs_file_extent_type(leaf, extent) == ++ BTRFS_FILE_EXTENT_INLINE) { ++ len = btrfs_file_extent_inline_len(leaf, ++ path->slots[0], ++ extent); ++ ASSERT(len == i_size); ++ return 0; ++ } ++ ++ len = btrfs_file_extent_num_bytes(leaf, extent); ++ /* Last extent goes beyond i_size, no need to log a hole. */ ++ if (key.offset + len > i_size) ++ return 0; ++ hole_start = key.offset + len; ++ hole_size = i_size - hole_start; ++ } ++ btrfs_release_path(path); ++ ++ /* Last extent ends at i_size. */ ++ if (hole_size == 0) ++ return 0; ++ ++ hole_size = ALIGN(hole_size, root->sectorsize); ++ ret = btrfs_insert_file_extent(trans, log, ino, hole_start, 0, 0, ++ hole_size, 0, hole_size, 0, 0, 0); ++ return ret; ++} ++ ++/* ++ * When we are logging a new inode X, check if it doesn't have a reference that ++ * matches the reference from some other inode Y created in a past transaction ++ * and that was renamed in the current transaction. If we don't do this, then at ++ * log replay time we can lose inode Y (and all its files if it's a directory): ++ * ++ * mkdir /mnt/x ++ * echo "hello world" > /mnt/x/foobar ++ * sync ++ * mv /mnt/x /mnt/y ++ * mkdir /mnt/x # or touch /mnt/x ++ * xfs_io -c fsync /mnt/x ++ * <power fail> ++ * mount fs, trigger log replay ++ * ++ * After the log replay procedure, we would lose the first directory and all its ++ * files (file foobar). ++ * For the case where inode Y is not a directory we simply end up losing it: ++ * ++ * echo "123" > /mnt/foo ++ * sync ++ * mv /mnt/foo /mnt/bar ++ * echo "abc" > /mnt/foo ++ * xfs_io -c fsync /mnt/foo ++ * <power fail> ++ * ++ * We also need this for cases where a snapshot entry is replaced by some other ++ * entry (file or directory) otherwise we end up with an unreplayable log due to ++ * attempts to delete the snapshot entry (entry of type BTRFS_ROOT_ITEM_KEY) as ++ * if it were a regular entry: ++ * ++ * mkdir /mnt/x ++ * btrfs subvolume snapshot /mnt /mnt/x/snap ++ * btrfs subvolume delete /mnt/x/snap ++ * rmdir /mnt/x ++ * mkdir /mnt/x ++ * fsync /mnt/x or fsync some new file inside it ++ * <power fail> ++ * ++ * The snapshot delete, rmdir of x, mkdir of a new x and the fsync all happen in ++ * the same transaction. ++ */ ++static int btrfs_check_ref_name_override(struct extent_buffer *eb, ++ const int slot, ++ const struct btrfs_key *key, ++ struct inode *inode) ++{ ++ int ret; ++ struct btrfs_path *search_path; ++ char *name = NULL; ++ u32 name_len = 0; ++ u32 item_size = btrfs_item_size_nr(eb, slot); ++ u32 cur_offset = 0; ++ unsigned long ptr = btrfs_item_ptr_offset(eb, slot); ++ ++ search_path = btrfs_alloc_path(); ++ if (!search_path) ++ return -ENOMEM; ++ search_path->search_commit_root = 1; ++ search_path->skip_locking = 1; ++ ++ while (cur_offset < item_size) { ++ u64 parent; ++ u32 this_name_len; ++ u32 this_len; ++ unsigned long name_ptr; ++ struct btrfs_dir_item *di; ++ ++ if (key->type == BTRFS_INODE_REF_KEY) { ++ struct btrfs_inode_ref *iref; ++ ++ iref = (struct btrfs_inode_ref *)(ptr + cur_offset); ++ parent = key->offset; ++ this_name_len = btrfs_inode_ref_name_len(eb, iref); ++ name_ptr = (unsigned long)(iref + 1); ++ this_len = sizeof(*iref) + this_name_len; ++ } else { ++ struct btrfs_inode_extref *extref; ++ ++ extref = (struct btrfs_inode_extref *)(ptr + ++ cur_offset); ++ parent = btrfs_inode_extref_parent(eb, extref); ++ this_name_len = btrfs_inode_extref_name_len(eb, extref); ++ name_ptr = (unsigned long)&extref->name; ++ this_len = sizeof(*extref) + this_name_len; ++ } ++ ++ if (this_name_len > name_len) { ++ char *new_name; ++ ++ new_name = krealloc(name, this_name_len, GFP_NOFS); ++ if (!new_name) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ name_len = this_name_len; ++ name = new_name; ++ } ++ ++ read_extent_buffer(eb, name, name_ptr, this_name_len); ++ di = btrfs_lookup_dir_item(NULL, BTRFS_I(inode)->root, ++ search_path, parent, ++ name, this_name_len, 0); ++ if (di && !IS_ERR(di)) { ++ ret = 1; ++ goto out; ++ } else if (IS_ERR(di)) { ++ ret = PTR_ERR(di); ++ goto out; ++ } ++ btrfs_release_path(search_path); ++ ++ cur_offset += this_len; ++ } ++ ret = 0; ++out: ++ btrfs_free_path(search_path); ++ kfree(name); ++ return ret; ++} ++ + /* log a single inode in the tree log. + * At least one parent directory for this inode must exist in the tree + * or be logged already. +@@ -4295,6 +4597,41 @@ again: + if (min_key.type == BTRFS_INODE_ITEM_KEY) + need_log_inode_item = false; + ++ if ((min_key.type == BTRFS_INODE_REF_KEY || ++ min_key.type == BTRFS_INODE_EXTREF_KEY) && ++ BTRFS_I(inode)->generation == trans->transid) { ++ ret = btrfs_check_ref_name_override(path->nodes[0], ++ path->slots[0], ++ &min_key, inode); ++ if (ret < 0) { ++ err = ret; ++ goto out_unlock; ++ } else if (ret > 0) { ++ err = 1; ++ btrfs_set_log_full_commit(root->fs_info, trans); ++ goto out_unlock; ++ } ++ } ++ ++ /* Skip xattrs, we log them later with btrfs_log_all_xattrs() */ ++ if (min_key.type == BTRFS_XATTR_ITEM_KEY) { ++ if (ins_nr == 0) ++ goto next_slot; ++ ret = copy_items(trans, inode, dst_path, path, ++ &last_extent, ins_start_slot, ++ ins_nr, inode_only, logged_isize); ++ if (ret < 0) { ++ err = ret; ++ goto out_unlock; ++ } ++ ins_nr = 0; ++ if (ret) { ++ btrfs_release_path(path); ++ continue; ++ } ++ goto next_slot; ++ } ++ + src = path->nodes[0]; + if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) { + ins_nr++; +@@ -4362,6 +4699,18 @@ next_slot: + ins_nr = 0; + } + ++ btrfs_release_path(path); ++ btrfs_release_path(dst_path); ++ err = btrfs_log_all_xattrs(trans, root, inode, path, dst_path); ++ if (err) ++ goto out_unlock; ++ if (max_key.type >= BTRFS_EXTENT_DATA_KEY && !fast_search) { ++ btrfs_release_path(path); ++ btrfs_release_path(dst_path); ++ err = btrfs_log_trailing_hole(trans, root, inode, path); ++ if (err) ++ goto out_unlock; ++ } + log_extents: + btrfs_release_path(path); + btrfs_release_path(dst_path); +diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c +index 8bec8f1e4b31..153c9a0db303 100644 +--- a/fs/debugfs/inode.c ++++ b/fs/debugfs/inode.c +@@ -462,7 +462,7 @@ struct dentry *debugfs_create_automount(const char *name, + if (unlikely(!inode)) + return failed_creating(dentry); + +- inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO; ++ make_empty_dir_inode(inode); + inode->i_flags |= S_AUTOMOUNT; + inode->i_private = data; + dentry->d_fsdata = (void *)f; +diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h +index 95dfff88de11..15213a567301 100644 +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -813,6 +813,29 @@ do { \ + #include "extents_status.h" + + /* ++ * Lock subclasses for i_data_sem in the ext4_inode_info structure. ++ * ++ * These are needed to avoid lockdep false positives when we need to ++ * allocate blocks to the quota inode during ext4_map_blocks(), while ++ * holding i_data_sem for a normal (non-quota) inode. Since we don't ++ * do quota tracking for the quota inode, this avoids deadlock (as ++ * well as infinite recursion, since it isn't turtles all the way ++ * down...) ++ * ++ * I_DATA_SEM_NORMAL - Used for most inodes ++ * I_DATA_SEM_OTHER - Used by move_inode.c for the second normal inode ++ * where the second inode has larger inode number ++ * than the first ++ * I_DATA_SEM_QUOTA - Used for quota inodes only ++ */ ++enum { ++ I_DATA_SEM_NORMAL = 0, ++ I_DATA_SEM_OTHER, ++ I_DATA_SEM_QUOTA, ++}; ++ ++ ++/* + * fourth extended file system inode data in memory + */ + struct ext4_inode_info { +diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c +index 3fb92abe5707..bd059e985485 100644 +--- a/fs/ext4/move_extent.c ++++ b/fs/ext4/move_extent.c +@@ -60,10 +60,10 @@ ext4_double_down_write_data_sem(struct inode *first, struct inode *second) + { + if (first < second) { + down_write(&EXT4_I(first)->i_data_sem); +- down_write_nested(&EXT4_I(second)->i_data_sem, SINGLE_DEPTH_NESTING); ++ down_write_nested(&EXT4_I(second)->i_data_sem, I_DATA_SEM_OTHER); + } else { + down_write(&EXT4_I(second)->i_data_sem); +- down_write_nested(&EXT4_I(first)->i_data_sem, SINGLE_DEPTH_NESTING); ++ down_write_nested(&EXT4_I(first)->i_data_sem, I_DATA_SEM_OTHER); + + } + } +@@ -487,6 +487,13 @@ mext_check_arguments(struct inode *orig_inode, + return -EBUSY; + } + ++ if (IS_NOQUOTA(orig_inode) || IS_NOQUOTA(donor_inode)) { ++ ext4_debug("ext4 move extent: The argument files should " ++ "not be quota files [ino:orig %lu, donor %lu]\n", ++ orig_inode->i_ino, donor_inode->i_ino); ++ return -EBUSY; ++ } ++ + /* Ext4 move extent supports only extent based file */ + if (!(ext4_test_inode_flag(orig_inode, EXT4_INODE_EXTENTS))) { + ext4_debug("ext4 move extent: orig file is not extents " +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 6f5ca3e92246..aedff7963468 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -1276,9 +1276,9 @@ static int set_qf_name(struct super_block *sb, int qtype, substring_t *args) + return -1; + } + if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) { +- ext4_msg(sb, KERN_ERR, "Cannot set journaled quota options " +- "when QUOTA feature is enabled"); +- return -1; ++ ext4_msg(sb, KERN_INFO, "Journaled quota options " ++ "ignored when QUOTA feature is enabled"); ++ return 1; + } + qname = match_strdup(args); + if (!qname) { +@@ -1636,10 +1636,10 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token, + } + if (EXT4_HAS_RO_COMPAT_FEATURE(sb, + EXT4_FEATURE_RO_COMPAT_QUOTA)) { +- ext4_msg(sb, KERN_ERR, +- "Cannot set journaled quota options " ++ ext4_msg(sb, KERN_INFO, ++ "Quota format mount options ignored " + "when QUOTA feature is enabled"); +- return -1; ++ return 1; + } + sbi->s_jquota_fmt = m->mount_opt; + #endif +@@ -1696,11 +1696,11 @@ static int parse_options(char *options, struct super_block *sb, + #ifdef CONFIG_QUOTA + if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) && + (test_opt(sb, USRQUOTA) || test_opt(sb, GRPQUOTA))) { +- ext4_msg(sb, KERN_ERR, "Cannot set quota options when QUOTA " +- "feature is enabled"); +- return 0; +- } +- if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) { ++ ext4_msg(sb, KERN_INFO, "Quota feature enabled, usrquota and grpquota " ++ "mount options ignored."); ++ clear_opt(sb, USRQUOTA); ++ clear_opt(sb, GRPQUOTA); ++ } else if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) { + if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA]) + clear_opt(sb, USRQUOTA); + +@@ -5272,6 +5272,20 @@ static int ext4_quota_on_mount(struct super_block *sb, int type) + EXT4_SB(sb)->s_jquota_fmt, type); + } + ++static void lockdep_set_quota_inode(struct inode *inode, int subclass) ++{ ++ struct ext4_inode_info *ei = EXT4_I(inode); ++ ++ /* The first argument of lockdep_set_subclass has to be ++ * *exactly* the same as the argument to init_rwsem() --- in ++ * this case, in init_once() --- or lockdep gets unhappy ++ * because the name of the lock is set using the ++ * stringification of the argument to init_rwsem(). ++ */ ++ (void) ei; /* shut up clang warning if !CONFIG_LOCKDEP */ ++ lockdep_set_subclass(&ei->i_data_sem, subclass); ++} ++ + /* + * Standard function to be called on quota_on + */ +@@ -5311,8 +5325,12 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id, + if (err) + return err; + } +- +- return dquot_quota_on(sb, type, format_id, path); ++ lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA); ++ err = dquot_quota_on(sb, type, format_id, path); ++ if (err) ++ lockdep_set_quota_inode(path->dentry->d_inode, ++ I_DATA_SEM_NORMAL); ++ return err; + } + + static int ext4_quota_enable(struct super_block *sb, int type, int format_id, +@@ -5338,8 +5356,11 @@ static int ext4_quota_enable(struct super_block *sb, int type, int format_id, + + /* Don't account quota for quota files to avoid recursion */ + qf_inode->i_flags |= S_NOQUOTA; ++ lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA); + err = dquot_enable(qf_inode, type, format_id, flags); + iput(qf_inode); ++ if (err) ++ lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL); + + return err; + } +diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h +index 371e560d13cf..27fa57322550 100644 +--- a/include/linux/compiler-gcc.h ++++ b/include/linux/compiler-gcc.h +@@ -115,10 +115,122 @@ + #define __maybe_unused __attribute__((unused)) + #define __always_unused __attribute__((unused)) + +-#define __gcc_header(x) #x +-#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h) +-#define gcc_header(x) _gcc_header(x) +-#include gcc_header(__GNUC__) ++/* gcc version specific checks */ ++ ++#if GCC_VERSION < 30200 ++# error Sorry, your compiler is too old - please upgrade it. ++#endif ++ ++#if GCC_VERSION < 30300 ++# define __used __attribute__((__unused__)) ++#else ++# define __used __attribute__((__used__)) ++#endif ++ ++#ifdef CONFIG_GCOV_KERNEL ++# if GCC_VERSION < 30400 ++# error "GCOV profiling support for gcc versions below 3.4 not included" ++# endif /* __GNUC_MINOR__ */ ++#endif /* CONFIG_GCOV_KERNEL */ ++ ++#if GCC_VERSION >= 30400 ++#define __must_check __attribute__((warn_unused_result)) ++#endif ++ ++#if GCC_VERSION >= 40000 ++ ++/* GCC 4.1.[01] miscompiles __weak */ ++#ifdef __KERNEL__ ++# if GCC_VERSION >= 40100 && GCC_VERSION <= 40101 ++# error Your version of gcc miscompiles the __weak directive ++# endif ++#endif ++ ++#define __used __attribute__((__used__)) ++#define __compiler_offsetof(a, b) \ ++ __builtin_offsetof(a, b) ++ ++#if GCC_VERSION >= 40100 && GCC_VERSION < 40600 ++# define __compiletime_object_size(obj) __builtin_object_size(obj, 0) ++#endif ++ ++#if GCC_VERSION >= 40300 ++/* Mark functions as cold. gcc will assume any path leading to a call ++ * to them will be unlikely. This means a lot of manual unlikely()s ++ * are unnecessary now for any paths leading to the usual suspects ++ * like BUG(), printk(), panic() etc. [but let's keep them for now for ++ * older compilers] ++ * ++ * Early snapshots of gcc 4.3 don't support this and we can't detect this ++ * in the preprocessor, but we can live with this because they're unreleased. ++ * Maketime probing would be overkill here. ++ * ++ * gcc also has a __attribute__((__hot__)) to move hot functions into ++ * a special section, but I don't see any sense in this right now in ++ * the kernel context ++ */ ++#define __cold __attribute__((__cold__)) ++ ++#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) ++ ++#ifndef __CHECKER__ ++# define __compiletime_warning(message) __attribute__((warning(message))) ++# define __compiletime_error(message) __attribute__((error(message))) ++#endif /* __CHECKER__ */ ++#endif /* GCC_VERSION >= 40300 */ ++ ++#if GCC_VERSION >= 40500 ++/* ++ * Mark a position in code as unreachable. This can be used to ++ * suppress control flow warnings after asm blocks that transfer ++ * control elsewhere. ++ * ++ * Early snapshots of gcc 4.5 don't support this and we can't detect ++ * this in the preprocessor, but we can live with this because they're ++ * unreleased. Really, we need to have autoconf for the kernel. ++ */ ++#define unreachable() __builtin_unreachable() ++ ++/* Mark a function definition as prohibited from being cloned. */ ++#define __noclone __attribute__((__noclone__, __optimize__("no-tracer"))) ++ ++#endif /* GCC_VERSION >= 40500 */ ++ ++#if GCC_VERSION >= 40600 ++/* ++ * Tell the optimizer that something else uses this function or variable. ++ */ ++#define __visible __attribute__((externally_visible)) ++#endif ++ ++/* ++ * GCC 'asm goto' miscompiles certain code sequences: ++ * ++ * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670 ++ * ++ * Work it around via a compiler barrier quirk suggested by Jakub Jelinek. ++ * ++ * (asm goto is automatically volatile - the naming reflects this.) ++ */ ++#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0) ++ ++#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP ++#if GCC_VERSION >= 40400 ++#define __HAVE_BUILTIN_BSWAP32__ ++#define __HAVE_BUILTIN_BSWAP64__ ++#endif ++#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600) ++#define __HAVE_BUILTIN_BSWAP16__ ++#endif ++#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */ ++ ++#if GCC_VERSION >= 50000 ++#define KASAN_ABI_VERSION 4 ++#elif GCC_VERSION >= 40902 ++#define KASAN_ABI_VERSION 3 ++#endif ++ ++#endif /* gcc version >= 40000 specific checks */ + + #if !defined(__noclone) + #define __noclone /* not needed */ +diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h +deleted file mode 100644 +index 7d89febe4d79..000000000000 +--- a/include/linux/compiler-gcc3.h ++++ /dev/null +@@ -1,23 +0,0 @@ +-#ifndef __LINUX_COMPILER_H +-#error "Please don't include <linux/compiler-gcc3.h> directly, include <linux/compiler.h> instead." +-#endif +- +-#if GCC_VERSION < 30200 +-# error Sorry, your compiler is too old - please upgrade it. +-#endif +- +-#if GCC_VERSION >= 30300 +-# define __used __attribute__((__used__)) +-#else +-# define __used __attribute__((__unused__)) +-#endif +- +-#if GCC_VERSION >= 30400 +-#define __must_check __attribute__((warn_unused_result)) +-#endif +- +-#ifdef CONFIG_GCOV_KERNEL +-# if GCC_VERSION < 30400 +-# error "GCOV profiling support for gcc versions below 3.4 not included" +-# endif /* __GNUC_MINOR__ */ +-#endif /* CONFIG_GCOV_KERNEL */ +diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h +deleted file mode 100644 +index 769e19864632..000000000000 +--- a/include/linux/compiler-gcc4.h ++++ /dev/null +@@ -1,91 +0,0 @@ +-#ifndef __LINUX_COMPILER_H +-#error "Please don't include <linux/compiler-gcc4.h> directly, include <linux/compiler.h> instead." +-#endif +- +-/* GCC 4.1.[01] miscompiles __weak */ +-#ifdef __KERNEL__ +-# if GCC_VERSION >= 40100 && GCC_VERSION <= 40101 +-# error Your version of gcc miscompiles the __weak directive +-# endif +-#endif +- +-#define __used __attribute__((__used__)) +-#define __must_check __attribute__((warn_unused_result)) +-#define __compiler_offsetof(a,b) __builtin_offsetof(a,b) +- +-#if GCC_VERSION >= 40100 && GCC_VERSION < 40600 +-# define __compiletime_object_size(obj) __builtin_object_size(obj, 0) +-#endif +- +-#if GCC_VERSION >= 40300 +-/* Mark functions as cold. gcc will assume any path leading to a call +- to them will be unlikely. This means a lot of manual unlikely()s +- are unnecessary now for any paths leading to the usual suspects +- like BUG(), printk(), panic() etc. [but let's keep them for now for +- older compilers] +- +- Early snapshots of gcc 4.3 don't support this and we can't detect this +- in the preprocessor, but we can live with this because they're unreleased. +- Maketime probing would be overkill here. +- +- gcc also has a __attribute__((__hot__)) to move hot functions into +- a special section, but I don't see any sense in this right now in +- the kernel context */ +-#define __cold __attribute__((__cold__)) +- +-#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) +- +-#ifndef __CHECKER__ +-# define __compiletime_warning(message) __attribute__((warning(message))) +-# define __compiletime_error(message) __attribute__((error(message))) +-#endif /* __CHECKER__ */ +-#endif /* GCC_VERSION >= 40300 */ +- +-#if GCC_VERSION >= 40500 +-/* +- * Mark a position in code as unreachable. This can be used to +- * suppress control flow warnings after asm blocks that transfer +- * control elsewhere. +- * +- * Early snapshots of gcc 4.5 don't support this and we can't detect +- * this in the preprocessor, but we can live with this because they're +- * unreleased. Really, we need to have autoconf for the kernel. +- */ +-#define unreachable() __builtin_unreachable() +- +-/* Mark a function definition as prohibited from being cloned. */ +-#define __noclone __attribute__((__noclone__)) +- +-#endif /* GCC_VERSION >= 40500 */ +- +-#if GCC_VERSION >= 40600 +-/* +- * Tell the optimizer that something else uses this function or variable. +- */ +-#define __visible __attribute__((externally_visible)) +-#endif +- +-/* +- * GCC 'asm goto' miscompiles certain code sequences: +- * +- * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670 +- * +- * Work it around via a compiler barrier quirk suggested by Jakub Jelinek. +- * +- * (asm goto is automatically volatile - the naming reflects this.) +- */ +-#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0) +- +-#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP +-#if GCC_VERSION >= 40400 +-#define __HAVE_BUILTIN_BSWAP32__ +-#define __HAVE_BUILTIN_BSWAP64__ +-#endif +-#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600) +-#define __HAVE_BUILTIN_BSWAP16__ +-#endif +-#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */ +- +-#if GCC_VERSION >= 40902 +-#define KASAN_ABI_VERSION 3 +-#endif +diff --git a/include/linux/compiler-gcc5.h b/include/linux/compiler-gcc5.h +deleted file mode 100644 +index efee493714eb..000000000000 +--- a/include/linux/compiler-gcc5.h ++++ /dev/null +@@ -1,67 +0,0 @@ +-#ifndef __LINUX_COMPILER_H +-#error "Please don't include <linux/compiler-gcc5.h> directly, include <linux/compiler.h> instead." +-#endif +- +-#define __used __attribute__((__used__)) +-#define __must_check __attribute__((warn_unused_result)) +-#define __compiler_offsetof(a, b) __builtin_offsetof(a, b) +- +-/* Mark functions as cold. gcc will assume any path leading to a call +- to them will be unlikely. This means a lot of manual unlikely()s +- are unnecessary now for any paths leading to the usual suspects +- like BUG(), printk(), panic() etc. [but let's keep them for now for +- older compilers] +- +- Early snapshots of gcc 4.3 don't support this and we can't detect this +- in the preprocessor, but we can live with this because they're unreleased. +- Maketime probing would be overkill here. +- +- gcc also has a __attribute__((__hot__)) to move hot functions into +- a special section, but I don't see any sense in this right now in +- the kernel context */ +-#define __cold __attribute__((__cold__)) +- +-#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) +- +-#ifndef __CHECKER__ +-# define __compiletime_warning(message) __attribute__((warning(message))) +-# define __compiletime_error(message) __attribute__((error(message))) +-#endif /* __CHECKER__ */ +- +-/* +- * Mark a position in code as unreachable. This can be used to +- * suppress control flow warnings after asm blocks that transfer +- * control elsewhere. +- * +- * Early snapshots of gcc 4.5 don't support this and we can't detect +- * this in the preprocessor, but we can live with this because they're +- * unreleased. Really, we need to have autoconf for the kernel. +- */ +-#define unreachable() __builtin_unreachable() +- +-/* Mark a function definition as prohibited from being cloned. */ +-#define __noclone __attribute__((__noclone__)) +- +-/* +- * Tell the optimizer that something else uses this function or variable. +- */ +-#define __visible __attribute__((externally_visible)) +- +-/* +- * GCC 'asm goto' miscompiles certain code sequences: +- * +- * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670 +- * +- * Work it around via a compiler barrier quirk suggested by Jakub Jelinek. +- * +- * (asm goto is automatically volatile - the naming reflects this.) +- */ +-#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0) +- +-#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP +-#define __HAVE_BUILTIN_BSWAP32__ +-#define __HAVE_BUILTIN_BSWAP64__ +-#define __HAVE_BUILTIN_BSWAP16__ +-#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */ +- +-#define KASAN_ABI_VERSION 4 +diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h +index 7f5f78bd15ad..245f57dbbb61 100644 +--- a/include/linux/usb_usual.h ++++ b/include/linux/usb_usual.h +@@ -79,6 +79,8 @@ + /* Cannot handle MI_REPORT_SUPPORTED_OPERATION_CODES */ \ + US_FLAG(MAX_SECTORS_240, 0x08000000) \ + /* Sets max_sectors to 240 */ \ ++ US_FLAG(NO_REPORT_LUNS, 0x10000000) \ ++ /* Cannot handle REPORT_LUNS */ \ + + #define US_FLAG(name, value) US_FL_##name = value , + enum { US_DO_ALL_FLAGS }; +diff --git a/lib/assoc_array.c b/lib/assoc_array.c +index 03dd576e6773..59fd7c0b119c 100644 +--- a/lib/assoc_array.c ++++ b/lib/assoc_array.c +@@ -524,7 +524,9 @@ static bool assoc_array_insert_into_terminal_node(struct assoc_array_edit *edit, + free_slot = i; + continue; + } +- if (ops->compare_object(assoc_array_ptr_to_leaf(ptr), index_key)) { ++ if (assoc_array_ptr_is_leaf(ptr) && ++ ops->compare_object(assoc_array_ptr_to_leaf(ptr), ++ index_key)) { + pr_devel("replace in slot %d\n", i); + edit->leaf_p = &node->slots[i]; + edit->dead_leaf = node->slots[i]; +diff --git a/lib/lz4/lz4defs.h b/lib/lz4/lz4defs.h +index abcecdc2d0f2..0710a62ad2f6 100644 +--- a/lib/lz4/lz4defs.h ++++ b/lib/lz4/lz4defs.h +@@ -11,8 +11,7 @@ + /* + * Detects 64 bits mode + */ +-#if (defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) \ +- || defined(__ppc64__) || defined(__LP64__)) ++#if defined(CONFIG_64BIT) + #define LZ4_ARCH64 1 + #else + #define LZ4_ARCH64 0 +@@ -35,6 +34,10 @@ typedef struct _U64_S { u64 v; } U64_S; + + #define PUT4(s, d) (A32(d) = A32(s)) + #define PUT8(s, d) (A64(d) = A64(s)) ++ ++#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ ++ (d = s - A16(p)) ++ + #define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ + do { \ + A16(p) = v; \ +@@ -51,10 +54,13 @@ typedef struct _U64_S { u64 v; } U64_S; + #define PUT8(s, d) \ + put_unaligned(get_unaligned((const u64 *) s), (u64 *) d) + +-#define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ +- do { \ +- put_unaligned(v, (u16 *)(p)); \ +- p += 2; \ ++#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ ++ (d = s - get_unaligned_le16(p)) ++ ++#define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ ++ do { \ ++ put_unaligned_le16(v, (u16 *)(p)); \ ++ p += 2; \ + } while (0) + #endif + +@@ -140,9 +146,6 @@ typedef struct _U64_S { u64 v; } U64_S; + + #endif + +-#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ +- (d = s - get_unaligned_le16(p)) +- + #define LZ4_WILDCOPY(s, d, e) \ + do { \ + LZ4_COPYPACKET(s, d); \ +diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c +index 06d3d665a9fd..3ce0b861cc0e 100644 +--- a/net/ipv4/tcp_cubic.c ++++ b/net/ipv4/tcp_cubic.c +@@ -151,6 +151,27 @@ static void bictcp_init(struct sock *sk) + tcp_sk(sk)->snd_ssthresh = initial_ssthresh; + } + ++static void bictcp_cwnd_event(struct sock *sk, enum tcp_ca_event event) ++{ ++ if (event == CA_EVENT_TX_START) { ++ struct bictcp *ca = inet_csk_ca(sk); ++ u32 now = tcp_time_stamp; ++ s32 delta; ++ ++ delta = now - tcp_sk(sk)->lsndtime; ++ ++ /* We were application limited (idle) for a while. ++ * Shift epoch_start to keep cwnd growth to cubic curve. ++ */ ++ if (ca->epoch_start && delta > 0) { ++ ca->epoch_start += delta; ++ if (after(ca->epoch_start, now)) ++ ca->epoch_start = now; ++ } ++ return; ++ } ++} ++ + /* calculate the cubic root of x using a table lookup followed by one + * Newton-Raphson iteration. + * Avg err ~= 0.195% +@@ -450,6 +471,7 @@ static struct tcp_congestion_ops cubictcp __read_mostly = { + .cong_avoid = bictcp_cong_avoid, + .set_state = bictcp_state, + .undo_cwnd = bictcp_undo_cwnd, ++ .cwnd_event = bictcp_cwnd_event, + .pkts_acked = bictcp_acked, + .owner = THIS_MODULE, + .name = "cubic", +diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c +index 2880f2ae99ab..a7027190f298 100644 +--- a/net/mac80211/sta_info.c ++++ b/net/mac80211/sta_info.c +@@ -252,11 +252,11 @@ void sta_info_free(struct ieee80211_local *local, struct sta_info *sta) + } + + /* Caller must hold local->sta_mtx */ +-static void sta_info_hash_add(struct ieee80211_local *local, +- struct sta_info *sta) ++static int sta_info_hash_add(struct ieee80211_local *local, ++ struct sta_info *sta) + { +- rhashtable_insert_fast(&local->sta_hash, &sta->hash_node, +- sta_rht_params); ++ return rhashtable_insert_fast(&local->sta_hash, &sta->hash_node, ++ sta_rht_params); + } + + static void sta_deliver_ps_frames(struct work_struct *wk) +@@ -491,7 +491,9 @@ static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU) + set_sta_flag(sta, WLAN_STA_BLOCK_BA); + + /* make the station visible */ +- sta_info_hash_add(local, sta); ++ err = sta_info_hash_add(local, sta); ++ if (err) ++ goto out_drop_sta; + + list_add_tail_rcu(&sta->list, &local->sta_list); + +@@ -526,6 +528,7 @@ static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU) + out_remove: + sta_info_hash_del(local, sta); + list_del_rcu(&sta->list); ++ out_drop_sta: + local->num_sta--; + synchronize_net(); + __cleanup_single_sta(sta); +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 90cf6168267e..cc1a7a4a7cbd 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -4638,6 +4638,8 @@ enum { + ALC255_FIXUP_DELL_SPK_NOISE, + ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, + ALC280_FIXUP_HP_HEADSET_MIC, ++ ALC221_FIXUP_HP_FRONT_MIC, ++ ALC292_FIXUP_TPT460, + }; + + static const struct hda_fixup alc269_fixups[] = { +@@ -5270,6 +5272,19 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC269_FIXUP_HEADSET_MIC, + }, ++ [ALC221_FIXUP_HP_FRONT_MIC] = { ++ .type = HDA_FIXUP_PINS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x19, 0x02a19020 }, /* Front Mic */ ++ { } ++ }, ++ }, ++ [ALC292_FIXUP_TPT460] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc_fixup_tpt440_dock, ++ .chained = true, ++ .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, ++ }, + }; + + static const struct snd_pci_quirk alc269_fixup_tbl[] = { +@@ -5374,6 +5389,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), + SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), + SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), ++ SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), + SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), + SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), + SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), +@@ -5421,7 +5437,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), + SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), + SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), +- SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), ++ SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), + SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), + SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), + SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), +@@ -5514,6 +5530,7 @@ static const struct hda_model_fixup alc269_fixup_models[] = { + {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, + {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, + {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, ++ {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, + {} + }; + #define ALC225_STANDARD_PINS \ +diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c +index ddca6547399b..1f8fb0d904e0 100644 +--- a/sound/usb/mixer_maps.c ++++ b/sound/usb/mixer_maps.c +@@ -349,6 +349,16 @@ static struct usbmix_name_map bose_companion5_map[] = { + }; + + /* ++ * Dell usb dock with ALC4020 codec had a firmware problem where it got ++ * screwed up when zero volume is passed; just skip it as a workaround ++ */ ++static const struct usbmix_name_map dell_alc4020_map[] = { ++ { 16, NULL }, ++ { 19, NULL }, ++ { 0 } ++}; ++ ++/* + * Control map entries + */ + +@@ -431,6 +441,10 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = { + .map = aureon_51_2_map, + }, + { ++ .id = USB_ID(0x0bda, 0x4014), ++ .map = dell_alc4020_map, ++ }, ++ { + .id = USB_ID(0x0dba, 0x1000), + .map = mbox1_map, + }, +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index 5fb308d39e2a..5ad43cba860c 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1128,9 +1128,11 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip) + case USB_ID(0x045E, 0x076F): /* MS Lifecam HD-6000 */ + case USB_ID(0x045E, 0x0772): /* MS Lifecam Studio */ + case USB_ID(0x045E, 0x0779): /* MS Lifecam HD-3000 */ ++ case USB_ID(0x047F, 0x0415): /* Plantronics BT-300 */ + case USB_ID(0x047F, 0xAA05): /* Plantronics DA45 */ + case USB_ID(0x04D8, 0xFEEA): /* Benchmark DAC1 Pre */ + case USB_ID(0x074D, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */ ++ case USB_ID(0x1de7, 0x0014): /* Phoenix Audio TMX320 */ + case USB_ID(0x21B4, 0x0081): /* AudioQuest DragonFly */ + return true; + }
