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