Merge tag 'pci-v4.14-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaa...

[sfrench/cifs-2.6.git] / kernel / locking / lockdep.c

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index 1114dc42c27fbaa4a81c1059015321c8cb28b064..44c8d0d17170af808ab0f11c4e556d49044a6c78 100644 (file)
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -4624,8 +4624,7 @@ asmlinkage __visible void lockdep_sys_exit(void)
         * The lock history for each syscall should be independent. So wipe the
         * slate clean on return to userspace.
         */
-       crossrelease_hist_end(XHLOCK_PROC);
-       crossrelease_hist_start(XHLOCK_PROC);
+       lockdep_invariant_state(false);
 }
 
 void lockdep_rcu_suspicious(const char *file, const int line, const char *s)
@@ -4719,43 +4718,26 @@ static inline void invalidate_xhlock(struct hist_lock *xhlock)
 }
 
 /*
- * Lock history stacks; we have 3 nested lock history stacks:
+ * Lock history stacks; we have 2 nested lock history stacks:
  *
- *   Hard IRQ
- *   Soft IRQ
- *   History / Task
+ *   HARD(IRQ)
+ *   SOFT(IRQ)
  *
- * The thing is that once we complete a (Hard/Soft) IRQ the future task locks
- * should not depend on any of the locks observed while running the IRQ.
- *
- * So what we do is rewind the history buffer and erase all our knowledge of
- * that temporal event.
+ * The thing is that once we complete a HARD/SOFT IRQ the future task locks
+ * should not depend on any of the locks observed while running the IRQ.  So
+ * what we do is rewind the history buffer and erase all our knowledge of that
+ * temporal event.
  */
 
-/*
- * We need this to annotate lock history boundaries. Take for instance
- * workqueues; each work is independent of the last. The completion of a future
- * work does not depend on the completion of a past work (in general).
- * Therefore we must not carry that (lock) dependency across works.
- *
- * This is true for many things; pretty much all kthreads fall into this
- * pattern, where they have an 'idle' state and future completions do not
- * depend on past completions. Its just that since they all have the 'same'
- * form -- the kthread does the same over and over -- it doesn't typically
- * matter.
- *
- * The same is true for system-calls, once a system call is completed (we've
- * returned to userspace) the next system call does not depend on the lock
- * history of the previous system call.
- */
 void crossrelease_hist_start(enum xhlock_context_t c)
 {
        struct task_struct *cur = current;
 
-       if (cur->xhlocks) {
-               cur->xhlock_idx_hist[c] = cur->xhlock_idx;
-               cur->hist_id_save[c] = cur->hist_id;
-       }
+       if (!cur->xhlocks)
+               return;
+
+       cur->xhlock_idx_hist[c] = cur->xhlock_idx;
+       cur->hist_id_save[c]    = cur->hist_id;
 }
 
 void crossrelease_hist_end(enum xhlock_context_t c)
@@ -4774,6 +4756,41 @@ void crossrelease_hist_end(enum xhlock_context_t c)
        }
 }
 
+/*
+ * lockdep_invariant_state() is used to annotate independence inside a task, to
+ * make one task look like multiple independent 'tasks'.
+ *
+ * Take for instance workqueues; each work is independent of the last. The
+ * completion of a future work does not depend on the completion of a past work
+ * (in general). Therefore we must not carry that (lock) dependency across
+ * works.
+ *
+ * This is true for many things; pretty much all kthreads fall into this
+ * pattern, where they have an invariant state and future completions do not
+ * depend on past completions. Its just that since they all have the 'same'
+ * form -- the kthread does the same over and over -- it doesn't typically
+ * matter.
+ *
+ * The same is true for system-calls, once a system call is completed (we've
+ * returned to userspace) the next system call does not depend on the lock
+ * history of the previous system call.
+ *
+ * They key property for independence, this invariant state, is that it must be
+ * a point where we hold no locks and have no history. Because if we were to
+ * hold locks, the restore at _end() would not necessarily recover it's history
+ * entry. Similarly, independence per-definition means it does not depend on
+ * prior state.
+ */
+void lockdep_invariant_state(bool force)
+{
+       /*
+        * We call this at an invariant point, no current state, no history.
+        * Verify the former, enforce the latter.
+        */
+       WARN_ON_ONCE(!force && current->lockdep_depth);
+       invalidate_xhlock(&xhlock(current->xhlock_idx));
+}
+
 static int cross_lock(struct lockdep_map *lock)
 {
        return lock ? lock->cross : 0;
@@ -4849,7 +4866,7 @@ static void add_xhlock(struct held_lock *hlock)
 
        /* Initialize hist_lock's members */
        xhlock->hlock = *hlock;
-       xhlock->hist_id = current->hist_id++;
+       xhlock->hist_id = ++current->hist_id;
 
        xhlock->trace.nr_entries = 0;
        xhlock->trace.max_entries = MAX_XHLOCK_TRACE_ENTRIES;
@@ -5025,12 +5042,12 @@ static void commit_xhlocks(struct cross_lock *xlock)
                                break;
 
                        /*
-                        * Filter out the cases that the ring buffer was
-                        * overwritten and the previous entry has a bigger
-                        * hist_id than the following one, which is impossible
-                        * otherwise.
+                        * Filter out the cases where the ring buffer was
+                        * overwritten and the current entry has a bigger
+                        * hist_id than the previous one, which is impossible
+                        * otherwise:
                         */
-                       if (unlikely(before(xhlock->hist_id, prev_hist_id)))
+                       if (unlikely(before(prev_hist_id, xhlock->hist_id)))
                                break;
 
                        prev_hist_id = xhlock->hist_id;