root/dev/ccd.c

DEFINITIONS

1. getccdbuf
2. putccdbuf
3. ccdattach
4. ccdinit
5. ccdinterleave
6. ccdopen
7. ccdclose
8. ccdstrategy
9. ccdstart
10. ccdbuffer
11. ccdintr
12. ccdiodone
13. ccdread
14. ccdwrite
15. ccdioctl
16. ccdsize
17. ccddump
18. ccdlookup
19. ccdgetdisklabel
20. printiinfo

    1 /*      $OpenBSD: ccd.c,v 1.78 2007/06/20 18:15:46 deraadt Exp $        */
    2 /*      $NetBSD: ccd.c,v 1.33 1996/05/05 04:21:14 thorpej Exp $ */
    4 /*-
    5  * Copyright (c) 1996 The NetBSD Foundation, Inc.
    6  * Copyright (c) 1997 Niklas Hallqvist.
    7  * Copyright (c) 2005 Michael Shalayeff.
    8  * All rights reserved.
    9  * 
   10  * This code is derived from software contributed to The NetBSD Foundation
   11  * by Jason R. Thorpe.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. All advertising materials mentioning features or use of this software
   22  *    must display the following acknowledgement:
   23  *        This product includes software developed by the NetBSD
   24  *        Foundation, Inc. and its contributors.
   25  * 4. Neither the name of The NetBSD Foundation nor the names of its
   26  *    contributors may be used to endorse or promote products derived
   27  *    from this software without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
   33  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   39  * POSSIBILITY OF SUCH DAMAGE.
   40  */
   42 /*
   43  * Copyright (c) 1988 University of Utah.
   44  * Copyright (c) 1990, 1993
   45  *      The Regents of the University of California.  All rights reserved.
   46  *
   47  * This code is derived from software contributed to Berkeley by
   48  * the Systems Programming Group of the University of Utah Computer
   49  * Science Department.
   50  *
   51  * Redistribution and use in source and binary forms, with or without
   52  * modification, are permitted provided that the following conditions
   53  * are met:
   54  * 1. Redistributions of source code must retain the above copyright
   55  *    notice, this list of conditions and the following disclaimer.
   56  * 2. Redistributions in binary form must reproduce the above copyright
   57  *    notice, this list of conditions and the following disclaimer in the
   58  *    documentation and/or other materials provided with the distribution.
   59  * 3. Neither the name of the University nor the names of its contributors
   60  *    may be used to endorse or promote products derived from this software
   61  *    without specific prior written permission.
   62  *
   63  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   64  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   65  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   66  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   67  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   68  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   69  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   70  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   71  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   72  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   73  * SUCH DAMAGE.
   74  *
   75  * from: Utah $Hdr: cd.c 1.6 90/11/28$
   76  *
   77  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
   78  */
   80 /*
   81  * "Concatenated" disk driver.
   82  *
   83  * Dynamic configuration and disklabel support by:
   84  *      Jason R. Thorpe <thorpej@nas.nasa.gov>
   85  *      Numerical Aerodynamic Simulation Facility
   86  *      Mail Stop 258-6
   87  *      NASA Ames Research Center
   88  *      Moffett Field, CA 94035
   89  *
   90  * Mirroring support based on code written by Satoshi Asami
   91  * and Nisha Talagala.
   92  */
   93 /* #define      CCDDEBUG */
   95 #include <sys/param.h>
   96 #include <sys/systm.h>
   97 #include <sys/proc.h>
   98 #include <sys/errno.h>
   99 #include <sys/buf.h>
  100 #include <sys/malloc.h>
  101 #include <sys/pool.h>
  102 #include <sys/namei.h>
  103 #include <sys/stat.h>
  104 #include <sys/ioctl.h>
  105 #include <sys/disklabel.h>
  106 #include <sys/device.h>
  107 #include <sys/disk.h>
  108 #include <sys/syslog.h>
  109 #include <sys/fcntl.h>
  110 #include <sys/vnode.h>
  111 #include <sys/conf.h>
  112 #include <sys/rwlock.h>
  114 #include <dev/ccdvar.h>
  116 #ifdef __GNUC__
  117 #define INLINE static __inline
  118 #else
  119 #define INLINE
  120 #endif
  122 /*
  123  * A concatenated disk is described after initialization by this structure.
  124  */
  125 struct ccd_softc {
  126         struct disk     sc_dkdev;               /* generic disk device info */
  127         struct ccdgeom  sc_geom;                /* pseudo geometry info */
  128         struct ccdcinfo *sc_cinfo;              /* component info */
  129         struct ccdiinfo *sc_itable;             /* interleave table */
  130         char            sc_xname[8];            /* XXX external name */
size_t          sc_size;                /* size of ccd */
  132         int             sc_flags;               /* flags */
  133         int             sc_cflags;              /* copy of ccd_flags */
  134         int             sc_ileave;              /* interleave */
u_int           sc_nccdisks;            /* # of components */
u_int           sc_nccunits;            /* # of components for data */
  137         struct rwlock   sc_rwlock;              /* lock */
  139 };
  141 /* sc_flags */
  142 #define CCDF_INITED     0x01    /* unit has been initialized */
  143 #define CCDF_WLABEL     0x02    /* label area is writable */
  144 #define CCDF_LABELLING  0x04    /* unit is currently being labelled */
  146 #ifdef CCDDEBUG
  147 #define CCD_DCALL(m,c)          if (ccddebug & (m)) c
  148 #define CCD_DPRINTF(m,a)        CCD_DCALL(m, printf a)
  149 #define CCDB_FOLLOW     0x01
  150 #define CCDB_INIT       0x02
  151 #define CCDB_IO         0x04
  152 #define CCDB_LABEL      0x08
  153 #define CCDB_VNODE      0x10
  154 int ccddebug = 0x00;
  155 #else
  156 #define CCD_DCALL(m,c)          /* m, c */
  157 #define CCD_DPRINTF(m,a)        /* m, a */
  158 #endif
  160 struct ccdbuf {
  161         struct buf      cb_buf;         /* new I/O buf */
  162         struct buf      *cb_obp;        /* ptr. to original I/O buf */
  163         struct ccd_softc*cb_sc;         /* point back to the device */
  164         struct ccdbuf   *cb_dep;        /* mutual ptrs for mirror part */
  165         int             cb_comp;        /* target component */
  166         int             cb_flags;       /* misc. flags */
  167 #define CBF_MIRROR      0x01            /* we're for a mirror component */
  168 #define CBF_DONE        0x02            /* this buffer is done */
  169 };
  171 /* called by main() at boot time */
  172 void    ccdattach(int);
  174 /* called by biodone() at interrupt time */
  175 void    ccdiodone(struct buf *);
daddr64_t       ccdsize(dev_t);
  178 void    ccdstart(struct ccd_softc *, struct buf *);
  179 void    ccdinterleave(struct ccd_softc *);
  180 void    ccdintr(struct ccd_softc *, struct buf *);
  181 int     ccdinit(struct ccddevice *, char **, struct proc *);
  182 int     ccdlookup(char *, struct proc *p, struct vnode **);
  183 long    ccdbuffer(struct ccd_softc *, struct buf *, daddr64_t, caddr_t,
  184     long, struct ccdbuf **);
  185 void    ccdgetdisklabel(dev_t, struct ccd_softc *, struct disklabel *, int);
INLINE struct ccdbuf *getccdbuf(void);
INLINE void putccdbuf(struct ccdbuf *);
  189 #define ccdlock(sc) rw_enter(&sc->sc_rwlock, RW_WRITE|RW_INTR)
  190 #define ccdunlock(sc) rw_exit_write(&sc->sc_rwlock)
  192 #ifdef CCDDEBUG
  193 void    printiinfo(struct ccdiinfo *);
  194 #endif
  196 /* Non-private for the benefit of libkvm. */
  197 struct  ccd_softc *ccd_softc;
  198 struct  ccddevice *ccddevs;
  199 int     numccd = 0;
  201 /*
  202  * struct ccdbuf allocator
  203  */
  204 struct pool     ccdbufpl;
  206 /*
  207  * Manage the ccd buffer structures.
  208  */
INLINE struct ccdbuf *
getccdbuf(void)
  211 {
  212         struct ccdbuf *cbp;
  214         if ((cbp = pool_get(&ccdbufpl, PR_WAITOK)))
bzero(cbp, sizeof(struct ccdbuf));
  216         return (cbp);
  217 }
INLINE void
putccdbuf(struct ccdbuf *cbp)
  221 {
pool_put(&ccdbufpl, cbp);
  223 }
  225 /*
  226  * Called by main() during pseudo-device attachment.  All we need
  227  * to do is allocate enough space for devices to be configured later.
  228  */
  229 void
ccdattach(int num)
  231 {
  232         int i;
  234         if (num <= 0) {
  235 #ifdef DIAGNOSTIC
panic("ccdattach: count <= 0");
  237 #endif
  238                 return;
  239         }
ccd_softc = (struct ccd_softc *)malloc(num * sizeof(struct ccd_softc),
M_DEVBUF, M_NOWAIT);
ccddevs = (struct ccddevice *)malloc(num * sizeof(struct ccddevice),
M_DEVBUF, M_NOWAIT);
  245         if ((ccd_softc == NULL) || (ccddevs == NULL)) {
printf("WARNING: no memory for concatenated disks\n");
  247                 if (ccd_softc != NULL)
free(ccd_softc, M_DEVBUF);
  249                 if (ccddevs != NULL)
free(ccddevs, M_DEVBUF);
  251                 return;
  252         }
  253         for (i = 0; i < num; i++) {
rw_init(&ccd_softc[i].sc_rwlock, "ccdlock");
  255         }
numccd = num;
bzero(ccd_softc, num * sizeof(struct ccd_softc));
bzero(ccddevs, num * sizeof(struct ccddevice));
pool_init(&ccdbufpl, sizeof(struct ccdbuf), 0, 0, 0, "ccdbufpl", NULL);
pool_setlowat(&ccdbufpl, 16);
pool_sethiwat(&ccdbufpl, 1024);
  263 }
  265 int
ccdinit(struct ccddevice *ccd, char **cpaths, struct proc *p)
  267 {
  268         struct ccd_softc *cs = &ccd_softc[ccd->ccd_unit];
  269         struct ccdcinfo *ci = NULL;
daddr64_t size;
  271         int ix, rpm;
  272         struct vnode *vp;
  273         struct vattr va;
size_t minsize;
  275         int maxsecsize;
  276         struct partinfo dpart;
  277         struct ccdgeom *ccg = &cs->sc_geom;
  278         char tmppath[MAXPATHLEN];
  279         int error;
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT, ("ccdinit: unit %d cflags %b\n",
ccd->ccd_unit, ccd->ccd_flags, CCDF_BITS));
cs->sc_size = 0;
cs->sc_ileave = ccd->ccd_interleave;
cs->sc_nccdisks = ccd->ccd_ndev;
  287         if (snprintf(cs->sc_xname, sizeof(cs->sc_xname), "ccd%d",
ccd->ccd_unit) >= sizeof(cs->sc_xname)) {
printf("ccdinit: device name too long.\n");
  290                 return(ENXIO);
  291         }
  293         /* Allocate space for the component info. */
cs->sc_cinfo = malloc(cs->sc_nccdisks * sizeof(struct ccdcinfo),
M_DEVBUF, M_WAITOK);
bzero(cs->sc_cinfo, cs->sc_nccdisks * sizeof(struct ccdcinfo));
  298         /*
  299          * Verify that each component piece exists and record
  300          * relevant information about it.
  301          */
maxsecsize = 0;
minsize = 0;
rpm = 0;
  305         for (ix = 0; ix < cs->sc_nccdisks; ix++) {
vp = ccd->ccd_vpp[ix];
ci = &cs->sc_cinfo[ix];
ci->ci_vp = vp;
  310                 /*
  311                  * Copy in the pathname of the component.
  312                  */
bzero(tmppath, sizeof(tmppath));        /* sanity */
error = copyinstr(cpaths[ix], tmppath,
MAXPATHLEN, &ci->ci_pathlen);
  316                 if (error) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  318                             ("%s: can't copy path, error = %d\n",
cs->sc_xname, error));
free(cs->sc_cinfo, M_DEVBUF);
  321                         return (error);
  322                 }
ci->ci_path = malloc(ci->ci_pathlen, M_DEVBUF, M_WAITOK);
bcopy(tmppath, ci->ci_path, ci->ci_pathlen);
  326                 /*
  327                  * XXX: Cache the component's dev_t.
  328                  */
  329                 if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  331                             ("%s: %s: getattr failed error = %d\n",
cs->sc_xname, ci->ci_path, error));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  335                         return (error);
  336                 }
ci->ci_dev = va.va_rdev;
  339                 /*
  340                  * Get partition information for the component.
  341                  */
error = VOP_IOCTL(vp, DIOCGPART, (caddr_t)&dpart,
FREAD, p->p_ucred, p);
  344                 if (error) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  346                             ("%s: %s: ioctl failed, error = %d\n",
cs->sc_xname, ci->ci_path, error));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  350                         return (error);
  351                 }
  352                 if (dpart.part->p_fstype == FS_CCD ||
dpart.part->p_fstype == FS_BSDFFS) {
maxsecsize =
  355                             ((dpart.disklab->d_secsize > maxsecsize) ?
dpart.disklab->d_secsize : maxsecsize);
size = DL_GETPSIZE(dpart.part);
  358                 } else {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  360                             ("%s: %s: incorrect partition type\n",
cs->sc_xname, ci->ci_path));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  364                         return (EFTYPE);
  365                 }
  367                 /*
  368                  * Calculate the size, truncating to an interleave
  369                  * boundary if necessary.
  370                  */
  371                 if (cs->sc_ileave > 1)
size -= size % cs->sc_ileave;
  374                 if (size == 0) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  376                             ("%s: %s: size == 0\n", cs->sc_xname, ci->ci_path));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  379                         return (ENODEV);
  380                 }
  382                 if (minsize == 0 || size < minsize)
minsize = size;
ci->ci_size = size;
cs->sc_size += size;
rpm += dpart.disklab->d_rpm;
  387         }
ccg->ccg_rpm = rpm / cs->sc_nccdisks;
  390         /*
  391          * Don't allow the interleave to be smaller than
  392          * the biggest component sector.
  393          */
  394         if ((cs->sc_ileave > 0) &&
  395             (cs->sc_ileave < (maxsecsize / DEV_BSIZE))) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  397                     ("%s: interleave must be at least %d\n",
cs->sc_xname, (maxsecsize / DEV_BSIZE)));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  401                 return (EINVAL);
  402         }
  404         /*
  405          * Mirroring support requires uniform interleave and
  406          * and even number of components.
  407          */
  408         if (ccd->ccd_flags & CCDF_MIRROR) {
ccd->ccd_flags |= CCDF_UNIFORM;
  410                 if (cs->sc_ileave == 0) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  412                             ("%s: mirroring requires interleave\n",
cs->sc_xname));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  416                         return (EINVAL);
  417                 }
  418                 if (cs->sc_nccdisks % 2) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
  420                             ("%s: mirroring requires even # of components\n",
cs->sc_xname));
free(ci->ci_path, M_DEVBUF);
free(cs->sc_cinfo, M_DEVBUF);
  424                         return (EINVAL);
  425                 }
  426         }
  428         /*
  429          * If uniform interleave is desired set all sizes to that of
  430          * the smallest component.
  431          */
ccg->ccg_ntracks = cs->sc_nccunits = cs->sc_nccdisks;
  433         if (ccd->ccd_flags & CCDF_UNIFORM) {
  434                 for (ci = cs->sc_cinfo;
ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++)
ci->ci_size = minsize;
  438                 if (ccd->ccd_flags & CCDF_MIRROR)
cs->sc_nccunits = ccg->ccg_ntracks /= 2;
cs->sc_size = ccg->ccg_ntracks * minsize;
  441         }
cs->sc_cflags = ccd->ccd_flags; /* So we can find out later... */
  445         /*
  446          * Construct the interleave table.
  447          */
ccdinterleave(cs);
  450         /*
  451          * Create pseudo-geometry based on 1MB cylinders.  It's
  452          * pretty close.
  453          */
ccg->ccg_secsize = DEV_BSIZE;
ccg->ccg_nsectors = cs->sc_ileave? cs->sc_ileave :
  456             1024 * (1024 / ccg->ccg_secsize);
ccg->ccg_ncylinders = cs->sc_size / ccg->ccg_ntracks /
ccg->ccg_nsectors;
cs->sc_flags |= CCDF_INITED;
  462         return (0);
  463 }
  465 void
ccdinterleave(struct ccd_softc *cs)
  467 {
  468         struct ccdcinfo *ci, *smallci;
  469         struct ccdiinfo *ii;
daddr64_t bn, lbn;
  471         int ix;
u_long size;
CCD_DPRINTF(CCDB_INIT,
  475             ("ccdinterleave(%p): ileave %d\n", cs, cs->sc_ileave));
  477         /*
  478          * Allocate an interleave table.
  479          * Chances are this is too big, but we don't care.
  480          */
size = (cs->sc_nccdisks + 1) * sizeof(struct ccdiinfo);
cs->sc_itable = (struct ccdiinfo *)malloc(size, M_DEVBUF, M_WAITOK);
bzero((caddr_t)cs->sc_itable, size);
  485         /*
  486          * Trivial case: no interleave (actually interleave of disk size).
  487          * Each table entry represents a single component in its entirety.
  488          */
  489         if (cs->sc_ileave == 0) {
bn = 0;
ii = cs->sc_itable;
  493                 for (ix = 0; ix < cs->sc_nccdisks; ix++) {
  494                         /* Allocate space for ii_index. */
ii->ii_index = malloc(sizeof(int), M_DEVBUF, M_WAITOK);
ii->ii_ndisk = 1;
ii->ii_startblk = bn;
ii->ii_startoff = 0;
ii->ii_index[0] = ix;
bn += cs->sc_cinfo[ix].ci_size;
ii++;
  502                 }
ii->ii_ndisk = 0;
CCD_DCALL(CCDB_INIT, printiinfo(cs->sc_itable));
  506                 return;
  507         }
  509         /*
  510          * The following isn't fast or pretty; it doesn't have to be.
  511          */
size = 0;
bn = lbn = 0;
  514         for (ii = cs->sc_itable; ; ii++) {
  515                 /* Allocate space for ii_index. */
ii->ii_index = malloc((sizeof(int) * cs->sc_nccdisks),
M_DEVBUF, M_WAITOK);
  519                 /*
  520                  * Locate the smallest of the remaining components
  521                  */
smallci = NULL;
  523                 for (ci = cs->sc_cinfo;
ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++)
  525                         if (ci->ci_size > size &&
  526                             (smallci == NULL ||
ci->ci_size < smallci->ci_size))
smallci = ci;
  530                 /*
  531                  * Nobody left, all done
  532                  */
  533                 if (smallci == NULL) {
ii->ii_ndisk = 0;
  535                         break;
  536                 }
  538                 /*
  539                  * Record starting logical block and component offset
  540                  */
ii->ii_startblk = bn / cs->sc_ileave;
ii->ii_startoff = lbn;
  544                 /*
  545                  * Determine how many disks take part in this interleave
  546                  * and record their indices.
  547                  */
ix = 0;
  549                 for (ci = cs->sc_cinfo;
ci < &cs->sc_cinfo[cs->sc_nccunits]; ci++)
  551                         if (ci->ci_size >= smallci->ci_size)
ii->ii_index[ix++] = ci - cs->sc_cinfo;
ii->ii_ndisk = ix;
bn += ix * (smallci->ci_size - size);
lbn = smallci->ci_size / cs->sc_ileave;
size = smallci->ci_size;
  557         }
CCD_DCALL(CCDB_INIT, printiinfo(cs->sc_itable));
  560 }
  562 /* ARGSUSED */
  563 int
ccdopen(dev_t dev, int flags, int fmt, struct proc *p)
  565 {
  566         int unit = DISKUNIT(dev);
  567         struct ccd_softc *cs;
  568         struct disklabel *lp;
  569         int error = 0, part, pmask;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdopen(%x, %x)\n", dev, flags));
  573         if (unit >= numccd)
  574                 return (ENXIO);
cs = &ccd_softc[unit];
  577         if ((error = ccdlock(cs)) != 0)
  578                 return (error);
lp = cs->sc_dkdev.dk_label;
part = DISKPART(dev);
pmask = (1 << part);
  585         /*
  586          * If we're initialized, check to see if there are any other
  587          * open partitions.  If not, then it's safe to update
  588          * the in-core disklabel.
  589          */
  590         if ((cs->sc_flags & CCDF_INITED) && (cs->sc_dkdev.dk_openmask == 0))
ccdgetdisklabel(dev, cs, lp, 0);
  593         /* Check that the partition exists. */
  594         if (part != RAW_PART) {
  595                 if (((cs->sc_flags & CCDF_INITED) == 0) ||
  596                     ((part >= lp->d_npartitions) ||
  597                     (lp->d_partitions[part].p_fstype == FS_UNUSED))) {
error = ENXIO;
  599                         goto done;
  600                 }
  601         }
  603         /* Prevent our unit from being unconfigured while open. */
  604         switch (fmt) {
  605         case S_IFCHR:
cs->sc_dkdev.dk_copenmask |= pmask;
  607                 break;
  609         case S_IFBLK:
cs->sc_dkdev.dk_bopenmask |= pmask;
  611                 break;
  612         }
cs->sc_dkdev.dk_openmask =
cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask;
done:
ccdunlock(cs);
  618         return (error);
  619 }
  621 /* ARGSUSED */
  622 int
ccdclose(dev_t dev, int flags, int fmt, struct proc *p)
  624 {
  625         int unit = DISKUNIT(dev);
  626         struct ccd_softc *cs;
  627         int error = 0, part;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdclose(%x, %x)\n", dev, flags));
  631         if (unit >= numccd)
  632                 return (ENXIO);
cs = &ccd_softc[unit];
  635         if ((error = ccdlock(cs)) != 0)
  636                 return (error);
part = DISKPART(dev);
  640         /* ...that much closer to allowing unconfiguration... */
  641         switch (fmt) {
  642         case S_IFCHR:
cs->sc_dkdev.dk_copenmask &= ~(1 << part);
  644                 break;
  646         case S_IFBLK:
cs->sc_dkdev.dk_bopenmask &= ~(1 << part);
  648                 break;
  649         }
cs->sc_dkdev.dk_openmask =
cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask;
ccdunlock(cs);
  654         return (0);
  655 }
  657 void
ccdstrategy(struct buf *bp)
  659 {
  660         int unit = DISKUNIT(bp->b_dev);
  661         struct ccd_softc *cs = &ccd_softc[unit];
  662         int s;
  663         int wlabel;
  664         struct disklabel *lp;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdstrategy(%p): unit %d\n", bp, unit));
  668         if ((cs->sc_flags & CCDF_INITED) == 0) {
bp->b_error = ENXIO;
bp->b_resid = bp->b_bcount;
bp->b_flags |= B_ERROR;
  672                 goto done;
  673         }
  675         /* If it's a nil transfer, wake up the top half now. */
  676         if (bp->b_bcount == 0)
  677                 goto done;
lp = cs->sc_dkdev.dk_label;
  681         /*
  682          * Do bounds checking and adjust transfer.  If there's an
  683          * error, the bounds check will flag that for us.
  684          */
wlabel = cs->sc_flags & (CCDF_WLABEL|CCDF_LABELLING);
  686         if (DISKPART(bp->b_dev) != RAW_PART &&
bounds_check_with_label(bp, lp, wlabel) <= 0)
  688                 goto done;
bp->b_resid = bp->b_bcount;
  692         /*
  693          * "Start" the unit.
  694          */
s = splbio();
ccdstart(cs, bp);
splx(s);
  698         return;
done:
s = splbio();
biodone(bp);
splx(s);
  703 }
  705 void
ccdstart(struct ccd_softc *cs, struct buf *bp)
  707 {
  708         long bcount, rcount;
  709         struct ccdbuf **cbpp;
caddr_t addr;
daddr64_t bn;
  712         struct partition *pp;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdstart(%p, %p, %s)\n", cs, bp,
bp->b_flags & B_READ? "read" : "write"));
  717         /* Instrumentation. */
disk_busy(&cs->sc_dkdev);
  720         /*
  721          * Translate the partition-relative block number to an absolute.
  722          */
bn = bp->b_blkno;
pp = &cs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
bn += DL_GETPOFFSET(pp);
  727         /*
  728          * Allocate component buffers
  729          */
cbpp = malloc(2 * cs->sc_nccdisks * sizeof(struct ccdbuf *), M_DEVBUF,
M_WAITOK);
bzero(cbpp, 2 * cs->sc_nccdisks * sizeof(struct ccdbuf *));
addr = bp->b_data;
  734         for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
rcount = ccdbuffer(cs, bp, bn, addr, bcount, cbpp);
  737                 /*
  738                  * This is the old, slower, but less restrictive, mode of
  739                  * operation.  It allows interleaves which are not multiples
  740                  * of PAGE_SIZE and mirroring.
  741                  */
  742                 if ((cbpp[0]->cb_buf.b_flags & B_READ) == 0)
cbpp[0]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(&cbpp[0]->cb_buf);
  746                 if ((cs->sc_cflags & CCDF_MIRROR) &&
  747                     ((cbpp[0]->cb_buf.b_flags & B_READ) == 0)) {
cbpp[1]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(&cbpp[1]->cb_buf);
  750                 }
bn += btodb(rcount);
addr += rcount;
  754         }
free(cbpp, M_DEVBUF);
  757 }
  759 /*
  760  * Build a component buffer header.
  761  */
  762 long
ccdbuffer(struct ccd_softc *cs, struct buf *bp, daddr64_t bn, caddr_t addr,
  764     long bcount, struct ccdbuf **cbpp)
  765 {
  766         struct ccdcinfo *ci, *ci2 = NULL;
  767         struct ccdbuf *cbp;
daddr64_t cbn, cboff, sblk;
  769         int ccdisk, ccdisk2, off;
  770         long cnt;
  771         struct ccdiinfo *ii;
  772         struct buf *nbp;
CCD_DPRINTF(CCDB_IO, ("ccdbuffer(%p, %p, %d, %p, %ld, %p)\n",
cs, bp, bn, addr, bcount, cbpp));
  777         /*
  778          * Determine which component bn falls in.
  779          */
cbn = bn;
cboff = 0;
  783         if (cs->sc_ileave == 0) {
  784                 /*
  785                  * Serially concatenated
  786                  */
sblk = 0;
  788                 for (ccdisk = 0, ci = &cs->sc_cinfo[ccdisk];
cbn >= sblk + ci->ci_size;
ccdisk++, ci = &cs->sc_cinfo[ccdisk])
sblk += ci->ci_size;
cbn -= sblk;
  793         } else {
  794                 /*
  795                  * Interleaved
  796                  */
cboff = cbn % cs->sc_ileave;
cbn /= cs->sc_ileave;
  799                 for (ii = cs->sc_itable; ii->ii_ndisk; ii++)
  800                         if (ii->ii_startblk > cbn)
  801                                 break;
ii--;
off = cbn - ii->ii_startblk;
  804                 if (ii->ii_ndisk == 1) {
ccdisk = ii->ii_index[0];
cbn = ii->ii_startoff + off;
  807                 } else {
ccdisk = ii->ii_index[off % ii->ii_ndisk];
cbn = ii->ii_startoff + off / ii->ii_ndisk;
  810                 }
  811                 if (cs->sc_cflags & CCDF_MIRROR) {
  812                         /* Mirrored data */
ccdisk2 = ccdisk + ii->ii_ndisk;
ci2 = &cs->sc_cinfo[ccdisk2];
  815                         /* spread the read over both parts */
  816                         if (bp->b_flags & B_READ &&
bcount > bp->b_bcount / 2 &&
  818                             (!(ci2->ci_flags & CCIF_FAILED) ||
ci->ci_flags & CCIF_FAILED))
ccdisk = ccdisk2;
  821                 }
cbn *= cs->sc_ileave;
ci = &cs->sc_cinfo[ccdisk];
CCD_DPRINTF(CCDB_IO, ("ccdisk %d cbn %d ci %p ci2 %p\n",
ccdisk, cbn, ci, ci2));
  826         }
  828         /* Limit the operation at next component border */
  829         if (cs->sc_ileave == 0)
cnt = dbtob(ci->ci_size - cbn);
  831         else
cnt = dbtob(cs->sc_ileave - cboff);
  833         if (cnt < bcount)
bcount = cnt;
  836         /*
  837          * Setup new component buffer.
  838          */
cbp = cbpp[0] = getccdbuf();
cbp->cb_flags = 0;
nbp = &cbp->cb_buf;
nbp->b_flags = bp->b_flags | B_CALL;
nbp->b_iodone = ccdiodone;
nbp->b_proc = bp->b_proc;
nbp->b_dev = ci->ci_dev;                /* XXX */
nbp->b_blkno = cbn + cboff;
nbp->b_vp = ci->ci_vp;
nbp->b_bcount = bcount;
LIST_INIT(&nbp->b_dep);
nbp->b_data = addr;
  852         /*
  853          * context for ccdiodone
  854          */
cbp->cb_obp = bp;
cbp->cb_sc = cs;
cbp->cb_comp = ccdisk;
  859         /*
  860          * Mirrors have an additional write operation that is nearly
  861          * identical to the first.
  862          */
  863         if ((cs->sc_cflags & CCDF_MIRROR) &&
  864             !(ci2->ci_flags & CCIF_FAILED) &&
  865             ((cbp->cb_buf.b_flags & B_READ) == 0)) {
  866                 struct ccdbuf *cbp2;
cbpp[1] = cbp2 = getccdbuf();
  868                 *cbp2 = *cbp;
cbp2->cb_flags = CBF_MIRROR;
cbp2->cb_buf.b_dev = ci2->ci_dev;       /* XXX */
cbp2->cb_buf.b_vp = ci2->ci_vp;
LIST_INIT(&cbp2->cb_buf.b_dep);
cbp2->cb_comp = ccdisk2;
cbp2->cb_dep = cbp;
cbp->cb_dep = cbp2;
  876         }
CCD_DPRINTF(CCDB_IO, (" dev %x(u%d): cbp %p bn %d addr %p bcnt %ld\n",
ci->ci_dev, ci-cs->sc_cinfo, cbp, bp->b_blkno,
bp->b_data, bp->b_bcount));
  882         return (bcount);
  883 }
  885 void
ccdintr(struct ccd_softc *cs, struct buf *bp)
  887 {
splassert(IPL_BIO);
CCD_DPRINTF(CCDB_FOLLOW, ("ccdintr(%p, %p)\n", cs, bp));
  893         /*
  894          * Request is done for better or worse, wakeup the top half.
  895          */
  896         if (bp->b_flags & B_ERROR)
bp->b_resid = bp->b_bcount;
disk_unbusy(&cs->sc_dkdev, (bp->b_bcount - bp->b_resid),
  899             (bp->b_flags & B_READ));
biodone(bp);
  901 }
  903 /*
  904  * Called at interrupt time.
  905  * Mark the component as done and if all components are done,
  906  * take a ccd interrupt.
  907  */
  908 void
ccdiodone(struct buf *vbp)
  910 {
  911         struct ccdbuf *cbp = (struct ccdbuf *)vbp;
  912         struct buf *bp = cbp->cb_obp;
  913         struct ccd_softc *cs = cbp->cb_sc;
  914         long count = bp->b_bcount;
  915         char *comptype;
splassert(IPL_BIO);
CCD_DPRINTF(CCDB_FOLLOW, ("ccdiodone(%p)\n", cbp));
CCD_DPRINTF(CCDB_IO, (cbp->cb_flags & CBF_MIRROR?
  921             "ccdiodone: mirror component\n" : 
  922             "ccdiodone: bp %p bcount %ld resid %ld\n",
bp, bp->b_bcount, bp->b_resid));
CCD_DPRINTF(CCDB_IO, (" dev %x(u%d), cbp %p bn %d addr %p bcnt %ld\n",
vbp->b_dev, cbp->cb_comp, cbp, vbp->b_blkno,
vbp->b_data, vbp->b_bcount));
  928         if (vbp->b_flags & B_ERROR) {
cs->sc_cinfo[cbp->cb_comp].ci_flags |= CCIF_FAILED;
  930                 if (cbp->cb_flags & CBF_MIRROR)
comptype = " (mirror)";
  932                 else {
bp->b_flags |= B_ERROR;
bp->b_error = vbp->b_error ?
vbp->b_error : EIO;
comptype = "";
  937                 }
printf("%s: error %d on component %d%s\n",
cs->sc_xname, bp->b_error, cbp->cb_comp, comptype);
  941         }
cbp->cb_flags |= CBF_DONE;
  944         if (cbp->cb_dep &&
  945             (cbp->cb_dep->cb_flags & CBF_DONE) != (cbp->cb_flags & CBF_DONE))
  946                 return;
  948         if (cbp->cb_flags & CBF_MIRROR &&
  949             !(cbp->cb_dep->cb_flags & CBF_MIRROR)) {
cbp = cbp->cb_dep;
vbp = (struct buf *)cbp;
  952         }
count = vbp->b_bcount;
putccdbuf(cbp);
  957         if (cbp->cb_dep)
putccdbuf(cbp->cb_dep);
  960         /*
  961          * If all done, "interrupt".
  962          *
  963          * Note that mirror component buffers aren't counted against
  964          * the original I/O buffer.
  965          */
  966         if (count > bp->b_resid)
panic("ccdiodone: count");
bp->b_resid -= count;
  969         if (bp->b_resid == 0)
ccdintr(cs, bp);
  971 }
  973 /* ARGSUSED */
  974 int
  975 ccdread(dev_t dev, struct uio *uio, int flags)
  976 {
  977         int unit = DISKUNIT(dev);
  978         struct ccd_softc *cs;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdread(%x, %p)\n", dev, uio));
  982         if (unit >= numccd)
  983                 return (ENXIO);
cs = &ccd_softc[unit];
  986         if ((cs->sc_flags & CCDF_INITED) == 0)
  987                 return (ENXIO);
  989         /*
  990          * XXX: It's not clear that using minphys() is completely safe,
  991          * in particular, for raw I/O.  Underlying devices might have some
  992          * non-obvious limits, because of the copy to user-space.
  993          */
  994         return (physio(ccdstrategy, NULL, dev, B_READ, minphys, uio));
  995 }
  997 /* ARGSUSED */
  998 int
  999 ccdwrite(dev_t dev, struct uio *uio, int flags)
 1000 {
 1001         int unit = DISKUNIT(dev);
 1002         struct ccd_softc *cs;
CCD_DPRINTF(CCDB_FOLLOW, ("ccdwrite(%x, %p)\n", dev, uio));
 1006         if (unit >= numccd)
 1007                 return (ENXIO);
cs = &ccd_softc[unit];
 1010         if ((cs->sc_flags & CCDF_INITED) == 0)
 1011                 return (ENXIO);
 1013         /*
 1014          * XXX: It's not clear that using minphys() is completely safe,
 1015          * in particular, for raw I/O.  Underlying devices might have some
 1016          * non-obvious limits, because of the copy to user-space.
 1017          */
 1018         return (physio(ccdstrategy, NULL, dev, B_WRITE, minphys, uio));
 1019 }
 1021 int
 1022 ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 1023 {
 1024         int unit = DISKUNIT(dev);
 1025         int i, j, lookedup = 0, error = 0;
 1026         int part, pmask, s;
 1027         struct ccd_softc *cs;
 1028         struct ccd_ioctl *ccio = (struct ccd_ioctl *)data;
 1029         struct ccddevice ccd;
 1030         char **cpp;
 1031         struct vnode **vpp;
 1033         if (unit >= numccd)
 1034                 return (ENXIO);
cs = &ccd_softc[unit];
 1037         if (cmd != CCDIOCSET && !(cs->sc_flags & CCDF_INITED))
 1038                 return (ENXIO);
 1040         /* access control */
 1041         switch (cmd) {
 1042         case CCDIOCSET:
 1043         case CCDIOCCLR:
 1044         case DIOCWDINFO:
 1045         case DIOCSDINFO:
 1046         case DIOCWLABEL:
 1047                 if ((flag & FWRITE) == 0)
 1048                         return (EBADF);
 1049         }
bzero(&ccd, sizeof(ccd));
 1052         switch (cmd) {
 1053         case CCDIOCSET:
 1054                 if (cs->sc_flags & CCDF_INITED)
 1055                         return (EBUSY);
 1057                 if (ccio->ccio_ndisks == 0 || ccio->ccio_ndisks > INT_MAX ||
ccio->ccio_ileave < 0)
 1059                         return (EINVAL);
 1061                 if ((error = ccdlock(cs)) != 0)
 1062                         return (error);
 1064                 /* Fill in some important bits. */
ccd.ccd_unit = unit;
ccd.ccd_interleave = ccio->ccio_ileave;
ccd.ccd_flags = ccio->ccio_flags & CCDF_USERMASK;
 1069                 /*
 1070                  * Allocate space for and copy in the array of
 1071                  * componet pathnames and device numbers.
 1072                  */
cpp = malloc(ccio->ccio_ndisks * sizeof(char *),
M_DEVBUF, M_WAITOK);
vpp = malloc(ccio->ccio_ndisks * sizeof(struct vnode *),
M_DEVBUF, M_WAITOK);
error = copyin((caddr_t)ccio->ccio_disks, (caddr_t)cpp,
ccio->ccio_ndisks * sizeof(char **));
 1080                 if (error) {
free(vpp, M_DEVBUF);
free(cpp, M_DEVBUF);
ccdunlock(cs);
 1084                         return (error);
 1085                 }
 1087                 for (i = 0; i < ccio->ccio_ndisks; ++i) {
CCD_DPRINTF(CCDB_INIT,
 1089                             ("ccdioctl: component %d: %p, lookedup = %d\n",
i, cpp[i], lookedup));
 1091                         if ((error = ccdlookup(cpp[i], p, &vpp[i])) != 0) {
 1092                                 for (j = 0; j < lookedup; ++j)
 1093                                         (void)vn_close(vpp[j], FREAD|FWRITE,
p->p_ucred, p);
free(vpp, M_DEVBUF);
free(cpp, M_DEVBUF);
ccdunlock(cs);
 1098                                 return (error);
 1099                         }
 1100                         ++lookedup;
 1101                 }
ccd.ccd_cpp = cpp;
ccd.ccd_vpp = vpp;
ccd.ccd_ndev = ccio->ccio_ndisks;
 1106                 /*
 1107                  * Initialize the ccd.  Fills in the softc for us.
 1108                  */
 1109                 if ((error = ccdinit(&ccd, cpp, p)) != 0) {
 1110                         for (j = 0; j < lookedup; ++j)
 1111                                 (void)vn_close(vpp[j], FREAD|FWRITE,
p->p_ucred, p);
bzero(&ccd_softc[unit], sizeof(struct ccd_softc));
free(vpp, M_DEVBUF);
free(cpp, M_DEVBUF);
ccdunlock(cs);
 1117                         return (error);
 1118                 }
 1120                 /*
 1121                  * The ccd has been successfully initialized, so
 1122                  * we can place it into the array.  Don't try to
 1123                  * read the disklabel until the disk has been attached,
 1124                  * because space for the disklabel is allocated
 1125                  * in disk_attach();
 1126                  */
bcopy(&ccd, &ccddevs[unit], sizeof(ccd));
ccio->ccio_unit = unit;
ccio->ccio_size = cs->sc_size;
 1131                 /* Attach the disk. */
cs->sc_dkdev.dk_name = cs->sc_xname;
disk_attach(&cs->sc_dkdev);
 1135                 /* Try and read the disklabel. */
ccdgetdisklabel(dev, cs, cs->sc_dkdev.dk_label, 0);
ccdunlock(cs);
 1139                 break;
 1141         case CCDIOCCLR:
 1142                 if ((error = ccdlock(cs)) != 0)
 1143                         return (error);
 1145                 /*
 1146                  * Don't unconfigure if any other partitions are open
 1147                  * or if both the character and block flavors of this
 1148                  * partition are open.
 1149                  */
part = DISKPART(dev);
pmask = (1 << part);
 1152                 if ((cs->sc_dkdev.dk_openmask & ~pmask) ||
 1153                     ((cs->sc_dkdev.dk_bopenmask & pmask) &&
 1154                     (cs->sc_dkdev.dk_copenmask & pmask))) {
ccdunlock(cs);
 1156                         return (EBUSY);
 1157                 }
 1159                 /*
 1160                  * Free ccd_softc information and clear entry.
 1161                  */
 1163                 /* Close the components and free their pathnames. */
 1164                 for (i = 0; i < cs->sc_nccdisks; ++i) {
 1165                         /*
 1166                          * XXX: this close could potentially fail and
 1167                          * cause Bad Things.  Maybe we need to force
 1168                          * the close to happen?
 1169                          */
 1170 #ifdef DIAGNOSTIC
CCD_DCALL(CCDB_VNODE, vprint("CCDIOCCLR: vnode info",
cs->sc_cinfo[i].ci_vp));
 1173 #endif
 1175                         (void)vn_close(cs->sc_cinfo[i].ci_vp, FREAD|FWRITE,
p->p_ucred, p);
free(cs->sc_cinfo[i].ci_path, M_DEVBUF);
 1178                 }
 1180                 /* Free interleave index. */
 1181                 for (i = 0; cs->sc_itable[i].ii_ndisk; ++i)
free(cs->sc_itable[i].ii_index, M_DEVBUF);
 1184                 /* Free component info and interleave table. */
free(cs->sc_cinfo, M_DEVBUF);
free(cs->sc_itable, M_DEVBUF);
cs->sc_flags &= ~CCDF_INITED;
 1189                 /*
 1190                  * Free ccddevice information and clear entry.
 1191                  */
free(ccddevs[unit].ccd_cpp, M_DEVBUF);
free(ccddevs[unit].ccd_vpp, M_DEVBUF);
bcopy(&ccd, &ccddevs[unit], sizeof(ccd));
 1196                 /* Detatch the disk. */
disk_detach(&cs->sc_dkdev);
 1199                 /* This must be atomic. */
s = splhigh();
ccdunlock(cs);
bzero(cs, sizeof(struct ccd_softc));
splx(s);
 1204                 break;
 1206         case DIOCGPDINFO:
 1207                 if ((error = ccdlock(cs)) != 0)
 1208                         return (error);
ccdgetdisklabel(dev, cs, (struct disklabel *)data, 1);
ccdunlock(cs);
 1213                 break;
 1215         case DIOCGDINFO:
 1216                 *(struct disklabel *)data = *(cs->sc_dkdev.dk_label);
 1217                 break;
 1219         case DIOCGPART:
 1220                 ((struct partinfo *)data)->disklab = cs->sc_dkdev.dk_label;
 1221                 ((struct partinfo *)data)->part =
 1222                     &cs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
 1223                 break;
 1225         case DIOCWDINFO:
 1226         case DIOCSDINFO:
 1227                 if ((error = ccdlock(cs)) != 0)
 1228                         return (error);
cs->sc_flags |= CCDF_LABELLING;
error = setdisklabel(cs->sc_dkdev.dk_label,
 1233                     (struct disklabel *)data, 0);
 1234                 if (error == 0) {
 1235                         if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
ccdstrategy, cs->sc_dkdev.dk_label);
 1238                 }
cs->sc_flags &= ~CCDF_LABELLING;
ccdunlock(cs);
 1244                 if (error)
 1245                         return (error);
 1246                 break;
 1248         case DIOCWLABEL:
 1249                 if (*(int *)data != 0)
cs->sc_flags |= CCDF_WLABEL;
 1251                 else
cs->sc_flags &= ~CCDF_WLABEL;
 1253                 break;
 1255         default:
 1256                 return (ENOTTY);
 1257         }
 1259         return (0);
 1260 }
daddr64_t
ccdsize(dev_t dev)
 1264 {
 1265         struct ccd_softc *cs;
 1266         int part, unit;
daddr64_t size;
unit = DISKUNIT(dev);
 1270         if (unit >= numccd)
 1271                 return (-1);
cs = &ccd_softc[unit];
 1274         if ((cs->sc_flags & CCDF_INITED) == 0)
 1275                 return (-1);
 1277         if (ccdopen(dev, 0, S_IFBLK, curproc))
 1278                 return (-1);
part = DISKPART(dev);
 1281         if (cs->sc_dkdev.dk_label->d_partitions[part].p_fstype != FS_SWAP)
size = -1;
 1283         else
size = DL_GETPSIZE(&cs->sc_dkdev.dk_label->d_partitions[part]);
 1286         if (ccdclose(dev, 0, S_IFBLK, curproc))
 1287                 return (-1);
 1289         return (size);
 1290 }
 1292 int
 1293 ccddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
 1294 {
 1296         /* Not implemented. */
 1297         return ENXIO;
 1298 }
 1300 /*
 1301  * Lookup the provided name in the filesystem.  If the file exists,
 1302  * is a valid block device, and isn't being used by anyone else,
 1303  * set *vpp to the file's vnode.
 1304  */
 1305 int
ccdlookup(char *path, struct proc *p, struct vnode **vpp)
 1307 {
 1308         struct nameidata nd;
 1309         struct vnode *vp;
 1310         struct vattr va;
 1311         int error;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, p);
 1314         if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
 1316                     ("ccdlookup: vn_open error = %d\n", error));
 1317                 return (error);
 1318         }
vp = nd.ni_vp;
 1321         if (vp->v_usecount > 1) {
VOP_UNLOCK(vp, 0, p);
 1323                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 1324                 return (EBUSY);
 1325         }
 1327         if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
 1329                     ("ccdlookup: getattr error = %d\n", error));
VOP_UNLOCK(vp, 0, p);
 1331                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 1332                 return (error);
 1333         }
 1335         /* XXX: eventually we should handle VREG, too. */
 1336         if (va.va_type != VBLK) {
VOP_UNLOCK(vp, 0, p);
 1338                 (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
 1339                 return (ENOTBLK);
 1340         }
 1342 #ifdef DIAGNOSTIC
CCD_DCALL(CCDB_VNODE, vprint("ccdlookup: vnode info", vp));
 1344 #endif
VOP_UNLOCK(vp, 0, p);
 1347         *vpp = vp;
 1348         return (0);
 1349 }
 1351 /*
 1352  * Read the disklabel from the ccd.  If one is not present, fake one
 1353  * up.
 1354  */
 1355 void
ccdgetdisklabel(dev_t dev, struct ccd_softc *cs, struct disklabel *lp,
 1357     int spoofonly)
 1358 {
 1359         struct ccdgeom *ccg = &cs->sc_geom;
 1360         char *errstring;
bzero(lp, sizeof(*lp));
DL_SETDSIZE(lp, cs->sc_size);
lp->d_secsize = ccg->ccg_secsize;
lp->d_nsectors = ccg->ccg_nsectors;
lp->d_ntracks = ccg->ccg_ntracks;
lp->d_ncylinders = ccg->ccg_ncylinders;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp->d_rpm = ccg->ccg_rpm;
strncpy(lp->d_typename, "ccd", sizeof(lp->d_typename));
lp->d_type = DTYPE_CCD;
strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp->d_interleave = 1;
lp->d_flags = 0;
lp->d_version = 1;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(cs->sc_dkdev.dk_label);
 1383         /*
 1384          * Call the generic disklabel extraction routine.
 1385          */
errstring = readdisklabel(DISKLABELDEV(dev), ccdstrategy,
cs->sc_dkdev.dk_label, spoofonly);
 1388         /* It's actually extremely common to have unlabeled ccds. */
 1389         if (errstring != NULL)
CCD_DPRINTF(CCDB_LABEL, ("%s: %s\n", cs->sc_xname, errstring));
 1391 }
 1393 #ifdef CCDDEBUG
 1394 void
printiinfo(struct ccdiinfo *ii)
 1396 {
 1397         int ix, i;
 1399         for (ix = 0; ii->ii_ndisk; ix++, ii++) {
printf(" itab[%d]: #dk %d sblk %d soff %d",
ix, ii->ii_ndisk, ii->ii_startblk, ii->ii_startoff);
 1402                 for (i = 0; i < ii->ii_ndisk; i++)
printf(" %d", ii->ii_index[i]);
printf("\n");
 1405         }
 1406 }
 1407 #endif