net core: fix kernel-doc for new function parameters
[linux-2.6.git] / net / dccp / ccid.c
1 /*
2  *  net/dccp/ccid.c
3  *
4  *  An implementation of the DCCP protocol
5  *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6  *
7  *  CCID infrastructure
8  *
9  *      This program is free software; you can redistribute it and/or modify it
10  *      under the terms of the GNU General Public License version 2 as
11  *      published by the Free Software Foundation.
12  */
13
14 #include "ccid.h"
15
16 static struct ccid_operations *ccids[CCID_MAX];
17 #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
18 static atomic_t ccids_lockct = ATOMIC_INIT(0);
19 static DEFINE_SPINLOCK(ccids_lock);
20
21 /*
22  * The strategy is: modifications ccids vector are short, do not sleep and
23  * veeery rare, but read access should be free of any exclusive locks.
24  */
25 static void ccids_write_lock(void)
26 {
27         spin_lock(&ccids_lock);
28         while (atomic_read(&ccids_lockct) != 0) {
29                 spin_unlock(&ccids_lock);
30                 yield();
31                 spin_lock(&ccids_lock);
32         }
33 }
34
35 static inline void ccids_write_unlock(void)
36 {
37         spin_unlock(&ccids_lock);
38 }
39
40 static inline void ccids_read_lock(void)
41 {
42         atomic_inc(&ccids_lockct);
43         smp_mb__after_atomic_inc();
44         spin_unlock_wait(&ccids_lock);
45 }
46
47 static inline void ccids_read_unlock(void)
48 {
49         atomic_dec(&ccids_lockct);
50 }
51
52 #else
53 #define ccids_write_lock() do { } while(0)
54 #define ccids_write_unlock() do { } while(0)
55 #define ccids_read_lock() do { } while(0)
56 #define ccids_read_unlock() do { } while(0)
57 #endif
58
59 static struct kmem_cache *ccid_kmem_cache_create(int obj_size, const char *fmt,...)
60 {
61         struct kmem_cache *slab;
62         char slab_name_fmt[32], *slab_name;
63         va_list args;
64
65         va_start(args, fmt);
66         vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
67         va_end(args);
68
69         slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
70         if (slab_name == NULL)
71                 return NULL;
72         slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
73                                  SLAB_HWCACHE_ALIGN, NULL);
74         if (slab == NULL)
75                 kfree(slab_name);
76         return slab;
77 }
78
79 static void ccid_kmem_cache_destroy(struct kmem_cache *slab)
80 {
81         if (slab != NULL) {
82                 const char *name = kmem_cache_name(slab);
83
84                 kmem_cache_destroy(slab);
85                 kfree(name);
86         }
87 }
88
89 int ccid_register(struct ccid_operations *ccid_ops)
90 {
91         int err = -ENOBUFS;
92
93         ccid_ops->ccid_hc_rx_slab =
94                         ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size,
95                                                "%s_hc_rx_sock",
96                                                ccid_ops->ccid_name);
97         if (ccid_ops->ccid_hc_rx_slab == NULL)
98                 goto out;
99
100         ccid_ops->ccid_hc_tx_slab =
101                         ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size,
102                                                "%s_hc_tx_sock",
103                                                ccid_ops->ccid_name);
104         if (ccid_ops->ccid_hc_tx_slab == NULL)
105                 goto out_free_rx_slab;
106
107         ccids_write_lock();
108         err = -EEXIST;
109         if (ccids[ccid_ops->ccid_id] == NULL) {
110                 ccids[ccid_ops->ccid_id] = ccid_ops;
111                 err = 0;
112         }
113         ccids_write_unlock();
114         if (err != 0)
115                 goto out_free_tx_slab;
116
117         pr_info("CCID: Registered CCID %d (%s)\n",
118                 ccid_ops->ccid_id, ccid_ops->ccid_name);
119 out:
120         return err;
121 out_free_tx_slab:
122         ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
123         ccid_ops->ccid_hc_tx_slab = NULL;
124         goto out;
125 out_free_rx_slab:
126         ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
127         ccid_ops->ccid_hc_rx_slab = NULL;
128         goto out;
129 }
130
131 EXPORT_SYMBOL_GPL(ccid_register);
132
133 int ccid_unregister(struct ccid_operations *ccid_ops)
134 {
135         ccids_write_lock();
136         ccids[ccid_ops->ccid_id] = NULL;
137         ccids_write_unlock();
138
139         ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
140         ccid_ops->ccid_hc_tx_slab = NULL;
141         ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
142         ccid_ops->ccid_hc_rx_slab = NULL;
143
144         pr_info("CCID: Unregistered CCID %d (%s)\n",
145                 ccid_ops->ccid_id, ccid_ops->ccid_name);
146         return 0;
147 }
148
149 EXPORT_SYMBOL_GPL(ccid_unregister);
150
151 struct ccid *ccid_new(unsigned char id, struct sock *sk, int rx, gfp_t gfp)
152 {
153         struct ccid_operations *ccid_ops;
154         struct ccid *ccid = NULL;
155
156         ccids_read_lock();
157 #ifdef CONFIG_KMOD
158         if (ccids[id] == NULL) {
159                 /* We only try to load if in process context */
160                 ccids_read_unlock();
161                 if (gfp & GFP_ATOMIC)
162                         goto out;
163                 request_module("net-dccp-ccid-%d", id);
164                 ccids_read_lock();
165         }
166 #endif
167         ccid_ops = ccids[id];
168         if (ccid_ops == NULL)
169                 goto out_unlock;
170
171         if (!try_module_get(ccid_ops->ccid_owner))
172                 goto out_unlock;
173
174         ccids_read_unlock();
175
176         ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
177                                      ccid_ops->ccid_hc_tx_slab, gfp);
178         if (ccid == NULL)
179                 goto out_module_put;
180         ccid->ccid_ops = ccid_ops;
181         if (rx) {
182                 memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size);
183                 if (ccid->ccid_ops->ccid_hc_rx_init != NULL &&
184                     ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0)
185                         goto out_free_ccid;
186         } else {
187                 memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size);
188                 if (ccid->ccid_ops->ccid_hc_tx_init != NULL &&
189                     ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0)
190                         goto out_free_ccid;
191         }
192 out:
193         return ccid;
194 out_unlock:
195         ccids_read_unlock();
196         goto out;
197 out_free_ccid:
198         kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
199                         ccid_ops->ccid_hc_tx_slab, ccid);
200         ccid = NULL;
201 out_module_put:
202         module_put(ccid_ops->ccid_owner);
203         goto out;
204 }
205
206 EXPORT_SYMBOL_GPL(ccid_new);
207
208 struct ccid *ccid_hc_rx_new(unsigned char id, struct sock *sk, gfp_t gfp)
209 {
210         return ccid_new(id, sk, 1, gfp);
211 }
212
213 EXPORT_SYMBOL_GPL(ccid_hc_rx_new);
214
215 struct ccid *ccid_hc_tx_new(unsigned char id,struct sock *sk,  gfp_t gfp)
216 {
217         return ccid_new(id, sk, 0, gfp);
218 }
219
220 EXPORT_SYMBOL_GPL(ccid_hc_tx_new);
221
222 static void ccid_delete(struct ccid *ccid, struct sock *sk, int rx)
223 {
224         struct ccid_operations *ccid_ops;
225
226         if (ccid == NULL)
227                 return;
228
229         ccid_ops = ccid->ccid_ops;
230         if (rx) {
231                 if (ccid_ops->ccid_hc_rx_exit != NULL)
232                         ccid_ops->ccid_hc_rx_exit(sk);
233                 kmem_cache_free(ccid_ops->ccid_hc_rx_slab,  ccid);
234         } else {
235                 if (ccid_ops->ccid_hc_tx_exit != NULL)
236                         ccid_ops->ccid_hc_tx_exit(sk);
237                 kmem_cache_free(ccid_ops->ccid_hc_tx_slab,  ccid);
238         }
239         ccids_read_lock();
240         if (ccids[ccid_ops->ccid_id] != NULL)
241                 module_put(ccid_ops->ccid_owner);
242         ccids_read_unlock();
243 }
244
245 void ccid_hc_rx_delete(struct ccid *ccid, struct sock *sk)
246 {
247         ccid_delete(ccid, sk, 1);
248 }
249
250 EXPORT_SYMBOL_GPL(ccid_hc_rx_delete);
251
252 void ccid_hc_tx_delete(struct ccid *ccid, struct sock *sk)
253 {
254         ccid_delete(ccid, sk, 0);
255 }
256
257 EXPORT_SYMBOL_GPL(ccid_hc_tx_delete);