[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, &param);
+-}
+-
+-/*
+  * 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