1 /* 2 * net/dccp/proto.c 3 * 4 * An implementation of the DCCP protocol 5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 12 #include <linux/config.h> 13 #include <linux/dccp.h> 14 #include <linux/module.h> 15 #include <linux/types.h> 16 #include <linux/sched.h> 17 #include <linux/kernel.h> 18 #include <linux/skbuff.h> 19 #include <linux/netdevice.h> 20 #include <linux/in.h> 21 #include <linux/if_arp.h> 22 #include <linux/init.h> 23 #include <linux/random.h> 24 #include <net/checksum.h> 25 26 #include <net/inet_common.h> 27 #include <net/ip.h> 28 #include <net/protocol.h> 29 #include <net/sock.h> 30 #include <net/xfrm.h> 31 32 #include <asm/semaphore.h> 33 #include <linux/spinlock.h> 34 #include <linux/timer.h> 35 #include <linux/delay.h> 36 #include <linux/poll.h> 37 #include <linux/dccp.h> 38 39 #include "ccid.h" 40 #include "dccp.h" 41 42 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly; 43 44 atomic_t dccp_orphan_count = ATOMIC_INIT(0); 45 46 static struct net_protocol dccp_protocol = { 47 .handler = dccp_v4_rcv, 48 .err_handler = dccp_v4_err, 49 }; 50 51 const char *dccp_packet_name(const int type) 52 { 53 static const char *dccp_packet_names[] = { 54 [DCCP_PKT_REQUEST] = "REQUEST", 55 [DCCP_PKT_RESPONSE] = "RESPONSE", 56 [DCCP_PKT_DATA] = "DATA", 57 [DCCP_PKT_ACK] = "ACK", 58 [DCCP_PKT_DATAACK] = "DATAACK", 59 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ", 60 [DCCP_PKT_CLOSE] = "CLOSE", 61 [DCCP_PKT_RESET] = "RESET", 62 [DCCP_PKT_SYNC] = "SYNC", 63 [DCCP_PKT_SYNCACK] = "SYNCACK", 64 }; 65 66 if (type >= DCCP_NR_PKT_TYPES) 67 return "INVALID"; 68 else 69 return dccp_packet_names[type]; 70 } 71 72 EXPORT_SYMBOL_GPL(dccp_packet_name); 73 74 const char *dccp_state_name(const int state) 75 { 76 static char *dccp_state_names[] = { 77 [DCCP_OPEN] = "OPEN", 78 [DCCP_REQUESTING] = "REQUESTING", 79 [DCCP_PARTOPEN] = "PARTOPEN", 80 [DCCP_LISTEN] = "LISTEN", 81 [DCCP_RESPOND] = "RESPOND", 82 [DCCP_CLOSING] = "CLOSING", 83 [DCCP_TIME_WAIT] = "TIME_WAIT", 84 [DCCP_CLOSED] = "CLOSED", 85 }; 86 87 if (state >= DCCP_MAX_STATES) 88 return "INVALID STATE!"; 89 else 90 return dccp_state_names[state]; 91 } 92 93 EXPORT_SYMBOL_GPL(dccp_state_name); 94 95 static inline int dccp_listen_start(struct sock *sk) 96 { 97 struct dccp_sock *dp = dccp_sk(sk); 98 99 dp->dccps_role = DCCP_ROLE_LISTEN; 100 /* 101 * Apps need to use setsockopt(DCCP_SOCKOPT_SERVICE) 102 * before calling listen() 103 */ 104 if (dccp_service_not_initialized(sk)) 105 return -EPROTO; 106 return inet_csk_listen_start(sk, TCP_SYNQ_HSIZE); 107 } 108 109 int dccp_disconnect(struct sock *sk, int flags) 110 { 111 struct inet_connection_sock *icsk = inet_csk(sk); 112 struct inet_sock *inet = inet_sk(sk); 113 int err = 0; 114 const int old_state = sk->sk_state; 115 116 if (old_state != DCCP_CLOSED) 117 dccp_set_state(sk, DCCP_CLOSED); 118 119 /* ABORT function of RFC793 */ 120 if (old_state == DCCP_LISTEN) { 121 inet_csk_listen_stop(sk); 122 /* FIXME: do the active reset thing */ 123 } else if (old_state == DCCP_REQUESTING) 124 sk->sk_err = ECONNRESET; 125 126 dccp_clear_xmit_timers(sk); 127 __skb_queue_purge(&sk->sk_receive_queue); 128 if (sk->sk_send_head != NULL) { 129 __kfree_skb(sk->sk_send_head); 130 sk->sk_send_head = NULL; 131 } 132 133 inet->dport = 0; 134 135 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) 136 inet_reset_saddr(sk); 137 138 sk->sk_shutdown = 0; 139 sock_reset_flag(sk, SOCK_DONE); 140 141 icsk->icsk_backoff = 0; 142 inet_csk_delack_init(sk); 143 __sk_dst_reset(sk); 144 145 BUG_TRAP(!inet->num || icsk->icsk_bind_hash); 146 147 sk->sk_error_report(sk); 148 return err; 149 } 150 151 /* 152 * Wait for a DCCP event. 153 * 154 * Note that we don't need to lock the socket, as the upper poll layers 155 * take care of normal races (between the test and the event) and we don't 156 * go look at any of the socket buffers directly. 157 */ 158 static unsigned int dccp_poll(struct file *file, struct socket *sock, 159 poll_table *wait) 160 { 161 unsigned int mask; 162 struct sock *sk = sock->sk; 163 164 poll_wait(file, sk->sk_sleep, wait); 165 if (sk->sk_state == DCCP_LISTEN) 166 return inet_csk_listen_poll(sk); 167 168 /* Socket is not locked. We are protected from async events 169 by poll logic and correct handling of state changes 170 made by another threads is impossible in any case. 171 */ 172 173 mask = 0; 174 if (sk->sk_err) 175 mask = POLLERR; 176 177 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED) 178 mask |= POLLHUP; 179 if (sk->sk_shutdown & RCV_SHUTDOWN) 180 mask |= POLLIN | POLLRDNORM; 181 182 /* Connected? */ 183 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) { 184 if (atomic_read(&sk->sk_rmem_alloc) > 0) 185 mask |= POLLIN | POLLRDNORM; 186 187 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) { 188 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 189 mask |= POLLOUT | POLLWRNORM; 190 } else { /* send SIGIO later */ 191 set_bit(SOCK_ASYNC_NOSPACE, 192 &sk->sk_socket->flags); 193 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 194 195 /* Race breaker. If space is freed after 196 * wspace test but before the flags are set, 197 * IO signal will be lost. 198 */ 199 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) 200 mask |= POLLOUT | POLLWRNORM; 201 } 202 } 203 } 204 return mask; 205 } 206 207 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg) 208 { 209 dccp_pr_debug("entry\n"); 210 return -ENOIOCTLCMD; 211 } 212 213 static int dccp_setsockopt_service(struct sock *sk, const u32 service, 214 char __user *optval, int optlen) 215 { 216 struct dccp_sock *dp = dccp_sk(sk); 217 struct dccp_service_list *sl = NULL; 218 219 if (service == DCCP_SERVICE_INVALID_VALUE || 220 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32)) 221 return -EINVAL; 222 223 if (optlen > sizeof(service)) { 224 sl = kmalloc(optlen, GFP_KERNEL); 225 if (sl == NULL) 226 return -ENOMEM; 227 228 sl->dccpsl_nr = optlen / sizeof(u32) - 1; 229 if (copy_from_user(sl->dccpsl_list, 230 optval + sizeof(service), 231 optlen - sizeof(service)) || 232 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) { 233 kfree(sl); 234 return -EFAULT; 235 } 236 } 237 238 lock_sock(sk); 239 dp->dccps_service = service; 240 241 if (dp->dccps_service_list != NULL) 242 kfree(dp->dccps_service_list); 243 244 dp->dccps_service_list = sl; 245 release_sock(sk); 246 return 0; 247 } 248 249 int dccp_setsockopt(struct sock *sk, int level, int optname, 250 char __user *optval, int optlen) 251 { 252 struct dccp_sock *dp; 253 int err; 254 int val; 255 256 if (level != SOL_DCCP) 257 return ip_setsockopt(sk, level, optname, optval, optlen); 258 259 if (optlen < sizeof(int)) 260 return -EINVAL; 261 262 if (get_user(val, (int __user *)optval)) 263 return -EFAULT; 264 265 if (optname == DCCP_SOCKOPT_SERVICE) 266 return dccp_setsockopt_service(sk, val, optval, optlen); 267 268 lock_sock(sk); 269 dp = dccp_sk(sk); 270 err = 0; 271 272 switch (optname) { 273 case DCCP_SOCKOPT_PACKET_SIZE: 274 dp->dccps_packet_size = val; 275 break; 276 default: 277 err = -ENOPROTOOPT; 278 break; 279 } 280 281 release_sock(sk); 282 return err; 283 } 284 285 static int dccp_getsockopt_service(struct sock *sk, int len, 286 u32 __user *optval, 287 int __user *optlen) 288 { 289 const struct dccp_sock *dp = dccp_sk(sk); 290 const struct dccp_service_list *sl; 291 int err = -ENOENT, slen = 0, total_len = sizeof(u32); 292 293 lock_sock(sk); 294 if (dccp_service_not_initialized(sk)) 295 goto out; 296 297 if ((sl = dp->dccps_service_list) != NULL) { 298 slen = sl->dccpsl_nr * sizeof(u32); 299 total_len += slen; 300 } 301 302 err = -EINVAL; 303 if (total_len > len) 304 goto out; 305 306 err = 0; 307 if (put_user(total_len, optlen) || 308 put_user(dp->dccps_service, optval) || 309 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen))) 310 err = -EFAULT; 311 out: 312 release_sock(sk); 313 return err; 314 } 315 316 int dccp_getsockopt(struct sock *sk, int level, int optname, 317 char __user *optval, int __user *optlen) 318 { 319 struct dccp_sock *dp; 320 int val, len; 321 322 if (level != SOL_DCCP) 323 return ip_getsockopt(sk, level, optname, optval, optlen); 324 325 if (get_user(len, optlen)) 326 return -EFAULT; 327 328 if (len < sizeof(int)) 329 return -EINVAL; 330 331 dp = dccp_sk(sk); 332 333 switch (optname) { 334 case DCCP_SOCKOPT_PACKET_SIZE: 335 val = dp->dccps_packet_size; 336 len = sizeof(dp->dccps_packet_size); 337 break; 338 case DCCP_SOCKOPT_SERVICE: 339 return dccp_getsockopt_service(sk, len, 340 (u32 __user *)optval, optlen); 341 case 128 ... 191: 342 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname, 343 len, (u32 __user *)optval, optlen); 344 case 192 ... 255: 345 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname, 346 len, (u32 __user *)optval, optlen); 347 default: 348 return -ENOPROTOOPT; 349 } 350 351 if (put_user(len, optlen) || copy_to_user(optval, &val, len)) 352 return -EFAULT; 353 354 return 0; 355 } 356 357 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 358 size_t len) 359 { 360 const struct dccp_sock *dp = dccp_sk(sk); 361 const int flags = msg->msg_flags; 362 const int noblock = flags & MSG_DONTWAIT; 363 struct sk_buff *skb; 364 int rc, size; 365 long timeo; 366 367 if (len > dp->dccps_mss_cache) 368 return -EMSGSIZE; 369 370 lock_sock(sk); 371 timeo = sock_sndtimeo(sk, noblock); 372 373 /* 374 * We have to use sk_stream_wait_connect here to set sk_write_pending, 375 * so that the trick in dccp_rcv_request_sent_state_process. 376 */ 377 /* Wait for a connection to finish. */ 378 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING)) 379 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0) 380 goto out_release; 381 382 size = sk->sk_prot->max_header + len; 383 release_sock(sk); 384 skb = sock_alloc_send_skb(sk, size, noblock, &rc); 385 lock_sock(sk); 386 if (skb == NULL) 387 goto out_release; 388 389 skb_reserve(skb, sk->sk_prot->max_header); 390 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len); 391 if (rc != 0) 392 goto out_discard; 393 394 rc = dccp_write_xmit(sk, skb, &timeo); 395 /* 396 * XXX we don't use sk_write_queue, so just discard the packet. 397 * Current plan however is to _use_ sk_write_queue with 398 * an algorith similar to tcp_sendmsg, where the main difference 399 * is that in DCCP we have to respect packet boundaries, so 400 * no coalescing of skbs. 401 * 402 * This bug was _quickly_ found & fixed by just looking at an OSTRA 403 * generated callgraph 8) -acme 404 */ 405 out_release: 406 release_sock(sk); 407 return rc ? : len; 408 out_discard: 409 kfree_skb(skb); 410 goto out_release; 411 } 412 413 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 414 size_t len, int nonblock, int flags, int *addr_len) 415 { 416 const struct dccp_hdr *dh; 417 long timeo; 418 419 lock_sock(sk); 420 421 if (sk->sk_state == DCCP_LISTEN) { 422 len = -ENOTCONN; 423 goto out; 424 } 425 426 timeo = sock_rcvtimeo(sk, nonblock); 427 428 do { 429 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); 430 431 if (skb == NULL) 432 goto verify_sock_status; 433 434 dh = dccp_hdr(skb); 435 436 if (dh->dccph_type == DCCP_PKT_DATA || 437 dh->dccph_type == DCCP_PKT_DATAACK) 438 goto found_ok_skb; 439 440 if (dh->dccph_type == DCCP_PKT_RESET || 441 dh->dccph_type == DCCP_PKT_CLOSE) { 442 dccp_pr_debug("found fin ok!\n"); 443 len = 0; 444 goto found_fin_ok; 445 } 446 dccp_pr_debug("packet_type=%s\n", 447 dccp_packet_name(dh->dccph_type)); 448 sk_eat_skb(sk, skb); 449 verify_sock_status: 450 if (sock_flag(sk, SOCK_DONE)) { 451 len = 0; 452 break; 453 } 454 455 if (sk->sk_err) { 456 len = sock_error(sk); 457 break; 458 } 459 460 if (sk->sk_shutdown & RCV_SHUTDOWN) { 461 len = 0; 462 break; 463 } 464 465 if (sk->sk_state == DCCP_CLOSED) { 466 if (!sock_flag(sk, SOCK_DONE)) { 467 /* This occurs when user tries to read 468 * from never connected socket. 469 */ 470 len = -ENOTCONN; 471 break; 472 } 473 len = 0; 474 break; 475 } 476 477 if (!timeo) { 478 len = -EAGAIN; 479 break; 480 } 481 482 if (signal_pending(current)) { 483 len = sock_intr_errno(timeo); 484 break; 485 } 486 487 sk_wait_data(sk, &timeo); 488 continue; 489 found_ok_skb: 490 if (len > skb->len) 491 len = skb->len; 492 else if (len < skb->len) 493 msg->msg_flags |= MSG_TRUNC; 494 495 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) { 496 /* Exception. Bailout! */ 497 len = -EFAULT; 498 break; 499 } 500 found_fin_ok: 501 if (!(flags & MSG_PEEK)) 502 sk_eat_skb(sk, skb); 503 break; 504 } while (1); 505 out: 506 release_sock(sk); 507 return len; 508 } 509 510 static int inet_dccp_listen(struct socket *sock, int backlog) 511 { 512 struct sock *sk = sock->sk; 513 unsigned char old_state; 514 int err; 515 516 lock_sock(sk); 517 518 err = -EINVAL; 519 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP) 520 goto out; 521 522 old_state = sk->sk_state; 523 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN))) 524 goto out; 525 526 /* Really, if the socket is already in listen state 527 * we can only allow the backlog to be adjusted. 528 */ 529 if (old_state != DCCP_LISTEN) { 530 /* 531 * FIXME: here it probably should be sk->sk_prot->listen_start 532 * see tcp_listen_start 533 */ 534 err = dccp_listen_start(sk); 535 if (err) 536 goto out; 537 } 538 sk->sk_max_ack_backlog = backlog; 539 err = 0; 540 541 out: 542 release_sock(sk); 543 return err; 544 } 545 546 static const unsigned char dccp_new_state[] = { 547 /* current state: new state: action: */ 548 [0] = DCCP_CLOSED, 549 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN, 550 [DCCP_REQUESTING] = DCCP_CLOSED, 551 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN, 552 [DCCP_LISTEN] = DCCP_CLOSED, 553 [DCCP_RESPOND] = DCCP_CLOSED, 554 [DCCP_CLOSING] = DCCP_CLOSED, 555 [DCCP_TIME_WAIT] = DCCP_CLOSED, 556 [DCCP_CLOSED] = DCCP_CLOSED, 557 }; 558 559 static int dccp_close_state(struct sock *sk) 560 { 561 const int next = dccp_new_state[sk->sk_state]; 562 const int ns = next & DCCP_STATE_MASK; 563 564 if (ns != sk->sk_state) 565 dccp_set_state(sk, ns); 566 567 return next & DCCP_ACTION_FIN; 568 } 569 570 void dccp_close(struct sock *sk, long timeout) 571 { 572 struct sk_buff *skb; 573 574 lock_sock(sk); 575 576 sk->sk_shutdown = SHUTDOWN_MASK; 577 578 if (sk->sk_state == DCCP_LISTEN) { 579 dccp_set_state(sk, DCCP_CLOSED); 580 581 /* Special case. */ 582 inet_csk_listen_stop(sk); 583 584 goto adjudge_to_death; 585 } 586 587 /* 588 * We need to flush the recv. buffs. We do this only on the 589 * descriptor close, not protocol-sourced closes, because the 590 *reader process may not have drained the data yet! 591 */ 592 /* FIXME: check for unread data */ 593 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) { 594 __kfree_skb(skb); 595 } 596 597 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) { 598 /* Check zero linger _after_ checking for unread data. */ 599 sk->sk_prot->disconnect(sk, 0); 600 } else if (dccp_close_state(sk)) { 601 dccp_send_close(sk, 1); 602 } 603 604 sk_stream_wait_close(sk, timeout); 605 606 adjudge_to_death: 607 /* 608 * It is the last release_sock in its life. It will remove backlog. 609 */ 610 release_sock(sk); 611 /* 612 * Now socket is owned by kernel and we acquire BH lock 613 * to finish close. No need to check for user refs. 614 */ 615 local_bh_disable(); 616 bh_lock_sock(sk); 617 BUG_TRAP(!sock_owned_by_user(sk)); 618 619 sock_hold(sk); 620 sock_orphan(sk); 621 622 /* 623 * The last release_sock may have processed the CLOSE or RESET 624 * packet moving sock to CLOSED state, if not we have to fire 625 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination" 626 * in draft-ietf-dccp-spec-11. -acme 627 */ 628 if (sk->sk_state == DCCP_CLOSING) { 629 /* FIXME: should start at 2 * RTT */ 630 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */ 631 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, 632 inet_csk(sk)->icsk_rto, 633 DCCP_RTO_MAX); 634 #if 0 635 /* Yeah, we should use sk->sk_prot->orphan_count, etc */ 636 dccp_set_state(sk, DCCP_CLOSED); 637 #endif 638 } 639 640 atomic_inc(sk->sk_prot->orphan_count); 641 if (sk->sk_state == DCCP_CLOSED) 642 inet_csk_destroy_sock(sk); 643 644 /* Otherwise, socket is reprieved until protocol close. */ 645 646 bh_unlock_sock(sk); 647 local_bh_enable(); 648 sock_put(sk); 649 } 650 651 void dccp_shutdown(struct sock *sk, int how) 652 { 653 dccp_pr_debug("entry\n"); 654 } 655 656 static struct proto_ops inet_dccp_ops = { 657 .family = PF_INET, 658 .owner = THIS_MODULE, 659 .release = inet_release, 660 .bind = inet_bind, 661 .connect = inet_stream_connect, 662 .socketpair = sock_no_socketpair, 663 .accept = inet_accept, 664 .getname = inet_getname, 665 /* FIXME: work on tcp_poll to rename it to inet_csk_poll */ 666 .poll = dccp_poll, 667 .ioctl = inet_ioctl, 668 /* FIXME: work on inet_listen to rename it to sock_common_listen */ 669 .listen = inet_dccp_listen, 670 .shutdown = inet_shutdown, 671 .setsockopt = sock_common_setsockopt, 672 .getsockopt = sock_common_getsockopt, 673 .sendmsg = inet_sendmsg, 674 .recvmsg = sock_common_recvmsg, 675 .mmap = sock_no_mmap, 676 .sendpage = sock_no_sendpage, 677 }; 678 679 extern struct net_proto_family inet_family_ops; 680 681 static struct inet_protosw dccp_v4_protosw = { 682 .type = SOCK_DCCP, 683 .protocol = IPPROTO_DCCP, 684 .prot = &dccp_v4_prot, 685 .ops = &inet_dccp_ops, 686 .capability = -1, 687 .no_check = 0, 688 .flags = 0, 689 }; 690 691 /* 692 * This is the global socket data structure used for responding to 693 * the Out-of-the-blue (OOTB) packets. A control sock will be created 694 * for this socket at the initialization time. 695 */ 696 struct socket *dccp_ctl_socket; 697 698 static char dccp_ctl_socket_err_msg[] __initdata = 699 KERN_ERR "DCCP: Failed to create the control socket.\n"; 700 701 static int __init dccp_ctl_sock_init(void) 702 { 703 int rc = sock_create_kern(PF_INET, SOCK_DCCP, IPPROTO_DCCP, 704 &dccp_ctl_socket); 705 if (rc < 0) 706 printk(dccp_ctl_socket_err_msg); 707 else { 708 dccp_ctl_socket->sk->sk_allocation = GFP_ATOMIC; 709 inet_sk(dccp_ctl_socket->sk)->uc_ttl = -1; 710 711 /* Unhash it so that IP input processing does not even 712 * see it, we do not wish this socket to see incoming 713 * packets. 714 */ 715 dccp_ctl_socket->sk->sk_prot->unhash(dccp_ctl_socket->sk); 716 } 717 718 return rc; 719 } 720 721 #ifdef CONFIG_IP_DCCP_UNLOAD_HACK 722 void dccp_ctl_sock_exit(void) 723 { 724 if (dccp_ctl_socket != NULL) { 725 sock_release(dccp_ctl_socket); 726 dccp_ctl_socket = NULL; 727 } 728 } 729 730 EXPORT_SYMBOL_GPL(dccp_ctl_sock_exit); 731 #endif 732 733 static int __init init_dccp_v4_mibs(void) 734 { 735 int rc = -ENOMEM; 736 737 dccp_statistics[0] = alloc_percpu(struct dccp_mib); 738 if (dccp_statistics[0] == NULL) 739 goto out; 740 741 dccp_statistics[1] = alloc_percpu(struct dccp_mib); 742 if (dccp_statistics[1] == NULL) 743 goto out_free_one; 744 745 rc = 0; 746 out: 747 return rc; 748 out_free_one: 749 free_percpu(dccp_statistics[0]); 750 dccp_statistics[0] = NULL; 751 goto out; 752 753 } 754 755 static int thash_entries; 756 module_param(thash_entries, int, 0444); 757 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets"); 758 759 #ifdef CONFIG_IP_DCCP_DEBUG 760 int dccp_debug; 761 module_param(dccp_debug, int, 0444); 762 MODULE_PARM_DESC(dccp_debug, "Enable debug messages"); 763 #endif 764 765 static int __init dccp_init(void) 766 { 767 unsigned long goal; 768 int ehash_order, bhash_order, i; 769 int rc = proto_register(&dccp_v4_prot, 1); 770 771 if (rc) 772 goto out; 773 774 dccp_hashinfo.bind_bucket_cachep = 775 kmem_cache_create("dccp_bind_bucket", 776 sizeof(struct inet_bind_bucket), 0, 777 SLAB_HWCACHE_ALIGN, NULL, NULL); 778 if (!dccp_hashinfo.bind_bucket_cachep) 779 goto out_proto_unregister; 780 781 /* 782 * Size and allocate the main established and bind bucket 783 * hash tables. 784 * 785 * The methodology is similar to that of the buffer cache. 786 */ 787 if (num_physpages >= (128 * 1024)) 788 goal = num_physpages >> (21 - PAGE_SHIFT); 789 else 790 goal = num_physpages >> (23 - PAGE_SHIFT); 791 792 if (thash_entries) 793 goal = (thash_entries * 794 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT; 795 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++) 796 ; 797 do { 798 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE / 799 sizeof(struct inet_ehash_bucket); 800 dccp_hashinfo.ehash_size >>= 1; 801 while (dccp_hashinfo.ehash_size & 802 (dccp_hashinfo.ehash_size - 1)) 803 dccp_hashinfo.ehash_size--; 804 dccp_hashinfo.ehash = (struct inet_ehash_bucket *) 805 __get_free_pages(GFP_ATOMIC, ehash_order); 806 } while (!dccp_hashinfo.ehash && --ehash_order > 0); 807 808 if (!dccp_hashinfo.ehash) { 809 printk(KERN_CRIT "Failed to allocate DCCP " 810 "established hash table\n"); 811 goto out_free_bind_bucket_cachep; 812 } 813 814 for (i = 0; i < (dccp_hashinfo.ehash_size << 1); i++) { 815 rwlock_init(&dccp_hashinfo.ehash[i].lock); 816 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain); 817 } 818 819 bhash_order = ehash_order; 820 821 do { 822 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE / 823 sizeof(struct inet_bind_hashbucket); 824 if ((dccp_hashinfo.bhash_size > (64 * 1024)) && 825 bhash_order > 0) 826 continue; 827 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *) 828 __get_free_pages(GFP_ATOMIC, bhash_order); 829 } while (!dccp_hashinfo.bhash && --bhash_order >= 0); 830 831 if (!dccp_hashinfo.bhash) { 832 printk(KERN_CRIT "Failed to allocate DCCP bind hash table\n"); 833 goto out_free_dccp_ehash; 834 } 835 836 for (i = 0; i < dccp_hashinfo.bhash_size; i++) { 837 spin_lock_init(&dccp_hashinfo.bhash[i].lock); 838 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain); 839 } 840 841 if (init_dccp_v4_mibs()) 842 goto out_free_dccp_bhash; 843 844 rc = -EAGAIN; 845 if (inet_add_protocol(&dccp_protocol, IPPROTO_DCCP)) 846 goto out_free_dccp_v4_mibs; 847 848 inet_register_protosw(&dccp_v4_protosw); 849 850 rc = dccp_ctl_sock_init(); 851 if (rc) 852 goto out_unregister_protosw; 853 out: 854 return rc; 855 out_unregister_protosw: 856 inet_unregister_protosw(&dccp_v4_protosw); 857 inet_del_protocol(&dccp_protocol, IPPROTO_DCCP); 858 out_free_dccp_v4_mibs: 859 free_percpu(dccp_statistics[0]); 860 free_percpu(dccp_statistics[1]); 861 dccp_statistics[0] = dccp_statistics[1] = NULL; 862 out_free_dccp_bhash: 863 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order); 864 dccp_hashinfo.bhash = NULL; 865 out_free_dccp_ehash: 866 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order); 867 dccp_hashinfo.ehash = NULL; 868 out_free_bind_bucket_cachep: 869 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); 870 dccp_hashinfo.bind_bucket_cachep = NULL; 871 out_proto_unregister: 872 proto_unregister(&dccp_v4_prot); 873 goto out; 874 } 875 876 static const char dccp_del_proto_err_msg[] __exitdata = 877 KERN_ERR "can't remove dccp net_protocol\n"; 878 879 static void __exit dccp_fini(void) 880 { 881 inet_unregister_protosw(&dccp_v4_protosw); 882 883 if (inet_del_protocol(&dccp_protocol, IPPROTO_DCCP) < 0) 884 printk(dccp_del_proto_err_msg); 885 886 free_percpu(dccp_statistics[0]); 887 free_percpu(dccp_statistics[1]); 888 free_pages((unsigned long)dccp_hashinfo.bhash, 889 get_order(dccp_hashinfo.bhash_size * 890 sizeof(struct inet_bind_hashbucket))); 891 free_pages((unsigned long)dccp_hashinfo.ehash, 892 get_order(dccp_hashinfo.ehash_size * 893 sizeof(struct inet_ehash_bucket))); 894 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); 895 proto_unregister(&dccp_v4_prot); 896 } 897 898 module_init(dccp_init); 899 module_exit(dccp_fini); 900 901 /* 902 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33) 903 * values directly, Also cover the case where the protocol is not specified, 904 * i.e. net-pf-PF_INET-proto-0-type-SOCK_DCCP 905 */ 906 MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-33-type-6"); 907 MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-0-type-6"); 908 MODULE_LICENSE("GPL"); 909 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>"); 910 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol"); 911