rtmutex_common.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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 
   25 extern 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  * @list_entry:         pi node to enqueue into the mutex waiters list
   44  * @pi_list_entry:      pi node to enqueue into the mutex owner waiters list
   45  * @task:               task reference to the blocked task
   46  */
   47 struct rt_mutex_waiter {
   48         struct plist_node       list_entry;
   49         struct plist_node       pi_list_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 };
   58 
   59 /*
   60  * Various helpers to access the waiters-plist:
   61  */
   62 static inline int rt_mutex_has_waiters(struct rt_mutex *lock)
   63 {
   64         return !plist_head_empty(&lock->wait_list);
   65 }
   66 
   67 static inline struct rt_mutex_waiter *
   68 rt_mutex_top_waiter(struct rt_mutex *lock)
   69 {
   70         struct rt_mutex_waiter *w;
   71 
   72         w = plist_first_entry(&lock->wait_list, struct rt_mutex_waiter,
   73                                list_entry);
   74         BUG_ON(w->lock != lock);
   75 
   76         return w;
   77 }
   78 
   79 static inline int task_has_pi_waiters(struct task_struct *p)
   80 {
   81         return !plist_head_empty(&p->pi_waiters);
   82 }
   83 
   84 static inline struct rt_mutex_waiter *
   85 task_top_pi_waiter(struct task_struct *p)
   86 {
   87         return plist_first_entry(&p->pi_waiters, struct rt_mutex_waiter,
   88                                   pi_list_entry);
   89 }
   90 
   91 /*
   92  * lock->owner state tracking:
   93  */
   94 #define RT_MUTEX_HAS_WAITERS    1UL
   95 #define RT_MUTEX_OWNER_MASKALL  1UL
   96 
   97 static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)
   98 {
   99         return (struct task_struct *)
  100                 ((unsigned long)lock->owner & ~RT_MUTEX_OWNER_MASKALL);
  101 }
  102 
  103 /*
  104  * PI-futex support (proxy locking functions, etc.):
  105  */
  106 extern struct task_struct *rt_mutex_next_owner(struct rt_mutex *lock);
  107 extern void rt_mutex_init_proxy_locked(struct rt_mutex *lock,
  108                                        struct task_struct *proxy_owner);
  109 extern void rt_mutex_proxy_unlock(struct rt_mutex *lock,
  110                                   struct task_struct *proxy_owner);
  111 extern int rt_mutex_start_proxy_lock(struct rt_mutex *lock,
  112                                      struct rt_mutex_waiter *waiter,
  113                                      struct task_struct *task,
  114                                      int detect_deadlock);
  115 extern int rt_mutex_finish_proxy_lock(struct rt_mutex *lock,
  116                                       struct hrtimer_sleeper *to,
  117                                       struct rt_mutex_waiter *waiter,
  118                                       int detect_deadlock);
  119 
  120 #ifdef CONFIG_DEBUG_RT_MUTEXES
  121 # include "rtmutex-debug.h"
  122 #else
  123 # include "rtmutex.h"
  124 #endif
  125 
  126 #endif

Cache object: 012f9d2f8fd63cb23113f95787b2c833

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/kernel/rtmutex_common.h

FreeBSD/Linux Kernel Cross Reference
sys/kernel/rtmutex_common.h