ccd.c revision 1.126
1 /* $NetBSD: ccd.c,v 1.126 2008/01/02 11:48:36 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 1997, 1998, 1999, 2007 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Copyright (c) 1990, 1993 41 * The Regents of the University of California. All rights reserved. 42 * 43 * This code is derived from software contributed to Berkeley by 44 * the Systems Programming Group of the University of Utah Computer 45 * Science Department. 46 * 47 * Redistribution and use in source and binary forms, with or without 48 * modification, are permitted provided that the following conditions 49 * are met: 50 * 1. Redistributions of source code must retain the above copyright 51 * notice, this list of conditions and the following disclaimer. 52 * 2. Redistributions in binary form must reproduce the above copyright 53 * notice, this list of conditions and the following disclaimer in the 54 * documentation and/or other materials provided with the distribution. 55 * 3. Neither the name of the University nor the names of its contributors 56 * may be used to endorse or promote products derived from this software 57 * without specific prior written permission. 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 69 * SUCH DAMAGE. 70 * 71 * from: Utah $Hdr: cd.c 1.6 90/11/28$ 72 * 73 * @(#)cd.c 8.2 (Berkeley) 11/16/93 74 */ 75 76 /* 77 * Copyright (c) 1988 University of Utah. 78 * 79 * This code is derived from software contributed to Berkeley by 80 * the Systems Programming Group of the University of Utah Computer 81 * Science Department. 82 * 83 * Redistribution and use in source and binary forms, with or without 84 * modification, are permitted provided that the following conditions 85 * are met: 86 * 1. Redistributions of source code must retain the above copyright 87 * notice, this list of conditions and the following disclaimer. 88 * 2. Redistributions in binary form must reproduce the above copyright 89 * notice, this list of conditions and the following disclaimer in the 90 * documentation and/or other materials provided with the distribution. 91 * 3. All advertising materials mentioning features or use of this software 92 * must display the following acknowledgement: 93 * This product includes software developed by the University of 94 * California, Berkeley and its contributors. 95 * 4. Neither the name of the University nor the names of its contributors 96 * may be used to endorse or promote products derived from this software 97 * without specific prior written permission. 98 * 99 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 100 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 101 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 102 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 103 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 104 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 105 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 106 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 107 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 108 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 109 * SUCH DAMAGE. 110 * 111 * from: Utah $Hdr: cd.c 1.6 90/11/28$ 112 * 113 * @(#)cd.c 8.2 (Berkeley) 11/16/93 114 */ 115 116 /* 117 * "Concatenated" disk driver. 118 * 119 * Dynamic configuration and disklabel support by: 120 * Jason R. Thorpe <thorpej (at) nas.nasa.gov> 121 * Numerical Aerodynamic Simulation Facility 122 * Mail Stop 258-6 123 * NASA Ames Research Center 124 * Moffett Field, CA 94035 125 */ 126 127 #include <sys/cdefs.h> 128 __KERNEL_RCSID(0, "$NetBSD: ccd.c,v 1.126 2008/01/02 11:48:36 ad Exp $"); 129 130 #include <sys/param.h> 131 #include <sys/systm.h> 132 #include <sys/proc.h> 133 #include <sys/errno.h> 134 #include <sys/buf.h> 135 #include <sys/bufq.h> 136 #include <sys/malloc.h> 137 #include <sys/pool.h> 138 #include <sys/namei.h> 139 #include <sys/stat.h> 140 #include <sys/ioctl.h> 141 #include <sys/disklabel.h> 142 #include <sys/device.h> 143 #include <sys/disk.h> 144 #include <sys/syslog.h> 145 #include <sys/fcntl.h> 146 #include <sys/vnode.h> 147 #include <sys/conf.h> 148 #include <sys/mutex.h> 149 #include <sys/queue.h> 150 #include <sys/kauth.h> 151 152 #include <dev/ccdvar.h> 153 #include <dev/dkvar.h> 154 155 #if defined(CCDDEBUG) && !defined(DEBUG) 156 #define DEBUG 157 #endif 158 159 #ifdef DEBUG 160 #define CCDB_FOLLOW 0x01 161 #define CCDB_INIT 0x02 162 #define CCDB_IO 0x04 163 #define CCDB_LABEL 0x08 164 #define CCDB_VNODE 0x10 165 int ccddebug = 0x00; 166 #endif 167 168 #define ccdunit(x) DISKUNIT(x) 169 170 struct ccdbuf { 171 struct buf cb_buf; /* new I/O buf */ 172 struct buf *cb_obp; /* ptr. to original I/O buf */ 173 struct ccd_softc *cb_sc; /* pointer to ccd softc */ 174 int cb_comp; /* target component */ 175 SIMPLEQ_ENTRY(ccdbuf) cb_q; /* fifo of component buffers */ 176 }; 177 178 /* component buffer pool */ 179 static struct pool ccd_cbufpool; 180 181 #define CCD_GETBUF() pool_get(&ccd_cbufpool, PR_NOWAIT) 182 #define CCD_PUTBUF(cbp) pool_put(&ccd_cbufpool, cbp) 183 184 #define CCDLABELDEV(dev) \ 185 (MAKEDISKDEV(major((dev)), ccdunit((dev)), RAW_PART)) 186 187 /* called by main() at boot time */ 188 void ccdattach(int); 189 190 /* called by biodone() at interrupt time */ 191 static void ccdiodone(struct buf *); 192 193 static void ccdstart(struct ccd_softc *); 194 static void ccdinterleave(struct ccd_softc *); 195 static void ccdintr(struct ccd_softc *, struct buf *); 196 static int ccdinit(struct ccd_softc *, char **, struct vnode **, 197 struct lwp *); 198 static struct ccdbuf *ccdbuffer(struct ccd_softc *, struct buf *, 199 daddr_t, void *, long); 200 static void ccdgetdefaultlabel(struct ccd_softc *, struct disklabel *); 201 static void ccdgetdisklabel(dev_t); 202 static void ccdmakedisklabel(struct ccd_softc *); 203 204 static dev_type_open(ccdopen); 205 static dev_type_close(ccdclose); 206 static dev_type_read(ccdread); 207 static dev_type_write(ccdwrite); 208 static dev_type_ioctl(ccdioctl); 209 static dev_type_strategy(ccdstrategy); 210 static dev_type_dump(ccddump); 211 static dev_type_size(ccdsize); 212 213 const struct bdevsw ccd_bdevsw = { 214 ccdopen, ccdclose, ccdstrategy, ccdioctl, ccddump, ccdsize, D_DISK 215 }; 216 217 const struct cdevsw ccd_cdevsw = { 218 ccdopen, ccdclose, ccdread, ccdwrite, ccdioctl, 219 nostop, notty, nopoll, nommap, nokqfilter, D_DISK 220 }; 221 222 #ifdef DEBUG 223 static void printiinfo(struct ccdiinfo *); 224 #endif 225 226 /* Publically visible for the benefit of libkvm and ccdconfig(8). */ 227 struct ccd_softc *ccd_softc; 228 const int ccd_softc_elemsize = sizeof(struct ccd_softc); 229 int numccd = 0; 230 231 /* 232 * Called by main() during pseudo-device attachment. All we need 233 * to do is allocate enough space for devices to be configured later. 234 */ 235 void 236 ccdattach(int num) 237 { 238 struct ccd_softc *cs; 239 int i; 240 241 if (num <= 0) { 242 #ifdef DIAGNOSTIC 243 panic("ccdattach: count <= 0"); 244 #endif 245 return; 246 } 247 248 ccd_softc = (struct ccd_softc *)malloc(num * ccd_softc_elemsize, 249 M_DEVBUF, M_NOWAIT|M_ZERO); 250 if (ccd_softc == NULL) { 251 printf("WARNING: no memory for concatenated disks\n"); 252 return; 253 } 254 numccd = num; 255 256 /* Initialize the component buffer pool. */ 257 pool_init(&ccd_cbufpool, sizeof(struct ccdbuf), 0, 258 0, 0, "ccdpl", NULL, IPL_BIO); 259 260 /* Initialize per-softc structures. */ 261 for (i = 0; i < num; i++) { 262 cs = &ccd_softc[i]; 263 snprintf(cs->sc_xname, sizeof(cs->sc_xname), "ccd%d", i); 264 mutex_init(&cs->sc_lock, MUTEX_DEFAULT, IPL_NONE); 265 disk_init(&cs->sc_dkdev, cs->sc_xname, NULL); /* XXX */ 266 } 267 } 268 269 static int 270 ccdinit(struct ccd_softc *cs, char **cpaths, struct vnode **vpp, 271 struct lwp *l) 272 { 273 struct ccdcinfo *ci = NULL; 274 size_t size; 275 int ix; 276 struct vattr va; 277 size_t minsize; 278 int maxsecsize; 279 struct partinfo dpart; 280 struct ccdgeom *ccg = &cs->sc_geom; 281 char *tmppath; 282 int error, path_alloced; 283 284 #ifdef DEBUG 285 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 286 printf("%s: ccdinit\n", cs->sc_xname); 287 #endif 288 289 /* Allocate space for the component info. */ 290 cs->sc_cinfo = malloc(cs->sc_nccdisks * sizeof(struct ccdcinfo), 291 M_DEVBUF, M_WAITOK); 292 293 tmppath = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 294 295 cs->sc_size = 0; 296 297 /* 298 * Verify that each component piece exists and record 299 * relevant information about it. 300 */ 301 maxsecsize = 0; 302 minsize = 0; 303 for (ix = 0, path_alloced = 0; ix < cs->sc_nccdisks; ix++) { 304 ci = &cs->sc_cinfo[ix]; 305 ci->ci_vp = vpp[ix]; 306 307 /* 308 * Copy in the pathname of the component. 309 */ 310 memset(tmppath, 0, sizeof(tmppath)); /* sanity */ 311 error = copyinstr(cpaths[ix], tmppath, 312 MAXPATHLEN, &ci->ci_pathlen); 313 if (error) { 314 #ifdef DEBUG 315 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 316 printf("%s: can't copy path, error = %d\n", 317 cs->sc_xname, error); 318 #endif 319 goto out; 320 } 321 ci->ci_path = malloc(ci->ci_pathlen, M_DEVBUF, M_WAITOK); 322 memcpy(ci->ci_path, tmppath, ci->ci_pathlen); 323 path_alloced++; 324 325 /* 326 * XXX: Cache the component's dev_t. 327 */ 328 if ((error = VOP_GETATTR(vpp[ix], &va, l->l_cred)) != 0) { 329 #ifdef DEBUG 330 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 331 printf("%s: %s: getattr failed %s = %d\n", 332 cs->sc_xname, ci->ci_path, 333 "error", error); 334 #endif 335 goto out; 336 } 337 ci->ci_dev = va.va_rdev; 338 339 /* 340 * Get partition information for the component. 341 */ 342 error = VOP_IOCTL(vpp[ix], DIOCGPART, &dpart, 343 FREAD, l->l_cred); 344 if (error) { 345 #ifdef DEBUG 346 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 347 printf("%s: %s: ioctl failed, error = %d\n", 348 cs->sc_xname, ci->ci_path, error); 349 #endif 350 goto out; 351 } 352 353 /* 354 * This diagnostic test is disabled (for now?) since not all port supports 355 * on-disk BSD disklabel. 356 */ 357 #if 0 /* def DIAGNOSTIC */ 358 /* Check fstype field of component. */ 359 if (dpart.part->p_fstype != FS_CCD) 360 printf("%s: WARNING: %s: fstype %d != FS_CCD\n", 361 cs->sc_xname, ci->ci_path, dpart.part->p_fstype); 362 #endif 363 364 /* 365 * Calculate the size, truncating to an interleave 366 * boundary if necessary. 367 */ 368 maxsecsize = 369 ((dpart.disklab->d_secsize > maxsecsize) ? 370 dpart.disklab->d_secsize : maxsecsize); 371 size = dpart.part->p_size; 372 if (cs->sc_ileave > 1) 373 size -= size % cs->sc_ileave; 374 375 if (size == 0) { 376 #ifdef DEBUG 377 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 378 printf("%s: %s: size == 0\n", 379 cs->sc_xname, ci->ci_path); 380 #endif 381 error = ENODEV; 382 goto out; 383 } 384 385 if (minsize == 0 || size < minsize) 386 minsize = size; 387 ci->ci_size = size; 388 cs->sc_size += size; 389 } 390 391 /* 392 * Don't allow the interleave to be smaller than 393 * the biggest component sector. 394 */ 395 if ((cs->sc_ileave > 0) && 396 (cs->sc_ileave < (maxsecsize / DEV_BSIZE))) { 397 #ifdef DEBUG 398 if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) 399 printf("%s: interleave must be at least %d\n", 400 cs->sc_xname, (maxsecsize / DEV_BSIZE)); 401 #endif 402 error = EINVAL; 403 goto out; 404 } 405 406 /* 407 * If uniform interleave is desired set all sizes to that of 408 * the smallest component. 409 */ 410 if (cs->sc_flags & CCDF_UNIFORM) { 411 for (ci = cs->sc_cinfo; 412 ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++) 413 ci->ci_size = minsize; 414 415 cs->sc_size = cs->sc_nccdisks * minsize; 416 } 417 418 /* 419 * Construct the interleave table. 420 */ 421 ccdinterleave(cs); 422 423 /* 424 * Create pseudo-geometry based on 1MB cylinders. It's 425 * pretty close. 426 */ 427 ccg->ccg_secsize = DEV_BSIZE; 428 ccg->ccg_ntracks = 1; 429 ccg->ccg_nsectors = 1024 * (1024 / ccg->ccg_secsize); 430 ccg->ccg_ncylinders = cs->sc_size / ccg->ccg_nsectors; 431 432 cs->sc_flags |= CCDF_INITED; 433 434 free(tmppath, M_TEMP); 435 436 return (0); 437 438 out: 439 for (ix = 0; ix < path_alloced; ix++) 440 free(cs->sc_cinfo[ix].ci_path, M_DEVBUF); 441 free(cs->sc_cinfo, M_DEVBUF); 442 free(tmppath, M_TEMP); 443 return (error); 444 } 445 446 static void 447 ccdinterleave(struct ccd_softc *cs) 448 { 449 struct ccdcinfo *ci, *smallci; 450 struct ccdiinfo *ii; 451 daddr_t bn, lbn; 452 int ix; 453 u_long size; 454 455 #ifdef DEBUG 456 if (ccddebug & CCDB_INIT) 457 printf("ccdinterleave(%p): ileave %d\n", cs, cs->sc_ileave); 458 #endif 459 /* 460 * Allocate an interleave table. 461 * Chances are this is too big, but we don't care. 462 */ 463 size = (cs->sc_nccdisks + 1) * sizeof(struct ccdiinfo); 464 cs->sc_itable = (struct ccdiinfo *)malloc(size, M_DEVBUF, 465 M_WAITOK|M_ZERO); 466 467 /* 468 * Trivial case: no interleave (actually interleave of disk size). 469 * Each table entry represents a single component in its entirety. 470 */ 471 if (cs->sc_ileave == 0) { 472 bn = 0; 473 ii = cs->sc_itable; 474 475 for (ix = 0; ix < cs->sc_nccdisks; ix++) { 476 /* Allocate space for ii_index. */ 477 ii->ii_index = malloc(sizeof(int), M_DEVBUF, M_WAITOK); 478 ii->ii_ndisk = 1; 479 ii->ii_startblk = bn; 480 ii->ii_startoff = 0; 481 ii->ii_index[0] = ix; 482 bn += cs->sc_cinfo[ix].ci_size; 483 ii++; 484 } 485 ii->ii_ndisk = 0; 486 #ifdef DEBUG 487 if (ccddebug & CCDB_INIT) 488 printiinfo(cs->sc_itable); 489 #endif 490 return; 491 } 492 493 /* 494 * The following isn't fast or pretty; it doesn't have to be. 495 */ 496 size = 0; 497 bn = lbn = 0; 498 for (ii = cs->sc_itable; ; ii++) { 499 /* Allocate space for ii_index. */ 500 ii->ii_index = malloc((sizeof(int) * cs->sc_nccdisks), 501 M_DEVBUF, M_WAITOK); 502 503 /* 504 * Locate the smallest of the remaining components 505 */ 506 smallci = NULL; 507 for (ci = cs->sc_cinfo; 508 ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++) 509 if (ci->ci_size > size && 510 (smallci == NULL || 511 ci->ci_size < smallci->ci_size)) 512 smallci = ci; 513 514 /* 515 * Nobody left, all done 516 */ 517 if (smallci == NULL) { 518 ii->ii_ndisk = 0; 519 break; 520 } 521 522 /* 523 * Record starting logical block and component offset 524 */ 525 ii->ii_startblk = bn / cs->sc_ileave; 526 ii->ii_startoff = lbn; 527 528 /* 529 * Determine how many disks take part in this interleave 530 * and record their indices. 531 */ 532 ix = 0; 533 for (ci = cs->sc_cinfo; 534 ci < &cs->sc_cinfo[cs->sc_nccdisks]; ci++) 535 if (ci->ci_size >= smallci->ci_size) 536 ii->ii_index[ix++] = ci - cs->sc_cinfo; 537 ii->ii_ndisk = ix; 538 bn += ix * (smallci->ci_size - size); 539 lbn = smallci->ci_size / cs->sc_ileave; 540 size = smallci->ci_size; 541 } 542 #ifdef DEBUG 543 if (ccddebug & CCDB_INIT) 544 printiinfo(cs->sc_itable); 545 #endif 546 } 547 548 /* ARGSUSED */ 549 static int 550 ccdopen(dev_t dev, int flags, int fmt, struct lwp *l) 551 { 552 int unit = ccdunit(dev); 553 struct ccd_softc *cs; 554 struct disklabel *lp; 555 int error = 0, part, pmask; 556 557 #ifdef DEBUG 558 if (ccddebug & CCDB_FOLLOW) 559 printf("ccdopen(0x%x, 0x%x)\n", dev, flags); 560 #endif 561 if (unit >= numccd) 562 return (ENXIO); 563 cs = &ccd_softc[unit]; 564 565 mutex_enter(&cs->sc_lock); 566 567 lp = cs->sc_dkdev.dk_label; 568 569 part = DISKPART(dev); 570 pmask = (1 << part); 571 572 /* 573 * If we're initialized, check to see if there are any other 574 * open partitions. If not, then it's safe to update 575 * the in-core disklabel. Only read the disklabel if it is 576 * not already valid. 577 */ 578 if ((cs->sc_flags & (CCDF_INITED|CCDF_VLABEL)) == CCDF_INITED && 579 cs->sc_dkdev.dk_openmask == 0) 580 ccdgetdisklabel(dev); 581 582 /* Check that the partition exists. */ 583 if (part != RAW_PART) { 584 if (((cs->sc_flags & CCDF_INITED) == 0) || 585 ((part >= lp->d_npartitions) || 586 (lp->d_partitions[part].p_fstype == FS_UNUSED))) { 587 error = ENXIO; 588 goto done; 589 } 590 } 591 592 /* Prevent our unit from being unconfigured while open. */ 593 switch (fmt) { 594 case S_IFCHR: 595 cs->sc_dkdev.dk_copenmask |= pmask; 596 break; 597 598 case S_IFBLK: 599 cs->sc_dkdev.dk_bopenmask |= pmask; 600 break; 601 } 602 cs->sc_dkdev.dk_openmask = 603 cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask; 604 605 done: 606 mutex_exit(&cs->sc_lock); 607 return (error); 608 } 609 610 /* ARGSUSED */ 611 static int 612 ccdclose(dev_t dev, int flags, int fmt, struct lwp *l) 613 { 614 int unit = ccdunit(dev); 615 struct ccd_softc *cs; 616 int part; 617 618 #ifdef DEBUG 619 if (ccddebug & CCDB_FOLLOW) 620 printf("ccdclose(0x%x, 0x%x)\n", dev, flags); 621 #endif 622 623 if (unit >= numccd) 624 return (ENXIO); 625 cs = &ccd_softc[unit]; 626 627 mutex_enter(&cs->sc_lock); 628 629 part = DISKPART(dev); 630 631 /* ...that much closer to allowing unconfiguration... */ 632 switch (fmt) { 633 case S_IFCHR: 634 cs->sc_dkdev.dk_copenmask &= ~(1 << part); 635 break; 636 637 case S_IFBLK: 638 cs->sc_dkdev.dk_bopenmask &= ~(1 << part); 639 break; 640 } 641 cs->sc_dkdev.dk_openmask = 642 cs->sc_dkdev.dk_copenmask | cs->sc_dkdev.dk_bopenmask; 643 644 if (cs->sc_dkdev.dk_openmask == 0) { 645 if ((cs->sc_flags & CCDF_KLABEL) == 0) 646 cs->sc_flags &= ~CCDF_VLABEL; 647 } 648 649 mutex_exit(&cs->sc_lock); 650 return (0); 651 } 652 653 static void 654 ccdstrategy(struct buf *bp) 655 { 656 int unit = ccdunit(bp->b_dev); 657 struct ccd_softc *cs = &ccd_softc[unit]; 658 daddr_t blkno; 659 int s; 660 int wlabel; 661 struct disklabel *lp; 662 663 #ifdef DEBUG 664 if (ccddebug & CCDB_FOLLOW) 665 printf("ccdstrategy(%p): unit %d\n", bp, unit); 666 #endif 667 if ((cs->sc_flags & CCDF_INITED) == 0) { 668 #ifdef DEBUG 669 if (ccddebug & CCDB_FOLLOW) 670 printf("ccdstrategy: unit %d: not inited\n", unit); 671 #endif 672 bp->b_error = ENXIO; 673 goto done; 674 } 675 676 /* If it's a nil transfer, wake up the top half now. */ 677 if (bp->b_bcount == 0) 678 goto done; 679 680 lp = cs->sc_dkdev.dk_label; 681 682 /* 683 * Do bounds checking and adjust transfer. If there's an 684 * error, the bounds check will flag that for us. Convert 685 * the partition relative block number to an absolute. 686 */ 687 blkno = bp->b_blkno; 688 wlabel = cs->sc_flags & (CCDF_WLABEL|CCDF_LABELLING); 689 if (DISKPART(bp->b_dev) != RAW_PART) { 690 if (bounds_check_with_label(&cs->sc_dkdev, bp, wlabel) <= 0) 691 goto done; 692 blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset; 693 } 694 bp->b_rawblkno = blkno; 695 696 /* Place it in the queue and start I/O on the unit. */ 697 s = splbio(); 698 BUFQ_PUT(cs->sc_bufq, bp); 699 ccdstart(cs); 700 splx(s); 701 return; 702 703 done: 704 bp->b_resid = bp->b_bcount; 705 biodone(bp); 706 } 707 708 static void 709 ccdstart(struct ccd_softc *cs) 710 { 711 long bcount, rcount; 712 struct buf *bp; 713 struct ccdbuf *cbp; 714 char *addr; 715 daddr_t bn; 716 SIMPLEQ_HEAD(, ccdbuf) cbufq; 717 718 #ifdef DEBUG 719 if (ccddebug & CCDB_FOLLOW) 720 printf("ccdstart(%p)\n", cs); 721 #endif 722 723 /* See if there is work for us to do. */ 724 while ((bp = BUFQ_PEEK(cs->sc_bufq)) != NULL) { 725 /* Instrumentation. */ 726 disk_busy(&cs->sc_dkdev); 727 728 bp->b_resid = bp->b_bcount; 729 bn = bp->b_rawblkno; 730 731 /* Allocate the component buffers. */ 732 SIMPLEQ_INIT(&cbufq); 733 addr = bp->b_data; 734 for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) { 735 cbp = ccdbuffer(cs, bp, bn, addr, bcount); 736 if (cbp == NULL) { 737 /* 738 * Can't allocate a component buffer; just 739 * defer the job until later. 740 * 741 * XXX We might consider a watchdog timer 742 * XXX to make sure we are kicked into action, 743 * XXX or consider a low-water mark for our 744 * XXX component buffer pool. 745 */ 746 while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { 747 SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); 748 CCD_PUTBUF(cbp); 749 } 750 disk_unbusy(&cs->sc_dkdev, 0, 0); 751 return; 752 } 753 SIMPLEQ_INSERT_TAIL(&cbufq, cbp, cb_q); 754 rcount = cbp->cb_buf.b_bcount; 755 bn += btodb(rcount); 756 addr += rcount; 757 } 758 759 /* Transfer all set up, remove job from the queue. */ 760 (void) BUFQ_GET(cs->sc_bufq); 761 762 /* Now fire off the requests. */ 763 while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { 764 SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); 765 if ((cbp->cb_buf.b_flags & B_READ) == 0) 766 cbp->cb_buf.b_vp->v_numoutput++; 767 bdev_strategy(&cbp->cb_buf); 768 } 769 } 770 } 771 772 /* 773 * Build a component buffer header. 774 */ 775 static struct ccdbuf * 776 ccdbuffer(struct ccd_softc *cs, struct buf *bp, daddr_t bn, void *addr, 777 long bcount) 778 { 779 struct ccdcinfo *ci; 780 struct ccdbuf *cbp; 781 daddr_t cbn, cboff; 782 u_int64_t cbc; 783 int ccdisk; 784 785 #ifdef DEBUG 786 if (ccddebug & CCDB_IO) 787 printf("ccdbuffer(%p, %p, %" PRId64 ", %p, %ld)\n", 788 cs, bp, bn, addr, bcount); 789 #endif 790 /* 791 * Determine which component bn falls in. 792 */ 793 cbn = bn; 794 cboff = 0; 795 796 /* 797 * Serially concatenated 798 */ 799 if (cs->sc_ileave == 0) { 800 daddr_t sblk; 801 802 sblk = 0; 803 for (ccdisk = 0, ci = &cs->sc_cinfo[ccdisk]; 804 cbn >= sblk + ci->ci_size; 805 ccdisk++, ci = &cs->sc_cinfo[ccdisk]) 806 sblk += ci->ci_size; 807 cbn -= sblk; 808 } 809 /* 810 * Interleaved 811 */ 812 else { 813 struct ccdiinfo *ii; 814 int off; 815 816 cboff = cbn % cs->sc_ileave; 817 cbn /= cs->sc_ileave; 818 for (ii = cs->sc_itable; ii->ii_ndisk; ii++) 819 if (ii->ii_startblk > cbn) 820 break; 821 ii--; 822 off = cbn - ii->ii_startblk; 823 if (ii->ii_ndisk == 1) { 824 ccdisk = ii->ii_index[0]; 825 cbn = ii->ii_startoff + off; 826 } else { 827 ccdisk = ii->ii_index[off % ii->ii_ndisk]; 828 cbn = ii->ii_startoff + off / ii->ii_ndisk; 829 } 830 cbn *= cs->sc_ileave; 831 ci = &cs->sc_cinfo[ccdisk]; 832 } 833 834 /* 835 * Fill in the component buf structure. 836 */ 837 cbp = CCD_GETBUF(); 838 if (cbp == NULL) 839 return (NULL); 840 buf_init(&cbp->cb_buf); 841 cbp->cb_buf.b_flags = bp->b_flags; 842 cbp->cb_buf.b_oflags = bp->b_oflags; 843 cbp->cb_buf.b_cflags = bp->b_cflags; 844 cbp->cb_buf.b_iodone = ccdiodone; 845 cbp->cb_buf.b_proc = bp->b_proc; 846 cbp->cb_buf.b_dev = ci->ci_dev; 847 cbp->cb_buf.b_blkno = cbn + cboff; 848 cbp->cb_buf.b_data = addr; 849 cbp->cb_buf.b_vp = ci->ci_vp; 850 if (cs->sc_ileave == 0) 851 cbc = dbtob((u_int64_t)(ci->ci_size - cbn)); 852 else 853 cbc = dbtob((u_int64_t)(cs->sc_ileave - cboff)); 854 cbp->cb_buf.b_bcount = cbc < bcount ? cbc : bcount; 855 856 /* 857 * context for ccdiodone 858 */ 859 cbp->cb_obp = bp; 860 cbp->cb_sc = cs; 861 cbp->cb_comp = ccdisk; 862 863 BIO_COPYPRIO(&cbp->cb_buf, bp); 864 865 #ifdef DEBUG 866 if (ccddebug & CCDB_IO) 867 printf(" dev 0x%x(u%lu): cbp %p bn %" PRId64 " addr %p" 868 " bcnt %d\n", 869 ci->ci_dev, (unsigned long) (ci-cs->sc_cinfo), cbp, 870 cbp->cb_buf.b_blkno, cbp->cb_buf.b_data, 871 cbp->cb_buf.b_bcount); 872 #endif 873 874 return (cbp); 875 } 876 877 static void 878 ccdintr(struct ccd_softc *cs, struct buf *bp) 879 { 880 881 #ifdef DEBUG 882 if (ccddebug & CCDB_FOLLOW) 883 printf("ccdintr(%p, %p)\n", cs, bp); 884 #endif 885 /* 886 * Request is done for better or worse, wakeup the top half. 887 */ 888 if (bp->b_error != 0) 889 bp->b_resid = bp->b_bcount; 890 disk_unbusy(&cs->sc_dkdev, (bp->b_bcount - bp->b_resid), 891 (bp->b_flags & B_READ)); 892 biodone(bp); 893 } 894 895 /* 896 * Called at interrupt time. 897 * Mark the component as done and if all components are done, 898 * take a ccd interrupt. 899 */ 900 static void 901 ccdiodone(struct buf *vbp) 902 { 903 struct ccdbuf *cbp = (struct ccdbuf *) vbp; 904 struct buf *bp = cbp->cb_obp; 905 struct ccd_softc *cs = cbp->cb_sc; 906 int count, s; 907 908 s = splbio(); 909 #ifdef DEBUG 910 if (ccddebug & CCDB_FOLLOW) 911 printf("ccdiodone(%p)\n", cbp); 912 if (ccddebug & CCDB_IO) { 913 printf("ccdiodone: bp %p bcount %d resid %d\n", 914 bp, bp->b_bcount, bp->b_resid); 915 printf(" dev 0x%x(u%d), cbp %p bn %" PRId64 " addr %p" 916 " bcnt %d\n", 917 cbp->cb_buf.b_dev, cbp->cb_comp, cbp, 918 cbp->cb_buf.b_blkno, cbp->cb_buf.b_data, 919 cbp->cb_buf.b_bcount); 920 } 921 #endif 922 923 if (cbp->cb_buf.b_error != 0) { 924 bp->b_error = cbp->cb_buf.b_error; 925 printf("%s: error %d on component %d\n", 926 cs->sc_xname, bp->b_error, cbp->cb_comp); 927 } 928 count = cbp->cb_buf.b_bcount; 929 buf_destroy(&cbp->cb_buf); 930 CCD_PUTBUF(cbp); 931 932 /* 933 * If all done, "interrupt". 934 */ 935 bp->b_resid -= count; 936 if (bp->b_resid < 0) 937 panic("ccdiodone: count"); 938 if (bp->b_resid == 0) 939 ccdintr(cs, bp); 940 splx(s); 941 } 942 943 /* ARGSUSED */ 944 static int 945 ccdread(dev_t dev, struct uio *uio, int flags) 946 { 947 int unit = ccdunit(dev); 948 struct ccd_softc *cs; 949 950 #ifdef DEBUG 951 if (ccddebug & CCDB_FOLLOW) 952 printf("ccdread(0x%x, %p)\n", dev, uio); 953 #endif 954 if (unit >= numccd) 955 return (ENXIO); 956 cs = &ccd_softc[unit]; 957 958 if ((cs->sc_flags & CCDF_INITED) == 0) 959 return (ENXIO); 960 961 return (physio(ccdstrategy, NULL, dev, B_READ, minphys, uio)); 962 } 963 964 /* ARGSUSED */ 965 static int 966 ccdwrite(dev_t dev, struct uio *uio, int flags) 967 { 968 int unit = ccdunit(dev); 969 struct ccd_softc *cs; 970 971 #ifdef DEBUG 972 if (ccddebug & CCDB_FOLLOW) 973 printf("ccdwrite(0x%x, %p)\n", dev, uio); 974 #endif 975 if (unit >= numccd) 976 return (ENXIO); 977 cs = &ccd_softc[unit]; 978 979 if ((cs->sc_flags & CCDF_INITED) == 0) 980 return (ENXIO); 981 982 return (physio(ccdstrategy, NULL, dev, B_WRITE, minphys, uio)); 983 } 984 985 static int 986 ccdioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 987 { 988 int unit = ccdunit(dev); 989 int s, i, j, lookedup = 0, error = 0; 990 int part, pmask; 991 struct ccd_softc *cs; 992 struct ccd_ioctl *ccio = (struct ccd_ioctl *)data; 993 kauth_cred_t uc; 994 char **cpp; 995 struct vnode **vpp; 996 #ifdef __HAVE_OLD_DISKLABEL 997 struct disklabel newlabel; 998 #endif 999 1000 if (unit >= numccd) 1001 return (ENXIO); 1002 cs = &ccd_softc[unit]; 1003 1004 uc = (l != NULL) ? l->l_cred : NOCRED; 1005 1006 /* Must be open for writes for these commands... */ 1007 switch (cmd) { 1008 case CCDIOCSET: 1009 case CCDIOCCLR: 1010 case DIOCSDINFO: 1011 case DIOCWDINFO: 1012 #ifdef __HAVE_OLD_DISKLABEL 1013 case ODIOCSDINFO: 1014 case ODIOCWDINFO: 1015 #endif 1016 case DIOCKLABEL: 1017 case DIOCWLABEL: 1018 if ((flag & FWRITE) == 0) 1019 return (EBADF); 1020 } 1021 1022 mutex_enter(&cs->sc_lock); 1023 1024 /* Must be initialized for these... */ 1025 switch (cmd) { 1026 case CCDIOCCLR: 1027 case DIOCGDINFO: 1028 case DIOCCACHESYNC: 1029 case DIOCSDINFO: 1030 case DIOCWDINFO: 1031 case DIOCGPART: 1032 case DIOCWLABEL: 1033 case DIOCKLABEL: 1034 case DIOCGDEFLABEL: 1035 #ifdef __HAVE_OLD_DISKLABEL 1036 case ODIOCGDINFO: 1037 case ODIOCSDINFO: 1038 case ODIOCWDINFO: 1039 case ODIOCGDEFLABEL: 1040 #endif 1041 if ((cs->sc_flags & CCDF_INITED) == 0) { 1042 error = ENXIO; 1043 goto out; 1044 } 1045 } 1046 1047 switch (cmd) { 1048 case CCDIOCSET: 1049 if (cs->sc_flags & CCDF_INITED) { 1050 error = EBUSY; 1051 goto out; 1052 } 1053 1054 /* Validate the flags. */ 1055 if ((ccio->ccio_flags & CCDF_USERMASK) != ccio->ccio_flags) { 1056 error = EINVAL; 1057 goto out; 1058 } 1059 1060 if (ccio->ccio_ndisks > CCD_MAXNDISKS) { 1061 error = EINVAL; 1062 goto out; 1063 } 1064 1065 /* Fill in some important bits. */ 1066 cs->sc_ileave = ccio->ccio_ileave; 1067 cs->sc_nccdisks = ccio->ccio_ndisks; 1068 cs->sc_flags = ccio->ccio_flags & CCDF_USERMASK; 1069 1070 /* 1071 * Allocate space for and copy in the array of 1072 * componet pathnames and device numbers. 1073 */ 1074 cpp = malloc(ccio->ccio_ndisks * sizeof(char *), 1075 M_DEVBUF, M_WAITOK); 1076 vpp = malloc(ccio->ccio_ndisks * sizeof(struct vnode *), 1077 M_DEVBUF, M_WAITOK); 1078 1079 error = copyin(ccio->ccio_disks, cpp, 1080 ccio->ccio_ndisks * sizeof(char **)); 1081 if (error) { 1082 free(vpp, M_DEVBUF); 1083 free(cpp, M_DEVBUF); 1084 goto out; 1085 } 1086 1087 #ifdef DEBUG 1088 if (ccddebug & CCDB_INIT) 1089 for (i = 0; i < ccio->ccio_ndisks; ++i) 1090 printf("ccdioctl: component %d: %p\n", 1091 i, cpp[i]); 1092 #endif 1093 1094 for (i = 0; i < ccio->ccio_ndisks; ++i) { 1095 #ifdef DEBUG 1096 if (ccddebug & CCDB_INIT) 1097 printf("ccdioctl: lookedup = %d\n", lookedup); 1098 #endif 1099 if ((error = dk_lookup(cpp[i], l, &vpp[i], 1100 UIO_USERSPACE)) != 0) { 1101 for (j = 0; j < lookedup; ++j) 1102 (void)vn_close(vpp[j], FREAD|FWRITE, 1103 uc, l); 1104 free(vpp, M_DEVBUF); 1105 free(cpp, M_DEVBUF); 1106 goto out; 1107 } 1108 ++lookedup; 1109 } 1110 1111 /* 1112 * Initialize the ccd. Fills in the softc for us. 1113 */ 1114 if ((error = ccdinit(cs, cpp, vpp, l)) != 0) { 1115 for (j = 0; j < lookedup; ++j) 1116 (void)vn_close(vpp[j], FREAD|FWRITE, 1117 uc, l); 1118 free(vpp, M_DEVBUF); 1119 free(cpp, M_DEVBUF); 1120 goto out; 1121 } 1122 1123 /* We can free the temporary variables now. */ 1124 free(vpp, M_DEVBUF); 1125 free(cpp, M_DEVBUF); 1126 1127 /* 1128 * The ccd has been successfully initialized, so 1129 * we can place it into the array. Don't try to 1130 * read the disklabel until the disk has been attached, 1131 * because space for the disklabel is allocated 1132 * in disk_attach(); 1133 */ 1134 ccio->ccio_unit = unit; 1135 ccio->ccio_size = cs->sc_size; 1136 1137 bufq_alloc(&cs->sc_bufq, "fcfs", 0); 1138 1139 /* Attach the disk. */ 1140 disk_attach(&cs->sc_dkdev); 1141 1142 /* Try and read the disklabel. */ 1143 ccdgetdisklabel(dev); 1144 break; 1145 1146 case CCDIOCCLR: 1147 /* 1148 * Don't unconfigure if any other partitions are open 1149 * or if both the character and block flavors of this 1150 * partition are open. 1151 */ 1152 part = DISKPART(dev); 1153 pmask = (1 << part); 1154 if ((cs->sc_dkdev.dk_openmask & ~pmask) || 1155 ((cs->sc_dkdev.dk_bopenmask & pmask) && 1156 (cs->sc_dkdev.dk_copenmask & pmask))) { 1157 error = EBUSY; 1158 goto out; 1159 } 1160 1161 /* Kill off any queued buffers. */ 1162 s = splbio(); 1163 bufq_drain(cs->sc_bufq); 1164 splx(s); 1165 1166 bufq_free(cs->sc_bufq); 1167 1168 /* 1169 * Free ccd_softc information and clear entry. 1170 */ 1171 1172 /* Close the components and free their pathnames. */ 1173 for (i = 0; i < cs->sc_nccdisks; ++i) { 1174 /* 1175 * XXX: this close could potentially fail and 1176 * cause Bad Things. Maybe we need to force 1177 * the close to happen? 1178 */ 1179 #ifdef DEBUG 1180 if (ccddebug & CCDB_VNODE) 1181 vprint("CCDIOCCLR: vnode info", 1182 cs->sc_cinfo[i].ci_vp); 1183 #endif 1184 (void)vn_close(cs->sc_cinfo[i].ci_vp, FREAD|FWRITE, 1185 uc, l); 1186 free(cs->sc_cinfo[i].ci_path, M_DEVBUF); 1187 } 1188 1189 /* Free interleave index. */ 1190 for (i = 0; cs->sc_itable[i].ii_ndisk; ++i) 1191 free(cs->sc_itable[i].ii_index, M_DEVBUF); 1192 1193 /* Free component info and interleave table. */ 1194 free(cs->sc_cinfo, M_DEVBUF); 1195 free(cs->sc_itable, M_DEVBUF); 1196 cs->sc_flags &= ~(CCDF_INITED|CCDF_VLABEL); 1197 1198 /* Detatch the disk. */ 1199 disk_detach(&cs->sc_dkdev); 1200 break; 1201 1202 case DIOCGDINFO: 1203 *(struct disklabel *)data = *(cs->sc_dkdev.dk_label); 1204 break; 1205 #ifdef __HAVE_OLD_DISKLABEL 1206 case ODIOCGDINFO: 1207 newlabel = *(cs->sc_dkdev.dk_label); 1208 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 1209 return ENOTTY; 1210 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 1211 break; 1212 #endif 1213 1214 case DIOCGPART: 1215 ((struct partinfo *)data)->disklab = cs->sc_dkdev.dk_label; 1216 ((struct partinfo *)data)->part = 1217 &cs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)]; 1218 break; 1219 1220 case DIOCCACHESYNC: 1221 /* 1222 * XXX Do we really need to care about having a writable 1223 * file descriptor here? 1224 */ 1225 if ((flag & FWRITE) == 0) 1226 return (EBADF); 1227 1228 /* 1229 * We pass this call down to all components and report 1230 * the first error we encounter. 1231 */ 1232 for (error = 0, i = 0; i < cs->sc_nccdisks; i++) { 1233 j = VOP_IOCTL(cs->sc_cinfo[i].ci_vp, cmd, data, 1234 flag, uc); 1235 if (j != 0 && error == 0) 1236 error = j; 1237 } 1238 break; 1239 1240 case DIOCWDINFO: 1241 case DIOCSDINFO: 1242 #ifdef __HAVE_OLD_DISKLABEL 1243 case ODIOCWDINFO: 1244 case ODIOCSDINFO: 1245 #endif 1246 { 1247 struct disklabel *lp; 1248 #ifdef __HAVE_OLD_DISKLABEL 1249 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 1250 memset(&newlabel, 0, sizeof newlabel); 1251 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 1252 lp = &newlabel; 1253 } else 1254 #endif 1255 lp = (struct disklabel *)data; 1256 1257 cs->sc_flags |= CCDF_LABELLING; 1258 1259 error = setdisklabel(cs->sc_dkdev.dk_label, 1260 lp, 0, cs->sc_dkdev.dk_cpulabel); 1261 if (error == 0) { 1262 if (cmd == DIOCWDINFO 1263 #ifdef __HAVE_OLD_DISKLABEL 1264 || cmd == ODIOCWDINFO 1265 #endif 1266 ) 1267 error = writedisklabel(CCDLABELDEV(dev), 1268 ccdstrategy, cs->sc_dkdev.dk_label, 1269 cs->sc_dkdev.dk_cpulabel); 1270 } 1271 1272 cs->sc_flags &= ~CCDF_LABELLING; 1273 break; 1274 } 1275 1276 case DIOCKLABEL: 1277 if (*(int *)data != 0) 1278 cs->sc_flags |= CCDF_KLABEL; 1279 else 1280 cs->sc_flags &= ~CCDF_KLABEL; 1281 break; 1282 1283 case DIOCWLABEL: 1284 if (*(int *)data != 0) 1285 cs->sc_flags |= CCDF_WLABEL; 1286 else 1287 cs->sc_flags &= ~CCDF_WLABEL; 1288 break; 1289 1290 case DIOCGDEFLABEL: 1291 ccdgetdefaultlabel(cs, (struct disklabel *)data); 1292 break; 1293 1294 #ifdef __HAVE_OLD_DISKLABEL 1295 case ODIOCGDEFLABEL: 1296 ccdgetdefaultlabel(cs, &newlabel); 1297 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 1298 return ENOTTY; 1299 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 1300 break; 1301 #endif 1302 1303 default: 1304 error = ENOTTY; 1305 } 1306 1307 out: 1308 mutex_exit(&cs->sc_lock); 1309 return (error); 1310 } 1311 1312 static int 1313 ccdsize(dev_t dev) 1314 { 1315 struct ccd_softc *cs; 1316 struct disklabel *lp; 1317 int part, unit, omask, size; 1318 1319 unit = ccdunit(dev); 1320 if (unit >= numccd) 1321 return (-1); 1322 cs = &ccd_softc[unit]; 1323 1324 if ((cs->sc_flags & CCDF_INITED) == 0) 1325 return (-1); 1326 1327 part = DISKPART(dev); 1328 omask = cs->sc_dkdev.dk_openmask & (1 << part); 1329 lp = cs->sc_dkdev.dk_label; 1330 1331 if (omask == 0 && ccdopen(dev, 0, S_IFBLK, curlwp)) 1332 return (-1); 1333 1334 if (lp->d_partitions[part].p_fstype != FS_SWAP) 1335 size = -1; 1336 else 1337 size = lp->d_partitions[part].p_size * 1338 (lp->d_secsize / DEV_BSIZE); 1339 1340 if (omask == 0 && ccdclose(dev, 0, S_IFBLK, curlwp)) 1341 return (-1); 1342 1343 return (size); 1344 } 1345 1346 static int 1347 ccddump(dev_t dev, daddr_t blkno, void *va, 1348 size_t size) 1349 { 1350 1351 /* Not implemented. */ 1352 return ENXIO; 1353 } 1354 1355 static void 1356 ccdgetdefaultlabel(struct ccd_softc *cs, struct disklabel *lp) 1357 { 1358 struct ccdgeom *ccg = &cs->sc_geom; 1359 1360 memset(lp, 0, sizeof(*lp)); 1361 1362 lp->d_secperunit = cs->sc_size; 1363 lp->d_secsize = ccg->ccg_secsize; 1364 lp->d_nsectors = ccg->ccg_nsectors; 1365 lp->d_ntracks = ccg->ccg_ntracks; 1366 lp->d_ncylinders = ccg->ccg_ncylinders; 1367 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1368 1369 strncpy(lp->d_typename, "ccd", sizeof(lp->d_typename)); 1370 lp->d_type = DTYPE_CCD; 1371 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 1372 lp->d_rpm = 3600; 1373 lp->d_interleave = 1; 1374 lp->d_flags = 0; 1375 1376 lp->d_partitions[RAW_PART].p_offset = 0; 1377 lp->d_partitions[RAW_PART].p_size = cs->sc_size; 1378 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 1379 lp->d_npartitions = RAW_PART + 1; 1380 1381 lp->d_magic = DISKMAGIC; 1382 lp->d_magic2 = DISKMAGIC; 1383 lp->d_checksum = dkcksum(cs->sc_dkdev.dk_label); 1384 } 1385 1386 /* 1387 * Read the disklabel from the ccd. If one is not present, fake one 1388 * up. 1389 */ 1390 static void 1391 ccdgetdisklabel(dev_t dev) 1392 { 1393 int unit = ccdunit(dev); 1394 struct ccd_softc *cs = &ccd_softc[unit]; 1395 const char *errstring; 1396 struct disklabel *lp = cs->sc_dkdev.dk_label; 1397 struct cpu_disklabel *clp = cs->sc_dkdev.dk_cpulabel; 1398 1399 memset(clp, 0, sizeof(*clp)); 1400 1401 ccdgetdefaultlabel(cs, lp); 1402 1403 /* 1404 * Call the generic disklabel extraction routine. 1405 */ 1406 if ((cs->sc_flags & CCDF_NOLABEL) != 0) 1407 errstring = "CCDF_NOLABEL set; ignoring on-disk label"; 1408 else 1409 errstring = readdisklabel(CCDLABELDEV(dev), ccdstrategy, 1410 cs->sc_dkdev.dk_label, cs->sc_dkdev.dk_cpulabel); 1411 if (errstring) 1412 ccdmakedisklabel(cs); 1413 else { 1414 int i; 1415 struct partition *pp; 1416 1417 /* 1418 * Sanity check whether the found disklabel is valid. 1419 * 1420 * This is necessary since total size of ccd may vary 1421 * when an interleave is changed even though exactly 1422 * same componets are used, and old disklabel may used 1423 * if that is found. 1424 */ 1425 if (lp->d_secperunit != cs->sc_size) 1426 printf("WARNING: %s: " 1427 "total sector size in disklabel (%d) != " 1428 "the size of ccd (%lu)\n", cs->sc_xname, 1429 lp->d_secperunit, (u_long)cs->sc_size); 1430 for (i = 0; i < lp->d_npartitions; i++) { 1431 pp = &lp->d_partitions[i]; 1432 if (pp->p_offset + pp->p_size > cs->sc_size) 1433 printf("WARNING: %s: end of partition `%c' " 1434 "exceeds the size of ccd (%lu)\n", 1435 cs->sc_xname, 'a' + i, (u_long)cs->sc_size); 1436 } 1437 } 1438 1439 #ifdef DEBUG 1440 /* It's actually extremely common to have unlabeled ccds. */ 1441 if (ccddebug & CCDB_LABEL) 1442 if (errstring != NULL) 1443 printf("%s: %s\n", cs->sc_xname, errstring); 1444 #endif 1445 1446 /* In-core label now valid. */ 1447 cs->sc_flags |= CCDF_VLABEL; 1448 } 1449 1450 /* 1451 * Take care of things one might want to take care of in the event 1452 * that a disklabel isn't present. 1453 */ 1454 static void 1455 ccdmakedisklabel(struct ccd_softc *cs) 1456 { 1457 struct disklabel *lp = cs->sc_dkdev.dk_label; 1458 1459 /* 1460 * For historical reasons, if there's no disklabel present 1461 * the raw partition must be marked FS_BSDFFS. 1462 */ 1463 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 1464 1465 strncpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 1466 1467 lp->d_checksum = dkcksum(lp); 1468 } 1469 1470 #ifdef DEBUG 1471 static void 1472 printiinfo(struct ccdiinfo *ii) 1473 { 1474 int ix, i; 1475 1476 for (ix = 0; ii->ii_ndisk; ix++, ii++) { 1477 printf(" itab[%d]: #dk %d sblk %" PRId64 " soff %" PRId64, 1478 ix, ii->ii_ndisk, ii->ii_startblk, ii->ii_startoff); 1479 for (i = 0; i < ii->ii_ndisk; i++) 1480 printf(" %d", ii->ii_index[i]); 1481 printf("\n"); 1482 } 1483 } 1484 #endif 1485
Indexes created Tue Sep 30 11:09:46 GMT 2025