Replace rwlock_t in sched_trace.c

In PreemptRT rwlock_t can sleep and it's not irq safe.

To grant proper creation and deletion of the kfifo buffer the vanilla
rwlock_t is substituted for a raw_spinlock and two atomic_t variables.

The spinlock only protects the atomic variables, so the kernel can use
blocking variant of various lock in the kfifo implementation and in the
memory allocation.

1 files changed, 50 insertions, 16 deletions

diff --git a/litmus/sched_trace.c b/litmus/sched_trace.c
index f3943c16738d..8a9a7ddc4870 100644
--- a/litmus/sched_trace.c
+++ b/litmus/sched_trace.c
@@ -28,13 +28,18 @@
 /* Max length for one write --- from kernel --- to the buffer */
 #define MSG_SIZE 255
 
-/* Inner ring buffer structure */
+/* Inner ring buffer structure
+ *
+ * In PreemptRT we easily replace a rwlock_t (which may block here) with
+ * a raw_spinlock_t and two atomic_t
+ */
 typedef struct {
-        /* in PREEMPT-RT rwlock_t can sleep, instead we need to access the
-         * buffer from atomic contexts. Changing rwlock_t in raw_spinlock_t
-         * adds an extra serialization, but it's probably unavoidable
-         */
+        /* only used to protect the atomic ops */
         raw_spinlock_t  del_lock;
+        /* is the buffer initialized? */
+        atomic_t        init;
+        /* is the buffer in use? */
+        atomic_t        in_use;
 
         /* the buffer */
         struct kfifo    kfifo;
@@ -53,6 +58,8 @@ typedef struct {
  */
 void rb_init(ring_buffer_t* buf)
 {
+        atomic_set(&buf->init, 0);
+        atomic_set(&buf->in_use, 0);
         raw_spin_lock_init(&buf->del_lock);
 }
 
@@ -61,17 +68,21 @@ int rb_alloc_buf(ring_buffer_t* buf, unsigned int size)
         unsigned long flags;
         int ret = 0;
 
-        raw_spin_lock_irqsave(&buf->del_lock, flags);
-
         /* kfifo size must be a power of 2
          * atm kfifo alloc is automatically rounding the size
          */
         ret = kfifo_alloc(&buf->kfifo, size, GFP_ATOMIC);
 
-        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+        if(ret < 0) {
 
-        if(ret < 0)
                 printk(KERN_ERR "kfifo_alloc failed\n");
+                return ret;
+        }
+
+        /* now the buffer is allocated, others can access */
+        raw_spin_lock_irqsave(&buf->del_lock, flags);
+        atomic_set(&buf->init, 1);
+        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
 
         return ret;
 }
@@ -80,20 +91,22 @@ int rb_free_buf(ring_buffer_t* buf)
 {
         unsigned long flags;
 
+        /* be sure to synchronize with put / get */
         raw_spin_lock_irqsave(&buf->del_lock, flags);
+        atomic_set(&buf->init, 0);
+        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+
+        /* if someone started to use the buffer wait it ends */
+        while(atomic_read(&buf->in_use))
+                cpu_relax();
 
         BUG_ON(!kfifo_initialized(&buf->kfifo));
         kfifo_free(&buf->kfifo);
 
-        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
-
         return 0;
 }
 
 /*
- * In preempt-rt, changing the rwlock_t in a raw_spinlock_t has the side
- * effect to serialize writings.
- *
  * Will only succeed if there is enough space for all len bytes.
  */
 int rb_put(ring_buffer_t* buf, char* mem, size_t len)
@@ -101,8 +114,18 @@ int rb_put(ring_buffer_t* buf, char* mem, size_t len)
         unsigned long flags;
         int error = 0;
 
+        /* be sure we see a free */
         raw_spin_lock_irqsave(&buf->del_lock, flags);
 
+        /* if not init'ed yet, quit */
+        if (!atomic_read(&buf->init)) {
+                raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+                goto out;
+        }
+
+        atomic_inc(&buf->in_use);
+        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+
         if (!kfifo_initialized(&buf->kfifo)) {
                 error = -ENODEV;
                 goto out;
@@ -113,8 +136,8 @@ int rb_put(ring_buffer_t* buf, char* mem, size_t len)
                 goto out;
         }
 
+        atomic_dec(&buf->in_use);
  out:
-        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
         return error;
 }
 
@@ -127,7 +150,18 @@ int rb_get(ring_buffer_t* buf, char* mem, size_t len)
         unsigned long flags;
         int error = 0;
 
+        /* be sure we see a free */
         raw_spin_lock_irqsave(&buf->del_lock, flags);
+
+        /* if not init'ed yet, quit */
+        if (!atomic_read(&buf->init)) {
+                raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+                goto out;
+        }
+
+        atomic_inc(&buf->in_use);
+        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
+
         if (!kfifo_initialized(&buf->kfifo)) {
                 error = -ENODEV;
                 goto out;
@@ -135,8 +169,8 @@ int rb_get(ring_buffer_t* buf, char* mem, size_t len)
 
         error = kfifo_out(&buf->kfifo, (unsigned char*)mem, len);
 
+        atomic_dec(&buf->in_use);
  out:
-        raw_spin_unlock_irqrestore(&buf->del_lock, flags);
         return error;
 }