WebSVN – Kolibri OS – Diff – /drivers/ddk/linux/mutex.c

 #include
 #include
 #include
 #include
 #include
+struct  kos_taskdata
+{
+    u32 event_mask;
+    u32 pid;
+    u16 r0;
+    u8  state;
+    u8  r1;
+    u16 r2;
+    u8  wnd_number;
+    u8  r3;
+    u32 mem_start;
+    u32 counter_sum;
+    u32 counter_add;
+    u32 cpu_usage;
+}__attribute__((packed));
+static inline void mutex_set_owner(struct mutex *lock)
+{
+}
 /*
  * A negative mutex count indicates that waiters are sleeping waiting for the
  * mutex.
  */
 #define MUTEX_SHOW_NO_WAITER(mutex) (atomic_read(&(mutex)->count) >= 0)
     lock->osq = NULL;
 #endif
 }
 static __always_inline void ww_mutex_lock_acquired(struct ww_mutex *ww,
-                           struct ww_acquire_ctx *ww_ctx)
-{
-#ifdef CONFIG_DEBUG_MUTEXES
-    /*
-     * If this WARN_ON triggers, you used ww_mutex_lock to acquire,
-     * but released with a normal mutex_unlock in this call.
+static inline int __ww_mutex_lock_check_stamp(struct mutex *lock, struct ww_acquire_ctx *ctx)
-     *
-     * This should never happen, always use ww_mutex_unlock.
+{
-     */
-    DEBUG_LOCKS_WARN_ON(ww->ctx);
+        struct ww_mutex *ww = container_of(lock, struct ww_mutex, base);
-    /*
+        struct ww_acquire_ctx *hold_ctx = READ_ONCE(ww->ctx);
-     * Not quite done after calling ww_acquire_done() ?
-     */
-    DEBUG_LOCKS_WARN_ON(ww_ctx->done_acquire);
+        if (!hold_ctx)
-    if (ww_ctx->contending_lock) {
-        /*
-         * After -EDEADLK you tried to
-         * acquire a different ww_mutex? Bad!
-         */
+                return 0;
-        DEBUG_LOCKS_WARN_ON(ww_ctx->contending_lock != ww);
-        /*
+        if (unlikely(ctx == hold_ctx))
-         * You called ww_mutex_lock after receiving -EDEADLK,
+                return -EALREADY;
-         * but 'forgot' to unlock everything else first?
+        if (ctx->stamp - hold_ctx->stamp <= LONG_MAX &&
+            (ctx->stamp != hold_ctx->stamp || ctx > hold_ctx)) {
+                return -EDEADLK;
-         */
+        }
-        DEBUG_LOCKS_WARN_ON(ww_ctx->acquired > 0);
-        ww_ctx->contending_lock = NULL;
-    }
+        return 0;
+}
     /*
      * Naughty, using a different class will lead to undefined behavior!
-     */
+static __always_inline void ww_mutex_lock_acquired(struct ww_mutex *ww,
-        lock->ctx = NULL;
+            lock->ctx = NULL;
+    }
     MutexUnlock(&lock->base);
+}
-int __ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+static inline int __mutex_fastpath_lock_retval(atomic_t *count)
+{
+    if (unlikely(atomic_dec_return(count) < 0))
+        return -1;
+    else
+        return 0;
+}
+static __always_inline void
+ww_mutex_set_context_fastpath(struct ww_mutex *lock,
+                               struct ww_acquire_ctx *ctx)
+{
-{
+    u32 flags;
+    struct mutex_waiter *cur;
     MutexLock(&lock->base);
+    ww_mutex_lock_acquired(lock, ctx);
     ww_mutex_lock_acquired(lock, ctx);
     lock->ctx = ctx;
+    /*
+     * The lock->ctx update should be visible on all cores before
+     * the atomic read is done, otherwise contended waiters might be
+     * missed. The contended waiters will either see ww_ctx == NULL
+     * and keep spinning, or it will acquire wait_lock, add itself
+     * to waiter list and sleep.
+     */
+    smp_mb(); /* ^^^ */
+    /*
+     * Check if lock is contended, if not there is nobody to wake up
+     */
+    if (likely(atomic_read(&lock->base.count) == 0))
+            return;
+    /*
+     * Uh oh, we raced in fastpath, wake up everyone in this case,
+     * so they can see the new lock->ctx.
+     */
+    flags = safe_cli();
+    list_for_each_entry(cur, &lock->base.wait_list, list) {
+        ((struct kos_taskdata*)cur->task)->state = 0;
-    return 0;
+    }
+    safe_sti(flags);
+}
+ww_mutex_set_context_slowpath(struct ww_mutex *lock,
                               struct ww_acquire_ctx *ctx)
 int __ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+    struct mutex_waiter *cur;
+    ww_mutex_lock_acquired(lock, ctx);
+    lock->ctx = ctx;
+    /*
+     * Give any possible sleeping processes the chance to wake up,
+     * so they can recheck if they have to back off.
+     */
+    list_for_each_entry(cur, &lock->base.wait_list, list) {
+        ((struct kos_taskdata*)cur->task)->state = 0;
+    }
+}
+int __ww_mutex_lock_slowpath(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
+{
+    struct mutex *lock;
+    struct mutex_waiter waiter;
+    struct kos_taskdata* taskdata;
+    u32 eflags;
+    int ret = 0;
+    lock = &ww->base;
+    taskdata = (struct kos_taskdata*)(0x80003010);
+    waiter.task = (u32*)taskdata;
+    eflags = safe_cli();
+    list_add_tail(&waiter.list, &lock->wait_list);
+    for(;;)
+    {
+        if( atomic_xchg(&lock->count, -1) == 1)
+            break;
+        if (ctx->acquired > 0) {
+            ret = __ww_mutex_lock_check_stamp(lock, ctx);
+            if (ret)
+                goto err;
+        };
+        taskdata->state = 1;
+        change_task();
+    };
+    if (likely(list_empty(&lock->wait_list)))
+        atomic_set(&lock->count, 0);
+    ww_mutex_set_context_slowpath(ww, ctx);
+err:
+    list_del(&waiter.list);
+    safe_sti(eflags);
+    return ret;
+}
+int __ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+    int ret;
+    ret = __mutex_fastpath_lock_retval(&lock->base.count);
+    if (likely(!ret)) {
+            ww_mutex_set_context_fastpath(lock, ctx);
+            mutex_set_owner(&lock->base);
+    } else
+            ret = __ww_mutex_lock_slowpath(lock, ctx);
+    return ret;
+}
+int __ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+    int ret;
+    ret = __mutex_fastpath_lock_retval(&lock->base.count);
-{
+    if (likely(!ret)) {
-    MutexLock(&lock->base);
+            ww_mutex_set_context_fastpath(lock, ctx);

Subversion Repositories Kolibri OS

(root)/drivers/ddk/linux/mutex.c – Rev 5056 → 6082