rf_netbsdkintf.c revision 1.98
1 /* $NetBSD: rf_netbsdkintf.c,v 1.98 2000/10/17 03:39:41 oster 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 if (!RF_DEAD_DISK(diskPtr->status)) { 1063 ci_label.partitionSize = diskPtr->partitionSize; 1064 ci_label.column = column; 1065 raidwrite_component_label( 1066 raidPtr->Disks[row][column].dev, 1067 raidPtr->raid_cinfo[row][column].ci_vp, 1068 &ci_label ); 1069 } 1070 } 1071 } 1072 1073 return (retcode); 1074 case RAIDFRAME_SET_AUTOCONFIG: 1075 d = rf_set_autoconfig(raidPtr, *(int *) data); 1076 printf("New autoconfig value is: %d\n", d); 1077 *(int *) data = d; 1078 return (retcode); 1079 1080 case RAIDFRAME_SET_ROOT: 1081 d = rf_set_rootpartition(raidPtr, *(int *) data); 1082 printf("New rootpartition value is: %d\n", d); 1083 *(int *) data = d; 1084 return (retcode); 1085 1086 /* initialize all parity */ 1087 case RAIDFRAME_REWRITEPARITY: 1088 1089 if (raidPtr->Layout.map->faultsTolerated == 0) { 1090 /* Parity for RAID 0 is trivially correct */ 1091 raidPtr->parity_good = RF_RAID_CLEAN; 1092 return(0); 1093 } 1094 1095 if (raidPtr->parity_rewrite_in_progress == 1) { 1096 /* Re-write is already in progress! */ 1097 return(EINVAL); 1098 } 1099 1100 retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread, 1101 rf_RewriteParityThread, 1102 raidPtr,"raid_parity"); 1103 return (retcode); 1104 1105 1106 case RAIDFRAME_ADD_HOT_SPARE: 1107 sparePtr = (RF_SingleComponent_t *) data; 1108 memcpy( &hot_spare, sparePtr, sizeof(RF_SingleComponent_t)); 1109 retcode = rf_add_hot_spare(raidPtr, &hot_spare); 1110 return(retcode); 1111 1112 case RAIDFRAME_REMOVE_HOT_SPARE: 1113 return(retcode); 1114 1115 case RAIDFRAME_DELETE_COMPONENT: 1116 componentPtr = (RF_SingleComponent_t *)data; 1117 memcpy( &component, componentPtr, 1118 sizeof(RF_SingleComponent_t)); 1119 retcode = rf_delete_component(raidPtr, &component); 1120 return(retcode); 1121 1122 case RAIDFRAME_INCORPORATE_HOT_SPARE: 1123 componentPtr = (RF_SingleComponent_t *)data; 1124 memcpy( &component, componentPtr, 1125 sizeof(RF_SingleComponent_t)); 1126 retcode = rf_incorporate_hot_spare(raidPtr, &component); 1127 return(retcode); 1128 1129 case RAIDFRAME_REBUILD_IN_PLACE: 1130 1131 if (raidPtr->Layout.map->faultsTolerated == 0) { 1132 /* Can't do this on a RAID 0!! */ 1133 return(EINVAL); 1134 } 1135 1136 if (raidPtr->recon_in_progress == 1) { 1137 /* a reconstruct is already in progress! */ 1138 return(EINVAL); 1139 } 1140 1141 componentPtr = (RF_SingleComponent_t *) data; 1142 memcpy( &component, componentPtr, 1143 sizeof(RF_SingleComponent_t)); 1144 row = component.row; 1145 column = component.column; 1146 printf("Rebuild: %d %d\n",row, column); 1147 if ((row < 0) || (row >= raidPtr->numRow) || 1148 (column < 0) || (column >= raidPtr->numCol)) { 1149 return(EINVAL); 1150 } 1151 1152 RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); 1153 if (rrcopy == NULL) 1154 return(ENOMEM); 1155 1156 rrcopy->raidPtr = (void *) raidPtr; 1157 rrcopy->row = row; 1158 rrcopy->col = column; 1159 1160 retcode = RF_CREATE_THREAD(raidPtr->recon_thread, 1161 rf_ReconstructInPlaceThread, 1162 rrcopy,"raid_reconip"); 1163 return(retcode); 1164 1165 case RAIDFRAME_GET_INFO: 1166 if (!raidPtr->valid) 1167 return (ENODEV); 1168 ucfgp = (RF_DeviceConfig_t **) data; 1169 RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t), 1170 (RF_DeviceConfig_t *)); 1171 if (d_cfg == NULL) 1172 return (ENOMEM); 1173 bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t)); 1174 d_cfg->rows = raidPtr->numRow; 1175 d_cfg->cols = raidPtr->numCol; 1176 d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol; 1177 if (d_cfg->ndevs >= RF_MAX_DISKS) { 1178 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1179 return (ENOMEM); 1180 } 1181 d_cfg->nspares = raidPtr->numSpare; 1182 if (d_cfg->nspares >= RF_MAX_DISKS) { 1183 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1184 return (ENOMEM); 1185 } 1186 d_cfg->maxqdepth = raidPtr->maxQueueDepth; 1187 d = 0; 1188 for (i = 0; i < d_cfg->rows; i++) { 1189 for (j = 0; j < d_cfg->cols; j++) { 1190 d_cfg->devs[d] = raidPtr->Disks[i][j]; 1191 d++; 1192 } 1193 } 1194 for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) { 1195 d_cfg->spares[i] = raidPtr->Disks[0][j]; 1196 } 1197 retcode = copyout((caddr_t) d_cfg, (caddr_t) * ucfgp, 1198 sizeof(RF_DeviceConfig_t)); 1199 RF_Free(d_cfg, sizeof(RF_DeviceConfig_t)); 1200 1201 return (retcode); 1202 1203 case RAIDFRAME_CHECK_PARITY: 1204 *(int *) data = raidPtr->parity_good; 1205 return (0); 1206 1207 case RAIDFRAME_RESET_ACCTOTALS: 1208 bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals)); 1209 return (0); 1210 1211 case RAIDFRAME_GET_ACCTOTALS: 1212 totals = (RF_AccTotals_t *) data; 1213 *totals = raidPtr->acc_totals; 1214 return (0); 1215 1216 case RAIDFRAME_KEEP_ACCTOTALS: 1217 raidPtr->keep_acc_totals = *(int *)data; 1218 return (0); 1219 1220 case RAIDFRAME_GET_SIZE: 1221 *(int *) data = raidPtr->totalSectors; 1222 return (0); 1223 1224 /* fail a disk & optionally start reconstruction */ 1225 case RAIDFRAME_FAIL_DISK: 1226 1227 if (raidPtr->Layout.map->faultsTolerated == 0) { 1228 /* Can't do this on a RAID 0!! */ 1229 return(EINVAL); 1230 } 1231 1232 rr = (struct rf_recon_req *) data; 1233 1234 if (rr->row < 0 || rr->row >= raidPtr->numRow 1235 || rr->col < 0 || rr->col >= raidPtr->numCol) 1236 return (EINVAL); 1237 1238 printf("raid%d: Failing the disk: row: %d col: %d\n", 1239 unit, rr->row, rr->col); 1240 1241 /* make a copy of the recon request so that we don't rely on 1242 * the user's buffer */ 1243 RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); 1244 if (rrcopy == NULL) 1245 return(ENOMEM); 1246 bcopy(rr, rrcopy, sizeof(*rr)); 1247 rrcopy->raidPtr = (void *) raidPtr; 1248 1249 retcode = RF_CREATE_THREAD(raidPtr->recon_thread, 1250 rf_ReconThread, 1251 rrcopy,"raid_recon"); 1252 return (0); 1253 1254 /* invoke a copyback operation after recon on whatever disk 1255 * needs it, if any */ 1256 case RAIDFRAME_COPYBACK: 1257 1258 if (raidPtr->Layout.map->faultsTolerated == 0) { 1259 /* This makes no sense on a RAID 0!! */ 1260 return(EINVAL); 1261 } 1262 1263 if (raidPtr->copyback_in_progress == 1) { 1264 /* Copyback is already in progress! */ 1265 return(EINVAL); 1266 } 1267 1268 retcode = RF_CREATE_THREAD(raidPtr->copyback_thread, 1269 rf_CopybackThread, 1270 raidPtr,"raid_copyback"); 1271 return (retcode); 1272 1273 /* return the percentage completion of reconstruction */ 1274 case RAIDFRAME_CHECK_RECON_STATUS: 1275 if (raidPtr->Layout.map->faultsTolerated == 0) { 1276 /* This makes no sense on a RAID 0, so tell the 1277 user it's done. */ 1278 *(int *) data = 100; 1279 return(0); 1280 } 1281 row = 0; /* XXX we only consider a single row... */ 1282 if (raidPtr->status[row] != rf_rs_reconstructing) 1283 *(int *) data = 100; 1284 else 1285 *(int *) data = raidPtr->reconControl[row]->percentComplete; 1286 return (0); 1287 case RAIDFRAME_CHECK_RECON_STATUS_EXT: 1288 progressInfoPtr = (RF_ProgressInfo_t **) data; 1289 row = 0; /* XXX we only consider a single row... */ 1290 if (raidPtr->status[row] != rf_rs_reconstructing) { 1291 progressInfo.remaining = 0; 1292 progressInfo.completed = 100; 1293 progressInfo.total = 100; 1294 } else { 1295 progressInfo.total = 1296 raidPtr->reconControl[row]->numRUsTotal; 1297 progressInfo.completed = 1298 raidPtr->reconControl[row]->numRUsComplete; 1299 progressInfo.remaining = progressInfo.total - 1300 progressInfo.completed; 1301 } 1302 retcode = copyout((caddr_t) &progressInfo, 1303 (caddr_t) *progressInfoPtr, 1304 sizeof(RF_ProgressInfo_t)); 1305 return (retcode); 1306 1307 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS: 1308 if (raidPtr->Layout.map->faultsTolerated == 0) { 1309 /* This makes no sense on a RAID 0, so tell the 1310 user it's done. */ 1311 *(int *) data = 100; 1312 return(0); 1313 } 1314 if (raidPtr->parity_rewrite_in_progress == 1) { 1315 *(int *) data = 100 * 1316 raidPtr->parity_rewrite_stripes_done / 1317 raidPtr->Layout.numStripe; 1318 } else { 1319 *(int *) data = 100; 1320 } 1321 return (0); 1322 1323 case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT: 1324 progressInfoPtr = (RF_ProgressInfo_t **) data; 1325 if (raidPtr->parity_rewrite_in_progress == 1) { 1326 progressInfo.total = raidPtr->Layout.numStripe; 1327 progressInfo.completed = 1328 raidPtr->parity_rewrite_stripes_done; 1329 progressInfo.remaining = progressInfo.total - 1330 progressInfo.completed; 1331 } else { 1332 progressInfo.remaining = 0; 1333 progressInfo.completed = 100; 1334 progressInfo.total = 100; 1335 } 1336 retcode = copyout((caddr_t) &progressInfo, 1337 (caddr_t) *progressInfoPtr, 1338 sizeof(RF_ProgressInfo_t)); 1339 return (retcode); 1340 1341 case RAIDFRAME_CHECK_COPYBACK_STATUS: 1342 if (raidPtr->Layout.map->faultsTolerated == 0) { 1343 /* This makes no sense on a RAID 0 */ 1344 *(int *) data = 100; 1345 return(0); 1346 } 1347 if (raidPtr->copyback_in_progress == 1) { 1348 *(int *) data = 100 * raidPtr->copyback_stripes_done / 1349 raidPtr->Layout.numStripe; 1350 } else { 1351 *(int *) data = 100; 1352 } 1353 return (0); 1354 1355 case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT: 1356 progressInfoPtr = (RF_ProgressInfo_t **) data; 1357 if (raidPtr->copyback_in_progress == 1) { 1358 progressInfo.total = raidPtr->Layout.numStripe; 1359 progressInfo.completed = 1360 raidPtr->copyback_stripes_done; 1361 progressInfo.remaining = progressInfo.total - 1362 progressInfo.completed; 1363 } else { 1364 progressInfo.remaining = 0; 1365 progressInfo.completed = 100; 1366 progressInfo.total = 100; 1367 } 1368 retcode = copyout((caddr_t) &progressInfo, 1369 (caddr_t) *progressInfoPtr, 1370 sizeof(RF_ProgressInfo_t)); 1371 return (retcode); 1372 1373 /* the sparetable daemon calls this to wait for the kernel to 1374 * need a spare table. this ioctl does not return until a 1375 * spare table is needed. XXX -- calling mpsleep here in the 1376 * ioctl code is almost certainly wrong and evil. -- XXX XXX 1377 * -- I should either compute the spare table in the kernel, 1378 * or have a different -- XXX XXX -- interface (a different 1379 * character device) for delivering the table -- XXX */ 1380 #if 0 1381 case RAIDFRAME_SPARET_WAIT: 1382 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1383 while (!rf_sparet_wait_queue) 1384 mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE); 1385 waitreq = rf_sparet_wait_queue; 1386 rf_sparet_wait_queue = rf_sparet_wait_queue->next; 1387 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1388 1389 /* structure assignment */ 1390 *((RF_SparetWait_t *) data) = *waitreq; 1391 1392 RF_Free(waitreq, sizeof(*waitreq)); 1393 return (0); 1394 1395 /* wakes up a process waiting on SPARET_WAIT and puts an error 1396 * code in it that will cause the dameon to exit */ 1397 case RAIDFRAME_ABORT_SPARET_WAIT: 1398 RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); 1399 waitreq->fcol = -1; 1400 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1401 waitreq->next = rf_sparet_wait_queue; 1402 rf_sparet_wait_queue = waitreq; 1403 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1404 wakeup(&rf_sparet_wait_queue); 1405 return (0); 1406 1407 /* used by the spare table daemon to deliver a spare table 1408 * into the kernel */ 1409 case RAIDFRAME_SEND_SPARET: 1410 1411 /* install the spare table */ 1412 retcode = rf_SetSpareTable(raidPtr, *(void **) data); 1413 1414 /* respond to the requestor. the return status of the spare 1415 * table installation is passed in the "fcol" field */ 1416 RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *)); 1417 waitreq->fcol = retcode; 1418 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1419 waitreq->next = rf_sparet_resp_queue; 1420 rf_sparet_resp_queue = waitreq; 1421 wakeup(&rf_sparet_resp_queue); 1422 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1423 1424 return (retcode); 1425 #endif 1426 1427 default: 1428 break; /* fall through to the os-specific code below */ 1429 1430 } 1431 1432 if (!raidPtr->valid) 1433 return (EINVAL); 1434 1435 /* 1436 * Add support for "regular" device ioctls here. 1437 */ 1438 1439 switch (cmd) { 1440 case DIOCGDINFO: 1441 *(struct disklabel *) data = *(rs->sc_dkdev.dk_label); 1442 break; 1443 1444 case DIOCGPART: 1445 ((struct partinfo *) data)->disklab = rs->sc_dkdev.dk_label; 1446 ((struct partinfo *) data)->part = 1447 &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)]; 1448 break; 1449 1450 case DIOCWDINFO: 1451 case DIOCSDINFO: 1452 if ((error = raidlock(rs)) != 0) 1453 return (error); 1454 1455 rs->sc_flags |= RAIDF_LABELLING; 1456 1457 error = setdisklabel(rs->sc_dkdev.dk_label, 1458 (struct disklabel *) data, 0, rs->sc_dkdev.dk_cpulabel); 1459 if (error == 0) { 1460 if (cmd == DIOCWDINFO) 1461 error = writedisklabel(RAIDLABELDEV(dev), 1462 raidstrategy, rs->sc_dkdev.dk_label, 1463 rs->sc_dkdev.dk_cpulabel); 1464 } 1465 rs->sc_flags &= ~RAIDF_LABELLING; 1466 1467 raidunlock(rs); 1468 1469 if (error) 1470 return (error); 1471 break; 1472 1473 case DIOCWLABEL: 1474 if (*(int *) data != 0) 1475 rs->sc_flags |= RAIDF_WLABEL; 1476 else 1477 rs->sc_flags &= ~RAIDF_WLABEL; 1478 break; 1479 1480 case DIOCGDEFLABEL: 1481 raidgetdefaultlabel(raidPtr, rs, 1482 (struct disklabel *) data); 1483 break; 1484 1485 default: 1486 retcode = ENOTTY; 1487 } 1488 return (retcode); 1489 1490 } 1491 1492 1493 /* raidinit -- complete the rest of the initialization for the 1494 RAIDframe device. */ 1495 1496 1497 static void 1498 raidinit(raidPtr) 1499 RF_Raid_t *raidPtr; 1500 { 1501 struct raid_softc *rs; 1502 int unit; 1503 1504 unit = raidPtr->raidid; 1505 1506 rs = &raid_softc[unit]; 1507 pool_init(&rs->sc_cbufpool, sizeof(struct raidbuf), 0, 1508 0, 0, "raidpl", 0, NULL, NULL, M_RAIDFRAME); 1509 1510 1511 /* XXX should check return code first... */ 1512 rs->sc_flags |= RAIDF_INITED; 1513 1514 sprintf(rs->sc_xname, "raid%d", unit); /* XXX doesn't check bounds. */ 1515 1516 rs->sc_dkdev.dk_name = rs->sc_xname; 1517 1518 /* disk_attach actually creates space for the CPU disklabel, among 1519 * other things, so it's critical to call this *BEFORE* we try putzing 1520 * with disklabels. */ 1521 1522 disk_attach(&rs->sc_dkdev); 1523 1524 /* XXX There may be a weird interaction here between this, and 1525 * protectedSectors, as used in RAIDframe. */ 1526 1527 rs->sc_size = raidPtr->totalSectors; 1528 1529 } 1530 1531 /* wake up the daemon & tell it to get us a spare table 1532 * XXX 1533 * the entries in the queues should be tagged with the raidPtr 1534 * so that in the extremely rare case that two recons happen at once, 1535 * we know for which device were requesting a spare table 1536 * XXX 1537 * 1538 * XXX This code is not currently used. GO 1539 */ 1540 int 1541 rf_GetSpareTableFromDaemon(req) 1542 RF_SparetWait_t *req; 1543 { 1544 int retcode; 1545 1546 RF_LOCK_MUTEX(rf_sparet_wait_mutex); 1547 req->next = rf_sparet_wait_queue; 1548 rf_sparet_wait_queue = req; 1549 wakeup(&rf_sparet_wait_queue); 1550 1551 /* mpsleep unlocks the mutex */ 1552 while (!rf_sparet_resp_queue) { 1553 tsleep(&rf_sparet_resp_queue, PRIBIO, 1554 "raidframe getsparetable", 0); 1555 } 1556 req = rf_sparet_resp_queue; 1557 rf_sparet_resp_queue = req->next; 1558 RF_UNLOCK_MUTEX(rf_sparet_wait_mutex); 1559 1560 retcode = req->fcol; 1561 RF_Free(req, sizeof(*req)); /* this is not the same req as we 1562 * alloc'd */ 1563 return (retcode); 1564 } 1565 1566 /* a wrapper around rf_DoAccess that extracts appropriate info from the 1567 * bp & passes it down. 1568 * any calls originating in the kernel must use non-blocking I/O 1569 * do some extra sanity checking to return "appropriate" error values for 1570 * certain conditions (to make some standard utilities work) 1571 * 1572 * Formerly known as: rf_DoAccessKernel 1573 */ 1574 void 1575 raidstart(raidPtr) 1576 RF_Raid_t *raidPtr; 1577 { 1578 RF_SectorCount_t num_blocks, pb, sum; 1579 RF_RaidAddr_t raid_addr; 1580 int retcode; 1581 struct partition *pp; 1582 daddr_t blocknum; 1583 int unit; 1584 struct raid_softc *rs; 1585 int do_async; 1586 struct buf *bp; 1587 1588 unit = raidPtr->raidid; 1589 rs = &raid_softc[unit]; 1590 1591 /* quick check to see if anything has died recently */ 1592 RF_LOCK_MUTEX(raidPtr->mutex); 1593 if (raidPtr->numNewFailures > 0) { 1594 rf_update_component_labels(raidPtr, 1595 RF_NORMAL_COMPONENT_UPDATE); 1596 raidPtr->numNewFailures--; 1597 } 1598 RF_UNLOCK_MUTEX(raidPtr->mutex); 1599 1600 /* Check to see if we're at the limit... */ 1601 RF_LOCK_MUTEX(raidPtr->mutex); 1602 while (raidPtr->openings > 0) { 1603 RF_UNLOCK_MUTEX(raidPtr->mutex); 1604 1605 /* get the next item, if any, from the queue */ 1606 if ((bp = BUFQ_FIRST(&rs->buf_queue)) == NULL) { 1607 /* nothing more to do */ 1608 return; 1609 } 1610 BUFQ_REMOVE(&rs->buf_queue, bp); 1611 1612 /* Ok, for the bp we have here, bp->b_blkno is relative to the 1613 * partition.. Need to make it absolute to the underlying 1614 * device.. */ 1615 1616 blocknum = bp->b_blkno; 1617 if (DISKPART(bp->b_dev) != RAW_PART) { 1618 pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)]; 1619 blocknum += pp->p_offset; 1620 } 1621 1622 db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno, 1623 (int) blocknum)); 1624 1625 db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount)); 1626 db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid)); 1627 1628 /* *THIS* is where we adjust what block we're going to... 1629 * but DO NOT TOUCH bp->b_blkno!!! */ 1630 raid_addr = blocknum; 1631 1632 num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector; 1633 pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0; 1634 sum = raid_addr + num_blocks + pb; 1635 if (1 || rf_debugKernelAccess) { 1636 db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n", 1637 (int) raid_addr, (int) sum, (int) num_blocks, 1638 (int) pb, (int) bp->b_resid)); 1639 } 1640 if ((sum > raidPtr->totalSectors) || (sum < raid_addr) 1641 || (sum < num_blocks) || (sum < pb)) { 1642 bp->b_error = ENOSPC; 1643 bp->b_flags |= B_ERROR; 1644 bp->b_resid = bp->b_bcount; 1645 biodone(bp); 1646 RF_LOCK_MUTEX(raidPtr->mutex); 1647 continue; 1648 } 1649 /* 1650 * XXX rf_DoAccess() should do this, not just DoAccessKernel() 1651 */ 1652 1653 if (bp->b_bcount & raidPtr->sectorMask) { 1654 bp->b_error = EINVAL; 1655 bp->b_flags |= B_ERROR; 1656 bp->b_resid = bp->b_bcount; 1657 biodone(bp); 1658 RF_LOCK_MUTEX(raidPtr->mutex); 1659 continue; 1660 1661 } 1662 db1_printf(("Calling DoAccess..\n")); 1663 1664 1665 RF_LOCK_MUTEX(raidPtr->mutex); 1666 raidPtr->openings--; 1667 RF_UNLOCK_MUTEX(raidPtr->mutex); 1668 1669 /* 1670 * Everything is async. 1671 */ 1672 do_async = 1; 1673 1674 /* don't ever condition on bp->b_flags & B_WRITE. 1675 * always condition on B_READ instead */ 1676 1677 /* XXX we're still at splbio() here... do we *really* 1678 need to be? */ 1679 1680 1681 retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ? 1682 RF_IO_TYPE_READ : RF_IO_TYPE_WRITE, 1683 do_async, raid_addr, num_blocks, 1684 bp->b_data, bp, NULL, NULL, 1685 RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL); 1686 1687 1688 RF_LOCK_MUTEX(raidPtr->mutex); 1689 } 1690 RF_UNLOCK_MUTEX(raidPtr->mutex); 1691 } 1692 1693 1694 1695 1696 /* invoke an I/O from kernel mode. Disk queue should be locked upon entry */ 1697 1698 int 1699 rf_DispatchKernelIO(queue, req) 1700 RF_DiskQueue_t *queue; 1701 RF_DiskQueueData_t *req; 1702 { 1703 int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE; 1704 struct buf *bp; 1705 struct raidbuf *raidbp = NULL; 1706 struct raid_softc *rs; 1707 int unit; 1708 int s; 1709 1710 s=0; 1711 /* s = splbio();*/ /* want to test this */ 1712 /* XXX along with the vnode, we also need the softc associated with 1713 * this device.. */ 1714 1715 req->queue = queue; 1716 1717 unit = queue->raidPtr->raidid; 1718 1719 db1_printf(("DispatchKernelIO unit: %d\n", unit)); 1720 1721 if (unit >= numraid) { 1722 printf("Invalid unit number: %d %d\n", unit, numraid); 1723 panic("Invalid Unit number in rf_DispatchKernelIO\n"); 1724 } 1725 rs = &raid_softc[unit]; 1726 1727 /* XXX is this the right place? */ 1728 disk_busy(&rs->sc_dkdev); 1729 1730 bp = req->bp; 1731 #if 1 1732 /* XXX when there is a physical disk failure, someone is passing us a 1733 * buffer that contains old stuff!! Attempt to deal with this problem 1734 * without taking a performance hit... (not sure where the real bug 1735 * is. It's buried in RAIDframe somewhere) :-( GO ) */ 1736 1737 if (bp->b_flags & B_ERROR) { 1738 bp->b_flags &= ~B_ERROR; 1739 } 1740 if (bp->b_error != 0) { 1741 bp->b_error = 0; 1742 } 1743 #endif 1744 raidbp = RAIDGETBUF(rs); 1745 1746 raidbp->rf_flags = 0; /* XXX not really used anywhere... */ 1747 1748 /* 1749 * context for raidiodone 1750 */ 1751 raidbp->rf_obp = bp; 1752 raidbp->req = req; 1753 1754 LIST_INIT(&raidbp->rf_buf.b_dep); 1755 1756 switch (req->type) { 1757 case RF_IO_TYPE_NOP: /* used primarily to unlock a locked queue */ 1758 /* XXX need to do something extra here.. */ 1759 /* I'm leaving this in, as I've never actually seen it used, 1760 * and I'd like folks to report it... GO */ 1761 printf(("WAKEUP CALLED\n")); 1762 queue->numOutstanding++; 1763 1764 /* XXX need to glue the original buffer into this?? */ 1765 1766 KernelWakeupFunc(&raidbp->rf_buf); 1767 break; 1768 1769 case RF_IO_TYPE_READ: 1770 case RF_IO_TYPE_WRITE: 1771 1772 if (req->tracerec) { 1773 RF_ETIMER_START(req->tracerec->timer); 1774 } 1775 InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp, 1776 op | bp->b_flags, queue->rf_cinfo->ci_dev, 1777 req->sectorOffset, req->numSector, 1778 req->buf, KernelWakeupFunc, (void *) req, 1779 queue->raidPtr->logBytesPerSector, req->b_proc); 1780 1781 if (rf_debugKernelAccess) { 1782 db1_printf(("dispatch: bp->b_blkno = %ld\n", 1783 (long) bp->b_blkno)); 1784 } 1785 queue->numOutstanding++; 1786 queue->last_deq_sector = req->sectorOffset; 1787 /* acc wouldn't have been let in if there were any pending 1788 * reqs at any other priority */ 1789 queue->curPriority = req->priority; 1790 1791 db1_printf(("Going for %c to unit %d row %d col %d\n", 1792 req->type, unit, queue->row, queue->col)); 1793 db1_printf(("sector %d count %d (%d bytes) %d\n", 1794 (int) req->sectorOffset, (int) req->numSector, 1795 (int) (req->numSector << 1796 queue->raidPtr->logBytesPerSector), 1797 (int) queue->raidPtr->logBytesPerSector)); 1798 if ((raidbp->rf_buf.b_flags & B_READ) == 0) { 1799 raidbp->rf_buf.b_vp->v_numoutput++; 1800 } 1801 VOP_STRATEGY(&raidbp->rf_buf); 1802 1803 break; 1804 1805 default: 1806 panic("bad req->type in rf_DispatchKernelIO"); 1807 } 1808 db1_printf(("Exiting from DispatchKernelIO\n")); 1809 /* splx(s); */ /* want to test this */ 1810 return (0); 1811 } 1812 /* this is the callback function associated with a I/O invoked from 1813 kernel code. 1814 */ 1815 static void 1816 KernelWakeupFunc(vbp) 1817 struct buf *vbp; 1818 { 1819 RF_DiskQueueData_t *req = NULL; 1820 RF_DiskQueue_t *queue; 1821 struct raidbuf *raidbp = (struct raidbuf *) vbp; 1822 struct buf *bp; 1823 struct raid_softc *rs; 1824 int unit; 1825 int s; 1826 1827 s = splbio(); 1828 db1_printf(("recovering the request queue:\n")); 1829 req = raidbp->req; 1830 1831 bp = raidbp->rf_obp; 1832 1833 queue = (RF_DiskQueue_t *) req->queue; 1834 1835 if (raidbp->rf_buf.b_flags & B_ERROR) { 1836 bp->b_flags |= B_ERROR; 1837 bp->b_error = raidbp->rf_buf.b_error ? 1838 raidbp->rf_buf.b_error : EIO; 1839 } 1840 1841 /* XXX methinks this could be wrong... */ 1842 #if 1 1843 bp->b_resid = raidbp->rf_buf.b_resid; 1844 #endif 1845 1846 if (req->tracerec) { 1847 RF_ETIMER_STOP(req->tracerec->timer); 1848 RF_ETIMER_EVAL(req->tracerec->timer); 1849 RF_LOCK_MUTEX(rf_tracing_mutex); 1850 req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer); 1851 req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer); 1852 req->tracerec->num_phys_ios++; 1853 RF_UNLOCK_MUTEX(rf_tracing_mutex); 1854 } 1855 bp->b_bcount = raidbp->rf_buf.b_bcount; /* XXXX ?? */ 1856 1857 unit = queue->raidPtr->raidid; /* *Much* simpler :-> */ 1858 1859 1860 /* XXX Ok, let's get aggressive... If B_ERROR is set, let's go 1861 * ballistic, and mark the component as hosed... */ 1862 1863 if (bp->b_flags & B_ERROR) { 1864 /* Mark the disk as dead */ 1865 /* but only mark it once... */ 1866 if (queue->raidPtr->Disks[queue->row][queue->col].status == 1867 rf_ds_optimal) { 1868 printf("raid%d: IO Error. Marking %s as failed.\n", 1869 unit, queue->raidPtr->Disks[queue->row][queue->col].devname); 1870 queue->raidPtr->Disks[queue->row][queue->col].status = 1871 rf_ds_failed; 1872 queue->raidPtr->status[queue->row] = rf_rs_degraded; 1873 queue->raidPtr->numFailures++; 1874 queue->raidPtr->numNewFailures++; 1875 } else { /* Disk is already dead... */ 1876 /* printf("Disk already marked as dead!\n"); */ 1877 } 1878 1879 } 1880 1881 rs = &raid_softc[unit]; 1882 RAIDPUTBUF(rs, raidbp); 1883 1884 1885 if (bp->b_resid == 0) { 1886 /* XXX is this the right place for a disk_unbusy()??!??!?!? */ 1887 disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid)); 1888 } 1889 1890 rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0); 1891 (req->CompleteFunc) (req->argument, (bp->b_flags & B_ERROR) ? 1 : 0); 1892 1893 splx(s); 1894 } 1895 1896 1897 1898 /* 1899 * initialize a buf structure for doing an I/O in the kernel. 1900 */ 1901 static void 1902 InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg, 1903 logBytesPerSector, b_proc) 1904 struct buf *bp; 1905 struct vnode *b_vp; 1906 unsigned rw_flag; 1907 dev_t dev; 1908 RF_SectorNum_t startSect; 1909 RF_SectorCount_t numSect; 1910 caddr_t buf; 1911 void (*cbFunc) (struct buf *); 1912 void *cbArg; 1913 int logBytesPerSector; 1914 struct proc *b_proc; 1915 { 1916 /* bp->b_flags = B_PHYS | rw_flag; */ 1917 bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too??? */ 1918 bp->b_bcount = numSect << logBytesPerSector; 1919 bp->b_bufsize = bp->b_bcount; 1920 bp->b_error = 0; 1921 bp->b_dev = dev; 1922 bp->b_data = buf; 1923 bp->b_blkno = startSect; 1924 bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */ 1925 if (bp->b_bcount == 0) { 1926 panic("bp->b_bcount is zero in InitBP!!\n"); 1927 } 1928 bp->b_proc = b_proc; 1929 bp->b_iodone = cbFunc; 1930 bp->b_vp = b_vp; 1931 1932 } 1933 1934 static void 1935 raidgetdefaultlabel(raidPtr, rs, lp) 1936 RF_Raid_t *raidPtr; 1937 struct raid_softc *rs; 1938 struct disklabel *lp; 1939 { 1940 db1_printf(("Building a default label...\n")); 1941 bzero(lp, sizeof(*lp)); 1942 1943 /* fabricate a label... */ 1944 lp->d_secperunit = raidPtr->totalSectors; 1945 lp->d_secsize = raidPtr->bytesPerSector; 1946 lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe; 1947 lp->d_ntracks = 1; 1948 lp->d_ncylinders = raidPtr->totalSectors / 1949 (lp->d_nsectors * lp->d_ntracks); 1950 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1951 1952 strncpy(lp->d_typename, "raid", sizeof(lp->d_typename)); 1953 lp->d_type = DTYPE_RAID; 1954 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 1955 lp->d_rpm = 3600; 1956 lp->d_interleave = 1; 1957 lp->d_flags = 0; 1958 1959 lp->d_partitions[RAW_PART].p_offset = 0; 1960 lp->d_partitions[RAW_PART].p_size = raidPtr->totalSectors; 1961 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 1962 lp->d_npartitions = RAW_PART + 1; 1963 1964 lp->d_magic = DISKMAGIC; 1965 lp->d_magic2 = DISKMAGIC; 1966 lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label); 1967 1968 } 1969 /* 1970 * Read the disklabel from the raid device. If one is not present, fake one 1971 * up. 1972 */ 1973 static void 1974 raidgetdisklabel(dev) 1975 dev_t dev; 1976 { 1977 int unit = raidunit(dev); 1978 struct raid_softc *rs = &raid_softc[unit]; 1979 char *errstring; 1980 struct disklabel *lp = rs->sc_dkdev.dk_label; 1981 struct cpu_disklabel *clp = rs->sc_dkdev.dk_cpulabel; 1982 RF_Raid_t *raidPtr; 1983 1984 db1_printf(("Getting the disklabel...\n")); 1985 1986 bzero(clp, sizeof(*clp)); 1987 1988 raidPtr = raidPtrs[unit]; 1989 1990 raidgetdefaultlabel(raidPtr, rs, lp); 1991 1992 /* 1993 * Call the generic disklabel extraction routine. 1994 */ 1995 errstring = readdisklabel(RAIDLABELDEV(dev), raidstrategy, 1996 rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel); 1997 if (errstring) 1998 raidmakedisklabel(rs); 1999 else { 2000 int i; 2001 struct partition *pp; 2002 2003 /* 2004 * Sanity check whether the found disklabel is valid. 2005 * 2006 * This is necessary since total size of the raid device 2007 * may vary when an interleave is changed even though exactly 2008 * same componets are used, and old disklabel may used 2009 * if that is found. 2010 */ 2011 if (lp->d_secperunit != rs->sc_size) 2012 printf("WARNING: %s: " 2013 "total sector size in disklabel (%d) != " 2014 "the size of raid (%ld)\n", rs->sc_xname, 2015 lp->d_secperunit, (long) rs->sc_size); 2016 for (i = 0; i < lp->d_npartitions; i++) { 2017 pp = &lp->d_partitions[i]; 2018 if (pp->p_offset + pp->p_size > rs->sc_size) 2019 printf("WARNING: %s: end of partition `%c' " 2020 "exceeds the size of raid (%ld)\n", 2021 rs->sc_xname, 'a' + i, (long) rs->sc_size); 2022 } 2023 } 2024 2025 } 2026 /* 2027 * Take care of things one might want to take care of in the event 2028 * that a disklabel isn't present. 2029 */ 2030 static void 2031 raidmakedisklabel(rs) 2032 struct raid_softc *rs; 2033 { 2034 struct disklabel *lp = rs->sc_dkdev.dk_label; 2035 db1_printf(("Making a label..\n")); 2036 2037 /* 2038 * For historical reasons, if there's no disklabel present 2039 * the raw partition must be marked FS_BSDFFS. 2040 */ 2041 2042 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS; 2043 2044 strncpy(lp->d_packname, "default label", sizeof(lp->d_packname)); 2045 2046 lp->d_checksum = dkcksum(lp); 2047 } 2048 /* 2049 * Lookup the provided name in the filesystem. If the file exists, 2050 * is a valid block device, and isn't being used by anyone else, 2051 * set *vpp to the file's vnode. 2052 * You'll find the original of this in ccd.c 2053 */ 2054 int 2055 raidlookup(path, p, vpp) 2056 char *path; 2057 struct proc *p; 2058 struct vnode **vpp; /* result */ 2059 { 2060 struct nameidata nd; 2061 struct vnode *vp; 2062 struct vattr va; 2063 int error; 2064 2065 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p); 2066 if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) { 2067 #ifdef DEBUG 2068 printf("RAIDframe: vn_open returned %d\n", error); 2069 #endif 2070 return (error); 2071 } 2072 vp = nd.ni_vp; 2073 if (vp->v_usecount > 1) { 2074 VOP_UNLOCK(vp, 0); 2075 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2076 return (EBUSY); 2077 } 2078 if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) { 2079 VOP_UNLOCK(vp, 0); 2080 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2081 return (error); 2082 } 2083 /* XXX: eventually we should handle VREG, too. */ 2084 if (va.va_type != VBLK) { 2085 VOP_UNLOCK(vp, 0); 2086 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2087 return (ENOTBLK); 2088 } 2089 VOP_UNLOCK(vp, 0); 2090 *vpp = vp; 2091 return (0); 2092 } 2093 /* 2094 * Wait interruptibly for an exclusive lock. 2095 * 2096 * XXX 2097 * Several drivers do this; it should be abstracted and made MP-safe. 2098 * (Hmm... where have we seen this warning before :-> GO ) 2099 */ 2100 static int 2101 raidlock(rs) 2102 struct raid_softc *rs; 2103 { 2104 int error; 2105 2106 while ((rs->sc_flags & RAIDF_LOCKED) != 0) { 2107 rs->sc_flags |= RAIDF_WANTED; 2108 if ((error = 2109 tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0) 2110 return (error); 2111 } 2112 rs->sc_flags |= RAIDF_LOCKED; 2113 return (0); 2114 } 2115 /* 2116 * Unlock and wake up any waiters. 2117 */ 2118 static void 2119 raidunlock(rs) 2120 struct raid_softc *rs; 2121 { 2122 2123 rs->sc_flags &= ~RAIDF_LOCKED; 2124 if ((rs->sc_flags & RAIDF_WANTED) != 0) { 2125 rs->sc_flags &= ~RAIDF_WANTED; 2126 wakeup(rs); 2127 } 2128 } 2129 2130 2131 #define RF_COMPONENT_INFO_OFFSET 16384 /* bytes */ 2132 #define RF_COMPONENT_INFO_SIZE 1024 /* bytes */ 2133 2134 int 2135 raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter) 2136 { 2137 RF_ComponentLabel_t clabel; 2138 raidread_component_label(dev, b_vp, &clabel); 2139 clabel.mod_counter = mod_counter; 2140 clabel.clean = RF_RAID_CLEAN; 2141 raidwrite_component_label(dev, b_vp, &clabel); 2142 return(0); 2143 } 2144 2145 2146 int 2147 raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter) 2148 { 2149 RF_ComponentLabel_t clabel; 2150 raidread_component_label(dev, b_vp, &clabel); 2151 clabel.mod_counter = mod_counter; 2152 clabel.clean = RF_RAID_DIRTY; 2153 raidwrite_component_label(dev, b_vp, &clabel); 2154 return(0); 2155 } 2156 2157 /* ARGSUSED */ 2158 int 2159 raidread_component_label(dev, b_vp, clabel) 2160 dev_t dev; 2161 struct vnode *b_vp; 2162 RF_ComponentLabel_t *clabel; 2163 { 2164 struct buf *bp; 2165 int error; 2166 2167 /* XXX should probably ensure that we don't try to do this if 2168 someone has changed rf_protected_sectors. */ 2169 2170 if (b_vp == NULL) { 2171 /* For whatever reason, this component is not valid. 2172 Don't try to read a component label from it. */ 2173 return(EINVAL); 2174 } 2175 2176 /* get a block of the appropriate size... */ 2177 bp = geteblk((int)RF_COMPONENT_INFO_SIZE); 2178 bp->b_dev = dev; 2179 2180 /* get our ducks in a row for the read */ 2181 bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; 2182 bp->b_bcount = RF_COMPONENT_INFO_SIZE; 2183 bp->b_flags = B_BUSY | B_READ; 2184 bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; 2185 2186 (*bdevsw[major(bp->b_dev)].d_strategy)(bp); 2187 2188 error = biowait(bp); 2189 2190 if (!error) { 2191 memcpy(clabel, bp->b_data, 2192 sizeof(RF_ComponentLabel_t)); 2193 #if 0 2194 rf_print_component_label( clabel ); 2195 #endif 2196 } else { 2197 #if 0 2198 printf("Failed to read RAID component label!\n"); 2199 #endif 2200 } 2201 2202 bp->b_flags = B_INVAL | B_AGE; 2203 brelse(bp); 2204 return(error); 2205 } 2206 /* ARGSUSED */ 2207 int 2208 raidwrite_component_label(dev, b_vp, clabel) 2209 dev_t dev; 2210 struct vnode *b_vp; 2211 RF_ComponentLabel_t *clabel; 2212 { 2213 struct buf *bp; 2214 int error; 2215 2216 /* get a block of the appropriate size... */ 2217 bp = geteblk((int)RF_COMPONENT_INFO_SIZE); 2218 bp->b_dev = dev; 2219 2220 /* get our ducks in a row for the write */ 2221 bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE; 2222 bp->b_bcount = RF_COMPONENT_INFO_SIZE; 2223 bp->b_flags = B_BUSY | B_WRITE; 2224 bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE; 2225 2226 memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE ); 2227 2228 memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t)); 2229 2230 (*bdevsw[major(bp->b_dev)].d_strategy)(bp); 2231 error = biowait(bp); 2232 bp->b_flags = B_INVAL | B_AGE; 2233 brelse(bp); 2234 if (error) { 2235 #if 1 2236 printf("Failed to write RAID component info!\n"); 2237 #endif 2238 } 2239 2240 return(error); 2241 } 2242 2243 void 2244 rf_markalldirty(raidPtr) 2245 RF_Raid_t *raidPtr; 2246 { 2247 RF_ComponentLabel_t clabel; 2248 int r,c; 2249 2250 raidPtr->mod_counter++; 2251 for (r = 0; r < raidPtr->numRow; r++) { 2252 for (c = 0; c < raidPtr->numCol; c++) { 2253 /* we don't want to touch (at all) a disk that has 2254 failed */ 2255 if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) { 2256 raidread_component_label( 2257 raidPtr->Disks[r][c].dev, 2258 raidPtr->raid_cinfo[r][c].ci_vp, 2259 &clabel); 2260 if (clabel.status == rf_ds_spared) { 2261 /* XXX do something special... 2262 but whatever you do, don't 2263 try to access it!! */ 2264 } else { 2265 #if 0 2266 clabel.status = 2267 raidPtr->Disks[r][c].status; 2268 raidwrite_component_label( 2269 raidPtr->Disks[r][c].dev, 2270 raidPtr->raid_cinfo[r][c].ci_vp, 2271 &clabel); 2272 #endif 2273 raidmarkdirty( 2274 raidPtr->Disks[r][c].dev, 2275 raidPtr->raid_cinfo[r][c].ci_vp, 2276 raidPtr->mod_counter); 2277 } 2278 } 2279 } 2280 } 2281 /* printf("Component labels marked dirty.\n"); */ 2282 #if 0 2283 for( c = 0; c < raidPtr->numSpare ; c++) { 2284 sparecol = raidPtr->numCol + c; 2285 if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) { 2286 /* 2287 2288 XXX this is where we get fancy and map this spare 2289 into it's correct spot in the array. 2290 2291 */ 2292 /* 2293 2294 we claim this disk is "optimal" if it's 2295 rf_ds_used_spare, as that means it should be 2296 directly substitutable for the disk it replaced. 2297 We note that too... 2298 2299 */ 2300 2301 for(i=0;i<raidPtr->numRow;i++) { 2302 for(j=0;j<raidPtr->numCol;j++) { 2303 if ((raidPtr->Disks[i][j].spareRow == 2304 r) && 2305 (raidPtr->Disks[i][j].spareCol == 2306 sparecol)) { 2307 srow = r; 2308 scol = sparecol; 2309 break; 2310 } 2311 } 2312 } 2313 2314 raidread_component_label( 2315 raidPtr->Disks[r][sparecol].dev, 2316 raidPtr->raid_cinfo[r][sparecol].ci_vp, 2317 &clabel); 2318 /* make sure status is noted */ 2319 clabel.version = RF_COMPONENT_LABEL_VERSION; 2320 clabel.mod_counter = raidPtr->mod_counter; 2321 clabel.serial_number = raidPtr->serial_number; 2322 clabel.row = srow; 2323 clabel.column = scol; 2324 clabel.num_rows = raidPtr->numRow; 2325 clabel.num_columns = raidPtr->numCol; 2326 clabel.clean = RF_RAID_DIRTY; /* changed in a bit*/ 2327 clabel.status = rf_ds_optimal; 2328 raidwrite_component_label( 2329 raidPtr->Disks[r][sparecol].dev, 2330 raidPtr->raid_cinfo[r][sparecol].ci_vp, 2331 &clabel); 2332 raidmarkclean( raidPtr->Disks[r][sparecol].dev, 2333 raidPtr->raid_cinfo[r][sparecol].ci_vp); 2334 } 2335 } 2336 2337 #endif 2338 } 2339 2340 2341 void 2342 rf_update_component_labels(raidPtr, final) 2343 RF_Raid_t *raidPtr; 2344 int final; 2345 { 2346 RF_ComponentLabel_t clabel; 2347 int sparecol; 2348 int r,c; 2349 int i,j; 2350 int srow, scol; 2351 2352 srow = -1; 2353 scol = -1; 2354 2355 /* XXX should do extra checks to make sure things really are clean, 2356 rather than blindly setting the clean bit... */ 2357 2358 raidPtr->mod_counter++; 2359 2360 for (r = 0; r < raidPtr->numRow; r++) { 2361 for (c = 0; c < raidPtr->numCol; c++) { 2362 if (raidPtr->Disks[r][c].status == rf_ds_optimal) { 2363 raidread_component_label( 2364 raidPtr->Disks[r][c].dev, 2365 raidPtr->raid_cinfo[r][c].ci_vp, 2366 &clabel); 2367 /* make sure status is noted */ 2368 clabel.status = rf_ds_optimal; 2369 /* bump the counter */ 2370 clabel.mod_counter = raidPtr->mod_counter; 2371 2372 raidwrite_component_label( 2373 raidPtr->Disks[r][c].dev, 2374 raidPtr->raid_cinfo[r][c].ci_vp, 2375 &clabel); 2376 if (final == RF_FINAL_COMPONENT_UPDATE) { 2377 if (raidPtr->parity_good == RF_RAID_CLEAN) { 2378 raidmarkclean( 2379 raidPtr->Disks[r][c].dev, 2380 raidPtr->raid_cinfo[r][c].ci_vp, 2381 raidPtr->mod_counter); 2382 } 2383 } 2384 } 2385 /* else we don't touch it.. */ 2386 } 2387 } 2388 2389 for( c = 0; c < raidPtr->numSpare ; c++) { 2390 sparecol = raidPtr->numCol + c; 2391 if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) { 2392 /* 2393 2394 we claim this disk is "optimal" if it's 2395 rf_ds_used_spare, as that means it should be 2396 directly substitutable for the disk it replaced. 2397 We note that too... 2398 2399 */ 2400 2401 for(i=0;i<raidPtr->numRow;i++) { 2402 for(j=0;j<raidPtr->numCol;j++) { 2403 if ((raidPtr->Disks[i][j].spareRow == 2404 0) && 2405 (raidPtr->Disks[i][j].spareCol == 2406 sparecol)) { 2407 srow = i; 2408 scol = j; 2409 break; 2410 } 2411 } 2412 } 2413 2414 /* XXX shouldn't *really* need this... */ 2415 raidread_component_label( 2416 raidPtr->Disks[0][sparecol].dev, 2417 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2418 &clabel); 2419 /* make sure status is noted */ 2420 2421 raid_init_component_label(raidPtr, &clabel); 2422 2423 clabel.mod_counter = raidPtr->mod_counter; 2424 clabel.row = srow; 2425 clabel.column = scol; 2426 clabel.status = rf_ds_optimal; 2427 2428 raidwrite_component_label( 2429 raidPtr->Disks[0][sparecol].dev, 2430 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2431 &clabel); 2432 if (final == RF_FINAL_COMPONENT_UPDATE) { 2433 if (raidPtr->parity_good == RF_RAID_CLEAN) { 2434 raidmarkclean( raidPtr->Disks[0][sparecol].dev, 2435 raidPtr->raid_cinfo[0][sparecol].ci_vp, 2436 raidPtr->mod_counter); 2437 } 2438 } 2439 } 2440 } 2441 /* printf("Component labels updated\n"); */ 2442 } 2443 2444 void 2445 rf_close_component(raidPtr, vp, auto_configured) 2446 RF_Raid_t *raidPtr; 2447 struct vnode *vp; 2448 int auto_configured; 2449 { 2450 struct proc *p; 2451 2452 p = raidPtr->engine_thread; 2453 2454 if (vp != NULL) { 2455 if (auto_configured == 1) { 2456 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2457 VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0); 2458 vput(vp); 2459 2460 } else { 2461 (void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p); 2462 } 2463 } else { 2464 printf("vnode was NULL\n"); 2465 } 2466 } 2467 2468 2469 void 2470 rf_UnconfigureVnodes(raidPtr) 2471 RF_Raid_t *raidPtr; 2472 { 2473 int r,c; 2474 struct proc *p; 2475 struct vnode *vp; 2476 int acd; 2477 2478 2479 /* We take this opportunity to close the vnodes like we should.. */ 2480 2481 p = raidPtr->engine_thread; 2482 2483 for (r = 0; r < raidPtr->numRow; r++) { 2484 for (c = 0; c < raidPtr->numCol; c++) { 2485 printf("Closing vnode for row: %d col: %d\n", r, c); 2486 vp = raidPtr->raid_cinfo[r][c].ci_vp; 2487 acd = raidPtr->Disks[r][c].auto_configured; 2488 rf_close_component(raidPtr, vp, acd); 2489 raidPtr->raid_cinfo[r][c].ci_vp = NULL; 2490 raidPtr->Disks[r][c].auto_configured = 0; 2491 } 2492 } 2493 for (r = 0; r < raidPtr->numSpare; r++) { 2494 printf("Closing vnode for spare: %d\n", r); 2495 vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp; 2496 acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured; 2497 rf_close_component(raidPtr, vp, acd); 2498 raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL; 2499 raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0; 2500 } 2501 } 2502 2503 2504 void 2505 rf_ReconThread(req) 2506 struct rf_recon_req *req; 2507 { 2508 int s; 2509 RF_Raid_t *raidPtr; 2510 2511 s = splbio(); 2512 raidPtr = (RF_Raid_t *) req->raidPtr; 2513 raidPtr->recon_in_progress = 1; 2514 2515 rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col, 2516 ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0)); 2517 2518 /* XXX get rid of this! we don't need it at all.. */ 2519 RF_Free(req, sizeof(*req)); 2520 2521 raidPtr->recon_in_progress = 0; 2522 splx(s); 2523 2524 /* That's all... */ 2525 kthread_exit(0); /* does not return */ 2526 } 2527 2528 void 2529 rf_RewriteParityThread(raidPtr) 2530 RF_Raid_t *raidPtr; 2531 { 2532 int retcode; 2533 int s; 2534 2535 raidPtr->parity_rewrite_in_progress = 1; 2536 s = splbio(); 2537 retcode = rf_RewriteParity(raidPtr); 2538 splx(s); 2539 if (retcode) { 2540 printf("raid%d: Error re-writing parity!\n",raidPtr->raidid); 2541 } else { 2542 /* set the clean bit! If we shutdown correctly, 2543 the clean bit on each component label will get 2544 set */ 2545 raidPtr->parity_good = RF_RAID_CLEAN; 2546 } 2547 raidPtr->parity_rewrite_in_progress = 0; 2548 2549 /* Anyone waiting for us to stop? If so, inform them... */ 2550 if (raidPtr->waitShutdown) { 2551 wakeup(&raidPtr->parity_rewrite_in_progress); 2552 } 2553 2554 /* That's all... */ 2555 kthread_exit(0); /* does not return */ 2556 } 2557 2558 2559 void 2560 rf_CopybackThread(raidPtr) 2561 RF_Raid_t *raidPtr; 2562 { 2563 int s; 2564 2565 raidPtr->copyback_in_progress = 1; 2566 s = splbio(); 2567 rf_CopybackReconstructedData(raidPtr); 2568 splx(s); 2569 raidPtr->copyback_in_progress = 0; 2570 2571 /* That's all... */ 2572 kthread_exit(0); /* does not return */ 2573 } 2574 2575 2576 void 2577 rf_ReconstructInPlaceThread(req) 2578 struct rf_recon_req *req; 2579 { 2580 int retcode; 2581 int s; 2582 RF_Raid_t *raidPtr; 2583 2584 s = splbio(); 2585 raidPtr = req->raidPtr; 2586 raidPtr->recon_in_progress = 1; 2587 retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col); 2588 RF_Free(req, sizeof(*req)); 2589 raidPtr->recon_in_progress = 0; 2590 splx(s); 2591 2592 /* That's all... */ 2593 kthread_exit(0); /* does not return */ 2594 } 2595 2596 void 2597 rf_mountroot_hook(dev) 2598 struct device *dev; 2599 { 2600 2601 } 2602 2603 2604 RF_AutoConfig_t * 2605 rf_find_raid_components() 2606 { 2607 struct devnametobdevmaj *dtobdm; 2608 struct vnode *vp; 2609 struct disklabel label; 2610 struct device *dv; 2611 char *cd_name; 2612 dev_t dev; 2613 int error; 2614 int i; 2615 int good_one; 2616 RF_ComponentLabel_t *clabel; 2617 RF_AutoConfig_t *ac_list; 2618 RF_AutoConfig_t *ac; 2619 2620 2621 /* initialize the AutoConfig list */ 2622 ac_list = NULL; 2623 2624 if (raidautoconfig) { 2625 2626 /* we begin by trolling through *all* the devices on the system */ 2627 2628 for (dv = alldevs.tqh_first; dv != NULL; 2629 dv = dv->dv_list.tqe_next) { 2630 2631 /* we are only interested in disks... */ 2632 if (dv->dv_class != DV_DISK) 2633 continue; 2634 2635 /* we don't care about floppies... */ 2636 if (!strcmp(dv->dv_cfdata->cf_driver->cd_name,"fd")) { 2637 continue; 2638 } 2639 2640 /* need to find the device_name_to_block_device_major stuff */ 2641 cd_name = dv->dv_cfdata->cf_driver->cd_name; 2642 dtobdm = dev_name2blk; 2643 while (dtobdm->d_name && strcmp(dtobdm->d_name, cd_name)) { 2644 dtobdm++; 2645 } 2646 2647 /* get a vnode for the raw partition of this disk */ 2648 2649 dev = MAKEDISKDEV(dtobdm->d_maj, dv->dv_unit, RAW_PART); 2650 if (bdevvp(dev, &vp)) 2651 panic("RAID can't alloc vnode"); 2652 2653 error = VOP_OPEN(vp, FREAD, NOCRED, 0); 2654 2655 if (error) { 2656 /* "Who cares." Continue looking 2657 for something that exists*/ 2658 vput(vp); 2659 continue; 2660 } 2661 2662 /* Ok, the disk exists. Go get the disklabel. */ 2663 error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label, 2664 FREAD, NOCRED, 0); 2665 if (error) { 2666 /* 2667 * XXX can't happen - open() would 2668 * have errored out (or faked up one) 2669 */ 2670 printf("can't get label for dev %s%c (%d)!?!?\n", 2671 dv->dv_xname, 'a' + RAW_PART, error); 2672 } 2673 2674 /* don't need this any more. We'll allocate it again 2675 a little later if we really do... */ 2676 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2677 VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0); 2678 vput(vp); 2679 2680 for (i=0; i < label.d_npartitions; i++) { 2681 /* We only support partitions marked as RAID */ 2682 if (label.d_partitions[i].p_fstype != FS_RAID) 2683 continue; 2684 2685 dev = MAKEDISKDEV(dtobdm->d_maj, dv->dv_unit, i); 2686 if (bdevvp(dev, &vp)) 2687 panic("RAID can't alloc vnode"); 2688 2689 error = VOP_OPEN(vp, FREAD, NOCRED, 0); 2690 if (error) { 2691 /* Whatever... */ 2692 vput(vp); 2693 continue; 2694 } 2695 2696 good_one = 0; 2697 2698 clabel = (RF_ComponentLabel_t *) 2699 malloc(sizeof(RF_ComponentLabel_t), 2700 M_RAIDFRAME, M_NOWAIT); 2701 if (clabel == NULL) { 2702 /* XXX CLEANUP HERE */ 2703 printf("RAID auto config: out of memory!\n"); 2704 return(NULL); /* XXX probably should panic? */ 2705 } 2706 2707 if (!raidread_component_label(dev, vp, clabel)) { 2708 /* Got the label. Does it look reasonable? */ 2709 if (rf_reasonable_label(clabel) && 2710 (clabel->partitionSize <= 2711 label.d_partitions[i].p_size)) { 2712 #if DEBUG 2713 printf("Component on: %s%c: %d\n", 2714 dv->dv_xname, 'a'+i, 2715 label.d_partitions[i].p_size); 2716 rf_print_component_label(clabel); 2717 #endif 2718 /* if it's reasonable, add it, 2719 else ignore it. */ 2720 ac = (RF_AutoConfig_t *) 2721 malloc(sizeof(RF_AutoConfig_t), 2722 M_RAIDFRAME, 2723 M_NOWAIT); 2724 if (ac == NULL) { 2725 /* XXX should panic?? */ 2726 return(NULL); 2727 } 2728 2729 sprintf(ac->devname, "%s%c", 2730 dv->dv_xname, 'a'+i); 2731 ac->dev = dev; 2732 ac->vp = vp; 2733 ac->clabel = clabel; 2734 ac->next = ac_list; 2735 ac_list = ac; 2736 good_one = 1; 2737 } 2738 } 2739 if (!good_one) { 2740 /* cleanup */ 2741 free(clabel, M_RAIDFRAME); 2742 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2743 VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0); 2744 vput(vp); 2745 } 2746 } 2747 } 2748 } 2749 return(ac_list); 2750 } 2751 2752 static int 2753 rf_reasonable_label(clabel) 2754 RF_ComponentLabel_t *clabel; 2755 { 2756 2757 if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) || 2758 (clabel->version==RF_COMPONENT_LABEL_VERSION)) && 2759 ((clabel->clean == RF_RAID_CLEAN) || 2760 (clabel->clean == RF_RAID_DIRTY)) && 2761 clabel->row >=0 && 2762 clabel->column >= 0 && 2763 clabel->num_rows > 0 && 2764 clabel->num_columns > 0 && 2765 clabel->row < clabel->num_rows && 2766 clabel->column < clabel->num_columns && 2767 clabel->blockSize > 0 && 2768 clabel->numBlocks > 0) { 2769 /* label looks reasonable enough... */ 2770 return(1); 2771 } 2772 return(0); 2773 } 2774 2775 2776 void 2777 rf_print_component_label(clabel) 2778 RF_ComponentLabel_t *clabel; 2779 { 2780 printf(" Row: %d Column: %d Num Rows: %d Num Columns: %d\n", 2781 clabel->row, clabel->column, 2782 clabel->num_rows, clabel->num_columns); 2783 printf(" Version: %d Serial Number: %d Mod Counter: %d\n", 2784 clabel->version, clabel->serial_number, 2785 clabel->mod_counter); 2786 printf(" Clean: %s Status: %d\n", 2787 clabel->clean ? "Yes" : "No", clabel->status ); 2788 printf(" sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n", 2789 clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU); 2790 printf(" RAID Level: %c blocksize: %d numBlocks: %d\n", 2791 (char) clabel->parityConfig, clabel->blockSize, 2792 clabel->numBlocks); 2793 printf(" Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No" ); 2794 printf(" Contains root partition: %s\n", 2795 clabel->root_partition ? "Yes" : "No" ); 2796 printf(" Last configured as: raid%d\n", clabel->last_unit ); 2797 #if 0 2798 printf(" Config order: %d\n", clabel->config_order); 2799 #endif 2800 2801 } 2802 2803 RF_ConfigSet_t * 2804 rf_create_auto_sets(ac_list) 2805 RF_AutoConfig_t *ac_list; 2806 { 2807 RF_AutoConfig_t *ac; 2808 RF_ConfigSet_t *config_sets; 2809 RF_ConfigSet_t *cset; 2810 RF_AutoConfig_t *ac_next; 2811 2812 2813 config_sets = NULL; 2814 2815 /* Go through the AutoConfig list, and figure out which components 2816 belong to what sets. */ 2817 ac = ac_list; 2818 while(ac!=NULL) { 2819 /* we're going to putz with ac->next, so save it here 2820 for use at the end of the loop */ 2821 ac_next = ac->next; 2822 2823 if (config_sets == NULL) { 2824 /* will need at least this one... */ 2825 config_sets = (RF_ConfigSet_t *) 2826 malloc(sizeof(RF_ConfigSet_t), 2827 M_RAIDFRAME, M_NOWAIT); 2828 if (config_sets == NULL) { 2829 panic("rf_create_auto_sets: No memory!\n"); 2830 } 2831 /* this one is easy :) */ 2832 config_sets->ac = ac; 2833 config_sets->next = NULL; 2834 config_sets->rootable = 0; 2835 ac->next = NULL; 2836 } else { 2837 /* which set does this component fit into? */ 2838 cset = config_sets; 2839 while(cset!=NULL) { 2840 if (rf_does_it_fit(cset, ac)) { 2841 /* looks like it matches... */ 2842 ac->next = cset->ac; 2843 cset->ac = ac; 2844 break; 2845 } 2846 cset = cset->next; 2847 } 2848 if (cset==NULL) { 2849 /* didn't find a match above... new set..*/ 2850 cset = (RF_ConfigSet_t *) 2851 malloc(sizeof(RF_ConfigSet_t), 2852 M_RAIDFRAME, M_NOWAIT); 2853 if (cset == NULL) { 2854 panic("rf_create_auto_sets: No memory!\n"); 2855 } 2856 cset->ac = ac; 2857 ac->next = NULL; 2858 cset->next = config_sets; 2859 cset->rootable = 0; 2860 config_sets = cset; 2861 } 2862 } 2863 ac = ac_next; 2864 } 2865 2866 2867 return(config_sets); 2868 } 2869 2870 static int 2871 rf_does_it_fit(cset, ac) 2872 RF_ConfigSet_t *cset; 2873 RF_AutoConfig_t *ac; 2874 { 2875 RF_ComponentLabel_t *clabel1, *clabel2; 2876 2877 /* If this one matches the *first* one in the set, that's good 2878 enough, since the other members of the set would have been 2879 through here too... */ 2880 /* note that we are not checking partitionSize here.. 2881 2882 Note that we are also not checking the mod_counters here. 2883 If everything else matches execpt the mod_counter, that's 2884 good enough for this test. We will deal with the mod_counters 2885 a little later in the autoconfiguration process. 2886 2887 (clabel1->mod_counter == clabel2->mod_counter) && 2888 2889 The reason we don't check for this is that failed disks 2890 will have lower modification counts. If those disks are 2891 not added to the set they used to belong to, then they will 2892 form their own set, which may result in 2 different sets, 2893 for example, competing to be configured at raid0, and 2894 perhaps competing to be the root filesystem set. If the 2895 wrong ones get configured, or both attempt to become /, 2896 weird behaviour and or serious lossage will occur. Thus we 2897 need to bring them into the fold here, and kick them out at 2898 a later point. 2899 2900 */ 2901 2902 clabel1 = cset->ac->clabel; 2903 clabel2 = ac->clabel; 2904 if ((clabel1->version == clabel2->version) && 2905 (clabel1->serial_number == clabel2->serial_number) && 2906 (clabel1->num_rows == clabel2->num_rows) && 2907 (clabel1->num_columns == clabel2->num_columns) && 2908 (clabel1->sectPerSU == clabel2->sectPerSU) && 2909 (clabel1->SUsPerPU == clabel2->SUsPerPU) && 2910 (clabel1->SUsPerRU == clabel2->SUsPerRU) && 2911 (clabel1->parityConfig == clabel2->parityConfig) && 2912 (clabel1->maxOutstanding == clabel2->maxOutstanding) && 2913 (clabel1->blockSize == clabel2->blockSize) && 2914 (clabel1->numBlocks == clabel2->numBlocks) && 2915 (clabel1->autoconfigure == clabel2->autoconfigure) && 2916 (clabel1->root_partition == clabel2->root_partition) && 2917 (clabel1->last_unit == clabel2->last_unit) && 2918 (clabel1->config_order == clabel2->config_order)) { 2919 /* if it get's here, it almost *has* to be a match */ 2920 } else { 2921 /* it's not consistent with somebody in the set.. 2922 punt */ 2923 return(0); 2924 } 2925 /* all was fine.. it must fit... */ 2926 return(1); 2927 } 2928 2929 int 2930 rf_have_enough_components(cset) 2931 RF_ConfigSet_t *cset; 2932 { 2933 RF_AutoConfig_t *ac; 2934 RF_AutoConfig_t *auto_config; 2935 RF_ComponentLabel_t *clabel; 2936 int r,c; 2937 int num_rows; 2938 int num_cols; 2939 int num_missing; 2940 int mod_counter; 2941 int mod_counter_found; 2942 int even_pair_failed; 2943 char parity_type; 2944 2945 2946 /* check to see that we have enough 'live' components 2947 of this set. If so, we can configure it if necessary */ 2948 2949 num_rows = cset->ac->clabel->num_rows; 2950 num_cols = cset->ac->clabel->num_columns; 2951 parity_type = cset->ac->clabel->parityConfig; 2952 2953 /* XXX Check for duplicate components!?!?!? */ 2954 2955 /* Determine what the mod_counter is supposed to be for this set. */ 2956 2957 mod_counter_found = 0; 2958 ac = cset->ac; 2959 while(ac!=NULL) { 2960 if (mod_counter_found==0) { 2961 mod_counter = ac->clabel->mod_counter; 2962 mod_counter_found = 1; 2963 } else { 2964 if (ac->clabel->mod_counter > mod_counter) { 2965 mod_counter = ac->clabel->mod_counter; 2966 } 2967 } 2968 ac = ac->next; 2969 } 2970 2971 num_missing = 0; 2972 auto_config = cset->ac; 2973 2974 for(r=0; r<num_rows; r++) { 2975 even_pair_failed = 0; 2976 for(c=0; c<num_cols; c++) { 2977 ac = auto_config; 2978 while(ac!=NULL) { 2979 if ((ac->clabel->row == r) && 2980 (ac->clabel->column == c) && 2981 (ac->clabel->mod_counter == mod_counter)) { 2982 /* it's this one... */ 2983 #if DEBUG 2984 printf("Found: %s at %d,%d\n", 2985 ac->devname,r,c); 2986 #endif 2987 break; 2988 } 2989 ac=ac->next; 2990 } 2991 if (ac==NULL) { 2992 /* Didn't find one here! */ 2993 /* special case for RAID 1, especially 2994 where there are more than 2 2995 components (where RAIDframe treats 2996 things a little differently :( ) */ 2997 if (parity_type == '1') { 2998 if (c%2 == 0) { /* even component */ 2999 even_pair_failed = 1; 3000 } else { /* odd component. If 3001 we're failed, and 3002 so is the even 3003 component, it's 3004 "Good Night, Charlie" */ 3005 if (even_pair_failed == 1) { 3006 return(0); 3007 } 3008 } 3009 } else { 3010 /* normal accounting */ 3011 num_missing++; 3012 } 3013 } 3014 if ((parity_type == '1') && (c%2 == 1)) { 3015 /* Just did an even component, and we didn't 3016 bail.. reset the even_pair_failed flag, 3017 and go on to the next component.... */ 3018 even_pair_failed = 0; 3019 } 3020 } 3021 } 3022 3023 clabel = cset->ac->clabel; 3024 3025 if (((clabel->parityConfig == '0') && (num_missing > 0)) || 3026 ((clabel->parityConfig == '4') && (num_missing > 1)) || 3027 ((clabel->parityConfig == '5') && (num_missing > 1))) { 3028 /* XXX this needs to be made *much* more general */ 3029 /* Too many failures */ 3030 return(0); 3031 } 3032 /* otherwise, all is well, and we've got enough to take a kick 3033 at autoconfiguring this set */ 3034 return(1); 3035 } 3036 3037 void 3038 rf_create_configuration(ac,config,raidPtr) 3039 RF_AutoConfig_t *ac; 3040 RF_Config_t *config; 3041 RF_Raid_t *raidPtr; 3042 { 3043 RF_ComponentLabel_t *clabel; 3044 int i; 3045 3046 clabel = ac->clabel; 3047 3048 /* 1. Fill in the common stuff */ 3049 config->numRow = clabel->num_rows; 3050 config->numCol = clabel->num_columns; 3051 config->numSpare = 0; /* XXX should this be set here? */ 3052 config->sectPerSU = clabel->sectPerSU; 3053 config->SUsPerPU = clabel->SUsPerPU; 3054 config->SUsPerRU = clabel->SUsPerRU; 3055 config->parityConfig = clabel->parityConfig; 3056 /* XXX... */ 3057 strcpy(config->diskQueueType,"fifo"); 3058 config->maxOutstandingDiskReqs = clabel->maxOutstanding; 3059 config->layoutSpecificSize = 0; /* XXX ?? */ 3060 3061 while(ac!=NULL) { 3062 /* row/col values will be in range due to the checks 3063 in reasonable_label() */ 3064 strcpy(config->devnames[ac->clabel->row][ac->clabel->column], 3065 ac->devname); 3066 ac = ac->next; 3067 } 3068 3069 for(i=0;i<RF_MAXDBGV;i++) { 3070 config->debugVars[i][0] = NULL; 3071 } 3072 } 3073 3074 int 3075 rf_set_autoconfig(raidPtr, new_value) 3076 RF_Raid_t *raidPtr; 3077 int new_value; 3078 { 3079 RF_ComponentLabel_t clabel; 3080 struct vnode *vp; 3081 dev_t dev; 3082 int row, column; 3083 3084 raidPtr->autoconfigure = new_value; 3085 for(row=0; row<raidPtr->numRow; row++) { 3086 for(column=0; column<raidPtr->numCol; column++) { 3087 if (raidPtr->Disks[row][column].status == 3088 rf_ds_optimal) { 3089 dev = raidPtr->Disks[row][column].dev; 3090 vp = raidPtr->raid_cinfo[row][column].ci_vp; 3091 raidread_component_label(dev, vp, &clabel); 3092 clabel.autoconfigure = new_value; 3093 raidwrite_component_label(dev, vp, &clabel); 3094 } 3095 } 3096 } 3097 return(new_value); 3098 } 3099 3100 int 3101 rf_set_rootpartition(raidPtr, new_value) 3102 RF_Raid_t *raidPtr; 3103 int new_value; 3104 { 3105 RF_ComponentLabel_t clabel; 3106 struct vnode *vp; 3107 dev_t dev; 3108 int row, column; 3109 3110 raidPtr->root_partition = new_value; 3111 for(row=0; row<raidPtr->numRow; row++) { 3112 for(column=0; column<raidPtr->numCol; column++) { 3113 if (raidPtr->Disks[row][column].status == 3114 rf_ds_optimal) { 3115 dev = raidPtr->Disks[row][column].dev; 3116 vp = raidPtr->raid_cinfo[row][column].ci_vp; 3117 raidread_component_label(dev, vp, &clabel); 3118 clabel.root_partition = new_value; 3119 raidwrite_component_label(dev, vp, &clabel); 3120 } 3121 } 3122 } 3123 return(new_value); 3124 } 3125 3126 void 3127 rf_release_all_vps(cset) 3128 RF_ConfigSet_t *cset; 3129 { 3130 RF_AutoConfig_t *ac; 3131 3132 ac = cset->ac; 3133 while(ac!=NULL) { 3134 /* Close the vp, and give it back */ 3135 if (ac->vp) { 3136 vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY); 3137 VOP_CLOSE(ac->vp, FREAD, NOCRED, 0); 3138 vput(ac->vp); 3139 ac->vp = NULL; 3140 } 3141 ac = ac->next; 3142 } 3143 } 3144 3145 3146 void 3147 rf_cleanup_config_set(cset) 3148 RF_ConfigSet_t *cset; 3149 { 3150 RF_AutoConfig_t *ac; 3151 RF_AutoConfig_t *next_ac; 3152 3153 ac = cset->ac; 3154 while(ac!=NULL) { 3155 next_ac = ac->next; 3156 /* nuke the label */ 3157 free(ac->clabel, M_RAIDFRAME); 3158 /* cleanup the config structure */ 3159 free(ac, M_RAIDFRAME); 3160 /* "next.." */ 3161 ac = next_ac; 3162 } 3163 /* and, finally, nuke the config set */ 3164 free(cset, M_RAIDFRAME); 3165 } 3166 3167 3168 void 3169 raid_init_component_label(raidPtr, clabel) 3170 RF_Raid_t *raidPtr; 3171 RF_ComponentLabel_t *clabel; 3172 { 3173 /* current version number */ 3174 clabel->version = RF_COMPONENT_LABEL_VERSION; 3175 clabel->serial_number = raidPtr->serial_number; 3176 clabel->mod_counter = raidPtr->mod_counter; 3177 clabel->num_rows = raidPtr->numRow; 3178 clabel->num_columns = raidPtr->numCol; 3179 clabel->clean = RF_RAID_DIRTY; /* not clean */ 3180 clabel->status = rf_ds_optimal; /* "It's good!" */ 3181 3182 clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit; 3183 clabel->SUsPerPU = raidPtr->Layout.SUsPerPU; 3184 clabel->SUsPerRU = raidPtr->Layout.SUsPerRU; 3185 3186 clabel->blockSize = raidPtr->bytesPerSector; 3187 clabel->numBlocks = raidPtr->sectorsPerDisk; 3188 3189 /* XXX not portable */ 3190 clabel->parityConfig = raidPtr->Layout.map->parityConfig; 3191 clabel->maxOutstanding = raidPtr->maxOutstanding; 3192 clabel->autoconfigure = raidPtr->autoconfigure; 3193 clabel->root_partition = raidPtr->root_partition; 3194 clabel->last_unit = raidPtr->raidid; 3195 clabel->config_order = raidPtr->config_order; 3196 } 3197 3198 int 3199 rf_auto_config_set(cset,unit) 3200 RF_ConfigSet_t *cset; 3201 int *unit; 3202 { 3203 RF_Raid_t *raidPtr; 3204 RF_Config_t *config; 3205 int raidID; 3206 int retcode; 3207 3208 printf("RAID autoconfigure\n"); 3209 3210 retcode = 0; 3211 *unit = -1; 3212 3213 /* 1. Create a config structure */ 3214 3215 config = (RF_Config_t *)malloc(sizeof(RF_Config_t), 3216 M_RAIDFRAME, 3217 M_NOWAIT); 3218 if (config==NULL) { 3219 printf("Out of mem!?!?\n"); 3220 /* XXX do something more intelligent here. */ 3221 return(1); 3222 } 3223 3224 memset(config, 0, sizeof(RF_Config_t)); 3225 3226 /* XXX raidID needs to be set correctly.. */ 3227 3228 /* 3229 2. Figure out what RAID ID this one is supposed to live at 3230 See if we can get the same RAID dev that it was configured 3231 on last time.. 3232 */ 3233 3234 raidID = cset->ac->clabel->last_unit; 3235 if ((raidID < 0) || (raidID >= numraid)) { 3236 /* let's not wander off into lala land. */ 3237 raidID = numraid - 1; 3238 } 3239 if (raidPtrs[raidID]->valid != 0) { 3240 3241 /* 3242 Nope... Go looking for an alternative... 3243 Start high so we don't immediately use raid0 if that's 3244 not taken. 3245 */ 3246 3247 for(raidID = numraid; raidID >= 0; raidID--) { 3248 if (raidPtrs[raidID]->valid == 0) { 3249 /* can use this one! */ 3250 break; 3251 } 3252 } 3253 } 3254 3255 if (raidID < 0) { 3256 /* punt... */ 3257 printf("Unable to auto configure this set!\n"); 3258 printf("(Out of RAID devs!)\n"); 3259 return(1); 3260 } 3261 printf("Configuring raid%d:\n",raidID); 3262 raidPtr = raidPtrs[raidID]; 3263 3264 /* XXX all this stuff should be done SOMEWHERE ELSE! */ 3265 raidPtr->raidid = raidID; 3266 raidPtr->openings = RAIDOUTSTANDING; 3267 3268 /* 3. Build the configuration structure */ 3269 rf_create_configuration(cset->ac, config, raidPtr); 3270 3271 /* 4. Do the configuration */ 3272 retcode = rf_Configure(raidPtr, config, cset->ac); 3273 3274 if (retcode == 0) { 3275 3276 raidinit(raidPtrs[raidID]); 3277 3278 rf_markalldirty(raidPtrs[raidID]); 3279 raidPtrs[raidID]->autoconfigure = 1; /* XXX do this here? */ 3280 if (cset->ac->clabel->root_partition==1) { 3281 /* everything configured just fine. Make a note 3282 that this set is eligible to be root. */ 3283 cset->rootable = 1; 3284 /* XXX do this here? */ 3285 raidPtrs[raidID]->root_partition = 1; 3286 } 3287 } 3288 3289 /* 5. Cleanup */ 3290 free(config, M_RAIDFRAME); 3291 3292 *unit = raidID; 3293 return(retcode); 3294 } 3295
Indexes created Fri Sep 26 20:09:58 GMT 2025