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