1 files changed, 213 insertions, 118 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 6d8de051382b..b9d467d83fc1 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -44,6 +44,7 @@
 #include <linux/kmod.h>
 #include <linux/delayacct.h>
 #include <linux/cgroupstats.h>
+#include <linux/hash.h>
 
 #include <asm/atomic.h>
 
@@ -118,17 +119,7 @@ static int root_count;
  * be called.
  */
 static int need_forkexit_callback;
-
-/* bits in struct cgroup flags field */
-enum {
-        /* Control Group is dead */
-        CGRP_REMOVED,
-        /* Control Group has previously had a child cgroup or a task,
-         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
-        CGRP_RELEASABLE,
-        /* Control Group requires release notifications to userspace */
-        CGRP_NOTIFY_ON_RELEASE,
-};
+static int need_mm_owner_callback __read_mostly;
 
 /* convenient tests for these bits */
 inline int cgroup_is_removed(const struct cgroup *cgrp)
@@ -204,6 +195,27 @@ static struct cg_cgroup_link init_css_set_link;
 static DEFINE_RWLOCK(css_set_lock);
 static int css_set_count;
 
+/* hash table for cgroup groups. This improves the performance to
+ * find an existing css_set */
+#define CSS_SET_HASH_BITS       7
+#define CSS_SET_TABLE_SIZE      (1 << CSS_SET_HASH_BITS)
+static struct hlist_head css_set_table[CSS_SET_TABLE_SIZE];
+
+static struct hlist_head *css_set_hash(struct cgroup_subsys_state *css[])
+{
+        int i;
+        int index;
+        unsigned long tmp = 0UL;
+
+        for (i = 0; i < CGROUP_SUBSYS_COUNT; i++)
+                tmp += (unsigned long)css[i];
+        tmp = (tmp >> 16) ^ tmp;
+
+        index = hash_long(tmp, CSS_SET_HASH_BITS);
+
+        return &css_set_table[index];
+}
+
 /* We don't maintain the lists running through each css_set to its
  * task until after the first call to cgroup_iter_start(). This
  * reduces the fork()/exit() overhead for people who have cgroups
@@ -230,7 +242,7 @@ static int use_task_css_set_links;
 static void unlink_css_set(struct css_set *cg)
 {
         write_lock(&css_set_lock);
-        list_del(&cg->list);
+        hlist_del(&cg->hlist);
         css_set_count--;
         while (!list_empty(&cg->cg_links)) {
                 struct cg_cgroup_link *link;
@@ -295,9 +307,7 @@ static inline void put_css_set_taskexit(struct css_set *cg)
 /*
  * find_existing_css_set() is a helper for
  * find_css_set(), and checks to see whether an existing
- * css_set is suitable. This currently walks a linked-list for
- * simplicity; a later patch will use a hash table for better
- * performance
+ * css_set is suitable.
  *
  * oldcg: the cgroup group that we're using before the cgroup
  * transition
@@ -314,7 +324,9 @@ static struct css_set *find_existing_css_set(
 {
         int i;
         struct cgroupfs_root *root = cgrp->root;
-        struct list_head *l = &init_css_set.list;
+        struct hlist_head *hhead;
+        struct hlist_node *node;
+        struct css_set *cg;
 
         /* Built the set of subsystem state objects that we want to
          * see in the new css_set */
@@ -331,18 +343,13 @@ static struct css_set *find_existing_css_set(
                 }
         }
 
-        /* Look through existing cgroup groups to find one to reuse */
-        do {
-                struct css_set *cg =
-                        list_entry(l, struct css_set, list);
-
+        hhead = css_set_hash(template);
+        hlist_for_each_entry(cg, node, hhead, hlist) {
                 if (!memcmp(template, cg->subsys, sizeof(cg->subsys))) {
                         /* All subsystems matched */
                         return cg;
                 }
-                /* Try the next cgroup group */
-                l = l->next;
-        } while (l != &init_css_set.list);
+        }
 
         /* No existing cgroup group matched */
         return NULL;
@@ -404,6 +411,8 @@ static struct css_set *find_css_set(
         struct list_head tmp_cg_links;
         struct cg_cgroup_link *link;
 
+        struct hlist_head *hhead;
+
         /* First see if we already have a cgroup group that matches
          * the desired set */
         write_lock(&css_set_lock);
@@ -428,6 +437,7 @@ static struct css_set *find_css_set(
         kref_init(&res->ref);
         INIT_LIST_HEAD(&res->cg_links);
         INIT_LIST_HEAD(&res->tasks);
+        INIT_HLIST_NODE(&res->hlist);
 
         /* Copy the set of subsystem state objects generated in
          * find_existing_css_set() */
@@ -467,9 +477,12 @@ static struct css_set *find_css_set(
 
         BUG_ON(!list_empty(&tmp_cg_links));
 
-        /* Link this cgroup group into the list */
-        list_add(&res->list, &init_css_set.list);
         css_set_count++;
+
+        /* Add this cgroup group to the hash table */
+        hhead = css_set_hash(res->subsys);
+        hlist_add_head(&res->hlist, hhead);
+
         write_unlock(&css_set_lock);
 
         return res;
@@ -948,7 +961,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
         int ret = 0;
         struct super_block *sb;
         struct cgroupfs_root *root;
-        struct list_head tmp_cg_links, *l;
+        struct list_head tmp_cg_links;
         INIT_LIST_HEAD(&tmp_cg_links);
 
         /* First find the desired set of subsystems */
@@ -990,6 +1003,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
                 /* New superblock */
                 struct cgroup *cgrp = &root->top_cgroup;
                 struct inode *inode;
+                int i;
 
                 BUG_ON(sb->s_root != NULL);
 
@@ -1034,22 +1048,25 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
                 /* Link the top cgroup in this hierarchy into all
                  * the css_set objects */
                 write_lock(&css_set_lock);
-                l = &init_css_set.list;
-                do {
+                for (i = 0; i < CSS_SET_TABLE_SIZE; i++) {
+                        struct hlist_head *hhead = &css_set_table[i];
+                        struct hlist_node *node;
                         struct css_set *cg;
-                        struct cg_cgroup_link *link;
-                        cg = list_entry(l, struct css_set, list);
-                        BUG_ON(list_empty(&tmp_cg_links));
-                        link = list_entry(tmp_cg_links.next,
-                                          struct cg_cgroup_link,
-                                          cgrp_link_list);
-                        list_del(&link->cgrp_link_list);
-                        link->cg = cg;
-                        list_add(&link->cgrp_link_list,
-                                 &root->top_cgroup.css_sets);
-                        list_add(&link->cg_link_list, &cg->cg_links);
-                        l = l->next;
-                } while (l != &init_css_set.list);
+
+                        hlist_for_each_entry(cg, node, hhead, hlist) {
+                                struct cg_cgroup_link *link;
+
+                                BUG_ON(list_empty(&tmp_cg_links));
+                                link = list_entry(tmp_cg_links.next,
+                                                  struct cg_cgroup_link,
+                                                  cgrp_link_list);
+                                list_del(&link->cgrp_link_list);
+                                link->cg = cg;
+                                list_add(&link->cgrp_link_list,
+                                         &root->top_cgroup.css_sets);
+                                list_add(&link->cg_link_list, &cg->cg_links);
+                        }
+                }
                 write_unlock(&css_set_lock);
 
                 free_cg_links(&tmp_cg_links);
@@ -1307,18 +1324,16 @@ enum cgroup_filetype {
         FILE_DIR,
         FILE_TASKLIST,
         FILE_NOTIFY_ON_RELEASE,
-        FILE_RELEASABLE,
         FILE_RELEASE_AGENT,
 };
 
-static ssize_t cgroup_write_uint(struct cgroup *cgrp, struct cftype *cft,
-                                 struct file *file,
-                                 const char __user *userbuf,
-                                 size_t nbytes, loff_t *unused_ppos)
+static ssize_t cgroup_write_X64(struct cgroup *cgrp, struct cftype *cft,
+                                struct file *file,
+                                const char __user *userbuf,
+                                size_t nbytes, loff_t *unused_ppos)
 {
         char buffer[64];
         int retval = 0;
-        u64 val;
         char *end;
 
         if (!nbytes)
@@ -1329,16 +1344,18 @@ static ssize_t cgroup_write_uint(struct cgroup *cgrp, struct cftype *cft,
                 return -EFAULT;
 
         buffer[nbytes] = 0;     /* nul-terminate */
-
-        /* strip newline if necessary */
-        if (nbytes && (buffer[nbytes-1] == '\n'))
-                buffer[nbytes-1] = 0;
-        val = simple_strtoull(buffer, &end, 0);
-        if (*end)
-                return -EINVAL;
-
-        /* Pass to subsystem */
-        retval = cft->write_uint(cgrp, cft, val);
+        strstrip(buffer);
+        if (cft->write_u64) {
+                u64 val = simple_strtoull(buffer, &end, 0);
+                if (*end)
+                        return -EINVAL;
+                retval = cft->write_u64(cgrp, cft, val);
+        } else {
+                s64 val = simple_strtoll(buffer, &end, 0);
+                if (*end)
+                        return -EINVAL;
+                retval = cft->write_s64(cgrp, cft, val);
+        }
         if (!retval)
                 retval = nbytes;
         return retval;
@@ -1419,23 +1436,39 @@ static ssize_t cgroup_file_write(struct file *file, const char __user *buf,
                 return -ENODEV;
         if (cft->write)
                 return cft->write(cgrp, cft, file, buf, nbytes, ppos);
-        if (cft->write_uint)
-                return cgroup_write_uint(cgrp, cft, file, buf, nbytes, ppos);
+        if (cft->write_u64 || cft->write_s64)
+                return cgroup_write_X64(cgrp, cft, file, buf, nbytes, ppos);
+        if (cft->trigger) {
+                int ret = cft->trigger(cgrp, (unsigned int)cft->private);
+                return ret ? ret : nbytes;
+        }
         return -EINVAL;
 }
 
-static ssize_t cgroup_read_uint(struct cgroup *cgrp, struct cftype *cft,
-                                   struct file *file,
-                                   char __user *buf, size_t nbytes,
-                                   loff_t *ppos)
+static ssize_t cgroup_read_u64(struct cgroup *cgrp, struct cftype *cft,
+                               struct file *file,
+                               char __user *buf, size_t nbytes,
+                               loff_t *ppos)
 {
         char tmp[64];
-        u64 val = cft->read_uint(cgrp, cft);
+        u64 val = cft->read_u64(cgrp, cft);
         int len = sprintf(tmp, "%llu\n", (unsigned long long) val);
 
         return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
 }
 
+static ssize_t cgroup_read_s64(struct cgroup *cgrp, struct cftype *cft,
+                               struct file *file,
+                               char __user *buf, size_t nbytes,
+                               loff_t *ppos)
+{
+        char tmp[64];
+        s64 val = cft->read_s64(cgrp, cft);
+        int len = sprintf(tmp, "%lld\n", (long long) val);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
+}
+
 static ssize_t cgroup_common_file_read(struct cgroup *cgrp,
                                           struct cftype *cft,
                                           struct file *file,
@@ -1490,11 +1523,56 @@ static ssize_t cgroup_file_read(struct file *file, char __user *buf,
 
         if (cft->read)
                 return cft->read(cgrp, cft, file, buf, nbytes, ppos);
-        if (cft->read_uint)
-                return cgroup_read_uint(cgrp, cft, file, buf, nbytes, ppos);
+        if (cft->read_u64)
+                return cgroup_read_u64(cgrp, cft, file, buf, nbytes, ppos);
+        if (cft->read_s64)
+                return cgroup_read_s64(cgrp, cft, file, buf, nbytes, ppos);
         return -EINVAL;
 }
 
+/*
+ * seqfile ops/methods for returning structured data. Currently just
+ * supports string->u64 maps, but can be extended in future.
+ */
+
+struct cgroup_seqfile_state {
+        struct cftype *cft;
+        struct cgroup *cgroup;
+};
+
+static int cgroup_map_add(struct cgroup_map_cb *cb, const char *key, u64 value)
+{
+        struct seq_file *sf = cb->state;
+        return seq_printf(sf, "%s %llu\n", key, (unsigned long long)value);
+}
+
+static int cgroup_seqfile_show(struct seq_file *m, void *arg)
+{
+        struct cgroup_seqfile_state *state = m->private;
+        struct cftype *cft = state->cft;
+        if (cft->read_map) {
+                struct cgroup_map_cb cb = {
+                        .fill = cgroup_map_add,
+                        .state = m,
+                };
+                return cft->read_map(state->cgroup, cft, &cb);
+        }
+        return cft->read_seq_string(state->cgroup, cft, m);
+}
+
+int cgroup_seqfile_release(struct inode *inode, struct file *file)
+{
+        struct seq_file *seq = file->private_data;
+        kfree(seq->private);
+        return single_release(inode, file);
+}
+
+static struct file_operations cgroup_seqfile_operations = {
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = cgroup_seqfile_release,
+};
+
 static int cgroup_file_open(struct inode *inode, struct file *file)
 {
         int err;
@@ -1507,7 +1585,18 @@ static int cgroup_file_open(struct inode *inode, struct file *file)
         cft = __d_cft(file->f_dentry);
         if (!cft)
                 return -ENODEV;
-        if (cft->open)
+        if (cft->read_map || cft->read_seq_string) {
+                struct cgroup_seqfile_state *state =
+                        kzalloc(sizeof(*state), GFP_USER);
+                if (!state)
+                        return -ENOMEM;
+                state->cft = cft;
+                state->cgroup = __d_cgrp(file->f_dentry->d_parent);
+                file->f_op = &cgroup_seqfile_operations;
+                err = single_open(file, cgroup_seqfile_show, state);
+                if (err < 0)
+                        kfree(state);
+        } else if (cft->open)
                 err = cft->open(inode, file);
         else
                 err = 0;
@@ -1715,7 +1804,7 @@ static void cgroup_advance_iter(struct cgroup *cgrp,
  * The tasklist_lock is not held here, as do_each_thread() and
  * while_each_thread() are protected by RCU.
  */
-void cgroup_enable_task_cg_lists(void)
+static void cgroup_enable_task_cg_lists(void)
 {
         struct task_struct *p, *g;
         write_lock(&css_set_lock);
@@ -1913,14 +2002,14 @@ int cgroup_scan_tasks(struct cgroup_scanner *scan)
 
         if (heap->size) {
                 for (i = 0; i < heap->size; i++) {
-                        struct task_struct *p = heap->ptrs[i];
+                        struct task_struct *q = heap->ptrs[i];
                         if (i == 0) {
-                                latest_time = p->start_time;
-                                latest_task = p;
+                                latest_time = q->start_time;
+                                latest_task = q;
                         }
                         /* Process the task per the caller's callback */
-                        scan->process_task(p, scan);
-                        put_task_struct(p);
+                        scan->process_task(q, scan);
+                        put_task_struct(q);
                 }
                 /*
                  * If we had to process any tasks at all, scan again
@@ -2138,11 +2227,6 @@ static u64 cgroup_read_notify_on_release(struct cgroup *cgrp,
         return notify_on_release(cgrp);
 }
 
-static u64 cgroup_read_releasable(struct cgroup *cgrp, struct cftype *cft)
-{
-        return test_bit(CGRP_RELEASABLE, &cgrp->flags);
-}
-
 /*
  * for the common functions, 'private' gives the type of file
  */
@@ -2158,16 +2242,10 @@ static struct cftype files[] = {
 
         {
                 .name = "notify_on_release",
-                .read_uint = cgroup_read_notify_on_release,
+                .read_u64 = cgroup_read_notify_on_release,
                 .write = cgroup_common_file_write,
                 .private = FILE_NOTIFY_ON_RELEASE,
         },
-
-        {
-                .name = "releasable",
-                .read_uint = cgroup_read_releasable,
-                .private = FILE_RELEASABLE,
-        }
 };
 
 static struct cftype cft_release_agent = {
@@ -2401,10 +2479,9 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
         return 0;
 }
 
-static void cgroup_init_subsys(struct cgroup_subsys *ss)
+static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
 {
         struct cgroup_subsys_state *css;
-        struct list_head *l;
 
         printk(KERN_INFO "Initializing cgroup subsys %s\n", ss->name);
 
@@ -2415,34 +2492,19 @@ static void cgroup_init_subsys(struct cgroup_subsys *ss)
         BUG_ON(IS_ERR(css));
         init_cgroup_css(css, ss, dummytop);
 
-        /* Update all cgroup groups to contain a subsys
+        /* Update the init_css_set to contain a subsys
          * pointer to this state - since the subsystem is
-         * newly registered, all tasks and hence all cgroup
-         * groups are in the subsystem's top cgroup. */
-        write_lock(&css_set_lock);
-        l = &init_css_set.list;
-        do {
-                struct css_set *cg =
-                        list_entry(l, struct css_set, list);
-                cg->subsys[ss->subsys_id] = dummytop->subsys[ss->subsys_id];
-                l = l->next;
-        } while (l != &init_css_set.list);
-        write_unlock(&css_set_lock);
-
-        /* If this subsystem requested that it be notified with fork
-         * events, we should send it one now for every process in the
-         * system */
-        if (ss->fork) {
-                struct task_struct *g, *p;
-
-                read_lock(&tasklist_lock);
-                do_each_thread(g, p) {
-                        ss->fork(ss, p);
-                } while_each_thread(g, p);
-                read_unlock(&tasklist_lock);
-        }
+         * newly registered, all tasks and hence the
+         * init_css_set is in the subsystem's top cgroup. */
+        init_css_set.subsys[ss->subsys_id] = dummytop->subsys[ss->subsys_id];
 
         need_forkexit_callback |= ss->fork || ss->exit;
+        need_mm_owner_callback |= !!ss->mm_owner_changed;
+
+        /* At system boot, before all subsystems have been
+         * registered, no tasks have been forked, so we don't
+         * need to invoke fork callbacks here. */
+        BUG_ON(!list_empty(&init_task.tasks));
 
         ss->active = 1;
 }
@@ -2458,9 +2520,9 @@ int __init cgroup_init_early(void)
         int i;
         kref_init(&init_css_set.ref);
         kref_get(&init_css_set.ref);
-        INIT_LIST_HEAD(&init_css_set.list);
         INIT_LIST_HEAD(&init_css_set.cg_links);
         INIT_LIST_HEAD(&init_css_set.tasks);
+        INIT_HLIST_NODE(&init_css_set.hlist);
         css_set_count = 1;
         init_cgroup_root(&rootnode);
         list_add(&rootnode.root_list, &roots);
@@ -2473,6 +2535,9 @@ int __init cgroup_init_early(void)
         list_add(&init_css_set_link.cg_link_list,
                  &init_css_set.cg_links);
 
+        for (i = 0; i < CSS_SET_TABLE_SIZE; i++)
+                INIT_HLIST_HEAD(&css_set_table[i]);
+
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
                 struct cgroup_subsys *ss = subsys[i];
 
@@ -2502,7 +2567,7 @@ int __init cgroup_init(void)
 {
         int err;
         int i;
-        struct proc_dir_entry *entry;
+        struct hlist_head *hhead;
 
         err = bdi_init(&cgroup_backing_dev_info);
         if (err)
@@ -2514,13 +2579,15 @@ int __init cgroup_init(void)
                         cgroup_init_subsys(ss);
         }
 
+        /* Add init_css_set to the hash table */
+        hhead = css_set_hash(init_css_set.subsys);
+        hlist_add_head(&init_css_set.hlist, hhead);
+
         err = register_filesystem(&cgroup_fs_type);
         if (err < 0)
                 goto out;
 
-        entry = create_proc_entry("cgroups", 0, NULL);
-        if (entry)
-                entry->proc_fops = &proc_cgroupstats_operations;
+        proc_create("cgroups", 0, NULL, &proc_cgroupstats_operations);
 
 out:
         if (err)
@@ -2683,6 +2750,34 @@ void cgroup_fork_callbacks(struct task_struct *child)
         }
 }
 
+#ifdef CONFIG_MM_OWNER
+/**
+ * cgroup_mm_owner_callbacks - run callbacks when the mm->owner changes
+ * @p: the new owner
+ *
+ * Called on every change to mm->owner. mm_init_owner() does not
+ * invoke this routine, since it assigns the mm->owner the first time
+ * and does not change it.
+ */
+void cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new)
+{
+        struct cgroup *oldcgrp, *newcgrp;
+
+        if (need_mm_owner_callback) {
+                int i;
+                for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
+                        struct cgroup_subsys *ss = subsys[i];
+                        oldcgrp = task_cgroup(old, ss->subsys_id);
+                        newcgrp = task_cgroup(new, ss->subsys_id);
+                        if (oldcgrp == newcgrp)
+                                continue;
+                        if (ss->mm_owner_changed)
+                                ss->mm_owner_changed(ss, oldcgrp, newcgrp);
+                }
+        }
+}
+#endif /* CONFIG_MM_OWNER */
+
 /**
  * cgroup_post_fork - called on a new task after adding it to the task list
  * @child: the task in question