Merge branch 'for-4.4-fixes' into for-4.5 (8075b542) · Commits · e / devices / android_kernel_fairphone_FP3

block/blk-cgroup.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -1127,15 +1127,15 @@ void blkcg_exit_queue(struct request_queue *q)
		* of the main cic data structures. For now we allow a task to change
		* its cgroup only if it's the only owner of its ioc.
		*/
		static int blkcg_can_attach(struct cgroup_subsys_state *css,
		struct cgroup_taskset *tset)
		static int blkcg_can_attach(struct cgroup_taskset *tset)
		{
		struct task_struct *task;
		struct cgroup_subsys_state *dst_css;
		struct io_context *ioc;
		int ret = 0;

		/* task_lock() is needed to avoid races with exit_io_context() */
		cgroup_taskset_for_each(task, tset) {
		cgroup_taskset_for_each(task, dst_css, tset) {
		task_lock(task);
		ioc = task->io_context;
		if (ioc && atomic_read(&ioc->nr_tasks) > 1)

include/linux/cgroup-defs.h

+3 −6

Original line number	Diff line number	Diff line
		@@ -421,12 +421,9 @@ struct cgroup_subsys {
		void (css_reset)(struct cgroup_subsys_state css);
		void (css_e_css_changed)(struct cgroup_subsys_state css);

		int (can_attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		void (cancel_attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		void (attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		int (can_attach)(struct cgroup_taskset tset);
		void (cancel_attach)(struct cgroup_taskset tset);
		void (attach)(struct cgroup_taskset tset);
		int (can_fork)(struct task_struct task, void **priv_p);
		void (cancel_fork)(struct task_struct task, void *priv);
		void (fork)(struct task_struct task, void *priv);

include/linux/cgroup.h

+22 −11

Original line number	Diff line number	Diff line
		@@ -120,8 +120,10 @@ struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state
		struct cgroup_subsys_state css_next_descendant_post(struct cgroup_subsys_state pos,
		struct cgroup_subsys_state *css);

		struct task_struct cgroup_taskset_first(struct cgroup_taskset tset);
		struct task_struct cgroup_taskset_next(struct cgroup_taskset tset);
		struct task_struct cgroup_taskset_first(struct cgroup_taskset tset,
		struct cgroup_subsys_state **dst_cssp);
		struct task_struct cgroup_taskset_next(struct cgroup_taskset tset,
		struct cgroup_subsys_state **dst_cssp);

		void css_task_iter_start(struct cgroup_subsys_state *css,
		struct css_task_iter *it);
		@@ -236,30 +238,39 @@ void css_task_iter_end(struct css_task_iter *it);
		/**
		* cgroup_taskset_for_each - iterate cgroup_taskset
		* @task: the loop cursor
		* @dst_css: the destination css
		* @tset: taskset to iterate
		*
		* @tset may contain multiple tasks and they may belong to multiple
		* processes. When there are multiple tasks in @tset, if a task of a
		* process is in @tset, all tasks of the process are in @tset. Also, all
		* are guaranteed to share the same source and destination csses.
		* processes.
		*
		* On the v2 hierarchy, there may be tasks from multiple processes and they
		* may not share the source or destination csses.
		*
		* On traditional hierarchies, when there are multiple tasks in @tset, if a
		* task of a process is in @tset, all tasks of the process are in @tset.
		* Also, all are guaranteed to share the same source and destination csses.
		*
		* Iteration is not in any specific order.
		*/
		#define cgroup_taskset_for_each(task, tset) \
		for ((task) = cgroup_taskset_first((tset)); (task); \
		(task) = cgroup_taskset_next((tset)))
		#define cgroup_taskset_for_each(task, dst_css, tset) \
		for ((task) = cgroup_taskset_first((tset), &(dst_css)); \
		(task); \
		(task) = cgroup_taskset_next((tset), &(dst_css)))

		/**
		* cgroup_taskset_for_each_leader - iterate group leaders in a cgroup_taskset
		* @leader: the loop cursor
		* @dst_css: the destination css
		* @tset: takset to iterate
		*
		* Iterate threadgroup leaders of @tset. For single-task migrations, @tset
		* may not contain any.
		*/
		#define cgroup_taskset_for_each_leader(leader, tset) \
		for ((leader) = cgroup_taskset_first((tset)); (leader); \
		(leader) = cgroup_taskset_next((tset))) \
		#define cgroup_taskset_for_each_leader(leader, dst_css, tset) \
		for ((leader) = cgroup_taskset_first((tset), &(dst_css)); \
		(leader); \
		(leader) = cgroup_taskset_next((tset), &(dst_css))) \
		if ((leader) != (leader)->group_leader) \
		; \
		else

kernel/cgroup.c

+44 −13

Original line number	Diff line number	Diff line
		@@ -761,9 +761,11 @@ static void put_css_set_locked(struct css_set *cset)
		if (!atomic_dec_and_test(&cset->refcount))
		return;

		/* This css_set is dead. unlink it and release cgroup refcounts */
		for_each_subsys(ss, ssid)
		/* This css_set is dead. unlink it and release cgroup and css refs */
		for_each_subsys(ss, ssid) {
		list_del(&cset->e_cset_node[ssid]);
		css_put(cset->subsys[ssid]);
		}
		hash_del(&cset->hlist);
		css_set_count--;

		@@ -1063,9 +1065,13 @@ static struct css_set find_css_set(struct css_set old_cset,
		key = css_set_hash(cset->subsys);
		hash_add(css_set_table, &cset->hlist, key);

		for_each_subsys(ss, ssid)
		for_each_subsys(ss, ssid) {
		struct cgroup_subsys_state *css = cset->subsys[ssid];

		list_add_tail(&cset->e_cset_node[ssid],
		&cset->subsys[ssid]->cgroup->e_csets[ssid]);
		&css->cgroup->e_csets[ssid]);
		css_get(css);
		}

		spin_unlock_bh(&css_set_lock);

		@@ -2229,6 +2235,9 @@ struct cgroup_taskset {
		struct list_head src_csets;
		struct list_head dst_csets;

		/* the subsys currently being processed */
		int ssid;

		/*
		* Fields for cgroup_taskset_*() iteration.
		*
		@@ -2291,25 +2300,29 @@ static void cgroup_taskset_add(struct task_struct *task,
		/**
		* cgroup_taskset_first - reset taskset and return the first task
		* @tset: taskset of interest
		* @dst_cssp: output variable for the destination css
		*
		* @tset iteration is initialized and the first task is returned.
		*/
		struct task_struct cgroup_taskset_first(struct cgroup_taskset tset)
		struct task_struct cgroup_taskset_first(struct cgroup_taskset tset,
		struct cgroup_subsys_state **dst_cssp)
		{
		tset->cur_cset = list_first_entry(tset->csets, struct css_set, mg_node);
		tset->cur_task = NULL;

		return cgroup_taskset_next(tset);
		return cgroup_taskset_next(tset, dst_cssp);
		}

		/**
		* cgroup_taskset_next - iterate to the next task in taskset
		* @tset: taskset of interest
		* @dst_cssp: output variable for the destination css
		*
		* Return the next task in @tset. Iteration must have been initialized
		* with cgroup_taskset_first().
		*/
		struct task_struct cgroup_taskset_next(struct cgroup_taskset tset)
		struct task_struct cgroup_taskset_next(struct cgroup_taskset tset,
		struct cgroup_subsys_state **dst_cssp)
		{
		struct css_set *cset = tset->cur_cset;
		struct task_struct *task = tset->cur_task;
		@@ -2324,6 +2337,18 @@ struct task_struct cgroup_taskset_next(struct cgroup_taskset tset)
		if (&task->cg_list != &cset->mg_tasks) {
		tset->cur_cset = cset;
		tset->cur_task = task;

		/*
		* This function may be called both before and
		* after cgroup_taskset_migrate(). The two cases
		* can be distinguished by looking at whether @cset
		* has its ->mg_dst_cset set.
		*/
		if (cset->mg_dst_cset)
		*dst_cssp = cset->mg_dst_cset->subsys[tset->ssid];
		else
		*dst_cssp = cset->subsys[tset->ssid];

		return task;
		}

		@@ -2359,7 +2384,8 @@ static int cgroup_taskset_migrate(struct cgroup_taskset *tset,
		/* check that we can legitimately attach to the cgroup */
		for_each_e_css(css, i, dst_cgrp) {
		if (css->ss->can_attach) {
		ret = css->ss->can_attach(css, tset);
		tset->ssid = i;
		ret = css->ss->can_attach(tset);
		if (ret) {
		failed_css = css;
		goto out_cancel_attach;
		@@ -2392,9 +2418,12 @@ static int cgroup_taskset_migrate(struct cgroup_taskset *tset,
		*/
		tset->csets = &tset->dst_csets;

		for_each_e_css(css, i, dst_cgrp)
		if (css->ss->attach)
		css->ss->attach(css, tset);
		for_each_e_css(css, i, dst_cgrp) {
		if (css->ss->attach) {
		tset->ssid = i;
		css->ss->attach(tset);
		}
		}

		ret = 0;
		goto out_release_tset;
		@@ -2403,8 +2432,10 @@ static int cgroup_taskset_migrate(struct cgroup_taskset *tset,
		for_each_e_css(css, i, dst_cgrp) {
		if (css == failed_css)
		break;
		if (css->ss->cancel_attach)
		css->ss->cancel_attach(css, tset);
		if (css->ss->cancel_attach) {
		tset->ssid = i;
		css->ss->cancel_attach(tset);
		}
		}
		out_release_tset:
		spin_lock_bh(&css_set_lock);

kernel/cgroup_freezer.c

+10 −13

Original line number	Diff line number	Diff line
		@@ -155,12 +155,10 @@ static void freezer_css_free(struct cgroup_subsys_state *css)
		* @freezer->lock. freezer_attach() makes the new tasks conform to the
		* current state and all following state changes can see the new tasks.
		*/
		static void freezer_attach(struct cgroup_subsys_state *new_css,
		struct cgroup_taskset *tset)
		static void freezer_attach(struct cgroup_taskset *tset)
		{
		struct freezer *freezer = css_freezer(new_css);
		struct task_struct *task;
		bool clear_frozen = false;
		struct cgroup_subsys_state *new_css;

		mutex_lock(&freezer_mutex);

		@@ -174,20 +172,19 @@ static void freezer_attach(struct cgroup_subsys_state *new_css,
		* current state before executing the following - !frozen tasks may
		* be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
		*/
		cgroup_taskset_for_each(task, tset) {
		cgroup_taskset_for_each(task, new_css, tset) {
		struct freezer *freezer = css_freezer(new_css);

		if (!(freezer->state & CGROUP_FREEZING)) {
		__thaw_task(task);
		} else {
		freeze_task(task);
		/* clear FROZEN and propagate upwards */
		while (freezer && (freezer->state & CGROUP_FROZEN)) {
		freezer->state &= ~CGROUP_FROZEN;
		clear_frozen = true;
		freezer = parent_freezer(freezer);
		}
		}

		/* propagate FROZEN clearing upwards */
		while (clear_frozen && (freezer = parent_freezer(freezer))) {
		freezer->state &= ~CGROUP_FROZEN;
		clear_frozen = freezer->state & CGROUP_FREEZING;
		}

		mutex_unlock(&freezer_mutex);

Original line number	Diff line number	Diff line
		@@ -421,12 +421,9 @@ struct cgroup_subsys {
		void (css_reset)(struct cgroup_subsys_state css);
		void (css_e_css_changed)(struct cgroup_subsys_state css);

		int (can_attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		void (cancel_attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		void (attach)(struct cgroup_subsys_state css,
		struct cgroup_taskset *tset);
		int (can_attach)(struct cgroup_taskset tset);
		void (cancel_attach)(struct cgroup_taskset tset);
		void (attach)(struct cgroup_taskset tset);
		int (can_fork)(struct task_struct task, void **priv_p);
		void (cancel_fork)(struct task_struct task, void *priv);
		void (fork)(struct task_struct task, void *priv);