Lines Matching refs:session
169 static void l2tp_session_free(struct l2tp_session *session)
171 trace_free_session(session);
172 if (session->tunnel)
173 l2tp_tunnel_put(session->tunnel);
174 kfree_rcu(session, rcu);
207 void l2tp_session_put(struct l2tp_session *session)
209 if (refcount_dec_and_test(&session->ref_count))
210 l2tp_session_free(session);
257 struct l2tp_session *session;
260 session = idr_find(&pn->l2tp_v3_session_idr, session_id);
261 if (session && !hash_hashed(&session->hlist) &&
262 refcount_inc_not_zero(&session->ref_count)) {
264 return session;
267 /* If we get here and session is non-NULL, the session_id
269 * find the session matching sk.
271 if (session && sk) {
272 unsigned long key = l2tp_v3_session_hashkey(sk, session->session_id);
274 hash_for_each_possible_rcu(pn->l2tp_v3_session_htable, session,
276 /* session->tunnel may be NULL if another thread is in
279 * session to its tunnel's session_list.
281 struct l2tp_tunnel *tunnel = READ_ONCE(session->tunnel);
283 if (session->session_id == session_id &&
285 refcount_inc_not_zero(&session->ref_count)) {
287 return session;
301 struct l2tp_session *session;
304 session = idr_find(&pn->l2tp_v2_session_idr, session_key);
305 if (session && refcount_inc_not_zero(&session->ref_count)) {
307 return session;
330 struct l2tp_session *session = NULL;
338 session = idr_get_next_ul(&pn->l2tp_v2_session_idr, key);
339 if (session) {
340 struct l2tp_tunnel *tunnel = READ_ONCE(session->tunnel);
343 if (session->session_id == 0) {
349 refcount_inc_not_zero(&session->ref_count)) {
351 return session;
368 struct l2tp_session *session = NULL;
372 session = idr_get_next_ul(&pn->l2tp_v3_session_idr, key);
373 if (session && !hash_hashed(&session->hlist)) {
374 struct l2tp_tunnel *tunnel = READ_ONCE(session->tunnel);
377 refcount_inc_not_zero(&session->ref_count)) {
379 return session;
386 /* If we get here and session is non-NULL, the IDR entry may be one
388 * session_htable for a match. There can only be one session of a given
391 if (session && hash_hashed(&session->hlist)) {
392 unsigned long hkey = l2tp_v3_session_hashkey(sk, session->session_id);
393 u32 sid = session->session_id;
395 hash_for_each_possible_rcu(pn->l2tp_v3_session_htable, session,
397 struct l2tp_tunnel *tunnel = READ_ONCE(session->tunnel);
399 if (session->session_id == sid &&
401 refcount_inc_not_zero(&session->ref_count)) {
403 return session;
407 /* If no match found, the colliding session ID isn't in our
408 * tunnel so try the next session ID.
429 /* Lookup a session by interface name.
437 struct l2tp_session *session;
443 list_for_each_entry_rcu(session, &tunnel->session_list, list) {
444 if (!strcmp(session->ifname, ifname)) {
445 refcount_inc(&session->ref_count);
448 return session;
460 struct l2tp_session *session)
462 refcount_inc(&session->ref_count);
463 WARN_ON_ONCE(session->coll_list);
464 session->coll_list = clist;
466 list_add(&session->clist, &clist->list);
481 /* If existing session is in IP-encap tunnel, refuse new session */
488 * and add the existing session to the list.
500 /* If existing session isn't already in the session hlist, add it. */
505 /* Add new session to the hlist and collision list */
515 struct l2tp_session *session)
517 struct l2tp_session_coll_list *clist = session->coll_list;
518 unsigned long session_key = session->session_id;
523 hash_del_rcu(&session->hlist);
526 /* Remove session from its collision list. If there
528 * session's IDR entry with that session, otherwise
529 * remove the IDR entry. If this is the last session,
533 list_del_init(&session->clist);
542 WARN_ON_ONCE(removed != session);
544 session->coll_list = NULL;
548 l2tp_session_put(session);
552 int l2tp_session_register(struct l2tp_session *session,
570 session_key = session->session_id;
573 /* IP encap expects session IDs to be globally unique, while
575 * sessions are identified only by the session ID, but is to
581 err = l2tp_session_collision_add(pn, session,
586 session->session_id);
598 WRITE_ONCE(session->tunnel, tunnel);
599 list_add_rcu(&session->list, &tunnel->session_list);
601 /* this makes session available to lockless getters */
604 old = idr_replace(&pn->l2tp_v3_session_idr, session, session_key);
606 old = idr_replace(&pn->l2tp_v2_session_idr, session, session_key);
619 trace_register_session(session);
632 static void l2tp_recv_queue_skb(struct l2tp_session *session, struct sk_buff *skb)
638 spin_lock_bh(&session->reorder_q.lock);
639 skb_queue_walk_safe(&session->reorder_q, skbp, tmp) {
641 __skb_queue_before(&session->reorder_q, skbp, skb);
642 atomic_long_inc(&session->stats.rx_oos_packets);
647 __skb_queue_tail(&session->reorder_q, skb);
650 spin_unlock_bh(&session->reorder_q.lock);
655 static void l2tp_recv_dequeue_skb(struct l2tp_session *session, struct sk_buff *skb)
657 struct l2tp_tunnel *tunnel = session->tunnel;
667 atomic_long_inc(&session->stats.rx_packets);
668 atomic_long_add(length, &session->stats.rx_bytes);
672 session->nr++;
673 session->nr &= session->nr_max;
674 trace_session_seqnum_update(session);
678 if (session->recv_skb)
679 (*session->recv_skb)(session, skb, L2TP_SKB_CB(skb)->length);
684 /* Dequeue skbs from the session's reorder_q, subject to packet order.
687 static void l2tp_recv_dequeue(struct l2tp_session *session)
697 spin_lock_bh(&session->reorder_q.lock);
698 skb_queue_walk_safe(&session->reorder_q, skb, tmp) {
703 atomic_long_inc(&session->stats.rx_seq_discards);
704 atomic_long_inc(&session->stats.rx_errors);
705 trace_session_pkt_expired(session, cb->ns);
706 session->reorder_skip = 1;
707 __skb_unlink(skb, &session->reorder_q);
713 if (session->reorder_skip) {
714 session->reorder_skip = 0;
715 session->nr = cb->ns;
716 trace_session_seqnum_reset(session);
718 if (cb->ns != session->nr)
721 __skb_unlink(skb, &session->reorder_q);
726 spin_unlock_bh(&session->reorder_q.lock);
727 l2tp_recv_dequeue_skb(session, skb);
732 spin_unlock_bh(&session->reorder_q.lock);
735 static int l2tp_seq_check_rx_window(struct l2tp_session *session, u32 nr)
739 if (nr >= session->nr)
740 nws = nr - session->nr;
742 nws = (session->nr_max + 1) - (session->nr - nr);
744 return nws < session->nr_window_size;
750 static int l2tp_recv_data_seq(struct l2tp_session *session, struct sk_buff *skb)
754 if (!l2tp_seq_check_rx_window(session, cb->ns)) {
758 trace_session_pkt_outside_rx_window(session, cb->ns);
762 if (session->reorder_timeout != 0) {
763 /* Packet reordering enabled. Add skb to session's
766 l2tp_recv_queue_skb(session, skb);
775 if (cb->ns == session->nr) {
776 skb_queue_tail(&session->reorder_q, skb);
779 u32 nr_next = (session->nr_oos + 1) & session->nr_max;
782 session->nr_oos_count++;
784 session->nr_oos_count = 0;
786 session->nr_oos = nr_oos;
787 if (session->nr_oos_count > session->nr_oos_count_max) {
788 session->reorder_skip = 1;
790 if (!session->reorder_skip) {
791 atomic_long_inc(&session->stats.rx_seq_discards);
792 trace_session_pkt_oos(session, cb->ns);
795 skb_queue_tail(&session->reorder_q, skb);
856 * the session is set up. Unlike L2TPv2, we do not need to parse the
861 * session-id have already been parsed and ptr points to the data
862 * after the session-id.
864 void l2tp_recv_common(struct l2tp_session *session, struct sk_buff *skb,
868 struct l2tp_tunnel *tunnel = session->tunnel;
872 if (session->peer_cookie_len > 0) {
873 if (memcmp(ptr, &session->peer_cookie[0], session->peer_cookie_len)) {
876 session->session_id);
877 atomic_long_inc(&session->stats.rx_cookie_discards);
880 ptr += session->peer_cookie_len;
901 } else if (session->l2specific_type == L2TP_L2SPECTYPE_DEFAULT) {
917 if (!session->lns_mode && !session->send_seq) {
918 trace_session_seqnum_lns_enable(session);
919 session->send_seq = 1;
920 l2tp_session_set_header_len(session, tunnel->version,
927 if (session->recv_seq) {
929 session->name);
930 atomic_long_inc(&session->stats.rx_seq_discards);
939 if (!session->lns_mode && session->send_seq) {
940 trace_session_seqnum_lns_disable(session);
941 session->send_seq = 0;
942 l2tp_session_set_header_len(session, tunnel->version,
944 } else if (session->send_seq) {
946 session->name);
947 atomic_long_inc(&session->stats.rx_seq_discards);
969 /* Prepare skb for adding to the session's reorder_q. Hold
975 (session->reorder_timeout ? session->reorder_timeout : HZ);
977 /* Add packet to the session's receive queue. Reordering is done here, if
981 if (l2tp_recv_data_seq(session, skb))
988 skb_queue_tail(&session->reorder_q, skb);
992 l2tp_recv_dequeue(session);
997 atomic_long_inc(&session->stats.rx_errors);
1002 /* Drop skbs from the session's reorder_q
1004 static void l2tp_session_queue_purge(struct l2tp_session *session)
1008 while ((skb = skb_dequeue(&session->reorder_q))) {
1009 atomic_long_inc(&session->stats.rx_errors);
1017 struct l2tp_session *session = NULL;
1061 /* Extract tunnel and session ID */
1067 session = l2tp_v2_session_get(net, tunnel_id, session_id);
1075 session = l2tp_v3_session_get(net, sk, session_id);
1078 if (!session || !session->recv_skb) {
1079 if (session)
1080 l2tp_session_put(session);
1086 tunnel = session->tunnel;
1093 l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr)) {
1094 l2tp_session_put(session);
1098 l2tp_recv_common(session, skb, ptr, optr, hdrflags, length);
1099 l2tp_session_put(session);
1136 /* Build an L2TP header for the session into the buffer provided.
1138 static int l2tp_build_l2tpv2_header(struct l2tp_session *session, void *buf)
1140 struct l2tp_tunnel *tunnel = session->tunnel;
1145 u32 session_id = session->peer_session_id;
1147 if (session->send_seq)
1154 if (session->send_seq) {
1155 *bufp++ = htons(session->ns);
1157 session->ns++;
1158 session->ns &= 0xffff;
1159 trace_session_seqnum_update(session);
1165 static int l2tp_build_l2tpv3_header(struct l2tp_session *session, void *buf)
1167 struct l2tp_tunnel *tunnel = session->tunnel;
1182 *((__be32 *)bufp) = htonl(session->peer_session_id);
1184 if (session->cookie_len) {
1185 memcpy(bufp, &session->cookie[0], session->cookie_len);
1186 bufp += session->cookie_len;
1188 if (session->l2specific_type == L2TP_L2SPECTYPE_DEFAULT) {
1191 if (session->send_seq) {
1192 l2h = 0x40000000 | session->ns;
1193 session->ns++;
1194 session->ns &= 0xffffff;
1195 trace_session_seqnum_update(session);
1222 static int l2tp_xmit_core(struct l2tp_session *session, struct sk_buff *skb, unsigned int *len)
1224 struct l2tp_tunnel *tunnel = session->tunnel;
1237 headroom = NET_SKB_PAD + sizeof(struct iphdr) + uhlen + session->hdr_len;
1245 l2tp_build_l2tpv2_header(session, __skb_push(skb, session->hdr_len));
1247 l2tp_build_l2tpv3_header(session, __skb_push(skb, session->hdr_len));
1290 udp_len = uhlen + session->hdr_len + data_len;
1320 int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb)
1325 ret = l2tp_xmit_core(session, skb, &len);
1327 atomic_long_inc(&session->tunnel->stats.tx_packets);
1328 atomic_long_add(len, &session->tunnel->stats.tx_bytes);
1329 atomic_long_inc(&session->stats.tx_packets);
1330 atomic_long_add(len, &session->stats.tx_bytes);
1332 atomic_long_inc(&session->tunnel->stats.tx_errors);
1333 atomic_long_inc(&session->stats.tx_errors);
1340 * Tinnel and session create/destroy.
1343 /* Remove an l2tp session from l2tp_core's lists. */
1344 static void l2tp_session_unhash(struct l2tp_session *session)
1346 struct l2tp_tunnel *tunnel = session->tunnel;
1350 struct l2tp_session *removed = session;
1356 list_del_init(&session->list);
1360 if (hash_hashed(&session->hlist))
1361 l2tp_session_collision_del(pn, session);
1364 session->session_id);
1367 session->session_id);
1371 WARN_ON_ONCE(removed && removed != session);
1382 struct l2tp_session *session;
1386 list_for_each_entry(session, &tunnel->session_list, list)
1387 l2tp_session_delete(session);
1726 void l2tp_session_delete(struct l2tp_session *session)
1728 if (!test_and_set_bit(0, &session->dead)) {
1729 trace_delete_session(session);
1730 refcount_inc(&session->ref_count);
1731 queue_work(l2tp_wq, &session->del_work);
1736 /* Workqueue session deletion function */
1739 struct l2tp_session *session = container_of(work, struct l2tp_session,
1742 l2tp_session_unhash(session);
1743 l2tp_session_queue_purge(session);
1744 if (session->session_close)
1745 (*session->session_close)(session);
1748 l2tp_session_put(session);
1751 l2tp_session_put(session);
1754 /* We come here whenever a session's send_seq, cookie_len or
1757 void l2tp_session_set_header_len(struct l2tp_session *session, int version,
1761 session->hdr_len = 6;
1762 if (session->send_seq)
1763 session->hdr_len += 4;
1765 session->hdr_len = 4 + session->cookie_len;
1766 session->hdr_len += l2tp_get_l2specific_len(session);
1768 session->hdr_len += 4;
1776 struct l2tp_session *session;
1778 session = kzalloc(sizeof(*session) + priv_size, GFP_KERNEL);
1779 if (session) {
1780 session->magic = L2TP_SESSION_MAGIC;
1782 session->session_id = session_id;
1783 session->peer_session_id = peer_session_id;
1784 session->nr = 0;
1786 session->nr_max = 0xffff;
1788 session->nr_max = 0xffffff;
1789 session->nr_window_size = session->nr_max / 2;
1790 session->nr_oos_count_max = 4;
1793 session->reorder_skip = 1;
1795 sprintf(&session->name[0], "sess %u/%u",
1796 tunnel->tunnel_id, session->session_id);
1798 skb_queue_head_init(&session->reorder_q);
1800 session->hlist_key = l2tp_v3_session_hashkey(tunnel->sock, session->session_id);
1801 INIT_HLIST_NODE(&session->hlist);
1802 INIT_LIST_HEAD(&session->clist);
1803 INIT_LIST_HEAD(&session->list);
1804 INIT_WORK(&session->del_work, l2tp_session_del_work);
1807 session->pwtype = cfg->pw_type;
1808 session->send_seq = cfg->send_seq;
1809 session->recv_seq = cfg->recv_seq;
1810 session->lns_mode = cfg->lns_mode;
1811 session->reorder_timeout = cfg->reorder_timeout;
1812 session->l2specific_type = cfg->l2specific_type;
1813 session->cookie_len = cfg->cookie_len;
1814 memcpy(&session->cookie[0], &cfg->cookie[0], cfg->cookie_len);
1815 session->peer_cookie_len = cfg->peer_cookie_len;
1816 memcpy(&session->peer_cookie[0], &cfg->peer_cookie[0], cfg->peer_cookie_len);
1819 l2tp_session_set_header_len(session, tunnel->version, tunnel->encap);
1821 refcount_set(&session->ref_count, 1);
1823 return session;
1866 * work item for each session in the tunnel. Flush the