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 <[email protected]> --- 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
