tree 159b82f8eb9479cdc10f861d682309b4c0c8c411
parent bbd1ae412c9eb09ae7bb11cfaf7018a2367d493f
author James Bottomley <James.Bottomley@HansenPartnership.com> 1206064072 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1208895391 -0500

[SCSI] sysfs: make group is_valid return a mode_t

We have a problem in scsi_transport_spi in that we need to customise
not only the visibility of the attributes, but also their mode.  Fix
this by making the is_visible() callback return a mode, with 0
indicating is not visible.

Also add a sysfs_update_group() API to allow us to change either the
visibility or mode of the files at any time on the fly.

Acked-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
