lkml.org 
[lkml]   [2019]   [Aug]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH v4 18/30] ocking/lockdep: Add read-write type for a lock dependency
Date
Direct dependencies need to keep track of their read-write lock types.
Two bit fields, which share the distance field, are added to lock_list
struct to store the types.

With a dependecy lock1 -> lock2, lock_type1 has the type for lock1 and
lock_type2 has the type for lock2, where the values are one of the
lock_type enums.

Signed-off-by: Yuyang Du <duyuyang@gmail.com>
---
include/linux/lockdep.h | 15 ++++++++++++++-
kernel/locking/lockdep.c | 25 +++++++++++++++++++++++--
2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 2335447..eab8a90 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -182,6 +182,8 @@ static inline void lockdep_copy_map(struct lockdep_map *to,
to->class_cache[i] = NULL;
}

+#define LOCK_TYPE_BITS 2
+
/*
* Every lock has a list of other locks that were taken after or before
* it as lock dependencies. These dependencies constitute a graph, which
@@ -204,7 +206,17 @@ struct lock_list {
struct list_head chains;
struct lock_class *class[2];
const struct lock_trace *trace;
- int distance;
+
+ /*
+ * The lock_type fields keep track of the lock type of this
+ * dependency.
+ *
+ * With L1 -> L2, lock_type1 stores the lock type of L1, and
+ * lock_type2 stores that of L2.
+ */
+ unsigned int lock_type1 : LOCK_TYPE_BITS,
+ lock_type2 : LOCK_TYPE_BITS,
+ distance : 32 - 2*LOCK_TYPE_BITS;

/*
* The parent field is used to implement breadth-first search.
@@ -359,6 +371,7 @@ enum lock_type {
LOCK_TYPE_WRITE = 0,
LOCK_TYPE_READ,
LOCK_TYPE_RECURSIVE,
+ NR_LOCK_TYPE,
};

/*
diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index bdc7e94..18303ff 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -1379,9 +1379,17 @@ static int add_lock_to_list(struct lock_class *lock1,
struct lock_class *lock2,
unsigned long ip, int distance,
const struct lock_trace *trace,
- struct lock_chain *chain)
+ struct lock_chain *chain,
+ int lock_type1, int lock_type2)
{
struct lock_list *entry;
+
+ /*
+ * The distance bit field in struct lock_list must be large
+ * enough to hold the maximum lock depth.
+ */
+ BUILD_BUG_ON((1 << (32 - 2*LOCK_TYPE_BITS)) < MAX_LOCK_DEPTH);
+
/*
* Lock not present yet - get a new dependency struct and
* add it to the list:
@@ -1394,6 +1402,8 @@ static int add_lock_to_list(struct lock_class *lock1,
entry->class[1] = lock2;
entry->distance = distance;
entry->trace = trace;
+ entry->lock_type1 = lock_type1;
+ entry->lock_type2 = lock_type2;

/*
* Both allocation and removal are done under the graph lock; but
@@ -1537,6 +1547,16 @@ static inline struct list_head *get_dep_list(struct lock_list *lock, int forward
return &class->dep_list[forward];
}

+static inline int get_lock_type1(struct lock_list *lock)
+{
+ return lock->lock_type1;
+}
+
+static inline int get_lock_type2(struct lock_list *lock)
+{
+ return lock->lock_type2;
+}
+
/*
* Forward- or backward-dependency search, used for both circular dependency
* checking and hardirq-unsafe/softirq-unsafe checking.
@@ -2580,7 +2600,8 @@ static inline void inc_chains(void)
* dependency list of the previous lock <prev>:
*/
ret = add_lock_to_list(hlock_class(prev), hlock_class(next),
- next->acquire_ip, distance, *trace, chain);
+ next->acquire_ip, distance, *trace, chain,
+ prev->read, next->read);
if (!ret)
return 0;

--
1.8.3.1
\
 
 \ /
  Last update: 2019-08-29 10:33    [W:0.114 / U:2.324 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site