1 /* net/atm/resources.c - Statically allocated resources */ 2 3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */ 4 5 /* Fixes 6 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 7 * 2002/01 - don't free the whole struct sock on sk->destruct time, 8 * use the default destruct function initialized by sock_init_data */ 9 10 11 #include <linux/config.h> 12 #include <linux/ctype.h> 13 #include <linux/string.h> 14 #include <linux/atmdev.h> 15 #include <linux/sonet.h> 16 #include <linux/kernel.h> /* for barrier */ 17 #include <linux/module.h> 18 #include <linux/bitops.h> 19 #include <linux/capability.h> 20 #include <linux/delay.h> 21 #include <linux/mutex.h> 22 23 #include <net/sock.h> /* for struct sock */ 24 25 #include "common.h" 26 #include "resources.h" 27 #include "addr.h" 28 29 30 LIST_HEAD(atm_devs); 31 DEFINE_MUTEX(atm_dev_mutex); 32 33 static struct atm_dev *__alloc_atm_dev(const char *type) 34 { 35 struct atm_dev *dev; 36 37 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 38 if (!dev) 39 return NULL; 40 memset(dev, 0, sizeof(*dev)); 41 dev->type = type; 42 dev->signal = ATM_PHY_SIG_UNKNOWN; 43 dev->link_rate = ATM_OC3_PCR; 44 spin_lock_init(&dev->lock); 45 INIT_LIST_HEAD(&dev->local); 46 INIT_LIST_HEAD(&dev->lecs); 47 48 return dev; 49 } 50 51 static struct atm_dev *__atm_dev_lookup(int number) 52 { 53 struct atm_dev *dev; 54 struct list_head *p; 55 56 list_for_each(p, &atm_devs) { 57 dev = list_entry(p, struct atm_dev, dev_list); 58 if (dev->number == number) { 59 atm_dev_hold(dev); 60 return dev; 61 } 62 } 63 return NULL; 64 } 65 66 struct atm_dev *atm_dev_lookup(int number) 67 { 68 struct atm_dev *dev; 69 70 mutex_lock(&atm_dev_mutex); 71 dev = __atm_dev_lookup(number); 72 mutex_unlock(&atm_dev_mutex); 73 return dev; 74 } 75 76 77 struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops, 78 int number, unsigned long *flags) 79 { 80 struct atm_dev *dev, *inuse; 81 82 dev = __alloc_atm_dev(type); 83 if (!dev) { 84 printk(KERN_ERR "atm_dev_register: no space for dev %s\n", 85 type); 86 return NULL; 87 } 88 mutex_lock(&atm_dev_mutex); 89 if (number != -1) { 90 if ((inuse = __atm_dev_lookup(number))) { 91 atm_dev_put(inuse); 92 mutex_unlock(&atm_dev_mutex); 93 kfree(dev); 94 return NULL; 95 } 96 dev->number = number; 97 } else { 98 dev->number = 0; 99 while ((inuse = __atm_dev_lookup(dev->number))) { 100 atm_dev_put(inuse); 101 dev->number++; 102 } 103 } 104 105 dev->ops = ops; 106 if (flags) 107 dev->flags = *flags; 108 else 109 memset(&dev->flags, 0, sizeof(dev->flags)); 110 memset(&dev->stats, 0, sizeof(dev->stats)); 111 atomic_set(&dev->refcnt, 1); 112 113 if (atm_proc_dev_register(dev) < 0) { 114 printk(KERN_ERR "atm_dev_register: " 115 "atm_proc_dev_register failed for dev %s\n", 116 type); 117 mutex_unlock(&atm_dev_mutex); 118 kfree(dev); 119 return NULL; 120 } 121 list_add_tail(&dev->dev_list, &atm_devs); 122 mutex_unlock(&atm_dev_mutex); 123 124 return dev; 125 } 126 127 128 void atm_dev_deregister(struct atm_dev *dev) 129 { 130 BUG_ON(test_bit(ATM_DF_REMOVED, &dev->flags)); 131 set_bit(ATM_DF_REMOVED, &dev->flags); 132 133 /* 134 * if we remove current device from atm_devs list, new device 135 * with same number can appear, such we need deregister proc, 136 * release async all vccs and remove them from vccs list too 137 */ 138 mutex_lock(&atm_dev_mutex); 139 list_del(&dev->dev_list); 140 mutex_unlock(&atm_dev_mutex); 141 142 atm_dev_release_vccs(dev); 143 atm_proc_dev_deregister(dev); 144 145 atm_dev_put(dev); 146 } 147 148 149 static void copy_aal_stats(struct k_atm_aal_stats *from, 150 struct atm_aal_stats *to) 151 { 152 #define __HANDLE_ITEM(i) to->i = atomic_read(&from->i) 153 __AAL_STAT_ITEMS 154 #undef __HANDLE_ITEM 155 } 156 157 158 static void subtract_aal_stats(struct k_atm_aal_stats *from, 159 struct atm_aal_stats *to) 160 { 161 #define __HANDLE_ITEM(i) atomic_sub(to->i, &from->i) 162 __AAL_STAT_ITEMS 163 #undef __HANDLE_ITEM 164 } 165 166 167 static int fetch_stats(struct atm_dev *dev, struct atm_dev_stats __user *arg, int zero) 168 { 169 struct atm_dev_stats tmp; 170 int error = 0; 171 172 copy_aal_stats(&dev->stats.aal0, &tmp.aal0); 173 copy_aal_stats(&dev->stats.aal34, &tmp.aal34); 174 copy_aal_stats(&dev->stats.aal5, &tmp.aal5); 175 if (arg) 176 error = copy_to_user(arg, &tmp, sizeof(tmp)); 177 if (zero && !error) { 178 subtract_aal_stats(&dev->stats.aal0, &tmp.aal0); 179 subtract_aal_stats(&dev->stats.aal34, &tmp.aal34); 180 subtract_aal_stats(&dev->stats.aal5, &tmp.aal5); 181 } 182 return error ? -EFAULT : 0; 183 } 184 185 186 int atm_dev_ioctl(unsigned int cmd, void __user *arg) 187 { 188 void __user *buf; 189 int error, len, number, size = 0; 190 struct atm_dev *dev; 191 struct list_head *p; 192 int *tmp_buf, *tmp_p; 193 struct atm_iobuf __user *iobuf = arg; 194 struct atmif_sioc __user *sioc = arg; 195 switch (cmd) { 196 case ATM_GETNAMES: 197 if (get_user(buf, &iobuf->buffer)) 198 return -EFAULT; 199 if (get_user(len, &iobuf->length)) 200 return -EFAULT; 201 mutex_lock(&atm_dev_mutex); 202 list_for_each(p, &atm_devs) 203 size += sizeof(int); 204 if (size > len) { 205 mutex_unlock(&atm_dev_mutex); 206 return -E2BIG; 207 } 208 tmp_buf = kmalloc(size, GFP_ATOMIC); 209 if (!tmp_buf) { 210 mutex_unlock(&atm_dev_mutex); 211 return -ENOMEM; 212 } 213 tmp_p = tmp_buf; 214 list_for_each(p, &atm_devs) { 215 dev = list_entry(p, struct atm_dev, dev_list); 216 *tmp_p++ = dev->number; 217 } 218 mutex_unlock(&atm_dev_mutex); 219 error = ((copy_to_user(buf, tmp_buf, size)) || 220 put_user(size, &iobuf->length)) 221 ? -EFAULT : 0; 222 kfree(tmp_buf); 223 return error; 224 default: 225 break; 226 } 227 228 if (get_user(buf, &sioc->arg)) 229 return -EFAULT; 230 if (get_user(len, &sioc->length)) 231 return -EFAULT; 232 if (get_user(number, &sioc->number)) 233 return -EFAULT; 234 235 if (!(dev = try_then_request_module(atm_dev_lookup(number), 236 "atm-device-%d", number))) 237 return -ENODEV; 238 239 switch (cmd) { 240 case ATM_GETTYPE: 241 size = strlen(dev->type) + 1; 242 if (copy_to_user(buf, dev->type, size)) { 243 error = -EFAULT; 244 goto done; 245 } 246 break; 247 case ATM_GETESI: 248 size = ESI_LEN; 249 if (copy_to_user(buf, dev->esi, size)) { 250 error = -EFAULT; 251 goto done; 252 } 253 break; 254 case ATM_SETESI: 255 { 256 int i; 257 258 for (i = 0; i < ESI_LEN; i++) 259 if (dev->esi[i]) { 260 error = -EEXIST; 261 goto done; 262 } 263 } 264 /* fall through */ 265 case ATM_SETESIF: 266 { 267 unsigned char esi[ESI_LEN]; 268 269 if (!capable(CAP_NET_ADMIN)) { 270 error = -EPERM; 271 goto done; 272 } 273 if (copy_from_user(esi, buf, ESI_LEN)) { 274 error = -EFAULT; 275 goto done; 276 } 277 memcpy(dev->esi, esi, ESI_LEN); 278 error = ESI_LEN; 279 goto done; 280 } 281 case ATM_GETSTATZ: 282 if (!capable(CAP_NET_ADMIN)) { 283 error = -EPERM; 284 goto done; 285 } 286 /* fall through */ 287 case ATM_GETSTAT: 288 size = sizeof(struct atm_dev_stats); 289 error = fetch_stats(dev, buf, cmd == ATM_GETSTATZ); 290 if (error) 291 goto done; 292 break; 293 case ATM_GETCIRANGE: 294 size = sizeof(struct atm_cirange); 295 if (copy_to_user(buf, &dev->ci_range, size)) { 296 error = -EFAULT; 297 goto done; 298 } 299 break; 300 case ATM_GETLINKRATE: 301 size = sizeof(int); 302 if (copy_to_user(buf, &dev->link_rate, size)) { 303 error = -EFAULT; 304 goto done; 305 } 306 break; 307 case ATM_RSTADDR: 308 if (!capable(CAP_NET_ADMIN)) { 309 error = -EPERM; 310 goto done; 311 } 312 atm_reset_addr(dev, ATM_ADDR_LOCAL); 313 break; 314 case ATM_ADDADDR: 315 case ATM_DELADDR: 316 case ATM_ADDLECSADDR: 317 case ATM_DELLECSADDR: 318 if (!capable(CAP_NET_ADMIN)) { 319 error = -EPERM; 320 goto done; 321 } 322 { 323 struct sockaddr_atmsvc addr; 324 325 if (copy_from_user(&addr, buf, sizeof(addr))) { 326 error = -EFAULT; 327 goto done; 328 } 329 if (cmd == ATM_ADDADDR || cmd == ATM_ADDLECSADDR) 330 error = atm_add_addr(dev, &addr, 331 (cmd == ATM_ADDADDR ? 332 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 333 else 334 error = atm_del_addr(dev, &addr, 335 (cmd == ATM_DELADDR ? 336 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 337 goto done; 338 } 339 case ATM_GETADDR: 340 case ATM_GETLECSADDR: 341 error = atm_get_addr(dev, buf, len, 342 (cmd == ATM_GETADDR ? 343 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 344 if (error < 0) 345 goto done; 346 size = error; 347 /* may return 0, but later on size == 0 means "don't 348 write the length" */ 349 error = put_user(size, &sioc->length) 350 ? -EFAULT : 0; 351 goto done; 352 case ATM_SETLOOP: 353 if (__ATM_LM_XTRMT((int) (unsigned long) buf) && 354 __ATM_LM_XTLOC((int) (unsigned long) buf) > 355 __ATM_LM_XTRMT((int) (unsigned long) buf)) { 356 error = -EINVAL; 357 goto done; 358 } 359 /* fall through */ 360 case ATM_SETCIRANGE: 361 case SONET_GETSTATZ: 362 case SONET_SETDIAG: 363 case SONET_CLRDIAG: 364 case SONET_SETFRAMING: 365 if (!capable(CAP_NET_ADMIN)) { 366 error = -EPERM; 367 goto done; 368 } 369 /* fall through */ 370 default: 371 if (!dev->ops->ioctl) { 372 error = -EINVAL; 373 goto done; 374 } 375 size = dev->ops->ioctl(dev, cmd, buf); 376 if (size < 0) { 377 error = (size == -ENOIOCTLCMD ? -EINVAL : size); 378 goto done; 379 } 380 } 381 382 if (size) 383 error = put_user(size, &sioc->length) 384 ? -EFAULT : 0; 385 else 386 error = 0; 387 done: 388 atm_dev_put(dev); 389 return error; 390 } 391 392 static __inline__ void *dev_get_idx(loff_t left) 393 { 394 struct list_head *p; 395 396 list_for_each(p, &atm_devs) { 397 if (!--left) 398 break; 399 } 400 return (p != &atm_devs) ? p : NULL; 401 } 402 403 void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos) 404 { 405 mutex_lock(&atm_dev_mutex); 406 return *pos ? dev_get_idx(*pos) : (void *) 1; 407 } 408 409 void atm_dev_seq_stop(struct seq_file *seq, void *v) 410 { 411 mutex_unlock(&atm_dev_mutex); 412 } 413 414 void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos) 415 { 416 ++*pos; 417 v = (v == (void *)1) ? atm_devs.next : ((struct list_head *)v)->next; 418 return (v == &atm_devs) ? NULL : v; 419 } 420 421 422 EXPORT_SYMBOL(atm_dev_register); 423 EXPORT_SYMBOL(atm_dev_deregister); 424 EXPORT_SYMBOL(atm_dev_lookup); 425