next/master bisection: baseline.login on rk3328-rock64

Mark Brown broonie at kernel.org
Mon Oct 10 05:17:15 PDT 2022


On Fri, Oct 07, 2022 at 02:10:11PM -0700, KernelCI bot wrote:

The KernelCI bisection bot found a boot problem on today's -next 
on rk3328-rock64 with a defconfig plus debug fragments triggered by
cb1b1dd96241f ("clk: Set req_rate on reparenting").  The log doesn't
show any obvious warnings but simply stalls out after:

[  258.676722][    T1] pps_core: LinuxPPS API ver. 1 registered
[  258.684929][    T1] pps_core: Software ver. 5.3.6 - Copyright 2005-2007 Rodolfo Giometti <giometti at linux.it>
[  258.788655][    T1] PTP clock support registered
[  259.246358][    T1] EDAC MC: Ver: 3.0.0

It seems like the performance of the system has been dramatically
reduced, current mainline boots with the same kernel config show we're
reaching that point after only 5s:

[    5.577047][    T1] PTP clock support registered
[    5.585556][    T1] EDAC MC: Ver: 3.0.0

and getting to a prompt after a bit over a minute which is much more
viable.  There do seem to be a kasan issues in mainline in some
combination of the clock and ASoC code though, log at:

   https://storage.kernelci.org/mainline/master/v6.0-9423-g493ffd6605b2d/arm64/defconfig%2Bdebug/gcc-10/lab-baylibre/baseline-rk3328-rock64.txt

The full config is:

   https://storage.kernelci.org/next/master/next-20221005/arm64/defconfig+debug/gcc-10/config/kernel.config

The debug fragment is:

   https://storage.kernelci.org/next/master/next-20221005/arm64/defconfig+debug/gcc-10/config/kernelci.config

I've left the full bot report, including links to the full logs and
other information plus a tag for the bot below:

> * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
> * This automated bisection report was sent to you on the basis  *
> * that you may be involved with the breaking commit it has      *
> * found.  No manual investigation has been done to verify it,   *
> * and the root cause of the problem may be somewhere else.      *
> *                                                               *
> * If you do send a fix, please include this trailer:            *
> *   Reported-by: "kernelci.org bot" <bot at kernelci.org>          *
> *                                                               *
> * Hope this helps!                                              *
> * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
> 
> next/master bisection: baseline.login on rk3328-rock64
> 
> Summary:
>   Start:      67ae4f7434cee Add linux-next specific files for 20221005
>   Plain log:  https://storage.kernelci.org/next/master/next-20221005/arm64/defconfig+debug/gcc-10/lab-baylibre/baseline-rk3328-rock64.txt
>   HTML log:   https://storage.kernelci.org/next/master/next-20221005/arm64/defconfig+debug/gcc-10/lab-baylibre/baseline-rk3328-rock64.html
>   Result:     cb1b1dd96241f clk: Set req_rate on reparenting
> 
> Checks:
>   revert:     PASS
>   verify:     PASS
> 
> Parameters:
>   Tree:       next
>   URL:        https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git
>   Branch:     master
>   Target:     rk3328-rock64
>   CPU arch:   arm64
>   Lab:        lab-baylibre
>   Compiler:   gcc-10
>   Config:     defconfig+debug
>   Test case:  baseline.login
> 
> Breaking commit found:
> 
> -------------------------------------------------------------------------------
> commit cb1b1dd96241f37ea41d241946d5153c48141cd5
> Author: Maxime Ripard <maxime at cerno.tech>
> Date:   Tue Aug 16 13:25:18 2022 +0200
> 
>     clk: Set req_rate on reparenting
>     
>     If a non-rate clock started by default with a parent that never
>     registered, core->req_rate will be 0. The expectation is that whenever
>     the parent will be registered, req_rate will be updated with the new
>     value that has just been computed.
>     
>     However, if that clock is a mux, clk_set_parent() can also make that
>     clock no longer orphan. In this case however, we never update req_rate.
>     
>     The natural solution to this would be to update core->rate and
>     core->req_rate in clk_reparent() by calling clk_recalc().
>     
>     However, this doesn't work in all cases. Indeed, clk_recalc() is called
>     by __clk_set_parent_before(), __clk_set_parent() and
>     clk_core_reparent(). Both __clk_set_parent_before() and __clk_set_parent
>     will call clk_recalc() with the enable_lock taken through a call to
>     clk_enable_lock(), the underlying locking primitive being a spinlock.
>     
>     clk_recalc() calls the backing driver .recalc_rate hook, and that
>     implementation might sleep if the underlying device uses a bus with
>     accesses that might sleep, such as i2c.
>     
>     In such a situation, we would end up sleeping while holding a spinlock,
>     and thus in an atomic section.
>     
>     In order to work around this, we can move the core->rate and
>     core->req_rate update to the clk_recalc() calling sites, after the
>     enable_lock has been released if it was taken.
>     
>     The only situation that could still be problematic is the
>     clk_core_reparent() -> clk_reparent() case that doesn't have any
>     locking. clk_core_reparent() is itself called by clk_hw_reparent(),
>     which is then called by 4 drivers:
>     
>       * clk-stm32mp1.c, stm32/clk-stm32-core.c and tegra/clk-tegra210-emc.c
>         use it in their set_parent implementation. The set_parent hook is
>         only called by __clk_set_parent() and clk_change_rate(), both of
>         them calling it without the enable_lock taken.
>     
>       * clk/tegra/clk-tegra124-emc.c calls it as part of its set_rate
>         implementation. set_rate is only called by clk_change_rate(), again
>         without the enable_lock taken.
>     
>     In both cases we can't end up in a situation where the clk_hw_reparent()
>     caller would hold a spinlock, so it seems like this is a good
>     workaround.
>     
>     Let's also add some unit tests to make sure we cover the original bug.
>     
>     Tested-by: Alexander Stein <alexander.stein at ew.tq-group.com> # imx8mp
>     Tested-by: Marek Szyprowski <m.szyprowski at samsung.com> # exynos4210, meson g12b
>     Signed-off-by: Maxime Ripard <maxime at cerno.tech>
>     Link: https://lore.kernel.org/r/20220816112530.1837489-14-maxime@cerno.tech
>     Tested-by: Linux Kernel Functional Testing <lkft at linaro.org>
>     Tested-by: Naresh Kamboju <naresh.kamboju at linaro.org>
>     Signed-off-by: Stephen Boyd <sboyd at kernel.org>
> 
> diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
> index 53b28e63deae3..91bb1ea0e147b 100644
> --- a/drivers/clk/clk.c
> +++ b/drivers/clk/clk.c
> @@ -1765,6 +1765,23 @@ static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
>  		clk_core_update_orphan_status(child, is_orphan);
>  }
>  
> +/*
> + * Update the orphan rate and req_rate of @core and all its children.
> + */
> +static void clk_core_update_orphan_child_rates(struct clk_core *core)
> +{
> +	struct clk_core *child;
> +	unsigned long parent_rate = 0;
> +
> +	if (core->parent)
> +		parent_rate = core->parent->rate;
> +
> +	core->rate = core->req_rate = clk_recalc(core, parent_rate);
> +
> +	hlist_for_each_entry(child, &core->children, child_node)
> +		clk_core_update_orphan_child_rates(child);
> +}
> +
>  static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
>  {
>  	bool was_orphan = core->orphan;
> @@ -1834,6 +1851,8 @@ static struct clk_core *__clk_set_parent_before(struct clk_core *core,
>  	clk_reparent(core, parent);
>  	clk_enable_unlock(flags);
>  
> +	clk_core_update_orphan_child_rates(core);
> +
>  	return old_parent;
>  }
>  
> @@ -1878,6 +1897,8 @@ static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
>  		flags = clk_enable_lock();
>  		clk_reparent(core, old_parent);
>  		clk_enable_unlock(flags);
> +
> +		clk_core_update_orphan_child_rates(core);
>  		__clk_set_parent_after(core, old_parent, parent);
>  
>  		return ret;
> @@ -2506,6 +2527,7 @@ static void clk_core_reparent(struct clk_core *core,
>  				  struct clk_core *new_parent)
>  {
>  	clk_reparent(core, new_parent);
> +	clk_core_update_orphan_child_rates(core);
>  	__clk_recalc_accuracies(core);
>  	__clk_recalc_rates(core, POST_RATE_CHANGE);
>  }
> diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c
> index d3e121f21ae21..d1b1372f7aaa9 100644
> --- a/drivers/clk/clk_test.c
> +++ b/drivers/clk/clk_test.c
> @@ -594,6 +594,41 @@ clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
>  	clk_put(clk);
>  }
>  
> +/*
> + * Test that, for a mux that started orphan but got switched to a valid
> + * parent, calling clk_drop_range() on the mux won't affect the parent
> + * rate.
> + */
> +static void
> +clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
> +{
> +	struct clk_multiple_parent_ctx *ctx = test->priv;
> +	struct clk_hw *hw = &ctx->hw;
> +	struct clk *clk = clk_hw_get_clk(hw, NULL);
> +	struct clk *parent;
> +	unsigned long parent_rate, new_parent_rate;
> +	int ret;
> +
> +	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
> +
> +	parent_rate = clk_get_rate(parent);
> +	KUNIT_ASSERT_GT(test, parent_rate, 0);
> +
> +	ret = clk_set_parent(clk, parent);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	ret = clk_drop_range(clk);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	new_parent_rate = clk_get_rate(clk);
> +	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
> +	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
> +
> +	clk_put(parent);
> +	clk_put(clk);
> +}
> +
>  /*
>   * Test that, for a mux that started orphan but got switched to a valid
>   * parent, the rate of the mux and its new parent are consistent.
> @@ -625,6 +660,39 @@ clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit
>  	clk_put(clk);
>  }
>  
> +/*
> + * Test that, for a mux that started orphan but got switched to a valid
> + * parent, calling clk_put() on the mux won't affect the parent rate.
> + */
> +static void
> +clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
> +{
> +	struct clk_multiple_parent_ctx *ctx = test->priv;
> +	struct clk *clk, *parent;
> +	unsigned long parent_rate, new_parent_rate;
> +	int ret;
> +
> +	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
> +
> +	clk = clk_hw_get_clk(&ctx->hw, NULL);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
> +
> +	parent_rate = clk_get_rate(parent);
> +	KUNIT_ASSERT_GT(test, parent_rate, 0);
> +
> +	ret = clk_set_parent(clk, parent);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	clk_put(clk);
> +
> +	new_parent_rate = clk_get_rate(parent);
> +	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
> +	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
> +
> +	clk_put(parent);
> +}
> +
>  /*
>   * Test that, for a mux that started orphan but got switched to a valid
>   * parent, calling clk_set_rate_range() will affect the parent state if
> @@ -658,6 +726,43 @@ clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(st
>  	clk_put(clk);
>  }
>  
> +/*
> + * Test that, for a mux that started orphan but got switched to a valid
> + * parent, calling clk_set_rate_range() won't affect the parent state if
> + * its rate is within range.
> + */
> +static void
> +clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
> +{
> +	struct clk_multiple_parent_ctx *ctx = test->priv;
> +	struct clk_hw *hw = &ctx->hw;
> +	struct clk *clk = clk_hw_get_clk(hw, NULL);
> +	struct clk *parent;
> +	unsigned long parent_rate, new_parent_rate;
> +	int ret;
> +
> +	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
> +
> +	parent_rate = clk_get_rate(parent);
> +	KUNIT_ASSERT_GT(test, parent_rate, 0);
> +
> +	ret = clk_set_parent(clk, parent);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	ret = clk_set_rate_range(clk,
> +				 DUMMY_CLOCK_INIT_RATE - 1000,
> +				 DUMMY_CLOCK_INIT_RATE + 1000);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	new_parent_rate = clk_get_rate(parent);
> +	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
> +	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
> +
> +	clk_put(parent);
> +	clk_put(clk);
> +}
> +
>  /*
>   * Test that, for a mux whose current parent hasn't been registered yet,
>   * calling clk_set_rate_range() will succeed, and will be taken into
> @@ -724,8 +829,11 @@ clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(st
>  static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
> +	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
> +	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
> +	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
>  	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
>  	{}
> @@ -1021,6 +1129,136 @@ static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
>  	.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
>  };
>  
> +struct clk_single_parent_two_lvl_ctx {
> +	struct clk_dummy_context parent_parent_ctx;
> +	struct clk_dummy_context parent_ctx;
> +	struct clk_hw hw;
> +};
> +
> +static int
> +clk_orphan_two_level_root_last_test_init(struct kunit *test)
> +{
> +	struct clk_single_parent_two_lvl_ctx *ctx;
> +	int ret;
> +
> +	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
> +	if (!ctx)
> +		return -ENOMEM;
> +	test->priv = ctx;
> +
> +	ctx->parent_ctx.hw.init =
> +		CLK_HW_INIT("intermediate-parent",
> +			    "root-parent",
> +			    &clk_dummy_single_parent_ops,
> +			    CLK_SET_RATE_PARENT);
> +	ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
> +	if (ret)
> +		return ret;
> +
> +	ctx->hw.init =
> +		CLK_HW_INIT("test-clk", "intermediate-parent",
> +			    &clk_dummy_single_parent_ops,
> +			    CLK_SET_RATE_PARENT);
> +	ret = clk_hw_register(NULL, &ctx->hw);
> +	if (ret)
> +		return ret;
> +
> +	ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
> +	ctx->parent_parent_ctx.hw.init =
> +		CLK_HW_INIT_NO_PARENT("root-parent",
> +				      &clk_dummy_rate_ops,
> +				      0);
> +	ret = clk_hw_register(NULL, &ctx->parent_parent_ctx.hw);
> +	if (ret)
> +		return ret;
> +
> +	return 0;
> +}
> +
> +static void
> +clk_orphan_two_level_root_last_test_exit(struct kunit *test)
> +{
> +	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
> +
> +	clk_hw_unregister(&ctx->hw);
> +	clk_hw_unregister(&ctx->parent_ctx.hw);
> +	clk_hw_unregister(&ctx->parent_parent_ctx.hw);
> +}
> +
> +/*
> + * Test that, for a clock whose parent used to be orphan, clk_get_rate()
> + * will return the proper rate.
> + */
> +static void
> +clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
> +{
> +	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
> +	struct clk_hw *hw = &ctx->hw;
> +	struct clk *clk = clk_hw_get_clk(hw, NULL);
> +	unsigned long rate;
> +
> +	rate = clk_get_rate(clk);
> +	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
> +
> +	clk_put(clk);
> +}
> +
> +/*
> + * Test that, for a clock whose parent used to be orphan,
> + * clk_set_rate_range() won't affect its rate if it is already within
> + * range.
> + *
> + * See (for Exynos 4210):
> + * https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
> + */
> +static void
> +clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
> +{
> +	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
> +	struct clk_hw *hw = &ctx->hw;
> +	struct clk *clk = clk_hw_get_clk(hw, NULL);
> +	unsigned long rate;
> +	int ret;
> +
> +	ret = clk_set_rate_range(clk,
> +				 DUMMY_CLOCK_INIT_RATE - 1000,
> +				 DUMMY_CLOCK_INIT_RATE + 1000);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +
> +	rate = clk_get_rate(clk);
> +	KUNIT_ASSERT_GT(test, rate, 0);
> +	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
> +
> +	clk_put(clk);
> +}
> +
> +static struct kunit_case
> +clk_orphan_two_level_root_last_test_cases[] = {
> +	KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
> +	KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
> +	{}
> +};
> +
> +/*
> + * Test suite for a basic, transparent, clock with a parent that is also
> + * such a clock. The parent's parent is registered last, while the
> + * parent and its child are registered in that order. The intermediate
> + * and leaf clocks will thus be orphan when registered, but the leaf
> + * clock itself will always have its parent and will never be
> + * reparented. Indeed, it's only orphan because its parent is.
> + *
> + * These tests exercise the behaviour of the consumer API when dealing
> + * with an orphan clock, and how we deal with the transition to a valid
> + * parent.
> + */
> +static struct kunit_suite
> +clk_orphan_two_level_root_last_test_suite = {
> +	.name = "clk-orphan-two-level-root-last-test",
> +	.init = clk_orphan_two_level_root_last_test_init,
> +	.exit = clk_orphan_two_level_root_last_test_exit,
> +	.test_cases = clk_orphan_two_level_root_last_test_cases,
> +};
> +
>  /*
>   * Test that clk_set_rate_range won't return an error for a valid range
>   * and that it will make sure the rate of the clock is within the
> @@ -1729,6 +1967,7 @@ kunit_test_suites(
>  	&clk_multiple_parents_mux_test_suite,
>  	&clk_orphan_transparent_multiple_parent_mux_test_suite,
>  	&clk_orphan_transparent_single_parent_test_suite,
> +	&clk_orphan_two_level_root_last_test_suite,
>  	&clk_range_test_suite,
>  	&clk_range_maximize_test_suite,
>  	&clk_range_minimize_test_suite,
> -------------------------------------------------------------------------------
> 
> 
> Git bisection log:
> 
> -------------------------------------------------------------------------------
> git bisect start
> # good: [40a5af128af54dc0fbd06e11ef2d8a693e25d33f] Merge tag 'samsung-dt-dt64-6.1-2' of https://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux into arm/dt
> git bisect good 40a5af128af54dc0fbd06e11ef2d8a693e25d33f
> # bad: [67ae4f7434cee86ee318d46fb10b8a9840ad2e81] Add linux-next specific files for 20221005
> git bisect bad 67ae4f7434cee86ee318d46fb10b8a9840ad2e81
> # bad: [7755a2e51417434920d2727d1e8a13b6b7bc2a7b] Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
> git bisect bad 7755a2e51417434920d2727d1e8a13b6b7bc2a7b
> # good: [d4e9325a5c3e933944240648fb59b32cc8354536] Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux.git
> git bisect good d4e9325a5c3e933944240648fb59b32cc8354536
> # good: [62c07983bef9d3e78e71189441e1a470f0d1e653] once: add DO_ONCE_SLOW() for sleepable contexts
> git bisect good 62c07983bef9d3e78e71189441e1a470f0d1e653
> # bad: [15be0f33185304d3031c6226fe999be86aaeb0d4] Merge branch '9p-next' of git://github.com/martinetd/linux
> git bisect bad 15be0f33185304d3031c6226fe999be86aaeb0d4
> # bad: [fb41178108eaf0ad17a9d76dc2be4cc46c57b47c] Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git
> git bisect bad fb41178108eaf0ad17a9d76dc2be4cc46c57b47c
> # bad: [0e343aed45e3f4f893ac2766331ca7961c164ec8] Merge branch 'clk-next' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git
> git bisect bad 0e343aed45e3f4f893ac2766331ca7961c164ec8
> # good: [26bebbfed5bd06fd7202fd1befa6c2c935a593e8] Merge branches 'clk-rockchip', 'clk-renesas', 'clk-microchip', 'clk-allwinner' and 'clk-imx' into clk-next
> git bisect good 26bebbfed5bd06fd7202fd1befa6c2c935a593e8
> # good: [f9efefdba95a5110a1346bb03acdd8ff3cdf557f] Merge branches 'clk-baikal', 'clk-broadcom', 'clk-vc5' and 'clk-versaclock' into clk-next
> git bisect good f9efefdba95a5110a1346bb03acdd8ff3cdf557f
> # good: [3b989d7c1cfc79eb79676cd5440d0fbf98d42148] Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux.git
> git bisect good 3b989d7c1cfc79eb79676cd5440d0fbf98d42148
> # bad: [718af795d3fd786928506cd5251597fbe29c7fda] clk: Change clk_core_init_rate_req prototype
> git bisect bad 718af795d3fd786928506cd5251597fbe29c7fda
> # good: [7d79c26b60e623a9a089d771f81c5997bda577cd] clk: tests: Add reference to the orphan mux bug report
> git bisect good 7d79c26b60e623a9a089d771f81c5997bda577cd
> # good: [74933ef22c1c3d3d1456c2f949f1910ce2aab1f1] clk: tests: Add tests for mux with multiple parents
> git bisect good 74933ef22c1c3d3d1456c2f949f1910ce2aab1f1
> # good: [3afb07231d603d51dca6a5d5e16d9d8f422f9b5f] clk: Take into account uncached clocks in clk_set_rate_range()
> git bisect good 3afb07231d603d51dca6a5d5e16d9d8f422f9b5f
> # bad: [cb1b1dd96241f37ea41d241946d5153c48141cd5] clk: Set req_rate on reparenting
> git bisect bad cb1b1dd96241f37ea41d241946d5153c48141cd5
> # first bad commit: [cb1b1dd96241f37ea41d241946d5153c48141cd5] clk: Set req_rate on reparenting
> -------------------------------------------------------------------------------
> 
> 
> -=-=-=-=-=-=-=-=-=-=-=-
> Groups.io Links: You receive all messages sent to this group.
> View/Reply Online (#32442): https://groups.io/g/kernelci-results/message/32442
> Mute This Topic: https://groups.io/mt/94189147/1131744
> Group Owner: kernelci-results+owner at groups.io
> Unsubscribe: https://groups.io/g/kernelci-results/unsub [broonie at kernel.org]
> -=-=-=-=-=-=-=-=-=-=-=-
> 
> 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 488 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-rockchip/attachments/20221010/555ce1b0/attachment-0001.sig>


More information about the Linux-rockchip mailing list