cmd/vntsd/queue.c

	queue.c revision 1ae0874509b6811fdde1dfd46f0d93fd09867a3f
/*
 * 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"

/*
 * utility for vntsd queue handling
 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <wait.h>
#include <time.h>
#include <netinet/in.h>
#include <thread.h>
#include <signal.h>
#include "vntsd.h"

/* alloc_que_el() allocates a queue element */
static vntsd_que_t *
alloc_que_el(void *handle)
{
    vntsd_que_t *el;

    /* allocate a queue element */
    el = (vntsd_que_t *)malloc(sizeof (vntsd_que_t));
    if (el == NULL) {
        return (NULL);
    }


    el->nextp = NULL;
    el->prevp = NULL;
    el->handle = handle;

    return (el);
}

/* vntsd_que_append() appends a element to a queue */
int
vntsd_que_append(vntsd_que_t **que_hd, void *handle)
{
    vntsd_que_t *p;
    vntsd_que_t *el;

    assert(que_hd);
    assert(handle);

    /* allocate a queue element */
    el = alloc_que_el(handle);

    if (el == NULL) {
        return (VNTSD_ERR_NO_MEM);
    }

    p = *que_hd;

    if (p == NULL) {
        /* first one */
        *que_hd  = el;
    } else {
        /* walk to the last one */
        while (p->nextp != NULL)
            p = p->nextp;
        p->nextp = el;
    }

    el->prevp = p;

    return (VNTSD_SUCCESS);
}

/* vntsd_que_insert_after() inserts element arter the handle */
int
vntsd_que_insert_after(vntsd_que_t *que, void *handle, void *next)
{
    vntsd_que_t *q, *el;

    assert(que);

    q = que;

    while (q != NULL) {
        if (q->handle == handle) {
            break;
        }

        q = q->nextp;
    }

    if (q == NULL) {
        /* not in queue */
        return (VNTSD_ERR_EL_NOT_FOUND);
    }

    el = alloc_que_el(next);

    if (el == NULL) {
        return (VNTSD_ERR_NO_MEM);
    }

    el->nextp = q->nextp;
    q->nextp = el;
    el->prevp = q;

    return (VNTSD_SUCCESS);
}


/* vntsd_que_rm() removes an element from a queue */
int
vntsd_que_rm(vntsd_que_t **que_hd, void *handle)
{
    vntsd_que_t *p = *que_hd;
    vntsd_que_t *prevp = NULL;


    while (p != NULL) {
        /* match handle */
        if (p->handle == handle) {
            break;
        }
        prevp = p;
        p = p->nextp;
    }

    if (p == NULL) {
        /* not found */
        return (VNTSD_ERR_EL_NOT_FOUND);
    }

    /* found */
    if (p == *que_hd) {
        /* first one */
        *que_hd = p->nextp;
    } else {
        prevp->nextp = p->nextp;
    }

    if (p->nextp != NULL) {
        p->nextp->prevp = prevp;
    }

    handle = p->handle;

    free(p);

    return (VNTSD_SUCCESS);

}

/* vntsd_que_walk() - walk queue and apply function to each element */
void *
vntsd_que_walk(vntsd_que_t *que_hd, el_func_t el_func)
{
    vntsd_que_t *p = que_hd;

    while (p != NULL) {
        if ((*el_func)(p->handle)) {
            return (p->handle);
        }

        p = p->nextp;
    }
    return (VNTSD_SUCCESS);
}


/* vntsd_que_find() finds first match */
void *
vntsd_que_find(vntsd_que_t *que_hd, compare_func_t compare_func, void *data)
{
    vntsd_que_t *p = que_hd;

    assert(compare_func != NULL);
    while (p != NULL) {
        if ((*compare_func)(p->handle, data)) {
            /* found match */
            return (p->handle);
        }

        p = p->nextp;
    }

    /* not found */
    return (NULL);
}

/* vntsd_free_que() frees entire queue */
void
vntsd_free_que(vntsd_que_t **q, clean_func_t clean_func)
{
    vntsd_que_t *p;

    while (*q != NULL) {
        p = *q;

        *q  = p->nextp;

        if (clean_func) {
            /* clean func will free the handle */
            (*clean_func)(p->handle);
        } else {
            free(p->handle);
        }

        free(p);
    }
}

/*
 * vntsd_que_pos() matches a handle and returns a handle located at "pos"
 * relative to the matched handle. pos supported are 1 or -1.
 */
void *
vntsd_que_pos(vntsd_que_t *que_hd, void *handle, int pos)
{
    vntsd_que_t *p = que_hd;

    assert((pos == 1) || (pos == -1));


    while (p != NULL) {
        if (p->handle == handle) {
            /* find match */
            if (pos == 1) {
                /* forward 1 */
                if (p->nextp != NULL) {
                    return (p->nextp->handle);
                }

                /* last one go to first */
                return (que_hd->handle);

            } else {
                /* backward 1 */
                if (p->prevp != NULL) {
                    return (p->prevp->handle);
                }

                /* first one, return last one */
                while (p->nextp != NULL) {
                    p = p->nextp;
                }

                assert(p != NULL);
                assert(p->handle != NULL);
                return (p->handle);

            }
        }
        p = p->nextp;
    }

    DERR(stderr, "t@%d vntsd_que_pos can not find handle \n",
        thr_self());

    return (NULL);
}