git.oblomov.eu Git - linux-2.6/blob - mm/memcontrol.c

   1 /* memcontrol.c - Memory Controller
   2  *
   3  * Copyright IBM Corporation, 2007
   4  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
   5  *
   6  * Copyright 2007 OpenVZ SWsoft Inc
   7  * Author: Pavel Emelianov <xemul@openvz.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #include <linux/res_counter.h>
  21 #include <linux/memcontrol.h>
  22 #include <linux/cgroup.h>
  23 #include <linux/mm.h>
  24
  25 struct cgroup_subsys mem_cgroup_subsys;
  26
  27 /*
  28  * The memory controller data structure. The memory controller controls both
  29  * page cache and RSS per cgroup. We would eventually like to provide
  30  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
  31  * to help the administrator determine what knobs to tune.
  32  *
  33  * TODO: Add a water mark for the memory controller. Reclaim will begin when
  34  * we hit the water mark.
  35  */
  36 struct mem_cgroup {
  37         struct cgroup_subsys_state css;
  38         /*
  39          * the counter to account for memory usage
  40          */
  41         struct res_counter res;
  42         /*
  43          * Per cgroup active and inactive list, similar to the
  44          * per zone LRU lists.
  45          * TODO: Consider making these lists per zone
  46          */
  47         struct list_head active_list;
  48         struct list_head inactive_list;
  49 };
  50
  51 /*
  52  * A page_cgroup page is associated with every page descriptor. The
  53  * page_cgroup helps us identify information about the cgroup
  54  */
  55 struct page_cgroup {
  56         struct list_head lru;           /* per cgroup LRU list */
  57         struct page *page;
  58         struct mem_cgroup *mem_cgroup;
  59 };
  60
  61
  62 static inline
  63 struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont)
  64 {
  65         return container_of(cgroup_subsys_state(cont,
  66                                 mem_cgroup_subsys_id), struct mem_cgroup,
  67                                 css);
  68 }
  69
  70 static inline
  71 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
  72 {
  73         return container_of(task_subsys_state(p, mem_cgroup_subsys_id),
  74                                 struct mem_cgroup, css);
  75 }
  76
  77 void mm_init_cgroup(struct mm_struct *mm, struct task_struct *p)
  78 {
  79         struct mem_cgroup *mem;
  80
  81         mem = mem_cgroup_from_task(p);
  82         css_get(&mem->css);
  83         mm->mem_cgroup = mem;
  84 }
  85
  86 void mm_free_cgroup(struct mm_struct *mm)
  87 {
  88         css_put(&mm->mem_cgroup->css);
  89 }
  90
  91 void page_assign_page_cgroup(struct page *page, struct page_cgroup *pc)
  92 {
  93         page->page_cgroup = (unsigned long)pc;
  94 }
  95
  96 struct page_cgroup *page_get_page_cgroup(struct page *page)
  97 {
  98         return page->page_cgroup;
  99 }
 100
 101 static ssize_t mem_cgroup_read(struct cgroup *cont, struct cftype *cft,
 102                         struct file *file, char __user *userbuf, size_t nbytes,
 103                         loff_t *ppos)
 104 {
 105         return res_counter_read(&mem_cgroup_from_cont(cont)->res,
 106                                 cft->private, userbuf, nbytes, ppos);
 107 }
 108
 109 static ssize_t mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
 110                                 struct file *file, const char __user *userbuf,
 111                                 size_t nbytes, loff_t *ppos)
 112 {
 113         return res_counter_write(&mem_cgroup_from_cont(cont)->res,
 114                                 cft->private, userbuf, nbytes, ppos);
 115 }
 116
 117 static struct cftype mem_cgroup_files[] = {
 118         {
 119                 .name = "usage",
 120                 .private = RES_USAGE,
 121                 .read = mem_cgroup_read,
 122         },
 123         {
 124                 .name = "limit",
 125                 .private = RES_LIMIT,
 126                 .write = mem_cgroup_write,
 127                 .read = mem_cgroup_read,
 128         },
 129         {
 130                 .name = "failcnt",
 131                 .private = RES_FAILCNT,
 132                 .read = mem_cgroup_read,
 133         },
 134 };
 135
 136 static struct mem_cgroup init_mem_cgroup;
 137
 138 static struct cgroup_subsys_state *
 139 mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
 140 {
 141         struct mem_cgroup *mem;
 142
 143         if (unlikely((cont->parent) == NULL)) {
 144                 mem = &init_mem_cgroup;
 145                 init_mm.mem_cgroup = mem;
 146         } else
 147                 mem = kzalloc(sizeof(struct mem_cgroup), GFP_KERNEL);
 148
 149         if (mem == NULL)
 150                 return NULL;
 151
 152         res_counter_init(&mem->res);
 153         return &mem->css;
 154 }
 155
 156 static void mem_cgroup_destroy(struct cgroup_subsys *ss,
 157                                 struct cgroup *cont)
 158 {
 159         kfree(mem_cgroup_from_cont(cont));
 160 }
 161
 162 static int mem_cgroup_populate(struct cgroup_subsys *ss,
 163                                 struct cgroup *cont)
 164 {
 165         return cgroup_add_files(cont, ss, mem_cgroup_files,
 166                                         ARRAY_SIZE(mem_cgroup_files));
 167 }
 168
 169 struct cgroup_subsys mem_cgroup_subsys = {
 170         .name = "memory",
 171         .subsys_id = mem_cgroup_subsys_id,
 172         .create = mem_cgroup_create,
 173         .destroy = mem_cgroup_destroy,
 174         .populate = mem_cgroup_populate,
 175         .early_init = 1,
 176 };