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) {
394 spin_unlock_irqrestore(&session->skb_queue.lock, flags);
398 __func__, session, offset_start,
399 skb_queue_len(&session->skb_queue));
404 static struct sk_buff *j1939_session_skb_get(struct j1939_session *session)
408 offset_start = session->pkt.dpo * 7;
409 return j1939_session_skb_get_by_offset(session, offset_start);
467 /* find existing session:
518 struct j1939_session *session;
522 list_for_each_entry(session, root, active_session_list_entry) {
523 j1939_session_get(session);
524 if (j1939_session_match(&session->skcb.addr, addr, reverse) &&
525 session->transmission == transmitter)
526 return session;
527 j1939_session_put(session);
538 struct j1939_session *session;
542 list_for_each_entry(session, &priv->active_session_list,
544 j1939_session_get(session);
545 if (session->skcb.addr.type == J1939_SIMPLE &&
546 session->tskey == skcb->tskey && session->sk == skb->sk)
547 return session;
548 j1939_session_put(session);
559 struct j1939_session *session;
562 session = j1939_session_get_by_addr_locked(priv,
567 return session;
631 static int j1939_tp_tx_dat(struct j1939_session *session,
634 struct j1939_priv *priv = session->priv;
637 skb = j1939_tp_tx_dat_new(priv, &session->skcb,
672 static inline int j1939_tp_tx_ctl(struct j1939_session *session,
675 struct j1939_priv *priv = session->priv;
677 return j1939_xtp_do_tx_ctl(priv, &session->skcb,
679 session->skcb.addr.pgn, dat);
699 void j1939_tp_schedule_txtimer(struct j1939_session *session, int msec)
701 j1939_session_get(session);
702 hrtimer_start(&session->txtimer, ms_to_ktime(msec),
706 static inline void j1939_tp_set_rxtimeout(struct j1939_session *session,
709 j1939_session_rxtimer_cancel(session);
710 j1939_session_get(session);
711 hrtimer_start(&session->rxtimer, ms_to_ktime(msec),
715 static int j1939_session_tx_rts(struct j1939_session *session)
722 dat[1] = (session->total_message_size >> 0);
723 dat[2] = (session->total_message_size >> 8);
724 dat[3] = session->pkt.total;
726 if (session->skcb.addr.type == J1939_ETP) {
728 dat[1] = (session->total_message_size >> 0);
729 dat[2] = (session->total_message_size >> 8);
730 dat[3] = (session->total_message_size >> 16);
731 dat[4] = (session->total_message_size >> 24);
732 } else if (j1939_cb_is_broadcast(&session->skcb)) {
735 session->pkt.tx = 0;
741 if (dat[0] == session->last_txcmd)
745 ret = j1939_tp_tx_ctl(session, false, dat);
749 session->last_txcmd = dat[0];
751 j1939_tp_schedule_txtimer(session, 50);
752 j1939_tp_set_rxtimeout(session, 250);
754 j1939_tp_set_rxtimeout(session, 1250);
757 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
762 static int j1939_session_tx_dpo(struct j1939_session *session)
771 session->pkt.dpo = session->pkt.tx_acked;
772 pkt = session->pkt.dpo;
773 dat[1] = session->pkt.last - session->pkt.tx_acked;
778 ret = j1939_tp_tx_ctl(session, false, dat);
782 session->last_txcmd = dat[0];
783 j1939_tp_set_rxtimeout(session, 1250);
784 session->pkt.tx = session->pkt.tx_acked;
786 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
791 static int j1939_session_tx_dat(struct j1939_session *session)
793 struct j1939_priv *priv = session->priv;
802 se_skb = j1939_session_skb_get_by_offset(session, session->pkt.tx * 7);
810 if (session->skcb.addr.type != J1939_ETP &&
811 j1939_cb_is_broadcast(&session->skcb))
812 pkt_end = session->pkt.total;
814 pkt_end = session->pkt.last;
816 while (session->pkt.tx < pkt_end) {
817 dat[0] = session->pkt.tx - session->pkt.dpo + 1;
818 offset = (session->pkt.tx * 7) - se_skcb->offset;
826 __func__, session, se_skcb->offset,
827 se_skb->len , session->pkt.tx);
838 ret = j1939_tp_tx_dat(session, dat, len + 1);
844 __func__, session, ret);
848 session->last_txcmd = 0xff;
850 session->pkt.tx++;
851 pdelay = j1939_cb_is_broadcast(&session->skcb) ? 50 :
854 if (session->pkt.tx < session->pkt.total && pdelay) {
855 j1939_tp_schedule_txtimer(session, pdelay);
861 j1939_tp_set_rxtimeout(session, 250);
872 static int j1939_xtp_txnext_transmiter(struct j1939_session *session)
874 struct j1939_priv *priv = session->priv;
877 if (!j1939_tp_im_transmitter(&session->skcb)) {
879 __func__, session);
883 switch (session->last_cmd) {
885 ret = j1939_session_tx_rts(session);
889 if (session->last_txcmd != J1939_ETP_CMD_DPO) {
890 ret = j1939_session_tx_dpo(session);
900 ret = j1939_session_tx_dat(session);
905 __func__, session, session->last_cmd);
911 static int j1939_session_tx_cts(struct j1939_session *session)
913 struct j1939_priv *priv = session->priv;
918 if (!j1939_sk_recv_match(priv, &session->skcb))
921 len = session->pkt.total - session->pkt.rx;
922 len = min3(len, session->pkt.block, j1939_tp_block ?: 255);
925 if (session->skcb.addr.type == J1939_ETP) {
926 pkt = session->pkt.rx + 1;
935 dat[2] = session->pkt.rx + 1;
938 if (dat[0] == session->last_txcmd)
942 ret = j1939_tp_tx_ctl(session, true, dat);
948 session->last_txcmd = dat[0];
949 j1939_tp_set_rxtimeout(session, 1250);
951 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
956 static int j1939_session_tx_eoma(struct j1939_session *session)
958 struct j1939_priv *priv = session->priv;
962 if (!j1939_sk_recv_match(priv, &session->skcb))
967 if (session->skcb.addr.type == J1939_ETP) {
969 dat[1] = session->total_message_size >> 0;
970 dat[2] = session->total_message_size >> 8;
971 dat[3] = session->total_message_size >> 16;
972 dat[4] = session->total_message_size >> 24;
975 dat[1] = session->total_message_size;
976 dat[2] = session->total_message_size >> 8;
977 dat[3] = session->pkt.total;
980 if (dat[0] == session->last_txcmd)
984 ret = j1939_tp_tx_ctl(session, true, dat);
988 session->last_txcmd = dat[0];
991 j1939_tp_set_rxtimeout(session, 1250);
993 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
998 static int j1939_xtp_txnext_receiver(struct j1939_session *session)
1000 struct j1939_priv *priv = session->priv;
1003 if (!j1939_tp_im_receiver(&session->skcb)) {
1005 __func__, session);
1009 switch (session->last_cmd) {
1012 ret = j1939_session_tx_cts(session);
1019 if ((session->skcb.addr.type == J1939_TP &&
1020 j1939_cb_is_broadcast(&session->skcb)))
1023 if (session->pkt.rx >= session->pkt.total) {
1024 ret = j1939_session_tx_eoma(session);
1025 } else if (session->pkt.rx >= session->pkt.last) {
1026 session->last_txcmd = 0;
1027 ret = j1939_session_tx_cts(session);
1032 __func__, session, session->last_cmd);
1038 static int j1939_simple_txnext(struct j1939_session *session)
1040 struct j1939_priv *priv = session->priv;
1041 struct sk_buff *se_skb = j1939_session_skb_get(session);
1056 j1939_tp_set_rxtimeout(session, J1939_SIMPLE_ECHO_TIMEOUT_MS);
1062 j1939_sk_errqueue(session, J1939_ERRQUEUE_TX_SCHED);
1063 j1939_sk_queue_activate_next(session);
1074 static bool j1939_session_deactivate_locked(struct j1939_session *session)
1078 lockdep_assert_held(&session->priv->active_session_list_lock);
1080 if (session->state >= J1939_SESSION_ACTIVE &&
1081 session->state < J1939_SESSION_ACTIVE_MAX) {
1084 list_del_init(&session->active_session_list_entry);
1085 session->state = J1939_SESSION_DONE;
1086 j1939_session_put(session);
1092 static bool j1939_session_deactivate(struct j1939_session *session)
1094 struct j1939_priv *priv = session->priv;
1098 active = j1939_session_deactivate_locked(session);
1105 j1939_session_deactivate_activate_next(struct j1939_session *session)
1107 if (j1939_session_deactivate(session))
1108 j1939_sk_queue_activate_next(session);
1111 static void __j1939_session_cancel(struct j1939_session *session,
1114 struct j1939_priv *priv = session->priv;
1117 lockdep_assert_held(&session->priv->active_session_list_lock);
1119 session->err = j1939_xtp_abort_to_errno(priv, err);
1120 session->state = J1939_SESSION_WAITING_ABORT;
1122 if (!j1939_cb_is_broadcast(&session->skcb)) {
1123 j1939_xtp_tx_abort(priv, &session->skcb,
1124 !session->transmission,
1125 err, session->skcb.addr.pgn);
1128 if (session->sk)
1129 j1939_sk_send_loop_abort(session->sk, session->err);
1132 static void j1939_session_cancel(struct j1939_session *session,
1135 j1939_session_list_lock(session->priv);
1137 if (session->state >= J1939_SESSION_ACTIVE &&
1138 session->state < J1939_SESSION_WAITING_ABORT) {
1139 j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS);
1140 __j1939_session_cancel(session, err);
1143 j1939_session_list_unlock(session->priv);
1145 if (!session->sk)
1146 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1151 struct j1939_session *session =
1153 struct j1939_priv *priv = session->priv;
1156 if (session->skcb.addr.type == J1939_SIMPLE) {
1157 ret = j1939_simple_txnext(session);
1159 if (session->transmission)
1160 ret = j1939_xtp_txnext_transmiter(session);
1162 ret = j1939_xtp_txnext_receiver(session);
1168 if (session->tx_retry < J1939_XTP_TX_RETRY_LIMIT) {
1169 session->tx_retry++;
1170 j1939_tp_schedule_txtimer(session,
1174 __func__, session);
1175 session->err = -ENETUNREACH;
1176 j1939_session_rxtimer_cancel(session);
1177 j1939_session_deactivate_activate_next(session);
1189 j1939_session_cancel(session, J1939_XTP_ABORT_ECTS_TOO_BIG);
1192 session->tx_retry = 0;
1196 __func__, session, ret);
1197 if (session->skcb.addr.type != J1939_SIMPLE) {
1198 j1939_session_cancel(session, J1939_XTP_ABORT_OTHER);
1200 session->err = ret;
1201 j1939_session_rxtimer_cancel(session);
1202 j1939_session_deactivate_activate_next(session);
1206 j1939_session_put(session);
1211 static void j1939_session_completed(struct j1939_session *session)
1215 if (!session->transmission) {
1216 se_skb = j1939_session_skb_get(session);
1218 j1939_sk_recv(session->priv, se_skb);
1222 j1939_session_deactivate_activate_next(session);
1227 struct j1939_session *session = container_of(hrtimer,
1230 struct j1939_priv *priv = session->priv;
1232 if (session->state == J1939_SESSION_WAITING_ABORT) {
1233 netdev_alert(priv->ndev, "%s: 0x%p: abort rx timeout. Force session deactivation\n",
1234 __func__, session);
1236 j1939_session_deactivate_activate_next(session);
1238 } else if (session->skcb.addr.type == J1939_SIMPLE) {
1240 __func__, session);
1245 session->err = -ETIME;
1246 j1939_session_deactivate(session);
1248 j1939_session_list_lock(session->priv);
1249 if (session->state >= J1939_SESSION_ACTIVE &&
1250 session->state < J1939_SESSION_ACTIVE_MAX) {
1252 __func__, session);
1253 j1939_session_get(session);
1254 hrtimer_start(&session->rxtimer,
1257 __j1939_session_cancel(session, J1939_XTP_ABORT_TIMEOUT);
1259 j1939_session_list_unlock(session->priv);
1261 if (!session->sk)
1262 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1265 j1939_session_put(session);
1270 static bool j1939_xtp_rx_cmd_bad_pgn(struct j1939_session *session,
1275 struct j1939_priv *priv = session->priv;
1279 if (session->skcb.addr.pgn == pgn)
1318 netdev_warn(priv->ndev, "%s: 0x%p: CMD 0x%02x with PGN 0x%05x for running session with different PGN 0x%05x.\n",
1319 __func__, session, cmd, pgn, session->skcb.addr.pgn);
1330 struct j1939_session *session;
1333 session = j1939_session_get_by_addr(priv, &skcb->addr, reverse,
1335 if (!session)
1338 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1342 session, j1939_xtp_ctl_to_pgn(skb->data), abort,
1345 j1939_session_timers_cancel(session);
1346 session->err = j1939_xtp_abort_to_errno(priv, abort);
1347 if (session->sk)
1348 j1939_sk_send_loop_abort(session->sk, session->err);
1350 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_ABORT);
1351 j1939_session_deactivate_activate_next(session);
1354 j1939_session_put(session);
1367 j1939_xtp_rx_eoma_one(struct j1939_session *session, struct sk_buff *skb)
1373 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1383 if (session->total_message_size != len) {
1384 netdev_warn_once(session->priv->ndev,
1386 __func__, session, session->total_message_size,
1390 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1392 session->pkt.tx_acked = session->pkt.total;
1393 j1939_session_timers_cancel(session);
1395 j1939_session_completed(session);
1403 struct j1939_session *session;
1405 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1407 if (!session)
1410 j1939_xtp_rx_eoma_one(session, skb);
1411 j1939_session_put(session);
1415 j1939_xtp_rx_cts_one(struct j1939_session *session, struct sk_buff *skb)
1423 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1426 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1428 if (session->last_cmd == dat[0]) {
1433 if (session->skcb.addr.type == J1939_ETP)
1440 else if (dat[1] > session->pkt.block /* 0xff for etp */)
1444 session->pkt.tx_acked = pkt - 1;
1445 j1939_session_skb_drop_old(session);
1446 session->pkt.last = session->pkt.tx_acked + dat[1];
1447 if (session->pkt.last > session->pkt.total)
1449 session->pkt.last = session->pkt.total;
1451 session->pkt.tx = session->pkt.tx_acked;
1453 session->last_cmd = dat[0];
1455 j1939_tp_set_rxtimeout(session, 1250);
1456 if (session->transmission) {
1457 if (session->pkt.tx_acked)
1458 j1939_sk_errqueue(session,
1460 j1939_session_txtimer_cancel(session);
1461 j1939_tp_schedule_txtimer(session, 0);
1465 j1939_tp_set_rxtimeout(session, 550);
1470 j1939_session_timers_cancel(session);
1471 j1939_session_cancel(session, err);
1478 struct j1939_session *session;
1480 session = j1939_session_get_by_addr(priv, &skcb->addr, true,
1482 if (!session)
1484 j1939_xtp_rx_cts_one(session, skb);
1485 j1939_session_put(session);
1491 struct j1939_session *session;
1494 session = kzalloc(sizeof(*session), gfp_any());
1495 if (!session)
1498 INIT_LIST_HEAD(&session->active_session_list_entry);
1499 INIT_LIST_HEAD(&session->sk_session_queue_entry);
1500 kref_init(&session->kref);
1503 session->priv = priv;
1504 session->total_message_size = size;
1505 session->state = J1939_SESSION_NEW;
1507 skb_queue_head_init(&session->skb_queue);
1508 skb_queue_tail(&session->skb_queue, skb);
1511 memcpy(&session->skcb, skcb, sizeof(session->skcb));
1513 hrtimer_init(&session->txtimer, CLOCK_MONOTONIC,
1515 session->txtimer.function = j1939_tp_txtimer;
1516 hrtimer_init(&session->rxtimer, CLOCK_MONOTONIC,
1518 session->rxtimer.function = j1939_tp_rxtimer;
1521 __func__, session, skcb->addr.sa, skcb->addr.da);
1523 return session;
1533 struct j1939_session *session;
1546 session = j1939_session_new(priv, skb, size);
1547 if (!session) {
1555 return session;
1558 int j1939_session_activate(struct j1939_session *session)
1560 struct j1939_priv *priv = session->priv;
1565 if (session->skcb.addr.type != J1939_SIMPLE)
1568 &session->skcb.addr, false,
1569 session->transmission);
1574 WARN_ON_ONCE(session->state != J1939_SESSION_NEW);
1575 list_add_tail(&session->active_session_list_entry,
1577 j1939_session_get(session);
1578 session->state = J1939_SESSION_ACTIVE;
1580 netdev_dbg(session->priv->ndev, "%s: 0x%p\n",
1581 __func__, session);
1594 struct j1939_session *session;
1631 session = j1939_session_fresh_new(priv, len, &skcb);
1632 if (!session) {
1639 session->pkt.total = (len + 6) / 7;
1640 session->pkt.block = 0xff;
1642 if (dat[3] != session->pkt.total)
1644 __func__, session, session->pkt.total,
1646 session->pkt.total = dat[3];
1647 session->pkt.block = min(dat[3], dat[4]);
1650 session->pkt.rx = 0;
1651 session->pkt.tx = 0;
1653 session->tskey = priv->rx_tskey++;
1654 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_RTS);
1656 WARN_ON_ONCE(j1939_session_activate(session));
1658 return session;
1661 static int j1939_xtp_rx_rts_session_active(struct j1939_session *session,
1665 struct j1939_priv *priv = session->priv;
1667 if (!session->transmission) {
1668 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1671 /* RTS on active session */
1672 j1939_session_timers_cancel(session);
1673 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1676 if (session->last_cmd != 0) {
1679 __func__, session, skcb->addr.sa, skcb->addr.da,
1680 session->last_cmd);
1682 j1939_session_timers_cancel(session);
1683 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY);
1688 if (session->skcb.addr.sa != skcb->addr.sa ||
1689 session->skcb.addr.da != skcb->addr.da)
1690 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",
1691 __func__, session,
1692 session->skcb.addr.sa, skcb->addr.sa,
1693 session->skcb.addr.da, skcb->addr.da);
1698 session->skcb.addr.sa = skcb->addr.sa;
1699 session->skcb.addr.da = skcb->addr.da;
1701 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1710 struct j1939_session *session;
1713 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1716 if (!session) {
1719 * we received our own RTS. A session has already been
1725 * receiver session.
1727 * The reasons the session is already destroyed might
1729 * - user space closed socket was and the session was
1731 * - session was aborted due to external abort message
1735 session = j1939_xtp_rx_rts_session_new(priv, skb);
1736 if (!session) {
1738 netdev_info(priv->ndev, "%s: failed to create TP BAM session\n",
1743 if (j1939_xtp_rx_rts_session_active(session, skb)) {
1744 j1939_session_put(session);
1748 session->last_cmd = cmd;
1751 if (!session->transmission)
1752 j1939_tp_set_rxtimeout(session, 750);
1754 if (!session->transmission) {
1755 j1939_session_txtimer_cancel(session);
1756 j1939_tp_schedule_txtimer(session, 0);
1758 j1939_tp_set_rxtimeout(session, 1250);
1761 j1939_session_put(session);
1764 static void j1939_xtp_rx_dpo_one(struct j1939_session *session,
1769 if (j1939_xtp_rx_cmd_bad_pgn(session, skb))
1772 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session);
1775 session->pkt.dpo = j1939_etp_ctl_to_packet(skb->data);
1776 session->last_cmd = dat[0];
1777 j1939_tp_set_rxtimeout(session, 750);
1779 if (!session->transmission)
1780 j1939_sk_errqueue(session, J1939_ERRQUEUE_RX_DPO);
1787 struct j1939_session *session;
1789 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1791 if (!session) {
1797 j1939_xtp_rx_dpo_one(session, skb);
1798 j1939_session_put(session);
1801 static void j1939_xtp_rx_dat_one(struct j1939_session *session,
1805 struct j1939_priv *priv = session->priv;
1825 switch (session->last_cmd) {
1840 session, session->last_cmd);
1844 packet = (dat[0] - 1 + session->pkt.dpo);
1845 if (packet > session->pkt.total ||
1846 (session->pkt.rx + 1) > session->pkt.total) {
1848 __func__, session);
1852 se_skb = j1939_session_skb_get_by_offset(session, packet * 7);
1855 session);
1866 __func__, session, nbytes, skb->len);
1871 if (!session->transmission) {
1880 __func__, session,
1885 if (packet == session->pkt.rx)
1886 session->pkt.rx++;
1889 j1939_cb_is_broadcast(&session->skcb)) {
1890 if (session->pkt.rx >= session->pkt.total)
1896 if (session->pkt.rx >= session->pkt.last)
1901 j1939_session_timers_cancel(session);
1902 j1939_session_completed(session);
1904 if (!session->transmission)
1905 j1939_tp_set_rxtimeout(session, 750);
1907 j1939_tp_set_rxtimeout(session, 1250);
1908 if (!session->transmission)
1909 j1939_tp_schedule_txtimer(session, 0);
1911 j1939_tp_set_rxtimeout(session, 750);
1913 session->last_cmd = 0xff;
1915 j1939_session_put(session);
1921 j1939_session_timers_cancel(session);
1922 j1939_session_cancel(session, abort);
1923 j1939_session_put(session);
1929 struct j1939_session *session;
1934 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1936 if (!session)
1940 j1939_xtp_rx_dat_one(session, skb);
1944 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1946 if (!session)
1950 j1939_xtp_rx_dat_one(session, skb);
1954 session = j1939_session_get_by_addr(priv, &skcb->addr, false,
1956 if (session)
1957 j1939_xtp_rx_dat_one(session, skb);
1966 struct j1939_session *session;
2003 /* prepare new session */
2004 session = j1939_session_new(priv, skb, size);
2005 if (!session)
2010 session->sk = skb->sk;
2011 session->transmission = true;
2012 session->pkt.total = (size + 6) / 7;
2013 session->pkt.block = skcb->addr.type == J1939_ETP ? 255 :
2014 min(j1939_tp_block ?: 255, session->pkt.total);
2016 if (j1939_cb_is_broadcast(&session->skcb))
2018 session->pkt.last = session->pkt.total;
2020 skcb->tskey = atomic_inc_return(&session->sk->sk_tskey) - 1;
2021 session->tskey = skcb->tskey;
2023 return session;
2154 struct j1939_session *session;
2164 session = j1939_session_get_simple(priv, skb);
2166 if (!session) {
2173 j1939_session_timers_cancel(session);
2174 j1939_session_deactivate(session);
2175 j1939_session_put(session);
2180 struct j1939_session *session, *saved;
2184 list_for_each_entry_safe(session, saved,
2187 if (!sk || sk == session->sk) {
2188 if (hrtimer_try_to_cancel(&session->txtimer) == 1)
2189 j1939_session_put(session);
2190 if (hrtimer_try_to_cancel(&session->rxtimer) == 1)
2191 j1939_session_put(session);
2193 session->err = ESHUTDOWN;
2194 j1939_session_deactivate_locked(session);