Annotation of sys/dev/ccd.c, Revision 1.1.1.1
1.1 nbrk 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 $ */
3:
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: */
41:
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: */
79:
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 */
94:
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>
113:
114: #include <dev/ccdvar.h>
115:
116: #ifdef __GNUC__
117: #define INLINE static __inline
118: #else
119: #define INLINE
120: #endif
121:
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 */
131: 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 */
135: u_int sc_nccdisks; /* # of components */
136: u_int sc_nccunits; /* # of components for data */
137: struct rwlock sc_rwlock; /* lock */
138:
139: };
140:
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 */
145:
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
159:
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: };
170:
171: /* called by main() at boot time */
172: void ccdattach(int);
173:
174: /* called by biodone() at interrupt time */
175: void ccdiodone(struct buf *);
176: daddr64_t ccdsize(dev_t);
177:
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);
186: INLINE struct ccdbuf *getccdbuf(void);
187: INLINE void putccdbuf(struct ccdbuf *);
188:
189: #define ccdlock(sc) rw_enter(&sc->sc_rwlock, RW_WRITE|RW_INTR)
190: #define ccdunlock(sc) rw_exit_write(&sc->sc_rwlock)
191:
192: #ifdef CCDDEBUG
193: void printiinfo(struct ccdiinfo *);
194: #endif
195:
196: /* Non-private for the benefit of libkvm. */
197: struct ccd_softc *ccd_softc;
198: struct ccddevice *ccddevs;
199: int numccd = 0;
200:
201: /*
202: * struct ccdbuf allocator
203: */
204: struct pool ccdbufpl;
205:
206: /*
207: * Manage the ccd buffer structures.
208: */
209: INLINE struct ccdbuf *
210: getccdbuf(void)
211: {
212: struct ccdbuf *cbp;
213:
214: if ((cbp = pool_get(&ccdbufpl, PR_WAITOK)))
215: bzero(cbp, sizeof(struct ccdbuf));
216: return (cbp);
217: }
218:
219: INLINE void
220: putccdbuf(struct ccdbuf *cbp)
221: {
222: pool_put(&ccdbufpl, cbp);
223: }
224:
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
230: ccdattach(int num)
231: {
232: int i;
233:
234: if (num <= 0) {
235: #ifdef DIAGNOSTIC
236: panic("ccdattach: count <= 0");
237: #endif
238: return;
239: }
240:
241: ccd_softc = (struct ccd_softc *)malloc(num * sizeof(struct ccd_softc),
242: M_DEVBUF, M_NOWAIT);
243: ccddevs = (struct ccddevice *)malloc(num * sizeof(struct ccddevice),
244: M_DEVBUF, M_NOWAIT);
245: if ((ccd_softc == NULL) || (ccddevs == NULL)) {
246: printf("WARNING: no memory for concatenated disks\n");
247: if (ccd_softc != NULL)
248: free(ccd_softc, M_DEVBUF);
249: if (ccddevs != NULL)
250: free(ccddevs, M_DEVBUF);
251: return;
252: }
253: for (i = 0; i < num; i++) {
254: rw_init(&ccd_softc[i].sc_rwlock, "ccdlock");
255: }
256: numccd = num;
257: bzero(ccd_softc, num * sizeof(struct ccd_softc));
258: bzero(ccddevs, num * sizeof(struct ccddevice));
259:
260: pool_init(&ccdbufpl, sizeof(struct ccdbuf), 0, 0, 0, "ccdbufpl", NULL);
261: pool_setlowat(&ccdbufpl, 16);
262: pool_sethiwat(&ccdbufpl, 1024);
263: }
264:
265: int
266: 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;
270: daddr64_t size;
271: int ix, rpm;
272: struct vnode *vp;
273: struct vattr va;
274: size_t minsize;
275: int maxsecsize;
276: struct partinfo dpart;
277: struct ccdgeom *ccg = &cs->sc_geom;
278: char tmppath[MAXPATHLEN];
279: int error;
280:
281: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT, ("ccdinit: unit %d cflags %b\n",
282: ccd->ccd_unit, ccd->ccd_flags, CCDF_BITS));
283:
284: cs->sc_size = 0;
285: cs->sc_ileave = ccd->ccd_interleave;
286: cs->sc_nccdisks = ccd->ccd_ndev;
287: if (snprintf(cs->sc_xname, sizeof(cs->sc_xname), "ccd%d",
288: ccd->ccd_unit) >= sizeof(cs->sc_xname)) {
289: printf("ccdinit: device name too long.\n");
290: return(ENXIO);
291: }
292:
293: /* Allocate space for the component info. */
294: cs->sc_cinfo = malloc(cs->sc_nccdisks * sizeof(struct ccdcinfo),
295: M_DEVBUF, M_WAITOK);
296: bzero(cs->sc_cinfo, cs->sc_nccdisks * sizeof(struct ccdcinfo));
297:
298: /*
299: * Verify that each component piece exists and record
300: * relevant information about it.
301: */
302: maxsecsize = 0;
303: minsize = 0;
304: rpm = 0;
305: for (ix = 0; ix < cs->sc_nccdisks; ix++) {
306: vp = ccd->ccd_vpp[ix];
307: ci = &cs->sc_cinfo[ix];
308: ci->ci_vp = vp;
309:
310: /*
311: * Copy in the pathname of the component.
312: */
313: bzero(tmppath, sizeof(tmppath)); /* sanity */
314: error = copyinstr(cpaths[ix], tmppath,
315: MAXPATHLEN, &ci->ci_pathlen);
316: if (error) {
317: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
318: ("%s: can't copy path, error = %d\n",
319: cs->sc_xname, error));
320: free(cs->sc_cinfo, M_DEVBUF);
321: return (error);
322: }
323: ci->ci_path = malloc(ci->ci_pathlen, M_DEVBUF, M_WAITOK);
324: bcopy(tmppath, ci->ci_path, ci->ci_pathlen);
325:
326: /*
327: * XXX: Cache the component's dev_t.
328: */
329: if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
330: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
331: ("%s: %s: getattr failed error = %d\n",
332: cs->sc_xname, ci->ci_path, error));
333: free(ci->ci_path, M_DEVBUF);
334: free(cs->sc_cinfo, M_DEVBUF);
335: return (error);
336: }
337: ci->ci_dev = va.va_rdev;
338:
339: /*
340: * Get partition information for the component.
341: */
342: error = VOP_IOCTL(vp, DIOCGPART, (caddr_t)&dpart,
343: FREAD, p->p_ucred, p);
344: if (error) {
345: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
346: ("%s: %s: ioctl failed, error = %d\n",
347: cs->sc_xname, ci->ci_path, error));
348: free(ci->ci_path, M_DEVBUF);
349: free(cs->sc_cinfo, M_DEVBUF);
350: return (error);
351: }
352: if (dpart.part->p_fstype == FS_CCD ||
353: dpart.part->p_fstype == FS_BSDFFS) {
354: maxsecsize =
355: ((dpart.disklab->d_secsize > maxsecsize) ?
356: dpart.disklab->d_secsize : maxsecsize);
357: size = DL_GETPSIZE(dpart.part);
358: } else {
359: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
360: ("%s: %s: incorrect partition type\n",
361: cs->sc_xname, ci->ci_path));
362: free(ci->ci_path, M_DEVBUF);
363: free(cs->sc_cinfo, M_DEVBUF);
364: return (EFTYPE);
365: }
366:
367: /*
368: * Calculate the size, truncating to an interleave
369: * boundary if necessary.
370: */
371: if (cs->sc_ileave > 1)
372: size -= size % cs->sc_ileave;
373:
374: if (size == 0) {
375: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
376: ("%s: %s: size == 0\n", cs->sc_xname, ci->ci_path));
377: free(ci->ci_path, M_DEVBUF);
378: free(cs->sc_cinfo, M_DEVBUF);
379: return (ENODEV);
380: }
381:
382: if (minsize == 0 || size < minsize)
383: minsize = size;
384: ci->ci_size = size;
385: cs->sc_size += size;
386: rpm += dpart.disklab->d_rpm;
387: }
388: ccg->ccg_rpm = rpm / cs->sc_nccdisks;
389:
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))) {
396: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
397: ("%s: interleave must be at least %d\n",
398: cs->sc_xname, (maxsecsize / DEV_BSIZE)));
399: free(ci->ci_path, M_DEVBUF);
400: free(cs->sc_cinfo, M_DEVBUF);
401: return (EINVAL);
402: }
403:
404: /*
405: * Mirroring support requires uniform interleave and
406: * and even number of components.
407: */
408: if (ccd->ccd_flags & CCDF_MIRROR) {
409: ccd->ccd_flags |= CCDF_UNIFORM;
410: if (cs->sc_ileave == 0) {
411: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
412: ("%s: mirroring requires interleave\n",
413: cs->sc_xname));
414: free(ci->ci_path, M_DEVBUF);
415: free(cs->sc_cinfo, M_DEVBUF);
416: return (EINVAL);
417: }
418: if (cs->sc_nccdisks % 2) {
419: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
420: ("%s: mirroring requires even # of components\n",
421: cs->sc_xname));
422: free(ci->ci_path, M_DEVBUF);
423: free(cs->sc_cinfo, M_DEVBUF);
424: return (EINVAL);
425: }
426: }
427:
428: /*
429: * If uniform interleave is desired set all sizes to that of
430: * the smallest component.
431: */
432: ccg->ccg_ntracks = cs->sc_nccunits = cs->sc_nccdisks;
433: if (ccd->ccd_flags & CCDF_UNIFORM) {
434: for (ci = cs->sc_cinfo;
435: ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++)
436: ci->ci_size = minsize;
437:
438: if (ccd->ccd_flags & CCDF_MIRROR)
439: cs->sc_nccunits = ccg->ccg_ntracks /= 2;
440: cs->sc_size = ccg->ccg_ntracks * minsize;
441: }
442:
443: cs->sc_cflags = ccd->ccd_flags; /* So we can find out later... */
444:
445: /*
446: * Construct the interleave table.
447: */
448: ccdinterleave(cs);
449:
450: /*
451: * Create pseudo-geometry based on 1MB cylinders. It's
452: * pretty close.
453: */
454: ccg->ccg_secsize = DEV_BSIZE;
455: ccg->ccg_nsectors = cs->sc_ileave? cs->sc_ileave :
456: 1024 * (1024 / ccg->ccg_secsize);
457: ccg->ccg_ncylinders = cs->sc_size / ccg->ccg_ntracks /
458: ccg->ccg_nsectors;
459:
460: cs->sc_flags |= CCDF_INITED;
461:
462: return (0);
463: }
464:
465: void
466: ccdinterleave(struct ccd_softc *cs)
467: {
468: struct ccdcinfo *ci, *smallci;
469: struct ccdiinfo *ii;
470: daddr64_t bn, lbn;
471: int ix;
472: u_long size;
473:
474: CCD_DPRINTF(CCDB_INIT,
475: ("ccdinterleave(%p): ileave %d\n", cs, cs->sc_ileave));
476:
477: /*
478: * Allocate an interleave table.
479: * Chances are this is too big, but we don't care.
480: */
481: size = (cs->sc_nccdisks + 1) * sizeof(struct ccdiinfo);
482: cs->sc_itable = (struct ccdiinfo *)malloc(size, M_DEVBUF, M_WAITOK);
483: bzero((caddr_t)cs->sc_itable, size);
484:
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) {
490: bn = 0;
491: ii = cs->sc_itable;
492:
493: for (ix = 0; ix < cs->sc_nccdisks; ix++) {
494: /* Allocate space for ii_index. */
495: ii->ii_index = malloc(sizeof(int), M_DEVBUF, M_WAITOK);
496: ii->ii_ndisk = 1;
497: ii->ii_startblk = bn;
498: ii->ii_startoff = 0;
499: ii->ii_index[0] = ix;
500: bn += cs->sc_cinfo[ix].ci_size;
501: ii++;
502: }
503: ii->ii_ndisk = 0;
504:
505: CCD_DCALL(CCDB_INIT, printiinfo(cs->sc_itable));
506: return;
507: }
508:
509: /*
510: * The following isn't fast or pretty; it doesn't have to be.
511: */
512: size = 0;
513: bn = lbn = 0;
514: for (ii = cs->sc_itable; ; ii++) {
515: /* Allocate space for ii_index. */
516: ii->ii_index = malloc((sizeof(int) * cs->sc_nccdisks),
517: M_DEVBUF, M_WAITOK);
518:
519: /*
520: * Locate the smallest of the remaining components
521: */
522: smallci = NULL;
523: for (ci = cs->sc_cinfo;
524: ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++)
525: if (ci->ci_size > size &&
526: (smallci == NULL ||
527: ci->ci_size < smallci->ci_size))
528: smallci = ci;
529:
530: /*
531: * Nobody left, all done
532: */
533: if (smallci == NULL) {
534: ii->ii_ndisk = 0;
535: break;
536: }
537:
538: /*
539: * Record starting logical block and component offset
540: */
541: ii->ii_startblk = bn / cs->sc_ileave;
542: ii->ii_startoff = lbn;
543:
544: /*
545: * Determine how many disks take part in this interleave
546: * and record their indices.
547: */
548: ix = 0;
549: for (ci = cs->sc_cinfo;
550: ci < &cs->sc_cinfo[cs->sc_nccunits]; ci++)
551: if (ci->ci_size >= smallci->ci_size)
552: ii->ii_index[ix++] = ci - cs->sc_cinfo;
553: ii->ii_ndisk = ix;
554: bn += ix * (smallci->ci_size - size);
555: lbn = smallci->ci_size / cs->sc_ileave;
556: size = smallci->ci_size;
557: }
558:
559: CCD_DCALL(CCDB_INIT, printiinfo(cs->sc_itable));
560: }
561:
562: /* ARGSUSED */
563: int
564: 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;
570:
571: CCD_DPRINTF(CCDB_FOLLOW, ("ccdopen(%x, %x)\n", dev, flags));
572:
573: if (unit >= numccd)
574: return (ENXIO);
575: cs = &ccd_softc[unit];
576:
577: if ((error = ccdlock(cs)) != 0)
578: return (error);
579:
580: lp = cs->sc_dkdev.dk_label;
581:
582: part = DISKPART(dev);
583: pmask = (1 << part);
584:
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))
591: ccdgetdisklabel(dev, cs, lp, 0);
592:
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))) {
598: error = ENXIO;
599: goto done;
600: }
601: }
602:
603: /* Prevent our unit from being unconfigured while open. */
604: switch (fmt) {
605: case S_IFCHR:
606: cs->sc_dkdev.dk_copenmask |= pmask;
607: break;
608:
609: case S_IFBLK:
610: cs->sc_dkdev.dk_bopenmask |= pmask;
611: break;
612: }
613: cs->sc_dkdev.dk_openmask =
614: cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask;
615:
616: done:
617: ccdunlock(cs);
618: return (error);
619: }
620:
621: /* ARGSUSED */
622: int
623: 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;
628:
629: CCD_DPRINTF(CCDB_FOLLOW, ("ccdclose(%x, %x)\n", dev, flags));
630:
631: if (unit >= numccd)
632: return (ENXIO);
633: cs = &ccd_softc[unit];
634:
635: if ((error = ccdlock(cs)) != 0)
636: return (error);
637:
638: part = DISKPART(dev);
639:
640: /* ...that much closer to allowing unconfiguration... */
641: switch (fmt) {
642: case S_IFCHR:
643: cs->sc_dkdev.dk_copenmask &= ~(1 << part);
644: break;
645:
646: case S_IFBLK:
647: cs->sc_dkdev.dk_bopenmask &= ~(1 << part);
648: break;
649: }
650: cs->sc_dkdev.dk_openmask =
651: cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask;
652:
653: ccdunlock(cs);
654: return (0);
655: }
656:
657: void
658: 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;
665:
666: CCD_DPRINTF(CCDB_FOLLOW, ("ccdstrategy(%p): unit %d\n", bp, unit));
667:
668: if ((cs->sc_flags & CCDF_INITED) == 0) {
669: bp->b_error = ENXIO;
670: bp->b_resid = bp->b_bcount;
671: bp->b_flags |= B_ERROR;
672: goto done;
673: }
674:
675: /* If it's a nil transfer, wake up the top half now. */
676: if (bp->b_bcount == 0)
677: goto done;
678:
679: lp = cs->sc_dkdev.dk_label;
680:
681: /*
682: * Do bounds checking and adjust transfer. If there's an
683: * error, the bounds check will flag that for us.
684: */
685: wlabel = cs->sc_flags & (CCDF_WLABEL|CCDF_LABELLING);
686: if (DISKPART(bp->b_dev) != RAW_PART &&
687: bounds_check_with_label(bp, lp, wlabel) <= 0)
688: goto done;
689:
690: bp->b_resid = bp->b_bcount;
691:
692: /*
693: * "Start" the unit.
694: */
695: s = splbio();
696: ccdstart(cs, bp);
697: splx(s);
698: return;
699: done:
700: s = splbio();
701: biodone(bp);
702: splx(s);
703: }
704:
705: void
706: ccdstart(struct ccd_softc *cs, struct buf *bp)
707: {
708: long bcount, rcount;
709: struct ccdbuf **cbpp;
710: caddr_t addr;
711: daddr64_t bn;
712: struct partition *pp;
713:
714: CCD_DPRINTF(CCDB_FOLLOW, ("ccdstart(%p, %p, %s)\n", cs, bp,
715: bp->b_flags & B_READ? "read" : "write"));
716:
717: /* Instrumentation. */
718: disk_busy(&cs->sc_dkdev);
719:
720: /*
721: * Translate the partition-relative block number to an absolute.
722: */
723: bn = bp->b_blkno;
724: pp = &cs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
725: bn += DL_GETPOFFSET(pp);
726:
727: /*
728: * Allocate component buffers
729: */
730: cbpp = malloc(2 * cs->sc_nccdisks * sizeof(struct ccdbuf *), M_DEVBUF,
731: M_WAITOK);
732: bzero(cbpp, 2 * cs->sc_nccdisks * sizeof(struct ccdbuf *));
733: addr = bp->b_data;
734: for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
735: rcount = ccdbuffer(cs, bp, bn, addr, bcount, cbpp);
736:
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)
743: cbpp[0]->cb_buf.b_vp->v_numoutput++;
744: VOP_STRATEGY(&cbpp[0]->cb_buf);
745:
746: if ((cs->sc_cflags & CCDF_MIRROR) &&
747: ((cbpp[0]->cb_buf.b_flags & B_READ) == 0)) {
748: cbpp[1]->cb_buf.b_vp->v_numoutput++;
749: VOP_STRATEGY(&cbpp[1]->cb_buf);
750: }
751:
752: bn += btodb(rcount);
753: addr += rcount;
754: }
755:
756: free(cbpp, M_DEVBUF);
757: }
758:
759: /*
760: * Build a component buffer header.
761: */
762: long
763: 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;
768: daddr64_t cbn, cboff, sblk;
769: int ccdisk, ccdisk2, off;
770: long cnt;
771: struct ccdiinfo *ii;
772: struct buf *nbp;
773:
774: CCD_DPRINTF(CCDB_IO, ("ccdbuffer(%p, %p, %d, %p, %ld, %p)\n",
775: cs, bp, bn, addr, bcount, cbpp));
776:
777: /*
778: * Determine which component bn falls in.
779: */
780: cbn = bn;
781: cboff = 0;
782:
783: if (cs->sc_ileave == 0) {
784: /*
785: * Serially concatenated
786: */
787: sblk = 0;
788: for (ccdisk = 0, ci = &cs->sc_cinfo[ccdisk];
789: cbn >= sblk + ci->ci_size;
790: ccdisk++, ci = &cs->sc_cinfo[ccdisk])
791: sblk += ci->ci_size;
792: cbn -= sblk;
793: } else {
794: /*
795: * Interleaved
796: */
797: cboff = cbn % cs->sc_ileave;
798: cbn /= cs->sc_ileave;
799: for (ii = cs->sc_itable; ii->ii_ndisk; ii++)
800: if (ii->ii_startblk > cbn)
801: break;
802: ii--;
803: off = cbn - ii->ii_startblk;
804: if (ii->ii_ndisk == 1) {
805: ccdisk = ii->ii_index[0];
806: cbn = ii->ii_startoff + off;
807: } else {
808: ccdisk = ii->ii_index[off % ii->ii_ndisk];
809: cbn = ii->ii_startoff + off / ii->ii_ndisk;
810: }
811: if (cs->sc_cflags & CCDF_MIRROR) {
812: /* Mirrored data */
813: ccdisk2 = ccdisk + ii->ii_ndisk;
814: ci2 = &cs->sc_cinfo[ccdisk2];
815: /* spread the read over both parts */
816: if (bp->b_flags & B_READ &&
817: bcount > bp->b_bcount / 2 &&
818: (!(ci2->ci_flags & CCIF_FAILED) ||
819: ci->ci_flags & CCIF_FAILED))
820: ccdisk = ccdisk2;
821: }
822: cbn *= cs->sc_ileave;
823: ci = &cs->sc_cinfo[ccdisk];
824: CCD_DPRINTF(CCDB_IO, ("ccdisk %d cbn %d ci %p ci2 %p\n",
825: ccdisk, cbn, ci, ci2));
826: }
827:
828: /* Limit the operation at next component border */
829: if (cs->sc_ileave == 0)
830: cnt = dbtob(ci->ci_size - cbn);
831: else
832: cnt = dbtob(cs->sc_ileave - cboff);
833: if (cnt < bcount)
834: bcount = cnt;
835:
836: /*
837: * Setup new component buffer.
838: */
839: cbp = cbpp[0] = getccdbuf();
840: cbp->cb_flags = 0;
841: nbp = &cbp->cb_buf;
842: nbp->b_flags = bp->b_flags | B_CALL;
843: nbp->b_iodone = ccdiodone;
844: nbp->b_proc = bp->b_proc;
845: nbp->b_dev = ci->ci_dev; /* XXX */
846: nbp->b_blkno = cbn + cboff;
847: nbp->b_vp = ci->ci_vp;
848: nbp->b_bcount = bcount;
849: LIST_INIT(&nbp->b_dep);
850: nbp->b_data = addr;
851:
852: /*
853: * context for ccdiodone
854: */
855: cbp->cb_obp = bp;
856: cbp->cb_sc = cs;
857: cbp->cb_comp = ccdisk;
858:
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;
867: cbpp[1] = cbp2 = getccdbuf();
868: *cbp2 = *cbp;
869: cbp2->cb_flags = CBF_MIRROR;
870: cbp2->cb_buf.b_dev = ci2->ci_dev; /* XXX */
871: cbp2->cb_buf.b_vp = ci2->ci_vp;
872: LIST_INIT(&cbp2->cb_buf.b_dep);
873: cbp2->cb_comp = ccdisk2;
874: cbp2->cb_dep = cbp;
875: cbp->cb_dep = cbp2;
876: }
877:
878: CCD_DPRINTF(CCDB_IO, (" dev %x(u%d): cbp %p bn %d addr %p bcnt %ld\n",
879: ci->ci_dev, ci-cs->sc_cinfo, cbp, bp->b_blkno,
880: bp->b_data, bp->b_bcount));
881:
882: return (bcount);
883: }
884:
885: void
886: ccdintr(struct ccd_softc *cs, struct buf *bp)
887: {
888:
889: splassert(IPL_BIO);
890:
891: CCD_DPRINTF(CCDB_FOLLOW, ("ccdintr(%p, %p)\n", cs, bp));
892:
893: /*
894: * Request is done for better or worse, wakeup the top half.
895: */
896: if (bp->b_flags & B_ERROR)
897: bp->b_resid = bp->b_bcount;
898: disk_unbusy(&cs->sc_dkdev, (bp->b_bcount - bp->b_resid),
899: (bp->b_flags & B_READ));
900: biodone(bp);
901: }
902:
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
909: 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;
916:
917: splassert(IPL_BIO);
918:
919: CCD_DPRINTF(CCDB_FOLLOW, ("ccdiodone(%p)\n", cbp));
920: CCD_DPRINTF(CCDB_IO, (cbp->cb_flags & CBF_MIRROR?
921: "ccdiodone: mirror component\n" :
922: "ccdiodone: bp %p bcount %ld resid %ld\n",
923: bp, bp->b_bcount, bp->b_resid));
924: CCD_DPRINTF(CCDB_IO, (" dev %x(u%d), cbp %p bn %d addr %p bcnt %ld\n",
925: vbp->b_dev, cbp->cb_comp, cbp, vbp->b_blkno,
926: vbp->b_data, vbp->b_bcount));
927:
928: if (vbp->b_flags & B_ERROR) {
929: cs->sc_cinfo[cbp->cb_comp].ci_flags |= CCIF_FAILED;
930: if (cbp->cb_flags & CBF_MIRROR)
931: comptype = " (mirror)";
932: else {
933: bp->b_flags |= B_ERROR;
934: bp->b_error = vbp->b_error ?
935: vbp->b_error : EIO;
936: comptype = "";
937: }
938:
939: printf("%s: error %d on component %d%s\n",
940: cs->sc_xname, bp->b_error, cbp->cb_comp, comptype);
941: }
942: cbp->cb_flags |= CBF_DONE;
943:
944: if (cbp->cb_dep &&
945: (cbp->cb_dep->cb_flags & CBF_DONE) != (cbp->cb_flags & CBF_DONE))
946: return;
947:
948: if (cbp->cb_flags & CBF_MIRROR &&
949: !(cbp->cb_dep->cb_flags & CBF_MIRROR)) {
950: cbp = cbp->cb_dep;
951: vbp = (struct buf *)cbp;
952: }
953:
954: count = vbp->b_bcount;
955:
956: putccdbuf(cbp);
957: if (cbp->cb_dep)
958: putccdbuf(cbp->cb_dep);
959:
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)
967: panic("ccdiodone: count");
968: bp->b_resid -= count;
969: if (bp->b_resid == 0)
970: ccdintr(cs, bp);
971: }
972:
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;
979:
980: CCD_DPRINTF(CCDB_FOLLOW, ("ccdread(%x, %p)\n", dev, uio));
981:
982: if (unit >= numccd)
983: return (ENXIO);
984: cs = &ccd_softc[unit];
985:
986: if ((cs->sc_flags & CCDF_INITED) == 0)
987: return (ENXIO);
988:
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: }
996:
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;
1003:
1004: CCD_DPRINTF(CCDB_FOLLOW, ("ccdwrite(%x, %p)\n", dev, uio));
1005:
1006: if (unit >= numccd)
1007: return (ENXIO);
1008: cs = &ccd_softc[unit];
1009:
1010: if ((cs->sc_flags & CCDF_INITED) == 0)
1011: return (ENXIO);
1012:
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: }
1020:
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;
1032:
1033: if (unit >= numccd)
1034: return (ENXIO);
1035:
1036: cs = &ccd_softc[unit];
1037: if (cmd != CCDIOCSET && !(cs->sc_flags & CCDF_INITED))
1038: return (ENXIO);
1039:
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: }
1050:
1051: bzero(&ccd, sizeof(ccd));
1052: switch (cmd) {
1053: case CCDIOCSET:
1054: if (cs->sc_flags & CCDF_INITED)
1055: return (EBUSY);
1056:
1057: if (ccio->ccio_ndisks == 0 || ccio->ccio_ndisks > INT_MAX ||
1058: ccio->ccio_ileave < 0)
1059: return (EINVAL);
1060:
1061: if ((error = ccdlock(cs)) != 0)
1062: return (error);
1063:
1064: /* Fill in some important bits. */
1065: ccd.ccd_unit = unit;
1066: ccd.ccd_interleave = ccio->ccio_ileave;
1067: ccd.ccd_flags = ccio->ccio_flags & CCDF_USERMASK;
1068:
1069: /*
1070: * Allocate space for and copy in the array of
1071: * componet pathnames and device numbers.
1072: */
1073: cpp = malloc(ccio->ccio_ndisks * sizeof(char *),
1074: M_DEVBUF, M_WAITOK);
1075: vpp = malloc(ccio->ccio_ndisks * sizeof(struct vnode *),
1076: M_DEVBUF, M_WAITOK);
1077:
1078: error = copyin((caddr_t)ccio->ccio_disks, (caddr_t)cpp,
1079: ccio->ccio_ndisks * sizeof(char **));
1080: if (error) {
1081: free(vpp, M_DEVBUF);
1082: free(cpp, M_DEVBUF);
1083: ccdunlock(cs);
1084: return (error);
1085: }
1086:
1087: for (i = 0; i < ccio->ccio_ndisks; ++i) {
1088: CCD_DPRINTF(CCDB_INIT,
1089: ("ccdioctl: component %d: %p, lookedup = %d\n",
1090: 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,
1094: p->p_ucred, p);
1095: free(vpp, M_DEVBUF);
1096: free(cpp, M_DEVBUF);
1097: ccdunlock(cs);
1098: return (error);
1099: }
1100: ++lookedup;
1101: }
1102: ccd.ccd_cpp = cpp;
1103: ccd.ccd_vpp = vpp;
1104: ccd.ccd_ndev = ccio->ccio_ndisks;
1105:
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,
1112: p->p_ucred, p);
1113: bzero(&ccd_softc[unit], sizeof(struct ccd_softc));
1114: free(vpp, M_DEVBUF);
1115: free(cpp, M_DEVBUF);
1116: ccdunlock(cs);
1117: return (error);
1118: }
1119:
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: */
1127: bcopy(&ccd, &ccddevs[unit], sizeof(ccd));
1128: ccio->ccio_unit = unit;
1129: ccio->ccio_size = cs->sc_size;
1130:
1131: /* Attach the disk. */
1132: cs->sc_dkdev.dk_name = cs->sc_xname;
1133: disk_attach(&cs->sc_dkdev);
1134:
1135: /* Try and read the disklabel. */
1136: ccdgetdisklabel(dev, cs, cs->sc_dkdev.dk_label, 0);
1137:
1138: ccdunlock(cs);
1139: break;
1140:
1141: case CCDIOCCLR:
1142: if ((error = ccdlock(cs)) != 0)
1143: return (error);
1144:
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: */
1150: part = DISKPART(dev);
1151: 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))) {
1155: ccdunlock(cs);
1156: return (EBUSY);
1157: }
1158:
1159: /*
1160: * Free ccd_softc information and clear entry.
1161: */
1162:
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
1171: CCD_DCALL(CCDB_VNODE, vprint("CCDIOCCLR: vnode info",
1172: cs->sc_cinfo[i].ci_vp));
1173: #endif
1174:
1175: (void)vn_close(cs->sc_cinfo[i].ci_vp, FREAD|FWRITE,
1176: p->p_ucred, p);
1177: free(cs->sc_cinfo[i].ci_path, M_DEVBUF);
1178: }
1179:
1180: /* Free interleave index. */
1181: for (i = 0; cs->sc_itable[i].ii_ndisk; ++i)
1182: free(cs->sc_itable[i].ii_index, M_DEVBUF);
1183:
1184: /* Free component info and interleave table. */
1185: free(cs->sc_cinfo, M_DEVBUF);
1186: free(cs->sc_itable, M_DEVBUF);
1187: cs->sc_flags &= ~CCDF_INITED;
1188:
1189: /*
1190: * Free ccddevice information and clear entry.
1191: */
1192: free(ccddevs[unit].ccd_cpp, M_DEVBUF);
1193: free(ccddevs[unit].ccd_vpp, M_DEVBUF);
1194: bcopy(&ccd, &ccddevs[unit], sizeof(ccd));
1195:
1196: /* Detatch the disk. */
1197: disk_detach(&cs->sc_dkdev);
1198:
1199: /* This must be atomic. */
1200: s = splhigh();
1201: ccdunlock(cs);
1202: bzero(cs, sizeof(struct ccd_softc));
1203: splx(s);
1204: break;
1205:
1206: case DIOCGPDINFO:
1207: if ((error = ccdlock(cs)) != 0)
1208: return (error);
1209:
1210: ccdgetdisklabel(dev, cs, (struct disklabel *)data, 1);
1211:
1212: ccdunlock(cs);
1213: break;
1214:
1215: case DIOCGDINFO:
1216: *(struct disklabel *)data = *(cs->sc_dkdev.dk_label);
1217: break;
1218:
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;
1224:
1225: case DIOCWDINFO:
1226: case DIOCSDINFO:
1227: if ((error = ccdlock(cs)) != 0)
1228: return (error);
1229:
1230: cs->sc_flags |= CCDF_LABELLING;
1231:
1232: error = setdisklabel(cs->sc_dkdev.dk_label,
1233: (struct disklabel *)data, 0);
1234: if (error == 0) {
1235: if (cmd == DIOCWDINFO)
1236: error = writedisklabel(DISKLABELDEV(dev),
1237: ccdstrategy, cs->sc_dkdev.dk_label);
1238: }
1239:
1240: cs->sc_flags &= ~CCDF_LABELLING;
1241:
1242: ccdunlock(cs);
1243:
1244: if (error)
1245: return (error);
1246: break;
1247:
1248: case DIOCWLABEL:
1249: if (*(int *)data != 0)
1250: cs->sc_flags |= CCDF_WLABEL;
1251: else
1252: cs->sc_flags &= ~CCDF_WLABEL;
1253: break;
1254:
1255: default:
1256: return (ENOTTY);
1257: }
1258:
1259: return (0);
1260: }
1261:
1262: daddr64_t
1263: ccdsize(dev_t dev)
1264: {
1265: struct ccd_softc *cs;
1266: int part, unit;
1267: daddr64_t size;
1268:
1269: unit = DISKUNIT(dev);
1270: if (unit >= numccd)
1271: return (-1);
1272:
1273: cs = &ccd_softc[unit];
1274: if ((cs->sc_flags & CCDF_INITED) == 0)
1275: return (-1);
1276:
1277: if (ccdopen(dev, 0, S_IFBLK, curproc))
1278: return (-1);
1279:
1280: part = DISKPART(dev);
1281: if (cs->sc_dkdev.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1282: size = -1;
1283: else
1284: size = DL_GETPSIZE(&cs->sc_dkdev.dk_label->d_partitions[part]);
1285:
1286: if (ccdclose(dev, 0, S_IFBLK, curproc))
1287: return (-1);
1288:
1289: return (size);
1290: }
1291:
1292: int
1293: ccddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
1294: {
1295:
1296: /* Not implemented. */
1297: return ENXIO;
1298: }
1299:
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
1306: 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;
1312:
1313: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, p);
1314: if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
1315: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
1316: ("ccdlookup: vn_open error = %d\n", error));
1317: return (error);
1318: }
1319: vp = nd.ni_vp;
1320:
1321: if (vp->v_usecount > 1) {
1322: VOP_UNLOCK(vp, 0, p);
1323: (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
1324: return (EBUSY);
1325: }
1326:
1327: if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
1328: CCD_DPRINTF(CCDB_FOLLOW | CCDB_INIT,
1329: ("ccdlookup: getattr error = %d\n", error));
1330: VOP_UNLOCK(vp, 0, p);
1331: (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
1332: return (error);
1333: }
1334:
1335: /* XXX: eventually we should handle VREG, too. */
1336: if (va.va_type != VBLK) {
1337: VOP_UNLOCK(vp, 0, p);
1338: (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
1339: return (ENOTBLK);
1340: }
1341:
1342: #ifdef DIAGNOSTIC
1343: CCD_DCALL(CCDB_VNODE, vprint("ccdlookup: vnode info", vp));
1344: #endif
1345:
1346: VOP_UNLOCK(vp, 0, p);
1347: *vpp = vp;
1348: return (0);
1349: }
1350:
1351: /*
1352: * Read the disklabel from the ccd. If one is not present, fake one
1353: * up.
1354: */
1355: void
1356: 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;
1361:
1362: bzero(lp, sizeof(*lp));
1363:
1364: DL_SETDSIZE(lp, cs->sc_size);
1365: lp->d_secsize = ccg->ccg_secsize;
1366: lp->d_nsectors = ccg->ccg_nsectors;
1367: lp->d_ntracks = ccg->ccg_ntracks;
1368: lp->d_ncylinders = ccg->ccg_ncylinders;
1369: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
1370: lp->d_rpm = ccg->ccg_rpm;
1371:
1372: strncpy(lp->d_typename, "ccd", sizeof(lp->d_typename));
1373: lp->d_type = DTYPE_CCD;
1374: strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
1375: lp->d_interleave = 1;
1376: lp->d_flags = 0;
1377: lp->d_version = 1;
1378:
1379: lp->d_magic = DISKMAGIC;
1380: lp->d_magic2 = DISKMAGIC;
1381: lp->d_checksum = dkcksum(cs->sc_dkdev.dk_label);
1382:
1383: /*
1384: * Call the generic disklabel extraction routine.
1385: */
1386: errstring = readdisklabel(DISKLABELDEV(dev), ccdstrategy,
1387: cs->sc_dkdev.dk_label, spoofonly);
1388: /* It's actually extremely common to have unlabeled ccds. */
1389: if (errstring != NULL)
1390: CCD_DPRINTF(CCDB_LABEL, ("%s: %s\n", cs->sc_xname, errstring));
1391: }
1392:
1393: #ifdef CCDDEBUG
1394: void
1395: printiinfo(struct ccdiinfo *ii)
1396: {
1397: int ix, i;
1398:
1399: for (ix = 0; ii->ii_ndisk; ix++, ii++) {
1400: printf(" itab[%d]: #dk %d sblk %d soff %d",
1401: ix, ii->ii_ndisk, ii->ii_startblk, ii->ii_startoff);
1402: for (i = 0; i < ii->ii_ndisk; i++)
1403: printf(" %d", ii->ii_index[i]);
1404: printf("\n");
1405: }
1406: }
1407: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ccd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev