root/dev/ramdisk.c

DEFINITIONS

1. rdattach
2. rd_attach
3. rddump
4. rdsize
5. rdopen
6. rdclose
7. rdread
8. rdwrite
9. rdstrategy
10. rdioctl
11. rdgetdisklabel
12. rd_ioctl_kalloc
13. rd_ioctl_server
14. rd_server_loop

    1 /*      $OpenBSD: ramdisk.c,v 1.37 2007/06/20 18:15:46 deraadt Exp $    */
    2 /*      $NetBSD: ramdisk.c,v 1.8 1996/04/12 08:30:09 leo Exp $  */
    4 /*
    5  * Copyright (c) 1995 Gordon W. Ross, Leo Weppelman.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. The name of the author may not be used to endorse or promote products
   17  *    derived from this software without specific prior written permission.
   18  * 4. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by
   21  *                      Gordon W. Ross and Leo Weppelman.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   33  */
   35 /*
   36  * This implements a general-purpose RAM-disk.
   37  * See ramdisk.h for notes on the config types.
   38  *
   39  * Note that this driver provides the same functionality
   40  * as the MFS filesystem hack, but this is better because
   41  * you can use this for any filesystem type you'd like!
   42  *
   43  * Credit for most of the kmem ramdisk code goes to:
   44  *   Leo Weppelman (atari) and Phil Nelson (pc532)
   45  * Credit for the ideas behind the "user space RAM" code goes
   46  * to the authors of the MFS implementation.
   47  */
   49 #include <sys/param.h>
   50 #include <sys/kernel.h>
   51 #include <sys/malloc.h>
   52 #include <sys/systm.h>
   53 #include <sys/buf.h>
   54 #include <sys/device.h>
   55 #include <sys/file.h>
   56 #include <sys/disk.h>
   57 #include <sys/proc.h>
   58 #include <sys/conf.h>
   59 #include <sys/disklabel.h>
   60 #include <sys/dkio.h>
   62 #include <uvm/uvm_extern.h>
   64 #include <dev/ramdisk.h>
   66 /*
   67  * By default, include the user-space functionality.
   68  * Use:  option RAMDISK_SERVER=0 to turn it off.
   69  */
   70 #if !defined(RAMDISK_SERVER) && !defined(SMALL_KERNEL)
   71 #define RAMDISK_SERVER 1
   72 #endif
   74 /*
   75  * XXX: the "control" unit is (base unit + 16).
   76  * We should just use the cdev as the "control", but
   77  * that interferes with the security stuff preventing
   78  * simultaneous use of raw and block devices.
   79  *
   80  * XXX Assumption: 16 RAM-disks are enough!
   81  */
   82 #define RD_MAX_UNITS    0x10
   83 #define RD_IS_CTRL(dev) (DISKPART(dev) == RAW_PART)
   85 /* autoconfig stuff... */
   87 struct rd_softc {
   88         struct device sc_dev;   /* REQUIRED first entry */
   89         struct disk sc_dkdev;   /* hook for generic disk handling */
   90         struct rd_conf sc_rd;
   91 #if RAMDISK_SERVER
   92         struct buf *sc_buflist;
   93 #endif
   94 };
   95 /* shorthand for fields in sc_rd: */
   96 #define sc_addr sc_rd.rd_addr
   97 #define sc_size sc_rd.rd_size
   98 #define sc_type sc_rd.rd_type
  100 void rdattach(int);
  101 void rd_attach(struct device *, struct device *, void *);
  102 void rdgetdisklabel(dev_t, struct rd_softc *, struct disklabel *, int);
  104 /*
  105  * Some ports (like i386) use a swapgeneric that wants to
  106  * snoop around in this rd_cd structure.  It is preserved
  107  * (for now) to remain compatible with such practice.
  108  * XXX - that practice is questionable...
  109  */
  110 struct cfdriver rd_cd = {
NULL, "rd", DV_DULL
  112 };
  114 void rdstrategy(struct buf *bp);
  115 struct dkdriver rddkdriver = { rdstrategy };
  117 int   ramdisk_ndevs;
  118 void *ramdisk_devs[RD_MAX_UNITS];
  120 /*
  121  * This is called if we are configured as a pseudo-device
  122  */
  123 void
rdattach(n)
  125         int n;
  126 {
  127         struct rd_softc *sc;
  128         int i;
  130 #ifdef  DIAGNOSTIC
  131         if (ramdisk_ndevs) {
printf("ramdisk: multiple attach calls?\n");
  133                 return;
  134         }
  135 #endif
  137         /* XXX:  Are we supposed to provide a default? */
  138         if (n <= 1)
n = 1;
  140         if (n > RD_MAX_UNITS)
n = RD_MAX_UNITS;
ramdisk_ndevs = n;
  144         /* XXX: Fake-up rd_cd (see above) */
rd_cd.cd_ndevs = ramdisk_ndevs;
rd_cd.cd_devs  = ramdisk_devs;
  148         /* Attach as if by autoconfig. */
  149         for (i = 0; i < n; i++) {
sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK);
bzero((caddr_t)sc, sizeof(*sc));
  152                 if (snprintf(sc->sc_dev.dv_xname, sizeof(sc->sc_dev.dv_xname),
  153                     "rd%d", i) >= sizeof(sc->sc_dev.dv_xname)) {
printf("rdattach: device name too long\n");
free(sc, M_DEVBUF);
  156                         return;
  157                 }
ramdisk_devs[i] = sc;
sc->sc_dev.dv_unit = i;
rd_attach(NULL, &sc->sc_dev, NULL);
  161         }
  162 }
  164 void
rd_attach(parent, self, aux)
  166         struct device   *parent, *self;
  167         void            *aux;
  168 {
  169         struct rd_softc *sc = (struct rd_softc *)self;
  171         /* XXX - Could accept aux info here to set the config. */
  172 #ifdef  RAMDISK_HOOKS
  173         /*
  174          * This external function might setup a pre-loaded disk.
  175          * All it would need to do is setup the rd_conf struct.
  176          * See sys/arch/sun3/dev/rd_root.c for an example.
  177          */
rd_attach_hook(sc->sc_dev.dv_unit, &sc->sc_rd);
  179 #endif
  181         /*
  182          * Initialize and attach the disk structure.
  183          */
sc->sc_dkdev.dk_driver = &rddkdriver;
sc->sc_dkdev.dk_name = sc->sc_dev.dv_xname;
disk_attach(&sc->sc_dkdev);
  187 }
  189 /*
  190  * operational routines:
  191  * open, close, read, write, strategy,
  192  * ioctl, dump, size
  193  */
  195 #if RAMDISK_SERVER
  196 int rd_server_loop(struct rd_softc *sc);
  197 int rd_ioctl_server(struct rd_softc *sc,
  198                 struct rd_conf *urd, struct proc *proc);
  199 #endif
  200 int rd_ioctl_kalloc(struct rd_softc *sc,
  201                 struct rd_conf *urd, struct proc *proc);
dev_type_open(rdopen);
dev_type_close(rdclose);
dev_type_read(rdread);
dev_type_write(rdwrite);
dev_type_ioctl(rdioctl);
dev_type_size(rdsize);
dev_type_dump(rddump);
  211 int
  212 rddump(dev, blkno, va, size)
dev_t dev;
daddr64_t blkno;
caddr_t va;
size_t size;
  217 {
  218         return ENODEV;
  219 }
daddr64_t
rdsize(dev_t dev)
  223 {
  224         int part, unit;
  225         struct rd_softc *sc;
  227         /* Disallow control units. */
unit = DISKUNIT(dev);
  229         if (unit >= ramdisk_ndevs)
  230                 return 0;
sc = ramdisk_devs[unit];
  232         if (sc == NULL)
  233                 return 0;
  235         if (sc->sc_type == RD_UNCONFIGURED)
  236                 return 0;
rdgetdisklabel(dev, sc, sc->sc_dkdev.dk_label, 0);
part = DISKPART(dev);
  240         if (part >= sc->sc_dkdev.dk_label->d_npartitions)
  241                 return 0;
  242         else
  243                 return DL_GETPSIZE(&sc->sc_dkdev.dk_label->d_partitions[part]) *
  244                     (sc->sc_dkdev.dk_label->d_secsize / DEV_BSIZE);
  245 }
  247 int
  248 rdopen(dev, flag, fmt, proc)
dev_t   dev;
  250         int     flag, fmt;
  251         struct proc *proc;
  252 {
  253         int unit;
  254         struct rd_softc *sc;
unit = DISKUNIT(dev);
  257         if (unit >= ramdisk_ndevs)
  258                 return ENXIO;
sc = ramdisk_devs[unit];
  260         if (sc == NULL)
  261                 return ENXIO;
  263         /*
  264          * The control device is not exclusive, and can
  265          * open uninitialized units (so you can setconf).
  266          */
  267         if (RD_IS_CTRL(dev))
  268                 return 0;
  270 #ifdef  RAMDISK_HOOKS
  271         /* Call the open hook to allow loading the device. */
rd_open_hook(unit, &sc->sc_rd);
  273 #endif
  275         /*
  276          * This is a normal, "slave" device, so
  277          * enforce initialized, exclusive open.
  278          */
  279         if (sc->sc_type == RD_UNCONFIGURED)
  280                 return ENXIO;
  282         return 0;
  283 }
  285 int
  286 rdclose(dev, flag, fmt, proc)
dev_t   dev;
  288         int     flag, fmt;
  289         struct proc *proc;
  290 {
  292         return 0;
  293 }
  295 int
  296 rdread(dev, uio, flags)
dev_t           dev;
  298         struct uio      *uio;
  299         int             flags;
  300 {
  301         return (physio(rdstrategy, NULL, dev, B_READ, minphys, uio));
  302 }
  304 int
  305 rdwrite(dev, uio, flags)
dev_t           dev;
  307         struct uio      *uio;
  308         int             flags;
  309 {
  310         return (physio(rdstrategy, NULL, dev, B_WRITE, minphys, uio));
  311 }
  313 /*
  314  * Handle I/O requests, either directly, or
  315  * by passing them to the server process.
  316  */
  317 void
rdstrategy(bp)
  319         struct buf *bp;
  320 {
  321         int unit, part;
  322         struct rd_softc *sc;
caddr_t addr;
size_t off, xfer;
  325         int s;
unit = DISKUNIT(bp->b_dev);
sc = ramdisk_devs[unit];
  330         /* Sort rogue requests out */
  331         if (sc == NULL || bp->b_blkno < 0 ||
  332             (bp->b_bcount % sc->sc_dkdev.dk_label->d_secsize) != 0) {
bp->b_error = EINVAL;
  334                 goto bad;
  335         }
  337         /* Do not write on "no trespassing" areas... */
part = DISKPART(bp->b_dev);
  339         if (part != RAW_PART &&
bounds_check_with_label(bp, sc->sc_dkdev.dk_label, 1) <= 0)
  341                 goto bad;
  343         switch (sc->sc_type) {
  344 #if RAMDISK_SERVER
  345         case RD_UMEM_SERVER:
  346                 /* Just add this job to the server's queue. */
bp->b_actf = sc->sc_buflist;
sc->sc_buflist = bp;
  349                 if (bp->b_actf == NULL) {
  350                         /* server queue was empty. */
wakeup((caddr_t)sc);
  352                         /* see rd_server_loop() */
  353                 }
  354                 /* no biodone in this case */
  355                 return;
  356 #endif  /* RAMDISK_SERVER */
  358         case RD_KMEM_FIXED:
  359         case RD_KMEM_ALLOCATED:
  360                 /* These are in kernel space.  Access directly. */
bp->b_resid = bp->b_bcount;
off = (bp->b_blkno << DEV_BSHIFT);
xfer = bp->b_bcount;
  364                 if (xfer > (sc->sc_size - off))
xfer = (sc->sc_size - off);
addr = sc->sc_addr + off;
  367                 if (bp->b_flags & B_READ)
bcopy(addr, bp->b_data, xfer);
  369                 else
bcopy(bp->b_data, addr, xfer);
bp->b_resid -= xfer;
  372                 break;
  374         default:
bp->b_error = EIO;
bad:
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
  379                 break;
  380         }
s = splbio();
biodone(bp);
splx(s);
  385 }
  387 int
  388 rdioctl(dev, cmd, data, flag, proc)
dev_t   dev;
u_long  cmd;
  391         int             flag;
caddr_t data;
  393         struct proc     *proc;
  394 {
  395         int unit;
  396         struct disklabel *lp;
  397         struct rd_softc *sc;
  398         struct rd_conf *urd;
  399         int error;
unit = DISKUNIT(dev);
sc = ramdisk_devs[unit];
urd = (struct rd_conf *)data;
  405         switch (cmd) {
  406         case DIOCRLDINFO:
  407                 if (sc->sc_type == RD_UNCONFIGURED)
  408                         break;
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
rdgetdisklabel(dev, sc, lp, 0);
bcopy(lp, sc->sc_dkdev.dk_label, sizeof(*lp));
free(lp, M_TEMP);
  413                 return 0;
  415         case DIOCGPDINFO:
  416                 if (sc->sc_type == RD_UNCONFIGURED)
  417                         break;
rdgetdisklabel(dev, sc, (struct disklabel *)data, 1);
  419                 return 0;
  421         case DIOCGDINFO:
  422                 if (sc->sc_type == RD_UNCONFIGURED) {
  423                         break;
  424                 }
  425                 *(struct disklabel *)data = *(sc->sc_dkdev.dk_label);
  426                 return 0;
  428         case DIOCGPART:
  429                 ((struct partinfo *)data)->disklab = sc->sc_dkdev.dk_label;
  430                 ((struct partinfo *)data)->part =
  431                     &sc->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
  432                 return 0;
  434         case DIOCWDINFO:
  435         case DIOCSDINFO:
  436                 if (sc->sc_type == RD_UNCONFIGURED) {
  437                         break;
  438                 }
  439                 if ((flag & FWRITE) == 0)
  440                         return EBADF;
error = setdisklabel(sc->sc_dkdev.dk_label,
  443                     (struct disklabel *)data, /*sd->sc_dk.dk_openmask : */0);
  444                 if (error == 0) {
  445                         if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
rdstrategy, sc->sc_dkdev.dk_label);
  448                 }
  450                 return error;
  452         case DIOCWLABEL:
  453                 if (sc->sc_type == RD_UNCONFIGURED) {
  454                         break;
  455                 }
  456                 if ((flag & FWRITE) == 0)
  457                         return EBADF;
  458                 return 0;
  460         case RD_GETCONF:
  461                 /* If this is not the control device, punt! */
  462                 if (RD_IS_CTRL(dev) == 0) {
  463                         break;
  464                 }
  465                 *urd = sc->sc_rd;
  466                 return 0;
  468         case RD_SETCONF:
  469                 /* If this is not the control device, punt! */
  470                 if (RD_IS_CTRL(dev) == 0) {
  471                         break;
  472                 }
  473                 /* Can only set it once. */
  474                 if (sc->sc_type != RD_UNCONFIGURED) {
  475                         break;
  476                 }
  477                 switch (urd->rd_type) {
  478                 case RD_KMEM_ALLOCATED:
  479                         return rd_ioctl_kalloc(sc, urd, proc);
  480 #if RAMDISK_SERVER
  481                 case RD_UMEM_SERVER:
  482                         return rd_ioctl_server(sc, urd, proc);
  483 #endif
  484                 default:
  485                         break;
  486                 }
  487                 break;
  488         }
  489         return EINVAL;
  490 }
  492 void
rdgetdisklabel(dev_t dev, struct rd_softc *sc, struct disklabel *lp,
  494     int spoofonly)
  495 {
bzero(lp, sizeof(struct disklabel));
lp->d_secsize = DEV_BSIZE;
lp->d_ntracks = 1;
lp->d_nsectors = sc->sc_size >> DEV_BSHIFT;
lp->d_ncylinders = 1;
lp->d_secpercyl = lp->d_nsectors;
  503         if (lp->d_secpercyl == 0) {
lp->d_secpercyl = 100;
  505                 /* as long as it's not 0 - readdisklabel divides by it (?) */
  506         }
strncpy(lp->d_typename, "RAM disk", sizeof(lp->d_typename));
lp->d_type = DTYPE_SCSI;
strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
DL_SETDSIZE(lp, lp->d_nsectors);
lp->d_rpm = 3600;
lp->d_interleave = 1;
lp->d_version = 1;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
  520         /*
  521          * Call the generic disklabel extraction routine
  522          */
readdisklabel(DISKLABELDEV(dev), rdstrategy, lp, spoofonly);
  524 }
  526 /*
  527  * Handle ioctl RD_SETCONF for (sc_type == RD_KMEM_ALLOCATED)
  528  * Just allocate some kernel memory and return.
  529  */
  530 int
rd_ioctl_kalloc(sc, urd, proc)
  532         struct rd_softc *sc;
  533         struct rd_conf *urd;
  534         struct proc     *proc;
  535 {
vaddr_t addr;
vsize_t size;
  539         /* Sanity check the size. */
size = urd->rd_size;
addr = uvm_km_zalloc(kernel_map, size);
  542         if (!addr)
  543                 return ENOMEM;
  545         /* This unit is now configured. */
sc->sc_addr = (caddr_t)addr;    /* kernel space */
sc->sc_size = (size_t)size;
sc->sc_type = RD_KMEM_ALLOCATED;
  549         return 0;
  550 }       
  552 #if RAMDISK_SERVER
  554 /*
  555  * Handle ioctl RD_SETCONF for (sc_type == RD_UMEM_SERVER)
  556  * Set config, then become the I/O server for this unit.
  557  */
  558 int
rd_ioctl_server(sc, urd, proc)
  560         struct rd_softc *sc;
  561         struct rd_conf *urd;
  562         struct proc     *proc;
  563 {
vaddr_t end;
  565         int error;
  567         /* Sanity check addr, size. */
end = (vaddr_t) (urd->rd_addr + urd->rd_size);
  570         if ((end >= VM_MAXUSER_ADDRESS) || (end < ((vaddr_t) urd->rd_addr)) )
  571                 return EINVAL;
  573         /* This unit is now configured. */
sc->sc_addr = urd->rd_addr;     /* user space */
sc->sc_size = urd->rd_size;
sc->sc_type = RD_UMEM_SERVER;
  578         /* Become the server daemon */
error = rd_server_loop(sc);
  581         /* This server is now going away! */
sc->sc_type = RD_UNCONFIGURED;
sc->sc_addr = 0;
sc->sc_size = 0;
  586         return (error);
  587 }       
  589 int     rd_sleep_pri = PWAIT | PCATCH;
  591 int
rd_server_loop(sc)
  593         struct rd_softc *sc;
  594 {
  595         struct buf *bp;
caddr_t addr;   /* user space address */
size_t  off;    /* offset into "device" */
size_t  xfer;   /* amount to transfer */
  599         int error;
  600         int s;
  602         for (;;) {
  603                 /* Wait for some work to arrive. */
  604                 while (sc->sc_buflist == NULL) {
error = tsleep((caddr_t)sc, rd_sleep_pri, "rd_idle", 0);
  606                         if (error)
  607                                 return error;
  608                 }
  610                 /* Unlink buf from head of list. */
bp = sc->sc_buflist;
sc->sc_buflist = bp->b_actf;
bp->b_actf = NULL;
  615                 /* Do the transfer to/from user space. */
error = 0;
bp->b_resid = bp->b_bcount;
off = (bp->b_blkno << DEV_BSHIFT);
  619                 if (off >= sc->sc_size) {
  620                         if (bp->b_flags & B_READ)
  621                                 goto done;      /* EOF (not an error) */
error = EIO;
  623                         goto done;
  624                 }
xfer = bp->b_resid;
  626                 if (xfer > (sc->sc_size - off))
xfer = (sc->sc_size - off);
addr = sc->sc_addr + off;
  629                 if (bp->b_flags & B_READ)
error = copyin(addr, bp->b_data, xfer);
  631                 else
error = copyout(bp->b_data, addr, xfer);
  633                 if (!error)
bp->b_resid -= xfer;
done:
  637                 if (error) {
bp->b_error = error;
bp->b_flags |= B_ERROR;
  640                 }
s = splbio();
biodone(bp);
splx(s);
  644         }
  645 }
  647 #endif  /* RAMDISK_SERVER */