Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
17enum 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 */
63struct lockdep_subclass_key {
64 char __one_byte;
65} __attribute__ ((__packed__));
66
67/* hash_entry is used to keep track of dynamically allocated keys. */
68struct lock_class_key {
69 union {
70 struct hlist_node hash_entry;
71 struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
72 };
73};
74
75extern struct lock_class_key __lockdep_no_validate__;
76
77struct 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 */
85struct 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
132struct lock_time {
133 s64 min;
134 s64 max;
135 s64 total;
136 unsigned long nr;
137};
138
139enum 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
150struct 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
160struct lock_class_stats lock_stats(struct lock_class *class);
161void 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 */
168struct 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
180struct pin_cookie { unsigned int val; };
181
182#else /* !CONFIG_LOCKDEP */
183
184/*
185 * The class key takes no space if lockdep is disabled:
186 */
187struct lock_class_key { };
188
189/*
190 * The lockdep_map takes no space if lockdep is disabled:
191 */
192struct lockdep_map { };
193
194struct pin_cookie { };
195
196#endif /* !LOCKDEP */
197
198#endif /* __LINUX_LOCKDEP_TYPES_H */