2 * gw.c - CAN frame Gateway/Router/Bridge with netlink interface
4 * Copyright (c) 2011 Volkswagen Group Electronic Research
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Volkswagen nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * Alternatively, provided that this notice is retained in full, this
20 * software may be distributed under the terms of the GNU General
21 * Public License ("GPL") version 2, in which case the provisions of the
22 * GPL apply INSTEAD OF those given above.
24 * The provided data structures and external interfaces from this code
25 * are not restricted to be used by modules with a GPL compatible license.
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/types.h>
45 #include <linux/list.h>
46 #include <linux/spinlock.h>
47 #include <linux/rcupdate.h>
48 #include <linux/rculist.h>
49 #include <linux/net.h>
50 #include <linux/netdevice.h>
51 #include <linux/if_arp.h>
52 #include <linux/skbuff.h>
53 #include <linux/can.h>
54 #include <linux/can/core.h>
55 #include <linux/can/gw.h>
56 #include <net/rtnetlink.h>
57 #include <net/net_namespace.h>
60 #define CAN_GW_VERSION "20101209"
61 static __initconst
const char banner
[] =
62 KERN_INFO
"can: netlink gateway (rev " CAN_GW_VERSION
")\n";
64 MODULE_DESCRIPTION("PF_CAN netlink gateway");
65 MODULE_LICENSE("Dual BSD/GPL");
66 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
67 MODULE_ALIAS("can-gw");
69 static HLIST_HEAD(cgw_list
);
70 static struct notifier_block notifier
;
72 static struct kmem_cache
*cgw_cache __read_mostly
;
74 /* structure that contains the (on-the-fly) CAN frame modifications */
88 void (*modfunc
[MAX_MODFUNCTIONS
])(struct can_frame
*cf
,
91 /* CAN frame checksum calculation after CAN frame modifications */
93 struct cgw_csum_xor
xor;
94 struct cgw_csum_crc8 crc8
;
97 void (*xor)(struct can_frame
*cf
, struct cgw_csum_xor
*xor);
98 void (*crc8
)(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
);
104 * So far we just support CAN -> CAN routing and frame modifications.
106 * The internal can_can_gw structure contains data and attributes for
107 * a CAN -> CAN gateway job.
110 struct can_filter filter
;
115 /* list entry for CAN gateways jobs */
117 struct hlist_node list
;
123 /* CAN frame data source */
124 struct net_device
*dev
;
127 /* CAN frame data destination */
128 struct net_device
*dev
;
131 struct can_can_gw ccgw
;
138 /* modification functions that are invoked in the hot path in can_can_gw_rcv */
140 #define MODFUNC(func, op) static void func(struct can_frame *cf, \
141 struct cf_mod *mod) { op ; }
143 MODFUNC(mod_and_id
, cf
->can_id
&= mod
->modframe
.and.can_id
)
144 MODFUNC(mod_and_dlc
, cf
->can_dlc
&= mod
->modframe
.and.can_dlc
)
145 MODFUNC(mod_and_data
, *(u64
*)cf
->data
&= *(u64
*)mod
->modframe
.and.data
)
146 MODFUNC(mod_or_id
, cf
->can_id
|= mod
->modframe
.or.can_id
)
147 MODFUNC(mod_or_dlc
, cf
->can_dlc
|= mod
->modframe
.or.can_dlc
)
148 MODFUNC(mod_or_data
, *(u64
*)cf
->data
|= *(u64
*)mod
->modframe
.or.data
)
149 MODFUNC(mod_xor_id
, cf
->can_id
^= mod
->modframe
.xor.can_id
)
150 MODFUNC(mod_xor_dlc
, cf
->can_dlc
^= mod
->modframe
.xor.can_dlc
)
151 MODFUNC(mod_xor_data
, *(u64
*)cf
->data
^= *(u64
*)mod
->modframe
.xor.data
)
152 MODFUNC(mod_set_id
, cf
->can_id
= mod
->modframe
.set
.can_id
)
153 MODFUNC(mod_set_dlc
, cf
->can_dlc
= mod
->modframe
.set
.can_dlc
)
154 MODFUNC(mod_set_data
, *(u64
*)cf
->data
= *(u64
*)mod
->modframe
.set
.data
)
156 static inline void canframecpy(struct can_frame
*dst
, struct can_frame
*src
)
159 * Copy the struct members separately to ensure that no uninitialized
160 * data are copied in the 3 bytes hole of the struct. This is needed
161 * to make easy compares of the data in the struct cf_mod.
164 dst
->can_id
= src
->can_id
;
165 dst
->can_dlc
= src
->can_dlc
;
166 *(u64
*)dst
->data
= *(u64
*)src
->data
;
169 static int cgw_chk_csum_parms(s8 fr
, s8 to
, s8 re
)
172 * absolute dlc values 0 .. 7 => 0 .. 7, e.g. data [0]
173 * relative to received dlc -1 .. -8 :
174 * e.g. for received dlc = 8
175 * -1 => index = 7 (data[7])
176 * -3 => index = 5 (data[5])
177 * -8 => index = 0 (data[0])
180 if (fr
> -9 && fr
< 8 &&
188 static inline int calc_idx(int idx
, int rx_dlc
)
196 static void cgw_csum_xor_rel(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
198 int from
= calc_idx(xor->from_idx
, cf
->can_dlc
);
199 int to
= calc_idx(xor->to_idx
, cf
->can_dlc
);
200 int res
= calc_idx(xor->result_idx
, cf
->can_dlc
);
201 u8 val
= xor->init_xor_val
;
204 if (from
< 0 || to
< 0 || res
< 0)
208 for (i
= from
; i
<= to
; i
++)
211 for (i
= from
; i
>= to
; i
--)
218 static void cgw_csum_xor_pos(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
220 u8 val
= xor->init_xor_val
;
223 for (i
= xor->from_idx
; i
<= xor->to_idx
; i
++)
226 cf
->data
[xor->result_idx
] = val
;
229 static void cgw_csum_xor_neg(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
231 u8 val
= xor->init_xor_val
;
234 for (i
= xor->from_idx
; i
>= xor->to_idx
; i
--)
237 cf
->data
[xor->result_idx
] = val
;
240 static void cgw_csum_crc8_rel(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
242 int from
= calc_idx(crc8
->from_idx
, cf
->can_dlc
);
243 int to
= calc_idx(crc8
->to_idx
, cf
->can_dlc
);
244 int res
= calc_idx(crc8
->result_idx
, cf
->can_dlc
);
245 u8 crc
= crc8
->init_crc_val
;
248 if (from
< 0 || to
< 0 || res
< 0)
252 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
253 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
255 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
256 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
259 switch (crc8
->profile
) {
261 case CGW_CRC8PRF_1U8
:
262 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
265 case CGW_CRC8PRF_16U8
:
266 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
269 case CGW_CRC8PRF_SFFID_XOR
:
270 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
271 (cf
->can_id
>> 8 & 0xFF)];
276 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
279 static void cgw_csum_crc8_pos(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
281 u8 crc
= crc8
->init_crc_val
;
284 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
285 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
287 switch (crc8
->profile
) {
289 case CGW_CRC8PRF_1U8
:
290 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
293 case CGW_CRC8PRF_16U8
:
294 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
297 case CGW_CRC8PRF_SFFID_XOR
:
298 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
299 (cf
->can_id
>> 8 & 0xFF)];
303 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
306 static void cgw_csum_crc8_neg(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
308 u8 crc
= crc8
->init_crc_val
;
311 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
312 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
314 switch (crc8
->profile
) {
316 case CGW_CRC8PRF_1U8
:
317 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
320 case CGW_CRC8PRF_16U8
:
321 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
324 case CGW_CRC8PRF_SFFID_XOR
:
325 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
326 (cf
->can_id
>> 8 & 0xFF)];
330 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
333 /* the receive & process & send function */
334 static void can_can_gw_rcv(struct sk_buff
*skb
, void *data
)
336 struct cgw_job
*gwj
= (struct cgw_job
*)data
;
337 struct can_frame
*cf
;
338 struct sk_buff
*nskb
;
341 /* do not handle already routed frames - see comment below */
342 if (skb_mac_header_was_set(skb
))
345 if (!(gwj
->dst
.dev
->flags
& IFF_UP
)) {
346 gwj
->dropped_frames
++;
351 * clone the given skb, which has not been done in can_rcv()
353 * When there is at least one modification function activated,
354 * we need to copy the skb as we want to modify skb->data.
356 if (gwj
->mod
.modfunc
[0])
357 nskb
= skb_copy(skb
, GFP_ATOMIC
);
359 nskb
= skb_clone(skb
, GFP_ATOMIC
);
362 gwj
->dropped_frames
++;
367 * Mark routed frames by setting some mac header length which is
368 * not relevant for the CAN frames located in the skb->data section.
370 * As dev->header_ops is not set in CAN netdevices no one is ever
371 * accessing the various header offsets in the CAN skbuffs anyway.
372 * E.g. using the packet socket to read CAN frames is still working.
374 skb_set_mac_header(nskb
, 8);
375 nskb
->dev
= gwj
->dst
.dev
;
377 /* pointer to modifiable CAN frame */
378 cf
= (struct can_frame
*)nskb
->data
;
380 /* perform preprocessed modification functions if there are any */
381 while (modidx
< MAX_MODFUNCTIONS
&& gwj
->mod
.modfunc
[modidx
])
382 (*gwj
->mod
.modfunc
[modidx
++])(cf
, &gwj
->mod
);
384 /* check for checksum updates when the CAN frame has been modified */
386 if (gwj
->mod
.csumfunc
.crc8
)
387 (*gwj
->mod
.csumfunc
.crc8
)(cf
, &gwj
->mod
.csum
.crc8
);
389 if (gwj
->mod
.csumfunc
.xor)
390 (*gwj
->mod
.csumfunc
.xor)(cf
, &gwj
->mod
.csum
.xor);
393 /* clear the skb timestamp if not configured the other way */
394 if (!(gwj
->flags
& CGW_FLAGS_CAN_SRC_TSTAMP
))
395 nskb
->tstamp
.tv64
= 0;
397 /* send to netdevice */
398 if (can_send(nskb
, gwj
->flags
& CGW_FLAGS_CAN_ECHO
))
399 gwj
->dropped_frames
++;
401 gwj
->handled_frames
++;
404 static inline int cgw_register_filter(struct cgw_job
*gwj
)
406 return can_rx_register(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
407 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
,
411 static inline void cgw_unregister_filter(struct cgw_job
*gwj
)
413 can_rx_unregister(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
414 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
, gwj
);
417 static int cgw_notifier(struct notifier_block
*nb
,
418 unsigned long msg
, void *data
)
420 struct net_device
*dev
= (struct net_device
*)data
;
422 if (!net_eq(dev_net(dev
), &init_net
))
424 if (dev
->type
!= ARPHRD_CAN
)
427 if (msg
== NETDEV_UNREGISTER
) {
429 struct cgw_job
*gwj
= NULL
;
430 struct hlist_node
*n
, *nx
;
434 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
436 if (gwj
->src
.dev
== dev
|| gwj
->dst
.dev
== dev
) {
437 hlist_del(&gwj
->list
);
438 cgw_unregister_filter(gwj
);
447 static int cgw_put_job(struct sk_buff
*skb
, struct cgw_job
*gwj
, int type
,
448 u32 pid
, u32 seq
, int flags
)
450 struct cgw_frame_mod mb
;
451 struct rtcanmsg
*rtcan
;
452 struct nlmsghdr
*nlh
;
454 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*rtcan
), flags
);
458 rtcan
= nlmsg_data(nlh
);
459 rtcan
->can_family
= AF_CAN
;
460 rtcan
->gwtype
= gwj
->gwtype
;
461 rtcan
->flags
= gwj
->flags
;
463 /* add statistics if available */
465 if (gwj
->handled_frames
) {
466 if (nla_put_u32(skb
, CGW_HANDLED
, gwj
->handled_frames
) < 0)
470 if (gwj
->dropped_frames
) {
471 if (nla_put_u32(skb
, CGW_DROPPED
, gwj
->dropped_frames
) < 0)
475 /* check non default settings of attributes */
477 if (gwj
->mod
.modtype
.and) {
478 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.and, sizeof(mb
.cf
));
479 mb
.modtype
= gwj
->mod
.modtype
.and;
480 if (nla_put(skb
, CGW_MOD_AND
, sizeof(mb
), &mb
) < 0)
484 if (gwj
->mod
.modtype
.or) {
485 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.or, sizeof(mb
.cf
));
486 mb
.modtype
= gwj
->mod
.modtype
.or;
487 if (nla_put(skb
, CGW_MOD_OR
, sizeof(mb
), &mb
) < 0)
491 if (gwj
->mod
.modtype
.xor) {
492 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.xor, sizeof(mb
.cf
));
493 mb
.modtype
= gwj
->mod
.modtype
.xor;
494 if (nla_put(skb
, CGW_MOD_XOR
, sizeof(mb
), &mb
) < 0)
498 if (gwj
->mod
.modtype
.set
) {
499 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.set
, sizeof(mb
.cf
));
500 mb
.modtype
= gwj
->mod
.modtype
.set
;
501 if (nla_put(skb
, CGW_MOD_SET
, sizeof(mb
), &mb
) < 0)
505 if (gwj
->mod
.csumfunc
.crc8
) {
506 if (nla_put(skb
, CGW_CS_CRC8
, CGW_CS_CRC8_LEN
,
507 &gwj
->mod
.csum
.crc8
) < 0)
511 if (gwj
->mod
.csumfunc
.xor) {
512 if (nla_put(skb
, CGW_CS_XOR
, CGW_CS_XOR_LEN
,
513 &gwj
->mod
.csum
.xor) < 0)
517 if (gwj
->gwtype
== CGW_TYPE_CAN_CAN
) {
519 if (gwj
->ccgw
.filter
.can_id
|| gwj
->ccgw
.filter
.can_mask
) {
520 if (nla_put(skb
, CGW_FILTER
, sizeof(struct can_filter
),
521 &gwj
->ccgw
.filter
) < 0)
525 if (nla_put_u32(skb
, CGW_SRC_IF
, gwj
->ccgw
.src_idx
) < 0)
528 if (nla_put_u32(skb
, CGW_DST_IF
, gwj
->ccgw
.dst_idx
) < 0)
532 return nlmsg_end(skb
, nlh
);
535 nlmsg_cancel(skb
, nlh
);
539 /* Dump information about all CAN gateway jobs, in response to RTM_GETROUTE */
540 static int cgw_dump_jobs(struct sk_buff
*skb
, struct netlink_callback
*cb
)
542 struct cgw_job
*gwj
= NULL
;
543 struct hlist_node
*n
;
545 int s_idx
= cb
->args
[0];
548 hlist_for_each_entry_rcu(gwj
, n
, &cgw_list
, list
) {
552 if (cgw_put_job(skb
, gwj
, RTM_NEWROUTE
, NETLINK_CB(cb
->skb
).portid
,
553 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
) < 0)
565 static const struct nla_policy cgw_policy
[CGW_MAX
+1] = {
566 [CGW_MOD_AND
] = { .len
= sizeof(struct cgw_frame_mod
) },
567 [CGW_MOD_OR
] = { .len
= sizeof(struct cgw_frame_mod
) },
568 [CGW_MOD_XOR
] = { .len
= sizeof(struct cgw_frame_mod
) },
569 [CGW_MOD_SET
] = { .len
= sizeof(struct cgw_frame_mod
) },
570 [CGW_CS_XOR
] = { .len
= sizeof(struct cgw_csum_xor
) },
571 [CGW_CS_CRC8
] = { .len
= sizeof(struct cgw_csum_crc8
) },
572 [CGW_SRC_IF
] = { .type
= NLA_U32
},
573 [CGW_DST_IF
] = { .type
= NLA_U32
},
574 [CGW_FILTER
] = { .len
= sizeof(struct can_filter
) },
577 /* check for common and gwtype specific attributes */
578 static int cgw_parse_attr(struct nlmsghdr
*nlh
, struct cf_mod
*mod
,
579 u8 gwtype
, void *gwtypeattr
)
581 struct nlattr
*tb
[CGW_MAX
+1];
582 struct cgw_frame_mod mb
;
586 /* initialize modification & checksum data space */
587 memset(mod
, 0, sizeof(*mod
));
589 err
= nlmsg_parse(nlh
, sizeof(struct rtcanmsg
), tb
, CGW_MAX
,
594 /* check for AND/OR/XOR/SET modifications */
596 if (tb
[CGW_MOD_AND
]) {
597 nla_memcpy(&mb
, tb
[CGW_MOD_AND
], CGW_MODATTR_LEN
);
599 canframecpy(&mod
->modframe
.and, &mb
.cf
);
600 mod
->modtype
.and = mb
.modtype
;
602 if (mb
.modtype
& CGW_MOD_ID
)
603 mod
->modfunc
[modidx
++] = mod_and_id
;
605 if (mb
.modtype
& CGW_MOD_DLC
)
606 mod
->modfunc
[modidx
++] = mod_and_dlc
;
608 if (mb
.modtype
& CGW_MOD_DATA
)
609 mod
->modfunc
[modidx
++] = mod_and_data
;
612 if (tb
[CGW_MOD_OR
]) {
613 nla_memcpy(&mb
, tb
[CGW_MOD_OR
], CGW_MODATTR_LEN
);
615 canframecpy(&mod
->modframe
.or, &mb
.cf
);
616 mod
->modtype
.or = mb
.modtype
;
618 if (mb
.modtype
& CGW_MOD_ID
)
619 mod
->modfunc
[modidx
++] = mod_or_id
;
621 if (mb
.modtype
& CGW_MOD_DLC
)
622 mod
->modfunc
[modidx
++] = mod_or_dlc
;
624 if (mb
.modtype
& CGW_MOD_DATA
)
625 mod
->modfunc
[modidx
++] = mod_or_data
;
628 if (tb
[CGW_MOD_XOR
]) {
629 nla_memcpy(&mb
, tb
[CGW_MOD_XOR
], CGW_MODATTR_LEN
);
631 canframecpy(&mod
->modframe
.xor, &mb
.cf
);
632 mod
->modtype
.xor = mb
.modtype
;
634 if (mb
.modtype
& CGW_MOD_ID
)
635 mod
->modfunc
[modidx
++] = mod_xor_id
;
637 if (mb
.modtype
& CGW_MOD_DLC
)
638 mod
->modfunc
[modidx
++] = mod_xor_dlc
;
640 if (mb
.modtype
& CGW_MOD_DATA
)
641 mod
->modfunc
[modidx
++] = mod_xor_data
;
644 if (tb
[CGW_MOD_SET
]) {
645 nla_memcpy(&mb
, tb
[CGW_MOD_SET
], CGW_MODATTR_LEN
);
647 canframecpy(&mod
->modframe
.set
, &mb
.cf
);
648 mod
->modtype
.set
= mb
.modtype
;
650 if (mb
.modtype
& CGW_MOD_ID
)
651 mod
->modfunc
[modidx
++] = mod_set_id
;
653 if (mb
.modtype
& CGW_MOD_DLC
)
654 mod
->modfunc
[modidx
++] = mod_set_dlc
;
656 if (mb
.modtype
& CGW_MOD_DATA
)
657 mod
->modfunc
[modidx
++] = mod_set_data
;
660 /* check for checksum operations after CAN frame modifications */
663 if (tb
[CGW_CS_CRC8
]) {
664 struct cgw_csum_crc8
*c
= nla_data(tb
[CGW_CS_CRC8
]);
666 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
671 nla_memcpy(&mod
->csum
.crc8
, tb
[CGW_CS_CRC8
],
675 * select dedicated processing function to reduce
676 * runtime operations in receive hot path.
678 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
680 mod
->csumfunc
.crc8
= cgw_csum_crc8_rel
;
681 else if (c
->from_idx
<= c
->to_idx
)
682 mod
->csumfunc
.crc8
= cgw_csum_crc8_pos
;
684 mod
->csumfunc
.crc8
= cgw_csum_crc8_neg
;
687 if (tb
[CGW_CS_XOR
]) {
688 struct cgw_csum_xor
*c
= nla_data(tb
[CGW_CS_XOR
]);
690 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
695 nla_memcpy(&mod
->csum
.xor, tb
[CGW_CS_XOR
],
699 * select dedicated processing function to reduce
700 * runtime operations in receive hot path.
702 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
704 mod
->csumfunc
.xor = cgw_csum_xor_rel
;
705 else if (c
->from_idx
<= c
->to_idx
)
706 mod
->csumfunc
.xor = cgw_csum_xor_pos
;
708 mod
->csumfunc
.xor = cgw_csum_xor_neg
;
712 if (gwtype
== CGW_TYPE_CAN_CAN
) {
714 /* check CGW_TYPE_CAN_CAN specific attributes */
716 struct can_can_gw
*ccgw
= (struct can_can_gw
*)gwtypeattr
;
717 memset(ccgw
, 0, sizeof(*ccgw
));
719 /* check for can_filter in attributes */
721 nla_memcpy(&ccgw
->filter
, tb
[CGW_FILTER
],
722 sizeof(struct can_filter
));
726 /* specifying two interfaces is mandatory */
727 if (!tb
[CGW_SRC_IF
] || !tb
[CGW_DST_IF
])
730 ccgw
->src_idx
= nla_get_u32(tb
[CGW_SRC_IF
]);
731 ccgw
->dst_idx
= nla_get_u32(tb
[CGW_DST_IF
]);
733 /* both indices set to 0 for flushing all routing entries */
734 if (!ccgw
->src_idx
&& !ccgw
->dst_idx
)
737 /* only one index set to 0 is an error */
738 if (!ccgw
->src_idx
|| !ccgw
->dst_idx
)
742 /* add the checks for other gwtypes here */
747 static int cgw_create_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
754 if (!capable(CAP_NET_ADMIN
))
757 if (nlmsg_len(nlh
) < sizeof(*r
))
761 if (r
->can_family
!= AF_CAN
)
762 return -EPFNOSUPPORT
;
764 /* so far we only support CAN -> CAN routings */
765 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
768 gwj
= kmem_cache_alloc(cgw_cache
, GFP_KERNEL
);
772 gwj
->handled_frames
= 0;
773 gwj
->dropped_frames
= 0;
774 gwj
->flags
= r
->flags
;
775 gwj
->gwtype
= r
->gwtype
;
777 err
= cgw_parse_attr(nlh
, &gwj
->mod
, CGW_TYPE_CAN_CAN
, &gwj
->ccgw
);
783 /* ifindex == 0 is not allowed for job creation */
784 if (!gwj
->ccgw
.src_idx
|| !gwj
->ccgw
.dst_idx
)
787 gwj
->src
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.src_idx
);
792 /* check for CAN netdev not using header_ops - see gw_rcv() */
793 if (gwj
->src
.dev
->type
!= ARPHRD_CAN
|| gwj
->src
.dev
->header_ops
)
796 gwj
->dst
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.dst_idx
);
801 /* check for CAN netdev not using header_ops - see gw_rcv() */
802 if (gwj
->dst
.dev
->type
!= ARPHRD_CAN
|| gwj
->dst
.dev
->header_ops
)
803 goto put_src_dst_out
;
807 err
= cgw_register_filter(gwj
);
809 hlist_add_head_rcu(&gwj
->list
, &cgw_list
);
812 dev_put(gwj
->dst
.dev
);
814 dev_put(gwj
->src
.dev
);
817 kmem_cache_free(cgw_cache
, gwj
);
822 static void cgw_remove_all_jobs(void)
824 struct cgw_job
*gwj
= NULL
;
825 struct hlist_node
*n
, *nx
;
829 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
830 hlist_del(&gwj
->list
);
831 cgw_unregister_filter(gwj
);
836 static int cgw_remove_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
838 struct cgw_job
*gwj
= NULL
;
839 struct hlist_node
*n
, *nx
;
842 struct can_can_gw ccgw
;
845 if (!capable(CAP_NET_ADMIN
))
848 if (nlmsg_len(nlh
) < sizeof(*r
))
852 if (r
->can_family
!= AF_CAN
)
853 return -EPFNOSUPPORT
;
855 /* so far we only support CAN -> CAN routings */
856 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
859 err
= cgw_parse_attr(nlh
, &mod
, CGW_TYPE_CAN_CAN
, &ccgw
);
863 /* two interface indices both set to 0 => remove all entries */
864 if (!ccgw
.src_idx
&& !ccgw
.dst_idx
) {
865 cgw_remove_all_jobs();
873 /* remove only the first matching entry */
874 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
876 if (gwj
->flags
!= r
->flags
)
879 if (memcmp(&gwj
->mod
, &mod
, sizeof(mod
)))
882 /* if (r->gwtype == CGW_TYPE_CAN_CAN) - is made sure here */
883 if (memcmp(&gwj
->ccgw
, &ccgw
, sizeof(ccgw
)))
886 hlist_del(&gwj
->list
);
887 cgw_unregister_filter(gwj
);
896 static __init
int cgw_module_init(void)
900 cgw_cache
= kmem_cache_create("can_gw", sizeof(struct cgw_job
),
907 notifier
.notifier_call
= cgw_notifier
;
908 register_netdevice_notifier(¬ifier
);
910 if (__rtnl_register(PF_CAN
, RTM_GETROUTE
, NULL
, cgw_dump_jobs
, NULL
)) {
911 unregister_netdevice_notifier(¬ifier
);
912 kmem_cache_destroy(cgw_cache
);
916 /* Only the first call to __rtnl_register can fail */
917 __rtnl_register(PF_CAN
, RTM_NEWROUTE
, cgw_create_job
, NULL
, NULL
);
918 __rtnl_register(PF_CAN
, RTM_DELROUTE
, cgw_remove_job
, NULL
, NULL
);
923 static __exit
void cgw_module_exit(void)
925 rtnl_unregister_all(PF_CAN
);
927 unregister_netdevice_notifier(¬ifier
);
930 cgw_remove_all_jobs();
933 rcu_barrier(); /* Wait for completion of call_rcu()'s */
935 kmem_cache_destroy(cgw_cache
);
938 module_init(cgw_module_init
);
939 module_exit(cgw_module_exit
);