1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2007 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 #include <linux/slab.h> 11 #include <asm/ebcdic.h> 12 #include <linux/hashtable.h> 13 #include <linux/inet.h> 14 #include "qeth_l3.h" 15 16 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \ 17 struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store) 18 19 static int qeth_l3_string_to_ipaddr(const char *buf, 20 enum qeth_prot_versions proto, u8 *addr) 21 { 22 const char *end; 23 24 if ((proto == QETH_PROT_IPV4 && !in4_pton(buf, -1, addr, -1, &end)) || 25 (proto == QETH_PROT_IPV6 && !in6_pton(buf, -1, addr, -1, &end))) 26 return -EINVAL; 27 return 0; 28 } 29 30 static ssize_t qeth_l3_dev_route_show(struct qeth_card *card, 31 struct qeth_routing_info *route, char *buf) 32 { 33 switch (route->type) { 34 case PRIMARY_ROUTER: 35 return sprintf(buf, "%s\n", "primary router"); 36 case SECONDARY_ROUTER: 37 return sprintf(buf, "%s\n", "secondary router"); 38 case MULTICAST_ROUTER: 39 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 40 return sprintf(buf, "%s\n", "multicast router+"); 41 else 42 return sprintf(buf, "%s\n", "multicast router"); 43 case PRIMARY_CONNECTOR: 44 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 45 return sprintf(buf, "%s\n", "primary connector+"); 46 else 47 return sprintf(buf, "%s\n", "primary connector"); 48 case SECONDARY_CONNECTOR: 49 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 50 return sprintf(buf, "%s\n", "secondary connector+"); 51 else 52 return sprintf(buf, "%s\n", "secondary connector"); 53 default: 54 return sprintf(buf, "%s\n", "no"); 55 } 56 } 57 58 static ssize_t qeth_l3_dev_route4_show(struct device *dev, 59 struct device_attribute *attr, char *buf) 60 { 61 struct qeth_card *card = dev_get_drvdata(dev); 62 63 if (!card) 64 return -EINVAL; 65 66 return qeth_l3_dev_route_show(card, &card->options.route4, buf); 67 } 68 69 static ssize_t qeth_l3_dev_route_store(struct qeth_card *card, 70 struct qeth_routing_info *route, enum qeth_prot_versions prot, 71 const char *buf, size_t count) 72 { 73 enum qeth_routing_types old_route_type = route->type; 74 int rc = 0; 75 76 mutex_lock(&card->conf_mutex); 77 if (sysfs_streq(buf, "no_router")) { 78 route->type = NO_ROUTER; 79 } else if (sysfs_streq(buf, "primary_connector")) { 80 route->type = PRIMARY_CONNECTOR; 81 } else if (sysfs_streq(buf, "secondary_connector")) { 82 route->type = SECONDARY_CONNECTOR; 83 } else if (sysfs_streq(buf, "primary_router")) { 84 route->type = PRIMARY_ROUTER; 85 } else if (sysfs_streq(buf, "secondary_router")) { 86 route->type = SECONDARY_ROUTER; 87 } else if (sysfs_streq(buf, "multicast_router")) { 88 route->type = MULTICAST_ROUTER; 89 } else { 90 rc = -EINVAL; 91 goto out; 92 } 93 if (qeth_card_hw_is_reachable(card) && 94 (old_route_type != route->type)) { 95 if (prot == QETH_PROT_IPV4) 96 rc = qeth_l3_setrouting_v4(card); 97 else if (prot == QETH_PROT_IPV6) 98 rc = qeth_l3_setrouting_v6(card); 99 } 100 out: 101 if (rc) 102 route->type = old_route_type; 103 mutex_unlock(&card->conf_mutex); 104 return rc ? rc : count; 105 } 106 107 static ssize_t qeth_l3_dev_route4_store(struct device *dev, 108 struct device_attribute *attr, const char *buf, size_t count) 109 { 110 struct qeth_card *card = dev_get_drvdata(dev); 111 112 if (!card) 113 return -EINVAL; 114 115 return qeth_l3_dev_route_store(card, &card->options.route4, 116 QETH_PROT_IPV4, buf, count); 117 } 118 119 static DEVICE_ATTR(route4, 0644, qeth_l3_dev_route4_show, 120 qeth_l3_dev_route4_store); 121 122 static ssize_t qeth_l3_dev_route6_show(struct device *dev, 123 struct device_attribute *attr, char *buf) 124 { 125 struct qeth_card *card = dev_get_drvdata(dev); 126 127 if (!card) 128 return -EINVAL; 129 130 return qeth_l3_dev_route_show(card, &card->options.route6, buf); 131 } 132 133 static ssize_t qeth_l3_dev_route6_store(struct device *dev, 134 struct device_attribute *attr, const char *buf, size_t count) 135 { 136 struct qeth_card *card = dev_get_drvdata(dev); 137 138 if (!card) 139 return -EINVAL; 140 141 return qeth_l3_dev_route_store(card, &card->options.route6, 142 QETH_PROT_IPV6, buf, count); 143 } 144 145 static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show, 146 qeth_l3_dev_route6_store); 147 148 static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev, 149 struct device_attribute *attr, char *buf) 150 { 151 struct qeth_card *card = dev_get_drvdata(dev); 152 153 if (!card) 154 return -EINVAL; 155 156 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0); 157 } 158 159 static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev, 160 struct device_attribute *attr, const char *buf, size_t count) 161 { 162 struct qeth_card *card = dev_get_drvdata(dev); 163 char *tmp; 164 int i, rc = 0; 165 166 if (!card) 167 return -EINVAL; 168 169 mutex_lock(&card->conf_mutex); 170 if (card->state != CARD_STATE_DOWN) { 171 rc = -EPERM; 172 goto out; 173 } 174 175 i = simple_strtoul(buf, &tmp, 16); 176 if ((i == 0) || (i == 1)) 177 card->options.fake_broadcast = i; 178 else 179 rc = -EINVAL; 180 out: 181 mutex_unlock(&card->conf_mutex); 182 return rc ? rc : count; 183 } 184 185 static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show, 186 qeth_l3_dev_fake_broadcast_store); 187 188 static ssize_t qeth_l3_dev_sniffer_show(struct device *dev, 189 struct device_attribute *attr, char *buf) 190 { 191 struct qeth_card *card = dev_get_drvdata(dev); 192 193 if (!card) 194 return -EINVAL; 195 196 return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0); 197 } 198 199 static ssize_t qeth_l3_dev_sniffer_store(struct device *dev, 200 struct device_attribute *attr, const char *buf, size_t count) 201 { 202 struct qeth_card *card = dev_get_drvdata(dev); 203 int rc = 0; 204 unsigned long i; 205 206 if (!card) 207 return -EINVAL; 208 209 if (!IS_IQD(card)) 210 return -EPERM; 211 if (card->options.cq == QETH_CQ_ENABLED) 212 return -EPERM; 213 214 mutex_lock(&card->conf_mutex); 215 if (card->state != CARD_STATE_DOWN) { 216 rc = -EPERM; 217 goto out; 218 } 219 220 rc = kstrtoul(buf, 16, &i); 221 if (rc) { 222 rc = -EINVAL; 223 goto out; 224 } 225 switch (i) { 226 case 0: 227 card->options.sniffer = i; 228 break; 229 case 1: 230 qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd); 231 if (card->ssqd.qdioac2 & QETH_SNIFF_AVAIL) { 232 card->options.sniffer = i; 233 if (card->qdio.init_pool.buf_count != 234 QETH_IN_BUF_COUNT_MAX) 235 qeth_realloc_buffer_pool(card, 236 QETH_IN_BUF_COUNT_MAX); 237 } else 238 rc = -EPERM; 239 break; 240 default: 241 rc = -EINVAL; 242 } 243 out: 244 mutex_unlock(&card->conf_mutex); 245 return rc ? rc : count; 246 } 247 248 static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show, 249 qeth_l3_dev_sniffer_store); 250 251 252 static ssize_t qeth_l3_dev_hsuid_show(struct device *dev, 253 struct device_attribute *attr, char *buf) 254 { 255 struct qeth_card *card = dev_get_drvdata(dev); 256 char tmp_hsuid[9]; 257 258 if (!card) 259 return -EINVAL; 260 261 if (!IS_IQD(card)) 262 return -EPERM; 263 264 memcpy(tmp_hsuid, card->options.hsuid, sizeof(tmp_hsuid)); 265 EBCASC(tmp_hsuid, 8); 266 return sprintf(buf, "%s\n", tmp_hsuid); 267 } 268 269 static ssize_t qeth_l3_dev_hsuid_store(struct device *dev, 270 struct device_attribute *attr, const char *buf, size_t count) 271 { 272 struct qeth_card *card = dev_get_drvdata(dev); 273 char *tmp; 274 int rc; 275 276 if (!card) 277 return -EINVAL; 278 279 if (!IS_IQD(card)) 280 return -EPERM; 281 if (card->state != CARD_STATE_DOWN) 282 return -EPERM; 283 if (card->options.sniffer) 284 return -EPERM; 285 if (card->options.cq == QETH_CQ_NOTAVAILABLE) 286 return -EPERM; 287 288 tmp = strsep((char **)&buf, "\n"); 289 if (strlen(tmp) > 8) 290 return -EINVAL; 291 292 if (card->options.hsuid[0]) 293 /* delete old ip address */ 294 qeth_l3_modify_hsuid(card, false); 295 296 if (strlen(tmp) == 0) { 297 /* delete ip address only */ 298 card->options.hsuid[0] = '\0'; 299 memcpy(card->dev->perm_addr, card->options.hsuid, 9); 300 qeth_configure_cq(card, QETH_CQ_DISABLED); 301 return count; 302 } 303 304 if (qeth_configure_cq(card, QETH_CQ_ENABLED)) 305 return -EPERM; 306 307 snprintf(card->options.hsuid, sizeof(card->options.hsuid), 308 "%-8s", tmp); 309 ASCEBC(card->options.hsuid, 8); 310 memcpy(card->dev->perm_addr, card->options.hsuid, 9); 311 312 rc = qeth_l3_modify_hsuid(card, true); 313 314 return rc ? rc : count; 315 } 316 317 static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show, 318 qeth_l3_dev_hsuid_store); 319 320 321 static struct attribute *qeth_l3_device_attrs[] = { 322 &dev_attr_route4.attr, 323 &dev_attr_route6.attr, 324 &dev_attr_fake_broadcast.attr, 325 &dev_attr_sniffer.attr, 326 &dev_attr_hsuid.attr, 327 NULL, 328 }; 329 330 static const struct attribute_group qeth_l3_device_attr_group = { 331 .attrs = qeth_l3_device_attrs, 332 }; 333 334 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev, 335 struct device_attribute *attr, char *buf) 336 { 337 struct qeth_card *card = dev_get_drvdata(dev); 338 339 if (!card) 340 return -EINVAL; 341 342 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0); 343 } 344 345 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev, 346 struct device_attribute *attr, const char *buf, size_t count) 347 { 348 struct qeth_card *card = dev_get_drvdata(dev); 349 bool enable; 350 int rc = 0; 351 352 if (!card) 353 return -EINVAL; 354 355 mutex_lock(&card->conf_mutex); 356 if (card->state != CARD_STATE_DOWN) { 357 rc = -EPERM; 358 goto out; 359 } 360 361 if (sysfs_streq(buf, "toggle")) { 362 enable = !card->ipato.enabled; 363 } else if (kstrtobool(buf, &enable)) { 364 rc = -EINVAL; 365 goto out; 366 } 367 368 if (card->ipato.enabled != enable) { 369 card->ipato.enabled = enable; 370 mutex_lock(&card->ip_lock); 371 qeth_l3_update_ipato(card); 372 mutex_unlock(&card->ip_lock); 373 } 374 out: 375 mutex_unlock(&card->conf_mutex); 376 return rc ? rc : count; 377 } 378 379 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644, 380 qeth_l3_dev_ipato_enable_show, 381 qeth_l3_dev_ipato_enable_store); 382 383 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev, 384 struct device_attribute *attr, char *buf) 385 { 386 struct qeth_card *card = dev_get_drvdata(dev); 387 388 if (!card) 389 return -EINVAL; 390 391 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0); 392 } 393 394 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev, 395 struct device_attribute *attr, 396 const char *buf, size_t count) 397 { 398 struct qeth_card *card = dev_get_drvdata(dev); 399 bool invert; 400 int rc = 0; 401 402 if (!card) 403 return -EINVAL; 404 405 mutex_lock(&card->conf_mutex); 406 if (sysfs_streq(buf, "toggle")) { 407 invert = !card->ipato.invert4; 408 } else if (kstrtobool(buf, &invert)) { 409 rc = -EINVAL; 410 goto out; 411 } 412 413 if (card->ipato.invert4 != invert) { 414 card->ipato.invert4 = invert; 415 mutex_lock(&card->ip_lock); 416 qeth_l3_update_ipato(card); 417 mutex_unlock(&card->ip_lock); 418 } 419 out: 420 mutex_unlock(&card->conf_mutex); 421 return rc ? rc : count; 422 } 423 424 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644, 425 qeth_l3_dev_ipato_invert4_show, 426 qeth_l3_dev_ipato_invert4_store); 427 428 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card, 429 enum qeth_prot_versions proto) 430 { 431 struct qeth_ipato_entry *ipatoe; 432 char addr_str[40]; 433 int entry_len; /* length of 1 entry string, differs between v4 and v6 */ 434 int i = 0; 435 436 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40; 437 /* add strlen for "/<mask>\n" */ 438 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6; 439 mutex_lock(&card->ip_lock); 440 list_for_each_entry(ipatoe, &card->ipato.entries, entry) { 441 if (ipatoe->proto != proto) 442 continue; 443 /* String must not be longer than PAGE_SIZE. So we check if 444 * string length gets near PAGE_SIZE. Then we can savely display 445 * the next IPv6 address (worst case, compared to IPv4) */ 446 if ((PAGE_SIZE - i) <= entry_len) 447 break; 448 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str); 449 i += snprintf(buf + i, PAGE_SIZE - i, 450 "%s/%i\n", addr_str, ipatoe->mask_bits); 451 } 452 mutex_unlock(&card->ip_lock); 453 i += snprintf(buf + i, PAGE_SIZE - i, "\n"); 454 455 return i; 456 } 457 458 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev, 459 struct device_attribute *attr, char *buf) 460 { 461 struct qeth_card *card = dev_get_drvdata(dev); 462 463 if (!card) 464 return -EINVAL; 465 466 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4); 467 } 468 469 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto, 470 u8 *addr, int *mask_bits) 471 { 472 const char *start, *end; 473 char *tmp; 474 char buffer[40] = {0, }; 475 476 start = buf; 477 /* get address string */ 478 end = strchr(start, '/'); 479 if (!end || (end - start >= 40)) { 480 return -EINVAL; 481 } 482 strncpy(buffer, start, end - start); 483 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) { 484 return -EINVAL; 485 } 486 start = end + 1; 487 *mask_bits = simple_strtoul(start, &tmp, 10); 488 if (!strlen(start) || 489 (tmp == start) || 490 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) { 491 return -EINVAL; 492 } 493 return 0; 494 } 495 496 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count, 497 struct qeth_card *card, enum qeth_prot_versions proto) 498 { 499 struct qeth_ipato_entry *ipatoe; 500 u8 addr[16]; 501 int mask_bits; 502 int rc = 0; 503 504 mutex_lock(&card->conf_mutex); 505 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits); 506 if (rc) 507 goto out; 508 509 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL); 510 if (!ipatoe) { 511 rc = -ENOMEM; 512 goto out; 513 } 514 ipatoe->proto = proto; 515 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16); 516 ipatoe->mask_bits = mask_bits; 517 518 rc = qeth_l3_add_ipato_entry(card, ipatoe); 519 if (rc) 520 kfree(ipatoe); 521 out: 522 mutex_unlock(&card->conf_mutex); 523 return rc ? rc : count; 524 } 525 526 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev, 527 struct device_attribute *attr, const char *buf, size_t count) 528 { 529 struct qeth_card *card = dev_get_drvdata(dev); 530 531 if (!card) 532 return -EINVAL; 533 534 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4); 535 } 536 537 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644, 538 qeth_l3_dev_ipato_add4_show, 539 qeth_l3_dev_ipato_add4_store); 540 541 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count, 542 struct qeth_card *card, enum qeth_prot_versions proto) 543 { 544 u8 addr[16]; 545 int mask_bits; 546 int rc = 0; 547 548 mutex_lock(&card->conf_mutex); 549 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits); 550 if (!rc) 551 rc = qeth_l3_del_ipato_entry(card, proto, addr, mask_bits); 552 mutex_unlock(&card->conf_mutex); 553 return rc ? rc : count; 554 } 555 556 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev, 557 struct device_attribute *attr, const char *buf, size_t count) 558 { 559 struct qeth_card *card = dev_get_drvdata(dev); 560 561 if (!card) 562 return -EINVAL; 563 564 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4); 565 } 566 567 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL, 568 qeth_l3_dev_ipato_del4_store); 569 570 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev, 571 struct device_attribute *attr, char *buf) 572 { 573 struct qeth_card *card = dev_get_drvdata(dev); 574 575 if (!card) 576 return -EINVAL; 577 578 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0); 579 } 580 581 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev, 582 struct device_attribute *attr, const char *buf, size_t count) 583 { 584 struct qeth_card *card = dev_get_drvdata(dev); 585 bool invert; 586 int rc = 0; 587 588 if (!card) 589 return -EINVAL; 590 591 mutex_lock(&card->conf_mutex); 592 if (sysfs_streq(buf, "toggle")) { 593 invert = !card->ipato.invert6; 594 } else if (kstrtobool(buf, &invert)) { 595 rc = -EINVAL; 596 goto out; 597 } 598 599 if (card->ipato.invert6 != invert) { 600 card->ipato.invert6 = invert; 601 mutex_lock(&card->ip_lock); 602 qeth_l3_update_ipato(card); 603 mutex_unlock(&card->ip_lock); 604 } 605 out: 606 mutex_unlock(&card->conf_mutex); 607 return rc ? rc : count; 608 } 609 610 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644, 611 qeth_l3_dev_ipato_invert6_show, 612 qeth_l3_dev_ipato_invert6_store); 613 614 615 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev, 616 struct device_attribute *attr, char *buf) 617 { 618 struct qeth_card *card = dev_get_drvdata(dev); 619 620 if (!card) 621 return -EINVAL; 622 623 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6); 624 } 625 626 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev, 627 struct device_attribute *attr, const char *buf, size_t count) 628 { 629 struct qeth_card *card = dev_get_drvdata(dev); 630 631 if (!card) 632 return -EINVAL; 633 634 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6); 635 } 636 637 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644, 638 qeth_l3_dev_ipato_add6_show, 639 qeth_l3_dev_ipato_add6_store); 640 641 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev, 642 struct device_attribute *attr, const char *buf, size_t count) 643 { 644 struct qeth_card *card = dev_get_drvdata(dev); 645 646 if (!card) 647 return -EINVAL; 648 649 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6); 650 } 651 652 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL, 653 qeth_l3_dev_ipato_del6_store); 654 655 static struct attribute *qeth_ipato_device_attrs[] = { 656 &dev_attr_ipato_enable.attr, 657 &dev_attr_ipato_invert4.attr, 658 &dev_attr_ipato_add4.attr, 659 &dev_attr_ipato_del4.attr, 660 &dev_attr_ipato_invert6.attr, 661 &dev_attr_ipato_add6.attr, 662 &dev_attr_ipato_del6.attr, 663 NULL, 664 }; 665 666 static const struct attribute_group qeth_device_ipato_group = { 667 .name = "ipa_takeover", 668 .attrs = qeth_ipato_device_attrs, 669 }; 670 671 static ssize_t qeth_l3_dev_ip_add_show(struct device *dev, char *buf, 672 enum qeth_prot_versions proto, 673 enum qeth_ip_types type) 674 { 675 struct qeth_card *card = dev_get_drvdata(dev); 676 struct qeth_ipaddr *ipaddr; 677 char addr_str[40]; 678 int str_len = 0; 679 int entry_len; /* length of 1 entry string, differs between v4 and v6 */ 680 int i; 681 682 if (!card) 683 return -EINVAL; 684 685 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40; 686 entry_len += 2; /* \n + terminator */ 687 mutex_lock(&card->ip_lock); 688 hash_for_each(card->ip_htable, i, ipaddr, hnode) { 689 if (ipaddr->proto != proto || ipaddr->type != type) 690 continue; 691 /* String must not be longer than PAGE_SIZE. So we check if 692 * string length gets near PAGE_SIZE. Then we can savely display 693 * the next IPv6 address (worst case, compared to IPv4) */ 694 if ((PAGE_SIZE - str_len) <= entry_len) 695 break; 696 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, 697 addr_str); 698 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "%s\n", 699 addr_str); 700 } 701 mutex_unlock(&card->ip_lock); 702 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "\n"); 703 704 return str_len; 705 } 706 707 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev, 708 struct device_attribute *attr, 709 char *buf) 710 { 711 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4, 712 QETH_IP_TYPE_VIPA); 713 } 714 715 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto, 716 u8 *addr) 717 { 718 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) { 719 return -EINVAL; 720 } 721 return 0; 722 } 723 724 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count, 725 struct qeth_card *card, enum qeth_prot_versions proto) 726 { 727 u8 addr[16] = {0, }; 728 int rc; 729 730 mutex_lock(&card->conf_mutex); 731 rc = qeth_l3_parse_vipae(buf, proto, addr); 732 if (!rc) 733 rc = qeth_l3_modify_rxip_vipa(card, true, addr, 734 QETH_IP_TYPE_VIPA, proto); 735 mutex_unlock(&card->conf_mutex); 736 return rc ? rc : count; 737 } 738 739 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev, 740 struct device_attribute *attr, const char *buf, size_t count) 741 { 742 struct qeth_card *card = dev_get_drvdata(dev); 743 744 if (!card) 745 return -EINVAL; 746 747 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4); 748 } 749 750 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644, 751 qeth_l3_dev_vipa_add4_show, 752 qeth_l3_dev_vipa_add4_store); 753 754 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count, 755 struct qeth_card *card, enum qeth_prot_versions proto) 756 { 757 u8 addr[16]; 758 int rc; 759 760 mutex_lock(&card->conf_mutex); 761 rc = qeth_l3_parse_vipae(buf, proto, addr); 762 if (!rc) 763 rc = qeth_l3_modify_rxip_vipa(card, false, addr, 764 QETH_IP_TYPE_VIPA, proto); 765 mutex_unlock(&card->conf_mutex); 766 return rc ? rc : count; 767 } 768 769 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev, 770 struct device_attribute *attr, const char *buf, size_t count) 771 { 772 struct qeth_card *card = dev_get_drvdata(dev); 773 774 if (!card) 775 return -EINVAL; 776 777 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4); 778 } 779 780 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL, 781 qeth_l3_dev_vipa_del4_store); 782 783 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev, 784 struct device_attribute *attr, 785 char *buf) 786 { 787 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6, 788 QETH_IP_TYPE_VIPA); 789 } 790 791 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev, 792 struct device_attribute *attr, const char *buf, size_t count) 793 { 794 struct qeth_card *card = dev_get_drvdata(dev); 795 796 if (!card) 797 return -EINVAL; 798 799 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6); 800 } 801 802 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644, 803 qeth_l3_dev_vipa_add6_show, 804 qeth_l3_dev_vipa_add6_store); 805 806 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev, 807 struct device_attribute *attr, const char *buf, size_t count) 808 { 809 struct qeth_card *card = dev_get_drvdata(dev); 810 811 if (!card) 812 return -EINVAL; 813 814 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6); 815 } 816 817 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL, 818 qeth_l3_dev_vipa_del6_store); 819 820 static struct attribute *qeth_vipa_device_attrs[] = { 821 &dev_attr_vipa_add4.attr, 822 &dev_attr_vipa_del4.attr, 823 &dev_attr_vipa_add6.attr, 824 &dev_attr_vipa_del6.attr, 825 NULL, 826 }; 827 828 static const struct attribute_group qeth_device_vipa_group = { 829 .name = "vipa", 830 .attrs = qeth_vipa_device_attrs, 831 }; 832 833 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev, 834 struct device_attribute *attr, 835 char *buf) 836 { 837 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4, 838 QETH_IP_TYPE_RXIP); 839 } 840 841 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto, 842 u8 *addr) 843 { 844 __be32 ipv4_addr; 845 struct in6_addr ipv6_addr; 846 847 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) { 848 return -EINVAL; 849 } 850 if (proto == QETH_PROT_IPV4) { 851 memcpy(&ipv4_addr, addr, sizeof(ipv4_addr)); 852 if (ipv4_is_multicast(ipv4_addr)) { 853 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n"); 854 return -EINVAL; 855 } 856 } else if (proto == QETH_PROT_IPV6) { 857 memcpy(&ipv6_addr, addr, sizeof(ipv6_addr)); 858 if (ipv6_addr_is_multicast(&ipv6_addr)) { 859 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n"); 860 return -EINVAL; 861 } 862 } 863 864 return 0; 865 } 866 867 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count, 868 struct qeth_card *card, enum qeth_prot_versions proto) 869 { 870 u8 addr[16] = {0, }; 871 int rc; 872 873 mutex_lock(&card->conf_mutex); 874 rc = qeth_l3_parse_rxipe(buf, proto, addr); 875 if (!rc) 876 rc = qeth_l3_modify_rxip_vipa(card, true, addr, 877 QETH_IP_TYPE_RXIP, proto); 878 mutex_unlock(&card->conf_mutex); 879 return rc ? rc : count; 880 } 881 882 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev, 883 struct device_attribute *attr, const char *buf, size_t count) 884 { 885 struct qeth_card *card = dev_get_drvdata(dev); 886 887 if (!card) 888 return -EINVAL; 889 890 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4); 891 } 892 893 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644, 894 qeth_l3_dev_rxip_add4_show, 895 qeth_l3_dev_rxip_add4_store); 896 897 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count, 898 struct qeth_card *card, enum qeth_prot_versions proto) 899 { 900 u8 addr[16]; 901 int rc; 902 903 mutex_lock(&card->conf_mutex); 904 rc = qeth_l3_parse_rxipe(buf, proto, addr); 905 if (!rc) 906 rc = qeth_l3_modify_rxip_vipa(card, false, addr, 907 QETH_IP_TYPE_RXIP, proto); 908 mutex_unlock(&card->conf_mutex); 909 return rc ? rc : count; 910 } 911 912 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev, 913 struct device_attribute *attr, const char *buf, size_t count) 914 { 915 struct qeth_card *card = dev_get_drvdata(dev); 916 917 if (!card) 918 return -EINVAL; 919 920 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4); 921 } 922 923 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL, 924 qeth_l3_dev_rxip_del4_store); 925 926 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev, 927 struct device_attribute *attr, 928 char *buf) 929 { 930 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6, 931 QETH_IP_TYPE_RXIP); 932 } 933 934 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev, 935 struct device_attribute *attr, const char *buf, size_t count) 936 { 937 struct qeth_card *card = dev_get_drvdata(dev); 938 939 if (!card) 940 return -EINVAL; 941 942 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6); 943 } 944 945 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644, 946 qeth_l3_dev_rxip_add6_show, 947 qeth_l3_dev_rxip_add6_store); 948 949 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev, 950 struct device_attribute *attr, const char *buf, size_t count) 951 { 952 struct qeth_card *card = dev_get_drvdata(dev); 953 954 if (!card) 955 return -EINVAL; 956 957 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6); 958 } 959 960 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL, 961 qeth_l3_dev_rxip_del6_store); 962 963 static struct attribute *qeth_rxip_device_attrs[] = { 964 &dev_attr_rxip_add4.attr, 965 &dev_attr_rxip_del4.attr, 966 &dev_attr_rxip_add6.attr, 967 &dev_attr_rxip_del6.attr, 968 NULL, 969 }; 970 971 static const struct attribute_group qeth_device_rxip_group = { 972 .name = "rxip", 973 .attrs = qeth_rxip_device_attrs, 974 }; 975 976 static const struct attribute_group *qeth_l3_only_attr_groups[] = { 977 &qeth_l3_device_attr_group, 978 &qeth_device_ipato_group, 979 &qeth_device_vipa_group, 980 &qeth_device_rxip_group, 981 NULL, 982 }; 983 984 int qeth_l3_create_device_attributes(struct device *dev) 985 { 986 return sysfs_create_groups(&dev->kobj, qeth_l3_only_attr_groups); 987 } 988 989 void qeth_l3_remove_device_attributes(struct device *dev) 990 { 991 sysfs_remove_groups(&dev->kobj, qeth_l3_only_attr_groups); 992 } 993 994 const struct attribute_group *qeth_l3_attr_groups[] = { 995 &qeth_device_attr_group, 996 &qeth_device_blkt_group, 997 /* l3 specific, see qeth_l3_only_attr_groups: */ 998 &qeth_l3_device_attr_group, 999 &qeth_device_ipato_group, 1000 &qeth_device_vipa_group, 1001 &qeth_device_rxip_group, 1002 NULL, 1003 }; 1004