1 /* 2 * Collaborative memory management interface. 3 * 4 * Copyright (C) 2008 IBM Corporation 5 * Author(s): Brian King (brking@linux.vnet.ibm.com), 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 * 21 */ 22 23 #include <linux/ctype.h> 24 #include <linux/delay.h> 25 #include <linux/errno.h> 26 #include <linux/fs.h> 27 #include <linux/init.h> 28 #include <linux/kthread.h> 29 #include <linux/module.h> 30 #include <linux/oom.h> 31 #include <linux/sched.h> 32 #include <linux/stringify.h> 33 #include <linux/swap.h> 34 #include <linux/sysdev.h> 35 #include <asm/firmware.h> 36 #include <asm/hvcall.h> 37 #include <asm/mmu.h> 38 #include <asm/pgalloc.h> 39 #include <asm/uaccess.h> 40 41 #include "plpar_wrappers.h" 42 43 #define CMM_DRIVER_VERSION "1.0.0" 44 #define CMM_DEFAULT_DELAY 1 45 #define CMM_DEBUG 0 46 #define CMM_DISABLE 0 47 #define CMM_OOM_KB 1024 48 #define CMM_MIN_MEM_MB 256 49 #define KB2PAGES(_p) ((_p)>>(PAGE_SHIFT-10)) 50 #define PAGES2KB(_p) ((_p)<<(PAGE_SHIFT-10)) 51 52 static unsigned int delay = CMM_DEFAULT_DELAY; 53 static unsigned int oom_kb = CMM_OOM_KB; 54 static unsigned int cmm_debug = CMM_DEBUG; 55 static unsigned int cmm_disabled = CMM_DISABLE; 56 static unsigned long min_mem_mb = CMM_MIN_MEM_MB; 57 static struct sys_device cmm_sysdev; 58 59 MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>"); 60 MODULE_DESCRIPTION("IBM System p Collaborative Memory Manager"); 61 MODULE_LICENSE("GPL"); 62 MODULE_VERSION(CMM_DRIVER_VERSION); 63 64 module_param_named(delay, delay, uint, S_IRUGO | S_IWUSR); 65 MODULE_PARM_DESC(delay, "Delay (in seconds) between polls to query hypervisor paging requests. " 66 "[Default=" __stringify(CMM_DEFAULT_DELAY) "]"); 67 module_param_named(oom_kb, oom_kb, uint, S_IRUGO | S_IWUSR); 68 MODULE_PARM_DESC(oom_kb, "Amount of memory in kb to free on OOM. " 69 "[Default=" __stringify(CMM_OOM_KB) "]"); 70 module_param_named(min_mem_mb, min_mem_mb, ulong, S_IRUGO | S_IWUSR); 71 MODULE_PARM_DESC(min_mem_mb, "Minimum amount of memory (in MB) to not balloon. " 72 "[Default=" __stringify(CMM_MIN_MEM_MB) "]"); 73 module_param_named(debug, cmm_debug, uint, S_IRUGO | S_IWUSR); 74 MODULE_PARM_DESC(debug, "Enable module debugging logging. Set to 1 to enable. " 75 "[Default=" __stringify(CMM_DEBUG) "]"); 76 77 #define CMM_NR_PAGES ((PAGE_SIZE - sizeof(void *) - sizeof(unsigned long)) / sizeof(unsigned long)) 78 79 #define cmm_dbg(...) if (cmm_debug) { printk(KERN_INFO "cmm: "__VA_ARGS__); } 80 81 struct cmm_page_array { 82 struct cmm_page_array *next; 83 unsigned long index; 84 unsigned long page[CMM_NR_PAGES]; 85 }; 86 87 static unsigned long loaned_pages; 88 static unsigned long loaned_pages_target; 89 static unsigned long oom_freed_pages; 90 91 static struct cmm_page_array *cmm_page_list; 92 static DEFINE_SPINLOCK(cmm_lock); 93 94 static struct task_struct *cmm_thread_ptr; 95 96 /** 97 * cmm_alloc_pages - Allocate pages and mark them as loaned 98 * @nr: number of pages to allocate 99 * 100 * Return value: 101 * number of pages requested to be allocated which were not 102 **/ 103 static long cmm_alloc_pages(long nr) 104 { 105 struct cmm_page_array *pa, *npa; 106 unsigned long addr; 107 long rc; 108 109 cmm_dbg("Begin request for %ld pages\n", nr); 110 111 while (nr) { 112 addr = __get_free_page(GFP_NOIO | __GFP_NOWARN | 113 __GFP_NORETRY | __GFP_NOMEMALLOC); 114 if (!addr) 115 break; 116 spin_lock(&cmm_lock); 117 pa = cmm_page_list; 118 if (!pa || pa->index >= CMM_NR_PAGES) { 119 /* Need a new page for the page list. */ 120 spin_unlock(&cmm_lock); 121 npa = (struct cmm_page_array *)__get_free_page(GFP_NOIO | __GFP_NOWARN | 122 __GFP_NORETRY | __GFP_NOMEMALLOC); 123 if (!npa) { 124 pr_info("%s: Can not allocate new page list\n", __func__); 125 free_page(addr); 126 break; 127 } 128 spin_lock(&cmm_lock); 129 pa = cmm_page_list; 130 131 if (!pa || pa->index >= CMM_NR_PAGES) { 132 npa->next = pa; 133 npa->index = 0; 134 pa = npa; 135 cmm_page_list = pa; 136 } else 137 free_page((unsigned long) npa); 138 } 139 140 if ((rc = plpar_page_set_loaned(__pa(addr)))) { 141 pr_err("%s: Can not set page to loaned. rc=%ld\n", __func__, rc); 142 spin_unlock(&cmm_lock); 143 free_page(addr); 144 break; 145 } 146 147 pa->page[pa->index++] = addr; 148 loaned_pages++; 149 totalram_pages--; 150 spin_unlock(&cmm_lock); 151 nr--; 152 } 153 154 cmm_dbg("End request with %ld pages unfulfilled\n", nr); 155 return nr; 156 } 157 158 /** 159 * cmm_free_pages - Free pages and mark them as active 160 * @nr: number of pages to free 161 * 162 * Return value: 163 * number of pages requested to be freed which were not 164 **/ 165 static long cmm_free_pages(long nr) 166 { 167 struct cmm_page_array *pa; 168 unsigned long addr; 169 170 cmm_dbg("Begin free of %ld pages.\n", nr); 171 spin_lock(&cmm_lock); 172 pa = cmm_page_list; 173 while (nr) { 174 if (!pa || pa->index <= 0) 175 break; 176 addr = pa->page[--pa->index]; 177 178 if (pa->index == 0) { 179 pa = pa->next; 180 free_page((unsigned long) cmm_page_list); 181 cmm_page_list = pa; 182 } 183 184 plpar_page_set_active(__pa(addr)); 185 free_page(addr); 186 loaned_pages--; 187 nr--; 188 totalram_pages++; 189 } 190 spin_unlock(&cmm_lock); 191 cmm_dbg("End request with %ld pages unfulfilled\n", nr); 192 return nr; 193 } 194 195 /** 196 * cmm_oom_notify - OOM notifier 197 * @self: notifier block struct 198 * @dummy: not used 199 * @parm: returned - number of pages freed 200 * 201 * Return value: 202 * NOTIFY_OK 203 **/ 204 static int cmm_oom_notify(struct notifier_block *self, 205 unsigned long dummy, void *parm) 206 { 207 unsigned long *freed = parm; 208 long nr = KB2PAGES(oom_kb); 209 210 cmm_dbg("OOM processing started\n"); 211 nr = cmm_free_pages(nr); 212 loaned_pages_target = loaned_pages; 213 *freed += KB2PAGES(oom_kb) - nr; 214 oom_freed_pages += KB2PAGES(oom_kb) - nr; 215 cmm_dbg("OOM processing complete\n"); 216 return NOTIFY_OK; 217 } 218 219 /** 220 * cmm_get_mpp - Read memory performance parameters 221 * 222 * Makes hcall to query the current page loan request from the hypervisor. 223 * 224 * Return value: 225 * nothing 226 **/ 227 static void cmm_get_mpp(void) 228 { 229 int rc; 230 struct hvcall_mpp_data mpp_data; 231 unsigned long active_pages_target; 232 signed long page_loan_request; 233 234 rc = h_get_mpp(&mpp_data); 235 236 if (rc != H_SUCCESS) 237 return; 238 239 page_loan_request = div_s64((s64)mpp_data.loan_request, PAGE_SIZE); 240 loaned_pages_target = page_loan_request + loaned_pages; 241 if (loaned_pages_target > oom_freed_pages) 242 loaned_pages_target -= oom_freed_pages; 243 else 244 loaned_pages_target = 0; 245 246 active_pages_target = totalram_pages + loaned_pages - loaned_pages_target; 247 248 if ((min_mem_mb * 1024 * 1024) > (active_pages_target * PAGE_SIZE)) 249 loaned_pages_target = totalram_pages + loaned_pages - 250 ((min_mem_mb * 1024 * 1024) / PAGE_SIZE); 251 252 cmm_dbg("delta = %ld, loaned = %lu, target = %lu, oom = %lu, totalram = %lu\n", 253 page_loan_request, loaned_pages, loaned_pages_target, 254 oom_freed_pages, totalram_pages); 255 } 256 257 static struct notifier_block cmm_oom_nb = { 258 .notifier_call = cmm_oom_notify 259 }; 260 261 /** 262 * cmm_thread - CMM task thread 263 * @dummy: not used 264 * 265 * Return value: 266 * 0 267 **/ 268 static int cmm_thread(void *dummy) 269 { 270 unsigned long timeleft; 271 272 while (1) { 273 timeleft = msleep_interruptible(delay * 1000); 274 275 if (kthread_should_stop() || timeleft) { 276 loaned_pages_target = loaned_pages; 277 break; 278 } 279 280 cmm_get_mpp(); 281 282 if (loaned_pages_target > loaned_pages) { 283 if (cmm_alloc_pages(loaned_pages_target - loaned_pages)) 284 loaned_pages_target = loaned_pages; 285 } else if (loaned_pages_target < loaned_pages) 286 cmm_free_pages(loaned_pages - loaned_pages_target); 287 } 288 return 0; 289 } 290 291 #define CMM_SHOW(name, format, args...) \ 292 static ssize_t show_##name(struct sys_device *dev, \ 293 struct sysdev_attribute *attr, \ 294 char *buf) \ 295 { \ 296 return sprintf(buf, format, ##args); \ 297 } \ 298 static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL) 299 300 CMM_SHOW(loaned_kb, "%lu\n", PAGES2KB(loaned_pages)); 301 CMM_SHOW(loaned_target_kb, "%lu\n", PAGES2KB(loaned_pages_target)); 302 303 static ssize_t show_oom_pages(struct sys_device *dev, 304 struct sysdev_attribute *attr, char *buf) 305 { 306 return sprintf(buf, "%lu\n", PAGES2KB(oom_freed_pages)); 307 } 308 309 static ssize_t store_oom_pages(struct sys_device *dev, 310 struct sysdev_attribute *attr, 311 const char *buf, size_t count) 312 { 313 unsigned long val = simple_strtoul (buf, NULL, 10); 314 315 if (!capable(CAP_SYS_ADMIN)) 316 return -EPERM; 317 if (val != 0) 318 return -EBADMSG; 319 320 oom_freed_pages = 0; 321 return count; 322 } 323 324 static SYSDEV_ATTR(oom_freed_kb, S_IWUSR| S_IRUGO, 325 show_oom_pages, store_oom_pages); 326 327 static struct sysdev_attribute *cmm_attrs[] = { 328 &attr_loaned_kb, 329 &attr_loaned_target_kb, 330 &attr_oom_freed_kb, 331 }; 332 333 static struct sysdev_class cmm_sysdev_class = { 334 .name = "cmm", 335 }; 336 337 /** 338 * cmm_sysfs_register - Register with sysfs 339 * 340 * Return value: 341 * 0 on success / other on failure 342 **/ 343 static int cmm_sysfs_register(struct sys_device *sysdev) 344 { 345 int i, rc; 346 347 if ((rc = sysdev_class_register(&cmm_sysdev_class))) 348 return rc; 349 350 sysdev->id = 0; 351 sysdev->cls = &cmm_sysdev_class; 352 353 if ((rc = sysdev_register(sysdev))) 354 goto class_unregister; 355 356 for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) { 357 if ((rc = sysdev_create_file(sysdev, cmm_attrs[i]))) 358 goto fail; 359 } 360 361 return 0; 362 363 fail: 364 while (--i >= 0) 365 sysdev_remove_file(sysdev, cmm_attrs[i]); 366 sysdev_unregister(sysdev); 367 class_unregister: 368 sysdev_class_unregister(&cmm_sysdev_class); 369 return rc; 370 } 371 372 /** 373 * cmm_unregister_sysfs - Unregister from sysfs 374 * 375 **/ 376 static void cmm_unregister_sysfs(struct sys_device *sysdev) 377 { 378 int i; 379 380 for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) 381 sysdev_remove_file(sysdev, cmm_attrs[i]); 382 sysdev_unregister(sysdev); 383 sysdev_class_unregister(&cmm_sysdev_class); 384 } 385 386 /** 387 * cmm_init - Module initialization 388 * 389 * Return value: 390 * 0 on success / other on failure 391 **/ 392 static int cmm_init(void) 393 { 394 int rc = -ENOMEM; 395 396 if (!firmware_has_feature(FW_FEATURE_CMO)) 397 return -EOPNOTSUPP; 398 399 if ((rc = register_oom_notifier(&cmm_oom_nb)) < 0) 400 return rc; 401 402 if ((rc = cmm_sysfs_register(&cmm_sysdev))) 403 goto out_oom_notifier; 404 405 if (cmm_disabled) 406 return rc; 407 408 cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread"); 409 if (IS_ERR(cmm_thread_ptr)) { 410 rc = PTR_ERR(cmm_thread_ptr); 411 goto out_unregister_sysfs; 412 } 413 414 return rc; 415 416 out_unregister_sysfs: 417 cmm_unregister_sysfs(&cmm_sysdev); 418 out_oom_notifier: 419 unregister_oom_notifier(&cmm_oom_nb); 420 return rc; 421 } 422 423 /** 424 * cmm_exit - Module exit 425 * 426 * Return value: 427 * nothing 428 **/ 429 static void cmm_exit(void) 430 { 431 if (cmm_thread_ptr) 432 kthread_stop(cmm_thread_ptr); 433 unregister_oom_notifier(&cmm_oom_nb); 434 cmm_free_pages(loaned_pages); 435 cmm_unregister_sysfs(&cmm_sysdev); 436 } 437 438 /** 439 * cmm_set_disable - Disable/Enable CMM 440 * 441 * Return value: 442 * 0 on success / other on failure 443 **/ 444 static int cmm_set_disable(const char *val, struct kernel_param *kp) 445 { 446 int disable = simple_strtoul(val, NULL, 10); 447 448 if (disable != 0 && disable != 1) 449 return -EINVAL; 450 451 if (disable && !cmm_disabled) { 452 if (cmm_thread_ptr) 453 kthread_stop(cmm_thread_ptr); 454 cmm_thread_ptr = NULL; 455 cmm_free_pages(loaned_pages); 456 } else if (!disable && cmm_disabled) { 457 cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread"); 458 if (IS_ERR(cmm_thread_ptr)) 459 return PTR_ERR(cmm_thread_ptr); 460 } 461 462 cmm_disabled = disable; 463 return 0; 464 } 465 466 module_param_call(disable, cmm_set_disable, param_get_uint, 467 &cmm_disabled, S_IRUGO | S_IWUSR); 468 MODULE_PARM_DESC(disable, "Disable CMM. Set to 1 to disable. " 469 "[Default=" __stringify(CMM_DISABLE) "]"); 470 471 module_init(cmm_init); 472 module_exit(cmm_exit); 473