sys/dev/raid/vinum/vinum.c

   1 /*-
   2  * Copyright (c) 1997, 1998
   3  *      Nan Yang Computer Services Limited.  All rights reserved.
   4  *
   5  *  Written by Greg Lehey
   6  *
   7  *  This software is distributed under the so-called ``Berkeley
   8  *  License'':
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by Nan Yang Computer
  21  *      Services Limited.
  22  * 4. Neither the name of the Company nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * This software is provided ``as is'', and any express or implied
  27  * warranties, including, but not limited to, the implied warranties of
  28  * merchantability and fitness for a particular purpose are disclaimed.
  29  * In no event shall the company or contributors be liable for any
  30  * direct, indirect, incidental, special, exemplary, or consequential
  31  * damages (including, but not limited to, procurement of substitute
  32  * goods or services; loss of use, data, or profits; or business
  33  * interruption) however caused and on any theory of liability, whether
  34  * in contract, strict liability, or tort (including negligence or
  35  * otherwise) arising in any way out of the use of this software, even if
  36  * advised of the possibility of such damage.
  37  *
  38  * $Id: vinum.c,v 1.33 2001/01/09 06:19:15 grog Exp grog $
  39  * $FreeBSD: src/sys/dev/vinum/vinum.c,v 1.38.2.3 2003/01/07 12:14:16 joerg Exp $
  40  * $DragonFly: src/sys/dev/raid/vinum/vinum.c,v 1.20 2007/05/15 22:44:12 dillon Exp $
  41  */
  42
  43 #define STATIC static                                       /* nothing while we're testing XXX */
  44
  45 #include "vinumhdr.h"
  46 #include <sys/sysproto.h>                                   /* for sync(2) */
  47 #include <sys/devicestat.h>
  48 #include <sys/poll.h>                                       /* XXX: poll ops used in kq filters */
  49 #include <sys/event.h>
  50 #include <sys/udev.h>
  51 #ifdef VINUMDEBUG
  52 #include <sys/reboot.h>
  53 int debug = 0;
  54 extern int total_malloced;
  55 extern int malloccount;
  56 extern struct mc malloced[];
  57 #endif
  58 #include "request.h"
  59
  60 struct dev_ops vinum_ops =
  61 {
  62         { "vinum", VINUM_CDEV_MAJOR, D_DISK | D_KQFILTER },
  63         .d_open =       vinumopen,
  64         .d_close =      vinumclose,
  65         .d_read =       physread,
  66         .d_write =      physwrite,
  67         .d_ioctl =      vinumioctl,
  68         .d_kqfilter =   vinumkqfilter,
  69         .d_strategy =   vinumstrategy,
  70         .d_dump =       vinumdump,
  71         .d_psize =      vinumsize,
  72 };
  73
  74 /* Called by main() during pseudo-device attachment. */
  75 STATIC void vinumattach(void *);
  76
  77 STATIC int vinum_modevent(module_t mod, modeventtype_t type, void *unused);
  78 STATIC void vinum_initconf(void);
  79
  80 struct _vinum_conf vinum_conf;                              /* configuration information */
  81 cdev_t  vinum_super_dev;
  82 cdev_t  vinum_wsuper_dev;
  83 cdev_t  vinum_daemon_dev;
  84
  85 /*
  86  * Called by main() during pseudo-device attachment.  All we need
  87  * to do is allocate enough space for devices to be configured later, and
  88  * add devsw entries.
  89  */
  90 void
  91 vinumattach(void *dummy)
  92 {
  93     char *cp, *cp1, *cp2, **drives;
  94     int i, rv;
  95     struct volume *vol;
  96
  97     /* modload should prevent multiple loads, so this is worth a panic */
  98     if ((vinum_conf.flags & VF_LOADED) != 0)
  99         panic("vinum: already loaded");
 100
 101     log(LOG_INFO, "vinum: loaded\n");
 102     vinum_conf.flags |= VF_LOADED;                          /* we're loaded now */
 103
 104     daemonq = NULL;                                         /* initialize daemon's work queue */
 105     dqend = NULL;
 106
 107 #if 0
 108     dev_ops_add(&vinum_ops, 0, 0);
 109 #endif
 110
 111     vinum_initconf();
 112
 113     /*
 114      * Create superdev, wrongsuperdev, and controld devices.
 115      */
 116     vinum_super_dev =   make_dev(&vinum_ops, VINUM_SUPERDEV,
 117                                  UID_ROOT, GID_WHEEL, 0600,
 118                                  VINUM_SUPERDEV_BASE);
 119     vinum_wsuper_dev =  make_dev(&vinum_ops, VINUM_WRONGSUPERDEV,
 120                                  UID_ROOT, GID_WHEEL, 0600,
 121                                  VINUM_WRONGSUPERDEV_BASE);
 122     vinum_daemon_dev =  make_dev(&vinum_ops, VINUM_DAEMON_DEV,
 123                                  UID_ROOT, GID_WHEEL, 0600,
 124                                  VINUM_DAEMON_DEV_BASE);
 125
 126     /*
 127      * See if the loader has passed us a disk to
 128      * read the initial configuration from.
 129      */
 130     if ((cp = kgetenv("vinum.drives")) != NULL) {
 131         for (cp1 = cp, i = 0, drives = 0; *cp1 != '\0'; i++) {
 132             cp2 = cp1;
 133             while (*cp1 != '\0' && *cp1 != ',' && *cp1 != ' ')
 134                 cp1++;
 135             if (*cp1 != '\0')
 136                 *cp1++ = '\0';
 137             drives = krealloc(drives, (unsigned long)((i + 1) * sizeof(char *)),
 138                              M_TEMP, M_WAITOK);
 139             drives[i] = cp2;
 140         }
 141         if (i == 0)
 142             goto bailout;
 143         rv = vinum_scandisk(drives, i);
 144         if (rv)
 145             log(LOG_NOTICE, "vinum_scandisk() returned %d", rv);
 146     bailout:
 147         kfree(drives, M_TEMP);
 148     }
 149     if ((cp = kgetenv("vinum.root")) != NULL) {
 150         for (i = 0; i < vinum_conf.volumes_used; i++) {
 151             vol = &vinum_conf.volume[i];
 152             if ((vol->state == volume_up)
 153                 && (strcmp (vol->name, cp) == 0)
 154             ) {
 155                 rootdev = make_dev(&vinum_ops, i, UID_ROOT, GID_OPERATOR,
 156                                 0640, VINUM_BASE "vinumroot");
 157                 udev_dict_set_cstr(rootdev, "subsystem", "raid");
 158                 udev_dict_set_cstr(rootdev, "disk-type", "raid");
 159                 log(LOG_INFO, "vinum: using volume %s for root device\n", cp);
 160                 break;
 161             }
 162         }
 163     }
 164 }
 165
 166 /*
 167  * Check if we have anything open.  If confopen is != 0,
 168  * that goes for the super device as well, otherwise
 169  * only for volumes.
 170  *
 171  * Return 0 if not inactive, 1 if inactive.
 172  */
 173 int
 174 vinum_inactive(int confopen)
 175 {
 176     int i;
 177     int can_do = 1;                                         /* assume we can do it */
 178
 179     if (confopen && (vinum_conf.flags & VF_OPEN))           /* open by vinum(8)? */
 180         return 0;                                           /* can't do it while we're open */
 181     lock_config();
 182     for (i = 0; i < vinum_conf.volumes_allocated; i++) {
 183         if ((VOL[i].state > volume_down)
 184             && (VOL[i].flags & VF_OPEN)) {                  /* volume is open */
 185             can_do = 0;
 186             break;
 187         }
 188     }
 189     unlock_config();
 190     return can_do;
 191 }
 192
 193 /*
 194  * Free all structures.
 195  * If cleardrive is 0, save the configuration; otherwise
 196  * remove the configuration from the drive.
 197  *
 198  * Before coming here, ensure that no volumes are open.
 199  */
 200 void
 201 free_vinum(int cleardrive)
 202 {
 203     int i;
 204     int drives_allocated = vinum_conf.drives_allocated;
 205
 206     if (DRIVE != NULL) {
 207         if (cleardrive) {                                   /* remove the vinum config */
 208             for (i = 0; i < drives_allocated; i++)
 209                 remove_drive(i);                            /* remove the drive */
 210         } else {                                            /* keep the config */
 211             for (i = 0; i < drives_allocated; i++)
 212                 free_drive(&DRIVE[i]);                      /* close files and things */
 213         }
 214         Free(DRIVE);
 215     }
 216     while ((vinum_conf.flags & (VF_STOPPING | VF_DAEMONOPEN))
 217         == (VF_STOPPING | VF_DAEMONOPEN)) {                 /* at least one daemon open, we're stopping */
 218         queue_daemon_request(daemonrq_return, (union daemoninfo) 0); /* stop the daemon */
 219         tsleep(&vinumclose, 0, "vstop", 1);                 /* and wait for it */
 220     }
 221     if (SD != NULL) {
 222         for (i = 0; i < vinum_conf.subdisks_allocated; i++) {
 223             struct sd *sd = &vinum_conf.sd[i];
 224             if (sd->sd_dev) {
 225                 destroy_dev(sd->sd_dev);
 226                 sd->sd_dev = NULL;
 227             }
 228         }
 229         Free(SD);
 230     }
 231     if (PLEX != NULL) {
 232         for (i = 0; i < vinum_conf.plexes_allocated; i++) {
 233             struct plex *plex = &vinum_conf.plex[i];
 234
 235             if (plex->plex_dev) {
 236                 destroy_dev(plex->plex_dev);
 237                 plex->plex_dev = NULL;
 238             }
 239
 240             if (plex->state != plex_unallocated) {          /* we have real data there */
 241                 if (plex->sdnos)
 242                     Free(plex->sdnos);
 243             }
 244         }
 245         Free(PLEX);
 246     }
 247     if (VOL != NULL) {
 248         for (i = 0; i < vinum_conf.volumes_allocated; i++) {
 249             struct volume *vol = &vinum_conf.volume[i];
 250
 251             if (vol->vol_dev) {
 252                 destroy_dev(vol->vol_dev);
 253                 vol->vol_dev = NULL;
 254             }
 255         }
 256         Free(VOL);
 257     }
 258     bzero(&vinum_conf, sizeof(vinum_conf));
 259     vinum_initconf();
 260 }
 261
 262 STATIC void
 263 vinum_initconf(void)
 264 {
 265     vinum_conf.physbufs = nswbuf / 2 + 1;
 266
 267     /* allocate space: drives... */
 268     DRIVE = (struct drive *) Malloc(sizeof(struct drive) * INITIAL_DRIVES);
 269     CHECKALLOC(DRIVE, "vinum: no memory\n");
 270     bzero(DRIVE, sizeof(struct drive) * INITIAL_DRIVES);
 271     vinum_conf.drives_allocated = INITIAL_DRIVES;
 272     vinum_conf.drives_used = 0;
 273
 274     /* volumes, ... */
 275     VOL = (struct volume *) Malloc(sizeof(struct volume) * INITIAL_VOLUMES);
 276     CHECKALLOC(VOL, "vinum: no memory\n");
 277     bzero(VOL, sizeof(struct volume) * INITIAL_VOLUMES);
 278     vinum_conf.volumes_allocated = INITIAL_VOLUMES;
 279     vinum_conf.volumes_used = 0;
 280
 281     /* plexes, ... */
 282     PLEX = (struct plex *) Malloc(sizeof(struct plex) * INITIAL_PLEXES);
 283     CHECKALLOC(PLEX, "vinum: no memory\n");
 284     bzero(PLEX, sizeof(struct plex) * INITIAL_PLEXES);
 285     vinum_conf.plexes_allocated = INITIAL_PLEXES;
 286     vinum_conf.plexes_used = 0;
 287
 288     /* and subdisks */
 289     SD = (struct sd *) Malloc(sizeof(struct sd) * INITIAL_SUBDISKS);
 290     CHECKALLOC(SD, "vinum: no memory\n");
 291     bzero(SD, sizeof(struct sd) * INITIAL_SUBDISKS);
 292     vinum_conf.subdisks_allocated = INITIAL_SUBDISKS;
 293     vinum_conf.subdisks_used = 0;
 294 }
 295
 296 STATIC int
 297 vinum_modevent(module_t mod, modeventtype_t type, void *unused)
 298 {
 299     switch (type) {
 300     case MOD_LOAD:
 301         vinumattach(NULL);
 302         return 0;                                           /* OK */
 303     case MOD_UNLOAD:
 304         if (!vinum_inactive(1))                             /* is anything open? */
 305             return EBUSY;                                   /* yes, we can't do it */
 306         vinum_conf.flags |= VF_STOPPING;                    /* note that we want to stop */
 307         sys_sync(NULL);                     /* write out buffers */
 308         free_vinum(0);                                      /* clean up */
 309
 310         if (vinum_super_dev) {
 311             destroy_dev(vinum_super_dev);
 312             vinum_super_dev = NULL;
 313         }
 314         if (vinum_wsuper_dev) {
 315             destroy_dev(vinum_wsuper_dev);
 316             vinum_wsuper_dev = NULL;
 317         }
 318         if (vinum_daemon_dev) {
 319             destroy_dev(vinum_daemon_dev);
 320             vinum_daemon_dev = NULL;
 321         }
 322
 323         sync_devs();
 324 #ifdef VINUMDEBUG
 325         if (total_malloced) {
 326             int i;
 327 #ifdef INVARIANTS
 328             int *poke;
 329 #endif
 330
 331             for (i = 0; i < malloccount; i++) {
 332                 if (debug & DEBUG_WARNINGS)                 /* want to hear about them */
 333                     log(LOG_WARNING,
 334                         "vinum: exiting with %d bytes malloced from %s:%d\n",
 335                         malloced[i].size,
 336                         malloced[i].file,
 337                         malloced[i].line);
 338 #ifdef INVARIANTS
 339                 poke = &((int *) malloced[i].address)
 340                     [malloced[i].size / (2 * sizeof(int))]; /* middle of the area */
 341                 if (*poke == 0xdeadc0de)                    /* already freed */
 342                     log(LOG_ERR,
 343                         "vinum: exiting with malloc table inconsistency at %p from %s:%d\n",
 344                         malloced[i].address,
 345                         malloced[i].file,
 346                         malloced[i].line);
 347 #endif
 348                 Free(malloced[i].address);
 349             }
 350         }
 351 #endif
 352         dev_ops_remove_all(&vinum_ops);
 353         log(LOG_INFO, "vinum: unloaded\n");                 /* tell the world */
 354         return 0;
 355     default:
 356         break;
 357     }
 358     return 0;
 359 }
 360
 361 moduledata_t vinum_mod =
 362 {
 363     "vinum",
 364     (modeventhand_t) vinum_modevent,
 365     0
 366 };
 367 DECLARE_MODULE(vinum, vinum_mod, SI_SUB_RAID, SI_ORDER_MIDDLE);
 368
 369 /* ARGSUSED */
 370 /* Open a vinum object */
 371 int
 372 vinumopen(struct dev_open_args *ap)
 373 {
 374     cdev_t dev = ap->a_head.a_dev;
 375     int error;
 376     unsigned int index;
 377     struct volume *vol;
 378     struct plex *plex;
 379     struct sd *sd;
 380     int devminor;                                           /* minor number */
 381
 382     devminor = minor(dev);
 383     error = 0;
 384     /* First, decide what we're looking at */
 385     switch (DEVTYPE(dev)) {
 386     case VINUM_VOLUME_TYPE:
 387         index = Volno(dev);
 388         if (index >= vinum_conf.volumes_allocated)
 389             return ENXIO;                                   /* no such device */
 390         vol = &VOL[index];
 391
 392         switch (vol->state) {
 393         case volume_unallocated:
 394         case volume_uninit:
 395             return ENXIO;
 396
 397         case volume_up:
 398             vol->flags |= VF_OPEN;                          /* note we're open */
 399             return 0;
 400
 401         case volume_down:
 402             return EIO;
 403
 404         default:
 405             return EINVAL;
 406         }
 407
 408     case VINUM_PLEX_TYPE:
 409         if (Volno(dev) >= vinum_conf.volumes_allocated)
 410             return ENXIO;
 411         /* FALLTHROUGH */
 412
 413     case VINUM_RAWPLEX_TYPE:
 414         index = Plexno(dev);                                /* get plex index in vinum_conf */
 415         if (index >= vinum_conf.plexes_allocated)
 416             return ENXIO;                                   /* no such device */
 417         plex = &PLEX[index];
 418
 419         switch (plex->state) {
 420         case plex_referenced:
 421         case plex_unallocated:
 422             return EINVAL;
 423
 424         default:
 425             plex->flags |= VF_OPEN;                         /* note we're open */
 426             return 0;
 427         }
 428
 429     case VINUM_SD_TYPE:
 430         if ((Volno(dev) >= vinum_conf.volumes_allocated)    /* no such volume */
 431         ||(Plexno(dev) >= vinum_conf.plexes_allocated))     /* or no such plex */
 432             return ENXIO;                                   /* no such device */
 433
 434         /* FALLTHROUGH */
 435
 436     case VINUM_RAWSD_TYPE:
 437         index = Sdno(dev);                                  /* get the subdisk number */
 438         if ((index >= vinum_conf.subdisks_allocated)        /* not a valid SD entry */
 439         ||(SD[index].state < sd_init))                      /* or SD is not real */
 440             return ENXIO;                                   /* no such device */
 441         sd = &SD[index];
 442
 443         /*
 444          * Opening a subdisk is always a special operation, so we
 445          * ignore the state as long as it represents a real subdisk
 446          */
 447         switch (sd->state) {
 448         case sd_unallocated:
 449         case sd_uninit:
 450             return EINVAL;
 451
 452         default:
 453             sd->flags |= VF_OPEN;                           /* note we're open */
 454             return 0;
 455         }
 456
 457     case VINUM_SUPERDEV_TYPE:
 458         error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);  /* are we root? */
 459         if (error == 0) {                                   /* yes, can do */
 460             if (devminor == VINUM_DAEMON_DEV)               /* daemon device */
 461                 vinum_conf.flags |= VF_DAEMONOPEN;          /* we're open */
 462             else if (devminor == VINUM_SUPERDEV)
 463                 vinum_conf.flags |= VF_OPEN;                /* we're open */
 464             else
 465                 error = ENODEV;                             /* nothing, maybe a debug mismatch */
 466         }
 467         return error;
 468
 469         /* Vinum drives are disks.  We already have a disk
 470          * driver, so don't handle them here */
 471     case VINUM_DRIVE_TYPE:
 472     default:
 473         return ENODEV;                                      /* don't know what to do with these */
 474     }
 475 }
 476
 477 /* ARGSUSED */
 478 int
 479 vinumclose(struct dev_close_args *ap)
 480 {
 481     cdev_t dev = ap->a_head.a_dev;
 482     unsigned int index;
 483     struct volume *vol;
 484     int devminor;
 485
 486     devminor = minor(dev);
 487     index = Volno(dev);
 488     /* First, decide what we're looking at */
 489     switch (DEVTYPE(dev)) {
 490     case VINUM_VOLUME_TYPE:
 491         if (index >= vinum_conf.volumes_allocated)
 492             return ENXIO;                                   /* no such device */
 493         vol = &VOL[index];
 494
 495         switch (vol->state) {
 496         case volume_unallocated:
 497         case volume_uninit:
 498             return ENXIO;
 499
 500         case volume_up:
 501             vol->flags &= ~VF_OPEN;                         /* reset our flags */
 502             return 0;
 503
 504         case volume_down:
 505             return EIO;
 506
 507         default:
 508             return EINVAL;
 509         }
 510
 511     case VINUM_PLEX_TYPE:
 512         if (Volno(dev) >= vinum_conf.volumes_allocated)
 513             return ENXIO;
 514         /* FALLTHROUGH */
 515
 516     case VINUM_RAWPLEX_TYPE:
 517         index = Plexno(dev);                                /* get plex index in vinum_conf */
 518         if (index >= vinum_conf.plexes_allocated)
 519             return ENXIO;                                   /* no such device */
 520         PLEX[index].flags &= ~VF_OPEN;                      /* reset our flags */
 521         return 0;
 522
 523     case VINUM_SD_TYPE:
 524         if ((Volno(dev) >= vinum_conf.volumes_allocated) || /* no such volume */
 525             (Plexno(dev) >= vinum_conf.plexes_allocated))   /* or no such plex */
 526             return ENXIO;                                   /* no such device */
 527         /* FALLTHROUGH */
 528
 529     case VINUM_RAWSD_TYPE:
 530         index = Sdno(dev);                                  /* get the subdisk number */
 531         if (index >= vinum_conf.subdisks_allocated)
 532             return ENXIO;                                   /* no such device */
 533         SD[index].flags &= ~VF_OPEN;                        /* reset our flags */
 534         return 0;
 535
 536     case VINUM_SUPERDEV_TYPE:
 537         /*
 538          * don't worry about whether we're root:
 539          * nobody else would get this far.
 540          */
 541         if (devminor == VINUM_SUPERDEV)                     /* normal superdev */
 542             vinum_conf.flags &= ~VF_OPEN;                   /* no longer open */
 543         else if (devminor == VINUM_DAEMON_DEV) {            /* the daemon device */
 544             vinum_conf.flags &= ~VF_DAEMONOPEN;             /* no longer open */
 545             if (vinum_conf.flags & VF_STOPPING)             /* we're stopping, */
 546                 wakeup(&vinumclose);                        /* we can continue stopping now */
 547         }
 548         return 0;
 549
 550     case VINUM_DRIVE_TYPE:
 551     default:
 552         return ENODEV;                                      /* don't know what to do with these */
 553     }
 554 }
 555
 556 /* size routine */
 557 int
 558 vinumsize(struct dev_psize_args *ap)
 559 {
 560     cdev_t dev = ap->a_head.a_dev;
 561     struct volume *vol;
 562
 563     vol = &VOL[Volno(dev)];
 564
 565     if (vol->state == volume_up) {
 566         ap->a_result = (int64_t)vol->size;
 567         return(0);
 568     } else {
 569         return(ENXIO);
 570     }
 571 }
 572
 573 int
 574 vinumdump(struct dev_dump_args *ap)
 575 {
 576     /* Not implemented. */
 577     return ENXIO;
 578 }
 579
 580 void
 581 vinumfilt_detach(struct knote *kn) {}
 582
 583 int
 584 vinumfilt_rd(struct knote *kn, long hint)
 585 {
 586     cdev_t dev = (cdev_t)kn->kn_hook;
 587
 588     if (seltrue(dev, POLLIN | POLLRDNORM))
 589         return (1);
 590
 591     return (0);
 592 }
 593
 594 int
 595 vinumfilt_wr(struct knote *kn, long hint)
 596 {
 597     /* Writing is always OK */
 598     return (1);
 599 }
 600
 601 struct filterops vinumfiltops_rd =
 602     { FILTEROP_ISFD, NULL, vinumfilt_detach, vinumfilt_rd };
 603 struct filterops vinumfiltops_wr =
 604     { FILTEROP_ISFD, NULL, vinumfilt_detach, vinumfilt_wr };
 605
 606 int
 607 vinumkqfilter(struct dev_kqfilter_args *ap)
 608 {
 609     if (ap->a_kn->kn_filter == EVFILT_READ) {
 610         ap->a_kn->kn_fop = &vinumfiltops_rd;
 611         ap->a_kn->kn_hook = (caddr_t)ap->a_head.a_dev;
 612         ap->a_result = 0;
 613     } else if (ap->a_kn->kn_filter == EVFILT_WRITE) {
 614         ap->a_kn->kn_fop = &vinumfiltops_wr;
 615         ap->a_result = 0;
 616     } else {
 617         ap->a_result = EOPNOTSUPP;
 618     }
 619
 620     return (0);
 621 }
 622
 623 /* Local Variables: */
 624 /* fill-column: 50 */
 625 /* End: */