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 spin_unlock_wait(&ccids_lock); 44 } 45 46 static inline void ccids_read_unlock(void) 47 { 48 atomic_dec(&ccids_lockct); 49 } 50 51 #else 52 #define ccids_write_lock() do { } while(0) 53 #define ccids_write_unlock() do { } while(0) 54 #define ccids_read_lock() do { } while(0) 55 #define ccids_read_unlock() do { } while(0) 56 #endif 57 58 static struct kmem_cache *ccid_kmem_cache_create(int obj_size, const char *fmt,...) 59 { 60 struct kmem_cache *slab; 61 char slab_name_fmt[32], *slab_name; 62 va_list args; 63 64 va_start(args, fmt); 65 vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args); 66 va_end(args); 67 68 slab_name = kstrdup(slab_name_fmt, GFP_KERNEL); 69 if (slab_name == NULL) 70 return NULL; 71 slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0, 72 SLAB_HWCACHE_ALIGN, NULL); 73 if (slab == NULL) 74 kfree(slab_name); 75 return slab; 76 } 77 78 static void ccid_kmem_cache_destroy(struct kmem_cache *slab) 79 { 80 if (slab != NULL) { 81 const char *name = kmem_cache_name(slab); 82 83 kmem_cache_destroy(slab); 84 kfree(name); 85 } 86 } 87 88 int ccid_register(struct ccid_operations *ccid_ops) 89 { 90 int err = -ENOBUFS; 91 92 ccid_ops->ccid_hc_rx_slab = 93 ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size, 94 "%s_hc_rx_sock", 95 ccid_ops->ccid_name); 96 if (ccid_ops->ccid_hc_rx_slab == NULL) 97 goto out; 98 99 ccid_ops->ccid_hc_tx_slab = 100 ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size, 101 "%s_hc_tx_sock", 102 ccid_ops->ccid_name); 103 if (ccid_ops->ccid_hc_tx_slab == NULL) 104 goto out_free_rx_slab; 105 106 ccids_write_lock(); 107 err = -EEXIST; 108 if (ccids[ccid_ops->ccid_id] == NULL) { 109 ccids[ccid_ops->ccid_id] = ccid_ops; 110 err = 0; 111 } 112 ccids_write_unlock(); 113 if (err != 0) 114 goto out_free_tx_slab; 115 116 pr_info("CCID: Registered CCID %d (%s)\n", 117 ccid_ops->ccid_id, ccid_ops->ccid_name); 118 out: 119 return err; 120 out_free_tx_slab: 121 ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab); 122 ccid_ops->ccid_hc_tx_slab = NULL; 123 goto out; 124 out_free_rx_slab: 125 ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab); 126 ccid_ops->ccid_hc_rx_slab = NULL; 127 goto out; 128 } 129 130 EXPORT_SYMBOL_GPL(ccid_register); 131 132 int ccid_unregister(struct ccid_operations *ccid_ops) 133 { 134 ccids_write_lock(); 135 ccids[ccid_ops->ccid_id] = NULL; 136 ccids_write_unlock(); 137 138 ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab); 139 ccid_ops->ccid_hc_tx_slab = NULL; 140 ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab); 141 ccid_ops->ccid_hc_rx_slab = NULL; 142 143 pr_info("CCID: Unregistered CCID %d (%s)\n", 144 ccid_ops->ccid_id, ccid_ops->ccid_name); 145 return 0; 146 } 147 148 EXPORT_SYMBOL_GPL(ccid_unregister); 149 150 struct ccid *ccid_new(unsigned char id, struct sock *sk, int rx, gfp_t gfp) 151 { 152 struct ccid_operations *ccid_ops; 153 struct ccid *ccid = NULL; 154 155 ccids_read_lock(); 156 #ifdef CONFIG_KMOD 157 if (ccids[id] == NULL) { 158 /* We only try to load if in process context */ 159 ccids_read_unlock(); 160 if (gfp & GFP_ATOMIC) 161 goto out; 162 request_module("net-dccp-ccid-%d", id); 163 ccids_read_lock(); 164 } 165 #endif 166 ccid_ops = ccids[id]; 167 if (ccid_ops == NULL) 168 goto out_unlock; 169 170 if (!try_module_get(ccid_ops->ccid_owner)) 171 goto out_unlock; 172 173 ccids_read_unlock(); 174 175 ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab : 176 ccid_ops->ccid_hc_tx_slab, gfp); 177 if (ccid == NULL) 178 goto out_module_put; 179 ccid->ccid_ops = ccid_ops; 180 if (rx) { 181 memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size); 182 if (ccid->ccid_ops->ccid_hc_rx_init != NULL && 183 ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0) 184 goto out_free_ccid; 185 } else { 186 memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size); 187 if (ccid->ccid_ops->ccid_hc_tx_init != NULL && 188 ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0) 189 goto out_free_ccid; 190 } 191 out: 192 return ccid; 193 out_unlock: 194 ccids_read_unlock(); 195 goto out; 196 out_free_ccid: 197 kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab : 198 ccid_ops->ccid_hc_tx_slab, ccid); 199 ccid = NULL; 200 out_module_put: 201 module_put(ccid_ops->ccid_owner); 202 goto out; 203 } 204 205 EXPORT_SYMBOL_GPL(ccid_new); 206 207 struct ccid *ccid_hc_rx_new(unsigned char id, struct sock *sk, gfp_t gfp) 208 { 209 return ccid_new(id, sk, 1, gfp); 210 } 211 212 EXPORT_SYMBOL_GPL(ccid_hc_rx_new); 213 214 struct ccid *ccid_hc_tx_new(unsigned char id,struct sock *sk, gfp_t gfp) 215 { 216 return ccid_new(id, sk, 0, gfp); 217 } 218 219 EXPORT_SYMBOL_GPL(ccid_hc_tx_new); 220 221 static void ccid_delete(struct ccid *ccid, struct sock *sk, int rx) 222 { 223 struct ccid_operations *ccid_ops; 224 225 if (ccid == NULL) 226 return; 227 228 ccid_ops = ccid->ccid_ops; 229 if (rx) { 230 if (ccid_ops->ccid_hc_rx_exit != NULL) 231 ccid_ops->ccid_hc_rx_exit(sk); 232 kmem_cache_free(ccid_ops->ccid_hc_rx_slab, ccid); 233 } else { 234 if (ccid_ops->ccid_hc_tx_exit != NULL) 235 ccid_ops->ccid_hc_tx_exit(sk); 236 kmem_cache_free(ccid_ops->ccid_hc_tx_slab, ccid); 237 } 238 ccids_read_lock(); 239 if (ccids[ccid_ops->ccid_id] != NULL) 240 module_put(ccid_ops->ccid_owner); 241 ccids_read_unlock(); 242 } 243 244 void ccid_hc_rx_delete(struct ccid *ccid, struct sock *sk) 245 { 246 ccid_delete(ccid, sk, 1); 247 } 248 249 EXPORT_SYMBOL_GPL(ccid_hc_rx_delete); 250 251 void ccid_hc_tx_delete(struct ccid *ccid, struct sock *sk) 252 { 253 ccid_delete(ccid, sk, 0); 254 } 255 256 EXPORT_SYMBOL_GPL(ccid_hc_tx_delete); 257