Files
kernel_samsung_a71/include/linux
Igor Pylypiv 2e5ed753c9 Revert "module, async: async_synchronize_full() on module init iff async is used"
[ Upstream commit 67d6212afda218d564890d1674bab28e8612170f ]

This reverts commit 774a1221e8.

We need to finish all async code before the module init sequence is
done.  In the reverted commit the PF_USED_ASYNC flag was added to mark a
thread that called async_schedule().  Then the PF_USED_ASYNC flag was
used to determine whether or not async_synchronize_full() needs to be
invoked.  This works when modprobe thread is calling async_schedule(),
but it does not work if module dispatches init code to a worker thread
which then calls async_schedule().

For example, PCI driver probing is invoked from a worker thread based on
a node where device is attached:

	if (cpu < nr_cpu_ids)
		error = work_on_cpu(cpu, local_pci_probe, &ddi);
	else
		error = local_pci_probe(&ddi);

We end up in a situation where a worker thread gets the PF_USED_ASYNC
flag set instead of the modprobe thread.  As a result,
async_synchronize_full() is not invoked and modprobe completes without
waiting for the async code to finish.

The issue was discovered while loading the pm80xx driver:
(scsi_mod.scan=async)

modprobe pm80xx                      worker
...
  do_init_module()
  ...
    pci_call_probe()
      work_on_cpu(local_pci_probe)
                                     local_pci_probe()
                                       pm8001_pci_probe()
                                         scsi_scan_host()
                                           async_schedule()
                                           worker->flags |= PF_USED_ASYNC;
                                     ...
      < return from worker >
  ...
  if (current->flags & PF_USED_ASYNC) <--- false
  	async_synchronize_full();

Commit 21c3c5d280 ("block: don't request module during elevator init")
fixed the deadlock issue which the reverted commit 774a1221e8
("module, async: async_synchronize_full() on module init iff async is
used") tried to fix.

Since commit 0fdff3ec6d ("async, kmod: warn on synchronous
request_module() from async workers") synchronous module loading from
async is not allowed.

Given that the original deadlock issue is fixed and it is no longer
allowed to call synchronous request_module() from async we can remove
PF_USED_ASYNC flag to make module init consistently invoke
async_synchronize_full() unless async module probe is requested.

Signed-off-by: Igor Pylypiv <ipylypiv@google.com>
Reviewed-by: Changyuan Lyu <changyuanl@google.com>
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>
2022-02-23 11:57:33 +01:00
..
2018-02-22 15:42:23 +01:00
2017-08-30 14:40:40 +02:00
2018-08-03 07:50:38 +02:00
2017-08-24 13:23:03 -07:00
2017-08-03 19:09:26 -07:00
2019-11-24 08:22:48 +01:00
2017-08-07 17:22:14 +02:00
2021-12-08 08:46:55 +01:00
2021-12-08 08:46:55 +01:00
2020-04-02 16:34:21 +02:00
2018-02-22 15:42:24 +01:00
2019-12-17 20:38:50 +01:00
2021-03-03 18:22:46 +01:00
2021-02-07 14:47:41 +01:00
2021-11-26 11:40:20 +01:00
2017-08-28 20:51:22 +02:00
2017-09-07 11:53:11 +02:00
2019-12-31 12:37:21 +01:00
2021-07-11 12:48:09 +02:00
2020-07-29 07:42:55 +02:00
2018-02-22 15:42:23 +01:00
2017-09-25 08:56:05 -06:00
2020-11-18 18:28:00 +01:00
2020-03-20 10:54:12 +01:00
2017-08-06 20:55:29 -07:00
2019-06-11 12:21:48 +02:00
2020-04-02 16:34:36 +02:00
2017-08-16 16:28:47 -07:00
2018-11-13 11:15:11 -08:00
2020-12-11 13:39:04 +01:00
2020-04-02 16:34:36 +02:00
2017-08-31 18:50:14 +02:00
2021-12-14 10:16:55 +01:00
2017-08-15 09:02:07 -07:00
2017-08-15 09:02:08 -07:00