static int notify_fillin_empty_ioctl(void *data, void *ioctl_in, size_t sz, int mode) { int err; md_event_ioctl_t *ioctl = (md_event_ioctl_t *)data; ioctl->mdn_event = EQ_EMPTY; ioctl->mdn_tag = TAG_EMPTY; ioctl->mdn_set = MD_ALLSETS; ioctl->mdn_dev = MD_ALLDEVS; uniqtime32(&ioctl->mdn_time); ioctl->mdn_user = (u_longlong_t)0; err = ddi_copyout(data, ioctl_in, sz, mode); return (err); }
/* * NAME: resync_comp * * DESCRIPTION: Resync the component. Iterate through the raid unit a line at * a time, read from the good device(s) and write the resync * device. * * PARAMETERS: minor_t mnum - minor number identity of metadevice * md_raidcs_t *cs - child save struct * * RETURN: 0 - successfull * 1 - failed * -1 - aborted * * LOCKS: Expects Unit Reader Lock to be held across call. Acquires and * releases Line Reader Lock for per-line I/O. */ static void resync_comp( minor_t mnum, md_raidcs_t *cs ) { mdi_unit_t *ui; mr_unit_t *un; mddb_recid_t recids[2]; rcs_state_t state; md_dev64_t dev_to_write; diskaddr_t write_pwstart; diskaddr_t write_devstart; md_dev64_t dev; int resync; int i; int single_read = 0; int err; int err_cnt; int last_err; diskaddr_t line; diskaddr_t segsincolumn; size_t bsize; uint_t line_count; /* * hs_state is the state of the hotspare on the column being resynced * dev_state is the state of the resync target */ hs_cmds_t hs_state; int err_col = -1; diskaddr_t resync_end_pos; ui = MDI_UNIT(mnum); ASSERT(ui != NULL); un = cs->cs_un; md_unit_readerexit(ui); un = (mr_unit_t *)md_io_writerlock(ui); un = (mr_unit_t *)md_unit_writerlock(ui); resync = un->un_resync_index; state = un->un_column[resync].un_devstate; line_count = un->un_maxio / un->un_segsize; if (line_count == 0) { /* handle the case of segsize > maxio */ line_count = 1; bsize = un->un_maxio; } else bsize = line_count * un->un_segsize; un->un_resync_copysize = (uint_t)bsize; ASSERT(un->c.un_status & MD_UN_RESYNC_ACTIVE); ASSERT(un->un_column[resync].un_devflags & (MD_RAID_COPY_RESYNC | MD_RAID_REGEN_RESYNC)); /* * if the column is not in resync then just bail out. */ if (! (un->un_column[resync].un_devstate & RCS_RESYNC)) { md_unit_writerexit(ui); md_io_writerexit(ui); un = (mr_unit_t *)md_unit_readerlock(ui); return; } SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_START, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); /* identify device to write and its start block */ if (un->un_column[resync].un_alt_dev != NODEV64) { if (raid_open_alt(un, resync)) { raid_set_state(un, resync, state, 0); md_unit_writerexit(ui); md_io_writerexit(ui); un = (mr_unit_t *)md_unit_readerlock(ui); cmn_err(CE_WARN, "md: %s: %s open failed replace " "terminated", md_shortname(MD_SID(un)), md_devname(MD_UN2SET(un), un->un_column[resync].un_alt_dev, NULL, 0)); SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_FAILED, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); return; } ASSERT(un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC); dev_to_write = un->un_column[resync].un_alt_dev; write_devstart = un->un_column[resync].un_alt_devstart; write_pwstart = un->un_column[resync].un_alt_pwstart; if (un->un_column[resync].un_devflags & MD_RAID_DEV_ERRED) { single_read = 0; hs_state = HS_BAD; } else { hs_state = HS_FREE; single_read = 1; } un->un_column[resync].un_devflags |= MD_RAID_WRITE_ALT; } else { dev_to_write = un->un_column[resync].un_dev; write_devstart = un->un_column[resync].un_devstart; write_pwstart = un->un_column[resync].un_pwstart; single_read = 0; hs_state = HS_FREE; ASSERT(un->un_column[resync].un_devflags & MD_RAID_REGEN_RESYNC); } alloc_bufs(cs, dbtob(bsize)); /* initialize pre-write area */ if (init_pw_area(un, dev_to_write, write_pwstart, resync)) { un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT; if (un->un_column[resync].un_alt_dev != NODEV64) { raid_close_alt(un, resync); } md_unit_writerexit(ui); md_io_writerexit(ui); if (dev_to_write == un->un_column[resync].un_dev) hs_state = HS_BAD; err = RAID_RESYNC_WRERROR; goto resync_comp_error; } un->c.un_status &= ~MD_UN_RESYNC_CANCEL; segsincolumn = un->un_segsincolumn; err_cnt = raid_state_cnt(un, RCS_ERRED | RCS_LAST_ERRED); /* commit the record */ md_unit_writerexit(ui); md_io_writerexit(ui); /* resync each line of the unit */ for (line = 0; line < segsincolumn; line += line_count) { /* * Update address range in child struct and lock the line. * * The reader version of the line lock is used since only * resync will use data beyond un_resync_line_index on the * resync device. */ un = (mr_unit_t *)md_io_readerlock(ui); if (line + line_count > segsincolumn) line_count = segsincolumn - line; resync_end_pos = raid_resync_fillin_cs(line, line_count, cs); (void) md_unit_readerlock(ui); ASSERT(un->un_resync_line_index == resync_end_pos); err = raid_resync_region(cs, line, (int)line_count, &single_read, &hs_state, &err_col, dev_to_write, write_devstart); /* * if the column failed to resync then stop writing directly * to the column. */ if (err) un->un_resync_line_index = 0; md_unit_readerexit(ui); raid_line_exit(cs); md_io_readerexit(ui); if (err) break; un = (mr_unit_t *)md_unit_writerlock(ui); if (raid_state_cnt(un, RCS_ERRED | RCS_LAST_ERRED) != err_cnt) { err = RAID_RESYNC_STATE; md_unit_writerexit(ui); break; } md_unit_writerexit(ui); } /* for */ resync_comp_error: un = (mr_unit_t *)md_io_writerlock(ui); (void) md_unit_writerlock(ui); un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT; recids[0] = 0; recids[1] = 0; switch (err) { /* * successful resync */ case RAID_RESYNC_OKAY: /* initialize pre-write area */ if ((un->un_column[resync].un_orig_dev != NODEV64) && (un->un_column[resync].un_orig_dev == un->un_column[resync].un_alt_dev)) { /* * replacing a hot spare * release the hot spare, which will close the hotspare * and mark it closed. */ raid_hs_release(hs_state, un, &recids[0], resync); /* * make the resync target the main device and * mark open */ un->un_column[resync].un_hs_id = 0; un->un_column[resync].un_dev = un->un_column[resync].un_orig_dev; un->un_column[resync].un_devstart = un->un_column[resync].un_orig_devstart; un->un_column[resync].un_pwstart = un->un_column[resync].un_orig_pwstart; un->un_column[resync].un_devflags |= MD_RAID_DEV_ISOPEN; /* alt becomes the device so don't close it */ un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT; un->un_column[resync].un_devflags &= ~MD_RAID_ALT_ISOPEN; un->un_column[resync].un_alt_dev = NODEV64; } raid_set_state(un, resync, RCS_OKAY, 0); break; case RAID_RESYNC_WRERROR: if (HOTSPARED(un, resync) && single_read && (un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC)) { /* * this is the case where the resync target is * bad but there is a good hotspare. In this * case keep the hotspare, and go back to okay. */ raid_set_state(un, resync, RCS_OKAY, 0); cmn_err(CE_WARN, "md: %s: %s write error, replace " "terminated", md_shortname(MD_SID(un)), md_devname(MD_UN2SET(un), un->un_column[resync].un_orig_dev, NULL, 0)); break; } if (HOTSPARED(un, resync)) { raid_hs_release(hs_state, un, &recids[0], resync); un->un_column[resync].un_dev = un->un_column[resync].un_orig_dev; un->un_column[resync].un_devstart = un->un_column[resync].un_orig_devstart; un->un_column[resync].un_pwstart = un->un_column[resync].un_orig_pwstart; } raid_set_state(un, resync, RCS_ERRED, 0); if (un->un_column[resync].un_devflags & MD_RAID_REGEN_RESYNC) dev = un->un_column[resync].un_dev; else dev = un->un_column[resync].un_alt_dev; cmn_err(CE_WARN, "md: %s: %s write error replace terminated", md_shortname(MD_SID(un)), md_devname(MD_UN2SET(un), dev, NULL, 0)); break; case RAID_RESYNC_STATE: if (HOTSPARED(un, resync) && single_read && (un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC)) { /* * this is the case where the resync target is * bad but there is a good hotspare. In this * case keep the hotspare, and go back to okay. */ raid_set_state(un, resync, RCS_OKAY, 0); cmn_err(CE_WARN, "md: %s: needs maintenance, replace " "terminated", md_shortname(MD_SID(un))); break; } if (HOTSPARED(un, resync)) { raid_hs_release(hs_state, un, &recids[0], resync); un->un_column[resync].un_dev = un->un_column[resync].un_orig_dev; un->un_column[resync].un_devstart = un->un_column[resync].un_orig_devstart; un->un_column[resync].un_pwstart = un->un_column[resync].un_orig_pwstart; } break; case RAID_RESYNC_RDERROR: if (HOTSPARED(un, resync)) { raid_hs_release(hs_state, un, &recids[0], resync); un->un_column[resync].un_dev = un->un_column[resync].un_orig_dev; un->un_column[resync].un_devstart = un->un_column[resync].un_orig_devstart; un->un_column[resync].un_pwstart = un->un_column[resync].un_orig_pwstart; } if ((resync != err_col) && (err_col != NOCOLUMN)) raid_set_state(un, err_col, RCS_ERRED, 0); break; default: ASSERT(0); } if (un->un_column[resync].un_alt_dev != NODEV64) { raid_close_alt(un, resync); } /* * an io operation may have gotten an error and placed a * column in erred state. This will abort the resync, which * will end up in last erred. This is ugly so go through * the columns and do cleanup */ err_cnt = 0; last_err = 0; for (i = 0; i < un->un_totalcolumncnt; i++) { if (un->un_column[i].un_devstate & RCS_OKAY) continue; if (i == resync) { raid_set_state(un, i, RCS_ERRED, 1); err_cnt++; } else if (err == RAID_RESYNC_OKAY) { err_cnt++; } else { raid_set_state(un, i, RCS_LAST_ERRED, 1); last_err++; } } if ((err_cnt == 0) && (last_err == 0)) un->un_state = RUS_OKAY; else if (last_err == 0) { un->un_state = RUS_ERRED; ASSERT(err_cnt == 1); } else if (last_err > 0) { un->un_state = RUS_LAST_ERRED; } uniqtime32(&un->un_column[resync].un_devtimestamp); un->un_resync_copysize = 0; un->un_column[resync].un_devflags &= ~(MD_RAID_REGEN_RESYNC | MD_RAID_COPY_RESYNC); raid_commit(un, recids); /* release unit writer lock and acquire unit reader lock */ md_unit_writerexit(ui); md_io_writerexit(ui); (void) md_unit_readerlock(ui); if (err == RAID_RESYNC_OKAY) { SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_DONE, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); } else { SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_FAILED, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); if (raid_state_cnt(un, RCS_ERRED | RCS_LAST_ERRED) > 1) { SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); } else { SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED, SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un)); } } free_bufs(dbtob(bsize), cs); }
static void set_hot_spare_state(hot_spare_t *hs, hotspare_states_t newstate) { hs->hs_state = newstate; uniqtime32(&hs->hs_timestamp); }