Annotation of /trunk/kernel26-alx/patches-2.6.33-r1/0102-2.6.33.3-all-fixes.patch
Parent Directory | Revision Log
Revision 1178 -
(hide annotations)
(download)
Thu Oct 14 20:10:01 2010 UTC (13 years, 11 months ago) by niro
File size: 169949 byte(s)
Thu Oct 14 20:10:01 2010 UTC (13 years, 11 months ago) by niro
File size: 169949 byte(s)
-2.6.33-alx-r1: new magellan 0.5.2 kernel
1 | niro | 1178 | diff --git a/Documentation/i2c/busses/i2c-i801 b/Documentation/i2c/busses/i2c-i801 |
2 | index 81c0c59..e1bb5b2 100644 | ||
3 | --- a/Documentation/i2c/busses/i2c-i801 | ||
4 | +++ b/Documentation/i2c/busses/i2c-i801 | ||
5 | @@ -15,7 +15,8 @@ Supported adapters: | ||
6 | * Intel 82801I (ICH9) | ||
7 | * Intel EP80579 (Tolapai) | ||
8 | * Intel 82801JI (ICH10) | ||
9 | - * Intel PCH | ||
10 | + * Intel 3400/5 Series (PCH) | ||
11 | + * Intel Cougar Point (PCH) | ||
12 | Datasheets: Publicly available at the Intel website | ||
13 | |||
14 | Authors: | ||
15 | diff --git a/arch/arm/boot/compressed/head.S b/arch/arm/boot/compressed/head.S | ||
16 | index 6b84a04..cbeb6e0 100644 | ||
17 | --- a/arch/arm/boot/compressed/head.S | ||
18 | +++ b/arch/arm/boot/compressed/head.S | ||
19 | @@ -172,7 +172,7 @@ not_angel: | ||
20 | adr r0, LC0 | ||
21 | ARM( ldmia r0, {r1, r2, r3, r4, r5, r6, r11, ip, sp}) | ||
22 | THUMB( ldmia r0, {r1, r2, r3, r4, r5, r6, r11, ip} ) | ||
23 | - THUMB( ldr sp, [r0, #28] ) | ||
24 | + THUMB( ldr sp, [r0, #32] ) | ||
25 | subs r0, r0, r1 @ calculate the delta offset | ||
26 | |||
27 | @ if delta is zero, we are | ||
28 | diff --git a/arch/ia64/kvm/kvm-ia64.c b/arch/ia64/kvm/kvm-ia64.c | ||
29 | index 5fdeec5..d76279a 100644 | ||
30 | --- a/arch/ia64/kvm/kvm-ia64.c | ||
31 | +++ b/arch/ia64/kvm/kvm-ia64.c | ||
32 | @@ -1794,7 +1794,8 @@ static int kvm_ia64_sync_dirty_log(struct kvm *kvm, | ||
33 | { | ||
34 | struct kvm_memory_slot *memslot; | ||
35 | int r, i; | ||
36 | - long n, base; | ||
37 | + long base; | ||
38 | + unsigned long n; | ||
39 | unsigned long *dirty_bitmap = (unsigned long *)(kvm->arch.vm_base + | ||
40 | offsetof(struct kvm_vm_data, kvm_mem_dirty_log)); | ||
41 | |||
42 | @@ -1807,7 +1808,7 @@ static int kvm_ia64_sync_dirty_log(struct kvm *kvm, | ||
43 | if (!memslot->dirty_bitmap) | ||
44 | goto out; | ||
45 | |||
46 | - n = ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
47 | + n = kvm_dirty_bitmap_bytes(memslot); | ||
48 | base = memslot->base_gfn / BITS_PER_LONG; | ||
49 | |||
50 | for (i = 0; i < n/sizeof(long); ++i) { | ||
51 | @@ -1823,7 +1824,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
52 | struct kvm_dirty_log *log) | ||
53 | { | ||
54 | int r; | ||
55 | - int n; | ||
56 | + unsigned long n; | ||
57 | struct kvm_memory_slot *memslot; | ||
58 | int is_dirty = 0; | ||
59 | |||
60 | @@ -1841,7 +1842,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
61 | if (is_dirty) { | ||
62 | kvm_flush_remote_tlbs(kvm); | ||
63 | memslot = &kvm->memslots[log->slot]; | ||
64 | - n = ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
65 | + n = kvm_dirty_bitmap_bytes(memslot); | ||
66 | memset(memslot->dirty_bitmap, 0, n); | ||
67 | } | ||
68 | r = 0; | ||
69 | diff --git a/arch/powerpc/kvm/book3s.c b/arch/powerpc/kvm/book3s.c | ||
70 | index 3e294bd..e6dc595 100644 | ||
71 | --- a/arch/powerpc/kvm/book3s.c | ||
72 | +++ b/arch/powerpc/kvm/book3s.c | ||
73 | @@ -848,7 +848,8 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
74 | struct kvm_vcpu *vcpu; | ||
75 | ulong ga, ga_end; | ||
76 | int is_dirty = 0; | ||
77 | - int r, n; | ||
78 | + int r; | ||
79 | + unsigned long n; | ||
80 | |||
81 | down_write(&kvm->slots_lock); | ||
82 | |||
83 | @@ -866,7 +867,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
84 | kvm_for_each_vcpu(n, vcpu, kvm) | ||
85 | kvmppc_mmu_pte_pflush(vcpu, ga, ga_end); | ||
86 | |||
87 | - n = ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
88 | + n = kvm_dirty_bitmap_bytes(memslot); | ||
89 | memset(memslot->dirty_bitmap, 0, n); | ||
90 | } | ||
91 | |||
92 | diff --git a/arch/powerpc/platforms/pseries/offline_states.h b/arch/powerpc/platforms/pseries/offline_states.h | ||
93 | index 22574e0..202d869 100644 | ||
94 | --- a/arch/powerpc/platforms/pseries/offline_states.h | ||
95 | +++ b/arch/powerpc/platforms/pseries/offline_states.h | ||
96 | @@ -9,10 +9,30 @@ enum cpu_state_vals { | ||
97 | CPU_MAX_OFFLINE_STATES | ||
98 | }; | ||
99 | |||
100 | +#ifdef CONFIG_HOTPLUG_CPU | ||
101 | extern enum cpu_state_vals get_cpu_current_state(int cpu); | ||
102 | extern void set_cpu_current_state(int cpu, enum cpu_state_vals state); | ||
103 | -extern enum cpu_state_vals get_preferred_offline_state(int cpu); | ||
104 | extern void set_preferred_offline_state(int cpu, enum cpu_state_vals state); | ||
105 | extern void set_default_offline_state(int cpu); | ||
106 | +#else | ||
107 | +static inline enum cpu_state_vals get_cpu_current_state(int cpu) | ||
108 | +{ | ||
109 | + return CPU_STATE_ONLINE; | ||
110 | +} | ||
111 | + | ||
112 | +static inline void set_cpu_current_state(int cpu, enum cpu_state_vals state) | ||
113 | +{ | ||
114 | +} | ||
115 | + | ||
116 | +static inline void set_preferred_offline_state(int cpu, enum cpu_state_vals state) | ||
117 | +{ | ||
118 | +} | ||
119 | + | ||
120 | +static inline void set_default_offline_state(int cpu) | ||
121 | +{ | ||
122 | +} | ||
123 | +#endif | ||
124 | + | ||
125 | +extern enum cpu_state_vals get_preferred_offline_state(int cpu); | ||
126 | extern int start_secondary(void); | ||
127 | #endif | ||
128 | diff --git a/arch/s390/mm/vmem.c b/arch/s390/mm/vmem.c | ||
129 | index 300ab01..5f91a38 100644 | ||
130 | --- a/arch/s390/mm/vmem.c | ||
131 | +++ b/arch/s390/mm/vmem.c | ||
132 | @@ -70,12 +70,8 @@ static pte_t __ref *vmem_pte_alloc(void) | ||
133 | pte = alloc_bootmem(PTRS_PER_PTE * sizeof(pte_t)); | ||
134 | if (!pte) | ||
135 | return NULL; | ||
136 | - if (MACHINE_HAS_HPAGE) | ||
137 | - clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY | _PAGE_CO, | ||
138 | - PTRS_PER_PTE * sizeof(pte_t)); | ||
139 | - else | ||
140 | - clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY, | ||
141 | - PTRS_PER_PTE * sizeof(pte_t)); | ||
142 | + clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY, | ||
143 | + PTRS_PER_PTE * sizeof(pte_t)); | ||
144 | return pte; | ||
145 | } | ||
146 | |||
147 | @@ -116,8 +112,7 @@ static int vmem_add_mem(unsigned long start, unsigned long size, int ro) | ||
148 | if (MACHINE_HAS_HPAGE && !(address & ~HPAGE_MASK) && | ||
149 | (address + HPAGE_SIZE <= start + size) && | ||
150 | (address >= HPAGE_SIZE)) { | ||
151 | - pte_val(pte) |= _SEGMENT_ENTRY_LARGE | | ||
152 | - _SEGMENT_ENTRY_CO; | ||
153 | + pte_val(pte) |= _SEGMENT_ENTRY_LARGE; | ||
154 | pmd_val(*pm_dir) = pte_val(pte); | ||
155 | address += HPAGE_SIZE - PAGE_SIZE; | ||
156 | continue; | ||
157 | diff --git a/arch/sh/include/asm/elf.h b/arch/sh/include/asm/elf.h | ||
158 | index ac04255..ce830fa 100644 | ||
159 | --- a/arch/sh/include/asm/elf.h | ||
160 | +++ b/arch/sh/include/asm/elf.h | ||
161 | @@ -211,7 +211,9 @@ extern void __kernel_vsyscall; | ||
162 | |||
163 | #define VSYSCALL_AUX_ENT \ | ||
164 | if (vdso_enabled) \ | ||
165 | - NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_BASE); | ||
166 | + NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_BASE); \ | ||
167 | + else \ | ||
168 | + NEW_AUX_ENT(AT_IGNORE, 0); | ||
169 | #else | ||
170 | #define VSYSCALL_AUX_ENT | ||
171 | #endif /* CONFIG_VSYSCALL */ | ||
172 | @@ -219,7 +221,7 @@ extern void __kernel_vsyscall; | ||
173 | #ifdef CONFIG_SH_FPU | ||
174 | #define FPU_AUX_ENT NEW_AUX_ENT(AT_FPUCW, FPSCR_INIT) | ||
175 | #else | ||
176 | -#define FPU_AUX_ENT | ||
177 | +#define FPU_AUX_ENT NEW_AUX_ENT(AT_IGNORE, 0) | ||
178 | #endif | ||
179 | |||
180 | extern int l1i_cache_shape, l1d_cache_shape, l2_cache_shape; | ||
181 | diff --git a/arch/sh/kernel/smp.c b/arch/sh/kernel/smp.c | ||
182 | index 983e079..1d19c19 100644 | ||
183 | --- a/arch/sh/kernel/smp.c | ||
184 | +++ b/arch/sh/kernel/smp.c | ||
185 | @@ -69,6 +69,7 @@ asmlinkage void __cpuinit start_secondary(void) | ||
186 | unsigned int cpu; | ||
187 | struct mm_struct *mm = &init_mm; | ||
188 | |||
189 | + enable_mmu(); | ||
190 | atomic_inc(&mm->mm_count); | ||
191 | atomic_inc(&mm->mm_users); | ||
192 | current->active_mm = mm; | ||
193 | diff --git a/arch/sparc/kernel/ptrace_32.c b/arch/sparc/kernel/ptrace_32.c | ||
194 | index 7e3dfd9..e608f39 100644 | ||
195 | --- a/arch/sparc/kernel/ptrace_32.c | ||
196 | +++ b/arch/sparc/kernel/ptrace_32.c | ||
197 | @@ -65,6 +65,7 @@ static int genregs32_get(struct task_struct *target, | ||
198 | *k++ = regs->u_regs[pos++]; | ||
199 | |||
200 | reg_window = (unsigned long __user *) regs->u_regs[UREG_I6]; | ||
201 | + reg_window -= 16; | ||
202 | for (; count > 0 && pos < 32; count--) { | ||
203 | if (get_user(*k++, ®_window[pos++])) | ||
204 | return -EFAULT; | ||
205 | @@ -76,6 +77,7 @@ static int genregs32_get(struct task_struct *target, | ||
206 | } | ||
207 | |||
208 | reg_window = (unsigned long __user *) regs->u_regs[UREG_I6]; | ||
209 | + reg_window -= 16; | ||
210 | for (; count > 0 && pos < 32; count--) { | ||
211 | if (get_user(reg, ®_window[pos++]) || | ||
212 | put_user(reg, u++)) | ||
213 | @@ -141,6 +143,7 @@ static int genregs32_set(struct task_struct *target, | ||
214 | regs->u_regs[pos++] = *k++; | ||
215 | |||
216 | reg_window = (unsigned long __user *) regs->u_regs[UREG_I6]; | ||
217 | + reg_window -= 16; | ||
218 | for (; count > 0 && pos < 32; count--) { | ||
219 | if (put_user(*k++, ®_window[pos++])) | ||
220 | return -EFAULT; | ||
221 | @@ -153,6 +156,7 @@ static int genregs32_set(struct task_struct *target, | ||
222 | } | ||
223 | |||
224 | reg_window = (unsigned long __user *) regs->u_regs[UREG_I6]; | ||
225 | + reg_window -= 16; | ||
226 | for (; count > 0 && pos < 32; count--) { | ||
227 | if (get_user(reg, u++) || | ||
228 | put_user(reg, ®_window[pos++])) | ||
229 | diff --git a/arch/sparc/kernel/ptrace_64.c b/arch/sparc/kernel/ptrace_64.c | ||
230 | index 2f6524d..aa90da0 100644 | ||
231 | --- a/arch/sparc/kernel/ptrace_64.c | ||
232 | +++ b/arch/sparc/kernel/ptrace_64.c | ||
233 | @@ -492,6 +492,7 @@ static int genregs32_get(struct task_struct *target, | ||
234 | *k++ = regs->u_regs[pos++]; | ||
235 | |||
236 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | ||
237 | + reg_window -= 16; | ||
238 | if (target == current) { | ||
239 | for (; count > 0 && pos < 32; count--) { | ||
240 | if (get_user(*k++, ®_window[pos++])) | ||
241 | @@ -516,6 +517,7 @@ static int genregs32_get(struct task_struct *target, | ||
242 | } | ||
243 | |||
244 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | ||
245 | + reg_window -= 16; | ||
246 | if (target == current) { | ||
247 | for (; count > 0 && pos < 32; count--) { | ||
248 | if (get_user(reg, ®_window[pos++]) || | ||
249 | @@ -599,6 +601,7 @@ static int genregs32_set(struct task_struct *target, | ||
250 | regs->u_regs[pos++] = *k++; | ||
251 | |||
252 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | ||
253 | + reg_window -= 16; | ||
254 | if (target == current) { | ||
255 | for (; count > 0 && pos < 32; count--) { | ||
256 | if (put_user(*k++, ®_window[pos++])) | ||
257 | @@ -625,6 +628,7 @@ static int genregs32_set(struct task_struct *target, | ||
258 | } | ||
259 | |||
260 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | ||
261 | + reg_window -= 16; | ||
262 | if (target == current) { | ||
263 | for (; count > 0 && pos < 32; count--) { | ||
264 | if (get_user(reg, u++) || | ||
265 | diff --git a/arch/um/sys-x86_64/Makefile b/arch/um/sys-x86_64/Makefile | ||
266 | index 2201e9c..c1ea9eb 100644 | ||
267 | --- a/arch/um/sys-x86_64/Makefile | ||
268 | +++ b/arch/um/sys-x86_64/Makefile | ||
269 | @@ -8,7 +8,8 @@ obj-y = bug.o bugs.o delay.o fault.o ldt.o mem.o ptrace.o ptrace_user.o \ | ||
270 | setjmp.o signal.o stub.o stub_segv.o syscalls.o syscall_table.o \ | ||
271 | sysrq.o ksyms.o tls.o | ||
272 | |||
273 | -subarch-obj-y = lib/csum-partial_64.o lib/memcpy_64.o lib/thunk_64.o | ||
274 | +subarch-obj-y = lib/csum-partial_64.o lib/memcpy_64.o lib/thunk_64.o \ | ||
275 | + lib/rwsem_64.o | ||
276 | subarch-obj-$(CONFIG_MODULES) += kernel/module.o | ||
277 | |||
278 | ldt-y = ../sys-i386/ldt.o | ||
279 | diff --git a/arch/x86/Kconfig.cpu b/arch/x86/Kconfig.cpu | ||
280 | index f20ddf8..a198293 100644 | ||
281 | --- a/arch/x86/Kconfig.cpu | ||
282 | +++ b/arch/x86/Kconfig.cpu | ||
283 | @@ -319,7 +319,7 @@ config X86_L1_CACHE_SHIFT | ||
284 | |||
285 | config X86_XADD | ||
286 | def_bool y | ||
287 | - depends on X86_32 && !M386 | ||
288 | + depends on X86_64 || !M386 | ||
289 | |||
290 | config X86_PPRO_FENCE | ||
291 | bool "PentiumPro memory ordering errata workaround" | ||
292 | diff --git a/arch/x86/include/asm/rwsem.h b/arch/x86/include/asm/rwsem.h | ||
293 | index ca7517d..606ede1 100644 | ||
294 | --- a/arch/x86/include/asm/rwsem.h | ||
295 | +++ b/arch/x86/include/asm/rwsem.h | ||
296 | @@ -41,6 +41,7 @@ | ||
297 | #include <linux/list.h> | ||
298 | #include <linux/spinlock.h> | ||
299 | #include <linux/lockdep.h> | ||
300 | +#include <asm/asm.h> | ||
301 | |||
302 | struct rwsem_waiter; | ||
303 | |||
304 | @@ -55,17 +56,28 @@ extern asmregparm struct rw_semaphore * | ||
305 | |||
306 | /* | ||
307 | * the semaphore definition | ||
308 | + * | ||
309 | + * The bias values and the counter type limits the number of | ||
310 | + * potential readers/writers to 32767 for 32 bits and 2147483647 | ||
311 | + * for 64 bits. | ||
312 | */ | ||
313 | |||
314 | -#define RWSEM_UNLOCKED_VALUE 0x00000000 | ||
315 | -#define RWSEM_ACTIVE_BIAS 0x00000001 | ||
316 | -#define RWSEM_ACTIVE_MASK 0x0000ffff | ||
317 | -#define RWSEM_WAITING_BIAS (-0x00010000) | ||
318 | +#ifdef CONFIG_X86_64 | ||
319 | +# define RWSEM_ACTIVE_MASK 0xffffffffL | ||
320 | +#else | ||
321 | +# define RWSEM_ACTIVE_MASK 0x0000ffffL | ||
322 | +#endif | ||
323 | + | ||
324 | +#define RWSEM_UNLOCKED_VALUE 0x00000000L | ||
325 | +#define RWSEM_ACTIVE_BIAS 0x00000001L | ||
326 | +#define RWSEM_WAITING_BIAS (-RWSEM_ACTIVE_MASK-1) | ||
327 | #define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS | ||
328 | #define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS) | ||
329 | |||
330 | +typedef signed long rwsem_count_t; | ||
331 | + | ||
332 | struct rw_semaphore { | ||
333 | - signed long count; | ||
334 | + rwsem_count_t count; | ||
335 | spinlock_t wait_lock; | ||
336 | struct list_head wait_list; | ||
337 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
338 | @@ -105,7 +117,7 @@ do { \ | ||
339 | static inline void __down_read(struct rw_semaphore *sem) | ||
340 | { | ||
341 | asm volatile("# beginning down_read\n\t" | ||
342 | - LOCK_PREFIX " incl (%%eax)\n\t" | ||
343 | + LOCK_PREFIX _ASM_INC "(%1)\n\t" | ||
344 | /* adds 0x00000001, returns the old value */ | ||
345 | " jns 1f\n" | ||
346 | " call call_rwsem_down_read_failed\n" | ||
347 | @@ -121,14 +133,14 @@ static inline void __down_read(struct rw_semaphore *sem) | ||
348 | */ | ||
349 | static inline int __down_read_trylock(struct rw_semaphore *sem) | ||
350 | { | ||
351 | - __s32 result, tmp; | ||
352 | + rwsem_count_t result, tmp; | ||
353 | asm volatile("# beginning __down_read_trylock\n\t" | ||
354 | - " movl %0,%1\n\t" | ||
355 | + " mov %0,%1\n\t" | ||
356 | "1:\n\t" | ||
357 | - " movl %1,%2\n\t" | ||
358 | - " addl %3,%2\n\t" | ||
359 | + " mov %1,%2\n\t" | ||
360 | + " add %3,%2\n\t" | ||
361 | " jle 2f\n\t" | ||
362 | - LOCK_PREFIX " cmpxchgl %2,%0\n\t" | ||
363 | + LOCK_PREFIX " cmpxchg %2,%0\n\t" | ||
364 | " jnz 1b\n\t" | ||
365 | "2:\n\t" | ||
366 | "# ending __down_read_trylock\n\t" | ||
367 | @@ -143,13 +155,13 @@ static inline int __down_read_trylock(struct rw_semaphore *sem) | ||
368 | */ | ||
369 | static inline void __down_write_nested(struct rw_semaphore *sem, int subclass) | ||
370 | { | ||
371 | - int tmp; | ||
372 | + rwsem_count_t tmp; | ||
373 | |||
374 | tmp = RWSEM_ACTIVE_WRITE_BIAS; | ||
375 | asm volatile("# beginning down_write\n\t" | ||
376 | - LOCK_PREFIX " xadd %%edx,(%%eax)\n\t" | ||
377 | + LOCK_PREFIX " xadd %1,(%2)\n\t" | ||
378 | /* subtract 0x0000ffff, returns the old value */ | ||
379 | - " testl %%edx,%%edx\n\t" | ||
380 | + " test %1,%1\n\t" | ||
381 | /* was the count 0 before? */ | ||
382 | " jz 1f\n" | ||
383 | " call call_rwsem_down_write_failed\n" | ||
384 | @@ -170,9 +182,9 @@ static inline void __down_write(struct rw_semaphore *sem) | ||
385 | */ | ||
386 | static inline int __down_write_trylock(struct rw_semaphore *sem) | ||
387 | { | ||
388 | - signed long ret = cmpxchg(&sem->count, | ||
389 | - RWSEM_UNLOCKED_VALUE, | ||
390 | - RWSEM_ACTIVE_WRITE_BIAS); | ||
391 | + rwsem_count_t ret = cmpxchg(&sem->count, | ||
392 | + RWSEM_UNLOCKED_VALUE, | ||
393 | + RWSEM_ACTIVE_WRITE_BIAS); | ||
394 | if (ret == RWSEM_UNLOCKED_VALUE) | ||
395 | return 1; | ||
396 | return 0; | ||
397 | @@ -183,9 +195,9 @@ static inline int __down_write_trylock(struct rw_semaphore *sem) | ||
398 | */ | ||
399 | static inline void __up_read(struct rw_semaphore *sem) | ||
400 | { | ||
401 | - __s32 tmp = -RWSEM_ACTIVE_READ_BIAS; | ||
402 | + rwsem_count_t tmp = -RWSEM_ACTIVE_READ_BIAS; | ||
403 | asm volatile("# beginning __up_read\n\t" | ||
404 | - LOCK_PREFIX " xadd %%edx,(%%eax)\n\t" | ||
405 | + LOCK_PREFIX " xadd %1,(%2)\n\t" | ||
406 | /* subtracts 1, returns the old value */ | ||
407 | " jns 1f\n\t" | ||
408 | " call call_rwsem_wake\n" | ||
409 | @@ -201,18 +213,18 @@ static inline void __up_read(struct rw_semaphore *sem) | ||
410 | */ | ||
411 | static inline void __up_write(struct rw_semaphore *sem) | ||
412 | { | ||
413 | + rwsem_count_t tmp; | ||
414 | asm volatile("# beginning __up_write\n\t" | ||
415 | - " movl %2,%%edx\n\t" | ||
416 | - LOCK_PREFIX " xaddl %%edx,(%%eax)\n\t" | ||
417 | + LOCK_PREFIX " xadd %1,(%2)\n\t" | ||
418 | /* tries to transition | ||
419 | 0xffff0001 -> 0x00000000 */ | ||
420 | " jz 1f\n" | ||
421 | " call call_rwsem_wake\n" | ||
422 | "1:\n\t" | ||
423 | "# ending __up_write\n" | ||
424 | - : "+m" (sem->count) | ||
425 | - : "a" (sem), "i" (-RWSEM_ACTIVE_WRITE_BIAS) | ||
426 | - : "memory", "cc", "edx"); | ||
427 | + : "+m" (sem->count), "=d" (tmp) | ||
428 | + : "a" (sem), "1" (-RWSEM_ACTIVE_WRITE_BIAS) | ||
429 | + : "memory", "cc"); | ||
430 | } | ||
431 | |||
432 | /* | ||
433 | @@ -221,33 +233,38 @@ static inline void __up_write(struct rw_semaphore *sem) | ||
434 | static inline void __downgrade_write(struct rw_semaphore *sem) | ||
435 | { | ||
436 | asm volatile("# beginning __downgrade_write\n\t" | ||
437 | - LOCK_PREFIX " addl %2,(%%eax)\n\t" | ||
438 | - /* transitions 0xZZZZ0001 -> 0xYYYY0001 */ | ||
439 | + LOCK_PREFIX _ASM_ADD "%2,(%1)\n\t" | ||
440 | + /* | ||
441 | + * transitions 0xZZZZ0001 -> 0xYYYY0001 (i386) | ||
442 | + * 0xZZZZZZZZ00000001 -> 0xYYYYYYYY00000001 (x86_64) | ||
443 | + */ | ||
444 | " jns 1f\n\t" | ||
445 | " call call_rwsem_downgrade_wake\n" | ||
446 | "1:\n\t" | ||
447 | "# ending __downgrade_write\n" | ||
448 | : "+m" (sem->count) | ||
449 | - : "a" (sem), "i" (-RWSEM_WAITING_BIAS) | ||
450 | + : "a" (sem), "er" (-RWSEM_WAITING_BIAS) | ||
451 | : "memory", "cc"); | ||
452 | } | ||
453 | |||
454 | /* | ||
455 | * implement atomic add functionality | ||
456 | */ | ||
457 | -static inline void rwsem_atomic_add(int delta, struct rw_semaphore *sem) | ||
458 | +static inline void rwsem_atomic_add(rwsem_count_t delta, | ||
459 | + struct rw_semaphore *sem) | ||
460 | { | ||
461 | - asm volatile(LOCK_PREFIX "addl %1,%0" | ||
462 | + asm volatile(LOCK_PREFIX _ASM_ADD "%1,%0" | ||
463 | : "+m" (sem->count) | ||
464 | - : "ir" (delta)); | ||
465 | + : "er" (delta)); | ||
466 | } | ||
467 | |||
468 | /* | ||
469 | * implement exchange and add functionality | ||
470 | */ | ||
471 | -static inline int rwsem_atomic_update(int delta, struct rw_semaphore *sem) | ||
472 | +static inline rwsem_count_t rwsem_atomic_update(rwsem_count_t delta, | ||
473 | + struct rw_semaphore *sem) | ||
474 | { | ||
475 | - int tmp = delta; | ||
476 | + rwsem_count_t tmp = delta; | ||
477 | |||
478 | asm volatile(LOCK_PREFIX "xadd %0,%1" | ||
479 | : "+r" (tmp), "+m" (sem->count) | ||
480 | diff --git a/arch/x86/include/asm/smp.h b/arch/x86/include/asm/smp.h | ||
481 | index 1e79678..4cfc908 100644 | ||
482 | --- a/arch/x86/include/asm/smp.h | ||
483 | +++ b/arch/x86/include/asm/smp.h | ||
484 | @@ -135,6 +135,8 @@ int native_cpu_disable(void); | ||
485 | void native_cpu_die(unsigned int cpu); | ||
486 | void native_play_dead(void); | ||
487 | void play_dead_common(void); | ||
488 | +void wbinvd_on_cpu(int cpu); | ||
489 | +int wbinvd_on_all_cpus(void); | ||
490 | |||
491 | void native_send_call_func_ipi(const struct cpumask *mask); | ||
492 | void native_send_call_func_single_ipi(int cpu); | ||
493 | @@ -147,6 +149,13 @@ static inline int num_booting_cpus(void) | ||
494 | { | ||
495 | return cpumask_weight(cpu_callout_mask); | ||
496 | } | ||
497 | +#else /* !CONFIG_SMP */ | ||
498 | +#define wbinvd_on_cpu(cpu) wbinvd() | ||
499 | +static inline int wbinvd_on_all_cpus(void) | ||
500 | +{ | ||
501 | + wbinvd(); | ||
502 | + return 0; | ||
503 | +} | ||
504 | #endif /* CONFIG_SMP */ | ||
505 | |||
506 | extern unsigned disabled_cpus __cpuinitdata; | ||
507 | diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c | ||
508 | index adb0ba0..2e77516 100644 | ||
509 | --- a/arch/x86/kernel/amd_iommu.c | ||
510 | +++ b/arch/x86/kernel/amd_iommu.c | ||
511 | @@ -2298,7 +2298,7 @@ static void cleanup_domain(struct protection_domain *domain) | ||
512 | list_for_each_entry_safe(dev_data, next, &domain->dev_list, list) { | ||
513 | struct device *dev = dev_data->dev; | ||
514 | |||
515 | - do_detach(dev); | ||
516 | + __detach_device(dev); | ||
517 | atomic_set(&dev_data->bind, 0); | ||
518 | } | ||
519 | |||
520 | @@ -2379,9 +2379,7 @@ static void amd_iommu_domain_destroy(struct iommu_domain *dom) | ||
521 | |||
522 | free_pagetable(domain); | ||
523 | |||
524 | - domain_id_free(domain->id); | ||
525 | - | ||
526 | - kfree(domain); | ||
527 | + protection_domain_free(domain); | ||
528 | |||
529 | dom->priv = NULL; | ||
530 | } | ||
531 | diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c | ||
532 | index 9dc91b4..883d619 100644 | ||
533 | --- a/arch/x86/kernel/amd_iommu_init.c | ||
534 | +++ b/arch/x86/kernel/amd_iommu_init.c | ||
535 | @@ -1288,6 +1288,8 @@ static int __init amd_iommu_init(void) | ||
536 | if (ret) | ||
537 | goto free; | ||
538 | |||
539 | + enable_iommus(); | ||
540 | + | ||
541 | if (iommu_pass_through) | ||
542 | ret = amd_iommu_init_passthrough(); | ||
543 | else | ||
544 | @@ -1300,8 +1302,6 @@ static int __init amd_iommu_init(void) | ||
545 | |||
546 | amd_iommu_init_notifier(); | ||
547 | |||
548 | - enable_iommus(); | ||
549 | - | ||
550 | if (iommu_pass_through) | ||
551 | goto out; | ||
552 | |||
553 | @@ -1315,6 +1315,7 @@ out: | ||
554 | return ret; | ||
555 | |||
556 | free: | ||
557 | + disable_iommus(); | ||
558 | |||
559 | amd_iommu_uninit_devices(); | ||
560 | |||
561 | diff --git a/arch/x86/kernel/aperture_64.c b/arch/x86/kernel/aperture_64.c | ||
562 | index f147a95..19f2c70 100644 | ||
563 | --- a/arch/x86/kernel/aperture_64.c | ||
564 | +++ b/arch/x86/kernel/aperture_64.c | ||
565 | @@ -394,6 +394,7 @@ void __init gart_iommu_hole_init(void) | ||
566 | for (i = 0; i < ARRAY_SIZE(bus_dev_ranges); i++) { | ||
567 | int bus; | ||
568 | int dev_base, dev_limit; | ||
569 | + u32 ctl; | ||
570 | |||
571 | bus = bus_dev_ranges[i].bus; | ||
572 | dev_base = bus_dev_ranges[i].dev_base; | ||
573 | @@ -407,7 +408,19 @@ void __init gart_iommu_hole_init(void) | ||
574 | gart_iommu_aperture = 1; | ||
575 | x86_init.iommu.iommu_init = gart_iommu_init; | ||
576 | |||
577 | - aper_order = (read_pci_config(bus, slot, 3, AMD64_GARTAPERTURECTL) >> 1) & 7; | ||
578 | + ctl = read_pci_config(bus, slot, 3, | ||
579 | + AMD64_GARTAPERTURECTL); | ||
580 | + | ||
581 | + /* | ||
582 | + * Before we do anything else disable the GART. It may | ||
583 | + * still be enabled if we boot into a crash-kernel here. | ||
584 | + * Reconfiguring the GART while it is enabled could have | ||
585 | + * unknown side-effects. | ||
586 | + */ | ||
587 | + ctl &= ~GARTEN; | ||
588 | + write_pci_config(bus, slot, 3, AMD64_GARTAPERTURECTL, ctl); | ||
589 | + | ||
590 | + aper_order = (ctl >> 1) & 7; | ||
591 | aper_size = (32 * 1024 * 1024) << aper_order; | ||
592 | aper_base = read_pci_config(bus, slot, 3, AMD64_GARTAPERTUREBASE) & 0x7fff; | ||
593 | aper_base <<= 25; | ||
594 | diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c | ||
595 | index dfca210..d4df517 100644 | ||
596 | --- a/arch/x86/kernel/apic/apic.c | ||
597 | +++ b/arch/x86/kernel/apic/apic.c | ||
598 | @@ -1640,8 +1640,10 @@ int __init APIC_init_uniprocessor(void) | ||
599 | } | ||
600 | #endif | ||
601 | |||
602 | +#ifndef CONFIG_SMP | ||
603 | enable_IR_x2apic(); | ||
604 | default_setup_apic_routing(); | ||
605 | +#endif | ||
606 | |||
607 | verify_local_APIC(); | ||
608 | connect_bsp_APIC(); | ||
609 | diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c | ||
610 | index fc6c8ef..d440123 100644 | ||
611 | --- a/arch/x86/kernel/cpu/intel_cacheinfo.c | ||
612 | +++ b/arch/x86/kernel/cpu/intel_cacheinfo.c | ||
613 | @@ -18,6 +18,7 @@ | ||
614 | #include <asm/processor.h> | ||
615 | #include <linux/smp.h> | ||
616 | #include <asm/k8.h> | ||
617 | +#include <asm/smp.h> | ||
618 | |||
619 | #define LVL_1_INST 1 | ||
620 | #define LVL_1_DATA 2 | ||
621 | @@ -150,7 +151,8 @@ struct _cpuid4_info { | ||
622 | union _cpuid4_leaf_ebx ebx; | ||
623 | union _cpuid4_leaf_ecx ecx; | ||
624 | unsigned long size; | ||
625 | - unsigned long can_disable; | ||
626 | + bool can_disable; | ||
627 | + unsigned int l3_indices; | ||
628 | DECLARE_BITMAP(shared_cpu_map, NR_CPUS); | ||
629 | }; | ||
630 | |||
631 | @@ -160,7 +162,8 @@ struct _cpuid4_info_regs { | ||
632 | union _cpuid4_leaf_ebx ebx; | ||
633 | union _cpuid4_leaf_ecx ecx; | ||
634 | unsigned long size; | ||
635 | - unsigned long can_disable; | ||
636 | + bool can_disable; | ||
637 | + unsigned int l3_indices; | ||
638 | }; | ||
639 | |||
640 | unsigned short num_cache_leaves; | ||
641 | @@ -290,6 +293,36 @@ amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax, | ||
642 | (ebx->split.ways_of_associativity + 1) - 1; | ||
643 | } | ||
644 | |||
645 | +struct _cache_attr { | ||
646 | + struct attribute attr; | ||
647 | + ssize_t (*show)(struct _cpuid4_info *, char *); | ||
648 | + ssize_t (*store)(struct _cpuid4_info *, const char *, size_t count); | ||
649 | +}; | ||
650 | + | ||
651 | +#ifdef CONFIG_CPU_SUP_AMD | ||
652 | +static unsigned int __cpuinit amd_calc_l3_indices(void) | ||
653 | +{ | ||
654 | + /* | ||
655 | + * We're called over smp_call_function_single() and therefore | ||
656 | + * are on the correct cpu. | ||
657 | + */ | ||
658 | + int cpu = smp_processor_id(); | ||
659 | + int node = cpu_to_node(cpu); | ||
660 | + struct pci_dev *dev = node_to_k8_nb_misc(node); | ||
661 | + unsigned int sc0, sc1, sc2, sc3; | ||
662 | + u32 val = 0; | ||
663 | + | ||
664 | + pci_read_config_dword(dev, 0x1C4, &val); | ||
665 | + | ||
666 | + /* calculate subcache sizes */ | ||
667 | + sc0 = !(val & BIT(0)); | ||
668 | + sc1 = !(val & BIT(4)); | ||
669 | + sc2 = !(val & BIT(8)) + !(val & BIT(9)); | ||
670 | + sc3 = !(val & BIT(12)) + !(val & BIT(13)); | ||
671 | + | ||
672 | + return (max(max(max(sc0, sc1), sc2), sc3) << 10) - 1; | ||
673 | +} | ||
674 | + | ||
675 | static void __cpuinit | ||
676 | amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf) | ||
677 | { | ||
678 | @@ -299,12 +332,103 @@ amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf) | ||
679 | if (boot_cpu_data.x86 == 0x11) | ||
680 | return; | ||
681 | |||
682 | - /* see erratum #382 */ | ||
683 | - if ((boot_cpu_data.x86 == 0x10) && (boot_cpu_data.x86_model < 0x8)) | ||
684 | + /* see errata #382 and #388 */ | ||
685 | + if ((boot_cpu_data.x86 == 0x10) && | ||
686 | + ((boot_cpu_data.x86_model < 0x8) || | ||
687 | + (boot_cpu_data.x86_mask < 0x1))) | ||
688 | return; | ||
689 | |||
690 | - this_leaf->can_disable = 1; | ||
691 | + this_leaf->can_disable = true; | ||
692 | + this_leaf->l3_indices = amd_calc_l3_indices(); | ||
693 | +} | ||
694 | + | ||
695 | +static ssize_t show_cache_disable(struct _cpuid4_info *this_leaf, char *buf, | ||
696 | + unsigned int index) | ||
697 | +{ | ||
698 | + int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map)); | ||
699 | + int node = amd_get_nb_id(cpu); | ||
700 | + struct pci_dev *dev = node_to_k8_nb_misc(node); | ||
701 | + unsigned int reg = 0; | ||
702 | + | ||
703 | + if (!this_leaf->can_disable) | ||
704 | + return -EINVAL; | ||
705 | + | ||
706 | + if (!dev) | ||
707 | + return -EINVAL; | ||
708 | + | ||
709 | + pci_read_config_dword(dev, 0x1BC + index * 4, ®); | ||
710 | + return sprintf(buf, "0x%08x\n", reg); | ||
711 | +} | ||
712 | + | ||
713 | +#define SHOW_CACHE_DISABLE(index) \ | ||
714 | +static ssize_t \ | ||
715 | +show_cache_disable_##index(struct _cpuid4_info *this_leaf, char *buf) \ | ||
716 | +{ \ | ||
717 | + return show_cache_disable(this_leaf, buf, index); \ | ||
718 | +} | ||
719 | +SHOW_CACHE_DISABLE(0) | ||
720 | +SHOW_CACHE_DISABLE(1) | ||
721 | + | ||
722 | +static ssize_t store_cache_disable(struct _cpuid4_info *this_leaf, | ||
723 | + const char *buf, size_t count, unsigned int index) | ||
724 | +{ | ||
725 | + int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map)); | ||
726 | + int node = amd_get_nb_id(cpu); | ||
727 | + struct pci_dev *dev = node_to_k8_nb_misc(node); | ||
728 | + unsigned long val = 0; | ||
729 | + | ||
730 | +#define SUBCACHE_MASK (3UL << 20) | ||
731 | +#define SUBCACHE_INDEX 0xfff | ||
732 | + | ||
733 | + if (!this_leaf->can_disable) | ||
734 | + return -EINVAL; | ||
735 | + | ||
736 | + if (!capable(CAP_SYS_ADMIN)) | ||
737 | + return -EPERM; | ||
738 | + | ||
739 | + if (!dev) | ||
740 | + return -EINVAL; | ||
741 | + | ||
742 | + if (strict_strtoul(buf, 10, &val) < 0) | ||
743 | + return -EINVAL; | ||
744 | + | ||
745 | + /* do not allow writes outside of allowed bits */ | ||
746 | + if ((val & ~(SUBCACHE_MASK | SUBCACHE_INDEX)) || | ||
747 | + ((val & SUBCACHE_INDEX) > this_leaf->l3_indices)) | ||
748 | + return -EINVAL; | ||
749 | + | ||
750 | + val |= BIT(30); | ||
751 | + pci_write_config_dword(dev, 0x1BC + index * 4, val); | ||
752 | + /* | ||
753 | + * We need to WBINVD on a core on the node containing the L3 cache which | ||
754 | + * indices we disable therefore a simple wbinvd() is not sufficient. | ||
755 | + */ | ||
756 | + wbinvd_on_cpu(cpu); | ||
757 | + pci_write_config_dword(dev, 0x1BC + index * 4, val | BIT(31)); | ||
758 | + return count; | ||
759 | +} | ||
760 | + | ||
761 | +#define STORE_CACHE_DISABLE(index) \ | ||
762 | +static ssize_t \ | ||
763 | +store_cache_disable_##index(struct _cpuid4_info *this_leaf, \ | ||
764 | + const char *buf, size_t count) \ | ||
765 | +{ \ | ||
766 | + return store_cache_disable(this_leaf, buf, count, index); \ | ||
767 | } | ||
768 | +STORE_CACHE_DISABLE(0) | ||
769 | +STORE_CACHE_DISABLE(1) | ||
770 | + | ||
771 | +static struct _cache_attr cache_disable_0 = __ATTR(cache_disable_0, 0644, | ||
772 | + show_cache_disable_0, store_cache_disable_0); | ||
773 | +static struct _cache_attr cache_disable_1 = __ATTR(cache_disable_1, 0644, | ||
774 | + show_cache_disable_1, store_cache_disable_1); | ||
775 | + | ||
776 | +#else /* CONFIG_CPU_SUP_AMD */ | ||
777 | +static void __cpuinit | ||
778 | +amd_check_l3_disable(int index, struct _cpuid4_info_regs *this_leaf) | ||
779 | +{ | ||
780 | +}; | ||
781 | +#endif /* CONFIG_CPU_SUP_AMD */ | ||
782 | |||
783 | static int | ||
784 | __cpuinit cpuid4_cache_lookup_regs(int index, | ||
785 | @@ -711,82 +835,6 @@ static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf) | ||
786 | #define to_object(k) container_of(k, struct _index_kobject, kobj) | ||
787 | #define to_attr(a) container_of(a, struct _cache_attr, attr) | ||
788 | |||
789 | -static ssize_t show_cache_disable(struct _cpuid4_info *this_leaf, char *buf, | ||
790 | - unsigned int index) | ||
791 | -{ | ||
792 | - int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map)); | ||
793 | - int node = cpu_to_node(cpu); | ||
794 | - struct pci_dev *dev = node_to_k8_nb_misc(node); | ||
795 | - unsigned int reg = 0; | ||
796 | - | ||
797 | - if (!this_leaf->can_disable) | ||
798 | - return -EINVAL; | ||
799 | - | ||
800 | - if (!dev) | ||
801 | - return -EINVAL; | ||
802 | - | ||
803 | - pci_read_config_dword(dev, 0x1BC + index * 4, ®); | ||
804 | - return sprintf(buf, "%x\n", reg); | ||
805 | -} | ||
806 | - | ||
807 | -#define SHOW_CACHE_DISABLE(index) \ | ||
808 | -static ssize_t \ | ||
809 | -show_cache_disable_##index(struct _cpuid4_info *this_leaf, char *buf) \ | ||
810 | -{ \ | ||
811 | - return show_cache_disable(this_leaf, buf, index); \ | ||
812 | -} | ||
813 | -SHOW_CACHE_DISABLE(0) | ||
814 | -SHOW_CACHE_DISABLE(1) | ||
815 | - | ||
816 | -static ssize_t store_cache_disable(struct _cpuid4_info *this_leaf, | ||
817 | - const char *buf, size_t count, unsigned int index) | ||
818 | -{ | ||
819 | - int cpu = cpumask_first(to_cpumask(this_leaf->shared_cpu_map)); | ||
820 | - int node = cpu_to_node(cpu); | ||
821 | - struct pci_dev *dev = node_to_k8_nb_misc(node); | ||
822 | - unsigned long val = 0; | ||
823 | - unsigned int scrubber = 0; | ||
824 | - | ||
825 | - if (!this_leaf->can_disable) | ||
826 | - return -EINVAL; | ||
827 | - | ||
828 | - if (!capable(CAP_SYS_ADMIN)) | ||
829 | - return -EPERM; | ||
830 | - | ||
831 | - if (!dev) | ||
832 | - return -EINVAL; | ||
833 | - | ||
834 | - if (strict_strtoul(buf, 10, &val) < 0) | ||
835 | - return -EINVAL; | ||
836 | - | ||
837 | - val |= 0xc0000000; | ||
838 | - | ||
839 | - pci_read_config_dword(dev, 0x58, &scrubber); | ||
840 | - scrubber &= ~0x1f000000; | ||
841 | - pci_write_config_dword(dev, 0x58, scrubber); | ||
842 | - | ||
843 | - pci_write_config_dword(dev, 0x1BC + index * 4, val & ~0x40000000); | ||
844 | - wbinvd(); | ||
845 | - pci_write_config_dword(dev, 0x1BC + index * 4, val); | ||
846 | - return count; | ||
847 | -} | ||
848 | - | ||
849 | -#define STORE_CACHE_DISABLE(index) \ | ||
850 | -static ssize_t \ | ||
851 | -store_cache_disable_##index(struct _cpuid4_info *this_leaf, \ | ||
852 | - const char *buf, size_t count) \ | ||
853 | -{ \ | ||
854 | - return store_cache_disable(this_leaf, buf, count, index); \ | ||
855 | -} | ||
856 | -STORE_CACHE_DISABLE(0) | ||
857 | -STORE_CACHE_DISABLE(1) | ||
858 | - | ||
859 | -struct _cache_attr { | ||
860 | - struct attribute attr; | ||
861 | - ssize_t (*show)(struct _cpuid4_info *, char *); | ||
862 | - ssize_t (*store)(struct _cpuid4_info *, const char *, size_t count); | ||
863 | -}; | ||
864 | - | ||
865 | #define define_one_ro(_name) \ | ||
866 | static struct _cache_attr _name = \ | ||
867 | __ATTR(_name, 0444, show_##_name, NULL) | ||
868 | @@ -801,23 +849,28 @@ define_one_ro(size); | ||
869 | define_one_ro(shared_cpu_map); | ||
870 | define_one_ro(shared_cpu_list); | ||
871 | |||
872 | -static struct _cache_attr cache_disable_0 = __ATTR(cache_disable_0, 0644, | ||
873 | - show_cache_disable_0, store_cache_disable_0); | ||
874 | -static struct _cache_attr cache_disable_1 = __ATTR(cache_disable_1, 0644, | ||
875 | - show_cache_disable_1, store_cache_disable_1); | ||
876 | +#define DEFAULT_SYSFS_CACHE_ATTRS \ | ||
877 | + &type.attr, \ | ||
878 | + &level.attr, \ | ||
879 | + &coherency_line_size.attr, \ | ||
880 | + &physical_line_partition.attr, \ | ||
881 | + &ways_of_associativity.attr, \ | ||
882 | + &number_of_sets.attr, \ | ||
883 | + &size.attr, \ | ||
884 | + &shared_cpu_map.attr, \ | ||
885 | + &shared_cpu_list.attr | ||
886 | |||
887 | static struct attribute *default_attrs[] = { | ||
888 | - &type.attr, | ||
889 | - &level.attr, | ||
890 | - &coherency_line_size.attr, | ||
891 | - &physical_line_partition.attr, | ||
892 | - &ways_of_associativity.attr, | ||
893 | - &number_of_sets.attr, | ||
894 | - &size.attr, | ||
895 | - &shared_cpu_map.attr, | ||
896 | - &shared_cpu_list.attr, | ||
897 | + DEFAULT_SYSFS_CACHE_ATTRS, | ||
898 | + NULL | ||
899 | +}; | ||
900 | + | ||
901 | +static struct attribute *default_l3_attrs[] = { | ||
902 | + DEFAULT_SYSFS_CACHE_ATTRS, | ||
903 | +#ifdef CONFIG_CPU_SUP_AMD | ||
904 | &cache_disable_0.attr, | ||
905 | &cache_disable_1.attr, | ||
906 | +#endif | ||
907 | NULL | ||
908 | }; | ||
909 | |||
910 | @@ -908,6 +961,7 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev) | ||
911 | unsigned int cpu = sys_dev->id; | ||
912 | unsigned long i, j; | ||
913 | struct _index_kobject *this_object; | ||
914 | + struct _cpuid4_info *this_leaf; | ||
915 | int retval; | ||
916 | |||
917 | retval = cpuid4_cache_sysfs_init(cpu); | ||
918 | @@ -926,6 +980,14 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev) | ||
919 | this_object = INDEX_KOBJECT_PTR(cpu, i); | ||
920 | this_object->cpu = cpu; | ||
921 | this_object->index = i; | ||
922 | + | ||
923 | + this_leaf = CPUID4_INFO_IDX(cpu, i); | ||
924 | + | ||
925 | + if (this_leaf->can_disable) | ||
926 | + ktype_cache.default_attrs = default_l3_attrs; | ||
927 | + else | ||
928 | + ktype_cache.default_attrs = default_attrs; | ||
929 | + | ||
930 | retval = kobject_init_and_add(&(this_object->kobj), | ||
931 | &ktype_cache, | ||
932 | per_cpu(ici_cache_kobject, cpu), | ||
933 | diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c | ||
934 | index 98819b3..c7ca8e2 100644 | ||
935 | --- a/arch/x86/kernel/cpu/perf_event.c | ||
936 | +++ b/arch/x86/kernel/cpu/perf_event.c | ||
937 | @@ -245,6 +245,97 @@ static u64 __read_mostly hw_cache_event_ids | ||
938 | [PERF_COUNT_HW_CACHE_OP_MAX] | ||
939 | [PERF_COUNT_HW_CACHE_RESULT_MAX]; | ||
940 | |||
941 | +static const u64 westmere_hw_cache_event_ids | ||
942 | + [PERF_COUNT_HW_CACHE_MAX] | ||
943 | + [PERF_COUNT_HW_CACHE_OP_MAX] | ||
944 | + [PERF_COUNT_HW_CACHE_RESULT_MAX] = | ||
945 | +{ | ||
946 | + [ C(L1D) ] = { | ||
947 | + [ C(OP_READ) ] = { | ||
948 | + [ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS */ | ||
949 | + [ C(RESULT_MISS) ] = 0x0151, /* L1D.REPL */ | ||
950 | + }, | ||
951 | + [ C(OP_WRITE) ] = { | ||
952 | + [ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES */ | ||
953 | + [ C(RESULT_MISS) ] = 0x0251, /* L1D.M_REPL */ | ||
954 | + }, | ||
955 | + [ C(OP_PREFETCH) ] = { | ||
956 | + [ C(RESULT_ACCESS) ] = 0x014e, /* L1D_PREFETCH.REQUESTS */ | ||
957 | + [ C(RESULT_MISS) ] = 0x024e, /* L1D_PREFETCH.MISS */ | ||
958 | + }, | ||
959 | + }, | ||
960 | + [ C(L1I ) ] = { | ||
961 | + [ C(OP_READ) ] = { | ||
962 | + [ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS */ | ||
963 | + [ C(RESULT_MISS) ] = 0x0280, /* L1I.MISSES */ | ||
964 | + }, | ||
965 | + [ C(OP_WRITE) ] = { | ||
966 | + [ C(RESULT_ACCESS) ] = -1, | ||
967 | + [ C(RESULT_MISS) ] = -1, | ||
968 | + }, | ||
969 | + [ C(OP_PREFETCH) ] = { | ||
970 | + [ C(RESULT_ACCESS) ] = 0x0, | ||
971 | + [ C(RESULT_MISS) ] = 0x0, | ||
972 | + }, | ||
973 | + }, | ||
974 | + [ C(LL ) ] = { | ||
975 | + [ C(OP_READ) ] = { | ||
976 | + [ C(RESULT_ACCESS) ] = 0x0324, /* L2_RQSTS.LOADS */ | ||
977 | + [ C(RESULT_MISS) ] = 0x0224, /* L2_RQSTS.LD_MISS */ | ||
978 | + }, | ||
979 | + [ C(OP_WRITE) ] = { | ||
980 | + [ C(RESULT_ACCESS) ] = 0x0c24, /* L2_RQSTS.RFOS */ | ||
981 | + [ C(RESULT_MISS) ] = 0x0824, /* L2_RQSTS.RFO_MISS */ | ||
982 | + }, | ||
983 | + [ C(OP_PREFETCH) ] = { | ||
984 | + [ C(RESULT_ACCESS) ] = 0x4f2e, /* LLC Reference */ | ||
985 | + [ C(RESULT_MISS) ] = 0x412e, /* LLC Misses */ | ||
986 | + }, | ||
987 | + }, | ||
988 | + [ C(DTLB) ] = { | ||
989 | + [ C(OP_READ) ] = { | ||
990 | + [ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS */ | ||
991 | + [ C(RESULT_MISS) ] = 0x0108, /* DTLB_LOAD_MISSES.ANY */ | ||
992 | + }, | ||
993 | + [ C(OP_WRITE) ] = { | ||
994 | + [ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES */ | ||
995 | + [ C(RESULT_MISS) ] = 0x010c, /* MEM_STORE_RETIRED.DTLB_MISS */ | ||
996 | + }, | ||
997 | + [ C(OP_PREFETCH) ] = { | ||
998 | + [ C(RESULT_ACCESS) ] = 0x0, | ||
999 | + [ C(RESULT_MISS) ] = 0x0, | ||
1000 | + }, | ||
1001 | + }, | ||
1002 | + [ C(ITLB) ] = { | ||
1003 | + [ C(OP_READ) ] = { | ||
1004 | + [ C(RESULT_ACCESS) ] = 0x01c0, /* INST_RETIRED.ANY_P */ | ||
1005 | + [ C(RESULT_MISS) ] = 0x0185, /* ITLB_MISSES.ANY */ | ||
1006 | + }, | ||
1007 | + [ C(OP_WRITE) ] = { | ||
1008 | + [ C(RESULT_ACCESS) ] = -1, | ||
1009 | + [ C(RESULT_MISS) ] = -1, | ||
1010 | + }, | ||
1011 | + [ C(OP_PREFETCH) ] = { | ||
1012 | + [ C(RESULT_ACCESS) ] = -1, | ||
1013 | + [ C(RESULT_MISS) ] = -1, | ||
1014 | + }, | ||
1015 | + }, | ||
1016 | + [ C(BPU ) ] = { | ||
1017 | + [ C(OP_READ) ] = { | ||
1018 | + [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */ | ||
1019 | + [ C(RESULT_MISS) ] = 0x03e8, /* BPU_CLEARS.ANY */ | ||
1020 | + }, | ||
1021 | + [ C(OP_WRITE) ] = { | ||
1022 | + [ C(RESULT_ACCESS) ] = -1, | ||
1023 | + [ C(RESULT_MISS) ] = -1, | ||
1024 | + }, | ||
1025 | + [ C(OP_PREFETCH) ] = { | ||
1026 | + [ C(RESULT_ACCESS) ] = -1, | ||
1027 | + [ C(RESULT_MISS) ] = -1, | ||
1028 | + }, | ||
1029 | + }, | ||
1030 | +}; | ||
1031 | + | ||
1032 | static __initconst u64 nehalem_hw_cache_event_ids | ||
1033 | [PERF_COUNT_HW_CACHE_MAX] | ||
1034 | [PERF_COUNT_HW_CACHE_OP_MAX] | ||
1035 | @@ -2118,6 +2209,7 @@ static __init int intel_pmu_init(void) | ||
1036 | * Install the hw-cache-events table: | ||
1037 | */ | ||
1038 | switch (boot_cpu_data.x86_model) { | ||
1039 | + | ||
1040 | case 15: /* original 65 nm celeron/pentium/core2/xeon, "Merom"/"Conroe" */ | ||
1041 | case 22: /* single-core 65 nm celeron/core2solo "Merom-L"/"Conroe-L" */ | ||
1042 | case 23: /* current 45 nm celeron/core2/xeon "Penryn"/"Wolfdale" */ | ||
1043 | @@ -2129,7 +2221,9 @@ static __init int intel_pmu_init(void) | ||
1044 | event_constraints = intel_core_event_constraints; | ||
1045 | break; | ||
1046 | default: | ||
1047 | - case 26: | ||
1048 | + case 26: /* 45 nm nehalem, "Bloomfield" */ | ||
1049 | + case 30: /* 45 nm nehalem, "Lynnfield" */ | ||
1050 | + case 46: /* 45 nm nehalem-ex, "Beckton" */ | ||
1051 | memcpy(hw_cache_event_ids, nehalem_hw_cache_event_ids, | ||
1052 | sizeof(hw_cache_event_ids)); | ||
1053 | |||
1054 | @@ -2142,6 +2236,14 @@ static __init int intel_pmu_init(void) | ||
1055 | |||
1056 | pr_cont("Atom events, "); | ||
1057 | break; | ||
1058 | + | ||
1059 | + case 37: /* 32 nm nehalem, "Clarkdale" */ | ||
1060 | + case 44: /* 32 nm nehalem, "Gulftown" */ | ||
1061 | + memcpy(hw_cache_event_ids, westmere_hw_cache_event_ids, | ||
1062 | + sizeof(hw_cache_event_ids)); | ||
1063 | + | ||
1064 | + pr_cont("Westmere events, "); | ||
1065 | + break; | ||
1066 | } | ||
1067 | return 0; | ||
1068 | } | ||
1069 | diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c | ||
1070 | index a4849c1..ebd4c51 100644 | ||
1071 | --- a/arch/x86/kernel/crash.c | ||
1072 | +++ b/arch/x86/kernel/crash.c | ||
1073 | @@ -27,7 +27,6 @@ | ||
1074 | #include <asm/cpu.h> | ||
1075 | #include <asm/reboot.h> | ||
1076 | #include <asm/virtext.h> | ||
1077 | -#include <asm/x86_init.h> | ||
1078 | |||
1079 | #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC) | ||
1080 | |||
1081 | @@ -103,10 +102,5 @@ void native_machine_crash_shutdown(struct pt_regs *regs) | ||
1082 | #ifdef CONFIG_HPET_TIMER | ||
1083 | hpet_disable(); | ||
1084 | #endif | ||
1085 | - | ||
1086 | -#ifdef CONFIG_X86_64 | ||
1087 | - x86_platform.iommu_shutdown(); | ||
1088 | -#endif | ||
1089 | - | ||
1090 | crash_save_cpu(regs, safe_smp_processor_id()); | ||
1091 | } | ||
1092 | diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c | ||
1093 | index ad80a1c..773afc9 100644 | ||
1094 | --- a/arch/x86/kernel/hpet.c | ||
1095 | +++ b/arch/x86/kernel/hpet.c | ||
1096 | @@ -399,9 +399,15 @@ static int hpet_next_event(unsigned long delta, | ||
1097 | * then we might have a real hardware problem. We can not do | ||
1098 | * much about it here, but at least alert the user/admin with | ||
1099 | * a prominent warning. | ||
1100 | + * An erratum on some chipsets (ICH9,..), results in comparator read | ||
1101 | + * immediately following a write returning old value. Workaround | ||
1102 | + * for this is to read this value second time, when first | ||
1103 | + * read returns old value. | ||
1104 | */ | ||
1105 | - WARN_ONCE(hpet_readl(HPET_Tn_CMP(timer)) != cnt, | ||
1106 | + if (unlikely((u32)hpet_readl(HPET_Tn_CMP(timer)) != cnt)) { | ||
1107 | + WARN_ONCE(hpet_readl(HPET_Tn_CMP(timer)) != cnt, | ||
1108 | KERN_WARNING "hpet: compare register read back failed.\n"); | ||
1109 | + } | ||
1110 | |||
1111 | return (s32)(hpet_readl(HPET_COUNTER) - cnt) >= 0 ? -ETIME : 0; | ||
1112 | } | ||
1113 | diff --git a/arch/x86/kernel/kgdb.c b/arch/x86/kernel/kgdb.c | ||
1114 | index bfba601..b2258ca 100644 | ||
1115 | --- a/arch/x86/kernel/kgdb.c | ||
1116 | +++ b/arch/x86/kernel/kgdb.c | ||
1117 | @@ -618,8 +618,8 @@ int kgdb_arch_init(void) | ||
1118 | * portion of kgdb because this operation requires mutexs to | ||
1119 | * complete. | ||
1120 | */ | ||
1121 | + hw_breakpoint_init(&attr); | ||
1122 | attr.bp_addr = (unsigned long)kgdb_arch_init; | ||
1123 | - attr.type = PERF_TYPE_BREAKPOINT; | ||
1124 | attr.bp_len = HW_BREAKPOINT_LEN_1; | ||
1125 | attr.bp_type = HW_BREAKPOINT_W; | ||
1126 | attr.disabled = 1; | ||
1127 | diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c | ||
1128 | index a2c1edd..e81030f 100644 | ||
1129 | --- a/arch/x86/kernel/mpparse.c | ||
1130 | +++ b/arch/x86/kernel/mpparse.c | ||
1131 | @@ -664,7 +664,7 @@ static void __init smp_reserve_memory(struct mpf_intel *mpf) | ||
1132 | { | ||
1133 | unsigned long size = get_mpc_size(mpf->physptr); | ||
1134 | |||
1135 | - reserve_early(mpf->physptr, mpf->physptr+size, "MP-table mpc"); | ||
1136 | + reserve_early_overlap_ok(mpf->physptr, mpf->physptr+size, "MP-table mpc"); | ||
1137 | } | ||
1138 | |||
1139 | static int __init smp_scan_config(unsigned long base, unsigned long length) | ||
1140 | @@ -693,7 +693,7 @@ static int __init smp_scan_config(unsigned long base, unsigned long length) | ||
1141 | mpf, (u64)virt_to_phys(mpf)); | ||
1142 | |||
1143 | mem = virt_to_phys(mpf); | ||
1144 | - reserve_early(mem, mem + sizeof(*mpf), "MP-table mpf"); | ||
1145 | + reserve_early_overlap_ok(mem, mem + sizeof(*mpf), "MP-table mpf"); | ||
1146 | if (mpf->physptr) | ||
1147 | smp_reserve_memory(mpf); | ||
1148 | |||
1149 | diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/pci-gart_64.c | ||
1150 | index 34de53b..4f41b29 100644 | ||
1151 | --- a/arch/x86/kernel/pci-gart_64.c | ||
1152 | +++ b/arch/x86/kernel/pci-gart_64.c | ||
1153 | @@ -564,6 +564,9 @@ static void enable_gart_translations(void) | ||
1154 | |||
1155 | enable_gart_translation(dev, __pa(agp_gatt_table)); | ||
1156 | } | ||
1157 | + | ||
1158 | + /* Flush the GART-TLB to remove stale entries */ | ||
1159 | + k8_flush_garts(); | ||
1160 | } | ||
1161 | |||
1162 | /* | ||
1163 | diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c | ||
1164 | index 89a49fb..28c3d81 100644 | ||
1165 | --- a/arch/x86/kvm/mmu.c | ||
1166 | +++ b/arch/x86/kvm/mmu.c | ||
1167 | @@ -1502,8 +1502,8 @@ static int mmu_zap_unsync_children(struct kvm *kvm, | ||
1168 | for_each_sp(pages, sp, parents, i) { | ||
1169 | kvm_mmu_zap_page(kvm, sp); | ||
1170 | mmu_pages_clear_parents(&parents); | ||
1171 | + zapped++; | ||
1172 | } | ||
1173 | - zapped += pages.nr; | ||
1174 | kvm_mmu_pages_init(parent, &parents, &pages); | ||
1175 | } | ||
1176 | |||
1177 | @@ -1554,14 +1554,16 @@ void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages) | ||
1178 | */ | ||
1179 | |||
1180 | if (used_pages > kvm_nr_mmu_pages) { | ||
1181 | - while (used_pages > kvm_nr_mmu_pages) { | ||
1182 | + while (used_pages > kvm_nr_mmu_pages && | ||
1183 | + !list_empty(&kvm->arch.active_mmu_pages)) { | ||
1184 | struct kvm_mmu_page *page; | ||
1185 | |||
1186 | page = container_of(kvm->arch.active_mmu_pages.prev, | ||
1187 | struct kvm_mmu_page, link); | ||
1188 | - kvm_mmu_zap_page(kvm, page); | ||
1189 | + used_pages -= kvm_mmu_zap_page(kvm, page); | ||
1190 | used_pages--; | ||
1191 | } | ||
1192 | + kvm_nr_mmu_pages = used_pages; | ||
1193 | kvm->arch.n_free_mmu_pages = 0; | ||
1194 | } | ||
1195 | else | ||
1196 | @@ -1608,7 +1610,8 @@ static void mmu_unshadow(struct kvm *kvm, gfn_t gfn) | ||
1197 | && !sp->role.invalid) { | ||
1198 | pgprintk("%s: zap %lx %x\n", | ||
1199 | __func__, gfn, sp->role.word); | ||
1200 | - kvm_mmu_zap_page(kvm, sp); | ||
1201 | + if (kvm_mmu_zap_page(kvm, sp)) | ||
1202 | + nn = bucket->first; | ||
1203 | } | ||
1204 | } | ||
1205 | } | ||
1206 | diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c | ||
1207 | index 1d9b338..d42e191 100644 | ||
1208 | --- a/arch/x86/kvm/svm.c | ||
1209 | +++ b/arch/x86/kvm/svm.c | ||
1210 | @@ -698,29 +698,28 @@ static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id) | ||
1211 | if (err) | ||
1212 | goto free_svm; | ||
1213 | |||
1214 | + err = -ENOMEM; | ||
1215 | page = alloc_page(GFP_KERNEL); | ||
1216 | - if (!page) { | ||
1217 | - err = -ENOMEM; | ||
1218 | + if (!page) | ||
1219 | goto uninit; | ||
1220 | - } | ||
1221 | |||
1222 | - err = -ENOMEM; | ||
1223 | msrpm_pages = alloc_pages(GFP_KERNEL, MSRPM_ALLOC_ORDER); | ||
1224 | if (!msrpm_pages) | ||
1225 | - goto uninit; | ||
1226 | + goto free_page1; | ||
1227 | |||
1228 | nested_msrpm_pages = alloc_pages(GFP_KERNEL, MSRPM_ALLOC_ORDER); | ||
1229 | if (!nested_msrpm_pages) | ||
1230 | - goto uninit; | ||
1231 | - | ||
1232 | - svm->msrpm = page_address(msrpm_pages); | ||
1233 | - svm_vcpu_init_msrpm(svm->msrpm); | ||
1234 | + goto free_page2; | ||
1235 | |||
1236 | hsave_page = alloc_page(GFP_KERNEL); | ||
1237 | if (!hsave_page) | ||
1238 | - goto uninit; | ||
1239 | + goto free_page3; | ||
1240 | + | ||
1241 | svm->nested.hsave = page_address(hsave_page); | ||
1242 | |||
1243 | + svm->msrpm = page_address(msrpm_pages); | ||
1244 | + svm_vcpu_init_msrpm(svm->msrpm); | ||
1245 | + | ||
1246 | svm->nested.msrpm = page_address(nested_msrpm_pages); | ||
1247 | |||
1248 | svm->vmcb = page_address(page); | ||
1249 | @@ -737,6 +736,12 @@ static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id) | ||
1250 | |||
1251 | return &svm->vcpu; | ||
1252 | |||
1253 | +free_page3: | ||
1254 | + __free_pages(nested_msrpm_pages, MSRPM_ALLOC_ORDER); | ||
1255 | +free_page2: | ||
1256 | + __free_pages(msrpm_pages, MSRPM_ALLOC_ORDER); | ||
1257 | +free_page1: | ||
1258 | + __free_page(page); | ||
1259 | uninit: | ||
1260 | kvm_vcpu_uninit(&svm->vcpu); | ||
1261 | free_svm: | ||
1262 | diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c | ||
1263 | index 8a8e139..3acbe19 100644 | ||
1264 | --- a/arch/x86/kvm/vmx.c | ||
1265 | +++ b/arch/x86/kvm/vmx.c | ||
1266 | @@ -61,6 +61,8 @@ module_param_named(unrestricted_guest, | ||
1267 | static int __read_mostly emulate_invalid_guest_state = 0; | ||
1268 | module_param(emulate_invalid_guest_state, bool, S_IRUGO); | ||
1269 | |||
1270 | +#define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL | X86_EFLAGS_VM)) | ||
1271 | + | ||
1272 | /* | ||
1273 | * These 2 parameters are used to config the controls for Pause-Loop Exiting: | ||
1274 | * ple_gap: upper bound on the amount of time between two successive | ||
1275 | @@ -115,7 +117,7 @@ struct vcpu_vmx { | ||
1276 | } host_state; | ||
1277 | struct { | ||
1278 | int vm86_active; | ||
1279 | - u8 save_iopl; | ||
1280 | + ulong save_rflags; | ||
1281 | struct kvm_save_segment { | ||
1282 | u16 selector; | ||
1283 | unsigned long base; | ||
1284 | @@ -787,18 +789,23 @@ static void vmx_fpu_deactivate(struct kvm_vcpu *vcpu) | ||
1285 | |||
1286 | static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu) | ||
1287 | { | ||
1288 | - unsigned long rflags; | ||
1289 | + unsigned long rflags, save_rflags; | ||
1290 | |||
1291 | rflags = vmcs_readl(GUEST_RFLAGS); | ||
1292 | - if (to_vmx(vcpu)->rmode.vm86_active) | ||
1293 | - rflags &= ~(unsigned long)(X86_EFLAGS_IOPL | X86_EFLAGS_VM); | ||
1294 | + if (to_vmx(vcpu)->rmode.vm86_active) { | ||
1295 | + rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS; | ||
1296 | + save_rflags = to_vmx(vcpu)->rmode.save_rflags; | ||
1297 | + rflags |= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; | ||
1298 | + } | ||
1299 | return rflags; | ||
1300 | } | ||
1301 | |||
1302 | static void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags) | ||
1303 | { | ||
1304 | - if (to_vmx(vcpu)->rmode.vm86_active) | ||
1305 | + if (to_vmx(vcpu)->rmode.vm86_active) { | ||
1306 | + to_vmx(vcpu)->rmode.save_rflags = rflags; | ||
1307 | rflags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM; | ||
1308 | + } | ||
1309 | vmcs_writel(GUEST_RFLAGS, rflags); | ||
1310 | } | ||
1311 | |||
1312 | @@ -1431,8 +1438,8 @@ static void enter_pmode(struct kvm_vcpu *vcpu) | ||
1313 | vmcs_write32(GUEST_TR_AR_BYTES, vmx->rmode.tr.ar); | ||
1314 | |||
1315 | flags = vmcs_readl(GUEST_RFLAGS); | ||
1316 | - flags &= ~(X86_EFLAGS_IOPL | X86_EFLAGS_VM); | ||
1317 | - flags |= (vmx->rmode.save_iopl << IOPL_SHIFT); | ||
1318 | + flags &= RMODE_GUEST_OWNED_EFLAGS_BITS; | ||
1319 | + flags |= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; | ||
1320 | vmcs_writel(GUEST_RFLAGS, flags); | ||
1321 | |||
1322 | vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) | | ||
1323 | @@ -1501,8 +1508,7 @@ static void enter_rmode(struct kvm_vcpu *vcpu) | ||
1324 | vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); | ||
1325 | |||
1326 | flags = vmcs_readl(GUEST_RFLAGS); | ||
1327 | - vmx->rmode.save_iopl | ||
1328 | - = (flags & X86_EFLAGS_IOPL) >> IOPL_SHIFT; | ||
1329 | + vmx->rmode.save_rflags = flags; | ||
1330 | |||
1331 | flags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM; | ||
1332 | |||
1333 | @@ -2719,6 +2725,12 @@ static int handle_rmode_exception(struct kvm_vcpu *vcpu, | ||
1334 | kvm_queue_exception(vcpu, vec); | ||
1335 | return 1; | ||
1336 | case BP_VECTOR: | ||
1337 | + /* | ||
1338 | + * Update instruction length as we may reinject the exception | ||
1339 | + * from user space while in guest debugging mode. | ||
1340 | + */ | ||
1341 | + to_vmx(vcpu)->vcpu.arch.event_exit_inst_len = | ||
1342 | + vmcs_read32(VM_EXIT_INSTRUCTION_LEN); | ||
1343 | if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) | ||
1344 | return 0; | ||
1345 | /* fall through */ | ||
1346 | @@ -2841,6 +2853,13 @@ static int handle_exception(struct kvm_vcpu *vcpu) | ||
1347 | kvm_run->debug.arch.dr7 = vmcs_readl(GUEST_DR7); | ||
1348 | /* fall through */ | ||
1349 | case BP_VECTOR: | ||
1350 | + /* | ||
1351 | + * Update instruction length as we may reinject #BP from | ||
1352 | + * user space while in guest debugging mode. Reading it for | ||
1353 | + * #DB as well causes no harm, it is not used in that case. | ||
1354 | + */ | ||
1355 | + vmx->vcpu.arch.event_exit_inst_len = | ||
1356 | + vmcs_read32(VM_EXIT_INSTRUCTION_LEN); | ||
1357 | kvm_run->exit_reason = KVM_EXIT_DEBUG; | ||
1358 | kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip; | ||
1359 | kvm_run->debug.arch.exception = ex_no; | ||
1360 | diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c | ||
1361 | index e900908..dd78927 100644 | ||
1362 | --- a/arch/x86/kvm/x86.c | ||
1363 | +++ b/arch/x86/kvm/x86.c | ||
1364 | @@ -384,21 +384,16 @@ out: | ||
1365 | void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0) | ||
1366 | { | ||
1367 | if (cr0 & CR0_RESERVED_BITS) { | ||
1368 | - printk(KERN_DEBUG "set_cr0: 0x%lx #GP, reserved bits 0x%lx\n", | ||
1369 | - cr0, vcpu->arch.cr0); | ||
1370 | kvm_inject_gp(vcpu, 0); | ||
1371 | return; | ||
1372 | } | ||
1373 | |||
1374 | if ((cr0 & X86_CR0_NW) && !(cr0 & X86_CR0_CD)) { | ||
1375 | - printk(KERN_DEBUG "set_cr0: #GP, CD == 0 && NW == 1\n"); | ||
1376 | kvm_inject_gp(vcpu, 0); | ||
1377 | return; | ||
1378 | } | ||
1379 | |||
1380 | if ((cr0 & X86_CR0_PG) && !(cr0 & X86_CR0_PE)) { | ||
1381 | - printk(KERN_DEBUG "set_cr0: #GP, set PG flag " | ||
1382 | - "and a clear PE flag\n"); | ||
1383 | kvm_inject_gp(vcpu, 0); | ||
1384 | return; | ||
1385 | } | ||
1386 | @@ -409,15 +404,11 @@ void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0) | ||
1387 | int cs_db, cs_l; | ||
1388 | |||
1389 | if (!is_pae(vcpu)) { | ||
1390 | - printk(KERN_DEBUG "set_cr0: #GP, start paging " | ||
1391 | - "in long mode while PAE is disabled\n"); | ||
1392 | kvm_inject_gp(vcpu, 0); | ||
1393 | return; | ||
1394 | } | ||
1395 | kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l); | ||
1396 | if (cs_l) { | ||
1397 | - printk(KERN_DEBUG "set_cr0: #GP, start paging " | ||
1398 | - "in long mode while CS.L == 1\n"); | ||
1399 | kvm_inject_gp(vcpu, 0); | ||
1400 | return; | ||
1401 | |||
1402 | @@ -425,8 +416,6 @@ void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0) | ||
1403 | } else | ||
1404 | #endif | ||
1405 | if (is_pae(vcpu) && !load_pdptrs(vcpu, vcpu->arch.cr3)) { | ||
1406 | - printk(KERN_DEBUG "set_cr0: #GP, pdptrs " | ||
1407 | - "reserved bits\n"); | ||
1408 | kvm_inject_gp(vcpu, 0); | ||
1409 | return; | ||
1410 | } | ||
1411 | @@ -453,28 +442,23 @@ void kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4) | ||
1412 | unsigned long pdptr_bits = X86_CR4_PGE | X86_CR4_PSE | X86_CR4_PAE; | ||
1413 | |||
1414 | if (cr4 & CR4_RESERVED_BITS) { | ||
1415 | - printk(KERN_DEBUG "set_cr4: #GP, reserved bits\n"); | ||
1416 | kvm_inject_gp(vcpu, 0); | ||
1417 | return; | ||
1418 | } | ||
1419 | |||
1420 | if (is_long_mode(vcpu)) { | ||
1421 | if (!(cr4 & X86_CR4_PAE)) { | ||
1422 | - printk(KERN_DEBUG "set_cr4: #GP, clearing PAE while " | ||
1423 | - "in long mode\n"); | ||
1424 | kvm_inject_gp(vcpu, 0); | ||
1425 | return; | ||
1426 | } | ||
1427 | } else if (is_paging(vcpu) && (cr4 & X86_CR4_PAE) | ||
1428 | && ((cr4 ^ old_cr4) & pdptr_bits) | ||
1429 | && !load_pdptrs(vcpu, vcpu->arch.cr3)) { | ||
1430 | - printk(KERN_DEBUG "set_cr4: #GP, pdptrs reserved bits\n"); | ||
1431 | kvm_inject_gp(vcpu, 0); | ||
1432 | return; | ||
1433 | } | ||
1434 | |||
1435 | if (cr4 & X86_CR4_VMXE) { | ||
1436 | - printk(KERN_DEBUG "set_cr4: #GP, setting VMXE\n"); | ||
1437 | kvm_inject_gp(vcpu, 0); | ||
1438 | return; | ||
1439 | } | ||
1440 | @@ -495,21 +479,16 @@ void kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3) | ||
1441 | |||
1442 | if (is_long_mode(vcpu)) { | ||
1443 | if (cr3 & CR3_L_MODE_RESERVED_BITS) { | ||
1444 | - printk(KERN_DEBUG "set_cr3: #GP, reserved bits\n"); | ||
1445 | kvm_inject_gp(vcpu, 0); | ||
1446 | return; | ||
1447 | } | ||
1448 | } else { | ||
1449 | if (is_pae(vcpu)) { | ||
1450 | if (cr3 & CR3_PAE_RESERVED_BITS) { | ||
1451 | - printk(KERN_DEBUG | ||
1452 | - "set_cr3: #GP, reserved bits\n"); | ||
1453 | kvm_inject_gp(vcpu, 0); | ||
1454 | return; | ||
1455 | } | ||
1456 | if (is_paging(vcpu) && !load_pdptrs(vcpu, cr3)) { | ||
1457 | - printk(KERN_DEBUG "set_cr3: #GP, pdptrs " | ||
1458 | - "reserved bits\n"); | ||
1459 | kvm_inject_gp(vcpu, 0); | ||
1460 | return; | ||
1461 | } | ||
1462 | @@ -541,7 +520,6 @@ EXPORT_SYMBOL_GPL(kvm_set_cr3); | ||
1463 | void kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8) | ||
1464 | { | ||
1465 | if (cr8 & CR8_RESERVED_BITS) { | ||
1466 | - printk(KERN_DEBUG "set_cr8: #GP, reserved bits 0x%lx\n", cr8); | ||
1467 | kvm_inject_gp(vcpu, 0); | ||
1468 | return; | ||
1469 | } | ||
1470 | @@ -595,15 +573,12 @@ static u32 emulated_msrs[] = { | ||
1471 | static void set_efer(struct kvm_vcpu *vcpu, u64 efer) | ||
1472 | { | ||
1473 | if (efer & efer_reserved_bits) { | ||
1474 | - printk(KERN_DEBUG "set_efer: 0x%llx #GP, reserved bits\n", | ||
1475 | - efer); | ||
1476 | kvm_inject_gp(vcpu, 0); | ||
1477 | return; | ||
1478 | } | ||
1479 | |||
1480 | if (is_paging(vcpu) | ||
1481 | && (vcpu->arch.shadow_efer & EFER_LME) != (efer & EFER_LME)) { | ||
1482 | - printk(KERN_DEBUG "set_efer: #GP, change LME while paging\n"); | ||
1483 | kvm_inject_gp(vcpu, 0); | ||
1484 | return; | ||
1485 | } | ||
1486 | @@ -613,7 +588,6 @@ static void set_efer(struct kvm_vcpu *vcpu, u64 efer) | ||
1487 | |||
1488 | feat = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); | ||
1489 | if (!feat || !(feat->edx & bit(X86_FEATURE_FXSR_OPT))) { | ||
1490 | - printk(KERN_DEBUG "set_efer: #GP, enable FFXSR w/o CPUID capability\n"); | ||
1491 | kvm_inject_gp(vcpu, 0); | ||
1492 | return; | ||
1493 | } | ||
1494 | @@ -624,7 +598,6 @@ static void set_efer(struct kvm_vcpu *vcpu, u64 efer) | ||
1495 | |||
1496 | feat = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); | ||
1497 | if (!feat || !(feat->ecx & bit(X86_FEATURE_SVM))) { | ||
1498 | - printk(KERN_DEBUG "set_efer: #GP, enable SVM w/o SVM\n"); | ||
1499 | kvm_inject_gp(vcpu, 0); | ||
1500 | return; | ||
1501 | } | ||
1502 | @@ -913,9 +886,13 @@ static int set_msr_mce(struct kvm_vcpu *vcpu, u32 msr, u64 data) | ||
1503 | if (msr >= MSR_IA32_MC0_CTL && | ||
1504 | msr < MSR_IA32_MC0_CTL + 4 * bank_num) { | ||
1505 | u32 offset = msr - MSR_IA32_MC0_CTL; | ||
1506 | - /* only 0 or all 1s can be written to IA32_MCi_CTL */ | ||
1507 | + /* only 0 or all 1s can be written to IA32_MCi_CTL | ||
1508 | + * some Linux kernels though clear bit 10 in bank 4 to | ||
1509 | + * workaround a BIOS/GART TBL issue on AMD K8s, ignore | ||
1510 | + * this to avoid an uncatched #GP in the guest | ||
1511 | + */ | ||
1512 | if ((offset & 0x3) == 0 && | ||
1513 | - data != 0 && data != ~(u64)0) | ||
1514 | + data != 0 && (data | (1 << 10)) != ~(u64)0) | ||
1515 | return -1; | ||
1516 | vcpu->arch.mce_banks[offset] = data; | ||
1517 | break; | ||
1518 | @@ -2366,7 +2343,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
1519 | struct kvm_dirty_log *log) | ||
1520 | { | ||
1521 | int r; | ||
1522 | - int n; | ||
1523 | + unsigned long n; | ||
1524 | struct kvm_memory_slot *memslot; | ||
1525 | int is_dirty = 0; | ||
1526 | |||
1527 | @@ -2382,7 +2359,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | ||
1528 | kvm_mmu_slot_remove_write_access(kvm, log->slot); | ||
1529 | spin_unlock(&kvm->mmu_lock); | ||
1530 | memslot = &kvm->memslots[log->slot]; | ||
1531 | - n = ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
1532 | + n = kvm_dirty_bitmap_bytes(memslot); | ||
1533 | memset(memslot->dirty_bitmap, 0, n); | ||
1534 | } | ||
1535 | r = 0; | ||
1536 | @@ -4599,6 +4576,7 @@ int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason) | ||
1537 | int ret = 0; | ||
1538 | u32 old_tss_base = get_segment_base(vcpu, VCPU_SREG_TR); | ||
1539 | u16 old_tss_sel = get_segment_selector(vcpu, VCPU_SREG_TR); | ||
1540 | + u32 desc_limit; | ||
1541 | |||
1542 | old_tss_base = vcpu->arch.mmu.gva_to_gpa(vcpu, old_tss_base); | ||
1543 | |||
1544 | @@ -4621,7 +4599,10 @@ int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason) | ||
1545 | } | ||
1546 | } | ||
1547 | |||
1548 | - if (!nseg_desc.p || get_desc_limit(&nseg_desc) < 0x67) { | ||
1549 | + desc_limit = get_desc_limit(&nseg_desc); | ||
1550 | + if (!nseg_desc.p || | ||
1551 | + ((desc_limit < 0x67 && (nseg_desc.type & 8)) || | ||
1552 | + desc_limit < 0x2b)) { | ||
1553 | kvm_queue_exception_e(vcpu, TS_VECTOR, tss_selector & 0xfffc); | ||
1554 | return 1; | ||
1555 | } | ||
1556 | diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile | ||
1557 | index cffd754..ddef409 100644 | ||
1558 | --- a/arch/x86/lib/Makefile | ||
1559 | +++ b/arch/x86/lib/Makefile | ||
1560 | @@ -14,7 +14,7 @@ $(obj)/inat.o: $(obj)/inat-tables.c | ||
1561 | |||
1562 | clean-files := inat-tables.c | ||
1563 | |||
1564 | -obj-$(CONFIG_SMP) += msr-smp.o | ||
1565 | +obj-$(CONFIG_SMP) += msr-smp.o cache-smp.o | ||
1566 | |||
1567 | lib-y := delay.o | ||
1568 | lib-y += thunk_$(BITS).o | ||
1569 | @@ -39,4 +39,5 @@ else | ||
1570 | lib-y += thunk_64.o clear_page_64.o copy_page_64.o | ||
1571 | lib-y += memmove_64.o memset_64.o | ||
1572 | lib-y += copy_user_64.o rwlock_64.o copy_user_nocache_64.o | ||
1573 | + lib-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem_64.o | ||
1574 | endif | ||
1575 | diff --git a/arch/x86/lib/cache-smp.c b/arch/x86/lib/cache-smp.c | ||
1576 | new file mode 100644 | ||
1577 | index 0000000..a3c6688 | ||
1578 | --- /dev/null | ||
1579 | +++ b/arch/x86/lib/cache-smp.c | ||
1580 | @@ -0,0 +1,19 @@ | ||
1581 | +#include <linux/smp.h> | ||
1582 | +#include <linux/module.h> | ||
1583 | + | ||
1584 | +static void __wbinvd(void *dummy) | ||
1585 | +{ | ||
1586 | + wbinvd(); | ||
1587 | +} | ||
1588 | + | ||
1589 | +void wbinvd_on_cpu(int cpu) | ||
1590 | +{ | ||
1591 | + smp_call_function_single(cpu, __wbinvd, NULL, 1); | ||
1592 | +} | ||
1593 | +EXPORT_SYMBOL(wbinvd_on_cpu); | ||
1594 | + | ||
1595 | +int wbinvd_on_all_cpus(void) | ||
1596 | +{ | ||
1597 | + return on_each_cpu(__wbinvd, NULL, 1); | ||
1598 | +} | ||
1599 | +EXPORT_SYMBOL(wbinvd_on_all_cpus); | ||
1600 | diff --git a/arch/x86/lib/rwsem_64.S b/arch/x86/lib/rwsem_64.S | ||
1601 | new file mode 100644 | ||
1602 | index 0000000..15acecf | ||
1603 | --- /dev/null | ||
1604 | +++ b/arch/x86/lib/rwsem_64.S | ||
1605 | @@ -0,0 +1,81 @@ | ||
1606 | +/* | ||
1607 | + * x86-64 rwsem wrappers | ||
1608 | + * | ||
1609 | + * This interfaces the inline asm code to the slow-path | ||
1610 | + * C routines. We need to save the call-clobbered regs | ||
1611 | + * that the asm does not mark as clobbered, and move the | ||
1612 | + * argument from %rax to %rdi. | ||
1613 | + * | ||
1614 | + * NOTE! We don't need to save %rax, because the functions | ||
1615 | + * will always return the semaphore pointer in %rax (which | ||
1616 | + * is also the input argument to these helpers) | ||
1617 | + * | ||
1618 | + * The following can clobber %rdx because the asm clobbers it: | ||
1619 | + * call_rwsem_down_write_failed | ||
1620 | + * call_rwsem_wake | ||
1621 | + * but %rdi, %rsi, %rcx, %r8-r11 always need saving. | ||
1622 | + */ | ||
1623 | + | ||
1624 | +#include <linux/linkage.h> | ||
1625 | +#include <asm/rwlock.h> | ||
1626 | +#include <asm/alternative-asm.h> | ||
1627 | +#include <asm/frame.h> | ||
1628 | +#include <asm/dwarf2.h> | ||
1629 | + | ||
1630 | +#define save_common_regs \ | ||
1631 | + pushq %rdi; \ | ||
1632 | + pushq %rsi; \ | ||
1633 | + pushq %rcx; \ | ||
1634 | + pushq %r8; \ | ||
1635 | + pushq %r9; \ | ||
1636 | + pushq %r10; \ | ||
1637 | + pushq %r11 | ||
1638 | + | ||
1639 | +#define restore_common_regs \ | ||
1640 | + popq %r11; \ | ||
1641 | + popq %r10; \ | ||
1642 | + popq %r9; \ | ||
1643 | + popq %r8; \ | ||
1644 | + popq %rcx; \ | ||
1645 | + popq %rsi; \ | ||
1646 | + popq %rdi | ||
1647 | + | ||
1648 | +/* Fix up special calling conventions */ | ||
1649 | +ENTRY(call_rwsem_down_read_failed) | ||
1650 | + save_common_regs | ||
1651 | + pushq %rdx | ||
1652 | + movq %rax,%rdi | ||
1653 | + call rwsem_down_read_failed | ||
1654 | + popq %rdx | ||
1655 | + restore_common_regs | ||
1656 | + ret | ||
1657 | + ENDPROC(call_rwsem_down_read_failed) | ||
1658 | + | ||
1659 | +ENTRY(call_rwsem_down_write_failed) | ||
1660 | + save_common_regs | ||
1661 | + movq %rax,%rdi | ||
1662 | + call rwsem_down_write_failed | ||
1663 | + restore_common_regs | ||
1664 | + ret | ||
1665 | + ENDPROC(call_rwsem_down_write_failed) | ||
1666 | + | ||
1667 | +ENTRY(call_rwsem_wake) | ||
1668 | + decw %dx /* do nothing if still outstanding active readers */ | ||
1669 | + jnz 1f | ||
1670 | + save_common_regs | ||
1671 | + movq %rax,%rdi | ||
1672 | + call rwsem_wake | ||
1673 | + restore_common_regs | ||
1674 | +1: ret | ||
1675 | + ENDPROC(call_rwsem_wake) | ||
1676 | + | ||
1677 | +/* Fix up special calling conventions */ | ||
1678 | +ENTRY(call_rwsem_downgrade_wake) | ||
1679 | + save_common_regs | ||
1680 | + pushq %rdx | ||
1681 | + movq %rax,%rdi | ||
1682 | + call rwsem_downgrade_wake | ||
1683 | + popq %rdx | ||
1684 | + restore_common_regs | ||
1685 | + ret | ||
1686 | + ENDPROC(call_rwsem_downgrade_wake) | ||
1687 | diff --git a/arch/x86/pci/irq.c b/arch/x86/pci/irq.c | ||
1688 | index 0696d50..b02f6d8 100644 | ||
1689 | --- a/arch/x86/pci/irq.c | ||
1690 | +++ b/arch/x86/pci/irq.c | ||
1691 | @@ -590,6 +590,8 @@ static __init int intel_router_probe(struct irq_router *r, struct pci_dev *route | ||
1692 | case PCI_DEVICE_ID_INTEL_ICH10_1: | ||
1693 | case PCI_DEVICE_ID_INTEL_ICH10_2: | ||
1694 | case PCI_DEVICE_ID_INTEL_ICH10_3: | ||
1695 | + case PCI_DEVICE_ID_INTEL_CPT_LPC1: | ||
1696 | + case PCI_DEVICE_ID_INTEL_CPT_LPC2: | ||
1697 | r->name = "PIIX/ICH"; | ||
1698 | r->get = pirq_piix_get; | ||
1699 | r->set = pirq_piix_set; | ||
1700 | diff --git a/arch/x86/power/hibernate_asm_32.S b/arch/x86/power/hibernate_asm_32.S | ||
1701 | index b641388..ad47dae 100644 | ||
1702 | --- a/arch/x86/power/hibernate_asm_32.S | ||
1703 | +++ b/arch/x86/power/hibernate_asm_32.S | ||
1704 | @@ -27,10 +27,17 @@ ENTRY(swsusp_arch_suspend) | ||
1705 | ret | ||
1706 | |||
1707 | ENTRY(restore_image) | ||
1708 | + movl mmu_cr4_features, %ecx | ||
1709 | movl resume_pg_dir, %eax | ||
1710 | subl $__PAGE_OFFSET, %eax | ||
1711 | movl %eax, %cr3 | ||
1712 | |||
1713 | + jecxz 1f # cr4 Pentium and higher, skip if zero | ||
1714 | + andl $~(X86_CR4_PGE), %ecx | ||
1715 | + movl %ecx, %cr4; # turn off PGE | ||
1716 | + movl %cr3, %eax; # flush TLB | ||
1717 | + movl %eax, %cr3 | ||
1718 | +1: | ||
1719 | movl restore_pblist, %edx | ||
1720 | .p2align 4,,7 | ||
1721 | |||
1722 | @@ -54,16 +61,8 @@ done: | ||
1723 | movl $swapper_pg_dir, %eax | ||
1724 | subl $__PAGE_OFFSET, %eax | ||
1725 | movl %eax, %cr3 | ||
1726 | - /* Flush TLB, including "global" things (vmalloc) */ | ||
1727 | movl mmu_cr4_features, %ecx | ||
1728 | jecxz 1f # cr4 Pentium and higher, skip if zero | ||
1729 | - movl %ecx, %edx | ||
1730 | - andl $~(X86_CR4_PGE), %edx | ||
1731 | - movl %edx, %cr4; # turn off PGE | ||
1732 | -1: | ||
1733 | - movl %cr3, %eax; # flush TLB | ||
1734 | - movl %eax, %cr3 | ||
1735 | - jecxz 1f # cr4 Pentium and higher, skip if zero | ||
1736 | movl %ecx, %cr4; # turn PGE back on | ||
1737 | 1: | ||
1738 | |||
1739 | diff --git a/drivers/acpi/acpica/exprep.c b/drivers/acpi/acpica/exprep.c | ||
1740 | index 52fec07..83b6252 100644 | ||
1741 | --- a/drivers/acpi/acpica/exprep.c | ||
1742 | +++ b/drivers/acpi/acpica/exprep.c | ||
1743 | @@ -468,6 +468,23 @@ acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info) | ||
1744 | |||
1745 | acpi_ut_add_reference(obj_desc->field.region_obj); | ||
1746 | |||
1747 | + /* allow full data read from EC address space */ | ||
1748 | + if (obj_desc->field.region_obj->region.space_id == | ||
1749 | + ACPI_ADR_SPACE_EC) { | ||
1750 | + if (obj_desc->common_field.bit_length > 8) { | ||
1751 | + unsigned width = | ||
1752 | + ACPI_ROUND_BITS_UP_TO_BYTES( | ||
1753 | + obj_desc->common_field.bit_length); | ||
1754 | + // access_bit_width is u8, don't overflow it | ||
1755 | + if (width > 8) | ||
1756 | + width = 8; | ||
1757 | + obj_desc->common_field.access_byte_width = | ||
1758 | + width; | ||
1759 | + obj_desc->common_field.access_bit_width = | ||
1760 | + 8 * width; | ||
1761 | + } | ||
1762 | + } | ||
1763 | + | ||
1764 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, | ||
1765 | "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", | ||
1766 | obj_desc->field.start_field_bit_offset, | ||
1767 | diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c | ||
1768 | index d6471bb..fc67d11 100644 | ||
1769 | --- a/drivers/acpi/ec.c | ||
1770 | +++ b/drivers/acpi/ec.c | ||
1771 | @@ -589,12 +589,12 @@ static u32 acpi_ec_gpe_handler(void *data) | ||
1772 | |||
1773 | static acpi_status | ||
1774 | acpi_ec_space_handler(u32 function, acpi_physical_address address, | ||
1775 | - u32 bits, acpi_integer *value, | ||
1776 | + u32 bits, acpi_integer *value64, | ||
1777 | void *handler_context, void *region_context) | ||
1778 | { | ||
1779 | struct acpi_ec *ec = handler_context; | ||
1780 | - int result = 0, i; | ||
1781 | - u8 temp = 0; | ||
1782 | + int result = 0, i, bytes = bits / 8; | ||
1783 | + u8 *value = (u8 *)value64; | ||
1784 | |||
1785 | if ((address > 0xFF) || !value || !handler_context) | ||
1786 | return AE_BAD_PARAMETER; | ||
1787 | @@ -602,32 +602,15 @@ acpi_ec_space_handler(u32 function, acpi_physical_address address, | ||
1788 | if (function != ACPI_READ && function != ACPI_WRITE) | ||
1789 | return AE_BAD_PARAMETER; | ||
1790 | |||
1791 | - if (bits != 8 && acpi_strict) | ||
1792 | - return AE_BAD_PARAMETER; | ||
1793 | - | ||
1794 | - if (EC_FLAGS_MSI) | ||
1795 | + if (EC_FLAGS_MSI || bits > 8) | ||
1796 | acpi_ec_burst_enable(ec); | ||
1797 | |||
1798 | - if (function == ACPI_READ) { | ||
1799 | - result = acpi_ec_read(ec, address, &temp); | ||
1800 | - *value = temp; | ||
1801 | - } else { | ||
1802 | - temp = 0xff & (*value); | ||
1803 | - result = acpi_ec_write(ec, address, temp); | ||
1804 | - } | ||
1805 | - | ||
1806 | - for (i = 8; unlikely(bits - i > 0); i += 8) { | ||
1807 | - ++address; | ||
1808 | - if (function == ACPI_READ) { | ||
1809 | - result = acpi_ec_read(ec, address, &temp); | ||
1810 | - (*value) |= ((acpi_integer)temp) << i; | ||
1811 | - } else { | ||
1812 | - temp = 0xff & ((*value) >> i); | ||
1813 | - result = acpi_ec_write(ec, address, temp); | ||
1814 | - } | ||
1815 | - } | ||
1816 | + for (i = 0; i < bytes; ++i, ++address, ++value) | ||
1817 | + result = (function == ACPI_READ) ? | ||
1818 | + acpi_ec_read(ec, address, value) : | ||
1819 | + acpi_ec_write(ec, address, *value); | ||
1820 | |||
1821 | - if (EC_FLAGS_MSI) | ||
1822 | + if (EC_FLAGS_MSI || bits > 8) | ||
1823 | acpi_ec_burst_disable(ec); | ||
1824 | |||
1825 | switch (result) { | ||
1826 | diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c | ||
1827 | index 9e2feb6..462200d 100644 | ||
1828 | --- a/drivers/ata/ahci.c | ||
1829 | +++ b/drivers/ata/ahci.c | ||
1830 | @@ -570,6 +570,12 @@ static const struct pci_device_id ahci_pci_tbl[] = { | ||
1831 | { PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */ | ||
1832 | { PCI_VDEVICE(INTEL, 0x3b2c), board_ahci }, /* PCH RAID */ | ||
1833 | { PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */ | ||
1834 | + { PCI_VDEVICE(INTEL, 0x1c02), board_ahci }, /* CPT AHCI */ | ||
1835 | + { PCI_VDEVICE(INTEL, 0x1c03), board_ahci }, /* CPT AHCI */ | ||
1836 | + { PCI_VDEVICE(INTEL, 0x1c04), board_ahci }, /* CPT RAID */ | ||
1837 | + { PCI_VDEVICE(INTEL, 0x1c05), board_ahci }, /* CPT RAID */ | ||
1838 | + { PCI_VDEVICE(INTEL, 0x1c06), board_ahci }, /* CPT RAID */ | ||
1839 | + { PCI_VDEVICE(INTEL, 0x1c07), board_ahci }, /* CPT RAID */ | ||
1840 | |||
1841 | /* JMicron 360/1/3/5/6, match class to avoid IDE function */ | ||
1842 | { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, | ||
1843 | diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c | ||
1844 | index 6f3f225..b5f614b 100644 | ||
1845 | --- a/drivers/ata/ata_piix.c | ||
1846 | +++ b/drivers/ata/ata_piix.c | ||
1847 | @@ -291,6 +291,14 @@ static const struct pci_device_id piix_pci_tbl[] = { | ||
1848 | { 0x8086, 0x3b2d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata }, | ||
1849 | /* SATA Controller IDE (PCH) */ | ||
1850 | { 0x8086, 0x3b2e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata }, | ||
1851 | + /* SATA Controller IDE (CPT) */ | ||
1852 | + { 0x8086, 0x1c00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata }, | ||
1853 | + /* SATA Controller IDE (CPT) */ | ||
1854 | + { 0x8086, 0x1c01, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata }, | ||
1855 | + /* SATA Controller IDE (CPT) */ | ||
1856 | + { 0x8086, 0x1c08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata }, | ||
1857 | + /* SATA Controller IDE (CPT) */ | ||
1858 | + { 0x8086, 0x1c09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata }, | ||
1859 | { } /* terminate list */ | ||
1860 | }; | ||
1861 | |||
1862 | diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c | ||
1863 | index 6728328..2401c9c 100644 | ||
1864 | --- a/drivers/ata/libata-core.c | ||
1865 | +++ b/drivers/ata/libata-core.c | ||
1866 | @@ -4348,6 +4348,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { | ||
1867 | { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, }, | ||
1868 | { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, }, | ||
1869 | |||
1870 | + /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */ | ||
1871 | + { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ, }, | ||
1872 | + | ||
1873 | /* devices which puke on READ_NATIVE_MAX */ | ||
1874 | { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, }, | ||
1875 | { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA }, | ||
1876 | diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c | ||
1877 | index be7c395..ad64750 100644 | ||
1878 | --- a/drivers/ata/pata_via.c | ||
1879 | +++ b/drivers/ata/pata_via.c | ||
1880 | @@ -697,6 +697,7 @@ static const struct pci_device_id via[] = { | ||
1881 | { PCI_VDEVICE(VIA, 0x3164), }, | ||
1882 | { PCI_VDEVICE(VIA, 0x5324), }, | ||
1883 | { PCI_VDEVICE(VIA, 0xC409), VIA_IDFLAG_SINGLE }, | ||
1884 | + { PCI_VDEVICE(VIA, 0x9001), VIA_IDFLAG_SINGLE }, | ||
1885 | |||
1886 | { }, | ||
1887 | }; | ||
1888 | diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c | ||
1889 | index 3999a5f..8a713f1 100644 | ||
1890 | --- a/drivers/char/agp/intel-agp.c | ||
1891 | +++ b/drivers/char/agp/intel-agp.c | ||
1892 | @@ -8,6 +8,7 @@ | ||
1893 | #include <linux/kernel.h> | ||
1894 | #include <linux/pagemap.h> | ||
1895 | #include <linux/agp_backend.h> | ||
1896 | +#include <asm/smp.h> | ||
1897 | #include "agp.h" | ||
1898 | |||
1899 | /* | ||
1900 | @@ -815,12 +816,6 @@ static void intel_i830_setup_flush(void) | ||
1901 | intel_i830_fini_flush(); | ||
1902 | } | ||
1903 | |||
1904 | -static void | ||
1905 | -do_wbinvd(void *null) | ||
1906 | -{ | ||
1907 | - wbinvd(); | ||
1908 | -} | ||
1909 | - | ||
1910 | /* The chipset_flush interface needs to get data that has already been | ||
1911 | * flushed out of the CPU all the way out to main memory, because the GPU | ||
1912 | * doesn't snoop those buffers. | ||
1913 | @@ -837,12 +832,10 @@ static void intel_i830_chipset_flush(struct agp_bridge_data *bridge) | ||
1914 | |||
1915 | memset(pg, 0, 1024); | ||
1916 | |||
1917 | - if (cpu_has_clflush) { | ||
1918 | + if (cpu_has_clflush) | ||
1919 | clflush_cache_range(pg, 1024); | ||
1920 | - } else { | ||
1921 | - if (on_each_cpu(do_wbinvd, NULL, 1) != 0) | ||
1922 | - printk(KERN_ERR "Timed out waiting for cache flush.\n"); | ||
1923 | - } | ||
1924 | + else if (wbinvd_on_all_cpus() != 0) | ||
1925 | + printk(KERN_ERR "Timed out waiting for cache flush.\n"); | ||
1926 | } | ||
1927 | |||
1928 | /* The intel i830 automatically initializes the agp aperture during POST. | ||
1929 | diff --git a/drivers/char/raw.c b/drivers/char/raw.c | ||
1930 | index 64acd05..9abc3a1 100644 | ||
1931 | --- a/drivers/char/raw.c | ||
1932 | +++ b/drivers/char/raw.c | ||
1933 | @@ -247,6 +247,7 @@ static const struct file_operations raw_fops = { | ||
1934 | .aio_read = generic_file_aio_read, | ||
1935 | .write = do_sync_write, | ||
1936 | .aio_write = blkdev_aio_write, | ||
1937 | + .fsync = block_fsync, | ||
1938 | .open = raw_open, | ||
1939 | .release= raw_release, | ||
1940 | .ioctl = raw_ioctl, | ||
1941 | diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c | ||
1942 | index dcb9083..76253cf 100644 | ||
1943 | --- a/drivers/char/tty_io.c | ||
1944 | +++ b/drivers/char/tty_io.c | ||
1945 | @@ -1423,6 +1423,8 @@ static void release_one_tty(struct work_struct *work) | ||
1946 | list_del_init(&tty->tty_files); | ||
1947 | file_list_unlock(); | ||
1948 | |||
1949 | + put_pid(tty->pgrp); | ||
1950 | + put_pid(tty->session); | ||
1951 | free_tty_struct(tty); | ||
1952 | } | ||
1953 | |||
1954 | diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c | ||
1955 | index 7d0f00a..99907c3 100644 | ||
1956 | --- a/drivers/gpu/drm/drm_crtc_helper.c | ||
1957 | +++ b/drivers/gpu/drm/drm_crtc_helper.c | ||
1958 | @@ -104,6 +104,7 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector, | ||
1959 | if (connector->status == connector_status_disconnected) { | ||
1960 | DRM_DEBUG_KMS("%s is disconnected\n", | ||
1961 | drm_get_connector_name(connector)); | ||
1962 | + drm_mode_connector_update_edid_property(connector, NULL); | ||
1963 | goto prune; | ||
1964 | } | ||
1965 | |||
1966 | diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c | ||
1967 | index ab6c973..bfd0e4a 100644 | ||
1968 | --- a/drivers/gpu/drm/drm_edid.c | ||
1969 | +++ b/drivers/gpu/drm/drm_edid.c | ||
1970 | @@ -85,6 +85,8 @@ static struct edid_quirk { | ||
1971 | |||
1972 | /* Envision Peripherals, Inc. EN-7100e */ | ||
1973 | { "EPI", 59264, EDID_QUIRK_135_CLOCK_TOO_HIGH }, | ||
1974 | + /* Envision EN2028 */ | ||
1975 | + { "EPI", 8232, EDID_QUIRK_PREFER_LARGE_60 }, | ||
1976 | |||
1977 | /* Funai Electronics PM36B */ | ||
1978 | { "FCM", 13600, EDID_QUIRK_PREFER_LARGE_75 | | ||
1979 | @@ -707,15 +709,6 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev, | ||
1980 | mode->vsync_end = mode->vsync_start + vsync_pulse_width; | ||
1981 | mode->vtotal = mode->vdisplay + vblank; | ||
1982 | |||
1983 | - /* perform the basic check for the detailed timing */ | ||
1984 | - if (mode->hsync_end > mode->htotal || | ||
1985 | - mode->vsync_end > mode->vtotal) { | ||
1986 | - drm_mode_destroy(dev, mode); | ||
1987 | - DRM_DEBUG_KMS("Incorrect detailed timing. " | ||
1988 | - "Sync is beyond the blank.\n"); | ||
1989 | - return NULL; | ||
1990 | - } | ||
1991 | - | ||
1992 | /* Some EDIDs have bogus h/vtotal values */ | ||
1993 | if (mode->hsync_end > mode->htotal) | ||
1994 | mode->htotal = mode->hsync_end + 1; | ||
1995 | diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c | ||
1996 | index 08d14df..4804872 100644 | ||
1997 | --- a/drivers/gpu/drm/drm_fops.c | ||
1998 | +++ b/drivers/gpu/drm/drm_fops.c | ||
1999 | @@ -140,14 +140,16 @@ int drm_open(struct inode *inode, struct file *filp) | ||
2000 | spin_unlock(&dev->count_lock); | ||
2001 | } | ||
2002 | out: | ||
2003 | - mutex_lock(&dev->struct_mutex); | ||
2004 | - if (minor->type == DRM_MINOR_LEGACY) { | ||
2005 | - BUG_ON((dev->dev_mapping != NULL) && | ||
2006 | - (dev->dev_mapping != inode->i_mapping)); | ||
2007 | - if (dev->dev_mapping == NULL) | ||
2008 | - dev->dev_mapping = inode->i_mapping; | ||
2009 | + if (!retcode) { | ||
2010 | + mutex_lock(&dev->struct_mutex); | ||
2011 | + if (minor->type == DRM_MINOR_LEGACY) { | ||
2012 | + if (dev->dev_mapping == NULL) | ||
2013 | + dev->dev_mapping = inode->i_mapping; | ||
2014 | + else if (dev->dev_mapping != inode->i_mapping) | ||
2015 | + retcode = -ENODEV; | ||
2016 | + } | ||
2017 | + mutex_unlock(&dev->struct_mutex); | ||
2018 | } | ||
2019 | - mutex_unlock(&dev->struct_mutex); | ||
2020 | |||
2021 | return retcode; | ||
2022 | } | ||
2023 | diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c | ||
2024 | index 93031a7..1238bc9 100644 | ||
2025 | --- a/drivers/gpu/drm/i915/intel_lvds.c | ||
2026 | +++ b/drivers/gpu/drm/i915/intel_lvds.c | ||
2027 | @@ -899,6 +899,14 @@ static const struct dmi_system_id intel_no_lvds[] = { | ||
2028 | DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"), | ||
2029 | }, | ||
2030 | }, | ||
2031 | + { | ||
2032 | + .callback = intel_no_lvds_dmi_callback, | ||
2033 | + .ident = "Clientron U800", | ||
2034 | + .matches = { | ||
2035 | + DMI_MATCH(DMI_SYS_VENDOR, "Clientron"), | ||
2036 | + DMI_MATCH(DMI_PRODUCT_NAME, "U800"), | ||
2037 | + }, | ||
2038 | + }, | ||
2039 | |||
2040 | { } /* terminating entry */ | ||
2041 | }; | ||
2042 | diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c | ||
2043 | index d75788f..b1f929d 100644 | ||
2044 | --- a/drivers/gpu/drm/radeon/atom.c | ||
2045 | +++ b/drivers/gpu/drm/radeon/atom.c | ||
2046 | @@ -881,11 +881,16 @@ static void atom_op_shl(atom_exec_context *ctx, int *ptr, int arg) | ||
2047 | uint8_t attr = U8((*ptr)++), shift; | ||
2048 | uint32_t saved, dst; | ||
2049 | int dptr = *ptr; | ||
2050 | + uint32_t dst_align = atom_dst_to_src[(attr >> 3) & 7][(attr >> 6) & 3]; | ||
2051 | SDEBUG(" dst: "); | ||
2052 | dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1); | ||
2053 | + /* op needs to full dst value */ | ||
2054 | + dst = saved; | ||
2055 | shift = atom_get_src(ctx, attr, ptr); | ||
2056 | SDEBUG(" shift: %d\n", shift); | ||
2057 | dst <<= shift; | ||
2058 | + dst &= atom_arg_mask[dst_align]; | ||
2059 | + dst >>= atom_arg_shift[dst_align]; | ||
2060 | SDEBUG(" dst: "); | ||
2061 | atom_put_dst(ctx, arg, attr, &dptr, dst, saved); | ||
2062 | } | ||
2063 | @@ -895,11 +900,16 @@ static void atom_op_shr(atom_exec_context *ctx, int *ptr, int arg) | ||
2064 | uint8_t attr = U8((*ptr)++), shift; | ||
2065 | uint32_t saved, dst; | ||
2066 | int dptr = *ptr; | ||
2067 | + uint32_t dst_align = atom_dst_to_src[(attr >> 3) & 7][(attr >> 6) & 3]; | ||
2068 | SDEBUG(" dst: "); | ||
2069 | dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1); | ||
2070 | + /* op needs to full dst value */ | ||
2071 | + dst = saved; | ||
2072 | shift = atom_get_src(ctx, attr, ptr); | ||
2073 | SDEBUG(" shift: %d\n", shift); | ||
2074 | dst >>= shift; | ||
2075 | + dst &= atom_arg_mask[dst_align]; | ||
2076 | + dst >>= atom_arg_shift[dst_align]; | ||
2077 | SDEBUG(" dst: "); | ||
2078 | atom_put_dst(ctx, arg, attr, &dptr, dst, saved); | ||
2079 | } | ||
2080 | diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c | ||
2081 | index 43b55a0..5bdfaf2 100644 | ||
2082 | --- a/drivers/gpu/drm/radeon/r300.c | ||
2083 | +++ b/drivers/gpu/drm/radeon/r300.c | ||
2084 | @@ -364,11 +364,12 @@ void r300_gpu_init(struct radeon_device *rdev) | ||
2085 | |||
2086 | r100_hdp_reset(rdev); | ||
2087 | /* FIXME: rv380 one pipes ? */ | ||
2088 | - if ((rdev->family == CHIP_R300) || (rdev->family == CHIP_R350)) { | ||
2089 | + if ((rdev->family == CHIP_R300 && rdev->pdev->device != 0x4144) || | ||
2090 | + (rdev->family == CHIP_R350)) { | ||
2091 | /* r300,r350 */ | ||
2092 | rdev->num_gb_pipes = 2; | ||
2093 | } else { | ||
2094 | - /* rv350,rv370,rv380 */ | ||
2095 | + /* rv350,rv370,rv380,r300 AD */ | ||
2096 | rdev->num_gb_pipes = 1; | ||
2097 | } | ||
2098 | rdev->num_z_pipes = 1; | ||
2099 | diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c | ||
2100 | index e7b1944..81b832e 100644 | ||
2101 | --- a/drivers/gpu/drm/radeon/radeon_combios.c | ||
2102 | +++ b/drivers/gpu/drm/radeon/radeon_combios.c | ||
2103 | @@ -670,7 +670,9 @@ struct radeon_encoder_primary_dac *radeon_combios_get_primary_dac_info(struct | ||
2104 | dac = RBIOS8(dac_info + 0x3) & 0xf; | ||
2105 | p_dac->ps2_pdac_adj = (bg << 8) | (dac); | ||
2106 | } | ||
2107 | - found = 1; | ||
2108 | + /* if the values are all zeros, use the table */ | ||
2109 | + if (p_dac->ps2_pdac_adj) | ||
2110 | + found = 1; | ||
2111 | } | ||
2112 | |||
2113 | out: | ||
2114 | @@ -812,7 +814,9 @@ struct radeon_encoder_tv_dac *radeon_combios_get_tv_dac_info(struct | ||
2115 | bg = RBIOS8(dac_info + 0x10) & 0xf; | ||
2116 | dac = RBIOS8(dac_info + 0x11) & 0xf; | ||
2117 | tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20); | ||
2118 | - found = 1; | ||
2119 | + /* if the values are all zeros, use the table */ | ||
2120 | + if (tv_dac->ps2_tvdac_adj) | ||
2121 | + found = 1; | ||
2122 | } else if (rev > 1) { | ||
2123 | bg = RBIOS8(dac_info + 0xc) & 0xf; | ||
2124 | dac = (RBIOS8(dac_info + 0xc) >> 4) & 0xf; | ||
2125 | @@ -825,7 +829,9 @@ struct radeon_encoder_tv_dac *radeon_combios_get_tv_dac_info(struct | ||
2126 | bg = RBIOS8(dac_info + 0xe) & 0xf; | ||
2127 | dac = (RBIOS8(dac_info + 0xe) >> 4) & 0xf; | ||
2128 | tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20); | ||
2129 | - found = 1; | ||
2130 | + /* if the values are all zeros, use the table */ | ||
2131 | + if (tv_dac->ps2_tvdac_adj) | ||
2132 | + found = 1; | ||
2133 | } | ||
2134 | tv_dac->tv_std = radeon_combios_get_tv_info(rdev); | ||
2135 | } | ||
2136 | @@ -842,7 +848,9 @@ struct radeon_encoder_tv_dac *radeon_combios_get_tv_dac_info(struct | ||
2137 | (bg << 16) | (dac << 20); | ||
2138 | tv_dac->pal_tvdac_adj = tv_dac->ps2_tvdac_adj; | ||
2139 | tv_dac->ntsc_tvdac_adj = tv_dac->ps2_tvdac_adj; | ||
2140 | - found = 1; | ||
2141 | + /* if the values are all zeros, use the table */ | ||
2142 | + if (tv_dac->ps2_tvdac_adj) | ||
2143 | + found = 1; | ||
2144 | } else { | ||
2145 | bg = RBIOS8(dac_info + 0x4) & 0xf; | ||
2146 | dac = RBIOS8(dac_info + 0x5) & 0xf; | ||
2147 | @@ -850,7 +858,9 @@ struct radeon_encoder_tv_dac *radeon_combios_get_tv_dac_info(struct | ||
2148 | (bg << 16) | (dac << 20); | ||
2149 | tv_dac->pal_tvdac_adj = tv_dac->ps2_tvdac_adj; | ||
2150 | tv_dac->ntsc_tvdac_adj = tv_dac->ps2_tvdac_adj; | ||
2151 | - found = 1; | ||
2152 | + /* if the values are all zeros, use the table */ | ||
2153 | + if (tv_dac->ps2_tvdac_adj) | ||
2154 | + found = 1; | ||
2155 | } | ||
2156 | } else { | ||
2157 | DRM_INFO("No TV DAC info found in BIOS\n"); | ||
2158 | diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c | ||
2159 | index 65f8194..2bdfbcd 100644 | ||
2160 | --- a/drivers/gpu/drm/radeon/radeon_connectors.c | ||
2161 | +++ b/drivers/gpu/drm/radeon/radeon_connectors.c | ||
2162 | @@ -162,12 +162,14 @@ radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector, | ||
2163 | { | ||
2164 | struct drm_device *dev = connector->dev; | ||
2165 | struct drm_connector *conflict; | ||
2166 | + struct radeon_connector *radeon_conflict; | ||
2167 | int i; | ||
2168 | |||
2169 | list_for_each_entry(conflict, &dev->mode_config.connector_list, head) { | ||
2170 | if (conflict == connector) | ||
2171 | continue; | ||
2172 | |||
2173 | + radeon_conflict = to_radeon_connector(conflict); | ||
2174 | for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { | ||
2175 | if (conflict->encoder_ids[i] == 0) | ||
2176 | break; | ||
2177 | @@ -177,6 +179,9 @@ radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector, | ||
2178 | if (conflict->status != connector_status_connected) | ||
2179 | continue; | ||
2180 | |||
2181 | + if (radeon_conflict->use_digital) | ||
2182 | + continue; | ||
2183 | + | ||
2184 | if (priority == true) { | ||
2185 | DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict)); | ||
2186 | DRM_INFO("in favor of %s\n", drm_get_connector_name(connector)); | ||
2187 | @@ -315,7 +320,7 @@ int radeon_connector_set_property(struct drm_connector *connector, struct drm_pr | ||
2188 | radeon_encoder = to_radeon_encoder(encoder); | ||
2189 | if (!radeon_encoder->enc_priv) | ||
2190 | return 0; | ||
2191 | - if (rdev->is_atom_bios) { | ||
2192 | + if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) { | ||
2193 | struct radeon_encoder_atom_dac *dac_int; | ||
2194 | dac_int = radeon_encoder->enc_priv; | ||
2195 | dac_int->tv_std = val; | ||
2196 | diff --git a/drivers/gpu/drm/radeon/radeon_cp.c b/drivers/gpu/drm/radeon/radeon_cp.c | ||
2197 | index 06123ba..f129bbb 100644 | ||
2198 | --- a/drivers/gpu/drm/radeon/radeon_cp.c | ||
2199 | +++ b/drivers/gpu/drm/radeon/radeon_cp.c | ||
2200 | @@ -417,8 +417,9 @@ static int radeon_do_wait_for_idle(drm_radeon_private_t * dev_priv) | ||
2201 | return -EBUSY; | ||
2202 | } | ||
2203 | |||
2204 | -static void radeon_init_pipes(drm_radeon_private_t *dev_priv) | ||
2205 | +static void radeon_init_pipes(struct drm_device *dev) | ||
2206 | { | ||
2207 | + drm_radeon_private_t *dev_priv = dev->dev_private; | ||
2208 | uint32_t gb_tile_config, gb_pipe_sel = 0; | ||
2209 | |||
2210 | if ((dev_priv->flags & RADEON_FAMILY_MASK) == CHIP_RV530) { | ||
2211 | @@ -436,11 +437,12 @@ static void radeon_init_pipes(drm_radeon_private_t *dev_priv) | ||
2212 | dev_priv->num_gb_pipes = ((gb_pipe_sel >> 12) & 0x3) + 1; | ||
2213 | } else { | ||
2214 | /* R3xx */ | ||
2215 | - if (((dev_priv->flags & RADEON_FAMILY_MASK) == CHIP_R300) || | ||
2216 | + if (((dev_priv->flags & RADEON_FAMILY_MASK) == CHIP_R300 && | ||
2217 | + dev->pdev->device != 0x4144) || | ||
2218 | ((dev_priv->flags & RADEON_FAMILY_MASK) == CHIP_R350)) { | ||
2219 | dev_priv->num_gb_pipes = 2; | ||
2220 | } else { | ||
2221 | - /* R3Vxx */ | ||
2222 | + /* RV3xx/R300 AD */ | ||
2223 | dev_priv->num_gb_pipes = 1; | ||
2224 | } | ||
2225 | } | ||
2226 | @@ -736,7 +738,7 @@ static int radeon_do_engine_reset(struct drm_device * dev) | ||
2227 | |||
2228 | /* setup the raster pipes */ | ||
2229 | if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_R300) | ||
2230 | - radeon_init_pipes(dev_priv); | ||
2231 | + radeon_init_pipes(dev); | ||
2232 | |||
2233 | /* Reset the CP ring */ | ||
2234 | radeon_do_cp_reset(dev_priv); | ||
2235 | diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c | ||
2236 | index e9d0850..9933c2c 100644 | ||
2237 | --- a/drivers/gpu/drm/radeon/radeon_cs.c | ||
2238 | +++ b/drivers/gpu/drm/radeon/radeon_cs.c | ||
2239 | @@ -193,11 +193,13 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error) | ||
2240 | radeon_bo_list_fence(&parser->validated, parser->ib->fence); | ||
2241 | } | ||
2242 | radeon_bo_list_unreserve(&parser->validated); | ||
2243 | - for (i = 0; i < parser->nrelocs; i++) { | ||
2244 | - if (parser->relocs[i].gobj) { | ||
2245 | - mutex_lock(&parser->rdev->ddev->struct_mutex); | ||
2246 | - drm_gem_object_unreference(parser->relocs[i].gobj); | ||
2247 | - mutex_unlock(&parser->rdev->ddev->struct_mutex); | ||
2248 | + if (parser->relocs != NULL) { | ||
2249 | + for (i = 0; i < parser->nrelocs; i++) { | ||
2250 | + if (parser->relocs[i].gobj) { | ||
2251 | + mutex_lock(&parser->rdev->ddev->struct_mutex); | ||
2252 | + drm_gem_object_unreference(parser->relocs[i].gobj); | ||
2253 | + mutex_unlock(&parser->rdev->ddev->struct_mutex); | ||
2254 | + } | ||
2255 | } | ||
2256 | } | ||
2257 | kfree(parser->track); | ||
2258 | @@ -246,7 +248,8 @@ int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) | ||
2259 | } | ||
2260 | r = radeon_cs_parser_relocs(&parser); | ||
2261 | if (r) { | ||
2262 | - DRM_ERROR("Failed to parse relocation !\n"); | ||
2263 | + if (r != -ERESTARTSYS) | ||
2264 | + DRM_ERROR("Failed to parse relocation %d!\n", r); | ||
2265 | radeon_cs_parser_fini(&parser, r); | ||
2266 | mutex_unlock(&rdev->cs_mutex); | ||
2267 | return r; | ||
2268 | diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c | ||
2269 | index 768b150..509ba3f 100644 | ||
2270 | --- a/drivers/gpu/drm/radeon/radeon_device.c | ||
2271 | +++ b/drivers/gpu/drm/radeon/radeon_device.c | ||
2272 | @@ -655,6 +655,14 @@ int radeon_device_init(struct radeon_device *rdev, | ||
2273 | return r; | ||
2274 | radeon_check_arguments(rdev); | ||
2275 | |||
2276 | + /* all of the newer IGP chips have an internal gart | ||
2277 | + * However some rs4xx report as AGP, so remove that here. | ||
2278 | + */ | ||
2279 | + if ((rdev->family >= CHIP_RS400) && | ||
2280 | + (rdev->flags & RADEON_IS_IGP)) { | ||
2281 | + rdev->flags &= ~RADEON_IS_AGP; | ||
2282 | + } | ||
2283 | + | ||
2284 | if (rdev->flags & RADEON_IS_AGP && radeon_agpmode == -1) { | ||
2285 | radeon_agp_disable(rdev); | ||
2286 | } | ||
2287 | diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c | ||
2288 | index 3c91724..7626bd5 100644 | ||
2289 | --- a/drivers/gpu/drm/radeon/radeon_encoders.c | ||
2290 | +++ b/drivers/gpu/drm/radeon/radeon_encoders.c | ||
2291 | @@ -1276,8 +1276,12 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder, | ||
2292 | case ENCODER_OBJECT_ID_INTERNAL_DAC2: | ||
2293 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2: | ||
2294 | atombios_dac_setup(encoder, ATOM_ENABLE); | ||
2295 | - if (radeon_encoder->active_device & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) | ||
2296 | - atombios_tv_setup(encoder, ATOM_ENABLE); | ||
2297 | + if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) { | ||
2298 | + if (radeon_encoder->active_device & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) | ||
2299 | + atombios_tv_setup(encoder, ATOM_ENABLE); | ||
2300 | + else | ||
2301 | + atombios_tv_setup(encoder, ATOM_DISABLE); | ||
2302 | + } | ||
2303 | break; | ||
2304 | } | ||
2305 | atombios_apply_encoder_quirks(encoder, adjusted_mode); | ||
2306 | diff --git a/drivers/gpu/drm/radeon/radeon_legacy_tv.c b/drivers/gpu/drm/radeon/radeon_legacy_tv.c | ||
2307 | index 417684d..f2ed27c 100644 | ||
2308 | --- a/drivers/gpu/drm/radeon/radeon_legacy_tv.c | ||
2309 | +++ b/drivers/gpu/drm/radeon/radeon_legacy_tv.c | ||
2310 | @@ -57,6 +57,10 @@ | ||
2311 | #define NTSC_TV_PLL_N_14 693 | ||
2312 | #define NTSC_TV_PLL_P_14 7 | ||
2313 | |||
2314 | +#define PAL_TV_PLL_M_14 19 | ||
2315 | +#define PAL_TV_PLL_N_14 353 | ||
2316 | +#define PAL_TV_PLL_P_14 5 | ||
2317 | + | ||
2318 | #define VERT_LEAD_IN_LINES 2 | ||
2319 | #define FRAC_BITS 0xe | ||
2320 | #define FRAC_MASK 0x3fff | ||
2321 | @@ -205,9 +209,24 @@ static const struct radeon_tv_mode_constants available_tv_modes[] = { | ||
2322 | 630627, /* defRestart */ | ||
2323 | 347, /* crtcPLL_N */ | ||
2324 | 14, /* crtcPLL_M */ | ||
2325 | - 8, /* crtcPLL_postDiv */ | ||
2326 | + 8, /* crtcPLL_postDiv */ | ||
2327 | 1022, /* pixToTV */ | ||
2328 | }, | ||
2329 | + { /* PAL timing for 14 Mhz ref clk */ | ||
2330 | + 800, /* horResolution */ | ||
2331 | + 600, /* verResolution */ | ||
2332 | + TV_STD_PAL, /* standard */ | ||
2333 | + 1131, /* horTotal */ | ||
2334 | + 742, /* verTotal */ | ||
2335 | + 813, /* horStart */ | ||
2336 | + 840, /* horSyncStart */ | ||
2337 | + 633, /* verSyncStart */ | ||
2338 | + 708369, /* defRestart */ | ||
2339 | + 211, /* crtcPLL_N */ | ||
2340 | + 9, /* crtcPLL_M */ | ||
2341 | + 8, /* crtcPLL_postDiv */ | ||
2342 | + 759, /* pixToTV */ | ||
2343 | + }, | ||
2344 | }; | ||
2345 | |||
2346 | #define N_AVAILABLE_MODES ARRAY_SIZE(available_tv_modes) | ||
2347 | @@ -242,7 +261,7 @@ static const struct radeon_tv_mode_constants *radeon_legacy_tv_get_std_mode(stru | ||
2348 | if (pll->reference_freq == 2700) | ||
2349 | const_ptr = &available_tv_modes[1]; | ||
2350 | else | ||
2351 | - const_ptr = &available_tv_modes[1]; /* FIX ME */ | ||
2352 | + const_ptr = &available_tv_modes[3]; | ||
2353 | } | ||
2354 | return const_ptr; | ||
2355 | } | ||
2356 | @@ -685,9 +704,9 @@ void radeon_legacy_tv_mode_set(struct drm_encoder *encoder, | ||
2357 | n = PAL_TV_PLL_N_27; | ||
2358 | p = PAL_TV_PLL_P_27; | ||
2359 | } else { | ||
2360 | - m = PAL_TV_PLL_M_27; | ||
2361 | - n = PAL_TV_PLL_N_27; | ||
2362 | - p = PAL_TV_PLL_P_27; | ||
2363 | + m = PAL_TV_PLL_M_14; | ||
2364 | + n = PAL_TV_PLL_N_14; | ||
2365 | + p = PAL_TV_PLL_P_14; | ||
2366 | } | ||
2367 | } | ||
2368 | |||
2369 | diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c | ||
2370 | index c381856..a27c09f 100644 | ||
2371 | --- a/drivers/gpu/drm/radeon/rs600.c | ||
2372 | +++ b/drivers/gpu/drm/radeon/rs600.c | ||
2373 | @@ -175,7 +175,7 @@ void rs600_gart_tlb_flush(struct radeon_device *rdev) | ||
2374 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); | ||
2375 | |||
2376 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); | ||
2377 | - tmp |= S_000100_INVALIDATE_ALL_L1_TLBS(1) & S_000100_INVALIDATE_L2_CACHE(1); | ||
2378 | + tmp |= S_000100_INVALIDATE_ALL_L1_TLBS(1) | S_000100_INVALIDATE_L2_CACHE(1); | ||
2379 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); | ||
2380 | |||
2381 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); | ||
2382 | diff --git a/drivers/hid/hid-gyration.c b/drivers/hid/hid-gyration.c | ||
2383 | index cab13e8..62416e6 100644 | ||
2384 | --- a/drivers/hid/hid-gyration.c | ||
2385 | +++ b/drivers/hid/hid-gyration.c | ||
2386 | @@ -53,10 +53,13 @@ static int gyration_input_mapping(struct hid_device *hdev, struct hid_input *hi, | ||
2387 | static int gyration_event(struct hid_device *hdev, struct hid_field *field, | ||
2388 | struct hid_usage *usage, __s32 value) | ||
2389 | { | ||
2390 | - struct input_dev *input = field->hidinput->input; | ||
2391 | + | ||
2392 | + if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput) | ||
2393 | + return 0; | ||
2394 | |||
2395 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK && | ||
2396 | (usage->hid & 0xff) == 0x82) { | ||
2397 | + struct input_dev *input = field->hidinput->input; | ||
2398 | input_event(input, usage->type, usage->code, 1); | ||
2399 | input_sync(input); | ||
2400 | input_event(input, usage->type, usage->code, 0); | ||
2401 | diff --git a/drivers/hwmon/sht15.c b/drivers/hwmon/sht15.c | ||
2402 | index 864a371..fbc997e 100644 | ||
2403 | --- a/drivers/hwmon/sht15.c | ||
2404 | +++ b/drivers/hwmon/sht15.c | ||
2405 | @@ -302,13 +302,13 @@ error_ret: | ||
2406 | **/ | ||
2407 | static inline int sht15_calc_temp(struct sht15_data *data) | ||
2408 | { | ||
2409 | - int d1 = 0; | ||
2410 | + int d1 = temppoints[0].d1; | ||
2411 | int i; | ||
2412 | |||
2413 | - for (i = 1; i < ARRAY_SIZE(temppoints); i++) | ||
2414 | + for (i = ARRAY_SIZE(temppoints) - 1; i > 0; i--) | ||
2415 | /* Find pointer to interpolate */ | ||
2416 | if (data->supply_uV > temppoints[i - 1].vdd) { | ||
2417 | - d1 = (data->supply_uV/1000 - temppoints[i - 1].vdd) | ||
2418 | + d1 = (data->supply_uV - temppoints[i - 1].vdd) | ||
2419 | * (temppoints[i].d1 - temppoints[i - 1].d1) | ||
2420 | / (temppoints[i].vdd - temppoints[i - 1].vdd) | ||
2421 | + temppoints[i - 1].d1; | ||
2422 | @@ -541,7 +541,12 @@ static int __devinit sht15_probe(struct platform_device *pdev) | ||
2423 | /* If a regulator is available, query what the supply voltage actually is!*/ | ||
2424 | data->reg = regulator_get(data->dev, "vcc"); | ||
2425 | if (!IS_ERR(data->reg)) { | ||
2426 | - data->supply_uV = regulator_get_voltage(data->reg); | ||
2427 | + int voltage; | ||
2428 | + | ||
2429 | + voltage = regulator_get_voltage(data->reg); | ||
2430 | + if (voltage) | ||
2431 | + data->supply_uV = voltage; | ||
2432 | + | ||
2433 | regulator_enable(data->reg); | ||
2434 | /* setup a notifier block to update this if another device | ||
2435 | * causes the voltage to change */ | ||
2436 | diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig | ||
2437 | index 5f318ce..cb9f95c 100644 | ||
2438 | --- a/drivers/i2c/busses/Kconfig | ||
2439 | +++ b/drivers/i2c/busses/Kconfig | ||
2440 | @@ -77,7 +77,7 @@ config I2C_AMD8111 | ||
2441 | will be called i2c-amd8111. | ||
2442 | |||
2443 | config I2C_I801 | ||
2444 | - tristate "Intel 82801 (ICH)" | ||
2445 | + tristate "Intel 82801 (ICH/PCH)" | ||
2446 | depends on PCI | ||
2447 | help | ||
2448 | If you say yes to this option, support will be included for the Intel | ||
2449 | @@ -97,7 +97,8 @@ config I2C_I801 | ||
2450 | ICH9 | ||
2451 | Tolapai | ||
2452 | ICH10 | ||
2453 | - PCH | ||
2454 | + 3400/5 Series (PCH) | ||
2455 | + Cougar Point (PCH) | ||
2456 | |||
2457 | This driver can also be built as a module. If so, the module | ||
2458 | will be called i2c-i801. | ||
2459 | diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c | ||
2460 | index 5574be2..e361da7 100644 | ||
2461 | --- a/drivers/i2c/busses/i2c-i801.c | ||
2462 | +++ b/drivers/i2c/busses/i2c-i801.c | ||
2463 | @@ -41,7 +41,8 @@ | ||
2464 | Tolapai 0x5032 32 hard yes yes yes | ||
2465 | ICH10 0x3a30 32 hard yes yes yes | ||
2466 | ICH10 0x3a60 32 hard yes yes yes | ||
2467 | - PCH 0x3b30 32 hard yes yes yes | ||
2468 | + 3400/5 Series (PCH) 0x3b30 32 hard yes yes yes | ||
2469 | + Cougar Point (PCH) 0x1c22 32 hard yes yes yes | ||
2470 | |||
2471 | Features supported by this driver: | ||
2472 | Software PEC no | ||
2473 | @@ -580,6 +581,7 @@ static struct pci_device_id i801_ids[] = { | ||
2474 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_4) }, | ||
2475 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_5) }, | ||
2476 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PCH_SMBUS) }, | ||
2477 | + { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CPT_SMBUS) }, | ||
2478 | { 0, } | ||
2479 | }; | ||
2480 | |||
2481 | @@ -709,6 +711,7 @@ static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id | ||
2482 | case PCI_DEVICE_ID_INTEL_ICH10_4: | ||
2483 | case PCI_DEVICE_ID_INTEL_ICH10_5: | ||
2484 | case PCI_DEVICE_ID_INTEL_PCH_SMBUS: | ||
2485 | + case PCI_DEVICE_ID_INTEL_CPT_SMBUS: | ||
2486 | i801_features |= FEATURE_I2C_BLOCK_READ; | ||
2487 | /* fall through */ | ||
2488 | case PCI_DEVICE_ID_INTEL_82801DB_3: | ||
2489 | diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
2490 | index 30bdf42..f8302c2 100644 | ||
2491 | --- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
2492 | +++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
2493 | @@ -752,6 +752,8 @@ void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_ | ||
2494 | if (++priv->tx_outstanding == ipoib_sendq_size) { | ||
2495 | ipoib_dbg(priv, "TX ring 0x%x full, stopping kernel net queue\n", | ||
2496 | tx->qp->qp_num); | ||
2497 | + if (ib_req_notify_cq(priv->send_cq, IB_CQ_NEXT_COMP)) | ||
2498 | + ipoib_warn(priv, "request notify on send CQ failed\n"); | ||
2499 | netif_stop_queue(dev); | ||
2500 | } | ||
2501 | } | ||
2502 | diff --git a/drivers/input/sparse-keymap.c b/drivers/input/sparse-keymap.c | ||
2503 | index fbd3987..e8d65b3 100644 | ||
2504 | --- a/drivers/input/sparse-keymap.c | ||
2505 | +++ b/drivers/input/sparse-keymap.c | ||
2506 | @@ -161,7 +161,7 @@ int sparse_keymap_setup(struct input_dev *dev, | ||
2507 | return 0; | ||
2508 | |||
2509 | err_out: | ||
2510 | - kfree(keymap); | ||
2511 | + kfree(map); | ||
2512 | return error; | ||
2513 | |||
2514 | } | ||
2515 | diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c | ||
2516 | index 072f33b..e53ddc5 100644 | ||
2517 | --- a/drivers/input/tablet/wacom_sys.c | ||
2518 | +++ b/drivers/input/tablet/wacom_sys.c | ||
2519 | @@ -644,13 +644,15 @@ static int wacom_resume(struct usb_interface *intf) | ||
2520 | int rv; | ||
2521 | |||
2522 | mutex_lock(&wacom->lock); | ||
2523 | - if (wacom->open) { | ||
2524 | + | ||
2525 | + /* switch to wacom mode first */ | ||
2526 | + wacom_query_tablet_data(intf, features); | ||
2527 | + | ||
2528 | + if (wacom->open) | ||
2529 | rv = usb_submit_urb(wacom->irq, GFP_NOIO); | ||
2530 | - /* switch to wacom mode if needed */ | ||
2531 | - if (!wacom_retrieve_hid_descriptor(intf, features)) | ||
2532 | - wacom_query_tablet_data(intf, features); | ||
2533 | - } else | ||
2534 | + else | ||
2535 | rv = 0; | ||
2536 | + | ||
2537 | mutex_unlock(&wacom->lock); | ||
2538 | |||
2539 | return rv; | ||
2540 | diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c | ||
2541 | index e3cf568..d7500e1 100644 | ||
2542 | --- a/drivers/md/dm-ioctl.c | ||
2543 | +++ b/drivers/md/dm-ioctl.c | ||
2544 | @@ -285,7 +285,8 @@ retry: | ||
2545 | up_write(&_hash_lock); | ||
2546 | } | ||
2547 | |||
2548 | -static int dm_hash_rename(uint32_t cookie, const char *old, const char *new) | ||
2549 | +static int dm_hash_rename(uint32_t cookie, uint32_t *flags, const char *old, | ||
2550 | + const char *new) | ||
2551 | { | ||
2552 | char *new_name, *old_name; | ||
2553 | struct hash_cell *hc; | ||
2554 | @@ -344,7 +345,8 @@ static int dm_hash_rename(uint32_t cookie, const char *old, const char *new) | ||
2555 | dm_table_put(table); | ||
2556 | } | ||
2557 | |||
2558 | - dm_kobject_uevent(hc->md, KOBJ_CHANGE, cookie); | ||
2559 | + if (!dm_kobject_uevent(hc->md, KOBJ_CHANGE, cookie)) | ||
2560 | + *flags |= DM_UEVENT_GENERATED_FLAG; | ||
2561 | |||
2562 | dm_put(hc->md); | ||
2563 | up_write(&_hash_lock); | ||
2564 | @@ -736,10 +738,10 @@ static int dev_remove(struct dm_ioctl *param, size_t param_size) | ||
2565 | __hash_remove(hc); | ||
2566 | up_write(&_hash_lock); | ||
2567 | |||
2568 | - dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr); | ||
2569 | + if (!dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr)) | ||
2570 | + param->flags |= DM_UEVENT_GENERATED_FLAG; | ||
2571 | |||
2572 | dm_put(md); | ||
2573 | - param->data_size = 0; | ||
2574 | return 0; | ||
2575 | } | ||
2576 | |||
2577 | @@ -773,7 +775,9 @@ static int dev_rename(struct dm_ioctl *param, size_t param_size) | ||
2578 | return r; | ||
2579 | |||
2580 | param->data_size = 0; | ||
2581 | - return dm_hash_rename(param->event_nr, param->name, new_name); | ||
2582 | + | ||
2583 | + return dm_hash_rename(param->event_nr, ¶m->flags, param->name, | ||
2584 | + new_name); | ||
2585 | } | ||
2586 | |||
2587 | static int dev_set_geometry(struct dm_ioctl *param, size_t param_size) | ||
2588 | @@ -899,8 +903,8 @@ static int do_resume(struct dm_ioctl *param) | ||
2589 | |||
2590 | if (dm_suspended_md(md)) { | ||
2591 | r = dm_resume(md); | ||
2592 | - if (!r) | ||
2593 | - dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr); | ||
2594 | + if (!r && !dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr)) | ||
2595 | + param->flags |= DM_UEVENT_GENERATED_FLAG; | ||
2596 | } | ||
2597 | |||
2598 | if (old_map) | ||
2599 | @@ -1477,6 +1481,7 @@ static int validate_params(uint cmd, struct dm_ioctl *param) | ||
2600 | { | ||
2601 | /* Always clear this flag */ | ||
2602 | param->flags &= ~DM_BUFFER_FULL_FLAG; | ||
2603 | + param->flags &= ~DM_UEVENT_GENERATED_FLAG; | ||
2604 | |||
2605 | /* Ignores parameters */ | ||
2606 | if (cmd == DM_REMOVE_ALL_CMD || | ||
2607 | diff --git a/drivers/md/dm.c b/drivers/md/dm.c | ||
2608 | index fa786b9..fe8889e 100644 | ||
2609 | --- a/drivers/md/dm.c | ||
2610 | +++ b/drivers/md/dm.c | ||
2611 | @@ -2618,18 +2618,19 @@ out: | ||
2612 | /*----------------------------------------------------------------- | ||
2613 | * Event notification. | ||
2614 | *---------------------------------------------------------------*/ | ||
2615 | -void dm_kobject_uevent(struct mapped_device *md, enum kobject_action action, | ||
2616 | +int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action, | ||
2617 | unsigned cookie) | ||
2618 | { | ||
2619 | char udev_cookie[DM_COOKIE_LENGTH]; | ||
2620 | char *envp[] = { udev_cookie, NULL }; | ||
2621 | |||
2622 | if (!cookie) | ||
2623 | - kobject_uevent(&disk_to_dev(md->disk)->kobj, action); | ||
2624 | + return kobject_uevent(&disk_to_dev(md->disk)->kobj, action); | ||
2625 | else { | ||
2626 | snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u", | ||
2627 | DM_COOKIE_ENV_VAR_NAME, cookie); | ||
2628 | - kobject_uevent_env(&disk_to_dev(md->disk)->kobj, action, envp); | ||
2629 | + return kobject_uevent_env(&disk_to_dev(md->disk)->kobj, | ||
2630 | + action, envp); | ||
2631 | } | ||
2632 | } | ||
2633 | |||
2634 | diff --git a/drivers/md/dm.h b/drivers/md/dm.h | ||
2635 | index 8dadaa5..bad1724 100644 | ||
2636 | --- a/drivers/md/dm.h | ||
2637 | +++ b/drivers/md/dm.h | ||
2638 | @@ -125,8 +125,8 @@ void dm_stripe_exit(void); | ||
2639 | int dm_open_count(struct mapped_device *md); | ||
2640 | int dm_lock_for_deletion(struct mapped_device *md); | ||
2641 | |||
2642 | -void dm_kobject_uevent(struct mapped_device *md, enum kobject_action action, | ||
2643 | - unsigned cookie); | ||
2644 | +int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action, | ||
2645 | + unsigned cookie); | ||
2646 | |||
2647 | int dm_io_init(void); | ||
2648 | void dm_io_exit(void); | ||
2649 | diff --git a/drivers/md/linear.c b/drivers/md/linear.c | ||
2650 | index 00435bd..001317b 100644 | ||
2651 | --- a/drivers/md/linear.c | ||
2652 | +++ b/drivers/md/linear.c | ||
2653 | @@ -172,12 +172,14 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) | ||
2654 | disk_stack_limits(mddev->gendisk, rdev->bdev, | ||
2655 | rdev->data_offset << 9); | ||
2656 | /* as we don't honour merge_bvec_fn, we must never risk | ||
2657 | - * violating it, so limit ->max_sector to one PAGE, as | ||
2658 | - * a one page request is never in violation. | ||
2659 | + * violating it, so limit max_phys_segments to 1 lying within | ||
2660 | + * a single page. | ||
2661 | */ | ||
2662 | - if (rdev->bdev->bd_disk->queue->merge_bvec_fn && | ||
2663 | - queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9)) | ||
2664 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2665 | + if (rdev->bdev->bd_disk->queue->merge_bvec_fn) { | ||
2666 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2667 | + blk_queue_segment_boundary(mddev->queue, | ||
2668 | + PAGE_CACHE_SIZE - 1); | ||
2669 | + } | ||
2670 | |||
2671 | conf->array_sectors += rdev->sectors; | ||
2672 | cnt++; | ||
2673 | diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c | ||
2674 | index 32a662f..f9ee99f 100644 | ||
2675 | --- a/drivers/md/multipath.c | ||
2676 | +++ b/drivers/md/multipath.c | ||
2677 | @@ -301,14 +301,16 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev) | ||
2678 | rdev->data_offset << 9); | ||
2679 | |||
2680 | /* as we don't honour merge_bvec_fn, we must never risk | ||
2681 | - * violating it, so limit ->max_sector to one PAGE, as | ||
2682 | - * a one page request is never in violation. | ||
2683 | + * violating it, so limit ->max_phys_segments to one, lying | ||
2684 | + * within a single page. | ||
2685 | * (Note: it is very unlikely that a device with | ||
2686 | * merge_bvec_fn will be involved in multipath.) | ||
2687 | */ | ||
2688 | - if (q->merge_bvec_fn && | ||
2689 | - queue_max_sectors(q) > (PAGE_SIZE>>9)) | ||
2690 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2691 | + if (q->merge_bvec_fn) { | ||
2692 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2693 | + blk_queue_segment_boundary(mddev->queue, | ||
2694 | + PAGE_CACHE_SIZE - 1); | ||
2695 | + } | ||
2696 | |||
2697 | conf->working_disks++; | ||
2698 | mddev->degraded--; | ||
2699 | @@ -476,9 +478,11 @@ static int multipath_run (mddev_t *mddev) | ||
2700 | /* as we don't honour merge_bvec_fn, we must never risk | ||
2701 | * violating it, not that we ever expect a device with | ||
2702 | * a merge_bvec_fn to be involved in multipath */ | ||
2703 | - if (rdev->bdev->bd_disk->queue->merge_bvec_fn && | ||
2704 | - queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9)) | ||
2705 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2706 | + if (rdev->bdev->bd_disk->queue->merge_bvec_fn) { | ||
2707 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2708 | + blk_queue_segment_boundary(mddev->queue, | ||
2709 | + PAGE_CACHE_SIZE - 1); | ||
2710 | + } | ||
2711 | |||
2712 | if (!test_bit(Faulty, &rdev->flags)) | ||
2713 | conf->working_disks++; | ||
2714 | diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c | ||
2715 | index 77605cd..41ee9de 100644 | ||
2716 | --- a/drivers/md/raid0.c | ||
2717 | +++ b/drivers/md/raid0.c | ||
2718 | @@ -176,14 +176,15 @@ static int create_strip_zones(mddev_t *mddev) | ||
2719 | disk_stack_limits(mddev->gendisk, rdev1->bdev, | ||
2720 | rdev1->data_offset << 9); | ||
2721 | /* as we don't honour merge_bvec_fn, we must never risk | ||
2722 | - * violating it, so limit ->max_sector to one PAGE, as | ||
2723 | - * a one page request is never in violation. | ||
2724 | + * violating it, so limit ->max_phys_segments to 1, lying within | ||
2725 | + * a single page. | ||
2726 | */ | ||
2727 | |||
2728 | - if (rdev1->bdev->bd_disk->queue->merge_bvec_fn && | ||
2729 | - queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9)) | ||
2730 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2731 | - | ||
2732 | + if (rdev1->bdev->bd_disk->queue->merge_bvec_fn) { | ||
2733 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2734 | + blk_queue_segment_boundary(mddev->queue, | ||
2735 | + PAGE_CACHE_SIZE - 1); | ||
2736 | + } | ||
2737 | if (!smallest || (rdev1->sectors < smallest->sectors)) | ||
2738 | smallest = rdev1; | ||
2739 | cnt++; | ||
2740 | diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c | ||
2741 | index d119b7b..047c468 100644 | ||
2742 | --- a/drivers/md/raid10.c | ||
2743 | +++ b/drivers/md/raid10.c | ||
2744 | @@ -1155,13 +1155,17 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev) | ||
2745 | |||
2746 | disk_stack_limits(mddev->gendisk, rdev->bdev, | ||
2747 | rdev->data_offset << 9); | ||
2748 | - /* as we don't honour merge_bvec_fn, we must never risk | ||
2749 | - * violating it, so limit ->max_sector to one PAGE, as | ||
2750 | - * a one page request is never in violation. | ||
2751 | + /* as we don't honour merge_bvec_fn, we must | ||
2752 | + * never risk violating it, so limit | ||
2753 | + * ->max_phys_segments to one lying with a single | ||
2754 | + * page, as a one page request is never in | ||
2755 | + * violation. | ||
2756 | */ | ||
2757 | - if (rdev->bdev->bd_disk->queue->merge_bvec_fn && | ||
2758 | - queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9)) | ||
2759 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2760 | + if (rdev->bdev->bd_disk->queue->merge_bvec_fn) { | ||
2761 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2762 | + blk_queue_segment_boundary(mddev->queue, | ||
2763 | + PAGE_CACHE_SIZE - 1); | ||
2764 | + } | ||
2765 | |||
2766 | p->head_position = 0; | ||
2767 | rdev->raid_disk = mirror; | ||
2768 | @@ -2255,12 +2259,14 @@ static int run(mddev_t *mddev) | ||
2769 | disk_stack_limits(mddev->gendisk, rdev->bdev, | ||
2770 | rdev->data_offset << 9); | ||
2771 | /* as we don't honour merge_bvec_fn, we must never risk | ||
2772 | - * violating it, so limit ->max_sector to one PAGE, as | ||
2773 | - * a one page request is never in violation. | ||
2774 | + * violating it, so limit max_phys_segments to 1 lying | ||
2775 | + * within a single page. | ||
2776 | */ | ||
2777 | - if (rdev->bdev->bd_disk->queue->merge_bvec_fn && | ||
2778 | - queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9)) | ||
2779 | - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); | ||
2780 | + if (rdev->bdev->bd_disk->queue->merge_bvec_fn) { | ||
2781 | + blk_queue_max_phys_segments(mddev->queue, 1); | ||
2782 | + blk_queue_segment_boundary(mddev->queue, | ||
2783 | + PAGE_CACHE_SIZE - 1); | ||
2784 | + } | ||
2785 | |||
2786 | disk->head_position = 0; | ||
2787 | } | ||
2788 | diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c | ||
2789 | index 57f149b..4d353d2 100644 | ||
2790 | --- a/drivers/net/e1000e/netdev.c | ||
2791 | +++ b/drivers/net/e1000e/netdev.c | ||
2792 | @@ -660,6 +660,8 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter) | ||
2793 | i = 0; | ||
2794 | } | ||
2795 | |||
2796 | + if (i == tx_ring->next_to_use) | ||
2797 | + break; | ||
2798 | eop = tx_ring->buffer_info[i].next_to_watch; | ||
2799 | eop_desc = E1000_TX_DESC(*tx_ring, eop); | ||
2800 | } | ||
2801 | diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c | ||
2802 | index 67d414b..3db85da 100644 | ||
2803 | --- a/drivers/net/r8169.c | ||
2804 | +++ b/drivers/net/r8169.c | ||
2805 | @@ -3255,8 +3255,8 @@ static void rtl8169_set_rxbufsize(struct rtl8169_private *tp, | ||
2806 | unsigned int max_frame = mtu + VLAN_ETH_HLEN + ETH_FCS_LEN; | ||
2807 | |||
2808 | if (max_frame != 16383) | ||
2809 | - printk(KERN_WARNING "WARNING! Changing of MTU on this NIC" | ||
2810 | - "May lead to frame reception errors!\n"); | ||
2811 | + printk(KERN_WARNING PFX "WARNING! Changing of MTU on this " | ||
2812 | + "NIC may lead to frame reception errors!\n"); | ||
2813 | |||
2814 | tp->rx_buf_sz = (max_frame > RX_BUF_SIZE) ? max_frame : RX_BUF_SIZE; | ||
2815 | } | ||
2816 | diff --git a/drivers/net/wireless/ath/ar9170/usb.c b/drivers/net/wireless/ath/ar9170/usb.c | ||
2817 | index e0799d9..0387658 100644 | ||
2818 | --- a/drivers/net/wireless/ath/ar9170/usb.c | ||
2819 | +++ b/drivers/net/wireless/ath/ar9170/usb.c | ||
2820 | @@ -414,7 +414,7 @@ static int ar9170_usb_exec_cmd(struct ar9170 *ar, enum ar9170_cmd cmd, | ||
2821 | spin_unlock_irqrestore(&aru->common.cmdlock, flags); | ||
2822 | |||
2823 | usb_fill_int_urb(urb, aru->udev, | ||
2824 | - usb_sndbulkpipe(aru->udev, AR9170_EP_CMD), | ||
2825 | + usb_sndintpipe(aru->udev, AR9170_EP_CMD), | ||
2826 | aru->common.cmdbuf, plen + 4, | ||
2827 | ar9170_usb_tx_urb_complete, NULL, 1); | ||
2828 | |||
2829 | diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c | ||
2830 | index 33a1071..7b1eab4 100644 | ||
2831 | --- a/drivers/net/wireless/ath/ath9k/main.c | ||
2832 | +++ b/drivers/net/wireless/ath/ath9k/main.c | ||
2833 | @@ -2721,8 +2721,7 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed) | ||
2834 | all_wiphys_idle = ath9k_all_wiphys_idle(sc); | ||
2835 | ath9k_set_wiphy_idle(aphy, idle); | ||
2836 | |||
2837 | - if (!idle && all_wiphys_idle) | ||
2838 | - enable_radio = true; | ||
2839 | + enable_radio = (!idle && all_wiphys_idle); | ||
2840 | |||
2841 | /* | ||
2842 | * After we unlock here its possible another wiphy | ||
2843 | diff --git a/drivers/net/wireless/b43/Kconfig b/drivers/net/wireless/b43/Kconfig | ||
2844 | index 64c12e1..0a00d42 100644 | ||
2845 | --- a/drivers/net/wireless/b43/Kconfig | ||
2846 | +++ b/drivers/net/wireless/b43/Kconfig | ||
2847 | @@ -78,11 +78,11 @@ config B43_SDIO | ||
2848 | |||
2849 | If unsure, say N. | ||
2850 | |||
2851 | -# Data transfers to the device via PIO | ||
2852 | -# This is only needed on PCMCIA and SDIO devices. All others can do DMA properly. | ||
2853 | +#Data transfers to the device via PIO. We want it as a fallback even | ||
2854 | +# if we can do DMA. | ||
2855 | config B43_PIO | ||
2856 | bool | ||
2857 | - depends on B43 && (B43_SDIO || B43_PCMCIA || B43_FORCE_PIO) | ||
2858 | + depends on B43 | ||
2859 | select SSB_BLOCKIO | ||
2860 | default y | ||
2861 | |||
2862 | diff --git a/drivers/net/wireless/b43/Makefile b/drivers/net/wireless/b43/Makefile | ||
2863 | index 84772a2..5e83b6f 100644 | ||
2864 | --- a/drivers/net/wireless/b43/Makefile | ||
2865 | +++ b/drivers/net/wireless/b43/Makefile | ||
2866 | @@ -12,7 +12,7 @@ b43-y += xmit.o | ||
2867 | b43-y += lo.o | ||
2868 | b43-y += wa.o | ||
2869 | b43-y += dma.o | ||
2870 | -b43-$(CONFIG_B43_PIO) += pio.o | ||
2871 | +b43-y += pio.o | ||
2872 | b43-y += rfkill.o | ||
2873 | b43-$(CONFIG_B43_LEDS) += leds.o | ||
2874 | b43-$(CONFIG_B43_PCMCIA) += pcmcia.o | ||
2875 | diff --git a/drivers/net/wireless/b43/b43.h b/drivers/net/wireless/b43/b43.h | ||
2876 | index c484cc2..7df822e 100644 | ||
2877 | --- a/drivers/net/wireless/b43/b43.h | ||
2878 | +++ b/drivers/net/wireless/b43/b43.h | ||
2879 | @@ -694,6 +694,7 @@ struct b43_wldev { | ||
2880 | bool radio_hw_enable; /* saved state of radio hardware enabled state */ | ||
2881 | bool qos_enabled; /* TRUE, if QoS is used. */ | ||
2882 | bool hwcrypto_enabled; /* TRUE, if HW crypto acceleration is enabled. */ | ||
2883 | + bool use_pio; /* TRUE if next init should use PIO */ | ||
2884 | |||
2885 | /* PHY/Radio device. */ | ||
2886 | struct b43_phy phy; | ||
2887 | @@ -822,11 +823,9 @@ struct b43_wl { | ||
2888 | /* The device LEDs. */ | ||
2889 | struct b43_leds leds; | ||
2890 | |||
2891 | -#ifdef CONFIG_B43_PIO | ||
2892 | /* Kmalloc'ed scratch space for PIO TX/RX. Protected by wl->mutex. */ | ||
2893 | u8 pio_scratchspace[110] __attribute__((__aligned__(8))); | ||
2894 | u8 pio_tailspace[4] __attribute__((__aligned__(8))); | ||
2895 | -#endif /* CONFIG_B43_PIO */ | ||
2896 | }; | ||
2897 | |||
2898 | static inline struct b43_wl *hw_to_b43_wl(struct ieee80211_hw *hw) | ||
2899 | @@ -877,20 +876,15 @@ static inline void b43_write32(struct b43_wldev *dev, u16 offset, u32 value) | ||
2900 | |||
2901 | static inline bool b43_using_pio_transfers(struct b43_wldev *dev) | ||
2902 | { | ||
2903 | -#ifdef CONFIG_B43_PIO | ||
2904 | return dev->__using_pio_transfers; | ||
2905 | -#else | ||
2906 | - return 0; | ||
2907 | -#endif | ||
2908 | } | ||
2909 | |||
2910 | #ifdef CONFIG_B43_FORCE_PIO | ||
2911 | -# define B43_FORCE_PIO 1 | ||
2912 | +# define B43_PIO_DEFAULT 1 | ||
2913 | #else | ||
2914 | -# define B43_FORCE_PIO 0 | ||
2915 | +# define B43_PIO_DEFAULT 0 | ||
2916 | #endif | ||
2917 | |||
2918 | - | ||
2919 | /* Message printing */ | ||
2920 | void b43info(struct b43_wl *wl, const char *fmt, ...) | ||
2921 | __attribute__ ((format(printf, 2, 3))); | ||
2922 | diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c | ||
2923 | index 88d1fd0..615af22 100644 | ||
2924 | --- a/drivers/net/wireless/b43/dma.c | ||
2925 | +++ b/drivers/net/wireless/b43/dma.c | ||
2926 | @@ -1653,7 +1653,6 @@ void b43_dma_tx_resume(struct b43_wldev *dev) | ||
2927 | b43_power_saving_ctl_bits(dev, 0); | ||
2928 | } | ||
2929 | |||
2930 | -#ifdef CONFIG_B43_PIO | ||
2931 | static void direct_fifo_rx(struct b43_wldev *dev, enum b43_dmatype type, | ||
2932 | u16 mmio_base, bool enable) | ||
2933 | { | ||
2934 | @@ -1687,4 +1686,3 @@ void b43_dma_direct_fifo_rx(struct b43_wldev *dev, | ||
2935 | mmio_base = b43_dmacontroller_base(type, engine_index); | ||
2936 | direct_fifo_rx(dev, type, mmio_base, enable); | ||
2937 | } | ||
2938 | -#endif /* CONFIG_B43_PIO */ | ||
2939 | diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c | ||
2940 | index 629c166..9eb4f5e 100644 | ||
2941 | --- a/drivers/net/wireless/b43/main.c | ||
2942 | +++ b/drivers/net/wireless/b43/main.c | ||
2943 | @@ -102,6 +102,9 @@ int b43_modparam_verbose = B43_VERBOSITY_DEFAULT; | ||
2944 | module_param_named(verbose, b43_modparam_verbose, int, 0644); | ||
2945 | MODULE_PARM_DESC(verbose, "Log message verbosity: 0=error, 1=warn, 2=info(default), 3=debug"); | ||
2946 | |||
2947 | +int b43_modparam_pio = B43_PIO_DEFAULT; | ||
2948 | +module_param_named(pio, b43_modparam_pio, int, 0644); | ||
2949 | +MODULE_PARM_DESC(pio, "Use PIO accesses by default: 0=DMA, 1=PIO"); | ||
2950 | |||
2951 | static const struct ssb_device_id b43_ssb_tbl[] = { | ||
2952 | SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 5), | ||
2953 | @@ -1790,8 +1793,9 @@ static void b43_do_interrupt_thread(struct b43_wldev *dev) | ||
2954 | dma_reason[4], dma_reason[5]); | ||
2955 | b43err(dev->wl, "This device does not support DMA " | ||
2956 | "on your system. Please use PIO instead.\n"); | ||
2957 | - b43err(dev->wl, "CONFIG_B43_FORCE_PIO must be set in " | ||
2958 | - "your kernel configuration.\n"); | ||
2959 | + /* Fall back to PIO transfers if we get fatal DMA errors! */ | ||
2960 | + dev->use_pio = 1; | ||
2961 | + b43_controller_restart(dev, "DMA error"); | ||
2962 | return; | ||
2963 | } | ||
2964 | if (merged_dma_reason & B43_DMAIRQ_NONFATALMASK) { | ||
2965 | @@ -4358,7 +4362,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev) | ||
2966 | |||
2967 | if ((dev->dev->bus->bustype == SSB_BUSTYPE_PCMCIA) || | ||
2968 | (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) || | ||
2969 | - B43_FORCE_PIO) { | ||
2970 | + dev->use_pio) { | ||
2971 | dev->__using_pio_transfers = 1; | ||
2972 | err = b43_pio_init(dev); | ||
2973 | } else { | ||
2974 | @@ -4826,6 +4830,7 @@ static int b43_one_core_attach(struct ssb_device *dev, struct b43_wl *wl) | ||
2975 | if (!wldev) | ||
2976 | goto out; | ||
2977 | |||
2978 | + wldev->use_pio = b43_modparam_pio; | ||
2979 | wldev->dev = dev; | ||
2980 | wldev->wl = wl; | ||
2981 | b43_set_status(wldev, B43_STAT_UNINIT); | ||
2982 | diff --git a/drivers/net/wireless/b43/pio.h b/drivers/net/wireless/b43/pio.h | ||
2983 | index 7dd649c..7b3c42f 100644 | ||
2984 | --- a/drivers/net/wireless/b43/pio.h | ||
2985 | +++ b/drivers/net/wireless/b43/pio.h | ||
2986 | @@ -55,8 +55,6 @@ | ||
2987 | #define B43_PIO_MAX_NR_TXPACKETS 32 | ||
2988 | |||
2989 | |||
2990 | -#ifdef CONFIG_B43_PIO | ||
2991 | - | ||
2992 | struct b43_pio_txpacket { | ||
2993 | /* Pointer to the TX queue we belong to. */ | ||
2994 | struct b43_pio_txqueue *queue; | ||
2995 | @@ -169,42 +167,4 @@ void b43_pio_rx(struct b43_pio_rxqueue *q); | ||
2996 | void b43_pio_tx_suspend(struct b43_wldev *dev); | ||
2997 | void b43_pio_tx_resume(struct b43_wldev *dev); | ||
2998 | |||
2999 | - | ||
3000 | -#else /* CONFIG_B43_PIO */ | ||
3001 | - | ||
3002 | - | ||
3003 | -static inline int b43_pio_init(struct b43_wldev *dev) | ||
3004 | -{ | ||
3005 | - return 0; | ||
3006 | -} | ||
3007 | -static inline void b43_pio_free(struct b43_wldev *dev) | ||
3008 | -{ | ||
3009 | -} | ||
3010 | -static inline void b43_pio_stop(struct b43_wldev *dev) | ||
3011 | -{ | ||
3012 | -} | ||
3013 | -static inline int b43_pio_tx(struct b43_wldev *dev, | ||
3014 | - struct sk_buff *skb) | ||
3015 | -{ | ||
3016 | - return 0; | ||
3017 | -} | ||
3018 | -static inline void b43_pio_handle_txstatus(struct b43_wldev *dev, | ||
3019 | - const struct b43_txstatus *status) | ||
3020 | -{ | ||
3021 | -} | ||
3022 | -static inline void b43_pio_get_tx_stats(struct b43_wldev *dev, | ||
3023 | - struct ieee80211_tx_queue_stats *stats) | ||
3024 | -{ | ||
3025 | -} | ||
3026 | -static inline void b43_pio_rx(struct b43_pio_rxqueue *q) | ||
3027 | -{ | ||
3028 | -} | ||
3029 | -static inline void b43_pio_tx_suspend(struct b43_wldev *dev) | ||
3030 | -{ | ||
3031 | -} | ||
3032 | -static inline void b43_pio_tx_resume(struct b43_wldev *dev) | ||
3033 | -{ | ||
3034 | -} | ||
3035 | - | ||
3036 | -#endif /* CONFIG_B43_PIO */ | ||
3037 | #endif /* B43_PIO_H_ */ | ||
3038 | diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c | ||
3039 | index 3146281..3b4c5a4 100644 | ||
3040 | --- a/drivers/net/wireless/iwlwifi/iwl-4965.c | ||
3041 | +++ b/drivers/net/wireless/iwlwifi/iwl-4965.c | ||
3042 | @@ -581,6 +581,8 @@ static int iwl4965_alive_notify(struct iwl_priv *priv) | ||
3043 | |||
3044 | iwl4965_set_wr_ptrs(priv, IWL_CMD_QUEUE_NUM, 0); | ||
3045 | |||
3046 | + /* reset to 0 to enable all the queue first */ | ||
3047 | + priv->txq_ctx_active_msk = 0; | ||
3048 | /* Map each Tx/cmd queue to its corresponding fifo */ | ||
3049 | for (i = 0; i < ARRAY_SIZE(default_queue_to_tx_fifo); i++) { | ||
3050 | int ac = default_queue_to_tx_fifo[i]; | ||
3051 | @@ -2008,7 +2010,9 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv, | ||
3052 | IWL_DEBUG_TX_REPLY(priv, "Retry scheduler reclaim scd_ssn " | ||
3053 | "%d index %d\n", scd_ssn , index); | ||
3054 | freed = iwl_tx_queue_reclaim(priv, txq_id, index); | ||
3055 | - iwl_free_tfds_in_queue(priv, sta_id, tid, freed); | ||
3056 | + if (qc) | ||
3057 | + iwl_free_tfds_in_queue(priv, sta_id, | ||
3058 | + tid, freed); | ||
3059 | |||
3060 | if (priv->mac80211_registered && | ||
3061 | (iwl_queue_space(&txq->q) > txq->q.low_mark) && | ||
3062 | @@ -2035,13 +2039,14 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv, | ||
3063 | |||
3064 | freed = iwl_tx_queue_reclaim(priv, txq_id, index); | ||
3065 | if (qc && likely(sta_id != IWL_INVALID_STATION)) | ||
3066 | - priv->stations[sta_id].tid[tid].tfds_in_queue -= freed; | ||
3067 | + iwl_free_tfds_in_queue(priv, sta_id, tid, freed); | ||
3068 | + else if (sta_id == IWL_INVALID_STATION) | ||
3069 | + IWL_DEBUG_TX_REPLY(priv, "Station not known\n"); | ||
3070 | |||
3071 | if (priv->mac80211_registered && | ||
3072 | (iwl_queue_space(&txq->q) > txq->q.low_mark)) | ||
3073 | iwl_wake_queue(priv, txq_id); | ||
3074 | } | ||
3075 | - | ||
3076 | if (qc && likely(sta_id != IWL_INVALID_STATION)) | ||
3077 | iwl_txq_check_empty(priv, sta_id, tid, txq_id); | ||
3078 | |||
3079 | diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c | ||
3080 | index cffaae7..c610e5f 100644 | ||
3081 | --- a/drivers/net/wireless/iwlwifi/iwl-5000.c | ||
3082 | +++ b/drivers/net/wireless/iwlwifi/iwl-5000.c | ||
3083 | @@ -657,6 +657,8 @@ int iwl5000_alive_notify(struct iwl_priv *priv) | ||
3084 | |||
3085 | iwl5000_set_wr_ptrs(priv, IWL_CMD_QUEUE_NUM, 0); | ||
3086 | |||
3087 | + /* reset to 0 to enable all the queue first */ | ||
3088 | + priv->txq_ctx_active_msk = 0; | ||
3089 | /* map qos queues to fifos one-to-one */ | ||
3090 | for (i = 0; i < ARRAY_SIZE(iwl5000_default_queue_to_tx_fifo); i++) { | ||
3091 | int ac = iwl5000_default_queue_to_tx_fifo[i]; | ||
3092 | diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c | ||
3093 | index 1c9866d..5622a55 100644 | ||
3094 | --- a/drivers/net/wireless/iwlwifi/iwl-agn.c | ||
3095 | +++ b/drivers/net/wireless/iwlwifi/iwl-agn.c | ||
3096 | @@ -2461,7 +2461,7 @@ static int iwl_setup_mac(struct iwl_priv *priv) | ||
3097 | BIT(NL80211_IFTYPE_STATION) | | ||
3098 | BIT(NL80211_IFTYPE_ADHOC); | ||
3099 | |||
3100 | - hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY | | ||
3101 | + hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY | | ||
3102 | WIPHY_FLAG_DISABLE_BEACON_HINTS; | ||
3103 | |||
3104 | /* | ||
3105 | diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c | ||
3106 | index fa1c89b..8f1b850 100644 | ||
3107 | --- a/drivers/net/wireless/iwlwifi/iwl-scan.c | ||
3108 | +++ b/drivers/net/wireless/iwlwifi/iwl-scan.c | ||
3109 | @@ -404,21 +404,6 @@ EXPORT_SYMBOL(iwl_init_scan_params); | ||
3110 | |||
3111 | static int iwl_scan_initiate(struct iwl_priv *priv) | ||
3112 | { | ||
3113 | - if (!iwl_is_ready_rf(priv)) { | ||
3114 | - IWL_DEBUG_SCAN(priv, "Aborting scan due to not ready.\n"); | ||
3115 | - return -EIO; | ||
3116 | - } | ||
3117 | - | ||
3118 | - if (test_bit(STATUS_SCANNING, &priv->status)) { | ||
3119 | - IWL_DEBUG_SCAN(priv, "Scan already in progress.\n"); | ||
3120 | - return -EAGAIN; | ||
3121 | - } | ||
3122 | - | ||
3123 | - if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { | ||
3124 | - IWL_DEBUG_SCAN(priv, "Scan request while abort pending\n"); | ||
3125 | - return -EAGAIN; | ||
3126 | - } | ||
3127 | - | ||
3128 | IWL_DEBUG_INFO(priv, "Starting scan...\n"); | ||
3129 | set_bit(STATUS_SCANNING, &priv->status); | ||
3130 | priv->scan_start = jiffies; | ||
3131 | @@ -449,6 +434,18 @@ int iwl_mac_hw_scan(struct ieee80211_hw *hw, | ||
3132 | goto out_unlock; | ||
3133 | } | ||
3134 | |||
3135 | + if (test_bit(STATUS_SCANNING, &priv->status)) { | ||
3136 | + IWL_DEBUG_SCAN(priv, "Scan already in progress.\n"); | ||
3137 | + ret = -EAGAIN; | ||
3138 | + goto out_unlock; | ||
3139 | + } | ||
3140 | + | ||
3141 | + if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { | ||
3142 | + IWL_DEBUG_SCAN(priv, "Scan request while abort pending\n"); | ||
3143 | + ret = -EAGAIN; | ||
3144 | + goto out_unlock; | ||
3145 | + } | ||
3146 | + | ||
3147 | /* We don't schedule scan within next_scan_jiffies period. | ||
3148 | * Avoid scanning during possible EAPOL exchange, return | ||
3149 | * success immediately. | ||
3150 | diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c | ||
3151 | index f297865..adbb3ea 100644 | ||
3152 | --- a/drivers/net/wireless/iwlwifi/iwl3945-base.c | ||
3153 | +++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c | ||
3154 | @@ -1926,7 +1926,7 @@ static void iwl3945_init_hw_rates(struct iwl_priv *priv, | ||
3155 | { | ||
3156 | int i; | ||
3157 | |||
3158 | - for (i = 0; i < IWL_RATE_COUNT; i++) { | ||
3159 | + for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) { | ||
3160 | rates[i].bitrate = iwl3945_rates[i].ieee * 5; | ||
3161 | rates[i].hw_value = i; /* Rate scaling will work on indexes */ | ||
3162 | rates[i].hw_value_short = i; | ||
3163 | @@ -3903,7 +3903,7 @@ static int iwl3945_setup_mac(struct iwl_priv *priv) | ||
3164 | BIT(NL80211_IFTYPE_STATION) | | ||
3165 | BIT(NL80211_IFTYPE_ADHOC); | ||
3166 | |||
3167 | - hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY | | ||
3168 | + hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY | | ||
3169 | WIPHY_FLAG_DISABLE_BEACON_HINTS; | ||
3170 | |||
3171 | hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945; | ||
3172 | diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c | ||
3173 | index 3245d33..c4fead1 100644 | ||
3174 | --- a/drivers/pci/pci.c | ||
3175 | +++ b/drivers/pci/pci.c | ||
3176 | @@ -2612,6 +2612,23 @@ int pci_resource_bar(struct pci_dev *dev, int resno, enum pci_bar_type *type) | ||
3177 | return 0; | ||
3178 | } | ||
3179 | |||
3180 | +/* Some architectures require additional programming to enable VGA */ | ||
3181 | +static arch_set_vga_state_t arch_set_vga_state; | ||
3182 | + | ||
3183 | +void __init pci_register_set_vga_state(arch_set_vga_state_t func) | ||
3184 | +{ | ||
3185 | + arch_set_vga_state = func; /* NULL disables */ | ||
3186 | +} | ||
3187 | + | ||
3188 | +static int pci_set_vga_state_arch(struct pci_dev *dev, bool decode, | ||
3189 | + unsigned int command_bits, bool change_bridge) | ||
3190 | +{ | ||
3191 | + if (arch_set_vga_state) | ||
3192 | + return arch_set_vga_state(dev, decode, command_bits, | ||
3193 | + change_bridge); | ||
3194 | + return 0; | ||
3195 | +} | ||
3196 | + | ||
3197 | /** | ||
3198 | * pci_set_vga_state - set VGA decode state on device and parents if requested | ||
3199 | * @dev: the PCI device | ||
3200 | @@ -2625,9 +2642,15 @@ int pci_set_vga_state(struct pci_dev *dev, bool decode, | ||
3201 | struct pci_bus *bus; | ||
3202 | struct pci_dev *bridge; | ||
3203 | u16 cmd; | ||
3204 | + int rc; | ||
3205 | |||
3206 | WARN_ON(command_bits & ~(PCI_COMMAND_IO|PCI_COMMAND_MEMORY)); | ||
3207 | |||
3208 | + /* ARCH specific VGA enables */ | ||
3209 | + rc = pci_set_vga_state_arch(dev, decode, command_bits, change_bridge); | ||
3210 | + if (rc) | ||
3211 | + return rc; | ||
3212 | + | ||
3213 | pci_read_config_word(dev, PCI_COMMAND, &cmd); | ||
3214 | if (decode == true) | ||
3215 | cmd |= command_bits; | ||
3216 | @@ -2874,4 +2897,3 @@ EXPORT_SYMBOL(pci_target_state); | ||
3217 | EXPORT_SYMBOL(pci_prepare_to_sleep); | ||
3218 | EXPORT_SYMBOL(pci_back_from_sleep); | ||
3219 | EXPORT_SYMBOL_GPL(pci_set_pcie_reset_state); | ||
3220 | - | ||
3221 | diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c | ||
3222 | index c28a712..e6b67f2 100644 | ||
3223 | --- a/drivers/scsi/libiscsi.c | ||
3224 | +++ b/drivers/scsi/libiscsi.c | ||
3225 | @@ -3027,14 +3027,15 @@ static void iscsi_start_session_recovery(struct iscsi_session *session, | ||
3226 | session->state = ISCSI_STATE_TERMINATE; | ||
3227 | else if (conn->stop_stage != STOP_CONN_RECOVER) | ||
3228 | session->state = ISCSI_STATE_IN_RECOVERY; | ||
3229 | + | ||
3230 | + old_stop_stage = conn->stop_stage; | ||
3231 | + conn->stop_stage = flag; | ||
3232 | spin_unlock_bh(&session->lock); | ||
3233 | |||
3234 | del_timer_sync(&conn->transport_timer); | ||
3235 | iscsi_suspend_tx(conn); | ||
3236 | |||
3237 | spin_lock_bh(&session->lock); | ||
3238 | - old_stop_stage = conn->stop_stage; | ||
3239 | - conn->stop_stage = flag; | ||
3240 | conn->c_stage = ISCSI_CONN_STOPPED; | ||
3241 | spin_unlock_bh(&session->lock); | ||
3242 | |||
3243 | diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c | ||
3244 | index 34d4eb9..db6b071 100644 | ||
3245 | --- a/drivers/usb/class/cdc-acm.c | ||
3246 | +++ b/drivers/usb/class/cdc-acm.c | ||
3247 | @@ -170,6 +170,7 @@ static void acm_write_done(struct acm *acm, struct acm_wb *wb) | ||
3248 | { | ||
3249 | wb->use = 0; | ||
3250 | acm->transmitting--; | ||
3251 | + usb_autopm_put_interface_async(acm->control); | ||
3252 | } | ||
3253 | |||
3254 | /* | ||
3255 | @@ -211,9 +212,12 @@ static int acm_write_start(struct acm *acm, int wbn) | ||
3256 | } | ||
3257 | |||
3258 | dbg("%s susp_count: %d", __func__, acm->susp_count); | ||
3259 | + usb_autopm_get_interface_async(acm->control); | ||
3260 | if (acm->susp_count) { | ||
3261 | - acm->delayed_wb = wb; | ||
3262 | - schedule_work(&acm->waker); | ||
3263 | + if (!acm->delayed_wb) | ||
3264 | + acm->delayed_wb = wb; | ||
3265 | + else | ||
3266 | + usb_autopm_put_interface_async(acm->control); | ||
3267 | spin_unlock_irqrestore(&acm->write_lock, flags); | ||
3268 | return 0; /* A white lie */ | ||
3269 | } | ||
3270 | @@ -534,23 +538,6 @@ static void acm_softint(struct work_struct *work) | ||
3271 | tty_kref_put(tty); | ||
3272 | } | ||
3273 | |||
3274 | -static void acm_waker(struct work_struct *waker) | ||
3275 | -{ | ||
3276 | - struct acm *acm = container_of(waker, struct acm, waker); | ||
3277 | - int rv; | ||
3278 | - | ||
3279 | - rv = usb_autopm_get_interface(acm->control); | ||
3280 | - if (rv < 0) { | ||
3281 | - dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__); | ||
3282 | - return; | ||
3283 | - } | ||
3284 | - if (acm->delayed_wb) { | ||
3285 | - acm_start_wb(acm, acm->delayed_wb); | ||
3286 | - acm->delayed_wb = NULL; | ||
3287 | - } | ||
3288 | - usb_autopm_put_interface(acm->control); | ||
3289 | -} | ||
3290 | - | ||
3291 | /* | ||
3292 | * TTY handlers | ||
3293 | */ | ||
3294 | @@ -1178,7 +1165,6 @@ made_compressed_probe: | ||
3295 | acm->urb_task.func = acm_rx_tasklet; | ||
3296 | acm->urb_task.data = (unsigned long) acm; | ||
3297 | INIT_WORK(&acm->work, acm_softint); | ||
3298 | - INIT_WORK(&acm->waker, acm_waker); | ||
3299 | init_waitqueue_head(&acm->drain_wait); | ||
3300 | spin_lock_init(&acm->throttle_lock); | ||
3301 | spin_lock_init(&acm->write_lock); | ||
3302 | @@ -1343,7 +1329,6 @@ static void stop_data_traffic(struct acm *acm) | ||
3303 | tasklet_enable(&acm->urb_task); | ||
3304 | |||
3305 | cancel_work_sync(&acm->work); | ||
3306 | - cancel_work_sync(&acm->waker); | ||
3307 | } | ||
3308 | |||
3309 | static void acm_disconnect(struct usb_interface *intf) | ||
3310 | @@ -1435,6 +1420,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message) | ||
3311 | static int acm_resume(struct usb_interface *intf) | ||
3312 | { | ||
3313 | struct acm *acm = usb_get_intfdata(intf); | ||
3314 | + struct acm_wb *wb; | ||
3315 | int rv = 0; | ||
3316 | int cnt; | ||
3317 | |||
3318 | @@ -1449,6 +1435,21 @@ static int acm_resume(struct usb_interface *intf) | ||
3319 | mutex_lock(&acm->mutex); | ||
3320 | if (acm->port.count) { | ||
3321 | rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO); | ||
3322 | + | ||
3323 | + spin_lock_irq(&acm->write_lock); | ||
3324 | + if (acm->delayed_wb) { | ||
3325 | + wb = acm->delayed_wb; | ||
3326 | + acm->delayed_wb = NULL; | ||
3327 | + spin_unlock_irq(&acm->write_lock); | ||
3328 | + acm_start_wb(acm, wb); | ||
3329 | + } else { | ||
3330 | + spin_unlock_irq(&acm->write_lock); | ||
3331 | + } | ||
3332 | + | ||
3333 | + /* | ||
3334 | + * delayed error checking because we must | ||
3335 | + * do the write path at all cost | ||
3336 | + */ | ||
3337 | if (rv < 0) | ||
3338 | goto err_out; | ||
3339 | |||
3340 | diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h | ||
3341 | index c4a0ee8..519eb63 100644 | ||
3342 | --- a/drivers/usb/class/cdc-acm.h | ||
3343 | +++ b/drivers/usb/class/cdc-acm.h | ||
3344 | @@ -112,7 +112,6 @@ struct acm { | ||
3345 | struct mutex mutex; | ||
3346 | struct usb_cdc_line_coding line; /* bits, stop, parity */ | ||
3347 | struct work_struct work; /* work queue entry for line discipline waking up */ | ||
3348 | - struct work_struct waker; | ||
3349 | wait_queue_head_t drain_wait; /* close processing */ | ||
3350 | struct tasklet_struct urb_task; /* rx processing */ | ||
3351 | spinlock_t throttle_lock; /* synchronize throtteling and read callback */ | ||
3352 | diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c | ||
3353 | index 2e78b07..9804ee9 100644 | ||
3354 | --- a/drivers/video/backlight/mbp_nvidia_bl.c | ||
3355 | +++ b/drivers/video/backlight/mbp_nvidia_bl.c | ||
3356 | @@ -139,6 +139,51 @@ static int mbp_dmi_match(const struct dmi_system_id *id) | ||
3357 | static const struct dmi_system_id __initdata mbp_device_table[] = { | ||
3358 | { | ||
3359 | .callback = mbp_dmi_match, | ||
3360 | + .ident = "MacBook 1,1", | ||
3361 | + .matches = { | ||
3362 | + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3363 | + DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"), | ||
3364 | + }, | ||
3365 | + .driver_data = (void *)&intel_chipset_data, | ||
3366 | + }, | ||
3367 | + { | ||
3368 | + .callback = mbp_dmi_match, | ||
3369 | + .ident = "MacBook 2,1", | ||
3370 | + .matches = { | ||
3371 | + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3372 | + DMI_MATCH(DMI_PRODUCT_NAME, "MacBook2,1"), | ||
3373 | + }, | ||
3374 | + .driver_data = (void *)&intel_chipset_data, | ||
3375 | + }, | ||
3376 | + { | ||
3377 | + .callback = mbp_dmi_match, | ||
3378 | + .ident = "MacBook 3,1", | ||
3379 | + .matches = { | ||
3380 | + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3381 | + DMI_MATCH(DMI_PRODUCT_NAME, "MacBook3,1"), | ||
3382 | + }, | ||
3383 | + .driver_data = (void *)&intel_chipset_data, | ||
3384 | + }, | ||
3385 | + { | ||
3386 | + .callback = mbp_dmi_match, | ||
3387 | + .ident = "MacBook 4,1", | ||
3388 | + .matches = { | ||
3389 | + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3390 | + DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,1"), | ||
3391 | + }, | ||
3392 | + .driver_data = (void *)&intel_chipset_data, | ||
3393 | + }, | ||
3394 | + { | ||
3395 | + .callback = mbp_dmi_match, | ||
3396 | + .ident = "MacBook 4,2", | ||
3397 | + .matches = { | ||
3398 | + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3399 | + DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,2"), | ||
3400 | + }, | ||
3401 | + .driver_data = (void *)&intel_chipset_data, | ||
3402 | + }, | ||
3403 | + { | ||
3404 | + .callback = mbp_dmi_match, | ||
3405 | .ident = "MacBookPro 3,1", | ||
3406 | .matches = { | ||
3407 | DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), | ||
3408 | diff --git a/drivers/video/sunxvr500.c b/drivers/video/sunxvr500.c | ||
3409 | index 4cd5049..3803745 100644 | ||
3410 | --- a/drivers/video/sunxvr500.c | ||
3411 | +++ b/drivers/video/sunxvr500.c | ||
3412 | @@ -242,11 +242,27 @@ static int __devinit e3d_set_fbinfo(struct e3d_info *ep) | ||
3413 | static int __devinit e3d_pci_register(struct pci_dev *pdev, | ||
3414 | const struct pci_device_id *ent) | ||
3415 | { | ||
3416 | + struct device_node *of_node; | ||
3417 | + const char *device_type; | ||
3418 | struct fb_info *info; | ||
3419 | struct e3d_info *ep; | ||
3420 | unsigned int line_length; | ||
3421 | int err; | ||
3422 | |||
3423 | + of_node = pci_device_to_OF_node(pdev); | ||
3424 | + if (!of_node) { | ||
3425 | + printk(KERN_ERR "e3d: Cannot find OF node of %s\n", | ||
3426 | + pci_name(pdev)); | ||
3427 | + return -ENODEV; | ||
3428 | + } | ||
3429 | + | ||
3430 | + device_type = of_get_property(of_node, "device_type", NULL); | ||
3431 | + if (!device_type) { | ||
3432 | + printk(KERN_INFO "e3d: Ignoring secondary output device " | ||
3433 | + "at %s\n", pci_name(pdev)); | ||
3434 | + return -ENODEV; | ||
3435 | + } | ||
3436 | + | ||
3437 | err = pci_enable_device(pdev); | ||
3438 | if (err < 0) { | ||
3439 | printk(KERN_ERR "e3d: Cannot enable PCI device %s\n", | ||
3440 | @@ -265,13 +281,7 @@ static int __devinit e3d_pci_register(struct pci_dev *pdev, | ||
3441 | ep->info = info; | ||
3442 | ep->pdev = pdev; | ||
3443 | spin_lock_init(&ep->lock); | ||
3444 | - ep->of_node = pci_device_to_OF_node(pdev); | ||
3445 | - if (!ep->of_node) { | ||
3446 | - printk(KERN_ERR "e3d: Cannot find OF node of %s\n", | ||
3447 | - pci_name(pdev)); | ||
3448 | - err = -ENODEV; | ||
3449 | - goto err_release_fb; | ||
3450 | - } | ||
3451 | + ep->of_node = of_node; | ||
3452 | |||
3453 | /* Read the PCI base register of the frame buffer, which we | ||
3454 | * need in order to interpret the RAMDAC_VID_*FB* values in | ||
3455 | diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c | ||
3456 | index a6c5674..0b91907 100644 | ||
3457 | --- a/drivers/watchdog/hpwdt.c | ||
3458 | +++ b/drivers/watchdog/hpwdt.c | ||
3459 | @@ -443,7 +443,7 @@ static void hpwdt_ping(void) | ||
3460 | static int hpwdt_change_timer(int new_margin) | ||
3461 | { | ||
3462 | /* Arbitrary, can't find the card's limits */ | ||
3463 | - if (new_margin < 30 || new_margin > 600) { | ||
3464 | + if (new_margin < 5 || new_margin > 600) { | ||
3465 | printk(KERN_WARNING | ||
3466 | "hpwdt: New value passed in is invalid: %d seconds.\n", | ||
3467 | new_margin); | ||
3468 | diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c | ||
3469 | index 4bdb7f1..e2ebe08 100644 | ||
3470 | --- a/drivers/watchdog/iTCO_wdt.c | ||
3471 | +++ b/drivers/watchdog/iTCO_wdt.c | ||
3472 | @@ -115,8 +115,37 @@ enum iTCO_chipsets { | ||
3473 | TCO_3420, /* 3420 */ | ||
3474 | TCO_3450, /* 3450 */ | ||
3475 | TCO_EP80579, /* EP80579 */ | ||
3476 | - TCO_CPTD, /* CPT Desktop */ | ||
3477 | - TCO_CPTM, /* CPT Mobile */ | ||
3478 | + TCO_CPT1, /* Cougar Point */ | ||
3479 | + TCO_CPT2, /* Cougar Point Desktop */ | ||
3480 | + TCO_CPT3, /* Cougar Point Mobile */ | ||
3481 | + TCO_CPT4, /* Cougar Point */ | ||
3482 | + TCO_CPT5, /* Cougar Point */ | ||
3483 | + TCO_CPT6, /* Cougar Point */ | ||
3484 | + TCO_CPT7, /* Cougar Point */ | ||
3485 | + TCO_CPT8, /* Cougar Point */ | ||
3486 | + TCO_CPT9, /* Cougar Point */ | ||
3487 | + TCO_CPT10, /* Cougar Point */ | ||
3488 | + TCO_CPT11, /* Cougar Point */ | ||
3489 | + TCO_CPT12, /* Cougar Point */ | ||
3490 | + TCO_CPT13, /* Cougar Point */ | ||
3491 | + TCO_CPT14, /* Cougar Point */ | ||
3492 | + TCO_CPT15, /* Cougar Point */ | ||
3493 | + TCO_CPT16, /* Cougar Point */ | ||
3494 | + TCO_CPT17, /* Cougar Point */ | ||
3495 | + TCO_CPT18, /* Cougar Point */ | ||
3496 | + TCO_CPT19, /* Cougar Point */ | ||
3497 | + TCO_CPT20, /* Cougar Point */ | ||
3498 | + TCO_CPT21, /* Cougar Point */ | ||
3499 | + TCO_CPT22, /* Cougar Point */ | ||
3500 | + TCO_CPT23, /* Cougar Point */ | ||
3501 | + TCO_CPT24, /* Cougar Point */ | ||
3502 | + TCO_CPT25, /* Cougar Point */ | ||
3503 | + TCO_CPT26, /* Cougar Point */ | ||
3504 | + TCO_CPT27, /* Cougar Point */ | ||
3505 | + TCO_CPT28, /* Cougar Point */ | ||
3506 | + TCO_CPT29, /* Cougar Point */ | ||
3507 | + TCO_CPT30, /* Cougar Point */ | ||
3508 | + TCO_CPT31, /* Cougar Point */ | ||
3509 | }; | ||
3510 | |||
3511 | static struct { | ||
3512 | @@ -173,8 +202,37 @@ static struct { | ||
3513 | {"3420", 2}, | ||
3514 | {"3450", 2}, | ||
3515 | {"EP80579", 2}, | ||
3516 | - {"CPT Desktop", 2}, | ||
3517 | - {"CPT Mobile", 2}, | ||
3518 | + {"Cougar Point", 2}, | ||
3519 | + {"Cougar Point", 2}, | ||
3520 | + {"Cougar Point", 2}, | ||
3521 | + {"Cougar Point", 2}, | ||
3522 | + {"Cougar Point", 2}, | ||
3523 | + {"Cougar Point", 2}, | ||
3524 | + {"Cougar Point", 2}, | ||
3525 | + {"Cougar Point", 2}, | ||
3526 | + {"Cougar Point", 2}, | ||
3527 | + {"Cougar Point", 2}, | ||
3528 | + {"Cougar Point", 2}, | ||
3529 | + {"Cougar Point", 2}, | ||
3530 | + {"Cougar Point", 2}, | ||
3531 | + {"Cougar Point", 2}, | ||
3532 | + {"Cougar Point", 2}, | ||
3533 | + {"Cougar Point", 2}, | ||
3534 | + {"Cougar Point", 2}, | ||
3535 | + {"Cougar Point", 2}, | ||
3536 | + {"Cougar Point", 2}, | ||
3537 | + {"Cougar Point", 2}, | ||
3538 | + {"Cougar Point", 2}, | ||
3539 | + {"Cougar Point", 2}, | ||
3540 | + {"Cougar Point", 2}, | ||
3541 | + {"Cougar Point", 2}, | ||
3542 | + {"Cougar Point", 2}, | ||
3543 | + {"Cougar Point", 2}, | ||
3544 | + {"Cougar Point", 2}, | ||
3545 | + {"Cougar Point", 2}, | ||
3546 | + {"Cougar Point", 2}, | ||
3547 | + {"Cougar Point", 2}, | ||
3548 | + {"Cougar Point", 2}, | ||
3549 | {NULL, 0} | ||
3550 | }; | ||
3551 | |||
3552 | @@ -259,8 +317,37 @@ static struct pci_device_id iTCO_wdt_pci_tbl[] = { | ||
3553 | { ITCO_PCI_DEVICE(0x3b14, TCO_3420)}, | ||
3554 | { ITCO_PCI_DEVICE(0x3b16, TCO_3450)}, | ||
3555 | { ITCO_PCI_DEVICE(0x5031, TCO_EP80579)}, | ||
3556 | - { ITCO_PCI_DEVICE(0x1c42, TCO_CPTD)}, | ||
3557 | - { ITCO_PCI_DEVICE(0x1c43, TCO_CPTM)}, | ||
3558 | + { ITCO_PCI_DEVICE(0x1c41, TCO_CPT1)}, | ||
3559 | + { ITCO_PCI_DEVICE(0x1c42, TCO_CPT2)}, | ||
3560 | + { ITCO_PCI_DEVICE(0x1c43, TCO_CPT3)}, | ||
3561 | + { ITCO_PCI_DEVICE(0x1c44, TCO_CPT4)}, | ||
3562 | + { ITCO_PCI_DEVICE(0x1c45, TCO_CPT5)}, | ||
3563 | + { ITCO_PCI_DEVICE(0x1c46, TCO_CPT6)}, | ||
3564 | + { ITCO_PCI_DEVICE(0x1c47, TCO_CPT7)}, | ||
3565 | + { ITCO_PCI_DEVICE(0x1c48, TCO_CPT8)}, | ||
3566 | + { ITCO_PCI_DEVICE(0x1c49, TCO_CPT9)}, | ||
3567 | + { ITCO_PCI_DEVICE(0x1c4a, TCO_CPT10)}, | ||
3568 | + { ITCO_PCI_DEVICE(0x1c4b, TCO_CPT11)}, | ||
3569 | + { ITCO_PCI_DEVICE(0x1c4c, TCO_CPT12)}, | ||
3570 | + { ITCO_PCI_DEVICE(0x1c4d, TCO_CPT13)}, | ||
3571 | + { ITCO_PCI_DEVICE(0x1c4e, TCO_CPT14)}, | ||
3572 | + { ITCO_PCI_DEVICE(0x1c4f, TCO_CPT15)}, | ||
3573 | + { ITCO_PCI_DEVICE(0x1c50, TCO_CPT16)}, | ||
3574 | + { ITCO_PCI_DEVICE(0x1c51, TCO_CPT17)}, | ||
3575 | + { ITCO_PCI_DEVICE(0x1c52, TCO_CPT18)}, | ||
3576 | + { ITCO_PCI_DEVICE(0x1c53, TCO_CPT19)}, | ||
3577 | + { ITCO_PCI_DEVICE(0x1c54, TCO_CPT20)}, | ||
3578 | + { ITCO_PCI_DEVICE(0x1c55, TCO_CPT21)}, | ||
3579 | + { ITCO_PCI_DEVICE(0x1c56, TCO_CPT22)}, | ||
3580 | + { ITCO_PCI_DEVICE(0x1c57, TCO_CPT23)}, | ||
3581 | + { ITCO_PCI_DEVICE(0x1c58, TCO_CPT24)}, | ||
3582 | + { ITCO_PCI_DEVICE(0x1c59, TCO_CPT25)}, | ||
3583 | + { ITCO_PCI_DEVICE(0x1c5a, TCO_CPT26)}, | ||
3584 | + { ITCO_PCI_DEVICE(0x1c5b, TCO_CPT27)}, | ||
3585 | + { ITCO_PCI_DEVICE(0x1c5c, TCO_CPT28)}, | ||
3586 | + { ITCO_PCI_DEVICE(0x1c5d, TCO_CPT29)}, | ||
3587 | + { ITCO_PCI_DEVICE(0x1c5e, TCO_CPT30)}, | ||
3588 | + { ITCO_PCI_DEVICE(0x1c5f, TCO_CPT31)}, | ||
3589 | { 0, }, /* End of list */ | ||
3590 | }; | ||
3591 | MODULE_DEVICE_TABLE(pci, iTCO_wdt_pci_tbl); | ||
3592 | diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c | ||
3593 | index 74a0461..92f9590 100644 | ||
3594 | --- a/fs/9p/vfs_file.c | ||
3595 | +++ b/fs/9p/vfs_file.c | ||
3596 | @@ -114,7 +114,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) | ||
3597 | P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); | ||
3598 | |||
3599 | /* No mandatory locks */ | ||
3600 | - if (__mandatory_lock(inode)) | ||
3601 | + if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) | ||
3602 | return -ENOLCK; | ||
3603 | |||
3604 | if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { | ||
3605 | diff --git a/fs/block_dev.c b/fs/block_dev.c | ||
3606 | index d11d028..8db62b2 100644 | ||
3607 | --- a/fs/block_dev.c | ||
3608 | +++ b/fs/block_dev.c | ||
3609 | @@ -404,7 +404,7 @@ static loff_t block_llseek(struct file *file, loff_t offset, int origin) | ||
3610 | * NULL first argument is nfsd_sync_dir() and that's not a directory. | ||
3611 | */ | ||
3612 | |||
3613 | -static int block_fsync(struct file *filp, struct dentry *dentry, int datasync) | ||
3614 | +int block_fsync(struct file *filp, struct dentry *dentry, int datasync) | ||
3615 | { | ||
3616 | struct block_device *bdev = I_BDEV(filp->f_mapping->host); | ||
3617 | int error; | ||
3618 | @@ -418,6 +418,7 @@ static int block_fsync(struct file *filp, struct dentry *dentry, int datasync) | ||
3619 | error = 0; | ||
3620 | return error; | ||
3621 | } | ||
3622 | +EXPORT_SYMBOL(block_fsync); | ||
3623 | |||
3624 | /* | ||
3625 | * pseudo-fs | ||
3626 | diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c | ||
3627 | index 941441d..4e6dbab 100644 | ||
3628 | --- a/fs/cifs/cifssmb.c | ||
3629 | +++ b/fs/cifs/cifssmb.c | ||
3630 | @@ -1430,6 +1430,8 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon, | ||
3631 | __u32 bytes_sent; | ||
3632 | __u16 byte_count; | ||
3633 | |||
3634 | + *nbytes = 0; | ||
3635 | + | ||
3636 | /* cFYI(1, ("write at %lld %d bytes", offset, count));*/ | ||
3637 | if (tcon->ses == NULL) | ||
3638 | return -ECONNABORTED; | ||
3639 | @@ -1512,11 +1514,18 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon, | ||
3640 | cifs_stats_inc(&tcon->num_writes); | ||
3641 | if (rc) { | ||
3642 | cFYI(1, ("Send error in write = %d", rc)); | ||
3643 | - *nbytes = 0; | ||
3644 | } else { | ||
3645 | *nbytes = le16_to_cpu(pSMBr->CountHigh); | ||
3646 | *nbytes = (*nbytes) << 16; | ||
3647 | *nbytes += le16_to_cpu(pSMBr->Count); | ||
3648 | + | ||
3649 | + /* | ||
3650 | + * Mask off high 16 bits when bytes written as returned by the | ||
3651 | + * server is greater than bytes requested by the client. Some | ||
3652 | + * OS/2 servers are known to set incorrect CountHigh values. | ||
3653 | + */ | ||
3654 | + if (*nbytes > count) | ||
3655 | + *nbytes &= 0xFFFF; | ||
3656 | } | ||
3657 | |||
3658 | cifs_buf_release(pSMB); | ||
3659 | @@ -1605,6 +1614,14 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon, | ||
3660 | *nbytes = le16_to_cpu(pSMBr->CountHigh); | ||
3661 | *nbytes = (*nbytes) << 16; | ||
3662 | *nbytes += le16_to_cpu(pSMBr->Count); | ||
3663 | + | ||
3664 | + /* | ||
3665 | + * Mask off high 16 bits when bytes written as returned by the | ||
3666 | + * server is greater than bytes requested by the client. OS/2 | ||
3667 | + * servers are known to set incorrect CountHigh values. | ||
3668 | + */ | ||
3669 | + if (*nbytes > count) | ||
3670 | + *nbytes &= 0xFFFF; | ||
3671 | } | ||
3672 | |||
3673 | /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */ | ||
3674 | diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c | ||
3675 | index 4a430ab..23dc2af 100644 | ||
3676 | --- a/fs/ecryptfs/inode.c | ||
3677 | +++ b/fs/ecryptfs/inode.c | ||
3678 | @@ -647,38 +647,17 @@ out_lock: | ||
3679 | return rc; | ||
3680 | } | ||
3681 | |||
3682 | -static int | ||
3683 | -ecryptfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz) | ||
3684 | +static int ecryptfs_readlink_lower(struct dentry *dentry, char **buf, | ||
3685 | + size_t *bufsiz) | ||
3686 | { | ||
3687 | + struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
3688 | char *lower_buf; | ||
3689 | - size_t lower_bufsiz; | ||
3690 | - struct dentry *lower_dentry; | ||
3691 | - struct ecryptfs_mount_crypt_stat *mount_crypt_stat; | ||
3692 | - char *plaintext_name; | ||
3693 | - size_t plaintext_name_size; | ||
3694 | + size_t lower_bufsiz = PATH_MAX; | ||
3695 | mm_segment_t old_fs; | ||
3696 | int rc; | ||
3697 | |||
3698 | - lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
3699 | - if (!lower_dentry->d_inode->i_op->readlink) { | ||
3700 | - rc = -EINVAL; | ||
3701 | - goto out; | ||
3702 | - } | ||
3703 | - mount_crypt_stat = &ecryptfs_superblock_to_private( | ||
3704 | - dentry->d_sb)->mount_crypt_stat; | ||
3705 | - /* | ||
3706 | - * If the lower filename is encrypted, it will result in a significantly | ||
3707 | - * longer name. If needed, truncate the name after decode and decrypt. | ||
3708 | - */ | ||
3709 | - if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) | ||
3710 | - lower_bufsiz = PATH_MAX; | ||
3711 | - else | ||
3712 | - lower_bufsiz = bufsiz; | ||
3713 | - /* Released in this function */ | ||
3714 | lower_buf = kmalloc(lower_bufsiz, GFP_KERNEL); | ||
3715 | - if (lower_buf == NULL) { | ||
3716 | - printk(KERN_ERR "%s: Out of memory whilst attempting to " | ||
3717 | - "kmalloc [%zd] bytes\n", __func__, lower_bufsiz); | ||
3718 | + if (!lower_buf) { | ||
3719 | rc = -ENOMEM; | ||
3720 | goto out; | ||
3721 | } | ||
3722 | @@ -688,29 +667,31 @@ ecryptfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz) | ||
3723 | (char __user *)lower_buf, | ||
3724 | lower_bufsiz); | ||
3725 | set_fs(old_fs); | ||
3726 | - if (rc >= 0) { | ||
3727 | - rc = ecryptfs_decode_and_decrypt_filename(&plaintext_name, | ||
3728 | - &plaintext_name_size, | ||
3729 | - dentry, lower_buf, | ||
3730 | - rc); | ||
3731 | - if (rc) { | ||
3732 | - printk(KERN_ERR "%s: Error attempting to decode and " | ||
3733 | - "decrypt filename; rc = [%d]\n", __func__, | ||
3734 | - rc); | ||
3735 | - goto out_free_lower_buf; | ||
3736 | - } | ||
3737 | - /* Check for bufsiz <= 0 done in sys_readlinkat() */ | ||
3738 | - rc = copy_to_user(buf, plaintext_name, | ||
3739 | - min((size_t) bufsiz, plaintext_name_size)); | ||
3740 | - if (rc) | ||
3741 | - rc = -EFAULT; | ||
3742 | - else | ||
3743 | - rc = plaintext_name_size; | ||
3744 | - kfree(plaintext_name); | ||
3745 | - fsstack_copy_attr_atime(dentry->d_inode, lower_dentry->d_inode); | ||
3746 | - } | ||
3747 | -out_free_lower_buf: | ||
3748 | + if (rc < 0) | ||
3749 | + goto out; | ||
3750 | + lower_bufsiz = rc; | ||
3751 | + rc = ecryptfs_decode_and_decrypt_filename(buf, bufsiz, dentry, | ||
3752 | + lower_buf, lower_bufsiz); | ||
3753 | +out: | ||
3754 | kfree(lower_buf); | ||
3755 | + return rc; | ||
3756 | +} | ||
3757 | + | ||
3758 | +static int | ||
3759 | +ecryptfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz) | ||
3760 | +{ | ||
3761 | + char *kbuf; | ||
3762 | + size_t kbufsiz, copied; | ||
3763 | + int rc; | ||
3764 | + | ||
3765 | + rc = ecryptfs_readlink_lower(dentry, &kbuf, &kbufsiz); | ||
3766 | + if (rc) | ||
3767 | + goto out; | ||
3768 | + copied = min_t(size_t, bufsiz, kbufsiz); | ||
3769 | + rc = copy_to_user(buf, kbuf, copied) ? -EFAULT : copied; | ||
3770 | + kfree(kbuf); | ||
3771 | + fsstack_copy_attr_atime(dentry->d_inode, | ||
3772 | + ecryptfs_dentry_to_lower(dentry)->d_inode); | ||
3773 | out: | ||
3774 | return rc; | ||
3775 | } | ||
3776 | @@ -1015,6 +996,28 @@ out: | ||
3777 | return rc; | ||
3778 | } | ||
3779 | |||
3780 | +int ecryptfs_getattr_link(struct vfsmount *mnt, struct dentry *dentry, | ||
3781 | + struct kstat *stat) | ||
3782 | +{ | ||
3783 | + struct ecryptfs_mount_crypt_stat *mount_crypt_stat; | ||
3784 | + int rc = 0; | ||
3785 | + | ||
3786 | + mount_crypt_stat = &ecryptfs_superblock_to_private( | ||
3787 | + dentry->d_sb)->mount_crypt_stat; | ||
3788 | + generic_fillattr(dentry->d_inode, stat); | ||
3789 | + if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) { | ||
3790 | + char *target; | ||
3791 | + size_t targetsiz; | ||
3792 | + | ||
3793 | + rc = ecryptfs_readlink_lower(dentry, &target, &targetsiz); | ||
3794 | + if (!rc) { | ||
3795 | + kfree(target); | ||
3796 | + stat->size = targetsiz; | ||
3797 | + } | ||
3798 | + } | ||
3799 | + return rc; | ||
3800 | +} | ||
3801 | + | ||
3802 | int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry, | ||
3803 | struct kstat *stat) | ||
3804 | { | ||
3805 | @@ -1039,7 +1042,7 @@ ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value, | ||
3806 | |||
3807 | lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
3808 | if (!lower_dentry->d_inode->i_op->setxattr) { | ||
3809 | - rc = -ENOSYS; | ||
3810 | + rc = -EOPNOTSUPP; | ||
3811 | goto out; | ||
3812 | } | ||
3813 | mutex_lock(&lower_dentry->d_inode->i_mutex); | ||
3814 | @@ -1057,7 +1060,7 @@ ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name, | ||
3815 | int rc = 0; | ||
3816 | |||
3817 | if (!lower_dentry->d_inode->i_op->getxattr) { | ||
3818 | - rc = -ENOSYS; | ||
3819 | + rc = -EOPNOTSUPP; | ||
3820 | goto out; | ||
3821 | } | ||
3822 | mutex_lock(&lower_dentry->d_inode->i_mutex); | ||
3823 | @@ -1084,7 +1087,7 @@ ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size) | ||
3824 | |||
3825 | lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
3826 | if (!lower_dentry->d_inode->i_op->listxattr) { | ||
3827 | - rc = -ENOSYS; | ||
3828 | + rc = -EOPNOTSUPP; | ||
3829 | goto out; | ||
3830 | } | ||
3831 | mutex_lock(&lower_dentry->d_inode->i_mutex); | ||
3832 | @@ -1101,7 +1104,7 @@ static int ecryptfs_removexattr(struct dentry *dentry, const char *name) | ||
3833 | |||
3834 | lower_dentry = ecryptfs_dentry_to_lower(dentry); | ||
3835 | if (!lower_dentry->d_inode->i_op->removexattr) { | ||
3836 | - rc = -ENOSYS; | ||
3837 | + rc = -EOPNOTSUPP; | ||
3838 | goto out; | ||
3839 | } | ||
3840 | mutex_lock(&lower_dentry->d_inode->i_mutex); | ||
3841 | @@ -1132,6 +1135,7 @@ const struct inode_operations ecryptfs_symlink_iops = { | ||
3842 | .put_link = ecryptfs_put_link, | ||
3843 | .permission = ecryptfs_permission, | ||
3844 | .setattr = ecryptfs_setattr, | ||
3845 | + .getattr = ecryptfs_getattr_link, | ||
3846 | .setxattr = ecryptfs_setxattr, | ||
3847 | .getxattr = ecryptfs_getxattr, | ||
3848 | .listxattr = ecryptfs_listxattr, | ||
3849 | diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c | ||
3850 | index b15a43a..1a037f7 100644 | ||
3851 | --- a/fs/ecryptfs/super.c | ||
3852 | +++ b/fs/ecryptfs/super.c | ||
3853 | @@ -85,7 +85,6 @@ static void ecryptfs_destroy_inode(struct inode *inode) | ||
3854 | if (lower_dentry->d_inode) { | ||
3855 | fput(inode_info->lower_file); | ||
3856 | inode_info->lower_file = NULL; | ||
3857 | - d_drop(lower_dentry); | ||
3858 | } | ||
3859 | } | ||
3860 | ecryptfs_destroy_crypt_stat(&inode_info->crypt_stat); | ||
3861 | diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h | ||
3862 | index 874d169..602d5ad 100644 | ||
3863 | --- a/fs/ext4/ext4.h | ||
3864 | +++ b/fs/ext4/ext4.h | ||
3865 | @@ -139,8 +139,8 @@ typedef struct ext4_io_end { | ||
3866 | struct inode *inode; /* file being written to */ | ||
3867 | unsigned int flag; /* unwritten or not */ | ||
3868 | int error; /* I/O error code */ | ||
3869 | - ext4_lblk_t offset; /* offset in the file */ | ||
3870 | - size_t size; /* size of the extent */ | ||
3871 | + loff_t offset; /* offset in the file */ | ||
3872 | + ssize_t size; /* size of the extent */ | ||
3873 | struct work_struct work; /* data work queue */ | ||
3874 | } ext4_io_end_t; | ||
3875 | |||
3876 | @@ -1744,7 +1744,7 @@ extern void ext4_ext_release(struct super_block *); | ||
3877 | extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset, | ||
3878 | loff_t len); | ||
3879 | extern int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset, | ||
3880 | - loff_t len); | ||
3881 | + ssize_t len); | ||
3882 | extern int ext4_get_blocks(handle_t *handle, struct inode *inode, | ||
3883 | sector_t block, unsigned int max_blocks, | ||
3884 | struct buffer_head *bh, int flags); | ||
3885 | diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c | ||
3886 | index 765a482..c568779 100644 | ||
3887 | --- a/fs/ext4/extents.c | ||
3888 | +++ b/fs/ext4/extents.c | ||
3889 | @@ -3603,7 +3603,7 @@ retry: | ||
3890 | * Returns 0 on success. | ||
3891 | */ | ||
3892 | int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset, | ||
3893 | - loff_t len) | ||
3894 | + ssize_t len) | ||
3895 | { | ||
3896 | handle_t *handle; | ||
3897 | ext4_lblk_t block; | ||
3898 | diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c | ||
3899 | index e119524..2059c34 100644 | ||
3900 | --- a/fs/ext4/inode.c | ||
3901 | +++ b/fs/ext4/inode.c | ||
3902 | @@ -3551,7 +3551,7 @@ static int ext4_end_aio_dio_nolock(ext4_io_end_t *io) | ||
3903 | { | ||
3904 | struct inode *inode = io->inode; | ||
3905 | loff_t offset = io->offset; | ||
3906 | - size_t size = io->size; | ||
3907 | + ssize_t size = io->size; | ||
3908 | int ret = 0; | ||
3909 | |||
3910 | ext4_debug("end_aio_dio_onlock: io 0x%p from inode %lu,list->next 0x%p," | ||
3911 | diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c | ||
3912 | index f565f24..72646e2 100644 | ||
3913 | --- a/fs/fat/namei_vfat.c | ||
3914 | +++ b/fs/fat/namei_vfat.c | ||
3915 | @@ -309,7 +309,7 @@ static int vfat_create_shortname(struct inode *dir, struct nls_table *nls, | ||
3916 | { | ||
3917 | struct fat_mount_options *opts = &MSDOS_SB(dir->i_sb)->options; | ||
3918 | wchar_t *ip, *ext_start, *end, *name_start; | ||
3919 | - unsigned char base[9], ext[4], buf[8], *p; | ||
3920 | + unsigned char base[9], ext[4], buf[5], *p; | ||
3921 | unsigned char charbuf[NLS_MAX_CHARSET_SIZE]; | ||
3922 | int chl, chi; | ||
3923 | int sz = 0, extlen, baselen, i, numtail_baselen, numtail2_baselen; | ||
3924 | @@ -467,7 +467,7 @@ static int vfat_create_shortname(struct inode *dir, struct nls_table *nls, | ||
3925 | return 0; | ||
3926 | } | ||
3927 | |||
3928 | - i = jiffies & 0xffff; | ||
3929 | + i = jiffies; | ||
3930 | sz = (jiffies >> 16) & 0x7; | ||
3931 | if (baselen > 2) { | ||
3932 | baselen = numtail2_baselen; | ||
3933 | @@ -476,7 +476,7 @@ static int vfat_create_shortname(struct inode *dir, struct nls_table *nls, | ||
3934 | name_res[baselen + 4] = '~'; | ||
3935 | name_res[baselen + 5] = '1' + sz; | ||
3936 | while (1) { | ||
3937 | - sprintf(buf, "%04X", i); | ||
3938 | + snprintf(buf, sizeof(buf), "%04X", i & 0xffff); | ||
3939 | memcpy(&name_res[baselen], buf, 4); | ||
3940 | if (vfat_find_form(dir, name_res) < 0) | ||
3941 | break; | ||
3942 | diff --git a/fs/nfs/client.c b/fs/nfs/client.c | ||
3943 | index ee77713..bd39abc 100644 | ||
3944 | --- a/fs/nfs/client.c | ||
3945 | +++ b/fs/nfs/client.c | ||
3946 | @@ -1293,7 +1293,8 @@ static int nfs4_init_server(struct nfs_server *server, | ||
3947 | |||
3948 | /* Initialise the client representation from the mount data */ | ||
3949 | server->flags = data->flags; | ||
3950 | - server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR; | ||
3951 | + server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR| | ||
3952 | + NFS_CAP_POSIX_LOCK; | ||
3953 | server->options = data->options; | ||
3954 | |||
3955 | /* Get a client record */ | ||
3956 | diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c | ||
3957 | index 8b5382e..af6948d 100644 | ||
3958 | --- a/fs/nfs/dir.c | ||
3959 | +++ b/fs/nfs/dir.c | ||
3960 | @@ -1025,12 +1025,12 @@ static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry | ||
3961 | res = NULL; | ||
3962 | goto out; | ||
3963 | /* This turned out not to be a regular file */ | ||
3964 | + case -EISDIR: | ||
3965 | case -ENOTDIR: | ||
3966 | goto no_open; | ||
3967 | case -ELOOP: | ||
3968 | if (!(nd->intent.open.flags & O_NOFOLLOW)) | ||
3969 | goto no_open; | ||
3970 | - /* case -EISDIR: */ | ||
3971 | /* case -EINVAL: */ | ||
3972 | default: | ||
3973 | goto out; | ||
3974 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
3975 | index 375f0fa..ecf6602 100644 | ||
3976 | --- a/fs/nfs/nfs4proc.c | ||
3977 | +++ b/fs/nfs/nfs4proc.c | ||
3978 | @@ -1520,6 +1520,8 @@ static int _nfs4_proc_open(struct nfs4_opendata *data) | ||
3979 | nfs_post_op_update_inode(dir, o_res->dir_attr); | ||
3980 | } else | ||
3981 | nfs_refresh_inode(dir, o_res->dir_attr); | ||
3982 | + if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) | ||
3983 | + server->caps &= ~NFS_CAP_POSIX_LOCK; | ||
3984 | if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { | ||
3985 | status = _nfs4_proc_open_confirm(data); | ||
3986 | if (status != 0) | ||
3987 | @@ -1660,7 +1662,7 @@ static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, in | ||
3988 | status = PTR_ERR(state); | ||
3989 | if (IS_ERR(state)) | ||
3990 | goto err_opendata_put; | ||
3991 | - if ((opendata->o_res.rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) != 0) | ||
3992 | + if (server->caps & NFS_CAP_POSIX_LOCK) | ||
3993 | set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); | ||
3994 | nfs4_opendata_put(opendata); | ||
3995 | nfs4_put_state_owner(sp); | ||
3996 | diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c | ||
3997 | index a8587e9..bbf72d8 100644 | ||
3998 | --- a/fs/nfsd/nfs4xdr.c | ||
3999 | +++ b/fs/nfsd/nfs4xdr.c | ||
4000 | @@ -2121,9 +2121,15 @@ out_acl: | ||
4001 | * and this is the root of a cross-mounted filesystem. | ||
4002 | */ | ||
4003 | if (ignore_crossmnt == 0 && | ||
4004 | - exp->ex_path.mnt->mnt_root->d_inode == dentry->d_inode) { | ||
4005 | - err = vfs_getattr(exp->ex_path.mnt->mnt_parent, | ||
4006 | - exp->ex_path.mnt->mnt_mountpoint, &stat); | ||
4007 | + dentry == exp->ex_path.mnt->mnt_root) { | ||
4008 | + struct path path = exp->ex_path; | ||
4009 | + path_get(&path); | ||
4010 | + while (follow_up(&path)) { | ||
4011 | + if (path.dentry != path.mnt->mnt_root) | ||
4012 | + break; | ||
4013 | + } | ||
4014 | + err = vfs_getattr(path.mnt, path.dentry, &stat); | ||
4015 | + path_put(&path); | ||
4016 | if (err) | ||
4017 | goto out_nfserr; | ||
4018 | } | ||
4019 | diff --git a/fs/ocfs2/acl.c b/fs/ocfs2/acl.c | ||
4020 | index 0501974..8ccf0f8 100644 | ||
4021 | --- a/fs/ocfs2/acl.c | ||
4022 | +++ b/fs/ocfs2/acl.c | ||
4023 | @@ -30,6 +30,8 @@ | ||
4024 | #include "alloc.h" | ||
4025 | #include "dlmglue.h" | ||
4026 | #include "file.h" | ||
4027 | +#include "inode.h" | ||
4028 | +#include "journal.h" | ||
4029 | #include "ocfs2_fs.h" | ||
4030 | |||
4031 | #include "xattr.h" | ||
4032 | @@ -166,6 +168,60 @@ static struct posix_acl *ocfs2_get_acl(struct inode *inode, int type) | ||
4033 | } | ||
4034 | |||
4035 | /* | ||
4036 | + * Helper function to set i_mode in memory and disk. Some call paths | ||
4037 | + * will not have di_bh or a journal handle to pass, in which case it | ||
4038 | + * will create it's own. | ||
4039 | + */ | ||
4040 | +static int ocfs2_acl_set_mode(struct inode *inode, struct buffer_head *di_bh, | ||
4041 | + handle_t *handle, umode_t new_mode) | ||
4042 | +{ | ||
4043 | + int ret, commit_handle = 0; | ||
4044 | + struct ocfs2_dinode *di; | ||
4045 | + | ||
4046 | + if (di_bh == NULL) { | ||
4047 | + ret = ocfs2_read_inode_block(inode, &di_bh); | ||
4048 | + if (ret) { | ||
4049 | + mlog_errno(ret); | ||
4050 | + goto out; | ||
4051 | + } | ||
4052 | + } else | ||
4053 | + get_bh(di_bh); | ||
4054 | + | ||
4055 | + if (handle == NULL) { | ||
4056 | + handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), | ||
4057 | + OCFS2_INODE_UPDATE_CREDITS); | ||
4058 | + if (IS_ERR(handle)) { | ||
4059 | + ret = PTR_ERR(handle); | ||
4060 | + mlog_errno(ret); | ||
4061 | + goto out_brelse; | ||
4062 | + } | ||
4063 | + | ||
4064 | + commit_handle = 1; | ||
4065 | + } | ||
4066 | + | ||
4067 | + di = (struct ocfs2_dinode *)di_bh->b_data; | ||
4068 | + ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, | ||
4069 | + OCFS2_JOURNAL_ACCESS_WRITE); | ||
4070 | + if (ret) { | ||
4071 | + mlog_errno(ret); | ||
4072 | + goto out_commit; | ||
4073 | + } | ||
4074 | + | ||
4075 | + inode->i_mode = new_mode; | ||
4076 | + di->i_mode = cpu_to_le16(inode->i_mode); | ||
4077 | + | ||
4078 | + ocfs2_journal_dirty(handle, di_bh); | ||
4079 | + | ||
4080 | +out_commit: | ||
4081 | + if (commit_handle) | ||
4082 | + ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); | ||
4083 | +out_brelse: | ||
4084 | + brelse(di_bh); | ||
4085 | +out: | ||
4086 | + return ret; | ||
4087 | +} | ||
4088 | + | ||
4089 | +/* | ||
4090 | * Set the access or default ACL of an inode. | ||
4091 | */ | ||
4092 | static int ocfs2_set_acl(handle_t *handle, | ||
4093 | @@ -193,9 +249,14 @@ static int ocfs2_set_acl(handle_t *handle, | ||
4094 | if (ret < 0) | ||
4095 | return ret; | ||
4096 | else { | ||
4097 | - inode->i_mode = mode; | ||
4098 | if (ret == 0) | ||
4099 | acl = NULL; | ||
4100 | + | ||
4101 | + ret = ocfs2_acl_set_mode(inode, di_bh, | ||
4102 | + handle, mode); | ||
4103 | + if (ret) | ||
4104 | + return ret; | ||
4105 | + | ||
4106 | } | ||
4107 | } | ||
4108 | break; | ||
4109 | @@ -283,6 +344,7 @@ int ocfs2_init_acl(handle_t *handle, | ||
4110 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | ||
4111 | struct posix_acl *acl = NULL; | ||
4112 | int ret = 0; | ||
4113 | + mode_t mode; | ||
4114 | |||
4115 | if (!S_ISLNK(inode->i_mode)) { | ||
4116 | if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) { | ||
4117 | @@ -291,12 +353,17 @@ int ocfs2_init_acl(handle_t *handle, | ||
4118 | if (IS_ERR(acl)) | ||
4119 | return PTR_ERR(acl); | ||
4120 | } | ||
4121 | - if (!acl) | ||
4122 | - inode->i_mode &= ~current_umask(); | ||
4123 | + if (!acl) { | ||
4124 | + mode = inode->i_mode & ~current_umask(); | ||
4125 | + ret = ocfs2_acl_set_mode(inode, di_bh, handle, mode); | ||
4126 | + if (ret) { | ||
4127 | + mlog_errno(ret); | ||
4128 | + goto cleanup; | ||
4129 | + } | ||
4130 | + } | ||
4131 | } | ||
4132 | if ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) && acl) { | ||
4133 | struct posix_acl *clone; | ||
4134 | - mode_t mode; | ||
4135 | |||
4136 | if (S_ISDIR(inode->i_mode)) { | ||
4137 | ret = ocfs2_set_acl(handle, inode, di_bh, | ||
4138 | @@ -313,7 +380,7 @@ int ocfs2_init_acl(handle_t *handle, | ||
4139 | mode = inode->i_mode; | ||
4140 | ret = posix_acl_create_masq(clone, &mode); | ||
4141 | if (ret >= 0) { | ||
4142 | - inode->i_mode = mode; | ||
4143 | + ret = ocfs2_acl_set_mode(inode, di_bh, handle, mode); | ||
4144 | if (ret > 0) { | ||
4145 | ret = ocfs2_set_acl(handle, inode, | ||
4146 | di_bh, ACL_TYPE_ACCESS, | ||
4147 | diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c | ||
4148 | index c30b644..79b5dac 100644 | ||
4149 | --- a/fs/ocfs2/suballoc.c | ||
4150 | +++ b/fs/ocfs2/suballoc.c | ||
4151 | @@ -152,7 +152,7 @@ static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl) | ||
4152 | |||
4153 | #define do_error(fmt, ...) \ | ||
4154 | do{ \ | ||
4155 | - if (clean_error) \ | ||
4156 | + if (resize) \ | ||
4157 | mlog(ML_ERROR, fmt "\n", ##__VA_ARGS__); \ | ||
4158 | else \ | ||
4159 | ocfs2_error(sb, fmt, ##__VA_ARGS__); \ | ||
4160 | @@ -160,7 +160,7 @@ static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl) | ||
4161 | |||
4162 | static int ocfs2_validate_gd_self(struct super_block *sb, | ||
4163 | struct buffer_head *bh, | ||
4164 | - int clean_error) | ||
4165 | + int resize) | ||
4166 | { | ||
4167 | struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; | ||
4168 | |||
4169 | @@ -211,7 +211,7 @@ static int ocfs2_validate_gd_self(struct super_block *sb, | ||
4170 | static int ocfs2_validate_gd_parent(struct super_block *sb, | ||
4171 | struct ocfs2_dinode *di, | ||
4172 | struct buffer_head *bh, | ||
4173 | - int clean_error) | ||
4174 | + int resize) | ||
4175 | { | ||
4176 | unsigned int max_bits; | ||
4177 | struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; | ||
4178 | @@ -233,8 +233,11 @@ static int ocfs2_validate_gd_parent(struct super_block *sb, | ||
4179 | return -EINVAL; | ||
4180 | } | ||
4181 | |||
4182 | - if (le16_to_cpu(gd->bg_chain) >= | ||
4183 | - le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) { | ||
4184 | + /* In resize, we may meet the case bg_chain == cl_next_free_rec. */ | ||
4185 | + if ((le16_to_cpu(gd->bg_chain) > | ||
4186 | + le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) || | ||
4187 | + ((le16_to_cpu(gd->bg_chain) == | ||
4188 | + le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) && !resize)) { | ||
4189 | do_error("Group descriptor #%llu has bad chain %u", | ||
4190 | (unsigned long long)bh->b_blocknr, | ||
4191 | le16_to_cpu(gd->bg_chain)); | ||
4192 | diff --git a/fs/proc/base.c b/fs/proc/base.c | ||
4193 | index 58324c2..3cd449d 100644 | ||
4194 | --- a/fs/proc/base.c | ||
4195 | +++ b/fs/proc/base.c | ||
4196 | @@ -442,12 +442,13 @@ static const struct file_operations proc_lstats_operations = { | ||
4197 | unsigned long badness(struct task_struct *p, unsigned long uptime); | ||
4198 | static int proc_oom_score(struct task_struct *task, char *buffer) | ||
4199 | { | ||
4200 | - unsigned long points; | ||
4201 | + unsigned long points = 0; | ||
4202 | struct timespec uptime; | ||
4203 | |||
4204 | do_posix_clock_monotonic_gettime(&uptime); | ||
4205 | read_lock(&tasklist_lock); | ||
4206 | - points = badness(task->group_leader, uptime.tv_sec); | ||
4207 | + if (pid_alive(task)) | ||
4208 | + points = badness(task, uptime.tv_sec); | ||
4209 | read_unlock(&tasklist_lock); | ||
4210 | return sprintf(buffer, "%lu\n", points); | ||
4211 | } | ||
4212 | diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c | ||
4213 | index 6e722c1..6c9da00 100644 | ||
4214 | --- a/fs/quota/dquot.c | ||
4215 | +++ b/fs/quota/dquot.c | ||
4216 | @@ -2321,34 +2321,34 @@ static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di) | ||
4217 | if (di->dqb_valid & QIF_SPACE) { | ||
4218 | dm->dqb_curspace = di->dqb_curspace - dm->dqb_rsvspace; | ||
4219 | check_blim = 1; | ||
4220 | - __set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); | ||
4221 | + set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); | ||
4222 | } | ||
4223 | if (di->dqb_valid & QIF_BLIMITS) { | ||
4224 | dm->dqb_bsoftlimit = qbtos(di->dqb_bsoftlimit); | ||
4225 | dm->dqb_bhardlimit = qbtos(di->dqb_bhardlimit); | ||
4226 | check_blim = 1; | ||
4227 | - __set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); | ||
4228 | + set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); | ||
4229 | } | ||
4230 | if (di->dqb_valid & QIF_INODES) { | ||
4231 | dm->dqb_curinodes = di->dqb_curinodes; | ||
4232 | check_ilim = 1; | ||
4233 | - __set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); | ||
4234 | + set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); | ||
4235 | } | ||
4236 | if (di->dqb_valid & QIF_ILIMITS) { | ||
4237 | dm->dqb_isoftlimit = di->dqb_isoftlimit; | ||
4238 | dm->dqb_ihardlimit = di->dqb_ihardlimit; | ||
4239 | check_ilim = 1; | ||
4240 | - __set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); | ||
4241 | + set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); | ||
4242 | } | ||
4243 | if (di->dqb_valid & QIF_BTIME) { | ||
4244 | dm->dqb_btime = di->dqb_btime; | ||
4245 | check_blim = 1; | ||
4246 | - __set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); | ||
4247 | + set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); | ||
4248 | } | ||
4249 | if (di->dqb_valid & QIF_ITIME) { | ||
4250 | dm->dqb_itime = di->dqb_itime; | ||
4251 | check_ilim = 1; | ||
4252 | - __set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); | ||
4253 | + set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); | ||
4254 | } | ||
4255 | |||
4256 | if (check_blim) { | ||
4257 | diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c | ||
4258 | index b4a7dd0..33bc410 100644 | ||
4259 | --- a/fs/reiserfs/super.c | ||
4260 | +++ b/fs/reiserfs/super.c | ||
4261 | @@ -1619,10 +1619,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent) | ||
4262 | save_mount_options(s, data); | ||
4263 | |||
4264 | sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL); | ||
4265 | - if (!sbi) { | ||
4266 | - errval = -ENOMEM; | ||
4267 | - goto error_alloc; | ||
4268 | - } | ||
4269 | + if (!sbi) | ||
4270 | + return -ENOMEM; | ||
4271 | s->s_fs_info = sbi; | ||
4272 | /* Set default values for options: non-aggressive tails, RO on errors */ | ||
4273 | REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL); | ||
4274 | @@ -1879,12 +1877,12 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent) | ||
4275 | return (0); | ||
4276 | |||
4277 | error: | ||
4278 | - reiserfs_write_unlock(s); | ||
4279 | -error_alloc: | ||
4280 | if (jinit_done) { /* kill the commit thread, free journal ram */ | ||
4281 | journal_release_error(NULL, s); | ||
4282 | } | ||
4283 | |||
4284 | + reiserfs_write_unlock(s); | ||
4285 | + | ||
4286 | reiserfs_free_bitmap_cache(s); | ||
4287 | if (SB_BUFFER_WITH_SB(s)) | ||
4288 | brelse(SB_BUFFER_WITH_SB(s)); | ||
4289 | diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c | ||
4290 | index 66abe36..1c65a2b 100644 | ||
4291 | --- a/fs/xfs/linux-2.6/xfs_aops.c | ||
4292 | +++ b/fs/xfs/linux-2.6/xfs_aops.c | ||
4293 | @@ -163,14 +163,17 @@ xfs_ioend_new_eof( | ||
4294 | } | ||
4295 | |||
4296 | /* | ||
4297 | - * Update on-disk file size now that data has been written to disk. | ||
4298 | - * The current in-memory file size is i_size. If a write is beyond | ||
4299 | - * eof i_new_size will be the intended file size until i_size is | ||
4300 | - * updated. If this write does not extend all the way to the valid | ||
4301 | - * file size then restrict this update to the end of the write. | ||
4302 | + * Update on-disk file size now that data has been written to disk. The | ||
4303 | + * current in-memory file size is i_size. If a write is beyond eof i_new_size | ||
4304 | + * will be the intended file size until i_size is updated. If this write does | ||
4305 | + * not extend all the way to the valid file size then restrict this update to | ||
4306 | + * the end of the write. | ||
4307 | + * | ||
4308 | + * This function does not block as blocking on the inode lock in IO completion | ||
4309 | + * can lead to IO completion order dependency deadlocks.. If it can't get the | ||
4310 | + * inode ilock it will return EAGAIN. Callers must handle this. | ||
4311 | */ | ||
4312 | - | ||
4313 | -STATIC void | ||
4314 | +STATIC int | ||
4315 | xfs_setfilesize( | ||
4316 | xfs_ioend_t *ioend) | ||
4317 | { | ||
4318 | @@ -181,9 +184,11 @@ xfs_setfilesize( | ||
4319 | ASSERT(ioend->io_type != IOMAP_READ); | ||
4320 | |||
4321 | if (unlikely(ioend->io_error)) | ||
4322 | - return; | ||
4323 | + return 0; | ||
4324 | + | ||
4325 | + if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) | ||
4326 | + return EAGAIN; | ||
4327 | |||
4328 | - xfs_ilock(ip, XFS_ILOCK_EXCL); | ||
4329 | isize = xfs_ioend_new_eof(ioend); | ||
4330 | if (isize) { | ||
4331 | ip->i_d.di_size = isize; | ||
4332 | @@ -191,6 +196,28 @@ xfs_setfilesize( | ||
4333 | } | ||
4334 | |||
4335 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | ||
4336 | + return 0; | ||
4337 | +} | ||
4338 | + | ||
4339 | +/* | ||
4340 | + * Schedule IO completion handling on a xfsdatad if this was | ||
4341 | + * the final hold on this ioend. If we are asked to wait, | ||
4342 | + * flush the workqueue. | ||
4343 | + */ | ||
4344 | +STATIC void | ||
4345 | +xfs_finish_ioend( | ||
4346 | + xfs_ioend_t *ioend, | ||
4347 | + int wait) | ||
4348 | +{ | ||
4349 | + if (atomic_dec_and_test(&ioend->io_remaining)) { | ||
4350 | + struct workqueue_struct *wq; | ||
4351 | + | ||
4352 | + wq = (ioend->io_type == IOMAP_UNWRITTEN) ? | ||
4353 | + xfsconvertd_workqueue : xfsdatad_workqueue; | ||
4354 | + queue_work(wq, &ioend->io_work); | ||
4355 | + if (wait) | ||
4356 | + flush_workqueue(wq); | ||
4357 | + } | ||
4358 | } | ||
4359 | |||
4360 | /* | ||
4361 | @@ -198,11 +225,11 @@ xfs_setfilesize( | ||
4362 | */ | ||
4363 | STATIC void | ||
4364 | xfs_end_io( | ||
4365 | - struct work_struct *work) | ||
4366 | + struct work_struct *work) | ||
4367 | { | ||
4368 | - xfs_ioend_t *ioend = | ||
4369 | - container_of(work, xfs_ioend_t, io_work); | ||
4370 | - struct xfs_inode *ip = XFS_I(ioend->io_inode); | ||
4371 | + xfs_ioend_t *ioend = container_of(work, xfs_ioend_t, io_work); | ||
4372 | + struct xfs_inode *ip = XFS_I(ioend->io_inode); | ||
4373 | + int error; | ||
4374 | |||
4375 | /* | ||
4376 | * For unwritten extents we need to issue transactions to convert a | ||
4377 | @@ -210,7 +237,6 @@ xfs_end_io( | ||
4378 | */ | ||
4379 | if (ioend->io_type == IOMAP_UNWRITTEN && | ||
4380 | likely(!ioend->io_error && !XFS_FORCED_SHUTDOWN(ip->i_mount))) { | ||
4381 | - int error; | ||
4382 | |||
4383 | error = xfs_iomap_write_unwritten(ip, ioend->io_offset, | ||
4384 | ioend->io_size); | ||
4385 | @@ -222,30 +248,23 @@ xfs_end_io( | ||
4386 | * We might have to update the on-disk file size after extending | ||
4387 | * writes. | ||
4388 | */ | ||
4389 | - if (ioend->io_type != IOMAP_READ) | ||
4390 | - xfs_setfilesize(ioend); | ||
4391 | - xfs_destroy_ioend(ioend); | ||
4392 | -} | ||
4393 | - | ||
4394 | -/* | ||
4395 | - * Schedule IO completion handling on a xfsdatad if this was | ||
4396 | - * the final hold on this ioend. If we are asked to wait, | ||
4397 | - * flush the workqueue. | ||
4398 | - */ | ||
4399 | -STATIC void | ||
4400 | -xfs_finish_ioend( | ||
4401 | - xfs_ioend_t *ioend, | ||
4402 | - int wait) | ||
4403 | -{ | ||
4404 | - if (atomic_dec_and_test(&ioend->io_remaining)) { | ||
4405 | - struct workqueue_struct *wq; | ||
4406 | - | ||
4407 | - wq = (ioend->io_type == IOMAP_UNWRITTEN) ? | ||
4408 | - xfsconvertd_workqueue : xfsdatad_workqueue; | ||
4409 | - queue_work(wq, &ioend->io_work); | ||
4410 | - if (wait) | ||
4411 | - flush_workqueue(wq); | ||
4412 | + if (ioend->io_type != IOMAP_READ) { | ||
4413 | + error = xfs_setfilesize(ioend); | ||
4414 | + ASSERT(!error || error == EAGAIN); | ||
4415 | } | ||
4416 | + | ||
4417 | + /* | ||
4418 | + * If we didn't complete processing of the ioend, requeue it to the | ||
4419 | + * tail of the workqueue for another attempt later. Otherwise destroy | ||
4420 | + * it. | ||
4421 | + */ | ||
4422 | + if (error == EAGAIN) { | ||
4423 | + atomic_inc(&ioend->io_remaining); | ||
4424 | + xfs_finish_ioend(ioend, 0); | ||
4425 | + /* ensure we don't spin on blocked ioends */ | ||
4426 | + delay(1); | ||
4427 | + } else | ||
4428 | + xfs_destroy_ioend(ioend); | ||
4429 | } | ||
4430 | |||
4431 | /* | ||
4432 | diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c | ||
4433 | index 1f5e4bb..6b6b394 100644 | ||
4434 | --- a/fs/xfs/linux-2.6/xfs_sync.c | ||
4435 | +++ b/fs/xfs/linux-2.6/xfs_sync.c | ||
4436 | @@ -613,7 +613,8 @@ xfssyncd( | ||
4437 | set_freezable(); | ||
4438 | timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10); | ||
4439 | for (;;) { | ||
4440 | - timeleft = schedule_timeout_interruptible(timeleft); | ||
4441 | + if (list_empty(&mp->m_sync_list)) | ||
4442 | + timeleft = schedule_timeout_interruptible(timeleft); | ||
4443 | /* swsusp */ | ||
4444 | try_to_freeze(); | ||
4445 | if (kthread_should_stop() && list_empty(&mp->m_sync_list)) | ||
4446 | @@ -633,8 +634,7 @@ xfssyncd( | ||
4447 | list_add_tail(&mp->m_sync_work.w_list, | ||
4448 | &mp->m_sync_list); | ||
4449 | } | ||
4450 | - list_for_each_entry_safe(work, n, &mp->m_sync_list, w_list) | ||
4451 | - list_move(&work->w_list, &tmp); | ||
4452 | + list_splice_init(&mp->m_sync_list, &tmp); | ||
4453 | spin_unlock(&mp->m_sync_lock); | ||
4454 | |||
4455 | list_for_each_entry_safe(work, n, &tmp, w_list) { | ||
4456 | @@ -693,12 +693,12 @@ xfs_inode_set_reclaim_tag( | ||
4457 | xfs_mount_t *mp = ip->i_mount; | ||
4458 | xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino); | ||
4459 | |||
4460 | - read_lock(&pag->pag_ici_lock); | ||
4461 | + write_lock(&pag->pag_ici_lock); | ||
4462 | spin_lock(&ip->i_flags_lock); | ||
4463 | __xfs_inode_set_reclaim_tag(pag, ip); | ||
4464 | __xfs_iflags_set(ip, XFS_IRECLAIMABLE); | ||
4465 | spin_unlock(&ip->i_flags_lock); | ||
4466 | - read_unlock(&pag->pag_ici_lock); | ||
4467 | + write_unlock(&pag->pag_ici_lock); | ||
4468 | xfs_put_perag(mp, pag); | ||
4469 | } | ||
4470 | |||
4471 | diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c | ||
4472 | index 155e798..fd21160 100644 | ||
4473 | --- a/fs/xfs/xfs_iget.c | ||
4474 | +++ b/fs/xfs/xfs_iget.c | ||
4475 | @@ -190,13 +190,12 @@ xfs_iget_cache_hit( | ||
4476 | trace_xfs_iget_reclaim(ip); | ||
4477 | |||
4478 | /* | ||
4479 | - * We need to set XFS_INEW atomically with clearing the | ||
4480 | - * reclaimable tag so that we do have an indicator of the | ||
4481 | - * inode still being initialized. | ||
4482 | + * We need to set XFS_IRECLAIM to prevent xfs_reclaim_inode | ||
4483 | + * from stomping over us while we recycle the inode. We can't | ||
4484 | + * clear the radix tree reclaimable tag yet as it requires | ||
4485 | + * pag_ici_lock to be held exclusive. | ||
4486 | */ | ||
4487 | - ip->i_flags |= XFS_INEW; | ||
4488 | - ip->i_flags &= ~XFS_IRECLAIMABLE; | ||
4489 | - __xfs_inode_clear_reclaim_tag(mp, pag, ip); | ||
4490 | + ip->i_flags |= XFS_IRECLAIM; | ||
4491 | |||
4492 | spin_unlock(&ip->i_flags_lock); | ||
4493 | read_unlock(&pag->pag_ici_lock); | ||
4494 | @@ -216,7 +215,15 @@ xfs_iget_cache_hit( | ||
4495 | trace_xfs_iget_reclaim(ip); | ||
4496 | goto out_error; | ||
4497 | } | ||
4498 | + | ||
4499 | + write_lock(&pag->pag_ici_lock); | ||
4500 | + spin_lock(&ip->i_flags_lock); | ||
4501 | + ip->i_flags &= ~(XFS_IRECLAIMABLE | XFS_IRECLAIM); | ||
4502 | + ip->i_flags |= XFS_INEW; | ||
4503 | + __xfs_inode_clear_reclaim_tag(mp, pag, ip); | ||
4504 | inode->i_state = I_NEW; | ||
4505 | + spin_unlock(&ip->i_flags_lock); | ||
4506 | + write_unlock(&pag->pag_ici_lock); | ||
4507 | } else { | ||
4508 | /* If the VFS inode is being torn down, pause and try again. */ | ||
4509 | if (!igrab(inode)) { | ||
4510 | diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h | ||
4511 | index e6f3b12..0cbdccc 100644 | ||
4512 | --- a/include/drm/drm_pciids.h | ||
4513 | +++ b/include/drm/drm_pciids.h | ||
4514 | @@ -6,6 +6,7 @@ | ||
4515 | {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | ||
4516 | {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | ||
4517 | {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | ||
4518 | + {0x1002, 0x3155, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | ||
4519 | {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | ||
4520 | {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | ||
4521 | {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP}, \ | ||
4522 | @@ -375,6 +376,7 @@ | ||
4523 | {0x1002, 0x9712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ | ||
4524 | {0x1002, 0x9713, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ | ||
4525 | {0x1002, 0x9714, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ | ||
4526 | + {0x1002, 0x9715, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ | ||
4527 | {0, 0, 0} | ||
4528 | |||
4529 | #define r128_PCI_IDS \ | ||
4530 | diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h | ||
4531 | index aa95508..2c445e1 100644 | ||
4532 | --- a/include/linux/dm-ioctl.h | ||
4533 | +++ b/include/linux/dm-ioctl.h | ||
4534 | @@ -266,9 +266,9 @@ enum { | ||
4535 | #define DM_DEV_SET_GEOMETRY _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl) | ||
4536 | |||
4537 | #define DM_VERSION_MAJOR 4 | ||
4538 | -#define DM_VERSION_MINOR 16 | ||
4539 | +#define DM_VERSION_MINOR 17 | ||
4540 | #define DM_VERSION_PATCHLEVEL 0 | ||
4541 | -#define DM_VERSION_EXTRA "-ioctl (2009-11-05)" | ||
4542 | +#define DM_VERSION_EXTRA "-ioctl (2010-03-05)" | ||
4543 | |||
4544 | /* Status bits */ | ||
4545 | #define DM_READONLY_FLAG (1 << 0) /* In/Out */ | ||
4546 | @@ -316,4 +316,9 @@ enum { | ||
4547 | */ | ||
4548 | #define DM_QUERY_INACTIVE_TABLE_FLAG (1 << 12) /* In */ | ||
4549 | |||
4550 | +/* | ||
4551 | + * If set, a uevent was generated for which the caller may need to wait. | ||
4552 | + */ | ||
4553 | +#define DM_UEVENT_GENERATED_FLAG (1 << 13) /* Out */ | ||
4554 | + | ||
4555 | #endif /* _LINUX_DM_IOCTL_H */ | ||
4556 | diff --git a/include/linux/freezer.h b/include/linux/freezer.h | ||
4557 | index 5a361f8..da7e52b 100644 | ||
4558 | --- a/include/linux/freezer.h | ||
4559 | +++ b/include/linux/freezer.h | ||
4560 | @@ -64,9 +64,12 @@ extern bool freeze_task(struct task_struct *p, bool sig_only); | ||
4561 | extern void cancel_freezing(struct task_struct *p); | ||
4562 | |||
4563 | #ifdef CONFIG_CGROUP_FREEZER | ||
4564 | -extern int cgroup_frozen(struct task_struct *task); | ||
4565 | +extern int cgroup_freezing_or_frozen(struct task_struct *task); | ||
4566 | #else /* !CONFIG_CGROUP_FREEZER */ | ||
4567 | -static inline int cgroup_frozen(struct task_struct *task) { return 0; } | ||
4568 | +static inline int cgroup_freezing_or_frozen(struct task_struct *task) | ||
4569 | +{ | ||
4570 | + return 0; | ||
4571 | +} | ||
4572 | #endif /* !CONFIG_CGROUP_FREEZER */ | ||
4573 | |||
4574 | /* | ||
4575 | diff --git a/include/linux/fs.h b/include/linux/fs.h | ||
4576 | index f2f68ce..66b0705 100644 | ||
4577 | --- a/include/linux/fs.h | ||
4578 | +++ b/include/linux/fs.h | ||
4579 | @@ -2214,6 +2214,7 @@ extern int generic_segment_checks(const struct iovec *iov, | ||
4580 | /* fs/block_dev.c */ | ||
4581 | extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov, | ||
4582 | unsigned long nr_segs, loff_t pos); | ||
4583 | +extern int block_fsync(struct file *filp, struct dentry *dentry, int datasync); | ||
4584 | |||
4585 | /* fs/splice.c */ | ||
4586 | extern ssize_t generic_file_splice_read(struct file *, loff_t *, | ||
4587 | diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h | ||
4588 | index ece0b1c..e117b1a 100644 | ||
4589 | --- a/include/linux/kfifo.h | ||
4590 | +++ b/include/linux/kfifo.h | ||
4591 | @@ -86,7 +86,8 @@ union { \ | ||
4592 | */ | ||
4593 | #define INIT_KFIFO(name) \ | ||
4594 | name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \ | ||
4595 | - sizeof(struct kfifo), name##kfifo_buffer) | ||
4596 | + sizeof(struct kfifo), \ | ||
4597 | + name##kfifo_buffer + sizeof(struct kfifo)) | ||
4598 | |||
4599 | /** | ||
4600 | * DEFINE_KFIFO - macro to define and initialize a kfifo | ||
4601 | diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h | ||
4602 | index bd5a616..1fe293e 100644 | ||
4603 | --- a/include/linux/kvm_host.h | ||
4604 | +++ b/include/linux/kvm_host.h | ||
4605 | @@ -53,7 +53,7 @@ extern struct kmem_cache *kvm_vcpu_cache; | ||
4606 | */ | ||
4607 | struct kvm_io_bus { | ||
4608 | int dev_count; | ||
4609 | -#define NR_IOBUS_DEVS 6 | ||
4610 | +#define NR_IOBUS_DEVS 200 | ||
4611 | struct kvm_io_device *devs[NR_IOBUS_DEVS]; | ||
4612 | }; | ||
4613 | |||
4614 | @@ -116,6 +116,11 @@ struct kvm_memory_slot { | ||
4615 | int user_alloc; | ||
4616 | }; | ||
4617 | |||
4618 | +static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot) | ||
4619 | +{ | ||
4620 | + return ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
4621 | +} | ||
4622 | + | ||
4623 | struct kvm_kernel_irq_routing_entry { | ||
4624 | u32 gsi; | ||
4625 | u32 type; | ||
4626 | diff --git a/include/linux/module.h b/include/linux/module.h | ||
4627 | index 6cb1a3c..bd465d4 100644 | ||
4628 | --- a/include/linux/module.h | ||
4629 | +++ b/include/linux/module.h | ||
4630 | @@ -457,7 +457,7 @@ void symbol_put_addr(void *addr); | ||
4631 | static inline local_t *__module_ref_addr(struct module *mod, int cpu) | ||
4632 | { | ||
4633 | #ifdef CONFIG_SMP | ||
4634 | - return (local_t *) (mod->refptr + per_cpu_offset(cpu)); | ||
4635 | + return (local_t *) per_cpu_ptr(mod->refptr, cpu); | ||
4636 | #else | ||
4637 | return &mod->ref; | ||
4638 | #endif | ||
4639 | diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h | ||
4640 | index 34fc6be..ebc4809 100644 | ||
4641 | --- a/include/linux/nfs_fs_sb.h | ||
4642 | +++ b/include/linux/nfs_fs_sb.h | ||
4643 | @@ -176,6 +176,7 @@ struct nfs_server { | ||
4644 | #define NFS_CAP_ATIME (1U << 11) | ||
4645 | #define NFS_CAP_CTIME (1U << 12) | ||
4646 | #define NFS_CAP_MTIME (1U << 13) | ||
4647 | +#define NFS_CAP_POSIX_LOCK (1U << 14) | ||
4648 | |||
4649 | |||
4650 | /* maximum number of slots to use */ | ||
4651 | diff --git a/include/linux/pci.h b/include/linux/pci.h | ||
4652 | index c1968f4..0afb527 100644 | ||
4653 | --- a/include/linux/pci.h | ||
4654 | +++ b/include/linux/pci.h | ||
4655 | @@ -959,6 +959,11 @@ static inline int pci_proc_domain(struct pci_bus *bus) | ||
4656 | } | ||
4657 | #endif /* CONFIG_PCI_DOMAINS */ | ||
4658 | |||
4659 | +/* some architectures require additional setup to direct VGA traffic */ | ||
4660 | +typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode, | ||
4661 | + unsigned int command_bits, bool change_bridge); | ||
4662 | +extern void pci_register_set_vga_state(arch_set_vga_state_t func); | ||
4663 | + | ||
4664 | #else /* CONFIG_PCI is not enabled */ | ||
4665 | |||
4666 | /* | ||
4667 | diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h | ||
4668 | index cca8a04..0be8243 100644 | ||
4669 | --- a/include/linux/pci_ids.h | ||
4670 | +++ b/include/linux/pci_ids.h | ||
4671 | @@ -2417,6 +2417,9 @@ | ||
4672 | #define PCI_DEVICE_ID_INTEL_82840_HB 0x1a21 | ||
4673 | #define PCI_DEVICE_ID_INTEL_82845_HB 0x1a30 | ||
4674 | #define PCI_DEVICE_ID_INTEL_IOAT 0x1a38 | ||
4675 | +#define PCI_DEVICE_ID_INTEL_CPT_SMBUS 0x1c22 | ||
4676 | +#define PCI_DEVICE_ID_INTEL_CPT_LPC1 0x1c42 | ||
4677 | +#define PCI_DEVICE_ID_INTEL_CPT_LPC2 0x1c43 | ||
4678 | #define PCI_DEVICE_ID_INTEL_82801AA_0 0x2410 | ||
4679 | #define PCI_DEVICE_ID_INTEL_82801AA_1 0x2411 | ||
4680 | #define PCI_DEVICE_ID_INTEL_82801AA_3 0x2413 | ||
4681 | diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c | ||
4682 | index 59e9ef6..eb3f34d 100644 | ||
4683 | --- a/kernel/cgroup_freezer.c | ||
4684 | +++ b/kernel/cgroup_freezer.c | ||
4685 | @@ -47,17 +47,20 @@ static inline struct freezer *task_freezer(struct task_struct *task) | ||
4686 | struct freezer, css); | ||
4687 | } | ||
4688 | |||
4689 | -int cgroup_frozen(struct task_struct *task) | ||
4690 | +int cgroup_freezing_or_frozen(struct task_struct *task) | ||
4691 | { | ||
4692 | struct freezer *freezer; | ||
4693 | enum freezer_state state; | ||
4694 | |||
4695 | task_lock(task); | ||
4696 | freezer = task_freezer(task); | ||
4697 | - state = freezer->state; | ||
4698 | + if (!freezer->css.cgroup->parent) | ||
4699 | + state = CGROUP_THAWED; /* root cgroup can't be frozen */ | ||
4700 | + else | ||
4701 | + state = freezer->state; | ||
4702 | task_unlock(task); | ||
4703 | |||
4704 | - return state == CGROUP_FROZEN; | ||
4705 | + return (state == CGROUP_FREEZING) || (state == CGROUP_FROZEN); | ||
4706 | } | ||
4707 | |||
4708 | /* | ||
4709 | diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c | ||
4710 | index 69a3d7b..0b23ff7 100644 | ||
4711 | --- a/kernel/irq/manage.c | ||
4712 | +++ b/kernel/irq/manage.c | ||
4713 | @@ -753,6 +753,16 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new) | ||
4714 | if (new->flags & IRQF_ONESHOT) | ||
4715 | desc->status |= IRQ_ONESHOT; | ||
4716 | |||
4717 | + /* | ||
4718 | + * Force MSI interrupts to run with interrupts | ||
4719 | + * disabled. The multi vector cards can cause stack | ||
4720 | + * overflows due to nested interrupts when enough of | ||
4721 | + * them are directed to a core and fire at the same | ||
4722 | + * time. | ||
4723 | + */ | ||
4724 | + if (desc->msi_desc) | ||
4725 | + new->flags |= IRQF_DISABLED; | ||
4726 | + | ||
4727 | if (!(desc->status & IRQ_NOAUTOEN)) { | ||
4728 | desc->depth = 0; | ||
4729 | desc->status &= ~IRQ_DISABLED; | ||
4730 | diff --git a/kernel/lockdep.c b/kernel/lockdep.c | ||
4731 | index c62ec14..493a0ef 100644 | ||
4732 | --- a/kernel/lockdep.c | ||
4733 | +++ b/kernel/lockdep.c | ||
4734 | @@ -600,9 +600,9 @@ static int static_obj(void *obj) | ||
4735 | * percpu var? | ||
4736 | */ | ||
4737 | for_each_possible_cpu(i) { | ||
4738 | - start = (unsigned long) &__per_cpu_start + per_cpu_offset(i); | ||
4739 | - end = (unsigned long) &__per_cpu_start + PERCPU_ENOUGH_ROOM | ||
4740 | - + per_cpu_offset(i); | ||
4741 | + start = (unsigned long) per_cpu_ptr(&__per_cpu_start, i); | ||
4742 | + end = (unsigned long) per_cpu_ptr(&__per_cpu_start, i) | ||
4743 | + + PERCPU_ENOUGH_ROOM; | ||
4744 | |||
4745 | if ((addr >= start) && (addr < end)) | ||
4746 | return 1; | ||
4747 | diff --git a/kernel/module.c b/kernel/module.c | ||
4748 | index f82386b..5b6ce39 100644 | ||
4749 | --- a/kernel/module.c | ||
4750 | +++ b/kernel/module.c | ||
4751 | @@ -405,7 +405,7 @@ static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size) | ||
4752 | int cpu; | ||
4753 | |||
4754 | for_each_possible_cpu(cpu) | ||
4755 | - memcpy(pcpudest + per_cpu_offset(cpu), from, size); | ||
4756 | + memcpy(per_cpu_ptr(pcpudest, cpu), from, size); | ||
4757 | } | ||
4758 | |||
4759 | #else /* ... !CONFIG_SMP */ | ||
4760 | diff --git a/kernel/power/process.c b/kernel/power/process.c | ||
4761 | index 5ade1bd..de53015 100644 | ||
4762 | --- a/kernel/power/process.c | ||
4763 | +++ b/kernel/power/process.c | ||
4764 | @@ -145,7 +145,7 @@ static void thaw_tasks(bool nosig_only) | ||
4765 | if (nosig_only && should_send_signal(p)) | ||
4766 | continue; | ||
4767 | |||
4768 | - if (cgroup_frozen(p)) | ||
4769 | + if (cgroup_freezing_or_frozen(p)) | ||
4770 | continue; | ||
4771 | |||
4772 | thaw_process(p); | ||
4773 | diff --git a/kernel/sched.c b/kernel/sched.c | ||
4774 | index 7ca9345..da19c1e 100644 | ||
4775 | --- a/kernel/sched.c | ||
4776 | +++ b/kernel/sched.c | ||
4777 | @@ -6717,7 +6717,9 @@ SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len, | ||
4778 | int ret; | ||
4779 | cpumask_var_t mask; | ||
4780 | |||
4781 | - if (len < cpumask_size()) | ||
4782 | + if ((len * BITS_PER_BYTE) < nr_cpu_ids) | ||
4783 | + return -EINVAL; | ||
4784 | + if (len & (sizeof(unsigned long)-1)) | ||
4785 | return -EINVAL; | ||
4786 | |||
4787 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) | ||
4788 | @@ -6725,10 +6727,12 @@ SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len, | ||
4789 | |||
4790 | ret = sched_getaffinity(pid, mask); | ||
4791 | if (ret == 0) { | ||
4792 | - if (copy_to_user(user_mask_ptr, mask, cpumask_size())) | ||
4793 | + size_t retlen = min_t(size_t, len, cpumask_size()); | ||
4794 | + | ||
4795 | + if (copy_to_user(user_mask_ptr, mask, retlen)) | ||
4796 | ret = -EFAULT; | ||
4797 | else | ||
4798 | - ret = cpumask_size(); | ||
4799 | + ret = retlen; | ||
4800 | } | ||
4801 | free_cpumask_var(mask); | ||
4802 | |||
4803 | diff --git a/mm/readahead.c b/mm/readahead.c | ||
4804 | index 337b20e..fe1a069 100644 | ||
4805 | --- a/mm/readahead.c | ||
4806 | +++ b/mm/readahead.c | ||
4807 | @@ -502,7 +502,7 @@ void page_cache_sync_readahead(struct address_space *mapping, | ||
4808 | return; | ||
4809 | |||
4810 | /* be dumb */ | ||
4811 | - if (filp->f_mode & FMODE_RANDOM) { | ||
4812 | + if (filp && (filp->f_mode & FMODE_RANDOM)) { | ||
4813 | force_page_cache_readahead(mapping, filp, offset, req_size); | ||
4814 | return; | ||
4815 | } | ||
4816 | diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c | ||
4817 | index 6a43314..ba1fadb 100644 | ||
4818 | --- a/net/mac80211/mesh.c | ||
4819 | +++ b/net/mac80211/mesh.c | ||
4820 | @@ -749,9 +749,6 @@ ieee80211_mesh_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb) | ||
4821 | |||
4822 | switch (fc & IEEE80211_FCTL_STYPE) { | ||
4823 | case IEEE80211_STYPE_ACTION: | ||
4824 | - if (skb->len < IEEE80211_MIN_ACTION_SIZE) | ||
4825 | - return RX_DROP_MONITOR; | ||
4826 | - /* fall through */ | ||
4827 | case IEEE80211_STYPE_PROBE_RESP: | ||
4828 | case IEEE80211_STYPE_BEACON: | ||
4829 | skb_queue_tail(&ifmsh->skb_queue, skb); | ||
4830 | diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c | ||
4831 | index d28acb6..4eed81b 100644 | ||
4832 | --- a/net/mac80211/mesh_hwmp.c | ||
4833 | +++ b/net/mac80211/mesh_hwmp.c | ||
4834 | @@ -391,7 +391,7 @@ static u32 hwmp_route_info_get(struct ieee80211_sub_if_data *sdata, | ||
4835 | if (SN_GT(mpath->sn, orig_sn) || | ||
4836 | (mpath->sn == orig_sn && | ||
4837 | action == MPATH_PREQ && | ||
4838 | - new_metric > mpath->metric)) { | ||
4839 | + new_metric >= mpath->metric)) { | ||
4840 | process = false; | ||
4841 | fresh_info = false; | ||
4842 | } | ||
4843 | @@ -611,7 +611,7 @@ static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata, | ||
4844 | |||
4845 | mesh_path_sel_frame_tx(MPATH_PREP, flags, orig_addr, | ||
4846 | cpu_to_le32(orig_sn), 0, target_addr, | ||
4847 | - cpu_to_le32(target_sn), mpath->next_hop->sta.addr, hopcount, | ||
4848 | + cpu_to_le32(target_sn), next_hop, hopcount, | ||
4849 | ttl, cpu_to_le32(lifetime), cpu_to_le32(metric), | ||
4850 | 0, sdata); | ||
4851 | rcu_read_unlock(); | ||
4852 | diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c | ||
4853 | index da92cde..edfa036 100644 | ||
4854 | --- a/net/mac80211/rx.c | ||
4855 | +++ b/net/mac80211/rx.c | ||
4856 | @@ -2355,6 +2355,11 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata, | ||
4857 | /* should never get here */ | ||
4858 | WARN_ON(1); | ||
4859 | break; | ||
4860 | + case MESH_PLINK_CATEGORY: | ||
4861 | + case MESH_PATH_SEL_CATEGORY: | ||
4862 | + if (ieee80211_vif_is_mesh(&sdata->vif)) | ||
4863 | + return ieee80211_mesh_rx_mgmt(sdata, rx->skb); | ||
4864 | + break; | ||
4865 | } | ||
4866 | |||
4867 | return 1; | ||
4868 | diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c | ||
4869 | index 70c79c3..1fdc0a5 100644 | ||
4870 | --- a/net/mac80211/tx.c | ||
4871 | +++ b/net/mac80211/tx.c | ||
4872 | @@ -1945,6 +1945,7 @@ static bool ieee80211_tx_pending_skb(struct ieee80211_local *local, | ||
4873 | void ieee80211_tx_pending(unsigned long data) | ||
4874 | { | ||
4875 | struct ieee80211_local *local = (struct ieee80211_local *)data; | ||
4876 | + struct ieee80211_sub_if_data *sdata; | ||
4877 | unsigned long flags; | ||
4878 | int i; | ||
4879 | bool txok; | ||
4880 | @@ -1983,6 +1984,11 @@ void ieee80211_tx_pending(unsigned long data) | ||
4881 | if (!txok) | ||
4882 | break; | ||
4883 | } | ||
4884 | + | ||
4885 | + if (skb_queue_empty(&local->pending[i])) | ||
4886 | + list_for_each_entry_rcu(sdata, &local->interfaces, list) | ||
4887 | + netif_tx_wake_queue( | ||
4888 | + netdev_get_tx_queue(sdata->dev, i)); | ||
4889 | } | ||
4890 | spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); | ||
4891 | |||
4892 | diff --git a/net/mac80211/util.c b/net/mac80211/util.c | ||
4893 | index 3848140..27212e8 100644 | ||
4894 | --- a/net/mac80211/util.c | ||
4895 | +++ b/net/mac80211/util.c | ||
4896 | @@ -280,13 +280,13 @@ static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue, | ||
4897 | /* someone still has this queue stopped */ | ||
4898 | return; | ||
4899 | |||
4900 | - if (!skb_queue_empty(&local->pending[queue])) | ||
4901 | + if (skb_queue_empty(&local->pending[queue])) { | ||
4902 | + rcu_read_lock(); | ||
4903 | + list_for_each_entry_rcu(sdata, &local->interfaces, list) | ||
4904 | + netif_tx_wake_queue(netdev_get_tx_queue(sdata->dev, queue)); | ||
4905 | + rcu_read_unlock(); | ||
4906 | + } else | ||
4907 | tasklet_schedule(&local->tx_pending_tasklet); | ||
4908 | - | ||
4909 | - rcu_read_lock(); | ||
4910 | - list_for_each_entry_rcu(sdata, &local->interfaces, list) | ||
4911 | - netif_tx_wake_queue(netdev_get_tx_queue(sdata->dev, queue)); | ||
4912 | - rcu_read_unlock(); | ||
4913 | } | ||
4914 | |||
4915 | void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, | ||
4916 | @@ -1145,6 +1145,14 @@ int ieee80211_reconfig(struct ieee80211_local *local) | ||
4917 | } | ||
4918 | } | ||
4919 | |||
4920 | + rcu_read_lock(); | ||
4921 | + if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) { | ||
4922 | + list_for_each_entry_rcu(sta, &local->sta_list, list) { | ||
4923 | + ieee80211_sta_tear_down_BA_sessions(sta); | ||
4924 | + } | ||
4925 | + } | ||
4926 | + rcu_read_unlock(); | ||
4927 | + | ||
4928 | /* add back keys */ | ||
4929 | list_for_each_entry(sdata, &local->interfaces, list) | ||
4930 | if (netif_running(sdata->dev)) | ||
4931 | diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c | ||
4932 | index 9ace8eb..062a8b0 100644 | ||
4933 | --- a/sound/pci/hda/hda_intel.c | ||
4934 | +++ b/sound/pci/hda/hda_intel.c | ||
4935 | @@ -125,6 +125,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6}," | ||
4936 | "{Intel, ICH9}," | ||
4937 | "{Intel, ICH10}," | ||
4938 | "{Intel, PCH}," | ||
4939 | + "{Intel, CPT}," | ||
4940 | "{Intel, SCH}," | ||
4941 | "{ATI, SB450}," | ||
4942 | "{ATI, SB600}," | ||
4943 | @@ -449,6 +450,7 @@ struct azx { | ||
4944 | /* driver types */ | ||
4945 | enum { | ||
4946 | AZX_DRIVER_ICH, | ||
4947 | + AZX_DRIVER_PCH, | ||
4948 | AZX_DRIVER_SCH, | ||
4949 | AZX_DRIVER_ATI, | ||
4950 | AZX_DRIVER_ATIHDMI, | ||
4951 | @@ -463,6 +465,7 @@ enum { | ||
4952 | |||
4953 | static char *driver_short_names[] __devinitdata = { | ||
4954 | [AZX_DRIVER_ICH] = "HDA Intel", | ||
4955 | + [AZX_DRIVER_PCH] = "HDA Intel PCH", | ||
4956 | [AZX_DRIVER_SCH] = "HDA Intel MID", | ||
4957 | [AZX_DRIVER_ATI] = "HDA ATI SB", | ||
4958 | [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI", | ||
4959 | @@ -1065,6 +1068,7 @@ static void azx_init_pci(struct azx *chip) | ||
4960 | 0x01, NVIDIA_HDA_ENABLE_COHBIT); | ||
4961 | break; | ||
4962 | case AZX_DRIVER_SCH: | ||
4963 | + case AZX_DRIVER_PCH: | ||
4964 | pci_read_config_word(chip->pci, INTEL_SCH_HDA_DEVC, &snoop); | ||
4965 | if (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) { | ||
4966 | pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC, | ||
4967 | @@ -2268,6 +2272,7 @@ static struct snd_pci_quirk position_fix_list[] __devinitdata = { | ||
4968 | SND_PCI_QUIRK(0x1458, 0xa022, "ga-ma770-ud3", POS_FIX_LPIB), | ||
4969 | SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB), | ||
4970 | SND_PCI_QUIRK(0x1565, 0x820f, "Biostar Microtech", POS_FIX_LPIB), | ||
4971 | + SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB), | ||
4972 | SND_PCI_QUIRK(0x8086, 0xd601, "eMachines T5212", POS_FIX_LPIB), | ||
4973 | {} | ||
4974 | }; | ||
4975 | @@ -2357,6 +2362,8 @@ static struct snd_pci_quirk msi_black_list[] __devinitdata = { | ||
4976 | SND_PCI_QUIRK(0x1043, 0x81f2, "ASUS", 0), /* Athlon64 X2 + nvidia */ | ||
4977 | SND_PCI_QUIRK(0x1043, 0x81f6, "ASUS", 0), /* nvidia */ | ||
4978 | SND_PCI_QUIRK(0x1043, 0x822d, "ASUS", 0), /* Athlon64 X2 + nvidia MCP55 */ | ||
4979 | + SND_PCI_QUIRK(0x1849, 0x0888, "ASRock", 0), /* Athlon64 X2 + nvidia */ | ||
4980 | + SND_PCI_QUIRK(0xa0a0, 0x0575, "Aopen MZ915-M", 0), /* ICH6 */ | ||
4981 | {} | ||
4982 | }; | ||
4983 | |||
4984 | @@ -2431,6 +2438,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci, | ||
4985 | if (bdl_pos_adj[dev] < 0) { | ||
4986 | switch (chip->driver_type) { | ||
4987 | case AZX_DRIVER_ICH: | ||
4988 | + case AZX_DRIVER_PCH: | ||
4989 | bdl_pos_adj[dev] = 1; | ||
4990 | break; | ||
4991 | default: | ||
4992 | @@ -2709,6 +2717,8 @@ static struct pci_device_id azx_ids[] = { | ||
4993 | { PCI_DEVICE(0x8086, 0x3a6e), .driver_data = AZX_DRIVER_ICH }, | ||
4994 | /* PCH */ | ||
4995 | { PCI_DEVICE(0x8086, 0x3b56), .driver_data = AZX_DRIVER_ICH }, | ||
4996 | + /* CPT */ | ||
4997 | + { PCI_DEVICE(0x8086, 0x1c20), .driver_data = AZX_DRIVER_PCH }, | ||
4998 | /* SCH */ | ||
4999 | { PCI_DEVICE(0x8086, 0x811b), .driver_data = AZX_DRIVER_SCH }, | ||
5000 | /* ATI SB 450/600 */ | ||
5001 | diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c | ||
5002 | index 7069441..263bf3b 100644 | ||
5003 | --- a/sound/pci/hda/patch_analog.c | ||
5004 | +++ b/sound/pci/hda/patch_analog.c | ||
5005 | @@ -1805,6 +1805,14 @@ static int patch_ad1981(struct hda_codec *codec) | ||
5006 | case AD1981_THINKPAD: | ||
5007 | spec->mixers[0] = ad1981_thinkpad_mixers; | ||
5008 | spec->input_mux = &ad1981_thinkpad_capture_source; | ||
5009 | + /* set the upper-limit for mixer amp to 0dB for avoiding the | ||
5010 | + * possible damage by overloading | ||
5011 | + */ | ||
5012 | + snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT, | ||
5013 | + (0x17 << AC_AMPCAP_OFFSET_SHIFT) | | ||
5014 | + (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | | ||
5015 | + (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | | ||
5016 | + (1 << AC_AMPCAP_MUTE_SHIFT)); | ||
5017 | break; | ||
5018 | case AD1981_TOSHIBA: | ||
5019 | spec->mixers[0] = ad1981_hp_mixers; | ||
5020 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
5021 | index a79f841..bd8a567 100644 | ||
5022 | --- a/sound/pci/hda/patch_realtek.c | ||
5023 | +++ b/sound/pci/hda/patch_realtek.c | ||
5024 | @@ -9074,6 +9074,7 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = { | ||
5025 | SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG), | ||
5026 | |||
5027 | SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), | ||
5028 | + SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG), | ||
5029 | SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), | ||
5030 | SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), | ||
5031 | SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R), | ||
5032 | diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c | ||
5033 | index a83d196..32f9853 100644 | ||
5034 | --- a/sound/pci/mixart/mixart.c | ||
5035 | +++ b/sound/pci/mixart/mixart.c | ||
5036 | @@ -1161,13 +1161,15 @@ static long snd_mixart_BA0_read(struct snd_info_entry *entry, void *file_private | ||
5037 | unsigned long count, unsigned long pos) | ||
5038 | { | ||
5039 | struct mixart_mgr *mgr = entry->private_data; | ||
5040 | + unsigned long maxsize; | ||
5041 | |||
5042 | - count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ | ||
5043 | - if(count <= 0) | ||
5044 | + if (pos >= MIXART_BA0_SIZE) | ||
5045 | return 0; | ||
5046 | - if(pos + count > MIXART_BA0_SIZE) | ||
5047 | - count = (long)(MIXART_BA0_SIZE - pos); | ||
5048 | - if(copy_to_user_fromio(buf, MIXART_MEM( mgr, pos ), count)) | ||
5049 | + maxsize = MIXART_BA0_SIZE - pos; | ||
5050 | + if (count > maxsize) | ||
5051 | + count = maxsize; | ||
5052 | + count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ | ||
5053 | + if (copy_to_user_fromio(buf, MIXART_MEM(mgr, pos), count)) | ||
5054 | return -EFAULT; | ||
5055 | return count; | ||
5056 | } | ||
5057 | @@ -1180,13 +1182,15 @@ static long snd_mixart_BA1_read(struct snd_info_entry *entry, void *file_private | ||
5058 | unsigned long count, unsigned long pos) | ||
5059 | { | ||
5060 | struct mixart_mgr *mgr = entry->private_data; | ||
5061 | + unsigned long maxsize; | ||
5062 | |||
5063 | - count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ | ||
5064 | - if(count <= 0) | ||
5065 | + if (pos > MIXART_BA1_SIZE) | ||
5066 | return 0; | ||
5067 | - if(pos + count > MIXART_BA1_SIZE) | ||
5068 | - count = (long)(MIXART_BA1_SIZE - pos); | ||
5069 | - if(copy_to_user_fromio(buf, MIXART_REG( mgr, pos ), count)) | ||
5070 | + maxsize = MIXART_BA1_SIZE - pos; | ||
5071 | + if (count > maxsize) | ||
5072 | + count = maxsize; | ||
5073 | + count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ | ||
5074 | + if (copy_to_user_fromio(buf, MIXART_REG(mgr, pos), count)) | ||
5075 | return -EFAULT; | ||
5076 | return count; | ||
5077 | } | ||
5078 | diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c | ||
5079 | index b2da478..c7cb207 100644 | ||
5080 | --- a/sound/usb/usbmidi.c | ||
5081 | +++ b/sound/usb/usbmidi.c | ||
5082 | @@ -984,6 +984,8 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream) | ||
5083 | DEFINE_WAIT(wait); | ||
5084 | long timeout = msecs_to_jiffies(50); | ||
5085 | |||
5086 | + if (ep->umidi->disconnected) | ||
5087 | + return; | ||
5088 | /* | ||
5089 | * The substream buffer is empty, but some data might still be in the | ||
5090 | * currently active URBs, so we have to wait for those to complete. | ||
5091 | @@ -1121,14 +1123,21 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi, | ||
5092 | * Frees an output endpoint. | ||
5093 | * May be called when ep hasn't been initialized completely. | ||
5094 | */ | ||
5095 | -static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep) | ||
5096 | +static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep) | ||
5097 | { | ||
5098 | unsigned int i; | ||
5099 | |||
5100 | for (i = 0; i < OUTPUT_URBS; ++i) | ||
5101 | - if (ep->urbs[i].urb) | ||
5102 | + if (ep->urbs[i].urb) { | ||
5103 | free_urb_and_buffer(ep->umidi, ep->urbs[i].urb, | ||
5104 | ep->max_transfer); | ||
5105 | + ep->urbs[i].urb = NULL; | ||
5106 | + } | ||
5107 | +} | ||
5108 | + | ||
5109 | +static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep) | ||
5110 | +{ | ||
5111 | + snd_usbmidi_out_endpoint_clear(ep); | ||
5112 | kfree(ep); | ||
5113 | } | ||
5114 | |||
5115 | @@ -1260,15 +1269,18 @@ void snd_usbmidi_disconnect(struct list_head* p) | ||
5116 | usb_kill_urb(ep->out->urbs[j].urb); | ||
5117 | if (umidi->usb_protocol_ops->finish_out_endpoint) | ||
5118 | umidi->usb_protocol_ops->finish_out_endpoint(ep->out); | ||
5119 | + ep->out->active_urbs = 0; | ||
5120 | + if (ep->out->drain_urbs) { | ||
5121 | + ep->out->drain_urbs = 0; | ||
5122 | + wake_up(&ep->out->drain_wait); | ||
5123 | + } | ||
5124 | } | ||
5125 | if (ep->in) | ||
5126 | for (j = 0; j < INPUT_URBS; ++j) | ||
5127 | usb_kill_urb(ep->in->urbs[j]); | ||
5128 | /* free endpoints here; later call can result in Oops */ | ||
5129 | - if (ep->out) { | ||
5130 | - snd_usbmidi_out_endpoint_delete(ep->out); | ||
5131 | - ep->out = NULL; | ||
5132 | - } | ||
5133 | + if (ep->out) | ||
5134 | + snd_usbmidi_out_endpoint_clear(ep->out); | ||
5135 | if (ep->in) { | ||
5136 | snd_usbmidi_in_endpoint_delete(ep->in); | ||
5137 | ep->in = NULL; | ||
5138 | diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c | ||
5139 | index a944be3..9dd98cb 100644 | ||
5140 | --- a/virt/kvm/kvm_main.c | ||
5141 | +++ b/virt/kvm/kvm_main.c | ||
5142 | @@ -636,7 +636,7 @@ skip_lpage: | ||
5143 | |||
5144 | /* Allocate page dirty bitmap if needed */ | ||
5145 | if ((new.flags & KVM_MEM_LOG_DIRTY_PAGES) && !new.dirty_bitmap) { | ||
5146 | - unsigned dirty_bytes = ALIGN(npages, BITS_PER_LONG) / 8; | ||
5147 | + unsigned long dirty_bytes = kvm_dirty_bitmap_bytes(&new); | ||
5148 | |||
5149 | new.dirty_bitmap = vmalloc(dirty_bytes); | ||
5150 | if (!new.dirty_bitmap) | ||
5151 | @@ -719,7 +719,7 @@ int kvm_get_dirty_log(struct kvm *kvm, | ||
5152 | { | ||
5153 | struct kvm_memory_slot *memslot; | ||
5154 | int r, i; | ||
5155 | - int n; | ||
5156 | + unsigned long n; | ||
5157 | unsigned long any = 0; | ||
5158 | |||
5159 | r = -EINVAL; | ||
5160 | @@ -731,7 +731,7 @@ int kvm_get_dirty_log(struct kvm *kvm, | ||
5161 | if (!memslot->dirty_bitmap) | ||
5162 | goto out; | ||
5163 | |||
5164 | - n = ALIGN(memslot->npages, BITS_PER_LONG) / 8; | ||
5165 | + n = kvm_dirty_bitmap_bytes(memslot); | ||
5166 | |||
5167 | for (i = 0; !any && i < n/sizeof(long); ++i) | ||
5168 | any = memslot->dirty_bitmap[i]; | ||
5169 | @@ -1073,10 +1073,13 @@ void mark_page_dirty(struct kvm *kvm, gfn_t gfn) | ||
5170 | memslot = gfn_to_memslot_unaliased(kvm, gfn); | ||
5171 | if (memslot && memslot->dirty_bitmap) { | ||
5172 | unsigned long rel_gfn = gfn - memslot->base_gfn; | ||
5173 | + unsigned long *p = memslot->dirty_bitmap + | ||
5174 | + rel_gfn / BITS_PER_LONG; | ||
5175 | + int offset = rel_gfn % BITS_PER_LONG; | ||
5176 | |||
5177 | /* avoid RMW */ | ||
5178 | - if (!generic_test_le_bit(rel_gfn, memslot->dirty_bitmap)) | ||
5179 | - generic___set_le_bit(rel_gfn, memslot->dirty_bitmap); | ||
5180 | + if (!generic_test_le_bit(offset, p)) | ||
5181 | + generic___set_le_bit(offset, p); | ||
5182 | } | ||
5183 | } | ||
5184 |