Lines Matching defs:disk
113 static int g_mirror_update_disk(struct g_mirror_disk *disk, u_int state);
120 static void g_mirror_sync_reinit(const struct g_mirror_disk *disk,
122 static void g_mirror_sync_stop(struct g_mirror_disk *disk, int type);
166 g_mirror_get_diskname(struct g_mirror_disk *disk)
169 if (disk->d_consumer == NULL || disk->d_consumer->provider == NULL)
171 return (disk->d_name);
191 struct g_mirror_disk *disk;
196 disk = NULL;
199 disk = arg;
200 sc = disk->d_softc;
202 ep->e_disk = disk;
258 g_mirror_event_cancel(struct g_mirror_disk *disk)
263 sc = disk->d_softc;
270 if (ep->e_disk != disk)
290 struct g_mirror_disk *disk;
293 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
294 if (state == -1 || disk->d_state == state)
301 * Find a disk in mirror by its disk ID.
306 struct g_mirror_disk *disk;
310 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
311 if (disk->d_id == id)
312 return (disk);
404 g_mirror_connect_disk(struct g_mirror_disk *disk, struct g_provider *pp)
410 KASSERT(disk->d_consumer == NULL,
411 ("Disk already connected (device %s).", disk->d_softc->sc_name));
414 cp = g_new_consumer(disk->d_softc->sc_geom);
432 disk->d_consumer = cp;
433 disk->d_consumer->private = disk;
434 disk->d_consumer->index = 0;
436 G_MIRROR_DEBUG(2, "Disk %s connected.", g_mirror_get_diskname(disk));
455 * Initialize disk. This means allocate memory, create consumer, attach it
462 struct g_mirror_disk *disk;
465 disk = malloc(sizeof(*disk), M_MIRROR, M_NOWAIT | M_ZERO);
466 if (disk == NULL) {
470 disk->d_softc = sc;
471 error = g_mirror_connect_disk(disk, pp);
474 disk->d_id = md->md_did;
475 disk->d_state = G_MIRROR_DISK_STATE_NONE;
476 disk->d_priority = md->md_priority;
477 disk->d_flags = md->md_dflags;
478 error = g_getattr("GEOM::candelete", disk->d_consumer, &i);
480 disk->d_flags |= G_MIRROR_DISK_FLAG_CANDELETE;
481 error = g_getattr("GEOM::rotation_rate", disk->d_consumer,
482 &disk->d_rotation_rate);
484 disk->d_rotation_rate = DISK_RR_UNKNOWN;
486 disk->d_flags |= G_MIRROR_DISK_FLAG_HARDCODED;
487 disk->d_sync.ds_consumer = NULL;
488 disk->d_sync.ds_offset = md->md_sync_offset;
489 disk->d_sync.ds_offset_done = md->md_sync_offset;
490 disk->d_sync.ds_update_ts = time_uptime;
491 disk->d_genid = md->md_genid;
492 disk->d_sync.ds_syncid = md->md_syncid;
493 disk->d_init_ndisks = md->md_all;
494 disk->d_init_slice = md->md_slice;
495 disk->d_init_balance = md->md_balance;
496 disk->d_init_mediasize = md->md_mediasize;
499 return (disk);
503 if (disk != NULL)
504 free(disk, M_MIRROR);
509 g_mirror_destroy_disk(struct g_mirror_disk *disk)
514 sc = disk->d_softc;
518 LIST_REMOVE(disk, d_next);
520 g_mirror_event_cancel(disk);
521 if (sc->sc_hint == disk)
523 switch (disk->d_state) {
525 g_mirror_sync_stop(disk, 1);
531 g_mirror_disconnect_consumer(sc, disk->d_consumer);
533 free(disk, M_MIRROR);
536 KASSERT(0 == 1, ("Wrong disk state (%s, %s).",
537 g_mirror_get_diskname(disk),
538 g_mirror_disk_state2str(disk->d_state)));
567 struct g_mirror_disk *disk;
578 for (disk = LIST_FIRST(&sc->sc_disks); disk != NULL;
579 disk = LIST_FIRST(&sc->sc_disks)) {
580 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
581 g_mirror_update_metadata(disk);
582 g_mirror_destroy_disk(disk);
615 struct g_mirror_disk *disk;
619 disk = cp->private;
620 if (disk == NULL)
622 disk->d_softc->sc_bump_id |= G_MIRROR_BUMP_SYNCID;
623 g_mirror_event_send(disk, G_MIRROR_DISK_STATE_DISCONNECTED,
628 * Function should return the next active disk on the list.
629 * It is possible that it will be the same disk as given.
633 g_mirror_find_next(struct g_mirror_softc *sc, struct g_mirror_disk *disk)
637 for (dp = LIST_NEXT(disk, d_next); dp != disk;
652 struct g_mirror_disk *disk;
659 disk = sc->sc_hint;
660 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE) {
661 disk = g_mirror_find_next(sc, disk);
662 if (disk == NULL)
665 sc->sc_hint = g_mirror_find_next(sc, disk);
666 return (disk);
670 g_mirror_write_metadata(struct g_mirror_disk *disk,
680 sc = disk->d_softc;
683 cp = disk->d_consumer;
707 if ((disk->d_flags & G_MIRROR_DISK_FLAG_BROKEN) == 0) {
708 disk->d_flags |= G_MIRROR_DISK_FLAG_BROKEN;
711 g_mirror_get_diskname(disk), sc->sc_name, error);
715 g_mirror_get_diskname(disk), sc->sc_name, error);
720 g_mirror_event_send(disk,
729 g_mirror_clear_metadata(struct g_mirror_disk *disk)
734 sx_assert(&disk->d_softc->sc_lock, SX_LOCKED);
736 if (disk->d_softc->sc_type != G_MIRROR_TYPE_AUTOMATIC)
738 error = g_mirror_write_metadata(disk, NULL);
741 g_mirror_get_diskname(disk));
744 "Cannot clear metadata on disk %s (error=%d).",
745 g_mirror_get_diskname(disk), error);
751 g_mirror_fill_metadata(struct g_mirror_softc *sc, struct g_mirror_disk *disk,
767 if (disk == NULL) {
770 md->md_did = disk->d_id;
771 md->md_priority = disk->d_priority;
772 md->md_syncid = disk->d_sync.ds_syncid;
773 md->md_dflags = (disk->d_flags & G_MIRROR_DISK_FLAG_MASK);
774 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
775 md->md_sync_offset = disk->d_sync.ds_offset_done;
776 if ((disk->d_flags & G_MIRROR_DISK_FLAG_HARDCODED) != 0) {
778 disk->d_consumer->provider->name,
781 md->md_provsize = disk->d_consumer->provider->mediasize;
786 g_mirror_update_metadata(struct g_mirror_disk *disk)
793 sc = disk->d_softc;
799 g_mirror_fill_metadata(sc, disk, &md);
800 error = g_mirror_write_metadata(disk, &md);
803 g_mirror_get_diskname(disk));
806 "Cannot update metadata on disk %s (error=%d).",
807 g_mirror_get_diskname(disk), error);
814 struct g_mirror_disk *disk;
825 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
826 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
827 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
828 disk->d_sync.ds_syncid = sc->sc_syncid;
829 g_mirror_update_metadata(disk);
837 struct g_mirror_disk *disk;
848 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
849 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
850 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
851 disk->d_genid = sc->sc_genid;
852 g_mirror_update_metadata(disk);
860 struct g_mirror_disk *disk;
880 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
881 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
884 g_mirror_get_diskname(disk), sc->sc_name);
885 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
886 g_mirror_update_metadata(disk);
894 struct g_mirror_disk *disk;
903 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
904 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
907 g_mirror_get_diskname(disk), sc->sc_name);
908 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
909 g_mirror_update_metadata(disk);
928 struct g_mirror_disk *disk, struct bio *bp)
935 if ((disk->d_flags & G_MIRROR_DISK_FLAG_BROKEN) == 0) {
936 disk->d_flags |= G_MIRROR_DISK_FLAG_BROKEN;
952 g_mirror_event_send(disk, G_MIRROR_DISK_STATE_DISCONNECTED,
960 struct g_mirror_disk *disk;
971 disk = bp->bio_from->private;
972 if (disk == NULL) {
1023 if (disk != NULL)
1024 g_mirror_regular_request_error(sc, disk, bp);
1043 * If there is only one active disk we want to double-check that
1044 * it is, in fact, the disk that we already tried. This is
1046 * removal of the tried disk (likely because of the same error)
1047 * and the only remaining disk is still viable for a retry.
1050 disk != NULL &&
1051 disk->d_state == G_MIRROR_DISK_STATE_ACTIVE) {
1109 struct g_mirror_disk *disk;
1113 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1114 if (disk->d_flags & G_MIRROR_DISK_FLAG_CANDELETE)
1117 val = disk != NULL;
1125 struct g_mirror_disk *disk;
1137 disk = LIST_FIRST(&sc->sc_disks);
1148 g_io_request(cbp, disk->d_consumer);
1150 g_mirror_get_diskname(disk));
1157 struct g_mirror_disk *disk;
1162 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1164 rr = disk->d_rotation_rate;
1165 else if (rr != disk->d_rotation_rate) {
1231 struct g_mirror_disk *disk;
1240 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1241 if (disk->d_state != G_MIRROR_DISK_STATE_SYNCHRONIZING)
1244 sbp = disk->d_sync.ds_bios[i];
1344 g_mirror_sync_request_free(struct g_mirror_disk *disk, struct bio *bp)
1348 if (disk != NULL && disk->d_sync.ds_bios != NULL) {
1350 KASSERT(disk->d_sync.ds_bios[idx] == bp,
1351 ("unexpected sync BIO at %p:%d", disk, idx));
1352 disk->d_sync.ds_bios[idx] = NULL;
1362 * successfully, it is converted to a write and sent to the disk being
1369 struct g_mirror_disk *disk;
1378 disk = bp->bio_from->private;
1379 if (disk == NULL) {
1389 sync = &disk->d_sync;
1414 g_mirror_sync_request_free(disk, bp);
1415 g_mirror_event_send(disk,
1424 cp = disk->d_consumer;
1443 g_mirror_sync_request_free(disk, bp);
1445 g_mirror_event_send(disk,
1456 g_mirror_sync_request_free(disk, bp);
1464 g_mirror_event_send(disk, G_MIRROR_DISK_STATE_ACTIVE,
1470 g_mirror_sync_reinit(disk, bp, sync->ds_offset);
1497 g_mirror_update_metadata(disk);
1510 struct g_mirror_disk *disk;
1514 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1515 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE)
1518 if (disk == NULL) {
1534 cp = disk->d_consumer;
1548 struct g_mirror_disk *disk;
1552 disk = g_mirror_get_disk(sc);
1553 if (disk == NULL) {
1569 cp = disk->d_consumer;
1587 struct g_mirror_disk *disk, *dp;
1592 /* Find a disk with the smallest load. */
1593 disk = NULL;
1599 /* If disk head is precisely in position - highly prefer it. */
1603 /* If disk head is close to position - prefer it. */
1607 disk = dp;
1611 KASSERT(disk != NULL, ("NULL disk for %s.", sc->sc_name));
1622 cp = disk->d_consumer;
1631 disk->d_last_offset = bp->bio_offset + bp->bio_length;
1644 struct g_mirror_disk *disk;
1668 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1669 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
1684 cbp->bio_caller1 = disk;
1685 cbp->bio_to = disk->d_consumer->provider;
1698 disk = cbp->bio_caller1;
1700 cp = disk->d_consumer;
1704 disk->d_consumer->index++;
1705 g_io_request(cbp, disk->d_consumer);
1715 struct g_mirror_disk *disk;
1776 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1777 switch (disk->d_state) {
1781 if (bp->bio_offset >= disk->d_sync.ds_offset)
1788 (disk->d_flags & G_MIRROR_DISK_FLAG_CANDELETE) == 0)
1803 cp = disk->d_consumer;
1834 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1835 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
1850 cbp->bio_caller1 = disk;
1851 cbp->bio_to = disk->d_consumer->provider;
1858 disk = cbp->bio_caller1;
1860 cp = disk->d_consumer;
1967 /* Update disk status. */
1968 G_MIRROR_DEBUG(3, "Running event for disk %s.",
2075 g_mirror_update_idle(struct g_mirror_softc *sc, struct g_mirror_disk *disk)
2082 if (!sc->sc_idle && (disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) == 0) {
2084 g_mirror_get_diskname(disk), sc->sc_name);
2085 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
2087 (disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) != 0) {
2089 g_mirror_get_diskname(disk), sc->sc_name);
2090 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2095 g_mirror_sync_reinit(const struct g_mirror_disk *disk, struct bio *bp,
2108 bp->bio_from = disk->d_sync.ds_consumer;
2109 bp->bio_to = disk->d_softc->sc_provider;
2113 disk->d_softc->sc_mediasize - bp->bio_offset);
2117 g_mirror_sync_start(struct g_mirror_disk *disk)
2126 sc = disk->d_softc;
2127 sync = &disk->d_sync;
2130 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2132 g_mirror_get_diskname(disk)));
2150 g_mirror_get_diskname(disk));
2152 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
2154 ("Sync consumer already exists (device=%s, disk=%s).",
2155 sc->sc_name, g_mirror_get_diskname(disk)));
2158 sync->ds_consumer->private = disk;
2172 g_mirror_sync_reinit(disk, bp, sync->ds_offset);
2204 g_mirror_sync_stop(struct g_mirror_disk *disk, int type)
2210 sc = disk->d_softc;
2213 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2214 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2215 g_mirror_disk_state2str(disk->d_state)));
2216 if (disk->d_sync.ds_consumer == NULL)
2221 sc->sc_name, g_mirror_get_diskname(disk));
2224 sc->sc_name, g_mirror_get_diskname(disk));
2227 free(disk->d_sync.ds_bios, M_MIRROR);
2228 disk->d_sync.ds_bios = NULL;
2229 cp = disk->d_sync.ds_consumer;
2230 disk->d_sync.ds_consumer = NULL;
2231 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2243 struct g_mirror_disk *disk;
2260 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2261 if (disk->d_consumer && disk->d_consumer->provider) {
2262 dp = disk->d_consumer->provider;
2282 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2283 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
2284 g_mirror_sync_start(disk);
2291 struct g_mirror_disk *disk;
2298 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2299 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
2300 g_mirror_sync_stop(disk, 1);
2354 g_mirror_determine_state(struct g_mirror_disk *disk)
2359 sc = disk->d_softc;
2360 if (sc->sc_syncid == disk->d_sync.ds_syncid) {
2361 if ((disk->d_flags &
2364 (disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) == 0)) {
2370 (disk->d_flags &
2381 } else if (disk->d_sync.ds_syncid < sc->sc_syncid) {
2383 * Reset all synchronization data for this disk,
2387 disk->d_flags |= G_MIRROR_DISK_FLAG_SYNCHRONIZING;
2388 disk->d_sync.ds_offset = 0;
2389 disk->d_sync.ds_offset_done = 0;
2390 disk->d_sync.ds_syncid = sc->sc_syncid;
2392 (disk->d_flags & G_MIRROR_DISK_FLAG_FORCE_SYNC) != 0) {
2397 } else /* if (sc->sc_syncid < disk->d_sync.ds_syncid) */ {
2401 * and more fresh disk just arrive.
2404 * this disk and inform the user loudly.
2407 "disk (%s) arrives!! It will not be connected to the "
2409 g_mirror_get_diskname(disk));
2410 g_mirror_destroy_disk(disk);
2412 /* Return immediately, because disk was destroyed. */
2415 G_MIRROR_DEBUG(3, "State for %s disk: %s.",
2416 g_mirror_get_diskname(disk), g_mirror_disk_state2str(state));
2426 struct g_mirror_disk *disk;
2440 LIST_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) {
2444 KASSERT(sc->sc_genid >= disk->d_genid,
2446 disk->d_genid, sc, sc->sc_genid));
2449 if (disk->d_genid < sc->sc_genid) {
2452 g_mirror_get_diskname(disk), sc->sc_name,
2453 disk->d_genid, sc->sc_genid);
2454 g_mirror_destroy_disk(disk);
2462 KASSERT(sc->sc_syncid >= disk->d_sync.ds_syncid,
2464 __func__, disk->d_sync.ds_syncid, sc,
2469 disk->d_init_ ## field != sc->sc_ ## field) { \
2471 found = (intmax_t)disk->d_init_ ## field; \
2484 g_mirror_get_diskname(disk), sc->sc_name,
2486 g_mirror_destroy_disk(disk);
2529 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2530 if ((disk->d_flags &
2557 * While here, find a disk with the biggest priority.
2561 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2562 if (disk->d_sync.ds_syncid != sc->sc_syncid)
2564 if ((disk->d_flags &
2569 if ((disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) != 0) {
2572 pdisk->d_priority < disk->d_priority) {
2573 pdisk = disk;
2585 G_MIRROR_DEBUG(1, "Using disk %s (device %s) as a "
2586 "master disk for synchronization.",
2588 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2589 if (disk->d_sync.ds_syncid != sc->sc_syncid)
2591 if ((disk->d_flags &
2595 KASSERT((disk->d_flags &
2598 g_mirror_get_diskname(disk)));
2599 /* Skip the disk with the biggest priority. */
2600 if (disk == pdisk)
2602 disk->d_sync.ds_syncid = 0;
2609 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2610 if (disk->d_sync.ds_syncid != sc->sc_syncid)
2612 if ((disk->d_flags &
2616 if ((disk->d_flags &
2620 disk->d_sync.ds_syncid = 0;
2635 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2636 state = g_mirror_determine_state(disk);
2637 g_mirror_event_send(disk, state,
2688 * Update disk state and device state if needed.
2692 g_mirror_get_diskname(disk), \
2693 g_mirror_disk_state2str(disk->d_state), \
2696 g_mirror_update_disk(struct g_mirror_disk *disk, u_int state)
2700 sc = disk->d_softc;
2704 G_MIRROR_DEBUG(3, "Changing disk %s state from %s to %s.",
2705 g_mirror_get_diskname(disk), g_mirror_disk_state2str(disk->d_state),
2711 * 1. New disk arrive.
2714 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NONE,
2715 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2716 g_mirror_disk_state2str(disk->d_state)));
2719 disk->d_state = state;
2722 LIST_INSERT_HEAD(&sc->sc_disks, disk, d_next);
2727 if (disk->d_priority >= dp->d_priority) {
2728 LIST_INSERT_BEFORE(dp, disk, d_next);
2736 LIST_INSERT_AFTER(dp, disk, d_next);
2740 sc->sc_name, g_mirror_get_diskname(disk));
2746 g_mirror_get_diskname(disk),
2747 g_mirror_disk_state2str(disk->d_state)));
2748 state = g_mirror_determine_state(disk);
2755 * 1. New disk does not need synchronization.
2761 g_mirror_get_diskname(disk),
2762 g_mirror_disk_state2str(disk->d_state)));
2764 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW ||
2765 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2766 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2767 g_mirror_disk_state2str(disk->d_state)));
2770 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
2771 disk->d_flags &= ~G_MIRROR_DISK_FLAG_SYNCHRONIZING;
2772 disk->d_flags &= ~G_MIRROR_DISK_FLAG_FORCE_SYNC;
2773 g_mirror_sync_stop(disk, 0);
2775 disk->d_state = state;
2776 disk->d_sync.ds_offset = 0;
2777 disk->d_sync.ds_offset_done = 0;
2778 g_mirror_update_idle(sc, disk);
2779 g_mirror_update_metadata(disk);
2781 sc->sc_name, g_mirror_get_diskname(disk));
2786 * 1. Stale disk was connected.
2789 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2790 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2791 g_mirror_disk_state2str(disk->d_state)));
2795 g_mirror_get_diskname(disk),
2796 g_mirror_disk_state2str(disk->d_state)));
2804 g_mirror_get_diskname(disk),
2805 g_mirror_disk_state2str(disk->d_state)));
2808 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2809 disk->d_state = state;
2810 g_mirror_update_metadata(disk);
2812 sc->sc_name, g_mirror_get_diskname(disk));
2820 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2821 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2822 g_mirror_disk_state2str(disk->d_state)));
2826 g_mirror_get_diskname(disk),
2827 g_mirror_disk_state2str(disk->d_state)));
2830 if (disk->d_state == G_MIRROR_DISK_STATE_NEW)
2831 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2832 disk->d_state = state;
2834 g_mirror_sync_start(disk);
2835 g_mirror_update_metadata(disk);
2841 * 1. Device wasn't running yet, but disk disappear.
2850 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
2851 disk->d_state == G_MIRROR_DISK_STATE_STALE ||
2852 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2853 ("Wrong disk state (%s, %s).",
2854 g_mirror_get_diskname(disk),
2855 g_mirror_disk_state2str(disk->d_state)));
2858 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2859 ("Wrong disk state (%s, %s).",
2860 g_mirror_get_diskname(disk),
2861 g_mirror_disk_state2str(disk->d_state)));
2863 * Reset bumping syncid if disk disappeared in STARTING
2873 g_mirror_get_diskname(disk),
2874 g_mirror_disk_state2str(disk->d_state)));
2879 sc->sc_name, g_mirror_get_diskname(disk));
2881 g_mirror_destroy_disk(disk);
2887 error = g_mirror_clear_metadata(disk);
2891 sc->sc_name, g_mirror_get_diskname(disk), error);
2896 sc->sc_name, g_mirror_get_diskname(disk));
2898 g_mirror_destroy_disk(disk);
2900 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2901 g_mirror_update_metadata(disk);
2963 G_MIRROR_DEBUG(2, "%s: md_did 0x%u disk %s device %s md_all 0x%x "
2983 "Invalid size of disk %s (device %s), skipping.", pp->name,
2989 "Invalid '%s' field on disk %s (device %s), skipping.",
2995 "Invalid sector size of disk %s (device %s), skipping.",
3001 "Invalid device flags on disk %s (device %s), skipping.",
3007 "Invalid disk flags on disk %s (device %s), skipping.",
3018 struct g_mirror_disk *disk;
3022 G_MIRROR_DEBUG(2, "Adding disk %s.", pp->name);
3035 * If the component disk we're tasting has newer metadata than the
3042 disk = g_mirror_init_disk(sc, pp, md, &error);
3043 if (disk == NULL)
3045 error = g_mirror_event_send(disk, G_MIRROR_DISK_STATE_NEW,
3052 g_mirror_update_metadata(disk);
3146 /* One disk is minimum. */
3222 struct g_mirror_disk *disk;
3238 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
3239 if (disk->d_state ==
3241 g_mirror_sync_stop(disk, 1);
3355 G_MIRROR_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
3362 G_MIRROR_DEBUG(0, "Cannot add disk %s to %s (error=%d).",
3385 struct g_mirror_disk *disk;
3390 disk = cp->private;
3391 if (disk == NULL)
3394 g_mirror_update_metadata(disk);
3433 struct g_mirror_disk *disk;
3435 disk = cp->private;
3436 if (disk == NULL)
3438 sbuf_printf(sb, "%s<ID>%u</ID>\n", indent, (u_int)disk->d_id);
3439 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
3441 if (disk->d_sync.ds_offset == 0)
3445 (u_int)((disk->d_sync.ds_offset * 100) /
3448 if (disk->d_sync.ds_offset > 0)
3451 (intmax_t)disk->d_sync.ds_offset);
3454 disk->d_sync.ds_syncid);
3456 disk->d_genid);
3458 if (disk->d_flags == 0)
3464 if ((disk->d_flags & (flag)) != 0) { \
3483 disk->d_priority);
3485 g_mirror_disk_state2str(disk->d_state));
3629 G_MIRROR_DEBUG(1, "Refresh device %s (id=%u, state=%s) from disk %s "