firmware_class: Do not warn that system is not ready from async loads (9b78c1da) · Commits · 戴 / test

drivers/base/firmware_class.c

+30 −21

Original line number	Diff line number	Diff line
		@@ -81,6 +81,11 @@ enum {

		static int loading_timeout = 60; /* In seconds */

		static inline long firmware_loading_timeout(void)
		{
		return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
		}

		/* fw_lock could be moved to 'struct firmware_priv' but since it is just
		* guarding for corner cases a global lock should be OK */
		static DEFINE_MUTEX(fw_lock);
		@@ -541,31 +546,22 @@ static void _request_firmware_cleanup(const struct firmware **firmware_p)

		static int _request_firmware(const struct firmware *firmware,
		const char name, struct device device,
		bool uevent, bool nowait)
		bool uevent, bool nowait, long timeout)
		{
		struct firmware_priv *fw_priv;
		int retval;

		retval = usermodehelper_read_trylock();
		if (WARN_ON(retval)) {
		dev_err(device, "firmware: %s will not be loaded\n", name);
		return retval;
		}
		int retval = 0;

		if (uevent)
		dev_dbg(device, "firmware: requesting %s\n", name);

		fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
		if (IS_ERR(fw_priv)) {
		retval = PTR_ERR(fw_priv);
		goto out;
		}
		if (IS_ERR(fw_priv))
		return PTR_ERR(fw_priv);

		if (uevent) {
		if (loading_timeout > 0)
		if (timeout != MAX_SCHEDULE_TIMEOUT)
		mod_timer(&fw_priv->timeout,
		round_jiffies_up(jiffies +
		loading_timeout * HZ));
		round_jiffies_up(jiffies + timeout));

		kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
		}
		@@ -582,9 +578,6 @@ static int _request_firmware(const struct firmware *firmware,
		mutex_unlock(&fw_lock);

		fw_destroy_instance(fw_priv);

		out:
		usermodehelper_read_unlock();
		return retval;
		}

		@@ -613,7 +606,14 @@ request_firmware(const struct firmware *firmware_p, const char name,
		if (ret <= 0)
		return ret;

		ret = _request_firmware(*firmware_p, name, device, true, false);
		ret = usermodehelper_read_trylock();
		if (WARN_ON(ret)) {
		dev_err(device, "firmware: %s will not be loaded\n", name);
		} else {
		ret = _request_firmware(*firmware_p, name, device, true, false,
		firmware_loading_timeout());
		usermodehelper_read_unlock();
		}
		if (ret)
		_request_firmware_cleanup(firmware_p);

		@@ -648,6 +648,7 @@ static int request_firmware_work_func(void *arg)
		{
		struct firmware_work *fw_work = arg;
		const struct firmware *fw;
		long timeout;
		int ret;

		if (!arg) {
		@@ -659,8 +660,16 @@ static int request_firmware_work_func(void *arg)
		if (ret <= 0)
		goto out;

		timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
		if (timeout) {
		ret = _request_firmware(fw, fw_work->name, fw_work->device,
		fw_work->uevent, true);
		fw_work->uevent, true, timeout);
		usermodehelper_read_unlock();
		} else {
		dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
		fw_work->name);
		ret = -EAGAIN;
		}
		if (ret)
		_request_firmware_cleanup(&fw);

include/linux/kmod.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -115,6 +115,7 @@ extern void usermodehelper_init(void);
		extern int usermodehelper_disable(void);
		extern void usermodehelper_enable(void);
		extern int usermodehelper_read_trylock(void);
		extern long usermodehelper_read_lock_wait(long timeout);
		extern void usermodehelper_read_unlock(void);

		#endif /* __LINUX_KMOD_H__ */

kernel/kmod.c

+45 −13

Original line number	Diff line number	Diff line
		@@ -333,6 +333,12 @@ static atomic_t running_helpers = ATOMIC_INIT(0);
		*/
		static DECLARE_WAIT_QUEUE_HEAD(running_helpers_waitq);

		/*
		* Used by usermodehelper_read_lock_wait() to wait for usermodehelper_disabled
		* to become 'false'.
		*/
		static DECLARE_WAIT_QUEUE_HEAD(usermodehelper_disabled_waitq);

		/*
		* Time to wait for running_helpers to become zero before the setting of
		* usermodehelper_disabled in usermodehelper_disable() fails
		@@ -352,12 +358,50 @@ int usermodehelper_read_trylock(void)
		}
		EXPORT_SYMBOL_GPL(usermodehelper_read_trylock);

		long usermodehelper_read_lock_wait(long timeout)
		{
		DEFINE_WAIT(wait);

		if (timeout < 0)
		return -EINVAL;

		down_read(&umhelper_sem);
		for (;;) {
		prepare_to_wait(&usermodehelper_disabled_waitq, &wait,
		TASK_UNINTERRUPTIBLE);
		if (!usermodehelper_disabled)
		break;

		up_read(&umhelper_sem);

		timeout = schedule_timeout(timeout);
		if (!timeout)
		break;

		down_read(&umhelper_sem);
		}
		finish_wait(&usermodehelper_disabled_waitq, &wait);
		return timeout;
		}
		EXPORT_SYMBOL_GPL(usermodehelper_read_lock_wait);

		void usermodehelper_read_unlock(void)
		{
		up_read(&umhelper_sem);
		}
		EXPORT_SYMBOL_GPL(usermodehelper_read_unlock);

		/**
		* usermodehelper_enable - allow new helpers to be started again
		*/
		void usermodehelper_enable(void)
		{
		down_write(&umhelper_sem);
		usermodehelper_disabled = 0;
		wake_up(&usermodehelper_disabled_waitq);
		up_write(&umhelper_sem);
		}

		/**
		* usermodehelper_disable - prevent new helpers from being started
		*/
		@@ -381,22 +425,10 @@ int usermodehelper_disable(void)
		if (retval)
		return 0;

		down_write(&umhelper_sem);
		usermodehelper_disabled = 0;
		up_write(&umhelper_sem);
		usermodehelper_enable();
		return -EAGAIN;
		}

		/**
		* usermodehelper_enable - allow new helpers to be started again
		*/
		void usermodehelper_enable(void)
		{
		down_write(&umhelper_sem);
		usermodehelper_disabled = 0;
		up_write(&umhelper_sem);
		}

		static void helper_lock(void)
		{
		atomic_inc(&running_helpers);

Admin message