Merge branch 'for-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Jun 2018 00:31:33 +0000 (17:31 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Jun 2018 00:31:33 +0000 (17:31 -0700)
Pull workqueue updates from Tejun Heo:

 - make kworkers report the workqueue it is executing or has executed
   most recently in /proc/PID/comm (so they show up in ps/top)

 - CONFIG_SMP shuffle to move stuff which isn't necessary for UP builds
   inside CONFIG_SMP.

* 'for-4.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: move function definitions within CONFIG_SMP block
  workqueue: Make sure struct worker is accessible for wq_worker_comm()
  workqueue: Show the latest workqueue name in /proc/PID/{comm,stat,status}
  proc: Consolidate task->comm formatting into proc_task_name()
  workqueue: Set worker->desc to workqueue name by default
  workqueue: Make worker_attach/detach_pool() update worker->pool
  workqueue: Replace pool->attach_mutex with global wq_pool_attach_mutex

fs/proc/array.c
fs/proc/base.c
fs/proc/internal.h
include/linux/workqueue.h
kernel/workqueue.c
kernel/workqueue_internal.h

index e6d7f41b66845af42f51fe442fee288152161870..004077f1a7bfd1c4083665f998390e3586a15506 100644 (file)
 #include <asm/processor.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;
        size_t size;
-       char tcomm[sizeof(p->comm)];
+       char tcomm[64];
        int ret;
 
-       get_task_comm(tcomm, p);
-
-       seq_puts(m, "Name:\t");
+       if (p->flags & PF_WQ_WORKER)
+               wq_worker_comm(tcomm, sizeof(tcomm), p);
+       else
+               __get_task_comm(tcomm, sizeof(tcomm), p);
 
        size = seq_get_buf(m, &buf);
-       ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
-       seq_commit(m, ret < size ? ret : -1);
+       if (escape) {
+               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);
 
-       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);
 
        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 cgtime, gtime;
        unsigned long rsslim = 0;
-       char tcomm[sizeof(task->comm)];
        unsigned long flags;
 
        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(&sigcatch);
        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_puts(m, " (");
-       seq_puts(m, tcomm);
+       proc_task_name(m, task, false);
        seq_puts(m, ") ");
        seq_putc(m, state);
        seq_put_decimal_ll(m, " ", ppid);
index 33ed1746927a82ff4e39f57a65fb822561a9079c..af128b37414308025819ad8038507ad622ac3e94 100644 (file)
@@ -1563,9 +1563,8 @@ static int comm_show(struct seq_file *m, void *v)
        if (!p)
                return -ESRCH;
 
-       task_lock(p);
-       seq_printf(m, "%s\n", p->comm);
-       task_unlock(p);
+       proc_task_name(m, p, false);
+       seq_putc(m, '\n');
 
        put_task_struct(p);
 
index 43c70c9e6b6298cdea32ae02611d5025f3bb665e..93eb1906c28db04a2a78c56090c158e8b0076206 100644 (file)
@@ -136,6 +136,8 @@ unsigned name_to_int(const struct qstr *qstr);
  */
 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 *,
                         struct pid *, struct task_struct *);
 extern int proc_tgid_stat(struct seq_file *, struct pid_namespace *,
index 39a0e215022a458e21ed57af697ba8e544510bfc..60d673e15632126a038b1efe12108abe122fc235 100644 (file)
@@ -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 void print_worker_info(const char *log_lvl, struct task_struct *task);
 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
index ca7959be8aaa1bf4bd6f540c54db614974db8586..7ea75529eabb7123984a41b0f4c0a0f5ee25f3c8 100644 (file)
@@ -66,7 +66,7 @@ enum {
         * be executing on any CPU.  The pool behaves as an unbound one.
         *
         * 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.
         */
        POOL_MANAGER_ACTIVE     = 1 << 0,       /* being managed */
@@ -123,7 +123,7 @@ enum {
  *    cpu or grabbing pool->lock is enough for read access.  If
  *    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.
  *
@@ -166,7 +166,6 @@ struct worker_pool {
                                                /* L: hash of busy workers */
 
        struct worker           *manager;       /* L: purely informational */
-       struct mutex            attach_mutex;   /* attach/detach exclusion */
        struct list_head        workers;        /* A: attached workers */
        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 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 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
  * @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
  * ignored.
  */
 #define for_each_pool_worker(worker, pool)                             \
        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
 
 /**
@@ -1724,7 +1724,7 @@ static struct worker *alloc_worker(int node)
 static void worker_attach_to_pool(struct worker *worker,
                                   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
@@ -1733,37 +1733,40 @@ static void worker_attach_to_pool(struct worker *worker,
        set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);
 
        /*
-        * The pool->attach_mutex ensures %POOL_DISASSOCIATED remains
-        * stable across this function.  See the comments above the
-        * flag definition for details.
+        * The wq_pool_attach_mutex ensures %POOL_DISASSOCIATED remains
+        * stable across this function.  See the comments above the flag
+        * definition for details.
         */
        if (pool->flags & POOL_DISASSOCIATED)
                worker->flags |= WORKER_UNBOUND;
 
        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: 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
  * caller worker shouldn't access to the pool after detached except it has
  * other reference to the pool.
  */
-static void worker_detach_from_pool(struct worker *worker,
-                                   struct worker_pool *pool)
+static void worker_detach_from_pool(struct worker *worker)
 {
+       struct worker_pool *pool = worker->pool;
        struct completion *detach_completion = NULL;
 
-       mutex_lock(&pool->attach_mutex);
+       mutex_lock(&wq_pool_attach_mutex);
+
        list_del(&worker->node);
+       worker->pool = NULL;
+
        if (list_empty(&pool->workers))
                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 */
        worker->flags &= ~(WORKER_UNBOUND | WORKER_REBOUND);
@@ -1799,7 +1802,6 @@ static struct worker *create_worker(struct worker_pool *pool)
        if (!worker)
                goto fail;
 
-       worker->pool = pool;
        worker->id = id;
 
        if (pool->cpu >= 0)
@@ -2086,6 +2088,12 @@ __acquires(&pool->lock)
        worker->current_pwq = pwq;
        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);
 
        /*
@@ -2181,7 +2189,6 @@ __acquires(&pool->lock)
        worker->current_work = NULL;
        worker->current_func = NULL;
        worker->current_pwq = NULL;
-       worker->desc_valid = false;
        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: self
@@ -2224,7 +2241,7 @@ static int worker_thread(void *__worker)
        struct worker_pool *pool = worker->pool;
 
        /* tell the scheduler that this is a workqueue worker */
-       worker->task->flags |= PF_WQ_WORKER;
+       set_pf_worker(true);
 woke_up:
        spin_lock_irq(&pool->lock);
 
@@ -2232,11 +2249,11 @@ woke_up:
        if (unlikely(worker->flags & WORKER_DIE)) {
                spin_unlock_irq(&pool->lock);
                WARN_ON_ONCE(!list_empty(&worker->entry));
-               worker->task->flags &= ~PF_WQ_WORKER;
+               set_pf_worker(false);
 
                set_task_comm(worker->task, "kworker/dying");
                ida_simple_remove(&pool->worker_ida, worker->id);
-               worker_detach_from_pool(worker, pool);
+               worker_detach_from_pool(worker);
                kfree(worker);
                return 0;
        }
@@ -2335,7 +2352,7 @@ static int rescuer_thread(void *__rescuer)
         * Mark rescuer as worker too.  As WORKER_PREP is never cleared, it
         * doesn't participate in concurrency management.
         */
-       rescuer->task->flags |= PF_WQ_WORKER;
+       set_pf_worker(true);
 repeat:
        set_current_state(TASK_IDLE);
 
@@ -2367,7 +2384,6 @@ repeat:
                worker_attach_to_pool(rescuer, pool);
 
                spin_lock_irq(&pool->lock);
-               rescuer->pool = pool;
 
                /*
                 * Slurp in all works issued via this workqueue and
@@ -2417,10 +2433,9 @@ repeat:
                if (need_more_worker(pool))
                        wake_up_worker(pool);
 
-               rescuer->pool = NULL;
                spin_unlock_irq(&pool->lock);
 
-               worker_detach_from_pool(rescuer, pool);
+               worker_detach_from_pool(rescuer);
 
                spin_lock_irq(&wq_mayday_lock);
        }
@@ -2429,7 +2444,7 @@ repeat:
 
        if (should_stop) {
                __set_current_state(TASK_RUNNING);
-               rescuer->task->flags &= ~PF_WQ_WORKER;
+               set_pf_worker(false);
                return 0;
        }
 
@@ -3271,7 +3286,6 @@ static int init_worker_pool(struct worker_pool *pool)
 
        timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0);
 
-       mutex_init(&pool->attach_mutex);
        INIT_LIST_HEAD(&pool->workers);
 
        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);
        spin_unlock_irq(&pool->lock);
 
-       mutex_lock(&pool->attach_mutex);
+       mutex_lock(&wq_pool_attach_mutex);
        if (!list_empty(&pool->workers))
                pool->detach_completion = &detach_completion;
-       mutex_unlock(&pool->attach_mutex);
+       mutex_unlock(&wq_pool_attach_mutex);
 
        if (pool->detach_completion)
                wait_for_completion(pool->detach_completion);
@@ -4347,7 +4361,6 @@ void set_worker_desc(const char *fmt, ...)
                va_start(args, fmt);
                vsnprintf(worker->desc, sizeof(worker->desc), fmt, 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] = { };
        struct pool_workqueue *pwq = NULL;
        struct workqueue_struct *wq = NULL;
-       bool desc_valid = false;
        struct worker *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);
 
        /*
-        * Carefully copy the associated workqueue's workfn and name.  Keep
-        * the original last '\0' in case the original contains garbage.
+        * Carefully copy the associated workqueue's workfn, name and desc.
+        * Keep the original last '\0' in case the original is garbage.
         */
        probe_kernel_read(&fn, &worker->current_func, sizeof(fn));
        probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));
        probe_kernel_read(&wq, &pwq->wq, sizeof(wq));
        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]) {
                printk("%sWorkqueue: %s %pf", log_lvl, name, fn);
-               if (desc[0])
+               if (strcmp(name, desc))
                        pr_cont(" (%s)", desc);
                pr_cont("\n");
        }
@@ -4579,6 +4587,47 @@ void show_workqueue_state(void)
        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.
  *
@@ -4600,7 +4649,7 @@ static void unbind_workers(int cpu)
        struct worker *worker;
 
        for_each_cpu_worker_pool(pool, cpu) {
-               mutex_lock(&pool->attach_mutex);
+               mutex_lock(&wq_pool_attach_mutex);
                spin_lock_irq(&pool->lock);
 
                /*
@@ -4616,7 +4665,7 @@ static void unbind_workers(int cpu)
                pool->flags |= POOL_DISASSOCIATED;
 
                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
@@ -4657,7 +4706,7 @@ static void rebind_workers(struct worker_pool *pool)
 {
        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
@@ -4727,7 +4776,7 @@ static void restore_unbound_workers_cpumask(struct worker_pool *pool, int cpu)
        static cpumask_t cpumask;
        struct worker *worker;
 
-       lockdep_assert_held(&pool->attach_mutex);
+       lockdep_assert_held(&wq_pool_attach_mutex);
 
        /* is @cpu allowed for @pool? */
        if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))
@@ -4762,14 +4811,14 @@ int workqueue_online_cpu(unsigned int cpu)
        mutex_lock(&wq_pool_mutex);
 
        for_each_pool(pool, pi) {
-               mutex_lock(&pool->attach_mutex);
+               mutex_lock(&wq_pool_attach_mutex);
 
                if (pool->cpu == cpu)
                        rebind_workers(pool);
                else if (pool->cpu < 0)
                        restore_unbound_workers_cpumask(pool, cpu);
 
-               mutex_unlock(&pool->attach_mutex);
+               mutex_unlock(&wq_pool_attach_mutex);
        }
 
        /* update NUMA affinity of unbound workqueues */
@@ -4799,8 +4848,6 @@ int workqueue_offline_cpu(unsigned int cpu)
        return 0;
 }
 
-#ifdef CONFIG_SMP
-
 struct work_for_cpu {
        struct work_struct work;
        long (*fn)(void *);
index d390d1be37489f37bd8ac42826a12782a4ca99dc..66fbb5a9e633b4fbe2b9d6090774ad89a8bfebf9 100644 (file)
@@ -31,13 +31,12 @@ struct worker {
        struct work_struct      *current_work;  /* L: work being processed */
        work_func_t             current_func;   /* L: current_work's fn */
        struct pool_workqueue   *current_pwq; /* L: current_work's pwq */
-       bool                    desc_valid;     /* ->desc is valid */
        struct list_head        scheduled;      /* L: scheduled works */
 
        /* 64 bytes boundary on 64bit, 32 on 32bit */
 
        struct task_struct      *task;          /* I: worker task */
-       struct worker_pool      *pool;          /* I: the associated pool */
+       struct worker_pool      *pool;          /* A: the associated pool */
                                                /* L: for rescuers */
        struct list_head        node;           /* A: anchored at pool->workers */
                                                /* A: runs through worker->node */