LXR linux/kernel/locking/rtmutex

   1/*
   2 * RT Mutexes: blocking mutual exclusion locks with PI support
   3 *
   4 * started by Ingo Molnar and Thomas Gleixner:
   5 *
   6 *  Copyright (C) 2004-2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
   7 *  Copyright (C) 2006, Timesys Corp., Thomas Gleixner <tglx@timesys.com>
   8 *
   9 * This file contains the private data structure and API definitions.
  10 */
  11
  12#ifndef __KERNEL_RTMUTEX_COMMON_H
  13#define __KERNEL_RTMUTEX_COMMON_H
  14
  15#include <linux/rtmutex.h>
  16
  17/*
  18 * The rtmutex in kernel tester is independent of rtmutex debugging. We
  19 * call schedule_rt_mutex_test() instead of schedule() for the tasks which
  20 * belong to the tester. That way we can delay the wakeup path of those
  21 * threads to provoke lock stealing and testing of  complex boosting scenarios.
  22 */
  23#ifdef CONFIG_RT_MUTEX_TESTER
  24
  25extern void schedule_rt_mutex_test(struct rt_mutex *lock);
  26
  27#define schedule_rt_mutex(_lock)                                \
  28  do {                                                          \
  29        if (!(current->flags & PF_MUTEX_TESTER))                \
  30                schedule();                                     \
  31        else                                                    \
  32                schedule_rt_mutex_test(_lock);                  \
  33  } while (0)
  34
  35#else
  36# define schedule_rt_mutex(_lock)                       schedule()
  37#endif
  38
  39/*
  40 * This is the control structure for tasks blocked on a rt_mutex,
  41 * which is allocated on the kernel stack on of the blocked task.
  42 *
  43 * @tree_entry:         pi node to enqueue into the mutex waiters tree
  44 * @pi_tree_entry:      pi node to enqueue into the mutex owner waiters tree
  45 * @task:               task reference to the blocked task
  46 */
  47struct rt_mutex_waiter {
  48        struct rb_node          tree_entry;
  49        struct rb_node          pi_tree_entry;
  50        struct task_struct      *task;
  51        struct rt_mutex         *lock;
  52#ifdef CONFIG_DEBUG_RT_MUTEXES
  53        unsigned long           ip;
  54        struct pid              *deadlock_task_pid;
  55        struct rt_mutex         *deadlock_lock;
  56#endif
  57        int prio;
  58};
  59
  60/*
  61 * Various helpers to access the waiters-tree:
  62 */
  63static inline int rt_mutex_has_waiters(struct rt_mutex *lock)
  64{
  65        return !RB_EMPTY_ROOT(&lock->waiters);
  66}
  67
  68static inline struct rt_mutex_waiter *
  69rt_mutex_top_waiter(struct rt_mutex *lock)
  70{
  71        struct rt_mutex_waiter *w;
  72
  73        w = rb_entry(lock->waiters_leftmost, struct rt_mutex_waiter,
  74                     tree_entry);
  75        BUG_ON(w->lock != lock);
  76
  77        return w;
  78}
  79
  80static inline int task_has_pi_waiters(struct task_struct *p)
  81{
  82        return !RB_EMPTY_ROOT(&p->pi_waiters);
  83}
  84
  85static inline struct rt_mutex_waiter *
  86task_top_pi_waiter(struct task_struct *p)
  87{
  88        return rb_entry(p->pi_waiters_leftmost, struct rt_mutex_waiter,
  89                        pi_tree_entry);
  90}
  91
  92/*
  93 * lock->owner state tracking:
  94 */
  95#define RT_MUTEX_HAS_WAITERS    1UL
  96#define RT_MUTEX_OWNER_MASKALL  1UL
  97
  98static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)
  99{
 100        return (struct task_struct *)
 101                ((unsigned long)lock->owner & ~RT_MUTEX_OWNER_MASKALL);
 102}
 103
 104/*
 105 * PI-futex support (proxy locking functions, etc.):
 106 */
 107extern struct task_struct *rt_mutex_next_owner(struct rt_mutex *lock);
 108extern void rt_mutex_init_proxy_locked(struct rt_mutex *lock,
 109                                       struct task_struct *proxy_owner);
 110extern void rt_mutex_proxy_unlock(struct rt_mutex *lock,
 111                                  struct task_struct *proxy_owner);
 112extern int rt_mutex_start_proxy_lock(struct rt_mutex *lock,
 113                                     struct rt_mutex_waiter *waiter,
 114                                     struct task_struct *task,
 115                                     int detect_deadlock);
 116extern int rt_mutex_finish_proxy_lock(struct rt_mutex *lock,
 117                                      struct hrtimer_sleeper *to,
 118                                      struct rt_mutex_waiter *waiter,
 119                                      int detect_deadlock);
 120
 121#ifdef CONFIG_DEBUG_RT_MUTEXES
 122# include "rtmutex-debug.h"
 123#else
 124# include "rtmutex.h"
 125#endif
 126
 127#endif
 128