[gentoo-commits] linux-patches r1828 - genpatches-2.6/trunk/2.6.36

[Mike Pagano (mpagano)]

Author: mpagano
Date: 2010-11-22 22:45:50 +0000 (Mon, 22 Nov 2010)
New Revision: 1828

Added:
   genpatches-2.6/trunk/2.6.36/1000_linux-2.6.36.1.patch
Removed:
   genpatches-2.6/trunk/2.6.36/1800_automated-per-tty-task-groups.patch
Modified:
   genpatches-2.6/trunk/2.6.36/0000_README
Log:
Removal of cgroups tty scheduler patch. Linux version 2.6.36.1

Modified: genpatches-2.6/trunk/2.6.36/0000_README
===================================================================
--- genpatches-2.6/trunk/2.6.36/0000_README	2010-11-21 00:34:02 UTC (rev 1827)
+++ genpatches-2.6/trunk/2.6.36/0000_README	2010-11-22 22:45:50 UTC (rev 1828)
@@ -39,9 +39,9 @@
 Individual Patch Descriptions:
 --------------------------------------------------------------------------
 
-Patch:  1800_automated-per-tty-task-groups.patch
-From:   http://bugs.gentoo.org/show_bug.cgi?id=346021
-Desc:   Automatically create task groups per tty, to improve desktop interactivity
+Patch:  1000_linux-2.6.36.1.patch
+From:   http://www.kernel.org
+Desc:   Linux 2.6.36.1
 
 Patch:  2700_disable-sticky-PCM-stream-assignment-for-AD-codecs.patch
 From:   http://bugs.gentoo.org/show_bug.cgi?id=344153

Added: genpatches-2.6/trunk/2.6.36/1000_linux-2.6.36.1.patch
===================================================================
--- genpatches-2.6/trunk/2.6.36/1000_linux-2.6.36.1.patch	                        (rev 0)
+++ genpatches-2.6/trunk/2.6.36/1000_linux-2.6.36.1.patch	2010-11-22 22:45:50 UTC (rev 1828)
@@ -0,0 +1,1788 @@
+diff --git a/arch/arm/include/asm/kgdb.h b/arch/arm/include/asm/kgdb.h
+index 0826599..48066ce 100644
+--- a/arch/arm/include/asm/kgdb.h
++++ b/arch/arm/include/asm/kgdb.h
+@@ -70,7 +70,8 @@ extern int kgdb_fault_expected;
+ #define _GP_REGS		16
+ #define _FP_REGS		8
+ #define _EXTRA_REGS		2
+-#define DBG_MAX_REG_NUM		(_GP_REGS + (_FP_REGS * 3) + _EXTRA_REGS)
++#define GDB_MAX_REGS		(_GP_REGS + (_FP_REGS * 3) + _EXTRA_REGS)
++#define DBG_MAX_REG_NUM		(_GP_REGS + _FP_REGS + _EXTRA_REGS)
+ 
+ #define KGDB_MAX_NO_CPUS	1
+ #define BUFMAX			400
+@@ -93,7 +94,7 @@ extern int kgdb_fault_expected;
+ #define _SPT			13
+ #define _LR			14
+ #define _PC			15
+-#define _CPSR			(DBG_MAX_REG_NUM - 1)
++#define _CPSR			(GDB_MAX_REGS - 1)
+ 
+ /*
+  * So that we can denote the end of a frame for tracing,
+diff --git a/arch/arm/kernel/kgdb.c b/arch/arm/kernel/kgdb.c
+index d6e8b4d..778c2f7 100644
+--- a/arch/arm/kernel/kgdb.c
++++ b/arch/arm/kernel/kgdb.c
+@@ -79,7 +79,7 @@ sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)
+ 		return;
+ 
+ 	/* Initialize to zero */
+-	for (regno = 0; regno < DBG_MAX_REG_NUM; regno++)
++	for (regno = 0; regno < GDB_MAX_REGS; regno++)
+ 		gdb_regs[regno] = 0;
+ 
+ 	/* Otherwise, we have only some registers from switch_to() */
+diff --git a/arch/arm/mach-cns3xxx/include/mach/debug-macro.S b/arch/arm/mach-cns3xxx/include/mach/debug-macro.S
+index d16ce7e..9b50442 100644
+--- a/arch/arm/mach-cns3xxx/include/mach/debug-macro.S
++++ b/arch/arm/mach-cns3xxx/include/mach/debug-macro.S
+@@ -10,7 +10,7 @@
+  * published by the Free Software Foundation.
+  */
+ 
+-		.macro	addruart,rx
++		.macro	addruart,rx,rtmp
+ 		mrc	p15, 0, \rx, c1, c0
+ 		tst	\rx, #1			@ MMU enabled?
+ 		moveq	\rx,      #0x10000000
+diff --git a/arch/powerpc/kernel/ppc970-pmu.c b/arch/powerpc/kernel/ppc970-pmu.c
+index 8eff48e..3fee685 100644
+--- a/arch/powerpc/kernel/ppc970-pmu.c
++++ b/arch/powerpc/kernel/ppc970-pmu.c
+@@ -169,9 +169,11 @@ static int p970_marked_instr_event(u64 event)
+ 	switch (unit) {
+ 	case PM_VPU:
+ 		mask = 0x4c;		/* byte 0 bits 2,3,6 */
++		break;
+ 	case PM_LSU0:
+ 		/* byte 2 bits 0,2,3,4,6; all of byte 1 */
+ 		mask = 0x085dff00;
++		break;
+ 	case PM_LSU1L:
+ 		mask = 0x50 << 24;	/* byte 3 bits 4,6 */
+ 		break;
+diff --git a/arch/x86/include/asm/cpufeature.h b/arch/x86/include/asm/cpufeature.h
+index 3f76523..f857bd3 100644
+--- a/arch/x86/include/asm/cpufeature.h
++++ b/arch/x86/include/asm/cpufeature.h
+@@ -152,7 +152,7 @@
+ #define X86_FEATURE_3DNOWPREFETCH (6*32+ 8) /* 3DNow prefetch instructions */
+ #define X86_FEATURE_OSVW	(6*32+ 9) /* OS Visible Workaround */
+ #define X86_FEATURE_IBS		(6*32+10) /* Instruction Based Sampling */
+-#define X86_FEATURE_SSE5	(6*32+11) /* SSE-5 */
++#define X86_FEATURE_XOP		(6*32+11) /* extended AVX instructions */
+ #define X86_FEATURE_SKINIT	(6*32+12) /* SKINIT/STGI instructions */
+ #define X86_FEATURE_WDT		(6*32+13) /* Watchdog timer */
+ #define X86_FEATURE_NODEID_MSR	(6*32+19) /* NodeId MSR */
+diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
+index 30a3e97..6a45ec4 100644
+--- a/arch/x86/include/asm/io.h
++++ b/arch/x86/include/asm/io.h
+@@ -206,6 +206,7 @@ static inline void __iomem *ioremap(resource_size_t offset, unsigned long size)
+ 
+ extern void iounmap(volatile void __iomem *addr);
+ 
++extern void set_iounmap_nonlazy(void);
+ 
+ #ifdef __KERNEL__
+ 
+diff --git a/arch/x86/include/asm/mrst.h b/arch/x86/include/asm/mrst.h
+index 1635074..33fc296 100644
+--- a/arch/x86/include/asm/mrst.h
++++ b/arch/x86/include/asm/mrst.h
+@@ -26,7 +26,7 @@ enum mrst_cpu_type {
+ };
+ 
+ extern enum mrst_cpu_type __mrst_cpu_chip;
+-static enum mrst_cpu_type mrst_identify_cpu(void)
++static inline enum mrst_cpu_type mrst_identify_cpu(void)
+ {
+ 	return __mrst_cpu_chip;
+ }
+diff --git a/arch/x86/include/asm/smp.h b/arch/x86/include/asm/smp.h
+index 4cfc908..4c2f63c 100644
+--- a/arch/x86/include/asm/smp.h
++++ b/arch/x86/include/asm/smp.h
+@@ -50,7 +50,7 @@ struct smp_ops {
+ 	void (*smp_prepare_cpus)(unsigned max_cpus);
+ 	void (*smp_cpus_done)(unsigned max_cpus);
+ 
+-	void (*smp_send_stop)(void);
++	void (*stop_other_cpus)(int wait);
+ 	void (*smp_send_reschedule)(int cpu);
+ 
+ 	int (*cpu_up)(unsigned cpu);
+@@ -73,7 +73,12 @@ extern struct smp_ops smp_ops;
+ 
+ static inline void smp_send_stop(void)
+ {
+-	smp_ops.smp_send_stop();
++	smp_ops.stop_other_cpus(0);
++}
++
++static inline void stop_other_cpus(void)
++{
++	smp_ops.stop_other_cpus(1);
+ }
+ 
+ static inline void smp_prepare_boot_cpu(void)
+diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
+index 5c5b8f3..ad1515d 100644
+--- a/arch/x86/kernel/apic/io_apic.c
++++ b/arch/x86/kernel/apic/io_apic.c
+@@ -1397,6 +1397,7 @@ int setup_ioapic_entry(int apic_id, int irq,
+ 		irte.dlvry_mode = apic->irq_delivery_mode;
+ 		irte.vector = vector;
+ 		irte.dest_id = IRTE_DEST(destination);
++		irte.redir_hint = 1;
+ 
+ 		/* Set source-id of interrupt request */
+ 		set_ioapic_sid(&irte, apic_id);
+@@ -3348,6 +3349,7 @@ static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq,
+ 		irte.dlvry_mode = apic->irq_delivery_mode;
+ 		irte.vector = cfg->vector;
+ 		irte.dest_id = IRTE_DEST(dest);
++		irte.redir_hint = 1;
+ 
+ 		/* Set source-id of interrupt request */
+ 		if (pdev)
+diff --git a/arch/x86/kernel/cpu/mtrr/cleanup.c b/arch/x86/kernel/cpu/mtrr/cleanup.c
+index c5f59d0..ac140c7 100644
+--- a/arch/x86/kernel/cpu/mtrr/cleanup.c
++++ b/arch/x86/kernel/cpu/mtrr/cleanup.c
+@@ -827,7 +827,7 @@ int __init amd_special_default_mtrr(void)
+ 
+ 	if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
+ 		return 0;
+-	if (boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x11)
++	if (boot_cpu_data.x86 < 0xf)
+ 		return 0;
+ 	/* In case some hypervisor doesn't pass SYSCFG through: */
+ 	if (rdmsr_safe(MSR_K8_SYSCFG, &l, &h) < 0)
+diff --git a/arch/x86/kernel/cpu/perf_event_amd.c b/arch/x86/kernel/cpu/perf_event_amd.c
+index c2897b7..46d5844 100644
+--- a/arch/x86/kernel/cpu/perf_event_amd.c
++++ b/arch/x86/kernel/cpu/perf_event_amd.c
+@@ -52,7 +52,7 @@ static __initconst const u64 amd_hw_cache_event_ids
+  [ C(DTLB) ] = {
+ 	[ C(OP_READ) ] = {
+ 		[ C(RESULT_ACCESS) ] = 0x0040, /* Data Cache Accesses        */
+-		[ C(RESULT_MISS)   ] = 0x0046, /* L1 DTLB and L2 DLTB Miss   */
++		[ C(RESULT_MISS)   ] = 0x0746, /* L1_DTLB_AND_L2_DLTB_MISS.ALL */
+ 	},
+ 	[ C(OP_WRITE) ] = {
+ 		[ C(RESULT_ACCESS) ] = 0,
+@@ -66,7 +66,7 @@ static __initconst const u64 amd_hw_cache_event_ids
+  [ C(ITLB) ] = {
+ 	[ C(OP_READ) ] = {
+ 		[ C(RESULT_ACCESS) ] = 0x0080, /* Instruction fecthes        */
+-		[ C(RESULT_MISS)   ] = 0x0085, /* Instr. fetch ITLB misses   */
++		[ C(RESULT_MISS)   ] = 0x0385, /* L1_ITLB_AND_L2_ITLB_MISS.ALL */
+ 	},
+ 	[ C(OP_WRITE) ] = {
+ 		[ C(RESULT_ACCESS) ] = -1,
+diff --git a/arch/x86/kernel/crash_dump_64.c b/arch/x86/kernel/crash_dump_64.c
+index 045b36c..9948288 100644
+--- a/arch/x86/kernel/crash_dump_64.c
++++ b/arch/x86/kernel/crash_dump_64.c
+@@ -34,7 +34,7 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
+ 	if (!csize)
+ 		return 0;
+ 
+-	vaddr = ioremap(pfn << PAGE_SHIFT, PAGE_SIZE);
++	vaddr = ioremap_cache(pfn << PAGE_SHIFT, PAGE_SIZE);
+ 	if (!vaddr)
+ 		return -ENOMEM;
+ 
+@@ -46,6 +46,7 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
+ 	} else
+ 		memcpy(buf, vaddr + offset, csize);
+ 
++	set_iounmap_nonlazy();
+ 	iounmap(vaddr);
+ 	return csize;
+ }
+diff --git a/arch/x86/kernel/olpc.c b/arch/x86/kernel/olpc.c
+index 0e0cdde..a2bd899 100644
+--- a/arch/x86/kernel/olpc.c
++++ b/arch/x86/kernel/olpc.c
+@@ -114,6 +114,7 @@ int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen,
+ 	unsigned long flags;
+ 	int ret = -EIO;
+ 	int i;
++	int restarts = 0;
+ 
+ 	spin_lock_irqsave(&ec_lock, flags);
+ 
+@@ -169,7 +170,9 @@ restart:
+ 			if (wait_on_obf(0x6c, 1)) {
+ 				printk(KERN_ERR "olpc-ec:  timeout waiting for"
+ 						" EC to provide data!\n");
+-				goto restart;
++				if (restarts++ < 10)
++					goto restart;
++				goto err;
+ 			}
+ 			outbuf[i] = inb(0x68);
+ 			pr_devel("olpc-ec:  received 0x%x\n", outbuf[i]);
+diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
+index e3af342..76a0d71 100644
+--- a/arch/x86/kernel/reboot.c
++++ b/arch/x86/kernel/reboot.c
+@@ -641,7 +641,7 @@ void native_machine_shutdown(void)
+ 	/* O.K Now that I'm on the appropriate processor,
+ 	 * stop all of the others.
+ 	 */
+-	smp_send_stop();
++	stop_other_cpus();
+ #endif
+ 
+ 	lapic_shutdown();
+diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
+index d801210..513deac 100644
+--- a/arch/x86/kernel/smp.c
++++ b/arch/x86/kernel/smp.c
+@@ -159,10 +159,10 @@ asmlinkage void smp_reboot_interrupt(void)
+ 	irq_exit();
+ }
+ 
+-static void native_smp_send_stop(void)
++static void native_stop_other_cpus(int wait)
+ {
+ 	unsigned long flags;
+-	unsigned long wait;
++	unsigned long timeout;
+ 
+ 	if (reboot_force)
+ 		return;
+@@ -179,9 +179,12 @@ static void native_smp_send_stop(void)
+ 	if (num_online_cpus() > 1) {
+ 		apic->send_IPI_allbutself(REBOOT_VECTOR);
+ 
+-		/* Don't wait longer than a second */
+-		wait = USEC_PER_SEC;
+-		while (num_online_cpus() > 1 && wait--)
++		/*
++		 * Don't wait longer than a second if the caller
++		 * didn't ask us to wait.
++		 */
++		timeout = USEC_PER_SEC;
++		while (num_online_cpus() > 1 && (wait || timeout--))
+ 			udelay(1);
+ 	}
+ 
+@@ -227,7 +230,7 @@ struct smp_ops smp_ops = {
+ 	.smp_prepare_cpus	= native_smp_prepare_cpus,
+ 	.smp_cpus_done		= native_smp_cpus_done,
+ 
+-	.smp_send_stop		= native_smp_send_stop,
++	.stop_other_cpus	= native_stop_other_cpus,
+ 	.smp_send_reschedule	= native_smp_send_reschedule,
+ 
+ 	.cpu_up			= native_cpu_up,
+diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
+index 60788de..9f4edeb 100644
+--- a/arch/x86/kernel/traps.c
++++ b/arch/x86/kernel/traps.c
+@@ -575,6 +575,7 @@ dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code)
+ 	if (regs->flags & X86_VM_MASK) {
+ 		handle_vm86_trap((struct kernel_vm86_regs *) regs,
+ 				error_code, 1);
++		preempt_conditional_cli(regs);
+ 		return;
+ 	}
+ 
+diff --git a/arch/x86/kernel/vm86_32.c b/arch/x86/kernel/vm86_32.c
+index 5ffb562..61fb985 100644
+--- a/arch/x86/kernel/vm86_32.c
++++ b/arch/x86/kernel/vm86_32.c
+@@ -551,8 +551,14 @@ cannot_handle:
+ int handle_vm86_trap(struct kernel_vm86_regs *regs, long error_code, int trapno)
+ {
+ 	if (VMPI.is_vm86pus) {
+-		if ((trapno == 3) || (trapno == 1))
+-			return_to_32bit(regs, VM86_TRAP + (trapno << 8));
++		if ((trapno == 3) || (trapno == 1)) {
++			KVM86->regs32->ax = VM86_TRAP + (trapno << 8);
++			/* setting this flag forces the code in entry_32.S to
++			   call save_v86_state() and change the stack pointer
++			   to KVM86->regs32 */
++			set_thread_flag(TIF_IRET);
++			return 0;
++		}
+ 		do_int(regs, trapno, (unsigned char __user *) (regs->pt.ss << 4), SP(regs));
+ 		return 0;
+ 	}
+diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c
+index 8a3f9f6..2a02a65 100644
+--- a/arch/x86/kvm/svm.c
++++ b/arch/x86/kvm/svm.c
+@@ -88,6 +88,14 @@ struct nested_state {
+ 	/* A VMEXIT is required but not yet emulated */
+ 	bool exit_required;
+ 
++	/*
++	 * If we vmexit during an instruction emulation we need this to restore
++	 * the l1 guest rip after the emulation
++	 */
++	unsigned long vmexit_rip;
++	unsigned long vmexit_rsp;
++	unsigned long vmexit_rax;
++
+ 	/* cache for intercepts of the guest */
+ 	u16 intercept_cr_read;
+ 	u16 intercept_cr_write;
+@@ -1206,8 +1214,12 @@ static void svm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
+ 		if (old == new) {
+ 			/* cr0 write with ts and mp unchanged */
+ 			svm->vmcb->control.exit_code = SVM_EXIT_CR0_SEL_WRITE;
+-			if (nested_svm_exit_handled(svm) == NESTED_EXIT_DONE)
++			if (nested_svm_exit_handled(svm) == NESTED_EXIT_DONE) {
++				svm->nested.vmexit_rip = kvm_rip_read(vcpu);
++				svm->nested.vmexit_rsp = kvm_register_read(vcpu, VCPU_REGS_RSP);
++				svm->nested.vmexit_rax = kvm_register_read(vcpu, VCPU_REGS_RAX);
+ 				return;
++			}
+ 		}
+ 	}
+ 
+@@ -2399,6 +2411,23 @@ static int emulate_on_interception(struct vcpu_svm *svm)
+ 	return emulate_instruction(&svm->vcpu, 0, 0, 0) == EMULATE_DONE;
+ }
+ 
++static int cr0_write_interception(struct vcpu_svm *svm)
++{
++	struct kvm_vcpu *vcpu = &svm->vcpu;
++	int r;
++
++	r = emulate_instruction(&svm->vcpu, 0, 0, 0);
++
++	if (svm->nested.vmexit_rip) {
++		kvm_register_write(vcpu, VCPU_REGS_RIP, svm->nested.vmexit_rip);
++		kvm_register_write(vcpu, VCPU_REGS_RSP, svm->nested.vmexit_rsp);
++		kvm_register_write(vcpu, VCPU_REGS_RAX, svm->nested.vmexit_rax);
++		svm->nested.vmexit_rip = 0;
++	}
++
++	return r == EMULATE_DONE;
++}
++
+ static int cr8_write_interception(struct vcpu_svm *svm)
+ {
+ 	struct kvm_run *kvm_run = svm->vcpu.run;
+@@ -2672,7 +2701,7 @@ static int (*svm_exit_handlers[])(struct vcpu_svm *svm) = {
+ 	[SVM_EXIT_READ_CR4]			= emulate_on_interception,
+ 	[SVM_EXIT_READ_CR8]			= emulate_on_interception,
+ 	[SVM_EXIT_CR0_SEL_WRITE]		= emulate_on_interception,
+-	[SVM_EXIT_WRITE_CR0]			= emulate_on_interception,
++	[SVM_EXIT_WRITE_CR0]			= cr0_write_interception,
+ 	[SVM_EXIT_WRITE_CR3]			= emulate_on_interception,
+ 	[SVM_EXIT_WRITE_CR4]			= emulate_on_interception,
+ 	[SVM_EXIT_WRITE_CR8]			= cr8_write_interception,
+@@ -3354,6 +3383,10 @@ static void svm_cpuid_update(struct kvm_vcpu *vcpu)
+ static void svm_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 *entry)
+ {
+ 	switch (func) {
++	case 0x80000001:
++		if (nested)
++			entry->ecx |= (1 << 2); /* Set SVM bit */
++		break;
+ 	case 0x8000000A:
+ 		entry->eax = 1; /* SVM revision 1 */
+ 		entry->ebx = 8; /* Lets support 8 ASIDs in case we add proper
+diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
+index 3a09c62..a4a427b 100644
+--- a/arch/x86/kvm/x86.c
++++ b/arch/x86/kvm/x86.c
+@@ -1994,9 +1994,9 @@ static void do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function,
+ 		0 /* Reserved, AES */ | F(XSAVE) | 0 /* OSXSAVE */ | F(AVX);
+ 	/* cpuid 0x80000001.ecx */
+ 	const u32 kvm_supported_word6_x86_features =
+-		F(LAHF_LM) | F(CMP_LEGACY) | F(SVM) | 0 /* ExtApicSpace */ |
++		F(LAHF_LM) | F(CMP_LEGACY) | 0 /*SVM*/ | 0 /* ExtApicSpace */ |
+ 		F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) |
+-		F(3DNOWPREFETCH) | 0 /* OSVW */ | 0 /* IBS */ | F(SSE5) |
++		F(3DNOWPREFETCH) | 0 /* OSVW */ | 0 /* IBS */ | F(XOP) |
+ 		0 /* SKINIT */ | 0 /* WDT */;
+ 
+ 	/* all calls to cpuid_count() should be made on the same cpu */
+diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
+index 7d46c84..44f8086 100644
+--- a/arch/x86/xen/enlighten.c
++++ b/arch/x86/xen/enlighten.c
+@@ -1018,7 +1018,7 @@ static void xen_reboot(int reason)
+ 	struct sched_shutdown r = { .reason = reason };
+ 
+ #ifdef CONFIG_SMP
+-	smp_send_stop();
++	stop_other_cpus();
+ #endif
+ 
+ 	if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
+diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
+index 25f232b..f4d0100 100644
+--- a/arch/x86/xen/smp.c
++++ b/arch/x86/xen/smp.c
+@@ -400,9 +400,9 @@ static void stop_self(void *v)
+ 	BUG();
+ }
+ 
+-static void xen_smp_send_stop(void)
++static void xen_stop_other_cpus(int wait)
+ {
+-	smp_call_function(stop_self, NULL, 0);
++	smp_call_function(stop_self, NULL, wait);
+ }
+ 
+ static void xen_smp_send_reschedule(int cpu)
+@@ -470,7 +470,7 @@ static const struct smp_ops xen_smp_ops __initdata = {
+ 	.cpu_disable = xen_cpu_disable,
+ 	.play_dead = xen_play_dead,
+ 
+-	.smp_send_stop = xen_smp_send_stop,
++	.stop_other_cpus = xen_stop_other_cpus,
+ 	.smp_send_reschedule = xen_smp_send_reschedule,
+ 
+ 	.send_call_func_ipi = xen_smp_send_call_function_ipi,
+diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h
+index e5fdeeb..d1a0f5b 100644
+--- a/drivers/ata/ahci.h
++++ b/drivers/ata/ahci.h
+@@ -72,6 +72,7 @@ enum {
+ 	AHCI_CMD_RESET		= (1 << 8),
+ 	AHCI_CMD_CLR_BUSY	= (1 << 10),
+ 
++	RX_FIS_PIO_SETUP	= 0x20,	/* offset of PIO Setup FIS data */
+ 	RX_FIS_D2H_REG		= 0x40,	/* offset of D2H Register FIS data */
+ 	RX_FIS_SDB		= 0x58, /* offset of SDB FIS data */
+ 	RX_FIS_UNK		= 0x60, /* offset of Unknown FIS data */
+diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
+index 8eea309..137514d 100644
+--- a/drivers/ata/libahci.c
++++ b/drivers/ata/libahci.c
+@@ -1830,12 +1830,24 @@ static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
+ static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
+ {
+ 	struct ahci_port_priv *pp = qc->ap->private_data;
+-	u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
++	u8 *rx_fis = pp->rx_fis;
+ 
+ 	if (pp->fbs_enabled)
+-		d2h_fis += qc->dev->link->pmp * AHCI_RX_FIS_SZ;
++		rx_fis += qc->dev->link->pmp * AHCI_RX_FIS_SZ;
++
++	/*
++	 * After a successful execution of an ATA PIO data-in command,
++	 * the device doesn't send D2H Reg FIS to update the TF and
++	 * the host should take TF and E_Status from the preceding PIO
++	 * Setup FIS.
++	 */
++	if (qc->tf.protocol == ATA_PROT_PIO && qc->dma_dir == DMA_FROM_DEVICE &&
++	    !(qc->flags & ATA_QCFLAG_FAILED)) {
++		ata_tf_from_fis(rx_fis + RX_FIS_PIO_SETUP, &qc->result_tf);
++		qc->result_tf.command = (rx_fis + RX_FIS_PIO_SETUP)[15];
++	} else
++		ata_tf_from_fis(rx_fis + RX_FIS_D2H_REG, &qc->result_tf);
+ 
+-	ata_tf_from_fis(d2h_fis, &qc->result_tf);
+ 	return true;
+ }
+ 
+diff --git a/drivers/bluetooth/hci_ldisc.c b/drivers/bluetooth/hci_ldisc.c
+index 998833d..17361ba 100644
+--- a/drivers/bluetooth/hci_ldisc.c
++++ b/drivers/bluetooth/hci_ldisc.c
+@@ -256,9 +256,16 @@ static int hci_uart_tty_open(struct tty_struct *tty)
+ 
+ 	BT_DBG("tty %p", tty);
+ 
++	/* FIXME: This btw is bogus, nothing requires the old ldisc to clear
++	   the pointer */
+ 	if (hu)
+ 		return -EEXIST;
+ 
++	/* Error if the tty has no write op instead of leaving an exploitable
++	   hole */
++	if (tty->ops->write == NULL)
++		return -EOPNOTSUPP;
++
+ 	if (!(hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
+ 		BT_ERR("Can't allocate control structure");
+ 		return -ENFILE;
+diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
+index 9ecd6be..45f9fad 100644
+--- a/drivers/char/pcmcia/synclink_cs.c
++++ b/drivers/char/pcmcia/synclink_cs.c
+@@ -4127,6 +4127,8 @@ static int hdlcdev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+ 	if (cmd != SIOCWANDEV)
+ 		return hdlc_ioctl(dev, ifr, cmd);
+ 
++	memset(&new_line, 0, size);
++
+ 	switch(ifr->ifr_settings.type) {
+ 	case IF_GET_IFACE: /* return current sync_serial_settings */
+ 
+diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
+index c37ef64..cf88588 100644
+--- a/drivers/idle/intel_idle.c
++++ b/drivers/idle/intel_idle.c
+@@ -276,7 +276,7 @@ static int intel_idle_probe(void)
+ 
+ 	case 0x1C:	/* 28 - Atom Processor */
+ 	case 0x26:	/* 38 - Lincroft Atom Processor */
+-		lapic_timer_reliable_states = (1 << 2) | (1 << 1); /* C2, C1 */
++		lapic_timer_reliable_states = (1 << 1); /* C1 */
+ 		cpuidle_state_table = atom_cstates;
+ 		break;
+ #ifdef FUTURE_USE
+diff --git a/drivers/misc/sgi-xp/xpc_uv.c b/drivers/misc/sgi-xp/xpc_uv.c
+index 1f59ee2..17bbacb 100644
+--- a/drivers/misc/sgi-xp/xpc_uv.c
++++ b/drivers/misc/sgi-xp/xpc_uv.c
+@@ -417,6 +417,7 @@ xpc_process_activate_IRQ_rcvd_uv(void)
+ static void
+ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 			      struct xpc_activate_mq_msghdr_uv *msg_hdr,
++			      int part_setup,
+ 			      int *wakeup_hb_checker)
+ {
+ 	unsigned long irq_flags;
+@@ -481,6 +482,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 	case XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREQUEST_UV: {
+ 		struct xpc_activate_mq_msg_chctl_closerequest_uv *msg;
+ 
++		if (!part_setup)
++			break;
++
+ 		msg = container_of(msg_hdr, struct
+ 				   xpc_activate_mq_msg_chctl_closerequest_uv,
+ 				   hdr);
+@@ -497,6 +501,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 	case XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREPLY_UV: {
+ 		struct xpc_activate_mq_msg_chctl_closereply_uv *msg;
+ 
++		if (!part_setup)
++			break;
++
+ 		msg = container_of(msg_hdr, struct
+ 				   xpc_activate_mq_msg_chctl_closereply_uv,
+ 				   hdr);
+@@ -511,6 +518,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 	case XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREQUEST_UV: {
+ 		struct xpc_activate_mq_msg_chctl_openrequest_uv *msg;
+ 
++		if (!part_setup)
++			break;
++
+ 		msg = container_of(msg_hdr, struct
+ 				   xpc_activate_mq_msg_chctl_openrequest_uv,
+ 				   hdr);
+@@ -528,6 +538,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 	case XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREPLY_UV: {
+ 		struct xpc_activate_mq_msg_chctl_openreply_uv *msg;
+ 
++		if (!part_setup)
++			break;
++
+ 		msg = container_of(msg_hdr, struct
+ 				   xpc_activate_mq_msg_chctl_openreply_uv, hdr);
+ 		args = &part->remote_openclose_args[msg->ch_number];
+@@ -545,6 +558,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
+ 	case XPC_ACTIVATE_MQ_MSG_CHCTL_OPENCOMPLETE_UV: {
+ 		struct xpc_activate_mq_msg_chctl_opencomplete_uv *msg;
+ 
++		if (!part_setup)
++			break;
++
+ 		msg = container_of(msg_hdr, struct
+ 				xpc_activate_mq_msg_chctl_opencomplete_uv, hdr);
+ 		spin_lock_irqsave(&part->chctl_lock, irq_flags);
+@@ -621,6 +637,7 @@ xpc_handle_activate_IRQ_uv(int irq, void *dev_id)
+ 
+ 			part_referenced = xpc_part_ref(part);
+ 			xpc_handle_activate_mq_msg_uv(part, msg_hdr,
++						      part_referenced,
+ 						      &wakeup_hb_checker);
+ 			if (part_referenced)
+ 				xpc_part_deref(part);
+diff --git a/drivers/net/wireless/p54/eeprom.c b/drivers/net/wireless/p54/eeprom.c
+index 78347041..0a7ce37 100644
+--- a/drivers/net/wireless/p54/eeprom.c
++++ b/drivers/net/wireless/p54/eeprom.c
+@@ -260,8 +260,10 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
+ 	list->max_entries = max_channel_num;
+ 	list->channels = kzalloc(sizeof(struct p54_channel_entry) *
+ 				 max_channel_num, GFP_KERNEL);
+-	if (!list->channels)
++	if (!list->channels) {
++		ret = -ENOMEM;
+ 		goto free;
++	}
+ 
+ 	for (i = 0; i < max_channel_num; i++) {
+ 		if (i < priv->iq_autocal_len) {
+diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
+index ad59595..d5bc21e 100644
+--- a/drivers/net/wireless/p54/p54usb.c
++++ b/drivers/net/wireless/p54/p54usb.c
+@@ -33,8 +33,17 @@ MODULE_ALIAS("prism54usb");
+ MODULE_FIRMWARE("isl3886usb");
+ MODULE_FIRMWARE("isl3887usb");
+ 
++/*
++ * Note:
++ *
++ * Always update our wiki's device list (located at:
++ * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
++ * whenever you add a new device.
++ */
++
+ static struct usb_device_id p54u_table[] __devinitdata = {
+ 	/* Version 1 devices (pci chip + net2280) */
++	{USB_DEVICE(0x045e, 0x00c2)},	/* Microsoft MN-710 */
+ 	{USB_DEVICE(0x0506, 0x0a11)},	/* 3COM 3CRWE254G72 */
+ 	{USB_DEVICE(0x06b9, 0x0120)},	/* Thomson SpeedTouch 120g */
+ 	{USB_DEVICE(0x0707, 0xee06)},	/* SMC 2862W-G */
+@@ -47,7 +56,9 @@ static struct usb_device_id p54u_table[] __devinitdata = {
+ 	{USB_DEVICE(0x0846, 0x4220)},	/* Netgear WG111 */
+ 	{USB_DEVICE(0x09aa, 0x1000)},	/* Spinnaker Proto board */
+ 	{USB_DEVICE(0x0cde, 0x0006)},	/* Medion 40900, Roper Europe */
++	{USB_DEVICE(0x107b, 0x55f2)},	/* Gateway WGU-210 (Gemtek) */
+ 	{USB_DEVICE(0x124a, 0x4023)},	/* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
++	{USB_DEVICE(0x1630, 0x0005)},	/* 2Wire 802.11g USB (v1) / Z-Com */
+ 	{USB_DEVICE(0x1915, 0x2234)},	/* Linksys WUSB54G OEM */
+ 	{USB_DEVICE(0x1915, 0x2235)},	/* Linksys WUSB54G Portable OEM */
+ 	{USB_DEVICE(0x2001, 0x3701)},	/* DLink DWL-G120 Spinnaker */
+@@ -60,6 +71,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
+ 	{USB_DEVICE(0x050d, 0x7050)},	/* Belkin F5D7050 ver 1000 */
+ 	{USB_DEVICE(0x0572, 0x2000)},	/* Cohiba Proto board */
+ 	{USB_DEVICE(0x0572, 0x2002)},	/* Cohiba Proto board */
++	{USB_DEVICE(0x06a9, 0x000e)},	/* Westell 802.11g USB (A90-211WG-01) */
+ 	{USB_DEVICE(0x06b9, 0x0121)},	/* Thomson SpeedTouch 121g */
+ 	{USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
+ 	{USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
+@@ -80,6 +92,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
+ 	{USB_DEVICE(0x13B1, 0x000C)},	/* Linksys WUSB54AG */
+ 	{USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
+ 	{USB_DEVICE(0x1435, 0x0427)},	/* Inventel UR054G */
++	{USB_DEVICE(0x1668, 0x1050)},	/* Actiontec 802UIG-1 */
+ 	{USB_DEVICE(0x2001, 0x3704)},	/* DLink DWL-G122 rev A2 */
+ 	{USB_DEVICE(0x413c, 0x5513)},	/* Dell WLA3310 USB Wireless Adapter */
+ 	{USB_DEVICE(0x413c, 0x8102)},	/* Spinnaker DUT */
+@@ -930,8 +943,8 @@ static int __devinit p54u_probe(struct usb_interface *intf,
+ #ifdef CONFIG_PM
+ 		/* ISL3887 needs a full reset on resume */
+ 		udev->reset_resume = 1;
++#endif /* CONFIG_PM */
+ 		err = p54u_device_reset(dev);
+-#endif
+ 
+ 		priv->hw_type = P54U_3887;
+ 		dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
+diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
+index b756e07..e8acb1c 100644
+--- a/drivers/platform/x86/asus-laptop.c
++++ b/drivers/platform/x86/asus-laptop.c
+@@ -1065,9 +1065,9 @@ static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
+  */
+ static int asus_gps_rfkill_set(void *data, bool blocked)
+ {
+-	acpi_handle handle = data;
++	struct asus_laptop *asus = data;
+ 
+-	return asus_gps_switch(handle, !blocked);
++	return asus_gps_switch(asus, !blocked);
+ }
+ 
+ static const struct rfkill_ops asus_gps_rfkill_ops = {
+@@ -1094,7 +1094,7 @@ static int asus_rfkill_init(struct asus_laptop *asus)
+ 
+ 	asus->gps_rfkill = rfkill_alloc("asus-gps", &asus->platform_device->dev,
+ 					RFKILL_TYPE_GPS,
+-					&asus_gps_rfkill_ops, NULL);
++					&asus_gps_rfkill_ops, asus);
+ 	if (!asus->gps_rfkill)
+ 		return -EINVAL;
+ 
+diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
+index b860d65..4cf7ffa 100644
+--- a/drivers/scsi/gdth.c
++++ b/drivers/scsi/gdth.c
+@@ -4175,6 +4175,14 @@ static int ioc_general(void __user *arg, char *cmnd)
+     ha = gdth_find_ha(gen.ionode);
+     if (!ha)
+         return -EFAULT;
++
++    if (gen.data_len > INT_MAX)
++        return -EINVAL;
++    if (gen.sense_len > INT_MAX)
++        return -EINVAL;
++    if (gen.data_len + gen.sense_len > INT_MAX)
++        return -EINVAL;
++
+     if (gen.data_len + gen.sense_len != 0) {
+         if (!(buf = gdth_ioctl_alloc(ha, gen.data_len + gen.sense_len,
+                                      FALSE, &paddr)))
+diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
+index 042153c..ddbade7 100644
+--- a/drivers/scsi/libsas/sas_ata.c
++++ b/drivers/scsi/libsas/sas_ata.c
+@@ -347,6 +347,7 @@ static int sas_ata_scr_read(struct ata_link *link, unsigned int sc_reg_in,
+ static struct ata_port_operations sas_sata_ops = {
+ 	.phy_reset		= sas_ata_phy_reset,
+ 	.post_internal_cmd	= sas_ata_post_internal,
++	.qc_defer               = ata_std_qc_defer,
+ 	.qc_prep		= ata_noop_qc_prep,
+ 	.qc_issue		= sas_ata_qc_issue,
+ 	.qc_fill_rtf		= sas_ata_qc_fill_rtf,
+diff --git a/drivers/scsi/pmcraid.h b/drivers/scsi/pmcraid.h
+index 6cfa014..dd78f9e 100644
+--- a/drivers/scsi/pmcraid.h
++++ b/drivers/scsi/pmcraid.h
+@@ -568,7 +568,6 @@ struct pmcraid_cmd {
+ 	struct pmcraid_control_block *ioa_cb;
+ 	dma_addr_t ioa_cb_bus_addr;
+ 	dma_addr_t dma_handle;
+-	u8 *sense_buffer;
+ 
+ 	/* pointer to mid layer structure of SCSI commands */
+ 	struct scsi_cmnd *scsi_cmd;
+diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
+index 5d4a382..449256f 100644
+--- a/drivers/scsi/qla4xxx/ql4_nx.c
++++ b/drivers/scsi/qla4xxx/ql4_nx.c
+@@ -5,6 +5,7 @@
+  * See LICENSE.qla4xxx for copyright and licensing details.
+  */
+ #include <linux/delay.h>
++#include <linux/io.h>
+ #include <linux/pci.h>
+ #include "ql4_def.h"
+ #include "ql4_glbl.h"
+diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
+index ee02d38..71c4cf7 100644
+--- a/drivers/scsi/scsi_lib.c
++++ b/drivers/scsi/scsi_lib.c
+@@ -2428,7 +2428,8 @@ scsi_internal_device_unblock(struct scsi_device *sdev)
+ 		sdev->sdev_state = SDEV_RUNNING;
+ 	else if (sdev->sdev_state == SDEV_CREATED_BLOCK)
+ 		sdev->sdev_state = SDEV_CREATED;
+-	else
++	else if (sdev->sdev_state != SDEV_CANCEL &&
++		 sdev->sdev_state != SDEV_OFFLINE)
+ 		return -EINVAL;
+ 
+ 	spin_lock_irqsave(q->queue_lock, flags);
+diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
+index c3f6737..7a0ca6f 100644
+--- a/drivers/scsi/scsi_sysfs.c
++++ b/drivers/scsi/scsi_sysfs.c
+@@ -962,10 +962,11 @@ static void __scsi_remove_target(struct scsi_target *starget)
+ 	list_for_each_entry(sdev, &shost->__devices, siblings) {
+ 		if (sdev->channel != starget->channel ||
+ 		    sdev->id != starget->id ||
+-		    sdev->sdev_state == SDEV_DEL)
++		    scsi_device_get(sdev))
+ 			continue;
+ 		spin_unlock_irqrestore(shost->host_lock, flags);
+ 		scsi_remove_device(sdev);
++		scsi_device_put(sdev);
+ 		spin_lock_irqsave(shost->host_lock, flags);
+ 		goto restart;
+ 	}
+diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
+index ffa0689..0eb0af5 100644
+--- a/drivers/scsi/sd.c
++++ b/drivers/scsi/sd.c
+@@ -2252,11 +2252,10 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
+ 	index = sdkp->index;
+ 	dev = &sdp->sdev_gendev;
+ 
+-	if (index < SD_MAX_DISKS) {
+-		gd->major = sd_major((index & 0xf0) >> 4);
+-		gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
+-		gd->minors = SD_MINORS;
+-	}
++	gd->major = sd_major((index & 0xf0) >> 4);
++	gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
++	gd->minors = SD_MINORS;
++
+ 	gd->fops = &sd_fops;
+ 	gd->private_data = &sdkp->driver;
+ 	gd->queue = sdkp->device->request_queue;
+@@ -2346,6 +2345,12 @@ static int sd_probe(struct device *dev)
+ 	if (error)
+ 		goto out_put;
+ 
++	if (index >= SD_MAX_DISKS) {
++		error = -ENODEV;
++		sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name space exhausted.\n");
++		goto out_free_index;
++	}
++
+ 	error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
+ 	if (error)
+ 		goto out_free_index;
+diff --git a/drivers/staging/phison/phison.c b/drivers/staging/phison/phison.c
+index 42783d7..6771520 100644
+--- a/drivers/staging/phison/phison.c
++++ b/drivers/staging/phison/phison.c
+@@ -62,7 +62,7 @@ static int phison_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+ 	};
+ 	const struct ata_port_info *ppi[] = { &info, NULL };
+ 
+-	ret = ata_pci_sff_init_one(pdev, ppi, &phison_sht, NULL, 0);
++	ret = ata_pci_bmdma_init_one(pdev, ppi, &phison_sht, NULL, 0);
+ 
+ 	dev_dbg(&pdev->dev, "phison_init_one(), ret = %x\n", ret);
+ 
+diff --git a/drivers/staging/usbip/usbip_event.c b/drivers/staging/usbip/usbip_event.c
+index a2566f1..af3832b 100644
+--- a/drivers/staging/usbip/usbip_event.c
++++ b/drivers/staging/usbip/usbip_event.c
+@@ -38,21 +38,13 @@ static int event_handler(struct usbip_device *ud)
+ 			ud->eh_ops.shutdown(ud);
+ 
+ 			ud->event &= ~USBIP_EH_SHUTDOWN;
+-
+-			break;
+ 		}
+ 
+-		/* Stop the error handler. */
+-		if (ud->event & USBIP_EH_BYE)
+-			return -1;
+-
+ 		/* Reset the device. */
+ 		if (ud->event & USBIP_EH_RESET) {
+ 			ud->eh_ops.reset(ud);
+ 
+ 			ud->event &= ~USBIP_EH_RESET;
+-
+-			break;
+ 		}
+ 
+ 		/* Mark the device as unusable. */
+@@ -60,13 +52,11 @@ static int event_handler(struct usbip_device *ud)
+ 			ud->eh_ops.unusable(ud);
+ 
+ 			ud->event &= ~USBIP_EH_UNUSABLE;
+-
+-			break;
+ 		}
+ 
+-		/* NOTREACHED */
+-		printk(KERN_ERR "%s: unknown event\n", __func__);
+-		return -1;
++		/* Stop the error handler. */
++		if (ud->event & USBIP_EH_BYE)
++			return -1;
+ 	}
+ 
+ 	return 0;
+diff --git a/drivers/staging/usbip/vhci_hcd.c b/drivers/staging/usbip/vhci_hcd.c
+index 0574d84..832608d 100644
+--- a/drivers/staging/usbip/vhci_hcd.c
++++ b/drivers/staging/usbip/vhci_hcd.c
+@@ -164,6 +164,8 @@ void rh_port_disconnect(int rhport)
+ 	 * spin_unlock(&vdev->ud.lock); */
+ 
+ 	spin_unlock_irqrestore(&the_controller->lock, flags);
++
++	usb_hcd_poll_rh_status(vhci_to_hcd(the_controller));
+ }
+ 
+ 
+diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
+index 84c18971..566c183 100644
+--- a/drivers/usb/core/hub.c
++++ b/drivers/usb/core/hub.c
+@@ -2860,13 +2860,16 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
+ 	else
+ 		i = udev->descriptor.bMaxPacketSize0;
+ 	if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {
+-		if (udev->speed != USB_SPEED_FULL ||
++		if (udev->speed == USB_SPEED_LOW ||
+ 				!(i == 8 || i == 16 || i == 32 || i == 64)) {
+-			dev_err(&udev->dev, "ep0 maxpacket = %d\n", i);
++			dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
+ 			retval = -EMSGSIZE;
+ 			goto fail;
+ 		}
+-		dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
++		if (udev->speed == USB_SPEED_FULL)
++			dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
++		else
++			dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
+ 		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
+ 		usb_ep0_reinit(udev);
+ 	}
+diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
+index 9f0ce7d..d6e3e41 100644
+--- a/drivers/usb/core/message.c
++++ b/drivers/usb/core/message.c
+@@ -1140,13 +1140,6 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
+ {
+ 	int i;
+ 
+-	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
+-		skip_ep0 ? "non-ep0" : "all");
+-	for (i = skip_ep0; i < 16; ++i) {
+-		usb_disable_endpoint(dev, i, true);
+-		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
+-	}
+-
+ 	/* getting rid of interfaces will disconnect
+ 	 * any drivers bound to them (a key side effect)
+ 	 */
+@@ -1176,6 +1169,13 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
+ 		if (dev->state == USB_STATE_CONFIGURED)
+ 			usb_set_device_state(dev, USB_STATE_ADDRESS);
+ 	}
++
++	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
++		skip_ep0 ? "non-ep0" : "all");
++	for (i = skip_ep0; i < 16; ++i) {
++		usb_disable_endpoint(dev, i, true);
++		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
++	}
+ }
+ 
+ /**
+diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
+index d623c7b..959f062 100644
+--- a/drivers/usb/gadget/atmel_usba_udc.c
++++ b/drivers/usb/gadget/atmel_usba_udc.c
+@@ -2014,6 +2014,9 @@ static int __init usba_udc_probe(struct platform_device *pdev)
+ 			} else {
+ 				disable_irq(gpio_to_irq(udc->vbus_pin));
+ 			}
++		} else {
++			/* gpio_request fail so use -EINVAL for gpio_is_valid */
++			ubc->vbus_pin = -EINVAL;
+ 		}
+ 	}
+ 
+diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
+index 1160c55..9a98c38 100644
+--- a/drivers/usb/gadget/composite.c
++++ b/drivers/usb/gadget/composite.c
+@@ -901,7 +901,8 @@ unknown:
+ 		 */
+ 		switch (ctrl->bRequestType & USB_RECIP_MASK) {
+ 		case USB_RECIP_INTERFACE:
+-			f = cdev->config->interface[intf];
++			if (cdev->config)
++				f = cdev->config->interface[intf];
+ 			break;
+ 
+ 		case USB_RECIP_ENDPOINT:
+diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
+index d47a123..bd6226c 100644
+--- a/drivers/usb/gadget/f_acm.c
++++ b/drivers/usb/gadget/f_acm.c
+@@ -111,7 +111,7 @@ acm_iad_descriptor = {
+ 	.bInterfaceCount = 	2,	// control + data
+ 	.bFunctionClass =	USB_CLASS_COMM,
+ 	.bFunctionSubClass =	USB_CDC_SUBCLASS_ACM,
+-	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
++	.bFunctionProtocol =	USB_CDC_ACM_PROTO_AT_V25TER,
+ 	/* .iFunction =		DYNAMIC */
+ };
+ 
+diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
+index a9474f8..3c2f0a4 100644
+--- a/drivers/usb/gadget/g_ffs.c
++++ b/drivers/usb/gadget/g_ffs.c
+@@ -53,8 +53,8 @@ MODULE_AUTHOR("Michal Nazarewicz");
+ MODULE_LICENSE("GPL");
+ 
+ 
+-static unsigned short gfs_vendor_id    = 0x0525;	/* XXX NetChip */
+-static unsigned short gfs_product_id   = 0xa4ac;	/* XXX */
++static unsigned short gfs_vendor_id    = 0x1d6b;	/* Linux Foundation */
++static unsigned short gfs_product_id   = 0x0105;	/* FunctionFS Gadget */
+ 
+ static struct usb_device_descriptor gfs_dev_desc = {
+ 	.bLength		= sizeof gfs_dev_desc,
+diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
+index 795d762..36d67a3 100644
+--- a/drivers/usb/gadget/multi.c
++++ b/drivers/usb/gadget/multi.c
+@@ -74,8 +74,8 @@ MODULE_LICENSE("GPL");
+ 
+ /***************************** Device Descriptor ****************************/
+ 
+-#define MULTI_VENDOR_NUM	0x0525	/* XXX NetChip */
+-#define MULTI_PRODUCT_NUM	0xa4ab	/* XXX */
++#define MULTI_VENDOR_NUM	0x1d6b	/* Linux Foundation */
++#define MULTI_PRODUCT_NUM	0x0104	/* Multifunction Composite Gadget */
+ 
+ 
+ enum {
+diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
+index 95d0f5a..25563e9 100644
+--- a/drivers/usb/host/r8a66597.h
++++ b/drivers/usb/host/r8a66597.h
+@@ -227,7 +227,7 @@ static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
+ 		int odd = len & 0x0001;
+ 
+ 		len = len / 2;
+-		ioread16_rep(fifoaddr, buf, len);
++		iowrite16_rep(fifoaddr, buf, len);
+ 		if (unlikely(odd)) {
+ 			buf = &buf[len];
+ 			iowrite8((unsigned char)*buf, fifoaddr);
+diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
+index b611420..611a9d2 100644
+--- a/drivers/usb/musb/blackfin.c
++++ b/drivers/usb/musb/blackfin.c
+@@ -342,8 +342,10 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
+ 
+ 	usb_nop_xceiv_register();
+ 	musb->xceiv = otg_get_transceiver();
+-	if (!musb->xceiv)
++	if (!musb->xceiv) {
++		gpio_free(musb->config->gpio_vrsel);
+ 		return -ENODEV;
++	}
+ 
+ 	if (ANOMALY_05000346) {
+ 		bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
+@@ -394,8 +396,9 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
+ 
+ int musb_platform_exit(struct musb *musb)
+ {
+-
+ 	gpio_free(musb->config->gpio_vrsel);
+ 
++	otg_put_transceiver(musb->xceiv);
++	usb_nop_xceiv_unregister();
+ 	return 0;
+ }
+diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
+index 5762436..6e67629 100644
+--- a/drivers/usb/musb/davinci.c
++++ b/drivers/usb/musb/davinci.c
+@@ -446,6 +446,7 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
+ fail:
+ 	clk_disable(musb->clock);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 	return -ENODEV;
+ }
+@@ -496,6 +497,7 @@ int musb_platform_exit(struct musb *musb)
+ 
+ 	clk_disable(musb->clock);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 
+ 	return 0;
+diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
+index 540c766..513d6bd 100644
+--- a/drivers/usb/musb/musb_core.c
++++ b/drivers/usb/musb/musb_core.c
+@@ -1921,10 +1921,6 @@ static void musb_free(struct musb *musb)
+ 		dma_controller_destroy(c);
+ 	}
+ 
+-#ifdef CONFIG_USB_MUSB_OTG
+-	put_device(musb->xceiv->dev);
+-#endif
+-
+ #ifdef CONFIG_USB_MUSB_HDRC_HCD
+ 	usb_put_hcd(musb_to_hcd(musb));
+ #else
+diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
+index 2111a24..ed618bd 100644
+--- a/drivers/usb/musb/omap2430.c
++++ b/drivers/usb/musb/omap2430.c
+@@ -320,5 +320,6 @@ int musb_platform_exit(struct musb *musb)
+ 
+ 	musb_platform_suspend(musb);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	return 0;
+ }
+diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
+index 3c48e77..bde40ef 100644
+--- a/drivers/usb/musb/tusb6010.c
++++ b/drivers/usb/musb/tusb6010.c
+@@ -1152,6 +1152,8 @@ done:
+ 	if (ret < 0) {
+ 		if (sync)
+ 			iounmap(sync);
++
++		otg_put_transceiver(musb->xceiv);
+ 		usb_nop_xceiv_unregister();
+ 	}
+ 	return ret;
+@@ -1166,6 +1168,8 @@ int musb_platform_exit(struct musb *musb)
+ 		musb->board_set_power(0);
+ 
+ 	iounmap(musb->sync_va);
++
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 	return 0;
+ }
+diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
+index 4f1744c..8d7731d 100644
+--- a/drivers/usb/serial/cp210x.c
++++ b/drivers/usb/serial/cp210x.c
+@@ -54,6 +54,7 @@ static int cp210x_carrier_raised(struct usb_serial_port *p);
+ static int debug;
+ 
+ static const struct usb_device_id id_table[] = {
++	{ USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
+ 	{ USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
+ 	{ USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+ 	{ USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+@@ -132,6 +133,7 @@ static const struct usb_device_id id_table[] = {
+ 	{ USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
+ 	{ USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
+ 	{ USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
++	{ USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
+ 	{ USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
+ 	{ } /* Terminating Entry */
+ };
+diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
+index 97cc87d..01ba740 100644
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -177,6 +177,7 @@ static struct usb_device_id id_table_combined [] = {
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
++	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
+ 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
+ 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
+@@ -674,7 +675,6 @@ static struct usb_device_id id_table_combined [] = {
+ 	{ USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
+ 	{ USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
+-	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
+@@ -715,8 +715,37 @@ static struct usb_device_id id_table_combined [] = {
+ 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+ 	{ USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
++
++	/* Papouch devices based on FTDI chip */
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
+ 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
+ 	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
++	{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
++
+ 	{ USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
+ 	{ USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
+@@ -751,6 +780,7 @@ static struct usb_device_id id_table_combined [] = {
+ 	{ USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
+ 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+ 	{ USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
++	{ USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
+ 	{ USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
+ 		.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
+@@ -761,6 +791,9 @@ static struct usb_device_id id_table_combined [] = {
+ 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
++	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
++	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
++	{ USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
+ 	{ },					/* Optional parameter entry */
+ 	{ }					/* Terminating entry */
+ };
+@@ -2028,8 +2061,6 @@ static void ftdi_set_termios(struct tty_struct *tty,
+ 				"urb failed to set to rts/cts flow control\n");
+ 		}
+ 
+-		/* raise DTR/RTS */
+-		set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+ 	} else {
+ 		/*
+ 		 * Xon/Xoff code
+@@ -2077,8 +2108,6 @@ static void ftdi_set_termios(struct tty_struct *tty,
+ 			}
+ 		}
+ 
+-		/* lower DTR/RTS */
+-		clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+ 	}
+ 	return;
+ }
+diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
+index 15a4583..cf1aea1b 100644
+--- a/drivers/usb/serial/ftdi_sio_ids.h
++++ b/drivers/usb/serial/ftdi_sio_ids.h
+@@ -61,6 +61,7 @@
+ #define FTDI_OPENDCC_SNIFFER_PID	0xBFD9
+ #define FTDI_OPENDCC_THROTTLE_PID	0xBFDA
+ #define FTDI_OPENDCC_GATEWAY_PID	0xBFDB
++#define FTDI_OPENDCC_GBM_PID	0xBFDC
+ 
+ /*
+  * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
+@@ -1022,9 +1023,34 @@
+  */
+ 
+ #define PAPOUCH_VID			0x5050	/* Vendor ID */
++#define PAPOUCH_SB485_PID		0x0100	/* Papouch SB485 USB-485/422 Converter */
++#define PAPOUCH_AP485_PID		0x0101	/* AP485 USB-RS485 Converter */
++#define PAPOUCH_SB422_PID		0x0102	/* Papouch SB422 USB-RS422 Converter  */
++#define PAPOUCH_SB485_2_PID		0x0103	/* Papouch SB485 USB-485/422 Converter */
++#define PAPOUCH_AP485_2_PID		0x0104	/* AP485 USB-RS485 Converter */
++#define PAPOUCH_SB422_2_PID		0x0105	/* Papouch SB422 USB-RS422 Converter  */
++#define PAPOUCH_SB485S_PID		0x0106	/* Papouch SB485S USB-485/422 Converter */
++#define PAPOUCH_SB485C_PID		0x0107	/* Papouch SB485C USB-485/422 Converter */
++#define PAPOUCH_LEC_PID			0x0300	/* LEC USB Converter */
++#define PAPOUCH_SB232_PID		0x0301	/* Papouch SB232 USB-RS232 Converter */
+ #define PAPOUCH_TMU_PID			0x0400	/* TMU USB Thermometer */
+-#define PAPOUCH_QUIDO4x4_PID		0x0900	/* Quido 4/4 Module */
++#define PAPOUCH_IRAMP_PID		0x0500	/* Papouch IRAmp Duplex */
++#define PAPOUCH_DRAK5_PID		0x0700	/* Papouch DRAK5 */
++#define PAPOUCH_QUIDO8x8_PID		0x0800	/* Papouch Quido 8/8 Module */
++#define PAPOUCH_QUIDO4x4_PID		0x0900	/* Papouch Quido 4/4 Module */
++#define PAPOUCH_QUIDO2x2_PID		0x0a00	/* Papouch Quido 2/2 Module */
++#define PAPOUCH_QUIDO10x1_PID		0x0b00	/* Papouch Quido 10/1 Module */
++#define PAPOUCH_QUIDO30x3_PID		0x0c00	/* Papouch Quido 30/3 Module */
++#define PAPOUCH_QUIDO60x3_PID		0x0d00	/* Papouch Quido 60(100)/3 Module */
++#define PAPOUCH_QUIDO2x16_PID		0x0e00	/* Papouch Quido 2/16 Module */
++#define PAPOUCH_QUIDO3x32_PID		0x0f00	/* Papouch Quido 3/32 Module */
++#define PAPOUCH_DRAK6_PID		0x1000	/* Papouch DRAK6 */
++#define PAPOUCH_UPSUSB_PID		0x8000	/* Papouch UPS-USB adapter */
++#define PAPOUCH_MU_PID			0x8001	/* MU controller */
++#define PAPOUCH_SIMUKEY_PID		0x8002	/* Papouch SimuKey */
+ #define PAPOUCH_AD4USB_PID		0x8003	/* AD4USB Measurement Module */
++#define PAPOUCH_GMUX_PID		0x8004	/* Papouch GOLIATH MUX */
++#define PAPOUCH_GMSR_PID		0x8005	/* Papouch GOLIATH MSR */
+ 
+ /*
+  * Marvell SheevaPlug
+@@ -1063,3 +1089,14 @@
+  * Submitted by John G. Rogers
+  */
+ #define SEGWAY_RMP200_PID	0xe729
++
++
++/*
++ * Accesio USB Data Acquisition products (http://www.accesio.com/)
++ */
++#define ACCESIO_COM4SM_PID 	0xD578
++
++/* www.sciencescope.co.uk educational dataloggers */
++#define FTDI_SCIENCESCOPE_LOGBOOKML_PID		0xFF18
++#define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID	0xFF1C
++#define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID	0xFF1D
+diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
+index 7aa01b9..2849f8c 100644
+--- a/drivers/usb/serial/mct_u232.c
++++ b/drivers/usb/serial/mct_u232.c
+@@ -549,9 +549,12 @@ static void mct_u232_close(struct usb_serial_port *port)
+ {
+ 	dbg("%s port %d", __func__, port->number);
+ 
+-	usb_serial_generic_close(port);
+-	if (port->serial->dev)
++	if (port->serial->dev) {
++		/* shutdown our urbs */
++		usb_kill_urb(port->write_urb);
++		usb_kill_urb(port->read_urb);
+ 		usb_kill_urb(port->interrupt_in_urb);
++	}
+ } /* mct_u232_close */
+ 
+ 
+diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
+index ed01f3b..9ff19c8 100644
+--- a/drivers/usb/serial/opticon.c
++++ b/drivers/usb/serial/opticon.c
+@@ -96,8 +96,8 @@ static void opticon_bulk_callback(struct urb *urb)
+ 			/* real data, send it to the tty layer */
+ 			tty = tty_port_tty_get(&port->port);
+ 			if (tty) {
+-				tty_insert_flip_string(tty, data,
+-							       data_length);
++				tty_insert_flip_string(tty, data + 2,
++						       data_length);
+ 				tty_flip_buffer_push(tty);
+ 				tty_kref_put(tty);
+ 			}
+@@ -130,7 +130,7 @@ exit:
+ 						  priv->bulk_address),
+ 				  priv->bulk_in_buffer, priv->buffer_size,
+ 				  opticon_bulk_callback, priv);
+-		result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
++		result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
+ 		if (result)
+ 			dev_err(&port->dev,
+ 			    "%s - failed resubmitting read urb, error %d\n",
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index c46911a..51de0dd 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -622,6 +622,7 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0011, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0012, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0013, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0016, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0017, 0xff, 0xff, 0xff) },
+@@ -633,38 +634,52 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0023, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0024, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0025, 0xff, 0xff, 0xff) },
+-	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0026, 0xff, 0xff, 0xff) },
++	/* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0026, 0xff, 0xff, 0xff) }, */
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0028, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0029, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0030, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0032, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0033, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0034, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0037, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0038, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0039, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0040, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0042, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0043, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0044, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0048, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0049, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0050, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0051, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0052, 0xff, 0xff, 0xff) },
++	/* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0053, 0xff, 0xff, 0xff) }, */
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0054, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0055, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0056, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0057, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0058, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0061, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0062, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0063, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0064, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0065, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0066, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0067, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0069, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0076, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0077, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0078, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0079, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0082, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0083, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0086, 0xff, 0xff, 0xff) },
+-	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff, 0xff, 0xff) },
+-	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0087, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0104, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0105, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0106, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0108, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0113, 0xff, 0xff, 0xff) },
+@@ -880,6 +895,8 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
+diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
+index eb76aae..15a5d89 100644
+--- a/drivers/usb/serial/visor.c
++++ b/drivers/usb/serial/visor.c
+@@ -606,6 +606,10 @@ static int treo_attach(struct usb_serial *serial)
+ 
+ static int clie_5_attach(struct usb_serial *serial)
+ {
++	struct usb_serial_port *port;
++	unsigned int pipe;
++	int j;
++
+ 	dbg("%s", __func__);
+ 
+ 	/* TH55 registers 2 ports.
+@@ -621,9 +625,14 @@ static int clie_5_attach(struct usb_serial *serial)
+ 		return -1;
+ 
+ 	/* port 0 now uses the modified endpoint Address */
+-	serial->port[0]->bulk_out_endpointAddress =
++	port = serial->port[0];
++	port->bulk_out_endpointAddress =
+ 				serial->port[1]->bulk_out_endpointAddress;
+ 
++	pipe = usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress);
++	for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j)
++		port->write_urbs[j]->pipe = pipe;
++
+ 	return 0;
+ }
+ 
+diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
+index 1d60c65..f110e0e 100644
+--- a/fs/cifs/cifsproto.h
++++ b/fs/cifs/cifsproto.h
+@@ -107,7 +107,8 @@ extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,
+ 
+ extern struct cifsFileInfo *cifs_new_fileinfo(struct inode *newinode,
+ 				__u16 fileHandle, struct file *file,
+-				struct vfsmount *mnt, unsigned int oflags);
++				struct vfsmount *mnt, unsigned int oflags,
++				__u32 oplock);
+ extern int cifs_posix_open(char *full_path, struct inode **pinode,
+ 				struct super_block *sb,
+ 				int mode, int oflags,
+diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
+index f9ed075..0f947bf 100644
+--- a/fs/cifs/dir.c
++++ b/fs/cifs/dir.c
+@@ -132,9 +132,9 @@ cifs_bp_rename_retry:
+ 
+ struct cifsFileInfo *
+ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
+-		  struct file *file, struct vfsmount *mnt, unsigned int oflags)
++		  struct file *file, struct vfsmount *mnt, unsigned int oflags,
++		  __u32 oplock)
+ {
+-	int oplock = 0;
+ 	struct cifsFileInfo *pCifsFile;
+ 	struct cifsInodeInfo *pCifsInode;
+ 	struct cifs_sb_info *cifs_sb = CIFS_SB(mnt->mnt_sb);
+@@ -143,9 +143,6 @@ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle,
+ 	if (pCifsFile == NULL)
+ 		return pCifsFile;
+ 
+-	if (oplockEnabled)
+-		oplock = REQ_OPLOCK;
+-
+ 	pCifsFile->netfid = fileHandle;
+ 	pCifsFile->pid = current->tgid;
+ 	pCifsFile->pInode = igrab(newinode);
+@@ -468,7 +465,7 @@ cifs_create_set_dentry:
+ 		}
+ 
+ 		pfile_info = cifs_new_fileinfo(newinode, fileHandle, filp,
+-					       nd->path.mnt, oflags);
++					       nd->path.mnt, oflags, oplock);
+ 		if (pfile_info == NULL) {
+ 			fput(filp);
+ 			CIFSSMBClose(xid, tcon, fileHandle);
+@@ -729,7 +726,8 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
+ 
+ 			cfile = cifs_new_fileinfo(newInode, fileHandle, filp,
+ 						  nd->path.mnt,
+-						  nd->intent.open.flags);
++						  nd->intent.open.flags,
++						  oplock);
+ 			if (cfile == NULL) {
+ 				fput(filp);
+ 				CIFSSMBClose(xid, pTcon, fileHandle);
+diff --git a/fs/cifs/file.c b/fs/cifs/file.c
+index de748c6..681761c 100644
+--- a/fs/cifs/file.c
++++ b/fs/cifs/file.c
+@@ -277,7 +277,7 @@ int cifs_open(struct inode *inode, struct file *file)
+ 
+ 			pCifsFile = cifs_new_fileinfo(inode, netfid, file,
+ 							file->f_path.mnt,
+-							oflags);
++							oflags, oplock);
+ 			if (pCifsFile == NULL) {
+ 				CIFSSMBClose(xid, tcon, netfid);
+ 				rc = -ENOMEM;
+@@ -370,7 +370,7 @@ int cifs_open(struct inode *inode, struct file *file)
+ 		goto out;
+ 
+ 	pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
+-					file->f_flags);
++					file->f_flags, oplock);
+ 	if (pCifsFile == NULL) {
+ 		rc = -ENOMEM;
+ 		goto out;
+diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
+index 064a809..84d3c8b 100644
+--- a/fs/nfs/direct.c
++++ b/fs/nfs/direct.c
+@@ -873,7 +873,7 @@ static ssize_t nfs_direct_write(struct kiocb *iocb, const struct iovec *iov,
+ 	dreq->inode = inode;
+ 	dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
+ 	dreq->l_ctx = nfs_get_lock_context(dreq->ctx);
+-	if (dreq->l_ctx != NULL)
++	if (dreq->l_ctx == NULL)
+ 		goto out_release;
+ 	if (!is_sync_kiocb(iocb))
+ 		dreq->iocb = iocb;
+diff --git a/fs/pipe.c b/fs/pipe.c
+index 279eef9..37eb1eb 100644
+--- a/fs/pipe.c
++++ b/fs/pipe.c
+@@ -382,7 +382,7 @@ pipe_read(struct kiocb *iocb, const struct iovec *_iov,
+ 			error = ops->confirm(pipe, buf);
+ 			if (error) {
+ 				if (!ret)
+-					error = ret;
++					ret = error;
+ 				break;
+ 			}
+ 
+diff --git a/kernel/futex.c b/kernel/futex.c
+index 6a3a5fa..e328f57 100644
+--- a/kernel/futex.c
++++ b/kernel/futex.c
+@@ -1363,7 +1363,6 @@ static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
+ {
+ 	struct futex_hash_bucket *hb;
+ 
+-	get_futex_key_refs(&q->key);
+ 	hb = hash_futex(&q->key);
+ 	q->lock_ptr = &hb->lock;
+ 
+@@ -1375,7 +1374,6 @@ static inline void
+ queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
+ {
+ 	spin_unlock(&hb->lock);
+-	drop_futex_key_refs(&q->key);
+ }
+ 
+ /**
+@@ -1480,8 +1478,6 @@ static void unqueue_me_pi(struct futex_q *q)
+ 	q->pi_state = NULL;
+ 
+ 	spin_unlock(q->lock_ptr);
+-
+-	drop_futex_key_refs(&q->key);
+ }
+ 
+ /*
+@@ -1812,7 +1808,10 @@ static int futex_wait(u32 __user *uaddr, int fshared,
+ 	}
+ 
+ retry:
+-	/* Prepare to wait on uaddr. */
++	/*
++	 * Prepare to wait on uaddr. On success, holds hb lock and increments
++	 * q.key refs.
++	 */
+ 	ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
+ 	if (ret)
+ 		goto out;
+@@ -1822,24 +1821,23 @@ retry:
+ 
+ 	/* If we were woken (and unqueued), we succeeded, whatever. */
+ 	ret = 0;
++	/* unqueue_me() drops q.key ref */
+ 	if (!unqueue_me(&q))
+-		goto out_put_key;
++		goto out;
+ 	ret = -ETIMEDOUT;
+ 	if (to && !to->task)
+-		goto out_put_key;
++		goto out;
+ 
+ 	/*
+ 	 * We expect signal_pending(current), but we might be the
+ 	 * victim of a spurious wakeup as well.
+ 	 */
+-	if (!signal_pending(current)) {
+-		put_futex_key(fshared, &q.key);
++	if (!signal_pending(current))
+ 		goto retry;
+-	}
+ 
+ 	ret = -ERESTARTSYS;
+ 	if (!abs_time)
+-		goto out_put_key;
++		goto out;
+ 
+ 	restart = &current_thread_info()->restart_block;
+ 	restart->fn = futex_wait_restart;
+@@ -1856,8 +1854,6 @@ retry:
+ 
+ 	ret = -ERESTART_RESTARTBLOCK;
+ 
+-out_put_key:
+-	put_futex_key(fshared, &q.key);
+ out:
+ 	if (to) {
+ 		hrtimer_cancel(&to->timer);
+@@ -2236,7 +2232,10 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, int fshared,
+ 	q.rt_waiter = &rt_waiter;
+ 	q.requeue_pi_key = &key2;
+ 
+-	/* Prepare to wait on uaddr. */
++	/*
++	 * Prepare to wait on uaddr. On success, increments q.key (key1) ref
++	 * count.
++	 */
+ 	ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
+ 	if (ret)
+ 		goto out_key2;
+@@ -2254,7 +2253,9 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, int fshared,
+ 	 * In order for us to be here, we know our q.key == key2, and since
+ 	 * we took the hb->lock above, we also know that futex_requeue() has
+ 	 * completed and we no longer have to concern ourselves with a wakeup
+-	 * race with the atomic proxy lock acquition by the requeue code.
++	 * race with the atomic proxy lock acquisition by the requeue code. The
++	 * futex_requeue dropped our key1 reference and incremented our key2
++	 * reference count.
+ 	 */
+ 
+ 	/* Check if the requeue code acquired the second futex for us. */
+diff --git a/kernel/perf_event.c b/kernel/perf_event.c
+index b98bed3..03bb897 100644
+--- a/kernel/perf_event.c
++++ b/kernel/perf_event.c
+@@ -1773,7 +1773,13 @@ static u64 perf_event_read(struct perf_event *event)
+ 		unsigned long flags;
+ 
+ 		raw_spin_lock_irqsave(&ctx->lock, flags);
+-		update_context_time(ctx);
++		/*
++		 * may read while context is not active
++		 * (e.g., thread is blocked), in that case
++		 * we cannot update context time
++		 */
++		if (ctx->is_active)
++			update_context_time(ctx);
+ 		update_event_times(event);
+ 		raw_spin_unlock_irqrestore(&ctx->lock, flags);
+ 	}
+diff --git a/kernel/sched.c b/kernel/sched.c
+index dc85ceb..3fd774c 100644
+--- a/kernel/sched.c
++++ b/kernel/sched.c
+@@ -723,7 +723,7 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
+ 		size_t cnt, loff_t *ppos)
+ {
+ 	char buf[64];
+-	char *cmp = buf;
++	char *cmp;
+ 	int neg = 0;
+ 	int i;
+ 
+@@ -734,6 +734,7 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
+ 		return -EFAULT;
+ 
+ 	buf[cnt] = 0;
++	cmp = strstrip(buf);
+ 
+ 	if (strncmp(buf, "NO_", 3) == 0) {
+ 		neg = 1;
+@@ -741,9 +742,7 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
+ 	}
+ 
+ 	for (i = 0; sched_feat_names[i]; i++) {
+-		int len = strlen(sched_feat_names[i]);
+-
+-		if (strncmp(cmp, sched_feat_names[i], len) == 0) {
++		if (strcmp(cmp, sched_feat_names[i]) == 0) {
+ 			if (neg)
+ 				sysctl_sched_features &= ~(1UL << i);
+ 			else
+@@ -1858,12 +1857,6 @@ static void dec_nr_running(struct rq *rq)
+ 
+ static void set_load_weight(struct task_struct *p)
+ {
+-	if (task_has_rt_policy(p)) {
+-		p->se.load.weight = 0;
+-		p->se.load.inv_weight = WMULT_CONST;
+-		return;
+-	}
+-
+ 	/*
+ 	 * SCHED_IDLE tasks get minimal weight:
+ 	 */
+diff --git a/mm/vmalloc.c b/mm/vmalloc.c
+index 6b8889d..d8087f0 100644
+--- a/mm/vmalloc.c
++++ b/mm/vmalloc.c
+@@ -517,6 +517,15 @@ static atomic_t vmap_lazy_nr = ATOMIC_INIT(0);
+ static void purge_fragmented_blocks_allcpus(void);
+ 
+ /*
++ * called before a call to iounmap() if the caller wants vm_area_struct's
++ * immediately freed.
++ */
++void set_iounmap_nonlazy(void)
++{
++	atomic_set(&vmap_lazy_nr, lazy_max_pages()+1);
++}
++
++/*
+  * Purges all lazily-freed vmap areas.
+  *
+  * If sync is 0 then don't purge if there is already a purge in progress.
+diff --git a/net/bluetooth/l2cap.c b/net/bluetooth/l2cap.c
+index 0b54b7d..dc60205 100644
+--- a/net/bluetooth/l2cap.c
++++ b/net/bluetooth/l2cap.c
+@@ -2891,7 +2891,7 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
+ 	struct l2cap_chan_list *list = &conn->chan_list;
+ 	struct l2cap_conn_req *req = (struct l2cap_conn_req *) data;
+ 	struct l2cap_conn_rsp rsp;
+-	struct sock *parent, *uninitialized_var(sk);
++	struct sock *parent, *sk = NULL;
+ 	int result, status = L2CAP_CS_NO_INFO;
+ 
+ 	u16 dcid = 0, scid = __le16_to_cpu(req->scid);
+@@ -3000,7 +3000,7 @@ sendresp:
+ 					L2CAP_INFO_REQ, sizeof(info), &info);
+ 	}
+ 
+-	if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT) &&
++	if (sk && !(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT) &&
+ 				result == L2CAP_CR_SUCCESS) {
+ 		u8 buf[128];
+ 		l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
+diff --git a/net/netfilter/xt_SECMARK.c b/net/netfilter/xt_SECMARK.c
+index 23b2d6c..364ad16 100644
+--- a/net/netfilter/xt_SECMARK.c
++++ b/net/netfilter/xt_SECMARK.c
+@@ -101,7 +101,7 @@ static int secmark_tg_check(const struct xt_tgchk_param *par)
+ 	switch (info->mode) {
+ 	case SECMARK_MODE_SEL:
+ 		err = checkentry_selinux(info);
+-		if (err <= 0)
++		if (err)
+ 			return err;
+ 		break;
+ 

Deleted: genpatches-2.6/trunk/2.6.36/1800_automated-per-tty-task-groups.patch
===================================================================
--- genpatches-2.6/trunk/2.6.36/1800_automated-per-tty-task-groups.patch	2010-11-21 00:34:02 UTC (rev 1827)
+++ genpatches-2.6/trunk/2.6.36/1800_automated-per-tty-task-groups.patch	2010-11-22 22:45:50 UTC (rev 1828)
@@ -1,533 +0,0 @@
-Index: linux-2.6.36/include/linux/sched.h
-===================================================================
---- linux-2.6.36.orig/include/linux/sched.h
-+++ linux-2.6.36/include/linux/sched.h
-@@ -506,6 +506,8 @@ struct thread_group_cputimer {
- 	spinlock_t lock;
- };
- 
-+struct autogroup;
-+
- /*
-  * NOTE! "signal_struct" does not have it's own
-  * locking, because a shared signal_struct always
-@@ -573,6 +575,9 @@ struct signal_struct {
- 
- 	struct tty_struct *tty; /* NULL if no tty */
- 
-+#ifdef CONFIG_SCHED_AUTOGROUP
-+	struct autogroup *autogroup;
-+#endif
- 	/*
- 	 * Cumulative resource counters for dead threads in the group,
- 	 * and for reaped dead child processes forked by this group.
-@@ -1900,6 +1905,20 @@ int sched_rt_handler(struct ctl_table *t
- 
- extern unsigned int sysctl_sched_compat_yield;
- 
-+#ifdef CONFIG_SCHED_AUTOGROUP
-+extern unsigned int sysctl_sched_autogroup_enabled;
-+
-+extern void sched_autogroup_create_attach(struct task_struct *p);
-+extern void sched_autogroup_detach(struct task_struct *p);
-+extern void sched_autogroup_fork(struct signal_struct *sig);
-+extern void sched_autogroup_exit(struct signal_struct *sig);
-+#else
-+static inline void sched_autogroup_create_attach(struct task_struct *p) { }
-+static inline void sched_autogroup_detach(struct task_struct *p) { }
-+static inline void sched_autogroup_fork(struct signal_struct *sig) { }
-+static inline void sched_autogroup_exit(struct signal_struct *sig) { }
-+#endif
-+
- #ifdef CONFIG_RT_MUTEXES
- extern int rt_mutex_getprio(struct task_struct *p);
- extern void rt_mutex_setprio(struct task_struct *p, int prio);
-Index: linux-2.6.36/kernel/sched.c
-===================================================================
---- linux-2.6.36.orig/kernel/sched.c
-+++ linux-2.6.36/kernel/sched.c
-@@ -78,6 +78,7 @@
- 
- #include "sched_cpupri.h"
- #include "workqueue_sched.h"
-+#include "sched_autogroup.h"
- 
- #define CREATE_TRACE_POINTS
- #include <trace/events/sched.h>
-@@ -268,6 +269,10 @@ struct task_group {
- 	struct task_group *parent;
- 	struct list_head siblings;
- 	struct list_head children;
-+
-+#if defined(CONFIG_SCHED_AUTOGROUP)
-+	struct autogroup *autogroup;
-+#endif
- };
- 
- #define root_task_group init_task_group
-@@ -612,11 +617,14 @@ static inline int cpu_of(struct rq *rq)
-  */
- static inline struct task_group *task_group(struct task_struct *p)
- {
-+	struct task_group *tg;
- 	struct cgroup_subsys_state *css;
- 
- 	css = task_subsys_state_check(p, cpu_cgroup_subsys_id,
- 			lockdep_is_held(&task_rq(p)->lock));
--	return container_of(css, struct task_group, css);
-+	tg = container_of(css, struct task_group, css);
-+
-+	return autogroup_task_group(p, tg);
- }
- 
- /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
-@@ -1920,6 +1928,7 @@ static void deactivate_task(struct rq *r
- #include "sched_idletask.c"
- #include "sched_fair.c"
- #include "sched_rt.c"
-+#include "sched_autogroup.c"
- #ifdef CONFIG_SCHED_DEBUG
- # include "sched_debug.c"
- #endif
-@@ -7749,7 +7758,7 @@ void __init sched_init(void)
- #ifdef CONFIG_CGROUP_SCHED
- 	list_add(&init_task_group.list, &task_groups);
- 	INIT_LIST_HEAD(&init_task_group.children);
--
-+	autogroup_init(&init_task);
- #endif /* CONFIG_CGROUP_SCHED */
- 
- #if defined CONFIG_FAIR_GROUP_SCHED && defined CONFIG_SMP
-Index: linux-2.6.36/kernel/fork.c
-===================================================================
---- linux-2.6.36.orig/kernel/fork.c
-+++ linux-2.6.36/kernel/fork.c
-@@ -173,8 +173,10 @@ static inline void free_signal_struct(st
- 
- static inline void put_signal_struct(struct signal_struct *sig)
- {
--	if (atomic_dec_and_test(&sig->sigcnt))
-+	if (atomic_dec_and_test(&sig->sigcnt)) {
-+		sched_autogroup_exit(sig);
- 		free_signal_struct(sig);
-+	}
- }
- 
- void __put_task_struct(struct task_struct *tsk)
-@@ -900,6 +902,7 @@ static int copy_signal(unsigned long clo
- 	posix_cpu_timers_init_group(sig);
- 
- 	tty_audit_fork(sig);
-+	sched_autogroup_fork(sig);
- 
- 	sig->oom_adj = current->signal->oom_adj;
- 	sig->oom_score_adj = current->signal->oom_score_adj;
-Index: linux-2.6.36/kernel/sys.c
-===================================================================
---- linux-2.6.36.orig/kernel/sys.c
-+++ linux-2.6.36/kernel/sys.c
-@@ -1080,8 +1080,10 @@ SYSCALL_DEFINE0(setsid)
- 	err = session;
- out:
- 	write_unlock_irq(&tasklist_lock);
--	if (err > 0)
-+	if (err > 0) {
- 		proc_sid_connector(group_leader);
-+		sched_autogroup_create_attach(group_leader);
-+	}
- 	return err;
- }
- 
-Index: linux-2.6.36/kernel/sched_debug.c
-===================================================================
---- linux-2.6.36.orig/kernel/sched_debug.c
-+++ linux-2.6.36/kernel/sched_debug.c
-@@ -87,6 +87,20 @@ static void print_cfs_group_stats(struct
- }
- #endif
- 
-+#if defined(CONFIG_CGROUP_SCHED) && \
-+	(defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED))
-+static void task_group_path(struct task_group *tg, char *buf, int buflen)
-+{
-+	/* may be NULL if the underlying cgroup isn't fully-created yet */
-+	if (!tg->css.cgroup) {
-+		buf[0] = '\0';
-+		autogroup_path(tg, buf, buflen);
-+		return;
-+	}
-+	cgroup_path(tg->css.cgroup, buf, buflen);
-+}
-+#endif
-+
- static void
- print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
- {
-@@ -115,7 +129,7 @@ print_task(struct seq_file *m, struct rq
- 		char path[64];
- 
- 		rcu_read_lock();
--		cgroup_path(task_group(p)->css.cgroup, path, sizeof(path));
-+		task_group_path(task_group(p), path, sizeof(path));
- 		rcu_read_unlock();
- 		SEQ_printf(m, " %s", path);
- 	}
-@@ -147,19 +161,6 @@ static void print_rq(struct seq_file *m,
- 	read_unlock_irqrestore(&tasklist_lock, flags);
- }
- 
--#if defined(CONFIG_CGROUP_SCHED) && \
--	(defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED))
--static void task_group_path(struct task_group *tg, char *buf, int buflen)
--{
--	/* may be NULL if the underlying cgroup isn't fully-created yet */
--	if (!tg->css.cgroup) {
--		buf[0] = '\0';
--		return;
--	}
--	cgroup_path(tg->css.cgroup, buf, buflen);
--}
--#endif
--
- void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
- {
- 	s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1,
-Index: linux-2.6.36/kernel/sched_autogroup.h
-===================================================================
---- /dev/null
-+++ linux-2.6.36/kernel/sched_autogroup.h
-@@ -0,0 +1,23 @@
-+#ifdef CONFIG_SCHED_AUTOGROUP
-+
-+static inline struct task_group *
-+autogroup_task_group(struct task_struct *p, struct task_group *tg);
-+
-+#else /* !CONFIG_SCHED_AUTOGROUP */
-+
-+static inline void autogroup_init(struct task_struct *init_task) {  }
-+
-+static inline struct task_group *
-+autogroup_task_group(struct task_struct *p, struct task_group *tg)
-+{
-+	return tg;
-+}
-+
-+#ifdef CONFIG_SCHED_DEBUG
-+static inline int autogroup_path(struct task_group *tg, char *buf, int buflen)
-+{
-+	return 0;
-+}
-+#endif
-+
-+#endif /* CONFIG_SCHED_AUTOGROUP */
-Index: linux-2.6.36/kernel/sched_autogroup.c
-===================================================================
---- /dev/null
-+++ linux-2.6.36/kernel/sched_autogroup.c
-@@ -0,0 +1,170 @@
-+#ifdef CONFIG_SCHED_AUTOGROUP
-+
-+unsigned int __read_mostly sysctl_sched_autogroup_enabled = 1;
-+
-+struct autogroup {
-+	struct task_group	*tg;
-+	struct kref		kref;
-+	unsigned long		id;
-+};
-+
-+static struct autogroup autogroup_default;
-+static atomic_t autogroup_seq_nr;
-+
-+static void autogroup_init(struct task_struct *init_task)
-+{
-+	autogroup_default.tg = &init_task_group;
-+	autogroup_default.id = 0;
-+	atomic_set(&autogroup_seq_nr, 1);
-+	kref_init(&autogroup_default.kref);
-+	init_task->signal->autogroup = &autogroup_default;
-+}
-+
-+static inline void autogroup_destroy(struct kref *kref)
-+{
-+	struct autogroup *ag = container_of(kref, struct autogroup, kref);
-+	struct task_group *tg = ag->tg;
-+
-+	kfree(ag);
-+	sched_destroy_group(tg);
-+}
-+
-+static inline void autogroup_kref_put(struct autogroup *ag)
-+{
-+	kref_put(&ag->kref, autogroup_destroy);
-+}
-+
-+static inline struct autogroup *autogroup_kref_get(struct autogroup *ag)
-+{
-+	kref_get(&ag->kref);
-+	return ag;
-+}
-+
-+static inline struct autogroup *autogroup_create(void)
-+{
-+	struct autogroup *ag = kmalloc(sizeof(*ag), GFP_KERNEL);
-+
-+	if (!ag)
-+		goto out_fail;
-+
-+	ag->tg = sched_create_group(&init_task_group);
-+
-+	if (IS_ERR(ag->tg))
-+		goto out_fail;
-+
-+	kref_init(&ag->kref);
-+	ag->tg->autogroup = ag;
-+	ag->id = atomic_inc_return(&autogroup_seq_nr);
-+
-+	return ag;
-+
-+out_fail:
-+	if (ag) {
-+		kfree(ag);
-+		WARN_ON(1);
-+	} else
-+		WARN_ON(1);
-+
-+	return autogroup_kref_get(&autogroup_default);
-+}
-+
-+static inline bool
-+task_wants_autogroup(struct task_struct *p, struct task_group *tg)
-+{
-+	if (tg != &root_task_group)
-+		return false;
-+
-+	if (p->sched_class != &fair_sched_class)
-+		return false;
-+
-+	if (p->flags & PF_EXITING)
-+		return false;
-+
-+	return true;
-+}
-+
-+static inline struct task_group *
-+autogroup_task_group(struct task_struct *p, struct task_group *tg)
-+{
-+	int enabled = ACCESS_ONCE(sysctl_sched_autogroup_enabled);
-+
-+	if (enabled && task_wants_autogroup(p, tg))
-+		return p->signal->autogroup->tg;
-+
-+	return tg;
-+}
-+
-+static void
-+autogroup_move_group(struct task_struct *p, struct autogroup *ag)
-+{
-+	struct autogroup *prev;
-+	struct task_struct *t;
-+
-+	spin_lock(&p->sighand->siglock);
-+
-+	prev = p->signal->autogroup;
-+	if (prev == ag) {
-+		spin_unlock(&p->sighand->siglock);
-+		return;
-+	}
-+
-+	p->signal->autogroup = autogroup_kref_get(ag);
-+	t = p;
-+
-+	do {
-+		sched_move_task(p);
-+	} while_each_thread(p, t);
-+
-+	spin_unlock(&p->sighand->siglock);
-+
-+	autogroup_kref_put(prev);
-+}
-+
-+/* Allocates GFP_KERNEL, cannot be called under any spinlock */
-+void sched_autogroup_create_attach(struct task_struct *p)
-+{
-+	struct autogroup *ag = autogroup_create();
-+
-+	autogroup_move_group(p, ag);
-+	/* drop extra refrence added by autogroup_create() */
-+	autogroup_kref_put(ag);
-+}
-+EXPORT_SYMBOL(sched_autogroup_create_attach);
-+
-+/* Cannot be called under siglock.  Currently has no users */
-+void sched_autogroup_detach(struct task_struct *p)
-+{
-+	autogroup_move_group(p, &autogroup_default);
-+}
-+EXPORT_SYMBOL(sched_autogroup_detach);
-+
-+void sched_autogroup_fork(struct signal_struct *sig)
-+{
-+	struct sighand_struct *sighand = current->sighand;
-+
-+	spin_lock(&sighand->siglock);
-+	sig->autogroup = autogroup_kref_get(current->signal->autogroup);
-+	spin_unlock(&sighand->siglock);
-+}
-+
-+void sched_autogroup_exit(struct signal_struct *sig)
-+{
-+	autogroup_kref_put(sig->autogroup);
-+}
-+
-+static int __init setup_autogroup(char *str)
-+{
-+	sysctl_sched_autogroup_enabled = 0;
-+
-+	return 1;
-+}
-+
-+__setup("noautogroup", setup_autogroup);
-+
-+#ifdef CONFIG_SCHED_DEBUG
-+static inline int autogroup_path(struct task_group *tg, char *buf, int buflen)
-+{
-+	return snprintf(buf, buflen, "%s-%ld", "autogroup", tg->autogroup->id);
-+}
-+#endif
-+#endif /* CONFIG_SCHED_AUTOGROUP */
-Index: linux-2.6.36/kernel/sysctl.c
-===================================================================
---- linux-2.6.36.orig/kernel/sysctl.c
-+++ linux-2.6.36/kernel/sysctl.c
-@@ -384,6 +384,17 @@ static struct ctl_table kern_table[] = {
- 		.mode		= 0644,
- 		.proc_handler	= proc_dointvec,
- 	},
-+#ifdef CONFIG_SCHED_AUTOGROUP
-+	{
-+		.procname	= "sched_autogroup_enabled",
-+		.data		= &sysctl_sched_autogroup_enabled,
-+		.maxlen		= sizeof(unsigned int),
-+		.mode		= 0644,
-+		.proc_handler	= proc_dointvec,
-+		.extra1		= &zero,
-+		.extra2		= &one,
-+	},
-+#endif
- #ifdef CONFIG_PROVE_LOCKING
- 	{
- 		.procname	= "prove_locking",
-Index: linux-2.6.36/init/Kconfig
-===================================================================
---- linux-2.6.36.orig/init/Kconfig
-+++ linux-2.6.36/init/Kconfig
-@@ -652,6 +652,18 @@ config DEBUG_BLK_CGROUP
- 
- endif # CGROUPS
- 
-+config SCHED_AUTOGROUP
-+	bool "Automatic process group scheduling"
-+	select CGROUPS
-+	select CGROUP_SCHED
-+	select FAIR_GROUP_SCHED
-+	help
-+	  This option optimizes the scheduler for common desktop workloads by
-+	  automatically creating and populating task groups.  This separation
-+	  of workloads isolates aggressive CPU burners (like build jobs) from
-+	  desktop applications.  Task group autogeneration is currently based
-+	  upon task session.
-+
- config MM_OWNER
- 	bool
- 
-Index: linux-2.6.36/Documentation/kernel-parameters.txt
-===================================================================
---- linux-2.6.36.orig/Documentation/kernel-parameters.txt
-+++ linux-2.6.36/Documentation/kernel-parameters.txt
-@@ -1610,6 +1610,8 @@ and is between 256 and 4096 characters.
- 	noapic		[SMP,APIC] Tells the kernel to not make use of any
- 			IOAPICs that may be present in the system.
- 
-+	noautogroup	Disable scheduler automatic task group creation.
-+
- 	nobats		[PPC] Do not use BATs for mapping kernel lowmem
- 			on "Classic" PPC cores.
-
-Index: linux-2.6.36.git/kernel/sched.c
-===================================================================
---- linux-2.6.36.git.orig/kernel/sched.c
-+++ linux-2.6.36.git/kernel/sched.c
-@@ -8297,12 +8297,12 @@ void sched_move_task(struct task_struct
- 	if (unlikely(running))
- 		tsk->sched_class->put_prev_task(rq, tsk);
- 
--	set_task_rq(tsk, task_cpu(tsk));
--
- #ifdef CONFIG_FAIR_GROUP_SCHED
--	if (tsk->sched_class->moved_group)
--		tsk->sched_class->moved_group(tsk, on_rq);
-+	if (tsk->sched_class->task_move_group)
-+		tsk->sched_class->task_move_group(tsk, on_rq);
-+	else
- #endif
-+		set_task_rq(tsk, task_cpu(tsk));
- 
- 	if (unlikely(running))
- 		tsk->sched_class->set_curr_task(rq);
-Index: linux-2.6.36.git/include/linux/sched.h
-===================================================================
---- linux-2.6.36.git.orig/include/linux/sched.h
-+++ linux-2.6.36.git/include/linux/sched.h
-@@ -1072,7 +1072,7 @@ struct sched_class {
- 					 struct task_struct *task);
- 
- #ifdef CONFIG_FAIR_GROUP_SCHED
--	void (*moved_group) (struct task_struct *p, int on_rq);
-+	void (*task_move_group) (struct task_struct *p, int on_rq);
- #endif
- };
- 
-Index: linux-2.6.36.git/kernel/sched_fair.c
-===================================================================
---- linux-2.6.36.git.orig/kernel/sched_fair.c
-+++ linux-2.6.36.git/kernel/sched_fair.c
-@@ -3824,13 +3824,26 @@ static void set_curr_task_fair(struct rq
- }
- 
- #ifdef CONFIG_FAIR_GROUP_SCHED
--static void moved_group_fair(struct task_struct *p, int on_rq)
-+static void task_move_group_fair(struct task_struct *p, int on_rq)
- {
--	struct cfs_rq *cfs_rq = task_cfs_rq(p);
--
--	update_curr(cfs_rq);
-+	/*
-+	 * If the task was not on the rq at the time of this cgroup movement
-+	 * it must have been asleep, sleeping tasks keep their ->vruntime
-+	 * absolute on their old rq until wakeup (needed for the fair sleeper
-+	 * bonus in place_entity()).
-+	 *
-+	 * If it was on the rq, we've just 'preempted' it, which does convert
-+	 * ->vruntime to a relative base.
-+	 *
-+	 * Make sure both cases convert their relative position when migrating
-+	 * to another cgroup's rq. This does somewhat interfere with the
-+	 * fair sleeper stuff for the first placement, but who cares.
-+	 */
-+	if (!on_rq)
-+		p->se.vruntime -= cfs_rq_of(&p->se)->min_vruntime;
-+	set_task_rq(p, task_cpu(p));
- 	if (!on_rq)
--		place_entity(cfs_rq, &p->se, 1);
-+		p->se.vruntime += cfs_rq_of(&p->se)->min_vruntime;
- }
- #endif
- 
-@@ -3882,7 +3895,7 @@ static const struct sched_class fair_sch
- 	.get_rr_interval	= get_rr_interval_fair,
- 
- #ifdef CONFIG_FAIR_GROUP_SCHED
--	.moved_group		= moved_group_fair,
-+	.task_move_group	= task_move_group_fair,
- #endif
- };