Add two new public methods `display_name` and `display_path` to
`FwNode`. They can be used by driver authors for logging purposes. In
addition, they will be used by core property abstractions for automatic
logging, for example when a driver attempts to read a required but
missing property.
Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
---
rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
1 file changed, 72 insertions(+)
diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
index 70593343bd811..6ccc7947f9c31 100644
--- a/rust/kernel/device/property.rs
+++ b/rust/kernel/device/property.rs
@@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
self.0.get()
}
+ /// Returns an object that implements [`Display`](core::fmt::Display) for
+ /// printing the name of a node.
+ pub fn display_name(&self) -> impl core::fmt::Display + '_ {
+ struct FwNodeDisplayName<'a>(&'a FwNode);
+
+ impl core::fmt::Display for FwNodeDisplayName<'_> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ // SAFETY: self is valid by its type invariant
+ let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
+ if name.is_null() {
+ return Ok(());
+ }
+ // SAFETY: fwnode_get_name returns null or a valid C string and
+ // name is not null
+ let name = unsafe { CStr::from_char_ptr(name) };
+ write!(f, "{name}")
+ }
+ }
+
+ FwNodeDisplayName(self)
+ }
+
+ /// Returns an object that implements [`Display`](core::fmt::Display) for
+ /// printing the full path of a node.
+ pub fn display_path(&self) -> impl core::fmt::Display + '_ {
+ struct FwNodeDisplayPath<'a>(&'a FwNode);
+
+ impl core::fmt::Display for FwNodeDisplayPath<'_> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ // The logic here is the same as the one in lib/vsprintf.c
+ // (fwnode_full_name_string).
+
+ // SAFETY: `self.0.as_raw()` is valid by its type invariant
+ let num_parents = unsafe { bindings::fwnode_count_parents(self.0.as_raw()) };
+
+ for depth in (0..=num_parents).rev() {
+ let fwnode = if depth == 0 {
+ self.0.as_raw()
+ } else {
+ // SAFETY: `self.0.as_raw()` is valid
+ unsafe { bindings::fwnode_get_nth_parent(self.0.as_raw(), depth) }
+ };
+
+ // SAFETY: fwnode is valid, it is either `self.0.as_raw()` or
+ // the return value of `bindings::fwnode_get_nth_parent` which
+ // returns a valid pointer to a fwnode_handle if the provided
+ // depth is within the valid range, which we know to be true.
+ let prefix = unsafe { bindings::fwnode_get_name_prefix(fwnode) };
+ if !prefix.is_null() {
+ // SAFETY: fwnode_get_name_prefix returns null or a
+ // valid C string
+ let prefix = unsafe { CStr::from_char_ptr(prefix) };
+ write!(f, "{prefix}")?;
+ }
+ write!(f, "{}", self.0.display_name())?;
+
+ if depth != 0 {
+ // SAFETY: `fwnode` is valid, because `depth` is
+ // a valid depth of a parent of `self.0.as_raw()`.
+ // `fwnode_get_nth_parent` increments the refcount and
+ // we are responsible to decrement it.
+ unsafe { bindings::fwnode_handle_put(fwnode) }
+ }
+ }
+
+ Ok(())
+ }
+ }
+
+ FwNodeDisplayPath(self)
+ }
+
/// Checks if property is present or not.
pub fn property_present(&self, name: &CStr) -> bool {
// SAFETY: By the invariant of `CStr`, `name` is null-terminated.
--
2.49.0On Tue, May 20, 2025 at 10:01 PM Remo Senekowitsch <remo@buenzli.dev> wrote: > > + // SAFETY: self is valid by its type invariant Please try to be consistent with the style of the rest of the code, e.g. use Markdown in comments and end with a period (you do it in some cases, but most are missing). Thanks! Cheers, Miguel
On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
> Add two new public methods `display_name` and `display_path` to
> `FwNode`. They can be used by driver authors for logging purposes. In
> addition, they will be used by core property abstractions for automatic
> logging, for example when a driver attempts to read a required but
> missing property.
>
> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
> ---
> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
> 1 file changed, 72 insertions(+)
>
> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
> index 70593343bd811..6ccc7947f9c31 100644
> --- a/rust/kernel/device/property.rs
> +++ b/rust/kernel/device/property.rs
> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
> self.0.get()
> }
>
> + /// Returns an object that implements [`Display`](core::fmt::Display) for
> + /// printing the name of a node.
> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
> + struct FwNodeDisplayName<'a>(&'a FwNode);
> +
> + impl core::fmt::Display for FwNodeDisplayName<'_> {
> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
> + // SAFETY: self is valid by its type invariant
> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
> + if name.is_null() {
> + return Ok(());
So if there is no name, you are returning Ok()? Are you sure that's ok
to do? What will the result of the string look like then?
thanks,
greg k-h
On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
> On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
>> Add two new public methods `display_name` and `display_path` to
>> `FwNode`. They can be used by driver authors for logging purposes. In
>> addition, they will be used by core property abstractions for automatic
>> logging, for example when a driver attempts to read a required but
>> missing property.
>>
>> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
>> ---
>> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
>> 1 file changed, 72 insertions(+)
>>
>> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
>> index 70593343bd811..6ccc7947f9c31 100644
>> --- a/rust/kernel/device/property.rs
>> +++ b/rust/kernel/device/property.rs
>> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
>> self.0.get()
>> }
>>
>> + /// Returns an object that implements [`Display`](core::fmt::Display) for
>> + /// printing the name of a node.
>> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
>> + struct FwNodeDisplayName<'a>(&'a FwNode);
>> +
>> + impl core::fmt::Display for FwNodeDisplayName<'_> {
>> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
>> + // SAFETY: self is valid by its type invariant
>> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
>> + if name.is_null() {
>> + return Ok(());
>
> So if there is no name, you are returning Ok()? Are you sure that's ok
> to do? What will the result of the string look like then?
In that case we're not writing anything to the formatter, which is
equivalent to an empty string. `Ok(())` means that writing succeeded.
I assumed that a valid node would always have a name. And we're
guaranteed to have a valid node. So I assumed this case would never
happen and didn't think too hard about it. But even if a valid node has
not name, empty string is probably the correct thing, right?
On Wed, May 21, 2025 at 03:03:07PM +0200, Remo Senekowitsch wrote:
> On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
> > On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
> >> Add two new public methods `display_name` and `display_path` to
> >> `FwNode`. They can be used by driver authors for logging purposes. In
> >> addition, they will be used by core property abstractions for automatic
> >> logging, for example when a driver attempts to read a required but
> >> missing property.
> >>
> >> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
> >> ---
> >> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
> >> 1 file changed, 72 insertions(+)
> >>
> >> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
> >> index 70593343bd811..6ccc7947f9c31 100644
> >> --- a/rust/kernel/device/property.rs
> >> +++ b/rust/kernel/device/property.rs
> >> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
> >> self.0.get()
> >> }
> >>
> >> + /// Returns an object that implements [`Display`](core::fmt::Display) for
> >> + /// printing the name of a node.
> >> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
> >> + struct FwNodeDisplayName<'a>(&'a FwNode);
> >> +
> >> + impl core::fmt::Display for FwNodeDisplayName<'_> {
> >> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
> >> + // SAFETY: self is valid by its type invariant
> >> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
> >> + if name.is_null() {
> >> + return Ok(());
> >
> > So if there is no name, you are returning Ok()? Are you sure that's ok
> > to do? What will the result of the string look like then?
>
> In that case we're not writing anything to the formatter, which is
> equivalent to an empty string. `Ok(())` means that writing succeeded.
>
> I assumed that a valid node would always have a name. And we're
> guaranteed to have a valid node. So I assumed this case would never
> happen and didn't think too hard about it. But even if a valid node has
> not name, empty string is probably the correct thing, right?
I don't know what this "name" is used for. An empty string might not be
what you want to use here, given that you could be naming something
based on it, right? fwnode_get_name() is used for many things,
including the detection if a name is not present at all, and if not,
then the code needs to clean up and abort.
So what exactly are you going to be using this for?
thanks,
greg k-h
On Wed May 21, 2025 at 6:58 PM CEST, Greg Kroah-Hartman wrote:
> On Wed, May 21, 2025 at 03:03:07PM +0200, Remo Senekowitsch wrote:
>> On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
>> > On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
>> >> Add two new public methods `display_name` and `display_path` to
>> >> `FwNode`. They can be used by driver authors for logging purposes. In
>> >> addition, they will be used by core property abstractions for automatic
>> >> logging, for example when a driver attempts to read a required but
>> >> missing property.
>> >>
>> >> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
>> >> ---
>> >> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
>> >> 1 file changed, 72 insertions(+)
>> >>
>> >> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
>> >> index 70593343bd811..6ccc7947f9c31 100644
>> >> --- a/rust/kernel/device/property.rs
>> >> +++ b/rust/kernel/device/property.rs
>> >> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
>> >> self.0.get()
>> >> }
>> >>
>> >> + /// Returns an object that implements [`Display`](core::fmt::Display) for
>> >> + /// printing the name of a node.
>> >> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
>> >> + struct FwNodeDisplayName<'a>(&'a FwNode);
>> >> +
>> >> + impl core::fmt::Display for FwNodeDisplayName<'_> {
>> >> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
>> >> + // SAFETY: self is valid by its type invariant
>> >> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
>> >> + if name.is_null() {
>> >> + return Ok(());
>> >
>> > So if there is no name, you are returning Ok()? Are you sure that's ok
>> > to do? What will the result of the string look like then?
>>
>> In that case we're not writing anything to the formatter, which is
>> equivalent to an empty string. `Ok(())` means that writing succeeded.
>>
>> I assumed that a valid node would always have a name. And we're
>> guaranteed to have a valid node. So I assumed this case would never
>> happen and didn't think too hard about it. But even if a valid node has
>> not name, empty string is probably the correct thing, right?
>
> I don't know what this "name" is used for. An empty string might not be
> what you want to use here, given that you could be naming something
> based on it, right? fwnode_get_name() is used for many things,
> including the detection if a name is not present at all, and if not,
> then the code needs to clean up and abort.
>
> So what exactly are you going to be using this for?
Valid question... I'm not using it for anything. I was trying to match
the C API which has capabilities to print a fwnode's name and full path.
I think the format specifiers are %pfwP and %pfwf if I'm reading the
source correctly. It also looks to me like the C API for printing fwnode
names does the same thing - print nothing if the name is null. [1] [2]
[1] https://elixir.bootlin.com/linux/v6.14.7/source/lib/vsprintf.c#L2242
[2] https://elixir.bootlin.com/linux/v6.14.7/source/lib/vsprintf.c#L711
On Wed, May 21, 2025 at 08:36:10PM +0200, Remo Senekowitsch wrote:
> On Wed May 21, 2025 at 6:58 PM CEST, Greg Kroah-Hartman wrote:
> > On Wed, May 21, 2025 at 03:03:07PM +0200, Remo Senekowitsch wrote:
> >> On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
> >> > On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
> >> >> Add two new public methods `display_name` and `display_path` to
> >> >> `FwNode`. They can be used by driver authors for logging purposes. In
> >> >> addition, they will be used by core property abstractions for automatic
> >> >> logging, for example when a driver attempts to read a required but
> >> >> missing property.
> >> >>
> >> >> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
> >> >> ---
> >> >> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
> >> >> 1 file changed, 72 insertions(+)
> >> >>
> >> >> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
> >> >> index 70593343bd811..6ccc7947f9c31 100644
> >> >> --- a/rust/kernel/device/property.rs
> >> >> +++ b/rust/kernel/device/property.rs
> >> >> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
> >> >> self.0.get()
> >> >> }
> >> >>
> >> >> + /// Returns an object that implements [`Display`](core::fmt::Display) for
> >> >> + /// printing the name of a node.
> >> >> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
> >> >> + struct FwNodeDisplayName<'a>(&'a FwNode);
> >> >> +
> >> >> + impl core::fmt::Display for FwNodeDisplayName<'_> {
> >> >> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
> >> >> + // SAFETY: self is valid by its type invariant
> >> >> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
> >> >> + if name.is_null() {
> >> >> + return Ok(());
> >> >
> >> > So if there is no name, you are returning Ok()? Are you sure that's ok
> >> > to do? What will the result of the string look like then?
> >>
> >> In that case we're not writing anything to the formatter, which is
> >> equivalent to an empty string. `Ok(())` means that writing succeeded.
> >>
> >> I assumed that a valid node would always have a name. And we're
> >> guaranteed to have a valid node. So I assumed this case would never
> >> happen and didn't think too hard about it. But even if a valid node has
> >> not name, empty string is probably the correct thing, right?
> >
> > I don't know what this "name" is used for. An empty string might not be
> > what you want to use here, given that you could be naming something
> > based on it, right? fwnode_get_name() is used for many things,
> > including the detection if a name is not present at all, and if not,
> > then the code needs to clean up and abort.
> >
> > So what exactly are you going to be using this for?
>
> Valid question... I'm not using it for anything.
You're using this in PropertyGuard::required_by(), where you use display_path()
and hence display_name() to print the node path in the error case.
So, currently, this is only used in the error case when a property of a given
node that is required by a driver can't be found.
On Wed, May 21, 2025 at 09:13:08PM +0200, Danilo Krummrich wrote:
> On Wed, May 21, 2025 at 08:36:10PM +0200, Remo Senekowitsch wrote:
> > On Wed May 21, 2025 at 6:58 PM CEST, Greg Kroah-Hartman wrote:
> > > On Wed, May 21, 2025 at 03:03:07PM +0200, Remo Senekowitsch wrote:
> > >> On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
> > >> > On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
> > >> >> Add two new public methods `display_name` and `display_path` to
> > >> >> `FwNode`. They can be used by driver authors for logging purposes. In
> > >> >> addition, they will be used by core property abstractions for automatic
> > >> >> logging, for example when a driver attempts to read a required but
> > >> >> missing property.
> > >> >>
> > >> >> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
> > >> >> ---
> > >> >> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
> > >> >> 1 file changed, 72 insertions(+)
> > >> >>
> > >> >> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
> > >> >> index 70593343bd811..6ccc7947f9c31 100644
> > >> >> --- a/rust/kernel/device/property.rs
> > >> >> +++ b/rust/kernel/device/property.rs
> > >> >> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
> > >> >> self.0.get()
> > >> >> }
> > >> >>
> > >> >> + /// Returns an object that implements [`Display`](core::fmt::Display) for
> > >> >> + /// printing the name of a node.
> > >> >> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
> > >> >> + struct FwNodeDisplayName<'a>(&'a FwNode);
> > >> >> +
> > >> >> + impl core::fmt::Display for FwNodeDisplayName<'_> {
> > >> >> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
> > >> >> + // SAFETY: self is valid by its type invariant
> > >> >> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
> > >> >> + if name.is_null() {
> > >> >> + return Ok(());
> > >> >
> > >> > So if there is no name, you are returning Ok()? Are you sure that's ok
> > >> > to do? What will the result of the string look like then?
> > >>
> > >> In that case we're not writing anything to the formatter, which is
> > >> equivalent to an empty string. `Ok(())` means that writing succeeded.
> > >>
> > >> I assumed that a valid node would always have a name. And we're
> > >> guaranteed to have a valid node. So I assumed this case would never
> > >> happen and didn't think too hard about it. But even if a valid node has
> > >> not name, empty string is probably the correct thing, right?
> > >
> > > I don't know what this "name" is used for. An empty string might not be
> > > what you want to use here, given that you could be naming something
> > > based on it, right? fwnode_get_name() is used for many things,
> > > including the detection if a name is not present at all, and if not,
> > > then the code needs to clean up and abort.
> > >
> > > So what exactly are you going to be using this for?
> >
> > Valid question... I'm not using it for anything.
>
> You're using this in PropertyGuard::required_by(), where you use display_path()
> and hence display_name() to print the node path in the error case.
>
> So, currently, this is only used in the error case when a property of a given
> node that is required by a driver can't be found.
And in that case, the "normal" dev_err() output should be all that is
needed here, not a "pretty printer" that might fail to document it at
all :)
thanks,
greg k-h
On Thu, May 22, 2025 at 06:49:15AM +0200, Greg Kroah-Hartman wrote:
> On Wed, May 21, 2025 at 09:13:08PM +0200, Danilo Krummrich wrote:
> > On Wed, May 21, 2025 at 08:36:10PM +0200, Remo Senekowitsch wrote:
> > > On Wed May 21, 2025 at 6:58 PM CEST, Greg Kroah-Hartman wrote:
> > > > On Wed, May 21, 2025 at 03:03:07PM +0200, Remo Senekowitsch wrote:
> > > >> On Wed May 21, 2025 at 2:02 PM CEST, Greg Kroah-Hartman wrote:
> > > >> > On Tue, May 20, 2025 at 10:00:19PM +0200, Remo Senekowitsch wrote:
> > > >> >> Add two new public methods `display_name` and `display_path` to
> > > >> >> `FwNode`. They can be used by driver authors for logging purposes. In
> > > >> >> addition, they will be used by core property abstractions for automatic
> > > >> >> logging, for example when a driver attempts to read a required but
> > > >> >> missing property.
> > > >> >>
> > > >> >> Signed-off-by: Remo Senekowitsch <remo@buenzli.dev>
> > > >> >> ---
> > > >> >> rust/kernel/device/property.rs | 72 ++++++++++++++++++++++++++++++++++
> > > >> >> 1 file changed, 72 insertions(+)
> > > >> >>
> > > >> >> diff --git a/rust/kernel/device/property.rs b/rust/kernel/device/property.rs
> > > >> >> index 70593343bd811..6ccc7947f9c31 100644
> > > >> >> --- a/rust/kernel/device/property.rs
> > > >> >> +++ b/rust/kernel/device/property.rs
> > > >> >> @@ -32,6 +32,78 @@ pub(crate) fn as_raw(&self) -> *mut bindings::fwnode_handle {
> > > >> >> self.0.get()
> > > >> >> }
> > > >> >>
> > > >> >> + /// Returns an object that implements [`Display`](core::fmt::Display) for
> > > >> >> + /// printing the name of a node.
> > > >> >> + pub fn display_name(&self) -> impl core::fmt::Display + '_ {
> > > >> >> + struct FwNodeDisplayName<'a>(&'a FwNode);
> > > >> >> +
> > > >> >> + impl core::fmt::Display for FwNodeDisplayName<'_> {
> > > >> >> + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
> > > >> >> + // SAFETY: self is valid by its type invariant
> > > >> >> + let name = unsafe { bindings::fwnode_get_name(self.0.as_raw()) };
> > > >> >> + if name.is_null() {
> > > >> >> + return Ok(());
> > > >> >
> > > >> > So if there is no name, you are returning Ok()? Are you sure that's ok
> > > >> > to do? What will the result of the string look like then?
> > > >>
> > > >> In that case we're not writing anything to the formatter, which is
> > > >> equivalent to an empty string. `Ok(())` means that writing succeeded.
> > > >>
> > > >> I assumed that a valid node would always have a name. And we're
> > > >> guaranteed to have a valid node. So I assumed this case would never
> > > >> happen and didn't think too hard about it. But even if a valid node has
> > > >> not name, empty string is probably the correct thing, right?
> > > >
> > > > I don't know what this "name" is used for. An empty string might not be
> > > > what you want to use here, given that you could be naming something
> > > > based on it, right? fwnode_get_name() is used for many things,
> > > > including the detection if a name is not present at all, and if not,
> > > > then the code needs to clean up and abort.
> > > >
> > > > So what exactly are you going to be using this for?
> > >
> > > Valid question... I'm not using it for anything.
> >
> > You're using this in PropertyGuard::required_by(), where you use display_path()
> > and hence display_name() to print the node path in the error case.
> >
> > So, currently, this is only used in the error case when a property of a given
> > node that is required by a driver can't be found.
>
> And in that case, the "normal" dev_err() output should be all that is
> needed here, not a "pretty printer" that might fail to document it at
> all :)
That's what the code does; PropertyGuard::required_by() uses dev_err!() to print
the string.
It's just that the functions from the C side that provide the strings are
abstracted in an implementation of core::fmt::Display for the FwNode, which is
the idiomatic way to abstract a string representations of a type.
And since Display::fmt() is fallible, we need to decide if NULL is a valid value
for fwnode_get_name() to return. The interface, i.e. struct fwnode_operations,
does not document this, but to me it seems that fwnode_get_name() returning a
NULL pointer is an error case.
© 2016 - 2025 Red Hat, Inc.