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