Lines Matching refs:session
46 * connection managed session was terminated.
56 * close the session.
136 return "System resources were needed for another task so this connection managed session was terminated.";
138 return "A timeout occurred and this is the connection abort to close the session.";
246 void j1939_session_get(struct j1939_session *session)
248 kref_get(&session->kref);
251 /* session completion functions */
252 static void __j1939_session_drop(struct j1939_session *session)
254 if (!session->transmission)
257 j1939_sock_pending_del(session->sk);
258 sock_put(session->sk);
261 static void j1939_session_destroy(struct j1939_session *session)
265 if (session->err)
266 j1939_sk_errqueue(session, J1939_ERRQUEUE_ABORT);
268 j1939_sk_errqueue(session, J1939_ERRQUEUE_ACK);
270 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
272 WARN_ON_ONCE(!list_empty(&session->sk_session_queue_entry));
273 WARN_ON_ONCE(!list_empty(&session->active_session_list_entry));
275 while ((skb = skb_dequeue(&session->skb_queue)) != NULL) {
280 __j1939_session_drop(session);
281 j1939_priv_put(session->priv);
282 kfree(session);
287 struct j1939_session *session = container_of(kref, struct j1939_session,
290 j1939_session_destroy(session);
293 void j1939_session_put(struct j1939_session *session)
295 kref_put(&session->kref, __j1939_session_release);
298 static void j1939_session_txtimer_cancel(struct j1939_session *session)
300 if (hrtimer_cancel(&session->txtimer))
301 j1939_session_put(session);
304 static void j1939_session_rxtimer_cancel(struct j1939_session *session)
306 if (hrtimer_cancel(&session->rxtimer))
307 j1939_session_put(session);
310 void j1939_session_timers_cancel(struct j1939_session *session)
312 j1939_session_txtimer_cancel(session);
313 j1939_session_rxtimer_cancel(session);
321 static void j1939_session_skb_drop_old(struct j1939_session *session)
328 if (skb_queue_len(&session->skb_queue) < 2)
331 offset_start = session->pkt.tx_acked * 7;
333 spin_lock_irqsave(&session->skb_queue.lock, flags);
334 do_skb = skb_peek(&session->skb_queue);
338 __skb_unlink(do_skb, &session->skb_queue);
341 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
345 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
349 void j1939_session_skb_queue(struct j1939_session *session,
353 struct j1939_priv *priv = session->priv;
364 skb_queue_tail(&session->skb_queue, skb);
368 sk_buff *j1939_session_skb_get_by_offset(struct j1939_session *session,
371 struct j1939_priv *priv = session->priv;
377 spin_lock_irqsave(&session->skb_queue.lock, flags);
378 skb_queue_walk(&session->skb_queue, do_skb) {
390 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
394 __func__, session, offset_start,
395 skb_queue_len(&session->skb_queue));
400 static struct sk_buff *j1939_session_skb_get(struct j1939_session *session)
404 offset_start = session->pkt.dpo * 7;
405 return j1939_session_skb_get_by_offset(session, offset_start);
463 /* find existing session:
514 struct j1939_session *session;
518 list_for_each_entry(session, root, active_session_list_entry) {
519 j1939_session_get(session);
520 if (j1939_session_match(&session->skcb.addr, addr, reverse) &&
521 session->transmission == transmitter)
522 return session;
523 j1939_session_put(session);
534 struct j1939_session *session;
538 list_for_each_entry(session, &priv->active_session_list,
540 j1939_session_get(session);
541 if (session->skcb.addr.type == J1939_SIMPLE &&
542 session->tskey == skcb->tskey && session->sk == skb->sk)
543 return session;
544 j1939_session_put(session);
555 struct j1939_session *session;
558 session = j1939_session_get_by_addr_locked(priv,
563 return session;
627 static int j1939_tp_tx_dat(struct j1939_session *session,
630 struct j1939_priv *priv = session->priv;
633 skb = j1939_tp_tx_dat_new(priv, &session->skcb,
668 static inline int j1939_tp_tx_ctl(struct j1939_session *session,
671 struct j1939_priv *priv = session->priv;
673 return j1939_xtp_do_tx_ctl(priv, &session->skcb,
675 session->skcb.addr.pgn, dat);
695 void j1939_tp_schedule_txtimer(struct j1939_session *session, int msec)
697 j1939_session_get(session);
698 hrtimer_start(&session->txtimer, ms_to_ktime(msec),
702 static inline void j1939_tp_set_rxtimeout(struct j1939_session *session,
705 j1939_session_rxtimer_cancel(session);
706 j1939_session_get(session);
707 hrtimer_start(&session->rxtimer, ms_to_ktime(msec),
711 static int j1939_session_tx_rts(struct j1939_session *session)
718 dat[1] = (session->total_message_size >> 0);
719 dat[2] = (session->total_message_size >> 8);
720 dat[3] = session->pkt.total;
722 if (session->skcb.addr.type == J1939_ETP) {
724 dat[1] = (session->total_message_size >> 0);
725 dat[2] = (session->total_message_size >> 8);
726 dat[3] = (session->total_message_size >> 16);
727 dat[4] = (session->total_message_size >> 24);
728 } else if (j1939_cb_is_broadcast(&session->skcb)) {
731 session->pkt.tx = 0;
737 if (dat[0] == session->last_txcmd)
741 ret = j1939_tp_tx_ctl(session, false, dat);
745 session->last_txcmd = dat[0];
747 j1939_tp_schedule_txtimer(session, 50);
748 j1939_tp_set_rxtimeout(session, 250);
750 j1939_tp_set_rxtimeout(session, 1250);
753 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
758 static int j1939_session_tx_dpo(struct j1939_session *session)
767 session->pkt.dpo = session->pkt.tx_acked;
768 pkt = session->pkt.dpo;
769 dat[1] = session->pkt.last - session->pkt.tx_acked;
774 ret = j1939_tp_tx_ctl(session, false, dat);
778 session->last_txcmd = dat[0];
779 j1939_tp_set_rxtimeout(session, 1250);
780 session->pkt.tx = session->pkt.tx_acked;
782 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
787 static int j1939_session_tx_dat(struct j1939_session *session)
789 struct j1939_priv *priv = session->priv;
798 se_skb = j1939_session_skb_get_by_offset(session, session->pkt.tx * 7);
806 if (session->skcb.addr.type != J1939_ETP &&
807 j1939_cb_is_broadcast(&session->skcb))
808 pkt_end = session->pkt.total;
810 pkt_end = session->pkt.last;
812 while (session->pkt.tx < pkt_end) {
813 dat[0] = session->pkt.tx - session->pkt.dpo + 1;
814 offset = (session->pkt.tx * 7) - skcb->offset;
822 __func__, session, skcb->offset, se_skb->len , session->pkt.tx);
833 ret = j1939_tp_tx_dat(session, dat, len + 1);
839 __func__, session, ret);
843 session->last_txcmd = 0xff;
845 session->pkt.tx++;
846 pdelay = j1939_cb_is_broadcast(&session->skcb) ? 50 :
849 if (session->pkt.tx < session->pkt.total && pdelay) {
850 j1939_tp_schedule_txtimer(session, pdelay);
856 j1939_tp_set_rxtimeout(session, 250);
867 static int j1939_xtp_txnext_transmiter(struct j1939_session *session)
869 struct j1939_priv *priv = session->priv;
872 if (!j1939_tp_im_transmitter(&session->skcb)) {
874 __func__, session);
878 switch (session->last_cmd) {
880 ret = j1939_session_tx_rts(session);
884 if (session->last_txcmd != J1939_ETP_CMD_DPO) {
885 ret = j1939_session_tx_dpo(session);
895 ret = j1939_session_tx_dat(session);
900 __func__, session, session->last_cmd);
906 static int j1939_session_tx_cts(struct j1939_session *session)
908 struct j1939_priv *priv = session->priv;
913 if (!j1939_sk_recv_match(priv, &session->skcb))
916 len = session->pkt.total - session->pkt.rx;
917 len = min3(len, session->pkt.block, j1939_tp_block ?: 255);
920 if (session->skcb.addr.type == J1939_ETP) {
921 pkt = session->pkt.rx + 1;
930 dat[2] = session->pkt.rx + 1;
933 if (dat[0] == session->last_txcmd)
937 ret = j1939_tp_tx_ctl(session, true, dat);
943 session->last_txcmd = dat[0];
944 j1939_tp_set_rxtimeout(session, 1250);
946 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
951 static int j1939_session_tx_eoma(struct j1939_session *session)
953 struct j1939_priv *priv = session->priv;
957 if (!j1939_sk_recv_match(priv, &session->skcb))
962 if (session->skcb.addr.type == J1939_ETP) {
964 dat[1] = session->total_message_size >> 0;
965 dat[2] = session->total_message_size >> 8;
966 dat[3] = session->total_message_size >> 16;
967 dat[4] = session->total_message_size >> 24;
970 dat[1] = session->total_message_size;
971 dat[2] = session->total_message_size >> 8;
972 dat[3] = session->pkt.total;
975 if (dat[0] == session->last_txcmd)
979 ret = j1939_tp_tx_ctl(session, true, dat);
983 session->last_txcmd = dat[0];
986 j1939_tp_set_rxtimeout(session, 1250);
988 netdev_dbg(session->priv->ndev, "%p: 0x%p\n", __func__, session);
993 static int j1939_xtp_txnext_receiver(struct j1939_session *session)
995 struct j1939_priv *priv = session->priv;
998 if (!j1939_tp_im_receiver(&session->skcb)) {
1000 __func__, session);
1004 switch (session->last_cmd) {
1007 ret = j1939_session_tx_cts(session);
1014 if ((session->skcb.addr.type == J1939_TP &&
1015 j1939_cb_is_broadcast(&session->skcb)))
1018 if (session->pkt.rx >= session->pkt.total) {
1019 ret = j1939_session_tx_eoma(session);
1020 } else if (session->pkt.rx >= session->pkt.last) {
1021 session->last_txcmd = 0;
1022 ret = j1939_session_tx_cts(session);
1027 __func__, session, session->last_cmd);
1033 static int j1939_simple_txnext(struct j1939_session *session)
1035 struct j1939_priv *priv = session->priv;
1036 struct sk_buff *se_skb = j1939_session_skb_get(session);
1051 j1939_tp_set_rxtimeout(session, J1939_SIMPLE_ECHO_TIMEOUT_MS);
1057 j1939_sk_errqueue(session, J1939_ERRQUEUE_SCHED);
1058 j1939_sk_queue_activate_next(session);
1069 static bool j1939_session_deactivate_locked(struct j1939_session *session)
1073 lockdep_assert_held(&session->priv->active_session_list_lock);
1075 if (session->state >= J1939_SESSION_ACTIVE &&
1076 session->state < J1939_SESSION_ACTIVE_MAX) {
1079 list_del_init(&session->active_session_list_entry);
1080 session->state = J1939_SESSION_DONE;
1081 j1939_session_put(session);
1087 static bool j1939_session_deactivate(struct j1939_session *session)
1089 struct j1939_priv *priv = session->priv;
1093 active = j1939_session_deactivate_locked(session);
1100 j1939_session_deactivate_activate_next(struct j1939_session *session)
1102 if (j1939_session_deactivate(session))
1103 j1939_sk_queue_activate_next(session);
1106 static void __j1939_session_cancel(struct j1939_session *session,
1109 struct j1939_priv *priv = session->priv;
1112 lockdep_assert_held(&session->priv->active_session_list_lock);
1114 session->err = j1939_xtp_abort_to_errno(priv, err);
1115 session->state = J1939_SESSION_WAITING_ABORT;
1117 if (!j1939_cb_is_broadcast(&session->skcb)) {
1118 j1939_xtp_tx_abort(priv, &session->skcb,
1119 !session->transmission,
1120 err, session->skcb.addr.pgn);
1123 if (session->sk)
1124 j1939_sk_send_loop_abort(session->sk, session->err);
1127 static void j1939_session_cancel(struct j1939_session *session,
1130 j1939_session_list_lock(session->priv);
1132 if (session->state >= J1939_SESSION_ACTIVE &&
1133 session->state < J1939_SESSION_WAITING_ABORT) {
1134 j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS);
1135 __j1939_session_cancel(session, err);
1138 j1939_session_list_unlock(session->priv);
1143 struct j1939_session *session =
1145 struct j1939_priv *priv = session->priv;
1148 if (session->skcb.addr.type == J1939_SIMPLE) {
1149 ret = j1939_simple_txnext(session);
1151 if (session->transmission)
1152 ret = j1939_xtp_txnext_transmiter(session);
1154 ret = j1939_xtp_txnext_receiver(session);
1160 if (session->tx_retry < J1939_XTP_TX_RETRY_LIMIT) {
1161 session->tx_retry++;
1162 j1939_tp_schedule_txtimer(session,
1166 __func__, session);
1167 session->err = -ENETUNREACH;
1168 j1939_session_rxtimer_cancel(session);
1169 j1939_session_deactivate_activate_next(session);
1181 j1939_session_cancel(session, J1939_XTP_ABORT_ECTS_TOO_BIG);
1184 session->tx_retry = 0;
1188 __func__, session, ret);
1189 if (session->skcb.addr.type != J1939_SIMPLE) {
1190 j1939_session_cancel(session, J1939_XTP_ABORT_OTHER);
1192 session->err = ret;
1193 j1939_session_rxtimer_cancel(session);
1194 j1939_session_deactivate_activate_next(session);
1198 j1939_session_put(session);
1203 static void j1939_session_completed(struct j1939_session *session)
1207 if (!session->transmission) {
1208 skb = j1939_session_skb_get(session);
1210 j1939_sk_recv(session->priv, skb);
1214 j1939_session_deactivate_activate_next(session);
1219 struct j1939_session *session = container_of(hrtimer,
1222 struct j1939_priv *priv = session->priv;
1224 if (session->state == J1939_SESSION_WAITING_ABORT) {
1225 netdev_alert(priv->ndev, "%s: 0x%p: abort rx timeout. Force session deactivation\n",
1226 __func__, session);
1228 j1939_session_deactivate_activate_next(session);
1230 } else if (session->skcb.addr.type == J1939_SIMPLE) {
1232 __func__, session);
1237 session->err = -ETIME;
1238 j1939_session_deactivate(session);
1240 j1939_session_list_lock(session->priv);
1241 if (session->state >= J1939_SESSION_ACTIVE &&
1242 session->state < J1939_SESSION_ACTIVE_MAX) {
1244 __func__, session);
1245 j1939_session_get(session);
1246 hrtimer_start(&session->rxtimer,
1249 __j1939_session_cancel(session, J1939_XTP_ABORT_TIMEOUT);
1251 j1939_session_list_unlock(session->priv);
1254 j1939_session_put(session);
1259 static bool j1939_xtp_rx_cmd_bad_pgn(struct j1939_session *session,
1264 struct j1939_priv *priv = session->priv;
1268 if (session->skcb.addr.pgn == pgn)
1304 netdev_warn(priv->ndev, "%s: 0x%p: CMD 0x%02x with PGN 0x%05x for running session with different PGN 0x%05x.\n",
1305 __func__, session, cmd, pgn, session->skcb.addr.pgn);
1316 struct j1939_session *session;
1319 session = j1939_session_get_by_addr(priv, &skcb->addr, reverse,
1321 if (!session)
1324 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1328 session, j1939_xtp_ctl_to_pgn(skb->data), abort,
1331 j1939_session_timers_cancel(session);
1332 session->err = j1939_xtp_abort_to_errno(priv, abort);
1333 if (session->sk)
1334 j1939_sk_send_loop_abort(session->sk, session->err);
1335 j1939_session_deactivate_activate_next(session);
1338 j1939_session_put(session);
1351 j1939_xtp_rx_eoma_one(struct j1939_session *session, struct sk_buff *skb)
1357 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1367 if (session->total_message_size != len) {
1368 netdev_warn_once(session->priv->ndev,
1370 __func__, session, session->total_message_size,
1374 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1376 session->pkt.tx_acked = session->pkt.total;
1377 j1939_session_timers_cancel(session);
1379 j1939_session_completed(session);
1387 struct j1939_session *session;
1389 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1391 if (!session)
1394 j1939_xtp_rx_eoma_one(session, skb);
1395 j1939_session_put(session);
1399 j1939_xtp_rx_cts_one(struct j1939_session *session, struct sk_buff *skb)
1407 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1410 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1412 if (session->last_cmd == dat[0]) {
1417 if (session->skcb.addr.type == J1939_ETP)
1424 else if (dat[1] > session->pkt.block /* 0xff for etp */)
1428 session->pkt.tx_acked = pkt - 1;
1429 j1939_session_skb_drop_old(session);
1430 session->pkt.last = session->pkt.tx_acked + dat[1];
1431 if (session->pkt.last > session->pkt.total)
1433 session->pkt.last = session->pkt.total;
1435 session->pkt.tx = session->pkt.tx_acked;
1437 session->last_cmd = dat[0];
1439 j1939_tp_set_rxtimeout(session, 1250);
1440 if (session->transmission) {
1441 if (session->pkt.tx_acked)
1442 j1939_sk_errqueue(session,
1444 j1939_session_txtimer_cancel(session);
1445 j1939_tp_schedule_txtimer(session, 0);
1449 j1939_tp_set_rxtimeout(session, 550);
1454 j1939_session_timers_cancel(session);
1455 j1939_session_cancel(session, err);
1462 struct j1939_session *session;
1464 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1466 if (!session)
1468 j1939_xtp_rx_cts_one(session, skb);
1469 j1939_session_put(session);
1475 struct j1939_session *session;
1478 session = kzalloc(sizeof(*session), gfp_any());
1479 if (!session)
1482 INIT_LIST_HEAD(&session->active_session_list_entry);
1483 INIT_LIST_HEAD(&session->sk_session_queue_entry);
1484 kref_init(&session->kref);
1487 session->priv = priv;
1488 session->total_message_size = size;
1489 session->state = J1939_SESSION_NEW;
1491 skb_queue_head_init(&session->skb_queue);
1492 skb_queue_tail(&session->skb_queue, skb);
1495 memcpy(&session->skcb, skcb, sizeof(session->skcb));
1497 hrtimer_init(&session->txtimer, CLOCK_MONOTONIC,
1499 session->txtimer.function = j1939_tp_txtimer;
1500 hrtimer_init(&session->rxtimer, CLOCK_MONOTONIC,
1502 session->rxtimer.function = j1939_tp_rxtimer;
1505 __func__, session, skcb->addr.sa, skcb->addr.da);
1507 return session;
1517 struct j1939_session *session;
1530 session = j1939_session_new(priv, skb, size);
1531 if (!session) {
1539 return session;
1542 int j1939_session_activate(struct j1939_session *session)
1544 struct j1939_priv *priv = session->priv;
1549 if (session->skcb.addr.type != J1939_SIMPLE)
1552 &session->skcb.addr, false,
1553 session->transmission);
1558 WARN_ON_ONCE(session->state != J1939_SESSION_NEW);
1559 list_add_tail(&session->active_session_list_entry,
1561 j1939_session_get(session);
1562 session->state = J1939_SESSION_ACTIVE;
1564 netdev_dbg(session->priv->ndev, "%s: 0x%p\n",
1565 __func__, session);
1578 struct j1939_session *session;
1615 session = j1939_session_fresh_new(priv, len, &skcb);
1616 if (!session) {
1623 session->pkt.total = (len + 6) / 7;
1624 session->pkt.block = 0xff;
1626 if (dat[3] != session->pkt.total)
1628 __func__, session, session->pkt.total,
1630 session->pkt.total = dat[3];
1631 session->pkt.block = min(dat[3], dat[4]);
1634 session->pkt.rx = 0;
1635 session->pkt.tx = 0;
1637 WARN_ON_ONCE(j1939_session_activate(session));
1639 return session;
1642 static int j1939_xtp_rx_rts_session_active(struct j1939_session *session,
1646 struct j1939_priv *priv = session->priv;
1648 if (!session->transmission) {
1649 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1652 /* RTS on active session */
1653 j1939_session_timers_cancel(session);
1654 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1657 if (session->last_cmd != 0) {
1660 __func__, session, skcb->addr.sa, skcb->addr.da,
1661 session->last_cmd);
1663 j1939_session_timers_cancel(session);
1664 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1669 if (session->skcb.addr.sa != skcb->addr.sa ||
1670 session->skcb.addr.da != skcb->addr.da)
1671 netdev_warn(priv->ndev, "%s: 0x%p: session->skcb.addr.sa=0x%02x skcb->addr.sa=0x%02x session->skcb.addr.da=0x%02x skcb->addr.da=0x%02x\n",
1672 __func__, session,
1673 session->skcb.addr.sa, skcb->addr.sa,
1674 session->skcb.addr.da, skcb->addr.da);
1679 session->skcb.addr.sa = skcb->addr.sa;
1680 session->skcb.addr.da = skcb->addr.da;
1682 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1691 struct j1939_session *session;
1694 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1697 if (!session) {
1700 * we received our own RTS. A session has already been
1706 * receiver session.
1708 * The reasons the session is already destroyed might
1710 * - user space closed socket was and the session was
1712 * - session was aborted due to external abort message
1716 session = j1939_xtp_rx_rts_session_new(priv, skb);
1717 if (!session) {
1719 netdev_info(priv->ndev, "%s: failed to create TP BAM session\n",
1724 if (j1939_xtp_rx_rts_session_active(session, skb)) {
1725 j1939_session_put(session);
1729 session->last_cmd = cmd;
1732 if (!session->transmission)
1733 j1939_tp_set_rxtimeout(session, 750);
1735 if (!session->transmission) {
1736 j1939_session_txtimer_cancel(session);
1737 j1939_tp_schedule_txtimer(session, 0);
1739 j1939_tp_set_rxtimeout(session, 1250);
1742 j1939_session_put(session);
1745 static void j1939_xtp_rx_dpo_one(struct j1939_session *session,
1750 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1753 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1756 session->pkt.dpo = j1939_etp_ctl_to_packet(skb->data);
1757 session->last_cmd = dat[0];
1758 j1939_tp_set_rxtimeout(session, 750);
1765 struct j1939_session *session;
1767 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1769 if (!session) {
1775 j1939_xtp_rx_dpo_one(session, skb);
1776 j1939_session_put(session);
1779 static void j1939_xtp_rx_dat_one(struct j1939_session *session,
1783 struct j1939_priv *priv = session->priv;
1803 switch (session->last_cmd) {
1817 session, session->last_cmd);
1821 packet = (dat[0] - 1 + session->pkt.dpo);
1822 if (packet > session->pkt.total ||
1823 (session->pkt.rx + 1) > session->pkt.total) {
1825 __func__, session);
1829 se_skb = j1939_session_skb_get_by_offset(session, packet * 7);
1832 session);
1843 __func__, session, nbytes, skb->len);
1848 if (!session->transmission) {
1857 __func__, session,
1862 if (packet == session->pkt.rx)
1863 session->pkt.rx++;
1866 j1939_cb_is_broadcast(&session->skcb)) {
1867 if (session->pkt.rx >= session->pkt.total)
1873 if (session->pkt.rx >= session->pkt.last)
1878 j1939_session_timers_cancel(session);
1879 j1939_session_completed(session);
1881 if (!session->transmission)
1882 j1939_tp_set_rxtimeout(session, 750);
1884 j1939_tp_set_rxtimeout(session, 1250);
1885 if (!session->transmission)
1886 j1939_tp_schedule_txtimer(session, 0);
1888 j1939_tp_set_rxtimeout(session, 750);
1890 session->last_cmd = 0xff;
1892 j1939_session_put(session);
1898 j1939_session_timers_cancel(session);
1899 j1939_session_cancel(session, abort);
1900 j1939_session_put(session);
1906 struct j1939_session *session;
1911 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1913 if (!session)
1917 j1939_xtp_rx_dat_one(session, skb);
1921 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1923 if (!session)
1927 j1939_xtp_rx_dat_one(session, skb);
1931 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1933 if (session)
1934 j1939_xtp_rx_dat_one(session, skb);
1943 struct j1939_session *session;
1980 /* prepare new session */
1981 session = j1939_session_new(priv, skb, size);
1982 if (!session)
1987 session->sk = skb->sk;
1988 session->transmission = true;
1989 session->pkt.total = (size + 6) / 7;
1990 session->pkt.block = skcb->addr.type == J1939_ETP ? 255 :
1991 min(j1939_tp_block ?: 255, session->pkt.total);
1993 if (j1939_cb_is_broadcast(&session->skcb))
1995 session->pkt.last = session->pkt.total;
1997 skcb->tskey = session->sk->sk_tskey++;
1998 session->tskey = skcb->tskey;
2000 return session;
2131 struct j1939_session *session;
2141 session = j1939_session_get_simple(priv, skb);
2143 if (!session) {
2150 j1939_session_timers_cancel(session);
2151 j1939_session_deactivate(session);
2152 j1939_session_put(session);
2157 struct j1939_session *session, *saved;
2161 list_for_each_entry_safe(session, saved,
2164 if (!sk || sk == session->sk) {
2165 if (hrtimer_try_to_cancel(&session->txtimer) == 1)
2166 j1939_session_put(session);
2167 if (hrtimer_try_to_cancel(&session->rxtimer) == 1)
2168 j1939_session_put(session);
2170 session->err = ESHUTDOWN;
2171 j1939_session_deactivate_locked(session);