Differential D4055 Diff 10164 sys/netinet/tcp_syncache.c

Changeset View

Standalone View

sys/netinet/tcp_syncache.c

Context not available.
	#include <sys/param.h>	#include <sys/param.h>
	#include <sys/systm.h>	#include <sys/systm.h>
	#include <sys/hash.h>	#include <sys/hash.h>
		#include <sys/refcount.h>
	#include <sys/kernel.h>	#include <sys/kernel.h>
	#include <sys/sysctl.h>	#include <sys/sysctl.h>
	#include <sys/limits.h>	#include <sys/limits.h>
Context not available.
	static struct socket *	static struct socket *
	syncache_socket(struct syncache sc, struct socket lso, struct mbuf *m)	syncache_socket(struct syncache sc, struct socket lso, struct mbuf *m)
	{	{
		struct tcp_function_block *blk;
	struct inpcb *inp = NULL;	struct inpcb *inp = NULL;
	struct socket *so;	struct socket *so;
	struct tcpcb *tp;	struct tcpcb *tp;
Context not available.
	tp->irs = sc->sc_irs;	tp->irs = sc->sc_irs;
	tcp_rcvseqinit(tp);	tcp_rcvseqinit(tp);
	tcp_sendseqinit(tp);	tcp_sendseqinit(tp);
		jtlUnsubmitted Not Done Inline Actions Why track this at the time the syncache entry is created? Because we currently will require a common code path through the syncache, we shouldn't need to care which TCP stack is in use until we expand the syncache entry. And, the user can't change the TCP stack once the socket enters the listen state. If it isn't the default TCP stack, we do need to go through the initialization, which this code does. jtl: Why track this at the time the syncache entry is created? Because we currently will require a…
		rrsAuthorUnsubmitted Not Done Inline Actions Hmm I did not see that the the sync-cache expansion code had a easy reference back to the listening socket (maybe I missed it .. I will go relook). So I took the easy route and grabbed what the listener was on at this time. If I can access the listening socket at expansion then yes, thats where this should move too. rrs: Hmm I did not see that the the sync-cache expansion code had a easy reference back to the…
		blk = sototcpcb(lso)->t_fb;
		if (blk != tp->t_fb) {
		/*
		jtlUnsubmitted Not Done Inline Actions If the listen socket is using a custom stack and the custom stack is removed, this code will effectively switch all new sessions for the listen socket to use the default TCP stack. However, the refcount for the custom TCP stack won't drop to 0 until the listen socket itself is closed. I think it probably is better to keep using the same (custom) TCP stack until the listen socket itself is closed. That seems more predictable. jtl: If the listen socket is using a custom stack and the custom stack is removed, this code will…
		rrsAuthorUnsubmitted Not Done Inline Actions Which is fine but it means you extend it so it continues to be used.. which is why I did it this way.. I have no problems either way :-) rrs: Which is fine but it means you extend it so it continues to be used.. which is why I did it…
		* Our parents t_fb was not the default,
		* we need to release our ref on tp->t_fb and
		* pickup one on the new entry.
		*/
		struct tcp_function_block *rblk;

		rblk = find_and_ref_tcp_fb(blk);
		KASSERT(rblk != NULL,
		("cannot find blk %p out of syncache?", blk));
		if (tp->t_fb->tfb_tcp_fb_fini)
		jtlUnsubmitted Not Done Inline Actions We should always find the block, so there should probably be a KASSERT here. jtl: We should always find the block, so there should probably be a KASSERT here.
		rrsAuthorUnsubmitted Not Done Inline Actions ok rrs: ok
		(*tp->t_fb->tfb_tcp_fb_fini)(tp);
		refcount_release(&tp->t_fb->tfb_refcnt);
		tp->t_fb = rblk;
		if (tp->t_fb->tfb_tcp_fb_init) {
		(*tp->t_fb->tfb_tcp_fb_init)(tp);
		}
		}
	tp->snd_wl1 = sc->sc_irs;	tp->snd_wl1 = sc->sc_irs;
	tp->snd_max = tp->iss + 1;	tp->snd_max = tp->iss + 1;
	tp->snd_nxt = tp->iss + 1;	tp->snd_nxt = tp->iss + 1;
Context not available.