Skip to content

L
linux-davinci
Commit 6a6904d3 authored by Peter Zijlstra's avatar Peter Zijlstra Committed by Ingo Molnar
Browse files
Options

lockdep: split up mark_lock_irq() 

split mark_lock_irq() into 4 simple helper functions
Signed-off-by: default avatarPeter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent fabe9c42
Show whitespace changes
Inline Side-by-side
Showing with 147 additions and 225 deletions
kernel/lockdep.c
View file @ 6a6904d3
...@@ -2001,138 +2001,71 @@ static int reclaim_verbose(struct lock_class *class) ...@@ -2001,138 +2001,71 @@ static int reclaim_verbose(struct lock_class *class)
#define STRICT_READ_CHECKS 1 #define STRICT_READ_CHECKS 1
static int mark_lock_irq(struct task_struct *curr, struct held_lock *this, static int
enum lock_usage_bit new_bit) mark_lock_irq_used_in(struct task_struct *curr, struct held_lock *this,
int new_bit, int excl_bit,
const char *name, const char *rname,
int (*verbose)(struct lock_class *class))
{ {
int ret = 1; if (!valid_state(curr, this, new_bit, excl_bit))
switch(new_bit) {
case LOCK_USED_IN_HARDIRQ:
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, excl_bit + 1))
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, excl_bit, name))
LOCK_ENABLED_HARDIRQ, "hard"))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
/* /*
* just marked it hardirq-safe, check that this lock * just marked it hardirq-safe, check that this lock
* 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, excl_bit + 1, rname))
LOCK_ENABLED_HARDIRQ_READ, "hard-read"))
return 0; return 0;
#endif #endif
if (hardirq_verbose(hlock_class(this))) if (verbose(hlock_class(this)))
ret = 2; return 2;
break;
case LOCK_USED_IN_SOFTIRQ: return 1;
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQ)) }
return 0;
if (!valid_state(curr, this, new_bit, static int
LOCK_ENABLED_SOFTIRQ_READ)) mark_lock_irq_used_in_read(struct task_struct *curr, struct held_lock *this,
return 0; int new_bit, int excl_bit,
/* const char *name, const char *rname,
* just marked it softirq-safe, check that this lock int (*verbose)(struct lock_class *class))
* took no softirq-unsafe lock in the past: {
*/ if (!valid_state(curr, this, new_bit, excl_bit))
if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQ, "soft"))
return 0;
#if STRICT_READ_CHECKS
/*
* just marked it softirq-safe, check that this lock
* took no softirq-unsafe-read lock in the past:
*/
if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQ_READ, "soft-read"))
return 0;
#endif
if (softirq_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_USED_IN_RECLAIM_FS:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_RECLAIM_FS))
return 0;
if (!valid_state(curr, this, new_bit,
LOCK_ENABLED_RECLAIM_FS_READ))
return 0;
/*
* just marked it reclaim-fs-safe, check that this lock
* took no reclaim-fs-unsafe lock in the past:
*/
if (!check_usage_forwards(curr, this,
LOCK_ENABLED_RECLAIM_FS, "reclaim-fs"))
return 0;
#if STRICT_READ_CHECKS
/*
* just marked it reclaim-fs-safe, check that this lock
* took no reclaim-fs-unsafe-read lock in the past:
*/
if (!check_usage_forwards(curr, this,
LOCK_ENABLED_RECLAIM_FS_READ, "reclaim-fs-read"))
return 0;
#endif
if (reclaim_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_USED_IN_HARDIRQ_READ:
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, excl_bit, name))
LOCK_ENABLED_HARDIRQ, "hard"))
return 0;
if (hardirq_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_USED_IN_SOFTIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQ))
return 0;
/*
* just marked it softirq-read-safe, check that this lock
* took no softirq-unsafe lock in the past:
*/
if (!check_usage_forwards(curr, this,
LOCK_ENABLED_SOFTIRQ, "soft"))
return 0;
if (softirq_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_USED_IN_RECLAIM_FS_READ:
if (!valid_state(curr, this, new_bit, LOCK_ENABLED_RECLAIM_FS))
return 0; return 0;
/* if (verbose(hlock_class(this)))
* just marked it reclaim-fs-read-safe, check that this lock return 2;
* took no reclaim-fs-unsafe lock in the past:
*/ return 1;
if (!check_usage_forwards(curr, this, }
LOCK_ENABLED_RECLAIM_FS, "reclaim-fs"))
return 0; static int
if (reclaim_verbose(hlock_class(this))) mark_lock_irq_enabled(struct task_struct *curr, struct held_lock *this,
ret = 2; int new_bit, int excl_bit,
break; const char *name, const char *rname,
case LOCK_ENABLED_HARDIRQ: int (*verbose)(struct lock_class *class))
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ)) {
if (!valid_state(curr, this, new_bit, excl_bit))
return 0; return 0;
if (!valid_state(curr, this, new_bit, if (!valid_state(curr, this, new_bit, excl_bit + 1))
LOCK_USED_IN_HARDIRQ_READ))
return 0; return 0;
/* /*
* just marked it hardirq-unsafe, check that no hardirq-safe * just marked it hardirq-unsafe, check that no hardirq-safe
* lock in the system ever took it in the past: * lock in the system ever took it in the past:
*/ */
if (!check_usage_backwards(curr, this, if (!check_usage_backwards(curr, this, excl_bit, name))
LOCK_USED_IN_HARDIRQ, "hard"))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
/* /*
...@@ -2140,110 +2073,99 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this, ...@@ -2140,110 +2073,99 @@ static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
* hardirq-safe-read lock in the system ever took * hardirq-safe-read lock in the system ever took
* it in the past: * it in the past:
*/ */
if (!check_usage_backwards(curr, this, if (!check_usage_backwards(curr, this, excl_bit + 1, rname))
LOCK_USED_IN_HARDIRQ_READ, "hard-read"))
return 0;
#endif
if (hardirq_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_ENABLED_SOFTIRQ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
return 0;
if (!valid_state(curr, this, new_bit,
LOCK_USED_IN_SOFTIRQ_READ))
return 0;
/*
* just marked it softirq-unsafe, check that no softirq-safe
* lock in the system ever took it in the past:
*/
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_SOFTIRQ, "soft"))
return 0;
#if STRICT_READ_CHECKS
/*
* just marked it softirq-unsafe, check that no
* softirq-safe-read lock in the system ever took
* it in the past:
*/
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_SOFTIRQ_READ, "soft-read"))
return 0; return 0;
#endif #endif
if (softirq_verbose(hlock_class(this))) if (verbose(hlock_class(this)))
ret = 2; return 2;
break;
case LOCK_ENABLED_RECLAIM_FS: return 1;
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_RECLAIM_FS)) }
return 0;
if (!valid_state(curr, this, new_bit, static int
LOCK_USED_IN_RECLAIM_FS_READ)) mark_lock_irq_enabled_read(struct task_struct *curr, struct held_lock *this,
return 0; int new_bit, int excl_bit,
/* const char *name, const char *rname,
* just marked it reclaim-fs-unsafe, check that no reclaim-fs-safe int (*verbose)(struct lock_class *class))
* lock in the system ever took it in the past: {
*/ if (!valid_state(curr, this, new_bit, excl_bit))
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_RECLAIM_FS, "reclaim-fs"))
return 0;
#if STRICT_READ_CHECKS
/*
* just marked it softirq-unsafe, check that no
* softirq-safe-read lock in the system ever took
* it in the past:
*/
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_RECLAIM_FS_READ, "reclaim-fs-read"))
return 0;
#endif
if (reclaim_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_ENABLED_HARDIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
return 0; return 0;
#if STRICT_READ_CHECKS #if STRICT_READ_CHECKS
/* /*
* just marked it hardirq-read-unsafe, check that no * just marked it hardirq-read-unsafe, check that no
* hardirq-safe lock in the system ever took it in the past: * hardirq-safe lock in the system ever took it in the past:
*/ */
if (!check_usage_backwards(curr, this, if (!check_usage_backwards(curr, this, excl_bit, name))
LOCK_USED_IN_HARDIRQ, "hard"))
return 0; return 0;
#endif #endif
if (hardirq_verbose(hlock_class(this))) if (verbose(hlock_class(this)))
ret = 2; return 2;
break;
return 1;
}
static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
enum lock_usage_bit new_bit)
{
int ret = 1;
switch(new_bit) {
case LOCK_USED_IN_HARDIRQ:
return mark_lock_irq_used_in(curr, this, new_bit,
LOCK_ENABLED_HARDIRQ,
"hard", "hard-read", hardirq_verbose);
case LOCK_USED_IN_SOFTIRQ:
return mark_lock_irq_used_in(curr, this, new_bit,
LOCK_ENABLED_SOFTIRQ,
"soft", "soft-read", softirq_verbose);
case LOCK_USED_IN_RECLAIM_FS:
return mark_lock_irq_used_in(curr, this, new_bit,
LOCK_ENABLED_RECLAIM_FS,
"reclaim-fs", "reclaim-fs-read",
reclaim_verbose);
case LOCK_USED_IN_HARDIRQ_READ:
return mark_lock_irq_used_in_read(curr, this, new_bit,
LOCK_ENABLED_HARDIRQ,
"hard", "hard-read", hardirq_verbose);
case LOCK_USED_IN_SOFTIRQ_READ:
return mark_lock_irq_used_in_read(curr, this, new_bit,
LOCK_ENABLED_SOFTIRQ,
"soft", "soft-read", softirq_verbose);
case LOCK_USED_IN_RECLAIM_FS_READ:
return mark_lock_irq_used_in_read(curr, this, new_bit,
LOCK_ENABLED_RECLAIM_FS,
"reclaim-fs", "reclaim-fs-read",
reclaim_verbose);
case LOCK_ENABLED_HARDIRQ:
return mark_lock_irq_enabled(curr, this, new_bit,
LOCK_USED_IN_HARDIRQ,
"hard", "hard-read", hardirq_verbose);
case LOCK_ENABLED_SOFTIRQ:
return mark_lock_irq_enabled(curr, this, new_bit,
LOCK_USED_IN_SOFTIRQ,
"soft", "soft-read", softirq_verbose);
case LOCK_ENABLED_RECLAIM_FS:
return mark_lock_irq_enabled(curr, this, new_bit,
LOCK_USED_IN_RECLAIM_FS,
"reclaim-fs", "reclaim-fs-read",
reclaim_verbose);
case LOCK_ENABLED_HARDIRQ_READ:
return mark_lock_irq_enabled_read(curr, this, new_bit,
LOCK_USED_IN_HARDIRQ,
"hard", "hard-read", hardirq_verbose);
case LOCK_ENABLED_SOFTIRQ_READ: case LOCK_ENABLED_SOFTIRQ_READ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ)) return mark_lock_irq_enabled_read(curr, this, new_bit,
return 0; LOCK_USED_IN_SOFTIRQ,
#if STRICT_READ_CHECKS "soft", "soft-read", softirq_verbose);
/*
* just marked it softirq-read-unsafe, check that no
* softirq-safe lock in the system ever took it in the past:
*/
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_SOFTIRQ, "soft"))
return 0;
#endif
if (softirq_verbose(hlock_class(this)))
ret = 2;
break;
case LOCK_ENABLED_RECLAIM_FS_READ: case LOCK_ENABLED_RECLAIM_FS_READ:
if (!valid_state(curr, this, new_bit, LOCK_USED_IN_RECLAIM_FS)) return mark_lock_irq_enabled_read(curr, this, new_bit,
return 0; LOCK_USED_IN_RECLAIM_FS,
#if STRICT_READ_CHECKS "reclaim-fs", "reclaim-fs-read",
/* reclaim_verbose);
* just marked it reclaim-fs-read-unsafe, check that no
* reclaim-fs-safe lock in the system ever took it in the past:
*/
if (!check_usage_backwards(curr, this,
LOCK_USED_IN_RECLAIM_FS, "reclaim-fs"))
return 0;
#endif
if (reclaim_verbose(hlock_class(this)))
ret = 2;
break;
default: default:
WARN_ON(1); WARN_ON(1);
break; break;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment