?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
7712 mandoc -Tlint does always exit with error code 0
[unleashed.git] / usr / src / uts / common / io / lvm / raid / raid.c
blob940a3e99df53644665311f7a6d837b2b25573f32
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
26 */
27
28 /*
29 * NAME: raid.c
30 *
31 * DESCRIPTION: Main RAID driver source file containing open, close and I/O
32 * operations.
33 *
34 * ROUTINES PROVIDED FOR EXTERNAL USE:
35 * raid_open() - open the RAID metadevice for access.
36 * raid_internal_open() - internal open routine of RAID metdevice.
37 * md_raid_strategy() - perform normal I/O operations,
38 * such as read and write.
39 * raid_close() - close the RAID metadevice.
40 * raid_internal_close() - internal close routine of RAID metadevice.
41 * raid_snarf() - initialize and clean up MDD records.
42 * raid_halt() - reset the RAID metadevice
43 * raid_line() - return the line # of this segment
44 * raid_dcolumn() - return the data column # of this segment
45 * raid_pcolumn() - return the parity column # of this segment
46 */
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/conf.h>
51 #include <sys/file.h>
52 #include <sys/user.h>
53 #include <sys/uio.h>
54 #include <sys/t_lock.h>
55 #include <sys/buf.h>
56 #include <sys/dkio.h>
57 #include <sys/vtoc.h>
58 #include <sys/kmem.h>
59 #include <vm/page.h>
60 #include <sys/cmn_err.h>
61 #include <sys/sysmacros.h>
62 #include <sys/types.h>
63 #include <sys/mkdev.h>
64 #include <sys/stat.h>
65 #include <sys/open.h>
66 #include <sys/modctl.h>
67 #include <sys/ddi.h>
68 #include <sys/sunddi.h>
69 #include <sys/debug.h>
70 #include <sys/lvm/md_raid.h>
71 #include <sys/lvm/mdvar.h>
72 #include <sys/lvm/md_convert.h>
73
74 #include <sys/sysevent/eventdefs.h>
75 #include <sys/sysevent/svm.h>
76
77 md_ops_t raid_md_ops;
78 #ifndef lint
79 md_ops_t *md_interface_ops = &raid_md_ops;
80 #endif /* lint */
81
82 extern unit_t md_nunits;
83 extern unit_t md_nsets;
84 extern md_set_t md_set[];
85 extern int md_status;
86 extern major_t md_major;
87 extern mdq_anchor_t md_done_daemon;
88 extern mdq_anchor_t md_mstr_daemon;
89 extern int md_sleep_for_test;
90 extern clock_t md_hz;
91
92 extern md_event_queue_t *md_event_queue;
93
94
95 int pchunks = 16;
96 int phigh = 1024;
97 int plow = 128;
98 int cchunks = 64;
99 int chigh = 1024;
100 int clow = 512;
101 int bchunks = 32;
102 int bhigh = 256;
103 int blow = 128;
104
105 int raid_total_io = 0;
106 int raid_reads = 0;
107 int raid_writes = 0;
108 int raid_no_bpmaps = 0;
109 int raid_512 = 0;
110 int raid_1024 = 0;
111 int raid_1024_8192 = 0;
112 int raid_8192 = 0;
113 int raid_8192_bigger = 0;
114 int raid_line_lock_wait = 0;
115
116 int data_buffer_waits = 0;
117 int parity_buffer_waits = 0;
118
119 /* writer line locks */
120 int raid_writer_locks = 0; /* total writer locks */
121 int raid_write_waits = 0; /* total writer locks that waited */
122 int raid_full_line_writes = 0; /* total full line writes */
123 int raid_write_queue_length = 0; /* wait queue length */
124 int raid_max_write_q_length = 0; /* maximum queue length */
125 int raid_write_locks_active = 0; /* writer locks at any time */
126 int raid_max_write_locks = 0; /* maximum writer locks active */
127
128 /* read line locks */
129 int raid_reader_locks = 0; /* total reader locks held */
130 int raid_reader_locks_active = 0; /* reader locks held */
131 int raid_max_reader_locks = 0; /* maximum reader locks held in run */
132 int raid_read_overlaps = 0; /* number of times 2 reads hit same line */
133 int raid_read_waits = 0; /* times a reader waited on writer */
134
135 /* prewrite stats */
136 int raid_prewrite_waits = 0; /* number of waits for a pw slot */
137 int raid_pw = 0; /* number of pw slots in use */
138 int raid_prewrite_max = 0; /* maximum number of pw slots in use */
139 int raid_pw_invalidates = 0;
140
141 static clock_t md_wr_wait = 0;
142
143 int nv_available = 0; /* presence of nv-ram support in device */
144 int nv_prewrite = 1; /* mark prewrites with nv_available */
145 int nv_parity = 1; /* mark parity with nv_available */
146
147 kmem_cache_t *raid_parent_cache = NULL;
148 kmem_cache_t *raid_child_cache = NULL;
149 kmem_cache_t *raid_cbuf_cache = NULL;
150
151 int raid_internal_open(minor_t mnum, int flag, int otyp,
152 int md_oflags);
153
154 static void freebuffers(md_raidcs_t *cs);
155 static int raid_read(mr_unit_t *un, md_raidcs_t *cs);
156 static void raid_read_io(mr_unit_t *un, md_raidcs_t *cs);
157 static int raid_write(mr_unit_t *un, md_raidcs_t *cs);
158 static void raid_write_io(mr_unit_t *un, md_raidcs_t *cs);
159 static void raid_stage(md_raidcs_t *cs);
160 static void raid_enqueue(md_raidcs_t *cs);
161 static diskaddr_t raid_line(diskaddr_t segment, mr_unit_t *un);
162 uint_t raid_dcolumn(diskaddr_t segment, mr_unit_t *un);
163 static void getpbuffer(md_raidcs_t *cs);
164 static void getdbuffer(md_raidcs_t *cs);
165 static void raid_done(buf_t *bp);
166 static void raid_io_startup(mr_unit_t *un);
167
168 static rus_state_t
169 raid_col2unit(rcs_state_t state, rus_state_t unitstate)
170 {
171 switch (state) {
172 case RCS_INIT:
173 return (RUS_INIT);
174 case RCS_OKAY:
175 return (RUS_OKAY);
176 case RCS_RESYNC:
177 if (unitstate & RUS_LAST_ERRED)
178 return (RUS_LAST_ERRED);
179 else
180 return (RUS_ERRED);
181 case RCS_ERRED:
182 return (RUS_ERRED);
183 case RCS_LAST_ERRED:
184 return (RUS_ERRED);
185 default:
186 break;
187 }
188 panic("raid_col2unit");
189 /*NOTREACHED*/
190 }
191
192 void
193 raid_set_state(mr_unit_t *un, int col, rcs_state_t newstate, int force)
194 {
195
196 rus_state_t unitstate, origstate;
197 rcs_state_t colstate;
198 rcs_state_t orig_colstate;
199 int errcnt = 0, okaycnt = 0, resynccnt = 0;
200 int i;
201 char *devname;
202
203 ASSERT(un);
204 ASSERT(col < un->un_totalcolumncnt);
205 ASSERT(newstate &
206 (RCS_INIT | RCS_INIT_ERRED | RCS_OKAY | RCS_RESYNC | RCS_ERRED |
207 RCS_LAST_ERRED | RCS_REGEN));
208 ASSERT((newstate &
209 ~(RCS_INIT | RCS_INIT_ERRED | RCS_OKAY | RCS_RESYNC | RCS_ERRED |
210 RCS_LAST_ERRED | RCS_REGEN))
211 == 0);
212
213 ASSERT(MDI_UNIT(MD_SID(un)) ? UNIT_WRITER_HELD(un) : 1);
214
215 unitstate = un->un_state;
216 origstate = unitstate;
217
218 if (force) {
219 un->un_column[col].un_devstate = newstate;
220 un->un_state = raid_col2unit(newstate, unitstate);
221 uniqtime32(&un->un_column[col].un_devtimestamp);
222 uniqtime32(&un->un_timestamp);
223 return;
224 }
225
226 ASSERT(un->un_state &
227 (RUS_INIT | RUS_OKAY | RUS_ERRED | RUS_DOI | RUS_LAST_ERRED |
228 RUS_REGEN));
229 ASSERT((un->un_state & ~(RUS_INIT |
230 RUS_OKAY | RUS_ERRED | RUS_DOI | RUS_LAST_ERRED | RUS_REGEN)) == 0);
231
232 if (un->un_column[col].un_devstate == newstate)
233 return;
234
235 if (newstate == RCS_REGEN) {
236 if (raid_state_cnt(un, RCS_OKAY) != un->un_totalcolumncnt)
237 return;
238 un->un_state = RUS_REGEN;
239 return;
240 }
241
242 orig_colstate = un->un_column[col].un_devstate;
243
244 /*
245 * if there is another column in the error state then this
246 * column should go to the last errored state
247 */
248 for (i = 0; i < un->un_totalcolumncnt; i++) {
249 if (i == col)
250 colstate = newstate;
251 else
252 colstate = un->un_column[i].un_devstate;
253 if (colstate & (RCS_ERRED | RCS_LAST_ERRED | RCS_INIT_ERRED))
254 errcnt++;
255 if (colstate & RCS_OKAY)
256 okaycnt++;
257 if (colstate & RCS_RESYNC)
258 resynccnt++;
259 }
260 ASSERT(resynccnt < 2);
261
262 if (okaycnt == un->un_totalcolumncnt)
263 unitstate = RUS_OKAY;
264 else if (errcnt > 1) {
265 unitstate = RUS_LAST_ERRED;
266 if (newstate & RCS_ERRED)
267 newstate = RCS_LAST_ERRED;
268 } else if (errcnt == 1)
269 if (!(unitstate & RUS_LAST_ERRED))
270 unitstate = RUS_ERRED;
271
272 if (un->un_state == RUS_DOI)
273 unitstate = RUS_DOI;
274
275 un->un_column[col].un_devstate = newstate;
276 uniqtime32(&un->un_column[col].un_devtimestamp);
277 /*
278 * if there are last errored column being brought back online
279 * by open or snarf, then be sure to clear the RUS_LAST_ERRED
280 * bit to allow writes. If there is a real error then the
281 * column will go back into last erred.
282 */
283 if ((raid_state_cnt(un, RCS_LAST_ERRED) == 0) &&
284 (raid_state_cnt(un, RCS_ERRED) == 1))
285 unitstate = RUS_ERRED;
286
287 un->un_state = unitstate;
288 uniqtime32(&un->un_timestamp);
289
290 if ((! (origstate & (RUS_ERRED|RUS_LAST_ERRED|RUS_DOI))) &&
291 (unitstate & (RUS_ERRED|RUS_LAST_ERRED|RUS_DOI))) {
292 devname = md_devname(MD_UN2SET(un),
293 un->un_column[col].un_dev, NULL, 0);
294
295 cmn_err(CE_WARN, "md: %s: %s needs maintenance",
296 md_shortname(MD_SID(un)), devname);
297
298 if (unitstate & RUS_LAST_ERRED) {
299 cmn_err(CE_WARN, "md: %s: %s last erred",
300 md_shortname(MD_SID(un)), devname);
301
302 } else if (un->un_column[col].un_devflags &
303 MD_RAID_DEV_ISOPEN) {
304 /*
305 * Close the broken device and clear the open flag on
306 * it. We have to check that the device is open,
307 * otherwise the first open on it has resulted in the
308 * error that is being processed and the actual un_dev
309 * will be NODEV64.
310 */
311 md_layered_close(un->un_column[col].un_dev,
312 MD_OFLG_NULL);
313 un->un_column[col].un_devflags &= ~MD_RAID_DEV_ISOPEN;
314 }
315 } else if (orig_colstate == RCS_LAST_ERRED && newstate == RCS_ERRED &&
316 un->un_column[col].un_devflags & MD_RAID_DEV_ISOPEN) {
317 /*
318 * Similar to logic above except no log messages since we
319 * are just transitioning from Last Erred to Erred.
320 */
321 md_layered_close(un->un_column[col].un_dev, MD_OFLG_NULL);
322 un->un_column[col].un_devflags &= ~MD_RAID_DEV_ISOPEN;
323 }
324
325 /*
326 * If a resync has completed, see if there is a Last Erred
327 * component that we can change to the Erred state.
328 */
329 if ((orig_colstate == RCS_RESYNC) && (newstate == RCS_OKAY)) {
330 for (i = 0; i < un->un_totalcolumncnt; i++) {
331 if (i != col &&
332 (un->un_column[i].un_devstate & RCS_LAST_ERRED)) {
333 raid_set_state(un, i, RCS_ERRED, 0);
334 break;
335 }
336 }
337 }
338 }
339
340 /*
341 * NAME: erred_check_line
342 *
343 * DESCRIPTION: Return the type of write to perform on an erred column based
344 * upon any resync activity.
345 *
346 * if a column is being resynced and the write is above the
347 * resync point may have to write to the target being resynced.
348 *
349 * Column state may make it impossible to do the write
350 * in which case RCL_EIO or RCL_ENXIO is returned.
351 *
352 * If a column cannot be written directly, RCL_ERRED is
353 * returned and processing should proceed accordingly.
354 *
355 * PARAMETERS: minor_t mnum - minor number identity of metadevice
356 * md_raidcs_t *cs - child save structure
357 * mr_column_t *dcolumn - pointer to data column structure
358 * mr_column_t *pcolumn - pointer to parity column structure
359 *
360 * RETURNS: RCL_OKAY, RCL_ERRED
361 *
362 * LOCKS: Expects Line Writer Lock and Unit Resource Lock to be held
363 * across call.
364 */
365
366 static int
367 erred_check_line(mr_unit_t *un, md_raidcs_t *cs, mr_column_t *column)
368 {
369
370 ASSERT(un != NULL);
371 ASSERT(cs->cs_flags & MD_RCS_LLOCKD);
372
373 if (column->un_devstate & RCS_OKAY)
374 return (RCL_OKAY);
375
376 if (column->un_devstate & RCS_ERRED)
377 return (RCL_ERRED); /* do not read from errored disk */
378
379 /*
380 * for the last errored case their are two considerations.
381 * When the last errored column is the only errored column then
382 * do treat it like a maintenance column, not doing I/O from
383 * it. When it there are other failures then just attempt
384 * to use it.
385 */
386 if (column->un_devstate & RCS_LAST_ERRED)
387 return (RCL_ERRED);
388
389 ASSERT(column->un_devstate & RCS_RESYNC);
390
391 /*
392 * When a resync from a hotspare is being done (copy resync)
393 * then always treat it as an OKAY column, since no regen
394 * is required.
395 */
396 if (column->un_devflags & MD_RAID_COPY_RESYNC) {
397 return (RCL_OKAY);
398 }
399
400 mutex_enter(&un->un_mx);
401 if (cs->cs_line < un->un_resync_line_index) {
402 mutex_exit(&un->un_mx);
403 return (RCL_OKAY);
404 }
405 mutex_exit(&un->un_mx);
406 return (RCL_ERRED);
407
408 }
409
410 /*
411 * NAMES: raid_state_cnt
412 *
413 * DESCRIPTION: counts number of column in a specific state
414 *
415 * PARAMETERS: md_raid_t *un
416 * rcs_state state
417 */
418 int
419 raid_state_cnt(mr_unit_t *un, rcs_state_t state)
420 {
421 int i, retval = 0;
422
423 for (i = 0; i < un->un_totalcolumncnt; i++)
424 if (un->un_column[i].un_devstate & state)
425 retval++;
426 return (retval);
427 }
428
429 /*
430 * NAMES: raid_io_overlaps
431 *
432 * DESCRIPTION: checkst for overlap of 2 child save structures
433 *
434 * PARAMETERS: md_raidcs_t cs1
435 * md_raidcs_t cs2
436 *
437 * RETURNS: 0 - no overlap
438 * 1 - overlap
439 */
440 int
441 raid_io_overlaps(md_raidcs_t *cs1, md_raidcs_t *cs2)
442 {
443 if (cs1->cs_blkno > cs2->cs_lastblk)
444 return (0);
445 if (cs1->cs_lastblk < cs2->cs_blkno)
446 return (0);
447 return (1);
448 }
449
450 /*
451 * NAMES: raid_parent_constructor
452 * DESCRIPTION: parent structure constructor routine
453 * PARAMETERS:
454 */
455 /*ARGSUSED1*/
456 static int
457 raid_parent_constructor(void *p, void *d1, int d2)
458 {
459 mutex_init(&((md_raidps_t *)p)->ps_mx,
460 NULL, MUTEX_DEFAULT, NULL);
461 mutex_init(&((md_raidps_t *)p)->ps_mapin_mx,
462 NULL, MUTEX_DEFAULT, NULL);
463 return (0);
464 }
465
466 void
467 raid_parent_init(md_raidps_t *ps)
468 {
469 bzero(ps, offsetof(md_raidps_t, ps_mx));
470 ((md_raidps_t *)ps)->ps_flags = MD_RPS_INUSE;
471 ((md_raidps_t *)ps)->ps_magic = RAID_PSMAGIC;
472 }
473
474 /*ARGSUSED1*/
475 static void
476 raid_parent_destructor(void *p, void *d)
477 {
478 mutex_destroy(&((md_raidps_t *)p)->ps_mx);
479 mutex_destroy(&((md_raidps_t *)p)->ps_mapin_mx);
480 }
481
482 /*
483 * NAMES: raid_child_constructor
484 * DESCRIPTION: child structure constructor routine
485 * PARAMETERS:
486 */
487 /*ARGSUSED1*/
488 static int
489 raid_child_constructor(void *p, void *d1, int d2)
490 {
491 md_raidcs_t *cs = (md_raidcs_t *)p;
492 mutex_init(&cs->cs_mx, NULL, MUTEX_DEFAULT, NULL);
493 bioinit(&cs->cs_dbuf);
494 bioinit(&cs->cs_pbuf);
495 bioinit(&cs->cs_hbuf);
496 return (0);
497 }
498
499 void
500 raid_child_init(md_raidcs_t *cs)
501 {
502 bzero(cs, offsetof(md_raidcs_t, cs_mx));
503
504 md_bioreset(&cs->cs_dbuf);
505 md_bioreset(&cs->cs_pbuf);
506 md_bioreset(&cs->cs_hbuf);
507
508 ((md_raidcs_t *)cs)->cs_dbuf.b_chain =
509 ((md_raidcs_t *)cs)->cs_pbuf.b_chain =
510 ((md_raidcs_t *)cs)->cs_hbuf.b_chain =
511 (struct buf *)(cs);
512
513 cs->cs_magic = RAID_CSMAGIC;
514 cs->cs_line = MD_DISKADDR_ERROR;
515 cs->cs_dpwslot = -1;
516 cs->cs_ppwslot = -1;
517 }
518
519 /*ARGSUSED1*/
520 static void
521 raid_child_destructor(void *p, void *d)
522 {
523 biofini(&((md_raidcs_t *)p)->cs_dbuf);
524 biofini(&((md_raidcs_t *)p)->cs_hbuf);
525 biofini(&((md_raidcs_t *)p)->cs_pbuf);
526 mutex_destroy(&((md_raidcs_t *)p)->cs_mx);
527 }
528
529 /*ARGSUSED1*/
530 static int
531 raid_cbuf_constructor(void *p, void *d1, int d2)
532 {
533 bioinit(&((md_raidcbuf_t *)p)->cbuf_bp);
534 return (0);
535 }
536
537 static void
538 raid_cbuf_init(md_raidcbuf_t *cb)
539 {
540 bzero(cb, offsetof(md_raidcbuf_t, cbuf_bp));
541 md_bioreset(&cb->cbuf_bp);
542 cb->cbuf_magic = RAID_BUFMAGIC;
543 cb->cbuf_pwslot = -1;
544 cb->cbuf_flags = CBUF_WRITE;
545 }
546
547 /*ARGSUSED1*/
548 static void
549 raid_cbuf_destructor(void *p, void *d)
550 {
551 biofini(&((md_raidcbuf_t *)p)->cbuf_bp);
552 }
553
554 /*
555 * NAMES: raid_run_queue
556 * DESCRIPTION: spawn a backend processing daemon for RAID metadevice.
557 * PARAMETERS:
558 */
559 /*ARGSUSED*/
560 static void
561 raid_run_queue(void *d)
562 {
563 if (!(md_status & MD_GBL_DAEMONS_LIVE))
564 md_daemon(1, &md_done_daemon);
565 }
566
567 /*
568 * NAME: raid_build_pwslot
569 * DESCRIPTION: builds mr_pw_reserve for the column
570 * PARAMETERS: un is the pointer to the unit structure
571 * colindex is the column to create the structure for
572 */
573 int
574 raid_build_pw_reservation(mr_unit_t *un, int colindex)
575 {
576 mr_pw_reserve_t *pw;
577 mr_scoreboard_t *sb;
578 int i;
579
580 pw = (mr_pw_reserve_t *) kmem_zalloc(sizeof (mr_pw_reserve_t) +
581 (sizeof (mr_scoreboard_t) * un->un_pwcnt), KM_SLEEP);
582 pw->pw_magic = RAID_PWMAGIC;
583 pw->pw_column = colindex;
584 pw->pw_free = un->un_pwcnt;
585 sb = &pw->pw_sb[0];
586 for (i = 0; i < un->un_pwcnt; i++) {
587 sb[i].sb_column = colindex;
588 sb[i].sb_flags = SB_UNUSED;
589 sb[i].sb_start_blk = 0;
590 sb[i].sb_last_blk = 0;
591 sb[i].sb_cs = NULL;
592 }
593 un->un_column_ic[colindex].un_pw_reserve = pw;
594 return (0);
595 }
596 /*
597 * NAME: raid_free_pw_reservation
598 * DESCRIPTION: RAID metadevice pre-write slot structure destroy routine
599 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
600 * int colindex - index of the column whose pre-write slot struct
601 * is to be destroyed.
602 */
603 void
604 raid_free_pw_reservation(mr_unit_t *un, int colindex)
605 {
606 mr_pw_reserve_t *pw = un->un_column_ic[colindex].un_pw_reserve;
607
608 kmem_free(pw, sizeof (mr_pw_reserve_t) +
609 (sizeof (mr_scoreboard_t) * un->un_pwcnt));
610 }
611
612 /*
613 * NAME: raid_cancel_pwslot
614 * DESCRIPTION: RAID metadevice write routine
615 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
616 */
617 static void
618 raid_cancel_pwslot(md_raidcs_t *cs)
619 {
620 mr_unit_t *un = cs->cs_un;
621 mr_pw_reserve_t *pw;
622 mr_scoreboard_t *sb;
623 mr_column_ic_t *col;
624 md_raidcbuf_t *cbuf;
625 int broadcast = 0;
626
627 if (cs->cs_ps->ps_flags & MD_RPS_READ)
628 return;
629 if (cs->cs_dpwslot != -1) {
630 col = &un->un_column_ic[cs->cs_dcolumn];
631 pw = col->un_pw_reserve;
632 sb = &pw->pw_sb[cs->cs_dpwslot];
633 sb->sb_flags = SB_AVAIL;
634 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
635 broadcast++;
636 sb->sb_cs = NULL;
637 }
638
639 if (cs->cs_ppwslot != -1) {
640 col = &un->un_column_ic[cs->cs_pcolumn];
641 pw = col->un_pw_reserve;
642 sb = &pw->pw_sb[cs->cs_ppwslot];
643 sb->sb_flags = SB_AVAIL;
644 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
645 broadcast++;
646 sb->sb_cs = NULL;
647 }
648
649 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
650 if (cbuf->cbuf_pwslot == -1)
651 continue;
652 col = &un->un_column_ic[cbuf->cbuf_column];
653 pw = col->un_pw_reserve;
654 sb = &pw->pw_sb[cbuf->cbuf_pwslot];
655 sb->sb_flags = SB_AVAIL;
656 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
657 broadcast++;
658 sb->sb_cs = NULL;
659 }
660 if (broadcast) {
661 cv_broadcast(&un->un_cv);
662 return;
663 }
664 mutex_enter(&un->un_mx);
665 if (un->un_rflags & MD_RFLAG_NEEDPW)
666 cv_broadcast(&un->un_cv);
667 mutex_exit(&un->un_mx);
668 }
669
670 static void
671 raid_free_pwinvalidate(md_raidcs_t *cs)
672 {
673 md_raidcbuf_t *cbuf;
674 md_raidcbuf_t *cbuf_to_free;
675 mr_unit_t *un = cs->cs_un;
676 mdi_unit_t *ui = MDI_UNIT(MD_SID(un));
677 mr_pw_reserve_t *pw;
678 mr_scoreboard_t *sb;
679 int broadcast = 0;
680
681 cbuf = cs->cs_pw_inval_list;
682 ASSERT(cbuf);
683 mutex_enter(&un->un_linlck_mx);
684 while (cbuf) {
685 pw = un->un_column_ic[cbuf->cbuf_column].un_pw_reserve;
686 sb = &pw->pw_sb[0];
687 ASSERT(sb[cbuf->cbuf_pwslot].sb_flags & SB_INVAL_PEND);
688 sb[cbuf->cbuf_pwslot].sb_flags = SB_UNUSED;
689 sb[cbuf->cbuf_pwslot].sb_cs = NULL;
690 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
691 broadcast++;
692 cbuf_to_free = cbuf;
693 cbuf = cbuf->cbuf_next;
694 kmem_free(cbuf_to_free->cbuf_buffer, dbtob(un->un_iosize));
695 kmem_cache_free(raid_cbuf_cache, cbuf_to_free);
696 }
697 cs->cs_pw_inval_list = (md_raidcbuf_t *)NULL;
698 /*
699 * now that there is a free prewrite slot, check to see if there
700 * are any io operations waiting first wake up the raid_io_startup
701 * then signal the the processes waiting in raid_write.
702 */
703 if (ui->ui_io_lock->io_list_front)
704 raid_io_startup(un);
705 mutex_exit(&un->un_linlck_mx);
706 if (broadcast) {
707 cv_broadcast(&un->un_cv);
708 return;
709 }
710 mutex_enter(&un->un_mx);
711 if (un->un_rflags & MD_RFLAG_NEEDPW)
712 cv_broadcast(&un->un_cv);
713 mutex_exit(&un->un_mx);
714 }
715
716
717 static int
718 raid_get_pwslot(md_raidcs_t *cs, int column)
719 {
720 mr_scoreboard_t *sb;
721 mr_pw_reserve_t *pw;
722 mr_unit_t *un = cs->cs_un;
723 diskaddr_t start_blk = cs->cs_blkno;
724 diskaddr_t last_blk = cs->cs_lastblk;
725 int i;
726 int pwcnt = un->un_pwcnt;
727 int avail = -1;
728 int use = -1;
729 int flags;
730
731
732 /* start with the data column */
733 pw = cs->cs_un->un_column_ic[column].un_pw_reserve;
734 sb = &pw->pw_sb[0];
735 ASSERT(pw->pw_free > 0);
736 for (i = 0; i < pwcnt; i++) {
737 flags = sb[i].sb_flags;
738 if (flags & SB_INVAL_PEND)
739 continue;
740
741 if ((avail == -1) && (flags & (SB_AVAIL | SB_UNUSED)))
742 avail = i;
743
744 if ((start_blk > sb[i].sb_last_blk) ||
745 (last_blk < sb[i].sb_start_blk))
746 continue;
747
748 /* OVERLAP */
749 ASSERT(! (sb[i].sb_flags & SB_INUSE));
750
751 /*
752 * raid_invalidate_pwslot attempts to zero out prewrite entry
753 * in parallel with other disk reads/writes related to current
754 * transaction. however cs_frags accounting for this case is
755 * broken because raid_write_io resets cs_frags i.e. ignoring
756 * that it could have been been set to > 0 value by
757 * raid_invalidate_pwslot. While this can be fixed an
758 * additional problem is that we don't seem to handle
759 * correctly the case of getting a disk error for prewrite
760 * entry invalidation.
761 * It does not look like we really need
762 * to invalidate prewrite slots because raid_replay sorts
763 * prewrite id's in ascending order and during recovery the
764 * latest prewrite entry for the same block will be replay
765 * last. That's why i ifdef'd out the call to
766 * raid_invalidate_pwslot. --aguzovsk@east
767 */
768
769 if (use == -1) {
770 use = i;
771 }
772 }
773
774 ASSERT(avail != -1);
775 pw->pw_free--;
776 if (use == -1)
777 use = avail;
778
779 ASSERT(! (sb[use].sb_flags & SB_INUSE));
780 sb[use].sb_flags = SB_INUSE;
781 sb[use].sb_cs = cs;
782 sb[use].sb_start_blk = start_blk;
783 sb[use].sb_last_blk = last_blk;
784 ASSERT((use >= 0) && (use < un->un_pwcnt));
785 return (use);
786 }
787
788 static int
789 raid_check_pw(md_raidcs_t *cs)
790 {
791
792 mr_unit_t *un = cs->cs_un;
793 int i;
794
795 ASSERT(! (cs->cs_flags & MD_RCS_HAVE_PW_SLOTS));
796 /*
797 * check to be sure there is a prewrite slot available
798 * if not just return.
799 */
800 if (cs->cs_flags & MD_RCS_LINE) {
801 for (i = 0; i < un->un_totalcolumncnt; i++)
802 if (un->un_column_ic[i].un_pw_reserve->pw_free <= 0)
803 return (1);
804 return (0);
805 }
806
807 if (un->un_column_ic[cs->cs_dcolumn].un_pw_reserve->pw_free <= 0)
808 return (1);
809 if (un->un_column_ic[cs->cs_pcolumn].un_pw_reserve->pw_free <= 0)
810 return (1);
811 return (0);
812 }
813 static int
814 raid_alloc_pwslot(md_raidcs_t *cs)
815 {
816 mr_unit_t *un = cs->cs_un;
817 md_raidcbuf_t *cbuf;
818
819 ASSERT(! (cs->cs_flags & MD_RCS_HAVE_PW_SLOTS));
820 if (raid_check_pw(cs))
821 return (1);
822
823 mutex_enter(&un->un_mx);
824 un->un_pwid++;
825 cs->cs_pwid = un->un_pwid;
826 mutex_exit(&un->un_mx);
827
828 cs->cs_dpwslot = raid_get_pwslot(cs, cs->cs_dcolumn);
829 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
830 cbuf->cbuf_pwslot = raid_get_pwslot(cs, cbuf->cbuf_column);
831 }
832 cs->cs_ppwslot = raid_get_pwslot(cs, cs->cs_pcolumn);
833
834 cs->cs_flags |= MD_RCS_HAVE_PW_SLOTS;
835
836 return (0);
837 }
838
839 /*
840 * NAMES: raid_build_incore
841 * DESCRIPTION: RAID metadevice incore structure building routine
842 * PARAMETERS: void *p - pointer to a unit structure
843 * int snarfing - a flag to indicate snarfing is required
844 */
845 int
846 raid_build_incore(void *p, int snarfing)
847 {
848 mr_unit_t *un = (mr_unit_t *)p;
849 minor_t mnum = MD_SID(un);
850 mddb_recid_t hs_recid = 0;
851 int i;
852 int preserve_flags;
853 mr_column_t *column;
854 int iosize;
855 md_dev64_t hs, dev;
856 int resync_cnt = 0, error_cnt = 0;
857
858 hs = NODEV64;
859 dev = NODEV64;
860
861 /* clear out bogus pointer incase we return(1) prior to alloc */
862 un->mr_ic = NULL;
863
864 if (MD_STATUS(un) & MD_UN_BEING_RESET) {
865 mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCLEAN);
866 return (1);
867 }
868
869 if (MD_UNIT(mnum) != NULL)
870 return (0);
871
872 if (snarfing)
873 MD_STATUS(un) = 0;
874
875 un->mr_ic = (mr_unit_ic_t *)kmem_zalloc(sizeof (*un->mr_ic),
876 KM_SLEEP);
877
878 un->un_column_ic = (mr_column_ic_t *)
879 kmem_zalloc(sizeof (mr_column_ic_t) *
880 un->un_totalcolumncnt, KM_SLEEP);
881
882 for (i = 0; i < un->un_totalcolumncnt; i++) {
883
884 column = &un->un_column[i];
885 preserve_flags = column->un_devflags &
886 (MD_RAID_COPY_RESYNC | MD_RAID_REGEN_RESYNC);
887 column->un_devflags &=
888 ~(MD_RAID_ALT_ISOPEN | MD_RAID_DEV_ISOPEN |
889 MD_RAID_WRITE_ALT);
890 if (raid_build_pw_reservation(un, i) != 0) {
891 /* could not build pwslot */
892 return (1);
893 }
894
895 if (snarfing) {
896 set_t setno = MD_MIN2SET(mnum);
897 dev = md_getdevnum(setno, mddb_getsidenum(setno),
898 column->un_orig_key, MD_NOTRUST_DEVT);
899 /*
900 * Comment out instead of remove so we have history
901 * In the pre-SVM releases stored devt is used so
902 * as long as there is one snarf is always happy
903 * even the component is powered off. This is not
904 * the case in current SVM implementation. NODEV64
905 * can be returned and in this case since we resolve
906 * the devt at 'open' time (first use of metadevice)
907 * we will allow snarf continue.
908 *
909 * if (dev == NODEV64)
910 * return (1);
911 */
912
913 /*
914 * Setup un_orig_dev from device id info if the device
915 * is valid (not NODEV64).
916 */
917 if (dev != NODEV64)
918 column->un_orig_dev = dev;
919
920 if (column->un_devstate & RCS_RESYNC)
921 resync_cnt++;
922 if (column->un_devstate & (RCS_ERRED | RCS_LAST_ERRED))
923 error_cnt++;
924
925 if (HOTSPARED(un, i)) {
926 (void) md_hot_spare_ifc(HS_MKDEV,
927 0, 0, 0, &column->un_hs_id, NULL,
928 &hs, NULL);
929 /*
930 * Same here
931 *
932 * if (hs == NODEV64)
933 * return (1);
934 */
935 }
936
937 if (HOTSPARED(un, i)) {
938 if (column->un_devstate &
939 (RCS_OKAY | RCS_LAST_ERRED)) {
940 column->un_dev = hs;
941 column->un_pwstart =
942 column->un_hs_pwstart;
943 column->un_devstart =
944 column->un_hs_devstart;
945 preserve_flags &=
946 ~(MD_RAID_COPY_RESYNC |
947 MD_RAID_REGEN_RESYNC);
948 } else if (column->un_devstate & RCS_RESYNC) {
949 /*
950 * if previous system was 4.0 set
951 * the direction flags
952 */
953 if ((preserve_flags &
954 (MD_RAID_COPY_RESYNC |
955 MD_RAID_REGEN_RESYNC)) == 0) {
956 if (column->un_alt_dev !=
957 NODEV64)
958 preserve_flags |=
959 MD_RAID_COPY_RESYNC;
960 else
961 preserve_flags |=
962 /* CSTYLED */
963 MD_RAID_REGEN_RESYNC;
964 }
965 }
966 } else { /* no hot spares */
967 column->un_dev = dev;
968 column->un_pwstart = column->un_orig_pwstart;
969 column->un_devstart = column->un_orig_devstart;
970 if (column->un_devstate & RCS_RESYNC) {
971 preserve_flags |= MD_RAID_REGEN_RESYNC;
972 preserve_flags &= ~MD_RAID_COPY_RESYNC;
973 }
974 }
975 if (! (column->un_devstate & RCS_RESYNC)) {
976 preserve_flags &=
977 ~(MD_RAID_REGEN_RESYNC |
978 MD_RAID_COPY_RESYNC);
979 }
980
981 column->un_devflags = preserve_flags;
982 column->un_alt_dev = NODEV64;
983 column->un_alt_pwstart = 0;
984 column->un_alt_devstart = 0;
985 un->un_resync_line_index = 0;
986 un->un_resync_index = 0;
987 un->un_percent_done = 0;
988 }
989 }
990
991 if (resync_cnt && error_cnt) {
992 for (i = 0; i < un->un_totalcolumncnt; i++) {
993 column = &un->un_column[i];
994 if (HOTSPARED(un, i) &&
995 (column->un_devstate & RCS_RESYNC) &&
996 (column->un_devflags & MD_RAID_COPY_RESYNC))
997 /* hotspare has data */
998 continue;
999
1000 if (HOTSPARED(un, i) &&
1001 (column->un_devstate & RCS_RESYNC)) {
1002 /* hotspare does not have data */
1003 raid_hs_release(HS_FREE, un, &hs_recid, i);
1004 column->un_dev = column->un_orig_dev;
1005 column->un_pwstart = column->un_orig_pwstart;
1006 column->un_devstart = column->un_orig_devstart;
1007 mddb_setrecprivate(hs_recid, MD_PRV_PENDCOM);
1008 }
1009
1010 if (column->un_devstate & RCS_ERRED)
1011 column->un_devstate = RCS_LAST_ERRED;
1012
1013 if (column->un_devstate & RCS_RESYNC)
1014 column->un_devstate = RCS_ERRED;
1015 }
1016 }
1017 mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCOM);
1018
1019 un->un_pwid = 1; /* or some other possible value */
1020 un->un_magic = RAID_UNMAGIC;
1021 iosize = un->un_iosize;
1022 un->un_pbuffer = kmem_alloc(dbtob(iosize), KM_SLEEP);
1023 un->un_dbuffer = kmem_alloc(dbtob(iosize), KM_SLEEP);
1024 mutex_init(&un->un_linlck_mx, NULL, MUTEX_DEFAULT, NULL);
1025 cv_init(&un->un_linlck_cv, NULL, CV_DEFAULT, NULL);
1026 un->un_linlck_chn = NULL;
1027
1028 /* place various information in the in-core data structures */
1029 md_nblocks_set(mnum, un->c.un_total_blocks);
1030 MD_UNIT(mnum) = un;
1031
1032 return (0);
1033 }
1034
1035 /*
1036 * NAMES: reset_raid
1037 * DESCRIPTION: RAID metadevice reset routine
1038 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
1039 * minor_t mnum - RAID metadevice minor number
1040 * int removing - a flag to imply removing device name from
1041 * MDDB database.
1042 */
1043 void
1044 reset_raid(mr_unit_t *un, minor_t mnum, int removing)
1045 {
1046 int i, n = 0;
1047 sv_dev_t *sv;
1048 mr_column_t *column;
1049 int column_cnt = un->un_totalcolumncnt;
1050 mddb_recid_t *recids, vtoc_id;
1051 int hserr;
1052
1053 ASSERT((MDI_UNIT(mnum)->ui_io_lock->io_list_front == NULL) &&
1054 (MDI_UNIT(mnum)->ui_io_lock->io_list_back == NULL));
1055
1056 md_destroy_unit_incore(mnum, &raid_md_ops);
1057
1058 md_nblocks_set(mnum, -1ULL);
1059 MD_UNIT(mnum) = NULL;
1060
1061 if (un->un_pbuffer) {
1062 kmem_free(un->un_pbuffer, dbtob(un->un_iosize));
1063 un->un_pbuffer = NULL;
1064 }
1065 if (un->un_dbuffer) {
1066 kmem_free(un->un_dbuffer, dbtob(un->un_iosize));
1067 un->un_dbuffer = NULL;
1068 }
1069
1070 /* free all pre-write slots created during build incore */
1071 for (i = 0; i < un->un_totalcolumncnt; i++)
1072 raid_free_pw_reservation(un, i);
1073
1074 kmem_free(un->un_column_ic, sizeof (mr_column_ic_t) *
1075 un->un_totalcolumncnt);
1076
1077 kmem_free(un->mr_ic, sizeof (*un->mr_ic));
1078
1079 /*
1080 * Attempt release of its minor node
1081 */
1082 md_remove_minor_node(mnum);
1083
1084 if (!removing)
1085 return;
1086
1087 sv = (sv_dev_t *)kmem_zalloc((column_cnt + 1) * sizeof (sv_dev_t),
1088 KM_SLEEP);
1089
1090 recids = (mddb_recid_t *)
1091 kmem_zalloc((column_cnt + 2) * sizeof (mddb_recid_t), KM_SLEEP);
1092
1093 for (i = 0; i < column_cnt; i++) {
1094 md_unit_t *comp_un;
1095 md_dev64_t comp_dev;
1096
1097 column = &un->un_column[i];
1098 sv[i].setno = MD_MIN2SET(mnum);
1099 sv[i].key = column->un_orig_key;
1100 if (HOTSPARED(un, i)) {
1101 if (column->un_devstate & (RCS_ERRED | RCS_LAST_ERRED))
1102 hserr = HS_BAD;
1103 else
1104 hserr = HS_FREE;
1105 raid_hs_release(hserr, un, &recids[n++], i);
1106 }
1107 /*
1108 * deparent any metadevices.
1109 * NOTE: currently soft partitions are the only metadevices
1110 * allowed in RAID metadevices.
1111 */
1112 comp_dev = column->un_dev;
1113 if (md_getmajor(comp_dev) == md_major) {
1114 comp_un = MD_UNIT(md_getminor(comp_dev));
1115 recids[n++] = MD_RECID(comp_un);
1116 md_reset_parent(comp_dev);
1117 }
1118 }
1119 /* decrement the reference count of the old hsp */
1120 if (un->un_hsp_id != -1)
1121 (void) md_hot_spare_ifc(HSP_DECREF, un->un_hsp_id, 0, 0,
1122 &recids[n++], NULL, NULL, NULL);
1123 recids[n] = 0;
1124 MD_STATUS(un) |= MD_UN_BEING_RESET;
1125 vtoc_id = un->c.un_vtoc_id;
1126
1127 raid_commit(un, recids);
1128
1129 /*
1130 * Remove self from the namespace
1131 */
1132 if (un->c.un_revision & MD_FN_META_DEV) {
1133 (void) md_rem_selfname(un->c.un_self_id);
1134 }
1135
1136 /* Remove the unit structure */
1137 mddb_deleterec_wrapper(un->c.un_record_id);
1138
1139 /* Remove the vtoc, if present */
1140 if (vtoc_id)
1141 mddb_deleterec_wrapper(vtoc_id);
1142 md_rem_names(sv, column_cnt);
1143 kmem_free(sv, (column_cnt + 1) * sizeof (sv_dev_t));
1144 kmem_free(recids, (column_cnt + 2) * sizeof (mddb_recid_t));
1145
1146 SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DELETE, SVM_TAG_METADEVICE,
1147 MD_MIN2SET(mnum), mnum);
1148 }
1149
1150 /*
1151 * NAMES: raid_error_parent
1152 * DESCRIPTION: mark a parent structure in error
1153 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1154 * int error - error value to set
1155 * NOTE: (TBR) - this routine currently is not in use.
1156 */
1157 static void
1158 raid_error_parent(md_raidps_t *ps, int error)
1159 {
1160 mutex_enter(&ps->ps_mx);
1161 ps->ps_flags |= MD_RPS_ERROR;
1162 ps->ps_error = error;
1163 mutex_exit(&ps->ps_mx);
1164 }
1165
1166 /*
1167 * The following defines tell raid_free_parent
1168 * RFP_RLS_LOCK release the unit reader lock when done.
1169 * RFP_DECR_PWFRAGS decrement ps_pwfrags
1170 * RFP_DECR_FRAGS decrement ps_frags
1171 * RFP_DECR_READFRAGS read keeps FRAGS and PWFRAGS in lockstep
1172 */
1173 #define RFP_RLS_LOCK 0x00001
1174 #define RFP_DECR_PWFRAGS 0x00002
1175 #define RFP_DECR_FRAGS 0x00004
1176 #define RFP_DECR_READFRAGS (RFP_DECR_PWFRAGS | RFP_DECR_FRAGS)
1177
1178 /*
1179 * NAMES: raid_free_parent
1180 * DESCRIPTION: free a parent structure
1181 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1182 * int todo - indicates what needs to be done
1183 */
1184 static void
1185 raid_free_parent(md_raidps_t *ps, int todo)
1186 {
1187 mdi_unit_t *ui = ps->ps_ui;
1188
1189 ASSERT(ps->ps_magic == RAID_PSMAGIC);
1190 ASSERT(ps->ps_flags & MD_RPS_INUSE);
1191 mutex_enter(&ps->ps_mx);
1192 if (todo & RFP_DECR_PWFRAGS) {
1193 ASSERT(ps->ps_pwfrags);
1194 ps->ps_pwfrags--;
1195 if (ps->ps_pwfrags == 0 && (! (ps->ps_flags & MD_RPS_IODONE))) {
1196 if (ps->ps_flags & MD_RPS_ERROR) {
1197 ps->ps_bp->b_flags |= B_ERROR;
1198 ps->ps_bp->b_error = ps->ps_error;
1199 }
1200 md_kstat_done(ui, ps->ps_bp, 0);
1201 biodone(ps->ps_bp);
1202 ps->ps_flags |= MD_RPS_IODONE;
1203 }
1204 }
1205
1206 if (todo & RFP_DECR_FRAGS) {
1207 ASSERT(ps->ps_frags);
1208 ps->ps_frags--;
1209 }
1210
1211 if (ps->ps_frags != 0) {
1212 mutex_exit(&ps->ps_mx);
1213 return;
1214 }
1215
1216 ASSERT((ps->ps_frags == 0) && (ps->ps_pwfrags == 0));
1217 mutex_exit(&ps->ps_mx);
1218
1219 if (todo & RFP_RLS_LOCK)
1220 md_io_readerexit(ui);
1221
1222 if (panicstr) {
1223 ps->ps_flags |= MD_RPS_DONE;
1224 return;
1225 }
1226
1227 if (ps->ps_flags & MD_RPS_HSREQ)
1228 (void) raid_hotspares();
1229
1230 ASSERT(todo & RFP_RLS_LOCK);
1231 ps->ps_flags &= ~MD_RPS_INUSE;
1232
1233 md_dec_iocount(MD_MIN2SET(ps->ps_un->c.un_self_id));
1234
1235 kmem_cache_free(raid_parent_cache, ps);
1236 }
1237
1238 /*
1239 * NAMES: raid_free_child
1240 * DESCRIPTION: free a parent structure
1241 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1242 * int drop_locks - 0 for no locks held
1243 * NOTE: (TBR) - this routine currently is not in use.
1244 */
1245 static void
1246 raid_free_child(md_raidcs_t *cs, int drop_locks)
1247 {
1248 mr_unit_t *un = cs->cs_un;
1249 md_raidcbuf_t *cbuf, *cbuf1;
1250
1251 if (cs->cs_pw_inval_list)
1252 raid_free_pwinvalidate(cs);
1253
1254 if (drop_locks) {
1255 ASSERT(cs->cs_flags & MD_RCS_LLOCKD &&
1256 (cs->cs_flags & (MD_RCS_READER | MD_RCS_WRITER)));
1257 md_unit_readerexit(MDI_UNIT(MD_SID(un)));
1258 raid_line_exit(cs);
1259 } else {
1260 ASSERT(!(cs->cs_flags & MD_RCS_LLOCKD));
1261 }
1262
1263 freebuffers(cs);
1264 cbuf = cs->cs_buflist;
1265 while (cbuf) {
1266 cbuf1 = cbuf->cbuf_next;
1267 kmem_cache_free(raid_cbuf_cache, cbuf);
1268 cbuf = cbuf1;
1269 }
1270 if (cs->cs_dbuf.b_flags & B_REMAPPED)
1271 bp_mapout(&cs->cs_dbuf);
1272 kmem_cache_free(raid_child_cache, cs);
1273 }
1274
1275 /*
1276 * NAME: raid_regen_parity
1277 *
1278 * DESCRIPTION: This routine is used to regenerate the parity blocks
1279 * for the entire raid device. It is called from
1280 * both the regen thread and the IO path.
1281 *
1282 * On error the entire device is marked as in error by
1283 * placing the erroring device in error and all other
1284 * devices in last_errored.
1285 *
1286 * PARAMETERS: md_raidcs_t *cs
1287 */
1288 void
1289 raid_regen_parity(md_raidcs_t *cs)
1290 {
1291 mr_unit_t *un = cs->cs_un;
1292 mdi_unit_t *ui = MDI_UNIT(un->c.un_self_id);
1293 caddr_t buffer;
1294 caddr_t parity_buffer;
1295 buf_t *bp;
1296 uint_t *dbuf, *pbuf;
1297 uint_t colcnt = un->un_totalcolumncnt;
1298 int column;
1299 int parity_column = cs->cs_pcolumn;
1300 size_t bcount;
1301 int j;
1302
1303 /*
1304 * This routine uses the data and parity buffers allocated to a
1305 * write. In the case of a read the buffers are allocated and
1306 * freed at the end.
1307 */
1308
1309 ASSERT(IO_READER_HELD(un));
1310 ASSERT(cs->cs_flags & MD_RCS_LLOCKD);
1311 ASSERT(UNIT_READER_HELD(un));
1312
1313 if (raid_state_cnt(un, RCS_OKAY) != colcnt)
1314 return;
1315
1316 if (cs->cs_flags & MD_RCS_READER) {
1317 getpbuffer(cs);
1318 getdbuffer(cs);
1319 }
1320 ASSERT(cs->cs_dbuffer && cs->cs_pbuffer);
1321 bcount = cs->cs_bcount;
1322 buffer = cs->cs_dbuffer;
1323 parity_buffer = cs->cs_pbuffer;
1324 bzero(parity_buffer, bcount);
1325 bp = &cs->cs_dbuf;
1326 for (column = 0; column < colcnt; column++) {
1327 if (column == parity_column)
1328 continue;
1329 reset_buf(bp, B_READ | B_BUSY, bcount);
1330 bp->b_un.b_addr = buffer;
1331 bp->b_edev = md_dev64_to_dev(un->un_column[column].un_dev);
1332 bp->b_lblkno = cs->cs_blkno + un->un_column[column].un_devstart;
1333 bp->b_bcount = bcount;
1334 bp->b_bufsize = bcount;
1335 (void) md_call_strategy(bp, MD_STR_NOTTOP, NULL);
1336 if (biowait(bp))
1337 goto bail;
1338 pbuf = (uint_t *)(void *)parity_buffer;
1339 dbuf = (uint_t *)(void *)buffer;
1340 for (j = 0; j < (bcount / (sizeof (uint_t))); j++) {
1341 *pbuf = *pbuf ^ *dbuf;
1342 pbuf++;
1343 dbuf++;
1344 }
1345 }
1346
1347 reset_buf(bp, B_WRITE | B_BUSY, cs->cs_bcount);
1348 bp->b_un.b_addr = parity_buffer;
1349 bp->b_edev = md_dev64_to_dev(un->un_column[parity_column].un_dev);
1350 bp->b_lblkno = cs->cs_blkno + un->un_column[parity_column].un_devstart;
1351 bp->b_bcount = bcount;
1352 bp->b_bufsize = bcount;
1353 (void) md_call_strategy(bp, MD_STR_NOTTOP, NULL);
1354 if (biowait(bp))
1355 goto bail;
1356
1357 if (cs->cs_flags & MD_RCS_READER) {
1358 freebuffers(cs);
1359 cs->cs_pbuffer = NULL;
1360 cs->cs_dbuffer = NULL;
1361 }
1362 bp->b_chain = (struct buf *)cs;
1363 return;
1364 bail:
1365 if (cs->cs_flags & MD_RCS_READER) {
1366 freebuffers(cs);
1367 cs->cs_pbuffer = NULL;
1368 cs->cs_dbuffer = NULL;
1369 }
1370 md_unit_readerexit(ui);
1371 un = md_unit_writerlock(ui);
1372 raid_set_state(un, column, RCS_ERRED, 0);
1373 for (column = 0; column < colcnt; column++)
1374 raid_set_state(un, column, RCS_ERRED, 0);
1375 raid_commit(un, NULL);
1376 md_unit_writerexit(ui);
1377 un = md_unit_readerlock(ui);
1378 bp->b_chain = (struct buf *)cs;
1379 }
1380
1381 /*
1382 * NAMES: raid_error_state
1383 * DESCRIPTION: check unit and column states' impact on I/O error
1384 * NOTE: the state now may not be the state when the
1385 * I/O completed due to race conditions.
1386 * PARAMETERS: mr_unit_t *un - pointer to raid unit structure
1387 * md_raidcs_t *cs - pointer to child structure
1388 * buf_t *bp - pointer to buffer structure
1389 */
1390 static int
1391 raid_error_state(mr_unit_t *un, buf_t *bp)
1392 {
1393 int column;
1394 int i;
1395
1396 ASSERT(IO_READER_HELD(un));
1397 ASSERT(UNIT_WRITER_HELD(un));
1398
1399 column = -1;
1400 for (i = 0; i < un->un_totalcolumncnt; i++) {
1401 if (un->un_column[i].un_dev == md_expldev(bp->b_edev)) {
1402 column = i;
1403 break;
1404 }
1405 if (un->un_column[i].un_alt_dev == md_expldev(bp->b_edev)) {
1406 column = i;
1407 break;
1408 }
1409 }
1410
1411 /* in case a replace snuck in while waiting on unit writer lock */
1412
1413 if (column == -1) {
1414 return (0);
1415 }
1416
1417 (void) raid_set_state(un, column, RCS_ERRED, 0);
1418 ASSERT(un->un_state & (RUS_ERRED | RUS_LAST_ERRED));
1419
1420 raid_commit(un, NULL);
1421 if (un->un_state & RUS_ERRED) {
1422 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED, SVM_TAG_METADEVICE,
1423 MD_UN2SET(un), MD_SID(un));
1424 } else if (un->un_state & RUS_LAST_ERRED) {
1425 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED, SVM_TAG_METADEVICE,
1426 MD_UN2SET(un), MD_SID(un));
1427 }
1428
1429 return (EIO);
1430 }
1431
1432 /*
1433 * NAME: raid_mapin_buf
1434 * DESCRIPTION: wait for the input buffer header to be maped in
1435 * PARAMETERS: md_raidps_t *ps
1436 */
1437 static void
1438 raid_mapin_buf(md_raidcs_t *cs)
1439 {
1440 md_raidps_t *ps = cs->cs_ps;
1441
1442 /*
1443 * check to see if the buffer is maped. If all is ok return the
1444 * offset of the data and return. Since it is expensive to grab
1445 * a mutex this is only done if the mapin is not complete.
1446 * Once the mutex is aquired it is possible that the mapin was
1447 * not done so recheck and if necessary do the mapin.
1448 */
1449 if (ps->ps_mapin > 0) {
1450 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1451 return;
1452 }
1453 mutex_enter(&ps->ps_mapin_mx);
1454 if (ps->ps_mapin > 0) {
1455 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1456 mutex_exit(&ps->ps_mapin_mx);
1457 return;
1458 }
1459 bp_mapin(ps->ps_bp);
1460 /*
1461 * get the new b_addr out of the parent since bp_mapin just changed it
1462 */
1463 ps->ps_addr = ps->ps_bp->b_un.b_addr;
1464 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1465 ps->ps_mapin++;
1466 mutex_exit(&ps->ps_mapin_mx);
1467 }
1468
1469 /*
1470 * NAMES: raid_read_no_retry
1471 * DESCRIPTION: I/O retry routine for a RAID metadevice read
1472 * read failed attempting to regenerate the data,
1473 * no retry possible, error occured in raid_raidregenloop().
1474 * PARAMETERS: mr_unit_t *un - pointer to raid unit structure
1475 * md_raidcs_t *cs - pointer to child structure
1476 */
1477 /*ARGSUSED*/
1478 static void
1479 raid_read_no_retry(mr_unit_t *un, md_raidcs_t *cs)
1480 {
1481 md_raidps_t *ps = cs->cs_ps;
1482
1483 raid_error_parent(ps, EIO);
1484 raid_free_child(cs, 1);
1485
1486 /* decrement readfrags */
1487 raid_free_parent(ps, RFP_DECR_READFRAGS | RFP_RLS_LOCK);
1488 }
1489
1490 /*
1491 * NAMES: raid_read_retry
1492 * DESCRIPTION: I/O retry routine for a RAID metadevice read
1493 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1494 */
1495 static void
1496 raid_read_retry(mr_unit_t *un, md_raidcs_t *cs)
1497 {
1498 /* re-initialize the buf_t structure for raid_read() */
1499 cs->cs_dbuf.b_chain = (struct buf *)cs;
1500 cs->cs_dbuf.b_back = &cs->cs_dbuf;
1501 cs->cs_dbuf.b_forw = &cs->cs_dbuf;
1502 cs->cs_dbuf.b_flags = B_BUSY; /* initialize flags */
1503 cs->cs_dbuf.b_error = 0; /* initialize error */
1504 cs->cs_dbuf.b_offset = -1;
1505 /* Initialize semaphores */
1506 sema_init(&cs->cs_dbuf.b_io, 0, NULL,
1507 SEMA_DEFAULT, NULL);
1508 sema_init(&cs->cs_dbuf.b_sem, 0, NULL,
1509 SEMA_DEFAULT, NULL);
1510
1511 cs->cs_pbuf.b_chain = (struct buf *)cs;
1512 cs->cs_pbuf.b_back = &cs->cs_pbuf;
1513 cs->cs_pbuf.b_forw = &cs->cs_pbuf;
1514 cs->cs_pbuf.b_flags = B_BUSY; /* initialize flags */
1515 cs->cs_pbuf.b_error = 0; /* initialize error */
1516 cs->cs_pbuf.b_offset = -1;
1517 sema_init(&cs->cs_pbuf.b_io, 0, NULL,
1518 SEMA_DEFAULT, NULL);
1519 sema_init(&cs->cs_pbuf.b_sem, 0, NULL,
1520 SEMA_DEFAULT, NULL);
1521
1522 cs->cs_flags &= ~MD_RCS_ERROR; /* reset child error flag */
1523 cs->cs_flags |= MD_RCS_RECOVERY; /* set RECOVERY flag */
1524
1525 /*
1526 * re-scheduling I/O with raid_read_io() is simpler. basically,
1527 * raid_read_io() is invoked again with same child structure.
1528 * (NOTE: we aren`t supposed to do any error recovery when an I/O
1529 * error occured in raid_raidregenloop().
1530 */
1531 raid_mapin_buf(cs);
1532 raid_read_io(un, cs);
1533 }
1534
1535 /*
1536 * NAMES: raid_rderr
1537 * DESCRIPTION: I/O error handling routine for a RAID metadevice read
1538 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1539 * LOCKS: must obtain unit writer lock while calling raid_error_state
1540 * since a unit or column state transition may take place.
1541 * must obtain unit reader lock to retry I/O.
1542 */
1543 /*ARGSUSED*/
1544 static void
1545 raid_rderr(md_raidcs_t *cs)
1546 {
1547 md_raidps_t *ps;
1548 mdi_unit_t *ui;
1549 mr_unit_t *un;
1550 int error = 0;
1551
1552 ps = cs->cs_ps;
1553 ui = ps->ps_ui;
1554 un = (mr_unit_t *)md_unit_writerlock(ui);
1555 ASSERT(un != 0);
1556
1557 if (cs->cs_dbuf.b_flags & B_ERROR)
1558 error = raid_error_state(un, &cs->cs_dbuf);
1559 if (cs->cs_pbuf.b_flags & B_ERROR)
1560 error |= raid_error_state(un, &cs->cs_pbuf);
1561
1562 md_unit_writerexit(ui);
1563
1564 ps->ps_flags |= MD_RPS_HSREQ;
1565
1566 un = (mr_unit_t *)md_unit_readerlock(ui);
1567 ASSERT(un != 0);
1568 /* now attempt the appropriate retry routine */
1569 (*(cs->cs_retry_call))(un, cs);
1570 }
1571
1572
1573 /*
1574 * NAMES: raid_read_error
1575 * DESCRIPTION: I/O error handling routine for a RAID metadevice read
1576 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1577 */
1578 /*ARGSUSED*/
1579 static void
1580 raid_read_error(md_raidcs_t *cs)
1581 {
1582 md_raidps_t *ps;
1583 mdi_unit_t *ui;
1584 mr_unit_t *un;
1585 set_t setno;
1586
1587 ps = cs->cs_ps;
1588 ui = ps->ps_ui;
1589 un = cs->cs_un;
1590
1591 setno = MD_UN2SET(un);
1592
1593 if ((cs->cs_dbuf.b_flags & B_ERROR) &&
1594 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_ERRED) &&
1595 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_LAST_ERRED))
1596 cmn_err(CE_WARN, "md %s: read error on %s",
1597 md_shortname(MD_SID(un)),
1598 md_devname(setno, md_expldev(cs->cs_dbuf.b_edev), NULL, 0));
1599
1600 if ((cs->cs_pbuf.b_flags & B_ERROR) &&
1601 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_ERRED) &&
1602 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_LAST_ERRED))
1603 cmn_err(CE_WARN, "md %s: read error on %s",
1604 md_shortname(MD_SID(un)),
1605 md_devname(setno, md_expldev(cs->cs_pbuf.b_edev), NULL, 0));
1606
1607 md_unit_readerexit(ui);
1608
1609 ASSERT(cs->cs_frags == 0);
1610
1611 /* now schedule processing for possible state change */
1612 daemon_request(&md_mstr_daemon, raid_rderr,
1613 (daemon_queue_t *)cs, REQ_OLD);
1614
1615 }
1616
1617 /*
1618 * NAMES: getdbuffer
1619 * DESCRIPTION: data buffer allocation for a child structure
1620 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1621 *
1622 * NOTE: always get dbuffer before pbuffer
1623 * and get both buffers before pwslot
1624 * otherwise a deadlock could be introduced.
1625 */
1626 static void
1627 getdbuffer(md_raidcs_t *cs)
1628 {
1629 mr_unit_t *un;
1630
1631 cs->cs_dbuffer = kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_NOSLEEP);
1632 if (cs->cs_dbuffer != NULL)
1633 return;
1634 un = cs->cs_ps->ps_un;
1635 mutex_enter(&un->un_mx);
1636 while (un->un_dbuffer == NULL) {
1637 STAT_INC(data_buffer_waits);
1638 un->un_rflags |= MD_RFLAG_NEEDBUF;
1639 cv_wait(&un->un_cv, &un->un_mx);
1640 }
1641 cs->cs_dbuffer = un->un_dbuffer;
1642 cs->cs_flags |= MD_RCS_UNDBUF;
1643 un->un_dbuffer = NULL;
1644 mutex_exit(&un->un_mx);
1645 }
1646
1647 /*
1648 * NAMES: getpbuffer
1649 * DESCRIPTION: parity buffer allocation for a child structure
1650 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1651 *
1652 * NOTE: always get dbuffer before pbuffer
1653 * and get both buffers before pwslot
1654 * otherwise a deadlock could be introduced.
1655 */
1656 static void
1657 getpbuffer(md_raidcs_t *cs)
1658 {
1659 mr_unit_t *un;
1660
1661 cs->cs_pbuffer = kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_NOSLEEP);
1662 if (cs->cs_pbuffer != NULL)
1663 return;
1664 un = cs->cs_ps->ps_un;
1665 mutex_enter(&un->un_mx);
1666 while (un->un_pbuffer == NULL) {
1667 STAT_INC(parity_buffer_waits);
1668 un->un_rflags |= MD_RFLAG_NEEDBUF;
1669 cv_wait(&un->un_cv, &un->un_mx);
1670 }
1671 cs->cs_pbuffer = un->un_pbuffer;
1672 cs->cs_flags |= MD_RCS_UNPBUF;
1673 un->un_pbuffer = NULL;
1674 mutex_exit(&un->un_mx);
1675 }
1676 static void
1677 getresources(md_raidcs_t *cs)
1678 {
1679 md_raidcbuf_t *cbuf;
1680 /*
1681 * NOTE: always get dbuffer before pbuffer
1682 * and get both buffers before pwslot
1683 * otherwise a deadlock could be introduced.
1684 */
1685 getdbuffer(cs);
1686 getpbuffer(cs);
1687 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next)
1688 cbuf->cbuf_buffer =
1689 kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_SLEEP);
1690 }
1691 /*
1692 * NAMES: freebuffers
1693 * DESCRIPTION: child structure buffer freeing routine
1694 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1695 */
1696 static void
1697 freebuffers(md_raidcs_t *cs)
1698 {
1699 mr_unit_t *un;
1700 md_raidcbuf_t *cbuf;
1701
1702 /* free buffers used for full line write */
1703 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
1704 if (cbuf->cbuf_buffer == NULL)
1705 continue;
1706 kmem_free(cbuf->cbuf_buffer, cbuf->cbuf_bcount + DEV_BSIZE);
1707 cbuf->cbuf_buffer = NULL;
1708 cbuf->cbuf_bcount = 0;
1709 }
1710
1711 if (cs->cs_flags & (MD_RCS_UNDBUF | MD_RCS_UNPBUF)) {
1712 un = cs->cs_un;
1713 mutex_enter(&un->un_mx);
1714 }
1715 if (cs->cs_dbuffer) {
1716 if (cs->cs_flags & MD_RCS_UNDBUF)
1717 un->un_dbuffer = cs->cs_dbuffer;
1718 else
1719 kmem_free(cs->cs_dbuffer, cs->cs_bcount + DEV_BSIZE);
1720 }
1721 if (cs->cs_pbuffer) {
1722 if (cs->cs_flags & MD_RCS_UNPBUF)
1723 un->un_pbuffer = cs->cs_pbuffer;
1724 else
1725 kmem_free(cs->cs_pbuffer, cs->cs_bcount + DEV_BSIZE);
1726 }
1727 if (cs->cs_flags & (MD_RCS_UNDBUF | MD_RCS_UNPBUF)) {
1728 un->un_rflags &= ~MD_RFLAG_NEEDBUF;
1729 cv_broadcast(&un->un_cv);
1730 mutex_exit(&un->un_mx);
1731 }
1732 }
1733
1734 /*
1735 * NAMES: raid_line_reader_lock, raid_line_writer_lock
1736 * DESCRIPTION: RAID metadevice line reader and writer lock routines
1737 * data column # and parity column #.
1738 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1739 */
1740
1741 void
1742 raid_line_reader_lock(md_raidcs_t *cs, int resync_thread)
1743 {
1744 mr_unit_t *un;
1745 md_raidcs_t *cs1;
1746
1747 ASSERT(cs->cs_line != MD_DISKADDR_ERROR);
1748 un = cs->cs_un;
1749 cs->cs_flags |= MD_RCS_READER;
1750 STAT_CHECK(raid_line_lock_wait, MUTEX_HELD(&un->un_linlck_mx));
1751 if (!panicstr)
1752 mutex_enter(&un->un_linlck_mx);
1753 cs1 = un->un_linlck_chn;
1754 while (cs1 != NULL) {
1755 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1756 if (raid_io_overlaps(cs, cs1) == 1)
1757 if (cs1->cs_flags & MD_RCS_WRITER)
1758 break;
1759
1760 if (cs1 != NULL) {
1761 if (panicstr)
1762 panic("md; raid line write lock held");
1763 un->un_linlck_flg = 1;
1764 cv_wait(&un->un_linlck_cv, &un->un_linlck_mx);
1765 STAT_INC(raid_read_waits);
1766 }
1767 }
1768 STAT_MAX(raid_max_reader_locks, raid_reader_locks_active);
1769 STAT_INC(raid_reader_locks);
1770 cs1 = un->un_linlck_chn;
1771 if (cs1 != NULL)
1772 cs1->cs_linlck_prev = cs;
1773 cs->cs_linlck_next = cs1;
1774 cs->cs_linlck_prev = NULL;
1775 un->un_linlck_chn = cs;
1776 cs->cs_flags |= MD_RCS_LLOCKD;
1777 if (resync_thread) {
1778 diskaddr_t lastblk = cs->cs_blkno + cs->cs_blkcnt - 1;
1779 diskaddr_t line = (lastblk + 1) / un->un_segsize;
1780 ASSERT(raid_state_cnt(un, RCS_RESYNC));
1781 mutex_enter(&un->un_mx);
1782 un->un_resync_line_index = line;
1783 mutex_exit(&un->un_mx);
1784 }
1785 if (!panicstr)
1786 mutex_exit(&un->un_linlck_mx);
1787 }
1788
1789 int
1790 raid_line_writer_lock(md_raidcs_t *cs, int lock)
1791 {
1792 mr_unit_t *un;
1793 md_raidcs_t *cs1;
1794
1795 ASSERT(cs->cs_line != MD_DISKADDR_ERROR);
1796 cs->cs_flags |= MD_RCS_WRITER;
1797 un = cs->cs_ps->ps_un;
1798
1799 STAT_CHECK(raid_line_lock_wait, MUTEX_HELD(&un->un_linlck_mx));
1800 if (lock && !panicstr)
1801 mutex_enter(&un->un_linlck_mx);
1802 ASSERT(MUTEX_HELD(&un->un_linlck_mx));
1803
1804 cs1 = un->un_linlck_chn;
1805 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1806 if (raid_io_overlaps(cs, cs1))
1807 break;
1808
1809 if (cs1 != NULL) {
1810 if (panicstr)
1811 panic("md: line writer lock inaccessible");
1812 goto no_lock_exit;
1813 }
1814
1815 if (raid_alloc_pwslot(cs)) {
1816 if (panicstr)
1817 panic("md: no prewrite slots");
1818 STAT_INC(raid_prewrite_waits);
1819 goto no_lock_exit;
1820 }
1821
1822 cs1 = un->un_linlck_chn;
1823 if (cs1 != NULL)
1824 cs1->cs_linlck_prev = cs;
1825 cs->cs_linlck_next = cs1;
1826 cs->cs_linlck_prev = NULL;
1827 un->un_linlck_chn = cs;
1828 cs->cs_flags |= MD_RCS_LLOCKD;
1829 cs->cs_flags &= ~MD_RCS_WAITING;
1830 STAT_INC(raid_writer_locks);
1831 STAT_MAX(raid_max_write_locks, raid_write_locks_active);
1832 if (lock && !panicstr)
1833 mutex_exit(&un->un_linlck_mx);
1834 return (0);
1835
1836 no_lock_exit:
1837 /* if this is already queued then do not requeue it */
1838 ASSERT(! (cs->cs_flags & MD_RCS_LLOCKD));
1839 if (!lock || (cs->cs_flags & MD_RCS_WAITING))
1840 return (1);
1841 cs->cs_flags |= MD_RCS_WAITING;
1842 cs->cs_un = un;
1843 raid_enqueue(cs);
1844 if (lock && !panicstr)
1845 mutex_exit(&un->un_linlck_mx);
1846 return (1);
1847 }
1848
1849 static void
1850 raid_startio(md_raidcs_t *cs)
1851 {
1852 mdi_unit_t *ui = cs->cs_ps->ps_ui;
1853 mr_unit_t *un = cs->cs_un;
1854
1855 un = md_unit_readerlock(ui);
1856 raid_write_io(un, cs);
1857 }
1858
1859 void
1860 raid_io_startup(mr_unit_t *un)
1861 {
1862 md_raidcs_t *waiting_list, *cs1;
1863 md_raidcs_t *previous = NULL, *next = NULL;
1864 mdi_unit_t *ui = MDI_UNIT(un->c.un_self_id);
1865 kmutex_t *io_list_mutex = &ui->ui_io_lock->io_list_mutex;
1866
1867 ASSERT(MUTEX_HELD(&un->un_linlck_mx));
1868 mutex_enter(io_list_mutex);
1869
1870 /*
1871 * check to be sure there are no reader locks outstanding. If
1872 * there are not then pass on the writer lock.
1873 */
1874 waiting_list = ui->ui_io_lock->io_list_front;
1875 while (waiting_list) {
1876 ASSERT(waiting_list->cs_flags & MD_RCS_WAITING);
1877 ASSERT(! (waiting_list->cs_flags & MD_RCS_LLOCKD));
1878 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1879 if (raid_io_overlaps(waiting_list, cs1) == 1)
1880 break;
1881 /*
1882 * there was an IOs that overlaps this io so go onto
1883 * the next io in the waiting list
1884 */
1885 if (cs1) {
1886 previous = waiting_list;
1887 waiting_list = waiting_list->cs_linlck_next;
1888 continue;
1889 }
1890
1891 /*
1892 * There are no IOs that overlap this, so remove it from
1893 * the waiting queue, and start it
1894 */
1895
1896 if (raid_check_pw(waiting_list)) {
1897 ASSERT(waiting_list->cs_flags & MD_RCS_WAITING);
1898 previous = waiting_list;
1899 waiting_list = waiting_list->cs_linlck_next;
1900 continue;
1901 }
1902 ASSERT(waiting_list->cs_flags & MD_RCS_WAITING);
1903
1904 next = waiting_list->cs_linlck_next;
1905 if (previous)
1906 previous->cs_linlck_next = next;
1907 else
1908 ui->ui_io_lock->io_list_front = next;
1909
1910 if (ui->ui_io_lock->io_list_front == NULL)
1911 ui->ui_io_lock->io_list_back = NULL;
1912
1913 if (ui->ui_io_lock->io_list_back == waiting_list)
1914 ui->ui_io_lock->io_list_back = previous;
1915
1916 waiting_list->cs_linlck_next = NULL;
1917 waiting_list->cs_flags &= ~MD_RCS_WAITING;
1918 STAT_DEC(raid_write_queue_length);
1919 if (raid_line_writer_lock(waiting_list, 0))
1920 panic("region locking corrupted");
1921
1922 ASSERT(waiting_list->cs_flags & MD_RCS_LLOCKD);
1923 daemon_request(&md_mstr_daemon, raid_startio,
1924 (daemon_queue_t *)waiting_list, REQ_OLD);
1925 waiting_list = next;
1926
1927 }
1928 mutex_exit(io_list_mutex);
1929 }
1930
1931 void
1932 raid_line_exit(md_raidcs_t *cs)
1933 {
1934 mr_unit_t *un;
1935
1936 un = cs->cs_ps->ps_un;
1937 STAT_CHECK(raid_line_lock_wait, MUTEX_HELD(&un->un_linlck_mx));
1938 mutex_enter(&un->un_linlck_mx);
1939 if (cs->cs_flags & MD_RCS_READER)
1940 STAT_DEC(raid_reader_locks_active);
1941 else
1942 STAT_DEC(raid_write_locks_active);
1943
1944 if (cs->cs_linlck_prev)
1945 cs->cs_linlck_prev->cs_linlck_next = cs->cs_linlck_next;
1946 else
1947 un->un_linlck_chn = cs->cs_linlck_next;
1948 if (cs->cs_linlck_next)
1949 cs->cs_linlck_next->cs_linlck_prev = cs->cs_linlck_prev;
1950
1951 cs->cs_flags &= ~MD_RCS_LLOCKD;
1952
1953 if (un->un_linlck_flg)
1954 cv_broadcast(&un->un_linlck_cv);
1955
1956 un->un_linlck_flg = 0;
1957 cs->cs_line = MD_DISKADDR_ERROR;
1958
1959 raid_cancel_pwslot(cs);
1960 /*
1961 * now that the lock is droped go ahead and see if there are any
1962 * other writes that can be started up
1963 */
1964 raid_io_startup(un);
1965
1966 mutex_exit(&un->un_linlck_mx);
1967 }
1968
1969 /*
1970 * NAMES: raid_line, raid_pcolumn, raid_dcolumn
1971 * DESCRIPTION: RAID metadevice APIs for mapping segment # to line #,
1972 * data column # and parity column #.
1973 * PARAMETERS: int segment - segment number
1974 * mr_unit_t *un - pointer to an unit structure
1975 * RETURNS: raid_line returns line #
1976 * raid_dcolumn returns data column #
1977 * raid_pcolumn returns parity column #
1978 */
1979 static diskaddr_t
1980 raid_line(diskaddr_t segment, mr_unit_t *un)
1981 {
1982 diskaddr_t adj_seg;
1983 diskaddr_t line;
1984 diskaddr_t max_orig_segment;
1985
1986 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
1987 if (segment >= max_orig_segment) {
1988 adj_seg = segment - max_orig_segment;
1989 line = adj_seg % un->un_segsincolumn;
1990 } else {
1991 line = segment / (un->un_origcolumncnt - 1);
1992 }
1993 return (line);
1994 }
1995
1996 uint_t
1997 raid_dcolumn(diskaddr_t segment, mr_unit_t *un)
1998 {
1999 diskaddr_t adj_seg;
2000 diskaddr_t line;
2001 diskaddr_t max_orig_segment;
2002 uint_t column;
2003
2004 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
2005 if (segment >= max_orig_segment) {
2006 adj_seg = segment - max_orig_segment;
2007 column = un->un_origcolumncnt +
2008 (uint_t)(adj_seg / un->un_segsincolumn);
2009 } else {
2010 line = segment / (un->un_origcolumncnt - 1);
2011 column = (uint_t)((segment %
2012 (un->un_origcolumncnt - 1) + line) % un->un_origcolumncnt);
2013 }
2014 return (column);
2015 }
2016
2017 uint_t
2018 raid_pcolumn(diskaddr_t segment, mr_unit_t *un)
2019 {
2020 diskaddr_t adj_seg;
2021 diskaddr_t line;
2022 diskaddr_t max_orig_segment;
2023 uint_t column;
2024
2025 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
2026 if (segment >= max_orig_segment) {
2027 adj_seg = segment - max_orig_segment;
2028 line = adj_seg % un->un_segsincolumn;
2029 } else {
2030 line = segment / (un->un_origcolumncnt - 1);
2031 }
2032 column = (uint_t)((line + (un->un_origcolumncnt - 1)) %
2033 un->un_origcolumncnt);
2034 return (column);
2035 }
2036
2037
2038 /*
2039 * Is called in raid_iosetup to probe each column to insure
2040 * that all the columns are in 'okay' state and meet the
2041 * 'full line' requirement. If any column is in error,
2042 * we don't want to enable the 'full line' flag. Previously,
2043 * we would do so and disable it only when a error is
2044 * detected after the first 'full line' io which is too late
2045 * and leads to the potential data corruption.
2046 */
2047 static int
2048 raid_check_cols(mr_unit_t *un)
2049 {
2050 buf_t bp;
2051 char *buf;
2052 mr_column_t *colptr;
2053 minor_t mnum = MD_SID(un);
2054 int i;
2055 int err = 0;
2056
2057 buf = kmem_zalloc((uint_t)DEV_BSIZE, KM_SLEEP);
2058
2059 for (i = 0; i < un->un_totalcolumncnt; i++) {
2060 md_dev64_t tmpdev;
2061
2062 colptr = &un->un_column[i];
2063
2064 tmpdev = colptr->un_dev;
2065 /*
2066 * Open by device id
2067 * If this device is hotspared
2068 * use the hotspare key
2069 */
2070 tmpdev = md_resolve_bydevid(mnum, tmpdev, HOTSPARED(un, i) ?
2071 colptr->un_hs_key : colptr->un_orig_key);
2072
2073 if (tmpdev == NODEV64) {
2074 err = 1;
2075 break;
2076 }
2077
2078 colptr->un_dev = tmpdev;
2079
2080 bzero((caddr_t)&bp, sizeof (buf_t));
2081 bp.b_back = &bp;
2082 bp.b_forw = &bp;
2083 bp.b_flags = (B_READ | B_BUSY);
2084 sema_init(&bp.b_io, 0, NULL,
2085 SEMA_DEFAULT, NULL);
2086 sema_init(&bp.b_sem, 0, NULL,
2087 SEMA_DEFAULT, NULL);
2088 bp.b_edev = md_dev64_to_dev(colptr->un_dev);
2089 bp.b_lblkno = colptr->un_pwstart;
2090 bp.b_bcount = DEV_BSIZE;
2091 bp.b_bufsize = DEV_BSIZE;
2092 bp.b_un.b_addr = (caddr_t)buf;
2093 (void) md_call_strategy(&bp, 0, NULL);
2094 if (biowait(&bp)) {
2095 err = 1;
2096 break;
2097 }
2098 }
2099
2100 kmem_free(buf, DEV_BSIZE);
2101 return (err);
2102 }
2103
2104 /*
2105 * NAME: raid_iosetup
2106 * DESCRIPTION: RAID metadevice specific I/O set up routine which does
2107 * all the necessary calculations to determine the location
2108 * of the segement for the I/O.
2109 * PARAMETERS: mr_unit_t *un - unit number of RAID metadevice
2110 * diskaddr_t blkno - block number of the I/O attempt
2111 * size_t blkcnt - block count for this I/O
2112 * md_raidcs_t *cs - child structure for each segmented I/O
2113 *
2114 * NOTE: The following is an example of a raid disk layer out:
2115 *
2116 * Total Column = 5
2117 * Original Column = 4
2118 * Segment Per Column = 10
2119 *
2120 * Col#0 Col#1 Col#2 Col#3 Col#4 Col#5 Col#6
2121 * -------------------------------------------------------------
2122 * line#0 Seg#0 Seg#1 Seg#2 Parity Seg#30 Seg#40
2123 * line#1 Parity Seg#3 Seg#4 Seg#5 Seg#31
2124 * line#2 Seg#8 Parity Seg#6 Seg#7 Seg#32
2125 * line#3 Seg#10 Seg#11 Parity Seg#9 Seg#33
2126 * line#4 Seg#12 Seg#13 Seg#14 Parity Seg#34
2127 * line#5 Parity Seg#15 Seg#16 Seg#17 Seg#35
2128 * line#6 Seg#20 Parity Seg#18 Seg#19 Seg#36
2129 * line#7 Seg#22 Seg#23 Parity Seg#21 Seg#37
2130 * line#8 Seg#24 Seg#25 Seg#26 Parity Seg#38
2131 * line#9 Parity Seg#27 Seg#28 Seg#29 Seg#39
2132 */
2133 static size_t
2134 raid_iosetup(
2135 mr_unit_t *un,
2136 diskaddr_t blkno,
2137 size_t blkcnt,
2138 md_raidcs_t *cs
2139 )
2140 {
2141 diskaddr_t segment;
2142 diskaddr_t segstart;
2143 diskaddr_t segoff;
2144 size_t leftover;
2145 diskaddr_t line;
2146 uint_t iosize;
2147 uint_t colcnt;
2148
2149 /* caculate the segment# and offset for the block */
2150 segment = blkno / un->un_segsize;
2151 segstart = segment * un->un_segsize;
2152 segoff = blkno - segstart;
2153 iosize = un->un_iosize - 1;
2154 colcnt = un->un_totalcolumncnt - 1;
2155 line = raid_line(segment, un);
2156 cs->cs_dcolumn = raid_dcolumn(segment, un);
2157 cs->cs_pcolumn = raid_pcolumn(segment, un);
2158 cs->cs_dflags = un->un_column[cs->cs_dcolumn].un_devflags;
2159 cs->cs_pflags = un->un_column[cs->cs_pcolumn].un_devflags;
2160 cs->cs_line = line;
2161
2162 if ((cs->cs_ps->ps_flags & MD_RPS_WRITE) &&
2163 (UNIT_STATE(un) & RCS_OKAY) &&
2164 (segoff == 0) &&
2165 (un->un_totalcolumncnt == un->un_origcolumncnt) &&
2166 (un->un_segsize < un->un_iosize) &&
2167 (un->un_iosize <= un->un_maxio) &&
2168 (blkno == line * un->un_segsize * colcnt) &&
2169 (blkcnt >= ((un->un_totalcolumncnt -1) * un->un_segsize)) &&
2170 (raid_state_cnt(un, RCS_OKAY) == un->un_origcolumncnt) &&
2171 (raid_check_cols(un) == 0)) {
2172
2173 md_raidcbuf_t **cbufp;
2174 md_raidcbuf_t *cbuf;
2175 int i, j;
2176
2177 STAT_INC(raid_full_line_writes);
2178 leftover = blkcnt - (un->un_segsize * colcnt);
2179 ASSERT(blkcnt >= (un->un_segsize * colcnt));
2180 cs->cs_blkno = line * un->un_segsize;
2181 cs->cs_blkcnt = un->un_segsize;
2182 cs->cs_lastblk = cs->cs_blkno + cs->cs_blkcnt - 1;
2183 cs->cs_bcount = dbtob(cs->cs_blkcnt);
2184 cs->cs_flags |= MD_RCS_LINE;
2185
2186 cbufp = &cs->cs_buflist;
2187 for (i = 0; i < un->un_totalcolumncnt; i++) {
2188 j = cs->cs_dcolumn + i;
2189 j = j % un->un_totalcolumncnt;
2190
2191 if ((j == cs->cs_dcolumn) || (j == cs->cs_pcolumn))
2192 continue;
2193 cbuf = kmem_cache_alloc(raid_cbuf_cache,
2194 MD_ALLOCFLAGS);
2195 raid_cbuf_init(cbuf);
2196 cbuf->cbuf_un = cs->cs_un;
2197 cbuf->cbuf_ps = cs->cs_ps;
2198 cbuf->cbuf_column = j;
2199 cbuf->cbuf_bcount = dbtob(un->un_segsize);
2200 *cbufp = cbuf;
2201 cbufp = &cbuf->cbuf_next;
2202 }
2203 return (leftover);
2204 }
2205
2206 leftover = blkcnt - (un->un_segsize - segoff);
2207 if (blkcnt > (un->un_segsize - segoff))
2208 blkcnt -= leftover;
2209 else
2210 leftover = 0;
2211
2212 if (blkcnt > (size_t)iosize) {
2213 leftover += (blkcnt - iosize);
2214 blkcnt = iosize;
2215 }
2216
2217 /* calculate the line# and column# for the segment */
2218 cs->cs_flags &= ~MD_RCS_LINE;
2219 cs->cs_blkno = line * un->un_segsize + segoff;
2220 cs->cs_blkcnt = (uint_t)blkcnt;
2221 cs->cs_lastblk = cs->cs_blkno + cs->cs_blkcnt - 1;
2222 cs->cs_bcount = dbtob((uint_t)blkcnt);
2223 return (leftover);
2224 }
2225
2226 /*
2227 * NAME: raid_done
2228 * DESCRIPTION: RAID metadevice I/O done interrupt routine
2229 * PARAMETERS: struct buf *bp - pointer to a buffer structure
2230 */
2231 static void
2232 raid_done(struct buf *bp)
2233 {
2234 md_raidcs_t *cs;
2235 int flags, frags;
2236
2237 sema_v(&bp->b_io);
2238 cs = (md_raidcs_t *)bp->b_chain;
2239
2240 ASSERT(cs != NULL);
2241
2242 mutex_enter(&cs->cs_mx);
2243 if (bp->b_flags & B_ERROR) {
2244 cs->cs_flags |= MD_RCS_ERROR;
2245 cs->cs_flags &= ~(MD_RCS_ISCALL);
2246 }
2247
2248 flags = cs->cs_flags;
2249 frags = --cs->cs_frags;
2250 mutex_exit(&cs->cs_mx);
2251 if (frags != 0) {
2252 return;
2253 }
2254
2255 if (flags & MD_RCS_ERROR) {
2256 if (cs->cs_error_call) {
2257 daemon_request(&md_done_daemon, cs->cs_error_call,
2258 (daemon_queue_t *)cs, REQ_OLD);
2259 }
2260 return;
2261 }
2262
2263 if (flags & MD_RCS_ISCALL) {
2264 cs->cs_flags &= ~(MD_RCS_ISCALL);
2265 (*(cs->cs_call))(cs);
2266 return;
2267 }
2268 daemon_request(&md_done_daemon, cs->cs_call,
2269 (daemon_queue_t *)cs, REQ_OLD);
2270 }
2271 /*
2272 * the flag RIO_EXTRA is used when dealing with a column in the process
2273 * of being resynced. During the resync, writes may have to take place
2274 * on both the original component and a hotspare component.
2275 */
2276 #define RIO_DATA 0x00100 /* use data buffer & data column */
2277 #define RIO_PARITY 0x00200 /* use parity buffer & parity column */
2278 #define RIO_WRITE 0x00400 /* issue a write */
2279 #define RIO_READ 0x00800 /* issue a read */
2280 #define RIO_PWIO 0x01000 /* do the I/O to the prewrite entry */
2281 #define RIO_ALT 0x02000 /* do write to alternate device */
2282 #define RIO_EXTRA 0x04000 /* use extra buffer */
2283
2284 #define RIO_COLMASK 0x000ff
2285
2286 #define RIO_PREWRITE RIO_WRITE | RIO_PWIO
2287
2288 /*
2289 * NAME: raidio
2290 * DESCRIPTION: RAID metadevice write routine
2291 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2292 */
2293 static void
2294 raidio(md_raidcs_t *cs, int flags)
2295 {
2296 buf_t *bp;
2297 int column;
2298 int flag;
2299 void *private;
2300 mr_unit_t *un;
2301 int iosize;
2302 diskaddr_t pwstart;
2303 diskaddr_t devstart;
2304 md_dev64_t dev;
2305
2306 un = cs->cs_un;
2307
2308 ASSERT(IO_READER_HELD(un));
2309 ASSERT(UNIT_READER_HELD(un));
2310
2311 if (flags & RIO_DATA) {
2312 if (flags & RIO_EXTRA)
2313 bp = &cs->cs_hbuf;
2314 else
2315 bp = &cs->cs_dbuf;
2316 bp->b_un.b_addr = cs->cs_dbuffer;
2317 column = cs->cs_dcolumn;
2318 } else {
2319 if (flags & RIO_EXTRA)
2320 bp = &cs->cs_hbuf;
2321 else
2322 bp = &cs->cs_pbuf;
2323 bp->b_un.b_addr = cs->cs_pbuffer;
2324 column = cs->cs_pcolumn;
2325 }
2326 if (flags & RIO_COLMASK)
2327 column = (flags & RIO_COLMASK) - 1;
2328
2329 bp->b_bcount = cs->cs_bcount;
2330 bp->b_bufsize = cs->cs_bcount;
2331 iosize = un->un_iosize;
2332
2333 /* check if the hotspared device will be used */
2334 if (flags & RIO_ALT && (flags & RIO_WRITE)) {
2335 pwstart = un->un_column[column].un_alt_pwstart;
2336 devstart = un->un_column[column].un_alt_devstart;
2337 dev = un->un_column[column].un_alt_dev;
2338 } else {
2339 pwstart = un->un_column[column].un_pwstart;
2340 devstart = un->un_column[column].un_devstart;
2341 dev = un->un_column[column].un_dev;
2342 }
2343
2344 /* if not writing to log skip log header */
2345 if ((flags & RIO_PWIO) == 0) {
2346 bp->b_lblkno = devstart + cs->cs_blkno;
2347 bp->b_un.b_addr += DEV_BSIZE;
2348 } else {
2349 bp->b_bcount += DEV_BSIZE;
2350 bp->b_bufsize = bp->b_bcount;
2351 if (flags & RIO_DATA) {
2352 bp->b_lblkno = cs->cs_dpwslot * iosize + pwstart;
2353 } else { /* not DATA -> PARITY */
2354 bp->b_lblkno = cs->cs_ppwslot * iosize + pwstart;
2355 }
2356 }
2357
2358 bp->b_flags &= ~(B_READ | B_WRITE | B_ERROR | nv_available);
2359 bp->b_flags |= B_BUSY;
2360 if (flags & RIO_READ) {
2361 bp->b_flags |= B_READ;
2362 } else {
2363 bp->b_flags |= B_WRITE;
2364 if ((nv_available && nv_parity && (flags & RIO_PARITY)) ||
2365 (nv_available && nv_prewrite && (flags & RIO_PWIO)))
2366 bp->b_flags |= nv_available;
2367 }
2368 bp->b_iodone = (int (*)())raid_done;
2369 bp->b_edev = md_dev64_to_dev(dev);
2370
2371 ASSERT((bp->b_edev != 0) && (bp->b_edev != NODEV));
2372
2373 private = cs->cs_strategy_private;
2374 flag = cs->cs_strategy_flag;
2375
2376 md_call_strategy(bp, flag, private);
2377 }
2378
2379 /*
2380 * NAME: genstandardparity
2381 * DESCRIPTION: This routine
2382 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2383 */
2384 static void
2385 genstandardparity(md_raidcs_t *cs)
2386 {
2387 uint_t *dbuf, *pbuf;
2388 size_t wordcnt;
2389 uint_t dsum = 0;
2390 uint_t psum = 0;
2391
2392 ASSERT((cs->cs_bcount & 0x3) == 0);
2393
2394 wordcnt = cs->cs_bcount / sizeof (uint_t);
2395
2396 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
2397 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2398
2399 /* Word aligned */
2400 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
2401 uint_t *uwbuf = (uint_t *)(void *)(cs->cs_addr);
2402 uint_t uval;
2403
2404 while (wordcnt--) {
2405 uval = *uwbuf++;
2406 psum ^= (*pbuf = ((*pbuf ^ *dbuf) ^ uval));
2407 ++pbuf;
2408 *dbuf = uval;
2409 dsum ^= uval;
2410 ++dbuf;
2411 }
2412 } else {
2413 uchar_t *ubbuf = (uchar_t *)(cs->cs_addr);
2414 union {
2415 uint_t wb;
2416 uchar_t bb[4];
2417 } cb;
2418
2419 while (wordcnt--) {
2420 cb.bb[0] = *ubbuf++;
2421 cb.bb[1] = *ubbuf++;
2422 cb.bb[2] = *ubbuf++;
2423 cb.bb[3] = *ubbuf++;
2424 psum ^= (*pbuf = ((*pbuf ^ *dbuf) ^ cb.wb));
2425 ++pbuf;
2426 *dbuf = cb.wb;
2427 dsum ^= cb.wb;
2428 ++dbuf;
2429 }
2430 }
2431
2432 RAID_FILLIN_RPW(cs->cs_dbuffer, cs->cs_un, dsum, cs->cs_pcolumn,
2433 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2434 2, cs->cs_dcolumn, RAID_PWMAGIC);
2435
2436 RAID_FILLIN_RPW(cs->cs_pbuffer, cs->cs_un, psum, cs->cs_dcolumn,
2437 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2438 2, cs->cs_pcolumn, RAID_PWMAGIC);
2439 }
2440
2441 static void
2442 genlineparity(md_raidcs_t *cs)
2443 {
2444
2445 mr_unit_t *un = cs->cs_un;
2446 md_raidcbuf_t *cbuf;
2447 uint_t *pbuf, *dbuf;
2448 uint_t *uwbuf;
2449 uchar_t *ubbuf;
2450 size_t wordcnt;
2451 uint_t psum = 0, dsum = 0;
2452 size_t count = un->un_segsize * DEV_BSIZE;
2453 uint_t col;
2454 buf_t *bp;
2455
2456 ASSERT((cs->cs_bcount & 0x3) == 0);
2457
2458 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2459 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
2460 uwbuf = (uint_t *)(void *)(cs->cs_addr);
2461 ubbuf = (uchar_t *)(void *)(cs->cs_addr);
2462
2463 wordcnt = count / sizeof (uint_t);
2464
2465 /* Word aligned */
2466 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
2467 uint_t uval;
2468
2469 while (wordcnt--) {
2470 uval = *uwbuf++;
2471 *dbuf = uval;
2472 *pbuf = uval;
2473 dsum ^= uval;
2474 ++pbuf;
2475 ++dbuf;
2476 }
2477 } else {
2478 union {
2479 uint_t wb;
2480 uchar_t bb[4];
2481 } cb;
2482
2483 while (wordcnt--) {
2484 cb.bb[0] = *ubbuf++;
2485 cb.bb[1] = *ubbuf++;
2486 cb.bb[2] = *ubbuf++;
2487 cb.bb[3] = *ubbuf++;
2488 *dbuf = cb.wb;
2489 *pbuf = cb.wb;
2490 dsum ^= cb.wb;
2491 ++pbuf;
2492 ++dbuf;
2493 }
2494 }
2495
2496 RAID_FILLIN_RPW(cs->cs_dbuffer, un, dsum, cs->cs_pcolumn,
2497 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2498 un->un_totalcolumncnt, cs->cs_dcolumn, RAID_PWMAGIC);
2499
2500 raidio(cs, RIO_PREWRITE | RIO_DATA);
2501
2502 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
2503
2504 dsum = 0;
2505 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2506 dbuf = (uint_t *)(void *)(cbuf->cbuf_buffer + DEV_BSIZE);
2507
2508 wordcnt = count / sizeof (uint_t);
2509
2510 col = cbuf->cbuf_column;
2511
2512 /* Word aligned */
2513 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
2514 uint_t uval;
2515
2516 /*
2517 * Only calculate psum when working on the last
2518 * data buffer.
2519 */
2520 if (cbuf->cbuf_next == NULL) {
2521 psum = 0;
2522 while (wordcnt--) {
2523 uval = *uwbuf++;
2524 *dbuf = uval;
2525 psum ^= (*pbuf ^= uval);
2526 dsum ^= uval;
2527 ++dbuf;
2528 ++pbuf;
2529 }
2530 } else {
2531 while (wordcnt--) {
2532 uval = *uwbuf++;
2533 *dbuf = uval;
2534 *pbuf ^= uval;
2535 dsum ^= uval;
2536 ++dbuf;
2537 ++pbuf;
2538 }
2539 }
2540 } else {
2541 union {
2542 uint_t wb;
2543 uchar_t bb[4];
2544 } cb;
2545
2546 /*
2547 * Only calculate psum when working on the last
2548 * data buffer.
2549 */
2550 if (cbuf->cbuf_next == NULL) {
2551 psum = 0;
2552 while (wordcnt--) {
2553 cb.bb[0] = *ubbuf++;
2554 cb.bb[1] = *ubbuf++;
2555 cb.bb[2] = *ubbuf++;
2556 cb.bb[3] = *ubbuf++;
2557 *dbuf = cb.wb;
2558 psum ^= (*pbuf ^= cb.wb);
2559 dsum ^= cb.wb;
2560 ++dbuf;
2561 ++pbuf;
2562 }
2563 } else {
2564 while (wordcnt--) {
2565 cb.bb[0] = *ubbuf++;
2566 cb.bb[1] = *ubbuf++;
2567 cb.bb[2] = *ubbuf++;
2568 cb.bb[3] = *ubbuf++;
2569 *dbuf = cb.wb;
2570 *pbuf ^= cb.wb;
2571 dsum ^= cb.wb;
2572 ++dbuf;
2573 ++pbuf;
2574 }
2575 }
2576 }
2577 RAID_FILLIN_RPW(cbuf->cbuf_buffer, un, dsum, cs->cs_pcolumn,
2578 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2579 un->un_totalcolumncnt, col, RAID_PWMAGIC);
2580
2581 /*
2582 * fill in buffer for write to prewrite area
2583 */
2584 bp = &cbuf->cbuf_bp;
2585 bp->b_un.b_addr = cbuf->cbuf_buffer;
2586 bp->b_bcount = cbuf->cbuf_bcount + DEV_BSIZE;
2587 bp->b_bufsize = bp->b_bcount;
2588 bp->b_lblkno = (cbuf->cbuf_pwslot * un->un_iosize) +
2589 un->un_column[col].un_pwstart;
2590 bp->b_flags = B_WRITE | B_BUSY;
2591 if (nv_available && nv_prewrite)
2592 bp->b_flags |= nv_available;
2593 bp->b_iodone = (int (*)())raid_done;
2594 bp->b_edev = md_dev64_to_dev(un->un_column[col].un_dev);
2595 bp->b_chain = (struct buf *)cs;
2596 md_call_strategy(bp,
2597 cs->cs_strategy_flag, cs->cs_strategy_private);
2598 }
2599
2600 RAID_FILLIN_RPW(cs->cs_pbuffer, un, psum, cs->cs_dcolumn,
2601 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2602 un->un_totalcolumncnt, cs->cs_pcolumn, RAID_PWMAGIC);
2603
2604 raidio(cs, RIO_PREWRITE | RIO_PARITY);
2605 }
2606
2607 /*
2608 * NAME: raid_readregenloop
2609 * DESCRIPTION: RAID metadevice write routine
2610 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2611 */
2612 static void
2613 raid_readregenloop(md_raidcs_t *cs)
2614 {
2615 mr_unit_t *un;
2616 md_raidps_t *ps;
2617 uint_t *dbuf;
2618 uint_t *pbuf;
2619 size_t wordcnt;
2620
2621 un = cs->cs_un;
2622
2623 /*
2624 * XOR the parity with data bytes, must skip the
2625 * pre-write entry header in all data/parity buffers
2626 */
2627 wordcnt = cs->cs_bcount / sizeof (uint_t);
2628 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
2629 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2630 while (wordcnt--)
2631 *dbuf++ ^= *pbuf++;
2632
2633 /* bump up the loop count */
2634 cs->cs_loop++;
2635
2636 /* skip the errored component */
2637 if (cs->cs_loop == cs->cs_dcolumn)
2638 cs->cs_loop++;
2639
2640 if (cs->cs_loop != un->un_totalcolumncnt) {
2641 cs->cs_frags = 1;
2642 raidio(cs, RIO_PARITY | RIO_READ | (cs->cs_loop + 1));
2643 return;
2644 }
2645 /* reaching the end sof loop */
2646 ps = cs->cs_ps;
2647 bcopy(cs->cs_dbuffer + DEV_BSIZE, cs->cs_addr, cs->cs_bcount);
2648 raid_free_child(cs, 1);
2649
2650 /* decrement readfrags */
2651 raid_free_parent(ps, RFP_DECR_READFRAGS | RFP_RLS_LOCK);
2652 }
2653
2654 /*
2655 * NAME: raid_read_io
2656 * DESCRIPTION: RAID metadevice read I/O routine
2657 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2658 * md_raidcs_t *cs - pointer to a child structure
2659 */
2660 static void
2661 raid_read_io(mr_unit_t *un, md_raidcs_t *cs)
2662 {
2663 int flag;
2664 void *private;
2665 buf_t *bp;
2666 buf_t *pb = cs->cs_ps->ps_bp;
2667 mr_column_t *column;
2668
2669 flag = cs->cs_strategy_flag;
2670 private = cs->cs_strategy_private;
2671 column = &un->un_column[cs->cs_dcolumn];
2672
2673 /*
2674 * The component to be read is good, simply set up bp structure
2675 * and call low level md routine doing the read.
2676 */
2677
2678 if (COLUMN_ISOKAY(un, cs->cs_dcolumn) ||
2679 (COLUMN_ISLASTERR(un, cs->cs_dcolumn) &&
2680 (cs->cs_flags & MD_RCS_RECOVERY) == 0)) {
2681 dev_t ddi_dev; /* needed for bioclone, so not md_dev64_t */
2682 ddi_dev = md_dev64_to_dev(column->un_dev);
2683
2684 bp = &cs->cs_dbuf;
2685 bp = md_bioclone(pb, cs->cs_offset, cs->cs_bcount, ddi_dev,
2686 column->un_devstart + cs->cs_blkno,
2687 (int (*)())raid_done, bp, KM_NOSLEEP);
2688
2689 bp->b_chain = (buf_t *)cs;
2690
2691 cs->cs_frags = 1;
2692 cs->cs_error_call = raid_read_error;
2693 cs->cs_retry_call = raid_read_retry;
2694 cs->cs_flags |= MD_RCS_ISCALL;
2695 cs->cs_stage = RAID_READ_DONE;
2696 cs->cs_call = raid_stage;
2697
2698 ASSERT(bp->b_edev != 0);
2699
2700 md_call_strategy(bp, flag, private);
2701 return;
2702 }
2703
2704 /*
2705 * The component to be read is bad, have to go through
2706 * raid specific method to read data from other members.
2707 */
2708 cs->cs_loop = 0;
2709 /*
2710 * NOTE: always get dbuffer before pbuffer
2711 * and get both buffers before pwslot
2712 * otherwise a deadlock could be introduced.
2713 */
2714 raid_mapin_buf(cs);
2715 getdbuffer(cs);
2716 getpbuffer(cs);
2717 if (cs->cs_loop == cs->cs_dcolumn)
2718 cs->cs_loop++;
2719
2720 /* zero out data buffer for use as a data sink */
2721 bzero(cs->cs_dbuffer + DEV_BSIZE, cs->cs_bcount);
2722 cs->cs_stage = RAID_NONE;
2723 cs->cs_call = raid_readregenloop;
2724 cs->cs_error_call = raid_read_error;
2725 cs->cs_retry_call = raid_read_no_retry;
2726 cs->cs_frags = 1;
2727
2728 /* use parity buffer to read other columns */
2729 raidio(cs, RIO_PARITY | RIO_READ | (cs->cs_loop + 1));
2730 }
2731
2732 /*
2733 * NAME: raid_read
2734 * DESCRIPTION: RAID metadevice write routine
2735 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2736 * md_raidcs_t *cs - pointer to a child structure
2737 */
2738 static int
2739 raid_read(mr_unit_t *un, md_raidcs_t *cs)
2740 {
2741 int error = 0;
2742 md_raidps_t *ps;
2743 mdi_unit_t *ui;
2744 minor_t mnum;
2745
2746 ASSERT(IO_READER_HELD(un));
2747 ps = cs->cs_ps;
2748 ui = ps->ps_ui;
2749 raid_line_reader_lock(cs, 0);
2750 un = (mr_unit_t *)md_unit_readerlock(ui);
2751 ASSERT(UNIT_STATE(un) != RUS_INIT);
2752 mnum = MD_SID(un);
2753 cs->cs_un = un;
2754
2755 /* make sure the read doesn't go beyond the end of the column */
2756 if (cs->cs_blkno + cs->cs_blkcnt >
2757 un->un_segsize * un->un_segsincolumn) {
2758 error = ENXIO;
2759 }
2760 if (error)
2761 goto rerror;
2762
2763 if (un->un_state & RUS_REGEN) {
2764 raid_regen_parity(cs);
2765 un = MD_UNIT(mnum);
2766 cs->cs_un = un;
2767 }
2768
2769 raid_read_io(un, cs);
2770 return (0);
2771
2772 rerror:
2773 raid_error_parent(ps, error);
2774 raid_free_child(cs, 1);
2775 /* decrement readfrags */
2776 raid_free_parent(ps, RFP_DECR_READFRAGS | RFP_RLS_LOCK);
2777 return (0);
2778 }
2779
2780 /*
2781 * NAME: raid_write_err_retry
2782 * DESCRIPTION: RAID metadevice write retry routine
2783 * write was for parity or data only;
2784 * complete write with error, no recovery possible
2785 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2786 * md_raidcs_t *cs - pointer to a child structure
2787 */
2788 /*ARGSUSED*/
2789 static void
2790 raid_write_err_retry(mr_unit_t *un, md_raidcs_t *cs)
2791 {
2792 md_raidps_t *ps = cs->cs_ps;
2793 int flags = RFP_DECR_FRAGS | RFP_RLS_LOCK;
2794
2795 /* decrement pwfrags if needed, and frags */
2796 if (!(cs->cs_flags & MD_RCS_PWDONE))
2797 flags |= RFP_DECR_PWFRAGS;
2798 raid_error_parent(ps, EIO);
2799 raid_free_child(cs, 1);
2800 raid_free_parent(ps, flags);
2801 }
2802
2803 /*
2804 * NAME: raid_write_err_retry
2805 * DESCRIPTION: RAID metadevice write retry routine
2806 * write is too far along to retry and parent
2807 * has already been signaled with iodone.
2808 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2809 * md_raidcs_t *cs - pointer to a child structure
2810 */
2811 /*ARGSUSED*/
2812 static void
2813 raid_write_no_retry(mr_unit_t *un, md_raidcs_t *cs)
2814 {
2815 md_raidps_t *ps = cs->cs_ps;
2816 int flags = RFP_DECR_FRAGS | RFP_RLS_LOCK;
2817
2818 /* decrement pwfrags if needed, and frags */
2819 if (!(cs->cs_flags & MD_RCS_PWDONE))
2820 flags |= RFP_DECR_PWFRAGS;
2821 raid_free_child(cs, 1);
2822 raid_free_parent(ps, flags);
2823 }
2824
2825 /*
2826 * NAME: raid_write_retry
2827 * DESCRIPTION: RAID metadevice write retry routine
2828 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2829 * md_raidcs_t *cs - pointer to a child structure
2830 */
2831 static void
2832 raid_write_retry(mr_unit_t *un, md_raidcs_t *cs)
2833 {
2834 md_raidps_t *ps;
2835
2836 ps = cs->cs_ps;
2837
2838 /* re-initialize the buf_t structure for raid_write() */
2839 cs->cs_dbuf.b_chain = (struct buf *)cs;
2840 cs->cs_dbuf.b_back = &cs->cs_dbuf;
2841 cs->cs_dbuf.b_forw = &cs->cs_dbuf;
2842 cs->cs_dbuf.b_flags = B_BUSY; /* initialize flags */
2843 cs->cs_dbuf.b_error = 0; /* initialize error */
2844 cs->cs_dbuf.b_offset = -1;
2845 /* Initialize semaphores */
2846 sema_init(&cs->cs_dbuf.b_io, 0, NULL,
2847 SEMA_DEFAULT, NULL);
2848 sema_init(&cs->cs_dbuf.b_sem, 0, NULL,
2849 SEMA_DEFAULT, NULL);
2850
2851 cs->cs_pbuf.b_chain = (struct buf *)cs;
2852 cs->cs_pbuf.b_back = &cs->cs_pbuf;
2853 cs->cs_pbuf.b_forw = &cs->cs_pbuf;
2854 cs->cs_pbuf.b_flags = B_BUSY; /* initialize flags */
2855 cs->cs_pbuf.b_error = 0; /* initialize error */
2856 cs->cs_pbuf.b_offset = -1;
2857 sema_init(&cs->cs_pbuf.b_io, 0, NULL,
2858 SEMA_DEFAULT, NULL);
2859 sema_init(&cs->cs_pbuf.b_sem, 0, NULL,
2860 SEMA_DEFAULT, NULL);
2861
2862 cs->cs_hbuf.b_chain = (struct buf *)cs;
2863 cs->cs_hbuf.b_back = &cs->cs_hbuf;
2864 cs->cs_hbuf.b_forw = &cs->cs_hbuf;
2865 cs->cs_hbuf.b_flags = B_BUSY; /* initialize flags */
2866 cs->cs_hbuf.b_error = 0; /* initialize error */
2867 cs->cs_hbuf.b_offset = -1;
2868 sema_init(&cs->cs_hbuf.b_io, 0, NULL,
2869 SEMA_DEFAULT, NULL);
2870 sema_init(&cs->cs_hbuf.b_sem, 0, NULL,
2871 SEMA_DEFAULT, NULL);
2872
2873 cs->cs_flags &= ~(MD_RCS_ERROR);
2874 /*
2875 * If we have already done'ed the i/o but have done prewrite
2876 * on this child, then reset PWDONE flag and bump pwfrags before
2877 * restarting i/o.
2878 * If pwfrags is zero, we have already 'iodone'd the i/o so
2879 * leave things alone. We don't want to re-'done' it.
2880 */
2881 mutex_enter(&ps->ps_mx);
2882 if (cs->cs_flags & MD_RCS_PWDONE) {
2883 cs->cs_flags &= ~MD_RCS_PWDONE;
2884 ps->ps_pwfrags++;
2885 }
2886 mutex_exit(&ps->ps_mx);
2887 raid_write_io(un, cs);
2888 }
2889
2890 /*
2891 * NAME: raid_wrerr
2892 * DESCRIPTION: RAID metadevice write routine
2893 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2894 * LOCKS: must obtain unit writer lock while calling raid_error_state
2895 * since a unit or column state transition may take place.
2896 * must obtain unit reader lock to retry I/O.
2897 */
2898 static void
2899 raid_wrerr(md_raidcs_t *cs)
2900 {
2901 md_raidps_t *ps;
2902 mdi_unit_t *ui;
2903 mr_unit_t *un;
2904 md_raidcbuf_t *cbuf;
2905
2906 ps = cs->cs_ps;
2907 ui = ps->ps_ui;
2908
2909 un = (mr_unit_t *)md_unit_writerlock(ui);
2910 ASSERT(un != 0);
2911
2912 if (cs->cs_dbuf.b_flags & B_ERROR)
2913 (void) raid_error_state(un, &cs->cs_dbuf);
2914 if (cs->cs_pbuf.b_flags & B_ERROR)
2915 (void) raid_error_state(un, &cs->cs_pbuf);
2916 if (cs->cs_hbuf.b_flags & B_ERROR)
2917 (void) raid_error_state(un, &cs->cs_hbuf);
2918 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next)
2919 if (cbuf->cbuf_bp.b_flags & B_ERROR)
2920 (void) raid_error_state(un, &cbuf->cbuf_bp);
2921
2922 md_unit_writerexit(ui);
2923
2924 ps->ps_flags |= MD_RPS_HSREQ;
2925
2926 un = (mr_unit_t *)md_unit_readerlock(ui);
2927
2928 /* now attempt the appropriate retry routine */
2929 (*(cs->cs_retry_call))(un, cs);
2930 }
2931 /*
2932 * NAMES: raid_write_error
2933 * DESCRIPTION: I/O error handling routine for a RAID metadevice write
2934 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
2935 */
2936 /*ARGSUSED*/
2937 static void
2938 raid_write_error(md_raidcs_t *cs)
2939 {
2940 md_raidps_t *ps;
2941 mdi_unit_t *ui;
2942 mr_unit_t *un;
2943 md_raidcbuf_t *cbuf;
2944 set_t setno;
2945
2946 ps = cs->cs_ps;
2947 ui = ps->ps_ui;
2948 un = cs->cs_un;
2949
2950 setno = MD_UN2SET(un);
2951
2952 /*
2953 * locate each buf that is in error on this io and then
2954 * output an error message
2955 */
2956 if ((cs->cs_dbuf.b_flags & B_ERROR) &&
2957 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_ERRED) &&
2958 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_LAST_ERRED))
2959 cmn_err(CE_WARN, "md %s: write error on %s",
2960 md_shortname(MD_SID(un)),
2961 md_devname(setno, md_expldev(cs->cs_dbuf.b_edev), NULL, 0));
2962
2963 if ((cs->cs_pbuf.b_flags & B_ERROR) &&
2964 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_ERRED) &&
2965 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_LAST_ERRED))
2966 cmn_err(CE_WARN, "md %s: write error on %s",
2967 md_shortname(MD_SID(un)),
2968 md_devname(setno, md_expldev(cs->cs_pbuf.b_edev), NULL, 0));
2969
2970 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next)
2971 if ((cbuf->cbuf_bp.b_flags & B_ERROR) &&
2972 (COLUMN_STATE(un, cbuf->cbuf_column) != RCS_ERRED) &&
2973 (COLUMN_STATE(un, cbuf->cbuf_column) != RCS_LAST_ERRED))
2974 cmn_err(CE_WARN, "md %s: write error on %s",
2975 md_shortname(MD_SID(un)),
2976 md_devname(setno, md_expldev(cbuf->cbuf_bp.b_edev),
2977 NULL, 0));
2978
2979 md_unit_readerexit(ui);
2980
2981 ASSERT(cs->cs_frags == 0);
2982
2983 /* now schedule processing for possible state change */
2984 daemon_request(&md_mstr_daemon, raid_wrerr,
2985 (daemon_queue_t *)cs, REQ_OLD);
2986
2987 }
2988
2989 /*
2990 * NAME: raid_write_ponly
2991 * DESCRIPTION: RAID metadevice write routine
2992 * in the case where only the parity column can be written
2993 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2994 */
2995 static void
2996 raid_write_ponly(md_raidcs_t *cs)
2997 {
2998 md_raidps_t *ps;
2999 mr_unit_t *un = cs->cs_un;
3000
3001 ps = cs->cs_ps;
3002 /* decrement pwfrags if needed, but not frags */
3003 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
3004 raid_free_parent(ps, RFP_DECR_PWFRAGS);
3005 cs->cs_flags |= MD_RCS_PWDONE;
3006 cs->cs_frags = 1;
3007 cs->cs_stage = RAID_WRITE_PONLY_DONE;
3008 cs->cs_call = raid_stage;
3009 cs->cs_error_call = raid_write_error;
3010 cs->cs_retry_call = raid_write_no_retry;
3011 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3012 cs->cs_frags++;
3013 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_PARITY | RIO_WRITE);
3014 }
3015 raidio(cs, RIO_PARITY | RIO_WRITE);
3016 }
3017
3018 /*
3019 * NAME: raid_write_ploop
3020 * DESCRIPTION: RAID metadevice write routine, constructs parity from
3021 * data in other columns.
3022 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3023 */
3024 static void
3025 raid_write_ploop(md_raidcs_t *cs)
3026 {
3027 mr_unit_t *un = cs->cs_un;
3028 uint_t *dbuf;
3029 uint_t *pbuf;
3030 size_t wordcnt;
3031 uint_t psum = 0;
3032
3033 wordcnt = cs->cs_bcount / sizeof (uint_t);
3034 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
3035 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
3036 while (wordcnt--)
3037 *pbuf++ ^= *dbuf++;
3038 cs->cs_loop++;
3039
3040 /*
3041 * build parity from scratch using new data,
3042 * skip reading the data and parity columns.
3043 */
3044 while (cs->cs_loop == cs->cs_dcolumn || cs->cs_loop == cs->cs_pcolumn)
3045 cs->cs_loop++;
3046
3047 if (cs->cs_loop != un->un_totalcolumncnt) {
3048 cs->cs_frags = 1;
3049 raidio(cs, RIO_DATA | RIO_READ | (cs->cs_loop + 1));
3050 return;
3051 }
3052
3053 /* construct checksum for parity buffer */
3054 wordcnt = cs->cs_bcount / sizeof (uint_t);
3055 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
3056 while (wordcnt--) {
3057 psum ^= *pbuf;
3058 pbuf++;
3059 }
3060 RAID_FILLIN_RPW(cs->cs_pbuffer, un, psum, -1,
3061 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
3062 1, cs->cs_pcolumn, RAID_PWMAGIC);
3063
3064 cs->cs_stage = RAID_NONE;
3065 cs->cs_call = raid_write_ponly;
3066 cs->cs_error_call = raid_write_error;
3067 cs->cs_retry_call = raid_write_err_retry;
3068 cs->cs_frags = 1;
3069 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3070 cs->cs_frags++;
3071 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_PARITY | RIO_PREWRITE);
3072 }
3073 raidio(cs, RIO_PARITY | RIO_PREWRITE);
3074 }
3075
3076 /*
3077 * NAME: raid_write_donly
3078 * DESCRIPTION: RAID metadevice write routine
3079 * Completed writing data to prewrite entry
3080 * in the case where only the data column can be written
3081 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3082 */
3083 static void
3084 raid_write_donly(md_raidcs_t *cs)
3085 {
3086 md_raidps_t *ps;
3087 mr_unit_t *un = cs->cs_un;
3088
3089 ps = cs->cs_ps;
3090 /* WARNING: don't release unit reader lock here... */
3091 /* decrement pwfrags if needed, but not frags */
3092 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
3093 raid_free_parent(ps, RFP_DECR_PWFRAGS);
3094 cs->cs_flags |= MD_RCS_PWDONE;
3095 cs->cs_frags = 1;
3096 cs->cs_stage = RAID_WRITE_DONLY_DONE;
3097 cs->cs_call = raid_stage;
3098 cs->cs_error_call = raid_write_error;
3099 cs->cs_retry_call = raid_write_err_retry;
3100 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3101 cs->cs_frags++;
3102 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_DATA | RIO_WRITE);
3103 }
3104 raidio(cs, RIO_DATA | RIO_WRITE);
3105 }
3106
3107 /*
3108 * NAME: raid_write_got_old
3109 * DESCRIPTION: RAID metadevice write routine
3110 * completed read of old data and old parity
3111 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3112 */
3113 static void
3114 raid_write_got_old(md_raidcs_t *cs)
3115 {
3116 mr_unit_t *un = cs->cs_un;
3117
3118 ASSERT(IO_READER_HELD(cs->cs_un));
3119 ASSERT(UNIT_READER_HELD(cs->cs_un));
3120
3121 raid_mapin_buf(cs);
3122 genstandardparity(cs);
3123 cs->cs_frags = 2;
3124 cs->cs_call = raid_stage;
3125 cs->cs_stage = RAID_PREWRITE_DONE;
3126 cs->cs_error_call = raid_write_error;
3127 cs->cs_retry_call = raid_write_retry;
3128
3129 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3130 cs->cs_frags++;
3131 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_DATA | RIO_PREWRITE);
3132 }
3133
3134 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3135 cs->cs_frags++;
3136 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_PARITY | RIO_PREWRITE);
3137 }
3138 ASSERT(cs->cs_frags < 4);
3139 raidio(cs, RIO_DATA | RIO_PREWRITE);
3140 raidio(cs, RIO_PARITY | RIO_PREWRITE);
3141 }
3142
3143 /*
3144 * NAME: raid_write_io
3145 * DESCRIPTION: RAID metadevice write I/O routine
3146 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
3147 * md_raidcs_t *cs - pointer to a child structure
3148 */
3149
3150 /*ARGSUSED*/
3151 static void
3152 raid_write_io(mr_unit_t *un, md_raidcs_t *cs)
3153 {
3154 md_raidps_t *ps = cs->cs_ps;
3155 uint_t *dbuf;
3156 uint_t *ubuf;
3157 size_t wordcnt;
3158 uint_t dsum = 0;
3159 int pcheck;
3160 int dcheck;
3161
3162 ASSERT((un->un_column[cs->cs_pcolumn].un_devstate &
3163 RCS_INIT) == 0);
3164 ASSERT((un->un_column[cs->cs_dcolumn].un_devstate &
3165 RCS_INIT) == 0);
3166 ASSERT(IO_READER_HELD(un));
3167 ASSERT(UNIT_READER_HELD(un));
3168 ASSERT(cs->cs_flags & MD_RCS_HAVE_PW_SLOTS);
3169 if (cs->cs_flags & MD_RCS_LINE) {
3170
3171 mr_unit_t *un = cs->cs_un;
3172
3173 ASSERT(un->un_origcolumncnt == un->un_totalcolumncnt);
3174 raid_mapin_buf(cs);
3175 cs->cs_frags = un->un_origcolumncnt;
3176 cs->cs_call = raid_stage;
3177 cs->cs_error_call = raid_write_error;
3178 cs->cs_retry_call = raid_write_no_retry;
3179 cs->cs_stage = RAID_LINE_PWDONE;
3180 genlineparity(cs);
3181 return;
3182 }
3183
3184 pcheck = erred_check_line(un, cs, &un->un_column[cs->cs_pcolumn]);
3185 dcheck = erred_check_line(un, cs, &un->un_column[cs->cs_dcolumn]);
3186 cs->cs_resync_check = pcheck << RCL_PARITY_OFFSET || dcheck;
3187
3188 if (pcheck == RCL_ERRED && dcheck == RCL_ERRED) {
3189 int err = EIO;
3190
3191 if ((un->un_column[cs->cs_pcolumn].un_devstate ==
3192 RCS_LAST_ERRED) ||
3193 (un->un_column[cs->cs_dcolumn].un_devstate ==
3194 RCS_LAST_ERRED))
3195 err = ENXIO;
3196 raid_error_parent(ps, err);
3197 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
3198 raid_free_child(cs, 1);
3199 raid_free_parent(ps, RFP_DECR_FRAGS
3200 | RFP_RLS_LOCK | RFP_DECR_PWFRAGS);
3201 return;
3202 }
3203
3204 if (pcheck & RCL_ERRED) {
3205 /*
3206 * handle case of only having data drive
3207 */
3208 raid_mapin_buf(cs);
3209 wordcnt = cs->cs_bcount / sizeof (uint_t);
3210
3211 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
3212 ubuf = (uint_t *)(void *)(cs->cs_addr);
3213
3214 while (wordcnt--) {
3215 *dbuf = *ubuf;
3216 dsum ^= *ubuf;
3217 dbuf++;
3218 ubuf++;
3219 }
3220 RAID_FILLIN_RPW(cs->cs_dbuffer, un, dsum, -1,
3221 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
3222 1, cs->cs_dcolumn, RAID_PWMAGIC);
3223 cs->cs_frags = 1;
3224 cs->cs_stage = RAID_NONE;
3225 cs->cs_call = raid_write_donly;
3226 cs->cs_error_call = raid_write_error;
3227 cs->cs_retry_call = raid_write_err_retry;
3228 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3229 cs->cs_frags++;
3230 raidio(cs, RIO_DATA | RIO_ALT | RIO_EXTRA |
3231 RIO_PREWRITE);
3232 }
3233 raidio(cs, RIO_DATA | RIO_PREWRITE);
3234 return;
3235 }
3236
3237 if (dcheck & RCL_ERRED) {
3238 /*
3239 * handle case of only having parity drive
3240 * build parity from scratch using new data,
3241 * skip reading the data and parity columns.
3242 */
3243 raid_mapin_buf(cs);
3244 cs->cs_loop = 0;
3245 while (cs->cs_loop == cs->cs_dcolumn ||
3246 cs->cs_loop == cs->cs_pcolumn)
3247 cs->cs_loop++;
3248
3249 /* copy new data in to begin building parity */
3250 bcopy(cs->cs_addr, cs->cs_pbuffer + DEV_BSIZE, cs->cs_bcount);
3251 cs->cs_stage = RAID_NONE;
3252 cs->cs_call = raid_write_ploop;
3253 cs->cs_error_call = raid_write_error;
3254 cs->cs_retry_call = raid_write_err_retry;
3255 cs->cs_frags = 1;
3256 raidio(cs, RIO_DATA | RIO_READ | (cs->cs_loop + 1));
3257 return;
3258 }
3259 /*
3260 * handle normal cases
3261 * read old data and old parity
3262 */
3263 cs->cs_frags = 2;
3264 cs->cs_stage = RAID_NONE;
3265 cs->cs_call = raid_write_got_old;
3266 cs->cs_error_call = raid_write_error;
3267 cs->cs_retry_call = raid_write_retry;
3268 ASSERT(ps->ps_magic == RAID_PSMAGIC);
3269 raidio(cs, RIO_DATA | RIO_READ);
3270 raidio(cs, RIO_PARITY | RIO_READ);
3271 }
3272
3273 static void
3274 raid_enqueue(md_raidcs_t *cs)
3275 {
3276 mdi_unit_t *ui = cs->cs_ps->ps_ui;
3277 kmutex_t *io_list_mutex = &ui->ui_io_lock->io_list_mutex;
3278 md_raidcs_t *cs1;
3279
3280 mutex_enter(io_list_mutex);
3281 ASSERT(! (cs->cs_flags & MD_RCS_LLOCKD));
3282 if (ui->ui_io_lock->io_list_front == NULL) {
3283 ui->ui_io_lock->io_list_front = cs;
3284 ui->ui_io_lock->io_list_back = cs;
3285 } else {
3286 cs1 = ui->ui_io_lock->io_list_back;
3287 cs1->cs_linlck_next = cs;
3288 ui->ui_io_lock->io_list_back = cs;
3289 }
3290 STAT_INC(raid_write_waits);
3291 STAT_MAX(raid_max_write_q_length, raid_write_queue_length);
3292 cs->cs_linlck_next = NULL;
3293 mutex_exit(io_list_mutex);
3294 }
3295
3296 /*
3297 * NAME: raid_write
3298 * DESCRIPTION: RAID metadevice write routine
3299 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
3300 * md_raidcs_t *cs - pointer to a child structure
3301 */
3302
3303 /*ARGSUSED*/
3304 static int
3305 raid_write(mr_unit_t *un, md_raidcs_t *cs)
3306 {
3307 int error = 0;
3308 md_raidps_t *ps;
3309 mdi_unit_t *ui;
3310 minor_t mnum;
3311
3312 ASSERT(IO_READER_HELD(un));
3313 ps = cs->cs_ps;
3314 ui = ps->ps_ui;
3315
3316 ASSERT(UNIT_STATE(un) != RUS_INIT);
3317 if (UNIT_STATE(un) == RUS_LAST_ERRED)
3318 error = EIO;
3319
3320 /* make sure the write doesn't go beyond the column */
3321 if (cs->cs_blkno + cs->cs_blkcnt > un->un_segsize * un->un_segsincolumn)
3322 error = ENXIO;
3323 if (error)
3324 goto werror;
3325
3326 getresources(cs);
3327
3328 /*
3329 * this is an advisory loop that keeps the waiting lists short
3330 * to reduce cpu time. Since there is a race introduced by not
3331 * aquiring all the correct mutexes, use a cv_timedwait to be
3332 * sure the write always will wake up and start.
3333 */
3334 while (raid_check_pw(cs)) {
3335 mutex_enter(&un->un_mx);
3336 un->un_rflags |= MD_RFLAG_NEEDPW;
3337 STAT_INC(raid_prewrite_waits);
3338 (void) cv_reltimedwait(&un->un_cv, &un->un_mx, md_wr_wait,
3339 TR_CLOCK_TICK);
3340 un->un_rflags &= ~MD_RFLAG_NEEDPW;
3341 mutex_exit(&un->un_mx);
3342 }
3343
3344 if (raid_line_writer_lock(cs, 1))
3345 return (0);
3346
3347 un = (mr_unit_t *)md_unit_readerlock(ui);
3348 cs->cs_un = un;
3349 mnum = MD_SID(un);
3350
3351 if (un->un_state & RUS_REGEN) {
3352 raid_regen_parity(cs);
3353 un = MD_UNIT(mnum);
3354 cs->cs_un = un;
3355 }
3356
3357 raid_write_io(un, cs);
3358 return (0);
3359 werror:
3360 /* aquire unit reader lock sinc raid_free_child always drops it */
3361 raid_error_parent(ps, error);
3362 raid_free_child(cs, 0);
3363 /* decrement both pwfrags and frags */
3364 raid_free_parent(ps, RFP_DECR_PWFRAGS | RFP_DECR_FRAGS | RFP_RLS_LOCK);
3365 return (0);
3366 }
3367
3368
3369 /*
3370 * NAMES: raid_stage
3371 * DESCRIPTION: post-processing routine for a RAID metadevice
3372 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
3373 */
3374 static void
3375 raid_stage(md_raidcs_t *cs)
3376 {
3377 md_raidps_t *ps = cs->cs_ps;
3378 mr_unit_t *un = cs->cs_un;
3379 md_raidcbuf_t *cbuf;
3380 buf_t *bp;
3381 void *private;
3382 int flag;
3383
3384 switch (cs->cs_stage) {
3385 case RAID_READ_DONE:
3386 raid_free_child(cs, 1);
3387 /* decrement readfrags */
3388 raid_free_parent(ps, RFP_DECR_READFRAGS | RFP_RLS_LOCK);
3389 return;
3390
3391 case RAID_WRITE_DONE:
3392 case RAID_WRITE_PONLY_DONE:
3393 case RAID_WRITE_DONLY_DONE:
3394 /*
3395 * Completed writing real parity and/or data.
3396 */
3397 ASSERT(cs->cs_flags & MD_RCS_PWDONE);
3398 raid_free_child(cs, 1);
3399 /* decrement frags but not pwfrags */
3400 raid_free_parent(ps, RFP_DECR_FRAGS | RFP_RLS_LOCK);
3401 return;
3402
3403 case RAID_PREWRITE_DONE:
3404 /*
3405 * completed writing data and parity to prewrite entries
3406 */
3407 /*
3408 * WARNING: don't release unit reader lock here..
3409 * decrement pwfrags but not frags
3410 */
3411 raid_free_parent(ps, RFP_DECR_PWFRAGS);
3412 cs->cs_flags |= MD_RCS_PWDONE;
3413 cs->cs_frags = 2;
3414 cs->cs_stage = RAID_WRITE_DONE;
3415 cs->cs_call = raid_stage;
3416 cs->cs_error_call = raid_write_error;
3417 cs->cs_retry_call = raid_write_no_retry;
3418 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3419 cs->cs_frags++;
3420 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_PARITY |
3421 RIO_WRITE);
3422 }
3423 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3424 cs->cs_frags++;
3425 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_DATA | RIO_WRITE);
3426 }
3427 ASSERT(cs->cs_frags < 4);
3428 raidio(cs, RIO_DATA | RIO_WRITE);
3429 raidio(cs, RIO_PARITY | RIO_WRITE);
3430 if (cs->cs_pw_inval_list) {
3431 raid_free_pwinvalidate(cs);
3432 }
3433 return;
3434
3435 case RAID_LINE_PWDONE:
3436 ASSERT(cs->cs_frags == 0);
3437 raid_free_parent(ps, RFP_DECR_PWFRAGS);
3438 cs->cs_flags |= MD_RCS_PWDONE;
3439 cs->cs_frags = un->un_origcolumncnt;
3440 cs->cs_call = raid_stage;
3441 cs->cs_error_call = raid_write_error;
3442 cs->cs_retry_call = raid_write_no_retry;
3443 cs->cs_stage = RAID_WRITE_DONE;
3444 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
3445 /*
3446 * fill in buffer for write to prewrite area
3447 */
3448 bp = &cbuf->cbuf_bp;
3449 bp->b_back = bp;
3450 bp->b_forw = bp;
3451 bp->b_un.b_addr = cbuf->cbuf_buffer + DEV_BSIZE;
3452 bp->b_bcount = cbuf->cbuf_bcount;
3453 bp->b_bufsize = cbuf->cbuf_bcount;
3454 bp->b_lblkno =
3455 un->un_column[cbuf->cbuf_column].un_devstart +
3456 cs->cs_blkno;
3457 bp->b_flags &= ~(B_READ | B_WRITE | B_ERROR);
3458 bp->b_flags &= ~nv_available;
3459 bp->b_flags |= B_WRITE | B_BUSY;
3460 bp->b_iodone = (int (*)())raid_done;
3461 bp->b_edev = md_dev64_to_dev(
3462 un->un_column[cbuf->cbuf_column].un_dev);
3463 bp->b_chain = (struct buf *)cs;
3464 private = cs->cs_strategy_private;
3465 flag = cs->cs_strategy_flag;
3466 md_call_strategy(bp, flag, private);
3467 }
3468 raidio(cs, RIO_DATA | RIO_WRITE);
3469 raidio(cs, RIO_PARITY | RIO_WRITE);
3470 if (cs->cs_pw_inval_list) {
3471 raid_free_pwinvalidate(cs);
3472 }
3473 return;
3474
3475 default:
3476 ASSERT(0);
3477 break;
3478 }
3479 }
3480 /*
3481 * NAME: md_raid_strategy
3482 * DESCRIPTION: RAID metadevice I/O oprations entry point.
3483 * PARAMETERS: buf_t *pb - pointer to a user I/O buffer
3484 * int flag - metadevice specific flag
3485 * void *private - carry over flag ??
3486 *
3487 */
3488
3489 void
3490 md_raid_strategy(buf_t *pb, int flag, void *private)
3491 {
3492 md_raidps_t *ps;
3493 md_raidcs_t *cs;
3494 int doing_writes;
3495 int err;
3496 mr_unit_t *un;
3497 mdi_unit_t *ui;
3498 size_t count;
3499 diskaddr_t blkno;
3500 caddr_t addr;
3501 off_t offset;
3502 int colcnt;
3503 minor_t mnum;
3504 set_t setno;
3505
3506 ui = MDI_UNIT(getminor(pb->b_edev));
3507 md_kstat_waitq_enter(ui);
3508 un = (mr_unit_t *)md_io_readerlock(ui);
3509 setno = MD_MIN2SET(getminor(pb->b_edev));
3510
3511 if ((flag & MD_NOBLOCK) == 0) {
3512 if (md_inc_iocount(setno) != 0) {
3513 pb->b_flags |= B_ERROR;
3514 pb->b_error = ENXIO;
3515 pb->b_resid = pb->b_bcount;
3516 md_kstat_waitq_exit(ui);
3517 md_io_readerexit(ui);
3518 biodone(pb);
3519 return;
3520 }
3521 } else {
3522 md_inc_iocount_noblock(setno);
3523 }
3524
3525 mnum = MD_SID(un);
3526 colcnt = un->un_totalcolumncnt - 1;
3527 count = pb->b_bcount;
3528
3529 STAT_CHECK(raid_512, count == 512);
3530 STAT_CHECK(raid_1024, count == 1024);
3531 STAT_CHECK(raid_1024_8192, count > 1024 && count < 8192);
3532 STAT_CHECK(raid_8192, count == 8192);
3533 STAT_CHECK(raid_8192_bigger, count > 8192);
3534
3535 (void *) md_unit_readerlock(ui);
3536 if (!(flag & MD_STR_NOTTOP)) {
3537 err = md_checkbuf(ui, (md_unit_t *)un, pb); /* check and map */
3538 if (err != 0) {
3539 md_kstat_waitq_exit(ui);
3540 md_io_readerexit(ui);
3541 return;
3542 }
3543 }
3544 md_unit_readerexit(ui);
3545
3546 STAT_INC(raid_total_io);
3547
3548 /* allocate a parent structure for the user I/O */
3549 ps = kmem_cache_alloc(raid_parent_cache, MD_ALLOCFLAGS);
3550 raid_parent_init(ps);
3551
3552 /*
3553 * Save essential information from the original buffhdr
3554 * in the md_save structure.
3555 */
3556 ps->ps_un = un;
3557 ps->ps_ui = ui;
3558 ps->ps_bp = pb;
3559 ps->ps_addr = pb->b_un.b_addr;
3560
3561 if ((pb->b_flags & B_READ) == 0) {
3562 ps->ps_flags |= MD_RPS_WRITE;
3563 doing_writes = 1;
3564 STAT_INC(raid_writes);
3565 } else {
3566 ps->ps_flags |= MD_RPS_READ;
3567 doing_writes = 0;
3568 STAT_INC(raid_reads);
3569 }
3570
3571 count = lbtodb(pb->b_bcount); /* transfer count (in blocks) */
3572 blkno = pb->b_lblkno; /* block number on device */
3573 addr = 0;
3574 offset = 0;
3575 ps->ps_pwfrags = 1;
3576 ps->ps_frags = 1;
3577 md_kstat_waitq_to_runq(ui);
3578
3579 do {
3580 cs = kmem_cache_alloc(raid_child_cache, MD_ALLOCFLAGS);
3581 raid_child_init(cs);
3582 cs->cs_ps = ps;
3583 cs->cs_un = un;
3584 cs->cs_mdunit = mnum;
3585 cs->cs_strategy_flag = flag;
3586 cs->cs_strategy_private = private;
3587 cs->cs_addr = addr;
3588 cs->cs_offset = offset;
3589 count = raid_iosetup(un, blkno, count, cs);
3590 if (cs->cs_flags & MD_RCS_LINE) {
3591 blkno += (cs->cs_blkcnt * colcnt);
3592 offset += (cs->cs_bcount * colcnt);
3593 } else {
3594 blkno += cs->cs_blkcnt;
3595 offset += cs->cs_bcount;
3596 }
3597 /* for each cs bump up the ps_pwfrags and ps_frags fields */
3598 if (count) {
3599 mutex_enter(&ps->ps_mx);
3600 ps->ps_pwfrags++;
3601 ps->ps_frags++;
3602 mutex_exit(&ps->ps_mx);
3603 if (doing_writes)
3604 (void) raid_write(un, cs);
3605 else
3606 (void) raid_read(un, cs);
3607 }
3608 } while (count);
3609 if (doing_writes) {
3610 (void) raid_write(un, cs);
3611 } else
3612 (void) raid_read(un, cs);
3613
3614 if (! (flag & MD_STR_NOTTOP) && panicstr) {
3615 while (! (ps->ps_flags & MD_RPS_DONE)) {
3616 md_daemon(1, &md_done_daemon);
3617 drv_usecwait(10);
3618 }
3619 kmem_cache_free(raid_parent_cache, ps);
3620 }
3621 }
3622
3623 /*
3624 * NAMES: raid_snarf
3625 * DESCRIPTION: RAID metadevice SNARF entry point
3626 * PARAMETERS: md_snarfcmd_t cmd,
3627 * set_t setno
3628 * RETURNS:
3629 */
3630 static int
3631 raid_snarf(md_snarfcmd_t cmd, set_t setno)
3632 {
3633 mr_unit_t *un;
3634 mddb_recid_t recid;
3635 int gotsomething;
3636 int all_raid_gotten;
3637 mddb_type_t typ1;
3638 uint_t ncol;
3639 mddb_de_ic_t *dep;
3640 mddb_rb32_t *rbp;
3641 size_t newreqsize;
3642 mr_unit_t *big_un;
3643 mr_unit32_od_t *small_un;
3644
3645
3646 if (cmd == MD_SNARF_CLEANUP)
3647 return (0);
3648
3649 all_raid_gotten = 1;
3650 gotsomething = 0;
3651 typ1 = (mddb_type_t)md_getshared_key(setno,
3652 raid_md_ops.md_driver.md_drivername);
3653 recid = mddb_makerecid(setno, 0);
3654
3655 while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0) {
3656 if (mddb_getrecprivate(recid) & MD_PRV_GOTIT) {
3657 continue;
3658 }
3659
3660 dep = mddb_getrecdep(recid);
3661 dep->de_flags = MDDB_F_RAID;
3662 rbp = dep->de_rb;
3663 switch (rbp->rb_revision) {
3664 case MDDB_REV_RB:
3665 case MDDB_REV_RBFN:
3666 if ((rbp->rb_private & MD_PRV_CONVD) == 0) {
3667 /*
3668 * This means, we have an old and small record
3669 * and this record hasn't already been
3670 * converted. Before we create an incore
3671 * metadevice from this we have to convert it to
3672 * a big record.
3673 */
3674 small_un =
3675 (mr_unit32_od_t *)mddb_getrecaddr(recid);
3676 ncol = small_un->un_totalcolumncnt;
3677 newreqsize = sizeof (mr_unit_t) +
3678 ((ncol - 1) * sizeof (mr_column_t));
3679 big_un = (mr_unit_t *)kmem_zalloc(newreqsize,
3680 KM_SLEEP);
3681 raid_convert((caddr_t)small_un, (caddr_t)big_un,
3682 SMALL_2_BIG);
3683 kmem_free(small_un, dep->de_reqsize);
3684 dep->de_rb_userdata = big_un;
3685 dep->de_reqsize = newreqsize;
3686 un = big_un;
3687 rbp->rb_private |= MD_PRV_CONVD;
3688 } else {
3689 /*
3690 * Record has already been converted. Just
3691 * get its address.
3692 */
3693 un = (mr_unit_t *)mddb_getrecaddr(recid);
3694 }
3695 un->c.un_revision &= ~MD_64BIT_META_DEV;
3696 break;
3697 case MDDB_REV_RB64:
3698 case MDDB_REV_RB64FN:
3699 /* Big device */
3700 un = (mr_unit_t *)mddb_getrecaddr(recid);
3701 un->c.un_revision |= MD_64BIT_META_DEV;
3702 un->c.un_flag |= MD_EFILABEL;
3703 break;
3704 }
3705 MDDB_NOTE_FN(rbp->rb_revision, un->c.un_revision);
3706
3707 /*
3708 * Create minor device node for snarfed entry.
3709 */
3710 (void) md_create_minor_node(MD_MIN2SET(MD_SID(un)), MD_SID(un));
3711
3712 if (MD_UNIT(MD_SID(un)) != NULL) {
3713 mddb_setrecprivate(recid, MD_PRV_PENDDEL);
3714 continue;
3715 }
3716 all_raid_gotten = 0;
3717 if (raid_build_incore((void *)un, 1) == 0) {
3718 mddb_setrecprivate(recid, MD_PRV_GOTIT);
3719 md_create_unit_incore(MD_SID(un), &raid_md_ops, 1);
3720 gotsomething = 1;
3721 } else if (un->mr_ic) {
3722 kmem_free(un->un_column_ic, sizeof (mr_column_ic_t) *
3723 un->un_totalcolumncnt);
3724 kmem_free(un->mr_ic, sizeof (*un->mr_ic));
3725 }
3726 }
3727
3728 if (!all_raid_gotten) {
3729 return (gotsomething);
3730 }
3731
3732 recid = mddb_makerecid(setno, 0);
3733 while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0)
3734 if (!(mddb_getrecprivate(recid) & MD_PRV_GOTIT))
3735 mddb_setrecprivate(recid, MD_PRV_PENDDEL);
3736
3737 return (0);
3738 }
3739
3740 /*
3741 * NAMES: raid_halt
3742 * DESCRIPTION: RAID metadevice HALT entry point
3743 * PARAMETERS: md_haltcmd_t cmd -
3744 * set_t setno -
3745 * RETURNS:
3746 */
3747 static int
3748 raid_halt(md_haltcmd_t cmd, set_t setno)
3749 {
3750 set_t i;
3751 mdi_unit_t *ui;
3752 minor_t mnum;
3753
3754 if (cmd == MD_HALT_CLOSE)
3755 return (0);
3756
3757 if (cmd == MD_HALT_OPEN)
3758 return (0);
3759
3760 if (cmd == MD_HALT_UNLOAD)
3761 return (0);
3762
3763 if (cmd == MD_HALT_CHECK) {
3764 for (i = 0; i < md_nunits; i++) {
3765 mnum = MD_MKMIN(setno, i);
3766 if ((ui = MDI_UNIT(mnum)) == NULL)
3767 continue;
3768 if (ui->ui_opsindex != raid_md_ops.md_selfindex)
3769 continue;
3770 if (md_unit_isopen(ui))
3771 return (1);
3772 }
3773 return (0);
3774 }
3775
3776 if (cmd != MD_HALT_DOIT)
3777 return (1);
3778
3779 for (i = 0; i < md_nunits; i++) {
3780 mnum = MD_MKMIN(setno, i);
3781 if ((ui = MDI_UNIT(mnum)) == NULL)
3782 continue;
3783 if (ui->ui_opsindex != raid_md_ops.md_selfindex)
3784 continue;
3785 reset_raid((mr_unit_t *)MD_UNIT(mnum), mnum, 0);
3786 }
3787 return (0);
3788 }
3789
3790 /*
3791 * NAMES: raid_close_all_devs
3792 * DESCRIPTION: Close all the devices of the unit.
3793 * PARAMETERS: mr_unit_t *un - pointer to unit structure
3794 * RETURNS:
3795 */
3796 void
3797 raid_close_all_devs(mr_unit_t *un, int init_pw, int md_cflags)
3798 {
3799 int i;
3800 mr_column_t *device;
3801
3802 for (i = 0; i < un->un_totalcolumncnt; i++) {
3803 device = &un->un_column[i];
3804 if (device->un_devflags & MD_RAID_DEV_ISOPEN) {
3805 ASSERT((device->un_dev != (md_dev64_t)0) &&
3806 (device->un_dev != NODEV64));
3807 if ((device->un_devstate & RCS_OKAY) && init_pw)
3808 (void) init_pw_area(un, device->un_dev,
3809 device->un_pwstart, i);
3810 md_layered_close(device->un_dev, md_cflags);
3811 device->un_devflags &= ~MD_RAID_DEV_ISOPEN;
3812 }
3813 }
3814 }
3815
3816 /*
3817 * NAMES: raid_open_all_devs
3818 * DESCRIPTION: Open all the components (columns) of the device unit.
3819 * PARAMETERS: mr_unit_t *un - pointer to unit structure
3820 * RETURNS:
3821 */
3822 static int
3823 raid_open_all_devs(mr_unit_t *un, int md_oflags)
3824 {
3825 minor_t mnum = MD_SID(un);
3826 int i;
3827 int not_opened = 0;
3828 int commit = 0;
3829 int col = -1;
3830 mr_column_t *device;
3831 set_t setno = MD_MIN2SET(MD_SID(un));
3832 side_t side = mddb_getsidenum(setno);
3833 mdkey_t key;
3834 mdi_unit_t *ui = MDI_UNIT(mnum);
3835
3836 ui->ui_tstate &= ~MD_INACCESSIBLE;
3837
3838 for (i = 0; i < un->un_totalcolumncnt; i++) {
3839 md_dev64_t tmpdev;
3840
3841 device = &un->un_column[i];
3842
3843 if (COLUMN_STATE(un, i) & RCS_ERRED) {
3844 not_opened++;
3845 continue;
3846 }
3847
3848 if (device->un_devflags & MD_RAID_DEV_ISOPEN)
3849 continue;
3850
3851 tmpdev = device->un_dev;
3852 /*
3853 * Open by device id
3854 */
3855 key = HOTSPARED(un, i) ?
3856 device->un_hs_key : device->un_orig_key;
3857 if ((md_getmajor(tmpdev) != md_major) &&
3858 md_devid_found(setno, side, key) == 1) {
3859 tmpdev = md_resolve_bydevid(mnum, tmpdev, key);
3860 }
3861 if (md_layered_open(mnum, &tmpdev, md_oflags)) {
3862 device->un_dev = tmpdev;
3863 not_opened++;
3864 continue;
3865 }
3866 device->un_dev = tmpdev;
3867 device->un_devflags |= MD_RAID_DEV_ISOPEN;
3868 }
3869
3870 /* if open errors and errored devices are 1 then device can run */
3871 if (not_opened > 1) {
3872 cmn_err(CE_WARN,
3873 "md: %s failed to open. open error on %s\n",
3874 md_shortname(MD_SID(un)),
3875 md_devname(MD_UN2SET(un), device->un_orig_dev, NULL, 0));
3876
3877 ui->ui_tstate |= MD_INACCESSIBLE;
3878
3879 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL, SVM_TAG_METADEVICE,
3880 MD_UN2SET(un), MD_SID(un));
3881
3882 return (not_opened > 1);
3883 }
3884
3885 for (i = 0; i < un->un_totalcolumncnt; i++) {
3886 device = &un->un_column[i];
3887 if (device->un_devflags & MD_RAID_DEV_ISOPEN) {
3888 if (device->un_devstate & RCS_LAST_ERRED) {
3889 /*
3890 * At this point in time there is a possibility
3891 * that errors were the result of a controller
3892 * failure with more than a single column on it
3893 * so clear out last errored columns and let errors
3894 * re-occur is necessary.
3895 */
3896 raid_set_state(un, i, RCS_OKAY, 0);
3897 commit++;
3898 }
3899 continue;
3900 }
3901 ASSERT(col == -1);
3902 col = i;
3903 }
3904
3905 if (col != -1) {
3906 raid_set_state(un, col, RCS_ERRED, 0);
3907 commit++;
3908 }
3909
3910 if (commit)
3911 raid_commit(un, NULL);
3912
3913 if (col != -1) {
3914 if (COLUMN_STATE(un, col) & RCS_ERRED) {
3915 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
3916 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
3917 } else if (COLUMN_STATE(un, col) & RCS_LAST_ERRED) {
3918 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED,
3919 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
3920 }
3921 }
3922
3923 return (0);
3924 }
3925
3926 /*
3927 * NAMES: raid_internal_open
3928 * DESCRIPTION: Do the actual RAID open
3929 * PARAMETERS: minor_t mnum - minor number of the RAID device
3930 * int flag -
3931 * int otyp -
3932 * int md_oflags - RAID open flags
3933 * RETURNS: 0 if successful, nonzero otherwise
3934 */
3935 int
3936 raid_internal_open(minor_t mnum, int flag, int otyp, int md_oflags)
3937 {
3938 mr_unit_t *un;
3939 mdi_unit_t *ui;
3940 int err = 0;
3941 int replay_error = 0;
3942
3943 ui = MDI_UNIT(mnum);
3944 ASSERT(ui != NULL);
3945
3946 un = (mr_unit_t *)md_unit_openclose_enter(ui);
3947 /*
3948 * this MUST be checked before md_unit_isopen is checked.
3949 * raid_init_columns sets md_unit_isopen to block reset, halt.
3950 */
3951 if ((UNIT_STATE(un) & (RUS_INIT | RUS_DOI)) &&
3952 !(md_oflags & MD_OFLG_ISINIT)) {
3953 md_unit_openclose_exit(ui);
3954 return (EAGAIN);
3955 }
3956
3957 if ((md_oflags & MD_OFLG_ISINIT) || md_unit_isopen(ui)) {
3958 err = md_unit_incopen(mnum, flag, otyp);
3959 goto out;
3960 }
3961
3962 md_unit_readerexit(ui);
3963
3964 un = (mr_unit_t *)md_unit_writerlock(ui);
3965 if (raid_open_all_devs(un, md_oflags) == 0) {
3966 if ((err = md_unit_incopen(mnum, flag, otyp)) != 0) {
3967 md_unit_writerexit(ui);
3968 un = (mr_unit_t *)md_unit_readerlock(ui);
3969 raid_close_all_devs(un, 0, md_oflags);
3970 goto out;
3971 }
3972 } else {
3973 /*
3974 * if this unit contains more than two errored components
3975 * should return error and close all opened devices
3976 */
3977
3978 md_unit_writerexit(ui);
3979 un = (mr_unit_t *)md_unit_readerlock(ui);
3980 raid_close_all_devs(un, 0, md_oflags);
3981 md_unit_openclose_exit(ui);
3982 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL, SVM_TAG_METADEVICE,
3983 MD_UN2SET(un), MD_SID(un));
3984 return (ENXIO);
3985 }
3986
3987 if (!(MD_STATUS(un) & MD_UN_REPLAYED)) {
3988 replay_error = raid_replay(un);
3989 MD_STATUS(un) |= MD_UN_REPLAYED;
3990 }
3991
3992 md_unit_writerexit(ui);
3993 un = (mr_unit_t *)md_unit_readerlock(ui);
3994
3995 if ((replay_error == RAID_RPLY_READONLY) &&
3996 ((flag & (FREAD | FWRITE)) == FREAD)) {
3997 md_unit_openclose_exit(ui);
3998 return (0);
3999 }
4000
4001 /* allocate hotspare if possible */
4002 (void) raid_hotspares();
4003
4004
4005 out:
4006 md_unit_openclose_exit(ui);
4007 return (err);
4008 }
4009 /*
4010 * NAMES: raid_open
4011 * DESCRIPTION: RAID metadevice OPEN entry point
4012 * PARAMETERS: dev_t dev -
4013 * int flag -
4014 * int otyp -
4015 * cred_t * cred_p -
4016 * int md_oflags -
4017 * RETURNS:
4018 */
4019 /*ARGSUSED1*/
4020 static int
4021 raid_open(dev_t *dev, int flag, int otyp, cred_t *cred_p, int md_oflags)
4022 {
4023 int error = 0;
4024
4025 if (error = raid_internal_open(getminor(*dev), flag, otyp, md_oflags)) {
4026 return (error);
4027 }
4028 return (0);
4029 }
4030
4031 /*
4032 * NAMES: raid_internal_close
4033 * DESCRIPTION: RAID metadevice CLOSE actual implementation
4034 * PARAMETERS: minor_t - minor number of the RAID device
4035 * int otyp -
4036 * int init_pw -
4037 * int md_cflags - RAID close flags
4038 * RETURNS: 0 if successful, nonzero otherwise
4039 */
4040 /*ARGSUSED*/
4041 int
4042 raid_internal_close(minor_t mnum, int otyp, int init_pw, int md_cflags)
4043 {
4044 mdi_unit_t *ui = MDI_UNIT(mnum);
4045 mr_unit_t *un;
4046 int err = 0;
4047
4048 /* single thread */
4049 un = (mr_unit_t *)md_unit_openclose_enter(ui);
4050
4051 /* count closed */
4052 if ((err = md_unit_decopen(mnum, otyp)) != 0)
4053 goto out;
4054 /* close devices, if necessary */
4055 if (! md_unit_isopen(ui) || (md_cflags & MD_OFLG_PROBEDEV)) {
4056 raid_close_all_devs(un, init_pw, md_cflags);
4057 }
4058
4059 /* unlock, return success */
4060 out:
4061 md_unit_openclose_exit(ui);
4062 return (err);
4063 }
4064
4065 /*
4066 * NAMES: raid_close
4067 * DESCRIPTION: RAID metadevice close entry point
4068 * PARAMETERS: dev_t dev -
4069 * int flag -
4070 * int otyp -
4071 * cred_t * cred_p -
4072 * int md_oflags -
4073 * RETURNS:
4074 */
4075 /*ARGSUSED1*/
4076 static int
4077 raid_close(dev_t dev, int flag, int otyp, cred_t *cred_p, int md_cflags)
4078 {
4079 int retval;
4080
4081 (void) md_io_writerlock(MDI_UNIT(getminor(dev)));
4082 retval = raid_internal_close(getminor(dev), otyp, 1, md_cflags);
4083 (void) md_io_writerexit(MDI_UNIT(getminor(dev)));
4084 return (retval);
4085 }
4086
4087 /*
4088 * raid_probe_close_all_devs
4089 */
4090 void
4091 raid_probe_close_all_devs(mr_unit_t *un)
4092 {
4093 int i;
4094 mr_column_t *device;
4095
4096 for (i = 0; i < un->un_totalcolumncnt; i++) {
4097 device = &un->un_column[i];
4098
4099 if (device->un_devflags & MD_RAID_DEV_PROBEOPEN) {
4100 md_layered_close(device->un_dev,
4101 MD_OFLG_PROBEDEV);
4102 device->un_devflags &= ~MD_RAID_DEV_PROBEOPEN;
4103 }
4104 }
4105 }
4106 /*
4107 * Raid_probe_dev:
4108 *
4109 * On entry the unit writerlock is held
4110 */
4111 static int
4112 raid_probe_dev(mdi_unit_t *ui, minor_t mnum)
4113 {
4114 mr_unit_t *un;
4115 int i;
4116 int not_opened = 0;
4117 int commit = 0;
4118 int col = -1;
4119 mr_column_t *device;
4120 int md_devopen = 0;
4121
4122 if (md_unit_isopen(ui))
4123 md_devopen++;
4124
4125 un = MD_UNIT(mnum);
4126 /*
4127 * If the state has been set to LAST_ERRED because
4128 * of an error when the raid device was open at some
4129 * point in the past, don't probe. We really don't want
4130 * to reset the state in this case.
4131 */
4132 if (UNIT_STATE(un) == RUS_LAST_ERRED)
4133 return (0);
4134
4135 ui->ui_tstate &= ~MD_INACCESSIBLE;
4136
4137 for (i = 0; i < un->un_totalcolumncnt; i++) {
4138 md_dev64_t tmpdev;
4139
4140 device = &un->un_column[i];
4141 if (COLUMN_STATE(un, i) & RCS_ERRED) {
4142 not_opened++;
4143 continue;
4144 }
4145
4146 tmpdev = device->un_dev;
4147 /*
4148 * Currently the flags passed are not needed since
4149 * there cannot be an underlying metadevice. However
4150 * they are kept here for consistency.
4151 *
4152 * Open by device id
4153 */
4154 tmpdev = md_resolve_bydevid(mnum, tmpdev, HOTSPARED(un, i)?
4155 device->un_hs_key : device->un_orig_key);
4156 if (md_layered_open(mnum, &tmpdev,
4157 MD_OFLG_CONT_ERRS | MD_OFLG_PROBEDEV)) {
4158 device->un_dev = tmpdev;
4159 not_opened++;
4160 continue;
4161 }
4162 device->un_dev = tmpdev;
4163
4164 device->un_devflags |= MD_RAID_DEV_PROBEOPEN;
4165 }
4166
4167 /*
4168 * The code below is careful on setting the LAST_ERRED state.
4169 *
4170 * If open errors and exactly one device has failed we can run.
4171 * If more then one device fails we have to figure out when to set
4172 * LAST_ERRED state. The rationale is to avoid unnecessary resyncs
4173 * since they are painful and time consuming.
4174 *
4175 * When more than one component/column fails there are 2 scenerios.
4176 *
4177 * 1. Metadevice has NOT been opened: In this case, the behavior
4178 * mimics the open symantics. ie. Only the first failed device
4179 * is ERRED and LAST_ERRED is not set.
4180 *
4181 * 2. Metadevice has been opened: Here the read/write sematics are
4182 * followed. The first failed devicce is ERRED and on the next
4183 * failed device LAST_ERRED is set.
4184 */
4185
4186 if (not_opened > 1 && !md_devopen) {
4187 cmn_err(CE_WARN,
4188 "md: %s failed to open. open error on %s\n",
4189 md_shortname(MD_SID(un)),
4190 md_devname(MD_UN2SET(un), device->un_orig_dev, NULL, 0));
4191 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL, SVM_TAG_METADEVICE,
4192 MD_UN2SET(un), MD_SID(un));
4193 raid_probe_close_all_devs(un);
4194 ui->ui_tstate |= MD_INACCESSIBLE;
4195 return (not_opened > 1);
4196 }
4197
4198 if (!md_devopen) {
4199 for (i = 0; i < un->un_totalcolumncnt; i++) {
4200 device = &un->un_column[i];
4201 if (device->un_devflags & MD_RAID_DEV_PROBEOPEN) {
4202 if (device->un_devstate & RCS_LAST_ERRED) {
4203 /*
4204 * At this point in time there is a
4205 * possibility that errors were the
4206 * result of a controller failure with
4207 * more than a single column on it so
4208 * clear out last errored columns and
4209 * let errors re-occur is necessary.
4210 */
4211 raid_set_state(un, i, RCS_OKAY, 0);
4212 commit++;
4213 }
4214 continue;
4215 }
4216 ASSERT(col == -1);
4217 /*
4218 * note if multiple devices are failing then only
4219 * the last one is marked as error
4220 */
4221 col = i;
4222 }
4223
4224 if (col != -1) {
4225 raid_set_state(un, col, RCS_ERRED, 0);
4226 commit++;
4227 }
4228
4229 } else {
4230 for (i = 0; i < un->un_totalcolumncnt; i++) {
4231 device = &un->un_column[i];
4232
4233 /* if we have LAST_ERRED go ahead and commit. */
4234 if (un->un_state & RUS_LAST_ERRED)
4235 break;
4236 /*
4237 * could not open the component
4238 */
4239
4240 if (!(device->un_devflags & MD_RAID_DEV_PROBEOPEN)) {
4241 col = i;
4242 raid_set_state(un, col, RCS_ERRED, 0);
4243 commit++;
4244 }
4245 }
4246 }
4247
4248 if (commit)
4249 raid_commit(un, NULL);
4250
4251 if (col != -1) {
4252 if (COLUMN_STATE(un, col) & RCS_ERRED) {
4253 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
4254 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
4255 } else if (COLUMN_STATE(un, col) & RCS_LAST_ERRED) {
4256 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED,
4257 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
4258 }
4259 }
4260
4261 raid_probe_close_all_devs(un);
4262 return (0);
4263 }
4264
4265 static int
4266 raid_imp_set(
4267 set_t setno
4268 )
4269 {
4270 mddb_recid_t recid;
4271 int i, gotsomething;
4272 mddb_type_t typ1;
4273 mddb_de_ic_t *dep;
4274 mddb_rb32_t *rbp;
4275 mr_unit_t *un64;
4276 mr_unit32_od_t *un32;
4277 md_dev64_t self_devt;
4278 minor_t *self_id; /* minor needs to be updated */
4279 md_parent_t *parent_id; /* parent needs to be updated */
4280 mddb_recid_t *record_id; /* record id needs to be updated */
4281 hsp_t *hsp_id;
4282
4283 gotsomething = 0;
4284
4285 typ1 = (mddb_type_t)md_getshared_key(setno,
4286 raid_md_ops.md_driver.md_drivername);
4287 recid = mddb_makerecid(setno, 0);
4288
4289 while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0) {
4290 if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
4291 continue;
4292
4293 dep = mddb_getrecdep(recid);
4294 rbp = dep->de_rb;
4295
4296 switch (rbp->rb_revision) {
4297 case MDDB_REV_RB:
4298 case MDDB_REV_RBFN:
4299 /*
4300 * Small device
4301 */
4302 un32 = (mr_unit32_od_t *)mddb_getrecaddr(recid);
4303 self_id = &(un32->c.un_self_id);
4304 parent_id = &(un32->c.un_parent);
4305 record_id = &(un32->c.un_record_id);
4306 hsp_id = &(un32->un_hsp_id);
4307
4308 for (i = 0; i < un32->un_totalcolumncnt; i++) {
4309 mr_column32_od_t *device;
4310
4311 device = &un32->un_column[i];
4312 if (!md_update_minor(setno, mddb_getsidenum
4313 (setno), device->un_orig_key))
4314 goto out;
4315
4316 if (device->un_hs_id != 0)
4317 device->un_hs_id =
4318 MAKERECID(setno, device->un_hs_id);
4319 }
4320 break;
4321 case MDDB_REV_RB64:
4322 case MDDB_REV_RB64FN:
4323 un64 = (mr_unit_t *)mddb_getrecaddr(recid);
4324 self_id = &(un64->c.un_self_id);
4325 parent_id = &(un64->c.un_parent);
4326 record_id = &(un64->c.un_record_id);
4327 hsp_id = &(un64->un_hsp_id);
4328
4329 for (i = 0; i < un64->un_totalcolumncnt; i++) {
4330 mr_column_t *device;
4331
4332 device = &un64->un_column[i];
4333 if (!md_update_minor(setno, mddb_getsidenum
4334 (setno), device->un_orig_key))
4335 goto out;
4336
4337 if (device->un_hs_id != 0)
4338 device->un_hs_id =
4339 MAKERECID(setno, device->un_hs_id);
4340 }
4341 break;
4342 }
4343
4344 /*
4345 * If this is a top level and a friendly name metadevice,
4346 * update its minor in the namespace.
4347 */
4348 if ((*parent_id == MD_NO_PARENT) &&
4349 ((rbp->rb_revision == MDDB_REV_RBFN) ||
4350 (rbp->rb_revision == MDDB_REV_RB64FN))) {
4351
4352 self_devt = md_makedevice(md_major, *self_id);
4353 if (!md_update_top_device_minor(setno,
4354 mddb_getsidenum(setno), self_devt))
4355 goto out;
4356 }
4357
4358 /*
4359 * Update unit with the imported setno
4360 */
4361 mddb_setrecprivate(recid, MD_PRV_GOTIT);
4362
4363 *self_id = MD_MKMIN(setno, MD_MIN2UNIT(*self_id));
4364
4365 if (*hsp_id != -1)
4366 *hsp_id = MAKERECID(setno, DBID(*hsp_id));
4367
4368 if (*parent_id != MD_NO_PARENT)
4369 *parent_id = MD_MKMIN(setno, MD_MIN2UNIT(*parent_id));
4370 *record_id = MAKERECID(setno, DBID(*record_id));
4371 gotsomething = 1;
4372 }
4373
4374 out:
4375 return (gotsomething);
4376 }
4377
4378 static md_named_services_t raid_named_services[] = {
4379 {raid_hotspares, "poke hotspares" },
4380 {raid_rename_check, MDRNM_CHECK },
4381 {raid_rename_lock, MDRNM_LOCK },
4382 {(intptr_t (*)()) raid_rename_unlock, MDRNM_UNLOCK },
4383 {(intptr_t (*)()) raid_probe_dev, "probe open test" },
4384 {NULL, 0 }
4385 };
4386
4387 md_ops_t raid_md_ops = {
4388 raid_open, /* open */
4389 raid_close, /* close */
4390 md_raid_strategy, /* strategy */
4391 NULL, /* print */
4392 NULL, /* dump */
4393 NULL, /* read */
4394 NULL, /* write */
4395 md_raid_ioctl, /* ioctl, */
4396 raid_snarf, /* raid_snarf */
4397 raid_halt, /* raid_halt */
4398 NULL, /* aread */
4399 NULL, /* awrite */
4400 raid_imp_set, /* import set */
4401 raid_named_services
4402 };
4403
4404 static void
4405 init_init()
4406 {
4407 /* default to a second */
4408 if (md_wr_wait == 0)
4409 md_wr_wait = md_hz >> 1;
4410
4411 raid_parent_cache = kmem_cache_create("md_raid_parent",
4412 sizeof (md_raidps_t), 0, raid_parent_constructor,
4413 raid_parent_destructor, raid_run_queue, NULL, NULL, 0);
4414 raid_child_cache = kmem_cache_create("md_raid_child",
4415 sizeof (md_raidcs_t) - sizeof (buf_t) + biosize(), 0,
4416 raid_child_constructor, raid_child_destructor,
4417 raid_run_queue, NULL, NULL, 0);
4418 raid_cbuf_cache = kmem_cache_create("md_raid_cbufs",
4419 sizeof (md_raidcbuf_t), 0, raid_cbuf_constructor,
4420 raid_cbuf_destructor, raid_run_queue, NULL, NULL, 0);
4421 }
4422
4423 static void
4424 fini_uninit()
4425 {
4426 kmem_cache_destroy(raid_parent_cache);
4427 kmem_cache_destroy(raid_child_cache);
4428 kmem_cache_destroy(raid_cbuf_cache);
4429 raid_parent_cache = raid_child_cache = raid_cbuf_cache = NULL;
4430 }
4431
4432 /* define the module linkage */
4433 MD_PLUGIN_MISC_MODULE("raid module", init_init(), fini_uninit())
Unleashed OS