Merge branch 'linus' into irq/threaded

Conflicts:
	include/linux/irq.h
	kernel/irq/handle.c

1 files changed, 401 insertions, 34 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 9edb5c4b79b..382109b5bae 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -94,7 +94,6 @@ struct cgroupfs_root {
         char release_agent_path[PATH_MAX];
 };
 
-
 /*
  * The "rootnode" hierarchy is the "dummy hierarchy", reserved for the
  * subsystems that are otherwise unattached - it never has more than a
@@ -102,6 +101,39 @@ struct cgroupfs_root {
  */
 static struct cgroupfs_root rootnode;
 
+/*
+ * CSS ID -- ID per subsys's Cgroup Subsys State(CSS). used only when
+ * cgroup_subsys->use_id != 0.
+ */
+#define CSS_ID_MAX      (65535)
+struct css_id {
+        /*
+         * The css to which this ID points. This pointer is set to valid value
+         * after cgroup is populated. If cgroup is removed, this will be NULL.
+         * This pointer is expected to be RCU-safe because destroy()
+         * is called after synchronize_rcu(). But for safe use, css_is_removed()
+         * css_tryget() should be used for avoiding race.
+         */
+        struct cgroup_subsys_state *css;
+        /*
+         * ID of this css.
+         */
+        unsigned short id;
+        /*
+         * Depth in hierarchy which this ID belongs to.
+         */
+        unsigned short depth;
+        /*
+         * ID is freed by RCU. (and lookup routine is RCU safe.)
+         */
+        struct rcu_head rcu_head;
+        /*
+         * Hierarchy of CSS ID belongs to.
+         */
+        unsigned short stack[0]; /* Array of Length (depth+1) */
+};
+
+
 /* The list of hierarchy roots */
 
 static LIST_HEAD(roots);
@@ -185,6 +217,8 @@ struct cg_cgroup_link {
 static struct css_set init_css_set;
 static struct cg_cgroup_link init_css_set_link;
 
+static int cgroup_subsys_init_idr(struct cgroup_subsys *ss);
+
 /* css_set_lock protects the list of css_set objects, and the
  * chain of tasks off each css_set.  Nests outside task->alloc_lock
  * due to cgroup_iter_start() */
@@ -567,6 +601,9 @@ static struct backing_dev_info cgroup_backing_dev_info = {
         .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK,
 };
 
+static int alloc_css_id(struct cgroup_subsys *ss,
+                        struct cgroup *parent, struct cgroup *child);
+
 static struct inode *cgroup_new_inode(mode_t mode, struct super_block *sb)
 {
         struct inode *inode = new_inode(sb);
@@ -585,13 +622,18 @@ static struct inode *cgroup_new_inode(mode_t mode, struct super_block *sb)
  * Call subsys's pre_destroy handler.
  * This is called before css refcnt check.
  */
-static void cgroup_call_pre_destroy(struct cgroup *cgrp)
+static int cgroup_call_pre_destroy(struct cgroup *cgrp)
 {
         struct cgroup_subsys *ss;
+        int ret = 0;
+
         for_each_subsys(cgrp->root, ss)
-                if (ss->pre_destroy)
-                        ss->pre_destroy(ss, cgrp);
-        return;
+                if (ss->pre_destroy) {
+                        ret = ss->pre_destroy(ss, cgrp);
+                        if (ret)
+                                break;
+                }
+        return ret;
 }
 
 static void free_cgroup_rcu(struct rcu_head *obj)
@@ -685,6 +727,22 @@ static void cgroup_d_remove_dir(struct dentry *dentry)
         remove_dir(dentry);
 }
 
+/*
+ * A queue for waiters to do rmdir() cgroup. A tasks will sleep when
+ * cgroup->count == 0 && list_empty(&cgroup->children) && subsys has some
+ * reference to css->refcnt. In general, this refcnt is expected to goes down
+ * to zero, soon.
+ *
+ * CGRP_WAIT_ON_RMDIR flag is modified under cgroup's inode->i_mutex;
+ */
+DECLARE_WAIT_QUEUE_HEAD(cgroup_rmdir_waitq);
+
+static void cgroup_wakeup_rmdir_waiters(const struct cgroup *cgrp)
+{
+        if (unlikely(test_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags)))
+                wake_up_all(&cgroup_rmdir_waitq);
+}
+
 static int rebind_subsystems(struct cgroupfs_root *root,
                               unsigned long final_bits)
 {
@@ -857,16 +915,16 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
         }
 
         ret = rebind_subsystems(root, opts.subsys_bits);
+        if (ret)
+                goto out_unlock;
 
         /* (re)populate subsystem files */
-        if (!ret)
-                cgroup_populate_dir(cgrp);
+        cgroup_populate_dir(cgrp);
 
         if (opts.release_agent)
                 strcpy(root->release_agent_path, opts.release_agent);
  out_unlock:
-        if (opts.release_agent)
-                kfree(opts.release_agent);
+        kfree(opts.release_agent);
         mutex_unlock(&cgroup_mutex);
         mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
         return ret;
@@ -969,15 +1027,13 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
         /* First find the desired set of subsystems */
         ret = parse_cgroupfs_options(data, &opts);
         if (ret) {
-                if (opts.release_agent)
-                        kfree(opts.release_agent);
+                kfree(opts.release_agent);
                 return ret;
         }
 
         root = kzalloc(sizeof(*root), GFP_KERNEL);
         if (!root) {
-                if (opts.release_agent)
-                        kfree(opts.release_agent);
+                kfree(opts.release_agent);
                 return -ENOMEM;
         }
 
@@ -1071,7 +1127,8 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
                 mutex_unlock(&cgroup_mutex);
         }
 
-        return simple_set_mnt(mnt, sb);
+        simple_set_mnt(mnt, sb);
+        return 0;
 
  free_cg_links:
         free_cg_links(&tmp_cg_links);
@@ -1279,6 +1336,12 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
         set_bit(CGRP_RELEASABLE, &oldcgrp->flags);
         synchronize_rcu();
         put_css_set(cg);
+
+        /*
+         * wake up rmdir() waiter. the rmdir should fail since the cgroup
+         * is no longer empty.
+         */
+        cgroup_wakeup_rmdir_waiters(cgrp);
         return 0;
 }
 
@@ -1624,10 +1687,10 @@ static struct inode_operations cgroup_dir_inode_operations = {
         .rename = cgroup_rename,
 };
 
-static int cgroup_create_file(struct dentry *dentry, int mode,
+static int cgroup_create_file(struct dentry *dentry, mode_t mode,
                                 struct super_block *sb)
 {