[kernel] r17230 - in dists/sid/linux-2.6/debian: . patches/bugfix/all/stable patches/series
Ben Hutchings
benh at alioth.debian.org
Wed Apr 20 00:21:05 UTC 2011
Author: benh
Date: Wed Apr 20 00:20:54 2011
New Revision: 17230
Log:
Add stable 2.6.38.4-rc1
Added:
dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.38.4-rc1.patch
Modified:
dists/sid/linux-2.6/debian/changelog
dists/sid/linux-2.6/debian/patches/series/4
Modified: dists/sid/linux-2.6/debian/changelog
==============================================================================
--- dists/sid/linux-2.6/debian/changelog Tue Apr 19 23:39:00 2011 (r17229)
+++ dists/sid/linux-2.6/debian/changelog Wed Apr 20 00:20:54 2011 (r17230)
@@ -36,6 +36,7 @@
- nfsd4: fix oops on lock failure
For the complete list of changes, see:
http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.38.3
+ * Add stable 2.6.38.4-rc1
-- Ben Hutchings <ben at decadent.org.uk> Fri, 08 Apr 2011 00:59:57 +0100
Added: dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.38.4-rc1.patch
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.38.4-rc1.patch Wed Apr 20 00:20:54 2011 (r17230)
@@ -0,0 +1,3708 @@
+diff --git a/MAINTAINERS b/MAINTAINERS
+index f1bc3dc..80540e3 100644
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -5944,7 +5944,6 @@ F: arch/alpha/kernel/srm_env.c
+
+ STABLE BRANCH
+ M: Greg Kroah-Hartman <greg at kroah.com>
+-M: Chris Wright <chrisw at sous-sol.org>
+ L: stable at kernel.org
+ S: Maintained
+
+diff --git a/arch/arm/kernel/hw_breakpoint.c b/arch/arm/kernel/hw_breakpoint.c
+index 44b84fe..7e9a0c7 100644
+--- a/arch/arm/kernel/hw_breakpoint.c
++++ b/arch/arm/kernel/hw_breakpoint.c
+@@ -868,6 +868,13 @@ static void reset_ctrl_regs(void *info)
+ */
+ asm volatile("mcr p14, 0, %0, c1, c0, 4" : : "r" (0));
+ isb();
++
++ /*
++ * Clear any configured vector-catch events before
++ * enabling monitor mode.
++ */
++ asm volatile("mcr p14, 0, %0, c0, c7, 0" : : "r" (0));
++ isb();
+ }
+
+ if (enable_monitor_mode())
+diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
+index 1753f6a..ff14ab2 100644
+--- a/arch/ia64/kernel/mca.c
++++ b/arch/ia64/kernel/mca.c
+@@ -1859,7 +1859,8 @@ ia64_mca_cpu_init(void *cpu_data)
+ data = mca_bootmem();
+ first_time = 0;
+ } else
+- data = __get_free_pages(GFP_KERNEL, get_order(sz));
++ data = (void *)__get_free_pages(GFP_KERNEL,
++ get_order(sz));
+ if (!data)
+ panic("Could not allocate MCA memory for cpu %d\n",
+ cpu);
+diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
+index 4d4536e..9c271be 100644
+--- a/arch/ia64/sn/pci/tioca_provider.c
++++ b/arch/ia64/sn/pci/tioca_provider.c
+@@ -509,7 +509,7 @@ tioca_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
+ * use the GART mapped mode.
+ */
+ static u64
+-tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
++tioca_dma_map(struct pci_dev *pdev, unsigned long paddr, size_t byte_count, int dma_flags)
+ {
+ u64 mapaddr;
+
+diff --git a/arch/powerpc/kernel/perf_event.c b/arch/powerpc/kernel/perf_event.c
+index 97e0ae4..26e56e3 100644
+--- a/arch/powerpc/kernel/perf_event.c
++++ b/arch/powerpc/kernel/perf_event.c
+@@ -398,6 +398,25 @@ static int check_excludes(struct perf_event **ctrs, unsigned int cflags[],
+ return 0;
+ }
+
++static u64 check_and_compute_delta(u64 prev, u64 val)
++{
++ u64 delta = (val - prev) & 0xfffffffful;
++
++ /*
++ * POWER7 can roll back counter values, if the new value is smaller
++ * than the previous value it will cause the delta and the counter to
++ * have bogus values unless we rolled a counter over. If a coutner is
++ * rolled back, it will be smaller, but within 256, which is the maximum
++ * number of events to rollback at once. If we dectect a rollback
++ * return 0. This can lead to a small lack of precision in the
++ * counters.
++ */
++ if (prev > val && (prev - val) < 256)
++ delta = 0;
++
++ return delta;
++}
++
+ static void power_pmu_read(struct perf_event *event)
+ {
+ s64 val, delta, prev;
+@@ -416,10 +435,11 @@ static void power_pmu_read(struct perf_event *event)
+ prev = local64_read(&event->hw.prev_count);
+ barrier();
+ val = read_pmc(event->hw.idx);
++ delta = check_and_compute_delta(prev, val);
++ if (!delta)
++ return;
+ } while (local64_cmpxchg(&event->hw.prev_count, prev, val) != prev);
+
+- /* The counters are only 32 bits wide */
+- delta = (val - prev) & 0xfffffffful;
+ local64_add(delta, &event->count);
+ local64_sub(delta, &event->hw.period_left);
+ }
+@@ -449,8 +469,9 @@ static void freeze_limited_counters(struct cpu_hw_events *cpuhw,
+ val = (event->hw.idx == 5) ? pmc5 : pmc6;
+ prev = local64_read(&event->hw.prev_count);
+ event->hw.idx = 0;
+- delta = (val - prev) & 0xfffffffful;
+- local64_add(delta, &event->count);
++ delta = check_and_compute_delta(prev, val);
++ if (delta)
++ local64_add(delta, &event->count);
+ }
+ }
+
+@@ -458,14 +479,16 @@ static void thaw_limited_counters(struct cpu_hw_events *cpuhw,
+ unsigned long pmc5, unsigned long pmc6)
+ {
+ struct perf_event *event;
+- u64 val;
++ u64 val, prev;
+ int i;
+
+ for (i = 0; i < cpuhw->n_limited; ++i) {
+ event = cpuhw->limited_counter[i];
+ event->hw.idx = cpuhw->limited_hwidx[i];
+ val = (event->hw.idx == 5) ? pmc5 : pmc6;
+- local64_set(&event->hw.prev_count, val);
++ prev = local64_read(&event->hw.prev_count);
++ if (check_and_compute_delta(prev, val))
++ local64_set(&event->hw.prev_count, val);
+ perf_event_update_userpage(event);
+ }
+ }
+@@ -1197,7 +1220,7 @@ static void record_and_restart(struct perf_event *event, unsigned long val,
+
+ /* we don't have to worry about interrupts here */
+ prev = local64_read(&event->hw.prev_count);
+- delta = (val - prev) & 0xfffffffful;
++ delta = check_and_compute_delta(prev, val);
+ local64_add(delta, &event->count);
+
+ /*
+diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
+index aa92696..02d54e1 100644
+--- a/arch/powerpc/kernel/time.c
++++ b/arch/powerpc/kernel/time.c
+@@ -229,6 +229,9 @@ static u64 scan_dispatch_log(u64 stop_tb)
+ u64 stolen = 0;
+ u64 dtb;
+
++ if (!dtl)
++ return 0;
++
+ if (i == vpa->dtl_idx)
+ return 0;
+ while (i < vpa->dtl_idx) {
+diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
+index 1504df8..906ee3e 100644
+--- a/arch/sparc/kernel/entry.S
++++ b/arch/sparc/kernel/entry.S
+@@ -1283,7 +1283,7 @@ linux_syscall_trace:
+ .globl ret_from_fork
+ ret_from_fork:
+ call schedule_tail
+- mov %g3, %o0
++ ld [%g3 + TI_TASK], %o0
+ b ret_sys_call
+ ld [%sp + STACKFRAME_SZ + PT_I0], %o0
+
+diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
+index 72509d0..6f01e8c 100644
+--- a/arch/sparc/kernel/iommu.c
++++ b/arch/sparc/kernel/iommu.c
+@@ -333,13 +333,10 @@ static void dma_4u_free_coherent(struct device *dev, size_t size,
+ void *cpu, dma_addr_t dvma)
+ {
+ struct iommu *iommu;
+- iopte_t *iopte;
+ unsigned long flags, order, npages;
+
+ npages = IO_PAGE_ALIGN(size) >> IO_PAGE_SHIFT;
+ iommu = dev->archdata.iommu;
+- iopte = iommu->page_table +
+- ((dvma - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
+
+ spin_lock_irqsave(&iommu->lock, flags);
+
+diff --git a/arch/sparc/kernel/ldc.c b/arch/sparc/kernel/ldc.c
+index df39a0f..732b0bc 100644
+--- a/arch/sparc/kernel/ldc.c
++++ b/arch/sparc/kernel/ldc.c
+@@ -790,16 +790,20 @@ static void send_events(struct ldc_channel *lp, unsigned int event_mask)
+ static irqreturn_t ldc_rx(int irq, void *dev_id)
+ {
+ struct ldc_channel *lp = dev_id;
+- unsigned long orig_state, hv_err, flags;
++ unsigned long orig_state, flags;
+ unsigned int event_mask;
+
+ spin_lock_irqsave(&lp->lock, flags);
+
+ orig_state = lp->chan_state;
+- hv_err = sun4v_ldc_rx_get_state(lp->id,
+- &lp->rx_head,
+- &lp->rx_tail,
+- &lp->chan_state);
++
++ /* We should probably check for hypervisor errors here and
++ * reset the LDC channel if we get one.
++ */
++ sun4v_ldc_rx_get_state(lp->id,
++ &lp->rx_head,
++ &lp->rx_tail,
++ &lp->chan_state);
+
+ ldcdbg(RX, "RX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
+ orig_state, lp->chan_state, lp->rx_head, lp->rx_tail);
+@@ -904,16 +908,20 @@ out:
+ static irqreturn_t ldc_tx(int irq, void *dev_id)
+ {
+ struct ldc_channel *lp = dev_id;
+- unsigned long flags, hv_err, orig_state;
++ unsigned long flags, orig_state;
+ unsigned int event_mask = 0;
+
+ spin_lock_irqsave(&lp->lock, flags);
+
+ orig_state = lp->chan_state;
+- hv_err = sun4v_ldc_tx_get_state(lp->id,
+- &lp->tx_head,
+- &lp->tx_tail,
+- &lp->chan_state);
++
++ /* We should probably check for hypervisor errors here and
++ * reset the LDC channel if we get one.
++ */
++ sun4v_ldc_tx_get_state(lp->id,
++ &lp->tx_head,
++ &lp->tx_tail,
++ &lp->chan_state);
+
+ ldcdbg(TX, " TX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
+ orig_state, lp->chan_state, lp->tx_head, lp->tx_tail);
+diff --git a/arch/sparc/kernel/pci.c b/arch/sparc/kernel/pci.c
+index 4137579..f255382 100644
+--- a/arch/sparc/kernel/pci.c
++++ b/arch/sparc/kernel/pci.c
+@@ -675,6 +675,7 @@ static void __devinit pci_bus_register_of_sysfs(struct pci_bus *bus)
+ * humanoid.
+ */
+ err = sysfs_create_file(&dev->dev.kobj, &dev_attr_obppath.attr);
++ (void) err;
+ }
+ list_for_each_entry(child_bus, &bus->children, node)
+ pci_bus_register_of_sysfs(child_bus);
+diff --git a/arch/sparc/kernel/pci_common.c b/arch/sparc/kernel/pci_common.c
+index 6c7a33a..6e3874b 100644
+--- a/arch/sparc/kernel/pci_common.c
++++ b/arch/sparc/kernel/pci_common.c
+@@ -295,14 +295,17 @@ static int sun4v_write_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
+ unsigned int bus = bus_dev->number;
+ unsigned int device = PCI_SLOT(devfn);
+ unsigned int func = PCI_FUNC(devfn);
+- unsigned long ret;
+
+ if (config_out_of_range(pbm, bus, devfn, where)) {
+ /* Do nothing. */
+ } else {
+- ret = pci_sun4v_config_put(devhandle,
+- HV_PCI_DEVICE_BUILD(bus, device, func),
+- where, size, value);
++ /* We don't check for hypervisor errors here, but perhaps
++ * we should and influence our return value depending upon
++ * what kind of error is thrown.
++ */
++ pci_sun4v_config_put(devhandle,
++ HV_PCI_DEVICE_BUILD(bus, device, func),
++ where, size, value);
+ }
+ return PCIBIOS_SUCCESSFUL;
+ }
+diff --git a/arch/sparc/kernel/pci_fire.c b/arch/sparc/kernel/pci_fire.c
+index efb896d..75dfeb6 100644
+--- a/arch/sparc/kernel/pci_fire.c
++++ b/arch/sparc/kernel/pci_fire.c
+@@ -214,11 +214,9 @@ static int pci_fire_msi_setup(struct pci_pbm_info *pbm, unsigned long msiqid,
+
+ static int pci_fire_msi_teardown(struct pci_pbm_info *pbm, unsigned long msi)
+ {
+- unsigned long msiqid;
+ u64 val;
+
+ val = upa_readq(pbm->pbm_regs + MSI_MAP(msi));
+- msiqid = (val & MSI_MAP_EQNUM);
+
+ val &= ~MSI_MAP_VALID;
+
+diff --git a/arch/sparc/kernel/pci_schizo.c b/arch/sparc/kernel/pci_schizo.c
+index 445a47a..4620eb7 100644
+--- a/arch/sparc/kernel/pci_schizo.c
++++ b/arch/sparc/kernel/pci_schizo.c
+@@ -1313,7 +1313,7 @@ static int __devinit schizo_pbm_init(struct pci_pbm_info *pbm,
+ const struct linux_prom64_registers *regs;
+ struct device_node *dp = op->dev.of_node;
+ const char *chipset_name;
+- int is_pbm_a, err;
++ int err;
+
+ switch (chip_type) {
+ case PBM_CHIP_TYPE_TOMATILLO:
+@@ -1343,8 +1343,6 @@ static int __devinit schizo_pbm_init(struct pci_pbm_info *pbm,
+ */
+ regs = of_get_property(dp, "reg", NULL);
+
+- is_pbm_a = ((regs[0].phys_addr & 0x00700000) == 0x00600000);
+-
+ pbm->next = pci_pbm_root;
+ pci_pbm_root = pbm;
+
+diff --git a/arch/sparc/kernel/pci_sun4v.c b/arch/sparc/kernel/pci_sun4v.c
+index 743344a..859abfd 100644
+--- a/arch/sparc/kernel/pci_sun4v.c
++++ b/arch/sparc/kernel/pci_sun4v.c
+@@ -580,7 +580,7 @@ static int __devinit pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
+ {
+ static const u32 vdma_default[] = { 0x80000000, 0x80000000 };
+ struct iommu *iommu = pbm->iommu;
+- unsigned long num_tsb_entries, sz, tsbsize;
++ unsigned long num_tsb_entries, sz;
+ u32 dma_mask, dma_offset;
+ const u32 *vdma;
+
+@@ -596,7 +596,6 @@ static int __devinit pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
+
+ dma_mask = (roundup_pow_of_two(vdma[1]) - 1UL);
+ num_tsb_entries = vdma[1] / IO_PAGE_SIZE;
+- tsbsize = num_tsb_entries * sizeof(iopte_t);
+
+ dma_offset = vdma[0];
+
+diff --git a/arch/sparc/kernel/pcr.c b/arch/sparc/kernel/pcr.c
+index 7c2ced6..8ac23e6 100644
+--- a/arch/sparc/kernel/pcr.c
++++ b/arch/sparc/kernel/pcr.c
+@@ -81,7 +81,7 @@ static void n2_pcr_write(u64 val)
+ unsigned long ret;
+
+ ret = sun4v_niagara2_setperf(HV_N2_PERF_SPARC_CTL, val);
+- if (val != HV_EOK)
++ if (ret != HV_EOK)
+ write_pcr(val);
+ }
+
+diff --git a/arch/sparc/kernel/ptrace_64.c b/arch/sparc/kernel/ptrace_64.c
+index 9ccc812..96ee50a 100644
+--- a/arch/sparc/kernel/ptrace_64.c
++++ b/arch/sparc/kernel/ptrace_64.c
+@@ -1086,6 +1086,7 @@ asmlinkage int syscall_trace_enter(struct pt_regs *regs)
+
+ asmlinkage void syscall_trace_leave(struct pt_regs *regs)
+ {
++#ifdef CONFIG_AUDITSYSCALL
+ if (unlikely(current->audit_context)) {
+ unsigned long tstate = regs->tstate;
+ int result = AUDITSC_SUCCESS;
+@@ -1095,7 +1096,7 @@ asmlinkage void syscall_trace_leave(struct pt_regs *regs)
+
+ audit_syscall_exit(result, regs->u_regs[UREG_I0]);
+ }
+-
++#endif
+ if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+ trace_sys_exit(regs, regs->u_regs[UREG_G1]);
+
+diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
+index 555a76d..3e94a8c 100644
+--- a/arch/sparc/kernel/smp_64.c
++++ b/arch/sparc/kernel/smp_64.c
+@@ -189,7 +189,7 @@ static inline long get_delta (long *rt, long *master)
+ void smp_synchronize_tick_client(void)
+ {
+ long i, delta, adj, adjust_latency = 0, done = 0;
+- unsigned long flags, rt, master_time_stamp, bound;
++ unsigned long flags, rt, master_time_stamp;
+ #if DEBUG_TICK_SYNC
+ struct {
+ long rt; /* roundtrip time */
+@@ -208,10 +208,8 @@ void smp_synchronize_tick_client(void)
+ {
+ for (i = 0; i < NUM_ROUNDS; i++) {
+ delta = get_delta(&rt, &master_time_stamp);
+- if (delta == 0) {
++ if (delta == 0)
+ done = 1; /* let's lock on to this... */
+- bound = rt;
+- }
+
+ if (!done) {
+ if (i > 0) {
+@@ -933,13 +931,12 @@ void smp_flush_dcache_page_impl(struct page *page, int cpu)
+ void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
+ {
+ void *pg_addr;
+- int this_cpu;
+ u64 data0;
+
+ if (tlb_type == hypervisor)
+ return;
+
+- this_cpu = get_cpu();
++ preempt_disable();
+
+ #ifdef CONFIG_DEBUG_DCFLUSH
+ atomic_inc(&dcpage_flushes);
+@@ -964,7 +961,7 @@ void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
+ }
+ __local_flush_dcache_page(page);
+
+- put_cpu();
++ preempt_enable();
+ }
+
+ void __irq_entry smp_new_mmu_context_version_client(int irq, struct pt_regs *regs)
+diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
+index 1e97709..1ed547b 100644
+--- a/arch/sparc/kernel/traps_64.c
++++ b/arch/sparc/kernel/traps_64.c
+@@ -2152,7 +2152,7 @@ static void user_instruction_dump(unsigned int __user *pc)
+
+ void show_stack(struct task_struct *tsk, unsigned long *_ksp)
+ {
+- unsigned long fp, thread_base, ksp;
++ unsigned long fp, ksp;
+ struct thread_info *tp;
+ int count = 0;
+ #ifdef CONFIG_FUNCTION_GRAPH_TRACER
+@@ -2173,7 +2173,6 @@ void show_stack(struct task_struct *tsk, unsigned long *_ksp)
+ flushw_all();
+
+ fp = ksp + STACK_BIAS;
+- thread_base = (unsigned long) tp;
+
+ printk("Call Trace:\n");
+ do {
+diff --git a/arch/sparc/kernel/una_asm_64.S b/arch/sparc/kernel/una_asm_64.S
+index be183fe..1c8d332 100644
+--- a/arch/sparc/kernel/una_asm_64.S
++++ b/arch/sparc/kernel/una_asm_64.S
+@@ -127,7 +127,7 @@ do_int_load:
+ wr %o5, 0x0, %asi
+ retl
+ mov 0, %o0
+- .size __do_int_load, .-__do_int_load
++ .size do_int_load, .-do_int_load
+
+ .section __ex_table,"a"
+ .word 4b, __retl_efault
+diff --git a/arch/sparc/mm/fault_32.c b/arch/sparc/mm/fault_32.c
+index 5b836f5..b10ac4d 100644
+--- a/arch/sparc/mm/fault_32.c
++++ b/arch/sparc/mm/fault_32.c
+@@ -240,11 +240,10 @@ asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
+ * only copy the information from the master page table,
+ * nothing more.
+ */
++ code = SEGV_MAPERR;
+ if (!ARCH_SUN4C && address >= TASK_SIZE)
+ goto vmalloc_fault;
+
+- code = SEGV_MAPERR;
+-
+ /*
+ * If we're in an interrupt or have no user
+ * context, we must not take the fault..
+diff --git a/arch/x86/include/asm/msr-index.h b/arch/x86/include/asm/msr-index.h
+index 43a18c7..99b402c 100644
+--- a/arch/x86/include/asm/msr-index.h
++++ b/arch/x86/include/asm/msr-index.h
+@@ -92,11 +92,15 @@
+ #define MSR_IA32_MC0_ADDR 0x00000402
+ #define MSR_IA32_MC0_MISC 0x00000403
+
++#define MSR_AMD64_MC0_MASK 0xc0010044
++
+ #define MSR_IA32_MCx_CTL(x) (MSR_IA32_MC0_CTL + 4*(x))
+ #define MSR_IA32_MCx_STATUS(x) (MSR_IA32_MC0_STATUS + 4*(x))
+ #define MSR_IA32_MCx_ADDR(x) (MSR_IA32_MC0_ADDR + 4*(x))
+ #define MSR_IA32_MCx_MISC(x) (MSR_IA32_MC0_MISC + 4*(x))
+
++#define MSR_AMD64_MCx_MASK(x) (MSR_AMD64_MC0_MASK + (x))
++
+ /* These are consecutive and not in the normal 4er MCE bank block */
+ #define MSR_IA32_MC0_CTL2 0x00000280
+ #define MSR_IA32_MCx_CTL2(x) (MSR_IA32_MC0_CTL2 + (x))
+diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
+index 7c7bedb..a2b9c7d 100644
+--- a/arch/x86/kernel/cpu/amd.c
++++ b/arch/x86/kernel/cpu/amd.c
+@@ -594,6 +594,29 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
+ }
+ }
+ #endif
++
++ /* As a rule processors have APIC timer running in deep C states */
++ if (c->x86 >= 0xf && !cpu_has_amd_erratum(amd_erratum_400))
++ set_cpu_cap(c, X86_FEATURE_ARAT);
++
++ /*
++ * Disable GART TLB Walk Errors on Fam10h. We do this here
++ * because this is always needed when GART is enabled, even in a
++ * kernel which has no MCE support built in.
++ */
++ if (c->x86 == 0x10) {
++ /*
++ * BIOS should disable GartTlbWlk Errors themself. If
++ * it doesn't do it here as suggested by the BKDG.
++ *
++ * Fixes: https://bugzilla.kernel.org/show_bug.cgi?id=33012
++ */
++ u64 mask;
++
++ rdmsrl(MSR_AMD64_MCx_MASK(4), mask);
++ mask |= (1 << 10);
++ wrmsrl(MSR_AMD64_MCx_MASK(4), mask);
++ }
+ }
+
+ #ifdef CONFIG_X86_32
+diff --git a/arch/x86/lib/semaphore_32.S b/arch/x86/lib/semaphore_32.S
+index 648fe47..f35eec7 100644
+--- a/arch/x86/lib/semaphore_32.S
++++ b/arch/x86/lib/semaphore_32.S
+@@ -36,7 +36,7 @@
+ */
+ #ifdef CONFIG_SMP
+ ENTRY(__write_lock_failed)
+- CFI_STARTPROC simple
++ CFI_STARTPROC
+ FRAME
+ 2: LOCK_PREFIX
+ addl $ RW_LOCK_BIAS,(%eax)
+diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
+index 258fa5e..d71d375 100644
+--- a/drivers/gpu/drm/radeon/atom.c
++++ b/drivers/gpu/drm/radeon/atom.c
+@@ -32,6 +32,7 @@
+ #include "atom.h"
+ #include "atom-names.h"
+ #include "atom-bits.h"
++#include "radeon.h"
+
+ #define ATOM_COND_ABOVE 0
+ #define ATOM_COND_ABOVEOREQUAL 1
+@@ -101,7 +102,9 @@ static void debug_print_spaces(int n)
+ static uint32_t atom_iio_execute(struct atom_context *ctx, int base,
+ uint32_t index, uint32_t data)
+ {
++ struct radeon_device *rdev = ctx->card->dev->dev_private;
+ uint32_t temp = 0xCDCDCDCD;
++
+ while (1)
+ switch (CU8(base)) {
+ case ATOM_IIO_NOP:
+@@ -112,7 +115,8 @@ static uint32_t atom_iio_execute(struct atom_context *ctx, int base,
+ base += 3;
+ break;
+ case ATOM_IIO_WRITE:
+- (void)ctx->card->ioreg_read(ctx->card, CU16(base + 1));
++ if (rdev->family == CHIP_RV515)
++ (void)ctx->card->ioreg_read(ctx->card, CU16(base + 1));
+ ctx->card->ioreg_write(ctx->card, CU16(base + 1), temp);
+ base += 3;
+ break;
+diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
+index e967cc8..0861257 100644
+--- a/drivers/gpu/drm/radeon/atombios_crtc.c
++++ b/drivers/gpu/drm/radeon/atombios_crtc.c
+@@ -531,6 +531,12 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
+ pll->flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
+ else
+ pll->flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
++
++ if ((rdev->family == CHIP_R600) ||
++ (rdev->family == CHIP_RV610) ||
++ (rdev->family == CHIP_RV630) ||
++ (rdev->family == CHIP_RV670))
++ pll->flags |= RADEON_PLL_PREFER_MINM_OVER_MAXP;
+ } else {
+ pll->flags |= RADEON_PLL_LEGACY;
+
+diff --git a/drivers/gpu/drm/radeon/radeon_fence.c b/drivers/gpu/drm/radeon/radeon_fence.c
+index 171b0b2..2b0ee62 100644
+--- a/drivers/gpu/drm/radeon/radeon_fence.c
++++ b/drivers/gpu/drm/radeon/radeon_fence.c
+@@ -80,7 +80,7 @@ static bool radeon_fence_poll_locked(struct radeon_device *rdev)
+ scratch_index = R600_WB_EVENT_OFFSET + rdev->fence_drv.scratch_reg - rdev->scratch.reg_base;
+ else
+ scratch_index = RADEON_WB_SCRATCH_OFFSET + rdev->fence_drv.scratch_reg - rdev->scratch.reg_base;
+- seq = rdev->wb.wb[scratch_index/4];
++ seq = le32_to_cpu(rdev->wb.wb[scratch_index/4]);
+ } else
+ seq = RREG32(rdev->fence_drv.scratch_reg);
+ if (seq != rdev->fence_drv.last_seq) {
+diff --git a/drivers/gpu/drm/radeon/radeon_ring.c b/drivers/gpu/drm/radeon/radeon_ring.c
+index 06e7982..d6edfeb 100644
+--- a/drivers/gpu/drm/radeon/radeon_ring.c
++++ b/drivers/gpu/drm/radeon/radeon_ring.c
+@@ -248,7 +248,7 @@ void radeon_ib_pool_fini(struct radeon_device *rdev)
+ void radeon_ring_free_size(struct radeon_device *rdev)
+ {
+ if (rdev->wb.enabled)
+- rdev->cp.rptr = rdev->wb.wb[RADEON_WB_CP_RPTR_OFFSET/4];
++ rdev->cp.rptr = le32_to_cpu(rdev->wb.wb[RADEON_WB_CP_RPTR_OFFSET/4]);
+ else {
+ if (rdev->family >= CHIP_R600)
+ rdev->cp.rptr = RREG32(R600_CP_RB_RPTR);
+diff --git a/drivers/i2c/algos/i2c-algo-bit.c b/drivers/i2c/algos/i2c-algo-bit.c
+index 38319a6..d6d5868 100644
+--- a/drivers/i2c/algos/i2c-algo-bit.c
++++ b/drivers/i2c/algos/i2c-algo-bit.c
+@@ -232,9 +232,17 @@ static int i2c_inb(struct i2c_adapter *i2c_adap)
+ * Sanity check for the adapter hardware - check the reaction of
+ * the bus lines only if it seems to be idle.
+ */
+-static int test_bus(struct i2c_algo_bit_data *adap, char *name)
++static int test_bus(struct i2c_adapter *i2c_adap)
+ {
+- int scl, sda;
++ struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
++ const char *name = i2c_adap->name;
++ int scl, sda, ret;
++
++ if (adap->pre_xfer) {
++ ret = adap->pre_xfer(i2c_adap);
++ if (ret < 0)
++ return -ENODEV;
++ }
+
+ if (adap->getscl == NULL)
+ pr_info("%s: Testing SDA only, SCL is not readable\n", name);
+@@ -297,11 +305,19 @@ static int test_bus(struct i2c_algo_bit_data *adap, char *name)
+ "while pulling SCL high!\n", name);
+ goto bailout;
+ }
++
++ if (adap->post_xfer)
++ adap->post_xfer(i2c_adap);
++
+ pr_info("%s: Test OK\n", name);
+ return 0;
+ bailout:
+ sdahi(adap);
+ sclhi(adap);
++
++ if (adap->post_xfer)
++ adap->post_xfer(i2c_adap);
++
+ return -ENODEV;
+ }
+
+@@ -607,7 +623,7 @@ static int __i2c_bit_add_bus(struct i2c_adapter *adap,
+ int ret;
+
+ if (bit_test) {
+- ret = test_bus(bit_adap, adap->name);
++ ret = test_bus(adap);
+ if (ret < 0)
+ return -ENODEV;
+ }
+diff --git a/drivers/media/video/sn9c102/sn9c102_core.c b/drivers/media/video/sn9c102/sn9c102_core.c
+index 84984f6..ce56a1c 100644
+--- a/drivers/media/video/sn9c102/sn9c102_core.c
++++ b/drivers/media/video/sn9c102/sn9c102_core.c
+@@ -1430,9 +1430,9 @@ static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
+ sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
+ static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
+ sn9c102_show_i2c_val, sn9c102_store_i2c_val);
+-static DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
+-static DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
+-static DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
++static DEVICE_ATTR(green, S_IWUSR, NULL, sn9c102_store_green);
++static DEVICE_ATTR(blue, S_IWUSR, NULL, sn9c102_store_blue);
++static DEVICE_ATTR(red, S_IWUSR, NULL, sn9c102_store_red);
+ static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
+
+
+diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
+index 5ed8f9f..3da19a5 100644
+--- a/drivers/net/gianfar.c
++++ b/drivers/net/gianfar.c
+@@ -950,6 +950,11 @@ static void gfar_detect_errata(struct gfar_private *priv)
+ (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
+ priv->errata |= GFAR_ERRATA_A002;
+
++ /* MPC8313 Rev < 2.0, MPC8548 rev 2.0 */
++ if ((pvr == 0x80850010 && mod == 0x80b0 && rev < 0x0020) ||
++ (pvr == 0x80210020 && mod == 0x8030 && rev == 0x0020))
++ priv->errata |= GFAR_ERRATA_12;
++
+ if (priv->errata)
+ dev_info(dev, "enabled errata workarounds, flags: 0x%x\n",
+ priv->errata);
+@@ -2156,8 +2161,15 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
+ /* Set up checksumming */
+ if (CHECKSUM_PARTIAL == skb->ip_summed) {
+ fcb = gfar_add_fcb(skb);
+- lstatus |= BD_LFLAG(TXBD_TOE);
+- gfar_tx_checksum(skb, fcb);
++ /* as specified by errata */
++ if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12)
++ && ((unsigned long)fcb % 0x20) > 0x18)) {
++ __skb_pull(skb, GMAC_FCB_LEN);
++ skb_checksum_help(skb);
++ } else {
++ lstatus |= BD_LFLAG(TXBD_TOE);
++ gfar_tx_checksum(skb, fcb);
++ }
+ }
+
+ if (vlan_tx_tag_present(skb)) {
+diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
+index 54de413..ec5d595 100644
+--- a/drivers/net/gianfar.h
++++ b/drivers/net/gianfar.h
+@@ -1039,6 +1039,7 @@ enum gfar_errata {
+ GFAR_ERRATA_74 = 0x01,
+ GFAR_ERRATA_76 = 0x02,
+ GFAR_ERRATA_A002 = 0x04,
++ GFAR_ERRATA_12 = 0x08, /* a.k.a errata eTSEC49 */
+ };
+
+ /* Struct stolen almost completely (and shamelessly) from the FCC enet source
+diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
+index 78c0e3c..71b1d8f 100644
+--- a/drivers/net/pppoe.c
++++ b/drivers/net/pppoe.c
+@@ -317,7 +317,7 @@ static void pppoe_flush_dev(struct net_device *dev)
+ lock_sock(sk);
+
+ if (po->pppoe_dev == dev &&
+- sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND)) {
++ sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND | PPPOX_ZOMBIE)) {
+ pppox_unbind_sock(sk);
+ sk->sk_state = PPPOX_ZOMBIE;
+ sk->sk_state_change(sk);
+diff --git a/drivers/net/usb/cdc-phonet.c b/drivers/net/usb/cdc-phonet.c
+index 109751b..e7ce8af 100644
+--- a/drivers/net/usb/cdc-phonet.c
++++ b/drivers/net/usb/cdc-phonet.c
+@@ -328,13 +328,13 @@ int usbpn_probe(struct usb_interface *intf, const struct usb_device_id *id)
+ {
+ static const char ifname[] = "usbpn%d";
+ const struct usb_cdc_union_desc *union_header = NULL;
+- const struct usb_cdc_header_desc *phonet_header = NULL;
+ const struct usb_host_interface *data_desc;
+ struct usb_interface *data_intf;
+ struct usb_device *usbdev = interface_to_usbdev(intf);
+ struct net_device *dev;
+ struct usbpn_dev *pnd;
+ u8 *data;
++ int phonet = 0;
+ int len, err;
+
+ data = intf->altsetting->extra;
+@@ -355,10 +355,7 @@ int usbpn_probe(struct usb_interface *intf, const struct usb_device_id *id)
+ (struct usb_cdc_union_desc *)data;
+ break;
+ case 0xAB:
+- if (phonet_header || dlen < 5)
+- break;
+- phonet_header =
+- (struct usb_cdc_header_desc *)data;
++ phonet = 1;
+ break;
+ }
+ }
+@@ -366,7 +363,7 @@ int usbpn_probe(struct usb_interface *intf, const struct usb_device_id *id)
+ len -= dlen;
+ }
+
+- if (!union_header || !phonet_header)
++ if (!union_header || !phonet)
+ return -EINVAL;
+
+ data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);
+diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
+index 17971d9..0e61e2d 100644
+--- a/drivers/rtc/rtc-bfin.c
++++ b/drivers/rtc/rtc-bfin.c
+@@ -276,6 +276,8 @@ static int bfin_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+ bfin_rtc_int_set_alarm(rtc);
+ else
+ bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY));
++
++ return 0;
+ }
+
+ static int bfin_rtc_read_time(struct device *dev, struct rtc_time *tm)
+diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
+index a3d2e23..96fdfb8 100644
+--- a/drivers/usb/core/devices.c
++++ b/drivers/usb/core/devices.c
+@@ -221,7 +221,7 @@ static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
+ break;
+ case USB_ENDPOINT_XFER_INT:
+ type = "Int.";
+- if (speed == USB_SPEED_HIGH)
++ if (speed == USB_SPEED_HIGH || speed == USB_SPEED_SUPER)
+ interval = 1 << (desc->bInterval - 1);
+ else
+ interval = desc->bInterval;
+@@ -229,7 +229,8 @@ static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
+ default: /* "can't happen" */
+ return start;
+ }
+- interval *= (speed == USB_SPEED_HIGH) ? 125 : 1000;
++ interval *= (speed == USB_SPEED_HIGH ||
++ speed == USB_SPEED_SUPER) ? 125 : 1000;
+ if (interval % 1000)
+ unit = 'u';
+ else {
+@@ -542,8 +543,9 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
+ if (level == 0) {
+ int max;
+
+- /* high speed reserves 80%, full/low reserves 90% */
+- if (usbdev->speed == USB_SPEED_HIGH)
++ /* super/high speed reserves 80%, full/low reserves 90% */
++ if (usbdev->speed == USB_SPEED_HIGH ||
++ usbdev->speed == USB_SPEED_SUPER)
+ max = 800;
+ else
+ max = FRAME_TIME_MAX_USECS_ALLOC;
+diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
+index c34a935..fd95b9e 100644
+--- a/drivers/usb/core/hcd.c
++++ b/drivers/usb/core/hcd.c
+@@ -1885,7 +1885,7 @@ void usb_free_streams(struct usb_interface *interface,
+
+ /* Streams only apply to bulk endpoints. */
+ for (i = 0; i < num_eps; i++)
+- if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
++ if (!eps[i] || !usb_endpoint_xfer_bulk(&eps[i]->desc))
+ return;
+
+ hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
+diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
+index 5add8b5..baf7362 100644
+--- a/drivers/usb/host/ehci-q.c
++++ b/drivers/usb/host/ehci-q.c
+@@ -1245,24 +1245,27 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
+
+ static void scan_async (struct ehci_hcd *ehci)
+ {
++ bool stopped;
+ struct ehci_qh *qh;
+ enum ehci_timer_action action = TIMER_IO_WATCHDOG;
+
+ ehci->stamp = ehci_readl(ehci, &ehci->regs->frame_index);
+ timer_action_done (ehci, TIMER_ASYNC_SHRINK);
+ rescan:
++ stopped = !HC_IS_RUNNING(ehci_to_hcd(ehci)->state);
+ qh = ehci->async->qh_next.qh;
+ if (likely (qh != NULL)) {
+ do {
+ /* clean any finished work for this qh */
+- if (!list_empty (&qh->qtd_list)
+- && qh->stamp != ehci->stamp) {
++ if (!list_empty(&qh->qtd_list) && (stopped ||
++ qh->stamp != ehci->stamp)) {
+ int temp;
+
+ /* unlinks could happen here; completion
+ * reporting drops the lock. rescan using
+ * the latest schedule, but don't rescan
+- * qhs we already finished (no looping).
++ * qhs we already finished (no looping)
++ * unless the controller is stopped.
+ */
+ qh = qh_get (qh);
+ qh->stamp = ehci->stamp;
+@@ -1283,9 +1286,9 @@ rescan:
+ */
+ if (list_empty(&qh->qtd_list)
+ && qh->qh_state == QH_STATE_LINKED) {
+- if (!ehci->reclaim
+- && ((ehci->stamp - qh->stamp) & 0x1fff)
+- >= (EHCI_SHRINK_FRAMES * 8))
++ if (!ehci->reclaim && (stopped ||
++ ((ehci->stamp - qh->stamp) & 0x1fff)
++ >= EHCI_SHRINK_FRAMES * 8))
+ start_unlink_async(ehci, qh);
+ else
+ action = TIMER_ASYNC_SHRINK;
+diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
+index a953439..0de3100 100644
+--- a/drivers/usb/host/xhci-mem.c
++++ b/drivers/usb/host/xhci-mem.c
+@@ -920,6 +920,47 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
+ return 0;
+ }
+
++/*
++ * Convert interval expressed as 2^(bInterval - 1) == interval into
++ * straight exponent value 2^n == interval.
++ *
++ */
++static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
++ struct usb_host_endpoint *ep)
++{
++ unsigned int interval;
++
++ interval = clamp_val(ep->desc.bInterval, 1, 16) - 1;
++ if (interval != ep->desc.bInterval - 1)
++ dev_warn(&udev->dev,
++ "ep %#x - rounding interval to %d microframes\n",
++ ep->desc.bEndpointAddress,
++ 1 << interval);
++
++ return interval;
++}
++
++/*
++ * Convert bInterval expressed in frames (in 1-255 range) to exponent of
++ * microframes, rounded down to nearest power of 2.
++ */
++static unsigned int xhci_parse_frame_interval(struct usb_device *udev,
++ struct usb_host_endpoint *ep)
++{
++ unsigned int interval;
++
++ interval = fls(8 * ep->desc.bInterval) - 1;
++ interval = clamp_val(interval, 3, 10);
++ if ((1 << interval) != 8 * ep->desc.bInterval)
++ dev_warn(&udev->dev,
++ "ep %#x - rounding interval to %d microframes, ep desc says %d microframes\n",
++ ep->desc.bEndpointAddress,
++ 1 << interval,
++ 8 * ep->desc.bInterval);
++
++ return interval;
++}
++
+ /* Return the polling or NAK interval.
+ *
+ * The polling interval is expressed in "microframes". If xHCI's Interval field
+@@ -937,45 +978,38 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
+ case USB_SPEED_HIGH:
+ /* Max NAK rate */
+ if (usb_endpoint_xfer_control(&ep->desc) ||
+- usb_endpoint_xfer_bulk(&ep->desc))
++ usb_endpoint_xfer_bulk(&ep->desc)) {
+ interval = ep->desc.bInterval;
++ break;
++ }
+ /* Fall through - SS and HS isoc/int have same decoding */
++
+ case USB_SPEED_SUPER:
+ if (usb_endpoint_xfer_int(&ep->desc) ||
+- usb_endpoint_xfer_isoc(&ep->desc)) {
+- if (ep->desc.bInterval == 0)
+- interval = 0;
+- else
+- interval = ep->desc.bInterval - 1;
+- if (interval > 15)
+- interval = 15;
+- if (interval != ep->desc.bInterval + 1)
+- dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n",
+- ep->desc.bEndpointAddress, 1 << interval);
++ usb_endpoint_xfer_isoc(&ep->desc)) {
++ interval = xhci_parse_exponent_interval(udev, ep);
+ }
+ break;
+- /* Convert bInterval (in 1-255 frames) to microframes and round down to
+- * nearest power of 2.
+- */
++
+ case USB_SPEED_FULL:
++ if (usb_endpoint_xfer_int(&ep->desc)) {
++ interval = xhci_parse_exponent_interval(udev, ep);
++ break;
++ }
++ /*
++ * Fall through for isochronous endpoint interval decoding
++ * since it uses the same rules as low speed interrupt
++ * endpoints.
++ */
++
+ case USB_SPEED_LOW:
+ if (usb_endpoint_xfer_int(&ep->desc) ||
+- usb_endpoint_xfer_isoc(&ep->desc)) {
+- interval = fls(8*ep->desc.bInterval) - 1;
+- if (interval > 10)
+- interval = 10;
+- if (interval < 3)
+- interval = 3;
+- if ((1 << interval) != 8*ep->desc.bInterval)
+- dev_warn(&udev->dev,
+- "ep %#x - rounding interval"
+- " to %d microframes, "
+- "ep desc says %d microframes\n",
+- ep->desc.bEndpointAddress,
+- 1 << interval,
+- 8*ep->desc.bInterval);
++ usb_endpoint_xfer_isoc(&ep->desc)) {
++
++ interval = xhci_parse_frame_interval(udev, ep);
+ }
+ break;
++
+ default:
+ BUG();
+ }
+diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
+index 2083fc2..150349d 100644
+--- a/drivers/usb/host/xhci.c
++++ b/drivers/usb/host/xhci.c
+@@ -2335,10 +2335,18 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
+ /* Everything but endpoint 0 is disabled, so free or cache the rings. */
+ last_freed_endpoint = 1;
+ for (i = 1; i < 31; ++i) {
+- if (!virt_dev->eps[i].ring)
+- continue;
+- xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
+- last_freed_endpoint = i;
++ struct xhci_virt_ep *ep = &virt_dev->eps[i];
++
++ if (ep->ep_state & EP_HAS_STREAMS) {
++ xhci_free_stream_info(xhci, ep->stream_info);
++ ep->stream_info = NULL;
++ ep->ep_state &= ~EP_HAS_STREAMS;
++ }
++
++ if (ep->ring) {
++ xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
++ last_freed_endpoint = i;
++ }
+ }
+ xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
+ xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
+diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
+index 62bc1bc..19040c5 100644
+--- a/drivers/usb/host/xhci.h
++++ b/drivers/usb/host/xhci.h
+@@ -232,7 +232,7 @@ struct xhci_op_regs {
+ * notification type that matches a bit set in this bit field.
+ */
+ #define DEV_NOTE_MASK (0xffff)
+-#define ENABLE_DEV_NOTE(x) (1 << x)
++#define ENABLE_DEV_NOTE(x) (1 << (x))
+ /* Most of the device notification types should only be used for debug.
+ * SW does need to pay attention to function wake notifications.
+ */
+@@ -601,11 +601,11 @@ struct xhci_ep_ctx {
+ #define EP_STATE_STOPPED 3
+ #define EP_STATE_ERROR 4
+ /* Mult - Max number of burtst within an interval, in EP companion desc. */
+-#define EP_MULT(p) ((p & 0x3) << 8)
++#define EP_MULT(p) (((p) & 0x3) << 8)
+ /* bits 10:14 are Max Primary Streams */
+ /* bit 15 is Linear Stream Array */
+ /* Interval - period between requests to an endpoint - 125u increments. */
+-#define EP_INTERVAL(p) ((p & 0xff) << 16)
++#define EP_INTERVAL(p) (((p) & 0xff) << 16)
+ #define EP_INTERVAL_TO_UFRAMES(p) (1 << (((p) >> 16) & 0xff))
+ #define EP_MAXPSTREAMS_MASK (0x1f << 10)
+ #define EP_MAXPSTREAMS(p) (((p) << 10) & EP_MAXPSTREAMS_MASK)
+diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
+index 4cbb7e4b..74073b3 100644
+--- a/drivers/usb/musb/Kconfig
++++ b/drivers/usb/musb/Kconfig
+@@ -14,7 +14,7 @@ config USB_MUSB_HDRC
+ select TWL4030_USB if MACH_OMAP_3430SDP
+ select TWL6030_USB if MACH_OMAP_4430SDP || MACH_OMAP4_PANDA
+ select USB_OTG_UTILS
+- tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
++ bool 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
+ help
+ Say Y here if your system has a dual role high speed USB
+ controller based on the Mentor Graphics silicon IP. Then
+@@ -30,8 +30,8 @@ config USB_MUSB_HDRC
+
+ If you do not know what this is, please say N.
+
+- To compile this driver as a module, choose M here; the
+- module will be called "musb-hdrc".
++# To compile this driver as a module, choose M here; the
++# module will be called "musb-hdrc".
+
+ choice
+ prompt "Platform Glue Layer"
+diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
+index f349a36..31bba6d 100644
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -151,6 +151,8 @@ static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
+ * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
+ */
+ static struct usb_device_id id_table_combined [] = {
++ { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
++ { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
+@@ -525,6 +527,7 @@ static struct usb_device_id id_table_combined [] = {
+ { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
+ { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
+ { USB_DEVICE(OCT_VID, OCT_US101_PID) },
++ { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
+ .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
+ { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
+@@ -785,6 +788,8 @@ static struct usb_device_id id_table_combined [] = {
+ { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
+ .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+ { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
++ { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
++ { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
+ { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
+ { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
+ { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
+diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
+index 117e8e6..4e873ce 100644
+--- a/drivers/usb/serial/ftdi_sio_ids.h
++++ b/drivers/usb/serial/ftdi_sio_ids.h
+@@ -300,6 +300,8 @@
+ * Hameg HO820 and HO870 interface (using VID 0x0403)
+ */
+ #define HAMEG_HO820_PID 0xed74
++#define HAMEG_HO730_PID 0xed73
++#define HAMEG_HO720_PID 0xed72
+ #define HAMEG_HO870_PID 0xed71
+
+ /*
+@@ -572,6 +574,7 @@
+ /* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
+ /* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
+ /* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
++#define OCT_DK201_PID 0x0103 /* OCT DK201 USB docking station */
+ #define OCT_US101_PID 0x0421 /* OCT US101 USB to RS-232 */
+
+ /*
+@@ -1140,3 +1143,12 @@
+ #define QIHARDWARE_VID 0x20B7
+ #define MILKYMISTONE_JTAGSERIAL_PID 0x0713
+
++/*
++ * CTI GmbH RS485 Converter http://www.cti-lean.com/
++ */
++/* USB-485-Mini*/
++#define FTDI_CTI_MINI_PID 0xF608
++/* USB-Nano-485*/
++#define FTDI_CTI_NANO_PID 0xF60B
++
++
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index 75c7f45..d77ff04 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -407,6 +407,10 @@ static void option_instat_callback(struct urb *urb);
+ /* ONDA MT825UP HSDPA 14.2 modem */
+ #define ONDA_MT825UP 0x000b
+
++/* Samsung products */
++#define SAMSUNG_VENDOR_ID 0x04e8
++#define SAMSUNG_PRODUCT_GT_B3730 0x6889
++
+ /* some devices interfaces need special handling due to a number of reasons */
+ enum option_blacklist_reason {
+ OPTION_BLACKLIST_NONE = 0,
+@@ -968,6 +972,7 @@ static const struct usb_device_id option_ids[] = {
+ { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) },
+ { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
+ { USB_DEVICE(ONDA_VENDOR_ID, ONDA_MT825UP) }, /* ONDA MT825UP modem */
++ { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730/GT-B3710 LTE USB modem.*/
+ { } /* Terminating entry */
+ };
+ MODULE_DEVICE_TABLE(usb, option_ids);
+diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
+index 8858201..54a9dab 100644
+--- a/drivers/usb/serial/qcserial.c
++++ b/drivers/usb/serial/qcserial.c
+@@ -111,7 +111,7 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ ifnum = intf->desc.bInterfaceNumber;
+ dbg("This Interface = %d", ifnum);
+
+- data = serial->private = kzalloc(sizeof(struct usb_wwan_intf_private),
++ data = kzalloc(sizeof(struct usb_wwan_intf_private),
+ GFP_KERNEL);
+ if (!data)
+ return -ENOMEM;
+@@ -134,8 +134,10 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ usb_endpoint_is_bulk_out(&intf->endpoint[1].desc)) {
+ dbg("QDL port found");
+
+- if (serial->interface->num_altsetting == 1)
+- return 0;
++ if (serial->interface->num_altsetting == 1) {
++ retval = 0; /* Success */
++ break;
++ }
+
+ retval = usb_set_interface(serial->dev, ifnum, 1);
+ if (retval < 0) {
+@@ -145,7 +147,6 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ retval = -ENODEV;
+ kfree(data);
+ }
+- return retval;
+ }
+ break;
+
+@@ -166,6 +167,7 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ "Could not set interface, error %d\n",
+ retval);
+ retval = -ENODEV;
++ kfree(data);
+ }
+ } else if (ifnum == 2) {
+ dbg("Modem port found");
+@@ -177,7 +179,6 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ retval = -ENODEV;
+ kfree(data);
+ }
+- return retval;
+ } else if (ifnum==3) {
+ /*
+ * NMEA (serial line 9600 8N1)
+@@ -191,6 +192,7 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ "Could not set interface, error %d\n",
+ retval);
+ retval = -ENODEV;
++ kfree(data);
+ }
+ }
+ break;
+@@ -199,12 +201,27 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+ dev_err(&serial->dev->dev,
+ "unknown number of interfaces: %d\n", nintf);
+ kfree(data);
+- return -ENODEV;
++ retval = -ENODEV;
+ }
+
++ /* Set serial->private if not returning -ENODEV */
++ if (retval != -ENODEV)
++ usb_set_serial_data(serial, data);
+ return retval;
+ }
+
++static void qc_release(struct usb_serial *serial)
++{
++ struct usb_wwan_intf_private *priv = usb_get_serial_data(serial);
++
++ dbg("%s", __func__);
++
++ /* Call usb_wwan release & free the private data allocated in qcprobe */
++ usb_wwan_release(serial);
++ usb_set_serial_data(serial, NULL);
++ kfree(priv);
++}
++
+ static struct usb_serial_driver qcdevice = {
+ .driver = {
+ .owner = THIS_MODULE,
+@@ -222,7 +239,7 @@ static struct usb_serial_driver qcdevice = {
+ .chars_in_buffer = usb_wwan_chars_in_buffer,
+ .attach = usb_wwan_startup,
+ .disconnect = usb_wwan_disconnect,
+- .release = usb_wwan_release,
++ .release = qc_release,
+ #ifdef CONFIG_PM
+ .suspend = usb_wwan_suspend,
+ .resume = usb_wwan_resume,
+diff --git a/drivers/video/via/viafbdev.h b/drivers/video/via/viafbdev.h
+index d66f963..137996d 100644
+--- a/drivers/video/via/viafbdev.h
++++ b/drivers/video/via/viafbdev.h
+@@ -94,9 +94,6 @@ extern int viafb_LCD_ON;
+ extern int viafb_DVI_ON;
+ extern int viafb_hotplug;
+
+-extern int strict_strtoul(const char *cp, unsigned int base,
+- unsigned long *res);
+-
+ u8 viafb_gpio_i2c_read_lvds(struct lvds_setting_information
+ *plvds_setting_info, struct lvds_chip_information
+ *plvds_chip_info, u8 index);
+diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
+index d5b640b..70470b2 100644
+--- a/fs/binfmt_elf.c
++++ b/fs/binfmt_elf.c
+@@ -941,9 +941,13 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+ current->mm->start_stack = bprm->p;
+
+ #ifdef arch_randomize_brk
+- if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1))
++ if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
+ current->mm->brk = current->mm->start_brk =
+ arch_randomize_brk(current->mm);
++#ifdef CONFIG_COMPAT_BRK
++ current->brk_randomized = 1;
++#endif
++ }
+ #endif
+
+ if (current->personality & MMAP_PAGE_ZERO) {
+diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
+index a51585f..96b9a34 100644
+--- a/fs/cifs/cifsencrypt.c
++++ b/fs/cifs/cifsencrypt.c
+@@ -30,12 +30,13 @@
+ #include <linux/ctype.h>
+ #include <linux/random.h>
+
+-/* Calculate and return the CIFS signature based on the mac key and SMB PDU */
+-/* the 16 byte signature must be allocated by the caller */
+-/* Note we only use the 1st eight bytes */
+-/* Note that the smb header signature field on input contains the
+- sequence number before this function is called */
+-
++/*
++ * Calculate and return the CIFS signature based on the mac key and SMB PDU.
++ * The 16 byte signature must be allocated by the caller. Note we only use the
++ * 1st eight bytes and that the smb header signature field on input contains
++ * the sequence number before this function is called. Also, this function
++ * should be called with the server->srv_mutex held.
++ */
+ static int cifs_calculate_signature(const struct smb_hdr *cifs_pdu,
+ struct TCP_Server_Info *server, char *signature)
+ {
+@@ -209,8 +210,10 @@ int cifs_verify_signature(struct smb_hdr *cifs_pdu,
+ cpu_to_le32(expected_sequence_number);
+ cifs_pdu->Signature.Sequence.Reserved = 0;
+
++ mutex_lock(&server->srv_mutex);
+ rc = cifs_calculate_signature(cifs_pdu, server,
+ what_we_think_sig_should_be);
++ mutex_unlock(&server->srv_mutex);
+
+ if (rc)
+ return rc;
+diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
+index f297013..c0def4f 100644
+--- a/fs/cifs/cifsfs.c
++++ b/fs/cifs/cifsfs.c
+@@ -127,6 +127,7 @@ cifs_read_super(struct super_block *sb, void *data,
+ kfree(cifs_sb);
+ return rc;
+ }
++ cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
+
+ #ifdef CONFIG_CIFS_DFS_UPCALL
+ /* copy mount params to sb for use in submounts */
+diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
+index 8d6c17a..d3d836d 100644
+--- a/fs/cifs/connect.c
++++ b/fs/cifs/connect.c
+@@ -2826,7 +2826,7 @@ try_mount_again:
+
+ remote_path_check:
+ /* check if a whole path (including prepath) is not remote */
+- if (!rc && cifs_sb->prepathlen && tcon) {
++ if (!rc && tcon) {
+ /* build_path_to_root works only when we have a valid tcon */
+ full_path = cifs_build_path_to_root(cifs_sb, tcon);
+ if (full_path == NULL) {
+diff --git a/fs/cifs/file.c b/fs/cifs/file.c
+index e964b1c..7b2e8ec 100644
+--- a/fs/cifs/file.c
++++ b/fs/cifs/file.c
+@@ -575,8 +575,10 @@ reopen_error_exit:
+
+ int cifs_close(struct inode *inode, struct file *file)
+ {
+- cifsFileInfo_put(file->private_data);
+- file->private_data = NULL;
++ if (file->private_data != NULL) {
++ cifsFileInfo_put(file->private_data);
++ file->private_data = NULL;
++ }
+
+ /* return code from the ->release op is always ignored */
+ return 0;
+diff --git a/fs/namei.c b/fs/namei.c
+index a4689eb..3095ca8 100644
+--- a/fs/namei.c
++++ b/fs/namei.c
+@@ -712,6 +712,7 @@ static __always_inline void set_root_rcu(struct nameidata *nd)
+ do {
+ seq = read_seqcount_begin(&fs->seq);
+ nd->root = fs->root;
++ nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
+ } while (read_seqcount_retry(&fs->seq, seq));
+ }
+ }
+diff --git a/fs/proc/base.c b/fs/proc/base.c
+index d49c4b5..71a85d8 100644
+--- a/fs/proc/base.c
++++ b/fs/proc/base.c
+@@ -3066,11 +3066,16 @@ static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldi
+ /* for the /proc/ directory itself, after non-process stuff has been done */
+ int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
+ {
+- unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
+- struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
++ unsigned int nr;
++ struct task_struct *reaper;
+ struct tgid_iter iter;
+ struct pid_namespace *ns;
+
++ if (filp->f_pos >= PID_MAX_LIMIT + TGID_OFFSET)
++ goto out_no_task;
++ nr = filp->f_pos - FIRST_PROCESS_ENTRY;
++
++ reaper = get_proc_task(filp->f_path.dentry->d_inode);
+ if (!reaper)
+ goto out_no_task;
+
+diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
+index 9eead2c..fbb0b47 100644
+--- a/fs/ramfs/file-nommu.c
++++ b/fs/ramfs/file-nommu.c
+@@ -112,6 +112,7 @@ int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
+ SetPageDirty(page);
+
+ unlock_page(page);
++ put_page(page);
+ }
+
+ return 0;
+diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
+index 5b9e985..b67ed36 100644
+--- a/fs/ubifs/debug.c
++++ b/fs/ubifs/debug.c
+@@ -2844,19 +2844,19 @@ int dbg_debugfs_init_fs(struct ubifs_info *c)
+ }
+
+ fname = "dump_lprops";
+- dent = debugfs_create_file(fname, S_IWUGO, d->dfs_dir, c, &dfs_fops);
++ dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c, &dfs_fops);
+ if (IS_ERR(dent))
+ goto out_remove;
+ d->dfs_dump_lprops = dent;
+
+ fname = "dump_budg";
+- dent = debugfs_create_file(fname, S_IWUGO, d->dfs_dir, c, &dfs_fops);
++ dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c, &dfs_fops);
+ if (IS_ERR(dent))
+ goto out_remove;
+ d->dfs_dump_budg = dent;
+
+ fname = "dump_tnc";
+- dent = debugfs_create_file(fname, S_IWUGO, d->dfs_dir, c, &dfs_fops);
++ dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c, &dfs_fops);
+ if (IS_ERR(dent))
+ goto out_remove;
+ d->dfs_dump_tnc = dent;
+diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
+index d77db7e..fe14f4d 100644
+--- a/fs/ubifs/file.c
++++ b/fs/ubifs/file.c
+@@ -1309,6 +1309,9 @@ int ubifs_fsync(struct file *file, int datasync)
+
+ dbg_gen("syncing inode %lu", inode->i_ino);
+
++ if (inode->i_sb->s_flags & MS_RDONLY)
++ return 0;
++
+ /*
+ * VFS has already synchronized dirty pages for this inode. Synchronize
+ * the inode unless this is a 'datasync()' call.
+diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
+index 6e11c29..0f029e1 100644
+--- a/fs/ubifs/super.c
++++ b/fs/ubifs/super.c
+@@ -1543,6 +1543,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
+ mutex_lock(&c->umount_mutex);
+ dbg_save_space_info(c);
+ c->remounting_rw = 1;
++ c->ro_mount = 0;
+ c->always_chk_crc = 1;
+
+ err = check_free_space(c);
+@@ -1648,7 +1649,6 @@ static int ubifs_remount_rw(struct ubifs_info *c)
+ }
+
+ dbg_gen("re-mounted read-write");
+- c->ro_mount = 0;
+ c->remounting_rw = 0;
+ c->always_chk_crc = 0;
+ err = dbg_check_space_info(c);
+@@ -1656,6 +1656,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
+ return err;
+
+ out:
++ c->ro_mount = 1;
+ vfree(c->orph_buf);
+ c->orph_buf = NULL;
+ if (c->bgt) {
+diff --git a/include/linux/kernel.h b/include/linux/kernel.h
+index 2fe6e84..00cec4d 100644
+--- a/include/linux/kernel.h
++++ b/include/linux/kernel.h
+@@ -187,14 +187,76 @@ NORET_TYPE void do_exit(long error_code)
+ ATTRIB_NORET;
+ NORET_TYPE void complete_and_exit(struct completion *, long)
+ ATTRIB_NORET;
++
++/* Internal, do not use. */
++int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
++int __must_check _kstrtol(const char *s, unsigned int base, long *res);
++
++int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
++int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
++static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
++{
++ /*
++ * We want to shortcut function call, but
++ * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0.
++ */
++ if (sizeof(unsigned long) == sizeof(unsigned long long) &&
++ __alignof__(unsigned long) == __alignof__(unsigned long long))
++ return kstrtoull(s, base, (unsigned long long *)res);
++ else
++ return _kstrtoul(s, base, res);
++}
++
++static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
++{
++ /*
++ * We want to shortcut function call, but
++ * __builtin_types_compatible_p(long, long long) = 0.
++ */
++ if (sizeof(long) == sizeof(long long) &&
++ __alignof__(long) == __alignof__(long long))
++ return kstrtoll(s, base, (long long *)res);
++ else
++ return _kstrtol(s, base, res);
++}
++
++int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res);
++int __must_check kstrtoint(const char *s, unsigned int base, int *res);
++
++static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res)
++{
++ return kstrtoull(s, base, res);
++}
++
++static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res)
++{
++ return kstrtoll(s, base, res);
++}
++
++static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res)
++{
++ return kstrtouint(s, base, res);
++}
++
++static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res)
++{
++ return kstrtoint(s, base, res);
++}
++
++int __must_check kstrtou16(const char *s, unsigned int base, u16 *res);
++int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
++int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
++int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
++
+ extern unsigned long simple_strtoul(const char *,char **,unsigned int);
+ extern long simple_strtol(const char *,char **,unsigned int);
+ extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
+ extern long long simple_strtoll(const char *,char **,unsigned int);
+-extern int __must_check strict_strtoul(const char *, unsigned int, unsigned long *);
+-extern int __must_check strict_strtol(const char *, unsigned int, long *);
+-extern int __must_check strict_strtoull(const char *, unsigned int, unsigned long long *);
+-extern int __must_check strict_strtoll(const char *, unsigned int, long long *);
++#define strict_strtoul kstrtoul
++#define strict_strtol kstrtol
++#define strict_strtoull kstrtoull
++#define strict_strtoll kstrtoll
++
+ extern int sprintf(char * buf, const char * fmt, ...)
+ __attribute__ ((format (printf, 2, 3)));
+ extern int vsprintf(char *buf, const char *, va_list)
+diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
+index dda5b0a..a9bd9c0 100644
+--- a/include/linux/perf_event.h
++++ b/include/linux/perf_event.h
+@@ -1052,7 +1052,7 @@ void perf_event_task_sched_out(struct task_struct *task, struct task_struct *nex
+ {
+ perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, NULL, 0);
+
+- COND_STMT(&perf_task_events, __perf_event_task_sched_out(task, next));
++ __perf_event_task_sched_out(task, next);
+ }
+
+ extern void perf_event_mmap(struct vm_area_struct *vma);
+diff --git a/include/linux/pid.h b/include/linux/pid.h
+index 49f1c2f..ec9f2df 100644
+--- a/include/linux/pid.h
++++ b/include/linux/pid.h
+@@ -117,7 +117,7 @@ extern struct pid *find_vpid(int nr);
+ */
+ extern struct pid *find_get_pid(int nr);
+ extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
+-int next_pidmap(struct pid_namespace *pid_ns, int last);
++int next_pidmap(struct pid_namespace *pid_ns, unsigned int last);
+
+ extern struct pid *alloc_pid(struct pid_namespace *ns);
+ extern void free_pid(struct pid *pid);
+diff --git a/include/linux/sched.h b/include/linux/sched.h
+index 777d8a5..ed6c384 100644
+--- a/include/linux/sched.h
++++ b/include/linux/sched.h
+@@ -1254,6 +1254,9 @@ struct task_struct {
+ #endif
+
+ struct mm_struct *mm, *active_mm;
++#ifdef CONFIG_COMPAT_BRK
++ unsigned brk_randomized:1;
++#endif
+ #if defined(SPLIT_RSS_COUNTING)
+ struct task_rss_stat rss_stat;
+ #endif
+diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
+index 29a7a8c..84d3b23 100644
+--- a/include/net/bluetooth/hci.h
++++ b/include/net/bluetooth/hci.h
+@@ -76,6 +76,8 @@ enum {
+ HCI_INQUIRY,
+
+ HCI_RAW,
++
++ HCI_RESET,
+ };
+
+ /* HCI ioctl defines */
+diff --git a/kernel/futex.c b/kernel/futex.c
+index b766d28..d5065e8 100644
+--- a/kernel/futex.c
++++ b/kernel/futex.c
+@@ -1886,7 +1886,7 @@ retry:
+ restart->futex.val = val;
+ restart->futex.time = abs_time->tv64;
+ restart->futex.bitset = bitset;
+- restart->futex.flags = flags;
++ restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
+
+ ret = -ERESTART_RESTARTBLOCK;
+
+diff --git a/kernel/pid.c b/kernel/pid.c
+index 39b65b6..6aeebc2 100644
+--- a/kernel/pid.c
++++ b/kernel/pid.c
+@@ -217,11 +217,14 @@ static int alloc_pidmap(struct pid_namespace *pid_ns)
+ return -1;
+ }
+
+-int next_pidmap(struct pid_namespace *pid_ns, int last)
++int next_pidmap(struct pid_namespace *pid_ns, unsigned int last)
+ {
+ int offset;
+ struct pidmap *map, *end;
+
++ if (last >= PID_MAX_LIMIT)
++ return -1;
++
+ offset = (last + 1) & BITS_PER_PAGE_MASK;
+ map = &pid_ns->pidmap[(last + 1)/BITS_PER_PAGE];
+ end = &pid_ns->pidmap[PIDMAP_ENTRIES];
+diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
+index 0c26e2d..7406f36 100644
+--- a/kernel/sched_fair.c
++++ b/kernel/sched_fair.c
+@@ -2043,21 +2043,20 @@ balance_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
+ enum cpu_idle_type idle, int *all_pinned,
+ int *this_best_prio, struct cfs_rq *busiest_cfs_rq)
+ {
+- int loops = 0, pulled = 0, pinned = 0;
++ int loops = 0, pulled = 0;
+ long rem_load_move = max_load_move;
+ struct task_struct *p, *n;
+
+ if (max_load_move == 0)
+ goto out;
+
+- pinned = 1;
+-
+ list_for_each_entry_safe(p, n, &busiest_cfs_rq->tasks, se.group_node) {
+ if (loops++ > sysctl_sched_nr_migrate)
+ break;
+
+ if ((p->se.load.weight >> 1) > rem_load_move ||
+- !can_migrate_task(p, busiest, this_cpu, sd, idle, &pinned))
++ !can_migrate_task(p, busiest, this_cpu, sd, idle,
++ all_pinned))
+ continue;
+
+ pull_task(busiest, p, this_rq, this_cpu);
+@@ -2092,9 +2091,6 @@ out:
+ */
+ schedstat_add(sd, lb_gained[idle], pulled);
+
+- if (all_pinned)
+- *all_pinned = pinned;
+-
+ return max_load_move - rem_load_move;
+ }
+
+@@ -3297,6 +3293,7 @@ redo:
+ * still unbalanced. ld_moved simply stays zero, so it is
+ * correctly treated as an imbalance.
+ */
++ all_pinned = 1;
+ local_irq_save(flags);
+ double_rq_lock(this_rq, busiest);
+ ld_moved = move_tasks(this_rq, this_cpu, busiest,
+diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
+index 2b97418..d1b5951 100644
+--- a/lib/Kconfig.debug
++++ b/lib/Kconfig.debug
+@@ -1236,3 +1236,6 @@ source "samples/Kconfig"
+ source "lib/Kconfig.kgdb"
+
+ source "lib/Kconfig.kmemcheck"
++
++config TEST_KSTRTOX
++ tristate "Test kstrto*() family of functions at runtime"
+diff --git a/lib/Makefile b/lib/Makefile
+index cbb774f..dfbf7d8 100644
+--- a/lib/Makefile
++++ b/lib/Makefile
+@@ -22,6 +22,8 @@ lib-y += kobject.o kref.o klist.o
+ obj-y += bcd.o div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \
+ bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o \
+ string_helpers.o gcd.o lcm.o list_sort.o uuid.o flex_array.o
++obj-y += kstrtox.o
++obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
+
+ ifeq ($(CONFIG_DEBUG_KOBJECT),y)
+ CFLAGS_kobject.o += -DDEBUG
+diff --git a/lib/kstrtox.c b/lib/kstrtox.c
+new file mode 100644
+index 0000000..05672e8
+--- /dev/null
++++ b/lib/kstrtox.c
+@@ -0,0 +1,227 @@
++/*
++ * Convert integer string representation to an integer.
++ * If an integer doesn't fit into specified type, -E is returned.
++ *
++ * Integer starts with optional sign.
++ * kstrtou*() functions do not accept sign "-".
++ *
++ * Radix 0 means autodetection: leading "0x" implies radix 16,
++ * leading "0" implies radix 8, otherwise radix is 10.
++ * Autodetection hints work after optional sign, but not before.
++ *
++ * If -E is returned, result is not touched.
++ */
++#include <linux/ctype.h>
++#include <linux/errno.h>
++#include <linux/kernel.h>
++#include <linux/math64.h>
++#include <linux/module.h>
++#include <linux/types.h>
++
++static inline char _tolower(const char c)
++{
++ return c | 0x20;
++}
++
++static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
++{
++ unsigned long long acc;
++ int ok;
++
++ if (base == 0) {
++ if (s[0] == '0') {
++ if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
++ base = 16;
++ else
++ base = 8;
++ } else
++ base = 10;
++ }
++ if (base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
++ s += 2;
++
++ acc = 0;
++ ok = 0;
++ while (*s) {
++ unsigned int val;
++
++ if ('0' <= *s && *s <= '9')
++ val = *s - '0';
++ else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
++ val = _tolower(*s) - 'a' + 10;
++ else if (*s == '\n') {
++ if (*(s + 1) == '\0')
++ break;
++ else
++ return -EINVAL;
++ } else
++ return -EINVAL;
++
++ if (val >= base)
++ return -EINVAL;
++ if (acc > div_u64(ULLONG_MAX - val, base))
++ return -ERANGE;
++ acc = acc * base + val;
++ ok = 1;
++
++ s++;
++ }
++ if (!ok)
++ return -EINVAL;
++ *res = acc;
++ return 0;
++}
++
++int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
++{
++ if (s[0] == '+')
++ s++;
++ return _kstrtoull(s, base, res);
++}
++EXPORT_SYMBOL(kstrtoull);
++
++int kstrtoll(const char *s, unsigned int base, long long *res)
++{
++ unsigned long long tmp;
++ int rv;
++
++ if (s[0] == '-') {
++ rv = _kstrtoull(s + 1, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if ((long long)(-tmp) >= 0)
++ return -ERANGE;
++ *res = -tmp;
++ } else {
++ rv = kstrtoull(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if ((long long)tmp < 0)
++ return -ERANGE;
++ *res = tmp;
++ }
++ return 0;
++}
++EXPORT_SYMBOL(kstrtoll);
++
++/* Internal, do not use. */
++int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
++{
++ unsigned long long tmp;
++ int rv;
++
++ rv = kstrtoull(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (unsigned long long)(unsigned long)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(_kstrtoul);
++
++/* Internal, do not use. */
++int _kstrtol(const char *s, unsigned int base, long *res)
++{
++ long long tmp;
++ int rv;
++
++ rv = kstrtoll(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (long long)(long)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(_kstrtol);
++
++int kstrtouint(const char *s, unsigned int base, unsigned int *res)
++{
++ unsigned long long tmp;
++ int rv;
++
++ rv = kstrtoull(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (unsigned long long)(unsigned int)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtouint);
++
++int kstrtoint(const char *s, unsigned int base, int *res)
++{
++ long long tmp;
++ int rv;
++
++ rv = kstrtoll(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (long long)(int)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtoint);
++
++int kstrtou16(const char *s, unsigned int base, u16 *res)
++{
++ unsigned long long tmp;
++ int rv;
++
++ rv = kstrtoull(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (unsigned long long)(u16)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtou16);
++
++int kstrtos16(const char *s, unsigned int base, s16 *res)
++{
++ long long tmp;
++ int rv;
++
++ rv = kstrtoll(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (long long)(s16)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtos16);
++
++int kstrtou8(const char *s, unsigned int base, u8 *res)
++{
++ unsigned long long tmp;
++ int rv;
++
++ rv = kstrtoull(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (unsigned long long)(u8)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtou8);
++
++int kstrtos8(const char *s, unsigned int base, s8 *res)
++{
++ long long tmp;
++ int rv;
++
++ rv = kstrtoll(s, base, &tmp);
++ if (rv < 0)
++ return rv;
++ if (tmp != (long long)(s8)tmp)
++ return -ERANGE;
++ *res = tmp;
++ return 0;
++}
++EXPORT_SYMBOL(kstrtos8);
+diff --git a/lib/test-kstrtox.c b/lib/test-kstrtox.c
+new file mode 100644
+index 0000000..325c2f9
+--- /dev/null
++++ b/lib/test-kstrtox.c
+@@ -0,0 +1,739 @@
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++
++#define for_each_test(i, test) \
++ for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)
++
++struct test_fail {
++ const char *str;
++ unsigned int base;
++};
++
++#define DEFINE_TEST_FAIL(test) \
++ const struct test_fail test[] __initdata
++
++#define DECLARE_TEST_OK(type, test_type) \
++ test_type { \
++ const char *str; \
++ unsigned int base; \
++ type expected_res; \
++ }
++
++#define DEFINE_TEST_OK(type, test) \
++ const type test[] __initdata
++
++#define TEST_FAIL(fn, type, fmt, test) \
++{ \
++ unsigned int i; \
++ \
++ for_each_test(i, test) { \
++ const struct test_fail *t = &test[i]; \
++ type tmp; \
++ int rv; \
++ \
++ tmp = 0; \
++ rv = fn(t->str, t->base, &tmp); \
++ if (rv >= 0) { \
++ WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n", \
++ t->str, t->base, rv, tmp); \
++ continue; \
++ } \
++ } \
++}
++
++#define TEST_OK(fn, type, fmt, test) \
++{ \
++ unsigned int i; \
++ \
++ for_each_test(i, test) { \
++ const typeof(test[0]) *t = &test[i]; \
++ type res; \
++ int rv; \
++ \
++ rv = fn(t->str, t->base, &res); \
++ if (rv != 0) { \
++ WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n", \
++ t->str, t->base, t->expected_res, rv); \
++ continue; \
++ } \
++ if (res != t->expected_res) { \
++ WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n", \
++ t->str, t->base, t->expected_res, res); \
++ continue; \
++ } \
++ } \
++}
++
++static void __init test_kstrtoull_ok(void)
++{
++ DECLARE_TEST_OK(unsigned long long, struct test_ull);
++ static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = {
++ {"0", 10, 0ULL},
++ {"1", 10, 1ULL},
++ {"127", 10, 127ULL},
++ {"128", 10, 128ULL},
++ {"129", 10, 129ULL},
++ {"255", 10, 255ULL},
++ {"256", 10, 256ULL},
++ {"257", 10, 257ULL},
++ {"32767", 10, 32767ULL},
++ {"32768", 10, 32768ULL},
++ {"32769", 10, 32769ULL},
++ {"65535", 10, 65535ULL},
++ {"65536", 10, 65536ULL},
++ {"65537", 10, 65537ULL},
++ {"2147483647", 10, 2147483647ULL},
++ {"2147483648", 10, 2147483648ULL},
++ {"2147483649", 10, 2147483649ULL},
++ {"4294967295", 10, 4294967295ULL},
++ {"4294967296", 10, 4294967296ULL},
++ {"4294967297", 10, 4294967297ULL},
++ {"9223372036854775807", 10, 9223372036854775807ULL},
++ {"9223372036854775808", 10, 9223372036854775808ULL},
++ {"9223372036854775809", 10, 9223372036854775809ULL},
++ {"18446744073709551614", 10, 18446744073709551614ULL},
++ {"18446744073709551615", 10, 18446744073709551615ULL},
++
++ {"00", 8, 00ULL},
++ {"01", 8, 01ULL},
++ {"0177", 8, 0177ULL},
++ {"0200", 8, 0200ULL},
++ {"0201", 8, 0201ULL},
++ {"0377", 8, 0377ULL},
++ {"0400", 8, 0400ULL},
++ {"0401", 8, 0401ULL},
++ {"077777", 8, 077777ULL},
++ {"0100000", 8, 0100000ULL},
++ {"0100001", 8, 0100001ULL},
++ {"0177777", 8, 0177777ULL},
++ {"0200000", 8, 0200000ULL},
++ {"0200001", 8, 0200001ULL},
++ {"017777777777", 8, 017777777777ULL},
++ {"020000000000", 8, 020000000000ULL},
++ {"020000000001", 8, 020000000001ULL},
++ {"037777777777", 8, 037777777777ULL},
++ {"040000000000", 8, 040000000000ULL},
++ {"040000000001", 8, 040000000001ULL},
++ {"0777777777777777777777", 8, 0777777777777777777777ULL},
++ {"01000000000000000000000", 8, 01000000000000000000000ULL},
++ {"01000000000000000000001", 8, 01000000000000000000001ULL},
++ {"01777777777777777777776", 8, 01777777777777777777776ULL},
++ {"01777777777777777777777", 8, 01777777777777777777777ULL},
++
++ {"0x0", 16, 0x0ULL},
++ {"0x1", 16, 0x1ULL},
++ {"0x7f", 16, 0x7fULL},
++ {"0x80", 16, 0x80ULL},
++ {"0x81", 16, 0x81ULL},
++ {"0xff", 16, 0xffULL},
++ {"0x100", 16, 0x100ULL},
++ {"0x101", 16, 0x101ULL},
++ {"0x7fff", 16, 0x7fffULL},
++ {"0x8000", 16, 0x8000ULL},
++ {"0x8001", 16, 0x8001ULL},
++ {"0xffff", 16, 0xffffULL},
++ {"0x10000", 16, 0x10000ULL},
++ {"0x10001", 16, 0x10001ULL},
++ {"0x7fffffff", 16, 0x7fffffffULL},
++ {"0x80000000", 16, 0x80000000ULL},
++ {"0x80000001", 16, 0x80000001ULL},
++ {"0xffffffff", 16, 0xffffffffULL},
++ {"0x100000000", 16, 0x100000000ULL},
++ {"0x100000001", 16, 0x100000001ULL},
++ {"0x7fffffffffffffff", 16, 0x7fffffffffffffffULL},
++ {"0x8000000000000000", 16, 0x8000000000000000ULL},
++ {"0x8000000000000001", 16, 0x8000000000000001ULL},
++ {"0xfffffffffffffffe", 16, 0xfffffffffffffffeULL},
++ {"0xffffffffffffffff", 16, 0xffffffffffffffffULL},
++
++ {"0\n", 0, 0ULL},
++ };
++ TEST_OK(kstrtoull, unsigned long long, "%llu", test_ull_ok);
++}
++
++static void __init test_kstrtoull_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_ull_fail) = {
++ {"", 0},
++ {"", 8},
++ {"", 10},
++ {"", 16},
++ {"\n", 0},
++ {"\n", 8},
++ {"\n", 10},
++ {"\n", 16},
++ {"\n0", 0},
++ {"\n0", 8},
++ {"\n0", 10},
++ {"\n0", 16},
++ {"+", 0},
++ {"+", 8},
++ {"+", 10},
++ {"+", 16},
++ {"-", 0},
++ {"-", 8},
++ {"-", 10},
++ {"-", 16},
++ {"0x", 0},
++ {"0x", 16},
++ {"0X", 0},
++ {"0X", 16},
++ {"0 ", 0},
++ {"1+", 0},
++ {"1-", 0},
++ {" 2", 0},
++ /* base autodetection */
++ {"0x0z", 0},
++ {"0z", 0},
++ {"a", 0},
++ /* digit >= base */
++ {"2", 2},
++ {"8", 8},
++ {"a", 10},
++ {"A", 10},
++ {"g", 16},
++ {"G", 16},
++ /* overflow */
++ {"10000000000000000000000000000000000000000000000000000000000000000", 2},
++ {"2000000000000000000000", 8},
++ {"18446744073709551616", 10},
++ {"10000000000000000", 16},
++ /* negative */
++ {"-0", 0},
++ {"-0", 8},
++ {"-0", 10},
++ {"-0", 16},
++ {"-1", 0},
++ {"-1", 8},
++ {"-1", 10},
++ {"-1", 16},
++ /* sign is first character if any */
++ {"-+1", 0},
++ {"-+1", 8},
++ {"-+1", 10},
++ {"-+1", 16},
++ /* nothing after \n */
++ {"0\n0", 0},
++ {"0\n0", 8},
++ {"0\n0", 10},
++ {"0\n0", 16},
++ {"0\n+", 0},
++ {"0\n+", 8},
++ {"0\n+", 10},
++ {"0\n+", 16},
++ {"0\n-", 0},
++ {"0\n-", 8},
++ {"0\n-", 10},
++ {"0\n-", 16},
++ {"0\n ", 0},
++ {"0\n ", 8},
++ {"0\n ", 10},
++ {"0\n ", 16},
++ };
++ TEST_FAIL(kstrtoull, unsigned long long, "%llu", test_ull_fail);
++}
++
++static void __init test_kstrtoll_ok(void)
++{
++ DECLARE_TEST_OK(long long, struct test_ll);
++ static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = {
++ {"0", 10, 0LL},
++ {"1", 10, 1LL},
++ {"127", 10, 127LL},
++ {"128", 10, 128LL},
++ {"129", 10, 129LL},
++ {"255", 10, 255LL},
++ {"256", 10, 256LL},
++ {"257", 10, 257LL},
++ {"32767", 10, 32767LL},
++ {"32768", 10, 32768LL},
++ {"32769", 10, 32769LL},
++ {"65535", 10, 65535LL},
++ {"65536", 10, 65536LL},
++ {"65537", 10, 65537LL},
++ {"2147483647", 10, 2147483647LL},
++ {"2147483648", 10, 2147483648LL},
++ {"2147483649", 10, 2147483649LL},
++ {"4294967295", 10, 4294967295LL},
++ {"4294967296", 10, 4294967296LL},
++ {"4294967297", 10, 4294967297LL},
++ {"9223372036854775807", 10, 9223372036854775807LL},
++
++ {"-1", 10, -1LL},
++ {"-2", 10, -2LL},
++ {"-9223372036854775808", 10, LLONG_MIN},
++ };
++ TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
++}
++
++static void __init test_kstrtoll_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_ll_fail) = {
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"-9223372036854775809", 10},
++ {"-18446744073709551614", 10},
++ {"-18446744073709551615", 10},
++ /* negative zero isn't an integer in Linux */
++ {"-0", 0},
++ {"-0", 8},
++ {"-0", 10},
++ {"-0", 16},
++ /* sign is first character if any */
++ {"-+1", 0},
++ {"-+1", 8},
++ {"-+1", 10},
++ {"-+1", 16},
++ };
++ TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
++}
++
++static void __init test_kstrtou64_ok(void)
++{
++ DECLARE_TEST_OK(u64, struct test_u64);
++ static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ {"32768", 10, 32768},
++ {"32769", 10, 32769},
++ {"65534", 10, 65534},
++ {"65535", 10, 65535},
++ {"65536", 10, 65536},
++ {"65537", 10, 65537},
++ {"2147483646", 10, 2147483646},
++ {"2147483647", 10, 2147483647},
++ {"2147483648", 10, 2147483648},
++ {"2147483649", 10, 2147483649},
++ {"4294967294", 10, 4294967294},
++ {"4294967295", 10, 4294967295},
++ {"4294967296", 10, 4294967296},
++ {"4294967297", 10, 4294967297},
++ {"9223372036854775806", 10, 9223372036854775806ULL},
++ {"9223372036854775807", 10, 9223372036854775807ULL},
++ {"9223372036854775808", 10, 9223372036854775808ULL},
++ {"9223372036854775809", 10, 9223372036854775809ULL},
++ {"18446744073709551614", 10, 18446744073709551614ULL},
++ {"18446744073709551615", 10, 18446744073709551615ULL},
++ };
++ TEST_OK(kstrtou64, u64, "%llu", test_u64_ok);
++}
++
++static void __init test_kstrtou64_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_u64_fail) = {
++ {"-2", 10},
++ {"-1", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtou64, u64, "%llu", test_u64_fail);
++}
++
++static void __init test_kstrtos64_ok(void)
++{
++ DECLARE_TEST_OK(s64, struct test_s64);
++ static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = {
++ {"-128", 10, -128},
++ {"-127", 10, -127},
++ {"-1", 10, -1},
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ {"32768", 10, 32768},
++ {"32769", 10, 32769},
++ {"65534", 10, 65534},
++ {"65535", 10, 65535},
++ {"65536", 10, 65536},
++ {"65537", 10, 65537},
++ {"2147483646", 10, 2147483646},
++ {"2147483647", 10, 2147483647},
++ {"2147483648", 10, 2147483648},
++ {"2147483649", 10, 2147483649},
++ {"4294967294", 10, 4294967294},
++ {"4294967295", 10, 4294967295},
++ {"4294967296", 10, 4294967296},
++ {"4294967297", 10, 4294967297},
++ {"9223372036854775806", 10, 9223372036854775806LL},
++ {"9223372036854775807", 10, 9223372036854775807LL},
++ };
++ TEST_OK(kstrtos64, s64, "%lld", test_s64_ok);
++}
++
++static void __init test_kstrtos64_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_s64_fail) = {
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtos64, s64, "%lld", test_s64_fail);
++}
++
++static void __init test_kstrtou32_ok(void)
++{
++ DECLARE_TEST_OK(u32, struct test_u32);
++ static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = {
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ {"32768", 10, 32768},
++ {"32769", 10, 32769},
++ {"65534", 10, 65534},
++ {"65535", 10, 65535},
++ {"65536", 10, 65536},
++ {"65537", 10, 65537},
++ {"2147483646", 10, 2147483646},
++ {"2147483647", 10, 2147483647},
++ {"2147483648", 10, 2147483648},
++ {"2147483649", 10, 2147483649},
++ {"4294967294", 10, 4294967294},
++ {"4294967295", 10, 4294967295},
++ };
++ TEST_OK(kstrtou32, u32, "%u", test_u32_ok);
++}
++
++static void __init test_kstrtou32_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_u32_fail) = {
++ {"-2", 10},
++ {"-1", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtou32, u32, "%u", test_u32_fail);
++}
++
++static void __init test_kstrtos32_ok(void)
++{
++ DECLARE_TEST_OK(s32, struct test_s32);
++ static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = {
++ {"-128", 10, -128},
++ {"-127", 10, -127},
++ {"-1", 10, -1},
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ {"32768", 10, 32768},
++ {"32769", 10, 32769},
++ {"65534", 10, 65534},
++ {"65535", 10, 65535},
++ {"65536", 10, 65536},
++ {"65537", 10, 65537},
++ {"2147483646", 10, 2147483646},
++ {"2147483647", 10, 2147483647},
++ };
++ TEST_OK(kstrtos32, s32, "%d", test_s32_ok);
++}
++
++static void __init test_kstrtos32_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_s32_fail) = {
++ {"2147483648", 10},
++ {"2147483649", 10},
++ {"4294967294", 10},
++ {"4294967295", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtos32, s32, "%d", test_s32_fail);
++}
++
++static void __init test_kstrtou16_ok(void)
++{
++ DECLARE_TEST_OK(u16, struct test_u16);
++ static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = {
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ {"32768", 10, 32768},
++ {"32769", 10, 32769},
++ {"65534", 10, 65534},
++ {"65535", 10, 65535},
++ };
++ TEST_OK(kstrtou16, u16, "%hu", test_u16_ok);
++}
++
++static void __init test_kstrtou16_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_u16_fail) = {
++ {"-2", 10},
++ {"-1", 10},
++ {"65536", 10},
++ {"65537", 10},
++ {"2147483646", 10},
++ {"2147483647", 10},
++ {"2147483648", 10},
++ {"2147483649", 10},
++ {"4294967294", 10},
++ {"4294967295", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtou16, u16, "%hu", test_u16_fail);
++}
++
++static void __init test_kstrtos16_ok(void)
++{
++ DECLARE_TEST_OK(s16, struct test_s16);
++ static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = {
++ {"-130", 10, -130},
++ {"-129", 10, -129},
++ {"-128", 10, -128},
++ {"-127", 10, -127},
++ {"-1", 10, -1},
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ {"256", 10, 256},
++ {"257", 10, 257},
++ {"32766", 10, 32766},
++ {"32767", 10, 32767},
++ };
++ TEST_OK(kstrtos16, s16, "%hd", test_s16_ok);
++}
++
++static void __init test_kstrtos16_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_s16_fail) = {
++ {"32768", 10},
++ {"32769", 10},
++ {"65534", 10},
++ {"65535", 10},
++ {"65536", 10},
++ {"65537", 10},
++ {"2147483646", 10},
++ {"2147483647", 10},
++ {"2147483648", 10},
++ {"2147483649", 10},
++ {"4294967294", 10},
++ {"4294967295", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtos16, s16, "%hd", test_s16_fail);
++}
++
++static void __init test_kstrtou8_ok(void)
++{
++ DECLARE_TEST_OK(u8, struct test_u8);
++ static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = {
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ {"128", 10, 128},
++ {"129", 10, 129},
++ {"254", 10, 254},
++ {"255", 10, 255},
++ };
++ TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok);
++}
++
++static void __init test_kstrtou8_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_u8_fail) = {
++ {"-2", 10},
++ {"-1", 10},
++ {"256", 10},
++ {"257", 10},
++ {"32766", 10},
++ {"32767", 10},
++ {"32768", 10},
++ {"32769", 10},
++ {"65534", 10},
++ {"65535", 10},
++ {"65536", 10},
++ {"65537", 10},
++ {"2147483646", 10},
++ {"2147483647", 10},
++ {"2147483648", 10},
++ {"2147483649", 10},
++ {"4294967294", 10},
++ {"4294967295", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtou8, u8, "%hhu", test_u8_fail);
++}
++
++static void __init test_kstrtos8_ok(void)
++{
++ DECLARE_TEST_OK(s8, struct test_s8);
++ static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = {
++ {"-128", 10, -128},
++ {"-127", 10, -127},
++ {"-1", 10, -1},
++ {"0", 10, 0},
++ {"1", 10, 1},
++ {"126", 10, 126},
++ {"127", 10, 127},
++ };
++ TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok);
++}
++
++static void __init test_kstrtos8_fail(void)
++{
++ static DEFINE_TEST_FAIL(test_s8_fail) = {
++ {"-130", 10},
++ {"-129", 10},
++ {"128", 10},
++ {"129", 10},
++ {"254", 10},
++ {"255", 10},
++ {"256", 10},
++ {"257", 10},
++ {"32766", 10},
++ {"32767", 10},
++ {"32768", 10},
++ {"32769", 10},
++ {"65534", 10},
++ {"65535", 10},
++ {"65536", 10},
++ {"65537", 10},
++ {"2147483646", 10},
++ {"2147483647", 10},
++ {"2147483648", 10},
++ {"2147483649", 10},
++ {"4294967294", 10},
++ {"4294967295", 10},
++ {"4294967296", 10},
++ {"4294967297", 10},
++ {"9223372036854775806", 10},
++ {"9223372036854775807", 10},
++ {"9223372036854775808", 10},
++ {"9223372036854775809", 10},
++ {"18446744073709551614", 10},
++ {"18446744073709551615", 10},
++ {"18446744073709551616", 10},
++ {"18446744073709551617", 10},
++ };
++ TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail);
++}
++
++static int __init test_kstrtox_init(void)
++{
++ test_kstrtoull_ok();
++ test_kstrtoull_fail();
++ test_kstrtoll_ok();
++ test_kstrtoll_fail();
++
++ test_kstrtou64_ok();
++ test_kstrtou64_fail();
++ test_kstrtos64_ok();
++ test_kstrtos64_fail();
++
++ test_kstrtou32_ok();
++ test_kstrtou32_fail();
++ test_kstrtos32_ok();
++ test_kstrtos32_fail();
++
++ test_kstrtou16_ok();
++ test_kstrtou16_fail();
++ test_kstrtos16_ok();
++ test_kstrtos16_fail();
++
++ test_kstrtou8_ok();
++ test_kstrtou8_fail();
++ test_kstrtos8_ok();
++ test_kstrtos8_fail();
++ return -EINVAL;
++}
++module_init(test_kstrtox_init);
++MODULE_LICENSE("Dual BSD/GPL");
+diff --git a/lib/vsprintf.c b/lib/vsprintf.c
+index d3023df..f3fd99a 100644
+--- a/lib/vsprintf.c
++++ b/lib/vsprintf.c
+@@ -120,147 +120,6 @@ long long simple_strtoll(const char *cp, char **endp, unsigned int base)
+ }
+ EXPORT_SYMBOL(simple_strtoll);
+
+-/**
+- * strict_strtoul - convert a string to an unsigned long strictly
+- * @cp: The string to be converted
+- * @base: The number base to use
+- * @res: The converted result value
+- *
+- * strict_strtoul converts a string to an unsigned long only if the
+- * string is really an unsigned long string, any string containing
+- * any invalid char at the tail will be rejected and -EINVAL is returned,
+- * only a newline char at the tail is acceptible because people generally
+- * change a module parameter in the following way:
+- *
+- * echo 1024 > /sys/module/e1000/parameters/copybreak
+- *
+- * echo will append a newline to the tail.
+- *
+- * It returns 0 if conversion is successful and *res is set to the converted
+- * value, otherwise it returns -EINVAL and *res is set to 0.
+- *
+- * simple_strtoul just ignores the successive invalid characters and
+- * return the converted value of prefix part of the string.
+- */
+-int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
+-{
+- char *tail;
+- unsigned long val;
+-
+- *res = 0;
+- if (!*cp)
+- return -EINVAL;
+-
+- val = simple_strtoul(cp, &tail, base);
+- if (tail == cp)
+- return -EINVAL;
+-
+- if ((tail[0] == '\0') || (tail[0] == '\n' && tail[1] == '\0')) {
+- *res = val;
+- return 0;
+- }
+-
+- return -EINVAL;
+-}
+-EXPORT_SYMBOL(strict_strtoul);
+-
+-/**
+- * strict_strtol - convert a string to a long strictly
+- * @cp: The string to be converted
+- * @base: The number base to use
+- * @res: The converted result value
+- *
+- * strict_strtol is similiar to strict_strtoul, but it allows the first
+- * character of a string is '-'.
+- *
+- * It returns 0 if conversion is successful and *res is set to the converted
+- * value, otherwise it returns -EINVAL and *res is set to 0.
+- */
+-int strict_strtol(const char *cp, unsigned int base, long *res)
+-{
+- int ret;
+- if (*cp == '-') {
+- ret = strict_strtoul(cp + 1, base, (unsigned long *)res);
+- if (!ret)
+- *res = -(*res);
+- } else {
+- ret = strict_strtoul(cp, base, (unsigned long *)res);
+- }
+-
+- return ret;
+-}
+-EXPORT_SYMBOL(strict_strtol);
+-
+-/**
+- * strict_strtoull - convert a string to an unsigned long long strictly
+- * @cp: The string to be converted
+- * @base: The number base to use
+- * @res: The converted result value
+- *
+- * strict_strtoull converts a string to an unsigned long long only if the
+- * string is really an unsigned long long string, any string containing
+- * any invalid char at the tail will be rejected and -EINVAL is returned,
+- * only a newline char at the tail is acceptible because people generally
+- * change a module parameter in the following way:
+- *
+- * echo 1024 > /sys/module/e1000/parameters/copybreak
+- *
+- * echo will append a newline to the tail of the string.
+- *
+- * It returns 0 if conversion is successful and *res is set to the converted
+- * value, otherwise it returns -EINVAL and *res is set to 0.
+- *
+- * simple_strtoull just ignores the successive invalid characters and
+- * return the converted value of prefix part of the string.
+- */
+-int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
+-{
+- char *tail;
+- unsigned long long val;
+-
+- *res = 0;
+- if (!*cp)
+- return -EINVAL;
+-
+- val = simple_strtoull(cp, &tail, base);
+- if (tail == cp)
+- return -EINVAL;
+- if ((tail[0] == '\0') || (tail[0] == '\n' && tail[1] == '\0')) {
+- *res = val;
+- return 0;
+- }
+-
+- return -EINVAL;
+-}
+-EXPORT_SYMBOL(strict_strtoull);
+-
+-/**
+- * strict_strtoll - convert a string to a long long strictly
+- * @cp: The string to be converted
+- * @base: The number base to use
+- * @res: The converted result value
+- *
+- * strict_strtoll is similiar to strict_strtoull, but it allows the first
+- * character of a string is '-'.
+- *
+- * It returns 0 if conversion is successful and *res is set to the converted
+- * value, otherwise it returns -EINVAL and *res is set to 0.
+- */
+-int strict_strtoll(const char *cp, unsigned int base, long long *res)
+-{
+- int ret;
+- if (*cp == '-') {
+- ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);
+- if (!ret)
+- *res = -(*res);
+- } else {
+- ret = strict_strtoull(cp, base, (unsigned long long *)res);
+- }
+-
+- return ret;
+-}
+-EXPORT_SYMBOL(strict_strtoll);
+-
+ static noinline_for_stack
+ int skip_atoi(const char **s)
+ {
+diff --git a/mm/huge_memory.c b/mm/huge_memory.c
+index 113e35c..8f76561 100644
+--- a/mm/huge_memory.c
++++ b/mm/huge_memory.c
+@@ -244,24 +244,28 @@ static ssize_t single_flag_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf,
+ enum transparent_hugepage_flag flag)
+ {
+- if (test_bit(flag, &transparent_hugepage_flags))
+- return sprintf(buf, "[yes] no\n");
+- else
+- return sprintf(buf, "yes [no]\n");
++ return sprintf(buf, "%d\n",
++ !!test_bit(flag, &transparent_hugepage_flags));
+ }
++
+ static ssize_t single_flag_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buf, size_t count,
+ enum transparent_hugepage_flag flag)
+ {
+- if (!memcmp("yes", buf,
+- min(sizeof("yes")-1, count))) {
++ unsigned long value;
++ int ret;
++
++ ret = kstrtoul(buf, 10, &value);
++ if (ret < 0)
++ return ret;
++ if (value > 1)
++ return -EINVAL;
++
++ if (value)
+ set_bit(flag, &transparent_hugepage_flags);
+- } else if (!memcmp("no", buf,
+- min(sizeof("no")-1, count))) {
++ else
+ clear_bit(flag, &transparent_hugepage_flags);
+- } else
+- return -EINVAL;
+
+ return count;
+ }
+diff --git a/mm/memory.c b/mm/memory.c
+index 5823698..f17746a 100644
+--- a/mm/memory.c
++++ b/mm/memory.c
+@@ -1410,6 +1410,13 @@ no_page_table:
+ return page;
+ }
+
++static inline int stack_guard_page(struct vm_area_struct *vma, unsigned long addr)
++{
++ return (vma->vm_flags & VM_GROWSDOWN) &&
++ (vma->vm_start == addr) &&
++ !vma_stack_continue(vma->vm_prev, addr);
++}
++
+ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ unsigned long start, int nr_pages, unsigned int gup_flags,
+ struct page **pages, struct vm_area_struct **vmas,
+@@ -1439,7 +1446,6 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ vma = find_extend_vma(mm, start);
+ if (!vma && in_gate_area(tsk, start)) {
+ unsigned long pg = start & PAGE_MASK;
+- struct vm_area_struct *gate_vma = get_gate_vma(tsk);
+ pgd_t *pgd;
+ pud_t *pud;
+ pmd_t *pmd;
+@@ -1464,10 +1470,11 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ pte_unmap(pte);
+ return i ? : -EFAULT;
+ }
++ vma = get_gate_vma(tsk);
+ if (pages) {
+ struct page *page;
+
+- page = vm_normal_page(gate_vma, start, *pte);
++ page = vm_normal_page(vma, start, *pte);
+ if (!page) {
+ if (!(gup_flags & FOLL_DUMP) &&
+ is_zero_pfn(pte_pfn(*pte)))
+@@ -1481,12 +1488,7 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ get_page(page);
+ }
+ pte_unmap(pte);
+- if (vmas)
+- vmas[i] = gate_vma;
+- i++;
+- start += PAGE_SIZE;
+- nr_pages--;
+- continue;
++ goto next_page;
+ }
+
+ if (!vma ||
+@@ -1500,6 +1502,13 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ continue;
+ }
+
++ /*
++ * If we don't actually want the page itself,
++ * and it's the stack guard page, just skip it.
++ */
++ if (!pages && stack_guard_page(vma, start))
++ goto next_page;
++
+ do {
+ struct page *page;
+ unsigned int foll_flags = gup_flags;
+@@ -1569,6 +1578,7 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+ flush_anon_page(vma, page, start);
+ flush_dcache_page(page);
+ }
++next_page:
+ if (vmas)
+ vmas[i] = vma;
+ i++;
+diff --git a/mm/mlock.c b/mm/mlock.c
+index c3924c7f..da23be4 100644
+--- a/mm/mlock.c
++++ b/mm/mlock.c
+@@ -135,13 +135,6 @@ void munlock_vma_page(struct page *page)
+ }
+ }
+
+-static inline int stack_guard_page(struct vm_area_struct *vma, unsigned long addr)
+-{
+- return (vma->vm_flags & VM_GROWSDOWN) &&
+- (vma->vm_start == addr) &&
+- !vma_stack_continue(vma->vm_prev, addr);
+-}
+-
+ /**
+ * __mlock_vma_pages_range() - mlock a range of pages in the vma.
+ * @vma: target vma
+@@ -188,12 +181,6 @@ static long __mlock_vma_pages_range(struct vm_area_struct *vma,
+ if (vma->vm_flags & VM_LOCKED)
+ gup_flags |= FOLL_MLOCK;
+
+- /* We don't try to access the guard page of a stack vma */
+- if (stack_guard_page(vma, start)) {
+- addr += PAGE_SIZE;
+- nr_pages--;
+- }
+-
+ return __get_user_pages(current, mm, addr, nr_pages, gup_flags,
+ NULL, NULL, nonblocking);
+ }
+diff --git a/mm/mmap.c b/mm/mmap.c
+index 2ec8eb5..e27e0cf 100644
+--- a/mm/mmap.c
++++ b/mm/mmap.c
+@@ -259,7 +259,7 @@ SYSCALL_DEFINE1(brk, unsigned long, brk)
+ * randomize_va_space to 2, which will still cause mm->start_brk
+ * to be arbitrarily shifted
+ */
+- if (mm->start_brk > PAGE_ALIGN(mm->end_data))
++ if (current->brk_randomized)
+ min_brk = mm->start_brk;
+ else
+ min_brk = mm->end_data;
+@@ -1814,11 +1814,14 @@ static int expand_downwards(struct vm_area_struct *vma,
+ size = vma->vm_end - address;
+ grow = (vma->vm_start - address) >> PAGE_SHIFT;
+
+- error = acct_stack_growth(vma, size, grow);
+- if (!error) {
+- vma->vm_start = address;
+- vma->vm_pgoff -= grow;
+- perf_event_mmap(vma);
++ error = -ENOMEM;
++ if (grow <= vma->vm_pgoff) {
++ error = acct_stack_growth(vma, size, grow);
++ if (!error) {
++ vma->vm_start = address;
++ vma->vm_pgoff -= grow;
++ perf_event_mmap(vma);
++ }
+ }
+ }
+ vma_unlock_anon_vma(vma);
+diff --git a/mm/oom_kill.c b/mm/oom_kill.c
+index 33b5861..ea16f72 100644
+--- a/mm/oom_kill.c
++++ b/mm/oom_kill.c
+@@ -84,24 +84,6 @@ static bool has_intersects_mems_allowed(struct task_struct *tsk,
+ #endif /* CONFIG_NUMA */
+
+ /*
+- * If this is a system OOM (not a memcg OOM) and the task selected to be
+- * killed is not already running at high (RT) priorities, speed up the
+- * recovery by boosting the dying task to the lowest FIFO priority.
+- * That helps with the recovery and avoids interfering with RT tasks.
+- */
+-static void boost_dying_task_prio(struct task_struct *p,
+- struct mem_cgroup *mem)
+-{
+- struct sched_param param = { .sched_priority = 1 };
+-
+- if (mem)
+- return;
+-
+- if (!rt_task(p))
+- sched_setscheduler_nocheck(p, SCHED_FIFO, ¶m);
+-}
+-
+-/*
+ * The process p may have detached its own ->mm while exiting or through
+ * use_mm(), but one or more of its subthreads may still have a valid
+ * pointer. Return p, or any of its subthreads with a valid ->mm, with
+@@ -452,13 +434,6 @@ static int oom_kill_task(struct task_struct *p, struct mem_cgroup *mem)
+ set_tsk_thread_flag(p, TIF_MEMDIE);
+ force_sig(SIGKILL, p);
+
+- /*
+- * We give our sacrificial lamb high priority and access to
+- * all the memory it needs. That way it should be able to
+- * exit() and clear out its resources quickly...
+- */
+- boost_dying_task_prio(p, mem);
+-
+ return 0;
+ }
+ #undef K
+@@ -482,7 +457,6 @@ static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
+ */
+ if (p->flags & PF_EXITING) {
+ set_tsk_thread_flag(p, TIF_MEMDIE);
+- boost_dying_task_prio(p, mem);
+ return 0;
+ }
+
+@@ -701,7 +675,6 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
+ */
+ if (fatal_signal_pending(current)) {
+ set_thread_flag(TIF_MEMDIE);
+- boost_dying_task_prio(current, NULL);
+ return;
+ }
+
+diff --git a/mm/vmscan.c b/mm/vmscan.c
+index 3b4a41d..0665520 100644
+--- a/mm/vmscan.c
++++ b/mm/vmscan.c
+@@ -41,6 +41,7 @@
+ #include <linux/memcontrol.h>
+ #include <linux/delayacct.h>
+ #include <linux/sysctl.h>
++#include <linux/oom.h>
+
+ #include <asm/tlbflush.h>
+ #include <asm/div64.h>
+@@ -1988,17 +1989,12 @@ static bool zone_reclaimable(struct zone *zone)
+ return zone->pages_scanned < zone_reclaimable_pages(zone) * 6;
+ }
+
+-/*
+- * As hibernation is going on, kswapd is freezed so that it can't mark
+- * the zone into all_unreclaimable. It can't handle OOM during hibernation.
+- * So let's check zone's unreclaimable in direct reclaim as well as kswapd.
+- */
++/* All zones in zonelist are unreclaimable? */
+ static bool all_unreclaimable(struct zonelist *zonelist,
+ struct scan_control *sc)
+ {
+ struct zoneref *z;
+ struct zone *zone;
+- bool all_unreclaimable = true;
+
+ for_each_zone_zonelist_nodemask(zone, z, zonelist,
+ gfp_zone(sc->gfp_mask), sc->nodemask) {
+@@ -2006,13 +2002,11 @@ static bool all_unreclaimable(struct zonelist *zonelist,
+ continue;
+ if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
+ continue;
+- if (zone_reclaimable(zone)) {
+- all_unreclaimable = false;
+- break;
+- }
++ if (!zone->all_unreclaimable)
++ return false;
+ }
+
+- return all_unreclaimable;
++ return true;
+ }
+
+ /*
+@@ -2108,6 +2102,14 @@ out:
+ if (sc->nr_reclaimed)
+ return sc->nr_reclaimed;
+
++ /*
++ * As hibernation is going on, kswapd is freezed so that it can't mark
++ * the zone into all_unreclaimable. Thus bypassing all_unreclaimable
++ * check.
++ */
++ if (oom_killer_disabled)
++ return 0;
++
+ /* top priority shrink_zones still had more to do? don't OOM, then */
+ if (scanning_global_lru(sc) && !all_unreclaimable(zonelist, sc))
+ return 1;
+diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
+index be73753..ed68d07 100644
+--- a/net/8021q/vlan_dev.c
++++ b/net/8021q/vlan_dev.c
+@@ -707,6 +707,7 @@ static int vlan_dev_init(struct net_device *dev)
+ dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;
+ #endif
+
++ dev->needed_headroom = real_dev->needed_headroom;
+ if (real_dev->features & NETIF_F_HW_VLAN_TX) {
+ dev->header_ops = real_dev->header_ops;
+ dev->hard_header_len = real_dev->hard_header_len;
+diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
+index 9c4541b..7d0a304 100644
+--- a/net/bluetooth/hci_core.c
++++ b/net/bluetooth/hci_core.c
+@@ -184,6 +184,7 @@ static void hci_reset_req(struct hci_dev *hdev, unsigned long opt)
+ BT_DBG("%s %ld", hdev->name, opt);
+
+ /* Reset device */
++ set_bit(HCI_RESET, &hdev->flags);
+ hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
+ }
+
+@@ -210,8 +211,10 @@ static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
+ /* Mandatory initialization */
+
+ /* Reset */
+- if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks))
++ if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) {
++ set_bit(HCI_RESET, &hdev->flags);
+ hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
++ }
+
+ /* Read Local Supported Features */
+ hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL);
+diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
+index a290854..a63bcf0 100644
+--- a/net/bluetooth/hci_event.c
++++ b/net/bluetooth/hci_event.c
+@@ -183,6 +183,8 @@ static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
+
+ BT_DBG("%s status 0x%x", hdev->name, status);
+
++ clear_bit(HCI_RESET, &hdev->flags);
++
+ hci_req_complete(hdev, HCI_OP_RESET, status);
+ }
+
+@@ -1464,7 +1466,7 @@ static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
+ break;
+ }
+
+- if (ev->ncmd) {
++ if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
+ atomic_set(&hdev->cmd_cnt, 1);
+ if (!skb_queue_empty(&hdev->cmd_q))
+ tasklet_schedule(&hdev->cmd_task);
+diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c
+index 030a002..f61eb2e 100644
+--- a/net/bridge/br_multicast.c
++++ b/net/bridge/br_multicast.c
+@@ -445,9 +445,9 @@ static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
+ ip6h->payload_len = htons(8 + sizeof(*mldq));
+ ip6h->nexthdr = IPPROTO_HOPOPTS;
+ ip6h->hop_limit = 1;
++ ipv6_addr_set(&ip6h->daddr, htonl(0xff020000), 0, 0, htonl(1));
+ ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
+ &ip6h->saddr);
+- ipv6_addr_set(&ip6h->daddr, htonl(0xff020000), 0, 0, htonl(1));
+ ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
+
+ hopopt = (u8 *)(ip6h + 1);
+diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
+index 4b5b66d..49d50ea 100644
+--- a/net/bridge/br_netfilter.c
++++ b/net/bridge/br_netfilter.c
+@@ -741,6 +741,9 @@ static unsigned int br_nf_forward_ip(unsigned int hook, struct sk_buff *skb,
+ nf_bridge->mask |= BRNF_PKT_TYPE;
+ }
+
++ if (br_parse_ip_options(skb))
++ return NF_DROP;
++
+ /* The physdev module checks on this */
+ nf_bridge->mask |= BRNF_BRIDGED;
+ nf_bridge->physoutdev = skb->dev;
+diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
+index 1d2cdd4..8725e78 100644
+--- a/net/ipv4/fib_frontend.c
++++ b/net/ipv4/fib_frontend.c
+@@ -1041,6 +1041,7 @@ static void ip_fib_net_exit(struct net *net)
+ fib4_rules_exit(net);
+ #endif
+
++ rtnl_lock();
+ for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
+ struct fib_table *tb;
+ struct hlist_head *head;
+@@ -1053,6 +1054,7 @@ static void ip_fib_net_exit(struct net *net)
+ fib_free_table(tb);
+ }
+ }
++ rtnl_unlock();
+ kfree(net->ipv4.fib_table_hash);
+ }
+
+diff --git a/net/ipv4/route.c b/net/ipv4/route.c
+index 6ed6603..fabfe81 100644
+--- a/net/ipv4/route.c
++++ b/net/ipv4/route.c
+@@ -171,7 +171,7 @@ static struct dst_ops ipv4_dst_ops = {
+
+ const __u8 ip_tos2prio[16] = {
+ TC_PRIO_BESTEFFORT,
+- ECN_OR_COST(FILLER),
++ ECN_OR_COST(BESTEFFORT),
+ TC_PRIO_BESTEFFORT,
+ ECN_OR_COST(BESTEFFORT),
+ TC_PRIO_BULK,
+diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
+index 65f6c04..5f1ea7c 100644
+--- a/net/ipv4/tcp_input.c
++++ b/net/ipv4/tcp_input.c
+@@ -2659,7 +2659,7 @@ static void DBGUNDO(struct sock *sk, const char *msg)
+ #define DBGUNDO(x...) do { } while (0)
+ #endif
+
+-static void tcp_undo_cwr(struct sock *sk, const int undo)
++static void tcp_undo_cwr(struct sock *sk, const int undo_ssthresh)
+ {
+ struct tcp_sock *tp = tcp_sk(sk);
+
+@@ -2671,14 +2671,13 @@ static void tcp_undo_cwr(struct sock *sk, const int undo)
+ else
+ tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);
+
+- if (undo && tp->prior_ssthresh > tp->snd_ssthresh) {
++ if (undo_ssthresh && tp->prior_ssthresh > tp->snd_ssthresh) {
+ tp->snd_ssthresh = tp->prior_ssthresh;
+ TCP_ECN_withdraw_cwr(tp);
+ }
+ } else {
+ tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);
+ }
+- tcp_moderate_cwnd(tp);
+ tp->snd_cwnd_stamp = tcp_time_stamp;
+ }
+
+@@ -2822,8 +2821,11 @@ static int tcp_try_undo_loss(struct sock *sk)
+ static inline void tcp_complete_cwr(struct sock *sk)
+ {
+ struct tcp_sock *tp = tcp_sk(sk);
+- tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
+- tp->snd_cwnd_stamp = tcp_time_stamp;
++ /* Do not moderate cwnd if it's already undone in cwr or recovery */
++ if (tp->undo_marker && tp->snd_cwnd > tp->snd_ssthresh) {
++ tp->snd_cwnd = tp->snd_ssthresh;
++ tp->snd_cwnd_stamp = tcp_time_stamp;
++ }
+ tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
+ }
+
+diff --git a/net/ipv6/sysctl_net_ipv6.c b/net/ipv6/sysctl_net_ipv6.c
+index 7cb65ef..6dcf5e7 100644
+--- a/net/ipv6/sysctl_net_ipv6.c
++++ b/net/ipv6/sysctl_net_ipv6.c
+@@ -17,6 +17,16 @@
+
+ static struct ctl_table empty[1];
+
++static ctl_table ipv6_static_skeleton[] = {
++ {
++ .procname = "neigh",
++ .maxlen = 0,
++ .mode = 0555,
++ .child = empty,
++ },
++ { }
++};
++
+ static ctl_table ipv6_table_template[] = {
+ {
+ .procname = "route",
+@@ -37,12 +47,6 @@ static ctl_table ipv6_table_template[] = {
+ .mode = 0644,
+ .proc_handler = proc_dointvec
+ },
+- {
+- .procname = "neigh",
+- .maxlen = 0,
+- .mode = 0555,
+- .child = empty,
+- },
+ { }
+ };
+
+@@ -160,7 +164,7 @@ static struct ctl_table_header *ip6_base;
+
+ int ipv6_static_sysctl_register(void)
+ {
+- ip6_base = register_sysctl_paths(net_ipv6_ctl_path, empty);
++ ip6_base = register_sysctl_paths(net_ipv6_ctl_path, ipv6_static_skeleton);
+ if (ip6_base == NULL)
+ return -ENOMEM;
+ return 0;
+diff --git a/net/l2tp/l2tp_eth.c b/net/l2tp/l2tp_eth.c
+index 8d9ce0a..a8193f5 100644
+--- a/net/l2tp/l2tp_eth.c
++++ b/net/l2tp/l2tp_eth.c
+@@ -283,7 +283,7 @@ static __net_init int l2tp_eth_init_net(struct net *net)
+ return 0;
+ }
+
+-static __net_initdata struct pernet_operations l2tp_eth_net_ops = {
++static struct pernet_operations l2tp_eth_net_ops = {
+ .init = l2tp_eth_init_net,
+ .id = &l2tp_eth_net_id,
+ .size = sizeof(struct l2tp_eth_net),
+diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
+index e58f947..dec012d 100644
+--- a/net/sctp/protocol.c
++++ b/net/sctp/protocol.c
+@@ -1204,7 +1204,7 @@ SCTP_STATIC __init int sctp_init(void)
+ if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
+ continue;
+ sctp_assoc_hashtable = (struct sctp_hashbucket *)
+- __get_free_pages(GFP_ATOMIC, order);
++ __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
+ } while (!sctp_assoc_hashtable && --order > 0);
+ if (!sctp_assoc_hashtable) {
+ pr_err("Failed association hash alloc\n");
+@@ -1237,7 +1237,7 @@ SCTP_STATIC __init int sctp_init(void)
+ if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
+ continue;
+ sctp_port_hashtable = (struct sctp_bind_hashbucket *)
+- __get_free_pages(GFP_ATOMIC, order);
++ __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
+ } while (!sctp_port_hashtable && --order > 0);
+ if (!sctp_port_hashtable) {
+ pr_err("Failed bind hash alloc\n");
+diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
+index 6459588..8da2741 100644
+--- a/net/xfrm/xfrm_policy.c
++++ b/net/xfrm/xfrm_policy.c
+@@ -1778,6 +1778,8 @@ restart:
+ goto no_transform;
+ }
+
++ dst_hold(&xdst->u.dst);
++
+ spin_lock_bh(&xfrm_policy_sk_bundle_lock);
+ xdst->u.dst.next = xfrm_policy_sk_bundles;
+ xfrm_policy_sk_bundles = &xdst->u.dst;
+diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
+index 4c0383d..58434b3 100755
+--- a/scripts/checkpatch.pl
++++ b/scripts/checkpatch.pl
+@@ -2809,9 +2809,9 @@ sub process {
+ WARN("consider using a completion\n" . $herecurr);
+
+ }
+-# recommend strict_strto* over simple_strto*
++# recommend kstrto* over simple_strto*
+ if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
+- WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);
++ WARN("consider using kstrto* in preference to simple_$1\n" . $herecurr);
+ }
+ # check for __initcall(), use device_initcall() explicitly please
+ if ($line =~ /^.\s*__initcall\s*\(/) {
+diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
+index e164a4b..da7cdca 100644
+--- a/sound/pci/hda/patch_realtek.c
++++ b/sound/pci/hda/patch_realtek.c
+@@ -9932,7 +9932,6 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = {
+ SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
+ SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
+ SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
+- SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
+
+ SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
+ SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
+@@ -10769,6 +10768,7 @@ enum {
+ PINFIX_LENOVO_Y530,
+ PINFIX_PB_M5210,
+ PINFIX_ACER_ASPIRE_7736,
++ PINFIX_GIGABYTE_880GM,
+ };
+
+ static const struct alc_fixup alc882_fixups[] = {
+@@ -10800,6 +10800,13 @@ static const struct alc_fixup alc882_fixups[] = {
+ .type = ALC_FIXUP_SKU,
+ .v.sku = ALC_FIXUP_SKU_IGNORE,
+ },
++ [PINFIX_GIGABYTE_880GM] = {
++ .type = ALC_FIXUP_PINS,
++ .v.pins = (const struct alc_pincfg[]) {
++ { 0x14, 0x1114410 }, /* set as speaker */
++ { }
++ }
++ },
+ };
+
+ static struct snd_pci_quirk alc882_fixup_tbl[] = {
+@@ -10807,6 +10814,7 @@ static struct snd_pci_quirk alc882_fixup_tbl[] = {
+ SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
+ SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
+ SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
++ SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte", PINFIX_GIGABYTE_880GM),
+ {}
+ };
+
+@@ -18851,8 +18859,6 @@ static struct snd_pci_quirk alc662_cfg_tbl[] = {
+ ALC662_3ST_6ch_DIG),
+ SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
+ SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
+- SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
+- ALC662_3ST_6ch_DIG),
+ SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
+ SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
+ SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
+@@ -19526,6 +19532,7 @@ enum {
+ ALC662_FIXUP_IDEAPAD,
+ ALC272_FIXUP_MARIO,
+ ALC662_FIXUP_CZC_P10T,
++ ALC662_FIXUP_GIGABYTE,
+ };
+
+ static const struct alc_fixup alc662_fixups[] = {
+@@ -19554,12 +19561,20 @@ static const struct alc_fixup alc662_fixups[] = {
+ {}
+ }
+ },
++ [ALC662_FIXUP_GIGABYTE] = {
++ .type = ALC_FIXUP_PINS,
++ .v.pins = (const struct alc_pincfg[]) {
++ { 0x14, 0x1114410 }, /* set as speaker */
++ { }
++ }
++ },
+ };
+
+ static struct snd_pci_quirk alc662_fixup_tbl[] = {
+ SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
+ SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
+ SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
++ SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte", ALC662_FIXUP_GIGABYTE),
+ SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
+ SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
+ SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
+diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
+index d9ab3ce..0c7454f 100644
+--- a/tools/perf/bench/sched-pipe.c
++++ b/tools/perf/bench/sched-pipe.c
+@@ -55,7 +55,7 @@ int bench_sched_pipe(int argc, const char **argv,
+ * discarding returned value of read(), write()
+ * causes error in building environment for perf
+ */
+- int ret, wait_stat;
++ int __used ret, wait_stat;
+ pid_t pid, retpid;
+
+ argc = parse_options(argc, argv, options,
+diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
+index 29acb89..ae7225c 100644
+--- a/tools/perf/builtin-sched.c
++++ b/tools/perf/builtin-sched.c
+@@ -369,11 +369,6 @@ static void
+ process_sched_event(struct task_desc *this_task __used, struct sched_atom *atom)
+ {
+ int ret = 0;
+- u64 now;
+- long long delta;
+-
+- now = get_nsecs();
+- delta = start_time + atom->timestamp - now;
+
+ switch (atom->type) {
+ case SCHED_EVENT_RUN:
+@@ -562,7 +557,7 @@ static void wait_for_tasks(void)
+
+ static void run_one_test(void)
+ {
+- u64 T0, T1, delta, avg_delta, fluct, std_dev;
++ u64 T0, T1, delta, avg_delta, fluct;
+
+ T0 = get_nsecs();
+ wait_for_tasks();
+@@ -578,7 +573,6 @@ static void run_one_test(void)
+ else
+ fluct = delta - avg_delta;
+ sum_fluct += fluct;
+- std_dev = sum_fluct / nr_runs / sqrt(nr_runs);
+ if (!run_avg)
+ run_avg = delta;
+ run_avg = (run_avg*9 + delta)/10;
+@@ -799,7 +793,7 @@ replay_switch_event(struct trace_switch_event *switch_event,
+ u64 timestamp,
+ struct thread *thread __used)
+ {
+- struct task_desc *prev, *next;
++ struct task_desc *prev, __used *next;
+ u64 timestamp0;
+ s64 delta;
+
+@@ -1404,7 +1398,7 @@ map_switch_event(struct trace_switch_event *switch_event,
+ u64 timestamp,
+ struct thread *thread __used)
+ {
+- struct thread *sched_out, *sched_in;
++ struct thread *sched_out __used, *sched_in;
+ int new_shortname;
+ u64 timestamp0;
+ s64 delta;
+diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
+index 5a29d9c..b0f6925 100644
+--- a/tools/perf/builtin-top.c
++++ b/tools/perf/builtin-top.c
+@@ -183,7 +183,6 @@ static int parse_source(struct sym_entry *syme)
+ FILE *file;
+ char command[PATH_MAX*2];
+ const char *path;
+- u64 len;
+
+ if (!syme)
+ return -1;
+@@ -212,8 +211,6 @@ static int parse_source(struct sym_entry *syme)
+ }
+ path = map->dso->long_name;
+
+- len = sym->end - sym->start;
+-
+ sprintf(command,
+ "objdump --start-address=%#0*" PRIx64 " --stop-address=%#0*" PRIx64 " -dS %s",
+ BITS_PER_LONG / 4, map__rip_2objdump(map, sym->start),
+@@ -1296,7 +1293,7 @@ static int __cmd_top(void)
+ {
+ pthread_t thread;
+ struct perf_evsel *counter;
+- int i, ret;
++ int i, ret __used;
+ /*
+ * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
+ * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
+diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
+index 0866bcd..9721e2f 100644
+--- a/tools/perf/util/header.c
++++ b/tools/perf/util/header.c
+@@ -1144,7 +1144,7 @@ int event__synthesize_tracing_data(int fd, struct list_head *pattrs,
+ {
+ event_t ev;
+ ssize_t size = 0, aligned_size = 0, padding;
+- int err = 0;
++ int err __used = 0;
+
+ memset(&ev, 0, sizeof(ev));
+
+diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
+index df51560..5214b70 100644
+--- a/tools/perf/util/hist.c
++++ b/tools/perf/util/hist.c
+@@ -1095,7 +1095,6 @@ int hist_entry__annotate(struct hist_entry *self, struct list_head *head,
+ char command[PATH_MAX * 2];
+ FILE *file;
+ int err = 0;
+- u64 len;
+ char symfs_filename[PATH_MAX];
+
+ if (filename) {
+@@ -1140,8 +1139,6 @@ fallback:
+ filename, sym->name, map->unmap_ip(map, sym->start),
+ map->unmap_ip(map, sym->end));
+
+- len = sym->end - sym->start;
+-
+ pr_debug("annotating [%p] %30s : [%p] %30s\n",
+ dso, dso->long_name, sym, sym->name);
+
+diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
+index c6d9933..2040b85 100644
+--- a/tools/perf/util/scripting-engines/trace-event-python.c
++++ b/tools/perf/util/scripting-engines/trace-event-python.c
+@@ -248,8 +248,7 @@ static void python_process_event(int cpu, void *data,
+ context = PyCObject_FromVoidPtr(scripting_context, NULL);
+
+ PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
+- PyTuple_SetItem(t, n++,
+- PyCObject_FromVoidPtr(scripting_context, NULL));
++ PyTuple_SetItem(t, n++, context);
+
+ if (handler) {
+ PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
+diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
+index b1bf490..ba6d489 100644
+--- a/tools/perf/util/symbol.c
++++ b/tools/perf/util/symbol.c
+@@ -1525,8 +1525,8 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
+ symbol_conf.symfs, self->long_name);
+ break;
+ case DSO__ORIG_GUEST_KMODULE:
+- if (map->groups && map->groups->machine)
+- root_dir = map->groups->machine->root_dir;
++ if (map->groups && machine)
++ root_dir = machine->root_dir;
+ else
+ root_dir = "";
+ snprintf(name, size, "%s%s%s", symbol_conf.symfs,
+diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
+index 73a0222..d8e622d 100644
+--- a/tools/perf/util/trace-event-parse.c
++++ b/tools/perf/util/trace-event-parse.c
+@@ -153,7 +153,7 @@ void parse_proc_kallsyms(char *file, unsigned int size __unused)
+ char *next = NULL;
+ char *addr_str;
+ char ch;
+- int ret;
++ int ret __used;
+ int i;
+
+ line = strtok_r(file, "\n", &next);
+diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/util/ui/browsers/map.c
+index e515836..8462bff 100644
+--- a/tools/perf/util/ui/browsers/map.c
++++ b/tools/perf/util/ui/browsers/map.c
+@@ -41,7 +41,7 @@ static int ui_entry__read(const char *title, char *bf, size_t size, int width)
+ out_free_form:
+ newtPopWindow();
+ newtFormDestroy(form);
+- return 0;
++ return err;
+ }
+
+ struct map_browser {
Modified: dists/sid/linux-2.6/debian/patches/series/4
==============================================================================
--- dists/sid/linux-2.6/debian/patches/series/4 Tue Apr 19 23:39:00 2011 (r17229)
+++ dists/sid/linux-2.6/debian/patches/series/4 Wed Apr 20 00:20:54 2011 (r17230)
@@ -10,3 +10,5 @@
- bugfix/all/rtc-rtc-ds1511-world-writable-sysfs-nvram-file.patch
+ bugfix/all/stable/2.6.38.3.patch
+ debian/ALSA-Restore-snd_pcm_lib_mmap_noncached.patch
+- bugfix/sparc/sparc-Fix-.size-directive-for-do_int_load.patch
++ bugfix/all/stable/2.6.38.4-rc1.patch
More information about the Kernel-svn-changes
mailing list