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