reservation: add suppport for read-only access using rcu

This adds some extra functions to deal with rcu.

reservation_object_get_fences_rcu() will obtain the list of shared
and exclusive fences without obtaining the ww_mutex.

reservation_object_wait_timeout_rcu() will wait on all fences of the
reservation_object, without obtaining the ww_mutex.

reservation_object_test_signaled_rcu() will test if all fences of the
reservation_object are signaled without using the ww_mutex.

reservation_object_get_excl and reservation_object_get_list require
the reservation object to be held, updating requires
write_seqcount_begin/end. If only the exclusive fence is needed,
rcu_dereference followed by fence_get_rcu can be used, if the shared
fences are needed it's recommended to use the supplied functions.

Signed-off-by: Maarten Lankhorst <maarten.lankhorst@canonical.com>
Acked-by: Sumit Semwal <sumit.semwal@linaro.org>
Acked-by: Daniel Vetter <daniel@ffwll.ch>
Reviewed-By: Thomas Hellstrom <thellstrom@vmware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 36 insertions, 16 deletions

diff --git a/include/linux/reservation.h b/include/linux/reservation.h
index 2affe67dea6e..5a0b64cf68b4 100644
--- a/include/linux/reservation.h
+++ b/include/linux/reservation.h
@@ -42,22 +42,29 @@
 #include <linux/ww_mutex.h>
 #include <linux/fence.h>
 #include <linux/slab.h>
+#include <linux/seqlock.h>
+#include <linux/rcupdate.h>
 
 extern struct ww_class reservation_ww_class;
+extern struct lock_class_key reservation_seqcount_class;
+extern const char reservation_seqcount_string[];
 
 struct reservation_object_list {
+        struct rcu_head rcu;
         u32 shared_count, shared_max;
-        struct fence *shared[];
+        struct fence __rcu *shared[];
 };
 
 struct reservation_object {
         struct ww_mutex lock;
+        seqcount_t seq;
 
-        struct fence *fence_excl;
-        struct reservation_object_list *fence;
+        struct fence __rcu *fence_excl;
+        struct reservation_object_list __rcu *fence;
         struct reservation_object_list *staged;
 };
 
+#define reservation_object_held(obj) lockdep_is_held(&(obj)->lock.base)
 #define reservation_object_assert_held(obj) \
         lockdep_assert_held(&(obj)->lock.base)
 
@@ -66,8 +73,9 @@ reservation_object_init(struct reservation_object *obj)
 {
         ww_mutex_init(&obj->lock, &reservation_ww_class);
 
-        obj->fence_excl = NULL;
-        obj->fence = NULL;
+        __seqcount_init(&obj->seq, reservation_seqcount_string, &reservation_seqcount_class);
+        RCU_INIT_POINTER(obj->fence, NULL);
+        RCU_INIT_POINTER(obj->fence_excl, NULL);
         obj->staged = NULL;
 }
 
@@ -76,18 +84,20 @@ reservation_object_fini(struct reservation_object *obj)
 {
         int i;
         struct reservation_object_list *fobj;
+        struct fence *excl;
 
         /*
          * This object should be dead and all references must have
-         * been released to it.
+         * been released to it, so no need to be protected with rcu.
          */
-        if (obj->fence_excl)
-                fence_put(obj->fence_excl);
+        excl = rcu_dereference_protected(obj->fence_excl, 1);
+        if (excl)
+                fence_put(excl);
 
-        fobj = obj->fence;
+        fobj = rcu_dereference_protected(obj->fence, 1);
         if (fobj) {
                 for (i = 0; i < fobj->shared_count; ++i)
-                        fence_put(fobj->shared[i]);
+                        fence_put(rcu_dereference_protected(fobj->shared[i], 1));
 
                 kfree(fobj);
         }
@@ -99,17 +109,15 @@ reservation_object_fini(struct reservation_object *obj)
 static inline struct reservation_object_list *
 reservation_object_get_list(struct reservation_object *obj)
 {
-        reservation_object_assert_held(obj);
-
-        return obj->fence;
+        return rcu_dereference_protected(obj->fence,
+                                         reservation_object_held(obj));
 }
 
 static inline struct fence *
 reservation_object_get_excl(struct reservation_object *obj)
 {
-        reservation_object_assert_held(obj);
-
-        return obj->fence_excl;
+        return rcu_dereference_protected(obj->fence_excl,
+                                         reservation_object_held(obj));
 }
 
 int reservation_object_reserve_shared(struct reservation_object *obj);
@@ -119,4 +127,16 @@ void reservation_object_add_shared_fence(struct reservation_object *obj,
 void reservation_object_add_excl_fence(struct reservation_object *obj,
                                        struct fence *fence);
 
+int reservation_object_get_fences_rcu(struct reservation_object *obj,
+                                      struct fence **pfence_excl,
+                                      unsigned *pshared_count,
+                                      struct fence ***pshared);
+
+long reservation_object_wait_timeout_rcu(struct reservation_object *obj,
+                                         bool wait_all, bool intr,
+                                         unsigned long timeout);
+
+bool reservation_object_test_signaled_rcu(struct reservation_object *obj,
+                                          bool test_all);
+
 #endif /* _LINUX_RESERVATION_H */