Annotation of /trunk/kernel26-alx/patches-2.6.27-r3/0147-2.6.27.48-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: 32511 byte(s)
Thu Oct 14 15:11:06 2010 UTC (13 years, 11 months ago) by niro
File size: 32511 byte(s)
-2.6.27-alx-r3: new magellan 0.5.2 kernel
1 | niro | 1176 | diff --git a/arch/parisc/math-emu/decode_exc.c b/arch/parisc/math-emu/decode_exc.c |
2 | index 66c8a9f..62ebcde 100644 | ||
3 | --- a/arch/parisc/math-emu/decode_exc.c | ||
4 | +++ b/arch/parisc/math-emu/decode_exc.c | ||
5 | @@ -342,6 +342,7 @@ decode_fpu(unsigned int Fpu_register[], unsigned int trap_counts[]) | ||
6 | return SIGNALCODE(SIGFPE, FPE_FLTINV); | ||
7 | case DIVISIONBYZEROEXCEPTION: | ||
8 | update_trap_counts(Fpu_register, aflags, bflags, trap_counts); | ||
9 | + Clear_excp_register(exception_index); | ||
10 | return SIGNALCODE(SIGFPE, FPE_FLTDIV); | ||
11 | case INEXACTEXCEPTION: | ||
12 | update_trap_counts(Fpu_register, aflags, bflags, trap_counts); | ||
13 | diff --git a/arch/powerpc/lib/string.S b/arch/powerpc/lib/string.S | ||
14 | index 64e2e49..3ac0cd3 100644 | ||
15 | --- a/arch/powerpc/lib/string.S | ||
16 | +++ b/arch/powerpc/lib/string.S | ||
17 | @@ -71,7 +71,7 @@ _GLOBAL(strcmp) | ||
18 | |||
19 | _GLOBAL(strncmp) | ||
20 | PPC_LCMPI r5,0 | ||
21 | - beqlr | ||
22 | + ble- 2f | ||
23 | mtctr r5 | ||
24 | addi r5,r3,-1 | ||
25 | addi r4,r4,-1 | ||
26 | @@ -82,6 +82,8 @@ _GLOBAL(strncmp) | ||
27 | beqlr 1 | ||
28 | bdnzt eq,1b | ||
29 | blr | ||
30 | +2: li r3,0 | ||
31 | + blr | ||
32 | |||
33 | _GLOBAL(strlen) | ||
34 | addi r4,r3,-1 | ||
35 | diff --git a/arch/powerpc/oprofile/op_model_cell.c b/arch/powerpc/oprofile/op_model_cell.c | ||
36 | index 5ff4de3..303721d 100644 | ||
37 | --- a/arch/powerpc/oprofile/op_model_cell.c | ||
38 | +++ b/arch/powerpc/oprofile/op_model_cell.c | ||
39 | @@ -821,7 +821,7 @@ static int calculate_lfsr(int n) | ||
40 | index = ENTRIES-1; | ||
41 | |||
42 | /* make sure index is valid */ | ||
43 | - if ((index > ENTRIES) || (index < 0)) | ||
44 | + if ((index >= ENTRIES) || (index < 0)) | ||
45 | index = ENTRIES-1; | ||
46 | |||
47 | return initial_lfsr[index]; | ||
48 | diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c | ||
49 | index 1f03248..ca5e7b0 100644 | ||
50 | --- a/arch/powerpc/platforms/pseries/hotplug-cpu.c | ||
51 | +++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c | ||
52 | @@ -66,30 +66,6 @@ static void pseries_mach_cpu_die(void) | ||
53 | for(;;); | ||
54 | } | ||
55 | |||
56 | -static int qcss_tok; /* query-cpu-stopped-state token */ | ||
57 | - | ||
58 | -/* Get state of physical CPU. | ||
59 | - * Return codes: | ||
60 | - * 0 - The processor is in the RTAS stopped state | ||
61 | - * 1 - stop-self is in progress | ||
62 | - * 2 - The processor is not in the RTAS stopped state | ||
63 | - * -1 - Hardware Error | ||
64 | - * -2 - Hardware Busy, Try again later. | ||
65 | - */ | ||
66 | -static int query_cpu_stopped(unsigned int pcpu) | ||
67 | -{ | ||
68 | - int cpu_status, status; | ||
69 | - | ||
70 | - status = rtas_call(qcss_tok, 1, 2, &cpu_status, pcpu); | ||
71 | - if (status != 0) { | ||
72 | - printk(KERN_ERR | ||
73 | - "RTAS query-cpu-stopped-state failed: %i\n", status); | ||
74 | - return status; | ||
75 | - } | ||
76 | - | ||
77 | - return cpu_status; | ||
78 | -} | ||
79 | - | ||
80 | static int pseries_cpu_disable(void) | ||
81 | { | ||
82 | int cpu = smp_processor_id(); | ||
83 | @@ -113,8 +89,9 @@ static void pseries_cpu_die(unsigned int cpu) | ||
84 | unsigned int pcpu = get_hard_smp_processor_id(cpu); | ||
85 | |||
86 | for (tries = 0; tries < 25; tries++) { | ||
87 | - cpu_status = query_cpu_stopped(pcpu); | ||
88 | - if (cpu_status == 0 || cpu_status == -1) | ||
89 | + cpu_status = smp_query_cpu_stopped(pcpu); | ||
90 | + if (cpu_status == QCSS_STOPPED || | ||
91 | + cpu_status == QCSS_HARDWARE_ERROR) | ||
92 | break; | ||
93 | msleep(200); | ||
94 | } | ||
95 | @@ -256,6 +233,7 @@ static int __init pseries_cpu_hotplug_init(void) | ||
96 | { | ||
97 | struct device_node *np; | ||
98 | const char *typep; | ||
99 | + int qcss_tok; | ||
100 | |||
101 | for_each_node_by_name(np, "interrupt-controller") { | ||
102 | typep = of_get_property(np, "compatible", NULL); | ||
103 | diff --git a/arch/powerpc/platforms/pseries/plpar_wrappers.h b/arch/powerpc/platforms/pseries/plpar_wrappers.h | ||
104 | index d967c18..1adef11 100644 | ||
105 | --- a/arch/powerpc/platforms/pseries/plpar_wrappers.h | ||
106 | +++ b/arch/powerpc/platforms/pseries/plpar_wrappers.h | ||
107 | @@ -4,6 +4,14 @@ | ||
108 | #include <asm/hvcall.h> | ||
109 | #include <asm/page.h> | ||
110 | |||
111 | +/* Get state of physical CPU from query_cpu_stopped */ | ||
112 | +int smp_query_cpu_stopped(unsigned int pcpu); | ||
113 | +#define QCSS_STOPPED 0 | ||
114 | +#define QCSS_STOPPING 1 | ||
115 | +#define QCSS_NOT_STOPPED 2 | ||
116 | +#define QCSS_HARDWARE_ERROR -1 | ||
117 | +#define QCSS_HARDWARE_BUSY -2 | ||
118 | + | ||
119 | static inline long poll_pending(void) | ||
120 | { | ||
121 | return plpar_hcall_norets(H_POLL_PENDING); | ||
122 | diff --git a/arch/powerpc/platforms/pseries/smp.c b/arch/powerpc/platforms/pseries/smp.c | ||
123 | index c9337c7..db0cbbb 100644 | ||
124 | --- a/arch/powerpc/platforms/pseries/smp.c | ||
125 | +++ b/arch/powerpc/platforms/pseries/smp.c | ||
126 | @@ -59,6 +59,28 @@ static cpumask_t of_spin_map; | ||
127 | |||
128 | extern void generic_secondary_smp_init(unsigned long); | ||
129 | |||
130 | +/* Query where a cpu is now. Return codes #defined in plpar_wrappers.h */ | ||
131 | +int smp_query_cpu_stopped(unsigned int pcpu) | ||
132 | +{ | ||
133 | + int cpu_status, status; | ||
134 | + int qcss_tok = rtas_token("query-cpu-stopped-state"); | ||
135 | + | ||
136 | + if (qcss_tok == RTAS_UNKNOWN_SERVICE) { | ||
137 | + printk(KERN_INFO "Firmware doesn't support " | ||
138 | + "query-cpu-stopped-state\n"); | ||
139 | + return QCSS_HARDWARE_ERROR; | ||
140 | + } | ||
141 | + | ||
142 | + status = rtas_call(qcss_tok, 1, 2, &cpu_status, pcpu); | ||
143 | + if (status != 0) { | ||
144 | + printk(KERN_ERR | ||
145 | + "RTAS query-cpu-stopped-state failed: %i\n", status); | ||
146 | + return status; | ||
147 | + } | ||
148 | + | ||
149 | + return cpu_status; | ||
150 | +} | ||
151 | + | ||
152 | /** | ||
153 | * smp_startup_cpu() - start the given cpu | ||
154 | * | ||
155 | @@ -84,6 +106,12 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu) | ||
156 | |||
157 | pcpu = get_hard_smp_processor_id(lcpu); | ||
158 | |||
159 | + /* Check to see if the CPU out of FW already for kexec */ | ||
160 | + if (smp_query_cpu_stopped(pcpu) == QCSS_NOT_STOPPED){ | ||
161 | + cpu_set(lcpu, of_spin_map); | ||
162 | + return 1; | ||
163 | + } | ||
164 | + | ||
165 | /* Fixup atomic count: it exited inside IRQ handler. */ | ||
166 | task_thread_info(paca[lcpu].__current)->preempt_count = 0; | ||
167 | |||
168 | diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c | ||
169 | index 8afc274..512c281 100644 | ||
170 | --- a/drivers/ata/libata-core.c | ||
171 | +++ b/drivers/ata/libata-core.c | ||
172 | @@ -157,6 +157,10 @@ int libata_allow_tpm = 0; | ||
173 | module_param_named(allow_tpm, libata_allow_tpm, int, 0444); | ||
174 | MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands"); | ||
175 | |||
176 | +static int atapi_an; | ||
177 | +module_param(atapi_an, int, 0444); | ||
178 | +MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)"); | ||
179 | + | ||
180 | MODULE_AUTHOR("Jeff Garzik"); | ||
181 | MODULE_DESCRIPTION("Library module for ATA devices"); | ||
182 | MODULE_LICENSE("GPL"); | ||
183 | @@ -2341,7 +2345,8 @@ int ata_dev_configure(struct ata_device *dev) | ||
184 | * to enable ATAPI AN to discern between PHY status | ||
185 | * changed notifications and ATAPI ANs. | ||
186 | */ | ||
187 | - if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) && | ||
188 | + if (atapi_an && | ||
189 | + (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) && | ||
190 | (!sata_pmp_attached(ap) || | ||
191 | sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) { | ||
192 | unsigned int err_mask; | ||
193 | diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c | ||
194 | index 7e860da..604c991 100644 | ||
195 | --- a/drivers/char/ipmi/ipmi_si_intf.c | ||
196 | +++ b/drivers/char/ipmi/ipmi_si_intf.c | ||
197 | @@ -313,9 +313,14 @@ static void deliver_recv_msg(struct smi_info *smi_info, | ||
198 | { | ||
199 | /* Deliver the message to the upper layer with the lock | ||
200 | released. */ | ||
201 | - spin_unlock(&(smi_info->si_lock)); | ||
202 | - ipmi_smi_msg_received(smi_info->intf, msg); | ||
203 | - spin_lock(&(smi_info->si_lock)); | ||
204 | + | ||
205 | + if (smi_info->run_to_completion) { | ||
206 | + ipmi_smi_msg_received(smi_info->intf, msg); | ||
207 | + } else { | ||
208 | + spin_unlock(&(smi_info->si_lock)); | ||
209 | + ipmi_smi_msg_received(smi_info->intf, msg); | ||
210 | + spin_lock(&(smi_info->si_lock)); | ||
211 | + } | ||
212 | } | ||
213 | |||
214 | static void return_hosed_msg(struct smi_info *smi_info, int cCode) | ||
215 | diff --git a/drivers/md/md.c b/drivers/md/md.c | ||
216 | index b60d328..4d96950 100644 | ||
217 | --- a/drivers/md/md.c | ||
218 | +++ b/drivers/md/md.c | ||
219 | @@ -4816,6 +4816,7 @@ static int md_ioctl(struct inode *inode, struct file *file, | ||
220 | int err = 0; | ||
221 | void __user *argp = (void __user *)arg; | ||
222 | mddev_t *mddev = NULL; | ||
223 | + int ro; | ||
224 | |||
225 | if (!capable(CAP_SYS_ADMIN)) | ||
226 | return -EACCES; | ||
227 | @@ -4951,6 +4952,34 @@ static int md_ioctl(struct inode *inode, struct file *file, | ||
228 | err = do_md_stop (mddev, 1, 1); | ||
229 | goto done_unlock; | ||
230 | |||
231 | + case BLKROSET: | ||
232 | + if (get_user(ro, (int __user *)(arg))) { | ||
233 | + err = -EFAULT; | ||
234 | + goto done_unlock; | ||
235 | + } | ||
236 | + err = -EINVAL; | ||
237 | + | ||
238 | + /* if the bdev is going readonly the value of mddev->ro | ||
239 | + * does not matter, no writes are coming | ||
240 | + */ | ||
241 | + if (ro) | ||
242 | + goto done_unlock; | ||
243 | + | ||
244 | + /* are we are already prepared for writes? */ | ||
245 | + if (mddev->ro != 1) | ||
246 | + goto done_unlock; | ||
247 | + | ||
248 | + /* transitioning to readauto need only happen for | ||
249 | + * arrays that call md_write_start | ||
250 | + */ | ||
251 | + if (mddev->pers) { | ||
252 | + err = restart_array(mddev); | ||
253 | + if (err == 0) { | ||
254 | + mddev->ro = 2; | ||
255 | + set_disk_ro(mddev->gendisk, 0); | ||
256 | + } | ||
257 | + } | ||
258 | + goto done_unlock; | ||
259 | } | ||
260 | |||
261 | /* | ||
262 | diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c | ||
263 | index 2b510a3..4b78069 100644 | ||
264 | --- a/drivers/md/raid1.c | ||
265 | +++ b/drivers/md/raid1.c | ||
266 | @@ -413,7 +413,7 @@ static void raid1_end_write_request(struct bio *bio, int error) | ||
267 | */ | ||
268 | static int read_balance(conf_t *conf, r1bio_t *r1_bio) | ||
269 | { | ||
270 | - const unsigned long this_sector = r1_bio->sector; | ||
271 | + const sector_t this_sector = r1_bio->sector; | ||
272 | int new_disk = conf->last_used, disk = new_disk; | ||
273 | int wonly_disk = -1; | ||
274 | const int sectors = r1_bio->sectors; | ||
275 | @@ -429,7 +429,7 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio) | ||
276 | retry: | ||
277 | if (conf->mddev->recovery_cp < MaxSector && | ||
278 | (this_sector + sectors >= conf->next_resync)) { | ||
279 | - /* Choose the first operation device, for consistancy */ | ||
280 | + /* Choose the first operational device, for consistancy */ | ||
281 | new_disk = 0; | ||
282 | |||
283 | for (rdev = rcu_dereference(conf->mirrors[new_disk].rdev); | ||
284 | @@ -879,9 +879,10 @@ static int make_request(struct request_queue *q, struct bio * bio) | ||
285 | if (test_bit(Faulty, &rdev->flags)) { | ||
286 | rdev_dec_pending(rdev, mddev); | ||
287 | r1_bio->bios[i] = NULL; | ||
288 | - } else | ||
289 | + } else { | ||
290 | r1_bio->bios[i] = bio; | ||
291 | - targets++; | ||
292 | + targets++; | ||
293 | + } | ||
294 | } else | ||
295 | r1_bio->bios[i] = NULL; | ||
296 | } | ||
297 | diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c | ||
298 | index b08dd95..dbf51e9 100644 | ||
299 | --- a/drivers/md/raid10.c | ||
300 | +++ b/drivers/md/raid10.c | ||
301 | @@ -490,7 +490,7 @@ static int raid10_mergeable_bvec(struct request_queue *q, | ||
302 | */ | ||
303 | static int read_balance(conf_t *conf, r10bio_t *r10_bio) | ||
304 | { | ||
305 | - const unsigned long this_sector = r10_bio->sector; | ||
306 | + const sector_t this_sector = r10_bio->sector; | ||
307 | int disk, slot, nslot; | ||
308 | const int sectors = r10_bio->sectors; | ||
309 | sector_t new_distance, current_distance; | ||
310 | diff --git a/drivers/net/arcnet/com20020-pci.c b/drivers/net/arcnet/com20020-pci.c | ||
311 | index b8c0fa6..0477bd1 100644 | ||
312 | --- a/drivers/net/arcnet/com20020-pci.c | ||
313 | +++ b/drivers/net/arcnet/com20020-pci.c | ||
314 | @@ -162,8 +162,8 @@ static struct pci_device_id com20020pci_id_table[] = { | ||
315 | { 0x1571, 0xa204, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
316 | { 0x1571, 0xa205, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
317 | { 0x1571, 0xa206, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
318 | - { 0x10B5, 0x9030, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
319 | - { 0x10B5, 0x9050, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
320 | + { 0x10B5, 0x9030, 0x10B5, 0x2978, 0, 0, ARC_CAN_10MBIT }, | ||
321 | + { 0x10B5, 0x9050, 0x10B5, 0x2273, 0, 0, ARC_CAN_10MBIT }, | ||
322 | { 0x14BA, 0x6000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
323 | { 0x10B5, 0x2200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ARC_CAN_10MBIT }, | ||
324 | {0,} | ||
325 | diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c | ||
326 | index a67f837..536e392 100644 | ||
327 | --- a/fs/ext4/inode.c | ||
328 | +++ b/fs/ext4/inode.c | ||
329 | @@ -1721,7 +1721,11 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd) | ||
330 | |||
331 | pages_skipped = mpd->wbc->pages_skipped; | ||
332 | err = mapping->a_ops->writepage(page, mpd->wbc); | ||
333 | - if (!err) | ||
334 | + if (!err && (pages_skipped == mpd->wbc->pages_skipped)) | ||
335 | + /* | ||
336 | + * have successfully written the page | ||
337 | + * without skipping the same | ||
338 | + */ | ||
339 | mpd->pages_written++; | ||
340 | /* | ||
341 | * In error case, we have to continue because | ||
342 | @@ -2059,17 +2063,6 @@ static int __mpage_da_writepage(struct page *page, | ||
343 | struct buffer_head *bh, *head, fake; | ||
344 | sector_t logical; | ||
345 | |||
346 | - if (mpd->io_done) { | ||
347 | - /* | ||
348 | - * Rest of the page in the page_vec | ||
349 | - * redirty then and skip then. We will | ||
350 | - * try to to write them again after | ||
351 | - * starting a new transaction | ||
352 | - */ | ||
353 | - redirty_page_for_writepage(wbc, page); | ||
354 | - unlock_page(page); | ||
355 | - return MPAGE_DA_EXTENT_TAIL; | ||
356 | - } | ||
357 | /* | ||
358 | * Can we merge this page to current extent? | ||
359 | */ | ||
360 | @@ -2160,6 +2153,137 @@ static int __mpage_da_writepage(struct page *page, | ||
361 | } | ||
362 | |||
363 | /* | ||
364 | + * write_cache_pages_da - walk the list of dirty pages of the given | ||
365 | + * address space and call the callback function (which usually writes | ||
366 | + * the pages). | ||
367 | + * | ||
368 | + * This is a forked version of write_cache_pages(). Differences: | ||
369 | + * Range cyclic is ignored. | ||
370 | + * no_nrwrite_index_update is always presumed true | ||
371 | + */ | ||
372 | +static int write_cache_pages_da(struct address_space *mapping, | ||
373 | + struct writeback_control *wbc, | ||
374 | + struct mpage_da_data *mpd) | ||
375 | +{ | ||
376 | + struct backing_dev_info *bdi = mapping->backing_dev_info; | ||
377 | + int ret = 0; | ||
378 | + int done = 0; | ||
379 | + struct pagevec pvec; | ||
380 | + int nr_pages; | ||
381 | + pgoff_t index; | ||
382 | + pgoff_t end; /* Inclusive */ | ||
383 | + long nr_to_write = wbc->nr_to_write; | ||
384 | + | ||
385 | + if (wbc->nonblocking && bdi_write_congested(bdi)) { | ||
386 | + wbc->encountered_congestion = 1; | ||
387 | + return 0; | ||
388 | + } | ||
389 | + | ||
390 | + pagevec_init(&pvec, 0); | ||
391 | + index = wbc->range_start >> PAGE_CACHE_SHIFT; | ||
392 | + end = wbc->range_end >> PAGE_CACHE_SHIFT; | ||
393 | + | ||
394 | + while (!done && (index <= end)) { | ||
395 | + int i; | ||
396 | + | ||
397 | + nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, | ||
398 | + PAGECACHE_TAG_DIRTY, | ||
399 | + min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1); | ||
400 | + if (nr_pages == 0) | ||
401 | + break; | ||
402 | + | ||
403 | + for (i = 0; i < nr_pages; i++) { | ||
404 | + struct page *page = pvec.pages[i]; | ||
405 | + | ||
406 | + /* | ||
407 | + * At this point, the page may be truncated or | ||
408 | + * invalidated (changing page->mapping to NULL), or | ||
409 | + * even swizzled back from swapper_space to tmpfs file | ||
410 | + * mapping. However, page->index will not change | ||
411 | + * because we have a reference on the page. | ||
412 | + */ | ||
413 | + if (page->index > end) { | ||
414 | + done = 1; | ||
415 | + break; | ||
416 | + } | ||
417 | + | ||
418 | + lock_page(page); | ||
419 | + | ||
420 | + /* | ||
421 | + * Page truncated or invalidated. We can freely skip it | ||
422 | + * then, even for data integrity operations: the page | ||
423 | + * has disappeared concurrently, so there could be no | ||
424 | + * real expectation of this data interity operation | ||
425 | + * even if there is now a new, dirty page at the same | ||
426 | + * pagecache address. | ||
427 | + */ | ||
428 | + if (unlikely(page->mapping != mapping)) { | ||
429 | +continue_unlock: | ||
430 | + unlock_page(page); | ||
431 | + continue; | ||
432 | + } | ||
433 | + | ||
434 | + if (!PageDirty(page)) { | ||
435 | + /* someone wrote it for us */ | ||
436 | + goto continue_unlock; | ||
437 | + } | ||
438 | + | ||
439 | + if (PageWriteback(page)) { | ||
440 | + if (wbc->sync_mode != WB_SYNC_NONE) | ||
441 | + wait_on_page_writeback(page); | ||
442 | + else | ||
443 | + goto continue_unlock; | ||
444 | + } | ||
445 | + | ||
446 | + BUG_ON(PageWriteback(page)); | ||
447 | + if (!clear_page_dirty_for_io(page)) | ||
448 | + goto continue_unlock; | ||
449 | + | ||
450 | + ret = __mpage_da_writepage(page, wbc, mpd); | ||
451 | + | ||
452 | + if (unlikely(ret)) { | ||
453 | + if (ret == AOP_WRITEPAGE_ACTIVATE) { | ||
454 | + unlock_page(page); | ||
455 | + ret = 0; | ||
456 | + } else { | ||
457 | + done = 1; | ||
458 | + break; | ||
459 | + } | ||
460 | + } | ||
461 | + | ||
462 | + if (nr_to_write > 0) { | ||
463 | + nr_to_write--; | ||
464 | + if (nr_to_write == 0 && | ||
465 | + wbc->sync_mode == WB_SYNC_NONE) { | ||
466 | + /* | ||
467 | + * We stop writing back only if we are | ||
468 | + * not doing integrity sync. In case of | ||
469 | + * integrity sync we have to keep going | ||
470 | + * because someone may be concurrently | ||
471 | + * dirtying pages, and we might have | ||
472 | + * synced a lot of newly appeared dirty | ||
473 | + * pages, but have not synced all of the | ||
474 | + * old dirty pages. | ||
475 | + */ | ||
476 | + done = 1; | ||
477 | + break; | ||
478 | + } | ||
479 | + } | ||
480 | + | ||
481 | + if (wbc->nonblocking && bdi_write_congested(bdi)) { | ||
482 | + wbc->encountered_congestion = 1; | ||
483 | + done = 1; | ||
484 | + break; | ||
485 | + } | ||
486 | + } | ||
487 | + pagevec_release(&pvec); | ||
488 | + cond_resched(); | ||
489 | + } | ||
490 | + return ret; | ||
491 | +} | ||
492 | + | ||
493 | + | ||
494 | +/* | ||
495 | * mpage_da_writepages - walk the list of dirty pages of the given | ||
496 | * address space, allocates non-allocated blocks, maps newly-allocated | ||
497 | * blocks to existing bhs and issue IO them | ||
498 | @@ -2175,7 +2299,6 @@ static int mpage_da_writepages(struct address_space *mapping, | ||
499 | struct writeback_control *wbc, | ||
500 | struct mpage_da_data *mpd) | ||
501 | { | ||
502 | - long to_write; | ||
503 | int ret; | ||
504 | |||
505 | if (!mpd->get_block) | ||
506 | @@ -2190,19 +2313,18 @@ static int mpage_da_writepages(struct address_space *mapping, | ||
507 | mpd->pages_written = 0; | ||
508 | mpd->retval = 0; | ||
509 | |||
510 | - to_write = wbc->nr_to_write; | ||
511 | - | ||
512 | - ret = write_cache_pages(mapping, wbc, __mpage_da_writepage, mpd); | ||
513 | - | ||
514 | + ret = write_cache_pages_da(mapping, wbc, mpd); | ||
515 | /* | ||
516 | * Handle last extent of pages | ||
517 | */ | ||
518 | if (!mpd->io_done && mpd->next_page != mpd->first_page) { | ||
519 | if (mpage_da_map_blocks(mpd) == 0) | ||
520 | mpage_da_submit_io(mpd); | ||
521 | - } | ||
522 | |||
523 | - wbc->nr_to_write = to_write - mpd->pages_written; | ||
524 | + mpd->io_done = 1; | ||
525 | + ret = MPAGE_DA_EXTENT_TAIL; | ||
526 | + } | ||
527 | + wbc->nr_to_write -= mpd->pages_written; | ||
528 | return ret; | ||
529 | } | ||
530 | |||
531 | @@ -2447,11 +2569,14 @@ static int ext4_da_writepages_trans_blocks(struct inode *inode) | ||
532 | static int ext4_da_writepages(struct address_space *mapping, | ||
533 | struct writeback_control *wbc) | ||
534 | { | ||
535 | + pgoff_t index; | ||
536 | + int range_whole = 0; | ||
537 | handle_t *handle = NULL; | ||
538 | struct mpage_da_data mpd; | ||
539 | struct inode *inode = mapping->host; | ||
540 | + long pages_written = 0, pages_skipped; | ||
541 | + int range_cyclic, cycled = 1, io_done = 0; | ||
542 | int needed_blocks, ret = 0, nr_to_writebump = 0; | ||
543 | - long to_write, pages_skipped = 0; | ||
544 | struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb); | ||
545 | |||
546 | /* | ||
547 | @@ -2485,16 +2610,27 @@ static int ext4_da_writepages(struct address_space *mapping, | ||
548 | nr_to_writebump = sbi->s_mb_stream_request - wbc->nr_to_write; | ||
549 | wbc->nr_to_write = sbi->s_mb_stream_request; | ||
550 | } | ||
551 | - | ||
552 | - | ||
553 | - pages_skipped = wbc->pages_skipped; | ||
554 | + if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) | ||
555 | + range_whole = 1; | ||
556 | + | ||
557 | + range_cyclic = wbc->range_cyclic; | ||
558 | + if (wbc->range_cyclic) { | ||
559 | + index = mapping->writeback_index; | ||
560 | + if (index) | ||
561 | + cycled = 0; | ||
562 | + wbc->range_start = index << PAGE_CACHE_SHIFT; | ||
563 | + wbc->range_end = LLONG_MAX; | ||
564 | + wbc->range_cyclic = 0; | ||
565 | + } else | ||
566 | + index = wbc->range_start >> PAGE_CACHE_SHIFT; | ||
567 | |||
568 | mpd.wbc = wbc; | ||
569 | mpd.inode = mapping->host; | ||
570 | |||
571 | -restart_loop: | ||
572 | - to_write = wbc->nr_to_write; | ||
573 | - while (!ret && to_write > 0) { | ||
574 | + pages_skipped = wbc->pages_skipped; | ||
575 | + | ||
576 | +retry: | ||
577 | + while (!ret && wbc->nr_to_write > 0) { | ||
578 | |||
579 | /* | ||
580 | * we insert one extent at a time. So we need | ||
581 | @@ -2527,46 +2663,60 @@ restart_loop: | ||
582 | goto out_writepages; | ||
583 | } | ||
584 | } | ||
585 | - to_write -= wbc->nr_to_write; | ||
586 | - | ||
587 | mpd.get_block = ext4_da_get_block_write; | ||
588 | ret = mpage_da_writepages(mapping, wbc, &mpd); | ||
589 | |||
590 | ext4_journal_stop(handle); | ||
591 | |||
592 | - if (mpd.retval == -ENOSPC) | ||
593 | + if (mpd.retval == -ENOSPC) { | ||
594 | + /* commit the transaction which would | ||
595 | + * free blocks released in the transaction | ||
596 | + * and try again | ||
597 | + */ | ||
598 | jbd2_journal_force_commit_nested(sbi->s_journal); | ||
599 | - | ||
600 | - /* reset the retry count */ | ||
601 | - if (ret == MPAGE_DA_EXTENT_TAIL) { | ||
602 | + wbc->pages_skipped = pages_skipped; | ||
603 | + ret = 0; | ||
604 | + } else if (ret == MPAGE_DA_EXTENT_TAIL) { | ||
605 | /* | ||
606 | * got one extent now try with | ||
607 | * rest of the pages | ||
608 | */ | ||
609 | - to_write += wbc->nr_to_write; | ||
610 | + pages_written += mpd.pages_written; | ||
611 | + wbc->pages_skipped = pages_skipped; | ||
612 | ret = 0; | ||
613 | - } else if (wbc->nr_to_write) { | ||
614 | + io_done = 1; | ||
615 | + } else if (wbc->nr_to_write) | ||
616 | /* | ||
617 | * There is no more writeout needed | ||
618 | * or we requested for a noblocking writeout | ||
619 | * and we found the device congested | ||
620 | */ | ||
621 | - to_write += wbc->nr_to_write; | ||
622 | break; | ||
623 | - } | ||
624 | - wbc->nr_to_write = to_write; | ||
625 | } | ||
626 | - | ||
627 | - if (!wbc->range_cyclic && (pages_skipped != wbc->pages_skipped)) { | ||
628 | - /* We skipped pages in this loop */ | ||
629 | - wbc->nr_to_write = to_write + | ||
630 | - wbc->pages_skipped - pages_skipped; | ||
631 | - wbc->pages_skipped = pages_skipped; | ||
632 | - goto restart_loop; | ||
633 | + if (!io_done && !cycled) { | ||
634 | + cycled = 1; | ||
635 | + index = 0; | ||
636 | + wbc->range_start = index << PAGE_CACHE_SHIFT; | ||
637 | + wbc->range_end = mapping->writeback_index - 1; | ||
638 | + goto retry; | ||
639 | } | ||
640 | + if (pages_skipped != wbc->pages_skipped) | ||
641 | + printk(KERN_EMERG "This should not happen leaving %s " | ||
642 | + "with nr_to_write = %ld ret = %d\n", | ||
643 | + __func__, wbc->nr_to_write, ret); | ||
644 | + | ||
645 | + /* Update index */ | ||
646 | + index += pages_written; | ||
647 | + wbc->range_cyclic = range_cyclic; | ||
648 | + if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) | ||
649 | + /* | ||
650 | + * set the writeback_index so that range_cyclic | ||
651 | + * mode will write it back later | ||
652 | + */ | ||
653 | + mapping->writeback_index = index; | ||
654 | |||
655 | out_writepages: | ||
656 | - wbc->nr_to_write = to_write - nr_to_writebump; | ||
657 | + wbc->nr_to_write -= nr_to_writebump; | ||
658 | return ret; | ||
659 | } | ||
660 | |||
661 | diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c | ||
662 | index 0070431..f7f5995 100644 | ||
663 | --- a/fs/ext4/resize.c | ||
664 | +++ b/fs/ext4/resize.c | ||
665 | @@ -935,7 +935,8 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) | ||
666 | percpu_counter_add(&sbi->s_freeinodes_counter, | ||
667 | EXT4_INODES_PER_GROUP(sb)); | ||
668 | |||
669 | - if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { | ||
670 | + if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) && | ||
671 | + sbi->s_log_groups_per_flex) { | ||
672 | ext4_group_t flex_group; | ||
673 | flex_group = ext4_flex_group(sbi, input->group); | ||
674 | sbi->s_flex_groups[flex_group].free_blocks += | ||
675 | diff --git a/fs/namespace.c b/fs/namespace.c | ||
676 | index efe0251..2083810 100644 | ||
677 | --- a/fs/namespace.c | ||
678 | +++ b/fs/namespace.c | ||
679 | @@ -1132,8 +1132,15 @@ SYSCALL_DEFINE2(umount, char __user *, name, int, flags) | ||
680 | { | ||
681 | struct path path; | ||
682 | int retval; | ||
683 | + int lookup_flags = 0; | ||
684 | |||
685 | - retval = user_path(name, &path); | ||
686 | + if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW)) | ||
687 | + return -EINVAL; | ||
688 | + | ||
689 | + if (!(flags & UMOUNT_NOFOLLOW)) | ||
690 | + lookup_flags |= LOOKUP_FOLLOW; | ||
691 | + | ||
692 | + retval = user_path_at(AT_FDCWD, name, lookup_flags, &path); | ||
693 | if (retval) | ||
694 | goto out; | ||
695 | retval = -EINVAL; | ||
696 | diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c | ||
697 | index 80292ff..e02db8e 100644 | ||
698 | --- a/fs/nfsd/nfssvc.c | ||
699 | +++ b/fs/nfsd/nfssvc.c | ||
700 | @@ -126,7 +126,7 @@ struct svc_program nfsd_program = { | ||
701 | int nfsd_vers(int vers, enum vers_op change) | ||
702 | { | ||
703 | if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS) | ||
704 | - return -1; | ||
705 | + return 0; | ||
706 | switch(change) { | ||
707 | case NFSD_SET: | ||
708 | nfsd_versions[vers] = nfsd_version[vers]; | ||
709 | diff --git a/include/linux/fs.h b/include/linux/fs.h | ||
710 | index 909e13e..248465c 100644 | ||
711 | --- a/include/linux/fs.h | ||
712 | +++ b/include/linux/fs.h | ||
713 | @@ -1061,6 +1061,8 @@ extern int send_sigurg(struct fown_struct *fown); | ||
714 | #define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */ | ||
715 | #define MNT_DETACH 0x00000002 /* Just detach from the tree */ | ||
716 | #define MNT_EXPIRE 0x00000004 /* Mark for expiry */ | ||
717 | +#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */ | ||
718 | +#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */ | ||
719 | |||
720 | extern struct list_head super_blocks; | ||
721 | extern spinlock_t sb_lock; | ||
722 | diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h | ||
723 | index ab1c472..0594330 100644 | ||
724 | --- a/include/net/sctp/structs.h | ||
725 | +++ b/include/net/sctp/structs.h | ||
726 | @@ -753,6 +753,7 @@ int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len, | ||
727 | struct iovec *data); | ||
728 | void sctp_chunk_free(struct sctp_chunk *); | ||
729 | void *sctp_addto_chunk(struct sctp_chunk *, int len, const void *data); | ||
730 | +void *sctp_addto_chunk_fixed(struct sctp_chunk *, int len, const void *data); | ||
731 | struct sctp_chunk *sctp_chunkify(struct sk_buff *, | ||
732 | const struct sctp_association *, | ||
733 | struct sock *); | ||
734 | diff --git a/mm/filemap.c b/mm/filemap.c | ||
735 | index bff0b00..a4800c5 100644 | ||
736 | --- a/mm/filemap.c | ||
737 | +++ b/mm/filemap.c | ||
738 | @@ -1118,6 +1118,12 @@ page_not_up_to_date_locked: | ||
739 | } | ||
740 | |||
741 | readpage: | ||
742 | + /* | ||
743 | + * A previous I/O error may have been due to temporary | ||
744 | + * failures, eg. multipath errors. | ||
745 | + * PG_error will be set again if readpage fails. | ||
746 | + */ | ||
747 | + ClearPageError(page); | ||
748 | /* Start the actual read. The read will unlock the page. */ | ||
749 | error = mapping->a_ops->readpage(filp, page); | ||
750 | |||
751 | diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c | ||
752 | index d68869f..baf2fa4 100644 | ||
753 | --- a/net/sctp/sm_make_chunk.c | ||
754 | +++ b/net/sctp/sm_make_chunk.c | ||
755 | @@ -107,7 +107,7 @@ static const struct sctp_paramhdr prsctp_param = { | ||
756 | __constant_htons(sizeof(struct sctp_paramhdr)), | ||
757 | }; | ||
758 | |||
759 | -/* A helper to initialize to initialize an op error inside a | ||
760 | +/* A helper to initialize an op error inside a | ||
761 | * provided chunk, as most cause codes will be embedded inside an | ||
762 | * abort chunk. | ||
763 | */ | ||
764 | @@ -124,6 +124,29 @@ void sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code, | ||
765 | chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err); | ||
766 | } | ||
767 | |||
768 | +/* A helper to initialize an op error inside a | ||
769 | + * provided chunk, as most cause codes will be embedded inside an | ||
770 | + * abort chunk. Differs from sctp_init_cause in that it won't oops | ||
771 | + * if there isn't enough space in the op error chunk | ||
772 | + */ | ||
773 | +int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code, | ||
774 | + size_t paylen) | ||
775 | +{ | ||
776 | + sctp_errhdr_t err; | ||
777 | + __u16 len; | ||
778 | + | ||
779 | + /* Cause code constants are now defined in network order. */ | ||
780 | + err.cause = cause_code; | ||
781 | + len = sizeof(sctp_errhdr_t) + paylen; | ||
782 | + err.length = htons(len); | ||
783 | + | ||
784 | + if (skb_tailroom(chunk->skb) < len) | ||
785 | + return -ENOSPC; | ||
786 | + chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk, | ||
787 | + sizeof(sctp_errhdr_t), | ||
788 | + &err); | ||
789 | + return 0; | ||
790 | +} | ||
791 | /* 3.3.2 Initiation (INIT) (1) | ||
792 | * | ||
793 | * This chunk is used to initiate a SCTP association between two | ||
794 | @@ -1114,6 +1137,24 @@ nodata: | ||
795 | return retval; | ||
796 | } | ||
797 | |||
798 | +/* Create an Operation Error chunk of a fixed size, | ||
799 | + * specifically, max(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT) | ||
800 | + * This is a helper function to allocate an error chunk for | ||
801 | + * for those invalid parameter codes in which we may not want | ||
802 | + * to report all the errors, if the incomming chunk is large | ||
803 | + */ | ||
804 | +static inline struct sctp_chunk *sctp_make_op_error_fixed( | ||
805 | + const struct sctp_association *asoc, | ||
806 | + const struct sctp_chunk *chunk) | ||
807 | +{ | ||
808 | + size_t size = asoc ? asoc->pathmtu : 0; | ||
809 | + | ||
810 | + if (!size) | ||
811 | + size = SCTP_DEFAULT_MAXSEGMENT; | ||
812 | + | ||
813 | + return sctp_make_op_error_space(asoc, chunk, size); | ||
814 | +} | ||
815 | + | ||
816 | /* Create an Operation Error chunk. */ | ||
817 | struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc, | ||
818 | const struct sctp_chunk *chunk, | ||
819 | @@ -1354,6 +1395,18 @@ void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data) | ||
820 | return target; | ||
821 | } | ||
822 | |||
823 | +/* Append bytes to the end of a chunk. Returns NULL if there isn't sufficient | ||
824 | + * space in the chunk | ||
825 | + */ | ||
826 | +void *sctp_addto_chunk_fixed(struct sctp_chunk *chunk, | ||
827 | + int len, const void *data) | ||
828 | +{ | ||
829 | + if (skb_tailroom(chunk->skb) >= len) | ||
830 | + return sctp_addto_chunk(chunk, len, data); | ||
831 | + else | ||
832 | + return NULL; | ||
833 | +} | ||
834 | + | ||
835 | /* Append bytes from user space to the end of a chunk. Will panic if | ||
836 | * chunk is not big enough. | ||
837 | * Returns a kernel err value. | ||
838 | @@ -1957,13 +2010,12 @@ static sctp_ierror_t sctp_process_unk_param(const struct sctp_association *asoc, | ||
839 | * returning multiple unknown parameters. | ||
840 | */ | ||
841 | if (NULL == *errp) | ||
842 | - *errp = sctp_make_op_error_space(asoc, chunk, | ||
843 | - ntohs(chunk->chunk_hdr->length)); | ||
844 | + *errp = sctp_make_op_error_fixed(asoc, chunk); | ||
845 | |||
846 | if (*errp) { | ||
847 | - sctp_init_cause(*errp, SCTP_ERROR_UNKNOWN_PARAM, | ||
848 | + sctp_init_cause_fixed(*errp, SCTP_ERROR_UNKNOWN_PARAM, | ||
849 | WORD_ROUND(ntohs(param.p->length))); | ||
850 | - sctp_addto_chunk(*errp, | ||
851 | + sctp_addto_chunk_fixed(*errp, | ||
852 | WORD_ROUND(ntohs(param.p->length)), | ||
853 | param.v); | ||
854 | } else { | ||
855 | diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c | ||
856 | index a7a3677..a2a53e8 100644 | ||
857 | --- a/net/tipc/bearer.c | ||
858 | +++ b/net/tipc/bearer.c | ||
859 | @@ -45,10 +45,10 @@ | ||
860 | |||
861 | #define MAX_ADDR_STR 32 | ||
862 | |||
863 | -static struct media *media_list = NULL; | ||
864 | +static struct media media_list[MAX_MEDIA]; | ||
865 | static u32 media_count = 0; | ||
866 | |||
867 | -struct bearer *tipc_bearers = NULL; | ||
868 | +struct bearer tipc_bearers[MAX_BEARERS]; | ||
869 | |||
870 | /** | ||
871 | * media_name_valid - validate media name | ||
872 | @@ -108,9 +108,11 @@ int tipc_register_media(u32 media_type, | ||
873 | int res = -EINVAL; | ||
874 | |||
875 | write_lock_bh(&tipc_net_lock); | ||
876 | - if (!media_list) | ||
877 | - goto exit; | ||
878 | |||
879 | + if (tipc_mode != TIPC_NET_MODE) { | ||
880 | + warn("Media <%s> rejected, not in networked mode yet\n", name); | ||
881 | + goto exit; | ||
882 | + } | ||
883 | if (!media_name_valid(name)) { | ||
884 | warn("Media <%s> rejected, illegal name\n", name); | ||
885 | goto exit; | ||
886 | @@ -660,33 +662,10 @@ int tipc_disable_bearer(const char *name) | ||
887 | |||
888 | |||
889 | |||
890 | -int tipc_bearer_init(void) | ||
891 | -{ | ||
892 | - int res; | ||
893 | - | ||
894 | - write_lock_bh(&tipc_net_lock); | ||
895 | - tipc_bearers = kcalloc(MAX_BEARERS, sizeof(struct bearer), GFP_ATOMIC); | ||
896 | - media_list = kcalloc(MAX_MEDIA, sizeof(struct media), GFP_ATOMIC); | ||
897 | - if (tipc_bearers && media_list) { | ||
898 | - res = 0; | ||
899 | - } else { | ||
900 | - kfree(tipc_bearers); | ||
901 | - kfree(media_list); | ||
902 | - tipc_bearers = NULL; | ||
903 | - media_list = NULL; | ||
904 | - res = -ENOMEM; | ||
905 | - } | ||
906 | - write_unlock_bh(&tipc_net_lock); | ||
907 | - return res; | ||
908 | -} | ||
909 | - | ||
910 | void tipc_bearer_stop(void) | ||
911 | { | ||
912 | u32 i; | ||
913 | |||
914 | - if (!tipc_bearers) | ||
915 | - return; | ||
916 | - | ||
917 | for (i = 0; i < MAX_BEARERS; i++) { | ||
918 | if (tipc_bearers[i].active) | ||
919 | tipc_bearers[i].publ.blocked = 1; | ||
920 | @@ -695,10 +674,6 @@ void tipc_bearer_stop(void) | ||
921 | if (tipc_bearers[i].active) | ||
922 | bearer_disable(tipc_bearers[i].publ.name); | ||
923 | } | ||
924 | - kfree(tipc_bearers); | ||
925 | - kfree(media_list); | ||
926 | - tipc_bearers = NULL; | ||
927 | - media_list = NULL; | ||
928 | media_count = 0; | ||
929 | } | ||
930 | |||
931 | diff --git a/net/tipc/bearer.h b/net/tipc/bearer.h | ||
932 | index ca57348..000228e 100644 | ||
933 | --- a/net/tipc/bearer.h | ||
934 | +++ b/net/tipc/bearer.h | ||
935 | @@ -114,7 +114,7 @@ struct bearer_name { | ||
936 | |||
937 | struct link; | ||
938 | |||
939 | -extern struct bearer *tipc_bearers; | ||
940 | +extern struct bearer tipc_bearers[]; | ||
941 | |||
942 | void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a); | ||
943 | struct sk_buff *tipc_media_get_names(void); | ||
944 | diff --git a/net/tipc/net.c b/net/tipc/net.c | ||
945 | index 7906608..f25b1cd 100644 | ||
946 | --- a/net/tipc/net.c | ||
947 | +++ b/net/tipc/net.c | ||
948 | @@ -116,7 +116,8 @@ | ||
949 | */ | ||
950 | |||
951 | DEFINE_RWLOCK(tipc_net_lock); | ||
952 | -struct network tipc_net = { NULL }; | ||
953 | +struct _zone *tipc_zones[256] = { NULL, }; | ||
954 | +struct network tipc_net = { tipc_zones }; | ||
955 | |||
956 | struct tipc_node *tipc_net_select_remote_node(u32 addr, u32 ref) | ||
957 | { | ||
958 | @@ -158,28 +159,12 @@ void tipc_net_send_external_routes(u32 dest) | ||
959 | } | ||
960 | } | ||
961 | |||
962 | -static int net_init(void) | ||
963 | -{ | ||
964 | - memset(&tipc_net, 0, sizeof(tipc_net)); | ||
965 | - tipc_net.zones = kcalloc(tipc_max_zones + 1, sizeof(struct _zone *), GFP_ATOMIC); | ||
966 | - if (!tipc_net.zones) { | ||
967 | - return -ENOMEM; | ||
968 | - } | ||
969 | - return 0; | ||
970 | -} | ||
971 | - | ||
972 | static void net_stop(void) | ||
973 | { | ||
974 | u32 z_num; | ||
975 | |||
976 | - if (!tipc_net.zones) | ||
977 | - return; | ||
978 | - | ||
979 | - for (z_num = 1; z_num <= tipc_max_zones; z_num++) { | ||
980 | + for (z_num = 1; z_num <= tipc_max_zones; z_num++) | ||
981 | tipc_zone_delete(tipc_net.zones[z_num]); | ||
982 | - } | ||
983 | - kfree(tipc_net.zones); | ||
984 | - tipc_net.zones = NULL; | ||
985 | } | ||
986 | |||
987 | static void net_route_named_msg(struct sk_buff *buf) | ||
988 | @@ -282,9 +267,7 @@ int tipc_net_start(u32 addr) | ||
989 | tipc_named_reinit(); | ||
990 | tipc_port_reinit(); | ||
991 | |||
992 | - if ((res = tipc_bearer_init()) || | ||
993 | - (res = net_init()) || | ||
994 | - (res = tipc_cltr_init()) || | ||
995 | + if ((res = tipc_cltr_init()) || | ||
996 | (res = tipc_bclink_init())) { | ||
997 | return res; | ||
998 | } | ||
999 | diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile | ||
1000 | index fa1a7d5..61acdf1 100644 | ||
1001 | --- a/scripts/kconfig/Makefile | ||
1002 | +++ b/scripts/kconfig/Makefile | ||
1003 | @@ -161,7 +161,7 @@ HOSTCFLAGS_zconf.tab.o := -I$(src) | ||
1004 | HOSTLOADLIBES_qconf = $(KC_QT_LIBS) -ldl | ||
1005 | HOSTCXXFLAGS_qconf.o = $(KC_QT_CFLAGS) -D LKC_DIRECT_LINK | ||
1006 | |||
1007 | -HOSTLOADLIBES_gconf = `pkg-config --libs gtk+-2.0 gmodule-2.0 libglade-2.0` | ||
1008 | +HOSTLOADLIBES_gconf = `pkg-config --libs gtk+-2.0 gmodule-2.0 libglade-2.0` -ldl | ||
1009 | HOSTCFLAGS_gconf.o = `pkg-config --cflags gtk+-2.0 gmodule-2.0 libglade-2.0` \ | ||
1010 | -D LKC_DIRECT_LINK | ||
1011 | |||
1012 | diff --git a/security/keys/keyring.c b/security/keys/keyring.c | ||
1013 | index a9ab8af..594660f 100644 | ||
1014 | --- a/security/keys/keyring.c | ||
1015 | +++ b/security/keys/keyring.c | ||
1016 | @@ -523,9 +523,8 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check) | ||
1017 | struct key *keyring; | ||
1018 | int bucket; | ||
1019 | |||
1020 | - keyring = ERR_PTR(-EINVAL); | ||
1021 | if (!name) | ||
1022 | - goto error; | ||
1023 | + return ERR_PTR(-EINVAL); | ||
1024 | |||
1025 | bucket = keyring_hash(name); | ||
1026 | |||
1027 | @@ -549,17 +548,18 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check) | ||
1028 | KEY_SEARCH) < 0) | ||
1029 | continue; | ||
1030 | |||
1031 | - /* we've got a match */ | ||
1032 | - atomic_inc(&keyring->usage); | ||
1033 | - read_unlock(&keyring_name_lock); | ||
1034 | - goto error; | ||
1035 | + /* we've got a match but we might end up racing with | ||
1036 | + * key_cleanup() if the keyring is currently 'dead' | ||
1037 | + * (ie. it has a zero usage count) */ | ||
1038 | + if (!atomic_inc_not_zero(&keyring->usage)) | ||
1039 | + continue; | ||
1040 | + goto out; | ||
1041 | } | ||
1042 | } | ||
1043 | |||
1044 | - read_unlock(&keyring_name_lock); | ||
1045 | keyring = ERR_PTR(-ENOKEY); | ||
1046 | - | ||
1047 | - error: | ||
1048 | +out: | ||
1049 | + read_unlock(&keyring_name_lock); | ||
1050 | return keyring; | ||
1051 | |||
1052 | } /* end find_keyring_by_name() */ | ||
1053 | diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c | ||
1054 | index 45b240a..b04a2bd 100644 | ||
1055 | --- a/security/keys/process_keys.c | ||
1056 | +++ b/security/keys/process_keys.c | ||
1057 | @@ -592,7 +592,7 @@ key_ref_t lookup_user_key(struct task_struct *context, key_serial_t id, | ||
1058 | |||
1059 | ret = install_thread_keyring(context); | ||
1060 | if (ret < 0) { | ||
1061 | - key = ERR_PTR(ret); | ||
1062 | + key_ref = ERR_PTR(ret); | ||
1063 | goto error; | ||
1064 | } | ||
1065 | } | ||
1066 | @@ -609,7 +609,7 @@ key_ref_t lookup_user_key(struct task_struct *context, key_serial_t id, | ||
1067 | |||
1068 | ret = install_process_keyring(context); | ||
1069 | if (ret < 0) { | ||
1070 | - key = ERR_PTR(ret); | ||
1071 | + key_ref = ERR_PTR(ret); | ||
1072 | goto error; | ||
1073 | } | ||
1074 | } | ||
1075 | @@ -665,7 +665,7 @@ key_ref_t lookup_user_key(struct task_struct *context, key_serial_t id, | ||
1076 | |||
1077 | case KEY_SPEC_GROUP_KEYRING: | ||
1078 | /* group keyrings are not yet supported */ | ||
1079 | - key = ERR_PTR(-EINVAL); | ||
1080 | + key_ref = ERR_PTR(-EINVAL); | ||
1081 | goto error; | ||
1082 | |||
1083 | case KEY_SPEC_REQKEY_AUTH_KEY: |