1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 /* isotp.c - ISO 15765-2 CAN transport protocol for protocol family CAN
4 * This implementation does not provide ISO-TP specific return values to the
7 * - RX path timeout of data reception leads to -ETIMEDOUT
8 * - RX path SN mismatch leads to -EILSEQ
9 * - RX path data reception with wrong padding leads to -EBADMSG
10 * - TX path flowcontrol reception timeout leads to -ECOMM
11 * - TX path flowcontrol reception overflow leads to -EMSGSIZE
12 * - TX path flowcontrol reception with wrong layout/padding leads to -EBADMSG
13 * - when a transfer (tx) is on the run the next write() blocks until it's done
14 * - use CAN_ISOTP_WAIT_TX_DONE flag to block the caller until the PDU is sent
15 * - as we have static buffers the check whether the PDU fits into the buffer
16 * is done at FF reception time (no support for sending 'wait frames')
18 * Copyright (c) 2020 Volkswagen Group Electronic Research
19 * All rights reserved.
21 * Redistribution and use in source and binary forms, with or without
22 * modification, are permitted provided that the following conditions
24 * 1. Redistributions of source code must retain the above copyright
25 * notice, this list of conditions and the following disclaimer.
26 * 2. Redistributions in binary form must reproduce the above copyright
27 * notice, this list of conditions and the following disclaimer in the
28 * documentation and/or other materials provided with the distribution.
29 * 3. Neither the name of Volkswagen nor the names of its contributors
30 * may be used to endorse or promote products derived from this software
31 * without specific prior written permission.
33 * Alternatively, provided that this notice is retained in full, this
34 * software may be distributed under the terms of the GNU General
35 * Public License ("GPL") version 2, in which case the provisions of the
36 * GPL apply INSTEAD OF those given above.
38 * The provided data structures and external interfaces from this code
39 * are not restricted to be used by modules with a GPL compatible license.
41 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
42 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
43 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
44 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
45 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
47 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
48 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
49 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
50 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
51 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
55 #include <linux/module.h>
56 #include <linux/init.h>
57 #include <linux/interrupt.h>
58 #include <linux/spinlock.h>
59 #include <linux/hrtimer.h>
60 #include <linux/wait.h>
61 #include <linux/uio.h>
62 #include <linux/net.h>
63 #include <linux/netdevice.h>
64 #include <linux/socket.h>
65 #include <linux/if_arp.h>
66 #include <linux/skbuff.h>
67 #include <linux/can.h>
68 #include <linux/can/core.h>
69 #include <linux/can/skb.h>
70 #include <linux/can/isotp.h>
71 #include <linux/slab.h>
73 #include <net/net_namespace.h>
75 MODULE_DESCRIPTION("PF_CAN isotp 15765-2:2016 protocol");
76 MODULE_LICENSE("Dual BSD/GPL");
77 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
78 MODULE_ALIAS("can-proto-6");
80 #define ISOTP_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_addr.tp)
82 #define SINGLE_MASK(id) (((id) & CAN_EFF_FLAG) ? \
83 (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \
84 (CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG))
86 /* ISO 15765-2:2016 supports more than 4095 byte per ISO PDU as the FF_DL can
87 * take full 32 bit values (4 Gbyte). We would need some good concept to handle
88 * this between user space and kernel space. For now increase the static buffer
89 * to something about 64 kbyte to be able to test this new functionality.
91 #define MAX_MSG_LENGTH 66000
93 /* N_PCI type values in bits 7-4 of N_PCI bytes */
94 #define N_PCI_SF 0x00 /* single frame */
95 #define N_PCI_FF 0x10 /* first frame */
96 #define N_PCI_CF 0x20 /* consecutive frame */
97 #define N_PCI_FC 0x30 /* flow control */
99 #define N_PCI_SZ 1 /* size of the PCI byte #1 */
100 #define SF_PCI_SZ4 1 /* size of SingleFrame PCI including 4 bit SF_DL */
101 #define SF_PCI_SZ8 2 /* size of SingleFrame PCI including 8 bit SF_DL */
102 #define FF_PCI_SZ12 2 /* size of FirstFrame PCI including 12 bit FF_DL */
103 #define FF_PCI_SZ32 6 /* size of FirstFrame PCI including 32 bit FF_DL */
104 #define FC_CONTENT_SZ 3 /* flow control content size in byte (FS/BS/STmin) */
106 #define ISOTP_CHECK_PADDING (CAN_ISOTP_CHK_PAD_LEN | CAN_ISOTP_CHK_PAD_DATA)
107 #define ISOTP_ALL_BC_FLAGS (CAN_ISOTP_SF_BROADCAST | CAN_ISOTP_CF_BROADCAST)
109 /* Flow Status given in FC frame */
110 #define ISOTP_FC_CTS 0 /* clear to send */
111 #define ISOTP_FC_WT 1 /* wait */
112 #define ISOTP_FC_OVFLW 2 /* overflow */
129 u8 buf
[MAX_MSG_LENGTH
+ 1];
139 ktime_t lastrxcf_tstamp
;
140 struct hrtimer rxtimer
, txtimer
;
141 struct can_isotp_options opt
;
142 struct can_isotp_fc_options rxfc
, txfc
;
143 struct can_isotp_ll_options ll
;
147 u32 cfecho
; /* consecutive frame echo tag */
149 struct list_head notifier
;
150 wait_queue_head_t wait
;
151 spinlock_t rx_lock
; /* protect single thread state machine */
154 static LIST_HEAD(isotp_notifier_list
);
155 static DEFINE_SPINLOCK(isotp_notifier_lock
);
156 static struct isotp_sock
*isotp_busy_notifier
;
158 static inline struct isotp_sock
*isotp_sk(const struct sock
*sk
)
160 return (struct isotp_sock
*)sk
;
163 static u32
isotp_bc_flags(struct isotp_sock
*so
)
165 return so
->opt
.flags
& ISOTP_ALL_BC_FLAGS
;
168 static bool isotp_register_rxid(struct isotp_sock
*so
)
170 /* no broadcast modes => register rx_id for FC frame reception */
171 return (isotp_bc_flags(so
) == 0);
174 static bool isotp_register_txecho(struct isotp_sock
*so
)
176 /* all modes but SF_BROADCAST register for tx echo skbs */
177 return (isotp_bc_flags(so
) != CAN_ISOTP_SF_BROADCAST
);
180 static enum hrtimer_restart
isotp_rx_timer_handler(struct hrtimer
*hrtimer
)
182 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
184 struct sock
*sk
= &so
->sk
;
186 if (so
->rx
.state
== ISOTP_WAIT_DATA
) {
187 /* we did not get new data frames in time */
189 /* report 'connection timed out' */
190 sk
->sk_err
= ETIMEDOUT
;
191 if (!sock_flag(sk
, SOCK_DEAD
))
195 so
->rx
.state
= ISOTP_IDLE
;
198 return HRTIMER_NORESTART
;
201 static int isotp_send_fc(struct sock
*sk
, int ae
, u8 flowstatus
)
203 struct net_device
*dev
;
204 struct sk_buff
*nskb
;
205 struct canfd_frame
*ncf
;
206 struct isotp_sock
*so
= isotp_sk(sk
);
209 nskb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
), gfp_any());
213 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
219 can_skb_reserve(nskb
);
220 can_skb_prv(nskb
)->ifindex
= dev
->ifindex
;
221 can_skb_prv(nskb
)->skbcnt
= 0;
224 can_skb_set_owner(nskb
, sk
);
225 ncf
= (struct canfd_frame
*)nskb
->data
;
226 skb_put_zero(nskb
, so
->ll
.mtu
);
228 /* create & send flow control reply */
229 ncf
->can_id
= so
->txid
;
231 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
232 memset(ncf
->data
, so
->opt
.txpad_content
, CAN_MAX_DLEN
);
233 ncf
->len
= CAN_MAX_DLEN
;
235 ncf
->len
= ae
+ FC_CONTENT_SZ
;
238 ncf
->data
[ae
] = N_PCI_FC
| flowstatus
;
239 ncf
->data
[ae
+ 1] = so
->rxfc
.bs
;
240 ncf
->data
[ae
+ 2] = so
->rxfc
.stmin
;
243 ncf
->data
[0] = so
->opt
.ext_address
;
245 ncf
->flags
= so
->ll
.tx_flags
;
247 can_send_ret
= can_send(nskb
, 1);
249 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
250 __func__
, ERR_PTR(can_send_ret
));
254 /* reset blocksize counter */
257 /* reset last CF frame rx timestamp for rx stmin enforcement */
258 so
->lastrxcf_tstamp
= ktime_set(0, 0);
260 /* start rx timeout watchdog */
261 hrtimer_start(&so
->rxtimer
, ktime_set(1, 0), HRTIMER_MODE_REL_SOFT
);
265 static void isotp_rcv_skb(struct sk_buff
*skb
, struct sock
*sk
)
267 struct sockaddr_can
*addr
= (struct sockaddr_can
*)skb
->cb
;
269 BUILD_BUG_ON(sizeof(skb
->cb
) < sizeof(struct sockaddr_can
));
271 memset(addr
, 0, sizeof(*addr
));
272 addr
->can_family
= AF_CAN
;
273 addr
->can_ifindex
= skb
->dev
->ifindex
;
275 if (sock_queue_rcv_skb(sk
, skb
) < 0)
279 static u8
padlen(u8 datalen
)
281 static const u8 plen
[] = {
282 8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */
283 12, 12, 12, 12, /* 9 - 12 */
284 16, 16, 16, 16, /* 13 - 16 */
285 20, 20, 20, 20, /* 17 - 20 */
286 24, 24, 24, 24, /* 21 - 24 */
287 32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */
288 48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */
289 48, 48, 48, 48, 48, 48, 48, 48 /* 41 - 48 */
295 return plen
[datalen
];
298 /* check for length optimization and return 1/true when the check fails */
299 static int check_optimized(struct canfd_frame
*cf
, int start_index
)
301 /* for CAN_DL <= 8 the start_index is equal to the CAN_DL as the
302 * padding would start at this point. E.g. if the padding would
303 * start at cf.data[7] cf->len has to be 7 to be optimal.
304 * Note: The data[] index starts with zero.
306 if (cf
->len
<= CAN_MAX_DLEN
)
307 return (cf
->len
!= start_index
);
309 /* This relation is also valid in the non-linear DLC range, where
310 * we need to take care of the minimal next possible CAN_DL.
311 * The correct check would be (padlen(cf->len) != padlen(start_index)).
312 * But as cf->len can only take discrete values from 12, .., 64 at this
313 * point the padlen(cf->len) is always equal to cf->len.
315 return (cf
->len
!= padlen(start_index
));
318 /* check padding and return 1/true when the check fails */
319 static int check_pad(struct isotp_sock
*so
, struct canfd_frame
*cf
,
320 int start_index
, u8 content
)
324 /* no RX_PADDING value => check length of optimized frame length */
325 if (!(so
->opt
.flags
& CAN_ISOTP_RX_PADDING
)) {
326 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
)
327 return check_optimized(cf
, start_index
);
329 /* no valid test against empty value => ignore frame */
333 /* check datalength of correctly padded CAN frame */
334 if ((so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
) &&
335 cf
->len
!= padlen(cf
->len
))
338 /* check padding content */
339 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_DATA
) {
340 for (i
= start_index
; i
< cf
->len
; i
++)
341 if (cf
->data
[i
] != content
)
347 static int isotp_rcv_fc(struct isotp_sock
*so
, struct canfd_frame
*cf
, int ae
)
349 struct sock
*sk
= &so
->sk
;
351 if (so
->tx
.state
!= ISOTP_WAIT_FC
&&
352 so
->tx
.state
!= ISOTP_WAIT_FIRST_FC
)
355 hrtimer_cancel(&so
->txtimer
);
357 if ((cf
->len
< ae
+ FC_CONTENT_SZ
) ||
358 ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
359 check_pad(so
, cf
, ae
+ FC_CONTENT_SZ
, so
->opt
.rxpad_content
))) {
360 /* malformed PDU - report 'not a data message' */
361 sk
->sk_err
= EBADMSG
;
362 if (!sock_flag(sk
, SOCK_DEAD
))
365 so
->tx
.state
= ISOTP_IDLE
;
366 wake_up_interruptible(&so
->wait
);
370 /* get communication parameters only from the first FC frame */
371 if (so
->tx
.state
== ISOTP_WAIT_FIRST_FC
) {
372 so
->txfc
.bs
= cf
->data
[ae
+ 1];
373 so
->txfc
.stmin
= cf
->data
[ae
+ 2];
375 /* fix wrong STmin values according spec */
376 if (so
->txfc
.stmin
> 0x7F &&
377 (so
->txfc
.stmin
< 0xF1 || so
->txfc
.stmin
> 0xF9))
378 so
->txfc
.stmin
= 0x7F;
380 so
->tx_gap
= ktime_set(0, 0);
381 /* add transmission time for CAN frame N_As */
382 so
->tx_gap
= ktime_add_ns(so
->tx_gap
, so
->frame_txtime
);
383 /* add waiting time for consecutive frames N_Cs */
384 if (so
->opt
.flags
& CAN_ISOTP_FORCE_TXSTMIN
)
385 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
387 else if (so
->txfc
.stmin
< 0x80)
388 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
389 so
->txfc
.stmin
* 1000000);
391 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
392 (so
->txfc
.stmin
- 0xF0)
394 so
->tx
.state
= ISOTP_WAIT_FC
;
397 switch (cf
->data
[ae
] & 0x0F) {
400 so
->tx
.state
= ISOTP_SENDING
;
401 /* start cyclic timer for sending CF frame */
402 hrtimer_start(&so
->txtimer
, so
->tx_gap
,
403 HRTIMER_MODE_REL_SOFT
);
407 /* start timer to wait for next FC frame */
408 hrtimer_start(&so
->txtimer
, ktime_set(1, 0),
409 HRTIMER_MODE_REL_SOFT
);
413 /* overflow on receiver side - report 'message too long' */
414 sk
->sk_err
= EMSGSIZE
;
415 if (!sock_flag(sk
, SOCK_DEAD
))
420 /* stop this tx job */
421 so
->tx
.state
= ISOTP_IDLE
;
422 wake_up_interruptible(&so
->wait
);
427 static int isotp_rcv_sf(struct sock
*sk
, struct canfd_frame
*cf
, int pcilen
,
428 struct sk_buff
*skb
, int len
)
430 struct isotp_sock
*so
= isotp_sk(sk
);
431 struct sk_buff
*nskb
;
433 hrtimer_cancel(&so
->rxtimer
);
434 so
->rx
.state
= ISOTP_IDLE
;
436 if (!len
|| len
> cf
->len
- pcilen
)
439 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
440 check_pad(so
, cf
, pcilen
+ len
, so
->opt
.rxpad_content
)) {
441 /* malformed PDU - report 'not a data message' */
442 sk
->sk_err
= EBADMSG
;
443 if (!sock_flag(sk
, SOCK_DEAD
))
448 nskb
= alloc_skb(len
, gfp_any());
452 memcpy(skb_put(nskb
, len
), &cf
->data
[pcilen
], len
);
454 nskb
->tstamp
= skb
->tstamp
;
455 nskb
->dev
= skb
->dev
;
456 isotp_rcv_skb(nskb
, sk
);
460 static int isotp_rcv_ff(struct sock
*sk
, struct canfd_frame
*cf
, int ae
)
462 struct isotp_sock
*so
= isotp_sk(sk
);
467 hrtimer_cancel(&so
->rxtimer
);
468 so
->rx
.state
= ISOTP_IDLE
;
470 /* get the used sender LL_DL from the (first) CAN frame data length */
471 so
->rx
.ll_dl
= padlen(cf
->len
);
473 /* the first frame has to use the entire frame up to LL_DL length */
474 if (cf
->len
!= so
->rx
.ll_dl
)
478 so
->rx
.len
= (cf
->data
[ae
] & 0x0F) << 8;
479 so
->rx
.len
+= cf
->data
[ae
+ 1];
481 /* Check for FF_DL escape sequence supporting 32 bit PDU length */
483 ff_pci_sz
= FF_PCI_SZ12
;
485 /* FF_DL = 0 => get real length from next 4 bytes */
486 so
->rx
.len
= cf
->data
[ae
+ 2] << 24;
487 so
->rx
.len
+= cf
->data
[ae
+ 3] << 16;
488 so
->rx
.len
+= cf
->data
[ae
+ 4] << 8;
489 so
->rx
.len
+= cf
->data
[ae
+ 5];
490 ff_pci_sz
= FF_PCI_SZ32
;
493 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
494 off
= (so
->rx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
496 if (so
->rx
.len
+ ae
+ off
+ ff_pci_sz
< so
->rx
.ll_dl
)
499 if (so
->rx
.len
> MAX_MSG_LENGTH
) {
500 /* send FC frame with overflow status */
501 isotp_send_fc(sk
, ae
, ISOTP_FC_OVFLW
);
505 /* copy the first received data bytes */
507 for (i
= ae
+ ff_pci_sz
; i
< so
->rx
.ll_dl
; i
++)
508 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
510 /* initial setup for this pdu reception */
512 so
->rx
.state
= ISOTP_WAIT_DATA
;
514 /* no creation of flow control frames */
515 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
518 /* send our first FC frame */
519 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
523 static int isotp_rcv_cf(struct sock
*sk
, struct canfd_frame
*cf
, int ae
,
526 struct isotp_sock
*so
= isotp_sk(sk
);
527 struct sk_buff
*nskb
;
530 if (so
->rx
.state
!= ISOTP_WAIT_DATA
)
533 /* drop if timestamp gap is less than force_rx_stmin nano secs */
534 if (so
->opt
.flags
& CAN_ISOTP_FORCE_RXSTMIN
) {
535 if (ktime_to_ns(ktime_sub(skb
->tstamp
, so
->lastrxcf_tstamp
)) <
539 so
->lastrxcf_tstamp
= skb
->tstamp
;
542 hrtimer_cancel(&so
->rxtimer
);
544 /* CFs are never longer than the FF */
545 if (cf
->len
> so
->rx
.ll_dl
)
548 /* CFs have usually the LL_DL length */
549 if (cf
->len
< so
->rx
.ll_dl
) {
550 /* this is only allowed for the last CF */
551 if (so
->rx
.len
- so
->rx
.idx
> so
->rx
.ll_dl
- ae
- N_PCI_SZ
)
555 if ((cf
->data
[ae
] & 0x0F) != so
->rx
.sn
) {
556 /* wrong sn detected - report 'illegal byte sequence' */
558 if (!sock_flag(sk
, SOCK_DEAD
))
562 so
->rx
.state
= ISOTP_IDLE
;
568 for (i
= ae
+ N_PCI_SZ
; i
< cf
->len
; i
++) {
569 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
570 if (so
->rx
.idx
>= so
->rx
.len
)
574 if (so
->rx
.idx
>= so
->rx
.len
) {
576 so
->rx
.state
= ISOTP_IDLE
;
578 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
579 check_pad(so
, cf
, i
+ 1, so
->opt
.rxpad_content
)) {
580 /* malformed PDU - report 'not a data message' */
581 sk
->sk_err
= EBADMSG
;
582 if (!sock_flag(sk
, SOCK_DEAD
))
587 nskb
= alloc_skb(so
->rx
.len
, gfp_any());
591 memcpy(skb_put(nskb
, so
->rx
.len
), so
->rx
.buf
,
594 nskb
->tstamp
= skb
->tstamp
;
595 nskb
->dev
= skb
->dev
;
596 isotp_rcv_skb(nskb
, sk
);
600 /* perform blocksize handling, if enabled */
601 if (!so
->rxfc
.bs
|| ++so
->rx
.bs
< so
->rxfc
.bs
) {
602 /* start rx timeout watchdog */
603 hrtimer_start(&so
->rxtimer
, ktime_set(1, 0),
604 HRTIMER_MODE_REL_SOFT
);
608 /* no creation of flow control frames */
609 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
612 /* we reached the specified blocksize so->rxfc.bs */
613 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
617 static void isotp_rcv(struct sk_buff
*skb
, void *data
)
619 struct sock
*sk
= (struct sock
*)data
;
620 struct isotp_sock
*so
= isotp_sk(sk
);
621 struct canfd_frame
*cf
;
622 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
623 u8 n_pci_type
, sf_dl
;
625 /* Strictly receive only frames with the configured MTU size
626 * => clear separation of CAN2.0 / CAN FD transport channels
628 if (skb
->len
!= so
->ll
.mtu
)
631 cf
= (struct canfd_frame
*)skb
->data
;
633 /* if enabled: check reception of my configured extended address */
634 if (ae
&& cf
->data
[0] != so
->opt
.rx_ext_address
)
637 n_pci_type
= cf
->data
[ae
] & 0xF0;
639 /* Make sure the state changes and data structures stay consistent at
640 * CAN frame reception time. This locking is not needed in real world
641 * use cases but the inconsistency can be triggered with syzkaller.
643 spin_lock(&so
->rx_lock
);
645 if (so
->opt
.flags
& CAN_ISOTP_HALF_DUPLEX
) {
646 /* check rx/tx path half duplex expectations */
647 if ((so
->tx
.state
!= ISOTP_IDLE
&& n_pci_type
!= N_PCI_FC
) ||
648 (so
->rx
.state
!= ISOTP_IDLE
&& n_pci_type
== N_PCI_FC
))
652 switch (n_pci_type
) {
654 /* tx path: flow control frame containing the FC parameters */
655 isotp_rcv_fc(so
, cf
, ae
);
659 /* rx path: single frame
661 * As we do not have a rx.ll_dl configuration, we can only test
662 * if the CAN frames payload length matches the LL_DL == 8
663 * requirements - no matter if it's CAN 2.0 or CAN FD
666 /* get the SF_DL from the N_PCI byte */
667 sf_dl
= cf
->data
[ae
] & 0x0F;
669 if (cf
->len
<= CAN_MAX_DLEN
) {
670 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ4
+ ae
, skb
, sf_dl
);
672 if (skb
->len
== CANFD_MTU
) {
673 /* We have a CAN FD frame and CAN_DL is greater than 8:
674 * Only frames with the SF_DL == 0 ESC value are valid.
676 * If so take care of the increased SF PCI size
677 * (SF_PCI_SZ8) to point to the message content behind
678 * the extended SF PCI info and get the real SF_DL
679 * length value from the formerly first data byte.
682 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ8
+ ae
, skb
,
683 cf
->data
[SF_PCI_SZ4
+ ae
]);
689 /* rx path: first frame */
690 isotp_rcv_ff(sk
, cf
, ae
);
694 /* rx path: consecutive frame */
695 isotp_rcv_cf(sk
, cf
, ae
, skb
);
700 spin_unlock(&so
->rx_lock
);
703 static void isotp_fill_dataframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
706 int pcilen
= N_PCI_SZ
+ ae
+ off
;
707 int space
= so
->tx
.ll_dl
- pcilen
;
708 int num
= min_t(int, so
->tx
.len
- so
->tx
.idx
, space
);
711 cf
->can_id
= so
->txid
;
712 cf
->len
= num
+ pcilen
;
715 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
716 /* user requested padding */
717 cf
->len
= padlen(cf
->len
);
718 memset(cf
->data
, so
->opt
.txpad_content
, cf
->len
);
719 } else if (cf
->len
> CAN_MAX_DLEN
) {
720 /* mandatory padding for CAN FD frames */
721 cf
->len
= padlen(cf
->len
);
722 memset(cf
->data
, CAN_ISOTP_DEFAULT_PAD_CONTENT
,
727 for (i
= 0; i
< num
; i
++)
728 cf
->data
[pcilen
+ i
] = so
->tx
.buf
[so
->tx
.idx
++];
731 cf
->data
[0] = so
->opt
.ext_address
;
734 static void isotp_send_cframe(struct isotp_sock
*so
)
736 struct sock
*sk
= &so
->sk
;
738 struct net_device
*dev
;
739 struct canfd_frame
*cf
;
741 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
743 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
747 skb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
), GFP_ATOMIC
);
753 can_skb_reserve(skb
);
754 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
755 can_skb_prv(skb
)->skbcnt
= 0;
757 cf
= (struct canfd_frame
*)skb
->data
;
758 skb_put_zero(skb
, so
->ll
.mtu
);
760 /* create consecutive frame */
761 isotp_fill_dataframe(cf
, so
, ae
, 0);
763 /* place consecutive frame N_PCI in appropriate index */
764 cf
->data
[ae
] = N_PCI_CF
| so
->tx
.sn
++;
768 cf
->flags
= so
->ll
.tx_flags
;
771 can_skb_set_owner(skb
, sk
);
773 /* cfecho should have been zero'ed by init/isotp_rcv_echo() */
775 pr_notice_once("can-isotp: cfecho is %08X != 0\n", so
->cfecho
);
777 /* set consecutive frame echo tag */
778 so
->cfecho
= *(u32
*)cf
->data
;
780 /* send frame with local echo enabled */
781 can_send_ret
= can_send(skb
, 1);
783 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
784 __func__
, ERR_PTR(can_send_ret
));
785 if (can_send_ret
== -ENOBUFS
)
786 pr_notice_once("can-isotp: tx queue is full\n");
791 static void isotp_create_fframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
797 cf
->can_id
= so
->txid
;
798 cf
->len
= so
->tx
.ll_dl
;
800 cf
->data
[0] = so
->opt
.ext_address
;
802 /* create N_PCI bytes with 12/32 bit FF_DL data length */
803 if (so
->tx
.len
> 4095) {
804 /* use 32 bit FF_DL notation */
805 cf
->data
[ae
] = N_PCI_FF
;
806 cf
->data
[ae
+ 1] = 0;
807 cf
->data
[ae
+ 2] = (u8
)(so
->tx
.len
>> 24) & 0xFFU
;
808 cf
->data
[ae
+ 3] = (u8
)(so
->tx
.len
>> 16) & 0xFFU
;
809 cf
->data
[ae
+ 4] = (u8
)(so
->tx
.len
>> 8) & 0xFFU
;
810 cf
->data
[ae
+ 5] = (u8
)so
->tx
.len
& 0xFFU
;
811 ff_pci_sz
= FF_PCI_SZ32
;
813 /* use 12 bit FF_DL notation */
814 cf
->data
[ae
] = (u8
)(so
->tx
.len
>> 8) | N_PCI_FF
;
815 cf
->data
[ae
+ 1] = (u8
)so
->tx
.len
& 0xFFU
;
816 ff_pci_sz
= FF_PCI_SZ12
;
819 /* add first data bytes depending on ae */
820 for (i
= ae
+ ff_pci_sz
; i
< so
->tx
.ll_dl
; i
++)
821 cf
->data
[i
] = so
->tx
.buf
[so
->tx
.idx
++];
826 static void isotp_rcv_echo(struct sk_buff
*skb
, void *data
)
828 struct sock
*sk
= (struct sock
*)data
;
829 struct isotp_sock
*so
= isotp_sk(sk
);
830 struct canfd_frame
*cf
= (struct canfd_frame
*)skb
->data
;
832 /* only handle my own local echo skb's */
833 if (skb
->sk
!= sk
|| so
->cfecho
!= *(u32
*)cf
->data
)
836 /* cancel local echo timeout */
837 hrtimer_cancel(&so
->txtimer
);
839 /* local echo skb with consecutive frame has been consumed */
842 if (so
->tx
.idx
>= so
->tx
.len
) {
844 so
->tx
.state
= ISOTP_IDLE
;
845 wake_up_interruptible(&so
->wait
);
849 if (so
->txfc
.bs
&& so
->tx
.bs
>= so
->txfc
.bs
) {
850 /* stop and wait for FC with timeout */
851 so
->tx
.state
= ISOTP_WAIT_FC
;
852 hrtimer_start(&so
->txtimer
, ktime_set(1, 0),
853 HRTIMER_MODE_REL_SOFT
);
857 /* no gap between data frames needed => use burst mode */
859 isotp_send_cframe(so
);
863 /* start timer to send next consecutive frame with correct delay */
864 hrtimer_start(&so
->txtimer
, so
->tx_gap
, HRTIMER_MODE_REL_SOFT
);
867 static enum hrtimer_restart
isotp_tx_timer_handler(struct hrtimer
*hrtimer
)
869 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
871 struct sock
*sk
= &so
->sk
;
872 enum hrtimer_restart restart
= HRTIMER_NORESTART
;
874 switch (so
->tx
.state
) {
877 /* cfecho should be consumed by isotp_rcv_echo() here */
879 /* start timeout for unlikely lost echo skb */
880 hrtimer_set_expires(&so
->txtimer
,
881 ktime_add(ktime_get(),
883 restart
= HRTIMER_RESTART
;
885 /* push out the next consecutive frame */
886 isotp_send_cframe(so
);
890 /* cfecho has not been cleared in isotp_rcv_echo() */
891 pr_notice_once("can-isotp: cfecho %08X timeout\n", so
->cfecho
);
895 case ISOTP_WAIT_FIRST_FC
:
897 /* we did not get any flow control frame in time */
899 /* report 'communication error on send' */
901 if (!sock_flag(sk
, SOCK_DEAD
))
905 so
->tx
.state
= ISOTP_IDLE
;
906 wake_up_interruptible(&so
->wait
);
916 static int isotp_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
)
918 struct sock
*sk
= sock
->sk
;
919 struct isotp_sock
*so
= isotp_sk(sk
);
920 u32 old_state
= so
->tx
.state
;
922 struct net_device
*dev
;
923 struct canfd_frame
*cf
;
924 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
925 int wait_tx_done
= (so
->opt
.flags
& CAN_ISOTP_WAIT_TX_DONE
) ? 1 : 0;
931 return -EADDRNOTAVAIL
;
933 /* we do not support multiple buffers - for now */
934 if (cmpxchg(&so
->tx
.state
, ISOTP_IDLE
, ISOTP_SENDING
) != ISOTP_IDLE
||
935 wq_has_sleeper(&so
->wait
)) {
936 if (msg
->msg_flags
& MSG_DONTWAIT
) {
941 /* wait for complete transmission of current pdu */
942 err
= wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
947 if (!size
|| size
> MAX_MSG_LENGTH
) {
952 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
953 off
= (so
->tx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
955 /* does the given data fit into a single frame for SF_BROADCAST? */
956 if ((isotp_bc_flags(so
) == CAN_ISOTP_SF_BROADCAST
) &&
957 (size
> so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
)) {
962 err
= memcpy_from_msg(so
->tx
.buf
, msg
, size
);
966 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
972 skb
= sock_alloc_send_skb(sk
, so
->ll
.mtu
+ sizeof(struct can_skb_priv
),
973 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
979 can_skb_reserve(skb
);
980 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
981 can_skb_prv(skb
)->skbcnt
= 0;
986 cf
= (struct canfd_frame
*)skb
->data
;
987 skb_put_zero(skb
, so
->ll
.mtu
);
989 /* check for single frame transmission depending on TX_DL */
990 if (size
<= so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
) {
991 /* The message size generally fits into a SingleFrame - good.
993 * SF_DL ESC offset optimization:
995 * When TX_DL is greater 8 but the message would still fit
996 * into a 8 byte CAN frame, we can omit the offset.
997 * This prevents a protocol caused length extension from
998 * CAN_DL = 8 to CAN_DL = 12 due to the SF_SL ESC handling.
1000 if (size
<= CAN_MAX_DLEN
- SF_PCI_SZ4
- ae
)
1003 isotp_fill_dataframe(cf
, so
, ae
, off
);
1005 /* place single frame N_PCI w/o length in appropriate index */
1006 cf
->data
[ae
] = N_PCI_SF
;
1008 /* place SF_DL size value depending on the SF_DL ESC offset */
1010 cf
->data
[SF_PCI_SZ4
+ ae
] = size
;
1012 cf
->data
[ae
] |= size
;
1014 so
->tx
.state
= ISOTP_IDLE
;
1015 wake_up_interruptible(&so
->wait
);
1017 /* don't enable wait queue for a single frame transmission */
1020 /* send first frame */
1022 isotp_create_fframe(cf
, so
, ae
);
1024 if (isotp_bc_flags(so
) == CAN_ISOTP_CF_BROADCAST
) {
1025 /* set timer for FC-less operation (STmin = 0) */
1026 if (so
->opt
.flags
& CAN_ISOTP_FORCE_TXSTMIN
)
1027 so
->tx_gap
= ktime_set(0, so
->force_tx_stmin
);
1029 so
->tx_gap
= ktime_set(0, so
->frame_txtime
);
1031 /* disable wait for FCs due to activated block size */
1034 /* cfecho should have been zero'ed by init */
1036 pr_notice_once("can-isotp: no fc cfecho %08X\n",
1039 /* set consecutive frame echo tag */
1040 so
->cfecho
= *(u32
*)cf
->data
;
1042 /* switch directly to ISOTP_SENDING state */
1043 so
->tx
.state
= ISOTP_SENDING
;
1045 /* start timeout for unlikely lost echo skb */
1048 /* standard flow control check */
1049 so
->tx
.state
= ISOTP_WAIT_FIRST_FC
;
1051 /* start timeout for FC */
1055 hrtimer_start(&so
->txtimer
, ktime_set(hrtimer_sec
, 0),
1056 HRTIMER_MODE_REL_SOFT
);
1059 /* send the first or only CAN frame */
1060 cf
->flags
= so
->ll
.tx_flags
;
1064 err
= can_send(skb
, 1);
1067 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
1068 __func__
, ERR_PTR(err
));
1070 /* no transmission -> no timeout monitoring */
1072 hrtimer_cancel(&so
->txtimer
);
1074 /* reset consecutive frame echo tag */
1081 /* wait for complete transmission of current pdu */
1082 wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
1091 /* drop this PDU and unlock a potential wait queue */
1092 old_state
= ISOTP_IDLE
;
1094 so
->tx
.state
= old_state
;
1095 if (so
->tx
.state
== ISOTP_IDLE
)
1096 wake_up_interruptible(&so
->wait
);
1101 static int isotp_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1104 struct sock
*sk
= sock
->sk
;
1105 struct sk_buff
*skb
;
1106 struct isotp_sock
*so
= isotp_sk(sk
);
1109 if (flags
& ~(MSG_DONTWAIT
| MSG_TRUNC
| MSG_PEEK
))
1113 return -EADDRNOTAVAIL
;
1115 skb
= skb_recv_datagram(sk
, flags
, &ret
);
1119 if (size
< skb
->len
)
1120 msg
->msg_flags
|= MSG_TRUNC
;
1124 ret
= memcpy_to_msg(msg
, skb
->data
, size
);
1128 sock_recv_timestamp(msg
, sk
, skb
);
1130 if (msg
->msg_name
) {
1131 __sockaddr_check_size(ISOTP_MIN_NAMELEN
);
1132 msg
->msg_namelen
= ISOTP_MIN_NAMELEN
;
1133 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
1136 /* set length of return value */
1137 ret
= (flags
& MSG_TRUNC
) ? skb
->len
: size
;
1140 skb_free_datagram(sk
, skb
);
1145 static int isotp_release(struct socket
*sock
)
1147 struct sock
*sk
= sock
->sk
;
1148 struct isotp_sock
*so
;
1157 /* wait for complete transmission of current pdu */
1158 wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
1160 spin_lock(&isotp_notifier_lock
);
1161 while (isotp_busy_notifier
== so
) {
1162 spin_unlock(&isotp_notifier_lock
);
1163 schedule_timeout_uninterruptible(1);
1164 spin_lock(&isotp_notifier_lock
);
1166 list_del(&so
->notifier
);
1167 spin_unlock(&isotp_notifier_lock
);
1171 /* remove current filters & unregister */
1172 if (so
->bound
&& isotp_register_txecho(so
)) {
1174 struct net_device
*dev
;
1176 dev
= dev_get_by_index(net
, so
->ifindex
);
1178 if (isotp_register_rxid(so
))
1179 can_rx_unregister(net
, dev
, so
->rxid
,
1180 SINGLE_MASK(so
->rxid
),
1183 can_rx_unregister(net
, dev
, so
->txid
,
1184 SINGLE_MASK(so
->txid
),
1185 isotp_rcv_echo
, sk
);
1192 hrtimer_cancel(&so
->txtimer
);
1193 hrtimer_cancel(&so
->rxtimer
);
1207 static int isotp_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int len
)
1209 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1210 struct sock
*sk
= sock
->sk
;
1211 struct isotp_sock
*so
= isotp_sk(sk
);
1212 struct net
*net
= sock_net(sk
);
1214 struct net_device
*dev
;
1215 canid_t tx_id
= addr
->can_addr
.tp
.tx_id
;
1216 canid_t rx_id
= addr
->can_addr
.tp
.rx_id
;
1218 int notify_enetdown
= 0;
1220 if (len
< ISOTP_MIN_NAMELEN
)
1223 /* sanitize tx CAN identifier */
1224 if (tx_id
& CAN_EFF_FLAG
)
1225 tx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1227 tx_id
&= CAN_SFF_MASK
;
1229 /* give feedback on wrong CAN-ID value */
1230 if (tx_id
!= addr
->can_addr
.tp
.tx_id
)
1233 /* sanitize rx CAN identifier (if needed) */
1234 if (isotp_register_rxid(so
)) {
1235 if (rx_id
& CAN_EFF_FLAG
)
1236 rx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1238 rx_id
&= CAN_SFF_MASK
;
1240 /* give feedback on wrong CAN-ID value */
1241 if (rx_id
!= addr
->can_addr
.tp
.rx_id
)
1245 if (!addr
->can_ifindex
)
1255 /* ensure different CAN IDs when the rx_id is to be registered */
1256 if (isotp_register_rxid(so
) && rx_id
== tx_id
) {
1257 err
= -EADDRNOTAVAIL
;
1261 dev
= dev_get_by_index(net
, addr
->can_ifindex
);
1266 if (dev
->type
!= ARPHRD_CAN
) {
1271 if (dev
->mtu
< so
->ll
.mtu
) {
1276 if (!(dev
->flags
& IFF_UP
))
1277 notify_enetdown
= 1;
1279 ifindex
= dev
->ifindex
;
1281 if (isotp_register_rxid(so
))
1282 can_rx_register(net
, dev
, rx_id
, SINGLE_MASK(rx_id
),
1283 isotp_rcv
, sk
, "isotp", sk
);
1285 if (isotp_register_txecho(so
)) {
1286 /* no consecutive frame echo skb in flight */
1289 /* register for echo skb's */
1290 can_rx_register(net
, dev
, tx_id
, SINGLE_MASK(tx_id
),
1291 isotp_rcv_echo
, sk
, "isotpe", sk
);
1296 /* switch to new settings */
1297 so
->ifindex
= ifindex
;
1305 if (notify_enetdown
) {
1306 sk
->sk_err
= ENETDOWN
;
1307 if (!sock_flag(sk
, SOCK_DEAD
))
1308 sk_error_report(sk
);
1314 static int isotp_getname(struct socket
*sock
, struct sockaddr
*uaddr
, int peer
)
1316 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1317 struct sock
*sk
= sock
->sk
;
1318 struct isotp_sock
*so
= isotp_sk(sk
);
1323 memset(addr
, 0, ISOTP_MIN_NAMELEN
);
1324 addr
->can_family
= AF_CAN
;
1325 addr
->can_ifindex
= so
->ifindex
;
1326 addr
->can_addr
.tp
.rx_id
= so
->rxid
;
1327 addr
->can_addr
.tp
.tx_id
= so
->txid
;
1329 return ISOTP_MIN_NAMELEN
;
1332 static int isotp_setsockopt_locked(struct socket
*sock
, int level
, int optname
,
1333 sockptr_t optval
, unsigned int optlen
)
1335 struct sock
*sk
= sock
->sk
;
1336 struct isotp_sock
*so
= isotp_sk(sk
);
1343 case CAN_ISOTP_OPTS
:
1344 if (optlen
!= sizeof(struct can_isotp_options
))
1347 if (copy_from_sockptr(&so
->opt
, optval
, optlen
))
1350 /* no separate rx_ext_address is given => use ext_address */
1351 if (!(so
->opt
.flags
& CAN_ISOTP_RX_EXT_ADDR
))
1352 so
->opt
.rx_ext_address
= so
->opt
.ext_address
;
1354 /* these broadcast flags are not allowed together */
1355 if (isotp_bc_flags(so
) == ISOTP_ALL_BC_FLAGS
) {
1356 /* CAN_ISOTP_SF_BROADCAST is prioritized */
1357 so
->opt
.flags
&= ~CAN_ISOTP_CF_BROADCAST
;
1359 /* give user feedback on wrong config attempt */
1363 /* check for frame_txtime changes (0 => no changes) */
1364 if (so
->opt
.frame_txtime
) {
1365 if (so
->opt
.frame_txtime
== CAN_ISOTP_FRAME_TXTIME_ZERO
)
1366 so
->frame_txtime
= 0;
1368 so
->frame_txtime
= so
->opt
.frame_txtime
;
1372 case CAN_ISOTP_RECV_FC
:
1373 if (optlen
!= sizeof(struct can_isotp_fc_options
))
1376 if (copy_from_sockptr(&so
->rxfc
, optval
, optlen
))
1380 case CAN_ISOTP_TX_STMIN
:
1381 if (optlen
!= sizeof(u32
))
1384 if (copy_from_sockptr(&so
->force_tx_stmin
, optval
, optlen
))
1388 case CAN_ISOTP_RX_STMIN
:
1389 if (optlen
!= sizeof(u32
))
1392 if (copy_from_sockptr(&so
->force_rx_stmin
, optval
, optlen
))
1396 case CAN_ISOTP_LL_OPTS
:
1397 if (optlen
== sizeof(struct can_isotp_ll_options
)) {
1398 struct can_isotp_ll_options ll
;
1400 if (copy_from_sockptr(&ll
, optval
, optlen
))
1403 /* check for correct ISO 11898-1 DLC data length */
1404 if (ll
.tx_dl
!= padlen(ll
.tx_dl
))
1407 if (ll
.mtu
!= CAN_MTU
&& ll
.mtu
!= CANFD_MTU
)
1410 if (ll
.mtu
== CAN_MTU
&&
1411 (ll
.tx_dl
> CAN_MAX_DLEN
|| ll
.tx_flags
!= 0))
1414 memcpy(&so
->ll
, &ll
, sizeof(ll
));
1416 /* set ll_dl for tx path to similar place as for rx */
1417 so
->tx
.ll_dl
= ll
.tx_dl
;
1430 static int isotp_setsockopt(struct socket
*sock
, int level
, int optname
,
1431 sockptr_t optval
, unsigned int optlen
)
1434 struct sock
*sk
= sock
->sk
;
1437 if (level
!= SOL_CAN_ISOTP
)
1441 ret
= isotp_setsockopt_locked(sock
, level
, optname
, optval
, optlen
);
1446 static int isotp_getsockopt(struct socket
*sock
, int level
, int optname
,
1447 char __user
*optval
, int __user
*optlen
)
1449 struct sock
*sk
= sock
->sk
;
1450 struct isotp_sock
*so
= isotp_sk(sk
);
1454 if (level
!= SOL_CAN_ISOTP
)
1456 if (get_user(len
, optlen
))
1462 case CAN_ISOTP_OPTS
:
1463 len
= min_t(int, len
, sizeof(struct can_isotp_options
));
1467 case CAN_ISOTP_RECV_FC
:
1468 len
= min_t(int, len
, sizeof(struct can_isotp_fc_options
));
1472 case CAN_ISOTP_TX_STMIN
:
1473 len
= min_t(int, len
, sizeof(u32
));
1474 val
= &so
->force_tx_stmin
;
1477 case CAN_ISOTP_RX_STMIN
:
1478 len
= min_t(int, len
, sizeof(u32
));
1479 val
= &so
->force_rx_stmin
;
1482 case CAN_ISOTP_LL_OPTS
:
1483 len
= min_t(int, len
, sizeof(struct can_isotp_ll_options
));
1488 return -ENOPROTOOPT
;
1491 if (put_user(len
, optlen
))
1493 if (copy_to_user(optval
, val
, len
))
1498 static void isotp_notify(struct isotp_sock
*so
, unsigned long msg
,
1499 struct net_device
*dev
)
1501 struct sock
*sk
= &so
->sk
;
1503 if (!net_eq(dev_net(dev
), sock_net(sk
)))
1506 if (so
->ifindex
!= dev
->ifindex
)
1510 case NETDEV_UNREGISTER
:
1512 /* remove current filters & unregister */
1513 if (so
->bound
&& isotp_register_txecho(so
)) {
1514 if (isotp_register_rxid(so
))
1515 can_rx_unregister(dev_net(dev
), dev
, so
->rxid
,
1516 SINGLE_MASK(so
->rxid
),
1519 can_rx_unregister(dev_net(dev
), dev
, so
->txid
,
1520 SINGLE_MASK(so
->txid
),
1521 isotp_rcv_echo
, sk
);
1528 sk
->sk_err
= ENODEV
;
1529 if (!sock_flag(sk
, SOCK_DEAD
))
1530 sk_error_report(sk
);
1534 sk
->sk_err
= ENETDOWN
;
1535 if (!sock_flag(sk
, SOCK_DEAD
))
1536 sk_error_report(sk
);
1541 static int isotp_notifier(struct notifier_block
*nb
, unsigned long msg
,
1544 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1546 if (dev
->type
!= ARPHRD_CAN
)
1548 if (msg
!= NETDEV_UNREGISTER
&& msg
!= NETDEV_DOWN
)
1550 if (unlikely(isotp_busy_notifier
)) /* Check for reentrant bug. */
1553 spin_lock(&isotp_notifier_lock
);
1554 list_for_each_entry(isotp_busy_notifier
, &isotp_notifier_list
, notifier
) {
1555 spin_unlock(&isotp_notifier_lock
);
1556 isotp_notify(isotp_busy_notifier
, msg
, dev
);
1557 spin_lock(&isotp_notifier_lock
);
1559 isotp_busy_notifier
= NULL
;
1560 spin_unlock(&isotp_notifier_lock
);
1564 static int isotp_init(struct sock
*sk
)
1566 struct isotp_sock
*so
= isotp_sk(sk
);
1571 so
->opt
.flags
= CAN_ISOTP_DEFAULT_FLAGS
;
1572 so
->opt
.ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1573 so
->opt
.rx_ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1574 so
->opt
.rxpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1575 so
->opt
.txpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1576 so
->opt
.frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1577 so
->frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1578 so
->rxfc
.bs
= CAN_ISOTP_DEFAULT_RECV_BS
;
1579 so
->rxfc
.stmin
= CAN_ISOTP_DEFAULT_RECV_STMIN
;
1580 so
->rxfc
.wftmax
= CAN_ISOTP_DEFAULT_RECV_WFTMAX
;
1581 so
->ll
.mtu
= CAN_ISOTP_DEFAULT_LL_MTU
;
1582 so
->ll
.tx_dl
= CAN_ISOTP_DEFAULT_LL_TX_DL
;
1583 so
->ll
.tx_flags
= CAN_ISOTP_DEFAULT_LL_TX_FLAGS
;
1585 /* set ll_dl for tx path to similar place as for rx */
1586 so
->tx
.ll_dl
= so
->ll
.tx_dl
;
1588 so
->rx
.state
= ISOTP_IDLE
;
1589 so
->tx
.state
= ISOTP_IDLE
;
1591 hrtimer_init(&so
->rxtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1592 so
->rxtimer
.function
= isotp_rx_timer_handler
;
1593 hrtimer_init(&so
->txtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1594 so
->txtimer
.function
= isotp_tx_timer_handler
;
1596 init_waitqueue_head(&so
->wait
);
1597 spin_lock_init(&so
->rx_lock
);
1599 spin_lock(&isotp_notifier_lock
);
1600 list_add_tail(&so
->notifier
, &isotp_notifier_list
);
1601 spin_unlock(&isotp_notifier_lock
);
1606 static int isotp_sock_no_ioctlcmd(struct socket
*sock
, unsigned int cmd
,
1609 /* no ioctls for socket layer -> hand it down to NIC layer */
1610 return -ENOIOCTLCMD
;
1613 static const struct proto_ops isotp_ops
= {
1615 .release
= isotp_release
,
1617 .connect
= sock_no_connect
,
1618 .socketpair
= sock_no_socketpair
,
1619 .accept
= sock_no_accept
,
1620 .getname
= isotp_getname
,
1621 .poll
= datagram_poll
,
1622 .ioctl
= isotp_sock_no_ioctlcmd
,
1623 .gettstamp
= sock_gettstamp
,
1624 .listen
= sock_no_listen
,
1625 .shutdown
= sock_no_shutdown
,
1626 .setsockopt
= isotp_setsockopt
,
1627 .getsockopt
= isotp_getsockopt
,
1628 .sendmsg
= isotp_sendmsg
,
1629 .recvmsg
= isotp_recvmsg
,
1630 .mmap
= sock_no_mmap
,
1631 .sendpage
= sock_no_sendpage
,
1634 static struct proto isotp_proto __read_mostly
= {
1635 .name
= "CAN_ISOTP",
1636 .owner
= THIS_MODULE
,
1637 .obj_size
= sizeof(struct isotp_sock
),
1641 static const struct can_proto isotp_can_proto
= {
1643 .protocol
= CAN_ISOTP
,
1645 .prot
= &isotp_proto
,
1648 static struct notifier_block canisotp_notifier
= {
1649 .notifier_call
= isotp_notifier
1652 static __init
int isotp_module_init(void)
1656 pr_info("can: isotp protocol\n");
1658 err
= can_proto_register(&isotp_can_proto
);
1660 pr_err("can: registration of isotp protocol failed %pe\n", ERR_PTR(err
));
1662 register_netdevice_notifier(&canisotp_notifier
);
1667 static __exit
void isotp_module_exit(void)
1669 can_proto_unregister(&isotp_can_proto
);
1670 unregister_netdevice_notifier(&canisotp_notifier
);
1673 module_init(isotp_module_init
);
1674 module_exit(isotp_module_exit
);