arch/s390/mm/cmm.c

   1 /*
   2  *  arch/s390/mm/cmm.c
   3  *
   4  *  S390 version
   5  *    Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
   6  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
   7  *
   8  *  Collaborative memory management interface.
   9  */
  10
  11 #include <linux/config.h>
  12 #include <linux/errno.h>
  13 #include <linux/fs.h>
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/sched.h>
  17 #include <linux/sysctl.h>
  18 #include <linux/ctype.h>
  19
  20 #include <asm/pgalloc.h>
  21 #include <asm/uaccess.h>
  22 #include <asm/smp.h>
  23
  24 #include "../../../drivers/s390/net/smsgiucv.h"
  25
  26 #define CMM_NR_PAGES ((PAGE_SIZE / sizeof(unsigned long)) - 2)
  27
  28 struct cmm_page_array {
  29         struct cmm_page_array *next;
  30         unsigned long index;
  31         unsigned long pages[CMM_NR_PAGES];
  32 };
  33
  34 static long cmm_pages = 0;
  35 static long cmm_timed_pages = 0;
  36 static volatile long cmm_pages_target = 0;
  37 static volatile long cmm_timed_pages_target = 0;
  38 static long cmm_timeout_pages = 0;
  39 static long cmm_timeout_seconds = 0;
  40
  41 static struct cmm_page_array *cmm_page_list = 0;
  42 static struct cmm_page_array *cmm_timed_page_list = 0;
  43
  44 static unsigned long cmm_thread_active = 0;
  45 static struct work_struct cmm_thread_starter;
  46 static wait_queue_head_t cmm_thread_wait;
  47 static struct timer_list cmm_timer;
  48
  49 static void cmm_timer_fn(unsigned long);
  50 static void cmm_set_timer(void);
  51
  52 static long
  53 cmm_strtoul(const char *cp, char **endp)
  54 {
  55         unsigned int base = 10;
  56
  57         if (*cp == '0') {
  58                 base = 8;
  59                 cp++;
  60                 if ((*cp == 'x' || *cp == 'X') && isxdigit(cp[1])) {
  61                         base = 16;
  62                         cp++;
  63                 }
  64         }
  65         return simple_strtoul(cp, endp, base);
  66 }
  67
  68 static long
  69 cmm_alloc_pages(long pages, long *counter, struct cmm_page_array **list)
  70 {
  71         struct cmm_page_array *pa;
  72         unsigned long page;
  73
  74         pa = *list;
  75         while (pages) {
  76                 page = __get_free_page(GFP_NOIO);
  77                 if (!page)
  78                         break;
  79                 if (!pa || pa->index >= CMM_NR_PAGES) {
  80                         /* Need a new page for the page list. */
  81                         pa = (struct cmm_page_array *)
  82                                 __get_free_page(GFP_NOIO);
  83                         if (!pa) {
  84                                 free_page(page);
  85                                 break;
  86                         }
  87                         pa->next = *list;
  88                         pa->index = 0;
  89                         *list = pa;
  90                 }
  91                 diag10(page);
  92                 pa->pages[pa->index++] = page;
  93                 (*counter)++;
  94                 pages--;
  95         }
  96         return pages;
  97 }
  98
  99 static void
 100 cmm_free_pages(long pages, long *counter, struct cmm_page_array **list)
 101 {
 102         struct cmm_page_array *pa;
 103         unsigned long page;
 104
 105         pa = *list;
 106         while (pages) {
 107                 if (!pa || pa->index <= 0)
 108                         break;
 109                 page = pa->pages[--pa->index];
 110                 if (pa->index == 0) {
 111                         pa = pa->next;
 112                         free_page((unsigned long) *list);
 113                         *list = pa;
 114                 }
 115                 free_page(page);
 116                 (*counter)--;
 117                 pages--;
 118         }
 119 }
 120
 121 static int
 122 cmm_thread(void *dummy)
 123 {
 124         int rc;
 125
 126         daemonize("cmmthread");
 127         set_cpus_allowed(current, cpumask_of_cpu(0));
 128         while (1) {
 129                 rc = wait_event_interruptible(cmm_thread_wait,
 130                         (cmm_pages != cmm_pages_target ||
 131                          cmm_timed_pages != cmm_timed_pages_target));
 132                 if (rc == -ERESTARTSYS) {
 133                         /* Got kill signal. End thread. */
 134                         clear_bit(0, &cmm_thread_active);
 135                         cmm_pages_target = cmm_pages;
 136                         cmm_timed_pages_target = cmm_timed_pages;
 137                         break;
 138                 }
 139                 if (cmm_pages_target > cmm_pages) {
 140                         if (cmm_alloc_pages(1, &cmm_pages, &cmm_page_list))
 141                                 cmm_pages_target = cmm_pages;
 142                 } else if (cmm_pages_target < cmm_pages) {
 143                         cmm_free_pages(1, &cmm_pages, &cmm_page_list);
 144                 }
 145                 if (cmm_timed_pages_target > cmm_timed_pages) {
 146                         if (cmm_alloc_pages(1, &cmm_timed_pages,
 147                                            &cmm_timed_page_list))
 148                                 cmm_timed_pages_target = cmm_timed_pages;
 149                 } else if (cmm_timed_pages_target < cmm_timed_pages) {
 150                         cmm_free_pages(1, &cmm_timed_pages,
 151                                        &cmm_timed_page_list);
 152                 }
 153                 if (cmm_timed_pages > 0 && !timer_pending(&cmm_timer))
 154                         cmm_set_timer();
 155         }
 156         return 0;
 157 }
 158
 159 static void
 160 cmm_start_thread(void)
 161 {
 162         kernel_thread(cmm_thread, 0, 0);
 163 }
 164
 165 static void
 166 cmm_kick_thread(void)
 167 {
 168         if (!test_and_set_bit(0, &cmm_thread_active))
 169                 schedule_work(&cmm_thread_starter);
 170         wake_up(&cmm_thread_wait);
 171 }
 172
 173 static void
 174 cmm_set_timer(void)
 175 {
 176         if (cmm_timed_pages_target <= 0 || cmm_timeout_seconds <= 0) {
 177                 if (timer_pending(&cmm_timer))
 178                         del_timer(&cmm_timer);
 179                 return;
 180         }
 181         if (timer_pending(&cmm_timer)) {
 182                 if (mod_timer(&cmm_timer, jiffies + cmm_timeout_seconds*HZ))
 183                         return;
 184         }
 185         cmm_timer.function = cmm_timer_fn;
 186         cmm_timer.data = 0;
 187         cmm_timer.expires = jiffies + cmm_timeout_seconds*HZ;
 188         add_timer(&cmm_timer);
 189 }
 190
 191 static void
 192 cmm_timer_fn(unsigned long ignored)
 193 {
 194         long pages;
 195
 196         pages = cmm_timed_pages_target - cmm_timeout_pages;
 197         if (pages < 0)
 198                 cmm_timed_pages_target = 0;
 199         else
 200                 cmm_timed_pages_target = pages;
 201         cmm_kick_thread();
 202         cmm_set_timer();
 203 }
 204
 205 void
 206 cmm_set_pages(long pages)
 207 {
 208         cmm_pages_target = pages;
 209         cmm_kick_thread();
 210 }
 211
 212 long
 213 cmm_get_pages(void)
 214 {
 215         return cmm_pages;
 216 }
 217
 218 void
 219 cmm_add_timed_pages(long pages)
 220 {
 221         cmm_timed_pages_target += pages;
 222         cmm_kick_thread();
 223 }
 224
 225 long
 226 cmm_get_timed_pages(void)
 227 {
 228         return cmm_timed_pages;
 229 }
 230
 231 void
 232 cmm_set_timeout(long pages, long seconds)
 233 {
 234         cmm_timeout_pages = pages;
 235         cmm_timeout_seconds = seconds;
 236         cmm_set_timer();
 237 }
 238
 239 static inline int
 240 cmm_skip_blanks(char *cp, char **endp)
 241 {
 242         char *str;
 243
 244         for (str = cp; *str == ' ' || *str == '\t'; str++);
 245         *endp = str;
 246         return str != cp;
 247 }
 248
 249 #ifdef CONFIG_CMM_PROC
 250 /* These will someday get removed. */
 251 #define VM_CMM_PAGES            1111
 252 #define VM_CMM_TIMED_PAGES      1112
 253 #define VM_CMM_TIMEOUT          1113
 254
 255 static struct ctl_table cmm_table[];
 256
 257 static int
 258 cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
 259                   void *buffer, size_t *lenp, loff_t *ppos)
 260 {
 261         char buf[16], *p;
 262         long pages;
 263         int len;
 264
 265         if (!*lenp || (*ppos && !write)) {
 266                 *lenp = 0;
 267                 return 0;
 268         }
 269
 270         if (write) {
 271                 len = *lenp;
 272                 if (copy_from_user(buf, buffer,
 273                                    len > sizeof(buf) ? sizeof(buf) : len))
 274                         return -EFAULT;
 275                 buf[sizeof(buf) - 1] = '\0';
 276                 cmm_skip_blanks(buf, &p);
 277                 pages = cmm_strtoul(p, &p);
 278                 if (ctl == &cmm_table[0])
 279                         cmm_set_pages(pages);
 280                 else
 281                         cmm_add_timed_pages(pages);
 282         } else {
 283                 if (ctl == &cmm_table[0])
 284                         pages = cmm_get_pages();
 285                 else
 286                         pages = cmm_get_timed_pages();
 287                 len = sprintf(buf, "%ld\n", pages);
 288                 if (len > *lenp)
 289                         len = *lenp;
 290                 if (copy_to_user(buffer, buf, len))
 291                         return -EFAULT;
 292         }
 293         *lenp = len;
 294         *ppos += len;
 295         return 0;
 296 }
 297
 298 static int
 299 cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
 300                     void *buffer, size_t *lenp, loff_t *ppos)
 301 {
 302         char buf[64], *p;
 303         long pages, seconds;
 304         int len;
 305
 306         if (!*lenp || (*ppos && !write)) {
 307                 *lenp = 0;
 308                 return 0;
 309         }
 310
 311         if (write) {
 312                 len = *lenp;
 313                 if (copy_from_user(buf, buffer,
 314                                    len > sizeof(buf) ? sizeof(buf) : len))
 315                         return -EFAULT;
 316                 buf[sizeof(buf) - 1] = '\0';
 317                 cmm_skip_blanks(buf, &p);
 318                 pages = cmm_strtoul(p, &p);
 319                 cmm_skip_blanks(p, &p);
 320                 seconds = cmm_strtoul(p, &p);
 321                 cmm_set_timeout(pages, seconds);
 322         } else {
 323                 len = sprintf(buf, "%ld %ld\n",
 324                               cmm_timeout_pages, cmm_timeout_seconds);
 325                 if (len > *lenp)
 326                         len = *lenp;
 327                 if (copy_to_user(buffer, buf, len))
 328                         return -EFAULT;
 329         }
 330         *lenp = len;
 331         *ppos += len;
 332         return 0;
 333 }
 334
 335 static struct ctl_table cmm_table[] = {
 336         {
 337                 .ctl_name       = VM_CMM_PAGES,
 338                 .procname       = "cmm_pages",
 339                 .mode           = 0600,
 340                 .proc_handler   = &cmm_pages_handler,
 341         },
 342         {
 343                 .ctl_name       = VM_CMM_TIMED_PAGES,
 344                 .procname       = "cmm_timed_pages",
 345                 .mode           = 0600,
 346                 .proc_handler   = &cmm_pages_handler,
 347         },
 348         {
 349                 .ctl_name       = VM_CMM_TIMEOUT,
 350                 .procname       = "cmm_timeout",
 351                 .mode           = 0600,
 352                 .proc_handler   = &cmm_timeout_handler,
 353         },
 354         { .ctl_name = 0 }
 355 };
 356
 357 static struct ctl_table cmm_dir_table[] = {
 358         {
 359                 .ctl_name       = CTL_VM,
 360                 .procname       = "vm",
 361                 .maxlen         = 0,
 362                 .mode           = 0555,
 363                 .child          = cmm_table,
 364         },
 365         { .ctl_name = 0 }
 366 };
 367 #endif
 368
 369 #ifdef CONFIG_CMM_IUCV
 370 #define SMSG_PREFIX "CMM"
 371 static void
 372 cmm_smsg_target(char *msg)
 373 {
 374         long pages, seconds;
 375
 376         if (!cmm_skip_blanks(msg + strlen(SMSG_PREFIX), &msg))
 377                 return;
 378         if (strncmp(msg, "SHRINK", 6) == 0) {
 379                 if (!cmm_skip_blanks(msg + 6, &msg))
 380                         return;
 381                 pages = cmm_strtoul(msg, &msg);
 382                 cmm_skip_blanks(msg, &msg);
 383                 if (*msg == '\0')
 384                         cmm_set_pages(pages);
 385         } else if (strncmp(msg, "RELEASE", 7) == 0) {
 386                 if (!cmm_skip_blanks(msg + 7, &msg))
 387                         return;
 388                 pages = cmm_strtoul(msg, &msg);
 389                 cmm_skip_blanks(msg, &msg);
 390                 if (*msg == '\0')
 391                         cmm_add_timed_pages(pages);
 392         } else if (strncmp(msg, "REUSE", 5) == 0) {
 393                 if (!cmm_skip_blanks(msg + 5, &msg))
 394                         return;
 395                 pages = cmm_strtoul(msg, &msg);
 396                 if (!cmm_skip_blanks(msg, &msg))
 397                         return;
 398                 seconds = cmm_strtoul(msg, &msg);
 399                 cmm_skip_blanks(msg, &msg);
 400                 if (*msg == '\0')
 401                         cmm_set_timeout(pages, seconds);
 402         }
 403 }
 404 #endif
 405
 406 struct ctl_table_header *cmm_sysctl_header;
 407
 408 static int
 409 cmm_init (void)
 410 {
 411         int rc;
 412
 413         /* Prevent logical cpu 0 from being set offline. */
 414         rc = smp_get_cpu(cpumask_of_cpu(0));
 415         if (rc) {
 416                 printk(KERN_ERR "CMM: unable to reserve cpu 0\n");
 417                 return rc;
 418         }
 419 #ifdef CONFIG_CMM_PROC
 420         cmm_sysctl_header = register_sysctl_table(cmm_dir_table, 1);
 421 #endif
 422 #ifdef CONFIG_CMM_IUCV
 423         smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
 424 #endif
 425         INIT_WORK(&cmm_thread_starter, (void *) cmm_start_thread, 0);
 426         init_waitqueue_head(&cmm_thread_wait);
 427         init_timer(&cmm_timer);
 428         return 0;
 429 }
 430
 431 static void
 432 cmm_exit(void)
 433 {
 434         cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
 435         cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
 436 #ifdef CONFIG_CMM_PROC
 437         unregister_sysctl_table(cmm_sysctl_header);
 438 #endif
 439 #ifdef CONFIG_CMM_IUCV
 440         smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
 441 #endif
 442         /* Allow logical cpu 0 to be set offline again. */
 443         smp_put_cpu(0);
 444 }
 445
 446 module_init(cmm_init);
 447 module_exit(cmm_exit);
 448
 449 EXPORT_SYMBOL(cmm_set_pages);
 450 EXPORT_SYMBOL(cmm_get_pages);
 451 EXPORT_SYMBOL(cmm_add_timed_pages);
 452 EXPORT_SYMBOL(cmm_get_timed_pages);
 453 EXPORT_SYMBOL(cmm_set_timeout);
 454
 455 MODULE_LICENSE("GPL");