Annotation of /trunk/kernel26-alx/patches-2.6.27-r3/0124-2.6.27.25-all-fixes.patch
Parent Directory | Revision Log
Revision 1176 -
(hide annotations)
(download)
Thu Oct 14 15:11:06 2010 UTC (13 years, 11 months ago) by niro
File size: 60933 byte(s)
Thu Oct 14 15:11:06 2010 UTC (13 years, 11 months ago) by niro
File size: 60933 byte(s)
-2.6.27-alx-r3: new magellan 0.5.2 kernel
1 | niro | 1176 | diff --git a/Documentation/filesystems/ext4.txt b/Documentation/filesystems/ext4.txt |
2 | index 0d53949..befe8d4 100644 | ||
3 | --- a/Documentation/filesystems/ext4.txt | ||
4 | +++ b/Documentation/filesystems/ext4.txt | ||
5 | @@ -73,7 +73,7 @@ Mailing list: linux-ext4@vger.kernel.org | ||
6 | * extent format more robust in face of on-disk corruption due to magics, | ||
7 | * internal redunancy in tree | ||
8 | * improved file allocation (multi-block alloc) | ||
9 | -* fix 32000 subdirectory limit | ||
10 | +* lift 32000 subdirectory limit imposed by i_links_count[1] | ||
11 | * nsec timestamps for mtime, atime, ctime, create time | ||
12 | * inode version field on disk (NFSv4, Lustre) | ||
13 | * reduced e2fsck time via uninit_bg feature | ||
14 | @@ -88,6 +88,9 @@ Mailing list: linux-ext4@vger.kernel.org | ||
15 | * efficent new ordered mode in JBD2 and ext4(avoid using buffer head to force | ||
16 | the ordering) | ||
17 | |||
18 | +[1] Filesystems with a block size of 1k may see a limit imposed by the | ||
19 | +directory hash tree having a maximum depth of two. | ||
20 | + | ||
21 | 2.2 Candidate features for future inclusion | ||
22 | |||
23 | * Online defrag (patches available but not well tested) | ||
24 | diff --git a/arch/sparc/include/asm/pil.h b/arch/sparc/include/asm/pil.h | ||
25 | index 71819bb..6ea90d7 100644 | ||
26 | --- a/arch/sparc/include/asm/pil.h | ||
27 | +++ b/arch/sparc/include/asm/pil.h | ||
28 | @@ -18,5 +18,6 @@ | ||
29 | #define PIL_SMP_CTX_NEW_VERSION 4 | ||
30 | #define PIL_DEVICE_IRQ 5 | ||
31 | #define PIL_SMP_CALL_FUNC_SNGL 6 | ||
32 | +#define PIL_KGDB_CAPTURE 8 | ||
33 | |||
34 | #endif /* !(_SPARC64_PIL_H) */ | ||
35 | diff --git a/arch/sparc/include/asm/tlb_64.h b/arch/sparc/include/asm/tlb_64.h | ||
36 | index ec81cde..0aaa086 100644 | ||
37 | --- a/arch/sparc/include/asm/tlb_64.h | ||
38 | +++ b/arch/sparc/include/asm/tlb_64.h | ||
39 | @@ -58,6 +58,8 @@ static inline struct mmu_gather *tlb_gather_mmu(struct mm_struct *mm, unsigned i | ||
40 | static inline void tlb_flush_mmu(struct mmu_gather *mp) | ||
41 | { | ||
42 | if (mp->need_flush) { | ||
43 | + if (!mp->fullmm) | ||
44 | + flush_tlb_pending(); | ||
45 | free_pages_and_swap_cache(mp->pages, mp->pages_nr); | ||
46 | mp->pages_nr = 0; | ||
47 | mp->need_flush = 0; | ||
48 | @@ -78,8 +80,6 @@ static inline void tlb_finish_mmu(struct mmu_gather *mp, unsigned long start, un | ||
49 | |||
50 | if (mp->fullmm) | ||
51 | mp->fullmm = 0; | ||
52 | - else | ||
53 | - flush_tlb_pending(); | ||
54 | |||
55 | /* keep the page table cache within bounds */ | ||
56 | check_pgt_cache(); | ||
57 | diff --git a/arch/sparc/kernel/of_device.c b/arch/sparc/kernel/of_device.c | ||
58 | index f58c537..e0bfc51 100644 | ||
59 | --- a/arch/sparc/kernel/of_device.c | ||
60 | +++ b/arch/sparc/kernel/of_device.c | ||
61 | @@ -223,8 +223,25 @@ static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) | ||
62 | |||
63 | static int of_bus_sbus_match(struct device_node *np) | ||
64 | { | ||
65 | - return !strcmp(np->name, "sbus") || | ||
66 | - !strcmp(np->name, "sbi"); | ||
67 | + struct device_node *dp = np; | ||
68 | + | ||
69 | + while (dp) { | ||
70 | + if (!strcmp(dp->name, "sbus") || | ||
71 | + !strcmp(dp->name, "sbi")) | ||
72 | + return 1; | ||
73 | + | ||
74 | + /* Have a look at use_1to1_mapping(). We're trying | ||
75 | + * to match SBUS if that's the top-level bus and we | ||
76 | + * don't have some intervening real bus that provides | ||
77 | + * ranges based translations. | ||
78 | + */ | ||
79 | + if (of_find_property(dp, "ranges", NULL) != NULL) | ||
80 | + break; | ||
81 | + | ||
82 | + dp = dp->parent; | ||
83 | + } | ||
84 | + | ||
85 | + return 0; | ||
86 | } | ||
87 | |||
88 | static void of_bus_sbus_count_cells(struct device_node *child, | ||
89 | diff --git a/arch/sparc64/kernel/irq.c b/arch/sparc64/kernel/irq.c | ||
90 | index 7495bc7..0708a5b 100644 | ||
91 | --- a/arch/sparc64/kernel/irq.c | ||
92 | +++ b/arch/sparc64/kernel/irq.c | ||
93 | @@ -318,17 +318,25 @@ static void sun4u_set_affinity(unsigned int virt_irq, cpumask_t mask) | ||
94 | sun4u_irq_enable(virt_irq); | ||
95 | } | ||
96 | |||
97 | +/* Don't do anything. The desc->status check for IRQ_DISABLED in | ||
98 | + * handler_irq() will skip the handler call and that will leave the | ||
99 | + * interrupt in the sent state. The next ->enable() call will hit the | ||
100 | + * ICLR register to reset the state machine. | ||
101 | + * | ||
102 | + * This scheme is necessary, instead of clearing the Valid bit in the | ||
103 | + * IMAP register, to handle the case of IMAP registers being shared by | ||
104 | + * multiple INOs (and thus ICLR registers). Since we use a different | ||
105 | + * virtual IRQ for each shared IMAP instance, the generic code thinks | ||
106 | + * there is only one user so it prematurely calls ->disable() on | ||
107 | + * free_irq(). | ||
108 | + * | ||
109 | + * We have to provide an explicit ->disable() method instead of using | ||
110 | + * NULL to get the default. The reason is that if the generic code | ||
111 | + * sees that, it also hooks up a default ->shutdown method which | ||
112 | + * invokes ->mask() which we do not want. See irq_chip_set_defaults(). | ||
113 | + */ | ||
114 | static void sun4u_irq_disable(unsigned int virt_irq) | ||
115 | { | ||
116 | - struct irq_handler_data *data = get_irq_chip_data(virt_irq); | ||
117 | - | ||
118 | - if (likely(data)) { | ||
119 | - unsigned long imap = data->imap; | ||
120 | - unsigned long tmp = upa_readq(imap); | ||
121 | - | ||
122 | - tmp &= ~IMAP_VALID; | ||
123 | - upa_writeq(tmp, imap); | ||
124 | - } | ||
125 | } | ||
126 | |||
127 | static void sun4u_irq_eoi(unsigned int virt_irq) | ||
128 | @@ -739,7 +747,8 @@ void handler_irq(int irq, struct pt_regs *regs) | ||
129 | |||
130 | desc = irq_desc + virt_irq; | ||
131 | |||
132 | - desc->handle_irq(virt_irq, desc); | ||
133 | + if (!(desc->status & IRQ_DISABLED)) | ||
134 | + desc->handle_irq(virt_irq, desc); | ||
135 | |||
136 | bucket_pa = next_pa; | ||
137 | } | ||
138 | diff --git a/arch/sparc64/kernel/kgdb.c b/arch/sparc64/kernel/kgdb.c | ||
139 | index fefbe6d..f5a0fd4 100644 | ||
140 | --- a/arch/sparc64/kernel/kgdb.c | ||
141 | +++ b/arch/sparc64/kernel/kgdb.c | ||
142 | @@ -108,7 +108,7 @@ void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs) | ||
143 | } | ||
144 | |||
145 | #ifdef CONFIG_SMP | ||
146 | -void smp_kgdb_capture_client(struct pt_regs *regs) | ||
147 | +void smp_kgdb_capture_client(int irq, struct pt_regs *regs) | ||
148 | { | ||
149 | unsigned long flags; | ||
150 | |||
151 | diff --git a/arch/sparc64/kernel/of_device.c b/arch/sparc64/kernel/of_device.c | ||
152 | index 100ebd5..d342723 100644 | ||
153 | --- a/arch/sparc64/kernel/of_device.c | ||
154 | +++ b/arch/sparc64/kernel/of_device.c | ||
155 | @@ -278,8 +278,25 @@ static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) | ||
156 | |||
157 | static int of_bus_sbus_match(struct device_node *np) | ||
158 | { | ||
159 | - return !strcmp(np->name, "sbus") || | ||
160 | - !strcmp(np->name, "sbi"); | ||
161 | + struct device_node *dp = np; | ||
162 | + | ||
163 | + while (dp) { | ||
164 | + if (!strcmp(dp->name, "sbus") || | ||
165 | + !strcmp(dp->name, "sbi")) | ||
166 | + return 1; | ||
167 | + | ||
168 | + /* Have a look at use_1to1_mapping(). We're trying | ||
169 | + * to match SBUS if that's the top-level bus and we | ||
170 | + * don't have some intervening real bus that provides | ||
171 | + * ranges based translations. | ||
172 | + */ | ||
173 | + if (of_find_property(dp, "ranges", NULL) != NULL) | ||
174 | + break; | ||
175 | + | ||
176 | + dp = dp->parent; | ||
177 | + } | ||
178 | + | ||
179 | + return 0; | ||
180 | } | ||
181 | |||
182 | static void of_bus_sbus_count_cells(struct device_node *child, | ||
183 | diff --git a/arch/sparc64/kernel/pci_common.c b/arch/sparc64/kernel/pci_common.c | ||
184 | index 09a5ec2..d498c60 100644 | ||
185 | --- a/arch/sparc64/kernel/pci_common.c | ||
186 | +++ b/arch/sparc64/kernel/pci_common.c | ||
187 | @@ -368,7 +368,7 @@ static void pci_register_iommu_region(struct pci_pbm_info *pbm) | ||
188 | const u32 *vdma = of_get_property(pbm->prom_node, "virtual-dma", NULL); | ||
189 | |||
190 | if (vdma) { | ||
191 | - struct resource *rp = kmalloc(sizeof(*rp), GFP_KERNEL); | ||
192 | + struct resource *rp = kzalloc(sizeof(*rp), GFP_KERNEL); | ||
193 | |||
194 | if (!rp) { | ||
195 | prom_printf("Cannot allocate IOMMU resource.\n"); | ||
196 | diff --git a/arch/sparc64/kernel/smp.c b/arch/sparc64/kernel/smp.c | ||
197 | index 2be166c..a0ad401 100644 | ||
198 | --- a/arch/sparc64/kernel/smp.c | ||
199 | +++ b/arch/sparc64/kernel/smp.c | ||
200 | @@ -118,9 +118,9 @@ void __cpuinit smp_callin(void) | ||
201 | while (!cpu_isset(cpuid, smp_commenced_mask)) | ||
202 | rmb(); | ||
203 | |||
204 | - ipi_call_lock(); | ||
205 | + ipi_call_lock_irq(); | ||
206 | cpu_set(cpuid, cpu_online_map); | ||
207 | - ipi_call_unlock(); | ||
208 | + ipi_call_unlock_irq(); | ||
209 | |||
210 | /* idle thread is expected to have preempt disabled */ | ||
211 | preempt_disable(); | ||
212 | @@ -1031,7 +1031,7 @@ void smp_fetch_global_regs(void) | ||
213 | * If the address space is non-shared (ie. mm->count == 1) we avoid | ||
214 | * cross calls when we want to flush the currently running process's | ||
215 | * tlb state. This is done by clearing all cpu bits except the current | ||
216 | - * processor's in current->active_mm->cpu_vm_mask and performing the | ||
217 | + * processor's in current->mm->cpu_vm_mask and performing the | ||
218 | * flush locally only. This will force any subsequent cpus which run | ||
219 | * this task to flush the context from the local tlb if the process | ||
220 | * migrates to another cpu (again). | ||
221 | @@ -1074,7 +1074,7 @@ void smp_flush_tlb_pending(struct mm_struct *mm, unsigned long nr, unsigned long | ||
222 | u32 ctx = CTX_HWBITS(mm->context); | ||
223 | int cpu = get_cpu(); | ||
224 | |||
225 | - if (mm == current->active_mm && atomic_read(&mm->mm_users) == 1) | ||
226 | + if (mm == current->mm && atomic_read(&mm->mm_users) == 1) | ||
227 | mm->cpu_vm_mask = cpumask_of_cpu(cpu); | ||
228 | else | ||
229 | smp_cross_call_masked(&xcall_flush_tlb_pending, | ||
230 | diff --git a/arch/sparc64/kernel/ttable.S b/arch/sparc64/kernel/ttable.S | ||
231 | index 1ade3d6..89bf646 100644 | ||
232 | --- a/arch/sparc64/kernel/ttable.S | ||
233 | +++ b/arch/sparc64/kernel/ttable.S | ||
234 | @@ -63,7 +63,13 @@ tl0_irq6: TRAP_IRQ(smp_call_function_single_client, 6) | ||
235 | #else | ||
236 | tl0_irq6: BTRAP(0x46) | ||
237 | #endif | ||
238 | -tl0_irq7: BTRAP(0x47) BTRAP(0x48) BTRAP(0x49) | ||
239 | +tl0_irq7: BTRAP(0x47) | ||
240 | +#ifdef CONFIG_KGDB | ||
241 | +tl0_irq8: TRAP_IRQ(smp_kgdb_capture_client, 8) | ||
242 | +#else | ||
243 | +tl0_irq8: BTRAP(0x48) | ||
244 | +#endif | ||
245 | +tl0_irq9: BTRAP(0x49) | ||
246 | tl0_irq10: BTRAP(0x4a) BTRAP(0x4b) BTRAP(0x4c) BTRAP(0x4d) | ||
247 | tl0_irq14: TRAP_IRQ(timer_interrupt, 14) | ||
248 | tl0_irq15: TRAP_IRQ(handler_irq, 15) | ||
249 | diff --git a/arch/sparc64/mm/ultra.S b/arch/sparc64/mm/ultra.S | ||
250 | index 86773e8..f1d76cb 100644 | ||
251 | --- a/arch/sparc64/mm/ultra.S | ||
252 | +++ b/arch/sparc64/mm/ultra.S | ||
253 | @@ -681,28 +681,8 @@ xcall_new_mmu_context_version: | ||
254 | #ifdef CONFIG_KGDB | ||
255 | .globl xcall_kgdb_capture | ||
256 | xcall_kgdb_capture: | ||
257 | -661: rdpr %pstate, %g2 | ||
258 | - wrpr %g2, PSTATE_IG | PSTATE_AG, %pstate | ||
259 | - .section .sun4v_2insn_patch, "ax" | ||
260 | - .word 661b | ||
261 | - nop | ||
262 | - nop | ||
263 | - .previous | ||
264 | - | ||
265 | - rdpr %pil, %g2 | ||
266 | - wrpr %g0, 15, %pil | ||
267 | - sethi %hi(109f), %g7 | ||
268 | - ba,pt %xcc, etrap_irq | ||
269 | -109: or %g7, %lo(109b), %g7 | ||
270 | -#ifdef CONFIG_TRACE_IRQFLAGS | ||
271 | - call trace_hardirqs_off | ||
272 | - nop | ||
273 | -#endif | ||
274 | - call smp_kgdb_capture_client | ||
275 | - add %sp, PTREGS_OFF, %o0 | ||
276 | - /* Has to be a non-v9 branch due to the large distance. */ | ||
277 | - ba rtrap_xcall | ||
278 | - ldx [%sp + PTREGS_OFF + PT_V9_TSTATE], %l1 | ||
279 | + wr %g0, (1 << PIL_KGDB_CAPTURE), %set_softint | ||
280 | + retry | ||
281 | #endif | ||
282 | |||
283 | #endif /* CONFIG_SMP */ | ||
284 | diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c | ||
285 | index 6d5a3c4..2781331 100644 | ||
286 | --- a/arch/x86/kernel/setup.c | ||
287 | +++ b/arch/x86/kernel/setup.c | ||
288 | @@ -730,6 +730,9 @@ void __init setup_arch(char **cmdline_p) | ||
289 | |||
290 | finish_e820_parsing(); | ||
291 | |||
292 | + if (efi_enabled) | ||
293 | + efi_init(); | ||
294 | + | ||
295 | dmi_scan_machine(); | ||
296 | |||
297 | dmi_check_system(bad_bios_dmi_table); | ||
298 | @@ -743,8 +746,6 @@ void __init setup_arch(char **cmdline_p) | ||
299 | insert_resource(&iomem_resource, &data_resource); | ||
300 | insert_resource(&iomem_resource, &bss_resource); | ||
301 | |||
302 | - if (efi_enabled) | ||
303 | - efi_init(); | ||
304 | |||
305 | #ifdef CONFIG_X86_32 | ||
306 | if (ppro_with_ram_bug()) { | ||
307 | diff --git a/arch/x86/mm/hugetlbpage.c b/arch/x86/mm/hugetlbpage.c | ||
308 | index 8f307d9..f46c340 100644 | ||
309 | --- a/arch/x86/mm/hugetlbpage.c | ||
310 | +++ b/arch/x86/mm/hugetlbpage.c | ||
311 | @@ -26,12 +26,16 @@ static unsigned long page_table_shareable(struct vm_area_struct *svma, | ||
312 | unsigned long sbase = saddr & PUD_MASK; | ||
313 | unsigned long s_end = sbase + PUD_SIZE; | ||
314 | |||
315 | + /* Allow segments to share if only one is marked locked */ | ||
316 | + unsigned long vm_flags = vma->vm_flags & ~VM_LOCKED; | ||
317 | + unsigned long svm_flags = svma->vm_flags & ~VM_LOCKED; | ||
318 | + | ||
319 | /* | ||
320 | * match the virtual addresses, permission and the alignment of the | ||
321 | * page table page. | ||
322 | */ | ||
323 | if (pmd_index(addr) != pmd_index(saddr) || | ||
324 | - vma->vm_flags != svma->vm_flags || | ||
325 | + vm_flags != svm_flags || | ||
326 | sbase < svma->vm_start || svma->vm_end < s_end) | ||
327 | return 0; | ||
328 | |||
329 | diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c | ||
330 | index 7c3b8dc..5468c19 100644 | ||
331 | --- a/arch/x86/mm/pageattr.c | ||
332 | +++ b/arch/x86/mm/pageattr.c | ||
333 | @@ -565,6 +565,17 @@ static int split_large_page(pte_t *kpte, unsigned long address) | ||
334 | ref_prot = pte_pgprot(pte_mkexec(pte_clrhuge(*kpte))); | ||
335 | pgprot_val(ref_prot) |= _PAGE_PRESENT; | ||
336 | __set_pmd_pte(kpte, address, mk_pte(base, ref_prot)); | ||
337 | + | ||
338 | + /* | ||
339 | + * Intel Atom errata AAH41 workaround. | ||
340 | + * | ||
341 | + * The real fix should be in hw or in a microcode update, but | ||
342 | + * we also probabilistically try to reduce the window of having | ||
343 | + * a large TLB mixed with 4K TLBs while instruction fetches are | ||
344 | + * going on. | ||
345 | + */ | ||
346 | + __flush_tlb_all(); | ||
347 | + | ||
348 | base = NULL; | ||
349 | |||
350 | out_unlock: | ||
351 | diff --git a/arch/x86/pci/mmconfig-shared.c b/arch/x86/pci/mmconfig-shared.c | ||
352 | index 76d49eb..8a06160 100644 | ||
353 | --- a/arch/x86/pci/mmconfig-shared.c | ||
354 | +++ b/arch/x86/pci/mmconfig-shared.c | ||
355 | @@ -255,7 +255,7 @@ static acpi_status __init check_mcfg_resource(struct acpi_resource *res, | ||
356 | if (!fixmem32) | ||
357 | return AE_OK; | ||
358 | if ((mcfg_res->start >= fixmem32->address) && | ||
359 | - (mcfg_res->end <= (fixmem32->address + | ||
360 | + (mcfg_res->end < (fixmem32->address + | ||
361 | fixmem32->address_length))) { | ||
362 | mcfg_res->flags = 1; | ||
363 | return AE_CTRL_TERMINATE; | ||
364 | @@ -272,7 +272,7 @@ static acpi_status __init check_mcfg_resource(struct acpi_resource *res, | ||
365 | return AE_OK; | ||
366 | |||
367 | if ((mcfg_res->start >= address.minimum) && | ||
368 | - (mcfg_res->end <= (address.minimum + address.address_length))) { | ||
369 | + (mcfg_res->end < (address.minimum + address.address_length))) { | ||
370 | mcfg_res->flags = 1; | ||
371 | return AE_CTRL_TERMINATE; | ||
372 | } | ||
373 | @@ -298,7 +298,7 @@ static int __init is_acpi_reserved(u64 start, u64 end, unsigned not_used) | ||
374 | struct resource mcfg_res; | ||
375 | |||
376 | mcfg_res.start = start; | ||
377 | - mcfg_res.end = end; | ||
378 | + mcfg_res.end = end - 1; | ||
379 | mcfg_res.flags = 0; | ||
380 | |||
381 | acpi_get_devices("PNP0C01", find_mboard_resource, &mcfg_res, NULL); | ||
382 | diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c | ||
383 | index 81b40ed..5639e27 100644 | ||
384 | --- a/drivers/acpi/processor_idle.c | ||
385 | +++ b/drivers/acpi/processor_idle.c | ||
386 | @@ -303,6 +303,9 @@ static void acpi_timer_check_state(int state, struct acpi_processor *pr, | ||
387 | struct acpi_processor_power *pwr = &pr->power; | ||
388 | u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; | ||
389 | |||
390 | + if (boot_cpu_has(X86_FEATURE_AMDC1E)) | ||
391 | + type = ACPI_STATE_C1; | ||
392 | + | ||
393 | /* | ||
394 | * Check, if one of the previous states already marked the lapic | ||
395 | * unstable | ||
396 | @@ -1154,6 +1157,7 @@ static int acpi_processor_power_verify(struct acpi_processor *pr) | ||
397 | switch (cx->type) { | ||
398 | case ACPI_STATE_C1: | ||
399 | cx->valid = 1; | ||
400 | + acpi_timer_check_state(i, pr, cx); | ||
401 | break; | ||
402 | |||
403 | case ACPI_STATE_C2: | ||
404 | @@ -1468,20 +1472,22 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev, | ||
405 | |||
406 | /* Do not access any ACPI IO ports in suspend path */ | ||
407 | if (acpi_idle_suspend) { | ||
408 | - acpi_safe_halt(); | ||
409 | local_irq_enable(); | ||
410 | + cpu_relax(); | ||
411 | return 0; | ||
412 | } | ||
413 | |||
414 | if (pr->flags.bm_check) | ||
415 | acpi_idle_update_bm_rld(pr, cx); | ||
416 | |||
417 | + acpi_state_timer_broadcast(pr, cx, 1); | ||
418 | t1 = inl(acpi_gbl_FADT.xpm_timer_block.address); | ||
419 | acpi_idle_do_entry(cx); | ||
420 | t2 = inl(acpi_gbl_FADT.xpm_timer_block.address); | ||
421 | |||
422 | local_irq_enable(); | ||
423 | cx->usage++; | ||
424 | + acpi_state_timer_broadcast(pr, cx, 0); | ||
425 | |||
426 | return ticks_elapsed_in_us(t1, t2); | ||
427 | } | ||
428 | diff --git a/drivers/char/random.c b/drivers/char/random.c | ||
429 | index 7ce1ac4..201b2c1 100644 | ||
430 | --- a/drivers/char/random.c | ||
431 | +++ b/drivers/char/random.c | ||
432 | @@ -1626,15 +1626,20 @@ EXPORT_SYMBOL(secure_dccp_sequence_number); | ||
433 | * value is not cryptographically secure but for several uses the cost of | ||
434 | * depleting entropy is too high | ||
435 | */ | ||
436 | +DEFINE_PER_CPU(__u32 [4], get_random_int_hash); | ||
437 | unsigned int get_random_int(void) | ||
438 | { | ||
439 | - /* | ||
440 | - * Use IP's RNG. It suits our purpose perfectly: it re-keys itself | ||
441 | - * every second, from the entropy pool (and thus creates a limited | ||
442 | - * drain on it), and uses halfMD4Transform within the second. We | ||
443 | - * also mix it with jiffies and the PID: | ||
444 | - */ | ||
445 | - return secure_ip_id((__force __be32)(current->pid + jiffies)); | ||
446 | + struct keydata *keyptr; | ||
447 | + __u32 *hash = get_cpu_var(get_random_int_hash); | ||
448 | + int ret; | ||
449 | + | ||
450 | + keyptr = get_keyptr(); | ||
451 | + hash[0] += current->pid + jiffies + get_cycles(); | ||
452 | + | ||
453 | + ret = half_md4_transform(hash, keyptr->secret); | ||
454 | + put_cpu_var(get_random_int_hash); | ||
455 | + | ||
456 | + return ret; | ||
457 | } | ||
458 | |||
459 | /* | ||
460 | diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c | ||
461 | index 68f052b..2db432d 100644 | ||
462 | --- a/drivers/char/tpm/tpm_bios.c | ||
463 | +++ b/drivers/char/tpm/tpm_bios.c | ||
464 | @@ -214,7 +214,8 @@ static int get_event_name(char *dest, struct tcpa_event *event, | ||
465 | unsigned char * event_entry) | ||
466 | { | ||
467 | const char *name = ""; | ||
468 | - char data[40] = ""; | ||
469 | + /* 41 so there is room for 40 data and 1 nul */ | ||
470 | + char data[41] = ""; | ||
471 | int i, n_len = 0, d_len = 0; | ||
472 | struct tcpa_pc_event *pc_event; | ||
473 | |||
474 | diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c | ||
475 | index ed7859f..affee01 100644 | ||
476 | --- a/drivers/hwmon/lm78.c | ||
477 | +++ b/drivers/hwmon/lm78.c | ||
478 | @@ -178,7 +178,7 @@ static struct platform_driver lm78_isa_driver = { | ||
479 | .name = "lm78", | ||
480 | }, | ||
481 | .probe = lm78_isa_probe, | ||
482 | - .remove = lm78_isa_remove, | ||
483 | + .remove = __devexit_p(lm78_isa_remove), | ||
484 | }; | ||
485 | |||
486 | |||
487 | diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c | ||
488 | index 53526d9..dedf96b 100644 | ||
489 | --- a/drivers/media/video/cx88/cx88-input.c | ||
490 | +++ b/drivers/media/video/cx88/cx88-input.c | ||
491 | @@ -48,8 +48,7 @@ struct cx88_IR { | ||
492 | |||
493 | /* poll external decoder */ | ||
494 | int polling; | ||
495 | - struct work_struct work; | ||
496 | - struct timer_list timer; | ||
497 | + struct delayed_work work; | ||
498 | u32 gpio_addr; | ||
499 | u32 last_gpio; | ||
500 | u32 mask_keycode; | ||
501 | @@ -143,27 +142,19 @@ static void cx88_ir_handle_key(struct cx88_IR *ir) | ||
502 | } | ||
503 | } | ||
504 | |||
505 | -static void ir_timer(unsigned long data) | ||
506 | -{ | ||
507 | - struct cx88_IR *ir = (struct cx88_IR *)data; | ||
508 | - | ||
509 | - schedule_work(&ir->work); | ||
510 | -} | ||
511 | - | ||
512 | static void cx88_ir_work(struct work_struct *work) | ||
513 | { | ||
514 | - struct cx88_IR *ir = container_of(work, struct cx88_IR, work); | ||
515 | + struct cx88_IR *ir = container_of(work, struct cx88_IR, work.work); | ||
516 | |||
517 | cx88_ir_handle_key(ir); | ||
518 | - mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling)); | ||
519 | + schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); | ||
520 | } | ||
521 | |||
522 | void cx88_ir_start(struct cx88_core *core, struct cx88_IR *ir) | ||
523 | { | ||
524 | if (ir->polling) { | ||
525 | - setup_timer(&ir->timer, ir_timer, (unsigned long)ir); | ||
526 | - INIT_WORK(&ir->work, cx88_ir_work); | ||
527 | - schedule_work(&ir->work); | ||
528 | + INIT_DELAYED_WORK(&ir->work, cx88_ir_work); | ||
529 | + schedule_delayed_work(&ir->work, 0); | ||
530 | } | ||
531 | if (ir->sampling) { | ||
532 | core->pci_irqmask |= PCI_INT_IR_SMPINT; | ||
533 | @@ -179,10 +170,8 @@ void cx88_ir_stop(struct cx88_core *core, struct cx88_IR *ir) | ||
534 | core->pci_irqmask &= ~PCI_INT_IR_SMPINT; | ||
535 | } | ||
536 | |||
537 | - if (ir->polling) { | ||
538 | - del_timer_sync(&ir->timer); | ||
539 | - flush_scheduled_work(); | ||
540 | - } | ||
541 | + if (ir->polling) | ||
542 | + cancel_delayed_work_sync(&ir->work); | ||
543 | } | ||
544 | |||
545 | /* ---------------------------------------------------------------------- */ | ||
546 | diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c | ||
547 | index 2486a65..ba91aee 100644 | ||
548 | --- a/drivers/net/bnx2.c | ||
549 | +++ b/drivers/net/bnx2.c | ||
550 | @@ -2574,6 +2574,7 @@ bnx2_get_hw_tx_cons(struct bnx2_napi *bnapi) | ||
551 | /* Tell compiler that status block fields can change. */ | ||
552 | barrier(); | ||
553 | cons = *bnapi->hw_tx_cons_ptr; | ||
554 | + barrier(); | ||
555 | if (unlikely((cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT)) | ||
556 | cons++; | ||
557 | return cons; | ||
558 | @@ -2849,6 +2850,7 @@ bnx2_get_hw_rx_cons(struct bnx2_napi *bnapi) | ||
559 | /* Tell compiler that status block fields can change. */ | ||
560 | barrier(); | ||
561 | cons = *bnapi->hw_rx_cons_ptr; | ||
562 | + barrier(); | ||
563 | if (unlikely((cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT)) | ||
564 | cons++; | ||
565 | return cons; | ||
566 | diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c | ||
567 | index 4489e58..e929e61 100644 | ||
568 | --- a/drivers/net/bonding/bond_alb.c | ||
569 | +++ b/drivers/net/bonding/bond_alb.c | ||
570 | @@ -1716,9 +1716,6 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr) | ||
571 | } | ||
572 | } | ||
573 | |||
574 | - write_unlock_bh(&bond->curr_slave_lock); | ||
575 | - read_unlock(&bond->lock); | ||
576 | - | ||
577 | if (swap_slave) { | ||
578 | alb_swap_mac_addr(bond, swap_slave, bond->curr_active_slave); | ||
579 | alb_fasten_mac_swap(bond, swap_slave, bond->curr_active_slave); | ||
580 | @@ -1726,16 +1723,15 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr) | ||
581 | alb_set_slave_mac_addr(bond->curr_active_slave, bond_dev->dev_addr, | ||
582 | bond->alb_info.rlb_enabled); | ||
583 | |||
584 | + read_lock(&bond->lock); | ||
585 | alb_send_learning_packets(bond->curr_active_slave, bond_dev->dev_addr); | ||
586 | if (bond->alb_info.rlb_enabled) { | ||
587 | /* inform clients mac address has changed */ | ||
588 | rlb_req_update_slave_clients(bond, bond->curr_active_slave); | ||
589 | } | ||
590 | + read_unlock(&bond->lock); | ||
591 | } | ||
592 | |||
593 | - read_lock(&bond->lock); | ||
594 | - write_lock_bh(&bond->curr_slave_lock); | ||
595 | - | ||
596 | return 0; | ||
597 | } | ||
598 | |||
599 | diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c | ||
600 | index 6b96357..1f60117 100644 | ||
601 | --- a/drivers/net/e1000/e1000_main.c | ||
602 | +++ b/drivers/net/e1000/e1000_main.c | ||
603 | @@ -4133,8 +4133,9 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, | ||
604 | PCI_DMA_FROMDEVICE); | ||
605 | |||
606 | length = le16_to_cpu(rx_desc->length); | ||
607 | - | ||
608 | - if (unlikely(!(status & E1000_RXD_STAT_EOP))) { | ||
609 | + /* !EOP means multiple descriptors were used to store a single | ||
610 | + * packet, also make sure the frame isn't just CRC only */ | ||
611 | + if (unlikely(!(status & E1000_RXD_STAT_EOP) || (length <= 4))) { | ||
612 | /* All receives must fit into a single buffer */ | ||
613 | E1000_DBG("%s: Receive packet consumed multiple" | ||
614 | " buffers\n", netdev->name); | ||
615 | diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c | ||
616 | index 89964fa..23110d8 100644 | ||
617 | --- a/drivers/net/igb/igb_ethtool.c | ||
618 | +++ b/drivers/net/igb/igb_ethtool.c | ||
619 | @@ -2029,6 +2029,10 @@ static struct ethtool_ops igb_ethtool_ops = { | ||
620 | .get_ethtool_stats = igb_get_ethtool_stats, | ||
621 | .get_coalesce = igb_get_coalesce, | ||
622 | .set_coalesce = igb_set_coalesce, | ||
623 | + .get_flags = ethtool_op_get_flags, | ||
624 | +#ifdef CONFIG_IGB_LRO | ||
625 | + .set_flags = ethtool_op_set_flags, | ||
626 | +#endif | ||
627 | }; | ||
628 | |||
629 | void igb_set_ethtool_ops(struct net_device *netdev) | ||
630 | diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c | ||
631 | index 4239450..1aa0388 100644 | ||
632 | --- a/drivers/net/macvlan.c | ||
633 | +++ b/drivers/net/macvlan.c | ||
634 | @@ -328,7 +328,8 @@ static u32 macvlan_ethtool_get_rx_csum(struct net_device *dev) | ||
635 | const struct macvlan_dev *vlan = netdev_priv(dev); | ||
636 | struct net_device *lowerdev = vlan->lowerdev; | ||
637 | |||
638 | - if (lowerdev->ethtool_ops->get_rx_csum == NULL) | ||
639 | + if (lowerdev->ethtool_ops == NULL || | ||
640 | + lowerdev->ethtool_ops->get_rx_csum == NULL) | ||
641 | return 0; | ||
642 | return lowerdev->ethtool_ops->get_rx_csum(lowerdev); | ||
643 | } | ||
644 | diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c | ||
645 | index d6524db..7d41ec8 100644 | ||
646 | --- a/drivers/net/myri10ge/myri10ge.c | ||
647 | +++ b/drivers/net/myri10ge/myri10ge.c | ||
648 | @@ -2379,6 +2379,7 @@ static int myri10ge_open(struct net_device *dev) | ||
649 | lro_mgr->lro_arr = ss->rx_done.lro_desc; | ||
650 | lro_mgr->get_frag_header = myri10ge_get_frag_header; | ||
651 | lro_mgr->max_aggr = myri10ge_lro_max_pkts; | ||
652 | + lro_mgr->frag_align_pad = 2; | ||
653 | if (lro_mgr->max_aggr > MAX_SKB_FRAGS) | ||
654 | lro_mgr->max_aggr = MAX_SKB_FRAGS; | ||
655 | |||
656 | diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c | ||
657 | index a0537f0..6221cdc 100644 | ||
658 | --- a/drivers/scsi/3w-xxxx.c | ||
659 | +++ b/drivers/scsi/3w-xxxx.c | ||
660 | @@ -6,7 +6,7 @@ | ||
661 | Arnaldo Carvalho de Melo <acme@conectiva.com.br> | ||
662 | Brad Strand <linux@3ware.com> | ||
663 | |||
664 | - Copyright (C) 1999-2007 3ware Inc. | ||
665 | + Copyright (C) 1999-2009 3ware Inc. | ||
666 | |||
667 | Kernel compatiblity By: Andre Hedrick <andre@suse.com> | ||
668 | Non-Copyright (C) 2000 Andre Hedrick <andre@suse.com> | ||
669 | @@ -1294,7 +1294,8 @@ static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) | ||
670 | { | ||
671 | dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n"); | ||
672 | |||
673 | - scsi_dma_unmap(cmd); | ||
674 | + if (cmd->SCp.phase == TW_PHASE_SGLIST) | ||
675 | + scsi_dma_unmap(cmd); | ||
676 | } /* End tw_unmap_scsi_data() */ | ||
677 | |||
678 | /* This function will reset a device extension */ | ||
679 | diff --git a/drivers/scsi/3w-xxxx.h b/drivers/scsi/3w-xxxx.h | ||
680 | index 0742e68..e938615 100644 | ||
681 | --- a/drivers/scsi/3w-xxxx.h | ||
682 | +++ b/drivers/scsi/3w-xxxx.h | ||
683 | @@ -6,7 +6,7 @@ | ||
684 | Arnaldo Carvalho de Melo <acme@conectiva.com.br> | ||
685 | Brad Strand <linux@3ware.com> | ||
686 | |||
687 | - Copyright (C) 1999-2007 3ware Inc. | ||
688 | + Copyright (C) 1999-2009 3ware Inc. | ||
689 | |||
690 | Kernel compatiblity By: Andre Hedrick <andre@suse.com> | ||
691 | Non-Copyright (C) 2000 Andre Hedrick <andre@suse.com> | ||
692 | diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c | ||
693 | index 2b7531d..08eefec 100644 | ||
694 | --- a/drivers/serial/icom.c | ||
695 | +++ b/drivers/serial/icom.c | ||
696 | @@ -1482,8 +1482,8 @@ static void icom_remove_adapter(struct icom_adapter *icom_adapter) | ||
697 | |||
698 | free_irq(icom_adapter->pci_dev->irq, (void *) icom_adapter); | ||
699 | iounmap(icom_adapter->base_addr); | ||
700 | - icom_free_adapter(icom_adapter); | ||
701 | pci_release_regions(icom_adapter->pci_dev); | ||
702 | + icom_free_adapter(icom_adapter); | ||
703 | } | ||
704 | |||
705 | static void icom_kref_release(struct kref *kref) | ||
706 | diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c | ||
707 | index 32e7acb..3485510 100644 | ||
708 | --- a/drivers/serial/mpc52xx_uart.c | ||
709 | +++ b/drivers/serial/mpc52xx_uart.c | ||
710 | @@ -1000,7 +1000,7 @@ mpc52xx_console_setup(struct console *co, char *options) | ||
711 | pr_debug("mpc52xx_console_setup co=%p, co->index=%i, options=%s\n", | ||
712 | co, co->index, options); | ||
713 | |||
714 | - if ((co->index < 0) || (co->index > MPC52xx_PSC_MAXNUM)) { | ||
715 | + if ((co->index < 0) || (co->index >= MPC52xx_PSC_MAXNUM)) { | ||
716 | pr_debug("PSC%x out of range\n", co->index); | ||
717 | return -EINVAL; | ||
718 | } | ||
719 | diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c | ||
720 | index 8017f1c..eb3b103 100644 | ||
721 | --- a/drivers/usb/host/isp1760-hcd.c | ||
722 | +++ b/drivers/usb/host/isp1760-hcd.c | ||
723 | @@ -1645,6 +1645,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
724 | u32 reg_base, or_reg, skip_reg; | ||
725 | unsigned long flags; | ||
726 | struct ptd ptd; | ||
727 | + packet_enqueue *pe; | ||
728 | |||
729 | switch (usb_pipetype(urb->pipe)) { | ||
730 | case PIPE_ISOCHRONOUS: | ||
731 | @@ -1656,6 +1657,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
732 | reg_base = INT_REGS_OFFSET; | ||
733 | or_reg = HC_INT_IRQ_MASK_OR_REG; | ||
734 | skip_reg = HC_INT_PTD_SKIPMAP_REG; | ||
735 | + pe = enqueue_an_INT_packet; | ||
736 | break; | ||
737 | |||
738 | default: | ||
739 | @@ -1663,6 +1665,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
740 | reg_base = ATL_REGS_OFFSET; | ||
741 | or_reg = HC_ATL_IRQ_MASK_OR_REG; | ||
742 | skip_reg = HC_ATL_PTD_SKIPMAP_REG; | ||
743 | + pe = enqueue_an_ATL_packet; | ||
744 | break; | ||
745 | } | ||
746 | |||
747 | @@ -1674,6 +1677,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
748 | u32 skip_map; | ||
749 | u32 or_map; | ||
750 | struct isp1760_qtd *qtd; | ||
751 | + struct isp1760_qh *qh = ints->qh; | ||
752 | |||
753 | skip_map = isp1760_readl(hcd->regs + skip_reg); | ||
754 | skip_map |= 1 << i; | ||
755 | @@ -1686,8 +1690,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
756 | priv_write_copy(priv, (u32 *)&ptd, hcd->regs + reg_base | ||
757 | + i * sizeof(ptd), sizeof(ptd)); | ||
758 | qtd = ints->qtd; | ||
759 | - | ||
760 | - clean_up_qtdlist(qtd); | ||
761 | + qtd = clean_up_qtdlist(qtd); | ||
762 | |||
763 | free_mem(priv, ints->payload); | ||
764 | |||
765 | @@ -1698,7 +1701,24 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, | ||
766 | ints->payload = 0; | ||
767 | |||
768 | isp1760_urb_done(priv, urb, status); | ||
769 | + if (qtd) | ||
770 | + pe(hcd, qh, qtd); | ||
771 | break; | ||
772 | + | ||
773 | + } else if (ints->qtd) { | ||
774 | + struct isp1760_qtd *qtd, *prev_qtd = ints->qtd; | ||
775 | + | ||
776 | + for (qtd = ints->qtd->hw_next; qtd; qtd = qtd->hw_next) { | ||
777 | + if (qtd->urb == urb) { | ||
778 | + prev_qtd->hw_next = clean_up_qtdlist(qtd); | ||
779 | + isp1760_urb_done(priv, urb, status); | ||
780 | + break; | ||
781 | + } | ||
782 | + prev_qtd = qtd; | ||
783 | + } | ||
784 | + /* we found the urb before the end of the list */ | ||
785 | + if (qtd) | ||
786 | + break; | ||
787 | } | ||
788 | ints++; | ||
789 | } | ||
790 | diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h | ||
791 | index eadbee3..1985721 100644 | ||
792 | --- a/fs/ext4/ext4.h | ||
793 | +++ b/fs/ext4/ext4.h | ||
794 | @@ -248,6 +248,30 @@ struct flex_groups { | ||
795 | #define EXT4_FL_USER_VISIBLE 0x000BDFFF /* User visible flags */ | ||
796 | #define EXT4_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */ | ||
797 | |||
798 | +/* Flags that should be inherited by new inodes from their parent. */ | ||
799 | +#define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |\ | ||
800 | + EXT4_SYNC_FL | EXT4_IMMUTABLE_FL | EXT4_APPEND_FL |\ | ||
801 | + EXT4_NODUMP_FL | EXT4_NOATIME_FL |\ | ||
802 | + EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |\ | ||
803 | + EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL) | ||
804 | + | ||
805 | +/* Flags that are appropriate for regular files (all but dir-specific ones). */ | ||
806 | +#define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL)) | ||
807 | + | ||
808 | +/* Flags that are appropriate for non-directories/regular files. */ | ||
809 | +#define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL) | ||
810 | + | ||
811 | +/* Mask out flags that are inappropriate for the given type of inode. */ | ||
812 | +static inline __u32 ext4_mask_flags(umode_t mode, __u32 flags) | ||
813 | +{ | ||
814 | + if (S_ISDIR(mode)) | ||
815 | + return flags; | ||
816 | + else if (S_ISREG(mode)) | ||
817 | + return flags & EXT4_REG_FLMASK; | ||
818 | + else | ||
819 | + return flags & EXT4_OTHER_FLMASK; | ||
820 | +} | ||
821 | + | ||
822 | /* | ||
823 | * Inode dynamic state flags | ||
824 | */ | ||
825 | @@ -255,6 +279,7 @@ struct flex_groups { | ||
826 | #define EXT4_STATE_NEW 0x00000002 /* inode is newly created */ | ||
827 | #define EXT4_STATE_XATTR 0x00000004 /* has in-inode xattrs */ | ||
828 | #define EXT4_STATE_NO_EXPAND 0x00000008 /* No space for expansion */ | ||
829 | +#define EXT4_STATE_DA_ALLOC_CLOSE 0x00000010 /* Alloc DA blks on close */ | ||
830 | |||
831 | /* Used to pass group descriptor data when online resize is done */ | ||
832 | struct ext4_new_group_input { | ||
833 | @@ -302,7 +327,9 @@ struct ext4_new_group_data { | ||
834 | #define EXT4_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long) | ||
835 | #define EXT4_IOC_GROUP_ADD _IOW('f', 8, struct ext4_new_group_input) | ||
836 | #define EXT4_IOC_MIGRATE _IO('f', 9) | ||
837 | + /* note ioctl 10 reserved for an early version of the FIEMAP ioctl */ | ||
838 | /* note ioctl 11 reserved for filesystem-independent FIEMAP ioctl */ | ||
839 | +#define EXT4_IOC_ALLOC_DA_BLKS _IO('f', 12) | ||
840 | |||
841 | /* | ||
842 | * ioctl commands in 32 bit emulation | ||
843 | @@ -1078,6 +1105,7 @@ extern int ext4_can_truncate(struct inode *inode); | ||
844 | extern void ext4_truncate (struct inode *); | ||
845 | extern void ext4_set_inode_flags(struct inode *); | ||
846 | extern void ext4_get_inode_flags(struct ext4_inode_info *); | ||
847 | +extern int ext4_alloc_da_blocks(struct inode *inode); | ||
848 | extern void ext4_set_aops(struct inode *inode); | ||
849 | extern int ext4_writepage_trans_blocks(struct inode *); | ||
850 | extern int ext4_meta_trans_blocks(struct inode *, int nrblocks, int idxblocks); | ||
851 | diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c | ||
852 | index b24d3c5..f99635a 100644 | ||
853 | --- a/fs/ext4/extents.c | ||
854 | +++ b/fs/ext4/extents.c | ||
855 | @@ -1118,7 +1118,8 @@ ext4_ext_search_right(struct inode *inode, struct ext4_ext_path *path, | ||
856 | struct ext4_extent_idx *ix; | ||
857 | struct ext4_extent *ex; | ||
858 | ext4_fsblk_t block; | ||
859 | - int depth, ee_len; | ||
860 | + int depth; /* Note, NOT eh_depth; depth from top of tree */ | ||
861 | + int ee_len; | ||
862 | |||
863 | BUG_ON(path == NULL); | ||
864 | depth = path->p_depth; | ||
865 | @@ -1177,7 +1178,8 @@ ext4_ext_search_right(struct inode *inode, struct ext4_ext_path *path, | ||
866 | if (bh == NULL) | ||
867 | return -EIO; | ||
868 | eh = ext_block_hdr(bh); | ||
869 | - if (ext4_ext_check_header(inode, eh, depth)) { | ||
870 | + /* subtract from p_depth to get proper eh_depth */ | ||
871 | + if (ext4_ext_check_header(inode, eh, path->p_depth - depth)) { | ||
872 | put_bh(bh); | ||
873 | return -EIO; | ||
874 | } | ||
875 | @@ -1631,11 +1633,13 @@ ext4_ext_put_in_cache(struct inode *inode, ext4_lblk_t block, | ||
876 | { | ||
877 | struct ext4_ext_cache *cex; | ||
878 | BUG_ON(len == 0); | ||
879 | + spin_lock(&EXT4_I(inode)->i_block_reservation_lock); | ||
880 | cex = &EXT4_I(inode)->i_cached_extent; | ||
881 | cex->ec_type = type; | ||
882 | cex->ec_block = block; | ||
883 | cex->ec_len = len; | ||
884 | cex->ec_start = start; | ||
885 | + spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); | ||
886 | } | ||
887 | |||
888 | /* | ||
889 | @@ -1692,12 +1696,17 @@ ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block, | ||
890 | struct ext4_extent *ex) | ||
891 | { | ||
892 | struct ext4_ext_cache *cex; | ||
893 | + int ret = EXT4_EXT_CACHE_NO; | ||
894 | |||
895 | + /* | ||
896 | + * We borrow i_block_reservation_lock to protect i_cached_extent | ||
897 | + */ | ||
898 | + spin_lock(&EXT4_I(inode)->i_block_reservation_lock); | ||
899 | cex = &EXT4_I(inode)->i_cached_extent; | ||
900 | |||
901 | /* has cache valid data? */ | ||
902 | if (cex->ec_type == EXT4_EXT_CACHE_NO) | ||
903 | - return EXT4_EXT_CACHE_NO; | ||
904 | + goto errout; | ||
905 | |||
906 | BUG_ON(cex->ec_type != EXT4_EXT_CACHE_GAP && | ||
907 | cex->ec_type != EXT4_EXT_CACHE_EXTENT); | ||
908 | @@ -1708,11 +1717,11 @@ ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block, | ||
909 | ext_debug("%u cached by %u:%u:%llu\n", | ||
910 | block, | ||
911 | cex->ec_block, cex->ec_len, cex->ec_start); | ||
912 | - return cex->ec_type; | ||
913 | + ret = cex->ec_type; | ||
914 | } | ||
915 | - | ||
916 | - /* not in cache */ | ||
917 | - return EXT4_EXT_CACHE_NO; | ||
918 | +errout: | ||
919 | + spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); | ||
920 | + return ret; | ||
921 | } | ||
922 | |||
923 | /* | ||
924 | @@ -2668,6 +2677,8 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode, | ||
925 | if (allocated > max_blocks) | ||
926 | allocated = max_blocks; | ||
927 | set_buffer_unwritten(bh_result); | ||
928 | + bh_result->b_bdev = inode->i_sb->s_bdev; | ||
929 | + bh_result->b_blocknr = newblock; | ||
930 | goto out2; | ||
931 | } | ||
932 | |||
933 | diff --git a/fs/ext4/file.c b/fs/ext4/file.c | ||
934 | index 430eb79..c0d02f8 100644 | ||
935 | --- a/fs/ext4/file.c | ||
936 | +++ b/fs/ext4/file.c | ||
937 | @@ -33,9 +33,14 @@ | ||
938 | */ | ||
939 | static int ext4_release_file (struct inode * inode, struct file * filp) | ||
940 | { | ||
941 | + if (EXT4_I(inode)->i_state & EXT4_STATE_DA_ALLOC_CLOSE) { | ||
942 | + ext4_alloc_da_blocks(inode); | ||
943 | + EXT4_I(inode)->i_state &= ~EXT4_STATE_DA_ALLOC_CLOSE; | ||
944 | + } | ||
945 | /* if we are the last writer on the inode, drop the block reservation */ | ||
946 | if ((filp->f_mode & FMODE_WRITE) && | ||
947 | - (atomic_read(&inode->i_writecount) == 1)) | ||
948 | + (atomic_read(&inode->i_writecount) == 1) && | ||
949 | + !EXT4_I(inode)->i_reserved_data_blocks) | ||
950 | { | ||
951 | down_write(&EXT4_I(inode)->i_data_sem); | ||
952 | ext4_discard_reservation(inode); | ||
953 | diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c | ||
954 | index cce841f..e8754fd 100644 | ||
955 | --- a/fs/ext4/ialloc.c | ||
956 | +++ b/fs/ext4/ialloc.c | ||
957 | @@ -188,7 +188,7 @@ void ext4_free_inode (handle_t *handle, struct inode * inode) | ||
958 | struct ext4_group_desc * gdp; | ||
959 | struct ext4_super_block * es; | ||
960 | struct ext4_sb_info *sbi; | ||
961 | - int fatal = 0, err; | ||
962 | + int fatal = 0, err, cleared; | ||
963 | ext4_group_t flex_group; | ||
964 | |||
965 | if (atomic_read(&inode->i_count) > 1) { | ||
966 | @@ -242,10 +242,12 @@ void ext4_free_inode (handle_t *handle, struct inode * inode) | ||
967 | goto error_return; | ||
968 | |||
969 | /* Ok, now we can actually update the inode bitmaps.. */ | ||
970 | - if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group), | ||
971 | - bit, bitmap_bh->b_data)) | ||
972 | - ext4_error (sb, "ext4_free_inode", | ||
973 | - "bit already cleared for inode %lu", ino); | ||
974 | + spin_lock(sb_bgl_lock(sbi, block_group)); | ||
975 | + cleared = ext4_clear_bit(bit, bitmap_bh->b_data); | ||
976 | + spin_unlock(sb_bgl_lock(sbi, block_group)); | ||
977 | + if (!cleared) | ||
978 | + ext4_error(sb, "ext4_free_inode", | ||
979 | + "bit already cleared for inode %lu", ino); | ||
980 | else { | ||
981 | gdp = ext4_get_group_desc (sb, block_group, &bh2); | ||
982 | |||
983 | @@ -685,6 +687,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode) | ||
984 | struct inode *ret; | ||
985 | ext4_group_t i; | ||
986 | int free = 0; | ||
987 | + static int once = 1; | ||
988 | ext4_group_t flex_group; | ||
989 | |||
990 | /* Cannot create files in a deleted directory */ | ||
991 | @@ -704,10 +707,12 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode) | ||
992 | ret2 = find_group_flex(sb, dir, &group); | ||
993 | if (ret2 == -1) { | ||
994 | ret2 = find_group_other(sb, dir, &group); | ||
995 | - if (ret2 == 0 && printk_ratelimit()) | ||
996 | + if (ret2 == 0 && once) { | ||
997 | + once = 0; | ||
998 | printk(KERN_NOTICE "ext4: find_group_flex " | ||
999 | "failed, fallback succeeded dir %lu\n", | ||
1000 | dir->i_ino); | ||
1001 | + } | ||
1002 | } | ||
1003 | goto got_group; | ||
1004 | } | ||
1005 | @@ -861,16 +866,12 @@ got: | ||
1006 | ei->i_disksize = 0; | ||
1007 | |||
1008 | /* | ||
1009 | - * Don't inherit extent flag from directory. We set extent flag on | ||
1010 | - * newly created directory and file only if -o extent mount option is | ||
1011 | - * specified | ||
1012 | + * Don't inherit extent flag from directory, amongst others. We set | ||
1013 | + * extent flag on newly created directory and file only if -o extent | ||
1014 | + * mount option is specified | ||
1015 | */ | ||
1016 | - ei->i_flags = EXT4_I(dir)->i_flags & ~(EXT4_INDEX_FL|EXT4_EXTENTS_FL); | ||
1017 | - if (S_ISLNK(mode)) | ||
1018 | - ei->i_flags &= ~(EXT4_IMMUTABLE_FL|EXT4_APPEND_FL); | ||
1019 | - /* dirsync only applies to directories */ | ||
1020 | - if (!S_ISDIR(mode)) | ||
1021 | - ei->i_flags &= ~EXT4_DIRSYNC_FL; | ||
1022 | + ei->i_flags = | ||
1023 | + ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED); | ||
1024 | ei->i_file_acl = 0; | ||
1025 | ei->i_dtime = 0; | ||
1026 | ei->i_block_alloc_info = NULL; | ||
1027 | diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c | ||
1028 | index 63b911b..aeebfc2 100644 | ||
1029 | --- a/fs/ext4/inode.c | ||
1030 | +++ b/fs/ext4/inode.c | ||
1031 | @@ -1046,6 +1046,14 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used) | ||
1032 | EXT4_I(inode)->i_reserved_meta_blocks = mdb; | ||
1033 | EXT4_I(inode)->i_allocated_meta_blocks = 0; | ||
1034 | spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); | ||
1035 | + | ||
1036 | + /* | ||
1037 | + * If we have done all the pending block allocations and if | ||
1038 | + * there aren't any writers on the inode, we can discard the | ||
1039 | + * inode's preallocations. | ||
1040 | + */ | ||
1041 | + if (!total && (atomic_read(&inode->i_writecount) == 0)) | ||
1042 | + ext4_discard_reservation(inode); | ||
1043 | } | ||
1044 | |||
1045 | /* | ||
1046 | @@ -1077,6 +1085,7 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block, | ||
1047 | int retval; | ||
1048 | |||
1049 | clear_buffer_mapped(bh); | ||
1050 | + clear_buffer_unwritten(bh); | ||
1051 | |||
1052 | /* | ||
1053 | * Try to see if we can get the block without requesting | ||
1054 | @@ -1107,6 +1116,18 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block, | ||
1055 | return retval; | ||
1056 | |||
1057 | /* | ||
1058 | + * When we call get_blocks without the create flag, the | ||
1059 | + * BH_Unwritten flag could have gotten set if the blocks | ||
1060 | + * requested were part of a uninitialized extent. We need to | ||
1061 | + * clear this flag now that we are committed to convert all or | ||
1062 | + * part of the uninitialized extent to be an initialized | ||
1063 | + * extent. This is because we need to avoid the combination | ||
1064 | + * of BH_Unwritten and BH_Mapped flags being simultaneously | ||
1065 | + * set on the buffer_head. | ||
1066 | + */ | ||
1067 | + clear_buffer_unwritten(bh); | ||
1068 | + | ||
1069 | + /* | ||
1070 | * New blocks allocate and/or writing to uninitialized extent | ||
1071 | * will possibly result in updating i_data, so we take | ||
1072 | * the write lock of i_data_sem, and call get_blocks() | ||
1073 | @@ -2097,6 +2118,10 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, | ||
1074 | struct buffer_head *bh_result, int create) | ||
1075 | { | ||
1076 | int ret = 0; | ||
1077 | + sector_t invalid_block = ~((sector_t) 0xffff); | ||
1078 | + | ||
1079 | + if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es)) | ||
1080 | + invalid_block = ~0; | ||
1081 | |||
1082 | BUG_ON(create == 0); | ||
1083 | BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize); | ||
1084 | @@ -2118,11 +2143,18 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, | ||
1085 | /* not enough space to reserve */ | ||
1086 | return ret; | ||
1087 | |||
1088 | - map_bh(bh_result, inode->i_sb, 0); | ||
1089 | + map_bh(bh_result, inode->i_sb, invalid_block); | ||
1090 | set_buffer_new(bh_result); | ||
1091 | set_buffer_delay(bh_result); | ||
1092 | } else if (ret > 0) { | ||
1093 | bh_result->b_size = (ret << inode->i_blkbits); | ||
1094 | + /* | ||
1095 | + * With sub-block writes into unwritten extents | ||
1096 | + * we also need to mark the buffer as new so that | ||
1097 | + * the unwritten parts of the buffer gets correctly zeroed. | ||
1098 | + */ | ||
1099 | + if (buffer_unwritten(bh_result)) | ||
1100 | + set_buffer_new(bh_result); | ||
1101 | ret = 0; | ||
1102 | } | ||
1103 | |||
1104 | @@ -2585,6 +2617,48 @@ out: | ||
1105 | return; | ||
1106 | } | ||
1107 | |||
1108 | +/* | ||
1109 | + * Force all delayed allocation blocks to be allocated for a given inode. | ||
1110 | + */ | ||
1111 | +int ext4_alloc_da_blocks(struct inode *inode) | ||
1112 | +{ | ||
1113 | + if (!EXT4_I(inode)->i_reserved_data_blocks && | ||
1114 | + !EXT4_I(inode)->i_reserved_meta_blocks) | ||
1115 | + return 0; | ||
1116 | + | ||
1117 | + /* | ||
1118 | + * We do something simple for now. The filemap_flush() will | ||
1119 | + * also start triggering a write of the data blocks, which is | ||
1120 | + * not strictly speaking necessary (and for users of | ||
1121 | + * laptop_mode, not even desirable). However, to do otherwise | ||
1122 | + * would require replicating code paths in: | ||
1123 | + * | ||
1124 | + * ext4_da_writepages() -> | ||
1125 | + * write_cache_pages() ---> (via passed in callback function) | ||
1126 | + * __mpage_da_writepage() --> | ||
1127 | + * mpage_add_bh_to_extent() | ||
1128 | + * mpage_da_map_blocks() | ||
1129 | + * | ||
1130 | + * The problem is that write_cache_pages(), located in | ||
1131 | + * mm/page-writeback.c, marks pages clean in preparation for | ||
1132 | + * doing I/O, which is not desirable if we're not planning on | ||
1133 | + * doing I/O at all. | ||
1134 | + * | ||
1135 | + * We could call write_cache_pages(), and then redirty all of | ||
1136 | + * the pages by calling redirty_page_for_writeback() but that | ||
1137 | + * would be ugly in the extreme. So instead we would need to | ||
1138 | + * replicate parts of the code in the above functions, | ||
1139 | + * simplifying them becuase we wouldn't actually intend to | ||
1140 | + * write out the pages, but rather only collect contiguous | ||
1141 | + * logical block extents, call the multi-block allocator, and | ||
1142 | + * then update the buffer heads with the block allocations. | ||
1143 | + * | ||
1144 | + * For now, though, we'll cheat by calling filemap_flush(), | ||
1145 | + * which will map the blocks, and start the I/O, but not | ||
1146 | + * actually wait for the I/O to complete. | ||
1147 | + */ | ||
1148 | + return filemap_flush(inode->i_mapping); | ||
1149 | +} | ||
1150 | |||
1151 | /* | ||
1152 | * bmap() is special. It gets used by applications such as lilo and by | ||
1153 | @@ -3594,6 +3668,9 @@ void ext4_truncate(struct inode *inode) | ||
1154 | if (!ext4_can_truncate(inode)) | ||
1155 | return; | ||
1156 | |||
1157 | + if (inode->i_size == 0) | ||
1158 | + ei->i_state |= EXT4_STATE_DA_ALLOC_CLOSE; | ||
1159 | + | ||
1160 | if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) { | ||
1161 | ext4_ext_truncate(inode); | ||
1162 | return; | ||
1163 | @@ -4011,11 +4088,9 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) | ||
1164 | ei->i_flags = le32_to_cpu(raw_inode->i_flags); | ||
1165 | inode->i_blocks = ext4_inode_blocks(raw_inode, ei); | ||
1166 | ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo); | ||
1167 | - if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != | ||
1168 | - cpu_to_le32(EXT4_OS_HURD)) { | ||
1169 | + if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) | ||
1170 | ei->i_file_acl |= | ||
1171 | ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; | ||
1172 | - } | ||
1173 | inode->i_size = ext4_isize(raw_inode); | ||
1174 | ei->i_disksize = inode->i_size; | ||
1175 | inode->i_generation = le32_to_cpu(raw_inode->i_generation); | ||
1176 | @@ -4062,6 +4137,18 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) | ||
1177 | (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32; | ||
1178 | } | ||
1179 | |||
1180 | + if (ei->i_file_acl && | ||
1181 | + ((ei->i_file_acl < | ||
1182 | + (le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block) + | ||
1183 | + EXT4_SB(sb)->s_gdb_count)) || | ||
1184 | + (ei->i_file_acl >= ext4_blocks_count(EXT4_SB(sb)->s_es)))) { | ||
1185 | + ext4_error(sb, __func__, | ||
1186 | + "bad extended attribute block %llu in inode #%lu", | ||
1187 | + ei->i_file_acl, inode->i_ino); | ||
1188 | + ret = -EIO; | ||
1189 | + goto bad_inode; | ||
1190 | + } | ||
1191 | + | ||
1192 | if (S_ISREG(inode->i_mode)) { | ||
1193 | inode->i_op = &ext4_file_inode_operations; | ||
1194 | inode->i_fop = &ext4_file_operations; | ||
1195 | @@ -4076,7 +4163,8 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) | ||
1196 | inode->i_op = &ext4_symlink_inode_operations; | ||
1197 | ext4_set_aops(inode); | ||
1198 | } | ||
1199 | - } else { | ||
1200 | + } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || | ||
1201 | + S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { | ||
1202 | inode->i_op = &ext4_special_inode_operations; | ||
1203 | if (raw_inode->i_block[0]) | ||
1204 | init_special_inode(inode, inode->i_mode, | ||
1205 | @@ -4084,6 +4172,13 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) | ||
1206 | else | ||
1207 | init_special_inode(inode, inode->i_mode, | ||
1208 | new_decode_dev(le32_to_cpu(raw_inode->i_block[1]))); | ||
1209 | + } else { | ||
1210 | + brelse(bh); | ||
1211 | + ret = -EIO; | ||
1212 | + ext4_error(inode->i_sb, __func__, | ||
1213 | + "bogus i_mode (%o) for inode=%lu", | ||
1214 | + inode->i_mode, inode->i_ino); | ||
1215 | + goto bad_inode; | ||
1216 | } | ||
1217 | brelse (iloc.bh); | ||
1218 | ext4_set_inode_flags(inode); | ||
1219 | diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c | ||
1220 | index 306bfd4..58dedf0 100644 | ||
1221 | --- a/fs/ext4/ioctl.c | ||
1222 | +++ b/fs/ext4/ioctl.c | ||
1223 | @@ -49,8 +49,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | ||
1224 | if (err) | ||
1225 | return err; | ||
1226 | |||
1227 | - if (!S_ISDIR(inode->i_mode)) | ||
1228 | - flags &= ~EXT4_DIRSYNC_FL; | ||
1229 | + flags = ext4_mask_flags(inode->i_mode, flags); | ||
1230 | |||
1231 | err = -EPERM; | ||
1232 | mutex_lock(&inode->i_mutex); | ||
1233 | @@ -288,6 +287,20 @@ setversion_out: | ||
1234 | return err; | ||
1235 | } | ||
1236 | |||
1237 | + case EXT4_IOC_ALLOC_DA_BLKS: | ||
1238 | + { | ||
1239 | + int err; | ||
1240 | + if (!is_owner_or_cap(inode)) | ||
1241 | + return -EACCES; | ||
1242 | + | ||
1243 | + err = mnt_want_write(filp->f_path.mnt); | ||
1244 | + if (err) | ||
1245 | + return err; | ||
1246 | + err = ext4_alloc_da_blocks(inode); | ||
1247 | + mnt_drop_write(filp->f_path.mnt); | ||
1248 | + return err; | ||
1249 | + } | ||
1250 | + | ||
1251 | default: | ||
1252 | return -ENOTTY; | ||
1253 | } | ||
1254 | diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c | ||
1255 | index 39d7cc1..c7dc115 100644 | ||
1256 | --- a/fs/ext4/mballoc.c | ||
1257 | +++ b/fs/ext4/mballoc.c | ||
1258 | @@ -1450,7 +1450,7 @@ static void ext4_mb_measure_extent(struct ext4_allocation_context *ac, | ||
1259 | struct ext4_free_extent *gex = &ac->ac_g_ex; | ||
1260 | |||
1261 | BUG_ON(ex->fe_len <= 0); | ||
1262 | - BUG_ON(ex->fe_len >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb)); | ||
1263 | + BUG_ON(ex->fe_len > EXT4_BLOCKS_PER_GROUP(ac->ac_sb)); | ||
1264 | BUG_ON(ex->fe_start >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb)); | ||
1265 | BUG_ON(ac->ac_status != AC_STATUS_CONTINUE); | ||
1266 | |||
1267 | @@ -2698,7 +2698,7 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery) | ||
1268 | sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL); | ||
1269 | if (sbi->s_mb_maxs == NULL) { | ||
1270 | clear_opt(sbi->s_mount_opt, MBALLOC); | ||
1271 | - kfree(sbi->s_mb_maxs); | ||
1272 | + kfree(sbi->s_mb_offsets); | ||
1273 | return -ENOMEM; | ||
1274 | } | ||
1275 | |||
1276 | @@ -3400,7 +3400,7 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac, | ||
1277 | } | ||
1278 | BUG_ON(start + size <= ac->ac_o_ex.fe_logical && | ||
1279 | start > ac->ac_o_ex.fe_logical); | ||
1280 | - BUG_ON(size <= 0 || size >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb)); | ||
1281 | + BUG_ON(size <= 0 || size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb)); | ||
1282 | |||
1283 | /* now prepare goal request */ | ||
1284 | |||
1285 | @@ -3698,6 +3698,7 @@ static void ext4_mb_put_pa(struct ext4_allocation_context *ac, | ||
1286 | struct super_block *sb, struct ext4_prealloc_space *pa) | ||
1287 | { | ||
1288 | unsigned long grp; | ||
1289 | + ext4_fsblk_t grp_blk; | ||
1290 | |||
1291 | if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) | ||
1292 | return; | ||
1293 | @@ -3712,8 +3713,12 @@ static void ext4_mb_put_pa(struct ext4_allocation_context *ac, | ||
1294 | pa->pa_deleted = 1; | ||
1295 | spin_unlock(&pa->pa_lock); | ||
1296 | |||
1297 | - /* -1 is to protect from crossing allocation group */ | ||
1298 | - ext4_get_group_no_and_offset(sb, pa->pa_pstart - 1, &grp, NULL); | ||
1299 | + grp_blk = pa->pa_pstart; | ||
1300 | + /* If linear, pa_pstart may be in the next group when pa is used up */ | ||
1301 | + if (pa->pa_linear) | ||
1302 | + grp_blk--; | ||
1303 | + | ||
1304 | + ext4_get_group_no_and_offset(sb, grp_blk, &grp, NULL); | ||
1305 | |||
1306 | /* | ||
1307 | * possible race: | ||
1308 | @@ -4527,7 +4532,7 @@ static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac) | ||
1309 | pa_inode_list) { | ||
1310 | spin_lock(&tmp_pa->pa_lock); | ||
1311 | if (tmp_pa->pa_deleted) { | ||
1312 | - spin_unlock(&pa->pa_lock); | ||
1313 | + spin_unlock(&tmp_pa->pa_lock); | ||
1314 | continue; | ||
1315 | } | ||
1316 | if (!added && pa->pa_free < tmp_pa->pa_free) { | ||
1317 | diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c | ||
1318 | index 4f3628f..6a71680 100644 | ||
1319 | --- a/fs/ext4/namei.c | ||
1320 | +++ b/fs/ext4/namei.c | ||
1321 | @@ -1055,8 +1055,16 @@ static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, str | ||
1322 | return ERR_PTR(-EIO); | ||
1323 | } | ||
1324 | inode = ext4_iget(dir->i_sb, ino); | ||
1325 | - if (IS_ERR(inode)) | ||
1326 | - return ERR_CAST(inode); | ||
1327 | + if (unlikely(IS_ERR(inode))) { | ||
1328 | + if (PTR_ERR(inode) == -ESTALE) { | ||
1329 | + ext4_error(dir->i_sb, __func__, | ||
1330 | + "deleted inode referenced: %u", | ||
1331 | + ino); | ||
1332 | + return ERR_PTR(-EIO); | ||
1333 | + } else { | ||
1334 | + return ERR_CAST(inode); | ||
1335 | + } | ||
1336 | + } | ||
1337 | } | ||
1338 | return d_splice_alias(inode, dentry); | ||
1339 | } | ||
1340 | @@ -2306,7 +2314,7 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry, | ||
1341 | struct inode * old_inode, * new_inode; | ||
1342 | struct buffer_head * old_bh, * new_bh, * dir_bh; | ||
1343 | struct ext4_dir_entry_2 * old_de, * new_de; | ||
1344 | - int retval; | ||
1345 | + int retval, force_da_alloc = 0; | ||
1346 | |||
1347 | old_bh = new_bh = dir_bh = NULL; | ||
1348 | |||
1349 | @@ -2444,6 +2452,7 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry, | ||
1350 | ext4_mark_inode_dirty(handle, new_inode); | ||
1351 | if (!new_inode->i_nlink) | ||
1352 | ext4_orphan_add(handle, new_inode); | ||
1353 | + force_da_alloc = 1; | ||
1354 | } | ||
1355 | retval = 0; | ||
1356 | |||
1357 | @@ -2452,6 +2461,8 @@ end_rename: | ||
1358 | brelse (old_bh); | ||
1359 | brelse (new_bh); | ||
1360 | ext4_journal_stop(handle); | ||
1361 | + if (retval == 0 && force_da_alloc) | ||
1362 | + ext4_alloc_da_blocks(old_inode); | ||
1363 | return retval; | ||
1364 | } | ||
1365 | |||
1366 | diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c | ||
1367 | index 257ff26..bbe6d59 100644 | ||
1368 | --- a/fs/jbd2/revoke.c | ||
1369 | +++ b/fs/jbd2/revoke.c | ||
1370 | @@ -55,6 +55,25 @@ | ||
1371 | * need do nothing. | ||
1372 | * RevokeValid set, Revoked set: | ||
1373 | * buffer has been revoked. | ||
1374 | + * | ||
1375 | + * Locking rules: | ||
1376 | + * We keep two hash tables of revoke records. One hashtable belongs to the | ||
1377 | + * running transaction (is pointed to by journal->j_revoke), the other one | ||
1378 | + * belongs to the committing transaction. Accesses to the second hash table | ||
1379 | + * happen only from the kjournald and no other thread touches this table. Also | ||
1380 | + * journal_switch_revoke_table() which switches which hashtable belongs to the | ||
1381 | + * running and which to the committing transaction is called only from | ||
1382 | + * kjournald. Therefore we need no locks when accessing the hashtable belonging | ||
1383 | + * to the committing transaction. | ||
1384 | + * | ||
1385 | + * All users operating on the hash table belonging to the running transaction | ||
1386 | + * have a handle to the transaction. Therefore they are safe from kjournald | ||
1387 | + * switching hash tables under them. For operations on the lists of entries in | ||
1388 | + * the hash table j_revoke_lock is used. | ||
1389 | + * | ||
1390 | + * Finally, also replay code uses the hash tables but at this moment noone else | ||
1391 | + * can touch them (filesystem isn't mounted yet) and hence no locking is | ||
1392 | + * needed. | ||
1393 | */ | ||
1394 | |||
1395 | #ifndef __KERNEL__ | ||
1396 | @@ -401,8 +420,6 @@ int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr, | ||
1397 | * the second time we would still have a pending revoke to cancel. So, | ||
1398 | * do not trust the Revoked bit on buffers unless RevokeValid is also | ||
1399 | * set. | ||
1400 | - * | ||
1401 | - * The caller must have the journal locked. | ||
1402 | */ | ||
1403 | int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh) | ||
1404 | { | ||
1405 | @@ -480,10 +497,7 @@ void jbd2_journal_switch_revoke_table(journal_t *journal) | ||
1406 | /* | ||
1407 | * Write revoke records to the journal for all entries in the current | ||
1408 | * revoke hash, deleting the entries as we go. | ||
1409 | - * | ||
1410 | - * Called with the journal lock held. | ||
1411 | */ | ||
1412 | - | ||
1413 | void jbd2_journal_write_revoke_records(journal_t *journal, | ||
1414 | transaction_t *transaction) | ||
1415 | { | ||
1416 | diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c | ||
1417 | index bff8733..c3fe156 100644 | ||
1418 | --- a/fs/nfs/dir.c | ||
1419 | +++ b/fs/nfs/dir.c | ||
1420 | @@ -1925,7 +1925,8 @@ int nfs_permission(struct inode *inode, int mask) | ||
1421 | case S_IFREG: | ||
1422 | /* NFSv4 has atomic_open... */ | ||
1423 | if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) | ||
1424 | - && (mask & MAY_OPEN)) | ||
1425 | + && (mask & MAY_OPEN) | ||
1426 | + && !(mask & MAY_EXEC)) | ||
1427 | goto out; | ||
1428 | break; | ||
1429 | case S_IFDIR: | ||
1430 | diff --git a/mm/hugetlb.c b/mm/hugetlb.c | ||
1431 | index 81e9a82..1ecbcf6 100644 | ||
1432 | --- a/mm/hugetlb.c | ||
1433 | +++ b/mm/hugetlb.c | ||
1434 | @@ -286,7 +286,7 @@ void resv_map_release(struct kref *ref) | ||
1435 | static struct resv_map *vma_resv_map(struct vm_area_struct *vma) | ||
1436 | { | ||
1437 | VM_BUG_ON(!is_vm_hugetlb_page(vma)); | ||
1438 | - if (!(vma->vm_flags & VM_SHARED)) | ||
1439 | + if (!(vma->vm_flags & VM_MAYSHARE)) | ||
1440 | return (struct resv_map *)(get_vma_private_data(vma) & | ||
1441 | ~HPAGE_RESV_MASK); | ||
1442 | return 0; | ||
1443 | @@ -295,7 +295,7 @@ static struct resv_map *vma_resv_map(struct vm_area_struct *vma) | ||
1444 | static void set_vma_resv_map(struct vm_area_struct *vma, struct resv_map *map) | ||
1445 | { | ||
1446 | VM_BUG_ON(!is_vm_hugetlb_page(vma)); | ||
1447 | - VM_BUG_ON(vma->vm_flags & VM_SHARED); | ||
1448 | + VM_BUG_ON(vma->vm_flags & VM_MAYSHARE); | ||
1449 | |||
1450 | set_vma_private_data(vma, (get_vma_private_data(vma) & | ||
1451 | HPAGE_RESV_MASK) | (unsigned long)map); | ||
1452 | @@ -304,7 +304,7 @@ static void set_vma_resv_map(struct vm_area_struct *vma, struct resv_map *map) | ||
1453 | static void set_vma_resv_flags(struct vm_area_struct *vma, unsigned long flags) | ||
1454 | { | ||
1455 | VM_BUG_ON(!is_vm_hugetlb_page(vma)); | ||
1456 | - VM_BUG_ON(vma->vm_flags & VM_SHARED); | ||
1457 | + VM_BUG_ON(vma->vm_flags & VM_MAYSHARE); | ||
1458 | |||
1459 | set_vma_private_data(vma, get_vma_private_data(vma) | flags); | ||
1460 | } | ||
1461 | @@ -323,7 +323,7 @@ static void decrement_hugepage_resv_vma(struct hstate *h, | ||
1462 | if (vma->vm_flags & VM_NORESERVE) | ||
1463 | return; | ||
1464 | |||
1465 | - if (vma->vm_flags & VM_SHARED) { | ||
1466 | + if (vma->vm_flags & VM_MAYSHARE) { | ||
1467 | /* Shared mappings always use reserves */ | ||
1468 | h->resv_huge_pages--; | ||
1469 | } else if (is_vma_resv_set(vma, HPAGE_RESV_OWNER)) { | ||
1470 | @@ -339,14 +339,14 @@ static void decrement_hugepage_resv_vma(struct hstate *h, | ||
1471 | void reset_vma_resv_huge_pages(struct vm_area_struct *vma) | ||
1472 | { | ||
1473 | VM_BUG_ON(!is_vm_hugetlb_page(vma)); | ||
1474 | - if (!(vma->vm_flags & VM_SHARED)) | ||
1475 | + if (!(vma->vm_flags & VM_MAYSHARE)) | ||
1476 | vma->vm_private_data = (void *)0; | ||
1477 | } | ||
1478 | |||
1479 | /* Returns true if the VMA has associated reserve pages */ | ||
1480 | static int vma_has_reserves(struct vm_area_struct *vma) | ||
1481 | { | ||
1482 | - if (vma->vm_flags & VM_SHARED) | ||
1483 | + if (vma->vm_flags & VM_MAYSHARE) | ||
1484 | return 1; | ||
1485 | if (is_vma_resv_set(vma, HPAGE_RESV_OWNER)) | ||
1486 | return 1; | ||
1487 | @@ -890,7 +890,7 @@ static int vma_needs_reservation(struct hstate *h, | ||
1488 | struct address_space *mapping = vma->vm_file->f_mapping; | ||
1489 | struct inode *inode = mapping->host; | ||
1490 | |||
1491 | - if (vma->vm_flags & VM_SHARED) { | ||
1492 | + if (vma->vm_flags & VM_MAYSHARE) { | ||
1493 | pgoff_t idx = vma_hugecache_offset(h, vma, addr); | ||
1494 | return region_chg(&inode->i_mapping->private_list, | ||
1495 | idx, idx + 1); | ||
1496 | @@ -915,7 +915,7 @@ static void vma_commit_reservation(struct hstate *h, | ||
1497 | struct address_space *mapping = vma->vm_file->f_mapping; | ||
1498 | struct inode *inode = mapping->host; | ||
1499 | |||
1500 | - if (vma->vm_flags & VM_SHARED) { | ||
1501 | + if (vma->vm_flags & VM_MAYSHARE) { | ||
1502 | pgoff_t idx = vma_hugecache_offset(h, vma, addr); | ||
1503 | region_add(&inode->i_mapping->private_list, idx, idx + 1); | ||
1504 | |||
1505 | @@ -1862,7 +1862,7 @@ retry_avoidcopy: | ||
1506 | * at the time of fork() could consume its reserves on COW instead | ||
1507 | * of the full address range. | ||
1508 | */ | ||
1509 | - if (!(vma->vm_flags & VM_SHARED) && | ||
1510 | + if (!(vma->vm_flags & VM_MAYSHARE) && | ||
1511 | is_vma_resv_set(vma, HPAGE_RESV_OWNER) && | ||
1512 | old_page != pagecache_page) | ||
1513 | outside_reserve = 1; | ||
1514 | @@ -1969,7 +1969,7 @@ retry: | ||
1515 | clear_huge_page(page, address, huge_page_size(h)); | ||
1516 | __SetPageUptodate(page); | ||
1517 | |||
1518 | - if (vma->vm_flags & VM_SHARED) { | ||
1519 | + if (vma->vm_flags & VM_MAYSHARE) { | ||
1520 | int err; | ||
1521 | struct inode *inode = mapping->host; | ||
1522 | |||
1523 | @@ -2073,7 +2073,7 @@ int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, | ||
1524 | goto out_unlock; | ||
1525 | } | ||
1526 | |||
1527 | - if (!(vma->vm_flags & VM_SHARED)) | ||
1528 | + if (!(vma->vm_flags & VM_MAYSHARE)) | ||
1529 | pagecache_page = hugetlbfs_pagecache_page(h, | ||
1530 | vma, address); | ||
1531 | } | ||
1532 | @@ -2223,7 +2223,7 @@ int hugetlb_reserve_pages(struct inode *inode, | ||
1533 | * to reserve the full area even if read-only as mprotect() may be | ||
1534 | * called to make the mapping read-write. Assume !vma is a shm mapping | ||
1535 | */ | ||
1536 | - if (!vma || vma->vm_flags & VM_SHARED) | ||
1537 | + if (!vma || vma->vm_flags & VM_MAYSHARE) | ||
1538 | chg = region_chg(&inode->i_mapping->private_list, from, to); | ||
1539 | else { | ||
1540 | struct resv_map *resv_map = resv_map_alloc(); | ||
1541 | @@ -2246,7 +2246,7 @@ int hugetlb_reserve_pages(struct inode *inode, | ||
1542 | hugetlb_put_quota(inode->i_mapping, chg); | ||
1543 | return ret; | ||
1544 | } | ||
1545 | - if (!vma || vma->vm_flags & VM_SHARED) | ||
1546 | + if (!vma || vma->vm_flags & VM_MAYSHARE) | ||
1547 | region_add(&inode->i_mapping->private_list, from, to); | ||
1548 | return 0; | ||
1549 | } | ||
1550 | diff --git a/net/core/pktgen.c b/net/core/pktgen.c | ||
1551 | index a756847..86714d1 100644 | ||
1552 | --- a/net/core/pktgen.c | ||
1553 | +++ b/net/core/pktgen.c | ||
1554 | @@ -2449,7 +2449,7 @@ static inline void free_SAs(struct pktgen_dev *pkt_dev) | ||
1555 | if (pkt_dev->cflows) { | ||
1556 | /* let go of the SAs if we have them */ | ||
1557 | int i = 0; | ||
1558 | - for (; i < pkt_dev->nflows; i++){ | ||
1559 | + for (; i < pkt_dev->cflows; i++) { | ||
1560 | struct xfrm_state *x = pkt_dev->flows[i].x; | ||
1561 | if (x) { | ||
1562 | xfrm_state_put(x); | ||
1563 | diff --git a/net/core/skbuff.c b/net/core/skbuff.c | ||
1564 | index 0675991..7832287 100644 | ||
1565 | --- a/net/core/skbuff.c | ||
1566 | +++ b/net/core/skbuff.c | ||
1567 | @@ -1992,7 +1992,7 @@ unsigned int skb_seq_read(unsigned int consumed, const u8 **data, | ||
1568 | next_skb: | ||
1569 | block_limit = skb_headlen(st->cur_skb) + st->stepped_offset; | ||
1570 | |||
1571 | - if (abs_offset < block_limit) { | ||
1572 | + if (abs_offset < block_limit && !st->frag_data) { | ||
1573 | *data = st->cur_skb->data + (abs_offset - st->stepped_offset); | ||
1574 | return block_limit - abs_offset; | ||
1575 | } | ||
1576 | diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c | ||
1577 | index 7abc6b8..4eca4d3 100644 | ||
1578 | --- a/net/ipv4/tcp_input.c | ||
1579 | +++ b/net/ipv4/tcp_input.c | ||
1580 | @@ -931,6 +931,8 @@ static void tcp_init_metrics(struct sock *sk) | ||
1581 | tcp_bound_rto(sk); | ||
1582 | if (inet_csk(sk)->icsk_rto < TCP_TIMEOUT_INIT && !tp->rx_opt.saw_tstamp) | ||
1583 | goto reset; | ||
1584 | + | ||
1585 | +cwnd: | ||
1586 | tp->snd_cwnd = tcp_init_cwnd(tp, dst); | ||
1587 | tp->snd_cwnd_stamp = tcp_time_stamp; | ||
1588 | return; | ||
1589 | @@ -945,6 +947,7 @@ reset: | ||
1590 | tp->mdev = tp->mdev_max = tp->rttvar = TCP_TIMEOUT_INIT; | ||
1591 | inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT; | ||
1592 | } | ||
1593 | + goto cwnd; | ||
1594 | } | ||
1595 | |||
1596 | static void tcp_update_reordering(struct sock *sk, const int metric, | ||
1597 | diff --git a/net/mac80211/rc80211_pid_algo.c b/net/mac80211/rc80211_pid_algo.c | ||
1598 | index a914ba7..4077676 100644 | ||
1599 | --- a/net/mac80211/rc80211_pid_algo.c | ||
1600 | +++ b/net/mac80211/rc80211_pid_algo.c | ||
1601 | @@ -367,8 +367,40 @@ static void rate_control_pid_rate_init(void *priv, void *priv_sta, | ||
1602 | * Until that method is implemented, we will use the lowest supported | ||
1603 | * rate as a workaround. */ | ||
1604 | struct ieee80211_supported_band *sband; | ||
1605 | + struct rc_pid_info *pinfo = priv; | ||
1606 | + struct rc_pid_rateinfo *rinfo = pinfo->rinfo; | ||
1607 | + int i, j, tmp; | ||
1608 | + bool s; | ||
1609 | |||
1610 | sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; | ||
1611 | + | ||
1612 | + /* Sort the rates. This is optimized for the most common case (i.e. | ||
1613 | + * almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed | ||
1614 | + * mapping too. */ | ||
1615 | + for (i = 0; i < sband->n_bitrates; i++) { | ||
1616 | + rinfo[i].index = i; | ||
1617 | + rinfo[i].rev_index = i; | ||
1618 | + if (RC_PID_FAST_START) | ||
1619 | + rinfo[i].diff = 0; | ||
1620 | + else | ||
1621 | + rinfo[i].diff = i * pinfo->norm_offset; | ||
1622 | + } | ||
1623 | + for (i = 1; i < sband->n_bitrates; i++) { | ||
1624 | + s = 0; | ||
1625 | + for (j = 0; j < sband->n_bitrates - i; j++) | ||
1626 | + if (unlikely(sband->bitrates[rinfo[j].index].bitrate > | ||
1627 | + sband->bitrates[rinfo[j + 1].index].bitrate)) { | ||
1628 | + tmp = rinfo[j].index; | ||
1629 | + rinfo[j].index = rinfo[j + 1].index; | ||
1630 | + rinfo[j + 1].index = tmp; | ||
1631 | + rinfo[rinfo[j].index].rev_index = j; | ||
1632 | + rinfo[rinfo[j + 1].index].rev_index = j + 1; | ||
1633 | + s = 1; | ||
1634 | + } | ||
1635 | + if (!s) | ||
1636 | + break; | ||
1637 | + } | ||
1638 | + | ||
1639 | sta->txrate_idx = rate_lowest_index(local, sband, sta); | ||
1640 | sta->fail_avg = 0; | ||
1641 | } | ||
1642 | @@ -378,21 +410,23 @@ static void *rate_control_pid_alloc(struct ieee80211_local *local) | ||
1643 | struct rc_pid_info *pinfo; | ||
1644 | struct rc_pid_rateinfo *rinfo; | ||
1645 | struct ieee80211_supported_band *sband; | ||
1646 | - int i, j, tmp; | ||
1647 | - bool s; | ||
1648 | + int i, max_rates = 0; | ||
1649 | #ifdef CONFIG_MAC80211_DEBUGFS | ||
1650 | struct rc_pid_debugfs_entries *de; | ||
1651 | #endif | ||
1652 | |||
1653 | - sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; | ||
1654 | - | ||
1655 | pinfo = kmalloc(sizeof(*pinfo), GFP_ATOMIC); | ||
1656 | if (!pinfo) | ||
1657 | return NULL; | ||
1658 | |||
1659 | + for (i = 0; i < IEEE80211_NUM_BANDS; i++) { | ||
1660 | + sband = local->hw.wiphy->bands[i]; | ||
1661 | + if (sband && sband->n_bitrates > max_rates) | ||
1662 | + max_rates = sband->n_bitrates; | ||
1663 | + } | ||
1664 | /* We can safely assume that sband won't change unless we get | ||
1665 | * reinitialized. */ | ||
1666 | - rinfo = kmalloc(sizeof(*rinfo) * sband->n_bitrates, GFP_ATOMIC); | ||
1667 | + rinfo = kmalloc(sizeof(*rinfo) * max_rates, GFP_ATOMIC); | ||
1668 | if (!rinfo) { | ||
1669 | kfree(pinfo); | ||
1670 | return NULL; | ||
1671 | @@ -410,33 +444,6 @@ static void *rate_control_pid_alloc(struct ieee80211_local *local) | ||
1672 | pinfo->rinfo = rinfo; | ||
1673 | pinfo->oldrate = 0; | ||
1674 | |||
1675 | - /* Sort the rates. This is optimized for the most common case (i.e. | ||
1676 | - * almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed | ||
1677 | - * mapping too. */ | ||
1678 | - for (i = 0; i < sband->n_bitrates; i++) { | ||
1679 | - rinfo[i].index = i; | ||
1680 | - rinfo[i].rev_index = i; | ||
1681 | - if (RC_PID_FAST_START) | ||
1682 | - rinfo[i].diff = 0; | ||
1683 | - else | ||
1684 | - rinfo[i].diff = i * pinfo->norm_offset; | ||
1685 | - } | ||
1686 | - for (i = 1; i < sband->n_bitrates; i++) { | ||
1687 | - s = 0; | ||
1688 | - for (j = 0; j < sband->n_bitrates - i; j++) | ||
1689 | - if (unlikely(sband->bitrates[rinfo[j].index].bitrate > | ||
1690 | - sband->bitrates[rinfo[j + 1].index].bitrate)) { | ||
1691 | - tmp = rinfo[j].index; | ||
1692 | - rinfo[j].index = rinfo[j + 1].index; | ||
1693 | - rinfo[j + 1].index = tmp; | ||
1694 | - rinfo[rinfo[j].index].rev_index = j; | ||
1695 | - rinfo[rinfo[j + 1].index].rev_index = j + 1; | ||
1696 | - s = 1; | ||
1697 | - } | ||
1698 | - if (!s) | ||
1699 | - break; | ||
1700 | - } | ||
1701 | - | ||
1702 | #ifdef CONFIG_MAC80211_DEBUGFS | ||
1703 | de = &pinfo->dentries; | ||
1704 | de->dir = debugfs_create_dir("rc80211_pid", | ||
1705 | diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c | ||
1706 | index f028f70..e2d25da 100644 | ||
1707 | --- a/security/selinux/hooks.c | ||
1708 | +++ b/security/selinux/hooks.c | ||
1709 | @@ -4477,7 +4477,7 @@ static int selinux_ip_postroute_iptables_compat(struct sock *sk, | ||
1710 | if (err) | ||
1711 | return err; | ||
1712 | |||
1713 | - if (send_perm != 0) | ||
1714 | + if (!send_perm) | ||
1715 | return 0; | ||
1716 | |||
1717 | err = sel_netport_sid(sk->sk_protocol, | ||
1718 | diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c | ||
1719 | index 1710623..c10e476 100644 | ||
1720 | --- a/sound/usb/usbaudio.c | ||
1721 | +++ b/sound/usb/usbaudio.c | ||
1722 | @@ -3367,7 +3367,7 @@ static int snd_usb_create_quirk(struct snd_usb_audio *chip, | ||
1723 | [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface, | ||
1724 | [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface, | ||
1725 | [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface, | ||
1726 | - [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface, | ||
1727 | + [QUIRK_MIDI_FASTLANE] = snd_usb_create_midi_interface, | ||
1728 | [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface, | ||
1729 | [QUIRK_MIDI_CME] = snd_usb_create_midi_interface, | ||
1730 | [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk, | ||
1731 | diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h | ||
1732 | index 7cf18c3..7191d82 100644 | ||
1733 | --- a/sound/usb/usbaudio.h | ||
1734 | +++ b/sound/usb/usbaudio.h | ||
1735 | @@ -153,7 +153,7 @@ enum quirk_type { | ||
1736 | QUIRK_MIDI_YAMAHA, | ||
1737 | QUIRK_MIDI_MIDIMAN, | ||
1738 | QUIRK_MIDI_NOVATION, | ||
1739 | - QUIRK_MIDI_RAW, | ||
1740 | + QUIRK_MIDI_FASTLANE, | ||
1741 | QUIRK_MIDI_EMAGIC, | ||
1742 | QUIRK_MIDI_CME, | ||
1743 | QUIRK_AUDIO_STANDARD_INTERFACE, | ||
1744 | diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c | ||
1745 | index 940ae5a..cd2b622 100644 | ||
1746 | --- a/sound/usb/usbmidi.c | ||
1747 | +++ b/sound/usb/usbmidi.c | ||
1748 | @@ -1733,8 +1733,18 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip, | ||
1749 | umidi->usb_protocol_ops = &snd_usbmidi_novation_ops; | ||
1750 | err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); | ||
1751 | break; | ||
1752 | - case QUIRK_MIDI_RAW: | ||
1753 | + case QUIRK_MIDI_FASTLANE: | ||
1754 | umidi->usb_protocol_ops = &snd_usbmidi_raw_ops; | ||
1755 | + /* | ||
1756 | + * Interface 1 contains isochronous endpoints, but with the same | ||
1757 | + * numbers as in interface 0. Since it is interface 1 that the | ||
1758 | + * USB core has most recently seen, these descriptors are now | ||
1759 | + * associated with the endpoint numbers. This will foul up our | ||
1760 | + * attempts to submit bulk/interrupt URBs to the endpoints in | ||
1761 | + * interface 0, so we have to make sure that the USB core looks | ||
1762 | + * again at interface 0 by calling usb_set_interface() on it. | ||
1763 | + */ | ||
1764 | + usb_set_interface(umidi->chip->dev, 0, 0); | ||
1765 | err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); | ||
1766 | break; | ||
1767 | case QUIRK_MIDI_EMAGIC: | ||
1768 | diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h | ||
1769 | index 9ea726c..076ca4c 100644 | ||
1770 | --- a/sound/usb/usbquirks.h | ||
1771 | +++ b/sound/usb/usbquirks.h | ||
1772 | @@ -1756,7 +1756,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), | ||
1773 | .data = & (const struct snd_usb_audio_quirk[]) { | ||
1774 | { | ||
1775 | .ifnum = 0, | ||
1776 | - .type = QUIRK_MIDI_RAW | ||
1777 | + .type = QUIRK_MIDI_FASTLANE | ||
1778 | }, | ||
1779 | { | ||
1780 | .ifnum = 1, |