Commit 96ca1830 authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Ingo Molnar
Browse files

locking/lockdep: Move hlock_equal() to the respective #ifdeffery 



When hlock_equal() is unused, it prevents kernel builds with clang,
`make W=1` and CONFIG_WERROR=y, CONFIG_LOCKDEP=y and
CONFIG_LOCKDEP_SMALL=n:

  lockdep.c:2005:20: error: unused function 'hlock_equal' [-Werror,-Wunused-function]

Fix this by moving the function to the respective existing ifdeffery
for its the only user.

See also:

  6863f564 ("kbuild: allow Clang to find unused static inline functions for W=1 build")

Fixes: 68e30567 ("lockdep: Adjust check_redundant() for recursive read change")
Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
Cc: Bill Wendling <morbo@google.com>
Cc: Justin Stitt <justinstitt@google.com>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nick Desaulniers <nick.desaulniers+lkml@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Will Deacon <will@kernel.org>
Cc: llvm@lists.linux.dev
Link: https://lore.kernel.org/r/20250506042049.50060-2-boqun.feng@gmail.com
parent 92a09c47

kernel/locking/lockdep.c

+35 −35
Original line number Diff line number Diff line
@@ -1976,41 +1976,6 @@ print_circular_bug_header(struct lock_list *entry, unsigned int depth, 
	print_circular_bug_entry(entry, depth);

}



/*

 * We are about to add A -> B into the dependency graph, and in __bfs() a

 * strong dependency path A -> .. -> B is found: hlock_class equals

 * entry->class.

 *

 * If A -> .. -> B can replace A -> B in any __bfs() search (means the former

 * is _stronger_ than or equal to the latter), we consider A -> B as redundant.

 * For example if A -> .. -> B is -(EN)-> (i.e. A -(E*)-> .. -(*N)-> B), and A

 * -> B is -(ER)-> or -(EN)->, then we don't need to add A -> B into the

 * dependency graph, as any strong path ..-> A -> B ->.. we can get with

 * having dependency A -> B, we could already get a equivalent path ..-> A ->

 * .. -> B -> .. with A -> .. -> B. Therefore A -> B is redundant.

 *

 * We need to make sure both the start and the end of A -> .. -> B is not

 * weaker than A -> B. For the start part, please see the comment in

 * check_redundant(). For the end part, we need:

 *

 * Either

 *

 *     a) A -> B is -(*R)-> (everything is not weaker than that)

 *

 * or

 *

 *     b) A -> .. -> B is -(*N)-> (nothing is stronger than this)

 *

 */

static inline bool hlock_equal(struct lock_list *entry, void *data)

{

	struct held_lock *hlock = (struct held_lock *)data;



	return hlock_class(hlock) == entry->class && /* Found A -> .. -> B */

	       (hlock->read == 2 ||  /* A -> B is -(*R)-> */

		!entry->only_xr); /* A -> .. -> B is -(*N)-> */

}



/*

 * We are about to add B -> A into the dependency graph, and in __bfs() a

 * strong dependency path A -> .. -> B is found: hlock_class equals
@@ -2915,6 +2880,41 @@ static inline bool usage_skip(struct lock_list *entry, void *mask) 
#endif /* CONFIG_TRACE_IRQFLAGS */



#ifdef CONFIG_LOCKDEP_SMALL

/*

 * We are about to add A -> B into the dependency graph, and in __bfs() a

 * strong dependency path A -> .. -> B is found: hlock_class equals

 * entry->class.

 *

 * If A -> .. -> B can replace A -> B in any __bfs() search (means the former

 * is _stronger_ than or equal to the latter), we consider A -> B as redundant.

 * For example if A -> .. -> B is -(EN)-> (i.e. A -(E*)-> .. -(*N)-> B), and A

 * -> B is -(ER)-> or -(EN)->, then we don't need to add A -> B into the

 * dependency graph, as any strong path ..-> A -> B ->.. we can get with

 * having dependency A -> B, we could already get a equivalent path ..-> A ->

 * .. -> B -> .. with A -> .. -> B. Therefore A -> B is redundant.

 *

 * We need to make sure both the start and the end of A -> .. -> B is not

 * weaker than A -> B. For the start part, please see the comment in

 * check_redundant(). For the end part, we need:

 *

 * Either

 *

 *     a) A -> B is -(*R)-> (everything is not weaker than that)

 *

 * or

 *

 *     b) A -> .. -> B is -(*N)-> (nothing is stronger than this)

 *

 */

static inline bool hlock_equal(struct lock_list *entry, void *data)

{

	struct held_lock *hlock = (struct held_lock *)data;



	return hlock_class(hlock) == entry->class && /* Found A -> .. -> B */

	       (hlock->read == 2 ||  /* A -> B is -(*R)-> */

		!entry->only_xr); /* A -> .. -> B is -(*N)-> */

}



/*

 * Check that the dependency graph starting at <src> can lead to

 * <target> or not. If it can, <src> -> <target> dependency is already