[PATCH v2 net-next 0/2] net: print net_device name/state more often

[PATCH v2 net-next 0/2] net: print net_device name/state more often

[Veaceslav Falico]

Hi,

Currently we use net_device->name only if it's the NETREG_REGISTERED
reg_state, otherwise we return "(unregistered device)".

However, we always populate net_device->name on creation, so it's always
available to us for use. The only caveat is that we might have a name like
"eth%d", in which case we cannot use it as it might change in the future.

Also, the net_device might not be NETREG_UNREGISTERED when the function is
called (_UNINITIALIZED, _UNREGISTERING, _RELEASED, _DUMMY), so it's
misleading.

So, a better way would be to always return the dev->name in netdev_name(),
unless it's in the form of "eth%d" or it's empty, then return
"unnamed net_device". This way we'll always return the name in
NETREG_REGISTERED reg_state, and also return it in other states, when
possible.

Also, to be more verbose on non-NETREG_REGISTERED states, add a function
netdev_reg_state(), which returns a string describing the state, and use it
in netdev_printk()-related functions. If the dev is in NETREG_REGISTERED
state then a void string is regurned and, thus, nothing changes.

After these two patches we'll have the same behaviour in the usual cases,
and more verbose in non-standardad/buggy ones.

v1->v2:
As Tom Gundersen suggested, there might be a case when we have an empty
string as a name for a device, so account this also and return "unnamed
device" for that case too.

CC: "David S. Miller" <davem@davemloft.net>
CC: Jason Baron <jbaron@akamai.com>
CC: Eric Dumazet <edumazet@google.com>
CC: Vlad Yasevich <vyasevic@redhat.com>
CC: stephen hemminger <stephen@networkplumber.org>
CC: Jerry Chu <hkchu@google.com>
CC: Ben Hutchings <bhutchings@solarflare.com>
CC: Tom Gundersen <teg@jklm.no>
Signed-off-by: Veaceslav Falico <vfalico@gmail.com>

---
 include/linux/netdevice.h | 21 ++++++++++++++++++---
 lib/dynamic_debug.c       |  8 +++++---
 net/core/dev.c            |  8 +++++---
 3 files changed, 28 insertions(+), 9 deletions(-)

[PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Veaceslav Falico]

netdev_name() returns dev->name only when the net_device is in
NETREG_REGISTERED state.

However, dev->name is always populated on creation, so we can easily use
it.

There are two cases when there's no real name - when it's an empty string
or when the name is in form of "eth%d", then netdev_name() returns "unnamed
net_device".

CC: "David S. Miller" <davem@davemloft.net>
CC: Tom Gundersen <teg@jklm.no>
Signed-off-by: Veaceslav Falico <vfalico@gmail.com>
---

Notes:
    v1->v2:
    Also account for an empty string, as Tom Gundersen suggested.

 include/linux/netdevice.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 15ed750..70256aa 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -3383,8 +3383,8 @@ extern struct pernet_operations __net_initdata loopback_net_ops;
 
 static inline const char *netdev_name(const struct net_device *dev)
 {
-	if (dev->reg_state != NETREG_REGISTERED)
-		return "(unregistered net_device)";
+	if (!dev->name[0] || strchr(dev->name, '%'))
+		return "(unnamed net_device)";
 	return dev->name;
 }
 
-- 
1.8.4

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Joe Perches]

On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
> netdev_name() returns dev->name only when the net_device is in
> NETREG_REGISTERED state.
> 
> However, dev->name is always populated on creation, so we can easily use
> it.
> 
> There are two cases when there's no real name - when it's an empty string
> or when the name is in form of "eth%d", then netdev_name() returns "unnamed
> net_device".
> 
> CC: "David S. Miller" <davem@davemloft.net>
> CC: Tom Gundersen <teg@jklm.no>
> Signed-off-by: Veaceslav Falico <vfalico@gmail.com>
> ---
> 
> Notes:
>     v1->v2:
>     Also account for an empty string, as Tom Gundersen suggested.
> 
>  include/linux/netdevice.h | 4 ++--
>  1 file changed, 2 insertions(+), 2 deletions(-)
> 
> diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
> index 15ed750..70256aa 100644
> --- a/include/linux/netdevice.h
> +++ b/include/linux/netdevice.h
> @@ -3383,8 +3383,8 @@ extern struct pernet_operations __net_initdata loopback_net_ops;
>  
>  static inline const char *netdev_name(const struct net_device *dev)
>  {
> -	if (dev->reg_state != NETREG_REGISTERED)
> -		return "(unregistered net_device)";
> +	if (!dev->name[0] || strchr(dev->name, '%'))
> +		return "(unnamed net_device)";
>  	return dev->name;
>  }
>  

Maybe this should not be inline and become something like:

const char *netdev_name(const struct net_device *dev)
{
	if (dev->reg_state == NETREG_REGISTERED)
		return dev->name;

	if (!dev->name[0])
		return "(unnamed net_device)";

	if (!strchr(dev->name, '%'))
		return "(unregistered net_device)";

	return dev->name;
}
EXPORT_SYMBOL(netdev_name);

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Veaceslav Falico]

On Thu, Jul 17, 2014 at 09:18:44AM -0700, Joe Perches wrote:
>On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
>> netdev_name() returns dev->name only when the net_device is in
>> NETREG_REGISTERED state.
>>
>> However, dev->name is always populated on creation, so we can easily use
>> it.
>>
>> There are two cases when there's no real name - when it's an empty string
>> or when the name is in form of "eth%d", then netdev_name() returns "unnamed
>> net_device".
>>
>> CC: "David S. Miller" <davem@davemloft.net>
>> CC: Tom Gundersen <teg@jklm.no>
>> Signed-off-by: Veaceslav Falico <vfalico@gmail.com>
>> ---
>>
>> Notes:
>>     v1->v2:
>>     Also account for an empty string, as Tom Gundersen suggested.
>>
>>  include/linux/netdevice.h | 4 ++--
>>  1 file changed, 2 insertions(+), 2 deletions(-)
>>
>> diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
>> index 15ed750..70256aa 100644
>> --- a/include/linux/netdevice.h
>> +++ b/include/linux/netdevice.h
>> @@ -3383,8 +3383,8 @@ extern struct pernet_operations __net_initdata loopback_net_ops;
>>
>>  static inline const char *netdev_name(const struct net_device *dev)
>>  {
>> -	if (dev->reg_state != NETREG_REGISTERED)
>> -		return "(unregistered net_device)";
>> +	if (!dev->name[0] || strchr(dev->name, '%'))
>> +		return "(unnamed net_device)";
>>  	return dev->name;
>>  }
>>
>
>Maybe this should not be inline and become something like:

It will miss the states then, when it's not NETREG_REGISTERED.

>
>const char *netdev_name(const struct net_device *dev)
>{
>	if (dev->reg_state == NETREG_REGISTERED)
>		return dev->name;
>
>	if (!dev->name[0])
>		return "(unnamed net_device)";
>
>	if (!strchr(dev->name, '%'))
>		return "(unregistered net_device)";
>
>	return dev->name;
>}
>EXPORT_SYMBOL(netdev_name);
>
>

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Joe Perches]

On Thu, 2014-07-17 at 18:25 +0200, Veaceslav Falico wrote:
> On Thu, Jul 17, 2014 at 09:18:44AM -0700, Joe Perches wrote:
> >On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
> >> netdev_name() returns dev->name only when the net_device is in
> >> NETREG_REGISTERED state.
[]
> >Maybe this should not be inline and become something like:
> 
> It will miss the states then, when it's not NETREG_REGISTERED.

If it's registered, it has a valid name via
dev_get_valid_name() doesn't it?

> >const char *netdev_name(const struct net_device *dev)
> >{
> >	if (dev->reg_state == NETREG_REGISTERED)
> >		return dev->name;
> >
> >	if (!dev->name[0])
> >		return "(unnamed net_device)";
> >
> >	if (!strchr(dev->name, '%'))
> >		return "(unregistered net_device)";
> >
> >	return dev->name;
> >}
> >EXPORT_SYMBOL(netdev_name);

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Veaceslav Falico]

On Thu, Jul 17, 2014 at 09:36:08AM -0700, Joe Perches wrote:
>On Thu, 2014-07-17 at 18:25 +0200, Veaceslav Falico wrote:
>> On Thu, Jul 17, 2014 at 09:18:44AM -0700, Joe Perches wrote:
>> >On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
>> >> netdev_name() returns dev->name only when the net_device is in
>> >> NETREG_REGISTERED state.
>[]
>> >Maybe this should not be inline and become something like:
>>
>> It will miss the states then, when it's not NETREG_REGISTERED.
>
>If it's registered, it has a valid name via
>dev_get_valid_name() doesn't it?

Yes, I'm speaking about the NETREG_* states when it's not registered.

i.e.:

Jul 17 13:35:29 darkmag kernel: [  602.686489] bond2 (unregistering): Released all slaves

that's with my patchset, when the bond device is unregistering
(NETREG_UNREGISTERING). With your patch it would be only "bond2: Released
all slaves".

As the most time the device is in the NETREG_REGISTERED state, there will
be no differencies in the output (with either my or your approach), however
in less-common states/codepaths it will also output its state, which might
be quite valuable when analyzing the logs.

>
>> >const char *netdev_name(const struct net_device *dev)
>> >{
>> >	if (dev->reg_state == NETREG_REGISTERED)
>> >		return dev->name;
>> >
>> >	if (!dev->name[0])
>> >		return "(unnamed net_device)";
>> >
>> >	if (!strchr(dev->name, '%'))
>> >		return "(unregistered net_device)";
>> >
>> >	return dev->name;
>> >}
>> >EXPORT_SYMBOL(netdev_name);
>
>
>

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Joe Perches]

On Thu, 2014-07-17 at 18:38 +0200, Veaceslav Falico wrote:
> On Thu, Jul 17, 2014 at 09:36:08AM -0700, Joe Perches wrote:
> >On Thu, 2014-07-17 at 18:25 +0200, Veaceslav Falico wrote:
> >> On Thu, Jul 17, 2014 at 09:18:44AM -0700, Joe Perches wrote:
> >> >On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
> >> >> netdev_name() returns dev->name only when the net_device is in
> >> >> NETREG_REGISTERED state.
> >[]
> >> >Maybe this should not be inline and become something like:
> >>
> >> It will miss the states then, when it's not NETREG_REGISTERED.
> >
> >If it's registered, it has a valid name via
> >dev_get_valid_name() doesn't it?
> 
> Yes, I'm speaking about the NETREG_* states when it's not registered.
> 
> i.e.:
> 
> Jul 17 13:35:29 darkmag kernel: [  602.686489] bond2 (unregistering): Released all slaves

OK, I hadn't read the patch where netdev_reg_state was emitted.

Still, it's probably smaller overall code to uninline it now.

Re: [PATCH v2 net-next 1/2] net: use dev->name in netdev_pr* when it's available

[Veaceslav Falico]

On Thu, Jul 17, 2014 at 09:58:16AM -0700, Joe Perches wrote:
>On Thu, 2014-07-17 at 18:38 +0200, Veaceslav Falico wrote:
>> On Thu, Jul 17, 2014 at 09:36:08AM -0700, Joe Perches wrote:
>> >On Thu, 2014-07-17 at 18:25 +0200, Veaceslav Falico wrote:
>> >> On Thu, Jul 17, 2014 at 09:18:44AM -0700, Joe Perches wrote:
>> >> >On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
>> >> >> netdev_name() returns dev->name only when the net_device is in
>> >> >> NETREG_REGISTERED state.
>> >[]
>> >> >Maybe this should not be inline and become something like:
>> >>
>> >> It will miss the states then, when it's not NETREG_REGISTERED.
>> >
>> >If it's registered, it has a valid name via
>> >dev_get_valid_name() doesn't it?
>>
>> Yes, I'm speaking about the NETREG_* states when it's not registered.
>>
>> i.e.:
>>
>> Jul 17 13:35:29 darkmag kernel: [  602.686489] bond2 (unregistering): Released all slaves
>
>OK, I hadn't read the patch where netdev_reg_state was emitted.
>
>Still, it's probably smaller overall code to uninline it now.

I don't really care about that, and it's used only in several non-inlined
functions anyway, so the difference would be minimal, if any. I can easily
re-spin it unlined, however I don't really see a point in doing so :).

[PATCH v2 net-next 2/2] net: print net_device reg_state in netdev_* unless it's registered

[Veaceslav Falico]

This way we'll always know in what status the device is, unless it's
running normally (i.e. NETDEV_REGISTERED).

CC: "David S. Miller" <davem@davemloft.net>
CC: Jason Baron <jbaron@akamai.com>
CC: Eric Dumazet <edumazet@google.com>
CC: Vlad Yasevich <vyasevic@redhat.com>
CC: stephen hemminger <stephen@networkplumber.org>
CC: Jerry Chu <hkchu@google.com>
CC: Ben Hutchings <bhutchings@solarflare.com>
Signed-off-by: Veaceslav Falico <vfalico@gmail.com>
---
 include/linux/netdevice.h | 17 ++++++++++++++++-
 lib/dynamic_debug.c       |  8 +++++---
 net/core/dev.c            |  8 +++++---
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 70256aa..d868858 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -3388,6 +3388,20 @@ static inline const char *netdev_name(const struct net_device *dev)
 	return dev->name;
 }
 
+static inline const char *netdev_reg_state(const struct net_device *dev)
+{
+	switch (dev->reg_state) {
+	case NETREG_UNINITIALIZED: return " (unregistered)";
+	case NETREG_REGISTERED: return "";
+	case NETREG_UNREGISTERING: return " (unregistering)";
+	case NETREG_UNREGISTERED: return " (unregistered)";
+	case NETREG_RELEASED: return " (released)";
+	case NETREG_DUMMY: return " (dummy)";
+	}
+
+	return " (unknown)";
+}
+
 __printf(3, 4)
 int netdev_printk(const char *level, const struct net_device *dev,
 		  const char *format, ...);
@@ -3444,7 +3458,8 @@ do {								\
  * file/line information and a backtrace.
  */
 #define netdev_WARN(dev, format, args...)			\
-	WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args)
+	WARN(1, "netdevice: %s%s\n" format, netdev_name(dev),	\
+	     netdev_reg_state(dev), ##args)
 
 /* netif printk helpers, similar to netdev_printk */
 
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index 7288e38..c9afbe2 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -614,13 +614,15 @@ int __dynamic_netdev_dbg(struct _ddebug *descriptor,
 		char buf[PREFIX_SIZE];
 
 		res = dev_printk_emit(7, dev->dev.parent,
-				      "%s%s %s %s: %pV",
+				      "%s%s %s %s%s: %pV",
 				      dynamic_emit_prefix(descriptor, buf),
 				      dev_driver_string(dev->dev.parent),
 				      dev_name(dev->dev.parent),
-				      netdev_name(dev), &vaf);
+				      netdev_name(dev), netdev_reg_state(dev),
+				      &vaf);
 	} else if (dev) {
-		res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
+		res = printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
+			     netdev_reg_state(dev), &vaf);
 	} else {
 		res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 	}
diff --git a/net/core/dev.c b/net/core/dev.c
index 239722a..81d6101 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -6950,12 +6950,14 @@ static int __netdev_printk(const char *level, const struct net_device *dev,
 	if (dev && dev->dev.parent) {
 		r = dev_printk_emit(level[1] - '0',
 				    dev->dev.parent,
-				    "%s %s %s: %pV",
+				    "%s %s %s%s: %pV",
 				    dev_driver_string(dev->dev.parent),
 				    dev_name(dev->dev.parent),
-				    netdev_name(dev), vaf);
+				    netdev_name(dev), netdev_reg_state(dev),
+				    vaf);
 	} else if (dev) {
-		r = printk("%s%s: %pV", level, netdev_name(dev), vaf);
+		r = printk("%s%s%s: %pV", level, netdev_name(dev),
+			   netdev_reg_state(dev), vaf);
 	} else {
 		r = printk("%s(NULL net_device): %pV", level, vaf);
 	}
-- 
1.8.4

Re: [PATCH v2 net-next 2/2] net: print net_device reg_state in netdev_* unless it's registered

[Joe Perches]

On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
> This way we'll always know in what status the device is, unless it's
> running normally (i.e. NETDEV_REGISTERED).
[]
> diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
[]
> @@ -3388,6 +3388,20 @@ static inline const char *netdev_name(const struct net_device *dev)
>  	return dev->name;
>  }
>  
> +static inline const char *netdev_reg_state(const struct net_device *dev)
> +{
> +	switch (dev->reg_state) {
> +	case NETREG_UNINITIALIZED: return " (unregistered)";

Why not " (uninitialized)"?

> +	case NETREG_REGISTERED: return "";
> +	case NETREG_UNREGISTERING: return " (unregistering)";
> +	case NETREG_UNREGISTERED: return " (unregistered)";
> +	case NETREG_RELEASED: return " (released)";
> +	case NETREG_DUMMY: return " (dummy)";
> +	}
> +
> +	return " (unknown)";

Shouldn't this " (unknown)" have stronger text
and use a WARN_ON_ONCE?

I'd put this in net/core/dev.c and make it not be static inline.

Re: [PATCH v2 net-next 2/2] net: print net_device reg_state in netdev_* unless it's registered

[Veaceslav Falico]

On Thu, Jul 17, 2014 at 10:00:24AM -0700, Joe Perches wrote:
>On Thu, 2014-07-17 at 16:09 +0200, Veaceslav Falico wrote:
>> This way we'll always know in what status the device is, unless it's
>> running normally (i.e. NETDEV_REGISTERED).
>[]
>> diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
>[]
>> @@ -3388,6 +3388,20 @@ static inline const char *netdev_name(const struct net_device *dev)
>>  	return dev->name;
>>  }
>>
>> +static inline const char *netdev_reg_state(const struct net_device *dev)
>> +{
>> +	switch (dev->reg_state) {
>> +	case NETREG_UNINITIALIZED: return " (unregistered)";
>
>Why not " (uninitialized)"?

Good one, thank you, missed it somehow. Will send v2.

>
>> +	case NETREG_REGISTERED: return "";
>> +	case NETREG_UNREGISTERING: return " (unregistering)";
>> +	case NETREG_UNREGISTERED: return " (unregistered)";
>> +	case NETREG_RELEASED: return " (released)";
>> +	case NETREG_DUMMY: return " (dummy)";
>> +	}
>> +
>> +	return " (unknown)";
>
>Shouldn't this " (unknown)" have stronger text
>and use a WARN_ON_ONCE?

Hrm, I don't remember why, but I've specifically dropped the warning here.
Now it seems like a good idea, so I'll add it here.

>
>I'd put this in net/core/dev.c and make it not be static inline.

Again, I don't think it's really needed, as it's used in 4 functions (which
aren't inline), so the benefits are minimal, if any.

I'll rather keep them inline, I guess...

>
>

RE: [PATCH v2 net-next 0/2] net: print net_device name/state more often

[David Laight]

From: Veaceslav Falico
> Currently we use net_device->name only if it's the NETREG_REGISTERED
> reg_state, otherwise we return "(unregistered device)".
> 
> However, we always populate net_device->name on creation, so it's always
> available to us for use. The only caveat is that we might have a name like
> "eth%d", in which case we cannot use it as it might change in the future.

While you've got this code out on the operating table what about:
1) Tracing the renames into the kernel message buffer.
2) Including the original name in some of the kernel traces.

I've been trying to diagnose some issues on a system that renames
its interfaces, and it can get tricky working out which interface
messages refer to.

	David

Re: [PATCH v2 net-next 0/2] net: print net_device name/state more often

[Veaceslav Falico]

On Thu, Jul 17, 2014 at 02:48:17PM +0000, David Laight wrote:
>From: Veaceslav Falico
>> Currently we use net_device->name only if it's the NETREG_REGISTERED
>> reg_state, otherwise we return "(unregistered device)".
>>
>> However, we always populate net_device->name on creation, so it's always
>> available to us for use. The only caveat is that we might have a name like
>> "eth%d", in which case we cannot use it as it might change in the future.
>
>While you've got this code out on the operating table what about:

I don't think these ideas fit into the current patchset, as it's somehow
unrelated to the "lets give the real name/state when possible".

However, I like them, see below.

>1) Tracing the renames into the kernel message buffer.

I think you can enable it already. dev_change_name() (net's function to
change net_device name) calls device_rename(), which handles the device
renaming, and it has:

1805         dev_dbg(dev, "renaming to %s\n", new_name);

It can be easily enabled if you have dynamic debug compiled in.

However, indeed, it might be a good info to watch for, and a pretty simple
patch, which might be useful.

diff --git a/net/core/dev.c b/net/core/dev.c
index 239722a..d14ebf0 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1113,6 +1113,9 @@ int dev_change_name(struct net_device *dev, const char *newname)
 		return err;
 	}
 
+	if (oldname[0] && !strchr(oldname, '%'))
+		netdev_info(dev, "renamed from %s\n", oldname);
+
 	old_assign_type = dev->name_assign_type;
 	dev->name_assign_type = NET_NAME_RENAMED;
 

>2) Including the original name in some of the kernel traces.

The only possible use-case of that, from what I can see (with the patch
from 1) ) - is in the renaming functions themselves, which have already
quite a few output sources and, tbh, it's a really rare situation to
implenment tracking of renames in-kernel.

>
>I've been trying to diagnose some issues on a system that renames
>its interfaces, and it can get tricky working out which interface
>messages refer to.
>
>	David
>
>
>

Re: [PATCH v2 net-next 0/2] net: print net_device name/state more often

[Tom Gundersen]

On Thu, Jul 17, 2014 at 4:48 PM, David Laight <David.Laight@aculab.com> wrote:
> From: Veaceslav Falico
>> Currently we use net_device->name only if it's the NETREG_REGISTERED
>> reg_state, otherwise we return "(unregistered device)".
>>
>> However, we always populate net_device->name on creation, so it's always
>> available to us for use. The only caveat is that we might have a name like
>> "eth%d", in which case we cannot use it as it might change in the future.
>
> While you've got this code out on the operating table what about:
> 1) Tracing the renames into the kernel message buffer.

udev will log to dmesg what renames it does. I agree it would make
more sense to do this from the kernel though, as there are other ways
to rename interfaces than through udev.

Cheers,

Tom

> 2) Including the original name in some of the kernel traces.
>
> I've been trying to diagnose some issues on a system that renames
> its interfaces, and it can get tricky working out which interface
> messages refer to.

RE: [PATCH v2 net-next 0/2] net: print net_device name/state more often

[David Laight]

From: Tom Gundersen
> On Thu, Jul 17, 2014 at 4:48 PM, David Laight <David.Laight@aculab.com> wrote:
...
> > While you've got this code out on the operating table what about:
> > 1) Tracing the renames into the kernel message buffer.
> 
> udev will log to dmesg what renames it does.

Not on the systems I'm looking at (ubuntu 13.10 server).
Possibly the trace level is such that they get dropped.

	David