tree e9129a517153179534895bb7092d29817e7cf1e1
parent 94245f4ad9e10c161affaa4763136d29fbe91cb9
author Jason Gunthorpe <jgg@mellanox.com> 1532853291 +0300
committer Jason Gunthorpe <jgg@mellanox.com> 1533262781 -0600

IB/ipoib: Get rid of IPOIB_FLAG_GOING_DOWN

This essentially duplicates the netdev's reg_state, so just use that
directly. The reg_state is updated under the rntl_lock, and all places
using GOING_DOWN already acquire the rtnl_lock so checking is safe.

Since the only place we use GOING_DOWN is for the parent device this
does not fix any bugs, but it is a step to tidy up the unregister flow
so that after later patches the flow is uniform and sane.

Signed-off-by: Jason Gunthorpe <jgg@mellanox.com>
Signed-off-by: Leon Romanovsky <leonro@mellanox.com>
