EDAC: Remove edac_align_ptr()
Borislav Petkov
maintainercover EDAC: Remove edac_align_ptr()
From: Borislav Petkov <[email protected]>
Hi,
this edac_align_ptr() thing was part of the original EDAC upstreaming effort in 2006:
da9bb1d27b21 ("[PATCH] EDAC: core EDAC support code")
Comment above the usage says:
"Everything is kmalloc'ed as one big chunk - more efficient."
but I don't think that "efficiency" is measurable anymore. Then, 15+ years ago probably.
So get rid of it in favor of simple kzalloc() allocations for the couple of structures needed at each call site.
It boots fine here with amd64_edac but I'd greatly appreciate testing with other EDAC drivers.
Thx!
Borislav Petkov (5):
EDAC/mc: Get rid of silly one-shot struct allocation in
edac_mc_alloc()
EDAC/pci: Get rid of the silly one-shot memory allocation in
edac_pci_alloc_ctl_info()
EDAC/device: Get rid of the silly one-shot memory allocation in
edac_device_alloc_ctl_info()
EDAC/device: Sanitize edac_device_alloc_ctl_info() definition EDAC/mc: Get rid of edac_align_ptr()
drivers/edac/edac_device.c | 135 +++++++++++++------------------ drivers/edac/edac_device.h | 14 ++++ drivers/edac/edac_device_sysfs.c | 5 +- drivers/edac/edac_mc.c | 96 +++------------------- drivers/edac/edac_module.h | 2 - drivers/edac/edac_pci.c | 25 +++--- 6 files changed, 95 insertions(+), 182 deletions(-)
Signature · 1 line
2.29.2
Borislav Petkov
maintainerPATCH 1/5 EDAC/mc: Get rid of silly one-shot struct allocation in edac_mc_alloc()
From: Borislav Petkov <[email protected]>
This has probably meant something at some point but there's no need for it anymore - the struct mem_ctl_info allocation can happen with normal, boring k*alloc() calls like everyone else does it.
No functional changes.
--- drivers/edac/edac_mc.c | 41 +++++++++++++---------------------------- 1 file changed, 13 insertions(+), 28 deletions(-)
drivers/edac/edac_mc.c +13 -28
@@ -257,6 +257,8 @@ static void mci_release(struct device *dev) }kfree (mci->csrows); } +kfree (mci->pvt_info); +kfree (mci->layers);kfree (mci); }
@@ -392,9 +394,8 @@ struct mem_ctl_info *edac_mc_alloc(unsigned int mc_num, {struct mem_ctl_info *mci;struct edac_mc_layer *layer; -unsigned int idx, size, tot_dimms =1 ; +unsigned int idx, tot_dimms =1 ;unsigned int tot_csrows =1 , tot_channels =1 ; -void *pvt, *ptr =NULL ;bool per_rank = false;if (WARN_ON (n_layers >EDAC_MAX_LAYERS || n_layers ==0 ))
@@ -416,41 +417,25 @@ struct mem_ctl_info *edac_mc_alloc(unsigned int mc_num, per_rank = true; } -/* Figure out the offsets of the various items from the start of an mc -* structure. We want the alignment of each item to be at least as -* stringent as what the compiler would provide if we could simply -* hardcode everything into a single struct. -*/ - mci =edac_align_ptr (&ptr,sizeof (*mci),1 ); - layer =edac_align_ptr (&ptr,sizeof (*layer), n_layers); - pvt =edac_align_ptr (&ptr, sz_pvt,1 ); - size = ((unsigned long )pvt) + sz_pvt; - -edac_dbg (1 ,"allocating %u bytes for mci data (%d %s, %d csrows/channels)\n" , - size, - tot_dimms, - per_rank ?"ranks" :"dimms" , - tot_csrows * tot_channels); - - mci =kzalloc (size,GFP_KERNEL ); -if (mci ==NULL ) + mci =kzalloc (sizeof (struct mem_ctl_info ),GFP_KERNEL ); +if (!mci)return NULL ; + mci->layers =kmalloc_array (n_layers,sizeof (struct edac_mc_layer ),GFP_KERNEL | __GFP_ZERO); +if (!mci->layers) + goto error; + + mci->pvt_info =kzalloc (sz_pvt,GFP_KERNEL ); +if (!mci->pvt_info) + goto error; + mci->dev.release = mci_release;device_initialize (&mci->dev); -/* Adjust pointers so they point within the memory we just allocated -* rather than an imaginary chunk of memory located at address 0. -*/ - layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long )layer)); - pvt = sz_pvt ? (((char *)mci) + ((unsigned long )pvt)) :NULL ; -/* setup index and various internal pointers */ mci->mc_idx = mc_num; mci->tot_dimms = tot_dimms; - mci->pvt_info = pvt; mci->n_layers = n_layers; - mci->layers = layer;memcpy (mci->layers, layers,sizeof (*layer) * n_layers); mci->nr_csrows = tot_csrows; mci->num_cschannel = tot_channels;
Signature · 1 line
2.29.2
Borislav Petkov
maintainerPATCH 2/5 EDAC/pci: Get rid of the silly one-shot memory allocation in edac_pci_alloc_ctl_info()
In reply to Borislav PetkovFrom: Borislav Petkov <[email protected]>
Use boring kzalloc() instead.
There should be no functional changes resulting from this.
--- drivers/edac/edac_pci.c | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-)
drivers/edac/edac_pci.c +12 -13
@@ -29,32 +29,31 @@ static LIST_HEAD(edac_pci_list);static atomic_t pci_indexes =ATOMIC_INIT (0 );struct edac_pci_ctl_info *edac_pci_alloc_ctl_info (unsigned int sz_pvt, -const char *edac_pci_name) +const char *edac_pci_name) {struct edac_pci_ctl_info *pci; -void *p =NULL , *pvt; -unsigned int size;edac_dbg (1 ,"\n" ); - pci =edac_align_ptr (&p,sizeof (*pci),1 ); - pvt =edac_align_ptr (&p,1 , sz_pvt); - size = ((unsigned long )pvt) + sz_pvt; - -/* Alloc the needed control struct memory */ - pci =kzalloc (size,GFP_KERNEL ); -if (pci ==NULL ) + pci =kzalloc (sizeof (struct edac_pci_ctl_info ),GFP_KERNEL ); +if (!pci)return NULL ; -/* Now much private space */ - pvt = sz_pvt ? ((char *)pci) + ((unsigned long )pvt) :NULL ; +if (sz_pvt) { + pci->pvt_info =kzalloc (sz_pvt,GFP_KERNEL ); +if (!pci->pvt_info) + goto free; + } - pci->pvt_info = pvt; pci->op_state =OP_ALLOC ;snprintf (pci->name,strlen (edac_pci_name) +1 ,"%s" , edac_pci_name);return pci; + +free: +kfree (pci); +return NULL ; }EXPORT_SYMBOL_GPL (edac_pci_alloc_ctl_info);
Signature · 1 line
2.29.2
Borislav Petkov
maintainerPATCH 3/5 EDAC/device: Get rid of the silly one-shot memory allocation in edac_device_alloc_ctl_info()
In reply to Borislav PetkovFrom: Borislav Petkov <[email protected]>
Use boring kzalloc() instead. Add pointers to the different allocated members in struct edac_device_ctl_info for easier freeing later.
One of the reasons, perhaps, why it was done this way is to be able to do a single kfree(ctl_info) without having to kfree() the other parts of the struct too but that is not nearly a sensible reason as to why there should be this obscure pointer alignment.
There should be no functional changes resulting from this.
--- drivers/edac/edac_device.c | 109 ++++++++++++------------------- drivers/edac/edac_device.h | 14 ++++ drivers/edac/edac_device_sysfs.c | 5 +- 3 files changed, 57 insertions(+), 71 deletions(-)
drivers/edac/edac_device.c +42 -67
@@ -59,87 +59,59 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info(struct edac_device_instance *dev_inst, *inst;struct edac_device_block *dev_blk, *blk_p, *blk;struct edac_dev_sysfs_block_attribute *dev_attrib, *attrib_p, *attrib; -unsigned total_size; -unsigned count;unsigned instance, block, attr; -void *pvt, *p; +void *pvt;int err;edac_dbg (4 ,"instances=%d blocks=%d\n" , nr_instances, nr_blocks); -/* Calculate the size of memory we need to allocate AND -* determine the offsets of the various item arrays -* (instance,block,attrib) from the start of an allocated structure. -* We want the alignment of each item (instance,block,attrib) -* to be at least as stringent as what the compiler would -* provide if we could simply hardcode everything into a single struct. -*/ - p =NULL ; - dev_ctl =edac_align_ptr (&p,sizeof (*dev_ctl),1 ); + dev_ctl =kzalloc (sizeof (struct edac_device_ctl_info ),GFP_KERNEL ); +if (!dev_ctl) +return NULL ; -/* Calc the 'end' offset past end of ONE ctl_info structure -* which will become the start of the 'instance' array -*/ - dev_inst =edac_align_ptr (&p,sizeof (*dev_inst), nr_instances); + dev_inst =kmalloc_array (nr_instances, +sizeof (struct edac_device_instance ), +GFP_KERNEL | __GFP_ZERO); +if (!dev_inst) + goto free; -/* Calc the 'end' offset past the instance array within the ctl_info -* which will become the start of the block array -*/ - count = nr_instances * nr_blocks; - dev_blk =edac_align_ptr (&p,sizeof (*dev_blk), count); + dev_ctl->instances = dev_inst; -/* Calc the 'end' offset past the dev_blk array -* which will become the start of the attrib array, if any. -*/ -/* calc how many nr_attrib we need */ -if (nr_attrib >0 ) - count *= nr_attrib; - dev_attrib =edac_align_ptr (&p,sizeof (*dev_attrib), count); + dev_blk =kmalloc_array (nr_instances * nr_blocks, +sizeof (struct edac_device_block ), +GFP_KERNEL | __GFP_ZERO); +if (!dev_blk) + goto free; -/* Calc the 'end' offset past the attributes array */ - pvt =edac_align_ptr (&p, sz_private,1 ); + dev_ctl->blocks = dev_blk; -/* 'pvt' now points to where the private data area is. -* At this point 'pvt' (like dev_inst,dev_blk and dev_attrib) -* is baselined at ZERO -*/ - total_size = ((unsigned long )pvt) + sz_private; +if (nr_attrib) { + dev_attrib =kmalloc_array (nr_attrib, +sizeof (struct edac_dev_sysfs_block_attribute ), +GFP_KERNEL | __GFP_ZERO); +if (!dev_attrib) + goto free; -/* Allocate the amount of memory for the set of control structures */ - dev_ctl =kzalloc (total_size,GFP_KERNEL ); -if (dev_ctl ==NULL ) -return NULL ; + dev_ctl->attribs = dev_attrib; + } -/* Adjust pointers so they point within the actual memory we -* just allocated rather than an imaginary chunk of memory -* located at address 0. -* 'dev_ctl' points to REAL memory, while the others are -* ZERO based and thus need to be adjusted to point within -* the allocated memory. -*/ - dev_inst = (struct edac_device_instance *) - (((char *)dev_ctl) + ((unsigned long )dev_inst)); - dev_blk = (struct edac_device_block *) - (((char *)dev_ctl) + ((unsigned long )dev_blk)); - dev_attrib = (struct edac_dev_sysfs_block_attribute *) - (((char *)dev_ctl) + ((unsigned long )dev_attrib)); - pvt = sz_private ? (((char *)dev_ctl) + ((unsigned long )pvt)) :NULL ; - -/* Begin storing the information into the control info structure */ - dev_ctl->dev_idx = device_index; - dev_ctl->nr_instances = nr_instances; - dev_ctl->instances = dev_inst; - dev_ctl->pvt_info = pvt; +if (sz_private) { + pvt =kzalloc (sz_private,GFP_KERNEL ); +if (!pvt) + goto free; + + dev_ctl->pvt_info = pvt; + } + + dev_ctl->dev_idx = device_index; + dev_ctl->nr_instances = nr_instances;/* Default logging of CEs and UEs */ dev_ctl->log_ce =1 ; dev_ctl->log_ue =1 ;/* Name of this edac device */ -snprintf (dev_ctl->name,sizeof (dev_ctl->name),"%s" ,edac_device_name); - -edac_dbg (4 ,"edac_dev=%p next after end=%p\n" , - dev_ctl, pvt + sz_private); +snprintf (dev_ctl->name,sizeof (dev_ctl->name),"%s" , edac_device_name);/* Initialize every Instance */ for (instance =0 ; instance < nr_instances; instance++) {
@@ -210,10 +182,8 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info(* Initialize the 'root' kobj for the edac_device controller */ err =edac_device_register_sysfs_main_kobj (dev_ctl); -if (err) { -kfree (dev_ctl); -return NULL ; - } +if (err) + goto free;/* at this point, the root kobj is valid, and in order to * 'free' the object, then the function:
@@ -223,6 +193,11 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info(*/ return dev_ctl; + +free: +__edac_device_free_ctl_info (dev_ctl); + +return NULL ; }EXPORT_SYMBOL_GPL (edac_device_alloc_ctl_info);
drivers/edac/edac_device.h +14 -0
@@ -216,6 +216,8 @@ struct edac_device_ctl_info {*/ u32 nr_instances;struct edac_device_instance *instances; +struct edac_device_block *blocks; +struct edac_dev_sysfs_block_attribute *attribs;/* Event counters for the this whole EDAC Device */ struct edac_device_counter counters;
@@ -348,4 +350,16 @@ edac_device_handle_ue(struct edac_device_ctl_info *edac_dev, int inst_nr,*/ extern int edac_device_alloc_index (void );extern const char *edac_layer_name[]; + +/* Free the actual struct */ +static inline void __edac_device_free_ctl_info (struct edac_device_ctl_info *ci) +{ +if (ci) { +kfree (ci->pvt_info); +kfree (ci->attribs); +kfree (ci->blocks); +kfree (ci->instances); +kfree (ci); + } +}#endif
drivers/edac/edac_device_sysfs.c +1 -4
@@ -207,10 +207,7 @@ static void edac_device_ctrl_master_release(struct kobject *kobj)/* decrement the EDAC CORE module ref count */ module_put (edac_dev->owner); -/* free the control struct containing the 'main' kobj -* passed in to this routine -*/ -kfree (edac_dev); +__edac_device_free_ctl_info (edac_dev); }/* ktype for the main (master) kobject */
Signature · 1 line
2.29.2
Borislav Petkov
maintainerPATCH 4/5 EDAC/device: Sanitize edac_device_alloc_ctl_info() definition
In reply to Borislav PetkovFrom: Borislav Petkov <[email protected]>
Shorten argument names, correct formatting, sort local vars in reverse x-mas tree order.
No functional changes.
--- drivers/edac/edac_device.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)
drivers/edac/edac_device.c +16 -16
@@ -47,18 +47,19 @@ static void edac_device_dump_device(struct edac_device_ctl_info *edac_dev) }#endif /* CONFIG_EDAC_DEBUG */ -struct edac_device_ctl_info *edac_device_alloc_ctl_info ( -unsigned sz_private, -char *edac_device_name,unsigned nr_instances, -char *edac_block_name,unsigned nr_blocks, -unsigned offset_value,/* zero, 1, or other based offset */ -struct edac_dev_sysfs_block_attribute *attrib_spec,unsigned nr_attrib, -int device_index) +/* +* @off_val: zero, 1, or other based offset +*/ +struct edac_device_ctl_info * +edac_device_alloc_ctl_info (unsigned pvt_sz,char *dev_name,unsigned nr_instances, +char *blk_name,unsigned nr_blocks,unsigned off_val, +struct edac_dev_sysfs_block_attribute *attrib_spec, +unsigned nr_attrib,int device_index) { -struct edac_device_ctl_info *dev_ctl; -struct edac_device_instance *dev_inst, *inst; -struct edac_device_block *dev_blk, *blk_p, *blk;struct edac_dev_sysfs_block_attribute *dev_attrib, *attrib_p, *attrib; +struct edac_device_block *dev_blk, *blk_p, *blk; +struct edac_device_instance *dev_inst, *inst; +struct edac_device_ctl_info *dev_ctl;unsigned instance, block, attr;void *pvt;int err;
@@ -95,8 +96,8 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info( dev_ctl->attribs = dev_attrib; } -if (sz_private) { - pvt =kzalloc (sz_private,GFP_KERNEL ); +if (pvt_sz) { + pvt =kzalloc (pvt_sz,GFP_KERNEL );if (!pvt) goto free;
@@ -111,7 +112,7 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info( dev_ctl->log_ue =1 ;/* Name of this edac device */ -snprintf (dev_ctl->name,sizeof (dev_ctl->name),"%s" , edac_device_name); +snprintf (dev_ctl->name,sizeof (dev_ctl->name),"%s" , dev_name);/* Initialize every Instance */ for (instance =0 ; instance < nr_instances; instance++) {
@@ -122,15 +123,14 @@ struct edac_device_ctl_info *edac_device_alloc_ctl_info( inst->blocks = blk_p;/* name of this instance */ -snprintf (inst->name,sizeof (inst->name), -"%s%u" , edac_device_name, instance); +snprintf (inst->name,sizeof (inst->name),"%s%u" , dev_name, instance);/* Initialize every block in each instance */ for (block =0 ; block < nr_blocks; block++) { blk = &blk_p[block]; blk->instance = inst;snprintf (blk->name,sizeof (blk->name), -"%s%d" , edac_block_name, block+offset_value); +"%s%d" , blk_name, block + off_val);edac_dbg (4 ,"instance=%d inst_p=%p block=#%d block_p=%p name='%s'\n" , instance, inst, block, blk, blk->name);
Signature · 1 line
2.29.2
Borislav Petkov
maintainerPATCH 5/5 EDAC/mc: Get rid of edac_align_ptr()
In reply to Borislav PetkovFrom: Borislav Petkov <[email protected]>
Get rid of it now that it is unused.
--- drivers/edac/edac_mc.c | 55 -------------------------------------- drivers/edac/edac_module.h | 2 -- 2 files changed, 57 deletions(-)
drivers/edac/edac_mc.c +0 -55
@@ -170,61 +170,6 @@ const char * const edac_mem_types[] = { };EXPORT_SYMBOL_GPL (edac_mem_types); -/** -* edac_align_ptr - Prepares the pointer offsets for a single-shot allocation -* @p: pointer to a pointer with the memory offset to be used. At -* return, this will be incremented to point to the next offset -* @size: Size of the data structure to be reserved -* @n_elems: Number of elements that should be reserved -* -* If 'size' is a constant, the compiler will optimize this whole function -* down to either a no-op or the addition of a constant to the value of '*p'. -* -* The 'p' pointer is absolutely needed to keep the proper advancing -* further in memory to the proper offsets when allocating the struct along -* with its embedded structs, as edac_device_alloc_ctl_info() does it -* above, for example. -* -* At return, the pointer 'p' will be incremented to be used on a next call -* to this function. -*/ -void *edac_align_ptr (void **p,unsigned int size,int n_elems) -{ -unsigned int align, r; -void *ptr = *p; - - *p += size * n_elems; - -/* -* 'p' can possibly be an unaligned item X such that sizeof(X) is -* 'size'. Adjust 'p' so that its alignment is at least as -* stringent as what the compiler would provide for X and return -* the aligned result. -* Here we assume that the alignment of a "long long" is the most -* stringent alignment that the compiler will ever provide by default. -* As far as I know, this is a reasonable assumption. -*/ -if (size >sizeof (long )) - align =sizeof (long long ); -else if (size >sizeof (int )) - align =sizeof (long ); -else if (size >sizeof (short )) - align =sizeof (int ); -else if (size >sizeof (char )) - align =sizeof (short ); -else -return (char *)ptr; - - r = (unsigned long )ptr % align; - -if (r ==0 ) -return (char *)ptr; - - *p += align - r; - -return (void *)(((unsigned long )ptr) + align - r); -} -static void _edac_mc_free (struct mem_ctl_info *mci) {put_device (&mci->dev);
drivers/edac/edac_module.h +0 -2
@@ -59,8 +59,6 @@ extern void edac_device_reset_delay_period(struct edac_device_ctl_info *edac_dev, unsigned long value);extern void edac_mc_reset_delay_period (unsigned long value); -extern void *edac_align_ptr (void **p,unsigned size,int n_elems); -/* * EDAC debugfs functions */
Signature · 1 line
2.29.2