lael-labs/linux

Documentation/kernel-parameters.txt+1−1

@@ -2953,7 +2953,7 @@ bytes respectively. Such letter suffixes can also be entirely omitted. · 2952 unmodified lines
2953	improve throughput, but will also increase the	2953	improve throughput, but will also increase the
2954	amount of memory reserved for use by the client.	2954	amount of memory reserved for use by the client.
2955		2955
2956	swapaccount[=0\|1]	2956	swapaccount=[0\|1]
2957	[KNL] Enable accounting of swap in memory resource	2957	[KNL] Enable accounting of swap in memory resource
2958	controller if no parameter or 1 is given or disable	2958	controller if no parameter or 1 is given or disable
2959	it if 0 is given (See Documentation/cgroups/memory.txt)	2959	it if 0 is given (See Documentation/cgroups/memory.txt)

MAINTAINERS+7−7

 F:	drivers/media/tuners/mxl5007t.*
 MYRICOM MYRI-10G 10GbE DRIVER (MYRI10GE)
-M:	Andrew Gallatin <gallatin@myri.com>
+M:	Hyong-Youb Kim <hykim@myri.com>
 L:	netdev@vger.kernel.org
-W:	http://www.myri.com/scs/download-Myri10GE.html
+W:	https://www.myricom.com/support/downloads/myri10ge.html
 S:	Supported
 F:	drivers/net/ethernet/myricom/myri10ge/
 F:	include/linux/i2c-omap.h
 OMAP DEVICE TREE SUPPORT
-M:	Benoît Cousson <b-cousson@ti.com>
+M:	Benoît Cousson <bcousson@baylibre.com>
 M:	Tony Lindgren <tony@atomide.com>
 L:	linux-omap@vger.kernel.org
 L:	devicetree@vger.kernel.org
 F:	drivers/char/hw_random/omap-rng.c
 OMAP HWMOD SUPPORT
-M:	Benoît Cousson <b-cousson@ti.com>
+M:	Benoît Cousson <bcousson@baylibre.com>
 M:	Paul Walmsley <paul@pwsan.com>
 L:	linux-omap@vger.kernel.org
 S:	Maintained
 F:	arch/arm/mach-omap2/omap_hwmod.*
 OMAP HWMOD DATA FOR OMAP4-BASED DEVICES
-M:	Benoît Cousson <b-cousson@ti.com>
+M:	Benoît Cousson <bcousson@baylibre.com>
 L:	linux-omap@vger.kernel.org
 S:	Maintained
 F:	arch/arm/mach-omap2/omap_hwmod_44xx_data.c
 SGI GRU DRIVER
 M:	Dimitri Sivanich <sivanich@sgi.com>
-M:	Robin Holt <holt@sgi.com>
 S:	Maintained
 F:	drivers/misc/sgi-gru/
 F:	Documentation/sgi-visws.txt
 SGI XP/XPC/XPNET DRIVER
-M:	Robin Holt <holt@sgi.com>
+M:	Cliff Whickman <cpw@sgi.com>
+M:	Robin Holt <robinmholt@gmail.com>
 S:	Maintained
 F:	drivers/misc/sgi-xp/

Makefile+1−1

@@ -1,7 +1,7 @@
1	VERSION = 3	1	VERSION = 3
2	PATCHLEVEL = 11	2	PATCHLEVEL = 11
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc5	4	EXTRAVERSION = -rc7
5	NAME = Linux for Workgroups	5	NAME = Linux for Workgroups
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION

arch/Kconfig+6−0

 	help
 	  Architecture has the first two arguments of clone(2) swapped.
+config CLONE_BACKWARDS3
+	bool
+	help
+	  Architecture has tls passed as the 3rd argument of clone(2),
+	  not the 5th one.
 config ODD_RT_SIGACTION
 	bool
 	help

arch/arc/lib/strchr-700.S+10−0

 	ld.a	r2,[r0,4]
 	sub	r12,r6,r7
 	bic	r12,r12,r6
+#ifdef __LITTLE_ENDIAN__
 	and	r7,r12,r4
 	breq	r7,0,.Loop ; For speed, we want this branch to be unaligned.
 	b	.Lfound_char ; Likewise this one.
+#else
+	and	r12,r12,r4
+	breq	r12,0,.Loop ; For speed, we want this branch to be unaligned.
+	lsr_s	r12,r12,7
+	bic 	r2,r7,r6
+	b.d	.Lfound_char_b
+	and_s	r2,r2,r12
+#endif
 ; /* We require this code address to be unaligned for speed...  */
 .Laligned:
 	ld_s	r2,[r0]
 	lsr	r7,r7,7
 	bic	r2,r7,r6
+.Lfound_char_b:
 	norm	r2,r2
 	sub_s	r0,r0,4
 	asr_s	r2,r2,3

arch/arm/boot/dts/at91sam9n12ek.dts+2−2

@@ -14,11 +14,11 @@ · 13 unmodified lines
14	compatible = "atmel,at91sam9n12ek", "atmel,at91sam9n12", "atmel,at91sam9";	14	compatible = "atmel,at91sam9n12ek", "atmel,at91sam9n12", "atmel,at91sam9";
15		15
16	chosen {	16	chosen {
17	bootargs = "mem=128M console=ttyS0,115200 root=/dev/mtdblock1 rw rootfstype=jffs2";	17	bootargs = "console=ttyS0,115200 root=/dev/mtdblock1 rw rootfstype=jffs2";
18	};	18	};
19		19
20	memory {	20	memory {
21	reg = <0x20000000 0x10000000>;	21	reg = <0x20000000 0x8000000>;
22	};	22	};
23		23
24	clocks {	24	clocks {

arch/arm/boot/dts/at91sam9x5ek.dtsi+3−2

 		usb0: ohci@00600000 {
 			status = "okay";
-			num-ports = <2>;
+			num-ports = <3>;
-			atmel,vbus-gpio = <&pioD 19 GPIO_ACTIVE_LOW
+			atmel,vbus-gpio = <0 /* &pioD 18 GPIO_ACTIVE_LOW *//* Activate to have access to port A */
+					   &pioD 19 GPIO_ACTIVE_LOW
 					   &pioD 20 GPIO_ACTIVE_LOW
 					  >;
 		};

arch/arm/boot/dts/tegra20-seaboard.dts+2−0

@@ -830,6 +830,8 @@ · 829 unmodified lines
830	regulator-max-microvolt = <5000000>;	830	regulator-max-microvolt = <5000000>;
831	enable-active-high;	831	enable-active-high;
832	gpio = <&gpio 24 0>; /* PD0 */	832	gpio = <&gpio 24 0>; /* PD0 */
		833	regulator-always-on;
		834	regulator-boot-on;
833	};	835	};
834	};	836	};
835		837

arch/arm/boot/dts/tegra20-trimslice.dts+2−0

@@ -412,6 +412,8 @@ · 411 unmodified lines
412	regulator-max-microvolt = <5000000>;	412	regulator-max-microvolt = <5000000>;
413	enable-active-high;	413	enable-active-high;
414	gpio = <&gpio 170 0>; /* PV2 */	414	gpio = <&gpio 170 0>; /* PV2 */
		415	regulator-always-on;
		416	regulator-boot-on;
415	};	417	};
416	};	418	};
417		419

arch/arm/boot/dts/tegra20-whistler.dts+4−0

 			regulator-max-microvolt = <5000000>;
 			enable-active-high;
 			gpio = <&tca6416 0 0>; /* GPIO_PMU0 */
+			regulator-always-on;
+			regulator-boot-on;
 		};
 		vbus3_reg: regulator@3 {
 			regulator-max-microvolt = <5000000>;
 			enable-active-high;
 			gpio = <&tca6416 1 0>; /* GPIO_PMU1 */
+			regulator-always-on;
+			regulator-boot-on;
 		};
 	};

arch/arm/include/asm/smp_plat.h+3−0

@@ -88,4 +88,7 @@ static inline u32 mpidr_hash_size(void) · 87 unmodified lines
88	{	88	{
89	return 1 << mpidr_hash.bits;	89	return 1 << mpidr_hash.bits;
90	}	90	}
		91
		92	extern int platform_can_cpu_hotplug(void);
		93
91	#endif	94	#endif

arch/arm/include/asm/spinlock.h+31−20

@@ -107,7 +107,7 @@ static inline int arch_spin_trylock(arch_spinlock_t *lock) · 106 unmodified lines
107	" subs %1, %0, %0, ror #16\n"	107	" subs %1, %0, %0, ror #16\n"
108	" addeq %0, %0, %4\n"	108	" addeq %0, %0, %4\n"
109	" strexeq %2, %0, [%3]"	109	" strexeq %2, %0, [%3]"
110	: "=&r" (slock), "=&r" (contended), "=r" (res)	110	: "=&r" (slock), "=&r" (contended), "=&r" (res)
111	: "r" (&lock->slock), "I" (1 << TICKET_SHIFT)	111	: "r" (&lock->slock), "I" (1 << TICKET_SHIFT)
112	: "cc");	112	: "cc");
113	} while (res);	113	} while (res);
@@ -168,17 +168,20 @@ static inline void arch_write_lock(arch_rwlock_t *rw) · 54 unmodified lines
168		168
169	static inline int arch_write_trylock(arch_rwlock_t *rw)	169	static inline int arch_write_trylock(arch_rwlock_t *rw)
170	{	170	{
171	unsigned long tmp;	171	unsigned long contended, res;
172		172
173	__asm__ __volatile__(	173	do {
174	" ldrex %0, [%1]\n"	174	__asm__ __volatile__(
175	" teq %0, #0\n"	175	" ldrex %0, [%2]\n"
176	" strexeq %0, %2, [%1]"	176	" mov %1, #0\n"
177	: "=&r" (tmp)	177	" teq %0, #0\n"
178	: "r" (&rw->lock), "r" (0x80000000)	178	" strexeq %1, %3, [%2]"
179	: "cc");	179	: "=&r" (contended), "=&r" (res)
		180	: "r" (&rw->lock), "r" (0x80000000)
		181	: "cc");
		182	} while (res);
180		183
181	if (tmp == 0) {	184	if (!contended) {
182	smp_mb();	185	smp_mb();
183	return 1;	186	return 1;
184	} else {	187	} else {
@@ -254,18 +257,26 @@ static inline void arch_read_unlock(arch_rwlock_t *rw) · 69 unmodified lines
254		257
255	static inline int arch_read_trylock(arch_rwlock_t *rw)	258	static inline int arch_read_trylock(arch_rwlock_t *rw)
256	{	259	{
257	unsigned long tmp, tmp2 = 1;	260	unsigned long contended, res;
258		261
259	__asm__ __volatile__(	262	do {
260	" ldrex %0, [%2]\n"	263	__asm__ __volatile__(
261	" adds %0, %0, #1\n"	264	" ldrex %0, [%2]\n"
262	" strexpl %1, %0, [%2]\n"	265	" mov %1, #0\n"
263	: "=&r" (tmp), "+r" (tmp2)	266	" adds %0, %0, #1\n"
264	: "r" (&rw->lock)	267	" strexpl %1, %0, [%2]"
265	: "cc");	268	: "=&r" (contended), "=&r" (res)
		269	: "r" (&rw->lock)
		270	: "cc");
		271	} while (res);
266		272
267	smp_mb();	273	/* If the lock is negative, then it is already held for write. */
268	return tmp2 == 0;	274	if (contended < 0x80000000) {
		275	smp_mb();
		276	return 1;
		277	} else {
		278	return 0;
		279	}
269	}	280	}
270		281
271	/* read_can_lock - would read_trylock() succeed? */	282	/* read_can_lock - would read_trylock() succeed? */

arch/arm/include/asm/tlb.h+5−2

 	struct mm_struct	*mm;
 	unsigned int		fullmm;
 	struct vm_area_struct	*vma;
+	unsigned long		start, end;
 	unsigned long		range_start;
 	unsigned long		range_end;
 	unsigned int		nr;
 }
 static inline void
-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned int fullmm)
+tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
 {
 	tlb->mm = mm;
-	tlb->fullmm = fullmm;
+	tlb->fullmm = !(start | (end+1));
+	tlb->start = start;
+	tlb->end = end;
 	tlb->vma = NULL;
 	tlb->max = ARRAY_SIZE(tlb->local);
 	tlb->pages = tlb->local;

arch/arm/kernel/entry-armv.S+2−1

@@ -357,7 +357,8 @@ ENDPROC(__pabt_svc) · 356 unmodified lines
357	.endm	357	.endm
358		358
359	.macro kuser_cmpxchg_check	359	.macro kuser_cmpxchg_check
360	#if !defined(CONFIG_CPU_32v6K) && !defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)	360	#if !defined(CONFIG_CPU_32v6K) && defined(CONFIG_KUSER_HELPERS) && \
		361	!defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)
361	#ifndef CONFIG_MMU	362	#ifndef CONFIG_MMU
362	#warning "NPTL on non MMU needs fixing"	363	#warning "NPTL on non MMU needs fixing"
363	#else	364	#else

arch/arm/kernel/fiq.c+3−6

 void set_fiq_handler(void *start, unsigned int length)
 {
-#if defined(CONFIG_CPU_USE_DOMAINS)
-	void *base = (void *)0xffff0000;
-#else
 	void *base = vectors_page;
-#endif
 	unsigned offset = FIQ_OFFSET;
 	memcpy(base + offset, start, length);
+	if (!cache_is_vipt_nonaliasing())
+		flush_icache_range((unsigned long)base + offset, offset +
+				   length);
 	flush_icache_range(0xffff0000 + offset, 0xffff0000 + offset + length);
-	if (!vectors_high())
-		flush_icache_range(offset, offset + length);
 }
 int claim_fiq(struct fiq_handler *f)

arch/arm/kernel/machine_kexec.c+17−4

 #include <asm/mmu_context.h>
 #include <asm/cacheflush.h>
 #include <asm/mach-types.h>
+#include <asm/smp_plat.h>
 #include <asm/system_misc.h>
 extern const unsigned char relocate_new_kernel[];
 	__be32 header;
 	int i, err;
+	/*
+	 * Validate that if the current HW supports SMP, then the SW supports
+	 * and implements CPU hotplug for the current HW. If not, we won't be
+	 * able to kexec reliably, so fail the prepare operation.
+	 */
+	if (num_possible_cpus() > 1 && !platform_can_cpu_hotplug())
+		return -EINVAL;
 	/*
 	 * No segment at default ATAGs address. try to locate
 	 * a dtb using magic.
 	crash_save_cpu(&regs, smp_processor_id());
 	flush_cache_all();
+	set_cpu_online(smp_processor_id(), false);
 	atomic_dec(&waiting_for_crash_ipi);
 	while (1)
 		cpu_relax();
 	unsigned long reboot_code_buffer_phys;
 	void *reboot_code_buffer;
-	if (num_online_cpus() > 1) {
+	/*
-		pr_err("kexec: error: multiple CPUs still online\n");
+	 * This can only happen if machine_shutdown() failed to disable some
-		return;
+	 * CPU, and that can only happen if the checks in
-	}
+	 * machine_kexec_prepare() were not correct. If this fails, we can't
+	 * reliably kexec anyway, so BUG_ON is appropriate.
+	 */
+	BUG_ON(num_online_cpus() > 1);
 	page_list = image->head & PAGE_MASK;

arch/arm/kernel/perf_event.c+9−1

 static int
 armpmu_map_hw_event(const unsigned (*event_map)[PERF_COUNT_HW_MAX], u64 config)
 {
-	int mapping = (*event_map)[config];
+	int mapping;
+	if (config >= PERF_COUNT_HW_MAX)
+		return -EINVAL;
+	mapping = (*event_map)[config];
 	return mapping == HW_OP_UNSUPPORTED ? -ENOENT : mapping;
 }
 	struct arm_pmu *armpmu = to_arm_pmu(event->pmu);
 	struct pmu *leader_pmu = event->group_leader->pmu;
+	if (is_software_event(event))
+		return 1;
 	if (event->pmu != leader_pmu || event->state < PERF_EVENT_STATE_OFF)
 		return 1;

arch/arm/kernel/process.c+1−1

@@ -462,7 +462,7 @@ int in_gate_area_no_mm(unsigned long addr) · 461 unmodified lines
462	{	462	{
463	return in_gate_area(NULL, addr);	463	return in_gate_area(NULL, addr);
464	}	464	}
465	#define is_gate_vma(vma) ((vma) = &gate_vma)	465	#define is_gate_vma(vma) ((vma) == &gate_vma)
466	#else	466	#else
467	#define is_gate_vma(vma) 0	467	#define is_gate_vma(vma) 0
468	#endif	468	#endif

arch/arm/kernel/smp.c+10−0

@@ -145,6 +145,16 @@ int boot_secondary(unsigned int cpu, struct task_struct *idle) · 144 unmodified lines
145	return -ENOSYS;	145	return -ENOSYS;
146	}	146	}
147		147
		148	int platform_can_cpu_hotplug(void)
		149	{
		150	#ifdef CONFIG_HOTPLUG_CPU
		151	if (smp_ops.cpu_kill)
		152	return 1;
		153	#endif
		154
		155	return 0;
		156	}
		157
148	#ifdef CONFIG_HOTPLUG_CPU	158	#ifdef CONFIG_HOTPLUG_CPU
149	static void percpu_timer_stop(void);	159	static void percpu_timer_stop(void);
150		160

arch/arm/kvm/coproc.c+19−7

 #define access_pmintenclr pm_fake
 /* Architected CP15 registers.
- * Important: Must be sorted ascending by CRn, CRM, Op1, Op2
+ * CRn denotes the primary register number, but is copied to the CRm in the
+ * user space API for 64-bit register access in line with the terminology used
+ * in the ARM ARM.
+ * Important: Must be sorted ascending by CRn, CRM, Op1, Op2 and with 64-bit
+ *            registers preceding 32-bit ones.
  */
 static const struct coproc_reg cp15_regs[] = {
 	/* CSSELR: swapped by interrupt.S. */
 			NULL, reset_unknown, c0_CSSELR },
 	/* TTBR0/TTBR1: swapped by interrupt.S. */
-	{ CRm( 2), Op1( 0), is64, NULL, reset_unknown64, c2_TTBR0 },
+	{ CRm64( 2), Op1( 0), is64, NULL, reset_unknown64, c2_TTBR0 },
-	{ CRm( 2), Op1( 1), is64, NULL, reset_unknown64, c2_TTBR1 },
+	{ CRm64( 2), Op1( 1), is64, NULL, reset_unknown64, c2_TTBR1 },
 	/* TTBCR: swapped by interrupt.S. */
 	{ CRn( 2), CRm( 0), Op1( 0), Op2( 2), is32,
 			NULL, reset_unknown, c6_IFAR },
 	/* PAR swapped by interrupt.S */
-	{ CRn( 7), Op1( 0), is64, NULL, reset_unknown64, c7_PAR },
+	{ CRm64( 7), Op1( 0), is64, NULL, reset_unknown64, c7_PAR },
 	/*
 	 * DC{C,I,CI}SW operations:
 			      | KVM_REG_ARM_OPC1_MASK))
 			return false;
 		params->is_64bit = true;
-		params->CRm = ((id & KVM_REG_ARM_CRM_MASK)
+		/* CRm to CRn: see cp15_to_index for details */
+		params->CRn = ((id & KVM_REG_ARM_CRM_MASK)
 			       >> KVM_REG_ARM_CRM_SHIFT);
 		params->Op1 = ((id & KVM_REG_ARM_OPC1_MASK)
 			       >> KVM_REG_ARM_OPC1_SHIFT);
 		params->Op2 = 0;
-		params->CRn = 0;
+		params->CRm = 0;
 		return true;
 	default:
 		return false;
 	if (reg->is_64) {
 		val |= KVM_REG_SIZE_U64;
 		val |= (reg->Op1 << KVM_REG_ARM_OPC1_SHIFT);
-		val |= (reg->CRm << KVM_REG_ARM_CRM_SHIFT);
+		/*
+		 * CRn always denotes the primary coproc. reg. nr. for the
+		 * in-kernel representation, but the user space API uses the
+		 * CRm for the encoding, because it is modelled after the
+		 * MRRC/MCRR instructions: see the ARM ARM rev. c page
+		 * B3-1445
+		 */
+		val |= (reg->CRn << KVM_REG_ARM_CRM_SHIFT);
 	} else {
 		val |= KVM_REG_SIZE_U32;
 		val |= (reg->Op1 << KVM_REG_ARM_OPC1_SHIFT);

arch/arm/kvm/coproc.h+3−0

 		return -1;
 	if (i1->CRn != i2->CRn)
 		return i1->CRn - i2->CRn;
+	if (i1->is_64 != i2->is_64)
+		return i2->is_64 - i1->is_64;
 	if (i1->CRm != i2->CRm)
 		return i1->CRm - i2->CRm;
 	if (i1->Op1 != i2->Op1)
 #define CRn(_x)		.CRn = _x
 #define CRm(_x) 	.CRm = _x
+#define CRm64(_x)       .CRn = _x, .CRm = 0
 #define Op1(_x) 	.Op1 = _x
 #define Op2(_x) 	.Op2 = _x
 #define is64		.is_64 = true

arch/arm/kvm/coproc_a15.c+5−1

 /*
  * A15-specific CP15 registers.
- * Important: Must be sorted ascending by CRn, CRM, Op1, Op2
+ * CRn denotes the primary register number, but is copied to the CRm in the
+ * user space API for 64-bit register access in line with the terminology used
+ * in the ARM ARM.
+ * Important: Must be sorted ascending by CRn, CRM, Op1, Op2 and with 64-bit
+ *            registers preceding 32-bit ones.
  */
 static const struct coproc_reg a15_regs[] = {
 	/* MPIDR: we use VMPIDR for guest access. */

arch/arm/kvm/mmio.c+2−1

@@ -63,7 +63,8 @@ int kvm_handle_mmio_return(struct kvm_vcpu vcpu, struct kvm_run run) · 62 unmodified lines
63	static int decode_hsr(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,	63	static int decode_hsr(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,
64	struct kvm_exit_mmio *mmio)	64	struct kvm_exit_mmio *mmio)
65	{	65	{
66	unsigned long rt, len;	66	unsigned long rt;
		67	int len;
67	bool is_write, sign_extend;	68	bool is_write, sign_extend;
68		69
69	if (kvm_vcpu_dabt_isextabt(vcpu)) {	70	if (kvm_vcpu_dabt_isextabt(vcpu)) {

arch/arm/kvm/mmu.c+15−21

 	return p;
 }
+static bool page_empty(void *ptr)
+{
+	struct page *ptr_page = virt_to_page(ptr);
+	return page_count(ptr_page) == 1;
+}
 static void clear_pud_entry(struct kvm *kvm, pud_t *pud, phys_addr_t addr)
 {
 	pmd_t *pmd_table = pmd_offset(pud, 0);
 	put_page(virt_to_page(pmd));
 }
-static bool pmd_empty(pmd_t *pmd)
-{
-	struct page *pmd_page = virt_to_page(pmd);
-	return page_count(pmd_page) == 1;
-}
 static void clear_pte_entry(struct kvm *kvm, pte_t *pte, phys_addr_t addr)
 {
 	if (pte_present(*pte)) {
 	}
 }
-static bool pte_empty(pte_t *pte)
-{
-	struct page *pte_page = virt_to_page(pte);
-	return page_count(pte_page) == 1;
-}
 static void unmap_range(struct kvm *kvm, pgd_t *pgdp,
 			unsigned long long start, u64 size)
 {
 	pmd_t *pmd;
 	pte_t *pte;
 	unsigned long long addr = start, end = start + size;
-	u64 range;
+	u64 next;
 	while (addr < end) {
 		pgd = pgdp + pgd_index(addr);
 		pud = pud_offset(pgd, addr);
 		if (pud_none(*pud)) {
-			addr += PUD_SIZE;
+			addr = pud_addr_end(addr, end);
 			continue;
 		}
 		pmd = pmd_offset(pud, addr);
 		if (pmd_none(*pmd)) {
-			addr += PMD_SIZE;
+			addr = pmd_addr_end(addr, end);
 			continue;
 		}
 		pte = pte_offset_kernel(pmd, addr);
 		clear_pte_entry(kvm, pte, addr);
-		range = PAGE_SIZE;
+		next = addr + PAGE_SIZE;
 		/* If we emptied the pte, walk back up the ladder */
-		if (pte_empty(pte)) {
+		if (page_empty(pte)) {
 			clear_pmd_entry(kvm, pmd, addr);
-			range = PMD_SIZE;
+			next = pmd_addr_end(addr, end);
-			if (pmd_empty(pmd)) {
+			if (page_empty(pmd) && !page_empty(pud)) {
 				clear_pud_entry(kvm, pud, addr);
-				range = PUD_SIZE;
+				next = pud_addr_end(addr, end);
 			}
 		}
-		addr += range;
+		addr = next;
 	}
 }

arch/arm/mach-at91/at91sam9x5.c+2−0

 	CLKDEV_CON_DEV_ID("usart", "f8020000.serial", &usart1_clk),
 	CLKDEV_CON_DEV_ID("usart", "f8024000.serial", &usart2_clk),
 	CLKDEV_CON_DEV_ID("usart", "f8028000.serial", &usart3_clk),
+	CLKDEV_CON_DEV_ID("usart", "f8040000.serial", &uart0_clk),
+	CLKDEV_CON_DEV_ID("usart", "f8044000.serial", &uart1_clk),
 	CLKDEV_CON_DEV_ID("t0_clk", "f8008000.timer", &tcb0_clk),
 	CLKDEV_CON_DEV_ID("t0_clk", "f800c000.timer", &tcb0_clk),
 	CLKDEV_CON_DEV_ID("mci_clk", "f0008000.mmc", &mmc0_clk),

arch/arm/mach-davinci/board-dm355-leopard.c+1−0

@@ -75,6 +75,7 @@ static struct davinci_nand_pdata davinci_nand_data = { · 74 unmodified lines
75	.parts = davinci_nand_partitions,	75	.parts = davinci_nand_partitions,
76	.nr_parts = ARRAY_SIZE(davinci_nand_partitions),	76	.nr_parts = ARRAY_SIZE(davinci_nand_partitions),
77	.ecc_mode = NAND_ECC_HW_SYNDROME,	77	.ecc_mode = NAND_ECC_HW_SYNDROME,
		78	.ecc_bits = 4,
78	.bbt_options = NAND_BBT_USE_FLASH,	79	.bbt_options = NAND_BBT_USE_FLASH,
79	};	80	};
80		81

arch/arm/mach-davinci/board-dm644x-evm.c+1−0

@@ -153,6 +153,7 @@ static struct davinci_nand_pdata davinci_evm_nandflash_data = { · 152 unmodified lines
153	.parts = davinci_evm_nandflash_partition,	153	.parts = davinci_evm_nandflash_partition,
154	.nr_parts = ARRAY_SIZE(davinci_evm_nandflash_partition),	154	.nr_parts = ARRAY_SIZE(davinci_evm_nandflash_partition),
155	.ecc_mode = NAND_ECC_HW,	155	.ecc_mode = NAND_ECC_HW,
		156	.ecc_bits = 1,
156	.bbt_options = NAND_BBT_USE_FLASH,	157	.bbt_options = NAND_BBT_USE_FLASH,
157	.timing = &davinci_evm_nandflash_timing,	158	.timing = &davinci_evm_nandflash_timing,
158	};	159	};

arch/arm/mach-davinci/board-dm646x-evm.c+1−0

@@ -90,6 +90,7 @@ static struct davinci_nand_pdata davinci_nand_data = { · 89 unmodified lines
90	.parts = davinci_nand_partitions,	90	.parts = davinci_nand_partitions,
91	.nr_parts = ARRAY_SIZE(davinci_nand_partitions),	91	.nr_parts = ARRAY_SIZE(davinci_nand_partitions),
92	.ecc_mode = NAND_ECC_HW,	92	.ecc_mode = NAND_ECC_HW,
		93	.ecc_bits = 1,
93	.options = 0,	94	.options = 0,
94	};	95	};
95		96

arch/arm/mach-davinci/board-neuros-osd2.c+1−0

@@ -88,6 +88,7 @@ static struct davinci_nand_pdata davinci_ntosd2_nandflash_data = { · 87 unmodified lines
88	.parts = davinci_ntosd2_nandflash_partition,	88	.parts = davinci_ntosd2_nandflash_partition,
89	.nr_parts = ARRAY_SIZE(davinci_ntosd2_nandflash_partition),	89	.nr_parts = ARRAY_SIZE(davinci_ntosd2_nandflash_partition),
90	.ecc_mode = NAND_ECC_HW,	90	.ecc_mode = NAND_ECC_HW,
		91	.ecc_bits = 1,
91	.bbt_options = NAND_BBT_USE_FLASH,	92	.bbt_options = NAND_BBT_USE_FLASH,
92	};	93	};
93		94

arch/arm/mach-omap2/board-n8x0.c+0−4

 };
 static struct musb_hdrc_platform_data tusb_data = {
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
 	.mode		= MUSB_OTG,
-#else
-	.mode		= MUSB_HOST,
-#endif
 	.set_power	= tusb_set_power,
 	.min_power	= 25,	/* x2 = 50 mA drawn from VBUS as peripheral */
 	.power		= 100,	/* Max 100 mA VBUS for host mode */

arch/arm/mach-omap2/board-rx51.c+1−1

@@ -85,7 +85,7 @@ static struct omap_board_mux board_mux[] __initdata = { · 84 unmodified lines
85		85
86	static struct omap_musb_board_data musb_board_data = {	86	static struct omap_musb_board_data musb_board_data = {
87	.interface_type = MUSB_INTERFACE_ULPI,	87	.interface_type = MUSB_INTERFACE_ULPI,
88	.mode = MUSB_PERIPHERAL,	88	.mode = MUSB_OTG,
89	.power = 0,	89	.power = 0,
90	};	90	};
91		91

arch/arm/mach-omap2/usb-musb.c+1−4

@@ -38,11 +38,8 @@ static struct musb_hdrc_config musb_config = { · 37 unmodified lines
38	};	38	};
39		39
40	static struct musb_hdrc_platform_data musb_plat = {	40	static struct musb_hdrc_platform_data musb_plat = {
41	#ifdef CONFIG_USB_GADGET_MUSB_HDRC
42	.mode = MUSB_OTG,	41	.mode = MUSB_OTG,
43	#else	42
44	.mode = MUSB_HOST,
45	#endif
46	/* .clock is set dynamically */	43	/* .clock is set dynamically */
47	.config = &musb_config,	44	.config = &musb_config,
48		45

arch/arm/mm/Kconfig+6−3

 	  the CPU type fitted to the system.  This permits binaries to be
 	  run on ARMv4 through to ARMv7 without modification.
+	  See Documentation/arm/kernel_user_helpers.txt for details.
 	  However, the fixed address nature of these helpers can be used
 	  by ROP (return orientated programming) authors when creating
 	  exploits.
 	  If all of the binaries and libraries which run on your platform
 	  are built specifically for your platform, and make no use of
-	  these helpers, then you can turn this option off.  However,
+	  these helpers, then you can turn this option off to hinder
-	  when such an binary or library is run, it will receive a SIGILL
+	  such exploits. However, in that case, if a binary or library
-	  signal, which will terminate the program.
+	  relying on those helpers is run, it will receive a SIGILL signal,
+	  which will terminate the program.
 	  Say N here only if you are absolutely certain that you do not
 	  need these helpers; otherwise, the safe option is to say Y.

arch/arm/plat-samsung/init.c+3−2

 	printk("CPU %s (id 0x%08lx)\n", cpu->name, idcode);
-	if (cpu->map_io == NULL || cpu->init == NULL) {
+	if (cpu->init == NULL) {
 		printk(KERN_ERR "CPU %s support not enabled\n", cpu->name);
 		panic("Unsupported Samsung CPU");
 	}
-	cpu->map_io();
+	if (cpu->map_io)
+		cpu->map_io();
 }
 /* s3c24xx_init_clocks

arch/arm/xen/enlighten.c+1−0

@@ -170,6 +170,7 @@ static void __init xen_percpu_init(void *unused) · 169 unmodified lines
170	per_cpu(xen_vcpu, cpu) = vcpup;	170	per_cpu(xen_vcpu, cpu) = vcpup;
171		171
172	enable_percpu_irq(xen_events_irq, 0);	172	enable_percpu_irq(xen_events_irq, 0);
		173	put_cpu();
173	}	174	}
174		175
175	static void xen_restart(enum reboot_mode reboot_mode, const char *cmd)	176	static void xen_restart(enum reboot_mode reboot_mode, const char *cmd)

arch/arm64/include/asm/kvm_asm.h+10−7

 #define	TPIDR_EL1	18	/* Thread ID, Privileged */
 #define	AMAIR_EL1	19	/* Aux Memory Attribute Indirection Register */
 #define	CNTKCTL_EL1	20	/* Timer Control Register (EL1) */
+#define	PAR_EL1		21	/* Physical Address Register */
 /* 32bit specific registers. Keep them at the end of the range */
-#define	DACR32_EL2	21	/* Domain Access Control Register */
+#define	DACR32_EL2	22	/* Domain Access Control Register */
-#define	IFSR32_EL2	22	/* Instruction Fault Status Register */
+#define	IFSR32_EL2	23	/* Instruction Fault Status Register */
-#define	FPEXC32_EL2	23	/* Floating-Point Exception Control Register */
+#define	FPEXC32_EL2	24	/* Floating-Point Exception Control Register */
-#define	DBGVCR32_EL2	24	/* Debug Vector Catch Register */
+#define	DBGVCR32_EL2	25	/* Debug Vector Catch Register */
-#define	TEECR32_EL1	25	/* ThumbEE Configuration Register */
+#define	TEECR32_EL1	26	/* ThumbEE Configuration Register */
-#define	TEEHBR32_EL1	26	/* ThumbEE Handler Base Register */
+#define	TEEHBR32_EL1	27	/* ThumbEE Handler Base Register */
-#define	NR_SYS_REGS	27
+#define	NR_SYS_REGS	28
 /* 32bit mapping */
 #define c0_MPIDR	(MPIDR_EL1 * 2)	/* MultiProcessor ID Register */
 #define c5_AIFSR	(AFSR1_EL1 * 2)	/* Auxiliary Instr Fault Status R */
 #define c6_DFAR		(FAR_EL1 * 2)	/* Data Fault Address Register */
 #define c6_IFAR		(c6_DFAR + 1)	/* Instruction Fault Address Register */
+#define c7_PAR		(PAR_EL1 * 2)	/* Physical Address Register */
+#define c7_PAR_high	(c7_PAR + 1)	/* PAR top 32 bits */
 #define c10_PRRR	(MAIR_EL1 * 2)	/* Primary Region Remap Register */
 #define c10_NMRR	(c10_PRRR + 1)	/* Normal Memory Remap Register */
 #define c12_VBAR	(VBAR_EL1 * 2)	/* Vector Base Address Register */

arch/arm64/include/asm/kvm_host.h+1−1

@@ -129,7 +129,7 @@ struct kvm_vcpu_arch { · 128 unmodified lines
129	struct kvm_mmu_memory_cache mmu_page_cache;	129	struct kvm_mmu_memory_cache mmu_page_cache;
130		130
131	/* Target CPU and feature flags */	131	/* Target CPU and feature flags */
132	u32 target;	132	int target;
133	DECLARE_BITMAP(features, KVM_VCPU_MAX_FEATURES);	133	DECLARE_BITMAP(features, KVM_VCPU_MAX_FEATURES);
134		134
135	/* Detect first run of a vcpu */	135	/* Detect first run of a vcpu */

arch/arm64/include/asm/tlb.h+5−2

 	struct mm_struct	*mm;
 	unsigned int		fullmm;
 	struct vm_area_struct	*vma;
+	unsigned long		start, end;
 	unsigned long		range_start;
 	unsigned long		range_end;
 	unsigned int		nr;
 }
 static inline void
-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned int fullmm)
+tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
 {
 	tlb->mm = mm;
-	tlb->fullmm = fullmm;
+	tlb->fullmm = !(start | (end+1));
+	tlb->start = start;
+	tlb->end = end;
 	tlb->vma = NULL;
 	tlb->max = ARRAY_SIZE(tlb->local);
 	tlb->pages = tlb->local;

arch/arm64/kernel/perf_event.c+9−1

 static int
 armpmu_map_event(const unsigned (*event_map)[PERF_COUNT_HW_MAX], u64 config)
 {
-	int mapping = (*event_map)[config];
+	int mapping;
+	if (config >= PERF_COUNT_HW_MAX)
+		return -EINVAL;
+	mapping = (*event_map)[config];
 	return mapping == HW_OP_UNSUPPORTED ? -ENOENT : mapping;
 }
 	struct hw_perf_event fake_event = event->hw;
 	struct pmu *leader_pmu = event->group_leader->pmu;
+	if (is_software_event(event))
+		return 1;
 	if (event->pmu != leader_pmu || event->state <= PERF_EVENT_STATE_OFF)
 		return 1;

arch/arm64/kvm/hyp.S+13−0

 	mrs	x21,	tpidr_el1
 	mrs	x22, 	amair_el1
 	mrs	x23, 	cntkctl_el1
+	mrs	x24,	par_el1
 	stp	x4, x5, [x3]
 	stp	x6, x7, [x3, #16]
 	stp	x18, x19, [x3, #112]
 	stp	x20, x21, [x3, #128]
 	stp	x22, x23, [x3, #144]
+	str	x24, [x3, #160]
 .endm
 .macro restore_sysregs
 	ldp	x18, x19, [x3, #112]
 	ldp	x20, x21, [x3, #128]
 	ldp	x22, x23, [x3, #144]
+	ldr	x24, [x3, #160]
 	msr	vmpidr_el2,	x4
 	msr	csselr_el1,	x5
 	msr	tpidr_el1,	x21
 	msr	amair_el1,	x22
 	msr	cntkctl_el1,	x23
+	msr	par_el1,	x24
 .endm
 .macro skip_32bit_state tmp, target
 // void __kvm_tlb_flush_vmid_ipa(struct kvm *kvm, phys_addr_t ipa);
 ENTRY(__kvm_tlb_flush_vmid_ipa)
+	dsb	ishst
 	kern_hyp_va	x0
 	ldr	x2, [x0, #KVM_VTTBR]
 	msr	vttbr_el2, x2
 ENDPROC(__kvm_tlb_flush_vmid_ipa)
 ENTRY(__kvm_flush_vm_context)
+	dsb	ishst
 	tlbi	alle1is
 	ic	ialluis
 	dsb	sy
 	 */
 	tbnz	x1, #7, 1f	// S1PTW is set
+	/* Preserve PAR_EL1 */
+	mrs	x3, par_el1
+	push	x3, xzr
 	/*
 	 * Permission fault, HPFAR_EL2 is invalid.
 	 * Resolve the IPA the hard way using the guest VA.
 	/* Read result */
 	mrs	x3, par_el1
+	pop	x0, xzr			// Restore PAR_EL1 from the stack
+	msr	par_el1, x0
 	tbnz	x3, #0, 3f		// Bail out if we failed the translation
 	ubfx	x3, x3, #12, #36	// Extract IPA
 	lsl	x3, x3, #4		// and present it like HPFAR

arch/arm64/kvm/sys_regs.c+3−0

 	/* FAR_EL1 */
 	{ Op0(0b11), Op1(0b000), CRn(0b0110), CRm(0b0000), Op2(0b000),
 	  NULL, reset_unknown, FAR_EL1 },
+	/* PAR_EL1 */
+	{ Op0(0b11), Op1(0b000), CRn(0b0111), CRm(0b0100), Op2(0b000),
+	  NULL, reset_unknown, PAR_EL1 },
 	/* PMINTENSET_EL1 */
 	{ Op0(0b11), Op1(0b000), CRn(0b1001), CRm(0b1110), Op2(0b001),

arch/hexagon/Kconfig+1−0

@@ -158,6 +158,7 @@ source "kernel/Kconfig.hz" · 157 unmodified lines
158	endmenu	158	endmenu
159		159
160	source "init/Kconfig"	160	source "init/Kconfig"
		161	source "kernel/Kconfig.freezer"
161	source "drivers/Kconfig"	162	source "drivers/Kconfig"
162	source "fs/Kconfig"	163	source "fs/Kconfig"
163		164

arch/ia64/include/asm/tlb.h+6−3

  * unmapping a portion of the virtual address space, these hooks are called according to
  * the following template:
  *
- *	tlb <- tlb_gather_mmu(mm, full_mm_flush);	// start unmap for address space MM
+ *	tlb <- tlb_gather_mmu(mm, start, end);		// start unmap for address space MM
  *	{
  *	  for each vma that needs a shootdown do {
  *	    tlb_start_vma(tlb, vma);
 	unsigned int		max;
 	unsigned char		fullmm;		/* non-zero means full mm flush */
 	unsigned char		need_flush;	/* really unmapped some PTEs? */
+	unsigned long		start, end;
 	unsigned long		start_addr;
 	unsigned long		end_addr;
 	struct page		**pages;
 static inline void
-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned int full_mm_flush)
+tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
 {
 	tlb->mm = mm;
 	tlb->max = ARRAY_SIZE(tlb->local);
 	tlb->pages = tlb->local;
 	tlb->nr = 0;
-	tlb->fullmm = full_mm_flush;
+	tlb->fullmm = !(start | (end+1));
+	tlb->start = start;
+	tlb->end = end;
 	tlb->start_addr = ~0UL;
 }

arch/m68k/emu/natfeat.c+19−4

 #include <asm/machdep.h>
 #include <asm/natfeat.h>
+extern long nf_get_id2(const char *feature_name);
 asm("\n"
-"	.global nf_get_id,nf_call\n"
+"	.global nf_get_id2,nf_call\n"
-"nf_get_id:\n"
+"nf_get_id2:\n"
 "	.short	0x7300\n"
 "	rts\n"
 "nf_call:\n"
 "1:	moveq.l	#0,%d0\n"
 "	rts\n"
 "	.section __ex_table,\"a\"\n"
-"	.long	nf_get_id,1b\n"
+"	.long	nf_get_id2,1b\n"
 "	.long	nf_call,1b\n"
 "	.previous");
-EXPORT_SYMBOL_GPL(nf_get_id);
 EXPORT_SYMBOL_GPL(nf_call);
+long nf_get_id(const char *feature_name)
+{
+	/* feature_name may be in vmalloc()ed memory, so make a copy */
+	char name_copy[32];
+	size_t n;
+	n = strlcpy(name_copy, feature_name, sizeof(name_copy));
+	if (n >= sizeof(name_copy))
+		return 0;
+	return nf_get_id2(name_copy);
+}
+EXPORT_SYMBOL_GPL(nf_get_id);
 void nfprint(const char *fmt, ...)
 {
 	static char buf[256];

arch/m68k/include/asm/div64.h+5−4

 		unsigned long long n64;				\
 	} __n;							\
 	unsigned long __rem, __upper;				\
+	unsigned long __base = (base);				\
 								\
 	__n.n64 = (n);						\
 	if ((__upper = __n.n32[0])) {				\
 		asm ("divul.l %2,%1:%0"				\
-			: "=d" (__n.n32[0]), "=d" (__upper)	\
+		     : "=d" (__n.n32[0]), "=d" (__upper)	\
-			: "d" (base), "0" (__n.n32[0]));	\
+		     : "d" (__base), "0" (__n.n32[0]));		\
 	}							\
 	asm ("divu.l %2,%1:%0"					\
-		: "=d" (__n.n32[1]), "=d" (__rem)		\
+	     : "=d" (__n.n32[1]), "=d" (__rem)			\
-		: "d" (base), "1" (__upper), "0" (__n.n32[1]));	\
+	     : "d" (__base), "1" (__upper), "0" (__n.n32[1]));	\
 	(n) = __n.n64;						\
 	__rem;							\
 })

arch/microblaze/Kconfig+1−1

@@ -28,7 +28,7 @@ config MICROBLAZE · 27 unmodified lines
28	select GENERIC_CLOCKEVENTS	28	select GENERIC_CLOCKEVENTS
29	select GENERIC_IDLE_POLL_SETUP	29	select GENERIC_IDLE_POLL_SETUP
30	select MODULES_USE_ELF_RELA	30	select MODULES_USE_ELF_RELA
31	select CLONE_BACKWARDS	31	select CLONE_BACKWARDS3
32		32
33	config SWAP	33	config SWAP
34	def_bool n	34	def_bool n

arch/mips/math-emu/cp1emu.c+26−0

@@ -803,6 +803,32 @@ static int isBranchInstr(struct pt_regs *regs, struct mm_decoded_insn dec_insn, · 802 unmodified lines
803	dec_insn.next_pc_inc;	803	dec_insn.next_pc_inc;
804	return 1;	804	return 1;
805	break;	805	break;
		806	#ifdef CONFIG_CPU_CAVIUM_OCTEON
		807	case lwc2_op: /* This is bbit0 on Octeon */
		808	if ((regs->regs[insn.i_format.rs] & (1ull<<insn.i_format.rt)) == 0)
		809	*contpc = regs->cp0_epc + 4 + (insn.i_format.simmediate << 2);
		810	else
		811	*contpc = regs->cp0_epc + 8;
		812	return 1;
		813	case ldc2_op: /* This is bbit032 on Octeon */
		814	if ((regs->regs[insn.i_format.rs] & (1ull<<(insn.i_format.rt + 32))) == 0)
		815	*contpc = regs->cp0_epc + 4 + (insn.i_format.simmediate << 2);
		816	else
		817	*contpc = regs->cp0_epc + 8;
		818	return 1;
		819	case swc2_op: /* This is bbit1 on Octeon */
		820	if (regs->regs[insn.i_format.rs] & (1ull<<insn.i_format.rt))
		821	*contpc = regs->cp0_epc + 4 + (insn.i_format.simmediate << 2);
		822	else
		823	*contpc = regs->cp0_epc + 8;
		824	return 1;
		825	case sdc2_op: /* This is bbit132 on Octeon */
		826	if (regs->regs[insn.i_format.rs] & (1ull<<(insn.i_format.rt + 32)))
		827	*contpc = regs->cp0_epc + 4 + (insn.i_format.simmediate << 2);
		828	else
		829	*contpc = regs->cp0_epc + 8;
		830	return 1;
		831	#endif
806	case cop0_op:	832	case cop0_op:
807	case cop1_op:	833	case cop1_op:
808	case cop2_op:	834	case cop2_op:

arch/openrisc/Kconfig+1−0

@@ -55,6 +55,7 @@ config GENERIC_CSUM · 54 unmodified lines
55		55
56	source "init/Kconfig"	56	source "init/Kconfig"
57		57
		58	source "kernel/Kconfig.freezer"
58		59
59	menu "Processor type and features"	60	menu "Processor type and features"
60		61

arch/powerpc/Kconfig+1−0

@@ -979,6 +979,7 @@ config RELOCATABLE · 978 unmodified lines
979	must live at a different physical address than the primary	979	must live at a different physical address than the primary
980	kernel.	980	kernel.
981		981
		982	# This value must have zeroes in the bottom 60 bits otherwise lots will break
982	config PAGE_OFFSET	983	config PAGE_OFFSET
983	hex	984	hex
984	default "0xc000000000000000"	985	default "0xc000000000000000"

arch/powerpc/include/asm/page.h+10−0

@@ -211,9 +211,19 @@ extern long long virt_phys_offset; · 210 unmodified lines
211	#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + VIRT_PHYS_OFFSET))	211	#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + VIRT_PHYS_OFFSET))
212	#define __pa(x) ((unsigned long)(x) - VIRT_PHYS_OFFSET)	212	#define __pa(x) ((unsigned long)(x) - VIRT_PHYS_OFFSET)
213	#else	213	#else
		214	#ifdef CONFIG_PPC64
		215	/*
		216	* gcc miscompiles (unsigned long)(&static_var) - PAGE_OFFSET
		217	* with -mcmodel=medium, so we use & and \| instead of - and + on 64-bit.
		218	*/
		219	#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) \| PAGE_OFFSET))
		220	#define __pa(x) ((unsigned long)(x) & 0x0fffffffffffffffUL)
		221
		222	#else /* 32-bit, non book E */
214	#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + PAGE_OFFSET - MEMORY_START))	223	#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + PAGE_OFFSET - MEMORY_START))
215	#define __pa(x) ((unsigned long)(x) - PAGE_OFFSET + MEMORY_START)	224	#define __pa(x) ((unsigned long)(x) - PAGE_OFFSET + MEMORY_START)
216	#endif	225	#endif
		226	#endif
217		227
218	/*	228	/*
219	* Unfortunately the PLT is in the BSS in the PPC32 ELF ABI,	229	* Unfortunately the PLT is in the BSS in the PPC32 ELF ABI,

arch/powerpc/kernel/lparcfg.c+9−13

@@ -35,7 +35,13 @@ · 34 unmodified lines
35	#include <asm/vdso_datapage.h>	35	#include <asm/vdso_datapage.h>
36	#include <asm/vio.h>	36	#include <asm/vio.h>
37	#include <asm/mmu.h>	37	#include <asm/mmu.h>
		38	#include <asm/machdep.h>
38		39
		40
		41	/*
		42	* This isn't a module but we expose that to userspace
		43	* via /proc so leave the definitions here
		44	*/
39	#define MODULE_VERS "1.9"	45	#define MODULE_VERS "1.9"
40	#define MODULE_NAME "lparcfg"	46	#define MODULE_NAME "lparcfg"
41		47
@@ -418,7 +424,8 @@ static void parse_em_data(struct seq_file *m) · 376 unmodified lines
418	{	424	{
419	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];	425	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
420		426
421	if (plpar_hcall(H_GET_EM_PARMS, retbuf) == H_SUCCESS)	427	if (firmware_has_feature(FW_FEATURE_LPAR) &&
		428	plpar_hcall(H_GET_EM_PARMS, retbuf) == H_SUCCESS)
422	seq_printf(m, "power_mode_data=%016lx\n", retbuf[0]);	429	seq_printf(m, "power_mode_data=%016lx\n", retbuf[0]);
423	}	430	}
424		431
@@ -677,7 +684,6 @@ static int lparcfg_open(struct inode inode, struct file file) · 252 unmodified lines
677	}	684	}
678		685
679	static const struct file_operations lparcfg_fops = {	686	static const struct file_operations lparcfg_fops = {
680	.owner = THIS_MODULE,
681	.read = seq_read,	687	.read = seq_read,
682	.write = lparcfg_write,	688	.write = lparcfg_write,
683	.open = lparcfg_open,	689	.open = lparcfg_open,
@@ -699,14 +705,4 @@ static int __init lparcfg_init(void) · 15 unmodified lines
699	}	705	}
700	return 0;	706	return 0;
701	}	707	}
702		708	machine_device_initcall(pseries, lparcfg_init);
703	static void __exit lparcfg_cleanup(void)
704	{
705	remove_proc_subtree("powerpc/lparcfg", NULL);
706	}
707
708	module_init(lparcfg_init);
709	module_exit(lparcfg_cleanup);
710	MODULE_DESCRIPTION("Interface for LPAR configuration data");
711	MODULE_AUTHOR("Dave Engebretsen");
712	MODULE_LICENSE("GPL");

arch/s390/include/asm/tlb.h+6−2

 	struct mm_struct *mm;
 	struct mmu_table_batch *batch;
 	unsigned int fullmm;
+	unsigned long start, end;
 };
 struct mmu_table_batch {
 static inline void tlb_gather_mmu(struct mmu_gather *tlb,
 				  struct mm_struct *mm,
-				  unsigned int full_mm_flush)
+				  unsigned long start,
+				  unsigned long end)
 {
 	tlb->mm = mm;
-	tlb->fullmm = full_mm_flush;
+	tlb->start = start;
+	tlb->end = end;
+	tlb->fullmm = !(start | (end+1));
 	tlb->batch = NULL;
 	if (tlb->fullmm)
 		__tlb_flush_mm(mm);

arch/score/Kconfig+2−0

@@ -87,6 +87,8 @@ config STACKTRACE_SUPPORT · 86 unmodified lines
87		87
88	source "init/Kconfig"	88	source "init/Kconfig"
89		89
		90	source "kernel/Kconfig.freezer"
		91
90	config MMU	92	config MMU
91	def_bool y	93	def_bool y
92		94

arch/sh/include/asm/tlb.h+4−2

 }
 static inline void
-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned int full_mm_flush)
+tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
 {
 	tlb->mm = mm;
-	tlb->fullmm = full_mm_flush;
+	tlb->start = start;
+	tlb->end = end;
+	tlb->fullmm = !(start | (end+1));
 	init_tlb_gather(tlb);
 }

arch/um/include/asm/tlb.h+4−2

 }
 static inline void
-tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned int full_mm_flush)
+tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, unsigned long start, unsigned long end)
 {
 	tlb->mm = mm;
-	tlb->fullmm = full_mm_flush;
+	tlb->start = start;
+	tlb->end = end;
+	tlb->fullmm = !(start | (end+1));
 	init_tlb_gather(tlb);
 }

arch/x86/include/asm/bootparam_utils.h+2−2

@@ -35,9 +35,9 @@ static void sanitize_boot_params(struct boot_params *boot_params) · 34 unmodified lines
35	*/	35	*/
36	if (boot_params->sentinel) {	36	if (boot_params->sentinel) {
37	/* fields in boot_params are left uninitialized, clear them */	37	/* fields in boot_params are left uninitialized, clear them */
38	memset(&boot_params->olpc_ofw_header, 0,	38	memset(&boot_params->ext_ramdisk_image, 0,
39	(char *)&boot_params->efi_info -	39	(char *)&boot_params->efi_info -
40	(char *)&boot_params->olpc_ofw_header);	40	(char *)&boot_params->ext_ramdisk_image);
41	memset(&boot_params->kbd_status, 0,	41	memset(&boot_params->kbd_status, 0,
42	(char *)&boot_params->hdr -	42	(char *)&boot_params->hdr -
43	(char *)&boot_params->kbd_status);	43	(char *)&boot_params->kbd_status);

arch/x86/include/asm/microcode_amd.h+1−1

@@ -59,7 +59,7 @@ static inline u16 find_equiv_id(struct equiv_cpu_entry *equiv_cpu_table, · 58 unmodified lines
59		59
60	extern int __apply_microcode_amd(struct microcode_amd *mc_amd);	60	extern int __apply_microcode_amd(struct microcode_amd *mc_amd);
61	extern int apply_microcode_amd(int cpu);	61	extern int apply_microcode_amd(int cpu);
62	extern enum ucode_state load_microcode_amd(int cpu, const u8 *data, size_t size);	62	extern enum ucode_state load_microcode_amd(u8 family, const u8 *data, size_t size);
63		63
64	#ifdef CONFIG_MICROCODE_AMD_EARLY	64	#ifdef CONFIG_MICROCODE_AMD_EARLY
65	#ifdef CONFIG_X86_32	65	#ifdef CONFIG_X86_32

arch/x86/include/asm/pgtable-2level.h+47−1

@@ -55,9 +55,53 @@ static inline pmd_t native_pmdp_get_and_clear(pmd_t *xp) · 54 unmodified lines
55	#define native_pmdp_get_and_clear(xp) native_local_pmdp_get_and_clear(xp)	55	#define native_pmdp_get_and_clear(xp) native_local_pmdp_get_and_clear(xp)
56	#endif	56	#endif
57		57
		58	#ifdef CONFIG_MEM_SOFT_DIRTY
		59
		60	/*
		61	* Bits _PAGE_BIT_PRESENT, _PAGE_BIT_FILE, _PAGE_BIT_SOFT_DIRTY and
		62	* _PAGE_BIT_PROTNONE are taken, split up the 28 bits of offset
		63	* into this range.
		64	*/
		65	#define PTE_FILE_MAX_BITS 28
		66	#define PTE_FILE_SHIFT1 (_PAGE_BIT_PRESENT + 1)
		67	#define PTE_FILE_SHIFT2 (_PAGE_BIT_FILE + 1)
		68	#define PTE_FILE_SHIFT3 (_PAGE_BIT_PROTNONE + 1)
		69	#define PTE_FILE_SHIFT4 (_PAGE_BIT_SOFT_DIRTY + 1)
		70	#define PTE_FILE_BITS1 (PTE_FILE_SHIFT2 - PTE_FILE_SHIFT1 - 1)
		71	#define PTE_FILE_BITS2 (PTE_FILE_SHIFT3 - PTE_FILE_SHIFT2 - 1)
		72	#define PTE_FILE_BITS3 (PTE_FILE_SHIFT4 - PTE_FILE_SHIFT3 - 1)
		73
		74	#define pte_to_pgoff(pte) \
		75	((((pte).pte_low >> (PTE_FILE_SHIFT1)) \
		76	& ((1U << PTE_FILE_BITS1) - 1))) \
		77	+ ((((pte).pte_low >> (PTE_FILE_SHIFT2)) \
		78	& ((1U << PTE_FILE_BITS2) - 1)) \
		79	<< (PTE_FILE_BITS1)) \
		80	+ ((((pte).pte_low >> (PTE_FILE_SHIFT3)) \
		81	& ((1U << PTE_FILE_BITS3) - 1)) \
		82	<< (PTE_FILE_BITS1 + PTE_FILE_BITS2)) \
		83	+ ((((pte).pte_low >> (PTE_FILE_SHIFT4))) \
		84	<< (PTE_FILE_BITS1 + PTE_FILE_BITS2 + PTE_FILE_BITS3))
		85
		86	#define pgoff_to_pte(off) \
		87	((pte_t) { .pte_low = \
		88	((((off)) & ((1U << PTE_FILE_BITS1) - 1)) << PTE_FILE_SHIFT1) \
		89	+ ((((off) >> PTE_FILE_BITS1) \
		90	& ((1U << PTE_FILE_BITS2) - 1)) \
		91	<< PTE_FILE_SHIFT2) \
		92	+ ((((off) >> (PTE_FILE_BITS1 + PTE_FILE_BITS2)) \
		93	& ((1U << PTE_FILE_BITS3) - 1)) \
		94	<< PTE_FILE_SHIFT3) \
		95	+ ((((off) >> \
		96	(PTE_FILE_BITS1 + PTE_FILE_BITS2 + PTE_FILE_BITS3))) \
		97	<< PTE_FILE_SHIFT4) \
		98	+ _PAGE_FILE })
		99
		100	#else /* CONFIG_MEM_SOFT_DIRTY */
		101
58	/*	102	/*
59	* Bits _PAGE_BIT_PRESENT, _PAGE_BIT_FILE and _PAGE_BIT_PROTNONE are taken,	103	* Bits _PAGE_BIT_PRESENT, _PAGE_BIT_FILE and _PAGE_BIT_PROTNONE are taken,
60	* split up the 29 bits of offset into this range:	104	* split up the 29 bits of offset into this range.
61	*/	105	*/
62	#define PTE_FILE_MAX_BITS 29	106	#define PTE_FILE_MAX_BITS 29
63	#define PTE_FILE_SHIFT1 (_PAGE_BIT_PRESENT + 1)	107	#define PTE_FILE_SHIFT1 (_PAGE_BIT_PRESENT + 1)
@@ -88,6 +132,8 @@ static inline pmd_t native_pmdp_get_and_clear(pmd_t *xp) · 24 unmodified lines
88	<< PTE_FILE_SHIFT3) \	132	<< PTE_FILE_SHIFT3) \
89	+ _PAGE_FILE })	133	+ _PAGE_FILE })
90		134
		135	#endif /* CONFIG_MEM_SOFT_DIRTY */
		136
91	/* Encode and de-code a swap entry */	137	/* Encode and de-code a swap entry */
92	#if _PAGE_BIT_FILE < _PAGE_BIT_PROTNONE	138	#if _PAGE_BIT_FILE < _PAGE_BIT_PROTNONE
93	#define SWP_TYPE_BITS (_PAGE_BIT_FILE - _PAGE_BIT_PRESENT - 1)	139	#define SWP_TYPE_BITS (_PAGE_BIT_FILE - _PAGE_BIT_PRESENT - 1)

arch/x86/include/asm/pgtable-3level.h+3−0

 /*
  * Bits 0, 6 and 7 are taken in the low part of the pte,
  * put the 32 bits of offset into the high part.
+ *
+ * For soft-dirty tracking 11 bit is taken from
+ * the low part of pte as well.
  */
 #define pte_to_pgoff(pte) ((pte).pte_high)
 #define pgoff_to_pte(off)						\

arch/x86/include/asm/pgtable.h+30−0

@@ -314,6 +314,36 @@ static inline pmd_t pmd_mksoft_dirty(pmd_t pmd) · 313 unmodified lines
314	return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);	314	return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);
315	}	315	}
316		316
		317	static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
		318	{
		319	return pte_set_flags(pte, _PAGE_SWP_SOFT_DIRTY);
		320	}
		321
		322	static inline int pte_swp_soft_dirty(pte_t pte)
		323	{
		324	return pte_flags(pte) & _PAGE_SWP_SOFT_DIRTY;
		325	}
		326
		327	static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
		328	{
		329	return pte_clear_flags(pte, _PAGE_SWP_SOFT_DIRTY);
		330	}
		331
		332	static inline pte_t pte_file_clear_soft_dirty(pte_t pte)
		333	{
		334	return pte_clear_flags(pte, _PAGE_SOFT_DIRTY);
		335	}
		336
		337	static inline pte_t pte_file_mksoft_dirty(pte_t pte)
		338	{
		339	return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
		340	}
		341
		342	static inline int pte_file_soft_dirty(pte_t pte)
		343	{
		344	return pte_flags(pte) & _PAGE_SOFT_DIRTY;
		345	}
		346
317	/*	347	/*
318	* Mask out unsupported bits in a present pgprot. Non-present pgprots	348	* Mask out unsupported bits in a present pgprot. Non-present pgprots
319	* can use those bits for other purposes, so leave them be.	349	* can use those bits for other purposes, so leave them be.

arch/x86/include/asm/pgtable_types.h+16−1

@@ -61,12 +61,27 @@ · 60 unmodified lines
61	* they do not conflict with each other.	61	* they do not conflict with each other.
62	*/	62	*/
63		63
		64	#define _PAGE_BIT_SOFT_DIRTY _PAGE_BIT_HIDDEN
		65
64	#ifdef CONFIG_MEM_SOFT_DIRTY	66	#ifdef CONFIG_MEM_SOFT_DIRTY
65	#define _PAGE_SOFT_DIRTY (_AT(pteval_t, 1) << _PAGE_BIT_HIDDEN)	67	#define _PAGE_SOFT_DIRTY (_AT(pteval_t, 1) << _PAGE_BIT_SOFT_DIRTY)
66	#else	68	#else
67	#define _PAGE_SOFT_DIRTY (_AT(pteval_t, 0))	69	#define _PAGE_SOFT_DIRTY (_AT(pteval_t, 0))
68	#endif	70	#endif
69		71
		72	/*
		73	* Tracking soft dirty bit when a page goes to a swap is tricky.
		74	* We need a bit which can be stored in pte _and_ not conflict
		75	* with swap entry format. On x86 bits 6 and 7 are not involved
		76	* into swap entry computation, but bit 6 is used for nonlinear
		77	* file mapping, so we borrow bit 7 for soft dirty tracking.
		78	*/
		79	#ifdef CONFIG_MEM_SOFT_DIRTY
		80	#define _PAGE_SWP_SOFT_DIRTY _PAGE_PSE
		81	#else
		82	#define _PAGE_SWP_SOFT_DIRTY (_AT(pteval_t, 0))
		83	#endif
		84
70	#if defined(CONFIG_X86_64) \|\| defined(CONFIG_X86_PAE)	85	#if defined(CONFIG_X86_64) \|\| defined(CONFIG_X86_PAE)
71	#define _PAGE_NX (_AT(pteval_t, 1) << _PAGE_BIT_NX)	86	#define _PAGE_NX (_AT(pteval_t, 1) << _PAGE_BIT_NX)
72	#else	87	#else

arch/x86/include/asm/spinlock.h+0−4

@@ -233,8 +233,4 @@ static inline void arch_write_unlock(arch_rwlock_t *rw) · 232 unmodified lines
233	#define arch_read_relax(lock) cpu_relax()	233	#define arch_read_relax(lock) cpu_relax()
234	#define arch_write_relax(lock) cpu_relax()	234	#define arch_write_relax(lock) cpu_relax()
235		235
236	/* The {read\|write\|spin}_lock() on x86 are full memory barriers. */
237	static inline void smp_mb__after_lock(void) { }
238	#define ARCH_HAS_SMP_MB_AFTER_LOCK
239
240	#endif /* _ASM_X86_SPINLOCK_H */	236	#endif /* _ASM_X86_SPINLOCK_H */

arch/x86/kernel/cpu/amd.c+5−15

@@ -512,7 +512,7 @@ static void early_init_amd(struct cpuinfo_x86 *c) · 511 unmodified lines
512		512
513	static const int amd_erratum_383[];	513	static const int amd_erratum_383[];
514	static const int amd_erratum_400[];	514	static const int amd_erratum_400[];
515	static bool cpu_has_amd_erratum(const int *erratum);	515	static bool cpu_has_amd_erratum(struct cpuinfo_x86 cpu, const int erratum);
516		516
517	static void init_amd(struct cpuinfo_x86 *c)	517	static void init_amd(struct cpuinfo_x86 *c)
518	{	518	{
@@ -729,11 +729,11 @@ static void init_amd(struct cpuinfo_x86 *c) · 210 unmodified lines
729	value &= ~(1ULL << 24);	729	value &= ~(1ULL << 24);
730	wrmsrl_safe(MSR_AMD64_BU_CFG2, value);	730	wrmsrl_safe(MSR_AMD64_BU_CFG2, value);
731		731
732	if (cpu_has_amd_erratum(amd_erratum_383))	732	if (cpu_has_amd_erratum(c, amd_erratum_383))
733	set_cpu_bug(c, X86_BUG_AMD_TLB_MMATCH);	733	set_cpu_bug(c, X86_BUG_AMD_TLB_MMATCH);
734	}	734	}
735		735
736	if (cpu_has_amd_erratum(amd_erratum_400))	736	if (cpu_has_amd_erratum(c, amd_erratum_400))
737	set_cpu_bug(c, X86_BUG_AMD_APIC_C1E);	737	set_cpu_bug(c, X86_BUG_AMD_APIC_C1E);
738		738
739	rdmsr_safe(MSR_AMD64_PATCH_LEVEL, &c->microcode, &dummy);	739	rdmsr_safe(MSR_AMD64_PATCH_LEVEL, &c->microcode, &dummy);
@@ -878,23 +878,13 @@ static const int amd_erratum_400[] = · 138 unmodified lines
878	static const int amd_erratum_383[] =	878	static const int amd_erratum_383[] =
879	AMD_OSVW_ERRATUM(3, AMD_MODEL_RANGE(0x10, 0, 0, 0xff, 0xf));	879	AMD_OSVW_ERRATUM(3, AMD_MODEL_RANGE(0x10, 0, 0, 0xff, 0xf));
880		880
881	static bool cpu_has_amd_erratum(const int *erratum)	881
		882	static bool cpu_has_amd_erratum(struct cpuinfo_x86 cpu, const int erratum)
882	{	883	{
883	struct cpuinfo_x86 *cpu = __this_cpu_ptr(&cpu_info);
884	int osvw_id = *erratum++;	884	int osvw_id = *erratum++;
885	u32 range;	885	u32 range;
886	u32 ms;	886	u32 ms;
887		887
888	/*
889	* If called early enough that current_cpu_data hasn't been initialized
890	* yet, fall back to boot_cpu_data.
891	*/
892	if (cpu->x86 == 0)
893	cpu = &boot_cpu_data;
894
895	if (cpu->x86_vendor != X86_VENDOR_AMD)
896	return false;
897
898	if (osvw_id >= 0 && osvw_id < 65536 &&	888	if (osvw_id >= 0 && osvw_id < 65536 &&
899	cpu_has(cpu, X86_FEATURE_OSVW)) {	889	cpu_has(cpu, X86_FEATURE_OSVW)) {
900	u64 osvw_len;	890	u64 osvw_len;

arch/x86/kernel/cpu/perf_event_intel.c+1−0

@@ -2270,6 +2270,7 @@ __init int intel_pmu_init(void) · 2269 unmodified lines
2270	case 70:	2270	case 70:
2271	case 71:	2271	case 71:
2272	case 63:	2272	case 63:
		2273	case 69:
2273	x86_pmu.late_ack = true;	2274	x86_pmu.late_ack = true;
2274	memcpy(hw_cache_event_ids, snb_hw_cache_event_ids, sizeof(hw_cache_event_ids));	2275	memcpy(hw_cache_event_ids, snb_hw_cache_event_ids, sizeof(hw_cache_event_ids));
2275	memcpy(hw_cache_extra_regs, snb_hw_cache_extra_regs, sizeof(hw_cache_extra_regs));	2276	memcpy(hw_cache_extra_regs, snb_hw_cache_extra_regs, sizeof(hw_cache_extra_regs));

arch/x86/kernel/cpu/perf_event_intel_uncore.c+2−2

@@ -352,8 +352,8 @@ static struct uncore_event_desc snbep_uncore_imc_events[] = { · 351 unmodified lines
352	static struct uncore_event_desc snbep_uncore_qpi_events[] = {	352	static struct uncore_event_desc snbep_uncore_qpi_events[] = {
353	INTEL_UNCORE_EVENT_DESC(clockticks, "event=0x14"),	353	INTEL_UNCORE_EVENT_DESC(clockticks, "event=0x14"),
354	INTEL_UNCORE_EVENT_DESC(txl_flits_active, "event=0x00,umask=0x06"),	354	INTEL_UNCORE_EVENT_DESC(txl_flits_active, "event=0x00,umask=0x06"),
355	INTEL_UNCORE_EVENT_DESC(drs_data, "event=0x02,umask=0x08"),	355	INTEL_UNCORE_EVENT_DESC(drs_data, "event=0x102,umask=0x08"),
356	INTEL_UNCORE_EVENT_DESC(ncb_data, "event=0x03,umask=0x04"),	356	INTEL_UNCORE_EVENT_DESC(ncb_data, "event=0x103,umask=0x04"),
357	{ /* end: all zeroes */ },	357	{ /* end: all zeroes */ },
358	};	358	};
359		359

arch/x86/kernel/microcode_amd.c+13−14

 	return 0;
 }
-static unsigned int verify_patch_size(int cpu, u32 patch_size,
+static unsigned int verify_patch_size(u8 family, u32 patch_size,
 				      unsigned int size)
 {
-	struct cpuinfo_x86 *c = &cpu_data(cpu);
 	u32 max_size;
 #define F1XH_MPB_MAX_SIZE 2048
 #define F15H_MPB_MAX_SIZE 4096
 #define F16H_MPB_MAX_SIZE 3458
-	switch (c->x86) {
+	switch (family) {
 	case 0x14:
 		max_size = F14H_MPB_MAX_SIZE;
 		break;
  * driver cannot continue functioning normally. In such cases, we tear
  * down everything we've used up so far and exit.
  */
-static int verify_and_add_patch(unsigned int cpu, u8 *fw, unsigned int leftover)
+static int verify_and_add_patch(u8 family, u8 *fw, unsigned int leftover)
 {
-	struct cpuinfo_x86 *c = &cpu_data(cpu);
 	struct microcode_header_amd *mc_hdr;
 	struct ucode_patch *patch;
 	unsigned int patch_size, crnt_size, ret;
 	/* check if patch is for the current family */
 	proc_fam = ((proc_fam >> 8) & 0xf) + ((proc_fam >> 20) & 0xff);
-	if (proc_fam != c->x86)
+	if (proc_fam != family)
 		return crnt_size;
 	if (mc_hdr->nb_dev_id || mc_hdr->sb_dev_id) {
 		return crnt_size;
 	}
-	ret = verify_patch_size(cpu, patch_size, leftover);
+	ret = verify_patch_size(family, patch_size, leftover);
 	if (!ret) {
 		pr_err("Patch-ID 0x%08x: size mismatch.\n", mc_hdr->patch_id);
 		return crnt_size;
 	return crnt_size;
 }
-static enum ucode_state __load_microcode_amd(int cpu, const u8 *data, size_t size)
+static enum ucode_state __load_microcode_amd(u8 family, const u8 *data,
+					     size_t size)
 {
 	enum ucode_state ret = UCODE_ERROR;
 	unsigned int leftover;
 	}
 	while (leftover) {
-		crnt_size = verify_and_add_patch(cpu, fw, leftover);
+		crnt_size = verify_and_add_patch(family, fw, leftover);
 		if (crnt_size < 0)
 			return ret;
 	return UCODE_OK;
 }
-enum ucode_state load_microcode_amd(int cpu, const u8 *data, size_t size)
+enum ucode_state load_microcode_amd(u8 family, const u8 *data, size_t size)
 {
 	enum ucode_state ret;
 	/* free old equiv table */
 	free_equiv_cpu_table();
-	ret = __load_microcode_amd(cpu, data, size);
+	ret = __load_microcode_amd(family, data, size);
 	if (ret != UCODE_OK)
 		cleanup();
 #if defined(CONFIG_MICROCODE_AMD_EARLY) && defined(CONFIG_X86_32)
 	/* save BSP's matching patch for early load */
-	if (cpu_data(cpu).cpu_index == boot_cpu_data.cpu_index) {
+	if (cpu_data(smp_processor_id()).cpu_index == boot_cpu_data.cpu_index) {
-		struct ucode_patch *p = find_patch(cpu);
+		struct ucode_patch *p = find_patch(smp_processor_id());
 		if (p) {
 			memset(amd_bsp_mpb, 0, MPB_MAX_SIZE);
 			memcpy(amd_bsp_mpb, p->data, min_t(u32, ksize(p->data),
 		goto fw_release;
 	}
-	ret = load_microcode_amd(cpu, fw->data, fw->size);
+	ret = load_microcode_amd(c->x86, fw->data, fw->size);
  fw_release:
 	release_firmware(fw);

arch/x86/kernel/microcode_amd_early.c+13−14

 	uci->cpu_sig.sig = cpuid_eax(0x00000001);
 }
 #else
-static void collect_cpu_info_amd_early(struct cpuinfo_x86 *c,
+void load_ucode_amd_ap(void)
-						 struct ucode_cpu_info *uci)
 {
+	unsigned int cpu = smp_processor_id();
+	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 	u32 rev, eax;
 	rdmsr(MSR_AMD64_PATCH_LEVEL, rev, eax);
 	eax = cpuid_eax(0x00000001);
-	uci->cpu_sig.sig = eax;
 	uci->cpu_sig.rev = rev;
-	c->microcode = rev;
+	uci->cpu_sig.sig = eax;
-	c->x86 = ((eax >> 8) & 0xf) + ((eax >> 20) & 0xff);
-}
-void load_ucode_amd_ap(void)
-{
-	unsigned int cpu = smp_processor_id();
-	collect_cpu_info_amd_early(&cpu_data(cpu), ucode_cpu_info + cpu);
 	if (cpu && !ucode_loaded) {
 		void *ucode;
 			return;
 		ucode = (void *)(initrd_start + ucode_offset);
-		if (load_microcode_amd(0, ucode, ucode_size) != UCODE_OK)
+		eax   = ((eax >> 8) & 0xf) + ((eax >> 20) & 0xff);
+		if (load_microcode_amd(eax, ucode, ucode_size) != UCODE_OK)
 			return;
 		ucode_loaded = true;
 	}
 {
 	enum ucode_state ret;
 	void *ucode;
+	u32 eax;
 #ifdef CONFIG_X86_32
 	unsigned int bsp = boot_cpu_data.cpu_index;
 	struct ucode_cpu_info *uci = ucode_cpu_info + bsp;
 		return 0;
 	ucode = (void *)(initrd_start + ucode_offset);
-	ret = load_microcode_amd(0, ucode, ucode_size);
+	eax   = cpuid_eax(0x00000001);
+	eax   = ((eax >> 8) & 0xf) + ((eax >> 20) & 0xff);
+	ret = load_microcode_amd(eax, ucode, ucode_size);
 	if (ret != UCODE_OK)
 		return -EINVAL;

arch/x86/kernel/sys_x86_64.c+1−1

@@ -101,7 +101,7 @@ static void find_start_end(unsigned long flags, unsigned long *begin, · 100 unmodified lines
101	*begin = new_begin;	101	*begin = new_begin;
102	}	102	}
103	} else {	103	} else {
104	*begin = TASK_UNMAPPED_BASE;	104	*begin = current->mm->mmap_legacy_base;
105	*end = TASK_SIZE;	105	*end = TASK_SIZE;
106	}	106	}
107	}	107	}

arch/x86/mm/mmap.c+4−2

  */
 void arch_pick_mmap_layout(struct mm_struct *mm)
 {
+	mm->mmap_legacy_base = mmap_legacy_base();
+	mm->mmap_base = mmap_base();
 	if (mmap_is_legacy()) {
-		mm->mmap_base = mmap_legacy_base();
+		mm->mmap_base = mm->mmap_legacy_base;
 		mm->get_unmapped_area = arch_get_unmapped_area;
 	} else {
-		mm->mmap_base = mmap_base();
 		mm->get_unmapped_area = arch_get_unmapped_area_topdown;
 	}
 }

arch/x86/xen/setup.c+22−0

@@ -313,6 +313,17 @@ static void xen_align_and_add_e820_region(u64 start, u64 size, int type) · 312 unmodified lines
313	e820_add_region(start, end - start, type);	313	e820_add_region(start, end - start, type);
314	}	314	}
315		315
		316	void xen_ignore_unusable(struct e820entry *list, size_t map_size)
		317	{
		318	struct e820entry *entry;
		319	unsigned int i;
		320
		321	for (i = 0, entry = list; i < map_size; i++, entry++) {
		322	if (entry->type == E820_UNUSABLE)
		323	entry->type = E820_RAM;
		324	}
		325	}
		326
316	/**	327	/**
317	* machine_specific_memory_setup - Hook for machine specific memory setup.	328	* machine_specific_memory_setup - Hook for machine specific memory setup.
318	**/	329	**/
@@ -353,6 +364,17 @@ char * __init xen_memory_setup(void) · 34 unmodified lines
353	}	364	}
354	BUG_ON(rc);	365	BUG_ON(rc);
355		366
		367	/*
		368	* Xen won't allow a 1:1 mapping to be created to UNUSABLE
		369	* regions, so if we're using the machine memory map leave the
		370	* region as RAM as it is in the pseudo-physical map.
		371	*
		372	* UNUSABLE regions in domUs are not handled and will need
		373	* a patch in the future.
		374	*/
		375	if (xen_initial_domain())
		376	xen_ignore_unusable(map, memmap.nr_entries);
		377
356	/* Make sure the Xen-supplied memory map is well-ordered. */	378	/* Make sure the Xen-supplied memory map is well-ordered. */
357	sanitize_e820_map(map, memmap.nr_entries, &memmap.nr_entries);	379	sanitize_e820_map(map, memmap.nr_entries, &memmap.nr_entries);
358		380

arch/x86/xen/smp.c+9−2

 static int xen_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
 {
 	int rc;
-	rc = native_cpu_up(cpu, tidle);
+	/*
-	WARN_ON (xen_smp_intr_init(cpu));
+	 * xen_smp_intr_init() needs to run before native_cpu_up()
+	 * so that IPI vectors are set up on the booting CPU before
+	 * it is marked online in native_cpu_up().
+	*/
+	rc = xen_smp_intr_init(cpu);
+	WARN_ON(rc);
+	if (!rc)
+		rc =  native_cpu_up(cpu, tidle);
 	return rc;
 }

drivers/acpi/video.c+3−8

 		device->cap._DDC = 1;
 	}
-	if (acpi_video_init_brightness(device))
-		return;
 	if (acpi_video_backlight_support()) {
 		struct backlight_properties props;
 		struct pci_dev *pdev;
 		static int count = 0;
 		char *name;
+		result = acpi_video_init_brightness(device);
+		if (result)
+			return;
 		name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
 		if (!name)
 			return;
 		if (result)
 			printk(KERN_ERR PREFIX "Create sysfs link\n");
-	} else {
-		/* Remove the brightness object. */
-		kfree(device->brightness->levels);
-		kfree(device->brightness);
-		device->brightness = NULL;
 	}
 }

drivers/ata/libata-pmp.c+6−6

@@ -289,24 +289,24 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info) · 288 unmodified lines
289		289
290	/* Disable sending Early R_OK.	290	/* Disable sending Early R_OK.
291	* With "cached read" HDD testing and multiple ports busy on a SATA	291	* With "cached read" HDD testing and multiple ports busy on a SATA
292	* host controller, 3726 PMP will very rarely drop a deferred	292	* host controller, 3x26 PMP will very rarely drop a deferred
293	* R_OK that was intended for the host. Symptom will be all	293	* R_OK that was intended for the host. Symptom will be all
294	* 5 drives under test will timeout, get reset, and recover.	294	* 5 drives under test will timeout, get reset, and recover.
295	*/	295	*/
296	if (vendor == 0x1095 && devid == 0x3726) {	296	if (vendor == 0x1095 && (devid == 0x3726 \|\| devid == 0x3826)) {
297	u32 reg;	297	u32 reg;
298		298
299	err_mask = sata_pmp_read(&ap->link, PMP_GSCR_SII_POL, &reg);	299	err_mask = sata_pmp_read(&ap->link, PMP_GSCR_SII_POL, &reg);
300	if (err_mask) {	300	if (err_mask) {
301	rc = -EIO;	301	rc = -EIO;
302	reason = "failed to read Sil3726 Private Register";	302	reason = "failed to read Sil3x26 Private Register";
303	goto fail;	303	goto fail;
304	}	304	}
305	reg &= ~0x1;	305	reg &= ~0x1;
306	err_mask = sata_pmp_write(&ap->link, PMP_GSCR_SII_POL, reg);	306	err_mask = sata_pmp_write(&ap->link, PMP_GSCR_SII_POL, reg);
307	if (err_mask) {	307	if (err_mask) {
308	rc = -EIO;	308	rc = -EIO;
309	reason = "failed to write Sil3726 Private Register";	309	reason = "failed to write Sil3x26 Private Register";
310	goto fail;	310	goto fail;
311	}	311	}
312	}	312	}
@@ -383,8 +383,8 @@ static void sata_pmp_quirks(struct ata_port *ap) · 70 unmodified lines
383	u16 devid = sata_pmp_gscr_devid(gscr);	383	u16 devid = sata_pmp_gscr_devid(gscr);
384	struct ata_link *link;	384	struct ata_link *link;
385		385
386	if (vendor == 0x1095 && devid == 0x3726) {	386	if (vendor == 0x1095 && (devid == 0x3726 \|\| devid == 0x3826)) {
387	/* sil3726 quirks */	387	/* sil3x26 quirks */
388	ata_for_each_link(link, ap, EDGE) {	388	ata_for_each_link(link, ap, EDGE) {
389	/* link reports offline after LPM */	389	/* link reports offline after LPM */
390	link->flags \|= ATA_LFLAG_NO_LPM;	390	link->flags \|= ATA_LFLAG_NO_LPM;

drivers/ata/sata_fsl.c+3−2

 {
 	struct sata_fsl_host_priv *host_priv = host->private_data;
 	void __iomem *hcr_base = host_priv->hcr_base;
+	unsigned long flags;
 	if (count > ICC_MAX_INT_COUNT_THRESHOLD)
 		count = ICC_MAX_INT_COUNT_THRESHOLD;
 			(count > ICC_MIN_INT_COUNT_THRESHOLD))
 		ticks = ICC_SAFE_INT_TICKS;
-	spin_lock(&host->lock);
+	spin_lock_irqsave(&host->lock, flags);
 	iowrite32((count << 24 | ticks), hcr_base + ICC);
 	intr_coalescing_count = count;
 	intr_coalescing_ticks = ticks;
-	spin_unlock(&host->lock);
+	spin_unlock_irqrestore(&host->lock, flags);
 	DPRINTK("interrupt coalescing, count = 0x%x, ticks = %x\n",
 			intr_coalescing_count, intr_coalescing_ticks);

drivers/ata/sata_highbank.c+2−2

@@ -86,11 +86,11 @@ struct ecx_plat_data { · 85 unmodified lines
86		86
87	#define SGPIO_SIGNALS 3	87	#define SGPIO_SIGNALS 3
88	#define ECX_ACTIVITY_BITS 0x300000	88	#define ECX_ACTIVITY_BITS 0x300000
89	#define ECX_ACTIVITY_SHIFT 2	89	#define ECX_ACTIVITY_SHIFT 0
90	#define ECX_LOCATE_BITS 0x80000	90	#define ECX_LOCATE_BITS 0x80000
91	#define ECX_LOCATE_SHIFT 1	91	#define ECX_LOCATE_SHIFT 1
92	#define ECX_FAULT_BITS 0x400000	92	#define ECX_FAULT_BITS 0x400000
93	#define ECX_FAULT_SHIFT 0	93	#define ECX_FAULT_SHIFT 2
94	static inline int sgpio_bit_shift(struct ecx_plat_data *pdata, u32 port,	94	static inline int sgpio_bit_shift(struct ecx_plat_data *pdata, u32 port,
95	u32 shift)	95	u32 shift)
96	{	96	{

drivers/base/memory.c+2−0

@@ -141,6 +141,8 @@ static ssize_t show_mem_removable(struct device *dev, · 140 unmodified lines
141	container_of(dev, struct memory_block, dev);	141	container_of(dev, struct memory_block, dev);
142		142
143	for (i = 0; i < sections_per_block; i++) {	143	for (i = 0; i < sections_per_block; i++) {
		144	if (!present_section_nr(mem->start_section_nr + i))
		145	continue;
144	pfn = section_nr_to_pfn(mem->start_section_nr + i);	146	pfn = section_nr_to_pfn(mem->start_section_nr + i);
145	ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);	147	ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
146	}	148	}

drivers/base/regmap/regcache-rbtree.c+1−1

@@ -332,7 +332,7 @@ regcache_rbtree_node_alloc(struct regmap *map, unsigned int reg) · 331 unmodified lines
332	}	332	}
333		333
334	if (!rbnode->blklen) {	334	if (!rbnode->blklen) {
335	rbnode->blklen = sizeof(*rbnode);	335	rbnode->blklen = 1;
336	rbnode->base_reg = reg;	336	rbnode->base_reg = reg;
337	}	337	}
338		338

drivers/block/aoe/aoecmd.c+7−10

 	int i;
 	bio_for_each_segment(bv, bio, i) {
-		page = bv->bv_page;
 		/* Non-zero page count for non-head members of
-		 * compound pages is no longer allowed by the kernel,
+		 * compound pages is no longer allowed by the kernel.
-		 * but this has never been seen here.
 		 */
-		if (unlikely(PageCompound(page)))
+		page = compound_trans_head(bv->bv_page);
-			if (compound_trans_head(page) != page) {
-				pr_crit("page tail used for block I/O\n");
-				BUG();
-			}
 		atomic_inc(&page->_count);
 	}
 }
 bio_pagedec(struct bio *bio)
 {
 	struct bio_vec *bv;
+	struct page *page;
 	int i;
-	bio_for_each_segment(bv, bio, i)
+	bio_for_each_segment(bv, bio, i) {
-		atomic_dec(&bv->bv_page->_count);
+		page = compound_trans_head(bv->bv_page);
+		atomic_dec(&page->_count);
+	}
 }
 static void

drivers/clk/samsung/clk-exynos4.c+34−30

@@ -581,11 +581,15 @@ struct samsung_div_clock exynos4x12_div_clks[] __initdata = { · 580 unmodified lines
581	DIV(none, "div_spi1_isp", "mout_spi1_isp", E4X12_DIV_ISP, 16, 4),	581	DIV(none, "div_spi1_isp", "mout_spi1_isp", E4X12_DIV_ISP, 16, 4),
582	DIV(none, "div_spi1_isp_pre", "div_spi1_isp", E4X12_DIV_ISP, 20, 8),	582	DIV(none, "div_spi1_isp_pre", "div_spi1_isp", E4X12_DIV_ISP, 20, 8),
583	DIV(none, "div_uart_isp", "mout_uart_isp", E4X12_DIV_ISP, 28, 4),	583	DIV(none, "div_uart_isp", "mout_uart_isp", E4X12_DIV_ISP, 28, 4),
584	DIV(div_isp0, "div_isp0", "aclk200", E4X12_DIV_ISP0, 0, 3),	584	DIV_F(div_isp0, "div_isp0", "aclk200", E4X12_DIV_ISP0, 0, 3,
585	DIV(div_isp1, "div_isp1", "aclk200", E4X12_DIV_ISP0, 4, 3),	585	CLK_GET_RATE_NOCACHE, 0),
		586	DIV_F(div_isp1, "div_isp1", "aclk200", E4X12_DIV_ISP0, 4, 3,
		587	CLK_GET_RATE_NOCACHE, 0),
586	DIV(none, "div_mpwm", "div_isp1", E4X12_DIV_ISP1, 0, 3),	588	DIV(none, "div_mpwm", "div_isp1", E4X12_DIV_ISP1, 0, 3),
587	DIV(div_mcuisp0, "div_mcuisp0", "aclk400_mcuisp", E4X12_DIV_ISP1, 4, 3),	589	DIV_F(div_mcuisp0, "div_mcuisp0", "aclk400_mcuisp", E4X12_DIV_ISP1,
588	DIV(div_mcuisp1, "div_mcuisp1", "div_mcuisp0", E4X12_DIV_ISP1, 8, 3),	590	4, 3, CLK_GET_RATE_NOCACHE, 0),
		591	DIV_F(div_mcuisp1, "div_mcuisp1", "div_mcuisp0", E4X12_DIV_ISP1,
		592	8, 3, CLK_GET_RATE_NOCACHE, 0),
589	DIV(sclk_fimg2d, "sclk_fimg2d", "mout_g2d", DIV_DMC1, 0, 4),	593	DIV(sclk_fimg2d, "sclk_fimg2d", "mout_g2d", DIV_DMC1, 0, 4),
590	};	594	};
591		595
@@ -863,57 +867,57 @@ struct samsung_gate_clock exynos4x12_gate_clks[] __initdata = { · 271 unmodified lines
863	GATE_DA(i2s0, "samsung-i2s.0", "i2s0", "aclk100",	867	GATE_DA(i2s0, "samsung-i2s.0", "i2s0", "aclk100",
864	E4X12_GATE_IP_MAUDIO, 3, 0, 0, "iis"),	868	E4X12_GATE_IP_MAUDIO, 3, 0, 0, "iis"),
865	GATE(fimc_isp, "isp", "aclk200", E4X12_GATE_ISP0, 0,	869	GATE(fimc_isp, "isp", "aclk200", E4X12_GATE_ISP0, 0,
866	CLK_IGNORE_UNUSED, 0),	870	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
867	GATE(fimc_drc, "drc", "aclk200", E4X12_GATE_ISP0, 1,	871	GATE(fimc_drc, "drc", "aclk200", E4X12_GATE_ISP0, 1,
868	CLK_IGNORE_UNUSED, 0),	872	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
869	GATE(fimc_fd, "fd", "aclk200", E4X12_GATE_ISP0, 2,	873	GATE(fimc_fd, "fd", "aclk200", E4X12_GATE_ISP0, 2,
870	CLK_IGNORE_UNUSED, 0),	874	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
871	GATE(fimc_lite0, "lite0", "aclk200", E4X12_GATE_ISP0, 3,	875	GATE(fimc_lite0, "lite0", "aclk200", E4X12_GATE_ISP0, 3,
872	CLK_IGNORE_UNUSED, 0),	876	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
873	GATE(fimc_lite1, "lite1", "aclk200", E4X12_GATE_ISP0, 4,	877	GATE(fimc_lite1, "lite1", "aclk200", E4X12_GATE_ISP0, 4,
874	CLK_IGNORE_UNUSED, 0),	878	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
875	GATE(mcuisp, "mcuisp", "aclk200", E4X12_GATE_ISP0, 5,	879	GATE(mcuisp, "mcuisp", "aclk200", E4X12_GATE_ISP0, 5,
876	CLK_IGNORE_UNUSED, 0),	880	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
877	GATE(gicisp, "gicisp", "aclk200", E4X12_GATE_ISP0, 7,	881	GATE(gicisp, "gicisp", "aclk200", E4X12_GATE_ISP0, 7,
878	CLK_IGNORE_UNUSED, 0),	882	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
879	GATE(smmu_isp, "smmu_isp", "aclk200", E4X12_GATE_ISP0, 8,	883	GATE(smmu_isp, "smmu_isp", "aclk200", E4X12_GATE_ISP0, 8,
880	CLK_IGNORE_UNUSED, 0),	884	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
881	GATE(smmu_drc, "smmu_drc", "aclk200", E4X12_GATE_ISP0, 9,	885	GATE(smmu_drc, "smmu_drc", "aclk200", E4X12_GATE_ISP0, 9,
882	CLK_IGNORE_UNUSED, 0),	886	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
883	GATE(smmu_fd, "smmu_fd", "aclk200", E4X12_GATE_ISP0, 10,	887	GATE(smmu_fd, "smmu_fd", "aclk200", E4X12_GATE_ISP0, 10,
884	CLK_IGNORE_UNUSED, 0),	888	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
885	GATE(smmu_lite0, "smmu_lite0", "aclk200", E4X12_GATE_ISP0, 11,	889	GATE(smmu_lite0, "smmu_lite0", "aclk200", E4X12_GATE_ISP0, 11,
886	CLK_IGNORE_UNUSED, 0),	890	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
887	GATE(smmu_lite1, "smmu_lite1", "aclk200", E4X12_GATE_ISP0, 12,	891	GATE(smmu_lite1, "smmu_lite1", "aclk200", E4X12_GATE_ISP0, 12,
888	CLK_IGNORE_UNUSED, 0),	892	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
889	GATE(ppmuispmx, "ppmuispmx", "aclk200", E4X12_GATE_ISP0, 20,	893	GATE(ppmuispmx, "ppmuispmx", "aclk200", E4X12_GATE_ISP0, 20,
890	CLK_IGNORE_UNUSED, 0),	894	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
891	GATE(ppmuispx, "ppmuispx", "aclk200", E4X12_GATE_ISP0, 21,	895	GATE(ppmuispx, "ppmuispx", "aclk200", E4X12_GATE_ISP0, 21,
892	CLK_IGNORE_UNUSED, 0),	896	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
893	GATE(mcuctl_isp, "mcuctl_isp", "aclk200", E4X12_GATE_ISP0, 23,	897	GATE(mcuctl_isp, "mcuctl_isp", "aclk200", E4X12_GATE_ISP0, 23,
894	CLK_IGNORE_UNUSED, 0),	898	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
895	GATE(mpwm_isp, "mpwm_isp", "aclk200", E4X12_GATE_ISP0, 24,	899	GATE(mpwm_isp, "mpwm_isp", "aclk200", E4X12_GATE_ISP0, 24,
896	CLK_IGNORE_UNUSED, 0),	900	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
897	GATE(i2c0_isp, "i2c0_isp", "aclk200", E4X12_GATE_ISP0, 25,	901	GATE(i2c0_isp, "i2c0_isp", "aclk200", E4X12_GATE_ISP0, 25,
898	CLK_IGNORE_UNUSED, 0),	902	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
899	GATE(i2c1_isp, "i2c1_isp", "aclk200", E4X12_GATE_ISP0, 26,	903	GATE(i2c1_isp, "i2c1_isp", "aclk200", E4X12_GATE_ISP0, 26,
900	CLK_IGNORE_UNUSED, 0),	904	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
901	GATE(mtcadc_isp, "mtcadc_isp", "aclk200", E4X12_GATE_ISP0, 27,	905	GATE(mtcadc_isp, "mtcadc_isp", "aclk200", E4X12_GATE_ISP0, 27,
902	CLK_IGNORE_UNUSED, 0),	906	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
903	GATE(pwm_isp, "pwm_isp", "aclk200", E4X12_GATE_ISP0, 28,	907	GATE(pwm_isp, "pwm_isp", "aclk200", E4X12_GATE_ISP0, 28,
904	CLK_IGNORE_UNUSED, 0),	908	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
905	GATE(wdt_isp, "wdt_isp", "aclk200", E4X12_GATE_ISP0, 30,	909	GATE(wdt_isp, "wdt_isp", "aclk200", E4X12_GATE_ISP0, 30,
906	CLK_IGNORE_UNUSED, 0),	910	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
907	GATE(uart_isp, "uart_isp", "aclk200", E4X12_GATE_ISP0, 31,	911	GATE(uart_isp, "uart_isp", "aclk200", E4X12_GATE_ISP0, 31,
908	CLK_IGNORE_UNUSED, 0),	912	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
909	GATE(asyncaxim, "asyncaxim", "aclk200", E4X12_GATE_ISP1, 0,	913	GATE(asyncaxim, "asyncaxim", "aclk200", E4X12_GATE_ISP1, 0,
910	CLK_IGNORE_UNUSED, 0),	914	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
911	GATE(smmu_ispcx, "smmu_ispcx", "aclk200", E4X12_GATE_ISP1, 4,	915	GATE(smmu_ispcx, "smmu_ispcx", "aclk200", E4X12_GATE_ISP1, 4,
912	CLK_IGNORE_UNUSED, 0),	916	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
913	GATE(spi0_isp, "spi0_isp", "aclk200", E4X12_GATE_ISP1, 12,	917	GATE(spi0_isp, "spi0_isp", "aclk200", E4X12_GATE_ISP1, 12,
914	CLK_IGNORE_UNUSED, 0),	918	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
915	GATE(spi1_isp, "spi1_isp", "aclk200", E4X12_GATE_ISP1, 13,	919	GATE(spi1_isp, "spi1_isp", "aclk200", E4X12_GATE_ISP1, 13,
916	CLK_IGNORE_UNUSED, 0),	920	CLK_IGNORE_UNUSED \| CLK_GET_RATE_NOCACHE, 0),
917	GATE(g2d, "g2d", "aclk200", GATE_IP_DMC, 23, 0, 0),	921	GATE(g2d, "g2d", "aclk200", GATE_IP_DMC, 23, 0, 0),
918	};	922	};
919		923

drivers/clk/zynq/clkc.c+8−5

 static DEFINE_SPINLOCK(ddrpll_lock);
 static DEFINE_SPINLOCK(iopll_lock);
 static DEFINE_SPINLOCK(armclk_lock);
+static DEFINE_SPINLOCK(swdtclk_lock);
 static DEFINE_SPINLOCK(ddrclk_lock);
 static DEFINE_SPINLOCK(dciclk_lock);
 static DEFINE_SPINLOCK(gem0clk_lock);
 	}
 	clks[swdt] = clk_register_mux(NULL, clk_output_name[swdt],
 			swdt_ext_clk_mux_parents, 2, CLK_SET_RATE_PARENT,
-			SLCR_SWDT_CLK_SEL, 0, 1, 0, &gem0clk_lock);
+			SLCR_SWDT_CLK_SEL, 0, 1, 0, &swdtclk_lock);
 	/* DDR clocks */
 	clk = clk_register_divider(NULL, "ddr2x_div", "ddrpll", 0,
 			CLK_SET_RATE_PARENT, SLCR_GEM0_CLK_CTRL, 20, 6,
 			CLK_DIVIDER_ONE_BASED | CLK_DIVIDER_ALLOW_ZERO,
 			&gem0clk_lock);
-	clk = clk_register_mux(NULL, "gem0_emio_mux", gem0_mux_parents, 2, 0,
+	clk = clk_register_mux(NULL, "gem0_emio_mux", gem0_mux_parents, 2,
-			SLCR_GEM0_CLK_CTRL, 6, 1, 0, &gem0clk_lock);
+			CLK_SET_RATE_PARENT, SLCR_GEM0_CLK_CTRL, 6, 1, 0,
+			&gem0clk_lock);
 	clks[gem0] = clk_register_gate(NULL, clk_output_name[gem0],
 			"gem0_emio_mux", CLK_SET_RATE_PARENT,
 			SLCR_GEM0_CLK_CTRL, 0, 0, &gem0clk_lock);
 			CLK_SET_RATE_PARENT, SLCR_GEM1_CLK_CTRL, 20, 6,
 			CLK_DIVIDER_ONE_BASED | CLK_DIVIDER_ALLOW_ZERO,
 			&gem1clk_lock);
-	clk = clk_register_mux(NULL, "gem1_emio_mux", gem1_mux_parents, 2, 0,
+	clk = clk_register_mux(NULL, "gem1_emio_mux", gem1_mux_parents, 2,
-			SLCR_GEM1_CLK_CTRL, 6, 1, 0, &gem1clk_lock);
+			CLK_SET_RATE_PARENT, SLCR_GEM1_CLK_CTRL, 6, 1, 0,
+			&gem1clk_lock);
 	clks[gem1] = clk_register_gate(NULL, clk_output_name[gem1],
 			"gem1_emio_mux", CLK_SET_RATE_PARENT,
 			SLCR_GEM1_CLK_CTRL, 0, 0, &gem1clk_lock);

drivers/gpu/drm/gma500/psb_intel_sdvo.c+2−1

@@ -500,7 +500,8 @@ static bool psb_intel_sdvo_read_response(struct psb_intel_sdvo *psb_intel_sdvo, · 499 unmodified lines
500	&status))	500	&status))
501	goto log_fail;	501	goto log_fail;
502		502
503	while (status == SDVO_CMD_STATUS_PENDING && retry--) {	503	while ((status == SDVO_CMD_STATUS_PENDING \|\|
		504	status == SDVO_CMD_STATUS_TARGET_NOT_SPECIFIED) && retry--) {
504	udelay(15);	505	udelay(15);
505	if (!psb_intel_sdvo_read_byte(psb_intel_sdvo,	506	if (!psb_intel_sdvo_read_byte(psb_intel_sdvo,
506	SDVO_I2C_CMD_STATUS,	507	SDVO_I2C_CMD_STATUS,

drivers/gpu/drm/i915/i915_gem_dmabuf.c+8−0

 				   struct sg_table *sg,
 				   enum dma_data_direction dir)
 {
+	struct drm_i915_gem_object *obj = attachment->dmabuf->priv;
+	mutex_lock(&obj->base.dev->struct_mutex);
 	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
 	sg_free_table(sg);
 	kfree(sg);
+	i915_gem_object_unpin_pages(obj);
+	mutex_unlock(&obj->base.dev->struct_mutex);
 }
 static void i915_gem_dmabuf_release(struct dma_buf *dma_buf)

drivers/gpu/drm/i915/i915_reg.h+2−0

 					will not assert AGPBUSY# and will only
 					be delivered when out of C3. */
 #define   INSTPM_FORCE_ORDERING				(1<<7) /* GEN6+ */
+#define   INSTPM_TLB_INVALIDATE	(1<<9)
+#define   INSTPM_SYNC_FLUSH	(1<<5)
 #define ACTHD	        0x020c8
 #define FW_BLC		0x020d8
 #define FW_BLC2		0x020dc

drivers/gpu/drm/i915/intel_display.c+57−29

@@ -10042,6 +10042,8 @@ struct intel_display_error_state { · 10041 unmodified lines
10042		10042
10043	u32 power_well_driver;	10043	u32 power_well_driver;
10044		10044
		10045	int num_transcoders;
		10046
10045	struct intel_cursor_error_state {	10047	struct intel_cursor_error_state {
10046	u32 control;	10048	u32 control;
10047	u32 position;	10049	u32 position;
@@ -10050,16 +10052,7 @@ struct intel_display_error_state { · 2 unmodified lines
10050	} cursor[I915_MAX_PIPES];	10052	} cursor[I915_MAX_PIPES];
10051		10053
10052	struct intel_pipe_error_state {	10054	struct intel_pipe_error_state {
10053	enum transcoder cpu_transcoder;
10054	u32 conf;
10055	u32 source;	10055	u32 source;
10056
10057	u32 htotal;
10058	u32 hblank;
10059	u32 hsync;
10060	u32 vtotal;
10061	u32 vblank;
10062	u32 vsync;
10063	} pipe[I915_MAX_PIPES];	10056	} pipe[I915_MAX_PIPES];
10064		10057
10065	struct intel_plane_error_state {	10058	struct intel_plane_error_state {
@@ -10071,6 +10064,19 @@ struct intel_display_error_state { · 5 unmodified lines
10071	u32 surface;	10064	u32 surface;
10072	u32 tile_offset;	10065	u32 tile_offset;
10073	} plane[I915_MAX_PIPES];	10066	} plane[I915_MAX_PIPES];
		10067
		10068	struct intel_transcoder_error_state {
		10069	enum transcoder cpu_transcoder;
		10070
		10071	u32 conf;
		10072
		10073	u32 htotal;
		10074	u32 hblank;
		10075	u32 hsync;
		10076	u32 vtotal;
		10077	u32 vblank;
		10078	u32 vsync;
		10079	} transcoder[4];
10074	};	10080	};
10075		10081
10076	struct intel_display_error_state *	10082	struct intel_display_error_state *
@@ -10078,9 +10084,17 @@ intel_display_capture_error_state(struct drm_device *dev) · 1 unmodified line
10078	{	10084	{
10079	drm_i915_private_t *dev_priv = dev->dev_private;	10085	drm_i915_private_t *dev_priv = dev->dev_private;
10080	struct intel_display_error_state *error;	10086	struct intel_display_error_state *error;
10081	enum transcoder cpu_transcoder;	10087	int transcoders[] = {
		10088	TRANSCODER_A,
		10089	TRANSCODER_B,
		10090	TRANSCODER_C,
		10091	TRANSCODER_EDP,
		10092	};
10082	int i;	10093	int i;
10083		10094
		10095	if (INTEL_INFO(dev)->num_pipes == 0)
		10096	return NULL;
		10097
10084	error = kmalloc(sizeof(*error), GFP_ATOMIC);	10098	error = kmalloc(sizeof(*error), GFP_ATOMIC);
10085	if (error == NULL)	10099	if (error == NULL)
10086	return NULL;	10100	return NULL;
@@ -10089,9 +10103,6 @@ intel_display_capture_error_state(struct drm_device *dev) · 2 unmodified lines
10089	error->power_well_driver = I915_READ(HSW_PWR_WELL_DRIVER);	10103	error->power_well_driver = I915_READ(HSW_PWR_WELL_DRIVER);
10090		10104
10091	for_each_pipe(i) {	10105	for_each_pipe(i) {
10092	cpu_transcoder = intel_pipe_to_cpu_transcoder(dev_priv, i);
10093	error->pipe[i].cpu_transcoder = cpu_transcoder;
10094
10095	if (INTEL_INFO(dev)->gen <= 6 \|\| IS_VALLEYVIEW(dev)) {	10106	if (INTEL_INFO(dev)->gen <= 6 \|\| IS_VALLEYVIEW(dev)) {
10096	error->cursor[i].control = I915_READ(CURCNTR(i));	10107	error->cursor[i].control = I915_READ(CURCNTR(i));
10097	error->cursor[i].position = I915_READ(CURPOS(i));	10108	error->cursor[i].position = I915_READ(CURPOS(i));
@@ -10115,14 +10126,25 @@ intel_display_capture_error_state(struct drm_device *dev) · 17 unmodified lines
10115	error->plane[i].tile_offset = I915_READ(DSPTILEOFF(i));	10126	error->plane[i].tile_offset = I915_READ(DSPTILEOFF(i));
10116	}	10127	}
10117		10128
10118	error->pipe[i].conf = I915_READ(PIPECONF(cpu_transcoder));
10119	error->pipe[i].source = I915_READ(PIPESRC(i));	10129	error->pipe[i].source = I915_READ(PIPESRC(i));
10120	error->pipe[i].htotal = I915_READ(HTOTAL(cpu_transcoder));	10130	}
10121	error->pipe[i].hblank = I915_READ(HBLANK(cpu_transcoder));	10131
10122	error->pipe[i].hsync = I915_READ(HSYNC(cpu_transcoder));	10132	error->num_transcoders = INTEL_INFO(dev)->num_pipes;
10123	error->pipe[i].vtotal = I915_READ(VTOTAL(cpu_transcoder));	10133	if (HAS_DDI(dev_priv->dev))
10124	error->pipe[i].vblank = I915_READ(VBLANK(cpu_transcoder));	10134	error->num_transcoders++; /* Account for eDP. */
10125	error->pipe[i].vsync = I915_READ(VSYNC(cpu_transcoder));	10135
		10136	for (i = 0; i < error->num_transcoders; i++) {
		10137	enum transcoder cpu_transcoder = transcoders[i];
		10138
		10139	error->transcoder[i].cpu_transcoder = cpu_transcoder;
		10140
		10141	error->transcoder[i].conf = I915_READ(PIPECONF(cpu_transcoder));
		10142	error->transcoder[i].htotal = I915_READ(HTOTAL(cpu_transcoder));
		10143	error->transcoder[i].hblank = I915_READ(HBLANK(cpu_transcoder));
		10144	error->transcoder[i].hsync = I915_READ(HSYNC(cpu_transcoder));
		10145	error->transcoder[i].vtotal = I915_READ(VTOTAL(cpu_transcoder));
		10146	error->transcoder[i].vblank = I915_READ(VBLANK(cpu_transcoder));
		10147	error->transcoder[i].vsync = I915_READ(VSYNC(cpu_transcoder));
10126	}	10148	}
10127		10149
10128	/* In the code above we read the registers without checking if the power	10150	/* In the code above we read the registers without checking if the power
@@ -10144,22 +10166,16 @@ intel_display_print_error_state(struct drm_i915_error_state_buf *m, · 15 unmodified lines
10144	{	10166	{
10145	int i;	10167	int i;
10146		10168
		10169	if (!error)
		10170	return;
		10171
10147	err_printf(m, "Num Pipes: %d\n", INTEL_INFO(dev)->num_pipes);	10172	err_printf(m, "Num Pipes: %d\n", INTEL_INFO(dev)->num_pipes);
10148	if (HAS_POWER_WELL(dev))	10173	if (HAS_POWER_WELL(dev))
10149	err_printf(m, "PWR_WELL_CTL2: %08x\n",	10174	err_printf(m, "PWR_WELL_CTL2: %08x\n",
10150	error->power_well_driver);	10175	error->power_well_driver);
10151	for_each_pipe(i) {	10176	for_each_pipe(i) {
10152	err_printf(m, "Pipe [%d]:\n", i);	10177	err_printf(m, "Pipe [%d]:\n", i);
10153	err_printf(m, " CPU transcoder: %c\n",
10154	transcoder_name(error->pipe[i].cpu_transcoder));
10155	err_printf(m, " CONF: %08x\n", error->pipe[i].conf);
10156	err_printf(m, " SRC: %08x\n", error->pipe[i].source);	10178	err_printf(m, " SRC: %08x\n", error->pipe[i].source);
10157	err_printf(m, " HTOTAL: %08x\n", error->pipe[i].htotal);
10158	err_printf(m, " HBLANK: %08x\n", error->pipe[i].hblank);
10159	err_printf(m, " HSYNC: %08x\n", error->pipe[i].hsync);
10160	err_printf(m, " VTOTAL: %08x\n", error->pipe[i].vtotal);
10161	err_printf(m, " VBLANK: %08x\n", error->pipe[i].vblank);
10162	err_printf(m, " VSYNC: %08x\n", error->pipe[i].vsync);
10163		10179
10164	err_printf(m, "Plane [%d]:\n", i);	10180	err_printf(m, "Plane [%d]:\n", i);
10165	err_printf(m, " CNTR: %08x\n", error->plane[i].control);	10181	err_printf(m, " CNTR: %08x\n", error->plane[i].control);
@@ -10180,5 +10196,17 @@ intel_display_print_error_state(struct drm_i915_error_state_buf *m, · 14 unmodified lines
10180	err_printf(m, " POS: %08x\n", error->cursor[i].position);	10196	err_printf(m, " POS: %08x\n", error->cursor[i].position);
10181	err_printf(m, " BASE: %08x\n", error->cursor[i].base);	10197	err_printf(m, " BASE: %08x\n", error->cursor[i].base);
10182	}	10198	}
		10199
		10200	for (i = 0; i < error->num_transcoders; i++) {
		10201	err_printf(m, " CPU transcoder: %c\n",
		10202	transcoder_name(error->transcoder[i].cpu_transcoder));
		10203	err_printf(m, " CONF: %08x\n", error->transcoder[i].conf);
		10204	err_printf(m, " HTOTAL: %08x\n", error->transcoder[i].htotal);
		10205	err_printf(m, " HBLANK: %08x\n", error->transcoder[i].hblank);
		10206	err_printf(m, " HSYNC: %08x\n", error->transcoder[i].hsync);
		10207	err_printf(m, " VTOTAL: %08x\n", error->transcoder[i].vtotal);
		10208	err_printf(m, " VBLANK: %08x\n", error->transcoder[i].vblank);
		10209	err_printf(m, " VSYNC: %08x\n", error->transcoder[i].vsync);
		10210	}
10183	}	10211	}
10184	#endif	10212	#endif

drivers/gpu/drm/i915/intel_ringbuffer.c+12−0

@@ -968,6 +968,18 @@ void intel_ring_setup_status_page(struct intel_ring_buffer *ring) · 967 unmodified lines
968		968
969	I915_WRITE(mmio, (u32)ring->status_page.gfx_addr);	969	I915_WRITE(mmio, (u32)ring->status_page.gfx_addr);
970	POSTING_READ(mmio);	970	POSTING_READ(mmio);
		971
		972	/* Flush the TLB for this page */
		973	if (INTEL_INFO(dev)->gen >= 6) {
		974	u32 reg = RING_INSTPM(ring->mmio_base);
		975	I915_WRITE(reg,
		976	_MASKED_BIT_ENABLE(INSTPM_TLB_INVALIDATE \|
		977	INSTPM_SYNC_FLUSH));
		978	if (wait_for((I915_READ(reg) & INSTPM_SYNC_FLUSH) == 0,
		979	1000))
		980	DRM_ERROR("%s: wait for SyncFlush to complete for TLB invalidation timed out\n",
		981	ring->name);
		982	}
971	}	983	}
972		984
973	static int	985	static int

drivers/gpu/drm/nouveau/core/core/mm.c+4−0

 	u32 splitoff;
 	u32 s, e;
+	BUG_ON(!type);
 	list_for_each_entry(this, &mm->free, fl_entry) {
 		e = this->offset + this->length;
 		s = this->offset;
 	struct nouveau_mm_node *prev, *this, *next;
 	u32 mask = align - 1;
+	BUG_ON(!type);
 	list_for_each_entry_reverse(this, &mm->free, fl_entry) {
 		u32 e = this->offset + this->length;
 		u32 s = this->offset;

drivers/gpu/drm/nouveau/core/include/subdev/mc.h+4−3

 	return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_MC];
 }
-#define nouveau_mc_create(p,e,o,d)                                             \
+#define nouveau_mc_create(p,e,o,m,d)                                           \
-	nouveau_mc_create_((p), (e), (o), sizeof(**d), (void **)d)
+	nouveau_mc_create_((p), (e), (o), (m), sizeof(**d), (void **)d)
 #define nouveau_mc_destroy(p) ({                                               \
 	struct nouveau_mc *pmc = (p); _nouveau_mc_dtor(nv_object(pmc));        \
 })
 })
 int  nouveau_mc_create_(struct nouveau_object *, struct nouveau_object *,
-			struct nouveau_oclass *, int, void **);
+			struct nouveau_oclass *, const struct nouveau_mc_intr *,
+			int, void **);
 void _nouveau_mc_dtor(struct nouveau_object *);
 int  _nouveau_mc_init(struct nouveau_object *);
 int  _nouveau_mc_fini(struct nouveau_object *, bool);

drivers/gpu/drm/nouveau/core/subdev/fb/ramnv49.c+6−6

@@ -40,15 +40,15 @@ nv49_ram_create(struct nouveau_object parent, struct nouveau_object engine, · 39 unmodified lines
40	return ret;	40	return ret;
41		41
42	switch (pfb914 & 0x00000003) {	42	switch (pfb914 & 0x00000003) {
43	case 0x00000000: pfb->ram->type = NV_MEM_TYPE_DDR1; break;	43	case 0x00000000: ram->type = NV_MEM_TYPE_DDR1; break;
44	case 0x00000001: pfb->ram->type = NV_MEM_TYPE_DDR2; break;	44	case 0x00000001: ram->type = NV_MEM_TYPE_DDR2; break;
45	case 0x00000002: pfb->ram->type = NV_MEM_TYPE_GDDR3; break;	45	case 0x00000002: ram->type = NV_MEM_TYPE_GDDR3; break;
46	case 0x00000003: break;	46	case 0x00000003: break;
47	}	47	}
48		48
49	pfb->ram->size = nv_rd32(pfb, 0x10020c) & 0xff000000;	49	ram->size = nv_rd32(pfb, 0x10020c) & 0xff000000;
50	pfb->ram->parts = (nv_rd32(pfb, 0x100200) & 0x00000003) + 1;	50	ram->parts = (nv_rd32(pfb, 0x100200) & 0x00000003) + 1;
51	pfb->ram->tags = nv_rd32(pfb, 0x100320);	51	ram->tags = nv_rd32(pfb, 0x100320);
52	return 0;	52	return 0;
53	}	53	}
54		54

drivers/gpu/drm/nouveau/core/subdev/fb/ramnv4e.c+2−2

@@ -38,8 +38,8 @@ nv4e_ram_create(struct nouveau_object parent, struct nouveau_object engine, · 37 unmodified lines
38	if (ret)	38	if (ret)
39	return ret;	39	return ret;
40		40
41	pfb->ram->size = nv_rd32(pfb, 0x10020c) & 0xff000000;	41	ram->size = nv_rd32(pfb, 0x10020c) & 0xff000000;
42	pfb->ram->type = NV_MEM_TYPE_STOLEN;	42	ram->type = NV_MEM_TYPE_STOLEN;
43	return 0;	43	return 0;
44	}	44	}
45		45

drivers/gpu/drm/nouveau/core/subdev/ltcg/nvc0.c+24−10

 	struct nouveau_ltcg base;
 	u32 part_nr;
 	u32 subp_nr;
-	struct nouveau_mm tags;
 	u32 num_tags;
+	u32 tag_base;
+	struct nouveau_mm tags;
 	struct nouveau_mm_node *tag_ram;
 };
 	u32 tag_size, tag_margin, tag_align;
 	int ret;
-	nv_wr32(priv, 0x17e8d8, priv->part_nr);
-	if (nv_device(pfb)->card_type >= NV_E0)
-		nv_wr32(priv, 0x17e000, priv->part_nr);
 	/* tags for 1/4 of VRAM should be enough (8192/4 per GiB of VRAM) */
 	priv->num_tags = (pfb->ram->size >> 17) / 4;
 	if (priv->num_tags > (1 << 17))
 	tag_size += tag_align;
 	tag_size  = (tag_size + 0xfff) >> 12; /* round up */
-	ret = nouveau_mm_tail(&pfb->vram, 0, tag_size, tag_size, 1,
+	ret = nouveau_mm_tail(&pfb->vram, 1, tag_size, tag_size, 1,
 	                      &priv->tag_ram);
 	if (ret) {
 		priv->num_tags = 0;
 		tag_base += tag_align - 1;
 		ret = do_div(tag_base, tag_align);
-		nv_wr32(priv, 0x17e8d4, tag_base);
+		priv->tag_base = tag_base;
 	}
 	ret = nouveau_mm_init(&priv->tags, 0, priv->num_tags, 1);
 	}
 	priv->subp_nr = nv_rd32(priv, 0x17e8dc) >> 28;
-	nv_mask(priv, 0x17e820, 0x00100000, 0x00000000); /* INTR_EN &= ~0x10 */
 	ret = nvc0_ltcg_init_tag_ram(pfb, priv);
 	if (ret)
 		return ret;
 	nouveau_ltcg_destroy(ltcg);
 }
+static int
+nvc0_ltcg_init(struct nouveau_object *object)
+{
+	struct nouveau_ltcg *ltcg = (struct nouveau_ltcg *)object;
+	struct nvc0_ltcg_priv *priv = (struct nvc0_ltcg_priv *)ltcg;
+	int ret;
+	ret = nouveau_ltcg_init(ltcg);
+	if (ret)
+		return ret;
+	nv_mask(priv, 0x17e820, 0x00100000, 0x00000000); /* INTR_EN &= ~0x10 */
+	nv_wr32(priv, 0x17e8d8, priv->part_nr);
+	if (nv_device(ltcg)->card_type >= NV_E0)
+		nv_wr32(priv, 0x17e000, priv->part_nr);
+	nv_wr32(priv, 0x17e8d4, priv->tag_base);
+	return 0;
+}
 struct nouveau_oclass
 nvc0_ltcg_oclass = {
 	.handle = NV_SUBDEV(LTCG, 0xc0),
 	.ofuncs = &(struct nouveau_ofuncs) {
 		.ctor = nvc0_ltcg_ctor,
 		.dtor = nvc0_ltcg_dtor,
-		.init = _nouveau_ltcg_init,
+		.init = nvc0_ltcg_init,
 		.fini = _nouveau_ltcg_fini,
 	},
 };

drivers/gpu/drm/nouveau/core/subdev/mc/base.c+5−1

 int
 nouveau_mc_create_(struct nouveau_object *parent, struct nouveau_object *engine,
-		   struct nouveau_oclass *oclass, int length, void **pobject)
+		   struct nouveau_oclass *oclass,
+		   const struct nouveau_mc_intr *intr_map,
+		   int length, void **pobject)
 {
 	struct nouveau_device *device = nv_device(parent);
 	struct nouveau_mc *pmc;
 	if (ret)
 		return ret;
+	pmc->intr_map = intr_map;
 	ret = request_irq(device->pdev->irq, nouveau_mc_intr,
 			  IRQF_SHARED, "nouveau", pmc);
 	if (ret < 0)

drivers/gpu/drm/nouveau/core/subdev/mc/nv04.c+1−2

 	struct nv04_mc_priv *priv;
 	int ret;
-	ret = nouveau_mc_create(parent, engine, oclass, &priv);
+	ret = nouveau_mc_create(parent, engine, oclass, nv04_mc_intr, &priv);
 	*pobject = nv_object(priv);
 	if (ret)
 		return ret;
-	priv->base.intr_map = nv04_mc_intr;
 	return 0;
 }

drivers/gpu/drm/nouveau/core/subdev/mc/nv44.c+1−2

 	struct nv44_mc_priv *priv;
 	int ret;
-	ret = nouveau_mc_create(parent, engine, oclass, &priv);
+	ret = nouveau_mc_create(parent, engine, oclass, nv04_mc_intr, &priv);
 	*pobject = nv_object(priv);
 	if (ret)
 		return ret;
-	priv->base.intr_map = nv04_mc_intr;
 	return 0;
 }

drivers/gpu/drm/nouveau/core/subdev/mc/nv50.c+1−2

 	struct nv50_mc_priv *priv;
 	int ret;
-	ret = nouveau_mc_create(parent, engine, oclass, &priv);
+	ret = nouveau_mc_create(parent, engine, oclass, nv50_mc_intr, &priv);
 	*pobject = nv_object(priv);
 	if (ret)
 		return ret;
-	priv->base.intr_map = nv50_mc_intr;
 	return 0;
 }

drivers/gpu/drm/nouveau/core/subdev/mc/nv98.c+1−2

 	struct nv98_mc_priv *priv;
 	int ret;
-	ret = nouveau_mc_create(parent, engine, oclass, &priv);
+	ret = nouveau_mc_create(parent, engine, oclass, nv98_mc_intr, &priv);
 	*pobject = nv_object(priv);
 	if (ret)
 		return ret;
-	priv->base.intr_map = nv98_mc_intr;
 	return 0;
 }

drivers/gpu/drm/nouveau/core/subdev/mc/nvc0.c+1−2

 	struct nvc0_mc_priv *priv;
 	int ret;
-	ret = nouveau_mc_create(parent, engine, oclass, &priv);
+	ret = nouveau_mc_create(parent, engine, oclass, nvc0_mc_intr, &priv);
 	*pobject = nv_object(priv);
 	if (ret)
 		return ret;
-	priv->base.intr_map = nvc0_mc_intr;
 	return 0;
 }

drivers/gpu/drm/nouveau/dispnv04/crtc.c+43−15

 	regp->ramdac_a34 = 0x1;
 }
+static int
+nv_crtc_swap_fbs(struct drm_crtc *crtc, struct drm_framebuffer *old_fb)
+{
+	struct nv04_display *disp = nv04_display(crtc->dev);
+	struct nouveau_framebuffer *nvfb = nouveau_framebuffer(crtc->fb);
+	struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+	int ret;
+	ret = nouveau_bo_pin(nvfb->nvbo, TTM_PL_FLAG_VRAM);
+	if (ret == 0) {
+		if (disp->image[nv_crtc->index])
+			nouveau_bo_unpin(disp->image[nv_crtc->index]);
+		nouveau_bo_ref(nvfb->nvbo, &disp->image[nv_crtc->index]);
+	}
+	return ret;
+}
 /**
  * Sets up registers for the given mode/adjusted_mode pair.
  *
 	struct drm_device *dev = crtc->dev;
 	struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 	struct nouveau_drm *drm = nouveau_drm(dev);
+	int ret;
 	NV_DEBUG(drm, "CTRC mode on CRTC %d:\n", nv_crtc->index);
 	drm_mode_debug_printmodeline(adjusted_mode);
+	ret = nv_crtc_swap_fbs(crtc, old_fb);
+	if (ret)
+		return ret;
 	/* unlock must come after turning off FP_TG_CONTROL in output_prepare */
 	nv_lock_vga_crtc_shadow(dev, nv_crtc->index, -1);
 static void nv_crtc_destroy(struct drm_crtc *crtc)
 {
+	struct nv04_display *disp = nv04_display(crtc->dev);
 	struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 	if (!nv_crtc)
 	drm_crtc_cleanup(crtc);
+	if (disp->image[nv_crtc->index])
+		nouveau_bo_unpin(disp->image[nv_crtc->index]);
+	nouveau_bo_ref(NULL, &disp->image[nv_crtc->index]);
 	nouveau_bo_unmap(nv_crtc->cursor.nvbo);
 	nouveau_bo_unpin(nv_crtc->cursor.nvbo);
 	nouveau_bo_ref(NULL, &nv_crtc->cursor.nvbo);
 	nouveau_hw_load_state_palette(dev, nv_crtc->index, &nv04_display(dev)->mode_reg);
 }
+static void
+nv_crtc_disable(struct drm_crtc *crtc)
+{
+	struct nv04_display *disp = nv04_display(crtc->dev);
+	struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+	if (disp->image[nv_crtc->index])
+		nouveau_bo_unpin(disp->image[nv_crtc->index]);
+	nouveau_bo_ref(NULL, &disp->image[nv_crtc->index]);
+}
 static void
 nv_crtc_gamma_set(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, uint32_t start,
 		  uint32_t size)
 	struct drm_framebuffer *drm_fb;
 	struct nouveau_framebuffer *fb;
 	int arb_burst, arb_lwm;
-	int ret;
 	NV_DEBUG(drm, "index %d\n", nv_crtc->index);
 		return 0;
 	}
 	/* If atomic, we want to switch to the fb we were passed, so
-	 * now we update pointers to do that.  (We don't pin; just
+	 * now we update pointers to do that.
-	 * assume we're already pinned and update the base address.)
 	 */
 	if (atomic) {
 		drm_fb = passed_fb;
 	} else {
 		drm_fb = crtc->fb;
 		fb = nouveau_framebuffer(crtc->fb);
-		/* If not atomic, we can go ahead and pin, and unpin the
-		 * old fb we were passed.
-		 */
-		ret = nouveau_bo_pin(fb->nvbo, TTM_PL_FLAG_VRAM);
-		if (ret)
-			return ret;
-		if (passed_fb) {
-			struct nouveau_framebuffer *ofb = nouveau_framebuffer(passed_fb);
-			nouveau_bo_unpin(ofb->nvbo);
-		}
 	}
 	nv_crtc->fb.offset = fb->nvbo->bo.offset;
 nv04_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
 			struct drm_framebuffer *old_fb)
 {
+	int ret = nv_crtc_swap_fbs(crtc, old_fb);
+	if (ret)
+		return ret;
 	return nv04_crtc_do_mode_set_base(crtc, old_fb, x, y, false);
 }
 	.mode_set_base = nv04_crtc_mode_set_base,
 	.mode_set_base_atomic = nv04_crtc_mode_set_base_atomic,
 	.load_lut = nv_crtc_gamma_load,
+	.disable = nv_crtc_disable,
 };
 int

drivers/gpu/drm/nouveau/dispnv04/disp.h+1−0

@@ -81,6 +81,7 @@ struct nv04_display { · 80 unmodified lines
81	uint32_t saved_vga_font[4][16384];	81	uint32_t saved_vga_font[4][16384];
82	uint32_t dac_users[4];	82	uint32_t dac_users[4];
83	struct nouveau_object *core;	83	struct nouveau_object *core;
		84	struct nouveau_bo *image[2];
84	};	85	};
85		86
86	static inline struct nv04_display *	87	static inline struct nv04_display *

drivers/gpu/drm/nouveau/nouveau_display.c+3−0

 		ret = nv50_display_flip_next(crtc, fb, chan, 0);
 		if (ret)
 			goto fail_unreserve;
+	} else {
+		struct nv04_display *dispnv04 = nv04_display(dev);
+		nouveau_bo_ref(new_bo, &dispnv04->image[nouveau_crtc(crtc)->index]);
 	}
 	ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence);

drivers/gpu/drm/nouveau/nv40_pm.c+1−1

@@ -131,7 +131,7 @@ nv40_calc_pll(struct drm_device dev, u32 reg, struct nvbios_pll pll, · 130 unmodified lines
131	if (clk < pll->vco1.max_freq)	131	if (clk < pll->vco1.max_freq)
132	pll->vco2.max_freq = 0;	132	pll->vco2.max_freq = 0;
133		133
134	pclk->pll_calc(pclk, pll, clk, &coef);	134	ret = pclk->pll_calc(pclk, pll, clk, &coef);
135	if (ret == 0)	135	if (ret == 0)
136	return -ERANGE;	136	return -ERANGE;
137		137

drivers/gpu/drm/radeon/radeon.h+1−1

@@ -2163,7 +2163,7 @@ void cik_mm_wdoorbell(struct radeon_device *rdev, u32 offset, u32 v); · 2162 unmodified lines
2163	WREG32(reg, tmp_); \	2163	WREG32(reg, tmp_); \
2164	} while (0)	2164	} while (0)
2165	#define WREG32_AND(reg, and) WREG32_P(reg, 0, and)	2165	#define WREG32_AND(reg, and) WREG32_P(reg, 0, and)
2166	#define WREG32_OR(reg, or) WREG32_P(reg, or, ~or)	2166	#define WREG32_OR(reg, or) WREG32_P(reg, or, ~(or))
2167	#define WREG32_PLL_P(reg, val, mask) \	2167	#define WREG32_PLL_P(reg, val, mask) \
2168	do { \	2168	do { \
2169	uint32_t tmp_ = RREG32_PLL(reg); \	2169	uint32_t tmp_ = RREG32_PLL(reg); \

drivers/gpu/drm/radeon/radeon_uvd.c+8−0

@@ -356,6 +356,14 @@ static int radeon_uvd_cs_msg(struct radeon_cs_parser p, struct radeon_bo bo, · 355 unmodified lines
356	return -EINVAL;	356	return -EINVAL;
357	}	357	}
358		358
		359	if (bo->tbo.sync_obj) {
		360	r = radeon_fence_wait(bo->tbo.sync_obj, false);
		361	if (r) {
		362	DRM_ERROR("Failed waiting for UVD message (%d)!\n", r);
		363	return r;
		364	}
		365	}
		366
359	r = radeon_bo_kmap(bo, &ptr);	367	r = radeon_bo_kmap(bo, &ptr);
360	if (r) {	368	if (r) {
361	DRM_ERROR("Failed mapping the UVD message (%d)!\n", r);	369	DRM_ERROR("Failed mapping the UVD message (%d)!\n", r);

drivers/gpu/drm/radeon/rv770.c+6−6

@@ -744,10 +744,10 @@ static void rv770_init_golden_registers(struct radeon_device *rdev) · 743 unmodified lines
744	(const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));	744	(const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));
745	radeon_program_register_sequence(rdev,	745	radeon_program_register_sequence(rdev,
746	rv730_golden_registers,	746	rv730_golden_registers,
747	(const u32)ARRAY_SIZE(rv770_golden_registers));	747	(const u32)ARRAY_SIZE(rv730_golden_registers));
748	radeon_program_register_sequence(rdev,	748	radeon_program_register_sequence(rdev,
749	rv730_mgcg_init,	749	rv730_mgcg_init,
750	(const u32)ARRAY_SIZE(rv770_mgcg_init));	750	(const u32)ARRAY_SIZE(rv730_mgcg_init));
751	break;	751	break;
752	case CHIP_RV710:	752	case CHIP_RV710:
753	radeon_program_register_sequence(rdev,	753	radeon_program_register_sequence(rdev,
@@ -758,18 +758,18 @@ static void rv770_init_golden_registers(struct radeon_device *rdev) · 4 unmodified lines
758	(const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));	758	(const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));
759	radeon_program_register_sequence(rdev,	759	radeon_program_register_sequence(rdev,
760	rv710_golden_registers,	760	rv710_golden_registers,
761	(const u32)ARRAY_SIZE(rv770_golden_registers));	761	(const u32)ARRAY_SIZE(rv710_golden_registers));
762	radeon_program_register_sequence(rdev,	762	radeon_program_register_sequence(rdev,
763	rv710_mgcg_init,	763	rv710_mgcg_init,
764	(const u32)ARRAY_SIZE(rv770_mgcg_init));	764	(const u32)ARRAY_SIZE(rv710_mgcg_init));
765	break;	765	break;
766	case CHIP_RV740:	766	case CHIP_RV740:
767	radeon_program_register_sequence(rdev,	767	radeon_program_register_sequence(rdev,
768	rv740_golden_registers,	768	rv740_golden_registers,
769	(const u32)ARRAY_SIZE(rv770_golden_registers));	769	(const u32)ARRAY_SIZE(rv740_golden_registers));
770	radeon_program_register_sequence(rdev,	770	radeon_program_register_sequence(rdev,
771	rv740_mgcg_init,	771	rv740_mgcg_init,
772	(const u32)ARRAY_SIZE(rv770_mgcg_init));	772	(const u32)ARRAY_SIZE(rv740_mgcg_init));
773	break;	773	break;
774	default:	774	default:
775	break;	775	break;

drivers/iio/light/adjd_s311.c+2−1

@@ -232,7 +232,8 @@ static int adjd_s311_read_raw(struct iio_dev *indio_dev, · 231 unmodified lines
232		232
233	switch (mask) {	233	switch (mask) {
234	case IIO_CHAN_INFO_RAW:	234	case IIO_CHAN_INFO_RAW:
235	ret = adjd_s311_read_data(indio_dev, chan->address, val);	235	ret = adjd_s311_read_data(indio_dev,
		236	ADJD_S311_DATA_REG(chan->address), val);
236	if (ret < 0)	237	if (ret < 0)
237	return ret;	238	return ret;
238	return IIO_VAL_INT;	239	return IIO_VAL_INT;

drivers/md/dm-cache-policy-mq.c+7−9

 	return r;
 }
-static void remove_mapping(struct mq_policy *mq, dm_oblock_t oblock)
+static void mq_remove_mapping(struct dm_cache_policy *p, dm_oblock_t oblock)
 {
-	struct entry *e = hash_lookup(mq, oblock);
+	struct mq_policy *mq = to_mq_policy(p);
+	struct entry *e;
+	mutex_lock(&mq->lock);
+	e = hash_lookup(mq, oblock);
 	BUG_ON(!e || !e->in_cache);
 	del(mq, e);
 	e->in_cache = false;
 	push(mq, e);
-}
-static void mq_remove_mapping(struct dm_cache_policy *p, dm_oblock_t oblock)
-{
-	struct mq_policy *mq = to_mq_policy(p);
-	mutex_lock(&mq->lock);
-	remove_mapping(mq, oblock);
 	mutex_unlock(&mq->lock);
 }

drivers/net/bonding/bond_main.c+7−1

  * The bonding ndo_neigh_setup is called at init time beofre any
  * slave exists. So we must declare proxy setup function which will
  * be used at run time to resolve the actual slave neigh param setup.
+ *
+ * It's also called by master devices (such as vlans) to setup their
+ * underlying devices. In that case - do nothing, we're already set up from
+ * our init.
  */
 static int bond_neigh_setup(struct net_device *dev,
 			    struct neigh_parms *parms)
 {
-	parms->neigh_setup   = bond_neigh_init;
+	/* modify only our neigh_parms */
+	if (parms->dev == dev)
+		parms->neigh_setup = bond_neigh_init;
 	return 0;
 }

drivers/net/can/usb/peak_usb/pcan_usb.c+1−1

@@ -649,7 +649,7 @@ static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len) · 648 unmodified lines
649	if ((mc->ptr + rec_len) > mc->end)	649	if ((mc->ptr + rec_len) > mc->end)
650	goto decode_failed;	650	goto decode_failed;
651		651
652	memcpy(cf->data, mc->ptr, rec_len);	652	memcpy(cf->data, mc->ptr, cf->can_dlc);
653	mc->ptr += rec_len;	653	mc->ptr += rec_len;
654	}	654	}
655		655

drivers/net/ethernet/arc/emac_main.c+1−1

@@ -199,7 +199,7 @@ static int arc_emac_rx(struct net_device *ndev, int budget) · 198 unmodified lines
199	struct arc_emac_priv *priv = netdev_priv(ndev);	199	struct arc_emac_priv *priv = netdev_priv(ndev);
200	unsigned int work_done;	200	unsigned int work_done;
201		201
202	for (work_done = 0; work_done <= budget; work_done++) {	202	for (work_done = 0; work_done < budget; work_done++) {
203	unsigned int *last_rx_bd = &priv->last_rx_bd;	203	unsigned int *last_rx_bd = &priv->last_rx_bd;
204	struct net_device_stats *stats = &priv->stats;	204	struct net_device_stats *stats = &priv->stats;
205	struct buffer_state rx_buff = &priv->rx_buff[last_rx_bd];	205	struct buffer_state rx_buff = &priv->rx_buff[last_rx_bd];

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h+7−0

 	BNX2X_SP_RTNL_VFPF_CHANNEL_DOWN,
 	BNX2X_SP_RTNL_VFPF_STORM_RX_MODE,
 	BNX2X_SP_RTNL_HYPERVISOR_VLAN,
+	BNX2X_SP_RTNL_TX_STOP,
+	BNX2X_SP_RTNL_TX_RESUME,
 };
 struct bnx2x_prev_path_list {
 #define BC_SUPPORTS_DCBX_MSG_NON_PMF	(1 << 21)
 #define IS_VF_FLAG			(1 << 22)
 #define INTERRUPTS_ENABLED_FLAG		(1 << 23)
+#define BC_SUPPORTS_RMMOD_CMD		(1 << 24)
 #define BP_NOMCP(bp)			((bp)->flags & NO_MCP_FLAG)
 	int fp_array_size;
 	u32 dump_preset_idx;
+	bool					stats_started;
+	struct semaphore			stats_sema;
 };
 /* Tx queues may be less or equal to Rx queues */
 	BNX2X_PCI_LINK_SPEED_5000 = 5000,
 	BNX2X_PCI_LINK_SPEED_8000 = 8000
 };
+void bnx2x_set_local_cmng(struct bnx2x *bp);
 #endif /* bnx2x.h */

drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.c+42−11

@@ -30,10 +30,8 @@ · 29 unmodified lines
30	#include "bnx2x_dcb.h"	30	#include "bnx2x_dcb.h"
31		31
32	/* forward declarations of dcbx related functions */	32	/* forward declarations of dcbx related functions */
33	static int bnx2x_dcbx_stop_hw_tx(struct bnx2x *bp);
34	static void bnx2x_pfc_set_pfc(struct bnx2x *bp);	33	static void bnx2x_pfc_set_pfc(struct bnx2x *bp);
35	static void bnx2x_dcbx_update_ets_params(struct bnx2x *bp);	34	static void bnx2x_dcbx_update_ets_params(struct bnx2x *bp);
36	static int bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp);
37	static void bnx2x_dcbx_get_ets_pri_pg_tbl(struct bnx2x *bp,	35	static void bnx2x_dcbx_get_ets_pri_pg_tbl(struct bnx2x *bp,
38	u32 *set_configuration_ets_pg,	36	u32 *set_configuration_ets_pg,
39	u32 *pri_pg_tbl);	37	u32 *pri_pg_tbl);
@@ -425,30 +423,52 @@ static void bnx2x_pfc_set_pfc(struct bnx2x *bp) · 385 unmodified lines
425	bnx2x_pfc_clear(bp);	423	bnx2x_pfc_clear(bp);
426	}	424	}
427		425
428	static int bnx2x_dcbx_stop_hw_tx(struct bnx2x *bp)	426	int bnx2x_dcbx_stop_hw_tx(struct bnx2x *bp)
429	{	427	{
430	struct bnx2x_func_state_params func_params = {NULL};	428	struct bnx2x_func_state_params func_params = {NULL};
		429	int rc;
431		430
432	func_params.f_obj = &bp->func_obj;	431	func_params.f_obj = &bp->func_obj;
433	func_params.cmd = BNX2X_F_CMD_TX_STOP;	432	func_params.cmd = BNX2X_F_CMD_TX_STOP;
434		433
		434	__set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
		435	__set_bit(RAMROD_RETRY, &func_params.ramrod_flags);
		436
435	DP(BNX2X_MSG_DCB, "STOP TRAFFIC\n");	437	DP(BNX2X_MSG_DCB, "STOP TRAFFIC\n");
436	return bnx2x_func_state_change(bp, &func_params);	438
		439	rc = bnx2x_func_state_change(bp, &func_params);
		440	if (rc) {
		441	BNX2X_ERR("Unable to hold traffic for HW configuration\n");
		442	bnx2x_panic();
		443	}
		444
		445	return rc;
437	}	446	}
438		447
439	static int bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp)	448	int bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp)
440	{	449	{
441	struct bnx2x_func_state_params func_params = {NULL};	450	struct bnx2x_func_state_params func_params = {NULL};
442	struct bnx2x_func_tx_start_params *tx_params =	451	struct bnx2x_func_tx_start_params *tx_params =
443	&func_params.params.tx_start;	452	&func_params.params.tx_start;
		453	int rc;
444		454
445	func_params.f_obj = &bp->func_obj;	455	func_params.f_obj = &bp->func_obj;
446	func_params.cmd = BNX2X_F_CMD_TX_START;	456	func_params.cmd = BNX2X_F_CMD_TX_START;
447		457
		458	__set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
		459	__set_bit(RAMROD_RETRY, &func_params.ramrod_flags);
		460
448	bnx2x_dcbx_fw_struct(bp, tx_params);	461	bnx2x_dcbx_fw_struct(bp, tx_params);
449		462
450	DP(BNX2X_MSG_DCB, "START TRAFFIC\n");	463	DP(BNX2X_MSG_DCB, "START TRAFFIC\n");
451	return bnx2x_func_state_change(bp, &func_params);	464
		465	rc = bnx2x_func_state_change(bp, &func_params);
		466	if (rc) {
		467	BNX2X_ERR("Unable to resume traffic after HW configuration\n");
		468	bnx2x_panic();
		469	}
		470
		471	return rc;
452	}	472	}
453		473
454	static void bnx2x_dcbx_2cos_limit_update_ets_config(struct bnx2x *bp)	474	static void bnx2x_dcbx_2cos_limit_update_ets_config(struct bnx2x *bp)
@@ -744,7 +764,9 @@ void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state) · 289 unmodified lines
744	if (IS_MF(bp))	764	if (IS_MF(bp))
745	bnx2x_link_sync_notify(bp);	765	bnx2x_link_sync_notify(bp);
746		766
747	bnx2x_dcbx_stop_hw_tx(bp);	767	set_bit(BNX2X_SP_RTNL_TX_STOP, &bp->sp_rtnl_state);
		768
		769	schedule_delayed_work(&bp->sp_rtnl_task, 0);
748		770
749	return;	771	return;
750	}	772	}
@@ -753,7 +775,13 @@ void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state) · 2 unmodified lines
753	bnx2x_pfc_set_pfc(bp);	775	bnx2x_pfc_set_pfc(bp);
754		776
755	bnx2x_dcbx_update_ets_params(bp);	777	bnx2x_dcbx_update_ets_params(bp);
756	bnx2x_dcbx_resume_hw_tx(bp);	778
		779	/* ets may affect cmng configuration: reinit it in hw */
		780	bnx2x_set_local_cmng(bp);
		781
		782	set_bit(BNX2X_SP_RTNL_TX_RESUME, &bp->sp_rtnl_state);
		783
		784	schedule_delayed_work(&bp->sp_rtnl_task, 0);
757		785
758	return;	786	return;
759	case BNX2X_DCBX_STATE_TX_RELEASED:	787	case BNX2X_DCBX_STATE_TX_RELEASED:
@@ -2363,21 +2391,24 @@ static u8 bnx2x_dcbnl_get_featcfg(struct net_device *netdev, int featid, · 1603 unmodified lines
2363	case DCB_FEATCFG_ATTR_PG:	2391	case DCB_FEATCFG_ATTR_PG:
2364	if (bp->dcbx_local_feat.ets.enabled)	2392	if (bp->dcbx_local_feat.ets.enabled)
2365	*flags \|= DCB_FEATCFG_ENABLE;	2393	*flags \|= DCB_FEATCFG_ENABLE;
2366	if (bp->dcbx_error & DCBX_LOCAL_ETS_ERROR)	2394	if (bp->dcbx_error & (DCBX_LOCAL_ETS_ERROR \|
		2395	DCBX_REMOTE_MIB_ERROR))
2367	*flags \|= DCB_FEATCFG_ERROR;	2396	*flags \|= DCB_FEATCFG_ERROR;
2368	break;	2397	break;
2369	case DCB_FEATCFG_ATTR_PFC:	2398	case DCB_FEATCFG_ATTR_PFC:
2370	if (bp->dcbx_local_feat.pfc.enabled)	2399	if (bp->dcbx_local_feat.pfc.enabled)
2371	*flags \|= DCB_FEATCFG_ENABLE;	2400	*flags \|= DCB_FEATCFG_ENABLE;
2372	if (bp->dcbx_error & (DCBX_LOCAL_PFC_ERROR \|	2401	if (bp->dcbx_error & (DCBX_LOCAL_PFC_ERROR \|
2373	DCBX_LOCAL_PFC_MISMATCH))	2402	DCBX_LOCAL_PFC_MISMATCH \|
		2403	DCBX_REMOTE_MIB_ERROR))
2374	*flags \|= DCB_FEATCFG_ERROR;	2404	*flags \|= DCB_FEATCFG_ERROR;
2375	break;	2405	break;
2376	case DCB_FEATCFG_ATTR_APP:	2406	case DCB_FEATCFG_ATTR_APP:
2377	if (bp->dcbx_local_feat.app.enabled)	2407	if (bp->dcbx_local_feat.app.enabled)
2378	*flags \|= DCB_FEATCFG_ENABLE;	2408	*flags \|= DCB_FEATCFG_ENABLE;
2379	if (bp->dcbx_error & (DCBX_LOCAL_APP_ERROR \|	2409	if (bp->dcbx_error & (DCBX_LOCAL_APP_ERROR \|
2380	DCBX_LOCAL_APP_MISMATCH))	2410	DCBX_LOCAL_APP_MISMATCH \|
		2411	DCBX_REMOTE_MIB_ERROR))
2381	*flags \|= DCB_FEATCFG_ERROR;	2412	*flags \|= DCB_FEATCFG_ERROR;
2382	break;	2413	break;
2383	default:	2414	default:

drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.h+3−0

@@ -199,4 +199,7 @@ extern const struct dcbnl_rtnl_ops bnx2x_dcbnl_ops; · 198 unmodified lines
199	int bnx2x_dcbnl_update_applist(struct bnx2x *bp, bool delall);	199	int bnx2x_dcbnl_update_applist(struct bnx2x *bp, bool delall);
200	#endif /* BCM_DCBNL */	200	#endif /* BCM_DCBNL */
201		201
		202	int bnx2x_dcbx_stop_hw_tx(struct bnx2x *bp);
		203	int bnx2x_dcbx_resume_hw_tx(struct bnx2x *bp);
		204
202	#endif /* BNX2X_DCB_H */	205	#endif /* BNX2X_DCB_H */

drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h+5−0

 	#define DRV_MSG_CODE_EEE_RESULTS_ACK            0xda000000
+	#define DRV_MSG_CODE_RMMOD                      0xdb000000
+	#define REQ_BC_VER_4_RMMOD_CMD                  0x0007080f
 	#define DRV_MSG_CODE_SET_MF_BW                  0xe0000000
 	#define REQ_BC_VER_4_SET_MF_BW                  0x00060202
 	#define DRV_MSG_CODE_SET_MF_BW_ACK              0xe1000000
 	#define FW_MSG_CODE_EEE_RESULS_ACK              0xda100000
+	#define FW_MSG_CODE_RMMOD_ACK                   0xdb100000
 	#define FW_MSG_CODE_SET_MF_BW_SENT              0xe0000000
 	#define FW_MSG_CODE_SET_MF_BW_DONE              0xe1000000

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c+61−27

 		bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
 }
+static void bnx2x_init_dropless_fc(struct bnx2x *bp)
+{
+	u32 pause_enabled = 0;
+	if (!CHIP_IS_E1(bp) && bp->dropless_fc && bp->link_vars.link_up) {
+		if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
+			pause_enabled = 1;
+		REG_WR(bp, BAR_USTRORM_INTMEM +
+			   USTORM_ETH_PAUSE_ENABLED_OFFSET(BP_PORT(bp)),
+		       pause_enabled);
+	}
+	DP(NETIF_MSG_IFUP | NETIF_MSG_LINK, "dropless_fc is %s\n",
+	   pause_enabled ? "enabled" : "disabled");
+}
 int bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
 {
 	int rc, cfx_idx = bnx2x_get_link_cfg_idx(bp);
 		bnx2x_release_phy_lock(bp);
+		bnx2x_init_dropless_fc(bp);
 		bnx2x_calc_fc_adv(bp);
 		if (bp->link_vars.link_up) {
 		bnx2x_phy_init(&bp->link_params, &bp->link_vars);
 		bnx2x_release_phy_lock(bp);
+		bnx2x_init_dropless_fc(bp);
 		bnx2x_calc_fc_adv(bp);
 	} else
 		BNX2X_ERR("Bootcode is missing - can not set link\n");
 	input.port_rate = bp->link_vars.line_speed;
-	if (cmng_type == CMNG_FNS_MINMAX) {
+	if (cmng_type == CMNG_FNS_MINMAX && input.port_rate) {
 		int vn;
 		/* read mf conf from shmem */
 	}
 }
+/* init cmng mode in HW according to local configuration */
+void bnx2x_set_local_cmng(struct bnx2x *bp)
+{
+	int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
+	if (cmng_fns != CMNG_FNS_NONE) {
+		bnx2x_cmng_fns_init(bp, false, cmng_fns);
+		storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
+	} else {
+		/* rate shaping and fairness are disabled */
+		DP(NETIF_MSG_IFUP,
+		   "single function mode without fairness\n");
+	}
+}
 /* This function is called upon link interrupt */
 static void bnx2x_link_attn(struct bnx2x *bp)
 {
 	bnx2x_link_update(&bp->link_params, &bp->link_vars);
-	if (bp->link_vars.link_up) {
+	bnx2x_init_dropless_fc(bp);
-		/* dropless flow control */
+	if (bp->link_vars.link_up) {
-		if (!CHIP_IS_E1(bp) && bp->dropless_fc) {
-			int port = BP_PORT(bp);
-			u32 pause_enabled = 0;
-			if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
-				pause_enabled = 1;
-			REG_WR(bp, BAR_USTRORM_INTMEM +
-			       USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
-			       pause_enabled);
-		}
 		if (bp->link_vars.mac_type != MAC_TYPE_EMAC) {
 			struct host_port_stats *pstats;
 			bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
 	}
-	if (bp->link_vars.link_up && bp->link_vars.line_speed) {
+	if (bp->link_vars.link_up && bp->link_vars.line_speed)
-		int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
+		bnx2x_set_local_cmng(bp);
-		if (cmng_fns != CMNG_FNS_NONE) {
-			bnx2x_cmng_fns_init(bp, false, cmng_fns);
-			storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
-		} else
-			/* rate shaping and fairness are disabled */
-			DP(NETIF_MSG_IFUP,
-			   "single function mode without fairness\n");
-	}
 	__bnx2x_link_report(bp);
 			       &bp->sp_rtnl_state))
 		bnx2x_pf_set_vfs_vlan(bp);
+	if (test_and_clear_bit(BNX2X_SP_RTNL_TX_STOP, &bp->sp_rtnl_state))
+		bnx2x_dcbx_stop_hw_tx(bp);
+	if (test_and_clear_bit(BNX2X_SP_RTNL_TX_RESUME, &bp->sp_rtnl_state))
+		bnx2x_dcbx_resume_hw_tx(bp);
 	/* work which needs rtnl lock not-taken (as it takes the lock itself and
 	 * can be called from other contexts as well)
 	 */
 	bp->flags |= (val >= REQ_BC_VER_4_DCBX_ADMIN_MSG_NON_PMF) ?
 			BC_SUPPORTS_DCBX_MSG_NON_PMF : 0;
+	bp->flags |= (val >= REQ_BC_VER_4_RMMOD_CMD) ?
+			BC_SUPPORTS_RMMOD_CMD : 0;
 	boot_mode = SHMEM_RD(bp,
 			dev_info.port_feature_config[BP_PORT(bp)].mba_config) &
 			PORT_FEATURE_MBA_BOOT_AGENT_TYPE_MASK;
 	int tmp;
 	u32 cfg;
+	if (IS_VF(bp))
+		return 0;
 	if (IS_MF(bp) && !CHIP_IS_E1x(bp)) {
 		/* Take function: tmp = func */
 		tmp = BP_ABS_FUNC(bp);
 	mutex_init(&bp->port.phy_mutex);
 	mutex_init(&bp->fw_mb_mutex);
 	spin_lock_init(&bp->stats_lock);
+	sema_init(&bp->stats_sema, 1);
 	INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
 	INIT_DELAYED_WORK(&bp->sp_rtnl_task, bnx2x_sp_rtnl_task);
 	bnx2x_dcbnl_update_applist(bp, true);
 #endif
+	if (IS_PF(bp) &&
+	    !BP_NOMCP(bp) &&
+	    (bp->flags & BC_SUPPORTS_RMMOD_CMD))
+		bnx2x_fw_command(bp, DRV_MSG_CODE_RMMOD, 0);
 	/* Close the interface - either directly or implicitly */
 	if (remove_netdev) {
 		unregister_netdev(dev);
 	} else {
 		rtnl_lock();
-		if (netif_running(dev))
+		dev_close(dev);
-			bnx2x_close(dev);
 		rtnl_unlock();
 	}

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c+34−24

 void bnx2x_iov_init_dmae(struct bnx2x *bp)
 {
-	DP(BNX2X_MSG_IOV, "SRIOV is %s\n", IS_SRIOV(bp) ? "ON" : "OFF");
+	if (pci_find_ext_capability(bp->pdev, PCI_EXT_CAP_ID_SRIOV))
-	if (!IS_SRIOV(bp))
+		REG_WR(bp, DMAE_REG_BACKWARD_COMP_EN, 0);
-		return;
-	REG_WR(bp, DMAE_REG_BACKWARD_COMP_EN, 0);
 }
 static int bnx2x_vf_bus(struct bnx2x *bp, int vfid)
 	pci_disable_sriov(bp->pdev);
 }
-static int bnx2x_vf_ndo_sanity(struct bnx2x *bp, int vfidx,
+static int bnx2x_vf_ndo_prep(struct bnx2x *bp, int vfidx,
-			       struct bnx2x_virtf *vf)
+			     struct bnx2x_virtf **vf,
+			     struct pf_vf_bulletin_content **bulletin)
 {
 	if (bp->state != BNX2X_STATE_OPEN) {
 		BNX2X_ERR("vf ndo called though PF is down\n");
 		return -EINVAL;
 	}
-	if (!vf) {
+	/* init members */
+	*vf = BP_VF(bp, vfidx);
+	*bulletin = BP_VF_BULLETIN(bp, vfidx);
+	if (!*vf) {
 		BNX2X_ERR("vf ndo called but vf was null. vfidx was %d\n",
 			  vfidx);
 		return -EINVAL;
 	}
+	if (!*bulletin) {
+		BNX2X_ERR("vf ndo called but Bulletin Board struct is null. vfidx was %d\n",
+			  vfidx);
+		return -EINVAL;
+	}
 	return 0;
 }
 			struct ifla_vf_info *ivi)
 {
 	struct bnx2x *bp = netdev_priv(dev);
-	struct bnx2x_virtf *vf = BP_VF(bp, vfidx);
+	struct bnx2x_virtf *vf = NULL;
-	struct bnx2x_vlan_mac_obj *mac_obj = &bnx2x_vfq(vf, 0, mac_obj);
+	struct pf_vf_bulletin_content *bulletin = NULL;
-	struct bnx2x_vlan_mac_obj *vlan_obj = &bnx2x_vfq(vf, 0, vlan_obj);
+	struct bnx2x_vlan_mac_obj *mac_obj;
-	struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vfidx);
+	struct bnx2x_vlan_mac_obj *vlan_obj;
 	int rc;
-	/* sanity */
+	/* sanity and init */
-	rc = bnx2x_vf_ndo_sanity(bp, vfidx, vf);
+	rc = bnx2x_vf_ndo_prep(bp, vfidx, &vf, &bulletin);
 	if (rc)
 		return rc;
-	if (!mac_obj || !vlan_obj || !bulletin) {
+	mac_obj = &bnx2x_vfq(vf, 0, mac_obj);
+	vlan_obj = &bnx2x_vfq(vf, 0, vlan_obj);
+	if (!mac_obj || !vlan_obj) {
 		BNX2X_ERR("VF partially initialized\n");
 		return -EINVAL;
 	}
 {
 	struct bnx2x *bp = netdev_priv(dev);
 	int rc, q_logical_state;
-	struct bnx2x_virtf *vf = BP_VF(bp, vfidx);
+	struct bnx2x_virtf *vf = NULL;
-	struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vfidx);
+	struct pf_vf_bulletin_content *bulletin = NULL;
-	/* sanity */
+	/* sanity and init */
-	rc = bnx2x_vf_ndo_sanity(bp, vfidx, vf);
+	rc = bnx2x_vf_ndo_prep(bp, vfidx, &vf, &bulletin);
 	if (rc)
 		return rc;
 	if (!is_valid_ether_addr(mac)) {
 {
 	struct bnx2x *bp = netdev_priv(dev);
 	int rc, q_logical_state;
-	struct bnx2x_virtf *vf = BP_VF(bp, vfidx);
+	struct bnx2x_virtf *vf = NULL;
-	struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vfidx);
+	struct pf_vf_bulletin_content *bulletin = NULL;
-	/* sanity */
+	/* sanity and init */
-	rc = bnx2x_vf_ndo_sanity(bp, vfidx, vf);
+	rc = bnx2x_vf_ndo_prep(bp, vfidx, &vf, &bulletin);
 	if (rc)
 		return rc;
 alloc_mem_err:
 	BNX2X_PCI_FREE(bp->vf2pf_mbox, bp->vf2pf_mbox_mapping,
 		       sizeof(struct bnx2x_vf_mbx_msg));
-	BNX2X_PCI_FREE(bp->vf2pf_mbox, bp->vf2pf_mbox_mapping,
+	BNX2X_PCI_FREE(bp->vf2pf_mbox, bp->pf2vf_bulletin_mapping,
 		       sizeof(union pf_vf_bulletin));
 	return -ENOMEM;
 }

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c+54−12

  * Statistics service functions
  */
-static void bnx2x_stats_pmf_update(struct bnx2x *bp)
+/* should be called under stats_sema */
+static void __bnx2x_stats_pmf_update(struct bnx2x *bp)
 {
 	struct dmae_command *dmae;
 	u32 opcode;
 	*stats_comp = 0;
 }
-static void bnx2x_stats_start(struct bnx2x *bp)
+/* should be called under stats_sema */
+static void __bnx2x_stats_start(struct bnx2x *bp)
 {
 	/* vfs travel through here as part of the statistics FSM, but no action
 	 * is required
 	bnx2x_hw_stats_post(bp);
 	bnx2x_storm_stats_post(bp);
+	bp->stats_started = true;
+}
+static void bnx2x_stats_start(struct bnx2x *bp)
+{
+	if (down_timeout(&bp->stats_sema, HZ/10))
+		BNX2X_ERR("Unable to acquire stats lock\n");
+	__bnx2x_stats_start(bp);
+	up(&bp->stats_sema);
 }
 static void bnx2x_stats_pmf_start(struct bnx2x *bp)
 {
+	if (down_timeout(&bp->stats_sema, HZ/10))
+		BNX2X_ERR("Unable to acquire stats lock\n");
 	bnx2x_stats_comp(bp);
-	bnx2x_stats_pmf_update(bp);
+	__bnx2x_stats_pmf_update(bp);
-	bnx2x_stats_start(bp);
+	__bnx2x_stats_start(bp);
+	up(&bp->stats_sema);
+}
+static void bnx2x_stats_pmf_update(struct bnx2x *bp)
+{
+	if (down_timeout(&bp->stats_sema, HZ/10))
+		BNX2X_ERR("Unable to acquire stats lock\n");
+	__bnx2x_stats_pmf_update(bp);
+	up(&bp->stats_sema);
 }
 static void bnx2x_stats_restart(struct bnx2x *bp)
 	 */
 	if (IS_VF(bp))
 		return;
+	if (down_timeout(&bp->stats_sema, HZ/10))
+		BNX2X_ERR("Unable to acquire stats lock\n");
 	bnx2x_stats_comp(bp);
-	bnx2x_stats_start(bp);
+	__bnx2x_stats_start(bp);
+	up(&bp->stats_sema);
 }
 static void bnx2x_bmac_stats_update(struct bnx2x *bp)
 	/* Make sure we use the value of the counter
 	 * used for sending the last stats ramrod.
 	 */
-	spin_lock_bh(&bp->stats_lock);
 	cur_stats_counter = bp->stats_counter - 1;
-	spin_unlock_bh(&bp->stats_lock);
 	/* are storm stats valid? */
 	if (le16_to_cpu(counters->xstats_counter) != cur_stats_counter) {
 {
 	u32 *stats_comp = bnx2x_sp(bp, stats_comp);
-	if (bnx2x_edebug_stats_stopped(bp))
+	/* we run update from timer context, so give up
+	 * if somebody is in the middle of transition
+	 */
+	if (down_trylock(&bp->stats_sema))
 		return;
+	if (bnx2x_edebug_stats_stopped(bp) || !bp->stats_started)
+		goto out;
 	if (IS_PF(bp)) {
 		if (*stats_comp != DMAE_COMP_VAL)
-			return;
+			goto out;
 		if (bp->port.pmf)
 			bnx2x_hw_stats_update(bp);
 				BNX2X_ERR("storm stats were not updated for 3 times\n");
 				bnx2x_panic();
 			}
-			return;
+			goto out;
 		}
 	} else {
 		/* vf doesn't collect HW statistics, and doesn't get completions
 	/* vf is done */
 	if (IS_VF(bp))
-		return;
+		goto out;
 	if (netif_msg_timer(bp)) {
 		struct bnx2x_eth_stats *estats = &bp->eth_stats;
 	bnx2x_hw_stats_post(bp);
 	bnx2x_storm_stats_post(bp);
+out:
+	up(&bp->stats_sema);
 }
 static void bnx2x_port_stats_stop(struct bnx2x *bp)
 {
 	int update = 0;
+	if (down_timeout(&bp->stats_sema, HZ/10))
+		BNX2X_ERR("Unable to acquire stats lock\n");
+	bp->stats_started = false;
 	bnx2x_stats_comp(bp);
 	if (bp->port.pmf)
 		bnx2x_hw_stats_post(bp);
 		bnx2x_stats_comp(bp);
 	}
+	up(&bp->stats_sema);
 }
 static void bnx2x_stats_do_nothing(struct bnx2x *bp)
 void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
 {
 	enum bnx2x_stats_state state;
+	void (*action)(struct bnx2x *bp);
 	if (unlikely(bp->panic))
 		return;
 	spin_lock_bh(&bp->stats_lock);
 	state = bp->stats_state;
 	bp->stats_state = bnx2x_stats_stm[state][event].next_state;
+	action = bnx2x_stats_stm[state][event].action;
 	spin_unlock_bh(&bp->stats_lock);
-	bnx2x_stats_stm[state][event].action(bp);
+	action(bp);
 	if ((event != STATS_EVENT_UPDATE) || netif_msg_timer(bp))
 		DP(BNX2X_MSG_STATS, "state %d -> event %d -> state %d\n",

drivers/net/ethernet/broadcom/tg3.c+8−5

 done:
 	if (state == pci_channel_io_perm_failure) {
-		tg3_napi_enable(tp);
+		if (netdev) {
-		dev_close(netdev);
+			tg3_napi_enable(tp);
+			dev_close(netdev);
+		}
 		err = PCI_ERS_RESULT_DISCONNECT;
 	} else {
 		pci_disable_device(pdev);
 	rtnl_lock();
 	if (pci_enable_device(pdev)) {
-		netdev_err(netdev, "Cannot re-enable PCI device after reset.\n");
+		dev_err(&pdev->dev,
+			"Cannot re-enable PCI device after reset.\n");
 		goto done;
 	}
 	pci_restore_state(pdev);
 	pci_save_state(pdev);
-	if (!netif_running(netdev)) {
+	if (!netdev || !netif_running(netdev)) {
 		rc = PCI_ERS_RESULT_RECOVERED;
 		goto done;
 	}
 	rc = PCI_ERS_RESULT_RECOVERED;
 done:
-	if (rc != PCI_ERS_RESULT_RECOVERED && netif_running(netdev)) {
+	if (rc != PCI_ERS_RESULT_RECOVERED && netdev && netif_running(netdev)) {
 		tg3_napi_enable(tp);
 		dev_close(netdev);
 	}

drivers/net/ethernet/chelsio/cxgb3/sge.c+24−83

 		q->pg_chunk.offset = 0;
 		mapping = pci_map_page(adapter->pdev, q->pg_chunk.page,
 				       0, q->alloc_size, PCI_DMA_FROMDEVICE);
-		if (unlikely(pci_dma_mapping_error(adapter->pdev, mapping))) {
-			__free_pages(q->pg_chunk.page, order);
-			q->pg_chunk.page = NULL;
-			return -EIO;
-		}
 		q->pg_chunk.mapping = mapping;
 	}
 	sd->pg_chunk = q->pg_chunk;
 	return flits_to_desc(flits);
 }
-/*	map_skb - map a packet main body and its page fragments
- *	@pdev: the PCI device
- *	@skb: the packet
- *	@addr: placeholder to save the mapped addresses
- *
- *	map the main body of an sk_buff and its page fragments, if any.
- */
-static int map_skb(struct pci_dev *pdev, const struct sk_buff *skb,
-		   dma_addr_t *addr)
-{
-	const skb_frag_t *fp, *end;
-	const struct skb_shared_info *si;
-	*addr = pci_map_single(pdev, skb->data, skb_headlen(skb),
-			       PCI_DMA_TODEVICE);
-	if (pci_dma_mapping_error(pdev, *addr))
-		goto out_err;
-	si = skb_shinfo(skb);
-	end = &si->frags[si->nr_frags];
-	for (fp = si->frags; fp < end; fp++) {
-		*++addr = skb_frag_dma_map(&pdev->dev, fp, 0, skb_frag_size(fp),
-					   DMA_TO_DEVICE);
-		if (pci_dma_mapping_error(pdev, *addr))
-			goto unwind;
-	}
-	return 0;
-unwind:
-	while (fp-- > si->frags)
-		dma_unmap_page(&pdev->dev, *--addr, skb_frag_size(fp),
-			       DMA_TO_DEVICE);
-	pci_unmap_single(pdev, addr[-1], skb_headlen(skb), PCI_DMA_TODEVICE);
-out_err:
-	return -ENOMEM;
-}
 /**
- *	write_sgl - populate a scatter/gather list for a packet
+ *	make_sgl - populate a scatter/gather list for a packet
  *	@skb: the packet
  *	@sgp: the SGL to populate
  *	@start: start address of skb main body data to include in the SGL
  *	@len: length of skb main body data to include in the SGL
- *	@addr: the list of the mapped addresses
+ *	@pdev: the PCI device
  *
- *	Copies the scatter/gather list for the buffers that make up a packet
+ *	Generates a scatter/gather list for the buffers that make up a packet
  *	and returns the SGL size in 8-byte words.  The caller must size the SGL
  *	appropriately.
  */
-static inline unsigned int write_sgl(const struct sk_buff *skb,
+static inline unsigned int make_sgl(const struct sk_buff *skb,
 				    struct sg_ent *sgp, unsigned char *start,
-				    unsigned int len, const dma_addr_t *addr)
+				    unsigned int len, struct pci_dev *pdev)
 {
-	unsigned int i, j = 0, k = 0, nfrags;
+	dma_addr_t mapping;
+	unsigned int i, j = 0, nfrags;
 	if (len) {
+		mapping = pci_map_single(pdev, start, len, PCI_DMA_TODEVICE);
 		sgp->len[0] = cpu_to_be32(len);
-		sgp->addr[j++] = cpu_to_be64(addr[k++]);
+		sgp->addr[0] = cpu_to_be64(mapping);
+		j = 1;
 	}
 	nfrags = skb_shinfo(skb)->nr_frags;
 	for (i = 0; i < nfrags; i++) {
 		const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+		mapping = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
+					   DMA_TO_DEVICE);
 		sgp->len[j] = cpu_to_be32(skb_frag_size(frag));
-		sgp->addr[j] = cpu_to_be64(addr[k++]);
+		sgp->addr[j] = cpu_to_be64(mapping);
 		j ^= 1;
 		if (j == 0)
 			++sgp;
 			    const struct port_info *pi,
 			    unsigned int pidx, unsigned int gen,
 			    struct sge_txq *q, unsigned int ndesc,
-			    unsigned int compl, const dma_addr_t *addr)
+			    unsigned int compl)
 {
 	unsigned int flits, sgl_flits, cntrl, tso_info;
 	struct sg_ent *sgp, sgl[MAX_SKB_FRAGS / 2 + 1];
 	}
 	sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
-	sgl_flits = write_sgl(skb, sgp, skb->data, skb_headlen(skb), addr);
+	sgl_flits = make_sgl(skb, sgp, skb->data, skb_headlen(skb), adap->pdev);
 	write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits, gen,
 			 htonl(V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT) | compl),
 	struct netdev_queue *txq;
 	struct sge_qset *qs;
 	struct sge_txq *q;
-	dma_addr_t addr[MAX_SKB_FRAGS + 1];
 	/*
 	 * The chip min packet length is 9 octets but play safe and reject
 		return NETDEV_TX_BUSY;
 	}
-	if (unlikely(map_skb(adap->pdev, skb, addr) < 0)) {
-		dev_kfree_skb(skb);
-		return NETDEV_TX_OK;
-	}
 	q->in_use += ndesc;
 	if (unlikely(credits - ndesc < q->stop_thres)) {
 		t3_stop_tx_queue(txq, qs, q);
 	if (likely(!skb_shared(skb)))
 		skb_orphan(skb);
-	write_tx_pkt_wr(adap, skb, pi, pidx, gen, q, ndesc, compl, addr);
+	write_tx_pkt_wr(adap, skb, pi, pidx, gen, q, ndesc, compl);
 	check_ring_tx_db(adap, q);
 	return NETDEV_TX_OK;
 }
  */
 static void write_ofld_wr(struct adapter *adap, struct sk_buff *skb,
 			  struct sge_txq *q, unsigned int pidx,
-			  unsigned int gen, unsigned int ndesc,
+			  unsigned int gen, unsigned int ndesc)
-			  const dma_addr_t *addr)
 {
 	unsigned int sgl_flits, flits;
 	struct work_request_hdr *from;
 	flits = skb_transport_offset(skb) / 8;
 	sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
-	sgl_flits = write_sgl(skb, sgp, skb_transport_header(skb),
+	sgl_flits = make_sgl(skb, sgp, skb_transport_header(skb),
-			     skb_tail_pointer(skb) -
+			     skb->tail - skb->transport_header,
-			     skb_transport_header(skb), addr);
+			     adap->pdev);
 	if (need_skb_unmap()) {
 		setup_deferred_unmapping(skb, adap->pdev, sgp, sgl_flits);
 		skb->destructor = deferred_unmap_destructor;
 		goto again;
 	}
-	if (map_skb(adap->pdev, skb, (dma_addr_t *)skb->head)) {
-		spin_unlock(&q->lock);
-		return NET_XMIT_SUCCESS;
-	}
 	gen = q->gen;
 	q->in_use += ndesc;
 	pidx = q->pidx;
 	}
 	spin_unlock(&q->lock);
-	write_ofld_wr(adap, skb, q, pidx, gen, ndesc, (dma_addr_t *)skb->head);
+	write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
 	check_ring_tx_db(adap, q);
 	return NET_XMIT_SUCCESS;
 }
 	struct sge_txq *q = &qs->txq[TXQ_OFLD];
 	const struct port_info *pi = netdev_priv(qs->netdev);
 	struct adapter *adap = pi->adapter;
-	unsigned int written = 0;
 	spin_lock(&q->lock);
 again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
 			break;
 		}
-		if (map_skb(adap->pdev, skb, (dma_addr_t *)skb->head))
-			break;
 		gen = q->gen;
 		q->in_use += ndesc;
 		pidx = q->pidx;
 		q->pidx += ndesc;
-		written += ndesc;
 		if (q->pidx >= q->size) {
 			q->pidx -= q->size;
 			q->gen ^= 1;
 		__skb_unlink(skb, &q->sendq);
 		spin_unlock(&q->lock);
-		write_ofld_wr(adap, skb, q, pidx, gen, ndesc,
+		write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
-			     (dma_addr_t *)skb->head);
 		spin_lock(&q->lock);
 	}
 	spin_unlock(&q->lock);
 	set_bit(TXQ_LAST_PKT_DB, &q->flags);
 #endif
 	wmb();
-	if (likely(written))
+	t3_write_reg(adap, A_SG_KDOORBELL,
-		t3_write_reg(adap, A_SG_KDOORBELL,
+		     F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
-			     F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
 }
 /**

drivers/net/ethernet/emulex/benet/be_cmds.c+3−0

@@ -3048,6 +3048,9 @@ int be_cmd_get_func_config(struct be_adapter *adapter) · 3047 unmodified lines
3048		3048
3049	adapter->max_event_queues = le16_to_cpu(desc->eq_count);	3049	adapter->max_event_queues = le16_to_cpu(desc->eq_count);
3050	adapter->if_cap_flags = le32_to_cpu(desc->cap_flags);	3050	adapter->if_cap_flags = le32_to_cpu(desc->cap_flags);
		3051
		3052	/* Clear flags that driver is not interested in */
		3053	adapter->if_cap_flags &= BE_IF_CAP_FLAGS_WANT;
3051	}	3054	}
3052	err:	3055	err:
3053	mutex_unlock(&adapter->mbox_lock);	3056	mutex_unlock(&adapter->mbox_lock);

drivers/net/ethernet/emulex/benet/be_cmds.h+6−0

 	BE_IF_FLAGS_MULTICAST = 0x1000
 };
+#define BE_IF_CAP_FLAGS_WANT (BE_IF_FLAGS_RSS | BE_IF_FLAGS_PROMISCUOUS |\
+			 BE_IF_FLAGS_BROADCAST | BE_IF_FLAGS_VLAN_PROMISCUOUS |\
+			 BE_IF_FLAGS_VLAN | BE_IF_FLAGS_MCAST_PROMISCUOUS |\
+			 BE_IF_FLAGS_PASS_L3L4_ERRORS | BE_IF_FLAGS_MULTICAST |\
+			 BE_IF_FLAGS_UNTAGGED)
 /* An RX interface is an object with one or more MAC addresses and
  * filtering capabilities. */
 struct be_cmd_req_if_create {

drivers/net/ethernet/emulex/benet/be_main.c+1−1

@@ -2563,8 +2563,8 @@ static int be_close(struct net_device *netdev) · 2562 unmodified lines
2563	/* Wait for all pending tx completions to arrive so that	2563	/* Wait for all pending tx completions to arrive so that
2564	* all tx skbs are freed.	2564	* all tx skbs are freed.
2565	*/	2565	*/
2566	be_tx_compl_clean(adapter);
2567	netif_tx_disable(netdev);	2566	netif_tx_disable(netdev);
		2567	be_tx_compl_clean(adapter);
2568		2568
2569	be_rx_qs_destroy(adapter);	2569	be_rx_qs_destroy(adapter);
2570		2570

drivers/net/ethernet/marvell/skge.c+53−15

 }
 /* Allocate and setup a new buffer for receiving */
-static void skge_rx_setup(struct skge_port *skge, struct skge_element *e,
+static int skge_rx_setup(struct skge_port *skge, struct skge_element *e,
-			  struct sk_buff *skb, unsigned int bufsize)
+			 struct sk_buff *skb, unsigned int bufsize)
 {
 	struct skge_rx_desc *rd = e->desc;
-	u64 map;
+	dma_addr_t map;
 	map = pci_map_single(skge->hw->pdev, skb->data, bufsize,
 			     PCI_DMA_FROMDEVICE);
-	rd->dma_lo = map;
+	if (pci_dma_mapping_error(skge->hw->pdev, map))
-	rd->dma_hi = map >> 32;
+		return -1;
+	rd->dma_lo = lower_32_bits(map);
+	rd->dma_hi = upper_32_bits(map);
 	e->skb = skb;
 	rd->csum1_start = ETH_HLEN;
 	rd->csum2_start = ETH_HLEN;
 	rd->control = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | bufsize;
 	dma_unmap_addr_set(e, mapaddr, map);
 	dma_unmap_len_set(e, maplen, bufsize);
+	return 0;
 }
 /* Resume receiving using existing skb,
 			return -ENOMEM;
 		skb_reserve(skb, NET_IP_ALIGN);
-		skge_rx_setup(skge, e, skb, skge->rx_buf_size);
+		if (skge_rx_setup(skge, e, skb, skge->rx_buf_size) < 0) {
+			dev_kfree_skb(skb);
+			return -EIO;
+		}
 	} while ((e = e->next) != ring->start);
 	ring->to_clean = ring->start;
 	BUG_ON(skge->dma & 7);
-	if ((u64)skge->dma >> 32 != ((u64) skge->dma + skge->mem_size) >> 32) {
+	if (upper_32_bits(skge->dma) != upper_32_bits(skge->dma + skge->mem_size)) {
 		dev_err(&hw->pdev->dev, "pci_alloc_consistent region crosses 4G boundary\n");
 		err = -EINVAL;
 		goto free_pci_mem;
 	struct skge_tx_desc *td;
 	int i;
 	u32 control, len;
-	u64 map;
+	dma_addr_t map;
 	if (skb_padto(skb, ETH_ZLEN))
 		return NETDEV_TX_OK;
 	e->skb = skb;
 	len = skb_headlen(skb);
 	map = pci_map_single(hw->pdev, skb->data, len, PCI_DMA_TODEVICE);
+	if (pci_dma_mapping_error(hw->pdev, map))
+		goto mapping_error;
 	dma_unmap_addr_set(e, mapaddr, map);
 	dma_unmap_len_set(e, maplen, len);
-	td->dma_lo = map;
+	td->dma_lo = lower_32_bits(map);
-	td->dma_hi = map >> 32;
+	td->dma_hi = upper_32_bits(map);
 	if (skb->ip_summed == CHECKSUM_PARTIAL) {
 		const int offset = skb_checksum_start_offset(skb);
 			map = skb_frag_dma_map(&hw->pdev->dev, frag, 0,
 					       skb_frag_size(frag), DMA_TO_DEVICE);
+			if (dma_mapping_error(&hw->pdev->dev, map))
+				goto mapping_unwind;
 			e = e->next;
 			e->skb = skb;
 			tf = e->desc;
 			BUG_ON(tf->control & BMU_OWN);
-			tf->dma_lo = map;
+			tf->dma_lo = lower_32_bits(map);
-			tf->dma_hi = (u64) map >> 32;
+			tf->dma_hi = upper_32_bits(map);
 			dma_unmap_addr_set(e, mapaddr, map);
 			dma_unmap_len_set(e, maplen, skb_frag_size(frag));
 	}
 	return NETDEV_TX_OK;
+mapping_unwind:
+	e = skge->tx_ring.to_use;
+	pci_unmap_single(hw->pdev,
+			 dma_unmap_addr(e, mapaddr),
+			 dma_unmap_len(e, maplen),
+			 PCI_DMA_TODEVICE);
+	while (i-- > 0) {
+		e = e->next;
+		pci_unmap_page(hw->pdev,
+			       dma_unmap_addr(e, mapaddr),
+			       dma_unmap_len(e, maplen),
+			       PCI_DMA_TODEVICE);
+	}
+mapping_error:
+	if (net_ratelimit())
+		dev_warn(&hw->pdev->dev, "%s: tx mapping error\n", dev->name);
+	dev_kfree_skb(skb);
+	return NETDEV_TX_OK;
 }
 		pci_dma_sync_single_for_cpu(skge->hw->pdev,
 					    dma_unmap_addr(e, mapaddr),
-					    len, PCI_DMA_FROMDEVICE);
+					    dma_unmap_len(e, maplen),
+					    PCI_DMA_FROMDEVICE);
 		skb_copy_from_linear_data(e->skb, skb->data, len);
 		pci_dma_sync_single_for_device(skge->hw->pdev,
 					       dma_unmap_addr(e, mapaddr),
-					       len, PCI_DMA_FROMDEVICE);
+					       dma_unmap_len(e, maplen),
+					       PCI_DMA_FROMDEVICE);
 		skge_rx_reuse(e, skge->rx_buf_size);
 	} else {
 		struct sk_buff *nskb;
 		if (!nskb)
 			goto resubmit;
+		if (skge_rx_setup(skge, e, nskb, skge->rx_buf_size) < 0) {
+			dev_kfree_skb(nskb);
+			goto resubmit;
+		}
 		pci_unmap_single(skge->hw->pdev,
 				 dma_unmap_addr(e, mapaddr),
 				 dma_unmap_len(e, maplen),
 				 PCI_DMA_FROMDEVICE);
 		skb = e->skb;
 		prefetch(skb->data);
-		skge_rx_setup(skge, e, nskb, skge->rx_buf_size);
 	}
 	skb_put(skb, len);

drivers/net/ethernet/mellanox/mlx5/core/cmd.c+1−1

@@ -46,7 +46,7 @@ · 45 unmodified lines
46	#include "mlx5_core.h"	46	#include "mlx5_core.h"
47		47
48	enum {	48	enum {
49	CMD_IF_REV = 4,	49	CMD_IF_REV = 5,
50	};	50	};
51		51
52	enum {	52	enum {

drivers/net/ethernet/mellanox/mlx5/core/eq.c+1−1

@@ -268,7 +268,7 @@ static int mlx5_eq_int(struct mlx5_core_dev dev, struct mlx5_eq eq) · 267 unmodified lines
268	case MLX5_EVENT_TYPE_PAGE_REQUEST:	268	case MLX5_EVENT_TYPE_PAGE_REQUEST:
269	{	269	{
270	u16 func_id = be16_to_cpu(eqe->data.req_pages.func_id);	270	u16 func_id = be16_to_cpu(eqe->data.req_pages.func_id);
271	s16 npages = be16_to_cpu(eqe->data.req_pages.num_pages);	271	s32 npages = be32_to_cpu(eqe->data.req_pages.num_pages);
272		272
273	mlx5_core_dbg(dev, "page request for func 0x%x, napges %d\n", func_id, npages);	273	mlx5_core_dbg(dev, "page request for func 0x%x, napges %d\n", func_id, npages);
274	mlx5_core_req_pages_handler(dev, func_id, npages);	274	mlx5_core_req_pages_handler(dev, func_id, npages);

drivers/net/ethernet/mellanox/mlx5/core/fw.c+1−1

@@ -113,7 +113,7 @@ int mlx5_cmd_query_hca_cap(struct mlx5_core_dev *dev, · 112 unmodified lines
113	caps->log_max_srq = out->hca_cap.log_max_srqs & 0x1f;	113	caps->log_max_srq = out->hca_cap.log_max_srqs & 0x1f;
114	caps->local_ca_ack_delay = out->hca_cap.local_ca_ack_delay & 0x1f;	114	caps->local_ca_ack_delay = out->hca_cap.local_ca_ack_delay & 0x1f;
115	caps->log_max_mcg = out->hca_cap.log_max_mcg;	115	caps->log_max_mcg = out->hca_cap.log_max_mcg;
116	caps->max_qp_mcg = be16_to_cpu(out->hca_cap.max_qp_mcg);	116	caps->max_qp_mcg = be32_to_cpu(out->hca_cap.max_qp_mcg) & 0xffffff;
117	caps->max_ra_res_qp = 1 << (out->hca_cap.log_max_ra_res_qp & 0x3f);	117	caps->max_ra_res_qp = 1 << (out->hca_cap.log_max_ra_res_qp & 0x3f);
118	caps->max_ra_req_qp = 1 << (out->hca_cap.log_max_ra_req_qp & 0x3f);	118	caps->max_ra_req_qp = 1 << (out->hca_cap.log_max_ra_req_qp & 0x3f);
119	caps->max_srq_wqes = 1 << out->hca_cap.log_max_srq_sz;	119	caps->max_srq_wqes = 1 << out->hca_cap.log_max_srq_sz;

drivers/net/ethernet/mellanox/mlx5/core/health.c+1−28

@@ -55,33 +55,9 @@ enum { · 54 unmodified lines
55	};	55	};
56		56
57	static DEFINE_SPINLOCK(health_lock);	57	static DEFINE_SPINLOCK(health_lock);
58
59	static LIST_HEAD(health_list);	58	static LIST_HEAD(health_list);
60	static struct work_struct health_work;	59	static struct work_struct health_work;
61		60
62	static health_handler_t reg_handler;
63	int mlx5_register_health_report_handler(health_handler_t handler)
64	{
65	spin_lock_irq(&health_lock);
66	if (reg_handler) {
67	spin_unlock_irq(&health_lock);
68	return -EEXIST;
69	}
70	reg_handler = handler;
71	spin_unlock_irq(&health_lock);
72
73	return 0;
74	}
75	EXPORT_SYMBOL(mlx5_register_health_report_handler);
76
77	void mlx5_unregister_health_report_handler(void)
78	{
79	spin_lock_irq(&health_lock);
80	reg_handler = NULL;
81	spin_unlock_irq(&health_lock);
82	}
83	EXPORT_SYMBOL(mlx5_unregister_health_report_handler);
84
85	static void health_care(struct work_struct *work)	61	static void health_care(struct work_struct *work)
86	{	62	{
87	struct mlx5_core_health health, n;	63	struct mlx5_core_health health, n;
@@ -98,11 +74,8 @@ static void health_care(struct work_struct *work) · 10 unmodified lines
98	priv = container_of(health, struct mlx5_priv, health);	74	priv = container_of(health, struct mlx5_priv, health);
99	dev = container_of(priv, struct mlx5_core_dev, priv);	75	dev = container_of(priv, struct mlx5_core_dev, priv);
100	mlx5_core_warn(dev, "handling bad device here\n");	76	mlx5_core_warn(dev, "handling bad device here\n");
		77	/* nothing yet */
101	spin_lock_irq(&health_lock);	78	spin_lock_irq(&health_lock);
102	if (reg_handler)
103	reg_handler(dev->pdev, health->health,
104	sizeof(health->health));
105
106	list_del_init(&health->list);	79	list_del_init(&health->list);
107	spin_unlock_irq(&health_lock);	80	spin_unlock_irq(&health_lock);
108	}	81	}

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c+26−32

 	MLX5_PAGES_TAKE		= 2
 };
+enum {
+	MLX5_BOOT_PAGES		= 1,
+	MLX5_INIT_PAGES		= 2,
+	MLX5_POST_INIT_PAGES	= 3
+};
 struct mlx5_pages_req {
 	struct mlx5_core_dev *dev;
 	u32	func_id;
-	s16	npages;
+	s32	npages;
 	struct work_struct work;
 };
 struct mlx5_query_pages_outbox {
 	struct mlx5_outbox_hdr	hdr;
-	__be16			num_boot_pages;
+	__be16			rsvd;
 	__be16			func_id;
-	__be16			init_pages;
+	__be32			num_pages;
-	__be16			num_pages;
 };
 struct mlx5_manage_pages_inbox {
 	struct mlx5_inbox_hdr	hdr;
-	__be16			rsvd0;
+	__be16			rsvd;
 	__be16			func_id;
-	__be16			rsvd1;
+	__be32			num_entries;
-	__be16			num_entries;
-	u8			rsvd2[16];
 	__be64			pas[0];
 };
 struct mlx5_manage_pages_outbox {
 	struct mlx5_outbox_hdr	hdr;
-	u8			rsvd0[2];
+	__be32			num_entries;
-	__be16			num_entries;
+	u8			rsvd[4];
-	u8			rsvd1[20];
 	__be64			pas[0];
 };
 }
 static int mlx5_cmd_query_pages(struct mlx5_core_dev *dev, u16 *func_id,
-				s16 *pages, s16 *init_pages, u16 *boot_pages)
+				s32 *npages, int boot)
 {
 	struct mlx5_query_pages_inbox	in;
 	struct mlx5_query_pages_outbox	out;
 	memset(&in, 0, sizeof(in));
 	memset(&out, 0, sizeof(out));
 	in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_QUERY_PAGES);
+	in.hdr.opmod = boot ? cpu_to_be16(MLX5_BOOT_PAGES) : cpu_to_be16(MLX5_INIT_PAGES);
 	err = mlx5_cmd_exec(dev, &in, sizeof(in), &out, sizeof(out));
 	if (err)
 		return err;
 	if (out.hdr.status)
 		return mlx5_cmd_status_to_err(&out.hdr);
-	if (pages)
+	*npages = be32_to_cpu(out.num_pages);
-		*pages = be16_to_cpu(out.num_pages);
-	if (init_pages)
-		*init_pages = be16_to_cpu(out.init_pages);
-	if (boot_pages)
-		*boot_pages = be16_to_cpu(out.num_boot_pages);
 	*func_id = be16_to_cpu(out.func_id);
 	return err;
 	in->hdr.opcode = cpu_to_be16(MLX5_CMD_OP_MANAGE_PAGES);
 	in->hdr.opmod = cpu_to_be16(MLX5_PAGES_GIVE);
 	in->func_id = cpu_to_be16(func_id);
-	in->num_entries = cpu_to_be16(npages);
+	in->num_entries = cpu_to_be32(npages);
 	err = mlx5_cmd_exec(dev, in, inlen, &out, sizeof(out));
 	mlx5_core_dbg(dev, "err %d\n", err);
 	if (err) {
 	in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_MANAGE_PAGES);
 	in.hdr.opmod = cpu_to_be16(MLX5_PAGES_TAKE);
 	in.func_id = cpu_to_be16(func_id);
-	in.num_entries = cpu_to_be16(npages);
+	in.num_entries = cpu_to_be32(npages);
 	mlx5_core_dbg(dev, "npages %d, outlen %d\n", npages, outlen);
 	err = mlx5_cmd_exec(dev, &in, sizeof(in), out, outlen);
 	if (err) {
 		goto out_free;
 	}
-	num_claimed = be16_to_cpu(out->num_entries);
+	num_claimed = be32_to_cpu(out->num_entries);
 	if (nclaimed)
 		*nclaimed = num_claimed;
 }
 void mlx5_core_req_pages_handler(struct mlx5_core_dev *dev, u16 func_id,
-				 s16 npages)
+				 s32 npages)
 {
 	struct mlx5_pages_req *req;
 int mlx5_satisfy_startup_pages(struct mlx5_core_dev *dev, int boot)
 {
-	u16 uninitialized_var(boot_pages);
-	s16 uninitialized_var(init_pages);
 	u16 uninitialized_var(func_id);
+	s32 uninitialized_var(npages);
 	int err;
-	err = mlx5_cmd_query_pages(dev, &func_id, NULL, &init_pages,
+	err = mlx5_cmd_query_pages(dev, &func_id, &npages, boot);
-				   &boot_pages);
 	if (err)
 		return err;
+	mlx5_core_dbg(dev, "requested %d %s pages for func_id 0x%x\n",
+		      npages, boot ? "boot" : "init", func_id);
-	mlx5_core_dbg(dev, "requested %d init pages and %d boot pages for func_id 0x%x\n",
+	return give_pages(dev, func_id, npages, 0);
-		      init_pages, boot_pages, func_id);
-	return give_pages(dev, func_id, boot ? boot_pages : init_pages, 0);
 }
 static int optimal_reclaimed_pages(void)

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c+5−0

 	u8 val;
 	int ret, max_sds_rings = adapter->max_sds_rings;
+	if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
+		netdev_info(netdev, "Device is resetting\n");
+		return -EBUSY;
+	}
 	if (qlcnic_get_diag_lock(adapter)) {
 		netdev_info(netdev, "Device in diagnostics mode\n");
 		return -EBUSY;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c+2−1

@@ -629,7 +629,8 @@ int qlcnic_83xx_idc_reattach_driver(struct qlcnic_adapter *adapter) · 628 unmodified lines
629	return -EIO;	629	return -EIO;
630	}	630	}
631		631
632	qlcnic_set_drv_version(adapter);	632	if (adapter->portnum == 0)
		633	qlcnic_set_drv_version(adapter);
633	qlcnic_83xx_idc_attach_driver(adapter);	634	qlcnic_83xx_idc_attach_driver(adapter);
634		635
635	return 0;	636	return 0;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c+4−2

 	if (err)
 		goto err_out_disable_mbx_intr;
-	qlcnic_set_drv_version(adapter);
+	if (adapter->portnum == 0)
+		qlcnic_set_drv_version(adapter);
 	pci_set_drvdata(pdev, adapter);
 	adapter->fw_fail_cnt = 0;
 	adapter->flags &= ~QLCNIC_FW_HANG;
 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
-	qlcnic_set_drv_version(adapter);
+	if (adapter->portnum == 0)
+		qlcnic_set_drv_version(adapter);
 	if (!qlcnic_clr_drv_state(adapter))
 		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sysfs.c+3−3

@@ -170,9 +170,9 @@ static int qlcnic_82xx_store_beacon(struct qlcnic_adapter *adapter, · 169 unmodified lines
170		170
171	if (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_2_BEACON) {	171	if (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_2_BEACON) {
172	err = qlcnic_get_beacon_state(adapter, &h_beacon_state);	172	err = qlcnic_get_beacon_state(adapter, &h_beacon_state);
173	if (!err) {	173	if (err) {
174	dev_info(&adapter->pdev->dev,	174	netdev_err(adapter->netdev,
175	"Failed to get current beacon state\n");	175	"Failed to get current beacon state\n");
176	} else {	176	} else {
177	if (h_beacon_state == QLCNIC_BEACON_DISABLE)	177	if (h_beacon_state == QLCNIC_BEACON_DISABLE)
178	ahw->beacon_state = 0;	178	ahw->beacon_state = 0;

drivers/net/ethernet/realtek/8139cp.c+1−0

@@ -524,6 +524,7 @@ rx_status_loop: · 523 unmodified lines
524	PCI_DMA_FROMDEVICE);	524	PCI_DMA_FROMDEVICE);
525	if (dma_mapping_error(&cp->pdev->dev, new_mapping)) {	525	if (dma_mapping_error(&cp->pdev->dev, new_mapping)) {
526	dev->stats.rx_dropped++;	526	dev->stats.rx_dropped++;
		527	kfree_skb(new_skb);
527	goto rx_next;	528	goto rx_next;
528	}	529	}
529		530

drivers/net/ethernet/realtek/r8169.c+1−1

@@ -7088,7 +7088,7 @@ rtl_init_one(struct pci_dev pdev, const struct pci_device_id ent) · 7087 unmodified lines
7088		7088
7089	RTL_W8(Cfg9346, Cfg9346_Unlock);	7089	RTL_W8(Cfg9346, Cfg9346_Unlock);
7090	RTL_W8(Config1, RTL_R8(Config1) \| PMEnable);	7090	RTL_W8(Config1, RTL_R8(Config1) \| PMEnable);
7091	RTL_W8(Config5, RTL_R8(Config5) & PMEStatus);	7091	RTL_W8(Config5, RTL_R8(Config5) & (BWF \| MWF \| UWF \| LanWake \| PMEStatus));
7092	if ((RTL_R8(Config3) & (LinkUp \| MagicPacket)) != 0)	7092	if ((RTL_R8(Config3) & (LinkUp \| MagicPacket)) != 0)
7093	tp->features \|= RTL_FEATURE_WOL;	7093	tp->features \|= RTL_FEATURE_WOL;
7094	if ((RTL_R8(Config5) & (UWF \| BWF \| MWF)) != 0)	7094	if ((RTL_R8(Config5) & (UWF \| BWF \| MWF)) != 0)

drivers/net/ethernet/sfc/filter.c+1−1

@@ -675,7 +675,7 @@ s32 efx_filter_insert_filter(struct efx_nic efx, struct efx_filter_spec spec, · 674 unmodified lines
675	BUILD_BUG_ON(EFX_FILTER_INDEX_UC_DEF != 0);	675	BUILD_BUG_ON(EFX_FILTER_INDEX_UC_DEF != 0);
676	BUILD_BUG_ON(EFX_FILTER_INDEX_MC_DEF !=	676	BUILD_BUG_ON(EFX_FILTER_INDEX_MC_DEF !=
677	EFX_FILTER_MC_DEF - EFX_FILTER_UC_DEF);	677	EFX_FILTER_MC_DEF - EFX_FILTER_UC_DEF);
678	rep_index = spec->type - EFX_FILTER_INDEX_UC_DEF;	678	rep_index = spec->type - EFX_FILTER_UC_DEF;
679	ins_index = rep_index;	679	ins_index = rep_index;
680		680
681	spin_lock_bh(&state->lock);	681	spin_lock_bh(&state->lock);

drivers/net/ethernet/stmicro/stmmac/ring_mode.c+11−2

@@ -33,10 +33,15 @@ static unsigned int stmmac_jumbo_frm(void p, struct sk_buff skb, int csum) · 32 unmodified lines
33	struct stmmac_priv priv = (struct stmmac_priv )p;	33	struct stmmac_priv priv = (struct stmmac_priv )p;
34	unsigned int txsize = priv->dma_tx_size;	34	unsigned int txsize = priv->dma_tx_size;
35	unsigned int entry = priv->cur_tx % txsize;	35	unsigned int entry = priv->cur_tx % txsize;
36	struct dma_desc *desc = priv->dma_tx + entry;	36	struct dma_desc *desc;
37	unsigned int nopaged_len = skb_headlen(skb);	37	unsigned int nopaged_len = skb_headlen(skb);
38	unsigned int bmax, len;	38	unsigned int bmax, len;
39		39
		40	if (priv->extend_desc)
		41	desc = (struct dma_desc *)(priv->dma_etx + entry);
		42	else
		43	desc = priv->dma_tx + entry;
		44
40	if (priv->plat->enh_desc)	45	if (priv->plat->enh_desc)
41	bmax = BUF_SIZE_8KiB;	46	bmax = BUF_SIZE_8KiB;
42	else	47	else
@@ -54,7 +59,11 @@ static unsigned int stmmac_jumbo_frm(void p, struct sk_buff skb, int csum) · 11 unmodified lines
54	STMMAC_RING_MODE);	59	STMMAC_RING_MODE);
55	wmb();	60	wmb();
56	entry = (++priv->cur_tx) % txsize;	61	entry = (++priv->cur_tx) % txsize;
57	desc = priv->dma_tx + entry;	62
		63	if (priv->extend_desc)
		64	desc = (struct dma_desc *)(priv->dma_etx + entry);
		65	else
		66	desc = priv->dma_tx + entry;
58		67
59	desc->des2 = dma_map_single(priv->device, skb->data + bmax,	68	desc->des2 = dma_map_single(priv->device, skb->data + bmax,
60	len, DMA_TO_DEVICE);	69	len, DMA_TO_DEVICE);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+92−19

@@ -939,15 +939,20 @@ static int stmmac_init_rx_buffers(struct stmmac_priv priv, struct dma_desc p, · 938 unmodified lines
939		939
940	skb = __netdev_alloc_skb(priv->dev, priv->dma_buf_sz + NET_IP_ALIGN,	940	skb = __netdev_alloc_skb(priv->dev, priv->dma_buf_sz + NET_IP_ALIGN,
941	GFP_KERNEL);	941	GFP_KERNEL);
942	if (unlikely(skb == NULL)) {	942	if (!skb) {
943	pr_err("%s: Rx init fails; skb is NULL\n", __func__);	943	pr_err("%s: Rx init fails; skb is NULL\n", __func__);
944	return 1;	944	return -ENOMEM;
945	}	945	}
946	skb_reserve(skb, NET_IP_ALIGN);	946	skb_reserve(skb, NET_IP_ALIGN);
947	priv->rx_skbuff[i] = skb;	947	priv->rx_skbuff[i] = skb;
948	priv->rx_skbuff_dma[i] = dma_map_single(priv->device, skb->data,	948	priv->rx_skbuff_dma[i] = dma_map_single(priv->device, skb->data,
949	priv->dma_buf_sz,	949	priv->dma_buf_sz,
950	DMA_FROM_DEVICE);	950	DMA_FROM_DEVICE);
		951	if (dma_mapping_error(priv->device, priv->rx_skbuff_dma[i])) {
		952	pr_err("%s: DMA mapping error\n", __func__);
		953	dev_kfree_skb_any(skb);
		954	return -EINVAL;
		955	}
951		956
952	p->des2 = priv->rx_skbuff_dma[i];	957	p->des2 = priv->rx_skbuff_dma[i];
953		958
@@ -958,6 +963,16 @@ static int stmmac_init_rx_buffers(struct stmmac_priv priv, struct dma_desc p, · 4 unmodified lines
958	return 0;	963	return 0;
959	}	964	}
960		965
		966	static void stmmac_free_rx_buffers(struct stmmac_priv *priv, int i)
		967	{
		968	if (priv->rx_skbuff[i]) {
		969	dma_unmap_single(priv->device, priv->rx_skbuff_dma[i],
		970	priv->dma_buf_sz, DMA_FROM_DEVICE);
		971	dev_kfree_skb_any(priv->rx_skbuff[i]);
		972	}
		973	priv->rx_skbuff[i] = NULL;
		974	}
		975
961	/**	976	/**
962	* init_dma_desc_rings - init the RX/TX descriptor rings	977	* init_dma_desc_rings - init the RX/TX descriptor rings
963	* @dev: net device structure	978	* @dev: net device structure
@@ -965,13 +980,14 @@ static int stmmac_init_rx_buffers(struct stmmac_priv priv, struct dma_desc p, · 1 unmodified line
965	* and allocates the socket buffers. It suppors the chained and ring	980	* and allocates the socket buffers. It suppors the chained and ring
966	* modes.	981	* modes.
967	*/	982	*/
968	static void init_dma_desc_rings(struct net_device *dev)	983	static int init_dma_desc_rings(struct net_device *dev)
969	{	984	{
970	int i;	985	int i;
971	struct stmmac_priv *priv = netdev_priv(dev);	986	struct stmmac_priv *priv = netdev_priv(dev);
972	unsigned int txsize = priv->dma_tx_size;	987	unsigned int txsize = priv->dma_tx_size;
973	unsigned int rxsize = priv->dma_rx_size;	988	unsigned int rxsize = priv->dma_rx_size;
974	unsigned int bfsize = 0;	989	unsigned int bfsize = 0;
		990	int ret = -ENOMEM;
975		991
976	/* Set the max buffer size according to the DESC mode	992	/* Set the max buffer size according to the DESC mode
977	* and the MTU. Note that RING mode allows 16KiB bsize.	993	* and the MTU. Note that RING mode allows 16KiB bsize.
@@ -992,34 +1008,60 @@ static void init_dma_desc_rings(struct net_device *dev) · 14 unmodified lines
992	dma_extended_desc),	1008	dma_extended_desc),
993	&priv->dma_rx_phy,	1009	&priv->dma_rx_phy,
994	GFP_KERNEL);	1010	GFP_KERNEL);
		1011	if (!priv->dma_erx)
		1012	goto err_dma;
		1013
995	priv->dma_etx = dma_alloc_coherent(priv->device, txsize *	1014	priv->dma_etx = dma_alloc_coherent(priv->device, txsize *
996	sizeof(struct	1015	sizeof(struct
997	dma_extended_desc),	1016	dma_extended_desc),
998	&priv->dma_tx_phy,	1017	&priv->dma_tx_phy,
999	GFP_KERNEL);	1018	GFP_KERNEL);
1000	if ((!priv->dma_erx) \|\| (!priv->dma_etx))	1019	if (!priv->dma_etx) {
1001	return;	1020	dma_free_coherent(priv->device, priv->dma_rx_size *
		1021	sizeof(struct dma_extended_desc),
		1022	priv->dma_erx, priv->dma_rx_phy);
		1023	goto err_dma;
		1024	}
1002	} else {	1025	} else {
1003	priv->dma_rx = dma_alloc_coherent(priv->device, rxsize *	1026	priv->dma_rx = dma_alloc_coherent(priv->device, rxsize *
1004	sizeof(struct dma_desc),	1027	sizeof(struct dma_desc),
1005	&priv->dma_rx_phy,	1028	&priv->dma_rx_phy,
1006	GFP_KERNEL);	1029	GFP_KERNEL);
		1030	if (!priv->dma_rx)
		1031	goto err_dma;
		1032
1007	priv->dma_tx = dma_alloc_coherent(priv->device, txsize *	1033	priv->dma_tx = dma_alloc_coherent(priv->device, txsize *
1008	sizeof(struct dma_desc),	1034	sizeof(struct dma_desc),
1009	&priv->dma_tx_phy,	1035	&priv->dma_tx_phy,
1010	GFP_KERNEL);	1036	GFP_KERNEL);
1011	if ((!priv->dma_rx) \|\| (!priv->dma_tx))	1037	if (!priv->dma_tx) {
1012	return;	1038	dma_free_coherent(priv->device, priv->dma_rx_size *
		1039	sizeof(struct dma_desc),
		1040	priv->dma_rx, priv->dma_rx_phy);
		1041	goto err_dma;
		1042	}
1013	}	1043	}
1014		1044
1015	priv->rx_skbuff_dma = kmalloc_array(rxsize, sizeof(dma_addr_t),	1045	priv->rx_skbuff_dma = kmalloc_array(rxsize, sizeof(dma_addr_t),
1016	GFP_KERNEL);	1046	GFP_KERNEL);
		1047	if (!priv->rx_skbuff_dma)
		1048	goto err_rx_skbuff_dma;
		1049
1017	priv->rx_skbuff = kmalloc_array(rxsize, sizeof(struct sk_buff *),	1050	priv->rx_skbuff = kmalloc_array(rxsize, sizeof(struct sk_buff *),
1018	GFP_KERNEL);	1051	GFP_KERNEL);
		1052	if (!priv->rx_skbuff)
		1053	goto err_rx_skbuff;
		1054
1019	priv->tx_skbuff_dma = kmalloc_array(txsize, sizeof(dma_addr_t),	1055	priv->tx_skbuff_dma = kmalloc_array(txsize, sizeof(dma_addr_t),
1020	GFP_KERNEL);	1056	GFP_KERNEL);
		1057	if (!priv->tx_skbuff_dma)
		1058	goto err_tx_skbuff_dma;
		1059
1021	priv->tx_skbuff = kmalloc_array(txsize, sizeof(struct sk_buff *),	1060	priv->tx_skbuff = kmalloc_array(txsize, sizeof(struct sk_buff *),
1022	GFP_KERNEL);	1061	GFP_KERNEL);
		1062	if (!priv->tx_skbuff)
		1063	goto err_tx_skbuff;
		1064
1023	if (netif_msg_probe(priv)) {	1065	if (netif_msg_probe(priv)) {
1024	pr_debug("(%s) dma_rx_phy=0x%08x dma_tx_phy=0x%08x\n", __func__,	1066	pr_debug("(%s) dma_rx_phy=0x%08x dma_tx_phy=0x%08x\n", __func__,
1025	(u32) priv->dma_rx_phy, (u32) priv->dma_tx_phy);	1067	(u32) priv->dma_rx_phy, (u32) priv->dma_tx_phy);
@@ -1034,8 +1076,9 @@ static void init_dma_desc_rings(struct net_device *dev) · 8 unmodified lines
1034	else	1076	else
1035	p = priv->dma_rx + i;	1077	p = priv->dma_rx + i;
1036		1078
1037	if (stmmac_init_rx_buffers(priv, p, i))	1079	ret = stmmac_init_rx_buffers(priv, p, i);
1038	break;	1080	if (ret)
		1081	goto err_init_rx_buffers;
1039		1082
1040	if (netif_msg_probe(priv))	1083	if (netif_msg_probe(priv))
1041	pr_debug("[%p]\t[%p]\t[%x]\n", priv->rx_skbuff[i],	1084	pr_debug("[%p]\t[%p]\t[%x]\n", priv->rx_skbuff[i],
@@ -1081,20 +1124,44 @@ static void init_dma_desc_rings(struct net_device *dev) · 39 unmodified lines
1081		1124
1082	if (netif_msg_hw(priv))	1125	if (netif_msg_hw(priv))
1083	stmmac_display_rings(priv);	1126	stmmac_display_rings(priv);
		1127
		1128	return 0;
		1129	err_init_rx_buffers:
		1130	while (--i >= 0)
		1131	stmmac_free_rx_buffers(priv, i);
		1132	kfree(priv->tx_skbuff);
		1133	err_tx_skbuff:
		1134	kfree(priv->tx_skbuff_dma);
		1135	err_tx_skbuff_dma:
		1136	kfree(priv->rx_skbuff);
		1137	err_rx_skbuff:
		1138	kfree(priv->rx_skbuff_dma);
		1139	err_rx_skbuff_dma:
		1140	if (priv->extend_desc) {
		1141	dma_free_coherent(priv->device, priv->dma_tx_size *
		1142	sizeof(struct dma_extended_desc),
		1143	priv->dma_etx, priv->dma_tx_phy);
		1144	dma_free_coherent(priv->device, priv->dma_rx_size *
		1145	sizeof(struct dma_extended_desc),
		1146	priv->dma_erx, priv->dma_rx_phy);
		1147	} else {
		1148	dma_free_coherent(priv->device,
		1149	priv->dma_tx_size * sizeof(struct dma_desc),
		1150	priv->dma_tx, priv->dma_tx_phy);
		1151	dma_free_coherent(priv->device,
		1152	priv->dma_rx_size * sizeof(struct dma_desc),
		1153	priv->dma_rx, priv->dma_rx_phy);
		1154	}
		1155	err_dma:
		1156	return ret;
1084	}	1157	}
1085		1158
1086	static void dma_free_rx_skbufs(struct stmmac_priv *priv)	1159	static void dma_free_rx_skbufs(struct stmmac_priv *priv)
1087	{	1160	{
1088	int i;	1161	int i;
1089		1162
1090	for (i = 0; i < priv->dma_rx_size; i++) {	1163	for (i = 0; i < priv->dma_rx_size; i++)
1091	if (priv->rx_skbuff[i]) {	1164	stmmac_free_rx_buffers(priv, i);
1092	dma_unmap_single(priv->device, priv->rx_skbuff_dma[i],
1093	priv->dma_buf_sz, DMA_FROM_DEVICE);
1094	dev_kfree_skb_any(priv->rx_skbuff[i]);
1095	}
1096	priv->rx_skbuff[i] = NULL;
1097	}
1098	}	1165	}
1099		1166
1100	static void dma_free_tx_skbufs(struct stmmac_priv *priv)	1167	static void dma_free_tx_skbufs(struct stmmac_priv *priv)
@@ -1560,12 +1627,17 @@ static int stmmac_open(struct net_device *dev) · 459 unmodified lines
1560	priv->dma_tx_size = STMMAC_ALIGN(dma_txsize);	1627	priv->dma_tx_size = STMMAC_ALIGN(dma_txsize);
1561	priv->dma_rx_size = STMMAC_ALIGN(dma_rxsize);	1628	priv->dma_rx_size = STMMAC_ALIGN(dma_rxsize);
1562	priv->dma_buf_sz = STMMAC_ALIGN(buf_sz);	1629	priv->dma_buf_sz = STMMAC_ALIGN(buf_sz);
1563	init_dma_desc_rings(dev);	1630
		1631	ret = init_dma_desc_rings(dev);
		1632	if (ret < 0) {
		1633	pr_err("%s: DMA descriptors initialization failed\n", __func__);
		1634	goto dma_desc_error;
		1635	}
1564		1636
1565	/* DMA initialization and SW reset */	1637	/* DMA initialization and SW reset */
1566	ret = stmmac_init_dma_engine(priv);	1638	ret = stmmac_init_dma_engine(priv);
1567	if (ret < 0) {	1639	if (ret < 0) {
1568	pr_err("%s: DMA initialization failed\n", __func__);	1640	pr_err("%s: DMA engine initialization failed\n", __func__);
1569	goto init_error;	1641	goto init_error;
1570	}	1642	}
1571		1643
@@ -1672,6 +1744,7 @@ wolirq_error: · 100 unmodified lines
1672		1744
1673	init_error:	1745	init_error:
1674	free_dma_desc_resources(priv);	1746	free_dma_desc_resources(priv);
		1747	dma_desc_error:
1675	if (priv->phydev)	1748	if (priv->phydev)
1676	phy_disconnect(priv->phydev);	1749	phy_disconnect(priv->phydev);
1677	phy_error:	1750	phy_error:

drivers/net/ethernet/via/via-velocity.c+3−1

 		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
 	}
-	netif_rx(skb);
+	netif_receive_skb(skb);
 	stats->rx_bytes += pkt_len;
 	stats->rx_packets++;
 	return ret;
 err_iounmap:
+	netif_napi_del(&vptr->napi);
 	iounmap(regs);
 err_free_dev:
 	free_netdev(netdev);
 	struct velocity_info *vptr = netdev_priv(netdev);
 	unregister_netdev(netdev);
+	netif_napi_del(&vptr->napi);
 	iounmap(vptr->mac_regs);
 	free_netdev(netdev);
 	velocity_nics--;

drivers/net/irda/via-ircc.c+2−4

 			pci_write_config_byte(pcidev,0x42,(bTmp | 0xf0));
 			pci_write_config_byte(pcidev,0x5a,0xc0);
 			WriteLPCReg(0x28, 0x70 );
-			if (via_ircc_open(pcidev, &info, 0x3076) == 0)
+			rc = via_ircc_open(pcidev, &info, 0x3076);
-				rc=0;
 		} else
 			rc = -ENODEV; //IR not turn on
 	} else { //Not VT1211
 			info.irq=FirIRQ;
 			info.dma=FirDRQ1;
 			info.dma2=FirDRQ0;
-			if (via_ircc_open(pcidev, &info, 0x3096) == 0)
+			rc = via_ircc_open(pcidev, &info, 0x3096);
-				rc=0;
 		} else
 			rc = -ENODEV; //IR not turn on !!!!!
 	}//Not VT1211

drivers/net/macvlan.c+4−0

 			return -EADDRNOTAVAIL;
 	}
+	if (data && data[IFLA_MACVLAN_FLAGS] &&
+	    nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~MACVLAN_FLAG_NOPROMISC)
+		return -EINVAL;
 	if (data && data[IFLA_MACVLAN_MODE]) {
 		switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) {
 		case MACVLAN_MODE_PRIVATE:

drivers/net/macvtap.c+18−12

 #define TUN_OFFLOADS (NETIF_F_HW_CSUM | NETIF_F_TSO_ECN | NETIF_F_TSO | \
 		      NETIF_F_TSO6 | NETIF_F_UFO)
 #define RX_OFFLOADS (NETIF_F_GRO | NETIF_F_LRO)
+#define TAP_FEATURES (NETIF_F_GSO | NETIF_F_SG)
 /*
  * RCU usage:
  * The macvtap_queue and the macvlan_dev are loosely coupled, the
 {
 	struct macvlan_dev *vlan = netdev_priv(dev);
 	struct macvtap_queue *q = macvtap_get_queue(dev, skb);
-	netdev_features_t features;
+	netdev_features_t features = TAP_FEATURES;
 	if (!q)
 		goto drop;
 	skb->dev = dev;
 	/* Apply the forward feature mask so that we perform segmentation
-	 * according to users wishes.
+	 * according to users wishes.  This only works if VNET_HDR is
+	 * enabled.
 	 */
-	features = netif_skb_features(skb) & vlan->tap_features;
+	if (q->flags & IFF_VNET_HDR)
+		features |= vlan->tap_features;
 	if (netif_needs_gso(skb, features)) {
 		struct sk_buff *segs = __skb_gso_segment(skb, features, false);
 		skb_shinfo(skb)->tx_flags |= SKBTX_DEV_ZEROCOPY;
 		skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG;
 	}
-	if (vlan)
+	if (vlan) {
+		local_bh_disable();
 		macvlan_start_xmit(skb, vlan->dev);
-	else
+		local_bh_enable();
+	} else {
 		kfree_skb(skb);
+	}
 	rcu_read_unlock();
 	return total_len;
 done:
 	rcu_read_lock();
 	vlan = rcu_dereference(q->vlan);
-	if (vlan)
+	if (vlan) {
+		preempt_disable();
 		macvlan_count_rx(vlan, copied - vnet_hdr_len, ret == 0, 0);
+		preempt_enable();
+	}
 	rcu_read_unlock();
 	return ret ? ret : copied;
 	/* tap_features are the same as features on tun/tap and
 	 * reflect user expectations.
 	 */
-	vlan->tap_features = vlan->dev->features &
+	vlan->tap_features = feature_mask;
-			    (feature_mask | ~TUN_OFFLOADS);
 	vlan->set_features = features;
 	netdev_update_features(vlan->dev);
 			    TUN_F_TSO_ECN | TUN_F_UFO))
 			return -EINVAL;
-		/* TODO: only accept frames with the features that
-			 got enabled for forwarded frames */
-		if (!(q->flags & IFF_VNET_HDR))
-			return  -EINVAL;
 		rtnl_lock();
 		ret = set_offload(q, arg);
 		rtnl_unlock();

drivers/net/phy/realtek.c+2−2

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	#define RTL821x_INER_INIT 0x6400	23	#define RTL821x_INER_INIT 0x6400
24	#define RTL821x_INSR 0x13	24	#define RTL821x_INSR 0x13
25		25
26	#define RTL8211E_INER_LINK_STAT 0x10	26	#define RTL8211E_INER_LINK_STATUS 0x400
27		27
28	MODULE_DESCRIPTION("Realtek PHY driver");	28	MODULE_DESCRIPTION("Realtek PHY driver");
29	MODULE_AUTHOR("Johnson Leung");	29	MODULE_AUTHOR("Johnson Leung");
@@ -57,7 +57,7 @@ static int rtl8211e_config_intr(struct phy_device *phydev) · 27 unmodified lines
57		57
58	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)	58	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
59	err = phy_write(phydev, RTL821x_INER,	59	err = phy_write(phydev, RTL821x_INER,
60	RTL8211E_INER_LINK_STAT);	60	RTL8211E_INER_LINK_STATUS);
61	else	61	else
62	err = phy_write(phydev, RTL821x_INER, 0);	62	err = phy_write(phydev, RTL821x_INER, 0);
63		63

drivers/net/tun.c+4−2

 	u32 rxhash;
 	if (!(tun->flags & TUN_NO_PI)) {
-		if ((len -= sizeof(pi)) > total_len)
+		if (len < sizeof(pi))
 			return -EINVAL;
+		len -= sizeof(pi);
 		if (memcpy_fromiovecend((void *)&pi, iv, 0, sizeof(pi)))
 			return -EFAULT;
 	}
 	if (tun->flags & TUN_VNET_HDR) {
-		if ((len -= tun->vnet_hdr_sz) > total_len)
+		if (len < tun->vnet_hdr_sz)
 			return -EINVAL;
+		len -= tun->vnet_hdr_sz;
 		if (memcpy_fromiovecend((void *)&gso, iv, offset, sizeof(gso)))
 			return -EFAULT;

drivers/net/usb/hso.c+10−5

 static int hso_get_config_data(struct usb_interface *interface)
 {
 	struct usb_device *usbdev = interface_to_usbdev(interface);
-	u8 config_data[17];
+	u8 *config_data = kmalloc(17, GFP_KERNEL);
 	u32 if_num = interface->altsetting->desc.bInterfaceNumber;
 	s32 result;
+	if (!config_data)
+		return -ENOMEM;
 	if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 			    0x86, 0xC0, 0, 0, config_data, 17,
 			    USB_CTRL_SET_TIMEOUT) != 0x11) {
+		kfree(config_data);
 		return -EIO;
 	}
 	if (config_data[16] & 0x1)
 		result |= HSO_INFO_CRC_BUG;
+	kfree(config_data);
 	return result;
 }
 	struct hso_shared_int *shared_int;
 	struct hso_device *tmp_dev = NULL;
+	if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
+		dev_err(&interface->dev, "Not our interface\n");
+		return -ENODEV;
+	}
 	if_num = interface->altsetting->desc.bInterfaceNumber;
 	/* Get the interface/port specification from either driver_info or from
 	else
 		port_spec = hso_get_config_data(interface);
-	if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
-		dev_err(&interface->dev, "Not our interface\n");
-		return -ENODEV;
-	}
 	/* Check if we need to switch to alt interfaces prior to port
 	 * configuration */
 	if (interface->num_altsetting > 1)

drivers/net/vxlan.c+1−3

 		return -ENOTCONN;
 	if (IN_MULTICAST(ntohl(vxlan->default_dst.remote_ip)) &&
-	    ! vxlan_group_used(vn, vxlan->default_dst.remote_ip)) {
+	    vxlan_group_used(vn, vxlan->default_dst.remote_ip)) {
 		vxlan_sock_hold(vs);
 		dev_hold(dev);
 		queue_work(vxlan_wq, &vxlan->igmp_join);
 	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
 	struct vxlan_dev *vxlan = netdev_priv(dev);
-	flush_workqueue(vxlan_wq);
 	spin_lock(&vn->sock_lock);
 	hlist_del_rcu(&vxlan->hlist);
 	spin_unlock(&vn->sock_lock);

drivers/net/wireless/cw1200/sta.c+2−5

 	if (!priv->join_status)
 		goto done;
-	if (priv->join_status > CW1200_JOIN_STATUS_IBSS) {
+	if (priv->join_status == CW1200_JOIN_STATUS_AP)
-		wiphy_err(priv->hw->wiphy, "Unexpected: join status: %d\n",
+		goto done;
-			  priv->join_status);
-		BUG_ON(1);
-	}
 	cancel_work_sync(&priv->update_filtering_work);
 	cancel_work_sync(&priv->set_beacon_wakeup_period_work);

drivers/net/wireless/hostap/hostap_ioctl.c+2−2

@@ -523,9 +523,9 @@ static int prism2_ioctl_giwaplist(struct net_device *dev, · 522 unmodified lines
523		523
524	data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1);	524	data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1);
525		525
526	memcpy(extra, &addr, sizeof(struct sockaddr) * data->length);	526	memcpy(extra, addr, sizeof(struct sockaddr) * data->length);
527	data->flags = 1; /* has quality information */	527	data->flags = 1; /* has quality information */
528	memcpy(extra + sizeof(struct sockaddr) * data->length, &qual,	528	memcpy(extra + sizeof(struct sockaddr) * data->length, qual,
529	sizeof(struct iw_quality) * data->length);	529	sizeof(struct iw_quality) * data->length);
530		530
531	kfree(addr);	531	kfree(addr);

drivers/net/wireless/iwlegacy/4965-mac.c+8−8

 		 * is killed. Hence update the killswitch state here. The
 		 * rfkill handler will care about restarting if needed.
 		 */
-		if (!test_bit(S_ALIVE, &il->status)) {
+		if (hw_rf_kill) {
-			if (hw_rf_kill)
+			set_bit(S_RFKILL, &il->status);
-				set_bit(S_RFKILL, &il->status);
+		} else {
-			else
+			clear_bit(S_RFKILL, &il->status);
-				clear_bit(S_RFKILL, &il->status);
 			wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rf_kill);
+			il_force_reset(il, true);
 		}
 		handled |= CSR_INT_BIT_RF_KILL;
 	il->active_rate = RATES_MASK;
+	il_power_update_mode(il, true);
+	D_INFO("Updated power mode\n");
 	if (il_is_associated(il)) {
 		struct il_rxon_cmd *active_rxon =
 		    (struct il_rxon_cmd *)&il->active;
 	D_INFO("ALIVE processing complete.\n");
 	wake_up(&il->wait_command_queue);
-	il_power_update_mode(il, true);
-	D_INFO("Updated power mode\n");
 	return;
 restart:

drivers/net/wireless/iwlegacy/common.c+1−0

@@ -4660,6 +4660,7 @@ il_force_reset(struct il_priv *il, bool external) · 4659 unmodified lines
4660		4660
4661	return 0;	4661	return 0;
4662	}	4662	}
		4663	EXPORT_SYMBOL(il_force_reset);
4663		4664
4664	int	4665	int
4665	il_mac_change_interface(struct ieee80211_hw hw, struct ieee80211_vif vif,	4666	il_mac_change_interface(struct ieee80211_hw hw, struct ieee80211_vif vif,

drivers/net/wireless/iwlwifi/dvm/mac80211.c+4−1

@@ -1068,7 +1068,10 @@ void iwl_chswitch_done(struct iwl_priv *priv, bool is_success) · 1067 unmodified lines
1068	if (test_bit(STATUS_EXIT_PENDING, &priv->status))	1068	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
1069	return;	1069	return;
1070		1070
1071	if (test_and_clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))	1071	if (!test_and_clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
		1072	return;
		1073
		1074	if (ctx->vif)
1072	ieee80211_chswitch_done(ctx->vif, is_success);	1075	ieee80211_chswitch_done(ctx->vif, is_success);
1073	}	1076	}
1074		1077

drivers/net/wireless/iwlwifi/iwl-prph.h+0−2

@@ -97,8 +97,6 @@ · 96 unmodified lines
97		97
98	#define APMG_PCIDEV_STT_VAL_L1_ACT_DIS (0x00000800)	98	#define APMG_PCIDEV_STT_VAL_L1_ACT_DIS (0x00000800)
99		99
100	#define APMG_RTC_INT_STT_RFKILL (0x10000000)
101
102	/* Device system time */	100	/* Device system time */
103	#define DEVICE_SYSTEM_TIME_REG 0xA0206C	101	#define DEVICE_SYSTEM_TIME_REG 0xA0206C
104		102

drivers/net/wireless/iwlwifi/mvm/time-event.c+23−10

 	schedule_work(&mvm->roc_done_wk);
 }
+static bool iwl_mvm_te_check_disconnect(struct iwl_mvm *mvm,
+					struct ieee80211_vif *vif,
+					const char *errmsg)
+{
+	if (vif->type != NL80211_IFTYPE_STATION)
+		return false;
+	if (vif->bss_conf.assoc && vif->bss_conf.dtim_period)
+		return false;
+	if (errmsg)
+		IWL_ERR(mvm, "%s\n", errmsg);
+	ieee80211_connection_loss(vif);
+	return true;
+}
 /*
  * Handles a FW notification for an event that is known to the driver.
  *
 	 * P2P Device discoveribility, while there are other higher priority
 	 * events in the system).
 	 */
-	WARN_ONCE(!le32_to_cpu(notif->status),
+	if (WARN_ONCE(!le32_to_cpu(notif->status),
-		  "Failed to schedule time event\n");
+		      "Failed to schedule time event\n")) {
+		if (iwl_mvm_te_check_disconnect(mvm, te_data->vif, NULL)) {
+			iwl_mvm_te_clear_data(mvm, te_data);
+			return;
+		}
+	}
 	if (le32_to_cpu(notif->action) & TE_NOTIF_HOST_EVENT_END) {
 		IWL_DEBUG_TE(mvm,
 		 * By now, we should have finished association
 		 * and know the dtim period.
 		 */
-		if (te_data->vif->type == NL80211_IFTYPE_STATION &&
+		iwl_mvm_te_check_disconnect(mvm, te_data->vif,
-		    (!te_data->vif->bss_conf.assoc ||
+			"No assocation and the time event is over already...");
-		     !te_data->vif->bss_conf.dtim_period)) {
-			IWL_ERR(mvm,
-				"No assocation and the time event is over already...\n");
-			ieee80211_connection_loss(te_data->vif);
-		}
 		iwl_mvm_te_clear_data(mvm, te_data);
 	} else if (le32_to_cpu(notif->action) & TE_NOTIF_HOST_EVENT_START) {
 		te_data->running = true;

drivers/net/wireless/iwlwifi/pcie/rx.c+0−8

@@ -888,14 +888,6 @@ irqreturn_t iwl_pcie_irq_handler(int irq, void *dev_id) · 887 unmodified lines
888		888
889	iwl_op_mode_hw_rf_kill(trans->op_mode, hw_rfkill);	889	iwl_op_mode_hw_rf_kill(trans->op_mode, hw_rfkill);
890	if (hw_rfkill) {	890	if (hw_rfkill) {
891	/*
892	* Clear the interrupt in APMG if the NIC is going down.
893	* Note that when the NIC exits RFkill (else branch), we
894	* can't access prph and the NIC will be reset in
895	* start_hw anyway.
896	*/
897	iwl_write_prph(trans, APMG_RTC_INT_STT_REG,
898	APMG_RTC_INT_STT_RFKILL);
899	set_bit(STATUS_RFKILL, &trans_pcie->status);	891	set_bit(STATUS_RFKILL, &trans_pcie->status);
900	if (test_and_clear_bit(STATUS_HCMD_ACTIVE,	892	if (test_and_clear_bit(STATUS_HCMD_ACTIVE,
901	&trans_pcie->status))	893	&trans_pcie->status))

drivers/net/wireless/iwlwifi/pcie/trans.c+5−5

 	spin_lock_init(&trans_pcie->reg_lock);
 	init_waitqueue_head(&trans_pcie->ucode_write_waitq);
-	/* W/A - seems to solve weird behavior. We need to remove this if we
-	 * don't want to stay in L1 all the time. This wastes a lot of power */
-	pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
-			       PCIE_LINK_STATE_CLKPM);
 	if (pci_enable_device(pdev)) {
 		err = -ENODEV;
 		goto out_no_pci;
 	}
+	/* W/A - seems to solve weird behavior. We need to remove this if we
+	 * don't want to stay in L1 all the time. This wastes a lot of power */
+	pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
+			       PCIE_LINK_STATE_CLKPM);
 	pci_set_master(pdev);
 	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));

drivers/net/wireless/zd1201.c+3−1

 		goto exit;
 	err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0x4,
-	    USB_DIR_IN | 0x40, 0,0, &ret, sizeof(ret), ZD1201_FW_TIMEOUT);
+	    USB_DIR_IN | 0x40, 0, 0, buf, sizeof(ret), ZD1201_FW_TIMEOUT);
 	if (err < 0)
 		goto exit;
+	memcpy(&ret, buf, sizeof(ret));
 	if (ret & 0x80) {
 		err = -EIO;
 		goto exit;

drivers/of/fdt.c+2−0

@@ -392,6 +392,8 @@ static void __unflatten_device_tree(struct boot_param_header *blob, · 391 unmodified lines
392	mem = (unsigned long)	392	mem = (unsigned long)
393	dt_alloc(size + 4, __alignof__(struct device_node));	393	dt_alloc(size + 4, __alignof__(struct device_node));
394		394
		395	memset((void *)mem, 0, size);
		396
395	((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);	397	((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);
396		398
397	pr_debug(" unflattening %lx...\n", mem);	399	pr_debug(" unflattening %lx...\n", mem);

drivers/pinctrl/pinctrl-sunxi.c+62−4

 {
 	struct sunxi_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
 	struct sunxi_pinctrl_group *g = &pctl->groups[group];
+	unsigned long flags;
 	u32 val, mask;
 	u16 strength;
 	u8 dlevel;
 		 *   3: 40mA
 		 */
 		dlevel = strength / 10 - 1;
+		spin_lock_irqsave(&pctl->lock, flags);
 		val = readl(pctl->membase + sunxi_dlevel_reg(g->pin));
 	        mask = DLEVEL_PINS_MASK << sunxi_dlevel_offset(g->pin);
 		writel((val & ~mask) | dlevel << sunxi_dlevel_offset(g->pin),
 			pctl->membase + sunxi_dlevel_reg(g->pin));
+		spin_unlock_irqrestore(&pctl->lock, flags);
 		break;
 	case PIN_CONFIG_BIAS_PULL_UP:
+		spin_lock_irqsave(&pctl->lock, flags);
 		val = readl(pctl->membase + sunxi_pull_reg(g->pin));
 		mask = PULL_PINS_MASK << sunxi_pull_offset(g->pin);
 		writel((val & ~mask) | 1 << sunxi_pull_offset(g->pin),
 			pctl->membase + sunxi_pull_reg(g->pin));
+		spin_unlock_irqrestore(&pctl->lock, flags);
 		break;
 	case PIN_CONFIG_BIAS_PULL_DOWN:
+		spin_lock_irqsave(&pctl->lock, flags);
 		val = readl(pctl->membase + sunxi_pull_reg(g->pin));
 		mask = PULL_PINS_MASK << sunxi_pull_offset(g->pin);
 		writel((val & ~mask) | 2 << sunxi_pull_offset(g->pin),
 			pctl->membase + sunxi_pull_reg(g->pin));
+		spin_unlock_irqrestore(&pctl->lock, flags);
 		break;
 	default:
 		break;
 				 u8 config)
 {
 	struct sunxi_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
+	unsigned long flags;
+	u32 val, mask;
+	spin_lock_irqsave(&pctl->lock, flags);
-	u32 val = readl(pctl->membase + sunxi_mux_reg(pin));
+	val = readl(pctl->membase + sunxi_mux_reg(pin));
-	u32 mask = MUX_PINS_MASK << sunxi_mux_offset(pin);
+	mask = MUX_PINS_MASK << sunxi_mux_offset(pin);
 	writel((val & ~mask) | config << sunxi_mux_offset(pin),
 		pctl->membase + sunxi_mux_reg(pin));
+	spin_unlock_irqrestore(&pctl->lock, flags);
 }
 static int sunxi_pmx_enable(struct pinctrl_dev *pctldev,
 	struct sunxi_pinctrl *pctl = dev_get_drvdata(chip->dev);
 	u32 reg = sunxi_data_reg(offset);
 	u8 index = sunxi_data_offset(offset);
+	unsigned long flags;
+	u32 regval;
+	spin_lock_irqsave(&pctl->lock, flags);
+	regval = readl(pctl->membase + reg);
-	writel((value & DATA_PINS_MASK) << index, pctl->membase + reg);
+	if (value)
+		regval |= BIT(index);
+	else
+		regval &= ~(BIT(index));
+	writel(regval, pctl->membase + reg);
+	spin_unlock_irqrestore(&pctl->lock, flags);
 }
 static int sunxi_pinctrl_gpio_of_xlate(struct gpio_chip *gc,
 	struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
 	u32 reg = sunxi_irq_cfg_reg(d->hwirq);
 	u8 index = sunxi_irq_cfg_offset(d->hwirq);
+	unsigned long flags;
+	u32 regval;
 	u8 mode;
 	switch (type) {
 		return -EINVAL;
 	}
-	writel((mode & IRQ_CFG_IRQ_MASK) << index, pctl->membase + reg);
+	spin_lock_irqsave(&pctl->lock, flags);
+	regval = readl(pctl->membase + reg);
+	regval &= ~IRQ_CFG_IRQ_MASK;
+	writel(regval | (mode << index), pctl->membase + reg);
+	spin_unlock_irqrestore(&pctl->lock, flags);
 	return 0;
 }
 	u8 ctrl_idx = sunxi_irq_ctrl_offset(d->hwirq);
 	u32 status_reg = sunxi_irq_status_reg(d->hwirq);
 	u8 status_idx = sunxi_irq_status_offset(d->hwirq);
+	unsigned long flags;
 	u32 val;
+	spin_lock_irqsave(&pctl->lock, flags);
 	/* Mask the IRQ */
 	val = readl(pctl->membase + ctrl_reg);
 	writel(val & ~(1 << ctrl_idx), pctl->membase + ctrl_reg);
 	/* Clear the IRQ */
 	writel(1 << status_idx, pctl->membase + status_reg);
+	spin_unlock_irqrestore(&pctl->lock, flags);
 }
 static void sunxi_pinctrl_irq_mask(struct irq_data *d)
 	struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
 	u32 reg = sunxi_irq_ctrl_reg(d->hwirq);
 	u8 idx = sunxi_irq_ctrl_offset(d->hwirq);
+	unsigned long flags;
 	u32 val;
+	spin_lock_irqsave(&pctl->lock, flags);
 	/* Mask the IRQ */
 	val = readl(pctl->membase + reg);
 	writel(val & ~(1 << idx), pctl->membase + reg);
+	spin_unlock_irqrestore(&pctl->lock, flags);
 }
 static void sunxi_pinctrl_irq_unmask(struct irq_data *d)
 	struct sunxi_desc_function *func;
 	u32 reg = sunxi_irq_ctrl_reg(d->hwirq);
 	u8 idx = sunxi_irq_ctrl_offset(d->hwirq);
+	unsigned long flags;
 	u32 val;
 	func = sunxi_pinctrl_desc_find_function_by_pin(pctl,
 	/* Change muxing to INT mode */
 	sunxi_pmx_set(pctl->pctl_dev, pctl->irq_array[d->hwirq], func->muxval);
+	spin_lock_irqsave(&pctl->lock, flags);
 	/* Unmask the IRQ */
 	val = readl(pctl->membase + reg);
 	writel(val | (1 << idx), pctl->membase + reg);
+	spin_unlock_irqrestore(&pctl->lock, flags);
 }
 static struct irq_chip sunxi_pinctrl_irq_chip = {
 		return -ENOMEM;
 	platform_set_drvdata(pdev, pctl);
+	spin_lock_init(&pctl->lock);
 	pctl->membase = of_iomap(node, 0);
 	if (!pctl->membase)
 		return -ENOMEM;

drivers/pinctrl/pinctrl-sunxi.h+2−0

 #define __PINCTRL_SUNXI_H
 #include <linux/kernel.h>
+#include <linux/spinlock.h>
 #define PA_BASE	0
 #define PB_BASE	32
 	unsigned			ngroups;
 	int				irq;
 	int				irq_array[SUNXI_IRQ_NUMBER];
+	spinlock_t			lock;
 	struct pinctrl_dev		*pctl_dev;
 };

drivers/platform/olpc/olpc-ec.c+1−1

@@ -330,7 +330,7 @@ static int __init olpc_ec_init_module(void) · 329 unmodified lines
330	return platform_driver_register(&olpc_ec_plat_driver);	330	return platform_driver_register(&olpc_ec_plat_driver);
331	}	331	}
332		332
333	module_init(olpc_ec_init_module);	333	arch_initcall(olpc_ec_init_module);
334		334
335	MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");	335	MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
336	MODULE_LICENSE("GPL");	336	MODULE_LICENSE("GPL");

drivers/platform/x86/hp-wmi.c+0−16

 #define HPWMI_ALS_QUERY 0x3
 #define HPWMI_HARDWARE_QUERY 0x4
 #define HPWMI_WIRELESS_QUERY 0x5
-#define HPWMI_BIOS_QUERY 0x9
 #define HPWMI_HOTKEY_QUERY 0xc
 #define HPWMI_WIRELESS2_QUERY 0x1b
 #define HPWMI_POSTCODEERROR_QUERY 0x2a
 	return (state & 0x4) ? 1 : 0;
 }
-static int hp_wmi_enable_hotkeys(void)
-{
-	int ret;
-	int query = 0x6e;
-	ret = hp_wmi_perform_query(HPWMI_BIOS_QUERY, 1, &query, sizeof(query),
-				   0);
-	if (ret)
-		return -EINVAL;
-	return 0;
-}
 static int hp_wmi_set_block(void *data, bool blocked)
 {
 	enum hp_wmi_radio r = (enum hp_wmi_radio) data;
 		err = hp_wmi_input_setup();
 		if (err)
 			return err;
-		hp_wmi_enable_hotkeys();
 	}
 	if (bios_capable) {

drivers/platform/x86/sony-laptop.c+6−2

 	if (pos < 0)
 		return pos;
-	return snprintf(buffer, PAGE_SIZE, "%s\n", pos ? "speed" : "stamina");
+	return snprintf(buffer, PAGE_SIZE, "%s\n",
+					pos == SPEED ? "speed" :
+					pos == STAMINA ? "stamina" :
+					pos == AUTO ? "auto" : "unknown");
 }
 static int sony_nc_gfx_switch_setup(struct platform_device *pd,
 		goto err_free_resources;
 	}
-	if (sonypi_compat_init())
+	result = sonypi_compat_init();
+	if (result)
 		goto err_remove_input;
 	/* request io port */

drivers/rtc/rtc-stmp3xxx.c+25−10

 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
+#include <linux/delay.h>
 #include <linux/rtc.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
 }
 #endif /* CONFIG_STMP3XXX_RTC_WATCHDOG */
-static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
+static int stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
 {
+	int timeout = 5000; /* 3ms according to i.MX28 Ref Manual */
 	/*
-	 * The datasheet doesn't say which way round the
+	 * The i.MX28 Applications Processor Reference Manual, Rev. 1, 2010
-	 * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
+	 * states:
-	 * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
+	 * | The order in which registers are updated is
+	 * | Persistent 0, 1, 2, 3, 4, 5, Alarm, Seconds.
+	 * | (This list is in bitfield order, from LSB to MSB, as they would
+	 * | appear in the STALE_REGS and NEW_REGS bitfields of the HW_RTC_STAT
+	 * | register. For example, the Seconds register corresponds to
+	 * | STALE_REGS or NEW_REGS containing 0x80.)
 	 */
-	while (readl(rtc_data->io + STMP3XXX_RTC_STAT) &
+	do {
-			(0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT))
+		if (!(readl(rtc_data->io + STMP3XXX_RTC_STAT) &
-		cpu_relax();
+				(0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT)))
+			return 0;
+		udelay(1);
+	} while (--timeout > 0);
+	return (readl(rtc_data->io + STMP3XXX_RTC_STAT) &
+		(0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT)) ? -ETIME : 0;
 }
 /* Time read/write */
 static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
 {
+	int ret;
 	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
-	stmp3xxx_wait_time(rtc_data);
+	ret = stmp3xxx_wait_time(rtc_data);
+	if (ret)
+		return ret;
 	rtc_time_to_tm(readl(rtc_data->io + STMP3XXX_RTC_SECONDS), rtc_tm);
 	return 0;
 }
 	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
 	writel(t, rtc_data->io + STMP3XXX_RTC_SECONDS);
-	stmp3xxx_wait_time(rtc_data);
+	return stmp3xxx_wait_time(rtc_data);
-	return 0;
 }
 /* interrupt(s) handler */

drivers/s390/scsi/zfcp_erp.c+22−7

 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 		zfcp_erp_action_dismiss(&port->erp_action);
-	else
+	else {
-		shost_for_each_device(sdev, port->adapter->scsi_host)
+		spin_lock(port->adapter->scsi_host->host_lock);
+		__shost_for_each_device(sdev, port->adapter->scsi_host)
 			if (sdev_to_zfcp(sdev)->port == port)
 				zfcp_erp_action_dismiss_lun(sdev);
+		spin_unlock(port->adapter->scsi_host->host_lock);
+	}
 }
 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 {
 	struct scsi_device *sdev;
-	shost_for_each_device(sdev, port->adapter->scsi_host)
+	spin_lock(port->adapter->scsi_host->host_lock);
+	__shost_for_each_device(sdev, port->adapter->scsi_host)
 		if (sdev_to_zfcp(sdev)->port == port)
 			_zfcp_erp_lun_reopen(sdev, clear, id, 0);
+	spin_unlock(port->adapter->scsi_host->host_lock);
 }
 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
 		atomic_set_mask(common_mask, &port->status);
 	read_unlock_irqrestore(&adapter->port_list_lock, flags);
-	shost_for_each_device(sdev, adapter->scsi_host)
+	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
+	__shost_for_each_device(sdev, adapter->scsi_host)
 		atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
+	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
 }
 /**
 	}
 	read_unlock_irqrestore(&adapter->port_list_lock, flags);
-	shost_for_each_device(sdev, adapter->scsi_host) {
+	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
+	__shost_for_each_device(sdev, adapter->scsi_host) {
 		atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
 		if (clear_counter)
 			atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
 	}
+	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
 }
 /**
 {
 	struct scsi_device *sdev;
 	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
+	unsigned long flags;
 	atomic_set_mask(mask, &port->status);
 	if (!common_mask)
 		return;
-	shost_for_each_device(sdev, port->adapter->scsi_host)
+	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
+	__shost_for_each_device(sdev, port->adapter->scsi_host)
 		if (sdev_to_zfcp(sdev)->port == port)
 			atomic_set_mask(common_mask,
 					&sdev_to_zfcp(sdev)->status);
+	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
 }
 /**
 	struct scsi_device *sdev;
 	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 	u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
+	unsigned long flags;
 	atomic_clear_mask(mask, &port->status);
 	if (clear_counter)
 		atomic_set(&port->erp_counter, 0);
-	shost_for_each_device(sdev, port->adapter->scsi_host)
+	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
+	__shost_for_each_device(sdev, port->adapter->scsi_host)
 		if (sdev_to_zfcp(sdev)->port == port) {
 			atomic_clear_mask(common_mask,
 					  &sdev_to_zfcp(sdev)->status);
 			if (clear_counter)
 				atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
 		}
+	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
 }
 /**

drivers/s390/scsi/zfcp_qdio.c+2−6

 static int zfcp_qdio_sbal_check(struct zfcp_qdio *qdio)
 {
-	spin_lock_irq(&qdio->req_q_lock);
 	if (atomic_read(&qdio->req_q_free) ||
 	    !(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
 		return 1;
-	spin_unlock_irq(&qdio->req_q_lock);
 	return 0;
 }
 {
 	long ret;
-	spin_unlock_irq(&qdio->req_q_lock);
+	ret = wait_event_interruptible_lock_irq_timeout(qdio->req_q_wq,
-	ret = wait_event_interruptible_timeout(qdio->req_q_wq,
+		       zfcp_qdio_sbal_check(qdio), qdio->req_q_lock, 5 * HZ);
-			       zfcp_qdio_sbal_check(qdio), 5 * HZ);
 	if (!(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
 		return -EIO;
 		zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
 	}
-	spin_lock_irq(&qdio->req_q_lock);
 	return -EIO;
 }

drivers/s390/scsi/zfcp_sysfs.c+14−0

 static ZFCP_DEV_ATTR(_feat, _name, S_IRUGO,				       \
 		     zfcp_sysfs_##_feat##_##_name##_show, NULL);
+#define ZFCP_DEFINE_ATTR_CONST(_feat, _name, _format, _value)		       \
+static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev,	       \
+						   struct device_attribute *at,\
+						   char *buf)		       \
+{									       \
+	return sprintf(buf, _format, _value);				       \
+}									       \
+static ZFCP_DEV_ATTR(_feat, _name, S_IRUGO,				       \
+		     zfcp_sysfs_##_feat##_##_name##_show, NULL);
 #define ZFCP_DEFINE_A_ATTR(_name, _format, _value)			     \
 static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev,	     \
 						 struct device_attribute *at,\
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_denied, "%d\n",
 		 (zfcp_unit_sdev_status(unit) &
 		  ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
+ZFCP_DEFINE_ATTR_CONST(unit, access_shared, "%d\n", 0);
+ZFCP_DEFINE_ATTR_CONST(unit, access_readonly, "%d\n", 0);
 static ssize_t zfcp_sysfs_port_failed_show(struct device *dev,
 					   struct device_attribute *attr,
 	&dev_attr_unit_in_recovery.attr,
 	&dev_attr_unit_status.attr,
 	&dev_attr_unit_access_denied.attr,
+	&dev_attr_unit_access_shared.attr,
+	&dev_attr_unit_access_readonly.attr,
 	NULL
 };
 static struct attribute_group zfcp_unit_attr_group = {

drivers/scsi/Kconfig+0−1

@@ -1353,7 +1353,6 @@ config SCSI_LPFC · 1352 unmodified lines
1353	tristate "Emulex LightPulse Fibre Channel Support"	1353	tristate "Emulex LightPulse Fibre Channel Support"
1354	depends on PCI && SCSI	1354	depends on PCI && SCSI
1355	select SCSI_FC_ATTRS	1355	select SCSI_FC_ATTRS
1356	select GENERIC_CSUM
1357	select CRC_T10DIF	1356	select CRC_T10DIF
1358	help	1357	help
1359	This lpfc driver supports the Emulex LightPulse	1358	This lpfc driver supports the Emulex LightPulse

drivers/staging/comedi/drivers.c+1−1

@@ -482,7 +482,7 @@ int comedi_device_attach(struct comedi_device dev, struct comedi_devconfig it) · 481 unmodified lines
482	ret = comedi_device_postconfig(dev);	482	ret = comedi_device_postconfig(dev);
483	if (ret < 0) {	483	if (ret < 0) {
484	comedi_device_detach(dev);	484	comedi_device_detach(dev);
485	module_put(dev->driver->module);	485	module_put(driv->module);
486	}	486	}
487	/* On success, the driver module count has been incremented. */	487	/* On success, the driver module count has been incremented. */
488	return ret;	488	return ret;

drivers/tty/hvc/hvsi_lib.c+2−2

@@ -341,8 +341,8 @@ void hvsilib_establish(struct hvsi_priv *pv) · 340 unmodified lines
341		341
342	pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno);	342	pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno);
343		343
344	/* Try for up to 200s */	344	/* Try for up to 400ms */
345	for (timeout = 0; timeout < 20; timeout++) {	345	for (timeout = 0; timeout < 40; timeout++) {
346	if (pv->established)	346	if (pv->established)
347	goto established;	347	goto established;
348	if (!hvsi_get_packet(pv))	348	if (!hvsi_get_packet(pv))

drivers/usb/class/usbtmc.c+4−4

@@ -1119,11 +1119,11 @@ static int usbtmc_probe(struct usb_interface *intf, · 1118 unmodified lines
1119	/* Determine if it is a Rigol or not */	1119	/* Determine if it is a Rigol or not */
1120	data->rigol_quirk = 0;	1120	data->rigol_quirk = 0;
1121	dev_dbg(&intf->dev, "Trying to find if device Vendor 0x%04X Product 0x%04X has the RIGOL quirk\n",	1121	dev_dbg(&intf->dev, "Trying to find if device Vendor 0x%04X Product 0x%04X has the RIGOL quirk\n",
1122	data->usb_dev->descriptor.idVendor,	1122	le16_to_cpu(data->usb_dev->descriptor.idVendor),
1123	data->usb_dev->descriptor.idProduct);	1123	le16_to_cpu(data->usb_dev->descriptor.idProduct));
1124	for(n = 0; usbtmc_id_quirk[n].idVendor > 0; n++) {	1124	for(n = 0; usbtmc_id_quirk[n].idVendor > 0; n++) {
1125	if ((usbtmc_id_quirk[n].idVendor == data->usb_dev->descriptor.idVendor) &&	1125	if ((usbtmc_id_quirk[n].idVendor == le16_to_cpu(data->usb_dev->descriptor.idVendor)) &&
1126	(usbtmc_id_quirk[n].idProduct == data->usb_dev->descriptor.idProduct)) {	1126	(usbtmc_id_quirk[n].idProduct == le16_to_cpu(data->usb_dev->descriptor.idProduct))) {
1127	dev_dbg(&intf->dev, "Setting this device as having the RIGOL quirk\n");	1127	dev_dbg(&intf->dev, "Setting this device as having the RIGOL quirk\n");
1128	data->rigol_quirk = 1;	1128	data->rigol_quirk = 1;
1129	break;	1129	break;

drivers/usb/core/quirks.c+6−0

 	{ USB_DEVICE(0x04d8, 0x000c), .driver_info =
 			USB_QUIRK_CONFIG_INTF_STRINGS },
+	/* CarrolTouch 4000U */
+	{ USB_DEVICE(0x04e7, 0x0009), .driver_info = USB_QUIRK_RESET_RESUME },
+	/* CarrolTouch 4500U */
+	{ USB_DEVICE(0x04e7, 0x0030), .driver_info = USB_QUIRK_RESET_RESUME },
 	/* Samsung Android phone modem - ID conflict with SPH-I500 */
 	{ USB_DEVICE(0x04e8, 0x6601), .driver_info =
 			USB_QUIRK_CONFIG_INTF_STRINGS },

drivers/usb/host/ehci-sched.c+6−7

 		/* Behind the scheduling threshold? */
 		if (unlikely(start < next)) {
+			unsigned now2 = (now - base) & (mod - 1);
 			/* USB_ISO_ASAP: Round up to the first available slot */
 			if (urb->transfer_flags & URB_ISO_ASAP)
 				start += (next - start + period - 1) & -period;
 			/*
-			 * Not ASAP: Use the next slot in the stream.  If
+			 * Not ASAP: Use the next slot in the stream,
-			 * the entire URB falls before the threshold, fail.
+			 * no matter what.
 			 */
-			else if (start + span - period < next) {
+			else if (start + span - period < now2) {
-				ehci_dbg(ehci, "iso urb late %p (%u+%u < %u)\n",
+				ehci_dbg(ehci, "iso underrun %p (%u+%u < %u)\n",
 						urb, start + base,
-						span - period, next + base);
+						span - period, now2 + base);
-				status = -EXDEV;
-				goto fail;
 			}
 		}

drivers/usb/host/ohci-pci.c+7−0

@@ -304,6 +304,13 @@ static int __init ohci_pci_init(void) · 303 unmodified lines
304	pr_info("%s: " DRIVER_DESC "\n", hcd_name);	304	pr_info("%s: " DRIVER_DESC "\n", hcd_name);
305		305
306	ohci_init_driver(&ohci_pci_hc_driver, &pci_overrides);	306	ohci_init_driver(&ohci_pci_hc_driver, &pci_overrides);
		307
		308	#ifdef CONFIG_PM
		309	/* Entries for the PCI suspend/resume callbacks are special */
		310	ohci_pci_hc_driver.pci_suspend = ohci_suspend;
		311	ohci_pci_hc_driver.pci_resume = ohci_resume;
		312	#endif
		313
307	return pci_register_driver(&ohci_pci_driver);	314	return pci_register_driver(&ohci_pci_driver);
308	}	315	}
309	module_init(ohci_pci_init);	316	module_init(ohci_pci_init);

drivers/usb/misc/adutux.c+1−1

@@ -830,7 +830,7 @@ static int adu_probe(struct usb_interface *interface, · 829 unmodified lines
830		830
831	/* let the user know what node this device is now attached to */	831	/* let the user know what node this device is now attached to */
832	dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n",	832	dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n",
833	udev->descriptor.idProduct, dev->serial_number,	833	le16_to_cpu(udev->descriptor.idProduct), dev->serial_number,
834	(dev->minor - ADU_MINOR_BASE));	834	(dev->minor - ADU_MINOR_BASE));
835	exit:	835	exit:
836	dbg(2, " %s : leave, return value %p (dev)", __func__, dev);	836	dbg(2, " %s : leave, return value %p (dev)", __func__, dev);

drivers/usb/phy/phy-fsl-usb.h+1−1

@@ -15,7 +15,7 @@ · 14 unmodified lines
15	* 675 Mass Ave, Cambridge, MA 02139, USA.	15	* 675 Mass Ave, Cambridge, MA 02139, USA.
16	*/	16	*/
17		17
18	#include "otg_fsm.h"	18	#include "phy-fsm-usb.h"
19	#include <linux/usb/otg.h>	19	#include <linux/usb/otg.h>
20	#include <linux/ioctl.h>	20	#include <linux/ioctl.h>
21		21

drivers/usb/phy/phy-fsm-usb.c+1−1

@@ -29,7 +29,7 @@ · 28 unmodified lines
29	#include <linux/usb/gadget.h>	29	#include <linux/usb/gadget.h>
30	#include <linux/usb/otg.h>	30	#include <linux/usb/otg.h>
31		31
32	#include "phy-otg-fsm.h"	32	#include "phy-fsm-usb.h"
33		33
34	/* Change USB protocol when there is a protocol change */	34	/* Change USB protocol when there is a protocol change */
35	static int otg_set_protocol(struct otg_fsm *fsm, int protocol)	35	static int otg_set_protocol(struct otg_fsm *fsm, int protocol)

drivers/usb/serial/keyspan.c+1−1

@@ -2303,7 +2303,7 @@ static int keyspan_startup(struct usb_serial *serial) · 2302 unmodified lines
2303	if (d_details == NULL) {	2303	if (d_details == NULL) {
2304	dev_err(&serial->dev->dev, "%s - unknown product id %x\n",	2304	dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2305	__func__, le16_to_cpu(serial->dev->descriptor.idProduct));	2305	__func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2306	return 1;	2306	return -ENODEV;
2307	}	2307	}
2308		2308
2309	/* Setup private data for serial driver */	2309	/* Setup private data for serial driver */

drivers/usb/serial/mos7720.c+14−7

 	struct list_head        urblist_entry;
 	struct kref             ref_count;
 	struct urb              *urb;
+	struct usb_ctrlrequest	*setup;
 };
 enum mos7715_pp_modes {
 	struct mos7715_parport *mos_parport = urbtrack->mos_parport;
 	usb_free_urb(urbtrack->urb);
+	kfree(urbtrack->setup);
 	kfree(urbtrack);
 	kref_put(&mos_parport->ref_count, destroy_mos_parport);
 }
 	struct urbtracker *urbtrack;
 	int ret_val;
 	unsigned long flags;
-	struct usb_ctrlrequest setup;
 	struct usb_serial *serial = mos_parport->serial;
 	struct usb_device *usbdev = serial->dev;
 		kfree(urbtrack);
 		return -ENOMEM;
 	}
-	setup.bRequestType = (__u8)0x40;
+	urbtrack->setup = kmalloc(sizeof(*urbtrack->setup), GFP_KERNEL);
-	setup.bRequest = (__u8)0x0e;
+	if (!urbtrack->setup) {
-	setup.wValue = get_reg_value(reg, dummy);
+		usb_free_urb(urbtrack->urb);
-	setup.wIndex = get_reg_index(reg);
+		kfree(urbtrack);
-	setup.wLength = 0;
+		return -ENOMEM;
+	}
+	urbtrack->setup->bRequestType = (__u8)0x40;
+	urbtrack->setup->bRequest = (__u8)0x0e;
+	urbtrack->setup->wValue = get_reg_value(reg, dummy);
+	urbtrack->setup->wIndex = get_reg_index(reg);
+	urbtrack->setup->wLength = 0;
 	usb_fill_control_urb(urbtrack->urb, usbdev,
 			     usb_sndctrlpipe(usbdev, 0),
-			     (unsigned char *)&setup,
+			     (unsigned char *)urbtrack->setup,
 			     NULL, 0, async_complete, urbtrack);
 	kref_init(&urbtrack->ref_count);
 	INIT_LIST_HEAD(&urbtrack->urblist_entry);

drivers/usb/serial/mos7840.c+1−1

@@ -2193,7 +2193,7 @@ static int mos7810_check(struct usb_serial *serial) · 2192 unmodified lines
2193	static int mos7840_probe(struct usb_serial *serial,	2193	static int mos7840_probe(struct usb_serial *serial,
2194	const struct usb_device_id *id)	2194	const struct usb_device_id *id)
2195	{	2195	{
2196	u16 product = serial->dev->descriptor.idProduct;	2196	u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
2197	u8 *buf;	2197	u8 *buf;
2198	int device_type;	2198	int device_type;
2199		2199

drivers/usb/serial/ti_usb_3410_5052.c+5−4

 	char buf[32];
 	/* try ID specific firmware first, then try generic firmware */
-	sprintf(buf, "ti_usb-v%04x-p%04x.fw", dev->descriptor.idVendor,
+	sprintf(buf, "ti_usb-v%04x-p%04x.fw",
-	    dev->descriptor.idProduct);
+			le16_to_cpu(dev->descriptor.idVendor),
+			le16_to_cpu(dev->descriptor.idProduct));
 	status = request_firmware(&fw_p, buf, &dev->dev);
 	if (status != 0) {
 		buf[0] = '\0';
-		if (dev->descriptor.idVendor == MTS_VENDOR_ID) {
+		if (le16_to_cpu(dev->descriptor.idVendor) == MTS_VENDOR_ID) {
-			switch (dev->descriptor.idProduct) {
+			switch (le16_to_cpu(dev->descriptor.idProduct)) {
 			case MTS_CDMA_PRODUCT_ID:
 				strcpy(buf, "mts_cdma.fw");
 				break;

drivers/usb/serial/usb_wwan.c+10−10

@@ -291,18 +291,18 @@ static void usb_wwan_indat_callback(struct urb *urb) · 290 unmodified lines
291	tty_flip_buffer_push(&port->port);	291	tty_flip_buffer_push(&port->port);
292	} else	292	} else
293	dev_dbg(dev, "%s: empty read urb received\n", __func__);	293	dev_dbg(dev, "%s: empty read urb received\n", __func__);
294		294	}
295	/* Resubmit urb so we continue receiving */	295	/* Resubmit urb so we continue receiving */
296	err = usb_submit_urb(urb, GFP_ATOMIC);	296	err = usb_submit_urb(urb, GFP_ATOMIC);
297	if (err) {	297	if (err) {
298	if (err != -EPERM) {	298	if (err != -EPERM) {
299	dev_err(dev, "%s: resubmit read urb failed. (%d)\n", __func__, err);	299	dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
300	/* busy also in error unless we are killed */	300	__func__, err);
301	usb_mark_last_busy(port->serial->dev);	301	/* busy also in error unless we are killed */
302	}
303	} else {
304	usb_mark_last_busy(port->serial->dev);	302	usb_mark_last_busy(port->serial->dev);
305	}	303	}
		304	} else {
		305	usb_mark_last_busy(port->serial->dev);
306	}	306	}
307	}	307	}
308		308

drivers/usb/wusbcore/wa-xfer.c+7−2

 	}
 	spin_lock_irqsave(&xfer->lock, flags);
 	rpipe = xfer->ep->hcpriv;
+	if (rpipe == NULL) {
+		pr_debug("%s: xfer id 0x%08X has no RPIPE.  %s",
+			__func__, wa_xfer_id(xfer),
+			"Probably already aborted.\n" );
+		goto out_unlock;
+	}
 	/* Check the delayed list -> if there, release and complete */
 	spin_lock_irqsave(&wa->xfer_list_lock, flags2);
 	if (!list_empty(&xfer->list_node) && xfer->seg == NULL)
 			break;
 		}
 		usb_status = xfer_result->bTransferStatus & 0x3f;
-		if (usb_status == WA_XFER_STATUS_ABORTED
+		if (usb_status == WA_XFER_STATUS_NOT_FOUND)
-		    || usb_status == WA_XFER_STATUS_NOT_FOUND)
 			/* taken care of already */
 			break;
 		xfer_id = xfer_result->dwTransferID;

drivers/xen/events.c+12−1

 	for_each_possible_cpu(i)
 		memset(per_cpu(cpu_evtchn_mask, i),
-		       (i == 0) ? ~0 : 0, sizeof(*per_cpu(cpu_evtchn_mask, i)));
+		       (i == 0) ? ~0 : 0, NR_EVENT_CHANNELS/8);
 }
 static inline void clear_evtchn(int port)
 /* Rebind an evtchn so that it gets delivered to a specific cpu */
 static int rebind_irq_to_cpu(unsigned irq, unsigned tcpu)
 {
+	struct shared_info *s = HYPERVISOR_shared_info;
 	struct evtchn_bind_vcpu bind_vcpu;
 	int evtchn = evtchn_from_irq(irq);
+	int masked;
 	if (!VALID_EVTCHN(evtchn))
 		return -1;
 	bind_vcpu.port = evtchn;
 	bind_vcpu.vcpu = tcpu;
+	/*
+	 * Mask the event while changing the VCPU binding to prevent
+	 * it being delivered on an unexpected VCPU.
+	 */
+	masked = sync_test_and_set_bit(evtchn, BM(s->evtchn_mask));
 	/*
 	 * If this fails, it usually just indicates that we're dealing with a
 	 * virq or IPI channel, which don't actually need to be rebound. Ignore
 	if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_vcpu, &bind_vcpu) >= 0)
 		bind_evtchn_to_cpu(evtchn, tcpu);
+	if (!masked)
+		unmask_evtchn(evtchn);
 	return 0;
 }

fs/bfs/inode.c+1−1

@@ -40,7 +40,7 @@ struct inode bfs_iget(struct super_block sb, unsigned long ino) · 39 unmodified lines
40	int block, off;	40	int block, off;
41		41
42	inode = iget_locked(sb, ino);	42	inode = iget_locked(sb, ino);
43	if (IS_ERR(inode))	43	if (!inode)
44	return ERR_PTR(-ENOMEM);	44	return ERR_PTR(-ENOMEM);
45	if (!(inode->i_state & I_NEW))	45	if (!(inode->i_state & I_NEW))
46	return inode;	46	return inode;

fs/bio.c+15−5

 int bio_uncopy_user(struct bio *bio)
 {
 	struct bio_map_data *bmd = bio->bi_private;
-	int ret = 0;
+	struct bio_vec *bvec;
+	int ret = 0, i;
-	if (!bio_flagged(bio, BIO_NULL_MAPPED))
+	if (!bio_flagged(bio, BIO_NULL_MAPPED)) {
-		ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs,
+		/*
-				     bmd->nr_sgvecs, bio_data_dir(bio) == READ,
+		 * if we're in a workqueue, the request is orphaned, so
-				     0, bmd->is_our_pages);
+		 * don't copy into a random user address space, just free.
+		 */
+		if (current->mm)
+			ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs,
+					     bmd->nr_sgvecs, bio_data_dir(bio) == READ,
+					     0, bmd->is_our_pages);
+		else if (bmd->is_our_pages)
+			bio_for_each_segment_all(bvec, bio, i)
+				__free_page(bvec->bv_page);
+	}
 	bio_free_map_data(bmd);
 	bio_put(bio);
 	return ret;

fs/cifs/cifsencrypt.c+9−5

 	server->secmech.md5 = crypto_alloc_shash("md5", 0, 0);
 	if (IS_ERR(server->secmech.md5)) {
 		cifs_dbg(VFS, "could not allocate crypto md5\n");
-		return PTR_ERR(server->secmech.md5);
+		rc = PTR_ERR(server->secmech.md5);
+		server->secmech.md5 = NULL;
+		return rc;
 	}
 	size = sizeof(struct shash_desc) +
 			crypto_shash_descsize(server->secmech.md5);
 	server->secmech.sdescmd5 = kmalloc(size, GFP_KERNEL);
 	if (!server->secmech.sdescmd5) {
-		rc = -ENOMEM;
 		crypto_free_shash(server->secmech.md5);
 		server->secmech.md5 = NULL;
-		return rc;
+		return -ENOMEM;
 	}
 	server->secmech.sdescmd5->shash.tfm = server->secmech.md5;
 	server->secmech.sdescmd5->shash.flags = 0x0;
 		if (blobptr + attrsize > blobend)
 			break;
 		if (type == NTLMSSP_AV_NB_DOMAIN_NAME) {
-			if (!attrsize)
+			if (!attrsize || attrsize >= CIFS_MAX_DOMAINNAME_LEN)
 				break;
 			if (!ses->domainName) {
 				ses->domainName =
 static int crypto_hmacmd5_alloc(struct TCP_Server_Info *server)
 {
+	int rc;
 	unsigned int size;
 	/* check if already allocated */
 	server->secmech.hmacmd5 = crypto_alloc_shash("hmac(md5)", 0, 0);
 	if (IS_ERR(server->secmech.hmacmd5)) {
 		cifs_dbg(VFS, "could not allocate crypto hmacmd5\n");
-		return PTR_ERR(server->secmech.hmacmd5);
+		rc = PTR_ERR(server->secmech.hmacmd5);
+		server->secmech.hmacmd5 = NULL;
+		return rc;
 	}
 	size = sizeof(struct shash_desc) +

fs/cifs/cifsfs.c+5−6

 		goto out_no_root;
 	}
+	if (cifs_sb_master_tcon(cifs_sb)->nocase)
+		sb->s_d_op = &cifs_ci_dentry_ops;
+	else
+		sb->s_d_op = &cifs_dentry_ops;
 	sb->s_root = d_make_root(inode);
 	if (!sb->s_root) {
 		rc = -ENOMEM;
 		goto out_no_root;
 	}
-	/* do that *after* d_make_root() - we want NULL ->d_op for root here */
-	if (cifs_sb_master_tcon(cifs_sb)->nocase)
-		sb->s_d_op = &cifs_ci_dentry_ops;
-	else
-		sb->s_d_op = &cifs_dentry_ops;
 #ifdef CONFIG_CIFS_NFSD_EXPORT
 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 		cifs_dbg(FYI, "export ops supported\n");

fs/cifs/cifsglob.h+4−0

 #define MAX_TREE_SIZE (2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1)
 #define MAX_SERVER_SIZE 15
 #define MAX_SHARE_SIZE 80
+#define CIFS_MAX_DOMAINNAME_LEN 256 /* max domain name length */
 #define MAX_USERNAME_SIZE 256	/* reasonable maximum for current servers */
 #define MAX_PASSWORD_SIZE 512	/* max for windows seems to be 256 wide chars */
 	void (*generate_signingkey)(struct TCP_Server_Info *server);
 	int (*calc_signature)(struct smb_rqst *rqst,
 				   struct TCP_Server_Info *server);
+	int (*query_mf_symlink)(const unsigned char *path, char *pbuf,
+			unsigned int *pbytes_read, struct cifs_sb_info *cifs_sb,
+			unsigned int xid);
 };
 struct smb_version_values {

fs/cifs/cifsproto.h+3−1

@@ -497,5 +497,7 @@ void cifs_writev_complete(struct work_struct *work); · 496 unmodified lines
497	struct cifs_writedata *cifs_writedata_alloc(unsigned int nr_pages,	497	struct cifs_writedata *cifs_writedata_alloc(unsigned int nr_pages,
498	work_func_t complete);	498	work_func_t complete);
499	void cifs_writedata_release(struct kref *refcount);	499	void cifs_writedata_release(struct kref *refcount);
500		500	int open_query_close_cifs_symlink(const unsigned char path, char pbuf,
		501	unsigned int pbytes_read, struct cifs_sb_info cifs_sb,
		502	unsigned int xid);
501	#endif /* _CIFSPROTO_H */	503	#endif /* _CIFSPROTO_H */

fs/cifs/connect.c+4−3

 			if (string == NULL)
 				goto out_nomem;
-			if (strnlen(string, 256) == 256) {
+			if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
+					== CIFS_MAX_DOMAINNAME_LEN) {
 				printk(KERN_WARNING "CIFS: domain name too"
 						    " long\n");
 				goto cifs_parse_mount_err;
 #ifdef CONFIG_KEYS
-/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
+/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
-#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
+#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
 /* Populate username and pw fields from keyring if possible */
 static int

fs/cifs/file.c+1−0

@@ -647,6 +647,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush) · 646 unmodified lines
647	oflags, &oplock, &cfile->fid.netfid, xid);	647	oflags, &oplock, &cfile->fid.netfid, xid);
648	if (rc == 0) {	648	if (rc == 0) {
649	cifs_dbg(FYI, "posix reopen succeeded\n");	649	cifs_dbg(FYI, "posix reopen succeeded\n");
		650	oparms.reconnect = true;
650	goto reopen_success;	651	goto reopen_success;
651	}	652	}
652	/*	653	/*

fs/cifs/link.c+53−31

 }
 int
-CIFSCheckMFSymlink(struct cifs_fattr *fattr,
+open_query_close_cifs_symlink(const unsigned char *path, char *pbuf,
-		   const unsigned char *path,
+			unsigned int *pbytes_read, struct cifs_sb_info *cifs_sb,
-		   struct cifs_sb_info *cifs_sb, unsigned int xid)
+			unsigned int xid)
 {
 	int rc;
 	int oplock = 0;
 	__u16 netfid = 0;
 	struct tcon_link *tlink;
-	struct cifs_tcon *pTcon;
+	struct cifs_tcon *ptcon;
 	struct cifs_io_parms io_parms;
-	u8 *buf;
-	char *pbuf;
-	unsigned int bytes_read = 0;
 	int buf_type = CIFS_NO_BUFFER;
-	unsigned int link_len = 0;
 	FILE_ALL_INFO file_info;
-	if (!CIFSCouldBeMFSymlink(fattr))
-		/* it's not a symlink */
-		return 0;
 	tlink = cifs_sb_tlink(cifs_sb);
 	if (IS_ERR(tlink))
 		return PTR_ERR(tlink);
-	pTcon = tlink_tcon(tlink);
+	ptcon = tlink_tcon(tlink);
-	rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
+	rc = CIFSSMBOpen(xid, ptcon, path, FILE_OPEN, GENERIC_READ,
 			 CREATE_NOT_DIR, &netfid, &oplock, &file_info,
 			 cifs_sb->local_nls,
 			 cifs_sb->mnt_cifs_flags &
 				CIFS_MOUNT_MAP_SPECIAL_CHR);
-	if (rc != 0)
+	if (rc != 0) {
-		goto out;
+		cifs_put_tlink(tlink);
+		return rc;
+	}
 	if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
-		CIFSSMBClose(xid, pTcon, netfid);
+		CIFSSMBClose(xid, ptcon, netfid);
+		cifs_put_tlink(tlink);
 		/* it's not a symlink */
-		goto out;
+		return rc;
 	}
-	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
-	if (!buf) {
-		rc = -ENOMEM;
-		goto out;
-	}
-	pbuf = buf;
 	io_parms.netfid = netfid;
 	io_parms.pid = current->tgid;
-	io_parms.tcon = pTcon;
+	io_parms.tcon = ptcon;
 	io_parms.offset = 0;
 	io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
-	rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
+	rc = CIFSSMBRead(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
-	CIFSSMBClose(xid, pTcon, netfid);
+	CIFSSMBClose(xid, ptcon, netfid);
-	if (rc != 0) {
+	cifs_put_tlink(tlink);
-		kfree(buf);
+	return rc;
+}
+int
+CIFSCheckMFSymlink(struct cifs_fattr *fattr,
+		   const unsigned char *path,
+		   struct cifs_sb_info *cifs_sb, unsigned int xid)
+{
+	int rc = 0;
+	u8 *buf = NULL;
+	unsigned int link_len = 0;
+	unsigned int bytes_read = 0;
+	struct cifs_tcon *ptcon;
+	if (!CIFSCouldBeMFSymlink(fattr))
+		/* it's not a symlink */
+		return 0;
+	buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
+	if (!buf) {
+		rc = -ENOMEM;
 		goto out;
 	}
+	ptcon = tlink_tcon(cifs_sb_tlink(cifs_sb));
+	if ((ptcon->ses) && (ptcon->ses->server->ops->query_mf_symlink))
+		rc = ptcon->ses->server->ops->query_mf_symlink(path, buf,
+						 &bytes_read, cifs_sb, xid);
+	else
+		goto out;
+	if (rc != 0)
+		goto out;
+	if (bytes_read == 0) /* not a symlink */
+		goto out;
 	rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);
-	kfree(buf);
 	if (rc == -EINVAL) {
 		/* it's not a symlink */
 		rc = 0;
 	fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
 	fattr->cf_dtype = DT_LNK;
 out:
-	cifs_put_tlink(tlink);
+	kfree(buf);
 	return rc;
 }

fs/cifs/readdir.c+8−0

@@ -111,6 +111,14 @@ cifs_prime_dcache(struct dentry parent, struct qstr name, · 110 unmodified lines
111	return;	111	return;
112	}	112	}
113		113
		114	/*
		115	* If we know that the inode will need to be revalidated immediately,
		116	* then don't create a new dentry for it. We'll end up doing an on
		117	* the wire call either way and this spares us an invalidation.
		118	*/
		119	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
		120	return;
		121
114	dentry = d_alloc(parent, name);	122	dentry = d_alloc(parent, name);
115	if (!dentry)	123	if (!dentry)
116	return;	124	return;

fs/cifs/sess.c+3−3

@@ -197,7 +197,7 @@ static void unicode_domain_string(char *pbcc_area, struct cifs_ses ses, · 196 unmodified lines
197	bytes_ret = 0;	197	bytes_ret = 0;
198	} else	198	} else
199	bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,	199	bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,
200	256, nls_cp);	200	CIFS_MAX_DOMAINNAME_LEN, nls_cp);
201	bcc_ptr += 2 * bytes_ret;	201	bcc_ptr += 2 * bytes_ret;
202	bcc_ptr += 2; /* account for null terminator */	202	bcc_ptr += 2; /* account for null terminator */
203		203
@@ -255,8 +255,8 @@ static void ascii_ssetup_strings(char *pbcc_area, struct cifs_ses ses, · 51 unmodified lines
255		255
256	/* copy domain */	256	/* copy domain */
257	if (ses->domainName != NULL) {	257	if (ses->domainName != NULL) {
258	strncpy(bcc_ptr, ses->domainName, 256);	258	strncpy(bcc_ptr, ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
259	bcc_ptr += strnlen(ses->domainName, 256);	259	bcc_ptr += strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
260	} /* else we will send a null domain name	260	} /* else we will send a null domain name
261	so the server will default to its own domain */	261	so the server will default to its own domain */
262	*bcc_ptr = 0;	262	*bcc_ptr = 0;

fs/cifs/smb1ops.c+1−0

@@ -944,6 +944,7 @@ struct smb_version_operations smb1_operations = { · 943 unmodified lines
944	.mand_lock = cifs_mand_lock,	944	.mand_lock = cifs_mand_lock,
945	.mand_unlock_range = cifs_unlock_range,	945	.mand_unlock_range = cifs_unlock_range,
946	.push_mand_locks = cifs_push_mandatory_locks,	946	.push_mand_locks = cifs_push_mandatory_locks,
		947	.query_mf_symlink = open_query_close_cifs_symlink,
947	};	948	};
948		949
949	struct smb_version_values smb1_values = {	950	struct smb_version_values smb1_values = {

fs/cifs/smb2transport.c+7−2

 static int
 smb2_crypto_shash_allocate(struct TCP_Server_Info *server)
 {
+	int rc;
 	unsigned int size;
 	if (server->secmech.sdeschmacsha256 != NULL)
 	server->secmech.hmacsha256 = crypto_alloc_shash("hmac(sha256)", 0, 0);
 	if (IS_ERR(server->secmech.hmacsha256)) {
 		cifs_dbg(VFS, "could not allocate crypto hmacsha256\n");
-		return PTR_ERR(server->secmech.hmacsha256);
+		rc = PTR_ERR(server->secmech.hmacsha256);
+		server->secmech.hmacsha256 = NULL;
+		return rc;
 	}
 	size = sizeof(struct shash_desc) +
 		server->secmech.sdeschmacsha256 = NULL;
 		crypto_free_shash(server->secmech.hmacsha256);
 		server->secmech.hmacsha256 = NULL;
-		return PTR_ERR(server->secmech.cmacaes);
+		rc = PTR_ERR(server->secmech.cmacaes);
+		server->secmech.cmacaes = NULL;
+		return rc;
 	}
 	size = sizeof(struct shash_desc) +

fs/dcache.c+34−34

  */
 static void d_free(struct dentry *dentry)
 {
-	BUG_ON(dentry->d_count);
+	BUG_ON(dentry->d_lockref.count);
 	this_cpu_dec(nr_dentry);
 	if (dentry->d_op && dentry->d_op->d_release)
 		dentry->d_op->d_release(dentry);
 	}
 	if (ref)
-		dentry->d_count--;
+		dentry->d_lockref.count--;
 	/*
 	 * inform the fs via d_prune that this dentry is about to be
 	 * unhashed and destroyed.
 		return;
 repeat:
-	if (dentry->d_count == 1)
+	if (dentry->d_lockref.count == 1)
 		might_sleep();
-	spin_lock(&dentry->d_lock);
+	if (lockref_put_or_lock(&dentry->d_lockref))
-	BUG_ON(!dentry->d_count);
-	if (dentry->d_count > 1) {
-		dentry->d_count--;
-		spin_unlock(&dentry->d_lock);
 		return;
-	}
 	if (dentry->d_flags & DCACHE_OP_DELETE) {
 		if (dentry->d_op->d_delete(dentry))
 	dentry->d_flags |= DCACHE_REFERENCED;
 	dentry_lru_add(dentry);
-	dentry->d_count--;
+	dentry->d_lockref.count--;
 	spin_unlock(&dentry->d_lock);
 	return;
 	 * We also need to leave mountpoints alone,
 	 * directory or not.
 	 */
-	if (dentry->d_count > 1 && dentry->d_inode) {
+	if (dentry->d_lockref.count > 1 && dentry->d_inode) {
 		if (S_ISDIR(dentry->d_inode->i_mode) || d_mountpoint(dentry)) {
 			spin_unlock(&dentry->d_lock);
 			return -EBUSY;
 /* This must be called with d_lock held */
 static inline void __dget_dlock(struct dentry *dentry)
 {
-	dentry->d_count++;
+	dentry->d_lockref.count++;
 }
 static inline void __dget(struct dentry *dentry)
 {
-	spin_lock(&dentry->d_lock);
+	lockref_get(&dentry->d_lockref);
-	__dget_dlock(dentry);
-	spin_unlock(&dentry->d_lock);
 }
 struct dentry *dget_parent(struct dentry *dentry)
 		goto repeat;
 	}
 	rcu_read_unlock();
-	BUG_ON(!ret->d_count);
+	BUG_ON(!ret->d_lockref.count);
-	ret->d_count++;
+	ret->d_lockref.count++;
 	spin_unlock(&ret->d_lock);
 	return ret;
 }
 	spin_lock(&inode->i_lock);
 	hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
 		spin_lock(&dentry->d_lock);
-		if (!dentry->d_count) {
+		if (!dentry->d_lockref.count) {
 			__dget_dlock(dentry);
 			__d_drop(dentry);
 			spin_unlock(&dentry->d_lock);
 	/* Prune ancestors. */
 	dentry = parent;
 	while (dentry) {
-		spin_lock(&dentry->d_lock);
+		if (lockref_put_or_lock(&dentry->d_lockref))
-		if (dentry->d_count > 1) {
-			dentry->d_count--;
-			spin_unlock(&dentry->d_lock);
 			return;
-		}
 		dentry = dentry_kill(dentry, 1);
 	}
 }
 		 * the LRU because of laziness during lookup.  Do not free
 		 * it - just keep it off the LRU list.
 		 */
-		if (dentry->d_count) {
+		if (dentry->d_lockref.count) {
 			dentry_lru_del(dentry);
 			spin_unlock(&dentry->d_lock);
 			continue;
 			dentry_lru_del(dentry);
 			__d_shrink(dentry);
-			if (dentry->d_count != 0) {
+			if (dentry->d_lockref.count != 0) {
 				printk(KERN_ERR
 				       "BUG: Dentry %p{i=%lx,n=%s}"
 				       " still in use (%d)"
 				       dentry->d_inode ?
 				       dentry->d_inode->i_ino : 0UL,
 				       dentry->d_name.name,
-				       dentry->d_count,
+				       dentry->d_lockref.count,
 				       dentry->d_sb->s_type->name,
 				       dentry->d_sb->s_id);
 				BUG();
 				list_del(&dentry->d_u.d_child);
 			} else {
 				parent = dentry->d_parent;
-				parent->d_count--;
+				parent->d_lockref.count--;
 				list_del(&dentry->d_u.d_child);
 			}
 	dentry = sb->s_root;
 	sb->s_root = NULL;
-	dentry->d_count--;
+	dentry->d_lockref.count--;
 	shrink_dcache_for_umount_subtree(dentry);
 	while (!hlist_bl_empty(&sb->s_anon)) {
 		 * loop in shrink_dcache_parent() might not make any progress
 		 * and loop forever.
 		 */
-		if (dentry->d_count) {
+		if (dentry->d_lockref.count) {
 			dentry_lru_del(dentry);
 		} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
 			dentry_lru_move_list(dentry, dispose);
 	smp_wmb();
 	dentry->d_name.name = dname;
-	dentry->d_count = 1;
+	dentry->d_lockref.count = 1;
 	dentry->d_flags = 0;
 	spin_lock_init(&dentry->d_lock);
 	seqcount_init(&dentry->d_seq);
 				goto next;
 		}
-		dentry->d_count++;
+		dentry->d_lockref.count++;
 		found = dentry;
 		spin_unlock(&dentry->d_lock);
 		break;
 	spin_lock(&dentry->d_lock);
 	inode = dentry->d_inode;
 	isdir = S_ISDIR(inode->i_mode);
-	if (dentry->d_count == 1) {
+	if (dentry->d_lockref.count == 1) {
 		if (!spin_trylock(&inode->i_lock)) {
 			spin_unlock(&dentry->d_lock);
 			cpu_relax();
 	return memcpy(buffer, temp, sz);
 }
+char *simple_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+	char *end = buffer + buflen;
+	/* these dentries are never renamed, so d_lock is not needed */
+	if (prepend(&end, &buflen, " (deleted)", 11) ||
+	    prepend_name(&end, &buflen, &dentry->d_name) ||
+	    prepend(&end, &buflen, "/", 1))
+		end = ERR_PTR(-ENAMETOOLONG);
+	return end;
+}
 /*
  * Write full pathname from the root of the filesystem into the buffer.
  */
 		}
 		if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
 			dentry->d_flags |= DCACHE_GENOCIDE;
-			dentry->d_count--;
+			dentry->d_lockref.count--;
 		}
 		spin_unlock(&dentry->d_lock);
 	}
 		struct dentry *child = this_parent;
 		if (!(this_parent->d_flags & DCACHE_GENOCIDE)) {
 			this_parent->d_flags |= DCACHE_GENOCIDE;
-			this_parent->d_count--;
+			this_parent->d_lockref.count--;
 		}
 		this_parent = try_to_ascend(this_parent, locked, seq);
 		if (!this_parent)

fs/efs/inode.c+1−1

@@ -57,7 +57,7 @@ struct inode efs_iget(struct super_block super, unsigned long ino) · 56 unmodified lines
57	struct inode *inode;	57	struct inode *inode;
58		58
59	inode = iget_locked(super, ino);	59	inode = iget_locked(super, ino);
60	if (IS_ERR(inode))	60	if (!inode)
61	return ERR_PTR(-ENOMEM);	61	return ERR_PTR(-ENOMEM);
62	if (!(inode->i_state & I_NEW))	62	if (!(inode->i_state & I_NEW))
63	return inode;	63	return inode;

fs/exec.c+2−2

@@ -608,7 +608,7 @@ static int shift_arg_pages(struct vm_area_struct *vma, unsigned long shift) · 607 unmodified lines
608	return -ENOMEM;	608	return -ENOMEM;
609		609
610	lru_add_drain();	610	lru_add_drain();
611	tlb_gather_mmu(&tlb, mm, 0);	611	tlb_gather_mmu(&tlb, mm, old_start, old_end);
612	if (new_end > old_start) {	612	if (new_end > old_start) {
613	/*	613	/*
614	* when the old and new regions overlap clear from new_end.	614	* when the old and new regions overlap clear from new_end.
@@ -625,7 +625,7 @@ static int shift_arg_pages(struct vm_area_struct *vma, unsigned long shift) · 10 unmodified lines
625	free_pgd_range(&tlb, old_start, old_end, new_end,	625	free_pgd_range(&tlb, old_start, old_end, new_end,
626	vma->vm_next ? vma->vm_next->vm_start : USER_PGTABLES_CEILING);	626	vma->vm_next ? vma->vm_next->vm_start : USER_PGTABLES_CEILING);
627	}	627	}
628	tlb_finish_mmu(&tlb, new_end, old_end);	628	tlb_finish_mmu(&tlb, old_start, old_end);
629		629
630	/*	630	/*
631	* Shrink the vma to just the new range. Always succeeds.	631	* Shrink the vma to just the new range. Always succeeds.

fs/ext4/ext4.h+1−0

@@ -2086,6 +2086,7 @@ extern int ext4_sync_inode(handle_t , struct inode ); · 2085 unmodified lines
2086	extern void ext4_dirty_inode(struct inode *, int);	2086	extern void ext4_dirty_inode(struct inode *, int);
2087	extern int ext4_change_inode_journal_flag(struct inode *, int);	2087	extern int ext4_change_inode_journal_flag(struct inode *, int);
2088	extern int ext4_get_inode_loc(struct inode , struct ext4_iloc );	2088	extern int ext4_get_inode_loc(struct inode , struct ext4_iloc );
		2089	extern int ext4_inode_attach_jinode(struct inode *inode);
2089	extern int ext4_can_truncate(struct inode *inode);	2090	extern int ext4_can_truncate(struct inode *inode);
2090	extern void ext4_truncate(struct inode *);	2091	extern void ext4_truncate(struct inode *);
2091	extern int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length);	2092	extern int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length);

fs/ext4/ext4_jbd2.c+4−4

@@ -255,10 +255,10 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line, · 254 unmodified lines
255	set_buffer_prio(bh);	255	set_buffer_prio(bh);
256	if (ext4_handle_valid(handle)) {	256	if (ext4_handle_valid(handle)) {
257	err = jbd2_journal_dirty_metadata(handle, bh);	257	err = jbd2_journal_dirty_metadata(handle, bh);
258	if (err) {	258	/* Errors can only happen if there is a bug */
259	/* Errors can only happen if there is a bug */	259	if (WARN_ON_ONCE(err)) {
260	handle->h_err = err;	260	ext4_journal_abort_handle(where, line, __func__, bh,
261	__ext4_journal_stop(where, line, handle);	261	handle, err);
262	}	262	}
263	} else {	263	} else {
264	if (inode)	264	if (inode)

fs/ext4/file.c+4−17

@@ -219,7 +219,6 @@ static int ext4_file_open(struct inode * inode, struct file * filp) · 218 unmodified lines
219	{	219	{
220	struct super_block *sb = inode->i_sb;	220	struct super_block *sb = inode->i_sb;
221	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);	221	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
222	struct ext4_inode_info *ei = EXT4_I(inode);
223	struct vfsmount *mnt = filp->f_path.mnt;	222	struct vfsmount *mnt = filp->f_path.mnt;
224	struct path path;	223	struct path path;
225	char buf[64], *cp;	224	char buf[64], *cp;
@@ -259,22 +258,10 @@ static int ext4_file_open(struct inode * inode, struct file * filp) · 33 unmodified lines
259	* Set up the jbd2_inode if we are opening the inode for	258	* Set up the jbd2_inode if we are opening the inode for
260	* writing and the journal is present	259	* writing and the journal is present
261	*/	260	*/
262	if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {	261	if (filp->f_mode & FMODE_WRITE) {
263	struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);	262	int ret = ext4_inode_attach_jinode(inode);
264		263	if (ret < 0)
265	spin_lock(&inode->i_lock);	264	return ret;
266	if (!ei->jinode) {
267	if (!jinode) {
268	spin_unlock(&inode->i_lock);
269	return -ENOMEM;
270	}
271	ei->jinode = jinode;
272	jbd2_journal_init_jbd_inode(ei->jinode, inode);
273	jinode = NULL;
274	}
275	spin_unlock(&inode->i_lock);
276	if (unlikely(jinode != NULL))
277	jbd2_free_inode(jinode);
278	}	265	}
279	return dquot_file_open(inode, filp);	266	return dquot_file_open(inode, filp);
280	}	267	}

fs/ext4/inode.c+43−0

@@ -3533,6 +3533,18 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) · 3532 unmodified lines
3533	offset;	3533	offset;
3534	}	3534	}
3535		3535
		3536	if (offset & (sb->s_blocksize - 1) \|\|
		3537	(offset + length) & (sb->s_blocksize - 1)) {
		3538	/*
		3539	* Attach jinode to inode for jbd2 if we do any zeroing of
		3540	* partial block
		3541	*/
		3542	ret = ext4_inode_attach_jinode(inode);
		3543	if (ret < 0)
		3544	goto out_mutex;
		3545
		3546	}
		3547
3536	first_block_offset = round_up(offset, sb->s_blocksize);	3548	first_block_offset = round_up(offset, sb->s_blocksize);
3537	last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;	3549	last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;
3538		3550
@@ -3601,6 +3613,31 @@ out_mutex: · 62 unmodified lines
3601	return ret;	3613	return ret;
3602	}	3614	}
3603		3615
		3616	int ext4_inode_attach_jinode(struct inode *inode)
		3617	{
		3618	struct ext4_inode_info *ei = EXT4_I(inode);
		3619	struct jbd2_inode *jinode;
		3620
		3621	if (ei->jinode \|\| !EXT4_SB(inode->i_sb)->s_journal)
		3622	return 0;
		3623
		3624	jinode = jbd2_alloc_inode(GFP_KERNEL);
		3625	spin_lock(&inode->i_lock);
		3626	if (!ei->jinode) {
		3627	if (!jinode) {
		3628	spin_unlock(&inode->i_lock);
		3629	return -ENOMEM;
		3630	}
		3631	ei->jinode = jinode;
		3632	jbd2_journal_init_jbd_inode(ei->jinode, inode);
		3633	jinode = NULL;
		3634	}
		3635	spin_unlock(&inode->i_lock);
		3636	if (unlikely(jinode != NULL))
		3637	jbd2_free_inode(jinode);
		3638	return 0;
		3639	}
		3640
3604	/*	3641	/*
3605	* ext4_truncate()	3642	* ext4_truncate()
3606	*	3643	*
@@ -3661,6 +3698,12 @@ void ext4_truncate(struct inode *inode) · 54 unmodified lines
3661	return;	3698	return;
3662	}	3699	}
3663		3700
		3701	/* If we zero-out tail of the page, we have to create jinode for jbd2 */
		3702	if (inode->i_size & (inode->i_sb->s_blocksize - 1)) {
		3703	if (ext4_inode_attach_jinode(inode) < 0)
		3704	return;
		3705	}
		3706
3664	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))	3707	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3665	credits = ext4_writepage_trans_blocks(inode);	3708	credits = ext4_writepage_trans_blocks(inode);
3666	else	3709	else

fs/ext4/ioctl.c+4−2

 	memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
 	memswap(&ei1->i_flags, &ei2->i_flags, sizeof(ei1->i_flags));
 	memswap(&ei1->i_disksize, &ei2->i_disksize, sizeof(ei1->i_disksize));
-	memswap(&ei1->i_es_tree, &ei2->i_es_tree, sizeof(ei1->i_es_tree));
+	ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS);
-	memswap(&ei1->i_es_lru_nr, &ei2->i_es_lru_nr, sizeof(ei1->i_es_lru_nr));
+	ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS);
+	ext4_es_lru_del(inode1);
+	ext4_es_lru_del(inode2);
 	isize = i_size_read(inode1);
 	i_size_write(inode1, i_size_read(inode2));

fs/ext4/super.c+17−2

 	{Opt_delalloc, EXT4_MOUNT_DELALLOC,
 	 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
 	{Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
-	 MOPT_EXT4_ONLY | MOPT_CLEAR | MOPT_EXPLICIT},
+	 MOPT_EXT4_ONLY | MOPT_CLEAR},
 	{Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
 	 MOPT_EXT4_ONLY | MOPT_SET},
 	{Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
 		}
 		if (test_opt(sb, DIOREAD_NOLOCK)) {
 			ext4_msg(sb, KERN_ERR, "can't mount with "
-				 "both data=journal and delalloc");
+				 "both data=journal and dioread_nolock");
 			goto failed_mount;
 		}
 		if (test_opt(sb, DELALLOC))
 		goto restore_opts;
 	}
+	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
+		if (test_opt2(sb, EXPLICIT_DELALLOC)) {
+			ext4_msg(sb, KERN_ERR, "can't mount with "
+				 "both data=journal and delalloc");
+			err = -EINVAL;
+			goto restore_opts;
+		}
+		if (test_opt(sb, DIOREAD_NOLOCK)) {
+			ext4_msg(sb, KERN_ERR, "can't mount with "
+				 "both data=journal and dioread_nolock");
+			err = -EINVAL;
+			goto restore_opts;
+		}
+	}
 	if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
 		ext4_abort(sb, "Abort forced by user");

fs/gfs2/glock.c+4−4

@@ -1838,14 +1838,14 @@ int __init gfs2_glock_init(void) · 1837 unmodified lines
1838		1838
1839	glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM \|	1839	glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM \|
1840	WQ_HIGHPRI \| WQ_FREEZABLE, 0);	1840	WQ_HIGHPRI \| WQ_FREEZABLE, 0);
1841	if (IS_ERR(glock_workqueue))	1841	if (!glock_workqueue)
1842	return PTR_ERR(glock_workqueue);	1842	return -ENOMEM;
1843	gfs2_delete_workqueue = alloc_workqueue("delete_workqueue",	1843	gfs2_delete_workqueue = alloc_workqueue("delete_workqueue",
1844	WQ_MEM_RECLAIM \| WQ_FREEZABLE,	1844	WQ_MEM_RECLAIM \| WQ_FREEZABLE,
1845	0);	1845	0);
1846	if (IS_ERR(gfs2_delete_workqueue)) {	1846	if (!gfs2_delete_workqueue) {
1847	destroy_workqueue(glock_workqueue);	1847	destroy_workqueue(glock_workqueue);
1848	return PTR_ERR(gfs2_delete_workqueue);	1848	return -ENOMEM;
1849	}	1849	}
1850		1850
1851	register_shrinker(&glock_shrinker);	1851	register_shrinker(&glock_shrinker);

fs/gfs2/glops.c+13−5

  * None of the buffers should be dirty, locked, or pinned.
  */
-static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
+static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync,
+			     unsigned int nr_revokes)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	struct list_head *head = &gl->gl_ail_list;
 	gfs2_log_lock(sdp);
 	spin_lock(&sdp->sd_ail_lock);
-	list_for_each_entry_safe(bd, tmp, head, bd_ail_gl_list) {
+	list_for_each_entry_safe_reverse(bd, tmp, head, bd_ail_gl_list) {
+		if (nr_revokes == 0)
+			break;
 		bh = bd->bd_bh;
 		if (bh->b_state & b_state) {
 			if (fsync)
 			gfs2_ail_error(gl, bh);
 		}
 		gfs2_trans_add_revoke(sdp, bd);
+		nr_revokes--;
 	}
 	GLOCK_BUG_ON(gl, !fsync && atomic_read(&gl->gl_ail_count));
 	spin_unlock(&sdp->sd_ail_lock);
 	WARN_ON_ONCE(current->journal_info);
 	current->journal_info = &tr;
-	__gfs2_ail_flush(gl, 0);
+	__gfs2_ail_flush(gl, 0, tr.tr_revokes);
 	gfs2_trans_end(sdp);
 	gfs2_log_flush(sdp, NULL);
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	unsigned int revokes = atomic_read(&gl->gl_ail_count);
+	unsigned int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
 	int ret;
 	if (!revokes)
 		return;
-	ret = gfs2_trans_begin(sdp, 0, revokes);
+	while (revokes > max_revokes)
+		max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);
+	ret = gfs2_trans_begin(sdp, 0, max_revokes);
 	if (ret)
 		return;
-	__gfs2_ail_flush(gl, fsync);
+	__gfs2_ail_flush(gl, fsync, max_revokes);
 	gfs2_trans_end(sdp);
 	gfs2_log_flush(sdp, NULL);
 }

fs/gfs2/inode.c+5−1

 		}
 		gfs2_glock_dq_uninit(ghs);
 		if (IS_ERR(d))
-			return PTR_RET(d);
+			return PTR_ERR(d);
 		return error;
 	} else if (error != -ENOENT) {
 		goto fail_gunlock;
 	struct gfs2_holder gh;
 	int ret;
+	/* For selinux during lookup */
+	if (gfs2_glock_is_locked_by_me(ip->i_gl))
+		return generic_getxattr(dentry, name, data, size);
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 	ret = gfs2_glock_nq(&gh);
 	if (ret == 0) {

fs/gfs2/main.c+1−1

@@ -155,7 +155,7 @@ static int __init init_gfs2_fs(void) · 154 unmodified lines
155	goto fail_wq;	155	goto fail_wq;
156		156
157	gfs2_control_wq = alloc_workqueue("gfs2_control",	157	gfs2_control_wq = alloc_workqueue("gfs2_control",
158	WQ_NON_REENTRANT \| WQ_UNBOUND \| WQ_FREEZABLE, 0);	158	WQ_UNBOUND \| WQ_FREEZABLE, 0);
159	if (!gfs2_control_wq)	159	if (!gfs2_control_wq)
160	goto fail_recovery;	160	goto fail_recovery;
161		161

fs/hugetlbfs/inode.c+11−7

 	return inode;
 }
+/*
+ * Hugetlbfs is not reclaimable; therefore its i_mmap_mutex will never
+ * be taken from reclaim -- unlike regular filesystems. This needs an
+ * annotation because huge_pmd_share() does an allocation under
+ * i_mmap_mutex.
+ */
+struct lock_class_key hugetlbfs_i_mmap_mutex_key;
 static struct inode *hugetlbfs_get_inode(struct super_block *sb,
 					struct inode *dir,
 					umode_t mode, dev_t dev)
 		struct hugetlbfs_inode_info *info;
 		inode->i_ino = get_next_ino();
 		inode_init_owner(inode, dir, mode);
+		lockdep_set_class(&inode->i_mapping->i_mmap_mutex,
+				&hugetlbfs_i_mmap_mutex_key);
 		inode->i_mapping->a_ops = &hugetlbfs_aops;
 		inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 	return h - hstates;
 }
-static char *hugetlb_dname(struct dentry *dentry, char *buffer, int buflen)
-{
-	return dynamic_dname(dentry, buffer, buflen, "/%s (deleted)",
-				dentry->d_name.name);
-}
 static struct dentry_operations anon_ops = {
-	.d_dname = hugetlb_dname
+	.d_dname = simple_dname
 };
 /*

fs/jfs/jfs_dtree.c+23−8

 		dir_index = (u32) ctx->pos;
+		/*
+		 * NFSv4 reserves cookies 1 and 2 for . and .. so the value
+		 * we return to the vfs is one greater than the one we use
+		 * internally.
+		 */
+		if (dir_index)
+			dir_index--;
 		if (dir_index > 1) {
 			struct dir_table_slot dirtab_slot;
 			if (p->header.flag & BT_INTERNAL) {
 				jfs_err("jfs_readdir: bad index table");
 				DT_PUTPAGE(mp);
-				ctx->pos = -1;
+				ctx->pos = DIREND;
 				return 0;
 			}
 		} else {
 				/*
 				 * self "."
 				 */
-				ctx->pos = 0;
+				ctx->pos = 1;
 				if (!dir_emit(ctx, ".", 1, ip->i_ino, DT_DIR))
 					return 0;
 			}
 			/*
 			 * parent ".."
 			 */
-			ctx->pos = 1;
+			ctx->pos = 2;
 			if (!dir_emit(ctx, "..", 2, PARENT(ip), DT_DIR))
 				return 0;
 		/*
 		 * Legacy filesystem - OS/2 & Linux JFS < 0.3.6
 		 *
-		 * pn = index = 0:	First entry "."
+		 * pn = 0; index = 1:	First entry "."
-		 * pn = 0; index = 1:	Second entry ".."
+		 * pn = 0; index = 2:	Second entry ".."
 		 * pn > 0:		Real entries, pn=1 -> leftmost page
 		 * pn = index = -1:	No more entries
 		 */
 		dtpos = ctx->pos;
-		if (dtpos == 0) {
+		if (dtpos < 2) {
 			/* build "." entry */
+			ctx->pos = 1;
 			if (!dir_emit(ctx, ".", 1, ip->i_ino, DT_DIR))
 				return 0;
-			dtoffset->index = 1;
+			dtoffset->index = 2;
 			ctx->pos = dtpos;
 		}
 		if (dtoffset->pn == 0) {
-			if (dtoffset->index == 1) {
+			if (dtoffset->index == 2) {
 				/* build ".." entry */
 				if (!dir_emit(ctx, "..", 2, PARENT(ip), DT_DIR))
 					return 0;
 					}
 					jfs_dirent->position = unique_pos++;
 				}
+				/*
+				 * We add 1 to the index because we may
+				 * use a value of 2 internally, and NFSv4
+				 * doesn't like that.
+				 */
+				jfs_dirent->position++;
 			} else {
 				jfs_dirent->position = dtpos;
 				len = min(d_namleft, DTLHDRDATALEN_LEGACY);

fs/namei.c+10−6

 		 * a reference at this point.
 		 */
 		BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
-		BUG_ON(!parent->d_count);
+		BUG_ON(!parent->d_lockref.count);
-		parent->d_count++;
+		parent->d_lockref.count++;
 		spin_unlock(&dentry->d_lock);
 	}
 	spin_unlock(&parent->d_lock);
 {
 	shrink_dcache_parent(dentry);
 	spin_lock(&dentry->d_lock);
-	if (dentry->d_count == 1)
+	if (dentry->d_lockref.count == 1)
 		__d_drop(dentry);
 	spin_unlock(&dentry->d_lock);
 }
 	if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
 		return -EINVAL;
 	/*
-	 * Using empty names is equivalent to using AT_SYMLINK_FOLLOW
+	 * To use null names we require CAP_DAC_READ_SEARCH
-	 * on /proc/self/fd/<fd>.
+	 * This ensures that not everyone will be able to create
+	 * handlink using the passed filedescriptor.
 	 */
-	if (flags & AT_EMPTY_PATH)
+	if (flags & AT_EMPTY_PATH) {
+		if (!capable(CAP_DAC_READ_SEARCH))
+			return -ENOENT;
 		how = LOOKUP_EMPTY;
+	}
 	if (flags & AT_SYMLINK_FOLLOW)
 		how |= LOOKUP_FOLLOW;

fs/namespace.c+1−1

@@ -1429,7 +1429,7 @@ struct vfsmount collect_mounts(struct path path) · 1428 unmodified lines
1429	CL_COPY_ALL \| CL_PRIVATE);	1429	CL_COPY_ALL \| CL_PRIVATE);
1430	namespace_unlock();	1430	namespace_unlock();
1431	if (IS_ERR(tree))	1431	if (IS_ERR(tree))
1432	return NULL;	1432	return ERR_CAST(tree);
1433	return &tree->mnt;	1433	return &tree->mnt;
1434	}	1434	}
1435		1435

fs/nilfs2/segbuf.c+2−3

 	if (err == -EOPNOTSUPP) {
 		set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
-		bio_put(bio);
+		/* to be detected by nilfs_segbuf_submit_bio() */
-		/* to be detected by submit_seg_bio() */
 	}
 	if (!uptodate)
 	bio->bi_private = segbuf;
 	bio_get(bio);
 	submit_bio(mode, bio);
+	segbuf->sb_nbio++;
 	if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
 		bio_put(bio);
 		err = -EOPNOTSUPP;
 		goto failed;
 	}
-	segbuf->sb_nbio++;
 	bio_put(bio);
 	wi->bio = NULL;

fs/ocfs2/aops.c+1−1

@@ -1757,7 +1757,7 @@ try_again: · 1756 unmodified lines
1757	goto out;	1757	goto out;
1758	} else if (ret == 1) {	1758	} else if (ret == 1) {
1759	clusters_need = wc->w_clen;	1759	clusters_need = wc->w_clen;
1760	ret = ocfs2_refcount_cow(inode, filp, di_bh,	1760	ret = ocfs2_refcount_cow(inode, di_bh,
1761	wc->w_cpos, wc->w_clen, UINT_MAX);	1761	wc->w_cpos, wc->w_clen, UINT_MAX);
1762	if (ret) {	1762	if (ret) {
1763	mlog_errno(ret);	1763	mlog_errno(ret);

fs/ocfs2/dir.c+1−3

 {
 	int ret;
 	struct ocfs2_empty_dir_priv priv = {
-		.ctx.actor = ocfs2_empty_dir_filldir
+		.ctx.actor = ocfs2_empty_dir_filldir,
 	};
-	memset(&priv, 0, sizeof(priv));
 	if (ocfs2_dir_indexed(inode)) {
 		ret = ocfs2_empty_dir_dx(inode, &priv);
 		if (ret)

fs/ocfs2/file.c+3−3

@@ -370,7 +370,7 @@ static int ocfs2_cow_file_pos(struct inode *inode, · 369 unmodified lines
370	if (!(ext_flags & OCFS2_EXT_REFCOUNTED))	370	if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
371	goto out;	371	goto out;
372		372
373	return ocfs2_refcount_cow(inode, NULL, fe_bh, cpos, 1, cpos+1);	373	return ocfs2_refcount_cow(inode, fe_bh, cpos, 1, cpos+1);
374		374
375	out:	375	out:
376	return status;	376	return status;
@@ -899,7 +899,7 @@ static int ocfs2_zero_extend_get_range(struct inode *inode, · 522 unmodified lines
899	zero_clusters = last_cpos - zero_cpos;	899	zero_clusters = last_cpos - zero_cpos;
900		900
901	if (needs_cow) {	901	if (needs_cow) {
902	rc = ocfs2_refcount_cow(inode, NULL, di_bh, zero_cpos,	902	rc = ocfs2_refcount_cow(inode, di_bh, zero_cpos,
903	zero_clusters, UINT_MAX);	903	zero_clusters, UINT_MAX);
904	if (rc) {	904	if (rc) {
905	mlog_errno(rc);	905	mlog_errno(rc);
@@ -2078,7 +2078,7 @@ static int ocfs2_prepare_inode_for_refcount(struct inode *inode, · 1172 unmodified lines
2078		2078
2079	*meta_level = 1;	2079	*meta_level = 1;
2080		2080
2081	ret = ocfs2_refcount_cow(inode, file, di_bh, cpos, clusters, UINT_MAX);	2081	ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
2082	if (ret)	2082	if (ret)
2083	mlog_errno(ret);	2083	mlog_errno(ret);
2084	out:	2084	out:

fs/ocfs2/journal.h+1−1

@@ -537,7 +537,7 @@ static inline int ocfs2_calc_extend_credits(struct super_block *sb, · 536 unmodified lines
537	extent_blocks = 1 + 1 + le16_to_cpu(root_el->l_tree_depth);	537	extent_blocks = 1 + 1 + le16_to_cpu(root_el->l_tree_depth);
538		538
539	return bitmap_blocks + sysfile_bitmap_blocks + extent_blocks +	539	return bitmap_blocks + sysfile_bitmap_blocks + extent_blocks +
540	ocfs2_quota_trans_credits(sb) + bits_wanted;	540	ocfs2_quota_trans_credits(sb);
541	}	541	}
542		542
543	static inline int ocfs2_calc_symlink_credits(struct super_block *sb)	543	static inline int ocfs2_calc_symlink_credits(struct super_block *sb)

fs/ocfs2/move_extents.c+1−1

@@ -69,7 +69,7 @@ static int __ocfs2_move_extent(handle_t *handle, · 68 unmodified lines
69	u64 ino = ocfs2_metadata_cache_owner(context->et.et_ci);	69	u64 ino = ocfs2_metadata_cache_owner(context->et.et_ci);
70	u64 old_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cpos);	70	u64 old_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cpos);
71		71
72	ret = ocfs2_duplicate_clusters_by_page(handle, context->file, cpos,	72	ret = ocfs2_duplicate_clusters_by_page(handle, inode, cpos,
73	p_cpos, new_p_cpos, len);	73	p_cpos, new_p_cpos, len);
74	if (ret) {	74	if (ret) {
75	mlog_errno(ret);	75	mlog_errno(ret);

fs/ocfs2/refcounttree.c+8−45

 struct ocfs2_cow_context {
 	struct inode *inode;
-	struct file *file;
 	u32 cow_start;
 	u32 cow_len;
 	struct ocfs2_extent_tree data_et;
 			    u32 *num_clusters,
 			    unsigned int *extent_flags);
 	int (*cow_duplicate_clusters)(handle_t *handle,
-				      struct file *file,
+				      struct inode *inode,
 				      u32 cpos, u32 old_cluster,
 				      u32 new_cluster, u32 new_len);
 };
 }
 int ocfs2_duplicate_clusters_by_page(handle_t *handle,
-				     struct file *file,
+				     struct inode *inode,
 				     u32 cpos, u32 old_cluster,
 				     u32 new_cluster, u32 new_len)
 {
 	int ret = 0, partial;
-	struct inode *inode = file_inode(file);
+	struct super_block *sb = inode->i_sb;
-	struct ocfs2_caching_info *ci = INODE_CACHE(inode);
-	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
 	u64 new_block = ocfs2_clusters_to_blocks(sb, new_cluster);
 	struct page *page;
 	pgoff_t page_index;
 		if (PAGE_CACHE_SIZE <= OCFS2_SB(sb)->s_clustersize)
 			BUG_ON(PageDirty(page));
-		if (PageReadahead(page)) {
-			page_cache_async_readahead(mapping,
-						   &file->f_ra, file,
-						   page, page_index,
-						   readahead_pages);
-		}
 		if (!PageUptodate(page)) {
 			ret = block_read_full_page(page, ocfs2_get_block);
 			if (ret) {
 			}
 		}
-		ocfs2_map_and_dirty_page(inode, handle, from, to,
+		ocfs2_map_and_dirty_page(inode,
+					 handle, from, to,
 					 page, 0, &new_block);
 		mark_page_accessed(page);
 unlock:
 }
 int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
-				    struct file *file,
+				    struct inode *inode,
 				    u32 cpos, u32 old_cluster,
 				    u32 new_cluster, u32 new_len)
 {
 	int ret = 0;
-	struct inode *inode = file_inode(file);
 	struct super_block *sb = inode->i_sb;
 	struct ocfs2_caching_info *ci = INODE_CACHE(inode);
 	int i, blocks = ocfs2_clusters_to_blocks(sb, new_len);
 	/*If the old clusters is unwritten, no need to duplicate. */
 	if (!(ext_flags & OCFS2_EXT_UNWRITTEN)) {
-		ret = context->cow_duplicate_clusters(handle, context->file,
+		ret = context->cow_duplicate_clusters(handle, context->inode,
 						      cpos, old, new, len);
 		if (ret) {
 			mlog_errno(ret);
 	return ret;
 }
-static void ocfs2_readahead_for_cow(struct inode *inode,
-				    struct file *file,
-				    u32 start, u32 len)
-{
-	struct address_space *mapping;
-	pgoff_t index;
-	unsigned long num_pages;
-	int cs_bits = OCFS2_SB(inode->i_sb)->s_clustersize_bits;
-	if (!file)
-		return;
-	mapping = file->f_mapping;
-	num_pages = (len << cs_bits) >> PAGE_CACHE_SHIFT;
-	if (!num_pages)
-		num_pages = 1;
-	index = ((loff_t)start << cs_bits) >> PAGE_CACHE_SHIFT;
-	page_cache_sync_readahead(mapping, &file->f_ra, file,
-				  index, num_pages);
-}
 /*
  * Starting at cpos, try to CoW write_len clusters.  Don't CoW
  * past max_cpos.  This will stop when it runs into a hole or an
  * unrefcounted extent.
  */
 static int ocfs2_refcount_cow_hunk(struct inode *inode,
-				   struct file *file,
 				   struct buffer_head *di_bh,
 				   u32 cpos, u32 write_len, u32 max_cpos)
 {
 	BUG_ON(cow_len == 0);
-	ocfs2_readahead_for_cow(inode, file, cow_start, cow_len);
 	context = kzalloc(sizeof(struct ocfs2_cow_context), GFP_NOFS);
 	if (!context) {
 		ret = -ENOMEM;
 	context->ref_root_bh = ref_root_bh;
 	context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_page;
 	context->get_clusters = ocfs2_di_get_clusters;
-	context->file = file;
 	ocfs2_init_dinode_extent_tree(&context->data_et,
 				      INODE_CACHE(inode), di_bh);
  * clusters between cpos and cpos+write_len are safe to modify.
  */
 int ocfs2_refcount_cow(struct inode *inode,
-		       struct file *file,
 		       struct buffer_head *di_bh,
 		       u32 cpos, u32 write_len, u32 max_cpos)
 {
 			num_clusters = write_len;
 		if (ext_flags & OCFS2_EXT_REFCOUNTED) {
-			ret = ocfs2_refcount_cow_hunk(inode, file, di_bh, cpos,
+			ret = ocfs2_refcount_cow_hunk(inode, di_bh, cpos,
 						      num_clusters, max_cpos);
 			if (ret) {
 				mlog_errno(ret);

fs/ocfs2/refcounttree.h+3−3

@@ -53,7 +53,7 @@ int ocfs2_prepare_refcount_change_for_del(struct inode *inode, · 52 unmodified lines
53	int *credits,	53	int *credits,
54	int *ref_blocks);	54	int *ref_blocks);
55	int ocfs2_refcount_cow(struct inode *inode,	55	int ocfs2_refcount_cow(struct inode *inode,
56	struct file filep, struct buffer_head di_bh,	56	struct buffer_head *di_bh,
57	u32 cpos, u32 write_len, u32 max_cpos);	57	u32 cpos, u32 write_len, u32 max_cpos);
58		58
59	typedef int (ocfs2_post_refcount_func)(struct inode *inode,	59	typedef int (ocfs2_post_refcount_func)(struct inode *inode,
@@ -85,11 +85,11 @@ int ocfs2_refcount_cow_xattr(struct inode *inode, · 25 unmodified lines
85	u32 cpos, u32 write_len,	85	u32 cpos, u32 write_len,
86	struct ocfs2_post_refcount *post);	86	struct ocfs2_post_refcount *post);
87	int ocfs2_duplicate_clusters_by_page(handle_t *handle,	87	int ocfs2_duplicate_clusters_by_page(handle_t *handle,
88	struct file *file,	88	struct inode *inode,
89	u32 cpos, u32 old_cluster,	89	u32 cpos, u32 old_cluster,
90	u32 new_cluster, u32 new_len);	90	u32 new_cluster, u32 new_len);
91	int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,	91	int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
92	struct file *file,	92	struct inode *inode,
93	u32 cpos, u32 old_cluster,	93	u32 cpos, u32 old_cluster,
94	u32 new_cluster, u32 new_len);	94	u32 new_cluster, u32 new_len);
95	int ocfs2_cow_sync_writeback(struct super_block *sb,	95	int ocfs2_cow_sync_writeback(struct super_block *sb,

fs/ocfs2/super.c+1−1

@@ -1022,7 +1022,7 @@ static int ocfs2_fill_super(struct super_block sb, void data, int silent) · 1021 unmodified lines
1022	struct inode *inode = NULL;	1022	struct inode *inode = NULL;
1023	struct ocfs2_super *osb = NULL;	1023	struct ocfs2_super *osb = NULL;
1024	struct buffer_head *bh = NULL;	1024	struct buffer_head *bh = NULL;
1025	char nodestr[8];	1025	char nodestr[12];
1026	struct ocfs2_blockcheck_stats stats;	1026	struct ocfs2_blockcheck_stats stats;
1027		1027
1028	trace_ocfs2_fill_super(sb, data, silent);	1028	trace_ocfs2_fill_super(sb, data, silent);

fs/proc/fd.c+0−2

@@ -228,8 +228,6 @@ static int proc_readfd_common(struct file file, struct dir_context ctx, · 227 unmodified lines
228	if (!p)	228	if (!p)
229	return -ENOENT;	229	return -ENOENT;
230		230
231	if (!dir_emit_dots(file, ctx))
232	goto out;
233	if (!dir_emit_dots(file, ctx))	231	if (!dir_emit_dots(file, ctx))
234	goto out;	232	goto out;
235	files = get_files_struct(p);	233	files = get_files_struct(p);

fs/proc/generic.c+1−1

@@ -271,7 +271,7 @@ int proc_readdir_de(struct proc_dir_entry de, struct file file, · 270 unmodified lines
271	de = next;	271	de = next;
272	} while (de);	272	} while (de);
273	spin_unlock(&proc_subdir_lock);	273	spin_unlock(&proc_subdir_lock);
274	return 0;	274	return 1;
275	}	275	}
276		276
277	int proc_readdir(struct file file, struct dir_context ctx)	277	int proc_readdir(struct file file, struct dir_context ctx)

fs/proc/root.c+3−1

 static int proc_root_readdir(struct file *file, struct dir_context *ctx)
 {
 	if (ctx->pos < FIRST_PROCESS_ENTRY) {
-		proc_readdir(file, ctx);
+		int error = proc_readdir(file, ctx);
+		if (unlikely(error <= 0))
+			return error;
 		ctx->pos = FIRST_PROCESS_ENTRY;
 	}

fs/proc/task_mmu.c+21−10

@@ -730,8 +730,16 @@ static inline void clear_soft_dirty(struct vm_area_struct *vma, · 729 unmodified lines
730	* of how soft-dirty works.	730	* of how soft-dirty works.
731	*/	731	*/
732	pte_t ptent = *pte;	732	pte_t ptent = *pte;
733	ptent = pte_wrprotect(ptent);	733
734	ptent = pte_clear_flags(ptent, _PAGE_SOFT_DIRTY);	734	if (pte_present(ptent)) {
		735	ptent = pte_wrprotect(ptent);
		736	ptent = pte_clear_flags(ptent, _PAGE_SOFT_DIRTY);
		737	} else if (is_swap_pte(ptent)) {
		738	ptent = pte_swp_clear_soft_dirty(ptent);
		739	} else if (pte_file(ptent)) {
		740	ptent = pte_file_clear_soft_dirty(ptent);
		741	}
		742
735	set_pte_at(vma->vm_mm, addr, pte, ptent);	743	set_pte_at(vma->vm_mm, addr, pte, ptent);
736	#endif	744	#endif
737	}	745	}
@@ -752,14 +760,15 @@ static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr, · 14 unmodified lines
752	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);	760	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
753	for (; addr != end; pte++, addr += PAGE_SIZE) {	761	for (; addr != end; pte++, addr += PAGE_SIZE) {
754	ptent = *pte;	762	ptent = *pte;
755	if (!pte_present(ptent))
756	continue;
757		763
758	if (cp->type == CLEAR_REFS_SOFT_DIRTY) {	764	if (cp->type == CLEAR_REFS_SOFT_DIRTY) {
759	clear_soft_dirty(vma, addr, pte);	765	clear_soft_dirty(vma, addr, pte);
760	continue;	766	continue;
761	}	767	}
762		768
		769	if (!pte_present(ptent))
		770	continue;
		771
763	page = vm_normal_page(vma, addr, ptent);	772	page = vm_normal_page(vma, addr, ptent);
764	if (!page)	773	if (!page)
765	continue;	774	continue;
@@ -859,7 +868,7 @@ typedef struct { · 93 unmodified lines
859	} pagemap_entry_t;	868	} pagemap_entry_t;
860		869
861	struct pagemapread {	870	struct pagemapread {
862	int pos, len;	871	int pos, len; /* units: PM_ENTRY_BYTES, not bytes */
863	pagemap_entry_t *buffer;	872	pagemap_entry_t *buffer;
864	bool v2;	873	bool v2;
865	};	874	};
@@ -867,7 +876,7 @@ struct pagemapread { · 1 unmodified line
867	#define PAGEMAP_WALK_SIZE (PMD_SIZE)	876	#define PAGEMAP_WALK_SIZE (PMD_SIZE)
868	#define PAGEMAP_WALK_MASK (PMD_MASK)	877	#define PAGEMAP_WALK_MASK (PMD_MASK)
869		878
870	#define PM_ENTRY_BYTES sizeof(u64)	879	#define PM_ENTRY_BYTES sizeof(pagemap_entry_t)
871	#define PM_STATUS_BITS 3	880	#define PM_STATUS_BITS 3
872	#define PM_STATUS_OFFSET (64 - PM_STATUS_BITS)	881	#define PM_STATUS_OFFSET (64 - PM_STATUS_BITS)
873	#define PM_STATUS_MASK (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)	882	#define PM_STATUS_MASK (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)
@@ -930,8 +939,10 @@ static void pte_to_pagemap_entry(pagemap_entry_t pme, struct pagemapread pm, · 56 unmodified lines
930	flags = PM_PRESENT;	939	flags = PM_PRESENT;
931	page = vm_normal_page(vma, addr, pte);	940	page = vm_normal_page(vma, addr, pte);
932	} else if (is_swap_pte(pte)) {	941	} else if (is_swap_pte(pte)) {
933	swp_entry_t entry = pte_to_swp_entry(pte);	942	swp_entry_t entry;
934		943	if (pte_swp_soft_dirty(pte))
		944	flags2 \|= __PM_SOFT_DIRTY;
		945	entry = pte_to_swp_entry(pte);
935	frame = swp_type(entry) \|	946	frame = swp_type(entry) \|
936	(swp_offset(entry) << MAX_SWAPFILES_SHIFT);	947	(swp_offset(entry) << MAX_SWAPFILES_SHIFT);
937	flags = PM_SWAP;	948	flags = PM_SWAP;
@@ -1116,8 +1127,8 @@ static ssize_t pagemap_read(struct file file, char __user buf, · 178 unmodified lines
1116	goto out_task;	1127	goto out_task;
1117		1128
1118	pm.v2 = soft_dirty_cleared;	1129	pm.v2 = soft_dirty_cleared;
1119	pm.len = PM_ENTRY_BYTES * (PAGEMAP_WALK_SIZE >> PAGE_SHIFT);	1130	pm.len = (PAGEMAP_WALK_SIZE >> PAGE_SHIFT);
1120	pm.buffer = kmalloc(pm.len, GFP_TEMPORARY);	1131	pm.buffer = kmalloc(pm.len * PM_ENTRY_BYTES, GFP_TEMPORARY);
1121	ret = -ENOMEM;	1132	ret = -ENOMEM;
1122	if (!pm.buffer)	1133	if (!pm.buffer)
1123	goto out_task;	1134	goto out_task;

include/asm-generic/pgtable.h+30−0

@@ -417,6 +417,36 @@ static inline pmd_t pmd_mksoft_dirty(pmd_t pmd) · 416 unmodified lines
417	{	417	{
418	return pmd;	418	return pmd;
419	}	419	}
		420
		421	static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
		422	{
		423	return pte;
		424	}
		425
		426	static inline int pte_swp_soft_dirty(pte_t pte)
		427	{
		428	return 0;
		429	}
		430
		431	static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
		432	{
		433	return pte;
		434	}
		435
		436	static inline pte_t pte_file_clear_soft_dirty(pte_t pte)
		437	{
		438	return pte;
		439	}
		440
		441	static inline pte_t pte_file_mksoft_dirty(pte_t pte)
		442	{
		443	return pte;
		444	}
		445
		446	static inline int pte_file_soft_dirty(pte_t pte)
		447	{
		448	return 0;
		449	}
420	#endif	450	#endif
421		451
422	#ifndef __HAVE_PFNMAP_TRACKING	452	#ifndef __HAVE_PFNMAP_TRACKING

include/asm-generic/tlb.h+1−1

@@ -112,7 +112,7 @@ struct mmu_gather { · 111 unmodified lines
112		112
113	#define HAVE_GENERIC_MMU_GATHER	113	#define HAVE_GENERIC_MMU_GATHER
114		114
115	void tlb_gather_mmu(struct mmu_gather tlb, struct mm_struct mm, bool fullmm);	115	void tlb_gather_mmu(struct mmu_gather tlb, struct mm_struct mm, unsigned long start, unsigned long end);
116	void tlb_flush_mmu(struct mmu_gather *tlb);	116	void tlb_flush_mmu(struct mmu_gather *tlb);
117	void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start,	117	void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start,
118	unsigned long end);	118	unsigned long end);

include/linux/dcache.h+10−10

 #include <linux/seqlock.h>
 #include <linux/cache.h>
 #include <linux/rcupdate.h>
+#include <linux/lockref.h>
 struct nameidata;
 struct path;
 # endif
 #endif
+#define d_lock	d_lockref.lock
 struct dentry {
 	/* RCU lookup touched fields */
 	unsigned int d_flags;		/* protected by d_lock */
 	unsigned char d_iname[DNAME_INLINE_LEN];	/* small names */
 	/* Ref lookup also touches following */
-	unsigned int d_count;		/* protected by d_lock */
+	struct lockref d_lockref;	/* per-dentry lock and refcount */
-	spinlock_t d_lock;		/* per dentry lock */
 	const struct dentry_operations *d_op;
 	struct super_block *d_sb;	/* The root of the dentry tree */
 	unsigned long d_time;		/* used by d_revalidate */
 	assert_spin_locked(&dentry->d_lock);
 	if (!read_seqcount_retry(&dentry->d_seq, seq)) {
 		ret = 1;
-		dentry->d_count++;
+		dentry->d_lockref.count++;
 	}
 	return ret;
 static inline unsigned d_count(const struct dentry *dentry)
 {
-	return dentry->d_count;
+	return dentry->d_lockref.count;
 }
 /* validate "insecure" dentry pointer */
  * helper function for dentry_operations.d_dname() members
  */
 extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
+extern char *simple_dname(struct dentry *, char *, int);
 extern char *__d_path(const struct path *, const struct path *, char *, int);
 extern char *d_absolute_path(const struct path *, char *, int);
 static inline struct dentry *dget_dlock(struct dentry *dentry)
 {
 	if (dentry)
-		dentry->d_count++;
+		dentry->d_lockref.count++;
 	return dentry;
 }
 static inline struct dentry *dget(struct dentry *dentry)
 {
-	if (dentry) {
+	if (dentry)
-		spin_lock(&dentry->d_lock);
+		lockref_get(&dentry->d_lockref);
-		dget_dlock(dentry);
-		spin_unlock(&dentry->d_lock);
-	}
 	return dentry;
 }

include/linux/inetdevice.h+1−33

@@ -5,45 +5,13 @@ · 4 unmodified lines
5		5
6	#include <linux/bitmap.h>	6	#include <linux/bitmap.h>
7	#include <linux/if.h>	7	#include <linux/if.h>
		8	#include <linux/ip.h>
8	#include <linux/netdevice.h>	9	#include <linux/netdevice.h>
9	#include <linux/rcupdate.h>	10	#include <linux/rcupdate.h>
10	#include <linux/timer.h>	11	#include <linux/timer.h>
11	#include <linux/sysctl.h>	12	#include <linux/sysctl.h>
12	#include <linux/rtnetlink.h>	13	#include <linux/rtnetlink.h>
13		14
14	enum
15	{
16	IPV4_DEVCONF_FORWARDING=1,
17	IPV4_DEVCONF_MC_FORWARDING,
18	IPV4_DEVCONF_PROXY_ARP,
19	IPV4_DEVCONF_ACCEPT_REDIRECTS,
20	IPV4_DEVCONF_SECURE_REDIRECTS,
21	IPV4_DEVCONF_SEND_REDIRECTS,
22	IPV4_DEVCONF_SHARED_MEDIA,
23	IPV4_DEVCONF_RP_FILTER,
24	IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE,
25	IPV4_DEVCONF_BOOTP_RELAY,
26	IPV4_DEVCONF_LOG_MARTIANS,
27	IPV4_DEVCONF_TAG,
28	IPV4_DEVCONF_ARPFILTER,
29	IPV4_DEVCONF_MEDIUM_ID,
30	IPV4_DEVCONF_NOXFRM,
31	IPV4_DEVCONF_NOPOLICY,
32	IPV4_DEVCONF_FORCE_IGMP_VERSION,
33	IPV4_DEVCONF_ARP_ANNOUNCE,
34	IPV4_DEVCONF_ARP_IGNORE,
35	IPV4_DEVCONF_PROMOTE_SECONDARIES,
36	IPV4_DEVCONF_ARP_ACCEPT,
37	IPV4_DEVCONF_ARP_NOTIFY,
38	IPV4_DEVCONF_ACCEPT_LOCAL,
39	IPV4_DEVCONF_SRC_VMARK,
40	IPV4_DEVCONF_PROXY_ARP_PVLAN,
41	IPV4_DEVCONF_ROUTE_LOCALNET,
42	__IPV4_DEVCONF_MAX
43	};
44
45	#define IPV4_DEVCONF_MAX (__IPV4_DEVCONF_MAX - 1)
46
47	struct ipv4_devconf {	15	struct ipv4_devconf {
48	void *sysctl;	16	void *sysctl;
49	int data[IPV4_DEVCONF_MAX];	17	int data[IPV4_DEVCONF_MAX];

include/linux/ipv6.h+1−0

@@ -101,6 +101,7 @@ struct inet6_skb_parm { · 100 unmodified lines
101	#define IP6SKB_FORWARDED 2	101	#define IP6SKB_FORWARDED 2
102	#define IP6SKB_REROUTED 4	102	#define IP6SKB_REROUTED 4
103	#define IP6SKB_ROUTERALERT 8	103	#define IP6SKB_ROUTERALERT 8
		104	#define IP6SKB_FRAGMENTED 16
104	};	105	};
105		106
106	#define IP6CB(skb) ((struct inet6_skb_parm*)((skb)->cb))	107	#define IP6CB(skb) ((struct inet6_skb_parm*)((skb)->cb))

include/linux/lockref.h+71−0

@@ -0,0 +1,71 @@
	1	#ifndef __LINUX_LOCKREF_H
	2	#define __LINUX_LOCKREF_H
	3
	4	/*
	5	* Locked reference counts.
	6	*
	7	* These are different from just plain atomic refcounts in that they
	8	* are atomic with respect to the spinlock that goes with them. In
	9	* particular, there can be implementations that don't actually get
	10	* the spinlock for the common decrement/increment operations, but they
	11	* still have to check that the operation is done semantically as if
	12	* the spinlock had been taken (using a cmpxchg operation that covers
	13	* both the lock and the count word, or using memory transactions, for
	14	* example).
	15	*/
	16
	17	#include <linux/spinlock.h>
	18
	19	struct lockref {
	20	spinlock_t lock;
	21	unsigned int count;
	22	};
	23
	24	/**
	25	* lockref_get - Increments reference count unconditionally
	26	* @lockcnt: pointer to lockref structure
	27	*
	28	* This operation is only valid if you already hold a reference
	29	* to the object, so you know the count cannot be zero.
	30	*/
	31	static inline void lockref_get(struct lockref *lockref)
	32	{
	33	spin_lock(&lockref->lock);
	34	lockref->count++;
	35	spin_unlock(&lockref->lock);
	36	}
	37
	38	/**
	39	* lockref_get_not_zero - Increments count unless the count is 0
	40	* @lockcnt: pointer to lockref structure
	41	* Return: 1 if count updated successfully or 0 if count is 0
	42	*/
	43	static inline int lockref_get_not_zero(struct lockref *lockref)
	44	{
	45	int retval = 0;
	46
	47	spin_lock(&lockref->lock);
	48	if (lockref->count) {
	49	lockref->count++;
	50	retval = 1;
	51	}
	52	spin_unlock(&lockref->lock);
	53	return retval;
	54	}
	55
	56	/**
	57	* lockref_put_or_lock - decrements count unless count <= 1 before decrement
	58	* @lockcnt: pointer to lockref structure
	59	* Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
	60	*/
	61	static inline int lockref_put_or_lock(struct lockref *lockref)
	62	{
	63	spin_lock(&lockref->lock);
	64	if (lockref->count <= 1)
	65	return 0;
	66	lockref->count--;
	67	spin_unlock(&lockref->lock);
	68	return 1;
	69	}
	70
	71	#endif /* __LINUX_LOCKREF_H */

include/linux/mlx5/device.h+10−12

 	__be16	max_desc_sz_rq;
 	u8	rsvd21[2];
 	__be16	max_desc_sz_sq_dc;
-	u8	rsvd22[4];
+	__be32	max_qp_mcg;
-	__be16	max_qp_mcg;
+	u8	rsvd22[3];
-	u8	rsvd23;
 	u8	log_max_mcg;
-	u8	rsvd24;
+	u8	rsvd23;
 	u8	log_max_pd;
-	u8	rsvd25;
+	u8	rsvd24;
 	u8	log_max_xrcd;
-	u8	rsvd26[42];
+	u8	rsvd25[42];
 	__be16  log_uar_page_sz;
-	u8	rsvd27[28];
+	u8	rsvd26[28];
 	u8	log_msx_atomic_size_qp;
-	u8	rsvd28[2];
+	u8	rsvd27[2];
 	u8	log_msx_atomic_size_dc;
-	u8	rsvd29[76];
+	u8	rsvd28[76];
 };
 struct mlx5_eqe_page_req {
 	u8		rsvd0[2];
 	__be16		func_id;
-	u8		rsvd1[2];
+	__be32		num_pages;
-	__be16		num_pages;
+	__be32		rsvd1[5];
-	__be32		rsvd2[5];
 };
 union ev_data {

include/linux/mlx5/driver.h+2−5

 	u32	reserved_lkey;
 	u8	local_ca_ack_delay;
 	u8	log_max_mcg;
-	u16	max_qp_mcg;
+	u32	max_qp_mcg;
 	int	min_page_sz;
 };
 int mlx5_pagealloc_start(struct mlx5_core_dev *dev);
 void mlx5_pagealloc_stop(struct mlx5_core_dev *dev);
 void mlx5_core_req_pages_handler(struct mlx5_core_dev *dev, u16 func_id,
-				 s16 npages);
+				 s32 npages);
 int mlx5_satisfy_startup_pages(struct mlx5_core_dev *dev, int boot);
 int mlx5_reclaim_startup_pages(struct mlx5_core_dev *dev);
 void mlx5_register_debugfs(void);
 int mlx5_db_alloc(struct mlx5_core_dev *dev, struct mlx5_db *db);
 void mlx5_db_free(struct mlx5_core_dev *dev, struct mlx5_db *db);
-typedef void (*health_handler_t)(struct pci_dev *pdev, struct health_buffer __iomem *buf, int size);
-int mlx5_register_health_report_handler(health_handler_t handler);
-void mlx5_unregister_health_report_handler(void);
 const char *mlx5_command_str(int command);
 int mlx5_cmdif_debugfs_init(struct mlx5_core_dev *dev);
 void mlx5_cmdif_debugfs_cleanup(struct mlx5_core_dev *dev);

include/linux/mm_types.h+1−0

@@ -332,6 +332,7 @@ struct mm_struct { · 331 unmodified lines
332	unsigned long pgoff, unsigned long flags);	332	unsigned long pgoff, unsigned long flags);
333	#endif	333	#endif
334	unsigned long mmap_base; /* base of mmap area */	334	unsigned long mmap_base; /* base of mmap area */
		335	unsigned long mmap_legacy_base; /* base of mmap area in bottom-up allocations */
335	unsigned long task_size; /* size of task vm space */	336	unsigned long task_size; /* size of task vm space */
336	unsigned long highest_vm_end; /* highest vma end address */	337	unsigned long highest_vm_end; /* highest vma end address */
337	pgd_t * pgd;	338	pgd_t * pgd;

include/linux/regmap.h+1−0

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <linux/list.h>	16	#include <linux/list.h>
17	#include <linux/rbtree.h>	17	#include <linux/rbtree.h>
18	#include <linux/err.h>	18	#include <linux/err.h>
		19	#include <linux/bug.h>
19		20
20	struct module;	21	struct module;
21	struct device;	22	struct device;

include/linux/sched.h+6−0

  * Test if a process is not yet dead (at most zombie state)
  * If pid_alive fails, then pointers within the task structure
  * can be stale and must not be dereferenced.
+ *
+ * Return: 1 if the process is alive. 0 otherwise.
  */
 static inline int pid_alive(struct task_struct *p)
 {
  * @tsk: Task structure to be checked.
  *
  * Check if a task structure is the first user space task the kernel created.
+ *
+ * Return: 1 if the task structure is init. 0 otherwise.
  */
 static inline int is_global_init(struct task_struct *tsk)
 {
 /**
  * is_idle_task - is the specified task an idle task?
  * @p: the task in question.
+ *
+ * Return: 1 if @p is an idle task. 0 otherwise.
  */
 static inline bool is_idle_task(const struct task_struct *p)
 {

include/linux/spinlock.h+11−3

 #endif /*arch_spin_is_contended*/
 #endif
-/* The lock does not imply full memory barrier. */
+/*
-#ifndef ARCH_HAS_SMP_MB_AFTER_LOCK
+ * Despite its name it doesn't necessarily has to be a full barrier.
-static inline void smp_mb__after_lock(void) { smp_mb(); }
+ * It should only guarantee that a STORE before the critical section
+ * can not be reordered with a LOAD inside this section.
+ * spin_lock() is the one-way barrier, this LOAD can not escape out
+ * of the region. So the default implementation simply ensures that
+ * a STORE can not move into the critical section, smp_wmb() should
+ * serialize it with another STORE done by spin_lock().
+ */
+#ifndef smp_mb__before_spinlock
+#define smp_mb__before_spinlock()	smp_wmb()
 #endif
 /**

include/linux/swapops.h+2−0

@@ -67,6 +67,8 @@ static inline swp_entry_t pte_to_swp_entry(pte_t pte) · 66 unmodified lines
67	swp_entry_t arch_entry;	67	swp_entry_t arch_entry;
68		68
69	BUG_ON(pte_file(pte));	69	BUG_ON(pte_file(pte));
		70	if (pte_swp_soft_dirty(pte))
		71	pte = pte_swp_clear_soft_dirty(pte);
70	arch_entry = __pte_to_swp_entry(pte);	72	arch_entry = __pte_to_swp_entry(pte);
71	return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));	73	return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
72	}	74	}

include/linux/syscalls.h+5−0

 asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, int,
 	       int __user *);
 #else
+#ifdef CONFIG_CLONE_BACKWARDS3
+asmlinkage long sys_clone(unsigned long, unsigned long, int, int __user *,
+			  int __user *, int);
+#else
 asmlinkage long sys_clone(unsigned long, unsigned long, int __user *,
 	       int __user *, int);
 #endif
+#endif
 asmlinkage long sys_execve(const char __user *filename,
 		const char __user *const __user *argv,

include/linux/wait.h+57−0

@@ -811,6 +811,63 @@ do { \ · 810 unmodified lines
811	__ret; \	811	__ret; \
812	})	812	})
813		813
		814	#define __wait_event_interruptible_lock_irq_timeout(wq, condition, \
		815	lock, ret) \
		816	do { \
		817	DEFINE_WAIT(__wait); \
		818	\
		819	for (;;) { \
		820	prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \
		821	if (condition) \
		822	break; \
		823	if (signal_pending(current)) { \
		824	ret = -ERESTARTSYS; \
		825	break; \
		826	} \
		827	spin_unlock_irq(&lock); \
		828	ret = schedule_timeout(ret); \
		829	spin_lock_irq(&lock); \
		830	if (!ret) \
		831	break; \
		832	} \
		833	finish_wait(&wq, &__wait); \
		834	} while (0)
		835
		836	/**
		837	* wait_event_interruptible_lock_irq_timeout - sleep until a condition gets true or a timeout elapses.
		838	* The condition is checked under the lock. This is expected
		839	* to be called with the lock taken.
		840	* @wq: the waitqueue to wait on
		841	* @condition: a C expression for the event to wait for
		842	* @lock: a locked spinlock_t, which will be released before schedule()
		843	* and reacquired afterwards.
		844	* @timeout: timeout, in jiffies
		845	*
		846	* The process is put to sleep (TASK_INTERRUPTIBLE) until the
		847	* @condition evaluates to true or signal is received. The @condition is
		848	* checked each time the waitqueue @wq is woken up.
		849	*
		850	* wake_up() has to be called after changing any variable that could
		851	* change the result of the wait condition.
		852	*
		853	* This is supposed to be called while holding the lock. The lock is
		854	* dropped before going to sleep and is reacquired afterwards.
		855	*
		856	* The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
		857	* was interrupted by a signal, and the remaining jiffies otherwise
		858	* if the condition evaluated to true before the timeout elapsed.
		859	*/
		860	#define wait_event_interruptible_lock_irq_timeout(wq, condition, lock, \
		861	timeout) \
		862	({ \
		863	int __ret = timeout; \
		864	\
		865	if (!(condition)) \
		866	__wait_event_interruptible_lock_irq_timeout( \
		867	wq, condition, lock, __ret); \
		868	__ret; \
		869	})
		870
814		871
815	/*	872	/*
816	* These are the old interfaces to sleep waiting for an event.	873	* These are the old interfaces to sleep waiting for an event.

include/net/busy_poll.h+1−6

 		if (rc > 0)
 			/* local bh are disabled so it is ok to use _BH */
 			NET_ADD_STATS_BH(sock_net(sk),
-					 LINUX_MIB_LOWLATENCYRXPACKETS, rc);
+					 LINUX_MIB_BUSYPOLLRXPACKETS, rc);
 	} while (!nonblock && skb_queue_empty(&sk->sk_receive_queue) &&
 		 !need_resched() && !busy_loop_timeout(end_time));
 	return false;
 }
-static inline bool sk_busy_poll(struct sock *sk, int nonblock)
-{
-	return false;
-}
 static inline void skb_mark_napi_id(struct sk_buff *skb,
 				    struct napi_struct *napi)
 {

include/net/ip6_route.h+2−0

@@ -135,6 +135,8 @@ extern void ip6_update_pmtu(struct sk_buff skb, struct net net, __be32 mtu, · 134 unmodified lines
135	extern void ip6_sk_update_pmtu(struct sk_buff skb, struct sock sk,	135	extern void ip6_sk_update_pmtu(struct sk_buff skb, struct sock sk,
136	__be32 mtu);	136	__be32 mtu);
137	extern void ip6_redirect(struct sk_buff skb, struct net net, int oif, u32 mark);	137	extern void ip6_redirect(struct sk_buff skb, struct net net, int oif, u32 mark);
		138	extern void ip6_redirect_no_header(struct sk_buff skb, struct net net, int oif,
		139	u32 mark);
138	extern void ip6_sk_redirect(struct sk_buff skb, struct sock sk);	140	extern void ip6_sk_redirect(struct sk_buff skb, struct sock sk);
139		141
140	struct netlink_callback;	142	struct netlink_callback;

include/net/ip_tunnels.h+0−14

@@ -145,20 +145,6 @@ static inline u8 ip_tunnel_ecn_encap(u8 tos, const struct iphdr *iph, · 144 unmodified lines
145	return INET_ECN_encapsulate(tos, inner);	145	return INET_ECN_encapsulate(tos, inner);
146	}	146	}
147		147
148	static inline void tunnel_ip_select_ident(struct sk_buff *skb,
149	const struct iphdr *old_iph,
150	struct dst_entry *dst)
151	{
152	struct iphdr *iph = ip_hdr(skb);
153
154	/* Use inner packet iph-id if possible. */
155	if (skb->protocol == htons(ETH_P_IP) && old_iph->id)
156	iph->id = old_iph->id;
157	else
158	__ip_select_ident(iph, dst,
159	(skb_shinfo(skb)->gso_segs ?: 1) - 1);
160	}
161
162	int iptunnel_pull_header(struct sk_buff *skb, int hdr_len, __be16 inner_proto);	148	int iptunnel_pull_header(struct sk_buff *skb, int hdr_len, __be16 inner_proto);
163	int iptunnel_xmit(struct net net, struct rtable rt,	149	int iptunnel_xmit(struct net net, struct rtable rt,
164	struct sk_buff *skb,	150	struct sk_buff *skb,

include/net/sch_generic.h+8−1

 	u64	rate_bytes_ps; /* bytes per second */
 	u32	mult;
 	u16	overhead;
+	u8	linklayer;
 	u8	shift;
 };
 static inline u64 psched_l2t_ns(const struct psched_ratecfg *r,
 				unsigned int len)
 {
-	return ((u64)(len + r->overhead) * r->mult) >> r->shift;
+	len += r->overhead;
+	if (unlikely(r->linklayer == TC_LINKLAYER_ATM))
+		return ((u64)(DIV_ROUND_UP(len,48)*53) * r->mult) >> r->shift;
+	return ((u64)len * r->mult) >> r->shift;
 }
 extern void psched_ratecfg_precompute(struct psched_ratecfg *r, const struct tc_ratespec *conf);
 	memset(res, 0, sizeof(*res));
 	res->rate = r->rate_bytes_ps;
 	res->overhead = r->overhead;
+	res->linklayer = (r->linklayer & TC_LINKLAYER_MASK);
 }
 #endif

include/uapi/linux/cm4000_cs.h+1−0

@@ -2,6 +2,7 @@ · 1 unmodified line
2	#define _UAPI_CM4000_H_	2	#define _UAPI_CM4000_H_
3		3
4	#include <linux/types.h>	4	#include <linux/types.h>
		5	#include <linux/ioctl.h>
5		6
6	#define MAX_ATR 33	7	#define MAX_ATR 33
7		8

include/uapi/linux/ip.h+34−0

@@ -133,4 +133,38 @@ struct ip_beet_phdr { · 132 unmodified lines
133	__u8 reserved;	133	__u8 reserved;
134	};	134	};
135		135
		136	/* index values for the variables in ipv4_devconf */
		137	enum
		138	{
		139	IPV4_DEVCONF_FORWARDING=1,
		140	IPV4_DEVCONF_MC_FORWARDING,
		141	IPV4_DEVCONF_PROXY_ARP,
		142	IPV4_DEVCONF_ACCEPT_REDIRECTS,
		143	IPV4_DEVCONF_SECURE_REDIRECTS,
		144	IPV4_DEVCONF_SEND_REDIRECTS,
		145	IPV4_DEVCONF_SHARED_MEDIA,
		146	IPV4_DEVCONF_RP_FILTER,
		147	IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE,
		148	IPV4_DEVCONF_BOOTP_RELAY,
		149	IPV4_DEVCONF_LOG_MARTIANS,
		150	IPV4_DEVCONF_TAG,
		151	IPV4_DEVCONF_ARPFILTER,
		152	IPV4_DEVCONF_MEDIUM_ID,
		153	IPV4_DEVCONF_NOXFRM,
		154	IPV4_DEVCONF_NOPOLICY,
		155	IPV4_DEVCONF_FORCE_IGMP_VERSION,
		156	IPV4_DEVCONF_ARP_ANNOUNCE,
		157	IPV4_DEVCONF_ARP_IGNORE,
		158	IPV4_DEVCONF_PROMOTE_SECONDARIES,
		159	IPV4_DEVCONF_ARP_ACCEPT,
		160	IPV4_DEVCONF_ARP_NOTIFY,
		161	IPV4_DEVCONF_ACCEPT_LOCAL,
		162	IPV4_DEVCONF_SRC_VMARK,
		163	IPV4_DEVCONF_PROXY_ARP_PVLAN,
		164	IPV4_DEVCONF_ROUTE_LOCALNET,
		165	__IPV4_DEVCONF_MAX
		166	};
		167
		168	#define IPV4_DEVCONF_MAX (__IPV4_DEVCONF_MAX - 1)
		169
136	#endif /* _UAPI_LINUX_IP_H */	170	#endif /* _UAPI_LINUX_IP_H */

include/uapi/linux/pkt_sched.h+9−1

 #define TC_H_ROOT	(0xFFFFFFFFU)
 #define TC_H_INGRESS    (0xFFFFFFF1U)
+/* Need to corrospond to iproute2 tc/tc_core.h "enum link_layer" */
+enum tc_link_layer {
+	TC_LINKLAYER_UNAWARE, /* Indicate unaware old iproute2 util */
+	TC_LINKLAYER_ETHERNET,
+	TC_LINKLAYER_ATM,
+};
+#define TC_LINKLAYER_MASK 0x0F /* limit use to lower 4 bits */
 struct tc_ratespec {
 	unsigned char	cell_log;
-	unsigned char	__reserved;
+	__u8		linklayer; /* lower 4 bits */
 	unsigned short	overhead;
 	short		cell_align;
 	unsigned short	mpu;

include/uapi/linux/snmp.h+1−1

@@ -253,7 +253,7 @@ enum · 252 unmodified lines
253	LINUX_MIB_TCPFASTOPENLISTENOVERFLOW, /* TCPFastOpenListenOverflow */	253	LINUX_MIB_TCPFASTOPENLISTENOVERFLOW, /* TCPFastOpenListenOverflow */
254	LINUX_MIB_TCPFASTOPENCOOKIEREQD, /* TCPFastOpenCookieReqd */	254	LINUX_MIB_TCPFASTOPENCOOKIEREQD, /* TCPFastOpenCookieReqd */
255	LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES, /* TCPSpuriousRtxHostQueues */	255	LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES, /* TCPSpuriousRtxHostQueues */
256	LINUX_MIB_LOWLATENCYRXPACKETS, /* LowLatencyRxPackets */	256	LINUX_MIB_BUSYPOLLRXPACKETS, /* BusyPollRxPackets */
257	__LINUX_MIB_MAX	257	__LINUX_MIB_MAX
258	};	258	};
259		259

init/Kconfig+1−1

@@ -955,7 +955,7 @@ config MEMCG_SWAP_ENABLED · 954 unmodified lines
955	Memory Resource Controller Swap Extension comes with its price in	955	Memory Resource Controller Swap Extension comes with its price in
956	a bigger memory consumption. General purpose distribution kernels	956	a bigger memory consumption. General purpose distribution kernels
957	which want to enable the feature but keep it disabled by default	957	which want to enable the feature but keep it disabled by default
958	and let the user enable it by swapaccount boot command line	958	and let the user enable it by swapaccount=1 boot command line
959	parameter should have this option unselected.	959	parameter should have this option unselected.
960	For those who want to have the feature enabled by default should	960	For those who want to have the feature enabled by default should
961	select this option (if, for some reason, they need to disable it	961	select this option (if, for some reason, they need to disable it

ipc/msg.c+3−2

 static struct msg_msg *find_msg(struct msg_queue *msq, long *msgtyp, int mode)
 {
-	struct msg_msg *msg;
+	struct msg_msg *msg, *found = NULL;
 	long count = 0;
 	list_for_each_entry(msg, &msq->q_messages, m_list) {
 					       *msgtyp, mode)) {
 			if (mode == SEARCH_LESSEQUAL && msg->m_type != 1) {
 				*msgtyp = msg->m_type - 1;
+				found = msg;
 			} else if (mode == SEARCH_NUMBER) {
 				if (*msgtyp == count)
 					return msg;
 		}
 	}
-	return ERR_PTR(-EAGAIN);
+	return found ?: ERR_PTR(-EAGAIN);
 }
 long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgflg,

kernel/cpuset.c+13−7

 	/*
 	 * Cpusets with tasks - existing or newly being attached - can't
-	 * have empty cpus_allowed or mems_allowed.
+	 * be changed to have empty cpus_allowed or mems_allowed.
 	 */
 	ret = -ENOSPC;
-	if ((cgroup_task_count(cur->css.cgroup) || cur->attach_in_progress) &&
+	if ((cgroup_task_count(cur->css.cgroup) || cur->attach_in_progress)) {
-	    (cpumask_empty(trial->cpus_allowed) &&
+		if (!cpumask_empty(cur->cpus_allowed) &&
-	     nodes_empty(trial->mems_allowed)))
+		    cpumask_empty(trial->cpus_allowed))
-		goto out;
+			goto out;
+		if (!nodes_empty(cur->mems_allowed) &&
+		    nodes_empty(trial->mems_allowed))
+			goto out;
+	}
 	ret = 0;
 out:
 {
 	struct cpuset *cs = cgroup_cs(cgrp);
 	cpuset_filetype_t type = cft->private;
-	int retval = -ENODEV;
+	int retval = 0;
 	mutex_lock(&cpuset_mutex);
-	if (!is_cpuset_online(cs))
+	if (!is_cpuset_online(cs)) {
+		retval = -ENODEV;
 		goto out_unlock;
+	}
 	switch (type) {
 	case FILE_CPU_EXCLUSIVE:

kernel/fork.c+6−0

 		 int __user *, parent_tidptr,
 		 int __user *, child_tidptr,
 		 int, tls_val)
+#elif defined(CONFIG_CLONE_BACKWARDS3)
+SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
+		int, stack_size,
+		int __user *, parent_tidptr,
+		int __user *, child_tidptr,
+		int, tls_val)
 #else
 SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
 		 int __user *, parent_tidptr,

kernel/mutex.c+2−2

@@ -686,7 +686,7 @@ __ww_mutex_lock(struct ww_mutex lock, struct ww_acquire_ctx ctx) · 685 unmodified lines
686	might_sleep();	686	might_sleep();
687	ret = __mutex_lock_common(&lock->base, TASK_UNINTERRUPTIBLE,	687	ret = __mutex_lock_common(&lock->base, TASK_UNINTERRUPTIBLE,
688	0, &ctx->dep_map, _RET_IP_, ctx);	688	0, &ctx->dep_map, _RET_IP_, ctx);
689	if (!ret && ctx->acquired > 0)	689	if (!ret && ctx->acquired > 1)
690	return ww_mutex_deadlock_injection(lock, ctx);	690	return ww_mutex_deadlock_injection(lock, ctx);
691		691
692	return ret;	692	return ret;
@@ -702,7 +702,7 @@ __ww_mutex_lock_interruptible(struct ww_mutex lock, struct ww_acquire_ctx ctx) · 9 unmodified lines
702	ret = __mutex_lock_common(&lock->base, TASK_INTERRUPTIBLE,	702	ret = __mutex_lock_common(&lock->base, TASK_INTERRUPTIBLE,
703	0, &ctx->dep_map, _RET_IP_, ctx);	703	0, &ctx->dep_map, _RET_IP_, ctx);
704		704
705	if (!ret && ctx->acquired > 0)	705	if (!ret && ctx->acquired > 1)
706	return ww_mutex_deadlock_injection(lock, ctx);	706	return ww_mutex_deadlock_injection(lock, ctx);
707		707
708	return ret;	708	return ret;

kernel/power/qos.c+13−7

@@ -296,6 +296,17 @@ int pm_qos_request_active(struct pm_qos_request *req) · 295 unmodified lines
296	}	296	}
297	EXPORT_SYMBOL_GPL(pm_qos_request_active);	297	EXPORT_SYMBOL_GPL(pm_qos_request_active);
298		298
		299	static void __pm_qos_update_request(struct pm_qos_request *req,
		300	s32 new_value)
		301	{
		302	trace_pm_qos_update_request(req->pm_qos_class, new_value);
		303
		304	if (new_value != req->node.prio)
		305	pm_qos_update_target(
		306	pm_qos_array[req->pm_qos_class]->constraints,
		307	&req->node, PM_QOS_UPDATE_REQ, new_value);
		308	}
		309
299	/**	310	/**
300	* pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout	311	* pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout
301	* @work: work struct for the delayed work (timeout)	312	* @work: work struct for the delayed work (timeout)
@@ -308,7 +319,7 @@ static void pm_qos_work_fn(struct work_struct *work) · 6 unmodified lines
308	struct pm_qos_request,	319	struct pm_qos_request,
309	work);	320	work);
310		321
311	pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE);	322	__pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE);
312	}	323	}
313		324
314	/**	325	/**
@@ -364,12 +375,7 @@ void pm_qos_update_request(struct pm_qos_request *req, · 49 unmodified lines
364	}	375	}
365		376
366	cancel_delayed_work_sync(&req->work);	377	cancel_delayed_work_sync(&req->work);
367		378	__pm_qos_update_request(req, new_value);
368	trace_pm_qos_update_request(req->pm_qos_class, new_value);
369	if (new_value != req->node.prio)
370	pm_qos_update_target(
371	pm_qos_array[req->pm_qos_class]->constraints,
372	&req->node, PM_QOS_UPDATE_REQ, new_value);
373	}	379	}
374	EXPORT_SYMBOL_GPL(pm_qos_update_request);	380	EXPORT_SYMBOL_GPL(pm_qos_update_request);
375		381

kernel/sched/core.c+74−22

 /**
  * task_curr - is this task currently executing on a CPU?
  * @p: the task in question.
+ *
+ * Return: 1 if the task is currently executing. 0 otherwise.
  */
 inline int task_curr(const struct task_struct *p)
 {
  * the simpler "current->state = TASK_RUNNING" to mark yourself
  * runnable without the overhead of this.
  *
- * Returns %true if @p was woken up, %false if it was already running
+ * Return: %true if @p was woken up, %false if it was already running.
  * or @state didn't match @p's state.
  */
 static int
 	unsigned long flags;
 	int cpu, success = 0;
-	smp_wmb();
+	/*
+	 * If we are going to wake up a thread waiting for CONDITION we
+	 * need to ensure that CONDITION=1 done by the caller can not be
+	 * reordered with p->state check below. This pairs with mb() in
+	 * set_current_state() the waiting thread does.
+	 */
+	smp_mb__before_spinlock();
 	raw_spin_lock_irqsave(&p->pi_lock, flags);
 	if (!(p->state & state))
 		goto out;
  * @p: The process to be woken up.
  *
  * Attempt to wake up the nominated process and move it to the set of runnable
- * processes.  Returns 1 if the process was woken up, 0 if it was already
+ * processes.
- * running.
+ *
+ * Return: 1 if the process was woken up, 0 if it was already running.
  *
  * It may be assumed that this function implies a write memory barrier before
  * changing the task state if and only if any tasks are woken up.
  * This makes sure that uptime, CFS vruntime, load
  * balancing, etc... continue to move forward, even
  * with a very low granularity.
+ *
+ * Return: Maximum deferment in nanoseconds.
  */
 u64 scheduler_tick_max_deferment(void)
 {
 	if (sched_feat(HRTICK))
 		hrtick_clear(rq);
+	/*
+	 * Make sure that signal_pending_state()->signal_pending() below
+	 * can't be reordered with __set_current_state(TASK_INTERRUPTIBLE)
+	 * done by the caller to avoid the race with signal_wake_up().
+	 */
+	smp_mb__before_spinlock();
 	raw_spin_lock_irq(&rq->lock);
 	switch_count = &prev->nivcsw;
  * specified timeout to expire. The timeout is in jiffies. It is not
  * interruptible.
  *
- * The return value is 0 if timed out, and positive (at least 1, or number of
+ * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
- * jiffies left till timeout) if completed.
+ * till timeout) if completed.
  */
 unsigned long __sched
 wait_for_completion_timeout(struct completion *x, unsigned long timeout)
  * specified timeout to expire. The timeout is in jiffies. It is not
  * interruptible. The caller is accounted as waiting for IO.
  *
- * The return value is 0 if timed out, and positive (at least 1, or number of
+ * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
- * jiffies left till timeout) if completed.
+ * till timeout) if completed.
  */
 unsigned long __sched
 wait_for_completion_io_timeout(struct completion *x, unsigned long timeout)
  * This waits for completion of a specific task to be signaled. It is
  * interruptible.
  *
- * The return value is -ERESTARTSYS if interrupted, 0 if completed.
+ * Return: -ERESTARTSYS if interrupted, 0 if completed.
  */
 int __sched wait_for_completion_interruptible(struct completion *x)
 {
  * This waits for either a completion of a specific task to be signaled or for a
  * specified timeout to expire. It is interruptible. The timeout is in jiffies.
  *
- * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
+ * Return: -ERESTARTSYS if interrupted, 0 if timed out, positive (at least 1,
- * positive (at least 1, or number of jiffies left till timeout) if completed.
+ * or number of jiffies left till timeout) if completed.
  */
 long __sched
 wait_for_completion_interruptible_timeout(struct completion *x,
  * This waits to be signaled for completion of a specific task. It can be
  * interrupted by a kill signal.
  *
- * The return value is -ERESTARTSYS if interrupted, 0 if completed.
+ * Return: -ERESTARTSYS if interrupted, 0 if completed.
  */
 int __sched wait_for_completion_killable(struct completion *x)
 {
  * signaled or for a specified timeout to expire. It can be
  * interrupted by a kill signal. The timeout is in jiffies.
  *
- * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
+ * Return: -ERESTARTSYS if interrupted, 0 if timed out, positive (at least 1,
- * positive (at least 1, or number of jiffies left till timeout) if completed.
+ * or number of jiffies left till timeout) if completed.
  */
 long __sched
 wait_for_completion_killable_timeout(struct completion *x,
  *	try_wait_for_completion - try to decrement a completion without blocking
  *	@x:	completion structure
  *
- *	Returns: 0 if a decrement cannot be done without blocking
+ *	Return: 0 if a decrement cannot be done without blocking
  *		 1 if a decrement succeeded.
  *
  *	If a completion is being used as a counting completion,
  *	completion_done - Test to see if a completion has any waiters
  *	@x:	completion structure
  *
- *	Returns: 0 if there are waiters (wait_for_completion() in progress)
+ *	Return: 0 if there are waiters (wait_for_completion() in progress)
  *		 1 if there are no waiters.
  *
  */
  * task_prio - return the priority value of a given task.
  * @p: the task in question.
  *
- * This is the priority value as seen by users in /proc.
+ * Return: The priority value as seen by users in /proc.
  * RT tasks are offset by -200. Normal tasks are centered
  * around 0, value goes from -16 to +15.
  */
 /**
  * task_nice - return the nice value of a given task.
  * @p: the task in question.
+ *
+ * Return: The nice value [ -20 ... 0 ... 19 ].
  */
 int task_nice(const struct task_struct *p)
 {
 /**
  * idle_cpu - is a given cpu idle currently?
  * @cpu: the processor in question.
+ *
+ * Return: 1 if the CPU is currently idle. 0 otherwise.
  */
 int idle_cpu(int cpu)
 {
 /**
  * idle_task - return the idle task for a given cpu.
  * @cpu: the processor in question.
+ *
+ * Return: The idle task for the cpu @cpu.
  */
 struct task_struct *idle_task(int cpu)
 {
 /**
  * find_process_by_pid - find a process with a matching PID value.
  * @pid: the pid in question.
+ *
+ * The task of @pid, if found. %NULL otherwise.
  */
 static struct task_struct *find_process_by_pid(pid_t pid)
 {
  * @policy: new policy.
  * @param: structure containing the new RT priority.
  *
+ * Return: 0 on success. An error code otherwise.
+ *
  * NOTE that the task may be already dead.
  */
 int sched_setscheduler(struct task_struct *p, int policy,
  * current context has permission.  For example, this is needed in
  * stop_machine(): we create temporary high priority worker threads,
  * but our caller might not have that capability.
+ *
+ * Return: 0 on success. An error code otherwise.
  */
 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
 			       const struct sched_param *param)
  * @pid: the pid in question.
  * @policy: new policy.
  * @param: structure containing the new RT priority.
+ *
+ * Return: 0 on success. An error code otherwise.
  */
 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
 		struct sched_param __user *, param)
  * sys_sched_setparam - set/change the RT priority of a thread
  * @pid: the pid in question.
  * @param: structure containing the new RT priority.
+ *
+ * Return: 0 on success. An error code otherwise.
  */
 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
 {
 /**
  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
  * @pid: the pid in question.
+ *
+ * Return: On success, the policy of the thread. Otherwise, a negative error
+ * code.
  */
 SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
 {
  * sys_sched_getparam - get the RT priority of a thread
  * @pid: the pid in question.
  * @param: structure containing the RT priority.
+ *
+ * Return: On success, 0 and the RT priority is in @param. Otherwise, an error
+ * code.
  */
 SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
 {
  * @pid: pid of the process
  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  * @user_mask_ptr: user-space pointer to the new cpu mask
+ *
+ * Return: 0 on success. An error code otherwise.
  */
 SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
 		unsigned long __user *, user_mask_ptr)
  * @pid: pid of the process
  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  * @user_mask_ptr: user-space pointer to hold the current cpu mask
+ *
+ * Return: 0 on success. An error code otherwise.
  */
 SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
 		unsigned long __user *, user_mask_ptr)
  *
  * This function yields the current CPU to other tasks. If there are no
  * other threads running on this CPU then this function will return.
+ *
+ * Return: 0.
  */
 SYSCALL_DEFINE0(sched_yield)
 {
  * It's the caller's job to ensure that the target task struct
  * can't go away on us before we can do any checks.
  *
- * Returns:
+ * Return:
  *	true (>0) if we indeed boosted the target task.
  *	false (0) if we failed to boost the target.
  *	-ESRCH if there's no task to yield to.
  * sys_sched_get_priority_max - return maximum RT priority.
  * @policy: scheduling class.
  *
- * this syscall returns the maximum rt_priority that can be used
+ * Return: On success, this syscall returns the maximum
- * by a given scheduling class.
+ * rt_priority that can be used by a given scheduling class.
+ * On failure, a negative error code is returned.
  */
 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
 {
  * sys_sched_get_priority_min - return minimum RT priority.
  * @policy: scheduling class.
  *
- * this syscall returns the minimum rt_priority that can be used
+ * Return: On success, this syscall returns the minimum
- * by a given scheduling class.
+ * rt_priority that can be used by a given scheduling class.
+ * On failure, a negative error code is returned.
  */
 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
 {
  *
  * this syscall writes the default timeslice value of a given process
  * into the user-space timespec buffer. A value of '0' means infinity.
+ *
+ * Return: On success, 0 and the timeslice is in @interval. Otherwise,
+ * an error code.
  */
 SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
 		struct timespec __user *, interval)
  * @cpu: the processor in question.
  *
  * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
+ *
+ * Return: The current task for @cpu.
  */
 struct task_struct *curr_task(int cpu)
 {

kernel/sched/cpupri.c+2−2

@@ -62,7 +62,7 @@ static int convert_prio(int prio) · 61 unmodified lines
62	* any discrepancies created by racing against the uncertainty of the current	62	* any discrepancies created by racing against the uncertainty of the current
63	* priority configuration.	63	* priority configuration.
64	*	64	*
65	* Returns: (int)bool - CPUs were found	65	* Return: (int)bool - CPUs were found
66	*/	66	*/
67	int cpupri_find(struct cpupri cp, struct task_struct p,	67	int cpupri_find(struct cpupri cp, struct task_struct p,
68	struct cpumask *lowest_mask)	68	struct cpumask *lowest_mask)
@@ -203,7 +203,7 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri) · 134 unmodified lines
203	* cpupri_init - initialize the cpupri structure	203	* cpupri_init - initialize the cpupri structure
204	* @cp: The cpupri context	204	* @cp: The cpupri context
205	*	205	*
206	* Returns: -ENOMEM if memory fails.	206	* Return: -ENOMEM on memory allocation failure.
207	*/	207	*/
208	int cpupri_init(struct cpupri *cp)	208	int cpupri_init(struct cpupri *cp)
209	{	209	{

kernel/sched/fair.c+8−2

 	 */
 	update_entity_load_avg(curr, 1);
 	update_cfs_rq_blocked_load(cfs_rq, 1);
+	update_cfs_shares(cfs_rq);
 #ifdef CONFIG_SCHED_HRTICK
 	/*
  * get_sd_load_idx - Obtain the load index for a given sched domain.
  * @sd: The sched_domain whose load_idx is to be obtained.
  * @idle: The Idle status of the CPU for whose sd load_icx is obtained.
+ *
+ * Return: The load index.
  */
 static inline int get_sd_load_idx(struct sched_domain *sd,
 					enum cpu_idle_type idle)
  *
  * Determine if @sg is a busier group than the previously selected
  * busiest group.
+ *
+ * Return: %true if @sg is a busier group than the previously selected
+ * busiest group. %false otherwise.
  */
 static bool update_sd_pick_busiest(struct lb_env *env,
 				   struct sd_lb_stats *sds,
  * assuming lower CPU number will be equivalent to lower a SMT thread
  * number.
  *
- * Returns 1 when packing is required and a task should be moved to
+ * Return: 1 when packing is required and a task should be moved to
  * this CPU.  The amount of the imbalance is returned in *imbalance.
  *
  * @env: The load balancing environment.
  * @balance: Pointer to a variable indicating if this_cpu
  *	is the appropriate cpu to perform load balancing at this_level.
  *
- * Returns:	- the busiest group if imbalance exists.
+ * Return:	- The busiest group if imbalance exists.
  *		- If no imbalance and user has opted for power-savings balance,
  *		   return the least loaded group whose CPUs can be
  *		   put to idle by rebalancing its tasks onto our group.

kernel/time/sched_clock.c+1−1

@@ -121,7 +121,7 @@ void __init setup_sched_clock(u32 (*read)(void), int bits, unsigned long rate) · 120 unmodified lines
121	BUG_ON(bits > 32);	121	BUG_ON(bits > 32);
122	WARN_ON(!irqs_disabled());	122	WARN_ON(!irqs_disabled());
123	read_sched_clock = read;	123	read_sched_clock = read;
124	sched_clock_mask = (1 << bits) - 1;	124	sched_clock_mask = (1ULL << bits) - 1;
125	cd.rate = rate;	125	cd.rate = rate;
126		126
127	/* calculate the mult/shift to convert counter ticks to ns. */	127	/* calculate the mult/shift to convert counter ticks to ns. */

kernel/time/tick-sched.c+2−3

 		 * Don't allow the user to think they can get
 		 * full NO_HZ with this machine.
 		 */
-		WARN_ONCE(1, "NO_HZ FULL will not work with unstable sched clock");
+		WARN_ONCE(have_nohz_full_mask,
+			  "NO_HZ FULL will not work with unstable sched clock");
 		return false;
 	}
 #endif
 void __init tick_nohz_init(void)
 {
-	int cpu;
 	if (!have_nohz_full_mask) {
 		if (tick_nohz_init_all() < 0)
 			return;

kernel/time/timer_list.c+24−17

@@ -265,10 +265,9 @@ static inline void timer_list_header(struct seq_file *m, u64 now) · 264 unmodified lines
265	static int timer_list_show(struct seq_file m, void v)	265	static int timer_list_show(struct seq_file m, void v)
266	{	266	{
267	struct timer_list_iter *iter = v;	267	struct timer_list_iter *iter = v;
268	u64 now = ktime_to_ns(ktime_get());
269		268
270	if (iter->cpu == -1 && !iter->second_pass)	269	if (iter->cpu == -1 && !iter->second_pass)
271	timer_list_header(m, now);	270	timer_list_header(m, iter->now);
272	else if (!iter->second_pass)	271	else if (!iter->second_pass)
273	print_cpu(m, iter->cpu, iter->now);	272	print_cpu(m, iter->cpu, iter->now);
274	#ifdef CONFIG_GENERIC_CLOCKEVENTS	273	#ifdef CONFIG_GENERIC_CLOCKEVENTS
@@ -298,33 +297,41 @@ void sysrq_timer_list_show(void) · 23 unmodified lines
298	return;	297	return;
299	}	298	}
300		299
301	static void timer_list_start(struct seq_file file, loff_t *offset)	300	static void move_iter(struct timer_list_iter iter, loff_t offset)
302	{	301	{
303	struct timer_list_iter *iter = file->private;	302	for (; offset; offset--) {
304		303	iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);
305	if (!*offset) {	304	if (iter->cpu >= nr_cpu_ids) {
306	iter->cpu = -1;
307	iter->now = ktime_to_ns(ktime_get());
308	} else if (iter->cpu >= nr_cpu_ids) {
309	#ifdef CONFIG_GENERIC_CLOCKEVENTS	305	#ifdef CONFIG_GENERIC_CLOCKEVENTS
310	if (!iter->second_pass) {	306	if (!iter->second_pass) {
311	iter->cpu = -1;	307	iter->cpu = -1;
312	iter->second_pass = true;	308	iter->second_pass = true;
313	} else	309	} else
314	return NULL;	310	return NULL;
315	#else	311	#else
316	return NULL;	312	return NULL;
317	#endif	313	#endif
		314	}
318	}	315	}
319	return iter;	316	return iter;
320	}	317	}
321		318
		319	static void timer_list_start(struct seq_file file, loff_t *offset)
		320	{
		321	struct timer_list_iter *iter = file->private;
		322
		323	if (!*offset)
		324	iter->now = ktime_to_ns(ktime_get());
		325	iter->cpu = -1;
		326	iter->second_pass = false;
		327	return move_iter(iter, *offset);
		328	}
		329
322	static void timer_list_next(struct seq_file file, void v, loff_t offset)	330	static void timer_list_next(struct seq_file file, void v, loff_t offset)
323	{	331	{
324	struct timer_list_iter *iter = file->private;	332	struct timer_list_iter *iter = file->private;
325	iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);
326	++*offset;	333	++*offset;
327	return timer_list_start(file, offset);	334	return move_iter(iter, 1);
328	}	335	}
329		336
330	static void timer_list_stop(struct seq_file seq, void v)	337	static void timer_list_stop(struct seq_file seq, void v)

kernel/wait.c+1−2

@@ -363,8 +363,7 @@ EXPORT_SYMBOL(out_of_line_wait_on_atomic_t); · 362 unmodified lines
363		363
364	/**	364	/**
365	* wake_up_atomic_t - Wake up a waiter on a atomic_t	365	* wake_up_atomic_t - Wake up a waiter on a atomic_t
366	* @word: The word being waited on, a kernel virtual address	366	* @p: The atomic_t being waited on, a kernel virtual address
367	* @bit: The bit of the word being waited on
368	*	367	*
369	* Wake up anyone waiting for the atomic_t to go to zero.	368	* Wake up anyone waiting for the atomic_t to go to zero.
370	*	369	*

lib/lz4/lz4_compress.c+2−2

@@ -437,7 +437,7 @@ int lz4_compress(const unsigned char *src, size_t src_len, · 436 unmodified lines
437	exit:	437	exit:
438	return ret;	438	return ret;
439	}	439	}
440	EXPORT_SYMBOL_GPL(lz4_compress);	440	EXPORT_SYMBOL(lz4_compress);
441		441
442	MODULE_LICENSE("GPL");	442	MODULE_LICENSE("Dual BSD/GPL");
443	MODULE_DESCRIPTION("LZ4 compressor");	443	MODULE_DESCRIPTION("LZ4 compressor");

lib/lz4/lz4_decompress.c+3−3

@@ -299,7 +299,7 @@ exit_0: · 298 unmodified lines
299	return ret;	299	return ret;
300	}	300	}
301	#ifndef STATIC	301	#ifndef STATIC
302	EXPORT_SYMBOL_GPL(lz4_decompress);	302	EXPORT_SYMBOL(lz4_decompress);
303	#endif	303	#endif
304		304
305	int lz4_decompress_unknownoutputsize(const char *src, size_t src_len,	305	int lz4_decompress_unknownoutputsize(const char *src, size_t src_len,
@@ -319,8 +319,8 @@ exit_0: · 13 unmodified lines
319	return ret;	319	return ret;
320	}	320	}
321	#ifndef STATIC	321	#ifndef STATIC
322	EXPORT_SYMBOL_GPL(lz4_decompress_unknownoutputsize);	322	EXPORT_SYMBOL(lz4_decompress_unknownoutputsize);
323		323
324	MODULE_LICENSE("GPL");	324	MODULE_LICENSE("Dual BSD/GPL");
325	MODULE_DESCRIPTION("LZ4 Decompressor");	325	MODULE_DESCRIPTION("LZ4 Decompressor");
326	#endif	326	#endif

lib/lz4/lz4hc_compress.c+2−2

@@ -533,7 +533,7 @@ int lz4hc_compress(const unsigned char *src, size_t src_len, · 532 unmodified lines
533	exit:	533	exit:
534	return ret;	534	return ret;
535	}	535	}
536	EXPORT_SYMBOL_GPL(lz4hc_compress);	536	EXPORT_SYMBOL(lz4hc_compress);
537		537
538	MODULE_LICENSE("GPL");	538	MODULE_LICENSE("Dual BSD/GPL");
539	MODULE_DESCRIPTION("LZ4HC compressor");	539	MODULE_DESCRIPTION("LZ4HC compressor");

mm/fremap.c+8−3

 		unsigned long addr, unsigned long pgoff, pgprot_t prot)
 {
 	int err = -ENOMEM;
-	pte_t *pte;
+	pte_t *pte, ptfile;
 	spinlock_t *ptl;
 	pte = get_locked_pte(mm, addr, &ptl);
 	if (!pte)
 		goto out;
-	if (!pte_none(*pte))
+	ptfile = pgoff_to_pte(pgoff);
+	if (!pte_none(*pte)) {
+		if (pte_present(*pte) && pte_soft_dirty(*pte))
+			pte_file_mksoft_dirty(ptfile);
 		zap_pte(mm, vma, addr, pte);
+	}
-	set_pte_at(mm, addr, pte, pgoff_to_pte(pgoff));
+	set_pte_at(mm, addr, pte, ptfile);
 	/*
 	 * We don't need to run update_mmu_cache() here because the "file pte"
 	 * being installed by install_file_pte() is not a real pte - it's a

mm/hugetlb.c+1−1

@@ -2490,7 +2490,7 @@ void unmap_hugepage_range(struct vm_area_struct *vma, unsigned long start, · 2489 unmodified lines
2490		2490
2491	mm = vma->vm_mm;	2491	mm = vma->vm_mm;
2492		2492
2493	tlb_gather_mmu(&tlb, mm, 0);	2493	tlb_gather_mmu(&tlb, mm, start, end);
2494	__unmap_hugepage_range(&tlb, vma, start, end, ref_page);	2494	__unmap_hugepage_range(&tlb, vma, start, end, ref_page);
2495	tlb_finish_mmu(&tlb, start, end);	2495	tlb_finish_mmu(&tlb, start, end);
2496	}	2496	}

mm/memcontrol.c+2−3

 	if (!s->memcg_params)
 		return -ENOMEM;
-	INIT_WORK(&s->memcg_params->destroy,
-			kmem_cache_destroy_work_func);
 	if (memcg) {
 		s->memcg_params->memcg = memcg;
 		s->memcg_params->root_cache = root_cache;
+		INIT_WORK(&s->memcg_params->destroy,
+				kmem_cache_destroy_work_func);
 	} else
 		s->memcg_params->is_root_cache = true;
 #ifdef CONFIG_MEMCG_SWAP
 static int __init enable_swap_account(char *s)
 {
-	/* consider enabled if no parameter or 1 is given */
 	if (!strcmp(s, "1"))
 		really_do_swap_account = 1;
 	else if (!strcmp(s, "0"))

mm/memory.c+31−18

@@ -209,14 +209,15 @@ static int tlb_next_batch(struct mmu_gather *tlb) · 208 unmodified lines
209	* tear-down from @mm. The @fullmm argument is used when @mm is without	209	* tear-down from @mm. The @fullmm argument is used when @mm is without
210	* users and we're going to destroy the full address space (exit/execve).	210	* users and we're going to destroy the full address space (exit/execve).
211	*/	211	*/
212	void tlb_gather_mmu(struct mmu_gather tlb, struct mm_struct mm, bool fullmm)	212	void tlb_gather_mmu(struct mmu_gather tlb, struct mm_struct mm, unsigned long start, unsigned long end)
213	{	213	{
214	tlb->mm = mm;	214	tlb->mm = mm;
215		215
216	tlb->fullmm = fullmm;	216	/* Is it from 0 to ~0? */
		217	tlb->fullmm = !(start \| (end+1));
217	tlb->need_flush_all = 0;	218	tlb->need_flush_all = 0;
218	tlb->start = -1UL;	219	tlb->start = start;
219	tlb->end = 0;	220	tlb->end = end;
220	tlb->need_flush = 0;	221	tlb->need_flush = 0;
221	tlb->local.next = NULL;	222	tlb->local.next = NULL;
222	tlb->local.nr = 0;	223	tlb->local.nr = 0;
@@ -256,8 +257,6 @@ void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long e · 33 unmodified lines
256	{	257	{
257	struct mmu_gather_batch batch, next;	258	struct mmu_gather_batch batch, next;
258		259
259	tlb->start = start;
260	tlb->end = end;
261	tlb_flush_mmu(tlb);	260	tlb_flush_mmu(tlb);
262		261
263	/* keep the page table cache within bounds */	262	/* keep the page table cache within bounds */
@@ -1099,7 +1098,6 @@ static unsigned long zap_pte_range(struct mmu_gather *tlb, · 835 unmodified lines
1099	spinlock_t *ptl;	1098	spinlock_t *ptl;
1100	pte_t *start_pte;	1099	pte_t *start_pte;
1101	pte_t *pte;	1100	pte_t *pte;
1102	unsigned long range_start = addr;
1103		1101
1104	again:	1102	again:
1105	init_rss_vec(rss);	1103	init_rss_vec(rss);
@@ -1141,9 +1139,12 @@ again: · 35 unmodified lines
1141	continue;	1139	continue;
1142	if (unlikely(details) && details->nonlinear_vma	1140	if (unlikely(details) && details->nonlinear_vma
1143	&& linear_page_index(details->nonlinear_vma,	1141	&& linear_page_index(details->nonlinear_vma,
1144	addr) != page->index)	1142	addr) != page->index) {
1145	set_pte_at(mm, addr, pte,	1143	pte_t ptfile = pgoff_to_pte(page->index);
1146	pgoff_to_pte(page->index));	1144	if (pte_soft_dirty(ptent))
		1145	pte_file_mksoft_dirty(ptfile);
		1146	set_pte_at(mm, addr, pte, ptfile);
		1147	}
1147	if (PageAnon(page))	1148	if (PageAnon(page))
1148	rss[MM_ANONPAGES]--;	1149	rss[MM_ANONPAGES]--;
1149	else {	1150	else {
@@ -1202,17 +1203,25 @@ again: · 52 unmodified lines
1202	* and page-free while holding it.	1203	* and page-free while holding it.
1203	*/	1204	*/
1204	if (force_flush) {	1205	if (force_flush) {
		1206	unsigned long old_end;
		1207
1205	force_flush = 0;	1208	force_flush = 0;
1206		1209
1207	#ifdef HAVE_GENERIC_MMU_GATHER	1210	/*
1208	tlb->start = range_start;	1211	* Flush the TLB just for the previous segment,
		1212	* then update the range to be the remaining
		1213	* TLB range.
		1214	*/
		1215	old_end = tlb->end;
1209	tlb->end = addr;	1216	tlb->end = addr;
1210	#endif	1217
1211	tlb_flush_mmu(tlb);	1218	tlb_flush_mmu(tlb);
1212	if (addr != end) {	1219
1213	range_start = addr;	1220	tlb->start = addr;
		1221	tlb->end = old_end;
		1222
		1223	if (addr != end)
1214	goto again;	1224	goto again;
1215	}
1216	}	1225	}
1217		1226
1218	return addr;	1227	return addr;
@@ -1397,7 +1406,7 @@ void zap_page_range(struct vm_area_struct *vma, unsigned long start, · 178 unmodified lines
1397	unsigned long end = start + size;	1406	unsigned long end = start + size;
1398		1407
1399	lru_add_drain();	1408	lru_add_drain();
1400	tlb_gather_mmu(&tlb, mm, 0);	1409	tlb_gather_mmu(&tlb, mm, start, end);
1401	update_hiwater_rss(mm);	1410	update_hiwater_rss(mm);
1402	mmu_notifier_invalidate_range_start(mm, start, end);	1411	mmu_notifier_invalidate_range_start(mm, start, end);
1403	for ( ; vma && vma->vm_start < end; vma = vma->vm_next)	1412	for ( ; vma && vma->vm_start < end; vma = vma->vm_next)
@@ -1423,7 +1432,7 @@ static void zap_page_range_single(struct vm_area_struct *vma, unsigned long addr · 19 unmodified lines
1423	unsigned long end = address + size;	1432	unsigned long end = address + size;
1424		1433
1425	lru_add_drain();	1434	lru_add_drain();
1426	tlb_gather_mmu(&tlb, mm, 0);	1435	tlb_gather_mmu(&tlb, mm, address, end);
1427	update_hiwater_rss(mm);	1436	update_hiwater_rss(mm);
1428	mmu_notifier_invalidate_range_start(mm, address, end);	1437	mmu_notifier_invalidate_range_start(mm, address, end);
1429	unmap_single_vma(&tlb, vma, address, end, details);	1438	unmap_single_vma(&tlb, vma, address, end, details);
@@ -3115,6 +3124,8 @@ static int do_swap_page(struct mm_struct mm, struct vm_area_struct vma, · 1685 unmodified lines
3115	exclusive = 1;	3124	exclusive = 1;
3116	}	3125	}
3117	flush_icache_page(vma, page);	3126	flush_icache_page(vma, page);
		3127	if (pte_swp_soft_dirty(orig_pte))
		3128	pte = pte_mksoft_dirty(pte);
3118	set_pte_at(mm, address, page_table, pte);	3129	set_pte_at(mm, address, page_table, pte);
3119	if (page == swapcache)	3130	if (page == swapcache)
3120	do_page_add_anon_rmap(page, vma, address, exclusive);	3131	do_page_add_anon_rmap(page, vma, address, exclusive);
@@ -3408,6 +3419,8 @@ static int __do_fault(struct mm_struct mm, struct vm_area_struct vma, · 287 unmodified lines
3408	entry = mk_pte(page, vma->vm_page_prot);	3419	entry = mk_pte(page, vma->vm_page_prot);
3409	if (flags & FAULT_FLAG_WRITE)	3420	if (flags & FAULT_FLAG_WRITE)
3410	entry = maybe_mkwrite(pte_mkdirty(entry), vma);	3421	entry = maybe_mkwrite(pte_mkdirty(entry), vma);
		3422	else if (pte_file(orig_pte) && pte_file_soft_dirty(orig_pte))
		3423	pte_mksoft_dirty(entry);
3411	if (anon) {	3424	if (anon) {
3412	inc_mm_counter_fast(mm, MM_ANONPAGES);	3425	inc_mm_counter_fast(mm, MM_ANONPAGES);
3413	page_add_new_anon_rmap(page, vma, address);	3426	page_add_new_anon_rmap(page, vma, address);

mm/mmap.c+2−2

@@ -2336,7 +2336,7 @@ static void unmap_region(struct mm_struct *mm, · 2335 unmodified lines
2336	struct mmu_gather tlb;	2336	struct mmu_gather tlb;
2337		2337
2338	lru_add_drain();	2338	lru_add_drain();
2339	tlb_gather_mmu(&tlb, mm, 0);	2339	tlb_gather_mmu(&tlb, mm, start, end);
2340	update_hiwater_rss(mm);	2340	update_hiwater_rss(mm);
2341	unmap_vmas(&tlb, vma, start, end);	2341	unmap_vmas(&tlb, vma, start, end);
2342	free_pgtables(&tlb, vma, prev ? prev->vm_end : FIRST_USER_ADDRESS,	2342	free_pgtables(&tlb, vma, prev ? prev->vm_end : FIRST_USER_ADDRESS,
@@ -2709,7 +2709,7 @@ void exit_mmap(struct mm_struct *mm) · 366 unmodified lines
2709		2709
2710	lru_add_drain();	2710	lru_add_drain();
2711	flush_cache_mm(mm);	2711	flush_cache_mm(mm);
2712	tlb_gather_mmu(&tlb, mm, 1);	2712	tlb_gather_mmu(&tlb, mm, 0, -1);
2713	/* update_hiwater_rss(mm) here? but nobody should be looking */	2713	/* update_hiwater_rss(mm) here? but nobody should be looking */
2714	/* Use -1 here to ensure all VMAs in the mm are unmapped */	2714	/* Use -1 here to ensure all VMAs in the mm are unmapped */
2715	unmap_vmas(&tlb, vma, 0, -1);	2715	unmap_vmas(&tlb, vma, 0, -1);

mm/mremap.c+20−1

 #include <linux/swap.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
+#include <linux/swapops.h>
 #include <linux/highmem.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 	return pmd;
 }
+static pte_t move_soft_dirty_pte(pte_t pte)
+{
+	/*
+	 * Set soft dirty bit so we can notice
+	 * in userspace the ptes were moved.
+	 */
+#ifdef CONFIG_MEM_SOFT_DIRTY
+	if (pte_present(pte))
+		pte = pte_mksoft_dirty(pte);
+	else if (is_swap_pte(pte))
+		pte = pte_swp_mksoft_dirty(pte);
+	else if (pte_file(pte))
+		pte = pte_file_mksoft_dirty(pte);
+#endif
+	return pte;
+}
 static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd,
 		unsigned long old_addr, unsigned long old_end,
 		struct vm_area_struct *new_vma, pmd_t *new_pmd,
 			continue;
 		pte = ptep_get_and_clear(mm, old_addr, old_pte);
 		pte = move_pte(pte, new_vma->vm_page_prot, old_addr, new_addr);
-		set_pte_at(mm, new_addr, new_pte, pte_mksoft_dirty(pte));
+		pte = move_soft_dirty_pte(pte);
+		set_pte_at(mm, new_addr, new_pte, pte);
 	}
 	arch_leave_lazy_mmu_mode();

mm/rmap.c+11−3

 			   swp_entry_to_pte(make_hwpoison_entry(page)));
 	} else if (PageAnon(page)) {
 		swp_entry_t entry = { .val = page_private(page) };
+		pte_t swp_pte;
 		if (PageSwapCache(page)) {
 			/*
 			BUG_ON(TTU_ACTION(flags) != TTU_MIGRATION);
 			entry = make_migration_entry(page, pte_write(pteval));
 		}
-		set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
+		swp_pte = swp_entry_to_pte(entry);
+		if (pte_soft_dirty(pteval))
+			swp_pte = pte_swp_mksoft_dirty(swp_pte);
+		set_pte_at(mm, address, pte, swp_pte);
 		BUG_ON(pte_file(*pte));
 	} else if (IS_ENABLED(CONFIG_MIGRATION) &&
 		   (TTU_ACTION(flags) == TTU_MIGRATION)) {
 		pteval = ptep_clear_flush(vma, address, pte);
 		/* If nonlinear, store the file page offset in the pte. */
-		if (page->index != linear_page_index(vma, address))
+		if (page->index != linear_page_index(vma, address)) {
-			set_pte_at(mm, address, pte, pgoff_to_pte(page->index));
+			pte_t ptfile = pgoff_to_pte(page->index);
+			if (pte_soft_dirty(pteval))
+				pte_file_mksoft_dirty(ptfile);
+			set_pte_at(mm, address, pte, ptfile);
+		}
 		/* Move the dirty bit to the physical page now the pte is gone. */
 		if (pte_dirty(pteval))

mm/shmem.c+1−7

 /* common code */
-static char *shmem_dname(struct dentry *dentry, char *buffer, int buflen)
-{
-	return dynamic_dname(dentry, buffer, buflen, "/%s (deleted)",
-				dentry->d_name.name);
-}
 static struct dentry_operations anon_ops = {
-	.d_dname = shmem_dname
+	.d_dname = simple_dname
 };
 /**

mm/slab.h+2−0

@@ -162,6 +162,8 @@ static inline const char cache_name(struct kmem_cache s) · 161 unmodified lines
162		162
163	static inline struct kmem_cache cache_from_memcg(struct kmem_cache s, int idx)	163	static inline struct kmem_cache cache_from_memcg(struct kmem_cache s, int idx)
164	{	164	{
		165	if (!s->memcg_params)
		166	return NULL;
165	return s->memcg_params->memcg_caches[idx];	167	return s->memcg_params->memcg_caches[idx];
166	}	168	}
167		169

mm/swapfile.c+17−2

 }
 #endif /* CONFIG_HIBERNATION */
+static inline int maybe_same_pte(pte_t pte, pte_t swp_pte)
+{
+#ifdef CONFIG_MEM_SOFT_DIRTY
+	/*
+	 * When pte keeps soft dirty bit the pte generated
+	 * from swap entry does not has it, still it's same
+	 * pte from logical point of view.
+	 */
+	pte_t swp_pte_dirty = pte_swp_mksoft_dirty(swp_pte);
+	return pte_same(pte, swp_pte) || pte_same(pte, swp_pte_dirty);
+#else
+	return pte_same(pte, swp_pte);
+#endif
+}
 /*
  * No need to decide whether this PTE shares the swap entry with others,
  * just let do_wp_page work it out if a write is requested later - to
 	}
 	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
-	if (unlikely(!pte_same(*pte, swp_entry_to_pte(entry)))) {
+	if (unlikely(!maybe_same_pte(*pte, swp_entry_to_pte(entry)))) {
 		mem_cgroup_cancel_charge_swapin(memcg);
 		ret = 0;
 		goto out;
 		 * swapoff spends a _lot_ of time in this loop!
 		 * Test inline before going to call unuse_pte.
 		 */
-		if (unlikely(pte_same(*pte, swp_pte))) {
+		if (unlikely(maybe_same_pte(*pte, swp_pte))) {
 			pte_unmap(pte);
 			ret = unuse_pte(vma, pmd, addr, entry, page);
 			if (ret)

net/8021q/vlan_core.c+6−1

 struct net_device *vlan_dev_real_dev(const struct net_device *dev)
 {
-	return vlan_dev_priv(dev)->real_dev;
+	struct net_device *ret = vlan_dev_priv(dev)->real_dev;
+	while (is_vlan_dev(ret))
+		ret = vlan_dev_priv(ret)->real_dev;
+	return ret;
 }
 EXPORT_SYMBOL(vlan_dev_real_dev);

net/batman-adv/bridge_loop_avoidance.c+2−0

  * in these cases, the skb is further handled by this function and
  * returns 1, otherwise it returns 0 and the caller shall further
  * process the skb.
+ *
+ * This call might reallocate skb data.
  */
 int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
 		  unsigned short vid)

net/batman-adv/gateway_client.c+12−1

 	return 0;
 }
+/* this call might reallocate skb data */
 static bool batadv_is_type_dhcprequest(struct sk_buff *skb, int header_len)
 {
 	int ret = false;
 	return ret;
 }
+/* this call might reallocate skb data */
 bool batadv_gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len)
 {
 	struct ethhdr *ethhdr;
 	if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
 		return false;
+	/* skb->data might have been reallocated by pskb_may_pull() */
+	ethhdr = (struct ethhdr *)skb->data;
+	if (ntohs(ethhdr->h_proto) == ETH_P_8021Q)
+		ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
 	udphdr = (struct udphdr *)(skb->data + *header_len);
 	*header_len += sizeof(*udphdr);
 	return true;
 }
+/* this call might reallocate skb data */
 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
-			    struct sk_buff *skb, struct ethhdr *ethhdr)
+			    struct sk_buff *skb)
 {
 	struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL;
 	struct batadv_orig_node *orig_dst_node = NULL;
 	struct batadv_gw_node *curr_gw = NULL;
+	struct ethhdr *ethhdr;
 	bool ret, out_of_range = false;
 	unsigned int header_len = 0;
 	uint8_t curr_tq_avg;
 	if (!ret)
 		goto out;
+	ethhdr = (struct ethhdr *)skb->data;
 	orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
 						 ethhdr->h_dest);
 	if (!orig_dst_node)

net/batman-adv/gateway_client.h+1−2

@@ -34,7 +34,6 @@ void batadv_gw_node_delete(struct batadv_priv *bat_priv, · 33 unmodified lines
34	void batadv_gw_node_purge(struct batadv_priv *bat_priv);	34	void batadv_gw_node_purge(struct batadv_priv *bat_priv);
35	int batadv_gw_client_seq_print_text(struct seq_file seq, void offset);	35	int batadv_gw_client_seq_print_text(struct seq_file seq, void offset);
36	bool batadv_gw_is_dhcp_target(struct sk_buff skb, unsigned int header_len);	36	bool batadv_gw_is_dhcp_target(struct sk_buff skb, unsigned int header_len);
37	bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,	37	bool batadv_gw_out_of_range(struct batadv_priv bat_priv, struct sk_buff skb);
38	struct sk_buff skb, struct ethhdr ethhdr);
39		38
40	#endif /* _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ */	39	#endif /* _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ */

net/batman-adv/soft-interface.c+8−1

 	if (batadv_bla_tx(bat_priv, skb, vid))
 		goto dropped;
+	/* skb->data might have been reallocated by batadv_bla_tx() */
+	ethhdr = (struct ethhdr *)skb->data;
 	/* Register the client MAC in the transtable */
 	if (!is_multicast_ether_addr(ethhdr->h_source))
 		batadv_tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
 		default:
 			break;
 		}
+		/* reminder: ethhdr might have become unusable from here on
+		 * (batadv_gw_is_dhcp_target() might have reallocated skb data)
+		 */
 	}
 	/* ethernet packet should be broadcasted */
 	/* unicast packet */
 	} else {
 		if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) {
-			ret = batadv_gw_out_of_range(bat_priv, skb, ethhdr);
+			ret = batadv_gw_out_of_range(bat_priv, skb);
 			if (ret)
 				goto dropped;
 		}

net/batman-adv/unicast.c+17−6

  * @skb: the skb containing the payload to encapsulate
  * @orig_node: the destination node
  *
- * Returns false if the payload could not be encapsulated or true otherwise
+ * Returns false if the payload could not be encapsulated or true otherwise.
+ *
+ * This call might reallocate skb data.
  */
 static bool batadv_unicast_prepare_skb(struct sk_buff *skb,
 				       struct batadv_orig_node *orig_node)
  * @orig_node: the destination node
  * @packet_subtype: the batman 4addr packet subtype to use
  *
- * Returns false if the payload could not be encapsulated or true otherwise
+ * Returns false if the payload could not be encapsulated or true otherwise.
+ *
+ * This call might reallocate skb data.
  */
 bool batadv_unicast_4addr_prepare_skb(struct batadv_priv *bat_priv,
 				      struct sk_buff *skb,
 	struct batadv_neigh_node *neigh_node;
 	int data_len = skb->len;
 	int ret = NET_RX_DROP;
-	unsigned int dev_mtu;
+	unsigned int dev_mtu, header_len;
 	/* get routing information */
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 	switch (packet_type) {
 	case BATADV_UNICAST:
-		batadv_unicast_prepare_skb(skb, orig_node);
+		if (!batadv_unicast_prepare_skb(skb, orig_node))
+			goto out;
+		header_len = sizeof(struct batadv_unicast_packet);
 		break;
 	case BATADV_UNICAST_4ADDR:
-		batadv_unicast_4addr_prepare_skb(bat_priv, skb, orig_node,
+		if (!batadv_unicast_4addr_prepare_skb(bat_priv, skb, orig_node,
-						 packet_subtype);
+						      packet_subtype))
+			goto out;
+		header_len = sizeof(struct batadv_unicast_4addr_packet);
 		break;
 	default:
 		/* this function supports UNICAST and UNICAST_4ADDR only. It
 		goto out;
 	}
+	ethhdr = (struct ethhdr *)(skb->data + header_len);
 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
 	/* inform the destination node that we are still missing a correct route

net/bridge/br_fdb.c+5−5

@@ -161,7 +161,7 @@ void br_fdb_change_mac_address(struct net_bridge br, const u8 newaddr) · 160 unmodified lines
161	if (!pv)	161	if (!pv)
162	return;	162	return;
163		163
164	for_each_set_bit_from(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {	164	for_each_set_bit_from(vid, pv->vlan_bitmap, VLAN_N_VID) {
165	f = __br_fdb_get(br, br->dev->dev_addr, vid);	165	f = __br_fdb_get(br, br->dev->dev_addr, vid);
166	if (f && f->is_local && !f->dst)	166	if (f && f->is_local && !f->dst)
167	fdb_delete(br, f);	167	fdb_delete(br, f);
@@ -730,7 +730,7 @@ int br_fdb_add(struct ndmsg ndm, struct nlattr tb[], · 562 unmodified lines
730	/* VID was specified, so use it. */	730	/* VID was specified, so use it. */
731	err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);	731	err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
732	} else {	732	} else {
733	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN)) {	733	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, VLAN_N_VID)) {
734	err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);	734	err = __br_fdb_add(ndm, p, addr, nlh_flags, 0);
735	goto out;	735	goto out;
736	}	736	}
@@ -739,7 +739,7 @@ int br_fdb_add(struct ndmsg ndm, struct nlattr tb[], · 2 unmodified lines
739	* specify a VLAN. To be nice, add/update entry for every	739	* specify a VLAN. To be nice, add/update entry for every
740	* vlan on this port.	740	* vlan on this port.
741	*/	741	*/
742	for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {	742	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
743	err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);	743	err = __br_fdb_add(ndm, p, addr, nlh_flags, vid);
744	if (err)	744	if (err)
745	goto out;	745	goto out;
@@ -817,7 +817,7 @@ int br_fdb_delete(struct ndmsg ndm, struct nlattr tb[], · 71 unmodified lines
817		817
818	err = __br_fdb_delete(p, addr, vid);	818	err = __br_fdb_delete(p, addr, vid);
819	} else {	819	} else {
820	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN)) {	820	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, VLAN_N_VID)) {
821	err = __br_fdb_delete(p, addr, 0);	821	err = __br_fdb_delete(p, addr, 0);
822	goto out;	822	goto out;
823	}	823	}
@@ -827,7 +827,7 @@ int br_fdb_delete(struct ndmsg ndm, struct nlattr tb[], · 3 unmodified lines
827	* vlan on this port.	827	* vlan on this port.
828	*/	828	*/
829	err = -ENOENT;	829	err = -ENOENT;
830	for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {	830	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
831	err &= __br_fdb_delete(p, addr, vid);	831	err &= __br_fdb_delete(p, addr, vid);
832	}	832	}
833	}	833	}

net/bridge/br_multicast.c+1−1

@@ -1195,7 +1195,7 @@ static int br_ip6_multicast_query(struct net_bridge *br, · 1194 unmodified lines
1195	max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));	1195	max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
1196	if (max_delay)	1196	if (max_delay)
1197	group = &mld->mld_mca;	1197	group = &mld->mld_mca;
1198	} else if (skb->len >= sizeof(*mld2q)) {	1198	} else {
1199	if (!pskb_may_pull(skb, sizeof(*mld2q))) {	1199	if (!pskb_may_pull(skb, sizeof(*mld2q))) {
1200	err = -EINVAL;	1200	err = -EINVAL;
1201	goto out;	1201	goto out;

net/bridge/br_netlink.c+2−2

@@ -132,7 +132,7 @@ static int br_fill_ifinfo(struct sk_buff *skb, · 131 unmodified lines
132	else	132	else
133	pv = br_get_vlan_info(br);	133	pv = br_get_vlan_info(br);
134		134
135	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN))	135	if (!pv \|\| bitmap_empty(pv->vlan_bitmap, VLAN_N_VID))
136	goto done;	136	goto done;
137		137
138	af = nla_nest_start(skb, IFLA_AF_SPEC);	138	af = nla_nest_start(skb, IFLA_AF_SPEC);
@@ -140,7 +140,7 @@ static int br_fill_ifinfo(struct sk_buff *skb, · 1 unmodified line
140	goto nla_put_failure;	140	goto nla_put_failure;
141		141
142	pvid = br_get_pvid(pv);	142	pvid = br_get_pvid(pv);
143	for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {	143	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
144	vinfo.vid = vid;	144	vinfo.vid = vid;
145	vinfo.flags = 0;	145	vinfo.flags = 0;
146	if (vid == pvid)	146	if (vid == pvid)

net/bridge/br_sysfs_br.c+1−1

@@ -1,5 +1,5 @@
1	/*	1	/*
2	* Sysfs attributes of bridge ports	2	* Sysfs attributes of bridge
3	* Linux ethernet bridge	3	* Linux ethernet bridge
4	*	4	*
5	* Authors:	5	* Authors:

net/bridge/br_vlan.c+2−2

@@ -108,7 +108,7 @@ static int __vlan_del(struct net_port_vlans *v, u16 vid) · 107 unmodified lines
108		108
109	clear_bit(vid, v->vlan_bitmap);	109	clear_bit(vid, v->vlan_bitmap);
110	v->num_vlans--;	110	v->num_vlans--;
111	if (bitmap_empty(v->vlan_bitmap, BR_VLAN_BITMAP_LEN)) {	111	if (bitmap_empty(v->vlan_bitmap, VLAN_N_VID)) {
112	if (v->port_idx)	112	if (v->port_idx)
113	rcu_assign_pointer(v->parent.port->vlan_info, NULL);	113	rcu_assign_pointer(v->parent.port->vlan_info, NULL);
114	else	114	else
@@ -122,7 +122,7 @@ static void __vlan_flush(struct net_port_vlans *v) · 7 unmodified lines
122	{	122	{
123	smp_wmb();	123	smp_wmb();
124	v->pvid = 0;	124	v->pvid = 0;
125	bitmap_zero(v->vlan_bitmap, BR_VLAN_BITMAP_LEN);	125	bitmap_zero(v->vlan_bitmap, VLAN_N_VID);
126	if (v->port_idx)	126	if (v->port_idx)
127	rcu_assign_pointer(v->parent.port->vlan_info, NULL);	127	rcu_assign_pointer(v->parent.port->vlan_info, NULL);
128	else	128	else

net/core/flow_dissector.c+1−0

@@ -65,6 +65,7 @@ ipv6: · 64 unmodified lines
65	nhoff += sizeof(struct ipv6hdr);	65	nhoff += sizeof(struct ipv6hdr);
66	break;	66	break;
67	}	67	}
		68	case __constant_htons(ETH_P_8021AD):
68	case __constant_htons(ETH_P_8021Q): {	69	case __constant_htons(ETH_P_8021Q): {
69	const struct vlan_hdr *vlan;	70	const struct vlan_hdr *vlan;
70	struct vlan_hdr _vlan;	71	struct vlan_hdr _vlan;

net/core/neighbour.c+6−4

 		atomic_set(&p->refcnt, 1);
 		p->reachable_time =
 				neigh_rand_reach_time(p->base_reachable_time);
+		dev_hold(dev);
+		p->dev = dev;
+		write_pnet(&p->net, hold_net(net));
+		p->sysctl_table = NULL;
 		if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
+			release_net(net);
+			dev_put(dev);
 			kfree(p);
 			return NULL;
 		}
-		dev_hold(dev);
-		p->dev = dev;
-		write_pnet(&p->net, hold_net(net));
-		p->sysctl_table = NULL;
 		write_lock_bh(&tbl->lock);
 		p->next		= tbl->parms.next;
 		tbl->parms.next = p;

net/core/rtnetlink.c+2−2

@@ -2156,7 +2156,7 @@ int ndo_dflt_fdb_del(struct ndmsg *ndm, · 2155 unmodified lines
2156	/* If aging addresses are supported device will need to	2156	/* If aging addresses are supported device will need to
2157	* implement its own handler for this.	2157	* implement its own handler for this.
2158	*/	2158	*/
2159	if (ndm->ndm_state & NUD_PERMANENT) {	2159	if (!(ndm->ndm_state & NUD_PERMANENT)) {
2160	pr_info("%s: FDB only supports static addresses\n", dev->name);	2160	pr_info("%s: FDB only supports static addresses\n", dev->name);
2161	return -EINVAL;	2161	return -EINVAL;
2162	}	2162	}
@@ -2384,7 +2384,7 @@ static int rtnl_bridge_getlink(struct sk_buff skb, struct netlink_callback cb) · 221 unmodified lines
2384	struct nlattr *extfilt;	2384	struct nlattr *extfilt;
2385	u32 filter_mask = 0;	2385	u32 filter_mask = 0;
2386		2386
2387	extfilt = nlmsg_find_attr(cb->nlh, sizeof(struct rtgenmsg),	2387	extfilt = nlmsg_find_attr(cb->nlh, sizeof(struct ifinfomsg),
2388	IFLA_EXT_MASK);	2388	IFLA_EXT_MASK);
2389	if (extfilt)	2389	if (extfilt)
2390	filter_mask = nla_get_u32(extfilt);	2390	filter_mask = nla_get_u32(extfilt);

net/ipv4/esp4.c+1−1

@@ -477,7 +477,7 @@ static u32 esp4_get_mtu(struct xfrm_state *x, int mtu) · 476 unmodified lines
477	}	477	}
478		478
479	return ((mtu - x->props.header_len - crypto_aead_authsize(esp->aead) -	479	return ((mtu - x->props.header_len - crypto_aead_authsize(esp->aead) -
480	net_adj) & ~(align - 1)) + (net_adj - 2);	480	net_adj) & ~(align - 1)) + net_adj - 2;
481	}	481	}
482		482
483	static void esp4_err(struct sk_buff *skb, u32 info)	483	static void esp4_err(struct sk_buff *skb, u32 info)

net/ipv4/fib_trie.c+1−4

 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/slab.h>
-#include <linux/prefetch.h>
 #include <linux/export.h>
 #include <net/net_namespace.h>
 #include <net/ip.h>
 			if (!c)
 				continue;
-			if (IS_LEAF(c)) {
+			if (IS_LEAF(c))
-				prefetch(rcu_dereference_rtnl(p->child[idx]));
 				return (struct leaf *) c;
-			}
 			/* Rescan start scanning in new node */
 			p = (struct tnode *) c;

net/ipv4/ip_gre.c+1−1

@@ -383,7 +383,7 @@ static int ipgre_header(struct sk_buff skb, struct net_device dev, · 382 unmodified lines
383	if (daddr)	383	if (daddr)
384	memcpy(&iph->daddr, daddr, 4);	384	memcpy(&iph->daddr, daddr, 4);
385	if (iph->daddr)	385	if (iph->daddr)
386	return t->hlen;	386	return t->hlen + sizeof(*iph);
387		387
388	return -(t->hlen + sizeof(*iph));	388	return -(t->hlen + sizeof(*iph));
389	}	389	}

net/ipv4/ip_tunnel_core.c+1−3

 	iph->daddr	=	dst;
 	iph->saddr	=	src;
 	iph->ttl	=	ttl;
-	tunnel_ip_select_ident(skb,
+	__ip_select_ident(iph, &rt->dst, (skb_shinfo(skb)->gso_segs ?: 1) - 1);
-			       (const struct iphdr *)skb_inner_network_header(skb),
-			       &rt->dst);
 	err = ip_local_out(skb);
 	if (unlikely(net_xmit_eval(err)))

net/ipv4/proc.c+1−1

@@ -273,7 +273,7 @@ static const struct snmp_mib snmp4_net_list[] = { · 272 unmodified lines
273	SNMP_MIB_ITEM("TCPFastOpenListenOverflow", LINUX_MIB_TCPFASTOPENLISTENOVERFLOW),	273	SNMP_MIB_ITEM("TCPFastOpenListenOverflow", LINUX_MIB_TCPFASTOPENLISTENOVERFLOW),
274	SNMP_MIB_ITEM("TCPFastOpenCookieReqd", LINUX_MIB_TCPFASTOPENCOOKIEREQD),	274	SNMP_MIB_ITEM("TCPFastOpenCookieReqd", LINUX_MIB_TCPFASTOPENCOOKIEREQD),
275	SNMP_MIB_ITEM("TCPSpuriousRtxHostQueues", LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES),	275	SNMP_MIB_ITEM("TCPSpuriousRtxHostQueues", LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES),
276	SNMP_MIB_ITEM("LowLatencyRxPackets", LINUX_MIB_LOWLATENCYRXPACKETS),	276	SNMP_MIB_ITEM("BusyPollRxPackets", LINUX_MIB_BUSYPOLLRXPACKETS),
277	SNMP_MIB_SENTINEL	277	SNMP_MIB_SENTINEL
278	};	278	};
279		279

net/ipv4/tcp.c+7−0

@@ -1120,6 +1120,13 @@ new_segment: · 1119 unmodified lines
1120	if (!skb)	1120	if (!skb)
1121	goto wait_for_memory;	1121	goto wait_for_memory;
1122		1122
		1123	/*
		1124	* All packets are restored as if they have
		1125	* already been sent.
		1126	*/
		1127	if (tp->repair)
		1128	TCP_SKB_CB(skb)->when = tcp_time_stamp;
		1129
1123	/*	1130	/*
1124	* Check whether we can use HW checksum.	1131	* Check whether we can use HW checksum.
1125	*/	1132	*/

net/ipv4/tcp_cubic.c+7−5

  */
 static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
 {
-	u64 offs;
+	u32 delta, bic_target, max_cnt;
-	u32 delta, t, bic_target, max_cnt;
+	u64 offs, t;
 	ca->ack_cnt++;	/* count the number of ACKs */
 	 * if the cwnd < 1 million packets !!!
 	 */
+	t = (s32)(tcp_time_stamp - ca->epoch_start);
+	t += msecs_to_jiffies(ca->delay_min >> 3);
 	/* change the unit from HZ to bictcp_HZ */
-	t = ((tcp_time_stamp + msecs_to_jiffies(ca->delay_min>>3)
+	t <<= BICTCP_HZ;
-	      - ca->epoch_start) << BICTCP_HZ) / HZ;
+	do_div(t, HZ);
 	if (t < ca->bic_K)		/* t - K */
 		offs = ca->bic_K - t;
 		return;
 	/* Discard delay samples right after fast recovery */
-	if ((s32)(tcp_time_stamp - ca->epoch_start) < HZ)
+	if (ca->epoch_start && (s32)(tcp_time_stamp - ca->epoch_start) < HZ)
 		return;
 	delay = (rtt_us << 3) / USEC_PER_MSEC;

net/ipv6/addrconf.c+4−6

 	if (ifp->flags & IFA_F_OPTIMISTIC)
 		addr_flags |= IFA_F_OPTIMISTIC;
-	ift = !max_addresses ||
+	ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
-	      ipv6_count_addresses(idev) < max_addresses ?
+			    ipv6_addr_scope(&addr), addr_flags,
-		ipv6_add_addr(idev, &addr, NULL, tmp_plen,
+			    tmp_valid_lft, tmp_prefered_lft);
-			      ipv6_addr_scope(&addr), addr_flags,
+	if (IS_ERR(ift)) {
-			      tmp_valid_lft, tmp_prefered_lft) : NULL;
-	if (IS_ERR_OR_NULL(ift)) {
 		in6_ifa_put(ifp);
 		in6_dev_put(idev);
 		pr_info("%s: retry temporary address regeneration\n", __func__);

net/ipv6/esp6.c+1−1

@@ -425,7 +425,7 @@ static u32 esp6_get_mtu(struct xfrm_state *x, int mtu) · 424 unmodified lines
425	net_adj = 0;	425	net_adj = 0;
426		426
427	return ((mtu - x->props.header_len - crypto_aead_authsize(esp->aead) -	427	return ((mtu - x->props.header_len - crypto_aead_authsize(esp->aead) -
428	net_adj) & ~(align - 1)) + (net_adj - 2);	428	net_adj) & ~(align - 1)) + net_adj - 2;
429	}	429	}
430		430
431	static void esp6_err(struct sk_buff skb, struct inet6_skb_parm opt,	431	static void esp6_err(struct sk_buff skb, struct inet6_skb_parm opt,

net/ipv6/ip6_fib.c+12−4

@@ -993,14 +993,22 @@ static struct fib6_node * fib6_lookup_1(struct fib6_node *root, · 992 unmodified lines
993		993
994	if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) {	994	if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) {
995	#ifdef CONFIG_IPV6_SUBTREES	995	#ifdef CONFIG_IPV6_SUBTREES
996	if (fn->subtree)	996	if (fn->subtree) {
997	fn = fib6_lookup_1(fn->subtree, args + 1);	997	struct fib6_node *sfn;
		998	sfn = fib6_lookup_1(fn->subtree,
		999	args + 1);
		1000	if (!sfn)
		1001	goto backtrack;
		1002	fn = sfn;
		1003	}
998	#endif	1004	#endif
999	if (!fn \|\| fn->fn_flags & RTN_RTINFO)	1005	if (fn->fn_flags & RTN_RTINFO)
1000	return fn;	1006	return fn;
1001	}	1007	}
1002	}	1008	}
1003		1009	#ifdef CONFIG_IPV6_SUBTREES
		1010	backtrack:
		1011	#endif
1004	if (fn->fn_flags & RTN_ROOT)	1012	if (fn->fn_flags & RTN_ROOT)
1005	break;	1013	break;
1006		1014

net/ipv6/ndisc.c+3−1

 	if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
 		return;
-	if (!ndopts.nd_opts_rh)
+	if (!ndopts.nd_opts_rh) {
+		ip6_redirect_no_header(skb, dev_net(skb->dev), 0, 0);
 		return;
+	}
 	hdr = (u8 *)ndopts.nd_opts_rh;
 	hdr += 8;

net/ipv6/reassembly.c+5−0

 	ipv6_hdr(head)->payload_len = htons(payload_len);
 	ipv6_change_dsfield(ipv6_hdr(head), 0xff, ecn);
 	IP6CB(head)->nhoff = nhoff;
+	IP6CB(head)->flags |= IP6SKB_FRAGMENTED;
 	/* Yes, and fold redundant checksum back. 8) */
 	if (head->ip_summed == CHECKSUM_COMPLETE)
 	struct net *net = dev_net(skb_dst(skb)->dev);
 	int evicted;
+	if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED)
+		goto fail_hdr;
 	IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMREQDS);
 	/* Jumbo payload inhibits frag. header */
 				 ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMOKS);
 		IP6CB(skb)->nhoff = (u8 *)fhdr - skb_network_header(skb);
+		IP6CB(skb)->flags |= IP6SKB_FRAGMENTED;
 		return 1;
 	}

net/ipv6/route.c+21−0

@@ -1178,6 +1178,27 @@ void ip6_redirect(struct sk_buff skb, struct net net, int oif, u32 mark) · 1177 unmodified lines
1178	}	1178	}
1179	EXPORT_SYMBOL_GPL(ip6_redirect);	1179	EXPORT_SYMBOL_GPL(ip6_redirect);
1180		1180
		1181	void ip6_redirect_no_header(struct sk_buff skb, struct net net, int oif,
		1182	u32 mark)
		1183	{
		1184	const struct ipv6hdr *iph = ipv6_hdr(skb);
		1185	const struct rd_msg msg = (struct rd_msg )icmp6_hdr(skb);
		1186	struct dst_entry *dst;
		1187	struct flowi6 fl6;
		1188
		1189	memset(&fl6, 0, sizeof(fl6));
		1190	fl6.flowi6_oif = oif;
		1191	fl6.flowi6_mark = mark;
		1192	fl6.flowi6_flags = 0;
		1193	fl6.daddr = msg->dest;
		1194	fl6.saddr = iph->daddr;
		1195
		1196	dst = ip6_route_output(net, NULL, &fl6);
		1197	if (!dst->error)
		1198	rt6_do_redirect(dst, NULL, skb);
		1199	dst_release(dst);
		1200	}
		1201
1181	void ip6_sk_redirect(struct sk_buff skb, struct sock sk)	1202	void ip6_sk_redirect(struct sk_buff skb, struct sock sk)
1182	{	1203	{
1183	ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);	1204	ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);

net/mac80211/mlme.c+36−18

 #include "led.h"
 #define IEEE80211_AUTH_TIMEOUT		(HZ / 5)
+#define IEEE80211_AUTH_TIMEOUT_LONG	(HZ / 2)
 #define IEEE80211_AUTH_TIMEOUT_SHORT	(HZ / 10)
 #define IEEE80211_AUTH_MAX_TRIES	3
 #define IEEE80211_AUTH_WAIT_ASSOC	(HZ * 5)
 #define IEEE80211_ASSOC_TIMEOUT		(HZ / 5)
+#define IEEE80211_ASSOC_TIMEOUT_LONG	(HZ / 2)
 #define IEEE80211_ASSOC_TIMEOUT_SHORT	(HZ / 10)
 #define IEEE80211_ASSOC_MAX_TRIES	3
 			     struct ieee80211_channel *channel,
 			     const struct ieee80211_ht_operation *ht_oper,
 			     const struct ieee80211_vht_operation *vht_oper,
-			     struct cfg80211_chan_def *chandef, bool verbose)
+			     struct cfg80211_chan_def *chandef, bool tracking)
 {
+	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 	struct cfg80211_chan_def vht_chandef;
 	u32 ht_cfreq, ret;
 	ht_cfreq = ieee80211_channel_to_frequency(ht_oper->primary_chan,
 						  channel->band);
 	/* check that channel matches the right operating channel */
-	if (channel->center_freq != ht_cfreq) {
+	if (!tracking && channel->center_freq != ht_cfreq) {
 		/*
 		 * It's possible that some APs are confused here;
 		 * Netgear WNDR3700 sometimes reports 4 higher than
 		 * since we look at probe response/beacon data here
 		 * it should be OK.
 		 */
-		if (verbose)
+		sdata_info(sdata,
-			sdata_info(sdata,
+			   "Wrong control channel: center-freq: %d ht-cfreq: %d ht->primary_chan: %d band: %d - Disabling HT\n",
-				   "Wrong control channel: center-freq: %d ht-cfreq: %d ht->primary_chan: %d band: %d - Disabling HT\n",
+			   channel->center_freq, ht_cfreq,
-				   channel->center_freq, ht_cfreq,
+			   ht_oper->primary_chan, channel->band);
-				   ht_oper->primary_chan, channel->band);
 		ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
 		goto out;
 	}
 				channel->band);
 		break;
 	default:
-		if (verbose)
+		if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
 			sdata_info(sdata,
 				   "AP VHT operation IE has invalid channel width (%d), disable VHT\n",
 				   vht_oper->chan_width);
 	}
 	if (!cfg80211_chandef_valid(&vht_chandef)) {
-		if (verbose)
+		if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
 			sdata_info(sdata,
 				   "AP VHT information is invalid, disable VHT\n");
 		ret = IEEE80211_STA_DISABLE_VHT;
 	}
 	if (!cfg80211_chandef_compatible(chandef, &vht_chandef)) {
-		if (verbose)
+		if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
 			sdata_info(sdata,
 				   "AP VHT information doesn't match HT, disable VHT\n");
 		ret = IEEE80211_STA_DISABLE_VHT;
 	if (ret & IEEE80211_STA_DISABLE_VHT)
 		vht_chandef = *chandef;
+	/*
+	 * Ignore the DISABLED flag when we're already connected and only
+	 * tracking the APs beacon for bandwidth changes - otherwise we
+	 * might get disconnected here if we connect to an AP, update our
+	 * regulatory information based on the AP's country IE and the
+	 * information we have is wrong/outdated and disables the channel
+	 * that we're actually using for the connection to the AP.
+	 */
 	while (!cfg80211_chandef_usable(sdata->local->hw.wiphy, chandef,
-					IEEE80211_CHAN_DISABLED)) {
+					tracking ? 0 :
+						   IEEE80211_CHAN_DISABLED)) {
 		if (WARN_ON(chandef->width == NL80211_CHAN_WIDTH_20_NOHT)) {
 			ret = IEEE80211_STA_DISABLE_HT |
 			      IEEE80211_STA_DISABLE_VHT;
-			goto out;
+			break;
 		}
 		ret |= chandef_downgrade(chandef);
 	}
-	if (chandef->width != vht_chandef.width && verbose)
+	if (chandef->width != vht_chandef.width && !tracking)
 		sdata_info(sdata,
 			   "capabilities/regulatory prevented using AP HT/VHT configuration, downgraded\n");
 	/* calculate new channel (type) based on HT/VHT operation IEs */
 	flags = ieee80211_determine_chantype(sdata, sband, chan, ht_oper,
-					     vht_oper, &chandef, false);
+					     vht_oper, &chandef, true);
 	/*
 	 * Downgrade the new channel if we associated with restricted
 	if (tx_flags == 0) {
 		auth_data->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
-		ifmgd->auth_data->timeout_started = true;
+		auth_data->timeout_started = true;
 		run_again(sdata, auth_data->timeout);
 	} else {
-		auth_data->timeout_started = false;
+		auth_data->timeout =
+			round_jiffies_up(jiffies + IEEE80211_AUTH_TIMEOUT_LONG);
+		auth_data->timeout_started = true;
+		run_again(sdata, auth_data->timeout);
 	}
 	return 0;
 		assoc_data->timeout_started = true;
 		run_again(sdata, assoc_data->timeout);
 	} else {
-		assoc_data->timeout_started = false;
+		assoc_data->timeout =
+			round_jiffies_up(jiffies +
+					 IEEE80211_ASSOC_TIMEOUT_LONG);
+		assoc_data->timeout_started = true;
+		run_again(sdata, assoc_data->timeout);
 	}
 	return 0;
 	ifmgd->flags |= ieee80211_determine_chantype(sdata, sband,
 						     cbss->channel,
 						     ht_oper, vht_oper,
-						     &chandef, true);
+						     &chandef, false);
 	sdata->needed_rx_chains = min(ieee80211_ht_vht_rx_chains(sdata, cbss),
 				      local->rx_chains);

net/netfilter/nf_conntrack_proto_tcp.c+8−4

 	const struct nf_conntrack_tuple *tuple = &ct->tuplehash[dir].tuple;
 	__u32 seq, ack, sack, end, win, swin;
 	s16 receiver_offset;
-	bool res;
+	bool res, in_recv_win;
 	/*
 	 * Get the required data from the packet.
 		 receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
 		 receiver->td_scale);
+	/* Is the ending sequence in the receive window (if available)? */
+	in_recv_win = !receiver->td_maxwin ||
+		      after(end, sender->td_end - receiver->td_maxwin - 1);
 	pr_debug("tcp_in_window: I=%i II=%i III=%i IV=%i\n",
 		 before(seq, sender->td_maxend + 1),
-		 after(end, sender->td_end - receiver->td_maxwin - 1),
+		 (in_recv_win ? 1 : 0),
 		 before(sack, receiver->td_end + 1),
 		 after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1));
 	if (before(seq, sender->td_maxend + 1) &&
-	    after(end, sender->td_end - receiver->td_maxwin - 1) &&
+	    in_recv_win &&
 	    before(sack, receiver->td_end + 1) &&
 	    after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1)) {
 		/*
 			nf_log_packet(net, pf, 0, skb, NULL, NULL, NULL,
 			"nf_ct_tcp: %s ",
 			before(seq, sender->td_maxend + 1) ?
-			after(end, sender->td_end - receiver->td_maxwin - 1) ?
+			in_recv_win ?
 			before(sack, receiver->td_end + 1) ?
 			after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1) ? "BUG"
 			: "ACK is under the lower bound (possible overly delayed ACK)"

net/netfilter/nfnetlink_log.c+5−1

 	nfmsg->version = NFNETLINK_V0;
 	nfmsg->res_id = htons(inst->group_num);
+	memset(&pmsg, 0, sizeof(pmsg));
 	pmsg.hw_protocol	= skb->protocol;
 	pmsg.hook		= hooknum;
 	if (indev && skb->dev &&
 	    skb->mac_header != skb->network_header) {
 		struct nfulnl_msg_packet_hw phw;
-		int len = dev_parse_header(skb, phw.hw_addr);
+		int len;
+		memset(&phw, 0, sizeof(phw));
+		len = dev_parse_header(skb, phw.hw_addr);
 		if (len > 0) {
 			phw.hw_addrlen = htons(len);
 			if (nla_put(inst->skb, NFULA_HWADDR, sizeof(phw), &phw))

net/netfilter/nfnetlink_queue_core.c+4−1

 	if (indev && entskb->dev &&
 	    entskb->mac_header != entskb->network_header) {
 		struct nfqnl_msg_packet_hw phw;
-		int len = dev_parse_header(entskb, phw.hw_addr);
+		int len;
+		memset(&phw, 0, sizeof(phw));
+		len = dev_parse_header(entskb, phw.hw_addr);
 		if (len) {
 			phw.hw_addrlen = htons(len);
 			if (nla_put(skb, NFQA_HWADDR, sizeof(phw), &phw))

net/netfilter/xt_TCPMSS.c+16−12

 {
 	const struct xt_tcpmss_info *info = par->targinfo;
 	struct tcphdr *tcph;
-	unsigned int tcplen, i;
+	int len, tcp_hdrlen;
+	unsigned int i;
 	__be16 oldval;
 	u16 newmss;
 	u8 *opt;
 	if (!skb_make_writable(skb, skb->len))
 		return -1;
-	tcplen = skb->len - tcphoff;
+	len = skb->len - tcphoff;
+	if (len < (int)sizeof(struct tcphdr))
+		return -1;
 	tcph = (struct tcphdr *)(skb_network_header(skb) + tcphoff);
+	tcp_hdrlen = tcph->doff * 4;
-	/* Header cannot be larger than the packet */
+	if (len < tcp_hdrlen)
-	if (tcplen < tcph->doff*4)
 		return -1;
 	if (info->mss == XT_TCPMSS_CLAMP_PMTU) {
 		newmss = info->mss;
 	opt = (u_int8_t *)tcph;
-	for (i = sizeof(struct tcphdr); i < tcph->doff*4; i += optlen(opt, i)) {
+	for (i = sizeof(struct tcphdr); i <= tcp_hdrlen - TCPOLEN_MSS; i += optlen(opt, i)) {
-		if (opt[i] == TCPOPT_MSS && tcph->doff*4 - i >= TCPOLEN_MSS &&
+		if (opt[i] == TCPOPT_MSS && opt[i+1] == TCPOLEN_MSS) {
-		    opt[i+1] == TCPOLEN_MSS) {
 			u_int16_t oldmss;
 			oldmss = (opt[i+2] << 8) | opt[i+3];
 	}
 	/* There is data after the header so the option can't be added
-	   without moving it, and doing so may make the SYN packet
+	 * without moving it, and doing so may make the SYN packet
-	   itself too large. Accept the packet unmodified instead. */
+	 * itself too large. Accept the packet unmodified instead.
-	if (tcplen > tcph->doff*4)
+	 */
+	if (len > tcp_hdrlen)
 		return 0;
 	/*
 		newmss = min(newmss, (u16)1220);
 	opt = (u_int8_t *)tcph + sizeof(struct tcphdr);
-	memmove(opt + TCPOLEN_MSS, opt, tcplen - sizeof(struct tcphdr));
+	memmove(opt + TCPOLEN_MSS, opt, len - sizeof(struct tcphdr));
 	inet_proto_csum_replace2(&tcph->check, skb,
-				 htons(tcplen), htons(tcplen + TCPOLEN_MSS), 1);
+				 htons(len), htons(len + TCPOLEN_MSS), 1);
 	opt[0] = TCPOPT_MSS;
 	opt[1] = TCPOLEN_MSS;
 	opt[2] = (newmss & 0xff00) >> 8;

net/netfilter/xt_TCPOPTSTRIP.c+6−4

 	struct tcphdr *tcph;
 	u_int16_t n, o;
 	u_int8_t *opt;
-	int len;
+	int len, tcp_hdrlen;
 	/* This is a fragment, no TCP header is available */
 	if (par->fragoff != 0)
 		return NF_DROP;
 	tcph = (struct tcphdr *)(skb_network_header(skb) + tcphoff);
-	if (tcph->doff * 4 > len)
+	tcp_hdrlen = tcph->doff * 4;
+	if (len < tcp_hdrlen)
 		return NF_DROP;
 	opt  = (u_int8_t *)tcph;
 	 * Walk through all TCP options - if we find some option to remove,
 	 * set all octets to %TCPOPT_NOP and adjust checksum.
 	 */
-	for (i = sizeof(struct tcphdr); i < tcp_hdrlen(skb); i += optl) {
+	for (i = sizeof(struct tcphdr); i < tcp_hdrlen - 1; i += optl) {
 		optl = optlen(opt, i);
-		if (i + optl > tcp_hdrlen(skb))
+		if (i + optl > tcp_hdrlen)
 			break;
 		if (!tcpoptstrip_test_bit(info->strip_bmap, opt[i]))

net/openvswitch/actions.c+1−0

@@ -535,6 +535,7 @@ int ovs_execute_actions(struct datapath dp, struct sk_buff skb) · 534 unmodified lines
535	{	535	{
536	struct sw_flow_actions *acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);	536	struct sw_flow_actions *acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);
537		537
		538	OVS_CB(skb)->tun_key = NULL;
538	return do_execute_actions(dp, skb, acts->actions,	539	return do_execute_actions(dp, skb, acts->actions,
539	acts->actions_len, false);	540	acts->actions_len, false);
540	}	541	}

net/openvswitch/datapath.c+0−3

@@ -2076,9 +2076,6 @@ static int ovs_vport_cmd_set(struct sk_buff skb, struct genl_info info) · 2075 unmodified lines
2076	ovs_notify(reply, info, &ovs_dp_vport_multicast_group);	2076	ovs_notify(reply, info, &ovs_dp_vport_multicast_group);
2077	return 0;	2077	return 0;
2078		2078
2079	rtnl_unlock();
2080	return 0;
2081
2082	exit_free:	2079	exit_free:
2083	kfree_skb(reply);	2080	kfree_skb(reply);
2084	exit_unlock:	2081	exit_unlock:

net/openvswitch/flow.c+1−1

@@ -240,7 +240,7 @@ static struct flex_array *alloc_buckets(unsigned int n_buckets) · 239 unmodified lines
240	struct flex_array *buckets;	240	struct flex_array *buckets;
241	int i, err;	241	int i, err;
242		242
243	buckets = flex_array_alloc(sizeof(struct hlist_head *),	243	buckets = flex_array_alloc(sizeof(struct hlist_head),
244	n_buckets, GFP_KERNEL);	244	n_buckets, GFP_KERNEL);
245	if (!buckets)	245	if (!buckets)
246	return NULL;	246	return NULL;

net/packet/af_packet.c+2−0

 		if (po->tp_version == TPACKET_V3) {
 			lv = sizeof(struct tpacket_stats_v3);
+			st.stats3.tp_packets += st.stats3.tp_drops;
 			data = &st.stats3;
 		} else {
 			lv = sizeof(struct tpacket_stats);
+			st.stats1.tp_packets += st.stats1.tp_drops;
 			data = &st.stats1;
 		}

net/sched/sch_api.c+41−0

@@ -285,6 +285,45 @@ static struct Qdisc_ops qdisc_lookup_ops(struct nlattr kind) · 284 unmodified lines
285	return q;	285	return q;
286	}	286	}
287		287
		288	/* The linklayer setting were not transferred from iproute2, in older
		289	* versions, and the rate tables lookup systems have been dropped in
		290	* the kernel. To keep backward compatible with older iproute2 tc
		291	* utils, we detect the linklayer setting by detecting if the rate
		292	* table were modified.
		293	*
		294	* For linklayer ATM table entries, the rate table will be aligned to
		295	* 48 bytes, thus some table entries will contain the same value. The
		296	* mpu (min packet unit) is also encoded into the old rate table, thus
		297	* starting from the mpu, we find low and high table entries for
		298	* mapping this cell. If these entries contain the same value, when
		299	* the rate tables have been modified for linklayer ATM.
		300	*
		301	* This is done by rounding mpu to the nearest 48 bytes cell/entry,
		302	* and then roundup to the next cell, calc the table entry one below,
		303	* and compare.
		304	*/
		305	static __u8 __detect_linklayer(struct tc_ratespec r, __u32 rtab)
		306	{
		307	int low = roundup(r->mpu, 48);
		308	int high = roundup(low+1, 48);
		309	int cell_low = low >> r->cell_log;
		310	int cell_high = (high >> r->cell_log) - 1;
		311
		312	/* rtab is too inaccurate at rates > 100Mbit/s */
		313	if ((r->rate > (100000000/8)) \|\| (rtab[0] == 0)) {
		314	pr_debug("TC linklayer: Giving up ATM detection\n");
		315	return TC_LINKLAYER_ETHERNET;
		316	}
		317
		318	if ((cell_high > cell_low) && (cell_high < 256)
		319	&& (rtab[cell_low] == rtab[cell_high])) {
		320	pr_debug("TC linklayer: Detected ATM, low(%d)=high(%d)=%u\n",
		321	cell_low, cell_high, rtab[cell_high]);
		322	return TC_LINKLAYER_ATM;
		323	}
		324	return TC_LINKLAYER_ETHERNET;
		325	}
		326
288	static struct qdisc_rate_table *qdisc_rtab_list;	327	static struct qdisc_rate_table *qdisc_rtab_list;
289		328
290	struct qdisc_rate_table qdisc_get_rtab(struct tc_ratespec r, struct nlattr *tab)	329	struct qdisc_rate_table qdisc_get_rtab(struct tc_ratespec r, struct nlattr *tab)
@@ -308,6 +347,8 @@ struct qdisc_rate_table qdisc_get_rtab(struct tc_ratespec r, struct nlattr *ta · 17 unmodified lines
308	rtab->rate = *r;	347	rtab->rate = *r;
309	rtab->refcnt = 1;	348	rtab->refcnt = 1;
310	memcpy(rtab->data, nla_data(tab), 1024);	349	memcpy(rtab->data, nla_data(tab), 1024);
		350	if (r->linklayer == TC_LINKLAYER_UNAWARE)
		351	r->linklayer = __detect_linklayer(r, rtab->data);
311	rtab->next = qdisc_rtab_list;	352	rtab->next = qdisc_rtab_list;
312	qdisc_rtab_list = rtab;	353	qdisc_rtab_list = rtab;
313	}	354	}

net/sched/sch_generic.c+7−1

 #include <linux/rcupdate.h>
 #include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/if_vlan.h>
 #include <net/sch_generic.h>
 #include <net/pkt_sched.h>
 #include <net/dst.h>
 unsigned long dev_trans_start(struct net_device *dev)
 {
-	unsigned long val, res = dev->trans_start;
+	unsigned long val, res;
 	unsigned int i;
+	if (is_vlan_dev(dev))
+		dev = vlan_dev_real_dev(dev);
+	res = dev->trans_start;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		val = netdev_get_tx_queue(dev, i)->trans_start;
 		if (val && time_after(val, res))
 			res = val;
 	}
 	dev->trans_start = res;
 	return res;
 }
 EXPORT_SYMBOL(dev_trans_start);
 	memset(r, 0, sizeof(*r));
 	r->overhead = conf->overhead;
 	r->rate_bytes_ps = conf->rate;
+	r->linklayer = (conf->linklayer & TC_LINKLAYER_MASK);
 	r->mult = 1;
 	/*
 	 * The deal here is to replace a divide by a reciprocal one

net/sched/sch_htb.c+13−0

@@ -1329,6 +1329,7 @@ static int htb_change_class(struct Qdisc *sch, u32 classid, · 1328 unmodified lines
1329	struct htb_sched *q = qdisc_priv(sch);	1329	struct htb_sched *q = qdisc_priv(sch);
1330	struct htb_class cl = (struct htb_class )arg, parent;	1330	struct htb_class cl = (struct htb_class )arg, parent;
1331	struct nlattr *opt = tca[TCA_OPTIONS];	1331	struct nlattr *opt = tca[TCA_OPTIONS];
		1332	struct qdisc_rate_table rtab = NULL, ctab = NULL;
1332	struct nlattr *tb[TCA_HTB_MAX + 1];	1333	struct nlattr *tb[TCA_HTB_MAX + 1];
1333	struct tc_htb_opt *hopt;	1334	struct tc_htb_opt *hopt;
1334		1335
@@ -1350,6 +1351,18 @@ static int htb_change_class(struct Qdisc *sch, u32 classid, · 15 unmodified lines
1350	if (!hopt->rate.rate \|\| !hopt->ceil.rate)	1351	if (!hopt->rate.rate \|\| !hopt->ceil.rate)
1351	goto failure;	1352	goto failure;
1352		1353
		1354	/* Keeping backward compatible with rate_table based iproute2 tc */
		1355	if (hopt->rate.linklayer == TC_LINKLAYER_UNAWARE) {
		1356	rtab = qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB]);
		1357	if (rtab)
		1358	qdisc_put_rtab(rtab);
		1359	}
		1360	if (hopt->ceil.linklayer == TC_LINKLAYER_UNAWARE) {
		1361	ctab = qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB]);
		1362	if (ctab)
		1363	qdisc_put_rtab(ctab);
		1364	}
		1365
1353	if (!cl) { /* new class */	1366	if (!cl) { /* new class */
1354	struct Qdisc *new_q;	1367	struct Qdisc *new_q;
1355	int prio;	1368	int prio;

net/sctp/associola.c+2−2

@@ -846,12 +846,12 @@ void sctp_assoc_control_transport(struct sctp_association *asoc, · 845 unmodified lines
846	else	846	else
847	spc_state = SCTP_ADDR_AVAILABLE;	847	spc_state = SCTP_ADDR_AVAILABLE;
848	/* Don't inform ULP about transition from PF to	848	/* Don't inform ULP about transition from PF to
849	* active state and set cwnd to 1, see SCTP	849	* active state and set cwnd to 1 MTU, see SCTP
850	* Quick failover draft section 5.1, point 5	850	* Quick failover draft section 5.1, point 5
851	*/	851	*/
852	if (transport->state == SCTP_PF) {	852	if (transport->state == SCTP_PF) {
853	ulp_notify = false;	853	ulp_notify = false;
854	transport->cwnd = 1;	854	transport->cwnd = asoc->pathmtu;
855	}	855	}
856	transport->state = SCTP_ACTIVE;	856	transport->state = SCTP_ACTIVE;
857	break;	857	break;

net/sctp/transport.c+2−2

 		return;
 	}
-	call_rcu(&transport->rcu, sctp_transport_destroy_rcu);
 	sctp_packet_free(&transport->packet);
 	if (transport->asoc)
 		sctp_association_put(transport->asoc);
+	call_rcu(&transport->rcu, sctp_transport_destroy_rcu);
 }
 /* Start T3_rtx timer if it is not already running and update the heartbeat

net/tipc/bearer.c+7−2

 {
 	struct tipc_link *l_ptr;
 	struct tipc_link *temp_l_ptr;
+	struct tipc_link_req *temp_req;
 	pr_info("Disabling bearer <%s>\n", b_ptr->name);
 	spin_lock_bh(&b_ptr->lock);
 	list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
 		tipc_link_delete(l_ptr);
 	}
-	if (b_ptr->link_req)
+	temp_req = b_ptr->link_req;
-		tipc_disc_delete(b_ptr->link_req);
+	b_ptr->link_req = NULL;
 	spin_unlock_bh(&b_ptr->lock);
+	if (temp_req)
+		tipc_disc_delete(temp_req);
 	memset(b_ptr, 0, sizeof(struct tipc_bearer));
 }

net/vmw_vsock/af_vsock.c+1−1

@@ -347,7 +347,7 @@ void vsock_for_each_connected_socket(void (fn)(struct sock sk)) · 346 unmodified lines
347	for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) {	347	for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) {
348	struct vsock_sock *vsk;	348	struct vsock_sock *vsk;
349	list_for_each_entry(vsk, &vsock_connected_table[i],	349	list_for_each_entry(vsk, &vsock_connected_table[i],
350	connected_table);	350	connected_table)
351	fn(sk_vsock(vsk));	351	fn(sk_vsock(vsk));
352	}	352	}
353		353

net/wireless/core.c+1−0

@@ -765,6 +765,7 @@ void cfg80211_leave(struct cfg80211_registered_device *rdev, · 764 unmodified lines
765	cfg80211_leave_mesh(rdev, dev);	765	cfg80211_leave_mesh(rdev, dev);
766	break;	766	break;
767	case NL80211_IFTYPE_AP:	767	case NL80211_IFTYPE_AP:
		768	case NL80211_IFTYPE_P2P_GO:
768	cfg80211_stop_ap(rdev, dev);	769	cfg80211_stop_ap(rdev, dev);
769	break;	770	break;
770	default:	771	default:

net/wireless/nl80211.c+15−13

@@ -441,10 +441,12 @@ static int nl80211_prepare_wdev_dump(struct sk_buff *skb, · 440 unmodified lines
441	goto out_unlock;	441	goto out_unlock;
442	}	442	}
443	rdev = wiphy_to_dev((wdev)->wiphy);	443	rdev = wiphy_to_dev((wdev)->wiphy);
444	cb->args[0] = (*rdev)->wiphy_idx;	444	/* 0 is the first index - add 1 to parse only once */
		445	cb->args[0] = (*rdev)->wiphy_idx + 1;
445	cb->args[1] = (*wdev)->identifier;	446	cb->args[1] = (*wdev)->identifier;
446	} else {	447	} else {
447	struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0]);	448	/* subtract the 1 again here */
		449	struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
448	struct wireless_dev *tmp;	450	struct wireless_dev *tmp;
449		451
450	if (!wiphy) {	452	if (!wiphy) {
@@ -2620,8 +2622,8 @@ static int nl80211_get_key(struct sk_buff skb, struct genl_info info) · 2169 unmodified lines
2620		2622
2621	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,	2623	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
2622	NL80211_CMD_NEW_KEY);	2624	NL80211_CMD_NEW_KEY);
2623	if (IS_ERR(hdr))	2625	if (!hdr)
2624	return PTR_ERR(hdr);	2626	return -ENOBUFS;
2625		2627
2626	cookie.msg = msg;	2628	cookie.msg = msg;
2627	cookie.idx = key_idx;	2629	cookie.idx = key_idx;
@@ -6505,6 +6507,9 @@ static int nl80211_testmode_dump(struct sk_buff *skb, · 3877 unmodified lines
6505	NL80211_CMD_TESTMODE);	6507	NL80211_CMD_TESTMODE);
6506	struct nlattr *tmdata;	6508	struct nlattr *tmdata;
6507		6509
		6510	if (!hdr)
		6511	break;
		6512
6508	if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {	6513	if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
6509	genlmsg_cancel(skb, hdr);	6514	genlmsg_cancel(skb, hdr);
6510	break;	6515	break;
@@ -6949,9 +6954,8 @@ static int nl80211_remain_on_channel(struct sk_buff *skb, · 438 unmodified lines
6949		6954
6950	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,	6955	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6951	NL80211_CMD_REMAIN_ON_CHANNEL);	6956	NL80211_CMD_REMAIN_ON_CHANNEL);
6952		6957	if (!hdr) {
6953	if (IS_ERR(hdr)) {	6958	err = -ENOBUFS;
6954	err = PTR_ERR(hdr);
6955	goto free_msg;	6959	goto free_msg;
6956	}	6960	}
6957		6961
@@ -7249,9 +7253,8 @@ static int nl80211_tx_mgmt(struct sk_buff skb, struct genl_info info) · 291 unmodified lines
7249		7253
7250	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,	7254	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7251	NL80211_CMD_FRAME);	7255	NL80211_CMD_FRAME);
7252		7256	if (!hdr) {
7253	if (IS_ERR(hdr)) {	7257	err = -ENOBUFS;
7254	err = PTR_ERR(hdr);
7255	goto free_msg;	7258	goto free_msg;
7256	}	7259	}
7257	}	7260	}
@@ -8130,9 +8133,8 @@ static int nl80211_probe_client(struct sk_buff *skb, · 872 unmodified lines
8130		8133
8131	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,	8134	hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8132	NL80211_CMD_PROBE_CLIENT);	8135	NL80211_CMD_PROBE_CLIENT);
8133		8136	if (!hdr) {
8134	if (IS_ERR(hdr)) {	8137	err = -ENOBUFS;
8135	err = PTR_ERR(hdr);
8136	goto free_msg;	8138	goto free_msg;
8137	}	8139	}
8138		8140

net/wireless/sme.c+4−6

 			struct net_device *dev, u16 reason, bool wextev)
 {
 	struct wireless_dev *wdev = dev->ieee80211_ptr;
-	int err;
+	int err = 0;
 	ASSERT_WDEV_LOCK(wdev);
 	kfree(wdev->connect_keys);
 	wdev->connect_keys = NULL;
-	if (wdev->conn) {
+	if (wdev->conn)
 		err = cfg80211_sme_disconnect(wdev, reason);
-	} else if (!rdev->ops->disconnect) {
+	else if (!rdev->ops->disconnect)
 		cfg80211_mlme_down(rdev, dev);
-		err = 0;
+	else if (wdev->current_bss)
-	} else {
 		err = rdev_disconnect(rdev, dev, reason);
-	}
 	return err;
 }

sound/pci/hda/hda_generic.c+3−3

@@ -522,7 +522,7 @@ static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1, · 521 unmodified lines
522	}	522	}
523		523
524	#define nid_has_mute(codec, nid, dir) \	524	#define nid_has_mute(codec, nid, dir) \
525	check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)	525	check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE \| AC_AMPCAP_MIN_MUTE))
526	#define nid_has_volume(codec, nid, dir) \	526	#define nid_has_volume(codec, nid, dir) \
527	check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)	527	check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
528		528
@@ -624,7 +624,7 @@ static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid, · 95 unmodified lines
624	if (enable)	624	if (enable)
625	val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;	625	val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
626	}	626	}
627	if (caps & AC_AMPCAP_MUTE) {	627	if (caps & (AC_AMPCAP_MUTE \| AC_AMPCAP_MIN_MUTE)) {
628	if (!enable)	628	if (!enable)
629	val \|= HDA_AMP_MUTE;	629	val \|= HDA_AMP_MUTE;
630	}	630	}
@@ -648,7 +648,7 @@ static unsigned int get_amp_mask_to_modify(struct hda_codec *codec, · 17 unmodified lines
648	{	648	{
649	unsigned int mask = 0xff;	649	unsigned int mask = 0xff;
650		650
651	if (caps & AC_AMPCAP_MUTE) {	651	if (caps & (AC_AMPCAP_MUTE \| AC_AMPCAP_MIN_MUTE)) {
652	if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))	652	if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
653	mask &= ~0x80;	653	mask &= ~0x80;
654	}	654	}

sound/pci/hda/patch_realtek.c+11−0

 	ALC880_FIXUP_GPIO2,
 	ALC880_FIXUP_MEDION_RIM,
 	ALC880_FIXUP_LG,
+	ALC880_FIXUP_LG_LW25,
 	ALC880_FIXUP_W810,
 	ALC880_FIXUP_EAPD_COEF,
 	ALC880_FIXUP_TCL_S700,
 			{ }
 		}
 	},
+	[ALC880_FIXUP_LG_LW25] = {
+		.type = HDA_FIXUP_PINS,
+		.v.pins = (const struct hda_pintbl[]) {
+			{ 0x1a, 0x0181344f }, /* line-in */
+			{ 0x1b, 0x0321403f }, /* headphone */
+			{ }
+		}
+	},
 	[ALC880_FIXUP_W810] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
 	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
+	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
 	/* Below is the copied entries from alc880_quirks.c.
 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
+	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

sound/soc/codecs/cs42l52.c+4−1

 static DECLARE_TLV_DB_SCALE(mix_tlv, -50, 50, 0);
+static DECLARE_TLV_DB_SCALE(beep_tlv, -56, 200, 0);
 static const unsigned int limiter_tlv[] = {
 	TLV_DB_RANGE_HEAD(2),
 	0, 2, TLV_DB_SCALE_ITEM(-3000, 600, 0),
 	SOC_ENUM("Beep Pitch", beep_pitch_enum),
 	SOC_ENUM("Beep on Time", beep_ontime_enum),
 	SOC_ENUM("Beep off Time", beep_offtime_enum),
-	SOC_SINGLE_TLV("Beep Volume", CS42L52_BEEP_VOL, 0, 0x1f, 0x07, hl_tlv),
+	SOC_SINGLE_SX_TLV("Beep Volume", CS42L52_BEEP_VOL,
+			0, 0x07, 0x1f, beep_tlv),
 	SOC_SINGLE("Beep Mixer Switch", CS42L52_BEEP_TONE_CTL, 5, 1, 1),
 	SOC_ENUM("Beep Treble Corner Freq", beep_treble_enum),
 	SOC_ENUM("Beep Bass Corner Freq", beep_bass_enum),

sound/soc/codecs/sgtl5000.c+14−4

 static int power_vag_event(struct snd_soc_dapm_widget *w,
 	struct snd_kcontrol *kcontrol, int event)
 {
+	const u32 mask = SGTL5000_DAC_POWERUP | SGTL5000_ADC_POWERUP;
 	switch (event) {
 	case SND_SOC_DAPM_POST_PMU:
 		snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
 		break;
 	case SND_SOC_DAPM_PRE_PMD:
-		snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
+		/*
-			SGTL5000_VAG_POWERUP, 0);
+		 * Don't clear VAG_POWERUP, when both DAC and ADC are
-		msleep(400);
+		 * operational to prevent inadvertently starving the
+		 * other one of them.
+		 */
+		if ((snd_soc_read(w->codec, SGTL5000_CHIP_ANA_POWER) &
+				mask) != mask) {
+			snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
+				SGTL5000_VAG_POWERUP, 0);
+			msleep(400);
+		}
 		break;
 	default:
 		break;
 	SOC_DOUBLE("Capture Volume", SGTL5000_CHIP_ANA_ADC_CTRL, 0, 4, 0xf, 0),
 	SOC_SINGLE_TLV("Capture Attenuate Switch (-6dB)",
 			SGTL5000_CHIP_ANA_ADC_CTRL,
-			8, 2, 0, capture_6db_attenuate),
+			8, 1, 0, capture_6db_attenuate),
 	SOC_SINGLE("Capture ZC Switch", SGTL5000_CHIP_ANA_CTRL, 1, 1, 0),
 	SOC_DOUBLE_TLV("Headphone Playback Volume",

sound/soc/soc-dapm.c+4−3

 		return -EINVAL;
 	}
-	path = list_first_entry(&w->sources, struct snd_soc_dapm_path,
+	if (list_empty(&w->sources)) {
-				list_sink);
-	if (!path) {
 		dev_err(dapm->dev, "ASoC: mux %s has no paths\n", w->name);
 		return -EINVAL;
 	}
+	path = list_first_entry(&w->sources, struct snd_soc_dapm_path,
+				list_sink);
 	ret = dapm_create_or_share_mixmux_kcontrol(w, 0, path);
 	if (ret < 0)
 		return ret;

sound/soc/tegra/tegra30_i2s.c+1−1

@@ -228,7 +228,7 @@ static int tegra30_i2s_hw_params(struct snd_pcm_substream *substream, · 227 unmodified lines
228	reg = TEGRA30_I2S_CIF_RX_CTRL;	228	reg = TEGRA30_I2S_CIF_RX_CTRL;
229	} else {	229	} else {
230	val \|= TEGRA30_AUDIOCIF_CTRL_DIRECTION_TX;	230	val \|= TEGRA30_AUDIOCIF_CTRL_DIRECTION_TX;
231	reg = TEGRA30_I2S_CIF_RX_CTRL;	231	reg = TEGRA30_I2S_CIF_TX_CTRL;
232	}	232	}
233		233
234	regmap_write(i2s->regmap, reg, val);	234	regmap_write(i2s->regmap, reg, val);

sound/usb/6fire/midi.c+15−1

 #include "chip.h"
 #include "comm.h"
+enum {
+	MIDI_BUFSIZE = 64
+};
 static void usb6fire_midi_out_handler(struct urb *urb)
 {
 	struct midi_runtime *rt = urb->context;
 	if (!rt)
 		return -ENOMEM;
+	rt->out_buffer = kzalloc(MIDI_BUFSIZE, GFP_KERNEL);
+	if (!rt->out_buffer) {
+		kfree(rt);
+		return -ENOMEM;
+	}
 	rt->chip = chip;
 	rt->in_received = usb6fire_midi_in_received;
 	rt->out_buffer[0] = 0x80; /* 'send midi' command */
 	ret = snd_rawmidi_new(chip->card, "6FireUSB", 0, 1, 1, &rt->instance);
 	if (ret < 0) {
+		kfree(rt->out_buffer);
 		kfree(rt);
 		snd_printk(KERN_ERR PREFIX "unable to create midi.\n");
 		return ret;
 void usb6fire_midi_destroy(struct sfire_chip *chip)
 {
-	kfree(chip->midi);
+	struct midi_runtime *rt = chip->midi;
+	kfree(rt->out_buffer);
+	kfree(rt);
 	chip->midi = NULL;
 }

sound/usb/6fire/midi.h+1−5

 #include "common.h"
-enum {
-	MIDI_BUFSIZE = 64
-};
 struct midi_runtime {
 	struct sfire_chip *chip;
 	struct snd_rawmidi *instance;
 	struct snd_rawmidi_substream *out;
 	struct urb out_urb;
 	u8 out_serial; /* serial number of out packet */
-	u8 out_buffer[MIDI_BUFSIZE];
+	u8 *out_buffer;
 	int buffer_offset;
 	void (*in_received)(struct midi_runtime *rt, u8 *data, int length);

sound/usb/6fire/pcm.c+40−1

@@ -582,6 +582,33 @@ static void usb6fire_pcm_init_urb(struct pcm_urb *urb, · 581 unmodified lines
582	urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;	582	urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
583	}	583	}
584		584
		585	static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
		586	{
		587	int i;
		588
		589	for (i = 0; i < PCM_N_URBS; i++) {
		590	rt->out_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB
		591	* PCM_MAX_PACKET_SIZE, GFP_KERNEL);
		592	if (!rt->out_urbs[i].buffer)
		593	return -ENOMEM;
		594	rt->in_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB
		595	* PCM_MAX_PACKET_SIZE, GFP_KERNEL);
		596	if (!rt->in_urbs[i].buffer)
		597	return -ENOMEM;
		598	}
		599	return 0;
		600	}
		601
		602	static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
		603	{
		604	int i;
		605
		606	for (i = 0; i < PCM_N_URBS; i++) {
		607	kfree(rt->out_urbs[i].buffer);
		608	kfree(rt->in_urbs[i].buffer);
		609	}
		610	}
		611
585	int usb6fire_pcm_init(struct sfire_chip *chip)	612	int usb6fire_pcm_init(struct sfire_chip *chip)
586	{	613	{
587	int i;	614	int i;
@@ -593,6 +620,13 @@ int usb6fire_pcm_init(struct sfire_chip *chip) · 5 unmodified lines
593	if (!rt)	620	if (!rt)
594	return -ENOMEM;	621	return -ENOMEM;
595		622
		623	ret = usb6fire_pcm_buffers_init(rt);
		624	if (ret) {
		625	usb6fire_pcm_buffers_destroy(rt);
		626	kfree(rt);
		627	return ret;
		628	}
		629
596	rt->chip = chip;	630	rt->chip = chip;
597	rt->stream_state = STREAM_DISABLED;	631	rt->stream_state = STREAM_DISABLED;
598	rt->rate = ARRAY_SIZE(rates);	632	rt->rate = ARRAY_SIZE(rates);
@@ -614,6 +648,7 @@ int usb6fire_pcm_init(struct sfire_chip *chip) · 15 unmodified lines
614		648
615	ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);	649	ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
616	if (ret < 0) {	650	if (ret < 0) {
		651	usb6fire_pcm_buffers_destroy(rt);
617	kfree(rt);	652	kfree(rt);
618	snd_printk(KERN_ERR PREFIX "cannot create pcm instance.\n");	653	snd_printk(KERN_ERR PREFIX "cannot create pcm instance.\n");
619	return ret;	654	return ret;
@@ -625,6 +660,7 @@ int usb6fire_pcm_init(struct sfire_chip *chip) · 5 unmodified lines
625	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);	660	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);
626		661
627	if (ret) {	662	if (ret) {
		663	usb6fire_pcm_buffers_destroy(rt);
628	kfree(rt);	664	kfree(rt);
629	snd_printk(KERN_ERR PREFIX	665	snd_printk(KERN_ERR PREFIX
630	"error preallocating pcm buffers.\n");	666	"error preallocating pcm buffers.\n");
@@ -669,6 +705,9 @@ void usb6fire_pcm_abort(struct sfire_chip *chip) · 38 unmodified lines
669		705
670	void usb6fire_pcm_destroy(struct sfire_chip *chip)	706	void usb6fire_pcm_destroy(struct sfire_chip *chip)
671	{	707	{
672	kfree(chip->pcm);	708	struct pcm_runtime *rt = chip->pcm;
		709
		710	usb6fire_pcm_buffers_destroy(rt);
		711	kfree(rt);
673	chip->pcm = NULL;	712	chip->pcm = NULL;
674	}	713	}

sound/usb/6fire/pcm.h+1−1

@@ -32,7 +32,7 @@ struct pcm_urb { · 31 unmodified lines
32	struct urb instance;	32	struct urb instance;
33	struct usb_iso_packet_descriptor packets[PCM_N_PACKETS_PER_URB];	33	struct usb_iso_packet_descriptor packets[PCM_N_PACKETS_PER_URB];
34	/* END DO NOT SEPARATE */	34	/* END DO NOT SEPARATE */
35	u8 buffer[PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE];	35	u8 *buffer;
36		36
37	struct pcm_urb *peer;	37	struct pcm_urb *peer;
38	};	38	};

sound/usb/mixer.c+1−0

@@ -888,6 +888,7 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval, · 887 unmodified lines
888	case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */	888	case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */
889	case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */	889	case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
890	case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */	890	case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */
		891	case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */
891	case USB_ID(0x046d, 0x0991):	892	case USB_ID(0x046d, 0x0991):
892	/* Most audio usb devices lie about volume resolution.	893	/* Most audio usb devices lie about volume resolution.
893	* Most Logitech webcams have res = 384.	894	* Most Logitech webcams have res = 384.

sound/usb/quirks.c+3−3

@@ -319,19 +319,19 @@ static int create_auto_midi_quirk(struct snd_usb_audio *chip, · 318 unmodified lines
319	if (altsd->bNumEndpoints < 1)	319	if (altsd->bNumEndpoints < 1)
320	return -ENODEV;	320	return -ENODEV;
321	epd = get_endpoint(alts, 0);	321	epd = get_endpoint(alts, 0);
322	if (!usb_endpoint_xfer_bulk(epd) \|\|	322	if (!usb_endpoint_xfer_bulk(epd) &&
323	!usb_endpoint_xfer_int(epd))	323	!usb_endpoint_xfer_int(epd))
324	return -ENODEV;	324	return -ENODEV;
325		325
326	switch (USB_ID_VENDOR(chip->usb_id)) {	326	switch (USB_ID_VENDOR(chip->usb_id)) {
327	case 0x0499: /* Yamaha */	327	case 0x0499: /* Yamaha */
328	err = create_yamaha_midi_quirk(chip, iface, driver, alts);	328	err = create_yamaha_midi_quirk(chip, iface, driver, alts);
329	if (err < 0 && err != -ENODEV)	329	if (err != -ENODEV)
330	return err;	330	return err;
331	break;	331	break;
332	case 0x0582: /* Roland */	332	case 0x0582: /* Roland */
333	err = create_roland_midi_quirk(chip, iface, driver, alts);	333	err = create_roland_midi_quirk(chip, iface, driver, alts);
334	if (err < 0 && err != -ENODEV)	334	if (err != -ENODEV)
335	return err;	335	return err;
336	break;	336	break;
337	}	337	}