SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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
  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);