On Fri, Jun 28, 2019 at 05:15:15PM +0800, Yuyang Du wrote: > 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 so the types are stored there. > > 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 <duyuy...@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 eb26e93..fd619ac 100644 > --- a/include/linux/lockdep.h > +++ b/include/linux/lockdep.h > @@ -185,6 +185,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 > @@ -207,7 +209,17 @@ struct lock_list { > struct list_head chains; > struct lock_class *class[2]; > 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,
Bad names ;-) Maybe fw_dep_type and bw_dep_type? Which seems to be aligned with the naming schema other functions. Regards, Boqun > + distance : 32 - 2*LOCK_TYPE_BITS; > > /* > * The parent field is used to implement breadth-first search. > @@ -362,6 +374,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 3c97d71..1805017 100644 > --- a/kernel/locking/lockdep.c > +++ b/kernel/locking/lockdep.c > @@ -1307,9 +1307,17 @@ static struct lock_list *alloc_list_entry(void) > */ > static int add_lock_to_list(struct lock_class *lock1, struct lock_class > *lock2, > unsigned long ip, int distance, > - struct lock_trace *trace, struct lock_chain *chain) > + struct lock_trace *trace, 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: > @@ -1322,6 +1330,8 @@ static int add_lock_to_list(struct lock_class *lock1, > struct lock_class *lock2, > 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 > @@ -1465,6 +1475,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. > @@ -2503,7 +2523,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 >
signature.asc
Description: PGP signature