adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 19:56:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

lockdep: sanitize bit names

Browse source 
s/\(LOCKF\?_ENABLED_[^ ]*\)S\(_READ\)\?\>/\1\2/g

So that the USED_IN and ENABLED have the same names.

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Peter Zijlstra 2009-01-22 13:10:52 +01:00 committed by Ingo Molnar
parent cf40bd16fd
commit 4fc95e867f
3 changed files with 59 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
include/linux/lockdep.h
View file

@ -28,14 +28,14 @@ enum lock_usage_bit
LOCK_USED_IN_HARDIRQ, LOCK_USED_IN_HARDIRQ,
LOCK_USED_IN_SOFTIRQ, LOCK_USED_IN_SOFTIRQ,
LOCK_USED_IN_RECLAIM_FS, LOCK_USED_IN_RECLAIM_FS,
LOCK_ENABLED_SOFTIRQS, LOCK_ENABLED_SOFTIRQ,
LOCK_ENABLED_HARDIRQS, LOCK_ENABLED_HARDIRQ,
LOCK_HELD_OVER_RECLAIM_FS, LOCK_HELD_OVER_RECLAIM_FS,
LOCK_USED_IN_HARDIRQ_READ, LOCK_USED_IN_HARDIRQ_READ,
LOCK_USED_IN_SOFTIRQ_READ, LOCK_USED_IN_SOFTIRQ_READ,
LOCK_USED_IN_RECLAIM_FS_READ, LOCK_USED_IN_RECLAIM_FS_READ,
LOCK_ENABLED_SOFTIRQS_READ, LOCK_ENABLED_SOFTIRQ_READ,
LOCK_ENABLED_HARDIRQS_READ, LOCK_ENABLED_HARDIRQ_READ,
LOCK_HELD_OVER_RECLAIM_FS_READ, LOCK_HELD_OVER_RECLAIM_FS_READ,
LOCK_USAGE_STATES LOCK_USAGE_STATES
}; };
@ -47,22 +47,22 @@ enum lock_usage_bit
#define LOCKF_USED_IN_HARDIRQ (1 << LOCK_USED_IN_HARDIRQ) #define LOCKF_USED_IN_HARDIRQ (1 << LOCK_USED_IN_HARDIRQ)
#define LOCKF_USED_IN_SOFTIRQ (1 << LOCK_USED_IN_SOFTIRQ) #define LOCKF_USED_IN_SOFTIRQ (1 << LOCK_USED_IN_SOFTIRQ)
#define LOCKF_USED_IN_RECLAIM_FS (1 << LOCK_USED_IN_RECLAIM_FS) #define LOCKF_USED_IN_RECLAIM_FS (1 << LOCK_USED_IN_RECLAIM_FS)
#define LOCKF_ENABLED_HARDIRQS (1 << LOCK_ENABLED_HARDIRQS) #define LOCKF_ENABLED_HARDIRQ (1 << LOCK_ENABLED_HARDIRQ)
#define LOCKF_ENABLED_SOFTIRQS (1 << LOCK_ENABLED_SOFTIRQS) #define LOCKF_ENABLED_SOFTIRQ (1 << LOCK_ENABLED_SOFTIRQ)
#define LOCKF_HELD_OVER_RECLAIM_FS (1 << LOCK_HELD_OVER_RECLAIM_FS) #define LOCKF_HELD_OVER_RECLAIM_FS (1 << LOCK_HELD_OVER_RECLAIM_FS)
#define LOCKF_ENABLED_IRQS (LOCKF_ENABLED_HARDIRQS | LOCKF_ENABLED_SOFTIRQS) #define LOCKF_ENABLED_IRQ (LOCKF_ENABLED_HARDIRQ | LOCKF_ENABLED_SOFTIRQ)
#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ) #define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)
#define LOCKF_USED_IN_HARDIRQ_READ (1 << LOCK_USED_IN_HARDIRQ_READ) #define LOCKF_USED_IN_HARDIRQ_READ (1 << LOCK_USED_IN_HARDIRQ_READ)
#define LOCKF_USED_IN_SOFTIRQ_READ (1 << LOCK_USED_IN_SOFTIRQ_READ) #define LOCKF_USED_IN_SOFTIRQ_READ (1 << LOCK_USED_IN_SOFTIRQ_READ)
#define LOCKF_USED_IN_RECLAIM_FS_READ (1 << LOCK_USED_IN_RECLAIM_FS_READ) #define LOCKF_USED_IN_RECLAIM_FS_READ (1 << LOCK_USED_IN_RECLAIM_FS_READ)
#define LOCKF_ENABLED_HARDIRQS_READ (1 << LOCK_ENABLED_HARDIRQS_READ) #define LOCKF_ENABLED_HARDIRQ_READ (1 << LOCK_ENABLED_HARDIRQ_READ)
#define LOCKF_ENABLED_SOFTIRQS_READ (1 << LOCK_ENABLED_SOFTIRQS_READ) #define LOCKF_ENABLED_SOFTIRQ_READ (1 << LOCK_ENABLED_SOFTIRQ_READ)
#define LOCKF_HELD_OVER_RECLAIM_FS_READ (1 << LOCK_HELD_OVER_RECLAIM_FS_READ) #define LOCKF_HELD_OVER_RECLAIM_FS_READ (1 << LOCK_HELD_OVER_RECLAIM_FS_READ)
#define LOCKF_ENABLED_IRQS_READ \ #define LOCKF_ENABLED_IRQ_READ \
(LOCKF_ENABLED_HARDIRQS_READ | LOCKF_ENABLED_SOFTIRQS_READ) (LOCKF_ENABLED_HARDIRQ_READ | LOCKF_ENABLED_SOFTIRQ_READ)
#define LOCKF_USED_IN_IRQ_READ \ #define LOCKF_USED_IN_IRQ_READ \
(LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ) (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)

84
kernel/lockdep.c
View file

@ -450,12 +450,12 @@ static const char *usage_str[] =
[LOCK_USED] = "initial-use ", [LOCK_USED] = "initial-use ",
[LOCK_USED_IN_HARDIRQ] = "in-hardirq-W", [LOCK_USED_IN_HARDIRQ] = "in-hardirq-W",
[LOCK_USED_IN_SOFTIRQ] = "in-softirq-W", [LOCK_USED_IN_SOFTIRQ] = "in-softirq-W",
[LOCK_ENABLED_SOFTIRQS] = "softirq-on-W", [LOCK_ENABLED_SOFTIRQ] = "softirq-on-W",
[LOCK_ENABLED_HARDIRQS] = "hardirq-on-W", [LOCK_ENABLED_HARDIRQ] = "hardirq-on-W",
[LOCK_USED_IN_HARDIRQ_READ] = "in-hardirq-R", [LOCK_USED_IN_HARDIRQ_READ] = "in-hardirq-R",
[LOCK_USED_IN_SOFTIRQ_READ] = "in-softirq-R", [LOCK_USED_IN_SOFTIRQ_READ] = "in-softirq-R",
[LOCK_ENABLED_SOFTIRQS_READ] = "softirq-on-R", [LOCK_ENABLED_SOFTIRQ_READ] = "softirq-on-R",
[LOCK_ENABLED_HARDIRQS_READ] = "hardirq-on-R", [LOCK_ENABLED_HARDIRQ_READ] = "hardirq-on-R",
[LOCK_USED_IN_RECLAIM_FS] = "in-reclaim-W", [LOCK_USED_IN_RECLAIM_FS] = "in-reclaim-W",
[LOCK_USED_IN_RECLAIM_FS_READ] = "in-reclaim-R", [LOCK_USED_IN_RECLAIM_FS_READ] = "in-reclaim-R",
[LOCK_HELD_OVER_RECLAIM_FS] = "ov-reclaim-W", [LOCK_HELD_OVER_RECLAIM_FS] = "ov-reclaim-W",
@ -476,28 +476,28 @@ get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3,
if (class->usage_mask & LOCKF_USED_IN_HARDIRQ) if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
*c1 = '+'; *c1 = '+';
else else
if (class->usage_mask & LOCKF_ENABLED_HARDIRQS) if (class->usage_mask & LOCKF_ENABLED_HARDIRQ)
*c1 = '-'; *c1 = '-';
if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ) if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
*c2 = '+'; *c2 = '+';
else else
if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS) if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ)
*c2 = '-'; *c2 = '-';
if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ)
*c3 = '-'; *c3 = '-';
if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) { if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) {
*c3 = '+'; *c3 = '+';
if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ)
*c3 = '?'; *c3 = '?';
} }
if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ)
*c4 = '-'; *c4 = '-';
if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) { if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) {
*c4 = '+'; *c4 = '+';
if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ)
*c4 = '?'; *c4 = '?';
} }
@ -1296,7 +1296,7 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
* forwards-subgraph starting at <next>: * forwards-subgraph starting at <next>:
*/ */
if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ, if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ,
LOCK_ENABLED_HARDIRQS, "hard")) LOCK_ENABLED_HARDIRQ, "hard"))
return 0; return 0;
/* /*
@ -1306,7 +1306,7 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
* forwards-subgraph starting at <next>: * forwards-subgraph starting at <next>:
*/ */
if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ_READ, if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ_READ,
LOCK_ENABLED_HARDIRQS, "hard-read")) LOCK_ENABLED_HARDIRQ, "hard-read"))
return 0; return 0;
/* /*
@ -1316,7 +1316,7 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
* forwards-subgraph starting at <next>: * forwards-subgraph starting at <next>:
*/ */
if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ, if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ,
LOCK_ENABLED_SOFTIRQS, "soft")) LOCK_ENABLED_SOFTIRQ, "soft"))
return 0; return 0;
/* /*
* Prove that the new dependency does not connect a softirq-safe-read * Prove that the new dependency does not connect a softirq-safe-read
@ -1325,7 +1325,7 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
* forwards-subgraph starting at <next>: * forwards-subgraph starting at <next>:
*/ */
if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ_READ, if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ_READ,
LOCK_ENABLED_SOFTIRQS, "soft")) LOCK_ENABLED_SOFTIRQ, "soft"))
return 0; return 0;
/* /*
@ -2008,17 +2008,17 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
switch(new_bit) { switch(new_bit) {
case LOCK_USED_IN_HARDIRQ: case LOCK_USED_IN_HARDIRQ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS)) if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQ))
return 0; return 0;
if (!valid_state(curr, this, new_bit, if (!valid_state(curr, this, new_bit,
LOCK_ENABLED_HARDIRQS_READ)) LOCK_ENABLED_HARDIRQ_READ))
return 0; return 0;
/* /*
* just marked it hardirq-safe, check that this lock * just marked it hardirq-safe, check that this lock
* took no hardirq-unsafe lock in the past: * took no hardirq-unsafe lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_HARDIRQS, "hard")) LOCK_ENABLED_HARDIRQ, "hard"))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
/* /*
@ -2026,24 +2026,24 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
* took no hardirq-unsafe-read lock in the past: * took no hardirq-unsafe-read lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_HARDIRQS_READ, "hard-read")) LOCK_ENABLED_HARDIRQ_READ, "hard-read"))
return 0; return 0;
#endif #endif
if (hardirq_verbose(hlock_class(this))) if (hardirq_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_USED_IN_SOFTIRQ: case LOCK_USED_IN_SOFTIRQ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS)) if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQ))
return 0; return 0;
if (!valid_state(curr, this, new_bit, if (!valid_state(curr, this, new_bit,
LOCK_ENABLED_SOFTIRQS_READ)) LOCK_ENABLED_SOFTIRQ_READ))
return 0; return 0;
/* /*
* just marked it softirq-safe, check that this lock * just marked it softirq-safe, check that this lock
* took no softirq-unsafe lock in the past: * took no softirq-unsafe lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQS, "soft")) LOCK_ENABLED_SOFTIRQ, "soft"))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
/* /*
@ -2051,7 +2051,7 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
* took no softirq-unsafe-read lock in the past: * took no softirq-unsafe-read lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQS_READ, "soft-read")) LOCK_ENABLED_SOFTIRQ_READ, "soft-read"))
return 0; return 0;
#endif #endif
if (softirq_verbose(hlock_class(this))) if (softirq_verbose(hlock_class(this)))
@ -2083,27 +2083,27 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
ret = 2; ret = 2;
break; break;
case LOCK_USED_IN_HARDIRQ_READ: case LOCK_USED_IN_HARDIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS)) if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQ))
return 0; return 0;
/* /*
* just marked it hardirq-read-safe, check that this lock * just marked it hardirq-read-safe, check that this lock
* took no hardirq-unsafe lock in the past: * took no hardirq-unsafe lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_HARDIRQS, "hard")) LOCK_ENABLED_HARDIRQ, "hard"))
return 0; return 0;
if (hardirq_verbose(hlock_class(this))) if (hardirq_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_USED_IN_SOFTIRQ_READ: case LOCK_USED_IN_SOFTIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS)) if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQ))
return 0; return 0;
/* /*
* just marked it softirq-read-safe, check that this lock * just marked it softirq-read-safe, check that this lock
* took no softirq-unsafe lock in the past: * took no softirq-unsafe lock in the past:
*/ */
if (!check_usage_forwards(curr, this, if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQS, "soft")) LOCK_ENABLED_SOFTIRQ, "soft"))
return 0; return 0;
if (softirq_verbose(hlock_class(this))) if (softirq_verbose(hlock_class(this)))
ret = 2; ret = 2;
@ -2121,7 +2121,7 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
if (reclaim_verbose(hlock_class(this))) if (reclaim_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_ENABLED_HARDIRQS: case LOCK_ENABLED_HARDIRQ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ)) if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
return 0; return 0;
if (!valid_state(curr, this, new_bit, if (!valid_state(curr, this, new_bit,
@ -2147,7 +2147,7 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
if (hardirq_verbose(hlock_class(this))) if (hardirq_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_ENABLED_SOFTIRQS: case LOCK_ENABLED_SOFTIRQ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ)) if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
return 0; return 0;
if (!valid_state(curr, this, new_bit, if (!valid_state(curr, this, new_bit,
@ -2199,7 +2199,7 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
if (reclaim_verbose(hlock_class(this))) if (reclaim_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_ENABLED_HARDIRQS_READ: case LOCK_ENABLED_HARDIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ)) if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
@ -2214,7 +2214,7 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
if (hardirq_verbose(hlock_class(this))) if (hardirq_verbose(hlock_class(this)))
ret = 2; ret = 2;
break; break;
case LOCK_ENABLED_SOFTIRQS_READ: case LOCK_ENABLED_SOFTIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ)) if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
@ -2274,16 +2274,16 @@ mark_held_locks(struct task_struct *curr, enum mark_type mark)
switch (mark) { switch (mark) {
case HARDIRQ: case HARDIRQ:
if (hlock->read) if (hlock->read)
usage_bit = LOCK_ENABLED_HARDIRQS_READ; usage_bit = LOCK_ENABLED_HARDIRQ_READ;
else else
usage_bit = LOCK_ENABLED_HARDIRQS; usage_bit = LOCK_ENABLED_HARDIRQ;
break; break;
case SOFTIRQ: case SOFTIRQ:
if (hlock->read) if (hlock->read)
usage_bit = LOCK_ENABLED_SOFTIRQS_READ; usage_bit = LOCK_ENABLED_SOFTIRQ_READ;
else else
usage_bit = LOCK_ENABLED_SOFTIRQS; usage_bit = LOCK_ENABLED_SOFTIRQ;
break; break;
case RECLAIM_FS: case RECLAIM_FS:
@ -2520,19 +2520,19 @@ static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)
if (!hlock->hardirqs_off) { if (!hlock->hardirqs_off) {
if (hlock->read) { if (hlock->read) {
if (!mark_lock(curr, hlock, if (!mark_lock(curr, hlock,
LOCK_ENABLED_HARDIRQS_READ)) LOCK_ENABLED_HARDIRQ_READ))
return 0; return 0;
if (curr->softirqs_enabled) if (curr->softirqs_enabled)
if (!mark_lock(curr, hlock, if (!mark_lock(curr, hlock,
LOCK_ENABLED_SOFTIRQS_READ)) LOCK_ENABLED_SOFTIRQ_READ))
return 0; return 0;
} else { } else {
if (!mark_lock(curr, hlock, if (!mark_lock(curr, hlock,
LOCK_ENABLED_HARDIRQS)) LOCK_ENABLED_HARDIRQ))
return 0; return 0;
if (curr->softirqs_enabled) if (curr->softirqs_enabled)
if (!mark_lock(curr, hlock, if (!mark_lock(curr, hlock,
LOCK_ENABLED_SOFTIRQS)) LOCK_ENABLED_SOFTIRQ))
return 0; return 0;
} }
} }
@ -2640,10 +2640,10 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
case LOCK_USED_IN_SOFTIRQ: case LOCK_USED_IN_SOFTIRQ:
case LOCK_USED_IN_HARDIRQ_READ: case LOCK_USED_IN_HARDIRQ_READ:
case LOCK_USED_IN_SOFTIRQ_READ: case LOCK_USED_IN_SOFTIRQ_READ:
case LOCK_ENABLED_HARDIRQS: case LOCK_ENABLED_HARDIRQ:
case LOCK_ENABLED_SOFTIRQS: case LOCK_ENABLED_SOFTIRQ:
case LOCK_ENABLED_HARDIRQS_READ: case LOCK_ENABLED_HARDIRQ_READ:
case LOCK_ENABLED_SOFTIRQS_READ: case LOCK_ENABLED_SOFTIRQ_READ:
case LOCK_USED_IN_RECLAIM_FS: case LOCK_USED_IN_RECLAIM_FS:
case LOCK_USED_IN_RECLAIM_FS_READ: case LOCK_USED_IN_RECLAIM_FS_READ:
case LOCK_HELD_OVER_RECLAIM_FS: case LOCK_HELD_OVER_RECLAIM_FS:

12
kernel/lockdep_proc.c
View file

@ -300,27 +300,27 @@ static int lockdep_stats_show(struct seq_file *m, void *v)
nr_uncategorized++; nr_uncategorized++;
if (class->usage_mask & LOCKF_USED_IN_IRQ) if (class->usage_mask & LOCKF_USED_IN_IRQ)
nr_irq_safe++; nr_irq_safe++;
if (class->usage_mask & LOCKF_ENABLED_IRQS) if (class->usage_mask & LOCKF_ENABLED_IRQ)
nr_irq_unsafe++; nr_irq_unsafe++;
if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ) if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
nr_softirq_safe++; nr_softirq_safe++;
if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS) if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ)
nr_softirq_unsafe++; nr_softirq_unsafe++;
if (class->usage_mask & LOCKF_USED_IN_HARDIRQ) if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
nr_hardirq_safe++; nr_hardirq_safe++;
if (class->usage_mask & LOCKF_ENABLED_HARDIRQS) if (class->usage_mask & LOCKF_ENABLED_HARDIRQ)
nr_hardirq_unsafe++; nr_hardirq_unsafe++;
if (class->usage_mask & LOCKF_USED_IN_IRQ_READ) if (class->usage_mask & LOCKF_USED_IN_IRQ_READ)
nr_irq_read_safe++; nr_irq_read_safe++;
if (class->usage_mask & LOCKF_ENABLED_IRQS_READ) if (class->usage_mask & LOCKF_ENABLED_IRQ_READ)
nr_irq_read_unsafe++; nr_irq_read_unsafe++;
if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ)
nr_softirq_read_safe++; nr_softirq_read_safe++;
if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ)
nr_softirq_read_unsafe++; nr_softirq_read_unsafe++;
if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ)
nr_hardirq_read_safe++; nr_hardirq_read_safe++;
if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ) if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ)
nr_hardirq_read_unsafe++; nr_hardirq_read_unsafe++;
#ifdef CONFIG_PROVE_LOCKING #ifdef CONFIG_PROVE_LOCKING