From: Peter Zijlstra <a.p.zijlstra@chello.nl>
To: Ingo Molnar <mingo@elte.hu>, Nick Piggin <npiggin@suse.de>
Cc: linux-kernel@vger.kernel.org, Peter Zijlstra <a.p.zijlstra@chello.nl>
Subject: [RFC PATCH 10/19] lockdep: split up mark_lock_irq()
Date: Thu, 22 Jan 2009 18:37:11 +0100 [thread overview]
Message-ID: <20090122174053.021445554@chello.nl> (raw)
In-Reply-To: 20090122173701.674448070@chello.nl
[-- Attachment #1: lockdep-mark_irq.patch --]
[-- Type: text/plain, Size: 12237 bytes --]
split mark_lock_irq() into 4 simple helper functions
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
---
kernel/lockdep.c | 372 +++++++++++++++++++++----------------------------------
1 file changed, 147 insertions(+), 225 deletions(-)
Index: linux-2.6/kernel/lockdep.c
===================================================================
--- linux-2.6.orig/kernel/lockdep.c
+++ linux-2.6/kernel/lockdep.c
@@ -2001,6 +2001,109 @@ static int reclaim_verbose(struct lock_c
#define STRICT_READ_CHECKS 1
+static int
+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))
+{
+ if (!valid_state(curr, this, new_bit, excl_bit))
+ return 0;
+ if (!valid_state(curr, this, new_bit, excl_bit + 1))
+ return 0;
+ /*
+ * just marked it hardirq-safe, check that this lock
+ * took no hardirq-unsafe lock in the past:
+ */
+ if (!check_usage_forwards(curr, this, excl_bit, name))
+ return 0;
+#if STRICT_READ_CHECKS
+ /*
+ * just marked it hardirq-safe, check that this lock
+ * took no hardirq-unsafe-read lock in the past:
+ */
+ if (!check_usage_forwards(curr, this, excl_bit + 1, rname))
+ return 0;
+#endif
+ if (verbose(hlock_class(this)))
+ return 2;
+
+ return 1;
+}
+
+static int
+mark_lock_irq_used_in_read(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))
+{
+ if (!valid_state(curr, this, new_bit, excl_bit))
+ return 0;
+ /*
+ * just marked it hardirq-read-safe, check that this lock
+ * took no hardirq-unsafe lock in the past:
+ */
+ if (!check_usage_forwards(curr, this, excl_bit, name))
+ return 0;
+ if (verbose(hlock_class(this)))
+ return 2;
+
+ return 1;
+}
+
+static int
+mark_lock_irq_enabled(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))
+{
+ if (!valid_state(curr, this, new_bit, excl_bit))
+ return 0;
+ if (!valid_state(curr, this, new_bit, excl_bit + 1))
+ return 0;
+ /*
+ * just marked it hardirq-unsafe, check that no hardirq-safe
+ * lock in the system ever took it in the past:
+ */
+ if (!check_usage_backwards(curr, this, excl_bit, name))
+ return 0;
+#if STRICT_READ_CHECKS
+ /*
+ * just marked it hardirq-unsafe, check that no
+ * hardirq-safe-read lock in the system ever took
+ * it in the past:
+ */
+ if (!check_usage_backwards(curr, this, excl_bit + 1, rname))
+ return 0;
+#endif
+ if (verbose(hlock_class(this)))
+ return 2;
+
+ return 1;
+}
+
+static int
+mark_lock_irq_enabled_read(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))
+{
+ if (!valid_state(curr, this, new_bit, excl_bit))
+ return 0;
+#if STRICT_READ_CHECKS
+ /*
+ * just marked it hardirq-read-unsafe, check that no
+ * hardirq-safe lock in the system ever took it in the past:
+ */
+ if (!check_usage_backwards(curr, this, excl_bit, name))
+ return 0;
+#endif
+ if (verbose(hlock_class(this)))
+ return 2;
+
+ return 1;
+}
+
static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
enum lock_usage_bit new_bit)
{
@@ -2008,242 +2111,61 @@ static int mark_lock_irq(struct task_str
switch(new_bit) {
case LOCK_USED_IN_HARDIRQ:
- if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQ))
- return 0;
- if (!valid_state(curr, this, new_bit,
- LOCK_ENABLED_HARDIRQ_READ))
- return 0;
- /*
- * just marked it hardirq-safe, check that this lock
- * took no hardirq-unsafe lock in the past:
- */
- if (!check_usage_forwards(curr, this,
- LOCK_ENABLED_HARDIRQ, "hard"))
- return 0;
-#if STRICT_READ_CHECKS
- /*
- * just marked it hardirq-safe, check that this lock
- * took no hardirq-unsafe-read lock in the past:
- */
- if (!check_usage_forwards(curr, this,
- LOCK_ENABLED_HARDIRQ_READ, "hard-read"))
- return 0;
-#endif
- if (hardirq_verbose(hlock_class(this)))
- ret = 2;
- break;
+ return mark_lock_irq_used_in(curr, this, new_bit,
+ LOCK_ENABLED_HARDIRQ,
+ "hard", "hard-read", hardirq_verbose);
case LOCK_USED_IN_SOFTIRQ:
- if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQ))
- return 0;
- if (!valid_state(curr, this, new_bit,
- LOCK_ENABLED_SOFTIRQ_READ))
- return 0;
- /*
- * just marked it softirq-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 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;
+ return mark_lock_irq_used_in(curr, this, new_bit,
+ LOCK_ENABLED_SOFTIRQ,
+ "soft", "soft-read", softirq_verbose);
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;
+ 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:
- if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQ))
- return 0;
- /*
- * just marked it hardirq-read-safe, check that this lock
- * took no hardirq-unsafe lock in the past:
- */
- if (!check_usage_forwards(curr, this,
- LOCK_ENABLED_HARDIRQ, "hard"))
- return 0;
- if (hardirq_verbose(hlock_class(this)))
- ret = 2;
- break;
+ 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:
- 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;
+ 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:
- if (!valid_state(curr, this, new_bit, LOCK_ENABLED_RECLAIM_FS))
- return 0;
- /*
- * just marked it reclaim-fs-read-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 (reclaim_verbose(hlock_class(this)))
- ret = 2;
- break;
+ 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:
- if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
- return 0;
- if (!valid_state(curr, this, new_bit,
- LOCK_USED_IN_HARDIRQ_READ))
- return 0;
- /*
- * just marked it hardirq-unsafe, check that no hardirq-safe
- * lock in the system ever took it in the past:
- */
- if (!check_usage_backwards(curr, this,
- LOCK_USED_IN_HARDIRQ, "hard"))
- return 0;
-#if STRICT_READ_CHECKS
- /*
- * just marked it hardirq-unsafe, check that no
- * hardirq-safe-read lock in the system ever took
- * it in the past:
- */
- if (!check_usage_backwards(curr, this,
- LOCK_USED_IN_HARDIRQ_READ, "hard-read"))
- return 0;
-#endif
- if (hardirq_verbose(hlock_class(this)))
- ret = 2;
- break;
+ return mark_lock_irq_enabled(curr, this, new_bit,
+ LOCK_USED_IN_HARDIRQ,
+ "hard", "hard-read", hardirq_verbose);
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;
-#endif
- if (softirq_verbose(hlock_class(this)))
- ret = 2;
- break;
+ return mark_lock_irq_enabled(curr, this, new_bit,
+ LOCK_USED_IN_SOFTIRQ,
+ "soft", "soft-read", softirq_verbose);
case LOCK_ENABLED_RECLAIM_FS:
- if (!valid_state(curr, this, new_bit, LOCK_USED_IN_RECLAIM_FS))
- return 0;
- if (!valid_state(curr, this, new_bit,
- LOCK_USED_IN_RECLAIM_FS_READ))
- return 0;
- /*
- * just marked it reclaim-fs-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;
-#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;
+ 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:
- if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
- return 0;
-#if STRICT_READ_CHECKS
- /*
- * just marked it hardirq-read-unsafe, check that no
- * hardirq-safe lock in the system ever took it in the past:
- */
- if (!check_usage_backwards(curr, this,
- LOCK_USED_IN_HARDIRQ, "hard"))
- return 0;
-#endif
- if (hardirq_verbose(hlock_class(this)))
- ret = 2;
- break;
+ return mark_lock_irq_enabled_read(curr, this, new_bit,
+ LOCK_USED_IN_HARDIRQ,
+ "hard", "hard-read", hardirq_verbose);
case LOCK_ENABLED_SOFTIRQ_READ:
- if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
- return 0;
-#if STRICT_READ_CHECKS
- /*
- * 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;
+ return mark_lock_irq_enabled_read(curr, this, new_bit,
+ LOCK_USED_IN_SOFTIRQ,
+ "soft", "soft-read", softirq_verbose);
case LOCK_ENABLED_RECLAIM_FS_READ:
- if (!valid_state(curr, this, new_bit, LOCK_USED_IN_RECLAIM_FS))
- return 0;
-#if STRICT_READ_CHECKS
- /*
- * 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;
+ return mark_lock_irq_enabled_read(curr, this, new_bit,
+ LOCK_USED_IN_RECLAIM_FS,
+ "reclaim-fs", "reclaim-fs-read",
+ reclaim_verbose);
+
default:
WARN_ON(1);
break;
--
next prev parent reply other threads:[~2009-01-22 17:51 UTC|newest]
Thread overview: 25+ messages / expand[flat|nested] mbox.gz Atom feed top
2009-01-22 17:37 [RFC PATCH 00/19] lockdep series Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 01/19] lockdep: annotate reclaim context (__GFP_NOFS) Peter Zijlstra
2009-01-22 19:40 ` Peter Zijlstra
2009-01-22 20:29 ` Peter Zijlstra
2009-01-23 7:33 ` Nick Piggin
2009-01-23 8:00 ` Peter Zijlstra
2009-01-23 15:08 ` Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 02/19] lockdep: sanitize bit names Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 03/19] lockdep: sanitize reclaim " Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 04/19] lockdep: lockdep_states.h Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 05/19] lockdep: simplify mark_held_locks Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 06/19] lockdep: simplify mark_lock() Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 07/19] lockdep: move state bit definitions around Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 08/19] lockdep: generate the state bit definitions Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 09/19] lockdep: generate usage strings Peter Zijlstra
2009-01-22 17:37 ` Peter Zijlstra [this message]
2009-01-22 17:37 ` [RFC PATCH 11/19] lockdep: simplify the mark_lock_irq() helpers Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 12/19] lockdep: further simplify " Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 13/19] simplify mark_lock_irq() helpers #3 Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 14/19] lockdep: merge the _READ mark_lock_irq() helpers Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 15/19] lockdep: merge the !_READ " Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 16/19] lockdep: fully reduce mark_lock_irq() Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 17/19] lockdep: simplify get_user_chars() Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 18/19] lockdep: get_user_chars() redo Peter Zijlstra
2009-01-22 17:37 ` [RFC PATCH 19/19] lockdep: simplify check_prev_add_irq() Peter Zijlstra
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20090122174053.021445554@chello.nl \
--to=a.p.zijlstra@chello.nl \
--cc=linux-kernel@vger.kernel.org \
--cc=mingo@elte.hu \
--cc=npiggin@suse.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.