path: root/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);
}