cgroup: fix comments

 *

 *

 * When reading/writing to a file:

 *	- the cgroup to use in file->f_dentry->d_parent->d_fsdata

 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata

 *	- the 'cftype' of the file is file->f_dentry->d_fsdata

 */

#define dummytop (&rootnode.top_cgroup)

/* This flag indicates whether tasks in the fork and exit paths should

 * take callback_mutex and check for fork/exit handlers to call. This

 * avoids us having to do extra work in the fork/exit path if none of the

 * subsystems need to be called.

 * check for fork/exit handlers to call. This avoids us having to do

 * extra work in the fork/exit path if none of the subsystems need to

 * be called.

 */

static int need_forkexit_callback;

 * template: location in which to build the desired set of subsystem

 * state objects for the new cgroup group

 */

static struct css_set *find_existing_css_set(

	struct css_set *oldcg,

	struct cgroup *cgrp,

 * and chains them on tmp through their cgrp_link_list fields. Returns 0 on

 * success or a negative error

 */

static int allocate_cg_links(int count, struct list_head *tmp)

{

	struct cg_cgroup_link *link;

 * substituted into the appropriate hierarchy. Must be called with

 * cgroup_mutex held

 */

static struct css_set *find_css_set(

	struct css_set *oldcg, struct cgroup *cgrp)

{

 * critical pieces of code here.  The exception occurs on cgroup_exit(),

 * when a task in a notify_on_release cgroup exits.  Then cgroup_mutex

 * is taken, and if the cgroup count is zero, a usermode call made

 * to /sbin/cgroup_release_agent with the name of the cgroup (path

 * relative to the root of cgroup file system) as the argument.

 * to the release agent with the name of the cgroup (path relative to

 * the root of cgroup file system) as the argument.

 *

 * A cgroup can only be deleted if both its 'count' of using tasks

 * is zero, and its list of 'children' cgroups is empty.  Since all

 *

 * The need for this exception arises from the action of

 * cgroup_attach_task(), which overwrites one tasks cgroup pointer with

 * another.  It does so using cgroup_mutexe, however there are

 * another.  It does so using cgroup_mutex, however there are

 * several performance critical places that need to reference

 * task->cgroup without the expense of grabbing a system global

 * mutex.  Therefore except as noted below, when dereferencing or, as

 * cgroup_lock - lock out any changes to cgroup structures

 *

 */

void cgroup_lock(void)

{

	mutex_lock(&cgroup_mutex);

 *

 * Undo the lock taken in a previous cgroup_lock() call.

 */

void cgroup_unlock(void)

{

	mutex_unlock(&cgroup_mutex);

 * Call subsys's pre_destroy handler.

 * This is called before css refcnt check.

 */

static void cgroup_call_pre_destroy(struct cgroup *cgrp)

{

	struct cgroup_subsys *ss;

	return;

}

static void cgroup_diput(struct dentry *dentry, struct inode *inode)

{

	/* is dentry a directory ? if so, kfree() associated cgroup */

	return dentry->d_fsdata;

}

/*

/**

 * cgroup_path - generate the path of a cgroup

 * @cgrp: the cgroup in question

 * @buf: the buffer to write the path into

 * @buflen: the length of the buffer

 *

 * Called with cgroup_mutex held. Writes path of cgroup into buf.

 * Returns 0 on success, -errno on error.

 */

		*subsys_id = test_ss->subsys_id;

}

/*

 * Attach task 'tsk' to cgroup 'cgrp'

/**

 * cgroup_attach_task - attach task 'tsk' to cgroup 'cgrp'

 * @cgrp: the cgroup the task is attaching to

 * @tsk: the task to be attached

 *

 * Call holding cgroup_mutex. May take task_lock of

 * the task 'pid' during call.

 * the task 'tsk' during call.

 */

int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)

{

}

/* The various types of files and directories in a cgroup file system */

enum cgroup_filetype {

	FILE_ROOT,

	FILE_DIR,

/*

 * cgroup_create_dir - create a directory for an object.

 *	cgrp:	the cgroup we create the directory for.

 *		It must have a valid ->parent field

 *		And we are going to fill its ->dentry field.

 *	dentry: dentry of the new cgroup

 *	mode:	mode to set on new directory.

 * @cgrp: the cgroup we create the directory for. It must have a valid

 *        ->parent field. And we are going to fill its ->dentry field.

 * @dentry: dentry of the new cgroup

 * @mode: mode to set on new directory.

 */

static int cgroup_create_dir(struct cgroup *cgrp, struct dentry *dentry,

				int mode)

	return 0;

}

/* Count the number of tasks in a cgroup. */

/**

 * cgroup_task_count - count the number of tasks in a cgroup.

 * @cgrp: the cgroup in question

 *

 * Return the number of tasks in the cgroup.

 */

int cgroup_task_count(const struct cgroup *cgrp)

{

	int count = 0;

}

/**

 * Build and fill cgroupstats so that taskstats can export it to user

 * space.

 *

 * cgroupstats_build - build and fill cgroupstats

 * @stats: cgroupstats to fill information into

 * @dentry: A dentry entry belonging to the cgroup for which stats have

 * been requested.

 *

 * Build and fill cgroupstats so that taskstats can export it to user

 * space.

 */

int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)

{

/*

 * cgroup_create - create a cgroup

 *	parent:	cgroup that will be parent of the new cgroup.

 *	name:		name of the new cgroup. Will be strcpy'ed.

 *	mode:		mode to set on new inode

 * @parent: cgroup that will be parent of the new cgroup

 * @dentry: dentry of the new cgroup

 * @mode: mode to set on new inode

 *

 * Must be called with the mutex on the parent inode held

 */

static long cgroup_create(struct cgroup *parent, struct dentry *dentry,

			     int mode)

{

	parent = cgrp->parent;

	root = cgrp->root;

	sb = root->sb;

	/*

	 * Call pre_destroy handlers of subsys

	 * Call pre_destroy handlers of subsys. Notify subsystems

	 * that rmdir() request comes.

	 */

	cgroup_call_pre_destroy(cgrp);

	/*

	 * Notify subsyses that rmdir() request comes.

	 */

	if (cgroup_has_css_refs(cgrp)) {

		mutex_unlock(&cgroup_mutex);

}

/**

 * cgroup_init_early - initialize cgroups at system boot, and

 * initialize any subsystems that request early init.

 * cgroup_init_early - cgroup initialization at system boot

 *

 * Initialize cgroups at system boot, and initialize any

 * subsystems that request early init.

 */

int __init cgroup_init_early(void)

{

}

/**

 * cgroup_init - register cgroup filesystem and /proc file, and

 * initialize any subsystems that didn't request early init.

 * cgroup_init - cgroup initialization

 *

 * Register cgroup filesystem and /proc file, and initialize

 * any subsystems that didn't request early init.

 */

int __init cgroup_init(void)

{

/**

 * cgroup_fork - attach newly forked task to its parents cgroup.

 * @tsk: pointer to task_struct of forking parent process.

 * @child: pointer to task_struct of forking parent process.

 *

 * Description: A task inherits its parent's cgroup at fork().

 *

}

/**

 * cgroup_fork_callbacks - called on a new task very soon before

 * adding it to the tasklist. No need to take any locks since no-one

 * can be operating on this task

 * cgroup_fork_callbacks - run fork callbacks

 * @child: the new task

 *

 * Called on a new task very soon before adding it to the

 * tasklist. No need to take any locks since no-one can

 * be operating on this task.

 */

void cgroup_fork_callbacks(struct task_struct *child)

{

}

/**

 * cgroup_post_fork - called on a new task after adding it to the

 * task list. Adds the task to the list running through its css_set

 * if necessary. Has to be after the task is visible on the task list

 * in case we race with the first call to cgroup_iter_start() - to

 * guarantee that the new task ends up on its list. */

 * cgroup_post_fork - called on a new task after adding it to the task list

 * @child: the task in question

 *

 * Adds the task to the list running through its css_set if necessary.

 * Has to be after the task is visible on the task list in case we race

 * with the first call to cgroup_iter_start() - to guarantee that the

 * new task ends up on its list.

 */

void cgroup_post_fork(struct task_struct *child)

{

	if (use_task_css_set_links) {

/**

 * cgroup_exit - detach cgroup from exiting task

 * @tsk: pointer to task_struct of exiting process

 * @run_callback: run exit callbacks?

 *

 * Description: Detach cgroup from @tsk and release it.

 *

 *    top_cgroup isn't going away, and either task has PF_EXITING set,

 *    which wards off any cgroup_attach_task() attempts, or task is a failed

 *    fork, never visible to cgroup_attach_task.

 *

 */

void cgroup_exit(struct task_struct *tsk, int run_callbacks)

{

}

/**

 * cgroup_clone - duplicate the current cgroup in the hierarchy

 * that the given subsystem is attached to, and move this task into

 * the new child

 * cgroup_clone - clone the cgroup the given subsystem is attached to

 * @tsk: the task to be moved

 * @subsys: the given subsystem

 *

 * Duplicate the current cgroup in the hierarchy that the given

 * subsystem is attached to, and move this task into the new

 * child.

 */

int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)

{

	return ret;

}

/*

 * See if "cgrp" is a descendant of the current task's cgroup in

 * the appropriate hierarchy

/**

 * cgroup_is_descendant - see if @cgrp is a descendant of current task's cgrp

 * @cgrp: the cgroup in question

 *

 * See if @cgrp is a descendant of the current task's cgroup in

 * the appropriate hierarchy.

 *

 * If we are sending in dummytop, then presumably we are creating

 * the top cgroup in the subsystem.

 * release agent task.  We don't bother to wait because the caller of

 * this routine has no use for the exit status of the release agent

 * task, so no sense holding our caller up for that.

 *

 */

static void cgroup_release_agent(struct work_struct *work)

{

	BUG_ON(work != &release_agent_work);