tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

rds: Remove IPv6 dependency

This patch removes the IPv6 dependency from RDS.

Signed-off-by: Ka-Cheong Poon <ka-cheong.poon@oracle.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Ka-Cheong Poon and committed by
David S. Miller e65d4d96 f394ad28

+140 -26
+1 -1
net/rds/Kconfig
··· 1 1 2 2 config RDS 3 3 tristate "The RDS Protocol" 4 - depends on INET && IPV6 4 + depends on INET 5 5 ---help--- 6 6 The RDS (Reliable Datagram Sockets) protocol provides reliable, 7 7 sequenced delivery of datagrams over Infiniband or TCP.
+19 -13
net/rds/af_rds.c
··· 156 156 return sizeof(*sin); 157 157 } 158 158 159 - if (ipv6_addr_type(&rs->rs_conn_addr) & 160 - IPV6_ADDR_MAPPED) { 161 - sin = (struct sockaddr_in *)uaddr; 162 - memset(sin, 0, sizeof(*sin)); 163 - sin->sin_family = AF_INET; 164 - return sizeof(*sin); 159 + #if IS_ENABLED(CONFIG_IPV6) 160 + if (!(ipv6_addr_type(&rs->rs_conn_addr) & 161 + IPV6_ADDR_MAPPED)) { 162 + sin6 = (struct sockaddr_in6 *)uaddr; 163 + memset(sin6, 0, sizeof(*sin6)); 164 + sin6->sin6_family = AF_INET6; 165 + return sizeof(*sin6); 165 166 } 167 + #endif 166 168 167 - sin6 = (struct sockaddr_in6 *)uaddr; 168 - memset(sin6, 0, sizeof(*sin6)); 169 - sin6->sin6_family = AF_INET6; 170 - return sizeof(*sin6); 169 + sin = (struct sockaddr_in *)uaddr; 170 + memset(sin, 0, sizeof(*sin)); 171 + sin->sin_family = AF_INET; 172 + return sizeof(*sin); 171 173 } 172 174 if (ipv6_addr_v4mapped(&rs->rs_bound_addr)) { 173 175 sin = (struct sockaddr_in *)uaddr; ··· 503 501 { 504 502 struct sock *sk = sock->sk; 505 503 struct sockaddr_in *sin; 506 - struct sockaddr_in6 *sin6; 507 504 struct rds_sock *rs = rds_sk_to_rs(sk); 508 - int addr_type; 509 505 int ret = 0; 510 506 511 507 lock_sock(sk); ··· 528 528 rs->rs_conn_port = sin->sin_port; 529 529 break; 530 530 531 - case AF_INET6: 531 + #if IS_ENABLED(CONFIG_IPV6) 532 + case AF_INET6: { 533 + struct sockaddr_in6 *sin6; 534 + int addr_type; 535 + 532 536 sin6 = (struct sockaddr_in6 *)uaddr; 533 537 if (addr_len < sizeof(struct sockaddr_in6)) { 534 538 ret = -EINVAL; ··· 579 575 rs->rs_conn_addr = sin6->sin6_addr; 580 576 rs->rs_conn_port = sin6->sin6_port; 581 577 break; 578 + } 579 + #endif 582 580 583 581 default: 584 582 ret = -EAFNOSUPPORT;
+3 -1
net/rds/bind.c
··· 165 165 struct in6_addr v6addr, *binding_addr; 166 166 struct rds_transport *trans; 167 167 __u32 scope_id = 0; 168 - int addr_type; 169 168 int ret = 0; 170 169 __be16 port; 171 170 ··· 182 183 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &v6addr); 183 184 binding_addr = &v6addr; 184 185 port = sin->sin_port; 186 + #if IS_ENABLED(CONFIG_IPV6) 185 187 } else if (uaddr->sa_family == AF_INET6) { 186 188 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)uaddr; 189 + int addr_type; 187 190 188 191 if (addr_len < sizeof(struct sockaddr_in6)) 189 192 return -EINVAL; ··· 213 212 } 214 213 binding_addr = &sin6->sin6_addr; 215 214 port = sin6->sin6_port; 215 + #endif 216 216 } else { 217 217 return -EINVAL; 218 218 }
+24 -2
net/rds/connection.c
··· 63 63 net_get_random_once(&rds6_hash_secret, sizeof(rds6_hash_secret)); 64 64 65 65 lhash = (__force u32)laddr->s6_addr32[3]; 66 + #if IS_ENABLED(CONFIG_IPV6) 66 67 fhash = __ipv6_addr_jhash(faddr, rds6_hash_secret); 67 - hash = __inet6_ehashfn(lhash, 0, fhash, 0, rds_hash_secret); 68 + #else 69 + fhash = (__force u32)faddr->s6_addr32[3]; 70 + #endif 71 + hash = __inet_ehashfn(lhash, 0, fhash, 0, rds_hash_secret); 68 72 69 73 return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK]; 70 74 } ··· 205 201 conn->c_isv6 = !ipv6_addr_v4mapped(laddr); 206 202 conn->c_faddr = *faddr; 207 203 conn->c_dev_if = dev_if; 204 + 205 + #if IS_ENABLED(CONFIG_IPV6) 208 206 /* If the local address is link local, set c_bound_if to be the 209 207 * index used for this connection. Otherwise, set it to 0 as 210 208 * the socket is not bound to an interface. c_bound_if is used ··· 215 209 if (ipv6_addr_type(laddr) & IPV6_ADDR_LINKLOCAL) 216 210 conn->c_bound_if = dev_if; 217 211 else 212 + #endif 218 213 conn->c_bound_if = 0; 219 214 220 215 rds_conn_net_set(conn, net); ··· 507 500 struct rds_info_iterator *iter, 508 501 void *saddr, void *daddr, int flip, bool isv6) 509 502 { 503 + #if IS_ENABLED(CONFIG_IPV6) 510 504 if (isv6) 511 505 rds6_inc_info_copy(inc, iter, saddr, daddr, flip); 512 506 else 507 + #endif 513 508 rds_inc_info_copy(inc, iter, *(__be32 *)saddr, 514 509 *(__be32 *)daddr, flip); 515 510 } ··· 590 581 rds_conn_message_info_cmn(sock, len, iter, lens, want_send, false); 591 582 } 592 583 584 + #if IS_ENABLED(CONFIG_IPV6) 593 585 static void rds6_conn_message_info(struct socket *sock, unsigned int len, 594 586 struct rds_info_iterator *iter, 595 587 struct rds_info_lengths *lens, ··· 598 588 { 599 589 rds_conn_message_info_cmn(sock, len, iter, lens, want_send, true); 600 590 } 591 + #endif 601 592 602 593 static void rds_conn_message_info_send(struct socket *sock, unsigned int len, 603 594 struct rds_info_iterator *iter, ··· 607 596 rds_conn_message_info(sock, len, iter, lens, 1); 608 597 } 609 598 599 + #if IS_ENABLED(CONFIG_IPV6) 610 600 static void rds6_conn_message_info_send(struct socket *sock, unsigned int len, 611 601 struct rds_info_iterator *iter, 612 602 struct rds_info_lengths *lens) 613 603 { 614 604 rds6_conn_message_info(sock, len, iter, lens, 1); 615 605 } 606 + #endif 616 607 617 608 static void rds_conn_message_info_retrans(struct socket *sock, 618 609 unsigned int len, ··· 624 611 rds_conn_message_info(sock, len, iter, lens, 0); 625 612 } 626 613 614 + #if IS_ENABLED(CONFIG_IPV6) 627 615 static void rds6_conn_message_info_retrans(struct socket *sock, 628 616 unsigned int len, 629 617 struct rds_info_iterator *iter, ··· 632 618 { 633 619 rds6_conn_message_info(sock, len, iter, lens, 0); 634 620 } 621 + #endif 635 622 636 623 void rds_for_each_conn_info(struct socket *sock, unsigned int len, 637 624 struct rds_info_iterator *iter, ··· 749 734 return 1; 750 735 } 751 736 737 + #if IS_ENABLED(CONFIG_IPV6) 752 738 static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer) 753 739 { 754 740 struct rds6_info_connection *cinfo6 = buffer; ··· 777 761 */ 778 762 return 1; 779 763 } 764 + #endif 780 765 781 766 static void rds_conn_info(struct socket *sock, unsigned int len, 782 767 struct rds_info_iterator *iter, ··· 791 774 sizeof(struct rds_info_connection)); 792 775 } 793 776 777 + #if IS_ENABLED(CONFIG_IPV6) 794 778 static void rds6_conn_info(struct socket *sock, unsigned int len, 795 779 struct rds_info_iterator *iter, 796 780 struct rds_info_lengths *lens) ··· 803 785 buffer, 804 786 sizeof(struct rds6_info_connection)); 805 787 } 788 + #endif 806 789 807 790 int rds_conn_init(void) 808 791 { ··· 826 807 rds_conn_message_info_send); 827 808 rds_info_register_func(RDS_INFO_RETRANS_MESSAGES, 828 809 rds_conn_message_info_retrans); 810 + #if IS_ENABLED(CONFIG_IPV6) 829 811 rds_info_register_func(RDS6_INFO_CONNECTIONS, rds6_conn_info); 830 812 rds_info_register_func(RDS6_INFO_SEND_MESSAGES, 831 813 rds6_conn_message_info_send); 832 814 rds_info_register_func(RDS6_INFO_RETRANS_MESSAGES, 833 815 rds6_conn_message_info_retrans); 834 - 816 + #endif 835 817 return 0; 836 818 } 837 819 ··· 850 830 rds_conn_message_info_send); 851 831 rds_info_deregister_func(RDS_INFO_RETRANS_MESSAGES, 852 832 rds_conn_message_info_retrans); 833 + #if IS_ENABLED(CONFIG_IPV6) 853 834 rds_info_deregister_func(RDS6_INFO_CONNECTIONS, rds6_conn_info); 854 835 rds_info_deregister_func(RDS6_INFO_SEND_MESSAGES, 855 836 rds6_conn_message_info_send); 856 837 rds_info_deregister_func(RDS6_INFO_RETRANS_MESSAGES, 857 838 rds6_conn_message_info_retrans); 839 + #endif 858 840 } 859 841 860 842 /*
+26 -5
net/rds/ib.c
··· 321 321 return 1; 322 322 } 323 323 324 + #if IS_ENABLED(CONFIG_IPV6) 324 325 /* IPv6 version of rds_ib_conn_info_visitor(). */ 325 326 static int rds6_ib_conn_info_visitor(struct rds_connection *conn, 326 327 void *buffer) ··· 358 357 } 359 358 return 1; 360 359 } 360 + #endif 361 361 362 362 static void rds_ib_ic_info(struct socket *sock, unsigned int len, 363 363 struct rds_info_iterator *iter, ··· 372 370 sizeof(struct rds_info_rdma_connection)); 373 371 } 374 372 373 + #if IS_ENABLED(CONFIG_IPV6) 375 374 /* IPv6 version of rds_ib_ic_info(). */ 376 375 static void rds6_ib_ic_info(struct socket *sock, unsigned int len, 377 376 struct rds_info_iterator *iter, ··· 385 382 buffer, 386 383 sizeof(struct rds6_info_rdma_connection)); 387 384 } 385 + #endif 388 386 389 387 /* 390 388 * Early RDS/IB was built to only bind to an address if there is an IPoIB ··· 402 398 { 403 399 int ret; 404 400 struct rdma_cm_id *cm_id; 401 + #if IS_ENABLED(CONFIG_IPV6) 405 402 struct sockaddr_in6 sin6; 403 + #endif 406 404 struct sockaddr_in sin; 407 405 struct sockaddr *sa; 408 406 bool isv4; ··· 424 418 sin.sin_addr.s_addr = addr->s6_addr32[3]; 425 419 sa = (struct sockaddr *)&sin; 426 420 } else { 421 + #if IS_ENABLED(CONFIG_IPV6) 427 422 memset(&sin6, 0, sizeof(sin6)); 428 423 sin6.sin6_family = AF_INET6; 429 424 sin6.sin6_addr = *addr; ··· 439 432 if (ipv6_addr_type(addr) & IPV6_ADDR_LINKLOCAL) { 440 433 struct net_device *dev; 441 434 442 - if (scope_id == 0) 443 - return -EADDRNOTAVAIL; 435 + if (scope_id == 0) { 436 + ret = -EADDRNOTAVAIL; 437 + goto out; 438 + } 444 439 445 440 /* Use init_net for now as RDS is not network 446 441 * name space aware. 447 442 */ 448 443 dev = dev_get_by_index(&init_net, scope_id); 449 - if (!dev) 450 - return -EADDRNOTAVAIL; 444 + if (!dev) { 445 + ret = -EADDRNOTAVAIL; 446 + goto out; 447 + } 451 448 if (!ipv6_chk_addr(&init_net, addr, dev, 1)) { 452 449 dev_put(dev); 453 - return -EADDRNOTAVAIL; 450 + ret = -EADDRNOTAVAIL; 451 + goto out; 454 452 } 455 453 dev_put(dev); 456 454 } 455 + #else 456 + ret = -EADDRNOTAVAIL; 457 + goto out; 458 + #endif 457 459 } 458 460 459 461 /* rdma_bind_addr will only succeed for IB & iWARP devices */ ··· 477 461 addr, scope_id, ret, 478 462 cm_id->device ? cm_id->device->node_type : -1); 479 463 464 + out: 480 465 rdma_destroy_id(cm_id); 481 466 482 467 return ret; ··· 508 491 rds_ib_set_unloading(); 509 492 synchronize_rcu(); 510 493 rds_info_deregister_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info); 494 + #if IS_ENABLED(CONFIG_IPV6) 511 495 rds_info_deregister_func(RDS6_INFO_IB_CONNECTIONS, rds6_ib_ic_info); 496 + #endif 512 497 rds_ib_unregister_client(); 513 498 rds_ib_destroy_nodev_conns(); 514 499 rds_ib_sysctl_exit(); ··· 572 553 rds_trans_register(&rds_ib_transport); 573 554 574 555 rds_info_register_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info); 556 + #if IS_ENABLED(CONFIG_IPV6) 575 557 rds_info_register_func(RDS6_INFO_IB_CONNECTIONS, rds6_ib_ic_info); 558 + #endif 576 559 577 560 goto out; 578 561
+9
net/rds/ib_cm.c
··· 678 678 return version; 679 679 } 680 680 681 + #if IS_ENABLED(CONFIG_IPV6) 681 682 /* Given an IPv6 address, find the net_device which hosts that address and 682 683 * return its index. This is used by the rds_ib_cm_handle_connect() code to 683 684 * find the interface index of where an incoming request comes from when ··· 705 704 706 705 return idx; 707 706 } 707 + #endif 708 708 709 709 int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, 710 710 struct rdma_cm_event *event, bool isv6) ··· 734 732 735 733 dp = event->param.conn.private_data; 736 734 if (isv6) { 735 + #if IS_ENABLED(CONFIG_IPV6) 737 736 dp_cmn = &dp->ricp_v6.dp_cmn; 738 737 saddr6 = &dp->ricp_v6.dp_saddr; 739 738 daddr6 = &dp->ricp_v6.dp_daddr; ··· 759 756 goto out; 760 757 } 761 758 } 759 + #else 760 + err = -EOPNOTSUPP; 761 + goto out; 762 + #endif 762 763 } else { 763 764 dp_cmn = &dp->ricp_v4.dp_cmn; 764 765 ipv6_addr_set_v4mapped(dp->ricp_v4.dp_saddr, &s_mapped_addr); ··· 900 893 901 894 /* XXX I wonder what affect the port space has */ 902 895 /* delegate cm event handler to rdma_transport */ 896 + #if IS_ENABLED(CONFIG_IPV6) 903 897 if (conn->c_isv6) 904 898 handler = rds6_rdma_cm_event_handler; 905 899 else 900 + #endif 906 901 handler = rds_rdma_cm_event_handler; 907 902 ic->i_cm_id = rdma_create_id(&init_net, handler, conn, 908 903 RDMA_PS_TCP, IB_QPT_RC);
+2
net/rds/ib_rdma.c
··· 180 180 iinfo->rdma_mr_size = pool_1m->fmr_attr.max_pages; 181 181 } 182 182 183 + #if IS_ENABLED(CONFIG_IPV6) 183 184 void rds6_ib_get_mr_info(struct rds_ib_device *rds_ibdev, 184 185 struct rds6_info_rdma_connection *iinfo6) 185 186 { ··· 189 188 iinfo6->rdma_mr_max = pool_1m->max_items; 190 189 iinfo6->rdma_mr_size = pool_1m->fmr_attr.max_pages; 191 190 } 191 + #endif 192 192 193 193 struct rds_ib_mr *rds_ib_reuse_mr(struct rds_ib_mr_pool *pool) 194 194 {
+10
net/rds/rdma_transport.c
··· 39 39 40 40 /* Global IPv4 and IPv6 RDS RDMA listener cm_id */ 41 41 static struct rdma_cm_id *rds_rdma_listen_id; 42 + #if IS_ENABLED(CONFIG_IPV6) 42 43 static struct rdma_cm_id *rds6_rdma_listen_id; 44 + #endif 43 45 44 46 static int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, 45 47 struct rdma_cm_event *event, ··· 157 155 return rds_rdma_cm_event_handler_cmn(cm_id, event, false); 158 156 } 159 157 158 + #if IS_ENABLED(CONFIG_IPV6) 160 159 int rds6_rdma_cm_event_handler(struct rdma_cm_id *cm_id, 161 160 struct rdma_cm_event *event) 162 161 { 163 162 return rds_rdma_cm_event_handler_cmn(cm_id, event, true); 164 163 } 164 + #endif 165 165 166 166 static int rds_rdma_listen_init_common(rdma_cm_event_handler handler, 167 167 struct sockaddr *sa, ··· 218 214 static int rds_rdma_listen_init(void) 219 215 { 220 216 int ret; 217 + #if IS_ENABLED(CONFIG_IPV6) 221 218 struct sockaddr_in6 sin6; 219 + #endif 222 220 struct sockaddr_in sin; 223 221 224 222 sin.sin_family = PF_INET; ··· 232 226 if (ret != 0) 233 227 return ret; 234 228 229 + #if IS_ENABLED(CONFIG_IPV6) 235 230 sin6.sin6_family = PF_INET6; 236 231 sin6.sin6_addr = in6addr_any; 237 232 sin6.sin6_port = htons(RDS_CM_PORT); ··· 244 237 /* Keep going even when IPv6 is not enabled in the system. */ 245 238 if (ret != 0) 246 239 rdsdebug("Cannot set up IPv6 RDMA listener\n"); 240 + #endif 247 241 return 0; 248 242 } 249 243 ··· 255 247 rdma_destroy_id(rds_rdma_listen_id); 256 248 rds_rdma_listen_id = NULL; 257 249 } 250 + #if IS_ENABLED(CONFIG_IPV6) 258 251 if (rds6_rdma_listen_id) { 259 252 rdsdebug("cm %p\n", rds6_rdma_listen_id); 260 253 rdma_destroy_id(rds6_rdma_listen_id); 261 254 rds6_rdma_listen_id = NULL; 262 255 } 256 + #endif 263 257 } 264 258 265 259 static int rds_rdma_init(void)
+2
net/rds/recv.c
··· 793 793 rds_info_copy(iter, &minfo, sizeof(minfo)); 794 794 } 795 795 796 + #if IS_ENABLED(CONFIG_IPV6) 796 797 void rds6_inc_info_copy(struct rds_incoming *inc, 797 798 struct rds_info_iterator *iter, 798 799 struct in6_addr *saddr, struct in6_addr *daddr, ··· 818 817 819 818 rds_info_copy(iter, &minfo6, sizeof(minfo6)); 820 819 } 820 + #endif
+2
net/rds/send.c
··· 1103 1103 dport = usin->sin_port; 1104 1104 break; 1105 1105 1106 + #if IS_ENABLED(CONFIG_IPV6) 1106 1107 case AF_INET6: { 1107 1108 int addr_type; 1108 1109 ··· 1143 1142 dport = sin6->sin6_port; 1144 1143 break; 1145 1144 } 1145 + #endif 1146 1146 1147 1147 default: 1148 1148 ret = -EINVAL;
+25
net/rds/tcp.c
··· 51 51 * rds6_tcp_tc_count counts both IPv4 and IPv6 connections. 52 52 */ 53 53 static unsigned int rds_tcp_tc_count; 54 + #if IS_ENABLED(CONFIG_IPV6) 54 55 static unsigned int rds6_tcp_tc_count; 56 + #endif 55 57 56 58 /* Track rds_tcp_connection structs so they can be cleaned up */ 57 59 static DEFINE_SPINLOCK(rds_tcp_conn_lock); ··· 120 118 /* done under the callback_lock to serialize with write_space */ 121 119 spin_lock(&rds_tcp_tc_list_lock); 122 120 list_del_init(&tc->t_list_item); 121 + #if IS_ENABLED(CONFIG_IPV6) 123 122 rds6_tcp_tc_count--; 123 + #endif 124 124 if (!tc->t_cpath->cp_conn->c_isv6) 125 125 rds_tcp_tc_count--; 126 126 spin_unlock(&rds_tcp_tc_list_lock); ··· 211 207 /* done under the callback_lock to serialize with write_space */ 212 208 spin_lock(&rds_tcp_tc_list_lock); 213 209 list_add_tail(&tc->t_list_item, &rds_tcp_tc_list); 210 + #if IS_ENABLED(CONFIG_IPV6) 214 211 rds6_tcp_tc_count++; 212 + #endif 215 213 if (!tc->t_cpath->cp_conn->c_isv6) 216 214 rds_tcp_tc_count++; 217 215 spin_unlock(&rds_tcp_tc_list_lock); ··· 279 273 spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags); 280 274 } 281 275 276 + #if IS_ENABLED(CONFIG_IPV6) 282 277 /* Handle RDS6_INFO_TCP_SOCKETS socket option. It returns both IPv4 and 283 278 * IPv6 connections. IPv4 connection address is returned in an IPv4 mapped 284 279 * address. ··· 321 314 322 315 spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags); 323 316 } 317 + #endif 324 318 325 319 static int rds_tcp_laddr_check(struct net *net, const struct in6_addr *addr, 326 320 __u32 scope_id) 327 321 { 328 322 struct net_device *dev = NULL; 323 + #if IS_ENABLED(CONFIG_IPV6) 329 324 int ret; 325 + #endif 330 326 331 327 if (ipv6_addr_v4mapped(addr)) { 332 328 if (inet_addr_type(net, addr->s6_addr32[3]) == RTN_LOCAL) ··· 350 340 } 351 341 rcu_read_unlock(); 352 342 } 343 + #if IS_ENABLED(CONFIG_IPV6) 353 344 ret = ipv6_chk_addr(net, addr, dev, 0); 354 345 if (ret) 355 346 return 0; 347 + #endif 356 348 return -EADDRNOTAVAIL; 357 349 } 358 350 ··· 557 545 err = -ENOMEM; 558 546 goto fail; 559 547 } 548 + 549 + #if IS_ENABLED(CONFIG_IPV6) 560 550 rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, true); 551 + #else 552 + rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, false); 553 + #endif 561 554 if (!rtn->rds_tcp_listen_sock) { 562 555 pr_warn("could not set up IPv6 listen sock\n"); 563 556 557 + #if IS_ENABLED(CONFIG_IPV6) 564 558 /* Try IPv4 as some systems disable IPv6 */ 565 559 rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, false); 566 560 if (!rtn->rds_tcp_listen_sock) { 561 + #endif 567 562 unregister_net_sysctl_table(rtn->rds_tcp_sysctl); 568 563 rtn->rds_tcp_sysctl = NULL; 569 564 err = -EAFNOSUPPORT; 570 565 goto fail; 566 + #if IS_ENABLED(CONFIG_IPV6) 571 567 } 568 + #endif 572 569 } 573 570 INIT_WORK(&rtn->rds_tcp_accept_w, rds_tcp_accept_worker); 574 571 return 0; ··· 691 670 rds_tcp_set_unloading(); 692 671 synchronize_rcu(); 693 672 rds_info_deregister_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info); 673 + #if IS_ENABLED(CONFIG_IPV6) 694 674 rds_info_deregister_func(RDS6_INFO_TCP_SOCKETS, rds6_tcp_tc_info); 675 + #endif 695 676 unregister_pernet_device(&rds_tcp_net_ops); 696 677 rds_tcp_destroy_conns(); 697 678 rds_trans_unregister(&rds_tcp_transport); ··· 725 702 rds_trans_register(&rds_tcp_transport); 726 703 727 704 rds_info_register_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info); 705 + #if IS_ENABLED(CONFIG_IPV6) 728 706 rds_info_register_func(RDS6_INFO_TCP_SOCKETS, rds6_tcp_tc_info); 707 + #endif 729 708 730 709 goto out; 731 710 out_recv:
+17 -4
net/rds/tcp_listen.c
··· 132 132 int conn_state; 133 133 struct rds_conn_path *cp; 134 134 struct in6_addr *my_addr, *peer_addr; 135 - int dev_if; 135 + #if !IS_ENABLED(CONFIG_IPV6) 136 + struct in6_addr saddr, daddr; 137 + #endif 138 + int dev_if = 0; 136 139 137 140 if (!sock) /* module unload or netns delete in progress */ 138 141 return -ENETUNREACH; ··· 168 165 169 166 inet = inet_sk(new_sock->sk); 170 167 168 + #if IS_ENABLED(CONFIG_IPV6) 171 169 my_addr = &new_sock->sk->sk_v6_rcv_saddr; 172 170 peer_addr = &new_sock->sk->sk_v6_daddr; 173 - rdsdebug("accepted tcp %pI6c:%u -> %pI6c:%u\n", 171 + #else 172 + ipv6_addr_set_v4mapped(inet->inet_saddr, &saddr); 173 + ipv6_addr_set_v4mapped(inet->inet_daddr, &daddr); 174 + my_addr = &saddr; 175 + peer_addr = &daddr; 176 + #endif 177 + rdsdebug("accepted family %d tcp %pI6c:%u -> %pI6c:%u\n", 178 + sock->sk->sk_family, 174 179 my_addr, ntohs(inet->inet_sport), 175 180 peer_addr, ntohs(inet->inet_dport)); 176 181 182 + #if IS_ENABLED(CONFIG_IPV6) 177 183 /* sk_bound_dev_if is not set if the peer address is not link local 178 184 * address. In this case, it happens that mcast_oif is set. So 179 185 * just use it. ··· 196 184 } else { 197 185 dev_if = new_sock->sk->sk_bound_dev_if; 198 186 } 187 + #endif 188 + 199 189 conn = rds_conn_create(sock_net(sock->sk), 200 - &new_sock->sk->sk_v6_rcv_saddr, 201 - &new_sock->sk->sk_v6_daddr, 190 + my_addr, peer_addr, 202 191 &rds_tcp_transport, GFP_KERNEL, dev_if); 203 192 204 193 if (IS_ERR(conn)) {