lustre/obdclass/class_obd.c

   1 /*
   2  *              An implementation of a loadable kernel mode driver providing
   3  *              multiple kernel/user space bidirectional communications links.
   4  *
   5  *              Author:         Alan Cox <alan@cymru.net>
   6  *
   7  *              This program is free software; you can redistribute it and/or
   8  *              modify it under the terms of the GNU General Public License
   9  *              version 2 as published by the Free Software Foundation.
  10  *
  11  *              Adapted to become the Linux 2.0 Coda pseudo device
  12  *              Peter  Braam  <braam@maths.ox.ac.uk>
  13  *              Michael Callahan <mjc@emmy.smith.edu>
  14  *
  15  *              Changes for Linux 2.1
  16  *              Copyright (c) 1997 Carnegie-Mellon University
  17  *
  18  *              Redone again for Intermezzo
  19  *              Copyright (c) 1998 Peter J. Braam
  20  *
  21  *              Hacked up again for simulated OBD
  22  *              Copyright (c) 1999 Stelias Computing, Inc.
  23  *                (authors {pschwan,braam}@stelias.com)
  24  *              Copyright (C) 1999 Seagate Technology, Inc.
  25  *              Copyright (C) 2001 Cluster File Systems, Inc.
  26  *
  27  *
  28  */
  29
  30 #define EXPORT_SYMTAB
  31 #include <linux/config.h> /* for CONFIG_PROC_FS */
  32 #include <linux/module.h>
  33 #include <linux/errno.h>
  34 #include <linux/kernel.h>
  35 #include <linux/major.h>
  36 #include <linux/kmod.h>   /* for request_module() */
  37 #include <linux/sched.h>
  38 #include <linux/lp.h>
  39 #include <linux/slab.h>
  40 #include <linux/ioport.h>
  41 #include <linux/fcntl.h>
  42 #include <linux/delay.h>
  43 #include <linux/skbuff.h>
  44 #include <linux/proc_fs.h>
  45 #include <linux/vmalloc.h>
  46 #include <linux/fs.h>
  47 #include <linux/poll.h>
  48 #include <linux/init.h>
  49 #include <linux/list.h>
  50 #include <asm/io.h>
  51 #include <asm/system.h>
  52 #include <asm/poll.h>
  53 #include <asm/uaccess.h>
  54 #include <linux/miscdevice.h>
  55
  56 #include <linux/obd_support.h>
  57 #include <linux/obd_class.h>
  58
  59 static int obd_init_magic;
  60 int obd_print_entry = 1;
  61 int obd_debug_level = ~0;
  62 long obd_memory = 0;
  63 struct obd_device obd_dev[MAX_OBD_DEVICES];
  64 struct list_head obd_types;
  65
  66 /*  opening /dev/obd */
  67 static int obd_class_open(struct inode * inode, struct file * file)
  68 {
  69         ENTRY;
  70
  71         file->private_data = NULL;
  72         MOD_INC_USE_COUNT;
  73         EXIT;
  74         return 0;
  75 }
  76
  77 /*  closing /dev/obd */
  78 static int obd_class_release(struct inode * inode, struct file * file)
  79 {
  80         ENTRY;
  81
  82         if (file->private_data)
  83                 file->private_data = NULL;
  84
  85         MOD_DEC_USE_COUNT;
  86         EXIT;
  87         return 0;
  88 }
  89
  90 /*
  91  * support functions: we could use inter-module communication, but this
  92  * is more portable to other OS's
  93  */
  94 static struct obd_type *obd_search_type(char *nm)
  95 {
  96         struct list_head *tmp;
  97         struct obd_type *type;
  98         CDEBUG(D_INFO, "SEARCH %s\n", nm);
  99
 100         tmp = &obd_types;
 101         while ( (tmp = tmp->next) != &obd_types ) {
 102                 type = list_entry(tmp, struct obd_type, typ_chain);
 103                 CDEBUG(D_INFO, "TYP %s\n", type->typ_name);
 104                 if (strlen(type->typ_name) == strlen(nm) &&
 105                     strcmp(type->typ_name, nm) == 0 ) {
 106                         return type;
 107                 }
 108         }
 109         return NULL;
 110 }
 111
 112 static struct obd_type *obd_nm_to_type(char *nm)
 113 {
 114         struct obd_type *type = obd_search_type(nm);
 115
 116 #ifdef CONFIG_KMOD
 117         if ( !type ) {
 118                 if ( !request_module(nm) ) {
 119                         CDEBUG(D_PSDEV, "Loaded module '%s'\n", nm);
 120                         type = obd_search_type(nm);
 121                 } else {
 122                         CDEBUG(D_PSDEV, "Can't load module '%s'\n", nm);
 123                 }
 124         }
 125 #endif
 126         return type;
 127 }
 128
 129 /* to control /dev/obd */
 130 static int obd_class_ioctl (struct inode * inode, struct file * filp,
 131                             unsigned int cmd, unsigned long arg)
 132 {
 133         /* NOTE this must be larger than any of the ioctl data structs */
 134         char buf[1024];
 135         struct obd_ioctl_data *data;
 136         struct obd_device *obd = filp->private_data;
 137         struct obd_conn conn;
 138         int err = 0;
 139         ENTRY;
 140
 141         memset(buf, 0, sizeof(buf));
 142
 143         if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS) {
 144                 printk("OBD ioctl: No device\n");
 145                 return -EINVAL;
 146         }
 147         if (obd_ioctl_getdata(buf, buf + 800, (void *)arg)) {
 148                 printk("OBD ioctl: data error\n");
 149                 return -EINVAL;
 150         }
 151         data = (struct obd_ioctl_data *)buf;
 152
 153         switch (cmd) {
 154         case TCGETS:
 155                 return -EINVAL;
 156         case OBD_IOC_DEVICE: {
 157                 CDEBUG(D_IOCTL, "\n");
 158                 if (data->ioc_dev >= MAX_OBD_DEVICES ||
 159                     data->ioc_dev < 0) {
 160                         printk("OBD ioctl: DEVICE insufficient devices\n");
 161                         return -EINVAL;
 162                 }
 163                 CDEBUG(D_IOCTL, "device %d\n", data->ioc_dev);
 164
 165                 filp->private_data = &obd_dev[data->ioc_dev];
 166                 EXIT;
 167                 return 0;
 168         }
 169
 170         case OBD_IOC_ATTACH: {
 171                 struct obd_type *type;
 172
 173                 ENTRY;
 174                 /* have we attached a type to this device */
 175                 if ( obd->obd_type ||  (obd->obd_flags & OBD_ATTACHED) ){
 176                         printk("OBD: Device %d already typed as  %s.\n",
 177                                obd->obd_minor, MKSTR(obd->obd_type->typ_name));
 178                         return -EBUSY;
 179                 }
 180
 181                 printk("-----> attach %s %s\n",  MKSTR(data->ioc_inlbuf1),
 182                        MKSTR(data->ioc_inlbuf2));
 183
 184                 /* find the type */
 185                 type = obd_nm_to_type(data->ioc_inlbuf1);
 186                 if ( !type ) {
 187                         printk("OBD: unknown type dev %d\n", obd->obd_minor);
 188                         return -EINVAL;
 189                 }
 190
 191                 obd->obd_type = type;
 192                 obd->obd_multi_count = 0;
 193                 INIT_LIST_HEAD(&obd->obd_gen_clients);
 194
 195                 /* do the attach */
 196                 if ( OBT(obd) && OBP(obd, attach) ) {
 197                         err = OBP(obd, attach)(obd, data);
 198                 }
 199
 200                 if ( err ) {
 201                         obd->obd_flags &= ~OBD_ATTACHED;
 202                         obd->obd_type = NULL;
 203                         EXIT;
 204                 } else {
 205                         obd->obd_flags |=  OBD_ATTACHED;
 206                         type->typ_refcnt++;
 207                         printk("OBD: dev %d attached type %s\n",
 208                                obd->obd_minor, data->ioc_inlbuf1);
 209                         obd->obd_proc_entry =
 210                                 proc_lustre_register_obd_device(obd);
 211                         MOD_INC_USE_COUNT;
 212                         EXIT;
 213                 }
 214
 215                 return err;
 216         }
 217
 218         case OBD_IOC_DETACH: {
 219                 ENTRY;
 220                 if (obd->obd_flags & OBD_SET_UP) {
 221                         printk("OBD device %d still set up\n", obd->obd_minor);
 222                         return -EBUSY;
 223                 }
 224                 if (! (obd->obd_flags & OBD_ATTACHED) ) {
 225                         printk("OBD device %d not attached\n", obd->obd_minor);
 226                         return -ENODEV;
 227                 }
 228                 if ( !list_empty(&obd->obd_gen_clients) ) {
 229                         printk("OBD device %d has connected clients\n", obd->obd_minor);
 230                         return -EBUSY;
 231                 }
 232
 233                 if (obd->obd_proc_entry)
 234                         proc_lustre_release_obd_device(obd);
 235
 236                 obd->obd_flags &= ~OBD_ATTACHED;
 237                 obd->obd_type->typ_refcnt--;
 238                 obd->obd_type = NULL;
 239                 MOD_DEC_USE_COUNT;
 240                 EXIT;
 241                 return 0;
 242         }
 243
 244         case OBD_IOC_SETUP: {
 245                 ENTRY;
 246                 /* have we attached a type to this device? */
 247                 if (!(obd->obd_flags & OBD_ATTACHED)) {
 248                         printk("Device %d not attached\n", obd->obd_minor);
 249                         return -ENODEV;
 250                 }
 251
 252                 /* has this been done already? */
 253                 if ( obd->obd_flags & OBD_SET_UP ) {
 254                         printk("Device %d already setup (type %s)\n",
 255                                obd->obd_minor, obd->obd_type->typ_name);
 256                         return -EBUSY;
 257                 }
 258
 259                 if ( OBT(obd) && OBP(obd, setup) )
 260                         err = OBP(obd, setup)(obd, data);
 261
 262                 if (!err) {
 263                         obd->obd_type->typ_refcnt++;
 264                         obd->obd_flags |= OBD_SET_UP;
 265                         EXIT;
 266                 }
 267
 268                 return err;
 269         }
 270         case OBD_IOC_CLEANUP: {
 271                 ENTRY;
 272                 /* has this minor been registered? */
 273                 if (!obd->obd_type) {
 274                         printk("OBD cleanup dev %d has no type.\n",
 275                                obd->obd_minor);
 276                         EXIT;
 277                         return -ENODEV;
 278                 }
 279
 280                 if ( (!(obd->obd_flags & OBD_SET_UP)) ||
 281                      (!(obd->obd_flags & OBD_ATTACHED))) {
 282                         printk("OBD cleanup device %d not attached/set up\n",
 283                                obd->obd_minor);
 284                         EXIT;
 285                         return -ENODEV;
 286                 }
 287
 288                 if ( !OBT(obd) || !OBP(obd, cleanup) )
 289                         goto cleanup_out;
 290
 291                 /* cleanup has no argument */
 292                 err = OBP(obd, cleanup)(obd);
 293                 if ( err ) {
 294                         EXIT;
 295                         return err;
 296                 }
 297
 298         cleanup_out:
 299                 obd->obd_flags &= ~OBD_SET_UP;
 300                 obd->obd_type->typ_refcnt--;
 301                 EXIT;
 302                 return 0;
 303         }
 304
 305         case OBD_IOC_CONNECT:
 306         {
 307                 if ( (!(obd->obd_flags & OBD_SET_UP)) ||
 308                      (!(obd->obd_flags & OBD_ATTACHED))) {
 309                         CDEBUG(D_IOCTL, "Device not attached or set up\n");
 310                         return -ENODEV;
 311                 }
 312
 313                 if ( !OBT(obd) || !OBP(obd, connect) )
 314                         return -EOPNOTSUPP;
 315
 316                 conn.oc_id = data->ioc_conn1;
 317                 conn.oc_dev = obd;
 318
 319                 err = OBP(obd, connect)(&conn);
 320                 CDEBUG(D_IOCTL, "assigned connection %d\n", conn.oc_id);
 321                 data->ioc_conn1 = conn.oc_id;
 322                 if ( err )
 323                         return err;
 324
 325                 return copy_to_user((int *)arg, data, sizeof(*data));
 326         }
 327         case OBD_IOC_DISCONNECT: {
 328
 329                 if (!obd->obd_type)
 330                         return -ENODEV;
 331
 332                 if ( !OBT(obd) || !OBP(obd, disconnect))
 333                         return -EOPNOTSUPP;
 334
 335                 conn.oc_id = data->ioc_conn1;
 336                 conn.oc_dev = obd;
 337                 OBP(obd, disconnect)(&conn);
 338                 return 0;
 339         }
 340
 341         case OBD_IOC_DEC_USE_COUNT: {
 342                 MOD_DEC_USE_COUNT;
 343                 return 0;
 344         }
 345
 346         case OBD_IOC_CREATE: {
 347                 /* has this minor been registered? */
 348                 if ( !(obd->obd_flags & OBD_ATTACHED) ||
 349                      !(obd->obd_flags & OBD_SET_UP)) {
 350                         CDEBUG(D_IOCTL, "Device not attached or set up\n");
 351                         return -ENODEV;
 352                 }
 353                 conn.oc_id = data->ioc_conn1;
 354                 conn.oc_dev = obd;
 355
 356                 if ( !OBT(obd) || !OBP(obd, create) )
 357                         return -EOPNOTSUPP;
 358
 359                 err = OBP(obd, create)(&conn, &data->ioc_obdo1);
 360                 if (err) {
 361                         EXIT;
 362                         return err;
 363                 }
 364
 365                 err = copy_to_user((int *)arg, data, sizeof(*data));
 366                 EXIT;
 367                 return err;
 368         }
 369 #if 0
 370         case OBD_IOC_SYNC: {
 371                 struct oic_range_s *range = tmp_buf;
 372
 373                 if (!obd->obd_type)
 374                         return -ENODEV;
 375
 376                 err = copy_from_user(range, (const void *)arg,  sizeof(*range));
 377
 378                 if ( err ) {
 379                         EXIT;
 380                         return err;
 381                 }
 382
 383                 if ( !OBT(obd) || !OBP(obd, sync) ) {
 384                         err = -EOPNOTSUPP;
 385                         EXIT;
 386                         return err;
 387                 }
 388
 389                 /* XXX sync needs to be tested/verified */
 390                 err = OBP(obd, sync)(&conn, &range->obdo, range->count,
 391                                         range->offset);
 392
 393                 if ( err ) {
 394                         EXIT;
 395                         return err;
 396                 }
 397
 398                 return put_user(err, (int *) arg);
 399         }
 400
 401         case OBD_IOC_DESTROY: {
 402                 struct oic_attr_s *attr = tmp_buf;
 403
 404                 /* has this minor been registered? */
 405                 if (!obd->obd_type)
 406                         return -ENODEV;
 407
 408                 err = copy_from_user(attr, (int *)arg, sizeof(*attr));
 409                 if ( err ) {
 410                         EXIT;
 411                         return err;
 412                 }
 413
 414                 if ( !OBT(obd) || !OBP(obd, destroy) )
 415                         return -EOPNOTSUPP;
 416
 417                 conn.oc_id = attr->conn_id;
 418                 err = OBP(obd, destroy)(&conn, &attr->obdo);
 419                 EXIT;
 420                 return err;
 421         }
 422
 423         case OBD_IOC_SETATTR: {
 424                 struct oic_attr_s *attr = tmp_buf;
 425
 426                 /* has this minor been registered? */
 427                 if (!obd->obd_type)
 428                         return -ENODEV;
 429
 430                 err = copy_from_user(attr, (int *)arg, sizeof(*attr));
 431                 if (err)
 432                         return err;
 433
 434                 if ( !OBT(obd) || !OBP(obd, setattr) )
 435                         return -EOPNOTSUPP;
 436
 437                 conn.oc_id = attr->conn_id;
 438                 err = OBP(obd, setattr)(&conn, &attr->obdo);
 439                 EXIT;
 440                 return err;
 441         }
 442
 443         case OBD_IOC_GETATTR: {
 444                 struct oic_attr_s *attr = tmp_buf;
 445
 446                 err = copy_from_user(attr, (int *)arg, sizeof(*attr));
 447                 if (err)
 448                         return err;
 449
 450                 conn.oc_id = attr->conn_id;
 451                 ODEBUG(&attr->obdo);
 452                 err = OBP(obd, getattr)(&conn, &attr->obdo);
 453                 if ( err ) {
 454                         EXIT;
 455                         return err;
 456                 }
 457
 458                 err = copy_to_user((int *)arg, attr, sizeof(*attr));
 459                 EXIT;
 460                 return err;
 461         }
 462
 463         case OBD_IOC_READ: {
 464                 int err;
 465                 struct oic_rw_s *rw_s = tmp_buf;  /* read, write ioctl str */
 466
 467                 err = copy_from_user(rw_s, (int *)arg, sizeof(*rw_s));
 468                 if ( err ) {
 469                         EXIT;
 470                         return err;
 471                 }
 472
 473                 conn.oc_id = rw_s->conn_id;
 474
 475                 if ( !OBT(obd) || !OBP(obd, read) ) {
 476                         err = -EOPNOTSUPP;
 477                         EXIT;
 478                         return err;
 479                 }
 480
 481
 482                 err = OBP(obd, read)(&conn, &rw_s->obdo, rw_s->buf,
 483                                         &rw_s->count, rw_s->offset);
 484
 485                 ODEBUG(&rw_s->obdo);
 486                 CDEBUG(D_INFO, "READ: conn %d, count %Ld, offset %Ld, '%s'\n",
 487                        rw_s->conn_id, rw_s->count, rw_s->offset, rw_s->buf);
 488                 if ( err ) {
 489                         EXIT;
 490                         return err;
 491                 }
 492
 493                 err = copy_to_user((int*)arg, &rw_s->count, sizeof(rw_s->count));
 494                 EXIT;
 495                 return err;
 496         }
 497
 498         case OBD_IOC_WRITE: {
 499                 struct oic_rw_s *rw_s = tmp_buf;  /* read, write ioctl str */
 500
 501                 err = copy_from_user(rw_s, (int *)arg, sizeof(*rw_s));
 502                 if ( err ) {
 503                         EXIT;
 504                         return err;
 505                 }
 506
 507                 conn.oc_id = rw_s->conn_id;
 508
 509                 if ( !OBT(obd) || !OBP(obd, write) ) {
 510                         err = -EOPNOTSUPP;
 511                         return err;
 512                 }
 513
 514                 CDEBUG(D_INFO, "WRITE: conn %d, count %Ld, offset %Ld, '%s'\n",
 515                        rw_s->conn_id, rw_s->count, rw_s->offset, rw_s->buf);
 516
 517                 err = OBP(obd, write)(&conn, &rw_s->obdo, rw_s->buf,
 518                                          &rw_s->count, rw_s->offset);
 519                 ODEBUG(&rw_s->obdo);
 520                 if ( err ) {
 521                         EXIT;
 522                         return err;
 523                 }
 524
 525                 err = copy_to_user((int *)arg, &rw_s->count,
 526                                    sizeof(rw_s->count));
 527                 EXIT;
 528                 return err;
 529         }
 530         case OBD_IOC_PREALLOCATE: {
 531                 struct oic_prealloc_s *prealloc = tmp_buf;
 532
 533                 /* has this minor been registered? */
 534                 if (!obd->obd_type)
 535                         return -ENODEV;
 536
 537                 err = copy_from_user(prealloc, (int *)arg, sizeof(*prealloc));
 538                 if (err)
 539                         return -EFAULT;
 540
 541                 if ( !(obd->obd_flags & OBD_ATTACHED) ||
 542                      !(obd->obd_flags & OBD_SET_UP)) {
 543                         CDEBUG(D_IOCTL, "Device not attached or set up\n");
 544                         return -ENODEV;
 545                 }
 546
 547                 if ( !OBT(obd) || !OBP(obd, preallocate) )
 548                         return -EOPNOTSUPP;
 549
 550                 conn.oc_id = prealloc->conn_id;
 551                 err = OBP(obd, preallocate)(&conn, &prealloc->alloc,
 552                                                prealloc->ids);
 553                 if ( err ) {
 554                         EXIT;
 555                         return err;
 556                 }
 557
 558                 err =copy_to_user((int *)arg, prealloc, sizeof(*prealloc));
 559                 EXIT;
 560                 return err;
 561         }
 562         case OBD_IOC_STATFS: {
 563                 struct statfs *tmp;
 564                 unsigned int conn_id;
 565                 struct statfs buf;
 566
 567                 /* has this minor been registered? */
 568                 if (!obd->obd_type)
 569                         return -ENODEV;
 570
 571                 tmp = (void *)arg + sizeof(unsigned int);
 572                 get_user(conn_id, (int *) arg);
 573
 574                 if ( !OBT(obd) || !OBP(obd, statfs) )
 575                         return -EOPNOTSUPP;
 576
 577                 conn.oc_id = conn_id;
 578                 err = OBP(obd, statfs)(&conn, &buf);
 579                 if ( err ) {
 580                         EXIT;
 581                         return err;
 582                 }
 583                 err = copy_to_user(tmp, &buf, sizeof(buf));
 584                 EXIT;
 585                 return err;
 586
 587         }
 588         case OBD_IOC_COPY: {
 589                 struct ioc_mv_s *mvdata = tmp_buf;
 590
 591                 if ( (!(obd->obd_flags & OBD_SET_UP)) ||
 592                      (!(obd->obd_flags & OBD_ATTACHED))) {
 593                         CDEBUG(D_IOCTL, "Device not attached or set up\n");
 594                         return -ENODEV;
 595                 }
 596
 597                 /* get main structure */
 598                 err = copy_from_user(mvdata, (void *) arg, sizeof(*mvdata));
 599                 if (err) {
 600                         EXIT;
 601                         return err;
 602                 }
 603
 604                 if ( !OBT(obd) || !OBP(obd, copy) )
 605                         return -EOPNOTSUPP;
 606
 607                 /* do the partition */
 608                 CDEBUG(D_INFO, "Copy %d, type %s dst %Ld src %Ld\n", dev,
 609                        obd->obd_type->typ_name, mvdata->dst.o_id,
 610                        mvdata->src.o_id);
 611
 612                 conn.oc_id = mvdata->src_conn_id;
 613
 614                 err = OBP(obd, copy)(&conn, &mvdata->dst,
 615                                         &conn, &mvdata->src,
 616                                         mvdata->src.o_size, 0);
 617                 return err;
 618         }
 619
 620         case OBD_IOC_MIGR: {
 621                 struct ioc_mv_s *mvdata = tmp_buf;
 622
 623                 if ( (!(obd->obd_flags & OBD_SET_UP)) ||
 624                      (!(obd->obd_flags & OBD_ATTACHED))) {
 625                         CDEBUG(D_IOCTL, "Device not attached or set up\n");
 626                         return -ENODEV;
 627                 }
 628
 629                 err = copy_from_user(mvdata, (void *) arg, sizeof(*mvdata));
 630                 if (err) {
 631                         EXIT;
 632                         return err;
 633                 }
 634
 635                 CDEBUG(D_INFO, "Migrate copying %d bytes\n", sizeof(*mvdata));
 636
 637                 if ( !OBT(obd) || !OBP(obd, migrate) )
 638                         return -EOPNOTSUPP;
 639
 640                 /* do the partition */
 641                 CDEBUG(D_INFO, "Migrate %d, type %s conn %d src %Ld dst %Ld\n",
 642                        dev, obd->obd_type->typ_name, mvdata->src_conn_id,
 643                        mvdata->src.o_id, mvdata->dst.o_id);
 644
 645                 conn.oc_id = mvdata->src_conn_id;
 646                 err = OBP(obd, migrate)(&conn, &mvdata->dst, &mvdata->src,
 647                                            mvdata->src.o_size, 0);
 648
 649                 return err;
 650         }
 651         case OBD_IOC_PUNCH: {
 652                 struct oic_rw_s *rw_s = tmp_buf;  /* read, write ioctl str */
 653
 654                 err = copy_from_user(rw_s, (int *)arg, sizeof(*rw_s));
 655                 if ( err ) {
 656                         EXIT;
 657                         return err;
 658                 }
 659
 660                 conn.oc_id = rw_s->conn_id;
 661
 662                 if ( !OBT(obd) || !OBP(obd, punch) ) {
 663                         err = -EOPNOTSUPP;
 664                         return err;
 665                 }
 666
 667                 CDEBUG(D_INFO, "PUNCH: conn %d, count %Ld, offset %Ld\n",
 668                        rw_s->conn_id, rw_s->count, rw_s->offset);
 669                 err = OBP(obd, punch)(&conn, &rw_s->obdo, rw_s->count,
 670                                          rw_s->offset);
 671                 ODEBUG(&rw_s->obdo);
 672                 if ( err ) {
 673                         EXIT;
 674                         return err;
 675                 }
 676                 EXIT;
 677                 return err;
 678         }
 679
 680         default: {
 681                 struct obd_type *type;
 682                 struct oic_generic input;
 683                 char *nm;
 684                 void *karg;
 685
 686                 /* get data structures */
 687                 err = copy_from_user(&input, (void *)arg, sizeof(input));
 688                 if ( err ) {
 689                         EXIT;
 690                         return err;
 691                 }
 692
 693                 err = getdata(input.att_typelen + 1, &input.att_type);
 694                 if ( err ) {
 695                         EXIT;
 696                         return err;
 697                 }
 698
 699                 /* find the type */
 700                 nm = input.att_type;
 701                 type = obd_nm_to_type(nm);
 702 #ifdef CONFIG_KMOD
 703                 if ( !type ) {
 704                         if ( !request_module(nm) ) {
 705                                 CDEBUG(D_PSDEV, "Loaded module '%s'\n", nm);
 706                                 type = obd_nm_to_type(nm);
 707                         } else {
 708                                 CDEBUG(D_PSDEV, "Can't load module '%s'\n", nm);
 709                         }
 710                 }
 711 #endif
 712                 OBD_FREE(input.att_type, input.att_typelen + 1);
 713                 if ( !type ) {
 714                         printk(__FUNCTION__ ": unknown obd type dev %d\n", dev);
 715                         EXIT;
 716                         return -EINVAL;
 717                 }
 718
 719                 if ( !type->typ_ops || !type->typ_ops->o_iocontrol ) {
 720                         EXIT;
 721                         return -EOPNOTSUPP;
 722                 }
 723                 conn.oc_id = input.att_connid;
 724
 725                 CDEBUG(D_INFO, "Calling ioctl %x for type %s, len %d\n",
 726                        cmd, type->typ_name, input.att_datalen);
 727
 728                 /* get the generic data */
 729                 karg = input.att_data;
 730                 err = getdata(input.att_datalen, &karg);
 731                 if ( err ) {
 732                         EXIT;
 733                         return err;
 734                 }
 735
 736                 err = type->typ_ops->o_iocontrol(cmd, &conn, input.att_datalen,
 737                                                  karg, input.att_data);
 738                 OBD_FREE(karg, input.att_datalen);
 739
 740                 EXIT;
 741                 return err;
 742         }
 743 #endif
 744         default:
 745                 return -EINVAL;
 746
 747         }
 748 } /* obd_class_ioctl */
 749
 750 /* Driver interface done, utility functions follow */
 751
 752 int obd_register_type(struct obd_ops *ops, char *nm)
 753 {
 754         struct obd_type *type;
 755
 756
 757         if (obd_init_magic != 0x11223344) {
 758                 printk(__FUNCTION__ ": bad magic for type\n");
 759                 EXIT;
 760                 return -EINVAL;
 761         }
 762
 763         if  ( obd_nm_to_type(nm) ) {
 764                 CDEBUG(D_IOCTL, "Type %s already registered\n", nm);
 765                 EXIT;
 766                 return -EEXIST;
 767         }
 768
 769         OBD_ALLOC(type, struct obd_type * , sizeof(*type));
 770         if ( !type ) {
 771                 EXIT;
 772                 return -ENOMEM;
 773         }
 774         memset(type, 0, sizeof(*type));
 775         INIT_LIST_HEAD(&type->typ_chain);
 776         MOD_INC_USE_COUNT;
 777         list_add(&type->typ_chain, obd_types.next);
 778         type->typ_ops = ops;
 779         type->typ_name = nm;
 780         EXIT;
 781         return 0;
 782 }
 783
 784 int obd_unregister_type(char *nm)
 785 {
 786         struct obd_type *type = obd_nm_to_type(nm);
 787
 788         if ( !type ) {
 789                 MOD_DEC_USE_COUNT;
 790                 printk(KERN_INFO __FUNCTION__ ": unknown obd type\n");
 791                 EXIT;
 792                 return -EINVAL;
 793         }
 794
 795         if ( type->typ_refcnt ) {
 796                 MOD_DEC_USE_COUNT;
 797                 printk(KERN_ALERT __FUNCTION__ ":type %s has refcount "
 798                        "(%d)\n", nm, type->typ_refcnt);
 799                 EXIT;
 800                 return -EBUSY;
 801         }
 802
 803         list_del(&type->typ_chain);
 804         OBD_FREE(type, sizeof(*type));
 805         MOD_DEC_USE_COUNT;
 806         return 0;
 807 } /* obd_unregister_type */
 808
 809 /* declare character device */
 810 static struct file_operations obd_psdev_fops = {
 811         ioctl: obd_class_ioctl,       /* ioctl */
 812         open: obd_class_open,        /* open */
 813         release: obd_class_release,     /* release */
 814 };
 815
 816
 817 /* modules setup */
 818 #define OBD_MINOR 241
 819 static struct miscdevice obd_psdev = {
 820         OBD_MINOR,
 821         "obd_psdev",
 822         &obd_psdev_fops
 823 };
 824
 825 int init_obd(void)
 826 {
 827         int err;
 828         int i;
 829
 830         printk(KERN_INFO "OBD class driver  v0.01, braam@stelias.com\n");
 831
 832         INIT_LIST_HEAD(&obd_types);
 833
 834         if ( (err = misc_register(&obd_psdev)) ) {
 835                 printk(KERN_ERR __FUNCTION__ ": cannot register %d err %d\n",
 836                        OBD_MINOR, err);
 837                 return -EIO;
 838         }
 839
 840         for (i = 0; i < MAX_OBD_DEVICES; i++) {
 841                 memset(&(obd_dev[i]), 0, sizeof(obd_dev[i]));
 842                 obd_dev[i].obd_minor = i;
 843                 INIT_LIST_HEAD(&obd_dev[i].obd_gen_clients);
 844         }
 845
 846         err = obd_init_obdo_cache();
 847         if (err)
 848                 return err;
 849         obd_sysctl_init();
 850         obd_init_magic = 0x11223344;
 851         return 0;
 852 }
 853
 854 EXPORT_SYMBOL(obd_register_type);
 855 EXPORT_SYMBOL(obd_unregister_type);
 856
 857 EXPORT_SYMBOL(obd_print_entry);
 858 EXPORT_SYMBOL(obd_debug_level);
 859 EXPORT_SYMBOL(obd_dev);
 860
 861 EXPORT_SYMBOL(gen_connect);
 862 EXPORT_SYMBOL(gen_client);
 863 EXPORT_SYMBOL(gen_cleanup);
 864 EXPORT_SYMBOL(gen_disconnect);
 865 EXPORT_SYMBOL(gen_copy_data);
 866 EXPORT_SYMBOL(obdo_cachep);
 867
 868 /* EXPORT_SYMBOL(gen_multi_attach); */
 869 EXPORT_SYMBOL(gen_multi_setup);
 870 EXPORT_SYMBOL(gen_multi_cleanup);
 871
 872
 873 #ifdef MODULE
 874 int init_module(void)
 875 {
 876         return init_obd();
 877 }
 878
 879 void cleanup_module(void)
 880 {
 881         int i;
 882         ENTRY;
 883
 884         misc_deregister(&obd_psdev);
 885         for (i = 0; i < MAX_OBD_DEVICES; i++) {
 886                 struct obd_device *obd = &obd_dev[i];
 887                 if ( obd->obd_type &&
 888                      (obd->obd_flags & OBD_SET_UP) &&
 889                      OBT(obd) && OBP(obd, detach) ) {
 890                         /* XXX should this call generic detach otherwise? */
 891                         OBP(obd, detach)(obd);
 892                 }
 893         }
 894
 895         obd_cleanup_obdo_cache();
 896         obd_sysctl_clean();
 897         CDEBUG(D_MALLOC, "CLASS mem used %ld\n", obd_memory);
 898         obd_init_magic = 0;
 899         EXIT;
 900 }
 901 #endif