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