clk: samsung: use kzalloc_flex
Subsystems (3)
v3 cover clk: samsung: use kzalloc_flex
Switch three structs to flexible array members to combine allocations.
v3: move rd_num
v2: fix compilation and reword descriptions
Rosen Penev (3):
clk: samsung: use kzalloc_flex
clk: samsung: cpu: use kzalloc_flex
clk: samsung: pll: use kzalloc_flex
drivers/clk/samsung/clk-cpu.c | 34 +++++++++------------ drivers/clk/samsung/clk-pll.c | 56 ++++++++++++++++------------------- drivers/clk/samsung/clk.c | 11 +++---- drivers/clk/samsung/clk.h | 4 +-- 4 files changed, 48 insertions(+), 57 deletions(-)
--
2.54.0
PATCH v3 1/3 clk: samsung: use kzalloc_flex
Simplify allocation by using kzalloc_flex with a flexible array member to combine allocations. samsung_clk_alloc_reg_dump is no longer needed for this struct but is needed elsewhere.
Add __counted_by for extra runtime analysis. Move counting variable assignment after kzalloc_flex which does the same with GCC 15 and above.
--- drivers/clk/samsung/clk.c | 11 ++++++----- drivers/clk/samsung/clk.h | 4 ++-- 2 files changed, 8 insertions(+), 7 deletions(-)
drivers/clk/samsung/clk.c +6 -5
@@ -430,21 +430,22 @@ void samsung_clk_extended_sleep_init(void __iomem *reg_base, unsigned long nr_rsuspend) {struct samsung_clock_reg_cache *reg_cache; +int i; - reg_cache = kzalloc_obj(struct samsung_clock_reg_cache); + reg_cache =kzalloc_flex (*reg_cache, rdump, nr_rdump);if (!reg_cache)panic ("could not allocate register reg_cache.\n" ); - reg_cache->rdump =samsung_clk_alloc_reg_dump (rdump, nr_rdump); -if (!reg_cache->rdump) -panic ("could not allocate register dump storage.\n" ); + reg_cache->rd_num = nr_rdump; + +for (i =0 ; i < nr_rdump; ++i) + reg_cache->rdump[i].offset = rdump[i];if (list_empty (&clock_reg_cache_list))register_syscore (&samsung_clk_syscore); reg_cache->reg_base = reg_base; reg_cache->sysreg = sysreg; - reg_cache->rd_num = nr_rdump; reg_cache->rsuspend = rsuspend; reg_cache->rsuspend_num = nr_rsuspend;list_add_tail (®_cache->node, &clock_reg_cache_list);
drivers/clk/samsung/clk.h +2 -2
@@ -324,10 +324,10 @@ struct samsung_clock_reg_cache {struct list_head node;void __iomem *reg_base;struct regmap *sysreg; -struct samsung_clk_reg_dump *rdump; -unsigned int rd_num;const struct samsung_clk_reg_dump *rsuspend;unsigned int rsuspend_num; +unsigned int rd_num; + struct samsung_clk_reg_dump rdump[] __counted_by(rd_num); };/**
Signature · 1 line
2.54.0
PATCH v3 2/3 clk: samsung: cpu: use kzalloc_flex
In reply to Rosen PenevUse a flexible array member to combine allocations.
As kmemdup_array is really kcalloc + memcpy and kzalloc_flex kzalloc + kcalloc, kzalloc and kcalloc combine leaving the memcpy.
Add __counted_by for extra runtime analysis. Remove fake const num_cfgs. It needs to be assigned for __counted_by to work.
--- drivers/clk/samsung/clk-cpu.c | 34 ++++++++++++++-------------------- 1 file changed, 14 insertions(+), 20 deletions(-)
drivers/clk/samsung/clk-cpu.c +14 -20
@@ -101,11 +101,11 @@ struct exynos_cpuclk {const struct clk_hw *alt_parent;void __iomem *base;spinlock_t *lock; -const struct exynos_cpuclk_cfg_data *cfg; -const unsigned long num_cfgs; +unsigned long num_cfgs;struct notifier_block clk_nb;unsigned long flags;const struct exynos_cpuclk_chip *chip; + struct exynos_cpuclk_cfg_data cfg[] __counted_by(num_cfgs); };/* ---- Common code --------------------------------------------------------- */
@@ -660,10 +660,6 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx,return -EINVAL ; } - cpuclk =kzalloc_obj (*cpuclk); -if (!cpuclk) -return -ENOMEM ; - parent_name =clk_hw_get_name (parent); init.name = clk_data->name;
@@ -672,6 +668,17 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx, init.num_parents =1 ; init.ops = &exynos_cpuclk_clk_ops; +/* Find count of configuration rates in cfg */ +for (num_cfgs =0 ; clk_data->cfg[num_cfgs].prate !=0 ; ) + num_cfgs++; + + cpuclk =kzalloc_flex (*cpuclk, cfg, num_cfgs); +if (!cpuclk) +return -ENOMEM ; + + cpuclk->num_cfgs = num_cfgs; + +memcpy (cpuclk->cfg, clk_data->cfg, num_cfgs *sizeof (*cpuclk->cfg)); cpuclk->alt_parent = alt_parent; cpuclk->hw.init = &init; cpuclk->base = ctx->reg_base + clk_data->offset;
@@ -687,29 +694,16 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx, goto free_cpuclk; } -/* Find count of configuration rates in cfg */ -for (num_cfgs =0 ; clk_data->cfg[num_cfgs].prate !=0 ; ) - num_cfgs++; - - cpuclk->cfg =kmemdup_array (clk_data->cfg, num_cfgs,sizeof (*cpuclk->cfg), -GFP_KERNEL ); -if (!cpuclk->cfg) { - ret = -ENOMEM ; - goto unregister_clk_nb; - } - ret =clk_hw_register (NULL , &cpuclk->hw);if (ret) {pr_err ("%s: could not register cpuclk %s\n" , __func__, clk_data->name); - goto free_cpuclk_data; + goto unregister_clk_nb; }samsung_clk_add_lookup (ctx, &cpuclk->hw, clk_data->id);return 0 ; -free_cpuclk_data: -kfree (cpuclk->cfg); unregister_clk_nb:clk_notifier_unregister (parent->clk, &cpuclk->clk_nb); free_cpuclk:
Signature · 1 line
2.54.0
PATCH v3 3/3 clk: samsung: pll: use kzalloc_flex
In reply to Rosen PenevSimplify allocation by using a flexible array member to combine allocations and remove a kfree.
Use __counted_by for extra runtime analysis.
Since rate_table is now a flexible array member, NULL checks don't work. So use the counting variable to check allocation.
--- drivers/clk/samsung/clk-pll.c | 56 ++++++++++++++++------------------- 1 file changed, 26 insertions(+), 30 deletions(-)
drivers/clk/samsung/clk-pll.c +26 -30
@@ -28,7 +28,7 @@ struct samsung_clk_pll {unsigned short lock_offs;enum samsung_pll_type type;unsigned int rate_count; -const struct samsung_pll_rate_table *rate_table; + struct samsung_pll_rate_table rate_table[] __counted_by(rate_count); };#define to_clk_pll (_hw) container_of(_hw, struct samsung_clk_pll, hw)
@@ -1593,35 +1593,32 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, {struct samsung_clk_pll *pll;struct clk_init_data init; -int ret, len; +unsigned int len =0 ; +int ret; - pll =kzalloc_obj (*pll); +if (pll_clk->rate_table) { +/* find count of rates in rate_table */ +while (pll_clk->rate_table[len].rate !=0 ) + len++; + } + + pll =kzalloc_flex (*pll, rate_table, len);if (!pll) {pr_err ("%s: could not allocate pll clk %s\n" , __func__, pll_clk->name);return ; } + pll->rate_count = len; +if (len) +memcpy (pll->rate_table, pll_clk->rate_table, + len *sizeof (*pll->rate_table)); + init.name = pll_clk->name; init.flags = pll_clk->flags; init.parent_names = &pll_clk->parent_name; init.num_parents =1 ; -if (pll_clk->rate_table) { -/* find count of rates in rate_table */ -for (len =0 ; pll_clk->rate_table[len].rate !=0 ; ) - len++; - - pll->rate_count = len; - pll->rate_table =kmemdup_array (pll_clk->rate_table, - pll->rate_count, -sizeof (*pll->rate_table), -GFP_KERNEL ); -WARN (!pll->rate_table, -"%s: could not allocate rate table for %s\n" , - __func__, pll_clk->name); - } -switch (pll_clk->type) {case pll_2126: init.ops = &samsung_pll2126_clk_ops;
@@ -1640,7 +1637,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_a9fracm: pll->enable_offs =PLL35XX_ENABLE_SHIFT ; pll->lock_offs =PLL35XX_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll35xx_clk_min_ops;else init.ops = &samsung_pll35xx_clk_ops;
@@ -1659,7 +1656,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_0732x: pll->enable_offs =PLL0822X_ENABLE_SHIFT ; pll->lock_offs =PLL0822X_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll0822x_clk_min_ops;else init.ops = &samsung_pll0822x_clk_ops;
@@ -1669,7 +1666,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,break ;case pll_4502:case pll_4508: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll45xx_clk_min_ops;else init.ops = &samsung_pll45xx_clk_ops;
@@ -1679,7 +1676,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_2650: pll->enable_offs =PLL36XX_ENABLE_SHIFT ; pll->lock_offs =PLL36XX_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll36xx_clk_min_ops;else init.ops = &samsung_pll36xx_clk_ops;
@@ -1687,7 +1684,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_0831x: pll->enable_offs =PLL0831X_ENABLE_SHIFT ; pll->lock_offs =PLL0831X_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll0831x_clk_min_ops;else init.ops = &samsung_pll0831x_clk_ops;
@@ -1703,7 +1700,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_4650:case pll_4650c:case pll_1460x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll46xx_clk_min_ops;else init.ops = &samsung_pll46xx_clk_ops;
@@ -1712,19 +1709,19 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, init.ops = &samsung_pll2550x_clk_ops;break ;case pll_2550xx: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2550xx_clk_min_ops;else init.ops = &samsung_pll2550xx_clk_ops;break ;case pll_2650x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2650x_clk_min_ops;else init.ops = &samsung_pll2650x_clk_ops;break ;case pll_2650xx: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2650xx_clk_min_ops;else init.ops = &samsung_pll2650xx_clk_ops;
@@ -1734,7 +1731,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, init.ops = &samsung_pll531x_clk_ops;break ;case pll_1031x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll1031x_clk_min_ops;else init.ops = &samsung_pll1031x_clk_ops;
@@ -1742,7 +1739,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_a9fraco: pll->enable_offs =PLLA9FRACO_ENABLE_SHIFT ; pll->lock_offs =PLLA9FRACO_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_a9fraco_clk_min_ops;else init.ops = &samsung_a9fraco_clk_ops;
@@ -1761,7 +1758,6 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,if (ret) {pr_err ("%s: failed to register pll clock %s : %d\n" , __func__, pll_clk->name, ret); -kfree (pll->rate_table);kfree (pll);return ; }
Signature · 1 line
2.54.0
Quoted 11 lines · Rosen Penev
Switch three structs to flexible array members to combine allocations.
v3: move
rd_num
v2: fix compilation and reword descriptionsRosen Penev (3):
clk: samsung: usekzalloc_flex
clk: samsung: cpu: usekzalloc_flex
clk: samsung: pll: usekzalloc_flex[...]
Applied, thanks!
[1/3] clk: samsung: use kzalloc_flex
https://git.kernel.org/krzk/linux/c/7b2a8eb5c7b5545793e18036c8b66106f2d9fbb8 [2/3] clk: samsung: cpu: use kzalloc_flex https://git.kernel.org/krzk/linux/c/421ccea8f872c0e7cf6fd754a4a3bef4f45cf2dc [3/3] clk: samsung: pll: use kzalloc_flex https://git.kernel.org/krzk/linux/c/6d32ae6403694035896cbf0436088fca4c6a35f1
Best regards,
Signature · 1 line
Krzysztof Kozlowski <[email protected]>