4 * An implementation of the DCCP protocol
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
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.
12 #include <linux/dccp.h>
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/skbuff.h>
18 #include <linux/netdevice.h>
20 #include <linux/if_arp.h>
21 #include <linux/init.h>
22 #include <linux/random.h>
23 #include <net/checksum.h>
25 #include <net/inet_sock.h>
29 #include <asm/semaphore.h>
30 #include <linux/spinlock.h>
31 #include <linux/timer.h>
32 #include <linux/delay.h>
33 #include <linux/poll.h>
39 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
41 EXPORT_SYMBOL_GPL(dccp_statistics);
43 atomic_t dccp_orphan_count = ATOMIC_INIT(0);
45 EXPORT_SYMBOL_GPL(dccp_orphan_count);
47 struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
48 .lhash_lock = RW_LOCK_UNLOCKED,
49 .lhash_users = ATOMIC_INIT(0),
50 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
53 EXPORT_SYMBOL_GPL(dccp_hashinfo);
55 void dccp_set_state(struct sock *sk, const int state)
57 const int oldstate = sk->sk_state;
59 dccp_pr_debug("%s(%p) %-10.10s -> %s\n",
61 dccp_state_name(oldstate), dccp_state_name(state));
62 WARN_ON(state == oldstate);
66 if (oldstate != DCCP_OPEN)
67 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
71 if (oldstate == DCCP_CLOSING || oldstate == DCCP_OPEN)
72 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
74 sk->sk_prot->unhash(sk);
75 if (inet_csk(sk)->icsk_bind_hash != NULL &&
76 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
77 inet_put_port(&dccp_hashinfo, sk);
80 if (oldstate == DCCP_OPEN)
81 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
84 /* Change state AFTER socket is unhashed to avoid closed
85 * socket sitting in hash tables.
90 EXPORT_SYMBOL_GPL(dccp_set_state);
92 void dccp_done(struct sock *sk)
94 dccp_set_state(sk, DCCP_CLOSED);
95 dccp_clear_xmit_timers(sk);
97 sk->sk_shutdown = SHUTDOWN_MASK;
99 if (!sock_flag(sk, SOCK_DEAD))
100 sk->sk_state_change(sk);
102 inet_csk_destroy_sock(sk);
105 EXPORT_SYMBOL_GPL(dccp_done);
107 const char *dccp_packet_name(const int type)
109 static const char *dccp_packet_names[] = {
110 [DCCP_PKT_REQUEST] = "REQUEST",
111 [DCCP_PKT_RESPONSE] = "RESPONSE",
112 [DCCP_PKT_DATA] = "DATA",
113 [DCCP_PKT_ACK] = "ACK",
114 [DCCP_PKT_DATAACK] = "DATAACK",
115 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
116 [DCCP_PKT_CLOSE] = "CLOSE",
117 [DCCP_PKT_RESET] = "RESET",
118 [DCCP_PKT_SYNC] = "SYNC",
119 [DCCP_PKT_SYNCACK] = "SYNCACK",
122 if (type >= DCCP_NR_PKT_TYPES)
125 return dccp_packet_names[type];
128 EXPORT_SYMBOL_GPL(dccp_packet_name);
130 const char *dccp_state_name(const int state)
132 static char *dccp_state_names[] = {
133 [DCCP_OPEN] = "OPEN",
134 [DCCP_REQUESTING] = "REQUESTING",
135 [DCCP_PARTOPEN] = "PARTOPEN",
136 [DCCP_LISTEN] = "LISTEN",
137 [DCCP_RESPOND] = "RESPOND",
138 [DCCP_CLOSING] = "CLOSING",
139 [DCCP_TIME_WAIT] = "TIME_WAIT",
140 [DCCP_CLOSED] = "CLOSED",
143 if (state >= DCCP_MAX_STATES)
144 return "INVALID STATE!";
146 return dccp_state_names[state];
149 EXPORT_SYMBOL_GPL(dccp_state_name);
151 void dccp_hash(struct sock *sk)
153 inet_hash(&dccp_hashinfo, sk);
156 EXPORT_SYMBOL_GPL(dccp_hash);
158 void dccp_unhash(struct sock *sk)
160 inet_unhash(&dccp_hashinfo, sk);
163 EXPORT_SYMBOL_GPL(dccp_unhash);
165 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
167 struct dccp_sock *dp = dccp_sk(sk);
168 struct dccp_minisock *dmsk = dccp_msk(sk);
169 struct inet_connection_sock *icsk = inet_csk(sk);
171 dccp_minisock_init(&dp->dccps_minisock);
172 do_gettimeofday(&dp->dccps_epoch);
175 * FIXME: We're hardcoding the CCID, and doing this at this point makes
176 * the listening (master) sock get CCID control blocks, which is not
177 * necessary, but for now, to not mess with the test userspace apps,
178 * lets leave it here, later the real solution is to do this in a
179 * setsockopt(CCIDs-I-want/accept). -acme
181 if (likely(ctl_sock_initialized)) {
182 int rc = dccp_feat_init(dmsk);
187 if (dmsk->dccpms_send_ack_vector) {
188 dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
189 if (dp->dccps_hc_rx_ackvec == NULL)
192 dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
194 dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
196 if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
197 dp->dccps_hc_tx_ccid == NULL)) {
198 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
199 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
200 if (dmsk->dccpms_send_ack_vector) {
201 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
202 dp->dccps_hc_rx_ackvec = NULL;
204 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
208 /* control socket doesn't need feat nego */
209 INIT_LIST_HEAD(&dmsk->dccpms_pending);
210 INIT_LIST_HEAD(&dmsk->dccpms_conf);
213 dccp_init_xmit_timers(sk);
214 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
215 sk->sk_state = DCCP_CLOSED;
216 sk->sk_write_space = dccp_write_space;
217 icsk->icsk_sync_mss = dccp_sync_mss;
218 dp->dccps_mss_cache = 536;
219 dp->dccps_role = DCCP_ROLE_UNDEFINED;
220 dp->dccps_service = DCCP_SERVICE_INVALID_VALUE;
221 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
226 EXPORT_SYMBOL_GPL(dccp_init_sock);
228 int dccp_destroy_sock(struct sock *sk)
230 struct dccp_sock *dp = dccp_sk(sk);
231 struct dccp_minisock *dmsk = dccp_msk(sk);
234 * DCCP doesn't use sk_write_queue, just sk_send_head
235 * for retransmissions
237 if (sk->sk_send_head != NULL) {
238 kfree_skb(sk->sk_send_head);
239 sk->sk_send_head = NULL;
242 /* Clean up a referenced DCCP bind bucket. */
243 if (inet_csk(sk)->icsk_bind_hash != NULL)
244 inet_put_port(&dccp_hashinfo, sk);
246 kfree(dp->dccps_service_list);
247 dp->dccps_service_list = NULL;
249 if (dmsk->dccpms_send_ack_vector) {
250 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
251 dp->dccps_hc_rx_ackvec = NULL;
253 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
254 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
255 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
257 /* clean up feature negotiation state */
258 dccp_feat_clean(dmsk);
263 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
265 static inline int dccp_listen_start(struct sock *sk)
267 struct dccp_sock *dp = dccp_sk(sk);
269 dp->dccps_role = DCCP_ROLE_LISTEN;
271 * Apps need to use setsockopt(DCCP_SOCKOPT_SERVICE)
272 * before calling listen()
274 if (dccp_service_not_initialized(sk))
276 return inet_csk_listen_start(sk, TCP_SYNQ_HSIZE);
279 int dccp_disconnect(struct sock *sk, int flags)
281 struct inet_connection_sock *icsk = inet_csk(sk);
282 struct inet_sock *inet = inet_sk(sk);
284 const int old_state = sk->sk_state;
286 if (old_state != DCCP_CLOSED)
287 dccp_set_state(sk, DCCP_CLOSED);
289 /* ABORT function of RFC793 */
290 if (old_state == DCCP_LISTEN) {
291 inet_csk_listen_stop(sk);
292 /* FIXME: do the active reset thing */
293 } else if (old_state == DCCP_REQUESTING)
294 sk->sk_err = ECONNRESET;
296 dccp_clear_xmit_timers(sk);
297 __skb_queue_purge(&sk->sk_receive_queue);
298 if (sk->sk_send_head != NULL) {
299 __kfree_skb(sk->sk_send_head);
300 sk->sk_send_head = NULL;
305 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
306 inet_reset_saddr(sk);
309 sock_reset_flag(sk, SOCK_DONE);
311 icsk->icsk_backoff = 0;
312 inet_csk_delack_init(sk);
315 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
317 sk->sk_error_report(sk);
321 EXPORT_SYMBOL_GPL(dccp_disconnect);
324 * Wait for a DCCP event.
326 * Note that we don't need to lock the socket, as the upper poll layers
327 * take care of normal races (between the test and the event) and we don't
328 * go look at any of the socket buffers directly.
330 unsigned int dccp_poll(struct file *file, struct socket *sock,
334 struct sock *sk = sock->sk;
336 poll_wait(file, sk->sk_sleep, wait);
337 if (sk->sk_state == DCCP_LISTEN)
338 return inet_csk_listen_poll(sk);
340 /* Socket is not locked. We are protected from async events
341 by poll logic and correct handling of state changes
342 made by another threads is impossible in any case.
349 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
351 if (sk->sk_shutdown & RCV_SHUTDOWN)
352 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
355 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
356 if (atomic_read(&sk->sk_rmem_alloc) > 0)
357 mask |= POLLIN | POLLRDNORM;
359 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
360 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
361 mask |= POLLOUT | POLLWRNORM;
362 } else { /* send SIGIO later */
363 set_bit(SOCK_ASYNC_NOSPACE,
364 &sk->sk_socket->flags);
365 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
367 /* Race breaker. If space is freed after
368 * wspace test but before the flags are set,
369 * IO signal will be lost.
371 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
372 mask |= POLLOUT | POLLWRNORM;
379 EXPORT_SYMBOL_GPL(dccp_poll);
381 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
383 dccp_pr_debug("entry\n");
387 EXPORT_SYMBOL_GPL(dccp_ioctl);
389 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
390 char __user *optval, int optlen)
392 struct dccp_sock *dp = dccp_sk(sk);
393 struct dccp_service_list *sl = NULL;
395 if (service == DCCP_SERVICE_INVALID_VALUE ||
396 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
399 if (optlen > sizeof(service)) {
400 sl = kmalloc(optlen, GFP_KERNEL);
404 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
405 if (copy_from_user(sl->dccpsl_list,
406 optval + sizeof(service),
407 optlen - sizeof(service)) ||
408 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
415 dp->dccps_service = service;
417 kfree(dp->dccps_service_list);
419 dp->dccps_service_list = sl;
424 /* byte 1 is feature. the rest is the preference list */
425 static int dccp_setsockopt_change(struct sock *sk, int type,
426 struct dccp_so_feat __user *optval)
428 struct dccp_so_feat opt;
432 if (copy_from_user(&opt, optval, sizeof(opt)))
435 val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
439 if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
444 rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
445 val, opt.dccpsf_len, GFP_KERNEL);
457 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
458 char __user *optval, int optlen)
460 struct dccp_sock *dp;
464 if (optlen < sizeof(int))
467 if (get_user(val, (int __user *)optval))
470 if (optname == DCCP_SOCKOPT_SERVICE)
471 return dccp_setsockopt_service(sk, val, optval, optlen);
478 case DCCP_SOCKOPT_PACKET_SIZE:
479 dp->dccps_packet_size = val;
482 case DCCP_SOCKOPT_CHANGE_L:
483 if (optlen != sizeof(struct dccp_so_feat))
486 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
487 (struct dccp_so_feat __user *)
491 case DCCP_SOCKOPT_CHANGE_R:
492 if (optlen != sizeof(struct dccp_so_feat))
495 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
496 (struct dccp_so_feat __user *)
509 int dccp_setsockopt(struct sock *sk, int level, int optname,
510 char __user *optval, int optlen)
512 if (level != SOL_DCCP)
513 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
516 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
519 EXPORT_SYMBOL_GPL(dccp_setsockopt);
522 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
523 char __user *optval, int optlen)
525 if (level != SOL_DCCP)
526 return inet_csk_compat_setsockopt(sk, level, optname,
528 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
531 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
534 static int dccp_getsockopt_service(struct sock *sk, int len,
535 __be32 __user *optval,
538 const struct dccp_sock *dp = dccp_sk(sk);
539 const struct dccp_service_list *sl;
540 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
543 if (dccp_service_not_initialized(sk))
546 if ((sl = dp->dccps_service_list) != NULL) {
547 slen = sl->dccpsl_nr * sizeof(u32);
556 if (put_user(total_len, optlen) ||
557 put_user(dp->dccps_service, optval) ||
558 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
565 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
566 char __user *optval, int __user *optlen)
568 struct dccp_sock *dp;
571 if (get_user(len, optlen))
574 if (len < sizeof(int))
580 case DCCP_SOCKOPT_PACKET_SIZE:
581 val = dp->dccps_packet_size;
582 len = sizeof(dp->dccps_packet_size);
584 case DCCP_SOCKOPT_SERVICE:
585 return dccp_getsockopt_service(sk, len,
586 (__be32 __user *)optval, optlen);
588 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
589 len, (u32 __user *)optval, optlen);
591 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
592 len, (u32 __user *)optval, optlen);
597 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
603 int dccp_getsockopt(struct sock *sk, int level, int optname,
604 char __user *optval, int __user *optlen)
606 if (level != SOL_DCCP)
607 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
610 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
613 EXPORT_SYMBOL_GPL(dccp_getsockopt);
616 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
617 char __user *optval, int __user *optlen)
619 if (level != SOL_DCCP)
620 return inet_csk_compat_getsockopt(sk, level, optname,
622 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
625 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
628 int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
631 const struct dccp_sock *dp = dccp_sk(sk);
632 const int flags = msg->msg_flags;
633 const int noblock = flags & MSG_DONTWAIT;
638 if (len > dp->dccps_mss_cache)
642 timeo = sock_sndtimeo(sk, noblock);
645 * We have to use sk_stream_wait_connect here to set sk_write_pending,
646 * so that the trick in dccp_rcv_request_sent_state_process.
648 /* Wait for a connection to finish. */
649 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING))
650 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
653 size = sk->sk_prot->max_header + len;
655 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
660 skb_reserve(skb, sk->sk_prot->max_header);
661 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
665 skb_queue_tail(&sk->sk_write_queue, skb);
666 dccp_write_xmit(sk,0);
675 EXPORT_SYMBOL_GPL(dccp_sendmsg);
677 int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
678 size_t len, int nonblock, int flags, int *addr_len)
680 const struct dccp_hdr *dh;
685 if (sk->sk_state == DCCP_LISTEN) {
690 timeo = sock_rcvtimeo(sk, nonblock);
693 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
696 goto verify_sock_status;
700 if (dh->dccph_type == DCCP_PKT_DATA ||
701 dh->dccph_type == DCCP_PKT_DATAACK)
704 if (dh->dccph_type == DCCP_PKT_RESET ||
705 dh->dccph_type == DCCP_PKT_CLOSE) {
706 dccp_pr_debug("found fin ok!\n");
710 dccp_pr_debug("packet_type=%s\n",
711 dccp_packet_name(dh->dccph_type));
712 sk_eat_skb(sk, skb, 0);
714 if (sock_flag(sk, SOCK_DONE)) {
720 len = sock_error(sk);
724 if (sk->sk_shutdown & RCV_SHUTDOWN) {
729 if (sk->sk_state == DCCP_CLOSED) {
730 if (!sock_flag(sk, SOCK_DONE)) {
731 /* This occurs when user tries to read
732 * from never connected socket.
746 if (signal_pending(current)) {
747 len = sock_intr_errno(timeo);
751 sk_wait_data(sk, &timeo);
756 else if (len < skb->len)
757 msg->msg_flags |= MSG_TRUNC;
759 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
760 /* Exception. Bailout! */
765 if (!(flags & MSG_PEEK))
766 sk_eat_skb(sk, skb, 0);
774 EXPORT_SYMBOL_GPL(dccp_recvmsg);
776 int inet_dccp_listen(struct socket *sock, int backlog)
778 struct sock *sk = sock->sk;
779 unsigned char old_state;
785 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
788 old_state = sk->sk_state;
789 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
792 /* Really, if the socket is already in listen state
793 * we can only allow the backlog to be adjusted.
795 if (old_state != DCCP_LISTEN) {
797 * FIXME: here it probably should be sk->sk_prot->listen_start
798 * see tcp_listen_start
800 err = dccp_listen_start(sk);
804 sk->sk_max_ack_backlog = backlog;
812 EXPORT_SYMBOL_GPL(inet_dccp_listen);
814 static const unsigned char dccp_new_state[] = {
815 /* current state: new state: action: */
817 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
818 [DCCP_REQUESTING] = DCCP_CLOSED,
819 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
820 [DCCP_LISTEN] = DCCP_CLOSED,
821 [DCCP_RESPOND] = DCCP_CLOSED,
822 [DCCP_CLOSING] = DCCP_CLOSED,
823 [DCCP_TIME_WAIT] = DCCP_CLOSED,
824 [DCCP_CLOSED] = DCCP_CLOSED,
827 static int dccp_close_state(struct sock *sk)
829 const int next = dccp_new_state[sk->sk_state];
830 const int ns = next & DCCP_STATE_MASK;
832 if (ns != sk->sk_state)
833 dccp_set_state(sk, ns);
835 return next & DCCP_ACTION_FIN;
838 void dccp_close(struct sock *sk, long timeout)
840 struct dccp_sock *dp = dccp_sk(sk);
846 sk->sk_shutdown = SHUTDOWN_MASK;
848 if (sk->sk_state == DCCP_LISTEN) {
849 dccp_set_state(sk, DCCP_CLOSED);
852 inet_csk_listen_stop(sk);
854 goto adjudge_to_death;
857 sk_stop_timer(sk, &dp->dccps_xmit_timer);
860 * We need to flush the recv. buffs. We do this only on the
861 * descriptor close, not protocol-sourced closes, because the
862 *reader process may not have drained the data yet!
864 /* FIXME: check for unread data */
865 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
869 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
870 /* Check zero linger _after_ checking for unread data. */
871 sk->sk_prot->disconnect(sk, 0);
872 } else if (dccp_close_state(sk)) {
873 dccp_send_close(sk, 1);
876 sk_stream_wait_close(sk, timeout);
879 state = sk->sk_state;
882 atomic_inc(sk->sk_prot->orphan_count);
885 * It is the last release_sock in its life. It will remove backlog.
889 * Now socket is owned by kernel and we acquire BH lock
890 * to finish close. No need to check for user refs.
894 BUG_TRAP(!sock_owned_by_user(sk));
896 /* Have we already been destroyed by a softirq or backlog? */
897 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
901 * The last release_sock may have processed the CLOSE or RESET
902 * packet moving sock to CLOSED state, if not we have to fire
903 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
904 * in draft-ietf-dccp-spec-11. -acme
906 if (sk->sk_state == DCCP_CLOSING) {
907 /* FIXME: should start at 2 * RTT */
908 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
909 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
910 inet_csk(sk)->icsk_rto,
913 /* Yeah, we should use sk->sk_prot->orphan_count, etc */
914 dccp_set_state(sk, DCCP_CLOSED);
918 if (sk->sk_state == DCCP_CLOSED)
919 inet_csk_destroy_sock(sk);
921 /* Otherwise, socket is reprieved until protocol close. */
929 EXPORT_SYMBOL_GPL(dccp_close);
931 void dccp_shutdown(struct sock *sk, int how)
933 dccp_pr_debug("entry\n");
936 EXPORT_SYMBOL_GPL(dccp_shutdown);
938 static int __init dccp_mib_init(void)
942 dccp_statistics[0] = alloc_percpu(struct dccp_mib);
943 if (dccp_statistics[0] == NULL)
946 dccp_statistics[1] = alloc_percpu(struct dccp_mib);
947 if (dccp_statistics[1] == NULL)
954 free_percpu(dccp_statistics[0]);
955 dccp_statistics[0] = NULL;
960 static void dccp_mib_exit(void)
962 free_percpu(dccp_statistics[0]);
963 free_percpu(dccp_statistics[1]);
964 dccp_statistics[0] = dccp_statistics[1] = NULL;
967 static int thash_entries;
968 module_param(thash_entries, int, 0444);
969 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
971 #ifdef CONFIG_IP_DCCP_DEBUG
973 module_param(dccp_debug, int, 0444);
974 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
976 EXPORT_SYMBOL_GPL(dccp_debug);
979 static int __init dccp_init(void)
982 int ehash_order, bhash_order, i;
985 dccp_hashinfo.bind_bucket_cachep =
986 kmem_cache_create("dccp_bind_bucket",
987 sizeof(struct inet_bind_bucket), 0,
988 SLAB_HWCACHE_ALIGN, NULL, NULL);
989 if (!dccp_hashinfo.bind_bucket_cachep)
993 * Size and allocate the main established and bind bucket
996 * The methodology is similar to that of the buffer cache.
998 if (num_physpages >= (128 * 1024))
999 goal = num_physpages >> (21 - PAGE_SHIFT);
1001 goal = num_physpages >> (23 - PAGE_SHIFT);
1004 goal = (thash_entries *
1005 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1006 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1009 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1010 sizeof(struct inet_ehash_bucket);
1011 dccp_hashinfo.ehash_size >>= 1;
1012 while (dccp_hashinfo.ehash_size &
1013 (dccp_hashinfo.ehash_size - 1))
1014 dccp_hashinfo.ehash_size--;
1015 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1016 __get_free_pages(GFP_ATOMIC, ehash_order);
1017 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1019 if (!dccp_hashinfo.ehash) {
1020 printk(KERN_CRIT "Failed to allocate DCCP "
1021 "established hash table\n");
1022 goto out_free_bind_bucket_cachep;
1025 for (i = 0; i < (dccp_hashinfo.ehash_size << 1); i++) {
1026 rwlock_init(&dccp_hashinfo.ehash[i].lock);
1027 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1030 bhash_order = ehash_order;
1033 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1034 sizeof(struct inet_bind_hashbucket);
1035 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1038 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1039 __get_free_pages(GFP_ATOMIC, bhash_order);
1040 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1042 if (!dccp_hashinfo.bhash) {
1043 printk(KERN_CRIT "Failed to allocate DCCP bind hash table\n");
1044 goto out_free_dccp_ehash;
1047 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1048 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1049 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1052 rc = dccp_mib_init();
1054 goto out_free_dccp_bhash;
1056 rc = dccp_ackvec_init();
1058 goto out_free_dccp_mib;
1060 rc = dccp_sysctl_init();
1062 goto out_ackvec_exit;
1069 out_free_dccp_bhash:
1070 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1071 dccp_hashinfo.bhash = NULL;
1072 out_free_dccp_ehash:
1073 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1074 dccp_hashinfo.ehash = NULL;
1075 out_free_bind_bucket_cachep:
1076 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1077 dccp_hashinfo.bind_bucket_cachep = NULL;
1081 static void __exit dccp_fini(void)
1084 free_pages((unsigned long)dccp_hashinfo.bhash,
1085 get_order(dccp_hashinfo.bhash_size *
1086 sizeof(struct inet_bind_hashbucket)));
1087 free_pages((unsigned long)dccp_hashinfo.ehash,
1088 get_order(dccp_hashinfo.ehash_size *
1089 sizeof(struct inet_ehash_bucket)));
1090 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1095 module_init(dccp_init);
1096 module_exit(dccp_fini);
1098 MODULE_LICENSE("GPL");
1099 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1100 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");