]>
Commit | Line | Data |
---|---|---|
1 | From: Chandru <chandru@in.ibm.com> | |
2 | Date: Sat, 30 Aug 2008 00:28:16 +1000 | |
3 | Subject: [PATCH] powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels | |
4 | References: bnc#431492 | |
5 | X-Git-Commit: cf00085d8045cddd80a8aabad97de96fa8131793 Mon Sep 17 00:00:00 2001 | |
6 | ||
7 | Kdump kernel needs to use only those memory regions that it is allowed | |
8 | to use (crashkernel, rtas, tce, etc.). Each of these regions have | |
9 | their own sizes and are currently added under 'linux,usable-memory' | |
10 | property under each memory@xxx node of the device tree. | |
11 | ||
12 | The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory | |
13 | node (on POWER6) now stores in it the representation for most of the | |
14 | logical memory blocks with the size of each memory block being a | |
15 | constant (lmb_size). If one or more or part of the above mentioned | |
16 | regions lie under one of the lmb from ibm,dynamic-memory property, | |
17 | there is a need to identify those regions within the given lmb. | |
18 | ||
19 | This makes the kernel recognize a new 'linux,drconf-usable-memory' | |
20 | property added by kexec-tools. Each entry in this property is of the | |
21 | form of a count followed by that many (base, size) pairs for the above | |
22 | mentioned regions. The number of cells in the count value is given by | |
23 | the #size-cells property of the root node. | |
24 | ||
25 | Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com> | |
26 | Signed-off-by: Paul Mackerras <paulus@samba.org> | |
27 | Acked-by: Bernhard Walle <bwalle@suse.de> | |
28 | ||
29 | --- | |
30 | arch/powerpc/kernel/prom.c | 40 +++++++++++++++++++--- | |
31 | arch/powerpc/mm/numa.c | 79 +++++++++++++++++++++++++++++++++++---------- | |
32 | 2 files changed, 96 insertions(+), 23 deletions(-) | |
33 | ||
34 | --- a/arch/powerpc/kernel/prom.c | |
35 | +++ b/arch/powerpc/kernel/prom.c | |
36 | @@ -888,9 +888,10 @@ static u64 __init dt_mem_next_cell(int s | |
37 | */ | |
38 | static int __init early_init_dt_scan_drconf_memory(unsigned long node) | |
39 | { | |
40 | - cell_t *dm, *ls; | |
41 | + cell_t *dm, *ls, *usm; | |
42 | unsigned long l, n, flags; | |
43 | u64 base, size, lmb_size; | |
44 | + unsigned int is_kexec_kdump = 0, rngs; | |
45 | ||
46 | ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l); | |
47 | if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t)) | |
48 | @@ -905,6 +906,12 @@ static int __init early_init_dt_scan_drc | |
49 | if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t)) | |
50 | return 0; | |
51 | ||
52 | + /* check if this is a kexec/kdump kernel. */ | |
53 | + usm = (cell_t *)of_get_flat_dt_prop(node, "linux,drconf-usable-memory", | |
54 | + &l); | |
55 | + if (usm != NULL) | |
56 | + is_kexec_kdump = 1; | |
57 | + | |
58 | for (; n != 0; --n) { | |
59 | base = dt_mem_next_cell(dt_root_addr_cells, &dm); | |
60 | flags = dm[3]; | |
61 | @@ -915,13 +922,34 @@ static int __init early_init_dt_scan_drc | |
62 | if ((flags & 0x80) || !(flags & 0x8)) | |
63 | continue; | |
64 | size = lmb_size; | |
65 | - if (iommu_is_off) { | |
66 | - if (base >= 0x80000000ul) | |
67 | + rngs = 1; | |
68 | + if (is_kexec_kdump) { | |
69 | + /* | |
70 | + * For each lmb in ibm,dynamic-memory, a corresponding | |
71 | + * entry in linux,drconf-usable-memory property contains | |
72 | + * a counter 'p' followed by 'p' (base, size) duple. | |
73 | + * Now read the counter from | |
74 | + * linux,drconf-usable-memory property | |
75 | + */ | |
76 | + rngs = dt_mem_next_cell(dt_root_size_cells, &usm); | |
77 | + if (!rngs) /* there are no (base, size) duple */ | |
78 | continue; | |
79 | - if ((base + size) > 0x80000000ul) | |
80 | - size = 0x80000000ul - base; | |
81 | } | |
82 | - lmb_add(base, size); | |
83 | + do { | |
84 | + if (is_kexec_kdump) { | |
85 | + base = dt_mem_next_cell(dt_root_addr_cells, | |
86 | + &usm); | |
87 | + size = dt_mem_next_cell(dt_root_size_cells, | |
88 | + &usm); | |
89 | + } | |
90 | + if (iommu_is_off) { | |
91 | + if (base >= 0x80000000ul) | |
92 | + continue; | |
93 | + if ((base + size) > 0x80000000ul) | |
94 | + size = 0x80000000ul - base; | |
95 | + } | |
96 | + lmb_add(base, size); | |
97 | + } while (--rngs); | |
98 | } | |
99 | lmb_dump_all(); | |
100 | return 0; | |
101 | --- a/arch/powerpc/mm/numa.c | |
102 | +++ b/arch/powerpc/mm/numa.c | |
103 | @@ -192,6 +192,21 @@ static const int *of_get_associativity(s | |
104 | return of_get_property(dev, "ibm,associativity", NULL); | |
105 | } | |
106 | ||
107 | +/* | |
108 | + * Returns the property linux,drconf-usable-memory if | |
109 | + * it exists (the property exists only in kexec/kdump kernels, | |
110 | + * added by kexec-tools) | |
111 | + */ | |
112 | +static const u32 *of_get_usable_memory(struct device_node *memory) | |
113 | +{ | |
114 | + const u32 *prop; | |
115 | + u32 len; | |
116 | + prop = of_get_property(memory, "linux,drconf-usable-memory", &len); | |
117 | + if (!prop || len < sizeof(unsigned int)) | |
118 | + return 0; | |
119 | + return prop; | |
120 | +} | |
121 | + | |
122 | /* Returns nid in the range [0..MAX_NUMNODES-1], or -1 if no useful numa | |
123 | * info is found. | |
124 | */ | |
125 | @@ -529,14 +544,29 @@ static unsigned long __init numa_enforce | |
126 | } | |
127 | ||
128 | /* | |
129 | + * Reads the counter for a given entry in | |
130 | + * linux,drconf-usable-memory property | |
131 | + */ | |
132 | +static inline int __init read_usm_ranges(const u32 **usm) | |
133 | +{ | |
134 | + /* | |
135 | + * For each lmb in ibm,dynamic-memory a corresponding | |
136 | + * entry in linux,drconf-usable-memory property contains | |
137 | + * a counter followed by that many (base, size) duple. | |
138 | + * read the counter from linux,drconf-usable-memory | |
139 | + */ | |
140 | + return read_n_cells(n_mem_size_cells, usm); | |
141 | +} | |
142 | + | |
143 | +/* | |
144 | * Extract NUMA information from the ibm,dynamic-reconfiguration-memory | |
145 | * node. This assumes n_mem_{addr,size}_cells have been set. | |
146 | */ | |
147 | static void __init parse_drconf_memory(struct device_node *memory) | |
148 | { | |
149 | - const u32 *dm; | |
150 | - unsigned int n, rc; | |
151 | - unsigned long lmb_size, size; | |
152 | + const u32 *dm, *usm; | |
153 | + unsigned int n, rc, ranges, is_kexec_kdump = 0; | |
154 | + unsigned long lmb_size, base, size, sz; | |
155 | int nid; | |
156 | struct assoc_arrays aa; | |
157 | ||
158 | @@ -552,6 +582,11 @@ static void __init parse_drconf_memory(s | |
159 | if (rc) | |
160 | return; | |
161 | ||
162 | + /* check if this is a kexec/kdump kernel */ | |
163 | + usm = of_get_usable_memory(memory); | |
164 | + if (usm != NULL) | |
165 | + is_kexec_kdump = 1; | |
166 | + | |
167 | for (; n != 0; --n) { | |
168 | struct of_drconf_cell drmem; | |
169 | ||
170 | @@ -563,21 +598,31 @@ static void __init parse_drconf_memory(s | |
171 | || !(drmem.flags & DRCONF_MEM_ASSIGNED)) | |
172 | continue; | |
173 | ||
174 | - nid = of_drconf_to_nid_single(&drmem, &aa); | |
175 | - | |
176 | - fake_numa_create_new_node( | |
177 | - ((drmem.base_addr + lmb_size) >> PAGE_SHIFT), | |
178 | + base = drmem.base_addr; | |
179 | + size = lmb_size; | |
180 | + ranges = 1; | |
181 | + | |
182 | + if (is_kexec_kdump) { | |
183 | + ranges = read_usm_ranges(&usm); | |
184 | + if (!ranges) /* there are no (base, size) duple */ | |
185 | + continue; | |
186 | + } | |
187 | + do { | |
188 | + if (is_kexec_kdump) { | |
189 | + base = read_n_cells(n_mem_addr_cells, &usm); | |
190 | + size = read_n_cells(n_mem_size_cells, &usm); | |
191 | + } | |
192 | + nid = of_drconf_to_nid_single(&drmem, &aa); | |
193 | + fake_numa_create_new_node( | |
194 | + ((base + size) >> PAGE_SHIFT), | |
195 | &nid); | |
196 | - | |
197 | - node_set_online(nid); | |
198 | - | |
199 | - size = numa_enforce_memory_limit(drmem.base_addr, lmb_size); | |
200 | - if (!size) | |
201 | - continue; | |
202 | - | |
203 | - add_active_range(nid, drmem.base_addr >> PAGE_SHIFT, | |
204 | - (drmem.base_addr >> PAGE_SHIFT) | |
205 | - + (size >> PAGE_SHIFT)); | |
206 | + node_set_online(nid); | |
207 | + sz = numa_enforce_memory_limit(base, size); | |
208 | + if (sz) | |
209 | + add_active_range(nid, base >> PAGE_SHIFT, | |
210 | + (base >> PAGE_SHIFT) | |
211 | + + (sz >> PAGE_SHIFT)); | |
212 | + } while (--ranges); | |
213 | } | |
214 | } | |
215 |