Fix device links functional breakage in 4.19.99
Subsystems (7)
cover Fix device links functional breakage in 4.19.99
As mentioned in an earlier email thread [1], 4.19.99 broke the ability to create stateful and stateless device links between the same set of devices when it pulled in a valid bug fix [2]. While the fix was valid, it removes a functionality that was present before the bug fix.
This patch series attempts to fix that by pulling in more patches from upstream. I've just done compilation testing so far. But wanted to send out a v1 to see if this patch list was acceptable before I fixed up the commit text format to match what's needed for stable mailing list.
Some of the patches are new functionality, but for a first pass, it was easier to pull these in than try and fix the conflicts. If these patches are okay to pull into stable, then all I need to do is fix the commit text.
Thanks,
Saravana
[1] - https://lore.kernel.org/stable/CAGETcx-0dKRWo=tTVcfJQhQUsMtX_LtL6yvDkb3CMbvzREsvOQ@mail.gmail.com/#t
[2] - 6fdc440366f1a99f344b629ac92f350aefd77911
Rafael J. Wysocki (5):
driver core: Fix adding device links to probing suppliers driver core: Make driver core own stateful device links driver core: Add device link flag DL_FLAG_AUTOPROBE_CONSUMER driver core: Remove device link creation limitation driver core: Fix creation of device links with PM-runtime flags
Yong Wu (1):
driver core: Remove the link if there is no driver with AUTO flag
Documentation/driver-api/device_link.rst | 63 +++-- drivers/base/core.c | 293 +++++++++++++++++------ drivers/base/dd.c | 2 +- drivers/base/power/runtime.c | 4 +- include/linux/device.h | 7 +- 5 files changed, 265 insertions(+), 104 deletions(-)
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 1/6 driver core: Remove the link if there is no driver with AUTO flag
From: Yong Wu <[email protected]>
DL_FLAG_AUTOREMOVE_CONSUMER/SUPPLIER means "Remove the link automatically on consumer/supplier driver unbind", that means we should remove whole the device_link when there is no this driver no matter what the ref_count of the link is.
--- drivers/base/core.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/base/core.c +2 -2
@@ -546,7 +546,7 @@ static void __device_links_no_driver(struct device *dev)continue ;if (link->flags &DL_FLAG_AUTOREMOVE_CONSUMER ) -kref_put (&link->kref, __device_link_del); +__device_link_del (&link->kref);else if (link->status !=DL_STATE_SUPPLIER_UNBIND )WRITE_ONCE (link->status,DL_STATE_AVAILABLE ); }
@@ -591,7 +591,7 @@ void device_links_driver_cleanup(struct device *dev)*/ if (link->status ==DL_STATE_SUPPLIER_UNBIND && link->flags &DL_FLAG_AUTOREMOVE_SUPPLIER ) -kref_put (&link->kref, __device_link_del); +__device_link_del (&link->kref);WRITE_ONCE (link->status,DL_STATE_DORMANT ); }
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 2/6 driver core: Fix adding device links to probing suppliers
In reply to Saravana KannanFrom: "Rafael J. Wysocki" <[email protected]>
Currently, it is not valid to add a device link from a consumer driver ->probe callback to a supplier that is still probing too, but generally this is a valid use case. For example, if the consumer has just acquired a resource that can only be available if the supplier is functional, adding a device link to that supplier right away should be safe (and even desirable arguably), but device_link_add() doesn't handle that case correctly and the initial state of the link created by it is wrong then.
To address this problem, change the initial state of device links added between a probing supplier and a probing consumer to DL_STATE_CONSUMER_PROBE and update device_links_driver_bound() to skip such links on the supplier side.
With this change, if the supplier probe completes first, device_links_driver_bound() called for it will skip the link state update and when it is called for the consumer, the link state will be updated to "active". In turn, if the consumer probe completes first, device_links_driver_bound() called for it will change the state of the link to "active" and when it is called for the supplier, the link status update will be skipped.
However, in principle the supplier or consumer probe may still fail after the link has been added, so modify device_links_no_driver() to change device links in the "active" or "consumer probe" state to "dormant" on the supplier side and update __device_links_no_driver() to change the link state to "available" only if it is "consumer probe" or "active".
Then, if the supplier probe fails first, the leftover link to the probing consumer will become "dormant" and device_links_no_driver() called for the consumer (when its probe fails) will clean it up. In turn, if the consumer probe fails first, it will either drop the link, or change its state to "available" and, in the latter case, when device_links_no_driver() is called for the supplier, it will update the link state to "dormant". [If the supplier probe fails, but the consumer probe succeeds, which should not happen as long as the consumer driver is correct, the link still will be around, but it will be "dormant" until the supplier is probed again.]
--- Documentation/driver-api/device_link.rst | 10 +++- drivers/base/core.c | 74 +++++++++++++++++++++--- 2 files changed, 73 insertions(+), 11 deletions(-)
Documentation/driver-api/device_link.rst +7 -3
@@ -59,11 +59,15 @@ device ``->probe`` callback or a boot-time PCI quirk. Another example for an inconsistent state would be a device link that represents a driver presence dependency, yet is added from the consumer's -``->probe`` callback while the supplier hasn't probed yet: Had the driver -core known about the device link earlier, it wouldn't have probed the +``->probe`` callback while the supplier hasn't started to probe yet: Had the +driver core known about the device link earlier, it wouldn't have probed the consumer in the first place. The onus is thus on the consumer to check presence of the supplier after adding the link, and defer probing on -non-presence. +non-presence. [Note that it is valid to create a link from the consumer's +``->probe`` callback while the supplier is still probing, but the consumer must +know that the supplier is functional already at the link creation time (that is +the case, for instance, if the consumer has just acquired some resources that +would not have been available had the supplier not been functional then).] If a device link is added in the ``->probe`` callback of the supplier or consumer driver, it is typically deleted in its ``->remove`` callback for
drivers/base/core.c +66 -8
112 lines not on this page · raw message
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 3/6 driver core: Make driver core own stateful device links
In reply to Saravana KannanFrom: "Rafael J. Wysocki" <[email protected]>
Even though stateful device links are managed by the driver core in principle, their creators are allowed and sometimes even expected to drop references to them via device_link_del() or device_link_remove(), but that doesn't really play well with the "persistent" link concept.
If "persistent" managed device links are created from driver probe callbacks, device_link_add() called to do that will take a new reference on the link each time the callback runs and those references will never be dropped, which kind of isn't nice.
This issues arises because of the link reference counting carried out by device_link_add() for existing links, but that is only done to avoid deleting device links that may still be necessary, which shouldn't be a concern for managed (stateful) links. These device links are managed by the driver core and whoever creates one of them will need it at least as long as until the consumer driver is detached from its device and deleting it may be left to the driver core just fine.
For this reason, rework device_link_add() to apply the reference counting to stateless links only and make device_link_del() and device_link_remove() drop references to stateless links only too. After this change, if called to add a stateful device link for a consumer-supplier pair for which a stateful device link is present already, device_link_add() will return the existing link without incrementing its reference counter. Accordingly, device_link_del() and device_link_remove() will WARN() and do nothing when called to drop a reference to a stateful link. Thus, effectively, all stateful device links will be owned by the driver core.
In addition, clean up the handling of the link management flags, DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER, so that
(a) they are never set at the same time and (b) if device_link_add() is called for a consumer-supplier pair with an existing stateful link between them, the flags of that link will be combined with the flags passed to device_link_add() to ensure that the life time of the link is sufficient for all of the callers of device_link_add() for the same consumer-supplier pair.
Update the device_link_add() kerneldoc comment to reflect the above changes.
--- Documentation/driver-api/device_link.rst | 42 +++++++++------ drivers/base/core.c | 69 ++++++++++++++++++------ 2 files changed, 79 insertions(+), 32 deletions(-)
Documentation/driver-api/device_link.rst +25 -17
@@ -25,8 +25,8 @@ suspend/resume and shutdown ordering. Device links allow representation of such dependencies in the driver core. -In its standard form, a device link combines *both* dependency types: -It guarantees correct suspend/resume and shutdown ordering between a +In its standard or *managed* form, a device link combines *both* dependency +types: It guarantees correct suspend/resume and shutdown ordering between a "supplier" device and its "consumer" devices, and it guarantees driver presence on the supplier. The consumer devices are not probed before the supplier is bound to a driver, and they're unbound before the supplier
@@ -69,12 +69,14 @@ know that the supplier is functional already at the link creation time (that is the case, for instance, if the consumer has just acquired some resources that would not have been available had the supplier not been functional then).] -If a device link is added in the ``->probe`` callback of the supplier or -consumer driver, it is typically deleted in its ``->remove`` callback for -symmetry. That way, if the driver is compiled as a module, the device -link is added on module load and orderly deleted on unload. The same -restrictions that apply to device link addition (e.g. exclusion of a -parallel suspend/resume transition) apply equally to deletion. +If a device link with ``DL_FLAG_STATELESS`` set (i.e. a stateless device link) +is added in the ``->probe`` callback of the supplier or consumer driver, it is +typically deleted in its ``->remove`` callback for symmetry. That way, if the +driver is compiled as a module, the device link is added on module load and +orderly deleted on unload. The same restrictions that apply to device link +addition (e.g. exclusion of a parallel suspend/resume transition) apply equally +to deletion. Device links with ``DL_FLAG_STATELESS`` unset (i.e. managed +device links) are deleted automatically by the driver core. Several flags may be specified on device link addition, two of which have already been mentioned above: ``DL_FLAG_STATELESS`` to express that no
@@ -87,8 +89,6 @@ link is added from the consumer's ``->probe`` callback: ``DL_FLAG_RPM_ACTIVE`` can be specified to runtime resume the supplier upon addition of the device link. ``DL_FLAG_AUTOREMOVE_CONSUMER`` causes the device link to be automatically purged when the consumer fails to probe or later unbinds. -This obviates the need to explicitly delete the link in the ``->remove`` -callback or in the error path of the ``->probe`` callback. Similarly, when the device link is added from supplier's ``->probe`` callback, ``DL_FLAG_AUTOREMOVE_SUPPLIER`` causes the device link to be automatically
@@ -97,12 +97,20 @@ purged when the supplier fails to probe or later unbinds. Limitations =========== -Driver authors should be aware that a driver presence dependency (i.e. when -``DL_FLAG_STATELESS`` is not specified on link addition) may cause probing of -the consumer to be deferred indefinitely. This can become a problem if the -consumer is required to probe before a certain initcall level is reached. -Worse, if the supplier driver is blacklisted or missing, the consumer will -never be probed. +Driver authors should be aware that a driver presence dependency for managed +device links (i.e. when ``DL_FLAG_STATELESS`` is not specified on link addition) +may cause probing of the consumer to be deferred indefinitely. This can become +a problem if the consumer is required to probe before a certain initcall level +is reached. Worse, if the supplier driver is blacklisted or missing, the +consumer will never be probed. + +Moreover, managed device links cannot be deleted directly. They are deleted +by the driver core when they are not necessary any more in accordance with the +``DL_FLAG_AUTOREMOVE_CONSUMER`` and ``DL_FLAG_AUTOREMOVE_SUPPLIER`` flags. +However, stateless device links (i.e. device links with ``DL_FLAG_STATELESS`` +set) are expected to be removed by whoever called :c:func:`device_link_add()` +to add them with the help of either :c:func:`device_link_del()` or +:c:func:`device_link_remove()`. Sometimes drivers depend on optional resources. They are able to operate in a degraded mode (reduced feature set or performance) when those resources
@@ -286,4 +294,4 @@ API === .. kernel-doc:: drivers/base/core.c - :functions: device_link_add device_link_del + :functions: device_link_add device_link_del device_link_remove
drivers/base/core.c +54 -15
118 lines not on this page · raw message
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 4/6 driver core: Add device link flag DL_FLAG_AUTOPROBE_CONSUMER
In reply to Saravana KannanFrom: "Rafael J. Wysocki" <[email protected]>
Add a new device link flag, DL_FLAG_AUTOPROBE_CONSUMER, to request the driver core to probe for a consumer driver automatically after binding a driver to the supplier device on a persistent managed device link.
As unbinding the supplier driver on a managed device link causes the consumer driver to be detached from its device automatically, this flag provides a complementary mechanism which is needed to address some "composite device" use cases.
--- Documentation/driver-api/device_link.rst | 9 +++++++++ drivers/base/core.c | 16 +++++++++++++++- drivers/base/dd.c | 2 +- include/linux/device.h | 3 +++ 4 files changed, 28 insertions(+), 2 deletions(-)
Documentation/driver-api/device_link.rst +9 -0
@@ -94,6 +94,15 @@ Similarly, when the device link is added from supplier's ``->probe`` callback, ``DL_FLAG_AUTOREMOVE_SUPPLIER`` causes the device link to be automatically purged when the supplier fails to probe or later unbinds. +If neither ``DL_FLAG_AUTOREMOVE_CONSUMER`` nor ``DL_FLAG_AUTOREMOVE_SUPPLIER`` +is set, ``DL_FLAG_AUTOPROBE_CONSUMER`` can be used to request the driver core +to probe for a driver for the consumer driver on the link automatically after +a driver has been bound to the supplier device. + +Note, however, that any combinations of ``DL_FLAG_AUTOREMOVE_CONSUMER``, +``DL_FLAG_AUTOREMOVE_SUPPLIER`` or ``DL_FLAG_AUTOPROBE_CONSUMER`` with +``DL_FLAG_STATELESS`` are invalid and cannot be used. + Limitations ===========
drivers/base/core.c +15 -1
@@ -195,6 +195,12 @@ void device_pm_move_to_tail(struct device *dev)* the link will be maintained until one of the devices pointed to by it (either * the consumer or the supplier) is unregistered. * +* Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and +* DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent +* managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can +* be used to request the driver core to automaticall probe for a consmer +* driver after successfully binding a driver to the supplier device. +* * The combination of DL_FLAG_STATELESS and either DL_FLAG_AUTOREMOVE_CONSUMER * or DL_FLAG_AUTOREMOVE_SUPPLIER set in @flags at the same time is invalid and * will cause NULL to be returned upfront.
@@ -215,7 +221,12 @@ struct device_link *device_link_add(struct device *consumer,if (!consumer || !supplier || (flags &DL_FLAG_STATELESS && - flags & (DL_FLAG_AUTOREMOVE_CONSUMER |DL_FLAG_AUTOREMOVE_SUPPLIER ))) + flags & (DL_FLAG_AUTOREMOVE_CONSUMER | +DL_FLAG_AUTOREMOVE_SUPPLIER | +DL_FLAG_AUTOPROBE_CONSUMER )) || + (flags &DL_FLAG_AUTOPROBE_CONSUMER && + flags & (DL_FLAG_AUTOREMOVE_CONSUMER | +DL_FLAG_AUTOREMOVE_SUPPLIER )))return NULL ;if (flags &DL_FLAG_PM_RUNTIME && flags &DL_FLAG_RPM_ACTIVE ) {
@@ -576,6 +587,9 @@ void device_links_driver_bound(struct device *dev)WARN_ON (link->status !=DL_STATE_DORMANT );WRITE_ONCE (link->status,DL_STATE_AVAILABLE ); + +if (link->flags &DL_FLAG_AUTOPROBE_CONSUMER ) +driver_deferred_probe_add (link->consumer); }list_for_each_entry (link, &dev->links.suppliers, c_node) {
drivers/base/dd.c +1 -1
@@ -116,7 +116,7 @@ static void deferred_probe_work_func(struct work_struct *work) } static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); -static void driver_deferred_probe_add (struct device *dev) +void driver_deferred_probe_add (struct device *dev) {mutex_lock (&deferred_probe_mutex);if (list_empty (&dev->p->deferred_probe)) {
include/linux/device.h +3 -0
@@ -339,6 +339,7 @@ struct device *driver_find_device(struct device_driver *drv, struct device *start, void *data, int (*match)(struct device *dev, void *data)); +void driver_deferred_probe_add (struct device *dev);int driver_deferred_probe_check_state (struct device *dev);/**
@@ -824,12 +825,14 @@ enum device_link_state {* PM_RUNTIME: If set, the runtime PM framework will use this link. * RPM_ACTIVE: Run pm_runtime_get_sync() on the supplier during link creation. * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind. +* AUTOPROBE_CONSUMER: Probe consumer driver automatically after supplier binds. */ #define DL_FLAG_STATELESS BIT(0)#define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1)#define DL_FLAG_PM_RUNTIME BIT(2)#define DL_FLAG_RPM_ACTIVE BIT(3)#define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4) +#define DL_FLAG_AUTOPROBE_CONSUMER BIT(5)/** * struct device_link - Device link representation.
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 6/6 driver core: Fix creation of device links with PM-runtime flags
In reply to Saravana KannanFrom: "Rafael J. Wysocki" <[email protected]>
After commit 515db266a9da ("driver core: Remove device link creation limitation"), if PM-runtime flags are passed to device_link_add(), it will fail (returning NULL) due to an overly restrictive flags check introduced by that commit.
Fix this issue by extending the check in question to cover the PM-runtime flags too.
--- drivers/base/core.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
drivers/base/core.c +4 -2
@@ -213,6 +213,9 @@ void device_pm_move_to_tail(struct device *dev) DL_FLAG_AUTOREMOVE_SUPPLIER | \ DL_FLAG_AUTOPROBE_CONSUMER) +#define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ + DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) +/** * device_link_add - Create a link between two devices. * @consumer: Consumer end of the link.
@@ -274,8 +277,7 @@ struct device_link *device_link_add(struct device *consumer, { struct device_link *link; - if (!consumer || !supplier || - (flags & ~(DL_FLAG_STATELESS | DL_MANAGED_LINK_FLAGS)) || + if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || (flags & DL_FLAG_AUTOPROBE_CONSUMER && flags & (DL_FLAG_AUTOREMOVE_CONSUMER |
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
PATCH 5/6 driver core: Remove device link creation limitation
In reply to Saravana KannanFrom: "Rafael J. Wysocki" <[email protected]>
If device_link_add() is called for a consumer/supplier pair with an existing device link between them and the existing link's type is not in agreement with the flags passed to that function by its caller, NULL will be returned. That is seriously inconvenient, because it forces the callers of device_link_add() to worry about what others may or may not do even if that is not relevant to them for any other reasons.
It turns out, however, that this limitation can be made go away relatively easily.
The underlying observation is that if DL_FLAG_STATELESS has been passed to device_link_add() in flags for the given consumer/supplier pair at least once, calling either device_link_del() or device_link_remove() to release the link returned by it should work, but there are no other requirements associated with that flag. In turn, if at least one of the callers of device_link_add() for the given consumer/supplier pair has not passed DL_FLAG_STATELESS to it in flags, the driver core should track the status of the link and act on it as appropriate (ie. the link should be treated as "managed"). This means that DL_FLAG_STATELESS needs to be set for managed device links and it should be valid to call device_link_del() or device_link_remove() to drop references to them in certain sutiations.
To allow that to happen, introduce a new (internal) device link flag called DL_FLAG_MANAGED and make device_link_add() set it automatically whenever DL_FLAG_STATELESS is not passed to it. Also make it take additional references to existing device links that were previously stateless (that is, with DL_FLAG_STATELESS set and DL_FLAG_MANAGED unset) and will need to be managed going forward and initialize their status (which has been DL_STATE_NONE so far).
Accordingly, when a managed device link is dropped automatically by the driver core, make it clear DL_FLAG_MANAGED, reset the link's status back to DL_STATE_NONE and drop the reference to it associated with DL_FLAG_MANAGED instead of just deleting it right away (to allow it to stay around in case it still needs to be released explicitly by someone).
With that, since setting DL_FLAG_STATELESS doesn't mean that the device link in question is not managed any more, replace all of the status-tracking checks against DL_FLAG_STATELESS with analogous checks against DL_FLAG_MANAGED and update the documentation to reflect these changes.
While at it, make device_link_add() reject flags that it does not recognize, including DL_FLAG_MANAGED.
--- Documentation/driver-api/device_link.rst | 4 +- drivers/base/core.c | 176 +++++++++++++---------- drivers/base/power/runtime.c | 4 +- include/linux/device.h | 4 +- 4 files changed, 106 insertions(+), 82 deletions(-)
Documentation/driver-api/device_link.rst +2 -2
@@ -75,8 +75,8 @@ typically deleted in its ``->remove`` callback for symmetry. That way, if the driver is compiled as a module, the device link is added on module load and orderly deleted on unload. The same restrictions that apply to device link addition (e.g. exclusion of a parallel suspend/resume transition) apply equally -to deletion. Device links with ``DL_FLAG_STATELESS`` unset (i.e. managed -device links) are deleted automatically by the driver core. +to deletion. Device links managed by the driver core are deleted automatically +by it. Several flags may be specified on device link addition, two of which have already been mentioned above: ``DL_FLAG_STATELESS`` to express that no
drivers/base/core.c +99 -77
342 lines not on this page · raw message
drivers/base/power/runtime.c +2 -2
@@ -1531,7 +1531,7 @@ void pm_runtime_remove(struct device *dev)* runtime PM references to the device, drop the usage counter of the device * (as many times as needed). * -* Links with the DL_FLAG_STATELESS flag set are ignored. +* Links with the DL_FLAG_MANAGED flag unset are ignored. * * Since the device is guaranteed to be runtime-active at the point this is * called, nothing else needs to be done here.
@@ -1548,7 +1548,7 @@ void pm_runtime_clean_up_links(struct device *dev) idx =device_links_read_lock ();list_for_each_entry_rcu (link, &dev->links.consumers, s_node) { -if (link->flags &DL_FLAG_STATELESS ) +if (!(link->flags &DL_FLAG_MANAGED ))continue ;while (refcount_dec_not_one (&link->rpm_active))
include/linux/device.h +3 -1
@@ -820,12 +820,13 @@ enum device_link_state {/* * Device link flags. * -* STATELESS: The core won't track the presence of supplier/consumer drivers. +* STATELESS: The core will not remove this link automatically. * AUTOREMOVE_CONSUMER: Remove the link automatically on consumer driver unbind. * PM_RUNTIME: If set, the runtime PM framework will use this link. * RPM_ACTIVE: Run pm_runtime_get_sync() on the supplier during link creation. * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind. * AUTOPROBE_CONSUMER: Probe consumer driver automatically after supplier binds. +* MANAGED: The core tracks presence of supplier/consumer drivers (internal). */ #define DL_FLAG_STATELESS BIT(0)#define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1)
@@ -833,6 +834,7 @@ enum device_link_state {#define DL_FLAG_RPM_ACTIVE BIT(3)#define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4)#define DL_FLAG_AUTOPROBE_CONSUMER BIT(5) +#define DL_FLAG_MANAGED BIT(6)/** * struct device_link - Device link representation.
Signature · 1 line
2.25.1.481.gfbce0eb801-goog
Quoted 11 lines · Saravana Kannan
As mentioned in an earlier email thread [1], 4.19.99 broke the ability to create stateful and stateless device links between the same set of devices when it pulled in a valid bug fix [2]. While the fix was valid, it removes a functionality that was present before the bug fix.
This patch series attempts to fix that by pulling in more patches from upstream. I've just done compilation testing so far. But wanted to send out a v1 to see if this patch list was acceptable before I fixed up the commit text format to match what's needed for stable mailing list.
Quoted 4 lines
Some of the patches are new functionality, but for a first pass, it was easier to pull these in than try and fix the conflicts. If these patches are okay to pull into stable, then all I need to do is fix the commit text.
I took a closer look at all the patches. Everyone of them is a bug fix except Patch 4/6. But Patch 4/6 is a fairly minimal change and I think it's easier/cleaner to just pick it up too instead of trying to resolve merge conflicts in the stable branch.
1/6 - Fixes what appears to be a memory leak bug in upstream.
2/6 - Fixes error in initial state of the device link if it's created under some circumstances.
3/6 - Fixes a ref count bug in upstream. Looks like it can lead to memory leaks? 4/6 - Adds a minor feature to kick off a probe attempt of a consumer 5/6 - Fixes the break in functionality that happened in 4.19.99
6/6 - Fixes bug in 5/6 (upstream bug)
Greg
Do these patches look okay for you to pull into 4.19 stable? If so, please let me know if you need me to send v2 with commit fix up.
The only fix up needed is to these patches at this point is changing "(cherry picked from commit ...)" with "[ Upstream commit ... ]". The SHAs themselves are the correct SHAs from upstream.
Thanks,
Saravana
Greg Kroah-Hartman
maintainerQuoted 30 lines · Saravana Kannan
Quoted 11 lines · Saravana Kannan
As mentioned in an earlier email thread [1], 4.19.99 broke the ability to create stateful and stateless device links between the same set of devices when it pulled in a valid bug fix [2]. While the fix was valid, it removes a functionality that was present before the bug fix.
This patch series attempts to fix that by pulling in more patches from upstream. I've just done compilation testing so far. But wanted to send out a v1 to see if this patch list was acceptable before I fixed up the commit text format to match what's needed for stable mailing list.
Quoted 4 lines
Some of the patches are new functionality, but for a first pass, it was easier to pull these in than try and fix the conflicts. If these patches are okay to pull into stable, then all I need to do is fix the commit text.
I took a closer look at all the patches. Everyone of them is a bug fix except Patch 4/6. But Patch 4/6 is a fairly minimal change and I think it's easier/cleaner to just pick it up too instead of trying to resolve merge conflicts in the stable branch.
1/6 - Fixes what appears to be a memory leak bug in upstream.
2/6 - Fixes error in initial state of the device link if it's created under some circumstances.
3/6 - Fixes a ref count bug in upstream. Looks like it can lead to memory leaks? 4/6 - Adds a minor feature to kick off a probe attempt of a consumer 5/6 - Fixes the break in functionality that happened in 4.19.99
6/6 - Fixes bug in 5/6 (upstream bug)
Quoted 8 lines
Greg
Do these patches look okay for you to pull into 4.19 stable? If so, please let me know if you need me to send v2 with commit fix up.
The only fix up needed is to these patches at this point is changing "(cherry picked from commit ...)" with "[ Upstream commit ... ]". The SHAs themselves are the correct SHAs from upstream.
These all look good to me, now all queued up, thanks.
greg k-h
Quoted 34 lines · Greg Kroah-Hartman
Quoted 32 lines · Saravana Kannan
Quoted 11 lines · Saravana Kannan
As mentioned in an earlier email thread [1], 4.19.99 broke the ability to create stateful and stateless device links between the same set of devices when it pulled in a valid bug fix [2]. While the fix was valid, it removes a functionality that was present before the bug fix.
This patch series attempts to fix that by pulling in more patches from upstream. I've just done compilation testing so far. But wanted to send out a v1 to see if this patch list was acceptable before I fixed up the commit text format to match what's needed for stable mailing list.
Quoted 4 lines
Some of the patches are new functionality, but for a first pass, it was easier to pull these in than try and fix the conflicts. If these patches are okay to pull into stable, then all I need to do is fix the commit text.
I took a closer look at all the patches. Everyone of them is a bug fix except Patch 4/6. But Patch 4/6 is a fairly minimal change and I think it's easier/cleaner to just pick it up too instead of trying to resolve merge conflicts in the stable branch.
1/6 - Fixes what appears to be a memory leak bug in upstream.
2/6 - Fixes error in initial state of the device link if it's created under some circumstances.
3/6 - Fixes a ref count bug in upstream. Looks like it can lead to memory leaks? 4/6 - Adds a minor feature to kick off a probe attempt of a consumer 5/6 - Fixes the break in functionality that happened in 4.19.99
6/6 - Fixes bug in 5/6 (upstream bug)Greg
Quoted 8 lines
Quoted 6 lines
Do these patches look okay for you to pull into 4.19 stable? If so, please let me know if you need me to send v2 with commit fix up.
The only fix up needed is to these patches at this point is changing "(cherry picked from commit ...)" with "[ Upstream commit ... ]". The SHAs themselves are the correct SHAs from upstream.
These all look good to me, now all queued up, thanks.
Awesome, thanks!
-Saravana