Merge branch 'linus' into cont_syslog

[safe/jmp/linux-2.6] / block / blk-cgroup.c

diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index af42efb..a680964 100644 (file)
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -351,10 +351,8 @@ void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
        blkg->blkcg_id = css_id(&blkcg->css);
        hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
        spin_unlock_irqrestore(&blkcg->lock, flags);
-#ifdef CONFIG_DEBUG_BLK_CGROUP
        /* Need to take css reference ? */
        cgroup_path(blkcg->css.cgroup, blkg->path, sizeof(blkg->path));
-#endif
        blkg->dev = dev;
 }
 EXPORT_SYMBOL_GPL(blkiocg_add_blkio_group);
@@ -378,17 +376,16 @@ int blkiocg_del_blkio_group(struct blkio_group *blkg)
 
        rcu_read_lock();
        css = css_lookup(&blkio_subsys, blkg->blkcg_id);
-       if (!css)
-               goto out;
-
-       blkcg = container_of(css, struct blkio_cgroup, css);
-       spin_lock_irqsave(&blkcg->lock, flags);
-       if (!hlist_unhashed(&blkg->blkcg_node)) {
-               __blkiocg_del_blkio_group(blkg);
-               ret = 0;
+       if (css) {
+               blkcg = container_of(css, struct blkio_cgroup, css);
+               spin_lock_irqsave(&blkcg->lock, flags);
+               if (!hlist_unhashed(&blkg->blkcg_node)) {
+                       __blkiocg_del_blkio_group(blkg);
+                       ret = 0;
+               }
+               spin_unlock_irqrestore(&blkcg->lock, flags);
        }
-       spin_unlock_irqrestore(&blkcg->lock, flags);
-out:
+
        rcu_read_unlock();
        return ret;
 }
@@ -817,17 +814,15 @@ static int blkiocg_weight_device_read(struct cgroup *cgrp, struct cftype *cft,
        seq_printf(m, "dev\tweight\n");
 
        blkcg = cgroup_to_blkio_cgroup(cgrp);
-       if (list_empty(&blkcg->policy_list))
-               goto out;
-
-       spin_lock_irq(&blkcg->lock);
-       list_for_each_entry(pn, &blkcg->policy_list, node) {
-               seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
-                          MINOR(pn->dev), pn->weight);
+       if (!list_empty(&blkcg->policy_list)) {
+               spin_lock_irq(&blkcg->lock);
+               list_for_each_entry(pn, &blkcg->policy_list, node) {
+                       seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+                                  MINOR(pn->dev), pn->weight);
+               }
+               spin_unlock_irq(&blkcg->lock);
        }
-       spin_unlock_irq(&blkcg->lock);
 
-out:
        return 0;
 }
 
@@ -919,40 +914,39 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
        struct blkio_policy_node *pn, *pntmp;
 
        rcu_read_lock();
-remove_entry:
-       spin_lock_irqsave(&blkcg->lock, flags);
+       do {
+               spin_lock_irqsave(&blkcg->lock, flags);
 
-       if (hlist_empty(&blkcg->blkg_list)) {
-               spin_unlock_irqrestore(&blkcg->lock, flags);
-               goto done;
-       }
+               if (hlist_empty(&blkcg->blkg_list)) {
+                       spin_unlock_irqrestore(&blkcg->lock, flags);
+                       break;
+               }
 
-       blkg = hlist_entry(blkcg->blkg_list.first, struct blkio_group,
-                               blkcg_node);
-       key = rcu_dereference(blkg->key);
-       __blkiocg_del_blkio_group(blkg);
+               blkg = hlist_entry(blkcg->blkg_list.first, struct blkio_group,
+                                       blkcg_node);
+               key = rcu_dereference(blkg->key);
+               __blkiocg_del_blkio_group(blkg);
 
-       spin_unlock_irqrestore(&blkcg->lock, flags);
+               spin_unlock_irqrestore(&blkcg->lock, flags);
 
-       /*
-        * This blkio_group is being unlinked as associated cgroup is going
-        * away. Let all the IO controlling policies know about this event.
-        *
-        * Currently this is static call to one io controlling policy. Once
-        * we have more policies in place, we need some dynamic registration
-        * of callback function.
-        */
-       spin_lock(&blkio_list_lock);
-       list_for_each_entry(blkiop, &blkio_list, list)
-               blkiop->ops.blkio_unlink_group_fn(key, blkg);
-       spin_unlock(&blkio_list_lock);
-       goto remove_entry;
+               /*
+                * This blkio_group is being unlinked as associated cgroup is
+                * going away. Let all the IO controlling policies know about
+                * this event. Currently this is static call to one io
+                * controlling policy. Once we have more policies in place, we
+                * need some dynamic registration of callback function.
+                */
+               spin_lock(&blkio_list_lock);
+               list_for_each_entry(blkiop, &blkio_list, list)
+                       blkiop->ops.blkio_unlink_group_fn(key, blkg);
+               spin_unlock(&blkio_list_lock);
+       } while (1);
 
-done:
        list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
                blkio_policy_delete_node(pn);
                kfree(pn);
        }
+
        free_css_id(&blkio_subsys, &blkcg->css);
        rcu_read_unlock();
        if (blkcg != &blkio_root_cgroup)
@@ -962,16 +956,16 @@ done:
 static struct cgroup_subsys_state *
 blkiocg_create(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 {
-       struct blkio_cgroup *blkcg, *parent_blkcg;
+       struct blkio_cgroup *blkcg;
+       struct cgroup *parent = cgroup->parent;
 
-       if (!cgroup->parent) {
+       if (!parent) {
                blkcg = &blkio_root_cgroup;
                goto done;
        }
 
        /* Currently we do not support hierarchy deeper than two level (0,1) */
-       parent_blkcg = cgroup_to_blkio_cgroup(cgroup->parent);
-       if (css_depth(&parent_blkcg->css) > 0)
+       if (parent != cgroup->top_cgroup)
                return ERR_PTR(-EINVAL);
 
        blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);