tree 37f41671ddba891149a7aec6c3ab349c81a9a7c1
parent d39badf05b52f99169b22ce324fd31c8b44a0473
author Satyam Sharma <satyam@infradead.org> 1186784890 -0700
committer David S. Miller <davem@sunset.davemloft.net> 1192060082 -0700

[NET] netconsole: Remove bogus check

Based upon initial work by Keiichi Kii <k-keiichi@bx.jp.nec.com>.

The (!np.dev) check in write_msg() is bogus (always false), because: np.dev is
set by netpoll_setup(), which is called by init_netconsole() before
register_console(), so write_msg() cannot be triggered unless netpoll_setup()
successfully set np.dev.  Also np.dev cannot go away from under us, because
netpoll_setup() grabs us reference on it.  So let's remove the bogus check.

Signed-off-by: Satyam Sharma <satyam@infradead.org>
Acked-by: Keiichi Kii <k-keiichi@bx.jp.nec.com>
Acked-by: Matt Mackall <mpm@selenic.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
