net/atm/resources.c

   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 ? -EINVAL : 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 }