rf_paritymap.c revision 1.1
1/* $NetBSD: rf_paritymap.c,v 1.1 2009/11/17 18:54:26 jld Exp $ */ 2 3/*- 4 * Copyright (c) 2009 Jed Davis. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29#include <sys/cdefs.h> 30__KERNEL_RCSID(0, "$NetBSD: rf_paritymap.c,v 1.1 2009/11/17 18:54:26 jld Exp $"); 31 32#include <sys/callout.h> 33#include <sys/kmem.h> 34#include <sys/mutex.h> 35#include <sys/param.h> 36#include <sys/rwlock.h> 37#include <sys/systm.h> 38#include <sys/types.h> 39 40#include <dev/raidframe/rf_paritymap.h> 41#include <dev/raidframe/rf_stripelocks.h> 42#include <dev/raidframe/rf_layout.h> 43#include <dev/raidframe/rf_raid.h> 44#include <dev/raidframe/rf_parityscan.h> 45#include <dev/raidframe/rf_kintf.h> 46 47/* Important parameters: */ 48#define REGION_MINSIZE (25ULL << 20) 49#define DFL_TICKMS 40000 50#define DFL_COOLDOWN 8 /* 7-8 intervals of 40s = 5min +/- 20s */ 51 52/* Internal-use flag bits. */ 53#define TICKING 1 54#define TICKED 2 55 56/* Prototypes! */ 57static void rf_paritymap_write_locked(struct rf_paritymap *); 58static void rf_paritymap_tick(void *); 59static u_int rf_paritymap_nreg(RF_Raid_t *); 60 61/* Extract the current status of the parity map. */ 62void 63rf_paritymap_status(struct rf_paritymap *pm, struct rf_pmstat *ps) 64{ 65 memset(ps, 0, sizeof(*ps)); 66 if (pm == NULL) 67 ps->enabled = 0; 68 else { 69 ps->enabled = 1; 70 ps->region_size = pm->region_size; 71 mutex_enter(&pm->lock); 72 memcpy(&ps->params, &pm->params, sizeof(ps->params)); 73 memcpy(ps->dirty, pm->disk_now, sizeof(ps->dirty)); 74 memcpy(&ps->ctrs, &pm->ctrs, sizeof(ps->ctrs)); 75 mutex_exit(&pm->lock); 76 } 77} 78 79/* 80 * Test whether parity in a given sector is suspected of being inconsistent 81 * on disk (assuming that any pending I/O to it is allowed to complete). 82 * This may be of interest to future work on parity scrubbing. 83 */ 84int 85rf_paritymap_test(struct rf_paritymap *pm, daddr_t sector) 86{ 87 unsigned region = sector / pm->region_size; 88 int retval; 89 90 mutex_enter(&pm->lock); 91 retval = isset(pm->disk_boot->bits, region) ? 1 : 0; 92 mutex_exit(&pm->lock); 93 return retval; 94} 95 96/* To be called before a write to the RAID is submitted. */ 97void 98rf_paritymap_begin(struct rf_paritymap *pm, daddr_t offset, daddr_t size) 99{ 100 unsigned i, b, e; 101 102 b = offset / pm->region_size; 103 e = (offset + size - 1) / pm->region_size; 104 105 for (i = b; i <= e; i++) 106 rf_paritymap_begin_region(pm, i); 107} 108 109/* To be called after a write to the RAID completes. */ 110void 111rf_paritymap_end(struct rf_paritymap *pm, daddr_t offset, daddr_t size) 112{ 113 unsigned i, b, e; 114 115 b = offset / pm->region_size; 116 e = (offset + size - 1) / pm->region_size; 117 118 for (i = b; i <= e; i++) 119 rf_paritymap_end_region(pm, i); 120} 121 122void 123rf_paritymap_begin_region(struct rf_paritymap *pm, unsigned region) 124{ 125 int needs_write; 126 127 KASSERT(region < RF_PARITYMAP_NREG); 128 pm->ctrs.nwrite++; 129 130 /* If it was being kept warm, deal with that. */ 131 mutex_enter(&pm->lock); 132 if (pm->current->state[region] < 0) 133 pm->current->state[region] = 0; 134 135 /* This shouldn't happen unless RAIDOUTSTANDING is set too high. */ 136 KASSERT(pm->current->state[region] < 127); 137 pm->current->state[region]++; 138 139 needs_write = isclr(pm->disk_now->bits, region); 140 141 if (needs_write) { 142 KASSERT(pm->current->state[region] == 1); 143 rf_paritymap_write_locked(pm); 144 } 145 146 mutex_exit(&pm->lock); 147} 148 149void 150rf_paritymap_end_region(struct rf_paritymap *pm, unsigned region) 151{ 152 KASSERT(region < RF_PARITYMAP_NREG); 153 154 mutex_enter(&pm->lock); 155 KASSERT(pm->current->state[region] > 0); 156 --pm->current->state[region]; 157 158 if (pm->current->state[region] <= 0) { 159 pm->current->state[region] = -pm->params.cooldown; 160 KASSERT(pm->current->state[region] <= 0); 161 mutex_enter(&pm->lk_flags); 162 if (!(pm->flags & TICKING)) { 163 pm->flags |= TICKING; 164 mutex_exit(&pm->lk_flags); 165 callout_schedule(&pm->ticker, 166 mstohz(pm->params.tickms)); 167 } else 168 mutex_exit(&pm->lk_flags); 169 } 170 mutex_exit(&pm->lock); 171} 172 173/* 174 * Updates the parity map to account for any changes in current activity 175 * and/or an ongoing parity scan, then writes it to disk with appropriate 176 * synchronization. 177 */ 178void 179rf_paritymap_write(struct rf_paritymap *pm) 180{ 181 mutex_enter(&pm->lock); 182 rf_paritymap_write_locked(pm); 183 mutex_exit(&pm->lock); 184} 185 186/* As above, but to be used when pm->lock is already held. */ 187static void 188rf_paritymap_write_locked(struct rf_paritymap *pm) 189{ 190 char w, w0; 191 int i, j, setting, clearing; 192 193 setting = clearing = 0; 194 for (i = 0; i < RF_PARITYMAP_NBYTE; i++) { 195 w0 = pm->disk_now->bits[i]; 196 w = pm->disk_boot->bits[i]; 197 198 for (j = 0; j < NBBY; j++) 199 if (pm->current->state[i * NBBY + j] != 0) 200 w |= 1 << j; 201 202 if (w & ~w0) 203 setting = 1; 204 if (w0 & ~w) 205 clearing = 1; 206 207 pm->disk_now->bits[i] = w; 208 } 209 pm->ctrs.ncachesync += setting + clearing; 210 pm->ctrs.nclearing += clearing; 211 212 /* 213 * If bits are being set in the parity map, then a sync is 214 * required afterwards, so that the regions are marked dirty 215 * on disk before any writes to them take place. If bits are 216 * being cleared, then a sync is required before the write, so 217 * that any writes to those regions are processed before the 218 * region is marked clean. (Synchronization is somewhat 219 * overkill; a write ordering barrier would suffice, but we 220 * currently have no way to express that directly.) 221 */ 222 if (clearing) 223 rf_sync_component_caches(pm->raid); 224 rf_paritymap_kern_write(pm->raid, pm->disk_now); 225 if (setting) 226 rf_sync_component_caches(pm->raid); 227} 228 229/* Mark all parity as being in need of rewrite. */ 230void 231rf_paritymap_invalidate(struct rf_paritymap *pm) 232{ 233 mutex_enter(&pm->lock); 234 memset(pm->disk_boot, ~(unsigned char)0, 235 sizeof(struct rf_paritymap_ondisk)); 236 mutex_exit(&pm->lock); 237} 238 239/* Mark all parity as being correct. */ 240void 241rf_paritymap_forceclean(struct rf_paritymap *pm) 242{ 243 mutex_enter(&pm->lock); 244 memset(pm->disk_boot, (unsigned char)0, 245 sizeof(struct rf_paritymap_ondisk)); 246 mutex_exit(&pm->lock); 247} 248 249/* 250 * The cooldown callout routine just defers its work to a thread; it can't do 251 * the parity map write itself as it would block, and although mutex-induced 252 * blocking is permitted it seems wise to avoid tying up the softint. 253 */ 254static void 255rf_paritymap_tick(void *arg) 256{ 257 struct rf_paritymap *pm = arg; 258 259 mutex_enter(&pm->lk_flags); 260 pm->flags |= TICKED; 261 mutex_exit(&pm->lk_flags); 262 wakeup(&(pm->raid->iodone)); /* XXX */ 263} 264 265/* 266 * This is where the parity cooling work (and rearming the callout if needed) 267 * is done; the raidio thread calls it when woken up, as by the above. 268 */ 269void 270rf_paritymap_checkwork(struct rf_paritymap *pm) 271{ 272 int i, zerop, progressp; 273 274 mutex_enter(&pm->lk_flags); 275 if (pm->flags & TICKED) { 276 zerop = progressp = 0; 277 278 pm->flags &= ~TICKED; 279 mutex_exit(&pm->lk_flags); 280 281 mutex_enter(&pm->lock); 282 for (i = 0; i < RF_PARITYMAP_NREG; i++) { 283 if (pm->current->state[i] < 0) { 284 progressp = 1; 285 pm->current->state[i]++; 286 if (pm->current->state[i] == 0) 287 zerop = 1; 288 } 289 } 290 291 if (progressp) 292 callout_schedule(&pm->ticker, 293 mstohz(pm->params.tickms)); 294 else { 295 mutex_enter(&pm->lk_flags); 296 pm->flags &= ~TICKING; 297 mutex_exit(&pm->lk_flags); 298 } 299 300 if (zerop) 301 rf_paritymap_write_locked(pm); 302 mutex_exit(&pm->lock); 303 } else 304 mutex_exit(&pm->lk_flags); 305} 306 307/* 308 * Set parity map parameters; used both to alter parameters on the fly and to 309 * establish their initial values. Note that setting a parameter to 0 means 310 * to leave the previous setting unchanged, and that if this is done for the 311 * initial setting of "regions", then a default value will be computed based 312 * on the RAID component size. 313 */ 314int 315rf_paritymap_set_params(struct rf_paritymap *pm, 316 const struct rf_pmparams *params, int todisk) 317{ 318 int cooldown, tickms; 319 u_int regions; 320 RF_RowCol_t col; 321 RF_ComponentLabel_t *clabel; 322 RF_Raid_t *raidPtr; 323 324 cooldown = params->cooldown != 0 325 ? params->cooldown : pm->params.cooldown; 326 tickms = params->tickms != 0 327 ? params->tickms : pm->params.tickms; 328 regions = params->regions != 0 329 ? params->regions : pm->params.regions; 330 331 if (cooldown < 1 || cooldown > 128) { 332 printf("raid%d: cooldown %d out of range\n", pm->raid->raidid, 333 cooldown); 334 return (-1); 335 } 336 if (tickms < 10) { 337 printf("raid%d: tick time %dms out of range\n", 338 pm->raid->raidid, tickms); 339 return (-1); 340 } 341 if (regions == 0) { 342 regions = rf_paritymap_nreg(pm->raid); 343 } else if (regions > RF_PARITYMAP_NREG) { 344 printf("raid%d: region count %u too large (more than %u)\n", 345 pm->raid->raidid, regions, RF_PARITYMAP_NREG); 346 return (-1); 347 } 348 349 /* XXX any currently warm parity will be used with the new tickms! */ 350 pm->params.cooldown = cooldown; 351 pm->params.tickms = tickms; 352 /* Apply the initial region count, but do not change it after that. */ 353 if (pm->params.regions == 0) 354 pm->params.regions = regions; 355 356 /* So that the newly set parameters can be tested: */ 357 pm->ctrs.nwrite = pm->ctrs.ncachesync = pm->ctrs.nclearing = 0; 358 359 if (todisk) { 360 raidPtr = pm->raid; 361 for (col = 0; col < raidPtr->numCol; col++) { 362 clabel = raidget_component_label(raidPtr, col); 363 clabel->parity_map_ntick = cooldown; 364 clabel->parity_map_tickms = tickms; 365 clabel->parity_map_regions = regions; 366 raidflush_component_label(raidPtr, col); 367 } 368 } 369 return 0; 370} 371 372/* 373 * The number of regions may not be as many as can fit into the map, because 374 * when regions are too small, the overhead of setting parity map bits 375 * becomes significant in comparison to the actual I/O, while the 376 * corresponding gains in parity verification time become negligible. Thus, 377 * a minimum region size (defined above) is imposed. 378 * 379 * Note that, if the number of regions is less than the maximum, then some of 380 * the regions will be "fictional", corresponding to no actual disk; some 381 * parts of the code may process them as normal, but they can not ever be 382 * written to. 383 */ 384static u_int 385rf_paritymap_nreg(RF_Raid_t *raid) 386{ 387 daddr_t bytes_per_disk, nreg; 388 389 bytes_per_disk = raid->sectorsPerDisk << raid->logBytesPerSector; 390 nreg = bytes_per_disk / REGION_MINSIZE; 391 if (nreg > RF_PARITYMAP_NREG) 392 nreg = RF_PARITYMAP_NREG; 393 394 return (u_int)nreg; 395} 396 397/* 398 * Initialize a parity map given specific parameters. This neither reads nor 399 * writes the parity map config in the component labels; for that, see below. 400 */ 401int 402rf_paritymap_init(struct rf_paritymap *pm, RF_Raid_t *raid, 403 const struct rf_pmparams *params) 404{ 405 daddr_t rstripes; 406 struct rf_pmparams safe; 407 408 pm->raid = raid; 409 pm->params.regions = 0; 410 if (0 != rf_paritymap_set_params(pm, params, 0)) { 411 /* 412 * If the parameters are out-of-range, then bring the 413 * parity map up with something reasonable, so that 414 * the admin can at least go and fix it (or ignore it 415 * entirely). 416 */ 417 safe.cooldown = DFL_COOLDOWN; 418 safe.tickms = DFL_TICKMS; 419 safe.regions = 0; 420 421 if (0 != rf_paritymap_set_params(pm, &safe, 0)) 422 return (-1); 423 } 424 425 rstripes = howmany(raid->Layout.numStripe, pm->params.regions); 426 pm->region_size = rstripes * raid->Layout.dataSectorsPerStripe; 427 428 callout_init(&pm->ticker, CALLOUT_MPSAFE); 429 callout_setfunc(&pm->ticker, rf_paritymap_tick, pm); 430 pm->flags = 0; 431 432 pm->disk_boot = kmem_alloc(sizeof(struct rf_paritymap_ondisk), 433 KM_SLEEP); 434 pm->disk_now = kmem_alloc(sizeof(struct rf_paritymap_ondisk), 435 KM_SLEEP); 436 pm->current = kmem_zalloc(sizeof(struct rf_paritymap_current), 437 KM_SLEEP); 438 439 rf_paritymap_kern_read(pm->raid, pm->disk_boot); 440 memcpy(pm->disk_now, pm->disk_boot, sizeof(*pm->disk_now)); 441 442 mutex_init(&pm->lock, MUTEX_DEFAULT, IPL_NONE); 443 mutex_init(&pm->lk_flags, MUTEX_DEFAULT, IPL_SOFTCLOCK); 444 445 return 0; 446} 447 448/* 449 * Destroys a parity map; unless "force" is set, also cleans parity for any 450 * regions which were still in cooldown (but are not dirty on disk). 451 */ 452void 453rf_paritymap_destroy(struct rf_paritymap *pm, int force) 454{ 455 int i; 456 457 callout_halt(&pm->ticker, NULL); /* XXX stop? halt? */ 458 callout_destroy(&pm->ticker); 459 460 if (!force) { 461 for (i = 0; i < RF_PARITYMAP_NREG; i++) { 462 /* XXX check for > 0 ? */ 463 if (pm->current->state[i] < 0) 464 pm->current->state[i] = 0; 465 } 466 467 rf_paritymap_write_locked(pm); 468 } 469 470 mutex_destroy(&pm->lock); 471 mutex_destroy(&pm->lk_flags); 472 473 kmem_free(pm->disk_boot, sizeof(struct rf_paritymap_ondisk)); 474 kmem_free(pm->disk_now, sizeof(struct rf_paritymap_ondisk)); 475 kmem_free(pm->current, sizeof(struct rf_paritymap_current)); 476} 477 478/* 479 * Rewrite parity, taking parity map into account; this is the equivalent of 480 * the old rf_RewriteParity, and is likewise to be called from a suitable 481 * thread and shouldn't have multiple copies running in parallel and so on. 482 * 483 * Note that the fictional regions are "cleaned" in one shot, so that very 484 * small RAIDs (useful for testing) will not experience potentially severe 485 * regressions in rewrite time. 486 */ 487int 488rf_paritymap_rewrite(struct rf_paritymap *pm) 489{ 490 int i, ret_val = 0; 491 daddr_t reg_b, reg_e; 492 493 /* Process only the actual regions. */ 494 for (i = 0; i < pm->params.regions; i++) { 495 mutex_enter(&pm->lock); 496 if (isset(pm->disk_boot->bits, i)) { 497 mutex_exit(&pm->lock); 498 499 reg_b = i * pm->region_size; 500 reg_e = reg_b + pm->region_size; 501 if (reg_e > pm->raid->totalSectors) 502 reg_e = pm->raid->totalSectors; 503 504 if (rf_RewriteParityRange(pm->raid, reg_b, 505 reg_e - reg_b)) { 506 ret_val = 1; 507 if (pm->raid->waitShutdown) 508 return ret_val; 509 } else { 510 mutex_enter(&pm->lock); 511 clrbit(pm->disk_boot->bits, i); 512 rf_paritymap_write_locked(pm); 513 mutex_exit(&pm->lock); 514 } 515 } else { 516 mutex_exit(&pm->lock); 517 } 518 } 519 520 /* Now, clear the fictional regions, if any. */ 521 rf_paritymap_forceclean(pm); 522 rf_paritymap_write(pm); 523 524 return ret_val; 525} 526 527/* 528 * How to merge the on-disk parity maps when reading them in from the 529 * various components; returns whether they differ. In the case that 530 * they do differ, sets *dst to the union of *dst and *src. 531 * 532 * In theory, it should be safe to take the intersection (or just pick 533 * a single component arbitrarily), but the paranoid approach costs 534 * little. 535 * 536 * Appropriate locking, if any, is the responsibility of the caller. 537 */ 538int 539rf_paritymap_merge(struct rf_paritymap_ondisk *dst, 540 struct rf_paritymap_ondisk *src) 541{ 542 int i, discrep = 0; 543 544 for (i = 0; i < RF_PARITYMAP_NBYTE; i++) { 545 if (dst->bits[i] != src->bits[i]) 546 discrep = 1; 547 dst->bits[i] |= src->bits[i]; 548 } 549 550 return discrep; 551} 552 553/* 554 * Detach a parity map from its RAID. This is not meant to be applied except 555 * when unconfiguring the RAID after all I/O has been resolved, as otherwise 556 * an out-of-date parity map could be treated as current. 557 */ 558void 559rf_paritymap_detach(RF_Raid_t *raidPtr) 560{ 561 if (raidPtr->parity_map == NULL) 562 return; 563 564 simple_lock(&(raidPtr->iodone_lock)); 565 struct rf_paritymap *pm = raidPtr->parity_map; 566 raidPtr->parity_map = NULL; 567 simple_unlock(&(raidPtr->iodone_lock)); 568 /* XXXjld is that enough locking? Or too much? */ 569 rf_paritymap_destroy(pm, 0); 570 kmem_free(pm, sizeof(*pm)); 571} 572 573/* 574 * Attach a parity map to a RAID set if appropriate. Includes 575 * configure-time processing of parity-map fields of component label. 576 */ 577void 578rf_paritymap_attach(RF_Raid_t *raidPtr, int force) 579{ 580 RF_RowCol_t col; 581 int pm_use, pm_zap; 582 int g_tickms, g_ntick, g_regions; 583 int good; 584 RF_ComponentLabel_t *clabel; 585 u_int flags, regions; 586 struct rf_pmparams params; 587 588 if (raidPtr->Layout.map->faultsTolerated == 0) { 589 /* There isn't any parity. */ 590 return; 591 } 592 593 pm_use = 1; 594 pm_zap = 0; 595 g_tickms = DFL_TICKMS; 596 g_ntick = DFL_COOLDOWN; 597 g_regions = 0; 598 599 /* 600 * Collect opinions on the set config. If this is the initial 601 * config (raidctl -C), treat all labels as invalid, since 602 * there may be random data present. 603 */ 604 if (!force) { 605 for (col = 0; col < raidPtr->numCol; col++) { 606 clabel = raidget_component_label(raidPtr, col); 607 flags = clabel->parity_map_flags; 608 /* Check for use by non-parity-map kernel. */ 609 if (clabel->parity_map_modcount 610 != clabel->mod_counter) { 611 flags &= ~RF_PMLABEL_WASUSED; 612 } 613 614 if (flags & RF_PMLABEL_VALID) { 615 g_tickms = clabel->parity_map_tickms; 616 g_ntick = clabel->parity_map_ntick; 617 regions = clabel->parity_map_regions; 618 if (g_regions == 0) 619 g_regions = regions; 620 else if (g_regions != regions) { 621 pm_zap = 1; /* important! */ 622 } 623 624 if (flags & RF_PMLABEL_DISABLE) { 625 pm_use = 0; 626 } 627 if (!(flags & RF_PMLABEL_WASUSED)) { 628 pm_zap = 1; 629 } 630 } else { 631 pm_zap = 1; 632 } 633 } 634 } else { 635 pm_zap = 1; 636 } 637 638 /* Finally, create and attach the parity map. */ 639 if (pm_use) { 640 params.cooldown = g_ntick; 641 params.tickms = g_tickms; 642 params.regions = g_regions; 643 644 raidPtr->parity_map = kmem_alloc(sizeof(struct rf_paritymap), 645 KM_SLEEP); 646 if (0 != rf_paritymap_init(raidPtr->parity_map, raidPtr, 647 ¶ms)) { 648 /* It failed; do without. */ 649 kmem_free(raidPtr->parity_map, 650 sizeof(struct rf_paritymap)); 651 raidPtr->parity_map = NULL; 652 return; 653 } 654 655 if (g_regions == 0) 656 /* Pick up the autoconfigured region count. */ 657 g_regions = raidPtr->parity_map->params.regions; 658 659 if (pm_zap) { 660 good = raidPtr->parity_good && !force; 661 662 if (good) 663 rf_paritymap_forceclean(raidPtr->parity_map); 664 else 665 rf_paritymap_invalidate(raidPtr->parity_map); 666 /* This needs to be on disk before WASUSED is set. */ 667 rf_paritymap_write(raidPtr->parity_map); 668 } 669 } 670 671 /* Alter labels in-core to reflect the current view of things. */ 672 for (col = 0; col < raidPtr->numCol; col++) { 673 clabel = raidget_component_label(raidPtr, col); 674 675 if (pm_use) 676 flags = RF_PMLABEL_VALID | RF_PMLABEL_WASUSED; 677 else 678 flags = RF_PMLABEL_VALID | RF_PMLABEL_DISABLE; 679 680 clabel->parity_map_flags = flags; 681 clabel->parity_map_tickms = g_tickms; 682 clabel->parity_map_ntick = g_ntick; 683 clabel->parity_map_regions = g_regions; 684 raidflush_component_label(raidPtr, col); 685 } 686} 687 688/* 689 * For initializing the parity-map fields of a component label, both on 690 * initial creation and on reconstruct/copyback/etc. 691 */ 692void 693rf_paritymap_init_label(struct rf_paritymap *pm, RF_ComponentLabel_t *clabel) 694{ 695 if (pm != NULL) { 696 clabel->parity_map_flags = 697 RF_PMLABEL_VALID | RF_PMLABEL_WASUSED; 698 clabel->parity_map_tickms = pm->params.tickms; 699 clabel->parity_map_ntick = pm->params.cooldown; 700 /* 701 * XXXjld: If the number of regions is changed on disk, and 702 * then a new component is labeled before the next configure, 703 * then it will get the old value and they will conflict on 704 * the next boot (and the default will be used instead). 705 */ 706 clabel->parity_map_regions = pm->params.regions; 707 } else { 708 /* 709 * XXXjld: if the map is disabled, and all the components are 710 * replaced without an intervening unconfigure/reconfigure, 711 * then it will become enabled on the next unconfig/reconfig. 712 */ 713 } 714} 715 716 717/* Will the parity map be disabled next time? */ 718int 719rf_paritymap_get_disable(RF_Raid_t *raidPtr) 720{ 721 RF_ComponentLabel_t *clabel; 722 RF_RowCol_t col; 723 int dis; 724 725 dis = 0; 726 for (col = 0; col < raidPtr->numCol; col++) { 727 clabel = raidget_component_label(raidPtr, col); 728 if (clabel->parity_map_flags & RF_PMLABEL_DISABLE) 729 dis = 1; 730 } 731 732 return dis; 733} 734 735/* Set whether the parity map will be disabled next time. */ 736void 737rf_paritymap_set_disable(RF_Raid_t *raidPtr, int dis) 738{ 739 RF_ComponentLabel_t *clabel; 740 RF_RowCol_t col; 741 742 for (col = 0; col < raidPtr->numCol; col++) { 743 clabel = raidget_component_label(raidPtr, col); 744 if (dis) 745 clabel->parity_map_flags |= RF_PMLABEL_DISABLE; 746 else 747 clabel->parity_map_flags &= ~RF_PMLABEL_DISABLE; 748 raidflush_component_label(raidPtr, col); 749 } 750} 751