tree c7b9a48dc7dd7790d678a7a13f5ba245931876ad
parent fea68bb6e9fa65c7cc6caa6adda810d1d0fdbde4
author Markus Armbruster <armbru@redhat.com> 1412683151 +0200
committer Kevin Wolf <kwolf@redhat.com> 1413805286 +0200

block: Eliminate BlockDriverState member device_name[]

device_name[] can become non-empty only in bdrv_new_root() and
bdrv_move_feature_fields().  The latter is used only to undo damage
done by bdrv_swap().  The former is called only by blk_new_with_bs().
Therefore, when a BlockDriverState's device_name[] is non-empty, then
it's been created with a BlockBackend, and vice versa.  Furthermore,
blk_new_with_bs() keeps the two names equal.

Therefore, device_name[] is redundant.  Eliminate it.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
