Lines Matching refs:cs
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);
163 static void getpbuffer(md_raidcs_t *cs);
164 static void getdbuffer(md_raidcs_t *cs);
356 * md_raidcs_t *cs - child save structure
367 erred_check_line(mr_unit_t *un, md_raidcs_t *cs, mr_column_t *column)
371 ASSERT(cs->cs_flags & MD_RCS_LLOCKD);
401 if (cs->cs_line < un->un_resync_line_index) {
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);
500 raid_child_init(md_raidcs_t *cs)
502 bzero(cs, offsetof(md_raidcs_t, cs_mx));
504 md_bioreset(&cs->cs_dbuf);
505 md_bioreset(&cs->cs_pbuf);
506 md_bioreset(&cs->cs_hbuf);
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);
513 cs->cs_magic = RAID_CSMAGIC;
514 cs->cs_line = MD_DISKADDR_ERROR;
515 cs->cs_dpwslot = -1;
516 cs->cs_ppwslot = -1;
615 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
618 raid_cancel_pwslot(md_raidcs_t *cs)
620 mr_unit_t *un = cs->cs_un;
627 if (cs->cs_ps->ps_flags & MD_RPS_READ)
629 if (cs->cs_dpwslot != -1) {
630 col = &un->un_column_ic[cs->cs_dcolumn];
632 sb = &pw->pw_sb[cs->cs_dpwslot];
639 if (cs->cs_ppwslot != -1) {
640 col = &un->un_column_ic[cs->cs_pcolumn];
642 sb = &pw->pw_sb[cs->cs_ppwslot];
649 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
671 raid_free_pwinvalidate(md_raidcs_t *cs)
675 mr_unit_t *un = cs->cs_un;
681 cbuf = cs->cs_pw_inval_list;
697 cs->cs_pw_inval_list = (md_raidcbuf_t *)NULL;
718 raid_get_pwslot(md_raidcs_t *cs, int column)
722 mr_unit_t *un = cs->cs_un;
723 diskaddr_t start_blk = cs->cs_blkno;
724 diskaddr_t last_blk = cs->cs_lastblk;
733 pw = cs->cs_un->un_column_ic[column].un_pw_reserve;
781 sb[use].sb_cs = cs;
789 raid_check_pw(md_raidcs_t *cs)
792 mr_unit_t *un = cs->cs_un;
795 ASSERT(! (cs->cs_flags & MD_RCS_HAVE_PW_SLOTS));
800 if (cs->cs_flags & MD_RCS_LINE) {
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)
814 raid_alloc_pwslot(md_raidcs_t *cs)
816 mr_unit_t *un = cs->cs_un;
819 ASSERT(! (cs->cs_flags & MD_RCS_HAVE_PW_SLOTS));
820 if (raid_check_pw(cs))
825 cs->cs_pwid = un->un_pwid;
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);
832 cs->cs_ppwslot = raid_get_pwslot(cs, cs->cs_pcolumn);
834 cs->cs_flags |= MD_RCS_HAVE_PW_SLOTS;
1153 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1181 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1241 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1246 raid_free_child(md_raidcs_t *cs, int drop_locks)
1248 mr_unit_t *un = cs->cs_un;
1251 if (cs->cs_pw_inval_list)
1252 raid_free_pwinvalidate(cs);
1255 ASSERT(cs->cs_flags & MD_RCS_LLOCKD &&
1256 (cs->cs_flags & (MD_RCS_READER | MD_RCS_WRITER)));
1258 raid_line_exit(cs);
1260 ASSERT(!(cs->cs_flags & MD_RCS_LLOCKD));
1263 freebuffers(cs);
1264 cbuf = cs->cs_buflist;
1270 if (cs->cs_dbuf.b_flags & B_REMAPPED)
1271 bp_mapout(&cs->cs_dbuf);
1272 kmem_cache_free(raid_child_cache, cs);
1286 * PARAMETERS: md_raidcs_t *cs
1289 raid_regen_parity(md_raidcs_t *cs)
1291 mr_unit_t *un = cs->cs_un;
1299 int parity_column = cs->cs_pcolumn;
1310 ASSERT(cs->cs_flags & MD_RCS_LLOCKD);
1316 if (cs->cs_flags & MD_RCS_READER) {
1317 getpbuffer(cs);
1318 getdbuffer(cs);
1320 ASSERT(cs->cs_dbuffer && cs->cs_pbuffer);
1321 bcount = cs->cs_bcount;
1322 buffer = cs->cs_dbuffer;
1323 parity_buffer = cs->cs_pbuffer;
1325 bp = &cs->cs_dbuf;
1332 bp->b_lblkno = cs->cs_blkno + un->un_column[column].un_devstart;
1347 reset_buf(bp, B_WRITE | B_BUSY, cs->cs_bcount);
1350 bp->b_lblkno = cs->cs_blkno + un->un_column[parity_column].un_devstart;
1357 if (cs->cs_flags & MD_RCS_READER) {
1358 freebuffers(cs);
1359 cs->cs_pbuffer = NULL;
1360 cs->cs_dbuffer = NULL;
1362 bp->b_chain = (struct buf *)cs;
1365 if (cs->cs_flags & MD_RCS_READER) {
1366 freebuffers(cs);
1367 cs->cs_pbuffer = NULL;
1368 cs->cs_dbuffer = NULL;
1378 bp->b_chain = (struct buf *)cs;
1387 * md_raidcs_t *cs - pointer to child structure
1438 raid_mapin_buf(md_raidcs_t *cs)
1440 md_raidps_t *ps = cs->cs_ps;
1450 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1455 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1464 cs->cs_addr = ps->ps_addr + cs->cs_offset;
1475 * md_raidcs_t *cs - pointer to child structure
1479 raid_read_no_retry(mr_unit_t *un, md_raidcs_t *cs)
1481 md_raidps_t *ps = cs->cs_ps;
1484 raid_free_child(cs, 1);
1493 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1496 raid_read_retry(mr_unit_t *un, md_raidcs_t *cs)
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;
1506 sema_init(&cs->cs_dbuf.b_io, 0, NULL,
1508 sema_init(&cs->cs_dbuf.b_sem, 0, NULL,
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,
1519 sema_init(&cs->cs_pbuf.b_sem, 0, NULL,
1522 cs->cs_flags &= ~MD_RCS_ERROR; /* reset child error flag */
1523 cs->cs_flags |= MD_RCS_RECOVERY; /* set RECOVERY flag */
1531 raid_mapin_buf(cs);
1532 raid_read_io(un, cs);
1538 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1545 raid_rderr(md_raidcs_t *cs)
1552 ps = cs->cs_ps;
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);
1569 (*(cs->cs_retry_call))(un, cs);
1576 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1580 raid_read_error(md_raidcs_t *cs)
1587 ps = cs->cs_ps;
1589 un = cs->cs_un;
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))
1598 md_devname(setno, md_expldev(cs->cs_dbuf.b_edev), NULL, 0));
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))
1605 md_devname(setno, md_expldev(cs->cs_pbuf.b_edev), NULL, 0));
1609 ASSERT(cs->cs_frags == 0);
1613 (daemon_queue_t *)cs, REQ_OLD);
1620 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1627 getdbuffer(md_raidcs_t *cs)
1631 cs->cs_dbuffer = kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_NOSLEEP);
1632 if (cs->cs_dbuffer != NULL)
1634 un = cs->cs_ps->ps_un;
1641 cs->cs_dbuffer = un->un_dbuffer;
1642 cs->cs_flags |= MD_RCS_UNDBUF;
1650 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1657 getpbuffer(md_raidcs_t *cs)
1661 cs->cs_pbuffer = kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_NOSLEEP);
1662 if (cs->cs_pbuffer != NULL)
1664 un = cs->cs_ps->ps_un;
1671 cs->cs_pbuffer = un->un_pbuffer;
1672 cs->cs_flags |= MD_RCS_UNPBUF;
1677 getresources(md_raidcs_t *cs)
1685 getdbuffer(cs);
1686 getpbuffer(cs);
1687 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next)
1689 kmem_alloc(cs->cs_bcount + DEV_BSIZE, KM_SLEEP);
1694 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1697 freebuffers(md_raidcs_t *cs)
1703 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
1711 if (cs->cs_flags & (MD_RCS_UNDBUF | MD_RCS_UNPBUF)) {
1712 un = cs->cs_un;
1715 if (cs->cs_dbuffer) {
1716 if (cs->cs_flags & MD_RCS_UNDBUF)
1717 un->un_dbuffer = cs->cs_dbuffer;
1719 kmem_free(cs->cs_dbuffer, cs->cs_bcount + DEV_BSIZE);
1721 if (cs->cs_pbuffer) {
1722 if (cs->cs_flags & MD_RCS_UNPBUF)
1723 un->un_pbuffer = cs->cs_pbuffer;
1725 kmem_free(cs->cs_pbuffer, cs->cs_bcount + DEV_BSIZE);
1727 if (cs->cs_flags & (MD_RCS_UNDBUF | MD_RCS_UNPBUF)) {
1738 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
1742 raid_line_reader_lock(md_raidcs_t *cs, int resync_thread)
1747 ASSERT(cs->cs_line != MD_DISKADDR_ERROR);
1748 un = cs->cs_un;
1749 cs->cs_flags |= MD_RCS_READER;
1756 if (raid_io_overlaps(cs, cs1) == 1)
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;
1778 diskaddr_t lastblk = cs->cs_blkno + cs->cs_blkcnt - 1;
1790 raid_line_writer_lock(md_raidcs_t *cs, int lock)
1795 ASSERT(cs->cs_line != MD_DISKADDR_ERROR);
1796 cs->cs_flags |= MD_RCS_WRITER;
1797 un = cs->cs_ps->ps_un;
1806 if (raid_io_overlaps(cs, cs1))
1815 if (raid_alloc_pwslot(cs)) {
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;
1838 ASSERT(! (cs->cs_flags & MD_RCS_LLOCKD));
1839 if (!lock || (cs->cs_flags & MD_RCS_WAITING))
1841 cs->cs_flags |= MD_RCS_WAITING;
1842 cs->cs_un = un;
1843 raid_enqueue(cs);
1850 raid_startio(md_raidcs_t *cs)
1852 mdi_unit_t *ui = cs->cs_ps->ps_ui;
1853 mr_unit_t *un = cs->cs_un;
1856 raid_write_io(un, cs);
1932 raid_line_exit(md_raidcs_t *cs)
1936 un = cs->cs_ps->ps_un;
1939 if (cs->cs_flags & MD_RCS_READER)
1944 if (cs->cs_linlck_prev)
1945 cs->cs_linlck_prev->cs_linlck_next = cs->cs_linlck_next;
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;
1951 cs->cs_flags &= ~MD_RCS_LLOCKD;
1957 cs->cs_line = MD_DISKADDR_ERROR;
1959 raid_cancel_pwslot(cs);
2112 * md_raidcs_t *cs - child structure for each segmented I/O
2138 md_raidcs_t *cs
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;
2162 if ((cs->cs_ps->ps_flags & MD_RPS_WRITE) &&
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;
2186 cbufp = &cs->cs_buflist;
2188 j = cs->cs_dcolumn + i;
2191 if ((j == cs->cs_dcolumn) || (j == cs->cs_pcolumn))
2196 cbuf->cbuf_un = cs->cs_un;
2197 cbuf->cbuf_ps = cs->cs_ps;
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);
2234 md_raidcs_t *cs;
2238 cs = (md_raidcs_t *)bp->b_chain;
2240 ASSERT(cs != NULL);
2242 mutex_enter(&cs->cs_mx);
2244 cs->cs_flags |= MD_RCS_ERROR;
2245 cs->cs_flags &= ~(MD_RCS_ISCALL);
2248 flags = cs->cs_flags;
2249 frags = --cs->cs_frags;
2250 mutex_exit(&cs->cs_mx);
2256 if (cs->cs_error_call) {
2257 daemon_request(&md_done_daemon, cs->cs_error_call,
2258 (daemon_queue_t *)cs, REQ_OLD);
2264 cs->cs_flags &= ~(MD_RCS_ISCALL);
2265 (*(cs->cs_call))(cs);
2268 daemon_request(&md_done_daemon, cs->cs_call,
2269 (daemon_queue_t *)cs, REQ_OLD);
2291 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2294 raidio(md_raidcs_t *cs, int flags)
2306 un = cs->cs_un;
2313 bp = &cs->cs_hbuf;
2315 bp = &cs->cs_dbuf;
2316 bp->b_un.b_addr = cs->cs_dbuffer;
2317 column = cs->cs_dcolumn;
2320 bp = &cs->cs_hbuf;
2322 bp = &cs->cs_pbuf;
2323 bp->b_un.b_addr = cs->cs_pbuffer;
2324 column = cs->cs_pcolumn;
2329 bp->b_bcount = cs->cs_bcount;
2330 bp->b_bufsize = cs->cs_bcount;
2346 bp->b_lblkno = devstart + cs->cs_blkno;
2352 bp->b_lblkno = cs->cs_dpwslot * iosize + pwstart;
2354 bp->b_lblkno = cs->cs_ppwslot * iosize + pwstart;
2373 private = cs->cs_strategy_private;
2374 flag = cs->cs_strategy_flag;
2382 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2385 genstandardparity(md_raidcs_t *cs)
2392 ASSERT((cs->cs_bcount & 0x3) == 0);
2394 wordcnt = cs->cs_bcount / sizeof (uint_t);
2396 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
2397 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2400 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
2401 uint_t *uwbuf = (uint_t *)(void *)(cs->cs_addr);
2413 uchar_t *ubbuf = (uchar_t *)(cs->cs_addr);
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);
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);
2442 genlineparity(md_raidcs_t *cs)
2445 mr_unit_t *un = cs->cs_un;
2456 ASSERT((cs->cs_bcount & 0x3) == 0);
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);
2466 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
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);
2500 raidio(cs, RIO_PREWRITE | RIO_DATA);
2502 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next) {
2505 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
2513 if (((uintptr_t)cs->cs_addr & 0x3) == 0) {
2577 RAID_FILLIN_RPW(cbuf->cbuf_buffer, un, dsum, cs->cs_pcolumn,
2578 cs->cs_blkno, cs->cs_blkcnt, cs->cs_pwid,
2595 bp->b_chain = (struct buf *)cs;
2597 cs->cs_strategy_flag, cs->cs_strategy_private);
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);
2604 raidio(cs, RIO_PREWRITE | RIO_PARITY);
2610 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2613 raid_readregenloop(md_raidcs_t *cs)
2621 un = cs->cs_un;
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);
2634 cs->cs_loop++;
2637 if (cs->cs_loop == cs->cs_dcolumn)
2638 cs->cs_loop++;
2640 if (cs->cs_loop != un->un_totalcolumncnt) {
2641 cs->cs_frags = 1;
2642 raidio(cs, RIO_PARITY | RIO_READ | (cs->cs_loop + 1));
2646 ps = cs->cs_ps;
2647 bcopy(cs->cs_dbuffer + DEV_BSIZE, cs->cs_addr, cs->cs_bcount);
2648 raid_free_child(cs, 1);
2658 * md_raidcs_t *cs - pointer to a child structure
2661 raid_read_io(mr_unit_t *un, md_raidcs_t *cs)
2666 buf_t *pb = cs->cs_ps->ps_bp;
2669 flag = cs->cs_strategy_flag;
2670 private = cs->cs_strategy_private;
2671 column = &un->un_column[cs->cs_dcolumn];
2678 if (COLUMN_ISOKAY(un, cs->cs_dcolumn) ||
2679 (COLUMN_ISLASTERR(un, cs->cs_dcolumn) &&
2680 (cs->cs_flags & MD_RCS_RECOVERY) == 0)) {
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,
2689 bp->b_chain = (buf_t *)cs;
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;
2708 cs->cs_loop = 0;
2714 raid_mapin_buf(cs);
2715 getdbuffer(cs);
2716 getpbuffer(cs);
2717 if (cs->cs_loop == cs->cs_dcolumn)
2718 cs->cs_loop++;
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;
2729 raidio(cs, RIO_PARITY | RIO_READ | (cs->cs_loop + 1));
2736 * md_raidcs_t *cs - pointer to a child structure
2739 raid_read(mr_unit_t *un, md_raidcs_t *cs)
2747 ps = cs->cs_ps;
2749 raid_line_reader_lock(cs, 0);
2753 cs->cs_un = un;
2756 if (cs->cs_blkno + cs->cs_blkcnt >
2764 raid_regen_parity(cs);
2766 cs->cs_un = un;
2769 raid_read_io(un, cs);
2774 raid_free_child(cs, 1);
2786 * md_raidcs_t *cs - pointer to a child structure
2790 raid_write_err_retry(mr_unit_t *un, md_raidcs_t *cs)
2792 md_raidps_t *ps = cs->cs_ps;
2796 if (!(cs->cs_flags & MD_RCS_PWDONE))
2799 raid_free_child(cs, 1);
2809 * md_raidcs_t *cs - pointer to a child structure
2813 raid_write_no_retry(mr_unit_t *un, md_raidcs_t *cs)
2815 md_raidps_t *ps = cs->cs_ps;
2819 if (!(cs->cs_flags & MD_RCS_PWDONE))
2821 raid_free_child(cs, 1);
2829 * md_raidcs_t *cs - pointer to a child structure
2832 raid_write_retry(mr_unit_t *un, md_raidcs_t *cs)
2836 ps = cs->cs_ps;
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;
2846 sema_init(&cs->cs_dbuf.b_io, 0, NULL,
2848 sema_init(&cs->cs_dbuf.b_sem, 0, NULL,
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,
2859 sema_init(&cs->cs_pbuf.b_sem, 0, NULL,
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,
2870 sema_init(&cs->cs_hbuf.b_sem, 0, NULL,
2873 cs->cs_flags &= ~(MD_RCS_ERROR);
2882 if (cs->cs_flags & MD_RCS_PWDONE) {
2883 cs->cs_flags &= ~MD_RCS_PWDONE;
2887 raid_write_io(un, cs);
2893 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2899 raid_wrerr(md_raidcs_t *cs)
2906 ps = cs->cs_ps;
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)
2929 (*(cs->cs_retry_call))(un, cs);
2934 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
2938 raid_write_error(md_raidcs_t *cs)
2946 ps = cs->cs_ps;
2948 un = cs->cs_un;
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))
2961 md_devname(setno, md_expldev(cs->cs_dbuf.b_edev), NULL, 0));
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))
2968 md_devname(setno, md_expldev(cs->cs_pbuf.b_edev), NULL, 0));
2970 for (cbuf = cs->cs_buflist; cbuf; cbuf = cbuf->cbuf_next)
2981 ASSERT(cs->cs_frags == 0);
2985 (daemon_queue_t *)cs, REQ_OLD);
2993 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
2996 raid_write_ponly(md_raidcs_t *cs)
2999 mr_unit_t *un = cs->cs_un;
3001 ps = cs->cs_ps;
3003 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
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);
3015 raidio(cs, RIO_PARITY | RIO_WRITE);
3022 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3025 raid_write_ploop(md_raidcs_t *cs)
3027 mr_unit_t *un = cs->cs_un;
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);
3038 cs->cs_loop++;
3044 while (cs->cs_loop == cs->cs_dcolumn || cs->cs_loop == cs->cs_pcolumn)
3045 cs->cs_loop++;
3047 if (cs->cs_loop != un->un_totalcolumncnt) {
3048 cs->cs_frags = 1;
3049 raidio(cs, RIO_DATA | RIO_READ | (cs->cs_loop + 1));
3054 wordcnt = cs->cs_bcount / sizeof (uint_t);
3055 pbuf = (uint_t *)(void *)(cs->cs_pbuffer + DEV_BSIZE);
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);
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);
3073 raidio(cs, RIO_PARITY | RIO_PREWRITE);
3081 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3084 raid_write_donly(md_raidcs_t *cs)
3087 mr_unit_t *un = cs->cs_un;
3089 ps = cs->cs_ps;
3092 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
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);
3104 raidio(cs, RIO_DATA | RIO_WRITE);
3111 * PARAMETERS: md_raidcs_t *cs - pointer to a child structure
3114 raid_write_got_old(md_raidcs_t *cs)
3116 mr_unit_t *un = cs->cs_un;
3118 ASSERT(IO_READER_HELD(cs->cs_un));
3119 ASSERT(UNIT_READER_HELD(cs->cs_un));
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;
3129 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3130 cs->cs_frags++;
3131 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_DATA | RIO_PREWRITE);
3134 if (WRITE_ALT(un, cs->cs_pcolumn)) {
3135 cs->cs_frags++;
3136 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_PARITY | RIO_PREWRITE);
3138 ASSERT(cs->cs_frags < 4);
3139 raidio(cs, RIO_DATA | RIO_PREWRITE);
3140 raidio(cs, RIO_PARITY | RIO_PREWRITE);
3147 * md_raidcs_t *cs - pointer to a child structure
3152 raid_write_io(mr_unit_t *un, md_raidcs_t *cs)
3154 md_raidps_t *ps = cs->cs_ps;
3162 ASSERT((un->un_column[cs->cs_pcolumn].un_devstate &
3164 ASSERT((un->un_column[cs->cs_dcolumn].un_devstate &
3168 ASSERT(cs->cs_flags & MD_RCS_HAVE_PW_SLOTS);
3169 if (cs->cs_flags & MD_RCS_LINE) {
3171 mr_unit_t *un = cs->cs_un;
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);
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;
3191 if ((un->un_column[cs->cs_pcolumn].un_devstate ==
3193 (un->un_column[cs->cs_dcolumn].un_devstate ==
3197 ASSERT(!(cs->cs_flags & MD_RCS_PWDONE));
3198 raid_free_child(cs, 1);
3208 raid_mapin_buf(cs);
3209 wordcnt = cs->cs_bcount / sizeof (uint_t);
3211 dbuf = (uint_t *)(void *)(cs->cs_dbuffer + DEV_BSIZE);
3212 ubuf = (uint_t *)(void *)(cs->cs_addr);
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 |
3233 raidio(cs, RIO_DATA | RIO_PREWRITE);
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++;
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));
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;
3269 raidio(cs, RIO_DATA | RIO_READ);
3270 raidio(cs, RIO_PARITY | RIO_READ);
3274 raid_enqueue(md_raidcs_t *cs)
3276 mdi_unit_t *ui = cs->cs_ps->ps_ui;
3281 ASSERT(! (cs->cs_flags & MD_RCS_LLOCKD));
3283 ui->ui_io_lock->io_list_front = cs;
3284 ui->ui_io_lock->io_list_back = cs;
3287 cs1->cs_linlck_next = cs;
3288 ui->ui_io_lock->io_list_back = cs;
3292 cs->cs_linlck_next = NULL;
3300 * md_raidcs_t *cs - pointer to a child structure
3305 raid_write(mr_unit_t *un, md_raidcs_t *cs)
3313 ps = cs->cs_ps;
3321 if (cs->cs_blkno + cs->cs_blkcnt > un->un_segsize * un->un_segsincolumn)
3326 getresources(cs);
3334 while (raid_check_pw(cs)) {
3344 if (raid_line_writer_lock(cs, 1))
3348 cs->cs_un = un;
3352 raid_regen_parity(cs);
3354 cs->cs_un = un;
3357 raid_write_io(un, cs);
3362 raid_free_child(cs, 0);
3372 * PARAMETERS: md_raidcs_t *cs - pointer to child structure
3375 raid_stage(md_raidcs_t *cs)
3377 md_raidps_t *ps = cs->cs_ps;
3378 mr_unit_t *un = cs->cs_un;
3384 switch (cs->cs_stage) {
3386 raid_free_child(cs, 1);
3397 ASSERT(cs->cs_flags & MD_RCS_PWDONE);
3398 raid_free_child(cs, 1);
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 |
3423 if (WRITE_ALT(un, cs->cs_dcolumn)) {
3424 cs->cs_frags++;
3425 raidio(cs, RIO_ALT | RIO_EXTRA | RIO_DATA | RIO_WRITE);
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);
3436 ASSERT(cs->cs_frags == 0);
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) {
3456 cs->cs_blkno;
3463 bp->b_chain = (struct buf *)cs;
3464 private = cs->cs_strategy_private;
3465 flag = cs->cs_strategy_flag;
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);
3493 md_raidcs_t *cs;
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);
3594 blkno += cs->cs_blkcnt;
3595 offset += cs->cs_bcount;
3597 /* for each cs bump up the ps_pwfrags and ps_frags fields */
3604 (void) raid_write(un, cs);
3606 (void) raid_read(un, cs);
3610 (void) raid_write(un, cs);
3612 (void) raid_read(un, cs);