drivers/net/team/team_mode_loadbalance.c

   1 /*
   2  * drivers/net/team/team_mode_loadbalance.c - Load-balancing mode for team
   3  * Copyright (c) 2012 Jiri Pirko <jpirko@redhat.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/types.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/errno.h>
  16 #include <linux/netdevice.h>
  17 #include <linux/filter.h>
  18 #include <linux/if_team.h>
  19
  20 struct lb_priv;
  21
  22 typedef struct team_port *lb_select_tx_port_func_t(struct team *,
  23                                                    struct lb_priv *,
  24                                                    struct sk_buff *,
  25                                                    unsigned char);
  26
  27 #define LB_TX_HASHTABLE_SIZE 256 /* hash is a char */
  28
  29 struct lb_stats {
  30         u64 tx_bytes;
  31 };
  32
  33 struct lb_pcpu_stats {
  34         struct lb_stats hash_stats[LB_TX_HASHTABLE_SIZE];
  35         struct u64_stats_sync syncp;
  36 };
  37
  38 struct lb_stats_info {
  39         struct lb_stats stats;
  40         struct lb_stats last_stats;
  41         struct team_option_inst_info *opt_inst_info;
  42 };
  43
  44 struct lb_port_mapping {
  45         struct team_port __rcu *port;
  46         struct team_option_inst_info *opt_inst_info;
  47 };
  48
  49 struct lb_priv_ex {
  50         struct team *team;
  51         struct lb_port_mapping tx_hash_to_port_mapping[LB_TX_HASHTABLE_SIZE];
  52         struct sock_fprog *orig_fprog;
  53         struct {
  54                 unsigned int refresh_interval; /* in tenths of second */
  55                 struct delayed_work refresh_dw;
  56                 struct lb_stats_info info[LB_TX_HASHTABLE_SIZE];
  57         } stats;
  58 };
  59
  60 struct lb_priv {
  61         struct sk_filter __rcu *fp;
  62         lb_select_tx_port_func_t __rcu *select_tx_port_func;
  63         struct lb_pcpu_stats __percpu *pcpu_stats;
  64         struct lb_priv_ex *ex; /* priv extension */
  65 };
  66
  67 static struct lb_priv *get_lb_priv(struct team *team)
  68 {
  69         return (struct lb_priv *) &team->mode_priv;
  70 }
  71
  72 struct lb_port_priv {
  73         struct lb_stats __percpu *pcpu_stats;
  74         struct lb_stats_info stats_info;
  75 };
  76
  77 static struct lb_port_priv *get_lb_port_priv(struct team_port *port)
  78 {
  79         return (struct lb_port_priv *) &port->mode_priv;
  80 }
  81
  82 #define LB_HTPM_PORT_BY_HASH(lp_priv, hash) \
  83         (lb_priv)->ex->tx_hash_to_port_mapping[hash].port
  84
  85 #define LB_HTPM_OPT_INST_INFO_BY_HASH(lp_priv, hash) \
  86         (lb_priv)->ex->tx_hash_to_port_mapping[hash].opt_inst_info
  87
  88 static void lb_tx_hash_to_port_mapping_null_port(struct team *team,
  89                                                  struct team_port *port)
  90 {
  91         struct lb_priv *lb_priv = get_lb_priv(team);
  92         bool changed = false;
  93         int i;
  94
  95         for (i = 0; i < LB_TX_HASHTABLE_SIZE; i++) {
  96                 struct lb_port_mapping *pm;
  97
  98                 pm = &lb_priv->ex->tx_hash_to_port_mapping[i];
  99                 if (rcu_access_pointer(pm->port) == port) {
 100                         RCU_INIT_POINTER(pm->port, NULL);
 101                         team_option_inst_set_change(pm->opt_inst_info);
 102                         changed = true;
 103                 }
 104         }
 105         if (changed)
 106                 team_options_change_check(team);
 107 }
 108
 109 /* Basic tx selection based solely by hash */
 110 static struct team_port *lb_hash_select_tx_port(struct team *team,
 111                                                 struct lb_priv *lb_priv,
 112                                                 struct sk_buff *skb,
 113                                                 unsigned char hash)
 114 {
 115         int port_index;
 116
 117         port_index = hash % team->en_port_count;
 118         return team_get_port_by_index_rcu(team, port_index);
 119 }
 120
 121 /* Hash to port mapping select tx port */
 122 static struct team_port *lb_htpm_select_tx_port(struct team *team,
 123                                                 struct lb_priv *lb_priv,
 124                                                 struct sk_buff *skb,
 125                                                 unsigned char hash)
 126 {
 127         return rcu_dereference_bh(LB_HTPM_PORT_BY_HASH(lb_priv, hash));
 128 }
 129
 130 struct lb_select_tx_port {
 131         char *name;
 132         lb_select_tx_port_func_t *func;
 133 };
 134
 135 static const struct lb_select_tx_port lb_select_tx_port_list[] = {
 136         {
 137                 .name = "hash",
 138                 .func = lb_hash_select_tx_port,
 139         },
 140         {
 141                 .name = "hash_to_port_mapping",
 142                 .func = lb_htpm_select_tx_port,
 143         },
 144 };
 145 #define LB_SELECT_TX_PORT_LIST_COUNT ARRAY_SIZE(lb_select_tx_port_list)
 146
 147 static char *lb_select_tx_port_get_name(lb_select_tx_port_func_t *func)
 148 {
 149         int i;
 150
 151         for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
 152                 const struct lb_select_tx_port *item;
 153
 154                 item = &lb_select_tx_port_list[i];
 155                 if (item->func == func)
 156                         return item->name;
 157         }
 158         return NULL;
 159 }
 160
 161 static lb_select_tx_port_func_t *lb_select_tx_port_get_func(const char *name)
 162 {
 163         int i;
 164
 165         for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
 166                 const struct lb_select_tx_port *item;
 167
 168                 item = &lb_select_tx_port_list[i];
 169                 if (!strcmp(item->name, name))
 170                         return item->func;
 171         }
 172         return NULL;
 173 }
 174
 175 static unsigned int lb_get_skb_hash(struct lb_priv *lb_priv,
 176                                     struct sk_buff *skb)
 177 {
 178         struct sk_filter *fp;
 179         uint32_t lhash;
 180         unsigned char *c;
 181
 182         fp = rcu_dereference_bh(lb_priv->fp);
 183         if (unlikely(!fp))
 184                 return 0;
 185         lhash = SK_RUN_FILTER(fp, skb);
 186         c = (char *) &lhash;
 187         return c[0] ^ c[1] ^ c[2] ^ c[3];
 188 }
 189
 190 static void lb_update_tx_stats(unsigned int tx_bytes, struct lb_priv *lb_priv,
 191                                struct lb_port_priv *lb_port_priv,
 192                                unsigned char hash)
 193 {
 194         struct lb_pcpu_stats *pcpu_stats;
 195         struct lb_stats *port_stats;
 196         struct lb_stats *hash_stats;
 197
 198         pcpu_stats = this_cpu_ptr(lb_priv->pcpu_stats);
 199         port_stats = this_cpu_ptr(lb_port_priv->pcpu_stats);
 200         hash_stats = &pcpu_stats->hash_stats[hash];
 201         u64_stats_update_begin(&pcpu_stats->syncp);
 202         port_stats->tx_bytes += tx_bytes;
 203         hash_stats->tx_bytes += tx_bytes;
 204         u64_stats_update_end(&pcpu_stats->syncp);
 205 }
 206
 207 static bool lb_transmit(struct team *team, struct sk_buff *skb)
 208 {
 209         struct lb_priv *lb_priv = get_lb_priv(team);
 210         lb_select_tx_port_func_t *select_tx_port_func;
 211         struct team_port *port;
 212         unsigned char hash;
 213         unsigned int tx_bytes = skb->len;
 214
 215         hash = lb_get_skb_hash(lb_priv, skb);
 216         select_tx_port_func = rcu_dereference_bh(lb_priv->select_tx_port_func);
 217         port = select_tx_port_func(team, lb_priv, skb, hash);
 218         if (unlikely(!port))
 219                 goto drop;
 220         skb->dev = port->dev;
 221         if (dev_queue_xmit(skb))
 222                 return false;
 223         lb_update_tx_stats(tx_bytes, lb_priv, get_lb_port_priv(port), hash);
 224         return true;
 225
 226 drop:
 227         dev_kfree_skb_any(skb);
 228         return false;
 229 }
 230
 231 static int lb_bpf_func_get(struct team *team, struct team_gsetter_ctx *ctx)
 232 {
 233         struct lb_priv *lb_priv = get_lb_priv(team);
 234
 235         if (!lb_priv->ex->orig_fprog) {
 236                 ctx->data.bin_val.len = 0;
 237                 ctx->data.bin_val.ptr = NULL;
 238                 return 0;
 239         }
 240         ctx->data.bin_val.len = lb_priv->ex->orig_fprog->len *
 241                                 sizeof(struct sock_filter);
 242         ctx->data.bin_val.ptr = lb_priv->ex->orig_fprog->filter;
 243         return 0;
 244 }
 245
 246 static int __fprog_create(struct sock_fprog **pfprog, u32 data_len,
 247                           const void *data)
 248 {
 249         struct sock_fprog *fprog;
 250         struct sock_filter *filter = (struct sock_filter *) data;
 251
 252         if (data_len % sizeof(struct sock_filter))
 253                 return -EINVAL;
 254         fprog = kmalloc(sizeof(struct sock_fprog), GFP_KERNEL);
 255         if (!fprog)
 256                 return -ENOMEM;
 257         fprog->filter = kmemdup(filter, data_len, GFP_KERNEL);
 258         if (!fprog->filter) {
 259                 kfree(fprog);
 260                 return -ENOMEM;
 261         }
 262         fprog->len = data_len / sizeof(struct sock_filter);
 263         *pfprog = fprog;
 264         return 0;
 265 }
 266
 267 static void __fprog_destroy(struct sock_fprog *fprog)
 268 {
 269         kfree(fprog->filter);
 270         kfree(fprog);
 271 }
 272
 273 static int lb_bpf_func_set(struct team *team, struct team_gsetter_ctx *ctx)
 274 {
 275         struct lb_priv *lb_priv = get_lb_priv(team);
 276         struct sk_filter *fp = NULL;
 277         struct sk_filter *orig_fp;
 278         struct sock_fprog *fprog = NULL;
 279         int err;
 280
 281         if (ctx->data.bin_val.len) {
 282                 err = __fprog_create(&fprog, ctx->data.bin_val.len,
 283                                      ctx->data.bin_val.ptr);
 284                 if (err)
 285                         return err;
 286                 err = sk_unattached_filter_create(&fp, fprog);
 287                 if (err) {
 288                         __fprog_destroy(fprog);
 289                         return err;
 290                 }
 291         }
 292
 293         if (lb_priv->ex->orig_fprog) {
 294                 /* Clear old filter data */
 295                 __fprog_destroy(lb_priv->ex->orig_fprog);
 296                 orig_fp = rcu_dereference_protected(lb_priv->fp,
 297                                                 lockdep_is_held(&team->lock));
 298                 sk_unattached_filter_destroy(orig_fp);
 299         }
 300
 301         rcu_assign_pointer(lb_priv->fp, fp);
 302         lb_priv->ex->orig_fprog = fprog;
 303         return 0;
 304 }
 305
 306 static int lb_tx_method_get(struct team *team, struct team_gsetter_ctx *ctx)
 307 {
 308         struct lb_priv *lb_priv = get_lb_priv(team);
 309         lb_select_tx_port_func_t *func;
 310         char *name;
 311
 312         func = rcu_dereference_protected(lb_priv->select_tx_port_func,
 313                                          lockdep_is_held(&team->lock));
 314         name = lb_select_tx_port_get_name(func);
 315         BUG_ON(!name);
 316         ctx->data.str_val = name;
 317         return 0;
 318 }
 319
 320 static int lb_tx_method_set(struct team *team, struct team_gsetter_ctx *ctx)
 321 {
 322         struct lb_priv *lb_priv = get_lb_priv(team);
 323         lb_select_tx_port_func_t *func;
 324
 325         func = lb_select_tx_port_get_func(ctx->data.str_val);
 326         if (!func)
 327                 return -EINVAL;
 328         rcu_assign_pointer(lb_priv->select_tx_port_func, func);
 329         return 0;
 330 }
 331
 332 static int lb_tx_hash_to_port_mapping_init(struct team *team,
 333                                            struct team_option_inst_info *info)
 334 {
 335         struct lb_priv *lb_priv = get_lb_priv(team);
 336         unsigned char hash = info->array_index;
 337
 338         LB_HTPM_OPT_INST_INFO_BY_HASH(lb_priv, hash) = info;
 339         return 0;
 340 }
 341
 342 static int lb_tx_hash_to_port_mapping_get(struct team *team,
 343                                           struct team_gsetter_ctx *ctx)
 344 {
 345         struct lb_priv *lb_priv = get_lb_priv(team);
 346         struct team_port *port;
 347         unsigned char hash = ctx->info->array_index;
 348
 349         port = LB_HTPM_PORT_BY_HASH(lb_priv, hash);
 350         ctx->data.u32_val = port ? port->dev->ifindex : 0;
 351         return 0;
 352 }
 353
 354 static int lb_tx_hash_to_port_mapping_set(struct team *team,
 355                                           struct team_gsetter_ctx *ctx)
 356 {
 357         struct lb_priv *lb_priv = get_lb_priv(team);
 358         struct team_port *port;
 359         unsigned char hash = ctx->info->array_index;
 360
 361         list_for_each_entry(port, &team->port_list, list) {
 362                 if (ctx->data.u32_val == port->dev->ifindex &&
 363                     team_port_enabled(port)) {
 364                         rcu_assign_pointer(LB_HTPM_PORT_BY_HASH(lb_priv, hash),
 365                                            port);
 366                         return 0;
 367                 }
 368         }
 369         return -ENODEV;
 370 }
 371
 372 static int lb_hash_stats_init(struct team *team,
 373                               struct team_option_inst_info *info)
 374 {
 375         struct lb_priv *lb_priv = get_lb_priv(team);
 376         unsigned char hash = info->array_index;
 377
 378         lb_priv->ex->stats.info[hash].opt_inst_info = info;
 379         return 0;
 380 }
 381
 382 static int lb_hash_stats_get(struct team *team, struct team_gsetter_ctx *ctx)
 383 {
 384         struct lb_priv *lb_priv = get_lb_priv(team);
 385         unsigned char hash = ctx->info->array_index;
 386
 387         ctx->data.bin_val.ptr = &lb_priv->ex->stats.info[hash].stats;
 388         ctx->data.bin_val.len = sizeof(struct lb_stats);
 389         return 0;
 390 }
 391
 392 static int lb_port_stats_init(struct team *team,
 393                               struct team_option_inst_info *info)
 394 {
 395         struct team_port *port = info->port;
 396         struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
 397
 398         lb_port_priv->stats_info.opt_inst_info = info;
 399         return 0;
 400 }
 401
 402 static int lb_port_stats_get(struct team *team, struct team_gsetter_ctx *ctx)
 403 {
 404         struct team_port *port = ctx->info->port;
 405         struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
 406
 407         ctx->data.bin_val.ptr = &lb_port_priv->stats_info.stats;
 408         ctx->data.bin_val.len = sizeof(struct lb_stats);
 409         return 0;
 410 }
 411
 412 static void __lb_stats_info_refresh_prepare(struct lb_stats_info *s_info)
 413 {
 414         memcpy(&s_info->last_stats, &s_info->stats, sizeof(struct lb_stats));
 415         memset(&s_info->stats, 0, sizeof(struct lb_stats));
 416 }
 417
 418 static bool __lb_stats_info_refresh_check(struct lb_stats_info *s_info,
 419                                           struct team *team)
 420 {
 421         if (memcmp(&s_info->last_stats, &s_info->stats,
 422             sizeof(struct lb_stats))) {
 423                 team_option_inst_set_change(s_info->opt_inst_info);
 424                 return true;
 425         }
 426         return false;
 427 }
 428
 429 static void __lb_one_cpu_stats_add(struct lb_stats *acc_stats,
 430                                    struct lb_stats *cpu_stats,
 431                                    struct u64_stats_sync *syncp)
 432 {
 433         unsigned int start;
 434         struct lb_stats tmp;
 435
 436         do {
 437                 start = u64_stats_fetch_begin_bh(syncp);
 438                 tmp.tx_bytes = cpu_stats->tx_bytes;
 439         } while (u64_stats_fetch_retry_bh(syncp, start));
 440         acc_stats->tx_bytes += tmp.tx_bytes;
 441 }
 442
 443 static void lb_stats_refresh(struct work_struct *work)
 444 {
 445         struct team *team;
 446         struct lb_priv *lb_priv;
 447         struct lb_priv_ex *lb_priv_ex;
 448         struct lb_pcpu_stats *pcpu_stats;
 449         struct lb_stats *stats;
 450         struct lb_stats_info *s_info;
 451         struct team_port *port;
 452         bool changed = false;
 453         int i;
 454         int j;
 455
 456         lb_priv_ex = container_of(work, struct lb_priv_ex,
 457                                   stats.refresh_dw.work);
 458
 459         team = lb_priv_ex->team;
 460         lb_priv = get_lb_priv(team);
 461
 462         if (!mutex_trylock(&team->lock)) {
 463                 schedule_delayed_work(&lb_priv_ex->stats.refresh_dw, 0);
 464                 return;
 465         }
 466
 467         for (j = 0; j < LB_TX_HASHTABLE_SIZE; j++) {
 468                 s_info = &lb_priv->ex->stats.info[j];
 469                 __lb_stats_info_refresh_prepare(s_info);
 470                 for_each_possible_cpu(i) {
 471                         pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
 472                         stats = &pcpu_stats->hash_stats[j];
 473                         __lb_one_cpu_stats_add(&s_info->stats, stats,
 474                                                &pcpu_stats->syncp);
 475                 }
 476                 changed |= __lb_stats_info_refresh_check(s_info, team);
 477         }
 478
 479         list_for_each_entry(port, &team->port_list, list) {
 480                 struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
 481
 482                 s_info = &lb_port_priv->stats_info;
 483                 __lb_stats_info_refresh_prepare(s_info);
 484                 for_each_possible_cpu(i) {
 485                         pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
 486                         stats = per_cpu_ptr(lb_port_priv->pcpu_stats, i);
 487                         __lb_one_cpu_stats_add(&s_info->stats, stats,
 488                                                &pcpu_stats->syncp);
 489                 }
 490                 changed |= __lb_stats_info_refresh_check(s_info, team);
 491         }
 492
 493         if (changed)
 494                 team_options_change_check(team);
 495
 496         schedule_delayed_work(&lb_priv_ex->stats.refresh_dw,
 497                               (lb_priv_ex->stats.refresh_interval * HZ) / 10);
 498
 499         mutex_unlock(&team->lock);
 500 }
 501
 502 static int lb_stats_refresh_interval_get(struct team *team,
 503                                          struct team_gsetter_ctx *ctx)
 504 {
 505         struct lb_priv *lb_priv = get_lb_priv(team);
 506
 507         ctx->data.u32_val = lb_priv->ex->stats.refresh_interval;
 508         return 0;
 509 }
 510
 511 static int lb_stats_refresh_interval_set(struct team *team,
 512                                          struct team_gsetter_ctx *ctx)
 513 {
 514         struct lb_priv *lb_priv = get_lb_priv(team);
 515         unsigned int interval;
 516
 517         interval = ctx->data.u32_val;
 518         if (lb_priv->ex->stats.refresh_interval == interval)
 519                 return 0;
 520         lb_priv->ex->stats.refresh_interval = interval;
 521         if (interval)
 522                 schedule_delayed_work(&lb_priv->ex->stats.refresh_dw, 0);
 523         else
 524                 cancel_delayed_work(&lb_priv->ex->stats.refresh_dw);
 525         return 0;
 526 }
 527
 528 static const struct team_option lb_options[] = {
 529         {
 530                 .name = "bpf_hash_func",
 531                 .type = TEAM_OPTION_TYPE_BINARY,
 532                 .getter = lb_bpf_func_get,
 533                 .setter = lb_bpf_func_set,
 534         },
 535         {
 536                 .name = "lb_tx_method",
 537                 .type = TEAM_OPTION_TYPE_STRING,
 538                 .getter = lb_tx_method_get,
 539                 .setter = lb_tx_method_set,
 540         },
 541         {
 542                 .name = "lb_tx_hash_to_port_mapping",
 543                 .array_size = LB_TX_HASHTABLE_SIZE,
 544                 .type = TEAM_OPTION_TYPE_U32,
 545                 .init = lb_tx_hash_to_port_mapping_init,
 546                 .getter = lb_tx_hash_to_port_mapping_get,
 547                 .setter = lb_tx_hash_to_port_mapping_set,
 548         },
 549         {
 550                 .name = "lb_hash_stats",
 551                 .array_size = LB_TX_HASHTABLE_SIZE,
 552                 .type = TEAM_OPTION_TYPE_BINARY,
 553                 .init = lb_hash_stats_init,
 554                 .getter = lb_hash_stats_get,
 555         },
 556         {
 557                 .name = "lb_port_stats",
 558                 .per_port = true,
 559                 .type = TEAM_OPTION_TYPE_BINARY,
 560                 .init = lb_port_stats_init,
 561                 .getter = lb_port_stats_get,
 562         },
 563         {
 564                 .name = "lb_stats_refresh_interval",
 565                 .type = TEAM_OPTION_TYPE_U32,
 566                 .getter = lb_stats_refresh_interval_get,
 567                 .setter = lb_stats_refresh_interval_set,
 568         },
 569 };
 570
 571 static int lb_init(struct team *team)
 572 {
 573         struct lb_priv *lb_priv = get_lb_priv(team);
 574         lb_select_tx_port_func_t *func;
 575         int err;
 576
 577         /* set default tx port selector */
 578         func = lb_select_tx_port_get_func("hash");
 579         BUG_ON(!func);
 580         rcu_assign_pointer(lb_priv->select_tx_port_func, func);
 581
 582         lb_priv->ex = kzalloc(sizeof(*lb_priv->ex), GFP_KERNEL);
 583         if (!lb_priv->ex)
 584                 return -ENOMEM;
 585         lb_priv->ex->team = team;
 586
 587         lb_priv->pcpu_stats = alloc_percpu(struct lb_pcpu_stats);
 588         if (!lb_priv->pcpu_stats) {
 589                 err = -ENOMEM;
 590                 goto err_alloc_pcpu_stats;
 591         }
 592
 593         INIT_DELAYED_WORK(&lb_priv->ex->stats.refresh_dw, lb_stats_refresh);
 594
 595         err = team_options_register(team, lb_options, ARRAY_SIZE(lb_options));
 596         if (err)
 597                 goto err_options_register;
 598         return 0;
 599
 600 err_options_register:
 601         free_percpu(lb_priv->pcpu_stats);
 602 err_alloc_pcpu_stats:
 603         kfree(lb_priv->ex);
 604         return err;
 605 }
 606
 607 static void lb_exit(struct team *team)
 608 {
 609         struct lb_priv *lb_priv = get_lb_priv(team);
 610
 611         team_options_unregister(team, lb_options,
 612                                 ARRAY_SIZE(lb_options));
 613         cancel_delayed_work_sync(&lb_priv->ex->stats.refresh_dw);
 614         free_percpu(lb_priv->pcpu_stats);
 615         kfree(lb_priv->ex);
 616 }
 617
 618 static int lb_port_enter(struct team *team, struct team_port *port)
 619 {
 620         struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
 621
 622         lb_port_priv->pcpu_stats = alloc_percpu(struct lb_stats);
 623         if (!lb_port_priv->pcpu_stats)
 624                 return -ENOMEM;
 625         return 0;
 626 }
 627
 628 static void lb_port_leave(struct team *team, struct team_port *port)
 629 {
 630         struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
 631
 632         free_percpu(lb_port_priv->pcpu_stats);
 633 }
 634
 635 static void lb_port_disabled(struct team *team, struct team_port *port)
 636 {
 637         lb_tx_hash_to_port_mapping_null_port(team, port);
 638 }
 639
 640 static const struct team_mode_ops lb_mode_ops = {
 641         .init                   = lb_init,
 642         .exit                   = lb_exit,
 643         .port_enter             = lb_port_enter,
 644         .port_leave             = lb_port_leave,
 645         .port_disabled          = lb_port_disabled,
 646         .transmit               = lb_transmit,
 647 };
 648
 649 static const struct team_mode lb_mode = {
 650         .kind           = "loadbalance",
 651         .owner          = THIS_MODULE,
 652         .priv_size      = sizeof(struct lb_priv),
 653         .port_priv_size = sizeof(struct lb_port_priv),
 654         .ops            = &lb_mode_ops,
 655 };
 656
 657 static int __init lb_init_module(void)
 658 {
 659         return team_mode_register(&lb_mode);
 660 }
 661
 662 static void __exit lb_cleanup_module(void)
 663 {
 664         team_mode_unregister(&lb_mode);
 665 }
 666
 667 module_init(lb_init_module);
 668 module_exit(lb_cleanup_module);
 669
 670 MODULE_LICENSE("GPL v2");
 671 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
 672 MODULE_DESCRIPTION("Load-balancing mode for team");
 673 MODULE_ALIAS("team-mode-loadbalance");