1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
#include <xen/config.h>
#include <xen/cpumask.h>
#include <xen/cpu.h>
#include <xen/event.h>
#include <xen/init.h>
#include <xen/sched.h>
#include <xen/stop_machine.h>
unsigned int __read_mostly nr_cpu_ids = NR_CPUS;
#ifndef nr_cpumask_bits
unsigned int __read_mostly nr_cpumask_bits
= BITS_TO_LONGS(NR_CPUS) * BITS_PER_LONG;
#endif
/*
* cpu_bit_bitmap[] is a special, "compressed" data structure that
* represents all NR_CPUS bits binary values of 1<<nr.
*
* It is used by cpumask_of() to get a constant address to a CPU
* mask value that has a single bit set only.
*/
/* cpu_bit_bitmap[0] is empty - so we can back into it */
#define MASK_DECLARE_1(x) [x+1][0] = 1UL << (x)
#define MASK_DECLARE_2(x) MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
#define MASK_DECLARE_4(x) MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
#define MASK_DECLARE_8(x) MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
MASK_DECLARE_8(0), MASK_DECLARE_8(8),
MASK_DECLARE_8(16), MASK_DECLARE_8(24),
#if BITS_PER_LONG > 32
MASK_DECLARE_8(32), MASK_DECLARE_8(40),
MASK_DECLARE_8(48), MASK_DECLARE_8(56),
#endif
};
static DEFINE_SPINLOCK(cpu_add_remove_lock);
bool_t get_cpu_maps(void)
{
return spin_trylock_recursive(&cpu_add_remove_lock);
}
void put_cpu_maps(void)
{
spin_unlock_recursive(&cpu_add_remove_lock);
}
bool_t cpu_hotplug_begin(void)
{
return get_cpu_maps();
}
void cpu_hotplug_done(void)
{
put_cpu_maps();
}
static NOTIFIER_HEAD(cpu_chain);
void __init register_cpu_notifier(struct notifier_block *nb)
{
if ( !spin_trylock(&cpu_add_remove_lock) )
BUG(); /* Should never fail as we are called only during boot. */
notifier_chain_register(&cpu_chain, nb);
spin_unlock(&cpu_add_remove_lock);
}
static int take_cpu_down(void *unused)
{
void *hcpu = (void *)(long)smp_processor_id();
int notifier_rc = notifier_call_chain(&cpu_chain, CPU_DYING, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
__cpu_disable();
return 0;
}
int cpu_down(unsigned int cpu)
{
int err, notifier_rc;
void *hcpu = (void *)(long)cpu;
struct notifier_block *nb = NULL;
if ( !cpu_hotplug_begin() )
return -EBUSY;
if ( (cpu >= nr_cpu_ids) || (cpu == 0) || !cpu_online(cpu) )
{
cpu_hotplug_done();
return -EINVAL;
}
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE, hcpu, &nb);
if ( notifier_rc != NOTIFY_DONE )
{
err = notifier_to_errno(notifier_rc);
goto fail;
}
if ( (err = stop_machine_run(take_cpu_down, NULL, cpu)) < 0 )
goto fail;
__cpu_die(cpu);
BUG_ON(cpu_online(cpu));
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DEAD, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
send_global_virq(VIRQ_PCPU_STATE);
cpu_hotplug_done();
return 0;
fail:
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED, hcpu, &nb);
BUG_ON(notifier_rc != NOTIFY_DONE);
cpu_hotplug_done();
return err;
}
int cpu_up(unsigned int cpu)
{
int notifier_rc, err = 0;
void *hcpu = (void *)(long)cpu;
struct notifier_block *nb = NULL;
if ( !cpu_hotplug_begin() )
return -EBUSY;
if ( (cpu >= nr_cpu_ids) || cpu_online(cpu) || !cpu_present(cpu) )
{
cpu_hotplug_done();
return -EINVAL;
}
notifier_rc = notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu, &nb);
if ( notifier_rc != NOTIFY_DONE )
{
err = notifier_to_errno(notifier_rc);
goto fail;
}
err = __cpu_up(cpu);
if ( err < 0 )
goto fail;
notifier_rc = notifier_call_chain(&cpu_chain, CPU_ONLINE, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
send_global_virq(VIRQ_PCPU_STATE);
cpu_hotplug_done();
return 0;
fail:
notifier_rc = notifier_call_chain(&cpu_chain, CPU_UP_CANCELED, hcpu, &nb);
BUG_ON(notifier_rc != NOTIFY_DONE);
cpu_hotplug_done();
return err;
}
void notify_cpu_starting(unsigned int cpu)
{
void *hcpu = (void *)(long)cpu;
int notifier_rc = notifier_call_chain(
&cpu_chain, CPU_STARTING, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
}
static cpumask_t frozen_cpus;
int disable_nonboot_cpus(void)
{
int cpu, error = 0;
BUG_ON(smp_processor_id() != 0);
cpumask_clear(&frozen_cpus);
printk("Disabling non-boot CPUs ...\n");
for_each_online_cpu ( cpu )
{
if ( cpu == 0 )
continue;
if ( (error = cpu_down(cpu)) )
{
BUG_ON(error == -EBUSY);
printk("Error taking CPU%d down: %d\n", cpu, error);
break;
}
cpumask_set_cpu(cpu, &frozen_cpus);
}
BUG_ON(!error && (num_online_cpus() != 1));
return error;
}
void enable_nonboot_cpus(void)
{
int cpu, error;
printk("Enabling non-boot CPUs ...\n");
for_each_cpu ( cpu, &frozen_cpus )
{
if ( (error = cpu_up(cpu)) )
{
BUG_ON(error == -EBUSY);
printk("Error taking CPU%d up: %d\n", cpu, error);
}
}
cpumask_clear(&frozen_cpus);
}
|
