net/sched/cls_rsvp.h

   1 /*
   2  * net/sched/cls_rsvp.h Template file for RSVPv[46] classifiers.
   3  *
   4  *              This program is free software; you can redistribute 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  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  */
  11
  12 /*
  13    Comparing to general packet classification problem,
  14    RSVP needs only sevaral relatively simple rules:
  15
  16    * (dst, protocol) are always specified,
  17      so that we are able to hash them.
  18    * src may be exact, or may be wildcard, so that
  19      we can keep a hash table plus one wildcard entry.
  20    * source port (or flow label) is important only if src is given.
  21
  22    IMPLEMENTATION.
  23
  24    We use a two level hash table: The top level is keyed by
  25    destination address and protocol ID, every bucket contains a list
  26    of "rsvp sessions", identified by destination address, protocol and
  27    DPI(="Destination Port ID"): triple (key, mask, offset).
  28
  29    Every bucket has a smaller hash table keyed by source address
  30    (cf. RSVP flowspec) and one wildcard entry for wildcard reservations.
  31    Every bucket is again a list of "RSVP flows", selected by
  32    source address and SPI(="Source Port ID" here rather than
  33    "security parameter index"): triple (key, mask, offset).
  34
  35
  36    NOTE 1. All the packets with IPv6 extension headers (but AH and ESP)
  37    and all fragmented packets go to the best-effort traffic class.
  38
  39
  40    NOTE 2. Two "port id"'s seems to be redundant, rfc2207 requires
  41    only one "Generalized Port Identifier". So that for classic
  42    ah, esp (and udp,tcp) both *pi should coincide or one of them
  43    should be wildcard.
  44
  45    At first sight, this redundancy is just a waste of CPU
  46    resources. But DPI and SPI add the possibility to assign different
  47    priorities to GPIs. Look also at note 4 about tunnels below.
  48
  49
  50    NOTE 3. One complication is the case of tunneled packets.
  51    We implement it as following: if the first lookup
  52    matches a special session with "tunnelhdr" value not zero,
  53    flowid doesn't contain the true flow ID, but the tunnel ID (1...255).
  54    In this case, we pull tunnelhdr bytes and restart lookup
  55    with tunnel ID added to the list of keys. Simple and stupid 8)8)
  56    It's enough for PIMREG and IPIP.
  57
  58
  59    NOTE 4. Two GPIs make it possible to parse even GRE packets.
  60    F.e. DPI can select ETH_P_IP (and necessary flags to make
  61    tunnelhdr correct) in GRE protocol field and SPI matches
  62    GRE key. Is it not nice? 8)8)
  63
  64
  65    Well, as result, despite its simplicity, we get a pretty
  66    powerful classification engine.  */
  67
  68
  69 struct rsvp_head {
  70         u32                     tmap[256/32];
  71         u32                     hgenerator;
  72         u8                      tgenerator;
  73         struct rsvp_session __rcu *ht[256];
  74         struct rcu_head         rcu;
  75 };
  76
  77 struct rsvp_session {
  78         struct rsvp_session __rcu       *next;
  79         __be32                          dst[RSVP_DST_LEN];
  80         struct tc_rsvp_gpi              dpi;
  81         u8                              protocol;
  82         u8                              tunnelid;
  83         /* 16 (src,sport) hash slots, and one wildcard source slot */
  84         struct rsvp_filter __rcu        *ht[16 + 1];
  85         struct rcu_head                 rcu;
  86 };
  87
  88
  89 struct rsvp_filter {
  90         struct rsvp_filter __rcu        *next;
  91         __be32                          src[RSVP_DST_LEN];
  92         struct tc_rsvp_gpi              spi;
  93         u8                              tunnelhdr;
  94
  95         struct tcf_result               res;
  96         struct tcf_exts                 exts;
  97
  98         u32                             handle;
  99         struct rsvp_session             *sess;
 100         struct rcu_head                 rcu;
 101 };
 102
 103 static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)
 104 {
 105         unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1];
 106
 107         h ^= h>>16;
 108         h ^= h>>8;
 109         return (h ^ protocol ^ tunnelid) & 0xFF;
 110 }
 111
 112 static inline unsigned int hash_src(__be32 *src)
 113 {
 114         unsigned int h = (__force __u32)src[RSVP_DST_LEN-1];
 115
 116         h ^= h>>16;
 117         h ^= h>>8;
 118         h ^= h>>4;
 119         return h & 0xF;
 120 }
 121
 122 #define RSVP_APPLY_RESULT()                             \
 123 {                                                       \
 124         int r = tcf_exts_exec(skb, &f->exts, res);      \
 125         if (r < 0)                                      \
 126                 continue;                               \
 127         else if (r > 0)                                 \
 128                 return r;                               \
 129 }
 130
 131 static int rsvp_classify(struct sk_buff *skb, const struct tcf_proto *tp,
 132                          struct tcf_result *res)
 133 {
 134         struct rsvp_head *head = rcu_dereference_bh(tp->root);
 135         struct rsvp_session *s;
 136         struct rsvp_filter *f;
 137         unsigned int h1, h2;
 138         __be32 *dst, *src;
 139         u8 protocol;
 140         u8 tunnelid = 0;
 141         u8 *xprt;
 142 #if RSVP_DST_LEN == 4
 143         struct ipv6hdr *nhptr;
 144
 145         if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
 146                 return -1;
 147         nhptr = ipv6_hdr(skb);
 148 #else
 149         struct iphdr *nhptr;
 150
 151         if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
 152                 return -1;
 153         nhptr = ip_hdr(skb);
 154 #endif
 155         if (unlikely(!head))
 156                 return -1;
 157 restart:
 158
 159 #if RSVP_DST_LEN == 4
 160         src = &nhptr->saddr.s6_addr32[0];
 161         dst = &nhptr->daddr.s6_addr32[0];
 162         protocol = nhptr->nexthdr;
 163         xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);
 164 #else
 165         src = &nhptr->saddr;
 166         dst = &nhptr->daddr;
 167         protocol = nhptr->protocol;
 168         xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);
 169         if (ip_is_fragment(nhptr))
 170                 return -1;
 171 #endif
 172
 173         h1 = hash_dst(dst, protocol, tunnelid);
 174         h2 = hash_src(src);
 175
 176         for (s = rcu_dereference_bh(head->ht[h1]); s;
 177              s = rcu_dereference_bh(s->next)) {
 178                 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] &&
 179                     protocol == s->protocol &&
 180                     !(s->dpi.mask &
 181                       (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) &&
 182 #if RSVP_DST_LEN == 4
 183                     dst[0] == s->dst[0] &&
 184                     dst[1] == s->dst[1] &&
 185                     dst[2] == s->dst[2] &&
 186 #endif
 187                     tunnelid == s->tunnelid) {
 188
 189                         for (f = rcu_dereference_bh(s->ht[h2]); f;
 190                              f = rcu_dereference_bh(f->next)) {
 191                                 if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN - 1] &&
 192                                     !(f->spi.mask & (*(u32 *)(xprt + f->spi.offset) ^ f->spi.key))
 193 #if RSVP_DST_LEN == 4
 194                                     &&
 195                                     src[0] == f->src[0] &&
 196                                     src[1] == f->src[1] &&
 197                                     src[2] == f->src[2]
 198 #endif
 199                                     ) {
 200                                         *res = f->res;
 201                                         RSVP_APPLY_RESULT();
 202
 203 matched:
 204                                         if (f->tunnelhdr == 0)
 205                                                 return 0;
 206
 207                                         tunnelid = f->res.classid;
 208                                         nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr));
 209                                         goto restart;
 210                                 }
 211                         }
 212
 213                         /* And wildcard bucket... */
 214                         for (f = rcu_dereference_bh(s->ht[16]); f;
 215                              f = rcu_dereference_bh(f->next)) {
 216                                 *res = f->res;
 217                                 RSVP_APPLY_RESULT();
 218                                 goto matched;
 219                         }
 220                         return -1;
 221                 }
 222         }
 223         return -1;
 224 }
 225
 226 static void rsvp_replace(struct tcf_proto *tp, struct rsvp_filter *n, u32 h)
 227 {
 228         struct rsvp_head *head = rtnl_dereference(tp->root);
 229         struct rsvp_session *s;
 230         struct rsvp_filter __rcu **ins;
 231         struct rsvp_filter *pins;
 232         unsigned int h1 = h & 0xFF;
 233         unsigned int h2 = (h >> 8) & 0xFF;
 234
 235         for (s = rtnl_dereference(head->ht[h1]); s;
 236              s = rtnl_dereference(s->next)) {
 237                 for (ins = &s->ht[h2], pins = rtnl_dereference(*ins); ;
 238                      ins = &pins->next, pins = rtnl_dereference(*ins)) {
 239                         if (pins->handle == h) {
 240                                 RCU_INIT_POINTER(n->next, pins->next);
 241                                 rcu_assign_pointer(*ins, n);
 242                                 return;
 243                         }
 244                 }
 245         }
 246
 247         /* Something went wrong if we are trying to replace a non-existant
 248          * node. Mind as well halt instead of silently failing.
 249          */
 250         BUG_ON(1);
 251 }
 252
 253 static unsigned long rsvp_get(struct tcf_proto *tp, u32 handle)
 254 {
 255         struct rsvp_head *head = rtnl_dereference(tp->root);
 256         struct rsvp_session *s;
 257         struct rsvp_filter *f;
 258         unsigned int h1 = handle & 0xFF;
 259         unsigned int h2 = (handle >> 8) & 0xFF;
 260
 261         if (h2 > 16)
 262                 return 0;
 263
 264         for (s = rtnl_dereference(head->ht[h1]); s;
 265              s = rtnl_dereference(s->next)) {
 266                 for (f = rtnl_dereference(s->ht[h2]); f;
 267                      f = rtnl_dereference(f->next)) {
 268                         if (f->handle == handle)
 269                                 return (unsigned long)f;
 270                 }
 271         }
 272         return 0;
 273 }
 274
 275 static int rsvp_init(struct tcf_proto *tp)
 276 {
 277         struct rsvp_head *data;
 278
 279         data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
 280         if (data) {
 281                 rcu_assign_pointer(tp->root, data);
 282                 return 0;
 283         }
 284         return -ENOBUFS;
 285 }
 286
 287 static void rsvp_delete_filter_rcu(struct rcu_head *head)
 288 {
 289         struct rsvp_filter *f = container_of(head, struct rsvp_filter, rcu);
 290
 291         tcf_exts_destroy(&f->exts);
 292         kfree(f);
 293 }
 294
 295 static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
 296 {
 297         tcf_unbind_filter(tp, &f->res);
 298         /* all classifiers are required to call tcf_exts_destroy() after rcu
 299          * grace period, since converted-to-rcu actions are relying on that
 300          * in cleanup() callback
 301          */
 302         call_rcu(&f->rcu, rsvp_delete_filter_rcu);
 303 }
 304
 305 static void rsvp_destroy(struct tcf_proto *tp)
 306 {
 307         struct rsvp_head *data = rtnl_dereference(tp->root);
 308         int h1, h2;
 309
 310         if (data == NULL)
 311                 return;
 312
 313         RCU_INIT_POINTER(tp->root, NULL);
 314
 315         for (h1 = 0; h1 < 256; h1++) {
 316                 struct rsvp_session *s;
 317
 318                 while ((s = rtnl_dereference(data->ht[h1])) != NULL) {
 319                         RCU_INIT_POINTER(data->ht[h1], s->next);
 320
 321                         for (h2 = 0; h2 <= 16; h2++) {
 322                                 struct rsvp_filter *f;
 323
 324                                 while ((f = rtnl_dereference(s->ht[h2])) != NULL) {
 325                                         rcu_assign_pointer(s->ht[h2], f->next);
 326                                         rsvp_delete_filter(tp, f);
 327                                 }
 328                         }
 329                         kfree_rcu(s, rcu);
 330                 }
 331         }
 332         kfree_rcu(data, rcu);
 333 }
 334
 335 static int rsvp_delete(struct tcf_proto *tp, unsigned long arg, bool *last)
 336 {
 337         struct rsvp_head *head = rtnl_dereference(tp->root);
 338         struct rsvp_filter *nfp, *f = (struct rsvp_filter *)arg;
 339         struct rsvp_filter __rcu **fp;
 340         unsigned int h = f->handle;
 341         struct rsvp_session __rcu **sp;
 342         struct rsvp_session *nsp, *s = f->sess;
 343         int i, h1;
 344
 345         fp = &s->ht[(h >> 8) & 0xFF];
 346         for (nfp = rtnl_dereference(*fp); nfp;
 347              fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
 348                 if (nfp == f) {
 349                         RCU_INIT_POINTER(*fp, f->next);
 350                         rsvp_delete_filter(tp, f);
 351
 352                         /* Strip tree */
 353
 354                         for (i = 0; i <= 16; i++)
 355                                 if (s->ht[i])
 356                                         goto out;
 357
 358                         /* OK, session has no flows */
 359                         sp = &head->ht[h & 0xFF];
 360                         for (nsp = rtnl_dereference(*sp); nsp;
 361                              sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
 362                                 if (nsp == s) {
 363                                         RCU_INIT_POINTER(*sp, s->next);
 364                                         kfree_rcu(s, rcu);
 365                                         goto out;
 366                                 }
 367                         }
 368
 369                         break;
 370                 }
 371         }
 372
 373 out:
 374         *last = true;
 375         for (h1 = 0; h1 < 256; h1++) {
 376                 if (rcu_access_pointer(head->ht[h1])) {
 377                         *last = false;
 378                         break;
 379                 }
 380         }
 381
 382         return 0;
 383 }
 384
 385 static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)
 386 {
 387         struct rsvp_head *data = rtnl_dereference(tp->root);
 388         int i = 0xFFFF;
 389
 390         while (i-- > 0) {
 391                 u32 h;
 392
 393                 if ((data->hgenerator += 0x10000) == 0)
 394                         data->hgenerator = 0x10000;
 395                 h = data->hgenerator|salt;
 396                 if (rsvp_get(tp, h) == 0)
 397                         return h;
 398         }
 399         return 0;
 400 }
 401
 402 static int tunnel_bts(struct rsvp_head *data)
 403 {
 404         int n = data->tgenerator >> 5;
 405         u32 b = 1 << (data->tgenerator & 0x1F);
 406
 407         if (data->tmap[n] & b)
 408                 return 0;
 409         data->tmap[n] |= b;
 410         return 1;
 411 }
 412
 413 static void tunnel_recycle(struct rsvp_head *data)
 414 {
 415         struct rsvp_session __rcu **sht = data->ht;
 416         u32 tmap[256/32];
 417         int h1, h2;
 418
 419         memset(tmap, 0, sizeof(tmap));
 420
 421         for (h1 = 0; h1 < 256; h1++) {
 422                 struct rsvp_session *s;
 423                 for (s = rtnl_dereference(sht[h1]); s;
 424                      s = rtnl_dereference(s->next)) {
 425                         for (h2 = 0; h2 <= 16; h2++) {
 426                                 struct rsvp_filter *f;
 427
 428                                 for (f = rtnl_dereference(s->ht[h2]); f;
 429                                      f = rtnl_dereference(f->next)) {
 430                                         if (f->tunnelhdr == 0)
 431                                                 continue;
 432                                         data->tgenerator = f->res.classid;
 433                                         tunnel_bts(data);
 434                                 }
 435                         }
 436                 }
 437         }
 438
 439         memcpy(data->tmap, tmap, sizeof(tmap));
 440 }
 441
 442 static u32 gen_tunnel(struct rsvp_head *data)
 443 {
 444         int i, k;
 445
 446         for (k = 0; k < 2; k++) {
 447                 for (i = 255; i > 0; i--) {
 448                         if (++data->tgenerator == 0)
 449                                 data->tgenerator = 1;
 450                         if (tunnel_bts(data))
 451                                 return data->tgenerator;
 452                 }
 453                 tunnel_recycle(data);
 454         }
 455         return 0;
 456 }
 457
 458 static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {
 459         [TCA_RSVP_CLASSID]      = { .type = NLA_U32 },
 460         [TCA_RSVP_DST]          = { .type = NLA_BINARY,
 461                                     .len = RSVP_DST_LEN * sizeof(u32) },
 462         [TCA_RSVP_SRC]          = { .type = NLA_BINARY,
 463                                     .len = RSVP_DST_LEN * sizeof(u32) },
 464         [TCA_RSVP_PINFO]        = { .len = sizeof(struct tc_rsvp_pinfo) },
 465 };
 466
 467 static int rsvp_change(struct net *net, struct sk_buff *in_skb,
 468                        struct tcf_proto *tp, unsigned long base,
 469                        u32 handle,
 470                        struct nlattr **tca,
 471                        unsigned long *arg, bool ovr)
 472 {
 473         struct rsvp_head *data = rtnl_dereference(tp->root);
 474         struct rsvp_filter *f, *nfp;
 475         struct rsvp_filter __rcu **fp;
 476         struct rsvp_session *nsp, *s;
 477         struct rsvp_session __rcu **sp;
 478         struct tc_rsvp_pinfo *pinfo = NULL;
 479         struct nlattr *opt = tca[TCA_OPTIONS];
 480         struct nlattr *tb[TCA_RSVP_MAX + 1];
 481         struct tcf_exts e;
 482         unsigned int h1, h2;
 483         __be32 *dst;
 484         int err;
 485
 486         if (opt == NULL)
 487                 return handle ? -EINVAL : 0;
 488
 489         err = nla_parse_nested(tb, TCA_RSVP_MAX, opt, rsvp_policy, NULL);
 490         if (err < 0)
 491                 return err;
 492
 493         err = tcf_exts_init(&e, TCA_RSVP_ACT, TCA_RSVP_POLICE);
 494         if (err < 0)
 495                 return err;
 496         err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr);
 497         if (err < 0)
 498                 goto errout2;
 499
 500         f = (struct rsvp_filter *)*arg;
 501         if (f) {
 502                 /* Node exists: adjust only classid */
 503                 struct rsvp_filter *n;
 504
 505                 if (f->handle != handle && handle)
 506                         goto errout2;
 507
 508                 n = kmemdup(f, sizeof(*f), GFP_KERNEL);
 509                 if (!n) {
 510                         err = -ENOMEM;
 511                         goto errout2;
 512                 }
 513
 514                 err = tcf_exts_init(&n->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
 515                 if (err < 0) {
 516                         kfree(n);
 517                         goto errout2;
 518                 }
 519
 520                 if (tb[TCA_RSVP_CLASSID]) {
 521                         n->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
 522                         tcf_bind_filter(tp, &n->res, base);
 523                 }
 524
 525                 tcf_exts_change(tp, &n->exts, &e);
 526                 rsvp_replace(tp, n, handle);
 527                 return 0;
 528         }
 529
 530         /* Now more serious part... */
 531         err = -EINVAL;
 532         if (handle)
 533                 goto errout2;
 534         if (tb[TCA_RSVP_DST] == NULL)
 535                 goto errout2;
 536
 537         err = -ENOBUFS;
 538         f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
 539         if (f == NULL)
 540                 goto errout2;
 541
 542         err = tcf_exts_init(&f->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
 543         if (err < 0)
 544                 goto errout;
 545         h2 = 16;
 546         if (tb[TCA_RSVP_SRC]) {
 547                 memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src));
 548                 h2 = hash_src(f->src);
 549         }
 550         if (tb[TCA_RSVP_PINFO]) {
 551                 pinfo = nla_data(tb[TCA_RSVP_PINFO]);
 552                 f->spi = pinfo->spi;
 553                 f->tunnelhdr = pinfo->tunnelhdr;
 554         }
 555         if (tb[TCA_RSVP_CLASSID])
 556                 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
 557
 558         dst = nla_data(tb[TCA_RSVP_DST]);
 559         h1 = hash_dst(dst, pinfo ? pinfo->protocol : 0, pinfo ? pinfo->tunnelid : 0);
 560
 561         err = -ENOMEM;
 562         if ((f->handle = gen_handle(tp, h1 | (h2<<8))) == 0)
 563                 goto errout;
 564
 565         if (f->tunnelhdr) {
 566                 err = -EINVAL;
 567                 if (f->res.classid > 255)
 568                         goto errout;
 569
 570                 err = -ENOMEM;
 571                 if (f->res.classid == 0 &&
 572                     (f->res.classid = gen_tunnel(data)) == 0)
 573                         goto errout;
 574         }
 575
 576         for (sp = &data->ht[h1];
 577              (s = rtnl_dereference(*sp)) != NULL;
 578              sp = &s->next) {
 579                 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
 580                     pinfo && pinfo->protocol == s->protocol &&
 581                     memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
 582 #if RSVP_DST_LEN == 4
 583                     dst[0] == s->dst[0] &&
 584                     dst[1] == s->dst[1] &&
 585                     dst[2] == s->dst[2] &&
 586 #endif
 587                     pinfo->tunnelid == s->tunnelid) {
 588
 589 insert:
 590                         /* OK, we found appropriate session */
 591
 592                         fp = &s->ht[h2];
 593
 594                         f->sess = s;
 595                         if (f->tunnelhdr == 0)
 596                                 tcf_bind_filter(tp, &f->res, base);
 597
 598                         tcf_exts_change(tp, &f->exts, &e);
 599
 600                         fp = &s->ht[h2];
 601                         for (nfp = rtnl_dereference(*fp); nfp;
 602                              fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
 603                                 __u32 mask = nfp->spi.mask & f->spi.mask;
 604
 605                                 if (mask != f->spi.mask)
 606                                         break;
 607                         }
 608                         RCU_INIT_POINTER(f->next, nfp);
 609                         rcu_assign_pointer(*fp, f);
 610
 611                         *arg = (unsigned long)f;
 612                         return 0;
 613                 }
 614         }
 615
 616         /* No session found. Create new one. */
 617
 618         err = -ENOBUFS;
 619         s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
 620         if (s == NULL)
 621                 goto errout;
 622         memcpy(s->dst, dst, sizeof(s->dst));
 623
 624         if (pinfo) {
 625                 s->dpi = pinfo->dpi;
 626                 s->protocol = pinfo->protocol;
 627                 s->tunnelid = pinfo->tunnelid;
 628         }
 629         sp = &data->ht[h1];
 630         for (nsp = rtnl_dereference(*sp); nsp;
 631              sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
 632                 if ((nsp->dpi.mask & s->dpi.mask) != s->dpi.mask)
 633                         break;
 634         }
 635         RCU_INIT_POINTER(s->next, nsp);
 636         rcu_assign_pointer(*sp, s);
 637
 638         goto insert;
 639
 640 errout:
 641         tcf_exts_destroy(&f->exts);
 642         kfree(f);
 643 errout2:
 644         tcf_exts_destroy(&e);
 645         return err;
 646 }
 647
 648 static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg)
 649 {
 650         struct rsvp_head *head = rtnl_dereference(tp->root);
 651         unsigned int h, h1;
 652
 653         if (arg->stop)
 654                 return;
 655
 656         for (h = 0; h < 256; h++) {
 657                 struct rsvp_session *s;
 658
 659                 for (s = rtnl_dereference(head->ht[h]); s;
 660                      s = rtnl_dereference(s->next)) {
 661                         for (h1 = 0; h1 <= 16; h1++) {
 662                                 struct rsvp_filter *f;
 663
 664                                 for (f = rtnl_dereference(s->ht[h1]); f;
 665                                      f = rtnl_dereference(f->next)) {
 666                                         if (arg->count < arg->skip) {
 667                                                 arg->count++;
 668                                                 continue;
 669                                         }
 670                                         if (arg->fn(tp, (unsigned long)f, arg) < 0) {
 671                                                 arg->stop = 1;
 672                                                 return;
 673                                         }
 674                                         arg->count++;
 675                                 }
 676                         }
 677                 }
 678         }
 679 }
 680
 681 static int rsvp_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
 682                      struct sk_buff *skb, struct tcmsg *t)
 683 {
 684         struct rsvp_filter *f = (struct rsvp_filter *)fh;
 685         struct rsvp_session *s;
 686         struct nlattr *nest;
 687         struct tc_rsvp_pinfo pinfo;
 688
 689         if (f == NULL)
 690                 return skb->len;
 691         s = f->sess;
 692
 693         t->tcm_handle = f->handle;
 694
 695         nest = nla_nest_start(skb, TCA_OPTIONS);
 696         if (nest == NULL)
 697                 goto nla_put_failure;
 698
 699         if (nla_put(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst))
 700                 goto nla_put_failure;
 701         pinfo.dpi = s->dpi;
 702         pinfo.spi = f->spi;
 703         pinfo.protocol = s->protocol;
 704         pinfo.tunnelid = s->tunnelid;
 705         pinfo.tunnelhdr = f->tunnelhdr;
 706         pinfo.pad = 0;
 707         if (nla_put(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo))
 708                 goto nla_put_failure;
 709         if (f->res.classid &&
 710             nla_put_u32(skb, TCA_RSVP_CLASSID, f->res.classid))
 711                 goto nla_put_failure;
 712         if (((f->handle >> 8) & 0xFF) != 16 &&
 713             nla_put(skb, TCA_RSVP_SRC, sizeof(f->src), f->src))
 714                 goto nla_put_failure;
 715
 716         if (tcf_exts_dump(skb, &f->exts) < 0)
 717                 goto nla_put_failure;
 718
 719         nla_nest_end(skb, nest);
 720
 721         if (tcf_exts_dump_stats(skb, &f->exts) < 0)
 722                 goto nla_put_failure;
 723         return skb->len;
 724
 725 nla_put_failure:
 726         nla_nest_cancel(skb, nest);
 727         return -1;
 728 }
 729
 730 static struct tcf_proto_ops RSVP_OPS __read_mostly = {
 731         .kind           =       RSVP_ID,
 732         .classify       =       rsvp_classify,
 733         .init           =       rsvp_init,
 734         .destroy        =       rsvp_destroy,
 735         .get            =       rsvp_get,
 736         .change         =       rsvp_change,
 737         .delete         =       rsvp_delete,
 738         .walk           =       rsvp_walk,
 739         .dump           =       rsvp_dump,
 740         .owner          =       THIS_MODULE,
 741 };
 742
 743 static int __init init_rsvp(void)
 744 {
 745         return register_tcf_proto_ops(&RSVP_OPS);
 746 }
 747
 748 static void __exit exit_rsvp(void)
 749 {
 750         unregister_tcf_proto_ops(&RSVP_OPS);
 751 }
 752
 753 module_init(init_rsvp)
 754 module_exit(exit_rsvp)