From: Saravana Kannan <saravanak@google.com> To: Greg Kroah-Hartman <gregkh@linuxfoundation.org>, "Rafael J. Wysocki" <rafael@kernel.org>, Kevin Hilman <khilman@kernel.org>, Ulf Hansson <ulf.hansson@linaro.org>, Len Brown <len.brown@intel.com>, Pavel Machek <pavel@ucw.cz>, Joerg Roedel <joro@8bytes.org>, Will Deacon <will@kernel.org>, Andrew Lunn <andrew@lunn.ch>, Heiner Kallweit <hkallweit1@gmail.com>, Russell King <linux@armlinux.org.uk>, "David S. Miller" <davem@davemloft.net>, Eric Dumazet <edumazet@google.com>, Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>, Linus Walleij <linus.walleij@linaro.org>, Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>, David Ahern <dsahern@kernel.org> Cc: Saravana Kannan <saravanak@google.com>, kernel-team@android.com, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, iommu@lists.linux-foundation.org, netdev@vger.kernel.org, linux-gpio@vger.kernel.org Subject: [PATCH v2 4/9] driver core: Add wait_for_init_devices_probe helper function Date: Wed, 1 Jun 2022 00:07:00 -0700 [thread overview] Message-ID: <20220601070707.3946847-5-saravanak@google.com> (raw) In-Reply-To: <20220601070707.3946847-1-saravanak@google.com> Some devices might need to be probed and bound successfully before the kernel boot sequence can finish and move on to init/userspace. For example, a network interface might need to be bound to be able to mount a NFS rootfs. With fw_devlink=on by default, some of these devices might be blocked from probing because they are waiting on a optional supplier that doesn't have a driver. While fw_devlink will eventually identify such devices and unblock the probing automatically, it might be too late by the time it unblocks the probing of devices. For example, the IP4 autoconfig might timeout before fw_devlink unblocks probing of the network interface. This function is available to temporarily try and probe all devices that have a driver even if some of their suppliers haven't been added or don't have drivers. The drivers can then decide which of the suppliers are optional vs mandatory and probe the device if possible. By the time this function returns, all such "best effort" probes are guaranteed to be completed. If a device successfully probes in this mode, we delete all fw_devlink discovered dependencies of that device where the supplier hasn't yet probed successfully because they have to be optional dependencies. This also means that some devices that aren't needed for init and could have waited for their optional supplier to probe (when the supplier's module is loaded later on) would end up probing prematurely with limited functionality. So call this function only when boot would fail without it. Signed-off-by: Saravana Kannan <saravanak@google.com> --- drivers/base/base.h | 1 + drivers/base/core.c | 100 ++++++++++++++++++++++++++++++++-- drivers/base/dd.c | 19 +++++-- include/linux/device/driver.h | 1 + 4 files changed, 110 insertions(+), 11 deletions(-) diff --git a/drivers/base/base.h b/drivers/base/base.h index ab71403d102f..b3a43a164dcd 100644 --- a/drivers/base/base.h +++ b/drivers/base/base.h @@ -160,6 +160,7 @@ extern int devres_release_all(struct device *dev); extern void device_block_probing(void); extern void device_unblock_probing(void); extern void deferred_probe_extend_timeout(void); +extern void driver_deferred_probe_trigger(void); /* /sys/devices directory */ extern struct kset *devices_kset; diff --git a/drivers/base/core.c b/drivers/base/core.c index 7cd789c4985d..61fdfe99b348 100644 --- a/drivers/base/core.c +++ b/drivers/base/core.c @@ -54,6 +54,7 @@ static unsigned int defer_sync_state_count = 1; static DEFINE_MUTEX(fwnode_link_lock); static bool fw_devlink_is_permissive(void); static bool fw_devlink_drv_reg_done; +static bool fw_devlink_best_effort; /** * fwnode_link_add - Create a link between two fwnode_handles. @@ -965,6 +966,11 @@ static void device_links_missing_supplier(struct device *dev) } } +static bool dev_is_best_effort(struct device *dev) +{ + return fw_devlink_best_effort && dev->can_match; +} + /** * device_links_check_suppliers - Check presence of supplier drivers. * @dev: Consumer device. @@ -984,7 +990,7 @@ static void device_links_missing_supplier(struct device *dev) int device_links_check_suppliers(struct device *dev) { struct device_link *link; - int ret = 0; + int ret = 0, fwnode_ret = 0; struct fwnode_handle *sup_fw; /* @@ -997,12 +1003,17 @@ int device_links_check_suppliers(struct device *dev) sup_fw = list_first_entry(&dev->fwnode->suppliers, struct fwnode_link, c_hook)->supplier; - dev_err_probe(dev, -EPROBE_DEFER, "wait for supplier %pfwP\n", - sup_fw); - mutex_unlock(&fwnode_link_lock); - return -EPROBE_DEFER; + if (!dev_is_best_effort(dev)) { + fwnode_ret = -EPROBE_DEFER; + dev_err_probe(dev, -EPROBE_DEFER, + "wait for supplier %pfwP\n", sup_fw); + } else { + fwnode_ret = -EAGAIN; + } } mutex_unlock(&fwnode_link_lock); + if (fwnode_ret == -EPROBE_DEFER) + return fwnode_ret; device_links_write_lock(); @@ -1012,6 +1023,14 @@ int device_links_check_suppliers(struct device *dev) if (link->status != DL_STATE_AVAILABLE && !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { + + if (dev_is_best_effort(dev) && + link->flags & DL_FLAG_INFERRED && + !link->supplier->can_match) { + ret = -EAGAIN; + continue; + } + device_links_missing_supplier(dev); dev_err_probe(dev, -EPROBE_DEFER, "supplier %s not ready\n", @@ -1024,7 +1043,8 @@ int device_links_check_suppliers(struct device *dev) dev->links.status = DL_DEV_PROBING; device_links_write_unlock(); - return ret; + + return ret ? ret : fwnode_ret; } /** @@ -1289,6 +1309,18 @@ void device_links_driver_bound(struct device *dev) * save to drop the managed link completely. */ device_link_drop_managed(link); + } else if (dev_is_best_effort(dev) && + link->flags & DL_FLAG_INFERRED && + link->status != DL_STATE_CONSUMER_PROBE && + !link->supplier->can_match) { + /* + * When dev_is_best_effort() is true, we ignore device + * links to suppliers that don't have a driver. If the + * consumer device still managed to probe, there's no + * point in maintaining a device link in a weird state + * (consumer probed before supplier). So delete it. + */ + device_link_drop_managed(link); } else { WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); WRITE_ONCE(link->status, DL_STATE_ACTIVE); @@ -1655,6 +1687,62 @@ void fw_devlink_drivers_done(void) device_links_write_unlock(); } +/** + * wait_for_init_devices_probe - Try to probe any device needed for init + * + * Some devices might need to be probed and bound successfully before the kernel + * boot sequence can finish and move on to init/userspace. For example, a + * network interface might need to be bound to be able to mount a NFS rootfs. + * + * With fw_devlink=on by default, some of these devices might be blocked from + * probing because they are waiting on a optional supplier that doesn't have a + * driver. While fw_devlink will eventually identify such devices and unblock + * the probing automatically, it might be too late by the time it unblocks the + * probing of devices. For example, the IP4 autoconfig might timeout before + * fw_devlink unblocks probing of the network interface. + * + * This function is available to temporarily try and probe all devices that have + * a driver even if some of their suppliers haven't been added or don't have + * drivers. + * + * The drivers can then decide which of the suppliers are optional vs mandatory + * and probe the device if possible. By the time this function returns, all such + * "best effort" probes are guaranteed to be completed. If a device successfully + * probes in this mode, we delete all fw_devlink discovered dependencies of that + * device where the supplier hasn't yet probed successfully because they have to + * be optional dependencies. + * + * Any devices that didn't successfully probe go back to being treated as if + * this function was never called. + * + * This also means that some devices that aren't needed for init and could have + * waited for their optional supplier to probe (when the supplier's module is + * loaded later on) would end up probing prematurely with limited functionality. + * So call this function only when boot would fail without it. + */ +void __init wait_for_init_devices_probe(void) +{ + if (!fw_devlink_flags || fw_devlink_is_permissive()) + return; + + /* + * Wait for all ongoing probes to finish so that the "best effort" is + * only applied to devices that can't probe otherwise. + */ + wait_for_device_probe(); + + pr_info("Trying to probe devices needed for running init ...\n"); + fw_devlink_best_effort = true; + driver_deferred_probe_trigger(); + + /* + * Wait for all "best effort" probes to finish before going back to + * normal enforcement. + */ + wait_for_device_probe(); + fw_devlink_best_effort = false; +} + static void fw_devlink_unblock_consumers(struct device *dev) { struct device_link *link; diff --git a/drivers/base/dd.c b/drivers/base/dd.c index 11b0fb6414d3..4a55fbb7e0da 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -172,7 +172,7 @@ static bool driver_deferred_probe_enable; * changes in the midst of a probe, then deferred processing should be triggered * again. */ -static void driver_deferred_probe_trigger(void) +void driver_deferred_probe_trigger(void) { if (!driver_deferred_probe_enable) return; @@ -580,7 +580,7 @@ static int really_probe(struct device *dev, struct device_driver *drv) { bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && !drv->suppress_bind_attrs; - int ret; + int ret, link_ret; if (defer_all_probes) { /* @@ -592,9 +592,9 @@ static int really_probe(struct device *dev, struct device_driver *drv) return -EPROBE_DEFER; } - ret = device_links_check_suppliers(dev); - if (ret) - return ret; + link_ret = device_links_check_suppliers(dev); + if (link_ret == -EPROBE_DEFER) + return link_ret; pr_debug("bus: '%s': %s: probing driver %s with device %s\n", drv->bus->name, __func__, drv->name, dev_name(dev)); @@ -633,6 +633,15 @@ static int really_probe(struct device *dev, struct device_driver *drv) ret = call_driver_probe(dev, drv); if (ret) { + /* + * If fw_devlink_best_effort is active (denoted by -EAGAIN), the + * device might actually probe properly once some of its missing + * suppliers have probed. So, treat this as if the driver + * returned -EPROBE_DEFER. + */ + if (link_ret == -EAGAIN) + ret = -EPROBE_DEFER; + /* * Return probe errors as positive values so that the callers * can distinguish them from other errors. diff --git a/include/linux/device/driver.h b/include/linux/device/driver.h index 700453017e1c..2114d65b862f 100644 --- a/include/linux/device/driver.h +++ b/include/linux/device/driver.h @@ -129,6 +129,7 @@ extern struct device_driver *driver_find(const char *name, struct bus_type *bus); extern int driver_probe_done(void); extern void wait_for_device_probe(void); +void __init wait_for_init_devices_probe(void); /* sysfs interface for exporting driver attributes */ -- 2.36.1.255.ge46751e96f-goog
WARNING: multiple messages have this Message-ID (diff)
From: Saravana Kannan via iommu <iommu@lists.linux-foundation.org> To: Greg Kroah-Hartman <gregkh@linuxfoundation.org>, "Rafael J. Wysocki" <rafael@kernel.org>, Kevin Hilman <khilman@kernel.org>, Ulf Hansson <ulf.hansson@linaro.org>, Len Brown <len.brown@intel.com>, Pavel Machek <pavel@ucw.cz>, Joerg Roedel <joro@8bytes.org>, Will Deacon <will@kernel.org>, Andrew Lunn <andrew@lunn.ch>, Heiner Kallweit <hkallweit1@gmail.com>, Russell King <linux@armlinux.org.uk>, "David S. Miller" <davem@davemloft.net>, Eric Dumazet <edumazet@google.com>, Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>, Linus Walleij <linus.walleij@linaro.org>, Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>, David Ahern <dsahern@kernel.org> Cc: Saravana Kannan <saravanak@google.com>, linux-pm@vger.kernel.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, iommu@lists.linux-foundation.org, kernel-team@android.com Subject: [PATCH v2 4/9] driver core: Add wait_for_init_devices_probe helper function Date: Wed, 1 Jun 2022 00:07:00 -0700 [thread overview] Message-ID: <20220601070707.3946847-5-saravanak@google.com> (raw) In-Reply-To: <20220601070707.3946847-1-saravanak@google.com> Some devices might need to be probed and bound successfully before the kernel boot sequence can finish and move on to init/userspace. For example, a network interface might need to be bound to be able to mount a NFS rootfs. With fw_devlink=on by default, some of these devices might be blocked from probing because they are waiting on a optional supplier that doesn't have a driver. While fw_devlink will eventually identify such devices and unblock the probing automatically, it might be too late by the time it unblocks the probing of devices. For example, the IP4 autoconfig might timeout before fw_devlink unblocks probing of the network interface. This function is available to temporarily try and probe all devices that have a driver even if some of their suppliers haven't been added or don't have drivers. The drivers can then decide which of the suppliers are optional vs mandatory and probe the device if possible. By the time this function returns, all such "best effort" probes are guaranteed to be completed. If a device successfully probes in this mode, we delete all fw_devlink discovered dependencies of that device where the supplier hasn't yet probed successfully because they have to be optional dependencies. This also means that some devices that aren't needed for init and could have waited for their optional supplier to probe (when the supplier's module is loaded later on) would end up probing prematurely with limited functionality. So call this function only when boot would fail without it. Signed-off-by: Saravana Kannan <saravanak@google.com> --- drivers/base/base.h | 1 + drivers/base/core.c | 100 ++++++++++++++++++++++++++++++++-- drivers/base/dd.c | 19 +++++-- include/linux/device/driver.h | 1 + 4 files changed, 110 insertions(+), 11 deletions(-) diff --git a/drivers/base/base.h b/drivers/base/base.h index ab71403d102f..b3a43a164dcd 100644 --- a/drivers/base/base.h +++ b/drivers/base/base.h @@ -160,6 +160,7 @@ extern int devres_release_all(struct device *dev); extern void device_block_probing(void); extern void device_unblock_probing(void); extern void deferred_probe_extend_timeout(void); +extern void driver_deferred_probe_trigger(void); /* /sys/devices directory */ extern struct kset *devices_kset; diff --git a/drivers/base/core.c b/drivers/base/core.c index 7cd789c4985d..61fdfe99b348 100644 --- a/drivers/base/core.c +++ b/drivers/base/core.c @@ -54,6 +54,7 @@ static unsigned int defer_sync_state_count = 1; static DEFINE_MUTEX(fwnode_link_lock); static bool fw_devlink_is_permissive(void); static bool fw_devlink_drv_reg_done; +static bool fw_devlink_best_effort; /** * fwnode_link_add - Create a link between two fwnode_handles. @@ -965,6 +966,11 @@ static void device_links_missing_supplier(struct device *dev) } } +static bool dev_is_best_effort(struct device *dev) +{ + return fw_devlink_best_effort && dev->can_match; +} + /** * device_links_check_suppliers - Check presence of supplier drivers. * @dev: Consumer device. @@ -984,7 +990,7 @@ static void device_links_missing_supplier(struct device *dev) int device_links_check_suppliers(struct device *dev) { struct device_link *link; - int ret = 0; + int ret = 0, fwnode_ret = 0; struct fwnode_handle *sup_fw; /* @@ -997,12 +1003,17 @@ int device_links_check_suppliers(struct device *dev) sup_fw = list_first_entry(&dev->fwnode->suppliers, struct fwnode_link, c_hook)->supplier; - dev_err_probe(dev, -EPROBE_DEFER, "wait for supplier %pfwP\n", - sup_fw); - mutex_unlock(&fwnode_link_lock); - return -EPROBE_DEFER; + if (!dev_is_best_effort(dev)) { + fwnode_ret = -EPROBE_DEFER; + dev_err_probe(dev, -EPROBE_DEFER, + "wait for supplier %pfwP\n", sup_fw); + } else { + fwnode_ret = -EAGAIN; + } } mutex_unlock(&fwnode_link_lock); + if (fwnode_ret == -EPROBE_DEFER) + return fwnode_ret; device_links_write_lock(); @@ -1012,6 +1023,14 @@ int device_links_check_suppliers(struct device *dev) if (link->status != DL_STATE_AVAILABLE && !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { + + if (dev_is_best_effort(dev) && + link->flags & DL_FLAG_INFERRED && + !link->supplier->can_match) { + ret = -EAGAIN; + continue; + } + device_links_missing_supplier(dev); dev_err_probe(dev, -EPROBE_DEFER, "supplier %s not ready\n", @@ -1024,7 +1043,8 @@ int device_links_check_suppliers(struct device *dev) dev->links.status = DL_DEV_PROBING; device_links_write_unlock(); - return ret; + + return ret ? ret : fwnode_ret; } /** @@ -1289,6 +1309,18 @@ void device_links_driver_bound(struct device *dev) * save to drop the managed link completely. */ device_link_drop_managed(link); + } else if (dev_is_best_effort(dev) && + link->flags & DL_FLAG_INFERRED && + link->status != DL_STATE_CONSUMER_PROBE && + !link->supplier->can_match) { + /* + * When dev_is_best_effort() is true, we ignore device + * links to suppliers that don't have a driver. If the + * consumer device still managed to probe, there's no + * point in maintaining a device link in a weird state + * (consumer probed before supplier). So delete it. + */ + device_link_drop_managed(link); } else { WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); WRITE_ONCE(link->status, DL_STATE_ACTIVE); @@ -1655,6 +1687,62 @@ void fw_devlink_drivers_done(void) device_links_write_unlock(); } +/** + * wait_for_init_devices_probe - Try to probe any device needed for init + * + * Some devices might need to be probed and bound successfully before the kernel + * boot sequence can finish and move on to init/userspace. For example, a + * network interface might need to be bound to be able to mount a NFS rootfs. + * + * With fw_devlink=on by default, some of these devices might be blocked from + * probing because they are waiting on a optional supplier that doesn't have a + * driver. While fw_devlink will eventually identify such devices and unblock + * the probing automatically, it might be too late by the time it unblocks the + * probing of devices. For example, the IP4 autoconfig might timeout before + * fw_devlink unblocks probing of the network interface. + * + * This function is available to temporarily try and probe all devices that have + * a driver even if some of their suppliers haven't been added or don't have + * drivers. + * + * The drivers can then decide which of the suppliers are optional vs mandatory + * and probe the device if possible. By the time this function returns, all such + * "best effort" probes are guaranteed to be completed. If a device successfully + * probes in this mode, we delete all fw_devlink discovered dependencies of that + * device where the supplier hasn't yet probed successfully because they have to + * be optional dependencies. + * + * Any devices that didn't successfully probe go back to being treated as if + * this function was never called. + * + * This also means that some devices that aren't needed for init and could have + * waited for their optional supplier to probe (when the supplier's module is + * loaded later on) would end up probing prematurely with limited functionality. + * So call this function only when boot would fail without it. + */ +void __init wait_for_init_devices_probe(void) +{ + if (!fw_devlink_flags || fw_devlink_is_permissive()) + return; + + /* + * Wait for all ongoing probes to finish so that the "best effort" is + * only applied to devices that can't probe otherwise. + */ + wait_for_device_probe(); + + pr_info("Trying to probe devices needed for running init ...\n"); + fw_devlink_best_effort = true; + driver_deferred_probe_trigger(); + + /* + * Wait for all "best effort" probes to finish before going back to + * normal enforcement. + */ + wait_for_device_probe(); + fw_devlink_best_effort = false; +} + static void fw_devlink_unblock_consumers(struct device *dev) { struct device_link *link; diff --git a/drivers/base/dd.c b/drivers/base/dd.c index 11b0fb6414d3..4a55fbb7e0da 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -172,7 +172,7 @@ static bool driver_deferred_probe_enable; * changes in the midst of a probe, then deferred processing should be triggered * again. */ -static void driver_deferred_probe_trigger(void) +void driver_deferred_probe_trigger(void) { if (!driver_deferred_probe_enable) return; @@ -580,7 +580,7 @@ static int really_probe(struct device *dev, struct device_driver *drv) { bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && !drv->suppress_bind_attrs; - int ret; + int ret, link_ret; if (defer_all_probes) { /* @@ -592,9 +592,9 @@ static int really_probe(struct device *dev, struct device_driver *drv) return -EPROBE_DEFER; } - ret = device_links_check_suppliers(dev); - if (ret) - return ret; + link_ret = device_links_check_suppliers(dev); + if (link_ret == -EPROBE_DEFER) + return link_ret; pr_debug("bus: '%s': %s: probing driver %s with device %s\n", drv->bus->name, __func__, drv->name, dev_name(dev)); @@ -633,6 +633,15 @@ static int really_probe(struct device *dev, struct device_driver *drv) ret = call_driver_probe(dev, drv); if (ret) { + /* + * If fw_devlink_best_effort is active (denoted by -EAGAIN), the + * device might actually probe properly once some of its missing + * suppliers have probed. So, treat this as if the driver + * returned -EPROBE_DEFER. + */ + if (link_ret == -EAGAIN) + ret = -EPROBE_DEFER; + /* * Return probe errors as positive values so that the callers * can distinguish them from other errors. diff --git a/include/linux/device/driver.h b/include/linux/device/driver.h index 700453017e1c..2114d65b862f 100644 --- a/include/linux/device/driver.h +++ b/include/linux/device/driver.h @@ -129,6 +129,7 @@ extern struct device_driver *driver_find(const char *name, struct bus_type *bus); extern int driver_probe_done(void); extern void wait_for_device_probe(void); +void __init wait_for_init_devices_probe(void); /* sysfs interface for exporting driver attributes */ -- 2.36.1.255.ge46751e96f-goog _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu
next prev parent reply other threads:[~2022-06-01 7:07 UTC|newest] Thread overview: 127+ messages / expand[flat|nested] mbox.gz Atom feed top 2022-06-01 7:06 [PATCH v2 0/9] deferred_probe_timeout logic clean up Saravana Kannan via iommu 2022-06-01 7:06 ` Saravana Kannan 2022-06-01 7:06 ` [PATCH v2 1/9] PM: domains: Delete usage of driver_deferred_probe_check_state() Saravana Kannan 2022-06-01 7:06 ` Saravana Kannan via iommu 2022-06-09 11:44 ` Ulf Hansson 2022-06-09 11:44 ` Ulf Hansson 2022-06-09 19:29 ` Saravana Kannan 2022-06-09 19:29 ` Saravana Kannan via iommu 2022-06-21 7:28 ` Tony Lindgren 2022-06-21 7:28 ` Tony Lindgren 2022-06-21 19:34 ` Saravana Kannan 2022-06-21 19:34 ` Saravana Kannan via iommu 2022-06-22 4:58 ` Tony Lindgren 2022-06-22 4:58 ` Tony Lindgren 2022-06-22 19:09 ` Saravana Kannan 2022-06-22 19:09 ` Saravana Kannan via iommu 2022-06-23 7:01 ` Tony Lindgren 2022-06-23 7:01 ` Tony Lindgren 2022-06-23 8:21 ` Saravana Kannan 2022-06-23 8:21 ` Saravana Kannan via iommu 2022-06-27 9:10 ` Tony Lindgren 2022-06-27 9:10 ` Tony Lindgren 2022-06-30 23:10 ` Saravana Kannan 2022-06-30 23:10 ` Saravana Kannan via iommu 2022-06-30 23:26 ` Rob Herring 2022-06-30 23:26 ` Rob Herring 2022-06-30 23:30 ` Saravana Kannan 2022-06-30 23:30 ` Saravana Kannan via iommu 2022-07-01 5:33 ` Tony Lindgren 2022-07-01 5:33 ` Tony Lindgren 2022-07-01 6:12 ` Tony Lindgren 2022-07-01 6:12 ` Tony Lindgren 2022-07-01 8:10 ` Saravana Kannan 2022-07-01 8:10 ` Saravana Kannan via iommu 2022-07-01 8:26 ` Saravana Kannan via iommu 2022-07-01 8:26 ` Saravana Kannan 2022-07-01 13:00 ` Tony Lindgren 2022-07-01 13:00 ` Tony Lindgren 2022-07-12 7:12 ` Tony Lindgren 2022-07-13 0:49 ` Saravana Kannan 2022-07-13 8:06 ` Tony Lindgren 2022-07-01 15:08 ` Sudeep Holla 2022-07-01 15:08 ` Sudeep Holla 2022-07-01 19:13 ` Saravana Kannan 2022-07-01 19:13 ` Saravana Kannan via iommu 2022-07-05 8:44 ` Saravana Kannan 2022-07-05 8:44 ` Saravana Kannan via iommu 2022-07-01 7:38 ` Geert Uytterhoeven 2022-07-01 7:38 ` Geert Uytterhoeven 2022-06-23 12:08 ` Alexander Stein 2022-06-23 12:08 ` Alexander Stein 2022-07-01 0:37 ` Saravana Kannan 2022-07-01 0:37 ` Saravana Kannan via iommu 2022-07-01 6:01 ` (EXT) " Alexander Stein 2022-07-01 6:01 ` Alexander Stein 2022-07-01 7:02 ` Saravana Kannan 2022-07-01 7:02 ` Saravana Kannan via iommu 2022-07-04 7:07 ` (EXT) " Alexander Stein 2022-07-04 7:07 ` Alexander Stein 2022-07-05 1:24 ` Saravana Kannan 2022-07-05 1:24 ` Saravana Kannan via iommu 2022-07-06 13:02 ` Re: " Alexander Stein 2022-07-06 13:02 ` Alexander Stein 2022-07-13 0:45 ` Saravana Kannan 2022-07-14 6:41 ` Alexander Stein 2022-07-15 22:08 ` Saravana Kannan 2022-07-01 7:30 ` Geert Uytterhoeven 2022-07-01 7:30 ` Geert Uytterhoeven 2022-06-01 7:06 ` [PATCH v2 2/9] pinctrl: devicetree: " Saravana Kannan 2022-06-01 7:06 ` Saravana Kannan via iommu 2022-06-01 7:06 ` [PATCH v2 3/9] net: mdio: " Saravana Kannan 2022-06-01 7:06 ` Saravana Kannan via iommu 2022-07-05 9:11 ` Geert Uytterhoeven 2022-07-05 9:11 ` Geert Uytterhoeven 2022-07-13 1:40 ` Saravana Kannan 2022-07-13 11:39 ` Geert Uytterhoeven 2022-08-15 8:38 ` Geert Uytterhoeven 2022-06-01 7:07 ` Saravana Kannan [this message] 2022-06-01 7:07 ` [PATCH v2 4/9] driver core: Add wait_for_init_devices_probe helper function Saravana Kannan via iommu 2022-06-01 7:07 ` [PATCH v2 5/9] net: ipconfig: Relax fw_devlink if we need to mount a network rootfs Saravana Kannan 2022-06-01 7:07 ` Saravana Kannan via iommu 2022-06-01 7:07 ` [PATCH v2 6/9] Revert "driver core: Set default deferred_probe_timeout back to 0." Saravana Kannan 2022-06-01 7:07 ` Saravana Kannan via iommu 2022-07-20 17:31 ` Geert Uytterhoeven 2022-07-20 19:01 ` Saravana Kannan 2022-07-21 8:40 ` Geert Uytterhoeven 2022-06-01 7:07 ` [PATCH v2 7/9] driver core: Set fw_devlink.strict=1 by default Saravana Kannan 2022-06-01 7:07 ` Saravana Kannan via iommu 2022-06-22 7:47 ` Sascha Hauer 2022-06-22 7:47 ` Sascha Hauer 2022-06-22 8:44 ` Linus Walleij 2022-06-22 8:44 ` Linus Walleij 2022-06-22 10:52 ` Andy Shevchenko 2022-06-22 10:52 ` Andy Shevchenko 2022-06-22 11:18 ` Sascha Hauer 2022-06-22 11:18 ` Sascha Hauer 2022-06-22 19:40 ` Saravana Kannan via iommu 2022-06-22 19:40 ` Saravana Kannan 2022-06-22 20:35 ` Saravana Kannan 2022-06-22 20:35 ` Saravana Kannan via iommu 2022-06-22 22:30 ` Saravana Kannan 2022-06-22 22:30 ` Saravana Kannan via iommu 2022-06-28 13:09 ` Linus Walleij 2022-06-28 13:09 ` Linus Walleij 2022-06-01 7:07 ` [PATCH v2 8/9] iommu/of: Delete usage of driver_deferred_probe_check_state() Saravana Kannan 2022-06-01 7:07 ` Saravana Kannan via iommu 2022-08-19 14:26 ` Jean-Philippe Brucker 2022-06-01 7:07 ` [PATCH v2 9/9] driver core: Delete driver_deferred_probe_check_state() Saravana Kannan 2022-06-01 7:07 ` Saravana Kannan via iommu 2022-06-07 18:07 ` [PATCH v2 0/9] deferred_probe_timeout logic clean up Geert Uytterhoeven 2022-06-07 18:07 ` Geert Uytterhoeven 2022-06-08 0:55 ` Saravana Kannan via iommu 2022-06-08 0:55 ` Saravana Kannan 2022-06-08 4:17 ` Saravana Kannan via iommu 2022-06-08 4:17 ` Saravana Kannan 2022-06-08 10:25 ` Geert Uytterhoeven 2022-06-08 10:25 ` Geert Uytterhoeven 2022-06-08 18:12 ` Saravana Kannan 2022-06-08 18:12 ` Saravana Kannan via iommu 2022-06-08 18:47 ` Geert Uytterhoeven 2022-06-08 18:47 ` Geert Uytterhoeven 2022-06-08 21:07 ` Saravana Kannan 2022-06-08 21:07 ` Saravana Kannan via iommu 2022-06-08 22:49 ` Jakub Kicinski 2022-06-08 22:49 ` Jakub Kicinski 2022-06-08 23:15 ` Saravana Kannan via iommu 2022-06-08 23:15 ` Saravana Kannan
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20220601070707.3946847-5-saravanak@google.com \ --to=saravanak@google.com \ --cc=andrew@lunn.ch \ --cc=davem@davemloft.net \ --cc=dsahern@kernel.org \ --cc=edumazet@google.com \ --cc=gregkh@linuxfoundation.org \ --cc=hkallweit1@gmail.com \ --cc=iommu@lists.linux-foundation.org \ --cc=joro@8bytes.org \ --cc=kernel-team@android.com \ --cc=khilman@kernel.org \ --cc=kuba@kernel.org \ --cc=len.brown@intel.com \ --cc=linus.walleij@linaro.org \ --cc=linux-gpio@vger.kernel.org \ --cc=linux-kernel@vger.kernel.org \ --cc=linux-pm@vger.kernel.org \ --cc=linux@armlinux.org.uk \ --cc=netdev@vger.kernel.org \ --cc=pabeni@redhat.com \ --cc=pavel@ucw.cz \ --cc=rafael@kernel.org \ --cc=ulf.hansson@linaro.org \ --cc=will@kernel.org \ --cc=yoshfuji@linux-ipv6.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.