rf_netbsdkintf.c revision 1.79.2.1
1 /* $NetBSD: rf_netbsdkintf.c,v 1.79.2.1 2000/06/22 17:07:55 minoura Exp $ */ 2 /*- 3 * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to The NetBSD Foundation 7 * by Greg Oster; Jason R. Thorpe. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by the NetBSD 20 * Foundation, Inc. and its contributors. 21 * 4. Neither the name of The NetBSD Foundation nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 26 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * Copyright (c) 1988 University of Utah. 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. All advertising materials mentioning features or use of this software 56 * must display the following acknowledgement: 57 * This product includes software developed by the University of 58 * California, Berkeley and its contributors. 59 * 4. 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 82 83 /* 84 * Copyright (c) 1995 Carnegie-Mellon University. 85 * All rights reserved. 86 * 87 * Authors: Mark Holland, Jim Zelenka 88 * 89 * Permission to use, copy, modify and distribute this software and 90 * its documentation is hereby granted, provided that both the copyright 91 * notice and this permission notice appear in all copies of the 92 * software, derivative works or modified versions, and any portions 93 * thereof, and that both notices appear in supporting documentation. 94 * 95 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 96 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 97 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 98 * 99 * Carnegie Mellon requests users of this software to return to 100 * 101 * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU 102 * School of Computer Science 103 * Carnegie Mellon University 104 * Pittsburgh PA 15213-3890 105 * 106 * any improvements or extensions that they make and grant Carnegie the 107 * rights to redistribute these changes. 108 */ 109 110 /*********************************************************** 111 * 112 * rf_kintf.c -- the kernel interface routines for RAIDframe 113 * 114 ***********************************************************/ 115 116 #include <sys/errno.h> 117 #include <sys/param.h> 118 #include <sys/pool.h> 119 #include <sys/queue.h> 120 #include <sys/disk.h> 121 #include <sys/device.h> 122 #include <sys/stat.h> 123 #include <sys/ioctl.h> 124 #include <sys/fcntl.h> 125 #include <sys/systm.h> 126 #include <sys/namei.h> 127 #include <sys/vnode.h> 128 #include <sys/param.h> 129 #include <sys/types.h> 130 #include <machine/types.h> 131 #include <sys/disklabel.h> 132 #include <sys/conf.h> 133 #include <sys/lock.h> 134 #include <sys/buf.h> 135 #include <sys/user.h> 136 #include <sys/reboot.h> 137 138 #include "raid.h" 139 #include "opt_raid_autoconfig.h" 140 #include "rf_raid.h" 141 #include "rf_raidframe.h" 142 #include "rf_copyback.h" 143 #include "rf_dag.h" 144 #include "rf_dagflags.h" 145 #include "rf_diskqueue.h" 146 #include "rf_acctrace.h" 147 #include "rf_etimer.h" 148 #include "rf_general.h" 149 #include "rf_debugMem.h" 150 #include "rf_kintf.h" 151 #include "rf_options.h" 152 #include "rf_driver.h" 153 #include "rf_parityscan.h" 154 #include "rf_debugprint.h" 155 #include "rf_threadstuff.h" 156 #include "rf_configure.h" 157 158 int rf_kdebug_level = 0; 159 160 #ifdef DEBUG 161 #define db1_printf(a) if (rf_kdebug_level > 0) printf a 162 #else /* DEBUG */ 163 #define db1_printf(a) { } 164 #endif /* DEBUG */ 165 166 static RF_Raid_t **raidPtrs; /* global raid device descriptors */ 167 168 RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex) 169 170 static RF_SparetWait_t *rf_sparet_wait_queue; /* requests to install a 171 * spare table */ 172 static RF_SparetWait_t *rf_sparet_resp_queue; /* responses from 173 * installation process */ 174 175 /* prototypes */ 176 static void KernelWakeupFunc(struct buf * bp); 177 static void InitBP(struct buf * bp, struct vnode *, unsigned rw_flag, 178 dev_t dev, RF_SectorNum_t startSect, 179 RF_SectorCount_t numSect, caddr_t buf, 180 void (*cbFunc) (struct buf *), void *cbArg, 181 int logBytesPerSector, struct proc * b_proc); 182 static void raidinit __P((RF_Raid_t *)); 183 184 void raidattach __P((int)); 185 int raidsize __P((dev_t)); 186 int raidopen __P((dev_t, int, int, struct proc *)); 187 int raidclose __P((dev_t, int, int, struct proc *)); 188 int raidioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); 189 int raidwrite __P((dev_t, struct uio *, int)); 190 int raidread __P((dev_t, struct uio *, int)); 191 void raidstrategy __P((struct buf *)); 192 int raiddump __P((dev_t, daddr_t, caddr_t, size_t)); 193 194 /* 195 * Pilfered from ccd.c 196 */ 197 198 struct raidbuf { 199 struct buf rf_buf; /* new I/O buf. MUST BE FIRST!!! */ 200 struct buf *rf_obp; /* ptr. to original I/O buf */ 201 int rf_flags; /* misc. flags */ 202 RF_DiskQueueData_t *req;/* the request that this was part of.. */ 203 }; 204 205 206 #define RAIDGETBUF(rs) pool_get(&(rs)->sc_cbufpool, PR_NOWAIT) 207 #define RAIDPUTBUF(rs, cbp) pool_put(&(rs)->sc_cbufpool, cbp) 208 209 /* XXX Not sure if the following should be replacing the raidPtrs above, 210 or if it should be used in conjunction with that... 211 */ 212 213 struct raid_softc { 214 int sc_flags; /* flags */ 215 int sc_cflags; /* configuration flags */ 216 size_t sc_size; /* size of the raid device */ 217 char sc_xname[20]; /* XXX external name */ 218 struct disk sc_dkdev; /* generic disk device info */ 219 struct pool sc_cbufpool; /* component buffer pool */ 220 struct buf_queue buf_queue; /* used for the device queue */ 221 }; 222 /* sc_flags */ 223 #define RAIDF_INITED 0x01 /* unit has been initialized */ 224 #define RAIDF_WLABEL 0x02 /* label area is writable */ 225 #define RAIDF_LABELLING 0x04 /* unit is currently being labelled */ 226 #define RAIDF_WANTED 0x40 /* someone is waiting to obtain a lock */ 227 #define RAIDF_LOCKED 0x80 /* unit is locked */ 228 229 #define raidunit(x) DISKUNIT(x) 230 int numraid = 0; 231 232 /* 233 * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device. 234 * Be aware that large numbers can allow the driver to consume a lot of 235 * kernel memory, especially on writes, and in degraded mode reads. 236 * 237 * For example: with a stripe width of 64 blocks (32k) and 5 disks, 238 * a single 64K write will typically require 64K for the old data, 239 * 64K for the old parity, and 64K for the new parity, for a total 240 * of 192K (if the parity buffer is not re-used immediately). 241 * Even it if is used immedately, that's still 128K, which when multiplied 242 * by say 10 requests, is 1280K, *on top* of the 640K of incoming data. 243 * 244 * Now in degraded mode, for example, a 64K read on the above setup may 245 * require data reconstruction, which will require *all* of the 4 remaining 246 * disks to participate -- 4 * 32K/disk == 128K again. 247 */ 248 249 #ifndef RAIDOUTSTANDING 250 #define RAIDOUTSTANDING 6 251 #endif 252 253 #define RAIDLABELDEV(dev) \ 254 (MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART)) 255 256 /* declared here, and made public, for the benefit of KVM stuff.. */ 257 struct raid_softc *raid_softc; 258 259 static void raidgetdefaultlabel __P((RF_Raid_t *, struct raid_softc *, 260 struct disklabel *)); 261 static void raidgetdisklabel __P((dev_t)); 262 static void raidmakedisklabel __P((struct raid_softc *)); 263 264 static int raidlock __P((struct raid_softc *)); 265 static void raidunlock __P((struct raid_softc *)); 266 267 static void rf_markalldirty __P((RF_Raid_t *)); 268 void rf_mountroot_hook __P((struct device *)); 269 270 struct device *raidrootdev; 271 272 void rf_ReconThread __P((struct rf_recon_req *)); 273 /* XXX what I want is: */ 274 /*void rf_ReconThread __P((RF_Raid_t *raidPtr)); */ 275 void rf_RewriteParityThread __P((RF_Raid_t *raidPtr)); 276 void rf_CopybackThread __P((RF_Raid_t *raidPtr)); 277 void rf_ReconstructInPlaceThread __P((struct rf_recon_req *)); 278 void rf_buildroothack __P((void *)); 279 280 RF_AutoConfig_t *rf_find_raid_components __P((void)); 281 RF_ConfigSet_t *rf_create_auto_sets __P((RF_AutoConfig_t *)); 282 static int rf_does_it_fit __P((RF_ConfigSet_t *,RF_AutoConfig_t *)); 283 static int rf_reasonable_label __P((RF_ComponentLabel_t *)); 284 void rf_create_configuration __P((RF_AutoConfig_t *,RF_Config_t *, 285 RF_Raid_t *)); 286 int rf_set_autoconfig __P((RF_Raid_t *, int)); 287 int rf_set_rootpartition __P((RF_Raid_t *, int)); 288 void rf_release_all_vps __P((RF_ConfigSet_t *)); 289 void rf_cleanup_config_set __P((RF_ConfigSet_t *)); 290 int rf_have_enough_components __P((RF_ConfigSet_t *)); 291 int rf_auto_config_set __P((RF_ConfigSet_t *, int *)); 292 293 static int raidautoconfig = 0; /* Debugging, mostly. Set to 0 to not 294 allow autoconfig to take place. 295 Note that this is overridden by having 296 RAID_AUTOCONFIG as an option in the 297 kernel config file. */ 298 299 void 300 raidattach(num) 301 int num; 302 { 303 int raidID; 304 int i, rc; 305 RF_AutoConfig_t *ac_list; /* autoconfig list */ 306 RF_ConfigSet_t *config_sets; 307 308 #ifdef DEBUG 309 printf("raidattach: Asked for %d units\n", num); 310 #endif 311 312 if (num <= 0) { 313 #ifdef DIAGNOSTIC 314 panic("raidattach: count <= 0"); 315 #endif 316 return; 317 } 318 /* This is where all the initialization stuff gets done. */ 319 320 numraid = num; 321 322 /* Make some space for requested number of units... */ 323 324 RF_Calloc(raidPtrs, num, sizeof(RF_Raid_t *), (RF_Raid_t **)); 325 if (raidPtrs == NULL) { 326 panic("raidPtrs is NULL!!\n"); 327 } 328 329 rc = rf_mutex_init(&rf_sparet_wait_mutex); 330 if (rc) { 331 RF_PANIC(); 332 } 333 334 rf_sparet_wait_queue = rf_sparet_resp_queue = NULL; 335 336 for (i = 0; i < num; i++) 337 raidPtrs[i] = NULL; 338 rc = rf_BootRaidframe(); 339 if (rc == 0) 340 printf("Kernelized RAIDframe activated\n"); 341 else 342 panic("Serious error booting RAID!!\n"); 343 344 /* put together some datastructures like the CCD device does.. This 345 * lets us lock the device and what-not when it gets opened. */ 346 347 raid_softc = (struct raid_softc *) 348 malloc(num * sizeof(struct raid_softc), 349 M_RAIDFRAME, M_NOWAIT); 350 if (raid_softc == NULL) { 351 printf("WARNING: no memory for RAIDframe driver\n"); 352 return; 353 } 354 355 bzero(raid_softc, num * sizeof(struct raid_softc)); 356 357 raidrootdev = (struct device *)malloc(num * sizeof(struct device), 358 M_RAIDFRAME, M_NOWAIT); 359 if (raidrootdev == NULL) { 360 panic("No memory for RAIDframe driver!!?!?!\n"); 361 } 362 363 for (raidID = 0; raidID < num; raidID++) { 364 BUFQ_INIT(&raid_softc[raidID].buf_queue); 365 366 raidrootdev[raidID].dv_class = DV_DISK; 367 raidrootdev[raidID].dv_cfdata = NULL; 368 raidrootdev[raidID].dv_unit = raidID; 369 raidrootdev[raidID].dv_parent = NULL; 370 raidrootdev[raidID].dv_flags = 0; 371 sprintf(raidrootdev[raidID].dv_xname,"raid%d",raidID); 372 373 RF_Calloc(raidPtrs[raidID], 1, sizeof(RF_Raid_t), 374 (RF_Raid_t *)); 375 if (raidPtrs[raidID] == NULL) { 376 printf("WARNING: raidPtrs[%d] is NULL\n", raidID); 377 numraid = raidID; 378 return; 379 } 380 } 381 382 #if RAID_AUTOCONFIG 383 raidautoconfig = 1; 384 #endif 385 386 if (raidautoconfig) { 387 /* 1. locate all RAID components on the system */ 388 389 #if DEBUG 390 printf("Searching for raid components...\n"); 391 #endif 392 ac_list = rf_find_raid_components(); 393 394 /* 2. sort them into their respective sets */ 395 396 config_sets = rf_create_auto_sets(ac_list); 397 398 /* 3. evaluate each set and configure the valid ones 399 This gets done in rf_buildroothack() */ 400 401 /* schedule the creation of the thread to do the 402 "/ on RAID" stuff */ 403 404 kthread_create(rf_buildroothack,config_sets); 405 406 #if 0 407 mountroothook_establish(rf_mountroot_hook, &raidrootdev[0]); 408 #endif 409 } 410 411 } 412 413 void 414 rf_buildroothack(arg) 415 void *arg; 416 { 417 RF_ConfigSet_t *config_sets = arg; 418 RF_ConfigSet_t *cset; 419 RF_ConfigSet_t *next_cset; 420 int retcode; 421 int raidID; 422 int rootID; 423 int num_root; 424 425 num_root = 0; 426 cset = config_sets; 427 while(cset != NULL ) { 428 next_cset = cset->next; 429 if (rf_have_enough_components(cset) && 430 cset->ac->clabel->autoconfigure==1) { 431 retcode = rf_auto_config_set(cset,&raidID); 432 if (!retcode) { 433 if (cset->rootable) { 434 rootID = raidID; 435 num_root++; 436 } 437 } else { 438 /* The autoconfig didn't work :( */ 439 #if DEBUG 440 printf("Autoconfig failed with code %d for raid%d\n", retcode, raidID); 441 #endif 442 rf_release_all_vps(cset); 443 } 444 } else { 445 /* we're not autoconfiguring this set... 446 release the associated resources */ 447 rf_release_all_vps(cset); 448 } 449 /* cleanup */ 450 rf_cleanup_config_set(cset); 451 cset = next_cset; 452 } 453 if (boothowto & RB_ASKNAME) { 454 /* We don't auto-config... */ 455 } else { 456 /* They didn't ask, and we found something bootable... */ 457 458 if (num_root == 1) { 459 booted_device = &raidrootdev[rootID]; 460 } else if (num_root > 1) { 461 /* we can't guess.. require the user to answer... */ 462 boothowto |= RB_ASKNAME; 463 } 464 } 465 } 466 467 468 int 469 raidsize(dev) 470 dev_t dev; 471 { 472 struct raid_softc *rs; 473 struct disklabel *lp; 474 int part, unit, omask, size; 475 476 unit = raidunit(dev); 477 if (unit >= numraid) 478 return (-1); 479 rs = &raid_softc[unit]; 480 481 if ((rs->sc_flags & RAIDF_INITED) == 0) 482 return (-1); 483 484 part = DISKPART(dev); 485 omask = rs->sc_dkdev.dk_openmask & (1 << part); 486 lp = rs->sc_dkdev.dk_label; 487 488 if (omask == 0 && raidopen(dev, 0, S_IFBLK, curproc)) 489 return (-1); 490 491 if (lp->d_partitions[part].p_fstype != FS_SWAP) 492 size = -1; 493 else 494 size = lp->d_partitions[part].p_size * 495 (lp->d_secsize / DEV_BSIZE); 496 497 if (omask == 0 && raidclose(dev, 0, S_IFBLK, curproc)) 498 return (-1); 499 500 return (size); 501 502 } 503 504 int 505 raiddump(dev, blkno, va, size) 506 dev_t dev; 507 daddr_t blkno; 508 caddr_t va; 509 size_t size; 510 { 511 /* Not implemented. */ 512 return ENXIO; 513 } 514 /* ARGSUSED */ 515 int 516 raidopen(dev, flags, fmt, p) 517 dev_t dev; 518 int flags, fmt; 519 struct proc *p; 520 { 521 int unit = raidunit(dev); 522 struct raid_softc *rs; 523 struct disklabel *lp; 524 int part, pmask; 525 int error = 0; 526 527 if (unit >= numraid) 528 return (ENXIO); 529 rs = &raid_softc[unit]; 530 531 if ((error = raidlock(rs)) != 0) 532 return (error); 533 lp = rs->sc_dkdev.dk_label; 534 535 part = DISKPART(dev); 536 pmask = (1 << part); 537 538 db1_printf(("Opening raid device number: %d partition: %d\n", 539 unit, part)); 540 541 542 if ((rs->sc_flags & RAIDF_INITED) && 543 (rs->sc_dkdev.dk_openmask == 0)) 544 raidgetdisklabel(dev); 545 546 /* make sure that this partition exists */ 547 548 if (part != RAW_PART) { 549 db1_printf(("Not a raw partition..\n")); 550 if (((rs->sc_flags & RAIDF_INITED) == 0) || 551 ((part >= lp->d_npartitions) || 552 (lp->d_partitions[part].p_fstype == FS_UNUSED))) { 553 error = ENXIO; 554 raidunlock(rs); 555 db1_printf(("Bailing out...\n")); 556 return (error); 557 } 558 } 559 /* Prevent this unit from being unconfigured while open. */ 560 switch (fmt) { 561 case S_IFCHR: 562 rs->sc_dkdev.dk_copenmask |= pmask; 563 break; 564 565 case S_IFBLK: 566 rs->sc_dkdev.dk_bopenmask |= pmask; 567 break; 568 } 569 570 if ((rs->sc_dkdev.dk_openmask == 0) && 571 ((rs->sc_flags & RAIDF_INITED) != 0)) { 572 /* First one... mark things as dirty... Note that we *MUST* 573 have done a configure before this. I DO NOT WANT TO BE 574 SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED 575 THAT THEY BELONG TOGETHER!!!!! */ 576 /* XXX should check to see if we're only open for reading 577 here... If so, we needn't do this, but then need some 578 other way of keeping track of what's happened.. */ 579 580 rf_markalldirty( raidPtrs[unit] ); 581 } 582 583 584 rs->sc_dkdev.dk_openmask = 585 rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask; 586 587 raidunlock(rs); 588 589 return (error); 590 591 592 } 593 /* ARGSUSED */ 594 int 595 raidclose(dev, flags, fmt, p) 596 dev_t dev; 597 int flags, fmt; 598 struct proc *p; 599 { 600 int unit = raidunit(dev); 601 struct raid_softc *rs; 602 int error = 0; 603 int part; 604 605 if (unit >= numraid) 606 return (ENXIO); 607 rs = &raid_softc[unit]; 608 609 if ((error = raidlock(rs)) != 0) 610 return (error); 611 612 part = DISKPART(dev); 613 614 /* ...that much closer to allowing unconfiguration... */ 615 switch (fmt) { 616 case S_IFCHR: 617 rs->sc_dkdev.dk_copenmask &= ~(1 << part); 618 break; 619 620 case S_IFBLK: 621 rs->sc_dkdev.dk_bopenmask &= ~(1 << part); 622 break; 623 } 624 rs->sc_dkdev.dk_openmask = 625 rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask; 626 627 if ((rs->sc_dkdev.dk_openmask == 0) && 628 ((rs->sc_flags & RAIDF_INITED) != 0)) { 629 /* Last one... device is not unconfigured yet. 630 Device shutdown has taken care of setting the 631 clean bits if RAIDF_INITED is not set 632 mark things as clean... */ 633 #if 0 634 printf("Last one on raid%d. Updating status.\n",unit); 635 #endif 636 rf_update_component_labels(raidPtrs[unit], 637 RF_FINAL_COMPONENT_UPDATE); 638 } 639 640 raidunlock(rs); 641 return (0); 642 643 } 644 645 void 646 raidstrategy(bp) 647 struct buf *bp; 648 { 649 int s; 650 651 unsigned int raidID = raidunit(bp->b_dev); 652 RF_Raid_t *raidPtr; 653 struct raid_softc *rs = &raid_softc[raidID]; 654 struct disklabel *lp; 655 int wlabel; 656 657 if ((rs->sc_flags & RAIDF_INITED) ==0) { 658 bp->b_error = ENXIO; 659 bp->b_flags = B_ERROR; 660 bp->b_resid = bp->b_bcount; 661 biodone(bp); 662 return; 663 } 664 if (raidID >= numraid || !raidPtrs[raidID]) { 665 bp->b_error = ENODEV; 666 bp->b_flags |= B_ERROR; 667 bp->b_resid = bp->b_bcount; 668 biodone(bp); 669 return; 670 } 671 raidPtr = raidPtrs[raidID]; 672 if (!raidPtr->valid) { 673 bp->b_error = ENODEV; 674 bp->b_flags |= B_ERROR; 675 bp->b_resid = bp->b_bcount; 676 biodone(bp); 677 return; 678 } 679 if (bp->b_bcount == 0) { 680 db1_printf(("b_bcount is zero..\n")); 681 biodone(bp); 682 return; 683 } 684 lp = rs->sc_dkdev.dk_label; 685 686 /* 687 * Do bounds checking and adjust transfer. If there's an 688 * error, the bounds check will flag that for us. 689 */ 690 691 wlabel = rs->sc_flags & (RAIDF_WLABEL | RAIDF_LABELLING); 692 if (DISKPART(bp->b_dev) != RAW_PART) 693 if (bounds_check_with_label(bp, lp, wlabel) <= 0) { 694 db1_printf(("Bounds check failed!!:%d %d\n", 695 (int) bp->b_blkno, (int) wlabel)); 696 biodone(bp); 697 return; 698 } 699 s = splbio(); 700 701 bp->b_resid = 0; 702 703 /* stuff it onto our queue */ 704 BUFQ_INSERT_TAIL(&rs->buf_queue, bp); 705 706 raidstart(raidPtrs[raidID]); 707 708 splx(s); 709 } 710 /* ARGSUSED */ 711 int 712 raidread(dev, uio, flags) 713 dev_t dev; 714 struct uio *uio; 715 int flags; 716 { 717 int unit = raidunit(dev); 718 struct raid_softc *rs; 719 int part; 720 721 if (unit >= numraid) 722 return (ENXIO); 723 rs = &raid_softc[unit]; 724 725 if ((rs->sc_flags & RAIDF_INITED) == 0) 726 return (ENXIO); 727 part = DISKPART(dev); 728 729 db1_printf(("raidread: unit: %d partition: %d\n", unit, part)); 730 731 return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio)); 732 733 } 734 /* ARGSUSED */ 735 int 736 raidwrite(dev, uio, flags) 737 dev_t dev; 738 struct uio *uio; 739 int flags; 740 { 741 int unit = raidunit(dev); 742 struct raid_softc *rs; 743 744 if (unit >= numraid) 745 return (ENXIO); 746 rs = &raid_softc[unit]; 747 748 if ((rs->sc_flags & RAIDF_INITED) == 0) 749 return (ENXIO); 750 db1_printf(("raidwrite\n")); 751 return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio)); 752 753 } 754 755 int 756 raidioctl(dev, cmd, data, flag, p) 757 dev_t dev; 758 u_long cmd; 759 caddr_t data; 760 int flag; 761 struct proc *p; 762 { 763 int unit = raidunit(dev); 764 int error = 0; 765 int part, pmask; 766 struct raid_softc *rs; 767 RF_Config_t *k_cfg, *u_cfg; 768 RF_Raid_t *raidPtr; 769 RF_RaidDisk_t *diskPtr; 770 RF_AccTotals_t *totals; 771 RF_DeviceConfig_t *d_cfg, **ucfgp; 772 u_char *specific_buf; 773 int retcode = 0; 774 int row; 775 int column; 776 struct rf_recon_req *rrcopy, *rr; 777 RF_ComponentLabel_t *clabel; 778 RF_ComponentLabel_t ci_label; 779 RF_ComponentLabel_t **clabel_ptr; 780 RF_SingleComponent_t *sparePtr,*componentPtr; 781 RF_SingleComponent_t hot_spare; 782 RF_SingleComponent_t component; 783 RF_ProgressInfo_t progressInfo, **progressInfoPtr; 784 int i, j, d; 785 786 if (unit >= numraid) 787 return (ENXIO); 788 rs = &raid_softc[unit]; 789 raidPtr = raidPtrs[unit]; 790 791 db1_printf(("raidioctl: %d %d %d %d\n", (int) dev, 792 (int) DISKPART(dev), (int) unit, (int) cmd)); 793 794 /* Must be open for writes for these commands... */ 795 switch (cmd) { 796 case DIOCSDINFO: 797 case DIOCWDINFO: 798 case DIOCWLABEL: 799 if ((flag & FWRITE) == 0) 800 return (EBADF); 801 } 802 803 /* Must be initialized for these... */ 804 switch (cmd) { 805 case DIOCGDINFO: 806 case DIOCSDINFO: 807 case DIOCWDINFO: 808 case DIOCGPART: 809 case DIOCWLABEL: 810 case DIOCGDEFLABEL: 811 case RAIDFRAME_SHUTDOWN: 812 case RAIDFRAME_REWRITEPARITY: 813 case RAIDFRAME_GET_INFO: 814 case RAIDFRAME_RESET_ACCTOTALS: 815 case RAIDFRAME_GET_ACCTOTALS: 816 case RAIDFRAME_KEEP_ACCTOTALS: 817 case RAIDFRAME_GET_SIZE: 818 case RAIDFRAME_FAIL_DISK: 819 case RAIDFRAME_COPYBACK: 820 case RAIDFRAME_CHECK_RECON_STATUS: 821 case RAIDFRAME_CHECK_RECON_STATUS_EXT: 822 case RAIDFRAME_GET_COMPONENT_LABEL: 823 case RAIDFRAME_SET_COMPONENT_LABEL: 824 case RAIDFRAME_ADD_HOT_SPARE: 825 case RAIDFRAME_REMOVE_HOT_SPARE: 826 case RAIDFRAME_INIT_LABELS: 827 case RAIDFRAME_REBUILD_IN_PLACE: 828 case RAIDFRAME_CHECK_PARITY: 829 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS: 830 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT: 831 case RAIDFRAME_CHECK_COPYBACK_STATUS: 832 case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT: 833 case RAIDFRAME_SET_AUTOCONFIG: 834 case RAIDFRAME_SET_ROOT: 835 case RAIDFRAME_DELETE_COMPONENT: 836 case RAIDFRAME_INCORPORATE_HOT_SPARE: 837 if ((rs->sc_flags & RAIDF_INITED) == 0) 838 return (ENXIO); 839 } 840 841 switch (cmd) { 842 843 /* configure the system */ 844 case RAIDFRAME_CONFIGURE: 845 846 if (raidPtr->valid) { 847 /* There is a valid RAID set running on this unit! */ 848 printf("raid%d: Device already configured!\n",unit); 849 return(EINVAL); 850 } 851 852 /* copy-in the configuration information */ 853 /* data points to a pointer to the configuration structure */ 854 855 u_cfg = *((RF_Config_t **) data); 856 RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *)); 857 if (k_cfg == NULL) { 858 return (ENOMEM); 859 } 860 retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg, 861 sizeof(RF_Config_t)); 862 if (retcode) { 863 RF_Free(k_cfg, sizeof(RF_Config_t)); 864 db1_printf(("rf_ioctl: retcode=%d copyin.1\n", 865 retcode)); 866 return (retcode); 867 } 868 /* allocate a buffer for the layout-specific data, and copy it 869 * in */ 870 if (k_cfg->layoutSpecificSize) { 871 if (k_cfg->layoutSpecificSize > 10000) { 872 /* sanity check */ 873 RF_Free(k_cfg, sizeof(RF_Config_t)); 874 return (EINVAL); 875 } 876 RF_Malloc(specific_buf, k_cfg->layoutSpecificSize, 877 (u_char *)); 878 if (specific_buf == NULL) { 879 RF_Free(k_cfg, sizeof(RF_Config_t)); 880 return (ENOMEM); 881 } 882 retcode = copyin(k_cfg->layoutSpecific, 883 (caddr_t) specific_buf, 884 k_cfg->layoutSpecificSize); 885 if (retcode) { 886 RF_Free(k_cfg, sizeof(RF_Config_t)); 887 RF_Free(specific_buf, 888 k_cfg->layoutSpecificSize); 889 db1_printf(("rf_ioctl: retcode=%d copyin.2\n", 890 retcode)); 891 return (retcode); 892 } 893 } else 894 specific_buf = NULL; 895 k_cfg->layoutSpecific = specific_buf; 896 897 /* should do some kind of sanity check on the configuration. 898 * Store the sum of all the bytes in the last byte? */ 899 900 /* configure the system */ 901 902 /* 903 * Clear the entire RAID descriptor, just to make sure 904 * there is no stale data left in the case of a 905 * reconfiguration 906 */ 907 bzero((char *) raidPtr, sizeof(RF_Raid_t)); 908 raidPtr->raidid = unit; 909 910 retcode = rf_Configure(raidPtr, k_cfg, NULL); 911 912 if (retcode == 0) { 913 914 /* allow this many simultaneous IO's to 915 this RAID device */ 916 raidPtr->openings = RAIDOUTSTANDING; 917 918 raidinit(raidPtr); 919 rf_markalldirty(raidPtr); 920 } 921 /* free the buffers. No return code here. */ 922 if (k_cfg->layoutSpecificSize) { 923 RF_Free(specific_buf, k_cfg->layoutSpecificSize); 924 } 925 RF_Free(k_cfg, sizeof(RF_Config_t)); 926 927 return (retcode); 928 929 /* shutdown the system */ 930 case RAIDFRAME_SHUTDOWN: 931 932 if ((error = raidlock(rs)) != 0) 933 return (error); 934 935 /* 936 * If somebody has a partition mounted, we shouldn't 937 * shutdown. 938 */ 939 940 part = DISKPART(dev); 941 pmask = (1 << part); 942 if ((rs->sc_dkdev.dk_openmask & ~pmask) || 943 ((rs->sc_dkdev.dk_bopenmask & pmask) && 944 (rs->sc_dkdev.dk_copenmask & pmask))) { 945 raidunlock(rs); 946 return (EBUSY); 947 } 948 949 retcode = rf_Shutdown(raidPtr); 950 951 pool_destroy(&rs->sc_cbufpool); 952 953 /* It's no longer initialized... */ 954 rs->sc_flags &= ~RAIDF_INITED; 955 956 /* Detach the disk. */ 957 disk_detach(&rs->sc_dkdev); 958 959 raidunlock(rs); 960 961 return (retcode); 962 case RAIDFRAME_GET_COMPONENT_LABEL: 963 clabel_ptr = (RF_ComponentLabel_t **) data; 964 /* need to read the component label for the disk indicated 965 by row,column in clabel */ 966 967 /* For practice, let's get it directly fromdisk, rather 968 than from the in-core copy */ 969 RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ), 970 (RF_ComponentLabel_t *)); 971 if (clabel == NULL) 972 return (ENOMEM); 973 974 bzero((char *) clabel, sizeof(RF_ComponentLabel_t)); 975 976 retcode = copyin( *clabel_ptr, clabel, 977 sizeof(RF_ComponentLabel_t)); 978 979 if (retcode) { 980 RF_Free( clabel, sizeof(RF_ComponentLabel_t)); 981 return(retcode); 982 } 983 984 row = clabel->row; 985 column = clabel->column; 986 987 if ((row < 0) || (row >= raidPtr->numRow) || 988 (column < 0) || (column >= raidPtr->numCol + 989 raidPtr->numSpare)) { 990 RF_Free( clabel, sizeof(RF_ComponentLabel_t)); 991 return(EINVAL); 992 } 993 994 raidread_component_label(raidPtr->Disks[row][column].dev, 995 raidPtr->raid_cinfo[row][column].ci_vp, 996 clabel ); 997 998 retcode = copyout((caddr_t) clabel, 999 (caddr_t) *clabel_ptr, 1000 sizeof(RF_ComponentLabel_t)); 1001 RF_Free( clabel, sizeof(RF_ComponentLabel_t)); 1002 return (retcode); 1003 1004 case RAIDFRAME_SET_COMPONENT_LABEL: 1005 clabel = (RF_ComponentLabel_t *) data; 1006 1007 /* XXX check the label for valid stuff... */ 1008 /* Note that some things *should not* get modified -- 1009 the user should be re-initing the labels instead of 1010 trying to patch things. 1011 */ 1012 1013 printf("Got component label:\n"); 1014 printf("Version: %d\n",clabel->version); 1015 printf("Serial Number: %d\n",clabel->serial_number); 1016 printf("Mod counter: %d\n",clabel->mod_counter); 1017 printf("Row: %d\n", clabel->row); 1018 printf("Column: %d\n", clabel->column); 1019 printf("Num Rows: %d\n", clabel->num_rows); 1020 printf("Num Columns: %d\n", clabel->num_columns); 1021 printf("Clean: %d\n", clabel->clean); 1022 printf("Status: %d\n", clabel->status); 1023 1024 row = clabel->row; 1025 column = clabel->column; 1026 1027 if ((row < 0) || (row >= raidPtr->numRow) || 1028 (column < 0) || (column >= raidPtr->numCol)) { 1029 return(EINVAL); 1030 } 1031 1032 /* XXX this isn't allowed to do anything for now :-) */ 1033 1034 /* XXX and before it is, we need to fill in the rest 1035 of the fields!?!?!?! */ 1036 #if 0 1037 raidwrite_component_label( 1038 raidPtr->Disks[row][column].dev, 1039 raidPtr->raid_cinfo[row][column].ci_vp, 1040 clabel ); 1041 #endif 1042 return (0); 1043 1044 case RAIDFRAME_INIT_LABELS: 1045 clabel = (RF_ComponentLabel_t *) data; 1046 /* 1047 we only want the serial number from 1048 the above. We get all the rest of the information 1049 from the config that was used to create this RAID 1050 set. 1051 */ 1052 1053 raidPtr->serial_number = clabel->serial_number; 1054 1055 raid_init_component_label(raidPtr, &ci_label); 1056 ci_label.serial_number = clabel->serial_number; 1057 1058 for(row=0;row<raidPtr->numRow;row++) { 1059 ci_label.row = row; 1060 for(column=0;column<raidPtr->numCol;column++) { 1061 diskPtr = &raidPtr->Disks[row][column]; 1062 ci_label.partitionSize = diskPtr->partitionSize; 1063 ci_label.column = column; 1064 raidwrite_component_label( 1065 raidPtr->Disks[row][column].dev, 1066 raidPtr->raid_cinfo[row][column].ci_vp, 1067 &ci_label ); 1068 } 1069 } 1070 1071 return (retcode); 1072 case RAIDFRAME_SET_AUTOCONFIG: 1073 d = rf_set_autoconfig(raidPtr, *(int *) data); 1074 printf("New autoconfig value is: %d\n", d); 1075 *(int *) data = d; 1076 return (retcode); 1077 1078 case RAIDFRAME_SET_ROOT: 1079 d = rf_set_rootpartition(raidPtr, *(int *) data); 1080 printf("New rootpartition value is: %d\n", d); 1081 *(int *) data = d; 1082 return (retcode); 1083 1084 /* initialize all parity */ 1085 case RAIDFRAME_REWRITEPARITY: 1086 1087 if (raidPtr->Layout.map->faultsTolerated == 0) { 1088 /* Parity for RAID 0 is trivially correct */ 1089 raidPtr->parity_good = RF_RAID_CLEAN; 1090 return(0); 1091 } 1092 1093 if (raidPtr->parity_rewrite_in_progress == 1) { 1094 /* Re-write is already in progress! */ 1095 return(EINVAL); 1096 } 1097 1098 retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread, 1099 rf_RewriteParityThread, 1100 raidPtr,"raid_parity"); 1101 return (retcode); 1102 1103 1104 case RAIDFRAME_ADD_HOT_SPARE: 1105 sparePtr = (RF_SingleComponent_t *) data; 1106 memcpy( &hot_spare, sparePtr, sizeof(RF_SingleComponent_t)); 1107 retcode = rf_add_hot_spare(raidPtr, &hot_spare); 1108 return(retcode); 1109 1110 case RAIDFRAME_REMOVE_HOT_SPARE: 1111 return(retcode); 1112 1113 case RAIDFRAME_DELETE_COMPONENT: 1114 componentPtr = (RF_SingleComponent_t *)data; 1115 memcpy( &component, componentPtr, 1116 sizeof(RF_SingleComponent_t)); 1117 retcode = rf_delete_component(raidPtr, &component); 1118 return(retcode); 1119 1120 case RAIDFRAME_INCORPORATE_HOT_SPARE: 1121 componentPtr = (RF_SingleComponent_t *)data; 1122 memcpy( &component, componentPtr, 1123 sizeof(RF_SingleComponent_t)); 1124 retcode = rf_incorporate_hot_spare(raidPtr, &component); 1125 return(retcode); 1126 1127 case RAIDFRAME_REBUILD_IN_PLACE: 1128 1129 if (raidPtr->Layout.map->faultsTolerated == 0) { 1130 /* Can't do this on a RAID 0!! */ 1131 return(EINVAL); 1132 } 1133 1134 if (raidPtr->recon_in_progress == 1) { 1135 /* a reconstruct is already in progress! */ 1136 return(EINVAL); 1137 } 1138 1139 componentPtr = (RF_SingleComponent_t *) data; 1140 memcpy( &component, componentPtr, 1141 sizeof(RF_SingleComponent_t)); 1142 row = component.row; 1143 column = component.column; 1144 printf("Rebuild: %d %d\n",row, column); 1145 if ((row < 0) || (row >= raidPtr->numRow) || 1146 (column < 0) || (column >= raidPtr->numCol)) { 1147 return(EINVAL); 1148 } 1149 1150 RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); 1151 if (rrcopy == NULL) 1152 return(ENOMEM); 1153 1154 rrcopy->raidPtr = (void *) raidPtr; 1155 rrcopy->row = row; 1156 rrcopy->col = column; 1157 1158 retcode = RF_CREATE_THREAD(raidPtr->recon_thread, 1159 rf_ReconstructInPlaceThread, 1160 rrcopy,"raid_reconip"); 1161 return(retcode); 1162 1163 case RAIDFRAME_GET_INFO: 1164 if (!raidPtr->valid) 1165 return (ENODEV); 1166 ucfgp = (RF_DeviceConfig_t **) data; 1167 RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t), 1168 (RF_DeviceConfig_t *)); 1169 if (d_cfg == NULL) 1170 return (ENOMEM); 1171 bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t)); 1172 d_cfg->rows = raidPtr->numRow; 1173 d_cfg->cols = raidPtr->numCol; 1174 d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol; 1175 if (d_cfg->ndevs >= RF_MAX_DISKS) { 1176 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1177 return (ENOMEM); 1178 } 1179 d_cfg->nspares = raidPtr->numSpare; 1180 if (d_cfg->nspares >= RF_MAX_DISKS) { 1181 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1182 return (ENOMEM); 1183 } 1184 d_cfg->maxqdepth = raidPtr->maxQueueDepth; 1185 d = 0; 1186 for (i = 0; i < d_cfg->rows; i++) { 1187 for (j = 0; j < d_cfg->cols; j++) { 1188 d_cfg->devs[d] = raidPtr->Disks[i][j]; 1189 d++; 1190 } 1191 } 1192 for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) { 1193 d_cfg->spares[i] = raidPtr->Disks[0][j]; 1194 } 1195 retcode = copyout((caddr_t) d_cfg, (caddr_t) * ucfgp, 1196 sizeof(RF_DeviceConfig_t)); 1197 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1198 1199 return (retcode); 1200 1201 case RAIDFRAME_CHECK_PARITY: 1202 *(int *) data = raidPtr->parity_good; 1203 return (0); 1204 1205 case RAIDFRAME_RESET_ACCTOTALS: 1206 bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals)); 1207 return (0); 1208 1209 case RAIDFRAME_GET_ACCTOTALS: 1210 totals = (RF_AccTotals_t *) data; 1211 *totals = raidPtr->acc_totals; 1212 return (0); 1213 1214 case RAIDFRAME_KEEP_ACCTOTALS: 1215 raidPtr->keep_acc_totals = *(int *)data; 1216 return (0); 1217 1218 case RAIDFRAME_GET_SIZE: 1219 *(int *) data = raidPtr->totalSectors; 1220 return (0); 1221 1222 /* fail a disk & optionally start reconstruction */ 1223 case RAIDFRAME_FAIL_DISK: 1224 1225 if (raidPtr->Layout.map->faultsTolerated == 0) { 1226 /* Can't do this on a RAID 0!! */ 1227 return(EINVAL); 1228 } 1229 1230 rr = (struct rf_recon_req *) data; 1231 1232 if (rr->row < 0 || rr->row >= raidPtr->numRow 1233 || rr->col < 0 || rr->col >= raidPtr->numCol) 1234 return (EINVAL); 1235 1236 printf("raid%d: Failing the disk: row: %d col: %d\n", 1237 unit, rr->row, rr->col); 1238 1239 /* make a copy of the recon request so that we don't rely on 1240 * the user's buffer */ 1241 RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); 1242 if (rrcopy == NULL) 1243 return(ENOMEM); 1244 bcopy(rr, rrcopy, sizeof(*rr)); 1245 rrcopy->raidPtr = (void *) raidPtr; 1246 1247 retcode = RF_CREATE_THREAD(raidPtr->recon_thread, 1248 rf_ReconThread, 1249 rrcopy,"raid_recon"); 1250 return (0); 1251 1252 /* invoke a copyback operation after recon on whatever disk 1253 * needs it, if any */ 1254 case RAIDFRAME_COPYBACK: 1255 1256 if (raidPtr->Layout.map->faultsTolerated == 0) { 1257 /* This makes no sense on a RAID 0!! */ 1258 return(EINVAL); 1259 } 1260 1261 if (raidPtr->copyback_in_progress == 1) { 1262 /* Copyback is already in progress! */ 1263 return(EINVAL); 1264 } 1265 1266 retcode = RF_CREATE_THREAD(raidPtr->copyback_thread, 1267 rf_CopybackThread, 1268 raidPtr,"raid_copyback"); 1269 return (retcode); 1270 1271 /* return the percentage completion of reconstruction */ 1272 case RAIDFRAME_CHECK_RECON_STATUS: 1273 if (raidPtr->Layout.map->faultsTolerated == 0) { 1274 /* This makes no sense on a RAID 0, so tell the 1275 user it's done. */ 1276 *(int *) data = 100; 1277 return(0); 1278 } 1279 row = 0; /* XXX we only consider a single row... */ 1280 if (raidPtr->status[row] != rf_rs_reconstructing) 1281 *(int *) data = 100; 1282 else 1283 *(int *) data = raidPtr->reconControl[row]->percentComplete; 1284 return (0); 1285 case RAIDFRAME_CHECK_RECON_STATUS_EXT: 1286 progressInfoPtr = (RF_ProgressInfo_t **) data; 1287 row = 0; /* XXX we only consider a single row... */ 1288 if (raidPtr->status[row] != rf_rs_reconstructing) { 1289 progressInfo.remaining = 0; 1290 progressInfo.completed = 100; 1291 progressInfo.total = 100; 1292 } else { 1293 progressInfo.total = 1294 raidPtr->reconControl[row]->numRUsTotal; 1295 progressInfo.completed = 1296 raidPtr->reconControl[row]->numRUsComplete; 1297 progressInfo.remaining = progressInfo.total - 1298 progressInfo.completed; 1299 } 1300 retcode = copyout((caddr_t) &progressInfo, 1301 (caddr_t) *progressInfoPtr, 1302 sizeof(RF_ProgressInfo_t)); 1303 return (retcode); 1304 1305 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS: 1306 if (raidPtr->Layout.map->faultsTolerated == 0) { 1307 /* This makes no sense on a RAID 0, so tell the 1308 user it's done. */ 1309 *(int *) data = 100; 1310 return(0); 1311 } 1312 if (raidPtr->parity_rewrite_in_progress == 1) { 1313 *(int *) data = 100 * 1314 raidPtr->parity_rewrite_stripes_done / 1315 raidPtr->Layout.numStripe; 1316 } else { 1317 *(int *) data = 100; 1318 } 1319 return (0); 1320 1321 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT: 1322 progressInfoPtr = (RF_ProgressInfo_t **) data; 1323 if (raidPtr->parity_rewrite_in_progress == 1) { 1324 progressInfo.total = raidPtr->Layout.numStripe; 1325 progressInfo.completed = 1326 raidPtr->parity_rewrite_stripes_done; 1327 progressInfo.remaining = progressInfo.total - 1328 progressInfo.completed; 1329 } else { 1330 progressInfo.remaining = 0; 1331 progressInfo.completed = 100; 1332 progressInfo.total = 100; 1333 } 1334 retcode = copyout((caddr_t) &progressInfo, 1335 (caddr_t) *progressInfoPtr, 1336 sizeof(RF_ProgressInfo_t)); 1337 return (retcode); 1338 1339 case RAIDFRAME_CHECK_COPYBACK_STATUS: 1340 if (raidPtr->Layout.map->faultsTolerated == 0) { 1341 /* This makes no sense on a RAID 0 */ 1342 *(int *) data = 100; 1343 return(0); 1344 } 1345 if (raidPtr->copyback_in_progress == 1) { 1346 *(int *) data = 100 * raidPtr->copyback_stripes_done / 1347 raidPtr->Layout.numStripe; 1348 } else { 1349 *(int *) data = 100; 1350 } 1351 return (0); 1352 1353 case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT: 1354 if (raidPtr->copyback_in_progress == 1) { 1355 progressInfo.total = raidPtr->Layout.numStripe; 1356 progressInfo.completed = 1357 raidPtr->parity_rewrite_stripes_done; 1358 progressInfo.remaining = progressInfo.total - 1359 progressInfo.completed; 1360 } else { 1361 progressInfo.remaining = 0; 1362 progressInfo.completed = 100; 1363 progressInfo.total = 100; 1364 } 1365 retcode = copyout((caddr_t) &progressInfo, 1366 (caddr_t) *progressInfoPtr, 1367 sizeof(RF_ProgressInfo_t)); 1368 return (retcode); 1369 1370 /* the sparetable daemon calls this to wait for the kernel to 1371 * need a spare table. this ioctl does not return until a 1372 * spare table is needed. XXX -- calling mpsleep here in the 1373 * ioctl code is almost certainly wrong and evil. -- XXX XXX 1374 * -- I should either compute the spare table in the kernel, 1375 * or have a different -- XXX XXX -- interface (a different 1376 * character device) for delivering the table -- XXX */ 1377 #if 0 1378 case RAIDFRAME_SPARET_WAIT: 1379 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1380 while (!rf_sparet_wait_queue) 1381 mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); 1382 waitreq = rf_sparet_wait_queue; 1383 rf_sparet_wait_queue = rf_sparet_wait_queue->next; 1384 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1385 1386 /* structure assignment */ 1387 *((RF_SparetWait_t *) data) = *waitreq; 1388 1389 RF_Free(waitreq, sizeof(*waitreq)); 1390 return (0); 1391 1392 /* wakes up a process waiting on SPARET_WAIT and puts an error 1393 * code in it that will cause the dameon to exit */ 1394 case RAIDFRAME_ABORT_SPARET_WAIT: 1395 RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); 1396 waitreq->fcol = -1; 1397 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1398 waitreq->next = rf_sparet_wait_queue; 1399 rf_sparet_wait_queue = waitreq; 1400 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1401 wakeup(&rf_sparet_wait_queue); 1402 return (0); 1403 1404 /* used by the spare table daemon to deliver a spare table 1405 * into the kernel */ 1406 case RAIDFRAME_SEND_SPARET: 1407 1408 /* install the spare table */ 1409 retcode = rf_SetSpareTable(raidPtr, *(void **) data); 1410 1411 /* respond to the requestor. the return status of the spare 1412 * table installation is passed in the "fcol" field */ 1413 RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); 1414 waitreq->fcol = retcode; 1415 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1416 waitreq->next = rf_sparet_resp_queue; 1417 rf_sparet_resp_queue = waitreq; 1418 wakeup(&rf_sparet_resp_queue); 1419 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1420 1421 return (retcode); 1422 #endif 1423 1424 default: 1425 break; /* fall through to the os-specific code below */ 1426 1427 } 1428 1429 if (!raidPtr->valid) 1430 return (EINVAL); 1431 1432 /* 1433 * Add support for "regular" device ioctls here. 1434 */ 1435 1436 switch (cmd) { 1437 case DIOCGDINFO: 1438 *(struct disklabel *) data = *(rs->sc_dkdev.dk_label); 1439 break; 1440 1441 case DIOCGPART: 1442 ((struct partinfo *) data)->disklab = rs->sc_dkdev.dk_label; 1443 ((struct partinfo *) data)->part = 1444 &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)]; 1445 break; 1446 1447 case DIOCWDINFO: 1448 case DIOCSDINFO: 1449 if ((error = raidlock(rs)) != 0) 1450 return (error); 1451 1452 rs->sc_flags |= RAIDF_LABELLING; 1453 1454 error = setdisklabel(rs->sc_dkdev.dk_label, 1455 (struct disklabel *) data, 0, rs->sc_dkdev.dk_cpulabel); 1456 if (error == 0) { 1457 if (cmd == DIOCWDINFO) 1458 error = writedisklabel(RAIDLABELDEV(dev), 1459 raidstrategy, rs->sc_dkdev.dk_label, 1460 rs->sc_dkdev.dk_cpulabel); 1461 } 1462 rs->sc_flags &= ~RAIDF_LABELLING; 1463 1464 raidunlock(rs); 1465 1466 if (error) 1467 return (error); 1468 break; 1469 1470 case DIOCWLABEL: 1471 if (*(int *) data != 0) 1472 rs->sc_flags |= RAIDF_WLABEL; 1473 else 1474 rs->sc_flags &= ~RAIDF_WLABEL; 1475 break; 1476 1477 case DIOCGDEFLABEL: 1478 raidgetdefaultlabel(raidPtr, rs, 1479 (struct disklabel *) data); 1480 break; 1481 1482 default: 1483 retcode = ENOTTY; 1484 } 1485 return (retcode); 1486 1487 } 1488 1489 1490 /* raidinit -- complete the rest of the initialization for the 1491 RAIDframe device. */ 1492 1493 1494 static void 1495 raidinit(raidPtr) 1496 RF_Raid_t *raidPtr; 1497 { 1498 struct raid_softc *rs; 1499 int unit; 1500 1501 unit = raidPtr->raidid; 1502 1503 rs = &raid_softc[unit]; 1504 pool_init(&rs->sc_cbufpool, sizeof(struct raidbuf), 0, 1505 0, 0, "raidpl", 0, NULL, NULL, M_RAIDFRAME); 1506 1507 1508 /* XXX should check return code first... */ 1509 rs->sc_flags |= RAIDF_INITED; 1510 1511 sprintf(rs->sc_xname, "raid%d", unit); /* XXX doesn't check bounds. */ 1512 1513 rs->sc_dkdev.dk_name = rs->sc_xname; 1514 1515 /* disk_attach actually creates space for the CPU disklabel, among 1516 * other things, so it's critical to call this *BEFORE* we try putzing 1517 * with disklabels. */ 1518 1519 disk_attach(&rs->sc_dkdev); 1520 1521 /* XXX There may be a weird interaction here between this, and 1522 * protectedSectors, as used in RAIDframe. */ 1523 1524 rs->sc_size = raidPtr->totalSectors; 1525 1526 } 1527 1528 /* wake up the daemon & tell it to get us a spare table 1529 * XXX 1530 * the entries in the queues should be tagged with the raidPtr 1531 * so that in the extremely rare case that two recons happen at once, 1532 * we know for which device were requesting a spare table 1533 * XXX 1534 * 1535 * XXX This code is not currently used. GO 1536 */ 1537 int 1538 rf_GetSpareTableFromDaemon(req) 1539 RF_SparetWait_t *req; 1540 { 1541 int retcode; 1542 1543 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1544 req->next = rf_sparet_wait_queue; 1545 rf_sparet_wait_queue = req; 1546 wakeup(&rf_sparet_wait_queue); 1547 1548 /* mpsleep unlocks the mutex */ 1549 while (!rf_sparet_resp_queue) { 1550 tsleep(&rf_sparet_resp_queue, PRIBIO, 1551 "raidframe getsparetable", 0); 1552 } 1553 req = rf_sparet_resp_queue; 1554 rf_sparet_resp_queue = req->next; 1555 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1556 1557 retcode = req->fcol; 1558 RF_Free(req, sizeof(*req)); /* this is not the same req as we 1559 * alloc'd */ 1560 return (retcode); 1561 } 1562 1563 /* a wrapper around rf_DoAccess that extracts appropriate info from the 1564 * bp & passes it down. 1565 * any calls originating in the kernel must use non-blocking I/O 1566 * do some extra sanity checking to return "appropriate" error values for 1567 * certain conditions (to make some standard utilities work) 1568 * 1569 * Formerly known as: rf_DoAccessKernel 1570 */ 1571 void 1572 raidstart(raidPtr) 1573 RF_Raid_t *raidPtr; 1574 { 1575 RF_SectorCount_t num_blocks, pb, sum; 1576 RF_RaidAddr_t raid_addr; 1577 int retcode; 1578 struct partition *pp; 1579 daddr_t blocknum; 1580 int unit; 1581 struct raid_softc *rs; 1582 int do_async; 1583 struct buf *bp; 1584 1585 unit = raidPtr->raidid; 1586 rs = &raid_softc[unit]; 1587 1588 /* quick check to see if anything has died recently */ 1589 RF_LOCK_MUTEX(raidPtr->mutex); 1590 if (raidPtr->numNewFailures > 0) { 1591 rf_update_component_labels(raidPtr, 1592 RF_NORMAL_COMPONENT_UPDATE); 1593 raidPtr->numNewFailures--; 1594 } 1595 RF_UNLOCK_MUTEX(raidPtr->mutex); 1596 1597 /* Check to see if we're at the limit... */ 1598 RF_LOCK_MUTEX(raidPtr->mutex); 1599 while (raidPtr->openings > 0) { 1600 RF_UNLOCK_MUTEX(raidPtr->mutex); 1601 1602 /* get the next item, if any, from the queue */ 1603 if ((bp = BUFQ_FIRST(&rs->buf_queue)) == NULL) { 1604 /* nothing more to do */ 1605 return; 1606 } 1607 BUFQ_REMOVE(&rs->buf_queue, bp); 1608 1609 /* Ok, for the bp we have here, bp->b_blkno is relative to the 1610 * partition.. Need to make it absolute to the underlying 1611 * device.. */ 1612 1613 blocknum = bp->b_blkno; 1614 if (DISKPART(bp->b_dev) != RAW_PART) { 1615 pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)]; 1616 blocknum += pp->p_offset; 1617 } 1618 1619 db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno, 1620 (int) blocknum)); 1621 1622 db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount)); 1623 db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid)); 1624 1625 /* *THIS* is where we adjust what block we're going to... 1626 * but DO NOT TOUCH bp->b_blkno!!! */ 1627 raid_addr = blocknum; 1628 1629 num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector; 1630 pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0; 1631 sum = raid_addr + num_blocks + pb; 1632 if (1 || rf_debugKernelAccess) { 1633 db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n", 1634 (int) raid_addr, (int) sum, (int) num_blocks, 1635 (int) pb, (int) bp->b_resid)); 1636 } 1637 if ((sum > raidPtr->totalSectors) || (sum < raid_addr) 1638 || (sum < num_blocks) || (sum < pb)) { 1639 bp->b_error = ENOSPC; 1640 bp->b_flags |= B_ERROR; 1641 bp->b_resid = bp->b_bcount; 1642 biodone(bp); 1643 RF_LOCK_MUTEX(raidPtr->mutex); 1644 continue; 1645 } 1646 /* 1647 * XXX rf_DoAccess() should do this, not just DoAccessKernel() 1648 */ 1649 1650 if (bp->b_bcount & raidPtr->sectorMask) { 1651 bp->b_error = EINVAL; 1652 bp->b_flags |= B_ERROR; 1653 bp->b_resid = bp->b_bcount; 1654 biodone(bp); 1655 RF_LOCK_MUTEX(raidPtr->mutex); 1656 continue; 1657 1658 } 1659 db1_printf(("Calling DoAccess..\n")); 1660 1661 1662 RF_LOCK_MUTEX(raidPtr->mutex); 1663 raidPtr->openings--; 1664 RF_UNLOCK_MUTEX(raidPtr->mutex); 1665 1666 /* 1667 * Everything is async. 1668 */ 1669 do_async = 1; 1670 1671 /* don't ever condition on bp->b_flags & B_WRITE. 1672 * always condition on B_READ instead */ 1673 1674 /* XXX we're still at splbio() here... do we *really* 1675 need to be? */ 1676 1677 1678 retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ? 1679 RF_IO_TYPE_READ : RF_IO_TYPE_WRITE, 1680 do_async, raid_addr, num_blocks, 1681 bp->b_data, bp, NULL, NULL, 1682 RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL); 1683 1684 1685 RF_LOCK_MUTEX(raidPtr->mutex); 1686 } 1687 RF_UNLOCK_MUTEX(raidPtr->mutex); 1688 } 1689 1690 1691 1692 1693 /* invoke an I/O from kernel mode. Disk queue should be locked upon entry */ 1694 1695 int 1696 rf_DispatchKernelIO(queue, req) 1697 RF_DiskQueue_t *queue; 1698 RF_DiskQueueData_t *req; 1699 { 1700 int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE; 1701 struct buf *bp; 1702 struct raidbuf *raidbp = NULL; 1703 struct raid_softc *rs; 1704 int unit; 1705 int s; 1706 1707 s=0; 1708 /* s = splbio();*/ /* want to test this */ 1709 /* XXX along with the vnode, we also need the softc associated with 1710 * this device.. */ 1711 1712 req->queue = queue; 1713 1714 unit = queue->raidPtr->raidid; 1715 1716 db1_printf(("DispatchKernelIO unit: %d\n", unit)); 1717 1718 if (unit >= numraid) { 1719 printf("Invalid unit number: %d %d\n", unit, numraid); 1720 panic("Invalid Unit number in rf_DispatchKernelIO\n"); 1721 } 1722 rs = &raid_softc[unit]; 1723 1724 /* XXX is this the right place? */ 1725 disk_busy(&rs->sc_dkdev); 1726 1727 bp = req->bp; 1728 #if 1 1729 /* XXX when there is a physical disk failure, someone is passing us a 1730 * buffer that contains old stuff!! Attempt to deal with this problem 1731 * without taking a performance hit... (not sure where the real bug 1732 * is. It's buried in RAIDframe somewhere) :-( GO ) */ 1733 1734 if (bp->b_flags & B_ERROR) { 1735 bp->b_flags &= ~B_ERROR; 1736 } 1737 if (bp->b_error != 0) { 1738 bp->b_error = 0; 1739 } 1740 #endif 1741 raidbp = RAIDGETBUF(rs); 1742 1743 raidbp->rf_flags = 0; /* XXX not really used anywhere... */ 1744 1745 /* 1746 * context for raidiodone 1747 */ 1748 raidbp->rf_obp = bp; 1749 raidbp->req = req; 1750 1751 LIST_INIT(&raidbp->rf_buf.b_dep); 1752 1753 switch (req->type) { 1754 case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */ 1755 /* XXX need to do something extra here.. */ 1756 /* I'm leaving this in, as I've never actually seen it used, 1757 * and I'd like folks to report it... GO */ 1758 printf(("WAKEUP CALLED\n")); 1759 queue->numOutstanding++; 1760 1761 /* XXX need to glue the original buffer into this?? */ 1762 1763 KernelWakeupFunc(&raidbp->rf_buf); 1764 break; 1765 1766 case RF_IO_TYPE_READ: 1767 case RF_IO_TYPE_WRITE: 1768 1769 if (req->tracerec) { 1770 RF_ETIMER_START(req->tracerec->timer); 1771 } 1772 InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp, 1773 op | bp->b_flags, queue->rf_cinfo->ci_dev, 1774 req->sectorOffset, req->numSector, 1775 req->buf, KernelWakeupFunc, (void *) req, 1776 queue->raidPtr->logBytesPerSector, req->b_proc); 1777 1778 if (rf_debugKernelAccess) { 1779 db1_printf(("dispatch: bp->b_blkno = %ld\n", 1780 (long) bp->b_blkno)); 1781 } 1782 queue->numOutstanding++; 1783 queue->last_deq_sector = req->sectorOffset; 1784 /* acc wouldn't have been let in if there were any pending 1785 * reqs at any other priority */ 1786 queue->curPriority = req->priority; 1787 1788 db1_printf(("Going for %c to unit %d row %d col %d\n", 1789 req->type, unit, queue->row, queue->col)); 1790 db1_printf(("sector %d count %d (%d bytes) %d\n", 1791 (int) req->sectorOffset, (int) req->numSector, 1792 (int) (req->numSector << 1793 queue->raidPtr->logBytesPerSector), 1794 (int) queue->raidPtr->logBytesPerSector)); 1795 if ((raidbp->rf_buf.b_flags & B_READ) == 0) { 1796 raidbp->rf_buf.b_vp->v_numoutput++; 1797 } 1798 VOP_STRATEGY(&raidbp->rf_buf); 1799 1800 break; 1801 1802 default: 1803 panic("bad req->type in rf_DispatchKernelIO"); 1804 } 1805 db1_printf(("Exiting from DispatchKernelIO\n")); 1806 /* splx(s); */ /* want to test this */ 1807 return (0); 1808 } 1809 /* this is the callback function associated with a I/O invoked from 1810 kernel code. 1811 */ 1812 static void 1813 KernelWakeupFunc(vbp) 1814 struct buf *vbp; 1815 { 1816 RF_DiskQueueData_t *req = NULL; 1817 RF_DiskQueue_t *queue; 1818 struct raidbuf *raidbp = (struct raidbuf *) vbp; 1819 struct buf *bp; 1820 struct raid_softc *rs; 1821 int unit; 1822 int s; 1823 1824 s = splbio(); 1825 db1_printf(("recovering the request queue:\n")); 1826 req = raidbp->req; 1827 1828 bp = raidbp->rf_obp; 1829 1830 queue = (RF_DiskQueue_t *) req->queue; 1831 1832 if (raidbp->rf_buf.b_flags & B_ERROR) { 1833 bp->b_flags |= B_ERROR; 1834 bp->b_error = raidbp->rf_buf.b_error ? 1835 raidbp->rf_buf.b_error : EIO; 1836 } 1837 1838 /* XXX methinks this could be wrong... */ 1839 #if 1 1840 bp->b_resid = raidbp->rf_buf.b_resid; 1841 #endif 1842 1843 if (req->tracerec) { 1844 RF_ETIMER_STOP(req->tracerec->timer); 1845 RF_ETIMER_EVAL(req->tracerec->timer); 1846 RF_LOCK_MUTEX(rf_tracing_mutex); 1847 req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer); 1848 req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer); 1849 req->tracerec->num_phys_ios++; 1850 RF_UNLOCK_MUTEX(rf_tracing_mutex); 1851 } 1852 bp->b_bcount = raidbp->rf_buf.b_bcount; /* XXXX ?? */ 1853 1854 unit = queue->raidPtr->raidid; /* *Much* simpler :-> */ 1855 1856 1857 /* XXX Ok, let's get aggressive... If B_ERROR is set, let's go 1858 * ballistic, and mark the component as hosed... */ 1859 1860 if (bp->b_flags & B_ERROR) { 1861 /* Mark the disk as dead */ 1862 /* but only mark it once... */ 1863 if (queue->raidPtr->Disks[queue->row][queue->col].status == 1864 rf_ds_optimal) { 1865 printf("raid%d: IO Error. Marking %s as failed.\n", 1866 unit, queue->raidPtr->Disks[queue->row][queue->col].devname); 1867 queue->raidPtr->Disks[queue->row][queue->col].status = 1868 rf_ds_failed; 1869 queue->raidPtr->status[queue->row] = rf_rs_degraded; 1870 queue->raidPtr->numFailures++; 1871 queue->raidPtr->numNewFailures++; 1872 } else { /* Disk is already dead... */ 1873 /* printf("Disk already marked as dead!\n"); */ 1874 } 1875 1876 } 1877 1878 rs = &raid_softc[unit]; 1879 RAIDPUTBUF(rs, raidbp); 1880 1881 1882 if (bp->b_resid == 0) { 1883 /* XXX is this the right place for a disk_unbusy()??!??!?!? */ 1884 disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid)); 1885 } 1886 1887 rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0); 1888 (req->CompleteFunc) (req->argument, (bp->b_flags & B_ERROR) ? 1 : 0); 1889 1890 splx(s); 1891 } 1892 1893 1894 1895 /* 1896 * initialize a buf structure for doing an I/O in the kernel. 1897 */ 1898 static void 1899 InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg, 1900 logBytesPerSector, b_proc) 1901 struct buf *bp; 1902 struct vnode *b_vp; 1903 unsigned rw_flag; 1904 dev_t dev; 1905 RF_SectorNum_t startSect; 1906 RF_SectorCount_t numSect; 1907 caddr_t buf; 1908 void (*cbFunc) (struct buf *); 1909 void *cbArg; 1910 int logBytesPerSector; 1911 struct proc *b_proc; 1912 { 1913 /* bp->b_flags = B_PHYS | rw_flag; */ 1914 bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too??? */ 1915 bp->b_bcount = numSect << logBytesPerSector; 1916 bp->b_bufsize = bp->b_bcount; 1917 bp->b_error = 0; 1918 bp->b_dev = dev; 1919 bp->b_data = buf; 1920 bp->b_blkno = startSect; 1921 bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */ 1922 if (bp->b_bcount == 0) { 1923 panic("bp->b_bcount is zero in InitBP!!\n"); 1924 } 1925 bp->b_proc = b_proc; 1926 bp->b_iodone = cbFunc; 1927 bp->b_vp = b_vp; 1928 1929 } 1930 1931 static void 1932 raidgetdefaultlabel(raidPtr, rs, lp) 1933 RF_Raid_t *raidPtr; 1934 struct raid_softc *rs; 1935 struct disklabel *lp; 1936 { 1937 db1_printf(("Building a default label...\n")); 1938 bzero(lp, sizeof(*lp)); 1939 1940 /* fabricate a label... */ 1941 lp->d_secperunit = raidPtr->totalSectors; 1942 lp->d_secsize = raidPtr->bytesPerSector; 1943 lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe; 1944 lp->d_ntracks = 1; 1945 lp->d_ncylinders = raidPtr->totalSectors / 1946 (lp->d_nsectors * lp->d_ntracks); 1947 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1948 1949 strncpy(lp->d_typename, "raid", sizeof(lp->d_typename)); 1950 lp->d_type = DTYPE_RAID; 1951 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 1952 lp->d_rpm = 3600; 1953 lp->d_interleave = 1; 1954 lp->d_flags = 0; 1955 1956 lp->d_partitions[RAW_PART].p_offset = 0; 1957 lp->d_partitions[RAW_PART].p_size = raidPtr->totalSectors; 1958 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 1959 lp->d_npartitions = RAW_PART + 1; 1960 1961 lp->d_magic = DISKMAGIC; 1962 lp->d_magic2 = DISKMAGIC; 1963 lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label); 1964 1965 } 1966 /* 1967 * Read the disklabel from the raid device. If one is not present, fake one 1968 * up. 1969 */ 1970 static void 1971 raidgetdisklabel(dev) 1972 dev_t dev; 1973 { 1974 int unit = raidunit(dev); 1975 struct raid_softc *rs = &raid_softc[unit]; 1976 char *errstring; 1977 struct disklabel *lp = rs->sc_dkdev.dk_label; 1978 struct cpu_disklabel *clp = rs->sc_dkdev.dk_cpulabel; 1979 RF_Raid_t *raidPtr; 1980 1981 db1_printf(("Getting the disklabel...\n")); 1982 1983 bzero(clp, sizeof(*clp)); 1984 1985 raidPtr = raidPtrs[unit]; 1986 1987 raidgetdefaultlabel(raidPtr, rs, lp); 1988 1989 /* 1990 * Call the generic disklabel extraction routine. 1991 */ 1992 errstring = readdisklabel(RAIDLABELDEV(dev), raidstrategy, 1993 rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel); 1994 if (errstring) 1995 raidmakedisklabel(rs); 1996 else { 1997 int i; 1998 struct partition *pp; 1999 2000 /* 2001 * Sanity check whether the found disklabel is valid. 2002 * 2003 * This is necessary since total size of the raid device 2004 * may vary when an interleave is changed even though exactly 2005 * same componets are used, and old disklabel may used 2006 * if that is found. 2007 */ 2008 if (lp->d_secperunit != rs->sc_size) 2009 printf("WARNING: %s: " 2010 "total sector size in disklabel (%d) != " 2011 "the size of raid (%ld)\n", rs->sc_xname, 2012 lp->d_secperunit, (long) rs->sc_size); 2013 for (i = 0; i < lp->d_npartitions; i++) { 2014 pp = &lp->d_partitions[i]; 2015 if (pp->p_offset + pp->p_size > rs->sc_size) 2016 printf("WARNING: %s: end of partition `%c' " 2017 "exceeds the size of raid (%ld)\n", 2018 rs->sc_xname, 'a' + i, (long) rs->sc_size); 2019 } 2020 } 2021 2022 } 2023 /* 2024 * Take care of things one might want to take care of in the event 2025 * that a disklabel isn't present. 2026 */ 2027 static void 2028 raidmakedisklabel(rs) 2029 struct raid_softc *rs; 2030 { 2031 struct disklabel *lp = rs->sc_dkdev.dk_label; 2032 db1_printf(("Making a label..\n")); 2033 2034 /* 2035 * For historical reasons, if there's no disklabel present 2036 * the raw partition must be marked FS_BSDFFS. 2037 */ 2038 2039 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 2040 2041 strncpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 2042 2043 lp->d_checksum = dkcksum(lp); 2044 } 2045 /* 2046 * Lookup the provided name in the filesystem. If the file exists, 2047 * is a valid block device, and isn't being used by anyone else, 2048 * set *vpp to the file's vnode. 2049 * You'll find the original of this in ccd.c 2050 */ 2051 int 2052 raidlookup(path, p, vpp) 2053 char *path; 2054 struct proc *p; 2055 struct vnode **vpp; /* result */ 2056 { 2057 struct nameidata nd; 2058 struct vnode *vp; 2059 struct vattr va; 2060 int error; 2061 2062 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p); 2063 if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { 2064 #ifdef DEBUG 2065 printf("RAIDframe: vn_open returned %d\n", error); 2066 #endif 2067 return (error); 2068 } 2069 vp = nd.ni_vp; 2070 if (vp->v_usecount > 1) { 2071 VOP_UNLOCK(vp, 0); 2072 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2073 return (EBUSY); 2074 } 2075 if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) { 2076 VOP_UNLOCK(vp, 0); 2077 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2078 return (error); 2079 } 2080 /* XXX: eventually we should handle VREG, too. */ 2081 if (va.va_type != VBLK) { 2082 VOP_UNLOCK(vp, 0); 2083 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2084 return (ENOTBLK); 2085 } 2086 VOP_UNLOCK(vp, 0); 2087 *vpp = vp; 2088 return (0); 2089 } 2090 /* 2091 * Wait interruptibly for an exclusive lock. 2092 * 2093 * XXX 2094 * Several drivers do this; it should be abstracted and made MP-safe. 2095 * (Hmm... where have we seen this warning before :-> GO ) 2096 */ 2097 static int 2098 raidlock(rs) 2099 struct raid_softc *rs; 2100 { 2101 int error; 2102 2103 while ((rs->sc_flags & RAIDF_LOCKED) != 0) { 2104 rs->sc_flags |= RAIDF_WANTED; 2105 if ((error = 2106 tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0) 2107 return (error); 2108 } 2109 rs->sc_flags |= RAIDF_LOCKED; 2110 return (0); 2111 } 2112 /* 2113 * Unlock and wake up any waiters. 2114 */ 2115 static void 2116 raidunlock(rs) 2117 struct raid_softc *rs; 2118 { 2119 2120 rs->sc_flags &= ~RAIDF_LOCKED; 2121 if ((rs->sc_flags & RAIDF_WANTED) != 0) { 2122 rs->sc_flags &= ~RAIDF_WANTED; 2123 wakeup(rs); 2124 } 2125 } 2126 2127 2128 #define RF_COMPONENT_INFO_OFFSET 16384 /* bytes */ 2129 #define RF_COMPONENT_INFO_SIZE 1024 /* bytes */ 2130 2131 int 2132 raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter) 2133 { 2134 RF_ComponentLabel_t clabel; 2135 raidread_component_label(dev, b_vp, &clabel); 2136 clabel.mod_counter = mod_counter; 2137 clabel.clean = RF_RAID_CLEAN; 2138 raidwrite_component_label(dev, b_vp, &clabel); 2139 return(0); 2140 } 2141 2142 2143 int 2144 raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter) 2145 { 2146 RF_ComponentLabel_t clabel; 2147 raidread_component_label(dev, b_vp, &clabel); 2148 clabel.mod_counter = mod_counter; 2149 clabel.clean = RF_RAID_DIRTY; 2150 raidwrite_component_label(dev, b_vp, &clabel); 2151 return(0); 2152 } 2153 2154 /* ARGSUSED */ 2155 int 2156 raidread_component_label(dev, b_vp, clabel) 2157 dev_t dev; 2158 struct vnode *b_vp; 2159 RF_ComponentLabel_t *clabel; 2160 { 2161 struct buf *bp; 2162 int error; 2163 2164 /* XXX should probably ensure that we don't try to do this if 2165 someone has changed rf_protected_sectors. */ 2166 2167 /* get a block of the appropriate size... */ 2168 bp = geteblk((int)RF_COMPONENT_INFO_SIZE); 2169 bp->b_dev = dev; 2170 2171 /* get our ducks in a row for the read */ 2172 bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; 2173 bp->b_bcount = RF_COMPONENT_INFO_SIZE; 2174 bp->b_flags = B_BUSY | B_READ; 2175 bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; 2176 2177 (*bdevsw[major(bp->b_dev)].d_strategy)(bp); 2178 2179 error = biowait(bp); 2180 2181 if (!error) { 2182 memcpy(clabel, bp->b_data, 2183 sizeof(RF_ComponentLabel_t)); 2184 #if 0 2185 rf_print_component_label( clabel ); 2186 #endif 2187 } else { 2188 #if 0 2189 printf("Failed to read RAID component label!\n"); 2190 #endif 2191 } 2192 2193 bp->b_flags = B_INVAL | B_AGE; 2194 brelse(bp); 2195 return(error); 2196 } 2197 /* ARGSUSED */ 2198 int 2199 raidwrite_component_label(dev, b_vp, clabel) 2200 dev_t dev; 2201 struct vnode *b_vp; 2202 RF_ComponentLabel_t *clabel; 2203 { 2204 struct buf *bp; 2205 int error; 2206 2207 /* get a block of the appropriate size... */ 2208 bp = geteblk((int)RF_COMPONENT_INFO_SIZE); 2209 bp->b_dev = dev; 2210 2211 /* get our ducks in a row for the write */ 2212 bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; 2213 bp->b_bcount = RF_COMPONENT_INFO_SIZE; 2214 bp->b_flags = B_BUSY | B_WRITE; 2215 bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; 2216 2217 memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE ); 2218 2219 memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t)); 2220 2221 (*bdevsw[major(bp->b_dev)].d_strategy)(bp); 2222 error = biowait(bp); 2223 bp->b_flags = B_INVAL | B_AGE; 2224 brelse(bp); 2225 if (error) { 2226 #if 1 2227 printf("Failed to write RAID component info!\n"); 2228 #endif 2229 } 2230 2231 return(error); 2232 } 2233 2234 void 2235 rf_markalldirty(raidPtr) 2236 RF_Raid_t *raidPtr; 2237 { 2238 RF_ComponentLabel_t clabel; 2239 int r,c; 2240 2241 raidPtr->mod_counter++; 2242 for (r = 0; r < raidPtr->numRow; r++) { 2243 for (c = 0; c < raidPtr->numCol; c++) { 2244 if (raidPtr->Disks[r][c].status != rf_ds_failed) { 2245 raidread_component_label( 2246 raidPtr->Disks[r][c].dev, 2247 raidPtr->raid_cinfo[r][c].ci_vp, 2248 &clabel); 2249 if (clabel.status == rf_ds_spared) { 2250 /* XXX do something special... 2251 but whatever you do, don't 2252 try to access it!! */ 2253 } else { 2254 #if 0 2255 clabel.status = 2256 raidPtr->Disks[r][c].status; 2257 raidwrite_component_label( 2258 raidPtr->Disks[r][c].dev, 2259 raidPtr->raid_cinfo[r][c].ci_vp, 2260 &clabel); 2261 #endif 2262 raidmarkdirty( 2263 raidPtr->Disks[r][c].dev, 2264 raidPtr->raid_cinfo[r][c].ci_vp, 2265 raidPtr->mod_counter); 2266 } 2267 } 2268 } 2269 } 2270 /* printf("Component labels marked dirty.\n"); */ 2271 #if 0 2272 for( c = 0; c < raidPtr->numSpare ; c++) { 2273 sparecol = raidPtr->numCol + c; 2274 if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) { 2275 /* 2276 2277 XXX this is where we get fancy and map this spare 2278 into it's correct spot in the array. 2279 2280 */ 2281 /* 2282 2283 we claim this disk is "optimal" if it's 2284 rf_ds_used_spare, as that means it should be 2285 directly substitutable for the disk it replaced. 2286 We note that too... 2287 2288 */ 2289 2290 for(i=0;i<raidPtr->numRow;i++) { 2291 for(j=0;j<raidPtr->numCol;j++) { 2292 if ((raidPtr->Disks[i][j].spareRow == 2293 r) && 2294 (raidPtr->Disks[i][j].spareCol == 2295 sparecol)) { 2296 srow = r; 2297 scol = sparecol; 2298 break; 2299 } 2300 } 2301 } 2302 2303 raidread_component_label( 2304 raidPtr->Disks[r][sparecol].dev, 2305 raidPtr->raid_cinfo[r][sparecol].ci_vp, 2306 &clabel); 2307 /* make sure status is noted */ 2308 clabel.version = RF_COMPONENT_LABEL_VERSION; 2309 clabel.mod_counter = raidPtr->mod_counter; 2310 clabel.serial_number = raidPtr->serial_number; 2311 clabel.row = srow; 2312 clabel.column = scol; 2313 clabel.num_rows = raidPtr->numRow; 2314 clabel.num_columns = raidPtr->numCol; 2315 clabel.clean = RF_RAID_DIRTY; /* changed in a bit*/ 2316 clabel.status = rf_ds_optimal; 2317 raidwrite_component_label( 2318 raidPtr->Disks[r][sparecol].dev, 2319 raidPtr->raid_cinfo[r][sparecol].ci_vp, 2320 &clabel); 2321 raidmarkclean( raidPtr->Disks[r][sparecol].dev, 2322 raidPtr->raid_cinfo[r][sparecol].ci_vp); 2323 } 2324 } 2325 2326 #endif 2327 } 2328 2329 2330 void 2331 rf_update_component_labels(raidPtr, final) 2332 RF_Raid_t *raidPtr; 2333 int final; 2334 { 2335 RF_ComponentLabel_t clabel; 2336 int sparecol; 2337 int r,c; 2338 int i,j; 2339 int srow, scol; 2340 2341 srow = -1; 2342 scol = -1; 2343 2344 /* XXX should do extra checks to make sure things really are clean, 2345 rather than blindly setting the clean bit... */ 2346 2347 raidPtr->mod_counter++; 2348 2349 for (r = 0; r < raidPtr->numRow; r++) { 2350 for (c = 0; c < raidPtr->numCol; c++) { 2351 if (raidPtr->Disks[r][c].status == rf_ds_optimal) { 2352 raidread_component_label( 2353 raidPtr->Disks[r][c].dev, 2354 raidPtr->raid_cinfo[r][c].ci_vp, 2355 &clabel); 2356 /* make sure status is noted */ 2357 clabel.status = rf_ds_optimal; 2358 /* bump the counter */ 2359 clabel.mod_counter = raidPtr->mod_counter; 2360 2361 raidwrite_component_label( 2362 raidPtr->Disks[r][c].dev, 2363 raidPtr->raid_cinfo[r][c].ci_vp, 2364 &clabel); 2365 if (final == RF_FINAL_COMPONENT_UPDATE) { 2366 if (raidPtr->parity_good == RF_RAID_CLEAN) { 2367 raidmarkclean( 2368 raidPtr->Disks[r][c].dev, 2369 raidPtr->raid_cinfo[r][c].ci_vp, 2370 raidPtr->mod_counter); 2371 } 2372 } 2373 } 2374 /* else we don't touch it.. */ 2375 } 2376 } 2377 2378 for( c = 0; c < raidPtr->numSpare ; c++) { 2379 sparecol = raidPtr->numCol + c; 2380 if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) { 2381 /* 2382 2383 we claim this disk is "optimal" if it's 2384 rf_ds_used_spare, as that means it should be 2385 directly substitutable for the disk it replaced. 2386 We note that too... 2387 2388 */ 2389 2390 for(i=0;i<raidPtr->numRow;i++) { 2391 for(j=0;j<raidPtr->numCol;j++) { 2392 if ((raidPtr->Disks[i][j].spareRow == 2393 0) && 2394 (raidPtr->Disks[i][j].spareCol == 2395 sparecol)) { 2396 srow = i; 2397 scol = j; 2398 break; 2399 } 2400 } 2401 } 2402 2403 /* XXX shouldn't *really* need this... */ 2404 raidread_component_label( 2405 raidPtr->Disks[0][sparecol].dev, 2406 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2407 &clabel); 2408 /* make sure status is noted */ 2409 2410 raid_init_component_label(raidPtr, &clabel); 2411 2412 clabel.mod_counter = raidPtr->mod_counter; 2413 clabel.row = srow; 2414 clabel.column = scol; 2415 clabel.status = rf_ds_optimal; 2416 2417 raidwrite_component_label( 2418 raidPtr->Disks[0][sparecol].dev, 2419 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2420 &clabel); 2421 if (final == RF_FINAL_COMPONENT_UPDATE) { 2422 if (raidPtr->parity_good == RF_RAID_CLEAN) { 2423 raidmarkclean( raidPtr->Disks[0][sparecol].dev, 2424 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2425 raidPtr->mod_counter); 2426 } 2427 } 2428 } 2429 } 2430 /* printf("Component labels updated\n"); */ 2431 } 2432 2433 void 2434 rf_close_component(raidPtr, vp, auto_configured) 2435 RF_Raid_t *raidPtr; 2436 struct vnode *vp; 2437 int auto_configured; 2438 { 2439 struct proc *p; 2440 2441 p = raidPtr->engine_thread; 2442 2443 if (vp != NULL) { 2444 if (auto_configured == 1) { 2445 VOP_CLOSE(vp, FREAD, NOCRED, 0); 2446 vput(vp); 2447 2448 } else { 2449 VOP_UNLOCK(vp, 0); 2450 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2451 } 2452 } else { 2453 printf("vnode was NULL\n"); 2454 } 2455 } 2456 2457 2458 void 2459 rf_UnconfigureVnodes(raidPtr) 2460 RF_Raid_t *raidPtr; 2461 { 2462 int r,c; 2463 struct proc *p; 2464 struct vnode *vp; 2465 int acd; 2466 2467 2468 /* We take this opportunity to close the vnodes like we should.. */ 2469 2470 p = raidPtr->engine_thread; 2471 2472 for (r = 0; r < raidPtr->numRow; r++) { 2473 for (c = 0; c < raidPtr->numCol; c++) { 2474 printf("Closing vnode for row: %d col: %d\n", r, c); 2475 vp = raidPtr->raid_cinfo[r][c].ci_vp; 2476 acd = raidPtr->Disks[r][c].auto_configured; 2477 rf_close_component(raidPtr, vp, acd); 2478 raidPtr->raid_cinfo[r][c].ci_vp = NULL; 2479 raidPtr->Disks[r][c].auto_configured = 0; 2480 } 2481 } 2482 for (r = 0; r < raidPtr->numSpare; r++) { 2483 printf("Closing vnode for spare: %d\n", r); 2484 vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp; 2485 acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured; 2486 rf_close_component(raidPtr, vp, acd); 2487 raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL; 2488 raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0; 2489 } 2490 } 2491 2492 2493 void 2494 rf_ReconThread(req) 2495 struct rf_recon_req *req; 2496 { 2497 int s; 2498 RF_Raid_t *raidPtr; 2499 2500 s = splbio(); 2501 raidPtr = (RF_Raid_t *) req->raidPtr; 2502 raidPtr->recon_in_progress = 1; 2503 2504 rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col, 2505 ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0)); 2506 2507 /* XXX get rid of this! we don't need it at all.. */ 2508 RF_Free(req, sizeof(*req)); 2509 2510 raidPtr->recon_in_progress = 0; 2511 splx(s); 2512 2513 /* That's all... */ 2514 kthread_exit(0); /* does not return */ 2515 } 2516 2517 void 2518 rf_RewriteParityThread(raidPtr) 2519 RF_Raid_t *raidPtr; 2520 { 2521 int retcode; 2522 int s; 2523 2524 raidPtr->parity_rewrite_in_progress = 1; 2525 s = splbio(); 2526 retcode = rf_RewriteParity(raidPtr); 2527 splx(s); 2528 if (retcode) { 2529 printf("raid%d: Error re-writing parity!\n",raidPtr->raidid); 2530 } else { 2531 /* set the clean bit! If we shutdown correctly, 2532 the clean bit on each component label will get 2533 set */ 2534 raidPtr->parity_good = RF_RAID_CLEAN; 2535 } 2536 raidPtr->parity_rewrite_in_progress = 0; 2537 2538 /* Anyone waiting for us to stop? If so, inform them... */ 2539 if (raidPtr->waitShutdown) { 2540 wakeup(&raidPtr->parity_rewrite_in_progress); 2541 } 2542 2543 /* That's all... */ 2544 kthread_exit(0); /* does not return */ 2545 } 2546 2547 2548 void 2549 rf_CopybackThread(raidPtr) 2550 RF_Raid_t *raidPtr; 2551 { 2552 int s; 2553 2554 raidPtr->copyback_in_progress = 1; 2555 s = splbio(); 2556 rf_CopybackReconstructedData(raidPtr); 2557 splx(s); 2558 raidPtr->copyback_in_progress = 0; 2559 2560 /* That's all... */ 2561 kthread_exit(0); /* does not return */ 2562 } 2563 2564 2565 void 2566 rf_ReconstructInPlaceThread(req) 2567 struct rf_recon_req *req; 2568 { 2569 int retcode; 2570 int s; 2571 RF_Raid_t *raidPtr; 2572 2573 s = splbio(); 2574 raidPtr = req->raidPtr; 2575 raidPtr->recon_in_progress = 1; 2576 retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col); 2577 RF_Free(req, sizeof(*req)); 2578 raidPtr->recon_in_progress = 0; 2579 splx(s); 2580 2581 /* That's all... */ 2582 kthread_exit(0); /* does not return */ 2583 } 2584 2585 void 2586 rf_mountroot_hook(dev) 2587 struct device *dev; 2588 { 2589 2590 } 2591 2592 2593 RF_AutoConfig_t * 2594 rf_find_raid_components() 2595 { 2596 struct devnametobdevmaj *dtobdm; 2597 struct vnode *vp; 2598 struct disklabel label; 2599 struct device *dv; 2600 char *cd_name; 2601 dev_t dev; 2602 int error; 2603 int i; 2604 int good_one; 2605 RF_ComponentLabel_t *clabel; 2606 RF_AutoConfig_t *ac_list; 2607 RF_AutoConfig_t *ac; 2608 2609 2610 /* initialize the AutoConfig list */ 2611 ac_list = NULL; 2612 2613 if (raidautoconfig) { 2614 2615 /* we begin by trolling through *all* the devices on the system */ 2616 2617 for (dv = alldevs.tqh_first; dv != NULL; 2618 dv = dv->dv_list.tqe_next) { 2619 2620 /* we are only interested in disks... */ 2621 if (dv->dv_class != DV_DISK) 2622 continue; 2623 2624 /* we don't care about floppies... */ 2625 if (!strcmp(dv->dv_cfdata->cf_driver->cd_name,"fd")) { 2626 continue; 2627 } 2628 2629 /* need to find the device_name_to_block_device_major stuff */ 2630 cd_name = dv->dv_cfdata->cf_driver->cd_name; 2631 dtobdm = dev_name2blk; 2632 while (dtobdm->d_name && strcmp(dtobdm->d_name, cd_name)) { 2633 dtobdm++; 2634 } 2635 2636 /* get a vnode for the raw partition of this disk */ 2637 2638 dev = MAKEDISKDEV(dtobdm->d_maj, dv->dv_unit, RAW_PART); 2639 if (bdevvp(dev, &vp)) 2640 panic("RAID can't alloc vnode"); 2641 2642 error = VOP_OPEN(vp, FREAD, NOCRED, 0); 2643 2644 if (error) { 2645 /* "Who cares." Continue looking 2646 for something that exists*/ 2647 vput(vp); 2648 continue; 2649 } 2650 2651 /* Ok, the disk exists. Go get the disklabel. */ 2652 error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label, 2653 FREAD, NOCRED, 0); 2654 if (error) { 2655 /* 2656 * XXX can't happen - open() would 2657 * have errored out (or faked up one) 2658 */ 2659 printf("can't get label for dev %s%c (%d)!?!?\n", 2660 dv->dv_xname, 'a' + RAW_PART, error); 2661 } 2662 2663 /* don't need this any more. We'll allocate it again 2664 a little later if we really do... */ 2665 VOP_CLOSE(vp, FREAD, NOCRED, 0); 2666 vput(vp); 2667 2668 for (i=0; i < label.d_npartitions; i++) { 2669 /* We only support partitions marked as RAID */ 2670 if (label.d_partitions[i].p_fstype != FS_RAID) 2671 continue; 2672 2673 dev = MAKEDISKDEV(dtobdm->d_maj, dv->dv_unit, i); 2674 if (bdevvp(dev, &vp)) 2675 panic("RAID can't alloc vnode"); 2676 2677 error = VOP_OPEN(vp, FREAD, NOCRED, 0); 2678 if (error) { 2679 /* Whatever... */ 2680 vput(vp); 2681 continue; 2682 } 2683 2684 good_one = 0; 2685 2686 clabel = (RF_ComponentLabel_t *) 2687 malloc(sizeof(RF_ComponentLabel_t), 2688 M_RAIDFRAME, M_NOWAIT); 2689 if (clabel == NULL) { 2690 /* XXX CLEANUP HERE */ 2691 printf("RAID auto config: out of memory!\n"); 2692 return(NULL); /* XXX probably should panic? */ 2693 } 2694 2695 if (!raidread_component_label(dev, vp, clabel)) { 2696 /* Got the label. Does it look reasonable? */ 2697 if (rf_reasonable_label(clabel) && 2698 (clabel->partitionSize <= 2699 label.d_partitions[i].p_size)) { 2700 #if DEBUG 2701 printf("Component on: %s%c: %d\n", 2702 dv->dv_xname, 'a'+i, 2703 label.d_partitions[i].p_size); 2704 rf_print_component_label(clabel); 2705 #endif 2706 /* if it's reasonable, add it, 2707 else ignore it. */ 2708 ac = (RF_AutoConfig_t *) 2709 malloc(sizeof(RF_AutoConfig_t), 2710 M_RAIDFRAME, 2711 M_NOWAIT); 2712 if (ac == NULL) { 2713 /* XXX should panic?? */ 2714 return(NULL); 2715 } 2716 2717 sprintf(ac->devname, "%s%c", 2718 dv->dv_xname, 'a'+i); 2719 ac->dev = dev; 2720 ac->vp = vp; 2721 ac->clabel = clabel; 2722 ac->next = ac_list; 2723 ac_list = ac; 2724 good_one = 1; 2725 } 2726 } 2727 if (!good_one) { 2728 /* cleanup */ 2729 free(clabel, M_RAIDFRAME); 2730 VOP_CLOSE(vp, FREAD, NOCRED, 0); 2731 vput(vp); 2732 } 2733 } 2734 } 2735 } 2736 return(ac_list); 2737 } 2738 2739 static int 2740 rf_reasonable_label(clabel) 2741 RF_ComponentLabel_t *clabel; 2742 { 2743 2744 if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) || 2745 (clabel->version==RF_COMPONENT_LABEL_VERSION)) && 2746 ((clabel->clean == RF_RAID_CLEAN) || 2747 (clabel->clean == RF_RAID_DIRTY)) && 2748 clabel->row >=0 && 2749 clabel->column >= 0 && 2750 clabel->num_rows > 0 && 2751 clabel->num_columns > 0 && 2752 clabel->row < clabel->num_rows && 2753 clabel->column < clabel->num_columns && 2754 clabel->blockSize > 0 && 2755 clabel->numBlocks > 0) { 2756 /* label looks reasonable enough... */ 2757 return(1); 2758 } 2759 return(0); 2760 } 2761 2762 2763 void 2764 rf_print_component_label(clabel) 2765 RF_ComponentLabel_t *clabel; 2766 { 2767 printf(" Row: %d Column: %d Num Rows: %d Num Columns: %d\n", 2768 clabel->row, clabel->column, 2769 clabel->num_rows, clabel->num_columns); 2770 printf(" Version: %d Serial Number: %d Mod Counter: %d\n", 2771 clabel->version, clabel->serial_number, 2772 clabel->mod_counter); 2773 printf(" Clean: %s Status: %d\n", 2774 clabel->clean ? "Yes" : "No", clabel->status ); 2775 printf(" sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n", 2776 clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU); 2777 printf(" RAID Level: %c blocksize: %d numBlocks: %d\n", 2778 (char) clabel->parityConfig, clabel->blockSize, 2779 clabel->numBlocks); 2780 printf(" Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No" ); 2781 printf(" Contains root partition: %s\n", 2782 clabel->root_partition ? "Yes" : "No" ); 2783 printf(" Last configured as: raid%d\n", clabel->last_unit ); 2784 #if 0 2785 printf(" Config order: %d\n", clabel->config_order); 2786 #endif 2787 2788 } 2789 2790 RF_ConfigSet_t * 2791 rf_create_auto_sets(ac_list) 2792 RF_AutoConfig_t *ac_list; 2793 { 2794 RF_AutoConfig_t *ac; 2795 RF_ConfigSet_t *config_sets; 2796 RF_ConfigSet_t *cset; 2797 RF_AutoConfig_t *ac_next; 2798 2799 2800 config_sets = NULL; 2801 2802 /* Go through the AutoConfig list, and figure out which components 2803 belong to what sets. */ 2804 ac = ac_list; 2805 while(ac!=NULL) { 2806 /* we're going to putz with ac->next, so save it here 2807 for use at the end of the loop */ 2808 ac_next = ac->next; 2809 2810 if (config_sets == NULL) { 2811 /* will need at least this one... */ 2812 config_sets = (RF_ConfigSet_t *) 2813 malloc(sizeof(RF_ConfigSet_t), 2814 M_RAIDFRAME, M_NOWAIT); 2815 if (config_sets == NULL) { 2816 panic("rf_create_auto_sets: No memory!\n"); 2817 } 2818 /* this one is easy :) */ 2819 config_sets->ac = ac; 2820 config_sets->next = NULL; 2821 config_sets->rootable = 0; 2822 ac->next = NULL; 2823 } else { 2824 /* which set does this component fit into? */ 2825 cset = config_sets; 2826 while(cset!=NULL) { 2827 if (rf_does_it_fit(cset, ac)) { 2828 /* looks like it matches... */ 2829 ac->next = cset->ac; 2830 cset->ac = ac; 2831 break; 2832 } 2833 cset = cset->next; 2834 } 2835 if (cset==NULL) { 2836 /* didn't find a match above... new set..*/ 2837 cset = (RF_ConfigSet_t *) 2838 malloc(sizeof(RF_ConfigSet_t), 2839 M_RAIDFRAME, M_NOWAIT); 2840 if (cset == NULL) { 2841 panic("rf_create_auto_sets: No memory!\n"); 2842 } 2843 cset->ac = ac; 2844 ac->next = NULL; 2845 cset->next = config_sets; 2846 cset->rootable = 0; 2847 config_sets = cset; 2848 } 2849 } 2850 ac = ac_next; 2851 } 2852 2853 2854 return(config_sets); 2855 } 2856 2857 static int 2858 rf_does_it_fit(cset, ac) 2859 RF_ConfigSet_t *cset; 2860 RF_AutoConfig_t *ac; 2861 { 2862 RF_ComponentLabel_t *clabel1, *clabel2; 2863 2864 /* If this one matches the *first* one in the set, that's good 2865 enough, since the other members of the set would have been 2866 through here too... */ 2867 /* note that we are not checking partitionSize here.. 2868 2869 Note that we are also not checking the mod_counters here. 2870 If everything else matches execpt the mod_counter, that's 2871 good enough for this test. We will deal with the mod_counters 2872 a little later in the autoconfiguration process. 2873 2874 (clabel1->mod_counter == clabel2->mod_counter) && 2875 2876 The reason we don't check for this is that failed disks 2877 will have lower modification counts. If those disks are 2878 not added to the set they used to belong to, then they will 2879 form their own set, which may result in 2 different sets, 2880 for example, competing to be configured at raid0, and 2881 perhaps competing to be the root filesystem set. If the 2882 wrong ones get configured, or both attempt to become /, 2883 weird behaviour and or serious lossage will occur. Thus we 2884 need to bring them into the fold here, and kick them out at 2885 a later point. 2886 2887 */ 2888 2889 clabel1 = cset->ac->clabel; 2890 clabel2 = ac->clabel; 2891 if ((clabel1->version == clabel2->version) && 2892 (clabel1->serial_number == clabel2->serial_number) && 2893 (clabel1->num_rows == clabel2->num_rows) && 2894 (clabel1->num_columns == clabel2->num_columns) && 2895 (clabel1->sectPerSU == clabel2->sectPerSU) && 2896 (clabel1->SUsPerPU == clabel2->SUsPerPU) && 2897 (clabel1->SUsPerRU == clabel2->SUsPerRU) && 2898 (clabel1->parityConfig == clabel2->parityConfig) && 2899 (clabel1->maxOutstanding == clabel2->maxOutstanding) && 2900 (clabel1->blockSize == clabel2->blockSize) && 2901 (clabel1->numBlocks == clabel2->numBlocks) && 2902 (clabel1->autoconfigure == clabel2->autoconfigure) && 2903 (clabel1->root_partition == clabel2->root_partition) && 2904 (clabel1->last_unit == clabel2->last_unit) && 2905 (clabel1->config_order == clabel2->config_order)) { 2906 /* if it get's here, it almost *has* to be a match */ 2907 } else { 2908 /* it's not consistent with somebody in the set.. 2909 punt */ 2910 return(0); 2911 } 2912 /* all was fine.. it must fit... */ 2913 return(1); 2914 } 2915 2916 int 2917 rf_have_enough_components(cset) 2918 RF_ConfigSet_t *cset; 2919 { 2920 RF_AutoConfig_t *ac; 2921 RF_AutoConfig_t *auto_config; 2922 RF_ComponentLabel_t *clabel; 2923 int r,c; 2924 int num_rows; 2925 int num_cols; 2926 int num_missing; 2927 int mod_counter; 2928 int mod_counter_found; 2929 int even_pair_failed; 2930 char parity_type; 2931 2932 2933 /* check to see that we have enough 'live' components 2934 of this set. If so, we can configure it if necessary */ 2935 2936 num_rows = cset->ac->clabel->num_rows; 2937 num_cols = cset->ac->clabel->num_columns; 2938 parity_type = cset->ac->clabel->parityConfig; 2939 2940 /* XXX Check for duplicate components!?!?!? */ 2941 2942 /* Determine what the mod_counter is supposed to be for this set. */ 2943 2944 mod_counter_found = 0; 2945 ac = cset->ac; 2946 while(ac!=NULL) { 2947 if (mod_counter_found==0) { 2948 mod_counter = ac->clabel->mod_counter; 2949 mod_counter_found = 1; 2950 } else { 2951 if (ac->clabel->mod_counter > mod_counter) { 2952 mod_counter = ac->clabel->mod_counter; 2953 } 2954 } 2955 ac = ac->next; 2956 } 2957 2958 num_missing = 0; 2959 auto_config = cset->ac; 2960 2961 for(r=0; r<num_rows; r++) { 2962 even_pair_failed = 0; 2963 for(c=0; c<num_cols; c++) { 2964 ac = auto_config; 2965 while(ac!=NULL) { 2966 if ((ac->clabel->row == r) && 2967 (ac->clabel->column == c) && 2968 (ac->clabel->mod_counter == mod_counter)) { 2969 /* it's this one... */ 2970 #if DEBUG 2971 printf("Found: %s at %d,%d\n", 2972 ac->devname,r,c); 2973 #endif 2974 break; 2975 } 2976 ac=ac->next; 2977 } 2978 if (ac==NULL) { 2979 /* Didn't find one here! */ 2980 /* special case for RAID 1, especially 2981 where there are more than 2 2982 components (where RAIDframe treats 2983 things a little differently :( ) */ 2984 if (parity_type == '1') { 2985 if (c%2 == 0) { /* even component */ 2986 even_pair_failed = 1; 2987 } else { /* odd component. If 2988 we're failed, and 2989 so is the even 2990 component, it's 2991 "Good Night, Charlie" */ 2992 if (even_pair_failed == 1) { 2993 return(0); 2994 } 2995 } 2996 } else { 2997 /* normal accounting */ 2998 num_missing++; 2999 } 3000 } 3001 if ((parity_type == '1') && (c%2 == 1)) { 3002 /* Just did an even component, and we didn't 3003 bail.. reset the even_pair_failed flag, 3004 and go on to the next component.... */ 3005 even_pair_failed = 0; 3006 } 3007 } 3008 } 3009 3010 clabel = cset->ac->clabel; 3011 3012 if (((clabel->parityConfig == '0') && (num_missing > 0)) || 3013 ((clabel->parityConfig == '4') && (num_missing > 1)) || 3014 ((clabel->parityConfig == '5') && (num_missing > 1))) { 3015 /* XXX this needs to be made *much* more general */ 3016 /* Too many failures */ 3017 return(0); 3018 } 3019 /* otherwise, all is well, and we've got enough to take a kick 3020 at autoconfiguring this set */ 3021 return(1); 3022 } 3023 3024 void 3025 rf_create_configuration(ac,config,raidPtr) 3026 RF_AutoConfig_t *ac; 3027 RF_Config_t *config; 3028 RF_Raid_t *raidPtr; 3029 { 3030 RF_ComponentLabel_t *clabel; 3031 int i; 3032 3033 clabel = ac->clabel; 3034 3035 /* 1. Fill in the common stuff */ 3036 config->numRow = clabel->num_rows; 3037 config->numCol = clabel->num_columns; 3038 config->numSpare = 0; /* XXX should this be set here? */ 3039 config->sectPerSU = clabel->sectPerSU; 3040 config->SUsPerPU = clabel->SUsPerPU; 3041 config->SUsPerRU = clabel->SUsPerRU; 3042 config->parityConfig = clabel->parityConfig; 3043 /* XXX... */ 3044 strcpy(config->diskQueueType,"fifo"); 3045 config->maxOutstandingDiskReqs = clabel->maxOutstanding; 3046 config->layoutSpecificSize = 0; /* XXX ?? */ 3047 3048 while(ac!=NULL) { 3049 /* row/col values will be in range due to the checks 3050 in reasonable_label() */ 3051 strcpy(config->devnames[ac->clabel->row][ac->clabel->column], 3052 ac->devname); 3053 ac = ac->next; 3054 } 3055 3056 for(i=0;i<RF_MAXDBGV;i++) { 3057 config->debugVars[i][0] = NULL; 3058 } 3059 } 3060 3061 int 3062 rf_set_autoconfig(raidPtr, new_value) 3063 RF_Raid_t *raidPtr; 3064 int new_value; 3065 { 3066 RF_ComponentLabel_t clabel; 3067 struct vnode *vp; 3068 dev_t dev; 3069 int row, column; 3070 3071 raidPtr->autoconfigure = new_value; 3072 for(row=0; row<raidPtr->numRow; row++) { 3073 for(column=0; column<raidPtr->numCol; column++) { 3074 if (raidPtr->Disks[row][column].status == 3075 rf_ds_optimal) { 3076 dev = raidPtr->Disks[row][column].dev; 3077 vp = raidPtr->raid_cinfo[row][column].ci_vp; 3078 raidread_component_label(dev, vp, &clabel); 3079 clabel.autoconfigure = new_value; 3080 raidwrite_component_label(dev, vp, &clabel); 3081 } 3082 } 3083 } 3084 return(new_value); 3085 } 3086 3087 int 3088 rf_set_rootpartition(raidPtr, new_value) 3089 RF_Raid_t *raidPtr; 3090 int new_value; 3091 { 3092 RF_ComponentLabel_t clabel; 3093 struct vnode *vp; 3094 dev_t dev; 3095 int row, column; 3096 3097 raidPtr->root_partition = new_value; 3098 for(row=0; row<raidPtr->numRow; row++) { 3099 for(column=0; column<raidPtr->numCol; column++) { 3100 if (raidPtr->Disks[row][column].status == 3101 rf_ds_optimal) { 3102 dev = raidPtr->Disks[row][column].dev; 3103 vp = raidPtr->raid_cinfo[row][column].ci_vp; 3104 raidread_component_label(dev, vp, &clabel); 3105 clabel.root_partition = new_value; 3106 raidwrite_component_label(dev, vp, &clabel); 3107 } 3108 } 3109 } 3110 return(new_value); 3111 } 3112 3113 void 3114 rf_release_all_vps(cset) 3115 RF_ConfigSet_t *cset; 3116 { 3117 RF_AutoConfig_t *ac; 3118 3119 ac = cset->ac; 3120 while(ac!=NULL) { 3121 /* Close the vp, and give it back */ 3122 if (ac->vp) { 3123 VOP_CLOSE(ac->vp, FREAD, NOCRED, 0); 3124 vput(ac->vp); 3125 ac->vp = NULL; 3126 } 3127 ac = ac->next; 3128 } 3129 } 3130 3131 3132 void 3133 rf_cleanup_config_set(cset) 3134 RF_ConfigSet_t *cset; 3135 { 3136 RF_AutoConfig_t *ac; 3137 RF_AutoConfig_t *next_ac; 3138 3139 ac = cset->ac; 3140 while(ac!=NULL) { 3141 next_ac = ac->next; 3142 /* nuke the label */ 3143 free(ac->clabel, M_RAIDFRAME); 3144 /* cleanup the config structure */ 3145 free(ac, M_RAIDFRAME); 3146 /* "next.." */ 3147 ac = next_ac; 3148 } 3149 /* and, finally, nuke the config set */ 3150 free(cset, M_RAIDFRAME); 3151 } 3152 3153 3154 void 3155 raid_init_component_label(raidPtr, clabel) 3156 RF_Raid_t *raidPtr; 3157 RF_ComponentLabel_t *clabel; 3158 { 3159 /* current version number */ 3160 clabel->version = RF_COMPONENT_LABEL_VERSION; 3161 clabel->serial_number = raidPtr->serial_number; 3162 clabel->mod_counter = raidPtr->mod_counter; 3163 clabel->num_rows = raidPtr->numRow; 3164 clabel->num_columns = raidPtr->numCol; 3165 clabel->clean = RF_RAID_DIRTY; /* not clean */ 3166 clabel->status = rf_ds_optimal; /* "It's good!" */ 3167 3168 clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit; 3169 clabel->SUsPerPU = raidPtr->Layout.SUsPerPU; 3170 clabel->SUsPerRU = raidPtr->Layout.SUsPerRU; 3171 3172 clabel->blockSize = raidPtr->bytesPerSector; 3173 clabel->numBlocks = raidPtr->sectorsPerDisk; 3174 3175 /* XXX not portable */ 3176 clabel->parityConfig = raidPtr->Layout.map->parityConfig; 3177 clabel->maxOutstanding = raidPtr->maxOutstanding; 3178 clabel->autoconfigure = raidPtr->autoconfigure; 3179 clabel->root_partition = raidPtr->root_partition; 3180 clabel->last_unit = raidPtr->raidid; 3181 clabel->config_order = raidPtr->config_order; 3182 } 3183 3184 int 3185 rf_auto_config_set(cset,unit) 3186 RF_ConfigSet_t *cset; 3187 int *unit; 3188 { 3189 RF_Raid_t *raidPtr; 3190 RF_Config_t *config; 3191 int raidID; 3192 int retcode; 3193 3194 printf("RAID autoconfigure\n"); 3195 3196 retcode = 0; 3197 *unit = -1; 3198 3199 /* 1. Create a config structure */ 3200 3201 config = (RF_Config_t *)malloc(sizeof(RF_Config_t), 3202 M_RAIDFRAME, 3203 M_NOWAIT); 3204 if (config==NULL) { 3205 printf("Out of mem!?!?\n"); 3206 /* XXX do something more intelligent here. */ 3207 return(1); 3208 } 3209 3210 memset(config, 0, sizeof(RF_Config_t)); 3211 3212 /* XXX raidID needs to be set correctly.. */ 3213 3214 /* 3215 2. Figure out what RAID ID this one is supposed to live at 3216 See if we can get the same RAID dev that it was configured 3217 on last time.. 3218 */ 3219 3220 raidID = cset->ac->clabel->last_unit; 3221 if ((raidID < 0) || (raidID >= numraid)) { 3222 /* let's not wander off into lala land. */ 3223 raidID = numraid - 1; 3224 } 3225 if (raidPtrs[raidID]->valid != 0) { 3226 3227 /* 3228 Nope... Go looking for an alternative... 3229 Start high so we don't immediately use raid0 if that's 3230 not taken. 3231 */ 3232 3233 for(raidID = numraid; raidID >= 0; raidID--) { 3234 if (raidPtrs[raidID]->valid == 0) { 3235 /* can use this one! */ 3236 break; 3237 } 3238 } 3239 } 3240 3241 if (raidID < 0) { 3242 /* punt... */ 3243 printf("Unable to auto configure this set!\n"); 3244 printf("(Out of RAID devs!)\n"); 3245 return(1); 3246 } 3247 printf("Configuring raid%d:\n",raidID); 3248 raidPtr = raidPtrs[raidID]; 3249 3250 /* XXX all this stuff should be done SOMEWHERE ELSE! */ 3251 raidPtr->raidid = raidID; 3252 raidPtr->openings = RAIDOUTSTANDING; 3253 3254 /* 3. Build the configuration structure */ 3255 rf_create_configuration(cset->ac, config, raidPtr); 3256 3257 /* 4. Do the configuration */ 3258 retcode = rf_Configure(raidPtr, config, cset->ac); 3259 3260 if (retcode == 0) { 3261 3262 raidinit(raidPtrs[raidID]); 3263 3264 rf_markalldirty(raidPtrs[raidID]); 3265 raidPtrs[raidID]->autoconfigure = 1; /* XXX do this here? */ 3266 if (cset->ac->clabel->root_partition==1) { 3267 /* everything configured just fine. Make a note 3268 that this set is eligible to be root. */ 3269 cset->rootable = 1; 3270 /* XXX do this here? */ 3271 raidPtrs[raidID]->root_partition = 1; 3272 } 3273 } 3274 3275 /* 5. Cleanup */ 3276 free(config, M_RAIDFRAME); 3277 3278 *unit = raidID; 3279 return(retcode); 3280 } 3281
Indexes created Tue Sep 30 17:09:57 GMT 2025