| Message ID | 20181224064025.GA9588@embeddedor.com (mailing list archive) |
|---|---|
| State | Mainlined, archived |
| Commit | 921e88a4f9649cbd44b4995ebe9a52b384e2fef4 |
| Headers | show |
| Series | clk: imx: imx7ulp: use struct_size() in kzalloc() | expand |
> -----Original Message----- > From: Gustavo A. R. Silva [mailto:gustavo@embeddedor.com] > Sent: Monday, December 24, 2018 2:40 PM > > One of the more common cases of allocation size calculations is finding the > size of a structure that has a zero-sized array at the end, along with memory > for some number of elements for that array. For example: > > struct foo { > int stuff; > void *entry[]; > }; > > instance = kzalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL); > > Instead of leaving these open-coded and prone to type mistakes, we can now > use the new struct_size() helper: > > instance = kzalloc(struct_size(instance, entry, count), GFP_KERNEL); > > This issue was detected with the help of Coccinelle. > > Signed-off-by: Gustavo A. R. Silva <gustavo@embeddedor.com> Reviewed-by: Dong Aisheng <aisheng.dong@nxp.com> Regards Dong Aisheng
Hi, Friendly ping: Who can take this? Thanks -- Gustavo On 12/24/18 12:40 AM, Gustavo A. R. Silva wrote: > One of the more common cases of allocation size calculations is finding > the size of a structure that has a zero-sized array at the end, along > with memory for some number of elements for that array. For example: > > struct foo { > int stuff; > void *entry[]; > }; > > instance = kzalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL); > > Instead of leaving these open-coded and prone to type mistakes, we can > now use the new struct_size() helper: > > instance = kzalloc(struct_size(instance, entry, count), GFP_KERNEL); > > This issue was detected with the help of Coccinelle. > > Signed-off-by: Gustavo A. R. Silva <gustavo@embeddedor.com> > --- > drivers/clk/imx/clk-imx7ulp.c | 16 ++++++++-------- > 1 file changed, 8 insertions(+), 8 deletions(-) > > diff --git a/drivers/clk/imx/clk-imx7ulp.c b/drivers/clk/imx/clk-imx7ulp.c > index 4e18f629f823..ce306631e844 100644 > --- a/drivers/clk/imx/clk-imx7ulp.c > +++ b/drivers/clk/imx/clk-imx7ulp.c > @@ -48,8 +48,8 @@ static void __init imx7ulp_clk_scg1_init(struct device_node *np) > struct clk_hw **clks; > void __iomem *base; > > - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * > - IMX7ULP_CLK_SCG1_END, GFP_KERNEL); > + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_SCG1_END), > + GFP_KERNEL); > if (!clk_data) > return; > > @@ -136,8 +136,8 @@ static void __init imx7ulp_clk_pcc2_init(struct device_node *np) > struct clk_hw **clks; > void __iomem *base; > > - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * > - IMX7ULP_CLK_PCC2_END, GFP_KERNEL); > + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_PCC2_END), > + GFP_KERNEL); > if (!clk_data) > return; > > @@ -183,8 +183,8 @@ static void __init imx7ulp_clk_pcc3_init(struct device_node *np) > struct clk_hw **clks; > void __iomem *base; > > - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * > - IMX7ULP_CLK_PCC3_END, GFP_KERNEL); > + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_PCC3_END), > + GFP_KERNEL); > if (!clk_data) > return; > > @@ -228,8 +228,8 @@ static void __init imx7ulp_clk_smc1_init(struct device_node *np) > struct clk_hw **clks; > void __iomem *base; > > - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * > - IMX7ULP_CLK_SMC1_END, GFP_KERNEL); > + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_SMC1_END), > + GFP_KERNEL); > if (!clk_data) > return; > >
Quoting Gustavo A. R. Silva (2018-12-23 22:40:25) > One of the more common cases of allocation size calculations is finding > the size of a structure that has a zero-sized array at the end, along > with memory for some number of elements for that array. For example: > > struct foo { > int stuff; > void *entry[]; > }; > > instance = kzalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL); > > Instead of leaving these open-coded and prone to type mistakes, we can > now use the new struct_size() helper: > > instance = kzalloc(struct_size(instance, entry, count), GFP_KERNEL); > > This issue was detected with the help of Coccinelle. > > Signed-off-by: Gustavo A. R. Silva <gustavo@embeddedor.com> > --- Applied to clk-next
On 1/24/19 1:37 PM, Stephen Boyd wrote: > Quoting Gustavo A. R. Silva (2018-12-23 22:40:25) >> One of the more common cases of allocation size calculations is finding >> the size of a structure that has a zero-sized array at the end, along >> with memory for some number of elements for that array. For example: >> >> struct foo { >> int stuff; >> void *entry[]; >> }; >> >> instance = kzalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL); >> >> Instead of leaving these open-coded and prone to type mistakes, we can >> now use the new struct_size() helper: >> >> instance = kzalloc(struct_size(instance, entry, count), GFP_KERNEL); >> >> This issue was detected with the help of Coccinelle. >> >> Signed-off-by: Gustavo A. R. Silva <gustavo@embeddedor.com> >> --- > > Applied to clk-next > Thanks, Stephen. -- Gustavo
diff --git a/drivers/clk/imx/clk-imx7ulp.c b/drivers/clk/imx/clk-imx7ulp.c index 4e18f629f823..ce306631e844 100644 --- a/drivers/clk/imx/clk-imx7ulp.c +++ b/drivers/clk/imx/clk-imx7ulp.c @@ -48,8 +48,8 @@ static void __init imx7ulp_clk_scg1_init(struct device_node *np) struct clk_hw **clks; void __iomem *base; - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * - IMX7ULP_CLK_SCG1_END, GFP_KERNEL); + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_SCG1_END), + GFP_KERNEL); if (!clk_data) return; @@ -136,8 +136,8 @@ static void __init imx7ulp_clk_pcc2_init(struct device_node *np) struct clk_hw **clks; void __iomem *base; - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * - IMX7ULP_CLK_PCC2_END, GFP_KERNEL); + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_PCC2_END), + GFP_KERNEL); if (!clk_data) return; @@ -183,8 +183,8 @@ static void __init imx7ulp_clk_pcc3_init(struct device_node *np) struct clk_hw **clks; void __iomem *base; - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * - IMX7ULP_CLK_PCC3_END, GFP_KERNEL); + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_PCC3_END), + GFP_KERNEL); if (!clk_data) return; @@ -228,8 +228,8 @@ static void __init imx7ulp_clk_smc1_init(struct device_node *np) struct clk_hw **clks; void __iomem *base; - clk_data = kzalloc(sizeof(*clk_data) + sizeof(*clk_data->hws) * - IMX7ULP_CLK_SMC1_END, GFP_KERNEL); + clk_data = kzalloc(struct_size(clk_data, hws, IMX7ULP_CLK_SMC1_END), + GFP_KERNEL); if (!clk_data) return;
One of the more common cases of allocation size calculations is finding the size of a structure that has a zero-sized array at the end, along with memory for some number of elements for that array. For example: struct foo { int stuff; void *entry[]; }; instance = kzalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL); Instead of leaving these open-coded and prone to type mistakes, we can now use the new struct_size() helper: instance = kzalloc(struct_size(instance, entry, count), GFP_KERNEL); This issue was detected with the help of Coccinelle. Signed-off-by: Gustavo A. R. Silva <gustavo@embeddedor.com> --- drivers/clk/imx/clk-imx7ulp.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)