~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,5 +1,5 @@
1		-/*
2		- * L2TP core.
	1	+// SPDX-License-Identifier: GPL-2.0-only
	2	+/* L2TP core.
3	3	*
4	4	* Copyright (c) 2008,2009,2010 Katalix Systems Ltd
5	5	*
..	..	@@ -12,10 +12,6 @@
12	12	* Michal Ostrowski <mostrows@speakeasy.net>
13	13	* Arnaldo Carvalho de Melo <acme@xconectiva.com.br>
14	14	* David S. Miller (davem@redhat.com)
15		- *
16		- * This program is free software; you can redistribute it and/or modify
17		- * it under the terms of the GNU General Public License version 2 as
18		- * published by the Free Software Foundation.
19	15	*/
20	16
21	17	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
..	..	@@ -65,6 +61,10 @@
65	61	#include <linux/atomic.h>
66	62
67	63	#include "l2tp_core.h"
	64	+#include "trace.h"
	65	+
	66	+#define CREATE_TRACE_POINTS
	67	+#include "trace.h"
68	68
69	69	#define L2TP_DRV_VERSION "V2.0"
70	70
..	..	@@ -97,7 +97,7 @@
97	97	unsigned long expires;
98	98	};
99	99
100		-#define L2TP_SKB_CB(skb) ((struct l2tp_skb_cb *) &skb->cb[sizeof(struct inet_skb_parm)])
	100	+#define L2TP_SKB_CB(skb) ((struct l2tp_skb_cb *)&(skb)->cb[sizeof(struct inet_skb_parm)])
101	101
102	102	static struct workqueue_struct *l2tp_wq;
103	103
..	..	@@ -105,8 +105,10 @@
105	105	static unsigned int l2tp_net_id;
106	106	struct l2tp_net {
107	107	struct list_head l2tp_tunnel_list;
	108	+ /* Lock for write access to l2tp_tunnel_list */
108	109	spinlock_t l2tp_tunnel_list_lock;
109	110	struct hlist_head l2tp_session_hlist[L2TP_HASH_SIZE_2];
	111	+ /* Lock for write access to l2tp_session_hlist */
110	112	spinlock_t l2tp_session_hlist_lock;
111	113	};
112	114
..	..	@@ -118,15 +120,8 @@
118	120	}
119	121	#endif
120	122
121		-static inline struct l2tp_tunnel l2tp_tunnel(struct sock sk)
122		-{
123		- return sk->sk_user_data;
124		-}
125		-
126	123	static inline struct l2tp_net l2tp_pernet(const struct net net)
127	124	{
128		- BUG_ON(!net);
129		-
130	125	return net_generic(net, l2tp_net_id);
131	126	}
132	127
..	..	@@ -139,7 +134,6 @@
139	134	l2tp_session_id_hash_2(struct l2tp_net *pn, u32 session_id)
140	135	{
141	136	return &pn->l2tp_session_hlist[hash_32(session_id, L2TP_HASH_BITS_2)];
142		-
143	137	}
144	138
145	139	/* Session hash list.
..	..	@@ -154,12 +148,58 @@
154	148	return &tunnel->session_hlist[hash_32(session_id, L2TP_HASH_BITS)];
155	149	}
156	150
157		-void l2tp_tunnel_free(struct l2tp_tunnel *tunnel)
	151	+static void l2tp_tunnel_free(struct l2tp_tunnel *tunnel)
158	152	{
	153	+ trace_free_tunnel(tunnel);
159	154	sock_put(tunnel->sock);
160	155	/* the tunnel is freed in the socket destructor */
161	156	}
162		-EXPORT_SYMBOL(l2tp_tunnel_free);
	157	+
	158	+static void l2tp_session_free(struct l2tp_session *session)
	159	+{
	160	+ trace_free_session(session);
	161	+ if (session->tunnel)
	162	+ l2tp_tunnel_dec_refcount(session->tunnel);
	163	+ kfree(session);
	164	+}
	165	+
	166	+struct l2tp_tunnel l2tp_sk_to_tunnel(struct sock sk)
	167	+{
	168	+ struct l2tp_tunnel *tunnel = sk->sk_user_data;
	169	+
	170	+ if (tunnel)
	171	+ if (WARN_ON(tunnel->magic != L2TP_TUNNEL_MAGIC))
	172	+ return NULL;
	173	+
	174	+ return tunnel;
	175	+}
	176	+EXPORT_SYMBOL_GPL(l2tp_sk_to_tunnel);
	177	+
	178	+void l2tp_tunnel_inc_refcount(struct l2tp_tunnel *tunnel)
	179	+{
	180	+ refcount_inc(&tunnel->ref_count);
	181	+}
	182	+EXPORT_SYMBOL_GPL(l2tp_tunnel_inc_refcount);
	183	+
	184	+void l2tp_tunnel_dec_refcount(struct l2tp_tunnel *tunnel)
	185	+{
	186	+ if (refcount_dec_and_test(&tunnel->ref_count))
	187	+ l2tp_tunnel_free(tunnel);
	188	+}
	189	+EXPORT_SYMBOL_GPL(l2tp_tunnel_dec_refcount);
	190	+
	191	+void l2tp_session_inc_refcount(struct l2tp_session *session)
	192	+{
	193	+ refcount_inc(&session->ref_count);
	194	+}
	195	+EXPORT_SYMBOL_GPL(l2tp_session_inc_refcount);
	196	+
	197	+void l2tp_session_dec_refcount(struct l2tp_session *session)
	198	+{
	199	+ if (refcount_dec_and_test(&session->ref_count))
	200	+ l2tp_session_free(session);
	201	+}
	202	+EXPORT_SYMBOL_GPL(l2tp_session_dec_refcount);
163	203
164	204	/* Lookup a tunnel. A new reference is held on the returned tunnel. */
165	205	struct l2tp_tunnel l2tp_tunnel_get(const struct net net, u32 tunnel_id)
..	..	@@ -347,6 +387,8 @@
347	387	hlist_add_head(&session->hlist, head);
348	388	write_unlock_bh(&tunnel->hlist_lock);
349	389
	390	+ trace_register_session(session);
	391	+
350	392	return 0;
351	393
352	394	err_tlock_pnlock:
..	..	@@ -375,10 +417,6 @@
375	417	skb_queue_walk_safe(&session->reorder_q, skbp, tmp) {
376	418	if (L2TP_SKB_CB(skbp)->ns > ns) {
377	419	__skb_queue_before(&session->reorder_q, skbp, skb);
378		- l2tp_dbg(session, L2TP_MSG_SEQ,
379		- "%s: pkt %hu, inserted before %hu, reorder_q len=%d\n",
380		- session->name, ns, L2TP_SKB_CB(skbp)->ns,
381		- skb_queue_len(&session->reorder_q));
382	420	atomic_long_inc(&session->stats.rx_oos_packets);
383	421	goto out;
384	422	}
..	..	@@ -411,13 +449,11 @@
411	449	/* Bump our Nr */
412	450	session->nr++;
413	451	session->nr &= session->nr_max;
414		-
415		- l2tp_dbg(session, L2TP_MSG_SEQ, "%s: updated nr to %hu\n",
416		- session->name, session->nr);
	452	+ trace_session_seqnum_update(session);
417	453	}
418	454
419	455	/* call private receive handler */
420		- if (session->recv_skb != NULL)
	456	+ if (session->recv_skb)
421	457	(*session->recv_skb)(session, skb, L2TP_SKB_CB(skb)->length);
422	458	else
423	459	kfree_skb(skb);
..	..	@@ -438,37 +474,27 @@
438	474	start:
439	475	spin_lock_bh(&session->reorder_q.lock);
440	476	skb_queue_walk_safe(&session->reorder_q, skb, tmp) {
441		- if (time_after(jiffies, L2TP_SKB_CB(skb)->expires)) {
	477	+ struct l2tp_skb_cb *cb = L2TP_SKB_CB(skb);
	478	+
	479	+ /* If the packet has been pending on the queue for too long, discard it */
	480	+ if (time_after(jiffies, cb->expires)) {
442	481	atomic_long_inc(&session->stats.rx_seq_discards);
443	482	atomic_long_inc(&session->stats.rx_errors);
444		- l2tp_dbg(session, L2TP_MSG_SEQ,
445		- "%s: oos pkt %u len %d discarded (too old), waiting for %u, reorder_q_len=%d\n",
446		- session->name, L2TP_SKB_CB(skb)->ns,
447		- L2TP_SKB_CB(skb)->length, session->nr,
448		- skb_queue_len(&session->reorder_q));
	483	+ trace_session_pkt_expired(session, cb->ns);
449	484	session->reorder_skip = 1;
450	485	__skb_unlink(skb, &session->reorder_q);
451	486	kfree_skb(skb);
452	487	continue;
453	488	}
454	489
455		- if (L2TP_SKB_CB(skb)->has_seq) {
	490	+ if (cb->has_seq) {
456	491	if (session->reorder_skip) {
457		- l2tp_dbg(session, L2TP_MSG_SEQ,
458		- "%s: advancing nr to next pkt: %u -> %u",
459		- session->name, session->nr,
460		- L2TP_SKB_CB(skb)->ns);
461	492	session->reorder_skip = 0;
462		- session->nr = L2TP_SKB_CB(skb)->ns;
	493	+ session->nr = cb->ns;
	494	+ trace_session_seqnum_reset(session);
463	495	}
464		- if (L2TP_SKB_CB(skb)->ns != session->nr) {
465		- l2tp_dbg(session, L2TP_MSG_SEQ,
466		- "%s: holding oos pkt %u len %d, waiting for %u, reorder_q_len=%d\n",
467		- session->name, L2TP_SKB_CB(skb)->ns,
468		- L2TP_SKB_CB(skb)->length, session->nr,
469		- skb_queue_len(&session->reorder_q));
	496	+ if (cb->ns != session->nr)
470	497	goto out;
471		- }
472	498	}
473	499	__skb_unlink(skb, &session->reorder_q);
474	500
..	..	@@ -501,14 +527,13 @@
501	527	*/
502	528	static int l2tp_recv_data_seq(struct l2tp_session session, struct sk_buff skb)
503	529	{
504		- if (!l2tp_seq_check_rx_window(session, L2TP_SKB_CB(skb)->ns)) {
	530	+ struct l2tp_skb_cb *cb = L2TP_SKB_CB(skb);
	531	+
	532	+ if (!l2tp_seq_check_rx_window(session, cb->ns)) {
505	533	/* Packet sequence number is outside allowed window.
506	534	* Discard it.
507	535	*/
508		- l2tp_dbg(session, L2TP_MSG_SEQ,
509		- "%s: pkt %u len %d discarded, outside window, nr=%u\n",
510		- session->name, L2TP_SKB_CB(skb)->ns,
511		- L2TP_SKB_CB(skb)->length, session->nr);
	536	+ trace_session_pkt_outside_rx_window(session, cb->ns);
512	537	goto discard;
513	538	}
514	539
..	..	@@ -525,10 +550,10 @@
525	550	* is seen. After nr_oos_count_max in-sequence packets, reset the
526	551	* sequence number to re-enable packet reception.
527	552	*/
528		- if (L2TP_SKB_CB(skb)->ns == session->nr) {
	553	+ if (cb->ns == session->nr) {
529	554	skb_queue_tail(&session->reorder_q, skb);
530	555	} else {
531		- u32 nr_oos = L2TP_SKB_CB(skb)->ns;
	556	+ u32 nr_oos = cb->ns;
532	557	u32 nr_next = (session->nr_oos + 1) & session->nr_max;
533	558
534	559	if (nr_oos == nr_next)
..	..	@@ -539,17 +564,10 @@
539	564	session->nr_oos = nr_oos;
540	565	if (session->nr_oos_count > session->nr_oos_count_max) {
541	566	session->reorder_skip = 1;
542		- l2tp_dbg(session, L2TP_MSG_SEQ,
543		- "%s: %d oos packets received. Resetting sequence numbers\n",
544		- session->name, session->nr_oos_count);
545	567	}
546	568	if (!session->reorder_skip) {
547	569	atomic_long_inc(&session->stats.rx_seq_discards);
548		- l2tp_dbg(session, L2TP_MSG_SEQ,
549		- "%s: oos pkt %u len %d discarded, waiting for %u, reorder_q_len=%d\n",
550		- session->name, L2TP_SKB_CB(skb)->ns,
551		- L2TP_SKB_CB(skb)->length, session->nr,
552		- skb_queue_len(&session->reorder_q));
	570	+ trace_session_pkt_oos(session, cb->ns);
553	571	goto discard;
554	572	}
555	573	skb_queue_tail(&session->reorder_q, skb);
..	..	@@ -627,15 +645,13 @@
627	645	{
628	646	struct l2tp_tunnel *tunnel = session->tunnel;
629	647	int offset;
630		- u32 ns, nr;
631	648
632	649	/* Parse and check optional cookie */
633	650	if (session->peer_cookie_len > 0) {
634	651	if (memcmp(ptr, &session->peer_cookie[0], session->peer_cookie_len)) {
635		- l2tp_info(tunnel, L2TP_MSG_DATA,
636		- "%s: cookie mismatch (%u/%u). Discarding.\n",
637		- tunnel->name, tunnel->tunnel_id,
638		- session->session_id);
	652	+ pr_debug_ratelimited("%s: cookie mismatch (%u/%u). Discarding.\n",
	653	+ tunnel->name, tunnel->tunnel_id,
	654	+ session->session_id);
639	655	atomic_long_inc(&session->stats.rx_cookie_discards);
640	656	goto discard;
641	657	}
..	..	@@ -649,49 +665,35 @@
649	665	* the control of the LNS. If no sequence numbers present but
650	666	* we were expecting them, discard frame.
651	667	*/
652		- ns = nr = 0;
653	668	L2TP_SKB_CB(skb)->has_seq = 0;
654	669	if (tunnel->version == L2TP_HDR_VER_2) {
655	670	if (hdrflags & L2TP_HDRFLAG_S) {
656		- ns = ntohs((__be16 ) ptr);
657		- ptr += 2;
658		- nr = ntohs((__be16 ) ptr);
659		- ptr += 2;
660		-
661	671	/* Store L2TP info in the skb */
662		- L2TP_SKB_CB(skb)->ns = ns;
	672	+ L2TP_SKB_CB(skb)->ns = ntohs((__be16 )ptr);
663	673	L2TP_SKB_CB(skb)->has_seq = 1;
	674	+ ptr += 2;
	675	+ /* Skip past nr in the header */
	676	+ ptr += 2;
664	677
665		- l2tp_dbg(session, L2TP_MSG_SEQ,
666		- "%s: recv data ns=%u, nr=%u, session nr=%u\n",
667		- session->name, ns, nr, session->nr);
668	678	}
669	679	} else if (session->l2specific_type == L2TP_L2SPECTYPE_DEFAULT) {
670		- u32 l2h = ntohl((__be32 ) ptr);
	680	+ u32 l2h = ntohl((__be32 )ptr);
671	681
672	682	if (l2h & 0x40000000) {
673		- ns = l2h & 0x00ffffff;
674		-
675	683	/* Store L2TP info in the skb */
676		- L2TP_SKB_CB(skb)->ns = ns;
	684	+ L2TP_SKB_CB(skb)->ns = l2h & 0x00ffffff;
677	685	L2TP_SKB_CB(skb)->has_seq = 1;
678		-
679		- l2tp_dbg(session, L2TP_MSG_SEQ,
680		- "%s: recv data ns=%u, session nr=%u\n",
681		- session->name, ns, session->nr);
682	686	}
683	687	ptr += 4;
684	688	}
685	689
686	690	if (L2TP_SKB_CB(skb)->has_seq) {
687		- /* Received a packet with sequence numbers. If we're the LNS,
	691	+ /* Received a packet with sequence numbers. If we're the LAC,
688	692	* check if we sre sending sequence numbers and if not,
689	693	* configure it so.
690	694	*/
691		- if ((!session->lns_mode) && (!session->send_seq)) {
692		- l2tp_info(session, L2TP_MSG_SEQ,
693		- "%s: requested to enable seq numbers by LNS\n",
694		- session->name);
	695	+ if (!session->lns_mode && !session->send_seq) {
	696	+ trace_session_seqnum_lns_enable(session);
695	697	session->send_seq = 1;
696	698	l2tp_session_set_header_len(session, tunnel->version);
697	699	}
..	..	@@ -700,9 +702,8 @@
700	702	* If user has configured mandatory sequence numbers, discard.
701	703	*/
702	704	if (session->recv_seq) {
703		- l2tp_warn(session, L2TP_MSG_SEQ,
704		- "%s: recv data has no seq numbers when required. Discarding.\n",
705		- session->name);
	705	+ pr_debug_ratelimited("%s: recv data has no seq numbers when required. Discarding.\n",
	706	+ session->name);
706	707	atomic_long_inc(&session->stats.rx_seq_discards);
707	708	goto discard;
708	709	}
..	..	@@ -712,16 +713,13 @@
712	713	* If we're the LNS and we're sending sequence numbers, the
713	714	* LAC is broken. Discard the frame.
714	715	*/
715		- if ((!session->lns_mode) && (session->send_seq)) {
716		- l2tp_info(session, L2TP_MSG_SEQ,
717		- "%s: requested to disable seq numbers by LNS\n",
718		- session->name);
	716	+ if (!session->lns_mode && session->send_seq) {
	717	+ trace_session_seqnum_lns_disable(session);
719	718	session->send_seq = 0;
720	719	l2tp_session_set_header_len(session, tunnel->version);
721	720	} else if (session->send_seq) {
722		- l2tp_warn(session, L2TP_MSG_SEQ,
723		- "%s: recv data has no seq numbers when required. Discarding.\n",
724		- session->name);
	721	+ pr_debug_ratelimited("%s: recv data has no seq numbers when required. Discarding.\n",
	722	+ session->name);
725	723	atomic_long_inc(&session->stats.rx_seq_discards);
726	724	goto discard;
727	725	}
..	..	@@ -775,20 +773,18 @@
775	773	atomic_long_inc(&session->stats.rx_errors);
776	774	kfree_skb(skb);
777	775	}
778		-EXPORT_SYMBOL(l2tp_recv_common);
	776	+EXPORT_SYMBOL_GPL(l2tp_recv_common);
779	777
780	778	/* Drop skbs from the session's reorder_q
781	779	*/
782		-static int l2tp_session_queue_purge(struct l2tp_session *session)
	780	+static void l2tp_session_queue_purge(struct l2tp_session *session)
783	781	{
784	782	struct sk_buff *skb = NULL;
785		- BUG_ON(!session);
786		- BUG_ON(session->magic != L2TP_SESSION_MAGIC);
	783	+
787	784	while ((skb = skb_dequeue(&session->reorder_q))) {
788	785	atomic_long_inc(&session->stats.rx_errors);
789	786	kfree_skb(skb);
790	787	}
791		- return 0;
792	788	}
793	789
794	790	/* Internal UDP receive frame. Do the real work of receiving an L2TP data frame
..	..	@@ -813,47 +809,32 @@
813	809
814	810	/* Short packet? */
815	811	if (!pskb_may_pull(skb, L2TP_HDR_SIZE_MAX)) {
816		- l2tp_info(tunnel, L2TP_MSG_DATA,
817		- "%s: recv short packet (len=%d)\n",
818		- tunnel->name, skb->len);
819		- goto error;
820		- }
821		-
822		- /* Trace packet contents, if enabled */
823		- if (tunnel->debug & L2TP_MSG_DATA) {
824		- length = min(32u, skb->len);
825		- if (!pskb_may_pull(skb, length))
826		- goto error;
827		-
828		- pr_debug("%s: recv\n", tunnel->name);
829		- print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, skb->data, length);
	812	+ pr_debug_ratelimited("%s: recv short packet (len=%d)\n",
	813	+ tunnel->name, skb->len);
	814	+ goto invalid;
830	815	}
831	816
832	817	/* Point to L2TP header */
833		- optr = ptr = skb->data;
	818	+ optr = skb->data;
	819	+ ptr = skb->data;
834	820
835	821	/* Get L2TP header flags */
836		- hdrflags = ntohs((__be16 ) ptr);
	822	+ hdrflags = ntohs((__be16 )ptr);
837	823
838	824	/* Check protocol version */
839	825	version = hdrflags & L2TP_HDR_VER_MASK;
840	826	if (version != tunnel->version) {
841		- l2tp_info(tunnel, L2TP_MSG_DATA,
842		- "%s: recv protocol version mismatch: got %d expected %d\n",
843		- tunnel->name, version, tunnel->version);
844		- goto error;
	827	+ pr_debug_ratelimited("%s: recv protocol version mismatch: got %d expected %d\n",
	828	+ tunnel->name, version, tunnel->version);
	829	+ goto invalid;
845	830	}
846	831
847	832	/* Get length of L2TP packet */
848	833	length = skb->len;
849	834
850	835	/* If type is control packet, it is handled by userspace. */
851		- if (hdrflags & L2TP_HDRFLAG_T) {
852		- l2tp_dbg(tunnel, L2TP_MSG_DATA,
853		- "%s: recv control packet, len=%d\n",
854		- tunnel->name, length);
855		- goto error;
856		- }
	836	+ if (hdrflags & L2TP_HDRFLAG_T)
	837	+ goto pass;
857	838
858	839	/* Skip flags */
859	840	ptr += 2;
..	..	@@ -864,14 +845,14 @@
864	845	ptr += 2;
865	846
866	847	/* Extract tunnel and session ID */
867		- tunnel_id = ntohs((__be16 ) ptr);
	848	+ tunnel_id = ntohs((__be16 )ptr);
868	849	ptr += 2;
869		- session_id = ntohs((__be16 ) ptr);
	850	+ session_id = ntohs((__be16 )ptr);
870	851	ptr += 2;
871	852	} else {
872	853	ptr += 2; /* skip reserved bits */
873	854	tunnel_id = tunnel->tunnel_id;
874		- session_id = ntohl((__be32 ) ptr);
	855	+ session_id = ntohl((__be32 )ptr);
875	856	ptr += 4;
876	857	}
877	858
..	..	@@ -882,16 +863,15 @@
882	863	l2tp_session_dec_refcount(session);
883	864
884	865	/* Not found? Pass to userspace to deal with */
885		- l2tp_info(tunnel, L2TP_MSG_DATA,
886		- "%s: no session found (%u/%u). Passing up.\n",
887		- tunnel->name, tunnel_id, session_id);
888		- goto error;
	866	+ pr_debug_ratelimited("%s: no session found (%u/%u). Passing up.\n",
	867	+ tunnel->name, tunnel_id, session_id);
	868	+ goto pass;
889	869	}
890	870
891	871	if (tunnel->version == L2TP_HDR_VER_3 &&
892	872	l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr)) {
893	873	l2tp_session_dec_refcount(session);
894		- goto error;
	874	+ goto invalid;
895	875	}
896	876
897	877	l2tp_recv_common(session, skb, ptr, optr, hdrflags, length);
..	..	@@ -899,7 +879,10 @@
899	879
900	880	return 0;
901	881
902		-error:
	882	+invalid:
	883	+ atomic_long_inc(&tunnel->stats.rx_invalid);
	884	+
	885	+pass:
903	886	/* Put UDP header back */
904	887	__skb_push(skb, sizeof(struct udphdr));
905	888
..	..	@@ -916,12 +899,17 @@
916	899	{
917	900	struct l2tp_tunnel *tunnel;
918	901
	902	+ /* Note that this is called from the encap_rcv hook inside an
	903	+ * RCU-protected region, but without the socket being locked.
	904	+ * Hence we use rcu_dereference_sk_user_data to access the
	905	+ * tunnel data structure rather the usual l2tp_sk_to_tunnel
	906	+ * accessor function.
	907	+ */
919	908	tunnel = rcu_dereference_sk_user_data(sk);
920		- if (tunnel == NULL)
	909	+ if (!tunnel)
921	910	goto pass_up;
922		-
923		- l2tp_dbg(tunnel, L2TP_MSG_DATA, "%s: received %d bytes\n",
924		- tunnel->name, skb->len);
	911	+ if (WARN_ON(tunnel->magic != L2TP_TUNNEL_MAGIC))
	912	+ goto pass_up;
925	913
926	914	if (l2tp_udp_recv_core(tunnel, skb))
927	915	goto pass_up;
..	..	@@ -960,8 +948,7 @@
960	948	*bufp++ = 0;
961	949	session->ns++;
962	950	session->ns &= 0xffff;
963		- l2tp_dbg(session, L2TP_MSG_SEQ, "%s: updated ns to %u\n",
964		- session->name, session->ns);
	951	+ trace_session_seqnum_update(session);
965	952	}
966	953
967	954	return bufp - optr;
..	..	@@ -978,13 +965,13 @@
978	965	*/
979	966	if (tunnel->encap == L2TP_ENCAPTYPE_UDP) {
980	967	u16 flags = L2TP_HDR_VER_3;
981		- ((__be16 ) bufp) = htons(flags);
	968	+ ((__be16 )bufp) = htons(flags);
982	969	bufp += 2;
983		- ((__be16 ) bufp) = 0;
	970	+ ((__be16 )bufp) = 0;
984	971	bufp += 2;
985	972	}
986	973
987		- ((__be32 ) bufp) = htonl(session->peer_session_id);
	974	+ ((__be32 )bufp) = htonl(session->peer_session_id);
988	975	bufp += 4;
989	976	if (session->cookie_len) {
990	977	memcpy(bufp, &session->cookie[0], session->cookie_len);
..	..	@@ -997,9 +984,7 @@
997	984	l2h = 0x40000000 \| session->ns;
998	985	session->ns++;
999	986	session->ns &= 0xffffff;
1000		- l2tp_dbg(session, L2TP_MSG_SEQ,
1001		- "%s: updated ns to %u\n",
1002		- session->name, session->ns);
	987	+ trace_session_seqnum_update(session);
1003	988	}
1004	989
1005	990	((__be32 )bufp) = htonl(l2h);
..	..	@@ -1009,87 +994,54 @@
1009	994	return bufp - optr;
1010	995	}
1011	996
1012		-static void l2tp_xmit_core(struct l2tp_session session, struct sk_buff skb,
1013		- struct flowi *fl, size_t data_len)
	997	+/* Queue the packet to IP for output: tunnel socket lock must be held */
	998	+static int l2tp_xmit_queue(struct l2tp_tunnel tunnel, struct sk_buff skb, struct flowi *fl)
1014	999	{
1015		- struct l2tp_tunnel *tunnel = session->tunnel;
1016		- unsigned int len = skb->len;
1017		- int error;
	1000	+ int err;
1018	1001
1019		- /* Debug */
1020		- if (session->send_seq)
1021		- l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %zd bytes, ns=%u\n",
1022		- session->name, data_len, session->ns - 1);
1023		- else
1024		- l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %zd bytes\n",
1025		- session->name, data_len);
1026		-
1027		- if (session->debug & L2TP_MSG_DATA) {
1028		- int uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
1029		- unsigned char *datap = skb->data + uhlen;
1030		-
1031		- pr_debug("%s: xmit\n", session->name);
1032		- print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
1033		- datap, min_t(size_t, 32, len - uhlen));
1034		- }
1035		-
1036		- /* Queue the packet to IP for output */
1037	1002	skb->ignore_df = 1;
1038	1003	skb_dst_drop(skb);
1039	1004	#if IS_ENABLED(CONFIG_IPV6)
1040	1005	if (l2tp_sk_is_v6(tunnel->sock))
1041		- error = inet6_csk_xmit(tunnel->sock, skb, NULL);
	1006	+ err = inet6_csk_xmit(tunnel->sock, skb, NULL);
1042	1007	else
1043	1008	#endif
1044		- error = ip_queue_xmit(tunnel->sock, skb, fl);
	1009	+ err = ip_queue_xmit(tunnel->sock, skb, fl);
1045	1010
1046		- /* Update stats */
1047		- if (error >= 0) {
1048		- atomic_long_inc(&tunnel->stats.tx_packets);
1049		- atomic_long_add(len, &tunnel->stats.tx_bytes);
1050		- atomic_long_inc(&session->stats.tx_packets);
1051		- atomic_long_add(len, &session->stats.tx_bytes);
1052		- } else {
1053		- atomic_long_inc(&tunnel->stats.tx_errors);
1054		- atomic_long_inc(&session->stats.tx_errors);
1055		- }
	1011	+ return err >= 0 ? NET_XMIT_SUCCESS : NET_XMIT_DROP;
1056	1012	}
1057	1013
1058		-/* If caller requires the skb to have a ppp header, the header must be
1059		- * inserted in the skb data before calling this function.
1060		- */
1061		-int l2tp_xmit_skb(struct l2tp_session session, struct sk_buff skb, int hdr_len)
	1014	+static int l2tp_xmit_core(struct l2tp_session session, struct sk_buff skb, unsigned int *len)
1062	1015	{
1063		- int data_len = skb->len;
1064	1016	struct l2tp_tunnel *tunnel = session->tunnel;
	1017	+ unsigned int data_len = skb->len;
1065	1018	struct sock *sk = tunnel->sock;
1066		- struct flowi *fl;
1067		- struct udphdr *uh;
1068		- struct inet_sock *inet;
1069		- int headroom;
1070		- int uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
1071		- int udp_len;
	1019	+ int headroom, uhlen, udp_len;
1072	1020	int ret = NET_XMIT_SUCCESS;
	1021	+ struct inet_sock *inet;
	1022	+ struct udphdr *uh;
1073	1023
1074	1024	/* Check that there's enough headroom in the skb to insert IP,
1075	1025	* UDP and L2TP headers. If not enough, expand it to
1076	1026	* make room. Adjust truesize.
1077	1027	*/
1078		- headroom = NET_SKB_PAD + sizeof(struct iphdr) +
1079		- uhlen + hdr_len;
	1028	+ uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(*uh) : 0;
	1029	+ headroom = NET_SKB_PAD + sizeof(struct iphdr) + uhlen + session->hdr_len;
1080	1030	if (skb_cow_head(skb, headroom)) {
1081	1031	kfree_skb(skb);
1082	1032	return NET_XMIT_DROP;
1083	1033	}
1084	1034
1085	1035	/* Setup L2TP header */
1086		- session->build_header(session, __skb_push(skb, hdr_len));
	1036	+ if (tunnel->version == L2TP_HDR_VER_2)
	1037	+ l2tp_build_l2tpv2_header(session, __skb_push(skb, session->hdr_len));
	1038	+ else
	1039	+ l2tp_build_l2tpv3_header(session, __skb_push(skb, session->hdr_len));
1087	1040
1088	1041	/* Reset skb netfilter state */
1089	1042	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1090		- IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE \| IPSKB_XFRM_TRANSFORMED \|
1091		- IPSKB_REROUTED);
1092		- nf_reset(skb);
	1043	+ IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE \| IPSKB_XFRM_TRANSFORMED \| IPSKB_REROUTED);
	1044	+ nf_reset_ct(skb);
1093	1045
1094	1046	bh_lock_sock(sk);
1095	1047	if (sock_owned_by_user(sk)) {
..	..	@@ -1107,8 +1059,12 @@
1107	1059	goto out_unlock;
1108	1060	}
1109	1061
	1062	+ /* Report transmitted length before we add encap header, which keeps
	1063	+ * statistics consistent for both UDP and IP encap tx/rx paths.
	1064	+ */
	1065	+ *len = skb->len;
	1066	+
1110	1067	inet = inet_sk(sk);
1111		- fl = &inet->cork.fl;
1112	1068	switch (tunnel->encap) {
1113	1069	case L2TP_ENCAPTYPE_UDP:
1114	1070	/* Setup UDP header */
..	..	@@ -1117,7 +1073,7 @@
1117	1073	uh = udp_hdr(skb);
1118	1074	uh->source = inet->inet_sport;
1119	1075	uh->dest = inet->inet_dport;
1120		- udp_len = uhlen + hdr_len + data_len;
	1076	+ udp_len = uhlen + session->hdr_len + data_len;
1121	1077	uh->len = htons(udp_len);
1122	1078
1123	1079	/* Calculate UDP checksum if configured to do so */
..	..	@@ -1128,18 +1084,40 @@
1128	1084	&sk->sk_v6_daddr, udp_len);
1129	1085	else
1130	1086	#endif
1131		- udp_set_csum(sk->sk_no_check_tx, skb, inet->inet_saddr,
1132		- inet->inet_daddr, udp_len);
	1087	+ udp_set_csum(sk->sk_no_check_tx, skb, inet->inet_saddr,
	1088	+ inet->inet_daddr, udp_len);
1133	1089	break;
1134	1090
1135	1091	case L2TP_ENCAPTYPE_IP:
1136	1092	break;
1137	1093	}
1138	1094
1139		- l2tp_xmit_core(session, skb, fl, data_len);
	1095	+ ret = l2tp_xmit_queue(tunnel, skb, &inet->cork.fl);
	1096	+
1140	1097	out_unlock:
1141	1098	bh_unlock_sock(sk);
1142	1099
	1100	+ return ret;
	1101	+}
	1102	+
	1103	+/* If caller requires the skb to have a ppp header, the header must be
	1104	+ * inserted in the skb data before calling this function.
	1105	+ */
	1106	+int l2tp_xmit_skb(struct l2tp_session session, struct sk_buff skb)
	1107	+{
	1108	+ unsigned int len = 0;
	1109	+ int ret;
	1110	+
	1111	+ ret = l2tp_xmit_core(session, skb, &len);
	1112	+ if (ret == NET_XMIT_SUCCESS) {
	1113	+ atomic_long_inc(&session->tunnel->stats.tx_packets);
	1114	+ atomic_long_add(len, &session->tunnel->stats.tx_bytes);
	1115	+ atomic_long_inc(&session->stats.tx_packets);
	1116	+ atomic_long_add(len, &session->stats.tx_bytes);
	1117	+ } else {
	1118	+ atomic_long_inc(&session->tunnel->stats.tx_errors);
	1119	+ atomic_long_inc(&session->stats.tx_errors);
	1120	+ }
1143	1121	return ret;
1144	1122	}
1145	1123	EXPORT_SYMBOL_GPL(l2tp_xmit_skb);
..	..	@@ -1154,12 +1132,10 @@
1154	1132	*/
1155	1133	static void l2tp_tunnel_destruct(struct sock *sk)
1156	1134	{
1157		- struct l2tp_tunnel *tunnel = l2tp_tunnel(sk);
	1135	+ struct l2tp_tunnel *tunnel = l2tp_sk_to_tunnel(sk);
1158	1136
1159		- if (tunnel == NULL)
	1137	+ if (!tunnel)
1160	1138	goto end;
1161		-
1162		- l2tp_info(tunnel, L2TP_MSG_CONTROL, "%s: closing...\n", tunnel->name);
1163	1139
1164	1140	/* Disable udp encapsulation */
1165	1141	switch (tunnel->encap) {
..	..	@@ -1186,6 +1162,30 @@
1186	1162	return;
1187	1163	}
1188	1164
	1165	+/* Remove an l2tp session from l2tp_core's hash lists. */
	1166	+static void l2tp_session_unhash(struct l2tp_session *session)
	1167	+{
	1168	+ struct l2tp_tunnel *tunnel = session->tunnel;
	1169	+
	1170	+ /* Remove the session from core hashes */
	1171	+ if (tunnel) {
	1172	+ /* Remove from the per-tunnel hash */
	1173	+ write_lock_bh(&tunnel->hlist_lock);
	1174	+ hlist_del_init(&session->hlist);
	1175	+ write_unlock_bh(&tunnel->hlist_lock);
	1176	+
	1177	+ /* For L2TPv3 we have a per-net hash: remove from there, too */
	1178	+ if (tunnel->version != L2TP_HDR_VER_2) {
	1179	+ struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
	1180	+
	1181	+ spin_lock_bh(&pn->l2tp_session_hlist_lock);
	1182	+ hlist_del_init_rcu(&session->global_hlist);
	1183	+ spin_unlock_bh(&pn->l2tp_session_hlist_lock);
	1184	+ synchronize_rcu();
	1185	+ }
	1186	+ }
	1187	+}
	1188	+
1189	1189	/* When the tunnel is closed, all the attached sessions need to go too.
1190	1190	*/
1191	1191	static void l2tp_tunnel_closeall(struct l2tp_tunnel *tunnel)
..	..	@@ -1195,36 +1195,16 @@
1195	1195	struct hlist_node *tmp;
1196	1196	struct l2tp_session *session;
1197	1197
1198		- BUG_ON(tunnel == NULL);
1199		-
1200		- l2tp_info(tunnel, L2TP_MSG_CONTROL, "%s: closing all sessions...\n",
1201		- tunnel->name);
1202		-
1203	1198	write_lock_bh(&tunnel->hlist_lock);
1204	1199	tunnel->acpt_newsess = false;
1205	1200	for (hash = 0; hash < L2TP_HASH_SIZE; hash++) {
1206	1201	again:
1207	1202	hlist_for_each_safe(walk, tmp, &tunnel->session_hlist[hash]) {
1208	1203	session = hlist_entry(walk, struct l2tp_session, hlist);
1209		-
1210		- l2tp_info(session, L2TP_MSG_CONTROL,
1211		- "%s: closing session\n", session->name);
1212		-
1213	1204	hlist_del_init(&session->hlist);
1214	1205
1215		- if (test_and_set_bit(0, &session->dead))
1216		- goto again;
1217		-
1218	1206	write_unlock_bh(&tunnel->hlist_lock);
1219		-
1220		- __l2tp_session_unhash(session);
1221		- l2tp_session_queue_purge(session);
1222		-
1223		- if (session->session_close != NULL)
1224		- (*session->session_close)(session);
1225		-
1226		- l2tp_session_dec_refcount(session);
1227		-
	1207	+ l2tp_session_delete(session);
1228	1208	write_lock_bh(&tunnel->hlist_lock);
1229	1209
1230	1210	/* Now restart from the beginning of this hash
..	..	@@ -1241,7 +1221,7 @@
1241	1221	/* Tunnel socket destroy hook for UDP encapsulation */
1242	1222	static void l2tp_udp_encap_destroy(struct sock *sk)
1243	1223	{
1244		- struct l2tp_tunnel *tunnel = l2tp_tunnel(sk);
	1224	+ struct l2tp_tunnel *tunnel = l2tp_sk_to_tunnel(sk);
1245	1225
1246	1226	if (tunnel)
1247	1227	l2tp_tunnel_delete(tunnel);
..	..	@@ -1291,10 +1271,10 @@
1291	1271	* exit hook.
1292	1272	*/
1293	1273	static int l2tp_tunnel_sock_create(struct net *net,
1294		- u32 tunnel_id,
1295		- u32 peer_tunnel_id,
1296		- struct l2tp_tunnel_cfg *cfg,
1297		- struct socket **sockp)
	1274	+ u32 tunnel_id,
	1275	+ u32 peer_tunnel_id,
	1276	+ struct l2tp_tunnel_cfg *cfg,
	1277	+ struct socket **sockp)
1298	1278	{
1299	1279	int err = -EINVAL;
1300	1280	struct socket *sock = NULL;
..	..	@@ -1312,9 +1292,9 @@
1312	1292	memcpy(&udp_conf.peer_ip6, cfg->peer_ip6,
1313	1293	sizeof(udp_conf.peer_ip6));
1314	1294	udp_conf.use_udp6_tx_checksums =
1315		- ! cfg->udp6_zero_tx_checksums;
	1295	+ !cfg->udp6_zero_tx_checksums;
1316	1296	udp_conf.use_udp6_rx_checksums =
1317		- ! cfg->udp6_zero_rx_checksums;
	1297	+ !cfg->udp6_zero_rx_checksums;
1318	1298	} else
1319	1299	#endif
1320	1300	{
..	..	@@ -1339,7 +1319,7 @@
1339	1319	struct sockaddr_l2tpip6 ip6_addr = {0};
1340	1320
1341	1321	err = sock_create_kern(net, AF_INET6, SOCK_DGRAM,
1342		- IPPROTO_L2TP, &sock);
	1322	+ IPPROTO_L2TP, &sock);
1343	1323	if (err < 0)
1344	1324	goto out;
1345	1325
..	..	@@ -1347,7 +1327,7 @@
1347	1327	memcpy(&ip6_addr.l2tp_addr, cfg->local_ip6,
1348	1328	sizeof(ip6_addr.l2tp_addr));
1349	1329	ip6_addr.l2tp_conn_id = tunnel_id;
1350		- err = kernel_bind(sock, (struct sockaddr *) &ip6_addr,
	1330	+ err = kernel_bind(sock, (struct sockaddr *)&ip6_addr,
1351	1331	sizeof(ip6_addr));
1352	1332	if (err < 0)
1353	1333	goto out;
..	..	@@ -1357,7 +1337,7 @@
1357	1337	sizeof(ip6_addr.l2tp_addr));
1358	1338	ip6_addr.l2tp_conn_id = peer_tunnel_id;
1359	1339	err = kernel_connect(sock,
1360		- (struct sockaddr *) &ip6_addr,
	1340	+ (struct sockaddr *)&ip6_addr,
1361	1341	sizeof(ip6_addr), 0);
1362	1342	if (err < 0)
1363	1343	goto out;
..	..	@@ -1367,14 +1347,14 @@
1367	1347	struct sockaddr_l2tpip ip_addr = {0};
1368	1348
1369	1349	err = sock_create_kern(net, AF_INET, SOCK_DGRAM,
1370		- IPPROTO_L2TP, &sock);
	1350	+ IPPROTO_L2TP, &sock);
1371	1351	if (err < 0)
1372	1352	goto out;
1373	1353
1374	1354	ip_addr.l2tp_family = AF_INET;
1375	1355	ip_addr.l2tp_addr = cfg->local_ip;
1376	1356	ip_addr.l2tp_conn_id = tunnel_id;
1377		- err = kernel_bind(sock, (struct sockaddr *) &ip_addr,
	1357	+ err = kernel_bind(sock, (struct sockaddr *)&ip_addr,
1378	1358	sizeof(ip_addr));
1379	1359	if (err < 0)
1380	1360	goto out;
..	..	@@ -1382,7 +1362,7 @@
1382	1362	ip_addr.l2tp_family = AF_INET;
1383	1363	ip_addr.l2tp_addr = cfg->peer_ip;
1384	1364	ip_addr.l2tp_conn_id = peer_tunnel_id;
1385		- err = kernel_connect(sock, (struct sockaddr *) &ip_addr,
	1365	+ err = kernel_connect(sock, (struct sockaddr *)&ip_addr,
1386	1366	sizeof(ip_addr), 0);
1387	1367	if (err < 0)
1388	1368	goto out;
..	..	@@ -1395,7 +1375,7 @@
1395	1375
1396	1376	out:
1397	1377	*sockp = sock;
1398		- if ((err < 0) && sock) {
	1378	+ if (err < 0 && sock) {
1399	1379	kernel_sock_shutdown(sock, SHUT_RDWR);
1400	1380	sock_release(sock);
1401	1381	*sockp = NULL;
..	..	@@ -1406,17 +1386,18 @@
1406	1386
1407	1387	static struct lock_class_key l2tp_socket_class;
1408	1388
1409		-int l2tp_tunnel_create(struct net net, int fd, int version, u32 tunnel_id, u32 peer_tunnel_id, struct l2tp_tunnel_cfg cfg, struct l2tp_tunnel **tunnelp)
	1389	+int l2tp_tunnel_create(int fd, int version, u32 tunnel_id, u32 peer_tunnel_id,
	1390	+ struct l2tp_tunnel_cfg cfg, struct l2tp_tunnel *tunnelp)
1410	1391	{
1411	1392	struct l2tp_tunnel *tunnel = NULL;
1412	1393	int err;
1413	1394	enum l2tp_encap_type encap = L2TP_ENCAPTYPE_UDP;
1414	1395
1415		- if (cfg != NULL)
	1396	+ if (cfg)
1416	1397	encap = cfg->encap;
1417	1398
1418		- tunnel = kzalloc(sizeof(struct l2tp_tunnel), GFP_KERNEL);
1419		- if (tunnel == NULL) {
	1399	+ tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
	1400	+ if (!tunnel) {
1420	1401	err = -ENOMEM;
1421	1402	goto err;
1422	1403	}
..	..	@@ -1424,15 +1405,11 @@
1424	1405	tunnel->version = version;
1425	1406	tunnel->tunnel_id = tunnel_id;
1426	1407	tunnel->peer_tunnel_id = peer_tunnel_id;
1427		- tunnel->debug = L2TP_DEFAULT_DEBUG_FLAGS;
1428	1408
1429	1409	tunnel->magic = L2TP_TUNNEL_MAGIC;
1430	1410	sprintf(&tunnel->name[0], "tunl %u", tunnel_id);
1431	1411	rwlock_init(&tunnel->hlist_lock);
1432	1412	tunnel->acpt_newsess = true;
1433		-
1434		- if (cfg != NULL)
1435		- tunnel->debug = cfg->debug;
1436	1413
1437	1414	tunnel->encap = encap;
1438	1415
..	..	@@ -1503,21 +1480,21 @@
1503	1480	tunnel->l2tp_net = net;
1504	1481	pn = l2tp_pernet(net);
1505	1482
	1483	+ sk = sock->sk;
	1484	+ sock_hold(sk);
	1485	+ tunnel->sock = sk;
	1486	+
1506	1487	spin_lock_bh(&pn->l2tp_tunnel_list_lock);
1507	1488	list_for_each_entry(tunnel_walk, &pn->l2tp_tunnel_list, list) {
1508	1489	if (tunnel_walk->tunnel_id == tunnel->tunnel_id) {
1509	1490	spin_unlock_bh(&pn->l2tp_tunnel_list_lock);
1510		-
	1491	+ sock_put(sk);
1511	1492	ret = -EEXIST;
1512	1493	goto err_sock;
1513	1494	}
1514	1495	}
1515	1496	list_add_rcu(&tunnel->list, &pn->l2tp_tunnel_list);
1516	1497	spin_unlock_bh(&pn->l2tp_tunnel_list_lock);
1517		-
1518		- sk = sock->sk;
1519		- sock_hold(sk);
1520		- tunnel->sock = sk;
1521	1498
1522	1499	if (tunnel->encap == L2TP_ENCAPTYPE_UDP) {
1523	1500	struct udp_tunnel_sock_cfg udp_cfg = {
..	..	@@ -1537,6 +1514,8 @@
1537	1514	lockdep_set_class_and_name(&sk->sk_lock.slock, &l2tp_socket_class,
1538	1515	"l2tp_sock");
1539	1516	sk->sk_allocation = GFP_ATOMIC;
	1517	+
	1518	+ trace_register_tunnel(tunnel);
1540	1519
1541	1520	if (tunnel->fd >= 0)
1542	1521	sockfd_put(sock);
..	..	@@ -1558,73 +1537,25 @@
1558	1537	void l2tp_tunnel_delete(struct l2tp_tunnel *tunnel)
1559	1538	{
1560	1539	if (!test_and_set_bit(0, &tunnel->dead)) {
	1540	+ trace_delete_tunnel(tunnel);
1561	1541	l2tp_tunnel_inc_refcount(tunnel);
1562	1542	queue_work(l2tp_wq, &tunnel->del_work);
1563	1543	}
1564	1544	}
1565	1545	EXPORT_SYMBOL_GPL(l2tp_tunnel_delete);
1566	1546
1567		-/* Really kill the session.
1568		- */
1569		-void l2tp_session_free(struct l2tp_session *session)
1570		-{
1571		- struct l2tp_tunnel *tunnel = session->tunnel;
1572		-
1573		- BUG_ON(refcount_read(&session->ref_count) != 0);
1574		-
1575		- if (tunnel) {
1576		- BUG_ON(tunnel->magic != L2TP_TUNNEL_MAGIC);
1577		- l2tp_tunnel_dec_refcount(tunnel);
1578		- }
1579		-
1580		- kfree(session);
1581		-}
1582		-EXPORT_SYMBOL_GPL(l2tp_session_free);
1583		-
1584		-/* Remove an l2tp session from l2tp_core's hash lists.
1585		- * Provides a tidyup interface for pseudowire code which can't just route all
1586		- * shutdown via. l2tp_session_delete and a pseudowire-specific session_close
1587		- * callback.
1588		- */
1589		-void __l2tp_session_unhash(struct l2tp_session *session)
1590		-{
1591		- struct l2tp_tunnel *tunnel = session->tunnel;
1592		-
1593		- /* Remove the session from core hashes */
1594		- if (tunnel) {
1595		- /* Remove from the per-tunnel hash */
1596		- write_lock_bh(&tunnel->hlist_lock);
1597		- hlist_del_init(&session->hlist);
1598		- write_unlock_bh(&tunnel->hlist_lock);
1599		-
1600		- /* For L2TPv3 we have a per-net hash: remove from there, too */
1601		- if (tunnel->version != L2TP_HDR_VER_2) {
1602		- struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
1603		- spin_lock_bh(&pn->l2tp_session_hlist_lock);
1604		- hlist_del_init_rcu(&session->global_hlist);
1605		- spin_unlock_bh(&pn->l2tp_session_hlist_lock);
1606		- synchronize_rcu();
1607		- }
1608		- }
1609		-}
1610		-EXPORT_SYMBOL_GPL(__l2tp_session_unhash);
1611		-
1612		-/* This function is used by the netlink SESSION_DELETE command and by
1613		- pseudowire modules.
1614		- */
1615		-int l2tp_session_delete(struct l2tp_session *session)
	1547	+void l2tp_session_delete(struct l2tp_session *session)
1616	1548	{
1617	1549	if (test_and_set_bit(0, &session->dead))
1618		- return 0;
	1550	+ return;
1619	1551
1620		- __l2tp_session_unhash(session);
	1552	+ trace_delete_session(session);
	1553	+ l2tp_session_unhash(session);
1621	1554	l2tp_session_queue_purge(session);
1622		- if (session->session_close != NULL)
	1555	+ if (session->session_close)
1623	1556	(*session->session_close)(session);
1624	1557
1625	1558	l2tp_session_dec_refcount(session);
1626		-
1627		- return 0;
1628	1559	}
1629	1560	EXPORT_SYMBOL_GPL(l2tp_session_delete);
1630	1561
..	..	@@ -1643,16 +1574,16 @@
1643	1574	if (session->tunnel->encap == L2TP_ENCAPTYPE_UDP)
1644	1575	session->hdr_len += 4;
1645	1576	}
1646		-
1647	1577	}
1648	1578	EXPORT_SYMBOL_GPL(l2tp_session_set_header_len);
1649	1579
1650		-struct l2tp_session l2tp_session_create(int priv_size, struct l2tp_tunnel tunnel, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg)
	1580	+struct l2tp_session l2tp_session_create(int priv_size, struct l2tp_tunnel tunnel, u32 session_id,
	1581	+ u32 peer_session_id, struct l2tp_session_cfg *cfg)
1651	1582	{
1652	1583	struct l2tp_session *session;
1653	1584
1654		- session = kzalloc(sizeof(struct l2tp_session) + priv_size, GFP_KERNEL);
1655		- if (session != NULL) {
	1585	+ session = kzalloc(sizeof(*session) + priv_size, GFP_KERNEL);
	1586	+ if (session) {
1656	1587	session->magic = L2TP_SESSION_MAGIC;
1657	1588	session->tunnel = tunnel;
1658	1589
..	..	@@ -1677,12 +1608,8 @@
1677	1608	INIT_HLIST_NODE(&session->hlist);
1678	1609	INIT_HLIST_NODE(&session->global_hlist);
1679	1610
1680		- /* Inherit debug options from tunnel */
1681		- session->debug = tunnel->debug;
1682		-
1683	1611	if (cfg) {
1684	1612	session->pwtype = cfg->pw_type;
1685		- session->debug = cfg->debug;
1686	1613	session->send_seq = cfg->send_seq;
1687	1614	session->recv_seq = cfg->recv_seq;
1688	1615	session->lns_mode = cfg->lns_mode;
..	..	@@ -1693,11 +1620,6 @@
1693	1620	session->peer_cookie_len = cfg->peer_cookie_len;
1694	1621	memcpy(&session->peer_cookie[0], &cfg->peer_cookie[0], cfg->peer_cookie_len);
1695	1622	}
1696		-
1697		- if (tunnel->version == L2TP_HDR_VER_2)
1698		- session->build_header = l2tp_build_l2tpv2_header;
1699		- else
1700		- session->build_header = l2tp_build_l2tpv3_header;
1701	1623
1702	1624	l2tp_session_set_header_len(session, tunnel->version);
1703	1625