blob: 2e0ee8355c415d24d13644e20ecb6d8e837d10c1 [file] [log] [blame]
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001/*
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
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020026#include <net/inet_sock.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070027#include <net/sock.h>
28#include <net/xfrm.h>
29
30#include <asm/semaphore.h>
31#include <linux/spinlock.h>
32#include <linux/timer.h>
33#include <linux/delay.h>
34#include <linux/poll.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070035
36#include "ccid.h"
37#include "dccp.h"
Andrea Bittauafe00252006-03-20 17:43:56 -080038#include "feat.h"
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070039
Eric Dumazetba899662005-08-26 12:05:31 -070040DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070041
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080042EXPORT_SYMBOL_GPL(dccp_statistics);
43
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070044atomic_t dccp_orphan_count = ATOMIC_INIT(0);
45
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080046EXPORT_SYMBOL_GPL(dccp_orphan_count);
47
Arnaldo Carvalho de Melo075ae862006-03-20 21:24:19 -080048struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
49 .lhash_lock = RW_LOCK_UNLOCKED,
50 .lhash_users = ATOMIC_INIT(0),
51 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
52};
53
54EXPORT_SYMBOL_GPL(dccp_hashinfo);
55
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080056void dccp_set_state(struct sock *sk, const int state)
57{
58 const int oldstate = sk->sk_state;
59
60 dccp_pr_debug("%s(%p) %-10.10s -> %s\n",
61 dccp_role(sk), sk,
62 dccp_state_name(oldstate), dccp_state_name(state));
63 WARN_ON(state == oldstate);
64
65 switch (state) {
66 case DCCP_OPEN:
67 if (oldstate != DCCP_OPEN)
68 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
69 break;
70
71 case DCCP_CLOSED:
72 if (oldstate == DCCP_CLOSING || oldstate == DCCP_OPEN)
73 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
74
75 sk->sk_prot->unhash(sk);
76 if (inet_csk(sk)->icsk_bind_hash != NULL &&
77 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
78 inet_put_port(&dccp_hashinfo, sk);
79 /* fall through */
80 default:
81 if (oldstate == DCCP_OPEN)
82 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
83 }
84
85 /* Change state AFTER socket is unhashed to avoid closed
86 * socket sitting in hash tables.
87 */
88 sk->sk_state = state;
89}
90
91EXPORT_SYMBOL_GPL(dccp_set_state);
92
93void dccp_done(struct sock *sk)
94{
95 dccp_set_state(sk, DCCP_CLOSED);
96 dccp_clear_xmit_timers(sk);
97
98 sk->sk_shutdown = SHUTDOWN_MASK;
99
100 if (!sock_flag(sk, SOCK_DEAD))
101 sk->sk_state_change(sk);
102 else
103 inet_csk_destroy_sock(sk);
104}
105
106EXPORT_SYMBOL_GPL(dccp_done);
107
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700108const char *dccp_packet_name(const int type)
109{
110 static const char *dccp_packet_names[] = {
111 [DCCP_PKT_REQUEST] = "REQUEST",
112 [DCCP_PKT_RESPONSE] = "RESPONSE",
113 [DCCP_PKT_DATA] = "DATA",
114 [DCCP_PKT_ACK] = "ACK",
115 [DCCP_PKT_DATAACK] = "DATAACK",
116 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
117 [DCCP_PKT_CLOSE] = "CLOSE",
118 [DCCP_PKT_RESET] = "RESET",
119 [DCCP_PKT_SYNC] = "SYNC",
120 [DCCP_PKT_SYNCACK] = "SYNCACK",
121 };
122
123 if (type >= DCCP_NR_PKT_TYPES)
124 return "INVALID";
125 else
126 return dccp_packet_names[type];
127}
128
129EXPORT_SYMBOL_GPL(dccp_packet_name);
130
131const char *dccp_state_name(const int state)
132{
133 static char *dccp_state_names[] = {
134 [DCCP_OPEN] = "OPEN",
135 [DCCP_REQUESTING] = "REQUESTING",
136 [DCCP_PARTOPEN] = "PARTOPEN",
137 [DCCP_LISTEN] = "LISTEN",
138 [DCCP_RESPOND] = "RESPOND",
139 [DCCP_CLOSING] = "CLOSING",
140 [DCCP_TIME_WAIT] = "TIME_WAIT",
141 [DCCP_CLOSED] = "CLOSED",
142 };
143
144 if (state >= DCCP_MAX_STATES)
145 return "INVALID STATE!";
146 else
147 return dccp_state_names[state];
148}
149
150EXPORT_SYMBOL_GPL(dccp_state_name);
151
Arnaldo Carvalho de Meloc985ed72006-03-20 21:23:39 -0800152void dccp_hash(struct sock *sk)
153{
154 inet_hash(&dccp_hashinfo, sk);
155}
156
157EXPORT_SYMBOL_GPL(dccp_hash);
158
159void dccp_unhash(struct sock *sk)
160{
161 inet_unhash(&dccp_hashinfo, sk);
162}
163
164EXPORT_SYMBOL_GPL(dccp_unhash);
165
Arnaldo Carvalho de Melo72478872006-03-20 22:00:37 -0800166int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800167{
168 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800169 struct dccp_minisock *dmsk = dccp_msk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800170 struct inet_connection_sock *icsk = inet_csk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800171
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800172 dccp_minisock_init(&dp->dccps_minisock);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800173 do_gettimeofday(&dp->dccps_epoch);
174
175 /*
176 * FIXME: We're hardcoding the CCID, and doing this at this point makes
177 * the listening (master) sock get CCID control blocks, which is not
178 * necessary, but for now, to not mess with the test userspace apps,
179 * lets leave it here, later the real solution is to do this in a
180 * setsockopt(CCIDs-I-want/accept). -acme
181 */
Arnaldo Carvalho de Melo72478872006-03-20 22:00:37 -0800182 if (likely(ctl_sock_initialized)) {
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800183 int rc = dccp_feat_init(dmsk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800184
185 if (rc)
186 return rc;
187
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800188 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800189 dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
190 if (dp->dccps_hc_rx_ackvec == NULL)
191 return -ENOMEM;
192 }
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800193 dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
194 sk, GFP_KERNEL);
195 dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
196 sk, GFP_KERNEL);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800197 if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
198 dp->dccps_hc_tx_ccid == NULL)) {
199 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
200 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800201 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800202 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
203 dp->dccps_hc_rx_ackvec = NULL;
204 }
205 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
206 return -ENOMEM;
207 }
208 } else {
209 /* control socket doesn't need feat nego */
Arnaldo Carvalho de Meloa4bf3902006-03-20 22:50:58 -0800210 INIT_LIST_HEAD(&dmsk->dccpms_pending);
211 INIT_LIST_HEAD(&dmsk->dccpms_conf);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800212 }
213
214 dccp_init_xmit_timers(sk);
215 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
216 sk->sk_state = DCCP_CLOSED;
217 sk->sk_write_space = dccp_write_space;
218 icsk->icsk_sync_mss = dccp_sync_mss;
219 dp->dccps_mss_cache = 536;
220 dp->dccps_role = DCCP_ROLE_UNDEFINED;
221 dp->dccps_service = DCCP_SERVICE_INVALID_VALUE;
222 dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
223
224 return 0;
225}
226
227EXPORT_SYMBOL_GPL(dccp_init_sock);
228
229int dccp_destroy_sock(struct sock *sk)
230{
231 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800232 struct dccp_minisock *dmsk = dccp_msk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800233
234 /*
235 * DCCP doesn't use sk_write_queue, just sk_send_head
236 * for retransmissions
237 */
238 if (sk->sk_send_head != NULL) {
239 kfree_skb(sk->sk_send_head);
240 sk->sk_send_head = NULL;
241 }
242
243 /* Clean up a referenced DCCP bind bucket. */
244 if (inet_csk(sk)->icsk_bind_hash != NULL)
245 inet_put_port(&dccp_hashinfo, sk);
246
247 kfree(dp->dccps_service_list);
248 dp->dccps_service_list = NULL;
249
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800250 if (dmsk->dccpms_send_ack_vector) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800251 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
252 dp->dccps_hc_rx_ackvec = NULL;
253 }
254 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
255 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
256 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
257
258 /* clean up feature negotiation state */
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800259 dccp_feat_clean(dmsk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800260
261 return 0;
262}
263
264EXPORT_SYMBOL_GPL(dccp_destroy_sock);
265
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700266static inline int dccp_listen_start(struct sock *sk)
267{
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700268 struct dccp_sock *dp = dccp_sk(sk);
269
270 dp->dccps_role = DCCP_ROLE_LISTEN;
271 /*
272 * Apps need to use setsockopt(DCCP_SOCKOPT_SERVICE)
273 * before calling listen()
274 */
275 if (dccp_service_not_initialized(sk))
276 return -EPROTO;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700277 return inet_csk_listen_start(sk, TCP_SYNQ_HSIZE);
278}
279
280int dccp_disconnect(struct sock *sk, int flags)
281{
282 struct inet_connection_sock *icsk = inet_csk(sk);
283 struct inet_sock *inet = inet_sk(sk);
284 int err = 0;
285 const int old_state = sk->sk_state;
286
287 if (old_state != DCCP_CLOSED)
288 dccp_set_state(sk, DCCP_CLOSED);
289
290 /* ABORT function of RFC793 */
291 if (old_state == DCCP_LISTEN) {
292 inet_csk_listen_stop(sk);
293 /* FIXME: do the active reset thing */
294 } else if (old_state == DCCP_REQUESTING)
295 sk->sk_err = ECONNRESET;
296
297 dccp_clear_xmit_timers(sk);
298 __skb_queue_purge(&sk->sk_receive_queue);
299 if (sk->sk_send_head != NULL) {
300 __kfree_skb(sk->sk_send_head);
301 sk->sk_send_head = NULL;
302 }
303
304 inet->dport = 0;
305
306 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
307 inet_reset_saddr(sk);
308
309 sk->sk_shutdown = 0;
310 sock_reset_flag(sk, SOCK_DONE);
311
312 icsk->icsk_backoff = 0;
313 inet_csk_delack_init(sk);
314 __sk_dst_reset(sk);
315
316 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
317
318 sk->sk_error_report(sk);
319 return err;
320}
321
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800322EXPORT_SYMBOL_GPL(dccp_disconnect);
323
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700324/*
325 * Wait for a DCCP event.
326 *
327 * Note that we don't need to lock the socket, as the upper poll layers
328 * take care of normal races (between the test and the event) and we don't
329 * go look at any of the socket buffers directly.
330 */
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800331unsigned int dccp_poll(struct file *file, struct socket *sock,
332 poll_table *wait)
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700333{
334 unsigned int mask;
335 struct sock *sk = sock->sk;
336
337 poll_wait(file, sk->sk_sleep, wait);
338 if (sk->sk_state == DCCP_LISTEN)
339 return inet_csk_listen_poll(sk);
340
341 /* Socket is not locked. We are protected from async events
342 by poll logic and correct handling of state changes
343 made by another threads is impossible in any case.
344 */
345
346 mask = 0;
347 if (sk->sk_err)
348 mask = POLLERR;
349
350 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
351 mask |= POLLHUP;
352 if (sk->sk_shutdown & RCV_SHUTDOWN)
Davide Libenzif348d702006-03-25 03:07:39 -0800353 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700354
355 /* Connected? */
356 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
357 if (atomic_read(&sk->sk_rmem_alloc) > 0)
358 mask |= POLLIN | POLLRDNORM;
359
360 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
361 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
362 mask |= POLLOUT | POLLWRNORM;
363 } else { /* send SIGIO later */
364 set_bit(SOCK_ASYNC_NOSPACE,
365 &sk->sk_socket->flags);
366 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
367
368 /* Race breaker. If space is freed after
369 * wspace test but before the flags are set,
370 * IO signal will be lost.
371 */
372 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
373 mask |= POLLOUT | POLLWRNORM;
374 }
375 }
376 }
377 return mask;
378}
379
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800380EXPORT_SYMBOL_GPL(dccp_poll);
381
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700382int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
383{
384 dccp_pr_debug("entry\n");
385 return -ENOIOCTLCMD;
386}
387
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800388EXPORT_SYMBOL_GPL(dccp_ioctl);
389
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800390static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700391 char __user *optval, int optlen)
392{
393 struct dccp_sock *dp = dccp_sk(sk);
394 struct dccp_service_list *sl = NULL;
395
396 if (service == DCCP_SERVICE_INVALID_VALUE ||
397 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
398 return -EINVAL;
399
400 if (optlen > sizeof(service)) {
401 sl = kmalloc(optlen, GFP_KERNEL);
402 if (sl == NULL)
403 return -ENOMEM;
404
405 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
406 if (copy_from_user(sl->dccpsl_list,
407 optval + sizeof(service),
408 optlen - sizeof(service)) ||
409 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
410 kfree(sl);
411 return -EFAULT;
412 }
413 }
414
415 lock_sock(sk);
416 dp->dccps_service = service;
417
Jesper Juhla51482b2005-11-08 09:41:34 -0800418 kfree(dp->dccps_service_list);
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700419
420 dp->dccps_service_list = sl;
421 release_sock(sk);
422 return 0;
423}
424
Andrea Bittauafe00252006-03-20 17:43:56 -0800425/* byte 1 is feature. the rest is the preference list */
426static int dccp_setsockopt_change(struct sock *sk, int type,
427 struct dccp_so_feat __user *optval)
428{
429 struct dccp_so_feat opt;
430 u8 *val;
431 int rc;
432
433 if (copy_from_user(&opt, optval, sizeof(opt)))
434 return -EFAULT;
435
436 val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
437 if (!val)
438 return -ENOMEM;
439
440 if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
441 rc = -EFAULT;
442 goto out_free_val;
443 }
444
Arnaldo Carvalho de Melo8ca0d172006-03-20 22:51:53 -0800445 rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
446 val, opt.dccpsf_len, GFP_KERNEL);
Andrea Bittauafe00252006-03-20 17:43:56 -0800447 if (rc)
448 goto out_free_val;
449
450out:
451 return rc;
452
453out_free_val:
454 kfree(val);
455 goto out;
456}
457
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800458static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
459 char __user *optval, int optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700460{
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300461 struct dccp_sock *dp;
462 int err;
463 int val;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700464
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300465 if (optlen < sizeof(int))
466 return -EINVAL;
467
468 if (get_user(val, (int __user *)optval))
469 return -EFAULT;
470
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700471 if (optname == DCCP_SOCKOPT_SERVICE)
472 return dccp_setsockopt_service(sk, val, optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300473
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700474 lock_sock(sk);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300475 dp = dccp_sk(sk);
476 err = 0;
477
478 switch (optname) {
479 case DCCP_SOCKOPT_PACKET_SIZE:
480 dp->dccps_packet_size = val;
481 break;
Andrea Bittauafe00252006-03-20 17:43:56 -0800482
483 case DCCP_SOCKOPT_CHANGE_L:
484 if (optlen != sizeof(struct dccp_so_feat))
485 err = -EINVAL;
486 else
487 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
488 (struct dccp_so_feat *)
489 optval);
490 break;
491
492 case DCCP_SOCKOPT_CHANGE_R:
493 if (optlen != sizeof(struct dccp_so_feat))
494 err = -EINVAL;
495 else
496 err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
497 (struct dccp_so_feat *)
498 optval);
499 break;
500
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300501 default:
502 err = -ENOPROTOOPT;
503 break;
504 }
505
506 release_sock(sk);
507 return err;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700508}
509
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800510int dccp_setsockopt(struct sock *sk, int level, int optname,
511 char __user *optval, int optlen)
512{
513 if (level != SOL_DCCP)
514 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
515 optname, optval,
516 optlen);
517 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
518}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800519
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800520EXPORT_SYMBOL_GPL(dccp_setsockopt);
521
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800522#ifdef CONFIG_COMPAT
523int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800524 char __user *optval, int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800525{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800526 if (level != SOL_DCCP)
527 return inet_csk_compat_setsockopt(sk, level, optname,
528 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800529 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
530}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800531
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800532EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
533#endif
534
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700535static int dccp_getsockopt_service(struct sock *sk, int len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800536 __be32 __user *optval,
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700537 int __user *optlen)
538{
539 const struct dccp_sock *dp = dccp_sk(sk);
540 const struct dccp_service_list *sl;
541 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
542
543 lock_sock(sk);
544 if (dccp_service_not_initialized(sk))
545 goto out;
546
547 if ((sl = dp->dccps_service_list) != NULL) {
548 slen = sl->dccpsl_nr * sizeof(u32);
549 total_len += slen;
550 }
551
552 err = -EINVAL;
553 if (total_len > len)
554 goto out;
555
556 err = 0;
557 if (put_user(total_len, optlen) ||
558 put_user(dp->dccps_service, optval) ||
559 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
560 err = -EFAULT;
561out:
562 release_sock(sk);
563 return err;
564}
565
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800566static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300567 char __user *optval, int __user *optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700568{
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300569 struct dccp_sock *dp;
570 int val, len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700571
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300572 if (get_user(len, optlen))
573 return -EFAULT;
574
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700575 if (len < sizeof(int))
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300576 return -EINVAL;
577
578 dp = dccp_sk(sk);
579
580 switch (optname) {
581 case DCCP_SOCKOPT_PACKET_SIZE:
582 val = dp->dccps_packet_size;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700583 len = sizeof(dp->dccps_packet_size);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300584 break;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700585 case DCCP_SOCKOPT_SERVICE:
586 return dccp_getsockopt_service(sk, len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800587 (__be32 __user *)optval, optlen);
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700588 case 128 ... 191:
589 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
590 len, (u32 __user *)optval, optlen);
591 case 192 ... 255:
592 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
593 len, (u32 __user *)optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300594 default:
595 return -ENOPROTOOPT;
596 }
597
598 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
599 return -EFAULT;
600
601 return 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700602}
603
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800604int dccp_getsockopt(struct sock *sk, int level, int optname,
605 char __user *optval, int __user *optlen)
606{
607 if (level != SOL_DCCP)
608 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
609 optname, optval,
610 optlen);
611 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
612}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800613
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800614EXPORT_SYMBOL_GPL(dccp_getsockopt);
615
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800616#ifdef CONFIG_COMPAT
617int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800618 char __user *optval, int __user *optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800619{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800620 if (level != SOL_DCCP)
621 return inet_csk_compat_getsockopt(sk, level, optname,
622 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800623 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
624}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800625
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800626EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
627#endif
628
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700629int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
630 size_t len)
631{
632 const struct dccp_sock *dp = dccp_sk(sk);
633 const int flags = msg->msg_flags;
634 const int noblock = flags & MSG_DONTWAIT;
635 struct sk_buff *skb;
636 int rc, size;
637 long timeo;
638
639 if (len > dp->dccps_mss_cache)
640 return -EMSGSIZE;
641
642 lock_sock(sk);
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700643 timeo = sock_sndtimeo(sk, noblock);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700644
645 /*
646 * We have to use sk_stream_wait_connect here to set sk_write_pending,
647 * so that the trick in dccp_rcv_request_sent_state_process.
648 */
649 /* Wait for a connection to finish. */
650 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING))
651 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700652 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700653
654 size = sk->sk_prot->max_header + len;
655 release_sock(sk);
656 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
657 lock_sock(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700658 if (skb == NULL)
659 goto out_release;
660
661 skb_reserve(skb, sk->sk_prot->max_header);
662 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700663 if (rc != 0)
664 goto out_discard;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700665
Arnaldo Carvalho de Melod6809c12005-08-27 03:06:35 -0300666 rc = dccp_write_xmit(sk, skb, &timeo);
Arnaldo Carvalho de Melo20472af2005-08-23 21:50:21 -0700667 /*
668 * XXX we don't use sk_write_queue, so just discard the packet.
669 * Current plan however is to _use_ sk_write_queue with
670 * an algorith similar to tcp_sendmsg, where the main difference
671 * is that in DCCP we have to respect packet boundaries, so
672 * no coalescing of skbs.
673 *
674 * This bug was _quickly_ found & fixed by just looking at an OSTRA
675 * generated callgraph 8) -acme
676 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700677out_release:
678 release_sock(sk);
679 return rc ? : len;
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700680out_discard:
681 kfree_skb(skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700682 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700683}
684
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800685EXPORT_SYMBOL_GPL(dccp_sendmsg);
686
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700687int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
688 size_t len, int nonblock, int flags, int *addr_len)
689{
690 const struct dccp_hdr *dh;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700691 long timeo;
692
693 lock_sock(sk);
694
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300695 if (sk->sk_state == DCCP_LISTEN) {
696 len = -ENOTCONN;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700697 goto out;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300698 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700699
700 timeo = sock_rcvtimeo(sk, nonblock);
701
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700702 do {
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300703 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700704
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300705 if (skb == NULL)
706 goto verify_sock_status;
707
708 dh = dccp_hdr(skb);
709
710 if (dh->dccph_type == DCCP_PKT_DATA ||
711 dh->dccph_type == DCCP_PKT_DATAACK)
712 goto found_ok_skb;
713
714 if (dh->dccph_type == DCCP_PKT_RESET ||
715 dh->dccph_type == DCCP_PKT_CLOSE) {
716 dccp_pr_debug("found fin ok!\n");
717 len = 0;
718 goto found_fin_ok;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700719 }
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300720 dccp_pr_debug("packet_type=%s\n",
721 dccp_packet_name(dh->dccph_type));
722 sk_eat_skb(sk, skb);
723verify_sock_status:
724 if (sock_flag(sk, SOCK_DONE)) {
725 len = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700726 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700727 }
728
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300729 if (sk->sk_err) {
730 len = sock_error(sk);
731 break;
732 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700733
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300734 if (sk->sk_shutdown & RCV_SHUTDOWN) {
735 len = 0;
736 break;
737 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700738
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300739 if (sk->sk_state == DCCP_CLOSED) {
740 if (!sock_flag(sk, SOCK_DONE)) {
741 /* This occurs when user tries to read
742 * from never connected socket.
743 */
744 len = -ENOTCONN;
745 break;
746 }
747 len = 0;
748 break;
749 }
750
751 if (!timeo) {
752 len = -EAGAIN;
753 break;
754 }
755
756 if (signal_pending(current)) {
757 len = sock_intr_errno(timeo);
758 break;
759 }
760
761 sk_wait_data(sk, &timeo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700762 continue;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700763 found_ok_skb:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300764 if (len > skb->len)
765 len = skb->len;
766 else if (len < skb->len)
767 msg->msg_flags |= MSG_TRUNC;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700768
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300769 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
770 /* Exception. Bailout! */
771 len = -EFAULT;
772 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700773 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700774 found_fin_ok:
775 if (!(flags & MSG_PEEK))
776 sk_eat_skb(sk, skb);
777 break;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300778 } while (1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700779out:
780 release_sock(sk);
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300781 return len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700782}
783
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800784EXPORT_SYMBOL_GPL(dccp_recvmsg);
785
786int inet_dccp_listen(struct socket *sock, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700787{
788 struct sock *sk = sock->sk;
789 unsigned char old_state;
790 int err;
791
792 lock_sock(sk);
793
794 err = -EINVAL;
795 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
796 goto out;
797
798 old_state = sk->sk_state;
799 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
800 goto out;
801
802 /* Really, if the socket is already in listen state
803 * we can only allow the backlog to be adjusted.
804 */
805 if (old_state != DCCP_LISTEN) {
806 /*
807 * FIXME: here it probably should be sk->sk_prot->listen_start
808 * see tcp_listen_start
809 */
810 err = dccp_listen_start(sk);
811 if (err)
812 goto out;
813 }
814 sk->sk_max_ack_backlog = backlog;
815 err = 0;
816
817out:
818 release_sock(sk);
819 return err;
820}
821
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800822EXPORT_SYMBOL_GPL(inet_dccp_listen);
823
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700824static const unsigned char dccp_new_state[] = {
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -0300825 /* current state: new state: action: */
826 [0] = DCCP_CLOSED,
827 [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
828 [DCCP_REQUESTING] = DCCP_CLOSED,
829 [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
830 [DCCP_LISTEN] = DCCP_CLOSED,
831 [DCCP_RESPOND] = DCCP_CLOSED,
832 [DCCP_CLOSING] = DCCP_CLOSED,
833 [DCCP_TIME_WAIT] = DCCP_CLOSED,
834 [DCCP_CLOSED] = DCCP_CLOSED,
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700835};
836
837static int dccp_close_state(struct sock *sk)
838{
839 const int next = dccp_new_state[sk->sk_state];
840 const int ns = next & DCCP_STATE_MASK;
841
842 if (ns != sk->sk_state)
843 dccp_set_state(sk, ns);
844
845 return next & DCCP_ACTION_FIN;
846}
847
848void dccp_close(struct sock *sk, long timeout)
849{
850 struct sk_buff *skb;
Herbert Xu134af342006-05-05 17:09:13 -0700851 int state;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700852
853 lock_sock(sk);
854
855 sk->sk_shutdown = SHUTDOWN_MASK;
856
857 if (sk->sk_state == DCCP_LISTEN) {
858 dccp_set_state(sk, DCCP_CLOSED);
859
860 /* Special case. */
861 inet_csk_listen_stop(sk);
862
863 goto adjudge_to_death;
864 }
865
866 /*
867 * We need to flush the recv. buffs. We do this only on the
868 * descriptor close, not protocol-sourced closes, because the
869 *reader process may not have drained the data yet!
870 */
871 /* FIXME: check for unread data */
872 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
873 __kfree_skb(skb);
874 }
875
876 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
877 /* Check zero linger _after_ checking for unread data. */
878 sk->sk_prot->disconnect(sk, 0);
879 } else if (dccp_close_state(sk)) {
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700880 dccp_send_close(sk, 1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700881 }
882
883 sk_stream_wait_close(sk, timeout);
884
885adjudge_to_death:
Herbert Xu134af342006-05-05 17:09:13 -0700886 state = sk->sk_state;
887 sock_hold(sk);
888 sock_orphan(sk);
889 atomic_inc(sk->sk_prot->orphan_count);
890
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700891 /*
892 * It is the last release_sock in its life. It will remove backlog.
893 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700894 release_sock(sk);
895 /*
896 * Now socket is owned by kernel and we acquire BH lock
897 * to finish close. No need to check for user refs.
898 */
899 local_bh_disable();
900 bh_lock_sock(sk);
901 BUG_TRAP(!sock_owned_by_user(sk));
902
Herbert Xu134af342006-05-05 17:09:13 -0700903 /* Have we already been destroyed by a softirq or backlog? */
904 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
905 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700906
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -0700907 /*
908 * The last release_sock may have processed the CLOSE or RESET
909 * packet moving sock to CLOSED state, if not we have to fire
910 * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
911 * in draft-ietf-dccp-spec-11. -acme
912 */
913 if (sk->sk_state == DCCP_CLOSING) {
914 /* FIXME: should start at 2 * RTT */
915 /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
916 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
917 inet_csk(sk)->icsk_rto,
918 DCCP_RTO_MAX);
919#if 0
920 /* Yeah, we should use sk->sk_prot->orphan_count, etc */
921 dccp_set_state(sk, DCCP_CLOSED);
922#endif
923 }
924
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700925 if (sk->sk_state == DCCP_CLOSED)
926 inet_csk_destroy_sock(sk);
927
928 /* Otherwise, socket is reprieved until protocol close. */
929
Herbert Xu134af342006-05-05 17:09:13 -0700930out:
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700931 bh_unlock_sock(sk);
932 local_bh_enable();
933 sock_put(sk);
934}
935
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800936EXPORT_SYMBOL_GPL(dccp_close);
937
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700938void dccp_shutdown(struct sock *sk, int how)
939{
940 dccp_pr_debug("entry\n");
941}
942
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800943EXPORT_SYMBOL_GPL(dccp_shutdown);
944
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -0800945static int __init dccp_mib_init(void)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700946{
947 int rc = -ENOMEM;
948
949 dccp_statistics[0] = alloc_percpu(struct dccp_mib);
950 if (dccp_statistics[0] == NULL)
951 goto out;
952
953 dccp_statistics[1] = alloc_percpu(struct dccp_mib);
954 if (dccp_statistics[1] == NULL)
955 goto out_free_one;
956
957 rc = 0;
958out:
959 return rc;
960out_free_one:
961 free_percpu(dccp_statistics[0]);
962 dccp_statistics[0] = NULL;
963 goto out;
964
965}
966
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -0800967static void dccp_mib_exit(void)
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -0800968{
969 free_percpu(dccp_statistics[0]);
970 free_percpu(dccp_statistics[1]);
971 dccp_statistics[0] = dccp_statistics[1] = NULL;
972}
973
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700974static int thash_entries;
975module_param(thash_entries, int, 0444);
976MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
977
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300978#ifdef CONFIG_IP_DCCP_DEBUG
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700979int dccp_debug;
980module_param(dccp_debug, int, 0444);
981MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800982
983EXPORT_SYMBOL_GPL(dccp_debug);
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300984#endif
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700985
986static int __init dccp_init(void)
987{
988 unsigned long goal;
989 int ehash_order, bhash_order, i;
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -0800990 int rc = -ENOBUFS;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700991
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -0300992 dccp_hashinfo.bind_bucket_cachep =
993 kmem_cache_create("dccp_bind_bucket",
994 sizeof(struct inet_bind_bucket), 0,
995 SLAB_HWCACHE_ALIGN, NULL, NULL);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700996 if (!dccp_hashinfo.bind_bucket_cachep)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -0800997 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700998
999 /*
1000 * Size and allocate the main established and bind bucket
1001 * hash tables.
1002 *
1003 * The methodology is similar to that of the buffer cache.
1004 */
1005 if (num_physpages >= (128 * 1024))
1006 goal = num_physpages >> (21 - PAGE_SHIFT);
1007 else
1008 goal = num_physpages >> (23 - PAGE_SHIFT);
1009
1010 if (thash_entries)
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001011 goal = (thash_entries *
1012 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001013 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1014 ;
1015 do {
1016 dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
1017 sizeof(struct inet_ehash_bucket);
1018 dccp_hashinfo.ehash_size >>= 1;
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001019 while (dccp_hashinfo.ehash_size &
1020 (dccp_hashinfo.ehash_size - 1))
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001021 dccp_hashinfo.ehash_size--;
1022 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1023 __get_free_pages(GFP_ATOMIC, ehash_order);
1024 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1025
1026 if (!dccp_hashinfo.ehash) {
1027 printk(KERN_CRIT "Failed to allocate DCCP "
1028 "established hash table\n");
1029 goto out_free_bind_bucket_cachep;
1030 }
1031
1032 for (i = 0; i < (dccp_hashinfo.ehash_size << 1); i++) {
1033 rwlock_init(&dccp_hashinfo.ehash[i].lock);
1034 INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
1035 }
1036
1037 bhash_order = ehash_order;
1038
1039 do {
1040 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1041 sizeof(struct inet_bind_hashbucket);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001042 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1043 bhash_order > 0)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001044 continue;
1045 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1046 __get_free_pages(GFP_ATOMIC, bhash_order);
1047 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1048
1049 if (!dccp_hashinfo.bhash) {
1050 printk(KERN_CRIT "Failed to allocate DCCP bind hash table\n");
1051 goto out_free_dccp_ehash;
1052 }
1053
1054 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1055 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1056 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1057 }
1058
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001059 rc = dccp_mib_init();
Arnaldo Carvalho de Melofa23e2e2006-03-20 17:16:01 -08001060 if (rc)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001061 goto out_free_dccp_bhash;
1062
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001063 rc = dccp_ackvec_init();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001064 if (rc)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001065 goto out_free_dccp_mib;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001066
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001067 rc = dccp_sysctl_init();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001068 if (rc)
1069 goto out_ackvec_exit;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001070out:
1071 return rc;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001072out_ackvec_exit:
1073 dccp_ackvec_exit();
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001074out_free_dccp_mib:
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001075 dccp_mib_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001076out_free_dccp_bhash:
1077 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1078 dccp_hashinfo.bhash = NULL;
1079out_free_dccp_ehash:
1080 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1081 dccp_hashinfo.ehash = NULL;
1082out_free_bind_bucket_cachep:
1083 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1084 dccp_hashinfo.bind_bucket_cachep = NULL;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001085 goto out;
1086}
1087
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001088static void __exit dccp_fini(void)
1089{
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001090 dccp_mib_exit();
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001091 free_pages((unsigned long)dccp_hashinfo.bhash,
1092 get_order(dccp_hashinfo.bhash_size *
1093 sizeof(struct inet_bind_hashbucket)));
1094 free_pages((unsigned long)dccp_hashinfo.ehash,
1095 get_order(dccp_hashinfo.ehash_size *
1096 sizeof(struct inet_ehash_bucket)));
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001097 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001098 dccp_ackvec_exit();
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001099 dccp_sysctl_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001100}
1101
1102module_init(dccp_init);
1103module_exit(dccp_fini);
1104
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001105MODULE_LICENSE("GPL");
1106MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1107MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");