Lines Matching defs:disk
105 static int g_mirror_update_disk(struct g_mirror_disk *disk, u_int state);
109 static void g_mirror_sync_stop(struct g_mirror_disk *disk, int type);
153 g_mirror_get_diskname(struct g_mirror_disk *disk)
156 if (disk->d_consumer == NULL || disk->d_consumer->provider == NULL)
158 return (disk->d_name);
177 struct g_mirror_disk *disk;
184 disk = NULL;
187 disk = arg;
188 sc = disk->d_softc;
190 ep->e_disk = disk;
238 g_mirror_event_cancel(struct g_mirror_disk *disk)
243 sc = disk->d_softc;
250 if (ep->e_disk != disk)
270 struct g_mirror_disk *disk;
275 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
276 if (state == -1 || disk->d_state == state)
283 * Find a disk in mirror by its disk ID.
288 struct g_mirror_disk *disk;
292 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
293 if (disk->d_id == id)
294 return (disk);
386 g_mirror_connect_disk(struct g_mirror_disk *disk, struct g_provider *pp)
392 KASSERT(disk->d_consumer == NULL,
393 ("Disk already connected (device %s).", disk->d_softc->sc_name));
396 cp = g_new_consumer(disk->d_softc->sc_geom);
413 disk->d_consumer = cp;
414 disk->d_consumer->private = disk;
415 disk->d_consumer->index = 0;
417 G_MIRROR_DEBUG(2, "Disk %s connected.", g_mirror_get_diskname(disk));
436 * Initialize disk. This means allocate memory, create consumer, attach it
443 struct g_mirror_disk *disk;
446 disk = malloc(sizeof(*disk), M_MIRROR, M_NOWAIT | M_ZERO);
447 if (disk == NULL) {
451 disk->d_softc = sc;
452 error = g_mirror_connect_disk(disk, pp);
455 disk->d_id = md->md_did;
456 disk->d_state = G_MIRROR_DISK_STATE_NONE;
457 disk->d_priority = md->md_priority;
458 disk->d_flags = md->md_dflags;
459 error = g_getattr("GEOM::candelete", disk->d_consumer, &i);
461 disk->d_flags |= G_MIRROR_DISK_FLAG_CANDELETE;
463 disk->d_flags |= G_MIRROR_DISK_FLAG_HARDCODED;
464 disk->d_sync.ds_consumer = NULL;
465 disk->d_sync.ds_offset = md->md_sync_offset;
466 disk->d_sync.ds_offset_done = md->md_sync_offset;
467 disk->d_genid = md->md_genid;
468 disk->d_sync.ds_syncid = md->md_syncid;
471 return (disk);
475 if (disk != NULL)
476 free(disk, M_MIRROR);
481 g_mirror_destroy_disk(struct g_mirror_disk *disk)
486 sc = disk->d_softc;
489 LIST_REMOVE(disk, d_next);
490 g_mirror_event_cancel(disk);
491 if (sc->sc_hint == disk)
493 switch (disk->d_state) {
495 g_mirror_sync_stop(disk, 1);
501 g_mirror_disconnect_consumer(sc, disk->d_consumer);
503 free(disk, M_MIRROR);
506 KASSERT(0 == 1, ("Wrong disk state (%s, %s).",
507 g_mirror_get_diskname(disk),
508 g_mirror_disk_state2str(disk->d_state)));
515 struct g_mirror_disk *disk;
526 for (disk = LIST_FIRST(&sc->sc_disks); disk != NULL;
527 disk = LIST_FIRST(&sc->sc_disks)) {
528 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
529 g_mirror_update_metadata(disk);
530 g_mirror_destroy_disk(disk);
564 struct g_mirror_disk *disk;
568 disk = cp->private;
569 if (disk == NULL)
571 disk->d_softc->sc_bump_id |= G_MIRROR_BUMP_SYNCID;
572 g_mirror_event_send(disk, G_MIRROR_DISK_STATE_DISCONNECTED,
577 * Function should return the next active disk on the list.
578 * It is possible that it will be the same disk as given.
582 g_mirror_find_next(struct g_mirror_softc *sc, struct g_mirror_disk *disk)
586 for (dp = LIST_NEXT(disk, d_next); dp != disk;
601 struct g_mirror_disk *disk;
608 disk = sc->sc_hint;
609 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE) {
610 disk = g_mirror_find_next(sc, disk);
611 if (disk == NULL)
614 sc->sc_hint = g_mirror_find_next(sc, disk);
615 return (disk);
619 g_mirror_write_metadata(struct g_mirror_disk *disk,
629 sc = disk->d_softc;
632 cp = disk->d_consumer;
647 if ((disk->d_flags & G_MIRROR_DISK_FLAG_BROKEN) == 0) {
648 disk->d_flags |= G_MIRROR_DISK_FLAG_BROKEN;
651 g_mirror_get_diskname(disk), sc->sc_name, error);
655 g_mirror_get_diskname(disk), sc->sc_name, error);
660 g_mirror_event_send(disk,
669 g_mirror_clear_metadata(struct g_mirror_disk *disk)
674 sx_assert(&disk->d_softc->sc_lock, SX_LOCKED);
676 error = g_mirror_write_metadata(disk, NULL);
679 g_mirror_get_diskname(disk));
682 "Cannot clear metadata on disk %s (error=%d).",
683 g_mirror_get_diskname(disk), error);
689 g_mirror_fill_metadata(struct g_mirror_softc *sc, struct g_mirror_disk *disk,
705 if (disk == NULL) {
713 md->md_did = disk->d_id;
714 md->md_priority = disk->d_priority;
715 md->md_syncid = disk->d_sync.ds_syncid;
716 md->md_dflags = (disk->d_flags & G_MIRROR_DISK_FLAG_MASK);
717 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
718 md->md_sync_offset = disk->d_sync.ds_offset_done;
721 if ((disk->d_flags & G_MIRROR_DISK_FLAG_HARDCODED) != 0) {
723 disk->d_consumer->provider->name,
726 md->md_provsize = disk->d_consumer->provider->mediasize;
731 g_mirror_update_metadata(struct g_mirror_disk *disk)
738 sc = disk->d_softc;
742 g_mirror_fill_metadata(sc, disk, &md);
743 error = g_mirror_write_metadata(disk, &md);
746 g_mirror_get_diskname(disk));
749 "Cannot update metadata on disk %s (error=%d).",
750 g_mirror_get_diskname(disk), error);
757 struct g_mirror_disk *disk;
768 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
769 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
770 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
771 disk->d_sync.ds_syncid = sc->sc_syncid;
772 g_mirror_update_metadata(disk);
780 struct g_mirror_disk *disk;
791 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
792 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
793 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
794 disk->d_genid = sc->sc_genid;
795 g_mirror_update_metadata(disk);
803 struct g_mirror_disk *disk;
823 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
824 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
827 g_mirror_get_diskname(disk), sc->sc_name);
828 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
829 g_mirror_update_metadata(disk);
837 struct g_mirror_disk *disk;
846 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
847 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
850 g_mirror_get_diskname(disk), sc->sc_name);
851 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
852 g_mirror_update_metadata(disk);
873 struct g_mirror_disk *disk;
883 disk = bp->bio_from->private;
884 if (disk == NULL) {
912 if (disk != NULL) {
913 if ((disk->d_flags & G_MIRROR_DISK_FLAG_BROKEN) == 0) {
914 disk->d_flags |= G_MIRROR_DISK_FLAG_BROKEN;
927 g_mirror_event_send(disk,
1000 struct g_mirror_disk *disk;
1012 disk = LIST_FIRST(&sc->sc_disks);
1023 g_io_request(cbp, disk->d_consumer);
1025 g_mirror_get_diskname(disk));
1032 struct g_mirror_disk *disk;
1037 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1038 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
1054 cbp->bio_caller1 = disk;
1055 cbp->bio_to = disk->d_consumer->provider;
1060 disk = cbp->bio_caller1;
1062 cp = disk->d_consumer;
1066 g_io_request(cbp, disk->d_consumer);
1119 struct g_mirror_disk *disk;
1128 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1129 if (disk->d_state != G_MIRROR_DISK_STATE_SYNCHRONIZING)
1132 sbp = disk->d_sync.ds_bios[i];
1246 struct g_mirror_disk *disk;
1250 disk = bp->bio_from->private;
1251 if (disk == NULL) {
1281 cp = disk->d_consumer;
1302 g_mirror_event_send(disk,
1308 sync = &disk->d_sync;
1327 g_mirror_event_send(disk, G_MIRROR_DISK_STATE_ACTIVE,
1366 g_mirror_update_metadata(disk);
1380 struct g_mirror_disk *disk;
1384 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1385 if (disk->d_state == G_MIRROR_DISK_STATE_ACTIVE)
1388 if (disk == NULL) {
1404 cp = disk->d_consumer;
1418 struct g_mirror_disk *disk;
1422 disk = g_mirror_get_disk(sc);
1423 if (disk == NULL) {
1439 cp = disk->d_consumer;
1457 struct g_mirror_disk *disk, *dp;
1462 /* Find a disk with the smallest load. */
1463 disk = NULL;
1469 /* If disk head is precisely in position - highly prefer it. */
1473 /* If disk head is close to position - prefer it. */
1477 disk = dp;
1481 KASSERT(disk != NULL, ("NULL disk for %s.", sc->sc_name));
1492 cp = disk->d_consumer;
1501 disk->d_last_offset = bp->bio_offset + bp->bio_length;
1514 struct g_mirror_disk *disk;
1538 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1539 if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
1555 cbp->bio_caller1 = disk;
1556 cbp->bio_to = disk->d_consumer->provider;
1569 disk = cbp->bio_caller1;
1571 cp = disk->d_consumer;
1575 disk->d_consumer->index++;
1576 g_io_request(cbp, disk->d_consumer);
1606 struct g_mirror_disk *disk;
1631 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
1632 sync = &disk->d_sync;
1633 switch (disk->d_state) {
1644 (disk->d_flags & G_MIRROR_DISK_FLAG_CANDELETE) == 0)
1660 cp = disk->d_consumer;
1791 /* Update disk status. */
1792 G_MIRROR_DEBUG(3, "Running event for disk %s.",
1884 g_mirror_update_idle(struct g_mirror_softc *sc, struct g_mirror_disk *disk)
1891 if (!sc->sc_idle && (disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) == 0) {
1893 g_mirror_get_diskname(disk), sc->sc_name);
1894 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
1896 (disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) != 0) {
1898 g_mirror_get_diskname(disk), sc->sc_name);
1899 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
1904 g_mirror_sync_start(struct g_mirror_disk *disk)
1912 sc = disk->d_softc;
1915 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
1917 g_mirror_get_diskname(disk)));
1934 g_mirror_get_diskname(disk));
1936 disk->d_flags |= G_MIRROR_DISK_FLAG_DIRTY;
1937 KASSERT(disk->d_sync.ds_consumer == NULL,
1938 ("Sync consumer already exists (device=%s, disk=%s).",
1939 sc->sc_name, g_mirror_get_diskname(disk)));
1941 disk->d_sync.ds_consumer = cp;
1942 disk->d_sync.ds_consumer->private = disk;
1943 disk->d_sync.ds_consumer->index = 0;
1948 disk->d_sync.ds_bios = malloc(sizeof(struct bio *) * g_mirror_syncreqs,
1952 disk->d_sync.ds_bios[i] = bp;
1957 bp->bio_offset = disk->d_sync.ds_offset;
1959 disk->d_sync.ds_offset += bp->bio_length;
1961 bp->bio_from = disk->d_sync.ds_consumer;
1969 disk->d_sync.ds_inflight = g_mirror_syncreqs;
1975 bp = disk->d_sync.ds_bios[i];
1977 disk->d_sync.ds_consumer->index++;
1984 g_io_request(bp, disk->d_sync.ds_consumer);
1994 g_mirror_sync_stop(struct g_mirror_disk *disk, int type)
2000 sc = disk->d_softc;
2003 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2004 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2005 g_mirror_disk_state2str(disk->d_state)));
2006 if (disk->d_sync.ds_consumer == NULL)
2011 sc->sc_name, g_mirror_get_diskname(disk));
2014 sc->sc_name, g_mirror_get_diskname(disk));
2016 free(disk->d_sync.ds_bios, M_MIRROR);
2017 disk->d_sync.ds_bios = NULL;
2018 cp = disk->d_sync.ds_consumer;
2019 disk->d_sync.ds_consumer = NULL;
2020 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2032 struct g_mirror_disk *disk;
2048 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2049 if (disk->d_consumer && disk->d_consumer->provider) {
2050 dp = disk->d_consumer->provider;
2068 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2069 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
2070 g_mirror_sync_start(disk);
2077 struct g_mirror_disk *disk;
2098 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2099 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING)
2100 g_mirror_sync_stop(disk, 1);
2116 g_mirror_determine_state(struct g_mirror_disk *disk)
2121 sc = disk->d_softc;
2122 if (sc->sc_syncid == disk->d_sync.ds_syncid) {
2123 if ((disk->d_flags &
2130 (disk->d_flags &
2141 } else if (disk->d_sync.ds_syncid < sc->sc_syncid) {
2143 * Reset all synchronization data for this disk,
2147 disk->d_flags |= G_MIRROR_DISK_FLAG_SYNCHRONIZING;
2148 disk->d_sync.ds_offset = 0;
2149 disk->d_sync.ds_offset_done = 0;
2150 disk->d_sync.ds_syncid = sc->sc_syncid;
2152 (disk->d_flags & G_MIRROR_DISK_FLAG_FORCE_SYNC) != 0) {
2157 } else /* if (sc->sc_syncid < disk->d_sync.ds_syncid) */ {
2161 * and more fresh disk just arrive.
2164 * this disk and inform the user loudly.
2167 "disk (%s) arrives!! It will not be connected to the "
2169 g_mirror_get_diskname(disk));
2170 g_mirror_destroy_disk(disk);
2172 /* Return immediately, because disk was destroyed. */
2175 G_MIRROR_DEBUG(3, "State for %s disk: %s.",
2176 g_mirror_get_diskname(disk), g_mirror_disk_state2str(state));
2186 struct g_mirror_disk *disk;
2231 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2232 if ((disk->d_flags &
2255 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2256 if (disk->d_genid > genid)
2257 genid = disk->d_genid;
2263 LIST_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) {
2264 if (disk->d_genid < genid) {
2267 g_mirror_get_diskname(disk), sc->sc_name);
2268 g_mirror_destroy_disk(disk);
2276 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2277 if (disk->d_sync.ds_syncid > syncid)
2278 syncid = disk->d_sync.ds_syncid;
2289 * While here, find a disk with the biggest priority.
2293 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2294 if (disk->d_sync.ds_syncid != syncid)
2296 if ((disk->d_flags &
2301 if ((disk->d_flags & G_MIRROR_DISK_FLAG_DIRTY) != 0) {
2304 pdisk->d_priority < disk->d_priority) {
2305 pdisk = disk;
2317 G_MIRROR_DEBUG(1, "Using disk %s (device %s) as a "
2318 "master disk for synchronization.",
2320 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2321 if (disk->d_sync.ds_syncid != syncid)
2323 if ((disk->d_flags &
2327 KASSERT((disk->d_flags &
2330 g_mirror_get_diskname(disk)));
2331 /* Skip the disk with the biggest priority. */
2332 if (disk == pdisk)
2334 disk->d_sync.ds_syncid = 0;
2341 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2342 if (disk->d_sync.ds_syncid != syncid)
2344 if ((disk->d_flags &
2348 if ((disk->d_flags &
2352 disk->d_sync.ds_syncid = 0;
2368 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2369 state = g_mirror_determine_state(disk);
2370 g_mirror_event_send(disk, state,
2420 * Update disk state and device state if needed.
2424 g_mirror_get_diskname(disk), \
2425 g_mirror_disk_state2str(disk->d_state), \
2428 g_mirror_update_disk(struct g_mirror_disk *disk, u_int state)
2432 sc = disk->d_softc;
2436 G_MIRROR_DEBUG(3, "Changing disk %s state from %s to %s.",
2437 g_mirror_get_diskname(disk), g_mirror_disk_state2str(disk->d_state),
2443 * 1. New disk arrive.
2446 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NONE,
2447 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2448 g_mirror_disk_state2str(disk->d_state)));
2451 disk->d_state = state;
2453 LIST_INSERT_HEAD(&sc->sc_disks, disk, d_next);
2458 if (disk->d_priority >= dp->d_priority) {
2459 LIST_INSERT_BEFORE(dp, disk, d_next);
2467 LIST_INSERT_AFTER(dp, disk, d_next);
2470 sc->sc_name, g_mirror_get_diskname(disk));
2476 g_mirror_get_diskname(disk),
2477 g_mirror_disk_state2str(disk->d_state)));
2478 state = g_mirror_determine_state(disk);
2485 * 1. New disk does not need synchronization.
2491 g_mirror_get_diskname(disk),
2492 g_mirror_disk_state2str(disk->d_state)));
2494 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW ||
2495 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2496 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2497 g_mirror_disk_state2str(disk->d_state)));
2500 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
2501 disk->d_flags &= ~G_MIRROR_DISK_FLAG_SYNCHRONIZING;
2502 disk->d_flags &= ~G_MIRROR_DISK_FLAG_FORCE_SYNC;
2503 g_mirror_sync_stop(disk, 0);
2505 disk->d_state = state;
2506 disk->d_sync.ds_offset = 0;
2507 disk->d_sync.ds_offset_done = 0;
2508 g_mirror_update_idle(sc, disk);
2509 g_mirror_update_metadata(disk);
2511 sc->sc_name, g_mirror_get_diskname(disk));
2516 * 1. Stale disk was connected.
2519 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2520 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2521 g_mirror_disk_state2str(disk->d_state)));
2525 g_mirror_get_diskname(disk),
2526 g_mirror_disk_state2str(disk->d_state)));
2534 g_mirror_get_diskname(disk),
2535 g_mirror_disk_state2str(disk->d_state)));
2538 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2539 disk->d_state = state;
2540 g_mirror_update_metadata(disk);
2542 sc->sc_name, g_mirror_get_diskname(disk));
2550 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2551 ("Wrong disk state (%s, %s).", g_mirror_get_diskname(disk),
2552 g_mirror_disk_state2str(disk->d_state)));
2556 g_mirror_get_diskname(disk),
2557 g_mirror_disk_state2str(disk->d_state)));
2560 if (disk->d_state == G_MIRROR_DISK_STATE_NEW)
2561 disk->d_flags &= ~G_MIRROR_DISK_FLAG_DIRTY;
2562 disk->d_state = state;
2564 g_mirror_sync_start(disk);
2565 g_mirror_update_metadata(disk);
2571 * 1. Device wasn't running yet, but disk disappear.
2580 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_ACTIVE ||
2581 disk->d_state == G_MIRROR_DISK_STATE_STALE ||
2582 disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING,
2583 ("Wrong disk state (%s, %s).",
2584 g_mirror_get_diskname(disk),
2585 g_mirror_disk_state2str(disk->d_state)));
2588 KASSERT(disk->d_state == G_MIRROR_DISK_STATE_NEW,
2589 ("Wrong disk state (%s, %s).",
2590 g_mirror_get_diskname(disk),
2591 g_mirror_disk_state2str(disk->d_state)));
2593 * Reset bumping syncid if disk disappeared in STARTING
2603 g_mirror_get_diskname(disk),
2604 g_mirror_disk_state2str(disk->d_state)));
2609 sc->sc_name, g_mirror_get_diskname(disk));
2611 g_mirror_destroy_disk(disk);
2617 error = g_mirror_clear_metadata(disk);
2622 sc->sc_name, g_mirror_get_diskname(disk));
2624 g_mirror_destroy_disk(disk);
2626 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2627 g_mirror_update_metadata(disk);
2696 "Invalid '%s' field on disk %s (device %s), skipping.",
2702 "Invalid '%s' field on disk %s (device %s), skipping.",
2708 "Invalid '%s' field on disk %s (device %s), skipping.",
2714 "Invalid '%s' field on disk %s (device %s), skipping.",
2720 "Invalid size of disk %s (device %s), skipping.", pp->name,
2726 "Invalid '%s' field on disk %s (device %s), skipping.",
2732 "Invalid sector size of disk %s (device %s), skipping.",
2738 "Invalid device flags on disk %s (device %s), skipping.",
2744 "Invalid disk flags on disk %s (device %s), skipping.",
2755 struct g_mirror_disk *disk;
2759 G_MIRROR_DEBUG(2, "Adding disk %s.", pp->name);
2770 disk = g_mirror_init_disk(sc, pp, md, &error);
2771 if (disk == NULL)
2773 error = g_mirror_event_send(disk, G_MIRROR_DISK_STATE_NEW,
2780 g_mirror_update_metadata(disk);
2868 /* One disk is minimum. */
2944 struct g_mirror_disk *disk;
2964 LIST_FOREACH(disk, &sc->sc_disks, d_next) {
2965 if (disk->d_state ==
2967 g_mirror_sync_stop(disk, 1);
3082 G_MIRROR_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
3088 G_MIRROR_DEBUG(0, "Cannot add disk %s to %s (error=%d).",
3144 struct g_mirror_disk *disk;
3146 disk = cp->private;
3147 if (disk == NULL)
3151 sbuf_printf(sb, "%s<ID>%u</ID>\n", indent, (u_int)disk->d_id);
3152 if (disk->d_state == G_MIRROR_DISK_STATE_SYNCHRONIZING) {
3154 if (disk->d_sync.ds_offset == 0)
3158 (u_int)((disk->d_sync.ds_offset * 100) /
3162 if (disk->d_sync.ds_offset > 0) {
3165 (intmax_t)disk->d_sync.ds_offset);
3169 disk->d_sync.ds_syncid);
3171 disk->d_genid);
3173 if (disk->d_flags == 0)
3179 if ((disk->d_flags & (flag)) != 0) { \
3198 disk->d_priority);
3200 g_mirror_disk_state2str(disk->d_state));