Merge branch 'for-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq (af6c5d5e) · Commits · e / devices / android_kernel_teracube_emerald

fs/proc/array.c

+20 −13

Original line number	Original line	Diff line number	Diff line
	@@ -96,22 +96,29 @@
	#include <asm/processor.h>		#include <asm/processor.h>
	#include "internal.h"		#include "internal.h"

	static inline void task_name(struct seq_file m, struct task_struct p)		void proc_task_name(struct seq_file m, struct task_struct p, bool escape)
	{		{
	char *buf;		char *buf;
	size_t size;		size_t size;
	char tcomm[sizeof(p->comm)];		char tcomm[64];
	int ret;		int ret;

	get_task_comm(tcomm, p);		if (p->flags & PF_WQ_WORKER)
			wq_worker_comm(tcomm, sizeof(tcomm), p);
	seq_puts(m, "Name:\t");		else
			__get_task_comm(tcomm, sizeof(tcomm), p);

	size = seq_get_buf(m, &buf);		size = seq_get_buf(m, &buf);
	ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE \| ESCAPE_SPECIAL, "\n\\");		if (escape) {
	seq_commit(m, ret < size ? ret : -1);		ret = string_escape_str(tcomm, buf, size,
			ESCAPE_SPACE \| ESCAPE_SPECIAL, "\n\\");
			if (ret >= size)
			ret = -1;
			} else {
			ret = strscpy(buf, tcomm, size);
			}

	seq_putc(m, '\n');		seq_commit(m, ret);
	}		}

	/*		/*
	@@ -390,7 +397,10 @@ int proc_pid_status(struct seq_file m, struct pid_namespace ns,
	{		{
	struct mm_struct *mm = get_task_mm(task);		struct mm_struct *mm = get_task_mm(task);

	task_name(m, task);		seq_puts(m, "Name:\t");
			proc_task_name(m, task, true);
			seq_putc(m, '\n');

	task_state(m, ns, pid, task);		task_state(m, ns, pid, task);

	if (mm) {		if (mm) {
	@@ -425,7 +435,6 @@ static int do_task_stat(struct seq_file m, struct pid_namespace ns,
	u64 cutime, cstime, utime, stime;		u64 cutime, cstime, utime, stime;
	u64 cgtime, gtime;		u64 cgtime, gtime;
	unsigned long rsslim = 0;		unsigned long rsslim = 0;
	char tcomm[sizeof(task->comm)];
	unsigned long flags;		unsigned long flags;

	state = *get_task_state(task);		state = *get_task_state(task);
	@@ -452,8 +461,6 @@ static int do_task_stat(struct seq_file m, struct pid_namespace ns,
	}		}
	}		}

	get_task_comm(tcomm, task);

	sigemptyset(&sigign);		sigemptyset(&sigign);
	sigemptyset(&sigcatch);		sigemptyset(&sigcatch);
	cutime = cstime = utime = stime = 0;		cutime = cstime = utime = stime = 0;
	@@ -520,7 +527,7 @@ static int do_task_stat(struct seq_file m, struct pid_namespace ns,

	seq_put_decimal_ull(m, "", pid_nr_ns(pid, ns));		seq_put_decimal_ull(m, "", pid_nr_ns(pid, ns));
	seq_puts(m, " (");		seq_puts(m, " (");
	seq_puts(m, tcomm);		proc_task_name(m, task, false);
	seq_puts(m, ") ");		seq_puts(m, ") ");
	seq_putc(m, state);		seq_putc(m, state);
	seq_put_decimal_ll(m, " ", ppid);		seq_put_decimal_ll(m, " ", ppid);

fs/proc/base.c

+2 −3

Original line number	Original line	Diff line number	Diff line
	@@ -1563,9 +1563,8 @@ static int comm_show(struct seq_file m, void v)
	if (!p)		if (!p)
	return -ESRCH;		return -ESRCH;

	task_lock(p);		proc_task_name(m, p, false);
	seq_printf(m, "%s\n", p->comm);		seq_putc(m, '\n');
	task_unlock(p);

	put_task_struct(p);		put_task_struct(p);

fs/proc/internal.h

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -136,6 +136,8 @@ unsigned name_to_int(const struct qstr *qstr);
	*/		*/
	extern const struct file_operations proc_tid_children_operations;		extern const struct file_operations proc_tid_children_operations;

			extern void proc_task_name(struct seq_file m, struct task_struct p,
			bool escape);
	extern int proc_tid_stat(struct seq_file , struct pid_namespace ,		extern int proc_tid_stat(struct seq_file , struct pid_namespace ,
	struct pid , struct task_struct );		struct pid , struct task_struct );
	extern int proc_tgid_stat(struct seq_file , struct pid_namespace ,		extern int proc_tgid_stat(struct seq_file , struct pid_namespace ,

include/linux/workqueue.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -494,6 +494,7 @@ extern unsigned int work_busy(struct work_struct *work);
	extern __printf(1, 2) void set_worker_desc(const char *fmt, ...);		extern __printf(1, 2) void set_worker_desc(const char *fmt, ...);
	extern void print_worker_info(const char log_lvl, struct task_struct task);		extern void print_worker_info(const char log_lvl, struct task_struct task);
	extern void show_workqueue_state(void);		extern void show_workqueue_state(void);
			extern void wq_worker_comm(char buf, size_t size, struct task_struct task);

	/**		/**
	* queue_work - queue work on a workqueue		* queue_work - queue work on a workqueue

kernel/workqueue.c

+93 −46

Original line number	Original line	Diff line number	Diff line
	@@ -66,7 +66,7 @@ enum {
	* be executing on any CPU. The pool behaves as an unbound one.		* be executing on any CPU. The pool behaves as an unbound one.
	*		*
	* Note that DISASSOCIATED should be flipped only while holding		* Note that DISASSOCIATED should be flipped only while holding
	* attach_mutex to avoid changing binding state while		* wq_pool_attach_mutex to avoid changing binding state while
	* worker_attach_to_pool() is in progress.		* worker_attach_to_pool() is in progress.
	*/		*/
	POOL_MANAGER_ACTIVE = 1 << 0, /* being managed */		POOL_MANAGER_ACTIVE = 1 << 0, /* being managed */
	@@ -123,7 +123,7 @@ enum {
	* cpu or grabbing pool->lock is enough for read access. If		* cpu or grabbing pool->lock is enough for read access. If
	* POOL_DISASSOCIATED is set, it's identical to L.		* POOL_DISASSOCIATED is set, it's identical to L.
	*		*
	* A: pool->attach_mutex protected.		* A: wq_pool_attach_mutex protected.
	*		*
	* PL: wq_pool_mutex protected.		* PL: wq_pool_mutex protected.
	*		*
	@@ -166,7 +166,6 @@ struct worker_pool {
	/* L: hash of busy workers */		/* L: hash of busy workers */

	struct worker manager; / L: purely informational */		struct worker manager; / L: purely informational */
	struct mutex attach_mutex; /* attach/detach exclusion */
	struct list_head workers; /* A: attached workers */		struct list_head workers; /* A: attached workers */
	struct completion detach_completion; / all workers detached */		struct completion detach_completion; / all workers detached */

	@@ -297,6 +296,7 @@ static bool wq_numa_enabled; /* unbound NUMA affinity enabled */
	static struct workqueue_attrs *wq_update_unbound_numa_attrs_buf;		static struct workqueue_attrs *wq_update_unbound_numa_attrs_buf;

	static DEFINE_MUTEX(wq_pool_mutex); /* protects pools and workqueues list */		static DEFINE_MUTEX(wq_pool_mutex); /* protects pools and workqueues list */
			static DEFINE_MUTEX(wq_pool_attach_mutex); /* protects worker attach/detach */
	static DEFINE_SPINLOCK(wq_mayday_lock); /* protects wq->maydays list */		static DEFINE_SPINLOCK(wq_mayday_lock); /* protects wq->maydays list */
	static DECLARE_WAIT_QUEUE_HEAD(wq_manager_wait); /* wait for manager to go away */		static DECLARE_WAIT_QUEUE_HEAD(wq_manager_wait); /* wait for manager to go away */

	@@ -399,14 +399,14 @@ static void workqueue_sysfs_unregister(struct workqueue_struct *wq);
	* @worker: iteration cursor		* @worker: iteration cursor
	* @pool: worker_pool to iterate workers of		* @pool: worker_pool to iterate workers of
	*		*
	* This must be called with @pool->attach_mutex.		* This must be called with wq_pool_attach_mutex.
	*		*
	* The if/else clause exists only for the lockdep assertion and can be		* The if/else clause exists only for the lockdep assertion and can be
	* ignored.		* ignored.
	*/		*/
	#define for_each_pool_worker(worker, pool) \		#define for_each_pool_worker(worker, pool) \
	list_for_each_entry((worker), &(pool)->workers, node) \		list_for_each_entry((worker), &(pool)->workers, node) \
	if (({ lockdep_assert_held(&pool->attach_mutex); false; })) { } \		if (({ lockdep_assert_held(&wq_pool_attach_mutex); false; })) { } \
	else		else

	/**		/**
	@@ -1724,7 +1724,7 @@ static struct worker *alloc_worker(int node)
	static void worker_attach_to_pool(struct worker *worker,		static void worker_attach_to_pool(struct worker *worker,
	struct worker_pool *pool)		struct worker_pool *pool)
	{		{
	mutex_lock(&pool->attach_mutex);		mutex_lock(&wq_pool_attach_mutex);

	/*		/*
	* set_cpus_allowed_ptr() will fail if the cpumask doesn't have any		* set_cpus_allowed_ptr() will fail if the cpumask doesn't have any
	@@ -1733,37 +1733,40 @@ static void worker_attach_to_pool(struct worker *worker,
	set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);		set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);

	/*		/*
	* The pool->attach_mutex ensures %POOL_DISASSOCIATED remains		* The wq_pool_attach_mutex ensures %POOL_DISASSOCIATED remains
	* stable across this function. See the comments above the		* stable across this function. See the comments above the flag
	* flag definition for details.		* definition for details.
	*/		*/
	if (pool->flags & POOL_DISASSOCIATED)		if (pool->flags & POOL_DISASSOCIATED)
	worker->flags \|= WORKER_UNBOUND;		worker->flags \|= WORKER_UNBOUND;

	list_add_tail(&worker->node, &pool->workers);		list_add_tail(&worker->node, &pool->workers);
			worker->pool = pool;

	mutex_unlock(&pool->attach_mutex);		mutex_unlock(&wq_pool_attach_mutex);
	}		}

	/**		/**
	* worker_detach_from_pool() - detach a worker from its pool		* worker_detach_from_pool() - detach a worker from its pool
	* @worker: worker which is attached to its pool		* @worker: worker which is attached to its pool
	* @pool: the pool @worker is attached to
	*		*
	* Undo the attaching which had been done in worker_attach_to_pool(). The		* Undo the attaching which had been done in worker_attach_to_pool(). The
	* caller worker shouldn't access to the pool after detached except it has		* caller worker shouldn't access to the pool after detached except it has
	* other reference to the pool.		* other reference to the pool.
	*/		*/
	static void worker_detach_from_pool(struct worker *worker,		static void worker_detach_from_pool(struct worker *worker)
	struct worker_pool *pool)
	{		{
			struct worker_pool *pool = worker->pool;
	struct completion *detach_completion = NULL;		struct completion *detach_completion = NULL;

	mutex_lock(&pool->attach_mutex);		mutex_lock(&wq_pool_attach_mutex);

	list_del(&worker->node);		list_del(&worker->node);
			worker->pool = NULL;

	if (list_empty(&pool->workers))		if (list_empty(&pool->workers))
	detach_completion = pool->detach_completion;		detach_completion = pool->detach_completion;
	mutex_unlock(&pool->attach_mutex);		mutex_unlock(&wq_pool_attach_mutex);

	/* clear leftover flags without pool->lock after it is detached */		/* clear leftover flags without pool->lock after it is detached */
	worker->flags &= ~(WORKER_UNBOUND \| WORKER_REBOUND);		worker->flags &= ~(WORKER_UNBOUND \| WORKER_REBOUND);
	@@ -1799,7 +1802,6 @@ static struct worker create_worker(struct worker_pool pool)
	if (!worker)		if (!worker)
	goto fail;		goto fail;

	worker->pool = pool;
	worker->id = id;		worker->id = id;

	if (pool->cpu >= 0)		if (pool->cpu >= 0)
	@@ -2086,6 +2088,12 @@ __acquires(&pool->lock)
	worker->current_pwq = pwq;		worker->current_pwq = pwq;
	work_color = get_work_color(work);		work_color = get_work_color(work);

			/*
			* Record wq name for cmdline and debug reporting, may get
			* overridden through set_worker_desc().
			*/
			strscpy(worker->desc, pwq->wq->name, WORKER_DESC_LEN);

	list_del_init(&work->entry);		list_del_init(&work->entry);

	/*		/*
	@@ -2181,7 +2189,6 @@ __acquires(&pool->lock)
	worker->current_work = NULL;		worker->current_work = NULL;
	worker->current_func = NULL;		worker->current_func = NULL;
	worker->current_pwq = NULL;		worker->current_pwq = NULL;
	worker->desc_valid = false;
	pwq_dec_nr_in_flight(pwq, work_color);		pwq_dec_nr_in_flight(pwq, work_color);
	}		}

	@@ -2206,6 +2213,16 @@ static void process_scheduled_works(struct worker *worker)
	}		}
	}		}

			static void set_pf_worker(bool val)
			{
			mutex_lock(&wq_pool_attach_mutex);
			if (val)
			current->flags \|= PF_WQ_WORKER;
			else
			current->flags &= ~PF_WQ_WORKER;
			mutex_unlock(&wq_pool_attach_mutex);
			}

	/**		/**
	* worker_thread - the worker thread function		* worker_thread - the worker thread function
	* @__worker: self		* @__worker: self
	@@ -2224,7 +2241,7 @@ static int worker_thread(void *__worker)
	struct worker_pool *pool = worker->pool;		struct worker_pool *pool = worker->pool;

	/* tell the scheduler that this is a workqueue worker */		/* tell the scheduler that this is a workqueue worker */
	worker->task->flags \|= PF_WQ_WORKER;		set_pf_worker(true);
	woke_up:		woke_up:
	spin_lock_irq(&pool->lock);		spin_lock_irq(&pool->lock);

	@@ -2232,11 +2249,11 @@ static int worker_thread(void *__worker)
	if (unlikely(worker->flags & WORKER_DIE)) {		if (unlikely(worker->flags & WORKER_DIE)) {
	spin_unlock_irq(&pool->lock);		spin_unlock_irq(&pool->lock);
	WARN_ON_ONCE(!list_empty(&worker->entry));		WARN_ON_ONCE(!list_empty(&worker->entry));
	worker->task->flags &= ~PF_WQ_WORKER;		set_pf_worker(false);

	set_task_comm(worker->task, "kworker/dying");		set_task_comm(worker->task, "kworker/dying");
	ida_simple_remove(&pool->worker_ida, worker->id);		ida_simple_remove(&pool->worker_ida, worker->id);
	worker_detach_from_pool(worker, pool);		worker_detach_from_pool(worker);
	kfree(worker);		kfree(worker);
	return 0;		return 0;
	}		}
	@@ -2335,7 +2352,7 @@ static int rescuer_thread(void *__rescuer)
	* Mark rescuer as worker too. As WORKER_PREP is never cleared, it		* Mark rescuer as worker too. As WORKER_PREP is never cleared, it
	* doesn't participate in concurrency management.		* doesn't participate in concurrency management.
	*/		*/
	rescuer->task->flags \|= PF_WQ_WORKER;		set_pf_worker(true);
	repeat:		repeat:
	set_current_state(TASK_IDLE);		set_current_state(TASK_IDLE);

	@@ -2367,7 +2384,6 @@ static int rescuer_thread(void *__rescuer)
	worker_attach_to_pool(rescuer, pool);		worker_attach_to_pool(rescuer, pool);

	spin_lock_irq(&pool->lock);		spin_lock_irq(&pool->lock);
	rescuer->pool = pool;

	/*		/*
	* Slurp in all works issued via this workqueue and		* Slurp in all works issued via this workqueue and
	@@ -2417,10 +2433,9 @@ static int rescuer_thread(void *__rescuer)
	if (need_more_worker(pool))		if (need_more_worker(pool))
	wake_up_worker(pool);		wake_up_worker(pool);

	rescuer->pool = NULL;
	spin_unlock_irq(&pool->lock);		spin_unlock_irq(&pool->lock);

	worker_detach_from_pool(rescuer, pool);		worker_detach_from_pool(rescuer);

	spin_lock_irq(&wq_mayday_lock);		spin_lock_irq(&wq_mayday_lock);
	}		}
	@@ -2429,7 +2444,7 @@ static int rescuer_thread(void *__rescuer)

	if (should_stop) {		if (should_stop) {
	__set_current_state(TASK_RUNNING);		__set_current_state(TASK_RUNNING);
	rescuer->task->flags &= ~PF_WQ_WORKER;		set_pf_worker(false);
	return 0;		return 0;
	}		}

	@@ -3271,7 +3286,6 @@ static int init_worker_pool(struct worker_pool *pool)

	timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0);		timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0);

	mutex_init(&pool->attach_mutex);
	INIT_LIST_HEAD(&pool->workers);		INIT_LIST_HEAD(&pool->workers);

	ida_init(&pool->worker_ida);		ida_init(&pool->worker_ida);
	@@ -3354,10 +3368,10 @@ static void put_unbound_pool(struct worker_pool *pool)
	WARN_ON(pool->nr_workers \|\| pool->nr_idle);		WARN_ON(pool->nr_workers \|\| pool->nr_idle);
	spin_unlock_irq(&pool->lock);		spin_unlock_irq(&pool->lock);

	mutex_lock(&pool->attach_mutex);		mutex_lock(&wq_pool_attach_mutex);
	if (!list_empty(&pool->workers))		if (!list_empty(&pool->workers))
	pool->detach_completion = &detach_completion;		pool->detach_completion = &detach_completion;
	mutex_unlock(&pool->attach_mutex);		mutex_unlock(&wq_pool_attach_mutex);

	if (pool->detach_completion)		if (pool->detach_completion)
	wait_for_completion(pool->detach_completion);		wait_for_completion(pool->detach_completion);
	@@ -4347,7 +4361,6 @@ void set_worker_desc(const char *fmt, ...)
	va_start(args, fmt);		va_start(args, fmt);
	vsnprintf(worker->desc, sizeof(worker->desc), fmt, args);		vsnprintf(worker->desc, sizeof(worker->desc), fmt, args);
	va_end(args);		va_end(args);
	worker->desc_valid = true;
	}		}
	}		}

	@@ -4371,7 +4384,6 @@ void print_worker_info(const char log_lvl, struct task_struct task)
	char desc[WORKER_DESC_LEN] = { };		char desc[WORKER_DESC_LEN] = { };
	struct pool_workqueue *pwq = NULL;		struct pool_workqueue *pwq = NULL;
	struct workqueue_struct *wq = NULL;		struct workqueue_struct *wq = NULL;
	bool desc_valid = false;
	struct worker *worker;		struct worker *worker;

	if (!(task->flags & PF_WQ_WORKER))		if (!(task->flags & PF_WQ_WORKER))
	@@ -4384,22 +4396,18 @@ void print_worker_info(const char log_lvl, struct task_struct task)
	worker = kthread_probe_data(task);		worker = kthread_probe_data(task);

	/*		/*
	* Carefully copy the associated workqueue's workfn and name. Keep		* Carefully copy the associated workqueue's workfn, name and desc.
	* the original last '\0' in case the original contains garbage.		* Keep the original last '\0' in case the original is garbage.
	*/		*/
	probe_kernel_read(&fn, &worker->current_func, sizeof(fn));		probe_kernel_read(&fn, &worker->current_func, sizeof(fn));
	probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));		probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));
	probe_kernel_read(&wq, &pwq->wq, sizeof(wq));		probe_kernel_read(&wq, &pwq->wq, sizeof(wq));
	probe_kernel_read(name, wq->name, sizeof(name) - 1);		probe_kernel_read(name, wq->name, sizeof(name) - 1);

	/* copy worker description */
	probe_kernel_read(&desc_valid, &worker->desc_valid, sizeof(desc_valid));
	if (desc_valid)
	probe_kernel_read(desc, worker->desc, sizeof(desc) - 1);		probe_kernel_read(desc, worker->desc, sizeof(desc) - 1);

	if (fn \|\| name[0] \|\| desc[0]) {		if (fn \|\| name[0] \|\| desc[0]) {
	printk("%sWorkqueue: %s %pf", log_lvl, name, fn);		printk("%sWorkqueue: %s %pf", log_lvl, name, fn);
	if (desc[0])		if (strcmp(name, desc))
	pr_cont(" (%s)", desc);		pr_cont(" (%s)", desc);
	pr_cont("\n");		pr_cont("\n");
	}		}
	@@ -4579,6 +4587,47 @@ void show_workqueue_state(void)
	rcu_read_unlock_sched();		rcu_read_unlock_sched();
	}		}

			/* used to show worker information through /proc/PID/{comm,stat,status} */
			void wq_worker_comm(char buf, size_t size, struct task_struct task)
			{
			int off;

			/* always show the actual comm */
			off = strscpy(buf, task->comm, size);
			if (off < 0)
			return;

			/* stabilize PF_WQ_WORKER and worker pool association */
			mutex_lock(&wq_pool_attach_mutex);

			if (task->flags & PF_WQ_WORKER) {
			struct worker *worker = kthread_data(task);
			struct worker_pool *pool = worker->pool;

			if (pool) {
			spin_lock_irq(&pool->lock);
			/*
			* ->desc tracks information (wq name or
			* set_worker_desc()) for the latest execution. If
			* current, prepend '+', otherwise '-'.
			*/
			if (worker->desc[0] != '\0') {
			if (worker->current_work)
			scnprintf(buf + off, size - off, "+%s",
			worker->desc);
			else
			scnprintf(buf + off, size - off, "-%s",
			worker->desc);
			}
			spin_unlock_irq(&pool->lock);
			}
			}

			mutex_unlock(&wq_pool_attach_mutex);
			}

			#ifdef CONFIG_SMP

	/*		/*
	* CPU hotplug.		* CPU hotplug.
	*		*
	@@ -4600,7 +4649,7 @@ static void unbind_workers(int cpu)
	struct worker *worker;		struct worker *worker;

	for_each_cpu_worker_pool(pool, cpu) {		for_each_cpu_worker_pool(pool, cpu) {
	mutex_lock(&pool->attach_mutex);		mutex_lock(&wq_pool_attach_mutex);
	spin_lock_irq(&pool->lock);		spin_lock_irq(&pool->lock);

	/*		/*
	@@ -4616,7 +4665,7 @@ static void unbind_workers(int cpu)
	pool->flags \|= POOL_DISASSOCIATED;		pool->flags \|= POOL_DISASSOCIATED;

	spin_unlock_irq(&pool->lock);		spin_unlock_irq(&pool->lock);
	mutex_unlock(&pool->attach_mutex);		mutex_unlock(&wq_pool_attach_mutex);

	/*		/*
	* Call schedule() so that we cross rq->lock and thus can		* Call schedule() so that we cross rq->lock and thus can
	@@ -4657,7 +4706,7 @@ static void rebind_workers(struct worker_pool *pool)
	{		{
	struct worker *worker;		struct worker *worker;

	lockdep_assert_held(&pool->attach_mutex);		lockdep_assert_held(&wq_pool_attach_mutex);

	/*		/*
	* Restore CPU affinity of all workers. As all idle workers should		* Restore CPU affinity of all workers. As all idle workers should
	@@ -4727,7 +4776,7 @@ static void restore_unbound_workers_cpumask(struct worker_pool *pool, int cpu)
	static cpumask_t cpumask;		static cpumask_t cpumask;
	struct worker *worker;		struct worker *worker;

	lockdep_assert_held(&pool->attach_mutex);		lockdep_assert_held(&wq_pool_attach_mutex);

	/* is @cpu allowed for @pool? */		/* is @cpu allowed for @pool? */
	if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))		if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))
	@@ -4762,14 +4811,14 @@ int workqueue_online_cpu(unsigned int cpu)
	mutex_lock(&wq_pool_mutex);		mutex_lock(&wq_pool_mutex);

	for_each_pool(pool, pi) {		for_each_pool(pool, pi) {
	mutex_lock(&pool->attach_mutex);		mutex_lock(&wq_pool_attach_mutex);

	if (pool->cpu == cpu)		if (pool->cpu == cpu)
	rebind_workers(pool);		rebind_workers(pool);
	else if (pool->cpu < 0)		else if (pool->cpu < 0)
	restore_unbound_workers_cpumask(pool, cpu);		restore_unbound_workers_cpumask(pool, cpu);

	mutex_unlock(&pool->attach_mutex);		mutex_unlock(&wq_pool_attach_mutex);
	}		}

	/* update NUMA affinity of unbound workqueues */		/* update NUMA affinity of unbound workqueues */
	@@ -4799,8 +4848,6 @@ int workqueue_offline_cpu(unsigned int cpu)
	return 0;		return 0;
	}		}

	#ifdef CONFIG_SMP

	struct work_for_cpu {		struct work_for_cpu {
	struct work_struct work;		struct work_struct work;
	long (fn)(void );		long (fn)(void );