+2 -1

arch/alpha/kernel/srmcons.c

reviewed

··· 69 69 static void 70 70 srmcons_receive_chars(struct timer_list *t) 71 71 { 72 72 - struct srmcons_private *srmconsp = from_timer(srmconsp, t, timer); 72 72 + struct srmcons_private *srmconsp = timer_container_of(srmconsp, t, 73 73 + timer); 73 74 struct tty_port *port = &srmconsp->port; 74 75 unsigned long flags; 75 76 int incr = 10;

+1 -1

arch/powerpc/kvm/booke.c

reviewed

··· 628 628 629 629 static void kvmppc_watchdog_func(struct timer_list *t) 630 630 { 631 631 - struct kvm_vcpu *vcpu = from_timer(vcpu, t, arch.wdt_timer); 631 631 + struct kvm_vcpu *vcpu = timer_container_of(vcpu, t, arch.wdt_timer); 632 632 u32 tsr, new_tsr; 633 633 int final; 634 634

+2 -1

arch/powerpc/platforms/powermac/low_i2c.c

reviewed

··· 359 359 360 360 static void kw_i2c_timeout(struct timer_list *t) 361 361 { 362 362 - struct pmac_i2c_host_kw *host = from_timer(host, t, timeout_timer); 362 362 + struct pmac_i2c_host_kw *host = timer_container_of(host, t, 363 363 + timeout_timer); 363 364 unsigned long flags; 364 365 365 366 spin_lock_irqsave(&host->lock, flags);

+1 -1

arch/sh/drivers/heartbeat.c

reviewed

··· 58 58 59 59 static void heartbeat_timer(struct timer_list *t) 60 60 { 61 61 - struct heartbeat_data *hd = from_timer(hd, t, timer); 61 61 + struct heartbeat_data *hd = timer_container_of(hd, t, timer); 62 62 static unsigned bit = 0, up = 1; 63 63 64 64 heartbeat_toggle_bit(hd, bit, hd->flags & HEARTBEAT_INVERTED);

+2 -2

arch/sh/drivers/pci/common.c

reviewed

··· 88 88 89 89 static void pcibios_enable_err(struct timer_list *t) 90 90 { 91 91 - struct pci_channel *hose = from_timer(hose, t, err_timer); 91 91 + struct pci_channel *hose = timer_container_of(hose, t, err_timer); 92 92 93 93 timer_delete(&hose->err_timer); 94 94 printk(KERN_DEBUG "PCI: re-enabling error IRQ.\n"); ··· 97 97 98 98 static void pcibios_enable_serr(struct timer_list *t) 99 99 { 100 100 - struct pci_channel *hose = from_timer(hose, t, serr_timer); 100 100 + struct pci_channel *hose = timer_container_of(hose, t, serr_timer); 101 101 102 102 timer_delete(&hose->serr_timer); 103 103 printk(KERN_DEBUG "PCI: re-enabling system error IRQ.\n");

+1 -1

arch/sh/drivers/push-switch.c

reviewed

··· 25 25 26 26 static void switch_timer(struct timer_list *t) 27 27 { 28 28 - struct push_switch *psw = from_timer(psw, t, debounce); 28 28 + struct push_switch *psw = timer_container_of(psw, t, debounce); 29 29 30 30 schedule_work(&psw->work); 31 31 }

+1 -1

arch/sparc/kernel/viohs.c

reviewed

··· 804 804 805 805 static void vio_port_timer(struct timer_list *t) 806 806 { 807 807 - struct vio_driver_state *vio = from_timer(vio, t, timer); 807 807 + struct vio_driver_state *vio = timer_container_of(vio, t, timer); 808 808 809 809 vio_port_up(vio); 810 810 }

+1 -1

arch/um/drivers/vector_kern.c

reviewed

··· 1534 1534 1535 1535 static void vector_timer_expire(struct timer_list *t) 1536 1536 { 1537 1537 - struct vector_private *vp = from_timer(vp, t, tl); 1537 1537 + struct vector_private *vp = timer_container_of(vp, t, tl); 1538 1538 1539 1539 vp->estats.tx_kicks++; 1540 1540 napi_schedule(&vp->napi);

+2 -1

arch/x86/kvm/xen.c

reviewed

··· 1571 1571 1572 1572 static void cancel_evtchn_poll(struct timer_list *t) 1573 1573 { 1574 1574 - struct kvm_vcpu *vcpu = from_timer(vcpu, t, arch.xen.poll_timer); 1574 1574 + struct kvm_vcpu *vcpu = timer_container_of(vcpu, t, 1575 1575 + arch.xen.poll_timer); 1575 1576 1576 1577 kvm_make_request(KVM_REQ_UNBLOCK, vcpu); 1577 1578 kvm_vcpu_kick(vcpu);

+1 -1

arch/xtensa/platforms/iss/network.c

reviewed

··· 338 338 339 339 static void iss_net_timer(struct timer_list *t) 340 340 { 341 341 - struct iss_net_private *lp = from_timer(lp, t, timer); 341 341 + struct iss_net_private *lp = timer_container_of(lp, t, timer); 342 342 343 343 iss_net_poll(lp); 344 344 mod_timer(&lp->timer, jiffies + lp->timer_val);

+1 -1

block/blk-core.c

reviewed

··· 381 381 382 382 static void blk_rq_timed_out_timer(struct timer_list *t) 383 383 { 384 384 - struct request_queue *q = from_timer(q, t, timeout); 384 384 + struct request_queue *q = timer_container_of(q, t, timeout); 385 385 386 386 kblockd_schedule_work(&q->timeout_work); 387 387 }

+2 -1

block/blk-iolatency.c

reviewed

··· 658 658 659 659 static void blkiolatency_timer_fn(struct timer_list *t) 660 660 { 661 661 - struct blk_iolatency *blkiolat = from_timer(blkiolat, t, timer); 661 661 + struct blk_iolatency *blkiolat = timer_container_of(blkiolat, t, 662 662 + timer); 662 663 struct blkcg_gq *blkg; 663 664 struct cgroup_subsys_state *pos_css; 664 665 u64 now = blk_time_get_ns();

+1 -1

block/blk-stat.c

reviewed

··· 76 76 77 77 static void blk_stat_timer_fn(struct timer_list *t) 78 78 { 79 79 - struct blk_stat_callback *cb = from_timer(cb, t, timer); 79 79 + struct blk_stat_callback *cb = timer_container_of(cb, t, timer); 80 80 unsigned int bucket; 81 81 int cpu; 82 82

+2 -1

block/blk-throttle.c

reviewed

··· 1125 1125 */ 1126 1126 static void throtl_pending_timer_fn(struct timer_list *t) 1127 1127 { 1128 1128 - struct throtl_service_queue *sq = from_timer(sq, t, pending_timer); 1128 1128 + struct throtl_service_queue *sq = timer_container_of(sq, t, 1129 1129 + pending_timer); 1129 1130 struct throtl_grp *tg = sq_to_tg(sq); 1130 1131 struct throtl_data *td = sq_to_td(sq); 1131 1132 struct throtl_service_queue *parent_sq;

+1 -1

block/kyber-iosched.c

reviewed

··· 276 276 277 277 static void kyber_timer_fn(struct timer_list *t) 278 278 { 279 279 - struct kyber_queue_data *kqd = from_timer(kqd, t, timer); 279 279 + struct kyber_queue_data *kqd = timer_container_of(kqd, t, timer); 280 280 unsigned int sched_domain; 281 281 int cpu; 282 282 bool bad = false;

+1 -1

drivers/accel/qaic/qaic_timesync.c

reviewed

··· 129 129 130 130 static void qaic_timesync_timer(struct timer_list *t) 131 131 { 132 132 - struct mqts_dev *mqtsdev = from_timer(mqtsdev, t, timer); 132 132 + struct mqts_dev *mqtsdev = timer_container_of(mqtsdev, t, timer); 133 133 struct qts_host_time_sync_msg_data *sync_msg; 134 134 u64 device_qtimer_us; 135 135 u64 device_qtimer;

+1 -1

drivers/acpi/apei/ghes.c

reviewed

··· 1138 1138 1139 1139 static void ghes_poll_func(struct timer_list *t) 1140 1140 { 1141 1141 - struct ghes *ghes = from_timer(ghes, t, timer); 1141 1141 + struct ghes *ghes = timer_container_of(ghes, t, timer); 1142 1142 unsigned long flags; 1143 1143 1144 1144 spin_lock_irqsave(&ghes_notify_lock_irq, flags);

+1 -1

drivers/ata/libahci.c

reviewed

··· 1034 1034 1035 1035 static void ahci_sw_activity_blink(struct timer_list *t) 1036 1036 { 1037 1037 - struct ahci_em_priv *emp = from_timer(emp, t, timer); 1037 1037 + struct ahci_em_priv *emp = timer_container_of(emp, t, timer); 1038 1038 struct ata_link *link = emp->link; 1039 1039 struct ata_port *ap = link->ap; 1040 1040

+1 -1

drivers/ata/libata-eh.c

reviewed

··· 860 860 861 861 void ata_eh_fastdrain_timerfn(struct timer_list *t) 862 862 { 863 863 - struct ata_port *ap = from_timer(ap, t, fastdrain_timer); 863 863 + struct ata_port *ap = timer_container_of(ap, t, fastdrain_timer); 864 864 unsigned long flags; 865 865 unsigned int cnt; 866 866

+2 -2

drivers/atm/idt77252.c

reviewed

··· 1531 1531 static void 1532 1532 tst_timer(struct timer_list *t) 1533 1533 { 1534 1534 - struct idt77252_dev *card = from_timer(card, t, tst_timer); 1534 1534 + struct idt77252_dev *card = timer_container_of(card, t, tst_timer); 1535 1535 unsigned long base, idle, jump; 1536 1536 unsigned long flags; 1537 1537 u32 pc; ··· 2070 2070 static void 2071 2071 idt77252_est_timer(struct timer_list *t) 2072 2072 { 2073 2073 - struct rate_estimator *est = from_timer(est, t, timer); 2073 2073 + struct rate_estimator *est = timer_container_of(est, t, timer); 2074 2074 struct vc_map *vc = est->vc; 2075 2075 struct idt77252_dev *card = vc->card; 2076 2076 unsigned long flags;

+1 -1

drivers/atm/lanai.c

reviewed

··· 1758 1758 1759 1759 static void lanai_timed_poll(struct timer_list *t) 1760 1760 { 1761 1761 - struct lanai_dev *lanai = from_timer(lanai, t, timer); 1761 1761 + struct lanai_dev *lanai = timer_container_of(lanai, t, timer); 1762 1762 #ifndef DEBUG_RW 1763 1763 unsigned long flags; 1764 1764 #ifdef USE_POWERDOWN

+1 -1

drivers/auxdisplay/line-display.c

reviewed

··· 40 40 */ 41 41 static void linedisp_scroll(struct timer_list *t) 42 42 { 43 43 - struct linedisp *linedisp = from_timer(linedisp, t, timer); 43 43 + struct linedisp *linedisp = timer_container_of(linedisp, t, timer); 44 44 unsigned int i, ch = linedisp->scroll_pos; 45 45 unsigned int num_chars = linedisp->num_chars; 46 46

+1 -1

drivers/base/power/main.c

reviewed

··· 513 513 */ 514 514 static void dpm_watchdog_handler(struct timer_list *t) 515 515 { 516 516 - struct dpm_watchdog *wd = from_timer(wd, t, timer); 516 516 + struct dpm_watchdog *wd = timer_container_of(wd, t, timer); 517 517 struct timer_list *timer = &wd->timer; 518 518 unsigned int time_left; 519 519

+1 -1

drivers/base/power/wakeup.c

reviewed

··· 759 759 */ 760 760 static void pm_wakeup_timer_fn(struct timer_list *t) 761 761 { 762 762 - struct wakeup_source *ws = from_timer(ws, t, timer); 762 762 + struct wakeup_source *ws = timer_container_of(ws, t, timer); 763 763 unsigned long flags; 764 764 765 765 spin_lock_irqsave(&ws->lock, flags);

+1 -1

drivers/block/aoe/aoecmd.c

reviewed

··· 745 745 int utgts; /* number of aoetgt descriptors (not slots) */ 746 746 int since; 747 747 748 748 - d = from_timer(d, timer, timer); 748 748 + d = timer_container_of(d, timer, timer); 749 749 750 750 spin_lock_irqsave(&d->lock, flags); 751 751

+1 -1

drivers/block/aoe/aoedev.c

reviewed

··· 149 149 { 150 150 struct aoedev *d; 151 151 152 152 - d = from_timer(d, t, timer); 152 152 + d = timer_container_of(d, t, timer); 153 153 if (d->flags & DEVFL_TKILL) 154 154 return; 155 155 d->timer.expires = jiffies + HZ;

+2 -1

drivers/block/drbd/drbd_main.c

reviewed

··· 3591 3591 3592 3592 static void md_sync_timer_fn(struct timer_list *t) 3593 3593 { 3594 3594 - struct drbd_device *device = from_timer(device, t, md_sync_timer); 3594 3594 + struct drbd_device *device = timer_container_of(device, t, 3595 3595 + md_sync_timer); 3595 3596 drbd_device_post_work(device, MD_SYNC); 3596 3597 } 3597 3598

+2 -1

drivers/block/drbd/drbd_req.c

reviewed

··· 1699 1699 1700 1700 void request_timer_fn(struct timer_list *t) 1701 1701 { 1702 1702 - struct drbd_device *device = from_timer(device, t, request_timer); 1702 1702 + struct drbd_device *device = timer_container_of(device, t, 1703 1703 + request_timer); 1703 1704 struct drbd_connection *connection = first_peer_device(device)->connection; 1704 1705 struct drbd_request *req_read, *req_write, *req_peer; /* oldest request */ 1705 1706 struct net_conf *nc;

+4 -2

drivers/block/drbd/drbd_worker.c

reviewed

··· 442 442 443 443 void resync_timer_fn(struct timer_list *t) 444 444 { 445 445 - struct drbd_device *device = from_timer(device, t, resync_timer); 445 445 + struct drbd_device *device = timer_container_of(device, t, 446 446 + resync_timer); 446 447 447 448 drbd_queue_work_if_unqueued( 448 449 &first_peer_device(device)->connection->sender_work, ··· 1699 1698 1700 1699 void start_resync_timer_fn(struct timer_list *t) 1701 1700 { 1702 1702 - struct drbd_device *device = from_timer(device, t, start_resync_timer); 1701 1701 + struct drbd_device *device = timer_container_of(device, t, 1702 1702 + start_resync_timer); 1703 1703 drbd_device_post_work(device, RS_START); 1704 1704 } 1705 1705

+4 -4

drivers/block/swim3.c

reviewed

··· 555 555 556 556 static void scan_timeout(struct timer_list *t) 557 557 { 558 558 - struct floppy_state *fs = from_timer(fs, t, timeout); 558 558 + struct floppy_state *fs = timer_container_of(fs, t, timeout); 559 559 struct swim3 __iomem *sw = fs->swim3; 560 560 unsigned long flags; 561 561 ··· 579 579 580 580 static void seek_timeout(struct timer_list *t) 581 581 { 582 582 - struct floppy_state *fs = from_timer(fs, t, timeout); 582 582 + struct floppy_state *fs = timer_container_of(fs, t, timeout); 583 583 struct swim3 __iomem *sw = fs->swim3; 584 584 unsigned long flags; 585 585 ··· 598 598 599 599 static void settle_timeout(struct timer_list *t) 600 600 { 601 601 - struct floppy_state *fs = from_timer(fs, t, timeout); 601 601 + struct floppy_state *fs = timer_container_of(fs, t, timeout); 602 602 struct swim3 __iomem *sw = fs->swim3; 603 603 unsigned long flags; 604 604 ··· 627 627 628 628 static void xfer_timeout(struct timer_list *t) 629 629 { 630 630 - struct floppy_state *fs = from_timer(fs, t, timeout); 630 630 + struct floppy_state *fs = timer_container_of(fs, t, timeout); 631 631 struct swim3 __iomem *sw = fs->swim3; 632 632 struct dbdma_regs __iomem *dr = fs->dma; 633 633 unsigned long flags;

+1 -1

drivers/bluetooth/bluecard_cs.c

reviewed

··· 158 158 159 159 static void bluecard_activity_led_timeout(struct timer_list *t) 160 160 { 161 161 - struct bluecard_info *info = from_timer(info, t, timer); 161 161 + struct bluecard_info *info = timer_container_of(info, t, timer); 162 162 unsigned int iobase = info->p_dev->resource[0]->start; 163 163 164 164 if (test_bit(CARD_ACTIVITY, &(info->hw_state))) {

+1 -1

drivers/bluetooth/btnxpuart.c

reviewed

··· 467 467 468 468 static void ps_timeout_func(struct timer_list *t) 469 469 { 470 470 - struct ps_data *data = from_timer(data, t, ps_timer); 470 470 + struct ps_data *data = timer_container_of(data, t, ps_timer); 471 471 struct hci_dev *hdev = data->hdev; 472 472 struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); 473 473

+1 -1

drivers/bluetooth/hci_bcsp.c

reviewed

··· 688 688 /* Arrange to retransmit all messages in the relq. */ 689 689 static void bcsp_timed_event(struct timer_list *t) 690 690 { 691 691 - struct bcsp_struct *bcsp = from_timer(bcsp, t, tbcsp); 691 691 + struct bcsp_struct *bcsp = timer_container_of(bcsp, t, tbcsp); 692 692 struct hci_uart *hu = bcsp->hu; 693 693 struct sk_buff *skb; 694 694 unsigned long flags;

+1 -1

drivers/bluetooth/hci_h5.c

reviewed

··· 149 149 { 150 150 const unsigned char sync_req[] = { 0x01, 0x7e }; 151 151 unsigned char conf_req[3] = { 0x03, 0xfc }; 152 152 - struct h5 *h5 = from_timer(h5, t, timer); 152 152 + struct h5 *h5 = timer_container_of(h5, t, timer); 153 153 struct hci_uart *hu = h5->hu; 154 154 struct sk_buff *skb; 155 155 unsigned long flags;

+2 -2

drivers/bluetooth/hci_qca.c

reviewed

··· 474 474 475 475 static void hci_ibs_tx_idle_timeout(struct timer_list *t) 476 476 { 477 477 - struct qca_data *qca = from_timer(qca, t, tx_idle_timer); 477 477 + struct qca_data *qca = timer_container_of(qca, t, tx_idle_timer); 478 478 struct hci_uart *hu = qca->hu; 479 479 unsigned long flags; 480 480 ··· 507 507 508 508 static void hci_ibs_wake_retrans_timeout(struct timer_list *t) 509 509 { 510 510 - struct qca_data *qca = from_timer(qca, t, wake_retrans_timer); 510 510 + struct qca_data *qca = timer_container_of(qca, t, wake_retrans_timer); 511 511 struct hci_uart *hu = qca->hu; 512 512 unsigned long flags, retrans_delay; 513 513 bool retransmit = false;

+2 -1

drivers/bus/mhi/host/pci_generic.c

reviewed

··· 1171 1171 1172 1172 static void health_check(struct timer_list *t) 1173 1173 { 1174 1174 - struct mhi_pci_device *mhi_pdev = from_timer(mhi_pdev, t, health_check_timer); 1174 1174 + struct mhi_pci_device *mhi_pdev = timer_container_of(mhi_pdev, t, 1175 1175 + health_check_timer); 1175 1176 struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl; 1176 1177 1177 1178 if (!test_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status) ||

+1 -1

drivers/char/hw_random/xgene-rng.c

reviewed

··· 88 88 89 89 static void xgene_rng_expired_timer(struct timer_list *t) 90 90 { 91 91 - struct xgene_rng_dev *ctx = from_timer(ctx, t, failure_timer); 91 91 + struct xgene_rng_dev *ctx = timer_container_of(ctx, t, failure_timer); 92 92 93 93 /* Clear failure counter as timer expired */ 94 94 disable_irq(ctx->irq);

+1 -1

drivers/char/ipmi/bt-bmc.c

reviewed

··· 347 347 348 348 static void poll_timer(struct timer_list *t) 349 349 { 350 350 - struct bt_bmc *bt_bmc = from_timer(bt_bmc, t, poll_timer); 350 350 + struct bt_bmc *bt_bmc = timer_container_of(bt_bmc, t, poll_timer); 351 351 352 352 bt_bmc->poll_timer.expires += msecs_to_jiffies(500); 353 353 wake_up(&bt_bmc->queue);

+2 -1

drivers/char/ipmi/ipmi_si_intf.c

reviewed

··· 1076 1076 1077 1077 static void smi_timeout(struct timer_list *t) 1078 1078 { 1079 1079 - struct smi_info *smi_info = from_timer(smi_info, t, si_timer); 1079 1079 + struct smi_info *smi_info = timer_container_of(smi_info, t, 1080 1080 + si_timer); 1080 1081 enum si_sm_result smi_result; 1081 1082 unsigned long flags; 1082 1083 unsigned long jiffies_now;

+4 -2

drivers/char/ipmi/ipmi_ssif.c

reviewed

··· 539 539 540 540 static void retry_timeout(struct timer_list *t) 541 541 { 542 542 - struct ssif_info *ssif_info = from_timer(ssif_info, t, retry_timer); 542 542 + struct ssif_info *ssif_info = timer_container_of(ssif_info, t, 543 543 + retry_timer); 543 544 unsigned long oflags, *flags; 544 545 bool waiting, resend; 545 546 ··· 564 563 565 564 static void watch_timeout(struct timer_list *t) 566 565 { 567 567 - struct ssif_info *ssif_info = from_timer(ssif_info, t, watch_timer); 566 566 + struct ssif_info *ssif_info = timer_container_of(ssif_info, t, 567 567 + watch_timer); 568 568 unsigned long oflags, *flags; 569 569 570 570 if (ssif_info->stopping)

+2 -1

drivers/char/ipmi/ssif_bmc.c

reviewed

··· 297 297 298 298 static void response_timeout(struct timer_list *t) 299 299 { 300 300 - struct ssif_bmc_ctx *ssif_bmc = from_timer(ssif_bmc, t, response_timer); 300 300 + struct ssif_bmc_ctx *ssif_bmc = timer_container_of(ssif_bmc, t, 301 301 + response_timer); 301 302 unsigned long flags; 302 303 303 304 spin_lock_irqsave(&ssif_bmc->lock, flags);

+1 -1

drivers/char/tpm/tpm-dev-common.c

reviewed

··· 91 91 92 92 static void user_reader_timeout(struct timer_list *t) 93 93 { 94 94 - struct file_priv *priv = from_timer(priv, t, user_read_timer); 94 94 + struct file_priv *priv = timer_container_of(priv, t, user_read_timer); 95 95 96 96 pr_warn("TPM user space timeout is deprecated (pid=%d)\n", 97 97 task_tgid_nr(current));

+4 -2

drivers/comedi/drivers/comedi_test.c

reviewed

··· 197 197 */ 198 198 static void waveform_ai_timer(struct timer_list *t) 199 199 { 200 200 - struct waveform_private *devpriv = from_timer(devpriv, t, ai_timer); 200 200 + struct waveform_private *devpriv = timer_container_of(devpriv, t, 201 201 + ai_timer); 201 202 struct comedi_device *dev = devpriv->dev; 202 203 struct comedi_subdevice *s = dev->read_subdev; 203 204 struct comedi_async *async = s->async; ··· 445 444 */ 446 445 static void waveform_ao_timer(struct timer_list *t) 447 446 { 448 448 - struct waveform_private *devpriv = from_timer(devpriv, t, ao_timer); 447 447 + struct waveform_private *devpriv = timer_container_of(devpriv, t, 448 448 + ao_timer); 449 449 struct comedi_device *dev = devpriv->dev; 450 450 struct comedi_subdevice *s = dev->write_subdev; 451 451 struct comedi_async *async = s->async;

+2 -1

drivers/comedi/drivers/das16.c

reviewed

··· 517 517 518 518 static void das16_timer_interrupt(struct timer_list *t) 519 519 { 520 520 - struct das16_private_struct *devpriv = from_timer(devpriv, t, timer); 520 520 + struct das16_private_struct *devpriv = timer_container_of(devpriv, t, 521 521 + timer); 521 522 struct comedi_device *dev = devpriv->dev; 522 523 unsigned long flags; 523 524

+2 -1

drivers/comedi/drivers/jr3_pci.c

reviewed

··· 562 562 563 563 static void jr3_pci_poll_dev(struct timer_list *t) 564 564 { 565 565 - struct jr3_pci_dev_private *devpriv = from_timer(devpriv, t, timer); 565 565 + struct jr3_pci_dev_private *devpriv = timer_container_of(devpriv, t, 566 566 + timer); 566 567 struct comedi_device *dev = devpriv->dev; 567 568 struct jr3_pci_subdev_private *spriv; 568 569 struct comedi_subdevice *s;

+2 -1

drivers/cpufreq/powernv-cpufreq.c

reviewed

··· 667 667 */ 668 668 static void gpstate_timer_handler(struct timer_list *t) 669 669 { 670 670 - struct global_pstate_info *gpstates = from_timer(gpstates, t, timer); 670 670 + struct global_pstate_info *gpstates = timer_container_of(gpstates, t, 671 671 + timer); 671 672 struct cpufreq_policy *policy = gpstates->policy; 672 673 int gpstate_idx, lpstate_idx; 673 674 unsigned long val;

+1 -1

drivers/crypto/axis/artpec6_crypto.c

reviewed

··· 2072 2072 2073 2073 static void artpec6_crypto_timeout(struct timer_list *t) 2074 2074 { 2075 2075 - struct artpec6_crypto *ac = from_timer(ac, t, timer); 2075 2075 + struct artpec6_crypto *ac = timer_container_of(ac, t, timer); 2076 2076 2077 2077 dev_info_ratelimited(artpec6_crypto_dev, "timeout\n"); 2078 2078

+1 -1

drivers/dma-buf/st-dma-fence.c

reviewed

··· 375 375 376 376 static void wait_timer(struct timer_list *timer) 377 377 { 378 378 - struct wait_timer *wt = from_timer(wt, timer, timer); 378 378 + struct wait_timer *wt = timer_container_of(wt, timer, timer); 379 379 380 380 dma_fence_signal(wt->f); 381 381 }

+2 -1

drivers/dma/imx-dma.c

reviewed

··· 337 337 338 338 static void imxdma_watchdog(struct timer_list *t) 339 339 { 340 340 - struct imxdma_channel *imxdmac = from_timer(imxdmac, t, watchdog); 340 340 + struct imxdma_channel *imxdmac = timer_container_of(imxdmac, t, 341 341 + watchdog); 341 342 struct imxdma_engine *imxdma = imxdmac->imxdma; 342 343 int channel = imxdmac->channel; 343 344

+2 -1

drivers/dma/ioat/dma.c

reviewed

··· 901 901 902 902 void ioat_timer_event(struct timer_list *t) 903 903 { 904 904 - struct ioatdma_chan *ioat_chan = from_timer(ioat_chan, t, timer); 904 904 + struct ioatdma_chan *ioat_chan = timer_container_of(ioat_chan, t, 905 905 + timer); 905 906 dma_addr_t phys_complete; 906 907 u64 status; 907 908

+1 -1

drivers/firewire/core-transaction.c

reviewed

··· 114 114 115 115 static void split_transaction_timeout_callback(struct timer_list *timer) 116 116 { 117 117 - struct fw_transaction *t = from_timer(t, timer, split_timeout_timer); 117 117 + struct fw_transaction *t = timer_container_of(t, timer, split_timeout_timer); 118 118 struct fw_card *card = t->card; 119 119 120 120 scoped_guard(spinlock_irqsave, &card->lock) {

+2 -2

drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c

reviewed

··· 322 322 */ 323 323 static void amdgpu_fence_fallback(struct timer_list *t) 324 324 { 325 325 - struct amdgpu_ring *ring = from_timer(ring, t, 326 326 - fence_drv.fallback_timer); 325 325 + struct amdgpu_ring *ring = timer_container_of(ring, t, 326 326 + fence_drv.fallback_timer); 327 327 328 328 if (amdgpu_fence_process(ring)) 329 329 DRM_WARN("Fence fallback timer expired on ring %s\n", ring->name);

+2 -1

drivers/gpu/drm/amd/amdgpu/amdgpu_ring_mux.c

reviewed

··· 135 135 136 136 static void amdgpu_mux_resubmit_fallback(struct timer_list *t) 137 137 { 138 138 - struct amdgpu_ring_mux *mux = from_timer(mux, t, resubmit_timer); 138 138 + struct amdgpu_ring_mux *mux = timer_container_of(mux, t, 139 139 + resubmit_timer); 139 140 140 141 if (!spin_trylock(&mux->lock)) { 141 142 amdgpu_ring_mux_schedule_resubmit(mux);

+2 -1

drivers/gpu/drm/bridge/tda998x_drv.c

reviewed

··· 751 751 */ 752 752 static void tda998x_edid_delay_done(struct timer_list *t) 753 753 { 754 754 - struct tda998x_priv *priv = from_timer(priv, t, edid_delay_timer); 754 754 + struct tda998x_priv *priv = timer_container_of(priv, t, 755 755 + edid_delay_timer); 755 756 756 757 priv->edid_delay_active = false; 757 758 wake_up(&priv->edid_delay_waitq);

+2 -1

drivers/gpu/drm/drm_vblank.c

reviewed

··· 487 487 488 488 static void vblank_disable_fn(struct timer_list *t) 489 489 { 490 490 - struct drm_vblank_crtc *vblank = from_timer(vblank, t, disable_timer); 490 490 + struct drm_vblank_crtc *vblank = timer_container_of(vblank, t, 491 491 + disable_timer); 491 492 struct drm_device *dev = vblank->dev; 492 493 unsigned int pipe = vblank->pipe; 493 494 unsigned long irqflags;

+1 -1

drivers/gpu/drm/exynos/exynos_drm_vidi.c

reviewed

··· 159 159 160 160 static void vidi_fake_vblank_timer(struct timer_list *t) 161 161 { 162 162 - struct vidi_context *ctx = from_timer(ctx, t, timer); 162 162 + struct vidi_context *ctx = timer_container_of(ctx, t, timer); 163 163 164 164 if (drm_crtc_handle_vblank(&ctx->crtc->base)) 165 165 mod_timer(&ctx->timer,

+1 -1

drivers/gpu/drm/gud/gud_pipe.c

reviewed

··· 234 234 235 235 static void gud_usb_bulk_timeout(struct timer_list *t) 236 236 { 237 237 - struct gud_usb_bulk_context *ctx = from_timer(ctx, t, timer); 237 237 + struct gud_usb_bulk_context *ctx = timer_container_of(ctx, t, timer); 238 238 239 239 usb_sg_cancel(&ctx->sgr); 240 240 }

+1 -1

drivers/gpu/drm/i915/gt/intel_rps.c

reviewed

··· 74 74 75 75 static void rps_timer(struct timer_list *t) 76 76 { 77 77 - struct intel_rps *rps = from_timer(rps, t, timer); 77 77 + struct intel_rps *rps = timer_container_of(rps, t, timer); 78 78 struct intel_gt *gt = rps_to_gt(rps); 79 79 struct intel_engine_cs *engine; 80 80 ktime_t dt, last, timestamp;

+1 -1

drivers/gpu/drm/i915/gt/mock_engine.c

reviewed

··· 108 108 109 109 static void hw_delay_complete(struct timer_list *t) 110 110 { 111 111 - struct mock_engine *engine = from_timer(engine, t, hw_delay); 111 111 + struct mock_engine *engine = timer_container_of(engine, t, hw_delay); 112 112 struct i915_request *request; 113 113 unsigned long flags; 114 114

+1 -1

drivers/gpu/drm/i915/gt/selftest_migrate.c

reviewed

··· 537 537 538 538 static void spinner_kill(struct timer_list *timer) 539 539 { 540 540 - struct spinner_timer *st = from_timer(st, timer, timer); 540 540 + struct spinner_timer *st = timer_container_of(st, timer, timer); 541 541 542 542 igt_spinner_end(&st->spin); 543 543 pr_info("%s\n", __func__);

+2 -1

drivers/gpu/drm/i915/i915_sw_fence.c

reviewed

··· 427 427 428 428 static void timer_i915_sw_fence_wake(struct timer_list *t) 429 429 { 430 430 - struct i915_sw_dma_fence_cb_timer *cb = from_timer(cb, t, timer); 430 430 + struct i915_sw_dma_fence_cb_timer *cb = timer_container_of(cb, t, 431 431 + timer); 431 432 struct i915_sw_fence *fence; 432 433 433 434 fence = xchg(&cb->base.fence, NULL);

+1 -1

drivers/gpu/drm/i915/intel_wakeref.c

reviewed

··· 135 135 136 136 static void wakeref_auto_timeout(struct timer_list *t) 137 137 { 138 138 - struct intel_wakeref_auto *wf = from_timer(wf, t, timer); 138 138 + struct intel_wakeref_auto *wf = timer_container_of(wf, t, timer); 139 139 intel_wakeref_t wakeref; 140 140 unsigned long flags; 141 141

+1 -1

drivers/gpu/drm/i915/selftests/lib_sw_fence.c

reviewed

··· 55 55 56 56 static void timed_fence_wake(struct timer_list *t) 57 57 { 58 58 - struct timed_fence *tf = from_timer(tf, t, timer); 58 58 + struct timed_fence *tf = timer_container_of(tf, t, timer); 59 59 60 60 i915_sw_fence_commit(&tf->fence); 61 61 }

+1 -1

drivers/gpu/drm/mediatek/mtk_dp.c

reviewed

··· 2569 2569 2570 2570 static void mtk_dp_debounce_timer(struct timer_list *t) 2571 2571 { 2572 2572 - struct mtk_dp *mtk_dp = from_timer(mtk_dp, t, debounce_timer); 2572 2572 + struct mtk_dp *mtk_dp = timer_container_of(mtk_dp, t, debounce_timer); 2573 2573 2574 2574 mtk_dp->need_debounce = true; 2575 2575 }

+2 -1

drivers/gpu/drm/msm/adreno/a5xx_preempt.c

reviewed

··· 79 79 80 80 static void a5xx_preempt_timer(struct timer_list *t) 81 81 { 82 82 - struct a5xx_gpu *a5xx_gpu = from_timer(a5xx_gpu, t, preempt_timer); 82 82 + struct a5xx_gpu *a5xx_gpu = timer_container_of(a5xx_gpu, t, 83 83 + preempt_timer); 83 84 struct msm_gpu *gpu = &a5xx_gpu->base.base; 84 85 struct drm_device *dev = gpu->dev; 85 86

+2 -1

drivers/gpu/drm/msm/adreno/a6xx_preempt.c

reviewed

··· 87 87 88 88 static void a6xx_preempt_timer(struct timer_list *t) 89 89 { 90 90 - struct a6xx_gpu *a6xx_gpu = from_timer(a6xx_gpu, t, preempt_timer); 90 90 + struct a6xx_gpu *a6xx_gpu = timer_container_of(a6xx_gpu, t, 91 91 + preempt_timer); 91 92 struct msm_gpu *gpu = &a6xx_gpu->base.base; 92 93 struct drm_device *dev = gpu->dev; 93 94

+2 -2

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c

reviewed

··· 2693 2693 2694 2694 static void dpu_encoder_frame_done_timeout(struct timer_list *t) 2695 2695 { 2696 2696 - struct dpu_encoder_virt *dpu_enc = from_timer(dpu_enc, t, 2697 2697 - frame_done_timer); 2696 2696 + struct dpu_encoder_virt *dpu_enc = timer_container_of(dpu_enc, t, 2697 2697 + frame_done_timer); 2698 2698 struct drm_encoder *drm_enc = &dpu_enc->base; 2699 2699 u32 event; 2700 2700

+1 -1

drivers/gpu/drm/msm/msm_gpu.c

reviewed

··· 521 521 522 522 static void hangcheck_handler(struct timer_list *t) 523 523 { 524 524 - struct msm_gpu *gpu = from_timer(gpu, t, hangcheck_timer); 524 524 + struct msm_gpu *gpu = timer_container_of(gpu, t, hangcheck_timer); 525 525 struct drm_device *dev = gpu->dev; 526 526 struct msm_ringbuffer *ring = gpu->funcs->active_ring(gpu); 527 527 uint32_t fence = ring->memptrs->fence;

+1 -1

drivers/gpu/drm/ttm/tests/ttm_bo_test.c

reviewed

··· 175 175 176 176 static void signal_for_ttm_bo_reserve(struct timer_list *t) 177 177 { 178 178 - struct signal_timer *s_timer = from_timer(s_timer, t, timer); 178 178 + struct signal_timer *s_timer = timer_container_of(s_timer, t, timer); 179 179 struct task_struct *task = s_timer->ctx->task; 180 180 181 181 do_send_sig_info(SIGTERM, SEND_SIG_PRIV, task, PIDTYPE_PID);

+1 -1

drivers/gpu/drm/vc4/vc4_bo.c

reviewed

··· 679 679 680 680 static void vc4_bo_cache_time_timer(struct timer_list *t) 681 681 { 682 682 - struct vc4_dev *vc4 = from_timer(vc4, t, bo_cache.time_timer); 682 682 + struct vc4_dev *vc4 = timer_container_of(vc4, t, bo_cache.time_timer); 683 683 684 684 schedule_work(&vc4->bo_cache.time_work); 685 685 }

+1 -1

drivers/gpu/drm/vc4/vc4_gem.c

reviewed

··· 326 326 static void 327 327 vc4_hangcheck_elapsed(struct timer_list *t) 328 328 { 329 329 - struct vc4_dev *vc4 = from_timer(vc4, t, hangcheck.timer); 329 329 + struct vc4_dev *vc4 = timer_container_of(vc4, t, hangcheck.timer); 330 330 struct drm_device *dev = &vc4->base; 331 331 uint32_t ct0ca, ct1ca; 332 332 unsigned long irqflags;

+1 -1

drivers/gpu/drm/vgem/vgem_fence.c

reviewed

··· 61 61 62 62 static void vgem_fence_timeout(struct timer_list *t) 63 63 { 64 64 - struct vgem_fence *fence = from_timer(fence, t, timer); 64 64 + struct vgem_fence *fence = timer_container_of(fence, t, timer); 65 65 66 66 dma_fence_signal(&fence->base); 67 67 }

+2 -1

drivers/greybus/operation.c

reviewed

··· 295 295 296 296 static void gb_operation_timeout(struct timer_list *t) 297 297 { 298 298 - struct gb_operation *operation = from_timer(operation, t, timer); 298 298 + struct gb_operation *operation = timer_container_of(operation, t, 299 299 + timer); 299 300 300 301 if (gb_operation_result_set(operation, -ETIMEDOUT)) { 301 302 /*

+1 -1

drivers/hid/hid-apple.c

reviewed

··· 614 614 615 615 static void apple_battery_timer_tick(struct timer_list *t) 616 616 { 617 617 - struct apple_sc *asc = from_timer(asc, t, battery_timer); 617 617 + struct apple_sc *asc = timer_container_of(asc, t, battery_timer); 618 618 struct hid_device *hdev = asc->hdev; 619 619 620 620 if (apple_fetch_battery(hdev) == 0) {

+1 -1

drivers/hid/hid-appleir.c

reviewed

··· 167 167 168 168 static void key_up_tick(struct timer_list *t) 169 169 { 170 170 - struct appleir *appleir = from_timer(appleir, t, key_up_timer); 170 170 + struct appleir *appleir = timer_container_of(appleir, t, key_up_timer); 171 171 struct hid_device *hid = appleir->hid; 172 172 unsigned long flags; 173 173

+1 -1

drivers/hid/hid-appletb-kbd.c

reviewed

··· 166 166 167 167 static void appletb_inactivity_timer(struct timer_list *t) 168 168 { 169 169 - struct appletb_kbd *kbd = from_timer(kbd, t, inactivity_timer); 169 169 + struct appletb_kbd *kbd = timer_container_of(kbd, t, inactivity_timer); 170 170 171 171 if (kbd->backlight_dev && appletb_tb_autodim) { 172 172 if (!kbd->has_dimmed) {

+2 -1

drivers/hid/hid-letsketch.c

reviewed

··· 155 155 156 156 static void letsketch_inrange_timeout(struct timer_list *t) 157 157 { 158 158 - struct letsketch_data *data = from_timer(data, t, inrange_timer); 158 158 + struct letsketch_data *data = timer_container_of(data, t, 159 159 + inrange_timer); 159 160 struct input_dev *input = data->input_tablet; 160 161 161 162 input_report_key(input, BTN_TOOL_PEN, 0);

+1 -1

drivers/hid/hid-magicmouse.c

reviewed

··· 822 822 823 823 static void magicmouse_battery_timer_tick(struct timer_list *t) 824 824 { 825 825 - struct magicmouse_sc *msc = from_timer(msc, t, battery_timer); 825 825 + struct magicmouse_sc *msc = timer_container_of(msc, t, battery_timer); 826 826 struct hid_device *hdev = msc->hdev; 827 827 828 828 if (magicmouse_fetch_battery(hdev) == 0) {

+1 -1

drivers/hid/hid-multitouch.c

reviewed

··· 1745 1745 1746 1746 static void mt_expired_timeout(struct timer_list *t) 1747 1747 { 1748 1748 - struct mt_device *td = from_timer(td, t, release_timer); 1748 1748 + struct mt_device *td = timer_container_of(td, t, release_timer); 1749 1749 struct hid_device *hdev = td->hdev; 1750 1750 1751 1751 /*

+1 -1

drivers/hid/hid-prodikeys.c

reviewed

··· 227 227 228 228 static void pcmidi_sustained_note_release(struct timer_list *t) 229 229 { 230 230 - struct pcmidi_sustain *pms = from_timer(pms, t, timer); 230 230 + struct pcmidi_sustain *pms = timer_container_of(pms, t, timer); 231 231 232 232 pcmidi_send_note(pms->pm, pms->status, pms->note, pms->velocity); 233 233 pms->in_use = 0;

+1 -1

drivers/hid/hid-sony.c

reviewed

··· 545 545 static void ghl_magic_poke(struct timer_list *t) 546 546 { 547 547 int ret; 548 548 - struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer); 548 548 + struct sony_sc *sc = timer_container_of(sc, t, ghl_poke_timer); 549 549 550 550 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC); 551 551 if (ret < 0)

+2 -2

drivers/hid/hid-uclogic-core.c

reviewed

··· 32 32 */ 33 33 static void uclogic_inrange_timeout(struct timer_list *t) 34 34 { 35 35 - struct uclogic_drvdata *drvdata = from_timer(drvdata, t, 36 36 - inrange_timer); 35 35 + struct uclogic_drvdata *drvdata = timer_container_of(drvdata, t, 36 36 + inrange_timer); 37 37 struct input_dev *input = drvdata->pen_input; 38 38 39 39 if (input == NULL)

+1 -1

drivers/hid/hid-wiimote-core.c

reviewed

··· 1240 1240 1241 1241 static void wiimote_init_timeout(struct timer_list *t) 1242 1242 { 1243 1243 - struct wiimote_data *wdata = from_timer(wdata, t, timer); 1243 1243 + struct wiimote_data *wdata = timer_container_of(wdata, t, timer); 1244 1244 1245 1245 wiimote_schedule(wdata); 1246 1246 }

+1 -1

drivers/hid/usbhid/hid-core.c

reviewed

··· 106 106 /* I/O retry timer routine */ 107 107 static void hid_retry_timeout(struct timer_list *t) 108 108 { 109 109 - struct usbhid_device *usbhid = from_timer(usbhid, t, io_retry); 109 109 + struct usbhid_device *usbhid = timer_container_of(usbhid, t, io_retry); 110 110 struct hid_device *hid = usbhid->hid; 111 111 112 112 dev_dbg(&usbhid->intf->dev, "retrying intr urb\n");

+1 -1

drivers/hid/wacom_wac.c

reviewed

··· 63 63 64 64 void wacom_idleprox_timeout(struct timer_list *list) 65 65 { 66 66 - struct wacom *wacom = from_timer(wacom, list, idleprox_timer); 66 66 + struct wacom *wacom = timer_container_of(wacom, list, idleprox_timer); 67 67 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 68 68 69 69 if (!wacom_wac->hid_data.sense_state) {

+3 -3

drivers/hsi/clients/ssi_protocol.c

reviewed

··· 453 453 454 454 static void ssip_keep_alive(struct timer_list *t) 455 455 { 456 456 - struct ssi_protocol *ssi = from_timer(ssi, t, keep_alive); 456 456 + struct ssi_protocol *ssi = timer_container_of(ssi, t, keep_alive); 457 457 struct hsi_client *cl = ssi->cl; 458 458 459 459 dev_dbg(&cl->device, "Keep alive kick in: m(%d) r(%d) s(%d)\n", ··· 480 480 481 481 static void ssip_rx_wd(struct timer_list *t) 482 482 { 483 483 - struct ssi_protocol *ssi = from_timer(ssi, t, rx_wd); 483 483 + struct ssi_protocol *ssi = timer_container_of(ssi, t, rx_wd); 484 484 struct hsi_client *cl = ssi->cl; 485 485 486 486 dev_err(&cl->device, "Watchdog triggered\n"); ··· 489 489 490 490 static void ssip_tx_wd(struct timer_list *t) 491 491 { 492 492 - struct ssi_protocol *ssi = from_timer(ssi, t, tx_wd); 492 492 + struct ssi_protocol *ssi = timer_container_of(ssi, t, tx_wd); 493 493 struct hsi_client *cl = ssi->cl; 494 494 495 495 dev_err(&cl->device, "Watchdog triggered\n");

+1 -1

drivers/hwmon/npcm750-pwm-fan.c

reviewed

··· 331 331 struct npcm7xx_pwm_fan_data *data; 332 332 int i; 333 333 334 334 - data = from_timer(data, t, fan_timer); 334 334 + data = timer_container_of(data, t, fan_timer); 335 335 336 336 /* 337 337 * Polling two module per one round,

+1 -1

drivers/hwmon/pwm-fan.c

reviewed

··· 78 78 79 79 static void sample_timer(struct timer_list *t) 80 80 { 81 81 - struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer); 81 81 + struct pwm_fan_ctx *ctx = timer_container_of(ctx, t, rpm_timer); 82 82 unsigned int delta = ktime_ms_delta(ktime_get(), ctx->sample_start); 83 83 int i; 84 84

+1 -1

drivers/i2c/busses/i2c-img-scb.c

reviewed

··· 831 831 */ 832 832 static void img_i2c_check_timer(struct timer_list *t) 833 833 { 834 834 - struct img_i2c *i2c = from_timer(i2c, t, check_timer); 834 834 + struct img_i2c *i2c = timer_container_of(i2c, t, check_timer); 835 835 unsigned long flags; 836 836 unsigned int line_status; 837 837

+1 -1

drivers/iio/common/ssp_sensors/ssp_dev.c

reviewed

··· 167 167 168 168 static void ssp_wdt_timer_func(struct timer_list *t) 169 169 { 170 170 - struct ssp_data *data = from_timer(data, t, wdt_timer); 170 170 + struct ssp_data *data = timer_container_of(data, t, wdt_timer); 171 171 172 172 switch (data->fw_dl_state) { 173 173 case SSP_FW_DL_STATE_FAIL:

+1 -1

drivers/infiniband/hw/cxgb4/cm.c

reviewed

··· 4327 4327 4328 4328 static void ep_timeout(struct timer_list *t) 4329 4329 { 4330 4330 - struct c4iw_ep *ep = from_timer(ep, t, timer); 4330 4330 + struct c4iw_ep *ep = timer_container_of(ep, t, timer); 4331 4331 int kickit = 0; 4332 4332 4333 4333 spin_lock(&timeout_lock);

+1 -1

drivers/infiniband/hw/hfi1/aspm.c

reviewed

··· 169 169 /* Timer function for re-enabling ASPM in the absence of interrupt activity */ 170 170 static void aspm_ctx_timer_function(struct timer_list *t) 171 171 { 172 172 - struct hfi1_ctxtdata *rcd = from_timer(rcd, t, aspm_timer); 172 172 + struct hfi1_ctxtdata *rcd = timer_container_of(rcd, t, aspm_timer); 173 173 unsigned long flags; 174 174 175 175 spin_lock_irqsave(&rcd->aspm_lock, flags);

+2 -2

drivers/infiniband/hw/hfi1/chip.c

reviewed

··· 5548 5548 #define RCVERR_CHECK_TIME 10 5549 5549 static void update_rcverr_timer(struct timer_list *t) 5550 5550 { 5551 5551 - struct hfi1_devdata *dd = from_timer(dd, t, rcverr_timer); 5551 5551 + struct hfi1_devdata *dd = timer_container_of(dd, t, rcverr_timer); 5552 5552 struct hfi1_pportdata *ppd = dd->pport; 5553 5553 u32 cur_ovfl_cnt = read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL); 5554 5554 ··· 12587 12587 12588 12588 static void update_synth_timer(struct timer_list *t) 12589 12589 { 12590 12590 - struct hfi1_devdata *dd = from_timer(dd, t, synth_stats_timer); 12590 12590 + struct hfi1_devdata *dd = timer_container_of(dd, t, synth_stats_timer); 12591 12591 12592 12592 queue_work(dd->update_cntr_wq, &dd->update_cntr_work); 12593 12593 mod_timer(&dd->synth_stats_timer, jiffies + HZ * SYNTH_CNT_TIME);

+2 -1

drivers/infiniband/hw/hfi1/driver.c

reviewed

··· 1315 1315 1316 1316 static void run_led_override(struct timer_list *t) 1317 1317 { 1318 1318 - struct hfi1_pportdata *ppd = from_timer(ppd, t, led_override_timer); 1318 1318 + struct hfi1_pportdata *ppd = timer_container_of(ppd, t, 1319 1319 + led_override_timer); 1319 1320 struct hfi1_devdata *dd = ppd->dd; 1320 1321 unsigned long timeout; 1321 1322 int phase_idx;

+1 -1

drivers/infiniband/hw/hfi1/mad.c

reviewed

··· 369 369 370 370 void hfi1_handle_trap_timer(struct timer_list *t) 371 371 { 372 372 - struct hfi1_ibport *ibp = from_timer(ibp, t, rvp.trap_timer); 372 372 + struct hfi1_ibport *ibp = timer_container_of(ibp, t, rvp.trap_timer); 373 373 struct trap_node *trap = NULL; 374 374 unsigned long flags; 375 375 int i;

+2 -1

drivers/infiniband/hw/hfi1/sdma.c

reviewed

··· 467 467 static void sdma_err_progress_check(struct timer_list *t) 468 468 { 469 469 unsigned index; 470 470 - struct sdma_engine *sde = from_timer(sde, t, err_progress_check_timer); 470 470 + struct sdma_engine *sde = timer_container_of(sde, t, 471 471 + err_progress_check_timer); 471 472 472 473 dd_dev_err(sde->dd, "SDE progress check event\n"); 473 474 for (index = 0; index < sde->dd->num_sdma; index++) {

+3 -2

drivers/infiniband/hw/hfi1/tid_rdma.c

reviewed

··· 3981 3981 3982 3982 static void hfi1_tid_timeout(struct timer_list *t) 3983 3983 { 3984 3984 - struct hfi1_qp_priv *qpriv = from_timer(qpriv, t, s_tid_timer); 3984 3984 + struct hfi1_qp_priv *qpriv = timer_container_of(qpriv, t, s_tid_timer); 3985 3985 struct rvt_qp *qp = qpriv->owner; 3986 3986 struct rvt_dev_info *rdi = ib_to_rvt(qp->ibqp.device); 3987 3987 unsigned long flags; ··· 4797 4797 4798 4798 static void hfi1_tid_retry_timeout(struct timer_list *t) 4799 4799 { 4800 4800 - struct hfi1_qp_priv *priv = from_timer(priv, t, s_tid_retry_timer); 4800 4800 + struct hfi1_qp_priv *priv = timer_container_of(priv, t, 4801 4801 + s_tid_retry_timer); 4801 4802 struct rvt_qp *qp = priv->owner; 4802 4803 struct rvt_swqe *wqe; 4803 4804 unsigned long flags;

+1 -1

drivers/infiniband/hw/hfi1/verbs.c

reviewed

··· 554 554 */ 555 555 static void mem_timer(struct timer_list *t) 556 556 { 557 557 - struct hfi1_ibdev *dev = from_timer(dev, t, mem_timer); 557 557 + struct hfi1_ibdev *dev = timer_container_of(dev, t, mem_timer); 558 558 struct list_head *list = &dev->memwait; 559 559 struct rvt_qp *qp = NULL; 560 560 struct iowait *wait;

+2 -1

drivers/infiniband/hw/irdma/cm.c

reviewed

··· 1263 1263 struct irdma_timer_entry *send_entry, *close_entry; 1264 1264 struct list_head *list_core_temp; 1265 1265 struct list_head *list_node; 1266 1266 - struct irdma_cm_core *cm_core = from_timer(cm_core, t, tcp_timer); 1266 1266 + struct irdma_cm_core *cm_core = timer_container_of(cm_core, t, 1267 1267 + tcp_timer); 1267 1268 struct irdma_sc_vsi *vsi; 1268 1269 u32 settimer = 0; 1269 1270 unsigned long timetosend;

+2 -2

drivers/infiniband/hw/irdma/utils.c

reviewed

··· 930 930 931 931 static void irdma_terminate_timeout(struct timer_list *t) 932 932 { 933 933 - struct irdma_qp *iwqp = from_timer(iwqp, t, terminate_timer); 933 933 + struct irdma_qp *iwqp = timer_container_of(iwqp, t, terminate_timer); 934 934 struct irdma_sc_qp *qp = &iwqp->sc_qp; 935 935 936 936 irdma_terminate_done(qp, 1); ··· 1537 1537 static void irdma_hw_stats_timeout(struct timer_list *t) 1538 1538 { 1539 1539 struct irdma_vsi_pestat *pf_devstat = 1540 1540 - from_timer(pf_devstat, t, stats_timer); 1540 1540 + timer_container_of(pf_devstat, t, stats_timer); 1541 1541 struct irdma_sc_vsi *sc_vsi = pf_devstat->vsi; 1542 1542 1543 1543 if (sc_vsi->dev->hw_attrs.uk_attrs.hw_rev >= IRDMA_GEN_2)

+1 -1

drivers/infiniband/hw/mlx5/mr.c

reviewed

··· 838 838 839 839 static void delay_time_func(struct timer_list *t) 840 840 { 841 841 - struct mlx5_ib_dev *dev = from_timer(dev, t, delay_timer); 841 841 + struct mlx5_ib_dev *dev = timer_container_of(dev, t, delay_timer); 842 842 843 843 WRITE_ONCE(dev->fill_delay, 0); 844 844 }

+1 -1

drivers/infiniband/hw/mthca/mthca_catas.c

reviewed

··· 132 132 133 133 static void poll_catas(struct timer_list *t) 134 134 { 135 135 - struct mthca_dev *dev = from_timer(dev, t, catas_err.timer); 135 135 + struct mthca_dev *dev = timer_container_of(dev, t, catas_err.timer); 136 136 int i; 137 137 138 138 for (i = 0; i < dev->catas_err.size; ++i)

+2 -2

drivers/infiniband/hw/qib/qib_driver.c

reviewed

··· 659 659 660 660 static void qib_run_led_override(struct timer_list *t) 661 661 { 662 662 - struct qib_pportdata *ppd = from_timer(ppd, t, 663 663 - led_override_timer); 662 662 + struct qib_pportdata *ppd = timer_container_of(ppd, t, 663 663 + led_override_timer); 664 664 struct qib_devdata *dd = ppd->dd; 665 665 int timeoff; 666 666 int ph_idx;

+2 -2

drivers/infiniband/hw/qib/qib_iba6120.c

reviewed

··· 2615 2615 */ 2616 2616 static void qib_get_6120_faststats(struct timer_list *t) 2617 2617 { 2618 2618 - struct qib_devdata *dd = from_timer(dd, t, stats_timer); 2618 2618 + struct qib_devdata *dd = timer_container_of(dd, t, stats_timer); 2619 2619 struct qib_pportdata *ppd = dd->pport; 2620 2620 unsigned long flags; 2621 2621 u64 traffic_wds; ··· 2905 2905 2906 2906 static void pma_6120_timer(struct timer_list *t) 2907 2907 { 2908 2908 - struct qib_chip_specific *cs = from_timer(cs, t, pma_timer); 2908 2908 + struct qib_chip_specific *cs = timer_container_of(cs, t, pma_timer); 2909 2909 struct qib_pportdata *ppd = cs->ppd; 2910 2910 struct qib_ibport *ibp = &ppd->ibport_data; 2911 2911 unsigned long flags;

+3 -3

drivers/infiniband/hw/qib/qib_iba7220.c

reviewed

··· 1044 1044 1045 1045 static void reenable_7220_chase(struct timer_list *t) 1046 1046 { 1047 1047 - struct qib_chippport_specific *cpspec = from_timer(cpspec, t, 1048 1048 - chase_timer); 1047 1047 + struct qib_chippport_specific *cpspec = timer_container_of(cpspec, t, 1048 1048 + chase_timer); 1049 1049 struct qib_pportdata *ppd = &cpspec->pportdata; 1050 1050 1051 1051 ppd->cpspec->chase_timer.expires = 0; ··· 3240 3240 */ 3241 3241 static void qib_get_7220_faststats(struct timer_list *t) 3242 3242 { 3243 3243 - struct qib_devdata *dd = from_timer(dd, t, stats_timer); 3243 3243 + struct qib_devdata *dd = timer_container_of(dd, t, stats_timer); 3244 3244 struct qib_pportdata *ppd = dd->pport; 3245 3245 unsigned long flags; 3246 3246 u64 traffic_wds;

+3 -2

drivers/infiniband/hw/qib/qib_iba7322.c

reviewed

··· 1721 1721 1722 1722 static void reenable_chase(struct timer_list *t) 1723 1723 { 1724 1724 - struct qib_chippport_specific *cp = from_timer(cp, t, chase_timer); 1724 1724 + struct qib_chippport_specific *cp = timer_container_of(cp, t, 1725 1725 + chase_timer); 1725 1726 struct qib_pportdata *ppd = cp->ppd; 1726 1727 1727 1728 ppd->cpspec->chase_timer.expires = 0; ··· 5085 5084 */ 5086 5085 static void qib_get_7322_faststats(struct timer_list *t) 5087 5086 { 5088 5088 - struct qib_devdata *dd = from_timer(dd, t, stats_timer); 5087 5087 + struct qib_devdata *dd = timer_container_of(dd, t, stats_timer); 5089 5088 struct qib_pportdata *ppd; 5090 5089 unsigned long flags; 5091 5090 u64 traffic_wds;

+1 -1

drivers/infiniband/hw/qib/qib_init.c

reviewed

··· 493 493 494 494 static void verify_interrupt(struct timer_list *t) 495 495 { 496 496 - struct qib_devdata *dd = from_timer(dd, t, intrchk_timer); 496 496 + struct qib_devdata *dd = timer_container_of(dd, t, intrchk_timer); 497 497 u64 int_counter; 498 498 499 499 if (!dd)

+2 -1

drivers/infiniband/hw/qib/qib_intr.c

reviewed

··· 172 172 173 173 void qib_clear_symerror_on_linkup(struct timer_list *t) 174 174 { 175 175 - struct qib_pportdata *ppd = from_timer(ppd, t, symerr_clear_timer); 175 175 + struct qib_pportdata *ppd = timer_container_of(ppd, t, 176 176 + symerr_clear_timer); 176 177 177 178 if (ppd->lflags & QIBL_LINKACTIVE) 178 179 return;

+2 -1

drivers/infiniband/hw/qib/qib_mad.c

reviewed

··· 2398 2398 2399 2399 static void xmit_wait_timer_func(struct timer_list *t) 2400 2400 { 2401 2401 - struct qib_pportdata *ppd = from_timer(ppd, t, cong_stats.timer); 2401 2401 + struct qib_pportdata *ppd = timer_container_of(ppd, t, 2402 2402 + cong_stats.timer); 2402 2403 struct qib_devdata *dd = dd_from_ppd(ppd); 2403 2404 unsigned long flags; 2404 2405 u8 status;

+1 -1

drivers/infiniband/hw/qib/qib_sd7220.c

reviewed

··· 1385 1385 1386 1386 static void qib_run_relock(struct timer_list *t) 1387 1387 { 1388 1388 - struct qib_chip_specific *cs = from_timer(cs, t, relock_timer); 1388 1388 + struct qib_chip_specific *cs = timer_container_of(cs, t, relock_timer); 1389 1389 struct qib_devdata *dd = cs->dd; 1390 1390 struct qib_pportdata *ppd = dd->pport; 1391 1391 int timeoff;

+1 -1

drivers/infiniband/hw/qib/qib_tx.c

reviewed

··· 548 548 */ 549 549 void qib_hol_event(struct timer_list *t) 550 550 { 551 551 - struct qib_pportdata *ppd = from_timer(ppd, t, hol_timer); 551 551 + struct qib_pportdata *ppd = timer_container_of(ppd, t, hol_timer); 552 552 553 553 /* If hardware error, etc, skip. */ 554 554 if (!(ppd->dd->flags & QIB_INITTED))

+1 -1

drivers/infiniband/hw/qib/qib_verbs.c

reviewed

··· 361 361 */ 362 362 static void mem_timer(struct timer_list *t) 363 363 { 364 364 - struct qib_ibdev *dev = from_timer(dev, t, mem_timer); 364 364 + struct qib_ibdev *dev = timer_container_of(dev, t, mem_timer); 365 365 struct list_head *list = &dev->memwait; 366 366 struct rvt_qp *qp = NULL; 367 367 struct qib_qp_priv *priv = NULL;

+1 -1

drivers/infiniband/sw/rdmavt/qp.c

reviewed

··· 2585 2585 */ 2586 2586 static void rvt_rc_timeout(struct timer_list *t) 2587 2587 { 2588 2588 - struct rvt_qp *qp = from_timer(qp, t, s_timer); 2588 2588 + struct rvt_qp *qp = timer_container_of(qp, t, s_timer); 2589 2589 struct rvt_dev_info *rdi = ib_to_rvt(qp->ibqp.device); 2590 2590 unsigned long flags; 2591 2591

+1 -1

drivers/infiniband/sw/rxe/rxe_comp.c

reviewed

··· 114 114 115 115 void retransmit_timer(struct timer_list *t) 116 116 { 117 117 - struct rxe_qp *qp = from_timer(qp, t, retrans_timer); 117 117 + struct rxe_qp *qp = timer_container_of(qp, t, retrans_timer); 118 118 unsigned long flags; 119 119 120 120 rxe_dbg_qp(qp, "retransmit timer fired\n");

+1 -1

drivers/infiniband/sw/rxe/rxe_req.c

reviewed

··· 97 97 98 98 void rnr_nak_timer(struct timer_list *t) 99 99 { 100 100 - struct rxe_qp *qp = from_timer(qp, t, rnr_nak_timer); 100 100 + struct rxe_qp *qp = timer_container_of(qp, t, rnr_nak_timer); 101 101 unsigned long flags; 102 102 103 103 rxe_dbg_qp(qp, "nak timer fired\n");

+1 -1

drivers/input/ff-memless.c

reviewed

··· 399 399 400 400 static void ml_effect_timer(struct timer_list *t) 401 401 { 402 402 - struct ml_device *ml = from_timer(ml, t, timer); 402 402 + struct ml_device *ml = timer_container_of(ml, t, timer); 403 403 struct input_dev *dev = ml->dev; 404 404 405 405 pr_debug("timer: updating effects\n");

+2 -1

drivers/input/gameport/gameport.c

reviewed

··· 199 199 200 200 static void gameport_run_poll_handler(struct timer_list *t) 201 201 { 202 202 - struct gameport *gameport = from_timer(gameport, t, poll_timer); 202 202 + struct gameport *gameport = timer_container_of(gameport, t, 203 203 + poll_timer); 203 204 204 205 gameport->poll_handler(gameport); 205 206 if (gameport->poll_cnt)

+1 -1

drivers/input/input.c

reviewed

··· 2249 2249 */ 2250 2250 static void input_repeat_key(struct timer_list *t) 2251 2251 { 2252 2252 - struct input_dev *dev = from_timer(dev, t, timer); 2252 2252 + struct input_dev *dev = timer_container_of(dev, t, timer); 2253 2253 2254 2254 guard(spinlock_irqsave)(&dev->event_lock); 2255 2255

+1 -1

drivers/input/joystick/db9.c

reviewed

··· 351 351 352 352 static void db9_timer(struct timer_list *t) 353 353 { 354 354 - struct db9 *db9 = from_timer(db9, t, timer); 354 354 + struct db9 *db9 = timer_container_of(db9, t, timer); 355 355 struct parport *port = db9->pd->port; 356 356 struct input_dev *dev = db9->dev[0]; 357 357 struct input_dev *dev2 = db9->dev[1];

+1 -1

drivers/input/joystick/gamecon.c

reviewed

··· 726 726 727 727 static void gc_timer(struct timer_list *t) 728 728 { 729 729 - struct gc *gc = from_timer(gc, t, timer); 729 729 + struct gc *gc = timer_container_of(gc, t, timer); 730 730 731 731 /* 732 732 * N64 pads - must be read first, any read confuses them for 200 us

+1 -1

drivers/input/joystick/turbografx.c

reviewed

··· 72 72 73 73 static void tgfx_timer(struct timer_list *t) 74 74 { 75 75 - struct tgfx *tgfx = from_timer(tgfx, t, timer); 75 75 + struct tgfx *tgfx = timer_container_of(tgfx, t, timer); 76 76 struct input_dev *dev; 77 77 int data1, data2, i; 78 78

+2 -1

drivers/input/keyboard/imx_keypad.c

reviewed

··· 183 183 */ 184 184 static void imx_keypad_check_for_events(struct timer_list *t) 185 185 { 186 186 - struct imx_keypad *keypad = from_timer(keypad, t, check_matrix_timer); 186 186 + struct imx_keypad *keypad = timer_container_of(keypad, t, 187 187 + check_matrix_timer); 187 188 unsigned short matrix_volatile_state[MAX_MATRIX_KEY_COLS]; 188 189 unsigned short reg_val; 189 190 bool state_changed, is_zero_matrix;

+1 -1

drivers/input/keyboard/locomokbd.c

reviewed

··· 194 194 */ 195 195 static void locomokbd_timer_callback(struct timer_list *t) 196 196 { 197 197 - struct locomokbd *locomokbd = from_timer(locomokbd, t, timer); 197 197 + struct locomokbd *locomokbd = timer_container_of(locomokbd, t, timer); 198 198 199 199 locomokbd_scankeyboard(locomokbd); 200 200 }

+2 -1

drivers/input/keyboard/snvs_pwrkey.c

reviewed

··· 46 46 47 47 static void imx_imx_snvs_check_for_events(struct timer_list *t) 48 48 { 49 49 - struct pwrkey_drv_data *pdata = from_timer(pdata, t, check_timer); 49 49 + struct pwrkey_drv_data *pdata = timer_container_of(pdata, t, 50 50 + check_timer); 50 51 struct input_dev *input = pdata->input; 51 52 u32 state; 52 53

+1 -1

drivers/input/keyboard/tegra-kbc.c

reviewed

··· 240 240 241 241 static void tegra_kbc_keypress_timer(struct timer_list *t) 242 242 { 243 243 - struct tegra_kbc *kbc = from_timer(kbc, t, timer); 243 243 + struct tegra_kbc *kbc = timer_container_of(kbc, t, timer); 244 244 u32 val; 245 245 unsigned int i; 246 246

+1 -1

drivers/input/misc/nxp-bbnsm-pwrkey.c

reviewed

··· 45 45 46 46 static void bbnsm_pwrkey_check_for_events(struct timer_list *t) 47 47 { 48 48 - struct bbnsm_pwrkey *bbnsm = from_timer(bbnsm, t, check_timer); 48 48 + struct bbnsm_pwrkey *bbnsm = timer_container_of(bbnsm, t, check_timer); 49 49 struct input_dev *input = bbnsm->input; 50 50 u32 state; 51 51

+1 -1

drivers/input/mouse/alps.c

reviewed

··· 1582 1582 1583 1583 static void alps_flush_packet(struct timer_list *t) 1584 1584 { 1585 1585 - struct alps_data *priv = from_timer(priv, t, timer); 1585 1585 + struct alps_data *priv = timer_container_of(priv, t, timer); 1586 1586 struct psmouse *psmouse = priv->psmouse; 1587 1587 1588 1588 guard(serio_pause_rx)(psmouse->ps2dev.serio);

+1 -1

drivers/input/mouse/byd.c

reviewed

··· 251 251 252 252 static void byd_clear_touch(struct timer_list *t) 253 253 { 254 254 - struct byd_data *priv = from_timer(priv, t, timer); 254 254 + struct byd_data *priv = timer_container_of(priv, t, timer); 255 255 struct psmouse *psmouse = priv->psmouse; 256 256 257 257 guard(serio_pause_rx)(psmouse->ps2dev.serio);

+1 -1

drivers/input/touchscreen/ad7877.c

reviewed

··· 375 375 376 376 static void ad7877_timer(struct timer_list *t) 377 377 { 378 378 - struct ad7877 *ts = from_timer(ts, t, timer); 378 378 + struct ad7877 *ts = timer_container_of(ts, t, timer); 379 379 unsigned long flags; 380 380 381 381 spin_lock_irqsave(&ts->lock, flags);

+1 -1

drivers/input/touchscreen/ad7879.c

reviewed

··· 237 237 238 238 static void ad7879_timer(struct timer_list *t) 239 239 { 240 240 - struct ad7879 *ts = from_timer(ts, t, timer); 240 240 + struct ad7879 *ts = timer_container_of(ts, t, timer); 241 241 242 242 ad7879_ts_event_release(ts); 243 243 }

+2 -1

drivers/input/touchscreen/bu21029_ts.c

reviewed

··· 209 209 210 210 static void bu21029_touch_release(struct timer_list *t) 211 211 { 212 212 - struct bu21029_ts_data *bu21029 = from_timer(bu21029, t, timer); 212 212 + struct bu21029_ts_data *bu21029 = timer_container_of(bu21029, t, 213 213 + timer); 213 214 214 215 input_report_abs(bu21029->in_dev, ABS_PRESSURE, 0); 215 216 input_report_key(bu21029->in_dev, BTN_TOUCH, 0);

+1 -1

drivers/input/touchscreen/exc3000.c

reviewed

··· 105 105 106 106 static void exc3000_timer(struct timer_list *t) 107 107 { 108 108 - struct exc3000_data *data = from_timer(data, t, timer); 108 108 + struct exc3000_data *data = timer_container_of(data, t, timer); 109 109 110 110 input_mt_sync_frame(data->input); 111 111 input_sync(data->input);

+1 -1

drivers/input/touchscreen/sx8654.c

reviewed

··· 116 116 117 117 static void sx865x_penrelease_timer_handler(struct timer_list *t) 118 118 { 119 119 - struct sx8654 *ts = from_timer(ts, t, timer); 119 119 + struct sx8654 *ts = timer_container_of(ts, t, timer); 120 120 unsigned long flags; 121 121 122 122 spin_lock_irqsave(&ts->lock, flags);

+1 -1

drivers/input/touchscreen/tsc200x-core.c

reviewed

··· 194 194 195 195 static void tsc200x_penup_timer(struct timer_list *t) 196 196 { 197 197 - struct tsc200x *ts = from_timer(ts, t, penup_timer); 197 197 + struct tsc200x *ts = timer_container_of(ts, t, penup_timer); 198 198 199 199 guard(spinlock_irqsave)(&ts->lock); 200 200 tsc200x_update_pen_state(ts, 0, 0, 0);

+2 -1

drivers/iommu/dma-iommu.c

reviewed

··· 179 179 180 180 static void fq_flush_timeout(struct timer_list *t) 181 181 { 182 182 - struct iommu_dma_cookie *cookie = from_timer(cookie, t, fq_timer); 182 182 + struct iommu_dma_cookie *cookie = timer_container_of(cookie, t, 183 183 + fq_timer); 183 184 int cpu; 184 185 185 186 atomic_set(&cookie->fq_timer_on, 0);

+1 -1

drivers/isdn/hardware/mISDN/hfcpci.c

reviewed

··· 291 291 static void 292 292 hfcpci_Timer(struct timer_list *t) 293 293 { 294 294 - struct hfc_pci *hc = from_timer(hc, t, hw.timer); 294 294 + struct hfc_pci *hc = timer_container_of(hc, t, hw.timer); 295 295 hc->hw.timer.expires = jiffies + 75; 296 296 /* WD RESET */ 297 297 /*

+1 -1

drivers/isdn/hardware/mISDN/mISDNipac.c

reviewed

··· 713 713 static void 714 714 dbusy_timer_handler(struct timer_list *t) 715 715 { 716 716 - struct isac_hw *isac = from_timer(isac, t, dch.timer); 716 716 + struct isac_hw *isac = timer_container_of(isac, t, dch.timer); 717 717 int rbch, star; 718 718 u_long flags; 719 719

+1 -1

drivers/isdn/hardware/mISDN/mISDNisar.c

reviewed

··· 1135 1135 static void 1136 1136 ftimer_handler(struct timer_list *t) 1137 1137 { 1138 1138 - struct isar_ch *ch = from_timer(ch, t, ftimer); 1138 1138 + struct isar_ch *ch = timer_container_of(ch, t, ftimer); 1139 1139 1140 1140 pr_debug("%s: ftimer flags %lx\n", ch->is->name, ch->bch.Flags); 1141 1141 test_and_clear_bit(FLG_FTI_RUN, &ch->bch.Flags);

+1 -1

drivers/isdn/hardware/mISDN/w6692.c

reviewed

··· 802 802 static void 803 803 dbusy_timer_handler(struct timer_list *t) 804 804 { 805 805 - struct dchannel *dch = from_timer(dch, t, timer); 805 805 + struct dchannel *dch = timer_container_of(dch, t, timer); 806 806 struct w6692_hw *card = dch->hw; 807 807 int rbch, star; 808 808 u_long flags;

+1 -1

drivers/isdn/mISDN/dsp_tones.c

reviewed

··· 459 459 void 460 460 dsp_tone_timeout(struct timer_list *t) 461 461 { 462 462 - struct dsp *dsp = from_timer(dsp, t, tone.tl); 462 462 + struct dsp *dsp = timer_container_of(dsp, t, tone.tl); 463 463 struct dsp_tone *tone = &dsp->tone; 464 464 struct pattern *pat = (struct pattern *)tone->pattern; 465 465 int index = tone->index;

+1 -1

drivers/isdn/mISDN/fsm.c

reviewed

··· 95 95 static void 96 96 FsmExpireTimer(struct timer_list *t) 97 97 { 98 98 - struct FsmTimer *ft = from_timer(ft, t, tl); 98 98 + struct FsmTimer *ft = timer_container_of(ft, t, tl); 99 99 #if FSM_TIMER_DEBUG 100 100 if (ft->fi->debug) 101 101 ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft);

+3 -3

drivers/isdn/mISDN/l1oip_core.c

reviewed

··· 822 822 static void 823 823 l1oip_keepalive(struct timer_list *t) 824 824 { 825 825 - struct l1oip *hc = from_timer(hc, t, keep_tl); 825 825 + struct l1oip *hc = timer_container_of(hc, t, keep_tl); 826 826 827 827 schedule_work(&hc->workq); 828 828 } ··· 830 830 static void 831 831 l1oip_timeout(struct timer_list *t) 832 832 { 833 833 - struct l1oip *hc = from_timer(hc, t, 834 834 - timeout_tl); 833 833 + struct l1oip *hc = timer_container_of(hc, t, 834 834 + timeout_tl); 835 835 struct dchannel *dch = hc->chan[hc->d_idx].dch; 836 836 837 837 if (debug & DEBUG_L1OIP_MSG)

+1 -1

drivers/isdn/mISDN/timerdev.c

reviewed

··· 155 155 static void 156 156 dev_expire_timer(struct timer_list *t) 157 157 { 158 158 - struct mISDNtimer *timer = from_timer(timer, t, tl); 158 158 + struct mISDNtimer *timer = timer_container_of(timer, t, tl); 159 159 u_long flags; 160 160 161 161 spin_lock_irqsave(&timer->dev->lock, flags);

+1 -1

drivers/leds/flash/leds-rt8515.c

reviewed

··· 165 165 166 166 static void rt8515_powerdown_timer(struct timer_list *t) 167 167 { 168 168 - struct rt8515 *rt = from_timer(rt, t, powerdown_timer); 168 168 + struct rt8515 *rt = timer_container_of(rt, t, powerdown_timer); 169 169 170 170 /* Turn the LED off */ 171 171 rt8515_gpio_led_off(rt);

+1 -1

drivers/leds/flash/leds-sgm3140.c

reviewed

··· 135 135 136 136 static void sgm3140_powerdown_timer(struct timer_list *t) 137 137 { 138 138 - struct sgm3140 *priv = from_timer(priv, t, powerdown_timer); 138 138 + struct sgm3140 *priv = timer_container_of(priv, t, powerdown_timer); 139 139 140 140 gpiod_set_value(priv->enable_gpio, 0); 141 141 gpiod_set_value(priv->flash_gpio, 0);

+2 -1

drivers/leds/led-core.c

reviewed

··· 64 64 65 65 static void led_timer_function(struct timer_list *t) 66 66 { 67 67 - struct led_classdev *led_cdev = from_timer(led_cdev, t, blink_timer); 67 67 + struct led_classdev *led_cdev = timer_container_of(led_cdev, t, 68 68 + blink_timer); 68 69 unsigned long brightness; 69 70 unsigned long delay; 70 71

+2 -2

drivers/leds/trigger/ledtrig-activity.c

reviewed

··· 32 32 33 33 static void led_activity_function(struct timer_list *t) 34 34 { 35 35 - struct activity_data *activity_data = from_timer(activity_data, t, 36 36 - timer); 35 35 + struct activity_data *activity_data = timer_container_of(activity_data, 36 36 + t, timer); 37 37 struct led_classdev *led_cdev = activity_data->led_cdev; 38 38 unsigned int target; 39 39 unsigned int usage;

+1 -1

drivers/leds/trigger/ledtrig-heartbeat.c

reviewed

··· 33 33 static void led_heartbeat_function(struct timer_list *t) 34 34 { 35 35 struct heartbeat_trig_data *heartbeat_data = 36 36 - from_timer(heartbeat_data, t, timer); 36 36 + timer_container_of(heartbeat_data, t, timer); 37 37 struct led_classdev *led_cdev; 38 38 unsigned long brightness = LED_OFF; 39 39 unsigned long delay = 0;

+1 -1

drivers/leds/trigger/ledtrig-pattern.c

reviewed

··· 150 150 151 151 static void pattern_trig_timer_function(struct timer_list *t) 152 152 { 153 153 - struct pattern_trig_data *data = from_timer(data, t, timer); 153 153 + struct pattern_trig_data *data = timer_container_of(data, t, timer); 154 154 155 155 return pattern_trig_timer_common_function(data); 156 156 }

+1 -1

drivers/leds/trigger/ledtrig-transient.c

reviewed

··· 32 32 static void transient_timer_function(struct timer_list *t) 33 33 { 34 34 struct transient_trig_data *transient_data = 35 35 - from_timer(transient_data, t, timer); 35 35 + timer_container_of(transient_data, t, timer); 36 36 struct led_classdev *led_cdev = transient_data->led_cdev; 37 37 38 38 transient_data->activate = 0;

+1 -1

drivers/mailbox/mailbox-altera.c

reviewed

··· 130 130 131 131 static void altera_mbox_poll_rx(struct timer_list *t) 132 132 { 133 133 - struct altera_mbox *mbox = from_timer(mbox, t, rxpoll_timer); 133 133 + struct altera_mbox *mbox = timer_container_of(mbox, t, rxpoll_timer); 134 134 135 135 altera_mbox_rx_data(mbox->chan); 136 136

+1 -1

drivers/md/bcache/stats.c

reviewed

··· 149 149 150 150 static void scale_accounting(struct timer_list *t) 151 151 { 152 152 - struct cache_accounting *acc = from_timer(acc, t, timer); 152 152 + struct cache_accounting *acc = timer_container_of(acc, t, timer); 153 153 154 154 #define move_stat(name) do { \ 155 155 unsigned int t = atomic_xchg(&acc->collector.name, 0); \

+1 -1

drivers/md/dm-delay.c

reviewed

··· 56 56 57 57 static void handle_delayed_timer(struct timer_list *t) 58 58 { 59 59 - struct delay_c *dc = from_timer(dc, t, delay_timer); 59 59 + struct delay_c *dc = timer_container_of(dc, t, delay_timer); 60 60 61 61 queue_work(dc->kdelayd_wq, &dc->flush_expired_bios); 62 62 }

+2 -1

drivers/md/dm-integrity.c

reviewed

··· 1540 1540 1541 1541 static void autocommit_fn(struct timer_list *t) 1542 1542 { 1543 1543 - struct dm_integrity_c *ic = from_timer(ic, t, autocommit_timer); 1543 1543 + struct dm_integrity_c *ic = timer_container_of(ic, t, 1544 1544 + autocommit_timer); 1544 1545 1545 1546 if (likely(!dm_integrity_failed(ic))) 1546 1547 queue_work(ic->commit_wq, &ic->commit_work);

+1 -1

drivers/md/dm-mpath.c

reviewed

··· 790 790 */ 791 791 static void queue_if_no_path_timeout_work(struct timer_list *t) 792 792 { 793 793 - struct multipath *m = from_timer(m, t, nopath_timer); 793 793 + struct multipath *m = timer_container_of(m, t, nopath_timer); 794 794 795 795 DMWARN("queue_if_no_path timeout on %s, failing queued IO", 796 796 dm_table_device_name(m->ti->table));

+1 -1

drivers/md/dm-raid1.c

reviewed

··· 103 103 104 104 static void delayed_wake_fn(struct timer_list *t) 105 105 { 106 106 - struct mirror_set *ms = from_timer(ms, t, timer); 106 106 + struct mirror_set *ms = timer_container_of(ms, t, timer); 107 107 108 108 clear_bit(0, &ms->timer_pending); 109 109 wakeup_mirrord(ms);

+1 -1

drivers/md/dm-vdo/dedupe.c

reviewed

··· 2337 2337 2338 2338 static void timeout_index_operations(struct timer_list *t) 2339 2339 { 2340 2340 - struct hash_zone *zone = from_timer(zone, t, timer); 2340 2340 + struct hash_zone *zone = timer_container_of(zone, t, timer); 2341 2341 2342 2342 if (change_timer_state(zone, DEDUPE_QUERY_TIMER_RUNNING, 2343 2343 DEDUPE_QUERY_TIMER_FIRED))

+2 -2

drivers/md/dm-writecache.c

reviewed

··· 706 706 707 707 static void writecache_max_age_timer(struct timer_list *t) 708 708 { 709 709 - struct dm_writecache *wc = from_timer(wc, t, max_age_timer); 709 709 + struct dm_writecache *wc = timer_container_of(wc, t, max_age_timer); 710 710 711 711 if (!dm_suspended(wc->ti) && !writecache_has_error(wc)) { 712 712 queue_work(wc->writeback_wq, &wc->writeback_work); ··· 866 866 867 867 static void writecache_autocommit_timer(struct timer_list *t) 868 868 { 869 869 - struct dm_writecache *wc = from_timer(wc, t, autocommit_timer); 869 869 + struct dm_writecache *wc = timer_container_of(wc, t, autocommit_timer); 870 870 871 871 if (!writecache_has_error(wc)) 872 872 queue_work(wc->writeback_wq, &wc->flush_work);

+1 -1

drivers/md/md.c

reviewed

··· 6048 6048 6049 6049 static void md_safemode_timeout(struct timer_list *t) 6050 6050 { 6051 6051 - struct mddev *mddev = from_timer(mddev, t, safemode_timer); 6051 6051 + struct mddev *mddev = timer_container_of(mddev, t, safemode_timer); 6052 6052 6053 6053 mddev->safemode = 1; 6054 6054 if (mddev->external)

+1 -1

drivers/media/common/saa7146/saa7146_fops.c

reviewed

··· 153 153 154 154 void saa7146_buffer_timeout(struct timer_list *t) 155 155 { 156 156 - struct saa7146_dmaqueue *q = from_timer(q, t, timeout); 156 156 + struct saa7146_dmaqueue *q = timer_container_of(q, t, timeout); 157 157 struct saa7146_dev *dev = q->dev; 158 158 unsigned long flags; 159 159

+1 -1

drivers/media/common/saa7146/saa7146_vbi.c

reviewed

··· 330 330 331 331 static void vbi_read_timeout(struct timer_list *t) 332 332 { 333 333 - struct saa7146_vv *vv = from_timer(vv, t, vbi_read_timeout); 333 333 + struct saa7146_vv *vv = timer_container_of(vv, t, vbi_read_timeout); 334 334 struct saa7146_dev *dev = vv->vbi_dmaq.dev; 335 335 336 336 DEB_VBI("dev:%p\n", dev);

+2 -1

drivers/media/dvb-core/dmxdev.c

reviewed

··· 352 352 353 353 static void dvb_dmxdev_filter_timeout(struct timer_list *t) 354 354 { 355 355 - struct dmxdev_filter *dmxdevfilter = from_timer(dmxdevfilter, t, timer); 355 355 + struct dmxdev_filter *dmxdevfilter = timer_container_of(dmxdevfilter, 356 356 + t, timer); 356 357 357 358 dmxdevfilter->buffer.error = -ETIMEDOUT; 358 359 spin_lock_irq(&dmxdevfilter->dev->lock);

+1 -1

drivers/media/i2c/tc358743.c

reviewed

··· 1505 1505 1506 1506 static void tc358743_irq_poll_timer(struct timer_list *t) 1507 1507 { 1508 1508 - struct tc358743_state *state = from_timer(state, t, timer); 1508 1508 + struct tc358743_state *state = timer_container_of(state, t, timer); 1509 1509 unsigned int msecs; 1510 1510 1511 1511 schedule_work(&state->work_i2c_poll);

+1 -1

drivers/media/i2c/tvaudio.c

reviewed

··· 318 318 319 319 static void chip_thread_wake(struct timer_list *t) 320 320 { 321 321 - struct CHIPSTATE *chip = from_timer(chip, t, wt); 321 321 + struct CHIPSTATE *chip = timer_container_of(chip, t, wt); 322 322 wake_up_process(chip->thread); 323 323 } 324 324

+1 -1

drivers/media/pci/bt8xx/bttv-driver.c

reviewed

··· 2798 2798 2799 2799 static void bttv_irq_timeout(struct timer_list *t) 2800 2800 { 2801 2801 - struct bttv *btv = from_timer(btv, t, timeout); 2801 2801 + struct bttv *btv = timer_container_of(btv, t, timeout); 2802 2802 struct bttv_buffer_set old,new; 2803 2803 struct bttv_buffer *ovbi; 2804 2804 struct bttv_buffer *item;

+2 -2

drivers/media/pci/bt8xx/bttv-input.c

reviewed

··· 126 126 127 127 static void bttv_input_timer(struct timer_list *t) 128 128 { 129 129 - struct bttv_ir *ir = from_timer(ir, t, timer); 129 129 + struct bttv_ir *ir = timer_container_of(ir, t, timer); 130 130 struct bttv *btv = ir->btv; 131 131 132 132 if (btv->c.type == BTTV_BOARD_ENLTV_FM_2) ··· 182 182 183 183 static void bttv_rc5_timer_end(struct timer_list *t) 184 184 { 185 185 - struct bttv_ir *ir = from_timer(ir, t, timer); 185 185 + struct bttv_ir *ir = timer_container_of(ir, t, timer); 186 186 ktime_t tv; 187 187 u32 gap, rc5, scancode; 188 188 u8 toggle, command, system;

+1 -1

drivers/media/pci/cx18/cx18-fileops.c

reviewed

··· 628 628 629 629 void cx18_vb_timeout(struct timer_list *t) 630 630 { 631 631 - struct cx18_stream *s = from_timer(s, t, vb_timeout); 631 631 + struct cx18_stream *s = timer_container_of(s, t, vb_timeout); 632 632 633 633 /* 634 634 * Return all of the buffers in error state, so the vbi/vid inode

+1 -1

drivers/media/pci/ivtv/ivtv-irq.c

reviewed

··· 1064 1064 1065 1065 void ivtv_unfinished_dma(struct timer_list *t) 1066 1066 { 1067 1067 - struct ivtv *itv = from_timer(itv, t, dma_timer); 1067 1067 + struct ivtv *itv = timer_container_of(itv, t, dma_timer); 1068 1068 1069 1069 if (!test_bit(IVTV_F_I_DMA, &itv->i_flags)) 1070 1070 return;

+1 -1

drivers/media/pci/netup_unidvb/netup_unidvb_core.c

reviewed

··· 637 637 638 638 static void netup_unidvb_dma_timeout(struct timer_list *t) 639 639 { 640 640 - struct netup_dma *dma = from_timer(dma, t, timeout); 640 640 + struct netup_dma *dma = timer_container_of(dma, t, timeout); 641 641 struct netup_unidvb_dev *ndev = dma->ndev; 642 642 643 643 dev_dbg(&ndev->pci_dev->dev, "%s()\n", __func__);

+1 -1

drivers/media/pci/saa7134/saa7134-core.c

reviewed

··· 328 328 329 329 void saa7134_buffer_timeout(struct timer_list *t) 330 330 { 331 331 - struct saa7134_dmaqueue *q = from_timer(q, t, timeout); 331 331 + struct saa7134_dmaqueue *q = timer_container_of(q, t, timeout); 332 332 struct saa7134_dev *dev = q->dev; 333 333 unsigned long flags; 334 334

+1 -1

drivers/media/pci/saa7134/saa7134-input.c

reviewed

··· 431 431 432 432 static void saa7134_input_timer(struct timer_list *t) 433 433 { 434 434 - struct saa7134_card_ir *ir = from_timer(ir, t, timer); 434 434 + struct saa7134_card_ir *ir = timer_container_of(ir, t, timer); 435 435 struct saa7134_dev *dev = ir->dev->priv; 436 436 437 437 build_key(dev);

+1 -1

drivers/media/pci/tw686x/tw686x-core.c

reviewed

··· 125 125 */ 126 126 static void tw686x_dma_delay(struct timer_list *t) 127 127 { 128 128 - struct tw686x_dev *dev = from_timer(dev, t, dma_delay_timer); 128 128 + struct tw686x_dev *dev = timer_container_of(dev, t, dma_delay_timer); 129 129 unsigned long flags; 130 130 131 131 spin_lock_irqsave(&dev->lock, flags);

+1 -1

drivers/media/platform/samsung/s5p-mfc/s5p_mfc.c

reviewed

··· 143 143 144 144 static void s5p_mfc_watchdog(struct timer_list *t) 145 145 { 146 146 - struct s5p_mfc_dev *dev = from_timer(dev, t, watchdog_timer); 146 146 + struct s5p_mfc_dev *dev = timer_container_of(dev, t, watchdog_timer); 147 147 148 148 if (test_bit(0, &dev->hw_lock)) 149 149 atomic_inc(&dev->watchdog_cnt);

+1 -1

drivers/media/platform/st/sti/c8sectpfe/c8sectpfe-core.c

reviewed

··· 62 62 63 63 static void c8sectpfe_timer_interrupt(struct timer_list *t) 64 64 { 65 65 - struct c8sectpfei *fei = from_timer(fei, t, timer); 65 65 + struct c8sectpfei *fei = timer_container_of(fei, t, timer); 66 66 struct channel_info *channel; 67 67 int chan_num; 68 68

+1 -1

drivers/media/radio/radio-cadet.c

reviewed

··· 284 284 285 285 static void cadet_handler(struct timer_list *t) 286 286 { 287 287 - struct cadet *dev = from_timer(dev, t, readtimer); 287 287 + struct cadet *dev = timer_container_of(dev, t, readtimer); 288 288 289 289 /* Service the RDS fifo */ 290 290 if (mutex_trylock(&dev->lock)) {

+1 -1

drivers/media/rc/ene_ir.c

reviewed

··· 659 659 /* timer to simulate tx done interrupt */ 660 660 static void ene_tx_irqsim(struct timer_list *t) 661 661 { 662 662 - struct ene_device *dev = from_timer(dev, t, tx_sim_timer); 662 662 + struct ene_device *dev = timer_container_of(dev, t, tx_sim_timer); 663 663 unsigned long flags; 664 664 665 665 spin_lock_irqsave(&dev->hw_lock, flags);

+1 -1

drivers/media/rc/igorplugusb.c

reviewed

··· 131 131 132 132 static void igorplugusb_timer(struct timer_list *t) 133 133 { 134 134 - struct igorplugusb *ir = from_timer(ir, t, timer); 134 134 + struct igorplugusb *ir = timer_container_of(ir, t, timer); 135 135 136 136 igorplugusb_cmd(ir, GET_INFRACODE); 137 137 }

+3 -2

drivers/media/rc/img-ir/img-ir-hw.c

reviewed

··· 865 865 /* timer function to end waiting for repeat. */ 866 866 static void img_ir_end_timer(struct timer_list *t) 867 867 { 868 868 - struct img_ir_priv *priv = from_timer(priv, t, hw.end_timer); 868 868 + struct img_ir_priv *priv = timer_container_of(priv, t, hw.end_timer); 869 869 870 870 spin_lock_irq(&priv->lock); 871 871 img_ir_end_repeat(priv); ··· 879 879 */ 880 880 static void img_ir_suspend_timer(struct timer_list *t) 881 881 { 882 882 - struct img_ir_priv *priv = from_timer(priv, t, hw.suspend_timer); 882 882 + struct img_ir_priv *priv = timer_container_of(priv, t, 883 883 + hw.suspend_timer); 883 884 884 885 spin_lock_irq(&priv->lock); 885 886 /*

+1 -1

drivers/media/rc/img-ir/img-ir-raw.c

reviewed

··· 65 65 */ 66 66 static void img_ir_echo_timer(struct timer_list *t) 67 67 { 68 68 - struct img_ir_priv *priv = from_timer(priv, t, raw.timer); 68 68 + struct img_ir_priv *priv = timer_container_of(priv, t, raw.timer); 69 69 70 70 spin_lock_irq(&priv->lock); 71 71

+1 -1

drivers/media/rc/imon.c

reviewed

··· 1091 1091 */ 1092 1092 static void imon_touch_display_timeout(struct timer_list *t) 1093 1093 { 1094 1094 - struct imon_context *ictx = from_timer(ictx, t, ttimer); 1094 1094 + struct imon_context *ictx = timer_container_of(ictx, t, ttimer); 1095 1095 1096 1096 if (ictx->display_type != IMON_DISPLAY_TYPE_VGA) 1097 1097 return;

+2 -1

drivers/media/rc/ir-mce_kbd-decoder.c

reviewed

··· 109 109 110 110 static void mce_kbd_rx_timeout(struct timer_list *t) 111 111 { 112 112 - struct ir_raw_event_ctrl *raw = from_timer(raw, t, mce_kbd.rx_timeout); 112 112 + struct ir_raw_event_ctrl *raw = timer_container_of(raw, t, 113 113 + mce_kbd.rx_timeout); 113 114 unsigned char maskcode; 114 115 unsigned long flags; 115 116 int i;

+2 -1

drivers/media/rc/rc-ir-raw.c

reviewed

··· 552 552 */ 553 553 static void ir_raw_edge_handle(struct timer_list *t) 554 554 { 555 555 - struct ir_raw_event_ctrl *raw = from_timer(raw, t, edge_handle); 555 555 + struct ir_raw_event_ctrl *raw = timer_container_of(raw, t, 556 556 + edge_handle); 556 557 struct rc_dev *dev = raw->dev; 557 558 unsigned long flags; 558 559 ktime_t interval;

+2 -2

drivers/media/rc/rc-main.c

reviewed

··· 674 674 */ 675 675 static void ir_timer_keyup(struct timer_list *t) 676 676 { 677 677 - struct rc_dev *dev = from_timer(dev, t, timer_keyup); 677 677 + struct rc_dev *dev = timer_container_of(dev, t, timer_keyup); 678 678 unsigned long flags; 679 679 680 680 /* ··· 703 703 */ 704 704 static void ir_timer_repeat(struct timer_list *t) 705 705 { 706 706 - struct rc_dev *dev = from_timer(dev, t, timer_repeat); 706 706 + struct rc_dev *dev = timer_container_of(dev, t, timer_repeat); 707 707 struct input_dev *input = dev->input_dev; 708 708 unsigned long flags; 709 709

+1 -1

drivers/media/usb/au0828/au0828-dvb.c

reviewed

··· 97 97 98 98 static void au0828_bulk_timeout(struct timer_list *t) 99 99 { 100 100 - struct au0828_dev *dev = from_timer(dev, t, bulk_timeout); 100 100 + struct au0828_dev *dev = timer_container_of(dev, t, bulk_timeout); 101 101 102 102 dprintk(1, "%s called\n", __func__); 103 103 dev->bulk_timeout_running = 0;

+2 -2

drivers/media/usb/au0828/au0828-video.c

reviewed

··· 948 948 such as tvtime from hanging) */ 949 949 static void au0828_vid_buffer_timeout(struct timer_list *t) 950 950 { 951 951 - struct au0828_dev *dev = from_timer(dev, t, vid_timeout); 951 951 + struct au0828_dev *dev = timer_container_of(dev, t, vid_timeout); 952 952 struct au0828_dmaqueue *dma_q = &dev->vidq; 953 953 struct au0828_buffer *buf; 954 954 unsigned char *vid_data; ··· 972 972 973 973 static void au0828_vbi_buffer_timeout(struct timer_list *t) 974 974 { 975 975 - struct au0828_dev *dev = from_timer(dev, t, vbi_timeout); 975 975 + struct au0828_dev *dev = timer_container_of(dev, t, vbi_timeout); 976 976 struct au0828_dmaqueue *dma_q = &dev->vbiq; 977 977 struct au0828_buffer *buf; 978 978 unsigned char *vbi_data;

+6 -5

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

reviewed

··· 3562 3562 3563 3563 static void pvr2_ctl_timeout(struct timer_list *t) 3564 3564 { 3565 3565 - struct hdw_timer *timer = from_timer(timer, t, timer); 3565 3565 + struct hdw_timer *timer = timer_container_of(timer, t, timer); 3566 3566 struct pvr2_hdw *hdw = timer->hdw; 3567 3567 3568 3568 if (hdw->ctl_write_pend_flag || hdw->ctl_read_pend_flag) { ··· 4421 4421 /* Timeout function for quiescent timer. */ 4422 4422 static void pvr2_hdw_quiescent_timeout(struct timer_list *t) 4423 4423 { 4424 4424 - struct pvr2_hdw *hdw = from_timer(hdw, t, quiescent_timer); 4424 4424 + struct pvr2_hdw *hdw = timer_container_of(hdw, t, quiescent_timer); 4425 4425 hdw->state_decoder_quiescent = !0; 4426 4426 trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent); 4427 4427 hdw->state_stale = !0; ··· 4432 4432 /* Timeout function for decoder stabilization timer. */ 4433 4433 static void pvr2_hdw_decoder_stabilization_timeout(struct timer_list *t) 4434 4434 { 4435 4435 - struct pvr2_hdw *hdw = from_timer(hdw, t, decoder_stabilization_timer); 4435 4435 + struct pvr2_hdw *hdw = timer_container_of(hdw, t, 4436 4436 + decoder_stabilization_timer); 4436 4437 hdw->state_decoder_ready = !0; 4437 4438 trace_stbit("state_decoder_ready", hdw->state_decoder_ready); 4438 4439 hdw->state_stale = !0; ··· 4444 4443 /* Timeout function for encoder wait timer. */ 4445 4444 static void pvr2_hdw_encoder_wait_timeout(struct timer_list *t) 4446 4445 { 4447 4447 - struct pvr2_hdw *hdw = from_timer(hdw, t, encoder_wait_timer); 4446 4446 + struct pvr2_hdw *hdw = timer_container_of(hdw, t, encoder_wait_timer); 4448 4447 hdw->state_encoder_waitok = !0; 4449 4448 trace_stbit("state_encoder_waitok",hdw->state_encoder_waitok); 4450 4449 hdw->state_stale = !0; ··· 4455 4454 /* Timeout function for encoder run timer. */ 4456 4455 static void pvr2_hdw_encoder_run_timeout(struct timer_list *t) 4457 4456 { 4458 4458 - struct pvr2_hdw *hdw = from_timer(hdw, t, encoder_run_timer); 4457 4457 + struct pvr2_hdw *hdw = timer_container_of(hdw, t, encoder_run_timer); 4459 4458 if (!hdw->state_encoder_runok) { 4460 4459 hdw->state_encoder_runok = !0; 4461 4460 trace_stbit("state_encoder_runok",hdw->state_encoder_runok);

+1 -1

drivers/media/usb/s2255/s2255drv.c

reviewed

··· 471 471 */ 472 472 static void s2255_timer(struct timer_list *t) 473 473 { 474 474 - struct s2255_dev *dev = from_timer(dev, t, timer); 474 474 + struct s2255_dev *dev = timer_container_of(dev, t, timer); 475 475 struct s2255_fw *data = dev->fw_data; 476 476 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) { 477 477 pr_err("s2255: can't submit urb\n");

+3 -2

drivers/memory/tegra/tegra210-emc-core.c

reviewed

··· 558 558 559 559 static void tegra210_emc_train(struct timer_list *timer) 560 560 { 561 561 - struct tegra210_emc *emc = from_timer(emc, timer, training); 561 561 + struct tegra210_emc *emc = timer_container_of(emc, timer, training); 562 562 unsigned long flags; 563 563 564 564 if (!emc->last) ··· 614 614 615 615 static void tegra210_emc_poll_refresh(struct timer_list *timer) 616 616 { 617 617 - struct tegra210_emc *emc = from_timer(emc, timer, refresh_timer); 617 617 + struct tegra210_emc *emc = timer_container_of(emc, timer, 618 618 + refresh_timer); 618 619 unsigned int temperature; 619 620 620 621 if (!emc->debugfs.temperature)

+1 -1

drivers/memstick/core/ms_block.c

reviewed

··· 1498 1498 1499 1499 static void msb_cache_flush_timer(struct timer_list *t) 1500 1500 { 1501 1501 - struct msb_data *msb = from_timer(msb, t, cache_flush_timer); 1501 1501 + struct msb_data *msb = timer_container_of(msb, t, cache_flush_timer); 1502 1502 1503 1503 msb->need_flush_cache = true; 1504 1504 queue_work(msb->io_queue, &msb->io_work);

+1 -1

drivers/memstick/host/jmb38x_ms.c

reviewed

··· 590 590 591 591 static void jmb38x_ms_abort(struct timer_list *t) 592 592 { 593 593 - struct jmb38x_ms_host *host = from_timer(host, t, timer); 593 593 + struct jmb38x_ms_host *host = timer_container_of(host, t, timer); 594 594 struct memstick_host *msh = host->msh; 595 595 unsigned long flags; 596 596

+1 -1

drivers/memstick/host/r592.c

reviewed

··· 614 614 /* Timer routine that fires 1 second after last card detection event, */ 615 615 static void r592_detect_timer(struct timer_list *t) 616 616 { 617 617 - struct r592_device *dev = from_timer(dev, t, detect_timer); 617 617 + struct r592_device *dev = timer_container_of(dev, t, detect_timer); 618 618 r592_update_card_detect(dev); 619 619 memstick_detect_change(dev->host); 620 620 }

+1 -1

drivers/memstick/host/tifm_ms.c

reviewed

··· 535 535 536 536 static void tifm_ms_abort(struct timer_list *t) 537 537 { 538 538 - struct tifm_ms *host = from_timer(host, t, timer); 538 538 + struct tifm_ms *host = timer_container_of(host, t, timer); 539 539 540 540 dev_dbg(&host->dev->dev, "status %x\n", 541 541 readl(host->dev->addr + SOCK_MS_STATUS));

+1 -1

drivers/misc/bcm-vk/bcm_vk_tty.c

reviewed

··· 43 43 44 44 static void bcm_vk_tty_poll(struct timer_list *t) 45 45 { 46 46 - struct bcm_vk *vk = from_timer(vk, t, serial_timer); 46 46 + struct bcm_vk *vk = timer_container_of(vk, t, serial_timer); 47 47 48 48 queue_work(vk->tty_wq_thread, &vk->tty_wq_work); 49 49 mod_timer(&vk->serial_timer, jiffies + SERIAL_TIMER_VALUE);

+1 -1

drivers/misc/cardreader/rtsx_usb.c

reviewed

··· 31 31 32 32 static void rtsx_usb_sg_timed_out(struct timer_list *t) 33 33 { 34 34 - struct rtsx_ucr *ucr = from_timer(ucr, t, sg_timer); 34 34 + struct rtsx_ucr *ucr = timer_container_of(ucr, t, sg_timer); 35 35 36 36 dev_dbg(&ucr->pusb_intf->dev, "%s: sg transfer timed out", __func__); 37 37 usb_sg_cancel(&ucr->current_sg);

+2 -1

drivers/misc/sgi-xp/xpc_main.c

reviewed

··· 164 164 static void 165 165 xpc_timeout_partition_disengage(struct timer_list *t) 166 166 { 167 167 - struct xpc_partition *part = from_timer(part, t, disengage_timer); 167 167 + struct xpc_partition *part = timer_container_of(part, t, 168 168 + disengage_timer); 168 169 169 170 DBUG_ON(time_is_after_jiffies(part->disengage_timeout)); 170 171

+1 -1

drivers/mmc/core/host.c

reviewed

··· 212 212 213 213 static void mmc_retune_timer(struct timer_list *t) 214 214 { 215 215 - struct mmc_host *host = from_timer(host, t, retune_timer); 215 215 + struct mmc_host *host = timer_container_of(host, t, retune_timer); 216 216 217 217 mmc_retune_needed(host); 218 218 }

+3 -2

drivers/mmc/host/atmel-mci.c

reviewed

··· 714 714 715 715 static void atmci_timeout_timer(struct timer_list *t) 716 716 { 717 717 - struct atmel_mci *host = from_timer(host, t, timer); 717 717 + struct atmel_mci *host = timer_container_of(host, t, timer); 718 718 struct device *dev = host->dev; 719 719 720 720 dev_dbg(dev, "software timeout\n"); ··· 1652 1652 1653 1653 static void atmci_detect_change(struct timer_list *t) 1654 1654 { 1655 1655 - struct atmel_mci_slot *slot = from_timer(slot, t, detect_timer); 1655 1655 + struct atmel_mci_slot *slot = timer_container_of(slot, t, 1656 1656 + detect_timer); 1656 1657 bool present; 1657 1658 bool present_old; 1658 1659

+3 -3

drivers/mmc/host/dw_mmc.c

reviewed

··· 3179 3179 3180 3180 static void dw_mci_cmd11_timer(struct timer_list *t) 3181 3181 { 3182 3182 - struct dw_mci *host = from_timer(host, t, cmd11_timer); 3182 3182 + struct dw_mci *host = timer_container_of(host, t, cmd11_timer); 3183 3183 3184 3184 if (host->state != STATE_SENDING_CMD11) { 3185 3185 dev_warn(host->dev, "Unexpected CMD11 timeout\n"); ··· 3193 3193 3194 3194 static void dw_mci_cto_timer(struct timer_list *t) 3195 3195 { 3196 3196 - struct dw_mci *host = from_timer(host, t, cto_timer); 3196 3196 + struct dw_mci *host = timer_container_of(host, t, cto_timer); 3197 3197 unsigned long irqflags; 3198 3198 u32 pending; 3199 3199 ··· 3248 3248 3249 3249 static void dw_mci_dto_timer(struct timer_list *t) 3250 3250 { 3251 3251 - struct dw_mci *host = from_timer(host, t, dto_timer); 3251 3251 + struct dw_mci *host = timer_container_of(host, t, dto_timer); 3252 3252 unsigned long irqflags; 3253 3253 u32 pending; 3254 3254

+2 -1

drivers/mmc/host/jz4740_mmc.c

reviewed

··· 641 641 642 642 static void jz4740_mmc_timeout(struct timer_list *t) 643 643 { 644 644 - struct jz4740_mmc_host *host = from_timer(host, t, timeout_timer); 644 644 + struct jz4740_mmc_host *host = timer_container_of(host, t, 645 645 + timeout_timer); 645 646 646 647 if (!test_and_clear_bit(0, &host->waiting)) 647 648 return;

+2 -1

drivers/mmc/host/meson-mx-sdio.c

reviewed

··· 467 467 468 468 static void meson_mx_mmc_timeout(struct timer_list *t) 469 469 { 470 470 - struct meson_mx_mmc_host *host = from_timer(host, t, cmd_timeout); 470 470 + struct meson_mx_mmc_host *host = timer_container_of(host, t, 471 471 + cmd_timeout); 471 472 unsigned long irqflags; 472 473 u32 irqc; 473 474

+1 -1

drivers/mmc/host/mvsdio.c

reviewed

··· 509 509 510 510 static void mvsd_timeout_timer(struct timer_list *t) 511 511 { 512 512 - struct mvsd_host *host = from_timer(host, t, timer); 512 512 + struct mvsd_host *host = timer_container_of(host, t, timer); 513 513 void __iomem *iobase = host->base; 514 514 struct mmc_request *mrq; 515 515 unsigned long flags;

+1 -1

drivers/mmc/host/mxcmmc.c

reviewed

··· 955 955 956 956 static void mxcmci_watchdog(struct timer_list *t) 957 957 { 958 958 - struct mxcmci_host *host = from_timer(host, t, watchdog); 958 958 + struct mxcmci_host *host = timer_container_of(host, t, watchdog); 959 959 struct mmc_request *req = host->req; 960 960 unsigned int stat = mxcmci_readl(host, MMC_REG_STATUS); 961 961

+4 -3

drivers/mmc/host/omap.c

reviewed

··· 639 639 static void 640 640 mmc_omap_cmd_timer(struct timer_list *t) 641 641 { 642 642 - struct mmc_omap_host *host = from_timer(host, t, cmd_abort_timer); 642 642 + struct mmc_omap_host *host = timer_container_of(host, t, 643 643 + cmd_abort_timer); 643 644 unsigned long flags; 644 645 645 646 spin_lock_irqsave(&host->slot_lock, flags); ··· 656 655 static void 657 656 mmc_omap_clk_timer(struct timer_list *t) 658 657 { 659 659 - struct mmc_omap_host *host = from_timer(host, t, clk_timer); 658 658 + struct mmc_omap_host *host = timer_container_of(host, t, clk_timer); 660 659 661 660 mmc_omap_fclk_enable(host, 0); 662 661 } ··· 880 879 881 880 static void mmc_omap_cover_timer(struct timer_list *t) 882 881 { 883 883 - struct mmc_omap_slot *slot = from_timer(slot, t, cover_timer); 882 882 + struct mmc_omap_slot *slot = timer_container_of(slot, t, cover_timer); 884 883 queue_work(system_bh_wq, &slot->cover_bh_work); 885 884 } 886 885

+2 -2

drivers/mmc/host/sdhci.c

reviewed

··· 3245 3245 struct sdhci_host *host; 3246 3246 unsigned long flags; 3247 3247 3248 3248 - host = from_timer(host, t, timer); 3248 3248 + host = timer_container_of(host, t, timer); 3249 3249 3250 3250 spin_lock_irqsave(&host->lock, flags); 3251 3251 ··· 3267 3267 struct sdhci_host *host; 3268 3268 unsigned long flags; 3269 3269 3270 3270 - host = from_timer(host, t, data_timer); 3270 3270 + host = timer_container_of(host, t, data_timer); 3271 3271 3272 3272 spin_lock_irqsave(&host->lock, flags); 3273 3273

+1 -1

drivers/mmc/host/tifm_sd.c

reviewed

··· 777 777 778 778 static void tifm_sd_abort(struct timer_list *t) 779 779 { 780 780 - struct tifm_sd *host = from_timer(host, t, timer); 780 780 + struct tifm_sd *host = timer_container_of(host, t, timer); 781 781 782 782 pr_err("%s : card failed to respond for a long period of time " 783 783 "(%x, %x)\n",

+1 -1

drivers/mmc/host/via-sdmmc.c

reviewed

··· 937 937 struct via_crdr_mmc_host *sdhost; 938 938 unsigned long flags; 939 939 940 940 - sdhost = from_timer(sdhost, t, timer); 940 940 + sdhost = timer_container_of(sdhost, t, timer); 941 941 942 942 spin_lock_irqsave(&sdhost->lock, flags); 943 943

+4 -4

drivers/mmc/host/vub300.c

reviewed

··· 740 740 741 741 static void vub300_inactivity_timer_expired(struct timer_list *t) 742 742 { /* softirq */ 743 743 - struct vub300_mmc_host *vub300 = from_timer(vub300, t, 744 744 - inactivity_timer); 743 743 + struct vub300_mmc_host *vub300 = timer_container_of(vub300, t, 744 744 + inactivity_timer); 745 745 if (!vub300->interface) { 746 746 kref_put(&vub300->kref, vub300_delete); 747 747 } else if (vub300->cmd) { ··· 1180 1180 */ 1181 1181 static void vub300_sg_timed_out(struct timer_list *t) 1182 1182 { 1183 1183 - struct vub300_mmc_host *vub300 = from_timer(vub300, t, 1184 1184 - sg_transfer_timer); 1183 1183 + struct vub300_mmc_host *vub300 = timer_container_of(vub300, t, 1184 1184 + sg_transfer_timer); 1185 1185 vub300->usb_timed_out = 1; 1186 1186 usb_sg_cancel(&vub300->sg_request); 1187 1187 usb_unlink_urb(vub300->command_out_urb);

+1 -1

drivers/mmc/host/wbsd.c

reviewed

··· 947 947 948 948 static void wbsd_reset_ignore(struct timer_list *t) 949 949 { 950 950 - struct wbsd_host *host = from_timer(host, t, ignore_timer); 950 950 + struct wbsd_host *host = timer_container_of(host, t, ignore_timer); 951 951 952 952 BUG_ON(host == NULL); 953 953

+1 -1

drivers/most/most_usb.c

reviewed

··· 667 667 */ 668 668 static void link_stat_timer_handler(struct timer_list *t) 669 669 { 670 670 - struct most_dev *mdev = from_timer(mdev, t, link_stat_timer); 670 670 + struct most_dev *mdev = timer_container_of(mdev, t, link_stat_timer); 671 671 672 672 schedule_work(&mdev->poll_work_obj); 673 673 mdev->link_stat_timer.expires = jiffies + (2 * HZ);

+1 -1

drivers/mtd/sm_ftl.c

reviewed

··· 993 993 /* flush timer, runs a second after last write */ 994 994 static void sm_cache_flush_timer(struct timer_list *t) 995 995 { 996 996 - struct sm_ftl *ftl = from_timer(ftl, t, timer); 996 996 + struct sm_ftl *ftl = timer_container_of(ftl, t, timer); 997 997 queue_work(cache_flush_workqueue, &ftl->flush_work); 998 998 } 999 999

+1 -1

drivers/net/arcnet/arcnet.c

reviewed

··· 382 382 383 383 static void arcnet_timer(struct timer_list *t) 384 384 { 385 385 - struct arcnet_local *lp = from_timer(lp, t, timer); 385 385 + struct arcnet_local *lp = timer_container_of(lp, t, timer); 386 386 struct net_device *dev = lp->dev; 387 387 388 388 spin_lock_irq(&lp->lock);

+2 -2

drivers/net/can/grcan.c

reviewed

··· 806 806 */ 807 807 static void grcan_running_reset(struct timer_list *t) 808 808 { 809 809 - struct grcan_priv *priv = from_timer(priv, t, rr_timer); 809 809 + struct grcan_priv *priv = timer_container_of(priv, t, rr_timer); 810 810 struct net_device *dev = priv->dev; 811 811 struct grcan_registers __iomem *regs = priv->regs; 812 812 unsigned long flags; ··· 897 897 /* Disable channels and schedule a running reset */ 898 898 static void grcan_initiate_running_reset(struct timer_list *t) 899 899 { 900 900 - struct grcan_priv *priv = from_timer(priv, t, hang_timer); 900 900 + struct grcan_priv *priv = timer_container_of(priv, t, hang_timer); 901 901 struct net_device *dev = priv->dev; 902 902 struct grcan_registers __iomem *regs = priv->regs; 903 903 unsigned long flags;

+2 -1

drivers/net/can/kvaser_pciefd.c

reviewed

··· 937 937 938 938 static void kvaser_pciefd_bec_poll_timer(struct timer_list *data) 939 939 { 940 940 - struct kvaser_pciefd_can *can = from_timer(can, data, bec_poll_timer); 940 940 + struct kvaser_pciefd_can *can = timer_container_of(can, data, 941 941 + bec_poll_timer); 941 942 942 943 kvaser_pciefd_enable_err_gen(can); 943 944 kvaser_pciefd_request_status(can);

+1 -1

drivers/net/can/sja1000/peak_pcmcia.c

reviewed

··· 374 374 */ 375 375 static void pcan_led_timer(struct timer_list *t) 376 376 { 377 377 - struct pcan_pccard *card = from_timer(card, t, led_timer); 377 377 + struct pcan_pccard *card = timer_container_of(card, t, led_timer); 378 378 struct net_device *netdev; 379 379 int i, up_count = 0; 380 380 u8 ccr;

+1 -1

drivers/net/can/usb/peak_usb/pcan_usb.c

reviewed

··· 319 319 */ 320 320 static void pcan_usb_restart(struct timer_list *t) 321 321 { 322 322 - struct pcan_usb *pdev = from_timer(pdev, t, restart_timer); 322 322 + struct pcan_usb *pdev = timer_container_of(pdev, t, restart_timer); 323 323 struct peak_usb_device *dev = &pdev->dev; 324 324 325 325 /* notify candev and netdev */

+1 -1

drivers/net/dsa/mv88e6xxx/phy.c

reviewed

··· 182 182 183 183 static void mv88e6xxx_phy_ppu_reenable_timer(struct timer_list *t) 184 184 { 185 185 - struct mv88e6xxx_chip *chip = from_timer(chip, t, ppu_timer); 185 185 + struct mv88e6xxx_chip *chip = timer_container_of(chip, t, ppu_timer); 186 186 187 187 schedule_work(&chip->ppu_work); 188 188 }

+1 -1

drivers/net/eql.c

reviewed

··· 143 143 144 144 static void eql_timer(struct timer_list *t) 145 145 { 146 146 - equalizer_t *eql = from_timer(eql, t, timer); 146 146 + equalizer_t *eql = timer_container_of(eql, t, timer); 147 147 struct list_head *this, *tmp, *head; 148 148 149 149 spin_lock(&eql->queue.lock);

+1 -1

drivers/net/ethernet/3com/3c515.c

reviewed

··· 859 859 static void corkscrew_timer(struct timer_list *t) 860 860 { 861 861 #ifdef AUTOMEDIA 862 862 - struct corkscrew_private *vp = from_timer(vp, t, timer); 862 862 + struct corkscrew_private *vp = timer_container_of(vp, t, timer); 863 863 struct net_device *dev = vp->our_dev; 864 864 int ioaddr = dev->base_addr; 865 865 unsigned long flags;

+1 -1

drivers/net/ethernet/3com/3c574_cs.c

reviewed

··· 858 858 */ 859 859 static void media_check(struct timer_list *t) 860 860 { 861 861 - struct el3_private *lp = from_timer(lp, t, media); 861 861 + struct el3_private *lp = timer_container_of(lp, t, media); 862 862 struct net_device *dev = lp->p_dev->priv; 863 863 unsigned int ioaddr = dev->base_addr; 864 864 unsigned long flags;

+1 -1

drivers/net/ethernet/3com/3c589_cs.c

reviewed

··· 685 685 686 686 static void media_check(struct timer_list *t) 687 687 { 688 688 - struct el3_private *lp = from_timer(lp, t, media); 688 688 + struct el3_private *lp = timer_container_of(lp, t, media); 689 689 struct net_device *dev = lp->p_dev->priv; 690 690 unsigned int ioaddr = dev->base_addr; 691 691 u16 media, errs;

+1 -1

drivers/net/ethernet/3com/3c59x.c

reviewed

··· 1783 1783 static void 1784 1784 vortex_timer(struct timer_list *t) 1785 1785 { 1786 1786 - struct vortex_private *vp = from_timer(vp, t, timer); 1786 1786 + struct vortex_private *vp = timer_container_of(vp, t, timer); 1787 1787 struct net_device *dev = vp->mii.dev; 1788 1788 void __iomem *ioaddr = vp->ioaddr; 1789 1789 int next_tick = 60*HZ;

+1 -1

drivers/net/ethernet/8390/axnet_cs.c

reviewed

··· 550 550 551 551 static void ei_watchdog(struct timer_list *t) 552 552 { 553 553 - struct axnet_dev *info = from_timer(info, t, watchdog); 553 553 + struct axnet_dev *info = timer_container_of(info, t, watchdog); 554 554 struct net_device *dev = info->p_dev->priv; 555 555 unsigned int nic_base = dev->base_addr; 556 556 unsigned int mii_addr = nic_base + AXNET_MII_EEP;

+1 -1

drivers/net/ethernet/8390/pcnet_cs.c

reviewed

··· 1018 1018 1019 1019 static void ei_watchdog(struct timer_list *t) 1020 1020 { 1021 1021 - struct pcnet_dev *info = from_timer(info, t, watchdog); 1021 1021 + struct pcnet_dev *info = timer_container_of(info, t, watchdog); 1022 1022 struct net_device *dev = info->p_dev->priv; 1023 1023 unsigned int nic_base = dev->base_addr; 1024 1024 unsigned int mii_addr = nic_base + DLINK_GPIO;

+2 -1

drivers/net/ethernet/agere/et131x.c

reviewed

··· 3076 3076 */ 3077 3077 static void et131x_error_timer_handler(struct timer_list *t) 3078 3078 { 3079 3079 - struct et131x_adapter *adapter = from_timer(adapter, t, error_timer); 3079 3079 + struct et131x_adapter *adapter = timer_container_of(adapter, t, 3080 3080 + error_timer); 3080 3081 struct phy_device *phydev = adapter->netdev->phydev; 3081 3082 3082 3083 if (et1310_in_phy_coma(adapter)) {

+2 -1

drivers/net/ethernet/amazon/ena/ena_netdev.c

reviewed

··· 3667 3667 3668 3668 static void ena_timer_service(struct timer_list *t) 3669 3669 { 3670 3670 - struct ena_adapter *adapter = from_timer(adapter, t, timer_service); 3670 3670 + struct ena_adapter *adapter = timer_container_of(adapter, t, 3671 3671 + timer_service); 3671 3672 u8 *debug_area = adapter->ena_dev->host_attr.debug_area_virt_addr; 3672 3673 struct ena_admin_host_info *host_info = 3673 3674 adapter->ena_dev->host_attr.host_info;

+1 -1

drivers/net/ethernet/amd/a2065.c

reviewed

··· 636 636 637 637 static void lance_set_multicast_retry(struct timer_list *t) 638 638 { 639 639 - struct lance_private *lp = from_timer(lp, t, multicast_timer); 639 639 + struct lance_private *lp = timer_container_of(lp, t, multicast_timer); 640 640 641 641 lance_set_multicast(lp->dev); 642 642 }

+2 -1

drivers/net/ethernet/amd/amd8111e.c

reviewed

··· 1641 1641 1642 1642 static void amd8111e_config_ipg(struct timer_list *t) 1643 1643 { 1644 1644 - struct amd8111e_priv *lp = from_timer(lp, t, ipg_data.ipg_timer); 1644 1644 + struct amd8111e_priv *lp = timer_container_of(lp, t, 1645 1645 + ipg_data.ipg_timer); 1645 1646 struct ipg_info *ipg_data = &lp->ipg_data; 1646 1647 void __iomem *mmio = lp->mmio; 1647 1648 unsigned int prev_col_cnt = ipg_data->col_cnt;

+1 -1

drivers/net/ethernet/amd/declance.c

reviewed

··· 1004 1004 1005 1005 static void lance_set_multicast_retry(struct timer_list *t) 1006 1006 { 1007 1007 - struct lance_private *lp = from_timer(lp, t, multicast_timer); 1007 1007 + struct lance_private *lp = timer_container_of(lp, t, multicast_timer); 1008 1008 struct net_device *dev = lp->dev; 1009 1009 1010 1010 lance_set_multicast(dev);

+1 -1

drivers/net/ethernet/amd/pcnet32.c

reviewed

··· 2905 2905 2906 2906 static void pcnet32_watchdog(struct timer_list *t) 2907 2907 { 2908 2908 - struct pcnet32_private *lp = from_timer(lp, t, watchdog_timer); 2908 2908 + struct pcnet32_private *lp = timer_container_of(lp, t, watchdog_timer); 2909 2909 struct net_device *dev = lp->dev; 2910 2910 unsigned long flags; 2911 2911

+1 -1

drivers/net/ethernet/amd/pds_core/main.c

reviewed

··· 23 23 24 24 static void pdsc_wdtimer_cb(struct timer_list *t) 25 25 { 26 26 - struct pdsc *pdsc = from_timer(pdsc, t, wdtimer); 26 26 + struct pdsc *pdsc = timer_container_of(pdsc, t, wdtimer); 27 27 28 28 dev_dbg(pdsc->dev, "%s: jiffies %ld\n", __func__, jiffies); 29 29 mod_timer(&pdsc->wdtimer,

+1 -1

drivers/net/ethernet/amd/sunlance.c

reviewed

··· 1246 1246 1247 1247 static void lance_set_multicast_retry(struct timer_list *t) 1248 1248 { 1249 1249 - struct lance_private *lp = from_timer(lp, t, multicast_timer); 1249 1249 + struct lance_private *lp = timer_container_of(lp, t, multicast_timer); 1250 1250 struct net_device *dev = lp->dev; 1251 1251 1252 1252 lance_set_multicast(dev);

+4 -2

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

reviewed

··· 534 534 535 535 static void xgbe_tx_timer(struct timer_list *t) 536 536 { 537 537 - struct xgbe_channel *channel = from_timer(channel, t, tx_timer); 537 537 + struct xgbe_channel *channel = timer_container_of(channel, t, 538 538 + tx_timer); 538 539 struct xgbe_prv_data *pdata = channel->pdata; 539 540 struct napi_struct *napi; 540 541 ··· 573 572 574 573 static void xgbe_service_timer(struct timer_list *t) 575 574 { 576 576 - struct xgbe_prv_data *pdata = from_timer(pdata, t, service_timer); 575 575 + struct xgbe_prv_data *pdata = timer_container_of(pdata, t, 576 576 + service_timer); 577 577 struct xgbe_channel *channel; 578 578 unsigned int i; 579 579

+1 -1

drivers/net/ethernet/apple/bmac.c

reviewed

··· 1410 1410 1411 1411 static void bmac_tx_timeout(struct timer_list *t) 1412 1412 { 1413 1413 - struct bmac_data *bp = from_timer(bp, t, tx_timeout); 1413 1413 + struct bmac_data *bp = timer_container_of(bp, t, tx_timeout); 1414 1414 struct net_device *dev = macio_get_drvdata(bp->mdev); 1415 1415 volatile struct dbdma_regs __iomem *td = bp->tx_dma; 1416 1416 volatile struct dbdma_regs __iomem *rd = bp->rx_dma;

+1 -1

drivers/net/ethernet/apple/mace.c

reviewed

··· 805 805 806 806 static void mace_tx_timeout(struct timer_list *t) 807 807 { 808 808 - struct mace_data *mp = from_timer(mp, t, tx_timeout); 808 808 + struct mace_data *mp = timer_container_of(mp, t, tx_timeout); 809 809 struct net_device *dev = macio_get_drvdata(mp->mdev); 810 810 volatile struct mace __iomem *mb = mp->mace; 811 811 volatile struct dbdma_regs __iomem *td = mp->tx_dma;

+2 -2

drivers/net/ethernet/aquantia/atlantic/aq_nic.c

reviewed

··· 254 254 255 255 static void aq_nic_service_timer_cb(struct timer_list *t) 256 256 { 257 257 - struct aq_nic_s *self = from_timer(self, t, service_timer); 257 257 + struct aq_nic_s *self = timer_container_of(self, t, service_timer); 258 258 259 259 mod_timer(&self->service_timer, 260 260 jiffies + AQ_CFG_SERVICE_TIMER_INTERVAL); ··· 264 264 265 265 static void aq_nic_polling_timer_cb(struct timer_list *t) 266 266 { 267 267 - struct aq_nic_s *self = from_timer(self, t, polling_timer); 267 267 + struct aq_nic_s *self = timer_container_of(self, t, polling_timer); 268 268 unsigned int i = 0U; 269 269 270 270 for (i = 0U; self->aq_vecs > i; ++i)

+1 -1

drivers/net/ethernet/atheros/ag71xx.c

reviewed

··· 1563 1563 1564 1564 static void ag71xx_oom_timer_handler(struct timer_list *t) 1565 1565 { 1566 1566 - struct ag71xx *ag = from_timer(ag, t, oom_timer); 1566 1566 + struct ag71xx *ag = timer_container_of(ag, t, oom_timer); 1567 1567 1568 1568 napi_schedule(&ag->napi); 1569 1569 }

+2 -2

drivers/net/ethernet/atheros/atl1c/atl1c_main.c

reviewed

··· 231 231 */ 232 232 static void atl1c_phy_config(struct timer_list *t) 233 233 { 234 234 - struct atl1c_adapter *adapter = from_timer(adapter, t, 235 235 - phy_config_timer); 234 234 + struct atl1c_adapter *adapter = timer_container_of(adapter, t, 235 235 + phy_config_timer); 236 236 struct atl1c_hw *hw = &adapter->hw; 237 237 unsigned long flags; 238 238

+2 -2

drivers/net/ethernet/atheros/atl1e/atl1e_main.c

reviewed

··· 115 115 */ 116 116 static void atl1e_phy_config(struct timer_list *t) 117 117 { 118 118 - struct atl1e_adapter *adapter = from_timer(adapter, t, 119 119 - phy_config_timer); 118 118 + struct atl1e_adapter *adapter = timer_container_of(adapter, t, 119 119 + phy_config_timer); 120 120 struct atl1e_hw *hw = &adapter->hw; 121 121 unsigned long flags; 122 122

+2 -2

drivers/net/ethernet/atheros/atlx/atl1.c

reviewed

··· 2556 2556 */ 2557 2557 static void atl1_phy_config(struct timer_list *t) 2558 2558 { 2559 2559 - struct atl1_adapter *adapter = from_timer(adapter, t, 2560 2560 - phy_config_timer); 2559 2559 + struct atl1_adapter *adapter = timer_container_of(adapter, t, 2560 2560 + phy_config_timer); 2561 2561 struct atl1_hw *hw = &adapter->hw; 2562 2562 unsigned long flags; 2563 2563

+4 -3

drivers/net/ethernet/atheros/atlx/atl2.c

reviewed

··· 1010 1010 */ 1011 1011 static void atl2_watchdog(struct timer_list *t) 1012 1012 { 1013 1013 - struct atl2_adapter *adapter = from_timer(adapter, t, watchdog_timer); 1013 1013 + struct atl2_adapter *adapter = timer_container_of(adapter, t, 1014 1014 + watchdog_timer); 1014 1015 1015 1016 if (!test_bit(__ATL2_DOWN, &adapter->flags)) { 1016 1017 u32 drop_rxd, drop_rxs; ··· 1036 1035 */ 1037 1036 static void atl2_phy_config(struct timer_list *t) 1038 1037 { 1039 1039 - struct atl2_adapter *adapter = from_timer(adapter, t, 1040 1040 - phy_config_timer); 1038 1038 + struct atl2_adapter *adapter = timer_container_of(adapter, t, 1039 1039 + phy_config_timer); 1041 1040 struct atl2_hw *hw = &adapter->hw; 1042 1041 unsigned long flags; 1043 1042

+1 -1

drivers/net/ethernet/broadcom/b44.c

reviewed

··· 575 575 576 576 static void b44_timer(struct timer_list *t) 577 577 { 578 578 - struct b44 *bp = from_timer(bp, t, timer); 578 578 + struct b44 *bp = timer_container_of(bp, t, timer); 579 579 580 580 spin_lock_irq(&bp->lock); 581 581

+2 -2

drivers/net/ethernet/broadcom/bcm63xx_enet.c

reviewed

··· 286 286 */ 287 287 static void bcm_enet_refill_rx_timer(struct timer_list *t) 288 288 { 289 289 - struct bcm_enet_priv *priv = from_timer(priv, t, rx_timeout); 289 289 + struct bcm_enet_priv *priv = timer_container_of(priv, t, rx_timeout); 290 290 struct net_device *dev = priv->net_dev; 291 291 292 292 spin_lock(&priv->rx_lock); ··· 2001 2001 */ 2002 2002 static void swphy_poll_timer(struct timer_list *t) 2003 2003 { 2004 2004 - struct bcm_enet_priv *priv = from_timer(priv, t, swphy_poll); 2004 2004 + struct bcm_enet_priv *priv = timer_container_of(priv, t, swphy_poll); 2005 2005 unsigned int i; 2006 2006 2007 2007 for (i = 0; i < priv->num_ports; i++) {

+1 -1

drivers/net/ethernet/broadcom/bnx2.c

reviewed

··· 6163 6163 static void 6164 6164 bnx2_timer(struct timer_list *t) 6165 6165 { 6166 6166 - struct bnx2 *bp = from_timer(bp, t, timer); 6166 6166 + struct bnx2 *bp = timer_container_of(bp, t, timer); 6167 6167 6168 6168 if (!netif_running(bp->dev)) 6169 6169 return;

+1 -1

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

reviewed

··· 5783 5783 5784 5784 static void bnx2x_timer(struct timer_list *t) 5785 5785 { 5786 5786 - struct bnx2x *bp = from_timer(bp, t, timer); 5786 5786 + struct bnx2x *bp = timer_container_of(bp, t, timer); 5787 5787 5788 5788 if (!netif_running(bp->dev)) 5789 5789 return;

+1 -1

drivers/net/ethernet/broadcom/bnxt/bnxt.c

reviewed

··· 13995 13995 13996 13996 static void bnxt_timer(struct timer_list *t) 13997 13997 { 13998 13998 - struct bnxt *bp = from_timer(bp, t, timer); 13998 13998 + struct bnxt *bp = timer_container_of(bp, t, timer); 13999 13999 struct net_device *dev = bp->dev; 14000 14000 14001 14001 if (!netif_running(dev) || !test_bit(BNXT_STATE_OPEN, &bp->state))

+1 -1

drivers/net/ethernet/broadcom/tg3.c

reviewed

··· 11062 11062 11063 11063 static void tg3_timer(struct timer_list *t) 11064 11064 { 11065 11065 - struct tg3 *tp = from_timer(tp, t, timer); 11065 11065 + struct tg3 *tp = timer_container_of(tp, t, timer); 11066 11066 11067 11067 spin_lock(&tp->lock); 11068 11068

+10 -6

drivers/net/ethernet/brocade/bna/bnad.c

reviewed

··· 1688 1688 static void 1689 1689 bnad_ioc_timeout(struct timer_list *t) 1690 1690 { 1691 1691 - struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.ioc_timer); 1691 1691 + struct bnad *bnad = timer_container_of(bnad, t, 1692 1692 + bna.ioceth.ioc.ioc_timer); 1692 1693 unsigned long flags; 1693 1694 1694 1695 spin_lock_irqsave(&bnad->bna_lock, flags); ··· 1700 1699 static void 1701 1700 bnad_ioc_hb_check(struct timer_list *t) 1702 1701 { 1703 1703 - struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.hb_timer); 1702 1702 + struct bnad *bnad = timer_container_of(bnad, t, 1703 1703 + bna.ioceth.ioc.hb_timer); 1704 1704 unsigned long flags; 1705 1705 1706 1706 spin_lock_irqsave(&bnad->bna_lock, flags); ··· 1712 1710 static void 1713 1711 bnad_iocpf_timeout(struct timer_list *t) 1714 1712 { 1715 1715 - struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.iocpf_timer); 1713 1713 + struct bnad *bnad = timer_container_of(bnad, t, 1714 1714 + bna.ioceth.ioc.iocpf_timer); 1716 1715 unsigned long flags; 1717 1716 1718 1717 spin_lock_irqsave(&bnad->bna_lock, flags); ··· 1724 1721 static void 1725 1722 bnad_iocpf_sem_timeout(struct timer_list *t) 1726 1723 { 1727 1727 - struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.sem_timer); 1724 1724 + struct bnad *bnad = timer_container_of(bnad, t, 1725 1725 + bna.ioceth.ioc.sem_timer); 1728 1726 unsigned long flags; 1729 1727 1730 1728 spin_lock_irqsave(&bnad->bna_lock, flags); ··· 1747 1743 static void 1748 1744 bnad_dim_timeout(struct timer_list *t) 1749 1745 { 1750 1750 - struct bnad *bnad = from_timer(bnad, t, dim_timer); 1746 1746 + struct bnad *bnad = timer_container_of(bnad, t, dim_timer); 1751 1747 struct bnad_rx_info *rx_info; 1752 1748 struct bnad_rx_ctrl *rx_ctrl; 1753 1749 int i, j; ··· 1780 1776 static void 1781 1777 bnad_stats_timeout(struct timer_list *t) 1782 1778 { 1783 1783 - struct bnad *bnad = from_timer(bnad, t, stats_timer); 1779 1779 + struct bnad *bnad = timer_container_of(bnad, t, stats_timer); 1784 1780 unsigned long flags; 1785 1781 1786 1782 if (!netif_running(bnad->netdev) ||

+3 -3

drivers/net/ethernet/chelsio/cxgb/sge.c

reviewed

··· 1922 1922 static void sge_tx_reclaim_cb(struct timer_list *t) 1923 1923 { 1924 1924 int i; 1925 1925 - struct sge *sge = from_timer(sge, t, tx_reclaim_timer); 1925 1925 + struct sge *sge = timer_container_of(sge, t, tx_reclaim_timer); 1926 1926 1927 1927 for (i = 0; i < SGE_CMDQ_N; ++i) { 1928 1928 struct cmdQ *q = &sge->cmdQ[i]; ··· 2017 2017 */ 2018 2018 static void espibug_workaround_t204(struct timer_list *t) 2019 2019 { 2020 2020 - struct sge *sge = from_timer(sge, t, espibug_timer); 2020 2020 + struct sge *sge = timer_container_of(sge, t, espibug_timer); 2021 2021 struct adapter *adapter = sge->adapter; 2022 2022 unsigned int nports = adapter->params.nports; 2023 2023 u32 seop[MAX_NPORTS]; ··· 2060 2060 2061 2061 static void espibug_workaround(struct timer_list *t) 2062 2062 { 2063 2063 - struct sge *sge = from_timer(sge, t, espibug_timer); 2063 2063 + struct sge *sge = timer_container_of(sge, t, espibug_timer); 2064 2064 struct adapter *adapter = sge->adapter; 2065 2065 2066 2066 if (netif_running(adapter->port[0].dev)) {

+2 -2

drivers/net/ethernet/chelsio/cxgb3/sge.c

reviewed

··· 2906 2906 */ 2907 2907 static void sge_timer_tx(struct timer_list *t) 2908 2908 { 2909 2909 - struct sge_qset *qs = from_timer(qs, t, tx_reclaim_timer); 2909 2909 + struct sge_qset *qs = timer_container_of(qs, t, tx_reclaim_timer); 2910 2910 struct port_info *pi = netdev_priv(qs->netdev); 2911 2911 struct adapter *adap = pi->adapter; 2912 2912 unsigned int tbd[SGE_TXQ_PER_SET] = {0, 0}; ··· 2947 2947 static void sge_timer_rx(struct timer_list *t) 2948 2948 { 2949 2949 spinlock_t *lock; 2950 2950 - struct sge_qset *qs = from_timer(qs, t, rx_reclaim_timer); 2950 2950 + struct sge_qset *qs = timer_container_of(qs, t, rx_reclaim_timer); 2951 2951 struct port_info *pi = netdev_priv(qs->netdev); 2952 2952 struct adapter *adap = pi->adapter; 2953 2953 u32 status;

+1 -1

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

reviewed

··· 1051 1051 1052 1052 static void ch_flower_stats_cb(struct timer_list *t) 1053 1053 { 1054 1054 - struct adapter *adap = from_timer(adap, t, flower_stats_timer); 1054 1054 + struct adapter *adap = timer_container_of(adap, t, flower_stats_timer); 1055 1055 1056 1056 schedule_work(&adap->flower_stats_work); 1057 1057 }

+2 -2

drivers/net/ethernet/chelsio/cxgb4/sge.c

reviewed

··· 4234 4234 { 4235 4235 unsigned long m; 4236 4236 unsigned int i; 4237 4237 - struct adapter *adap = from_timer(adap, t, sge.rx_timer); 4237 4237 + struct adapter *adap = timer_container_of(adap, t, sge.rx_timer); 4238 4238 struct sge *s = &adap->sge; 4239 4239 4240 4240 for (i = 0; i < BITS_TO_LONGS(s->egr_sz); i++) ··· 4269 4269 4270 4270 static void sge_tx_timer_cb(struct timer_list *t) 4271 4271 { 4272 4272 - struct adapter *adap = from_timer(adap, t, sge.tx_timer); 4272 4272 + struct adapter *adap = timer_container_of(adap, t, sge.tx_timer); 4273 4273 struct sge *s = &adap->sge; 4274 4274 unsigned long m, period; 4275 4275 unsigned int i, budget;

+2 -2

drivers/net/ethernet/chelsio/cxgb4vf/sge.c

reviewed

··· 2062 2062 */ 2063 2063 static void sge_rx_timer_cb(struct timer_list *t) 2064 2064 { 2065 2065 - struct adapter *adapter = from_timer(adapter, t, sge.rx_timer); 2065 2065 + struct adapter *adapter = timer_container_of(adapter, t, sge.rx_timer); 2066 2066 struct sge *s = &adapter->sge; 2067 2067 unsigned int i; 2068 2068 ··· 2121 2121 */ 2122 2122 static void sge_tx_timer_cb(struct timer_list *t) 2123 2123 { 2124 2124 - struct adapter *adapter = from_timer(adapter, t, sge.tx_timer); 2124 2124 + struct adapter *adapter = timer_container_of(adapter, t, sge.tx_timer); 2125 2125 struct sge *s = &adapter->sge; 2126 2126 unsigned int i, budget; 2127 2127

+1 -1

drivers/net/ethernet/cisco/enic/enic_clsf.c

reviewed

··· 125 125 #ifdef CONFIG_RFS_ACCEL 126 126 void enic_flow_may_expire(struct timer_list *t) 127 127 { 128 128 - struct enic *enic = from_timer(enic, t, rfs_h.rfs_may_expire); 128 128 + struct enic *enic = timer_container_of(enic, t, rfs_h.rfs_may_expire); 129 129 bool res; 130 130 int j; 131 131

+1 -1

drivers/net/ethernet/cisco/enic/enic_main.c

reviewed

··· 1510 1510 1511 1511 static void enic_notify_timer(struct timer_list *t) 1512 1512 { 1513 1513 - struct enic *enic = from_timer(enic, t, notify_timer); 1513 1513 + struct enic *enic = timer_container_of(enic, t, notify_timer); 1514 1514 1515 1515 enic_notify_check(enic); 1516 1516

+2 -2

drivers/net/ethernet/dec/tulip/de2104x.c

reviewed

··· 963 963 964 964 static void de21040_media_timer (struct timer_list *t) 965 965 { 966 966 - struct de_private *de = from_timer(de, t, media_timer); 966 966 + struct de_private *de = timer_container_of(de, t, media_timer); 967 967 struct net_device *dev = de->dev; 968 968 u32 status = dr32(SIAStatus); 969 969 unsigned int carrier; ··· 1044 1044 1045 1045 static void de21041_media_timer (struct timer_list *t) 1046 1046 { 1047 1047 - struct de_private *de = from_timer(de, t, media_timer); 1047 1047 + struct de_private *de = timer_container_of(de, t, media_timer); 1048 1048 struct net_device *dev = de->dev; 1049 1049 u32 status = dr32(SIAStatus); 1050 1050 unsigned int carrier;

+1 -1

drivers/net/ethernet/dec/tulip/dmfe.c

reviewed

··· 1115 1115 1116 1116 static void dmfe_timer(struct timer_list *t) 1117 1117 { 1118 1118 - struct dmfe_board_info *db = from_timer(db, t, timer); 1118 1118 + struct dmfe_board_info *db = timer_container_of(db, t, timer); 1119 1119 struct net_device *dev = pci_get_drvdata(db->pdev); 1120 1120 void __iomem *ioaddr = db->ioaddr; 1121 1121 u32 tmp_cr8;

+1 -1

drivers/net/ethernet/dec/tulip/interrupt.c

reviewed

··· 104 104 105 105 void oom_timer(struct timer_list *t) 106 106 { 107 107 - struct tulip_private *tp = from_timer(tp, t, oom_timer); 107 107 + struct tulip_private *tp = timer_container_of(tp, t, oom_timer); 108 108 109 109 napi_schedule(&tp->napi); 110 110 }

+1 -1

drivers/net/ethernet/dec/tulip/pnic.c

reviewed

··· 86 86 87 87 void pnic_timer(struct timer_list *t) 88 88 { 89 89 - struct tulip_private *tp = from_timer(tp, t, timer); 89 89 + struct tulip_private *tp = timer_container_of(tp, t, timer); 90 90 struct net_device *dev = tp->dev; 91 91 void __iomem *ioaddr = tp->base_addr; 92 92 int next_tick = 60*HZ;

+1 -1

drivers/net/ethernet/dec/tulip/pnic2.c

reviewed

··· 78 78 79 79 void pnic2_timer(struct timer_list *t) 80 80 { 81 81 - struct tulip_private *tp = from_timer(tp, t, timer); 81 81 + struct tulip_private *tp = timer_container_of(tp, t, timer); 82 82 struct net_device *dev = tp->dev; 83 83 void __iomem *ioaddr = tp->base_addr; 84 84 int next_tick = 60*HZ;

+2 -2

drivers/net/ethernet/dec/tulip/timer.c

reviewed

··· 139 139 140 140 void mxic_timer(struct timer_list *t) 141 141 { 142 142 - struct tulip_private *tp = from_timer(tp, t, timer); 142 142 + struct tulip_private *tp = timer_container_of(tp, t, timer); 143 143 struct net_device *dev = tp->dev; 144 144 void __iomem *ioaddr = tp->base_addr; 145 145 int next_tick = 60*HZ; ··· 156 156 157 157 void comet_timer(struct timer_list *t) 158 158 { 159 159 - struct tulip_private *tp = from_timer(tp, t, timer); 159 159 + struct tulip_private *tp = timer_container_of(tp, t, timer); 160 160 struct net_device *dev = tp->dev; 161 161 int next_tick = 2*HZ; 162 162

+1 -1

drivers/net/ethernet/dec/tulip/tulip_core.c

reviewed

··· 114 114 115 115 static void tulip_timer(struct timer_list *t) 116 116 { 117 117 - struct tulip_private *tp = from_timer(tp, t, timer); 117 117 + struct tulip_private *tp = timer_container_of(tp, t, timer); 118 118 struct net_device *dev = tp->dev; 119 119 120 120 if (netif_running(dev))

+1 -1

drivers/net/ethernet/dec/tulip/uli526x.c

reviewed

··· 1014 1014 1015 1015 static void uli526x_timer(struct timer_list *t) 1016 1016 { 1017 1017 - struct uli526x_board_info *db = from_timer(db, t, timer); 1017 1017 + struct uli526x_board_info *db = timer_container_of(db, t, timer); 1018 1018 struct net_device *dev = pci_get_drvdata(db->pdev); 1019 1019 struct uli_phy_ops *phy = &db->phy; 1020 1020 void __iomem *ioaddr = db->ioaddr;

+1 -1

drivers/net/ethernet/dec/tulip/winbond-840.c

reviewed

··· 763 763 764 764 static void netdev_timer(struct timer_list *t) 765 765 { 766 766 - struct netdev_private *np = from_timer(np, t, timer); 766 766 + struct netdev_private *np = timer_container_of(np, t, timer); 767 767 struct net_device *dev = pci_get_drvdata(np->pci_dev); 768 768 void __iomem *ioaddr = np->base_addr; 769 769

+1 -1

drivers/net/ethernet/dlink/dl2k.c

reviewed

··· 650 650 static void 651 651 rio_timer (struct timer_list *t) 652 652 { 653 653 - struct netdev_private *np = from_timer(np, t, timer); 653 653 + struct netdev_private *np = timer_container_of(np, t, timer); 654 654 struct net_device *dev = pci_get_drvdata(np->pdev); 655 655 unsigned int entry; 656 656 int next_tick = 1*HZ;

+2 -2

drivers/net/ethernet/fealnx.c

reviewed

··· 1074 1074 1075 1075 static void netdev_timer(struct timer_list *t) 1076 1076 { 1077 1077 - struct netdev_private *np = from_timer(np, t, timer); 1077 1077 + struct netdev_private *np = timer_container_of(np, t, timer); 1078 1078 struct net_device *dev = np->mii.dev; 1079 1079 void __iomem *ioaddr = np->mem; 1080 1080 int old_crvalue = np->crvalue; ··· 1163 1163 1164 1164 static void reset_timer(struct timer_list *t) 1165 1165 { 1166 1166 - struct netdev_private *np = from_timer(np, t, reset_timer); 1166 1166 + struct netdev_private *np = timer_container_of(np, t, reset_timer); 1167 1167 struct net_device *dev = np->mii.dev; 1168 1168 unsigned long flags; 1169 1169

+2 -1

drivers/net/ethernet/google/gve/gve_main.c

reviewed

··· 268 268 269 269 static void gve_stats_report_timer(struct timer_list *t) 270 270 { 271 271 - struct gve_priv *priv = from_timer(priv, t, stats_report_timer); 271 271 + struct gve_priv *priv = timer_container_of(priv, t, 272 272 + stats_report_timer); 272 273 273 274 mod_timer(&priv->stats_report_timer, 274 275 round_jiffies(jiffies +

+1 -1

drivers/net/ethernet/hisilicon/hns/hns_enet.c

reviewed

··· 2075 2075 2076 2076 static void hns_nic_service_timer(struct timer_list *t) 2077 2077 { 2078 2078 - struct hns_nic_priv *priv = from_timer(priv, t, service_timer); 2078 2078 + struct hns_nic_priv *priv = timer_container_of(priv, t, service_timer); 2079 2079 2080 2080 (void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ); 2081 2081

+1 -1

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

reviewed

··· 4503 4503 4504 4504 static void hclge_reset_timer(struct timer_list *t) 4505 4505 { 4506 4506 - struct hclge_dev *hdev = from_timer(hdev, t, reset_timer); 4506 4506 + struct hclge_dev *hdev = timer_container_of(hdev, t, reset_timer); 4507 4507 4508 4508 /* if default_reset_request has no value, it means that this reset 4509 4509 * request has already be handled, so just return here

+1 -1

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

reviewed

··· 2057 2057 2058 2058 static void hclgevf_reset_timer(struct timer_list *t) 2059 2059 { 2060 2060 - struct hclgevf_dev *hdev = from_timer(hdev, t, reset_timer); 2060 2060 + struct hclgevf_dev *hdev = timer_container_of(hdev, t, reset_timer); 2061 2061 2062 2062 hclgevf_clear_event_cause(hdev, HCLGEVF_VECTOR0_EVENT_RST); 2063 2063 hclgevf_reset_task_schedule(hdev);

+1 -1

drivers/net/ethernet/intel/e100.c

reviewed

··· 1682 1682 1683 1683 static void e100_watchdog(struct timer_list *t) 1684 1684 { 1685 1685 - struct nic *nic = from_timer(nic, t, watchdog); 1685 1685 + struct nic *nic = timer_container_of(nic, t, watchdog); 1686 1686 struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET }; 1687 1687 u32 speed; 1688 1688

+4 -2

drivers/net/ethernet/intel/e1000e/netdev.c

reviewed

··· 4853 4853 **/ 4854 4854 static void e1000_update_phy_info(struct timer_list *t) 4855 4855 { 4856 4856 - struct e1000_adapter *adapter = from_timer(adapter, t, phy_info_timer); 4856 4856 + struct e1000_adapter *adapter = timer_container_of(adapter, t, 4857 4857 + phy_info_timer); 4857 4858 4858 4859 if (test_bit(__E1000_DOWN, &adapter->state)) 4859 4860 return; ··· 5190 5189 **/ 5191 5190 static void e1000_watchdog(struct timer_list *t) 5192 5191 { 5193 5193 - struct e1000_adapter *adapter = from_timer(adapter, t, watchdog_timer); 5192 5192 + struct e1000_adapter *adapter = timer_container_of(adapter, t, 5193 5193 + watchdog_timer); 5194 5194 5195 5195 /* Do the rest outside of interrupt context */ 5196 5196 schedule_work(&adapter->watchdog_task);

+2 -2

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

reviewed

··· 199 199 **/ 200 200 static void fm10k_service_timer(struct timer_list *t) 201 201 { 202 202 - struct fm10k_intfc *interface = from_timer(interface, t, 203 203 - service_timer); 202 202 + struct fm10k_intfc *interface = timer_container_of(interface, t, 203 203 + service_timer); 204 204 205 205 /* Reset the timer */ 206 206 mod_timer(&interface->service_timer, (HZ * 2) + jiffies);

+1 -1

drivers/net/ethernet/intel/i40e/i40e_main.c

reviewed

··· 11412 11412 **/ 11413 11413 static void i40e_service_timer(struct timer_list *t) 11414 11414 { 11415 11415 - struct i40e_pf *pf = from_timer(pf, t, service_timer); 11415 11415 + struct i40e_pf *pf = timer_container_of(pf, t, service_timer); 11416 11416 11417 11417 mod_timer(&pf->service_timer, 11418 11418 round_jiffies(jiffies + pf->service_timer_period));

+1 -1

drivers/net/ethernet/intel/ice/ice_main.c

reviewed

··· 1743 1743 */ 1744 1744 static void ice_service_timer(struct timer_list *t) 1745 1745 { 1746 1746 - struct ice_pf *pf = from_timer(pf, t, serv_tmr); 1746 1746 + struct ice_pf *pf = timer_container_of(pf, t, serv_tmr); 1747 1747 1748 1748 mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies)); 1749 1749 ice_service_task_schedule(pf);

+2 -1

drivers/net/ethernet/intel/ice/ice_virtchnl_fdir.c

reviewed

··· 1450 1450 */ 1451 1451 static void ice_vf_fdir_timer(struct timer_list *t) 1452 1452 { 1453 1453 - struct ice_vf_fdir_ctx *ctx_irq = from_timer(ctx_irq, t, rx_tmr); 1453 1453 + struct ice_vf_fdir_ctx *ctx_irq = timer_container_of(ctx_irq, t, 1454 1454 + rx_tmr); 1454 1455 struct ice_vf_fdir_ctx *ctx_done; 1455 1456 struct ice_vf_fdir *fdir; 1456 1457 unsigned long flags;

+4 -2

drivers/net/ethernet/intel/igb/igb_main.c

reviewed

··· 5465 5465 */ 5466 5466 static void igb_update_phy_info(struct timer_list *t) 5467 5467 { 5468 5468 - struct igb_adapter *adapter = from_timer(adapter, t, phy_info_timer); 5468 5468 + struct igb_adapter *adapter = timer_container_of(adapter, t, 5469 5469 + phy_info_timer); 5469 5470 igb_get_phy_info(&adapter->hw); 5470 5471 } 5471 5472 ··· 5556 5555 **/ 5557 5556 static void igb_watchdog(struct timer_list *t) 5558 5557 { 5559 5559 - struct igb_adapter *adapter = from_timer(adapter, t, watchdog_timer); 5558 5558 + struct igb_adapter *adapter = timer_container_of(adapter, t, 5559 5559 + watchdog_timer); 5560 5560 /* Do the rest outside of interrupt context */ 5561 5561 schedule_work(&adapter->watchdog_task); 5562 5562 }

+2 -1

drivers/net/ethernet/intel/igbvf/netdev.c

reviewed

··· 1900 1900 **/ 1901 1901 static void igbvf_watchdog(struct timer_list *t) 1902 1902 { 1903 1903 - struct igbvf_adapter *adapter = from_timer(adapter, t, watchdog_timer); 1903 1903 + struct igbvf_adapter *adapter = timer_container_of(adapter, t, 1904 1904 + watchdog_timer); 1904 1905 1905 1906 /* Do the rest outside of interrupt context */ 1906 1907 schedule_work(&adapter->watchdog_task);

+4 -2

drivers/net/ethernet/intel/igc/igc_main.c

reviewed

··· 5749 5749 */ 5750 5750 static void igc_update_phy_info(struct timer_list *t) 5751 5751 { 5752 5752 - struct igc_adapter *adapter = from_timer(adapter, t, phy_info_timer); 5752 5752 + struct igc_adapter *adapter = timer_container_of(adapter, t, 5753 5753 + phy_info_timer); 5753 5754 5754 5755 igc_get_phy_info(&adapter->hw); 5755 5756 } ··· 5792 5791 */ 5793 5792 static void igc_watchdog(struct timer_list *t) 5794 5793 { 5795 5795 - struct igc_adapter *adapter = from_timer(adapter, t, watchdog_timer); 5794 5794 + struct igc_adapter *adapter = timer_container_of(adapter, t, 5795 5795 + watchdog_timer); 5796 5796 /* Do the rest outside of interrupt context */ 5797 5797 schedule_work(&adapter->watchdog_task); 5798 5798 }

+2 -1

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

reviewed

··· 8310 8310 **/ 8311 8311 static void ixgbe_service_timer(struct timer_list *t) 8312 8312 { 8313 8313 - struct ixgbe_adapter *adapter = from_timer(adapter, t, service_timer); 8313 8313 + struct ixgbe_adapter *adapter = timer_container_of(adapter, t, 8314 8314 + service_timer); 8314 8315 unsigned long next_event_offset; 8315 8316 8316 8317 /* poll faster when waiting for link */

+2 -2

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

reviewed

··· 3176 3176 **/ 3177 3177 static void ixgbevf_service_timer(struct timer_list *t) 3178 3178 { 3179 3179 - struct ixgbevf_adapter *adapter = from_timer(adapter, t, 3180 3180 - service_timer); 3179 3179 + struct ixgbevf_adapter *adapter = timer_container_of(adapter, t, 3180 3180 + service_timer); 3181 3181 3182 3182 /* Reset the timer */ 3183 3183 mod_timer(&adapter->service_timer, (HZ * 2) + jiffies);

+2 -1

drivers/net/ethernet/korina.c

reviewed

··· 900 900 901 901 static void korina_poll_media(struct timer_list *t) 902 902 { 903 903 - struct korina_private *lp = from_timer(lp, t, media_check_timer); 903 903 + struct korina_private *lp = timer_container_of(lp, t, 904 904 + media_check_timer); 904 905 struct net_device *dev = lp->dev; 905 906 906 907 korina_check_media(dev, 0);

+3 -2

drivers/net/ethernet/marvell/mv643xx_eth.c

reviewed

··· 1333 1333 1334 1334 static void mib_counters_timer_wrapper(struct timer_list *t) 1335 1335 { 1336 1336 - struct mv643xx_eth_private *mp = from_timer(mp, t, mib_counters_timer); 1336 1336 + struct mv643xx_eth_private *mp = timer_container_of(mp, t, 1337 1337 + mib_counters_timer); 1337 1338 mib_counters_update(mp); 1338 1339 mod_timer(&mp->mib_counters_timer, jiffies + 30 * HZ); 1339 1340 } ··· 2307 2306 2308 2307 static inline void oom_timer_wrapper(struct timer_list *t) 2309 2308 { 2310 2310 - struct mv643xx_eth_private *mp = from_timer(mp, t, rx_oom); 2309 2309 + struct mv643xx_eth_private *mp = timer_container_of(mp, t, rx_oom); 2311 2310 2312 2311 napi_schedule(&mp->napi); 2313 2312 }

+1 -1

drivers/net/ethernet/marvell/pxa168_eth.c

reviewed

··· 353 353 354 354 static inline void rxq_refill_timer_wrapper(struct timer_list *t) 355 355 { 356 356 - struct pxa168_eth_private *pep = from_timer(pep, t, timeout); 356 356 + struct pxa168_eth_private *pep = timer_container_of(pep, t, timeout); 357 357 napi_schedule(&pep->napi); 358 358 } 359 359

+1 -1

drivers/net/ethernet/marvell/skge.c

reviewed

··· 1494 1494 */ 1495 1495 static void xm_link_timer(struct timer_list *t) 1496 1496 { 1497 1497 - struct skge_port *skge = from_timer(skge, t, link_timer); 1497 1497 + struct skge_port *skge = timer_container_of(skge, t, link_timer); 1498 1498 struct net_device *dev = skge->netdev; 1499 1499 struct skge_hw *hw = skge->hw; 1500 1500 int port = skge->port;

+1 -1

drivers/net/ethernet/marvell/sky2.c

reviewed

··· 2961 2961 2962 2962 static void sky2_watchdog(struct timer_list *t) 2963 2963 { 2964 2964 - struct sky2_hw *hw = from_timer(hw, t, watchdog_timer); 2964 2964 + struct sky2_hw *hw = timer_container_of(hw, t, watchdog_timer); 2965 2965 2966 2966 /* Check for lost IRQ once a second */ 2967 2967 if (sky2_read32(hw, B0_ISRC)) {

+1 -1

drivers/net/ethernet/mellanox/mlx4/catas.c

reviewed

··· 236 236 237 237 static void poll_catas(struct timer_list *t) 238 238 { 239 239 - struct mlx4_priv *priv = from_timer(priv, t, catas_err.timer); 239 239 + struct mlx4_priv *priv = timer_container_of(priv, t, catas_err.timer); 240 240 struct mlx4_dev *dev = &priv->dev; 241 241 u32 slave_read; 242 242

+2 -1

drivers/net/ethernet/mellanox/mlx5/core/fw_reset.c

reviewed

··· 278 278 #define MLX5_RESET_POLL_INTERVAL (HZ / 10) 279 279 static void poll_sync_reset(struct timer_list *t) 280 280 { 281 281 - struct mlx5_fw_reset *fw_reset = from_timer(fw_reset, t, timer); 281 281 + struct mlx5_fw_reset *fw_reset = timer_container_of(fw_reset, t, 282 282 + timer); 282 283 struct mlx5_core_dev *dev = fw_reset->dev; 283 284 u32 fatal_error; 284 285

+2 -1

drivers/net/ethernet/mellanox/mlx5/core/health.c

reviewed

··· 779 779 780 780 static void poll_health(struct timer_list *t) 781 781 { 782 782 - struct mlx5_core_dev *dev = from_timer(dev, t, priv.health.timer); 782 782 + struct mlx5_core_dev *dev = timer_container_of(dev, t, 783 783 + priv.health.timer); 783 784 struct mlx5_core_health *health = &dev->priv.health; 784 785 struct health_buffer __iomem *h = health->health; 785 786 u32 fatal_error;

+4 -2

drivers/net/ethernet/micrel/ksz884x.c

reviewed

··· 6304 6304 6305 6305 static void mib_monitor(struct timer_list *t) 6306 6306 { 6307 6307 - struct dev_info *hw_priv = from_timer(hw_priv, t, mib_timer_info.timer); 6307 6307 + struct dev_info *hw_priv = timer_container_of(hw_priv, t, 6308 6308 + mib_timer_info.timer); 6308 6309 6309 6310 mib_read_work(&hw_priv->mib_read); 6310 6311 ··· 6332 6331 */ 6333 6332 static void dev_monitor(struct timer_list *t) 6334 6333 { 6335 6335 - struct dev_priv *priv = from_timer(priv, t, monitor_timer_info.timer); 6334 6334 + struct dev_priv *priv = timer_container_of(priv, t, 6335 6335 + monitor_timer_info.timer); 6336 6336 struct net_device *dev = priv->mii_if.dev; 6337 6337 struct dev_info *hw_priv = priv->adapter; 6338 6338 struct ksz_hw *hw = &hw_priv->hw;

+1 -1

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

reviewed

··· 3478 3478 u32 rx_pause_cnt; 3479 3479 u16 cmd; 3480 3480 3481 3481 - mgp = from_timer(mgp, t, watchdog_timer); 3481 3481 + mgp = timer_container_of(mgp, t, watchdog_timer); 3482 3482 3483 3483 rx_pause_cnt = ntohl(mgp->ss[0].fw_stats->dropped_pause); 3484 3484 busy_slice_cnt = 0;

+1 -1

drivers/net/ethernet/natsemi/natsemi.c

reviewed

··· 1786 1786 */ 1787 1787 static void netdev_timer(struct timer_list *t) 1788 1788 { 1789 1789 - struct netdev_private *np = from_timer(np, t, timer); 1789 1789 + struct netdev_private *np = timer_container_of(np, t, timer); 1790 1790 struct net_device *dev = np->dev; 1791 1791 void __iomem * ioaddr = ns_ioaddr(dev); 1792 1792 int next_tick = NATSEMI_TIMER_FREQ;

+1 -1

drivers/net/ethernet/natsemi/ns83820.c

reviewed

··· 1587 1587 1588 1588 static void ns83820_tx_watch(struct timer_list *t) 1589 1589 { 1590 1590 - struct ns83820 *dev = from_timer(dev, t, tx_watchdog); 1590 1590 + struct ns83820 *dev = timer_container_of(dev, t, tx_watchdog); 1591 1591 struct net_device *ndev = dev->ndev; 1592 1592 1593 1593 #if defined(DEBUG)

+1 -1

drivers/net/ethernet/neterion/s2io.c

reviewed

··· 4195 4195 static void 4196 4196 s2io_alarm_handle(struct timer_list *t) 4197 4197 { 4198 4198 - struct s2io_nic *sp = from_timer(sp, t, alarm_timer); 4198 4198 + struct s2io_nic *sp = timer_container_of(sp, t, alarm_timer); 4199 4199 struct net_device *dev = sp->dev; 4200 4200 4201 4201 s2io_handle_errors(dev);

+1 -1

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

reviewed

··· 159 159 160 160 static void nfp_net_reconfig_timer(struct timer_list *t) 161 161 { 162 162 - struct nfp_net *nn = from_timer(nn, t, reconfig_timer); 162 162 + struct nfp_net *nn = timer_container_of(nn, t, reconfig_timer); 163 163 164 164 spin_lock_bh(&nn->reconfig_lock); 165 165

+3 -3

drivers/net/ethernet/nvidia/forcedeth.c

reviewed

··· 1891 1891 /* If rx bufs are exhausted called after 50ms to attempt to refresh */ 1892 1892 static void nv_do_rx_refill(struct timer_list *t) 1893 1893 { 1894 1894 - struct fe_priv *np = from_timer(np, t, oom_kick); 1894 1894 + struct fe_priv *np = timer_container_of(np, t, oom_kick); 1895 1895 1896 1896 /* Just reschedule NAPI rx processing */ 1897 1897 napi_schedule(&np->napi); ··· 4140 4140 4141 4141 static void nv_do_nic_poll(struct timer_list *t) 4142 4142 { 4143 4143 - struct fe_priv *np = from_timer(np, t, nic_poll); 4143 4143 + struct fe_priv *np = timer_container_of(np, t, nic_poll); 4144 4144 struct net_device *dev = np->dev; 4145 4145 u8 __iomem *base = get_hwbase(dev); 4146 4146 u32 mask = 0; ··· 4259 4259 __acquires(&netdev_priv(dev)->hwstats_lock) 4260 4260 __releases(&netdev_priv(dev)->hwstats_lock) 4261 4261 { 4262 4262 - struct fe_priv *np = from_timer(np, t, stats_poll); 4262 4262 + struct fe_priv *np = timer_container_of(np, t, stats_poll); 4263 4263 struct net_device *dev = np->dev; 4264 4264 4265 4265 /* If lock is currently taken, the stats are being refreshed

+2 -2

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

reviewed

··· 1014 1014 */ 1015 1015 static void pch_gbe_watchdog(struct timer_list *t) 1016 1016 { 1017 1017 - struct pch_gbe_adapter *adapter = from_timer(adapter, t, 1018 1018 - watchdog_timer); 1017 1017 + struct pch_gbe_adapter *adapter = timer_container_of(adapter, t, 1018 1018 + watchdog_timer); 1019 1019 struct net_device *netdev = adapter->netdev; 1020 1020 struct pch_gbe_hw *hw = &adapter->hw; 1021 1021

+1 -1

drivers/net/ethernet/packetengines/hamachi.c

reviewed

··· 1025 1025 1026 1026 static void hamachi_timer(struct timer_list *t) 1027 1027 { 1028 1028 - struct hamachi_private *hmp = from_timer(hmp, t, timer); 1028 1028 + struct hamachi_private *hmp = timer_container_of(hmp, t, timer); 1029 1029 struct net_device *dev = hmp->mii_if.dev; 1030 1030 void __iomem *ioaddr = hmp->base; 1031 1031 int next_tick = 10*HZ;

+1 -1

drivers/net/ethernet/packetengines/yellowfin.c

reviewed

··· 652 652 653 653 static void yellowfin_timer(struct timer_list *t) 654 654 { 655 655 - struct yellowfin_private *yp = from_timer(yp, t, timer); 655 655 + struct yellowfin_private *yp = timer_container_of(yp, t, timer); 656 656 struct net_device *dev = pci_get_drvdata(yp->pci_dev); 657 657 void __iomem *ioaddr = yp->base; 658 658 int next_tick = 60*HZ;

+2 -1

drivers/net/ethernet/pasemi/pasemi_mac.c

reviewed

··· 934 934 935 935 static void pasemi_mac_tx_timer(struct timer_list *t) 936 936 { 937 937 - struct pasemi_mac_txring *txring = from_timer(txring, t, clean_timer); 937 937 + struct pasemi_mac_txring *txring = timer_container_of(txring, t, 938 938 + clean_timer); 938 939 struct pasemi_mac *mac = txring->mac; 939 940 940 941 pasemi_mac_clean_tx(txring);

+1 -1

drivers/net/ethernet/pensando/ionic/ionic_dev.c

reviewed

··· 13 13 14 14 static void ionic_watchdog_cb(struct timer_list *t) 15 15 { 16 16 - struct ionic *ionic = from_timer(ionic, t, watchdog_timer); 16 16 + struct ionic *ionic = timer_container_of(ionic, t, watchdog_timer); 17 17 struct ionic_lif *lif = ionic->lif; 18 18 struct ionic_deferred_work *work; 19 19 int hb;

+1 -1

drivers/net/ethernet/qlogic/qla3xxx.c

reviewed

··· 3735 3735 3736 3736 static void ql3xxx_timer(struct timer_list *t) 3737 3737 { 3738 3738 - struct ql3_adapter *qdev = from_timer(qdev, t, adapter_timer); 3738 3738 + struct ql3_adapter *qdev = timer_container_of(qdev, t, adapter_timer); 3739 3739 queue_delayed_work(qdev->workqueue, &qdev->link_state_work, 0); 3740 3740 } 3741 3741

+1 -1

drivers/net/ethernet/realtek/atp.c

reviewed

··· 717 717 problem where the adapter forgets its ethernet address. */ 718 718 static void atp_timed_checker(struct timer_list *t) 719 719 { 720 720 - struct net_local *lp = from_timer(lp, t, timer); 720 720 + struct net_local *lp = timer_container_of(lp, t, timer); 721 721 struct net_device *dev = lp->dev; 722 722 long ioaddr = dev->base_addr; 723 723 int tickssofar = jiffies - lp->last_rx_time;

+1 -1

drivers/net/ethernet/rocker/rocker_ofdpa.c

reviewed

··· 1982 1982 1983 1983 static void ofdpa_fdb_cleanup(struct timer_list *t) 1984 1984 { 1985 1985 - struct ofdpa *ofdpa = from_timer(ofdpa, t, fdb_cleanup_timer); 1985 1985 + struct ofdpa *ofdpa = timer_container_of(ofdpa, t, fdb_cleanup_timer); 1986 1986 struct ofdpa_port *ofdpa_port; 1987 1987 struct ofdpa_fdb_tbl_entry *entry; 1988 1988 struct hlist_node *tmp;

+3 -2

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c

reviewed

··· 104 104 */ 105 105 static void sxgbe_eee_ctrl_timer(struct timer_list *t) 106 106 { 107 107 - struct sxgbe_priv_data *priv = from_timer(priv, t, eee_ctrl_timer); 107 107 + struct sxgbe_priv_data *priv = timer_container_of(priv, t, 108 108 + eee_ctrl_timer); 108 109 109 110 sxgbe_enable_eee_mode(priv); 110 111 mod_timer(&priv->eee_ctrl_timer, SXGBE_LPI_TIMER(eee_timer)); ··· 1013 1012 */ 1014 1013 static void sxgbe_tx_timer(struct timer_list *t) 1015 1014 { 1016 1016 - struct sxgbe_tx_queue *p = from_timer(p, t, txtimer); 1015 1015 + struct sxgbe_tx_queue *p = timer_container_of(p, t, txtimer); 1017 1016 sxgbe_tx_queue_clean(p); 1018 1017 } 1019 1018

+1 -1

drivers/net/ethernet/seeq/ether3.c

reviewed

··· 170 170 */ 171 171 static void ether3_ledoff(struct timer_list *t) 172 172 { 173 173 - struct dev_priv *private = from_timer(private, t, timer); 173 173 + struct dev_priv *private = timer_container_of(private, t, timer); 174 174 struct net_device *dev = private->dev; 175 175 176 176 ether3_outw(priv(dev)->regs.config2 |= CFG2_CTRLO, REG_CONFIG2);

+2 -2

drivers/net/ethernet/sfc/falcon/falcon.c

reviewed

··· 1453 1453 1454 1454 static void falcon_stats_timer_func(struct timer_list *t) 1455 1455 { 1456 1456 - struct falcon_nic_data *nic_data = from_timer(nic_data, t, 1457 1457 - stats_timer); 1456 1456 + struct falcon_nic_data *nic_data = timer_container_of(nic_data, t, 1457 1457 + stats_timer); 1458 1458 struct ef4_nic *efx = nic_data->efx; 1459 1459 1460 1460 spin_lock(&efx->stats_lock);

+2 -1

drivers/net/ethernet/sfc/falcon/rx.c

reviewed

··· 382 382 383 383 void ef4_rx_slow_fill(struct timer_list *t) 384 384 { 385 385 - struct ef4_rx_queue *rx_queue = from_timer(rx_queue, t, slow_fill); 385 385 + struct ef4_rx_queue *rx_queue = timer_container_of(rx_queue, t, 386 386 + slow_fill); 386 387 387 388 /* Post an event to cause NAPI to run and refill the queue */ 388 389 ef4_nic_generate_fill_event(rx_queue);

+1 -1

drivers/net/ethernet/sfc/mcdi.c

reviewed

··· 605 605 606 606 static void efx_mcdi_timeout_async(struct timer_list *t) 607 607 { 608 608 - struct efx_mcdi_iface *mcdi = from_timer(mcdi, t, async_timer); 608 608 + struct efx_mcdi_iface *mcdi = timer_container_of(mcdi, t, async_timer); 609 609 610 610 efx_mcdi_complete_async(mcdi, true); 611 611 }

+2 -1

drivers/net/ethernet/sfc/rx_common.c

reviewed

··· 352 352 353 353 void efx_rx_slow_fill(struct timer_list *t) 354 354 { 355 355 - struct efx_rx_queue *rx_queue = from_timer(rx_queue, t, slow_fill); 355 355 + struct efx_rx_queue *rx_queue = timer_container_of(rx_queue, t, 356 356 + slow_fill); 356 357 357 358 /* Post an event to cause NAPI to run and refill the queue */ 358 359 efx_nic_generate_fill_event(rx_queue);

+1 -1

drivers/net/ethernet/sfc/siena/mcdi.c

reviewed

··· 609 609 610 610 static void efx_mcdi_timeout_async(struct timer_list *t) 611 611 { 612 612 - struct efx_mcdi_iface *mcdi = from_timer(mcdi, t, async_timer); 612 612 + struct efx_mcdi_iface *mcdi = timer_container_of(mcdi, t, async_timer); 613 613 614 614 efx_mcdi_complete_async(mcdi, true); 615 615 }

+2 -1

drivers/net/ethernet/sfc/siena/rx_common.c

reviewed

··· 349 349 350 350 void efx_siena_rx_slow_fill(struct timer_list *t) 351 351 { 352 352 - struct efx_rx_queue *rx_queue = from_timer(rx_queue, t, slow_fill); 352 352 + struct efx_rx_queue *rx_queue = timer_container_of(rx_queue, t, 353 353 + slow_fill); 353 354 354 355 /* Post an event to cause NAPI to run and refill the queue */ 355 356 efx_nic_generate_fill_event(rx_queue);

+1 -1

drivers/net/ethernet/sgi/ioc3-eth.c

reviewed

··· 570 570 571 571 static void ioc3_timer(struct timer_list *t) 572 572 { 573 573 - struct ioc3_private *ip = from_timer(ip, t, ioc3_timer); 573 573 + struct ioc3_private *ip = timer_container_of(ip, t, ioc3_timer); 574 574 575 575 /* Print the link status if it has changed */ 576 576 mii_check_media(&ip->mii, 1, 0);

+1 -1

drivers/net/ethernet/sis/sis190.c

reviewed

··· 1023 1023 1024 1024 static void sis190_phy_timer(struct timer_list *t) 1025 1025 { 1026 1026 - struct sis190_private *tp = from_timer(tp, t, timer); 1026 1026 + struct sis190_private *tp = timer_container_of(tp, t, timer); 1027 1027 struct net_device *dev = tp->dev; 1028 1028 1029 1029 if (likely(netif_running(dev)))

+2 -1

drivers/net/ethernet/sis/sis900.c

reviewed

··· 1314 1314 1315 1315 static void sis900_timer(struct timer_list *t) 1316 1316 { 1317 1317 - struct sis900_private *sis_priv = from_timer(sis_priv, t, timer); 1317 1317 + struct sis900_private *sis_priv = timer_container_of(sis_priv, t, 1318 1318 + timer); 1318 1319 struct net_device *net_dev = sis_priv->mii_info.dev; 1319 1320 struct mii_phy *mii_phy = sis_priv->mii; 1320 1321 static const int next_tick = 5*HZ;

+1 -1

drivers/net/ethernet/smsc/epic100.c

reviewed

··· 850 850 851 851 static void epic_timer(struct timer_list *t) 852 852 { 853 853 - struct epic_private *ep = from_timer(ep, t, timer); 853 853 + struct epic_private *ep = timer_container_of(ep, t, timer); 854 854 struct net_device *dev = ep->mii.dev; 855 855 void __iomem *ioaddr = ep->ioaddr; 856 856 int next_tick = 5*HZ;

+1 -1

drivers/net/ethernet/smsc/smc91c92_cs.c

reviewed

··· 1713 1713 1714 1714 static void media_check(struct timer_list *t) 1715 1715 { 1716 1716 - struct smc_private *smc = from_timer(smc, t, media); 1716 1716 + struct smc_private *smc = timer_container_of(smc, t, media); 1717 1717 struct net_device *dev = smc->mii_if.dev; 1718 1718 unsigned int ioaddr = dev->base_addr; 1719 1719 u_short i, media, saved_bank;

+1 -1

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

reviewed

··· 481 481 */ 482 482 static void stmmac_eee_ctrl_timer(struct timer_list *t) 483 483 { 484 484 - struct stmmac_priv *priv = from_timer(priv, t, eee_ctrl_timer); 484 484 + struct stmmac_priv *priv = timer_container_of(priv, t, eee_ctrl_timer); 485 485 486 486 stmmac_try_to_start_sw_lpi(priv); 487 487 }

+1 -1

drivers/net/ethernet/sun/cassini.c

reviewed

··· 4021 4021 4022 4022 static void cas_link_timer(struct timer_list *t) 4023 4023 { 4024 4024 - struct cas *cp = from_timer(cp, t, link_timer); 4024 4024 + struct cas *cp = timer_container_of(cp, t, link_timer); 4025 4025 int mask, pending = 0, reset = 0; 4026 4026 unsigned long flags; 4027 4027

+1 -1

drivers/net/ethernet/sun/niu.c

reviewed

··· 2225 2225 2226 2226 static void niu_timer(struct timer_list *t) 2227 2227 { 2228 2228 - struct niu *np = from_timer(np, t, timer); 2228 2228 + struct niu *np = timer_container_of(np, t, timer); 2229 2229 unsigned long off; 2230 2230 int err, link_up; 2231 2231

+1 -1

drivers/net/ethernet/sun/sunbmac.c

reviewed

··· 526 526 527 527 static void bigmac_timer(struct timer_list *t) 528 528 { 529 529 - struct bigmac *bp = from_timer(bp, t, bigmac_timer); 529 529 + struct bigmac *bp = timer_container_of(bp, t, bigmac_timer); 530 530 void __iomem *tregs = bp->tregs; 531 531 int restart_timer = 0; 532 532

+1 -1

drivers/net/ethernet/sun/sungem.c

reviewed

··· 1481 1481 1482 1482 static void gem_link_timer(struct timer_list *t) 1483 1483 { 1484 1484 - struct gem *gp = from_timer(gp, t, link_timer); 1484 1484 + struct gem *gp = timer_container_of(gp, t, link_timer); 1485 1485 struct net_device *dev = gp->dev; 1486 1486 int restart_aneg = 0; 1487 1487

+1 -1

drivers/net/ethernet/sun/sunhme.c

reviewed

··· 721 721 722 722 static void happy_meal_timer(struct timer_list *t) 723 723 { 724 724 - struct happy_meal *hp = from_timer(hp, t, happy_timer); 724 724 + struct happy_meal *hp = timer_container_of(hp, t, happy_timer); 725 725 void __iomem *tregs = hp->tcvregs; 726 726 int restart_timer = 0; 727 727

+1 -1

drivers/net/ethernet/sun/sunvnet_common.c

reviewed

··· 1044 1044 1045 1045 void sunvnet_clean_timer_expire_common(struct timer_list *t) 1046 1046 { 1047 1047 - struct vnet_port *port = from_timer(port, t, clean_timer); 1047 1047 + struct vnet_port *port = timer_container_of(port, t, clean_timer); 1048 1048 struct sk_buff *freeskbs; 1049 1049 unsigned pending; 1050 1050

+2 -1

drivers/net/ethernet/synopsys/dwc-xlgmac-net.c

reviewed

··· 360 360 361 361 static void xlgmac_tx_timer(struct timer_list *t) 362 362 { 363 363 - struct xlgmac_channel *channel = from_timer(channel, t, tx_timer); 363 363 + struct xlgmac_channel *channel = timer_container_of(channel, t, 364 364 + tx_timer); 364 365 struct xlgmac_pdata *pdata = channel->pdata; 365 366 struct napi_struct *napi; 366 367

+1 -1

drivers/net/ethernet/ti/cpsw_ale.c

reviewed

··· 1231 1231 1232 1232 static void cpsw_ale_timer(struct timer_list *t) 1233 1233 { 1234 1234 - struct cpsw_ale *ale = from_timer(ale, t, timer); 1234 1234 + struct cpsw_ale *ale = timer_container_of(ale, t, timer); 1235 1235 1236 1236 cpsw_ale_control_set(ale, 0, ALE_AGEOUT, 1); 1237 1237

+1 -1

drivers/net/ethernet/ti/netcp_ethss.c

reviewed

··· 2833 2833 2834 2834 static void netcp_ethss_timer(struct timer_list *t) 2835 2835 { 2836 2836 - struct gbe_priv *gbe_dev = from_timer(gbe_dev, t, timer); 2836 2836 + struct gbe_priv *gbe_dev = timer_container_of(gbe_dev, t, timer); 2837 2837 struct gbe_intf *gbe_intf; 2838 2838 struct gbe_slave *slave; 2839 2839

+2 -2

drivers/net/ethernet/ti/tlan.c

reviewed

··· 1815 1815 1816 1816 static void tlan_timer(struct timer_list *t) 1817 1817 { 1818 1818 - struct tlan_priv *priv = from_timer(priv, t, timer); 1818 1818 + struct tlan_priv *priv = timer_container_of(priv, t, timer); 1819 1819 struct net_device *dev = priv->dev; 1820 1820 u32 elapsed; 1821 1821 unsigned long flags = 0; ··· 2746 2746 2747 2747 static void tlan_phy_monitor(struct timer_list *t) 2748 2748 { 2749 2749 - struct tlan_priv *priv = from_timer(priv, t, media_timer); 2749 2749 + struct tlan_priv *priv = timer_container_of(priv, t, media_timer); 2750 2750 struct net_device *dev = priv->dev; 2751 2751 u16 phy; 2752 2752 u16 phy_status;

+1 -1

drivers/net/ethernet/tundra/tsi108_eth.c

reviewed

··· 1652 1652 1653 1653 static void tsi108_timed_checker(struct timer_list *t) 1654 1654 { 1655 1655 - struct tsi108_prv_data *data = from_timer(data, t, timer); 1655 1655 + struct tsi108_prv_data *data = timer_container_of(data, t, timer); 1656 1656 struct net_device *dev = data->dev; 1657 1657 1658 1658 tsi108_check_phy(dev);

+1 -1

drivers/net/ethernet/wangxun/libwx/wx_lib.c

reviewed

··· 3116 3116 3117 3117 void wx_service_timer(struct timer_list *t) 3118 3118 { 3119 3119 - struct wx *wx = from_timer(wx, t, service_timer); 3119 3119 + struct wx *wx = timer_container_of(wx, t, service_timer); 3120 3120 unsigned long next_event_offset = HZ * 2; 3121 3121 3122 3122 /* Reset the timer */

+1 -1

drivers/net/fddi/defza.c

reviewed

··· 1044 1044 1045 1045 static void fza_reset_timer(struct timer_list *t) 1046 1046 { 1047 1047 - struct fza_private *fp = from_timer(fp, t, reset_timer); 1047 1047 + struct fza_private *fp = timer_container_of(fp, t, reset_timer); 1048 1048 1049 1049 if (!fp->timer_state) { 1050 1050 pr_err("%s: RESET timed out!\n", fp->name);

+2 -2

drivers/net/hamradio/6pack.c

reviewed

··· 133 133 134 134 static void sp_xmit_on_air(struct timer_list *t) 135 135 { 136 136 - struct sixpack *sp = from_timer(sp, t, tx_t); 136 136 + struct sixpack *sp = timer_container_of(sp, t, tx_t); 137 137 int actual, when = sp->slottime; 138 138 static unsigned char random; 139 139 ··· 491 491 492 492 static void resync_tnc(struct timer_list *t) 493 493 { 494 494 - struct sixpack *sp = from_timer(sp, t, resync_t); 494 494 + struct sixpack *sp = timer_container_of(sp, t, resync_t); 495 495 static char resync_cmd = 0xe8; 496 496 497 497 /* clear any data that might have been received */

+7 -7

drivers/net/hamradio/scc.c

reviewed

··· 1127 1127 1128 1128 static void t_dwait(struct timer_list *t) 1129 1129 { 1130 1130 - struct scc_channel *scc = from_timer(scc, t, tx_t); 1130 1130 + struct scc_channel *scc = timer_container_of(scc, t, tx_t); 1131 1131 1132 1132 if (scc->stat.tx_state == TXS_WAIT) /* maxkeyup or idle timeout */ 1133 1133 { ··· 1169 1169 1170 1170 static void t_txdelay(struct timer_list *t) 1171 1171 { 1172 1172 - struct scc_channel *scc = from_timer(scc, t, tx_t); 1172 1172 + struct scc_channel *scc = timer_container_of(scc, t, tx_t); 1173 1173 1174 1174 scc_start_maxkeyup(scc); 1175 1175 ··· 1190 1190 1191 1191 static void t_tail(struct timer_list *t) 1192 1192 { 1193 1193 - struct scc_channel *scc = from_timer(scc, t, tx_t); 1193 1193 + struct scc_channel *scc = timer_container_of(scc, t, tx_t); 1194 1194 unsigned long flags; 1195 1195 1196 1196 spin_lock_irqsave(&scc->lock, flags); ··· 1217 1217 1218 1218 static void t_busy(struct timer_list *t) 1219 1219 { 1220 1220 - struct scc_channel *scc = from_timer(scc, t, tx_wdog); 1220 1220 + struct scc_channel *scc = timer_container_of(scc, t, tx_wdog); 1221 1221 1222 1222 timer_delete(&scc->tx_t); 1223 1223 netif_stop_queue(scc->dev); /* don't pile on the wabbit! */ ··· 1236 1236 1237 1237 static void t_maxkeyup(struct timer_list *t) 1238 1238 { 1239 1239 - struct scc_channel *scc = from_timer(scc, t, tx_wdog); 1239 1239 + struct scc_channel *scc = timer_container_of(scc, t, tx_wdog); 1240 1240 unsigned long flags; 1241 1241 1242 1242 spin_lock_irqsave(&scc->lock, flags); ··· 1270 1270 1271 1271 static void t_idle(struct timer_list *t) 1272 1272 { 1273 1273 - struct scc_channel *scc = from_timer(scc, t, tx_t); 1273 1273 + struct scc_channel *scc = timer_container_of(scc, t, tx_t); 1274 1274 1275 1275 timer_delete(&scc->tx_wdog); 1276 1276 ··· 1403 1403 1404 1404 static void scc_stop_calibrate(struct timer_list *t) 1405 1405 { 1406 1406 - struct scc_channel *scc = from_timer(scc, t, tx_wdog); 1406 1406 + struct scc_channel *scc = timer_container_of(scc, t, tx_wdog); 1407 1407 unsigned long flags; 1408 1408 1409 1409 spin_lock_irqsave(&scc->lock, flags);

+1 -1

drivers/net/hippi/rrunner.c

reviewed

··· 1154 1154 1155 1155 static void rr_timer(struct timer_list *t) 1156 1156 { 1157 1157 - struct rr_private *rrpriv = from_timer(rrpriv, t, timer); 1157 1157 + struct rr_private *rrpriv = timer_container_of(rrpriv, t, timer); 1158 1158 struct net_device *dev = pci_get_drvdata(rrpriv->pci_dev); 1159 1159 struct rr_regs __iomem *regs = rrpriv->regs; 1160 1160 unsigned long flags;

+1 -1

drivers/net/ntb_netdev.c

reviewed

··· 229 229 230 230 static void ntb_netdev_tx_timer(struct timer_list *t) 231 231 { 232 232 - struct ntb_netdev *dev = from_timer(dev, t, tx_timer); 232 232 + struct ntb_netdev *dev = timer_container_of(dev, t, tx_timer); 233 233 struct net_device *ndev = dev->ndev; 234 234 235 235 if (ntb_transport_tx_free_entry(dev->qp) < tx_stop) {

+2 -2

drivers/net/slip/slip.c

reviewed

··· 1378 1378 1379 1379 static void sl_outfill(struct timer_list *t) 1380 1380 { 1381 1381 - struct slip *sl = from_timer(sl, t, outfill_timer); 1381 1381 + struct slip *sl = timer_container_of(sl, t, outfill_timer); 1382 1382 1383 1383 spin_lock(&sl->lock); 1384 1384 ··· 1409 1409 1410 1410 static void sl_keepalive(struct timer_list *t) 1411 1411 { 1412 1412 - struct slip *sl = from_timer(sl, t, keepalive_timer); 1412 1412 + struct slip *sl = timer_container_of(sl, t, keepalive_timer); 1413 1413 1414 1414 spin_lock(&sl->lock); 1415 1415

+1 -1

drivers/net/tun.c

reviewed

··· 377 377 378 378 static void tun_flow_cleanup(struct timer_list *t) 379 379 { 380 380 - struct tun_struct *tun = from_timer(tun, t, flow_gc_timer); 380 380 + struct tun_struct *tun = timer_container_of(tun, t, flow_gc_timer); 381 381 unsigned long delay = tun->ageing_time; 382 382 unsigned long next_timer = jiffies + delay; 383 383 unsigned long count = 0;

+1 -1

drivers/net/usb/catc.c

reviewed

··· 602 602 603 603 static void catc_stats_timer(struct timer_list *t) 604 604 { 605 605 - struct catc *catc = from_timer(catc, t, timer); 605 605 + struct catc *catc = timer_container_of(catc, t, timer); 606 606 int i; 607 607 608 608 for (i = 0; i < 8; i++)

+1 -1

drivers/net/usb/lan78xx.c

reviewed

··· 4642 4642 4643 4643 static void lan78xx_stat_monitor(struct timer_list *t) 4644 4644 { 4645 4645 - struct lan78xx_net *dev = from_timer(dev, t, stat_monitor); 4645 4645 + struct lan78xx_net *dev = timer_container_of(dev, t, stat_monitor); 4646 4646 4647 4647 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE); 4648 4648 }

+1 -1

drivers/net/usb/sierra_net.c

reviewed

··· 573 573 */ 574 574 static void sierra_sync_timer(struct timer_list *t) 575 575 { 576 576 - struct sierra_net_data *priv = from_timer(priv, t, sync_timer); 576 576 + struct sierra_net_data *priv = timer_container_of(priv, t, sync_timer); 577 577 struct usbnet *dev = priv->usbnet; 578 578 579 579 dev_dbg(&dev->udev->dev, "%s", __func__);

+1 -1

drivers/net/usb/usbnet.c

reviewed

··· 1551 1551 1552 1552 static void usbnet_bh (struct timer_list *t) 1553 1553 { 1554 1554 - struct usbnet *dev = from_timer(dev, t, delay); 1554 1554 + struct usbnet *dev = timer_container_of(dev, t, delay); 1555 1555 struct sk_buff *skb; 1556 1556 struct skb_data *entry; 1557 1557

+1 -1

drivers/net/vxlan/vxlan_core.c

reviewed

··· 2809 2809 /* Walk the forwarding table and purge stale entries */ 2810 2810 static void vxlan_cleanup(struct timer_list *t) 2811 2811 { 2812 2812 - struct vxlan_dev *vxlan = from_timer(vxlan, t, age_timer); 2812 2812 + struct vxlan_dev *vxlan = timer_container_of(vxlan, t, age_timer); 2813 2813 unsigned long next_timer = jiffies + FDB_AGE_INTERVAL; 2814 2814 struct vxlan_fdb *f; 2815 2815

+1 -1

drivers/net/wan/hdlc_cisco.c

reviewed

··· 244 244 245 245 static void cisco_timer(struct timer_list *t) 246 246 { 247 247 - struct cisco_state *st = from_timer(st, t, timer); 247 247 + struct cisco_state *st = timer_container_of(st, t, timer); 248 248 struct net_device *dev = st->dev; 249 249 250 250 spin_lock(&st->lock);

+1 -1

drivers/net/wan/hdlc_fr.c

reviewed

··· 581 581 582 582 static void fr_timer(struct timer_list *t) 583 583 { 584 584 - struct frad_state *st = from_timer(st, t, timer); 584 584 + struct frad_state *st = timer_container_of(st, t, timer); 585 585 struct net_device *dev = st->dev; 586 586 hdlc_device *hdlc = dev_to_hdlc(dev); 587 587 int i, cnt = 0, reliable;

+1 -1

drivers/net/wan/hdlc_ppp.c

reviewed

··· 561 561 562 562 static void ppp_timer(struct timer_list *t) 563 563 { 564 564 - struct proto *proto = from_timer(proto, t, timer); 564 564 + struct proto *proto = timer_container_of(proto, t, timer); 565 565 struct ppp *ppp = get_ppp(proto->dev); 566 566 unsigned long flags; 567 567

+10 -7

drivers/net/wireguard/timers.c

reviewed

··· 40 40 41 41 static void wg_expired_retransmit_handshake(struct timer_list *timer) 42 42 { 43 43 - struct wg_peer *peer = from_timer(peer, timer, 44 44 - timer_retransmit_handshake); 43 43 + struct wg_peer *peer = timer_container_of(peer, timer, 44 44 + timer_retransmit_handshake); 45 45 46 46 if (peer->timer_handshake_attempts > MAX_TIMER_HANDSHAKES) { 47 47 pr_debug("%s: Handshake for peer %llu (%pISpfsc) did not complete after %d attempts, giving up\n", ··· 78 78 79 79 static void wg_expired_send_keepalive(struct timer_list *timer) 80 80 { 81 81 - struct wg_peer *peer = from_timer(peer, timer, timer_send_keepalive); 81 81 + struct wg_peer *peer = timer_container_of(peer, timer, 82 82 + timer_send_keepalive); 82 83 83 84 wg_packet_send_keepalive(peer); 84 85 if (peer->timer_need_another_keepalive) { ··· 91 90 92 91 static void wg_expired_new_handshake(struct timer_list *timer) 93 92 { 94 94 - struct wg_peer *peer = from_timer(peer, timer, timer_new_handshake); 93 93 + struct wg_peer *peer = timer_container_of(peer, timer, 94 94 + timer_new_handshake); 95 95 96 96 pr_debug("%s: Retrying handshake with peer %llu (%pISpfsc) because we stopped hearing back after %d seconds\n", 97 97 peer->device->dev->name, peer->internal_id, ··· 106 104 107 105 static void wg_expired_zero_key_material(struct timer_list *timer) 108 106 { 109 109 - struct wg_peer *peer = from_timer(peer, timer, timer_zero_key_material); 107 107 + struct wg_peer *peer = timer_container_of(peer, timer, 108 108 + timer_zero_key_material); 110 109 111 110 rcu_read_lock_bh(); 112 111 if (!READ_ONCE(peer->is_dead)) { ··· 137 134 138 135 static void wg_expired_send_persistent_keepalive(struct timer_list *timer) 139 136 { 140 140 - struct wg_peer *peer = from_timer(peer, timer, 141 141 - timer_persistent_keepalive); 137 137 + struct wg_peer *peer = timer_container_of(peer, timer, 138 138 + timer_persistent_keepalive); 142 139 143 140 if (likely(peer->persistent_keepalive_interval)) 144 141 wg_packet_send_keepalive(peer);

+1 -1

drivers/net/wireless/ath/ar5523/ar5523.c

reviewed

··· 902 902 903 903 static void ar5523_tx_wd_timer(struct timer_list *t) 904 904 { 905 905 - struct ar5523 *ar = from_timer(ar, t, tx_wd_timer); 905 905 + struct ar5523 *ar = timer_container_of(ar, t, tx_wd_timer); 906 906 907 907 ar5523_dbg(ar, "TX watchdog timer triggered\n"); 908 908 ieee80211_queue_work(ar->hw, &ar->tx_wd_work);

+2 -1

drivers/net/wireless/ath/ath10k/htt_rx.c

reviewed

··· 257 257 258 258 static void ath10k_htt_rx_ring_refill_retry(struct timer_list *t) 259 259 { 260 260 - struct ath10k_htt *htt = from_timer(htt, t, rx_ring.refill_retry_timer); 260 260 + struct ath10k_htt *htt = timer_container_of(htt, t, 261 261 + rx_ring.refill_retry_timer); 261 262 262 263 ath10k_htt_rx_msdu_buff_replenish(htt); 263 264 }

+3 -2

drivers/net/wireless/ath/ath10k/pci.c

reviewed

··· 591 591 592 592 static void ath10k_pci_ps_timer(struct timer_list *t) 593 593 { 594 594 - struct ath10k_pci *ar_pci = from_timer(ar_pci, t, ps_timer); 594 594 + struct ath10k_pci *ar_pci = timer_container_of(ar_pci, t, ps_timer); 595 595 struct ath10k *ar = ar_pci->ar; 596 596 unsigned long flags; 597 597 ··· 844 844 845 845 void ath10k_pci_rx_replenish_retry(struct timer_list *t) 846 846 { 847 847 - struct ath10k_pci *ar_pci = from_timer(ar_pci, t, rx_post_retry); 847 847 + struct ath10k_pci *ar_pci = timer_container_of(ar_pci, t, 848 848 + rx_post_retry); 848 849 struct ath10k *ar = ar_pci->ar; 849 850 850 851 ath10k_pci_rx_post(ar);

+2 -1

drivers/net/wireless/ath/ath10k/sdio.c

reviewed

··· 1447 1447 1448 1448 static void ath10k_sdio_sleep_timer_handler(struct timer_list *t) 1449 1449 { 1450 1450 - struct ath10k_sdio *ar_sdio = from_timer(ar_sdio, t, sleep_timer); 1450 1450 + struct ath10k_sdio *ar_sdio = timer_container_of(ar_sdio, t, 1451 1451 + sleep_timer); 1451 1452 1452 1453 ar_sdio->mbox_state = SDIO_MBOX_REQUEST_TO_SLEEP_STATE; 1453 1454 queue_work(ar_sdio->workqueue, &ar_sdio->wr_async_work);

+2 -1

drivers/net/wireless/ath/ath10k/snoc.c

reviewed

··· 644 644 645 645 static void ath10k_snoc_rx_replenish_retry(struct timer_list *t) 646 646 { 647 647 - struct ath10k_snoc *ar_snoc = from_timer(ar_snoc, t, rx_post_retry); 647 647 + struct ath10k_snoc *ar_snoc = timer_container_of(ar_snoc, t, 648 648 + rx_post_retry); 648 649 struct ath10k *ar = ar_snoc->ar; 649 650 650 651 ath10k_snoc_rx_post(ar);

+1 -1

drivers/net/wireless/ath/ath11k/ce.c

reviewed

··· 907 907 908 908 void ath11k_ce_rx_replenish_retry(struct timer_list *t) 909 909 { 910 910 - struct ath11k_base *ab = from_timer(ab, t, rx_replenish_retry); 910 910 + struct ath11k_base *ab = timer_container_of(ab, t, rx_replenish_retry); 911 911 912 912 ath11k_ce_rx_post_buf(ab); 913 913 }

+3 -2

drivers/net/wireless/ath/ath11k/dp.c

reviewed

··· 1117 1117 1118 1118 static void ath11k_dp_shadow_timer_handler(struct timer_list *t) 1119 1119 { 1120 1120 - struct ath11k_hp_update_timer *update_timer = from_timer(update_timer, 1121 1121 - t, timer); 1120 1120 + struct ath11k_hp_update_timer *update_timer = timer_container_of(update_timer, 1121 1121 + t, 1122 1122 + timer); 1122 1123 struct ath11k_base *ab = update_timer->ab; 1123 1124 struct hal_srng *srng = &ab->hal.srng_list[update_timer->ring_id]; 1124 1125

+3 -2

drivers/net/wireless/ath/ath11k/dp_rx.c

reviewed

··· 308 308 309 309 static void ath11k_dp_service_mon_ring(struct timer_list *t) 310 310 { 311 311 - struct ath11k_base *ab = from_timer(ab, t, mon_reap_timer); 311 311 + struct ath11k_base *ab = timer_container_of(ab, t, mon_reap_timer); 312 312 int i; 313 313 314 314 for (i = 0; i < ab->hw_params.num_rxdma_per_pdev; i++) ··· 3174 3174 3175 3175 static void ath11k_dp_rx_frag_timer(struct timer_list *timer) 3176 3176 { 3177 3177 - struct dp_rx_tid *rx_tid = from_timer(rx_tid, timer, frag_timer); 3177 3177 + struct dp_rx_tid *rx_tid = timer_container_of(rx_tid, timer, 3178 3178 + frag_timer); 3178 3179 3179 3180 spin_lock_bh(&rx_tid->ab->base_lock); 3180 3181 if (rx_tid->last_frag_no &&

+1 -1

drivers/net/wireless/ath/ath12k/ce.c

reviewed

··· 868 868 869 869 void ath12k_ce_rx_replenish_retry(struct timer_list *t) 870 870 { 871 871 - struct ath12k_base *ab = from_timer(ab, t, rx_replenish_retry); 871 871 + struct ath12k_base *ab = timer_container_of(ab, t, rx_replenish_retry); 872 872 873 873 ath12k_ce_rx_post_buf(ab); 874 874 }

+2 -1

drivers/net/wireless/ath/ath12k/dp_rx.c

reviewed

··· 2955 2955 2956 2956 static void ath12k_dp_rx_frag_timer(struct timer_list *timer) 2957 2957 { 2958 2958 - struct ath12k_dp_rx_tid *rx_tid = from_timer(rx_tid, timer, frag_timer); 2958 2958 + struct ath12k_dp_rx_tid *rx_tid = timer_container_of(rx_tid, timer, 2959 2959 + frag_timer); 2959 2960 2960 2961 spin_lock_bh(&rx_tid->ab->base_lock); 2961 2962 if (rx_tid->last_frag_no &&

+1 -1

drivers/net/wireless/ath/ath6kl/main.c

reviewed

··· 503 503 504 504 void disconnect_timer_handler(struct timer_list *t) 505 505 { 506 506 - struct ath6kl_vif *vif = from_timer(vif, t, disconnect_timer); 506 506 + struct ath6kl_vif *vif = timer_container_of(vif, t, disconnect_timer); 507 507 508 508 ath6kl_init_profile_info(vif); 509 509 ath6kl_disconnect(vif);

+1 -1

drivers/net/wireless/ath/ath6kl/recovery.c

reviewed

··· 62 62 63 63 static void ath6kl_recovery_hb_timer(struct timer_list *t) 64 64 { 65 65 - struct ath6kl *ar = from_timer(ar, t, fw_recovery.hb_timer); 65 65 + struct ath6kl *ar = timer_container_of(ar, t, fw_recovery.hb_timer); 66 66 int err; 67 67 68 68 if (test_bit(RECOVERY_CLEANUP, &ar->flag) ||

+2 -1

drivers/net/wireless/ath/ath6kl/txrx.c

reviewed

··· 1623 1623 static void aggr_timeout(struct timer_list *t) 1624 1624 { 1625 1625 u8 i, j; 1626 1626 - struct aggr_info_conn *aggr_conn = from_timer(aggr_conn, t, timer); 1626 1626 + struct aggr_info_conn *aggr_conn = timer_container_of(aggr_conn, t, 1627 1627 + timer); 1627 1628 struct rxtid *rxtid; 1628 1629 struct rxtid_stats *stats; 1629 1630

+1 -1

drivers/net/wireless/ath/ath6kl/wmi.c

reviewed

··· 1078 1078 1079 1079 void ath6kl_wmi_sscan_timer(struct timer_list *t) 1080 1080 { 1081 1081 - struct ath6kl_vif *vif = from_timer(vif, t, sched_scan_timer); 1081 1081 + struct ath6kl_vif *vif = timer_container_of(vif, t, sched_scan_timer); 1082 1082 1083 1083 cfg80211_sched_scan_results(vif->ar->wiphy, 0); 1084 1084 }

+2 -2

drivers/net/wireless/ath/ath9k/channel.c

reviewed

··· 1040 1040 1041 1041 static void ath_chanctx_timer(struct timer_list *t) 1042 1042 { 1043 1043 - struct ath_softc *sc = from_timer(sc, t, sched.timer); 1043 1043 + struct ath_softc *sc = timer_container_of(sc, t, sched.timer); 1044 1044 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1045 1045 1046 1046 ath_dbg(common, CHAN_CTX, ··· 1051 1051 1052 1052 static void ath_offchannel_timer(struct timer_list *t) 1053 1053 { 1054 1054 - struct ath_softc *sc = from_timer(sc, t, offchannel.timer); 1054 1054 + struct ath_softc *sc = timer_container_of(sc, t, offchannel.timer); 1055 1055 struct ath_chanctx *ctx; 1056 1056 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1057 1057

+3 -2

drivers/net/wireless/ath/ath9k/gpio.c

reviewed

··· 193 193 */ 194 194 static void ath_btcoex_period_timer(struct timer_list *t) 195 195 { 196 196 - struct ath_softc *sc = from_timer(sc, t, btcoex.period_timer); 196 196 + struct ath_softc *sc = timer_container_of(sc, t, btcoex.period_timer); 197 197 struct ath_hw *ah = sc->sc_ah; 198 198 struct ath_btcoex *btcoex = &sc->btcoex; 199 199 enum ath_stomp_type stomp_type; ··· 254 254 */ 255 255 static void ath_btcoex_no_stomp_timer(struct timer_list *t) 256 256 { 257 257 - struct ath_softc *sc = from_timer(sc, t, btcoex.no_stomp_timer); 257 257 + struct ath_softc *sc = timer_container_of(sc, t, 258 258 + btcoex.no_stomp_timer); 258 259 struct ath_hw *ah = sc->sc_ah; 259 260 struct ath_btcoex *btcoex = &sc->btcoex; 260 261

+2 -1

drivers/net/wireless/ath/ath9k/htc_drv_txrx.c

reviewed

··· 760 760 761 761 void ath9k_htc_tx_cleanup_timer(struct timer_list *t) 762 762 { 763 763 - struct ath9k_htc_priv *priv = from_timer(priv, t, tx.cleanup_timer); 763 763 + struct ath9k_htc_priv *priv = timer_container_of(priv, t, 764 764 + tx.cleanup_timer); 764 765 struct ath_common *common = ath9k_hw_common(priv->ah); 765 766 struct ath9k_htc_tx_event *event, *tmp; 766 767 struct sk_buff *skb;

+1 -1

drivers/net/wireless/ath/ath9k/link.c

reviewed

··· 332 332 */ 333 333 void ath_ani_calibrate(struct timer_list *t) 334 334 { 335 335 - struct ath_common *common = from_timer(common, t, ani.timer); 335 335 + struct ath_common *common = timer_container_of(common, t, ani.timer); 336 336 struct ath_softc *sc = common->priv; 337 337 struct ath_hw *ah = sc->sc_ah; 338 338 bool longcal = false;

+1 -1

drivers/net/wireless/ath/ath9k/main.c

reviewed

··· 98 98 99 99 void ath_ps_full_sleep(struct timer_list *t) 100 100 { 101 101 - struct ath_softc *sc = from_timer(sc, t, sleep_timer); 101 101 + struct ath_softc *sc = timer_container_of(sc, t, sleep_timer); 102 102 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 103 103 unsigned long flags; 104 104 bool reset;

+1 -1

drivers/net/wireless/ath/wcn36xx/dxe.c

reviewed

··· 373 373 374 374 static void wcn36xx_dxe_tx_timer(struct timer_list *t) 375 375 { 376 376 - struct wcn36xx *wcn = from_timer(wcn, t, tx_ack_timer); 376 376 + struct wcn36xx *wcn = timer_container_of(wcn, t, tx_ack_timer); 377 377 struct ieee80211_tx_info *info; 378 378 unsigned long flags; 379 379 struct sk_buff *skb;

+4 -3

drivers/net/wireless/ath/wil6210/netdev.c

reviewed

··· 227 227 228 228 static void wil_connect_timer_fn(struct timer_list *t) 229 229 { 230 230 - struct wil6210_vif *vif = from_timer(vif, t, connect_timer); 230 230 + struct wil6210_vif *vif = timer_container_of(vif, t, connect_timer); 231 231 struct wil6210_priv *wil = vif_to_wil(vif); 232 232 bool q; 233 233 ··· 243 243 244 244 static void wil_scan_timer_fn(struct timer_list *t) 245 245 { 246 246 - struct wil6210_vif *vif = from_timer(vif, t, scan_timer); 246 246 + struct wil6210_vif *vif = timer_container_of(vif, t, scan_timer); 247 247 struct wil6210_priv *wil = vif_to_wil(vif); 248 248 249 249 clear_bit(wil_status_fwready, wil->status); ··· 253 253 254 254 static void wil_p2p_discovery_timer_fn(struct timer_list *t) 255 255 { 256 256 - struct wil6210_vif *vif = from_timer(vif, t, p2p.discovery_timer); 256 256 + struct wil6210_vif *vif = timer_container_of(vif, t, 257 257 + p2p.discovery_timer); 257 258 struct wil6210_priv *wil = vif_to_wil(vif); 258 259 259 260 wil_dbg_misc(wil, "p2p_discovery_timer_fn\n");

+2 -1

drivers/net/wireless/broadcom/brcm80211/brcmfmac/btcoex.c

reviewed

··· 272 272 */ 273 273 static void brcmf_btcoex_timerfunc(struct timer_list *t) 274 274 { 275 275 - struct brcmf_btcoex_info *bt_local = from_timer(bt_local, t, timer); 275 275 + struct brcmf_btcoex_info *bt_local = timer_container_of(bt_local, t, 276 276 + timer); 276 277 brcmf_dbg(TRACE, "enter\n"); 277 278 278 279 bt_local->timer_on = false;

+1 -1

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

reviewed

··· 3557 3557 static void brcmf_escan_timeout(struct timer_list *t) 3558 3558 { 3559 3559 struct brcmf_cfg80211_info *cfg = 3560 3560 - from_timer(cfg, t, escan_timeout); 3560 3560 + timer_container_of(cfg, t, escan_timeout); 3561 3561 struct brcmf_pub *drvr = cfg->pub; 3562 3562 3563 3563 if (cfg->int_escan_map || cfg->scan_request) {

+2 -1

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

reviewed

··· 2328 2328 static void 2329 2329 brcmf_pcie_fwcon(struct timer_list *t) 2330 2330 { 2331 2331 - struct brcmf_pciedev_info *devinfo = from_timer(devinfo, t, timer); 2331 2331 + struct brcmf_pciedev_info *devinfo = timer_container_of(devinfo, t, 2332 2332 + timer); 2332 2333 2333 2334 if (!devinfo->console_active) 2334 2335 return;

+1 -1

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

reviewed

··· 4121 4121 static void 4122 4122 brcmf_sdio_watchdog(struct timer_list *t) 4123 4123 { 4124 4124 - struct brcmf_sdio *bus = from_timer(bus, t, timer); 4124 4124 + struct brcmf_sdio *bus = timer_container_of(bus, t, timer); 4125 4125 4126 4126 if (bus->watchdog_tsk) { 4127 4127 complete(&bus->watchdog_wait);

+2 -2

drivers/net/wireless/intel/ipw2x00/libipw_crypto.c

reviewed

··· 110 110 111 111 static void libipw_crypt_deinit_handler(struct timer_list *t) 112 112 { 113 113 - struct libipw_crypt_info *info = from_timer(info, t, 114 114 - crypt_deinit_timer); 113 113 + struct libipw_crypt_info *info = timer_container_of(info, t, 114 114 + crypt_deinit_timer); 115 115 unsigned long flags; 116 116 117 117 libipw_crypt_deinit_entries(info, 0);

+2 -1

drivers/net/wireless/intel/iwlegacy/3945-rs.c

reviewed

··· 168 168 static void 169 169 il3945_bg_rate_scale_flush(struct timer_list *t) 170 170 { 171 171 - struct il3945_rs_sta *rs_sta = from_timer(rs_sta, t, rate_scale_flush); 171 171 + struct il3945_rs_sta *rs_sta = timer_container_of(rs_sta, t, 172 172 + rate_scale_flush); 172 173 struct il_priv *il __maybe_unused = rs_sta->il; 173 174 int unflushed = 0; 174 175 unsigned long flags;

+1 -1

drivers/net/wireless/intel/iwlegacy/4965-mac.c

reviewed

··· 4051 4051 static void 4052 4052 il4965_bg_stats_periodic(struct timer_list *t) 4053 4053 { 4054 4054 - struct il_priv *il = from_timer(il, t, stats_periodic); 4054 4054 + struct il_priv *il = timer_container_of(il, t, stats_periodic); 4055 4055 4056 4056 if (test_bit(S_EXIT_PENDING, &il->status)) 4057 4057 return;

+1 -1

drivers/net/wireless/intel/iwlegacy/common.c

reviewed

··· 4804 4804 void 4805 4805 il_bg_watchdog(struct timer_list *t) 4806 4806 { 4807 4807 - struct il_priv *il = from_timer(il, t, watchdog); 4807 4807 + struct il_priv *il = timer_container_of(il, t, watchdog); 4808 4808 int cnt; 4809 4809 unsigned long timeout; 4810 4810

+3 -2

drivers/net/wireless/intel/iwlwifi/dvm/main.c

reviewed

··· 381 381 */ 382 382 static void iwl_bg_statistics_periodic(struct timer_list *t) 383 383 { 384 384 - struct iwl_priv *priv = from_timer(priv, t, statistics_periodic); 384 384 + struct iwl_priv *priv = timer_container_of(priv, t, 385 385 + statistics_periodic); 385 386 386 387 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) 387 388 return; ··· 538 537 */ 539 538 static void iwl_bg_ucode_trace(struct timer_list *t) 540 539 { 541 541 - struct iwl_priv *priv = from_timer(priv, t, ucode_trace); 540 540 + struct iwl_priv *priv = timer_container_of(priv, t, ucode_trace); 542 541 543 542 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) 544 543 return;

+4 -4

drivers/net/wireless/intel/iwlwifi/dvm/tt.c

reviewed

··· 137 137 */ 138 138 static void iwl_tt_check_exit_ct_kill(struct timer_list *t) 139 139 { 140 140 - struct iwl_priv *priv = from_timer(priv, t, 141 141 - thermal_throttle.ct_kill_exit_tm); 140 140 + struct iwl_priv *priv = timer_container_of(priv, t, 141 141 + thermal_throttle.ct_kill_exit_tm); 142 142 struct iwl_tt_mgmt *tt = &priv->thermal_throttle; 143 143 144 144 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) ··· 187 187 188 188 static void iwl_tt_ready_for_ct_kill(struct timer_list *t) 189 189 { 190 190 - struct iwl_priv *priv = from_timer(priv, t, 191 191 - thermal_throttle.ct_kill_waiting_tm); 190 190 + struct iwl_priv *priv = timer_container_of(priv, t, 191 191 + thermal_throttle.ct_kill_waiting_tm); 192 192 struct iwl_tt_mgmt *tt = &priv->thermal_throttle; 193 193 194 194 if (test_bit(STATUS_EXIT_PENDING, &priv->status))

+1 -1

drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c

reviewed

··· 949 949 static void iwl_dbg_tlv_periodic_trig_handler(struct timer_list *t) 950 950 { 951 951 struct iwl_dbg_tlv_timer_node *timer_node = 952 952 - from_timer(timer_node, t, timer); 952 952 + timer_container_of(timer_node, t, timer); 953 953 struct iwl_fwrt_dump_data dump_data = { 954 954 .trig = (void *)timer_node->tlv->data, 955 955 };

+1 -1

drivers/net/wireless/intel/iwlwifi/mld/agg.c

reviewed

··· 317 317 static void iwl_mld_rx_agg_session_expired(struct timer_list *t) 318 318 { 319 319 struct iwl_mld_baid_data *data = 320 320 - from_timer(data, t, session_timer); 320 320 + timer_container_of(data, t, session_timer); 321 321 struct iwl_mld_baid_data __rcu **rcu_ptr = data->rcu_ptr; 322 322 struct iwl_mld_baid_data *ba_data; 323 323 struct ieee80211_link_sta *link_sta;

+1 -1

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

reviewed

··· 253 253 static void iwl_mvm_rx_agg_session_expired(struct timer_list *t) 254 254 { 255 255 struct iwl_mvm_baid_data *data = 256 256 - from_timer(data, t, session_timer); 256 256 + timer_container_of(data, t, session_timer); 257 257 struct iwl_mvm_baid_data __rcu **rcu_ptr = data->rcu_ptr; 258 258 struct iwl_mvm_baid_data *ba_data; 259 259 struct ieee80211_sta *sta;

+1 -1

drivers/net/wireless/intel/iwlwifi/pcie/tx.c

reviewed

··· 700 700 701 701 static void iwl_txq_stuck_timer(struct timer_list *t) 702 702 { 703 703 - struct iwl_txq *txq = from_timer(txq, t, stuck_timer); 703 703 + struct iwl_txq *txq = timer_container_of(txq, t, stuck_timer); 704 704 struct iwl_trans *trans = txq->trans; 705 705 706 706 spin_lock(&txq->lock);

+1 -1

drivers/net/wireless/marvell/libertas/if_usb.c

reviewed

··· 165 165 166 166 static void if_usb_fw_timeo(struct timer_list *t) 167 167 { 168 168 - struct if_usb_card *cardp = from_timer(cardp, t, fw_timeout); 168 168 + struct if_usb_card *cardp = timer_container_of(cardp, t, fw_timeout); 169 169 170 170 if (cardp->fwdnldover) { 171 171 lbs_deb_usb("Download complete, no event. Assuming success\n");

+3 -2

drivers/net/wireless/marvell/libertas/main.c

reviewed

··· 693 693 */ 694 694 static void lbs_cmd_timeout_handler(struct timer_list *t) 695 695 { 696 696 - struct lbs_private *priv = from_timer(priv, t, command_timer); 696 696 + struct lbs_private *priv = timer_container_of(priv, t, command_timer); 697 697 unsigned long flags; 698 698 699 699 spin_lock_irqsave(&priv->driver_lock, flags); ··· 727 727 */ 728 728 static void lbs_tx_lockup_handler(struct timer_list *t) 729 729 { 730 730 - struct lbs_private *priv = from_timer(priv, t, tx_lockup_timer); 730 730 + struct lbs_private *priv = timer_container_of(priv, t, 731 731 + tx_lockup_timer); 731 732 unsigned long flags; 732 733 733 734 spin_lock_irqsave(&priv->driver_lock, flags);

+1 -1

drivers/net/wireless/marvell/libertas_tf/if_usb.c

reviewed

··· 113 113 114 114 static void if_usb_fw_timeo(struct timer_list *t) 115 115 { 116 116 - struct if_usb_card *cardp = from_timer(cardp, t, fw_timeout); 116 116 + struct if_usb_card *cardp = timer_container_of(cardp, t, fw_timeout); 117 117 118 118 lbtf_deb_enter(LBTF_DEB_USB); 119 119 if (!cardp->fwdnldover) {

+1 -1

drivers/net/wireless/marvell/libertas_tf/main.c

reviewed

··· 126 126 */ 127 127 static void command_timer_fn(struct timer_list *t) 128 128 { 129 129 - struct lbtf_private *priv = from_timer(priv, t, command_timer); 129 129 + struct lbtf_private *priv = timer_container_of(priv, t, command_timer); 130 130 unsigned long flags; 131 131 lbtf_deb_enter(LBTF_DEB_CMD); 132 132

+1 -1

drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c

reviewed

··· 300 300 mwifiex_flush_data(struct timer_list *t) 301 301 { 302 302 struct reorder_tmr_cnxt *ctx = 303 303 - from_timer(ctx, t, timer); 303 303 + timer_container_of(ctx, t, timer); 304 304 int start_win, seq_num; 305 305 306 306 ctx->timer_is_set = false;

+2 -1

drivers/net/wireless/marvell/mwifiex/cmdevt.c

reviewed

··· 934 934 void 935 935 mwifiex_cmd_timeout_func(struct timer_list *t) 936 936 { 937 937 - struct mwifiex_adapter *adapter = from_timer(adapter, t, cmd_timer); 937 937 + struct mwifiex_adapter *adapter = timer_container_of(adapter, t, 938 938 + cmd_timer); 938 939 struct cmd_ctrl_node *cmd_node; 939 940 940 941 set_bit(MWIFIEX_IS_CMD_TIMEDOUT, &adapter->work_flags);

+2 -1

drivers/net/wireless/marvell/mwifiex/init.c

reviewed

··· 41 41 42 42 static void wakeup_timer_fn(struct timer_list *t) 43 43 { 44 44 - struct mwifiex_adapter *adapter = from_timer(adapter, t, wakeup_timer); 44 44 + struct mwifiex_adapter *adapter = timer_container_of(adapter, t, 45 45 + wakeup_timer); 45 46 46 47 mwifiex_dbg(adapter, ERROR, "Firmware wakeup failed\n"); 47 48 adapter->hw_status = MWIFIEX_HW_STATUS_RESET;

+2 -1

drivers/net/wireless/marvell/mwifiex/tdls.c

reviewed

··· 1415 1415 1416 1416 void mwifiex_check_auto_tdls(struct timer_list *t) 1417 1417 { 1418 1418 - struct mwifiex_private *priv = from_timer(priv, t, auto_tdls_timer); 1418 1418 + struct mwifiex_private *priv = timer_container_of(priv, t, 1419 1419 + auto_tdls_timer); 1419 1420 struct mwifiex_auto_tdls_peer *tdls_peer; 1420 1421 u16 reason = WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED; 1421 1422

+1 -1

drivers/net/wireless/marvell/mwifiex/usb.c

reviewed

··· 1125 1125 struct urb_context *urb_cnxt = NULL; 1126 1126 struct sk_buff *skb_send = NULL; 1127 1127 struct tx_aggr_tmr_cnxt *timer_context = 1128 1128 - from_timer(timer_context, t, hold_timer); 1128 1128 + timer_container_of(timer_context, t, hold_timer); 1129 1129 struct mwifiex_adapter *adapter = timer_context->adapter; 1130 1130 struct usb_tx_data_port *port = timer_context->port; 1131 1131 int err = 0;

+1 -1

drivers/net/wireless/mediatek/mt76/mt7615/main.c

reviewed

··· 1043 1043 1044 1044 void mt7615_roc_timer(struct timer_list *timer) 1045 1045 { 1046 1046 - struct mt7615_phy *phy = from_timer(phy, timer, roc_timer); 1046 1046 + struct mt7615_phy *phy = timer_container_of(phy, timer, roc_timer); 1047 1047 1048 1048 ieee80211_queue_work(phy->mt76->hw, &phy->roc_work); 1049 1049 }

+2 -2

drivers/net/wireless/mediatek/mt76/mt792x_core.c

reviewed

··· 283 283 284 284 void mt792x_roc_timer(struct timer_list *timer) 285 285 { 286 286 - struct mt792x_phy *phy = from_timer(phy, timer, roc_timer); 286 286 + struct mt792x_phy *phy = timer_container_of(phy, timer, roc_timer); 287 287 288 288 ieee80211_queue_work(phy->mt76->hw, &phy->roc_work); 289 289 } ··· 291 291 292 292 void mt792x_csa_timer(struct timer_list *timer) 293 293 { 294 294 - struct mt792x_vif *mvif = from_timer(mvif, timer, csa_timer); 294 294 + struct mt792x_vif *mvif = timer_container_of(mvif, timer, csa_timer); 295 295 296 296 ieee80211_queue_work(mvif->phy->mt76->hw, &mvif->csa_work); 297 297 }

+7 -6

drivers/net/wireless/microchip/wilc1000/hif.c

reviewed

··· 953 953 954 954 static void listen_timer_cb(struct timer_list *t) 955 955 { 956 956 - struct host_if_drv *hif_drv = from_timer(hif_drv, t, 957 957 - remain_on_ch_timer); 956 956 + struct host_if_drv *hif_drv = timer_container_of(hif_drv, t, 957 957 + remain_on_ch_timer); 958 958 struct wilc_vif *vif = hif_drv->remain_on_ch_timer_vif; 959 959 int result; 960 960 struct host_if_msg *msg; ··· 1075 1075 1076 1076 static void timer_scan_cb(struct timer_list *t) 1077 1077 { 1078 1078 - struct host_if_drv *hif_drv = from_timer(hif_drv, t, scan_timer); 1078 1078 + struct host_if_drv *hif_drv = timer_container_of(hif_drv, t, 1079 1079 + scan_timer); 1079 1080 struct wilc_vif *vif = hif_drv->scan_timer_vif; 1080 1081 struct host_if_msg *msg; 1081 1082 int result; ··· 1092 1091 1093 1092 static void timer_connect_cb(struct timer_list *t) 1094 1093 { 1095 1095 - struct host_if_drv *hif_drv = from_timer(hif_drv, t, 1096 1096 - connect_timer); 1094 1094 + struct host_if_drv *hif_drv = timer_container_of(hif_drv, t, 1095 1095 + connect_timer); 1097 1096 struct wilc_vif *vif = hif_drv->connect_timer_vif; 1098 1097 struct host_if_msg *msg; 1099 1098 int result; ··· 1498 1497 1499 1498 static void get_periodic_rssi(struct timer_list *t) 1500 1499 { 1501 1501 - struct wilc_vif *vif = from_timer(vif, t, periodic_rssi); 1500 1500 + struct wilc_vif *vif = timer_container_of(vif, t, periodic_rssi); 1502 1501 1503 1502 if (!vif->hif_drv) { 1504 1503 netdev_err(vif->ndev, "%s: hif driver is NULL", __func__);

+2 -2

drivers/net/wireless/purelifi/plfxlc/usb.c

reviewed

··· 548 548 549 549 static void slif_data_plane_sap_timer_callb(struct timer_list *t) 550 550 { 551 551 - struct plfxlc_usb *usb = from_timer(usb, t, tx.tx_retry_timer); 551 551 + struct plfxlc_usb *usb = timer_container_of(usb, t, tx.tx_retry_timer); 552 552 553 553 plfxlc_send_packet_from_data_queue(usb); 554 554 timer_setup(&usb->tx.tx_retry_timer, ··· 558 558 559 559 static void sta_queue_cleanup_timer_callb(struct timer_list *t) 560 560 { 561 561 - struct plfxlc_usb *usb = from_timer(usb, t, sta_queue_cleanup); 561 561 + struct plfxlc_usb *usb = timer_container_of(usb, t, sta_queue_cleanup); 562 562 struct plfxlc_usb_tx *tx = &usb->tx; 563 563 int sidx; 564 564

+2 -1

drivers/net/wireless/realtek/rtlwifi/base.c

reviewed

··· 2220 2220 2221 2221 void rtl_watch_dog_timer_callback(struct timer_list *t) 2222 2222 { 2223 2223 - struct rtl_priv *rtlpriv = from_timer(rtlpriv, t, works.watchdog_timer); 2223 2223 + struct rtl_priv *rtlpriv = timer_container_of(rtlpriv, t, 2224 2224 + works.watchdog_timer); 2224 2225 2225 2226 queue_delayed_work(rtlpriv->works.rtl_wq, 2226 2227 &rtlpriv->works.watchdog_wq, 0);

+2 -1

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/dm.c

reviewed

··· 1684 1684 void rtl88e_dm_fast_antenna_training_callback(struct timer_list *t) 1685 1685 { 1686 1686 struct rtl_priv *rtlpriv = 1687 1687 - from_timer(rtlpriv, t, works.fast_antenna_training_timer); 1687 1687 + timer_container_of(rtlpriv, t, 1688 1688 + works.fast_antenna_training_timer); 1688 1689 struct ieee80211_hw *hw = rtlpriv->hw; 1689 1690 1690 1691 rtl88e_dm_fast_ant_training(hw);

+2 -2

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/hw.c

reviewed

··· 237 237 238 238 void rtl88ee_fw_clk_off_timer_callback(struct timer_list *t) 239 239 { 240 240 - struct rtl_priv *rtlpriv = from_timer(rtlpriv, t, 241 241 - works.fw_clockoff_timer); 240 240 + struct rtl_priv *rtlpriv = timer_container_of(rtlpriv, t, 241 241 + works.fw_clockoff_timer); 242 242 struct ieee80211_hw *hw = rtlpriv->hw; 243 243 244 244 _rtl88ee_set_fw_ps_rf_off_low_power(hw);

+2 -1

drivers/net/wireless/realtek/rtw88/tx.c

reviewed

··· 178 178 179 179 void rtw_tx_report_purge_timer(struct timer_list *t) 180 180 { 181 181 - struct rtw_dev *rtwdev = from_timer(rtwdev, t, tx_report.purge_timer); 181 181 + struct rtw_dev *rtwdev = timer_container_of(rtwdev, t, 182 182 + tx_report.purge_timer); 182 183 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 183 184 unsigned long flags; 184 185

+1 -1

drivers/net/wireless/rsi/rsi_91x_hal.c

reviewed

··· 490 490 491 491 static void bl_cmd_timeout(struct timer_list *t) 492 492 { 493 493 - struct rsi_hw *adapter = from_timer(adapter, t, bl_cmd_timer); 493 493 + struct rsi_hw *adapter = timer_container_of(adapter, t, bl_cmd_timer); 494 494 495 495 adapter->blcmd_timer_expired = true; 496 496 timer_delete(&adapter->bl_cmd_timer);

+1 -1

drivers/net/wireless/rsi/rsi_91x_mac80211.c

reviewed

··· 1746 1746 1747 1747 void rsi_roc_timeout(struct timer_list *t) 1748 1748 { 1749 1749 - struct rsi_common *common = from_timer(common, t, roc_timer); 1749 1749 + struct rsi_common *common = timer_container_of(common, t, roc_timer); 1750 1750 1751 1751 rsi_dbg(INFO_ZONE, "Remain on channel expired\n"); 1752 1752

+1 -1

drivers/net/wireless/st/cw1200/queue.c

reviewed

··· 133 133 { 134 134 LIST_HEAD(list); 135 135 struct cw1200_queue *queue = 136 136 - from_timer(queue, t, gc); 136 136 + timer_container_of(queue, t, gc); 137 137 138 138 spin_lock_bh(&queue->lock); 139 139 __cw1200_queue_gc(queue, &list, true);

+2 -1

drivers/net/wireless/st/cw1200/sta.c

reviewed

··· 2112 2112 2113 2113 void cw1200_mcast_timeout(struct timer_list *t) 2114 2114 { 2115 2115 - struct cw1200_common *priv = from_timer(priv, t, mcast_timeout); 2115 2115 + struct cw1200_common *priv = timer_container_of(priv, t, 2116 2116 + mcast_timeout); 2116 2117 2117 2118 wiphy_warn(priv->hw->wiphy, 2118 2119 "Multicast delivery timeout.\n");

+2 -1

drivers/net/wireless/ti/wlcore/main.c

reviewed

··· 189 189 190 190 static void wl1271_rx_streaming_timer(struct timer_list *t) 191 191 { 192 192 - struct wl12xx_vif *wlvif = from_timer(wlvif, t, rx_streaming_timer); 192 192 + struct wl12xx_vif *wlvif = timer_container_of(wlvif, t, 193 193 + rx_streaming_timer); 193 194 struct wl1271 *wl = wlvif->wl; 194 195 ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work); 195 196 }

+2 -1

drivers/net/xen-netback/netback.c

reviewed

··· 198 198 199 199 void xenvif_tx_credit_callback(struct timer_list *t) 200 200 { 201 201 - struct xenvif_queue *queue = from_timer(queue, t, credit_timeout); 201 201 + struct xenvif_queue *queue = timer_container_of(queue, t, 202 202 + credit_timeout); 202 203 tx_add_credit(queue); 203 204 xenvif_napi_schedule_or_enable_events(queue); 204 205 }

+2 -1

drivers/net/xen-netfront.c

reviewed

··· 245 245 246 246 static void rx_refill_timeout(struct timer_list *t) 247 247 { 248 248 - struct netfront_queue *queue = from_timer(queue, t, rx_refill_timer); 248 248 + struct netfront_queue *queue = timer_container_of(queue, t, 249 249 + rx_refill_timer); 249 250 napi_schedule(&queue->napi); 250 251 } 251 252

+2 -1

drivers/nfc/nfcmrvl/fw_dnld.c

reviewed

··· 119 119 120 120 static void fw_dnld_timeout(struct timer_list *t) 121 121 { 122 122 - struct nfcmrvl_private *priv = from_timer(priv, t, fw_dnld.timer); 122 122 + struct nfcmrvl_private *priv = timer_container_of(priv, t, 123 123 + fw_dnld.timer); 123 124 124 125 nfc_err(priv->dev, "FW loading timeout"); 125 126 priv->fw_dnld.state = STATE_RESET;

+1 -1

drivers/nfc/pn533/pn533.c

reviewed

··· 1233 1233 1234 1234 static void pn533_listen_mode_timer(struct timer_list *t) 1235 1235 { 1236 1236 - struct pn533 *dev = from_timer(dev, t, listen_timer); 1236 1236 + struct pn533 *dev = timer_container_of(dev, t, listen_timer); 1237 1237 1238 1238 dev->cancel_listen = 1; 1239 1239

+1 -1

drivers/nfc/pn533/uart.c

reviewed

··· 133 133 134 134 static void pn532_cmd_timeout(struct timer_list *t) 135 135 { 136 136 - struct pn532_uart_phy *dev = from_timer(dev, t, cmd_timeout); 136 136 + struct pn532_uart_phy *dev = timer_container_of(dev, t, cmd_timeout); 137 137 138 138 pn532_uart_send_frame(dev->priv, dev->cur_out_buf); 139 139 }

+2 -2

drivers/nfc/st-nci/ndlc.c

reviewed

··· 237 237 238 238 static void ndlc_t1_timeout(struct timer_list *t) 239 239 { 240 240 - struct llt_ndlc *ndlc = from_timer(ndlc, t, t1_timer); 240 240 + struct llt_ndlc *ndlc = timer_container_of(ndlc, t, t1_timer); 241 241 242 242 schedule_work(&ndlc->sm_work); 243 243 } 244 244 245 245 static void ndlc_t2_timeout(struct timer_list *t) 246 246 { 247 247 - struct llt_ndlc *ndlc = from_timer(ndlc, t, t2_timer); 247 247 + struct llt_ndlc *ndlc = timer_container_of(ndlc, t, t2_timer); 248 248 249 249 schedule_work(&ndlc->sm_work); 250 250 }

+4 -3

drivers/nfc/st-nci/se.c

reviewed

··· 696 696 */ 697 697 /* hardware reset managed through VCC_UICC_OUT power supply */ 698 698 u8 param = 0x01; 699 699 - struct st_nci_info *info = from_timer(info, t, se_info.bwi_timer); 699 699 + struct st_nci_info *info = timer_container_of(info, t, 700 700 + se_info.bwi_timer); 700 701 701 702 info->se_info.bwi_active = false; 702 703 ··· 715 714 716 715 static void st_nci_se_activation_timeout(struct timer_list *t) 717 716 { 718 718 - struct st_nci_info *info = from_timer(info, t, 719 719 - se_info.se_active_timer); 717 717 + struct st_nci_info *info = timer_container_of(info, t, 718 718 + se_info.se_active_timer); 720 719 721 720 info->se_info.se_active = false; 722 721

+4 -3

drivers/nfc/st21nfca/se.c

reviewed

··· 280 280 281 281 static void st21nfca_se_wt_timeout(struct timer_list *t) 282 282 { 283 283 - struct st21nfca_hci_info *info = from_timer(info, t, se_info.bwi_timer); 283 283 + struct st21nfca_hci_info *info = timer_container_of(info, t, 284 284 + se_info.bwi_timer); 284 285 285 286 schedule_work(&info->se_info.timeout_work); 286 287 } 287 288 288 289 static void st21nfca_se_activation_timeout(struct timer_list *t) 289 290 { 290 290 - struct st21nfca_hci_info *info = from_timer(info, t, 291 291 - se_info.se_active_timer); 291 291 + struct st21nfca_hci_info *info = timer_container_of(info, t, 292 292 + se_info.se_active_timer); 292 293 293 294 info->se_info.se_active = false; 294 295

+1 -1

drivers/nvme/host/multipath.c

reviewed

··· 998 998 999 999 static void nvme_anatt_timeout(struct timer_list *t) 1000 1000 { 1001 1001 - struct nvme_ctrl *ctrl = from_timer(ctrl, t, anatt_timer); 1001 1001 + struct nvme_ctrl *ctrl = timer_container_of(ctrl, t, anatt_timer); 1002 1002 1003 1003 dev_info(ctrl->device, "ANATT timeout, resetting controller.\n"); 1004 1004 nvme_reset_ctrl(ctrl);

+1 -1

drivers/parport/ieee1284.c

reviewed

··· 40 40 41 41 static void timeout_waiting_on_port (struct timer_list *t) 42 42 { 43 43 - struct parport *port = from_timer(port, t, timer); 43 43 + struct parport *port = timer_container_of(port, t, timer); 44 44 45 45 parport_ieee1284_wakeup (port); 46 46 }

+1 -1

drivers/pci/hotplug/cpqphp_ctrl.c

reviewed

··· 1883 1883 { 1884 1884 u8 hp_slot; 1885 1885 struct pci_func *func; 1886 1886 - struct slot *p_slot = from_timer(p_slot, t, task_event); 1886 1886 + struct slot *p_slot = timer_container_of(p_slot, t, task_event); 1887 1887 struct controller *ctrl = (struct controller *) p_slot->ctrl; 1888 1888 1889 1889 pushbutton_pending = NULL;

+1 -1

drivers/pci/hotplug/shpchp_hpc.c

reviewed

··· 211 211 */ 212 212 static void int_poll_timeout(struct timer_list *t) 213 213 { 214 214 - struct controller *ctrl = from_timer(ctrl, t, poll_timer); 214 214 + struct controller *ctrl = timer_container_of(ctrl, t, poll_timer); 215 215 216 216 /* Poll for interrupt events. regs == NULL => polling */ 217 217 shpc_isr(0, ctrl);

+1 -1

drivers/pcmcia/bcm63xx_pcmcia.c

reviewed

··· 268 268 struct bcm63xx_pcmcia_socket *skt; 269 269 unsigned int stat, events; 270 270 271 271 - skt = from_timer(skt, t, timer); 271 271 + skt = timer_container_of(skt, t, timer); 272 272 273 273 spin_lock_bh(&skt->lock); 274 274

+1 -1

drivers/pcmcia/electra_cf.c

reviewed

··· 68 68 /* the timer is primarily to kick this socket's pccardd */ 69 69 static void electra_cf_timer(struct timer_list *t) 70 70 { 71 71 - struct electra_cf_socket *cf = from_timer(cf, t, timer); 71 71 + struct electra_cf_socket *cf = timer_container_of(cf, t, timer); 72 72 int present = electra_cf_present(cf); 73 73 74 74 if (present != cf->present) {

+1 -1

drivers/pcmcia/omap_cf.c

reviewed

··· 77 77 /* the timer is primarily to kick this socket's pccardd */ 78 78 static void omap_cf_timer(struct timer_list *t) 79 79 { 80 80 - struct omap_cf_socket *cf = from_timer(cf, t, timer); 80 80 + struct omap_cf_socket *cf = timer_container_of(cf, t, timer); 81 81 unsigned present = omap_cf_present(); 82 82 83 83 if (present != cf->present) {

+2 -1

drivers/pcmcia/pd6729.c

reviewed

··· 236 236 237 237 static void pd6729_interrupt_wrapper(struct timer_list *t) 238 238 { 239 239 - struct pd6729_socket *socket = from_timer(socket, t, poll_timer); 239 239 + struct pd6729_socket *socket = timer_container_of(socket, t, 240 240 + poll_timer); 240 241 241 242 pd6729_interrupt(0, (void *)socket); 242 243 mod_timer(&socket->poll_timer, jiffies + HZ);

+1 -1

drivers/pcmcia/soc_common.c

reviewed

··· 460 460 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */ 461 461 static void soc_common_pcmcia_poll_event(struct timer_list *t) 462 462 { 463 463 - struct soc_pcmcia_socket *skt = from_timer(skt, t, poll_timer); 463 463 + struct soc_pcmcia_socket *skt = timer_container_of(skt, t, poll_timer); 464 464 debug(skt, 4, "polling for events\n"); 465 465 466 466 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);

+2 -1

drivers/pcmcia/yenta_socket.c

reviewed

··· 539 539 540 540 static void yenta_interrupt_wrapper(struct timer_list *t) 541 541 { 542 542 - struct yenta_socket *socket = from_timer(socket, t, poll_timer); 542 542 + struct yenta_socket *socket = timer_container_of(socket, t, 543 543 + poll_timer); 543 544 544 545 yenta_interrupt(0, (void *)socket); 545 546 socket->poll_timer.expires = jiffies + HZ;

+1 -1

drivers/platform/x86/intel_ips.c

reviewed

··· 934 934 935 935 static void monitor_timeout(struct timer_list *t) 936 936 { 937 937 - struct ips_driver *ips = from_timer(ips, t, timer); 937 937 + struct ips_driver *ips = timer_container_of(ips, t, timer); 938 938 wake_up_process(ips->monitor); 939 939 } 940 940

+1 -1

drivers/pps/clients/pps-gpio.c

reviewed

··· 98 98 { 99 99 const struct pps_gpio_device_data *info; 100 100 101 101 - info = from_timer(info, t, echo_timer); 101 101 + info = timer_container_of(info, t, echo_timer); 102 102 103 103 gpiod_set_value(info->echo_pin, 0); 104 104 }

+1 -1

drivers/ptp/ptp_ocp.c

reviewed

··· 1526 1526 static void 1527 1527 ptp_ocp_watchdog(struct timer_list *t) 1528 1528 { 1529 1529 - struct ptp_ocp *bp = from_timer(bp, t, watchdog); 1529 1529 + struct ptp_ocp *bp = timer_container_of(bp, t, watchdog); 1530 1530 unsigned long flags; 1531 1531 u32 status, utc_offset; 1532 1532

+1 -1

drivers/rtc/dev.c

reviewed

··· 72 72 73 73 static void rtc_uie_timer(struct timer_list *t) 74 74 { 75 75 - struct rtc_device *rtc = from_timer(rtc, t, uie_timer); 75 75 + struct rtc_device *rtc = timer_container_of(rtc, t, uie_timer); 76 76 unsigned long flags; 77 77 78 78 spin_lock_irqsave(&rtc->irq_lock, flags);

+1 -1

drivers/rtc/rtc-test.c

reviewed

··· 107 107 108 108 static void test_rtc_alarm_handler(struct timer_list *t) 109 109 { 110 110 - struct rtc_test_data *rtd = from_timer(rtd, t, alarm); 110 110 + struct rtc_test_data *rtd = timer_container_of(rtd, t, alarm); 111 111 112 112 rtc_update_irq(rtd->rtc, 1, RTC_AF | RTC_IRQF); 113 113 }

+2 -2

drivers/s390/block/dasd.c

reviewed

··· 1493 1493 unsigned long flags; 1494 1494 struct dasd_device *device; 1495 1495 1496 1496 - device = from_timer(device, t, timer); 1496 1496 + device = timer_container_of(device, t, timer); 1497 1497 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1498 1498 /* re-activate request queue */ 1499 1499 dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING); ··· 2677 2677 unsigned long flags; 2678 2678 struct dasd_block *block; 2679 2679 2680 2680 - block = from_timer(block, t, timer); 2680 2680 + block = timer_container_of(block, t, timer); 2681 2681 spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags); 2682 2682 /* re-activate request queue */ 2683 2683 dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING);

+1 -1

drivers/s390/char/con3215.c

reviewed

··· 284 284 */ 285 285 static void raw3215_timeout(struct timer_list *t) 286 286 { 287 287 - struct raw3215_info *raw = from_timer(raw, t, timer); 287 287 + struct raw3215_info *raw = timer_container_of(raw, t, timer); 288 288 unsigned long flags; 289 289 290 290 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);

+1 -1

drivers/s390/char/con3270.c

reviewed

··· 525 525 */ 526 526 static void tty3270_update(struct timer_list *t) 527 527 { 528 528 - struct tty3270 *tp = from_timer(tp, t, timer); 528 528 + struct tty3270 *tp = timer_container_of(tp, t, timer); 529 529 struct raw3270_request *wrq; 530 530 u8 cmd = TC_WRITE; 531 531 int rc, len;

+1 -1

drivers/s390/char/tape_core.c

reviewed

··· 821 821 822 822 static void tape_long_busy_timeout(struct timer_list *t) 823 823 { 824 824 - struct tape_device *device = from_timer(device, t, lb_timeout); 824 824 + struct tape_device *device = timer_container_of(device, t, lb_timeout); 825 825 struct tape_request *request; 826 826 827 827 spin_lock_irq(get_ccwdev_lock(device->cdev));

+2 -1

drivers/s390/char/tape_std.c

reviewed

··· 35 35 static void 36 36 tape_std_assign_timeout(struct timer_list *t) 37 37 { 38 38 - struct tape_request * request = from_timer(request, t, timer); 38 38 + struct tape_request * request = timer_container_of(request, t, 39 39 + timer); 39 40 struct tape_device * device = request->device; 40 41 int rc; 41 42

+1 -1

drivers/s390/cio/device_fsm.c

reviewed

··· 98 98 void 99 99 ccw_device_timeout(struct timer_list *t) 100 100 { 101 101 - struct ccw_device_private *priv = from_timer(priv, t, timer); 101 101 + struct ccw_device_private *priv = timer_container_of(priv, t, timer); 102 102 struct ccw_device *cdev = priv->cdev; 103 103 104 104 spin_lock_irq(cdev->ccwlock);

+1 -1

drivers/s390/cio/eadm_sch.c

reviewed

··· 98 98 99 99 static void eadm_subchannel_timeout(struct timer_list *t) 100 100 { 101 101 - struct eadm_private *private = from_timer(private, t, timer); 101 101 + struct eadm_private *private = timer_container_of(private, t, timer); 102 102 struct subchannel *sch = private->sch; 103 103 104 104 spin_lock_irq(&sch->lock);

+1 -1

drivers/s390/crypto/ap_bus.c

reviewed

··· 428 428 */ 429 429 void ap_request_timeout(struct timer_list *t) 430 430 { 431 431 - struct ap_queue *aq = from_timer(aq, t, timeout); 431 431 + struct ap_queue *aq = timer_container_of(aq, t, timeout); 432 432 433 433 spin_lock_bh(&aq->lock); 434 434 ap_wait(ap_sm_event(aq, AP_SM_EVENT_TIMEOUT));

+1 -1

drivers/s390/net/fsm.c

reviewed

··· 132 132 static void 133 133 fsm_expire_timer(struct timer_list *t) 134 134 { 135 135 - fsm_timer *this = from_timer(this, t, tl); 135 135 + fsm_timer *this = timer_container_of(this, t, tl); 136 136 #if FSM_TIMER_DEBUG 137 137 printk(KERN_DEBUG "fsm(%s): Timer %p expired\n", 138 138 this->fi->name, this);

+2 -1

drivers/s390/net/qeth_core_main.c

reviewed

··· 2619 2619 2620 2620 static void qeth_tx_completion_timer(struct timer_list *timer) 2621 2621 { 2622 2622 - struct qeth_qdio_out_q *queue = from_timer(queue, timer, timer); 2622 2622 + struct qeth_qdio_out_q *queue = timer_container_of(queue, timer, 2623 2623 + timer); 2623 2624 2624 2625 napi_schedule(&queue->napi); 2625 2626 QETH_TXQ_STAT_INC(queue, completion_timer);

+2 -2

drivers/s390/scsi/zfcp_erp.c

reviewed

··· 615 615 */ 616 616 void zfcp_erp_timeout_handler(struct timer_list *t) 617 617 { 618 618 - struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer); 618 618 + struct zfcp_fsf_req *fsf_req = timer_container_of(fsf_req, t, timer); 619 619 struct zfcp_erp_action *act; 620 620 621 621 if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) ··· 629 629 630 630 static void zfcp_erp_memwait_handler(struct timer_list *t) 631 631 { 632 632 - struct zfcp_erp_action *act = from_timer(act, t, timer); 632 632 + struct zfcp_erp_action *act = timer_container_of(act, t, timer); 633 633 634 634 zfcp_erp_notify(act, 0); 635 635 }

+1 -1

drivers/s390/scsi/zfcp_fsf.c

reviewed

··· 36 36 37 37 static void zfcp_fsf_request_timeout_handler(struct timer_list *t) 38 38 { 39 39 - struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer); 39 39 + struct zfcp_fsf_req *fsf_req = timer_container_of(fsf_req, t, timer); 40 40 struct zfcp_adapter *adapter = fsf_req->adapter; 41 41 42 42 zfcp_qdio_siosl(adapter);

+2 -1

drivers/s390/scsi/zfcp_qdio.c

reviewed

··· 102 102 103 103 static void zfcp_qdio_request_timer(struct timer_list *timer) 104 104 { 105 105 - struct zfcp_qdio *qdio = from_timer(qdio, timer, request_timer); 105 105 + struct zfcp_qdio *qdio = timer_container_of(qdio, timer, 106 106 + request_timer); 106 107 107 108 tasklet_schedule(&qdio->request_tasklet); 108 109 }

+1 -1

drivers/scsi/aic7xxx/aic79xx_core.c

reviewed

··· 8784 8784 static void 8785 8785 ahd_stat_timer(struct timer_list *t) 8786 8786 { 8787 8787 - struct ahd_softc *ahd = from_timer(ahd, t, stat_timer); 8787 8787 + struct ahd_softc *ahd = timer_container_of(ahd, t, stat_timer); 8788 8788 u_long s; 8789 8789 int enint_coal; 8790 8790

+1 -1

drivers/scsi/aic94xx/aic94xx_scb.c

reviewed

··· 862 862 */ 863 863 void asd_ascb_timedout(struct timer_list *t) 864 864 { 865 865 - struct asd_ascb *ascb = from_timer(ascb, t, timer); 865 865 + struct asd_ascb *ascb = timer_container_of(ascb, t, timer); 866 866 struct asd_seq_data *seq = &ascb->ha->seq; 867 867 unsigned long flags; 868 868

+2 -2

drivers/scsi/aic94xx/aic94xx_tmf.c

reviewed

··· 70 70 71 71 static void asd_clear_nexus_timedout(struct timer_list *t) 72 72 { 73 73 - struct asd_ascb *ascb = from_timer(ascb, t, timer); 73 73 + struct asd_ascb *ascb = timer_container_of(ascb, t, timer); 74 74 struct tasklet_completion_status *tcs = ascb->uldd_task; 75 75 76 76 ASD_DPRINTK("%s: here\n", __func__); ··· 244 244 245 245 static void asd_tmf_timedout(struct timer_list *t) 246 246 { 247 247 - struct asd_ascb *ascb = from_timer(ascb, t, timer); 247 247 + struct asd_ascb *ascb = timer_container_of(ascb, t, timer); 248 248 struct tasklet_completion_status *tcs = ascb->uldd_task; 249 249 250 250 ASD_DPRINTK("tmf timed out\n");

+4 -2

drivers/scsi/arcmsr/arcmsr_hba.c

reviewed

··· 3935 3935 3936 3936 static void arcmsr_set_iop_datetime(struct timer_list *t) 3937 3937 { 3938 3938 - struct AdapterControlBlock *pacb = from_timer(pacb, t, refresh_timer); 3938 3938 + struct AdapterControlBlock *pacb = timer_container_of(pacb, t, 3939 3939 + refresh_timer); 3939 3940 unsigned int next_time; 3940 3941 struct tm tm; 3941 3942 ··· 4264 4263 4265 4264 static void arcmsr_request_device_map(struct timer_list *t) 4266 4265 { 4267 4267 - struct AdapterControlBlock *acb = from_timer(acb, t, eternal_timer); 4266 4266 + struct AdapterControlBlock *acb = timer_container_of(acb, t, 4267 4267 + eternal_timer); 4268 4268 if (acb->acb_flags & (ACB_F_MSG_GET_CONFIG | ACB_F_BUS_RESET | ACB_F_ABORT)) { 4269 4269 mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ)); 4270 4270 } else {

+1 -1

drivers/scsi/arm/fas216.c

reviewed

··· 2327 2327 */ 2328 2328 static void fas216_eh_timer(struct timer_list *t) 2329 2329 { 2330 2330 - FAS216_Info *info = from_timer(info, t, eh_timer); 2330 2330 + FAS216_Info *info = timer_container_of(info, t, eh_timer); 2331 2331 2332 2332 fas216_log(info, LOG_ERROR, "error handling timed out\n"); 2333 2333

+2 -2

drivers/scsi/be2iscsi/be_main.c

reviewed

··· 5240 5240 5241 5241 static void beiscsi_hw_tpe_check(struct timer_list *t) 5242 5242 { 5243 5243 - struct beiscsi_hba *phba = from_timer(phba, t, hw_check); 5243 5243 + struct beiscsi_hba *phba = timer_container_of(phba, t, hw_check); 5244 5244 u32 wait; 5245 5245 5246 5246 /* if not TPE, do nothing */ ··· 5257 5257 5258 5258 static void beiscsi_hw_health_check(struct timer_list *t) 5259 5259 { 5260 5260 - struct beiscsi_hba *phba = from_timer(phba, t, hw_check); 5260 5260 + struct beiscsi_hba *phba = timer_container_of(phba, t, hw_check); 5261 5261 5262 5262 beiscsi_detect_ue(phba); 5263 5263 if (beiscsi_detect_ue(phba)) {

+2 -1

drivers/scsi/bfa/bfad.c

reviewed

··· 685 685 void 686 686 bfad_bfa_tmo(struct timer_list *t) 687 687 { 688 688 - struct bfad_s *bfad = from_timer(bfad, t, hal_tmo); 688 688 + struct bfad_s *bfad = timer_container_of(bfad, t, 689 689 + hal_tmo); 689 690 unsigned long flags; 690 691 struct list_head doneq; 691 692

+1 -1

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

reviewed

··· 837 837 838 838 static void bnx2fc_destroy_timer(struct timer_list *t) 839 839 { 840 840 - struct bnx2fc_hba *hba = from_timer(hba, t, destroy_timer); 840 840 + struct bnx2fc_hba *hba = timer_container_of(hba, t, destroy_timer); 841 841 842 842 printk(KERN_ERR PFX "ERROR:bnx2fc_destroy_timer - " 843 843 "Destroy compl not received!!\n");

+2 -2

drivers/scsi/bnx2fc/bnx2fc_tgt.c

reviewed

··· 30 30 static void bnx2fc_upld_timer(struct timer_list *t) 31 31 { 32 32 33 33 - struct bnx2fc_rport *tgt = from_timer(tgt, t, upld_timer); 33 33 + struct bnx2fc_rport *tgt = timer_container_of(tgt, t, upld_timer); 34 34 35 35 BNX2FC_TGT_DBG(tgt, "upld_timer - Upload compl not received!!\n"); 36 36 /* fake upload completion */ ··· 43 43 static void bnx2fc_ofld_timer(struct timer_list *t) 44 44 { 45 45 46 46 - struct bnx2fc_rport *tgt = from_timer(tgt, t, ofld_timer); 46 46 + struct bnx2fc_rport *tgt = timer_container_of(tgt, t, ofld_timer); 47 47 48 48 BNX2FC_TGT_DBG(tgt, "entered bnx2fc_ofld_timer\n"); 49 49 /* NOTE: This function should never be called, as

+1 -1

drivers/scsi/bnx2i/bnx2i_hwi.c

reviewed

··· 685 685 */ 686 686 void bnx2i_ep_ofld_timer(struct timer_list *t) 687 687 { 688 688 - struct bnx2i_endpoint *ep = from_timer(ep, t, ofld_timer); 688 688 + struct bnx2i_endpoint *ep = timer_container_of(ep, t, ofld_timer); 689 689 690 690 if (ep->state == EP_STATE_OFLD_START) { 691 691 printk(KERN_ALERT "ofld_timer: CONN_OFLD timeout\n");

+2 -2

drivers/scsi/csiostor/csio_hw.c

reviewed

··· 3738 3738 static void 3739 3739 csio_hw_mb_timer(struct timer_list *t) 3740 3740 { 3741 3741 - struct csio_mbm *mbm = from_timer(mbm, t, timer); 3741 3741 + struct csio_mbm *mbm = timer_container_of(mbm, t, timer); 3742 3742 struct csio_hw *hw = mbm->hw; 3743 3743 struct csio_mb *mbp = NULL; 3744 3744 ··· 4107 4107 static void 4108 4108 csio_mgmt_tmo_handler(struct timer_list *t) 4109 4109 { 4110 4110 - struct csio_mgmtm *mgmtm = from_timer(mgmtm, t, mgmt_timer); 4110 4110 + struct csio_mgmtm *mgmtm = timer_container_of(mgmtm, t, mgmt_timer); 4111 4111 struct list_head *tmp; 4112 4112 struct csio_ioreq *io_req; 4113 4113

+1 -1

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

reviewed

··· 547 547 548 548 static void act_open_retry_timer(struct timer_list *t) 549 549 { 550 550 - struct cxgbi_sock *csk = from_timer(csk, t, retry_timer); 550 550 + struct cxgbi_sock *csk = timer_container_of(csk, t, retry_timer); 551 551 struct sk_buff *skb; 552 552 553 553 log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,

+1 -1

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

reviewed

··· 988 988 static void csk_act_open_retry_timer(struct timer_list *t) 989 989 { 990 990 struct sk_buff *skb = NULL; 991 991 - struct cxgbi_sock *csk = from_timer(csk, t, retry_timer); 991 991 + struct cxgbi_sock *csk = timer_container_of(csk, t, retry_timer); 992 992 struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(csk->cdev); 993 993 void (*send_act_open_func)(struct cxgbi_sock *, struct sk_buff *, 994 994 struct l2t_entry *);

+1 -1

drivers/scsi/dc395x.c

reviewed

··· 751 751 static void waiting_timeout(struct timer_list *t) 752 752 { 753 753 unsigned long flags; 754 754 - struct AdapterCtlBlk *acb = from_timer(acb, t, waiting_timer); 754 754 + struct AdapterCtlBlk *acb = timer_container_of(acb, t, waiting_timer); 755 755 DC395x_LOCK_IO(acb->scsi_host, flags); 756 756 waiting_process_next(acb); 757 757 DC395x_UNLOCK_IO(acb->scsi_host, flags);

+1 -1

drivers/scsi/elx/efct/efct_xport.c

reviewed

··· 180 180 static void 181 181 efct_xport_stats_timer_cb(struct timer_list *t) 182 182 { 183 183 - struct efct_xport *xport = from_timer(xport, t, stats_timer); 183 183 + struct efct_xport *xport = timer_container_of(xport, t, stats_timer); 184 184 struct efct *efct = xport->efct; 185 185 186 186 efct_xport_config_stats_timer(efct);

+1 -1

drivers/scsi/elx/libefc/efc_els.c

reviewed

··· 147 147 static void 148 148 efc_els_delay_timer_cb(struct timer_list *t) 149 149 { 150 150 - struct efc_els_io_req *els = from_timer(els, t, delay_timer); 150 150 + struct efc_els_io_req *els = timer_container_of(els, t, delay_timer); 151 151 152 152 /* Retry delay timer expired, retry the ELS request */ 153 153 efc_els_retry(els);

+1 -1

drivers/scsi/elx/libefc/efc_fabric.c

reviewed

··· 886 886 static void 887 887 gidpt_delay_timer_cb(struct timer_list *t) 888 888 { 889 889 - struct efc_node *node = from_timer(node, t, gidpt_delay_timer); 889 889 + struct efc_node *node = timer_container_of(node, t, gidpt_delay_timer); 890 890 891 891 timer_delete(&node->gidpt_delay_timer); 892 892

+1 -1

drivers/scsi/esas2r/esas2r_main.c

reviewed

··· 1585 1585 1586 1586 static void esas2r_timer_callback(struct timer_list *t) 1587 1587 { 1588 1588 - struct esas2r_adapter *a = from_timer(a, t, timer); 1588 1588 + struct esas2r_adapter *a = timer_container_of(a, t, timer); 1589 1589 1590 1590 set_bit(AF2_TIMER_TICK, &a->flags2); 1591 1591

+1 -1

drivers/scsi/fcoe/fcoe_ctlr.c

reviewed

··· 1773 1773 */ 1774 1774 static void fcoe_ctlr_timeout(struct timer_list *t) 1775 1775 { 1776 1776 - struct fcoe_ctlr *fip = from_timer(fip, t, timer); 1776 1776 + struct fcoe_ctlr *fip = timer_container_of(fip, t, timer); 1777 1777 1778 1778 schedule_work(&fip->timer_work); 1779 1779 }

+1 -1

drivers/scsi/fcoe/fcoe_transport.c

reviewed

··· 447 447 */ 448 448 void fcoe_queue_timer(struct timer_list *t) 449 449 { 450 450 - struct fcoe_port *port = from_timer(port, t, timer); 450 450 + struct fcoe_port *port = timer_container_of(port, t, timer); 451 451 452 452 fcoe_check_wait_queue(port->lport, NULL); 453 453 }

+5 -3

drivers/scsi/fnic/fdls_disc.c

reviewed

··· 2074 2074 2075 2075 void fdls_fabric_timer_callback(struct timer_list *t) 2076 2076 { 2077 2077 - struct fnic_fdls_fabric_s *fabric = from_timer(fabric, t, retry_timer); 2077 2077 + struct fnic_fdls_fabric_s *fabric = timer_container_of(fabric, t, 2078 2078 + retry_timer); 2078 2079 struct fnic_iport_s *iport = 2079 2080 container_of(fabric, struct fnic_iport_s, fabric); 2080 2081 struct fnic *fnic = iport->fnic; ··· 2247 2246 2248 2247 void fdls_fdmi_timer_callback(struct timer_list *t) 2249 2248 { 2250 2250 - struct fnic_fdls_fabric_s *fabric = from_timer(fabric, t, fdmi_timer); 2249 2249 + struct fnic_fdls_fabric_s *fabric = timer_container_of(fabric, t, 2250 2250 + fdmi_timer); 2251 2251 struct fnic_iport_s *iport = 2252 2252 container_of(fabric, struct fnic_iport_s, fabric); 2253 2253 struct fnic *fnic = iport->fnic; ··· 2325 2323 2326 2324 static void fdls_tport_timer_callback(struct timer_list *t) 2327 2325 { 2328 2328 - struct fnic_tport_s *tport = from_timer(tport, t, retry_timer); 2326 2326 + struct fnic_tport_s *tport = timer_container_of(tport, t, retry_timer); 2329 2327 struct fnic_iport_s *iport = (struct fnic_iport_s *) tport->iport; 2330 2328 struct fnic *fnic = iport->fnic; 2331 2329 uint16_t oxid;

+4 -4

drivers/scsi/fnic/fip.c

reviewed

··· 777 777 */ 778 778 void fnic_handle_fip_timer(struct timer_list *t) 779 779 { 780 780 - struct fnic *fnic = from_timer(fnic, t, retry_fip_timer); 780 780 + struct fnic *fnic = timer_container_of(fnic, t, retry_fip_timer); 781 781 782 782 INIT_WORK(&fnic->fip_timer_work, fnic_work_on_fip_timer); 783 783 queue_work(fnic_fip_queue, &fnic->fip_timer_work); ··· 790 790 void fnic_handle_enode_ka_timer(struct timer_list *t) 791 791 { 792 792 uint8_t *frame; 793 793 - struct fnic *fnic = from_timer(fnic, t, enode_ka_timer); 793 793 + struct fnic *fnic = timer_container_of(fnic, t, enode_ka_timer); 794 794 795 795 struct fnic_iport_s *iport = &fnic->iport; 796 796 struct fip_enode_ka *penode_ka; ··· 843 843 void fnic_handle_vn_ka_timer(struct timer_list *t) 844 844 { 845 845 uint8_t *frame; 846 846 - struct fnic *fnic = from_timer(fnic, t, vn_ka_timer); 846 846 + struct fnic *fnic = timer_container_of(fnic, t, vn_ka_timer); 847 847 848 848 struct fnic_iport_s *iport = &fnic->iport; 849 849 struct fip_vn_port_ka *pvn_port_ka; ··· 998 998 */ 999 999 void fnic_handle_fcs_ka_timer(struct timer_list *t) 1000 1000 { 1001 1001 - struct fnic *fnic = from_timer(fnic, t, fcs_ka_timer); 1001 1001 + struct fnic *fnic = timer_container_of(fnic, t, fcs_ka_timer); 1002 1002 1003 1003 INIT_WORK(&fnic->fip_timer_work, fnic_work_on_fcs_ka_timer); 1004 1004 queue_work(fnic_fip_queue, &fnic->fip_timer_work);

+1 -1

drivers/scsi/fnic/fnic_main.c

reviewed

··· 446 446 447 447 static void fnic_notify_timer(struct timer_list *t) 448 448 { 449 449 - struct fnic *fnic = from_timer(fnic, t, notify_timer); 449 449 + struct fnic *fnic = timer_container_of(fnic, t, notify_timer); 450 450 451 451 fnic_handle_link_event(fnic); 452 452 mod_timer(&fnic->notify_timer,

+1 -1

drivers/scsi/hisi_sas/hisi_sas_main.c

reviewed

··· 1016 1016 1017 1017 static void hisi_sas_wait_phyup_timedout(struct timer_list *t) 1018 1018 { 1019 1019 - struct hisi_sas_phy *phy = from_timer(phy, t, timer); 1019 1019 + struct hisi_sas_phy *phy = timer_container_of(phy, t, timer); 1020 1020 struct hisi_hba *hisi_hba = phy->hisi_hba; 1021 1021 struct device *dev = hisi_hba->dev; 1022 1022 int phy_no = phy->sas_phy.id;

+1 -1

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

reviewed

··· 795 795 796 796 static void start_phys_v1_hw(struct timer_list *t) 797 797 { 798 798 - struct hisi_hba *hisi_hba = from_timer(hisi_hba, t, timer); 798 798 + struct hisi_hba *hisi_hba = timer_container_of(hisi_hba, t, timer); 799 799 int i; 800 800 801 801 for (i = 0; i < hisi_hba->n_phy; i++) {

+4 -3

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

reviewed

··· 1328 1328 1329 1329 static void link_timeout_enable_link(struct timer_list *t) 1330 1330 { 1331 1331 - struct hisi_hba *hisi_hba = from_timer(hisi_hba, t, timer); 1331 1331 + struct hisi_hba *hisi_hba = timer_container_of(hisi_hba, t, timer); 1332 1332 int i, reg_val; 1333 1333 1334 1334 for (i = 0; i < hisi_hba->n_phy; i++) { ··· 1349 1349 1350 1350 static void link_timeout_disable_link(struct timer_list *t) 1351 1351 { 1352 1352 - struct hisi_hba *hisi_hba = from_timer(hisi_hba, t, timer); 1352 1352 + struct hisi_hba *hisi_hba = timer_container_of(hisi_hba, t, timer); 1353 1353 int i, reg_val; 1354 1354 1355 1355 reg_val = hisi_sas_read32(hisi_hba, PHY_STATE); ··· 2581 2581 2582 2582 static void hisi_sas_internal_abort_quirk_timeout(struct timer_list *t) 2583 2583 { 2584 2584 - struct hisi_sas_slot *slot = from_timer(slot, t, internal_abort_timer); 2584 2584 + struct hisi_sas_slot *slot = timer_container_of(slot, t, 2585 2585 + internal_abort_timer); 2585 2586 struct hisi_sas_port *port = slot->port; 2586 2587 struct asd_sas_port *asd_sas_port; 2587 2588 struct asd_sas_phy *sas_phy;

+2 -2

drivers/scsi/ibmvscsi/ibmvfc.c

reviewed

··· 1697 1697 **/ 1698 1698 static void ibmvfc_timeout(struct timer_list *t) 1699 1699 { 1700 1700 - struct ibmvfc_event *evt = from_timer(evt, t, timer); 1700 1700 + struct ibmvfc_event *evt = timer_container_of(evt, t, timer); 1701 1701 struct ibmvfc_host *vhost = evt->vhost; 1702 1702 dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt); 1703 1703 ibmvfc_reset_host(vhost); ··· 4630 4630 **/ 4631 4631 static void ibmvfc_adisc_timeout(struct timer_list *t) 4632 4632 { 4633 4633 - struct ibmvfc_target *tgt = from_timer(tgt, t, timer); 4633 4633 + struct ibmvfc_target *tgt = timer_container_of(tgt, t, timer); 4634 4634 struct ibmvfc_host *vhost = tgt->vhost; 4635 4635 struct ibmvfc_event *evt; 4636 4636 struct ibmvfc_tmf *tmf;

+2 -1

drivers/scsi/ibmvscsi/ibmvscsi.c

reviewed

··· 845 845 */ 846 846 static void ibmvscsi_timeout(struct timer_list *t) 847 847 { 848 848 - struct srp_event_struct *evt_struct = from_timer(evt_struct, t, timer); 848 848 + struct srp_event_struct *evt_struct = timer_container_of(evt_struct, 849 849 + t, timer); 849 850 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 850 851 851 852 dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n",

+4 -4

drivers/scsi/ipr.c

reviewed

··· 2589 2589 **/ 2590 2590 static void ipr_timeout(struct timer_list *t) 2591 2591 { 2592 2592 - struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 2592 2592 + struct ipr_cmnd *ipr_cmd = timer_container_of(ipr_cmd, t, timer); 2593 2593 unsigned long lock_flags = 0; 2594 2594 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 2595 2595 ··· 2622 2622 **/ 2623 2623 static void ipr_oper_timeout(struct timer_list *t) 2624 2624 { 2625 2625 - struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 2625 2625 + struct ipr_cmnd *ipr_cmd = timer_container_of(ipr_cmd, t, timer); 2626 2626 unsigned long lock_flags = 0; 2627 2627 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 2628 2628 ··· 5151 5151 **/ 5152 5152 static void ipr_abort_timeout(struct timer_list *t) 5153 5153 { 5154 5154 - struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 5154 5154 + struct ipr_cmnd *ipr_cmd = timer_container_of(ipr_cmd, t, timer); 5155 5155 struct ipr_cmnd *reset_cmd; 5156 5156 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 5157 5157 struct ipr_cmd_pkt *cmd_pkt; ··· 7476 7476 **/ 7477 7477 static void ipr_reset_timer_done(struct timer_list *t) 7478 7478 { 7479 7479 - struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 7479 7479 + struct ipr_cmnd *ipr_cmd = timer_container_of(ipr_cmd, t, timer); 7480 7480 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7481 7481 unsigned long lock_flags = 0; 7482 7482

+3 -3

drivers/scsi/isci/host.c

reviewed

··· 958 958 959 959 static void phy_startup_timeout(struct timer_list *t) 960 960 { 961 961 - struct sci_timer *tmr = from_timer(tmr, t, timer); 961 961 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 962 962 struct isci_host *ihost = container_of(tmr, typeof(*ihost), phy_timer); 963 963 unsigned long flags; 964 964 enum sci_status status; ··· 1592 1592 1593 1593 static void controller_timeout(struct timer_list *t) 1594 1594 { 1595 1595 - struct sci_timer *tmr = from_timer(tmr, t, timer); 1595 1595 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 1596 1596 struct isci_host *ihost = container_of(tmr, typeof(*ihost), timer); 1597 1597 struct sci_base_state_machine *sm = &ihost->sm; 1598 1598 unsigned long flags; ··· 1737 1737 1738 1738 static void power_control_timeout(struct timer_list *t) 1739 1739 { 1740 1740 - struct sci_timer *tmr = from_timer(tmr, t, timer); 1740 1740 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 1741 1741 struct isci_host *ihost = container_of(tmr, typeof(*ihost), power_control.timer); 1742 1742 struct isci_phy *iphy; 1743 1743 unsigned long flags;

+1 -1

drivers/scsi/isci/phy.c

reviewed

··· 317 317 318 318 static void phy_sata_timeout(struct timer_list *t) 319 319 { 320 320 - struct sci_timer *tmr = from_timer(tmr, t, timer); 320 320 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 321 321 struct isci_phy *iphy = container_of(tmr, typeof(*iphy), sata_timer); 322 322 struct isci_host *ihost = iphy->owning_port->owning_controller; 323 323 unsigned long flags;

+1 -1

drivers/scsi/isci/port.c

reviewed

··· 775 775 776 776 static void port_timeout(struct timer_list *t) 777 777 { 778 778 - struct sci_timer *tmr = from_timer(tmr, t, timer); 778 778 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 779 779 struct isci_port *iport = container_of(tmr, typeof(*iport), timer); 780 780 struct isci_host *ihost = iport->owning_controller; 781 781 unsigned long flags;

+2 -2

drivers/scsi/isci/port_config.c

reviewed

··· 321 321 static void mpc_agent_timeout(struct timer_list *t) 322 322 { 323 323 u8 index; 324 324 - struct sci_timer *tmr = from_timer(tmr, t, timer); 324 324 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 325 325 struct sci_port_configuration_agent *port_agent; 326 326 struct isci_host *ihost; 327 327 unsigned long flags; ··· 659 659 static void apc_agent_timeout(struct timer_list *t) 660 660 { 661 661 u32 index; 662 662 - struct sci_timer *tmr = from_timer(tmr, t, timer); 662 662 + struct sci_timer *tmr = timer_container_of(tmr, t, timer); 663 663 struct sci_port_configuration_agent *port_agent; 664 664 struct isci_host *ihost; 665 665 unsigned long flags;

+2 -2

drivers/scsi/libfc/fc_fcp.c

reviewed

··· 1283 1283 */ 1284 1284 static void fc_lun_reset_send(struct timer_list *t) 1285 1285 { 1286 1286 - struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer); 1286 1286 + struct fc_fcp_pkt *fsp = timer_container_of(fsp, t, timer); 1287 1287 struct fc_lport *lport = fsp->lp; 1288 1288 1289 1289 if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) { ··· 1416 1416 */ 1417 1417 static void fc_fcp_timeout(struct timer_list *t) 1418 1418 { 1419 1419 - struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer); 1419 1419 + struct fc_fcp_pkt *fsp = timer_container_of(fsp, t, timer); 1420 1420 struct fc_rport *rport = fsp->rport; 1421 1421 struct fc_rport_libfc_priv *rpriv = rport->dd_data; 1422 1422

+3 -2

drivers/scsi/libiscsi.c

reviewed

··· 1898 1898 1899 1899 static void iscsi_tmf_timedout(struct timer_list *t) 1900 1900 { 1901 1901 - struct iscsi_session *session = from_timer(session, t, tmf_timer); 1901 1901 + struct iscsi_session *session = timer_container_of(session, t, 1902 1902 + tmf_timer); 1902 1903 1903 1904 spin_lock(&session->frwd_lock); 1904 1905 if (session->tmf_state == TMF_QUEUED) { ··· 2241 2240 2242 2241 static void iscsi_check_transport_timeouts(struct timer_list *t) 2243 2242 { 2244 2244 - struct iscsi_conn *conn = from_timer(conn, t, transport_timer); 2243 2243 + struct iscsi_conn *conn = timer_container_of(conn, t, transport_timer); 2245 2244 struct iscsi_session *session = conn->session; 2246 2245 unsigned long recv_timeout, next_timeout = 0, last_recv; 2247 2246

+1 -1

drivers/scsi/libsas/sas_scsi_host.c

reviewed

··· 865 865 866 866 void sas_task_internal_timedout(struct timer_list *t) 867 867 { 868 868 - struct sas_task_slow *slow = from_timer(slow, t, timer); 868 868 + struct sas_task_slow *slow = timer_container_of(slow, t, timer); 869 869 struct sas_task *task = slow->task; 870 870 bool is_completed = true; 871 871 unsigned long flags;

+2 -1

drivers/scsi/lpfc/lpfc_ct.c

reviewed

··· 3433 3433 void 3434 3434 lpfc_delayed_disc_tmo(struct timer_list *t) 3435 3435 { 3436 3436 - struct lpfc_vport *vport = from_timer(vport, t, delayed_disc_tmo); 3436 3436 + struct lpfc_vport *vport = timer_container_of(vport, t, 3437 3437 + delayed_disc_tmo); 3437 3438 struct lpfc_hba *phba = vport->phba; 3438 3439 uint32_t tmo_posted; 3439 3440 unsigned long iflag;

+5 -3

drivers/scsi/lpfc/lpfc_els.c

reviewed

··· 4378 4378 void 4379 4379 lpfc_els_retry_delay(struct timer_list *t) 4380 4380 { 4381 4381 - struct lpfc_nodelist *ndlp = from_timer(ndlp, t, nlp_delayfunc); 4381 4381 + struct lpfc_nodelist *ndlp = timer_container_of(ndlp, t, 4382 4382 + nlp_delayfunc); 4382 4383 struct lpfc_vport *vport = ndlp->vport; 4383 4384 struct lpfc_hba *phba = vport->phba; 4384 4385 unsigned long flags; ··· 9386 9385 void 9387 9386 lpfc_els_timeout(struct timer_list *t) 9388 9387 { 9389 9389 - struct lpfc_vport *vport = from_timer(vport, t, els_tmofunc); 9388 9388 + struct lpfc_vport *vport = timer_container_of(vport, t, els_tmofunc); 9390 9389 struct lpfc_hba *phba = vport->phba; 9391 9390 uint32_t tmo_posted; 9392 9391 unsigned long iflag; ··· 11595 11594 void 11596 11595 lpfc_fabric_block_timeout(struct timer_list *t) 11597 11596 { 11598 11598 - struct lpfc_hba *phba = from_timer(phba, t, fabric_block_timer); 11597 11597 + struct lpfc_hba *phba = timer_container_of(phba, t, 11598 11598 + fabric_block_timer); 11599 11599 unsigned long iflags; 11600 11600 uint32_t tmo_posted; 11601 11601

+1 -1

drivers/scsi/lpfc/lpfc_hbadisc.c

reviewed

··· 6059 6059 void 6060 6060 lpfc_disc_timeout(struct timer_list *t) 6061 6061 { 6062 6062 - struct lpfc_vport *vport = from_timer(vport, t, fc_disctmo); 6062 6062 + struct lpfc_vport *vport = timer_container_of(vport, t, fc_disctmo); 6063 6063 struct lpfc_hba *phba = vport->phba; 6064 6064 uint32_t tmo_posted; 6065 6065 unsigned long flags = 0;

+5 -4

drivers/scsi/lpfc/lpfc_init.c

reviewed

··· 1196 1196 uint32_t tmo_posted; 1197 1197 unsigned long iflag; 1198 1198 1199 1199 - phba = from_timer(phba, t, hb_tmofunc); 1199 1199 + phba = timer_container_of(phba, t, hb_tmofunc); 1200 1200 1201 1201 /* Check for heart beat timeout conditions */ 1202 1202 spin_lock_irqsave(&phba->pport->work_port_lock, iflag); ··· 1228 1228 { 1229 1229 struct lpfc_hba *phba; 1230 1230 1231 1231 - phba = from_timer(phba, t, rrq_tmr); 1231 1231 + phba = timer_container_of(phba, t, rrq_tmr); 1232 1232 if (test_bit(FC_UNLOADING, &phba->pport->load_flag)) { 1233 1233 clear_bit(HBA_RRQ_ACTIVE, &phba->hba_flag); 1234 1234 return; ··· 5131 5131 static void 5132 5132 lpfc_sli4_fcf_redisc_wait_tmo(struct timer_list *t) 5133 5133 { 5134 5134 - struct lpfc_hba *phba = from_timer(phba, t, fcf.redisc_wait); 5134 5134 + struct lpfc_hba *phba = timer_container_of(phba, t, fcf.redisc_wait); 5135 5135 5136 5136 /* Don't send FCF rediscovery event if timer cancelled */ 5137 5137 spin_lock_irq(&phba->hbalock); ··· 5162 5162 static void 5163 5163 lpfc_vmid_poll(struct timer_list *t) 5164 5164 { 5165 5165 - struct lpfc_hba *phba = from_timer(phba, t, inactive_vmid_poll); 5165 5165 + struct lpfc_hba *phba = timer_container_of(phba, t, 5166 5166 + inactive_vmid_poll); 5166 5167 u32 wake_up = 0; 5167 5168 5168 5169 /* check if there is a need to issue QFPA */

+1 -1

drivers/scsi/lpfc/lpfc_scsi.c

reviewed

··· 5190 5190 **/ 5191 5191 void lpfc_poll_timeout(struct timer_list *t) 5192 5192 { 5193 5193 - struct lpfc_hba *phba = from_timer(phba, t, fcp_poll_timer); 5193 5193 + struct lpfc_hba *phba = timer_container_of(phba, t, fcp_poll_timer); 5194 5194 5195 5195 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { 5196 5196 lpfc_sli_handle_fast_ring_event(phba,

+3 -3

drivers/scsi/lpfc/lpfc_sli.c

reviewed

··· 3925 3925 uint32_t eratt = 0; 3926 3926 uint64_t sli_intr, cnt; 3927 3927 3928 3928 - phba = from_timer(phba, t, eratt_poll); 3928 3928 + phba = timer_container_of(phba, t, eratt_poll); 3929 3929 3930 3930 if (test_bit(FC_UNLOADING, &phba->pport->load_flag)) 3931 3931 return; ··· 9125 9125 void 9126 9126 lpfc_mbox_timeout(struct timer_list *t) 9127 9127 { 9128 9128 - struct lpfc_hba *phba = from_timer(phba, t, sli.mbox_tmo); 9128 9128 + struct lpfc_hba *phba = timer_container_of(phba, t, sli.mbox_tmo); 9129 9129 unsigned long iflag; 9130 9130 uint32_t tmo_posted; 9131 9131 ··· 15661 15661 15662 15662 void lpfc_sli4_poll_hbtimer(struct timer_list *t) 15663 15663 { 15664 15664 - struct lpfc_hba *phba = from_timer(phba, t, cpuhp_poll_timer); 15664 15664 + struct lpfc_hba *phba = timer_container_of(phba, t, cpuhp_poll_timer); 15665 15665 struct lpfc_queue *eq; 15666 15666 15667 15667 rcu_read_lock();

+1 -1

drivers/scsi/megaraid/megaraid_mbox.c

reviewed

··· 3836 3836 static void 3837 3837 megaraid_sysfs_get_ldmap_timeout(struct timer_list *t) 3838 3838 { 3839 3839 - struct uioc_timeout *timeout = from_timer(timeout, t, timer); 3839 3839 + struct uioc_timeout *timeout = timer_container_of(timeout, t, timer); 3840 3840 uioc_t *uioc = timeout->uioc; 3841 3841 adapter_t *adapter = (adapter_t *)uioc->buf_vaddr; 3842 3842 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);

+1 -1

drivers/scsi/megaraid/megaraid_mm.c

reviewed

··· 783 783 static void 784 784 lld_timedout(struct timer_list *t) 785 785 { 786 786 - struct uioc_timeout *timeout = from_timer(timeout, t, timer); 786 786 + struct uioc_timeout *timeout = timer_container_of(timeout, t, timer); 787 787 uioc_t *kioc = timeout->uioc; 788 788 789 789 kioc->status = -ETIME;

+1 -1

drivers/scsi/megaraid/megaraid_sas_base.c

reviewed

··· 2724 2724 static void megasas_sriov_heartbeat_handler(struct timer_list *t) 2725 2725 { 2726 2726 struct megasas_instance *instance = 2727 2727 - from_timer(instance, t, sriov_heartbeat_timer); 2727 2727 + timer_container_of(instance, t, sriov_heartbeat_timer); 2728 2728 2729 2729 if (instance->hb_host_mem->HB.fwCounter != 2730 2730 instance->hb_host_mem->HB.driverCounter) {

+1 -1

drivers/scsi/mvsas/mv_sas.c

reviewed

··· 1755 1755 1756 1756 static void mvs_sig_time_out(struct timer_list *t) 1757 1757 { 1758 1758 - struct mvs_phy *phy = from_timer(phy, t, timer); 1758 1758 + struct mvs_phy *phy = timer_container_of(phy, t, timer); 1759 1759 struct mvs_info *mvi = phy->mvi; 1760 1760 u8 phy_no; 1761 1761

+1 -1

drivers/scsi/ncr53c8xx.c

reviewed

··· 7923 7923 7924 7924 static void ncr53c8xx_timeout(struct timer_list *t) 7925 7925 { 7926 7926 - struct ncb *np = from_timer(np, t, timer); 7926 7926 + struct ncb *np = timer_container_of(np, t, timer); 7927 7927 unsigned long flags; 7928 7928 struct scsi_cmnd *done_list; 7929 7929

+3 -3

drivers/scsi/pmcraid.c

reviewed

··· 544 544 */ 545 545 static void pmcraid_bist_done(struct timer_list *t) 546 546 { 547 547 - struct pmcraid_cmd *cmd = from_timer(cmd, t, timer); 547 547 + struct pmcraid_cmd *cmd = timer_container_of(cmd, t, timer); 548 548 struct pmcraid_instance *pinstance = cmd->drv_inst; 549 549 unsigned long lock_flags; 550 550 int rc; ··· 601 601 */ 602 602 static void pmcraid_reset_alert_done(struct timer_list *t) 603 603 { 604 604 - struct pmcraid_cmd *cmd = from_timer(cmd, t, timer); 604 604 + struct pmcraid_cmd *cmd = timer_container_of(cmd, t, timer); 605 605 struct pmcraid_instance *pinstance = cmd->drv_inst; 606 606 u32 status = ioread32(pinstance->ioa_status); 607 607 unsigned long lock_flags; ··· 685 685 */ 686 686 static void pmcraid_timeout_handler(struct timer_list *t) 687 687 { 688 688 - struct pmcraid_cmd *cmd = from_timer(cmd, t, timer); 688 688 + struct pmcraid_cmd *cmd = timer_container_of(cmd, t, timer); 689 689 struct pmcraid_instance *pinstance = cmd->drv_inst; 690 690 unsigned long lock_flags; 691 691

+1 -1

drivers/scsi/qla1280.c

reviewed

··· 721 721 722 722 static void qla1280_mailbox_timeout(struct timer_list *t) 723 723 { 724 724 - struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer); 724 724 + struct scsi_qla_host *ha = timer_container_of(ha, t, mailbox_timer); 725 725 struct device_reg __iomem *reg; 726 726 reg = ha->iobase; 727 727

+2 -1

drivers/scsi/qla2xxx/qla_edif.c

reviewed

··· 94 94 /* timeout called when no traffic and delayed rx sa_index delete */ 95 95 static void qla2x00_sa_replace_iocb_timeout(struct timer_list *t) 96 96 { 97 97 - struct edif_list_entry *edif_entry = from_timer(edif_entry, t, timer); 97 97 + struct edif_list_entry *edif_entry = timer_container_of(edif_entry, t, 98 98 + timer); 98 99 fc_port_t *fcport = edif_entry->fcport; 99 100 struct scsi_qla_host *vha = fcport->vha; 100 101 struct edif_sa_ctl *sa_ctl;

+1 -1

drivers/scsi/qla2xxx/qla_init.c

reviewed

··· 45 45 void 46 46 qla2x00_sp_timeout(struct timer_list *t) 47 47 { 48 48 - srb_t *sp = from_timer(sp, t, u.iocb_cmd.timer); 48 48 + srb_t *sp = timer_container_of(sp, t, u.iocb_cmd.timer); 49 49 struct srb_iocb *iocb; 50 50 scsi_qla_host_t *vha = sp->vha; 51 51

+1 -1

drivers/scsi/qla2xxx/qla_os.c

reviewed

··· 7380 7380 void 7381 7381 qla2x00_timer(struct timer_list *t) 7382 7382 { 7383 7383 - scsi_qla_host_t *vha = from_timer(vha, t, timer); 7383 7383 + scsi_qla_host_t *vha = timer_container_of(vha, t, timer); 7384 7384 unsigned long cpu_flags = 0; 7385 7385 int start_dpc = 0; 7386 7386 int index;

+1 -1

drivers/scsi/qla4xxx/ql4_os.c

reviewed

··· 4551 4551 **/ 4552 4552 static void qla4xxx_timer(struct timer_list *t) 4553 4553 { 4554 4554 - struct scsi_qla_host *ha = from_timer(ha, t, timer); 4554 4554 + struct scsi_qla_host *ha = timer_container_of(ha, t, timer); 4555 4555 int start_dpc = 0; 4556 4556 uint16_t w; 4557 4557

+2 -1

drivers/scsi/smartpqi/smartpqi_init.c

reviewed

··· 3825 3825 { 3826 3826 int num_interrupts; 3827 3827 u32 heartbeat_count; 3828 3828 - struct pqi_ctrl_info *ctrl_info = from_timer(ctrl_info, t, heartbeat_timer); 3828 3828 + struct pqi_ctrl_info *ctrl_info = timer_container_of(ctrl_info, t, 3829 3829 + heartbeat_timer); 3829 3830 3830 3831 pqi_check_ctrl_health(ctrl_info); 3831 3832 if (pqi_ctrl_offline(ctrl_info))

+1 -1

drivers/scsi/sym53c8xx_2/sym_glue.c

reviewed

··· 545 545 */ 546 546 static void sym53c8xx_timer(struct timer_list *t) 547 547 { 548 548 - struct sym_hcb *np = from_timer(np, t, s.timer); 548 548 + struct sym_hcb *np = timer_container_of(np, t, s.timer); 549 549 unsigned long flags; 550 550 551 551 spin_lock_irqsave(np->s.host->host_lock, flags);

+2 -1

drivers/staging/gpib/agilent_82357a/agilent_82357a.c

reviewed

··· 39 39 40 40 static void agilent_82357a_timeout_handler(struct timer_list *t) 41 41 { 42 42 - struct agilent_82357a_priv *a_priv = from_timer(a_priv, t, bulk_timer); 42 42 + struct agilent_82357a_priv *a_priv = timer_container_of(a_priv, t, 43 43 + bulk_timer); 43 44 struct agilent_82357a_urb_ctx *context = &a_priv->context; 44 45 45 46 context->timed_out = 1;

+3 -2

drivers/staging/gpib/common/gpib_os.c

reviewed

··· 85 85 86 86 static void watchdog_timeout(struct timer_list *t) 87 87 { 88 88 - struct gpib_board *board = from_timer(board, t, timer); 88 88 + struct gpib_board *board = timer_container_of(board, t, timer); 89 89 90 90 set_bit(TIMO_NUM, &board->status); 91 91 wake_up_interruptible(&board->wait); ··· 133 133 134 134 static void pseudo_irq_handler(struct timer_list *t) 135 135 { 136 136 - struct gpib_pseudo_irq *pseudo_irq = from_timer(pseudo_irq, t, timer); 136 136 + struct gpib_pseudo_irq *pseudo_irq = timer_container_of(pseudo_irq, t, 137 137 + timer); 137 138 138 139 if (pseudo_irq->handler) 139 140 pseudo_irq->handler(0, pseudo_irq->board);

+1 -1

drivers/staging/gpib/common/iblib.c

reviewed

··· 574 574 575 575 static void wait_timeout(struct timer_list *t) 576 576 { 577 577 - struct wait_info *winfo = from_timer(winfo, t, timer); 577 577 + struct wait_info *winfo = timer_container_of(winfo, t, timer); 578 578 579 579 winfo->timed_out = 1; 580 580 wake_up_interruptible(&winfo->board->wait);

+2 -1

drivers/staging/gpib/ni_usb/ni_usb_gpib.c

reviewed

··· 93 93 94 94 static void ni_usb_timeout_handler(struct timer_list *t) 95 95 { 96 96 - struct ni_usb_priv *ni_priv = from_timer(ni_priv, t, bulk_timer); 96 96 + struct ni_usb_priv *ni_priv = timer_container_of(ni_priv, t, 97 97 + bulk_timer); 97 98 struct ni_usb_urb_ctx *context = &ni_priv->context; 98 99 99 100 context->timed_out = 1;

+1 -1

drivers/staging/media/imx/imx-ic-prpencvf.c

reviewed

··· 295 295 */ 296 296 static void prp_eof_timeout(struct timer_list *t) 297 297 { 298 298 - struct prp_priv *priv = from_timer(priv, t, eof_timeout_timer); 298 298 + struct prp_priv *priv = timer_container_of(priv, t, eof_timeout_timer); 299 299 struct imx_media_video_dev *vdev = priv->vdev; 300 300 struct imx_ic_priv *ic_priv = priv->ic_priv; 301 301

+1 -1

drivers/staging/media/imx/imx-media-csi.c

reviewed

··· 356 356 */ 357 357 static void csi_idmac_eof_timeout(struct timer_list *t) 358 358 { 359 359 - struct csi_priv *priv = from_timer(priv, t, eof_timeout_timer); 359 359 + struct csi_priv *priv = timer_container_of(priv, t, eof_timeout_timer); 360 360 struct imx_media_video_dev *vdev = priv->vdev; 361 361 362 362 v4l2_err(&priv->sd, "EOF timeout\n");

+4 -4

drivers/staging/rtl8723bs/core/rtw_mlme.c

reviewed

··· 1460 1460 */ 1461 1461 void _rtw_join_timeout_handler(struct timer_list *t) 1462 1462 { 1463 1463 - struct adapter *adapter = from_timer(adapter, t, 1464 1464 - mlmepriv.assoc_timer); 1463 1463 + struct adapter *adapter = timer_container_of(adapter, t, 1464 1464 + mlmepriv.assoc_timer); 1465 1465 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1466 1466 1467 1467 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) ··· 1504 1504 */ 1505 1505 void rtw_scan_timeout_handler(struct timer_list *t) 1506 1506 { 1507 1507 - struct adapter *adapter = from_timer(adapter, t, 1508 1508 - mlmepriv.scan_to_timer); 1507 1507 + struct adapter *adapter = timer_container_of(adapter, t, 1508 1508 + mlmepriv.scan_to_timer); 1509 1509 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1510 1510 1511 1511 spin_lock_bh(&pmlmepriv->lock);

+4 -4

drivers/staging/rtl8723bs/core/rtw_mlme_ext.c

reviewed

··· 5088 5088 void survey_timer_hdl(struct timer_list *t) 5089 5089 { 5090 5090 struct adapter *padapter = 5091 5091 - from_timer(padapter, t, mlmeextpriv.survey_timer); 5091 5091 + timer_container_of(padapter, t, mlmeextpriv.survey_timer); 5092 5092 struct cmd_obj *ph2c; 5093 5093 struct sitesurvey_parm *psurveyPara; 5094 5094 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; ··· 5123 5123 void link_timer_hdl(struct timer_list *t) 5124 5124 { 5125 5125 struct adapter *padapter = 5126 5126 - from_timer(padapter, t, mlmeextpriv.link_timer); 5126 5126 + timer_container_of(padapter, t, mlmeextpriv.link_timer); 5127 5127 /* static unsigned int rx_pkt = 0; */ 5128 5128 /* static u64 tx_cnt = 0; */ 5129 5129 /* struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); */ ··· 5161 5161 5162 5162 void addba_timer_hdl(struct timer_list *t) 5163 5163 { 5164 5164 - struct sta_info *psta = from_timer(psta, t, addba_retry_timer); 5164 5164 + struct sta_info *psta = timer_container_of(psta, t, addba_retry_timer); 5165 5165 struct ht_priv *phtpriv; 5166 5166 5167 5167 if (!psta) ··· 5179 5179 void sa_query_timer_hdl(struct timer_list *t) 5180 5180 { 5181 5181 struct adapter *padapter = 5182 5182 - from_timer(padapter, t, mlmeextpriv.sa_query_timer); 5182 5182 + timer_container_of(padapter, t, mlmeextpriv.sa_query_timer); 5183 5183 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 5184 5184 /* disconnect */ 5185 5185 spin_lock_bh(&pmlmepriv->lock);

+3 -2

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

reviewed

··· 175 175 static void pwr_state_check_handler(struct timer_list *t) 176 176 { 177 177 struct pwrctrl_priv *pwrctrlpriv = 178 178 - from_timer(pwrctrlpriv, t, pwr_state_check_timer); 178 178 + timer_container_of(pwrctrlpriv, t, pwr_state_check_timer); 179 179 struct adapter *padapter = pwrctrlpriv->adapter; 180 180 181 181 rtw_ps_cmd(padapter); ··· 674 674 */ 675 675 static void pwr_rpwm_timeout_handler(struct timer_list *t) 676 676 { 677 677 - struct pwrctrl_priv *pwrpriv = from_timer(pwrpriv, t, pwr_rpwm_timer); 677 677 + struct pwrctrl_priv *pwrpriv = timer_container_of(pwrpriv, t, 678 678 + pwr_rpwm_timer); 678 679 679 680 if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) 680 681 return;

+2 -2

drivers/staging/rtl8723bs/core/rtw_recv.c

reviewed

··· 1908 1908 void rtw_reordering_ctrl_timeout_handler(struct timer_list *t) 1909 1909 { 1910 1910 struct recv_reorder_ctrl *preorder_ctrl = 1911 1911 - from_timer(preorder_ctrl, t, reordering_ctrl_timer); 1911 1911 + timer_container_of(preorder_ctrl, t, reordering_ctrl_timer); 1912 1912 struct adapter *padapter = preorder_ctrl->padapter; 1913 1913 struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue; 1914 1914 ··· 2087 2087 static void rtw_signal_stat_timer_hdl(struct timer_list *t) 2088 2088 { 2089 2089 struct adapter *adapter = 2090 2090 - from_timer(adapter, t, recvpriv.signal_stat_timer); 2090 2090 + timer_container_of(adapter, t, recvpriv.signal_stat_timer); 2091 2091 struct recv_priv *recvpriv = &adapter->recvpriv; 2092 2092 2093 2093 u32 tmp_s, tmp_q;

+2 -2

drivers/staging/rtl8723bs/os_dep/mlme_linux.c

reviewed

··· 9 9 static void _dynamic_check_timer_handler(struct timer_list *t) 10 10 { 11 11 struct adapter *adapter = 12 12 - from_timer(adapter, t, mlmepriv.dynamic_chk_timer); 12 12 + timer_container_of(adapter, t, mlmepriv.dynamic_chk_timer); 13 13 14 14 rtw_dynamic_check_timer_handler(adapter); 15 15 ··· 19 19 static void _rtw_set_scan_deny_timer_hdl(struct timer_list *t) 20 20 { 21 21 struct adapter *adapter = 22 22 - from_timer(adapter, t, mlmepriv.set_scan_deny_timer); 22 22 + timer_container_of(adapter, t, mlmepriv.set_scan_deny_timer); 23 23 24 24 rtw_clear_scan_deny(adapter); 25 25 }

+2 -1

drivers/target/iscsi/iscsi_target_erl0.c

reviewed

··· 743 743 744 744 void iscsit_handle_time2retain_timeout(struct timer_list *t) 745 745 { 746 746 - struct iscsit_session *sess = from_timer(sess, t, time2retain_timer); 746 746 + struct iscsit_session *sess = timer_container_of(sess, t, 747 747 + time2retain_timer); 747 748 struct iscsi_portal_group *tpg = sess->tpg; 748 749 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 749 750

+1 -1

drivers/target/iscsi/iscsi_target_erl1.c

reviewed

··· 1094 1094 { 1095 1095 u32 pdu_length = 0, pdu_offset = 0; 1096 1096 u32 r2t_length = 0, r2t_offset = 0; 1097 1097 - struct iscsit_cmd *cmd = from_timer(cmd, t, dataout_timer); 1097 1097 + struct iscsit_cmd *cmd = timer_container_of(cmd, t, dataout_timer); 1098 1098 struct iscsit_conn *conn = cmd->conn; 1099 1099 struct iscsit_session *sess = NULL; 1100 1100 struct iscsi_node_attrib *na;

+4 -3

drivers/target/iscsi/iscsi_target_util.c

reviewed

··· 851 851 852 852 void iscsit_handle_nopin_response_timeout(struct timer_list *t) 853 853 { 854 854 - struct iscsit_conn *conn = from_timer(conn, t, nopin_response_timer); 854 854 + struct iscsit_conn *conn = timer_container_of(conn, t, 855 855 + nopin_response_timer); 855 856 struct iscsit_session *sess = conn->sess; 856 857 857 858 iscsit_inc_conn_usage_count(conn); ··· 932 931 933 932 void iscsit_handle_nopin_timeout(struct timer_list *t) 934 933 { 935 935 - struct iscsit_conn *conn = from_timer(conn, t, nopin_timer); 934 934 + struct iscsit_conn *conn = timer_container_of(conn, t, nopin_timer); 936 935 937 936 iscsit_inc_conn_usage_count(conn); 938 937 ··· 999 998 1000 999 void iscsit_login_timeout(struct timer_list *t) 1001 1000 { 1002 1002 - struct iscsit_conn *conn = from_timer(conn, t, login_timer); 1001 1001 + struct iscsit_conn *conn = timer_container_of(conn, t, login_timer); 1003 1002 struct iscsi_login *login = conn->login; 1004 1003 1005 1004 pr_debug("Entering iscsi_target_login_timeout >>>>>>>>>>>>>>>>>>>\n");

+2 -2

drivers/target/target_core_user.c

reviewed

··· 1564 1564 1565 1565 static void tcmu_cmd_timedout(struct timer_list *t) 1566 1566 { 1567 1567 - struct tcmu_dev *udev = from_timer(udev, t, cmd_timer); 1567 1567 + struct tcmu_dev *udev = timer_container_of(udev, t, cmd_timer); 1568 1568 1569 1569 pr_debug("%s cmd timeout has expired\n", udev->name); 1570 1570 tcmu_device_timedout(udev); ··· 1572 1572 1573 1573 static void tcmu_qfull_timedout(struct timer_list *t) 1574 1574 { 1575 1575 - struct tcmu_dev *udev = from_timer(udev, t, qfull_timer); 1575 1575 + struct tcmu_dev *udev = timer_container_of(udev, t, qfull_timer); 1576 1576 1577 1577 pr_debug("%s qfull timeout has expired\n", udev->name); 1578 1578 tcmu_device_timedout(udev);

+1 -1

drivers/tty/ipwireless/hardware.c

reviewed

··· 1676 1676 1677 1677 static void ipwireless_setup_timer(struct timer_list *t) 1678 1678 { 1679 1679 - struct ipw_hardware *hw = from_timer(hw, t, setup_timer); 1679 1679 + struct ipw_hardware *hw = timer_container_of(hw, t, setup_timer); 1680 1680 1681 1681 hw->init_loops++; 1682 1682

+2 -1

drivers/tty/mips_ejtag_fdc.c

reviewed

··· 683 683 */ 684 684 static void mips_ejtag_fdc_tty_timer(struct timer_list *t) 685 685 { 686 686 - struct mips_ejtag_fdc_tty *priv = from_timer(priv, t, poll_timer); 686 686 + struct mips_ejtag_fdc_tty *priv = timer_container_of(priv, t, 687 687 + poll_timer); 687 688 688 689 mips_ejtag_fdc_handle(priv); 689 690 if (!priv->removing)

+4 -4

drivers/tty/n_gsm.c

reviewed

··· 1971 1971 1972 1972 static void gsm_control_keep_alive(struct timer_list *t) 1973 1973 { 1974 1974 - struct gsm_mux *gsm = from_timer(gsm, t, ka_timer); 1974 1974 + struct gsm_mux *gsm = timer_container_of(gsm, t, ka_timer); 1975 1975 unsigned long flags; 1976 1976 1977 1977 spin_lock_irqsave(&gsm->control_lock, flags); ··· 2028 2028 2029 2029 static void gsm_control_retransmit(struct timer_list *t) 2030 2030 { 2031 2031 - struct gsm_mux *gsm = from_timer(gsm, t, t2_timer); 2031 2031 + struct gsm_mux *gsm = timer_container_of(gsm, t, t2_timer); 2032 2032 struct gsm_control *ctrl; 2033 2033 unsigned long flags; 2034 2034 spin_lock_irqsave(&gsm->control_lock, flags); ··· 2229 2229 2230 2230 static void gsm_dlci_t1(struct timer_list *t) 2231 2231 { 2232 2232 - struct gsm_dlci *dlci = from_timer(dlci, t, t1); 2232 2232 + struct gsm_dlci *dlci = timer_container_of(dlci, t, t1); 2233 2233 struct gsm_mux *gsm = dlci->gsm; 2234 2234 2235 2235 switch (dlci->state) { ··· 2489 2489 */ 2490 2490 static void gsm_kick_timer(struct timer_list *t) 2491 2491 { 2492 2492 - struct gsm_mux *gsm = from_timer(gsm, t, kick_timer); 2492 2492 + struct gsm_mux *gsm = timer_container_of(gsm, t, kick_timer); 2493 2493 unsigned long flags; 2494 2494 int sent = 0; 2495 2495

+2 -1

drivers/tty/serial/8250/8250_aspeed_vuart.c

reviewed

··· 304 304 305 305 static void aspeed_vuart_unthrottle_exp(struct timer_list *timer) 306 306 { 307 307 - struct aspeed_vuart *vuart = from_timer(vuart, timer, unthrottle_timer); 307 307 + struct aspeed_vuart *vuart = timer_container_of(vuart, timer, 308 308 + unthrottle_timer); 308 309 struct uart_8250_port *up = vuart->port; 309 310 310 311 if (!tty_buffer_space_avail(&up->port.state->port)) {

+2 -2

drivers/tty/serial/8250/8250_core.c

reviewed

··· 206 206 */ 207 207 static void serial8250_timeout(struct timer_list *t) 208 208 { 209 209 - struct uart_8250_port *up = from_timer(up, t, timer); 209 209 + struct uart_8250_port *up = timer_container_of(up, t, timer); 210 210 211 211 up->port.handle_irq(&up->port); 212 212 mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port)); ··· 214 214 215 215 static void serial8250_backup_timeout(struct timer_list *t) 216 216 { 217 217 - struct uart_8250_port *up = from_timer(up, t, timer); 217 217 + struct uart_8250_port *up = timer_container_of(up, t, timer); 218 218 unsigned int iir, ier = 0, lsr; 219 219 unsigned long flags; 220 220

+1 -1

drivers/tty/serial/altera_uart.c

reviewed

··· 275 275 276 276 static void altera_uart_timer(struct timer_list *t) 277 277 { 278 278 - struct altera_uart *pp = from_timer(pp, t, tmr); 278 278 + struct altera_uart *pp = timer_container_of(pp, t, tmr); 279 279 struct uart_port *port = &pp->port; 280 280 281 281 altera_uart_interrupt(0, port);

+1 -1

drivers/tty/serial/amba-pl011.c

reviewed

··· 1046 1046 */ 1047 1047 static void pl011_dma_rx_poll(struct timer_list *t) 1048 1048 { 1049 1049 - struct uart_amba_port *uap = from_timer(uap, t, dmarx.timer); 1049 1049 + struct uart_amba_port *uap = timer_container_of(uap, t, dmarx.timer); 1050 1050 struct tty_port *port = &uap->port.state->port; 1051 1051 struct pl011_dmarx_data *dmarx = &uap->dmarx; 1052 1052 struct dma_chan *rxchan = uap->dmarx.chan;

+2 -2

drivers/tty/serial/atmel_serial.c

reviewed

··· 1266 1266 1267 1267 static void atmel_uart_timer_callback(struct timer_list *t) 1268 1268 { 1269 1269 - struct atmel_uart_port *atmel_port = from_timer(atmel_port, t, 1270 1270 - uart_timer); 1269 1269 + struct atmel_uart_port *atmel_port = timer_container_of(atmel_port, t, 1270 1270 + uart_timer); 1271 1271 struct uart_port *port = &atmel_port->uart; 1272 1272 1273 1273 if (!atomic_read(&atmel_port->tasklet_shutdown)) {

+1 -1

drivers/tty/serial/fsl_lpuart.c

reviewed

··· 1307 1307 */ 1308 1308 static void lpuart_timer_func(struct timer_list *t) 1309 1309 { 1310 1310 - struct lpuart_port *sport = from_timer(sport, t, lpuart_timer); 1310 1310 + struct lpuart_port *sport = timer_container_of(sport, t, lpuart_timer); 1311 1311 enum dma_status dmastat; 1312 1312 struct dma_chan *chan = sport->dma_rx_chan; 1313 1313 struct circ_buf *ring = &sport->rx_ring;

+1 -1

drivers/tty/serial/imx.c

reviewed

··· 1165 1165 */ 1166 1166 static void imx_uart_timeout(struct timer_list *t) 1167 1167 { 1168 1168 - struct imx_port *sport = from_timer(sport, t, timer); 1168 1168 + struct imx_port *sport = timer_container_of(sport, t, timer); 1169 1169 unsigned long flags; 1170 1170 1171 1171 if (sport->port.state) {

+1 -1

drivers/tty/serial/liteuart.c

reviewed

··· 152 152 153 153 static void liteuart_timer(struct timer_list *t) 154 154 { 155 155 - struct liteuart_port *uart = from_timer(uart, t, timer); 155 155 + struct liteuart_port *uart = timer_container_of(uart, t, timer); 156 156 struct uart_port *port = &uart->port; 157 157 158 158 liteuart_interrupt(0, port);

+1 -1

drivers/tty/serial/max3100.c

reviewed

··· 309 309 310 310 static void max3100_timeout(struct timer_list *t) 311 311 { 312 312 - struct max3100_port *s = from_timer(s, t, timer); 312 312 + struct max3100_port *s = timer_container_of(s, t, timer); 313 313 314 314 max3100_dowork(s); 315 315 mod_timer(&s->timer, jiffies + uart_poll_timeout(&s->port));

+1 -1

drivers/tty/serial/sa1100.c

reviewed

··· 111 111 */ 112 112 static void sa1100_timeout(struct timer_list *t) 113 113 { 114 114 - struct sa1100_port *sport = from_timer(sport, t, timer); 114 114 + struct sa1100_port *sport = timer_container_of(sport, t, timer); 115 115 unsigned long flags; 116 116 117 117 if (sport->port.state) {

+1 -1

drivers/tty/serial/sccnxp.c

reviewed

··· 500 500 501 501 static void sccnxp_timer(struct timer_list *t) 502 502 { 503 503 - struct sccnxp_port *s = from_timer(s, t, timer); 503 503 + struct sccnxp_port *s = timer_container_of(s, t, timer); 504 504 unsigned long flags; 505 505 506 506 spin_lock_irqsave(&s->lock, flags);

+1 -1

drivers/tty/serial/sh-sci.c

reviewed

··· 1120 1120 1121 1121 static void rx_fifo_timer_fn(struct timer_list *t) 1122 1122 { 1123 1123 - struct sci_port *s = from_timer(s, t, rx_fifo_timer); 1123 1123 + struct sci_port *s = timer_container_of(s, t, rx_fifo_timer); 1124 1124 struct uart_port *port = &s->port; 1125 1125 1126 1126 dev_dbg(port->dev, "Rx timed out\n");

+2 -2

drivers/tty/synclink_gt.c

reviewed

··· 5002 5002 */ 5003 5003 static void tx_timeout(struct timer_list *t) 5004 5004 { 5005 5005 - struct slgt_info *info = from_timer(info, t, tx_timer); 5005 5005 + struct slgt_info *info = timer_container_of(info, t, tx_timer); 5006 5006 unsigned long flags; 5007 5007 5008 5008 DBGINFO(("%s tx_timeout\n", info->device_name)); ··· 5026 5026 */ 5027 5027 static void rx_timeout(struct timer_list *t) 5028 5028 { 5029 5029 - struct slgt_info *info = from_timer(info, t, rx_timer); 5029 5029 + struct slgt_info *info = timer_container_of(info, t, rx_timer); 5030 5030 unsigned long flags; 5031 5031 5032 5032 DBGINFO(("%s rx_timeout\n", info->device_name));

+2 -1

drivers/tty/sysrq.c

reviewed

··· 712 712 713 713 static void sysrq_do_reset(struct timer_list *t) 714 714 { 715 715 - struct sysrq_state *state = from_timer(state, t, keyreset_timer); 715 715 + struct sysrq_state *state = timer_container_of(state, t, 716 716 + keyreset_timer); 716 717 717 718 state->reset_requested = true; 718 719

+2 -2

drivers/tty/vcc.c

reviewed

··· 356 356 357 357 static void vcc_rx_timer(struct timer_list *t) 358 358 { 359 359 - struct vcc_port *port = from_timer(port, t, rx_timer); 359 359 + struct vcc_port *port = timer_container_of(port, t, rx_timer); 360 360 struct vio_driver_state *vio; 361 361 unsigned long flags; 362 362 int rv; ··· 382 382 383 383 static void vcc_tx_timer(struct timer_list *t) 384 384 { 385 385 - struct vcc_port *port = from_timer(port, t, tx_timer); 385 385 + struct vcc_port *port = timer_container_of(port, t, tx_timer); 386 386 struct vio_vcc *pkt; 387 387 unsigned long flags; 388 388 size_t tosend = 0;

+1 -1

drivers/usb/atm/cxacru.c

reviewed

··· 582 582 583 583 static void cxacru_timeout_kill(struct timer_list *t) 584 584 { 585 585 - struct cxacru_timer *timer = from_timer(timer, t, timer); 585 585 + struct cxacru_timer *timer = timer_container_of(timer, t, timer); 586 586 587 587 usb_unlink_urb(timer->urb); 588 588 }

+6 -4

drivers/usb/atm/speedtch.c

reviewed

··· 559 559 560 560 static void speedtch_status_poll(struct timer_list *t) 561 561 { 562 562 - struct speedtch_instance_data *instance = from_timer(instance, t, 563 563 - status_check_timer); 562 562 + struct speedtch_instance_data *instance = timer_container_of(instance, 563 563 + t, 564 564 + status_check_timer); 564 565 565 566 schedule_work(&instance->status_check_work); 566 567 ··· 574 573 575 574 static void speedtch_resubmit_int(struct timer_list *t) 576 575 { 577 577 - struct speedtch_instance_data *instance = from_timer(instance, t, 578 578 - resubmit_timer); 576 576 + struct speedtch_instance_data *instance = timer_container_of(instance, 577 577 + t, 578 578 + resubmit_timer); 579 579 struct urb *int_urb = instance->int_urb; 580 580 int ret; 581 581

+1 -1

drivers/usb/atm/usbatm.c

reviewed

··· 993 993 994 994 static void usbatm_tasklet_schedule(struct timer_list *t) 995 995 { 996 996 - struct usbatm_channel *channel = from_timer(channel, t, delay); 996 996 + struct usbatm_channel *channel = timer_container_of(channel, t, delay); 997 997 998 998 tasklet_schedule(&channel->tasklet); 999 999 }

+1 -1

drivers/usb/core/hcd.c

reviewed

··· 775 775 /* timer callback */ 776 776 static void rh_timer_func (struct timer_list *t) 777 777 { 778 778 - struct usb_hcd *_hcd = from_timer(_hcd, t, rh_timer); 778 778 + struct usb_hcd *_hcd = timer_container_of(_hcd, t, rh_timer); 779 779 780 780 usb_hcd_poll_rh_status(_hcd); 781 781 }

+1 -1

drivers/usb/core/hub.c

reviewed

··· 697 697 698 698 static void hub_retry_irq_urb(struct timer_list *t) 699 699 { 700 700 - struct usb_hub *hub = from_timer(hub, t, irq_urb_retry); 700 700 + struct usb_hub *hub = timer_container_of(hub, t, irq_urb_retry); 701 701 702 702 hub_resubmit_irq_urb(hub); 703 703 }

+1 -1

drivers/usb/dwc2/hcd.c

reviewed

··· 3227 3227 3228 3228 static void dwc2_wakeup_detected(struct timer_list *t) 3229 3229 { 3230 3230 - struct dwc2_hsotg *hsotg = from_timer(hsotg, t, wkp_timer); 3230 3230 + struct dwc2_hsotg *hsotg = timer_container_of(hsotg, t, wkp_timer); 3231 3231 u32 hprt0; 3232 3232 3233 3233 dev_dbg(hsotg->dev, "%s()\n", __func__);

+1 -1

drivers/usb/dwc2/hcd_queue.c

reviewed

··· 1215 1215 */ 1216 1216 static void dwc2_unreserve_timer_fn(struct timer_list *t) 1217 1217 { 1218 1218 - struct dwc2_qh *qh = from_timer(qh, t, unreserve_timer); 1218 1218 + struct dwc2_qh *qh = timer_container_of(qh, t, unreserve_timer); 1219 1219 struct dwc2_hsotg *hsotg = qh->hsotg; 1220 1220 unsigned long flags; 1221 1221

+1 -1

drivers/usb/gadget/udc/at91_udc.c

reviewed

··· 1541 1541 1542 1542 static void at91_vbus_timer(struct timer_list *t) 1543 1543 { 1544 1544 - struct at91_udc *udc = from_timer(udc, t, vbus_timer); 1544 1544 + struct at91_udc *udc = timer_container_of(udc, t, vbus_timer); 1545 1545 1546 1546 /* 1547 1547 * If we are polling vbus it is likely that the gpio is on an

+2 -1

drivers/usb/gadget/udc/dummy_hcd.c

reviewed

··· 1787 1787 */ 1788 1788 static enum hrtimer_restart dummy_timer(struct hrtimer *t) 1789 1789 { 1790 1790 - struct dummy_hcd *dum_hcd = from_timer(dum_hcd, t, timer); 1790 1790 + struct dummy_hcd *dum_hcd = timer_container_of(dum_hcd, t, 1791 1791 + timer); 1791 1792 struct dummy *dum = dum_hcd->dum; 1792 1793 struct urbp *urbp, *tmp; 1793 1794 unsigned long flags;

+1 -1

drivers/usb/gadget/udc/m66592-udc.c

reviewed

··· 1261 1261 1262 1262 static void m66592_timer(struct timer_list *t) 1263 1263 { 1264 1264 - struct m66592 *m66592 = from_timer(m66592, t, timer); 1264 1264 + struct m66592 *m66592 = timer_container_of(m66592, t, timer); 1265 1265 unsigned long flags; 1266 1266 u16 tmp; 1267 1267

+1 -1

drivers/usb/gadget/udc/omap_udc.c

reviewed

··· 1860 1860 1861 1861 static void pio_out_timer(struct timer_list *t) 1862 1862 { 1863 1863 - struct omap_ep *ep = from_timer(ep, t, timer); 1863 1863 + struct omap_ep *ep = timer_container_of(ep, t, timer); 1864 1864 unsigned long flags; 1865 1865 u16 stat_flg; 1866 1866

+1 -1

drivers/usb/gadget/udc/pxa25x_udc.c

reviewed

··· 1574 1574 1575 1575 static void udc_watchdog(struct timer_list *t) 1576 1576 { 1577 1577 - struct pxa25x_udc *dev = from_timer(dev, t, timer); 1577 1577 + struct pxa25x_udc *dev = timer_container_of(dev, t, timer); 1578 1578 1579 1579 local_irq_disable(); 1580 1580 if (dev->ep0state == EP0_STALL

+1 -1

drivers/usb/gadget/udc/r8a66597-udc.c

reviewed

··· 1516 1516 1517 1517 static void r8a66597_timer(struct timer_list *t) 1518 1518 { 1519 1519 - struct r8a66597 *r8a66597 = from_timer(r8a66597, t, timer); 1519 1519 + struct r8a66597 *r8a66597 = timer_container_of(r8a66597, t, timer); 1520 1520 unsigned long flags; 1521 1521 u16 tmp; 1522 1522

+2 -1

drivers/usb/host/ehci-platform.c

reviewed

··· 198 198 199 199 static void quirk_poll_timer(struct timer_list *t) 200 200 { 201 201 - struct ehci_platform_priv *priv = from_timer(priv, t, poll_timer); 201 201 + struct ehci_platform_priv *priv = timer_container_of(priv, t, 202 202 + poll_timer); 202 203 struct ehci_hcd *ehci = container_of((void *)priv, struct ehci_hcd, 203 204 priv); 204 205

+2 -1

drivers/usb/host/ohci-hcd.c

reviewed

··· 746 746 */ 747 747 static void io_watchdog_func(struct timer_list *t) 748 748 { 749 749 - struct ohci_hcd *ohci = from_timer(ohci, t, io_watchdog); 749 749 + struct ohci_hcd *ohci = timer_container_of(ohci, t, 750 750 + io_watchdog); 750 751 bool takeback_all_pending = false; 751 752 u32 status; 752 753 u32 head;

+1 -1

drivers/usb/host/oxu210hp-hcd.c

reviewed

··· 2955 2955 2956 2956 static void oxu_watchdog(struct timer_list *t) 2957 2957 { 2958 2958 - struct oxu_hcd *oxu = from_timer(oxu, t, watchdog); 2958 2958 + struct oxu_hcd *oxu = timer_container_of(oxu, t, watchdog); 2959 2959 unsigned long flags; 2960 2960 2961 2961 spin_lock_irqsave(&oxu->lock, flags);

+4 -3

drivers/usb/host/r8a66597-hcd.c

reviewed

··· 1720 1720 1721 1721 static void r8a66597_interval_timer(struct timer_list *t) 1722 1722 { 1723 1723 - struct r8a66597_timers *timers = from_timer(timers, t, interval); 1723 1723 + struct r8a66597_timers *timers = timer_container_of(timers, t, 1724 1724 + interval); 1724 1725 struct r8a66597 *r8a66597 = timers->r8a66597; 1725 1726 unsigned long flags; 1726 1727 u16 pipenum; ··· 1745 1744 1746 1745 static void r8a66597_td_timer(struct timer_list *t) 1747 1746 { 1748 1748 - struct r8a66597_timers *timers = from_timer(timers, t, td); 1747 1747 + struct r8a66597_timers *timers = timer_container_of(timers, t, td); 1749 1748 struct r8a66597 *r8a66597 = timers->r8a66597; 1750 1749 unsigned long flags; 1751 1750 u16 pipenum; ··· 1799 1798 1800 1799 static void r8a66597_timer(struct timer_list *t) 1801 1800 { 1802 1802 - struct r8a66597 *r8a66597 = from_timer(r8a66597, t, rh_timer); 1801 1801 + struct r8a66597 *r8a66597 = timer_container_of(r8a66597, t, rh_timer); 1803 1802 unsigned long flags; 1804 1803 int port; 1805 1804

+1 -1

drivers/usb/host/sl811-hcd.c

reviewed

··· 1124 1124 static void 1125 1125 sl811h_timer(struct timer_list *t) 1126 1126 { 1127 1127 - struct sl811 *sl811 = from_timer(sl811, t, timer); 1127 1127 + struct sl811 *sl811 = timer_container_of(sl811, t, timer); 1128 1128 unsigned long flags; 1129 1129 u8 irqstat; 1130 1130 u8 signaling = sl811->ctrl1 & SL11H_CTL1MASK_FORCE;

+1 -1

drivers/usb/host/uhci-q.c

reviewed

··· 91 91 92 92 static void uhci_fsbr_timeout(struct timer_list *t) 93 93 { 94 94 - struct uhci_hcd *uhci = from_timer(uhci, t, fsbr_timer); 94 94 + struct uhci_hcd *uhci = timer_container_of(uhci, t, fsbr_timer); 95 95 unsigned long flags; 96 96 97 97 spin_lock_irqsave(&uhci->lock, flags);

+1 -1

drivers/usb/host/xen-hcd.c

reviewed

··· 1258 1258 1259 1259 static void xenhcd_watchdog(struct timer_list *timer) 1260 1260 { 1261 1261 - struct xenhcd_info *info = from_timer(info, timer, watchdog); 1261 1261 + struct xenhcd_info *info = timer_container_of(info, timer, watchdog); 1262 1262 unsigned long flags; 1263 1263 1264 1264 spin_lock_irqsave(&info->lock, flags);

+1 -1

drivers/usb/host/xhci.c

reviewed

··· 385 385 u32 temp; 386 386 int i; 387 387 388 388 - xhci = from_timer(xhci, t, comp_mode_recovery_timer); 388 388 + xhci = timer_container_of(xhci, t, comp_mode_recovery_timer); 389 389 rhub = &xhci->usb3_rhub; 390 390 hcd = rhub->hcd; 391 391

+1 -1

drivers/usb/isp1760/isp1760-udc.c

reviewed

··· 1423 1423 1424 1424 static void isp1760_udc_vbus_poll(struct timer_list *t) 1425 1425 { 1426 1426 - struct isp1760_udc *udc = from_timer(udc, t, vbus_timer); 1426 1426 + struct isp1760_udc *udc = timer_container_of(udc, t, vbus_timer); 1427 1427 unsigned long flags; 1428 1428 1429 1429 spin_lock_irqsave(&udc->lock, flags);

+1 -1

drivers/usb/misc/usbtest.c

reviewed

··· 592 592 593 593 static void sg_timeout(struct timer_list *t) 594 594 { 595 595 - struct sg_timeout *timeout = from_timer(timeout, t, timer); 595 595 + struct sg_timeout *timeout = timer_container_of(timeout, t, timer); 596 596 597 597 usb_sg_cancel(timeout->req); 598 598 }

+2 -1

drivers/usb/musb/da8xx.c

reviewed

··· 123 123 124 124 static void otg_timer(struct timer_list *t) 125 125 { 126 126 - struct musb *musb = from_timer(musb, t, dev_timer); 126 126 + struct musb *musb = timer_container_of(musb, t, 127 127 + dev_timer); 127 128 void __iomem *mregs = musb->mregs; 128 129 u8 devctl; 129 130 unsigned long flags;

+2 -1

drivers/usb/musb/mpfs.c

reviewed

··· 91 91 92 92 static void otg_timer(struct timer_list *t) 93 93 { 94 94 - struct musb *musb = from_timer(musb, t, dev_timer); 94 94 + struct musb *musb = timer_container_of(musb, t, 95 95 + dev_timer); 95 96 void __iomem *mregs = musb->mregs; 96 97 u8 devctl; 97 98 unsigned long flags;

+1 -1

drivers/usb/musb/musb_core.c

reviewed

··· 596 596 */ 597 597 static void musb_otg_timer_func(struct timer_list *t) 598 598 { 599 599 - struct musb *musb = from_timer(musb, t, otg_timer); 599 599 + struct musb *musb = timer_container_of(musb, t, otg_timer); 600 600 unsigned long flags; 601 601 602 602 spin_lock_irqsave(&musb->lock, flags);

+1 -1

drivers/usb/musb/musb_dsps.c

reviewed

··· 278 278 279 279 static void otg_timer(struct timer_list *t) 280 280 { 281 281 - struct musb *musb = from_timer(musb, t, dev_timer); 281 281 + struct musb *musb = timer_container_of(musb, t, dev_timer); 282 282 struct device *dev = musb->controller; 283 283 unsigned long flags; 284 284 int err;

+1 -1

drivers/usb/musb/tusb6010.c

reviewed

··· 457 457 458 458 static void musb_do_idle(struct timer_list *t) 459 459 { 460 460 - struct musb *musb = from_timer(musb, t, dev_timer); 460 460 + struct musb *musb = timer_container_of(musb, t, dev_timer); 461 461 unsigned long flags; 462 462 463 463 spin_lock_irqsave(&musb->lock, flags);

+2 -1

drivers/usb/serial/garmin_gps.c

reviewed

··· 1357 1357 */ 1358 1358 static void timeout_handler(struct timer_list *t) 1359 1359 { 1360 1360 - struct garmin_data *garmin_data_p = from_timer(garmin_data_p, t, timer); 1360 1360 + struct garmin_data *garmin_data_p = timer_container_of(garmin_data_p, 1361 1361 + t, timer); 1361 1362 1362 1363 /* send the next queued packet to the tty port */ 1363 1364 if (garmin_data_p->mode == MODE_NATIVE)

+2 -2

drivers/usb/serial/mos7840.c

reviewed

··· 383 383 384 384 static void mos7840_led_off(struct timer_list *t) 385 385 { 386 386 - struct moschip_port *mcs = from_timer(mcs, t, led_timer1); 386 386 + struct moschip_port *mcs = timer_container_of(mcs, t, led_timer1); 387 387 388 388 /* Turn off LED */ 389 389 mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER); ··· 393 393 394 394 static void mos7840_led_flag_off(struct timer_list *t) 395 395 { 396 396 - struct moschip_port *mcs = from_timer(mcs, t, led_timer2); 396 396 + struct moschip_port *mcs = timer_container_of(mcs, t, led_timer2); 397 397 398 398 clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags); 399 399 }

+2 -1

drivers/usb/storage/realtek_cr.c

reviewed

··· 754 754 755 755 static void rts51x_suspend_timer_fn(struct timer_list *t) 756 756 { 757 757 - struct rts51x_chip *chip = from_timer(chip, t, rts51x_suspend_timer); 757 757 + struct rts51x_chip *chip = timer_container_of(chip, t, 758 758 + rts51x_suspend_timer); 758 759 struct us_data *us = chip->us; 759 760 760 761 switch (rts51x_get_stat(chip)) {

+1 -1

drivers/usb/usbip/vudc_transfer.c

reviewed

··· 301 301 302 302 static void v_timer(struct timer_list *t) 303 303 { 304 304 - struct vudc *udc = from_timer(udc, t, tr_timer.timer); 304 304 + struct vudc *udc = timer_container_of(udc, t, tr_timer.timer); 305 305 struct transfer_timer *timer = &udc->tr_timer; 306 306 struct urbp *urb_p, *tmp; 307 307 unsigned long flags;

+1 -1

drivers/video/fbdev/aty/radeon_base.c

reviewed

··· 1443 1443 */ 1444 1444 static void radeon_lvds_timer_func(struct timer_list *t) 1445 1445 { 1446 1446 - struct radeonfb_info *rinfo = from_timer(rinfo, t, lvds_timer); 1446 1446 + struct radeonfb_info *rinfo = timer_container_of(rinfo, t, lvds_timer); 1447 1447 1448 1448 radeon_engine_idle(); 1449 1449

+1 -1

drivers/virt/vboxguest/vboxguest_core.c

reviewed

··· 419 419 */ 420 420 static void vbg_heartbeat_timer(struct timer_list *t) 421 421 { 422 422 - struct vbg_dev *gdev = from_timer(gdev, t, heartbeat_timer); 422 422 + struct vbg_dev *gdev = timer_container_of(gdev, t, heartbeat_timer); 423 423 424 424 vbg_req_perform(gdev, gdev->guest_heartbeat_req); 425 425 mod_timer(&gdev->heartbeat_timer,

+1 -1

drivers/watchdog/at91sam9_wdt.c

reviewed

··· 119 119 */ 120 120 static void at91_ping(struct timer_list *t) 121 121 { 122 122 - struct at91wdt *wdt = from_timer(wdt, t, timer); 122 122 + struct at91wdt *wdt = timer_container_of(wdt, t, timer); 123 123 if (time_before(jiffies, wdt->next_heartbeat) || 124 124 !watchdog_active(&wdt->wdd)) { 125 125 at91_wdt_reset(wdt);

+1 -1

drivers/watchdog/bcm47xx_wdt.c

reviewed

··· 105 105 106 106 static void bcm47xx_wdt_soft_timer_tick(struct timer_list *t) 107 107 { 108 108 - struct bcm47xx_wdt *wdt = from_timer(wdt, t, soft_timer); 108 108 + struct bcm47xx_wdt *wdt = timer_container_of(wdt, t, soft_timer); 109 109 u32 next_tick = min(wdt->wdd.timeout * 1000, wdt->max_timer_ms); 110 110 111 111 if (!atomic_dec_and_test(&wdt->soft_ticks)) {

+2 -1

drivers/watchdog/lpc18xx_wdt.c

reviewed

··· 77 77 78 78 static void lpc18xx_wdt_timer_feed(struct timer_list *t) 79 79 { 80 80 - struct lpc18xx_wdt_dev *lpc18xx_wdt = from_timer(lpc18xx_wdt, t, timer); 80 80 + struct lpc18xx_wdt_dev *lpc18xx_wdt = timer_container_of(lpc18xx_wdt, 81 81 + t, timer); 81 82 struct watchdog_device *wdt_dev = &lpc18xx_wdt->wdt_dev; 82 83 83 84 lpc18xx_wdt_feed(wdt_dev);

+1 -1

drivers/watchdog/shwdt.c

reviewed

··· 173 173 174 174 static void sh_wdt_ping(struct timer_list *t) 175 175 { 176 176 - struct sh_wdt *wdt = from_timer(wdt, t, timer); 176 176 + struct sh_wdt *wdt = timer_container_of(wdt, t, timer); 177 177 unsigned long flags; 178 178 179 179 spin_lock_irqsave(&wdt->lock, flags);

+1 -1

fs/dlm/lock.c

reviewed

··· 509 509 510 510 void dlm_rsb_scan(struct timer_list *timer) 511 511 { 512 512 - struct dlm_ls *ls = from_timer(ls, timer, ls_scan_timer); 512 512 + struct dlm_ls *ls = timer_container_of(ls, timer, ls_scan_timer); 513 513 int our_nodeid = dlm_our_nodeid(); 514 514 struct dlm_rsb *r; 515 515 int rv;

+1 -1

fs/ext4/super.c

reviewed

··· 3627 3627 */ 3628 3628 static void print_daily_error_info(struct timer_list *t) 3629 3629 { 3630 3630 - struct ext4_sb_info *sbi = from_timer(sbi, t, s_err_report); 3630 3630 + struct ext4_sb_info *sbi = timer_container_of(sbi, t, s_err_report); 3631 3631 struct super_block *sb = sbi->s_sb; 3632 3632 struct ext4_super_block *es = sbi->s_es; 3633 3633

+1 -1

fs/jbd2/journal.c

reviewed

··· 134 134 135 135 static void commit_timeout(struct timer_list *t) 136 136 { 137 137 - journal_t *journal = from_timer(journal, t, j_commit_timer); 137 137 + journal_t *journal = timer_container_of(journal, t, j_commit_timer); 138 138 139 139 wake_up_process(journal->j_task); 140 140 }

+1 -1

fs/nilfs2/segment.c

reviewed

··· 2485 2485 2486 2486 static void nilfs_construction_timeout(struct timer_list *t) 2487 2487 { 2488 2488 - struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer); 2488 2488 + struct nilfs_sc_info *sci = timer_container_of(sci, t, sc_timer); 2489 2489 2490 2490 wake_up_process(sci->sc_task); 2491 2491 }

+2 -1

fs/ocfs2/cluster/tcp.c

reviewed

··· 1488 1488 * where shutdown is going to be involved */ 1489 1489 static void o2net_idle_timer(struct timer_list *t) 1490 1490 { 1491 1491 - struct o2net_sock_container *sc = from_timer(sc, t, sc_idle_timeout); 1491 1491 + struct o2net_sock_container *sc = timer_container_of(sc, t, 1492 1492 + sc_idle_timeout); 1492 1493 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); 1493 1494 #ifdef CONFIG_DEBUG_FS 1494 1495 unsigned long msecs = ktime_to_ms(ktime_get()) -

+1 -1

include/linux/timer.h

reviewed

··· 129 129 static inline void timer_destroy_on_stack(struct timer_list *timer) { } 130 130 #endif 131 131 132 132 - #define from_timer(var, callback_timer, timer_fieldname) \ 132 132 + #define timer_container_of(var, callback_timer, timer_fieldname) \ 133 133 container_of(callback_timer, typeof(*var), timer_fieldname) 134 134 135 135 /**

+2 -1

kernel/kthread.c

reviewed

··· 1207 1207 */ 1208 1208 void kthread_delayed_work_timer_fn(struct timer_list *t) 1209 1209 { 1210 1210 - struct kthread_delayed_work *dwork = from_timer(dwork, t, timer); 1210 1210 + struct kthread_delayed_work *dwork = timer_container_of(dwork, t, 1211 1211 + timer); 1211 1212 struct kthread_work *work = &dwork->work; 1212 1213 struct kthread_worker *worker = work->worker; 1213 1214 unsigned long flags;

+2 -1

kernel/rcu/tasks.h

reviewed

··· 316 316 unsigned long flags; 317 317 bool needwake = false; 318 318 struct rcu_tasks *rtp; 319 319 - struct rcu_tasks_percpu *rtpcp = from_timer(rtpcp, tlp, lazy_timer); 319 319 + struct rcu_tasks_percpu *rtpcp = timer_container_of(rtpcp, tlp, 320 320 + lazy_timer); 320 321 321 322 rtp = rtpcp->rtpp; 322 323 raw_spin_lock_irqsave_rcu_node(rtpcp, flags);

+1 -1

kernel/rcu/tree_nocb.h

reviewed

··· 985 985 static void do_nocb_deferred_wakeup_timer(struct timer_list *t) 986 986 { 987 987 unsigned long flags; 988 988 - struct rcu_data *rdp = from_timer(rdp, t, nocb_timer); 988 988 + struct rcu_data *rdp = timer_container_of(rdp, t, nocb_timer); 989 989 990 990 WARN_ON_ONCE(rdp->nocb_gp_rdp != rdp); 991 991 trace_rcu_nocb_wake(rcu_state.name, rdp->cpu, TPS("Timer"));

+1 -1

kernel/sched/psi.c

reviewed

··· 733 733 734 734 static void poll_timer_fn(struct timer_list *t) 735 735 { 736 736 - struct psi_group *group = from_timer(group, t, rtpoll_timer); 736 736 + struct psi_group *group = timer_container_of(group, t, rtpoll_timer); 737 737 738 738 atomic_set(&group->rtpoll_wakeup, 1); 739 739 wake_up_interruptible(&group->rtpoll_wait);

+1 -1

kernel/time/sleep_timeout.c

reviewed

··· 22 22 23 23 static void process_timeout(struct timer_list *t) 24 24 { 25 25 - struct process_timer *timeout = from_timer(timeout, t, timer); 25 25 + struct process_timer *timeout = timer_container_of(timeout, t, timer); 26 26 27 27 wake_up_process(timeout->task); 28 28 }

+3 -3

kernel/workqueue.c

reviewed

··· 2481 2481 2482 2482 void delayed_work_timer_fn(struct timer_list *t) 2483 2483 { 2484 2484 - struct delayed_work *dwork = from_timer(dwork, t, timer); 2484 2484 + struct delayed_work *dwork = timer_container_of(dwork, t, timer); 2485 2485 2486 2486 /* should have been called from irqsafe timer with irq already off */ 2487 2487 __queue_work(dwork->cpu, dwork->wq, &dwork->work); ··· 2909 2909 */ 2910 2910 static void idle_worker_timeout(struct timer_list *t) 2911 2911 { 2912 2912 - struct worker_pool *pool = from_timer(pool, t, idle_timer); 2912 2912 + struct worker_pool *pool = timer_container_of(pool, t, idle_timer); 2913 2913 bool do_cull = false; 2914 2914 2915 2915 if (work_pending(&pool->idle_cull_work)) ··· 3008 3008 3009 3009 static void pool_mayday_timeout(struct timer_list *t) 3010 3010 { 3011 3011 - struct worker_pool *pool = from_timer(pool, t, mayday_timer); 3011 3011 + struct worker_pool *pool = timer_container_of(pool, t, mayday_timer); 3012 3012 struct work_struct *work; 3013 3013 3014 3014 raw_spin_lock_irq(&pool->lock);

+2 -2

mm/page-writeback.c

reviewed

··· 608 608 */ 609 609 static void writeout_period(struct timer_list *t) 610 610 { 611 611 - struct wb_domain *dom = from_timer(dom, t, period_timer); 611 611 + struct wb_domain *dom = timer_container_of(dom, t, period_timer); 612 612 int miss_periods = (jiffies - dom->period_time) / 613 613 VM_COMPLETIONS_PERIOD_LEN; 614 614 ··· 2203 2203 void laptop_mode_timer_fn(struct timer_list *t) 2204 2204 { 2205 2205 struct backing_dev_info *backing_dev_info = 2206 2206 - from_timer(backing_dev_info, t, laptop_mode_wb_timer); 2206 2206 + timer_container_of(backing_dev_info, t, laptop_mode_wb_timer); 2207 2207 2208 2208 wakeup_flusher_threads_bdi(backing_dev_info, WB_REASON_LAPTOP_TIMER); 2209 2209 }

+1 -1

net/802/garp.c

reviewed

··· 414 414 415 415 static void garp_join_timer(struct timer_list *t) 416 416 { 417 417 - struct garp_applicant *app = from_timer(app, t, join_timer); 417 417 + struct garp_applicant *app = timer_container_of(app, t, join_timer); 418 418 419 419 spin_lock(&app->lock); 420 420 garp_gid_event(app, GARP_EVENT_TRANSMIT_PDU);

+2 -2

net/802/mrp.c

reviewed

··· 599 599 600 600 static void mrp_join_timer(struct timer_list *t) 601 601 { 602 602 - struct mrp_applicant *app = from_timer(app, t, join_timer); 602 602 + struct mrp_applicant *app = timer_container_of(app, t, join_timer); 603 603 604 604 spin_lock(&app->lock); 605 605 mrp_mad_event(app, MRP_EVENT_TX); ··· 621 621 622 622 static void mrp_periodic_timer(struct timer_list *t) 623 623 { 624 624 - struct mrp_applicant *app = from_timer(app, t, periodic_timer); 624 624 + struct mrp_applicant *app = timer_container_of(app, t, periodic_timer); 625 625 626 626 spin_lock(&app->lock); 627 627 if (likely(app->active)) {

+1 -1

net/appletalk/ddp.c

reviewed

··· 169 169 170 170 static void atalk_destroy_timer(struct timer_list *t) 171 171 { 172 172 - struct sock *sk = from_timer(sk, t, sk_timer); 172 172 + struct sock *sk = timer_container_of(sk, t, sk_timer); 173 173 174 174 if (sk_has_allocations(sk)) { 175 175 sk->sk_timer.expires = jiffies + SOCK_DESTROY_TIME;

+3 -2

net/atm/lec.c

reviewed

··· 1551 1551 { 1552 1552 struct lec_arp_table *entry; 1553 1553 1554 1554 - entry = from_timer(entry, t, timer); 1554 1554 + entry = timer_container_of(entry, t, timer); 1555 1555 1556 1556 pr_debug("\n"); 1557 1557 if (entry->status == ESI_ARP_PENDING) { ··· 1572 1572 static void lec_arp_expire_vcc(struct timer_list *t) 1573 1573 { 1574 1574 unsigned long flags; 1575 1575 - struct lec_arp_table *to_remove = from_timer(to_remove, t, timer); 1575 1575 + struct lec_arp_table *to_remove = timer_container_of(to_remove, t, 1576 1576 + timer); 1576 1577 struct lec_priv *priv = to_remove->priv; 1577 1578 1578 1579 timer_delete(&to_remove->timer);

+1 -1

net/ax25/af_ax25.c

reviewed

··· 287 287 */ 288 288 static void ax25_destroy_timer(struct timer_list *t) 289 289 { 290 290 - ax25_cb *ax25 = from_timer(ax25, t, dtimer); 290 290 + ax25_cb *ax25 = timer_container_of(ax25, t, dtimer); 291 291 struct sock *sk; 292 292 293 293 sk=ax25->sk;

+1 -1

net/ax25/ax25_ds_timer.c

reviewed

··· 64 64 65 65 static void ax25_ds_timeout(struct timer_list *t) 66 66 { 67 67 - ax25_dev *ax25_dev = from_timer(ax25_dev, t, dama.slave_timer); 67 67 + ax25_dev *ax25_dev = timer_container_of(ax25_dev, t, dama.slave_timer); 68 68 ax25_cb *ax25; 69 69 70 70 if (ax25_dev == NULL || !ax25_dev->dama.slave)

+5 -5

net/ax25/ax25_timer.c

reviewed

··· 121 121 static void ax25_heartbeat_expiry(struct timer_list *t) 122 122 { 123 123 int proto = AX25_PROTO_STD_SIMPLEX; 124 124 - ax25_cb *ax25 = from_timer(ax25, t, timer); 124 124 + ax25_cb *ax25 = timer_container_of(ax25, t, timer); 125 125 126 126 if (ax25->ax25_dev) 127 127 proto = ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]; ··· 145 145 146 146 static void ax25_t1timer_expiry(struct timer_list *t) 147 147 { 148 148 - ax25_cb *ax25 = from_timer(ax25, t, t1timer); 148 148 + ax25_cb *ax25 = timer_container_of(ax25, t, t1timer); 149 149 150 150 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 151 151 case AX25_PROTO_STD_SIMPLEX: ··· 164 164 165 165 static void ax25_t2timer_expiry(struct timer_list *t) 166 166 { 167 167 - ax25_cb *ax25 = from_timer(ax25, t, t2timer); 167 167 + ax25_cb *ax25 = timer_container_of(ax25, t, t2timer); 168 168 169 169 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 170 170 case AX25_PROTO_STD_SIMPLEX: ··· 183 183 184 184 static void ax25_t3timer_expiry(struct timer_list *t) 185 185 { 186 186 - ax25_cb *ax25 = from_timer(ax25, t, t3timer); 186 186 + ax25_cb *ax25 = timer_container_of(ax25, t, t3timer); 187 187 188 188 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 189 189 case AX25_PROTO_STD_SIMPLEX: ··· 204 204 205 205 static void ax25_idletimer_expiry(struct timer_list *t) 206 206 { 207 207 - ax25_cb *ax25 = from_timer(ax25, t, idletimer); 207 207 + ax25_cb *ax25 = timer_container_of(ax25, t, idletimer); 208 208 209 209 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 210 210 case AX25_PROTO_STD_SIMPLEX:

+2 -2

net/batman-adv/tp_meter.c

reviewed

··· 485 485 */ 486 486 static void batadv_tp_sender_timeout(struct timer_list *t) 487 487 { 488 488 - struct batadv_tp_vars *tp_vars = from_timer(tp_vars, t, timer); 488 488 + struct batadv_tp_vars *tp_vars = timer_container_of(tp_vars, t, timer); 489 489 struct batadv_priv *bat_priv = tp_vars->bat_priv; 490 490 491 491 if (atomic_read(&tp_vars->sending) == 0) ··· 1101 1101 */ 1102 1102 static void batadv_tp_receiver_shutdown(struct timer_list *t) 1103 1103 { 1104 1104 - struct batadv_tp_vars *tp_vars = from_timer(tp_vars, t, timer); 1104 1104 + struct batadv_tp_vars *tp_vars = timer_container_of(tp_vars, t, timer); 1105 1105 struct batadv_tp_unacked *un, *safe; 1106 1106 struct batadv_priv *bat_priv; 1107 1107

+1 -1

net/bluetooth/hidp/core.c

reviewed

··· 405 405 406 406 static void hidp_idle_timeout(struct timer_list *t) 407 407 { 408 408 - struct hidp_session *session = from_timer(session, t, timer); 408 408 + struct hidp_session *session = timer_container_of(session, t, timer); 409 409 410 410 /* The HIDP user-space API only contains calls to add and remove 411 411 * devices. There is no way to forward events of any kind. Therefore,

+2 -2

net/bluetooth/rfcomm/core.c

reviewed

··· 235 235 236 236 static void rfcomm_session_timeout(struct timer_list *t) 237 237 { 238 238 - struct rfcomm_session *s = from_timer(s, t, timer); 238 238 + struct rfcomm_session *s = timer_container_of(s, t, timer); 239 239 240 240 BT_DBG("session %p state %ld", s, s->state); 241 241 ··· 260 260 /* ---- RFCOMM DLCs ---- */ 261 261 static void rfcomm_dlc_timeout(struct timer_list *t) 262 262 { 263 263 - struct rfcomm_dlc *d = from_timer(d, t, timer); 263 263 + struct rfcomm_dlc *d = timer_container_of(d, t, timer); 264 264 265 265 BT_DBG("dlc %p state %ld", d, d->state); 266 266

+25 -24

net/bridge/br_multicast.c

reviewed

··· 648 648 649 649 static void br_multicast_group_expired(struct timer_list *t) 650 650 { 651 651 - struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer); 651 651 + struct net_bridge_mdb_entry *mp = timer_container_of(mp, t, timer); 652 652 struct net_bridge *br = mp->br; 653 653 654 654 spin_lock(&br->multicast_lock); ··· 856 856 857 857 static void br_multicast_port_group_expired(struct timer_list *t) 858 858 { 859 859 - struct net_bridge_port_group *pg = from_timer(pg, t, timer); 859 859 + struct net_bridge_port_group *pg = timer_container_of(pg, t, timer); 860 860 struct net_bridge_group_src *src_ent; 861 861 struct net_bridge *br = pg->key.port->br; 862 862 struct hlist_node *tmp; ··· 1314 1314 1315 1315 static void br_multicast_group_src_expired(struct timer_list *t) 1316 1316 { 1317 1317 - struct net_bridge_group_src *src = from_timer(src, t, timer); 1317 1317 + struct net_bridge_group_src *src = timer_container_of(src, t, timer); 1318 1318 struct net_bridge_port_group *pg; 1319 1319 struct net_bridge *br = src->br; 1320 1320 ··· 1667 1667 1668 1668 static void br_ip4_multicast_router_expired(struct timer_list *t) 1669 1669 { 1670 1670 - struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t, 1671 1671 - ip4_mc_router_timer); 1670 1670 + struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1671 1671 + ip4_mc_router_timer); 1672 1672 1673 1673 br_multicast_router_expired(pmctx, t, &pmctx->ip4_rlist); 1674 1674 } ··· 1676 1676 #if IS_ENABLED(CONFIG_IPV6) 1677 1677 static void br_ip6_multicast_router_expired(struct timer_list *t) 1678 1678 { 1679 1679 - struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t, 1680 1680 - ip6_mc_router_timer); 1679 1679 + struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1680 1680 + ip6_mc_router_timer); 1681 1681 1682 1682 br_multicast_router_expired(pmctx, t, &pmctx->ip6_rlist); 1683 1683 } ··· 1713 1713 1714 1714 static void br_ip4_multicast_local_router_expired(struct timer_list *t) 1715 1715 { 1716 1716 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 1717 1717 - ip4_mc_router_timer); 1716 1716 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1717 1717 + ip4_mc_router_timer); 1718 1718 1719 1719 br_multicast_local_router_expired(brmctx, t); 1720 1720 } ··· 1722 1722 #if IS_ENABLED(CONFIG_IPV6) 1723 1723 static void br_ip6_multicast_local_router_expired(struct timer_list *t) 1724 1724 { 1725 1725 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 1726 1726 - ip6_mc_router_timer); 1725 1725 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1726 1726 + ip6_mc_router_timer); 1727 1727 1728 1728 br_multicast_local_router_expired(brmctx, t); 1729 1729 } ··· 1746 1746 1747 1747 static void br_ip4_multicast_querier_expired(struct timer_list *t) 1748 1748 { 1749 1749 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 1750 1750 - ip4_other_query.timer); 1749 1749 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1750 1750 + ip4_other_query.timer); 1751 1751 1752 1752 br_multicast_querier_expired(brmctx, &brmctx->ip4_own_query); 1753 1753 } ··· 1755 1755 #if IS_ENABLED(CONFIG_IPV6) 1756 1756 static void br_ip6_multicast_querier_expired(struct timer_list *t) 1757 1757 { 1758 1758 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 1759 1759 - ip6_other_query.timer); 1758 1758 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 1759 1759 + ip6_other_query.timer); 1760 1760 1761 1761 br_multicast_querier_expired(brmctx, &brmctx->ip6_own_query); 1762 1762 } ··· 1918 1918 1919 1919 static void br_ip4_multicast_port_query_expired(struct timer_list *t) 1920 1920 { 1921 1921 - struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t, 1922 1922 - ip4_own_query.timer); 1921 1921 + struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1922 1922 + ip4_own_query.timer); 1923 1923 1924 1924 br_multicast_port_query_expired(pmctx, &pmctx->ip4_own_query); 1925 1925 } ··· 1927 1927 #if IS_ENABLED(CONFIG_IPV6) 1928 1928 static void br_ip6_multicast_port_query_expired(struct timer_list *t) 1929 1929 { 1930 1930 - struct net_bridge_mcast_port *pmctx = from_timer(pmctx, t, 1931 1931 - ip6_own_query.timer); 1930 1930 + struct net_bridge_mcast_port *pmctx = timer_container_of(pmctx, t, 1931 1931 + ip6_own_query.timer); 1932 1932 1933 1933 br_multicast_port_query_expired(pmctx, &pmctx->ip6_own_query); 1934 1934 } ··· 1936 1936 1937 1937 static void br_multicast_port_group_rexmit(struct timer_list *t) 1938 1938 { 1939 1939 - struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer); 1939 1939 + struct net_bridge_port_group *pg = timer_container_of(pg, t, 1940 1940 + rexmit_timer); 1940 1941 struct bridge_mcast_other_query *other_query = NULL; 1941 1942 struct net_bridge *br = pg->key.port->br; 1942 1943 struct net_bridge_mcast_port *pmctx; ··· 4057 4056 4058 4057 static void br_ip4_multicast_query_expired(struct timer_list *t) 4059 4058 { 4060 4060 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 4061 4061 - ip4_own_query.timer); 4059 4059 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 4060 4060 + ip4_own_query.timer); 4062 4061 4063 4062 br_multicast_query_expired(brmctx, &brmctx->ip4_own_query, 4064 4063 &brmctx->ip4_querier); ··· 4067 4066 #if IS_ENABLED(CONFIG_IPV6) 4068 4067 static void br_ip6_multicast_query_expired(struct timer_list *t) 4069 4068 { 4070 4070 - struct net_bridge_mcast *brmctx = from_timer(brmctx, t, 4071 4071 - ip6_own_query.timer); 4069 4069 + struct net_bridge_mcast *brmctx = timer_container_of(brmctx, t, 4070 4070 + ip6_own_query.timer); 4072 4071 4073 4072 br_multicast_query_expired(brmctx, &brmctx->ip6_own_query, 4074 4073 &brmctx->ip6_querier);

+6 -3

net/bridge/br_multicast_eht.c

reviewed

··· 207 207 208 208 static void br_multicast_eht_set_entry_expired(struct timer_list *t) 209 209 { 210 210 - struct net_bridge_group_eht_set_entry *set_h = from_timer(set_h, t, timer); 210 210 + struct net_bridge_group_eht_set_entry *set_h = timer_container_of(set_h, 211 211 + t, 212 212 + timer); 211 213 struct net_bridge *br = set_h->br; 212 214 213 215 spin_lock(&br->multicast_lock); ··· 225 223 226 224 static void br_multicast_eht_set_expired(struct timer_list *t) 227 225 { 228 228 - struct net_bridge_group_eht_set *eht_set = from_timer(eht_set, t, 229 229 - timer); 226 226 + struct net_bridge_group_eht_set *eht_set = timer_container_of(eht_set, 227 227 + t, 228 228 + timer); 230 229 struct net_bridge *br = eht_set->br; 231 230 232 231 spin_lock(&br->multicast_lock);

+9 -6

net/bridge/br_stp_timer.c

reviewed

··· 29 29 30 30 static void br_hello_timer_expired(struct timer_list *t) 31 31 { 32 32 - struct net_bridge *br = from_timer(br, t, hello_timer); 32 32 + struct net_bridge *br = timer_container_of(br, t, hello_timer); 33 33 34 34 br_debug(br, "hello timer expired\n"); 35 35 spin_lock(&br->lock); ··· 45 45 46 46 static void br_message_age_timer_expired(struct timer_list *t) 47 47 { 48 48 - struct net_bridge_port *p = from_timer(p, t, message_age_timer); 48 48 + struct net_bridge_port *p = timer_container_of(p, t, 49 49 + message_age_timer); 49 50 struct net_bridge *br = p->br; 50 51 const bridge_id *id = &p->designated_bridge; 51 52 int was_root; ··· 79 78 80 79 static void br_forward_delay_timer_expired(struct timer_list *t) 81 80 { 82 82 - struct net_bridge_port *p = from_timer(p, t, forward_delay_timer); 81 81 + struct net_bridge_port *p = timer_container_of(p, t, 82 82 + forward_delay_timer); 83 83 struct net_bridge *br = p->br; 84 84 85 85 br_debug(br, "port %u(%s) forward delay timer\n", ··· 104 102 105 103 static void br_tcn_timer_expired(struct timer_list *t) 106 104 { 107 107 - struct net_bridge *br = from_timer(br, t, tcn_timer); 105 105 + struct net_bridge *br = timer_container_of(br, t, tcn_timer); 108 106 109 107 br_debug(br, "tcn timer expired\n"); 110 108 spin_lock(&br->lock); ··· 118 116 119 117 static void br_topology_change_timer_expired(struct timer_list *t) 120 118 { 121 121 - struct net_bridge *br = from_timer(br, t, topology_change_timer); 119 119 + struct net_bridge *br = timer_container_of(br, t, 120 120 + topology_change_timer); 122 121 123 122 br_debug(br, "topo change timer expired\n"); 124 123 spin_lock(&br->lock); ··· 130 127 131 128 static void br_hold_timer_expired(struct timer_list *t) 132 129 { 133 133 - struct net_bridge_port *p = from_timer(p, t, hold_timer); 130 130 + struct net_bridge_port *p = timer_container_of(p, t, hold_timer); 134 131 135 132 br_debug(p->br, "port %u(%s) hold timer expired\n", 136 133 (unsigned int) p->port_no, p->dev->name);

+1 -1

net/can/proc.c

reviewed

··· 114 114 115 115 void can_stat_update(struct timer_list *t) 116 116 { 117 117 - struct net *net = from_timer(net, t, can.stattimer); 117 117 + struct net *net = timer_container_of(net, t, can.stattimer); 118 118 struct can_pkg_stats *pkg_stats = net->can.pkg_stats; 119 119 unsigned long j = jiffies; /* snapshot */ 120 120

+1 -1

net/core/drop_monitor.c

reviewed

··· 208 208 */ 209 209 static void sched_send_work(struct timer_list *t) 210 210 { 211 211 - struct per_cpu_dm_data *data = from_timer(data, t, send_timer); 211 211 + struct per_cpu_dm_data *data = timer_container_of(data, t, send_timer); 212 212 213 213 schedule_work(&data->dm_alert_work); 214 214 }

+1 -1

net/core/gen_estimator.c

reviewed

··· 75 75 76 76 static void est_timer(struct timer_list *t) 77 77 { 78 78 - struct net_rate_estimator *est = from_timer(est, t, timer); 78 78 + struct net_rate_estimator *est = timer_container_of(est, t, timer); 79 79 struct gnet_stats_basic_sync b; 80 80 u64 b_bytes, b_packets; 81 81 u64 rate, brate;

+2 -2

net/core/neighbour.c

reviewed

··· 1031 1031 static void neigh_timer_handler(struct timer_list *t) 1032 1032 { 1033 1033 unsigned long now, next; 1034 1034 - struct neighbour *neigh = from_timer(neigh, t, timer); 1034 1034 + struct neighbour *neigh = timer_container_of(neigh, t, timer); 1035 1035 unsigned int state; 1036 1036 int notify = 0; 1037 1037 ··· 1569 1569 1570 1570 static void neigh_proxy_process(struct timer_list *t) 1571 1571 { 1572 1572 - struct neigh_table *tbl = from_timer(tbl, t, proxy_timer); 1572 1572 + struct neigh_table *tbl = timer_container_of(tbl, t, proxy_timer); 1573 1573 long sched_next = 0; 1574 1574 unsigned long now = jiffies; 1575 1575 struct sk_buff *skb, *n;

+1 -1

net/ethtool/mm.c

reviewed

··· 315 315 */ 316 316 static void ethtool_mmsv_verify_timer(struct timer_list *t) 317 317 { 318 318 - struct ethtool_mmsv *mmsv = from_timer(mmsv, t, verify_timer); 318 318 + struct ethtool_mmsv *mmsv = timer_container_of(mmsv, t, verify_timer); 319 319 unsigned long flags; 320 320 bool rearm = false; 321 321

+3 -2

net/hsr/hsr_device.c

reviewed

··· 408 408 struct hsr_port *master; 409 409 unsigned long interval; 410 410 411 411 - hsr = from_timer(hsr, t, announce_timer); 411 411 + hsr = timer_container_of(hsr, t, announce_timer); 412 412 413 413 rcu_read_lock(); 414 414 master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); ··· 424 424 */ 425 425 static void hsr_proxy_announce(struct timer_list *t) 426 426 { 427 427 - struct hsr_priv *hsr = from_timer(hsr, t, announce_proxy_timer); 427 427 + struct hsr_priv *hsr = timer_container_of(hsr, t, 428 428 + announce_proxy_timer); 428 429 struct hsr_port *interlink; 429 430 unsigned long interval = 0; 430 431 struct hsr_node *node;

+2 -2

net/hsr/hsr_framereg.c

reviewed

··· 617 617 */ 618 618 void hsr_prune_nodes(struct timer_list *t) 619 619 { 620 620 - struct hsr_priv *hsr = from_timer(hsr, t, prune_timer); 620 620 + struct hsr_priv *hsr = timer_container_of(hsr, t, prune_timer); 621 621 struct hsr_node *node; 622 622 struct hsr_node *tmp; 623 623 struct hsr_port *port; ··· 685 685 686 686 void hsr_prune_proxy_nodes(struct timer_list *t) 687 687 { 688 688 - struct hsr_priv *hsr = from_timer(hsr, t, prune_proxy_timer); 688 688 + struct hsr_priv *hsr = timer_container_of(hsr, t, prune_proxy_timer); 689 689 unsigned long timestamp; 690 690 struct hsr_node *node; 691 691 struct hsr_node *tmp;

+1 -1

net/ieee802154/6lowpan/reassembly.c

reviewed

··· 44 44 45 45 static void lowpan_frag_expire(struct timer_list *t) 46 46 { 47 47 - struct inet_frag_queue *frag = from_timer(frag, t, timer); 47 47 + struct inet_frag_queue *frag = timer_container_of(frag, t, timer); 48 48 struct frag_queue *fq; 49 49 int refs = 1; 50 50

+3 -3

net/ipv4/igmp.c

reviewed

··· 801 801 802 802 static void igmp_gq_timer_expire(struct timer_list *t) 803 803 { 804 804 - struct in_device *in_dev = from_timer(in_dev, t, mr_gq_timer); 804 804 + struct in_device *in_dev = timer_container_of(in_dev, t, mr_gq_timer); 805 805 806 806 in_dev->mr_gq_running = 0; 807 807 igmpv3_send_report(in_dev, NULL); ··· 810 810 811 811 static void igmp_ifc_timer_expire(struct timer_list *t) 812 812 { 813 813 - struct in_device *in_dev = from_timer(in_dev, t, mr_ifc_timer); 813 813 + struct in_device *in_dev = timer_container_of(in_dev, t, mr_ifc_timer); 814 814 u32 mr_ifc_count; 815 815 816 816 igmpv3_send_cr(in_dev); ··· 840 840 841 841 static void igmp_timer_expire(struct timer_list *t) 842 842 { 843 843 - struct ip_mc_list *im = from_timer(im, t, timer); 843 843 + struct ip_mc_list *im = timer_container_of(im, t, timer); 844 844 struct in_device *in_dev = im->interface; 845 845 846 846 spin_lock(&im->lock);

+1 -1

net/ipv4/inet_connection_sock.c

reviewed

··· 1065 1065 1066 1066 static void reqsk_timer_handler(struct timer_list *t) 1067 1067 { 1068 1068 - struct request_sock *req = from_timer(req, t, rsk_timer); 1068 1068 + struct request_sock *req = timer_container_of(req, t, rsk_timer); 1069 1069 struct request_sock *nreq = NULL, *oreq = req; 1070 1070 struct sock *sk_listener = req->rsk_listener; 1071 1071 struct inet_connection_sock *icsk;

+1 -1

net/ipv4/inet_timewait_sock.c

reviewed

··· 169 169 170 170 static void tw_timer_handler(struct timer_list *t) 171 171 { 172 172 - struct inet_timewait_sock *tw = from_timer(tw, t, tw_timer); 172 172 + struct inet_timewait_sock *tw = timer_container_of(tw, t, tw_timer); 173 173 174 174 inet_twsk_kill(tw); 175 175 }

+1 -1

net/ipv4/ip_fragment.c

reviewed

··· 123 123 static void ip_expire(struct timer_list *t) 124 124 { 125 125 enum skb_drop_reason reason = SKB_DROP_REASON_FRAG_REASM_TIMEOUT; 126 126 - struct inet_frag_queue *frag = from_timer(frag, t, timer); 126 126 + struct inet_frag_queue *frag = timer_container_of(frag, t, timer); 127 127 const struct iphdr *iph; 128 128 struct sk_buff *head = NULL; 129 129 struct net *net;

+1 -1

net/ipv4/ipmr.c

reviewed

··· 765 765 /* Timer process for the unresolved queue. */ 766 766 static void ipmr_expire_process(struct timer_list *t) 767 767 { 768 768 - struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer); 768 768 + struct mr_table *mrt = timer_container_of(mrt, t, ipmr_expire_timer); 769 769 struct mr_mfc *c, *next; 770 770 unsigned long expires; 771 771 unsigned long now;

+3 -3

net/ipv4/tcp_timer.c

reviewed

··· 359 359 static void tcp_delack_timer(struct timer_list *t) 360 360 { 361 361 struct inet_connection_sock *icsk = 362 362 - from_timer(icsk, t, icsk_delack_timer); 362 362 + timer_container_of(icsk, t, icsk_delack_timer); 363 363 struct sock *sk = &icsk->icsk_inet.sk; 364 364 365 365 /* Avoid taking socket spinlock if there is no ACK to send. ··· 726 726 static void tcp_write_timer(struct timer_list *t) 727 727 { 728 728 struct inet_connection_sock *icsk = 729 729 - from_timer(icsk, t, icsk_retransmit_timer); 729 729 + timer_container_of(icsk, t, icsk_retransmit_timer); 730 730 struct sock *sk = &icsk->icsk_inet.sk; 731 731 732 732 /* Avoid locking the socket when there is no pending event. */ ··· 778 778 779 779 static void tcp_keepalive_timer(struct timer_list *t) 780 780 { 781 781 - struct sock *sk = from_timer(sk, t, sk_timer); 781 781 + struct sock *sk = timer_container_of(sk, t, sk_timer); 782 782 struct inet_connection_sock *icsk = inet_csk(sk); 783 783 struct tcp_sock *tp = tcp_sk(sk); 784 784 u32 elapsed;

+1 -1

net/ipv6/addrconf.c

reviewed

··· 4017 4017 4018 4018 static void addrconf_rs_timer(struct timer_list *t) 4019 4019 { 4020 4020 - struct inet6_dev *idev = from_timer(idev, t, rs_timer); 4020 4020 + struct inet6_dev *idev = timer_container_of(idev, t, rs_timer); 4021 4021 struct net_device *dev = idev->dev; 4022 4022 struct in6_addr lladdr; 4023 4023 int rtr_solicits;

+1 -1

net/ipv6/ip6_fib.c

reviewed

··· 2442 2442 2443 2443 static void fib6_gc_timer_cb(struct timer_list *t) 2444 2444 { 2445 2445 - struct net *arg = from_timer(arg, t, ipv6.ip6_fib_timer); 2445 2445 + struct net *arg = timer_container_of(arg, t, ipv6.ip6_fib_timer); 2446 2446 2447 2447 fib6_run_gc(0, arg, true); 2448 2448 }

+1 -1

net/ipv6/ip6mr.c

reviewed

··· 839 839 840 840 static void ipmr_expire_process(struct timer_list *t) 841 841 { 842 842 - struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer); 842 842 + struct mr_table *mrt = timer_container_of(mrt, t, ipmr_expire_timer); 843 843 844 844 if (!spin_trylock(&mfc_unres_lock)) { 845 845 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);

+1 -1

net/ipv6/netfilter/nf_conntrack_reasm.c

reviewed

··· 133 133 134 134 static void nf_ct_frag6_expire(struct timer_list *t) 135 135 { 136 136 - struct inet_frag_queue *frag = from_timer(frag, t, timer); 136 136 + struct inet_frag_queue *frag = timer_container_of(frag, t, timer); 137 137 struct frag_queue *fq; 138 138 139 139 fq = container_of(frag, struct frag_queue, q);

+1 -1

net/ipv6/reassembly.c

reviewed

··· 73 73 74 74 static void ip6_frag_expire(struct timer_list *t) 75 75 { 76 76 - struct inet_frag_queue *frag = from_timer(frag, t, timer); 76 76 + struct inet_frag_queue *frag = timer_container_of(frag, t, timer); 77 77 struct frag_queue *fq; 78 78 79 79 fq = container_of(frag, struct frag_queue, q);

+2 -2

net/lapb/lapb_timer.c

reviewed

··· 74 74 75 75 static void lapb_t2timer_expiry(struct timer_list *t) 76 76 { 77 77 - struct lapb_cb *lapb = from_timer(lapb, t, t2timer); 77 77 + struct lapb_cb *lapb = timer_container_of(lapb, t, t2timer); 78 78 79 79 spin_lock_bh(&lapb->lock); 80 80 if (timer_pending(&lapb->t2timer)) /* A new timer has been set up */ ··· 94 94 95 95 static void lapb_t1timer_expiry(struct timer_list *t) 96 96 { 97 97 - struct lapb_cb *lapb = from_timer(lapb, t, t1timer); 97 97 + struct lapb_cb *lapb = timer_container_of(lapb, t, t1timer); 98 98 99 99 spin_lock_bh(&lapb->lock); 100 100 if (timer_pending(&lapb->t1timer)) /* A new timer has been set up */

+7 -4

net/llc/llc_c_ac.c

reviewed

··· 1335 1335 1336 1336 void llc_conn_pf_cycle_tmr_cb(struct timer_list *t) 1337 1337 { 1338 1338 - struct llc_sock *llc = from_timer(llc, t, pf_cycle_timer.timer); 1338 1338 + struct llc_sock *llc = timer_container_of(llc, t, 1339 1339 + pf_cycle_timer.timer); 1339 1340 1340 1341 llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_P_TMR); 1341 1342 } 1342 1343 1343 1344 void llc_conn_busy_tmr_cb(struct timer_list *t) 1344 1345 { 1345 1345 - struct llc_sock *llc = from_timer(llc, t, busy_state_timer.timer); 1346 1346 + struct llc_sock *llc = timer_container_of(llc, t, 1347 1347 + busy_state_timer.timer); 1346 1348 1347 1349 llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_BUSY_TMR); 1348 1350 } 1349 1351 1350 1352 void llc_conn_ack_tmr_cb(struct timer_list *t) 1351 1353 { 1352 1352 - struct llc_sock *llc = from_timer(llc, t, ack_timer.timer); 1354 1354 + struct llc_sock *llc = timer_container_of(llc, t, ack_timer.timer); 1353 1355 1354 1356 llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_ACK_TMR); 1355 1357 } 1356 1358 1357 1359 void llc_conn_rej_tmr_cb(struct timer_list *t) 1358 1360 { 1359 1359 - struct llc_sock *llc = from_timer(llc, t, rej_sent_timer.timer); 1361 1361 + struct llc_sock *llc = timer_container_of(llc, t, 1362 1362 + rej_sent_timer.timer); 1360 1363 1361 1364 llc_conn_tmr_common_cb(&llc->sk, LLC_CONN_EV_TYPE_REJ_TMR); 1362 1365 }

+4 -2

net/mac80211/agg-rx.c

reviewed

··· 143 143 */ 144 144 static void sta_rx_agg_session_timer_expired(struct timer_list *t) 145 145 { 146 146 - struct tid_ampdu_rx *tid_rx = from_timer(tid_rx, t, session_timer); 146 146 + struct tid_ampdu_rx *tid_rx = timer_container_of(tid_rx, t, 147 147 + session_timer); 147 148 struct sta_info *sta = tid_rx->sta; 148 149 u8 tid = tid_rx->tid; 149 150 unsigned long timeout; ··· 164 163 165 164 static void sta_rx_agg_reorder_timer_expired(struct timer_list *t) 166 165 { 167 167 - struct tid_ampdu_rx *tid_rx = from_timer(tid_rx, t, reorder_timer); 166 166 + struct tid_ampdu_rx *tid_rx = timer_container_of(tid_rx, t, 167 167 + reorder_timer); 168 168 169 169 rcu_read_lock(); 170 170 ieee80211_release_reorder_timeout(tid_rx->sta, tid_rx->tid);

+4 -2

net/mac80211/agg-tx.c

reviewed

··· 422 422 */ 423 423 static void sta_addba_resp_timer_expired(struct timer_list *t) 424 424 { 425 425 - struct tid_ampdu_tx *tid_tx = from_timer(tid_tx, t, addba_resp_timer); 425 425 + struct tid_ampdu_tx *tid_tx = timer_container_of(tid_tx, t, 426 426 + addba_resp_timer); 426 427 struct sta_info *sta = tid_tx->sta; 427 428 u8 tid = tid_tx->tid; 428 429 ··· 575 574 */ 576 575 static void sta_tx_agg_session_timer_expired(struct timer_list *t) 577 576 { 578 578 - struct tid_ampdu_tx *tid_tx = from_timer(tid_tx, t, session_timer); 577 577 + struct tid_ampdu_tx *tid_tx = timer_container_of(tid_tx, t, 578 578 + session_timer); 579 579 struct sta_info *sta = tid_tx->sta; 580 580 u8 tid = tid_tx->tid; 581 581 unsigned long timeout;

+1 -1

net/mac80211/ibss.c

reviewed

··· 1673 1673 static void ieee80211_ibss_timer(struct timer_list *t) 1674 1674 { 1675 1675 struct ieee80211_sub_if_data *sdata = 1676 1676 - from_timer(sdata, t, u.ibss.timer); 1676 1676 + timer_container_of(sdata, t, u.ibss.timer); 1677 1677 1678 1678 wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work); 1679 1679 }

+2 -1

net/mac80211/led.c

reviewed

··· 257 257 258 258 static void tpt_trig_timer(struct timer_list *t) 259 259 { 260 260 - struct tpt_led_trigger *tpt_trig = from_timer(tpt_trig, t, timer); 260 260 + struct tpt_led_trigger *tpt_trig = timer_container_of(tpt_trig, t, 261 261 + timer); 261 262 struct ieee80211_local *local = tpt_trig->local; 262 263 unsigned long on, off, tpt; 263 264 int i;

+3 -3

net/mac80211/mesh.c

reviewed

··· 40 40 static void ieee80211_mesh_housekeeping_timer(struct timer_list *t) 41 41 { 42 42 struct ieee80211_sub_if_data *sdata = 43 43 - from_timer(sdata, t, u.mesh.housekeeping_timer); 43 43 + timer_container_of(sdata, t, u.mesh.housekeeping_timer); 44 44 struct ieee80211_local *local = sdata->local; 45 45 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 46 46 ··· 684 684 static void ieee80211_mesh_path_timer(struct timer_list *t) 685 685 { 686 686 struct ieee80211_sub_if_data *sdata = 687 687 - from_timer(sdata, t, u.mesh.mesh_path_timer); 687 687 + timer_container_of(sdata, t, u.mesh.mesh_path_timer); 688 688 689 689 wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work); 690 690 } ··· 692 692 static void ieee80211_mesh_path_root_timer(struct timer_list *t) 693 693 { 694 694 struct ieee80211_sub_if_data *sdata = 695 695 - from_timer(sdata, t, u.mesh.mesh_path_root_timer); 695 695 + timer_container_of(sdata, t, u.mesh.mesh_path_root_timer); 696 696 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 697 697 698 698 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);

+1 -1

net/mac80211/mesh_hwmp.c

reviewed

··· 1292 1292 1293 1293 void mesh_path_timer(struct timer_list *t) 1294 1294 { 1295 1295 - struct mesh_path *mpath = from_timer(mpath, t, timer); 1295 1295 + struct mesh_path *mpath = timer_container_of(mpath, t, timer); 1296 1296 struct ieee80211_sub_if_data *sdata = mpath->sdata; 1297 1297 int ret; 1298 1298

+1 -1

net/mac80211/mesh_plink.c

reviewed

··· 653 653 654 654 void mesh_plink_timer(struct timer_list *t) 655 655 { 656 656 - struct mesh_sta *mesh = from_timer(mesh, t, plink_timer); 656 656 + struct mesh_sta *mesh = timer_container_of(mesh, t, plink_timer); 657 657 struct sta_info *sta; 658 658 u16 reason = 0; 659 659 struct ieee80211_sub_if_data *sdata;

+5 -4

net/mac80211/mlme.c

reviewed

··· 3383 3383 3384 3384 void ieee80211_dynamic_ps_timer(struct timer_list *t) 3385 3385 { 3386 3386 - struct ieee80211_local *local = from_timer(local, t, dynamic_ps_timer); 3386 3386 + struct ieee80211_local *local = timer_container_of(local, t, 3387 3387 + dynamic_ps_timer); 3387 3388 3388 3389 wiphy_work_queue(local->hw.wiphy, &local->dynamic_ps_enable_work); 3389 3390 } ··· 8080 8079 static void ieee80211_sta_timer(struct timer_list *t) 8081 8080 { 8082 8081 struct ieee80211_sub_if_data *sdata = 8083 8083 - from_timer(sdata, t, u.mgd.timer); 8082 8082 + timer_container_of(sdata, t, u.mgd.timer); 8084 8083 8085 8084 wiphy_work_queue(sdata->local->hw.wiphy, &sdata->work); 8086 8085 } ··· 8386 8385 static void ieee80211_sta_bcn_mon_timer(struct timer_list *t) 8387 8386 { 8388 8387 struct ieee80211_sub_if_data *sdata = 8389 8389 - from_timer(sdata, t, u.mgd.bcn_mon_timer); 8388 8388 + timer_container_of(sdata, t, u.mgd.bcn_mon_timer); 8390 8389 8391 8390 if (WARN_ON(ieee80211_vif_is_mld(&sdata->vif))) 8392 8391 return; ··· 8406 8405 static void ieee80211_sta_conn_mon_timer(struct timer_list *t) 8407 8406 { 8408 8407 struct ieee80211_sub_if_data *sdata = 8409 8409 - from_timer(sdata, t, u.mgd.conn_mon_timer); 8408 8408 + timer_container_of(sdata, t, u.mgd.conn_mon_timer); 8410 8409 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 8411 8410 struct ieee80211_local *local = sdata->local; 8412 8411 struct sta_info *sta;

+1 -1

net/mac80211/ocb.c

reviewed

··· 146 146 static void ieee80211_ocb_housekeeping_timer(struct timer_list *t) 147 147 { 148 148 struct ieee80211_sub_if_data *sdata = 149 149 - from_timer(sdata, t, u.ocb.housekeeping_timer); 149 149 + timer_container_of(sdata, t, u.ocb.housekeeping_timer); 150 150 struct ieee80211_local *local = sdata->local; 151 151 struct ieee80211_if_ocb *ifocb = &sdata->u.ocb; 152 152

+2 -1

net/mac80211/sta_info.c

reviewed

··· 1542 1542 1543 1543 static void sta_info_cleanup(struct timer_list *t) 1544 1544 { 1545 1545 - struct ieee80211_local *local = from_timer(local, t, sta_cleanup); 1545 1545 + struct ieee80211_local *local = timer_container_of(local, t, 1546 1546 + sta_cleanup); 1546 1547 struct sta_info *sta; 1547 1548 bool timer_needed = false; 1548 1549

+2 -1

net/mptcp/pm.c

reviewed

··· 270 270 271 271 static void mptcp_pm_add_timer(struct timer_list *timer) 272 272 { 273 273 - struct mptcp_pm_add_entry *entry = from_timer(entry, timer, add_timer); 273 273 + struct mptcp_pm_add_entry *entry = timer_container_of(entry, timer, 274 274 + add_timer); 274 275 struct mptcp_sock *msk = entry->sock; 275 276 struct sock *sk = (struct sock *)msk; 276 277

+3 -3

net/mptcp/protocol.c

reviewed

··· 2203 2203 2204 2204 static void mptcp_retransmit_timer(struct timer_list *t) 2205 2205 { 2206 2206 - struct inet_connection_sock *icsk = from_timer(icsk, t, 2207 2207 - icsk_retransmit_timer); 2206 2206 + struct inet_connection_sock *icsk = timer_container_of(icsk, t, 2207 2207 + icsk_retransmit_timer); 2208 2208 struct sock *sk = &icsk->icsk_inet.sk; 2209 2209 struct mptcp_sock *msk = mptcp_sk(sk); 2210 2210 ··· 2223 2223 2224 2224 static void mptcp_tout_timer(struct timer_list *t) 2225 2225 { 2226 2226 - struct sock *sk = from_timer(sk, t, sk_timer); 2226 2226 + struct sock *sk = timer_container_of(sk, t, sk_timer); 2227 2227 2228 2228 mptcp_schedule_work(sk); 2229 2229 sock_put(sk);

+2 -2

net/ncsi/ncsi-manage.c

reviewed

··· 88 88 89 89 static void ncsi_channel_monitor(struct timer_list *t) 90 90 { 91 91 - struct ncsi_channel *nc = from_timer(nc, t, monitor.timer); 91 91 + struct ncsi_channel *nc = timer_container_of(nc, t, monitor.timer); 92 92 struct ncsi_package *np = nc->package; 93 93 struct ncsi_dev_priv *ndp = np->ndp; 94 94 struct ncsi_channel_mode *ncm; ··· 430 430 431 431 static void ncsi_request_timeout(struct timer_list *t) 432 432 { 433 433 - struct ncsi_request *nr = from_timer(nr, t, timer); 433 433 + struct ncsi_request *nr = timer_container_of(nr, t, timer); 434 434 struct ncsi_dev_priv *ndp = nr->ndp; 435 435 struct ncsi_cmd_pkt *cmd; 436 436 struct ncsi_package *np;

+1 -1

net/netfilter/ipset/ip_set_bitmap_gen.h

reviewed

··· 264 264 static void 265 265 mtype_gc(struct timer_list *t) 266 266 { 267 267 - struct mtype *map = from_timer(map, t, gc); 267 267 + struct mtype *map = timer_container_of(map, t, gc); 268 268 struct ip_set *set = map->set; 269 269 void *x; 270 270 u32 id;

+1 -1

net/netfilter/ipset/ip_set_list_set.c

reviewed

··· 571 571 static void 572 572 list_set_gc(struct timer_list *t) 573 573 { 574 574 - struct list_set *map = from_timer(map, t, gc); 574 574 + struct list_set *map = timer_container_of(map, t, gc); 575 575 struct ip_set *set = map->set; 576 576 577 577 spin_lock_bh(&set->lock);

+1 -1

net/netfilter/ipvs/ip_vs_conn.c

reviewed

··· 846 846 847 847 static void ip_vs_conn_expire(struct timer_list *t) 848 848 { 849 849 - struct ip_vs_conn *cp = from_timer(cp, t, timer); 849 849 + struct ip_vs_conn *cp = timer_container_of(cp, t, timer); 850 850 struct netns_ipvs *ipvs = cp->ipvs; 851 851 852 852 /*

+2 -1

net/netfilter/ipvs/ip_vs_ctl.c

reviewed

··· 1331 1331 1332 1332 static void ip_vs_dest_trash_expire(struct timer_list *t) 1333 1333 { 1334 1334 - struct netns_ipvs *ipvs = from_timer(ipvs, t, dest_trash_timer); 1334 1334 + struct netns_ipvs *ipvs = timer_container_of(ipvs, t, 1335 1335 + dest_trash_timer); 1335 1336 struct ip_vs_dest *dest, *next; 1336 1337 unsigned long now = jiffies; 1337 1338

+2 -1

net/netfilter/ipvs/ip_vs_lblc.c

reviewed

··· 292 292 */ 293 293 static void ip_vs_lblc_check_expire(struct timer_list *t) 294 294 { 295 295 - struct ip_vs_lblc_table *tbl = from_timer(tbl, t, periodic_timer); 295 295 + struct ip_vs_lblc_table *tbl = timer_container_of(tbl, t, 296 296 + periodic_timer); 296 297 struct ip_vs_service *svc = tbl->svc; 297 298 unsigned long now = jiffies; 298 299 int goal;

+2 -1

net/netfilter/ipvs/ip_vs_lblcr.c

reviewed

··· 456 456 */ 457 457 static void ip_vs_lblcr_check_expire(struct timer_list *t) 458 458 { 459 459 - struct ip_vs_lblcr_table *tbl = from_timer(tbl, t, periodic_timer); 459 459 + struct ip_vs_lblcr_table *tbl = timer_container_of(tbl, t, 460 460 + periodic_timer); 460 461 struct ip_vs_service *svc = tbl->svc; 461 462 unsigned long now = jiffies; 462 463 int goal;

+1 -1

net/netfilter/nf_conntrack_expect.c

reviewed

··· 71 71 72 72 static void nf_ct_expectation_timed_out(struct timer_list *t) 73 73 { 74 74 - struct nf_conntrack_expect *exp = from_timer(exp, t, timeout); 74 74 + struct nf_conntrack_expect *exp = timer_container_of(exp, t, timeout); 75 75 76 76 spin_lock_bh(&nf_conntrack_expect_lock); 77 77 nf_ct_unlink_expect(exp);

+1 -1

net/netfilter/nfnetlink_log.c

reviewed

··· 390 390 static void 391 391 nfulnl_timer(struct timer_list *t) 392 392 { 393 393 - struct nfulnl_instance *inst = from_timer(inst, t, timer); 393 393 + struct nfulnl_instance *inst = timer_container_of(inst, t, timer); 394 394 395 395 spin_lock_bh(&inst->lock); 396 396 if (inst->skb)

+1 -1

net/netfilter/xt_IDLETIMER.c

reviewed

··· 100 100 101 101 static void idletimer_tg_expired(struct timer_list *t) 102 102 { 103 103 - struct idletimer_tg *timer = from_timer(timer, t, timer); 103 103 + struct idletimer_tg *timer = timer_container_of(timer, t, timer); 104 104 105 105 pr_debug("timer %s expired\n", timer->attr.attr.name); 106 106

+3 -2

net/netfilter/xt_LED.c

reviewed

··· 72 72 73 73 static void led_timeout_callback(struct timer_list *t) 74 74 { 75 75 - struct xt_led_info_internal *ledinternal = from_timer(ledinternal, t, 76 76 - timer); 75 75 + struct xt_led_info_internal *ledinternal = timer_container_of(ledinternal, 76 76 + t, 77 77 + timer); 77 78 78 79 led_trigger_event(&ledinternal->netfilter_led_trigger, LED_OFF); 79 80 }

+1 -1

net/netrom/af_netrom.c

reviewed

··· 240 240 */ 241 241 static void nr_destroy_timer(struct timer_list *t) 242 242 { 243 243 - struct sock *sk = from_timer(sk, t, sk_timer); 243 243 + struct sock *sk = timer_container_of(sk, t, sk_timer); 244 244 bh_lock_sock(sk); 245 245 sock_hold(sk); 246 246 nr_destroy_socket(sk);

+5 -5

net/netrom/nr_timer.c

reviewed

··· 111 111 112 112 static void nr_heartbeat_expiry(struct timer_list *t) 113 113 { 114 114 - struct sock *sk = from_timer(sk, t, sk_timer); 114 114 + struct sock *sk = timer_container_of(sk, t, sk_timer); 115 115 struct nr_sock *nr = nr_sk(sk); 116 116 117 117 bh_lock_sock(sk); ··· 152 152 153 153 static void nr_t2timer_expiry(struct timer_list *t) 154 154 { 155 155 - struct nr_sock *nr = from_timer(nr, t, t2timer); 155 155 + struct nr_sock *nr = timer_container_of(nr, t, t2timer); 156 156 struct sock *sk = &nr->sock; 157 157 158 158 bh_lock_sock(sk); ··· 166 166 167 167 static void nr_t4timer_expiry(struct timer_list *t) 168 168 { 169 169 - struct nr_sock *nr = from_timer(nr, t, t4timer); 169 169 + struct nr_sock *nr = timer_container_of(nr, t, t4timer); 170 170 struct sock *sk = &nr->sock; 171 171 172 172 bh_lock_sock(sk); ··· 177 177 178 178 static void nr_idletimer_expiry(struct timer_list *t) 179 179 { 180 180 - struct nr_sock *nr = from_timer(nr, t, idletimer); 180 180 + struct nr_sock *nr = timer_container_of(nr, t, idletimer); 181 181 struct sock *sk = &nr->sock; 182 182 183 183 bh_lock_sock(sk); ··· 206 206 207 207 static void nr_t1timer_expiry(struct timer_list *t) 208 208 { 209 209 - struct nr_sock *nr = from_timer(nr, t, t1timer); 209 209 + struct nr_sock *nr = timer_container_of(nr, t, t1timer); 210 210 struct sock *sk = &nr->sock; 211 211 212 212 bh_lock_sock(sk);

+1 -1

net/nfc/core.c

reviewed

··· 1010 1010 1011 1011 static void nfc_check_pres_timeout(struct timer_list *t) 1012 1012 { 1013 1013 - struct nfc_dev *dev = from_timer(dev, t, check_pres_timer); 1013 1013 + struct nfc_dev *dev = timer_container_of(dev, t, check_pres_timer); 1014 1014 1015 1015 schedule_work(&dev->check_pres_work); 1016 1016 }

+1 -1

net/nfc/hci/core.c

reviewed

··· 441 441 442 442 static void nfc_hci_cmd_timeout(struct timer_list *t) 443 443 { 444 444 - struct nfc_hci_dev *hdev = from_timer(hdev, t, cmd_timer); 444 444 + struct nfc_hci_dev *hdev = timer_container_of(hdev, t, cmd_timer); 445 445 446 446 schedule_work(&hdev->msg_tx_work); 447 447 }

+3 -3

net/nfc/hci/llc_shdlc.c

reviewed

··· 564 564 565 565 static void llc_shdlc_connect_timeout(struct timer_list *t) 566 566 { 567 567 - struct llc_shdlc *shdlc = from_timer(shdlc, t, connect_timer); 567 567 + struct llc_shdlc *shdlc = timer_container_of(shdlc, t, connect_timer); 568 568 569 569 schedule_work(&shdlc->sm_work); 570 570 } 571 571 572 572 static void llc_shdlc_t1_timeout(struct timer_list *t) 573 573 { 574 574 - struct llc_shdlc *shdlc = from_timer(shdlc, t, t1_timer); 574 574 + struct llc_shdlc *shdlc = timer_container_of(shdlc, t, t1_timer); 575 575 576 576 pr_debug("SoftIRQ: need to send ack\n"); 577 577 ··· 580 580 581 581 static void llc_shdlc_t2_timeout(struct timer_list *t) 582 582 { 583 583 - struct llc_shdlc *shdlc = from_timer(shdlc, t, t2_timer); 583 583 + struct llc_shdlc *shdlc = timer_container_of(shdlc, t, t2_timer); 584 584 585 585 pr_debug("SoftIRQ: need to retransmit\n"); 586 586

+4 -2

net/nfc/llcp_core.c

reviewed

··· 243 243 244 244 static void nfc_llcp_symm_timer(struct timer_list *t) 245 245 { 246 246 - struct nfc_llcp_local *local = from_timer(local, t, link_timer); 246 246 + struct nfc_llcp_local *local = timer_container_of(local, t, 247 247 + link_timer); 247 248 248 249 pr_err("SYMM timeout\n"); 249 250 ··· 287 286 288 287 static void nfc_llcp_sdreq_timer(struct timer_list *t) 289 288 { 290 290 - struct nfc_llcp_local *local = from_timer(local, t, sdreq_timer); 289 289 + struct nfc_llcp_local *local = timer_container_of(local, t, 290 290 + sdreq_timer); 291 291 292 292 schedule_work(&local->sdreq_timeout_work); 293 293 }

+2 -2

net/nfc/nci/core.c

reviewed

··· 610 610 /* NCI command timer function */ 611 611 static void nci_cmd_timer(struct timer_list *t) 612 612 { 613 613 - struct nci_dev *ndev = from_timer(ndev, t, cmd_timer); 613 613 + struct nci_dev *ndev = timer_container_of(ndev, t, cmd_timer); 614 614 615 615 atomic_set(&ndev->cmd_cnt, 1); 616 616 queue_work(ndev->cmd_wq, &ndev->cmd_work); ··· 619 619 /* NCI data exchange timer function */ 620 620 static void nci_data_timer(struct timer_list *t) 621 621 { 622 622 - struct nci_dev *ndev = from_timer(ndev, t, data_timer); 622 622 + struct nci_dev *ndev = timer_container_of(ndev, t, data_timer); 623 623 624 624 set_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags); 625 625 queue_work(ndev->rx_wq, &ndev->rx_work);

+1 -1

net/packet/af_packet.c

reviewed

··· 722 722 static void prb_retire_rx_blk_timer_expired(struct timer_list *t) 723 723 { 724 724 struct packet_sock *po = 725 725 - from_timer(po, t, rx_ring.prb_bdqc.retire_blk_timer); 725 725 + timer_container_of(po, t, rx_ring.prb_bdqc.retire_blk_timer); 726 726 struct tpacket_kbdq_core *pkc = GET_PBDQC_FROM_RB(&po->rx_ring); 727 727 unsigned int frozen; 728 728 struct tpacket_block_desc *pbd;

+1 -1

net/rose/af_rose.c

reviewed

··· 345 345 */ 346 346 static void rose_destroy_timer(struct timer_list *t) 347 347 { 348 348 - struct sock *sk = from_timer(sk, t, sk_timer); 348 348 + struct sock *sk = timer_container_of(sk, t, sk_timer); 349 349 350 350 rose_destroy_socket(sk); 351 351 }

+1 -1

net/rose/rose_link.c

reviewed

··· 78 78 79 79 static void rose_t0timer_expiry(struct timer_list *t) 80 80 { 81 81 - struct rose_neigh *neigh = from_timer(neigh, t, t0timer); 81 81 + struct rose_neigh *neigh = timer_container_of(neigh, t, t0timer); 82 82 83 83 rose_transmit_restart_request(neigh); 84 84

+3 -3

net/rose/rose_timer.c

reviewed

··· 118 118 119 119 static void rose_heartbeat_expiry(struct timer_list *t) 120 120 { 121 121 - struct sock *sk = from_timer(sk, t, sk_timer); 121 121 + struct sock *sk = timer_container_of(sk, t, sk_timer); 122 122 struct rose_sock *rose = rose_sk(sk); 123 123 124 124 bh_lock_sock(sk); ··· 163 163 164 164 static void rose_timer_expiry(struct timer_list *t) 165 165 { 166 166 - struct rose_sock *rose = from_timer(rose, t, timer); 166 166 + struct rose_sock *rose = timer_container_of(rose, t, timer); 167 167 struct sock *sk = &rose->sock; 168 168 169 169 bh_lock_sock(sk); ··· 198 198 199 199 static void rose_idletimer_expiry(struct timer_list *t) 200 200 { 201 201 - struct rose_sock *rose = from_timer(rose, t, idletimer); 201 201 + struct rose_sock *rose = timer_container_of(rose, t, idletimer); 202 202 struct sock *sk = &rose->sock; 203 203 204 204 bh_lock_sock(sk);

+1 -1

net/rxrpc/call_object.c

reviewed

··· 64 64 65 65 static void rxrpc_call_timer_expired(struct timer_list *t) 66 66 { 67 67 - struct rxrpc_call *call = from_timer(call, t, timer); 67 67 + struct rxrpc_call *call = timer_container_of(call, t, timer); 68 68 69 69 _enter("%d", call->debug_id); 70 70

+1 -1

net/sched/cls_flow.c

reviewed

··· 345 345 346 346 static void flow_perturbation(struct timer_list *t) 347 347 { 348 348 - struct flow_filter *f = from_timer(f, t, perturb_timer); 348 348 + struct flow_filter *f = timer_container_of(f, t, perturb_timer); 349 349 350 350 get_random_bytes(&f->hashrnd, 4); 351 351 if (f->perturb_period)

+1 -1

net/sched/sch_fq_pie.c

reviewed

··· 384 384 385 385 static void fq_pie_timer(struct timer_list *t) 386 386 { 387 387 - struct fq_pie_sched_data *q = from_timer(q, t, adapt_timer); 387 387 + struct fq_pie_sched_data *q = timer_container_of(q, t, adapt_timer); 388 388 unsigned long next, tupdate; 389 389 struct Qdisc *sch = q->sch; 390 390 spinlock_t *root_lock; /* to lock qdisc for probability calculations */

+1 -1

net/sched/sch_generic.c

reviewed

··· 496 496 497 497 static void dev_watchdog(struct timer_list *t) 498 498 { 499 499 - struct net_device *dev = from_timer(dev, t, watchdog_timer); 499 499 + struct net_device *dev = timer_container_of(dev, t, watchdog_timer); 500 500 bool release = true; 501 501 502 502 spin_lock(&dev->tx_global_lock);

+1 -1

net/sched/sch_pie.c

reviewed

··· 424 424 425 425 static void pie_timer(struct timer_list *t) 426 426 { 427 427 - struct pie_sched_data *q = from_timer(q, t, adapt_timer); 427 427 + struct pie_sched_data *q = timer_container_of(q, t, adapt_timer); 428 428 struct Qdisc *sch = q->sch; 429 429 spinlock_t *root_lock; 430 430

+1 -1

net/sched/sch_red.c

reviewed

··· 321 321 322 322 static inline void red_adaptative_timer(struct timer_list *t) 323 323 { 324 324 - struct red_sched_data *q = from_timer(q, t, adapt_timer); 324 324 + struct red_sched_data *q = timer_container_of(q, t, adapt_timer); 325 325 struct Qdisc *sch = q->sch; 326 326 spinlock_t *root_lock; 327 327

+1 -1

net/sched/sch_sfq.c

reviewed

··· 597 597 598 598 static void sfq_perturbation(struct timer_list *t) 599 599 { 600 600 - struct sfq_sched_data *q = from_timer(q, t, perturb_timer); 600 600 + struct sfq_sched_data *q = timer_container_of(q, t, perturb_timer); 601 601 struct Qdisc *sch = q->sch; 602 602 spinlock_t *root_lock; 603 603 siphash_key_t nkey;

+1 -1

net/sctp/protocol.c

reviewed

··· 631 631 632 632 static void sctp_addr_wq_timeout_handler(struct timer_list *t) 633 633 { 634 634 - struct net *net = from_timer(net, t, sctp.addr_wq_timer); 634 634 + struct net *net = timer_container_of(net, t, sctp.addr_wq_timer); 635 635 struct sctp_sockaddr_entry *addrw, *temp; 636 636 struct sctp_sock *sp; 637 637

+19 -13

net/sctp/sm_sideeffect.c

reviewed

··· 231 231 void sctp_generate_t3_rtx_event(struct timer_list *t) 232 232 { 233 233 struct sctp_transport *transport = 234 234 - from_timer(transport, t, T3_rtx_timer); 234 234 + timer_container_of(transport, t, T3_rtx_timer); 235 235 struct sctp_association *asoc = transport->asoc; 236 236 struct sock *sk = asoc->base.sk; 237 237 struct net *net = sock_net(sk); ··· 308 308 static void sctp_generate_t1_cookie_event(struct timer_list *t) 309 309 { 310 310 struct sctp_association *asoc = 311 311 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_COOKIE]); 311 311 + timer_container_of(asoc, t, 312 312 + timers[SCTP_EVENT_TIMEOUT_T1_COOKIE]); 312 313 313 314 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE); 314 315 } ··· 317 316 static void sctp_generate_t1_init_event(struct timer_list *t) 318 317 { 319 318 struct sctp_association *asoc = 320 320 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_INIT]); 319 319 + timer_container_of(asoc, t, 320 320 + timers[SCTP_EVENT_TIMEOUT_T1_INIT]); 321 321 322 322 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT); 323 323 } ··· 326 324 static void sctp_generate_t2_shutdown_event(struct timer_list *t) 327 325 { 328 326 struct sctp_association *asoc = 329 329 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN]); 327 327 + timer_container_of(asoc, t, 328 328 + timers[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN]); 330 329 331 330 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN); 332 331 } ··· 335 332 static void sctp_generate_t4_rto_event(struct timer_list *t) 336 333 { 337 334 struct sctp_association *asoc = 338 338 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T4_RTO]); 335 335 + timer_container_of(asoc, t, timers[SCTP_EVENT_TIMEOUT_T4_RTO]); 339 336 340 337 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO); 341 338 } ··· 343 340 static void sctp_generate_t5_shutdown_guard_event(struct timer_list *t) 344 341 { 345 342 struct sctp_association *asoc = 346 346 - from_timer(asoc, t, 347 347 - timers[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]); 343 343 + timer_container_of(asoc, t, 344 344 + timers[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]); 348 345 349 346 sctp_generate_timeout_event(asoc, 350 347 SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD); ··· 354 351 static void sctp_generate_autoclose_event(struct timer_list *t) 355 352 { 356 353 struct sctp_association *asoc = 357 357 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE]); 354 354 + timer_container_of(asoc, t, 355 355 + timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE]); 358 356 359 357 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE); 360 358 } ··· 365 361 */ 366 362 void sctp_generate_heartbeat_event(struct timer_list *t) 367 363 { 368 368 - struct sctp_transport *transport = from_timer(transport, t, hb_timer); 364 364 + struct sctp_transport *transport = timer_container_of(transport, t, 365 365 + hb_timer); 369 366 struct sctp_association *asoc = transport->asoc; 370 367 struct sock *sk = asoc->base.sk; 371 368 struct net *net = sock_net(sk); ··· 412 407 void sctp_generate_proto_unreach_event(struct timer_list *t) 413 408 { 414 409 struct sctp_transport *transport = 415 415 - from_timer(transport, t, proto_unreach_timer); 410 410 + timer_container_of(transport, t, proto_unreach_timer); 416 411 struct sctp_association *asoc = transport->asoc; 417 412 struct sock *sk = asoc->base.sk; 418 413 struct net *net = sock_net(sk); ··· 447 442 void sctp_generate_reconf_event(struct timer_list *t) 448 443 { 449 444 struct sctp_transport *transport = 450 450 - from_timer(transport, t, reconf_timer); 445 445 + timer_container_of(transport, t, reconf_timer); 451 446 struct sctp_association *asoc = transport->asoc; 452 447 struct sock *sk = asoc->base.sk; 453 448 struct net *net = sock_net(sk); ··· 483 478 /* Handle the timeout of the probe timer. */ 484 479 void sctp_generate_probe_event(struct timer_list *t) 485 480 { 486 486 - struct sctp_transport *transport = from_timer(transport, t, probe_timer); 481 481 + struct sctp_transport *transport = timer_container_of(transport, t, 482 482 + probe_timer); 487 483 struct sctp_association *asoc = transport->asoc; 488 484 struct sock *sk = asoc->base.sk; 489 485 struct net *net = sock_net(sk); ··· 517 511 static void sctp_generate_sack_event(struct timer_list *t) 518 512 { 519 513 struct sctp_association *asoc = 520 520 - from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_SACK]); 514 514 + timer_container_of(asoc, t, timers[SCTP_EVENT_TIMEOUT_SACK]); 521 515 522 516 sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK); 523 517 }

+1 -1

net/sunrpc/svc_xprt.c

reviewed

··· 922 922 */ 923 923 static void svc_age_temp_xprts(struct timer_list *t) 924 924 { 925 925 - struct svc_serv *serv = from_timer(serv, t, sv_temptimer); 925 925 + struct svc_serv *serv = timer_container_of(serv, t, sv_temptimer); 926 926 struct svc_xprt *xprt; 927 927 struct list_head *le, *next; 928 928

+1 -1

net/sunrpc/xprt.c

reviewed

··· 854 854 static void 855 855 xprt_init_autodisconnect(struct timer_list *t) 856 856 { 857 857 - struct rpc_xprt *xprt = from_timer(xprt, t, timer); 857 857 + struct rpc_xprt *xprt = timer_container_of(xprt, t, timer); 858 858 859 859 if (!RB_EMPTY_ROOT(&xprt->recv_queue)) 860 860 return;

+1 -1

net/tipc/discover.c

reviewed

··· 292 292 */ 293 293 static void tipc_disc_timeout(struct timer_list *t) 294 294 { 295 295 - struct tipc_discoverer *d = from_timer(d, t, timer); 295 295 + struct tipc_discoverer *d = timer_container_of(d, t, timer); 296 296 struct tipc_net *tn = tipc_net(d->net); 297 297 struct tipc_media_addr maddr; 298 298 struct sk_buff *skb = NULL;

+1 -1

net/tipc/monitor.c

reviewed

··· 630 630 631 631 static void mon_timeout(struct timer_list *t) 632 632 { 633 633 - struct tipc_monitor *mon = from_timer(mon, t, timer); 633 633 + struct tipc_monitor *mon = timer_container_of(mon, t, timer); 634 634 struct tipc_peer *self; 635 635 int best_member_cnt = dom_size(mon->peer_cnt) - 1; 636 636

+1 -1

net/tipc/node.c

reviewed

··· 800 800 */ 801 801 static void tipc_node_timeout(struct timer_list *t) 802 802 { 803 803 - struct tipc_node *n = from_timer(n, t, timer); 803 803 + struct tipc_node *n = timer_container_of(n, t, timer); 804 804 struct tipc_link_entry *le; 805 805 struct sk_buff_head xmitq; 806 806 int remains = n->link_cnt;

+1 -1

net/tipc/socket.c

reviewed

··· 2862 2862 2863 2863 static void tipc_sk_timeout(struct timer_list *t) 2864 2864 { 2865 2865 - struct sock *sk = from_timer(sk, t, sk_timer); 2865 2865 + struct sock *sk = timer_container_of(sk, t, sk_timer); 2866 2866 struct tipc_sock *tsk = tipc_sk(sk); 2867 2867 u32 pnode = tsk_peer_node(tsk); 2868 2868 struct sk_buff_head list;

+1 -1

net/tipc/subscr.c

reviewed

··· 105 105 106 106 static void tipc_sub_timeout(struct timer_list *t) 107 107 { 108 108 - struct tipc_subscription *sub = from_timer(sub, t, timer); 108 108 + struct tipc_subscription *sub = timer_container_of(sub, t, timer); 109 109 110 110 spin_lock(&sub->lock); 111 111 tipc_sub_send_event(sub, NULL, TIPC_SUBSCR_TIMEOUT);

+1 -1

net/wireless/core.c

reviewed

··· 1709 1709 1710 1710 void wiphy_delayed_work_timer(struct timer_list *t) 1711 1711 { 1712 1712 - struct wiphy_delayed_work *dwork = from_timer(dwork, t, timer); 1712 1712 + struct wiphy_delayed_work *dwork = timer_container_of(dwork, t, timer); 1713 1713 1714 1714 wiphy_work_queue(dwork->wiphy, &dwork->work); 1715 1715 }

+1 -1

net/x25/af_x25.c

reviewed

··· 359 359 */ 360 360 static void x25_destroy_timer(struct timer_list *t) 361 361 { 362 362 - struct sock *sk = from_timer(sk, t, sk_timer); 362 362 + struct sock *sk = timer_container_of(sk, t, sk_timer); 363 363 364 364 x25_destroy_socket_from_timer(sk); 365 365 }

+1 -1

net/x25/x25_link.c

reviewed

··· 46 46 47 47 static void x25_t20timer_expiry(struct timer_list *t) 48 48 { 49 49 - struct x25_neigh *nb = from_timer(nb, t, t20timer); 49 49 + struct x25_neigh *nb = timer_container_of(nb, t, t20timer); 50 50 51 51 x25_transmit_restart_request(nb); 52 52

+2 -2

net/x25/x25_timer.c

reviewed

··· 89 89 90 90 static void x25_heartbeat_expiry(struct timer_list *t) 91 91 { 92 92 - struct sock *sk = from_timer(sk, t, sk_timer); 92 92 + struct sock *sk = timer_container_of(sk, t, sk_timer); 93 93 94 94 bh_lock_sock(sk); 95 95 if (sock_owned_by_user(sk)) /* can currently only occur in state 3 */ ··· 156 156 157 157 static void x25_timer_expiry(struct timer_list *t) 158 158 { 159 159 - struct x25_sock *x25 = from_timer(x25, t, timer); 159 159 + struct x25_sock *x25 = timer_container_of(x25, t, timer); 160 160 struct sock *sk = &x25->sk; 161 161 162 162 bh_lock_sock(sk);

+2 -2

net/xfrm/xfrm_policy.c

reviewed

··· 353 353 354 354 static void xfrm_policy_timer(struct timer_list *t) 355 355 { 356 356 - struct xfrm_policy *xp = from_timer(xp, t, timer); 356 356 + struct xfrm_policy *xp = timer_container_of(xp, t, timer); 357 357 time64_t now = ktime_get_real_seconds(); 358 358 time64_t next = TIME64_MAX; 359 359 int warn = 0; ··· 2898 2898 struct sk_buff *skb; 2899 2899 struct sock *sk; 2900 2900 struct dst_entry *dst; 2901 2901 - struct xfrm_policy *pol = from_timer(pol, t, polq.hold_timer); 2901 2901 + struct xfrm_policy *pol = timer_container_of(pol, t, polq.hold_timer); 2902 2902 struct net *net = xp_net(pol); 2903 2903 struct xfrm_policy_queue *pq = &pol->polq; 2904 2904 struct flowi fl;

+1 -1

net/xfrm/xfrm_state.c

reviewed

··· 2697 2697 2698 2698 static void xfrm_replay_timer_handler(struct timer_list *t) 2699 2699 { 2700 2700 - struct xfrm_state *x = from_timer(x, t, rtimer); 2700 2700 + struct xfrm_state *x = timer_container_of(x, t, rtimer); 2701 2701 2702 2702 spin_lock(&x->lock); 2703 2703

+2 -2

sound/core/timer.c

reviewed

··· 1118 1118 1119 1119 static void snd_timer_s_function(struct timer_list *t) 1120 1120 { 1121 1121 - struct snd_timer_system_private *priv = from_timer(priv, t, 1122 1122 - tlist); 1121 1121 + struct snd_timer_system_private *priv = timer_container_of(priv, t, 1122 1122 + tlist); 1123 1123 struct snd_timer *timer = priv->snd_timer; 1124 1124 unsigned long jiff = jiffies; 1125 1125 if (time_after(jiff, priv->last_expires))

+1 -1

sound/drivers/aloop.c

reviewed

··· 699 699 700 700 static void loopback_jiffies_timer_function(struct timer_list *t) 701 701 { 702 702 - struct loopback_pcm *dpcm = from_timer(dpcm, t, timer); 702 702 + struct loopback_pcm *dpcm = timer_container_of(dpcm, t, timer); 703 703 unsigned long flags; 704 704 705 705 spin_lock_irqsave(&dpcm->cable->lock, flags);

+1 -1

sound/drivers/dummy.c

reviewed

··· 301 301 302 302 static void dummy_systimer_callback(struct timer_list *t) 303 303 { 304 304 - struct dummy_systimer_pcm *dpcm = from_timer(dpcm, t, timer); 304 304 + struct dummy_systimer_pcm *dpcm = timer_container_of(dpcm, t, timer); 305 305 unsigned long flags; 306 306 int elapsed = 0; 307 307

+1 -1

sound/drivers/mpu401/mpu401_uart.c

reviewed

··· 157 157 */ 158 158 static void snd_mpu401_uart_timer(struct timer_list *t) 159 159 { 160 160 - struct snd_mpu401 *mpu = from_timer(mpu, t, timer); 160 160 + struct snd_mpu401 *mpu = timer_container_of(mpu, t, timer); 161 161 unsigned long flags; 162 162 163 163 spin_lock_irqsave(&mpu->timer_lock, flags);

+1 -1

sound/drivers/mtpav.c

reviewed

··· 388 388 static void snd_mtpav_output_timer(struct timer_list *t) 389 389 { 390 390 unsigned long flags; 391 391 - struct mtpav *chip = from_timer(chip, t, timer); 391 391 + struct mtpav *chip = timer_container_of(chip, t, timer); 392 392 int p; 393 393 394 394 spin_lock_irqsave(&chip->spinlock, flags);

+1 -1

sound/drivers/opl3/opl3_midi.c

reviewed

··· 233 233 void snd_opl3_timer_func(struct timer_list *t) 234 234 { 235 235 236 236 - struct snd_opl3 *opl3 = from_timer(opl3, t, tlist); 236 236 + struct snd_opl3 *opl3 = timer_container_of(opl3, t, tlist); 237 237 unsigned long flags; 238 238 int again = 0; 239 239 int i;

+1 -1

sound/drivers/pcmtest.c

reviewed

··· 345 345 struct pcmtst_buf_iter *v_iter; 346 346 struct snd_pcm_substream *substream; 347 347 348 348 - v_iter = from_timer(v_iter, data, timer_instance); 348 348 + v_iter = timer_container_of(v_iter, data, timer_instance); 349 349 substream = v_iter->substream; 350 350 351 351 if (v_iter->suspend)

+1 -1

sound/drivers/serial-u16550.c

reviewed

··· 299 299 unsigned long flags; 300 300 struct snd_uart16550 *uart; 301 301 302 302 - uart = from_timer(uart, t, buffer_timer); 302 302 + uart = timer_container_of(uart, t, buffer_timer); 303 303 spin_lock_irqsave(&uart->open_lock, flags); 304 304 snd_uart16550_del_timer(uart); 305 305 snd_uart16550_io_loop(uart);

+1 -1

sound/i2c/other/ak4117.c

reviewed

··· 504 504 505 505 static void snd_ak4117_timer(struct timer_list *t) 506 506 { 507 507 - struct ak4117 *chip = from_timer(chip, t, timer); 507 507 + struct ak4117 *chip = timer_container_of(chip, t, timer); 508 508 509 509 if (chip->init) 510 510 return;

+1 -1

sound/isa/sb/emu8000_pcm.c

reviewed

··· 182 182 */ 183 183 static void emu8k_pcm_timer_func(struct timer_list *t) 184 184 { 185 185 - struct snd_emu8k_pcm *rec = from_timer(rec, t, timer); 185 185 + struct snd_emu8k_pcm *rec = timer_container_of(rec, t, timer); 186 186 int ptr, delta; 187 187 188 188 spin_lock(&rec->timer_lock);

+1 -1

sound/isa/sb/sb8_midi.c

reviewed

··· 200 200 201 201 static void snd_sb8dsp_midi_output_timer(struct timer_list *t) 202 202 { 203 203 - struct snd_sb *chip = from_timer(chip, t, midi_timer); 203 203 + struct snd_sb *chip = timer_container_of(chip, t, midi_timer); 204 204 struct snd_rawmidi_substream *substream = chip->midi_substream_output; 205 205 unsigned long flags; 206 206

+1 -1

sound/isa/wavefront/wavefront_midi.c

reviewed

··· 352 352 353 353 static void snd_wavefront_midi_output_timer(struct timer_list *t) 354 354 { 355 355 - snd_wavefront_midi_t *midi = from_timer(midi, t, timer); 355 355 + snd_wavefront_midi_t *midi = timer_container_of(midi, t, timer); 356 356 snd_wavefront_card_t *card = midi->timer_card; 357 357 unsigned long flags; 358 358

+1 -1

sound/pci/asihpi/asihpi.c

reviewed

··· 709 709 */ 710 710 static void snd_card_asihpi_timer_function(struct timer_list *t) 711 711 { 712 712 - struct snd_card_asihpi_pcm *dpcm = from_timer(dpcm, t, timer); 712 712 + struct snd_card_asihpi_pcm *dpcm = timer_container_of(dpcm, t, timer); 713 713 struct snd_pcm_substream *substream = dpcm->substream; 714 714 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream); 715 715 struct snd_pcm_runtime *runtime;

+1 -1

sound/pci/ctxfi/cttimer.c

reviewed

··· 62 62 63 63 static void ct_systimer_callback(struct timer_list *t) 64 64 { 65 65 - struct ct_timer_instance *ti = from_timer(ti, t, timer); 65 65 + struct ct_timer_instance *ti = timer_container_of(ti, t, timer); 66 66 struct snd_pcm_substream *substream = ti->substream; 67 67 struct snd_pcm_runtime *runtime = substream->runtime; 68 68 struct ct_atc_pcm *apcm = ti->apcm;

+1 -1

sound/pci/echoaudio/midi.c

reviewed

··· 200 200 201 201 static void snd_echo_midi_output_write(struct timer_list *t) 202 202 { 203 203 - struct echoaudio *chip = from_timer(chip, t, timer); 203 203 + struct echoaudio *chip = timer_container_of(chip, t, timer); 204 204 unsigned long flags; 205 205 int bytes, sent, time; 206 206 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1];

+1 -1

sound/pci/rme9652/hdsp.c

reviewed

··· 1393 1393 1394 1394 static void snd_hdsp_midi_output_timer(struct timer_list *t) 1395 1395 { 1396 1396 - struct hdsp_midi *hmidi = from_timer(hmidi, t, timer); 1396 1396 + struct hdsp_midi *hmidi = timer_container_of(hmidi, t, timer); 1397 1397 unsigned long flags; 1398 1398 1399 1399 snd_hdsp_midi_output_write(hmidi);

+1 -1

sound/pci/rme9652/hdspm.c

reviewed

··· 1943 1943 1944 1944 static void snd_hdspm_midi_output_timer(struct timer_list *t) 1945 1945 { 1946 1946 - struct hdspm_midi *hmidi = from_timer(hmidi, t, timer); 1946 1946 + struct hdspm_midi *hmidi = timer_container_of(hmidi, t, timer); 1947 1947 unsigned long flags; 1948 1948 1949 1949 snd_hdspm_midi_output_write(hmidi);

+2 -2

sound/sh/aica.c

reviewed

··· 284 284 285 285 static void aica_period_elapsed(struct timer_list *t) 286 286 { 287 287 - struct snd_card_aica *dreamcastcard = from_timer(dreamcastcard, 288 288 - t, timer); 287 287 + struct snd_card_aica *dreamcastcard = timer_container_of(dreamcastcard, 288 288 + t, timer); 289 289 struct snd_pcm_substream *substream = dreamcastcard->substream; 290 290 /*timer function - so cannot sleep */ 291 291 int play_period;

+2 -1

sound/soc/codecs/rt5645.c

reviewed

··· 3439 3439 3440 3440 static void rt5645_btn_check_callback(struct timer_list *t) 3441 3441 { 3442 3442 - struct rt5645_priv *rt5645 = from_timer(rt5645, t, btn_check_timer); 3442 3442 + struct rt5645_priv *rt5645 = timer_container_of(rt5645, t, 3443 3443 + btn_check_timer); 3443 3444 3444 3445 queue_delayed_work(system_power_efficient_wq, 3445 3446 &rt5645->jack_detect_work, msecs_to_jiffies(5));

+1 -1

sound/soc/fsl/imx-pcm-rpmsg.c

reviewed

··· 209 209 static void imx_rpmsg_timer_callback(struct timer_list *t) 210 210 { 211 211 struct stream_timer *stream_timer = 212 212 - from_timer(stream_timer, t, timer); 212 212 + timer_container_of(stream_timer, t, timer); 213 213 struct snd_pcm_substream *substream = stream_timer->substream; 214 214 struct rpmsg_info *info = stream_timer->info; 215 215 struct rpmsg_msg *msg;

+1 -1

sound/synth/emux/emux_synth.c

reviewed

··· 190 190 */ 191 191 void snd_emux_timer_callback(struct timer_list *t) 192 192 { 193 193 - struct snd_emux *emu = from_timer(emu, t, tlist); 193 193 + struct snd_emux *emu = timer_container_of(emu, t, tlist); 194 194 struct snd_emux_voice *vp; 195 195 unsigned long flags; 196 196 int ch, do_again = 0;

+1 -1

sound/usb/midi.c

reviewed

··· 339 339 /* called after transfers had been interrupted due to some USB error */ 340 340 static void snd_usbmidi_error_timer(struct timer_list *t) 341 341 { 342 342 - struct snd_usb_midi *umidi = from_timer(umidi, t, error_timer); 342 342 + struct snd_usb_midi *umidi = timer_container_of(umidi, t, error_timer); 343 343 unsigned int i, j; 344 344 345 345 spin_lock(&umidi->disc_lock);