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 lock_device_hotplug(); 94 remove_memory(nid, start_pfn << PAGE_SHIFT, nr_pages << PAGE_SHIFT); 95 unlock_device_hotplug(); 96 97 return true; 98 } 99 100 static u64 memtrace_alloc_node(u32 nid, u64 size) 101 { 102 u64 start_pfn, end_pfn, nr_pages; 103 u64 base_pfn; 104 105 if (!node_spanned_pages(nid)) 106 return 0; 107 108 start_pfn = node_start_pfn(nid); 109 end_pfn = node_end_pfn(nid); 110 nr_pages = size >> PAGE_SHIFT; 111 112 /* Trace memory needs to be aligned to the size */ 113 end_pfn = round_down(end_pfn - nr_pages, nr_pages); 114 115 for (base_pfn = end_pfn; base_pfn > start_pfn; base_pfn -= nr_pages) { 116 if (memtrace_offline_pages(nid, base_pfn, nr_pages) == true) 117 return base_pfn << PAGE_SHIFT; 118 } 119 120 return 0; 121 } 122 123 static int memtrace_init_regions_runtime(u64 size) 124 { 125 u32 nid; 126 u64 m; 127 128 memtrace_array = kcalloc(num_online_nodes(), 129 sizeof(struct memtrace_entry), GFP_KERNEL); 130 if (!memtrace_array) { 131 pr_err("Failed to allocate memtrace_array\n"); 132 return -EINVAL; 133 } 134 135 for_each_online_node(nid) { 136 m = memtrace_alloc_node(nid, size); 137 138 /* 139 * A node might not have any local memory, so warn but 140 * continue on. 141 */ 142 if (!m) { 143 pr_err("Failed to allocate trace memory on node %d\n", nid); 144 continue; 145 } 146 147 pr_info("Allocated trace memory on node %d at 0x%016llx\n", nid, m); 148 149 memtrace_array[memtrace_array_nr].start = m; 150 memtrace_array[memtrace_array_nr].size = size; 151 memtrace_array[memtrace_array_nr].nid = nid; 152 memtrace_array_nr++; 153 } 154 155 return 0; 156 } 157 158 static struct dentry *memtrace_debugfs_dir; 159 160 static int memtrace_init_debugfs(void) 161 { 162 int ret = 0; 163 int i; 164 165 for (i = 0; i < memtrace_array_nr; i++) { 166 struct dentry *dir; 167 struct memtrace_entry *ent = &memtrace_array[i]; 168 169 ent->mem = ioremap(ent->start, ent->size); 170 /* Warn but continue on */ 171 if (!ent->mem) { 172 pr_err("Failed to map trace memory at 0x%llx\n", 173 ent->start); 174 ret = -1; 175 continue; 176 } 177 178 snprintf(ent->name, 16, "%08x", ent->nid); 179 dir = debugfs_create_dir(ent->name, memtrace_debugfs_dir); 180 if (!dir) { 181 pr_err("Failed to create debugfs directory for node %d\n", 182 ent->nid); 183 return -1; 184 } 185 186 ent->dir = dir; 187 debugfs_create_file("trace", 0400, dir, ent, &memtrace_fops); 188 debugfs_create_x64("start", 0400, dir, &ent->start); 189 debugfs_create_x64("size", 0400, dir, &ent->size); 190 } 191 192 return ret; 193 } 194 195 static int online_mem_block(struct memory_block *mem, void *arg) 196 { 197 return device_online(&mem->dev); 198 } 199 200 /* 201 * Iterate through the chunks of memory we have removed from the kernel 202 * and attempt to add them back to the kernel. 203 */ 204 static int memtrace_online(void) 205 { 206 int i, ret = 0; 207 struct memtrace_entry *ent; 208 209 for (i = memtrace_array_nr - 1; i >= 0; i--) { 210 ent = &memtrace_array[i]; 211 212 /* We have onlined this chunk previously */ 213 if (ent->nid == -1) 214 continue; 215 216 /* Remove from io mappings */ 217 if (ent->mem) { 218 iounmap(ent->mem); 219 ent->mem = 0; 220 } 221 222 if (add_memory(ent->nid, ent->start, ent->size)) { 223 pr_err("Failed to add trace memory to node %d\n", 224 ent->nid); 225 ret += 1; 226 continue; 227 } 228 229 /* 230 * If kernel isn't compiled with the auto online option 231 * we need to online the memory ourselves. 232 */ 233 if (!memhp_auto_online) { 234 walk_memory_range(PFN_DOWN(ent->start), 235 PFN_UP(ent->start + ent->size - 1), 236 NULL, online_mem_block); 237 } 238 239 /* 240 * Memory was added successfully so clean up references to it 241 * so on reentry we can tell that this chunk was added. 242 */ 243 debugfs_remove_recursive(ent->dir); 244 pr_info("Added trace memory back to node %d\n", ent->nid); 245 ent->size = ent->start = ent->nid = -1; 246 } 247 if (ret) 248 return ret; 249 250 /* If all chunks of memory were added successfully, reset globals */ 251 kfree(memtrace_array); 252 memtrace_array = NULL; 253 memtrace_size = 0; 254 memtrace_array_nr = 0; 255 return 0; 256 } 257 258 static int memtrace_enable_set(void *data, u64 val) 259 { 260 u64 bytes; 261 262 /* 263 * Don't attempt to do anything if size isn't aligned to a memory 264 * block or equal to zero. 265 */ 266 bytes = memory_block_size_bytes(); 267 if (val & (bytes - 1)) { 268 pr_err("Value must be aligned with 0x%llx\n", bytes); 269 return -EINVAL; 270 } 271 272 /* Re-add/online previously removed/offlined memory */ 273 if (memtrace_size) { 274 if (memtrace_online()) 275 return -EAGAIN; 276 } 277 278 if (!val) 279 return 0; 280 281 /* Offline and remove memory */ 282 if (memtrace_init_regions_runtime(val)) 283 return -EINVAL; 284 285 if (memtrace_init_debugfs()) 286 return -EINVAL; 287 288 memtrace_size = val; 289 290 return 0; 291 } 292 293 static int memtrace_enable_get(void *data, u64 *val) 294 { 295 *val = memtrace_size; 296 return 0; 297 } 298 299 DEFINE_SIMPLE_ATTRIBUTE(memtrace_init_fops, memtrace_enable_get, 300 memtrace_enable_set, "0x%016llx\n"); 301 302 static int memtrace_init(void) 303 { 304 memtrace_debugfs_dir = debugfs_create_dir("memtrace", 305 powerpc_debugfs_root); 306 if (!memtrace_debugfs_dir) 307 return -1; 308 309 debugfs_create_file("enable", 0600, memtrace_debugfs_dir, 310 NULL, &memtrace_init_fops); 311 312 return 0; 313 } 314 machine_device_initcall(powernv, memtrace_init); 315