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 set the static buffer to
89 * something about 8 kbyte to be able to test this new functionality.
91 #define DEFAULT_MAX_PDU_SIZE 8300
93 /* maximum PDU size before ISO 15765-2:2016 extension was 4095 */
94 #define MAX_12BIT_PDU_SIZE 4095
96 /* limit the isotp pdu size from the optional module parameter to 1MByte */
97 #define MAX_PDU_SIZE (1025 * 1024U)
99 static unsigned int max_pdu_size __read_mostly
= DEFAULT_MAX_PDU_SIZE
;
100 module_param(max_pdu_size
, uint
, 0444);
101 MODULE_PARM_DESC(max_pdu_size
, "maximum isotp pdu size (default "
102 __stringify(DEFAULT_MAX_PDU_SIZE
) ")");
104 /* N_PCI type values in bits 7-4 of N_PCI bytes */
105 #define N_PCI_SF 0x00 /* single frame */
106 #define N_PCI_FF 0x10 /* first frame */
107 #define N_PCI_CF 0x20 /* consecutive frame */
108 #define N_PCI_FC 0x30 /* flow control */
110 #define N_PCI_SZ 1 /* size of the PCI byte #1 */
111 #define SF_PCI_SZ4 1 /* size of SingleFrame PCI including 4 bit SF_DL */
112 #define SF_PCI_SZ8 2 /* size of SingleFrame PCI including 8 bit SF_DL */
113 #define FF_PCI_SZ12 2 /* size of FirstFrame PCI including 12 bit FF_DL */
114 #define FF_PCI_SZ32 6 /* size of FirstFrame PCI including 32 bit FF_DL */
115 #define FC_CONTENT_SZ 3 /* flow control content size in byte (FS/BS/STmin) */
117 #define ISOTP_CHECK_PADDING (CAN_ISOTP_CHK_PAD_LEN | CAN_ISOTP_CHK_PAD_DATA)
118 #define ISOTP_ALL_BC_FLAGS (CAN_ISOTP_SF_BROADCAST | CAN_ISOTP_CF_BROADCAST)
120 /* Flow Status given in FC frame */
121 #define ISOTP_FC_CTS 0 /* clear to send */
122 #define ISOTP_FC_WT 1 /* wait */
123 #define ISOTP_FC_OVFLW 2 /* overflow */
125 #define ISOTP_FC_TIMEOUT 1 /* 1 sec */
126 #define ISOTP_ECHO_TIMEOUT 2 /* 2 secs */
146 u8 sbuf
[DEFAULT_MAX_PDU_SIZE
];
156 ktime_t lastrxcf_tstamp
;
157 struct hrtimer rxtimer
, txtimer
, txfrtimer
;
158 struct can_isotp_options opt
;
159 struct can_isotp_fc_options rxfc
, txfc
;
160 struct can_isotp_ll_options ll
;
164 u32 cfecho
; /* consecutive frame echo tag */
166 struct list_head notifier
;
167 wait_queue_head_t wait
;
168 spinlock_t rx_lock
; /* protect single thread state machine */
171 static LIST_HEAD(isotp_notifier_list
);
172 static DEFINE_SPINLOCK(isotp_notifier_lock
);
173 static struct isotp_sock
*isotp_busy_notifier
;
175 static inline struct isotp_sock
*isotp_sk(const struct sock
*sk
)
177 return (struct isotp_sock
*)sk
;
180 static u32
isotp_bc_flags(struct isotp_sock
*so
)
182 return so
->opt
.flags
& ISOTP_ALL_BC_FLAGS
;
185 static bool isotp_register_rxid(struct isotp_sock
*so
)
187 /* no broadcast modes => register rx_id for FC frame reception */
188 return (isotp_bc_flags(so
) == 0);
191 static enum hrtimer_restart
isotp_rx_timer_handler(struct hrtimer
*hrtimer
)
193 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
195 struct sock
*sk
= &so
->sk
;
197 if (so
->rx
.state
== ISOTP_WAIT_DATA
) {
198 /* we did not get new data frames in time */
200 /* report 'connection timed out' */
201 sk
->sk_err
= ETIMEDOUT
;
202 if (!sock_flag(sk
, SOCK_DEAD
))
206 so
->rx
.state
= ISOTP_IDLE
;
209 return HRTIMER_NORESTART
;
212 static int isotp_send_fc(struct sock
*sk
, int ae
, u8 flowstatus
)
214 struct net_device
*dev
;
215 struct sk_buff
*nskb
;
216 struct canfd_frame
*ncf
;
217 struct isotp_sock
*so
= isotp_sk(sk
);
220 nskb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
), gfp_any());
224 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
230 can_skb_reserve(nskb
);
231 can_skb_prv(nskb
)->ifindex
= dev
->ifindex
;
232 can_skb_prv(nskb
)->skbcnt
= 0;
235 can_skb_set_owner(nskb
, sk
);
236 ncf
= (struct canfd_frame
*)nskb
->data
;
237 skb_put_zero(nskb
, so
->ll
.mtu
);
239 /* create & send flow control reply */
240 ncf
->can_id
= so
->txid
;
242 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
243 memset(ncf
->data
, so
->opt
.txpad_content
, CAN_MAX_DLEN
);
244 ncf
->len
= CAN_MAX_DLEN
;
246 ncf
->len
= ae
+ FC_CONTENT_SZ
;
249 ncf
->data
[ae
] = N_PCI_FC
| flowstatus
;
250 ncf
->data
[ae
+ 1] = so
->rxfc
.bs
;
251 ncf
->data
[ae
+ 2] = so
->rxfc
.stmin
;
254 ncf
->data
[0] = so
->opt
.ext_address
;
256 ncf
->flags
= so
->ll
.tx_flags
;
258 can_send_ret
= can_send(nskb
, 1);
260 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
261 __func__
, ERR_PTR(can_send_ret
));
265 /* reset blocksize counter */
268 /* reset last CF frame rx timestamp for rx stmin enforcement */
269 so
->lastrxcf_tstamp
= ktime_set(0, 0);
271 /* start rx timeout watchdog */
272 hrtimer_start(&so
->rxtimer
, ktime_set(ISOTP_FC_TIMEOUT
, 0),
273 HRTIMER_MODE_REL_SOFT
);
277 static void isotp_rcv_skb(struct sk_buff
*skb
, struct sock
*sk
)
279 struct sockaddr_can
*addr
= (struct sockaddr_can
*)skb
->cb
;
281 BUILD_BUG_ON(sizeof(skb
->cb
) < sizeof(struct sockaddr_can
));
283 memset(addr
, 0, sizeof(*addr
));
284 addr
->can_family
= AF_CAN
;
285 addr
->can_ifindex
= skb
->dev
->ifindex
;
287 if (sock_queue_rcv_skb(sk
, skb
) < 0)
291 static u8
padlen(u8 datalen
)
293 static const u8 plen
[] = {
294 8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */
295 12, 12, 12, 12, /* 9 - 12 */
296 16, 16, 16, 16, /* 13 - 16 */
297 20, 20, 20, 20, /* 17 - 20 */
298 24, 24, 24, 24, /* 21 - 24 */
299 32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */
300 48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */
301 48, 48, 48, 48, 48, 48, 48, 48 /* 41 - 48 */
307 return plen
[datalen
];
310 /* check for length optimization and return 1/true when the check fails */
311 static int check_optimized(struct canfd_frame
*cf
, int start_index
)
313 /* for CAN_DL <= 8 the start_index is equal to the CAN_DL as the
314 * padding would start at this point. E.g. if the padding would
315 * start at cf.data[7] cf->len has to be 7 to be optimal.
316 * Note: The data[] index starts with zero.
318 if (cf
->len
<= CAN_MAX_DLEN
)
319 return (cf
->len
!= start_index
);
321 /* This relation is also valid in the non-linear DLC range, where
322 * we need to take care of the minimal next possible CAN_DL.
323 * The correct check would be (padlen(cf->len) != padlen(start_index)).
324 * But as cf->len can only take discrete values from 12, .., 64 at this
325 * point the padlen(cf->len) is always equal to cf->len.
327 return (cf
->len
!= padlen(start_index
));
330 /* check padding and return 1/true when the check fails */
331 static int check_pad(struct isotp_sock
*so
, struct canfd_frame
*cf
,
332 int start_index
, u8 content
)
336 /* no RX_PADDING value => check length of optimized frame length */
337 if (!(so
->opt
.flags
& CAN_ISOTP_RX_PADDING
)) {
338 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
)
339 return check_optimized(cf
, start_index
);
341 /* no valid test against empty value => ignore frame */
345 /* check datalength of correctly padded CAN frame */
346 if ((so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
) &&
347 cf
->len
!= padlen(cf
->len
))
350 /* check padding content */
351 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_DATA
) {
352 for (i
= start_index
; i
< cf
->len
; i
++)
353 if (cf
->data
[i
] != content
)
359 static void isotp_send_cframe(struct isotp_sock
*so
);
361 static int isotp_rcv_fc(struct isotp_sock
*so
, struct canfd_frame
*cf
, int ae
)
363 struct sock
*sk
= &so
->sk
;
365 if (so
->tx
.state
!= ISOTP_WAIT_FC
&&
366 so
->tx
.state
!= ISOTP_WAIT_FIRST_FC
)
369 hrtimer_cancel(&so
->txtimer
);
371 if ((cf
->len
< ae
+ FC_CONTENT_SZ
) ||
372 ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
373 check_pad(so
, cf
, ae
+ FC_CONTENT_SZ
, so
->opt
.rxpad_content
))) {
374 /* malformed PDU - report 'not a data message' */
375 sk
->sk_err
= EBADMSG
;
376 if (!sock_flag(sk
, SOCK_DEAD
))
379 so
->tx
.state
= ISOTP_IDLE
;
380 wake_up_interruptible(&so
->wait
);
384 /* get communication parameters only from the first FC frame */
385 if (so
->tx
.state
== ISOTP_WAIT_FIRST_FC
) {
386 so
->txfc
.bs
= cf
->data
[ae
+ 1];
387 so
->txfc
.stmin
= cf
->data
[ae
+ 2];
389 /* fix wrong STmin values according spec */
390 if (so
->txfc
.stmin
> 0x7F &&
391 (so
->txfc
.stmin
< 0xF1 || so
->txfc
.stmin
> 0xF9))
392 so
->txfc
.stmin
= 0x7F;
394 so
->tx_gap
= ktime_set(0, 0);
395 /* add transmission time for CAN frame N_As */
396 so
->tx_gap
= ktime_add_ns(so
->tx_gap
, so
->frame_txtime
);
397 /* add waiting time for consecutive frames N_Cs */
398 if (so
->opt
.flags
& CAN_ISOTP_FORCE_TXSTMIN
)
399 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
401 else if (so
->txfc
.stmin
< 0x80)
402 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
403 so
->txfc
.stmin
* 1000000);
405 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
406 (so
->txfc
.stmin
- 0xF0)
408 so
->tx
.state
= ISOTP_WAIT_FC
;
411 switch (cf
->data
[ae
] & 0x0F) {
414 so
->tx
.state
= ISOTP_SENDING
;
415 /* send CF frame and enable echo timeout handling */
416 hrtimer_start(&so
->txtimer
, ktime_set(ISOTP_ECHO_TIMEOUT
, 0),
417 HRTIMER_MODE_REL_SOFT
);
418 isotp_send_cframe(so
);
422 /* start timer to wait for next FC frame */
423 hrtimer_start(&so
->txtimer
, ktime_set(ISOTP_FC_TIMEOUT
, 0),
424 HRTIMER_MODE_REL_SOFT
);
428 /* overflow on receiver side - report 'message too long' */
429 sk
->sk_err
= EMSGSIZE
;
430 if (!sock_flag(sk
, SOCK_DEAD
))
435 /* stop this tx job */
436 so
->tx
.state
= ISOTP_IDLE
;
437 wake_up_interruptible(&so
->wait
);
442 static int isotp_rcv_sf(struct sock
*sk
, struct canfd_frame
*cf
, int pcilen
,
443 struct sk_buff
*skb
, int len
)
445 struct isotp_sock
*so
= isotp_sk(sk
);
446 struct sk_buff
*nskb
;
448 hrtimer_cancel(&so
->rxtimer
);
449 so
->rx
.state
= ISOTP_IDLE
;
451 if (!len
|| len
> cf
->len
- pcilen
)
454 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
455 check_pad(so
, cf
, pcilen
+ len
, so
->opt
.rxpad_content
)) {
456 /* malformed PDU - report 'not a data message' */
457 sk
->sk_err
= EBADMSG
;
458 if (!sock_flag(sk
, SOCK_DEAD
))
463 nskb
= alloc_skb(len
, gfp_any());
467 memcpy(skb_put(nskb
, len
), &cf
->data
[pcilen
], len
);
469 nskb
->tstamp
= skb
->tstamp
;
470 nskb
->dev
= skb
->dev
;
471 isotp_rcv_skb(nskb
, sk
);
475 static int isotp_rcv_ff(struct sock
*sk
, struct canfd_frame
*cf
, int ae
)
477 struct isotp_sock
*so
= isotp_sk(sk
);
482 hrtimer_cancel(&so
->rxtimer
);
483 so
->rx
.state
= ISOTP_IDLE
;
485 /* get the used sender LL_DL from the (first) CAN frame data length */
486 so
->rx
.ll_dl
= padlen(cf
->len
);
488 /* the first frame has to use the entire frame up to LL_DL length */
489 if (cf
->len
!= so
->rx
.ll_dl
)
493 so
->rx
.len
= (cf
->data
[ae
] & 0x0F) << 8;
494 so
->rx
.len
+= cf
->data
[ae
+ 1];
496 /* Check for FF_DL escape sequence supporting 32 bit PDU length */
498 ff_pci_sz
= FF_PCI_SZ12
;
500 /* FF_DL = 0 => get real length from next 4 bytes */
501 so
->rx
.len
= cf
->data
[ae
+ 2] << 24;
502 so
->rx
.len
+= cf
->data
[ae
+ 3] << 16;
503 so
->rx
.len
+= cf
->data
[ae
+ 4] << 8;
504 so
->rx
.len
+= cf
->data
[ae
+ 5];
505 ff_pci_sz
= FF_PCI_SZ32
;
508 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
509 off
= (so
->rx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
511 if (so
->rx
.len
+ ae
+ off
+ ff_pci_sz
< so
->rx
.ll_dl
)
514 /* PDU size > default => try max_pdu_size */
515 if (so
->rx
.len
> so
->rx
.buflen
&& so
->rx
.buflen
< max_pdu_size
) {
516 u8
*newbuf
= kmalloc(max_pdu_size
, GFP_ATOMIC
);
520 so
->rx
.buflen
= max_pdu_size
;
524 if (so
->rx
.len
> so
->rx
.buflen
) {
525 /* send FC frame with overflow status */
526 isotp_send_fc(sk
, ae
, ISOTP_FC_OVFLW
);
530 /* copy the first received data bytes */
532 for (i
= ae
+ ff_pci_sz
; i
< so
->rx
.ll_dl
; i
++)
533 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
535 /* initial setup for this pdu reception */
537 so
->rx
.state
= ISOTP_WAIT_DATA
;
539 /* no creation of flow control frames */
540 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
543 /* send our first FC frame */
544 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
548 static int isotp_rcv_cf(struct sock
*sk
, struct canfd_frame
*cf
, int ae
,
551 struct isotp_sock
*so
= isotp_sk(sk
);
552 struct sk_buff
*nskb
;
555 if (so
->rx
.state
!= ISOTP_WAIT_DATA
)
558 /* drop if timestamp gap is less than force_rx_stmin nano secs */
559 if (so
->opt
.flags
& CAN_ISOTP_FORCE_RXSTMIN
) {
560 if (ktime_to_ns(ktime_sub(skb
->tstamp
, so
->lastrxcf_tstamp
)) <
564 so
->lastrxcf_tstamp
= skb
->tstamp
;
567 hrtimer_cancel(&so
->rxtimer
);
569 /* CFs are never longer than the FF */
570 if (cf
->len
> so
->rx
.ll_dl
)
573 /* CFs have usually the LL_DL length */
574 if (cf
->len
< so
->rx
.ll_dl
) {
575 /* this is only allowed for the last CF */
576 if (so
->rx
.len
- so
->rx
.idx
> so
->rx
.ll_dl
- ae
- N_PCI_SZ
)
580 if ((cf
->data
[ae
] & 0x0F) != so
->rx
.sn
) {
581 /* wrong sn detected - report 'illegal byte sequence' */
583 if (!sock_flag(sk
, SOCK_DEAD
))
587 so
->rx
.state
= ISOTP_IDLE
;
593 for (i
= ae
+ N_PCI_SZ
; i
< cf
->len
; i
++) {
594 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
595 if (so
->rx
.idx
>= so
->rx
.len
)
599 if (so
->rx
.idx
>= so
->rx
.len
) {
601 so
->rx
.state
= ISOTP_IDLE
;
603 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
604 check_pad(so
, cf
, i
+ 1, so
->opt
.rxpad_content
)) {
605 /* malformed PDU - report 'not a data message' */
606 sk
->sk_err
= EBADMSG
;
607 if (!sock_flag(sk
, SOCK_DEAD
))
612 nskb
= alloc_skb(so
->rx
.len
, gfp_any());
616 memcpy(skb_put(nskb
, so
->rx
.len
), so
->rx
.buf
,
619 nskb
->tstamp
= skb
->tstamp
;
620 nskb
->dev
= skb
->dev
;
621 isotp_rcv_skb(nskb
, sk
);
625 /* perform blocksize handling, if enabled */
626 if (!so
->rxfc
.bs
|| ++so
->rx
.bs
< so
->rxfc
.bs
) {
627 /* start rx timeout watchdog */
628 hrtimer_start(&so
->rxtimer
, ktime_set(ISOTP_FC_TIMEOUT
, 0),
629 HRTIMER_MODE_REL_SOFT
);
633 /* no creation of flow control frames */
634 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
637 /* we reached the specified blocksize so->rxfc.bs */
638 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
642 static void isotp_rcv(struct sk_buff
*skb
, void *data
)
644 struct sock
*sk
= (struct sock
*)data
;
645 struct isotp_sock
*so
= isotp_sk(sk
);
646 struct canfd_frame
*cf
;
647 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
648 u8 n_pci_type
, sf_dl
;
650 /* Strictly receive only frames with the configured MTU size
651 * => clear separation of CAN2.0 / CAN FD transport channels
653 if (skb
->len
!= so
->ll
.mtu
)
656 cf
= (struct canfd_frame
*)skb
->data
;
658 /* if enabled: check reception of my configured extended address */
659 if (ae
&& cf
->data
[0] != so
->opt
.rx_ext_address
)
662 n_pci_type
= cf
->data
[ae
] & 0xF0;
664 /* Make sure the state changes and data structures stay consistent at
665 * CAN frame reception time. This locking is not needed in real world
666 * use cases but the inconsistency can be triggered with syzkaller.
668 spin_lock(&so
->rx_lock
);
670 if (so
->opt
.flags
& CAN_ISOTP_HALF_DUPLEX
) {
671 /* check rx/tx path half duplex expectations */
672 if ((so
->tx
.state
!= ISOTP_IDLE
&& n_pci_type
!= N_PCI_FC
) ||
673 (so
->rx
.state
!= ISOTP_IDLE
&& n_pci_type
== N_PCI_FC
))
677 switch (n_pci_type
) {
679 /* tx path: flow control frame containing the FC parameters */
680 isotp_rcv_fc(so
, cf
, ae
);
684 /* rx path: single frame
686 * As we do not have a rx.ll_dl configuration, we can only test
687 * if the CAN frames payload length matches the LL_DL == 8
688 * requirements - no matter if it's CAN 2.0 or CAN FD
691 /* get the SF_DL from the N_PCI byte */
692 sf_dl
= cf
->data
[ae
] & 0x0F;
694 if (cf
->len
<= CAN_MAX_DLEN
) {
695 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ4
+ ae
, skb
, sf_dl
);
697 if (can_is_canfd_skb(skb
)) {
698 /* We have a CAN FD frame and CAN_DL is greater than 8:
699 * Only frames with the SF_DL == 0 ESC value are valid.
701 * If so take care of the increased SF PCI size
702 * (SF_PCI_SZ8) to point to the message content behind
703 * the extended SF PCI info and get the real SF_DL
704 * length value from the formerly first data byte.
707 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ8
+ ae
, skb
,
708 cf
->data
[SF_PCI_SZ4
+ ae
]);
714 /* rx path: first frame */
715 isotp_rcv_ff(sk
, cf
, ae
);
719 /* rx path: consecutive frame */
720 isotp_rcv_cf(sk
, cf
, ae
, skb
);
725 spin_unlock(&so
->rx_lock
);
728 static void isotp_fill_dataframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
731 int pcilen
= N_PCI_SZ
+ ae
+ off
;
732 int space
= so
->tx
.ll_dl
- pcilen
;
733 int num
= min_t(int, so
->tx
.len
- so
->tx
.idx
, space
);
736 cf
->can_id
= so
->txid
;
737 cf
->len
= num
+ pcilen
;
740 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
741 /* user requested padding */
742 cf
->len
= padlen(cf
->len
);
743 memset(cf
->data
, so
->opt
.txpad_content
, cf
->len
);
744 } else if (cf
->len
> CAN_MAX_DLEN
) {
745 /* mandatory padding for CAN FD frames */
746 cf
->len
= padlen(cf
->len
);
747 memset(cf
->data
, CAN_ISOTP_DEFAULT_PAD_CONTENT
,
752 for (i
= 0; i
< num
; i
++)
753 cf
->data
[pcilen
+ i
] = so
->tx
.buf
[so
->tx
.idx
++];
756 cf
->data
[0] = so
->opt
.ext_address
;
759 static void isotp_send_cframe(struct isotp_sock
*so
)
761 struct sock
*sk
= &so
->sk
;
763 struct net_device
*dev
;
764 struct canfd_frame
*cf
;
766 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
768 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
772 skb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
), GFP_ATOMIC
);
778 can_skb_reserve(skb
);
779 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
780 can_skb_prv(skb
)->skbcnt
= 0;
782 cf
= (struct canfd_frame
*)skb
->data
;
783 skb_put_zero(skb
, so
->ll
.mtu
);
785 /* create consecutive frame */
786 isotp_fill_dataframe(cf
, so
, ae
, 0);
788 /* place consecutive frame N_PCI in appropriate index */
789 cf
->data
[ae
] = N_PCI_CF
| so
->tx
.sn
++;
793 cf
->flags
= so
->ll
.tx_flags
;
796 can_skb_set_owner(skb
, sk
);
798 /* cfecho should have been zero'ed by init/isotp_rcv_echo() */
800 pr_notice_once("can-isotp: cfecho is %08X != 0\n", so
->cfecho
);
802 /* set consecutive frame echo tag */
803 so
->cfecho
= *(u32
*)cf
->data
;
805 /* send frame with local echo enabled */
806 can_send_ret
= can_send(skb
, 1);
808 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
809 __func__
, ERR_PTR(can_send_ret
));
810 if (can_send_ret
== -ENOBUFS
)
811 pr_notice_once("can-isotp: tx queue is full\n");
816 static void isotp_create_fframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
822 cf
->can_id
= so
->txid
;
823 cf
->len
= so
->tx
.ll_dl
;
825 cf
->data
[0] = so
->opt
.ext_address
;
827 /* create N_PCI bytes with 12/32 bit FF_DL data length */
828 if (so
->tx
.len
> MAX_12BIT_PDU_SIZE
) {
829 /* use 32 bit FF_DL notation */
830 cf
->data
[ae
] = N_PCI_FF
;
831 cf
->data
[ae
+ 1] = 0;
832 cf
->data
[ae
+ 2] = (u8
)(so
->tx
.len
>> 24) & 0xFFU
;
833 cf
->data
[ae
+ 3] = (u8
)(so
->tx
.len
>> 16) & 0xFFU
;
834 cf
->data
[ae
+ 4] = (u8
)(so
->tx
.len
>> 8) & 0xFFU
;
835 cf
->data
[ae
+ 5] = (u8
)so
->tx
.len
& 0xFFU
;
836 ff_pci_sz
= FF_PCI_SZ32
;
838 /* use 12 bit FF_DL notation */
839 cf
->data
[ae
] = (u8
)(so
->tx
.len
>> 8) | N_PCI_FF
;
840 cf
->data
[ae
+ 1] = (u8
)so
->tx
.len
& 0xFFU
;
841 ff_pci_sz
= FF_PCI_SZ12
;
844 /* add first data bytes depending on ae */
845 for (i
= ae
+ ff_pci_sz
; i
< so
->tx
.ll_dl
; i
++)
846 cf
->data
[i
] = so
->tx
.buf
[so
->tx
.idx
++];
851 static void isotp_rcv_echo(struct sk_buff
*skb
, void *data
)
853 struct sock
*sk
= (struct sock
*)data
;
854 struct isotp_sock
*so
= isotp_sk(sk
);
855 struct canfd_frame
*cf
= (struct canfd_frame
*)skb
->data
;
857 /* only handle my own local echo CF/SF skb's (no FF!) */
858 if (skb
->sk
!= sk
|| so
->cfecho
!= *(u32
*)cf
->data
)
861 /* cancel local echo timeout */
862 hrtimer_cancel(&so
->txtimer
);
864 /* local echo skb with consecutive frame has been consumed */
867 if (so
->tx
.idx
>= so
->tx
.len
) {
869 so
->tx
.state
= ISOTP_IDLE
;
870 wake_up_interruptible(&so
->wait
);
874 if (so
->txfc
.bs
&& so
->tx
.bs
>= so
->txfc
.bs
) {
875 /* stop and wait for FC with timeout */
876 so
->tx
.state
= ISOTP_WAIT_FC
;
877 hrtimer_start(&so
->txtimer
, ktime_set(ISOTP_FC_TIMEOUT
, 0),
878 HRTIMER_MODE_REL_SOFT
);
882 /* no gap between data frames needed => use burst mode */
884 /* enable echo timeout handling */
885 hrtimer_start(&so
->txtimer
, ktime_set(ISOTP_ECHO_TIMEOUT
, 0),
886 HRTIMER_MODE_REL_SOFT
);
887 isotp_send_cframe(so
);
891 /* start timer to send next consecutive frame with correct delay */
892 hrtimer_start(&so
->txfrtimer
, so
->tx_gap
, HRTIMER_MODE_REL_SOFT
);
895 static enum hrtimer_restart
isotp_tx_timer_handler(struct hrtimer
*hrtimer
)
897 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
899 struct sock
*sk
= &so
->sk
;
901 /* don't handle timeouts in IDLE or SHUTDOWN state */
902 if (so
->tx
.state
== ISOTP_IDLE
|| so
->tx
.state
== ISOTP_SHUTDOWN
)
903 return HRTIMER_NORESTART
;
905 /* we did not get any flow control or echo frame in time */
907 /* report 'communication error on send' */
909 if (!sock_flag(sk
, SOCK_DEAD
))
913 so
->tx
.state
= ISOTP_IDLE
;
914 wake_up_interruptible(&so
->wait
);
916 return HRTIMER_NORESTART
;
919 static enum hrtimer_restart
isotp_txfr_timer_handler(struct hrtimer
*hrtimer
)
921 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
924 /* start echo timeout handling and cover below protocol error */
925 hrtimer_start(&so
->txtimer
, ktime_set(ISOTP_ECHO_TIMEOUT
, 0),
926 HRTIMER_MODE_REL_SOFT
);
928 /* cfecho should be consumed by isotp_rcv_echo() here */
929 if (so
->tx
.state
== ISOTP_SENDING
&& !so
->cfecho
)
930 isotp_send_cframe(so
);
932 return HRTIMER_NORESTART
;
935 static int isotp_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
)
937 struct sock
*sk
= sock
->sk
;
938 struct isotp_sock
*so
= isotp_sk(sk
);
940 struct net_device
*dev
;
941 struct canfd_frame
*cf
;
942 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
943 int wait_tx_done
= (so
->opt
.flags
& CAN_ISOTP_WAIT_TX_DONE
) ? 1 : 0;
944 s64 hrtimer_sec
= ISOTP_ECHO_TIMEOUT
;
948 if (!so
->bound
|| so
->tx
.state
== ISOTP_SHUTDOWN
)
949 return -EADDRNOTAVAIL
;
951 while (cmpxchg(&so
->tx
.state
, ISOTP_IDLE
, ISOTP_SENDING
) != ISOTP_IDLE
) {
952 /* we do not support multiple buffers - for now */
953 if (msg
->msg_flags
& MSG_DONTWAIT
)
956 if (so
->tx
.state
== ISOTP_SHUTDOWN
)
957 return -EADDRNOTAVAIL
;
959 /* wait for complete transmission of current pdu */
960 err
= wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
965 /* PDU size > default => try max_pdu_size */
966 if (size
> so
->tx
.buflen
&& so
->tx
.buflen
< max_pdu_size
) {
967 u8
*newbuf
= kmalloc(max_pdu_size
, GFP_KERNEL
);
971 so
->tx
.buflen
= max_pdu_size
;
975 if (!size
|| size
> so
->tx
.buflen
) {
980 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
981 off
= (so
->tx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
983 /* does the given data fit into a single frame for SF_BROADCAST? */
984 if ((isotp_bc_flags(so
) == CAN_ISOTP_SF_BROADCAST
) &&
985 (size
> so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
)) {
990 err
= memcpy_from_msg(so
->tx
.buf
, msg
, size
);
994 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
1000 skb
= sock_alloc_send_skb(sk
, so
->ll
.mtu
+ sizeof(struct can_skb_priv
),
1001 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
1007 can_skb_reserve(skb
);
1008 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
1009 can_skb_prv(skb
)->skbcnt
= 0;
1014 cf
= (struct canfd_frame
*)skb
->data
;
1015 skb_put_zero(skb
, so
->ll
.mtu
);
1017 /* cfecho should have been zero'ed by init / former isotp_rcv_echo() */
1019 pr_notice_once("can-isotp: uninit cfecho %08X\n", so
->cfecho
);
1021 /* check for single frame transmission depending on TX_DL */
1022 if (size
<= so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
) {
1023 /* The message size generally fits into a SingleFrame - good.
1025 * SF_DL ESC offset optimization:
1027 * When TX_DL is greater 8 but the message would still fit
1028 * into a 8 byte CAN frame, we can omit the offset.
1029 * This prevents a protocol caused length extension from
1030 * CAN_DL = 8 to CAN_DL = 12 due to the SF_SL ESC handling.
1032 if (size
<= CAN_MAX_DLEN
- SF_PCI_SZ4
- ae
)
1035 isotp_fill_dataframe(cf
, so
, ae
, off
);
1037 /* place single frame N_PCI w/o length in appropriate index */
1038 cf
->data
[ae
] = N_PCI_SF
;
1040 /* place SF_DL size value depending on the SF_DL ESC offset */
1042 cf
->data
[SF_PCI_SZ4
+ ae
] = size
;
1044 cf
->data
[ae
] |= size
;
1046 /* set CF echo tag for isotp_rcv_echo() (SF-mode) */
1047 so
->cfecho
= *(u32
*)cf
->data
;
1049 /* send first frame */
1051 isotp_create_fframe(cf
, so
, ae
);
1053 if (isotp_bc_flags(so
) == CAN_ISOTP_CF_BROADCAST
) {
1054 /* set timer for FC-less operation (STmin = 0) */
1055 if (so
->opt
.flags
& CAN_ISOTP_FORCE_TXSTMIN
)
1056 so
->tx_gap
= ktime_set(0, so
->force_tx_stmin
);
1058 so
->tx_gap
= ktime_set(0, so
->frame_txtime
);
1060 /* disable wait for FCs due to activated block size */
1063 /* set CF echo tag for isotp_rcv_echo() (CF-mode) */
1064 so
->cfecho
= *(u32
*)cf
->data
;
1066 /* standard flow control check */
1067 so
->tx
.state
= ISOTP_WAIT_FIRST_FC
;
1069 /* start timeout for FC */
1070 hrtimer_sec
= ISOTP_FC_TIMEOUT
;
1072 /* no CF echo tag for isotp_rcv_echo() (FF-mode) */
1077 hrtimer_start(&so
->txtimer
, ktime_set(hrtimer_sec
, 0),
1078 HRTIMER_MODE_REL_SOFT
);
1080 /* send the first or only CAN frame */
1081 cf
->flags
= so
->ll
.tx_flags
;
1085 err
= can_send(skb
, 1);
1088 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
1089 __func__
, ERR_PTR(err
));
1091 /* no transmission -> no timeout monitoring */
1092 hrtimer_cancel(&so
->txtimer
);
1094 /* reset consecutive frame echo tag */
1101 /* wait for complete transmission of current pdu */
1102 err
= wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
1104 goto err_event_drop
;
1106 err
= sock_error(sk
);
1114 /* got signal: force tx state machine to be idle */
1115 so
->tx
.state
= ISOTP_IDLE
;
1116 hrtimer_cancel(&so
->txfrtimer
);
1117 hrtimer_cancel(&so
->txtimer
);
1119 /* drop this PDU and unlock a potential wait queue */
1120 so
->tx
.state
= ISOTP_IDLE
;
1121 wake_up_interruptible(&so
->wait
);
1126 static int isotp_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1129 struct sock
*sk
= sock
->sk
;
1130 struct sk_buff
*skb
;
1131 struct isotp_sock
*so
= isotp_sk(sk
);
1134 if (flags
& ~(MSG_DONTWAIT
| MSG_TRUNC
| MSG_PEEK
| MSG_CMSG_COMPAT
))
1138 return -EADDRNOTAVAIL
;
1140 skb
= skb_recv_datagram(sk
, flags
, &ret
);
1144 if (size
< skb
->len
)
1145 msg
->msg_flags
|= MSG_TRUNC
;
1149 ret
= memcpy_to_msg(msg
, skb
->data
, size
);
1153 sock_recv_cmsgs(msg
, sk
, skb
);
1155 if (msg
->msg_name
) {
1156 __sockaddr_check_size(ISOTP_MIN_NAMELEN
);
1157 msg
->msg_namelen
= ISOTP_MIN_NAMELEN
;
1158 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
1161 /* set length of return value */
1162 ret
= (flags
& MSG_TRUNC
) ? skb
->len
: size
;
1165 skb_free_datagram(sk
, skb
);
1170 static int isotp_release(struct socket
*sock
)
1172 struct sock
*sk
= sock
->sk
;
1173 struct isotp_sock
*so
;
1182 /* wait for complete transmission of current pdu */
1183 while (wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
) == 0 &&
1184 cmpxchg(&so
->tx
.state
, ISOTP_IDLE
, ISOTP_SHUTDOWN
) != ISOTP_IDLE
)
1187 /* force state machines to be idle also when a signal occurred */
1188 so
->tx
.state
= ISOTP_SHUTDOWN
;
1189 so
->rx
.state
= ISOTP_IDLE
;
1191 spin_lock(&isotp_notifier_lock
);
1192 while (isotp_busy_notifier
== so
) {
1193 spin_unlock(&isotp_notifier_lock
);
1194 schedule_timeout_uninterruptible(1);
1195 spin_lock(&isotp_notifier_lock
);
1197 list_del(&so
->notifier
);
1198 spin_unlock(&isotp_notifier_lock
);
1202 /* remove current filters & unregister */
1205 struct net_device
*dev
;
1207 dev
= dev_get_by_index(net
, so
->ifindex
);
1209 if (isotp_register_rxid(so
))
1210 can_rx_unregister(net
, dev
, so
->rxid
,
1211 SINGLE_MASK(so
->rxid
),
1214 can_rx_unregister(net
, dev
, so
->txid
,
1215 SINGLE_MASK(so
->txid
),
1216 isotp_rcv_echo
, sk
);
1223 hrtimer_cancel(&so
->txfrtimer
);
1224 hrtimer_cancel(&so
->txtimer
);
1225 hrtimer_cancel(&so
->rxtimer
);
1230 if (so
->rx
.buf
!= so
->rx
.sbuf
)
1233 if (so
->tx
.buf
!= so
->tx
.sbuf
)
1245 static int isotp_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int len
)
1247 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1248 struct sock
*sk
= sock
->sk
;
1249 struct isotp_sock
*so
= isotp_sk(sk
);
1250 struct net
*net
= sock_net(sk
);
1252 struct net_device
*dev
;
1253 canid_t tx_id
= addr
->can_addr
.tp
.tx_id
;
1254 canid_t rx_id
= addr
->can_addr
.tp
.rx_id
;
1256 int notify_enetdown
= 0;
1258 if (len
< ISOTP_MIN_NAMELEN
)
1261 if (addr
->can_family
!= AF_CAN
)
1264 /* sanitize tx CAN identifier */
1265 if (tx_id
& CAN_EFF_FLAG
)
1266 tx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1268 tx_id
&= CAN_SFF_MASK
;
1270 /* give feedback on wrong CAN-ID value */
1271 if (tx_id
!= addr
->can_addr
.tp
.tx_id
)
1274 /* sanitize rx CAN identifier (if needed) */
1275 if (isotp_register_rxid(so
)) {
1276 if (rx_id
& CAN_EFF_FLAG
)
1277 rx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1279 rx_id
&= CAN_SFF_MASK
;
1281 /* give feedback on wrong CAN-ID value */
1282 if (rx_id
!= addr
->can_addr
.tp
.rx_id
)
1286 if (!addr
->can_ifindex
)
1296 /* ensure different CAN IDs when the rx_id is to be registered */
1297 if (isotp_register_rxid(so
) && rx_id
== tx_id
) {
1298 err
= -EADDRNOTAVAIL
;
1302 dev
= dev_get_by_index(net
, addr
->can_ifindex
);
1307 if (dev
->type
!= ARPHRD_CAN
) {
1312 if (dev
->mtu
< so
->ll
.mtu
) {
1317 if (!(dev
->flags
& IFF_UP
))
1318 notify_enetdown
= 1;
1320 ifindex
= dev
->ifindex
;
1322 if (isotp_register_rxid(so
))
1323 can_rx_register(net
, dev
, rx_id
, SINGLE_MASK(rx_id
),
1324 isotp_rcv
, sk
, "isotp", sk
);
1326 /* no consecutive frame echo skb in flight */
1329 /* register for echo skb's */
1330 can_rx_register(net
, dev
, tx_id
, SINGLE_MASK(tx_id
),
1331 isotp_rcv_echo
, sk
, "isotpe", sk
);
1335 /* switch to new settings */
1336 so
->ifindex
= ifindex
;
1344 if (notify_enetdown
) {
1345 sk
->sk_err
= ENETDOWN
;
1346 if (!sock_flag(sk
, SOCK_DEAD
))
1347 sk_error_report(sk
);
1353 static int isotp_getname(struct socket
*sock
, struct sockaddr
*uaddr
, int peer
)
1355 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1356 struct sock
*sk
= sock
->sk
;
1357 struct isotp_sock
*so
= isotp_sk(sk
);
1362 memset(addr
, 0, ISOTP_MIN_NAMELEN
);
1363 addr
->can_family
= AF_CAN
;
1364 addr
->can_ifindex
= so
->ifindex
;
1365 addr
->can_addr
.tp
.rx_id
= so
->rxid
;
1366 addr
->can_addr
.tp
.tx_id
= so
->txid
;
1368 return ISOTP_MIN_NAMELEN
;
1371 static int isotp_setsockopt_locked(struct socket
*sock
, int level
, int optname
,
1372 sockptr_t optval
, unsigned int optlen
)
1374 struct sock
*sk
= sock
->sk
;
1375 struct isotp_sock
*so
= isotp_sk(sk
);
1382 case CAN_ISOTP_OPTS
:
1383 if (optlen
!= sizeof(struct can_isotp_options
))
1386 if (copy_from_sockptr(&so
->opt
, optval
, optlen
))
1389 /* no separate rx_ext_address is given => use ext_address */
1390 if (!(so
->opt
.flags
& CAN_ISOTP_RX_EXT_ADDR
))
1391 so
->opt
.rx_ext_address
= so
->opt
.ext_address
;
1393 /* these broadcast flags are not allowed together */
1394 if (isotp_bc_flags(so
) == ISOTP_ALL_BC_FLAGS
) {
1395 /* CAN_ISOTP_SF_BROADCAST is prioritized */
1396 so
->opt
.flags
&= ~CAN_ISOTP_CF_BROADCAST
;
1398 /* give user feedback on wrong config attempt */
1402 /* check for frame_txtime changes (0 => no changes) */
1403 if (so
->opt
.frame_txtime
) {
1404 if (so
->opt
.frame_txtime
== CAN_ISOTP_FRAME_TXTIME_ZERO
)
1405 so
->frame_txtime
= 0;
1407 so
->frame_txtime
= so
->opt
.frame_txtime
;
1411 case CAN_ISOTP_RECV_FC
:
1412 if (optlen
!= sizeof(struct can_isotp_fc_options
))
1415 if (copy_from_sockptr(&so
->rxfc
, optval
, optlen
))
1419 case CAN_ISOTP_TX_STMIN
:
1420 if (optlen
!= sizeof(u32
))
1423 if (copy_from_sockptr(&so
->force_tx_stmin
, optval
, optlen
))
1427 case CAN_ISOTP_RX_STMIN
:
1428 if (optlen
!= sizeof(u32
))
1431 if (copy_from_sockptr(&so
->force_rx_stmin
, optval
, optlen
))
1435 case CAN_ISOTP_LL_OPTS
:
1436 if (optlen
== sizeof(struct can_isotp_ll_options
)) {
1437 struct can_isotp_ll_options ll
;
1439 if (copy_from_sockptr(&ll
, optval
, optlen
))
1442 /* check for correct ISO 11898-1 DLC data length */
1443 if (ll
.tx_dl
!= padlen(ll
.tx_dl
))
1446 if (ll
.mtu
!= CAN_MTU
&& ll
.mtu
!= CANFD_MTU
)
1449 if (ll
.mtu
== CAN_MTU
&&
1450 (ll
.tx_dl
> CAN_MAX_DLEN
|| ll
.tx_flags
!= 0))
1453 memcpy(&so
->ll
, &ll
, sizeof(ll
));
1455 /* set ll_dl for tx path to similar place as for rx */
1456 so
->tx
.ll_dl
= ll
.tx_dl
;
1469 static int isotp_setsockopt(struct socket
*sock
, int level
, int optname
,
1470 sockptr_t optval
, unsigned int optlen
)
1473 struct sock
*sk
= sock
->sk
;
1476 if (level
!= SOL_CAN_ISOTP
)
1480 ret
= isotp_setsockopt_locked(sock
, level
, optname
, optval
, optlen
);
1485 static int isotp_getsockopt(struct socket
*sock
, int level
, int optname
,
1486 char __user
*optval
, int __user
*optlen
)
1488 struct sock
*sk
= sock
->sk
;
1489 struct isotp_sock
*so
= isotp_sk(sk
);
1493 if (level
!= SOL_CAN_ISOTP
)
1495 if (get_user(len
, optlen
))
1501 case CAN_ISOTP_OPTS
:
1502 len
= min_t(int, len
, sizeof(struct can_isotp_options
));
1506 case CAN_ISOTP_RECV_FC
:
1507 len
= min_t(int, len
, sizeof(struct can_isotp_fc_options
));
1511 case CAN_ISOTP_TX_STMIN
:
1512 len
= min_t(int, len
, sizeof(u32
));
1513 val
= &so
->force_tx_stmin
;
1516 case CAN_ISOTP_RX_STMIN
:
1517 len
= min_t(int, len
, sizeof(u32
));
1518 val
= &so
->force_rx_stmin
;
1521 case CAN_ISOTP_LL_OPTS
:
1522 len
= min_t(int, len
, sizeof(struct can_isotp_ll_options
));
1527 return -ENOPROTOOPT
;
1530 if (put_user(len
, optlen
))
1532 if (copy_to_user(optval
, val
, len
))
1537 static void isotp_notify(struct isotp_sock
*so
, unsigned long msg
,
1538 struct net_device
*dev
)
1540 struct sock
*sk
= &so
->sk
;
1542 if (!net_eq(dev_net(dev
), sock_net(sk
)))
1545 if (so
->ifindex
!= dev
->ifindex
)
1549 case NETDEV_UNREGISTER
:
1551 /* remove current filters & unregister */
1553 if (isotp_register_rxid(so
))
1554 can_rx_unregister(dev_net(dev
), dev
, so
->rxid
,
1555 SINGLE_MASK(so
->rxid
),
1558 can_rx_unregister(dev_net(dev
), dev
, so
->txid
,
1559 SINGLE_MASK(so
->txid
),
1560 isotp_rcv_echo
, sk
);
1567 sk
->sk_err
= ENODEV
;
1568 if (!sock_flag(sk
, SOCK_DEAD
))
1569 sk_error_report(sk
);
1573 sk
->sk_err
= ENETDOWN
;
1574 if (!sock_flag(sk
, SOCK_DEAD
))
1575 sk_error_report(sk
);
1580 static int isotp_notifier(struct notifier_block
*nb
, unsigned long msg
,
1583 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1585 if (dev
->type
!= ARPHRD_CAN
)
1587 if (msg
!= NETDEV_UNREGISTER
&& msg
!= NETDEV_DOWN
)
1589 if (unlikely(isotp_busy_notifier
)) /* Check for reentrant bug. */
1592 spin_lock(&isotp_notifier_lock
);
1593 list_for_each_entry(isotp_busy_notifier
, &isotp_notifier_list
, notifier
) {
1594 spin_unlock(&isotp_notifier_lock
);
1595 isotp_notify(isotp_busy_notifier
, msg
, dev
);
1596 spin_lock(&isotp_notifier_lock
);
1598 isotp_busy_notifier
= NULL
;
1599 spin_unlock(&isotp_notifier_lock
);
1603 static int isotp_init(struct sock
*sk
)
1605 struct isotp_sock
*so
= isotp_sk(sk
);
1610 so
->opt
.flags
= CAN_ISOTP_DEFAULT_FLAGS
;
1611 so
->opt
.ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1612 so
->opt
.rx_ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1613 so
->opt
.rxpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1614 so
->opt
.txpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1615 so
->opt
.frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1616 so
->frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1617 so
->rxfc
.bs
= CAN_ISOTP_DEFAULT_RECV_BS
;
1618 so
->rxfc
.stmin
= CAN_ISOTP_DEFAULT_RECV_STMIN
;
1619 so
->rxfc
.wftmax
= CAN_ISOTP_DEFAULT_RECV_WFTMAX
;
1620 so
->ll
.mtu
= CAN_ISOTP_DEFAULT_LL_MTU
;
1621 so
->ll
.tx_dl
= CAN_ISOTP_DEFAULT_LL_TX_DL
;
1622 so
->ll
.tx_flags
= CAN_ISOTP_DEFAULT_LL_TX_FLAGS
;
1624 /* set ll_dl for tx path to similar place as for rx */
1625 so
->tx
.ll_dl
= so
->ll
.tx_dl
;
1627 so
->rx
.state
= ISOTP_IDLE
;
1628 so
->tx
.state
= ISOTP_IDLE
;
1630 so
->rx
.buf
= so
->rx
.sbuf
;
1631 so
->tx
.buf
= so
->tx
.sbuf
;
1632 so
->rx
.buflen
= ARRAY_SIZE(so
->rx
.sbuf
);
1633 so
->tx
.buflen
= ARRAY_SIZE(so
->tx
.sbuf
);
1635 hrtimer_init(&so
->rxtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1636 so
->rxtimer
.function
= isotp_rx_timer_handler
;
1637 hrtimer_init(&so
->txtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1638 so
->txtimer
.function
= isotp_tx_timer_handler
;
1639 hrtimer_init(&so
->txfrtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1640 so
->txfrtimer
.function
= isotp_txfr_timer_handler
;
1642 init_waitqueue_head(&so
->wait
);
1643 spin_lock_init(&so
->rx_lock
);
1645 spin_lock(&isotp_notifier_lock
);
1646 list_add_tail(&so
->notifier
, &isotp_notifier_list
);
1647 spin_unlock(&isotp_notifier_lock
);
1652 static __poll_t
isotp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
1654 struct sock
*sk
= sock
->sk
;
1655 struct isotp_sock
*so
= isotp_sk(sk
);
1657 __poll_t mask
= datagram_poll(file
, sock
, wait
);
1658 poll_wait(file
, &so
->wait
, wait
);
1660 /* Check for false positives due to TX state */
1661 if ((mask
& EPOLLWRNORM
) && (so
->tx
.state
!= ISOTP_IDLE
))
1662 mask
&= ~(EPOLLOUT
| EPOLLWRNORM
);
1667 static int isotp_sock_no_ioctlcmd(struct socket
*sock
, unsigned int cmd
,
1670 /* no ioctls for socket layer -> hand it down to NIC layer */
1671 return -ENOIOCTLCMD
;
1674 static const struct proto_ops isotp_ops
= {
1676 .release
= isotp_release
,
1678 .connect
= sock_no_connect
,
1679 .socketpair
= sock_no_socketpair
,
1680 .accept
= sock_no_accept
,
1681 .getname
= isotp_getname
,
1683 .ioctl
= isotp_sock_no_ioctlcmd
,
1684 .gettstamp
= sock_gettstamp
,
1685 .listen
= sock_no_listen
,
1686 .shutdown
= sock_no_shutdown
,
1687 .setsockopt
= isotp_setsockopt
,
1688 .getsockopt
= isotp_getsockopt
,
1689 .sendmsg
= isotp_sendmsg
,
1690 .recvmsg
= isotp_recvmsg
,
1691 .mmap
= sock_no_mmap
,
1694 static struct proto isotp_proto __read_mostly
= {
1695 .name
= "CAN_ISOTP",
1696 .owner
= THIS_MODULE
,
1697 .obj_size
= sizeof(struct isotp_sock
),
1701 static const struct can_proto isotp_can_proto
= {
1703 .protocol
= CAN_ISOTP
,
1705 .prot
= &isotp_proto
,
1708 static struct notifier_block canisotp_notifier
= {
1709 .notifier_call
= isotp_notifier
1712 static __init
int isotp_module_init(void)
1716 max_pdu_size
= max_t(unsigned int, max_pdu_size
, MAX_12BIT_PDU_SIZE
);
1717 max_pdu_size
= min_t(unsigned int, max_pdu_size
, MAX_PDU_SIZE
);
1719 pr_info("can: isotp protocol (max_pdu_size %d)\n", max_pdu_size
);
1721 err
= can_proto_register(&isotp_can_proto
);
1723 pr_err("can: registration of isotp protocol failed %pe\n", ERR_PTR(err
));
1725 register_netdevice_notifier(&canisotp_notifier
);
1730 static __exit
void isotp_module_exit(void)
1732 can_proto_unregister(&isotp_can_proto
);
1733 unregister_netdevice_notifier(&canisotp_notifier
);
1736 module_init(isotp_module_init
);
1737 module_exit(isotp_module_exit
);