treewide: Replace kmalloc with kmalloc_obj for non-scalar types

This is the result of running the Coccinelle script from
scripts/coccinelle/api/kmalloc_objs.cocci. The script is designed to
avoid scalar types (which need careful case-by-case checking), and
instead replace kmalloc-family calls that allocate struct or union
object instances:

Single allocations:	kmalloc(sizeof(TYPE), ...)
are replaced with:	kmalloc_obj(TYPE, ...)

Array allocations:	kmalloc_array(COUNT, sizeof(TYPE), ...)
are replaced with:	kmalloc_objs(TYPE, COUNT, ...)

Flex array allocations:	kmalloc(struct_size(PTR, FAM, COUNT), ...)
are replaced with:	kmalloc_flex(*PTR, FAM, COUNT, ...)

(where TYPE may also be *VAR)

The resulting allocations no longer return "void *", instead returning
"TYPE *".

Signed-off-by: Kees Cook <kees@kernel.org>

12 files changed, 40 insertions, 45 deletions

diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 2bb1ceb9d621..129cbfd74f26 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -823,7 +823,7 @@ static int usb_parse_configuration(struct usb_device *dev, int cfgidx,
 			nalts[i] = j = USB_MAXALTSETTING;
 		}
 
-		intfc = kzalloc(struct_size(intfc, altsetting, j), GFP_KERNEL);
+		intfc = kzalloc_flex(*intfc, altsetting, j, GFP_KERNEL);
 		config->intf_cache[i] = intfc;
 		if (!intfc)
 			return -ENOMEM;
@@ -1045,7 +1045,7 @@ int usb_get_bos_descriptor(struct usb_device *dev)
 		return -ENOMSG;
 	}
 
-	bos = kzalloc(sizeof(*bos), GFP_KERNEL);
+	bos = kzalloc_obj(*bos, GFP_KERNEL);
 	if (!bos)
 		return -ENOMEM;
 
@@ -1066,7 +1066,7 @@ int usb_get_bos_descriptor(struct usb_device *dev)
 	if (total_len < length)
 		return -EINVAL;
 
-	dev->bos = kzalloc(sizeof(*dev->bos), GFP_KERNEL);
+	dev->bos = kzalloc_obj(*dev->bos, GFP_KERNEL);
 	if (!dev->bos)
 		return -ENOMEM;
 
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index f6ce6e26e0d4..d7ac181454f9 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -245,7 +245,7 @@ static int usbdev_mmap(struct file *file, struct vm_area_struct *vma)
 	if (ret)
 		goto error;
 
-	usbm = kzalloc(sizeof(struct usb_memory), GFP_KERNEL);
+	usbm = kzalloc_obj(struct usb_memory, GFP_KERNEL);
 	if (!usbm) {
 		ret = -ENOMEM;
 		goto error_decrease_mem;
@@ -402,7 +402,7 @@ static struct async *alloc_async(unsigned int numisoframes)
 {
 	struct async *as;
 
-	as = kzalloc(sizeof(struct async), GFP_KERNEL);
+	as = kzalloc_obj(struct async, GFP_KERNEL);
 	if (!as)
 		return NULL;
 	as->urb = usb_alloc_urb(numisoframes, GFP_KERNEL);
@@ -970,7 +970,7 @@ static int parse_usbdevfs_streams(struct usb_dev_state *ps,
 	if (num_streams_ret && (num_streams < 2 || num_streams > 65536))
 		return -EINVAL;
 
-	eps = kmalloc_array(num_eps, sizeof(*eps), GFP_KERNEL);
+	eps = kmalloc_objs(*eps, num_eps, GFP_KERNEL);
 	if (!eps)
 		return -ENOMEM;
 
@@ -1039,7 +1039,7 @@ static int usbdev_open(struct inode *inode, struct file *file)
 	int ret;
 
 	ret = -ENOMEM;
-	ps = kzalloc(sizeof(struct usb_dev_state), GFP_KERNEL);
+	ps = kzalloc_obj(struct usb_dev_state, GFP_KERNEL);
 	if (!ps)
 		goto out_free_ps;
 
@@ -1196,7 +1196,7 @@ static int do_proc_control(struct usb_dev_state *ps,
 	urb = usb_alloc_urb(0, GFP_NOIO);
 	if (!urb)
 		goto done;
-	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
+	dr = kmalloc_obj(struct usb_ctrlrequest, GFP_NOIO);
 	if (!dr)
 		goto done;
 
@@ -1670,7 +1670,7 @@ static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb
 		/* min 8 byte setup packet */
 		if (uurb->buffer_length < 8)
 			return -EINVAL;
-		dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
+		dr = kmalloc_obj(struct usb_ctrlrequest, GFP_KERNEL);
 		if (!dr)
 			return -ENOMEM;
 		if (copy_from_user(dr, uurb->buffer, 8)) {
@@ -1805,9 +1805,8 @@ static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb
 	as->mem_usage = u;
 
 	if (num_sgs) {
-		as->urb->sg = kmalloc_array(num_sgs,
-					    sizeof(struct scatterlist),
-					    GFP_KERNEL | __GFP_NOWARN);
+		as->urb->sg = kmalloc_objs(struct scatterlist, num_sgs,
+					   GFP_KERNEL | __GFP_NOWARN);
 		if (!as->urb->sg) {
 			ret = -ENOMEM;
 			goto error;
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 2f5958bc4f7f..db67874879d8 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -57,7 +57,7 @@ ssize_t usb_store_new_id(struct usb_dynids *dynids,
 	if (fields < 2)
 		return -EINVAL;
 
-	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
+	dynid = kzalloc_obj(*dynid, GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index e48399401608..f44f0fffeb41 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -154,7 +154,7 @@ int usb_create_ep_devs(struct device *parent,
 	struct ep_device *ep_dev;
 	int retval;
 
-	ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL);
+	ep_dev = kzalloc_obj(*ep_dev, GFP_KERNEL);
 	if (!ep_dev) {
 		retval = -ENOMEM;
 		goto exit;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 2d99a59d9f3f..f1b2b0e4c437 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2193,7 +2193,7 @@ int ehset_single_step_set_feature(struct usb_hcd *hcd, int port)
 	if (!buf)
 		return -ENOMEM;
 
-	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
+	dr = kmalloc_obj(struct usb_ctrlrequest, GFP_KERNEL);
 	if (!dr) {
 		kfree(buf);
 		return -ENOMEM;
@@ -2567,16 +2567,16 @@ struct usb_hcd *__usb_create_hcd(const struct hc_driver *driver,
 	if (!hcd)
 		return NULL;
 	if (primary_hcd == NULL) {
-		hcd->address0_mutex = kmalloc(sizeof(*hcd->address0_mutex),
-				GFP_KERNEL);
+		hcd->address0_mutex = kmalloc_obj(*hcd->address0_mutex,
+						  GFP_KERNEL);
 		if (!hcd->address0_mutex) {
 			kfree(hcd);
 			dev_dbg(dev, "hcd address0 mutex alloc failed\n");
 			return NULL;
 		}
 		mutex_init(hcd->address0_mutex);
-		hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex),
-				GFP_KERNEL);
+		hcd->bandwidth_mutex = kmalloc_obj(*hcd->bandwidth_mutex,
+						   GFP_KERNEL);
 		if (!hcd->bandwidth_mutex) {
 			kfree(hcd->address0_mutex);
 			kfree(hcd);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index be50d03034a9..22a54c632c26 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -929,7 +929,7 @@ int usb_hub_clear_tt_buffer(struct urb *urb)
 	 * since each TT has "at least two" buffers that can need it (and
 	 * there can be many TTs per hub).  even if they're uncommon.
 	 */
-	clear = kmalloc(sizeof *clear, GFP_ATOMIC);
+	clear = kmalloc_obj(*clear, GFP_ATOMIC);
 	if (clear == NULL) {
 		dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
 		/* FIXME recover somehow ... RESET_TT? */
@@ -1461,20 +1461,20 @@ static int hub_configure(struct usb_hub *hub,
 	unsigned full_load;
 	unsigned maxchild;
 
-	hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
+	hub->buffer = kmalloc_obj(*hub->buffer, GFP_KERNEL);
 	if (!hub->buffer) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 
-	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
+	hub->status = kmalloc_obj(*hub->status, GFP_KERNEL);
 	if (!hub->status) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	mutex_init(&hub->status_mutex);
 
-	hub->descriptor = kzalloc(sizeof(*hub->descriptor), GFP_KERNEL);
+	hub->descriptor = kzalloc_obj(*hub->descriptor, GFP_KERNEL);
 	if (!hub->descriptor) {
 		ret = -ENOMEM;
 		goto fail;
@@ -1522,7 +1522,7 @@ static int hub_configure(struct usb_hub *hub,
 	dev_info(hub_dev, "%d port%s detected\n", maxchild,
 			str_plural(maxchild));
 
-	hub->ports = kcalloc(maxchild, sizeof(struct usb_port *), GFP_KERNEL);
+	hub->ports = kzalloc_objs(struct usb_port *, maxchild, GFP_KERNEL);
 	if (!hub->ports) {
 		ret = -ENOMEM;
 		goto fail;
@@ -1958,7 +1958,7 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
 	/* We found a hub */
 	dev_info(&intf->dev, "USB hub found\n");
 
-	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
+	hub = kzalloc_obj(*hub, GFP_KERNEL);
 	if (!hub)
 		return -ENOMEM;
 
@@ -4142,7 +4142,7 @@ static int usb_req_set_sel(struct usb_device *udev)
 	 * which may be initiated by an error path of a mass storage driver.
 	 * Therefore, use GFP_NOIO.
 	 */
-	sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
+	sel_values = kmalloc_obj(*(sel_values), GFP_NOIO);
 	if (!sel_values)
 		return -ENOMEM;
 
@@ -5236,7 +5236,7 @@ check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1)
 	if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
 		return;
 
-	qual = kmalloc(sizeof *qual, GFP_KERNEL);
+	qual = kmalloc_obj(*qual, GFP_KERNEL);
 	if (qual == NULL)
 		return;
 
diff --git a/drivers/usb/core/ledtrig-usbport.c b/drivers/usb/core/ledtrig-usbport.c
index 5e3c515991f3..e7de8864a527 100644
--- a/drivers/usb/core/ledtrig-usbport.c
+++ b/drivers/usb/core/ledtrig-usbport.c
@@ -190,7 +190,7 @@ static int usbport_trig_add_port(struct usbport_trig_data *usbport_data,
 	size_t len;
 	int err;
 
-	port = kzalloc(sizeof(*port), GFP_KERNEL);
+	port = kzalloc_obj(*port, GFP_KERNEL);
 	if (!port) {
 		err = -ENOMEM;
 		goto err_out;
@@ -305,7 +305,7 @@ static int usbport_trig_activate(struct led_classdev *led_cdev)
 	struct usbport_trig_data *usbport_data;
 	int err;
 
-	usbport_data = kzalloc(sizeof(*usbport_data), GFP_KERNEL);
+	usbport_data = kzalloc_obj(*usbport_data, GFP_KERNEL);
 	if (!usbport_data)
 		return -ENOMEM;
 	usbport_data->led_cdev = led_cdev;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 6138468c67c4..d8f50d468794 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -141,7 +141,7 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
 	struct usb_ctrlrequest *dr;
 	int ret;
 
-	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
+	dr = kmalloc_obj(struct usb_ctrlrequest, GFP_NOIO);
 	if (!dr)
 		return -ENOMEM;
 
@@ -526,7 +526,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
 	}
 
 	/* initialize all the urbs we'll use */
-	io->urbs = kmalloc_array(io->entries, sizeof(*io->urbs), mem_flags);
+	io->urbs = kmalloc_objs(*io->urbs, io->entries, mem_flags);
 	if (!io->urbs)
 		goto nomem;
 
@@ -1058,7 +1058,7 @@ struct usb_device_descriptor *usb_get_device_descriptor(struct usb_device *udev)
 	struct usb_device_descriptor *desc;
 	int ret;
 
-	desc = kmalloc(sizeof(*desc), GFP_NOIO);
+	desc = kmalloc_obj(*desc, GFP_NOIO);
 	if (!desc)
 		return ERR_PTR(-ENOMEM);
 
@@ -2028,15 +2028,13 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
 	n = nintf = 0;
 	if (cp) {
 		nintf = cp->desc.bNumInterfaces;
-		new_interfaces = kmalloc_array(nintf, sizeof(*new_interfaces),
-					       GFP_NOIO);
+		new_interfaces = kmalloc_objs(*new_interfaces, nintf, GFP_NOIO);
 		if (!new_interfaces)
 			return -ENOMEM;
 
 		for (; n < nintf; ++n) {
-			new_interfaces[n] = kzalloc(
-					sizeof(struct usb_interface),
-					GFP_NOIO);
+			new_interfaces[n] = kzalloc_obj(struct usb_interface,
+							GFP_NOIO);
 			if (!new_interfaces[n]) {
 				ret = -ENOMEM;
 free_interfaces:
@@ -2289,7 +2287,7 @@ int usb_driver_set_configuration(struct usb_device *udev, int config)
 {
 	struct set_config_request *req;
 
-	req = kmalloc(sizeof(*req), GFP_KERNEL);
+	req = kmalloc_obj(*req, GFP_KERNEL);
 	if (!req)
 		return -ENOMEM;
 	req->udev = udev;
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index f54198171b6a..36096973eb59 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -739,11 +739,11 @@ int usb_hub_create_port_device(struct usb_hub *hub, int port1)
 	struct usb_device *hdev = hub->hdev;
 	int retval;
 
-	port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
+	port_dev = kzalloc_obj(*port_dev, GFP_KERNEL);
 	if (!port_dev)
 		return -ENOMEM;
 
-	port_dev->req = kzalloc(sizeof(*(port_dev->req)), GFP_KERNEL);
+	port_dev->req = kzalloc_obj(*(port_dev->req), GFP_KERNEL);
 	if (!port_dev->req) {
 		kfree(port_dev);
 		return -ENOMEM;
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index c4d85089d19b..135a89ab2bfa 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -61,8 +61,7 @@ static int quirks_param_set(const char *value, const struct kernel_param *kp)
 		quirk_list = NULL;
 	}
 
-	quirk_list = kcalloc(quirk_count, sizeof(struct quirk_entry),
-			     GFP_KERNEL);
+	quirk_list = kzalloc_objs(struct quirk_entry, quirk_count, GFP_KERNEL);
 	if (!quirk_list) {
 		quirk_count = 0;
 		mutex_unlock(&quirk_mutex);
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index ff8df16cca35..c06b44ca507b 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -72,8 +72,7 @@ struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
 {
 	struct urb *urb;
 
-	urb = kmalloc(struct_size(urb, iso_frame_desc, iso_packets),
-		      mem_flags);
+	urb = kmalloc_flex(*urb, iso_frame_desc, iso_packets, mem_flags);
 	if (!urb)
 		return NULL;
 	usb_init_urb(urb);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index e740f7852bcd..cfb882b86981 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -648,7 +648,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
 	struct usb_hcd *usb_hcd = bus_to_hcd(bus);
 	unsigned raw_port = port1;
 
-	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+	dev = kzalloc_obj(*dev, GFP_KERNEL);
 	if (!dev)
 		return NULL;