Skip to contentSkip to conversation

audit_tree: sleep inside atomic

DISCUSSION Jiri Slaby 4 participants 5 messages Jun 21, 2010 – Oct 30, 2010

lore
Share & tools
lore

Jiri Slaby

author
#0 lore raw

Hi,

stanse found a sleep inside atomic added by the following commit:
commit fb36de479642bc9bdd3af251ae48b882d8a1ad5d

Author: Eric Paris <[email protected]>
Date:   Thu Dec 17 20:12:05 2009 -0500

audit: reimplement audit_trees using fsnotify rather than inotify

Simply switch audit_trees from using inotify to using fsnotify for it's inode pinning and disappearing act information.

In untag_chunk, there is
spin_lock(&entry->lock);
...
new = alloc_chunk(size);
...
spin_unlock(&entry->lock);

with
static struct audit_chunk *alloc_chunk(int count)
{
struct audit_chunk *chunk;
...
chunk = kzalloc(size, GFP_KERNEL);

But this can sleep. How big the allocations are? Could it be ATOMIC or moved outside the spinlock?

thanks,

Signature · 1 line
js
author
#1 lore raw

Ideas, comments?

Quoted 33 lines · Jiri Slaby

Hi,

stanse found a sleep inside atomic added by the following commit:
commit fb36de479642bc9bdd3af251ae48b882d8a1ad5d

Author: Eric Paris <[email protected]>
Date:   Thu Dec 17 20:12:05 2009 -0500

audit: reimplement audit_trees using fsnotify rather than inotify

Simply switch audit_trees from using inotify to using fsnotify for it's inode pinning and disappearing act information.

In untag_chunk, there is
spin_lock(&entry->lock);
...
new = alloc_chunk(size);
...
spin_unlock(&entry->lock);

with
static struct audit_chunk *alloc_chunk(int count)
{
struct audit_chunk *chunk;
...
chunk = kzalloc(size, GFP_KERNEL);

But this can sleep. How big the allocations are? Could it be ATOMIC or moved outside the spinlock?

thanks,

Signature · 1 line
js
#2 lore raw
Quoted 1 line · On Fri, 03 Sep 2010 15:52:30 +0200 Jiri Slaby <[email protected]> wrote:

Ideas, comments?

Apparently not.

The question is: why is nobody reporting this bug? Obviously nobody's running that code path. Why not?

Quoted 30 lines · Jiri Slaby
Quoted 29 lines

Hi,

stanse found a sleep inside atomic added by the following commit:
commit fb36de479642bc9bdd3af251ae48b882d8a1ad5d

Author: Eric Paris <[email protected]>
Date:   Thu Dec 17 20:12:05 2009 -0500

audit: reimplement audit_trees using fsnotify rather than inotify

Simply switch audit_trees from using inotify to using fsnotify for it's inode pinning and disappearing act information.

In untag_chunk, there is
spin_lock(&entry->lock);
...
new = alloc_chunk(size);
...
spin_unlock(&entry->lock);

with
static struct audit_chunk *alloc_chunk(int count)
{
struct audit_chunk *chunk;
...
chunk = kzalloc(size, GFP_KERNEL);

Quoted 2 lines
Quoted 2 lines

But this can sleep. How big the allocations are? Could it be ATOMIC or moved outside the spinlock?

Yes, we could make it GFP_ATOMIC - the code tries to handle allocation failures.

But if we did that we'd be adding a rarely-executed codepath to an apparently-never-executed code path. We'd end up shipping stuff which nobody had tested, ever.

Plus GFP_ATOMIC is unreliable and using it because we screwed up the locking is lame.

untag_chunk() could be converted to use GFP_KERNEL outside hash_lock and ->entry_lock. The usual way is to take a peek, see if it looks like we'll probably need to do an allocation and if so, do it outside the locks then free it again if it turned out that we didn't need it after all. Or to maintain a one-deep static-local cache and preload that cache if it's empty. Neither are particularly pretty.

#3 lore raw
Quoted 6 lines · Andrew Morton
Quoted 1 line · On Fri, 03 Sep 2010 15:52:30 +0200 Jiri Slaby <[email protected]> wrote:

Ideas, comments?

Apparently not.

Sorry, I've been slacking off on vacation the last couple weeks.

Quoted 2 lines

The question is: why is nobody reporting this bug? Obviously nobody's running that code path. Why not?

The only people who run this code path, that I know of, are govt orgs who run in certified environments. I don't know of any upstream kernel users who really would hit it.

In any case I don't think it would be particularly painful to just always allocate a chunk between the two locks. this is not a hot path by any stretch of the imagination. I'll see if I can't code something up today/tomorrow.

-Eric

Quoted 49 lines
Quoted 30 lines · Jiri Slaby
Quoted 29 lines

Hi,

stanse found a sleep inside atomic added by the following commit:
commit fb36de479642bc9bdd3af251ae48b882d8a1ad5d

Author: Eric Paris <[email protected]>
Date:   Thu Dec 17 20:12:05 2009 -0500

audit: reimplement audit_trees using fsnotify rather than inotify

Simply switch audit_trees from using inotify to using fsnotify for it's inode pinning and disappearing act information.

In untag_chunk, there is
spin_lock(&entry->lock);
...
new = alloc_chunk(size);
...
spin_unlock(&entry->lock);

with
static struct audit_chunk *alloc_chunk(int count)
{
struct audit_chunk *chunk;
...
chunk = kzalloc(size, GFP_KERNEL);

Quoted 2 lines
Quoted 2 lines

But this can sleep. How big the allocations are? Could it be ATOMIC or moved outside the spinlock?

Yes, we could make it GFP_ATOMIC - the code tries to handle allocation failures.

But if we did that we'd be adding a rarely-executed codepath to an apparently-never-executed code path. We'd end up shipping stuff which nobody had tested, ever.

Plus GFP_ATOMIC is unreliable and using it because we screwed up the locking is lame.

untag_chunk() could be converted to use GFP_KERNEL outside hash_lock and ->entry_lock. The usual way is to take a peek, see if it looks like we'll probably need to do an allocation and if so, do it outside the locks then free it again if it turned out that we didn't need it after all. Or to maintain a one-deep static-local cache and preload that cache if it's empty. Neither are particularly pretty.

#4 lore raw
Quoted 13 lines · Eric Paris
Quoted 6 lines · Andrew Morton
Quoted 1 line · On Fri, 03 Sep 2010 15:52:30 +0200 Jiri Slaby <[email protected]> wrote:

Ideas, comments?

Apparently not.

Sorry, I've been slacking off on vacation the last couple weeks.

Quoted 2 lines

The question is: why is nobody reporting this bug? Obviously nobody's running that code path. Why not?

Quoted 8 lines

The only people who run this code path, that I know of, are govt orgs who run in certified environments. I don't know of any upstream kernel users who really would hit it.

In any case I don't think it would be particularly painful to just always allocate a chunk between the two locks. this is not a hot path by any stretch of the imagination. I'll see if I can't code something up today/tomorrow.

It's not even a matter of path being hot; we should do allocation before grabbing entry->lock if size is non-zero. End of the story.

Fixed in audit branch I'll push today.