@ -818,7 +818,7 @@ static int cgroup_call_pre_destroy(struct cgroup *cgrp)
for_each_subsys ( cgrp - > root , ss )
if ( ss - > pre_destroy ) {
ret = ss - > pre_destroy ( ss , cgrp ) ;
ret = ss - > pre_destroy ( cgrp ) ;
if ( ret )
break ;
}
@ -846,7 +846,7 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
* Release the subsystem state objects .
*/
for_each_subsys ( cgrp - > root , ss )
ss - > destroy ( ss , cgrp ) ;
ss - > destroy ( cgrp ) ;
cgrp - > root - > number_of_cgroups - - ;
mutex_unlock ( & cgroup_mutex ) ;
@ -1015,7 +1015,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
list_move ( & ss - > sibling , & root - > subsys_list ) ;
ss - > root = root ;
if ( ss - > bind )
ss - > bind ( ss , cgrp ) ;
ss - > bind ( cgrp ) ;
mutex_unlock ( & ss - > hierarchy_mutex ) ;
/* refcount was already taken, and we're keeping it */
} else if ( bit & removed_bits ) {
@ -1025,7 +1025,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
BUG_ON ( cgrp - > subsys [ i ] - > cgroup ! = cgrp ) ;
mutex_lock ( & ss - > hierarchy_mutex ) ;
if ( ss - > bind )
ss - > bind ( ss , dummytop ) ;
ss - > bind ( dummytop ) ;
dummytop - > subsys [ i ] - > cgroup = dummytop ;
cgrp - > subsys [ i ] = NULL ;
subsys [ i ] - > root = & rootnode ;
@ -1763,6 +1763,7 @@ EXPORT_SYMBOL_GPL(cgroup_path);
struct task_and_cgroup {
struct task_struct * task ;
struct cgroup * cgrp ;
struct css_set * cg ;
} ;
struct cgroup_taskset {
@ -1843,11 +1844,10 @@ EXPORT_SYMBOL_GPL(cgroup_taskset_size);
* will already exist . If not set , this function might sleep , and can fail with
* - ENOMEM . Must be called with cgroup_mutex and threadgroup locked .
*/
static int cgroup_task_migrate ( struct cgroup * cgrp , struct cgroup * oldcgrp ,
struct task_struct * tsk , bool guarantee )
static void cgroup_task_migrate ( struct cgroup * cgrp , struct cgroup * oldcgrp ,
struct task_struct * tsk , struct css_set * newcg )
{
struct css_set * oldcg ;
struct css_set * newcg ;
/*
* We are synchronized through threadgroup_lock ( ) against PF_EXITING
@ -1857,23 +1857,6 @@ static int cgroup_task_migrate(struct cgroup *cgrp, struct cgroup *oldcgrp,
WARN_ON_ONCE ( tsk - > flags & PF_EXITING ) ;
oldcg = tsk - > cgroups ;
/* locate or allocate a new css_set for this task. */
if ( guarantee ) {
/* we know the css_set we want already exists. */
struct cgroup_subsys_state * template [ CGROUP_SUBSYS_COUNT ] ;
read_lock ( & css_set_lock ) ;
newcg = find_existing_css_set ( oldcg , cgrp , template ) ;
BUG_ON ( ! newcg ) ;
get_css_set ( newcg ) ;
read_unlock ( & css_set_lock ) ;
} else {
might_sleep ( ) ;
/* find_css_set will give us newcg already referenced. */
newcg = find_css_set ( oldcg , cgrp ) ;
if ( ! newcg )
return - ENOMEM ;
}
task_lock ( tsk ) ;
rcu_assign_pointer ( tsk - > cgroups , newcg ) ;
task_unlock ( tsk ) ;
@ -1892,7 +1875,6 @@ static int cgroup_task_migrate(struct cgroup *cgrp, struct cgroup *oldcgrp,
put_css_set ( oldcg ) ;
set_bit ( CGRP_RELEASABLE , & oldcgrp - > flags ) ;
return 0 ;
}
/**
@ -1910,6 +1892,7 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
struct cgroup * oldcgrp ;
struct cgroupfs_root * root = cgrp - > root ;
struct cgroup_taskset tset = { } ;
struct css_set * newcg ;
/* @tsk either already exited or can't exit until the end */
if ( tsk - > flags & PF_EXITING )
@ -1925,7 +1908,7 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
for_each_subsys ( root , ss ) {
if ( ss - > can_attach ) {
retval = ss - > can_attach ( ss , cgrp , & tset ) ;
retval = ss - > can_attach ( cgrp , & tset ) ;
if ( retval ) {
/*
* Remember on which subsystem the can_attach ( )
@ -1939,13 +1922,17 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
}
}
retval = cgroup_task_migrate ( cgrp , oldcgrp , tsk , false ) ;
if ( retval )
newcg = find_css_set ( tsk - > cgroups , cgrp ) ;
if ( ! newcg ) {
retval = - ENOMEM ;
goto out ;
}
cgroup_task_migrate ( cgrp , oldcgrp , tsk , newcg ) ;
for_each_subsys ( root , ss ) {
if ( ss - > attach )
ss - > attach ( ss , cgrp , & tset ) ;
ss - > attach ( cgrp , & tset ) ;
}
synchronize_rcu ( ) ;
@ -1967,7 +1954,7 @@ out:
*/
break ;
if ( ss - > cancel_attach )
ss - > cancel_attach ( ss , cgrp , & tset ) ;
ss - > cancel_attach ( cgrp , & tset ) ;
}
}
return retval ;
@ -1997,66 +1984,6 @@ int cgroup_attach_task_all(struct task_struct *from, struct task_struct *tsk)
}
EXPORT_SYMBOL_GPL ( cgroup_attach_task_all ) ;
/*
* cgroup_attach_proc works in two stages , the first of which prefetches all
* new css_sets needed ( to make sure we have enough memory before committing
* to the move ) and stores them in a list of entries of the following type .
* TODO : possible optimization : use css_set - > rcu_head for chaining instead
*/
struct cg_list_entry {
struct css_set * cg ;
struct list_head links ;
} ;
static bool css_set_check_fetched ( struct cgroup * cgrp ,
struct task_struct * tsk , struct css_set * cg ,
struct list_head * newcg_list )
{
struct css_set * newcg ;
struct cg_list_entry * cg_entry ;
struct cgroup_subsys_state * template [ CGROUP_SUBSYS_COUNT ] ;
read_lock ( & css_set_lock ) ;
newcg = find_existing_css_set ( cg , cgrp , template ) ;
read_unlock ( & css_set_lock ) ;
/* doesn't exist at all? */
if ( ! newcg )
return false ;
/* see if it's already in the list */
list_for_each_entry ( cg_entry , newcg_list , links )
if ( cg_entry - > cg = = newcg )
return true ;
/* not found */
return false ;
}
/*
* Find the new css_set and store it in the list in preparation for moving the
* given task to the given cgroup . Returns 0 or - ENOMEM .
*/
static int css_set_prefetch ( struct cgroup * cgrp , struct css_set * cg ,
struct list_head * newcg_list )
{
struct css_set * newcg ;
struct cg_list_entry * cg_entry ;
/* ensure a new css_set will exist for this thread */
newcg = find_css_set ( cg , cgrp ) ;
if ( ! newcg )
return - ENOMEM ;
/* add it to the list */
cg_entry = kmalloc ( sizeof ( struct cg_list_entry ) , GFP_KERNEL ) ;
if ( ! cg_entry ) {
put_css_set ( newcg ) ;
return - ENOMEM ;
}
cg_entry - > cg = newcg ;
list_add ( & cg_entry - > links , newcg_list ) ;
return 0 ;
}
/**
* cgroup_attach_proc - attach all threads in a threadgroup to a cgroup
* @ cgrp : the cgroup to attach to
@ -2070,20 +1997,12 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
int retval , i , group_size ;
struct cgroup_subsys * ss , * failed_ss = NULL ;
/* guaranteed to be initialized later, but the compiler needs this */
struct css_set * oldcg ;
struct cgroupfs_root * root = cgrp - > root ;
/* threadgroup list cursor and array */
struct task_struct * tsk ;
struct task_and_cgroup * tc ;
struct flex_array * group ;
struct cgroup_taskset tset = { } ;
/*
* we need to make sure we have css_sets for all the tasks we ' re
* going to move - before - we actually start moving them , so that in
* case we get an ENOMEM we can bail out before making any changes .
*/
struct list_head newcg_list ;
struct cg_list_entry * cg_entry , * temp_nobe ;
/*
* step 0 : in order to do expensive , possibly blocking operations for
@ -2102,23 +2021,14 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
if ( retval )
goto out_free_group_list ;
/* prevent changes to the threadgroup list while we take a snapshot. */
read_lock ( & tasklist_lock ) ;
if ( ! thread_group_leader ( leader ) ) {
/*
* a race with de_thread from another thread ' s exec ( ) may strip
* us of our leadership , making while_each_thread unsafe to use
* on this task . if this happens , there is no choice but to
* throw this task away and try again ( from cgroup_procs_write ) ;
* this is " double-double-toil-and-trouble-check locking " .
*/
read_unlock ( & tasklist_lock ) ;
retval = - EAGAIN ;
goto out_free_group_list ;
}
tsk = leader ;
i = 0 ;
/*
* Prevent freeing of tasks while we take a snapshot . Tasks that are
* already PF_EXITING could be freed from underneath us unless we
* take an rcu_read_lock .
*/
rcu_read_lock ( ) ;
do {
struct task_and_cgroup ent ;
@ -2128,24 +2038,24 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
/* as per above, nr_threads may decrease, but not increase. */
BUG_ON ( i > = group_size ) ;
/*
* saying GFP_ATOMIC has no effect here because we did prealloc
* earlier , but it ' s good form to communicate our expectations .
*/
ent . task = tsk ;
ent . cgrp = task_cgroup_from_root ( tsk , root ) ;
/* nothing to do if this task is already in the cgroup */
if ( ent . cgrp = = cgrp )
continue ;
/*
* saying GFP_ATOMIC has no effect here because we did prealloc
* earlier , but it ' s good form to communicate our expectations .
*/
retval = flex_array_put ( group , i , & ent , GFP_ATOMIC ) ;
BUG_ON ( retval ! = 0 ) ;
i + + ;
} while_each_thread ( leader , tsk ) ;
rcu_read_unlock ( ) ;
/* remember the number of threads in the array for later. */
group_size = i ;
tset . tc_array = group ;
tset . tc_array_len = group_size ;
read_unlock ( & tasklist_lock ) ;
/* methods shouldn't be called if no task is actually migrating */
retval = 0 ;
@ -2157,7 +2067,7 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
*/
for_each_subsys ( root , ss ) {
if ( ss - > can_attach ) {
retval = ss - > can_attach ( ss , cgrp , & tset ) ;
retval = ss - > can_attach ( cgrp , & tset ) ;
if ( retval ) {
failed_ss = ss ;
goto out_cancel_attach ;
@ -2169,17 +2079,12 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
* step 2 : make sure css_sets exist for all threads to be migrated .
* we use find_css_set , which allocates a new one if necessary .
*/
INIT_LIST_HEAD ( & newcg_list ) ;
for ( i = 0 ; i < group_size ; i + + ) {
tc = flex_array_get ( group , i ) ;
oldcg = tc - > task - > cgroups ;
/* if we don't already have it in the list get a new one */
if ( ! css_set_check_fetched ( cgrp , tc - > task , oldcg ,
& newcg_list ) ) {
retval = css_set_prefetch ( cgrp , oldcg , & newcg_list ) ;
if ( retval )
goto out_list_teardown ;
tc - > cg = find_css_set ( tc - > task - > cgroups , cgrp ) ;
if ( ! tc - > cg ) {
retval = - ENOMEM ;
goto out_put_css_set_refs ;
}
}
@ -2190,8 +2095,7 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
*/
for ( i = 0 ; i < group_size ; i + + ) {
tc = flex_array_get ( group , i ) ;
retval = cgroup_task_migrate ( cgrp , tc - > cgrp , tc - > task , true ) ;
BUG_ON ( retval ) ;
cgroup_task_migrate ( cgrp , tc - > cgrp , tc - > task , tc - > cg ) ;
}
/* nothing is sensitive to fork() after this point. */
@ -2200,7 +2104,7 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
*/
for_each_subsys ( root , ss ) {
if ( ss - > attach )
ss - > attach ( ss , cgrp , & tset ) ;
ss - > attach ( cgrp , & tset ) ;
}
/*
@ -2209,21 +2113,22 @@ static int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
synchronize_rcu ( ) ;
cgroup_wakeup_rmdir_waiter ( cgrp ) ;
retval = 0 ;
out_list_teardown :
/* clean up the list of prefetched css_sets. */
list_for_each_entry_safe ( cg_entry , temp_nobe , & newcg_list , links ) {
list_del ( & cg_entry - > links ) ;
put_css_set ( cg_entry - > cg ) ;
kfree ( cg_entry ) ;
out_put_css_set_refs :
if ( retval ) {
for ( i = 0 ; i < group_size ; i + + ) {
tc = flex_array_get ( group , i ) ;
if ( ! tc - > cg )
break ;
put_css_set ( tc - > cg ) ;
}
}
out_cancel_attach :
/* same deal as in cgroup_attach_task */
if ( retval ) {
for_each_subsys ( root , ss ) {
if ( ss = = failed_ss )
break ;
if ( ss - > cancel_attach )
ss - > cancel_attach ( ss , cgrp , & tset ) ;
ss - > cancel_attach ( cgrp , & tset ) ;
}
}
out_free_group_list :
@ -2245,22 +2150,14 @@ static int attach_task_by_pid(struct cgroup *cgrp, u64 pid, bool threadgroup)
if ( ! cgroup_lock_live_group ( cgrp ) )
return - ENODEV ;
retry_find_task :
rcu_read_lock ( ) ;
if ( pid ) {
rcu_read_lock ( ) ;
tsk = find_task_by_vpid ( pid ) ;
if ( ! tsk ) {
rcu_read_unlock ( ) ;
cgroup_unlock ( ) ;
return - ESRCH ;
}
if ( threadgroup ) {
/*
* RCU protects this access , since tsk was found in the
* tid map . a race with de_thread may cause group_leader
* to stop being the leader , but cgroup_attach_proc will
* detect it later .
*/
tsk = tsk - > group_leader ;
ret = - ESRCH ;
goto out_unlock_cgroup ;
}
/*
* even if we ' re attaching all tasks in the thread group , we
@ -2271,29 +2168,38 @@ static int attach_task_by_pid(struct cgroup *cgrp, u64 pid, bool threadgroup)
cred - > euid ! = tcred - > uid & &
cred - > euid ! = tcred - > suid ) {
rcu_read_unlock ( ) ;
cgroup_unlock ( ) ;
return - EACCES ;
ret = - EACCES ;
goto out_unlock_cgroup ;
}
get_task_struct ( tsk ) ;
rcu_read_unlock ( ) ;
} else {
if ( threadgroup )
tsk = current - > group_leader ;
else
tsk = current ;
get_task_struct ( tsk ) ;
}
threadgroup_lock ( tsk ) ;
} else
tsk = current ;
if ( threadgroup )
tsk = tsk - > group_leader ;
get_task_struct ( tsk ) ;
rcu_read_unlock ( ) ;
threadgroup_lock ( tsk ) ;
if ( threadgroup ) {
if ( ! thread_group_leader ( tsk ) ) {
/*
* a race with de_thread from another thread ' s exec ( )
* may strip us of our leadership , if this happens ,
* there is no choice but to throw this task away and
* try again ; this is
* " double-double-toil-and-trouble-check locking " .
*/
threadgroup_unlock ( tsk ) ;
put_task_struct ( tsk ) ;
goto retry_find_task ;
}
ret = cgroup_attach_proc ( cgrp , tsk ) ;
else
} else
ret = cgroup_attach_task ( cgrp , tsk ) ;
threadgroup_unlock ( tsk ) ;
put_task_struct ( tsk ) ;
out_unlock_cgroup :
cgroup_unlock ( ) ;
return ret ;
}
@ -2305,16 +2211,7 @@ static int cgroup_tasks_write(struct cgroup *cgrp, struct cftype *cft, u64 pid)
static int cgroup_procs_write ( struct cgroup * cgrp , struct cftype * cft , u64 tgid )
{
int ret ;
do {
/*
* attach_proc fails with - EAGAIN if threadgroup leadership
* changes in the middle of the operation , in which case we need
* to find the task_struct for the new leader and start over .
*/
ret = attach_task_by_pid ( cgrp , tgid , true ) ;
} while ( ret = = - EAGAIN ) ;
return ret ;
return attach_task_by_pid ( cgrp , tgid , true ) ;
}
/**
@ -2804,15 +2701,20 @@ static void cgroup_advance_iter(struct cgroup *cgrp,
* using their cgroups capability , we don ' t maintain the lists running
* through each css_set to its tasks until we see the list actually
* used - in other words after the first call to cgroup_iter_start ( ) .
*
* The tasklist_lock is not held here , as do_each_thread ( ) and
* while_each_thread ( ) are protected by RCU .
*/
static void cgroup_enable_task_cg_lists ( void )
{
struct task_struct * p , * g ;
write_lock ( & css_set_lock ) ;
use_task_css_set_links = 1 ;
/*
* We need tasklist_lock because RCU is not safe against
* while_each_thread ( ) . Besides , a forking task that has passed
* cgroup_post_fork ( ) without seeing use_task_css_set_links = 1
* is not guaranteed to have its child immediately visible in the
* tasklist if we walk through it with RCU .
*/
read_lock ( & tasklist_lock ) ;
do_each_thread ( g , p ) {
task_lock ( p ) ;
/*
@ -2824,6 +2726,7 @@ static void cgroup_enable_task_cg_lists(void)
list_add ( & p - > cg_list , & p - > cgroups - > tasks ) ;
task_unlock ( p ) ;
} while_each_thread ( g , p ) ;
read_unlock ( & tasklist_lock ) ;
write_unlock ( & css_set_lock ) ;
}
@ -3043,6 +2946,38 @@ int cgroup_scan_tasks(struct cgroup_scanner *scan)
*
*/
/* which pidlist file are we talking about? */
enum cgroup_filetype {
CGROUP_FILE_PROCS ,
CGROUP_FILE_TASKS ,
} ;
/*
* A pidlist is a list of pids that virtually represents the contents of one
* of the cgroup files ( " procs " or " tasks " ) . We keep a list of such pidlists ,
* a pair ( one each for procs , tasks ) for each pid namespace that ' s relevant
* to the cgroup .
*/
struct cgroup_pidlist {
/*
* used to find which pidlist is wanted . doesn ' t change as long as
* this particular list stays in the list .
*/
struct { enum cgroup_filetype type ; struct pid_namespace * ns ; } key ;
/* array of xids */
pid_t * list ;
/* how many elements the above list has */
int length ;
/* how many files are using the current array */
int use_count ;
/* each of these stored in a list by its cgroup */
struct list_head links ;
/* pointer to the cgroup we belong to, for list removal purposes */
struct cgroup * owner ;
/* protects the other fields */
struct rw_semaphore mutex ;
} ;
/*
* The following two functions " fix " the issue where there are more pids
* than kmalloc will give memory for ; in such cases , we use vmalloc / vfree .
@ -3827,7 +3762,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
set_bit ( CGRP_CLONE_CHILDREN , & cgrp - > flags ) ;
for_each_subsys ( root , ss ) {
struct cgroup_subsys_state * css = ss - > create ( ss , cgrp ) ;
struct cgroup_subsys_state * css = ss - > create ( cgrp ) ;
if ( IS_ERR ( css ) ) {
err = PTR_ERR ( css ) ;
@ -3841,7 +3776,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
}
/* At error, ->destroy() callback has to free assigned ID. */
if ( clone_children ( parent ) & & ss - > post_clone )
ss - > post_clone ( ss , cgrp ) ;
ss - > post_clone ( cgrp ) ;
}
cgroup_lock_hierarchy ( root ) ;
@ -3875,7 +3810,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
for_each_subsys ( root , ss ) {
if ( cgrp - > subsys [ ss - > subsys_id ] )
ss - > destroy ( ss , cgrp ) ;
ss - > destroy ( cgrp ) ;
}
mutex_unlock ( & cgroup_mutex ) ;
@ -4099,7 +4034,7 @@ static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
/* Create the top cgroup state for this subsystem */
list_add ( & ss - > sibling , & rootnode . subsys_list ) ;
ss - > root = & rootnode ;
css = ss - > create ( ss , dummytop ) ;
css = ss - > create ( dummytop ) ;
/* We don't handle early failures gracefully */
BUG_ON ( IS_ERR ( css ) ) ;
init_cgroup_css ( css , ss , dummytop ) ;
@ -4188,7 +4123,7 @@ int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
* no ss - > create seems to need anything important in the ss struct , so
* this can happen first ( i . e . before the rootnode attachment ) .
*/
css = ss - > create ( ss , dummytop ) ;
css = ss - > create ( dummytop ) ;
if ( IS_ERR ( css ) ) {
/* failure case - need to deassign the subsys[] slot. */
subsys [ i ] = NULL ;
@ -4206,7 +4141,7 @@ int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
int ret = cgroup_init_idr ( ss , css ) ;
if ( ret ) {
dummytop - > subsys [ ss - > subsys_id ] = NULL ;
ss - > destroy ( ss , dummytop ) ;
ss - > destroy ( dummytop ) ;
subsys [ i ] = NULL ;
mutex_unlock ( & cgroup_mutex ) ;
return ret ;
@ -4304,7 +4239,7 @@ void cgroup_unload_subsys(struct cgroup_subsys *ss)
* pointer to find their state . note that this also takes care of
* freeing the css_id .
*/
ss - > destroy ( ss , dummytop ) ;
ss - > destroy ( dummytop ) ;
dummytop - > subsys [ ss - > subsys_id ] = NULL ;
mutex_unlock ( & cgroup_mutex ) ;
@ -4580,7 +4515,7 @@ void cgroup_fork_callbacks(struct task_struct *child)
for ( i = 0 ; i < CGROUP_BUILTIN_SUBSYS_COUNT ; i + + ) {
struct cgroup_subsys * ss = subsys [ i ] ;
if ( ss - > fork )
ss - > fork ( ss , child ) ;
ss - > fork ( child ) ;
}
}
}
@ -4596,6 +4531,17 @@ void cgroup_fork_callbacks(struct task_struct *child)
*/
void cgroup_post_fork ( struct task_struct * child )
{
/*
* use_task_css_set_links is set to 1 before we walk the tasklist
* under the tasklist_lock and we read it here after we added the child
* to the tasklist under the tasklist_lock as well . If the child wasn ' t
* yet in the tasklist when we walked through it from
* cgroup_enable_task_cg_lists ( ) , then use_task_css_set_links value
* should be visible now due to the paired locking and barriers implied
* by LOCK / UNLOCK : it is written before the tasklist_lock unlock
* in cgroup_enable_task_cg_lists ( ) and read here after the tasklist_lock
* lock on fork .
*/
if ( use_task_css_set_links ) {
write_lock ( & css_set_lock ) ;
if ( list_empty ( & child - > cg_list ) ) {
@ -4682,7 +4628,7 @@ void cgroup_exit(struct task_struct *tsk, int run_callbacks)
struct cgroup * old_cgrp =
rcu_dereference_raw ( cg - > subsys [ i ] ) - > cgroup ;
struct cgroup * cgrp = task_cgroup ( tsk , i ) ;
ss - > exit ( ss , cgrp , old_cgrp , tsk ) ;
ss - > exit ( cgrp , old_cgrp , tsk ) ;
}
}
}
@ -5137,8 +5083,7 @@ struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id)
}
# ifdef CONFIG_CGROUP_DEBUG
static struct cgroup_subsys_state * debug_create ( struct cgroup_subsys * ss ,
struct cgroup * cont )
static struct cgroup_subsys_state * debug_create ( struct cgroup * cont )
{
struct cgroup_subsys_state * css = kzalloc ( sizeof ( * css ) , GFP_KERNEL ) ;
@ -5148,7 +5093,7 @@ static struct cgroup_subsys_state *debug_create(struct cgroup_subsys *ss,
return css ;
}
static void debug_destroy ( struct cgroup_subsys * ss , struct cgroup * cont )
static void debug_destroy ( struct cgroup * cont )
{
kfree ( cont - > subsys [ debug_subsys_id ] ) ;
}
Linus Torvalds
13 years ago