On Thu, Nov 30, 2017 at 12:48:15AM +0100, Rafael J. Wysocki wrote:

On Thu, Nov 30, 2017 at 12:23 AM, Luis R. Rodriguez [off-list ref] wrote:

quoted

+int iterate_supers_excl(int (*f)(struct super_block *, void *), void *arg)
+{
+       struct super_block *sb, *p = NULL;
+       int error = 0;
+
+       spin_lock(&sb_lock);
+       list_for_each_entry(sb, &super_blocks, s_list) {
+               if (hlist_unhashed(&sb->s_instances))
+                       continue;
+               sb->s_count++;
+               spin_unlock(&sb_lock);

Can anything bad happen if the list is modified at this point by a
concurrent thread?

The race is theoretical and applies to all users of iterate_supers() as well.

Its certainly worth considering, however given other code is implicated its
not a *new* issue or race. Its the best we can do with the current design.

That said, as I looked at all this code I considered that perhaps super_blocks
deserves its own RCU lock to enable us to do full swap operations on the list,
without having to do these nasty releases in between.

If that's possible / desirable I'd consider it a welcomed future optimization,
and I could give it a shot, however its unclear if this is a requirement for
this feature at this time.

  Luis