Lines Matching refs:class
22 * locks (but of the same class as this lock), this code will detect it.
47 * class/list/hash allocators.
202 static int class_filter(struct lock_class *class)
209 static int verbose(struct lock_class *class)
212 return class_filter(class);
219 static int hardirq_verbose(struct lock_class *class)
222 return class_filter(class);
227 static int softirq_verbose(struct lock_class *class)
230 return class_filter(class);
338 get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3, char *c4)
342 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
345 if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
348 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
351 if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
354 if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
356 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) {
358 if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
362 if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
364 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) {
366 if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
371 static void print_lock_name(struct lock_class *class)
376 get_usage_chars(class, &c1, &c2, &c3, &c4);
378 name = class->name;
380 name = __get_key_name(class->key, str);
384 if (class->name_version > 1)
385 printk("#%d", class->name_version);
386 if (class->subclass)
387 printk("/%d", class->subclass);
406 print_lock_name(hlock->class);
428 static void print_lock_class_header(struct lock_class *class, int depth)
433 print_lock_name(class);
434 printk(" ops: %lu", class->ops);
438 if (class->usage_mask & (1 << bit)) {
443 print_stack_trace(class->usage_traces + bit, len);
449 print_ip_sym((unsigned long)class->key);
455 static void print_lock_dependencies(struct lock_class *class, int depth)
462 print_lock_class_header(class, depth);
464 list_for_each_entry(entry, &class->locks_after, entry) {
465 if (DEBUG_LOCKS_WARN_ON(!entry->class))
468 print_lock_dependencies(entry->class, depth + 1);
479 static int add_lock_to_list(struct lock_class *class, struct lock_class *this,
491 entry->class = this;
529 print_lock_name(target->class);
580 this.class = check_source->class;
625 if (entry->class == check_target->class)
628 if (!check_noncircular(entry->class, depth+1))
634 static int very_verbose(struct lock_class *class)
637 return class_filter(class);
683 ret = find_usage_forwards(entry->class, depth+1);
725 ret = find_usage_backwards(entry->class, depth+1);
759 print_lock_name(prev->class);
761 print_lock_name(next->class);
802 ret = find_usage_backwards(prev->class, 0);
807 ret = find_usage_forwards(next->class, 0);
844 * Check whether we are holding such a class already.
860 if (prev->class != next->class)
864 * lock class (i.e. read_lock(lock)+read_lock(lock)):
913 if (!(check_noncircular(next->class, 0)))
974 list_for_each_entry(entry, &prev->class->locks_after, entry) {
975 if (entry->class == next->class) {
986 ret = add_lock_to_list(prev->class, next->class,
987 &prev->class->locks_after, next->acquire_ip, distance);
992 ret = add_lock_to_list(next->class, prev->class,
993 &next->class->locks_before, next->acquire_ip, distance);
1000 if (verbose(prev->class) || verbose(next->class)) {
1003 print_lock_name(prev->class);
1005 print_lock_name(next->class);
1123 * class->name_version generation counter:
1127 struct lock_class *class;
1133 list_for_each_entry(class, &all_lock_classes, lock_entry) {
1134 if (new_class->key - new_class->subclass == class->key)
1135 return class->name_version;
1136 if (class->name && !strcmp(class->name, new_class->name))
1137 count = max(count, class->name_version);
1144 * Register a lock's class in the hash-table, if the class is not present
1153 struct lock_class *class;
1168 * Static locks do not have their class-keys yet - for them the key
1175 * NOTE: the class-key must be unique. For dynamic locks, a static
1190 list_for_each_entry(class, hash_head, hash_entry)
1191 if (class->key == key)
1192 return class;
1198 * Register a lock's class in the hash-table, if the class is not present
1207 struct lock_class *class;
1210 class = look_up_lock_class(lock, subclass);
1211 if (likely(class))
1212 return class;
1239 list_for_each_entry(class, hash_head, hash_entry)
1240 if (class->key == key)
1257 class = lock_classes + nr_lock_classes++;
1259 class->key = key;
1260 class->name = lock->name;
1261 class->subclass = subclass;
1262 INIT_LIST_HEAD(&class->lock_entry);
1263 INIT_LIST_HEAD(&class->locks_before);
1264 INIT_LIST_HEAD(&class->locks_after);
1265 class->name_version = count_matching_names(class);
1270 list_add_tail_rcu(&class->hash_entry, hash_head);
1272 if (verbose(class)) {
1276 printk("\nnew class %p: %s", class->key, class->name);
1277 if (class->name_version > 1)
1278 printk("#%d", class->name_version);
1293 lock->class_cache = class;
1295 if (DEBUG_LOCKS_WARN_ON(class->subclass != subclass))
1298 return class;
1307 static inline int lookup_chain_cache(u64 chain_key, struct lock_class *class)
1322 if (very_verbose(class))
1324 "%016Lx tail class: [%p] %s\n",
1326 class->key, class->name);
1330 if (very_verbose(class))
1331 printk("\nnew hash chain, key: %016Lx tail class: [%p] %s\n",
1332 (unsigned long long)chain_key, class->key, class->name);
1398 id = hlock->class - lock_classes;
1450 print_lock_dependencies(this->class, 0);
1473 ret = find_usage_forwards(this->class, 0);
1492 ret = find_usage_backwards(this->class, 0);
1538 print_stack_trace(this->class->usage_traces + prev_bit, 1);
1557 if (unlikely(this->class->usage_mask & (1 << bad_bit)))
1576 if (likely(this->class->usage_mask & new_mask))
1584 if (unlikely(this->class->usage_mask & new_mask)) {
1589 this->class->usage_mask |= new_mask;
1591 if (!save_trace(this->class->usage_traces + new_bit))
1618 if (hardirq_verbose(this->class))
1643 if (softirq_verbose(this->class))
1656 if (hardirq_verbose(this->class))
1669 if (softirq_verbose(this->class))
1695 if (hardirq_verbose(this->class))
1721 if (softirq_verbose(this->class))
1736 if (hardirq_verbose(this->class))
1751 if (softirq_verbose(this->class))
1759 list_add_tail_rcu(&this->class->lock_entry, &all_lock_classes);
1970 * Initialize a lock instance's lock-class mapping info:
1983 * Sanity check, the lock-class key must be persistent:
2008 struct lock_class *class = NULL;
2028 class = lock->class_cache;
2032 if (unlikely(!class)) {
2033 class = register_lock_class(lock, subclass, 0);
2034 if (!class)
2037 debug_atomic_inc((atomic_t *)&class->ops);
2038 if (very_verbose(class)) {
2039 printk("\nacquire class [%p] %s", class->key, class->name);
2040 if (class->name_version > 1)
2041 printk("#%d", class->name_version);
2057 hlock->class = class;
2123 * the hash, not class->key.
2125 id = class - lock_classes;
2172 if (!trylock && (check == 2) && lookup_chain_cache(chain_key, class)) {
2320 hlock->class->subclass, hlock->trylock,
2363 hlock->class = NULL;
2491 static void zap_class(struct lock_class *class)
2500 if (list_entries[i].class == class)
2504 * Unhash the class and remove it from the all_lock_classes list:
2506 list_del_rcu(&class->hash_entry);
2507 list_del_rcu(&class->lock_entry);
2518 struct lock_class *class, *next;
2533 list_for_each_entry_safe(class, next, head, hash_entry)
2534 if (within(class->key, start, size))
2535 zap_class(class);
2544 struct lock_class *class, *next;
2556 * If the class exists we look it up and zap it:
2558 class = look_up_lock_class(lock, j);
2559 if (class)
2560 zap_class(class);
2571 list_for_each_entry_safe(class, next, head, hash_entry) {
2572 if (unlikely(class == lock->class_cache)) {