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