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