Root/
1 | /* CPU control. |
2 | * (C) 2001, 2002, 2003, 2004 Rusty Russell |
3 | * |
4 | * This code is licenced under the GPL. |
5 | */ |
6 | #include <linux/proc_fs.h> |
7 | #include <linux/smp.h> |
8 | #include <linux/init.h> |
9 | #include <linux/notifier.h> |
10 | #include <linux/sched.h> |
11 | #include <linux/unistd.h> |
12 | #include <linux/cpu.h> |
13 | #include <linux/module.h> |
14 | #include <linux/kthread.h> |
15 | #include <linux/stop_machine.h> |
16 | #include <linux/mutex.h> |
17 | #include <linux/gfp.h> |
18 | |
19 | #ifdef CONFIG_SMP |
20 | /* Serializes the updates to cpu_online_mask, cpu_present_mask */ |
21 | static DEFINE_MUTEX(cpu_add_remove_lock); |
22 | |
23 | /* |
24 | * The following two API's must be used when attempting |
25 | * to serialize the updates to cpu_online_mask, cpu_present_mask. |
26 | */ |
27 | void cpu_maps_update_begin(void) |
28 | { |
29 | mutex_lock(&cpu_add_remove_lock); |
30 | } |
31 | |
32 | void cpu_maps_update_done(void) |
33 | { |
34 | mutex_unlock(&cpu_add_remove_lock); |
35 | } |
36 | |
37 | static RAW_NOTIFIER_HEAD(cpu_chain); |
38 | |
39 | /* If set, cpu_up and cpu_down will return -EBUSY and do nothing. |
40 | * Should always be manipulated under cpu_add_remove_lock |
41 | */ |
42 | static int cpu_hotplug_disabled; |
43 | |
44 | #ifdef CONFIG_HOTPLUG_CPU |
45 | |
46 | static struct { |
47 | struct task_struct *active_writer; |
48 | struct mutex lock; /* Synchronizes accesses to refcount, */ |
49 | /* |
50 | * Also blocks the new readers during |
51 | * an ongoing cpu hotplug operation. |
52 | */ |
53 | int refcount; |
54 | } cpu_hotplug = { |
55 | .active_writer = NULL, |
56 | .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock), |
57 | .refcount = 0, |
58 | }; |
59 | |
60 | void get_online_cpus(void) |
61 | { |
62 | might_sleep(); |
63 | if (cpu_hotplug.active_writer == current) |
64 | return; |
65 | mutex_lock(&cpu_hotplug.lock); |
66 | cpu_hotplug.refcount++; |
67 | mutex_unlock(&cpu_hotplug.lock); |
68 | |
69 | } |
70 | EXPORT_SYMBOL_GPL(get_online_cpus); |
71 | |
72 | void put_online_cpus(void) |
73 | { |
74 | if (cpu_hotplug.active_writer == current) |
75 | return; |
76 | mutex_lock(&cpu_hotplug.lock); |
77 | if (!--cpu_hotplug.refcount && unlikely(cpu_hotplug.active_writer)) |
78 | wake_up_process(cpu_hotplug.active_writer); |
79 | mutex_unlock(&cpu_hotplug.lock); |
80 | |
81 | } |
82 | EXPORT_SYMBOL_GPL(put_online_cpus); |
83 | |
84 | /* |
85 | * This ensures that the hotplug operation can begin only when the |
86 | * refcount goes to zero. |
87 | * |
88 | * Note that during a cpu-hotplug operation, the new readers, if any, |
89 | * will be blocked by the cpu_hotplug.lock |
90 | * |
91 | * Since cpu_hotplug_begin() is always called after invoking |
92 | * cpu_maps_update_begin(), we can be sure that only one writer is active. |
93 | * |
94 | * Note that theoretically, there is a possibility of a livelock: |
95 | * - Refcount goes to zero, last reader wakes up the sleeping |
96 | * writer. |
97 | * - Last reader unlocks the cpu_hotplug.lock. |
98 | * - A new reader arrives at this moment, bumps up the refcount. |
99 | * - The writer acquires the cpu_hotplug.lock finds the refcount |
100 | * non zero and goes to sleep again. |
101 | * |
102 | * However, this is very difficult to achieve in practice since |
103 | * get_online_cpus() not an api which is called all that often. |
104 | * |
105 | */ |
106 | static void cpu_hotplug_begin(void) |
107 | { |
108 | cpu_hotplug.active_writer = current; |
109 | |
110 | for (;;) { |
111 | mutex_lock(&cpu_hotplug.lock); |
112 | if (likely(!cpu_hotplug.refcount)) |
113 | break; |
114 | __set_current_state(TASK_UNINTERRUPTIBLE); |
115 | mutex_unlock(&cpu_hotplug.lock); |
116 | schedule(); |
117 | } |
118 | } |
119 | |
120 | static void cpu_hotplug_done(void) |
121 | { |
122 | cpu_hotplug.active_writer = NULL; |
123 | mutex_unlock(&cpu_hotplug.lock); |
124 | } |
125 | |
126 | #else /* #if CONFIG_HOTPLUG_CPU */ |
127 | static void cpu_hotplug_begin(void) {} |
128 | static void cpu_hotplug_done(void) {} |
129 | #endif /* #esle #if CONFIG_HOTPLUG_CPU */ |
130 | |
131 | /* Need to know about CPUs going up/down? */ |
132 | int __ref register_cpu_notifier(struct notifier_block *nb) |
133 | { |
134 | int ret; |
135 | cpu_maps_update_begin(); |
136 | ret = raw_notifier_chain_register(&cpu_chain, nb); |
137 | cpu_maps_update_done(); |
138 | return ret; |
139 | } |
140 | |
141 | static int __cpu_notify(unsigned long val, void *v, int nr_to_call, |
142 | int *nr_calls) |
143 | { |
144 | int ret; |
145 | |
146 | ret = __raw_notifier_call_chain(&cpu_chain, val, v, nr_to_call, |
147 | nr_calls); |
148 | |
149 | return notifier_to_errno(ret); |
150 | } |
151 | |
152 | static int cpu_notify(unsigned long val, void *v) |
153 | { |
154 | return __cpu_notify(val, v, -1, NULL); |
155 | } |
156 | |
157 | #ifdef CONFIG_HOTPLUG_CPU |
158 | |
159 | static void cpu_notify_nofail(unsigned long val, void *v) |
160 | { |
161 | BUG_ON(cpu_notify(val, v)); |
162 | } |
163 | |
164 | EXPORT_SYMBOL(register_cpu_notifier); |
165 | |
166 | void __ref unregister_cpu_notifier(struct notifier_block *nb) |
167 | { |
168 | cpu_maps_update_begin(); |
169 | raw_notifier_chain_unregister(&cpu_chain, nb); |
170 | cpu_maps_update_done(); |
171 | } |
172 | EXPORT_SYMBOL(unregister_cpu_notifier); |
173 | |
174 | static inline void check_for_tasks(int cpu) |
175 | { |
176 | struct task_struct *p; |
177 | |
178 | write_lock_irq(&tasklist_lock); |
179 | for_each_process(p) { |
180 | if (task_cpu(p) == cpu && p->state == TASK_RUNNING && |
181 | (!cputime_eq(p->utime, cputime_zero) || |
182 | !cputime_eq(p->stime, cputime_zero))) |
183 | printk(KERN_WARNING "Task %s (pid = %d) is on cpu %d " |
184 | "(state = %ld, flags = %x)\n", |
185 | p->comm, task_pid_nr(p), cpu, |
186 | p->state, p->flags); |
187 | } |
188 | write_unlock_irq(&tasklist_lock); |
189 | } |
190 | |
191 | struct take_cpu_down_param { |
192 | unsigned long mod; |
193 | void *hcpu; |
194 | }; |
195 | |
196 | /* Take this CPU down. */ |
197 | static int __ref take_cpu_down(void *_param) |
198 | { |
199 | struct take_cpu_down_param *param = _param; |
200 | int err; |
201 | |
202 | /* Ensure this CPU doesn't handle any more interrupts. */ |
203 | err = __cpu_disable(); |
204 | if (err < 0) |
205 | return err; |
206 | |
207 | cpu_notify(CPU_DYING | param->mod, param->hcpu); |
208 | |
209 | return 0; |
210 | } |
211 | |
212 | /* Requires cpu_add_remove_lock to be held */ |
213 | static int __ref _cpu_down(unsigned int cpu, int tasks_frozen) |
214 | { |
215 | int err, nr_calls = 0; |
216 | void *hcpu = (void *)(long)cpu; |
217 | unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0; |
218 | struct take_cpu_down_param tcd_param = { |
219 | .mod = mod, |
220 | .hcpu = hcpu, |
221 | }; |
222 | |
223 | if (num_online_cpus() == 1) |
224 | return -EBUSY; |
225 | |
226 | if (!cpu_online(cpu)) |
227 | return -EINVAL; |
228 | |
229 | cpu_hotplug_begin(); |
230 | err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls); |
231 | if (err) { |
232 | nr_calls--; |
233 | __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL); |
234 | printk("%s: attempt to take down CPU %u failed\n", |
235 | __func__, cpu); |
236 | goto out_release; |
237 | } |
238 | |
239 | err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu)); |
240 | if (err) { |
241 | /* CPU didn't die: tell everyone. Can't complain. */ |
242 | cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu); |
243 | |
244 | goto out_release; |
245 | } |
246 | BUG_ON(cpu_online(cpu)); |
247 | |
248 | /* |
249 | * The migration_call() CPU_DYING callback will have removed all |
250 | * runnable tasks from the cpu, there's only the idle task left now |
251 | * that the migration thread is done doing the stop_machine thing. |
252 | * |
253 | * Wait for the stop thread to go away. |
254 | */ |
255 | while (!idle_cpu(cpu)) |
256 | cpu_relax(); |
257 | |
258 | /* This actually kills the CPU. */ |
259 | __cpu_die(cpu); |
260 | |
261 | /* CPU is completely dead: tell everyone. Too late to complain. */ |
262 | cpu_notify_nofail(CPU_DEAD | mod, hcpu); |
263 | |
264 | check_for_tasks(cpu); |
265 | |
266 | out_release: |
267 | cpu_hotplug_done(); |
268 | if (!err) |
269 | cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu); |
270 | return err; |
271 | } |
272 | |
273 | int __ref cpu_down(unsigned int cpu) |
274 | { |
275 | int err; |
276 | |
277 | cpu_maps_update_begin(); |
278 | |
279 | if (cpu_hotplug_disabled) { |
280 | err = -EBUSY; |
281 | goto out; |
282 | } |
283 | |
284 | err = _cpu_down(cpu, 0); |
285 | |
286 | out: |
287 | cpu_maps_update_done(); |
288 | return err; |
289 | } |
290 | EXPORT_SYMBOL(cpu_down); |
291 | #endif /*CONFIG_HOTPLUG_CPU*/ |
292 | |
293 | /* Requires cpu_add_remove_lock to be held */ |
294 | static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen) |
295 | { |
296 | int ret, nr_calls = 0; |
297 | void *hcpu = (void *)(long)cpu; |
298 | unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0; |
299 | |
300 | if (cpu_online(cpu) || !cpu_present(cpu)) |
301 | return -EINVAL; |
302 | |
303 | cpu_hotplug_begin(); |
304 | ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls); |
305 | if (ret) { |
306 | nr_calls--; |
307 | printk("%s: attempt to bring up CPU %u failed\n", |
308 | __func__, cpu); |
309 | goto out_notify; |
310 | } |
311 | |
312 | /* Arch-specific enabling code. */ |
313 | ret = __cpu_up(cpu); |
314 | if (ret != 0) |
315 | goto out_notify; |
316 | BUG_ON(!cpu_online(cpu)); |
317 | |
318 | /* Now call notifier in preparation. */ |
319 | cpu_notify(CPU_ONLINE | mod, hcpu); |
320 | |
321 | out_notify: |
322 | if (ret != 0) |
323 | __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL); |
324 | cpu_hotplug_done(); |
325 | |
326 | return ret; |
327 | } |
328 | |
329 | int __cpuinit cpu_up(unsigned int cpu) |
330 | { |
331 | int err = 0; |
332 | |
333 | #ifdef CONFIG_MEMORY_HOTPLUG |
334 | int nid; |
335 | pg_data_t *pgdat; |
336 | #endif |
337 | |
338 | if (!cpu_possible(cpu)) { |
339 | printk(KERN_ERR "can't online cpu %d because it is not " |
340 | "configured as may-hotadd at boot time\n", cpu); |
341 | #if defined(CONFIG_IA64) |
342 | printk(KERN_ERR "please check additional_cpus= boot " |
343 | "parameter\n"); |
344 | #endif |
345 | return -EINVAL; |
346 | } |
347 | |
348 | #ifdef CONFIG_MEMORY_HOTPLUG |
349 | nid = cpu_to_node(cpu); |
350 | if (!node_online(nid)) { |
351 | err = mem_online_node(nid); |
352 | if (err) |
353 | return err; |
354 | } |
355 | |
356 | pgdat = NODE_DATA(nid); |
357 | if (!pgdat) { |
358 | printk(KERN_ERR |
359 | "Can't online cpu %d due to NULL pgdat\n", cpu); |
360 | return -ENOMEM; |
361 | } |
362 | |
363 | if (pgdat->node_zonelists->_zonerefs->zone == NULL) { |
364 | mutex_lock(&zonelists_mutex); |
365 | build_all_zonelists(NULL); |
366 | mutex_unlock(&zonelists_mutex); |
367 | } |
368 | #endif |
369 | |
370 | cpu_maps_update_begin(); |
371 | |
372 | if (cpu_hotplug_disabled) { |
373 | err = -EBUSY; |
374 | goto out; |
375 | } |
376 | |
377 | err = _cpu_up(cpu, 0); |
378 | |
379 | out: |
380 | cpu_maps_update_done(); |
381 | return err; |
382 | } |
383 | |
384 | #ifdef CONFIG_PM_SLEEP_SMP |
385 | static cpumask_var_t frozen_cpus; |
386 | |
387 | void __weak arch_disable_nonboot_cpus_begin(void) |
388 | { |
389 | } |
390 | |
391 | void __weak arch_disable_nonboot_cpus_end(void) |
392 | { |
393 | } |
394 | |
395 | int disable_nonboot_cpus(void) |
396 | { |
397 | int cpu, first_cpu, error = 0; |
398 | |
399 | cpu_maps_update_begin(); |
400 | first_cpu = cpumask_first(cpu_online_mask); |
401 | /* |
402 | * We take down all of the non-boot CPUs in one shot to avoid races |
403 | * with the userspace trying to use the CPU hotplug at the same time |
404 | */ |
405 | cpumask_clear(frozen_cpus); |
406 | arch_disable_nonboot_cpus_begin(); |
407 | |
408 | printk("Disabling non-boot CPUs ...\n"); |
409 | for_each_online_cpu(cpu) { |
410 | if (cpu == first_cpu) |
411 | continue; |
412 | error = _cpu_down(cpu, 1); |
413 | if (!error) |
414 | cpumask_set_cpu(cpu, frozen_cpus); |
415 | else { |
416 | printk(KERN_ERR "Error taking CPU%d down: %d\n", |
417 | cpu, error); |
418 | break; |
419 | } |
420 | } |
421 | |
422 | arch_disable_nonboot_cpus_end(); |
423 | |
424 | if (!error) { |
425 | BUG_ON(num_online_cpus() > 1); |
426 | /* Make sure the CPUs won't be enabled by someone else */ |
427 | cpu_hotplug_disabled = 1; |
428 | } else { |
429 | printk(KERN_ERR "Non-boot CPUs are not disabled\n"); |
430 | } |
431 | cpu_maps_update_done(); |
432 | return error; |
433 | } |
434 | |
435 | void __weak arch_enable_nonboot_cpus_begin(void) |
436 | { |
437 | } |
438 | |
439 | void __weak arch_enable_nonboot_cpus_end(void) |
440 | { |
441 | } |
442 | |
443 | void __ref enable_nonboot_cpus(void) |
444 | { |
445 | int cpu, error; |
446 | |
447 | /* Allow everyone to use the CPU hotplug again */ |
448 | cpu_maps_update_begin(); |
449 | cpu_hotplug_disabled = 0; |
450 | if (cpumask_empty(frozen_cpus)) |
451 | goto out; |
452 | |
453 | printk("Enabling non-boot CPUs ...\n"); |
454 | |
455 | arch_enable_nonboot_cpus_begin(); |
456 | |
457 | for_each_cpu(cpu, frozen_cpus) { |
458 | error = _cpu_up(cpu, 1); |
459 | if (!error) { |
460 | printk("CPU%d is up\n", cpu); |
461 | continue; |
462 | } |
463 | printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error); |
464 | } |
465 | |
466 | arch_enable_nonboot_cpus_end(); |
467 | |
468 | cpumask_clear(frozen_cpus); |
469 | out: |
470 | cpu_maps_update_done(); |
471 | } |
472 | |
473 | static int alloc_frozen_cpus(void) |
474 | { |
475 | if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO)) |
476 | return -ENOMEM; |
477 | return 0; |
478 | } |
479 | core_initcall(alloc_frozen_cpus); |
480 | #endif /* CONFIG_PM_SLEEP_SMP */ |
481 | |
482 | /** |
483 | * notify_cpu_starting(cpu) - call the CPU_STARTING notifiers |
484 | * @cpu: cpu that just started |
485 | * |
486 | * This function calls the cpu_chain notifiers with CPU_STARTING. |
487 | * It must be called by the arch code on the new cpu, before the new cpu |
488 | * enables interrupts and before the "boot" cpu returns from __cpu_up(). |
489 | */ |
490 | void __cpuinit notify_cpu_starting(unsigned int cpu) |
491 | { |
492 | unsigned long val = CPU_STARTING; |
493 | |
494 | #ifdef CONFIG_PM_SLEEP_SMP |
495 | if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus)) |
496 | val = CPU_STARTING_FROZEN; |
497 | #endif /* CONFIG_PM_SLEEP_SMP */ |
498 | cpu_notify(val, (void *)(long)cpu); |
499 | } |
500 | |
501 | #endif /* CONFIG_SMP */ |
502 | |
503 | /* |
504 | * cpu_bit_bitmap[] is a special, "compressed" data structure that |
505 | * represents all NR_CPUS bits binary values of 1<<nr. |
506 | * |
507 | * It is used by cpumask_of() to get a constant address to a CPU |
508 | * mask value that has a single bit set only. |
509 | */ |
510 | |
511 | /* cpu_bit_bitmap[0] is empty - so we can back into it */ |
512 | #define MASK_DECLARE_1(x) [x+1][0] = 1UL << (x) |
513 | #define MASK_DECLARE_2(x) MASK_DECLARE_1(x), MASK_DECLARE_1(x+1) |
514 | #define MASK_DECLARE_4(x) MASK_DECLARE_2(x), MASK_DECLARE_2(x+2) |
515 | #define MASK_DECLARE_8(x) MASK_DECLARE_4(x), MASK_DECLARE_4(x+4) |
516 | |
517 | const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = { |
518 | |
519 | MASK_DECLARE_8(0), MASK_DECLARE_8(8), |
520 | MASK_DECLARE_8(16), MASK_DECLARE_8(24), |
521 | #if BITS_PER_LONG > 32 |
522 | MASK_DECLARE_8(32), MASK_DECLARE_8(40), |
523 | MASK_DECLARE_8(48), MASK_DECLARE_8(56), |
524 | #endif |
525 | }; |
526 | EXPORT_SYMBOL_GPL(cpu_bit_bitmap); |
527 | |
528 | const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL; |
529 | EXPORT_SYMBOL(cpu_all_bits); |
530 | |
531 | #ifdef CONFIG_INIT_ALL_POSSIBLE |
532 | static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly |
533 | = CPU_BITS_ALL; |
534 | #else |
535 | static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly; |
536 | #endif |
537 | const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits); |
538 | EXPORT_SYMBOL(cpu_possible_mask); |
539 | |
540 | static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly; |
541 | const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits); |
542 | EXPORT_SYMBOL(cpu_online_mask); |
543 | |
544 | static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly; |
545 | const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits); |
546 | EXPORT_SYMBOL(cpu_present_mask); |
547 | |
548 | static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly; |
549 | const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits); |
550 | EXPORT_SYMBOL(cpu_active_mask); |
551 | |
552 | void set_cpu_possible(unsigned int cpu, bool possible) |
553 | { |
554 | if (possible) |
555 | cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits)); |
556 | else |
557 | cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits)); |
558 | } |
559 | |
560 | void set_cpu_present(unsigned int cpu, bool present) |
561 | { |
562 | if (present) |
563 | cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits)); |
564 | else |
565 | cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits)); |
566 | } |
567 | |
568 | void set_cpu_online(unsigned int cpu, bool online) |
569 | { |
570 | if (online) |
571 | cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits)); |
572 | else |
573 | cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits)); |
574 | } |
575 | |
576 | void set_cpu_active(unsigned int cpu, bool active) |
577 | { |
578 | if (active) |
579 | cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits)); |
580 | else |
581 | cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits)); |
582 | } |
583 | |
584 | void init_cpu_present(const struct cpumask *src) |
585 | { |
586 | cpumask_copy(to_cpumask(cpu_present_bits), src); |
587 | } |
588 | |
589 | void init_cpu_possible(const struct cpumask *src) |
590 | { |
591 | cpumask_copy(to_cpumask(cpu_possible_bits), src); |
592 | } |
593 | |
594 | void init_cpu_online(const struct cpumask *src) |
595 | { |
596 | cpumask_copy(to_cpumask(cpu_online_bits), src); |
597 | } |
598 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9