projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


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