[PATCH v4 1/2] PCI: Suppress false positive lockdep warning in pci_call_probe()

[Waiman Long <longman@redhat.com>]

local_pci_probe() and hence pci_call_probe() can be called recursively,
e.g. when vmd_probe() calls .probe() for devices in the new hierarchy
below VMD or a PF .probe() enables VFs and calls .probe() for them. If
the recursive calls are done indirectly via workqueue kworker, a lockdep
recursive warning like the following can be produced.

  ============================================
  WARNING: possible recursive locking detected
  7.1.0-rc6-test+ #1 Not tainted
  --------------------------------------------
  kworker/52:1/1593 is trying to acquire lock:
  ffffc9001498f708 ((work_completion)(&arg.work)){+.+.}-{0:0}, at: start_flush_work+0x3e9/0x9a0

  but task is already holding lock:
  ffffc9001498fd10 ((work_completion)(&arg.work)){+.+.}-{0:0}, at: process_one_work+0xd4c/0x1390

  other info that might help us debug this:
   Possible unsafe locking scenario:

         CPU0
         ----
    lock((work_completion)(&arg.work));
    lock((work_completion)(&arg.work));

   *** DEADLOCK ***

This is a false positive warning due to the limitation on the number
of distinct lockdep keys allowed. The same lockdep key is used when the
INIT_WORK_ONSTACK() macro is called in pci_call_probe(). So when a work
function queued by pci_call_probe() calls into pci_call_probe() again
and another work function is queued and flushed, the lockdep warning
will be displayed. This can be suppressed by registering a dynamic key
and used it whenever the current task is a wq kworker.

Dynamic lockdep keys are limited finite resources and they should be
used only when really necessary.

Signed-off-by: Waiman Long <longman@redhat.com>
---
 drivers/pci/pci-driver.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index e3f59001785a..bc8c0f061072 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -394,8 +394,21 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 		error = local_pci_probe(&ddi);
 	} else {
 		struct pci_probe_arg arg = { .ddi = &ddi };
+		struct lock_class_key key;
+
+		/*
+		 * A nested pci_call_probe() via a work func will produce a
+		 * false positive lockdep recursive locking warning. Use
+		 * lockdep_register_key() to provision a dynamic key to
+		 * suppress this warning when the current task is a wq kworker.
+		 */
+		if (current->flags & PF_WQ_WORKER) {
+			lockdep_register_key(&key);
+			INIT_WORK_ONSTACK_KEY(&arg.work, local_pci_probe_callback, &key);
+		} else {
+			INIT_WORK_ONSTACK(&arg.work, local_pci_probe_callback);
+		}
 
-		INIT_WORK_ONSTACK(&arg.work, local_pci_probe_callback);
 		/*
 		 * The target election and the enqueue of the work must be within
 		 * the same RCU read side section so that when the workqueue pool
@@ -422,6 +435,8 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 		}
 
 		destroy_work_on_stack(&arg.work);
+		if (current->flags & PF_WQ_WORKER)
+			lockdep_unregister_key(&key);
 	}
 
 	dev->is_probed = 0;
-- 
2.54.0