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_getnames(void __user *buf, int __user *iobuf_len) 197 { 198 int error, len, size = 0; 199 struct atm_dev *dev; 200 struct list_head *p; 201 int *tmp_buf, *tmp_p; 202 203 if (get_user(len, iobuf_len)) 204 return -EFAULT; 205 mutex_lock(&atm_dev_mutex); 206 list_for_each(p, &atm_devs) 207 size += sizeof(int); 208 if (size > len) { 209 mutex_unlock(&atm_dev_mutex); 210 return -E2BIG; 211 } 212 tmp_buf = kmalloc(size, GFP_ATOMIC); 213 if (!tmp_buf) { 214 mutex_unlock(&atm_dev_mutex); 215 return -ENOMEM; 216 } 217 tmp_p = tmp_buf; 218 list_for_each(p, &atm_devs) { 219 dev = list_entry(p, struct atm_dev, dev_list); 220 *tmp_p++ = dev->number; 221 } 222 mutex_unlock(&atm_dev_mutex); 223 error = ((copy_to_user(buf, tmp_buf, size)) || 224 put_user(size, iobuf_len)) 225 ? -EFAULT : 0; 226 kfree(tmp_buf); 227 return error; 228 } 229 230 int atm_dev_ioctl(unsigned int cmd, void __user *buf, int __user *sioc_len, 231 int number, int compat) 232 { 233 int error, len, size = 0; 234 struct atm_dev *dev; 235 236 if (get_user(len, sioc_len)) 237 return -EFAULT; 238 239 dev = try_then_request_module(atm_dev_lookup(number), "atm-device-%d", 240 number); 241 if (!dev) 242 return -ENODEV; 243 244 switch (cmd) { 245 case ATM_GETTYPE: 246 size = strlen(dev->type) + 1; 247 if (copy_to_user(buf, dev->type, size)) { 248 error = -EFAULT; 249 goto done; 250 } 251 break; 252 case ATM_GETESI: 253 size = ESI_LEN; 254 if (copy_to_user(buf, dev->esi, size)) { 255 error = -EFAULT; 256 goto done; 257 } 258 break; 259 case ATM_SETESI: 260 { 261 int i; 262 263 for (i = 0; i < ESI_LEN; i++) 264 if (dev->esi[i]) { 265 error = -EEXIST; 266 goto done; 267 } 268 } 269 fallthrough; 270 case ATM_SETESIF: 271 { 272 unsigned char esi[ESI_LEN]; 273 274 if (!capable(CAP_NET_ADMIN)) { 275 error = -EPERM; 276 goto done; 277 } 278 if (copy_from_user(esi, buf, ESI_LEN)) { 279 error = -EFAULT; 280 goto done; 281 } 282 memcpy(dev->esi, esi, ESI_LEN); 283 error = ESI_LEN; 284 goto done; 285 } 286 case ATM_GETSTATZ: 287 if (!capable(CAP_NET_ADMIN)) { 288 error = -EPERM; 289 goto done; 290 } 291 fallthrough; 292 case ATM_GETSTAT: 293 size = sizeof(struct atm_dev_stats); 294 error = fetch_stats(dev, buf, cmd == ATM_GETSTATZ); 295 if (error) 296 goto done; 297 break; 298 case ATM_GETCIRANGE: 299 size = sizeof(struct atm_cirange); 300 if (copy_to_user(buf, &dev->ci_range, size)) { 301 error = -EFAULT; 302 goto done; 303 } 304 break; 305 case ATM_GETLINKRATE: 306 size = sizeof(int); 307 if (copy_to_user(buf, &dev->link_rate, size)) { 308 error = -EFAULT; 309 goto done; 310 } 311 break; 312 case ATM_RSTADDR: 313 if (!capable(CAP_NET_ADMIN)) { 314 error = -EPERM; 315 goto done; 316 } 317 atm_reset_addr(dev, ATM_ADDR_LOCAL); 318 break; 319 case ATM_ADDADDR: 320 case ATM_DELADDR: 321 case ATM_ADDLECSADDR: 322 case ATM_DELLECSADDR: 323 { 324 struct sockaddr_atmsvc addr; 325 326 if (!capable(CAP_NET_ADMIN)) { 327 error = -EPERM; 328 goto done; 329 } 330 331 if (copy_from_user(&addr, buf, sizeof(addr))) { 332 error = -EFAULT; 333 goto done; 334 } 335 if (cmd == ATM_ADDADDR || cmd == ATM_ADDLECSADDR) 336 error = atm_add_addr(dev, &addr, 337 (cmd == ATM_ADDADDR ? 338 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 339 else 340 error = atm_del_addr(dev, &addr, 341 (cmd == ATM_DELADDR ? 342 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 343 goto done; 344 } 345 case ATM_GETADDR: 346 case ATM_GETLECSADDR: 347 error = atm_get_addr(dev, buf, len, 348 (cmd == ATM_GETADDR ? 349 ATM_ADDR_LOCAL : ATM_ADDR_LECS)); 350 if (error < 0) 351 goto done; 352 size = error; 353 /* may return 0, but later on size == 0 means "don't 354 write the length" */ 355 error = put_user(size, sioc_len) ? -EFAULT : 0; 356 goto done; 357 case ATM_SETLOOP: 358 if (__ATM_LM_XTRMT((int) (unsigned long) buf) && 359 __ATM_LM_XTLOC((int) (unsigned long) buf) > 360 __ATM_LM_XTRMT((int) (unsigned long) buf)) { 361 error = -EINVAL; 362 goto done; 363 } 364 fallthrough; 365 case ATM_SETCIRANGE: 366 case SONET_GETSTATZ: 367 case SONET_SETDIAG: 368 case SONET_CLRDIAG: 369 case SONET_SETFRAMING: 370 if (!capable(CAP_NET_ADMIN)) { 371 error = -EPERM; 372 goto done; 373 } 374 fallthrough; 375 default: 376 if (IS_ENABLED(CONFIG_COMPAT) && compat) { 377 #ifdef CONFIG_COMPAT 378 if (!dev->ops->compat_ioctl) { 379 error = -EINVAL; 380 goto done; 381 } 382 size = dev->ops->compat_ioctl(dev, cmd, buf); 383 #endif 384 } else { 385 if (!dev->ops->ioctl) { 386 error = -EINVAL; 387 goto done; 388 } 389 size = dev->ops->ioctl(dev, cmd, buf); 390 } 391 if (size < 0) { 392 error = (size == -ENOIOCTLCMD ? -ENOTTY : size); 393 goto done; 394 } 395 } 396 397 if (size) 398 error = put_user(size, sioc_len) ? -EFAULT : 0; 399 else 400 error = 0; 401 done: 402 atm_dev_put(dev); 403 return error; 404 } 405 406 void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos) 407 { 408 mutex_lock(&atm_dev_mutex); 409 return seq_list_start_head(&atm_devs, *pos); 410 } 411 412 void atm_dev_seq_stop(struct seq_file *seq, void *v) 413 { 414 mutex_unlock(&atm_dev_mutex); 415 } 416 417 void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos) 418 { 419 return seq_list_next(v, &atm_devs, pos); 420 } 421