Messages in this thread | | | From | "Vaittinen, Matti" <> | Subject | Re: [PATCH/RFC] clk: gate: Add some kunit test suites | Date | Tue, 14 Apr 2020 11:46:08 +0000 |
| |
Hello Stephen & All,
Prologue:
I have been traumatized in the past - by unit tests :) Thus I am always a bit jumpy when I see people adding UTs. I always see the inertia UTs add to development - when people change anything they must also change impacted UTs - and every unnecessary UT case is actually burden. I was once buried under such burden.. Back at those times I quite often found myself wondering why I spend two days fixing UT cases after I did a necessary code change which took maybe 10 minutes. Please see my comments knowing this history and do your decisions based on less biased - brighter understanding :]
On Tue, 2020-04-07 at 20:56 -0700, Stephen Boyd wrote: > Test various parts of the clk gate implementation with the kunit > testing > framework. > > Cc: Brendan Higgins <brendanhiggins@google.com> > Cc: <kunit-dev@googlegroups.com> > Signed-off-by: Stephen Boyd <sboyd@kernel.org> > --- > > This patch is on top of this series[1] that allows the clk > framework to be selected by Kconfig language. > > [1] > https://lore.kernel.org/r/20200405025123.154688-1-sboyd@kernel.org > > drivers/clk/Kconfig | 8 + > drivers/clk/Makefile | 1 + > drivers/clk/clk-gate-test.c | 481 > ++++++++++++++++++++++++++++++++++++ > 3 files changed, 490 insertions(+) > create mode 100644 drivers/clk/clk-gate-test.c > > diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig > index 6ea0631e3956..66193673bcdf 100644 > --- a/drivers/clk/Kconfig > +++ b/drivers/clk/Kconfig > @@ -377,4 +377,12 @@ source "drivers/clk/ti/Kconfig" > source "drivers/clk/uniphier/Kconfig" > source "drivers/clk/zynqmp/Kconfig" > > +# Kunit test cases > +config CLK_GATE_TEST > + tristate "Basic gate type Kunit test" > + depends on KUNIT > + default KUNIT > + help > + Kunit test for the basic clk gate type. > + > endif > diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile > index f4169cc2fd31..0785092880fd 100644 > --- a/drivers/clk/Makefile > +++ b/drivers/clk/Makefile > @@ -7,6 +7,7 @@ obj-$(CONFIG_COMMON_CLK) += clk-divider.o > obj-$(CONFIG_COMMON_CLK) += clk-fixed-factor.o > obj-$(CONFIG_COMMON_CLK) += clk-fixed-rate.o > obj-$(CONFIG_COMMON_CLK) += clk-gate.o > +obj-$(CONFIG_CLK_GATE_TEST) += clk-gate-test.o > obj-$(CONFIG_COMMON_CLK) += clk-multiplier.o > obj-$(CONFIG_COMMON_CLK) += clk-mux.o > obj-$(CONFIG_COMMON_CLK) += clk-composite.o > diff --git a/drivers/clk/clk-gate-test.c b/drivers/clk/clk-gate- > test.c > new file mode 100644 > index 000000000000..b1d6c21e9698 > --- /dev/null > +++ b/drivers/clk/clk-gate-test.c > @@ -0,0 +1,481 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * KUnit test for clk gate basic type > + */ > +#include <linux/clk.h> > +#include <linux/clk-provider.h> > +#include <linux/platform_device.h> > + > +#include <kunit/test.h> > + > +static void clk_gate_register_test_dev(struct kunit *test) > +{ > + struct clk_hw *ret; > + struct platform_device *pdev; > + > + pdev = platform_device_register_simple("test_gate_device", -1, > NULL, 0); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev); > + > + ret = clk_hw_register_gate(&pdev->dev, "test_gate", NULL, 0, > NULL, > + 0, 0, NULL); > + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ret); > + KUNIT_EXPECT_STREQ(test, "test_gate", clk_hw_get_name(ret)); > + KUNIT_EXPECT_EQ(test, 0UL, clk_hw_get_flags(ret)); > + > + clk_hw_unregister_gate(ret); > + platform_device_put(pdev); > +} > + > +static void clk_gate_register_test_parent_names(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *ret; > + > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 1000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + > + ret = clk_hw_register_gate(NULL, "test_gate", "test_parent", 0, > NULL, > + 0, 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret); > + KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret)); > + > + clk_hw_unregister_gate(ret); > + clk_hw_unregister_fixed_rate(parent); > +} > + > +static void clk_gate_register_test_parent_data(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *ret; > + struct clk_parent_data pdata = { }; > + > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 1000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + pdata.hw = parent; > + > + ret = clk_hw_register_gate_parent_data(NULL, "test_gate", > &pdata, 0, > + NULL, 0, 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret); > + KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret)); > + > + clk_hw_unregister_gate(ret); > + clk_hw_unregister_fixed_rate(parent); > +} > + > +static void clk_gate_register_test_parent_data_legacy(struct kunit > *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *ret; > + struct clk_parent_data pdata = { }; > + > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 1000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + pdata.name = "test_parent"; > + > + ret = clk_hw_register_gate_parent_data(NULL, "test_gate", > &pdata, 0, > + NULL, 0, 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret); > + KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret)); > + > + clk_hw_unregister_gate(ret); > + clk_hw_unregister_fixed_rate(parent); > +} > + > +static void clk_gate_register_test_parent_hw(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *ret; > + > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 1000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + > + ret = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, > 0, NULL, > + 0, 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret); > + KUNIT_EXPECT_PTR_EQ(test, parent, clk_hw_get_parent(ret)); > + > + clk_hw_unregister_gate(ret); > + clk_hw_unregister_fixed_rate(parent); > +} > + > +static void clk_gate_register_test_hiword_invalid(struct kunit > *test) > +{ > + struct clk_hw *ret; > + > + ret = clk_hw_register_gate(NULL, "test_gate", NULL, 0, NULL, > + 20, CLK_GATE_HIWORD_MASK, NULL); > + > + KUNIT_EXPECT_TRUE(test, IS_ERR(ret)); > +}
Do we really need all these registration tests? I guess most of the code path would be tested by just one of these - how much value we add by adding rest of the registration cases? (just wondering)
> + > +static struct kunit_case clk_gate_register_test_cases[] = { > + KUNIT_CASE(clk_gate_register_test_dev), > + KUNIT_CASE(clk_gate_register_test_parent_names), > + KUNIT_CASE(clk_gate_register_test_parent_data), > + KUNIT_CASE(clk_gate_register_test_parent_data_legacy), > + KUNIT_CASE(clk_gate_register_test_parent_hw), > + KUNIT_CASE(clk_gate_register_test_hiword_invalid), > + {} > +}; > + > +static struct kunit_suite clk_gate_register_test_suite = { > + .name = "clk-gate-register-test", > + .test_cases = clk_gate_register_test_cases, > +}; > + > +struct clk_gate_test_context { > + void __iomem *fake_mem; > + struct clk_hw *hw; > + struct clk_hw *parent; > + u32 fake_reg; /* Keep at end, KASAN can detect out of bounds */ > +}; > + > +static struct clk_gate_test_context *clk_gate_test_alloc_ctx(struct > kunit *test) > +{ > + struct clk_gate_test_context *ctx; > + > + test->priv = ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); > + ctx->fake_mem = (void __force __iomem *)&ctx->fake_reg; > + > + return ctx; > +} > + > +static void clk_gate_test_parent_rate(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + unsigned long prate = clk_hw_get_rate(parent); > + unsigned long rate = clk_hw_get_rate(hw); > + > + KUNIT_EXPECT_EQ(test, prate, rate); > +} > + > +static void clk_gate_test_enable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = BIT(5); > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent)); > +}
Is this really necessary? Wouldn't most of this be tested by clk_gate_test_disable()?
> + > +static void clk_gate_test_disable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = BIT(5); > + u32 disable_val = 0; > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg); > + > + clk_disable_unprepare(clk); > + KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent)); > +} > + > +static struct kunit_case clk_gate_test_cases[] = { > + KUNIT_CASE(clk_gate_test_parent_rate), > + KUNIT_CASE(clk_gate_test_enable), > + KUNIT_CASE(clk_gate_test_disable), > + {} > +}; > + > +static int clk_gate_test_init(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 2000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + > + hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, > 0, > + ctx->fake_mem, 5, 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + > + ctx->hw = hw; > + ctx->parent = parent; > + > + return 0; > +} > + > +static void clk_gate_test_exit(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + > + clk_hw_unregister_gate(ctx->hw); > + clk_hw_unregister_fixed_rate(ctx->parent); > + kfree(ctx); > +}
Aren't these init and exit actually covering some of the things tested in clk_gate_register_test_cases? Perhaps we could reduce some tests or use some test functions as init/exit?
> + > +static struct kunit_suite clk_gate_test_suite = { > + .name = "clk-gate-test", > + .init = clk_gate_test_init, > + .exit = clk_gate_test_exit, > + .test_cases = clk_gate_test_cases, > +}; > + > +static void clk_gate_test_invert_enable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = 0; > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent)); > +}
Is this really adding value after clk_gate_test_invert_disable() has passed?
+ > +static void clk_gate_test_invert_disable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = 0; > + u32 disable_val = BIT(15); > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg); > + > + clk_disable_unprepare(clk); > + KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent)); > +} > + > +static struct kunit_case clk_gate_test_invert_cases[] = { > + KUNIT_CASE(clk_gate_test_invert_enable), > + KUNIT_CASE(clk_gate_test_invert_disable), > + {} > +}; > + > +static int clk_gate_test_invert_init(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 2000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + > + ctx->fake_reg = BIT(15); /* Default to off */ > + hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, > 0, > + ctx->fake_mem, 15, > + CLK_GATE_SET_TO_DISABLE, > NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + > + ctx->hw = hw; > + ctx->parent = parent; > + > + return 0; > +}
Aren't these init and exit actually covering some of the things tested in clk_gate_register_test_cases? Perhaps we could reduce some tests or use some test functions as init/exit?
I stopped reviewing here - I think you know what I was up-to and you are the best experts to evaluate whether there is something to squash/drop also in the rest of the tests :)
Epilogue:
In general, I would be very careful when adding UT-code and I would try to minimize the required test changes when for example one of the clk APIs require a change. (I know, the test changes are least thing to worry if these APIs need change - but effort is still cumulative and if we can avoid some - we should).
I don't mean to be disrespectful. I know my place in the food-chain :p Besides, I have seen the great work Stephen has been doing with clk - and I believe he knows what he is doing. But sometimes little poking can invoke new thoughts :grin: You can ignore my comments if they make no sense to you.
Best Regards --Matti >
> + > +static struct kunit_suite clk_gate_test_invert_suite = { > + .name = "clk-gate-invert-test", > + .init = clk_gate_test_invert_init, > + .exit = clk_gate_test_exit, > + .test_cases = clk_gate_test_invert_cases, > +}; > + > +static void clk_gate_test_hiword_enable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = BIT(9) | BIT(9 + 16); > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + KUNIT_EXPECT_EQ(test, enable_val, ctx->fake_reg); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_TRUE(test, clk_hw_is_prepared(parent)); > +} > + > +static void clk_gate_test_hiword_disable(struct kunit *test) > +{ > + struct clk_gate_test_context *ctx = test->priv; > + struct clk_hw *parent = ctx->parent; > + struct clk_hw *hw = ctx->hw; > + struct clk *clk = hw->clk; > + int ret; > + u32 enable_val = BIT(9) | BIT(9 + 16); > + u32 disable_val = BIT(9 + 16); > + > + ret = clk_prepare_enable(clk); > + KUNIT_ASSERT_EQ(test, ret, 0); > + KUNIT_ASSERT_EQ(test, enable_val, ctx->fake_reg); > + > + clk_disable_unprepare(clk); > + KUNIT_EXPECT_EQ(test, disable_val, ctx->fake_reg); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(hw)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_enabled(parent)); > + KUNIT_EXPECT_FALSE(test, clk_hw_is_prepared(parent)); > +} > + > +static struct kunit_case clk_gate_test_hiword_cases[] = { > + KUNIT_CASE(clk_gate_test_hiword_enable), > + KUNIT_CASE(clk_gate_test_hiword_disable), > + {} > +}; > + > +static int clk_gate_test_hiword_init(struct kunit *test) > +{ > + struct clk_hw *parent; > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + parent = clk_hw_register_fixed_rate(NULL, "test_parent", NULL, > 0, > + 2000000); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent); > + > + hw = clk_hw_register_gate_parent_hw(NULL, "test_gate", parent, > 0, > + ctx->fake_mem, 9, > + CLK_GATE_HIWORD_MASK, > NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + > + ctx->hw = hw; > + ctx->parent = parent; > + > + return 0; > +} > + > +static struct kunit_suite clk_gate_test_hiword_suite = { > + .name = "clk-gate-hiword-test", > + .init = clk_gate_test_hiword_init, > + .exit = clk_gate_test_exit, > + .test_cases = clk_gate_test_hiword_cases, > +}; > + > +static void clk_gate_test_is_enabled(struct kunit *test) > +{ > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + ctx->fake_reg = BIT(7); > + hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx- > >fake_mem, 7, > + 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + KUNIT_ASSERT_TRUE(test, clk_hw_is_enabled(hw)); > + > + clk_hw_unregister_gate(hw); > + kfree(ctx); > +} > + > +static void clk_gate_test_is_disabled(struct kunit *test) > +{ > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + ctx->fake_reg = BIT(4); > + hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx- > >fake_mem, 7, > + 0, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + KUNIT_ASSERT_FALSE(test, clk_hw_is_enabled(hw)); > + > + clk_hw_unregister_gate(hw); > + kfree(ctx); > +} > + > +static void clk_gate_test_is_enabled_inverted(struct kunit *test) > +{ > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + ctx->fake_reg = BIT(31); > + hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx- > >fake_mem, 2, > + CLK_GATE_SET_TO_DISABLE, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + KUNIT_ASSERT_TRUE(test, clk_hw_is_enabled(hw)); > + > + clk_hw_unregister_gate(hw); > + kfree(ctx); > +} > + > +static void clk_gate_test_is_disabled_inverted(struct kunit *test) > +{ > + struct clk_hw *hw; > + struct clk_gate_test_context *ctx; > + > + ctx = clk_gate_test_alloc_ctx(test); > + ctx->fake_reg = BIT(29); > + hw = clk_hw_register_gate(NULL, "test_gate", NULL, 0, ctx- > >fake_mem, 29, > + CLK_GATE_SET_TO_DISABLE, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw); > + KUNIT_ASSERT_FALSE(test, clk_hw_is_enabled(hw)); > + > + clk_hw_unregister_gate(hw); > + kfree(ctx); > +} > + > +static struct kunit_case clk_gate_test_enabled_cases[] = { > + KUNIT_CASE(clk_gate_test_is_enabled), > + KUNIT_CASE(clk_gate_test_is_disabled), > + KUNIT_CASE(clk_gate_test_is_enabled_inverted), > + KUNIT_CASE(clk_gate_test_is_disabled_inverted), > + {} > +}; > + > +static struct kunit_suite clk_gate_test_enabled_suite = { > + .name = "clk-gate-is_enabled-test", > + .test_cases = clk_gate_test_enabled_cases, > +}; > + > +kunit_test_suites( > + &clk_gate_register_test_suite, > + &clk_gate_test_suite, > + &clk_gate_test_invert_suite, > + &clk_gate_test_hiword_suite, > + &clk_gate_test_enabled_suite > +); > +MODULE_LICENSE("GPL v2"); > > base-commit: 7111951b8d4973bda27ff663f2cf18b663d15b48 > prerequisite-patch-id: e066e74d3e3848a69239083647017b9e4b2a7b87 > prerequisite-patch-id: ab1cc18da4a59b8973b4c8d85b6ea90eb6200df0 > prerequisite-patch-id: 5608c2059c4ad2d76aae62cd9897862a1f447cfb > prerequisite-patch-id: 3a2300fc681af075232bfe62dbd1eb81290ca5a1 > prerequisite-patch-id: 6268382cce3446e3eb3cec7fec86973ab3dc9e7c > prerequisite-patch-id: 57b540a6a65ffb9cc53bb4b9c3fd8c4f55a4ce05 > prerequisite-patch-id: 2ec56bc3f971534850ebe7253d5ae023dfc87410 > prerequisite-patch-id: 9500860f59b801c734ab22f18737ca0ceff8208c > prerequisite-patch-id: 09a4d90ae718ab61fc9423862b1c2044ea898e3e > -- > Sent by a computer, using git, on the internet >
| |