1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
3 * bcm.c - Broadcast Manager to filter/send (cyclic) CAN content
5 * Copyright (c) 2002-2017 Volkswagen Group Electronic Research
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of Volkswagen nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * Alternatively, provided that this notice is retained in full, this
21 * software may be distributed under the terms of the GNU General
22 * Public License ("GPL") version 2, in which case the provisions of the
23 * GPL apply INSTEAD OF those given above.
25 * The provided data structures and external interfaces from this code
26 * are not restricted to be used by modules with a GPL compatible license.
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
43 #include <linux/module.h>
44 #include <linux/init.h>
45 #include <linux/interrupt.h>
46 #include <linux/hrtimer.h>
47 #include <linux/list.h>
48 #include <linux/proc_fs.h>
49 #include <linux/seq_file.h>
50 #include <linux/uio.h>
51 #include <linux/net.h>
52 #include <linux/netdevice.h>
53 #include <linux/socket.h>
54 #include <linux/if_arp.h>
55 #include <linux/skbuff.h>
56 #include <linux/can.h>
57 #include <linux/can/core.h>
58 #include <linux/can/skb.h>
59 #include <linux/can/bcm.h>
60 #include <linux/slab.h>
62 #include <net/net_namespace.h>
65 * To send multiple CAN frame content within TX_SETUP or to filter
66 * CAN messages with multiplex index within RX_SETUP, the number of
67 * different filters is limited to 256 due to the one byte index value.
69 #define MAX_NFRAMES 256
71 /* limit timers to 400 days for sending/timeouts */
72 #define BCM_TIMER_SEC_MAX (400 * 24 * 60 * 60)
74 /* use of last_frames[index].flags */
75 #define RX_LOCAL 0x10 /* frame was created on the local host */
76 #define RX_OWN 0x20 /* frame was sent via the socket it was received on */
77 #define RX_RECV 0x40 /* received data for this element */
78 #define RX_THR 0x80 /* element not been sent due to throttle feature */
79 #define BCM_CAN_FLAGS_MASK 0x0F /* to clean private flags after usage */
81 /* get best masking value for can_rx_register() for a given single can_id */
82 #define REGMASK(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 MODULE_DESCRIPTION("PF_CAN broadcast manager protocol");
87 MODULE_LICENSE("Dual BSD/GPL");
88 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
89 MODULE_ALIAS("can-proto-2");
91 #define BCM_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_ifindex)
94 * easy access to the first 64 bit of can(fd)_frame payload. cp->data is
95 * 64 bit aligned so the offset has to be multiples of 8 which is ensured
96 * by the only callers in bcm_rx_cmp_to_index() bcm_rx_handler().
98 static inline u64
get_u64(const struct canfd_frame
*cp
, int offset
)
100 return *(u64
*)(cp
->data
+ offset
);
104 struct list_head list
;
109 unsigned long frames_abs
, frames_filtered
;
110 struct bcm_timeval ival1
, ival2
;
111 struct hrtimer timer
, thrtimer
;
112 ktime_t rx_stamp
, kt_ival1
, kt_ival2
, kt_lastmsg
;
118 /* void pointers to arrays of struct can[fd]_frame */
121 struct canfd_frame sframe
;
122 struct canfd_frame last_sframe
;
124 struct net_device
*rx_reg_dev
;
131 struct list_head notifier
;
132 struct list_head rx_ops
;
133 struct list_head tx_ops
;
134 unsigned long dropped_usr_msgs
;
135 struct proc_dir_entry
*bcm_proc_read
;
136 char procname
[32]; /* inode number in decimal with \0 */
139 static LIST_HEAD(bcm_notifier_list
);
140 static DEFINE_SPINLOCK(bcm_notifier_lock
);
141 static struct bcm_sock
*bcm_busy_notifier
;
143 /* Return pointer to store the extra msg flags for bcm_recvmsg().
144 * We use the space of one unsigned int beyond the 'struct sockaddr_can'
147 static inline unsigned int *bcm_flags(struct sk_buff
*skb
)
149 /* return pointer after struct sockaddr_can */
150 return (unsigned int *)(&((struct sockaddr_can
*)skb
->cb
)[1]);
153 static inline struct bcm_sock
*bcm_sk(const struct sock
*sk
)
155 return (struct bcm_sock
*)sk
;
158 static inline ktime_t
bcm_timeval_to_ktime(struct bcm_timeval tv
)
160 return ktime_set(tv
.tv_sec
, tv
.tv_usec
* NSEC_PER_USEC
);
163 /* check limitations for timeval provided by user */
164 static bool bcm_is_invalid_tv(struct bcm_msg_head
*msg_head
)
166 if ((msg_head
->ival1
.tv_sec
< 0) ||
167 (msg_head
->ival1
.tv_sec
> BCM_TIMER_SEC_MAX
) ||
168 (msg_head
->ival1
.tv_usec
< 0) ||
169 (msg_head
->ival1
.tv_usec
>= USEC_PER_SEC
) ||
170 (msg_head
->ival2
.tv_sec
< 0) ||
171 (msg_head
->ival2
.tv_sec
> BCM_TIMER_SEC_MAX
) ||
172 (msg_head
->ival2
.tv_usec
< 0) ||
173 (msg_head
->ival2
.tv_usec
>= USEC_PER_SEC
))
179 #define CFSIZ(flags) ((flags & CAN_FD_FRAME) ? CANFD_MTU : CAN_MTU)
180 #define OPSIZ sizeof(struct bcm_op)
181 #define MHSIZ sizeof(struct bcm_msg_head)
186 #if IS_ENABLED(CONFIG_PROC_FS)
187 static char *bcm_proc_getifname(struct net
*net
, char *result
, int ifindex
)
189 struct net_device
*dev
;
195 dev
= dev_get_by_index_rcu(net
, ifindex
);
197 strcpy(result
, dev
->name
);
199 strcpy(result
, "???");
205 static int bcm_proc_show(struct seq_file
*m
, void *v
)
207 char ifname
[IFNAMSIZ
];
208 struct net
*net
= m
->private;
209 struct sock
*sk
= (struct sock
*)pde_data(m
->file
->f_inode
);
210 struct bcm_sock
*bo
= bcm_sk(sk
);
213 seq_printf(m
, ">>> socket %pK", sk
->sk_socket
);
214 seq_printf(m
, " / sk %pK", sk
);
215 seq_printf(m
, " / bo %pK", bo
);
216 seq_printf(m
, " / dropped %lu", bo
->dropped_usr_msgs
);
217 seq_printf(m
, " / bound %s", bcm_proc_getifname(net
, ifname
, bo
->ifindex
));
218 seq_printf(m
, " <<<\n");
220 list_for_each_entry(op
, &bo
->rx_ops
, list
) {
222 unsigned long reduction
;
224 /* print only active entries & prevent division by zero */
228 seq_printf(m
, "rx_op: %03X %-5s ", op
->can_id
,
229 bcm_proc_getifname(net
, ifname
, op
->ifindex
));
231 if (op
->flags
& CAN_FD_FRAME
)
232 seq_printf(m
, "(%u)", op
->nframes
);
234 seq_printf(m
, "[%u]", op
->nframes
);
236 seq_printf(m
, "%c ", (op
->flags
& RX_CHECK_DLC
) ? 'd' : ' ');
239 seq_printf(m
, "timeo=%lld ",
240 (long long)ktime_to_us(op
->kt_ival1
));
243 seq_printf(m
, "thr=%lld ",
244 (long long)ktime_to_us(op
->kt_ival2
));
246 seq_printf(m
, "# recv %ld (%ld) => reduction: ",
247 op
->frames_filtered
, op
->frames_abs
);
249 reduction
= 100 - (op
->frames_filtered
* 100) / op
->frames_abs
;
251 seq_printf(m
, "%s%ld%%\n",
252 (reduction
== 100) ? "near " : "", reduction
);
255 list_for_each_entry(op
, &bo
->tx_ops
, list
) {
257 seq_printf(m
, "tx_op: %03X %s ", op
->can_id
,
258 bcm_proc_getifname(net
, ifname
, op
->ifindex
));
260 if (op
->flags
& CAN_FD_FRAME
)
261 seq_printf(m
, "(%u) ", op
->nframes
);
263 seq_printf(m
, "[%u] ", op
->nframes
);
266 seq_printf(m
, "t1=%lld ",
267 (long long)ktime_to_us(op
->kt_ival1
));
270 seq_printf(m
, "t2=%lld ",
271 (long long)ktime_to_us(op
->kt_ival2
));
273 seq_printf(m
, "# sent %ld\n", op
->frames_abs
);
278 #endif /* CONFIG_PROC_FS */
281 * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface
282 * of the given bcm tx op
284 static void bcm_can_tx(struct bcm_op
*op
)
287 struct net_device
*dev
;
288 struct canfd_frame
*cf
= op
->frames
+ op
->cfsiz
* op
->currframe
;
291 /* no target device? => exit */
295 dev
= dev_get_by_index(sock_net(op
->sk
), op
->ifindex
);
297 /* RFC: should this bcm_op remove itself here? */
301 skb
= alloc_skb(op
->cfsiz
+ sizeof(struct can_skb_priv
), gfp_any());
305 can_skb_reserve(skb
);
306 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
307 can_skb_prv(skb
)->skbcnt
= 0;
309 skb_put_data(skb
, cf
, op
->cfsiz
);
311 /* send with loopback */
313 can_skb_set_owner(skb
, op
->sk
);
314 err
= can_send(skb
, 1);
320 /* reached last frame? */
321 if (op
->currframe
>= op
->nframes
)
328 * bcm_send_to_user - send a BCM message to the userspace
329 * (consisting of bcm_msg_head + x CAN frames)
331 static void bcm_send_to_user(struct bcm_op
*op
, struct bcm_msg_head
*head
,
332 struct canfd_frame
*frames
, int has_timestamp
)
335 struct canfd_frame
*firstframe
;
336 struct sockaddr_can
*addr
;
337 struct sock
*sk
= op
->sk
;
338 unsigned int datalen
= head
->nframes
* op
->cfsiz
;
340 unsigned int *pflags
;
342 skb
= alloc_skb(sizeof(*head
) + datalen
, gfp_any());
346 skb_put_data(skb
, head
, sizeof(*head
));
348 /* ensure space for sockaddr_can and msg flags */
349 sock_skb_cb_check_size(sizeof(struct sockaddr_can
) +
350 sizeof(unsigned int));
352 /* initialize msg flags */
353 pflags
= bcm_flags(skb
);
357 /* CAN frames starting here */
358 firstframe
= (struct canfd_frame
*)skb_tail_pointer(skb
);
360 skb_put_data(skb
, frames
, datalen
);
363 * the BCM uses the flags-element of the canfd_frame
364 * structure for internal purposes. This is only
365 * relevant for updates that are generated by the
366 * BCM, where nframes is 1
368 if (head
->nframes
== 1) {
369 if (firstframe
->flags
& RX_LOCAL
)
370 *pflags
|= MSG_DONTROUTE
;
371 if (firstframe
->flags
& RX_OWN
)
372 *pflags
|= MSG_CONFIRM
;
374 firstframe
->flags
&= BCM_CAN_FLAGS_MASK
;
379 /* restore rx timestamp */
380 skb
->tstamp
= op
->rx_stamp
;
384 * Put the datagram to the queue so that bcm_recvmsg() can
385 * get it from there. We need to pass the interface index to
386 * bcm_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
387 * containing the interface index.
390 addr
= (struct sockaddr_can
*)skb
->cb
;
391 memset(addr
, 0, sizeof(*addr
));
392 addr
->can_family
= AF_CAN
;
393 addr
->can_ifindex
= op
->rx_ifindex
;
395 err
= sock_queue_rcv_skb(sk
, skb
);
397 struct bcm_sock
*bo
= bcm_sk(sk
);
400 /* don't care about overflows in this statistic */
401 bo
->dropped_usr_msgs
++;
405 static bool bcm_tx_set_expiry(struct bcm_op
*op
, struct hrtimer
*hrt
)
409 if (op
->kt_ival1
&& op
->count
)
411 else if (op
->kt_ival2
)
416 hrtimer_set_expires(hrt
, ktime_add(ktime_get(), ival
));
420 static void bcm_tx_start_timer(struct bcm_op
*op
)
422 if (bcm_tx_set_expiry(op
, &op
->timer
))
423 hrtimer_start_expires(&op
->timer
, HRTIMER_MODE_ABS_SOFT
);
426 /* bcm_tx_timeout_handler - performs cyclic CAN frame transmissions */
427 static enum hrtimer_restart
bcm_tx_timeout_handler(struct hrtimer
*hrtimer
)
429 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, timer
);
430 struct bcm_msg_head msg_head
;
432 if (op
->kt_ival1
&& (op
->count
> 0)) {
434 if (!op
->count
&& (op
->flags
& TX_COUNTEVT
)) {
436 /* create notification to user */
437 memset(&msg_head
, 0, sizeof(msg_head
));
438 msg_head
.opcode
= TX_EXPIRED
;
439 msg_head
.flags
= op
->flags
;
440 msg_head
.count
= op
->count
;
441 msg_head
.ival1
= op
->ival1
;
442 msg_head
.ival2
= op
->ival2
;
443 msg_head
.can_id
= op
->can_id
;
444 msg_head
.nframes
= 0;
446 bcm_send_to_user(op
, &msg_head
, NULL
, 0);
450 } else if (op
->kt_ival2
) {
454 return bcm_tx_set_expiry(op
, &op
->timer
) ?
455 HRTIMER_RESTART
: HRTIMER_NORESTART
;
459 * bcm_rx_changed - create a RX_CHANGED notification due to changed content
461 static void bcm_rx_changed(struct bcm_op
*op
, struct canfd_frame
*data
)
463 struct bcm_msg_head head
;
465 /* update statistics */
466 op
->frames_filtered
++;
468 /* prevent statistics overflow */
469 if (op
->frames_filtered
> ULONG_MAX
/100)
470 op
->frames_filtered
= op
->frames_abs
= 0;
472 /* this element is not throttled anymore */
473 data
->flags
&= ~RX_THR
;
475 memset(&head
, 0, sizeof(head
));
476 head
.opcode
= RX_CHANGED
;
477 head
.flags
= op
->flags
;
478 head
.count
= op
->count
;
479 head
.ival1
= op
->ival1
;
480 head
.ival2
= op
->ival2
;
481 head
.can_id
= op
->can_id
;
484 bcm_send_to_user(op
, &head
, data
, 1);
488 * bcm_rx_update_and_send - process a detected relevant receive content change
489 * 1. update the last received data
490 * 2. send a notification to the user (if possible)
492 static void bcm_rx_update_and_send(struct bcm_op
*op
,
493 struct canfd_frame
*lastdata
,
494 const struct canfd_frame
*rxdata
,
495 unsigned char traffic_flags
)
497 memcpy(lastdata
, rxdata
, op
->cfsiz
);
499 /* mark as used and throttled by default */
500 lastdata
->flags
|= (RX_RECV
|RX_THR
);
502 /* add own/local/remote traffic flags */
503 lastdata
->flags
|= traffic_flags
;
505 /* throttling mode inactive ? */
507 /* send RX_CHANGED to the user immediately */
508 bcm_rx_changed(op
, lastdata
);
512 /* with active throttling timer we are just done here */
513 if (hrtimer_active(&op
->thrtimer
))
516 /* first reception with enabled throttling mode */
518 goto rx_changed_settime
;
520 /* got a second frame inside a potential throttle period? */
521 if (ktime_us_delta(ktime_get(), op
->kt_lastmsg
) <
522 ktime_to_us(op
->kt_ival2
)) {
523 /* do not send the saved data - only start throttle timer */
524 hrtimer_start(&op
->thrtimer
,
525 ktime_add(op
->kt_lastmsg
, op
->kt_ival2
),
526 HRTIMER_MODE_ABS_SOFT
);
530 /* the gap was that big, that throttling was not needed here */
532 bcm_rx_changed(op
, lastdata
);
533 op
->kt_lastmsg
= ktime_get();
537 * bcm_rx_cmp_to_index - (bit)compares the currently received data to formerly
538 * received data stored in op->last_frames[]
540 static void bcm_rx_cmp_to_index(struct bcm_op
*op
, unsigned int index
,
541 const struct canfd_frame
*rxdata
,
542 unsigned char traffic_flags
)
544 struct canfd_frame
*cf
= op
->frames
+ op
->cfsiz
* index
;
545 struct canfd_frame
*lcf
= op
->last_frames
+ op
->cfsiz
* index
;
549 * no one uses the MSBs of flags for comparison,
550 * so we use it here to detect the first time of reception
553 if (!(lcf
->flags
& RX_RECV
)) {
554 /* received data for the first time => send update to user */
555 bcm_rx_update_and_send(op
, lcf
, rxdata
, traffic_flags
);
559 /* do a real check in CAN frame data section */
560 for (i
= 0; i
< rxdata
->len
; i
+= 8) {
561 if ((get_u64(cf
, i
) & get_u64(rxdata
, i
)) !=
562 (get_u64(cf
, i
) & get_u64(lcf
, i
))) {
563 bcm_rx_update_and_send(op
, lcf
, rxdata
, traffic_flags
);
568 if (op
->flags
& RX_CHECK_DLC
) {
569 /* do a real check in CAN frame length */
570 if (rxdata
->len
!= lcf
->len
) {
571 bcm_rx_update_and_send(op
, lcf
, rxdata
, traffic_flags
);
578 * bcm_rx_starttimer - enable timeout monitoring for CAN frame reception
580 static void bcm_rx_starttimer(struct bcm_op
*op
)
582 if (op
->flags
& RX_NO_AUTOTIMER
)
586 hrtimer_start(&op
->timer
, op
->kt_ival1
, HRTIMER_MODE_REL_SOFT
);
589 /* bcm_rx_timeout_handler - when the (cyclic) CAN frame reception timed out */
590 static enum hrtimer_restart
bcm_rx_timeout_handler(struct hrtimer
*hrtimer
)
592 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, timer
);
593 struct bcm_msg_head msg_head
;
595 /* if user wants to be informed, when cyclic CAN-Messages come back */
596 if ((op
->flags
& RX_ANNOUNCE_RESUME
) && op
->last_frames
) {
597 /* clear received CAN frames to indicate 'nothing received' */
598 memset(op
->last_frames
, 0, op
->nframes
* op
->cfsiz
);
601 /* create notification to user */
602 memset(&msg_head
, 0, sizeof(msg_head
));
603 msg_head
.opcode
= RX_TIMEOUT
;
604 msg_head
.flags
= op
->flags
;
605 msg_head
.count
= op
->count
;
606 msg_head
.ival1
= op
->ival1
;
607 msg_head
.ival2
= op
->ival2
;
608 msg_head
.can_id
= op
->can_id
;
609 msg_head
.nframes
= 0;
611 bcm_send_to_user(op
, &msg_head
, NULL
, 0);
613 return HRTIMER_NORESTART
;
617 * bcm_rx_do_flush - helper for bcm_rx_thr_flush
619 static inline int bcm_rx_do_flush(struct bcm_op
*op
, unsigned int index
)
621 struct canfd_frame
*lcf
= op
->last_frames
+ op
->cfsiz
* index
;
623 if ((op
->last_frames
) && (lcf
->flags
& RX_THR
)) {
624 bcm_rx_changed(op
, lcf
);
631 * bcm_rx_thr_flush - Check for throttled data and send it to the userspace
633 static int bcm_rx_thr_flush(struct bcm_op
*op
)
637 if (op
->nframes
> 1) {
640 /* for MUX filter we start at index 1 */
641 for (i
= 1; i
< op
->nframes
; i
++)
642 updated
+= bcm_rx_do_flush(op
, i
);
645 /* for RX_FILTER_ID and simple filter */
646 updated
+= bcm_rx_do_flush(op
, 0);
653 * bcm_rx_thr_handler - the time for blocked content updates is over now:
654 * Check for throttled data and send it to the userspace
656 static enum hrtimer_restart
bcm_rx_thr_handler(struct hrtimer
*hrtimer
)
658 struct bcm_op
*op
= container_of(hrtimer
, struct bcm_op
, thrtimer
);
660 if (bcm_rx_thr_flush(op
)) {
661 hrtimer_forward_now(hrtimer
, op
->kt_ival2
);
662 return HRTIMER_RESTART
;
664 /* rearm throttle handling */
666 return HRTIMER_NORESTART
;
671 * bcm_rx_handler - handle a CAN frame reception
673 static void bcm_rx_handler(struct sk_buff
*skb
, void *data
)
675 struct bcm_op
*op
= (struct bcm_op
*)data
;
676 const struct canfd_frame
*rxframe
= (struct canfd_frame
*)skb
->data
;
678 unsigned char traffic_flags
;
680 if (op
->can_id
!= rxframe
->can_id
)
683 /* make sure to handle the correct frame type (CAN / CAN FD) */
684 if (op
->flags
& CAN_FD_FRAME
) {
685 if (!can_is_canfd_skb(skb
))
688 if (!can_is_can_skb(skb
))
692 /* disable timeout */
693 hrtimer_cancel(&op
->timer
);
695 /* save rx timestamp */
696 op
->rx_stamp
= skb
->tstamp
;
697 /* save originator for recvfrom() */
698 op
->rx_ifindex
= skb
->dev
->ifindex
;
699 /* update statistics */
702 if (op
->flags
& RX_RTR_FRAME
) {
703 /* send reply for RTR-request (placed in op->frames[0]) */
708 /* compute flags to distinguish between own/local/remote CAN traffic */
711 traffic_flags
|= RX_LOCAL
;
712 if (skb
->sk
== op
->sk
)
713 traffic_flags
|= RX_OWN
;
716 if (op
->flags
& RX_FILTER_ID
) {
717 /* the easiest case */
718 bcm_rx_update_and_send(op
, op
->last_frames
, rxframe
,
723 if (op
->nframes
== 1) {
724 /* simple compare with index 0 */
725 bcm_rx_cmp_to_index(op
, 0, rxframe
, traffic_flags
);
729 if (op
->nframes
> 1) {
733 * find the first multiplex mask that fits.
734 * Remark: The MUX-mask is stored in index 0 - but only the
735 * first 64 bits of the frame data[] are relevant (CAN FD)
738 for (i
= 1; i
< op
->nframes
; i
++) {
739 if ((get_u64(op
->frames
, 0) & get_u64(rxframe
, 0)) ==
740 (get_u64(op
->frames
, 0) &
741 get_u64(op
->frames
+ op
->cfsiz
* i
, 0))) {
742 bcm_rx_cmp_to_index(op
, i
, rxframe
,
750 bcm_rx_starttimer(op
);
754 * helpers for bcm_op handling: find & delete bcm [rx|tx] op elements
756 static struct bcm_op
*bcm_find_op(struct list_head
*ops
,
757 struct bcm_msg_head
*mh
, int ifindex
)
761 list_for_each_entry(op
, ops
, list
) {
762 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
763 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
))
770 static void bcm_free_op_rcu(struct rcu_head
*rcu_head
)
772 struct bcm_op
*op
= container_of(rcu_head
, struct bcm_op
, rcu
);
774 if ((op
->frames
) && (op
->frames
!= &op
->sframe
))
777 if ((op
->last_frames
) && (op
->last_frames
!= &op
->last_sframe
))
778 kfree(op
->last_frames
);
783 static void bcm_remove_op(struct bcm_op
*op
)
785 hrtimer_cancel(&op
->timer
);
786 hrtimer_cancel(&op
->thrtimer
);
788 call_rcu(&op
->rcu
, bcm_free_op_rcu
);
791 static void bcm_rx_unreg(struct net_device
*dev
, struct bcm_op
*op
)
793 if (op
->rx_reg_dev
== dev
) {
794 can_rx_unregister(dev_net(dev
), dev
, op
->can_id
,
795 REGMASK(op
->can_id
), bcm_rx_handler
, op
);
797 /* mark as removed subscription */
798 op
->rx_reg_dev
= NULL
;
800 printk(KERN_ERR
"can-bcm: bcm_rx_unreg: registered device "
801 "mismatch %p %p\n", op
->rx_reg_dev
, dev
);
805 * bcm_delete_rx_op - find and remove a rx op (returns number of removed ops)
807 static int bcm_delete_rx_op(struct list_head
*ops
, struct bcm_msg_head
*mh
,
810 struct bcm_op
*op
, *n
;
812 list_for_each_entry_safe(op
, n
, ops
, list
) {
813 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
814 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
)) {
816 /* disable automatic timer on frame reception */
817 op
->flags
|= RX_NO_AUTOTIMER
;
820 * Don't care if we're bound or not (due to netdev
821 * problems) can_rx_unregister() is always a save
826 * Only remove subscriptions that had not
827 * been removed due to NETDEV_UNREGISTER
830 if (op
->rx_reg_dev
) {
831 struct net_device
*dev
;
833 dev
= dev_get_by_index(sock_net(op
->sk
),
836 bcm_rx_unreg(dev
, op
);
841 can_rx_unregister(sock_net(op
->sk
), NULL
,
852 return 0; /* not found */
856 * bcm_delete_tx_op - find and remove a tx op (returns number of removed ops)
858 static int bcm_delete_tx_op(struct list_head
*ops
, struct bcm_msg_head
*mh
,
861 struct bcm_op
*op
, *n
;
863 list_for_each_entry_safe(op
, n
, ops
, list
) {
864 if ((op
->can_id
== mh
->can_id
) && (op
->ifindex
== ifindex
) &&
865 (op
->flags
& CAN_FD_FRAME
) == (mh
->flags
& CAN_FD_FRAME
)) {
872 return 0; /* not found */
876 * bcm_read_op - read out a bcm_op and send it to the user (for bcm_sendmsg)
878 static int bcm_read_op(struct list_head
*ops
, struct bcm_msg_head
*msg_head
,
881 struct bcm_op
*op
= bcm_find_op(ops
, msg_head
, ifindex
);
886 /* put current values into msg_head */
887 msg_head
->flags
= op
->flags
;
888 msg_head
->count
= op
->count
;
889 msg_head
->ival1
= op
->ival1
;
890 msg_head
->ival2
= op
->ival2
;
891 msg_head
->nframes
= op
->nframes
;
893 bcm_send_to_user(op
, msg_head
, op
->frames
, 0);
899 * bcm_tx_setup - create or update a bcm tx op (for bcm_sendmsg)
901 static int bcm_tx_setup(struct bcm_msg_head
*msg_head
, struct msghdr
*msg
,
902 int ifindex
, struct sock
*sk
)
904 struct bcm_sock
*bo
= bcm_sk(sk
);
906 struct canfd_frame
*cf
;
910 /* we need a real device to send frames */
914 /* check nframes boundaries - we need at least one CAN frame */
915 if (msg_head
->nframes
< 1 || msg_head
->nframes
> MAX_NFRAMES
)
918 /* check timeval limitations */
919 if ((msg_head
->flags
& SETTIMER
) && bcm_is_invalid_tv(msg_head
))
922 /* check the given can_id */
923 op
= bcm_find_op(&bo
->tx_ops
, msg_head
, ifindex
);
925 /* update existing BCM operation */
928 * Do we need more space for the CAN frames than currently
929 * allocated? -> This is a _really_ unusual use-case and
930 * therefore (complexity / locking) it is not supported.
932 if (msg_head
->nframes
> op
->nframes
)
935 /* update CAN frames content */
936 for (i
= 0; i
< msg_head
->nframes
; i
++) {
938 cf
= op
->frames
+ op
->cfsiz
* i
;
939 err
= memcpy_from_msg((u8
*)cf
, msg
, op
->cfsiz
);
941 if (op
->flags
& CAN_FD_FRAME
) {
952 if (msg_head
->flags
& TX_CP_CAN_ID
) {
953 /* copy can_id into frame */
954 cf
->can_id
= msg_head
->can_id
;
957 op
->flags
= msg_head
->flags
;
960 /* insert new BCM operation for the given can_id */
962 op
= kzalloc(OPSIZ
, GFP_KERNEL
);
966 op
->can_id
= msg_head
->can_id
;
967 op
->cfsiz
= CFSIZ(msg_head
->flags
);
968 op
->flags
= msg_head
->flags
;
970 /* create array for CAN frames and copy the data */
971 if (msg_head
->nframes
> 1) {
972 op
->frames
= kmalloc_array(msg_head
->nframes
,
980 op
->frames
= &op
->sframe
;
982 for (i
= 0; i
< msg_head
->nframes
; i
++) {
984 cf
= op
->frames
+ op
->cfsiz
* i
;
985 err
= memcpy_from_msg((u8
*)cf
, msg
, op
->cfsiz
);
989 if (op
->flags
& CAN_FD_FRAME
) {
1000 if (msg_head
->flags
& TX_CP_CAN_ID
) {
1001 /* copy can_id into frame */
1002 cf
->can_id
= msg_head
->can_id
;
1006 /* tx_ops never compare with previous received messages */
1007 op
->last_frames
= NULL
;
1009 /* bcm_can_tx / bcm_tx_timeout_handler needs this */
1011 op
->ifindex
= ifindex
;
1013 /* initialize uninitialized (kzalloc) structure */
1014 hrtimer_init(&op
->timer
, CLOCK_MONOTONIC
,
1015 HRTIMER_MODE_REL_SOFT
);
1016 op
->timer
.function
= bcm_tx_timeout_handler
;
1018 /* currently unused in tx_ops */
1019 hrtimer_init(&op
->thrtimer
, CLOCK_MONOTONIC
,
1020 HRTIMER_MODE_REL_SOFT
);
1022 /* add this bcm_op to the list of the tx_ops */
1023 list_add(&op
->list
, &bo
->tx_ops
);
1025 } /* if ((op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex))) */
1027 if (op
->nframes
!= msg_head
->nframes
) {
1028 op
->nframes
= msg_head
->nframes
;
1029 /* start multiple frame transmission with index 0 */
1035 if (op
->flags
& TX_RESET_MULTI_IDX
) {
1036 /* start multiple frame transmission with index 0 */
1040 if (op
->flags
& SETTIMER
) {
1041 /* set timer values */
1042 op
->count
= msg_head
->count
;
1043 op
->ival1
= msg_head
->ival1
;
1044 op
->ival2
= msg_head
->ival2
;
1045 op
->kt_ival1
= bcm_timeval_to_ktime(msg_head
->ival1
);
1046 op
->kt_ival2
= bcm_timeval_to_ktime(msg_head
->ival2
);
1048 /* disable an active timer due to zero values? */
1049 if (!op
->kt_ival1
&& !op
->kt_ival2
)
1050 hrtimer_cancel(&op
->timer
);
1053 if (op
->flags
& STARTTIMER
) {
1054 hrtimer_cancel(&op
->timer
);
1055 /* spec: send CAN frame when starting timer */
1056 op
->flags
|= TX_ANNOUNCE
;
1059 if (op
->flags
& TX_ANNOUNCE
) {
1065 if (op
->flags
& STARTTIMER
)
1066 bcm_tx_start_timer(op
);
1068 return msg_head
->nframes
* op
->cfsiz
+ MHSIZ
;
1071 if (op
->frames
!= &op
->sframe
)
1078 * bcm_rx_setup - create or update a bcm rx op (for bcm_sendmsg)
1080 static int bcm_rx_setup(struct bcm_msg_head
*msg_head
, struct msghdr
*msg
,
1081 int ifindex
, struct sock
*sk
)
1083 struct bcm_sock
*bo
= bcm_sk(sk
);
1088 if ((msg_head
->flags
& RX_FILTER_ID
) || (!(msg_head
->nframes
))) {
1089 /* be robust against wrong usage ... */
1090 msg_head
->flags
|= RX_FILTER_ID
;
1091 /* ignore trailing garbage */
1092 msg_head
->nframes
= 0;
1095 /* the first element contains the mux-mask => MAX_NFRAMES + 1 */
1096 if (msg_head
->nframes
> MAX_NFRAMES
+ 1)
1099 if ((msg_head
->flags
& RX_RTR_FRAME
) &&
1100 ((msg_head
->nframes
!= 1) ||
1101 (!(msg_head
->can_id
& CAN_RTR_FLAG
))))
1104 /* check timeval limitations */
1105 if ((msg_head
->flags
& SETTIMER
) && bcm_is_invalid_tv(msg_head
))
1108 /* check the given can_id */
1109 op
= bcm_find_op(&bo
->rx_ops
, msg_head
, ifindex
);
1111 /* update existing BCM operation */
1114 * Do we need more space for the CAN frames than currently
1115 * allocated? -> This is a _really_ unusual use-case and
1116 * therefore (complexity / locking) it is not supported.
1118 if (msg_head
->nframes
> op
->nframes
)
1121 if (msg_head
->nframes
) {
1122 /* update CAN frames content */
1123 err
= memcpy_from_msg(op
->frames
, msg
,
1124 msg_head
->nframes
* op
->cfsiz
);
1128 /* clear last_frames to indicate 'nothing received' */
1129 memset(op
->last_frames
, 0, msg_head
->nframes
* op
->cfsiz
);
1132 op
->nframes
= msg_head
->nframes
;
1133 op
->flags
= msg_head
->flags
;
1135 /* Only an update -> do not call can_rx_register() */
1139 /* insert new BCM operation for the given can_id */
1140 op
= kzalloc(OPSIZ
, GFP_KERNEL
);
1144 op
->can_id
= msg_head
->can_id
;
1145 op
->nframes
= msg_head
->nframes
;
1146 op
->cfsiz
= CFSIZ(msg_head
->flags
);
1147 op
->flags
= msg_head
->flags
;
1149 if (msg_head
->nframes
> 1) {
1150 /* create array for CAN frames and copy the data */
1151 op
->frames
= kmalloc_array(msg_head
->nframes
,
1159 /* create and init array for received CAN frames */
1160 op
->last_frames
= kcalloc(msg_head
->nframes
,
1163 if (!op
->last_frames
) {
1170 op
->frames
= &op
->sframe
;
1171 op
->last_frames
= &op
->last_sframe
;
1174 if (msg_head
->nframes
) {
1175 err
= memcpy_from_msg(op
->frames
, msg
,
1176 msg_head
->nframes
* op
->cfsiz
);
1178 if (op
->frames
!= &op
->sframe
)
1180 if (op
->last_frames
!= &op
->last_sframe
)
1181 kfree(op
->last_frames
);
1187 /* bcm_can_tx / bcm_tx_timeout_handler needs this */
1189 op
->ifindex
= ifindex
;
1191 /* ifindex for timeout events w/o previous frame reception */
1192 op
->rx_ifindex
= ifindex
;
1194 /* initialize uninitialized (kzalloc) structure */
1195 hrtimer_init(&op
->timer
, CLOCK_MONOTONIC
,
1196 HRTIMER_MODE_REL_SOFT
);
1197 op
->timer
.function
= bcm_rx_timeout_handler
;
1199 hrtimer_init(&op
->thrtimer
, CLOCK_MONOTONIC
,
1200 HRTIMER_MODE_REL_SOFT
);
1201 op
->thrtimer
.function
= bcm_rx_thr_handler
;
1203 /* add this bcm_op to the list of the rx_ops */
1204 list_add(&op
->list
, &bo
->rx_ops
);
1206 /* call can_rx_register() */
1209 } /* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
1213 if (op
->flags
& RX_RTR_FRAME
) {
1214 struct canfd_frame
*frame0
= op
->frames
;
1216 /* no timers in RTR-mode */
1217 hrtimer_cancel(&op
->thrtimer
);
1218 hrtimer_cancel(&op
->timer
);
1221 * funny feature in RX(!)_SETUP only for RTR-mode:
1222 * copy can_id into frame BUT without RTR-flag to
1223 * prevent a full-load-loopback-test ... ;-]
1225 if ((op
->flags
& TX_CP_CAN_ID
) ||
1226 (frame0
->can_id
== op
->can_id
))
1227 frame0
->can_id
= op
->can_id
& ~CAN_RTR_FLAG
;
1230 if (op
->flags
& SETTIMER
) {
1232 /* set timer value */
1233 op
->ival1
= msg_head
->ival1
;
1234 op
->ival2
= msg_head
->ival2
;
1235 op
->kt_ival1
= bcm_timeval_to_ktime(msg_head
->ival1
);
1236 op
->kt_ival2
= bcm_timeval_to_ktime(msg_head
->ival2
);
1238 /* disable an active timer due to zero value? */
1240 hrtimer_cancel(&op
->timer
);
1243 * In any case cancel the throttle timer, flush
1244 * potentially blocked msgs and reset throttle handling
1247 hrtimer_cancel(&op
->thrtimer
);
1248 bcm_rx_thr_flush(op
);
1251 if ((op
->flags
& STARTTIMER
) && op
->kt_ival1
)
1252 hrtimer_start(&op
->timer
, op
->kt_ival1
,
1253 HRTIMER_MODE_REL_SOFT
);
1256 /* now we can register for can_ids, if we added a new bcm_op */
1257 if (do_rx_register
) {
1259 struct net_device
*dev
;
1261 dev
= dev_get_by_index(sock_net(sk
), ifindex
);
1263 err
= can_rx_register(sock_net(sk
), dev
,
1265 REGMASK(op
->can_id
),
1269 op
->rx_reg_dev
= dev
;
1274 err
= can_rx_register(sock_net(sk
), NULL
, op
->can_id
,
1275 REGMASK(op
->can_id
),
1276 bcm_rx_handler
, op
, "bcm", sk
);
1278 /* this bcm rx op is broken -> remove it */
1279 list_del(&op
->list
);
1285 return msg_head
->nframes
* op
->cfsiz
+ MHSIZ
;
1289 * bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg)
1291 static int bcm_tx_send(struct msghdr
*msg
, int ifindex
, struct sock
*sk
,
1294 struct sk_buff
*skb
;
1295 struct net_device
*dev
;
1298 /* we need a real device to send frames */
1302 skb
= alloc_skb(cfsiz
+ sizeof(struct can_skb_priv
), GFP_KERNEL
);
1306 can_skb_reserve(skb
);
1308 err
= memcpy_from_msg(skb_put(skb
, cfsiz
), msg
, cfsiz
);
1314 dev
= dev_get_by_index(sock_net(sk
), ifindex
);
1320 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
1321 can_skb_prv(skb
)->skbcnt
= 0;
1323 can_skb_set_owner(skb
, sk
);
1324 err
= can_send(skb
, 1); /* send with loopback */
1330 return cfsiz
+ MHSIZ
;
1334 * bcm_sendmsg - process BCM commands (opcodes) from the userspace
1336 static int bcm_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
)
1338 struct sock
*sk
= sock
->sk
;
1339 struct bcm_sock
*bo
= bcm_sk(sk
);
1340 int ifindex
= bo
->ifindex
; /* default ifindex for this bcm_op */
1341 struct bcm_msg_head msg_head
;
1343 int ret
; /* read bytes or error codes as return value */
1348 /* check for valid message length from userspace */
1352 /* read message head information */
1353 ret
= memcpy_from_msg((u8
*)&msg_head
, msg
, MHSIZ
);
1357 cfsiz
= CFSIZ(msg_head
.flags
);
1358 if ((size
- MHSIZ
) % cfsiz
)
1361 /* check for alternative ifindex for this bcm_op */
1363 if (!ifindex
&& msg
->msg_name
) {
1364 /* no bound device as default => check msg_name */
1365 DECLARE_SOCKADDR(struct sockaddr_can
*, addr
, msg
->msg_name
);
1367 if (msg
->msg_namelen
< BCM_MIN_NAMELEN
)
1370 if (addr
->can_family
!= AF_CAN
)
1373 /* ifindex from sendto() */
1374 ifindex
= addr
->can_ifindex
;
1377 struct net_device
*dev
;
1379 dev
= dev_get_by_index(sock_net(sk
), ifindex
);
1383 if (dev
->type
!= ARPHRD_CAN
) {
1394 switch (msg_head
.opcode
) {
1397 ret
= bcm_tx_setup(&msg_head
, msg
, ifindex
, sk
);
1401 ret
= bcm_rx_setup(&msg_head
, msg
, ifindex
, sk
);
1405 if (bcm_delete_tx_op(&bo
->tx_ops
, &msg_head
, ifindex
))
1412 if (bcm_delete_rx_op(&bo
->rx_ops
, &msg_head
, ifindex
))
1419 /* reuse msg_head for the reply to TX_READ */
1420 msg_head
.opcode
= TX_STATUS
;
1421 ret
= bcm_read_op(&bo
->tx_ops
, &msg_head
, ifindex
);
1425 /* reuse msg_head for the reply to RX_READ */
1426 msg_head
.opcode
= RX_STATUS
;
1427 ret
= bcm_read_op(&bo
->rx_ops
, &msg_head
, ifindex
);
1431 /* we need exactly one CAN frame behind the msg head */
1432 if ((msg_head
.nframes
!= 1) || (size
!= cfsiz
+ MHSIZ
))
1435 ret
= bcm_tx_send(msg
, ifindex
, sk
, cfsiz
);
1449 * notification handler for netdevice status changes
1451 static void bcm_notify(struct bcm_sock
*bo
, unsigned long msg
,
1452 struct net_device
*dev
)
1454 struct sock
*sk
= &bo
->sk
;
1456 int notify_enodev
= 0;
1458 if (!net_eq(dev_net(dev
), sock_net(sk
)))
1463 case NETDEV_UNREGISTER
:
1466 /* remove device specific receive entries */
1467 list_for_each_entry(op
, &bo
->rx_ops
, list
)
1468 if (op
->rx_reg_dev
== dev
)
1469 bcm_rx_unreg(dev
, op
);
1471 /* remove device reference, if this is our bound device */
1472 if (bo
->bound
&& bo
->ifindex
== dev
->ifindex
) {
1473 #if IS_ENABLED(CONFIG_PROC_FS)
1474 if (sock_net(sk
)->can
.bcmproc_dir
&& bo
->bcm_proc_read
) {
1475 remove_proc_entry(bo
->procname
, sock_net(sk
)->can
.bcmproc_dir
);
1476 bo
->bcm_proc_read
= NULL
;
1486 if (notify_enodev
) {
1487 sk
->sk_err
= ENODEV
;
1488 if (!sock_flag(sk
, SOCK_DEAD
))
1489 sk_error_report(sk
);
1494 if (bo
->bound
&& bo
->ifindex
== dev
->ifindex
) {
1495 sk
->sk_err
= ENETDOWN
;
1496 if (!sock_flag(sk
, SOCK_DEAD
))
1497 sk_error_report(sk
);
1502 static int bcm_notifier(struct notifier_block
*nb
, unsigned long msg
,
1505 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1507 if (dev
->type
!= ARPHRD_CAN
)
1509 if (msg
!= NETDEV_UNREGISTER
&& msg
!= NETDEV_DOWN
)
1511 if (unlikely(bcm_busy_notifier
)) /* Check for reentrant bug. */
1514 spin_lock(&bcm_notifier_lock
);
1515 list_for_each_entry(bcm_busy_notifier
, &bcm_notifier_list
, notifier
) {
1516 spin_unlock(&bcm_notifier_lock
);
1517 bcm_notify(bcm_busy_notifier
, msg
, dev
);
1518 spin_lock(&bcm_notifier_lock
);
1520 bcm_busy_notifier
= NULL
;
1521 spin_unlock(&bcm_notifier_lock
);
1526 * initial settings for all BCM sockets to be set at socket creation time
1528 static int bcm_init(struct sock
*sk
)
1530 struct bcm_sock
*bo
= bcm_sk(sk
);
1534 bo
->dropped_usr_msgs
= 0;
1535 bo
->bcm_proc_read
= NULL
;
1537 INIT_LIST_HEAD(&bo
->tx_ops
);
1538 INIT_LIST_HEAD(&bo
->rx_ops
);
1541 spin_lock(&bcm_notifier_lock
);
1542 list_add_tail(&bo
->notifier
, &bcm_notifier_list
);
1543 spin_unlock(&bcm_notifier_lock
);
1549 * standard socket functions
1551 static int bcm_release(struct socket
*sock
)
1553 struct sock
*sk
= sock
->sk
;
1555 struct bcm_sock
*bo
;
1556 struct bcm_op
*op
, *next
;
1564 /* remove bcm_ops, timer, rx_unregister(), etc. */
1566 spin_lock(&bcm_notifier_lock
);
1567 while (bcm_busy_notifier
== bo
) {
1568 spin_unlock(&bcm_notifier_lock
);
1569 schedule_timeout_uninterruptible(1);
1570 spin_lock(&bcm_notifier_lock
);
1572 list_del(&bo
->notifier
);
1573 spin_unlock(&bcm_notifier_lock
);
1577 #if IS_ENABLED(CONFIG_PROC_FS)
1578 /* remove procfs entry */
1579 if (net
->can
.bcmproc_dir
&& bo
->bcm_proc_read
)
1580 remove_proc_entry(bo
->procname
, net
->can
.bcmproc_dir
);
1581 #endif /* CONFIG_PROC_FS */
1583 list_for_each_entry_safe(op
, next
, &bo
->tx_ops
, list
)
1586 list_for_each_entry_safe(op
, next
, &bo
->rx_ops
, list
) {
1588 * Don't care if we're bound or not (due to netdev problems)
1589 * can_rx_unregister() is always a save thing to do here.
1593 * Only remove subscriptions that had not
1594 * been removed due to NETDEV_UNREGISTER
1597 if (op
->rx_reg_dev
) {
1598 struct net_device
*dev
;
1600 dev
= dev_get_by_index(net
, op
->ifindex
);
1602 bcm_rx_unreg(dev
, op
);
1607 can_rx_unregister(net
, NULL
, op
->can_id
,
1608 REGMASK(op
->can_id
),
1609 bcm_rx_handler
, op
);
1615 list_for_each_entry_safe(op
, next
, &bo
->rx_ops
, list
)
1618 /* remove device reference */
1633 static int bcm_connect(struct socket
*sock
, struct sockaddr
*uaddr
, int len
,
1636 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
1637 struct sock
*sk
= sock
->sk
;
1638 struct bcm_sock
*bo
= bcm_sk(sk
);
1639 struct net
*net
= sock_net(sk
);
1642 if (len
< BCM_MIN_NAMELEN
)
1652 /* bind a device to this socket */
1653 if (addr
->can_ifindex
) {
1654 struct net_device
*dev
;
1656 dev
= dev_get_by_index(net
, addr
->can_ifindex
);
1661 if (dev
->type
!= ARPHRD_CAN
) {
1667 bo
->ifindex
= dev
->ifindex
;
1671 /* no interface reference for ifindex = 0 ('any' CAN device) */
1675 #if IS_ENABLED(CONFIG_PROC_FS)
1676 if (net
->can
.bcmproc_dir
) {
1677 /* unique socket address as filename */
1678 sprintf(bo
->procname
, "%lu", sock_i_ino(sk
));
1679 bo
->bcm_proc_read
= proc_create_net_single(bo
->procname
, 0644,
1680 net
->can
.bcmproc_dir
,
1682 if (!bo
->bcm_proc_read
) {
1687 #endif /* CONFIG_PROC_FS */
1697 static int bcm_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1700 struct sock
*sk
= sock
->sk
;
1701 struct sk_buff
*skb
;
1705 skb
= skb_recv_datagram(sk
, flags
, &error
);
1709 if (skb
->len
< size
)
1712 err
= memcpy_to_msg(msg
, skb
->data
, size
);
1714 skb_free_datagram(sk
, skb
);
1718 sock_recv_cmsgs(msg
, sk
, skb
);
1720 if (msg
->msg_name
) {
1721 __sockaddr_check_size(BCM_MIN_NAMELEN
);
1722 msg
->msg_namelen
= BCM_MIN_NAMELEN
;
1723 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
1726 /* assign the flags that have been recorded in bcm_send_to_user() */
1727 msg
->msg_flags
|= *(bcm_flags(skb
));
1729 skb_free_datagram(sk
, skb
);
1734 static int bcm_sock_no_ioctlcmd(struct socket
*sock
, unsigned int cmd
,
1737 /* no ioctls for socket layer -> hand it down to NIC layer */
1738 return -ENOIOCTLCMD
;
1741 static const struct proto_ops bcm_ops
= {
1743 .release
= bcm_release
,
1744 .bind
= sock_no_bind
,
1745 .connect
= bcm_connect
,
1746 .socketpair
= sock_no_socketpair
,
1747 .accept
= sock_no_accept
,
1748 .getname
= sock_no_getname
,
1749 .poll
= datagram_poll
,
1750 .ioctl
= bcm_sock_no_ioctlcmd
,
1751 .gettstamp
= sock_gettstamp
,
1752 .listen
= sock_no_listen
,
1753 .shutdown
= sock_no_shutdown
,
1754 .sendmsg
= bcm_sendmsg
,
1755 .recvmsg
= bcm_recvmsg
,
1756 .mmap
= sock_no_mmap
,
1759 static struct proto bcm_proto __read_mostly
= {
1761 .owner
= THIS_MODULE
,
1762 .obj_size
= sizeof(struct bcm_sock
),
1766 static const struct can_proto bcm_can_proto
= {
1768 .protocol
= CAN_BCM
,
1773 static int canbcm_pernet_init(struct net
*net
)
1775 #if IS_ENABLED(CONFIG_PROC_FS)
1776 /* create /proc/net/can-bcm directory */
1777 net
->can
.bcmproc_dir
= proc_net_mkdir(net
, "can-bcm", net
->proc_net
);
1778 #endif /* CONFIG_PROC_FS */
1783 static void canbcm_pernet_exit(struct net
*net
)
1785 #if IS_ENABLED(CONFIG_PROC_FS)
1786 /* remove /proc/net/can-bcm directory */
1787 if (net
->can
.bcmproc_dir
)
1788 remove_proc_entry("can-bcm", net
->proc_net
);
1789 #endif /* CONFIG_PROC_FS */
1792 static struct pernet_operations canbcm_pernet_ops __read_mostly
= {
1793 .init
= canbcm_pernet_init
,
1794 .exit
= canbcm_pernet_exit
,
1797 static struct notifier_block canbcm_notifier
= {
1798 .notifier_call
= bcm_notifier
1801 static int __init
bcm_module_init(void)
1805 pr_info("can: broadcast manager protocol\n");
1807 err
= register_pernet_subsys(&canbcm_pernet_ops
);
1811 err
= register_netdevice_notifier(&canbcm_notifier
);
1813 goto register_notifier_failed
;
1815 err
= can_proto_register(&bcm_can_proto
);
1817 printk(KERN_ERR
"can: registration of bcm protocol failed\n");
1818 goto register_proto_failed
;
1823 register_proto_failed
:
1824 unregister_netdevice_notifier(&canbcm_notifier
);
1825 register_notifier_failed
:
1826 unregister_pernet_subsys(&canbcm_pernet_ops
);
1830 static void __exit
bcm_module_exit(void)
1832 can_proto_unregister(&bcm_can_proto
);
1833 unregister_netdevice_notifier(&canbcm_notifier
);
1834 unregister_pernet_subsys(&canbcm_pernet_ops
);
1837 module_init(bcm_module_init
);
1838 module_exit(bcm_module_exit
);