common/zfs-retire/zfs_retire.c

	zfs_retire.c revision 99653d4ee642c6528e88224f12409a5f23060994
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * The ZFS retire agent is responsible for managing hot spares across all pools.
 * When we see a device fault, we try to open the associated pool and look for
 * any hot spares.  We iterate over any available hot spares and attempt a
 * 'zpool replace' for each one.
 */

#include <fm/fmd_api.h>
#include <sys/fs/zfs.h>
#include <sys/fm/protocol.h>
#include <sys/fm/fs/zfs.h>
#include <libzfs.h>

/*
 * Find a pool with a matching GUID.
 */
typedef struct find_cbdata {
    uint64_t    cb_guid;
    zpool_handle_t  *cb_zhp;
} find_cbdata_t;

static int
find_pool(zpool_handle_t *zhp, void *data)
{
    find_cbdata_t *cbp = data;

    if (cbp->cb_guid == zpool_get_guid(zhp)) {
        cbp->cb_zhp = zhp;
        return (1);
    }

    zpool_close(zhp);
    return (0);
}

/*
 * Find a vdev within a tree with a matching GUID.
 */
static nvlist_t *
find_vdev(nvlist_t *nv, uint64_t search)
{
    uint64_t guid;
    nvlist_t **child;
    uint_t c, children;
    nvlist_t *ret;

    if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 &&
        guid == search)
        return (nv);

    if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
        &child, &children) != 0)
        return (NULL);

    for (c = 0; c < children; c++) {
        if ((ret = find_vdev(child[c], search)) != NULL)
            return (ret);
    }

    return (NULL);
}

/*ARGSUSED*/
static void
zfs_retire_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl,
    const char *class)
{
    uint64_t pool_guid, vdev_guid;
    char *dev_name;
    zpool_handle_t *zhp;
    nvlist_t *resource, *config, *nvroot;
    nvlist_t *vdev;
    nvlist_t **spares, **faults;
    uint_t s, nspares, f, nfaults;
    nvlist_t *replacement;
    find_cbdata_t cb;
    libzfs_handle_t *zhdl = fmd_hdl_getspecific(hdl);

    /*
     * Get information from the fault.
     */
    if (nvlist_lookup_nvlist_array(nvl, FM_SUSPECT_FAULT_LIST,
        &faults, &nfaults) != 0)
        return;

    for (f = 0; f < nfaults; f++) {
        if (nvlist_lookup_nvlist(faults[f], FM_FAULT_RESOURCE,
            &resource) != 0 ||
            nvlist_lookup_uint64(resource, FM_FMRI_ZFS_POOL,
            &pool_guid) != 0 ||
            nvlist_lookup_uint64(resource, FM_FMRI_ZFS_VDEV,
            &vdev_guid) != 0)
            continue;

        /*
         * From the pool guid and vdev guid, get the pool name and
         * device name.
         */
        cb.cb_guid = pool_guid;
        if (zpool_iter(zhdl, find_pool, &cb) != 1)
            continue;

        zhp = cb.cb_zhp;
        config = zpool_get_config(zhp, NULL);
        if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
            &nvroot) != 0) {
            zpool_close(zhp);
            continue;
        }

        if ((vdev = find_vdev(nvroot, vdev_guid)) == NULL) {
            zpool_close(zhp);
            continue;
        }

        /*
         * Find out if there are any hot spares available in the pool.
         */
        if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
            &spares, &nspares) != 0) {
            zpool_close(zhp);
            continue;
        }

        if (nvlist_alloc(&replacement, NV_UNIQUE_NAME, 0) != 0) {
            zpool_close(zhp);
            continue;
        }

        if (nvlist_add_string(replacement, ZPOOL_CONFIG_TYPE,
            VDEV_TYPE_ROOT) != 0) {
            nvlist_free(replacement);
            zpool_close(zhp);
            continue;
        }

        dev_name = zpool_vdev_name(zhdl, zhp, vdev);

        /*
         * Try to replace each spare, ending when we successfully
         * replace it.
         */
        for (s = 0; s < nspares; s++) {
            char *spare_name;

            if (nvlist_lookup_string(spares[s], ZPOOL_CONFIG_PATH,
                &spare_name) != 0)
                continue;

            if (nvlist_add_nvlist_array(replacement,
                ZPOOL_CONFIG_CHILDREN, &spares[s], 1) != 0)
                continue;

            if (zpool_vdev_attach(zhp, dev_name, spare_name,
                replacement, B_TRUE) == 0)
                break;
        }

        free(dev_name);
        nvlist_free(replacement);
        zpool_close(zhp);
    }
}

static const fmd_hdl_ops_t fmd_ops = {
    zfs_retire_recv,    /* fmdo_recv */
    NULL,           /* fmdo_timeout */
    NULL,           /* fmdo_close */
    NULL,           /* fmdo_stats */
    NULL,           /* fmdo_gc */
};

static const fmd_prop_t fmd_props[] = {
    { NULL, 0, NULL }
};

static const fmd_hdl_info_t fmd_info = {
    "ZFS Retire Agent", "1.0", &fmd_ops, fmd_props
};

void
_fmd_init(fmd_hdl_t *hdl)
{
    libzfs_handle_t *zhdl;

    if ((zhdl = libzfs_init()) == NULL)
        return;

    if (fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info) != 0) {
        libzfs_fini(zhdl);
        return;
    }

    fmd_hdl_setspecific(hdl, zhdl);
}

void
_fmd_fini(fmd_hdl_t *hdl)
{
    libzfs_handle_t *zhdl = fmd_hdl_getspecific(hdl);

    if (zhdl != NULL)
        libzfs_fini(zhdl);
}