640 number_to_scaled_string is duplicated in several commands

[unleashed.git] / usr / src / lib / librcm / librcm_event.c

/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <door.h>
#include <unistd.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <synch.h>
#include <sys/stat.h>
#include <librcm_impl.h>

#include "librcm_event.h"

#define dprint  if (debug) (void) printf
static int debug = 1;

#define BUF_THRESHOLD   1024    /* larger bufs require a free */

/*
 * Lookup seq_num. We can not use the standard nvlist_lookup functions since
 * the nvlist is not allocated with NV_UNIQUE_NAME or NV_UNIQUE_NAME_TYPE.
 */
static int
lookup_seq_num(nvlist_t *nvl, uint64_t *seq_num)
{
        nvpair_t *nvp = NULL;

        while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
                if (strcmp(nvpair_name(nvp), RCM_SEQ_NUM) == 0 &&
                    nvpair_type(nvp) == DATA_TYPE_UINT64)
                        return (nvpair_value_uint64(nvp, seq_num));
        }

        return (ENOENT);
}

/*
 * Get event service from a named door.
 *
 * This is similar to sysevent_post_event(), except that it deals with
 * the "return buffer problem":
 *      Typically, the door service places the return buffer on the stack
 *      when calling door_return(). This places an artificial limit on the
 *      size of the return buffer.
 * This problem is solved by placing large buffers on the heap, referenced
 * through door_info. When client detects a large buffer, it will make a
 * second door_call() to free the buffer. The client and the server agrees
 * on a size, which is defined as BUF_THRESHOLD.
 *
 * Returns -1 if message not delivered. With errno set to cause of error.
 * Returns 0 for success with the results returned in posting buffer.
 */
int
get_event_service(char *door_name, void *data, size_t datalen,
    void **result, size_t *rlen)
{
        int service_door, error;
        door_arg_t door_arg;

        /*
         * Open the service door
         */
        if ((service_door = open(door_name, O_RDONLY, 0)) == -1) {
                errno = ESRCH;
                return (-1);
        }

retry1:
        door_arg.rbuf = NULL;   /* doorfs will provide return buf */
        door_arg.rsize = 0;
        door_arg.data_ptr = data;
        door_arg.data_size = datalen;
        door_arg.desc_ptr = NULL;
        door_arg.desc_num = 0;

        /*
         * Make door call
         * EAGAIN is returned when the door server is temporarily
         * out of threads to service the door call. So retry.
         */
        if ((error = door_call(service_door, &door_arg)) == -1 &&
            errno == EAGAIN) {
                (void) sleep(1);
                goto retry1;
        }

        if ((error == 0) && result) {

                uint64_t seq_num = 0;

                *result = NULL;
                *rlen = 0;
                if (door_arg.rbuf == NULL || door_arg.rsize == 0) {
                        dprint("bad return from door call\n");
                        (void) close(service_door);
                        errno = EFAULT;
                        return (-1);
                }

                (void) nvlist_unpack(door_arg.rbuf, door_arg.rsize,
                    (nvlist_t **)result, 0);
                (void) munmap(door_arg.rbuf, door_arg.rsize);

                /*
                 * If requiring a buf free, make another door call.  There is
                 * no need to call munmap() after this door call, though.
                 */
                if (lookup_seq_num((nvlist_t *)*result, &seq_num) == 0) {
retry2:
                        door_arg.rbuf = NULL;
                        door_arg.rsize = 0;
                        door_arg.data_ptr = (char *)&seq_num;
                        door_arg.data_size = sizeof (seq_num);
                        door_arg.desc_ptr = NULL;
                        door_arg.desc_num = 0;
                        if (door_call(service_door, &door_arg) == -1) {
                                if (errno == EAGAIN) {
                                        (void) sleep(1);
                                        goto retry2;
                                }
                                dprint("fail to free event buf in server\n");
                        }
                }
        }

        (void) close(service_door);
        return (error);
}

/*
 * Export an event service door
 */
struct door_result {
        struct door_result *next;
        void *data;
        uint64_t seq_num;
};

typedef struct door_cookie {
        uint64_t        seq_num;
        mutex_t         door_lock;
        void            (*door_func)(void **, size_t *);
        struct door_result *results;
} door_cookie_t;

/*
 * add result to cookie, this is only invoked if result size > BUF_THRESHOLD
 */
static void
add_door_result(door_cookie_t *cook, void *data, uint64_t seq_num)
{
        struct door_result *result;

        /*
         * Need a better way to handle memory here
         */
        result = malloc(sizeof (*result));
        while (result == NULL) {
                (void) sleep(1);
                result = malloc(sizeof (*result));
        }
        result->next = NULL;
        result->data = data;
        result->seq_num = seq_num;

        /*
         * Attach current door result to the door cookie
         */
        (void) mutex_lock(&cook->door_lock);
        if (cook->results == NULL) {
                cook->results = result;
        } else {
                struct door_result *tmp = cook->results;
                while (tmp->next) {
                        tmp = tmp->next;
                }
                tmp->next = result;
        }
        (void) mutex_unlock(&cook->door_lock);
}

/*
 * free a previous door result as described by number.
 */
static void
free_door_result(door_cookie_t *cook, uint64_t num)
{
        struct door_result *prev = NULL, *tmp;

        (void) mutex_lock(&cook->door_lock);
        tmp = cook->results;
        while (tmp && tmp->seq_num != num) {
                prev = tmp;
                tmp = tmp->next;
        }

        if (tmp == NULL) {
                dprint("attempting to free nonexistent buf: %llu\n",
                    (unsigned long long)num);
                (void) mutex_unlock(&cook->door_lock);
                return;
        }

        if (prev) {
                prev->next = tmp->next;
        } else {
                cook->results = tmp->next;
        }
        (void) mutex_unlock(&cook->door_lock);

        free(tmp->data);
        free(tmp);
}

/*ARGSUSED*/
static void
door_service(void *cookie, char *args, size_t alen,
    door_desc_t *ddp, uint_t ndid)
{
        nvlist_t *nvl;
        size_t nvl_size = 0;
        char rbuf[BUF_THRESHOLD];
        door_cookie_t *cook = (door_cookie_t *)cookie;
        uint64_t seq_num = 0;

        /*
         * Special case for asking to free buffer
         */
        if (alen == sizeof (uint64_t)) {
                free_door_result(cookie, *(uint64_t *)(void *)args);
                (void) door_return(NULL, 0, NULL, 0);
        }

        /*
         * door_func update args to point to return results.
         * memory for results are dynamically allocated.
         */
        (*cook->door_func)((void **)&args, &alen);

        /*
         * If no results, just return
         */
        if (args == NULL) {
                dprint("null results returned from door_func().\n");
                (void) door_return(NULL, 0, NULL, 0);
        }

        /* Determine the size of the packed nvlist */
        nvl = (nvlist_t *)(void *)args;
        args = NULL;
        alen = 0;
        if (errno = nvlist_size(nvl, &nvl_size, NV_ENCODE_NATIVE)) {
                nvlist_free(nvl);
                dprint("failure to sizeup door results: %s\n", strerror(errno));
                (void) door_return(NULL, 0, NULL, 0);
        }

        /*
         * If the size of the packed nvlist would exceed the buffer threshold
         * then get a sequence number and add it to the nvlist.
         */
        if (nvl_size > BUF_THRESHOLD) {
                (void) mutex_lock(&cook->door_lock);
                cook->seq_num++;
                seq_num = cook->seq_num;
                (void) mutex_unlock(&cook->door_lock);
                (void) nvlist_add_uint64(nvl, RCM_SEQ_NUM, seq_num);
        }

        /* Refill the args with a packed version of the nvlist */
        if (errno = nvlist_pack(nvl, &args, &alen, NV_ENCODE_NATIVE, 0)) {
                nvlist_free(nvl);
                dprint("failure to pack door results: %s\n", strerror(errno));
                (void) door_return(NULL, 0, NULL, 0);
        }
        nvlist_free(nvl);

        /*
         * Based on the size of the packed nvlist, either use the local buffer
         * or add it to the results list.
         */
        if (alen <= BUF_THRESHOLD) {
                bcopy(args, rbuf, alen);
                (void) free(args);
                args = rbuf;
        } else {
                /*
                 * for long data, append results to end of queue in cook
                 * and set ndid, ask client to do another door_call
                 * to free the buffer.
                 */
                add_door_result(cook, args, seq_num);
        }

        (void) door_return(args, alen, NULL, 0);
}

int
create_event_service(char *door_name,
    void (*func)(void **data, size_t *datalen))
{
        int service_door, fd;
        door_cookie_t *cookie;

        /* create an fs file */
        fd = open(door_name, O_EXCL|O_CREAT, S_IREAD|S_IWRITE);
        if ((fd == -1) && (errno != EEXIST)) {
                return (-1);
        }
        (void) close(fd);

        /* allocate space for door cookie */
        if ((cookie = calloc(1, sizeof (*cookie))) == NULL) {
                return (-1);
        }

        cookie->door_func = func;
        if ((service_door = door_create(door_service, (void *)cookie,
            DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
                dprint("door create failed: %s\n", strerror(errno));
                free(cookie);
                return (-1);
        }

retry:
        (void) fdetach(door_name);
        if (fattach(service_door, door_name) != 0) {
                if (errno == EBUSY) {
                        /*
                         * EBUSY error may occur if anyone references the door
                         * file while we are fattach'ing. Since librcm, in the
                         * the process context of a DR initiator program, may
                         * reference the door file (via open/close/stat/
                         * door_call etc.) while we are still fattach'ing,
                         * retry on EBUSY.
                         */
                        goto retry;
                }
                dprint("door attaching failed: %s\n", strerror(errno));
                free(cookie);
                (void) close(service_door);
                return (-1);
        }

        return (service_door);
}

int
revoke_event_service(int fd)
{
        struct door_info info;
        door_cookie_t *cookie;

        if (door_info(fd, &info) == -1) {
                return (-1);
        }

        if (door_revoke(fd) != 0) {
                return (-1);
        }

        /* wait for existing door calls to finish */
        (void) sleep(1);

        if ((cookie = (door_cookie_t *)(uintptr_t)info.di_data) != NULL) {
                struct door_result *tmp = cookie->results;
                while (tmp) {
                        cookie->results = tmp->next;
                        free(tmp->data);
                        free(tmp);
                        tmp = cookie->results;
                }
                free(cookie);
        }
        return (0);
}