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