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 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ 11 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 #include <linux/slab.h> 23 24 #include <net/sock.h> /* for struct sock */ 25 26 #include "common.h" 27 #include "resources.h" 28 #include "addr.h" 29 30 31 LIST_HEAD(atm_devs); 32 DEFINE_MUTEX(atm_dev_mutex); 33 34 static struct atm_dev *__alloc_atm_dev(const char *type) 35 { 36 struct atm_dev *dev; 37 38 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 39 if (!dev) 40 return NULL; 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 EXPORT_SYMBOL(atm_dev_lookup); 76 77 struct atm_dev *atm_dev_register(const char *type, struct device *parent, 78 const struct atmdev_ops *ops, int number, 79 unsigned long *flags) 80 { 81 struct atm_dev *dev, *inuse; 82 83 dev = __alloc_atm_dev(type); 84 if (!dev) { 85 pr_err("no space for dev %s\n", type); 86 return NULL; 87 } 88 mutex_lock(&atm_dev_mutex); 89 if (number != -1) { 90 inuse = __atm_dev_lookup(number); 91 if (inuse) { 92 atm_dev_put(inuse); 93 mutex_unlock(&atm_dev_mutex); 94 kfree(dev); 95 return NULL; 96 } 97 dev->number = number; 98 } else { 99 dev->number = 0; 100 while ((inuse = __atm_dev_lookup(dev->number))) { 101 atm_dev_put(inuse); 102 dev->number++; 103 } 104 } 105 106 dev->ops = ops; 107 if (flags) 108 dev->flags = *flags; 109 else 110 memset(&dev->flags, 0, sizeof(dev->flags)); 111 memset(&dev->stats, 0, sizeof(dev->stats)); 112 atomic_set(&dev->refcnt, 1); 113 114 if (atm_proc_dev_register(dev) < 0) { 115 pr_err("atm_proc_dev_register failed for dev %s\n", type); 116 goto out_fail; 117 } 118 119 if (atm_register_sysfs(dev, parent) < 0) { 120 pr_err("atm_register_sysfs failed for dev %s\n", type); 121 atm_proc_dev_deregister(dev); 122 goto out_fail; 123 } 124 125 list_add_tail(&dev->dev_list, &atm_devs); 126 127 out: 128 mutex_unlock(&atm_dev_mutex); 129 return dev; 130 131 out_fail: 132 kfree(dev); 133 dev = NULL; 134 goto out; 135 } 136 EXPORT_SYMBOL(atm_dev_register); 137 138 void atm_dev_deregister(struct atm_dev *dev) 139 { 140 BUG_ON(test_bit(ATM_DF_REMOVED, &dev->flags)); 141 set_bit(ATM_DF_REMOVED, &dev->flags); 142 143 /* 144 * if we remove current device from atm_devs list, new device 145 * with same number can appear, such we need deregister proc, 146 * release async all vccs and remove them from vccs list too 147 */ 148 mutex_lock(&atm_dev_mutex); 149 list_del(&dev->dev_list); 150 mutex_unlock(&atm_dev_mutex); 151 152 atm_dev_release_vccs(dev); 153 atm_unregister_sysfs(dev); 154 atm_proc_dev_deregister(dev); 155 156 atm_dev_put(dev); 157 } 158 EXPORT_SYMBOL(atm_dev_deregister); 159 160 static void copy_aal_stats(struct k_atm_aal_stats *from, 161 struct atm_aal_stats *to) 162 { 163 #define __HANDLE_ITEM(i) to->i = atomic_read(&from->i) 164 __AAL_STAT_ITEMS 165 #undef __HANDLE_ITEM 166 } 167 168 static void subtract_aal_stats(struct k_atm_aal_stats *from, 169 struct atm_aal_stats *to) 170 { 171 #define __HANDLE_ITEM(i) atomic_sub(to->i, &from->i) 172 __AAL_STAT_ITEMS 173 #undef __HANDLE_ITEM 174 } 175 176 static int fetch_stats(struct atm_dev *dev, struct atm_dev_stats __user *arg, 177 int zero) 178 { 179 struct atm_dev_stats tmp; 180 int error = 0; 181 182 copy_aal_stats(&dev->stats.aal0, &tmp.aal0); 183 copy_aal_stats(&dev->stats.aal34, &tmp.aal34); 184 copy_aal_stats(&dev->stats.aal5, &tmp.aal5); 185 if (arg) 186 error = copy_to_user(arg, &tmp, sizeof(tmp)); 187 if (zero && !error) { 188 subtract_aal_stats(&dev->stats.aal0, &tmp.aal0); 189 subtract_aal_stats(&dev->stats.aal34, &tmp.aal34); 190 subtract_aal_stats(&dev->stats.aal5, &tmp.aal5); 191 } 192 return error ? -EFAULT : 0; 193 } 194 195 int atm_dev_ioctl(unsigned int cmd, void __user *arg, int compat) 196 { 197 void __user *buf; 198 int error, len, number, size = 0; 199 struct atm_dev *dev; 200 struct list_head *p; 201 int *tmp_buf, *tmp_p; 202 int __user *sioc_len; 203 int __user *iobuf_len; 204 205 #ifndef CONFIG_COMPAT 206 compat = 0; /* Just so the compiler _knows_ */ 207 #endif 208 209 switch (cmd) { 210 case ATM_GETNAMES: 211 if (compat) { 212 #ifdef CONFIG_COMPAT 213 struct compat_atm_iobuf __user *ciobuf = arg; 214 compat_uptr_t cbuf; 215 iobuf_len = &ciobuf->length; 216 if (get_user(cbuf, &ciobuf->buffer)) 217 return -EFAULT; 218 buf = compat_ptr(cbuf); 219 #endif 220 } else { 221 struct atm_iobuf __user *iobuf = arg; 222 iobuf_len = &iobuf->length; 223 if (get_user(buf, &iobuf->buffer)) 224 return -EFAULT; 225 } 226 if (get_user(len, iobuf_len)) 227 return -EFAULT; 228 mutex_lock(&atm_dev_mutex); 229 list_for_each(p, &atm_devs) 230 size += sizeof(int); 231 if (size > len) { 232 mutex_unlock(&atm_dev_mutex); 233 return -E2BIG; 234 } 235 tmp_buf = kmalloc(size, GFP_ATOMIC); 236 if (!tmp_buf) { 237 mutex_unlock(&atm_dev_mutex); 238 return -ENOMEM; 239 } 240 tmp_p = tmp_buf; 241 list_for_each(p, &atm_devs) { 242 dev = list_entry(p, struct atm_dev, dev_list); 243 *tmp_p++ = dev->number; 244 } 245 mutex_unlock(&atm_dev_mutex); 246 error = ((copy_to_user(buf, tmp_buf, size)) || 247 put_user(size, iobuf_len)) 248 ? -EFAULT : 0; 249 kfree(tmp_buf); 250 return error; 251 default: 252 break; 253 } 254 255 if (compat) { 256 #ifdef CONFIG_COMPAT 257 struct compat_atmif_sioc __user *csioc = arg; 258 compat_uptr_t carg; 259 260 sioc_len = &csioc->length; 261 if (get_user(carg, &csioc->arg)) 262 return -EFAULT; 263 buf = compat_ptr(carg); 264 265 if (get_user(len, &csioc->length)) 266 return -EFAULT; 267 if (get_user(number, &csioc->number)) 268 return -EFAULT; 269 #endif 270 } else { 271 struct atmif_sioc __user *sioc = arg; 272 273 sioc_len = &sioc->length; 274 if (get_user(buf, &sioc->arg)) 275 return -EFAULT; 276 if (get_user(len, &sioc->length)) 277 return -EFAULT; 278 if (get_user(number, &sioc->number)) 279 return -EFAULT; 280 } 281 282 dev = try_then_request_module(atm_dev_lookup(number), "atm-device-%d", 283 number); 284 if (!dev) 285 return -ENODEV; 286 287 switch (cmd) { 288 case ATM_GETTYPE: 289 size = strlen(dev->type) + 1; 290 if (copy_to_user(buf, dev->type, size)) { 291 error = -EFAULT; 292 goto done; 293 } 294 break; 295 case ATM_GETESI: 296 size = ESI_LEN; 297 if (copy_to_user(buf, dev->esi, size)) { 298 error = -EFAULT; 299 goto done; 300 } 301 break; 302 case ATM_SETESI: 303 { 304 int i; 305 306 for (i = 0; i < ESI_LEN; i++) 307 if (dev->esi[i]) { 308 error = -EEXIST; 309 goto done; 310 } 311 } 312 /* fall through */ 313 case ATM_SETESIF: 314 { 315 unsigned char esi[ESI_LEN]; 316 317 if (!capable(CAP_NET_ADMIN)) { 318 error = -EPERM; 319 goto done; 320 } 321 if (copy_from_user(esi, buf, ESI_LEN)) { 322 error = -EFAULT; 323 goto done; 324 } 325 memcpy(dev->esi, esi, ESI_LEN); 326 error = ESI_LEN; 327 goto done; 328 } 329 case ATM_GETSTATZ: 330 if (!capable(CAP_NET_ADMIN)) { 331 error = -EPERM; 332 goto done; 333 } 334 /* fall through */ 335 case ATM_GETSTAT: 336 size = sizeof(struct atm_dev_stats); 337 error = fetch_stats(dev, buf, cmd == ATM_GETSTATZ); 338 if (error) 339 goto done; 340 break; 341 case ATM_GETCIRANGE: 342 size = sizeof(struct atm_cirange); 343 if (copy_to_user(buf, &dev->ci_range, size)) { 344 error = -EFAULT; 345 goto done; 346 } 347 break; 348 case ATM_GETLINKRATE: 349 size = sizeof(int); 350 if (copy_to_user(buf, &dev->link_rate, size)) { 351 error = -EFAULT; 352 goto done; 353 } 354 break; 355 case ATM_RSTADDR: 356 if (!capable(CAP_NET_ADMIN)) { 357 error = -EPERM; 358 goto done; 359 } 360 atm_reset_addr(dev, ATM_ADDR_LOCAL); 361 break; 362 case ATM_ADDADDR: 363 case ATM_DELADDR: 364 case ATM_ADDLECSADDR: 365 case ATM_DELLECSADDR: 366 { 367 struct sockaddr_atmsvc addr; 368 369 if (!capable(CAP_NET_ADMIN)) { 370 error = -EPERM; 371 goto done; 372 } 373 374 if (copy_from_user(&addr, buf, sizeof(addr))) { 375 error = -EFAULT; 376 goto done; 377 } 378 if (cmd == ATM_ADDADDR || cmd == ATM_ADDLECSADDR) 379 error = atm_add_addr(dev, &addr, 380 (cmd == ATM_ADDADDR ? 381 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 382 else 383 error = atm_del_addr(dev, &addr, 384 (cmd == ATM_DELADDR ? 385 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 386 goto done; 387 } 388 case ATM_GETADDR: 389 case ATM_GETLECSADDR: 390 error = atm_get_addr(dev, buf, len, 391 (cmd == ATM_GETADDR ? 392 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 393 if (error < 0) 394 goto done; 395 size = error; 396 /* may return 0, but later on size == 0 means "don't 397 write the length" */ 398 error = put_user(size, sioc_len) ? -EFAULT : 0; 399 goto done; 400 case ATM_SETLOOP: 401 if (__ATM_LM_XTRMT((int) (unsigned long) buf) && 402 __ATM_LM_XTLOC((int) (unsigned long) buf) > 403 __ATM_LM_XTRMT((int) (unsigned long) buf)) { 404 error = -EINVAL; 405 goto done; 406 } 407 /* fall through */ 408 case ATM_SETCIRANGE: 409 case SONET_GETSTATZ: 410 case SONET_SETDIAG: 411 case SONET_CLRDIAG: 412 case SONET_SETFRAMING: 413 if (!capable(CAP_NET_ADMIN)) { 414 error = -EPERM; 415 goto done; 416 } 417 /* fall through */ 418 default: 419 if (compat) { 420 #ifdef CONFIG_COMPAT 421 if (!dev->ops->compat_ioctl) { 422 error = -EINVAL; 423 goto done; 424 } 425 size = dev->ops->compat_ioctl(dev, cmd, buf); 426 #endif 427 } else { 428 if (!dev->ops->ioctl) { 429 error = -EINVAL; 430 goto done; 431 } 432 size = dev->ops->ioctl(dev, cmd, buf); 433 } 434 if (size < 0) { 435 error = (size == -ENOIOCTLCMD ? -ENOTTY : size); 436 goto done; 437 } 438 } 439 440 if (size) 441 error = put_user(size, sioc_len) ? -EFAULT : 0; 442 else 443 error = 0; 444 done: 445 atm_dev_put(dev); 446 return error; 447 } 448 449 void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos) 450 { 451 mutex_lock(&atm_dev_mutex); 452 return seq_list_start_head(&atm_devs, *pos); 453 } 454 455 void atm_dev_seq_stop(struct seq_file *seq, void *v) 456 { 457 mutex_unlock(&atm_dev_mutex); 458 } 459 460 void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos) 461 { 462 return seq_list_next(v, &atm_devs, pos); 463 } 464