Re: [GIT PULL] On-demand device probing
Quoting Rafael J. Wysocki (2015-10-25 06:54:39) > On Sun, Oct 25, 2015 at 12:06 AM, Mark Brownwrote: > > On Sat, Oct 24, 2015 at 04:17:12PM +0200, Rafael J. Wysocki wrote: > > > >> Well, I'm not quite sure why exactly everyone is so focused on probing > >> here. > > > > Probe deferral is really noisy even if it's working fine on a given > > system so it's constantly being highlighted to people in a way that > > other issues aren't if you're not directly having problems. > > > > There's also the understanding people had that the order things get > > bound changes the ordering for some of the other cases (perhaps it's a > > good idea to do that, it seems likely to be sensible?). > > But it really doesn't do that. Also making it do so doesn't help much > in the cases where things can happen asynchronously (system > suspend/resume, runtime PM). > > If, instead, there was a way to specify a functional dependency at the > device registration time, it might be used to change the order of > everything relevant, including probe. That should help to reduce the > noise you're referring to. Taking it a step further, if functional dependencies were understood at link-time then we could optimize link order as well. There are probably lots of optimizations if we only made the effort to understand these dependencies earlier. Constructing the device/resource dependency graph before the device ever boots sounds interesting to me. Regards, Mike > > If the dependency could only be discovered at the probe time, the > order of things might be changed in response to letting the driver > core know about it rather than "just in case", which should be more > efficient. > > Thanks, > Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 26, 2015 at 11:51 AM, Michael Turquettewrote: > Quoting Rafael J. Wysocki (2015-10-25 06:54:39) >> On Sun, Oct 25, 2015 at 12:06 AM, Mark Brown wrote: >> > On Sat, Oct 24, 2015 at 04:17:12PM +0200, Rafael J. Wysocki wrote: >> > >> >> Well, I'm not quite sure why exactly everyone is so focused on probing >> >> here. >> > >> > Probe deferral is really noisy even if it's working fine on a given >> > system so it's constantly being highlighted to people in a way that >> > other issues aren't if you're not directly having problems. >> > >> > There's also the understanding people had that the order things get >> > bound changes the ordering for some of the other cases (perhaps it's a >> > good idea to do that, it seems likely to be sensible?). >> >> But it really doesn't do that. Also making it do so doesn't help much >> in the cases where things can happen asynchronously (system >> suspend/resume, runtime PM). >> >> If, instead, there was a way to specify a functional dependency at the >> device registration time, it might be used to change the order of >> everything relevant, including probe. That should help to reduce the >> noise you're referring to. > > Taking it a step further, if functional dependencies were understood at > link-time then we could optimize link order as well. There are probably > lots of optimizations if we only made the effort to understand these > dependencies earlier. Do you mean the kernel link time or something else? At least in some cases the dependency information won't be known at that time, so we need a way to record a dependency at the time it becomes visible to us anyway. > Constructing the device/resource dependency graph before the device ever > boots sounds interesting to me. That's only practical if you build the kernel for a specific device. If you want a generic binary that can work with multiple different devices, that graph may very well be different for each of them. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tuesday, October 20, 2015 12:04:05 PM Alan Stern wrote: > On Tue, 20 Oct 2015, Mark Brown wrote: > > > On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: > > > > > Furthermore, that applies only to devices that use synchronous suspend. > > > Async suspend is becoming common, and there the only restrictions are > > > parent-child relations plus whatever explicit requirements that drivers > > > impose by calling device_pm_wait_for_dev(). > > > > Hrm, this is the first I'd noticed that feature though I see the initial > > commit dates from January. > > Async suspend and device_pm_wait_for_dev() were added in January 2010, > not 2015! > > > It looks like most of the users are PCs at > > the minute but we should be using it more widely for embedded things, > > there's definitely some cases I'm aware of where it will allow us to > > remove some open coding. > > > > It does seem like we want to be feeding dependency information we > > discover for probing way into the suspend dependencies... > > Rafael has been thinking about a way to do this systematically. > Nothing concrete has emerged yet. Well, good point. :-) I've been kind of struggling with finding time to work on the patches lately and some aspects of the design are still not finalized. It seems, though, that it can be beneficial to discuss the approach in general, so let me start a new thread for that. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 26 October 2015 at 11:51, Michael Turquettewrote: > Quoting Rafael J. Wysocki (2015-10-25 06:54:39) >> On Sun, Oct 25, 2015 at 12:06 AM, Mark Brown wrote: >> > On Sat, Oct 24, 2015 at 04:17:12PM +0200, Rafael J. Wysocki wrote: >> > >> >> Well, I'm not quite sure why exactly everyone is so focused on probing >> >> here. >> > >> > Probe deferral is really noisy even if it's working fine on a given >> > system so it's constantly being highlighted to people in a way that >> > other issues aren't if you're not directly having problems. >> > >> > There's also the understanding people had that the order things get >> > bound changes the ordering for some of the other cases (perhaps it's a >> > good idea to do that, it seems likely to be sensible?). >> >> But it really doesn't do that. Also making it do so doesn't help much >> in the cases where things can happen asynchronously (system >> suspend/resume, runtime PM). >> >> If, instead, there was a way to specify a functional dependency at the >> device registration time, it might be used to change the order of >> everything relevant, including probe. That should help to reduce the >> noise you're referring to. > > Taking it a step further, if functional dependencies were understood at > link-time then we could optimize link order as well. There are probably > lots of optimizations if we only made the effort to understand these > dependencies earlier. > > Constructing the device/resource dependency graph before the device ever > boots sounds interesting to me. Alexander Holler has been looking at that for some time already. Regards, Tomeu > Regards, > Mike > >> >> If the dependency could only be discovered at the probe time, the >> order of things might be changed in response to letting the driver >> core know about it rather than "just in case", which should be more >> efficient. >> >> Thanks, >> Rafael > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majord...@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/ -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sun, Oct 25, 2015 at 12:06 AM, Mark Brownwrote: > On Sat, Oct 24, 2015 at 04:17:12PM +0200, Rafael J. Wysocki wrote: > >> Well, I'm not quite sure why exactly everyone is so focused on probing here. > > Probe deferral is really noisy even if it's working fine on a given > system so it's constantly being highlighted to people in a way that > other issues aren't if you're not directly having problems. > > There's also the understanding people had that the order things get > bound changes the ordering for some of the other cases (perhaps it's a > good idea to do that, it seems likely to be sensible?). But it really doesn't do that. Also making it do so doesn't help much in the cases where things can happen asynchronously (system suspend/resume, runtime PM). If, instead, there was a way to specify a functional dependency at the device registration time, it might be used to change the order of everything relevant, including probe. That should help to reduce the noise you're referring to. If the dependency could only be discovered at the probe time, the order of things might be changed in response to letting the driver core know about it rather than "just in case", which should be more efficient. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sun, Oct 25, 2015 at 02:54:39PM +0100, Rafael J. Wysocki wrote: > On Sun, Oct 25, 2015 at 12:06 AM, Mark Brownwrote: > > There's also the understanding people had that the order things get > > bound changes the ordering for some of the other cases (perhaps it's a > > good idea to do that, it seems likely to be sensible?). > But it really doesn't do that. Also making it do so doesn't help much > in the cases where things can happen asynchronously (system > suspend/resume, runtime PM). Yeah, people seem to have that impression though. :( > If, instead, there was a way to specify a functional dependency at the > device registration time, it might be used to change the order of > everything relevant, including probe. That should help to reduce the > noise you're referring to. This links back to the idea of having generic support for pre-probe actions which is also generally useful (the ability to do things like power on regulators for devices on enumerable buses so they can be enumerated as standard). signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On 10/23/2015 10:45 AM, Tim Bird wrote: I've been worried about DT overhead adding to boot time for a while. And IMHO probe deferral is just about the lamest way to solve boot order dependencies I can imagine, from a computer science perspective. (Well, there's a certain elegance to it, but it's a stupid "make everything re-doable, back up and start over, time-wasting" elegance.) It has a bogosort kind of elegance. :) Also this might be a silly question (I haven't been following this issue for very long), but as the only place that can really know what devices depend on each other, in a generic kernel, is the DT (or whatever abstraction) will we not eventually need to solve this issue there? Could we just add a "depends-on = <>;" to nodes when we know they are needed for our board? -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Friday, October 23, 2015 11:34:34 AM Rob Herring wrote: > On Fri, Oct 23, 2015 at 10:45 AM, Tim Birdwrote: > > On 10/22/2015 11:53 AM, Frank Rowand wrote: > >> On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: > >>> > >>> > >>> On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: > But that's moot currently because Greg believes that the time spent > probing devices at boot time could be reduced enough so that the order > in which devices are probed becomes irrelevant. IME that would have to > be under 200ms so that the user doesn't notice and that's unicorn-far > from any bootlog I have ever seen. > >>> > >>> But as no one has actually produced a bootlog, how do you know that? > >>> Where exactly is your time being spent? What driver is causing long > >>> delays? Why is the long-delay-drivers not being done in their own > >>> thread? And most importantly, why are you ignoring the work that people > >>> did back in 2008 to solve the issue on other hardware platforms? > >>> > Given that downstreams are already carrying as many hacks as they > could think of to speed total boot up, I think this is effectively > telling them to go away. > >>> > >>> No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to > >>> solve-the-random-issue-i'm-having type patch by putting random calls in > >>> semi-random subsystems all over the kernel. > >>> > >>> And when I ask for real data, you respond with the fact that you aren't > >>> trying to speed up boot time here at all, so what am I supposed to think > >> > >> I also had the understanding that this patch series was about improving > >> boot time. But I was kindly corrected that the behavior change was > >> getting the panel displaying stuff at an earlier point in the boot > >> sequence, > >> _not_ completing the entire boot faster. > >> > >> The claim for the current series, in patch 0 in v7 is: > >> > >>With this series I get the kernel to output to the panel in 0.5s, > >>instead of 2.8s. > > > > It's very common to want to get the display up before the > > rest of the system. So wanting to accelerate one part of the boot > > at the expense to the rest of the system is a valid use case. > > Deferred initcalls, which is out of tree primarily because it requires > > the type of manual tweaking that Tomeu describes, specifically > > addressed this issue. > > Agreed and other folks will want other things up first. But it seems > we are getting lucky with link order with the speed ups in this case. > We need a way to specify priority of probing devices. If we have that > piece, then all this plumbing can be used. A simple solution would be > looking at stdout-path to get the console device to probe. That would > be trivial to add on top of this. That may work for the display too, > but you may not want the console on the display. That wouldn't work > for CAN bus either, but then I'm not sure there is a generic solution > for its requirements (respond within 50ms IIRC). Well, I'm not quite sure why exactly everyone is so focused on probing here. Probing is just one aspect of the fact that we need functional dependencies to be tracked somehow and acted on when necessary. And this is not limited to probing, as I have already said for a few times. Other cases include: system shutdown, system suspend/resume, runtime PM, unbinding of drivers. If there is a functional dependency between two devices (say, B requires A to be present and functional, meaning that the driver of A has to be present and working for the driver of B to be working), all of the above need to be done in a specific order. Today, however, the driver core only knows about structural dependencies and only in the specific parent-child case. So perhaps it's better to start discussing about a solution for the general issue? Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 8:53 PM, Frank Rowandwrote: > I have been defaulting to the position that has been asserted by > the device tree maintainters, that probe deferrals work just fine > for at least the majority of cases (and is the message I have been > sharing in my conference presentations about device tree). But I > suspect that there is at least a small minority of cases that are not > well served by probe deferral. (Not to be read as an endorsement of > this specific patch series, just a generic observation.) Yep, once in a while people still stumble on obscure subsystems and drivers not supporting probe deferral. Usually they don't fail with a big bang, so everything seems fine. E.g. last week's "of_mdiobus_register_phy() and deferred probe" (https://lkml.org/lkml/2015/10/22/377). Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- ge...@linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 24, 2015 at 04:17:12PM +0200, Rafael J. Wysocki wrote: > Well, I'm not quite sure why exactly everyone is so focused on probing here. Probe deferral is really noisy even if it's working fine on a given system so it's constantly being highlighted to people in a way that other issues aren't if you're not directly having problems. There's also the understanding people had that the order things get bound changes the ordering for some of the other cases (perhaps it's a good idea to do that, it seems likely to be sensible?). signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On 10/22/2015 09:26 PM, Greg Kroah-Hartman wrote: > On Thu, Oct 22, 2015 at 11:53:31AM -0700, Frank Rowand wrote: >> On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: >>>>>> >>> On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: But that's moot currently because Greg believes that the time spent probing devices at boot time could be reduced enough so that the order in which devices are probed becomes irrelevant. IME that would have to be under 200ms so that the user doesn't notice and that's unicorn-far from any bootlog I have ever seen. >>> >>> But as no one has actually produced a bootlog, how do you know that? >>> Where exactly is your time being spent? What driver is causing long >>> delays? Why is the long-delay-drivers not being done in their own >>> thread? And most importantly, why are you ignoring the work that people >>> did back in 2008 to solve the issue on other hardware platforms? >>> Given that downstreams are already carrying as many hacks as they could think of to speed total boot up, I think this is effectively telling them to go away. >>> >>> No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to >>> solve-the-random-issue-i'm-having type patch by putting random calls in >>> semi-random subsystems all over the kernel. >>> >>> And when I ask for real data, you respond with the fact that you aren't >>> trying to speed up boot time here at all, so what am I supposed to think >> >> I also had the understanding that this patch series was about improving >> boot time. But I was kindly corrected that the behavior change was >> getting the panel displaying stuff at an earlier point in the boot sequence, >> _not_ completing the entire boot faster. >> >> The claim for the current series, in patch 0 in v7 is: >> >>With this series I get the kernel to output to the panel in 0.5s, >>instead of 2.8s. >> >> Just to get side-tracked, one other approach at ordering to reduce >> deferrals reported a modest boot time reduction for four boards and a >> very slight boot time increase for one other board.) The report of boot >> times with that approach was in: >> >> http://article.gmane.org/gmane.linux.drivers.devicetree/133010 >> >> from Alexander Holler. >> >> I have not searched further to see if there is more data of boot time >> reductions from any of the other attempts to change driver binding >> order to move dependencies before use of a resource. But whether >> there is a performance improvement or not, there continues to be >> a stream of developers creatively impacting the binding order for >> their specific driver(s) or board. So it seems that maybe there >> is an underlying problem, or we don't have adequate documentation >> explaining how to avoid a need to order bindings, or the >> documentation exists and is not being read. >> >> I have been defaulting to the position that has been asserted by >> the device tree maintainters, that probe deferrals work just fine >> for at least the majority of cases (and is the message I have been >> sharing in my conference presentations about device tree). But I >> suspect that there is at least a small minority of cases that are not >> well served by probe deferral. (Not to be read as an endorsement of >> this specific patch series, just a generic observation.) > > I agree, there might be some small numbers that this is a problem for, > and if so, great, show us the boot logs where things are taking up all > of the time, and we can work on resolving those issues. > > But without hard numbers / details, this all is just random hand-waving, > and I don't like making core kernel changes on that basis. And no one > else should ever want us to do that either. Hi, have found the board in which Stéphane had the original issue on (exynos5250-snow), and I'm attaching the bootlog of next-20151013+exynos_defconfig with initcall_debug and DEBUG in dd.c. As can be seen, 145b.dp-controller is tried reasonably early (at 0.25s), but is deferred and only retried at 0.9s, with the display finally coming up at 1.35s. But I'm not sure what's the point in discussing this further if you have already said that it's fine if downstreams have to change the probing order by moving files around in the makefiles and by fiddling with initcall levels. To give a better understanding of what's going on here, I wasn't involved in the bringup of this board, but was tasked with fixing this issue in mainline so it doesn't have to be worked around in every product. Regards, Tomeu > thanks, > > greg k-h > [0.00] Booting Linux on physical CPU 0x0 [0.00] Linux version 4.3.0-rc5-next-20151013-dirty (tomeu@cizrna) (gcc version 5.2.1 20150716 (Red Hat Cross 5.2.1-3) (GCC) ) #3491 SMP PREEMPT Fri Oct 23 11:17:16 CEST 2015 [0.00] CPU: ARMv7 Processor [410fc0f4] revision 4 (ARMv7), cr=10c5387d [0.00] CPU: PIPT / VIPT nonaliasing data cache, PIPT
Re: [GIT PULL] On-demand device probing
On 10/22/2015 11:53 AM, Frank Rowand wrote: > On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: >>>> >> On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: >>> But that's moot currently because Greg believes that the time spent >>> probing devices at boot time could be reduced enough so that the order >>> in which devices are probed becomes irrelevant. IME that would have to >>> be under 200ms so that the user doesn't notice and that's unicorn-far >>> from any bootlog I have ever seen. >> >> But as no one has actually produced a bootlog, how do you know that? >> Where exactly is your time being spent? What driver is causing long >> delays? Why is the long-delay-drivers not being done in their own >> thread? And most importantly, why are you ignoring the work that people >> did back in 2008 to solve the issue on other hardware platforms? >> >>> Given that downstreams are already carrying as many hacks as they >>> could think of to speed total boot up, I think this is effectively >>> telling them to go away. >> >> No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to >> solve-the-random-issue-i'm-having type patch by putting random calls in >> semi-random subsystems all over the kernel. >> >> And when I ask for real data, you respond with the fact that you aren't >> trying to speed up boot time here at all, so what am I supposed to think > > I also had the understanding that this patch series was about improving > boot time. But I was kindly corrected that the behavior change was > getting the panel displaying stuff at an earlier point in the boot sequence, > _not_ completing the entire boot faster. > > The claim for the current series, in patch 0 in v7 is: > >With this series I get the kernel to output to the panel in 0.5s, >instead of 2.8s. It's very common to want to get the display up before the rest of the system. So wanting to accelerate one part of the boot at the expense to the rest of the system is a valid use case. Deferred initcalls, which is out of tree primarily because it requires the type of manual tweaking that Tomeu describes, specifically addressed this issue. > > Just to get side-tracked, one other approach at ordering to reduce > deferrals reported a modest boot time reduction for four boards and a > very slight boot time increase for one other board.) The report of boot > times with that approach was in: > > http://article.gmane.org/gmane.linux.drivers.devicetree/133010 > > from Alexander Holler. > > I have not searched further to see if there is more data of boot time > reductions from any of the other attempts to change driver binding > order to move dependencies before use of a resource. But whether > there is a performance improvement or not, there continues to be > a stream of developers creatively impacting the binding order for > their specific driver(s) or board. So it seems that maybe there > is an underlying problem, or we don't have adequate documentation > explaining how to avoid a need to order bindings, or the > documentation exists and is not being read. Well, I have probe order problems unrelated to boot time, that I solved by resorting to putting stuff into modules and loading them post-boot. So I'd be interested in easy solutions to managing boot order in mainline. > > I have been defaulting to the position that has been asserted by > the device tree maintainters, that probe deferrals work just fine > for at least the majority of cases (and is the message I have been > sharing in my conference presentations about device tree). But I > suspect that there is at least a small minority of cases that are not > well served by probe deferral. (Not to be read as an endorsement of > this specific patch series, just a generic observation.) I've been worried about DT overhead adding to boot time for a while. And IMHO probe deferral is just about the lamest way to solve boot order dependencies I can imagine, from a computer science perspective. (Well, there's a certain elegance to it, but it's a stupid "make everything re-doable, back up and start over, time-wasting" elegance.) However, when Android takes 35 seconds to boot, and most people almost never cold-boot your product, a few seconds of kernel time-wasting on cold-boot seem less important. Alas, when I started working on mobile phones I stopped caring much about boot time. Thus, I've never worried about the DT overhead enough to actually measure it, as requested by Greg. So I'll just shut up now. :-) -- Tim -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Fri, Oct 23, 2015 at 10:45 AM, Tim Birdwrote: > On 10/22/2015 11:53 AM, Frank Rowand wrote: >> On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: >>> >>> >>> On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: But that's moot currently because Greg believes that the time spent probing devices at boot time could be reduced enough so that the order in which devices are probed becomes irrelevant. IME that would have to be under 200ms so that the user doesn't notice and that's unicorn-far from any bootlog I have ever seen. >>> >>> But as no one has actually produced a bootlog, how do you know that? >>> Where exactly is your time being spent? What driver is causing long >>> delays? Why is the long-delay-drivers not being done in their own >>> thread? And most importantly, why are you ignoring the work that people >>> did back in 2008 to solve the issue on other hardware platforms? >>> Given that downstreams are already carrying as many hacks as they could think of to speed total boot up, I think this is effectively telling them to go away. >>> >>> No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to >>> solve-the-random-issue-i'm-having type patch by putting random calls in >>> semi-random subsystems all over the kernel. >>> >>> And when I ask for real data, you respond with the fact that you aren't >>> trying to speed up boot time here at all, so what am I supposed to think >> >> I also had the understanding that this patch series was about improving >> boot time. But I was kindly corrected that the behavior change was >> getting the panel displaying stuff at an earlier point in the boot sequence, >> _not_ completing the entire boot faster. >> >> The claim for the current series, in patch 0 in v7 is: >> >>With this series I get the kernel to output to the panel in 0.5s, >>instead of 2.8s. > > It's very common to want to get the display up before the > rest of the system. So wanting to accelerate one part of the boot > at the expense to the rest of the system is a valid use case. > Deferred initcalls, which is out of tree primarily because it requires > the type of manual tweaking that Tomeu describes, specifically > addressed this issue. Agreed and other folks will want other things up first. But it seems we are getting lucky with link order with the speed ups in this case. We need a way to specify priority of probing devices. If we have that piece, then all this plumbing can be used. A simple solution would be looking at stdout-path to get the console device to probe. That would be trivial to add on top of this. That may work for the display too, but you may not want the console on the display. That wouldn't work for CAN bus either, but then I'm not sure there is a generic solution for its requirements (respond within 50ms IIRC). >> Just to get side-tracked, one other approach at ordering to reduce >> deferrals reported a modest boot time reduction for four boards and a >> very slight boot time increase for one other board.) The report of boot >> times with that approach was in: >> >> http://article.gmane.org/gmane.linux.drivers.devicetree/133010 >> >> from Alexander Holler. >> >> I have not searched further to see if there is more data of boot time >> reductions from any of the other attempts to change driver binding >> order to move dependencies before use of a resource. But whether >> there is a performance improvement or not, there continues to be >> a stream of developers creatively impacting the binding order for >> their specific driver(s) or board. So it seems that maybe there >> is an underlying problem, or we don't have adequate documentation >> explaining how to avoid a need to order bindings, or the >> documentation exists and is not being read. > > Well, I have probe order problems unrelated to boot time, that > I solved by resorting to putting stuff into modules and loading > them post-boot. So I'd be interested in easy solutions to managing > boot order in mainline. I take it that this series doesn't help those problems? >> I have been defaulting to the position that has been asserted by >> the device tree maintainters, that probe deferrals work just fine >> for at least the majority of cases (and is the message I have been >> sharing in my conference presentations about device tree). But I >> suspect that there is at least a small minority of cases that are not >> well served by probe deferral. (Not to be read as an endorsement of >> this specific patch series, just a generic observation.) > > I've been worried about DT overhead adding to boot time for a while. Always beating up DT... ;) Yes, I'm sure there is some overhead, but looking at bootgraph there's much longer items not related to DT (USB, MMC and anything over I2C seem to be typical). With DT we lost most control of the order, and at the same time we added a load of new subsystems that are
Re: [GIT PULL] On-demand device probing
On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: >> > On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: >> But that's moot currently because Greg believes that the time spent >> probing devices at boot time could be reduced enough so that the order >> in which devices are probed becomes irrelevant. IME that would have to >> be under 200ms so that the user doesn't notice and that's unicorn-far >> from any bootlog I have ever seen. > > But as no one has actually produced a bootlog, how do you know that? > Where exactly is your time being spent? What driver is causing long > delays? Why is the long-delay-drivers not being done in their own > thread? And most importantly, why are you ignoring the work that people > did back in 2008 to solve the issue on other hardware platforms? > >> Given that downstreams are already carrying as many hacks as they >> could think of to speed total boot up, I think this is effectively >> telling them to go away. > > No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to > solve-the-random-issue-i'm-having type patch by putting random calls in > semi-random subsystems all over the kernel. > > And when I ask for real data, you respond with the fact that you aren't > trying to speed up boot time here at all, so what am I supposed to think I also had the understanding that this patch series was about improving boot time. But I was kindly corrected that the behavior change was getting the panel displaying stuff at an earlier point in the boot sequence, _not_ completing the entire boot faster. The claim for the current series, in patch 0 in v7 is: With this series I get the kernel to output to the panel in 0.5s, instead of 2.8s. Just to get side-tracked, one other approach at ordering to reduce deferrals reported a modest boot time reduction for four boards and a very slight boot time increase for one other board.) The report of boot times with that approach was in: http://article.gmane.org/gmane.linux.drivers.devicetree/133010 from Alexander Holler. I have not searched further to see if there is more data of boot time reductions from any of the other attempts to change driver binding order to move dependencies before use of a resource. But whether there is a performance improvement or not, there continues to be a stream of developers creatively impacting the binding order for their specific driver(s) or board. So it seems that maybe there is an underlying problem, or we don't have adequate documentation explaining how to avoid a need to order bindings, or the documentation exists and is not being read. I have been defaulting to the position that has been asserted by the device tree maintainters, that probe deferrals work just fine for at least the majority of cases (and is the message I have been sharing in my conference presentations about device tree). But I suspect that there is at least a small minority of cases that are not well served by probe deferral. (Not to be read as an endorsement of this specific patch series, just a generic observation.) -Frank > other than that you don't care enough to do the real work and are trying > to hack the driver core up instead. > >> Sorry for the rant, > > No apologies needed, it's cathartic at times :) > > thanks, > > greg k-h > . > -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 11:53:31AM -0700, Frank Rowand wrote: > On 10/22/2015 7:44 AM, Greg Kroah-Hartman wrote: > >> > > > On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: > >> But that's moot currently because Greg believes that the time spent > >> probing devices at boot time could be reduced enough so that the order > >> in which devices are probed becomes irrelevant. IME that would have to > >> be under 200ms so that the user doesn't notice and that's unicorn-far > >> from any bootlog I have ever seen. > > > > But as no one has actually produced a bootlog, how do you know that? > > Where exactly is your time being spent? What driver is causing long > > delays? Why is the long-delay-drivers not being done in their own > > thread? And most importantly, why are you ignoring the work that people > > did back in 2008 to solve the issue on other hardware platforms? > > > >> Given that downstreams are already carrying as many hacks as they > >> could think of to speed total boot up, I think this is effectively > >> telling them to go away. > > > > No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to > > solve-the-random-issue-i'm-having type patch by putting random calls in > > semi-random subsystems all over the kernel. > > > > And when I ask for real data, you respond with the fact that you aren't > > trying to speed up boot time here at all, so what am I supposed to think > > I also had the understanding that this patch series was about improving > boot time. But I was kindly corrected that the behavior change was > getting the panel displaying stuff at an earlier point in the boot sequence, > _not_ completing the entire boot faster. > > The claim for the current series, in patch 0 in v7 is: > >With this series I get the kernel to output to the panel in 0.5s, >instead of 2.8s. > > Just to get side-tracked, one other approach at ordering to reduce > deferrals reported a modest boot time reduction for four boards and a > very slight boot time increase for one other board.) The report of boot > times with that approach was in: > > http://article.gmane.org/gmane.linux.drivers.devicetree/133010 > > from Alexander Holler. > > I have not searched further to see if there is more data of boot time > reductions from any of the other attempts to change driver binding > order to move dependencies before use of a resource. But whether > there is a performance improvement or not, there continues to be > a stream of developers creatively impacting the binding order for > their specific driver(s) or board. So it seems that maybe there > is an underlying problem, or we don't have adequate documentation > explaining how to avoid a need to order bindings, or the > documentation exists and is not being read. > > I have been defaulting to the position that has been asserted by > the device tree maintainters, that probe deferrals work just fine > for at least the majority of cases (and is the message I have been > sharing in my conference presentations about device tree). But I > suspect that there is at least a small minority of cases that are not > well served by probe deferral. (Not to be read as an endorsement of > this specific patch series, just a generic observation.) I agree, there might be some small numbers that this is a problem for, and if so, great, show us the boot logs where things are taking up all of the time, and we can work on resolving those issues. But without hard numbers / details, this all is just random hand-waving, and I don't like making core kernel changes on that basis. And no one else should ever want us to do that either. thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 22 October 2015 at 02:54, Rafael J. Wysockiwrote: > On Tuesday, October 20, 2015 06:21:55 PM Tomeu Vizoso wrote: >> On 20 October 2015 at 18:04, Alan Stern wrote: >> > On Tue, 20 Oct 2015, Mark Brown wrote: >> > >> >> On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: >> >> >> >> > Furthermore, that applies only to devices that use synchronous suspend. >> >> > Async suspend is becoming common, and there the only restrictions are >> >> > parent-child relations plus whatever explicit requirements that drivers >> >> > impose by calling device_pm_wait_for_dev(). >> >> >> >> Hrm, this is the first I'd noticed that feature though I see the initial >> >> commit dates from January. >> > >> > Async suspend and device_pm_wait_for_dev() were added in January 2010, >> > not 2015! >> > >> >> It looks like most of the users are PCs at >> >> the minute but we should be using it more widely for embedded things, >> >> there's definitely some cases I'm aware of where it will allow us to >> >> remove some open coding. >> >> >> >> It does seem like we want to be feeding dependency information we >> >> discover for probing way into the suspend dependencies... >> > >> > Rafael has been thinking about a way to do this systematically. >> > Nothing concrete has emerged yet. >> >> This iteration of the series would make this quite easy, as >> dependencies are calculated before probes are attempted: >> >> https://lkml.org/lkml/2015/6/17/311 > > Well, if you know how to represent "links" between devices, the mechanism > introduced here doesn't really add much value, because in that case the > core knows what the dependencies are in the first place and can only > defer the probes that have to be deferred. By "here" you mean what you are proposing for ordering device suspends, or on-demand probing? If you meant that probing on-demand is unneeded if we already have dependency information, I agree with you and that's why I only pushed forward on-demand, as the approach linked above introduced some duplication when inferring the dependencies. Maybe that could be avoided without too much refactoring. In any case, Thierry mentioned the other day in #tegra that one could also collect dependency information as a follow up to the on-demand series by calling device_depend() or such instead of of_device_probe(). Regards, Tomeu > Thanks, > Rafael > > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majord...@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/ -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 04:02:13PM +0100, Russell King - ARM Linux wrote: > If it was such a problem, then in the _eight_ days that this has been > discussed so far, _someone_ would have sent some data showing the > problem. I think the fact is, there is no data. > Someone prove me wrong. Someone post the verifiable data showing that > there is a problem to be solved here. > Someone show what the specific failure cases are that are hampering > vendors moving forwards. Someone show the long boot times by way of > kernel message log. Someone show some evidence of the problems that > have been alluded to. > If no one can show some evidence, there isn't a problem here. :) Yeah, I'm not convinced the timing is *such* a big deal either - I do think that the log spam is a real problem but I think something much less invasive like the interface you proposed is good for addressing that. signature.asc Description: PGP signature
Re: Alternative approach to solve the deferred probe (was: [GIT PULL] On-demand device probing)
On Tue, Oct 20, 2015 at 04:46:56PM +0100, Russell King - ARM Linux wrote: > Something like this. I haven't put a lot of effort into it to change all > the places which return an -EPROBE_DEFER, and it also looks like we need > some helpers to report when we have only an device_node (or should that > be fwnode?) See the commented out of_warn_deferred() in > drivers/gpio/gpiolib-of.c. Adding this stuff in the subsystems searching > for resources should make debugging why things are getting deferred easier. Yeah, plus I'd expect it to also result in better error reporting overall if the subsystems are able to report when they fail to get something rather than just returning an error to the driver. > +/** > + * dev_warn_deferred() - report why a probe has been deferred > + */ > +void dev_warn_deferred(struct device *dev, const char *fmt, ...) > +{ > + if (driver_deferred_probe_report) { > + struct va_format vaf; > + va_list ap; > + > + va_start(ap, fmt); > + vaf.fmt = fmt; > + vaf.va = > + > + dev_warn(dev, "deferring probe: %pV", ); > + va_end(ap); > + } > +} > +EXPORT_SYMBOL_GPL(dev_warn_deferred); I'm not currently able to think of a nice way of writing this but I think what I'd really like to see from a driver point of view is something which decays into dev_err() if it's a non-deferral error. That way drivers can have minimal log and return error handling code and we will still get the output sensibly. The best I can think of is something like void dev_warn_deferred(struct device *dev, int err, const char *fmt, ...) which requires the caller to pass in err twice to get it logged. That's not a thing of beauty but it gets the job done... but perhaps your original interface is better, it's a bit cleaner. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On 21 October 2015 at 23:50, Frank Rowandwrote: > On 10/21/2015 2:12 PM, Rob Herring wrote: >> On Wed, Oct 21, 2015 at 1:18 PM, Frank Rowand wrote: >>> On 10/21/2015 9:27 AM, Mark Brown wrote: On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: > On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: >> To be clear, I was saying that this series should NOT affect total >> boot times much. > I'm confused. If I understood correctly, improving boot time was > the key justification for accepting this patch set. For example, > from "[PATCH v7 0/20] On-demand device probing": > >I have a problem with the panel on my Tegra Chromebook taking longer >than expected to be ready during boot (Stéphane Marchesin reported what >is basically the same issue in [0]), and have looked into ordered >probing as a better way of solving this than moving nodes around in the >DT or playing with initcall levels and linking order. > >... > >With this series I get the kernel to output to the panel in 0.5s, >instead of 2.8s. Overall boot time and time to get some individual built in component up and running aren't the same thing - what this'll do is get things up more in the link order of the leaf consumers rather than deferring those leaf consumers when their dependencies aren't ready yet. >>> >>> Thanks! I read too much into what was being improved. >>> >>> So this patch series, which on other merits may be a good idea, is as >>> a by product solving a specific ordering issue, moving successful panel >>> initialization to an earlier point in the boot sequence, if I now >>> understand more correctly. >>> >>> In that context, this seems like yet another ad hoc way of causing the >>> probe order to change in a way to solves one specific issue? Could >>> it just as likely move the boot order of some other driver on some >>> other board later, to the detriment of somebody else? >> >> Time to display on is important for many products. Having the console >> up as early as possible is another case. CAN bus is another. This is a >> real problem that is not just bad drivers. > > Yes, I agree. > > What I am seeing is that there continues to be a need for the ability > to explicitly order at least some driver initialization (at some > granularity), despite the push back against explicit ordering that > has been present in the past. The important point that I have struggled to explain is that right now for downstreams to influence the order in which devices are probed, they have to carry a substantial amount of patches that cannot be ever upstreamed. This fiddling with initcall levels and link order means changing files that are very frequently changing, increasing the amount of work when rebasing and increasing the probability of regressions after a rebase. This just adds up to other shortcomings of mainline and ends up with the net result of vendors getting stuck with 3.4 kernels on SoCs that start production in 2015. Another consequence is that vendors don't have a chance to upstream their stuff even if they cared. The overarching goal of the project I'm in is to reduce those shortcomings that downstreams have to workaround, to facilitate their involvement upstream. With this series, the order in which devices are probed becomes the order in which they were registered, which is the order in which the devices appear in the FW description of the hw or in the board files (much more predictable, which makes for a more robust process). For DT and board files, which cover a good part of the consumer devices shipped today with Linux, the downstream could just change the order of device nodes and get their display or whatever to probe before any other devices. And even if downstream's hw has a SoC .dtsi that exists in mainline, they could add a step to their build process that automatically reorders the nodes to avoid carrying changes to that DT fragment. But that's moot currently because Greg believes that the time spent probing devices at boot time could be reduced enough so that the order in which devices are probed becomes irrelevant. IME that would have to be under 200ms so that the user doesn't notice and that's unicorn-far from any bootlog I have ever seen. Given that downstreams are already carrying as many hacks as they could think of to speed total boot up, I think this is effectively telling them to go away. Sorry for the rant, Tomeu >> I don't think it is completely ad hoc. Given all devices are >> registered after drivers, drivers will still probe first in initcall >> level order and then link order AFAIK. We may not take (more) initcall >> level tweak hacks, but that is a much more simple change for >> downstream. Don't get me wrong, I'd really like to see a way to >> control order independent of initcall level. >> >> Rob > > Yep, it is
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: > On 21 October 2015 at 23:50, Frank Rowandwrote: > > On 10/21/2015 2:12 PM, Rob Herring wrote: > >> On Wed, Oct 21, 2015 at 1:18 PM, Frank Rowand > >> wrote: > >>> On 10/21/2015 9:27 AM, Mark Brown wrote: > On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: > > On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: > > >> To be clear, I was saying that this series should NOT affect total > >> boot times much. > > > I'm confused. If I understood correctly, improving boot time was > > the key justification for accepting this patch set. For example, > > from "[PATCH v7 0/20] On-demand device probing": > > > >I have a problem with the panel on my Tegra Chromebook taking longer > >than expected to be ready during boot (Stéphane Marchesin reported > > what > >is basically the same issue in [0]), and have looked into ordered > >probing as a better way of solving this than moving nodes around in > > the > >DT or playing with initcall levels and linking order. > > > >... > > > >With this series I get the kernel to output to the panel in 0.5s, > >instead of 2.8s. > > Overall boot time and time to get some individual built in component up > and running aren't the same thing - what this'll do is get things up > more in the link order of the leaf consumers rather than deferring those > leaf consumers when their dependencies aren't ready yet. > >>> > >>> Thanks! I read too much into what was being improved. > >>> > >>> So this patch series, which on other merits may be a good idea, is as > >>> a by product solving a specific ordering issue, moving successful panel > >>> initialization to an earlier point in the boot sequence, if I now > >>> understand more correctly. > >>> > >>> In that context, this seems like yet another ad hoc way of causing the > >>> probe order to change in a way to solves one specific issue? Could > >>> it just as likely move the boot order of some other driver on some > >>> other board later, to the detriment of somebody else? > >> > >> Time to display on is important for many products. Having the console > >> up as early as possible is another case. CAN bus is another. This is a > >> real problem that is not just bad drivers. > > > > Yes, I agree. > > > > What I am seeing is that there continues to be a need for the ability > > to explicitly order at least some driver initialization (at some > > granularity), despite the push back against explicit ordering that > > has been present in the past. > > The important point that I have struggled to explain is that right now > for downstreams to influence the order in which devices are probed, > they have to carry a substantial amount of patches that cannot be ever > upstreamed. This fiddling with initcall levels and link order means > changing files that are very frequently changing, increasing the > amount of work when rebasing and increasing the probability of > regressions after a rebase. > > This just adds up to other shortcomings of mainline and ends up with > the net result of vendors getting stuck with 3.4 kernels on SoCs that > start production in 2015. Another consequence is that vendors don't > have a chance to upstream their stuff even if they cared. The > overarching goal of the project I'm in is to reduce those shortcomings > that downstreams have to workaround, to facilitate their involvement > upstream. The init order of drivers has no influence at all on the ability for companies to have their individual drivers merged upstream, please don't be so dramatic about this. Worst case, a vendor keeps a single patch to drivers/Makefile in their tree that reorders things, yes it will get conflicts on every release, but really, it's trivial to maintain if they wish to keep doing this type of thing. Again, it is _not_ the reason that we are living with 2million+ lines of code in vendor kernels. thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: > But that's moot currently because Greg believes that the time spent > probing devices at boot time could be reduced enough so that the order > in which devices are probed becomes irrelevant. IME that would have to > be under 200ms so that the user doesn't notice and that's unicorn-far > from any bootlog I have ever seen. But as no one has actually produced a bootlog, how do you know that? Where exactly is your time being spent? What driver is causing long delays? Why is the long-delay-drivers not being done in their own thread? And most importantly, why are you ignoring the work that people did back in 2008 to solve the issue on other hardware platforms? > Given that downstreams are already carrying as many hacks as they > could think of to speed total boot up, I think this is effectively > telling them to go away. No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to solve-the-random-issue-i'm-having type patch by putting random calls in semi-random subsystems all over the kernel. And when I ask for real data, you respond with the fact that you aren't trying to speed up boot time here at all, so what am I supposed to think other than that you don't care enough to do the real work and are trying to hack the driver core up instead. > Sorry for the rant, No apologies needed, it's cathartic at times :) thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Thu, Oct 22, 2015 at 07:44:05AM -0700, Greg Kroah-Hartman wrote: >> > On Thu, Oct 22, 2015 at 11:05:11AM +0200, Tomeu Vizoso wrote: > > Given that downstreams are already carrying as many hacks as they > > could think of to speed total boot up, I think this is effectively > > telling them to go away. > > No I'm not, I'm asking for real data, not hand-wavy-this-is-going-to > solve-the-random-issue-i'm-having type patch by putting random calls in > semi-random subsystems all over the kernel. +1000, fully agree. There's too much verbal diarrhoea going on in this thread and no facts. I've been waiting for real data too, and there's not one shred of it, or even a hint that it might appear. So, the conclusion I'm coming to is that there isn't any data to back up the claims made in this thread. If it was such a problem, then in the _eight_ days that this has been discussed so far, _someone_ would have sent some data showing the problem. I think the fact is, there is no data. Someone prove me wrong. Someone post the verifiable data showing that there is a problem to be solved here. Someone show what the specific failure cases are that are hampering vendors moving forwards. Someone show the long boot times by way of kernel message log. Someone show some evidence of the problems that have been alluded to. If no one can show some evidence, there isn't a problem here. :) -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: > On 18 October 2015 at 21:53, Mark Brownwrote: >> On Sun, Oct 18, 2015 at 12:37:57PM -0700, Greg Kroah-Hartman wrote: >>> On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: < snip > > hope you don't mind I summarize the points taken instead of replying > to the individual emails. I tried to address all the concerns that > have been raised again in the cover letter, but I guess I did a bad > job at explaining myself, so here's another (more in-depth) go at it. < snip > > 3) Regarding total boot time, I don't expect this series to make much > of a difference because though we would save a lot of matching and > querying for resources, that's little time compared with how long we > wait for hardware to react during probing. Async probing is more > likely to help with drivers that take a long time to probe. And then in your reply to Russell's reply to your email you say: > To be clear, I was saying that this series should NOT affect total > boot times much. I'm confused. If I understood correctly, improving boot time was the key justification for accepting this patch set. For example, from "[PATCH v7 0/20] On-demand device probing": I have a problem with the panel on my Tegra Chromebook taking longer than expected to be ready during boot (Stéphane Marchesin reported what is basically the same issue in [0]), and have looked into ordered probing as a better way of solving this than moving nodes around in the DT or playing with initcall levels and linking order. ... With this series I get the kernel to output to the panel in 0.5s, instead of 2.8s. Alexander Holler reported improved boot times for his patch set in August, which is another approach to ordering probes (http://article.gmane.org/gmane.linux.drivers.devicetree/133010). His results for 5 boards was four booted faster, one slightly slower: Some numbers (5 boots on each board, without and with ordering drivers), all times are seconds. Kirkwood (dockstar, armv5): Boot to "Freeing unused kernel memory" (includes mounting the rootfs), unordered: 4.456016 3.937801 4.114788 4.114526 3.949480 (average 4.1145222) ordered: 3.173054 3.164045 3.141418 3.480679 3.459298 (3.2836988) Time needed to sort (of_init_build_order()): 0.003024 Time needed to match drivers to the order (without calling them): 0.002884 Beagleboard (rev C4, armv7): unordered: 6.706024 6.821746 6.696014 6.673675 6.769866 (6.733465) ordered: 5.544860 5.514160 5.505859 5.527374 5.496795 (5.5178096) sorting: 0.021209 matching: 0.006165 Beaglebone Black (rev A5, armv7): unordered: 3.826531 3.825662 3.826648 3.825434 3.825263 (3.8259076) ordered: 2.838554 2.838322 2.839459 2.838467 2.838421 (2.8386446) sorting: 0.004769 matching: 0.004860 imx6q (armv7): unordered: 3.451998 3.418864 3.446952 3.429974 3.440996 (3.4377568) ordered: 3.538312 3.549019 3.538105 3.515916 3.555715 (3.5394134) sorting: 0.004622 matching: 0.003868 While not as dramatic as your results, they are somewhat supportive. What has changed your assessment that the on-demand device probing patches will give a big boot performance increase? Do you have new data or analysis? -Frank -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: > On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: > > To be clear, I was saying that this series should NOT affect total > > boot times much. > I'm confused. If I understood correctly, improving boot time was > the key justification for accepting this patch set. For example, > from "[PATCH v7 0/20] On-demand device probing": > >I have a problem with the panel on my Tegra Chromebook taking longer >than expected to be ready during boot (Stéphane Marchesin reported what >is basically the same issue in [0]), and have looked into ordered >probing as a better way of solving this than moving nodes around in the >DT or playing with initcall levels and linking order. > >... > >With this series I get the kernel to output to the panel in 0.5s, >instead of 2.8s. Overall boot time and time to get some individual built in component up and running aren't the same thing - what this'll do is get things up more in the link order of the leaf consumers rather than deferring those leaf consumers when their dependencies aren't ready yet. > While not as dramatic as your results, they are somewhat supportive. > What has changed your assessment that the on-demand device probing > patches will give a big boot performance increase? Do you have > new data or analysis? See above, my understanding was that the performance improvements were more around improved control/predictability/handwave of the boot ordering rather than total time. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On 10/21/2015 9:27 AM, Mark Brown wrote: > On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: >> On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: > >>> To be clear, I was saying that this series should NOT affect total >>> boot times much. > >> I'm confused. If I understood correctly, improving boot time was >> the key justification for accepting this patch set. For example, >> from "[PATCH v7 0/20] On-demand device probing": >> >>I have a problem with the panel on my Tegra Chromebook taking longer >>than expected to be ready during boot (Stéphane Marchesin reported what >>is basically the same issue in [0]), and have looked into ordered >>probing as a better way of solving this than moving nodes around in the >>DT or playing with initcall levels and linking order. >> >>... >> >>With this series I get the kernel to output to the panel in 0.5s, >>instead of 2.8s. > > Overall boot time and time to get some individual built in component up > and running aren't the same thing - what this'll do is get things up > more in the link order of the leaf consumers rather than deferring those > leaf consumers when their dependencies aren't ready yet. Thanks! I read too much into what was being improved. So this patch series, which on other merits may be a good idea, is as a by product solving a specific ordering issue, moving successful panel initialization to an earlier point in the boot sequence, if I now understand more correctly. In that context, this seems like yet another ad hoc way of causing the probe order to change in a way to solves one specific issue? Could it just as likely move the boot order of some other driver on some other board later, to the detriment of somebody else? > >> While not as dramatic as your results, they are somewhat supportive. >> What has changed your assessment that the on-demand device probing >> patches will give a big boot performance increase? Do you have >> new data or analysis? > > See above, my understanding was that the performance improvements were > more around improved control/predictability/handwave of the boot > ordering rather than total time. > -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Wed, Oct 21, 2015 at 11:18:08AM -0700, Frank Rowand wrote: > On 10/21/2015 9:27 AM, Mark Brown wrote: > > Overall boot time and time to get some individual built in component up > > and running aren't the same thing - what this'll do is get things up > > more in the link order of the leaf consumers rather than deferring those > > leaf consumers when their dependencies aren't ready yet. > Thanks! I read too much into what was being improved. > So this patch series, which on other merits may be a good idea, is as > a by product solving a specific ordering issue, moving successful panel > initialization to an earlier point in the boot sequence, if I now > understand more correctly. Yeah, that's my understanding. > In that context, this seems like yet another ad hoc way of causing the > probe order to change in a way to solves one specific issue? Could > it just as likely move the boot order of some other driver on some > other board later, to the detriment of somebody else? Indeed. My general feeling is that it does make the link order stuff more predictable and easier to work with and it does have other merits (in terms of the error reporting, though there's other ways to address that like the one Russell is proposing). signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Wed, Oct 21, 2015 at 1:18 PM, Frank Rowandwrote: > On 10/21/2015 9:27 AM, Mark Brown wrote: >> On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: >>> On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: >> To be clear, I was saying that this series should NOT affect total boot times much. >> >>> I'm confused. If I understood correctly, improving boot time was >>> the key justification for accepting this patch set. For example, >>> from "[PATCH v7 0/20] On-demand device probing": >>> >>>I have a problem with the panel on my Tegra Chromebook taking longer >>>than expected to be ready during boot (Stéphane Marchesin reported what >>>is basically the same issue in [0]), and have looked into ordered >>>probing as a better way of solving this than moving nodes around in the >>>DT or playing with initcall levels and linking order. >>> >>>... >>> >>>With this series I get the kernel to output to the panel in 0.5s, >>>instead of 2.8s. >> >> Overall boot time and time to get some individual built in component up >> and running aren't the same thing - what this'll do is get things up >> more in the link order of the leaf consumers rather than deferring those >> leaf consumers when their dependencies aren't ready yet. > > Thanks! I read too much into what was being improved. > > So this patch series, which on other merits may be a good idea, is as > a by product solving a specific ordering issue, moving successful panel > initialization to an earlier point in the boot sequence, if I now > understand more correctly. > > In that context, this seems like yet another ad hoc way of causing the > probe order to change in a way to solves one specific issue? Could > it just as likely move the boot order of some other driver on some > other board later, to the detriment of somebody else? Time to display on is important for many products. Having the console up as early as possible is another case. CAN bus is another. This is a real problem that is not just bad drivers. I don't think it is completely ad hoc. Given all devices are registered after drivers, drivers will still probe first in initcall level order and then link order AFAIK. We may not take (more) initcall level tweak hacks, but that is a much more simple change for downstream. Don't get me wrong, I'd really like to see a way to control order independent of initcall level. Rob -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 10/21/2015 2:12 PM, Rob Herring wrote: > On Wed, Oct 21, 2015 at 1:18 PM, Frank Rowandwrote: >> On 10/21/2015 9:27 AM, Mark Brown wrote: >>> On Wed, Oct 21, 2015 at 08:59:51AM -0700, Frank Rowand wrote: On 10/19/2015 5:34 AM, Tomeu Vizoso wrote: >>> > To be clear, I was saying that this series should NOT affect total > boot times much. >>> I'm confused. If I understood correctly, improving boot time was the key justification for accepting this patch set. For example, from "[PATCH v7 0/20] On-demand device probing": I have a problem with the panel on my Tegra Chromebook taking longer than expected to be ready during boot (Stéphane Marchesin reported what is basically the same issue in [0]), and have looked into ordered probing as a better way of solving this than moving nodes around in the DT or playing with initcall levels and linking order. ... With this series I get the kernel to output to the panel in 0.5s, instead of 2.8s. >>> >>> Overall boot time and time to get some individual built in component up >>> and running aren't the same thing - what this'll do is get things up >>> more in the link order of the leaf consumers rather than deferring those >>> leaf consumers when their dependencies aren't ready yet. >> >> Thanks! I read too much into what was being improved. >> >> So this patch series, which on other merits may be a good idea, is as >> a by product solving a specific ordering issue, moving successful panel >> initialization to an earlier point in the boot sequence, if I now >> understand more correctly. >> >> In that context, this seems like yet another ad hoc way of causing the >> probe order to change in a way to solves one specific issue? Could >> it just as likely move the boot order of some other driver on some >> other board later, to the detriment of somebody else? > > Time to display on is important for many products. Having the console > up as early as possible is another case. CAN bus is another. This is a > real problem that is not just bad drivers. Yes, I agree. What I am seeing is that there continues to be a need for the ability to explicitly order at least some driver initialization (at some granularity), despite the push back against explicit ordering that has been present in the past. > I don't think it is completely ad hoc. Given all devices are > registered after drivers, drivers will still probe first in initcall > level order and then link order AFAIK. We may not take (more) initcall > level tweak hacks, but that is a much more simple change for > downstream. Don't get me wrong, I'd really like to see a way to > control order independent of initcall level. > > Rob Yep, it is not directly ad hoc, just a fortunate side effect in this case. So just accidently ad hoc. :-) -Frank -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Wednesday, October 21, 2015 10:55:14 AM Geert Uytterhoeven wrote: > Hi Rafael, > > On Wed, Oct 21, 2015 at 1:34 AM, Rafael J. Wysockiwrote: > > On Tuesday, October 20, 2015 09:15:01 AM Rob Herring wrote: > >> On Tue, Oct 20, 2015 at 2:56 AM, Rafael J. Wysocki > >> wrote: > >> > ACPI uses platform devices too. In fact, ACPI device objects are > >> > enumerated as > >> > platform devices by default now. > >> > >> Okay, I should have grepped for that: > >> drivers/base/platform.c:ACPI_COMPANION_SET(>dev, > >> NULL); > >> drivers/base/platform.c:len = acpi_device_modalias(dev, buf, > >> PAGE_SIZE -1); > >> drivers/base/platform.c:rc = acpi_device_uevent_modalias(dev, env); > >> drivers/base/platform.c:/* Then try ACPI style match */ > >> drivers/base/platform.c:if (acpi_driver_match_device(dev, drv)) > >> > >> These are all cases which have DT version as well, so we're not really > >> all that different here. There's a few more for DT, but that probably > >> means you have just not hit the problems we have yet. For example, > >> what happens if you have an interrupt line in which the controller is > >> probed after the device connected to the interrupt line? That required > >> resolving irqs in platform_get_irq rather than using static resources > >> to support deferred probe. > > > > We don't have this particular problem, because the IRQ controllers are > > enumerated in a special way. > > What does "in a special way" mean? Can you please be more specific? > > Can you have interrupt controllers that depend on clocks, pin controllers, > and PM domains? Currently, there's no native way to represent those dependencies in ACPI. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tuesday, October 20, 2015 06:21:55 PM Tomeu Vizoso wrote: > On 20 October 2015 at 18:04, Alan Sternwrote: > > On Tue, 20 Oct 2015, Mark Brown wrote: > > > >> On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: > >> > >> > Furthermore, that applies only to devices that use synchronous suspend. > >> > Async suspend is becoming common, and there the only restrictions are > >> > parent-child relations plus whatever explicit requirements that drivers > >> > impose by calling device_pm_wait_for_dev(). > >> > >> Hrm, this is the first I'd noticed that feature though I see the initial > >> commit dates from January. > > > > Async suspend and device_pm_wait_for_dev() were added in January 2010, > > not 2015! > > > >> It looks like most of the users are PCs at > >> the minute but we should be using it more widely for embedded things, > >> there's definitely some cases I'm aware of where it will allow us to > >> remove some open coding. > >> > >> It does seem like we want to be feeding dependency information we > >> discover for probing way into the suspend dependencies... > > > > Rafael has been thinking about a way to do this systematically. > > Nothing concrete has emerged yet. > > This iteration of the series would make this quite easy, as > dependencies are calculated before probes are attempted: > > https://lkml.org/lkml/2015/6/17/311 Well, if you know how to represent "links" between devices, the mechanism introduced here doesn't really add much value, because in that case the core knows what the dependencies are in the first place and can only defer the probes that have to be deferred. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Sorry to enter this thread a bit late. About the number of probe deferred messages, I proposed a simple patch to reduce them: https://lkml.org/lkml/2013/8/20/218 I was wondering how many messages this patch could save... -- Ken ar c'hentañ | ** Breizh ha Linux atav! ** Jef | http://moinejf.free.fr/ -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Hi Rafael, On Wed, Oct 21, 2015 at 1:34 AM, Rafael J. Wysockiwrote: > On Tuesday, October 20, 2015 09:15:01 AM Rob Herring wrote: >> On Tue, Oct 20, 2015 at 2:56 AM, Rafael J. Wysocki >> wrote: >> > ACPI uses platform devices too. In fact, ACPI device objects are >> > enumerated as >> > platform devices by default now. >> >> Okay, I should have grepped for that: >> drivers/base/platform.c:ACPI_COMPANION_SET(>dev, NULL); >> drivers/base/platform.c:len = acpi_device_modalias(dev, buf, >> PAGE_SIZE -1); >> drivers/base/platform.c:rc = acpi_device_uevent_modalias(dev, env); >> drivers/base/platform.c:/* Then try ACPI style match */ >> drivers/base/platform.c:if (acpi_driver_match_device(dev, drv)) >> >> These are all cases which have DT version as well, so we're not really >> all that different here. There's a few more for DT, but that probably >> means you have just not hit the problems we have yet. For example, >> what happens if you have an interrupt line in which the controller is >> probed after the device connected to the interrupt line? That required >> resolving irqs in platform_get_irq rather than using static resources >> to support deferred probe. > > We don't have this particular problem, because the IRQ controllers are > enumerated in a special way. What does "in a special way" mean? Can you please be more specific? Can you have interrupt controllers that depend on clocks, pin controllers, and PM domains? Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- ge...@linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Monday, October 19, 2015 05:58:40 PM Rob Herring wrote: > On Mon, Oct 19, 2015 at 4:40 PM, Rafael J. Wysockiwrote: > > On Monday, October 19, 2015 10:58:25 AM Rob Herring wrote: > >> On Mon, Oct 19, 2015 at 10:29 AM, David Woodhouse > >> wrote: > >> > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: > >> >> > But the point I'm making is that we are working towards *fixing* that, > >> >> > and *not* using DT-specific code in places where we should be using > >> >> > the > >> >> > generic APIs. > >> >> > >> >> What is the plan for fixing things here? It's not obvious (at least to > >> >> me) that we don't want to have the subsystems having knowledge of how > >> >> they are bound to a specific firmware which is what you seem to imply > >> >> here. > >> > > >> > I don't know that there *is* a coherent plan here to address it all. > >> > > >> > Certainly, we *will* need subsystems to have firmware-specific > >> > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > >> > describe GPIO, and properties which reference GPIO pins are intended to > >> > work through that — while in DT, properties which reference GPIO pins > >> > will have different contents. They'll be compatible at the driver > >> > level, in the sense that there's a call to get a given GPIO given the > >> > property name, but the subsystems *will* be doing different things > >> > behind the scenes. > >> > > >> > My plan, such as it is, is to go through the leaf-node drivers which > >> > almost definitely *should* be firmware-agnostic, and convert those. And > >> > then take stock of what we have left, and work out what, if anything, > >> > still needs to be done. > >> > >> Many cases are already agnostic in the drivers in terms of the *_get() > >> functions. Some are DT specific, but probably because those subsystems > >> are new and DT only. In any case, I don't think these 1 line changes > >> do anything to make doing conversions here harder. > >> > >> >> It seems like we're going to have to refactor these bits of code when > >> >> they get generalised anyway so I'm not sure that the additional cost > >> >> here is that big. > >> > > >> > That's an acceptable answer — "we're adding legacy code here but we > >> > know it's going to be refactored anyway". If that's true, all it takes > >> > is a note in the commit comment to that effect. That's different from > >> > having not thought about it :) > >> > >> Considering at one point we did create a fwnode based API, we did > >> think about it. Plus there was little input from ACPI folks as to > >> whether the change was even useful for ACPI case. > > > > Well, sorry, but who was asking whom, specifically? > > You and linux-acpi have been copied on v2 and later of the entire > series I think. Yes, but it wasn't like a direct request, say "We need your input, so can you please have a look and BTW we want this in 4.4, so please do it ASAP". In which case I'd prioritize that before other things I needed to take care of. > > The underlying problem is present in ACPI too and we don't really have a > > good > > solution for it. We might benefit from a common one if it existed. > > The problem for DT is we don't generically know what are the > dependencies at a core level. We could know some or most dependencies > if phandles (links to other nodes) were typed, but they are not. If > the core had this information, we could simply control the device > creation to order probing. Instead, this information is encoded into > the bindings and binding parsing resides in the subsystems. That > parsing happens during probe of the client side and is done by the > subsystems (for common bindings). Since we already do the parsing at > this point, it is a convenient place to trigger the probe of the > dependency. Is ACPI going to be similar in this regard? It is similar in some ways. For example, if a device's functionality depends on an I2C resource (connection), the core doesn't know that at the device creation time at least in some cases. Same for GPIO, SPI, DMA engines etc. There is a _DEP object in ACPI that can be used by firmware to tell the OS about those dependencies, but there's no way in the driver core to use that information anyway today. > Fundamentally, it is a question of probe devices when their > dependencies are present or drivers ensure their dependencies are > ready. IIRC, init systems went thru a similar debate for service > dependencies. The probe ordering is not the entire picture, though. Even if you get the probe ordering right, the problem is going to show up in multiple other places: system suspend/resume, runtime PM, system shutdown, unbinding of drivers. In all of those cases it is necessary to handle things in a specific order if there is a dependency. > >> In any case, we're talking about adding 1 line. > > > > But also about making the driver core slighly OF-centric. > > How so? The one line is in DT
Re: [GIT PULL] On-demand device probing
On Tue, Oct 20, 2015 at 2:56 AM, Rafael J. Wysockiwrote: > On Monday, October 19, 2015 05:58:40 PM Rob Herring wrote: >> On Mon, Oct 19, 2015 at 4:40 PM, Rafael J. Wysocki >> wrote: >> > On Monday, October 19, 2015 10:58:25 AM Rob Herring wrote: >> >> On Mon, Oct 19, 2015 at 10:29 AM, David Woodhouse >> >> wrote: >> >> > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: >> >> >> > But the point I'm making is that we are working towards *fixing* >> >> >> > that, >> >> >> > and *not* using DT-specific code in places where we should be using >> >> >> > the >> >> >> > generic APIs. >> >> >> >> >> >> What is the plan for fixing things here? It's not obvious (at least to >> >> >> me) that we don't want to have the subsystems having knowledge of how >> >> >> they are bound to a specific firmware which is what you seem to imply >> >> >> here. >> >> > >> >> > I don't know that there *is* a coherent plan here to address it all. >> >> > >> >> > Certainly, we *will* need subsystems to have firmware-specific >> >> > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to >> >> > describe GPIO, and properties which reference GPIO pins are intended to >> >> > work through that — while in DT, properties which reference GPIO pins >> >> > will have different contents. They'll be compatible at the driver >> >> > level, in the sense that there's a call to get a given GPIO given the >> >> > property name, but the subsystems *will* be doing different things >> >> > behind the scenes. >> >> > >> >> > My plan, such as it is, is to go through the leaf-node drivers which >> >> > almost definitely *should* be firmware-agnostic, and convert those. And >> >> > then take stock of what we have left, and work out what, if anything, >> >> > still needs to be done. >> >> >> >> Many cases are already agnostic in the drivers in terms of the *_get() >> >> functions. Some are DT specific, but probably because those subsystems >> >> are new and DT only. In any case, I don't think these 1 line changes >> >> do anything to make doing conversions here harder. >> >> >> >> >> It seems like we're going to have to refactor these bits of code when >> >> >> they get generalised anyway so I'm not sure that the additional cost >> >> >> here is that big. >> >> > >> >> > That's an acceptable answer — "we're adding legacy code here but we >> >> > know it's going to be refactored anyway". If that's true, all it takes >> >> > is a note in the commit comment to that effect. That's different from >> >> > having not thought about it :) >> >> >> >> Considering at one point we did create a fwnode based API, we did >> >> think about it. Plus there was little input from ACPI folks as to >> >> whether the change was even useful for ACPI case. >> > >> > Well, sorry, but who was asking whom, specifically? >> >> You and linux-acpi have been copied on v2 and later of the entire >> series I think. > > Yes, but it wasn't like a direct request, say "We need your input, so can you > please have a look and BTW we want this in 4.4, so please do it ASAP". In > which case I'd prioritize that before other things I needed to take care of. Fair enough. Can you please review and comment on v7 of the series? We can discuss at KS as well. >> > The underlying problem is present in ACPI too and we don't really have a >> > good >> > solution for it. We might benefit from a common one if it existed. >> >> The problem for DT is we don't generically know what are the >> dependencies at a core level. We could know some or most dependencies >> if phandles (links to other nodes) were typed, but they are not. If >> the core had this information, we could simply control the device >> creation to order probing. Instead, this information is encoded into >> the bindings and binding parsing resides in the subsystems. That >> parsing happens during probe of the client side and is done by the >> subsystems (for common bindings). Since we already do the parsing at >> this point, it is a convenient place to trigger the probe of the >> dependency. Is ACPI going to be similar in this regard? > > It is similar in some ways. For example, if a device's functionality depends > on an I2C resource (connection), the core doesn't know that at the device > creation time at least in some cases. Same for GPIO, SPI, DMA engines etc. So you will need to create devices, defer their probing and then probe on demand as well unless you have other ideas how you would do it. > There is a _DEP object in ACPI that can be used by firmware to tell the OS > about those dependencies, but there's no way in the driver core to use that > information anyway today. I would think that the equivalent function for ACPI to of_device_probe could process these if they are generic and you can associate the dependency to a struct device. >> Fundamentally, it is a question of probe devices when their >> dependencies are present or drivers ensure
Re: [GIT PULL] On-demand device probing
On Tue, 20 Oct 2015, Rob Herring wrote: > > The probe ordering is not the entire picture, though. > > > > Even if you get the probe ordering right, the problem is going to show up in > > multiple other places: system suspend/resume, runtime PM, system shutdown, > > unbinding of drivers. In all of those cases it is necessary to handle > > things > > in a specific order if there is a dependency. > > My understanding was with deferred probe that it also solves suspend > ordering problems because things are suspended in reverse order of > probing. Devices are suspended in reverse order of _registration_. Not of probing. Furthermore, that applies only to devices that use synchronous suspend. Async suspend is becoming common, and there the only restrictions are parent-child relations plus whatever explicit requirements that drivers impose by calling device_pm_wait_for_dev(). Alan Stern -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tue, Oct 20, 2015 at 01:14:46PM -0400, Alan Stern wrote: > On Tue, 20 Oct 2015, Tomeu Vizoso wrote: > > This iteration of the series would make this quite easy, as > > dependencies are calculated before probes are attempted: > > https://lkml.org/lkml/2015/6/17/311 > But what Rafael is proposing is quite general; it would apply to _all_ > dependencies as opposed to just those present in DT drivers or those > affecting platform_devices. We'll still need most of the DT bits that are there at the minute (the ones strewn around the subsystems) AFAICT since it's at the point where we parse the DT and work out what the dependencies are which we probably want to do prior to getting the drivers up and will be different for ACPI. I think the level of DT dependency here looks a lot larger than it actually is due to the fact that a lot of what's being modified is DT parsing code. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Tue, 20 Oct 2015, Mark Brown wrote: > On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: > > > Furthermore, that applies only to devices that use synchronous suspend. > > Async suspend is becoming common, and there the only restrictions are > > parent-child relations plus whatever explicit requirements that drivers > > impose by calling device_pm_wait_for_dev(). > > Hrm, this is the first I'd noticed that feature though I see the initial > commit dates from January. Async suspend and device_pm_wait_for_dev() were added in January 2010, not 2015! > It looks like most of the users are PCs at > the minute but we should be using it more widely for embedded things, > there's definitely some cases I'm aware of where it will allow us to > remove some open coding. > > It does seem like we want to be feeding dependency information we > discover for probing way into the suspend dependencies... Rafael has been thinking about a way to do this systematically. Nothing concrete has emerged yet. Alan Stern -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tue, 20 Oct 2015, Tomeu Vizoso wrote: > On 20 October 2015 at 18:04, Alan Sternwrote: > > On Tue, 20 Oct 2015, Mark Brown wrote: > > > >> On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: > >> > >> > Furthermore, that applies only to devices that use synchronous suspend. > >> > Async suspend is becoming common, and there the only restrictions are > >> > parent-child relations plus whatever explicit requirements that drivers > >> > impose by calling device_pm_wait_for_dev(). > >> > >> Hrm, this is the first I'd noticed that feature though I see the initial > >> commit dates from January. > > > > Async suspend and device_pm_wait_for_dev() were added in January 2010, > > not 2015! > > > >> It looks like most of the users are PCs at > >> the minute but we should be using it more widely for embedded things, > >> there's definitely some cases I'm aware of where it will allow us to > >> remove some open coding. > >> > >> It does seem like we want to be feeding dependency information we > >> discover for probing way into the suspend dependencies... > > > > Rafael has been thinking about a way to do this systematically. > > Nothing concrete has emerged yet. > > This iteration of the series would make this quite easy, as > dependencies are calculated before probes are attempted: > > https://lkml.org/lkml/2015/6/17/311 But what Rafael is proposing is quite general; it would apply to _all_ dependencies as opposed to just those present in DT drivers or those affecting platform_devices. Alan Stern -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: Alternative approach to solve the deferred probe (was: [GIT PULL] On-demand device probing)
On Mon, Oct 19, 2015 at 06:21:40PM +0200, Geert Uytterhoeven wrote: > Hi Russell, > > On Mon, Oct 19, 2015 at 5:35 PM, Russell King - ARM Linux >wrote: > >> > What you can do is print those devices which have failed to probe at > >> > late_initcall() time - possibly augmenting that with reports from > >> > subsystems showing what resources are not available, but that's only > >> > a guide, because of the "it might or might not be in a kernel module" > >> > problem. > >> > >> Well, adding those reports would give you a changelog similar to the > >> one in this series... > > > > I'm not sure about that, because what I was thinking of is adding > > a flag which would be set at late_initcall() time prior to running > > a final round of deferred device probing. > > Which round is the final round? > That's the one which didn't manage to bind any new devices to drivers, > which is something you only know _after_ the round has been run. > > So I think we need one extra round to handle this. > > > This flag would then be used in a deferred_warn() printk function > > which would normally be silent, but when this flag is set, it would > > print the reason for the deferral - and this would replace (or be > > added) to the subsystems and drivers which return -EPROBE_DEFER. > > > > That has the effect of hiding all the deferrals up until just before > > launching into userspace, which should then acomplish two things - > > firstly, getting rid of the rather useless deferred messages up to > > that point, and secondly printing the reason why the remaining > > deferrals are happening. > > > > That should be a small number of new lines plus a one-line change > > in subsystems and drivers. > > Apart from the extra round we probably can't get rid of, that sounds OK to me. Something like this. I haven't put a lot of effort into it to change all the places which return an -EPROBE_DEFER, and it also looks like we need some helpers to report when we have only an device_node (or should that be fwnode?) See the commented out of_warn_deferred() in drivers/gpio/gpiolib-of.c. Adding this stuff in the subsystems searching for resources should make debugging why things are getting deferred easier. We could make driver_deferred_probe_report something that can be deactivated again after the last deferred probe run, and provide the user with a knob that they can turn it back on again. I've tried this out on two of my platforms, including forcing driver_deferred_probe_report to be enabled, and I get exactly one deferred probe, so not a particularly good test. The patch won't apply as-is to mainline for all files; it's based on my tree which has some 360 additional patches (which seems to be about normal for my tree now.) drivers/base/dd.c | 29 + drivers/base/power/domain.c | 7 +-- drivers/clk/clkdev.c| 9 - drivers/gpio/gpiolib-of.c | 5 + drivers/gpu/drm/bridge/dw_hdmi.c| 2 +- drivers/gpu/drm/exynos/exynos_drm_dsi.c | 2 +- drivers/gpu/drm/imx/imx-ldb.c | 5 +++-- drivers/gpu/drm/msm/dsi/dsi.c | 2 +- drivers/gpu/drm/msm/msm_drv.c | 3 ++- drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 3 ++- drivers/of/irq.c| 5 - drivers/pci/host/pci-mvebu.c| 1 + drivers/pinctrl/core.c | 5 +++-- drivers/pinctrl/devicetree.c| 4 ++-- drivers/regulator/core.c| 5 +++-- include/linux/device.h | 1 + 16 files changed, 71 insertions(+), 17 deletions(-) diff --git a/drivers/base/dd.c b/drivers/base/dd.c index be0eb4639128..bb12224f2901 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -129,7 +129,29 @@ void driver_deferred_probe_del(struct device *dev) mutex_unlock(_probe_mutex); } +static bool driver_deferred_probe_report; + +/** + * dev_warn_deferred() - report why a probe has been deferred + */ +void dev_warn_deferred(struct device *dev, const char *fmt, ...) +{ + if (driver_deferred_probe_report) { + struct va_format vaf; + va_list ap; + + va_start(ap, fmt); + vaf.fmt = fmt; + vaf.va = + + dev_warn(dev, "deferring probe: %pV", ); + va_end(ap); + } +} +EXPORT_SYMBOL_GPL(dev_warn_deferred); + static bool driver_deferred_probe_enable = false; + /** * driver_deferred_probe_trigger() - Kick off re-probing deferred devices * @@ -188,6 +210,13 @@ static int deferred_probe_initcall(void) driver_deferred_probe_trigger(); /* Sort as many dependencies as possible before exiting initcalls */ flush_workqueue(deferred_wq); + + /* Now one final round, reporting any devices that remain deferred */ + driver_deferred_probe_report = true; + driver_deferred_probe_trigger(); + /* Sort as many
Re: [GIT PULL] On-demand device probing
On 20 October 2015 at 18:04, Alan Sternwrote: > On Tue, 20 Oct 2015, Mark Brown wrote: > >> On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: >> >> > Furthermore, that applies only to devices that use synchronous suspend. >> > Async suspend is becoming common, and there the only restrictions are >> > parent-child relations plus whatever explicit requirements that drivers >> > impose by calling device_pm_wait_for_dev(). >> >> Hrm, this is the first I'd noticed that feature though I see the initial >> commit dates from January. > > Async suspend and device_pm_wait_for_dev() were added in January 2010, > not 2015! > >> It looks like most of the users are PCs at >> the minute but we should be using it more widely for embedded things, >> there's definitely some cases I'm aware of where it will allow us to >> remove some open coding. >> >> It does seem like we want to be feeding dependency information we >> discover for probing way into the suspend dependencies... > > Rafael has been thinking about a way to do this systematically. > Nothing concrete has emerged yet. This iteration of the series would make this quite easy, as dependencies are calculated before probes are attempted: https://lkml.org/lkml/2015/6/17/311 Regards, Tomeu > Alan Stern > > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majord...@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/ -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tue, Oct 20, 2015 at 10:40:03AM -0400, Alan Stern wrote: > Furthermore, that applies only to devices that use synchronous suspend. > Async suspend is becoming common, and there the only restrictions are > parent-child relations plus whatever explicit requirements that drivers > impose by calling device_pm_wait_for_dev(). Hrm, this is the first I'd noticed that feature though I see the initial commit dates from January. It looks like most of the users are PCs at the minute but we should be using it more widely for embedded things, there's definitely some cases I'm aware of where it will allow us to remove some open coding. It does seem like we want to be feeding dependency information we discover for probing way into the suspend dependencies... signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Tuesday, October 20, 2015 09:15:01 AM Rob Herring wrote: > On Tue, Oct 20, 2015 at 2:56 AM, Rafael J. Wysockiwrote: > > On Monday, October 19, 2015 05:58:40 PM Rob Herring wrote: > >> On Mon, Oct 19, 2015 at 4:40 PM, Rafael J. Wysocki > >> wrote: > >> > On Monday, October 19, 2015 10:58:25 AM Rob Herring wrote: > >> >> On Mon, Oct 19, 2015 at 10:29 AM, David Woodhouse > >> >> wrote: > >> >> > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: > >> >> >> > But the point I'm making is that we are working towards *fixing* > >> >> >> > that, > >> >> >> > and *not* using DT-specific code in places where we should be > >> >> >> > using the > >> >> >> > generic APIs. > >> >> >> > >> >> >> What is the plan for fixing things here? It's not obvious (at least > >> >> >> to > >> >> >> me) that we don't want to have the subsystems having knowledge of how > >> >> >> they are bound to a specific firmware which is what you seem to imply > >> >> >> here. > >> >> > > >> >> > I don't know that there *is* a coherent plan here to address it all. > >> >> > > >> >> > Certainly, we *will* need subsystems to have firmware-specific > >> >> > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > >> >> > describe GPIO, and properties which reference GPIO pins are intended > >> >> > to > >> >> > work through that — while in DT, properties which reference GPIO pins > >> >> > will have different contents. They'll be compatible at the driver > >> >> > level, in the sense that there's a call to get a given GPIO given the > >> >> > property name, but the subsystems *will* be doing different things > >> >> > behind the scenes. > >> >> > > >> >> > My plan, such as it is, is to go through the leaf-node drivers which > >> >> > almost definitely *should* be firmware-agnostic, and convert those. > >> >> > And > >> >> > then take stock of what we have left, and work out what, if anything, > >> >> > still needs to be done. > >> >> > >> >> Many cases are already agnostic in the drivers in terms of the *_get() > >> >> functions. Some are DT specific, but probably because those subsystems > >> >> are new and DT only. In any case, I don't think these 1 line changes > >> >> do anything to make doing conversions here harder. > >> >> > >> >> >> It seems like we're going to have to refactor these bits of code when > >> >> >> they get generalised anyway so I'm not sure that the additional cost > >> >> >> here is that big. > >> >> > > >> >> > That's an acceptable answer — "we're adding legacy code here but we > >> >> > know it's going to be refactored anyway". If that's true, all it takes > >> >> > is a note in the commit comment to that effect. That's different from > >> >> > having not thought about it :) > >> >> > >> >> Considering at one point we did create a fwnode based API, we did > >> >> think about it. Plus there was little input from ACPI folks as to > >> >> whether the change was even useful for ACPI case. > >> > > >> > Well, sorry, but who was asking whom, specifically? > >> > >> You and linux-acpi have been copied on v2 and later of the entire > >> series I think. > > > > Yes, but it wasn't like a direct request, say "We need your input, so can > > you > > please have a look and BTW we want this in 4.4, so please do it ASAP". In > > which case I'd prioritize that before other things I needed to take care of. > > Fair enough. Can you please review and comment on v7 of the series? We > can discuss at KS as well. I'll do that. I'm in the middle of travel right now and speaking at a conference tomorrow, so I may not be able to get to that for a couple of days, but will do my best to do it as soon as I possibly can. > >> > The underlying problem is present in ACPI too and we don't really have a > >> > good > >> > solution for it. We might benefit from a common one if it existed. > >> > >> The problem for DT is we don't generically know what are the > >> dependencies at a core level. We could know some or most dependencies > >> if phandles (links to other nodes) were typed, but they are not. If > >> the core had this information, we could simply control the device > >> creation to order probing. Instead, this information is encoded into > >> the bindings and binding parsing resides in the subsystems. That > >> parsing happens during probe of the client side and is done by the > >> subsystems (for common bindings). Since we already do the parsing at > >> this point, it is a convenient place to trigger the probe of the > >> dependency. Is ACPI going to be similar in this regard? > > > > It is similar in some ways. For example, if a device's functionality > > depends > > on an I2C resource (connection), the core doesn't know that at the device > > creation time at least in some cases. Same for GPIO, SPI, DMA engines etc. > > So you will need to create devices, defer their probing and then probe > on demand as well unless you have other ideas how
Re: [GIT PULL] On-demand device probing
On Tuesday, October 20, 2015 08:35:28 PM Mark Brown wrote: > > --7fVr/IRGAG9sAW4J > Content-Type: text/plain; charset=us-ascii > Content-Disposition: inline > Content-Transfer-Encoding: quoted-printable > > On Tue, Oct 20, 2015 at 01:14:46PM -0400, Alan Stern wrote: > > On Tue, 20 Oct 2015, Tomeu Vizoso wrote: > > > > This iteration of the series would make this quite easy, as > > > dependencies are calculated before probes are attempted: > > > > https://lkml.org/lkml/2015/6/17/311 > > > But what Rafael is proposing is quite general; it would apply to _all_ > > dependencies as opposed to just those present in DT drivers or those=20 > > affecting platform_devices. > > We'll still need most of the DT bits that are there at the minute (the > ones strewn around the subsystems) AFAICT since it's at the point where > we parse the DT and work out what the dependencies are which we probably > want to do prior to getting the drivers up and will be different for > ACPI. I think the level of DT dependency here looks a lot larger than > it actually is due to the fact that a lot of what's being modified is DT > parsing code. Right, something will have to register the dependency, or a "link" between devices, with the core once we find out that the dependency is there. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 18 October 2015 at 21:53, Mark Brownwrote: > On Sun, Oct 18, 2015 at 12:37:57PM -0700, Greg Kroah-Hartman wrote: >> On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: >> > On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: > >> > > I can't see adding calls like this all over the tree just to solve a >> > > bus-specific problem, you are adding of_* calls where they aren't >> > > needed, or wanted, at all. > >> > This isn't bus specific, I'm not sure what makes you say that? > >> You are making it bus-specific by putting these calls all over the tree >> in different bus subsystems semi-randomly for all I can determine. > > Do you mean firmware rather than bus here? I think that's the confusion > I have... Hi all, hope you don't mind I summarize the points taken instead of replying to the individual emails. I tried to address all the concerns that have been raised again in the cover letter, but I guess I did a bad job at explaining myself, so here's another (more in-depth) go at it. 1) About the sprinkling of calls, everybody agreed it's a bad smell from the start, but the intention is to modify the behaviour of the already-DT-specific part of each subsystem without duplicating code. A way to avoid the sprinkling would be to move the storage and lookup of resources to the core (using classes and their list of devices to replace the likes of __of_usb_find_phy). I also like Mark's idea of calling of_device_probe from of_parse_phandle, which would be much less invasive but I'm not sure if it would be right to call that function in all the current cases in which of_parse_phandle is called. 2) About the goal of the series, what matters to my employer is that once a device defers its probe it's only going to be reprobed in late_initcall, after all the devices have been tentatively probed once. In the practice this means that devices get probed in a dependency order in which first go devices without dependencies then go up the tree until the leave devices (which tend to be the ones with effects visible to the user). This series changes to another dependency order in which when a leaf node gets probed, it recursively "pulls" its dependencies. This way we stop massively delaying the probing of the display devices and vendors can stop carrying sizeable hacks in their trees which just further reduce the incentive to upstream. The above is what funds this work, but in my personal opinion the biggest advantage of this work is that it makes development on embedded platforms more efficient because right now we don't have a way of telling if a device deferred its probe because of an ordering issue, or because there's a problem. If a device is available and has a compatible driver, but it cannot be probed because a dependency isn't going to be available, that's an error and is going to cause real-world problems unless the device is redundant. Currently we say nothing because with deferred probe the probe callbacks are also part of the mechanism that determines the dependency order. I have wasted countless hours hunting for the reason why a device didn't probe and I have heard the same several times from others. Having a specific switch for enabling deferred probe logging sounds good, but there's going to be hundreds of spurious messages about deferred probes that were just deferrals and only one of them is going to be the actual error in which a device failed to find a dependency. 3) Regarding total boot time, I don't expect this series to make much of a difference because though we would save a lot of matching and querying for resources, that's little time compared with how long we wait for hardware to react during probing. Async probing is more likely to help with drivers that take a long time to probe. 4) About the breakage we have seen, that's not caused so far by probing devices on-demand but by delaying probes until all built-in drivers have been registered. The latter isn't strictly needed for on-demand probing but without it most of the benefits are lost because probes of dependencies are going to be deferred because the drivers aren't there yet. We could avoid that by registering drivers also on-demand but we would need to make the matching information available beforehand, which is a massive change in itself. This should speed up boot some, and also cause leaf devices to be up earlier. One more thing about the breakage we have seen so far is that it's generally caused by implicit dependencies and hunting those is probably the second biggest timesink of the linux embedded developer after failed probes. We depend on hacks such as link order, node order in the DT, initcall gerrymandering and a blind hope in things that started some time ago to have finished by now. And those implicit dependencies are often left completely undocumented. This is really fragile and breaks often when changing something unrelated such as when adding another revision of a board
Re: [GIT PULL] On-demand device probing
On Mon, 2015-10-19 at 07:35 -0500, Rob Herring wrote: > > > Certainly, if it literally is adding of_* calls then that would seem to > > be gratuitously firmware-specific. Nothing should be using those these > > days; any new code should be using the generic device property APIs > > (except in special cases). > > See version 2 of the series[1] which did that. It became obvious that > was pointless because the call paths ended up looking like this: > > Generic subsystem code -> DT look-up code -> fwnode_probe_device -> > of_probe_device You link to a thread which says that "AT LEAST CURRENTLY, the calling locations [the 'DT look-up code' you mention above] are DT specific functions anyway. But the point I'm making is that we are working towards *fixing* that, and *not* using DT-specific code in places where we should be using the generic APIs. Sure, Russell is probably right that there are some places where the generic APIs need fixing because they don't quite cover all use cases yet. And Mark is (unfortunately) right that some people are inventing new bindings *purely* for ACPI which are different to the DT bindings for the same device. But still, in those cases you'll theoretically be able to see the *same* device represented under ACPI with *either* its new ACPI HID and the ACPI-specific bindings, *or* as a PRP0001 with the DT bindings. And this was always possible even with just DT — you could have two incompatible bindings for the *same* hardware, with different drivers. It was just a bad thing. And still is when one is ACPI and one is DT, in my opinion. None of that really negates that fact that we are *working* on cleaning these code paths up to be firmware-agnostic, and the fact that we haven't got to this one *yet* isn't necessarily a good reason to make it *worse* by adding new firmware-specificity to it. -- dwmw2 smime.p7s Description: S/MIME cryptographic signature
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 10:44:41AM +0100, David Woodhouse wrote: > On Sun, 2015-10-18 at 20:53 +0100, Mark Brown wrote: > > Do you mean firmware rather than bus here? I think that's the confusion > > I have... > Certainly, if it literally is adding of_* calls then that would seem to > be gratuitously firmware-specific. Nothing should be using those these > days; any new code should be using the generic device property APIs > (except in special cases). It's not entirely clear to me that we should be moving to fwnode_ wholesale yet - the last advice was to hold off for a little while which makes sense given that the ACPI community still doesn't seem to have worked out what it wants to do here and how. The x86 embedded people are all gung ho but it's less clear that anyone else wants to use _DSD in quite the same way (I know of some efforts to use _DSD separately to the DT compatibility stuff) and there are some vendors who definitely do have completely different binding schemes for ACPI and DT and therefore specifically care which is in use. It would really help if ACPI could get their binding review process in place, and if we do want to actually start converting everything to fwnode_ we need to start communicating that actively since otherwise people can't really be expected to know. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 4:44 AM, David Woodhousewrote: > On Sun, 2015-10-18 at 20:53 +0100, Mark Brown wrote: >> On Sun, Oct 18, 2015 at 12:37:57PM -0700, Greg Kroah-Hartman wrote: >> > On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: >> > > On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: >> >> > > > I can't see adding calls like this all over the tree just to solve a >> > > > bus-specific problem, you are adding of_* calls where they aren't >> > > > needed, or wanted, at all. >> >> > > This isn't bus specific, I'm not sure what makes you say that? >> >> > You are making it bus-specific by putting these calls all over the tree >> > in different bus subsystems semi-randomly for all I can determine. >> >> Do you mean firmware rather than bus here? I think that's the confusion >> I have... > > Certainly, if it literally is adding of_* calls then that would seem to > be gratuitously firmware-specific. Nothing should be using those these > days; any new code should be using the generic device property APIs > (except in special cases). See version 2 of the series[1] which did that. It became obvious that was pointless because the call paths ended up looking like this: Generic subsystem code -> DT look-up code -> fwnode_probe_device -> of_probe_device Rob [1] http://lists.infradead.org/pipermail/linux-arm-kernel/2015-July/361137.html -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sun, 2015-10-18 at 20:53 +0100, Mark Brown wrote: > On Sun, Oct 18, 2015 at 12:37:57PM -0700, Greg Kroah-Hartman wrote: > > On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: > > > On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: > > > > > I can't see adding calls like this all over the tree just to solve a > > > > bus-specific problem, you are adding of_* calls where they aren't > > > > needed, or wanted, at all. > > > > This isn't bus specific, I'm not sure what makes you say that? > > > You are making it bus-specific by putting these calls all over the tree > > in different bus subsystems semi-randomly for all I can determine. > > Do you mean firmware rather than bus here? I think that's the confusion > I have... Certainly, if it literally is adding of_* calls then that would seem to be gratuitously firmware-specific. Nothing should be using those these days; any new code should be using the generic device property APIs (except in special cases). -- dwmw2 smime.p7s Description: S/MIME cryptographic signature
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 02:34:22PM +0200, Tomeu Vizoso wrote: > ... If a device is available and has > a compatible driver, but it cannot be probed because a dependency > isn't going to be available, that's an error and is going to cause > real-world problems unless the device is redundant. Currently we say > nothing because with deferred probe the probe callbacks are also part > of the mechanism that determines the dependency order. So what if device X depends on device Y, and we have a driver for device Y built-in to the kernel, but the driver for device X is a module? I don't see this being solvable in the way you describe above - it's going to identify X as being unable to be satisfied, and report it as an error - but it's not an error at all. > Having a specific switch for enabling deferred probe logging sounds > good, but there's going to be hundreds of spurious messages about > deferred probes that were just deferrals and only one of them is going > to be the actual error in which a device failed to find a dependency. Why would there be? Sounds like something's very wrong there. You should only get deferred probes for devices which are declared to be present, but their resources have not yet been satisfied. It doesn't change anything if you have a kernel with lots of device drivers or just the device drivers you need - the device drivers you don't need do not contribute to the deferred probing in any way. So, really, after boot and all appropriate modules have been loaded, you should end up with no deferred probes. Are you saying that you still have "hundreds" at that point? If you do, that sounds like there's something very wrong. > 3) Regarding total boot time, I don't expect this series to make much > of a difference because though we would save a lot of matching and > querying for resources, that's little time compared with how long we > wait for hardware to react during probing. Async probing is more > likely to help with drivers that take a long time to probe. For me, on my fastest ARM board, though running serial console: [2.293468] VFS: Mounted root (ext4 filesystem) on device 179:1. There's a couple of delays in there, but they're not down to deferred probing. The biggest one is serial console startup (due to the time it takes to write out the initial kernel messages): [0.289962] f1012000.serial: ttyS0 at MMIO 0xf1012000 (irq = 23, base_baud = 15625000) is a 16550A [0.944124] console [ttyS0] enabled and DSA switch initialisation: [1.530655] libphy: dsa slave smi: probed [2.034426] dsa dsa@0 lan6 (uninitialized): attached PHY at address 0 [Generic PHY] I'm not sure what causes that, but at a guess it's having to talk to the DSA switch over the MDIO bus via several layers of indirect accesses. Of course, serial console adds to the boot time significantly anyway, especially at the "standard" kernel logging level. > One more thing about the breakage we have seen so far is that it's > generally caused by implicit dependencies and hunting those is > probably the second biggest timesink of the linux embedded developer > after failed probes. ... which is generally caused by the crappy code which the average embedded Linux developer creates, particularly with the crappy error messages they like creating. For the most part, they _might_ as well just print "Error!\n" and be done with it, for all the use they are. When creating an error print, your average embedded Linux developer fails to print the _reason_ why something failed, which makes debugging it much harder. The first thing I do when I touch code that needs this kind of debugging is to go through and add printing of the error code. That normally lets me quickly narrow down what's failed. If embedded Linux developers are struggling with this, they only have themselves to blame. In the case of deferred probing, what _may_ help is if we got rid of the core code printing that driver X requested deferred probing, instead moving the responsibility to report this onto the driver or subsystem. Resource claiming generally has the struct device, and can use dev_warn() to report which device is being probed, along with which resource is not yet available. This debug problem is solvable without needing to resort to complex probing solutions. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On 19 October 2015 at 15:18, Russell King - ARM Linuxwrote: > On Mon, Oct 19, 2015 at 02:34:22PM +0200, Tomeu Vizoso wrote: >> ... If a device is available and has >> a compatible driver, but it cannot be probed because a dependency >> isn't going to be available, that's an error and is going to cause >> real-world problems unless the device is redundant. Currently we say >> nothing because with deferred probe the probe callbacks are also part >> of the mechanism that determines the dependency order. > > So what if device X depends on device Y, and we have a driver for > device Y built-in to the kernel, but the driver for device X is a > module? > > I don't see this being solvable in the way you describe above - it's > going to identify X as being unable to be satisfied, and report it as > an error - but it's not an error at all. It's going to probe Y at late_initcall, then probe X when its driver is registered. No deferred probes nor messages about it. But if you meant to write the opposite case (X built-in and Y in a module), then I have to ask you in what situation that would make sense. >> Having a specific switch for enabling deferred probe logging sounds >> good, but there's going to be hundreds of spurious messages about >> deferred probes that were just deferrals and only one of them is going >> to be the actual error in which a device failed to find a dependency. > > Why would there be? Sounds like something's very wrong there. Sorry about that, I have checked that only now and I "only" get 39 deferred probe messages on exynos5250-snow. > You should only get deferred probes for devices which are declared to > be present, but their resources have not yet been satisfied. It > doesn't change anything if you have a kernel with lots of device drivers > or just the device drivers you need - the device drivers you don't need > do not contribute to the deferred probing in any way. I don't think that the number of registered drivers affects the number of probes that get deferred (but I'm not sure why you mention that). > So, really, after boot and all appropriate modules have been loaded, > you should end up with no deferred probes. Are you saying that you > still have "hundreds" at that point? If you do, that sounds like > there's something very wrong. I was talking about messages if we log each -EPROBE_DEFER, not devices that remain to be probed. The point being that right now we don't have a way to know if we are deferring because the dependency will be around later, or if we have a problem and the dependency isn't going to be there at all. If we had a way to enable printing the cause of each -EPROBE_DEFER, right now that would print 39 messages of this board that are only due to ordering. The actual issue would be printed in exactly the same way somewhere in the middle. >> 3) Regarding total boot time, I don't expect this series to make much >> of a difference because though we would save a lot of matching and >> querying for resources, that's little time compared with how long we >> wait for hardware to react during probing. Async probing is more >> likely to help with drivers that take a long time to probe. > > For me, on my fastest ARM board, though running serial console: > > [2.293468] VFS: Mounted root (ext4 filesystem) on device 179:1. > > There's a couple of delays in there, but they're not down to deferred > probing. The biggest one is serial console startup (due to the time > it takes to write out the initial kernel messages): > > [0.289962] f1012000.serial: ttyS0 at MMIO 0xf1012000 (irq = 23, base_baud > = 15625000) is a 16550A > [0.944124] console [ttyS0] enabled > > and DSA switch initialisation: > > [1.530655] libphy: dsa slave smi: probed > [2.034426] dsa dsa@0 lan6 (uninitialized): attached PHY at address 0 > [Generic PHY] > > I'm not sure what causes that, but at a guess it's having to talk to the > DSA switch over the MDIO bus via several layers of indirect accesses. > Of course, serial console adds to the boot time significantly anyway, > especially at the "standard" kernel logging level. Yes, I don't think it makes any sense to measure boot times with the serial console on, because it's not comparable to production and because printing an additional line during boot affects significantly the times. To be clear, I was saying that this series should NOT affect total boot times much. >> One more thing about the breakage we have seen so far is that it's >> generally caused by implicit dependencies and hunting those is >> probably the second biggest timesink of the linux embedded developer >> after failed probes. > > ... which is generally caused by the crappy code which the average > embedded Linux developer creates, particularly with the crappy error > messages they like creating. For the most part, they _might_ as well > just print "Error!\n" and be done with it, for all the use they are. > When creating an error
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 04:10:56PM +0200, Tomeu Vizoso wrote: > On 19 October 2015 at 15:18, Russell King - ARM Linux >wrote: > > On Mon, Oct 19, 2015 at 02:34:22PM +0200, Tomeu Vizoso wrote: > >> ... If a device is available and has > >> a compatible driver, but it cannot be probed because a dependency > >> isn't going to be available, that's an error and is going to cause > >> real-world problems unless the device is redundant. Currently we say > >> nothing because with deferred probe the probe callbacks are also part > >> of the mechanism that determines the dependency order. > > > > So what if device X depends on device Y, and we have a driver for > > device Y built-in to the kernel, but the driver for device X is a > > module? > > > > I don't see this being solvable in the way you describe above - it's > > going to identify X as being unable to be satisfied, and report it as > > an error - but it's not an error at all. > > It's going to probe Y at late_initcall, then probe X when its driver > is registered. No deferred probes nor messages about it. > > But if you meant to write the opposite case (X built-in and Y in a > module), then I have to ask you in what situation that would make > sense. I did mean the opposite way around. It may not make sense if you're targetting a single platform, but it may make sense in a single zImage kernel. Consider something like a single zImage kernel that is built with everything built-in to be able to boot and mount rootfs without initramfs support on both platform A and platform B. Both platforms share some hardware (eg, an I2C GPIO expander) which is built as a module. It is a resource provider. Platform B contains a driver which is required to boot on platform A, but not platform B (so the kernel has to have that driver built-in.) On platform B, there is a dependency to the I2C GPIO expander device. > >> Having a specific switch for enabling deferred probe logging sounds > >> good, but there's going to be hundreds of spurious messages about > >> deferred probes that were just deferrals and only one of them is going > >> to be the actual error in which a device failed to find a dependency. > > > > Why would there be? Sounds like something's very wrong there. > > Sorry about that, I have checked that only now and I "only" get 39 > deferred probe messages on exynos5250-snow. I typically see one or two, maybe five maximum on the platforms I have here, but normally zero. > > So, really, after boot and all appropriate modules have been loaded, > > you should end up with no deferred probes. Are you saying that you > > still have "hundreds" at that point? If you do, that sounds like > > there's something very wrong. > > I was talking about messages if we log each -EPROBE_DEFER, not devices > that remain to be probed. The point being that right now we don't have > a way to know if we are deferring because the dependency will be > around later, or if we have a problem and the dependency isn't going > to be there at all. What's the difference between a dependency which isn't around because the driver is not built into the kernel but is available as a module, and a dependency that isn't around because the module hasn't been loaded yet? How do you distinguish between those two scenarios? In the former scenario, the device will eventually come up when udev loads the module. In the latter case, it's a persistent failing case. > Agreed, with the note from above on why it would be better to only > print such a message only when the -EPROBE_DEFER is likely to be a > problem. ... and my argument is that there's _no way_ to know for certain which deferred probes will be a problem, and which won't. The only way to definitely know that is if you disable kernel modules, and require all drivers to be built into the kernel. What you can do is print those devices which have failed to probe at late_initcall() time - possibly augmenting that with reports from subsystems showing what resources are not available, but that's only a guide, because of the "it might or might not be in a kernel module" problem. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 01:47:50PM +0100, David Woodhouse wrote: > On Mon, 2015-10-19 at 07:35 -0500, Rob Herring wrote: > > See version 2 of the series[1] which did that. It became obvious that > > was pointless because the call paths ended up looking like this: > > Generic subsystem code -> DT look-up code -> fwnode_probe_device -> > > of_probe_device > You link to a thread which says that "AT LEAST CURRENTLY, the calling > locations [the 'DT look-up code' you mention above] are DT specific > functions anyway. > But the point I'm making is that we are working towards *fixing* that, > and *not* using DT-specific code in places where we should be using the > generic APIs. What is the plan for fixing things here? It's not obvious (at least to me) that we don't want to have the subsystems having knowledge of how they are bound to a specific firmware which is what you seem to imply here. That seems like it's going to fall down since the different firmware interfaces do have quite different ideas about how things fit together at a system level and different compatibility needs which do suggest that just trying to do a direct mapping from DT into ACPI may well not make people happy but it sounds like that's the intention. When it gets to drivers the situation is much more clear since it's normally just simple properties, it's generally a bit more worrying if drivers are needing to directly interact with cross-device linkage. This is all subsystem level code though. > None of that really negates that fact that we are *working* on cleaning > these code paths up to be firmware-agnostic, and the fact that we > haven't got to this one *yet* isn't necessarily a good reason to make > it *worse* by adding new firmware-specificity to it. It seems like we're going to have to refactor these bits of code when they get generalised anyway so I'm not sure that the additional cost here is that big. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: > > But the point I'm making is that we are working towards *fixing* that, > > and *not* using DT-specific code in places where we should be using the > > generic APIs. > > What is the plan for fixing things here? It's not obvious (at least to > me) that we don't want to have the subsystems having knowledge of how > they are bound to a specific firmware which is what you seem to imply > here. I don't know that there *is* a coherent plan here to address it all. Certainly, we *will* need subsystems to have firmware-specific knowledge in some cases. Take GPIO as an example; ACPI *has* a way to describe GPIO, and properties which reference GPIO pins are intended to work through that — while in DT, properties which reference GPIO pins will have different contents. They'll be compatible at the driver level, in the sense that there's a call to get a given GPIO given the property name, but the subsystems *will* be doing different things behind the scenes. My plan, such as it is, is to go through the leaf-node drivers which almost definitely *should* be firmware-agnostic, and convert those. And then take stock of what we have left, and work out what, if anything, still needs to be done. > It seems like we're going to have to refactor these bits of code when > they get generalised anyway so I'm not sure that the additional cost > here is that big. That's an acceptable answer — "we're adding legacy code here but we know it's going to be refactored anyway". If that's true, all it takes is a note in the commit comment to that effect. That's different from having not thought about it :) -- dwmw2 smime.p7s Description: S/MIME cryptographic signature
Re: [GIT PULL] On-demand device probing
On 19 October 2015 at 16:30, Russell King - ARM Linuxwrote: > On Mon, Oct 19, 2015 at 04:10:56PM +0200, Tomeu Vizoso wrote: >> On 19 October 2015 at 15:18, Russell King - ARM Linux >> wrote: >> > On Mon, Oct 19, 2015 at 02:34:22PM +0200, Tomeu Vizoso wrote: >> >> ... If a device is available and has >> >> a compatible driver, but it cannot be probed because a dependency >> >> isn't going to be available, that's an error and is going to cause >> >> real-world problems unless the device is redundant. Currently we say >> >> nothing because with deferred probe the probe callbacks are also part >> >> of the mechanism that determines the dependency order. >> > >> > So what if device X depends on device Y, and we have a driver for >> > device Y built-in to the kernel, but the driver for device X is a >> > module? >> > >> > I don't see this being solvable in the way you describe above - it's >> > going to identify X as being unable to be satisfied, and report it as >> > an error - but it's not an error at all. >> >> It's going to probe Y at late_initcall, then probe X when its driver >> is registered. No deferred probes nor messages about it. >> >> But if you meant to write the opposite case (X built-in and Y in a >> module), then I have to ask you in what situation that would make >> sense. > > I did mean the opposite way around. It may not make sense if you're > targetting a single platform, but it may make sense in a single zImage > kernel. > > Consider something like a single zImage kernel that is built with > everything built-in to be able to boot and mount rootfs without > initramfs support on both platform A and platform B. Both platforms > share some hardware (eg, an I2C GPIO expander) which is built as a > module. It is a resource provider. Platform B contains a driver > which is required to boot on platform A, but not platform B (so the > kernel has to have that driver built-in.) On platform B, there is > a dependency to the I2C GPIO expander device. I see, in this situation the person trying to find out why some device hadn't probed would enable debug logging of failed probes and would see one spurious message if there was a deferred probe because of the module. >> >> Having a specific switch for enabling deferred probe logging sounds >> >> good, but there's going to be hundreds of spurious messages about >> >> deferred probes that were just deferrals and only one of them is going >> >> to be the actual error in which a device failed to find a dependency. >> > >> > Why would there be? Sounds like something's very wrong there. >> >> Sorry about that, I have checked that only now and I "only" get 39 >> deferred probe messages on exynos5250-snow. > > I typically see one or two, maybe five maximum on the platforms I have > here, but normally zero. Hmm, I have given a look at our lava farm and have seen 2 dozens as common (with multi_v7). >> > So, really, after boot and all appropriate modules have been loaded, >> > you should end up with no deferred probes. Are you saying that you >> > still have "hundreds" at that point? If you do, that sounds like >> > there's something very wrong. >> >> I was talking about messages if we log each -EPROBE_DEFER, not devices >> that remain to be probed. The point being that right now we don't have >> a way to know if we are deferring because the dependency will be >> around later, or if we have a problem and the dependency isn't going >> to be there at all. > > What's the difference between a dependency which isn't around because > the driver is not built into the kernel but is available as a module, > and a dependency that isn't around because the module hasn't been > loaded yet? > > How do you distinguish between those two scenarios? In the former > scenario, the device will eventually come up when udev loads the > module. In the latter case, it's a persistent failing case. Agreed, but it's something that doesn't happen often and that's why such messages would be at the debug level instead of being warns or errors. >> Agreed, with the note from above on why it would be better to only >> print such a message only when the -EPROBE_DEFER is likely to be a >> problem. > > ... and my argument is that there's _no way_ to know for certain which > deferred probes will be a problem, and which won't. The only way to > definitely know that is if you disable kernel modules, and require > all drivers to be built into the kernel. > > What you can do is print those devices which have failed to probe at > late_initcall() time - possibly augmenting that with reports from > subsystems showing what resources are not available, but that's only > a guide, because of the "it might or might not be in a kernel module" > problem. Well, adding those reports would give you a changelog similar to the one in this series... Thanks, Tomeu > -- > FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up > according to
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 04:29:40PM +0100, David Woodhouse wrote: > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: > > > But the point I'm making is that we are working towards *fixing* that, > > > and *not* using DT-specific code in places where we should be using the > > > generic APIs. > > What is the plan for fixing things here? It's not obvious (at least to > > me) that we don't want to have the subsystems having knowledge of how > > they are bound to a specific firmware which is what you seem to imply > > here. > I don't know that there *is* a coherent plan here to address it all. > Certainly, we *will* need subsystems to have firmware-specific > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > describe GPIO, and properties which reference GPIO pins are intended to > work through that — while in DT, properties which reference GPIO pins > will have different contents. They'll be compatible at the driver > level, in the sense that there's a call to get a given GPIO given the > property name, but the subsystems *will* be doing different things > behind the scenes. I'd expect that to be the norm rather than the exception. > > It seems like we're going to have to refactor these bits of code when > > they get generalised anyway so I'm not sure that the additional cost > > here is that big. > That's an acceptable answer — "we're adding legacy code here but we > know it's going to be refactored anyway". If that's true, all it takes > is a note in the commit comment to that effect. That's different from > having not thought about it :) Given the above I'm not even sure it's legacy code, it's just as likely we're going to get some parallel ACPI code added to the subsystems for parsing their bindings. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 05:00:54PM +0200, Tomeu Vizoso wrote: > On 19 October 2015 at 16:30, Russell King - ARM Linux >wrote: > > I typically see one or two, maybe five maximum on the platforms I have > > here, but normally zero. > > Hmm, I have given a look at our lava farm and have seen 2 dozens as > common (with multi_v7). No, because the lava farms tend not to be public. > > What you can do is print those devices which have failed to probe at > > late_initcall() time - possibly augmenting that with reports from > > subsystems showing what resources are not available, but that's only > > a guide, because of the "it might or might not be in a kernel module" > > problem. > > Well, adding those reports would give you a changelog similar to the > one in this series... I'm not sure about that, because what I was thinking of is adding a flag which would be set at late_initcall() time prior to running a final round of deferred device probing. This flag would then be used in a deferred_warn() printk function which would normally be silent, but when this flag is set, it would print the reason for the deferral - and this would replace (or be added) to the subsystems and drivers which return -EPROBE_DEFER. That has the effect of hiding all the deferrals up until just before launching into userspace, which should then acomplish two things - firstly, getting rid of the rather useless deferred messages up to that point, and secondly printing the reason why the remaining deferrals are happening. That should be a small number of new lines plus a one-line change in subsystems and drivers. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 04:29:40PM +0100, David Woodhouse wrote: > I don't know that there *is* a coherent plan here to address it all. > > Certainly, we *will* need subsystems to have firmware-specific > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > describe GPIO, and properties which reference GPIO pins are intended to > work through that — while in DT, properties which reference GPIO pins > will have different contents. They'll be compatible at the driver > level, in the sense that there's a call to get a given GPIO given the > property name, but the subsystems *will* be doing different things > behind the scenes. It's a bit ironic that you've chosen GPIO as an example there. The "new" GPIO API (the gpiod_* stuff) only has a fwnode way to get the gpio descriptor. There's no of_* method. I'd like to use the gpiod_* stuff, but I feel that my options are rather limited: either use fwnode_get_named_gpiod() with >of_node->fwnode, which seems like a hack by going underneath the covers of how fwnode is (partially) implemented with DT, or by using of_get_named_gpio() and the converting the gpio number to a descriptor via gpio_to_desc(). Both feel very hacky. If ACPI already handles GPIOs internally, then I'm left wondering why GPIO descriptor stuff went down the fwnode route at all - it seems rather pointless in this case, and it seems to make the use of the gpiod* interfaces where we _do_ need to use it (DT) harder and more hacky. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 10:29 AM, David Woodhousewrote: > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: >> > But the point I'm making is that we are working towards *fixing* that, >> > and *not* using DT-specific code in places where we should be using the >> > generic APIs. >> >> What is the plan for fixing things here? It's not obvious (at least to >> me) that we don't want to have the subsystems having knowledge of how >> they are bound to a specific firmware which is what you seem to imply >> here. > > I don't know that there *is* a coherent plan here to address it all. > > Certainly, we *will* need subsystems to have firmware-specific > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > describe GPIO, and properties which reference GPIO pins are intended to > work through that — while in DT, properties which reference GPIO pins > will have different contents. They'll be compatible at the driver > level, in the sense that there's a call to get a given GPIO given the > property name, but the subsystems *will* be doing different things > behind the scenes. > > My plan, such as it is, is to go through the leaf-node drivers which > almost definitely *should* be firmware-agnostic, and convert those. And > then take stock of what we have left, and work out what, if anything, > still needs to be done. Many cases are already agnostic in the drivers in terms of the *_get() functions. Some are DT specific, but probably because those subsystems are new and DT only. In any case, I don't think these 1 line changes do anything to make doing conversions here harder. >> It seems like we're going to have to refactor these bits of code when >> they get generalised anyway so I'm not sure that the additional cost >> here is that big. > > That's an acceptable answer — "we're adding legacy code here but we > know it's going to be refactored anyway". If that's true, all it takes > is a note in the commit comment to that effect. That's different from > having not thought about it :) Considering at one point we did create a fwnode based API, we did think about it. Plus there was little input from ACPI folks as to whether the change was even useful for ACPI case. In any case, we're talking about adding 1 line. Rob -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Monday, October 19, 2015 10:58:25 AM Rob Herring wrote: > On Mon, Oct 19, 2015 at 10:29 AM, David Woodhousewrote: > > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: > >> > But the point I'm making is that we are working towards *fixing* that, > >> > and *not* using DT-specific code in places where we should be using the > >> > generic APIs. > >> > >> What is the plan for fixing things here? It's not obvious (at least to > >> me) that we don't want to have the subsystems having knowledge of how > >> they are bound to a specific firmware which is what you seem to imply > >> here. > > > > I don't know that there *is* a coherent plan here to address it all. > > > > Certainly, we *will* need subsystems to have firmware-specific > > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to > > describe GPIO, and properties which reference GPIO pins are intended to > > work through that — while in DT, properties which reference GPIO pins > > will have different contents. They'll be compatible at the driver > > level, in the sense that there's a call to get a given GPIO given the > > property name, but the subsystems *will* be doing different things > > behind the scenes. > > > > My plan, such as it is, is to go through the leaf-node drivers which > > almost definitely *should* be firmware-agnostic, and convert those. And > > then take stock of what we have left, and work out what, if anything, > > still needs to be done. > > Many cases are already agnostic in the drivers in terms of the *_get() > functions. Some are DT specific, but probably because those subsystems > are new and DT only. In any case, I don't think these 1 line changes > do anything to make doing conversions here harder. > > >> It seems like we're going to have to refactor these bits of code when > >> they get generalised anyway so I'm not sure that the additional cost > >> here is that big. > > > > That's an acceptable answer — "we're adding legacy code here but we > > know it's going to be refactored anyway". If that's true, all it takes > > is a note in the commit comment to that effect. That's different from > > having not thought about it :) > > Considering at one point we did create a fwnode based API, we did > think about it. Plus there was little input from ACPI folks as to > whether the change was even useful for ACPI case. Well, sorry, but who was asking whom, specifically? The underlying problem is present in ACPI too and we don't really have a good solution for it. We might benefit from a common one if it existed. > In any case, we're talking about adding 1 line. But also about making the driver core slighly OF-centric. Sure, we need OF-specific code and ACPI-specific code wherever different handling is required, but doing that at the driver core level seems to be a bit of a stretch to me. Please note that we don't really have ACPI-specific calls in the driver core, although we might have added them long ago even before the OF stuff appeared in the kernel for the first time. We didn't do that, (among other things) because we didn't want that particular firmware interface to appear special in any way and I'm not really sure why it is now OK to make OF look special instead. If it is trivial to avoid that (and you seem to be arguing that it is), why do we have to do it? Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 08:27:44PM +0200, Uwe Kleine-König wrote: > Hello, > > On Mon, Oct 19, 2015 at 04:43:24PM +0100, Russell King - ARM Linux wrote: > > It's a bit ironic that you've chosen GPIO as an example there. The > > "new" GPIO API (the gpiod_* stuff) only has a fwnode way to get the > > gpio descriptor. There's no of_* method. > > Without following all that fwnode discussion: > gpiod_get et al. should work for you here, doesn't it? It just takes a > struct device * and I'm happy with it. What if you don't have a struct device? I had that problem recently when modifying the mvebu PCIe code. The 'struct device' node doesn't contain the GPIOs, it's the PCIe controller. Individual ports on the controller are described in DT as sub-nodes, and the sub-nodes can have a GPIO for card reset purposes. These sub-nodes don't have a struct device. Right now, I'm having to do this to work around this issue: reset_gpio = of_get_named_gpio_flags(child, "reset-gpios", 0, ); if (reset_gpio == -EPROBE_DEFER) { ret = reset_gpio; goto err; } if (gpio_is_valid(reset_gpio)) { unsigned long gpio_flags; port->reset_name = devm_kasprintf(dev, GFP_KERNEL, "%s-reset", port->name); if (!port->reset_name) { ret = -ENOMEM; goto err; } if (flags & OF_GPIO_ACTIVE_LOW) { dev_info(dev, "%s: reset gpio is active low\n", of_node_full_name(child)); gpio_flags = GPIOF_ACTIVE_LOW | GPIOF_OUT_INIT_LOW; } else { gpio_flags = GPIOF_OUT_INIT_HIGH; } ret = devm_gpio_request_one(dev, reset_gpio, gpio_flags, port->reset_name); if (ret) { if (ret == -EPROBE_DEFER) goto err; goto skip; } port->reset_gpio = gpio_to_desc(reset_gpio); } Not nice, is it? Not nice to have that in lots of drivers either. However, switching to use any of_* or fwnode_* thing also carries with it another problem: you can't control the name appearing in the allocation, so you end up with a bunch of GPIOs requested with a "reset" name - meaning you lose any identification of which port the GPIO was bound to. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Hello, On Mon, Oct 19, 2015 at 04:43:24PM +0100, Russell King - ARM Linux wrote: > It's a bit ironic that you've chosen GPIO as an example there. The > "new" GPIO API (the gpiod_* stuff) only has a fwnode way to get the > gpio descriptor. There's no of_* method. Without following all that fwnode discussion: gpiod_get et al. should work for you here, doesn't it? It just takes a struct device * and I'm happy with it. Best regards Uwe -- Pengutronix e.K. | Uwe Kleine-König| Industrial Linux Solutions | http://www.pengutronix.de/ | -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Tue, Oct 20, 2015 at 3:39 AM, Russell King - ARM Linuxwrote: > On Mon, Oct 19, 2015 at 08:27:44PM +0200, Uwe Kleine-König wrote: >> Hello, >> >> On Mon, Oct 19, 2015 at 04:43:24PM +0100, Russell King - ARM Linux wrote: >> > It's a bit ironic that you've chosen GPIO as an example there. The >> > "new" GPIO API (the gpiod_* stuff) only has a fwnode way to get the >> > gpio descriptor. There's no of_* method. >> >> Without following all that fwnode discussion: >> gpiod_get et al. should work for you here, doesn't it? It just takes a >> struct device * and I'm happy with it. > > What if you don't have a struct device? I had that problem recently > when modifying the mvebu PCIe code. The 'struct device' node doesn't > contain the GPIOs, it's the PCIe controller. Individual ports on the > controller are described in DT as sub-nodes, and the sub-nodes can > have a GPIO for card reset purposes. These sub-nodes don't have a > struct device. > > Right now, I'm having to do this to work around this issue: > > reset_gpio = of_get_named_gpio_flags(child, "reset-gpios", 0, ); > if (reset_gpio == -EPROBE_DEFER) { > ret = reset_gpio; > goto err; > } > > if (gpio_is_valid(reset_gpio)) { > unsigned long gpio_flags; > > port->reset_name = devm_kasprintf(dev, GFP_KERNEL, "%s-reset", > port->name); > if (!port->reset_name) { > ret = -ENOMEM; > goto err; > } > > if (flags & OF_GPIO_ACTIVE_LOW) { > dev_info(dev, "%s: reset gpio is active low\n", > of_node_full_name(child)); > gpio_flags = GPIOF_ACTIVE_LOW | > GPIOF_OUT_INIT_LOW; > } else { > gpio_flags = GPIOF_OUT_INIT_HIGH; > } > > ret = devm_gpio_request_one(dev, reset_gpio, gpio_flags, > port->reset_name); > if (ret) { > if (ret == -EPROBE_DEFER) > goto err; > goto skip; > } > > port->reset_gpio = gpio_to_desc(reset_gpio); > } > > Not nice, is it? Not nice to have that in lots of drivers either. > > However, switching to use any of_* or fwnode_* thing also carries with > it another problem: you can't control the name appearing in the > allocation, so you end up with a bunch of GPIOs requested with a "reset" > name - meaning you lose any identification of which port the GPIO was > bound to. There are a few holes in the gpiod API. I see two solutions here: 1) extend devm_get_gpiod_from_child() to take an optional name argument 2) add a function to explicitly change a GPIO's name 2) seems to be the most generic solution, would that do the trick? (sorry for the off-topic) -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 4:40 PM, Rafael J. Wysockiwrote: > On Monday, October 19, 2015 10:58:25 AM Rob Herring wrote: >> On Mon, Oct 19, 2015 at 10:29 AM, David Woodhouse >> wrote: >> > On Mon, 2015-10-19 at 15:50 +0100, Mark Brown wrote: >> >> > But the point I'm making is that we are working towards *fixing* that, >> >> > and *not* using DT-specific code in places where we should be using the >> >> > generic APIs. >> >> >> >> What is the plan for fixing things here? It's not obvious (at least to >> >> me) that we don't want to have the subsystems having knowledge of how >> >> they are bound to a specific firmware which is what you seem to imply >> >> here. >> > >> > I don't know that there *is* a coherent plan here to address it all. >> > >> > Certainly, we *will* need subsystems to have firmware-specific >> > knowledge in some cases. Take GPIO as an example; ACPI *has* a way to >> > describe GPIO, and properties which reference GPIO pins are intended to >> > work through that — while in DT, properties which reference GPIO pins >> > will have different contents. They'll be compatible at the driver >> > level, in the sense that there's a call to get a given GPIO given the >> > property name, but the subsystems *will* be doing different things >> > behind the scenes. >> > >> > My plan, such as it is, is to go through the leaf-node drivers which >> > almost definitely *should* be firmware-agnostic, and convert those. And >> > then take stock of what we have left, and work out what, if anything, >> > still needs to be done. >> >> Many cases are already agnostic in the drivers in terms of the *_get() >> functions. Some are DT specific, but probably because those subsystems >> are new and DT only. In any case, I don't think these 1 line changes >> do anything to make doing conversions here harder. >> >> >> It seems like we're going to have to refactor these bits of code when >> >> they get generalised anyway so I'm not sure that the additional cost >> >> here is that big. >> > >> > That's an acceptable answer — "we're adding legacy code here but we >> > know it's going to be refactored anyway". If that's true, all it takes >> > is a note in the commit comment to that effect. That's different from >> > having not thought about it :) >> >> Considering at one point we did create a fwnode based API, we did >> think about it. Plus there was little input from ACPI folks as to >> whether the change was even useful for ACPI case. > > Well, sorry, but who was asking whom, specifically? You and linux-acpi have been copied on v2 and later of the entire series I think. > The underlying problem is present in ACPI too and we don't really have a good > solution for it. We might benefit from a common one if it existed. The problem for DT is we don't generically know what are the dependencies at a core level. We could know some or most dependencies if phandles (links to other nodes) were typed, but they are not. If the core had this information, we could simply control the device creation to order probing. Instead, this information is encoded into the bindings and binding parsing resides in the subsystems. That parsing happens during probe of the client side and is done by the subsystems (for common bindings). Since we already do the parsing at this point, it is a convenient place to trigger the probe of the dependency. Is ACPI going to be similar in this regard? Fundamentally, it is a question of probe devices when their dependencies are present or drivers ensure their dependencies are ready. IIRC, init systems went thru a similar debate for service dependencies. >> In any case, we're talking about adding 1 line. > > But also about making the driver core slighly OF-centric. How so? The one line is in DT binding parsing code in subsystems, not driver core. The driver core change is we add every device (that happened to be created by DT) to the deferred probe list, so they don't probe right away. > Sure, we need OF-specific code and ACPI-specific code wherever different > handling is required, but doing that at the driver core level seems to be > a bit of a stretch to me. > > Please note that we don't really have ACPI-specific calls in the driver core, > although we might have added them long ago even before the OF stuff appeared > in the kernel for the first time. We didn't do that, (among other things) > because we didn't want that particular firmware interface to appear special > in any way and I'm not really sure why it is now OK to make OF look special > instead. I don't think DT is special and we avoid DT specific core changes as much as possible. I think the difference is DT uses platform_device and ACPI does not. It used to be separate, but got merged together primarily to support the plethora of existing drivers. Anyway, that is all outside of anything in this series. > If it is trivial to avoid that (and you seem to be arguing that it is), why > do we have to
Re: [GIT PULL] On-demand device probing
On Mon, Oct 19, 2015 at 06:21:40PM +0200, Geert Uytterhoeven wrote: > Hi Russell, > > On Mon, Oct 19, 2015 at 5:35 PM, Russell King - ARM Linux >wrote: > >> > What you can do is print those devices which have failed to probe at > >> > late_initcall() time - possibly augmenting that with reports from > >> > subsystems showing what resources are not available, but that's only > >> > a guide, because of the "it might or might not be in a kernel module" > >> > problem. > >> > >> Well, adding those reports would give you a changelog similar to the > >> one in this series... > > > > I'm not sure about that, because what I was thinking of is adding > > a flag which would be set at late_initcall() time prior to running > > a final round of deferred device probing. > > Which round is the final round? I said "a" not "the". Maybe I should've said "one last round of deferred probing before entering userspace". > That's the one which didn't manage to bind any new devices to drivers, > which is something you only know _after_ the round has been run. > > So I think we need one extra round to handle this. Yes - because the idea is that we do everything we do today without printing anything about deferred probes. We then set a flag which indicates we should report defers, and then we trigger another round of probes. If everything probed successfully, the deferred probe list will be empty and nothing will be seen. Otherwise, we should end up with a report of all the devices that weren't able to be bound to their drivers due to -EPROBE_DEFER. > > > This flag would then be used in a deferred_warn() printk function > > which would normally be silent, but when this flag is set, it would > > print the reason for the deferral - and this would replace (or be > > added) to the subsystems and drivers which return -EPROBE_DEFER. > > > > That has the effect of hiding all the deferrals up until just before > > launching into userspace, which should then acomplish two things - > > firstly, getting rid of the rather useless deferred messages up to > > that point, and secondly printing the reason why the remaining > > deferrals are happening. > > > > That should be a small number of new lines plus a one-line change > > in subsystems and drivers. > > Apart from the extra round we probably can't get rid of, that sounds > OK to me. Yes, it means a little longer to boot, but if there's nothing pending this _should_ only be microseconds - it should be nothing more than setting the flag, possibly taking and releasing a lock, and checking that the deferred probe list is empty. Of course, if the deferred probe list isn't empty, then there'll be more expense - but I'm willing to bet that for those developers with serial console enabled, the kernel boot will be faster overall due to the reduced number of characters printed during the boot. -- FTTC broadband for 0.8mile line: currently at 9.6Mbps down 400kbps up according to speedtest.net. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Hi Russell, On Mon, Oct 19, 2015 at 5:35 PM, Russell King - ARM Linuxwrote: >> > What you can do is print those devices which have failed to probe at >> > late_initcall() time - possibly augmenting that with reports from >> > subsystems showing what resources are not available, but that's only >> > a guide, because of the "it might or might not be in a kernel module" >> > problem. >> >> Well, adding those reports would give you a changelog similar to the >> one in this series... > > I'm not sure about that, because what I was thinking of is adding > a flag which would be set at late_initcall() time prior to running > a final round of deferred device probing. Which round is the final round? That's the one which didn't manage to bind any new devices to drivers, which is something you only know _after_ the round has been run. So I think we need one extra round to handle this. > This flag would then be used in a deferred_warn() printk function > which would normally be silent, but when this flag is set, it would > print the reason for the deferral - and this would replace (or be > added) to the subsystems and drivers which return -EPROBE_DEFER. > > That has the effect of hiding all the deferrals up until just before > launching into userspace, which should then acomplish two things - > firstly, getting rid of the rather useless deferred messages up to > that point, and secondly printing the reason why the remaining > deferrals are happening. > > That should be a small number of new lines plus a one-line change > in subsystems and drivers. Apart from the extra round we probably can't get rid of, that sounds OK to me. Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- ge...@linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 8:19 AM, Rob Herringwrote: > On Fri, Oct 16, 2015 at 4:23 PM, Olof Johansson wrote: >> Hi, >> >> I've bisected boot failures in next-20151016 down to patches in this branch: >> >> On Thu, Oct 15, 2015 at 4:42 AM, Tomeu Vizoso >> wrote: >>> Tomeu Vizoso (20): >>> driver core: handle -EPROBE_DEFER from bus_type.match() >> >> The machine it happened on was OMAP5UEVM: >> >> http://arm-soc.lixom.net/bootlogs/next/next-20151016/omap5uevm-arm-omap2plus_defconfig.html > > So this one is because the MMC node numbering changed. I don't know > how to fix that other than with aliases, but that doesn't solve > backwards compatibility. Yep, aliases will take care of it in this case. This is where -next fills a great purpose, we can make sure we get those aliases added in before the patches go in. >> But I've also seen it on tegra2, that one bisected down to: >> >>> regulator: core: Probe regulators on demand >> >> http://arm-soc.lixom.net/bootlogs/next/next-20151016/seaboard-arm-multi_v7_defconfig.html > > This one you need a rootwait I think. The MMC scanning is not > guaranteed to be done before the rootfs mounting AFAIK. There may be > other problems, but we can't see them since it panics. Embarrassing, I almost always do this and I'm surprised this machine has been this stable without it. -Olof -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: > On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: > > > I can't see adding calls like this all over the tree just to solve a > > bus-specific problem, you are adding of_* calls where they aren't > > needed, or wanted, at all. > > This isn't bus specific, I'm not sure what makes you say that? You are making it bus-specific by putting these calls all over the tree in different bus subsystems semi-randomly for all I can determine. > > What is the root-problem of your delay in device probing? I read your > > last patch series and I can't seem to figure out what the issue is that > > this is solving in any "better" way from the existing deferred probing. > > So, I don't actually have any platforms that are especially bothered by > this (at least not for my use cases) so there's a bit of educated > guessing going on here but there's two broad things I'm aware of. > > One is that regardless of the actual performance of the system when > deferred probe goes off it splats errors all over the console which > makes it look like something is going wrong even if everything is fine > in the end. If lots of deferred probing happens then the volume gets > big too. People find this distracting, noisy and ugly - it obscures > actual issues and trains people to ignore errors. I do think this is a > reasonable concern and that it's worth trying to mitigate against > deferral for this reason alone. We don't want to just ignore the errors > and not print anything either since if the resource doesn't appear the > user needs to know what is preventing the driver from instantiating so > they can try to fix it. This has come up many times, I have no objection to just turning that message into a debug message that can be dynamically enabled for those people wanting to debug their systems for boot time issues. Please send a patch to do so. thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 08:47:09AM -0700, Greg Kroah-Hartman wrote: > On Sat, Oct 17, 2015 at 10:04:55AM -0500, Rob Herring wrote: > > I think Linus W, Mark B, and I all said a similar thing initially in > > that dependencies should be handled in the driver core. We went down > > the path of making this not firmware (aka bus) specific and an earlier > > version had just that (with fwnode_* calls). That turned out to be > > pointless as the calling locations were almost always in DT specific > > code anyway. If you notice, the calls are next to other DT specific > > calls generally (usually a "get"). So yes, I'd prefer not to have to > > touch every subsystem, but we had to do that anyway to add DT support. > If they are "next" to a call like that, why not put it in that call? I > really object to having to "sprinkle" this all over the kernel, for no > obvious reason why that is happening at all (look at the USB patch for > one such example.) I did ask that question myself IIRC - we could probably get a long way by trying to instantiate anything that looks probable when we do a phandle lookup on it. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Sun, Oct 18, 2015 at 12:37:57PM -0700, Greg Kroah-Hartman wrote: > On Sun, Oct 18, 2015 at 08:29:31PM +0100, Mark Brown wrote: > > On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: > > > I can't see adding calls like this all over the tree just to solve a > > > bus-specific problem, you are adding of_* calls where they aren't > > > needed, or wanted, at all. > > This isn't bus specific, I'm not sure what makes you say that? > You are making it bus-specific by putting these calls all over the tree > in different bus subsystems semi-randomly for all I can determine. Do you mean firmware rather than bus here? I think that's the confusion I have... > > One is that regardless of the actual performance of the system when > > deferred probe goes off it splats errors all over the console which > > makes it look like something is going wrong even if everything is fine > > in the end. If lots of deferred probing happens then the volume gets > > big too. People find this distracting, noisy and ugly - it obscures > > actual issues and trains people to ignore errors. I do think this is a > > reasonable concern and that it's worth trying to mitigate against > > deferral for this reason alone. We don't want to just ignore the errors > > and not print anything either since if the resource doesn't appear the > > user needs to know what is preventing the driver from instantiating so > > they can try to fix it. > This has come up many times, I have no objection to just turning that > message into a debug message that can be dynamically enabled for those > people wanting to debug their systems for boot time issues. It's not just the driver core logging, it's also all the individual drivers logging that they failed to get whatever resource since silently failing is not a great user experience. Many, hopefully most, of the drivers don't actually have special handling for probe deferral since half the beauty of probe deferral is that the subsystem supplying the resource can just return -EPROBE_DEFER when it notices something is missing but might appear and then the drivers will do the right thing so long as they have error handling code that they really should have anyway. We'd need to have a special dev_err() that handled probe deferral errors for drivers to use during probe or some other smarts in the logging infrastructure. Which isn't a totally horrible idea. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Fri, Oct 16, 2015 at 11:57:50PM -0700, Greg Kroah-Hartman wrote: > I can't see adding calls like this all over the tree just to solve a > bus-specific problem, you are adding of_* calls where they aren't > needed, or wanted, at all. This isn't bus specific, I'm not sure what makes you say that? > What is the root-problem of your delay in device probing? I read your > last patch series and I can't seem to figure out what the issue is that > this is solving in any "better" way from the existing deferred probing. So, I don't actually have any platforms that are especially bothered by this (at least not for my use cases) so there's a bit of educated guessing going on here but there's two broad things I'm aware of. One is that regardless of the actual performance of the system when deferred probe goes off it splats errors all over the console which makes it look like something is going wrong even if everything is fine in the end. If lots of deferred probing happens then the volume gets big too. People find this distracting, noisy and ugly - it obscures actual issues and trains people to ignore errors. I do think this is a reasonable concern and that it's worth trying to mitigate against deferral for this reason alone. We don't want to just ignore the errors and not print anything either since if the resource doesn't appear the user needs to know what is preventing the driver from instantiating so they can try to fix it. The other is that if you're printing to a serial console then that's not an especially fast operation so if you're getting lots of messages being printed simply physically outputting them takes measurable time. I'm not aware of any performance concerns outside of that, but like I say I'm not affected by this myself in any great way. Obviously this can be configured but not having actual errors on the console isn't super awesome either for systems that make use of the logging there and we don't have a good way of telling what's from deferral and what's not. signature.asc Description: PGP signature
Re: [GIT PULL] On-demand device probing
On Wed, Oct 14, 2015 at 10:34:00AM +0200, Tomeu Vizoso wrote: > Hi Rob, > > here is the pull request you asked for, with no changes from the version > that I posted last to the list. > > The following changes since commit 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: > > Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) > > are available in the git repository at: > > git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git > on-demand-probes-for-next That's not a signed tag :( Anyway, I REALLY don't like this series (sorry for the delay in reviewing them, normally I trust Rob's judgement...) I can't see adding calls like this all over the tree just to solve a bus-specific problem, you are adding of_* calls where they aren't needed, or wanted, at all. What is the root-problem of your delay in device probing? I read your last patch series and I can't seem to figure out what the issue is that this is solving in any "better" way from the existing deferred probing. thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartmanwrote: >> I'm guessing the time is a matter of probing and undoing the probes >> rather than slow h/w. We could maybe improve things by making sure >> drivers move what they defer on to the beginning of probe, but that >> seems like a horrible, fragile hack. > > How can calling probe and failing cause 2 seconds? How many different > probe calls are failing here? Again, a boot log graph would be great to > see as it will show the root cause, not just guessing at this. just fwiw, but when you have a driver that depends on several other drivers (which in turn depend on other drivers and so on), the amount of probe-defer we end up seeing is pretty comical. Yeah, there probably is some room to optimize by juggling around order drivers do things in probe. But that doesn't solve the fundamental problem with the current state, about probe order having no clue about dependencies.. BR, -R -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: > On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman >wrote: > >> I'm guessing the time is a matter of probing and undoing the probes > >> rather than slow h/w. We could maybe improve things by making sure > >> drivers move what they defer on to the beginning of probe, but that > >> seems like a horrible, fragile hack. > > > > How can calling probe and failing cause 2 seconds? How many different > > probe calls are failing here? Again, a boot log graph would be great to > > see as it will show the root cause, not just guessing at this. > > > just fwiw, but when you have a driver that depends on several other > drivers (which in turn depend on other drivers and so on), the amount > of probe-defer we end up seeing is pretty comical. Yeah, there > probably is some room to optimize by juggling around order drivers do > things in probe. But that doesn't solve the fundamental problem with > the current state, about probe order having no clue about > dependencies.. I can imagine it is a lot of iterations, but how long does it really take? How many different devices are involved that it takes multiple loops in order to finally work out the correct order? Where is the time delays here, just calling probe() and having it instantly return shouldn't take all that long. thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Den 17.10.2015 20:45, skrev Rob Clark: On Sat, Oct 17, 2015 at 2:27 PM, Greg Kroah-Hartmanwrote: On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman wrote: I'm guessing the time is a matter of probing and undoing the probes rather than slow h/w. We could maybe improve things by making sure drivers move what they defer on to the beginning of probe, but that seems like a horrible, fragile hack. How can calling probe and failing cause 2 seconds? How many different probe calls are failing here? Again, a boot log graph would be great to see as it will show the root cause, not just guessing at this. just fwiw, but when you have a driver that depends on several other drivers (which in turn depend on other drivers and so on), the amount of probe-defer we end up seeing is pretty comical. Yeah, there probably is some room to optimize by juggling around order drivers do things in probe. But that doesn't solve the fundamental problem with the current state, about probe order having no clue about dependencies.. I can imagine it is a lot of iterations, but how long does it really take? How many different devices are involved that it takes multiple loops in order to finally work out the correct order? Where is the time delays here, just calling probe() and having it instantly return shouldn't take all that long. offhand, I think the dependencies go at *least* three levels deep.. I'd say, from memory, I see drm/msm taking at least 5 or 6 tries to get all the way through requesting it's various different regulators/clks/gpios. I hadn't really paid attention to how many tries the drivers I depend on go through. (Of those, I take clks from two different clk drivers (which have dependency on a 3rd clk driver), and regulators and gpio's come from at least two places, which in turn have dependencies on clks, etc.) I don't have really good hard numbers handy (since my observations of this are w/ console over uart which effects timings, and so I see it taking much longer than 2sec).. but the 2sec figure that Tomeu mentioned seemed pretty plausible to me. I can try to get better #'s... I should have my kernel hat on at least some of the time next week.. but the 2sec figure didn't seem unrealistic to me. Are you saying that the total boot time is increased by 2 sec due to deferred probing, or that display initialization is happening 2 sec after it's first try? -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 2:27 PM, Greg Kroah-Hartmanwrote: > On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: >> On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman >> wrote: >> >> I'm guessing the time is a matter of probing and undoing the probes >> >> rather than slow h/w. We could maybe improve things by making sure >> >> drivers move what they defer on to the beginning of probe, but that >> >> seems like a horrible, fragile hack. >> > >> > How can calling probe and failing cause 2 seconds? How many different >> > probe calls are failing here? Again, a boot log graph would be great to >> > see as it will show the root cause, not just guessing at this. >> >> >> just fwiw, but when you have a driver that depends on several other >> drivers (which in turn depend on other drivers and so on), the amount >> of probe-defer we end up seeing is pretty comical. Yeah, there >> probably is some room to optimize by juggling around order drivers do >> things in probe. But that doesn't solve the fundamental problem with >> the current state, about probe order having no clue about >> dependencies.. > > I can imagine it is a lot of iterations, but how long does it really > take? How many different devices are involved that it takes multiple > loops in order to finally work out the correct order? Where is the time > delays here, just calling probe() and having it instantly return > shouldn't take all that long. offhand, I think the dependencies go at *least* three levels deep.. I'd say, from memory, I see drm/msm taking at least 5 or 6 tries to get all the way through requesting it's various different regulators/clks/gpios. I hadn't really paid attention to how many tries the drivers I depend on go through. (Of those, I take clks from two different clk drivers (which have dependency on a 3rd clk driver), and regulators and gpio's come from at least two places, which in turn have dependencies on clks, etc.) I don't have really good hard numbers handy (since my observations of this are w/ console over uart which effects timings, and so I see it taking much longer than 2sec).. but the 2sec figure that Tomeu mentioned seemed pretty plausible to me. I can try to get better #'s... I should have my kernel hat on at least some of the time next week.. but the 2sec figure didn't seem unrealistic to me. Just as an aside, the amount of probe-defer adds quite a lot of noise when you are trying to debug why some driver doesn't probe successfully. Which itself would be a nice reason to do something more clever.. BR, -R > thanks, > > greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 02:45:34PM -0400, Rob Clark wrote: > On Sat, Oct 17, 2015 at 2:27 PM, Greg Kroah-Hartman >wrote: > > On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: > >> On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman > >> wrote: > >> >> I'm guessing the time is a matter of probing and undoing the probes > >> >> rather than slow h/w. We could maybe improve things by making sure > >> >> drivers move what they defer on to the beginning of probe, but that > >> >> seems like a horrible, fragile hack. > >> > > >> > How can calling probe and failing cause 2 seconds? How many different > >> > probe calls are failing here? Again, a boot log graph would be great to > >> > see as it will show the root cause, not just guessing at this. > >> > >> > >> just fwiw, but when you have a driver that depends on several other > >> drivers (which in turn depend on other drivers and so on), the amount > >> of probe-defer we end up seeing is pretty comical. Yeah, there > >> probably is some room to optimize by juggling around order drivers do > >> things in probe. But that doesn't solve the fundamental problem with > >> the current state, about probe order having no clue about > >> dependencies.. > > > > I can imagine it is a lot of iterations, but how long does it really > > take? How many different devices are involved that it takes multiple > > loops in order to finally work out the correct order? Where is the time > > delays here, just calling probe() and having it instantly return > > shouldn't take all that long. > > offhand, I think the dependencies go at *least* three levels deep.. > I'd say, from memory, I see drm/msm taking at least 5 or 6 tries to > get all the way through requesting it's various different > regulators/clks/gpios. And how long does that really take? Numbers please :) > I hadn't really paid attention to how many > tries the drivers I depend on go through. (Of those, I take clks from > two different clk drivers (which have dependency on a 3rd clk driver), > and regulators and gpio's come from at least two places, which in turn > have dependencies on clks, etc.) I don't have really good hard > numbers handy (since my observations of this are w/ console over uart > which effects timings, and so I see it taking much longer than 2sec).. > but the 2sec figure that Tomeu mentioned seemed pretty plausible to > me. > > I can try to get better #'s... I should have my kernel hat on at least > some of the time next week.. but the 2sec figure didn't seem > unrealistic to me. Based on the time it takes a modern laptop to boot, 2 seconds is forever, there has to be something else going on here other than just calling probe() a bunch of times. Please use the tools we have to determine this before trying to change the driver core. > Just as an aside, the amount of probe-defer adds quite a lot of noise > when you are trying to debug why some driver doesn't probe > successfully. Which itself would be a nice reason to do something > more clever.. People seem to not like the noise, so let's turn off those messages, that should speed things up :) thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 2:59 PM, Greg Kroah-Hartmanwrote: > On Sat, Oct 17, 2015 at 02:45:34PM -0400, Rob Clark wrote: >> On Sat, Oct 17, 2015 at 2:27 PM, Greg Kroah-Hartman >> wrote: >> > On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: >> >> On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman >> >> wrote: >> >> >> I'm guessing the time is a matter of probing and undoing the probes >> >> >> rather than slow h/w. We could maybe improve things by making sure >> >> >> drivers move what they defer on to the beginning of probe, but that >> >> >> seems like a horrible, fragile hack. >> >> > >> >> > How can calling probe and failing cause 2 seconds? How many different >> >> > probe calls are failing here? Again, a boot log graph would be great to >> >> > see as it will show the root cause, not just guessing at this. >> >> >> >> >> >> just fwiw, but when you have a driver that depends on several other >> >> drivers (which in turn depend on other drivers and so on), the amount >> >> of probe-defer we end up seeing is pretty comical. Yeah, there >> >> probably is some room to optimize by juggling around order drivers do >> >> things in probe. But that doesn't solve the fundamental problem with >> >> the current state, about probe order having no clue about >> >> dependencies.. >> > >> > I can imagine it is a lot of iterations, but how long does it really >> > take? How many different devices are involved that it takes multiple >> > loops in order to finally work out the correct order? Where is the time >> > delays here, just calling probe() and having it instantly return >> > shouldn't take all that long. >> >> offhand, I think the dependencies go at *least* three levels deep.. >> I'd say, from memory, I see drm/msm taking at least 5 or 6 tries to >> get all the way through requesting it's various different >> regulators/clks/gpios. > > And how long does that really take? Numbers please :) > >> I hadn't really paid attention to how many >> tries the drivers I depend on go through. (Of those, I take clks from >> two different clk drivers (which have dependency on a 3rd clk driver), >> and regulators and gpio's come from at least two places, which in turn >> have dependencies on clks, etc.) I don't have really good hard >> numbers handy (since my observations of this are w/ console over uart >> which effects timings, and so I see it taking much longer than 2sec).. >> but the 2sec figure that Tomeu mentioned seemed pretty plausible to >> me. >> >> I can try to get better #'s... I should have my kernel hat on at least >> some of the time next week.. but the 2sec figure didn't seem >> unrealistic to me. > > Based on the time it takes a modern laptop to boot, 2 seconds is > forever, there has to be something else going on here other than just > calling probe() a bunch of times. Please use the tools we have to > determine this before trying to change the driver core. yes, I am aware of the tools.. although so far I spend most of my time just trying to get things working in the first place ;-) All I was trying to point out was that Tomeu's figures didn't really seem unrealistic. I mean, given that the average SoC driver probably depends on at least one clock and at least one regulator, having to probe each driver at least twice seems plausible. And that having a noticeable effect on boot time doesn't seem surprising. I'm not sure that saying 'modern laptop can boot in 2sec' adds much to the discussion since I don't think you have quite so much interdependency between devices vs random probe order. I have seen arm devices boot to UI in similar times, but that was pre-devicetree days. I expect Tomeu has some better number.. if not I can collect some. >> Just as an aside, the amount of probe-defer adds quite a lot of noise >> when you are trying to debug why some driver doesn't probe >> successfully. Which itself would be a nice reason to do something >> more clever.. > > People seem to not like the noise, so let's turn off those messages, > that should speed things up :) heh, except for when you are trying to debug what is missing preventing the driver you depend on from probing ;-) BR, -R -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 03:39:20PM -0400, Rob Clark wrote: > On Sat, Oct 17, 2015 at 2:59 PM, Greg Kroah-Hartman >wrote: > > On Sat, Oct 17, 2015 at 02:45:34PM -0400, Rob Clark wrote: > >> On Sat, Oct 17, 2015 at 2:27 PM, Greg Kroah-Hartman > >> wrote: > >> > On Sat, Oct 17, 2015 at 01:54:43PM -0400, Rob Clark wrote: > >> >> On Sat, Oct 17, 2015 at 12:56 PM, Greg Kroah-Hartman > >> >> wrote: > >> >> >> I'm guessing the time is a matter of probing and undoing the probes > >> >> >> rather than slow h/w. We could maybe improve things by making sure > >> >> >> drivers move what they defer on to the beginning of probe, but that > >> >> >> seems like a horrible, fragile hack. > >> >> > > >> >> > How can calling probe and failing cause 2 seconds? How many different > >> >> > probe calls are failing here? Again, a boot log graph would be great > >> >> > to > >> >> > see as it will show the root cause, not just guessing at this. > >> >> > >> >> > >> >> just fwiw, but when you have a driver that depends on several other > >> >> drivers (which in turn depend on other drivers and so on), the amount > >> >> of probe-defer we end up seeing is pretty comical. Yeah, there > >> >> probably is some room to optimize by juggling around order drivers do > >> >> things in probe. But that doesn't solve the fundamental problem with > >> >> the current state, about probe order having no clue about > >> >> dependencies.. > >> > > >> > I can imagine it is a lot of iterations, but how long does it really > >> > take? How many different devices are involved that it takes multiple > >> > loops in order to finally work out the correct order? Where is the time > >> > delays here, just calling probe() and having it instantly return > >> > shouldn't take all that long. > >> > >> offhand, I think the dependencies go at *least* three levels deep.. > >> I'd say, from memory, I see drm/msm taking at least 5 or 6 tries to > >> get all the way through requesting it's various different > >> regulators/clks/gpios. > > > > And how long does that really take? Numbers please :) > > > >> I hadn't really paid attention to how many > >> tries the drivers I depend on go through. (Of those, I take clks from > >> two different clk drivers (which have dependency on a 3rd clk driver), > >> and regulators and gpio's come from at least two places, which in turn > >> have dependencies on clks, etc.) I don't have really good hard > >> numbers handy (since my observations of this are w/ console over uart > >> which effects timings, and so I see it taking much longer than 2sec).. > >> but the 2sec figure that Tomeu mentioned seemed pretty plausible to > >> me. > >> > >> I can try to get better #'s... I should have my kernel hat on at least > >> some of the time next week.. but the 2sec figure didn't seem > >> unrealistic to me. > > > > Based on the time it takes a modern laptop to boot, 2 seconds is > > forever, there has to be something else going on here other than just > > calling probe() a bunch of times. Please use the tools we have to > > determine this before trying to change the driver core. > > yes, I am aware of the tools.. although so far I spend most of my time > just trying to get things working in the first place ;-) And that's where most people stop, if you want to make it fast, you have to put in more effort, sorry. Don't expect the driver core to work around driver bugs for you. > All I was trying to point out was that Tomeu's figures didn't really > seem unrealistic. I mean, given that the average SoC driver probably > depends on at least one clock and at least one regulator, having to > probe each driver at least twice seems plausible. And that having a > noticeable effect on boot time doesn't seem surprising. I'm not sure > that saying 'modern laptop can boot in 2sec' adds much to the > discussion since I don't think you have quite so much interdependency > between devices vs random probe order. I have seen arm devices boot > to UI in similar times, but that was pre-devicetree days. 2 extra probes add a second to the boot time? Those sound like really broken drivers to me :) thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 1:57 AM, Greg Kroah-Hartmanwrote: > On Wed, Oct 14, 2015 at 10:34:00AM +0200, Tomeu Vizoso wrote: >> Hi Rob, >> >> here is the pull request you asked for, with no changes from the version >> that I posted last to the list. >> >> The following changes since commit 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: >> >> Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) >> >> are available in the git repository at: >> >> git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git >> on-demand-probes-for-next > > That's not a signed tag :( > > Anyway, I REALLY don't like this series (sorry for the delay in > reviewing them, normally I trust Rob's judgement...) We've seen a lot of attempts here. This is really the best solution so far in that it is simple, uses existing data from DT, and was low risk for breaking platforms (at least I thought it would be). Anyway, getting more exposure is why I've put it into -next. > I can't see adding calls like this all over the tree just to solve a > bus-specific problem, you are adding of_* calls where they aren't > needed, or wanted, at all. I think Linus W, Mark B, and I all said a similar thing initially in that dependencies should be handled in the driver core. We went down the path of making this not firmware (aka bus) specific and an earlier version had just that (with fwnode_* calls). That turned out to be pointless as the calling locations were almost always in DT specific code anyway. If you notice, the calls are next to other DT specific calls generally (usually a "get"). So yes, I'd prefer not to have to touch every subsystem, but we had to do that anyway to add DT support. We've generally split the DT code into the core (in drivers/of) and the binding specific (in subsystems). Extracting dependency information the DT is going to require binding specific knowledge, so subsystem changes are probably unavoidable. The alternative is we put binding specific knowledge into the core DT code to parse dependencies. > What is the root-problem of your delay in device probing? I read your > last patch series and I can't seem to figure out what the issue is that > this is solving in any "better" way from the existing deferred probing. It saves 2 seconds in the boot time as re-probing takes time. That alone seems compelling to me. Another downside to deferred probing is you have to touch every driver and subsystem to support it. This contains the problem to the subsystems. Rob -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 10:47 AM, Greg Kroah-Hartmanwrote: > On Sat, Oct 17, 2015 at 10:04:55AM -0500, Rob Herring wrote: >> On Sat, Oct 17, 2015 at 1:57 AM, Greg Kroah-Hartman >> wrote: >> > On Wed, Oct 14, 2015 at 10:34:00AM +0200, Tomeu Vizoso wrote: >> >> Hi Rob, >> >> >> >> here is the pull request you asked for, with no changes from the version >> >> that I posted last to the list. >> >> >> >> The following changes since commit >> >> 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: >> >> >> >> Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) >> >> >> >> are available in the git repository at: >> >> >> >> git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git >> >> on-demand-probes-for-next >> > >> > That's not a signed tag :( >> > >> > Anyway, I REALLY don't like this series (sorry for the delay in >> > reviewing them, normally I trust Rob's judgement...) >> >> We've seen a lot of attempts here. This is really the best solution so >> far in that it is simple, uses existing data from DT, and was low risk >> for breaking platforms (at least I thought it would be). Anyway, >> getting more exposure is why I've put it into -next. > > Exposure is good, now we know it breaks some builds, which was useful :) Now that I've looked at them, they are somewhat questionable failures. They do show the fragile nature of probe ordering and the implicit dependencies we have. >> > I can't see adding calls like this all over the tree just to solve a >> > bus-specific problem, you are adding of_* calls where they aren't >> > needed, or wanted, at all. >> >> I think Linus W, Mark B, and I all said a similar thing initially in >> that dependencies should be handled in the driver core. We went down >> the path of making this not firmware (aka bus) specific and an earlier >> version had just that (with fwnode_* calls). That turned out to be >> pointless as the calling locations were almost always in DT specific >> code anyway. If you notice, the calls are next to other DT specific >> calls generally (usually a "get"). So yes, I'd prefer not to have to >> touch every subsystem, but we had to do that anyway to add DT support. > > If they are "next" to a call like that, why not put it in that call? I > really object to having to "sprinkle" this all over the kernel, for no > obvious reason why that is happening at all (look at the USB patch for > one such example.) Looking at it again, they are in DT specific code already. The USB one is in devm_usb_get_phy_by_node() which is a DT specific call. >> We've generally split the DT code into the core (in drivers/of) and >> the binding specific (in subsystems). Extracting dependency >> information the DT is going to require binding specific knowledge, so >> subsystem changes are probably unavoidable. >> >> The alternative is we put binding specific knowledge into the core DT >> code to parse dependencies. >> >> > What is the root-problem of your delay in device probing? I read your >> > last patch series and I can't seem to figure out what the issue is that >> > this is solving in any "better" way from the existing deferred probing. >> >> It saves 2 seconds in the boot time as re-probing takes time. That >> alone seems compelling to me. > > 2 seconds is _forever_, and really seems like some other driver is > sleeping and causing this problem. What does the bootlog time-chart say > is really causing this long delay? There's no way we are stuck in some > sort of logic loop for that long (i.e. having to walk the list of > devices somehow.) This sounds like a driver-specific problem that is > being worked around by having to touch all subsystems, which isn't nice. I don't think it is one driver as the improvement is seen on multiple platforms. I'll let Tomeu comment further on where the time was spent. > Hint, we didn't have to do this type of thing to solve boot delays on > x86 when we had hardware that was slow to initialize, why should DT be > special? :) x86 did not need deferred probe either (though we probably can find some initcall ordering hacks). This is an embedded problem, not a DT problem. I'm guessing the time is a matter of probing and undoing the probes rather than slow h/w. We could maybe improve things by making sure drivers move what they defer on to the beginning of probe, but that seems like a horrible, fragile hack. >> Another downside to deferred probing is you have to touch every driver >> and subsystem to support it. This contains the problem to the >> subsystems. > > But we have deferred probing already, only those drivers that need/want > it have to do anything, why create yet-another model here? Yes, the only ones needing it are drivers dependent on clocks, gpio, regulators, pwm, pin-ctrl, dma, etc. That's not a small number. This is a side benefit and wouldn't take this series for that reason alone. I've used the deferred probing is good enough argument myself on previous attempts. The boot time
Re: [GIT PULL] On-demand device probing
On Fri, Oct 16, 2015 at 4:23 PM, Olof Johanssonwrote: > Hi, > > I've bisected boot failures in next-20151016 down to patches in this branch: > > On Thu, Oct 15, 2015 at 4:42 AM, Tomeu Vizoso > wrote: >> Tomeu Vizoso (20): >> driver core: handle -EPROBE_DEFER from bus_type.match() > > The machine it happened on was OMAP5UEVM: > > http://arm-soc.lixom.net/bootlogs/next/next-20151016/omap5uevm-arm-omap2plus_defconfig.html So this one is because the MMC node numbering changed. I don't know how to fix that other than with aliases, but that doesn't solve backwards compatibility. > But I've also seen it on tegra2, that one bisected down to: > >> regulator: core: Probe regulators on demand > > http://arm-soc.lixom.net/bootlogs/next/next-20151016/seaboard-arm-multi_v7_defconfig.html This one you need a rootwait I think. The MMC scanning is not guaranteed to be done before the rootfs mounting AFAIK. There may be other problems, but we can't see them since it panics. Rob -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Sat, Oct 17, 2015 at 10:04:55AM -0500, Rob Herring wrote: > On Sat, Oct 17, 2015 at 1:57 AM, Greg Kroah-Hartman >wrote: > > On Wed, Oct 14, 2015 at 10:34:00AM +0200, Tomeu Vizoso wrote: > >> Hi Rob, > >> > >> here is the pull request you asked for, with no changes from the version > >> that I posted last to the list. > >> > >> The following changes since commit > >> 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: > >> > >> Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) > >> > >> are available in the git repository at: > >> > >> git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git > >> on-demand-probes-for-next > > > > That's not a signed tag :( > > > > Anyway, I REALLY don't like this series (sorry for the delay in > > reviewing them, normally I trust Rob's judgement...) > > We've seen a lot of attempts here. This is really the best solution so > far in that it is simple, uses existing data from DT, and was low risk > for breaking platforms (at least I thought it would be). Anyway, > getting more exposure is why I've put it into -next. Exposure is good, now we know it breaks some builds, which was useful :) > > I can't see adding calls like this all over the tree just to solve a > > bus-specific problem, you are adding of_* calls where they aren't > > needed, or wanted, at all. > > I think Linus W, Mark B, and I all said a similar thing initially in > that dependencies should be handled in the driver core. We went down > the path of making this not firmware (aka bus) specific and an earlier > version had just that (with fwnode_* calls). That turned out to be > pointless as the calling locations were almost always in DT specific > code anyway. If you notice, the calls are next to other DT specific > calls generally (usually a "get"). So yes, I'd prefer not to have to > touch every subsystem, but we had to do that anyway to add DT support. If they are "next" to a call like that, why not put it in that call? I really object to having to "sprinkle" this all over the kernel, for no obvious reason why that is happening at all (look at the USB patch for one such example.) > We've generally split the DT code into the core (in drivers/of) and > the binding specific (in subsystems). Extracting dependency > information the DT is going to require binding specific knowledge, so > subsystem changes are probably unavoidable. > > The alternative is we put binding specific knowledge into the core DT > code to parse dependencies. > > > What is the root-problem of your delay in device probing? I read your > > last patch series and I can't seem to figure out what the issue is that > > this is solving in any "better" way from the existing deferred probing. > > It saves 2 seconds in the boot time as re-probing takes time. That > alone seems compelling to me. 2 seconds is _forever_, and really seems like some other driver is sleeping and causing this problem. What does the bootlog time-chart say is really causing this long delay? There's no way we are stuck in some sort of logic loop for that long (i.e. having to walk the list of devices somehow.) This sounds like a driver-specific problem that is being worked around by having to touch all subsystems, which isn't nice. Hint, we didn't have to do this type of thing to solve boot delays on x86 when we had hardware that was slow to initialize, why should DT be special? :) > Another downside to deferred probing is you have to touch every driver > and subsystem to support it. This contains the problem to the > subsystems. But we have deferred probing already, only those drivers that need/want it have to do anything, why create yet-another model here? thanks, greg k-h -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
Hi, I've bisected boot failures in next-20151016 down to patches in this branch: On Thu, Oct 15, 2015 at 4:42 AM, Tomeu Vizosowrote: > Tomeu Vizoso (20): > driver core: handle -EPROBE_DEFER from bus_type.match() The machine it happened on was OMAP5UEVM: http://arm-soc.lixom.net/bootlogs/next/next-20151016/omap5uevm-arm-omap2plus_defconfig.html But I've also seen it on tegra2, that one bisected down to: > regulator: core: Probe regulators on demand http://arm-soc.lixom.net/bootlogs/next/next-20151016/seaboard-arm-multi_v7_defconfig.html -Olof -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[GIT PULL] On-demand device probing
Hi, this second pull request replaces the last references to device_initcall_sync with late_initcall, as noticed by Frank Rowand. Also fixes the url of the git repo and the wrapping, as suggested by Mark Brown. Thanks, Tomeu The following changes since commit 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) are available in the git repository at: git://git.collabora.com/git/user/tomeu/linux.git on-demand-probes-for-next for you to fetch changes up to c074fef5d36e1c27dfdf7474e23c01a1b044ff98: of/platform: Defer probes of registered devices (2015-10-15 13:25:47 +0200) Tomeu Vizoso (20): driver core: handle -EPROBE_DEFER from bus_type.match() ARM: amba: Move reading of periphid to amba_match() of/platform: Point to struct device from device node of: add function to allow probing a device from a OF node gpio: Probe GPIO drivers on demand pinctrl: Probe pinctrl devices on demand regulator: core: Probe regulators on demand drm: Probe panels on demand drm/tegra: Probe dpaux devices on demand i2c: core: Probe i2c adapters and devices on demand pwm: Probe PWM chip devices on demand backlight: Probe backlight devices on demand usb: phy: Probe phy devices on demand clk: Probe clk providers on demand pinctrl: Probe pinctrl devices on demand phy: core: Probe phy providers on demand dma: of: Probe DMA controllers on demand power-supply: Probe power supplies on demand driver core: Allow deferring probes until late init of/platform: Defer probes of registered devices drivers/amba/bus.c | 88 +++-- drivers/base/Kconfig| 18 drivers/base/dd.c | 30 - drivers/clk/clk.c | 3 ++ drivers/dma/of-dma.c| 3 ++ drivers/gpio/gpiolib-of.c | 5 +++ drivers/gpu/drm/drm_panel.c | 3 ++ drivers/gpu/drm/tegra/dpaux.c | 3 ++ drivers/i2c/i2c-core.c | 4 ++ drivers/of/device.c | 61 + drivers/of/platform.c | 30 - drivers/phy/phy-core.c | 3 ++ drivers/pinctrl/devicetree.c| 3 ++ drivers/power/power_supply_core.c | 3 ++ drivers/pwm/core.c | 3 ++ drivers/regulator/core.c| 2 + drivers/usb/phy/phy.c | 3 ++ drivers/video/backlight/backlight.c | 3 ++ include/linux/device.h | 4 +- include/linux/of.h | 1 + include/linux/of_device.h | 3 ++ 21 files changed, 219 insertions(+), 57 deletions(-) -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [GIT PULL] On-demand device probing
On Wed, Oct 14, 2015 at 10:34:00AM +0200, Tomeu Vizoso wrote: > git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git > on-demand-probes-for-next In don't think that's the URL you intended to use (also everything looks word wrapped here)? signature.asc Description: PGP signature
[GIT PULL] On-demand device probing
Hi Rob, here is the pull request you asked for, with no changes from the version that I posted last to the list. The following changes since commit 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f: Linux 4.3-rc1 (2015-09-12 16:35:56 -0700) are available in the git repository at: git+ssh://git.collabora.co.uk/git/user/tomeu/linux.git on-demand-probes-for-next for you to fetch changes up to 587402133fe433759d2d535e5d92ead87fd7f615: of/platform: Defer probes of registered devices (2015-10-14 10:08:23 +0200) Tomeu Vizoso (20): driver core: handle -EPROBE_DEFER from bus_type.match() ARM: amba: Move reading of periphid to amba_match() of/platform: Point to struct device from device node of: add function to allow probing a device from a OF node gpio: Probe GPIO drivers on demand pinctrl: Probe pinctrl devices on demand regulator: core: Probe regulators on demand drm: Probe panels on demand drm/tegra: Probe dpaux devices on demand i2c: core: Probe i2c adapters and devices on demand pwm: Probe PWM chip devices on demand backlight: Probe backlight devices on demand usb: phy: Probe phy devices on demand clk: Probe clk providers on demand pinctrl: Probe pinctrl devices on demand phy: core: Probe phy providers on demand dma: of: Probe DMA controllers on demand power-supply: Probe power supplies on demand driver core: Allow deferring probes until late init of/platform: Defer probes of registered devices drivers/amba/bus.c | 88 ++-- drivers/base/Kconfig | 18 ++ drivers/base/dd.c | 30 -- drivers/clk/clk.c | 3 +++ drivers/dma/of-dma.c | 3 +++ drivers/gpio/gpiolib-of.c | 5 + drivers/gpu/drm/drm_panel.c | 3 +++ drivers/gpu/drm/tegra/dpaux.c | 3 +++ drivers/i2c/i2c-core.c | 4 drivers/of/device.c | 61 + drivers/of/platform.c | 30 ++ drivers/phy/phy-core.c | 3 +++ drivers/pinctrl/devicetree.c | 3 +++ drivers/power/power_supply_core.c | 3 +++ drivers/pwm/core.c | 3 +++ drivers/regulator/core.c | 2 ++ drivers/usb/phy/phy.c | 3 +++ drivers/video/backlight/backlight.c | 3 +++ include/linux/device.h | 4 +++- include/linux/of.h | 1 + include/linux/of_device.h | 3 +++ 21 files changed, 219 insertions(+), 57 deletions(-) Thanks, Tomeu -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html