1 /* 2 * Copyright (C) IBM Corporation, 2014, 2017 3 * Anton Blanchard, Rashmica Gupta. 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 */ 10 11 #define pr_fmt(fmt) "memtrace: " fmt 12 13 #include <linux/bitops.h> 14 #include <linux/string.h> 15 #include <linux/memblock.h> 16 #include <linux/init.h> 17 #include <linux/moduleparam.h> 18 #include <linux/fs.h> 19 #include <linux/debugfs.h> 20 #include <linux/slab.h> 21 #include <linux/memory.h> 22 #include <linux/memory_hotplug.h> 23 #include <asm/machdep.h> 24 #include <asm/debugfs.h> 25 26 /* This enables us to keep track of the memory removed from each node. */ 27 struct memtrace_entry { 28 void *mem; 29 u64 start; 30 u64 size; 31 u32 nid; 32 struct dentry *dir; 33 char name[16]; 34 }; 35 36 static u64 memtrace_size; 37 38 static struct memtrace_entry *memtrace_array; 39 static unsigned int memtrace_array_nr; 40 41 42 static ssize_t memtrace_read(struct file *filp, char __user *ubuf, 43 size_t count, loff_t *ppos) 44 { 45 struct memtrace_entry *ent = filp->private_data; 46 47 return simple_read_from_buffer(ubuf, count, ppos, ent->mem, ent->size); 48 } 49 50 static const struct file_operations memtrace_fops = { 51 .llseek = default_llseek, 52 .read = memtrace_read, 53 .open = simple_open, 54 }; 55 56 static int check_memblock_online(struct memory_block *mem, void *arg) 57 { 58 if (mem->state != MEM_ONLINE) 59 return -1; 60 61 return 0; 62 } 63 64 static int change_memblock_state(struct memory_block *mem, void *arg) 65 { 66 unsigned long state = (unsigned long)arg; 67 68 mem->state = state; 69 70 return 0; 71 } 72 73 static bool memtrace_offline_pages(u32 nid, u64 start_pfn, u64 nr_pages) 74 { 75 u64 end_pfn = start_pfn + nr_pages - 1; 76 77 if (walk_memory_range(start_pfn, end_pfn, NULL, 78 check_memblock_online)) 79 return false; 80 81 walk_memory_range(start_pfn, end_pfn, (void *)MEM_GOING_OFFLINE, 82 change_memblock_state); 83 84 if (offline_pages(start_pfn, nr_pages)) { 85 walk_memory_range(start_pfn, end_pfn, (void *)MEM_ONLINE, 86 change_memblock_state); 87 return false; 88 } 89 90 walk_memory_range(start_pfn, end_pfn, (void *)MEM_OFFLINE, 91 change_memblock_state); 92 93 94 return true; 95 } 96 97 static u64 memtrace_alloc_node(u32 nid, u64 size) 98 { 99 u64 start_pfn, end_pfn, nr_pages, pfn; 100 u64 base_pfn; 101 u64 bytes = memory_block_size_bytes(); 102 103 if (!node_spanned_pages(nid)) 104 return 0; 105 106 start_pfn = node_start_pfn(nid); 107 end_pfn = node_end_pfn(nid); 108 nr_pages = size >> PAGE_SHIFT; 109 110 /* Trace memory needs to be aligned to the size */ 111 end_pfn = round_down(end_pfn - nr_pages, nr_pages); 112 113 for (base_pfn = end_pfn; base_pfn > start_pfn; base_pfn -= nr_pages) { 114 if (memtrace_offline_pages(nid, base_pfn, nr_pages) == true) { 115 /* 116 * Remove memory in memory block size chunks so that 117 * iomem resources are always split to the same size and 118 * we never try to remove memory that spans two iomem 119 * resources. 120 */ 121 lock_device_hotplug(); 122 end_pfn = base_pfn + nr_pages; 123 for (pfn = base_pfn; pfn < end_pfn; pfn += bytes>> PAGE_SHIFT) { 124 remove_memory(nid, pfn << PAGE_SHIFT, bytes); 125 } 126 unlock_device_hotplug(); 127 return base_pfn << PAGE_SHIFT; 128 } 129 } 130 131 return 0; 132 } 133 134 static int memtrace_init_regions_runtime(u64 size) 135 { 136 u32 nid; 137 u64 m; 138 139 memtrace_array = kcalloc(num_online_nodes(), 140 sizeof(struct memtrace_entry), GFP_KERNEL); 141 if (!memtrace_array) { 142 pr_err("Failed to allocate memtrace_array\n"); 143 return -EINVAL; 144 } 145 146 for_each_online_node(nid) { 147 m = memtrace_alloc_node(nid, size); 148 149 /* 150 * A node might not have any local memory, so warn but 151 * continue on. 152 */ 153 if (!m) { 154 pr_err("Failed to allocate trace memory on node %d\n", nid); 155 continue; 156 } 157 158 pr_info("Allocated trace memory on node %d at 0x%016llx\n", nid, m); 159 160 memtrace_array[memtrace_array_nr].start = m; 161 memtrace_array[memtrace_array_nr].size = size; 162 memtrace_array[memtrace_array_nr].nid = nid; 163 memtrace_array_nr++; 164 } 165 166 return 0; 167 } 168 169 static struct dentry *memtrace_debugfs_dir; 170 171 static int memtrace_init_debugfs(void) 172 { 173 int ret = 0; 174 int i; 175 176 for (i = 0; i < memtrace_array_nr; i++) { 177 struct dentry *dir; 178 struct memtrace_entry *ent = &memtrace_array[i]; 179 180 ent->mem = ioremap(ent->start, ent->size); 181 /* Warn but continue on */ 182 if (!ent->mem) { 183 pr_err("Failed to map trace memory at 0x%llx\n", 184 ent->start); 185 ret = -1; 186 continue; 187 } 188 189 snprintf(ent->name, 16, "%08x", ent->nid); 190 dir = debugfs_create_dir(ent->name, memtrace_debugfs_dir); 191 if (!dir) { 192 pr_err("Failed to create debugfs directory for node %d\n", 193 ent->nid); 194 return -1; 195 } 196 197 ent->dir = dir; 198 debugfs_create_file("trace", 0400, dir, ent, &memtrace_fops); 199 debugfs_create_x64("start", 0400, dir, &ent->start); 200 debugfs_create_x64("size", 0400, dir, &ent->size); 201 } 202 203 return ret; 204 } 205 206 static int online_mem_block(struct memory_block *mem, void *arg) 207 { 208 return device_online(&mem->dev); 209 } 210 211 /* 212 * Iterate through the chunks of memory we have removed from the kernel 213 * and attempt to add them back to the kernel. 214 */ 215 static int memtrace_online(void) 216 { 217 int i, ret = 0; 218 struct memtrace_entry *ent; 219 220 for (i = memtrace_array_nr - 1; i >= 0; i--) { 221 ent = &memtrace_array[i]; 222 223 /* We have onlined this chunk previously */ 224 if (ent->nid == -1) 225 continue; 226 227 /* Remove from io mappings */ 228 if (ent->mem) { 229 iounmap(ent->mem); 230 ent->mem = 0; 231 } 232 233 if (add_memory(ent->nid, ent->start, ent->size)) { 234 pr_err("Failed to add trace memory to node %d\n", 235 ent->nid); 236 ret += 1; 237 continue; 238 } 239 240 /* 241 * If kernel isn't compiled with the auto online option 242 * we need to online the memory ourselves. 243 */ 244 if (!memhp_auto_online) { 245 walk_memory_range(PFN_DOWN(ent->start), 246 PFN_UP(ent->start + ent->size - 1), 247 NULL, online_mem_block); 248 } 249 250 /* 251 * Memory was added successfully so clean up references to it 252 * so on reentry we can tell that this chunk was added. 253 */ 254 debugfs_remove_recursive(ent->dir); 255 pr_info("Added trace memory back to node %d\n", ent->nid); 256 ent->size = ent->start = ent->nid = -1; 257 } 258 if (ret) 259 return ret; 260 261 /* If all chunks of memory were added successfully, reset globals */ 262 kfree(memtrace_array); 263 memtrace_array = NULL; 264 memtrace_size = 0; 265 memtrace_array_nr = 0; 266 return 0; 267 } 268 269 static int memtrace_enable_set(void *data, u64 val) 270 { 271 u64 bytes; 272 273 /* 274 * Don't attempt to do anything if size isn't aligned to a memory 275 * block or equal to zero. 276 */ 277 bytes = memory_block_size_bytes(); 278 if (val & (bytes - 1)) { 279 pr_err("Value must be aligned with 0x%llx\n", bytes); 280 return -EINVAL; 281 } 282 283 /* Re-add/online previously removed/offlined memory */ 284 if (memtrace_size) { 285 if (memtrace_online()) 286 return -EAGAIN; 287 } 288 289 if (!val) 290 return 0; 291 292 /* Offline and remove memory */ 293 if (memtrace_init_regions_runtime(val)) 294 return -EINVAL; 295 296 if (memtrace_init_debugfs()) 297 return -EINVAL; 298 299 memtrace_size = val; 300 301 return 0; 302 } 303 304 static int memtrace_enable_get(void *data, u64 *val) 305 { 306 *val = memtrace_size; 307 return 0; 308 } 309 310 DEFINE_SIMPLE_ATTRIBUTE(memtrace_init_fops, memtrace_enable_get, 311 memtrace_enable_set, "0x%016llx\n"); 312 313 static int memtrace_init(void) 314 { 315 memtrace_debugfs_dir = debugfs_create_dir("memtrace", 316 powerpc_debugfs_root); 317 if (!memtrace_debugfs_dir) 318 return -1; 319 320 debugfs_create_file("enable", 0600, memtrace_debugfs_dir, 321 NULL, &memtrace_init_fops); 322 323 return 0; 324 } 325 machine_device_initcall(powernv, memtrace_init); 326