tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[PATCH] USB: kfree cleanup for drivers/usb/* - no need to check for NULL

Get rid of a bunch of redundant NULL pointer checks in drivers/usb/*,
there's no need to check a pointer for NULL before calling kfree() on it.

Signed-off-by: Jesper Juhl <juhl-lkml@dif.dk>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>


Index: gregkh-2.6/drivers/usb/class/audio.c
===================================================================

authored by Jesper Juhl and committed by Greg K-H 1bc3c9e1 6fd19f4b

+91 -166
unified split
+16 -32
drivers/usb/class/audio.c
··· 649 649 } 650 650 } 651 651 set_current_state(TASK_RUNNING); 652 - if (u->durb[0].urb->transfer_buffer) 653 - kfree(u->durb[0].urb->transfer_buffer); 654 - if (u->durb[1].urb->transfer_buffer) 655 - kfree(u->durb[1].urb->transfer_buffer); 656 - if (u->surb[0].urb->transfer_buffer) 657 - kfree(u->surb[0].urb->transfer_buffer); 658 - if (u->surb[1].urb->transfer_buffer) 659 - kfree(u->surb[1].urb->transfer_buffer); 652 + kfree(u->durb[0].urb->transfer_buffer); 653 + kfree(u->durb[1].urb->transfer_buffer); 654 + kfree(u->surb[0].urb->transfer_buffer); 655 + kfree(u->surb[1].urb->transfer_buffer); 660 656 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer = 661 657 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL; 662 658 } ··· 1005 1009 u->phase = 0; 1006 1010 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format)); 1007 1011 bufsz = DESCFRAMES * maxsze; 1008 - if (u->durb[0].urb->transfer_buffer) 1009 - kfree(u->durb[0].urb->transfer_buffer); 1012 + kfree(u->durb[0].urb->transfer_buffer); 1010 1013 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); 1011 1014 u->durb[0].urb->transfer_buffer_length = bufsz; 1012 - if (u->durb[1].urb->transfer_buffer) 1013 - kfree(u->durb[1].urb->transfer_buffer); 1015 + kfree(u->durb[1].urb->transfer_buffer); 1014 1016 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); 1015 1017 u->durb[1].urb->transfer_buffer_length = bufsz; 1016 1018 if (u->syncpipe) { 1017 - if (u->surb[0].urb->transfer_buffer) 1018 - kfree(u->surb[0].urb->transfer_buffer); 1019 + kfree(u->surb[0].urb->transfer_buffer); 1019 1020 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); 1020 1021 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES; 1021 - if (u->surb[1].urb->transfer_buffer) 1022 - kfree(u->surb[1].urb->transfer_buffer); 1022 + kfree(u->surb[1].urb->transfer_buffer); 1023 1023 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); 1024 1024 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES; 1025 1025 } ··· 1120 1128 } 1121 1129 } 1122 1130 set_current_state(TASK_RUNNING); 1123 - if (u->durb[0].urb->transfer_buffer) 1124 - kfree(u->durb[0].urb->transfer_buffer); 1125 - if (u->durb[1].urb->transfer_buffer) 1126 - kfree(u->durb[1].urb->transfer_buffer); 1127 - if (u->surb[0].urb->transfer_buffer) 1128 - kfree(u->surb[0].urb->transfer_buffer); 1129 - if (u->surb[1].urb->transfer_buffer) 1130 - kfree(u->surb[1].urb->transfer_buffer); 1131 + kfree(u->durb[0].urb->transfer_buffer); 1132 + kfree(u->durb[1].urb->transfer_buffer); 1133 + kfree(u->surb[0].urb->transfer_buffer); 1134 + kfree(u->surb[1].urb->transfer_buffer); 1131 1135 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer = 1132 1136 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL; 1133 1137 } ··· 1364 1376 u->phase = 0; 1365 1377 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format)); 1366 1378 bufsz = DESCFRAMES * maxsze; 1367 - if (u->durb[0].urb->transfer_buffer) 1368 - kfree(u->durb[0].urb->transfer_buffer); 1379 + kfree(u->durb[0].urb->transfer_buffer); 1369 1380 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); 1370 1381 u->durb[0].urb->transfer_buffer_length = bufsz; 1371 - if (u->durb[1].urb->transfer_buffer) 1372 - kfree(u->durb[1].urb->transfer_buffer); 1382 + kfree(u->durb[1].urb->transfer_buffer); 1373 1383 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); 1374 1384 u->durb[1].urb->transfer_buffer_length = bufsz; 1375 1385 if (u->syncpipe) { 1376 - if (u->surb[0].urb->transfer_buffer) 1377 - kfree(u->surb[0].urb->transfer_buffer); 1386 + kfree(u->surb[0].urb->transfer_buffer); 1378 1387 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); 1379 1388 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES; 1380 - if (u->surb[1].urb->transfer_buffer) 1381 - kfree(u->surb[1].urb->transfer_buffer); 1389 + kfree(u->surb[1].urb->transfer_buffer); 1382 1390 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); 1383 1391 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES; 1384 1392 }
+2 -2
drivers/usb/class/bluetty.c
··· 309 309 } 310 310 } 311 311 if (urb->transfer_buffer_length < len) { 312 - kfree (urb->transfer_buffer); 312 + kfree(urb->transfer_buffer); 313 313 urb->transfer_buffer = kmalloc (len, GFP_KERNEL); 314 314 if (urb->transfer_buffer == NULL) { 315 315 err ("%s - out of memory", __FUNCTION__); ··· 535 535 } 536 536 537 537 exit: 538 - kfree (temp_buffer); 538 + kfree(temp_buffer); 539 539 540 540 return retval; 541 541 }
+2 -5
drivers/usb/core/devices.c
··· 637 637 638 638 static int usb_device_release(struct inode *inode, struct file *file) 639 639 { 640 - if (file->private_data) { 641 - kfree(file->private_data); 642 - file->private_data = NULL; 643 - } 644 - 640 + kfree(file->private_data); 641 + file->private_data = NULL; 645 642 return 0; 646 643 } 647 644
+6 -10
drivers/usb/core/hub.c
··· 381 381 dev_err (&hdev->dev, 382 382 "clear tt %d (%04x) error %d\n", 383 383 clear->tt, clear->devinfo, status); 384 - kfree (clear); 384 + kfree(clear); 385 385 } 386 386 spin_unlock_irqrestore (&hub->tt.lock, flags); 387 387 } ··· 728 728 list_del_init(&hub->event_list); 729 729 spin_unlock_irq(&hub_event_lock); 730 730 731 - if (hub->descriptor) { 732 - kfree(hub->descriptor); 733 - hub->descriptor = NULL; 734 - } 731 + kfree(hub->descriptor); 732 + hub->descriptor = NULL; 735 733 736 - if (hub->status) { 737 - kfree(hub->status); 738 - hub->status = NULL; 739 - } 734 + kfree(hub->status); 735 + hub->status = NULL; 740 736 741 737 if (hub->buffer) { 742 738 usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer, ··· 2350 2354 schedule_work (&hub->leds); 2351 2355 } 2352 2356 } 2353 - kfree (qual); 2357 + kfree(qual); 2354 2358 } 2355 2359 2356 2360 static unsigned
+2 -3
drivers/usb/gadget/serial.c
··· 2312 2312 */ 2313 2313 void gs_buf_free(struct gs_buf *gb) 2314 2314 { 2315 - if (gb != NULL) { 2316 - if (gb->buf_buf != NULL) 2317 - kfree(gb->buf_buf); 2315 + if (gb) { 2316 + kfree(gb->buf_buf); 2318 2317 kfree(gb); 2319 2318 } 2320 2319 }
+1 -2
drivers/usb/host/ehci-mem.c
··· 156 156 ehci->periodic = NULL; 157 157 158 158 /* shadow periodic table */ 159 - if (ehci->pshadow) 160 - kfree (ehci->pshadow); 159 + kfree(ehci->pshadow); 161 160 ehci->pshadow = NULL; 162 161 } 163 162
+2 -5
drivers/usb/host/uhci-hcd.c
··· 890 890 debugfs_remove(uhci_debugfs_root); 891 891 892 892 debug_failed: 893 - if (errbuf) 894 - kfree(errbuf); 893 + kfree(errbuf); 895 894 896 895 errbuf_failed: 897 896 ··· 905 906 warn("not all urb_priv's were freed!"); 906 907 907 908 debugfs_remove(uhci_debugfs_root); 908 - 909 - if (errbuf) 910 - kfree(errbuf); 909 + kfree(errbuf); 911 910 } 912 911 913 912 module_init(uhci_hcd_init);
+1 -2
drivers/usb/input/hid-core.c
··· 558 558 } 559 559 } 560 560 561 - if (device->rdesc) 562 - kfree(device->rdesc); 561 + kfree(device->rdesc); 563 562 kfree(device); 564 563 } 565 564
+1 -2
drivers/usb/media/dabusb.c
··· 138 138 #ifdef DEBUG 139 139 dump_urb(b->purb); 140 140 #endif 141 - if (b->purb->transfer_buffer) 142 - kfree (b->purb->transfer_buffer); 141 + kfree(b->purb->transfer_buffer); 143 142 usb_free_urb(b->purb); 144 143 tmp = p->next; 145 144 list_del (p);
+4 -8
drivers/usb/media/ov511.c
··· 3915 3915 ov->tempfbuf = NULL; 3916 3916 3917 3917 for (i = 0; i < OV511_NUMSBUF; i++) { 3918 - if (ov->sbuf[i].data) { 3919 - kfree(ov->sbuf[i].data); 3920 - ov->sbuf[i].data = NULL; 3921 - } 3918 + kfree(ov->sbuf[i].data); 3919 + ov->sbuf[i].data = NULL; 3922 3920 } 3923 3921 3924 3922 for (i = 0; i < OV511_NUMFRAMES; i++) { ··· 5952 5954 up(&ov->cbuf_lock); 5953 5955 } 5954 5956 5955 - if (ov) { 5956 - kfree(ov); 5957 - ov = NULL; 5958 - } 5957 + kfree(ov); 5958 + ov = NULL; 5959 5959 5960 5960 error_out: 5961 5961 err("Camera initialization failed");
+8 -7
drivers/usb/media/se401.c
··· 868 868 869 869 se401->dev = NULL; 870 870 871 - for (i=0; i<SE401_NUMSBUF; i++) if (se401->urb[i]) { 872 - usb_kill_urb(se401->urb[i]); 873 - usb_free_urb(se401->urb[i]); 874 - se401->urb[i] = NULL; 875 - kfree(se401->sbuf[i].data); 876 - } 877 - for (i=0; i<SE401_NUMSCRATCH; i++) if (se401->scratch[i].data) { 871 + for (i=0; i<SE401_NUMSBUF; i++) 872 + if (se401->urb[i]) { 873 + usb_kill_urb(se401->urb[i]); 874 + usb_free_urb(se401->urb[i]); 875 + se401->urb[i] = NULL; 876 + kfree(se401->sbuf[i].data); 877 + } 878 + for (i=0; i<SE401_NUMSCRATCH; i++) { 878 879 kfree(se401->scratch[i].data); 879 880 } 880 881 if (se401->inturb) {
+2 -4
drivers/usb/media/usbvideo.c
··· 1169 1169 } 1170 1170 RingQueue_Free(&uvd->dp); 1171 1171 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1172 - if (uvd->sbuf[i].data != NULL) { 1173 - kfree (uvd->sbuf[i].data); 1174 - uvd->sbuf[i].data = NULL; 1175 - } 1172 + kfree(uvd->sbuf[i].data); 1173 + uvd->sbuf[i].data = NULL; 1176 1174 } 1177 1175 } 1178 1176 }
+2 -4
drivers/usb/media/w9968cf.c
··· 3624 3624 return 0; 3625 3625 3626 3626 fail: /* Free unused memory */ 3627 - if (cam->control_buffer) 3628 - kfree(cam->control_buffer); 3629 - if (cam->data_buffer) 3630 - kfree(cam->data_buffer); 3627 + kfree(cam->control_buffer); 3628 + kfree(cam->data_buffer); 3631 3629 if (cam->v4ldev) 3632 3630 video_device_release(cam->v4ldev); 3633 3631 up(&cam->dev_sem);
+10 -16
drivers/usb/misc/auerswald.c
··· 705 705 /* free a single auerbuf */ 706 706 static void auerbuf_free (pauerbuf_t bp) 707 707 { 708 - if (bp->bufp) { 709 - kfree (bp->bufp); 710 - } 711 - if (bp->dr) { 712 - kfree (bp->dr); 713 - } 708 + kfree(bp->bufp); 709 + kfree(bp->dr); 714 710 if (bp->urbp) { 715 - usb_free_urb (bp->urbp); 711 + usb_free_urb(bp->urbp); 716 712 } 717 - kfree (bp); 713 + kfree(bp); 718 714 } 719 715 720 716 /* free the buffers from an auerbuf list */ ··· 1089 1093 */ 1090 1094 static void auerswald_int_free (pauerswald_t cp) 1091 1095 { 1092 - if (cp->inturbp) { 1093 - usb_free_urb (cp->inturbp); 1094 - cp->inturbp = NULL; 1095 - } 1096 - if (cp->intbufp) { 1097 - kfree (cp->intbufp); 1098 - cp->intbufp = NULL; 1099 - } 1096 + if (cp->inturbp) { 1097 + usb_free_urb(cp->inturbp); 1098 + cp->inturbp = NULL; 1099 + } 1100 + kfree(cp->intbufp); 1101 + cp->intbufp = NULL; 1100 1102 } 1101 1103 1102 1104 /* This function is called to activate the interrupt
+1 -2
drivers/usb/net/zd1201.c
··· 106 106 107 107 err = 0; 108 108 exit: 109 - if (buf) 110 - kfree(buf); 109 + kfree(buf); 111 110 release_firmware(fw_entry); 112 111 return err; 113 112 }
+1 -2
drivers/usb/serial/belkin_sa.c
··· 202 202 for (i=0; i < serial->num_ports; ++i) { 203 203 /* My special items, the standard routines free my urbs */ 204 204 priv = usb_get_serial_port_data(serial->port[i]); 205 - if (priv) 206 - kfree(priv); 205 + kfree(priv); 207 206 } 208 207 } 209 208
+2 -3
drivers/usb/serial/cypress_m8.c
··· 1340 1340 1341 1341 static void cypress_buf_free(struct cypress_buf *cb) 1342 1342 { 1343 - if (cb != NULL) { 1344 - if (cb->buf_buf != NULL) 1345 - kfree(cb->buf_buf); 1343 + if (cb) { 1344 + kfree(cb->buf_buf); 1346 1345 kfree(cb); 1347 1346 } 1348 1347 }
+2 -4
drivers/usb/serial/empeg.c
··· 550 550 failed_usb_serial_register: 551 551 for (i = 0; i < NUM_URBS; ++i) { 552 552 if (write_urb_pool[i]) { 553 - if (write_urb_pool[i]->transfer_buffer) 554 - kfree(write_urb_pool[i]->transfer_buffer); 553 + kfree(write_urb_pool[i]->transfer_buffer); 555 554 usb_free_urb(write_urb_pool[i]); 556 555 } 557 556 } ··· 574 575 * the host controllers get fixed to set urb->dev = NULL after 575 576 * the urb is finished. Otherwise this call oopses. */ 576 577 /* usb_kill_urb(write_urb_pool[i]); */ 577 - if (write_urb_pool[i]->transfer_buffer) 578 - kfree(write_urb_pool[i]->transfer_buffer); 578 + kfree(write_urb_pool[i]->transfer_buffer); 579 579 usb_free_urb (write_urb_pool[i]); 580 580 } 581 581 }
+3 -7
drivers/usb/serial/ftdi_sio.c
··· 1347 1347 priv->flags = ASYNC_LOW_LATENCY; 1348 1348 1349 1349 /* Increase the size of read buffers */ 1350 - if (port->bulk_in_buffer) { 1351 - kfree (port->bulk_in_buffer); 1352 - } 1350 + kfree(port->bulk_in_buffer); 1353 1351 port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL); 1354 1352 if (!port->bulk_in_buffer) { 1355 1353 kfree (priv); ··· 1363 1365 usb_free_urb (port->write_urb); 1364 1366 port->write_urb = NULL; 1365 1367 } 1366 - if (port->bulk_out_buffer) { 1367 - kfree (port->bulk_out_buffer); 1368 - port->bulk_out_buffer = NULL; 1369 - } 1368 + kfree(port->bulk_out_buffer); 1369 + port->bulk_out_buffer = NULL; 1370 1370 1371 1371 usb_set_serial_port_data(serial->port[0], priv); 1372 1372
+8 -16
drivers/usb/serial/io_edgeport.c
··· 951 951 952 952 953 953 /* clean up the transfer buffer */ 954 - if (urb->transfer_buffer != NULL) { 955 - kfree(urb->transfer_buffer); 956 - } 954 + kfree(urb->transfer_buffer); 957 955 958 956 /* Free the command urb */ 959 957 usb_free_urb (urb); ··· 1264 1266 1265 1267 if (edge_port->write_urb) { 1266 1268 /* if this urb had a transfer buffer already (old transfer) free it */ 1267 - if (edge_port->write_urb->transfer_buffer != NULL) { 1268 - kfree(edge_port->write_urb->transfer_buffer); 1269 - } 1270 - usb_free_urb (edge_port->write_urb); 1269 + kfree(edge_port->write_urb->transfer_buffer); 1270 + usb_free_urb(edge_port->write_urb); 1271 1271 edge_port->write_urb = NULL; 1272 1272 } 1273 - if (edge_port->txfifo.fifo) { 1274 - kfree(edge_port->txfifo.fifo); 1275 - edge_port->txfifo.fifo = NULL; 1276 - } 1273 + kfree(edge_port->txfifo.fifo); 1274 + edge_port->txfifo.fifo = NULL; 1277 1275 1278 1276 dbg("%s exited", __FUNCTION__); 1279 1277 } ··· 1413 1419 // get a pointer to the write_urb 1414 1420 urb = edge_port->write_urb; 1415 1421 1416 - /* if this urb had a transfer buffer already (old transfer) free it */ 1417 - if (urb->transfer_buffer != NULL) { 1418 - kfree(urb->transfer_buffer); 1419 - urb->transfer_buffer = NULL; 1420 - } 1422 + /* make sure transfer buffer is freed */ 1423 + kfree(urb->transfer_buffer); 1424 + urb->transfer_buffer = NULL; 1421 1425 1422 1426 /* build the data header for the buffer and port that we are about to send out */ 1423 1427 count = fifo->count;
+2 -3
drivers/usb/serial/io_ti.c
··· 2845 2845 2846 2846 void edge_buf_free(struct edge_buf *eb) 2847 2847 { 2848 - if (eb != NULL) { 2849 - if (eb->buf_buf != NULL) 2850 - kfree(eb->buf_buf); 2848 + if (eb) { 2849 + kfree(eb->buf_buf); 2851 2850 kfree(eb); 2852 2851 } 2853 2852 }
+1 -2
drivers/usb/serial/kl5kusb105.c
··· 341 341 * finished. Otherwise this call 342 342 * oopses. */ 343 343 /* usb_kill_urb(write_urbs[j]); */ 344 - if (write_urbs[j]->transfer_buffer) 345 - kfree(write_urbs[j]->transfer_buffer); 344 + kfree(write_urbs[j]->transfer_buffer); 346 345 usb_free_urb (write_urbs[j]); 347 346 } 348 347 }
+1 -4
drivers/usb/serial/omninet.c
··· 178 178 { 179 179 struct usb_serial *serial = port->serial; 180 180 struct usb_serial_port *wport; 181 - struct omninet_data *od; 182 181 183 182 dbg("%s - port %d", __FUNCTION__, port->number); 184 183 ··· 185 186 usb_kill_urb(wport->write_urb); 186 187 usb_kill_urb(port->read_urb); 187 188 188 - od = usb_get_serial_port_data(port); 189 - if (od) 190 - kfree(od); 189 + kfree(usb_get_serial_port_data(port)); 191 190 } 192 191 193 192
+2 -3
drivers/usb/serial/pl2303.c
··· 1044 1044 1045 1045 static void pl2303_buf_free(struct pl2303_buf *pb) 1046 1046 { 1047 - if (pb != NULL) { 1048 - if (pb->buf_buf != NULL) 1049 - kfree(pb->buf_buf); 1047 + if (pb) { 1048 + kfree(pb->buf_buf); 1050 1049 kfree(pb); 1051 1050 } 1052 1051 }
+1 -2
drivers/usb/serial/ti_usb_3410_5052.c
··· 517 517 } 518 518 } 519 519 520 - if (tdev) 521 - kfree(tdev); 520 + kfree(tdev); 522 521 usb_set_serial_data(serial, NULL); 523 522 } 524 523
+8 -16
drivers/usb/storage/sddr55.c
··· 119 119 /* expect to get short transfer if no card fitted */ 120 120 if (result == USB_STOR_XFER_SHORT || result == USB_STOR_XFER_STALLED) { 121 121 /* had a short transfer, no card inserted, free map memory */ 122 - if (info->lba_to_pba) 123 - kfree(info->lba_to_pba); 124 - if (info->pba_to_lba) 125 - kfree(info->pba_to_lba); 122 + kfree(info->lba_to_pba); 123 + kfree(info->pba_to_lba); 126 124 info->lba_to_pba = NULL; 127 125 info->pba_to_lba = NULL; 128 126 ··· 647 649 return -1; 648 650 } 649 651 650 - if (info->lba_to_pba) 651 - kfree(info->lba_to_pba); 652 - if (info->pba_to_lba) 653 - kfree(info->pba_to_lba); 652 + kfree(info->lba_to_pba); 653 + kfree(info->pba_to_lba); 654 654 info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO); 655 655 info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO); 656 656 657 657 if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) { 658 - if (info->lba_to_pba != NULL) 659 - kfree(info->lba_to_pba); 660 - if (info->pba_to_lba != NULL) 661 - kfree(info->pba_to_lba); 658 + kfree(info->lba_to_pba); 659 + kfree(info->pba_to_lba); 662 660 info->lba_to_pba = NULL; 663 661 info->pba_to_lba = NULL; 664 662 kfree(buffer); ··· 722 728 if (!extra) 723 729 return; 724 730 725 - if (info->lba_to_pba) 726 - kfree(info->lba_to_pba); 727 - if (info->pba_to_lba) 728 - kfree(info->pba_to_lba); 731 + kfree(info->lba_to_pba); 732 + kfree(info->pba_to_lba); 729 733 } 730 734 731 735