tree f2ebed0b9d35298697c96ac8896ec34ba2a07a78
parent ecefe8a97577d6c1a68d14ab6fb19bce99448af2
author Tejun Heo <tj@kernel.org> 1216015170 +0900
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1217099690 -0400

[SCSI] sd: update index allocation and use ida instead of idr

Update index allocation as follows.

* sd_index_idr is used only for ID allocation and mapping
  functionality is not used.  Use more memory efficient ida instead.

* idr and ida have their own locks inside them and don't need them for
  operation.  Drop it.

* index wasn't freed if probing failed after index allocation.  fix
  it.

* ida allocation should be repeated if it fails with -EAGAIN.

Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
