1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2007, 2009 4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 5 * Frank Pavlic <fpavlic@de.ibm.com>, 6 * Thomas Spatzier <tspat@de.ibm.com>, 7 * Frank Blaschka <frank.blaschka@de.ibm.com> 8 */ 9 10 #define KMSG_COMPONENT "qeth" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/module.h> 14 #include <linux/moduleparam.h> 15 #include <linux/bitops.h> 16 #include <linux/string.h> 17 #include <linux/errno.h> 18 #include <linux/kernel.h> 19 #include <linux/etherdevice.h> 20 #include <linux/ip.h> 21 #include <linux/in.h> 22 #include <linux/ipv6.h> 23 #include <linux/inetdevice.h> 24 #include <linux/igmp.h> 25 #include <linux/slab.h> 26 #include <linux/if_ether.h> 27 #include <linux/if_vlan.h> 28 #include <linux/skbuff.h> 29 30 #include <net/ip.h> 31 #include <net/arp.h> 32 #include <net/route.h> 33 #include <net/ipv6.h> 34 #include <net/ip6_route.h> 35 #include <net/iucv/af_iucv.h> 36 #include <linux/hashtable.h> 37 38 #include "qeth_l3.h" 39 40 41 static int qeth_l3_set_offline(struct ccwgroup_device *); 42 static int qeth_l3_register_addr_entry(struct qeth_card *, 43 struct qeth_ipaddr *); 44 static int qeth_l3_deregister_addr_entry(struct qeth_card *, 45 struct qeth_ipaddr *); 46 47 int qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const u8 *addr, 48 char *buf) 49 { 50 if (proto == QETH_PROT_IPV4) 51 return sprintf(buf, "%pI4", addr); 52 else 53 return sprintf(buf, "%pI6", addr); 54 } 55 56 static struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card, 57 struct qeth_ipaddr *query) 58 { 59 u32 key = qeth_l3_ipaddr_hash(query); 60 struct qeth_ipaddr *addr; 61 62 if (query->is_multicast) { 63 hash_for_each_possible(card->ip_mc_htable, addr, hnode, key) 64 if (qeth_l3_addr_match_ip(addr, query)) 65 return addr; 66 } else { 67 hash_for_each_possible(card->ip_htable, addr, hnode, key) 68 if (qeth_l3_addr_match_ip(addr, query)) 69 return addr; 70 } 71 return NULL; 72 } 73 74 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len) 75 { 76 int i, j; 77 u8 octet; 78 79 for (i = 0; i < len; ++i) { 80 octet = addr[i]; 81 for (j = 7; j >= 0; --j) { 82 bits[i*8 + j] = octet & 1; 83 octet >>= 1; 84 } 85 } 86 } 87 88 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card, 89 struct qeth_ipaddr *addr) 90 { 91 struct qeth_ipato_entry *ipatoe; 92 u8 addr_bits[128] = {0, }; 93 u8 ipatoe_bits[128] = {0, }; 94 int rc = 0; 95 96 if (!card->ipato.enabled) 97 return false; 98 if (addr->type != QETH_IP_TYPE_NORMAL) 99 return false; 100 101 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits, 102 (addr->proto == QETH_PROT_IPV4)? 4:16); 103 list_for_each_entry(ipatoe, &card->ipato.entries, entry) { 104 if (addr->proto != ipatoe->proto) 105 continue; 106 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits, 107 (ipatoe->proto == QETH_PROT_IPV4) ? 108 4 : 16); 109 if (addr->proto == QETH_PROT_IPV4) 110 rc = !memcmp(addr_bits, ipatoe_bits, 111 min(32, ipatoe->mask_bits)); 112 else 113 rc = !memcmp(addr_bits, ipatoe_bits, 114 min(128, ipatoe->mask_bits)); 115 if (rc) 116 break; 117 } 118 /* invert? */ 119 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4) 120 rc = !rc; 121 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6) 122 rc = !rc; 123 124 return rc; 125 } 126 127 static int qeth_l3_delete_ip(struct qeth_card *card, 128 struct qeth_ipaddr *tmp_addr) 129 { 130 int rc = 0; 131 struct qeth_ipaddr *addr; 132 133 if (tmp_addr->type == QETH_IP_TYPE_RXIP) 134 QETH_CARD_TEXT(card, 2, "delrxip"); 135 else if (tmp_addr->type == QETH_IP_TYPE_VIPA) 136 QETH_CARD_TEXT(card, 2, "delvipa"); 137 else 138 QETH_CARD_TEXT(card, 2, "delip"); 139 140 if (tmp_addr->proto == QETH_PROT_IPV4) 141 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4); 142 else { 143 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8); 144 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8); 145 } 146 147 addr = qeth_l3_find_addr_by_ip(card, tmp_addr); 148 if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr)) 149 return -ENOENT; 150 151 addr->ref_counter--; 152 if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0) 153 return rc; 154 155 if (qeth_card_hw_is_reachable(card)) 156 rc = qeth_l3_deregister_addr_entry(card, addr); 157 158 hash_del(&addr->hnode); 159 kfree(addr); 160 161 return rc; 162 } 163 164 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr) 165 { 166 int rc = 0; 167 struct qeth_ipaddr *addr; 168 char buf[40]; 169 170 if (tmp_addr->type == QETH_IP_TYPE_RXIP) 171 QETH_CARD_TEXT(card, 2, "addrxip"); 172 else if (tmp_addr->type == QETH_IP_TYPE_VIPA) 173 QETH_CARD_TEXT(card, 2, "addvipa"); 174 else 175 QETH_CARD_TEXT(card, 2, "addip"); 176 177 if (tmp_addr->proto == QETH_PROT_IPV4) 178 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4); 179 else { 180 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8); 181 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8); 182 } 183 184 addr = qeth_l3_find_addr_by_ip(card, tmp_addr); 185 if (addr) { 186 if (tmp_addr->type != QETH_IP_TYPE_NORMAL) 187 return -EADDRINUSE; 188 if (qeth_l3_addr_match_all(addr, tmp_addr)) { 189 addr->ref_counter++; 190 return 0; 191 } 192 qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u, 193 buf); 194 dev_warn(&card->gdev->dev, 195 "Registering IP address %s failed\n", buf); 196 return -EADDRINUSE; 197 } else { 198 addr = kmemdup(tmp_addr, sizeof(*tmp_addr), GFP_KERNEL); 199 if (!addr) 200 return -ENOMEM; 201 202 if (qeth_l3_is_addr_covered_by_ipato(card, addr)) { 203 QETH_CARD_TEXT(card, 2, "tkovaddr"); 204 addr->ipato = 1; 205 } 206 hash_add(card->ip_htable, &addr->hnode, 207 qeth_l3_ipaddr_hash(addr)); 208 209 if (!qeth_card_hw_is_reachable(card)) { 210 addr->disp_flag = QETH_DISP_ADDR_ADD; 211 return 0; 212 } 213 214 rc = qeth_l3_register_addr_entry(card, addr); 215 216 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) { 217 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING; 218 } else { 219 hash_del(&addr->hnode); 220 kfree(addr); 221 } 222 } 223 return rc; 224 } 225 226 static int qeth_l3_modify_ip(struct qeth_card *card, struct qeth_ipaddr *addr, 227 bool add) 228 { 229 int rc; 230 231 mutex_lock(&card->ip_lock); 232 rc = add ? qeth_l3_add_ip(card, addr) : qeth_l3_delete_ip(card, addr); 233 mutex_unlock(&card->ip_lock); 234 235 return rc; 236 } 237 238 static void qeth_l3_drain_rx_mode_cache(struct qeth_card *card) 239 { 240 struct qeth_ipaddr *addr; 241 struct hlist_node *tmp; 242 int i; 243 244 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) { 245 hash_del(&addr->hnode); 246 kfree(addr); 247 } 248 } 249 250 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover) 251 { 252 struct qeth_ipaddr *addr; 253 struct hlist_node *tmp; 254 int i; 255 256 QETH_CARD_TEXT(card, 4, "clearip"); 257 258 mutex_lock(&card->ip_lock); 259 260 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) { 261 if (!recover) { 262 hash_del(&addr->hnode); 263 kfree(addr); 264 continue; 265 } 266 addr->disp_flag = QETH_DISP_ADDR_ADD; 267 } 268 269 mutex_unlock(&card->ip_lock); 270 } 271 272 static void qeth_l3_recover_ip(struct qeth_card *card) 273 { 274 struct qeth_ipaddr *addr; 275 struct hlist_node *tmp; 276 int i; 277 int rc; 278 279 QETH_CARD_TEXT(card, 4, "recovrip"); 280 281 mutex_lock(&card->ip_lock); 282 283 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) { 284 if (addr->disp_flag == QETH_DISP_ADDR_ADD) { 285 rc = qeth_l3_register_addr_entry(card, addr); 286 287 if (!rc) { 288 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING; 289 } else { 290 hash_del(&addr->hnode); 291 kfree(addr); 292 } 293 } 294 } 295 296 mutex_unlock(&card->ip_lock); 297 } 298 299 static int qeth_l3_setdelip_cb(struct qeth_card *card, struct qeth_reply *reply, 300 unsigned long data) 301 { 302 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 303 304 switch (cmd->hdr.return_code) { 305 case IPA_RC_SUCCESS: 306 return 0; 307 case IPA_RC_DUPLICATE_IP_ADDRESS: 308 return -EADDRINUSE; 309 case IPA_RC_MC_ADDR_NOT_FOUND: 310 return -ENOENT; 311 case IPA_RC_LAN_OFFLINE: 312 return -ENETDOWN; 313 default: 314 return -EIO; 315 } 316 } 317 318 static int qeth_l3_send_setdelmc(struct qeth_card *card, 319 struct qeth_ipaddr *addr, int ipacmd) 320 { 321 struct qeth_cmd_buffer *iob; 322 struct qeth_ipa_cmd *cmd; 323 324 QETH_CARD_TEXT(card, 4, "setdelmc"); 325 326 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto, 327 IPA_DATA_SIZEOF(setdelipm)); 328 if (!iob) 329 return -ENOMEM; 330 cmd = __ipa_cmd(iob); 331 if (addr->proto == QETH_PROT_IPV6) { 332 cmd->data.setdelipm.ip = addr->u.a6.addr; 333 ipv6_eth_mc_map(&addr->u.a6.addr, cmd->data.setdelipm.mac); 334 } else { 335 cmd->data.setdelipm.ip.s6_addr32[3] = addr->u.a4.addr; 336 ip_eth_mc_map(addr->u.a4.addr, cmd->data.setdelipm.mac); 337 } 338 339 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL); 340 } 341 342 static void qeth_l3_set_ipv6_prefix(struct in6_addr *prefix, unsigned int len) 343 { 344 unsigned int i = 0; 345 346 while (len && i < 4) { 347 int mask_len = min_t(int, len, 32); 348 349 prefix->s6_addr32[i] = inet_make_mask(mask_len); 350 len -= mask_len; 351 i++; 352 } 353 } 354 355 static u32 qeth_l3_get_setdelip_flags(struct qeth_ipaddr *addr, bool set) 356 { 357 switch (addr->type) { 358 case QETH_IP_TYPE_RXIP: 359 return (set) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0; 360 case QETH_IP_TYPE_VIPA: 361 return (set) ? QETH_IPA_SETIP_VIPA_FLAG : 362 QETH_IPA_DELIP_VIPA_FLAG; 363 default: 364 return (set && addr->ipato) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0; 365 } 366 } 367 368 static int qeth_l3_send_setdelip(struct qeth_card *card, 369 struct qeth_ipaddr *addr, 370 enum qeth_ipa_cmds ipacmd) 371 { 372 struct qeth_cmd_buffer *iob; 373 struct qeth_ipa_cmd *cmd; 374 u32 flags; 375 376 QETH_CARD_TEXT(card, 4, "setdelip"); 377 378 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto, 379 IPA_DATA_SIZEOF(setdelip6)); 380 if (!iob) 381 return -ENOMEM; 382 cmd = __ipa_cmd(iob); 383 384 flags = qeth_l3_get_setdelip_flags(addr, ipacmd == IPA_CMD_SETIP); 385 QETH_CARD_TEXT_(card, 4, "flags%02X", flags); 386 387 if (addr->proto == QETH_PROT_IPV6) { 388 cmd->data.setdelip6.addr = addr->u.a6.addr; 389 qeth_l3_set_ipv6_prefix(&cmd->data.setdelip6.prefix, 390 addr->u.a6.pfxlen); 391 cmd->data.setdelip6.flags = flags; 392 } else { 393 cmd->data.setdelip4.addr = addr->u.a4.addr; 394 cmd->data.setdelip4.mask = addr->u.a4.mask; 395 cmd->data.setdelip4.flags = flags; 396 } 397 398 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL); 399 } 400 401 static int qeth_l3_send_setrouting(struct qeth_card *card, 402 enum qeth_routing_types type, enum qeth_prot_versions prot) 403 { 404 int rc; 405 struct qeth_ipa_cmd *cmd; 406 struct qeth_cmd_buffer *iob; 407 408 QETH_CARD_TEXT(card, 4, "setroutg"); 409 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_SETRTG, prot, 410 IPA_DATA_SIZEOF(setrtg)); 411 if (!iob) 412 return -ENOMEM; 413 cmd = __ipa_cmd(iob); 414 cmd->data.setrtg.type = (type); 415 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL); 416 417 return rc; 418 } 419 420 static int qeth_l3_correct_routing_type(struct qeth_card *card, 421 enum qeth_routing_types *type, enum qeth_prot_versions prot) 422 { 423 if (IS_IQD(card)) { 424 switch (*type) { 425 case NO_ROUTER: 426 case PRIMARY_CONNECTOR: 427 case SECONDARY_CONNECTOR: 428 case MULTICAST_ROUTER: 429 return 0; 430 default: 431 goto out_inval; 432 } 433 } else { 434 switch (*type) { 435 case NO_ROUTER: 436 case PRIMARY_ROUTER: 437 case SECONDARY_ROUTER: 438 return 0; 439 case MULTICAST_ROUTER: 440 if (qeth_is_ipafunc_supported(card, prot, 441 IPA_OSA_MC_ROUTER)) 442 return 0; 443 default: 444 goto out_inval; 445 } 446 } 447 out_inval: 448 *type = NO_ROUTER; 449 return -EINVAL; 450 } 451 452 int qeth_l3_setrouting_v4(struct qeth_card *card) 453 { 454 int rc; 455 456 QETH_CARD_TEXT(card, 3, "setrtg4"); 457 458 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type, 459 QETH_PROT_IPV4); 460 if (rc) 461 return rc; 462 463 rc = qeth_l3_send_setrouting(card, card->options.route4.type, 464 QETH_PROT_IPV4); 465 if (rc) { 466 card->options.route4.type = NO_ROUTER; 467 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n", 468 rc, CARD_DEVID(card)); 469 } 470 return rc; 471 } 472 473 int qeth_l3_setrouting_v6(struct qeth_card *card) 474 { 475 int rc = 0; 476 477 QETH_CARD_TEXT(card, 3, "setrtg6"); 478 479 if (!qeth_is_supported(card, IPA_IPV6)) 480 return 0; 481 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type, 482 QETH_PROT_IPV6); 483 if (rc) 484 return rc; 485 486 rc = qeth_l3_send_setrouting(card, card->options.route6.type, 487 QETH_PROT_IPV6); 488 if (rc) { 489 card->options.route6.type = NO_ROUTER; 490 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n", 491 rc, CARD_DEVID(card)); 492 } 493 return rc; 494 } 495 496 /* 497 * IP address takeover related functions 498 */ 499 500 /** 501 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs. 502 * 503 * Caller must hold ip_lock. 504 */ 505 void qeth_l3_update_ipato(struct qeth_card *card) 506 { 507 struct qeth_ipaddr *addr; 508 unsigned int i; 509 510 hash_for_each(card->ip_htable, i, addr, hnode) { 511 if (addr->type != QETH_IP_TYPE_NORMAL) 512 continue; 513 addr->ipato = qeth_l3_is_addr_covered_by_ipato(card, addr); 514 } 515 } 516 517 static void qeth_l3_clear_ipato_list(struct qeth_card *card) 518 { 519 struct qeth_ipato_entry *ipatoe, *tmp; 520 521 mutex_lock(&card->ip_lock); 522 523 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) { 524 list_del(&ipatoe->entry); 525 kfree(ipatoe); 526 } 527 528 qeth_l3_update_ipato(card); 529 mutex_unlock(&card->ip_lock); 530 } 531 532 int qeth_l3_add_ipato_entry(struct qeth_card *card, 533 struct qeth_ipato_entry *new) 534 { 535 struct qeth_ipato_entry *ipatoe; 536 int rc = 0; 537 538 QETH_CARD_TEXT(card, 2, "addipato"); 539 540 mutex_lock(&card->conf_mutex); 541 mutex_lock(&card->ip_lock); 542 543 list_for_each_entry(ipatoe, &card->ipato.entries, entry) { 544 if (ipatoe->proto != new->proto) 545 continue; 546 if (!memcmp(ipatoe->addr, new->addr, 547 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) && 548 (ipatoe->mask_bits == new->mask_bits)) { 549 rc = -EEXIST; 550 break; 551 } 552 } 553 554 if (!rc) { 555 list_add_tail(&new->entry, &card->ipato.entries); 556 qeth_l3_update_ipato(card); 557 } 558 559 mutex_unlock(&card->ip_lock); 560 mutex_unlock(&card->conf_mutex); 561 562 return rc; 563 } 564 565 int qeth_l3_del_ipato_entry(struct qeth_card *card, 566 enum qeth_prot_versions proto, u8 *addr, 567 int mask_bits) 568 { 569 struct qeth_ipato_entry *ipatoe, *tmp; 570 int rc = -ENOENT; 571 572 QETH_CARD_TEXT(card, 2, "delipato"); 573 574 mutex_lock(&card->conf_mutex); 575 mutex_lock(&card->ip_lock); 576 577 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) { 578 if (ipatoe->proto != proto) 579 continue; 580 if (!memcmp(ipatoe->addr, addr, 581 (proto == QETH_PROT_IPV4)? 4:16) && 582 (ipatoe->mask_bits == mask_bits)) { 583 list_del(&ipatoe->entry); 584 qeth_l3_update_ipato(card); 585 kfree(ipatoe); 586 rc = 0; 587 } 588 } 589 590 mutex_unlock(&card->ip_lock); 591 mutex_unlock(&card->conf_mutex); 592 593 return rc; 594 } 595 596 int qeth_l3_modify_rxip_vipa(struct qeth_card *card, bool add, const u8 *ip, 597 enum qeth_ip_types type, 598 enum qeth_prot_versions proto) 599 { 600 struct qeth_ipaddr addr; 601 int rc; 602 603 qeth_l3_init_ipaddr(&addr, type, proto); 604 if (proto == QETH_PROT_IPV4) 605 memcpy(&addr.u.a4.addr, ip, 4); 606 else 607 memcpy(&addr.u.a6.addr, ip, 16); 608 609 mutex_lock(&card->conf_mutex); 610 rc = qeth_l3_modify_ip(card, &addr, add); 611 mutex_unlock(&card->conf_mutex); 612 613 return rc; 614 } 615 616 int qeth_l3_modify_hsuid(struct qeth_card *card, bool add) 617 { 618 struct qeth_ipaddr addr; 619 unsigned int i; 620 621 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6); 622 addr.u.a6.addr.s6_addr[0] = 0xfe; 623 addr.u.a6.addr.s6_addr[1] = 0x80; 624 for (i = 0; i < 8; i++) 625 addr.u.a6.addr.s6_addr[8+i] = card->options.hsuid[i]; 626 627 return qeth_l3_modify_ip(card, &addr, add); 628 } 629 630 static int qeth_l3_register_addr_entry(struct qeth_card *card, 631 struct qeth_ipaddr *addr) 632 { 633 char buf[50]; 634 int rc = 0; 635 int cnt = 3; 636 637 if (card->options.sniffer) 638 return 0; 639 640 if (addr->proto == QETH_PROT_IPV4) { 641 QETH_CARD_TEXT(card, 2, "setaddr4"); 642 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int)); 643 } else if (addr->proto == QETH_PROT_IPV6) { 644 QETH_CARD_TEXT(card, 2, "setaddr6"); 645 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8); 646 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8); 647 } else { 648 QETH_CARD_TEXT(card, 2, "setaddr?"); 649 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr)); 650 } 651 do { 652 if (addr->is_multicast) 653 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM); 654 else 655 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP); 656 if (rc) 657 QETH_CARD_TEXT(card, 2, "failed"); 658 } while ((--cnt > 0) && rc); 659 if (rc) { 660 QETH_CARD_TEXT(card, 2, "FAILED"); 661 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf); 662 dev_warn(&card->gdev->dev, 663 "Registering IP address %s failed\n", buf); 664 } 665 return rc; 666 } 667 668 static int qeth_l3_deregister_addr_entry(struct qeth_card *card, 669 struct qeth_ipaddr *addr) 670 { 671 int rc = 0; 672 673 if (card->options.sniffer) 674 return 0; 675 676 if (addr->proto == QETH_PROT_IPV4) { 677 QETH_CARD_TEXT(card, 2, "deladdr4"); 678 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int)); 679 } else if (addr->proto == QETH_PROT_IPV6) { 680 QETH_CARD_TEXT(card, 2, "deladdr6"); 681 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8); 682 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8); 683 } else { 684 QETH_CARD_TEXT(card, 2, "deladdr?"); 685 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr)); 686 } 687 if (addr->is_multicast) 688 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM); 689 else 690 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP); 691 if (rc) 692 QETH_CARD_TEXT(card, 2, "failed"); 693 694 return rc; 695 } 696 697 static int qeth_l3_setadapter_parms(struct qeth_card *card) 698 { 699 int rc = 0; 700 701 QETH_CARD_TEXT(card, 2, "setadprm"); 702 703 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) { 704 rc = qeth_setadpparms_change_macaddr(card); 705 if (rc) 706 dev_warn(&card->gdev->dev, "Reading the adapter MAC" 707 " address failed\n"); 708 } 709 710 return rc; 711 } 712 713 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card) 714 { 715 int rc; 716 717 QETH_CARD_TEXT(card, 3, "ipaarp"); 718 719 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 720 dev_info(&card->gdev->dev, 721 "ARP processing not supported on %s!\n", 722 QETH_CARD_IFNAME(card)); 723 return 0; 724 } 725 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING, 726 IPA_CMD_ASS_START, NULL); 727 if (rc) { 728 dev_warn(&card->gdev->dev, 729 "Starting ARP processing support for %s failed\n", 730 QETH_CARD_IFNAME(card)); 731 } 732 return rc; 733 } 734 735 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card) 736 { 737 int rc; 738 739 QETH_CARD_TEXT(card, 3, "stsrcmac"); 740 741 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) { 742 dev_info(&card->gdev->dev, 743 "Inbound source MAC-address not supported on %s\n", 744 QETH_CARD_IFNAME(card)); 745 return -EOPNOTSUPP; 746 } 747 748 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC, 749 IPA_CMD_ASS_START, NULL); 750 if (rc) 751 dev_warn(&card->gdev->dev, 752 "Starting source MAC-address support for %s failed\n", 753 QETH_CARD_IFNAME(card)); 754 return rc; 755 } 756 757 static int qeth_l3_start_ipa_vlan(struct qeth_card *card) 758 { 759 int rc = 0; 760 761 QETH_CARD_TEXT(card, 3, "strtvlan"); 762 763 if (!qeth_is_supported(card, IPA_FULL_VLAN)) { 764 dev_info(&card->gdev->dev, 765 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card)); 766 return -EOPNOTSUPP; 767 } 768 769 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO, 770 IPA_CMD_ASS_START, NULL); 771 if (rc) { 772 dev_warn(&card->gdev->dev, 773 "Starting VLAN support for %s failed\n", 774 QETH_CARD_IFNAME(card)); 775 } else { 776 dev_info(&card->gdev->dev, "VLAN enabled\n"); 777 } 778 return rc; 779 } 780 781 static int qeth_l3_start_ipa_multicast(struct qeth_card *card) 782 { 783 int rc; 784 785 QETH_CARD_TEXT(card, 3, "stmcast"); 786 787 if (!qeth_is_supported(card, IPA_MULTICASTING)) { 788 dev_info(&card->gdev->dev, 789 "Multicast not supported on %s\n", 790 QETH_CARD_IFNAME(card)); 791 return -EOPNOTSUPP; 792 } 793 794 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING, 795 IPA_CMD_ASS_START, NULL); 796 if (rc) { 797 dev_warn(&card->gdev->dev, 798 "Starting multicast support for %s failed\n", 799 QETH_CARD_IFNAME(card)); 800 } else { 801 dev_info(&card->gdev->dev, "Multicast enabled\n"); 802 card->dev->flags |= IFF_MULTICAST; 803 } 804 return rc; 805 } 806 807 static int qeth_l3_softsetup_ipv6(struct qeth_card *card) 808 { 809 u32 ipv6_data = 3; 810 int rc; 811 812 QETH_CARD_TEXT(card, 3, "softipv6"); 813 814 if (IS_IQD(card)) 815 goto out; 816 817 rc = qeth_send_simple_setassparms(card, IPA_IPV6, IPA_CMD_ASS_START, 818 &ipv6_data); 819 if (rc) { 820 dev_err(&card->gdev->dev, 821 "Activating IPv6 support for %s failed\n", 822 QETH_CARD_IFNAME(card)); 823 return rc; 824 } 825 rc = qeth_send_simple_setassparms_v6(card, IPA_IPV6, IPA_CMD_ASS_START, 826 NULL); 827 if (rc) { 828 dev_err(&card->gdev->dev, 829 "Activating IPv6 support for %s failed\n", 830 QETH_CARD_IFNAME(card)); 831 return rc; 832 } 833 rc = qeth_send_simple_setassparms_v6(card, IPA_PASSTHRU, 834 IPA_CMD_ASS_START, NULL); 835 if (rc) { 836 dev_warn(&card->gdev->dev, 837 "Enabling the passthrough mode for %s failed\n", 838 QETH_CARD_IFNAME(card)); 839 return rc; 840 } 841 out: 842 dev_info(&card->gdev->dev, "IPV6 enabled\n"); 843 return 0; 844 } 845 846 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card) 847 { 848 QETH_CARD_TEXT(card, 3, "strtipv6"); 849 850 if (!qeth_is_supported(card, IPA_IPV6)) { 851 dev_info(&card->gdev->dev, 852 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card)); 853 return 0; 854 } 855 return qeth_l3_softsetup_ipv6(card); 856 } 857 858 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card) 859 { 860 u32 filter_data = 1; 861 int rc; 862 863 QETH_CARD_TEXT(card, 3, "stbrdcst"); 864 card->info.broadcast_capable = 0; 865 if (!qeth_is_supported(card, IPA_FILTERING)) { 866 dev_info(&card->gdev->dev, 867 "Broadcast not supported on %s\n", 868 QETH_CARD_IFNAME(card)); 869 rc = -EOPNOTSUPP; 870 goto out; 871 } 872 rc = qeth_send_simple_setassparms(card, IPA_FILTERING, 873 IPA_CMD_ASS_START, NULL); 874 if (rc) { 875 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for " 876 "%s failed\n", QETH_CARD_IFNAME(card)); 877 goto out; 878 } 879 880 rc = qeth_send_simple_setassparms(card, IPA_FILTERING, 881 IPA_CMD_ASS_CONFIGURE, &filter_data); 882 if (rc) { 883 dev_warn(&card->gdev->dev, 884 "Setting up broadcast filtering for %s failed\n", 885 QETH_CARD_IFNAME(card)); 886 goto out; 887 } 888 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO; 889 dev_info(&card->gdev->dev, "Broadcast enabled\n"); 890 rc = qeth_send_simple_setassparms(card, IPA_FILTERING, 891 IPA_CMD_ASS_ENABLE, &filter_data); 892 if (rc) { 893 dev_warn(&card->gdev->dev, "Setting up broadcast echo " 894 "filtering for %s failed\n", QETH_CARD_IFNAME(card)); 895 goto out; 896 } 897 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO; 898 out: 899 if (card->info.broadcast_capable) 900 card->dev->flags |= IFF_BROADCAST; 901 else 902 card->dev->flags &= ~IFF_BROADCAST; 903 return rc; 904 } 905 906 static int qeth_l3_start_ipassists(struct qeth_card *card) 907 { 908 QETH_CARD_TEXT(card, 3, "strtipas"); 909 910 qeth_l3_start_ipa_arp_processing(card); /* go on*/ 911 qeth_l3_start_ipa_source_mac(card); /* go on*/ 912 qeth_l3_start_ipa_vlan(card); /* go on*/ 913 qeth_l3_start_ipa_multicast(card); /* go on*/ 914 qeth_l3_start_ipa_ipv6(card); /* go on*/ 915 qeth_l3_start_ipa_broadcast(card); /* go on*/ 916 return 0; 917 } 918 919 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card, 920 struct qeth_reply *reply, unsigned long data) 921 { 922 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 923 924 if (cmd->hdr.return_code) 925 return -EIO; 926 927 ether_addr_copy(card->dev->dev_addr, 928 cmd->data.create_destroy_addr.unique_id); 929 return 0; 930 } 931 932 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card) 933 { 934 int rc = 0; 935 struct qeth_cmd_buffer *iob; 936 struct qeth_ipa_cmd *cmd; 937 938 QETH_CARD_TEXT(card, 2, "hsrmac"); 939 940 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6, 941 IPA_DATA_SIZEOF(create_destroy_addr)); 942 if (!iob) 943 return -ENOMEM; 944 cmd = __ipa_cmd(iob); 945 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) = 946 card->info.unique_id; 947 948 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb, 949 NULL); 950 return rc; 951 } 952 953 static int qeth_l3_get_unique_id_cb(struct qeth_card *card, 954 struct qeth_reply *reply, unsigned long data) 955 { 956 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 957 958 if (cmd->hdr.return_code == 0) { 959 card->info.unique_id = *((__u16 *) 960 &cmd->data.create_destroy_addr.unique_id[6]); 961 return 0; 962 } 963 964 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED | 965 UNIQUE_ID_NOT_BY_CARD; 966 dev_warn(&card->gdev->dev, "The network adapter failed to generate a unique ID\n"); 967 return -EIO; 968 } 969 970 static int qeth_l3_get_unique_id(struct qeth_card *card) 971 { 972 int rc = 0; 973 struct qeth_cmd_buffer *iob; 974 struct qeth_ipa_cmd *cmd; 975 976 QETH_CARD_TEXT(card, 2, "guniqeid"); 977 978 if (!qeth_is_supported(card, IPA_IPV6)) { 979 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED | 980 UNIQUE_ID_NOT_BY_CARD; 981 return 0; 982 } 983 984 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6, 985 IPA_DATA_SIZEOF(create_destroy_addr)); 986 if (!iob) 987 return -ENOMEM; 988 cmd = __ipa_cmd(iob); 989 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) = 990 card->info.unique_id; 991 992 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL); 993 return rc; 994 } 995 996 static int 997 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply, 998 unsigned long data) 999 { 1000 struct qeth_ipa_cmd *cmd; 1001 __u16 rc; 1002 1003 QETH_CARD_TEXT(card, 2, "diastrcb"); 1004 1005 cmd = (struct qeth_ipa_cmd *)data; 1006 rc = cmd->hdr.return_code; 1007 if (rc) 1008 QETH_CARD_TEXT_(card, 2, "dxter%x", rc); 1009 switch (cmd->data.diagass.action) { 1010 case QETH_DIAGS_CMD_TRACE_QUERY: 1011 break; 1012 case QETH_DIAGS_CMD_TRACE_DISABLE: 1013 switch (rc) { 1014 case 0: 1015 case IPA_RC_INVALID_SUBCMD: 1016 card->info.promisc_mode = SET_PROMISC_MODE_OFF; 1017 dev_info(&card->gdev->dev, "The HiperSockets network " 1018 "traffic analyzer is deactivated\n"); 1019 break; 1020 default: 1021 break; 1022 } 1023 break; 1024 case QETH_DIAGS_CMD_TRACE_ENABLE: 1025 switch (rc) { 1026 case 0: 1027 card->info.promisc_mode = SET_PROMISC_MODE_ON; 1028 dev_info(&card->gdev->dev, "The HiperSockets network " 1029 "traffic analyzer is activated\n"); 1030 break; 1031 case IPA_RC_HARDWARE_AUTH_ERROR: 1032 dev_warn(&card->gdev->dev, "The device is not " 1033 "authorized to run as a HiperSockets network " 1034 "traffic analyzer\n"); 1035 break; 1036 case IPA_RC_TRACE_ALREADY_ACTIVE: 1037 dev_warn(&card->gdev->dev, "A HiperSockets " 1038 "network traffic analyzer is already " 1039 "active in the HiperSockets LAN\n"); 1040 break; 1041 default: 1042 break; 1043 } 1044 break; 1045 default: 1046 QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n", 1047 cmd->data.diagass.action, CARD_DEVID(card)); 1048 } 1049 1050 return rc ? -EIO : 0; 1051 } 1052 1053 static int 1054 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd) 1055 { 1056 struct qeth_cmd_buffer *iob; 1057 struct qeth_ipa_cmd *cmd; 1058 1059 QETH_CARD_TEXT(card, 2, "diagtrac"); 1060 1061 iob = qeth_get_diag_cmd(card, QETH_DIAGS_CMD_TRACE, 0); 1062 if (!iob) 1063 return -ENOMEM; 1064 cmd = __ipa_cmd(iob); 1065 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET; 1066 cmd->data.diagass.action = diags_cmd; 1067 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL); 1068 } 1069 1070 static int qeth_l3_add_mcast_rtnl(struct net_device *dev, int vid, void *arg) 1071 { 1072 struct qeth_card *card = arg; 1073 struct inet6_dev *in6_dev; 1074 struct in_device *in4_dev; 1075 struct qeth_ipaddr *ipm; 1076 struct qeth_ipaddr tmp; 1077 struct ip_mc_list *im4; 1078 struct ifmcaddr6 *im6; 1079 1080 QETH_CARD_TEXT(card, 4, "addmc"); 1081 1082 if (!dev || !(dev->flags & IFF_UP)) 1083 goto out; 1084 1085 in4_dev = __in_dev_get_rtnl(dev); 1086 if (!in4_dev) 1087 goto walk_ipv6; 1088 1089 qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4); 1090 tmp.disp_flag = QETH_DISP_ADDR_ADD; 1091 tmp.is_multicast = 1; 1092 1093 for (im4 = rtnl_dereference(in4_dev->mc_list); im4 != NULL; 1094 im4 = rtnl_dereference(im4->next_rcu)) { 1095 tmp.u.a4.addr = im4->multiaddr; 1096 1097 ipm = qeth_l3_find_addr_by_ip(card, &tmp); 1098 if (ipm) { 1099 /* for mcast, by-IP match means full match */ 1100 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING; 1101 continue; 1102 } 1103 1104 ipm = kmemdup(&tmp, sizeof(tmp), GFP_KERNEL); 1105 if (!ipm) 1106 continue; 1107 1108 hash_add(card->ip_mc_htable, &ipm->hnode, 1109 qeth_l3_ipaddr_hash(ipm)); 1110 } 1111 1112 walk_ipv6: 1113 if (!qeth_is_supported(card, IPA_IPV6)) 1114 goto out; 1115 1116 in6_dev = __in6_dev_get(dev); 1117 if (!in6_dev) 1118 goto out; 1119 1120 qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6); 1121 tmp.disp_flag = QETH_DISP_ADDR_ADD; 1122 tmp.is_multicast = 1; 1123 1124 read_lock_bh(&in6_dev->lock); 1125 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) { 1126 tmp.u.a6.addr = im6->mca_addr; 1127 1128 ipm = qeth_l3_find_addr_by_ip(card, &tmp); 1129 if (ipm) { 1130 /* for mcast, by-IP match means full match */ 1131 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING; 1132 continue; 1133 } 1134 1135 ipm = kmemdup(&tmp, sizeof(tmp), GFP_ATOMIC); 1136 if (!ipm) 1137 continue; 1138 1139 hash_add(card->ip_mc_htable, 1140 &ipm->hnode, qeth_l3_ipaddr_hash(ipm)); 1141 1142 } 1143 read_unlock_bh(&in6_dev->lock); 1144 1145 out: 1146 return 0; 1147 } 1148 1149 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev, 1150 __be16 proto, u16 vid) 1151 { 1152 struct qeth_card *card = dev->ml_priv; 1153 1154 QETH_CARD_TEXT_(card, 4, "aid:%d", vid); 1155 return 0; 1156 } 1157 1158 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev, 1159 __be16 proto, u16 vid) 1160 { 1161 struct qeth_card *card = dev->ml_priv; 1162 1163 QETH_CARD_TEXT_(card, 4, "kid:%d", vid); 1164 return 0; 1165 } 1166 1167 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb, 1168 struct qeth_hdr *hdr) 1169 { 1170 struct af_iucv_trans_hdr *iucv = (struct af_iucv_trans_hdr *) skb->data; 1171 struct net_device *dev = skb->dev; 1172 1173 if (IS_IQD(card) && iucv->magic == ETH_P_AF_IUCV) { 1174 dev_hard_header(skb, dev, ETH_P_AF_IUCV, dev->dev_addr, 1175 "FAKELL", skb->len); 1176 return; 1177 } 1178 1179 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) { 1180 u16 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 : 1181 ETH_P_IP; 1182 unsigned char tg_addr[ETH_ALEN]; 1183 1184 skb_reset_network_header(skb); 1185 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) { 1186 case QETH_CAST_MULTICAST: 1187 if (prot == ETH_P_IP) 1188 ip_eth_mc_map(ip_hdr(skb)->daddr, tg_addr); 1189 else 1190 ipv6_eth_mc_map(&ipv6_hdr(skb)->daddr, tg_addr); 1191 QETH_CARD_STAT_INC(card, rx_multicast); 1192 break; 1193 case QETH_CAST_BROADCAST: 1194 ether_addr_copy(tg_addr, card->dev->broadcast); 1195 QETH_CARD_STAT_INC(card, rx_multicast); 1196 break; 1197 default: 1198 if (card->options.sniffer) 1199 skb->pkt_type = PACKET_OTHERHOST; 1200 ether_addr_copy(tg_addr, card->dev->dev_addr); 1201 } 1202 1203 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR) 1204 card->dev->header_ops->create(skb, card->dev, prot, 1205 tg_addr, &hdr->hdr.l3.next_hop.rx.src_mac, 1206 skb->len); 1207 else 1208 card->dev->header_ops->create(skb, card->dev, prot, 1209 tg_addr, "FAKELL", skb->len); 1210 } 1211 1212 /* copy VLAN tag from hdr into skb */ 1213 if (!card->options.sniffer && 1214 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME | 1215 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) { 1216 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ? 1217 hdr->hdr.l3.vlan_id : 1218 hdr->hdr.l3.next_hop.rx.vlan_id; 1219 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag); 1220 } 1221 1222 qeth_rx_csum(card, skb, hdr->hdr.l3.ext_flags); 1223 } 1224 1225 static int qeth_l3_process_inbound_buffer(struct qeth_card *card, 1226 int budget, int *done) 1227 { 1228 int work_done = 0; 1229 struct sk_buff *skb; 1230 struct qeth_hdr *hdr; 1231 1232 *done = 0; 1233 WARN_ON_ONCE(!budget); 1234 while (budget) { 1235 skb = qeth_core_get_next_skb(card, 1236 &card->qdio.in_q->bufs[card->rx.b_index], 1237 &card->rx.b_element, &card->rx.e_offset, &hdr); 1238 if (!skb) { 1239 *done = 1; 1240 break; 1241 } 1242 1243 if (hdr->hdr.l3.id == QETH_HEADER_TYPE_LAYER3) 1244 qeth_l3_rebuild_skb(card, skb, hdr); 1245 1246 skb->protocol = eth_type_trans(skb, skb->dev); 1247 QETH_CARD_STAT_INC(card, rx_packets); 1248 QETH_CARD_STAT_ADD(card, rx_bytes, skb->len); 1249 1250 napi_gro_receive(&card->napi, skb); 1251 work_done++; 1252 budget--; 1253 } 1254 return work_done; 1255 } 1256 1257 static void qeth_l3_stop_card(struct qeth_card *card) 1258 { 1259 QETH_CARD_TEXT(card, 2, "stopcard"); 1260 1261 qeth_set_allowed_threads(card, 0, 1); 1262 1263 cancel_work_sync(&card->rx_mode_work); 1264 qeth_l3_drain_rx_mode_cache(card); 1265 1266 if (card->options.sniffer && 1267 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) 1268 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE); 1269 1270 if (card->state == CARD_STATE_SOFTSETUP) { 1271 qeth_l3_clear_ip_htable(card, 1); 1272 qeth_clear_ipacmd_list(card); 1273 card->state = CARD_STATE_HARDSETUP; 1274 } 1275 if (card->state == CARD_STATE_HARDSETUP) { 1276 qeth_qdio_clear_card(card, 0); 1277 qeth_drain_output_queues(card); 1278 qeth_clear_working_pool_list(card); 1279 card->state = CARD_STATE_DOWN; 1280 } 1281 1282 flush_workqueue(card->event_wq); 1283 } 1284 1285 static void qeth_l3_set_promisc_mode(struct qeth_card *card) 1286 { 1287 bool enable = card->dev->flags & IFF_PROMISC; 1288 1289 if (card->info.promisc_mode == enable) 1290 return; 1291 1292 if (IS_VM_NIC(card)) { /* Guestlan trace */ 1293 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) 1294 qeth_setadp_promisc_mode(card, enable); 1295 } else if (card->options.sniffer && /* HiperSockets trace */ 1296 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) { 1297 if (enable) { 1298 QETH_CARD_TEXT(card, 3, "+promisc"); 1299 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE); 1300 } else { 1301 QETH_CARD_TEXT(card, 3, "-promisc"); 1302 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE); 1303 } 1304 } 1305 } 1306 1307 static void qeth_l3_rx_mode_work(struct work_struct *work) 1308 { 1309 struct qeth_card *card = container_of(work, struct qeth_card, 1310 rx_mode_work); 1311 struct qeth_ipaddr *addr; 1312 struct hlist_node *tmp; 1313 int i, rc; 1314 1315 QETH_CARD_TEXT(card, 3, "setmulti"); 1316 1317 if (!card->options.sniffer) { 1318 rtnl_lock(); 1319 qeth_l3_add_mcast_rtnl(card->dev, 0, card); 1320 if (qeth_is_supported(card, IPA_FULL_VLAN)) 1321 vlan_for_each(card->dev, qeth_l3_add_mcast_rtnl, card); 1322 rtnl_unlock(); 1323 1324 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) { 1325 switch (addr->disp_flag) { 1326 case QETH_DISP_ADDR_DELETE: 1327 rc = qeth_l3_deregister_addr_entry(card, addr); 1328 if (!rc || rc == -ENOENT) { 1329 hash_del(&addr->hnode); 1330 kfree(addr); 1331 } 1332 break; 1333 case QETH_DISP_ADDR_ADD: 1334 rc = qeth_l3_register_addr_entry(card, addr); 1335 if (rc && rc != -ENETDOWN) { 1336 hash_del(&addr->hnode); 1337 kfree(addr); 1338 break; 1339 } 1340 addr->ref_counter = 1; 1341 /* fall through */ 1342 default: 1343 /* for next call to set_rx_mode(): */ 1344 addr->disp_flag = QETH_DISP_ADDR_DELETE; 1345 } 1346 } 1347 } 1348 1349 qeth_l3_set_promisc_mode(card); 1350 } 1351 1352 static int qeth_l3_arp_makerc(u16 rc) 1353 { 1354 switch (rc) { 1355 case IPA_RC_SUCCESS: 1356 return 0; 1357 case QETH_IPA_ARP_RC_NOTSUPP: 1358 case QETH_IPA_ARP_RC_Q_NOTSUPP: 1359 return -EOPNOTSUPP; 1360 case QETH_IPA_ARP_RC_OUT_OF_RANGE: 1361 return -EINVAL; 1362 case QETH_IPA_ARP_RC_Q_NO_DATA: 1363 return -ENOENT; 1364 default: 1365 return -EIO; 1366 } 1367 } 1368 1369 static int qeth_l3_arp_cmd_cb(struct qeth_card *card, struct qeth_reply *reply, 1370 unsigned long data) 1371 { 1372 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1373 1374 qeth_setassparms_cb(card, reply, data); 1375 return qeth_l3_arp_makerc(cmd->hdr.return_code); 1376 } 1377 1378 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries) 1379 { 1380 struct qeth_cmd_buffer *iob; 1381 int rc; 1382 1383 QETH_CARD_TEXT(card, 3, "arpstnoe"); 1384 1385 /* 1386 * currently GuestLAN only supports the ARP assist function 1387 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES; 1388 * thus we say EOPNOTSUPP for this ARP function 1389 */ 1390 if (IS_VM_NIC(card)) 1391 return -EOPNOTSUPP; 1392 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 1393 return -EOPNOTSUPP; 1394 } 1395 1396 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 1397 IPA_CMD_ASS_ARP_SET_NO_ENTRIES, 1398 SETASS_DATA_SIZEOF(flags_32bit), 1399 QETH_PROT_IPV4); 1400 if (!iob) 1401 return -ENOMEM; 1402 1403 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (u32) no_entries; 1404 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL); 1405 if (rc) 1406 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n", 1407 CARD_DEVID(card), rc); 1408 return rc; 1409 } 1410 1411 static __u32 get_arp_entry_size(struct qeth_card *card, 1412 struct qeth_arp_query_data *qdata, 1413 struct qeth_arp_entrytype *type, __u8 strip_entries) 1414 { 1415 __u32 rc; 1416 __u8 is_hsi; 1417 1418 is_hsi = qdata->reply_bits == 5; 1419 if (type->ip == QETHARP_IP_ADDR_V4) { 1420 QETH_CARD_TEXT(card, 4, "arpev4"); 1421 if (strip_entries) { 1422 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) : 1423 sizeof(struct qeth_arp_qi_entry7_short); 1424 } else { 1425 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) : 1426 sizeof(struct qeth_arp_qi_entry7); 1427 } 1428 } else if (type->ip == QETHARP_IP_ADDR_V6) { 1429 QETH_CARD_TEXT(card, 4, "arpev6"); 1430 if (strip_entries) { 1431 rc = is_hsi ? 1432 sizeof(struct qeth_arp_qi_entry5_short_ipv6) : 1433 sizeof(struct qeth_arp_qi_entry7_short_ipv6); 1434 } else { 1435 rc = is_hsi ? 1436 sizeof(struct qeth_arp_qi_entry5_ipv6) : 1437 sizeof(struct qeth_arp_qi_entry7_ipv6); 1438 } 1439 } else { 1440 QETH_CARD_TEXT(card, 4, "arpinv"); 1441 rc = 0; 1442 } 1443 1444 return rc; 1445 } 1446 1447 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot) 1448 { 1449 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) || 1450 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6); 1451 } 1452 1453 static int qeth_l3_arp_query_cb(struct qeth_card *card, 1454 struct qeth_reply *reply, unsigned long data) 1455 { 1456 struct qeth_ipa_cmd *cmd; 1457 struct qeth_arp_query_data *qdata; 1458 struct qeth_arp_query_info *qinfo; 1459 int e; 1460 int entrybytes_done; 1461 int stripped_bytes; 1462 __u8 do_strip_entries; 1463 1464 QETH_CARD_TEXT(card, 3, "arpquecb"); 1465 1466 qinfo = (struct qeth_arp_query_info *) reply->param; 1467 cmd = (struct qeth_ipa_cmd *) data; 1468 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version); 1469 if (cmd->hdr.return_code) { 1470 QETH_CARD_TEXT(card, 4, "arpcberr"); 1471 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code); 1472 return qeth_l3_arp_makerc(cmd->hdr.return_code); 1473 } 1474 if (cmd->data.setassparms.hdr.return_code) { 1475 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code; 1476 QETH_CARD_TEXT(card, 4, "setaperr"); 1477 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code); 1478 return qeth_l3_arp_makerc(cmd->hdr.return_code); 1479 } 1480 qdata = &cmd->data.setassparms.data.query_arp; 1481 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries); 1482 1483 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0; 1484 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0; 1485 entrybytes_done = 0; 1486 for (e = 0; e < qdata->no_entries; ++e) { 1487 char *cur_entry; 1488 __u32 esize; 1489 struct qeth_arp_entrytype *etype; 1490 1491 cur_entry = &qdata->data + entrybytes_done; 1492 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type; 1493 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) { 1494 QETH_CARD_TEXT(card, 4, "pmis"); 1495 QETH_CARD_TEXT_(card, 4, "%i", etype->ip); 1496 break; 1497 } 1498 esize = get_arp_entry_size(card, qdata, etype, 1499 do_strip_entries); 1500 QETH_CARD_TEXT_(card, 5, "esz%i", esize); 1501 if (!esize) 1502 break; 1503 1504 if ((qinfo->udata_len - qinfo->udata_offset) < esize) { 1505 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOSPC); 1506 memset(qinfo->udata, 0, 4); 1507 return -ENOSPC; 1508 } 1509 1510 memcpy(qinfo->udata + qinfo->udata_offset, 1511 &qdata->data + entrybytes_done + stripped_bytes, 1512 esize); 1513 entrybytes_done += esize + stripped_bytes; 1514 qinfo->udata_offset += esize; 1515 ++qinfo->no_entries; 1516 } 1517 /* check if all replies received ... */ 1518 if (cmd->data.setassparms.hdr.seq_no < 1519 cmd->data.setassparms.hdr.number_of_replies) 1520 return 1; 1521 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries); 1522 memcpy(qinfo->udata, &qinfo->no_entries, 4); 1523 /* keep STRIP_ENTRIES flag so the user program can distinguish 1524 * stripped entries from normal ones */ 1525 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) 1526 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES; 1527 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2); 1528 QETH_CARD_TEXT_(card, 4, "rc%i", 0); 1529 return 0; 1530 } 1531 1532 static int qeth_l3_query_arp_cache_info(struct qeth_card *card, 1533 enum qeth_prot_versions prot, 1534 struct qeth_arp_query_info *qinfo) 1535 { 1536 struct qeth_cmd_buffer *iob; 1537 struct qeth_ipa_cmd *cmd; 1538 int rc; 1539 1540 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot); 1541 1542 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 1543 IPA_CMD_ASS_ARP_QUERY_INFO, 1544 SETASS_DATA_SIZEOF(query_arp), prot); 1545 if (!iob) 1546 return -ENOMEM; 1547 cmd = __ipa_cmd(iob); 1548 cmd->data.setassparms.data.query_arp.request_bits = 0x000F; 1549 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_query_cb, qinfo); 1550 if (rc) 1551 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n", 1552 CARD_DEVID(card), rc); 1553 return rc; 1554 } 1555 1556 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata) 1557 { 1558 struct qeth_arp_query_info qinfo = {0, }; 1559 int rc; 1560 1561 QETH_CARD_TEXT(card, 3, "arpquery"); 1562 1563 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/ 1564 IPA_ARP_PROCESSING)) { 1565 QETH_CARD_TEXT(card, 3, "arpqnsup"); 1566 rc = -EOPNOTSUPP; 1567 goto out; 1568 } 1569 /* get size of userspace buffer and mask_bits -> 6 bytes */ 1570 if (copy_from_user(&qinfo, udata, 6)) { 1571 rc = -EFAULT; 1572 goto out; 1573 } 1574 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL); 1575 if (!qinfo.udata) { 1576 rc = -ENOMEM; 1577 goto out; 1578 } 1579 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET; 1580 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo); 1581 if (rc) { 1582 if (copy_to_user(udata, qinfo.udata, 4)) 1583 rc = -EFAULT; 1584 goto free_and_out; 1585 } 1586 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) { 1587 /* fails in case of GuestLAN QDIO mode */ 1588 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo); 1589 } 1590 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) { 1591 QETH_CARD_TEXT(card, 4, "qactf"); 1592 rc = -EFAULT; 1593 goto free_and_out; 1594 } 1595 QETH_CARD_TEXT(card, 4, "qacts"); 1596 1597 free_and_out: 1598 kfree(qinfo.udata); 1599 out: 1600 return rc; 1601 } 1602 1603 static int qeth_l3_arp_modify_entry(struct qeth_card *card, 1604 struct qeth_arp_cache_entry *entry, 1605 enum qeth_arp_process_subcmds arp_cmd) 1606 { 1607 struct qeth_arp_cache_entry *cmd_entry; 1608 struct qeth_cmd_buffer *iob; 1609 int rc; 1610 1611 if (arp_cmd == IPA_CMD_ASS_ARP_ADD_ENTRY) 1612 QETH_CARD_TEXT(card, 3, "arpadd"); 1613 else 1614 QETH_CARD_TEXT(card, 3, "arpdel"); 1615 1616 /* 1617 * currently GuestLAN only supports the ARP assist function 1618 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY; 1619 * thus we say EOPNOTSUPP for this ARP function 1620 */ 1621 if (IS_VM_NIC(card)) 1622 return -EOPNOTSUPP; 1623 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 1624 return -EOPNOTSUPP; 1625 } 1626 1627 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, arp_cmd, 1628 SETASS_DATA_SIZEOF(arp_entry), 1629 QETH_PROT_IPV4); 1630 if (!iob) 1631 return -ENOMEM; 1632 1633 cmd_entry = &__ipa_cmd(iob)->data.setassparms.data.arp_entry; 1634 ether_addr_copy(cmd_entry->macaddr, entry->macaddr); 1635 memcpy(cmd_entry->ipaddr, entry->ipaddr, 4); 1636 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL); 1637 if (rc) 1638 QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n", 1639 arp_cmd, CARD_DEVID(card), rc); 1640 return rc; 1641 } 1642 1643 static int qeth_l3_arp_flush_cache(struct qeth_card *card) 1644 { 1645 struct qeth_cmd_buffer *iob; 1646 int rc; 1647 1648 QETH_CARD_TEXT(card, 3, "arpflush"); 1649 1650 /* 1651 * currently GuestLAN only supports the ARP assist function 1652 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE; 1653 * thus we say EOPNOTSUPP for this ARP function 1654 */ 1655 if (IS_VM_NIC(card) || IS_IQD(card)) 1656 return -EOPNOTSUPP; 1657 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 1658 return -EOPNOTSUPP; 1659 } 1660 1661 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 1662 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0, 1663 QETH_PROT_IPV4); 1664 if (!iob) 1665 return -ENOMEM; 1666 1667 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL); 1668 if (rc) 1669 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n", 1670 CARD_DEVID(card), rc); 1671 return rc; 1672 } 1673 1674 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1675 { 1676 struct qeth_card *card = dev->ml_priv; 1677 struct qeth_arp_cache_entry arp_entry; 1678 enum qeth_arp_process_subcmds arp_cmd; 1679 int rc = 0; 1680 1681 switch (cmd) { 1682 case SIOC_QETH_ARP_SET_NO_ENTRIES: 1683 if (!capable(CAP_NET_ADMIN)) { 1684 rc = -EPERM; 1685 break; 1686 } 1687 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue); 1688 break; 1689 case SIOC_QETH_ARP_QUERY_INFO: 1690 if (!capable(CAP_NET_ADMIN)) { 1691 rc = -EPERM; 1692 break; 1693 } 1694 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data); 1695 break; 1696 case SIOC_QETH_ARP_ADD_ENTRY: 1697 case SIOC_QETH_ARP_REMOVE_ENTRY: 1698 if (!capable(CAP_NET_ADMIN)) 1699 return -EPERM; 1700 if (copy_from_user(&arp_entry, rq->ifr_data, sizeof(arp_entry))) 1701 return -EFAULT; 1702 1703 arp_cmd = (cmd == SIOC_QETH_ARP_ADD_ENTRY) ? 1704 IPA_CMD_ASS_ARP_ADD_ENTRY : 1705 IPA_CMD_ASS_ARP_REMOVE_ENTRY; 1706 return qeth_l3_arp_modify_entry(card, &arp_entry, arp_cmd); 1707 case SIOC_QETH_ARP_FLUSH_CACHE: 1708 if (!capable(CAP_NET_ADMIN)) { 1709 rc = -EPERM; 1710 break; 1711 } 1712 rc = qeth_l3_arp_flush_cache(card); 1713 break; 1714 default: 1715 rc = -EOPNOTSUPP; 1716 } 1717 return rc; 1718 } 1719 1720 static int qeth_l3_get_cast_type_rcu(struct sk_buff *skb, struct dst_entry *dst, 1721 int ipv) 1722 { 1723 struct neighbour *n = NULL; 1724 1725 if (dst) 1726 n = dst_neigh_lookup_skb(dst, skb); 1727 1728 if (n) { 1729 int cast_type = n->type; 1730 1731 neigh_release(n); 1732 if ((cast_type == RTN_BROADCAST) || 1733 (cast_type == RTN_MULTICAST) || 1734 (cast_type == RTN_ANYCAST)) 1735 return cast_type; 1736 return RTN_UNICAST; 1737 } 1738 1739 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */ 1740 switch (ipv) { 1741 case 4: 1742 if (ipv4_is_lbcast(ip_hdr(skb)->daddr)) 1743 return RTN_BROADCAST; 1744 return ipv4_is_multicast(ip_hdr(skb)->daddr) ? 1745 RTN_MULTICAST : RTN_UNICAST; 1746 case 6: 1747 return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ? 1748 RTN_MULTICAST : RTN_UNICAST; 1749 default: 1750 /* ... and MAC address */ 1751 return qeth_get_ether_cast_type(skb); 1752 } 1753 } 1754 1755 static int qeth_l3_get_cast_type(struct sk_buff *skb) 1756 { 1757 int ipv = qeth_get_ip_version(skb); 1758 struct dst_entry *dst; 1759 int cast_type; 1760 1761 rcu_read_lock(); 1762 dst = qeth_dst_check_rcu(skb, ipv); 1763 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, ipv); 1764 rcu_read_unlock(); 1765 1766 return cast_type; 1767 } 1768 1769 static u8 qeth_l3_cast_type_to_flag(int cast_type) 1770 { 1771 if (cast_type == RTN_MULTICAST) 1772 return QETH_CAST_MULTICAST; 1773 if (cast_type == RTN_ANYCAST) 1774 return QETH_CAST_ANYCAST; 1775 if (cast_type == RTN_BROADCAST) 1776 return QETH_CAST_BROADCAST; 1777 return QETH_CAST_UNICAST; 1778 } 1779 1780 static void qeth_l3_fill_header(struct qeth_qdio_out_q *queue, 1781 struct qeth_hdr *hdr, struct sk_buff *skb, 1782 int ipv, unsigned int data_len) 1783 { 1784 struct qeth_hdr_layer3 *l3_hdr = &hdr->hdr.l3; 1785 struct vlan_ethhdr *veth = vlan_eth_hdr(skb); 1786 struct qeth_card *card = queue->card; 1787 struct dst_entry *dst; 1788 int cast_type; 1789 1790 hdr->hdr.l3.length = data_len; 1791 1792 if (skb_is_gso(skb)) { 1793 hdr->hdr.l3.id = QETH_HEADER_TYPE_L3_TSO; 1794 } else { 1795 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3; 1796 1797 if (skb->protocol == htons(ETH_P_AF_IUCV)) { 1798 l3_hdr->flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST; 1799 l3_hdr->next_hop.ipv6_addr.s6_addr16[0] = htons(0xfe80); 1800 memcpy(&l3_hdr->next_hop.ipv6_addr.s6_addr32[2], 1801 iucv_trans_hdr(skb)->destUserID, 8); 1802 return; 1803 } 1804 1805 if (skb->ip_summed == CHECKSUM_PARTIAL) { 1806 qeth_tx_csum(skb, &hdr->hdr.l3.ext_flags, ipv); 1807 /* some HW requires combined L3+L4 csum offload: */ 1808 if (ipv == 4) 1809 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_HDR_REQ; 1810 } 1811 } 1812 1813 if (ipv == 4 || IS_IQD(card)) { 1814 /* NETIF_F_HW_VLAN_CTAG_TX */ 1815 if (skb_vlan_tag_present(skb)) { 1816 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_VLAN_FRAME; 1817 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb); 1818 } 1819 } else if (veth->h_vlan_proto == htons(ETH_P_8021Q)) { 1820 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_INCLUDE_VLAN_TAG; 1821 hdr->hdr.l3.vlan_id = ntohs(veth->h_vlan_TCI); 1822 } 1823 1824 rcu_read_lock(); 1825 dst = qeth_dst_check_rcu(skb, ipv); 1826 1827 if (IS_IQD(card) && skb_get_queue_mapping(skb) != QETH_IQD_MCAST_TXQ) 1828 cast_type = RTN_UNICAST; 1829 else 1830 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, ipv); 1831 l3_hdr->flags |= qeth_l3_cast_type_to_flag(cast_type); 1832 1833 if (ipv == 4) { 1834 struct rtable *rt = (struct rtable *) dst; 1835 1836 *((__be32 *) &hdr->hdr.l3.next_hop.ipv4.addr) = (rt) ? 1837 rt_nexthop(rt, ip_hdr(skb)->daddr) : 1838 ip_hdr(skb)->daddr; 1839 } else if (ipv == 6) { 1840 struct rt6_info *rt = (struct rt6_info *) dst; 1841 1842 if (rt && !ipv6_addr_any(&rt->rt6i_gateway)) 1843 l3_hdr->next_hop.ipv6_addr = rt->rt6i_gateway; 1844 else 1845 l3_hdr->next_hop.ipv6_addr = ipv6_hdr(skb)->daddr; 1846 1847 hdr->hdr.l3.flags |= QETH_HDR_IPV6; 1848 if (!IS_IQD(card)) 1849 hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU; 1850 } else { 1851 /* OSA only: */ 1852 l3_hdr->flags |= QETH_HDR_PASSTHRU; 1853 } 1854 rcu_read_unlock(); 1855 } 1856 1857 static void qeth_l3_fixup_headers(struct sk_buff *skb) 1858 { 1859 struct iphdr *iph = ip_hdr(skb); 1860 1861 /* this is safe, IPv6 traffic takes a different path */ 1862 if (skb->ip_summed == CHECKSUM_PARTIAL) 1863 iph->check = 0; 1864 if (skb_is_gso(skb)) { 1865 iph->tot_len = 0; 1866 tcp_hdr(skb)->check = ~tcp_v4_check(0, iph->saddr, 1867 iph->daddr, 0); 1868 } 1869 } 1870 1871 static int qeth_l3_xmit(struct qeth_card *card, struct sk_buff *skb, 1872 struct qeth_qdio_out_q *queue, int ipv) 1873 { 1874 unsigned int hw_hdr_len; 1875 int rc; 1876 1877 /* re-use the L2 header area for the HW header: */ 1878 hw_hdr_len = skb_is_gso(skb) ? sizeof(struct qeth_hdr_tso) : 1879 sizeof(struct qeth_hdr); 1880 rc = skb_cow_head(skb, hw_hdr_len - ETH_HLEN); 1881 if (rc) 1882 return rc; 1883 skb_pull(skb, ETH_HLEN); 1884 1885 qeth_l3_fixup_headers(skb); 1886 return qeth_xmit(card, skb, queue, ipv, qeth_l3_fill_header); 1887 } 1888 1889 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb, 1890 struct net_device *dev) 1891 { 1892 struct qeth_card *card = dev->ml_priv; 1893 u16 txq = skb_get_queue_mapping(skb); 1894 int ipv = qeth_get_ip_version(skb); 1895 struct qeth_qdio_out_q *queue; 1896 int rc; 1897 1898 if (!skb_is_gso(skb)) 1899 qdisc_skb_cb(skb)->pkt_len = skb->len; 1900 if (IS_IQD(card)) { 1901 queue = card->qdio.out_qs[qeth_iqd_translate_txq(dev, txq)]; 1902 1903 if (card->options.sniffer) 1904 goto tx_drop; 1905 if ((card->options.cq != QETH_CQ_ENABLED && !ipv) || 1906 (card->options.cq == QETH_CQ_ENABLED && 1907 skb->protocol != htons(ETH_P_AF_IUCV))) 1908 goto tx_drop; 1909 } else { 1910 queue = card->qdio.out_qs[txq]; 1911 } 1912 1913 if (!(dev->flags & IFF_BROADCAST) && 1914 qeth_l3_get_cast_type(skb) == RTN_BROADCAST) 1915 goto tx_drop; 1916 1917 if (ipv == 4 || IS_IQD(card)) 1918 rc = qeth_l3_xmit(card, skb, queue, ipv); 1919 else 1920 rc = qeth_xmit(card, skb, queue, ipv, qeth_l3_fill_header); 1921 1922 if (!rc) 1923 return NETDEV_TX_OK; 1924 1925 tx_drop: 1926 QETH_TXQ_STAT_INC(queue, tx_dropped); 1927 kfree_skb(skb); 1928 return NETDEV_TX_OK; 1929 } 1930 1931 static void qeth_l3_set_rx_mode(struct net_device *dev) 1932 { 1933 struct qeth_card *card = dev->ml_priv; 1934 1935 schedule_work(&card->rx_mode_work); 1936 } 1937 1938 /* 1939 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting 1940 * NOARP on the netdevice is no option because it also turns off neighbor 1941 * solicitation. For IPv4 we install a neighbor_setup function. We don't want 1942 * arp resolution but we want the hard header (packet socket will work 1943 * e.g. tcpdump) 1944 */ 1945 static int qeth_l3_neigh_setup_noarp(struct neighbour *n) 1946 { 1947 n->nud_state = NUD_NOARP; 1948 memcpy(n->ha, "FAKELL", 6); 1949 n->output = n->ops->connected_output; 1950 return 0; 1951 } 1952 1953 static int 1954 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np) 1955 { 1956 if (np->tbl->family == AF_INET) 1957 np->neigh_setup = qeth_l3_neigh_setup_noarp; 1958 1959 return 0; 1960 } 1961 1962 static netdev_features_t qeth_l3_osa_features_check(struct sk_buff *skb, 1963 struct net_device *dev, 1964 netdev_features_t features) 1965 { 1966 if (qeth_get_ip_version(skb) != 4) 1967 features &= ~NETIF_F_HW_VLAN_CTAG_TX; 1968 return qeth_features_check(skb, dev, features); 1969 } 1970 1971 static u16 qeth_l3_iqd_select_queue(struct net_device *dev, struct sk_buff *skb, 1972 struct net_device *sb_dev) 1973 { 1974 return qeth_iqd_select_queue(dev, skb, qeth_l3_get_cast_type(skb), 1975 sb_dev); 1976 } 1977 1978 static u16 qeth_l3_osa_select_queue(struct net_device *dev, struct sk_buff *skb, 1979 struct net_device *sb_dev) 1980 { 1981 struct qeth_card *card = dev->ml_priv; 1982 1983 return qeth_get_priority_queue(card, skb); 1984 } 1985 1986 static const struct net_device_ops qeth_l3_netdev_ops = { 1987 .ndo_open = qeth_open, 1988 .ndo_stop = qeth_stop, 1989 .ndo_get_stats64 = qeth_get_stats64, 1990 .ndo_start_xmit = qeth_l3_hard_start_xmit, 1991 .ndo_select_queue = qeth_l3_iqd_select_queue, 1992 .ndo_validate_addr = eth_validate_addr, 1993 .ndo_set_rx_mode = qeth_l3_set_rx_mode, 1994 .ndo_do_ioctl = qeth_do_ioctl, 1995 .ndo_fix_features = qeth_fix_features, 1996 .ndo_set_features = qeth_set_features, 1997 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid, 1998 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid, 1999 .ndo_tx_timeout = qeth_tx_timeout, 2000 }; 2001 2002 static const struct net_device_ops qeth_l3_osa_netdev_ops = { 2003 .ndo_open = qeth_open, 2004 .ndo_stop = qeth_stop, 2005 .ndo_get_stats64 = qeth_get_stats64, 2006 .ndo_start_xmit = qeth_l3_hard_start_xmit, 2007 .ndo_features_check = qeth_l3_osa_features_check, 2008 .ndo_select_queue = qeth_l3_osa_select_queue, 2009 .ndo_validate_addr = eth_validate_addr, 2010 .ndo_set_rx_mode = qeth_l3_set_rx_mode, 2011 .ndo_do_ioctl = qeth_do_ioctl, 2012 .ndo_fix_features = qeth_fix_features, 2013 .ndo_set_features = qeth_set_features, 2014 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid, 2015 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid, 2016 .ndo_tx_timeout = qeth_tx_timeout, 2017 .ndo_neigh_setup = qeth_l3_neigh_setup, 2018 }; 2019 2020 static int qeth_l3_setup_netdev(struct qeth_card *card, bool carrier_ok) 2021 { 2022 unsigned int headroom; 2023 int rc; 2024 2025 if (IS_OSD(card) || IS_OSX(card)) { 2026 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) || 2027 (card->info.link_type == QETH_LINK_TYPE_HSTR)) { 2028 pr_info("qeth_l3: ignoring TR device\n"); 2029 return -ENODEV; 2030 } 2031 2032 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops; 2033 2034 /*IPv6 address autoconfiguration stuff*/ 2035 qeth_l3_get_unique_id(card); 2036 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD)) 2037 card->dev->dev_id = card->info.unique_id & 0xffff; 2038 2039 if (!IS_VM_NIC(card)) { 2040 card->dev->features |= NETIF_F_SG; 2041 card->dev->hw_features |= NETIF_F_TSO | 2042 NETIF_F_RXCSUM | NETIF_F_IP_CSUM; 2043 card->dev->vlan_features |= NETIF_F_TSO | 2044 NETIF_F_RXCSUM | NETIF_F_IP_CSUM; 2045 } 2046 2047 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) { 2048 card->dev->hw_features |= NETIF_F_IPV6_CSUM; 2049 card->dev->vlan_features |= NETIF_F_IPV6_CSUM; 2050 } 2051 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) { 2052 card->dev->hw_features |= NETIF_F_TSO6; 2053 card->dev->vlan_features |= NETIF_F_TSO6; 2054 } 2055 2056 /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */ 2057 if (card->dev->hw_features & NETIF_F_TSO6) 2058 headroom = sizeof(struct qeth_hdr_tso) + VLAN_HLEN; 2059 else if (card->dev->hw_features & NETIF_F_TSO) 2060 headroom = sizeof(struct qeth_hdr_tso); 2061 else 2062 headroom = sizeof(struct qeth_hdr) + VLAN_HLEN; 2063 } else if (IS_IQD(card)) { 2064 card->dev->flags |= IFF_NOARP; 2065 card->dev->netdev_ops = &qeth_l3_netdev_ops; 2066 headroom = sizeof(struct qeth_hdr) - ETH_HLEN; 2067 2068 rc = qeth_l3_iqd_read_initial_mac(card); 2069 if (rc) 2070 goto out; 2071 } else 2072 return -ENODEV; 2073 2074 card->dev->needed_headroom = headroom; 2075 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX | 2076 NETIF_F_HW_VLAN_CTAG_RX | 2077 NETIF_F_HW_VLAN_CTAG_FILTER; 2078 2079 netif_keep_dst(card->dev); 2080 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) 2081 netif_set_gso_max_size(card->dev, 2082 PAGE_SIZE * (QETH_MAX_BUFFER_ELEMENTS(card) - 1)); 2083 2084 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT); 2085 rc = register_netdev(card->dev); 2086 if (!rc && carrier_ok) 2087 netif_carrier_on(card->dev); 2088 2089 out: 2090 if (rc) 2091 card->dev->netdev_ops = NULL; 2092 return rc; 2093 } 2094 2095 static const struct device_type qeth_l3_devtype = { 2096 .name = "qeth_layer3", 2097 .groups = qeth_l3_attr_groups, 2098 }; 2099 2100 static int qeth_l3_probe_device(struct ccwgroup_device *gdev) 2101 { 2102 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2103 int rc; 2104 2105 hash_init(card->ip_htable); 2106 mutex_init(&card->ip_lock); 2107 card->cmd_wq = alloc_ordered_workqueue("%s_cmd", 0, 2108 dev_name(&gdev->dev)); 2109 if (!card->cmd_wq) 2110 return -ENOMEM; 2111 2112 if (gdev->dev.type == &qeth_generic_devtype) { 2113 rc = qeth_l3_create_device_attributes(&gdev->dev); 2114 if (rc) { 2115 destroy_workqueue(card->cmd_wq); 2116 return rc; 2117 } 2118 } 2119 2120 hash_init(card->ip_mc_htable); 2121 INIT_WORK(&card->rx_mode_work, qeth_l3_rx_mode_work); 2122 return 0; 2123 } 2124 2125 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev) 2126 { 2127 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 2128 2129 if (cgdev->dev.type == &qeth_generic_devtype) 2130 qeth_l3_remove_device_attributes(&cgdev->dev); 2131 2132 qeth_set_allowed_threads(card, 0, 1); 2133 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 2134 2135 if (cgdev->state == CCWGROUP_ONLINE) 2136 qeth_l3_set_offline(cgdev); 2137 2138 cancel_work_sync(&card->close_dev_work); 2139 if (qeth_netdev_is_registered(card->dev)) 2140 unregister_netdev(card->dev); 2141 2142 flush_workqueue(card->cmd_wq); 2143 destroy_workqueue(card->cmd_wq); 2144 qeth_l3_clear_ip_htable(card, 0); 2145 qeth_l3_clear_ipato_list(card); 2146 } 2147 2148 static int qeth_l3_set_online(struct ccwgroup_device *gdev) 2149 { 2150 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2151 struct net_device *dev = card->dev; 2152 int rc = 0; 2153 bool carrier_ok; 2154 2155 mutex_lock(&card->discipline_mutex); 2156 mutex_lock(&card->conf_mutex); 2157 QETH_CARD_TEXT(card, 2, "setonlin"); 2158 2159 rc = qeth_core_hardsetup_card(card, &carrier_ok); 2160 if (rc) { 2161 QETH_CARD_TEXT_(card, 2, "2err%04x", rc); 2162 rc = -ENODEV; 2163 goto out_remove; 2164 } 2165 2166 card->state = CARD_STATE_HARDSETUP; 2167 qeth_print_status_message(card); 2168 2169 /* softsetup */ 2170 QETH_CARD_TEXT(card, 2, "softsetp"); 2171 2172 rc = qeth_l3_setadapter_parms(card); 2173 if (rc) 2174 QETH_CARD_TEXT_(card, 2, "2err%04x", rc); 2175 if (!card->options.sniffer) { 2176 rc = qeth_l3_start_ipassists(card); 2177 if (rc) { 2178 QETH_CARD_TEXT_(card, 2, "3err%d", rc); 2179 goto out_remove; 2180 } 2181 rc = qeth_l3_setrouting_v4(card); 2182 if (rc) 2183 QETH_CARD_TEXT_(card, 2, "4err%04x", rc); 2184 rc = qeth_l3_setrouting_v6(card); 2185 if (rc) 2186 QETH_CARD_TEXT_(card, 2, "5err%04x", rc); 2187 } 2188 2189 rc = qeth_init_qdio_queues(card); 2190 if (rc) { 2191 QETH_CARD_TEXT_(card, 2, "6err%d", rc); 2192 rc = -ENODEV; 2193 goto out_remove; 2194 } 2195 card->state = CARD_STATE_SOFTSETUP; 2196 2197 qeth_set_allowed_threads(card, 0xffffffff, 0); 2198 qeth_l3_recover_ip(card); 2199 2200 if (!qeth_netdev_is_registered(dev)) { 2201 rc = qeth_l3_setup_netdev(card, carrier_ok); 2202 if (rc) 2203 goto out_remove; 2204 } else { 2205 rtnl_lock(); 2206 if (carrier_ok) 2207 netif_carrier_on(dev); 2208 else 2209 netif_carrier_off(dev); 2210 2211 netif_device_attach(dev); 2212 qeth_enable_hw_features(dev); 2213 2214 if (card->info.open_when_online) { 2215 card->info.open_when_online = 0; 2216 dev_open(dev, NULL); 2217 } 2218 rtnl_unlock(); 2219 } 2220 qeth_trace_features(card); 2221 /* let user_space know that device is online */ 2222 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE); 2223 mutex_unlock(&card->conf_mutex); 2224 mutex_unlock(&card->discipline_mutex); 2225 return 0; 2226 out_remove: 2227 qeth_l3_stop_card(card); 2228 qeth_stop_channel(&card->data); 2229 qeth_stop_channel(&card->write); 2230 qeth_stop_channel(&card->read); 2231 qdio_free(CARD_DDEV(card)); 2232 2233 mutex_unlock(&card->conf_mutex); 2234 mutex_unlock(&card->discipline_mutex); 2235 return rc; 2236 } 2237 2238 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev, 2239 int recovery_mode) 2240 { 2241 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 2242 int rc = 0, rc2 = 0, rc3 = 0; 2243 2244 mutex_lock(&card->discipline_mutex); 2245 mutex_lock(&card->conf_mutex); 2246 QETH_CARD_TEXT(card, 3, "setoffl"); 2247 2248 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) { 2249 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 2250 card->info.hwtrap = 1; 2251 } 2252 2253 rtnl_lock(); 2254 card->info.open_when_online = card->dev->flags & IFF_UP; 2255 dev_close(card->dev); 2256 netif_device_detach(card->dev); 2257 netif_carrier_off(card->dev); 2258 rtnl_unlock(); 2259 2260 qeth_l3_stop_card(card); 2261 rc = qeth_stop_channel(&card->data); 2262 rc2 = qeth_stop_channel(&card->write); 2263 rc3 = qeth_stop_channel(&card->read); 2264 if (!rc) 2265 rc = (rc2) ? rc2 : rc3; 2266 if (rc) 2267 QETH_CARD_TEXT_(card, 2, "1err%d", rc); 2268 qdio_free(CARD_DDEV(card)); 2269 2270 /* let user_space know that device is offline */ 2271 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE); 2272 mutex_unlock(&card->conf_mutex); 2273 mutex_unlock(&card->discipline_mutex); 2274 return 0; 2275 } 2276 2277 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev) 2278 { 2279 return __qeth_l3_set_offline(cgdev, 0); 2280 } 2281 2282 static int qeth_l3_recover(void *ptr) 2283 { 2284 struct qeth_card *card; 2285 int rc = 0; 2286 2287 card = (struct qeth_card *) ptr; 2288 QETH_CARD_TEXT(card, 2, "recover1"); 2289 QETH_CARD_HEX(card, 2, &card, sizeof(void *)); 2290 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD)) 2291 return 0; 2292 QETH_CARD_TEXT(card, 2, "recover2"); 2293 dev_warn(&card->gdev->dev, 2294 "A recovery process has been started for the device\n"); 2295 __qeth_l3_set_offline(card->gdev, 1); 2296 rc = qeth_l3_set_online(card->gdev); 2297 if (!rc) 2298 dev_info(&card->gdev->dev, 2299 "Device successfully recovered!\n"); 2300 else { 2301 ccwgroup_set_offline(card->gdev); 2302 dev_warn(&card->gdev->dev, "The qeth device driver " 2303 "failed to recover an error on the device\n"); 2304 } 2305 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD); 2306 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD); 2307 return 0; 2308 } 2309 2310 /* Returns zero if the command is successfully "consumed" */ 2311 static int qeth_l3_control_event(struct qeth_card *card, 2312 struct qeth_ipa_cmd *cmd) 2313 { 2314 return 1; 2315 } 2316 2317 struct qeth_discipline qeth_l3_discipline = { 2318 .devtype = &qeth_l3_devtype, 2319 .process_rx_buffer = qeth_l3_process_inbound_buffer, 2320 .recover = qeth_l3_recover, 2321 .setup = qeth_l3_probe_device, 2322 .remove = qeth_l3_remove_device, 2323 .set_online = qeth_l3_set_online, 2324 .set_offline = qeth_l3_set_offline, 2325 .do_ioctl = qeth_l3_do_ioctl, 2326 .control_event_handler = qeth_l3_control_event, 2327 }; 2328 EXPORT_SYMBOL_GPL(qeth_l3_discipline); 2329 2330 static int qeth_l3_handle_ip_event(struct qeth_card *card, 2331 struct qeth_ipaddr *addr, 2332 unsigned long event) 2333 { 2334 switch (event) { 2335 case NETDEV_UP: 2336 qeth_l3_modify_ip(card, addr, true); 2337 return NOTIFY_OK; 2338 case NETDEV_DOWN: 2339 qeth_l3_modify_ip(card, addr, false); 2340 return NOTIFY_OK; 2341 default: 2342 return NOTIFY_DONE; 2343 } 2344 } 2345 2346 struct qeth_l3_ip_event_work { 2347 struct work_struct work; 2348 struct qeth_card *card; 2349 struct qeth_ipaddr addr; 2350 }; 2351 2352 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work) 2353 2354 static void qeth_l3_add_ip_worker(struct work_struct *work) 2355 { 2356 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work); 2357 2358 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, true); 2359 kfree(work); 2360 } 2361 2362 static void qeth_l3_delete_ip_worker(struct work_struct *work) 2363 { 2364 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work); 2365 2366 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, false); 2367 kfree(work); 2368 } 2369 2370 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev) 2371 { 2372 if (is_vlan_dev(dev)) 2373 dev = vlan_dev_real_dev(dev); 2374 if (dev->netdev_ops == &qeth_l3_osa_netdev_ops || 2375 dev->netdev_ops == &qeth_l3_netdev_ops) 2376 return (struct qeth_card *) dev->ml_priv; 2377 return NULL; 2378 } 2379 2380 static int qeth_l3_ip_event(struct notifier_block *this, 2381 unsigned long event, void *ptr) 2382 { 2383 2384 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 2385 struct net_device *dev = ifa->ifa_dev->dev; 2386 struct qeth_ipaddr addr; 2387 struct qeth_card *card; 2388 2389 if (dev_net(dev) != &init_net) 2390 return NOTIFY_DONE; 2391 2392 card = qeth_l3_get_card_from_dev(dev); 2393 if (!card) 2394 return NOTIFY_DONE; 2395 QETH_CARD_TEXT(card, 3, "ipevent"); 2396 2397 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4); 2398 addr.u.a4.addr = ifa->ifa_address; 2399 addr.u.a4.mask = ifa->ifa_mask; 2400 2401 return qeth_l3_handle_ip_event(card, &addr, event); 2402 } 2403 2404 static struct notifier_block qeth_l3_ip_notifier = { 2405 qeth_l3_ip_event, 2406 NULL, 2407 }; 2408 2409 static int qeth_l3_ip6_event(struct notifier_block *this, 2410 unsigned long event, void *ptr) 2411 { 2412 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 2413 struct net_device *dev = ifa->idev->dev; 2414 struct qeth_l3_ip_event_work *ip_work; 2415 struct qeth_card *card; 2416 2417 if (event != NETDEV_UP && event != NETDEV_DOWN) 2418 return NOTIFY_DONE; 2419 2420 card = qeth_l3_get_card_from_dev(dev); 2421 if (!card) 2422 return NOTIFY_DONE; 2423 QETH_CARD_TEXT(card, 3, "ip6event"); 2424 if (!qeth_is_supported(card, IPA_IPV6)) 2425 return NOTIFY_DONE; 2426 2427 ip_work = kmalloc(sizeof(*ip_work), GFP_ATOMIC); 2428 if (!ip_work) 2429 return NOTIFY_DONE; 2430 2431 if (event == NETDEV_UP) 2432 INIT_WORK(&ip_work->work, qeth_l3_add_ip_worker); 2433 else 2434 INIT_WORK(&ip_work->work, qeth_l3_delete_ip_worker); 2435 2436 ip_work->card = card; 2437 qeth_l3_init_ipaddr(&ip_work->addr, QETH_IP_TYPE_NORMAL, 2438 QETH_PROT_IPV6); 2439 ip_work->addr.u.a6.addr = ifa->addr; 2440 ip_work->addr.u.a6.pfxlen = ifa->prefix_len; 2441 2442 queue_work(card->cmd_wq, &ip_work->work); 2443 return NOTIFY_OK; 2444 } 2445 2446 static struct notifier_block qeth_l3_ip6_notifier = { 2447 qeth_l3_ip6_event, 2448 NULL, 2449 }; 2450 2451 static int qeth_l3_register_notifiers(void) 2452 { 2453 int rc; 2454 2455 QETH_DBF_TEXT(SETUP, 5, "regnotif"); 2456 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier); 2457 if (rc) 2458 return rc; 2459 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier); 2460 if (rc) { 2461 unregister_inetaddr_notifier(&qeth_l3_ip_notifier); 2462 return rc; 2463 } 2464 return 0; 2465 } 2466 2467 static void qeth_l3_unregister_notifiers(void) 2468 { 2469 QETH_DBF_TEXT(SETUP, 5, "unregnot"); 2470 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier)); 2471 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier)); 2472 } 2473 2474 static int __init qeth_l3_init(void) 2475 { 2476 pr_info("register layer 3 discipline\n"); 2477 return qeth_l3_register_notifiers(); 2478 } 2479 2480 static void __exit qeth_l3_exit(void) 2481 { 2482 qeth_l3_unregister_notifiers(); 2483 pr_info("unregister layer 3 discipline\n"); 2484 } 2485 2486 module_init(qeth_l3_init); 2487 module_exit(qeth_l3_exit); 2488 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 2489 MODULE_DESCRIPTION("qeth layer 3 discipline"); 2490 MODULE_LICENSE("GPL"); 2491