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')
17 * - take care of the tx-queue-len as traffic shaping is still on the TODO list
19 * Copyright (c) 2020 Volkswagen Group Electronic Research
20 * All rights reserved.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the above copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. Neither the name of Volkswagen nor the names of its contributors
31 * may be used to endorse or promote products derived from this software
32 * without specific prior written permission.
34 * Alternatively, provided that this notice is retained in full, this
35 * software may be distributed under the terms of the GNU General
36 * Public License ("GPL") version 2, in which case the provisions of the
37 * GPL apply INSTEAD OF those given above.
39 * The provided data structures and external interfaces from this code
40 * are not restricted to be used by modules with a GPL compatible license.
42 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
43 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
44 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
45 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
46 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
47 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
48 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
49 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
50 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
51 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
52 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
56 #include <linux/module.h>
57 #include <linux/init.h>
58 #include <linux/interrupt.h>
59 #include <linux/spinlock.h>
60 #include <linux/hrtimer.h>
61 #include <linux/wait.h>
62 #include <linux/uio.h>
63 #include <linux/net.h>
64 #include <linux/netdevice.h>
65 #include <linux/socket.h>
66 #include <linux/if_arp.h>
67 #include <linux/skbuff.h>
68 #include <linux/can.h>
69 #include <linux/can/core.h>
70 #include <linux/can/skb.h>
71 #include <linux/can/isotp.h>
72 #include <linux/slab.h>
74 #include <net/net_namespace.h>
76 MODULE_DESCRIPTION("PF_CAN isotp 15765-2:2016 protocol");
77 MODULE_LICENSE("Dual BSD/GPL");
78 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
79 MODULE_ALIAS("can-proto-6");
81 #define ISOTP_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_addr.tp)
83 #define SINGLE_MASK(id) (((id) & CAN_EFF_FLAG) ? \
84 (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \
85 (CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG))
87 /* ISO 15765-2:2016 supports more than 4095 byte per ISO PDU as the FF_DL can
88 * take full 32 bit values (4 Gbyte). We would need some good concept to handle
89 * this between user space and kernel space. For now increase the static buffer
90 * to something about 8 kbyte to be able to test this new functionality.
92 #define MAX_MSG_LENGTH 8200
94 /* N_PCI type values in bits 7-4 of N_PCI bytes */
95 #define N_PCI_SF 0x00 /* single frame */
96 #define N_PCI_FF 0x10 /* first frame */
97 #define N_PCI_CF 0x20 /* consecutive frame */
98 #define N_PCI_FC 0x30 /* flow control */
100 #define N_PCI_SZ 1 /* size of the PCI byte #1 */
101 #define SF_PCI_SZ4 1 /* size of SingleFrame PCI including 4 bit SF_DL */
102 #define SF_PCI_SZ8 2 /* size of SingleFrame PCI including 8 bit SF_DL */
103 #define FF_PCI_SZ12 2 /* size of FirstFrame PCI including 12 bit FF_DL */
104 #define FF_PCI_SZ32 6 /* size of FirstFrame PCI including 32 bit FF_DL */
105 #define FC_CONTENT_SZ 3 /* flow control content size in byte (FS/BS/STmin) */
107 #define ISOTP_CHECK_PADDING (CAN_ISOTP_CHK_PAD_LEN | CAN_ISOTP_CHK_PAD_DATA)
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
;
148 struct list_head notifier
;
149 wait_queue_head_t wait
;
150 spinlock_t rx_lock
; /* protect single thread state machine */
153 static LIST_HEAD(isotp_notifier_list
);
154 static DEFINE_SPINLOCK(isotp_notifier_lock
);
155 static struct isotp_sock
*isotp_busy_notifier
;
157 static inline struct isotp_sock
*isotp_sk(const struct sock
*sk
)
159 return (struct isotp_sock
*)sk
;
162 static enum hrtimer_restart
isotp_rx_timer_handler(struct hrtimer
*hrtimer
)
164 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
166 struct sock
*sk
= &so
->sk
;
168 if (so
->rx
.state
== ISOTP_WAIT_DATA
) {
169 /* we did not get new data frames in time */
171 /* report 'connection timed out' */
172 sk
->sk_err
= ETIMEDOUT
;
173 if (!sock_flag(sk
, SOCK_DEAD
))
177 so
->rx
.state
= ISOTP_IDLE
;
180 return HRTIMER_NORESTART
;
183 static int isotp_send_fc(struct sock
*sk
, int ae
, u8 flowstatus
)
185 struct net_device
*dev
;
186 struct sk_buff
*nskb
;
187 struct canfd_frame
*ncf
;
188 struct isotp_sock
*so
= isotp_sk(sk
);
191 nskb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
), gfp_any());
195 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
201 can_skb_reserve(nskb
);
202 can_skb_prv(nskb
)->ifindex
= dev
->ifindex
;
203 can_skb_prv(nskb
)->skbcnt
= 0;
206 can_skb_set_owner(nskb
, sk
);
207 ncf
= (struct canfd_frame
*)nskb
->data
;
208 skb_put_zero(nskb
, so
->ll
.mtu
);
210 /* create & send flow control reply */
211 ncf
->can_id
= so
->txid
;
213 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
214 memset(ncf
->data
, so
->opt
.txpad_content
, CAN_MAX_DLEN
);
215 ncf
->len
= CAN_MAX_DLEN
;
217 ncf
->len
= ae
+ FC_CONTENT_SZ
;
220 ncf
->data
[ae
] = N_PCI_FC
| flowstatus
;
221 ncf
->data
[ae
+ 1] = so
->rxfc
.bs
;
222 ncf
->data
[ae
+ 2] = so
->rxfc
.stmin
;
225 ncf
->data
[0] = so
->opt
.ext_address
;
227 ncf
->flags
= so
->ll
.tx_flags
;
229 can_send_ret
= can_send(nskb
, 1);
231 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
232 __func__
, ERR_PTR(can_send_ret
));
236 /* reset blocksize counter */
239 /* reset last CF frame rx timestamp for rx stmin enforcement */
240 so
->lastrxcf_tstamp
= ktime_set(0, 0);
242 /* start rx timeout watchdog */
243 hrtimer_start(&so
->rxtimer
, ktime_set(1, 0), HRTIMER_MODE_REL_SOFT
);
247 static void isotp_rcv_skb(struct sk_buff
*skb
, struct sock
*sk
)
249 struct sockaddr_can
*addr
= (struct sockaddr_can
*)skb
->cb
;
251 BUILD_BUG_ON(sizeof(skb
->cb
) < sizeof(struct sockaddr_can
));
253 memset(addr
, 0, sizeof(*addr
));
254 addr
->can_family
= AF_CAN
;
255 addr
->can_ifindex
= skb
->dev
->ifindex
;
257 if (sock_queue_rcv_skb(sk
, skb
) < 0)
261 static u8
padlen(u8 datalen
)
263 static const u8 plen
[] = {
264 8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */
265 12, 12, 12, 12, /* 9 - 12 */
266 16, 16, 16, 16, /* 13 - 16 */
267 20, 20, 20, 20, /* 17 - 20 */
268 24, 24, 24, 24, /* 21 - 24 */
269 32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */
270 48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */
271 48, 48, 48, 48, 48, 48, 48, 48 /* 41 - 48 */
277 return plen
[datalen
];
280 /* check for length optimization and return 1/true when the check fails */
281 static int check_optimized(struct canfd_frame
*cf
, int start_index
)
283 /* for CAN_DL <= 8 the start_index is equal to the CAN_DL as the
284 * padding would start at this point. E.g. if the padding would
285 * start at cf.data[7] cf->len has to be 7 to be optimal.
286 * Note: The data[] index starts with zero.
288 if (cf
->len
<= CAN_MAX_DLEN
)
289 return (cf
->len
!= start_index
);
291 /* This relation is also valid in the non-linear DLC range, where
292 * we need to take care of the minimal next possible CAN_DL.
293 * The correct check would be (padlen(cf->len) != padlen(start_index)).
294 * But as cf->len can only take discrete values from 12, .., 64 at this
295 * point the padlen(cf->len) is always equal to cf->len.
297 return (cf
->len
!= padlen(start_index
));
300 /* check padding and return 1/true when the check fails */
301 static int check_pad(struct isotp_sock
*so
, struct canfd_frame
*cf
,
302 int start_index
, u8 content
)
306 /* no RX_PADDING value => check length of optimized frame length */
307 if (!(so
->opt
.flags
& CAN_ISOTP_RX_PADDING
)) {
308 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
)
309 return check_optimized(cf
, start_index
);
311 /* no valid test against empty value => ignore frame */
315 /* check datalength of correctly padded CAN frame */
316 if ((so
->opt
.flags
& CAN_ISOTP_CHK_PAD_LEN
) &&
317 cf
->len
!= padlen(cf
->len
))
320 /* check padding content */
321 if (so
->opt
.flags
& CAN_ISOTP_CHK_PAD_DATA
) {
322 for (i
= start_index
; i
< cf
->len
; i
++)
323 if (cf
->data
[i
] != content
)
329 static int isotp_rcv_fc(struct isotp_sock
*so
, struct canfd_frame
*cf
, int ae
)
331 struct sock
*sk
= &so
->sk
;
333 if (so
->tx
.state
!= ISOTP_WAIT_FC
&&
334 so
->tx
.state
!= ISOTP_WAIT_FIRST_FC
)
337 hrtimer_cancel(&so
->txtimer
);
339 if ((cf
->len
< ae
+ FC_CONTENT_SZ
) ||
340 ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
341 check_pad(so
, cf
, ae
+ FC_CONTENT_SZ
, so
->opt
.rxpad_content
))) {
342 /* malformed PDU - report 'not a data message' */
343 sk
->sk_err
= EBADMSG
;
344 if (!sock_flag(sk
, SOCK_DEAD
))
347 so
->tx
.state
= ISOTP_IDLE
;
348 wake_up_interruptible(&so
->wait
);
352 /* get communication parameters only from the first FC frame */
353 if (so
->tx
.state
== ISOTP_WAIT_FIRST_FC
) {
354 so
->txfc
.bs
= cf
->data
[ae
+ 1];
355 so
->txfc
.stmin
= cf
->data
[ae
+ 2];
357 /* fix wrong STmin values according spec */
358 if (so
->txfc
.stmin
> 0x7F &&
359 (so
->txfc
.stmin
< 0xF1 || so
->txfc
.stmin
> 0xF9))
360 so
->txfc
.stmin
= 0x7F;
362 so
->tx_gap
= ktime_set(0, 0);
363 /* add transmission time for CAN frame N_As */
364 so
->tx_gap
= ktime_add_ns(so
->tx_gap
, so
->frame_txtime
);
365 /* add waiting time for consecutive frames N_Cs */
366 if (so
->opt
.flags
& CAN_ISOTP_FORCE_TXSTMIN
)
367 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
369 else if (so
->txfc
.stmin
< 0x80)
370 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
371 so
->txfc
.stmin
* 1000000);
373 so
->tx_gap
= ktime_add_ns(so
->tx_gap
,
374 (so
->txfc
.stmin
- 0xF0)
376 so
->tx
.state
= ISOTP_WAIT_FC
;
379 switch (cf
->data
[ae
] & 0x0F) {
382 so
->tx
.state
= ISOTP_SENDING
;
383 /* start cyclic timer for sending CF frame */
384 hrtimer_start(&so
->txtimer
, so
->tx_gap
,
385 HRTIMER_MODE_REL_SOFT
);
389 /* start timer to wait for next FC frame */
390 hrtimer_start(&so
->txtimer
, ktime_set(1, 0),
391 HRTIMER_MODE_REL_SOFT
);
395 /* overflow on receiver side - report 'message too long' */
396 sk
->sk_err
= EMSGSIZE
;
397 if (!sock_flag(sk
, SOCK_DEAD
))
402 /* stop this tx job */
403 so
->tx
.state
= ISOTP_IDLE
;
404 wake_up_interruptible(&so
->wait
);
409 static int isotp_rcv_sf(struct sock
*sk
, struct canfd_frame
*cf
, int pcilen
,
410 struct sk_buff
*skb
, int len
)
412 struct isotp_sock
*so
= isotp_sk(sk
);
413 struct sk_buff
*nskb
;
415 hrtimer_cancel(&so
->rxtimer
);
416 so
->rx
.state
= ISOTP_IDLE
;
418 if (!len
|| len
> cf
->len
- pcilen
)
421 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
422 check_pad(so
, cf
, pcilen
+ len
, so
->opt
.rxpad_content
)) {
423 /* malformed PDU - report 'not a data message' */
424 sk
->sk_err
= EBADMSG
;
425 if (!sock_flag(sk
, SOCK_DEAD
))
430 nskb
= alloc_skb(len
, gfp_any());
434 memcpy(skb_put(nskb
, len
), &cf
->data
[pcilen
], len
);
436 nskb
->tstamp
= skb
->tstamp
;
437 nskb
->dev
= skb
->dev
;
438 isotp_rcv_skb(nskb
, sk
);
442 static int isotp_rcv_ff(struct sock
*sk
, struct canfd_frame
*cf
, int ae
)
444 struct isotp_sock
*so
= isotp_sk(sk
);
449 hrtimer_cancel(&so
->rxtimer
);
450 so
->rx
.state
= ISOTP_IDLE
;
452 /* get the used sender LL_DL from the (first) CAN frame data length */
453 so
->rx
.ll_dl
= padlen(cf
->len
);
455 /* the first frame has to use the entire frame up to LL_DL length */
456 if (cf
->len
!= so
->rx
.ll_dl
)
460 so
->rx
.len
= (cf
->data
[ae
] & 0x0F) << 8;
461 so
->rx
.len
+= cf
->data
[ae
+ 1];
463 /* Check for FF_DL escape sequence supporting 32 bit PDU length */
465 ff_pci_sz
= FF_PCI_SZ12
;
467 /* FF_DL = 0 => get real length from next 4 bytes */
468 so
->rx
.len
= cf
->data
[ae
+ 2] << 24;
469 so
->rx
.len
+= cf
->data
[ae
+ 3] << 16;
470 so
->rx
.len
+= cf
->data
[ae
+ 4] << 8;
471 so
->rx
.len
+= cf
->data
[ae
+ 5];
472 ff_pci_sz
= FF_PCI_SZ32
;
475 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
476 off
= (so
->rx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
478 if (so
->rx
.len
+ ae
+ off
+ ff_pci_sz
< so
->rx
.ll_dl
)
481 if (so
->rx
.len
> MAX_MSG_LENGTH
) {
482 /* send FC frame with overflow status */
483 isotp_send_fc(sk
, ae
, ISOTP_FC_OVFLW
);
487 /* copy the first received data bytes */
489 for (i
= ae
+ ff_pci_sz
; i
< so
->rx
.ll_dl
; i
++)
490 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
492 /* initial setup for this pdu reception */
494 so
->rx
.state
= ISOTP_WAIT_DATA
;
496 /* no creation of flow control frames */
497 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
500 /* send our first FC frame */
501 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
505 static int isotp_rcv_cf(struct sock
*sk
, struct canfd_frame
*cf
, int ae
,
508 struct isotp_sock
*so
= isotp_sk(sk
);
509 struct sk_buff
*nskb
;
512 if (so
->rx
.state
!= ISOTP_WAIT_DATA
)
515 /* drop if timestamp gap is less than force_rx_stmin nano secs */
516 if (so
->opt
.flags
& CAN_ISOTP_FORCE_RXSTMIN
) {
517 if (ktime_to_ns(ktime_sub(skb
->tstamp
, so
->lastrxcf_tstamp
)) <
521 so
->lastrxcf_tstamp
= skb
->tstamp
;
524 hrtimer_cancel(&so
->rxtimer
);
526 /* CFs are never longer than the FF */
527 if (cf
->len
> so
->rx
.ll_dl
)
530 /* CFs have usually the LL_DL length */
531 if (cf
->len
< so
->rx
.ll_dl
) {
532 /* this is only allowed for the last CF */
533 if (so
->rx
.len
- so
->rx
.idx
> so
->rx
.ll_dl
- ae
- N_PCI_SZ
)
537 if ((cf
->data
[ae
] & 0x0F) != so
->rx
.sn
) {
538 /* wrong sn detected - report 'illegal byte sequence' */
540 if (!sock_flag(sk
, SOCK_DEAD
))
544 so
->rx
.state
= ISOTP_IDLE
;
550 for (i
= ae
+ N_PCI_SZ
; i
< cf
->len
; i
++) {
551 so
->rx
.buf
[so
->rx
.idx
++] = cf
->data
[i
];
552 if (so
->rx
.idx
>= so
->rx
.len
)
556 if (so
->rx
.idx
>= so
->rx
.len
) {
558 so
->rx
.state
= ISOTP_IDLE
;
560 if ((so
->opt
.flags
& ISOTP_CHECK_PADDING
) &&
561 check_pad(so
, cf
, i
+ 1, so
->opt
.rxpad_content
)) {
562 /* malformed PDU - report 'not a data message' */
563 sk
->sk_err
= EBADMSG
;
564 if (!sock_flag(sk
, SOCK_DEAD
))
569 nskb
= alloc_skb(so
->rx
.len
, gfp_any());
573 memcpy(skb_put(nskb
, so
->rx
.len
), so
->rx
.buf
,
576 nskb
->tstamp
= skb
->tstamp
;
577 nskb
->dev
= skb
->dev
;
578 isotp_rcv_skb(nskb
, sk
);
582 /* perform blocksize handling, if enabled */
583 if (!so
->rxfc
.bs
|| ++so
->rx
.bs
< so
->rxfc
.bs
) {
584 /* start rx timeout watchdog */
585 hrtimer_start(&so
->rxtimer
, ktime_set(1, 0),
586 HRTIMER_MODE_REL_SOFT
);
590 /* no creation of flow control frames */
591 if (so
->opt
.flags
& CAN_ISOTP_LISTEN_MODE
)
594 /* we reached the specified blocksize so->rxfc.bs */
595 isotp_send_fc(sk
, ae
, ISOTP_FC_CTS
);
599 static void isotp_rcv(struct sk_buff
*skb
, void *data
)
601 struct sock
*sk
= (struct sock
*)data
;
602 struct isotp_sock
*so
= isotp_sk(sk
);
603 struct canfd_frame
*cf
;
604 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
605 u8 n_pci_type
, sf_dl
;
607 /* Strictly receive only frames with the configured MTU size
608 * => clear separation of CAN2.0 / CAN FD transport channels
610 if (skb
->len
!= so
->ll
.mtu
)
613 cf
= (struct canfd_frame
*)skb
->data
;
615 /* if enabled: check reception of my configured extended address */
616 if (ae
&& cf
->data
[0] != so
->opt
.rx_ext_address
)
619 n_pci_type
= cf
->data
[ae
] & 0xF0;
621 /* Make sure the state changes and data structures stay consistent at
622 * CAN frame reception time. This locking is not needed in real world
623 * use cases but the inconsistency can be triggered with syzkaller.
625 spin_lock(&so
->rx_lock
);
627 if (so
->opt
.flags
& CAN_ISOTP_HALF_DUPLEX
) {
628 /* check rx/tx path half duplex expectations */
629 if ((so
->tx
.state
!= ISOTP_IDLE
&& n_pci_type
!= N_PCI_FC
) ||
630 (so
->rx
.state
!= ISOTP_IDLE
&& n_pci_type
== N_PCI_FC
))
634 switch (n_pci_type
) {
636 /* tx path: flow control frame containing the FC parameters */
637 isotp_rcv_fc(so
, cf
, ae
);
641 /* rx path: single frame
643 * As we do not have a rx.ll_dl configuration, we can only test
644 * if the CAN frames payload length matches the LL_DL == 8
645 * requirements - no matter if it's CAN 2.0 or CAN FD
648 /* get the SF_DL from the N_PCI byte */
649 sf_dl
= cf
->data
[ae
] & 0x0F;
651 if (cf
->len
<= CAN_MAX_DLEN
) {
652 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ4
+ ae
, skb
, sf_dl
);
654 if (skb
->len
== CANFD_MTU
) {
655 /* We have a CAN FD frame and CAN_DL is greater than 8:
656 * Only frames with the SF_DL == 0 ESC value are valid.
658 * If so take care of the increased SF PCI size
659 * (SF_PCI_SZ8) to point to the message content behind
660 * the extended SF PCI info and get the real SF_DL
661 * length value from the formerly first data byte.
664 isotp_rcv_sf(sk
, cf
, SF_PCI_SZ8
+ ae
, skb
,
665 cf
->data
[SF_PCI_SZ4
+ ae
]);
671 /* rx path: first frame */
672 isotp_rcv_ff(sk
, cf
, ae
);
676 /* rx path: consecutive frame */
677 isotp_rcv_cf(sk
, cf
, ae
, skb
);
682 spin_unlock(&so
->rx_lock
);
685 static void isotp_fill_dataframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
688 int pcilen
= N_PCI_SZ
+ ae
+ off
;
689 int space
= so
->tx
.ll_dl
- pcilen
;
690 int num
= min_t(int, so
->tx
.len
- so
->tx
.idx
, space
);
693 cf
->can_id
= so
->txid
;
694 cf
->len
= num
+ pcilen
;
697 if (so
->opt
.flags
& CAN_ISOTP_TX_PADDING
) {
698 /* user requested padding */
699 cf
->len
= padlen(cf
->len
);
700 memset(cf
->data
, so
->opt
.txpad_content
, cf
->len
);
701 } else if (cf
->len
> CAN_MAX_DLEN
) {
702 /* mandatory padding for CAN FD frames */
703 cf
->len
= padlen(cf
->len
);
704 memset(cf
->data
, CAN_ISOTP_DEFAULT_PAD_CONTENT
,
709 for (i
= 0; i
< num
; i
++)
710 cf
->data
[pcilen
+ i
] = so
->tx
.buf
[so
->tx
.idx
++];
713 cf
->data
[0] = so
->opt
.ext_address
;
716 static void isotp_create_fframe(struct canfd_frame
*cf
, struct isotp_sock
*so
,
722 cf
->can_id
= so
->txid
;
723 cf
->len
= so
->tx
.ll_dl
;
725 cf
->data
[0] = so
->opt
.ext_address
;
727 /* create N_PCI bytes with 12/32 bit FF_DL data length */
728 if (so
->tx
.len
> 4095) {
729 /* use 32 bit FF_DL notation */
730 cf
->data
[ae
] = N_PCI_FF
;
731 cf
->data
[ae
+ 1] = 0;
732 cf
->data
[ae
+ 2] = (u8
)(so
->tx
.len
>> 24) & 0xFFU
;
733 cf
->data
[ae
+ 3] = (u8
)(so
->tx
.len
>> 16) & 0xFFU
;
734 cf
->data
[ae
+ 4] = (u8
)(so
->tx
.len
>> 8) & 0xFFU
;
735 cf
->data
[ae
+ 5] = (u8
)so
->tx
.len
& 0xFFU
;
736 ff_pci_sz
= FF_PCI_SZ32
;
738 /* use 12 bit FF_DL notation */
739 cf
->data
[ae
] = (u8
)(so
->tx
.len
>> 8) | N_PCI_FF
;
740 cf
->data
[ae
+ 1] = (u8
)so
->tx
.len
& 0xFFU
;
741 ff_pci_sz
= FF_PCI_SZ12
;
744 /* add first data bytes depending on ae */
745 for (i
= ae
+ ff_pci_sz
; i
< so
->tx
.ll_dl
; i
++)
746 cf
->data
[i
] = so
->tx
.buf
[so
->tx
.idx
++];
749 so
->tx
.state
= ISOTP_WAIT_FIRST_FC
;
752 static enum hrtimer_restart
isotp_tx_timer_handler(struct hrtimer
*hrtimer
)
754 struct isotp_sock
*so
= container_of(hrtimer
, struct isotp_sock
,
756 struct sock
*sk
= &so
->sk
;
758 struct net_device
*dev
;
759 struct canfd_frame
*cf
;
760 enum hrtimer_restart restart
= HRTIMER_NORESTART
;
762 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
764 switch (so
->tx
.state
) {
766 case ISOTP_WAIT_FIRST_FC
:
768 /* we did not get any flow control frame in time */
770 /* report 'communication error on send' */
772 if (!sock_flag(sk
, SOCK_DEAD
))
776 so
->tx
.state
= ISOTP_IDLE
;
777 wake_up_interruptible(&so
->wait
);
782 /* push out the next segmented pdu */
783 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
788 skb
= alloc_skb(so
->ll
.mtu
+ sizeof(struct can_skb_priv
),
795 can_skb_reserve(skb
);
796 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
797 can_skb_prv(skb
)->skbcnt
= 0;
799 cf
= (struct canfd_frame
*)skb
->data
;
800 skb_put_zero(skb
, so
->ll
.mtu
);
802 /* create consecutive frame */
803 isotp_fill_dataframe(cf
, so
, ae
, 0);
805 /* place consecutive frame N_PCI in appropriate index */
806 cf
->data
[ae
] = N_PCI_CF
| so
->tx
.sn
++;
810 cf
->flags
= so
->ll
.tx_flags
;
813 can_skb_set_owner(skb
, sk
);
815 can_send_ret
= can_send(skb
, 1);
817 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
818 __func__
, ERR_PTR(can_send_ret
));
819 if (can_send_ret
== -ENOBUFS
)
820 pr_notice_once("can-isotp: tx queue is full, increasing txqueuelen may prevent this error\n");
822 if (so
->tx
.idx
>= so
->tx
.len
) {
824 so
->tx
.state
= ISOTP_IDLE
;
826 wake_up_interruptible(&so
->wait
);
830 if (so
->txfc
.bs
&& so
->tx
.bs
>= so
->txfc
.bs
) {
831 /* stop and wait for FC */
832 so
->tx
.state
= ISOTP_WAIT_FC
;
834 hrtimer_set_expires(&so
->txtimer
,
835 ktime_add(ktime_get(),
837 restart
= HRTIMER_RESTART
;
841 /* no gap between data frames needed => use burst mode */
845 /* start timer to send next data frame with correct delay */
847 hrtimer_set_expires(&so
->txtimer
,
848 ktime_add(ktime_get(), so
->tx_gap
));
849 restart
= HRTIMER_RESTART
;
859 static int isotp_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
)
861 struct sock
*sk
= sock
->sk
;
862 struct isotp_sock
*so
= isotp_sk(sk
);
863 u32 old_state
= so
->tx
.state
;
865 struct net_device
*dev
;
866 struct canfd_frame
*cf
;
867 int ae
= (so
->opt
.flags
& CAN_ISOTP_EXTEND_ADDR
) ? 1 : 0;
868 int wait_tx_done
= (so
->opt
.flags
& CAN_ISOTP_WAIT_TX_DONE
) ? 1 : 0;
873 return -EADDRNOTAVAIL
;
875 /* we do not support multiple buffers - for now */
876 if (cmpxchg(&so
->tx
.state
, ISOTP_IDLE
, ISOTP_SENDING
) != ISOTP_IDLE
||
877 wq_has_sleeper(&so
->wait
)) {
878 if (msg
->msg_flags
& MSG_DONTWAIT
) {
883 /* wait for complete transmission of current pdu */
884 err
= wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
889 if (!size
|| size
> MAX_MSG_LENGTH
) {
894 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */
895 off
= (so
->tx
.ll_dl
> CAN_MAX_DLEN
) ? 1 : 0;
897 /* does the given data fit into a single frame for SF_BROADCAST? */
898 if ((so
->opt
.flags
& CAN_ISOTP_SF_BROADCAST
) &&
899 (size
> so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
)) {
904 err
= memcpy_from_msg(so
->tx
.buf
, msg
, size
);
908 dev
= dev_get_by_index(sock_net(sk
), so
->ifindex
);
914 skb
= sock_alloc_send_skb(sk
, so
->ll
.mtu
+ sizeof(struct can_skb_priv
),
915 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
921 can_skb_reserve(skb
);
922 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
923 can_skb_prv(skb
)->skbcnt
= 0;
928 cf
= (struct canfd_frame
*)skb
->data
;
929 skb_put_zero(skb
, so
->ll
.mtu
);
931 /* check for single frame transmission depending on TX_DL */
932 if (size
<= so
->tx
.ll_dl
- SF_PCI_SZ4
- ae
- off
) {
933 /* The message size generally fits into a SingleFrame - good.
935 * SF_DL ESC offset optimization:
937 * When TX_DL is greater 8 but the message would still fit
938 * into a 8 byte CAN frame, we can omit the offset.
939 * This prevents a protocol caused length extension from
940 * CAN_DL = 8 to CAN_DL = 12 due to the SF_SL ESC handling.
942 if (size
<= CAN_MAX_DLEN
- SF_PCI_SZ4
- ae
)
945 isotp_fill_dataframe(cf
, so
, ae
, off
);
947 /* place single frame N_PCI w/o length in appropriate index */
948 cf
->data
[ae
] = N_PCI_SF
;
950 /* place SF_DL size value depending on the SF_DL ESC offset */
952 cf
->data
[SF_PCI_SZ4
+ ae
] = size
;
954 cf
->data
[ae
] |= size
;
956 so
->tx
.state
= ISOTP_IDLE
;
957 wake_up_interruptible(&so
->wait
);
959 /* don't enable wait queue for a single frame transmission */
962 /* send first frame and wait for FC */
964 isotp_create_fframe(cf
, so
, ae
);
966 /* start timeout for FC */
967 hrtimer_start(&so
->txtimer
, ktime_set(1, 0), HRTIMER_MODE_REL_SOFT
);
970 /* send the first or only CAN frame */
971 cf
->flags
= so
->ll
.tx_flags
;
975 err
= can_send(skb
, 1);
978 pr_notice_once("can-isotp: %s: can_send_ret %pe\n",
979 __func__
, ERR_PTR(err
));
984 /* wait for complete transmission of current pdu */
985 wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
994 /* drop this PDU and unlock a potential wait queue */
995 old_state
= ISOTP_IDLE
;
997 so
->tx
.state
= old_state
;
998 if (so
->tx
.state
== ISOTP_IDLE
)
999 wake_up_interruptible(&so
->wait
);
1004 static int isotp_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1007 struct sock
*sk
= sock
->sk
;
1008 struct sk_buff
*skb
;
1009 struct isotp_sock
*so
= isotp_sk(sk
);
1010 int noblock
= flags
& MSG_DONTWAIT
;
1013 if (flags
& ~(MSG_DONTWAIT
| MSG_TRUNC
| MSG_PEEK
))
1017 return -EADDRNOTAVAIL
;
1019 flags
&= ~MSG_DONTWAIT
;
1020 skb
= skb_recv_datagram(sk
, flags
, noblock
, &ret
);
1024 if (size
< skb
->len
)
1025 msg
->msg_flags
|= MSG_TRUNC
;
1029 ret
= memcpy_to_msg(msg
, skb
->data
, size
);
1033 sock_recv_timestamp(msg
, sk
, skb
);
1035 if (msg
->msg_name
) {
1036 __sockaddr_check_size(ISOTP_MIN_NAMELEN
);
1037 msg
->msg_namelen
= ISOTP_MIN_NAMELEN
;
1038 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
1041 /* set length of return value */
1042 ret
= (flags
& MSG_TRUNC
) ? skb
->len
: size
;
1045 skb_free_datagram(sk
, skb
);
1050 static int isotp_release(struct socket
*sock
)
1052 struct sock
*sk
= sock
->sk
;
1053 struct isotp_sock
*so
;
1062 /* wait for complete transmission of current pdu */
1063 wait_event_interruptible(so
->wait
, so
->tx
.state
== ISOTP_IDLE
);
1065 spin_lock(&isotp_notifier_lock
);
1066 while (isotp_busy_notifier
== so
) {
1067 spin_unlock(&isotp_notifier_lock
);
1068 schedule_timeout_uninterruptible(1);
1069 spin_lock(&isotp_notifier_lock
);
1071 list_del(&so
->notifier
);
1072 spin_unlock(&isotp_notifier_lock
);
1076 /* remove current filters & unregister */
1077 if (so
->bound
&& (!(so
->opt
.flags
& CAN_ISOTP_SF_BROADCAST
))) {
1079 struct net_device
*dev
;
1081 dev
= dev_get_by_index(net
, so
->ifindex
);
1083 can_rx_unregister(net
, dev
, so
->rxid
,
1084 SINGLE_MASK(so
->rxid
),
1092 hrtimer_cancel(&so
->txtimer
);
1093 hrtimer_cancel(&so
->rxtimer
);
1107 static int isotp_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int len
)
1109 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1110 struct sock
*sk
= sock
->sk
;
1111 struct isotp_sock
*so
= isotp_sk(sk
);
1112 struct net
*net
= sock_net(sk
);
1114 struct net_device
*dev
;
1115 canid_t tx_id
, rx_id
;
1117 int notify_enetdown
= 0;
1120 if (len
< ISOTP_MIN_NAMELEN
)
1123 /* sanitize tx/rx CAN identifiers */
1124 tx_id
= addr
->can_addr
.tp
.tx_id
;
1125 if (tx_id
& CAN_EFF_FLAG
)
1126 tx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1128 tx_id
&= CAN_SFF_MASK
;
1130 rx_id
= addr
->can_addr
.tp
.rx_id
;
1131 if (rx_id
& CAN_EFF_FLAG
)
1132 rx_id
&= (CAN_EFF_FLAG
| CAN_EFF_MASK
);
1134 rx_id
&= CAN_SFF_MASK
;
1136 if (!addr
->can_ifindex
)
1141 /* do not register frame reception for functional addressing */
1142 if (so
->opt
.flags
& CAN_ISOTP_SF_BROADCAST
)
1145 /* do not validate rx address for functional addressing */
1146 if (do_rx_reg
&& rx_id
== tx_id
) {
1147 err
= -EADDRNOTAVAIL
;
1151 if (so
->bound
&& addr
->can_ifindex
== so
->ifindex
&&
1152 rx_id
== so
->rxid
&& tx_id
== so
->txid
)
1155 dev
= dev_get_by_index(net
, addr
->can_ifindex
);
1160 if (dev
->type
!= ARPHRD_CAN
) {
1165 if (dev
->mtu
< so
->ll
.mtu
) {
1170 if (!(dev
->flags
& IFF_UP
))
1171 notify_enetdown
= 1;
1173 ifindex
= dev
->ifindex
;
1176 can_rx_register(net
, dev
, rx_id
, SINGLE_MASK(rx_id
),
1177 isotp_rcv
, sk
, "isotp", sk
);
1181 if (so
->bound
&& do_rx_reg
) {
1182 /* unregister old filter */
1184 dev
= dev_get_by_index(net
, so
->ifindex
);
1186 can_rx_unregister(net
, dev
, so
->rxid
,
1187 SINGLE_MASK(so
->rxid
),
1194 /* switch to new settings */
1195 so
->ifindex
= ifindex
;
1203 if (notify_enetdown
) {
1204 sk
->sk_err
= ENETDOWN
;
1205 if (!sock_flag(sk
, SOCK_DEAD
))
1206 sk_error_report(sk
);
1212 static int isotp_getname(struct socket
*sock
, struct sockaddr
*uaddr
, int peer
)
1214 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1215 struct sock
*sk
= sock
->sk
;
1216 struct isotp_sock
*so
= isotp_sk(sk
);
1221 memset(addr
, 0, ISOTP_MIN_NAMELEN
);
1222 addr
->can_family
= AF_CAN
;
1223 addr
->can_ifindex
= so
->ifindex
;
1224 addr
->can_addr
.tp
.rx_id
= so
->rxid
;
1225 addr
->can_addr
.tp
.tx_id
= so
->txid
;
1227 return ISOTP_MIN_NAMELEN
;
1230 static int isotp_setsockopt_locked(struct socket
*sock
, int level
, int optname
,
1231 sockptr_t optval
, unsigned int optlen
)
1233 struct sock
*sk
= sock
->sk
;
1234 struct isotp_sock
*so
= isotp_sk(sk
);
1241 case CAN_ISOTP_OPTS
:
1242 if (optlen
!= sizeof(struct can_isotp_options
))
1245 if (copy_from_sockptr(&so
->opt
, optval
, optlen
))
1248 /* no separate rx_ext_address is given => use ext_address */
1249 if (!(so
->opt
.flags
& CAN_ISOTP_RX_EXT_ADDR
))
1250 so
->opt
.rx_ext_address
= so
->opt
.ext_address
;
1252 /* check for frame_txtime changes (0 => no changes) */
1253 if (so
->opt
.frame_txtime
) {
1254 if (so
->opt
.frame_txtime
== CAN_ISOTP_FRAME_TXTIME_ZERO
)
1255 so
->frame_txtime
= 0;
1257 so
->frame_txtime
= so
->opt
.frame_txtime
;
1261 case CAN_ISOTP_RECV_FC
:
1262 if (optlen
!= sizeof(struct can_isotp_fc_options
))
1265 if (copy_from_sockptr(&so
->rxfc
, optval
, optlen
))
1269 case CAN_ISOTP_TX_STMIN
:
1270 if (optlen
!= sizeof(u32
))
1273 if (copy_from_sockptr(&so
->force_tx_stmin
, optval
, optlen
))
1277 case CAN_ISOTP_RX_STMIN
:
1278 if (optlen
!= sizeof(u32
))
1281 if (copy_from_sockptr(&so
->force_rx_stmin
, optval
, optlen
))
1285 case CAN_ISOTP_LL_OPTS
:
1286 if (optlen
== sizeof(struct can_isotp_ll_options
)) {
1287 struct can_isotp_ll_options ll
;
1289 if (copy_from_sockptr(&ll
, optval
, optlen
))
1292 /* check for correct ISO 11898-1 DLC data length */
1293 if (ll
.tx_dl
!= padlen(ll
.tx_dl
))
1296 if (ll
.mtu
!= CAN_MTU
&& ll
.mtu
!= CANFD_MTU
)
1299 if (ll
.mtu
== CAN_MTU
&&
1300 (ll
.tx_dl
> CAN_MAX_DLEN
|| ll
.tx_flags
!= 0))
1303 memcpy(&so
->ll
, &ll
, sizeof(ll
));
1305 /* set ll_dl for tx path to similar place as for rx */
1306 so
->tx
.ll_dl
= ll
.tx_dl
;
1319 static int isotp_setsockopt(struct socket
*sock
, int level
, int optname
,
1320 sockptr_t optval
, unsigned int optlen
)
1323 struct sock
*sk
= sock
->sk
;
1326 if (level
!= SOL_CAN_ISOTP
)
1330 ret
= isotp_setsockopt_locked(sock
, level
, optname
, optval
, optlen
);
1335 static int isotp_getsockopt(struct socket
*sock
, int level
, int optname
,
1336 char __user
*optval
, int __user
*optlen
)
1338 struct sock
*sk
= sock
->sk
;
1339 struct isotp_sock
*so
= isotp_sk(sk
);
1343 if (level
!= SOL_CAN_ISOTP
)
1345 if (get_user(len
, optlen
))
1351 case CAN_ISOTP_OPTS
:
1352 len
= min_t(int, len
, sizeof(struct can_isotp_options
));
1356 case CAN_ISOTP_RECV_FC
:
1357 len
= min_t(int, len
, sizeof(struct can_isotp_fc_options
));
1361 case CAN_ISOTP_TX_STMIN
:
1362 len
= min_t(int, len
, sizeof(u32
));
1363 val
= &so
->force_tx_stmin
;
1366 case CAN_ISOTP_RX_STMIN
:
1367 len
= min_t(int, len
, sizeof(u32
));
1368 val
= &so
->force_rx_stmin
;
1371 case CAN_ISOTP_LL_OPTS
:
1372 len
= min_t(int, len
, sizeof(struct can_isotp_ll_options
));
1377 return -ENOPROTOOPT
;
1380 if (put_user(len
, optlen
))
1382 if (copy_to_user(optval
, val
, len
))
1387 static void isotp_notify(struct isotp_sock
*so
, unsigned long msg
,
1388 struct net_device
*dev
)
1390 struct sock
*sk
= &so
->sk
;
1392 if (!net_eq(dev_net(dev
), sock_net(sk
)))
1395 if (so
->ifindex
!= dev
->ifindex
)
1399 case NETDEV_UNREGISTER
:
1401 /* remove current filters & unregister */
1402 if (so
->bound
&& (!(so
->opt
.flags
& CAN_ISOTP_SF_BROADCAST
)))
1403 can_rx_unregister(dev_net(dev
), dev
, so
->rxid
,
1404 SINGLE_MASK(so
->rxid
),
1411 sk
->sk_err
= ENODEV
;
1412 if (!sock_flag(sk
, SOCK_DEAD
))
1413 sk_error_report(sk
);
1417 sk
->sk_err
= ENETDOWN
;
1418 if (!sock_flag(sk
, SOCK_DEAD
))
1419 sk_error_report(sk
);
1424 static int isotp_notifier(struct notifier_block
*nb
, unsigned long msg
,
1427 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1429 if (dev
->type
!= ARPHRD_CAN
)
1431 if (msg
!= NETDEV_UNREGISTER
&& msg
!= NETDEV_DOWN
)
1433 if (unlikely(isotp_busy_notifier
)) /* Check for reentrant bug. */
1436 spin_lock(&isotp_notifier_lock
);
1437 list_for_each_entry(isotp_busy_notifier
, &isotp_notifier_list
, notifier
) {
1438 spin_unlock(&isotp_notifier_lock
);
1439 isotp_notify(isotp_busy_notifier
, msg
, dev
);
1440 spin_lock(&isotp_notifier_lock
);
1442 isotp_busy_notifier
= NULL
;
1443 spin_unlock(&isotp_notifier_lock
);
1447 static int isotp_init(struct sock
*sk
)
1449 struct isotp_sock
*so
= isotp_sk(sk
);
1454 so
->opt
.flags
= CAN_ISOTP_DEFAULT_FLAGS
;
1455 so
->opt
.ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1456 so
->opt
.rx_ext_address
= CAN_ISOTP_DEFAULT_EXT_ADDRESS
;
1457 so
->opt
.rxpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1458 so
->opt
.txpad_content
= CAN_ISOTP_DEFAULT_PAD_CONTENT
;
1459 so
->opt
.frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1460 so
->frame_txtime
= CAN_ISOTP_DEFAULT_FRAME_TXTIME
;
1461 so
->rxfc
.bs
= CAN_ISOTP_DEFAULT_RECV_BS
;
1462 so
->rxfc
.stmin
= CAN_ISOTP_DEFAULT_RECV_STMIN
;
1463 so
->rxfc
.wftmax
= CAN_ISOTP_DEFAULT_RECV_WFTMAX
;
1464 so
->ll
.mtu
= CAN_ISOTP_DEFAULT_LL_MTU
;
1465 so
->ll
.tx_dl
= CAN_ISOTP_DEFAULT_LL_TX_DL
;
1466 so
->ll
.tx_flags
= CAN_ISOTP_DEFAULT_LL_TX_FLAGS
;
1468 /* set ll_dl for tx path to similar place as for rx */
1469 so
->tx
.ll_dl
= so
->ll
.tx_dl
;
1471 so
->rx
.state
= ISOTP_IDLE
;
1472 so
->tx
.state
= ISOTP_IDLE
;
1474 hrtimer_init(&so
->rxtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1475 so
->rxtimer
.function
= isotp_rx_timer_handler
;
1476 hrtimer_init(&so
->txtimer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_SOFT
);
1477 so
->txtimer
.function
= isotp_tx_timer_handler
;
1479 init_waitqueue_head(&so
->wait
);
1480 spin_lock_init(&so
->rx_lock
);
1482 spin_lock(&isotp_notifier_lock
);
1483 list_add_tail(&so
->notifier
, &isotp_notifier_list
);
1484 spin_unlock(&isotp_notifier_lock
);
1489 static int isotp_sock_no_ioctlcmd(struct socket
*sock
, unsigned int cmd
,
1492 /* no ioctls for socket layer -> hand it down to NIC layer */
1493 return -ENOIOCTLCMD
;
1496 static const struct proto_ops isotp_ops
= {
1498 .release
= isotp_release
,
1500 .connect
= sock_no_connect
,
1501 .socketpair
= sock_no_socketpair
,
1502 .accept
= sock_no_accept
,
1503 .getname
= isotp_getname
,
1504 .poll
= datagram_poll
,
1505 .ioctl
= isotp_sock_no_ioctlcmd
,
1506 .gettstamp
= sock_gettstamp
,
1507 .listen
= sock_no_listen
,
1508 .shutdown
= sock_no_shutdown
,
1509 .setsockopt
= isotp_setsockopt
,
1510 .getsockopt
= isotp_getsockopt
,
1511 .sendmsg
= isotp_sendmsg
,
1512 .recvmsg
= isotp_recvmsg
,
1513 .mmap
= sock_no_mmap
,
1514 .sendpage
= sock_no_sendpage
,
1517 static struct proto isotp_proto __read_mostly
= {
1518 .name
= "CAN_ISOTP",
1519 .owner
= THIS_MODULE
,
1520 .obj_size
= sizeof(struct isotp_sock
),
1524 static const struct can_proto isotp_can_proto
= {
1526 .protocol
= CAN_ISOTP
,
1528 .prot
= &isotp_proto
,
1531 static struct notifier_block canisotp_notifier
= {
1532 .notifier_call
= isotp_notifier
1535 static __init
int isotp_module_init(void)
1539 pr_info("can: isotp protocol\n");
1541 err
= can_proto_register(&isotp_can_proto
);
1543 pr_err("can: registration of isotp protocol failed %pe\n", ERR_PTR(err
));
1545 register_netdevice_notifier(&canisotp_notifier
);
1550 static __exit
void isotp_module_exit(void)
1552 can_proto_unregister(&isotp_can_proto
);
1553 unregister_netdevice_notifier(&canisotp_notifier
);
1556 module_init(isotp_module_init
);
1557 module_exit(isotp_module_exit
);