Lines Matching refs:un
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);
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);
166 static void raid_io_startup(mr_unit_t *un);
193 raid_set_state(mr_unit_t *un, int col, rcs_state_t newstate, int force)
203 ASSERT(un);
204 ASSERT(col < un->un_totalcolumncnt);
213 ASSERT(MDI_UNIT(MD_SID(un)) ? UNIT_WRITER_HELD(un) : 1);
215 unitstate = un->un_state;
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);
226 ASSERT(un->un_state &
229 ASSERT((un->un_state & ~(RUS_INIT |
232 if (un->un_column[col].un_devstate == newstate)
236 if (raid_state_cnt(un, RCS_OKAY) != un->un_totalcolumncnt)
238 un->un_state = RUS_REGEN;
242 orig_colstate = un->un_column[col].un_devstate;
248 for (i = 0; i < un->un_totalcolumncnt; i++) {
252 colstate = un->un_column[i].un_devstate;
262 if (okaycnt == un->un_totalcolumncnt)
272 if (un->un_state == RUS_DOI)
275 un->un_column[col].un_devstate = newstate;
276 uniqtime32(&un->un_column[col].un_devtimestamp);
283 if ((raid_state_cnt(un, RCS_LAST_ERRED) == 0) &&
284 (raid_state_cnt(un, RCS_ERRED) == 1))
287 un->un_state = unitstate;
288 uniqtime32(&un->un_timestamp);
292 devname = md_devname(MD_UN2SET(un),
293 un->un_column[col].un_dev, NULL, 0);
296 md_shortname(MD_SID(un)), devname);
300 md_shortname(MD_SID(un)), devname);
302 } else if (un->un_column[col].un_devflags &
311 md_layered_close(un->un_column[col].un_dev,
313 un->un_column[col].un_devflags &= ~MD_RAID_DEV_ISOPEN;
316 un->un_column[col].un_devflags & MD_RAID_DEV_ISOPEN) {
321 md_layered_close(un->un_column[col].un_dev, MD_OFLG_NULL);
322 un->un_column[col].un_devflags &= ~MD_RAID_DEV_ISOPEN;
330 for (i = 0; i < un->un_totalcolumncnt; i++) {
332 (un->un_column[i].un_devstate & RCS_LAST_ERRED)) {
333 raid_set_state(un, i, RCS_ERRED, 0);
367 erred_check_line(mr_unit_t *un, md_raidcs_t *cs, mr_column_t *column)
370 ASSERT(un != NULL);
400 mutex_enter(&un->un_mx);
401 if (cs->cs_line < un->un_resync_line_index) {
402 mutex_exit(&un->un_mx);
405 mutex_exit(&un->un_mx);
415 * PARAMETERS: md_raid_t *un
419 raid_state_cnt(mr_unit_t *un, rcs_state_t state)
423 for (i = 0; i < un->un_totalcolumncnt; i++)
424 if (un->un_column[i].un_devstate & state)
570 * PARAMETERS: un is the pointer to the unit structure
574 raid_build_pw_reservation(mr_unit_t *un, int colindex)
581 (sizeof (mr_scoreboard_t) * un->un_pwcnt), KM_SLEEP);
584 pw->pw_free = un->un_pwcnt;
586 for (i = 0; i < un->un_pwcnt; i++) {
593 un->un_column_ic[colindex].un_pw_reserve = pw;
599 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
604 raid_free_pw_reservation(mr_unit_t *un, int colindex)
606 mr_pw_reserve_t *pw = un->un_column_ic[colindex].un_pw_reserve;
609 (sizeof (mr_scoreboard_t) * un->un_pwcnt));
620 mr_unit_t *un = cs->cs_un;
630 col = &un->un_column_ic[cs->cs_dcolumn];
634 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
640 col = &un->un_column_ic[cs->cs_pcolumn];
644 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
652 col = &un->un_column_ic[cbuf->cbuf_column];
656 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
661 cv_broadcast(&un->un_cv);
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);
675 mr_unit_t *un = cs->cs_un;
676 mdi_unit_t *ui = MDI_UNIT(MD_SID(un));
683 mutex_enter(&un->un_linlck_mx);
685 pw = un->un_column_ic[cbuf->cbuf_column].un_pw_reserve;
690 if ((pw->pw_free++ == 0) || (un->un_rflags & MD_RFLAG_NEEDPW))
694 kmem_free(cbuf_to_free->cbuf_buffer, dbtob(un->un_iosize));
704 raid_io_startup(un);
705 mutex_exit(&un->un_linlck_mx);
707 cv_broadcast(&un->un_cv);
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);
722 mr_unit_t *un = cs->cs_un;
726 int pwcnt = un->un_pwcnt;
784 ASSERT((use >= 0) && (use < un->un_pwcnt));
792 mr_unit_t *un = cs->cs_un;
801 for (i = 0; i < un->un_totalcolumncnt; i++)
802 if (un->un_column_ic[i].un_pw_reserve->pw_free <= 0)
807 if (un->un_column_ic[cs->cs_dcolumn].un_pw_reserve->pw_free <= 0)
809 if (un->un_column_ic[cs->cs_pcolumn].un_pw_reserve->pw_free <= 0)
816 mr_unit_t *un = cs->cs_un;
823 mutex_enter(&un->un_mx);
824 un->un_pwid++;
825 cs->cs_pwid = un->un_pwid;
826 mutex_exit(&un->un_mx);
848 mr_unit_t *un = (mr_unit_t *)p;
849 minor_t mnum = MD_SID(un);
862 un->mr_ic = NULL;
864 if (MD_STATUS(un) & MD_UN_BEING_RESET) {
865 mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCLEAN);
873 MD_STATUS(un) = 0;
875 un->mr_ic = (mr_unit_ic_t *)kmem_zalloc(sizeof (*un->mr_ic),
878 un->un_column_ic = (mr_column_ic_t *)
880 un->un_totalcolumncnt, KM_SLEEP);
882 for (i = 0; i < un->un_totalcolumncnt; i++) {
884 column = &un->un_column[i];
890 if (raid_build_pw_reservation(un, i) != 0) {
925 if (HOTSPARED(un, i)) {
937 if (HOTSPARED(un, i)) {
985 un->un_resync_line_index = 0;
986 un->un_resync_index = 0;
987 un->un_percent_done = 0;
992 for (i = 0; i < un->un_totalcolumncnt; i++) {
993 column = &un->un_column[i];
994 if (HOTSPARED(un, i) &&
1000 if (HOTSPARED(un, i) &&
1003 raid_hs_release(HS_FREE, un, &hs_recid, i);
1017 mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCOM);
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;
1029 md_nblocks_set(mnum, un->c.un_total_blocks);
1030 MD_UNIT(mnum) = un;
1038 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
1044 reset_raid(mr_unit_t *un, minor_t mnum, int removing)
1049 int column_cnt = un->un_totalcolumncnt;
1061 if (un->un_pbuffer) {
1062 kmem_free(un->un_pbuffer, dbtob(un->un_iosize));
1063 un->un_pbuffer = NULL;
1065 if (un->un_dbuffer) {
1066 kmem_free(un->un_dbuffer, dbtob(un->un_iosize));
1067 un->un_dbuffer = NULL;
1071 for (i = 0; i < un->un_totalcolumncnt; i++)
1072 raid_free_pw_reservation(un, i);
1074 kmem_free(un->un_column_ic, sizeof (mr_column_ic_t) *
1075 un->un_totalcolumncnt);
1077 kmem_free(un->mr_ic, sizeof (*un->mr_ic));
1097 column = &un->un_column[i];
1100 if (HOTSPARED(un, i)) {
1105 raid_hs_release(hserr, un, &recids[n++], i);
1120 if (un->un_hsp_id != -1)
1121 (void) md_hot_spare_ifc(HSP_DECREF, un->un_hsp_id, 0, 0,
1124 MD_STATUS(un) |= MD_UN_BEING_RESET;
1125 vtoc_id = un->c.un_vtoc_id;
1127 raid_commit(un, recids);
1132 if (un->c.un_revision & MD_FN_META_DEV) {
1133 (void) md_rem_selfname(un->c.un_self_id);
1137 mddb_deleterec_wrapper(un->c.un_record_id);
1248 mr_unit_t *un = cs->cs_un;
1257 md_unit_readerexit(MDI_UNIT(MD_SID(un)));
1291 mr_unit_t *un = cs->cs_un;
1292 mdi_unit_t *ui = MDI_UNIT(un->c.un_self_id);
1297 uint_t colcnt = un->un_totalcolumncnt;
1309 ASSERT(IO_READER_HELD(un));
1311 ASSERT(UNIT_READER_HELD(un));
1313 if (raid_state_cnt(un, RCS_OKAY) != colcnt)
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;
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;
1371 un = md_unit_writerlock(ui);
1372 raid_set_state(un, column, RCS_ERRED, 0);
1374 raid_set_state(un, column, RCS_ERRED, 0);
1375 raid_commit(un, NULL);
1377 un = md_unit_readerlock(ui);
1386 * PARAMETERS: mr_unit_t *un - pointer to raid unit structure
1391 raid_error_state(mr_unit_t *un, buf_t *bp)
1396 ASSERT(IO_READER_HELD(un));
1397 ASSERT(UNIT_WRITER_HELD(un));
1400 for (i = 0; i < un->un_totalcolumncnt; i++) {
1401 if (un->un_column[i].un_dev == md_expldev(bp->b_edev)) {
1405 if (un->un_column[i].un_alt_dev == md_expldev(bp->b_edev)) {
1417 (void) raid_set_state(un, column, RCS_ERRED, 0);
1418 ASSERT(un->un_state & (RUS_ERRED | RUS_LAST_ERRED));
1420 raid_commit(un, NULL);
1421 if (un->un_state & RUS_ERRED) {
1423 MD_UN2SET(un), MD_SID(un));
1424 } else if (un->un_state & RUS_LAST_ERRED) {
1426 MD_UN2SET(un), MD_SID(un));
1474 * PARAMETERS: mr_unit_t *un - pointer to raid unit structure
1479 raid_read_no_retry(mr_unit_t *un, md_raidcs_t *cs)
1496 raid_read_retry(mr_unit_t *un, md_raidcs_t *cs)
1532 raid_read_io(un, cs);
1549 mr_unit_t *un;
1554 un = (mr_unit_t *)md_unit_writerlock(ui);
1555 ASSERT(un != 0);
1558 error = raid_error_state(un, &cs->cs_dbuf);
1560 error |= raid_error_state(un, &cs->cs_pbuf);
1566 un = (mr_unit_t *)md_unit_readerlock(ui);
1567 ASSERT(un != 0);
1569 (*(cs->cs_retry_call))(un, cs);
1584 mr_unit_t *un;
1589 un = cs->cs_un;
1591 setno = MD_UN2SET(un);
1594 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_ERRED) &&
1595 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_LAST_ERRED))
1597 md_shortname(MD_SID(un)),
1601 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_ERRED) &&
1602 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_LAST_ERRED))
1604 md_shortname(MD_SID(un)),
1629 mr_unit_t *un;
1634 un = cs->cs_ps->ps_un;
1635 mutex_enter(&un->un_mx);
1636 while (un->un_dbuffer == NULL) {
1638 un->un_rflags |= MD_RFLAG_NEEDBUF;
1639 cv_wait(&un->un_cv, &un->un_mx);
1641 cs->cs_dbuffer = un->un_dbuffer;
1643 un->un_dbuffer = NULL;
1644 mutex_exit(&un->un_mx);
1659 mr_unit_t *un;
1664 un = cs->cs_ps->ps_un;
1665 mutex_enter(&un->un_mx);
1666 while (un->un_pbuffer == NULL) {
1668 un->un_rflags |= MD_RFLAG_NEEDBUF;
1669 cv_wait(&un->un_cv, &un->un_mx);
1671 cs->cs_pbuffer = un->un_pbuffer;
1673 un->un_pbuffer = NULL;
1674 mutex_exit(&un->un_mx);
1699 mr_unit_t *un;
1712 un = cs->cs_un;
1713 mutex_enter(&un->un_mx);
1717 un->un_dbuffer = cs->cs_dbuffer;
1723 un->un_pbuffer = cs->cs_pbuffer;
1728 un->un_rflags &= ~MD_RFLAG_NEEDBUF;
1729 cv_broadcast(&un->un_cv);
1730 mutex_exit(&un->un_mx);
1744 mr_unit_t *un;
1748 un = cs->cs_un;
1750 STAT_CHECK(raid_line_lock_wait, MUTEX_HELD(&un->un_linlck_mx));
1752 mutex_enter(&un->un_linlck_mx);
1753 cs1 = un->un_linlck_chn;
1755 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1763 un->un_linlck_flg = 1;
1764 cv_wait(&un->un_linlck_cv, &un->un_linlck_mx);
1770 cs1 = un->un_linlck_chn;
1775 un->un_linlck_chn = cs;
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);
1786 mutex_exit(&un->un_linlck_mx);
1792 mr_unit_t *un;
1797 un = cs->cs_ps->ps_un;
1799 STAT_CHECK(raid_line_lock_wait, MUTEX_HELD(&un->un_linlck_mx));
1801 mutex_enter(&un->un_linlck_mx);
1802 ASSERT(MUTEX_HELD(&un->un_linlck_mx));
1804 cs1 = un->un_linlck_chn;
1805 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1822 cs1 = un->un_linlck_chn;
1827 un->un_linlck_chn = cs;
1833 mutex_exit(&un->un_linlck_mx);
1842 cs->cs_un = un;
1845 mutex_exit(&un->un_linlck_mx);
1853 mr_unit_t *un = cs->cs_un;
1855 un = md_unit_readerlock(ui);
1856 raid_write_io(un, cs);
1860 raid_io_startup(mr_unit_t *un)
1864 mdi_unit_t *ui = MDI_UNIT(un->c.un_self_id);
1867 ASSERT(MUTEX_HELD(&un->un_linlck_mx));
1878 for (cs1 = un->un_linlck_chn; cs1; cs1 = cs1->cs_linlck_next)
1934 mr_unit_t *un;
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);
1947 un->un_linlck_chn = cs->cs_linlck_next;
1953 if (un->un_linlck_flg)
1954 cv_broadcast(&un->un_linlck_cv);
1956 un->un_linlck_flg = 0;
1964 raid_io_startup(un);
1966 mutex_exit(&un->un_linlck_mx);
1974 * mr_unit_t *un - pointer to an unit structure
1980 raid_line(diskaddr_t segment, mr_unit_t *un)
1986 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
1989 line = adj_seg % un->un_segsincolumn;
1991 line = segment / (un->un_origcolumncnt - 1);
1997 raid_dcolumn(diskaddr_t segment, mr_unit_t *un)
2004 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
2007 column = un->un_origcolumncnt +
2008 (uint_t)(adj_seg / un->un_segsincolumn);
2010 line = segment / (un->un_origcolumncnt - 1);
2012 (un->un_origcolumncnt - 1) + line) % un->un_origcolumncnt);
2018 raid_pcolumn(diskaddr_t segment, mr_unit_t *un)
2025 max_orig_segment = (un->un_origcolumncnt - 1) * un->un_segsincolumn;
2028 line = adj_seg % un->un_segsincolumn;
2030 line = segment / (un->un_origcolumncnt - 1);
2032 column = (uint_t)((line + (un->un_origcolumncnt - 1)) %
2033 un->un_origcolumncnt);
2048 raid_check_cols(mr_unit_t *un)
2053 minor_t mnum = MD_SID(un);
2059 for (i = 0; i < un->un_totalcolumncnt; i++) {
2062 colptr = &un->un_column[i];
2070 tmpdev = md_resolve_bydevid(mnum, tmpdev, HOTSPARED(un, i) ?
2109 * PARAMETERS: mr_unit_t *un - unit number of RAID metadevice
2135 mr_unit_t *un,
2150 segment = blkno / un->un_segsize;
2151 segstart = segment * un->un_segsize;
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;
2163 (UNIT_STATE(un) & RCS_OKAY) &&
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)) {
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;
2187 for (i = 0; i < un->un_totalcolumncnt; i++) {
2189 j = j % un->un_totalcolumncnt;
2199 cbuf->cbuf_bcount = dbtob(un->un_segsize);
2206 leftover = blkcnt - (un->un_segsize - segoff);
2207 if (blkcnt > (un->un_segsize - segoff))
2219 cs->cs_blkno = line * un->un_segsize + segoff;
2300 mr_unit_t *un;
2306 un = cs->cs_un;
2308 ASSERT(IO_READER_HELD(un));
2309 ASSERT(UNIT_READER_HELD(un));
2331 iosize = un->un_iosize;
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;
2339 pwstart = un->un_column[column].un_pwstart;
2340 devstart = un->un_column[column].un_devstart;
2341 dev = un->un_column[column].un_dev;
2445 mr_unit_t *un = cs->cs_un;
2452 size_t count = un->un_segsize * DEV_BSIZE;
2496 RAID_FILLIN_RPW(cs->cs_dbuffer, un, dsum, cs->cs_pcolumn,
2498 un->un_totalcolumncnt, cs->cs_dcolumn, RAID_PWMAGIC);
2577 RAID_FILLIN_RPW(cbuf->cbuf_buffer, un, dsum, cs->cs_pcolumn,
2579 un->un_totalcolumncnt, col, RAID_PWMAGIC);
2588 bp->b_lblkno = (cbuf->cbuf_pwslot * un->un_iosize) +
2589 un->un_column[col].un_pwstart;
2594 bp->b_edev = md_dev64_to_dev(un->un_column[col].un_dev);
2600 RAID_FILLIN_RPW(cs->cs_pbuffer, un, psum, cs->cs_dcolumn,
2602 un->un_totalcolumncnt, cs->cs_pcolumn, RAID_PWMAGIC);
2615 mr_unit_t *un;
2621 un = cs->cs_un;
2640 if (cs->cs_loop != un->un_totalcolumncnt) {
2657 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2661 raid_read_io(mr_unit_t *un, md_raidcs_t *cs)
2671 column = &un->un_column[cs->cs_dcolumn];
2678 if (COLUMN_ISOKAY(un, cs->cs_dcolumn) ||
2679 (COLUMN_ISLASTERR(un, cs->cs_dcolumn) &&
2735 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2739 raid_read(mr_unit_t *un, md_raidcs_t *cs)
2746 ASSERT(IO_READER_HELD(un));
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;
2757 un->un_segsize * un->un_segsincolumn) {
2763 if (un->un_state & RUS_REGEN) {
2765 un = MD_UNIT(mnum);
2766 cs->cs_un = un;
2769 raid_read_io(un, cs);
2785 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2790 raid_write_err_retry(mr_unit_t *un, md_raidcs_t *cs)
2808 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2813 raid_write_no_retry(mr_unit_t *un, md_raidcs_t *cs)
2828 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
2832 raid_write_retry(mr_unit_t *un, md_raidcs_t *cs)
2887 raid_write_io(un, cs);
2903 mr_unit_t *un;
2909 un = (mr_unit_t *)md_unit_writerlock(ui);
2910 ASSERT(un != 0);
2913 (void) raid_error_state(un, &cs->cs_dbuf);
2915 (void) raid_error_state(un, &cs->cs_pbuf);
2917 (void) raid_error_state(un, &cs->cs_hbuf);
2920 (void) raid_error_state(un, &cbuf->cbuf_bp);
2926 un = (mr_unit_t *)md_unit_readerlock(ui);
2929 (*(cs->cs_retry_call))(un, cs);
2942 mr_unit_t *un;
2948 un = cs->cs_un;
2950 setno = MD_UN2SET(un);
2957 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_ERRED) &&
2958 (COLUMN_STATE(un, cs->cs_dcolumn) != RCS_LAST_ERRED))
2960 md_shortname(MD_SID(un)),
2964 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_ERRED) &&
2965 (COLUMN_STATE(un, cs->cs_pcolumn) != RCS_LAST_ERRED))
2967 md_shortname(MD_SID(un)),
2972 (COLUMN_STATE(un, cbuf->cbuf_column) != RCS_ERRED) &&
2973 (COLUMN_STATE(un, cbuf->cbuf_column) != RCS_LAST_ERRED))
2975 md_shortname(MD_SID(un)),
2999 mr_unit_t *un = cs->cs_un;
3011 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3027 mr_unit_t *un = cs->cs_un;
3047 if (cs->cs_loop != un->un_totalcolumncnt) {
3060 RAID_FILLIN_RPW(cs->cs_pbuffer, un, psum, -1,
3069 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3087 mr_unit_t *un = cs->cs_un;
3100 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3116 mr_unit_t *un = cs->cs_un;
3129 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3134 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3146 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
3152 raid_write_io(mr_unit_t *un, md_raidcs_t *cs)
3162 ASSERT((un->un_column[cs->cs_pcolumn].un_devstate &
3164 ASSERT((un->un_column[cs->cs_dcolumn].un_devstate &
3166 ASSERT(IO_READER_HELD(un));
3167 ASSERT(UNIT_READER_HELD(un));
3171 mr_unit_t *un = cs->cs_un;
3173 ASSERT(un->un_origcolumncnt == un->un_totalcolumncnt);
3175 cs->cs_frags = un->un_origcolumncnt;
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]);
3191 if ((un->un_column[cs->cs_pcolumn].un_devstate ==
3193 (un->un_column[cs->cs_dcolumn].un_devstate ==
3220 RAID_FILLIN_RPW(cs->cs_dbuffer, un, dsum, -1,
3228 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3299 * PARAMETERS: mr_unit_t *un - pointer to a unit structure
3305 raid_write(mr_unit_t *un, md_raidcs_t *cs)
3312 ASSERT(IO_READER_HELD(un));
3316 ASSERT(UNIT_STATE(un) != RUS_INIT);
3317 if (UNIT_STATE(un) == RUS_LAST_ERRED)
3321 if (cs->cs_blkno + cs->cs_blkcnt > un->un_segsize * un->un_segsincolumn)
3335 mutex_enter(&un->un_mx);
3336 un->un_rflags |= MD_RFLAG_NEEDPW;
3338 (void) cv_reltimedwait(&un->un_cv, &un->un_mx, md_wr_wait,
3340 un->un_rflags &= ~MD_RFLAG_NEEDPW;
3341 mutex_exit(&un->un_mx);
3347 un = (mr_unit_t *)md_unit_readerlock(ui);
3348 cs->cs_un = un;
3349 mnum = MD_SID(un);
3351 if (un->un_state & RUS_REGEN) {
3353 un = MD_UNIT(mnum);
3354 cs->cs_un = un;
3357 raid_write_io(un, cs);
3378 mr_unit_t *un = cs->cs_un;
3418 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3423 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3439 cs->cs_frags = un->un_origcolumncnt;
3455 un->un_column[cbuf->cbuf_column].un_devstart +
3462 un->un_column[cbuf->cbuf_column].un_dev);
3496 mr_unit_t *un;
3508 un = (mr_unit_t *)md_io_readerlock(ui);
3525 mnum = MD_SID(un);
3526 colcnt = un->un_totalcolumncnt - 1;
3537 err = md_checkbuf(ui, (md_unit_t *)un, pb); /* check and map */
3556 ps->ps_un = un;
3583 cs->cs_un = un;
3589 count = raid_iosetup(un, blkno, count, cs);
3604 (void) raid_write(un, cs);
3606 (void) raid_read(un, cs);
3610 (void) raid_write(un, cs);
3612 (void) raid_read(un, cs);
3633 mr_unit_t *un;
3686 un = big_un;
3693 un = (mr_unit_t *)mddb_getrecaddr(recid);
3695 un->c.un_revision &= ~MD_64BIT_META_DEV;
3700 un = (mr_unit_t *)mddb_getrecaddr(recid);
3701 un->c.un_revision |= MD_64BIT_META_DEV;
3702 un->c.un_flag |= MD_EFILABEL;
3705 MDDB_NOTE_FN(rbp->rb_revision, un->c.un_revision);
3710 (void) md_create_minor_node(MD_MIN2SET(MD_SID(un)), MD_SID(un));
3712 if (MD_UNIT(MD_SID(un)) != NULL) {
3717 if (raid_build_incore((void *)un, 1) == 0) {
3719 md_create_unit_incore(MD_SID(un), &raid_md_ops, 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));
3793 * PARAMETERS: mr_unit_t *un - pointer to unit structure
3797 raid_close_all_devs(mr_unit_t *un, int init_pw, int md_cflags)
3802 for (i = 0; i < un->un_totalcolumncnt; i++) {
3803 device = &un->un_column[i];
3808 (void) init_pw_area(un, device->un_dev,
3819 * PARAMETERS: mr_unit_t *un - pointer to unit structure
3823 raid_open_all_devs(mr_unit_t *un, int md_oflags)
3825 minor_t mnum = MD_SID(un);
3831 set_t setno = MD_MIN2SET(MD_SID(un));
3838 for (i = 0; i < un->un_totalcolumncnt; i++) {
3841 device = &un->un_column[i];
3843 if (COLUMN_STATE(un, i) & RCS_ERRED) {
3855 key = HOTSPARED(un, i) ?
3874 md_shortname(MD_SID(un)),
3875 md_devname(MD_UN2SET(un), device->un_orig_dev, NULL, 0));
3880 MD_UN2SET(un), MD_SID(un));
3885 for (i = 0; i < un->un_totalcolumncnt; i++) {
3886 device = &un->un_column[i];
3896 raid_set_state(un, i, RCS_OKAY, 0);
3906 raid_set_state(un, col, RCS_ERRED, 0);
3911 raid_commit(un, NULL);
3914 if (COLUMN_STATE(un, col) & RCS_ERRED) {
3916 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
3917 } else if (COLUMN_STATE(un, col) & RCS_LAST_ERRED) {
3919 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
3938 mr_unit_t *un;
3946 un = (mr_unit_t *)md_unit_openclose_enter(ui);
3951 if ((UNIT_STATE(un) & (RUS_INIT | RUS_DOI)) &&
3964 un = (mr_unit_t *)md_unit_writerlock(ui);
3965 if (raid_open_all_devs(un, md_oflags) == 0) {
3968 un = (mr_unit_t *)md_unit_readerlock(ui);
3969 raid_close_all_devs(un, 0, md_oflags);
3979 un = (mr_unit_t *)md_unit_readerlock(ui);
3980 raid_close_all_devs(un, 0, md_oflags);
3983 MD_UN2SET(un), MD_SID(un));
3987 if (!(MD_STATUS(un) & MD_UN_REPLAYED)) {
3988 replay_error = raid_replay(un);
3989 MD_STATUS(un) |= MD_UN_REPLAYED;
3993 un = (mr_unit_t *)md_unit_readerlock(ui);
4045 mr_unit_t *un;
4049 un = (mr_unit_t *)md_unit_openclose_enter(ui);
4056 raid_close_all_devs(un, init_pw, md_cflags);
4091 raid_probe_close_all_devs(mr_unit_t *un)
4096 for (i = 0; i < un->un_totalcolumncnt; i++) {
4097 device = &un->un_column[i];
4114 mr_unit_t *un;
4125 un = MD_UNIT(mnum);
4132 if (UNIT_STATE(un) == RUS_LAST_ERRED)
4137 for (i = 0; i < un->un_totalcolumncnt; i++) {
4140 device = &un->un_column[i];
4141 if (COLUMN_STATE(un, i) & RCS_ERRED) {
4154 tmpdev = md_resolve_bydevid(mnum, tmpdev, HOTSPARED(un, i)?
4189 md_shortname(MD_SID(un)),
4190 md_devname(MD_UN2SET(un), device->un_orig_dev, NULL, 0));
4192 MD_UN2SET(un), MD_SID(un));
4193 raid_probe_close_all_devs(un);
4199 for (i = 0; i < un->un_totalcolumncnt; i++) {
4200 device = &un->un_column[i];
4211 raid_set_state(un, i, RCS_OKAY, 0);
4225 raid_set_state(un, col, RCS_ERRED, 0);
4230 for (i = 0; i < un->un_totalcolumncnt; i++) {
4231 device = &un->un_column[i];
4234 if (un->un_state & RUS_LAST_ERRED)
4242 raid_set_state(un, col, RCS_ERRED, 0);
4249 raid_commit(un, NULL);
4252 if (COLUMN_STATE(un, col) & RCS_ERRED) {
4254 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
4255 } else if (COLUMN_STATE(un, col) & RCS_LAST_ERRED) {
4257 SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
4261 raid_probe_close_all_devs(un);