Merge branch 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull core locking updates from Ingo Molnar:
 "The main changes in this cycle are:

   - Another attempt at enabling cross-release lockdep dependency
     tracking (automatically part of CONFIG_PROVE_LOCKING=y), this time
     with better performance and fewer false positives. (Byungchul Park)

   - Introduce lockdep_assert_irqs_enabled()/disabled() and convert
     open-coded equivalents to lockdep variants. (Frederic Weisbecker)

   - Add down_read_killable() and use it in the VFS's iterate_dir()
     method. (Kirill Tkhai)

   - Convert remaining uses of ACCESS_ONCE() to
     READ_ONCE()/WRITE_ONCE(). Most of the conversion was Coccinelle
     driven. (Mark Rutland, Paul E. McKenney)

   - Get rid of lockless_dereference(), by strengthening Alpha atomics,
     strengthening READ_ONCE() with smp_read_barrier_depends() and thus
     being able to convert users of lockless_dereference() to
     READ_ONCE(). (Will Deacon)

   - Various micro-optimizations:

        - better PV qspinlocks (Waiman Long),
        - better x86 barriers (Michael S. Tsirkin)
        - better x86 refcounts (Kees Cook)

   - ... plus other fixes and enhancements. (Borislav Petkov, Juergen
     Gross, Miguel Bernal Marin)"

* 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (70 commits)
  locking/x86: Use LOCK ADD for smp_mb() instead of MFENCE
  rcu: Use lockdep to assert IRQs are disabled/enabled
  netpoll: Use lockdep to assert IRQs are disabled/enabled
  timers/posix-cpu-timers: Use lockdep to assert IRQs are disabled/enabled
  sched/clock, sched/cputime: Use lockdep to assert IRQs are disabled/enabled
  irq_work: Use lockdep to assert IRQs are disabled/enabled
  irq/timings: Use lockdep to assert IRQs are disabled/enabled
  perf/core: Use lockdep to assert IRQs are disabled/enabled
  x86: Use lockdep to assert IRQs are disabled/enabled
  smp/core: Use lockdep to assert IRQs are disabled/enabled
  timers/hrtimer: Use lockdep to assert IRQs are disabled/enabled
  timers/nohz: Use lockdep to assert IRQs are disabled/enabled
  workqueue: Use lockdep to assert IRQs are disabled/enabled
  irq/softirqs: Use lockdep to assert IRQs are disabled/enabled
  locking/lockdep: Add IRQs disabled/enabled assertion APIs: lockdep_assert_irqs_enabled()/disabled()
  locking/pvqspinlock: Implement hybrid PV queued/unfair locks
  locking/rwlocks: Fix comments
  x86/paravirt: Set up the virt_spin_lock_key after static keys get initialized
  block, locking/lockdep: Assign a lock_class per gendisk used for wait_for_completion()
  workqueue: Remove now redundant lock acquisitions wrt. workqueue flushes
  ...

1 files changed, 6 insertions, 19 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index a2dccfe1acec..13f67b5a0a0c 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -1376,7 +1376,7 @@ static void __queue_work(int cpu, struct workqueue_struct *wq,
          * 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);
 
@@ -2491,15 +2491,8 @@ static void insert_wq_barrier(struct pool_workqueue *pwq,
         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;
 
         /*
@@ -2605,16 +2598,13 @@ void flush_workqueue(struct workqueue_struct *wq)
         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);
 
         /*
@@ -2877,9 +2867,6 @@ bool flush_work(struct work_struct *work)
         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);
@@ -4640,7 +4627,7 @@ static void rebind_workers(struct worker_pool *pool)
                  * 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
@@ -4649,7 +4636,7 @@ static void rebind_workers(struct worker_pool *pool)
                 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);