lkml.org 
[lkml]   [2010]   [Jan]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[RFC] [PATCH 1/2] cgroups: modular subsystems support for use_id

    On Fri, Jan 08, 2010 at 12:27:34AM -0500, Ben Blum wrote:
    > On Thu, Jan 07, 2010 at 02:42:19PM +0800, Li Zefan wrote:
    > > KAMEZAWA Hiroyuki wrote:
    > > > On Wed, 6 Jan 2010 20:26:06 -0500
    > > > Ben Blum <bblum@andrew.cmu.edu> wrote:
    > > >
    > > >> On Wed, Jan 06, 2010 at 04:04:14PM -0800, Andrew Morton wrote:
    > > >>> On Thu, 31 Dec 2009 00:10:50 -0500
    > > >>> Ben Blum <bblum@andrew.cmu.edu> wrote:
    > > >>>
    > > >>>> This patch series implements support for building, loading, and
    > > >>>> unloading subsystems as modules, both within and outside the kernel
    > > >>>> source tree. It provides an interface cgroup_load_subsys() and
    > > >>>> cgroup_unload_subsys() which modular subsystems can use to register and
    > > >>>> depart during runtime. The net_cls classifier subsystem serves as the
    > > >>>> example for a subsystem which can be converted into a module using these
    > > >>>> changes.
    > > >>> What is the value in this? What are the usage scenarios? Why does the
    > > >>> benefit of this change exceed the cost/risk/etc of merging it?
    > > >> As discussed in the first posting of these patches, this provides the
    > > >> ability for arbitrary subsystems to be used with cgroups.. cls_cgroup
    > > >> would have already been a module except for a lack of support from
    > > >> cgroups, and the change also allows other module-loadable classifiers
    > > >> to add subsystems of their own.
    > > >
    > > > Hmm, do you have your own module in plan ?
    > > >
    > >
    > > Maybe the new blkio_cgroup can also be made module-able.
    >
    > Ok, the following two patches make this happen (or at least pretend to
    > well enough to fool me). The first one adds use_id initialization in
    > cgroup_load_subsys, and the second rearranges config options and some
    > code as appropriate in block/ and adds EXPORT_SYMBOLs in cgroup.c.
    >
    > -- bblum
    >
    > ---
    > block/Kconfig | 2 -
    > block/Kconfig.iosched | 2 -
    > block/blk-cgroup.c | 53 +++++++++++++++++++++++++++++++++++-----------
    > block/blk-cgroup.h | 10 ++++++--
    > include/linux/iocontext.h | 2 -
    > kernel/cgroup.c | 31 +++++++++++++++++++++-----
    > 6 files changed, 77 insertions(+), 23 deletions(-)
    >
    >
    This patch adds support for subsys.use_id in module-loadable subsystems.

    From: Ben Blum <bblum@andrew.cmu.edu>

    Signed-off-by: Ben Blum <bblum@andrew.cmu.edu>
    ---
    kernel/cgroup.c | 23 +++++++++++++++++------
    1 files changed, 17 insertions(+), 6 deletions(-)

    diff --git a/kernel/cgroup.c b/kernel/cgroup.c
    index cc2e1f6..5af59eb 100644
    --- a/kernel/cgroup.c
    +++ b/kernel/cgroup.c
    @@ -240,7 +240,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);
    +static int cgroup_init_idr(struct cgroup_subsys *ss,
    + struct cgroup_subsys_state *css);

    /* css_set_lock protects the list of css_set objects, and the
    * chain of tasks off each css_set. Nests outside task->alloc_lock
    @@ -3390,6 +3391,16 @@ int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
    mutex_unlock(&cgroup_mutex);
    return PTR_ERR(css);
    }
    + /* call init_idr here because it has a failure case */
    + if (ss->use_id) {
    + int ret = cgroup_init_idr(ss, css);
    + if (ret) {
    + ss->destroy(ss, dummytop);
    + subsys[i] = NULL;
    + mutex_unlock(&cgroup_mutex);
    + return ret;
    + }
    + }

    list_add(&ss->sibling, &rootnode.subsys_list);
    ss->root = &rootnode;
    @@ -3484,7 +3495,8 @@ void cgroup_unload_subsys(struct cgroup_subsys *ss)
    /*
    * remove subsystem's css from the dummytop and free it - need to free
    * before marking as null because ss->destroy needs the cgrp->subsys
    - * pointer to find their state.
    + * pointer to find their state. note that this also takes care of
    + * freeing the css_id.
    */
    ss->destroy(ss, dummytop);
    dummytop->subsys[ss->subsys_id] = NULL;
    @@ -3563,7 +3575,7 @@ int __init cgroup_init(void)
    if (!ss->early_init)
    cgroup_init_subsys(ss);
    if (ss->use_id)
    - cgroup_subsys_init_idr(ss);
    + cgroup_init_idr(ss, init_css_set.subsys[ss->subsys_id]);
    }

    /* Add init_css_set to the hash table */
    @@ -4231,15 +4243,14 @@ err_out:

    }

    -static int __init cgroup_subsys_init_idr(struct cgroup_subsys *ss)
    +static int __init_or_module cgroup_init_idr(struct cgroup_subsys *ss,
    + struct cgroup_subsys_state *rootcss)
    {
    struct css_id *newid;
    - struct cgroup_subsys_state *rootcss;

    spin_lock_init(&ss->id_lock);
    idr_init(&ss->idr);

    - rootcss = init_css_set.subsys[ss->subsys_id];
    newid = get_new_cssid(ss, 0);
    if (IS_ERR(newid))
    return PTR_ERR(newid);
    \
     
     \ /
      Last update: 2010-01-08 06:31    [W:3.635 / U:0.040 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site