Merge branch 'for-4.15' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 15 Nov 2017 22:15:21 +0000 (14:15 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 15 Nov 2017 22:15:21 +0000 (14:15 -0800)
Pull workqueue updates from Tejun Heo:
 "There was a commit to make unbound kworkers respect cpu isolation but
  it conflicted with the restructuring of cpu isolation and got
  reverted, so the only thing left is the trivial comment fix.

  Will retry the cpu isolation change after this merge window"

* 'for-4.15' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: Fix comment for unbound workqueue's attrbutes
  Revert "workqueue: respect isolated cpus when queueing an unbound work"
  workqueue: respect isolated cpus when queueing an unbound work

1  2 
kernel/workqueue.c

diff --combined kernel/workqueue.c
index 7368b57842ea349ca0c1183f6999ec7f16e6c647,5f99851bff09afd512d8328b5d3ea43da22fd342..dde6298f6b221e136fc579a37adc80310f97a8f6
@@@ -68,7 -68,6 +68,7 @@@ enum 
         * attach_mutex to avoid changing binding state while
         * worker_attach_to_pool() is in progress.
         */
 +      POOL_MANAGER_ACTIVE     = 1 << 0,       /* being managed */
        POOL_DISASSOCIATED      = 1 << 2,       /* cpu can't serve workers */
  
        /* worker flags */
@@@ -166,6 -165,7 +166,6 @@@ struct worker_pool 
                                                /* L: hash of busy workers */
  
        /* see manage_workers() for details on the two manager mutexes */
 -      struct mutex            manager_arb;    /* manager arbitration */
        struct worker           *manager;       /* L: purely informational */
        struct mutex            attach_mutex;   /* attach/detach exclusion */
        struct list_head        workers;        /* A: attached workers */
@@@ -299,7 -299,6 +299,7 @@@ static struct workqueue_attrs *wq_updat
  
  static DEFINE_MUTEX(wq_pool_mutex);   /* protects pools and workqueues 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 LIST_HEAD(workqueues);         /* PR: list of all workqueues */
  static bool workqueue_freezing;               /* PL: have wqs started freezing? */
@@@ -802,7 -801,7 +802,7 @@@ static bool need_to_create_worker(struc
  /* Do we have too many workers and should some go away? */
  static bool too_many_workers(struct worker_pool *pool)
  {
 -      bool managing = mutex_is_locked(&pool->manager_arb);
 +      bool managing = pool->flags & POOL_MANAGER_ACTIVE;
        int nr_idle = pool->nr_idle + managing; /* manager is considered idle */
        int nr_busy = pool->nr_workers - nr_idle;
  
@@@ -1376,7 -1375,7 +1376,7 @@@ static void __queue_work(int cpu, struc
         * queued or lose PENDING.  Grabbing PENDING and queueing should
         * happen with IRQ disabled.
         */
 -      WARN_ON_ONCE(!irqs_disabled());
 +      lockdep_assert_irqs_disabled();
  
        debug_work_activate(work);
  
@@@ -1493,9 -1492,9 +1493,9 @@@ bool queue_work_on(int cpu, struct work
  }
  EXPORT_SYMBOL(queue_work_on);
  
 -void delayed_work_timer_fn(unsigned long __data)
 +void delayed_work_timer_fn(struct timer_list *t)
  {
 -      struct delayed_work *dwork = (struct delayed_work *)__data;
 +      struct delayed_work *dwork = from_timer(dwork, t, timer);
  
        /* should have been called from irqsafe timer with irq already off */
        __queue_work(dwork->cpu, dwork->wq, &dwork->work);
@@@ -1509,7 -1508,8 +1509,7 @@@ static void __queue_delayed_work(int cp
        struct work_struct *work = &dwork->work;
  
        WARN_ON_ONCE(!wq);
 -      WARN_ON_ONCE(timer->function != delayed_work_timer_fn ||
 -                   timer->data != (unsigned long)dwork);
 +      WARN_ON_ONCE(timer->function != (TIMER_FUNC_TYPE)delayed_work_timer_fn);
        WARN_ON_ONCE(timer_pending(timer));
        WARN_ON_ONCE(!list_empty(&work->entry));
  
@@@ -1832,9 -1832,9 +1832,9 @@@ static void destroy_worker(struct worke
        wake_up_process(worker->task);
  }
  
 -static void idle_worker_timeout(unsigned long __pool)
 +static void idle_worker_timeout(struct timer_list *t)
  {
 -      struct worker_pool *pool = (void *)__pool;
 +      struct worker_pool *pool = from_timer(pool, t, idle_timer);
  
        spin_lock_irq(&pool->lock);
  
@@@ -1880,9 -1880,9 +1880,9 @@@ static void send_mayday(struct work_str
        }
  }
  
 -static void pool_mayday_timeout(unsigned long __pool)
 +static void pool_mayday_timeout(struct timer_list *t)
  {
 -      struct worker_pool *pool = (void *)__pool;
 +      struct worker_pool *pool = from_timer(pool, t, mayday_timer);
        struct work_struct *work;
  
        spin_lock_irq(&pool->lock);
@@@ -1980,17 -1980,24 +1980,17 @@@ static bool manage_workers(struct worke
  {
        struct worker_pool *pool = worker->pool;
  
 -      /*
 -       * Anyone who successfully grabs manager_arb wins the arbitration
 -       * and becomes the manager.  mutex_trylock() on pool->manager_arb
 -       * failure while holding pool->lock reliably indicates that someone
 -       * else is managing the pool and the worker which failed trylock
 -       * can proceed to executing work items.  This means that anyone
 -       * grabbing manager_arb is responsible for actually performing
 -       * manager duties.  If manager_arb is grabbed and released without
 -       * actual management, the pool may stall indefinitely.
 -       */
 -      if (!mutex_trylock(&pool->manager_arb))
 +      if (pool->flags & POOL_MANAGER_ACTIVE)
                return false;
 +
 +      pool->flags |= POOL_MANAGER_ACTIVE;
        pool->manager = worker;
  
        maybe_create_worker(pool);
  
        pool->manager = NULL;
 -      mutex_unlock(&pool->manager_arb);
 +      pool->flags &= ~POOL_MANAGER_ACTIVE;
 +      wake_up(&wq_manager_wait);
        return true;
  }
  
@@@ -2490,8 -2497,15 +2490,8 @@@ static void insert_wq_barrier(struct po
        INIT_WORK_ONSTACK(&barr->work, wq_barrier_func);
        __set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&barr->work));
  
 -      /*
 -       * Explicitly init the crosslock for wq_barrier::done, make its lock
 -       * key a subkey of the corresponding work. As a result we won't
 -       * build a dependency between wq_barrier::done and unrelated work.
 -       */
 -      lockdep_init_map_crosslock((struct lockdep_map *)&barr->done.map,
 -                                 "(complete)wq_barr::done",
 -                                 target->lockdep_map.key, 1);
 -      __init_completion(&barr->done);
 +      init_completion_map(&barr->done, &target->lockdep_map);
 +
        barr->task = current;
  
        /*
@@@ -2597,13 -2611,16 +2597,13 @@@ void flush_workqueue(struct workqueue_s
        struct wq_flusher this_flusher = {
                .list = LIST_HEAD_INIT(this_flusher.list),
                .flush_color = -1,
 -              .done = COMPLETION_INITIALIZER_ONSTACK(this_flusher.done),
 +              .done = COMPLETION_INITIALIZER_ONSTACK_MAP(this_flusher.done, wq->lockdep_map),
        };
        int next_color;
  
        if (WARN_ON(!wq_online))
                return;
  
 -      lock_map_acquire(&wq->lockdep_map);
 -      lock_map_release(&wq->lockdep_map);
 -
        mutex_lock(&wq->mutex);
  
        /*
@@@ -2866,6 -2883,9 +2866,6 @@@ bool flush_work(struct work_struct *wor
        if (WARN_ON(!wq_online))
                return false;
  
 -      lock_map_acquire(&work->lockdep_map);
 -      lock_map_release(&work->lockdep_map);
 -
        if (start_flush_work(work, &barr)) {
                wait_for_completion(&barr.done);
                destroy_work_on_stack(&barr.work);
@@@ -3222,10 -3242,13 +3222,10 @@@ static int init_worker_pool(struct work
        INIT_LIST_HEAD(&pool->idle_list);
        hash_init(pool->busy_hash);
  
 -      setup_deferrable_timer(&pool->idle_timer, idle_worker_timeout,
 -                             (unsigned long)pool);
 +      timer_setup(&pool->idle_timer, idle_worker_timeout, TIMER_DEFERRABLE);
  
 -      setup_timer(&pool->mayday_timer, pool_mayday_timeout,
 -                  (unsigned long)pool);
 +      timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0);
  
 -      mutex_init(&pool->manager_arb);
        mutex_init(&pool->attach_mutex);
        INIT_LIST_HEAD(&pool->workers);
  
@@@ -3295,15 -3318,13 +3295,15 @@@ static void put_unbound_pool(struct wor
        hash_del(&pool->hash_node);
  
        /*
 -       * Become the manager and destroy all workers.  Grabbing
 -       * manager_arb prevents @pool's workers from blocking on
 -       * attach_mutex.
 +       * Become the manager and destroy all workers.  This prevents
 +       * @pool's workers from blocking on attach_mutex.  We're the last
 +       * manager and @pool gets freed with the flag set.
         */
 -      mutex_lock(&pool->manager_arb);
 -
        spin_lock_irq(&pool->lock);
 +      wait_event_lock_irq(wq_manager_wait,
 +                          !(pool->flags & POOL_MANAGER_ACTIVE), pool->lock);
 +      pool->flags |= POOL_MANAGER_ACTIVE;
 +
        while ((worker = first_idle_worker(pool)))
                destroy_worker(worker);
        WARN_ON(pool->nr_workers || pool->nr_idle);
        if (pool->detach_completion)
                wait_for_completion(pool->detach_completion);
  
 -      mutex_unlock(&pool->manager_arb);
 -
        /* shut down the timers */
        del_timer_sync(&pool->idle_timer);
        del_timer_sync(&pool->mayday_timer);
@@@ -4624,7 -4647,7 +4624,7 @@@ static void rebind_workers(struct worke
                 * concurrency management.  Note that when or whether
                 * @worker clears REBOUND doesn't affect correctness.
                 *
 -               * ACCESS_ONCE() is necessary because @worker->flags may be
 +               * WRITE_ONCE() is necessary because @worker->flags may be
                 * tested without holding any lock in
                 * wq_worker_waking_up().  Without it, NOT_RUNNING test may
                 * fail incorrectly leading to premature concurrency
                WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND));
                worker_flags |= WORKER_REBOUND;
                worker_flags &= ~WORKER_UNBOUND;
 -              ACCESS_ONCE(worker->flags) = worker_flags;
 +              WRITE_ONCE(worker->flags, worker_flags);
        }
  
        spin_unlock_irq(&pool->lock);
@@@ -4990,9 -5013,10 +4990,10 @@@ int workqueue_set_unbound_cpumask(cpuma
   *
   * Unbound workqueues have the following extra attributes.
   *
-  *  id                RO int  : the associated pool ID
+  *  pool_ids  RO int  : the associated pool IDs for each node
   *  nice      RW int  : nice value of the workers
   *  cpumask   RW mask : bitmask of allowed CPUs for the workers
+  *  numa      RW bool : whether enable NUMA affinity
   */
  struct wq_device {
        struct workqueue_struct         *wq;
@@@ -5367,8 -5391,11 +5368,8 @@@ static void workqueue_sysfs_unregister(
   */
  #ifdef CONFIG_WQ_WATCHDOG
  
 -static void wq_watchdog_timer_fn(unsigned long data);
 -
  static unsigned long wq_watchdog_thresh = 30;
 -static struct timer_list wq_watchdog_timer =
 -      TIMER_DEFERRED_INITIALIZER(wq_watchdog_timer_fn, 0, 0);
 +static struct timer_list wq_watchdog_timer;
  
  static unsigned long wq_watchdog_touched = INITIAL_JIFFIES;
  static DEFINE_PER_CPU(unsigned long, wq_watchdog_touched_cpu) = INITIAL_JIFFIES;
@@@ -5382,7 -5409,7 +5383,7 @@@ static void wq_watchdog_reset_touched(v
                per_cpu(wq_watchdog_touched_cpu, cpu) = jiffies;
  }
  
 -static void wq_watchdog_timer_fn(unsigned long data)
 +static void wq_watchdog_timer_fn(struct timer_list *unused)
  {
        unsigned long thresh = READ_ONCE(wq_watchdog_thresh) * HZ;
        bool lockup_detected = false;
@@@ -5484,7 -5511,6 +5485,7 @@@ module_param_cb(watchdog_thresh, &wq_wa
  
  static void wq_watchdog_init(void)
  {
 +      timer_setup(&wq_watchdog_timer, wq_watchdog_timer_fn, TIMER_DEFERRABLE);
        wq_watchdog_set_thresh(wq_watchdog_thresh);
  }