libmeta/common/meta_notify.c

	meta_notify.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 1995-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * Just in case we're not in a build environment, make sure that
 * TEXT_DOMAIN gets set to something.
 */
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

/*
 * libmeta wrappers for event notification
 */

#include <meta.h>
#include <sys/lvm/md_notify.h>

#if defined(DEBUG)
#include <assert.h>
#endif /* DEBUG */

struct tag2obj_type {
    md_tags_t   tag;
    ev_obj_t    obj;
} tag2obj_typetab[] =
{
    { TAG_EMPTY,        EVO_EMPTY   },
    { TAG_METADEVICE,   EVO_METADEV },
    { TAG_REPLICA,      EVO_REPLICA },
    { TAG_HSP,      EVO_HSP     },
    { TAG_HS,       EVO_HS      },
    { TAG_SET,      EVO_SET     },
    { TAG_DRIVE,        EVO_DRIVE   },
    { TAG_HOST,     EVO_HOST    },
    { TAG_MEDIATOR,     EVO_MEDIATOR    },
    { TAG_UNK,      EVO_UNSPECIFIED },

    { TAG_LAST,     EVO_LAST    }
};

struct evdrv2evlib_type {
    md_event_type_t drv;
    evid_t      lib;
} evdrv2evlib_typetab[] =
{
    { EQ_EMPTY,     EV_EMPTY        },
    { EQ_CREATE,        EV_CREATE       },
    { EQ_DELETE,        EV_DELETE       },
    { EQ_ADD,       EV_ADD          },
    { EQ_REMOVE,        EV_REMOVE       },
    { EQ_REPLACE,       EV_REPLACE      },
    { EQ_MEDIATOR_ADD,  EV_MEDIATOR_ADD     },
    { EQ_MEDIATOR_DELETE,   EV_MEDIATOR_DELETE  },
    { EQ_HOST_ADD,      EV_HOST_ADD     },
    { EQ_HOST_DELETE,   EV_HOST_DELETE      },
    { EQ_DRIVE_ADD,     EV_DRIVE_ADD        },
    { EQ_DRIVE_DELETE,  EV_DRIVE_DELETE     },
    { EQ_RENAME_SRC,    EV_RENAME_SRC       },
    { EQ_RENAME_DST,    EV_RENAME_DST       },
    { EQ_INIT_START,    EV_INIT_START       },
    { EQ_INIT_FAILED,   EV_INIT_FAILED      },
    { EQ_INIT_FATAL,    EV_INIT_FATAL       },
    { EQ_INIT_SUCCESS,  EV_INIT_SUCCESS     },
    { EQ_IOERR,     EV_IOERR        },
    { EQ_ERRED,     EV_ERRED        },
    { EQ_LASTERRED,     EV_LASTERRED        },
    { EQ_OK,        EV_OK           },
    { EQ_ENABLE,        EV_ENABLE       },
    { EQ_RESYNC_START,  EV_RESYNC_START     },
    { EQ_RESYNC_FAILED, EV_RESYNC_FAILED    },
    { EQ_RESYNC_SUCCESS,    EV_RESYNC_SUCCESS   },
    { EQ_RESYNC_DONE,   EV_RESYNC_DONE      },
    { EQ_HOTSPARED,     EV_HOTSPARED        },
    { EQ_HS_FREED,      EV_HS_FREED     },
    { EQ_TAKEOVER,      EV_TAKEOVER     },
    { EQ_RELEASE,       EV_RELEASE      },
    { EQ_OPEN_FAIL,     EV_OPEN_FAIL        },
    { EQ_OFFLINE,       EV_OFFLINE      },
    { EQ_ONLINE,        EV_ONLINE       },
    { EQ_GROW,      EV_GROW         },
    { EQ_DETACH,        EV_DETACH       },
    { EQ_DETACHING,     EV_DETACHING        },
    { EQ_ATTACH,        EV_ATTACH       },
    { EQ_ATTACHING,     EV_ATTACHING        },
    { EQ_CHANGE,        EV_CHANGE       },
    { EQ_EXCHANGE,      EV_EXCHANGE     },
    { EQ_REGEN_START,   EV_REGEN_START      },
    { EQ_REGEN_DONE,    EV_REGEN_DONE       },
    { EQ_REGEN_FAILED,  EV_REGEN_FAILED     },
    { EQ_USER,      EV_USER         },
    { EQ_NOTIFY_LOST,   EV_NOTIFY_LOST      },

    { EQ_LAST,      EV_LAST }
};

static ev_obj_t
dev2tag(md_dev64_t dev, set_t setno, md_error_t *ep)
{
    mdname_t    *np = NULL;
    mdsetname_t *sp = NULL;
    ev_obj_t     obj    = EVO_METADEV;
    char        *miscname;

    if ((sp = metasetnosetname(setno, ep)) == NULL) {
        goto out;
    }
    if (!(np = metamnumname(&sp, meta_getminor(dev), 0, ep))) {
        goto out;
    }

    /* need to invalidate name in case rename or delete/create done */
    meta_invalidate_name(np);

    if (!(miscname = metagetmiscname(np, ep))) {
        goto out;
    }
    if (strcmp(miscname, MD_STRIPE) == 0) {
        obj = EVO_STRIPE;
    } else if (strcmp(miscname, MD_MIRROR) == 0) {
        obj = EVO_MIRROR;
    } else if (strcmp(miscname, MD_RAID) == 0) {
        obj = EVO_RAID5;
    } else if (strcmp(miscname, MD_TRANS) == 0) {
        obj = EVO_TRANS;
    }
out:
    return (obj);
}

static ev_obj_t
tagdrv_2_objlib(md_tags_t tag)
{
    int i;

    for (i = 0; tag2obj_typetab[i].tag != TAG_LAST; i++) {
        if (tag2obj_typetab[i].tag == tag)
            return (tag2obj_typetab[i].obj);
    }
    return (EVO_UNSPECIFIED);
}

static md_tags_t
objlib_2_tagdrv(ev_obj_t obj)
{
    int i;

    for (i = 0; tag2obj_typetab[i].tag != TAG_LAST; i++) {
        if (tag2obj_typetab[i].obj == obj)
            return (tag2obj_typetab[i].tag);
    }
    return (TAG_UNK);
}


static evid_t
evdrv_2_evlib(md_event_type_t drv_ev)
{
    int i;

    for (i = 0; evdrv2evlib_typetab[i].drv != EQ_LAST; i++) {
        if (evdrv2evlib_typetab[i].drv == drv_ev)
            return (evdrv2evlib_typetab[i].lib);
    }
    return (EV_UNK);
}

static md_event_type_t
evlib_2_evdrv(evid_t lib_ev)
{
    int i;

    for (i = 0; evdrv2evlib_typetab[i].drv != EQ_LAST; i++) {
        if (evdrv2evlib_typetab[i].lib == lib_ev)
            return (evdrv2evlib_typetab[i].drv);
    }
    return (EQ_EMPTY);
}


/*
 * meta_event
 *  returns 0 on succcess or < 0 to indicate error.
 *  abs(return code) = errno
 */
static int
meta_event(md_event_ioctl_t *evctl, md_error_t *ep)
{
    int l;

    if (!evctl || !ep)
        return (-EINVAL);

    l = strlen(evctl->mdn_name);
    if ((l == 0 && evctl->mdn_cmd != EQ_PUT) || l >= MD_NOTIFY_NAME_SIZE) {
        return (-EINVAL);
    }

    MD_SETDRIVERNAME(evctl, MD_NOTIFY, 0);
    mdclrerror(ep);
    errno = 0;

    if (metaioctl(MD_IOCNOTIFY, evctl, ep, evctl->mdn_name) != 0) {
        if (errno == 0) {
            errno = EINVAL;
        }
        if (mdisok(ep)) {
            (void) mdsyserror(ep, errno, evctl->mdn_name);
        }
        return (-errno);
    }

    return (0);
}

static void
init_evctl(char *qname,
    md_tags_t tag,
    md_event_type_t ev,
    uint_t flags,
    set_t set,
    md_dev64_t dev,
    md_event_cmds_t cmd,
    u_longlong_t udata,
    md_event_ioctl_t *evctlp)
{

    assert(evctlp);

    (void) memset(evctlp, 0, sizeof (md_event_ioctl_t));

    evctlp->mdn_magic   = MD_EVENT_ID;
    evctlp->mdn_rev     = MD_NOTIFY_REVISION;

    if (qname)
        (void) strncpy(evctlp->mdn_name, qname, MD_NOTIFY_NAME_SIZE-1);
    else
        (void) memset(evctlp->mdn_name, 0, MD_NOTIFY_NAME_SIZE);

    evctlp->mdn_tag     = tag;
    evctlp->mdn_event   = ev;
    evctlp->mdn_flags   = flags;
    evctlp->mdn_set     = set;
    evctlp->mdn_dev     = dev;
    evctlp->mdn_cmd     = cmd;
    evctlp->mdn_user    = udata;
}

/*
 * meta_notify_createq
 * - creates an eventq
 * - returns 0 on success or errno and sets ep
 */
int
meta_notify_createq(char *qname, ulong_t flags, md_error_t *ep)
{
    md_event_ioctl_t    evctl;
    int         err = 0;

    mdclrerror(ep);
    if (!qname || strlen(qname) == 0) {
        (void) mdsyserror(ep, EINVAL,
            dgettext(TEXT_DOMAIN,
            "null or zero-length queue name"));
        return (EINVAL);
    }

    init_evctl(qname,
            TAG_EMPTY,
            EQ_EMPTY,
            (flags & EVFLG_PERMANENT) != 0? EQ_Q_PERM: 0,
            /* set */ 0,
            /* dev */ 0,
            EQ_ON,
            /* user-defined event data */ 0,
            &evctl);

    err = meta_event(&evctl, ep);

    if (err == -EEXIST && !(flags & EVFLG_EXISTERR)) {
        err = 0;
        mdclrerror(ep);
    }
    if (!mdisok(ep) && mdanysyserror(ep)) {
        err = (ep)->info.md_error_info_t_u.ds_error.errnum;
    }
    return (-err);
}

/*
 * meta_notify_deleteq
 * - deletes an eventq
 * - free's any underlying resources
 * - returns 0 on success or errno and sets ep
 */
int
meta_notify_deleteq(char *qname, md_error_t *ep)
{
    md_event_ioctl_t    evctl;
    int         err;

    init_evctl(qname,
            TAG_EMPTY,
            EQ_EMPTY,
            /* flags */ 0,
            /* set */ 0,
            /* dev */ 0,
            EQ_OFF,
            /* user-defined event data */ 0,
            &evctl);

    err = meta_event(&evctl, ep);
    return (-err);
}

/*
 * meta_notify_validq
 * - verifies that the queue exists
 * - returns true or false, ep may be changed as a side-effect
 */
bool_t
meta_notify_validq(char *qname, md_error_t *ep)
{
    md_event_ioctl_t    evctl;

    init_evctl(qname,
            TAG_EMPTY,
            EQ_EMPTY,
            /* flags */ 0,
            /* set */ 0,
            /* dev */ 0,
            EQ_ON,
            /* user-defined event data */ 0,
            &evctl);

    return (meta_event(&evctl, ep) == -EEXIST);
}

/*
 * meta_notify_listq
 * - returns number of (currently) active queus or -errno
 * - allocates qnames array and sets user's pointer to it,
 *   fills in array with vector of qnames
 */
int
meta_notify_listq(char ***qnames, md_error_t *ep)
{

#ifdef lint
    qnames = qnames;
#endif /* lint */

    mdclrerror(ep);
    (void) mdsyserror(ep, EOPNOTSUPP, "EOPNOTSUPP");
    return (-EOPNOTSUPP);
}

/*
 * meta_notify_flushq
 * - calls the underlying notify driver to flush all events
 *   from the named queue
 * - returns 0 on success or errno and sets ep as necessary
 */
int
meta_notify_flushq(char *qname, md_error_t *ep)
{

#ifdef lint
    qname = qname;
#endif /* lint */

    mdclrerror(ep);
    (void) mdsyserror(ep, EOPNOTSUPP, "EOPNOTSUPP");
    return (EOPNOTSUPP);
}

static void
cook_ev(md_event_ioctl_t *evctlp, md_ev_t *evp, md_error_t *ep)
{
    assert(evctlp);
    assert(evp);

    evp->obj_type = tagdrv_2_objlib(evctlp->mdn_tag);

    if (evp->obj_type == EVO_METADEV) {
        evp->obj_type = dev2tag(evctlp->mdn_dev, evctlp->mdn_set, ep);
    }

    evp->setno  = evctlp->mdn_set;
    evp->ev     = evdrv_2_evlib(evctlp->mdn_event);
    evp->obj    = evctlp->mdn_dev;
    evp->uev    = evctlp->mdn_user;
}

/*
 * meta_notify_getev
 * - collects up to 1 event and stores it into md_ev_t
 * - returns number of events found (0 or 1) on success or -errno
 * - flags governs whether an empty queue is waited upon (EVFLG_WAIT)
 */
int
meta_notify_getev(char *qname, ulong_t flags, md_ev_t *evp, md_error_t *ep)
{
    md_event_ioctl_t    evctl;
    int         n_ev;
    int         err = -EINVAL;

    if (!evp) {
        goto out;
    }

    init_evctl(qname,
            TAG_EMPTY,
            EQ_EMPTY,
            /* flags (unused in get) */ 0,
            (evp->setno == EV_ALLSETS)? MD_ALLSETS: evp->setno,
            (evp->obj == EV_ALLOBJS)? MD_ALLDEVS: evp->obj,
            (flags & EVFLG_WAIT) != 0? EQ_GET_WAIT: EQ_GET_NOWAIT,
            /* user-defined event data */ 0,
            &evctl);

    err = meta_event(&evctl, ep);

    /*
     * trap EAGAIN so that EV_EMPTY events get returned, but
     * be sure n_ev = 0 so that users who just watch the count
     * will also work
     */
    switch (err) {
    case -EAGAIN:
        err = n_ev = 0;
        cook_ev(&evctl, evp, ep);
        break;
    case 0:
        n_ev = 1;
        cook_ev(&evctl, evp, ep);
        break;
    }
out:
    return (err == 0? n_ev: err);
}


/*
 * meta_notify_getevlist
 * - collects all pending events in the named queue and allocates
 *   an md_evlist_t * to return them
 * - returns the number of events found (may be 0 if !WAIT) on success
 *   or -errno and sets ep as necessary
 */
int
meta_notify_getevlist(char *qname,
            ulong_t  flags,
            md_evlist_t **evpp_arg,
            md_error_t *ep)
{
    md_ev_t     *evp        = NULL;
    md_evlist_t *evlp       = NULL;
    md_evlist_t *evlp_head  = NULL;
    md_evlist_t *new        = NULL;
    int      n_ev       = 0;
    int      err        = -EINVAL;

    mdclrerror(ep);
    if (!evpp_arg) {
        (void) mdsyserror(ep, EINVAL, dgettext(TEXT_DOMAIN,
            "No event list pointer"));
        goto out;
    }

    if (!qname || strlen(qname) == 0) {
        (void) mdsyserror(ep, EINVAL, dgettext(TEXT_DOMAIN,
            "Null or zero-length queue name"));
        goto out;
    }

    do {
        if (!(evp = (md_ev_t *)Malloc(sizeof (md_ev_t)))) {
            (void) mdsyserror(ep, ENOMEM, qname);
            continue;
        }
        evp->obj_type   = EVO_EMPTY;
        evp->setno  = EV_ALLSETS;
        evp->ev     = EV_EMPTY;
        evp->obj    = EV_ALLOBJS;
        evp->uev    = 0ULL;

        err = meta_notify_getev(qname, flags, evp, ep);

        if (evp->ev != EV_EMPTY) {
            new = (md_evlist_t *)Zalloc(sizeof (md_evlist_t));
            if (evlp_head == NULL) {
                evlp = evlp_head = new;
            } else {
                evlp->next = new;
                evlp = new;
            }
            evlp->evp = evp;
            n_ev++;
        }

    } while (err >= 0 && evp && evp->ev != EV_EMPTY);
out:
    if (err == -EAGAIN) {
        err = 0;
    }

    if (err < 0) {
        meta_notify_freeevlist(evlp_head);
        evlp_head = NULL;
        return (err);
    } else if ((err == 0) && (evp->ev == EV_EMPTY)) {
        Free(evp);
        evp = NULL;
    }

    if (evpp_arg) {
        *evpp_arg = evlp_head;
    }

    return (n_ev);
}


/*
 * the guts of meta_notify_putev() and meta_notify_sendev()
 * are within this function.
 *
 * meta_notify_putev() is intended for general use by user-level code,
 * such as the GUI, to send user-defined events.
 *
 * meta_notify_sendev() is for "user-level driver" code, such as
 * set manipulation and the multi-host daemon to generate events.
 *
 * Note- only convention enforces this usage.
 */
int
meta_notify_doputev(md_ev_t *evp, md_error_t *ep)
{
    md_event_ioctl_t    evctl;

    if (!evp || !ep) {
        return (EINVAL);
    }

    /*
     * users may only put events of type EQ_USER
     */
    init_evctl(/* qname (unused in put) */ NULL,
            TAG_EMPTY,
            EQ_EMPTY,
            /* flags (unused in put) */ 0,
            (evp->setno == EV_ALLSETS)? MD_ALLSETS: evp->setno,
            (evp->obj == EV_ALLOBJS)? MD_ALLDEVS: evp->obj,
            EQ_PUT,
            evp->uev,
            &evctl);

    evctl.mdn_tag   = objlib_2_tagdrv(evp->obj_type);
    evctl.mdn_event = evlib_2_evdrv(evp->ev);

    return (-meta_event(&evctl, ep));
}

/*
 * meta_notify_putev
 * - sends an event down to the notify driver (hence, all queues)
 * - returns 0 on success or errno
 */
int
meta_notify_putev(md_ev_t *evp, md_error_t *ep)
{
    if (!evp || !ep) {
        return (EINVAL);
    }

    evp->ev = EV_USER;  /* by definition */

    return (meta_notify_doputev(evp, ep));
}

/*
 * alternate put event entry point which allows
 * more control of event innards (for use by md "user-level drivers")
 *
 * Since this routine isn't for use by clients, the user event data
 * is always forced to be 0. That is only meaningful for events
 * of type EQ_USER (and those go through meta_notify_putev()), so
 * this is consistent.
 */
int
meta_notify_sendev(
    ev_obj_t    tag,
    set_t       set,
    md_dev64_t  dev,
    evid_t      ev)
{
    md_error_t       status = mdnullerror;
    md_error_t      *ep = &status;
    md_ev_t          ev_packet;
    int          rc;

    ev_packet.obj_type  = tag;
    ev_packet.setno     = set;
    ev_packet.obj       = dev;
    ev_packet.ev        = ev;
    ev_packet.uev       = 0ULL;

    rc = meta_notify_doputev(&ev_packet, ep);

    if (0 == rc && !mdisok(ep)) {
        rc = EINVAL;
        mdclrerror(ep);
    }
    return (rc);
}

/*
 * meta_notify_putevlist
 * - sends all of the events in the event list
 * - returns number of events sent (>= 0) on success or -errno
 */
int
meta_notify_putevlist(md_evlist_t *evlp, md_error_t *ep)
{
    md_evlist_t *evlpi;
    int      n_ev   = 0;
    int      err;

    if (!evlp) {
        err = 0;
        goto out;   /* that was easy */
    }

    for (n_ev = 0, evlpi = evlp; evlpi; evlpi = evlpi->next) {
        if ((err = meta_notify_putev(evlpi->evp, ep)) < 0) {
            goto out;
        }
        n_ev++;
    }
out:
    return (err != 0? err: n_ev);
}

/*
 * meta_notify_freevlist
 * - frees any memory allocated within the event list
 * - returns 0 on success or errno and sets ep as necessary
 */
void
meta_notify_freeevlist(md_evlist_t *evlp)
{
    md_evlist_t *i;
    md_evlist_t *next;

    for (i = evlp; i; i = i->next) {
        if (i && i->evp) {
            Free(i->evp);
            i->evp = NULL;
        }
    }
    for (i = evlp; i; /* NULL */) {
        next = i->next;
        Free(i);
        i = next;
    }
}