include/linux/lockdep_types.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Runtime locking correctness validator
   4  *
   5  *  Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
   6  *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
   7  *
   8  * see Documentation/locking/lockdep-design.rst for more details.
   9  */
  10 #ifndef __LINUX_LOCKDEP_TYPES_H
  11 #define __LINUX_LOCKDEP_TYPES_H
  12
  13 #include <linux/types.h>
  14
  15 #define MAX_LOCKDEP_SUBCLASSES          8UL
  16
  17 enum lockdep_wait_type {
  18         LD_WAIT_INV = 0,        /* not checked, catch all */
  19
  20         LD_WAIT_FREE,           /* wait free, rcu etc.. */
  21         LD_WAIT_SPIN,           /* spin loops, raw_spinlock_t etc.. */
  22
  23 #ifdef CONFIG_PROVE_RAW_LOCK_NESTING
  24         LD_WAIT_CONFIG,         /* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */
  25 #else
  26         LD_WAIT_CONFIG = LD_WAIT_SPIN,
  27 #endif
  28         LD_WAIT_SLEEP,          /* sleeping locks, mutex_t etc.. */
  29
  30         LD_WAIT_MAX,            /* must be last */
  31 };
  32
  33 #ifdef CONFIG_LOCKDEP
  34
  35 /*
  36  * We'd rather not expose kernel/lockdep_states.h this wide, but we do need
  37  * the total number of states... :-(
  38  *
  39  * XXX_LOCK_USAGE_STATES is the number of lines in lockdep_states.h, for each
  40  * of those we generates 4 states, Additionally we report on USED and USED_READ.
  41  */
  42 #define XXX_LOCK_USAGE_STATES           2
  43 #define LOCK_TRACE_STATES               (XXX_LOCK_USAGE_STATES*4 + 2)
  44
  45 /*
  46  * NR_LOCKDEP_CACHING_CLASSES ... Number of classes
  47  * cached in the instance of lockdep_map
  48  *
  49  * Currently main class (subclass == 0) and signle depth subclass
  50  * are cached in lockdep_map. This optimization is mainly targeting
  51  * on rq->lock. double_rq_lock() acquires this highly competitive with
  52  * single depth.
  53  */
  54 #define NR_LOCKDEP_CACHING_CLASSES      2
  55
  56 /*
  57  * A lockdep key is associated with each lock object. For static locks we use
  58  * the lock address itself as the key. Dynamically allocated lock objects can
  59  * have a statically or dynamically allocated key. Dynamically allocated lock
  60  * keys must be registered before being used and must be unregistered before
  61  * the key memory is freed.
  62  */
  63 struct lockdep_subclass_key {
  64         char __one_byte;
  65 } __attribute__ ((__packed__));
  66
  67 /* hash_entry is used to keep track of dynamically allocated keys. */
  68 struct lock_class_key {
  69         union {
  70                 struct hlist_node               hash_entry;
  71                 struct lockdep_subclass_key     subkeys[MAX_LOCKDEP_SUBCLASSES];
  72         };
  73 };
  74
  75 extern struct lock_class_key __lockdep_no_validate__;
  76
  77 struct lock_trace;
  78
  79 #define LOCKSTAT_POINTS         4
  80
  81 /*
  82  * The lock-class itself. The order of the structure members matters.
  83  * reinit_class() zeroes the key member and all subsequent members.
  84  */
  85 struct lock_class {
  86         /*
  87          * class-hash:
  88          */
  89         struct hlist_node               hash_entry;
  90
  91         /*
  92          * Entry in all_lock_classes when in use. Entry in free_lock_classes
  93          * when not in use. Instances that are being freed are on one of the
  94          * zapped_classes lists.
  95          */
  96         struct list_head                lock_entry;
  97
  98         /*
  99          * These fields represent a directed graph of lock dependencies,
 100          * to every node we attach a list of "forward" and a list of
 101          * "backward" graph nodes.
 102          */
 103         struct list_head                locks_after, locks_before;
 104
 105         const struct lockdep_subclass_key *key;
 106         unsigned int                    subclass;
 107         unsigned int                    dep_gen_id;
 108
 109         /*
 110          * IRQ/softirq usage tracking bits:
 111          */
 112         unsigned long                   usage_mask;
 113         const struct lock_trace         *usage_traces[LOCK_TRACE_STATES];
 114
 115         /*
 116          * Generation counter, when doing certain classes of graph walking,
 117          * to ensure that we check one node only once:
 118          */
 119         int                             name_version;
 120         const char                      *name;
 121
 122         short                           wait_type_inner;
 123         short                           wait_type_outer;
 124
 125 #ifdef CONFIG_LOCK_STAT
 126         unsigned long                   contention_point[LOCKSTAT_POINTS];
 127         unsigned long                   contending_point[LOCKSTAT_POINTS];
 128 #endif
 129 } __no_randomize_layout;
 130
 131 #ifdef CONFIG_LOCK_STAT
 132 struct lock_time {
 133         s64                             min;
 134         s64                             max;
 135         s64                             total;
 136         unsigned long                   nr;
 137 };
 138
 139 enum bounce_type {
 140         bounce_acquired_write,
 141         bounce_acquired_read,
 142         bounce_contended_write,
 143         bounce_contended_read,
 144         nr_bounce_types,
 145
 146         bounce_acquired = bounce_acquired_write,
 147         bounce_contended = bounce_contended_write,
 148 };
 149
 150 struct lock_class_stats {
 151         unsigned long                   contention_point[LOCKSTAT_POINTS];
 152         unsigned long                   contending_point[LOCKSTAT_POINTS];
 153         struct lock_time                read_waittime;
 154         struct lock_time                write_waittime;
 155         struct lock_time                read_holdtime;
 156         struct lock_time                write_holdtime;
 157         unsigned long                   bounces[nr_bounce_types];
 158 };
 159
 160 struct lock_class_stats lock_stats(struct lock_class *class);
 161 void clear_lock_stats(struct lock_class *class);
 162 #endif
 163
 164 /*
 165  * Map the lock object (the lock instance) to the lock-class object.
 166  * This is embedded into specific lock instances:
 167  */
 168 struct lockdep_map {
 169         struct lock_class_key           *key;
 170         struct lock_class               *class_cache[NR_LOCKDEP_CACHING_CLASSES];
 171         const char                      *name;
 172         short                           wait_type_outer; /* can be taken in this context */
 173         short                           wait_type_inner; /* presents this context */
 174 #ifdef CONFIG_LOCK_STAT
 175         int                             cpu;
 176         unsigned long                   ip;
 177 #endif
 178 };
 179
 180 struct pin_cookie { unsigned int val; };
 181
 182 #else /* !CONFIG_LOCKDEP */
 183
 184 /*
 185  * The class key takes no space if lockdep is disabled:
 186  */
 187 struct lock_class_key { };
 188
 189 /*
 190  * The lockdep_map takes no space if lockdep is disabled:
 191  */
 192 struct lockdep_map { };
 193
 194 struct pin_cookie { };
 195
 196 #endif /* !LOCKDEP */
 197
 198 #endif /* __LINUX_LOCKDEP_TYPES_H */