lkml.org 
[lkml]   [2022]   [Oct]   [11]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH AUTOSEL 5.19 24/40] btrfs: add macros for annotating wait events with lockdep
    Date
    From: Ioannis Angelakopoulos <iangelak@fb.com>

    [ Upstream commit ab9a323f9ab576000795285dd7ac6afeedf29e32 ]

    Introduce four macros that are used to annotate wait events in btrfs code
    with lockdep;

    1) the btrfs_lockdep_init_map
    2) the btrfs_lockdep_acquire,
    3) the btrfs_lockdep_release
    4) the btrfs_might_wait_for_event macros.

    The btrfs_lockdep_init_map macro is used to initialize a lockdep map.

    The btrfs_lockdep_<acquire,release> macros are used by threads to take
    the lockdep map as readers (shared lock) and release it, respectively.

    The btrfs_might_wait_for_event macro is used by threads to take the
    lockdep map as writers (exclusive lock) and release it.

    In general, the lockdep annotation for wait events work as follows:

    The condition for a wait event can be modified and signaled at the same
    time by multiple threads. These threads hold the lockdep map as readers
    when they enter a context in which blocking would prevent signaling the
    condition. Frequently, this occurs when a thread violates a condition
    (lockdep map acquire), before restoring it and signaling it at a later
    point (lockdep map release).

    The threads that block on the wait event take the lockdep map as writers
    (exclusive lock). These threads have to block until all the threads that
    hold the lockdep map as readers signal the condition for the wait event
    and release the lockdep map.

    The lockdep annotation is used to warn about potential deadlock scenarios
    that involve the threads that modify and signal the wait event condition
    and threads that block on the wait event. A simple example is illustrated
    below:

    Without lockdep:

    TA TB
    cond = false
    lock(A)
    wait_event(w, cond)
    unlock(A)
    lock(A)
    cond = true
    signal(w)
    unlock(A)

    With lockdep:

    TA TB
    rwsem_acquire_read(lockdep_map)
    cond = false
    lock(A)
    rwsem_acquire(lockdep_map)
    rwsem_release(lockdep_map)
    wait_event(w, cond)
    unlock(A)
    lock(A)
    cond = true
    signal(w)
    unlock(A)
    rwsem_release(lockdep_map)

    In the second case, with the lockdep annotation, lockdep would warn about
    an ABBA deadlock, while the first case would just deadlock at some point.

    Reviewed-by: Josef Bacik <josef@toxicpanda.com>
    Signed-off-by: Ioannis Angelakopoulos <iangelak@fb.com>
    Reviewed-by: David Sterba <dsterba@suse.com>
    Signed-off-by: David Sterba <dsterba@suse.com>
    Signed-off-by: Sasha Levin <sashal@kernel.org>
    ---
    fs/btrfs/ctree.h | 45 +++++++++++++++++++++++++++++++++++++++++++++
    1 file changed, 45 insertions(+)

    diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
    index 1bbc810574f2..8d35db5b2b62 100644
    --- a/fs/btrfs/ctree.h
    +++ b/fs/btrfs/ctree.h
    @@ -1148,6 +1148,51 @@ enum {
    BTRFS_ROOT_RESET_LOCKDEP_CLASS,
    };

    +/*
    + * Lockdep annotation for wait events.
    + *
    + * @owner: The struct where the lockdep map is defined
    + * @lock: The lockdep map corresponding to a wait event
    + *
    + * This macro is used to annotate a wait event. In this case a thread acquires
    + * the lockdep map as writer (exclusive lock) because it has to block until all
    + * the threads that hold the lock as readers signal the condition for the wait
    + * event and release their locks.
    + */
    +#define btrfs_might_wait_for_event(owner, lock) \
    + do { \
    + rwsem_acquire(&owner->lock##_map, 0, 0, _THIS_IP_); \
    + rwsem_release(&owner->lock##_map, _THIS_IP_); \
    + } while (0)
    +
    +/*
    + * Protection for the resource/condition of a wait event.
    + *
    + * @owner: The struct where the lockdep map is defined
    + * @lock: The lockdep map corresponding to a wait event
    + *
    + * Many threads can modify the condition for the wait event at the same time
    + * and signal the threads that block on the wait event. The threads that modify
    + * the condition and do the signaling acquire the lock as readers (shared
    + * lock).
    + */
    +#define btrfs_lockdep_acquire(owner, lock) \
    + rwsem_acquire_read(&owner->lock##_map, 0, 0, _THIS_IP_)
    +
    +/*
    + * Used after signaling the condition for a wait event to release the lockdep
    + * map held by a reader thread.
    + */
    +#define btrfs_lockdep_release(owner, lock) \
    + rwsem_release(&owner->lock##_map, _THIS_IP_)
    +
    +/* Initialization of the lockdep map */
    +#define btrfs_lockdep_init_map(owner, lock) \
    + do { \
    + static struct lock_class_key lock##_key; \
    + lockdep_init_map(&owner->lock##_map, #lock, &lock##_key, 0); \
    + } while (0)
    +
    static inline void btrfs_wake_unfinished_drop(struct btrfs_fs_info *fs_info)
    {
    clear_and_wake_up_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);
    --
    2.35.1
    \
     
     \ /
      Last update: 2022-10-11 16:59    [W:2.982 / U:0.140 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site