sys/geom/geom_dev.c

   1 /*-
   2  * Copyright (c) 2002 Poul-Henning Kamp
   3  * Copyright (c) 2002 Networks Associates Technology, Inc.
   4  * All rights reserved.
   5  *
   6  * This software was developed for the FreeBSD Project by Poul-Henning Kamp
   7  * and NAI Labs, the Security Research Division of Network Associates, Inc.
   8  * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
   9  * DARPA CHATS research program.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The names of the authors may not be used to endorse or promote
  20  *    products derived from this software without specific prior written
  21  *    permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $FreeBSD$
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/malloc.h>
  41 #include <sys/kernel.h>
  42 #include <sys/conf.h>
  43 #include <sys/bio.h>
  44 #include <sys/lock.h>
  45 #include <sys/mutex.h>
  46 #include <sys/errno.h>
  47 #include <sys/time.h>
  48 #include <sys/disk.h>
  49 #include <sys/fcntl.h>
  50 #include <geom/geom.h>
  51
  52 #define CDEV_MAJOR      4
  53
  54 static d_open_t         g_dev_open;
  55 static d_close_t        g_dev_close;
  56 static d_strategy_t     g_dev_strategy;
  57 static d_ioctl_t        g_dev_ioctl;
  58 static d_psize_t        g_dev_psize;
  59
  60 static struct cdevsw g_dev_cdevsw = {
  61         /* open */      g_dev_open,
  62         /* close */     g_dev_close,
  63         /* read */      physread,
  64         /* write */     physwrite,
  65         /* ioctl */     g_dev_ioctl,
  66         /* poll */      nopoll,
  67         /* mmap */      nommap,
  68         /* strategy */  g_dev_strategy,
  69         /* name */      "g_dev",
  70         /* maj */       CDEV_MAJOR,
  71         /* dump */      nodump,
  72         /* psize */     g_dev_psize,
  73         /* flags */     D_DISK | D_CANFREE | D_TRACKCLOSE,
  74 };
  75
  76 static g_taste_t g_dev_taste;
  77 static g_orphan_t g_dev_orphan;
  78
  79 static struct g_method g_dev_method     = {
  80         "DEV-method",
  81         g_dev_taste,
  82         NULL,
  83         g_dev_orphan,
  84         NULL,
  85         G_METHOD_INITSTUFF
  86 };
  87
  88 static void
  89 g_dev_clone(void *arg, char *name, int namelen, dev_t *dev)
  90 {
  91         struct g_geom *gp;
  92
  93         if (*dev != NODEV)
  94                 return;
  95
  96         g_trace(G_T_TOPOLOGY, "g_dev_clone(%s)", name);
  97         g_rattle();
  98
  99         /* XXX: can I drop Giant here ??? */
 100         /* g_topology_lock(); */
 101         LIST_FOREACH(gp, &g_dev_method.geom, geom) {
 102                 if (strcmp(gp->name, name))
 103                         continue;
 104                 *dev = gp->softc;
 105                 g_trace(G_T_TOPOLOGY, "g_dev_clone(%s) = %p", name, *dev);
 106                 return;
 107         }
 108         /* g_topology_unlock(); */
 109         return;
 110 }
 111
 112 static void
 113 g_dev_register_cloner(void *foo __unused)
 114 {
 115         static int once;
 116
 117         if (!once) {
 118                 if (!once)
 119                         EVENTHANDLER_REGISTER(dev_clone, g_dev_clone, 0, 1000);
 120                 once++;
 121         }
 122 }
 123
 124 SYSINIT(geomdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,g_dev_register_cloner,NULL);
 125
 126 static struct g_geom *
 127 g_dev_taste(struct g_method *mp, struct g_provider *pp, struct thread *tp __unused, int insist __unused)
 128 {
 129         struct g_geom *gp;
 130         struct g_consumer *cp;
 131         static int unit;
 132         u_int secsize;
 133         off_t mediasize;
 134         int error, j;
 135         dev_t dev;
 136
 137         g_trace(G_T_TOPOLOGY, "dev_taste(%s,%s)", mp->name, pp->name);
 138         g_topology_assert();
 139         LIST_FOREACH(cp, &pp->consumers, consumers)
 140                 if (cp->geom->method == mp)
 141                         return (NULL);
 142         gp = g_new_geomf(mp, pp->name);
 143         cp = g_new_consumer(gp);
 144         g_attach(cp, pp);
 145         error = g_access_rel(cp, 1, 0, 0);
 146         g_topology_unlock();
 147         if (!error) {
 148                 j = sizeof secsize;
 149                 error = g_io_getattr("GEOM::sectorsize", cp, &j, &secsize, tp);
 150                 if (error) {
 151                         secsize = 512;
 152                         printf("g_bsd_taste: error %d Sectors are %d bytes\n",
 153                             error, secsize);
 154                 }
 155                 j = sizeof mediasize;
 156                 error = g_io_getattr("GEOM::mediasize", cp, &j, &mediasize, tp);
 157                 if (error) {
 158                         mediasize = 0;
 159                         printf("g_error %d Mediasize is %lld bytes\n",
 160                             error, mediasize);
 161                 }
 162                 g_topology_lock();
 163                 g_access_rel(cp, -1, 0, 0);
 164                 g_topology_unlock();
 165         } else {
 166                 secsize = 512;
 167                 mediasize = 0;
 168         }
 169         mtx_lock(&Giant);
 170         if (mediasize != 0)
 171                 printf("GEOM: \"%s\" %lld bytes in %lld sectors of %u bytes\n",
 172                     pp->name, mediasize, mediasize / secsize, secsize);
 173         else
 174                 printf("GEOM: \"%s\" (size unavailable)\n", pp->name);
 175         dev = make_dev(&g_dev_cdevsw, unit++,
 176             UID_ROOT, GID_WHEEL, 0600, gp->name);
 177         gp->softc = dev;
 178         dev->si_drv1 = gp;
 179         dev->si_drv2 = cp;
 180         mtx_unlock(&Giant);
 181         g_topology_lock();
 182         return (gp);
 183 }
 184
 185 static int
 186 g_dev_open(dev_t dev, int flags, int fmt, struct thread *td)
 187 {
 188         struct g_geom *gp;
 189         struct g_consumer *cp;
 190         int error, r, w, e;
 191
 192         gp = dev->si_drv1;
 193         cp = dev->si_drv2;
 194         if (gp == NULL || cp == NULL)
 195                 return(ENXIO);
 196         g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
 197             gp->name, flags, fmt, td);
 198         DROP_GIANT();
 199         g_topology_lock();
 200         g_silence();
 201         r = flags & FREAD ? 1 : 0;
 202         w = flags & FWRITE ? 1 : 0;
 203         e = flags & O_EXCL ? 1 : 0;
 204         error = g_access_rel(cp, r, w, e);
 205         g_topology_unlock();
 206         PICKUP_GIANT();
 207         g_rattle();
 208         return(error);
 209 }
 210
 211 static int
 212 g_dev_close(dev_t dev, int flags, int fmt, struct thread *td)
 213 {
 214         struct g_geom *gp;
 215         struct g_consumer *cp;
 216         int error, r, w, e;
 217
 218         gp = dev->si_drv1;
 219         cp = dev->si_drv2;
 220         if (gp == NULL || cp == NULL)
 221                 return(ENXIO);
 222         g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
 223             gp->name, flags, fmt, td);
 224         DROP_GIANT();
 225         g_topology_lock();
 226         g_silence();
 227         r = flags & FREAD ? -1 : 0;
 228         w = flags & FWRITE ? -1 : 0;
 229         e = flags & O_EXCL ? -1 : 0;
 230         error = g_access_rel(cp, r, w, e);
 231         g_topology_unlock();
 232         PICKUP_GIANT();
 233         g_rattle();
 234         return (error);
 235 }
 236
 237 static int
 238 g_dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
 239 {
 240         struct g_geom *gp;
 241         struct g_consumer *cp;
 242         int i, error;
 243         struct g_ioctl *gio;
 244
 245         gp = dev->si_drv1;
 246         cp = dev->si_drv2;
 247
 248         error = 0;
 249         DROP_GIANT();
 250
 251         gio = g_malloc(sizeof *gio, M_WAITOK);
 252         gio->cmd = cmd;
 253         gio->data = data;
 254         gio->fflag = fflag;
 255         gio->td = td;
 256         i = sizeof *gio;
 257         if (cmd & IOC_IN)
 258                 error = g_io_setattr("GEOM::ioctl", cp, i, gio, td);
 259         else
 260                 error = g_io_getattr("GEOM::ioctl", cp, &i, gio, td);
 261         g_free(gio);
 262
 263         if (error != 0 && cmd == DIOCGDVIRGIN) {
 264                 g_topology_lock();
 265                 gp = g_create_geomf("BSD-method", cp->provider, NULL);
 266                 g_topology_unlock();
 267         }
 268         PICKUP_GIANT();
 269         g_rattle();
 270         if (error == ENOIOCTL) {
 271                 i = IOCGROUP(cmd);
 272                 printf("IOCTL(0x%lx) \"%s\"", cmd, gp->name);
 273                 if (i > ' ' && i <= '~')
 274                         printf(" '%c'", (int)IOCGROUP(cmd));
 275                 else
 276                         printf(" 0x%lx", IOCGROUP(cmd));
 277                 printf("/%ld ", cmd & 0xff);
 278                 if (cmd & IOC_IN)
 279                         printf("I");
 280                 if (cmd & IOC_OUT)
 281                         printf("O");
 282                 printf("(%ld) = ENOIOCTL\n", IOCPARM_LEN(cmd));
 283                 error = ENOTTY;
 284         }
 285         return (error);
 286 }
 287
 288 static int
 289 g_dev_psize(dev_t dev)
 290 {
 291         struct g_consumer *cp;
 292         int i, error;
 293         off_t mediasize;
 294
 295         cp = dev->si_drv2;
 296
 297         i = sizeof mediasize;
 298         error = g_io_getattr("GEOM::mediasize", cp, &i, &mediasize, NULL);
 299         if (error)
 300                 return (-1);
 301         return (mediasize >> DEV_BSHIFT);
 302 }
 303
 304 static void
 305 g_dev_done(struct bio *bp2)
 306 {
 307         struct bio *bp;
 308
 309         bp = bp2->bio_linkage;
 310         bp->bio_error = bp2->bio_error;
 311         if (bp->bio_error != 0) {
 312                 g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
 313                     bp2, bp->bio_error);
 314                 bp->bio_flags |= BIO_ERROR;
 315         } else {
 316                 g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %lld",
 317                     bp2, bp, bp->bio_resid, bp2->bio_completed);
 318         }
 319         bp->bio_resid = bp->bio_bcount - bp2->bio_completed;
 320         g_destroy_bio(bp2);
 321         mtx_lock(&Giant);
 322         biodone(bp);
 323         mtx_unlock(&Giant);
 324 }
 325
 326 static void
 327 g_dev_strategy(struct bio *bp)
 328 {
 329         struct g_geom *gp;
 330         struct g_consumer *cp;
 331         struct bio *bp2;
 332         dev_t dev;
 333
 334         dev = bp->bio_dev;
 335         gp = dev->si_drv1;
 336         cp = dev->si_drv2;
 337         bp2 = g_clone_bio(bp);
 338         bp2->bio_offset = (off_t)bp->bio_blkno << DEV_BSHIFT;
 339         bp2->bio_length = (off_t)bp->bio_bcount;
 340         bp2->bio_done = g_dev_done;
 341         g_trace(G_T_BIO,
 342             "g_dev_strategy(%p/%p) offset %lld length %lld data %p cmd %d",
 343             bp, bp2, bp->bio_offset, bp2->bio_length, bp2->bio_data,
 344             bp2->bio_cmd);
 345         g_io_request(bp2, cp);
 346 }
 347
 348
 349 static void
 350 g_dev_orphan(struct g_consumer *cp, struct thread *tp)
 351 {
 352         struct g_geom *gp;
 353         dev_t dev;
 354
 355         gp = cp->geom;
 356         g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, gp->name);
 357         g_topology_assert();
 358         if (cp->biocount > 0)
 359                 return;
 360         dev = gp->softc;
 361         destroy_dev(dev);
 362         if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
 363                 g_access_rel(cp, -cp->acr, -cp->acw, -cp->ace);
 364         g_dettach(cp);
 365         g_destroy_consumer(cp);
 366         g_destroy_geom(gp);
 367 }
 368
 369 DECLARE_GEOM_METHOD(g_dev_method, g_dev)
 370