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->transmission) {
266 if (session->err)
267 j1939_sk_errqueue(session, J1939_ERRQUEUE_TX_ABORT);
269 j1939_sk_errqueue(session, J1939_ERRQUEUE_TX_ACK);
270 } else if (session->err) {
271 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
274 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
276 WARN_ON_ONCE(!list_empty(&session->sk_session_queue_entry));
277 WARN_ON_ONCE(!list_empty(&session->active_session_list_entry));
279 while ((skb = skb_dequeue(&session->skb_queue)) != NULL) {
284 __j1939_session_drop(session);
285 j1939_priv_put(session->priv);
286 kfree(session);
291 struct j1939_session *session = container_of(kref, struct j1939_session,
294 j1939_session_destroy(session);
297 void j1939_session_put(struct j1939_session *session)
299 kref_put(&session->kref, __j1939_session_release);
302 static void j1939_session_txtimer_cancel(struct j1939_session *session)
304 if (hrtimer_cancel(&session->txtimer))
305 j1939_session_put(session);
308 static void j1939_session_rxtimer_cancel(struct j1939_session *session)
310 if (hrtimer_cancel(&session->rxtimer))
311 j1939_session_put(session);
314 void j1939_session_timers_cancel(struct j1939_session *session)
316 j1939_session_txtimer_cancel(session);
317 j1939_session_rxtimer_cancel(session);
325 static void j1939_session_skb_drop_old(struct j1939_session *session)
332 if (skb_queue_len(&session->skb_queue) < 2)
335 offset_start = session->pkt.tx_acked * 7;
337 spin_lock_irqsave(&session->skb_queue.lock, flags);
338 do_skb = skb_peek(&session->skb_queue);
342 __skb_unlink(do_skb, &session->skb_queue);
345 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
349 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
353 void j1939_session_skb_queue(struct j1939_session *session,
357 struct j1939_priv *priv = session->priv;
368 skb_queue_tail(&session->skb_queue, skb);
372 sk_buff *j1939_session_skb_get_by_offset(struct j1939_session *session,
375 struct j1939_priv *priv = session->priv;
381 spin_lock_irqsave(&session->skb_queue.lock, flags);
382 skb_queue_walk(&session->skb_queue, do_skb) {
395 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
399 __func__, session, offset_start,
400 skb_queue_len(&session->skb_queue));
405 static struct sk_buff *j1939_session_skb_get(struct j1939_session *session)
409 offset_start = session->pkt.dpo * 7;
410 return j1939_session_skb_get_by_offset(session, offset_start);
468 /* find existing session:
519 struct j1939_session *session;
523 list_for_each_entry(session, root, active_session_list_entry) {
524 j1939_session_get(session);
525 if (j1939_session_match(&session->skcb.addr, addr, reverse) &&
526 session->transmission == transmitter)
527 return session;
528 j1939_session_put(session);
539 struct j1939_session *session;
543 list_for_each_entry(session, &priv->active_session_list,
545 j1939_session_get(session);
546 if (session->skcb.addr.type == J1939_SIMPLE &&
547 session->tskey == skcb->tskey && session->sk == skb->sk)
548 return session;
549 j1939_session_put(session);
560 struct j1939_session *session;
563 session = j1939_session_get_by_addr_locked(priv,
568 return session;
632 static int j1939_tp_tx_dat(struct j1939_session *session,
635 struct j1939_priv *priv = session->priv;
638 skb = j1939_tp_tx_dat_new(priv, &session->skcb,
673 static inline int j1939_tp_tx_ctl(struct j1939_session *session,
676 struct j1939_priv *priv = session->priv;
678 return j1939_xtp_do_tx_ctl(priv, &session->skcb,
680 session->skcb.addr.pgn, dat);
700 void j1939_tp_schedule_txtimer(struct j1939_session *session, int msec)
702 j1939_session_get(session);
703 hrtimer_start(&session->txtimer, ms_to_ktime(msec),
707 static inline void j1939_tp_set_rxtimeout(struct j1939_session *session,
710 j1939_session_rxtimer_cancel(session);
711 j1939_session_get(session);
712 hrtimer_start(&session->rxtimer, ms_to_ktime(msec),
716 static int j1939_session_tx_rts(struct j1939_session *session)
723 dat[1] = (session->total_message_size >> 0);
724 dat[2] = (session->total_message_size >> 8);
725 dat[3] = session->pkt.total;
727 if (session->skcb.addr.type == J1939_ETP) {
729 dat[1] = (session->total_message_size >> 0);
730 dat[2] = (session->total_message_size >> 8);
731 dat[3] = (session->total_message_size >> 16);
732 dat[4] = (session->total_message_size >> 24);
733 } else if (j1939_cb_is_broadcast(&session->skcb)) {
736 session->pkt.tx = 0;
742 if (dat[0] == session->last_txcmd)
746 ret = j1939_tp_tx_ctl(session, false, dat);
750 session->last_txcmd = dat[0];
752 j1939_tp_schedule_txtimer(session, 50);
753 j1939_tp_set_rxtimeout(session, 250);
755 j1939_tp_set_rxtimeout(session, 1250);
758 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
763 static int j1939_session_tx_dpo(struct j1939_session *session)
772 session->pkt.dpo = session->pkt.tx_acked;
773 pkt = session->pkt.dpo;
774 dat[1] = session->pkt.last - session->pkt.tx_acked;
779 ret = j1939_tp_tx_ctl(session, false, dat);
783 session->last_txcmd = dat[0];
784 j1939_tp_set_rxtimeout(session, 1250);
785 session->pkt.tx = session->pkt.tx_acked;
787 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
792 static int j1939_session_tx_dat(struct j1939_session *session)
794 struct j1939_priv *priv = session->priv;
803 se_skb = j1939_session_skb_get_by_offset(session, session->pkt.tx * 7);
811 if (session->skcb.addr.type != J1939_ETP &&
812 j1939_cb_is_broadcast(&session->skcb))
813 pkt_end = session->pkt.total;
815 pkt_end = session->pkt.last;
817 while (session->pkt.tx < pkt_end) {
818 dat[0] = session->pkt.tx - session->pkt.dpo + 1;
819 offset = (session->pkt.tx * 7) - se_skcb->offset;
827 __func__, session, se_skcb->offset,
828 se_skb->len , session->pkt.tx);
839 ret = j1939_tp_tx_dat(session, dat, len + 1);
845 __func__, session, ret);
849 session->last_txcmd = 0xff;
851 session->pkt.tx++;
852 pdelay = j1939_cb_is_broadcast(&session->skcb) ? 50 :
855 if (session->pkt.tx < session->pkt.total && pdelay) {
856 j1939_tp_schedule_txtimer(session, pdelay);
862 j1939_tp_set_rxtimeout(session, 250);
873 static int j1939_xtp_txnext_transmiter(struct j1939_session *session)
875 struct j1939_priv *priv = session->priv;
878 if (!j1939_tp_im_transmitter(&session->skcb)) {
880 __func__, session);
884 switch (session->last_cmd) {
886 ret = j1939_session_tx_rts(session);
890 if (session->last_txcmd != J1939_ETP_CMD_DPO) {
891 ret = j1939_session_tx_dpo(session);
901 ret = j1939_session_tx_dat(session);
906 __func__, session, session->last_cmd);
912 static int j1939_session_tx_cts(struct j1939_session *session)
914 struct j1939_priv *priv = session->priv;
919 if (!j1939_sk_recv_match(priv, &session->skcb))
922 len = session->pkt.total - session->pkt.rx;
923 len = min3(len, session->pkt.block, j1939_tp_block ?: 255);
926 if (session->skcb.addr.type == J1939_ETP) {
927 pkt = session->pkt.rx + 1;
936 dat[2] = session->pkt.rx + 1;
939 if (dat[0] == session->last_txcmd)
943 ret = j1939_tp_tx_ctl(session, true, dat);
949 session->last_txcmd = dat[0];
950 j1939_tp_set_rxtimeout(session, 1250);
952 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
957 static int j1939_session_tx_eoma(struct j1939_session *session)
959 struct j1939_priv *priv = session->priv;
963 if (!j1939_sk_recv_match(priv, &session->skcb))
968 if (session->skcb.addr.type == J1939_ETP) {
970 dat[1] = session->total_message_size >> 0;
971 dat[2] = session->total_message_size >> 8;
972 dat[3] = session->total_message_size >> 16;
973 dat[4] = session->total_message_size >> 24;
976 dat[1] = session->total_message_size;
977 dat[2] = session->total_message_size >> 8;
978 dat[3] = session->pkt.total;
981 if (dat[0] == session->last_txcmd)
985 ret = j1939_tp_tx_ctl(session, true, dat);
989 session->last_txcmd = dat[0];
992 j1939_tp_set_rxtimeout(session, 1250);
994 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
999 static int j1939_xtp_txnext_receiver(struct j1939_session *session)
1001 struct j1939_priv *priv = session->priv;
1004 if (!j1939_tp_im_receiver(&session->skcb)) {
1006 __func__, session);
1010 switch (session->last_cmd) {
1013 ret = j1939_session_tx_cts(session);
1020 if ((session->skcb.addr.type == J1939_TP &&
1021 j1939_cb_is_broadcast(&session->skcb)))
1024 if (session->pkt.rx >= session->pkt.total) {
1025 ret = j1939_session_tx_eoma(session);
1026 } else if (session->pkt.rx >= session->pkt.last) {
1027 session->last_txcmd = 0;
1028 ret = j1939_session_tx_cts(session);
1033 __func__, session, session->last_cmd);
1039 static int j1939_simple_txnext(struct j1939_session *session)
1041 struct j1939_priv *priv = session->priv;
1042 struct sk_buff *se_skb = j1939_session_skb_get(session);
1057 j1939_tp_set_rxtimeout(session, J1939_SIMPLE_ECHO_TIMEOUT_MS);
1063 j1939_sk_errqueue(session, J1939_ERRQUEUE_TX_SCHED);
1064 j1939_sk_queue_activate_next(session);
1075 static bool j1939_session_deactivate_locked(struct j1939_session *session)
1079 lockdep_assert_held(&session->priv->active_session_list_lock);
1081 if (session->state >= J1939_SESSION_ACTIVE &&
1082 session->state < J1939_SESSION_ACTIVE_MAX) {
1085 list_del_init(&session->active_session_list_entry);
1086 session->state = J1939_SESSION_DONE;
1087 j1939_session_put(session);
1093 static bool j1939_session_deactivate(struct j1939_session *session)
1095 struct j1939_priv *priv = session->priv;
1099 active = j1939_session_deactivate_locked(session);
1106 j1939_session_deactivate_activate_next(struct j1939_session *session)
1108 if (j1939_session_deactivate(session))
1109 j1939_sk_queue_activate_next(session);
1112 static void __j1939_session_cancel(struct j1939_session *session,
1115 struct j1939_priv *priv = session->priv;
1118 lockdep_assert_held(&session->priv->active_session_list_lock);
1120 session->err = j1939_xtp_abort_to_errno(priv, err);
1121 session->state = J1939_SESSION_WAITING_ABORT;
1123 if (!j1939_cb_is_broadcast(&session->skcb)) {
1124 j1939_xtp_tx_abort(priv, &session->skcb,
1125 !session->transmission,
1126 err, session->skcb.addr.pgn);
1129 if (session->sk)
1130 j1939_sk_send_loop_abort(session->sk, session->err);
1133 static void j1939_session_cancel(struct j1939_session *session,
1136 j1939_session_list_lock(session->priv);
1138 if (session->state >= J1939_SESSION_ACTIVE &&
1139 session->state < J1939_SESSION_WAITING_ABORT) {
1140 j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS);
1141 __j1939_session_cancel(session, err);
1144 j1939_session_list_unlock(session->priv);
1146 if (!session->sk)
1147 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1152 struct j1939_session *session =
1154 struct j1939_priv *priv = session->priv;
1157 if (session->skcb.addr.type == J1939_SIMPLE) {
1158 ret = j1939_simple_txnext(session);
1160 if (session->transmission)
1161 ret = j1939_xtp_txnext_transmiter(session);
1163 ret = j1939_xtp_txnext_receiver(session);
1169 if (session->tx_retry < J1939_XTP_TX_RETRY_LIMIT) {
1170 session->tx_retry++;
1171 j1939_tp_schedule_txtimer(session,
1175 __func__, session);
1176 session->err = -ENETUNREACH;
1177 j1939_session_rxtimer_cancel(session);
1178 j1939_session_deactivate_activate_next(session);
1190 j1939_session_cancel(session, J1939_XTP_ABORT_ECTS_TOO_BIG);
1193 session->tx_retry = 0;
1197 __func__, session, ret);
1198 if (session->skcb.addr.type != J1939_SIMPLE) {
1199 j1939_session_cancel(session, J1939_XTP_ABORT_OTHER);
1201 session->err = ret;
1202 j1939_session_rxtimer_cancel(session);
1203 j1939_session_deactivate_activate_next(session);
1207 j1939_session_put(session);
1212 static void j1939_session_completed(struct j1939_session *session)
1216 if (!session->transmission) {
1217 se_skb = j1939_session_skb_get(session);
1219 j1939_sk_recv(session->priv, se_skb);
1223 j1939_session_deactivate_activate_next(session);
1228 struct j1939_session *session = container_of(hrtimer,
1231 struct j1939_priv *priv = session->priv;
1233 if (session->state == J1939_SESSION_WAITING_ABORT) {
1234 netdev_alert(priv->ndev, "%s: 0x%p: abort rx timeout. Force session deactivation\n",
1235 __func__, session);
1237 j1939_session_deactivate_activate_next(session);
1239 } else if (session->skcb.addr.type == J1939_SIMPLE) {
1241 __func__, session);
1246 session->err = -ETIME;
1247 j1939_session_deactivate(session);
1249 j1939_session_list_lock(session->priv);
1250 if (session->state >= J1939_SESSION_ACTIVE &&
1251 session->state < J1939_SESSION_ACTIVE_MAX) {
1253 __func__, session);
1254 j1939_session_get(session);
1255 hrtimer_start(&session->rxtimer,
1258 __j1939_session_cancel(session, J1939_XTP_ABORT_TIMEOUT);
1260 j1939_session_list_unlock(session->priv);
1262 if (!session->sk)
1263 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1266 j1939_session_put(session);
1271 static bool j1939_xtp_rx_cmd_bad_pgn(struct j1939_session *session,
1276 struct j1939_priv *priv = session->priv;
1280 if (session->skcb.addr.pgn == pgn)
1319 netdev_warn(priv->ndev, "%s: 0x%p: CMD 0x%02x with PGN 0x%05x for running session with different PGN 0x%05x.\n",
1320 __func__, session, cmd, pgn, session->skcb.addr.pgn);
1331 struct j1939_session *session;
1334 session = j1939_session_get_by_addr(priv, &skcb->addr, reverse,
1336 if (!session)
1339 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1343 session, j1939_xtp_ctl_to_pgn(skb->data), abort,
1346 j1939_session_timers_cancel(session);
1347 session->err = j1939_xtp_abort_to_errno(priv, abort);
1348 if (session->sk)
1349 j1939_sk_send_loop_abort(session->sk, session->err);
1351 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1352 j1939_session_deactivate_activate_next(session);
1355 j1939_session_put(session);
1368 j1939_xtp_rx_eoma_one(struct j1939_session *session, struct sk_buff *skb)
1374 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1384 if (session->total_message_size != len) {
1385 netdev_warn_once(session->priv->ndev,
1387 __func__, session, session->total_message_size,
1391 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1393 session->pkt.tx_acked = session->pkt.total;
1394 j1939_session_timers_cancel(session);
1396 j1939_session_completed(session);
1404 struct j1939_session *session;
1406 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1408 if (!session)
1411 j1939_xtp_rx_eoma_one(session, skb);
1412 j1939_session_put(session);
1416 j1939_xtp_rx_cts_one(struct j1939_session *session, struct sk_buff *skb)
1424 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1427 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1429 if (session->last_cmd == dat[0]) {
1434 if (session->skcb.addr.type == J1939_ETP)
1441 else if (dat[1] > session->pkt.block /* 0xff for etp */)
1445 session->pkt.tx_acked = pkt - 1;
1446 j1939_session_skb_drop_old(session);
1447 session->pkt.last = session->pkt.tx_acked + dat[1];
1448 if (session->pkt.last > session->pkt.total)
1450 session->pkt.last = session->pkt.total;
1452 session->pkt.tx = session->pkt.tx_acked;
1454 session->last_cmd = dat[0];
1456 j1939_tp_set_rxtimeout(session, 1250);
1457 if (session->transmission) {
1458 if (session->pkt.tx_acked)
1459 j1939_sk_errqueue(session,
1461 j1939_session_txtimer_cancel(session);
1462 j1939_tp_schedule_txtimer(session, 0);
1466 j1939_tp_set_rxtimeout(session, 550);
1471 j1939_session_timers_cancel(session);
1472 j1939_session_cancel(session, err);
1479 struct j1939_session *session;
1481 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1483 if (!session)
1485 j1939_xtp_rx_cts_one(session, skb);
1486 j1939_session_put(session);
1492 struct j1939_session *session;
1495 session = kzalloc(sizeof(*session), gfp_any());
1496 if (!session)
1499 INIT_LIST_HEAD(&session->active_session_list_entry);
1500 INIT_LIST_HEAD(&session->sk_session_queue_entry);
1501 kref_init(&session->kref);
1504 session->priv = priv;
1505 session->total_message_size = size;
1506 session->state = J1939_SESSION_NEW;
1508 skb_queue_head_init(&session->skb_queue);
1509 skb_queue_tail(&session->skb_queue, skb_get(skb));
1512 memcpy(&session->skcb, skcb, sizeof(session->skcb));
1514 hrtimer_setup(&session->txtimer, j1939_tp_txtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT);
1515 hrtimer_setup(&session->rxtimer, j1939_tp_rxtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT);
1518 __func__, session, skcb->addr.sa, skcb->addr.da);
1520 return session;
1530 struct j1939_session *session;
1543 session = j1939_session_new(priv, skb, size);
1544 if (!session) {
1552 return session;
1555 int j1939_session_activate(struct j1939_session *session)
1557 struct j1939_priv *priv = session->priv;
1562 if (session->skcb.addr.type != J1939_SIMPLE)
1565 &session->skcb.addr, false,
1566 session->transmission);
1571 WARN_ON_ONCE(session->state != J1939_SESSION_NEW);
1572 list_add_tail(&session->active_session_list_entry,
1574 j1939_session_get(session);
1575 session->state = J1939_SESSION_ACTIVE;
1577 netdev_dbg(session->priv->ndev, "%s: 0x%p\n",
1578 __func__, session);
1591 struct j1939_session *session;
1628 session = j1939_session_fresh_new(priv, len, &skcb);
1629 if (!session) {
1636 session->pkt.total = (len + 6) / 7;
1637 session->pkt.block = 0xff;
1639 if (dat[3] != session->pkt.total)
1641 __func__, session, session->pkt.total,
1643 session->pkt.total = dat[3];
1644 session->pkt.block = min(dat[3], dat[4]);
1647 session->pkt.rx = 0;
1648 session->pkt.tx = 0;
1650 session->tskey = priv->rx_tskey++;
1651 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_RTS);
1653 ret = j1939_session_activate(session);
1657 * - A time lapse occurred, and a new session was initiated
1664 netdev_alert(priv->ndev, "%s: 0x%p: concurrent session with same addr (%02x %02x) is already active.\n",
1665 __func__, session, skcb.addr.sa, skcb.addr.da);
1666 j1939_session_put(session);
1670 return session;
1673 static int j1939_xtp_rx_rts_session_active(struct j1939_session *session,
1677 struct j1939_priv *priv = session->priv;
1679 if (!session->transmission) {
1680 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1683 /* RTS on active session */
1684 j1939_session_timers_cancel(session);
1685 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1688 if (session->last_cmd != 0) {
1691 __func__, session, skcb->addr.sa, skcb->addr.da,
1692 session->last_cmd);
1694 j1939_session_timers_cancel(session);
1695 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1696 if (session->transmission)
1697 j1939_session_deactivate_activate_next(session);
1702 if (session->skcb.addr.sa != skcb->addr.sa ||
1703 session->skcb.addr.da != skcb->addr.da)
1704 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",
1705 __func__, session,
1706 session->skcb.addr.sa, skcb->addr.sa,
1707 session->skcb.addr.da, skcb->addr.da);
1712 session->skcb.addr.sa = skcb->addr.sa;
1713 session->skcb.addr.da = skcb->addr.da;
1715 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1724 struct j1939_session *session;
1727 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1730 if (!session) {
1733 * we received our own RTS. A session has already been
1739 * receiver session.
1741 * The reasons the session is already destroyed might
1743 * - user space closed socket was and the session was
1745 * - session was aborted due to external abort message
1749 session = j1939_xtp_rx_rts_session_new(priv, skb);
1750 if (!session) {
1752 netdev_info(priv->ndev, "%s: failed to create TP BAM session\n",
1757 if (j1939_xtp_rx_rts_session_active(session, skb)) {
1758 j1939_session_put(session);
1762 session->last_cmd = cmd;
1765 if (!session->transmission)
1766 j1939_tp_set_rxtimeout(session, 750);
1768 if (!session->transmission) {
1769 j1939_session_txtimer_cancel(session);
1770 j1939_tp_schedule_txtimer(session, 0);
1772 j1939_tp_set_rxtimeout(session, 1250);
1775 j1939_session_put(session);
1778 static void j1939_xtp_rx_dpo_one(struct j1939_session *session,
1783 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1786 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1789 session->pkt.dpo = j1939_etp_ctl_to_packet(skb->data);
1790 session->last_cmd = dat[0];
1791 j1939_tp_set_rxtimeout(session, 750);
1793 if (!session->transmission)
1794 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_DPO);
1801 struct j1939_session *session;
1803 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1805 if (!session) {
1811 j1939_xtp_rx_dpo_one(session, skb);
1812 j1939_session_put(session);
1815 static void j1939_xtp_rx_dat_one(struct j1939_session *session,
1819 struct j1939_priv *priv = session->priv;
1839 switch (session->last_cmd) {
1854 session, session->last_cmd);
1858 packet = (dat[0] - 1 + session->pkt.dpo);
1859 if (packet > session->pkt.total ||
1860 (session->pkt.rx + 1) > session->pkt.total) {
1862 __func__, session);
1866 se_skb = j1939_session_skb_get_by_offset(session, packet * 7);
1869 session);
1880 __func__, session, nbytes, skb->len);
1885 if (!session->transmission) {
1894 __func__, session,
1899 if (packet == session->pkt.rx)
1900 session->pkt.rx++;
1903 j1939_cb_is_broadcast(&session->skcb)) {
1904 if (session->pkt.rx >= session->pkt.total)
1910 if (session->pkt.rx >= session->pkt.last)
1915 j1939_session_timers_cancel(session);
1916 j1939_session_completed(session);
1918 if (!session->transmission)
1919 j1939_tp_set_rxtimeout(session, 750);
1921 j1939_tp_set_rxtimeout(session, 1250);
1922 if (!session->transmission)
1923 j1939_tp_schedule_txtimer(session, 0);
1925 j1939_tp_set_rxtimeout(session, 750);
1927 session->last_cmd = 0xff;
1929 j1939_session_put(session);
1935 j1939_session_timers_cancel(session);
1936 j1939_session_cancel(session, abort);
1937 j1939_session_put(session);
1943 struct j1939_session *session;
1948 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1950 if (!session)
1954 j1939_xtp_rx_dat_one(session, skb);
1958 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1960 if (!session)
1964 j1939_xtp_rx_dat_one(session, skb);
1968 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1970 if (session)
1971 j1939_xtp_rx_dat_one(session, skb);
1980 struct j1939_session *session;
2017 /* prepare new session */
2018 session = j1939_session_new(priv, skb, size);
2019 if (!session)
2024 session->sk = skb->sk;
2025 session->transmission = true;
2026 session->pkt.total = (size + 6) / 7;
2027 session->pkt.block = skcb->addr.type == J1939_ETP ? 255 :
2028 min(j1939_tp_block ?: 255, session->pkt.total);
2030 if (j1939_cb_is_broadcast(&session->skcb))
2032 session->pkt.last = session->pkt.total;
2034 skcb->tskey = atomic_inc_return(&session->sk->sk_tskey) - 1;
2035 session->tskey = skcb->tskey;
2037 return session;
2168 struct j1939_session *session;
2178 session = j1939_session_get_simple(priv, skb);
2180 if (!session) {
2187 j1939_session_timers_cancel(session);
2188 j1939_session_deactivate(session);
2189 j1939_session_put(session);
2194 struct j1939_session *session, *saved;
2198 list_for_each_entry_safe(session, saved,
2201 if (!sk || sk == session->sk) {
2202 if (hrtimer_try_to_cancel(&session->txtimer) == 1)
2203 j1939_session_put(session);
2204 if (hrtimer_try_to_cancel(&session->rxtimer) == 1)
2205 j1939_session_put(session);
2207 session->err = ESHUTDOWN;
2208 j1939_session_deactivate_locked(session);