lib/route/cls/u32.c

   1 /*
   2  * lib/route/cls/u32.c          u32 classifier
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2009 Thomas Graf <tgraf@suug.ch>
  10  * Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
  11  * Copyright (c) 2005-2006 Siemens AG Oesterreich
  12  */
  13
  14 /**
  15  * @ingroup cls_api
  16  * @defgroup u32 Universal 32-bit Classifier
  17  *
  18  * @{
  19  */
  20
  21 #include <netlink-local.h>
  22 #include <netlink-tc.h>
  23 #include <netlink/netlink.h>
  24 #include <netlink/attr.h>
  25 #include <netlink/utils.h>
  26 #include <netlink/route/tc.h>
  27 #include <netlink/route/classifier.h>
  28 #include <netlink/route/classifier-modules.h>
  29 #include <netlink/route/cls/u32.h>
  30
  31 /** @cond SKIP */
  32 #define U32_ATTR_DIVISOR      0x001
  33 #define U32_ATTR_HASH         0x002
  34 #define U32_ATTR_CLASSID      0x004
  35 #define U32_ATTR_LINK         0x008
  36 #define U32_ATTR_PCNT         0x010
  37 #define U32_ATTR_SELECTOR     0x020
  38 #define U32_ATTR_ACTION       0x040
  39 #define U32_ATTR_POLICE       0x080
  40 #define U32_ATTR_INDEV        0x100
  41 /** @endcond */
  42
  43 static inline struct tc_u32_sel *u32_selector(struct rtnl_u32 *u)
  44 {
  45         return (struct tc_u32_sel *) u->cu_selector->d_data;
  46 }
  47
  48 static inline struct tc_u32_sel *u32_selector_alloc(struct rtnl_u32 *u)
  49 {
  50         if (!u->cu_selector)
  51                 u->cu_selector = nl_data_alloc(NULL, sizeof(struct tc_u32_sel));
  52
  53         return u32_selector(u);
  54 }
  55
  56 static struct nla_policy u32_policy[TCA_U32_MAX+1] = {
  57         [TCA_U32_DIVISOR]       = { .type = NLA_U32 },
  58         [TCA_U32_HASH]          = { .type = NLA_U32 },
  59         [TCA_U32_CLASSID]       = { .type = NLA_U32 },
  60         [TCA_U32_LINK]          = { .type = NLA_U32 },
  61         [TCA_U32_INDEV]         = { .type = NLA_STRING,
  62                                     .maxlen = IFNAMSIZ },
  63         [TCA_U32_SEL]           = { .minlen = sizeof(struct tc_u32_sel) },
  64         [TCA_U32_PCNT]          = { .minlen = sizeof(struct tc_u32_pcnt) },
  65 };
  66
  67 static int u32_msg_parser(struct rtnl_cls *cls)
  68 {
  69         struct rtnl_u32 *u = rtnl_cls_data(cls);
  70         struct nlattr *tb[TCA_U32_MAX + 1];
  71         int err;
  72
  73         err = tca_parse(tb, TCA_U32_MAX, (struct rtnl_tca *) cls, u32_policy);
  74         if (err < 0)
  75                 return err;
  76
  77         if (tb[TCA_U32_DIVISOR]) {
  78                 u->cu_divisor = nla_get_u32(tb[TCA_U32_DIVISOR]);
  79                 u->cu_mask |= U32_ATTR_DIVISOR;
  80         }
  81
  82         if (tb[TCA_U32_SEL]) {
  83                 u->cu_selector = nl_data_alloc_attr(tb[TCA_U32_SEL]);
  84                 if (!u->cu_selector)
  85                         goto errout_nomem;
  86                 u->cu_mask |= U32_ATTR_SELECTOR;
  87         }
  88
  89         if (tb[TCA_U32_HASH]) {
  90                 u->cu_hash = nla_get_u32(tb[TCA_U32_HASH]);
  91                 u->cu_mask |= U32_ATTR_HASH;
  92         }
  93
  94         if (tb[TCA_U32_CLASSID]) {
  95                 u->cu_classid = nla_get_u32(tb[TCA_U32_CLASSID]);
  96                 u->cu_mask |= U32_ATTR_CLASSID;
  97         }
  98
  99         if (tb[TCA_U32_LINK]) {
 100                 u->cu_link = nla_get_u32(tb[TCA_U32_LINK]);
 101                 u->cu_mask |= U32_ATTR_LINK;
 102         }
 103
 104         if (tb[TCA_U32_ACT]) {
 105                 u->cu_act = nl_data_alloc_attr(tb[TCA_U32_ACT]);
 106                 if (!u->cu_act)
 107                         goto errout_nomem;
 108                 u->cu_mask |= U32_ATTR_ACTION;
 109         }
 110
 111         if (tb[TCA_U32_POLICE]) {
 112                 u->cu_police = nl_data_alloc_attr(tb[TCA_U32_POLICE]);
 113                 if (!u->cu_police)
 114                         goto errout_nomem;
 115                 u->cu_mask |= U32_ATTR_POLICE;
 116         }
 117
 118         if (tb[TCA_U32_PCNT]) {
 119                 struct tc_u32_sel *sel;
 120                 int pcnt_size;
 121
 122                 if (!tb[TCA_U32_SEL]) {
 123                         err = -NLE_MISSING_ATTR;
 124                         goto errout;
 125                 }
 126
 127                 sel = u->cu_selector->d_data;
 128                 pcnt_size = sizeof(struct tc_u32_pcnt) +
 129                                 (sel->nkeys * sizeof(uint64_t));
 130                 if (nla_len(tb[TCA_U32_PCNT]) < pcnt_size) {
 131                         err = -NLE_INVAL;
 132                         goto errout;
 133                 }
 134
 135                 u->cu_pcnt = nl_data_alloc_attr(tb[TCA_U32_PCNT]);
 136                 if (!u->cu_pcnt)
 137                         goto errout_nomem;
 138                 u->cu_mask |= U32_ATTR_PCNT;
 139         }
 140
 141         if (tb[TCA_U32_INDEV]) {
 142                 nla_strlcpy(u->cu_indev, tb[TCA_U32_INDEV], IFNAMSIZ);
 143                 u->cu_mask |= U32_ATTR_INDEV;
 144         }
 145
 146         return 0;
 147
 148 errout_nomem:
 149         err = -NLE_NOMEM;
 150 errout:
 151         return err;
 152 }
 153
 154 static void u32_free_data(struct rtnl_cls *cls)
 155 {
 156         struct rtnl_u32 *u = rtnl_cls_data(cls);
 157
 158         nl_data_free(u->cu_selector);
 159         nl_data_free(u->cu_act);
 160         nl_data_free(u->cu_police);
 161         nl_data_free(u->cu_pcnt);
 162 }
 163
 164 static int u32_clone(struct rtnl_cls *_dst, struct rtnl_cls *_src)
 165 {
 166         struct rtnl_u32 *dst = rtnl_cls_data(_dst);
 167         struct rtnl_u32 *src = rtnl_cls_data(_src);
 168
 169         if (src->cu_selector &&
 170             !(dst->cu_selector = nl_data_clone(src->cu_selector)))
 171                 return -NLE_NOMEM;
 172
 173         if (src->cu_act && !(dst->cu_act = nl_data_clone(src->cu_act)))
 174                 return -NLE_NOMEM;
 175
 176         if (src->cu_police && !(dst->cu_police = nl_data_clone(src->cu_police)))
 177                 return -NLE_NOMEM;
 178
 179         if (src->cu_pcnt && !(dst->cu_pcnt = nl_data_clone(src->cu_pcnt)))
 180                 return -NLE_NOMEM;
 181
 182         return 0;
 183 }
 184
 185 static void u32_dump_line(struct rtnl_cls *cls, struct nl_dump_params *p)
 186 {
 187         struct rtnl_u32 *u = rtnl_cls_data(cls);
 188         char buf[32];
 189
 190         if (u->cu_mask & U32_ATTR_DIVISOR)
 191                 nl_dump(p, " divisor %u", u->cu_divisor);
 192         else if (u->cu_mask & U32_ATTR_CLASSID)
 193                 nl_dump(p, " target %s",
 194                         rtnl_tc_handle2str(u->cu_classid, buf, sizeof(buf)));
 195 }
 196
 197 static void print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
 198                            struct rtnl_cls *cls, struct rtnl_u32 *u)
 199 {
 200         int i;
 201         struct tc_u32_key *key;
 202
 203         if (sel->hmask || sel->hoff) {
 204                 /* I guess this will never be used since the kernel only
 205                  * exports the selector if no divisor is set but hash offset
 206                  * and hash mask make only sense in hash filters with divisor
 207                  * set */
 208                 nl_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
 209         }
 210
 211         if (sel->flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
 212                 nl_dump(p, " offset at %u", sel->off);
 213
 214                 if (sel->flags & TC_U32_VAROFFSET)
 215                         nl_dump(p, " variable (at %u & 0x%x) >> %u",
 216                                 sel->offoff, ntohs(sel->offmask), sel->offshift);
 217         }
 218
 219         if (sel->flags) {
 220                 int flags = sel->flags;
 221                 nl_dump(p, " <");
 222
 223 #define PRINT_FLAG(f) if (flags & TC_U32_##f) { \
 224         flags &= ~TC_U32_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
 225
 226                 PRINT_FLAG(TERMINAL);
 227                 PRINT_FLAG(OFFSET);
 228                 PRINT_FLAG(VAROFFSET);
 229                 PRINT_FLAG(EAT);
 230 #undef PRINT_FLAG
 231
 232                 nl_dump(p, ">");
 233         }
 234
 235
 236         for (i = 0; i < sel->nkeys; i++) {
 237                 key = (struct tc_u32_key *) ((char *) sel + sizeof(*sel)) + i;
 238
 239                 nl_dump(p, "\n");
 240                 nl_dump_line(p, "      match key at %s%u ",
 241                         key->offmask ? "nexthdr+" : "", key->off);
 242
 243                 if (key->offmask)
 244                         nl_dump(p, "[0x%u] ", key->offmask);
 245
 246                 nl_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
 247
 248                 if (p->dp_type == NL_DUMP_STATS &&
 249                     (u->cu_mask & U32_ATTR_PCNT)) {
 250                         struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
 251                         nl_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
 252                 }
 253         }
 254 }
 255
 256 static void u32_dump_details(struct rtnl_cls *cls, struct nl_dump_params *p)
 257 {
 258         struct rtnl_u32 *u = rtnl_cls_data(cls);
 259         struct tc_u32_sel *s;
 260
 261         if (!(u->cu_mask & U32_ATTR_SELECTOR)) {
 262                 nl_dump(p, "no-selector\n");
 263                 return;
 264         }
 265
 266         s = u->cu_selector->d_data;
 267
 268         nl_dump(p, "nkeys %u ", s->nkeys);
 269
 270         if (u->cu_mask & U32_ATTR_HASH)
 271                 nl_dump(p, "ht key 0x%x hash 0x%u",
 272                         TC_U32_USERHTID(u->cu_hash), TC_U32_HASH(u->cu_hash));
 273
 274         if (u->cu_mask & U32_ATTR_LINK)
 275                 nl_dump(p, "link %u ", u->cu_link);
 276
 277         if (u->cu_mask & U32_ATTR_INDEV)
 278                 nl_dump(p, "indev %s ", u->cu_indev);
 279
 280         print_selector(p, s, cls, u);
 281         nl_dump(p, "\n");
 282
 283 #if 0
 284 #define U32_ATTR_ACTION       0x040
 285 #define U32_ATTR_POLICE       0x080
 286
 287         struct nl_data   act;
 288         struct nl_data   police;
 289 #endif
 290 }
 291
 292 static void u32_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p)
 293 {
 294         struct rtnl_u32 *u = rtnl_cls_data(cls);
 295
 296         if (u->cu_mask & U32_ATTR_PCNT) {
 297                 struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
 298                 nl_dump(p, "\n");
 299                 nl_dump_line(p, "    hit %8llu count %8llu\n",
 300                              pc->rhit, pc->rcnt);
 301         }
 302 }
 303
 304 static int u32_get_opts(struct rtnl_cls *cls, struct nl_msg *msg)
 305 {
 306         struct rtnl_u32 *u = rtnl_cls_data(cls);
 307
 308         if (u->cu_mask & U32_ATTR_DIVISOR)
 309                 NLA_PUT_U32(msg, TCA_U32_DIVISOR, u->cu_divisor);
 310
 311         if (u->cu_mask & U32_ATTR_HASH)
 312                 NLA_PUT_U32(msg, TCA_U32_HASH, u->cu_hash);
 313
 314         if (u->cu_mask & U32_ATTR_CLASSID)
 315                 NLA_PUT_U32(msg, TCA_U32_CLASSID, u->cu_classid);
 316
 317         if (u->cu_mask & U32_ATTR_LINK)
 318                 NLA_PUT_U32(msg, TCA_U32_LINK, u->cu_link);
 319
 320         if (u->cu_mask & U32_ATTR_SELECTOR)
 321                 NLA_PUT_DATA(msg, TCA_U32_SEL, u->cu_selector);
 322
 323         if (u->cu_mask & U32_ATTR_ACTION)
 324                 NLA_PUT_DATA(msg, TCA_U32_ACT, u->cu_act);
 325
 326         if (u->cu_mask & U32_ATTR_POLICE)
 327                 NLA_PUT_DATA(msg, TCA_U32_POLICE, u->cu_police);
 328
 329         if (u->cu_mask & U32_ATTR_INDEV)
 330                 NLA_PUT_STRING(msg, TCA_U32_INDEV, u->cu_indev);
 331
 332         return 0;
 333
 334 nla_put_failure:
 335         return -NLE_NOMEM;
 336 }
 337
 338 /**
 339  * @name Attribute Modifications
 340  * @{
 341  */
 342
 343 void rtnl_u32_set_handle(struct rtnl_cls *cls, int htid, int hash,
 344                          int nodeid)
 345 {
 346         uint32_t handle = (htid << 20) | (hash << 12) | nodeid;
 347
 348         tca_set_handle((struct rtnl_tca *) cls, handle );
 349 }
 350
 351 int rtnl_u32_set_classid(struct rtnl_cls *cls, uint32_t classid)
 352 {
 353         struct rtnl_u32 *u = rtnl_cls_data(cls);
 354
 355         u->cu_classid = classid;
 356         u->cu_mask |= U32_ATTR_CLASSID;
 357
 358         return 0;
 359 }
 360
 361 /** @} */
 362
 363 /**
 364  * @name Selector Modifications
 365  * @{
 366  */
 367
 368 int rtnl_u32_set_flags(struct rtnl_cls *cls, int flags)
 369 {
 370         struct tc_u32_sel *sel;
 371         struct rtnl_u32 *u = rtnl_cls_data(cls);
 372
 373         sel = u32_selector_alloc(u);
 374         if (!sel)
 375                 return -NLE_NOMEM;
 376
 377         sel->flags |= flags;
 378         u->cu_mask |= U32_ATTR_SELECTOR;
 379
 380         return 0;
 381 }
 382
 383 /**
 384  * Append new 32-bit key to the selector
 385  *
 386  * @arg cls     classifier to be modifier
 387  * @arg val     value to be matched (network byte-order)
 388  * @arg mask    mask to be applied before matching (network byte-order)
 389  * @arg off     offset, in bytes, to start matching
 390  * @arg offmask offset mask
 391  *
 392  * General selectors define the pattern, mask and offset the pattern will be
 393  * matched to the packet contents. Using the general selectors you can match
 394  * virtually any single bit in the IP (or upper layer) header.
 395  *
 396 */
 397 int rtnl_u32_add_key(struct rtnl_cls *cls, uint32_t val, uint32_t mask,
 398                      int off, int offmask)
 399 {
 400         struct tc_u32_sel *sel;
 401         struct rtnl_u32 *u = rtnl_cls_data(cls);
 402         int err;
 403
 404         sel = u32_selector_alloc(u);
 405         if (!sel)
 406                 return -NLE_NOMEM;
 407
 408         err = nl_data_append(u->cu_selector, NULL, sizeof(struct tc_u32_key));
 409         if (err < 0)
 410                 return err;
 411
 412         /* the selector might have been moved by realloc */
 413         sel = u32_selector(u);
 414
 415         sel->keys[sel->nkeys].mask = mask;
 416         sel->keys[sel->nkeys].val = val & mask;
 417         sel->keys[sel->nkeys].off = off;
 418         sel->keys[sel->nkeys].offmask = offmask;
 419         sel->nkeys++;
 420         u->cu_mask |= U32_ATTR_SELECTOR;
 421
 422         return 0;
 423 }
 424
 425 int rtnl_u32_add_key_uint8(struct rtnl_cls *cls, uint8_t val, uint8_t mask,
 426                            int off, int offmask)
 427 {
 428         int shift = 24 - 8 * (off & 3);
 429
 430         return rtnl_u32_add_key(cls, htonl((uint32_t)val << shift),
 431                                 htonl((uint32_t)mask << shift),
 432                                 off & ~3, offmask);
 433 }
 434
 435 /**
 436  * Append new selector key to match a 16-bit number
 437  *
 438  * @arg cls     classifier to be modified
 439  * @arg val     value to be matched (host byte-order)
 440  * @arg mask    mask to be applied before matching (host byte-order)
 441  * @arg off     offset, in bytes, to start matching
 442  * @arg offmask offset mask
 443 */
 444 int rtnl_u32_add_key_uint16(struct rtnl_cls *cls, uint16_t val, uint16_t mask,
 445                             int off, int offmask)
 446 {
 447         int shift = ((off & 3) == 0 ? 16 : 0);
 448         if (off % 2)
 449                 return -NLE_INVAL;
 450
 451         return rtnl_u32_add_key(cls, htonl((uint32_t)val << shift),
 452                                 htonl((uint32_t)mask << shift),
 453                                 off & ~3, offmask);
 454 }
 455
 456 /**
 457  * Append new selector key to match a 32-bit number
 458  *
 459  * @arg cls     classifier to be modified
 460  * @arg val     value to be matched (host byte-order)
 461  * @arg mask    mask to be applied before matching (host byte-order)
 462  * @arg off     offset, in bytes, to start matching
 463  * @arg offmask offset mask
 464 */
 465 int rtnl_u32_add_key_uint32(struct rtnl_cls *cls, uint32_t val, uint32_t mask,
 466                             int off, int offmask)
 467 {
 468         return rtnl_u32_add_key(cls, htonl(val), htonl(mask),
 469                                 off & ~3, offmask);
 470 }
 471
 472 int rtnl_u32_add_key_in_addr(struct rtnl_cls *cls, struct in_addr *addr,
 473                              uint8_t bitmask, int off, int offmask)
 474 {
 475         uint32_t mask = 0xFFFFFFFF << (32 - bitmask);
 476         return rtnl_u32_add_key(cls, addr->s_addr, htonl(mask), off, offmask);
 477 }
 478
 479 int rtnl_u32_add_key_in6_addr(struct rtnl_cls *cls, struct in6_addr *addr,
 480                               uint8_t bitmask, int off, int offmask)
 481 {
 482         int i, err;
 483
 484         for (i = 1; i <= 4; i++) {
 485                 if (32 * i - bitmask <= 0) {
 486                         if ((err = rtnl_u32_add_key(cls, addr->s6_addr32[i-1],
 487                                                 0xFFFFFFFF, off+4*(i-1), offmask)) < 0)
 488                                 return err;
 489                 }
 490                 else if (32 * i - bitmask < 32) {
 491                         uint32_t mask = 0xFFFFFFFF << (32 * i - bitmask);
 492                         if ((err = rtnl_u32_add_key(cls, addr->s6_addr32[i-1],
 493                                                 htonl(mask), off+4*(i-1), offmask)) < 0)
 494                                 return err;
 495                 }
 496                 /* otherwise, if (32*i - bitmask >= 32) no key is generated */
 497         }
 498
 499         return 0;
 500 }
 501
 502 /** @} */
 503
 504 static struct rtnl_cls_ops u32_ops = {
 505         .co_kind                = "u32",
 506         .co_size                = sizeof(struct rtnl_u32),
 507         .co_msg_parser          = u32_msg_parser,
 508         .co_free_data           = u32_free_data,
 509         .co_clone               = u32_clone,
 510         .co_get_opts            = u32_get_opts,
 511         .co_dump = {
 512             [NL_DUMP_LINE]      = u32_dump_line,
 513             [NL_DUMP_DETAILS]   = u32_dump_details,
 514             [NL_DUMP_STATS]     = u32_dump_stats,
 515         },
 516 };
 517
 518 static void __init u32_init(void)
 519 {
 520         rtnl_cls_register(&u32_ops);
 521 }
 522
 523 static void __exit u32_exit(void)
 524 {
 525         rtnl_cls_unregister(&u32_ops);
 526 }
 527
 528 /** @} */