Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit de6eb66b authored by Roland Dreier's avatar Roland Dreier
Browse files

[IB] kzalloc() conversions 



Replace kmalloc()+memset(,0,) with kzalloc(), for a net savings of 35
source lines and about 500 bytes of text.

Signed-off-by: default avatarRoland Dreier <rolandd@cisco.com>
parent 7b28b0d0

drivers/infiniband/core/agent.c

+1 −2
Original line number Diff line number Diff line
@@ -155,13 +155,12 @@ int ib_agent_port_open(struct ib_device *device, int port_num) 
	int ret;



	/* Create new device info */

	port_priv = kmalloc(sizeof *port_priv, GFP_KERNEL);

	port_priv = kzalloc(sizeof *port_priv, GFP_KERNEL);

	if (!port_priv) {

		printk(KERN_ERR SPFX "No memory for ib_agent_port_private\n");

		ret = -ENOMEM;

		goto error1;

	}

	memset(port_priv, 0, sizeof *port_priv);



	/* Obtain send only MAD agent for SMI QP */

	port_priv->agent[0] = ib_register_mad_agent(device, port_num,

drivers/infiniband/core/cm.c

+2 −4
Original line number Diff line number Diff line
@@ -544,11 +544,10 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device, 
	struct cm_id_private *cm_id_priv;

	int ret;



	cm_id_priv = kmalloc(sizeof *cm_id_priv, GFP_KERNEL);

	cm_id_priv = kzalloc(sizeof *cm_id_priv, GFP_KERNEL);

	if (!cm_id_priv)

		return ERR_PTR(-ENOMEM);



	memset(cm_id_priv, 0, sizeof *cm_id_priv);

	cm_id_priv->id.state = IB_CM_IDLE;

	cm_id_priv->id.device = device;

	cm_id_priv->id.cm_handler = cm_handler;
@@ -621,10 +620,9 @@ static struct cm_timewait_info * cm_create_timewait_info(__be32 local_id) 
{

	struct cm_timewait_info *timewait_info;



	timewait_info = kmalloc(sizeof *timewait_info, GFP_KERNEL);

	timewait_info = kzalloc(sizeof *timewait_info, GFP_KERNEL);

	if (!timewait_info)

		return ERR_PTR(-ENOMEM);

	memset(timewait_info, 0, sizeof *timewait_info);



	timewait_info->work.local_id = local_id;

	INIT_WORK(&timewait_info->work.work, cm_work_handler,

drivers/infiniband/core/device.c

+1 −9
Original line number Diff line number Diff line
@@ -161,17 +161,9 @@ static int alloc_name(char *name) 
 */

struct ib_device *ib_alloc_device(size_t size)

{

	void *dev;



	BUG_ON(size < sizeof (struct ib_device));



	dev = kmalloc(size, GFP_KERNEL);

	if (!dev)

		return NULL;



	memset(dev, 0, size);



	return dev;

	return kzalloc(size, GFP_KERNEL);

}

EXPORT_SYMBOL(ib_alloc_device);

drivers/infiniband/core/mad.c

+12 −19
Original line number Diff line number Diff line
@@ -255,12 +255,11 @@ struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device, 
	}



	/* Allocate structures */

	mad_agent_priv = kmalloc(sizeof *mad_agent_priv, GFP_KERNEL);

	mad_agent_priv = kzalloc(sizeof *mad_agent_priv, GFP_KERNEL);

	if (!mad_agent_priv) {

		ret = ERR_PTR(-ENOMEM);

		goto error1;

	}

	memset(mad_agent_priv, 0, sizeof *mad_agent_priv);



	mad_agent_priv->agent.mr = ib_get_dma_mr(port_priv->qp_info[qpn].qp->pd,

						 IB_ACCESS_LOCAL_WRITE);
@@ -448,14 +447,13 @@ struct ib_mad_agent *ib_register_mad_snoop(struct ib_device *device, 
		goto error1;

	}

	/* Allocate structures */

	mad_snoop_priv = kmalloc(sizeof *mad_snoop_priv, GFP_KERNEL);

	mad_snoop_priv = kzalloc(sizeof *mad_snoop_priv, GFP_KERNEL);

	if (!mad_snoop_priv) {

		ret = ERR_PTR(-ENOMEM);

		goto error1;

	}



	/* Now, fill in the various structures */

	memset(mad_snoop_priv, 0, sizeof *mad_snoop_priv);

	mad_snoop_priv->qp_info = &port_priv->qp_info[qpn];

	mad_snoop_priv->agent.device = device;

	mad_snoop_priv->agent.recv_handler = recv_handler;
@@ -794,10 +792,9 @@ struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent, 
	    (!rmpp_active && buf_size > sizeof(struct ib_mad)))

		return ERR_PTR(-EINVAL);



	buf = kmalloc(sizeof *mad_send_wr + buf_size, gfp_mask);

	buf = kzalloc(sizeof *mad_send_wr + buf_size, gfp_mask);

	if (!buf)

		return ERR_PTR(-ENOMEM);

	memset(buf, 0, sizeof *mad_send_wr + buf_size);



	mad_send_wr = buf + buf_size;

	mad_send_wr->send_buf.mad = buf;
@@ -1039,14 +1036,12 @@ static int method_in_use(struct ib_mad_mgmt_method_table **method, 
static int allocate_method_table(struct ib_mad_mgmt_method_table **method)

{

	/* Allocate management method table */

	*method = kmalloc(sizeof **method, GFP_ATOMIC);

	*method = kzalloc(sizeof **method, GFP_ATOMIC);

	if (!*method) {

		printk(KERN_ERR PFX "No memory for "

		       "ib_mad_mgmt_method_table\n");

		return -ENOMEM;

	}

	/* Clear management method table */

	memset(*method, 0, sizeof **method);



	return 0;

}
@@ -1137,15 +1132,14 @@ static int add_nonoui_reg_req(struct ib_mad_reg_req *mad_reg_req, 
	class = &port_priv->version[mad_reg_req->mgmt_class_version].class;

	if (!*class) {

		/* Allocate management class table for "new" class version */

		*class = kmalloc(sizeof **class, GFP_ATOMIC);

		*class = kzalloc(sizeof **class, GFP_ATOMIC);

		if (!*class) {

			printk(KERN_ERR PFX "No memory for "

			       "ib_mad_mgmt_class_table\n");

			ret = -ENOMEM;

			goto error1;

		}

		/* Clear management class table */

		memset(*class, 0, sizeof(**class));



		/* Allocate method table for this management class */

		method = &(*class)->method_table[mgmt_class];

		if ((ret = allocate_method_table(method)))
@@ -1209,25 +1203,24 @@ static int add_oui_reg_req(struct ib_mad_reg_req *mad_reg_req, 
				mad_reg_req->mgmt_class_version].vendor;

	if (!*vendor_table) {

		/* Allocate mgmt vendor class table for "new" class version */

		vendor = kmalloc(sizeof *vendor, GFP_ATOMIC);

		vendor = kzalloc(sizeof *vendor, GFP_ATOMIC);

		if (!vendor) {

			printk(KERN_ERR PFX "No memory for "

			       "ib_mad_mgmt_vendor_class_table\n");

			goto error1;

		}

		/* Clear management vendor class table */

		memset(vendor, 0, sizeof(*vendor));



		*vendor_table = vendor;

	}

	if (!(*vendor_table)->vendor_class[vclass]) {

		/* Allocate table for this management vendor class */

		vendor_class = kmalloc(sizeof *vendor_class, GFP_ATOMIC);

		vendor_class = kzalloc(sizeof *vendor_class, GFP_ATOMIC);

		if (!vendor_class) {

			printk(KERN_ERR PFX "No memory for "

			       "ib_mad_mgmt_vendor_class\n");

			goto error2;

		}

		memset(vendor_class, 0, sizeof(*vendor_class));



		(*vendor_table)->vendor_class[vclass] = vendor_class;

	}

	for (i = 0; i < MAX_MGMT_OUI; i++) {
@@ -2524,12 +2517,12 @@ static int ib_mad_port_open(struct ib_device *device, 
	char name[sizeof "ib_mad123"];



	/* Create new device info */

	port_priv = kmalloc(sizeof *port_priv, GFP_KERNEL);

	port_priv = kzalloc(sizeof *port_priv, GFP_KERNEL);

	if (!port_priv) {

		printk(KERN_ERR PFX "No memory for ib_mad_port_private\n");

		return -ENOMEM;

	}

	memset(port_priv, 0, sizeof *port_priv);



	port_priv->device = device;

	port_priv->port_num = port_num;

	spin_lock_init(&port_priv->reg_lock);

drivers/infiniband/core/sysfs.c

+2 −4
Original line number Diff line number Diff line
@@ -307,14 +307,13 @@ static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr, 
	if (!p->ibdev->process_mad)

		return sprintf(buf, "N/A (no PMA)\n");



	in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);

	out_mad = kmalloc(sizeof *in_mad, GFP_KERNEL);

	if (!in_mad || !out_mad) {

		ret = -ENOMEM;

		goto out;

	}



	memset(in_mad, 0, sizeof *in_mad);

	in_mad->mad_hdr.base_version  = 1;

	in_mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_PERF_MGMT;

	in_mad->mad_hdr.class_version = 1;
@@ -508,10 +507,9 @@ static int add_port(struct ib_device *device, int port_num) 
	if (ret)

		return ret;



	p = kmalloc(sizeof *p, GFP_KERNEL);

	p = kzalloc(sizeof *p, GFP_KERNEL);

	if (!p)

		return -ENOMEM;

	memset(p, 0, sizeof *p);



	p->ibdev      = device;

	p->port_num   = port_num;