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

Configure Feed

Select the types of activity you want to include in your feed.

treewide: Convert del_timer*() to timer_shutdown*()

Due to several bugs caused by timers being re-armed after they are
shutdown and just before they are freed, a new state of timers was added
called "shutdown". After a timer is set to this state, then it can no
longer be re-armed.

The following script was run to find all the trivial locations where
del_timer() or del_timer_sync() is called in the same function that the
object holding the timer is freed. It also ignores any locations where
the timer->function is modified between the del_timer*() and the free(),
as that is not considered a "trivial" case.

This was created by using a coccinelle script and the following
commands:

$ cat timer.cocci
@@
expression ptr, slab;
identifier timer, rfield;
@@
(
- del_timer(&ptr->timer);
+ timer_shutdown(&ptr->timer);
|
- del_timer_sync(&ptr->timer);
+ timer_shutdown_sync(&ptr->timer);
)
... when strict
when != ptr->timer
(
kfree_rcu(ptr, rfield);
|
kmem_cache_free(slab, ptr);
|
kfree(ptr);
)

$ spatch timer.cocci . > /tmp/t.patch
$ patch -p1 < /tmp/t.patch

Link: https://lore.kernel.org/lkml/20221123201306.823305113@linutronix.de/
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
Acked-by: Pavel Machek <pavel@ucw.cz> [ LED ]
Acked-by: Kalle Valo <kvalo@kernel.org> [ wireless ]
Acked-by: Paolo Abeni <pabeni@redhat.com> [ networking ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Steven Rostedt (Google) and committed by
Linus Torvalds 292a089d 72a85e2b

+97 -97
+1 -1
arch/sh/drivers/push-switch.c
··· 102 102 103 103 platform_set_drvdata(pdev, NULL); 104 104 flush_work(&psw->work); 105 - del_timer_sync(&psw->debounce); 105 + timer_shutdown_sync(&psw->debounce); 106 106 free_irq(irq, pdev); 107 107 108 108 kfree(psw);
+1 -1
block/blk-iocost.c
··· 2820 2820 ioc->running = IOC_STOP; 2821 2821 spin_unlock_irq(&ioc->lock); 2822 2822 2823 - del_timer_sync(&ioc->timer); 2823 + timer_shutdown_sync(&ioc->timer); 2824 2824 free_percpu(ioc->pcpu_stat); 2825 2825 kfree(ioc); 2826 2826 }
+1 -1
block/blk-iolatency.c
··· 644 644 { 645 645 struct blk_iolatency *blkiolat = BLKIOLATENCY(rqos); 646 646 647 - del_timer_sync(&blkiolat->timer); 647 + timer_shutdown_sync(&blkiolat->timer); 648 648 flush_work(&blkiolat->enable_work); 649 649 blkcg_deactivate_policy(rqos->q, &blkcg_policy_iolatency); 650 650 kfree(blkiolat);
+1 -1
block/kyber-iosched.c
··· 434 434 struct kyber_queue_data *kqd = e->elevator_data; 435 435 int i; 436 436 437 - del_timer_sync(&kqd->timer); 437 + timer_shutdown_sync(&kqd->timer); 438 438 blk_stat_disable_accounting(kqd->q); 439 439 440 440 for (i = 0; i < KYBER_NUM_DOMAINS; i++)
+1 -1
drivers/acpi/apei/ghes.c
··· 1431 1431 ghes->flags |= GHES_EXITING; 1432 1432 switch (generic->notify.type) { 1433 1433 case ACPI_HEST_NOTIFY_POLLED: 1434 - del_timer_sync(&ghes->timer); 1434 + timer_shutdown_sync(&ghes->timer); 1435 1435 break; 1436 1436 case ACPI_HEST_NOTIFY_EXTERNAL: 1437 1437 free_irq(ghes->irq, ghes);
+3 -3
drivers/atm/idt77252.c
··· 2213 2213 } 2214 2214 spin_unlock_irqrestore(&vc->lock, flags); 2215 2215 if (est) { 2216 - del_timer_sync(&est->timer); 2216 + timer_shutdown_sync(&est->timer); 2217 2217 kfree(est); 2218 2218 } 2219 2219 ··· 2530 2530 vc->tx_vcc = NULL; 2531 2531 2532 2532 if (vc->estimator) { 2533 - del_timer(&vc->estimator->timer); 2533 + timer_shutdown(&vc->estimator->timer); 2534 2534 kfree(vc->estimator); 2535 2535 vc->estimator = NULL; 2536 2536 } ··· 3752 3752 card = idt77252_chain; 3753 3753 dev = card->atmdev; 3754 3754 idt77252_chain = card->next; 3755 - del_timer_sync(&card->tst_timer); 3755 + timer_shutdown_sync(&card->tst_timer); 3756 3756 3757 3757 if (dev->phy->stop) 3758 3758 dev->phy->stop(dev);
+1 -1
drivers/block/drbd/drbd_main.c
··· 2184 2184 struct drbd_resource *resource = device->resource; 2185 2185 struct drbd_peer_device *peer_device, *tmp_peer_device; 2186 2186 2187 - del_timer_sync(&device->request_timer); 2187 + timer_shutdown_sync(&device->request_timer); 2188 2188 2189 2189 /* paranoia asserts */ 2190 2190 D_ASSERT(device, device->open_cnt == 0);
+1 -1
drivers/block/loop.c
··· 1755 1755 if (lo->workqueue) 1756 1756 destroy_workqueue(lo->workqueue); 1757 1757 loop_free_idle_workers(lo, true); 1758 - del_timer_sync(&lo->timer); 1758 + timer_shutdown_sync(&lo->timer); 1759 1759 mutex_destroy(&lo->lo_mutex); 1760 1760 kfree(lo); 1761 1761 }
+1 -1
drivers/bluetooth/hci_bcsp.c
··· 737 737 { 738 738 struct bcsp_struct *bcsp = hu->priv; 739 739 740 - del_timer_sync(&bcsp->tbcsp); 740 + timer_shutdown_sync(&bcsp->tbcsp); 741 741 742 742 hu->priv = NULL; 743 743
+1 -1
drivers/gpu/drm/i915/i915_sw_fence.c
··· 465 465 struct i915_sw_dma_fence_cb_timer *cb = 466 466 container_of(wrk, typeof(*cb), work); 467 467 468 - del_timer_sync(&cb->timer); 468 + timer_shutdown_sync(&cb->timer); 469 469 dma_fence_put(cb->dma); 470 470 471 471 kfree_rcu(cb, rcu);
+1 -1
drivers/hid/hid-wiimote-core.c
··· 1771 1771 spin_unlock_irqrestore(&wdata->state.lock, flags); 1772 1772 1773 1773 cancel_work_sync(&wdata->init_worker); 1774 - del_timer_sync(&wdata->timer); 1774 + timer_shutdown_sync(&wdata->timer); 1775 1775 1776 1776 device_remove_file(&wdata->hdev->dev, &dev_attr_devtype); 1777 1777 device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
+1 -1
drivers/input/keyboard/locomokbd.c
··· 310 310 311 311 free_irq(dev->irq[0], locomokbd); 312 312 313 - del_timer_sync(&locomokbd->timer); 313 + timer_shutdown_sync(&locomokbd->timer); 314 314 315 315 input_unregister_device(locomokbd->input); 316 316 locomo_set_drvdata(dev, NULL);
+1 -1
drivers/input/keyboard/omap-keypad.c
··· 296 296 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 297 297 free_irq(omap_kp->irq, omap_kp); 298 298 299 - del_timer_sync(&omap_kp->timer); 299 + timer_shutdown_sync(&omap_kp->timer); 300 300 tasklet_kill(&kp_tasklet); 301 301 302 302 /* unregister everything */
+1 -1
drivers/input/mouse/alps.c
··· 2970 2970 struct alps_data *priv = psmouse->private; 2971 2971 2972 2972 psmouse_reset(psmouse); 2973 - del_timer_sync(&priv->timer); 2973 + timer_shutdown_sync(&priv->timer); 2974 2974 if (priv->dev2) 2975 2975 input_unregister_device(priv->dev2); 2976 2976 if (!IS_ERR_OR_NULL(priv->dev3))
+2 -2
drivers/isdn/mISDN/l1oip_core.c
··· 1236 1236 1237 1237 hc->shutdown = true; 1238 1238 1239 - del_timer_sync(&hc->keep_tl); 1240 - del_timer_sync(&hc->timeout_tl); 1239 + timer_shutdown_sync(&hc->keep_tl); 1240 + timer_shutdown_sync(&hc->timeout_tl); 1241 1241 1242 1242 cancel_work_sync(&hc->workq); 1243 1243
+2 -2
drivers/isdn/mISDN/timerdev.c
··· 74 74 while (!list_empty(list)) { 75 75 timer = list_first_entry(list, struct mISDNtimer, list); 76 76 spin_unlock_irq(&dev->lock); 77 - del_timer_sync(&timer->tl); 77 + timer_shutdown_sync(&timer->tl); 78 78 spin_lock_irq(&dev->lock); 79 79 /* it might have been moved to ->expired */ 80 80 list_del(&timer->list); ··· 204 204 list_del_init(&timer->list); 205 205 timer->id = -1; 206 206 spin_unlock_irq(&dev->lock); 207 - del_timer_sync(&timer->tl); 207 + timer_shutdown_sync(&timer->tl); 208 208 kfree(timer); 209 209 return id; 210 210 }
+1 -1
drivers/leds/trigger/ledtrig-activity.c
··· 208 208 { 209 209 struct activity_data *activity_data = led_get_trigger_data(led_cdev); 210 210 211 - del_timer_sync(&activity_data->timer); 211 + timer_shutdown_sync(&activity_data->timer); 212 212 kfree(activity_data); 213 213 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 214 214 }
+1 -1
drivers/leds/trigger/ledtrig-heartbeat.c
··· 151 151 struct heartbeat_trig_data *heartbeat_data = 152 152 led_get_trigger_data(led_cdev); 153 153 154 - del_timer_sync(&heartbeat_data->timer); 154 + timer_shutdown_sync(&heartbeat_data->timer); 155 155 kfree(heartbeat_data); 156 156 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 157 157 }
+1 -1
drivers/leds/trigger/ledtrig-pattern.c
··· 430 430 if (led_cdev->pattern_clear) 431 431 led_cdev->pattern_clear(led_cdev); 432 432 433 - del_timer_sync(&data->timer); 433 + timer_shutdown_sync(&data->timer); 434 434 435 435 led_set_brightness(led_cdev, LED_OFF); 436 436 kfree(data);
+1 -1
drivers/leds/trigger/ledtrig-transient.c
··· 180 180 { 181 181 struct transient_trig_data *transient_data = led_get_trigger_data(led_cdev); 182 182 183 - del_timer_sync(&transient_data->timer); 183 + timer_shutdown_sync(&transient_data->timer); 184 184 led_set_brightness_nosleep(led_cdev, transient_data->restore_state); 185 185 kfree(transient_data); 186 186 }
+1 -1
drivers/media/pci/ivtv/ivtv-driver.c
··· 1425 1425 1426 1426 /* Interrupts */ 1427 1427 ivtv_set_irq_mask(itv, 0xffffffff); 1428 - del_timer_sync(&itv->dma_timer); 1428 + timer_shutdown_sync(&itv->dma_timer); 1429 1429 1430 1430 /* Kill irq worker */ 1431 1431 kthread_flush_worker(&itv->irq_worker);
+8 -8
drivers/media/usb/pvrusb2/pvrusb2-hdw.c
··· 2605 2605 return hdw; 2606 2606 fail: 2607 2607 if (hdw) { 2608 - del_timer_sync(&hdw->quiescent_timer); 2609 - del_timer_sync(&hdw->decoder_stabilization_timer); 2610 - del_timer_sync(&hdw->encoder_run_timer); 2611 - del_timer_sync(&hdw->encoder_wait_timer); 2608 + timer_shutdown_sync(&hdw->quiescent_timer); 2609 + timer_shutdown_sync(&hdw->decoder_stabilization_timer); 2610 + timer_shutdown_sync(&hdw->encoder_run_timer); 2611 + timer_shutdown_sync(&hdw->encoder_wait_timer); 2612 2612 flush_work(&hdw->workpoll); 2613 2613 v4l2_device_unregister(&hdw->v4l2_dev); 2614 2614 usb_free_urb(hdw->ctl_read_urb); ··· 2668 2668 if (!hdw) return; 2669 2669 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_destroy: hdw=%p",hdw); 2670 2670 flush_work(&hdw->workpoll); 2671 - del_timer_sync(&hdw->quiescent_timer); 2672 - del_timer_sync(&hdw->decoder_stabilization_timer); 2673 - del_timer_sync(&hdw->encoder_run_timer); 2674 - del_timer_sync(&hdw->encoder_wait_timer); 2671 + timer_shutdown_sync(&hdw->quiescent_timer); 2672 + timer_shutdown_sync(&hdw->decoder_stabilization_timer); 2673 + timer_shutdown_sync(&hdw->encoder_run_timer); 2674 + timer_shutdown_sync(&hdw->encoder_wait_timer); 2675 2675 if (hdw->fw_buffer) { 2676 2676 kfree(hdw->fw_buffer); 2677 2677 hdw->fw_buffer = NULL;
+2 -2
drivers/media/usb/s2255/s2255drv.c
··· 1487 1487 /* board shutdown stops the read pipe if it is running */ 1488 1488 s2255_board_shutdown(dev); 1489 1489 /* make sure firmware still not trying to load */ 1490 - del_timer_sync(&dev->timer); /* only started in .probe and .open */ 1490 + timer_shutdown_sync(&dev->timer); /* only started in .probe and .open */ 1491 1491 if (dev->fw_data->fw_urb) { 1492 1492 usb_kill_urb(dev->fw_data->fw_urb); 1493 1493 usb_free_urb(dev->fw_data->fw_urb); ··· 2322 2322 errorFWDATA2: 2323 2323 usb_free_urb(dev->fw_data->fw_urb); 2324 2324 errorFWURB: 2325 - del_timer_sync(&dev->timer); 2325 + timer_shutdown_sync(&dev->timer); 2326 2326 errorEP: 2327 2327 usb_put_dev(dev->udev); 2328 2328 errorUDEV:
+3 -3
drivers/net/ethernet/intel/i40e/i40e_main.c
··· 15586 15586 15587 15587 err_switch_setup: 15588 15588 i40e_reset_interrupt_capability(pf); 15589 - del_timer_sync(&pf->service_timer); 15589 + timer_shutdown_sync(&pf->service_timer); 15590 15590 i40e_shutdown_adminq(hw); 15591 15591 iounmap(hw->hw_addr); 15592 15592 pci_disable_pcie_error_reporting(pf->pdev); ··· 16205 16205 kfree(pf->vsi); 16206 16206 err_switch_setup: 16207 16207 i40e_reset_interrupt_capability(pf); 16208 - del_timer_sync(&pf->service_timer); 16208 + timer_shutdown_sync(&pf->service_timer); 16209 16209 err_mac_addr: 16210 16210 err_configure_lan_hmc: 16211 16211 (void)i40e_shutdown_lan_hmc(hw); ··· 16267 16267 set_bit(__I40E_SUSPENDED, pf->state); 16268 16268 set_bit(__I40E_DOWN, pf->state); 16269 16269 if (pf->service_timer.function) 16270 - del_timer_sync(&pf->service_timer); 16270 + timer_shutdown_sync(&pf->service_timer); 16271 16271 if (pf->service_task.func) 16272 16272 cancel_work_sync(&pf->service_task); 16273 16273
+1 -1
drivers/net/ethernet/marvell/sky2.c
··· 5013 5013 if (!hw) 5014 5014 return; 5015 5015 5016 - del_timer_sync(&hw->watchdog_timer); 5016 + timer_shutdown_sync(&hw->watchdog_timer); 5017 5017 cancel_work_sync(&hw->restart_work); 5018 5018 5019 5019 for (i = hw->ports-1; i >= 0; --i)
+1 -1
drivers/net/ethernet/sun/sunvnet.c
··· 524 524 hlist_del_rcu(&port->hash); 525 525 526 526 synchronize_rcu(); 527 - del_timer_sync(&port->clean_timer); 527 + timer_shutdown_sync(&port->clean_timer); 528 528 sunvnet_port_rm_txq_common(port); 529 529 netif_napi_del(&port->napi); 530 530 sunvnet_port_free_tx_bufs_common(port);
+1 -1
drivers/net/usb/sierra_net.c
··· 759 759 dev_dbg(&dev->udev->dev, "%s", __func__); 760 760 761 761 /* kill the timer and work */ 762 - del_timer_sync(&priv->sync_timer); 762 + timer_shutdown_sync(&priv->sync_timer); 763 763 cancel_work_sync(&priv->sierra_net_kevent); 764 764 765 765 /* tell modem we are going away */
+1 -1
drivers/net/wireless/broadcom/brcm80211/brcmfmac/btcoex.c
··· 394 394 395 395 if (cfg->btcoex->timer_on) { 396 396 cfg->btcoex->timer_on = false; 397 - del_timer_sync(&cfg->btcoex->timer); 397 + timer_shutdown_sync(&cfg->btcoex->timer); 398 398 } 399 399 400 400 cancel_work_sync(&cfg->btcoex->work);
+1 -1
drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
··· 371 371 struct iwl_dbg_tlv_timer_node *node, *tmp; 372 372 373 373 list_for_each_entry_safe(node, tmp, timer_list, list) { 374 - del_timer_sync(&node->timer); 374 + timer_shutdown_sync(&node->timer); 375 375 list_del(&node->list); 376 376 kfree(node); 377 377 }
+1 -1
drivers/net/wireless/intel/iwlwifi/mvm/sta.c
··· 2835 2835 2836 2836 /* synchronize all rx queues so we can safely delete */ 2837 2837 iwl_mvm_free_reorder(mvm, baid_data); 2838 - del_timer_sync(&baid_data->session_timer); 2838 + timer_shutdown_sync(&baid_data->session_timer); 2839 2839 RCU_INIT_POINTER(mvm->baid_map[baid], NULL); 2840 2840 kfree_rcu(baid_data, rcu_head); 2841 2841 IWL_DEBUG_HT(mvm, "BAID %d is free\n", baid);
+1 -1
drivers/net/wireless/intersil/hostap/hostap_ap.c
··· 135 135 136 136 if (!sta->ap) 137 137 kfree(sta->u.sta.challenge); 138 - del_timer_sync(&sta->timer); 138 + timer_shutdown_sync(&sta->timer); 139 139 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */ 140 140 141 141 kfree(sta);
+1 -1
drivers/net/wireless/marvell/mwifiex/main.c
··· 123 123 if (adapter->if_ops.cleanup_if) 124 124 adapter->if_ops.cleanup_if(adapter); 125 125 126 - del_timer_sync(&adapter->cmd_timer); 126 + timer_shutdown_sync(&adapter->cmd_timer); 127 127 128 128 /* Free private structures */ 129 129 for (i = 0; i < adapter->priv_num; i++) {
+3 -3
drivers/net/wireless/microchip/wilc1000/hif.c
··· 1531 1531 1532 1532 mutex_lock(&vif->wilc->deinit_lock); 1533 1533 1534 - del_timer_sync(&hif_drv->scan_timer); 1535 - del_timer_sync(&hif_drv->connect_timer); 1534 + timer_shutdown_sync(&hif_drv->scan_timer); 1535 + timer_shutdown_sync(&hif_drv->connect_timer); 1536 1536 del_timer_sync(&vif->periodic_rssi); 1537 - del_timer_sync(&hif_drv->remain_on_ch_timer); 1537 + timer_shutdown_sync(&hif_drv->remain_on_ch_timer); 1538 1538 1539 1539 if (hif_drv->usr_scan_req.scan_result) { 1540 1540 hif_drv->usr_scan_req.scan_result(SCAN_EVENT_ABORTED, NULL,
+1 -1
drivers/nfc/pn533/pn533.c
··· 2792 2792 struct pn533_cmd *cmd, *n; 2793 2793 2794 2794 /* delete the timer before cleanup the worker */ 2795 - del_timer_sync(&priv->listen_timer); 2795 + timer_shutdown_sync(&priv->listen_timer); 2796 2796 2797 2797 flush_delayed_work(&priv->poll_work); 2798 2798 destroy_workqueue(priv->wq);
+1 -1
drivers/nfc/pn533/uart.c
··· 310 310 pn53x_unregister_nfc(pn532->priv); 311 311 serdev_device_close(serdev); 312 312 pn53x_common_clean(pn532->priv); 313 - del_timer_sync(&pn532->cmd_timeout); 313 + timer_shutdown_sync(&pn532->cmd_timeout); 314 314 kfree_skb(pn532->recv_skb); 315 315 kfree(pn532); 316 316 }
+1 -1
drivers/pcmcia/bcm63xx_pcmcia.c
··· 443 443 struct resource *res; 444 444 445 445 skt = platform_get_drvdata(pdev); 446 - del_timer_sync(&skt->timer); 446 + timer_shutdown_sync(&skt->timer); 447 447 iounmap(skt->base); 448 448 iounmap(skt->io_base); 449 449 res = skt->reg_res;
+1 -1
drivers/pcmcia/electra_cf.c
··· 317 317 cf->active = 0; 318 318 pcmcia_unregister_socket(&cf->socket); 319 319 free_irq(cf->irq, cf); 320 - del_timer_sync(&cf->timer); 320 + timer_shutdown_sync(&cf->timer); 321 321 322 322 iounmap(cf->io_virt); 323 323 iounmap(cf->mem_base);
+1 -1
drivers/pcmcia/omap_cf.c
··· 296 296 297 297 cf->active = 0; 298 298 pcmcia_unregister_socket(&cf->socket); 299 - del_timer_sync(&cf->timer); 299 + timer_shutdown_sync(&cf->timer); 300 300 release_mem_region(cf->phys_cf, SZ_8K); 301 301 free_irq(cf->irq, cf); 302 302 kfree(cf);
+2 -2
drivers/pcmcia/pd6729.c
··· 727 727 if (irq_mode == 1) 728 728 free_irq(dev->irq, socket); 729 729 else 730 - del_timer_sync(&socket->poll_timer); 730 + timer_shutdown_sync(&socket->poll_timer); 731 731 err_out_free_res: 732 732 pci_release_regions(dev); 733 733 err_out_disable: ··· 754 754 if (irq_mode == 1) 755 755 free_irq(dev->irq, socket); 756 756 else 757 - del_timer_sync(&socket->poll_timer); 757 + timer_shutdown_sync(&socket->poll_timer); 758 758 pci_release_regions(dev); 759 759 pci_disable_device(dev); 760 760
+2 -2
drivers/pcmcia/yenta_socket.c
··· 814 814 if (sock->cb_irq) 815 815 free_irq(sock->cb_irq, sock); 816 816 else 817 - del_timer_sync(&sock->poll_timer); 817 + timer_shutdown_sync(&sock->poll_timer); 818 818 819 819 iounmap(sock->base); 820 820 yenta_free_resources(sock); ··· 1285 1285 if (socket->cb_irq) 1286 1286 free_irq(socket->cb_irq, socket); 1287 1287 else 1288 - del_timer_sync(&socket->poll_timer); 1288 + timer_shutdown_sync(&socket->poll_timer); 1289 1289 unmap: 1290 1290 iounmap(socket->base); 1291 1291 yenta_free_resources(socket);
+2 -2
drivers/scsi/qla2xxx/qla_edif.c
··· 416 416 */ 417 417 if (edif_entry->delete_sa_index != 418 418 INVALID_EDIF_SA_INDEX) { 419 - del_timer(&edif_entry->timer); 419 + timer_shutdown(&edif_entry->timer); 420 420 421 421 /* build and send the aen */ 422 422 fcport->edif.rx_sa_set = 1; ··· 2799 2799 "%s: removing edif_entry %p, new sa_index: 0x%x\n", 2800 2800 __func__, edif_entry, pkt->sa_index); 2801 2801 qla_edif_list_delete_sa_index(sp->fcport, edif_entry); 2802 - del_timer(&edif_entry->timer); 2802 + timer_shutdown(&edif_entry->timer); 2803 2803 2804 2804 ql_dbg(ql_dbg_edif, vha, 0x5033, 2805 2805 "%s: releasing edif_entry %p, new sa_index: 0x%x\n",
+1 -1
drivers/staging/media/atomisp/i2c/atomisp-lm3554.c
··· 921 921 922 922 atomisp_gmin_remove_subdev(sd); 923 923 924 - del_timer_sync(&flash->flash_off_delay); 924 + timer_shutdown_sync(&flash->flash_off_delay); 925 925 926 926 lm3554_gpio_uninit(client); 927 927
+3 -3
drivers/staging/wlan-ng/prism2usb.c
··· 170 170 */ 171 171 prism2sta_ifstate(wlandev, P80211ENUM_ifstate_disable); 172 172 173 - del_timer_sync(&hw->throttle); 174 - del_timer_sync(&hw->reqtimer); 175 - del_timer_sync(&hw->resptimer); 173 + timer_shutdown_sync(&hw->throttle); 174 + timer_shutdown_sync(&hw->reqtimer); 175 + timer_shutdown_sync(&hw->resptimer); 176 176 177 177 /* Unlink all the URBs. This "removes the wheels" 178 178 * from the entire CTLX handling mechanism.
+1 -1
drivers/tty/n_gsm.c
··· 2444 2444 { 2445 2445 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port); 2446 2446 2447 - del_timer_sync(&dlci->t1); 2447 + timer_shutdown_sync(&dlci->t1); 2448 2448 dlci->gsm->dlci[dlci->addr] = NULL; 2449 2449 kfifo_free(&dlci->fifo); 2450 2450 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
+1 -1
drivers/tty/sysrq.c
··· 1003 1003 1004 1004 input_close_device(handle); 1005 1005 cancel_work_sync(&sysrq->reinject_work); 1006 - del_timer_sync(&sysrq->keyreset_timer); 1006 + timer_shutdown_sync(&sysrq->keyreset_timer); 1007 1007 input_unregister_handle(handle); 1008 1008 kfree(sysrq); 1009 1009 }
+1 -1
drivers/usb/gadget/udc/m66592-udc.c
··· 1519 1519 1520 1520 usb_del_gadget_udc(&m66592->gadget); 1521 1521 1522 - del_timer_sync(&m66592->timer); 1522 + timer_shutdown_sync(&m66592->timer); 1523 1523 iounmap(m66592->reg); 1524 1524 free_irq(platform_get_irq(pdev, 0), m66592); 1525 1525 m66592_free_request(&m66592->ep[0].ep, m66592->ep0_req);
+1 -1
drivers/usb/serial/garmin_gps.c
··· 1405 1405 1406 1406 usb_kill_anchored_urbs(&garmin_data_p->write_urbs); 1407 1407 usb_kill_urb(port->interrupt_in_urb); 1408 - del_timer_sync(&garmin_data_p->timer); 1408 + timer_shutdown_sync(&garmin_data_p->timer); 1409 1409 kfree(garmin_data_p); 1410 1410 } 1411 1411
+2 -2
drivers/usb/serial/mos7840.c
··· 1725 1725 /* Turn off LED */ 1726 1726 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300); 1727 1727 1728 - del_timer_sync(&mos7840_port->led_timer1); 1729 - del_timer_sync(&mos7840_port->led_timer2); 1728 + timer_shutdown_sync(&mos7840_port->led_timer1); 1729 + timer_shutdown_sync(&mos7840_port->led_timer2); 1730 1730 1731 1731 usb_kill_urb(mos7840_port->led_urb); 1732 1732 usb_free_urb(mos7840_port->led_urb);
+1 -1
fs/ext4/super.c
··· 1225 1225 } 1226 1226 1227 1227 ext4_es_unregister_shrinker(sbi); 1228 - del_timer_sync(&sbi->s_err_report); 1228 + timer_shutdown_sync(&sbi->s_err_report); 1229 1229 ext4_release_system_zone(sb); 1230 1230 ext4_mb_release(sb); 1231 1231 ext4_ext_release(sb);
+1 -1
fs/nilfs2/segment.c
··· 2752 2752 2753 2753 down_write(&nilfs->ns_segctor_sem); 2754 2754 2755 - del_timer_sync(&sci->sc_timer); 2755 + timer_shutdown_sync(&sci->sc_timer); 2756 2756 kfree(sci); 2757 2757 } 2758 2758
+1 -1
net/802/garp.c
··· 618 618 619 619 /* Delete timer and generate a final TRANSMIT_PDU event to flush out 620 620 * all pending messages before the applicant is gone. */ 621 - del_timer_sync(&app->join_timer); 621 + timer_shutdown_sync(&app->join_timer); 622 622 623 623 spin_lock_bh(&app->lock); 624 624 garp_gid_event(app, GARP_EVENT_TRANSMIT_PDU);
+2 -2
net/802/mrp.c
··· 911 911 /* Delete timer and generate a final TX event to flush out 912 912 * all pending messages before the applicant is gone. 913 913 */ 914 - del_timer_sync(&app->join_timer); 915 - del_timer_sync(&app->periodic_timer); 914 + timer_shutdown_sync(&app->join_timer); 915 + timer_shutdown_sync(&app->periodic_timer); 916 916 917 917 spin_lock_bh(&app->lock); 918 918 mrp_mad_event(app, MRP_EVENT_TX);
+4 -4
net/bridge/br_multicast.c
··· 606 606 WARN_ON(!hlist_unhashed(&mp->mdb_node)); 607 607 WARN_ON(mp->ports); 608 608 609 - del_timer_sync(&mp->timer); 609 + timer_shutdown_sync(&mp->timer); 610 610 kfree_rcu(mp, rcu); 611 611 } 612 612 ··· 647 647 src = container_of(gc, struct net_bridge_group_src, mcast_gc); 648 648 WARN_ON(!hlist_unhashed(&src->node)); 649 649 650 - del_timer_sync(&src->timer); 650 + timer_shutdown_sync(&src->timer); 651 651 kfree_rcu(src, rcu); 652 652 } 653 653 ··· 676 676 WARN_ON(!hlist_unhashed(&pg->mglist)); 677 677 WARN_ON(!hlist_empty(&pg->src_list)); 678 678 679 - del_timer_sync(&pg->rexmit_timer); 680 - del_timer_sync(&pg->timer); 679 + timer_shutdown_sync(&pg->rexmit_timer); 680 + timer_shutdown_sync(&pg->timer); 681 681 kfree_rcu(pg, rcu); 682 682 } 683 683
+2 -2
net/bridge/br_multicast_eht.c
··· 142 142 set_h = container_of(gc, struct net_bridge_group_eht_set_entry, mcast_gc); 143 143 WARN_ON(!RB_EMPTY_NODE(&set_h->rb_node)); 144 144 145 - del_timer_sync(&set_h->timer); 145 + timer_shutdown_sync(&set_h->timer); 146 146 kfree(set_h); 147 147 } 148 148 ··· 154 154 WARN_ON(!RB_EMPTY_NODE(&eht_set->rb_node)); 155 155 WARN_ON(!RB_EMPTY_ROOT(&eht_set->entry_tree)); 156 156 157 - del_timer_sync(&eht_set->timer); 157 + timer_shutdown_sync(&eht_set->timer); 158 158 kfree(eht_set); 159 159 } 160 160
+1 -1
net/core/gen_estimator.c
··· 208 208 209 209 est = xchg((__force struct net_rate_estimator **)rate_est, NULL); 210 210 if (est) { 211 - del_timer_sync(&est->timer); 211 + timer_shutdown_sync(&est->timer); 212 212 kfree_rcu(est, rcu); 213 213 } 214 214 }
+1 -1
net/ipv4/ipmr.c
··· 412 412 413 413 static void ipmr_free_table(struct mr_table *mrt) 414 414 { 415 - del_timer_sync(&mrt->ipmr_expire_timer); 415 + timer_shutdown_sync(&mrt->ipmr_expire_timer); 416 416 mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC | 417 417 MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC); 418 418 rhltable_destroy(&mrt->mfc_hash);
+1 -1
net/ipv6/ip6mr.c
··· 392 392 393 393 static void ip6mr_free_table(struct mr_table *mrt) 394 394 { 395 - del_timer_sync(&mrt->ipmr_expire_timer); 395 + timer_shutdown_sync(&mrt->ipmr_expire_timer); 396 396 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC | 397 397 MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC); 398 398 rhltable_destroy(&mrt->mfc_hash);
+1 -1
net/mac80211/mesh_pathtbl.c
··· 512 512 mpath->flags |= MESH_PATH_RESOLVING | MESH_PATH_DELETED; 513 513 mesh_gate_del(tbl, mpath); 514 514 spin_unlock_bh(&mpath->state_lock); 515 - del_timer_sync(&mpath->timer); 515 + timer_shutdown_sync(&mpath->timer); 516 516 atomic_dec(&sdata->u.mesh.mpaths); 517 517 atomic_dec(&tbl->entries); 518 518 mesh_path_flush_pending(mpath);
+1 -1
net/netfilter/ipset/ip_set_list_set.c
··· 427 427 struct set_elem *e, *n; 428 428 429 429 if (SET_WITH_TIMEOUT(set)) 430 - del_timer_sync(&map->gc); 430 + timer_shutdown_sync(&map->gc); 431 431 432 432 list_for_each_entry_safe(e, n, &map->members, list) { 433 433 list_del(&e->list);
+1 -1
net/netfilter/ipvs/ip_vs_lblc.c
··· 384 384 struct ip_vs_lblc_table *tbl = svc->sched_data; 385 385 386 386 /* remove periodic timer */ 387 - del_timer_sync(&tbl->periodic_timer); 387 + timer_shutdown_sync(&tbl->periodic_timer); 388 388 389 389 /* got to clean up table entries here */ 390 390 ip_vs_lblc_flush(svc);
+1 -1
net/netfilter/ipvs/ip_vs_lblcr.c
··· 547 547 struct ip_vs_lblcr_table *tbl = svc->sched_data; 548 548 549 549 /* remove periodic timer */ 550 - del_timer_sync(&tbl->periodic_timer); 550 + timer_shutdown_sync(&tbl->periodic_timer); 551 551 552 552 /* got to clean up table entries here */ 553 553 ip_vs_lblcr_flush(svc);
+2 -2
net/netfilter/xt_IDLETIMER.c
··· 413 413 pr_debug("deleting timer %s\n", info->label); 414 414 415 415 list_del(&info->timer->entry); 416 - del_timer_sync(&info->timer->timer); 416 + timer_shutdown_sync(&info->timer->timer); 417 417 cancel_work_sync(&info->timer->work); 418 418 sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr); 419 419 kfree(info->timer->attr.attr.name); ··· 441 441 if (info->timer->timer_type & XT_IDLETIMER_ALARM) { 442 442 alarm_cancel(&info->timer->alarm); 443 443 } else { 444 - del_timer_sync(&info->timer->timer); 444 + timer_shutdown_sync(&info->timer->timer); 445 445 } 446 446 cancel_work_sync(&info->timer->work); 447 447 sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);
+1 -1
net/netfilter/xt_LED.c
··· 166 166 167 167 list_del(&ledinternal->list); 168 168 169 - del_timer_sync(&ledinternal->timer); 169 + timer_shutdown_sync(&ledinternal->timer); 170 170 171 171 led_trigger_unregister(&ledinternal->netfilter_led_trigger); 172 172
+1 -1
net/sched/cls_flow.c
··· 369 369 370 370 static void __flow_destroy_filter(struct flow_filter *f) 371 371 { 372 - del_timer_sync(&f->perturb_timer); 372 + timer_shutdown_sync(&f->perturb_timer); 373 373 tcf_exts_destroy(&f->exts); 374 374 tcf_em_tree_destroy(&f->ematches); 375 375 tcf_exts_put_net(&f->exts);
+1 -1
net/sunrpc/svc.c
··· 567 567 struct svc_serv *serv = container_of(ref, struct svc_serv, sv_refcnt); 568 568 569 569 dprintk("svc: svc_destroy(%s)\n", serv->sv_program->pg_name); 570 - del_timer_sync(&serv->sv_temptimer); 570 + timer_shutdown_sync(&serv->sv_temptimer); 571 571 572 572 /* 573 573 * The last user is gone and thus all sockets have to be destroyed to
+1 -1
net/tipc/discover.c
··· 388 388 */ 389 389 void tipc_disc_delete(struct tipc_discoverer *d) 390 390 { 391 - del_timer_sync(&d->timer); 391 + timer_shutdown_sync(&d->timer); 392 392 kfree_skb(d->skb); 393 393 kfree(d); 394 394 }
+1 -1
net/tipc/monitor.c
··· 700 700 } 701 701 mon->self = NULL; 702 702 write_unlock_bh(&mon->lock); 703 - del_timer_sync(&mon->timer); 703 + timer_shutdown_sync(&mon->timer); 704 704 kfree(self->domain); 705 705 kfree(self); 706 706 kfree(mon);
+1 -1
sound/i2c/other/ak4117.c
··· 47 47 48 48 static void snd_ak4117_free(struct ak4117 *chip) 49 49 { 50 - del_timer_sync(&chip->timer); 50 + timer_shutdown_sync(&chip->timer); 51 51 kfree(chip); 52 52 } 53 53
+1 -1
sound/synth/emux/emux.c
··· 129 129 if (! emu) 130 130 return -EINVAL; 131 131 132 - del_timer_sync(&emu->tlist); 132 + timer_shutdown_sync(&emu->tlist); 133 133 134 134 snd_emux_proc_free(emu); 135 135 snd_emux_delete_virmidi(emu);