lkml.org 
[lkml]   [2013]   [May]   [6]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[051/126] kref: Implement kref_get_unless_zero v3
    3.6.11.3 stable review patch.
    If anyone has any objections, please let me know.

    ------------------

    From: Thomas Hellstrom <thellstrom@vmware.com>

    [ Upstream commit 4b20db3de8dab005b07c74161cb041db8c5ff3a7 ]

    This function is intended to simplify locking around refcounting for
    objects that can be looked up from a lookup structure, and which are
    removed from that lookup structure in the object destructor.
    Operations on such objects require at least a read lock around
    lookup + kref_get, and a write lock around kref_put + remove from lookup
    structure. Furthermore, RCU implementations become extremely tricky.
    With a lookup followed by a kref_get_unless_zero *with return value check*
    locking in the kref_put path can be deferred to the actual removal from
    the lookup structure and RCU lookups become trivial.

    v2: Formatting fixes.
    v3: Invert the return value.

    Signed-off-by: Thomas Hellstrom <thellstrom@vmware.com>
    Signed-off-by: Dave Airlie <airlied@redhat.com>
    Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
    ---
    include/linux/kref.h | 21 +++++++++++++++++++++
    1 file changed, 21 insertions(+)

    diff --git a/include/linux/kref.h b/include/linux/kref.h
    index 65af688..4972e6e 100644
    --- a/include/linux/kref.h
    +++ b/include/linux/kref.h
    @@ -111,4 +111,25 @@ static inline int kref_put_mutex(struct kref *kref,
    }
    return 0;
    }
    +
    +/**
    + * kref_get_unless_zero - Increment refcount for object unless it is zero.
    + * @kref: object.
    + *
    + * Return non-zero if the increment succeeded. Otherwise return 0.
    + *
    + * This function is intended to simplify locking around refcounting for
    + * objects that can be looked up from a lookup structure, and which are
    + * removed from that lookup structure in the object destructor.
    + * Operations on such objects require at least a read lock around
    + * lookup + kref_get, and a write lock around kref_put + remove from lookup
    + * structure. Furthermore, RCU implementations become extremely tricky.
    + * With a lookup followed by a kref_get_unless_zero *with return value check*
    + * locking in the kref_put path can be deferred to the actual removal from
    + * the lookup structure and RCU lookups become trivial.
    + */
    +static inline int __must_check kref_get_unless_zero(struct kref *kref)
    +{
    + return atomic_add_unless(&kref->refcount, 1, 0);
    +}
    #endif /* _KREF_H_ */
    --
    1.7.10.4



    \
     
     \ /
      Last update: 2013-05-07 06:41    [W:3.694 / U:1.592 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site