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

voidieee80211_notify_country(struct ieee80211vap *vap,	const uint8_t bssid[IEEE80211_ADDR_LEN], const uint8_t cc[2]){	struct ifnet *ifp = vap->iv_ifp;	struct ieee80211_country_event iev;	memset(&iev, 0, sizeof(iev));	IEEE80211_ADDR_COPY(iev.iev_addr, bssid);	iev.iev_cc[0] = cc[0];	iev.iev_cc[1] = cc[1];	CURVNET_SET(ifp->if_vnet);	rt_ieee80211msg(ifp, RTM_IEEE80211_COUNTRY, &iev, sizeof(iev));	CURVNET_RESTORE();}

voidieee80211_notify_radar(struct ieee80211com *ic,	const struct ieee80211_channel *c){	struct ifnet *ifp = ic->ic_ifp;	struct ieee80211_radar_event iev;	memset(&iev, 0, sizeof(iev));	iev.iev_flags = c->ic_flags;	iev.iev_freq = c->ic_freq;	iev.iev_ieee = c->ic_ieee;	CURVNET_SET(ifp->if_vnet);	rt_ieee80211msg(ifp, RTM_IEEE80211_RADAR, &iev, sizeof(iev));	CURVNET_RESTORE();}

/* * Tcp protocol timeout routine called every 500 ms. * Updates timestamps used for TCP * causes finite state machine actions if timers expire. */voidtcp_slowtimo(void){	VNET_ITERATOR_DECL(vnet_iter);	VNET_LIST_RLOCK_NOSLEEP();	VNET_FOREACH(vnet_iter) {		CURVNET_SET(vnet_iter);		INP_INFO_WLOCK(&V_tcbinfo);		(void) tcp_tw_2msl_scan(0);		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();	}	VNET_LIST_RUNLOCK_NOSLEEP();}

voidieee80211_notify_cac(struct ieee80211com *ic,	const struct ieee80211_channel *c, enum ieee80211_notify_cac_event type){	struct ifnet *ifp = ic->ic_ifp;	struct ieee80211_cac_event iev;	memset(&iev, 0, sizeof(iev));	iev.iev_flags = c->ic_flags;	iev.iev_freq = c->ic_freq;	iev.iev_ieee = c->ic_ieee;	iev.iev_type = type;	CURVNET_SET(ifp->if_vnet);	rt_ieee80211msg(ifp, RTM_IEEE80211_CAC, &iev, sizeof(iev));	CURVNET_RESTORE();}

voidieee80211_notify_csa(struct ieee80211com *ic,	const struct ieee80211_channel *c, int mode, int count){	struct ifnet *ifp = ic->ic_ifp;	struct ieee80211_csa_event iev;	memset(&iev, 0, sizeof(iev));	iev.iev_flags = c->ic_flags;	iev.iev_freq = c->ic_freq;	iev.iev_ieee = c->ic_ieee;	iev.iev_mode = mode;	iev.iev_count = count;	CURVNET_SET(ifp->if_vnet);	rt_ieee80211msg(ifp, RTM_IEEE80211_CSA, &iev, sizeof(iev));	CURVNET_RESTORE();}

static voidin_rtqtimo(void *rock){	CURVNET_SET((struct vnet *) rock);	int fibnum;	void *newrock;	struct timeval atv;	for (fibnum = 0; fibnum < rt_numfibs; fibnum++) {		newrock = rt_tables_get_rnh(fibnum, AF_INET);		if (newrock != NULL)			in_rtqtimo_one(newrock);	}	atv.tv_usec = 0;	atv.tv_sec = V_rtq_timeout;	callout_reset(&V_rtq_timer, tvtohz(&atv), in_rtqtimo, rock);	CURVNET_RESTORE();}

ipfpoll(dev_t dev, int events, struct proc *td)#endif{	int unit = GET_MINOR(dev);	int revents;	if (unit < 0 || unit > IPL_LOGMAX)		return 0;	revents = 0;	CURVNET_SET(TD_TO_VNET(td));	switch (unit)	{	case IPL_LOGIPF :	case IPL_LOGNAT :	case IPL_LOGSTATE :#ifdef IPFILTER_LOG		if ((events & (POLLIN | POLLRDNORM)) && ipf_log_canread(&V_ipfmain, unit))			revents |= events & (POLLIN | POLLRDNORM);#endif		break;	case IPL_LOGAUTH :		if ((events & (POLLIN | POLLRDNORM)) && ipf_auth_waiting(&V_ipfmain))			revents |= events & (POLLIN | POLLRDNORM);		break;	case IPL_LOGSYNC :		if ((events & (POLLIN | POLLRDNORM)) && ipf_sync_canread(&V_ipfmain))			revents |= events & (POLLIN | POLLRDNORM);		if ((events & (POLLOUT | POLLWRNORM)) && ipf_sync_canwrite(&V_ipfmain))			revents |= events & (POLLOUT | POLLWRNORM);		break;	case IPL_LOGSCAN :	case IPL_LOGLOOKUP :	default :		break;	}	if ((revents == 0) && ((events & (POLLIN|POLLRDNORM)) != 0))		selrecord(td, &V_ipfmain.ipf_selwait[unit]);	CURVNET_RESTORE();	return revents;}

/* * Detach net80211 state on device detach.  Tear down * all vap's and reclaim all common state prior to the * device state going away.  Note we may call back into * driver; it must be prepared for this. */voidieee80211_ifdetach(struct ieee80211com *ic){	struct ifnet *ifp = ic->ic_ifp;	struct ieee80211vap *vap;	/*	 * This detaches the main interface, but not the vaps.	 * Each VAP may be in a separate VIMAGE.	 */	CURVNET_SET(ifp->if_vnet);	if_detach(ifp);	CURVNET_RESTORE();	/*	 * The VAP is responsible for setting and clearing	 * the VIMAGE context.	 */	while ((vap = TAILQ_FIRST(&ic->ic_vaps)) != NULL)		ieee80211_vap_destroy(vap);	ieee80211_waitfor_parent(ic);	ieee80211_sysctl_detach(ic);	ieee80211_dfs_detach(ic);	ieee80211_regdomain_detach(ic);	ieee80211_scan_detach(ic);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_superg_detach(ic);#endif	ieee80211_ht_detach(ic);	/* NB: must be called before ieee80211_node_detach */	ieee80211_proto_detach(ic);	ieee80211_crypto_detach(ic);	ieee80211_power_detach(ic);	ieee80211_node_detach(ic);	/* XXX VNET needed? */	ifmedia_removeall(&ic->ic_media);	taskqueue_free(ic->ic_tq);	IEEE80211_TX_LOCK_DESTROY(ic);	IEEE80211_LOCK_DESTROY(ic);}

voidact_open_failure_cleanup(struct adapter *sc, u_int atid, u_int status){	struct toepcb *toep = lookup_atid(sc, atid);	struct inpcb *inp = toep->inp;	struct toedev *tod = &toep->td->tod;	free_atid(sc, atid);	toep->tid = -1;	CURVNET_SET(toep->vnet);	if (status != EAGAIN)		INP_INFO_RLOCK(&V_tcbinfo);	INP_WLOCK(inp);	toe_connect_failed(tod, inp, status);	final_cpl_received(toep);	/* unlocks inp */	if (status != EAGAIN)		INP_INFO_RUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();}

/* * Active open succeeded. */static intdo_act_establish(struct sge_iq *iq, const struct rss_header *rss,    struct mbuf *m){	struct adapter *sc = iq->adapter;	const struct cpl_act_establish *cpl = (const void *)(rss + 1);	u_int tid = GET_TID(cpl);	u_int atid = G_TID_TID(ntohl(cpl->tos_atid));	struct toepcb *toep = lookup_atid(sc, atid);	struct inpcb *inp = toep->inp;	KASSERT(m == NULL, ("%s: wasn't expecting payload", __func__));	KASSERT(toep->tid == atid, ("%s: toep tid/atid mismatch", __func__));	CTR3(KTR_CXGBE, "%s: atid %u, tid %u", __func__, atid, tid);	free_atid(sc, atid);	CURVNET_SET(toep->vnet);	INP_WLOCK(inp);	toep->tid = tid;	insert_tid(sc, tid, toep, inp->inp_vflag & INP_IPV6 ? 2 : 1);	if (inp->inp_flags & INP_DROPPED) {		/* socket closed by the kernel before hw told us it connected */		send_flowc_wr(toep, NULL);		send_reset(sc, toep, be32toh(cpl->snd_isn));		goto done;	}	make_established(toep, be32toh(cpl->snd_isn) - 1,	    be32toh(cpl->rcv_isn) - 1, cpl->tcp_opt);	if (toep->ulp_mode == ULP_MODE_TLS)		tls_establish(toep);done:	INP_WUNLOCK(inp);	CURVNET_RESTORE();	return (0);}

voidtcp_timer_delack(void *xtp){	struct tcpcb *tp = xtp;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);	inp = tp->t_inpcb;	/*	 * XXXRW: While this assert is in fact correct, bugs in the tcpcb	 * tear-down mean we need it as a work-around for races between	 * timers and tcp_discardcb().	 *	 * KASSERT(inp != NULL, ("tcp_timer_delack: inp == NULL"));	 */	if (inp == NULL) {		tcp_timer_race++;		CURVNET_RESTORE();		return;	}	INP_WLOCK(inp);	if (callout_pending(&tp->t_timers->tt_delack) ||	    !callout_active(&tp->t_timers->tt_delack)) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_delack);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	tp->t_flags |= TF_ACKNOW;	TCPSTAT_INC(tcps_delack);	(void) tcp_output(tp);	INP_WUNLOCK(inp);	CURVNET_RESTORE();}

voidieee80211_notify_michael_failure(struct ieee80211vap *vap,	const struct ieee80211_frame *wh, u_int keyix){	struct ifnet *ifp = vap->iv_ifp;	IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,	    "michael MIC verification failed <keyix %u>", keyix);	vap->iv_stats.is_rx_tkipmic++;	if (ifp != NULL) {		/* NB: for cipher test modules */		struct ieee80211_michael_event iev;		IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);		IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);		iev.iev_cipher = IEEE80211_CIPHER_TKIP;		iev.iev_keyix = keyix;		CURVNET_SET(ifp->if_vnet);		rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev));		CURVNET_RESTORE();	}}

static intsoo_ioctl(struct file *fp, u_long cmd, void *data, struct ucred *active_cred,    struct thread *td){	struct socket *so = fp->f_data;	int error = 0;	switch (cmd) {	case FIONBIO:		SOCK_LOCK(so);		if (*(int *)data)			so->so_state |= SS_NBIO;		else			so->so_state &= ~SS_NBIO;		SOCK_UNLOCK(so);		break;	case FIOASYNC:		/*		 * XXXRW: This code separately acquires SOCK_LOCK(so) and		 * SOCKBUF_LOCK(&so->so_rcv) even though they are the same		 * mutex to avoid introducing the assumption that they are		 * the same.		 */		if (*(int *)data) {			SOCK_LOCK(so);			so->so_state |= SS_ASYNC;			SOCK_UNLOCK(so);			SOCKBUF_LOCK(&so->so_rcv);			so->so_rcv.sb_flags |= SB_ASYNC;			SOCKBUF_UNLOCK(&so->so_rcv);			SOCKBUF_LOCK(&so->so_snd);			so->so_snd.sb_flags |= SB_ASYNC;			SOCKBUF_UNLOCK(&so->so_snd);		} else {			SOCK_LOCK(so);			so->so_state &= ~SS_ASYNC;			SOCK_UNLOCK(so);			SOCKBUF_LOCK(&so->so_rcv);			so->so_rcv.sb_flags &= ~SB_ASYNC;			SOCKBUF_UNLOCK(&so->so_rcv);			SOCKBUF_LOCK(&so->so_snd);			so->so_snd.sb_flags &= ~SB_ASYNC;			SOCKBUF_UNLOCK(&so->so_snd);		}		break;	case FIONREAD:		/* Unlocked read. */		*(int *)data = sbavail(&so->so_rcv);		break;	case FIONWRITE:		/* Unlocked read. */		*(int *)data = sbavail(&so->so_snd);		break;	case FIONSPACE:		/* Unlocked read. */		if ((so->so_snd.sb_hiwat < sbused(&so->so_snd)) ||		    (so->so_snd.sb_mbmax < so->so_snd.sb_mbcnt))			*(int *)data = 0;		else			*(int *)data = sbspace(&so->so_snd);		break;	case FIOSETOWN:		error = fsetown(*(int *)data, &so->so_sigio);		break;	case FIOGETOWN:		*(int *)data = fgetown(&so->so_sigio);		break;	case SIOCSPGRP:		error = fsetown(-(*(int *)data), &so->so_sigio);		break;	case SIOCGPGRP:		*(int *)data = -fgetown(&so->so_sigio);		break;	case SIOCATMARK:		/* Unlocked read. */		*(int *)data = (so->so_rcv.sb_state & SBS_RCVATMARK) != 0;		break;	default:		/*		 * Interface/routing/protocol specific ioctls: interface and		 * routing ioctls should have a different entry since a		 * socket is unnecessary.		 */		if (IOCGROUP(cmd) == 'i')			error = ifioctl(so, cmd, data, td);		else if (IOCGROUP(cmd) == 'r') {			CURVNET_SET(so->so_vnet);			error = rtioctl_fib(cmd, data, so->so_fibnum);			CURVNET_RESTORE();		} else {			CURVNET_SET(so->so_vnet);//.........这里部分代码省略.........

voidtcp_timer_2msl(void *xtp){	struct tcpcb *tp = xtp;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	/*	 * XXXRW: Does this actually happen?	 */	INP_INFO_WLOCK(&V_tcbinfo);	inp = tp->t_inpcb;	/*	 * XXXRW: While this assert is in fact correct, bugs in the tcpcb	 * tear-down mean we need it as a work-around for races between	 * timers and tcp_discardcb().	 *	 * KASSERT(inp != NULL, ("tcp_timer_2msl: inp == NULL"));	 */	if (inp == NULL) {		tcp_timer_race++;		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	INP_WLOCK(inp);	tcp_free_sackholes(tp);	if ((inp->inp_flags & INP_DROPPED) || callout_pending(&tp->t_timers->tt_2msl) ||	    !callout_active(&tp->t_timers->tt_2msl)) {		INP_WUNLOCK(tp->t_inpcb);		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_2msl);	/*	 * 2 MSL timeout in shutdown went off.  If we're closed but	 * still waiting for peer to close and connection has been idle	 * too long, or if 2MSL time is up from TIME_WAIT, delete connection	 * control block.  Otherwise, check again in a bit.	 *	 * If fastrecycle of FIN_WAIT_2, in FIN_WAIT_2 and receiver has closed, 	 * there's no point in hanging onto FIN_WAIT_2 socket. Just close it. 	 * Ignore fact that there were recent incoming segments.	 */	if (tcp_fast_finwait2_recycle && tp->t_state == TCPS_FIN_WAIT_2 &&	    tp->t_inpcb && tp->t_inpcb->inp_socket && 	    (tp->t_inpcb->inp_socket->so_rcv.sb_state & SBS_CANTRCVMORE)) {		TCPSTAT_INC(tcps_finwait2_drops);		tp = tcp_close(tp);             	} else {		if (tp->t_state != TCPS_TIME_WAIT &&		   ticks - tp->t_rcvtime <= TP_MAXIDLE(tp))		       callout_reset_on(&tp->t_timers->tt_2msl,			   TP_KEEPINTVL(tp), tcp_timer_2msl, tp, INP_CPU(inp));	       else		       tp = tcp_close(tp);       }#ifdef TCPDEBUG	if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	if (tp != NULL)		INP_WUNLOCK(inp);	INP_INFO_WUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();}

//.........这里部分代码省略.........	/*	 * XXX splnet, so networks will receive...	 */	splnet();	/*	 * Do enough of ifconfig(8) so that the critical net interface can	 * talk to the server.	 */	error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,	    td->td_ucred, td);	if (error)		panic("nfs_mountroot: socreate(%04x): %d",			nd->myif.ifra_addr.sa_family, error);#if 0 /* XXX Bad idea */	/*	 * We might not have been told the right interface, so we pass	 * over the first ten interfaces of the same kind, until we get	 * one of them configured.	 */	for (i = strlen(nd->myif.ifra_name) - 1;		nd->myif.ifra_name[i] >= '0' &&		nd->myif.ifra_name[i] <= '9';		nd->myif.ifra_name[i] ++) {		error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);		if(!error)			break;	}#endif	error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);	if (error)		panic("nfs_mountroot: SIOCAIFADDR: %d", error);	if ((cp = getenv("boot.netif.mtu")) != NULL) {		ir.ifr_mtu = strtol(cp, NULL, 10);		bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);		freeenv(cp);		error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);		if (error)			printf("nfs_mountroot: SIOCSIFMTU: %d", error);	}	soclose(so);	/*	 * If the gateway field is filled in, set it as the default route.	 * Note that pxeboot will set a default route of 0 if the route	 * is not set by the DHCP server.  Check also for a value of 0	 * to avoid panicking inappropriately in that situation.	 */	if (nd->mygateway.sin_len != 0 &&	    nd->mygateway.sin_addr.s_addr != 0) {		struct sockaddr_in mask, sin;		bzero((caddr_t)&mask, sizeof(mask));		sin = mask;		sin.sin_family = AF_INET;		sin.sin_len = sizeof(sin);                /* XXX MRT use table 0 for this sort of thing */		CURVNET_SET(TD_TO_VNET(td));		error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,		    (struct sockaddr *)&nd->mygateway,		    (struct sockaddr *)&mask,		    RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);		CURVNET_RESTORE();		if (error)			panic("nfs_mountroot: RTM_ADD: %d", error);	}	/*	 * Create the rootfs mount point.	 */	nd->root_args.fh = nd->root_fh;	nd->root_args.fhsize = nd->root_fhsize;	l = ntohl(nd->root_saddr.sin_addr.s_addr);	snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",		(l >> 24) & 0xff, (l >> 16) & 0xff,		(l >>  8) & 0xff, (l >>  0) & 0xff, nd->root_hostnam);	printf("NFS ROOT: %s/n", buf);	nd->root_args.hostname = buf;	if ((error = nfs_mountdiskless(buf,	    &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {		return (error);	}	/*	 * This is not really an nfs issue, but it is much easier to	 * set hostname here and then let the "/etc/rc.xxx" files	 * mount the right /var based upon its preset value.	 */	mtx_lock(&prison0.pr_mtx);	strlcpy(prison0.pr_hostname, nd->my_hostnam,	    sizeof (prison0.pr_hostname));	mtx_unlock(&prison0.pr_mtx);	inittodr(ntohl(nd->root_time));	return (0);}

/*  * Tear down vap state and reclaim the ifnet. * The driver is assumed to have prepared for * this; e.g. by turning off interrupts for the * underlying device. */voidieee80211_vap_detach(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ifnet *ifp = vap->iv_ifp;	CURVNET_SET(ifp->if_vnet);	IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s parent %s/n",	    __func__, ieee80211_opmode_name[vap->iv_opmode],	    ic->ic_ifp->if_xname);	/* NB: bpfdetach is called by ether_ifdetach and claims all taps */	ether_ifdetach(ifp);	ieee80211_stop(vap);	/*	 * Flush any deferred vap tasks.	 */	ieee80211_draintask(ic, &vap->iv_nstate_task);	ieee80211_draintask(ic, &vap->iv_swbmiss_task);	/* XXX band-aid until ifnet handles this for us */	taskqueue_drain(taskqueue_swi, &ifp->if_linktask);	IEEE80211_LOCK(ic);	KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running"));	TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next);	ieee80211_syncflag_locked(ic, IEEE80211_F_WME);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP);#endif	ieee80211_syncflag_locked(ic, IEEE80211_F_PCF);	ieee80211_syncflag_locked(ic, IEEE80211_F_BURST);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);	/* NB: this handles the bpfdetach done below */	ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF);	ieee80211_syncifflag_locked(ic, IFF_PROMISC);	ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);	IEEE80211_UNLOCK(ic);	ifmedia_removeall(&vap->iv_media);	ieee80211_radiotap_vdetach(vap);	ieee80211_regdomain_vdetach(vap);	ieee80211_scan_vdetach(vap);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_superg_vdetach(vap);#endif	ieee80211_ht_vdetach(vap);	/* NB: must be before ieee80211_node_vdetach */	ieee80211_proto_vdetach(vap);	ieee80211_crypto_vdetach(vap);	ieee80211_power_vdetach(vap);	ieee80211_node_vdetach(vap);	ieee80211_sysctl_vdetach(vap);	if_free(ifp);	CURVNET_RESTORE();}

/* * The timer handler for dummynet. Time is computed in ticks, but * but the code is tolerant to the actual rate at which this is called. * Once complete, the function reschedules itself for the next tick. */voiddummynet_task(void *context, int pending){	struct timeval t;	struct mq q = { NULL, NULL }; /* queue to accumulate results */	CURVNET_SET((struct vnet *)context);	DN_BH_WLOCK();	/* Update number of lost(coalesced) ticks. */	tick_lost += pending - 1;	getmicrouptime(&t);	/* Last tick duration (usec). */	tick_last = (t.tv_sec - dn_cfg.prev_t.tv_sec) * 1000000 +	(t.tv_usec - dn_cfg.prev_t.tv_usec);	/* Last tick vs standard tick difference (usec). */	tick_delta = (tick_last * hz - 1000000) / hz;	/* Accumulated tick difference (usec). */	tick_delta_sum += tick_delta;	dn_cfg.prev_t = t;	/*	* Adjust curr_time if the accumulated tick difference is	* greater than the 'standard' tick. Since curr_time should	* be monotonically increasing, we do positive adjustments	* as required, and throttle curr_time in case of negative	* adjustment.	*/	dn_cfg.curr_time++;	if (tick_delta_sum - tick >= 0) {		int diff = tick_delta_sum / tick;		dn_cfg.curr_time += diff;		tick_diff += diff;		tick_delta_sum %= tick;		tick_adjustment++;	} else if (tick_delta_sum + tick <= 0) {		dn_cfg.curr_time--;		tick_diff--;		tick_delta_sum += tick;		tick_adjustment++;	}	/* serve pending events, accumulate in q */	for (;;) {		struct dn_id *p;    /* generic parameter to handler */		if (dn_cfg.evheap.elements == 0 ||		    DN_KEY_LT(dn_cfg.curr_time, HEAP_TOP(&dn_cfg.evheap)->key))			break;		p = HEAP_TOP(&dn_cfg.evheap)->object;		heap_extract(&dn_cfg.evheap, NULL);		if (p->type == DN_SCH_I) {			serve_sched(&q, (struct dn_sch_inst *)p, dn_cfg.curr_time);		} else { /* extracted a delay line */			transmit_event(&q, (struct delay_line *)p, dn_cfg.curr_time);		}	}	if (dn_cfg.expire && ++dn_cfg.expire_cycle >= dn_cfg.expire) {		dn_cfg.expire_cycle = 0;		dn_drain_scheduler();		dn_drain_queue();	}	DN_BH_WUNLOCK();	dn_reschedule();	if (q.head != NULL)		dummynet_send(q.head);	CURVNET_RESTORE();}

/* * Attach/setup the common net80211 state.  Called by * the driver on attach to prior to creating any vap's. */voidieee80211_ifattach(struct ieee80211com *ic,	const uint8_t macaddr[IEEE80211_ADDR_LEN]){	struct ifnet *ifp = ic->ic_ifp;	struct sockaddr_dl *sdl;	struct ifaddr *ifa;	KASSERT(ifp->if_type == IFT_IEEE80211, ("if_type %d", ifp->if_type));	IEEE80211_LOCK_INIT(ic, ifp->if_xname);	IEEE80211_TX_LOCK_INIT(ic, ifp->if_xname);	TAILQ_INIT(&ic->ic_vaps);	/* Create a taskqueue for all state changes */	ic->ic_tq = taskqueue_create("ic_taskq", M_WAITOK | M_ZERO,	    taskqueue_thread_enqueue, &ic->ic_tq);	taskqueue_start_threads(&ic->ic_tq, 1, PI_NET, "%s net80211 taskq",	    ifp->if_xname);	/*	 * Fill in 802.11 available channel set, mark all	 * available channels as active, and pick a default	 * channel if not already specified.	 */	ieee80211_media_init(ic);	ic->ic_update_mcast = null_update_mcast;	ic->ic_update_promisc = null_update_promisc;	ic->ic_update_chw = null_update_chw;	ic->ic_hash_key = arc4random();	ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT;	ic->ic_lintval = ic->ic_bintval;	ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX;	ieee80211_crypto_attach(ic);	ieee80211_node_attach(ic);	ieee80211_power_attach(ic);	ieee80211_proto_attach(ic);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_superg_attach(ic);#endif	ieee80211_ht_attach(ic);	ieee80211_scan_attach(ic);	ieee80211_regdomain_attach(ic);	ieee80211_dfs_attach(ic);	ieee80211_sysctl_attach(ic);	ifp->if_addrlen = IEEE80211_ADDR_LEN;	ifp->if_hdrlen = 0;	CURVNET_SET(vnet0);	if_attach(ifp);	ifp->if_mtu = IEEE80211_MTU_MAX;	ifp->if_broadcastaddr = ieee80211broadcastaddr;	ifp->if_output = null_output;	ifp->if_input = null_input;	/* just in case */	ifp->if_resolvemulti = NULL;	/* NB: callers check */	ifa = ifaddr_byindex(ifp->if_index);	KASSERT(ifa != NULL, ("%s: no lladdr!/n", __func__));	sdl = (struct sockaddr_dl *)ifa->ifa_addr;	sdl->sdl_type = IFT_ETHER;		/* XXX IFT_IEEE80211? */	sdl->sdl_alen = IEEE80211_ADDR_LEN;	IEEE80211_ADDR_COPY(LLADDR(sdl), macaddr);	ifa_free(ifa);	CURVNET_RESTORE();}

voidtcp_timer_persist(void *xtp){	struct tcpcb *tp = xtp;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	inp = tp->t_inpcb;	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL", __func__, tp));	INP_WLOCK(inp);	if (callout_pending(&tp->t_timers->tt_persist) ||	    !callout_active(&tp->t_timers->tt_persist)) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_persist);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) == 0,		("%s: tp %p tcpcb can't be stopped here", __func__, tp));	/*	 * Persistence timer into zero window.	 * Force a byte to be output, if possible.	 */	TCPSTAT_INC(tcps_persisttimeo);	/*	 * Hack: if the peer is dead/unreachable, we do not	 * time out if the window is closed.  After a full	 * backoff, drop the connection if the idle time	 * (no responses to probes) reaches the maximum	 * backoff that we would use if retransmitting.	 */	if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&	    (ticks - tp->t_rcvtime >= tcp_maxpersistidle ||	     ticks - tp->t_rcvtime >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {		TCPSTAT_INC(tcps_persistdrop);		if (tcp_inpinfo_lock_add(inp)) {			tcp_inpinfo_lock_del(inp, tp);			goto out;		}		tp = tcp_drop(tp, ETIMEDOUT);		tcp_inpinfo_lock_del(inp, tp);		goto out;	}	/*	 * If the user has closed the socket then drop a persisting	 * connection after a much reduced timeout.	 */	if (tp->t_state > TCPS_CLOSE_WAIT &&	    (ticks - tp->t_rcvtime) >= TCPTV_PERSMAX) {		TCPSTAT_INC(tcps_persistdrop);		if (tcp_inpinfo_lock_add(inp)) {			tcp_inpinfo_lock_del(inp, tp);			goto out;		}		tp = tcp_drop(tp, ETIMEDOUT);		tcp_inpinfo_lock_del(inp, tp);		goto out;	}	tcp_setpersist(tp);	tp->t_flags |= TF_FORCEDATA;	(void) tp->t_fb->tfb_tcp_output(tp);	tp->t_flags &= ~TF_FORCEDATA;#ifdef TCPDEBUG	if (tp != NULL && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)		tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);#endif	TCP_PROBE2(debug__user, tp, PRU_SLOWTIMO);	INP_WUNLOCK(inp);out:	CURVNET_RESTORE();}

voidtcp_timer_rexmt(void * xtp){	struct tcpcb *tp = xtp;	CURVNET_SET(tp->t_vnet);	int rexmt;	struct inpcb *inp;#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	inp = tp->t_inpcb;	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL", __func__, tp));	INP_WLOCK(inp);	if (callout_pending(&tp->t_timers->tt_rexmt) ||	    !callout_active(&tp->t_timers->tt_rexmt)) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_rexmt);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) == 0,		("%s: tp %p tcpcb can't be stopped here", __func__, tp));	tcp_free_sackholes(tp);	if (tp->t_fb->tfb_tcp_rexmit_tmr) {		/* The stack has a timer action too. */		(*tp->t_fb->tfb_tcp_rexmit_tmr)(tp);	}	/*	 * Retransmission timer went off.  Message has not	 * been acked within retransmit interval.  Back off	 * to a longer retransmit interval and retransmit one segment.	 */	if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {		tp->t_rxtshift = TCP_MAXRXTSHIFT;		TCPSTAT_INC(tcps_timeoutdrop);		if (tcp_inpinfo_lock_add(inp)) {			tcp_inpinfo_lock_del(inp, tp);			goto out;		}		tp = tcp_drop(tp, tp->t_softerror ?			      tp->t_softerror : ETIMEDOUT);		tcp_inpinfo_lock_del(inp, tp);		goto out;	}	if (tp->t_state == TCPS_SYN_SENT) {		/*		 * If the SYN was retransmitted, indicate CWND to be		 * limited to 1 segment in cc_conn_init().		 */		tp->snd_cwnd = 1;	} else if (tp->t_rxtshift == 1) {		/*		 * first retransmit; record ssthresh and cwnd so they can		 * be recovered if this turns out to be a "bad" retransmit.		 * A retransmit is considered "bad" if an ACK for this		 * segment is received within RTT/2 interval; the assumption		 * here is that the ACK was already in flight.  See		 * "On Estimating End-to-End Network Path Properties" by		 * Allman and Paxson for more details.		 */		tp->snd_cwnd_prev = tp->snd_cwnd;		tp->snd_ssthresh_prev = tp->snd_ssthresh;		tp->snd_recover_prev = tp->snd_recover;		if (IN_FASTRECOVERY(tp->t_flags))			tp->t_flags |= TF_WASFRECOVERY;		else			tp->t_flags &= ~TF_WASFRECOVERY;		if (IN_CONGRECOVERY(tp->t_flags))			tp->t_flags |= TF_WASCRECOVERY;		else			tp->t_flags &= ~TF_WASCRECOVERY;		tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));		tp->t_flags |= TF_PREVVALID;	} else

voidtcp_timer_2msl(void *xtp){	struct tcpcb *tp = xtp;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	inp = tp->t_inpcb;	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL", __func__, tp));	INP_WLOCK(inp);	tcp_free_sackholes(tp);	if (callout_pending(&tp->t_timers->tt_2msl) ||	    !callout_active(&tp->t_timers->tt_2msl)) {		INP_WUNLOCK(tp->t_inpcb);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_2msl);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) == 0,		("%s: tp %p tcpcb can't be stopped here", __func__, tp));	/*	 * 2 MSL timeout in shutdown went off.  If we're closed but	 * still waiting for peer to close and connection has been idle	 * too long delete connection control block.  Otherwise, check	 * again in a bit.	 *	 * If in TIME_WAIT state just ignore as this timeout is handled in	 * tcp_tw_2msl_scan().	 *	 * If fastrecycle of FIN_WAIT_2, in FIN_WAIT_2 and receiver has closed, 	 * there's no point in hanging onto FIN_WAIT_2 socket. Just close it. 	 * Ignore fact that there were recent incoming segments.	 */	if ((inp->inp_flags & INP_TIMEWAIT) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	if (tcp_fast_finwait2_recycle && tp->t_state == TCPS_FIN_WAIT_2 &&	    tp->t_inpcb && tp->t_inpcb->inp_socket && 	    (tp->t_inpcb->inp_socket->so_rcv.sb_state & SBS_CANTRCVMORE)) {		TCPSTAT_INC(tcps_finwait2_drops);		if (tcp_inpinfo_lock_add(inp)) {			tcp_inpinfo_lock_del(inp, tp);			goto out;		}		tp = tcp_close(tp);             		tcp_inpinfo_lock_del(inp, tp);		goto out;	} else {		if (ticks - tp->t_rcvtime <= TP_MAXIDLE(tp)) {			callout_reset(&tp->t_timers->tt_2msl,				      TP_KEEPINTVL(tp), tcp_timer_2msl, tp);		} else {			if (tcp_inpinfo_lock_add(inp)) {				tcp_inpinfo_lock_del(inp, tp);				goto out;			}			tp = tcp_close(tp);			tcp_inpinfo_lock_del(inp, tp);			goto out;		}       }#ifdef TCPDEBUG	if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	TCP_PROBE2(debug__user, tp, PRU_SLOWTIMO);	if (tp != NULL)		INP_WUNLOCK(inp);out:	CURVNET_RESTORE();}

voidtcp_timer_keep(void *xtp){	struct tcpcb *tp = xtp;	struct tcptemp *t_template;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	inp = tp->t_inpcb;	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL", __func__, tp));	INP_WLOCK(inp);	if (callout_pending(&tp->t_timers->tt_keep) ||	    !callout_active(&tp->t_timers->tt_keep)) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_keep);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		CURVNET_RESTORE();		return;	}	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) == 0,		("%s: tp %p tcpcb can't be stopped here", __func__, tp));	/*	 * Because we don't regularly reset the keepalive callout in	 * the ESTABLISHED state, it may be that we don't actually need	 * to send a keepalive yet. If that occurs, schedule another	 * call for the next time the keepalive timer might expire.	 */	if (TCPS_HAVEESTABLISHED(tp->t_state)) {		u_int idletime;		idletime = ticks - tp->t_rcvtime;		if (idletime < TP_KEEPIDLE(tp)) {			callout_reset(&tp->t_timers->tt_keep,			    TP_KEEPIDLE(tp) - idletime, tcp_timer_keep, tp);			INP_WUNLOCK(inp);			CURVNET_RESTORE();			return;		}	}	/*	 * Keep-alive timer went off; send something	 * or drop connection if idle for too long.	 */	TCPSTAT_INC(tcps_keeptimeo);	if (tp->t_state < TCPS_ESTABLISHED)		goto dropit;	if ((always_keepalive || inp->inp_socket->so_options & SO_KEEPALIVE) &&	    tp->t_state <= TCPS_CLOSING) {		if (ticks - tp->t_rcvtime >= TP_KEEPIDLE(tp) + TP_MAXIDLE(tp))			goto dropit;		/*		 * Send a packet designed to force a response		 * if the peer is up and reachable:		 * either an ACK if the connection is still alive,		 * or an RST if the peer has closed the connection		 * due to timeout or reboot.		 * Using sequence number tp->snd_una-1		 * causes the transmitted zero-length segment		 * to lie outside the receive window;		 * by the protocol spec, this requires the		 * correspondent TCP to respond.		 */		TCPSTAT_INC(tcps_keepprobe);		t_template = tcpip_maketemplate(inp);		if (t_template) {			tcp_respond(tp, t_template->tt_ipgen,				    &t_template->tt_t, (struct mbuf *)NULL,				    tp->rcv_nxt, tp->snd_una - 1, 0);			free(t_template, M_TEMP);		}		callout_reset(&tp->t_timers->tt_keep, TP_KEEPINTVL(tp),			      tcp_timer_keep, tp);	} else		callout_reset(&tp->t_timers->tt_keep, TP_KEEPIDLE(tp),			      tcp_timer_keep, tp);#ifdef TCPDEBUG	if (inp->inp_socket->so_options & SO_DEBUG)		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	TCP_PROBE2(debug__user, tp, PRU_SLOWTIMO);	INP_WUNLOCK(inp);	CURVNET_RESTORE();	return;dropit:	TCPSTAT_INC(tcps_keepdrops);	if (tcp_inpinfo_lock_add(inp)) {//.........这里部分代码省略.........

voidtcp_timer_rexmt(void * xtp){	struct tcpcb *tp = xtp;	CURVNET_SET(tp->t_vnet);	int rexmt;	int headlocked;	struct inpcb *inp;#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	INP_INFO_RLOCK(&V_tcbinfo);	inp = tp->t_inpcb;	/*	 * XXXRW: While this assert is in fact correct, bugs in the tcpcb	 * tear-down mean we need it as a work-around for races between	 * timers and tcp_discardcb().	 *	 * KASSERT(inp != NULL, ("tcp_timer_rexmt: inp == NULL"));	 */	if (inp == NULL) {		tcp_timer_race++;		INP_INFO_RUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	INP_WLOCK(inp);	if ((inp->inp_flags & INP_DROPPED) || callout_pending(&tp->t_timers->tt_rexmt)	    || !callout_active(&tp->t_timers->tt_rexmt)) {		INP_WUNLOCK(inp);		INP_INFO_RUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_rexmt);	tcp_free_sackholes(tp);	/*	 * Retransmission timer went off.  Message has not	 * been acked within retransmit interval.  Back off	 * to a longer retransmit interval and retransmit one segment.	 */	if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {		tp->t_rxtshift = TCP_MAXRXTSHIFT;		TCPSTAT_INC(tcps_timeoutdrop);		in_pcbref(inp);		INP_INFO_RUNLOCK(&V_tcbinfo);		INP_WUNLOCK(inp);		INP_INFO_WLOCK(&V_tcbinfo);		INP_WLOCK(inp);		if (in_pcbrele_wlocked(inp)) {			INP_INFO_WUNLOCK(&V_tcbinfo);			CURVNET_RESTORE();			return;		}		if (inp->inp_flags & INP_DROPPED) {			INP_WUNLOCK(inp);			INP_INFO_WUNLOCK(&V_tcbinfo);			CURVNET_RESTORE();			return;		}		tp = tcp_drop(tp, tp->t_softerror ?			      tp->t_softerror : ETIMEDOUT);		headlocked = 1;		goto out;	}	INP_INFO_RUNLOCK(&V_tcbinfo);	headlocked = 0;	if (tp->t_rxtshift == 1) {		/*		 * first retransmit; record ssthresh and cwnd so they can		 * be recovered if this turns out to be a "bad" retransmit.		 * A retransmit is considered "bad" if an ACK for this		 * segment is received within RTT/2 interval; the assumption		 * here is that the ACK was already in flight.  See		 * "On Estimating End-to-End Network Path Properties" by		 * Allman and Paxson for more details.		 */		tp->snd_cwnd_prev = tp->snd_cwnd;		tp->snd_ssthresh_prev = tp->snd_ssthresh;		tp->snd_recover_prev = tp->snd_recover;		if (IN_FASTRECOVERY(tp->t_flags))			tp->t_flags |= TF_WASFRECOVERY;		else			tp->t_flags &= ~TF_WASFRECOVERY;		if (IN_CONGRECOVERY(tp->t_flags))			tp->t_flags |= TF_WASCRECOVERY;		else			tp->t_flags &= ~TF_WASCRECOVERY;		tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));		tp->t_flags |= TF_PREVVALID;	} else

voidtcp_timer_persist(void *xtp){	struct tcpcb *tp = xtp;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	INP_INFO_WLOCK(&V_tcbinfo);	inp = tp->t_inpcb;	/*	 * XXXRW: While this assert is in fact correct, bugs in the tcpcb	 * tear-down mean we need it as a work-around for races between	 * timers and tcp_discardcb().	 *	 * KASSERT(inp != NULL, ("tcp_timer_persist: inp == NULL"));	 */	if (inp == NULL) {		tcp_timer_race++;		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	INP_WLOCK(inp);	if ((inp->inp_flags & INP_DROPPED) || callout_pending(&tp->t_timers->tt_persist)	    || !callout_active(&tp->t_timers->tt_persist)) {		INP_WUNLOCK(inp);		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_persist);	/*	 * Persistance timer into zero window.	 * Force a byte to be output, if possible.	 */	TCPSTAT_INC(tcps_persisttimeo);	/*	 * Hack: if the peer is dead/unreachable, we do not	 * time out if the window is closed.  After a full	 * backoff, drop the connection if the idle time	 * (no responses to probes) reaches the maximum	 * backoff that we would use if retransmitting.	 */	if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&	    (ticks - tp->t_rcvtime >= tcp_maxpersistidle ||	     ticks - tp->t_rcvtime >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {		TCPSTAT_INC(tcps_persistdrop);		tp = tcp_drop(tp, ETIMEDOUT);		goto out;	}	tcp_setpersist(tp);	tp->t_flags |= TF_FORCEDATA;	(void) tcp_output(tp);	tp->t_flags &= ~TF_FORCEDATA;out:#ifdef TCPDEBUG	if (tp != NULL && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)		tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);#endif	if (tp != NULL)		INP_WUNLOCK(inp);	INP_INFO_WUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();}

voidbootpc_init(void){	struct bootpc_ifcontext *ifctx, *nctx;	/* Interface BOOTP contexts */	struct bootpc_globalcontext *gctx; 	/* Global BOOTP context */	struct ifnet *ifp;	int error;#ifndef BOOTP_WIRED_TO	int ifcnt;#endif	struct nfsv3_diskless *nd;	struct thread *td;	nd = &nfsv3_diskless;	td = curthread;	/*	 * If already filled in, don't touch it here	 */	if (nfs_diskless_valid != 0)		return;	gctx = malloc(sizeof(*gctx), M_TEMP, M_WAITOK | M_ZERO);	if (gctx == NULL)		panic("Failed to allocate bootp global context structure");	gctx->xid = ~0xFFFF;	gctx->starttime = time_second;	/*	 * Find a network interface.	 */	CURVNET_SET(TD_TO_VNET(td));#ifdef BOOTP_WIRED_TO	printf("bootpc_init: wired to interface '%s'/n",	       __XSTRING(BOOTP_WIRED_TO));	allocifctx(gctx);#else	/*	 * Preallocate interface context storage, if another interface	 * attaches and wins the race, it won't be eligible for bootp.	 */	IFNET_RLOCK();	for (ifp = TAILQ_FIRST(&V_ifnet), ifcnt = 0;	     ifp != NULL;	     ifp = TAILQ_NEXT(ifp, if_link)) {		if ((ifp->if_flags &		     (IFF_LOOPBACK | IFF_POINTOPOINT | IFF_BROADCAST)) !=		    IFF_BROADCAST)			continue;		ifcnt++;	}	IFNET_RUNLOCK();	if (ifcnt == 0)		panic("bootpc_init: no eligible interfaces");	for (; ifcnt > 0; ifcnt--)		allocifctx(gctx);#endif	IFNET_RLOCK();	for (ifp = TAILQ_FIRST(&V_ifnet), ifctx = gctx->interfaces;	     ifp != NULL && ifctx != NULL;	     ifp = TAILQ_NEXT(ifp, if_link)) {		strlcpy(ifctx->ireq.ifr_name, ifp->if_xname,		    sizeof(ifctx->ireq.ifr_name));#ifdef BOOTP_WIRED_TO		if (strcmp(ifctx->ireq.ifr_name,			   __XSTRING(BOOTP_WIRED_TO)) != 0)			continue;#else		if ((ifp->if_flags &		     (IFF_LOOPBACK | IFF_POINTOPOINT | IFF_BROADCAST)) !=		    IFF_BROADCAST)			continue;#endif		ifctx->ifp = ifp;		ifctx = ifctx->next;	}	IFNET_RUNLOCK();	CURVNET_RESTORE();	if (gctx->interfaces == NULL || gctx->interfaces->ifp == NULL) {#ifdef BOOTP_WIRED_TO		panic("bootpc_init: Could not find interface specified "		      "by BOOTP_WIRED_TO: "		      __XSTRING(BOOTP_WIRED_TO));#else		panic("bootpc_init: no suitable interface");#endif	}	for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)		bootpc_fakeup_interface(ifctx, gctx, td);	for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)		bootpc_compose_query(ifctx, gctx, td);	error = bootpc_call(gctx, td);	if (error != 0) {//.........这里部分代码省略.........

voidtcp_timer_keep(void *xtp){	struct tcpcb *tp = xtp;	struct tcptemp *t_template;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	INP_INFO_RLOCK(&V_tcbinfo);	inp = tp->t_inpcb;	KASSERT(inp != NULL, ("%s: tp %p tp->t_inpcb == NULL", __func__, tp));	INP_WLOCK(inp);	if (callout_pending(&tp->t_timers->tt_keep) ||	    !callout_active(&tp->t_timers->tt_keep)) {		INP_WUNLOCK(inp);		INP_INFO_RUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_keep);	if ((inp->inp_flags & INP_DROPPED) != 0) {		INP_WUNLOCK(inp);		INP_INFO_RUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	KASSERT((tp->t_timers->tt_flags & TT_STOPPED) == 0,		("%s: tp %p tcpcb can't be stopped here", __func__, tp));	KASSERT((tp->t_timers->tt_flags & TT_KEEP) != 0,		("%s: tp %p keep callout should be running", __func__, tp));	/*	 * Keep-alive timer went off; send something	 * or drop connection if idle for too long.	 */	TCPSTAT_INC(tcps_keeptimeo);	if (tp->t_state < TCPS_ESTABLISHED)		goto dropit;	if ((always_keepalive || inp->inp_socket->so_options & SO_KEEPALIVE) &&	    tp->t_state <= TCPS_CLOSING) {		if (ticks - tp->t_rcvtime >= TP_KEEPIDLE(tp) + TP_MAXIDLE(tp))			goto dropit;		/*		 * Send a packet designed to force a response		 * if the peer is up and reachable:		 * either an ACK if the connection is still alive,		 * or an RST if the peer has closed the connection		 * due to timeout or reboot.		 * Using sequence number tp->snd_una-1		 * causes the transmitted zero-length segment		 * to lie outside the receive window;		 * by the protocol spec, this requires the		 * correspondent TCP to respond.		 */		TCPSTAT_INC(tcps_keepprobe);		t_template = tcpip_maketemplate(inp);		if (t_template) {			tcp_respond(tp, t_template->tt_ipgen,				    &t_template->tt_t, (struct mbuf *)NULL,				    tp->rcv_nxt, tp->snd_una - 1, 0);			free(t_template, M_TEMP);		}		if (!callout_reset(&tp->t_timers->tt_keep, TP_KEEPINTVL(tp),		    tcp_timer_keep, tp)) {			tp->t_timers->tt_flags &= ~TT_KEEP_RST;		}	} else if (!callout_reset(&tp->t_timers->tt_keep, TP_KEEPIDLE(tp),		    tcp_timer_keep, tp)) {			tp->t_timers->tt_flags &= ~TT_KEEP_RST;		}#ifdef TCPDEBUG	if (inp->inp_socket->so_options & SO_DEBUG)		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	TCP_PROBE2(debug__user, tp, PRU_SLOWTIMO);	INP_WUNLOCK(inp);	INP_INFO_RUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();	return;dropit:	TCPSTAT_INC(tcps_keepdrops);	tp = tcp_drop(tp, ETIMEDOUT);#ifdef TCPDEBUG	if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	TCP_PROBE2(debug__user, tp, PRU_SLOWTIMO);	if (tp != NULL)		INP_WUNLOCK(tp->t_inpcb);	INP_INFO_RUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();}

voidtcp_timer_keep(void *xtp){	struct tcpcb *tp = xtp;	struct tcptemp *t_template;	struct inpcb *inp;	CURVNET_SET(tp->t_vnet);#ifdef TCPDEBUG	int ostate;	ostate = tp->t_state;#endif	INP_INFO_WLOCK(&V_tcbinfo);	inp = tp->t_inpcb;	/*	 * XXXRW: While this assert is in fact correct, bugs in the tcpcb	 * tear-down mean we need it as a work-around for races between	 * timers and tcp_discardcb().	 *	 * KASSERT(inp != NULL, ("tcp_timer_keep: inp == NULL"));	 */	if (inp == NULL) {		tcp_timer_race++;		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	INP_WLOCK(inp);	if ((inp->inp_flags & INP_DROPPED) || callout_pending(&tp->t_timers->tt_keep)	    || !callout_active(&tp->t_timers->tt_keep)) {		INP_WUNLOCK(inp);		INP_INFO_WUNLOCK(&V_tcbinfo);		CURVNET_RESTORE();		return;	}	callout_deactivate(&tp->t_timers->tt_keep);	/*	 * Keep-alive timer went off; send something	 * or drop connection if idle for too long.	 */	TCPSTAT_INC(tcps_keeptimeo);	if (tp->t_state < TCPS_ESTABLISHED)		goto dropit;	if ((always_keepalive || inp->inp_socket->so_options & SO_KEEPALIVE) &&	    tp->t_state <= TCPS_CLOSING) {		if (ticks - tp->t_rcvtime >= TP_KEEPIDLE(tp) + TP_MAXIDLE(tp))			goto dropit;		/*		 * Send a packet designed to force a response		 * if the peer is up and reachable:		 * either an ACK if the connection is still alive,		 * or an RST if the peer has closed the connection		 * due to timeout or reboot.		 * Using sequence number tp->snd_una-1		 * causes the transmitted zero-length segment		 * to lie outside the receive window;		 * by the protocol spec, this requires the		 * correspondent TCP to respond.		 */		TCPSTAT_INC(tcps_keepprobe);		t_template = tcpip_maketemplate(inp);		if (t_template) {			tcp_respond(tp, t_template->tt_ipgen,				    &t_template->tt_t, (struct mbuf *)NULL,				    tp->rcv_nxt, tp->snd_una - 1, 0);			free(t_template, M_TEMP);		}		callout_reset_on(&tp->t_timers->tt_keep, TP_KEEPINTVL(tp),		    tcp_timer_keep, tp, INP_CPU(inp));	} else		callout_reset_on(&tp->t_timers->tt_keep, TP_KEEPIDLE(tp),		    tcp_timer_keep, tp, INP_CPU(inp));#ifdef TCPDEBUG	if (inp->inp_socket->so_options & SO_DEBUG)		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	INP_WUNLOCK(inp);	INP_INFO_WUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();	return;dropit:	TCPSTAT_INC(tcps_keepdrops);	tp = tcp_drop(tp, ETIMEDOUT);#ifdef TCPDEBUG	if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))		tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,			  PRU_SLOWTIMO);#endif	if (tp != NULL)		INP_WUNLOCK(tp->t_inpcb);	INP_INFO_WUNLOCK(&V_tcbinfo);	CURVNET_RESTORE();}