~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sched/em_canid.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * em_canid.c  Ematch rule to match CAN frames according to their CAN IDs
  3  *
  4  *              This program is free software; you can distribute it and/or
  5  *              modify it under the terms of the GNU General Public License
  6  *              as published by the Free Software Foundation; either version
  7  *              2 of the License, or (at your option) any later version.
  8  *
  9  * Idea:       Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
 10  * Copyright:  (c) 2011 Czech Technical University in Prague
 11  *             (c) 2011 Volkswagen Group Research
 12  * Authors:    Michal Sojka <sojkam1@fel.cvut.cz>
 13  *             Pavel Pisa <pisa@cmp.felk.cvut.cz>
 14  *             Rostislav Lisovy <lisovy@gmail.cz>
 15  * Funded by:  Volkswagen Group Research
 16  */
 17 
 18 #include <linux/slab.h>
 19 #include <linux/module.h>
 20 #include <linux/types.h>
 21 #include <linux/kernel.h>
 22 #include <linux/string.h>
 23 #include <linux/skbuff.h>
 24 #include <net/pkt_cls.h>
 25 #include <linux/can.h>
 26 
 27 #define EM_CAN_RULES_MAX 500
 28 
 29 struct canid_match {
 30         /* For each SFF CAN ID (11 bit) there is one record in this bitfield */
 31         DECLARE_BITMAP(match_sff, (1 << CAN_SFF_ID_BITS));
 32 
 33         int rules_count;
 34         int sff_rules_count;
 35         int eff_rules_count;
 36 
 37         /*
 38          * Raw rules copied from netlink message; Used for sending
 39          * information to userspace (when 'tc filter show' is invoked)
 40          * AND when matching EFF frames
 41          */
 42         struct can_filter rules_raw[];
 43 };
 44 
 45 /**
 46  * em_canid_get_id() - Extracts Can ID out of the sk_buff structure.
 47  */
 48 static canid_t em_canid_get_id(struct sk_buff *skb)
 49 {
 50         /* CAN ID is stored within the data field */
 51         struct can_frame *cf = (struct can_frame *)skb->data;
 52 
 53         return cf->can_id;
 54 }
 55 
 56 static void em_canid_sff_match_add(struct canid_match *cm, u32 can_id,
 57                                         u32 can_mask)
 58 {
 59         int i;
 60 
 61         /*
 62          * Limit can_mask and can_id to SFF range to
 63          * protect against write after end of array
 64          */
 65         can_mask &= CAN_SFF_MASK;
 66         can_id &= can_mask;
 67 
 68         /* Single frame */
 69         if (can_mask == CAN_SFF_MASK) {
 70                 set_bit(can_id, cm->match_sff);
 71                 return;
 72         }
 73 
 74         /* All frames */
 75         if (can_mask == 0) {
 76                 bitmap_fill(cm->match_sff, (1 << CAN_SFF_ID_BITS));
 77                 return;
 78         }
 79 
 80         /*
 81          * Individual frame filter.
 82          * Add record (set bit to 1) for each ID that
 83          * conforms particular rule
 84          */
 85         for (i = 0; i < (1 << CAN_SFF_ID_BITS); i++) {
 86                 if ((i & can_mask) == can_id)
 87                         set_bit(i, cm->match_sff);
 88         }
 89 }
 90 
 91 static inline struct canid_match *em_canid_priv(struct tcf_ematch *m)
 92 {
 93         return (struct canid_match *)m->data;
 94 }
 95 
 96 static int em_canid_match(struct sk_buff *skb, struct tcf_ematch *m,
 97                          struct tcf_pkt_info *info)
 98 {
 99         struct canid_match *cm = em_canid_priv(m);
100         canid_t can_id;
101         int match = 0;
102         int i;
103         const struct can_filter *lp;
104 
105         can_id = em_canid_get_id(skb);
106 
107         if (can_id & CAN_EFF_FLAG) {
108                 for (i = 0, lp = cm->rules_raw;
109                      i < cm->eff_rules_count; i++, lp++) {
110                         if (!(((lp->can_id ^ can_id) & lp->can_mask))) {
111                                 match = 1;
112                                 break;
113                         }
114                 }
115         } else { /* SFF */
116                 can_id &= CAN_SFF_MASK;
117                 match = (test_bit(can_id, cm->match_sff) ? 1 : 0);
118         }
119 
120         return match;
121 }
122 
123 static int em_canid_change(struct net *net, void *data, int len,
124                           struct tcf_ematch *m)
125 {
126         struct can_filter *conf = data; /* Array with rules */
127         struct canid_match *cm;
128         int i;
129 
130         if (!len)
131                 return -EINVAL;
132 
133         if (len % sizeof(struct can_filter))
134                 return -EINVAL;
135 
136         if (len > sizeof(struct can_filter) * EM_CAN_RULES_MAX)
137                 return -EINVAL;
138 
139         cm = kzalloc(sizeof(struct canid_match) + len, GFP_KERNEL);
140         if (!cm)
141                 return -ENOMEM;
142 
143         cm->rules_count = len / sizeof(struct can_filter);
144 
145         /*
146          * We need two for() loops for copying rules into two contiguous
147          * areas in rules_raw to process all eff rules with a simple loop.
148          * NB: The configuration interface supports sff and eff rules.
149          * We do not support filters here that match for the same can_id
150          * provided in a SFF and EFF frame (e.g. 0x123 / 0x80000123).
151          * For this (unusual case) two filters have to be specified. The
152          * SFF/EFF separation is done with the CAN_EFF_FLAG in the can_id.
153          */
154 
155         /* Fill rules_raw with EFF rules first */
156         for (i = 0; i < cm->rules_count; i++) {
157                 if (conf[i].can_id & CAN_EFF_FLAG) {
158                         memcpy(cm->rules_raw + cm->eff_rules_count,
159                                 &conf[i],
160                                 sizeof(struct can_filter));
161 
162                         cm->eff_rules_count++;
163                 }
164         }
165 
166         /* append SFF frame rules */
167         for (i = 0; i < cm->rules_count; i++) {
168                 if (!(conf[i].can_id & CAN_EFF_FLAG)) {
169                         memcpy(cm->rules_raw
170                                 + cm->eff_rules_count
171                                 + cm->sff_rules_count,
172                                 &conf[i], sizeof(struct can_filter));
173 
174                         cm->sff_rules_count++;
175 
176                         em_canid_sff_match_add(cm,
177                                 conf[i].can_id, conf[i].can_mask);
178                 }
179         }
180 
181         m->datalen = sizeof(struct canid_match) + len;
182         m->data = (unsigned long)cm;
183         return 0;
184 }
185 
186 static void em_canid_destroy(struct tcf_ematch *m)
187 {
188         struct canid_match *cm = em_canid_priv(m);
189 
190         kfree(cm);
191 }
192 
193 static int em_canid_dump(struct sk_buff *skb, struct tcf_ematch *m)
194 {
195         struct canid_match *cm = em_canid_priv(m);
196 
197         /*
198          * When configuring this ematch 'rules_count' is set not to exceed
199          * 'rules_raw' array size
200          */
201         if (nla_put_nohdr(skb, sizeof(struct can_filter) * cm->rules_count,
202             &cm->rules_raw) < 0)
203                 return -EMSGSIZE;
204 
205         return 0;
206 }
207 
208 static struct tcf_ematch_ops em_canid_ops = {
209         .kind     = TCF_EM_CANID,
210         .change   = em_canid_change,
211         .match    = em_canid_match,
212         .destroy  = em_canid_destroy,
213         .dump     = em_canid_dump,
214         .owner    = THIS_MODULE,
215         .link     = LIST_HEAD_INIT(em_canid_ops.link)
216 };
217 
218 static int __init init_em_canid(void)
219 {
220         return tcf_em_register(&em_canid_ops);
221 }
222 
223 static void __exit exit_em_canid(void)
224 {
225         tcf_em_unregister(&em_canid_ops);
226 }
227 
228 MODULE_LICENSE("GPL");
229 
230 module_init(init_em_canid);
231 module_exit(exit_em_canid);
232 
233 MODULE_ALIAS_TCF_EMATCH(TCF_EM_CANID);
234 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp