自学教程：C++ timeout_del函数代码示例

voidieee80211_free_node(struct ieee80211com *ic, struct ieee80211_node *ni){	if (ni == ic->ic_bss)		panic("freeing bss node");	splassert(IPL_NET);	DPRINTF(("%s/n", ether_sprintf(ni->ni_macaddr)));#ifndef IEEE80211_STA_ONLY	timeout_del(&ni->ni_eapol_to);	timeout_del(&ni->ni_sa_query_to);	IEEE80211_AID_CLR(ni->ni_associd, ic->ic_aid_bitmap);#endif	RB_REMOVE(ieee80211_tree, &ic->ic_tree, ni);	ic->ic_nnodes--;#ifndef IEEE80211_STA_ONLY	if (!IF_IS_EMPTY(&ni->ni_savedq)) {		IF_PURGE(&ni->ni_savedq);		if (ic->ic_set_tim != NULL)			(*ic->ic_set_tim)(ic, ni->ni_associd, 0);	}#endif	(*ic->ic_node_free)(ic, ni);	/* TBD indicate to drivers that a new node can be allocated */}

/* * Bell routines. */voiddnkbd_bell(void *v, u_int period, u_int pitch, u_int volume){	struct dnkbd_softc *sc = v;	int ticks, s;	s = spltty();	if (pitch == 0 || period == 0 || volume == 0) {		if (ISSET(sc->sc_flags, SF_BELL_TMO)) {			timeout_del(&sc->sc_bellstop_tmo);			dnkbd_bellstop(v);		}	} else {		ticks = (period * hz) / 1000;		if (ticks <= 0)			ticks = 1;		if (!ISSET(sc->sc_flags, SF_BELL)) {			dnkbd_pollout(sc->sc_regs, DNCMD_PREFIX);			dnkbd_pollout(sc->sc_regs, DNCMD_BELL);			dnkbd_pollout(sc->sc_regs, DNCMD_BELL_ON);			SET(sc->sc_flags, SF_BELL);		}		if (ISSET(sc->sc_flags, SF_BELL_TMO))			timeout_del(&sc->sc_bellstop_tmo);		timeout_add(&sc->sc_bellstop_tmo, ticks);		SET(sc->sc_flags, SF_BELL_TMO);	}	splx(s);}

intcom_detach(struct device *self, int flags){	struct com_softc *sc = (struct com_softc *)self;	int maj, mn;	sc->sc_swflags |= COM_SW_DEAD;	/* Locate the major number. */	for (maj = 0; maj < nchrdev; maj++)		if (cdevsw[maj].d_open == comopen)			break;	/* Nuke the vnodes for any open instances. */	mn = self->dv_unit;	vdevgone(maj, mn, mn, VCHR);	/* XXX a symbolic constant for the cua bit would be nicer. */	mn |= 0x80;	vdevgone(maj, mn, mn, VCHR);	/* Detach and free the tty. */	if (sc->sc_tty) {		ttyfree(sc->sc_tty);	}	timeout_del(&sc->sc_dtr_tmo);	timeout_del(&sc->sc_diag_tmo);	softintr_disestablish(sc->sc_si);	return (0);}

/* * Stop the keyboard controller when we are going to suspend */voidpckbc_stop(struct pckbc_softc *sc){	struct pckbc_internal *t = sc->id;	timeout_del(&t->t_poll);	pckbc_cleanqueues(t);	timeout_del(&t->t_cleanup);}

intgem_detach_pci(struct device *self, int flags){	struct gem_pci_softc *gsc = (void *)self;	struct gem_softc *sc = &gsc->gsc_gem;	timeout_del(&sc->sc_tick_ch);	timeout_del(&sc->sc_rx_watchdog);	gem_unconfig(sc);	pci_intr_disestablish(gsc->gsc_pc, gsc->gsc_ih);	bus_space_unmap(gsc->gsc_memt, gsc->gsc_memh, gsc->gsc_memsize);	return (0);}

voidnep_stop(struct ifnet *ifp){	struct nep_softc *sc = (struct nep_softc *)ifp->if_softc;	timeout_del(&sc->sc_tick_ch);}

voidbmac_stop(struct bmac_softc *sc){	struct ifnet *ifp = &sc->arpcom.ac_if;	int s;	s = splnet();	/* timeout */	timeout_del(&sc->sc_tick_ch);	mii_down(&sc->sc_mii);	/* Disable TX/RX. */	bmac_reset_bits(sc, TXCFG, TxMACEnable);	bmac_reset_bits(sc, RXCFG, RxMACEnable);	/* Disable all interrupts. */	bmac_write_reg(sc, INTDISABLE, NoEventsMask);	dbdma_stop(sc->sc_txdma);	dbdma_stop(sc->sc_rxdma);	ifp->if_flags &= ~(IFF_UP | IFF_RUNNING);	ifp->if_timer = 0;	splx(s);}

voidwskbd_input(struct device *dev, u_int type, int value){	struct wskbd_softc *sc = (struct wskbd_softc *)dev; #if NWSDISPLAY > 0	int num;#endif#if NWSDISPLAY > 0	if (sc->sc_repeating) {		sc->sc_repeating = 0;		timeout_del(&sc->sc_repeat_ch);	}	/*	 * If /dev/wskbdN is not connected in event mode translate and	 * send upstream.	 */	if (sc->sc_translating) {#ifdef HAVE_BURNER_SUPPORT		if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_displaydv != NULL)			wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_KBD);#endif		num = wskbd_translate(sc->id, type, value);		if (num > 0) {			if (sc->sc_displaydv != NULL) {#ifdef HAVE_SCROLLBACK_SUPPORT				/* XXX - Shift_R+PGUP(release) emits PrtSc */				if (sc->id->t_symbols[0] != KS_Print_Screen) {					wsscrollback(sc->sc_displaydv,					    WSDISPLAY_SCROLL_RESET);				}#endif				wsdisplay_kbdinput(sc->sc_displaydv,				    sc->id->t_keymap.layout,				    sc->id->t_symbols, num);			}			if (sc->sc_keyrepeat_data.del1 != 0) {				sc->sc_repeating = num;				timeout_add_msec(&sc->sc_repeat_ch,				    sc->sc_keyrepeat_data.del1);			}		}		return;	}#endif	wskbd_deliver_event(sc, type, value);#if NWSDISPLAY > 0	/* Repeat key presses if enabled. */	if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_keyrepeat_data.del1 != 0) {		sc->sc_repeat_type = type;		sc->sc_repeat_value = value;		sc->sc_repeating = 1;		timeout_add_msec(&sc->sc_repeat_ch, sc->sc_keyrepeat_data.del1);	}#endif}

voidykbec_bell(void *arg, u_int pitch, u_int period, u_int volume, int poll){	struct ykbec_softc *sc = (struct ykbec_softc *)arg;	int bctrl;	int s;	s = spltty();	bctrl = ykbec_read(sc, REG_BEEP_CONTROL);	if (volume == 0 || timeout_pending(&sc->sc_bell_tmo)) {		timeout_del(&sc->sc_bell_tmo);		/* inline ykbec_bell_stop(arg); */		ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE);	}	if (volume != 0) {		ykbec_write(sc, REG_BEEP_CONTROL, bctrl | BEEP_ENABLE);		if (poll) {			delay(period * 1000);			ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE);		} else {			timeout_add_msec(&sc->sc_bell_tmo, period);		}	}	splx(s);}

intre_pci_detach(struct device *self, int flags){	struct re_pci_softc	*psc = (struct re_pci_softc *)self;	struct rl_softc		*sc = &psc->sc_rl;	struct ifnet		*ifp = &sc->sc_arpcom.ac_if;	/* Remove timeout handler */	timeout_del(&sc->timer_handle);	/* Detach PHY */	if (LIST_FIRST(&sc->sc_mii.mii_phys) != NULL)		mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);	/* Delete media stuff */	ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);	ether_ifdetach(ifp);	if_detach(ifp);	/* Disable interrupts */	if (psc->sc_ih != NULL)		pci_intr_disestablish(psc->sc_pc, psc->sc_ih);	/* Free pci resources */	bus_space_unmap(sc->rl_btag, sc->rl_bhandle, psc->sc_iosize);	return (0);}

voidvnet_ldc_reset(struct ldc_conn *lc){	struct vnet_softc *sc = lc->lc_sc;	int i;	timeout_del(&sc->sc_handshake_to);	sc->sc_tx_prod = sc->sc_tx_cons = 0;	sc->sc_peer_state = VIO_DP_STOPPED;	sc->sc_vio_state = 0;	vnet_link_state(sc);	sc->sc_lm->lm_next = 1;	sc->sc_lm->lm_count = 1;	for (i = 1; i < sc->sc_lm->lm_nentries; i++)		sc->sc_lm->lm_slot[i].entry = 0;	for (i = 0; i < sc->sc_vd->vd_nentries; i++) {		if (sc->sc_vsd[i].vsd_buf) {			pool_put(&sc->sc_pool, sc->sc_vsd[i].vsd_buf);			sc->sc_vsd[i].vsd_buf = NULL;		}		sc->sc_vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE;	}}

EVQ_API intevq_del (struct event *ev, const int reuse_fd){  struct event_queue *evq = ev->evq;  const unsigned int ev_flags = ev->flags;  if (ev->tq) timeout_del(ev);  ev->evq = NULL;  evq->nevents--;  if (ev_flags & EVENT_TIMER) return 0;  if (ev_flags & EVENT_SIGNAL)    return signal_del(evq, ev);  if (ev_flags & EVENT_DIRWATCH)    return close(ev->fd);  if (!reuse_fd) return 0;  return ((ev_flags & EVENT_READ)    ? kqueue_set(evq, ev, EVFILT_READ, EV_DELETE) : 0)   | ((ev_flags & EVENT_WRITE)    ? kqueue_set(evq, ev, EVFILT_WRITE, EV_DELETE) : 0);}

voiddrm_vblank_cleanup(struct drm_device *dev){#if defined(__NetBSD__)	int	i;#endif /* defined(__NetBSD__) */	if (dev->vblank == NULL)		return; /* not initialised */	timeout_del(&dev->vblank->vb_disable_timer);#if defined(__NetBSD__)	callout_destroy(&dev->vblank->vb_disable_timer);#endif /* defined(__NetBSD__) */	vblank_disable(dev);#if defined(__NetBSD__)	for (i = 0; i < dev->vblank->vb_num; i++)		cv_destroy(&dev->vblank->vb_crtcs[i].condvar);	mutex_destroy(&dev->vblank->vb_lock);#endif /* defined(__NetBSD__) */	drm_free(dev->vblank);	dev->vblank = NULL;}

voidmec_stop(struct ifnet *ifp){	struct mec_softc *sc = ifp->if_softc;	struct mec_txsoft *txs;	int i;	DPRINTF(MEC_DEBUG_STOP, ("mec_stop/n"));	ifp->if_timer = 0;	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);	timeout_del(&sc->sc_tick_ch);	mii_down(&sc->sc_mii);	/* Disable DMA. */	bus_space_write_8(sc->sc_st, sc->sc_sh, MEC_DMA_CONTROL, 0);	/* Release any TX buffers. */	for (i = 0; i < MEC_NTXDESC; i++) {		txs = &sc->sc_txsoft[i];		if ((txs->txs_flags & MEC_TXS_TXDPTR1) != 0) {			bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);			m_freem(txs->txs_mbuf);			txs->txs_mbuf = NULL;		}	}}

intzts_enable(void *v){	struct zts_softc *sc = v;	if (sc->sc_enabled)		return EBUSY;	timeout_del(&sc->sc_ts_poll);	pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN);	/* XXX */	if (sc->sc_gh == NULL)		sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K,		    IST_EDGE_FALLING, IPL_TTY, zts_irq, sc,		    sc->sc_dev.dv_xname);	else		pxa2x0_gpio_intr_unmask(sc->sc_gh);	/* enable interrupts */	sc->sc_enabled = 1;	sc->sc_running = 1;	sc->sc_buttons = 0;	return 0;}

/* * Cardbus detach function: deallocate all resources */intre_cardbus_detach(struct device *self, int flags){	struct re_cardbus_softc *csc = (void *)self;	struct rl_softc *sc = &csc->sc_rl;	struct cardbus_devfunc *ct = csc->ct;	struct ifnet *ifp = &sc->sc_arpcom.ac_if;	/* Remove timeout handler */	timeout_del(&sc->timer_handle);	/* Detach PHY */	if (LIST_FIRST(&sc->sc_mii.mii_phys) != NULL)		mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);	/* Delete media stuff */	ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);	ether_ifdetach(ifp);	if_detach(ifp);	/* Disable interrupts */	if (csc->sc_ih != NULL)		cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);	/* Free cardbus resources */	Cardbus_mapreg_unmap(ct, csc->sc_bar_reg, sc->rl_btag, sc->rl_bhandle,	    csc->sc_mapsize);	return (0);}

intdnkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p){#ifdef WSDISPLAY_COMPAT_RAWKBD	struct dnkbd_softc *sc = v;#endif	switch (cmd) {	case WSKBDIO_GTYPE:		*(int *)data = WSKBD_TYPE_DOMAIN;		return (0);	case WSKBDIO_SETLEDS:		return (ENXIO);	case WSKBDIO_GETLEDS:		*(int *)data = 0;		return (0);	case WSKBDIO_COMPLEXBELL:#define	d	((struct wskbd_bell_data *)data)		dnkbd_bell(v, d->period, d->pitch, d->volume);#undef d		return (0);#ifdef WSDISPLAY_COMPAT_RAWKBD	case WSKBDIO_SETMODE:		sc->sc_rawkbd = *(int *)data == WSKBD_RAW;		timeout_del(&sc->sc_rawrepeat_ch);		return (0);#endif	}	return (-1);}

intukbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p){	struct ukbd_softc *sc = v;	switch (cmd) {	case WSKBDIO_GTYPE:		*(int *)data = WSKBD_TYPE_USB;		return (0);	case WSKBDIO_SETLEDS:		ukbd_set_leds(v, *(int *)data);		return (0);	case WSKBDIO_GETLEDS:		*(int *)data = sc->sc_leds;		return (0);	case WSKBDIO_COMPLEXBELL:#define d ((struct wskbd_bell_data *)data)		ukbd_bell(d->pitch, d->period, d->volume, 0);#undef d		return (0);#ifdef WSDISPLAY_COMPAT_RAWKBD	case WSKBDIO_SETMODE:		DPRINTF(("ukbd_ioctl: set raw = %d/n", *(int *)data));		sc->sc_rawkbd = *(int *)data == WSKBD_RAW;		timeout_del(&sc->sc_rawrepeat_ch);		return (0);#endif	}	return (-1);}

voidaps_power(int why, void *arg){	struct aps_softc *sc = (struct aps_softc *)arg;	bus_space_tag_t iot = sc->aps_iot;	bus_space_handle_t ioh = sc->aps_ioh;	unsigned char iobuf[16];	if (why != PWR_RESUME) {		timeout_del(&aps_timeout);		return;	}	/*	 * Redo the init sequence on resume, because APS is 	 * as forgetful as it is deaf.	 */	/* get APS mode */	iobuf[APS_CMD] = 0x13;	if (aps_do_io(iot, ioh, iobuf, APS_WRITE_0, APS_READ_1)	    || aps_init(iot, ioh))		printf("aps: failed to wake up/n");	else		timeout_add(&aps_timeout, (5 * hz) / 10);}

static intwin32thr_del (struct win32thr *wth, struct event *ev){    int i, n = --wth->n;    if (ev->tq) timeout_del(ev);    ev->wth = NULL;    wth->evq->nevents--;    i = ev->w.index;    if (ev->flags & EVENT_SOCKET) {	HANDLE hEvent = wth->handles[i];	WSAEventSelect((int) ev->fd, hEvent, 0);	CloseHandle(hEvent);    }    if (i < n) {	ev = wth->events[n];	ev->w.index = i;	wth->events[i] = ev;	wth->handles[i] = wth->handles[n];    }    wth->handles[n] = wth->signal;  /* lower signal event */    if (ev->flags & EVENT_DIRWATCH)	return !FindCloseChangeNotification(ev->fd);    return 0;}

/* * Pass command to device during normal operation. * to be called at spltty() */voidpckbc_start(struct pckbc_internal *t, pckbc_slot_t slot){	struct pckbc_slotdata *q = t->t_slotdata[slot];	struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);	if (q->polling) {		do {			pckbc_poll_cmd1(t, slot, cmd);			if (cmd->status)				printf("pckbc_start: command error/n");			if (cmd->flags & KBC_CMDFLAG_SYNC) {				wakeup(cmd);				cmd = TAILQ_NEXT(cmd, next);			} else {				TAILQ_REMOVE(&q->cmdqueue, cmd, next);				timeout_del(&t->t_cleanup);				TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);				cmd = TAILQ_FIRST(&q->cmdqueue);			}		} while (cmd);		return;	}	if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {		printf("pckbc_start: send error/n");		/* XXX what now? */		return;	}}

voidvnet_ldc_start(struct ldc_conn *lc){	struct vnet_softc *sc = lc->lc_sc;	timeout_del(&sc->sc_handshake_to);	vnet_send_ver_info(sc, VNET_MAJOR, VNET_MINOR);}

voidlpt_detach_common(struct lpt_softc *sc){	timeout_del(&sc->sc_wakeup_tmo);	if (sc->sc_state != 0) {		sc->sc_state = 0;		wakeup(sc);	}}

intocteon_eth_stop(struct ifnet *ifp, int disable){	struct octeon_eth_softc *sc = ifp->if_softc;	timeout_del(&sc->sc_tick_misc_ch);	timeout_del(&sc->sc_tick_free_ch);	timeout_del(&sc->sc_resume_ch);	mii_down(&sc->sc_mii);	cn30xxgmx_port_enable(sc->sc_gmx_port, 0);	/* Mark the interface as down and cancel the watchdog timer. */	CLR(ifp->if_flags, IFF_RUNNING | IFF_OACTIVE);	ifp->if_timer = 0;	return 0;}