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

/*
 * etm_ckpt.c
 * Description:
 *    Checkpoint the ereport events for persitence across fmd restart.
 *
 *    Each ereport is stored in a named buffer. Each ereport is uniquely
 *    indentified by a id which is consists of a number of ereport fields. The
 *    name of the buffer is derived from the id.
 *
 *    All ereport ids are stored in the circular list which is saved in a
 *    separate buffer.
 */

#include <assert.h>
#include <stdio.h>
#include <pthread.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fm/ldom.h>
#include <sys/fm/protocol.h>
#include <fm/fmd_api.h>
#include <fm/libtopo.h>
#include <fm/topo_hc.h>

#include "etm_etm_proto.h"
#include "etm_iosvc.h"
#include "etm_ckpt.h"
#include "etm_filter.h"

#define	ETM_ATTR_PRIMARY	"primary"
#define	ETM_ATTR_TOD		"__tod"
#define	ETM_LDOM_PRIMARY	"primary"

/*
 * -------------------------- private variables ------------------------------
 */

static etm_ckpt_id_list_t *etm_id_lst = NULL;	/* list of ereports ids */

static pthread_mutex_t etm_id_lst_lock;		/* list lock */

/*
 * -------------------------- functions --------------------------------------
 */

/*
 * etm_ckpt_str_hash()
 * Description:
 *     Hash a class name to a number
 */
static uint_t
etm_ckpt_str_hash(char *str)
{
	uint_t		hash = 0;	/* hash value */

	if (str == NULL)
		return (0);

	while (*str != '\0')
		hash += *str++;

	return (hash);
}

/*
 * etm_ckpt_id2str()
 * Description:
 *     Get the string of an ereport id. It is used as the named buffer that
 *     store the ereport.
 */
static void
etm_ckpt_id2str(etm_ckpt_erpt_id_t *id, char *str, size_t size) {
	(void) snprintf(str, size, "%s_%llx_%d_%x_%d", ETM_CKPT_ERPT_PREFIX,
	    id->ei_ena, id->ei_hash, id->ei_tod1, id->ei_pri);
}

/*
 * etm_ckpt_erpt2id()
 * Description:
 *     Get the buffer name and ereport id of a given ereport
 */
static int
etm_ckpt_erpt2id(fmd_hdl_t *hdl, nvlist_t *erpt, etm_ckpt_erpt_id_t *id,
    char *str, int size) {
	char		*class = NULL;
	uint64_t	*tod;
	uint_t		sz;
	boolean_t	pri = B_FALSE;

	bzero(id, sizeof (etm_ckpt_erpt_id_t));

	/* ena */
	if (nvlist_lookup_uint64(erpt, FM_EREPORT_ENA, &id->ei_ena) != 0) {
		fmd_hdl_debug(hdl, "Ena not found\n");
		return (-1);
	}

	/* class name */
	(void) nvlist_lookup_string(erpt, FM_CLASS, &class);
	if (class == NULL) {
		fmd_hdl_debug(hdl, "%s not found\n", FM_CLASS);
		return (-1);
	}
	if (strncmp(class, FM_EREPORT_CLASS, strlen(FM_EREPORT_CLASS)) != 0) {
		fmd_hdl_debug(hdl, "Only support checkpointing %s\n",
		    FM_EREPORT_CLASS);
		return (-1);
	}
	id->ei_hash = etm_ckpt_str_hash(class);

	/* tod[1]: fractional of a second */
	if (nvlist_lookup_uint64_array(erpt, ETM_ATTR_TOD, &tod, &sz) == 0) {
		if (sz >= 2) {
			id->ei_tod1 = (uint32_t)tod[1];
		}
	}

	/* primary flag */
	if (nvlist_lookup_boolean_value(erpt, ETM_ATTR_PRIMARY, &pri) == 0) {
		id->ei_pri = pri ? 1 : 0;
	}

	etm_ckpt_id2str(id, str, size);

	return (0);
}

/*
 * etm_ckpt_il_equal()
 * Description:
 *     Test if two ereport ids are equal.
 */
static boolean_t
etm_ckpt_il_equal(etm_ckpt_erpt_id_t *i1, etm_ckpt_erpt_id_t *i2)
{
	return ((i1->ei_ena == i2->ei_ena) && (i1->ei_tod1 == i2->ei_tod1) &&
	    (i1->ei_pri == i2->ei_pri) && (i1->ei_hash == i2->ei_hash));
}

/*
 * etm_ckpt_il_resize()
 * Description:
 *     Increase the size of the circular list and pack its entries.
 */
static void
etm_ckpt_il_resize(fmd_hdl_t *hdl, uint_t factor)
{
	etm_ckpt_id_list_t	*il1, *il2;		/* temp lists */
	size_t			sz1, sz2;		/* sizes of lists */
	int			i, next;		/* temp counters */
	etm_ckpt_erpt_id_t	*p1, *p2, *s1, *s2;	/* temp id pointers */
	etm_ckpt_erpt_id_t	blank;			/* blank ereport id */

	if (factor == 0)
		return;

	/* the present queue */
	il1 = etm_id_lst;
	sz1 = sizeof (etm_ckpt_id_list_t) + il1->il_ids_sz;

	/* Create an empty queue with a new size */
	sz2 = sizeof (etm_ckpt_id_list_t) + (factor * il1->il_ids_sz);
	il2 = fmd_hdl_zalloc(hdl, sz2, FMD_SLEEP);
	il2->il_ver = ETM_CKPT_VERSION;
	il2->il_max = factor * etm_id_lst->il_max;
	il2->il_ids_sz = factor * il1->il_ids_sz;

	/* pointers to the two arrays of entries */
	bzero(&blank, sizeof (blank));
	s1 = (etm_ckpt_erpt_id_t *)
	    ((ptrdiff_t)il1 + sizeof (etm_ckpt_id_list_t));
	s2 = (etm_ckpt_erpt_id_t *)
	    ((ptrdiff_t)il2 + sizeof (etm_ckpt_id_list_t));

	/* copy non-empty ereport ids from list il1 to il2. Toss the blank. */
	if (il1->il_head != il1->il_tail) {
		for (i = il1->il_head; i != il1->il_tail; i = next) {
			next = (i + 1) % il1->il_max;
			p1 = s1 + next;
			if (!etm_ckpt_il_equal(p1, &blank)) {
				/* copy non-empty entries */
				il2->il_tail = (il2->il_tail + 1) % il2->il_max;
				fmd_hdl_debug(hdl, "Copying entry %d to %d\n",
				    next, il2->il_tail);
				p2 = s2 +  il2->il_tail;
				*p2 = *p1;
				il2->il_cnt++;
			}
		}
	}

	if (factor == 1) {
		/* both lists have the same size, update the present list */
		bcopy(il2, il1, sz1);
		fmd_hdl_free(hdl, il2, sz2);
		fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) il1, sz1);
	} else {
		/* replace the present list */
		etm_id_lst = il2;
		fmd_hdl_free(hdl, il1, sz1);
		/* write to new buffer */
		fmd_buf_destroy(hdl, NULL, ETM_CKPT_IL_BUF);
		fmd_buf_create(hdl, NULL, ETM_CKPT_IL_BUF, sz2);
		fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) il2, sz2);
	}
}

/*
 * etm_ckpt_il_find()
 * Description:
 *     Find the ereport id in the list.
 */
/* ARGSUSED */
static int
etm_ckpt_il_find(fmd_hdl_t *hdl, etm_ckpt_erpt_id_t *id)
{
	int			i, next;	/* temp counter */
	etm_ckpt_erpt_id_t	*p, *s;		/* temp erpt id */

	fmd_hdl_debug(hdl, "etm_ckpt_il_find()\n");

	/* empty list */
	if (etm_id_lst->il_head == etm_id_lst->il_tail) {
		fmd_hdl_debug(hdl, "find an empty list\n");
		return (-1);
	}
	s = (etm_ckpt_erpt_id_t *)((ptrdiff_t)etm_id_lst +
	    sizeof (etm_ckpt_id_list_t));
	for (i = etm_id_lst->il_head; i != etm_id_lst->il_tail; i = next) {
		next = (i + 1) % etm_id_lst->il_max;
		p = s + next;
		if (etm_ckpt_il_equal(p, id))
			return (i);
	}

	return (-1);
}

/*
 * etm_ckpt_il_add()
 * Description:
 *     Add an ereport id in the list.
 */
static int
etm_ckpt_il_add(fmd_hdl_t *hdl, etm_ckpt_erpt_id_t *id) {
	int			next;
	etm_ckpt_erpt_id_t	*p, *s;	/* temp id */

	/*
	 * resize the q if it is full.
	 * If the capacity is less 80%, purge the emtpy entries to make more
	 * room for new entries. Otherwise, double the queue size.
	 */
	next = (etm_id_lst->il_tail + 1) % etm_id_lst->il_max;
	if (next == etm_id_lst->il_head) {
		if ((etm_id_lst->il_cnt * 1.0 / etm_id_lst->il_max) < 0.8) {
			etm_ckpt_il_resize(hdl, 1);
		} else {
			etm_ckpt_il_resize(hdl, 2);
		}

		/* test if the list again */
		next = (etm_id_lst->il_tail + 1) % etm_id_lst->il_max;
		if (next == etm_id_lst->il_head) {
			fmd_hdl_error(hdl, "List is full %d %d\n",
			    etm_id_lst->il_head, etm_id_lst->il_tail);
		}
	}

	/* Add the id entry at the head */
	s = (etm_ckpt_erpt_id_t *)((ptrdiff_t)etm_id_lst +
	    sizeof (etm_ckpt_id_list_t));
	etm_id_lst->il_tail = (etm_id_lst->il_tail + 1) % etm_id_lst->il_max;
	p = s + etm_id_lst->il_tail;
	*p = *id;
	etm_id_lst->il_cnt++;

	return (etm_id_lst->il_tail);
}

/*
 * etm_ckpt_il_delete()
 * Description:
 *     Delete an ereport id from the list.
 */
int
etm_ckpt_il_delete(fmd_hdl_t *hdl, etm_ckpt_erpt_id_t *id) {

	int			i, next;	/* temp counter */
	etm_ckpt_erpt_id_t	*p, *s;		/* temp id pointers */
	etm_ckpt_erpt_id_t	blank;		/* blank id */

	/* empty list */
	if (etm_id_lst->il_tail == etm_id_lst->il_head) {
		fmd_hdl_debug(hdl, "Empty queue(%d)\n", etm_id_lst->il_head);
		return (-1);
	}

	bzero(&blank, sizeof (blank));
	s = (etm_ckpt_erpt_id_t *)((ptrdiff_t)etm_id_lst +
	    sizeof (etm_ckpt_id_list_t));

	/* delete leading empty entries */
	for (i = etm_id_lst->il_head; i != etm_id_lst->il_tail; i = next) {
		next = (i + 1) % etm_id_lst->il_max;
		p = s + next;
		if (!etm_ckpt_il_equal(p, &blank)) {
			break;
		}
		etm_id_lst->il_cnt--;
		etm_id_lst->il_head = next;
	}

	/* empty queue */
	if (etm_id_lst->il_head == etm_id_lst->il_tail) {
		fmd_hdl_debug(hdl, "Empty queue(%d)\n", etm_id_lst->il_head);
		return (-1);
	}

	/* find the entry and clear it */
	for (i = etm_id_lst->il_head; i != etm_id_lst->il_tail; i = next) {
		next = (i + 1) % etm_id_lst->il_max;
		p = s + next;
		if (etm_ckpt_il_equal(p, id)) {
			/* clear the entry */
			*p = blank;
			etm_id_lst->il_cnt--;

			/* remove the entry if it is the last one */
			if (i == etm_id_lst->il_head) {
				etm_id_lst->il_head = next;
			}
			return (i);
		}
	}

	return (-1);
}


/*
 * etm_ckpt_il_restore()
 * Description:
 *     Restore the idlist named buffer which is the circular list of the
 *     the ereport ids.
 */
void
etm_ckpt_il_restore(fmd_hdl_t *hdl)
{
	size_t	size;		/* buffer size */

	/* get the buffer of the id list */
	size = fmd_buf_size(hdl, NULL, ETM_CKPT_IL_BUF);
	if (size < sizeof (etm_ckpt_id_list_t)) {
		fmd_hdl_debug(hdl, "Buffer name %s do not exist\n",
		    ETM_CKPT_IL_BUF);
		return;
	}
	etm_id_lst = (etm_ckpt_id_list_t *)fmd_hdl_zalloc(hdl, size, FMD_SLEEP);
	fmd_buf_read(hdl, NULL, ETM_CKPT_IL_BUF, (void *) etm_id_lst, size);

	/* check version */
	if (etm_id_lst->il_ver > ETM_CKPT_VERSION) {

		fmd_hdl_error(hdl, "Unsupport checkpoint version (%#x)\n",
		    etm_id_lst->il_ver);
		fmd_hdl_free(hdl, (void *) etm_id_lst, size);
		etm_id_lst = NULL;
		return;
	}

	/* check the length */
	if (etm_id_lst->il_ids_sz != (size - sizeof (etm_ckpt_id_list_t))) {
		fmd_hdl_debug(hdl, "Invalid ids buffer size (%d, %d)\n",
		    etm_id_lst->il_ids_sz, size);
		fmd_hdl_free(hdl, (void *) etm_id_lst, size);
		etm_id_lst = NULL;
		return;
	}
}

/*
 * etm_ckpt_recover()
 * Description:
 *    Recover ereports from the checkpointed data and dispatch them to the
 *    ldom queue(s).
 */
void
etm_ckpt_recover(fmd_hdl_t *hdl)
{
	int			size;			/* buffer size */
	int			i, next;		/* temp counter */
	boolean_t		dirty = B_FALSE;	/* dirty flag */
	uint64_t		did;			/* domain id */
	char			name[ETM_LINE_LEN];	/* temp str */
	char			ldom[ETM_LINE_LEN];	/* ldom id */
	etm_ckpt_erpt_id_t	*p, *s;			/* temp ereport id */
	etm_ckpt_erpt_id_t	blank;			/* blank ereport id */
	etm_ckpt_erpt_buf_t	*ep;			/* ereport buffer */
	size_t			sz;			/* size of ep */
	char			*buf;			/* temp buf */
	nvlist_t		*nvl;			/* ereport */
	etm_iosvc_t		*iosvc;			/* iosvc data struct */

	/*
	 * restore the circular list of ereport ids
	 */
	etm_ckpt_il_restore(hdl);
	if (etm_id_lst == NULL) {
		fmd_hdl_debug(hdl, "Initialize a new id list\n");
		size = sizeof (etm_ckpt_id_list_t) +
		    ETM_CKPT_IL_MIN_SIZE * sizeof (etm_ckpt_erpt_id_t);
		etm_id_lst = fmd_hdl_zalloc(hdl, size, FMD_SLEEP);
		etm_id_lst->il_ver = ETM_CKPT_VERSION;
		etm_id_lst->il_max = ETM_CKPT_IL_MIN_SIZE;
		etm_id_lst->il_head = 0;
		etm_id_lst->il_tail = 0;
		etm_id_lst->il_ids_sz =
		    ETM_CKPT_IL_MIN_SIZE * sizeof (etm_ckpt_erpt_id_t);
		fmd_buf_destroy(hdl, NULL, ETM_CKPT_IL_BUF);
		fmd_buf_create(hdl, NULL, ETM_CKPT_IL_BUF, size);
		fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) etm_id_lst,
		    size);

		/* commit */
		fmd_thr_checkpoint(hdl);

		return;
	}

	/* Empty list */
	if ((etm_id_lst->il_head == etm_id_lst->il_tail) ||
	    (etm_id_lst->il_cnt == 0)) {
		return;
	}

	/* Visit all the entries in the list */
	bzero(&blank, sizeof (blank));
	s = (etm_ckpt_erpt_id_t *)((ptrdiff_t)etm_id_lst +
	    sizeof (etm_ckpt_id_list_t));
	for (i = etm_id_lst->il_head; i != etm_id_lst->il_tail; i = next) {
		next = (i + 1) % etm_id_lst->il_max;
		p = s + next;
		if (etm_ckpt_il_equal(p, &blank)) {
			fmd_hdl_debug(hdl, "Skip empty entry %d\n", i);
			continue;
		}

		etm_ckpt_id2str(p, name, sizeof (name));
		fmd_hdl_debug(hdl, "Restoring entry %s\n", name);
		if ((sz = fmd_buf_size(hdl, NULL, name)) == 0) {
			fmd_hdl_error(hdl, "Clear the stale entry %s\n", name);
			*p = blank;
			continue;
		}
		ep = (etm_ckpt_erpt_buf_t *)fmd_hdl_zalloc(hdl, sz, FMD_SLEEP);
		fmd_buf_read(hdl, NULL, name, (void *) ep, sz);
		buf = (char *)((ptrdiff_t)ep + sizeof (etm_ckpt_erpt_buf_t));
		nvl = NULL;
		if (nvlist_unpack(buf, ep->eb_len, &nvl, 0)) {
			fmd_hdl_debug(hdl, "failed to unpack %s\n", name);
			fmd_hdl_free(hdl, ep, sz);
			continue;
		}
		fmd_hdl_free(hdl, ep, sz);
		if (etm_filter_find_ldom_id(hdl, nvl, ldom, ETM_LINE_LEN,
		    &did) || (strcmp(name, ETM_LDOM_PRIMARY) == 0)) {
			fmd_hdl_debug(hdl, "Discard event %s\n", name);
			fmd_buf_destroy(hdl, NULL, name);
			*p = blank;
			nvlist_free(nvl);
			dirty = B_TRUE;
			continue;
		}

		fmd_hdl_debug(hdl, "Dispatch %s to ldom %s\n", name, ldom);

		/*
		 * Find the queue of the ldom, create it if not exist.
		 * Then insert this event into the queue.
		 */
		iosvc = etm_iosvc_lookup(hdl, ldom, DS_INVALID_HDL, B_TRUE);
		if (iosvc != NULL) {
			(void) etm_pack_ds_msg(hdl, iosvc, NULL, 0, nvl, SP_MSG,
			    ETM_CKPT_RESTORE);
		}
		nvlist_free(nvl);
	}
	if (dirty) {
		/* update the buffer of the queue */
		size = sizeof (etm_ckpt_id_list_t) + etm_id_lst->il_ids_sz;
		fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) etm_id_lst,
		    size);

		/* commit */
		fmd_thr_checkpoint(hdl);
	}

} /* etm_ckpt_recover */


/*
 * etm_ckpt_add_entry()
 * Description:
 *     Save an ereport for persistence.
 */
int
etm_ckpt_add_entry(fmd_hdl_t *hdl, nvlist_t *erpt) {
	etm_ckpt_erpt_id_t	id;
	char			name[ETM_LINE_LEN];
	int			rc;			/* gen use */
	size_t			sz;			/* size */
	size_t			buflen;			/* sz of packed erpt */
	uint8_t			*buf;			/* buffer of erpt */
	etm_ckpt_erpt_buf_t	*hdr;

	/* map ereport to id */
	bzero(name, ETM_LINE_LEN);
	rc = etm_ckpt_erpt2id(hdl, erpt, &id, name, ETM_LINE_LEN);
	if (rc != 0) {
		fmd_hdl_debug(hdl, "Invalid ereport\n");
		return (rc);
	}

	/*
	 * check for a duplicate entry in the id list
	 * find the ereport buffer and search for the id
	 */
	if (fmd_buf_size(hdl, NULL, name) > 0 &&
	    etm_ckpt_il_find(hdl, &id) >= 0) {
		fmd_hdl_debug(hdl, "Duplicate id %s\n", name);
		return (-1);
	}

	/* Create the ereport buffer */
	if (nvlist_size(erpt, &buflen, NV_ENCODE_XDR) != 0) {
		fmd_hdl_debug(hdl, "nvlist_size fails\n");
		return (-1);
	}
	sz = sizeof (etm_ckpt_erpt_buf_t) + buflen;
	hdr = (etm_ckpt_erpt_buf_t *)fmd_hdl_zalloc(hdl, sz, FMD_SLEEP);
	buf = (uint8_t *)((ptrdiff_t)hdr + sizeof (etm_ckpt_erpt_buf_t));
	hdr->eb_ver = ETM_CKPT_VERSION;
	hdr->eb_len = buflen;
	if (nvlist_pack(erpt, (char **)&buf, &buflen, NV_ENCODE_XDR, 0) != 0) {
		fmd_hdl_free(hdl, hdr, sz);
		fmd_hdl_debug(hdl, "unpack fails\n");
		return (-1);
	}
	fmd_hdl_debug(hdl, "Add ckpt event(%s, %d)\n", name, sz);
	fmd_buf_create(hdl, NULL, name, sz);
	fmd_buf_write(hdl, NULL, name, hdr, sz);
	fmd_hdl_free(hdl, hdr, sz);

	/* Insert the ereport id into the id list */
	if (etm_ckpt_il_add(hdl, &id) < 0) {
		fmd_hdl_debug(hdl, "Insert id %s failed\n", name);
		fmd_buf_destroy(hdl, NULL, name);
		return (-1);
	}

	/* update the buffer of the queue */
	sz = sizeof (etm_ckpt_id_list_t) + etm_id_lst->il_ids_sz;
	fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) etm_id_lst, sz);

	/* commit */
	fmd_thr_checkpoint(hdl);

	return (0);
}

/*
 * etm_ckpt_delete_entry()
 * Description:
 *     Delete an ereport id in the list.
 */
static int
etm_ckpt_delete_entry(fmd_hdl_t *hdl, nvlist_t *erpt) {
	etm_ckpt_erpt_id_t	id;
	char			name[ETM_LINE_LEN];
	int			rc;			/* return code */
	size_t			sz;			/* size */

	/* get id, id name */
	bzero(name, ETM_LINE_LEN);
	if (etm_ckpt_erpt2id(hdl, erpt, &id, name, ETM_LINE_LEN) != 0) {
		fmd_hdl_debug(hdl, "Invalid ereport\n");
		return (-1);
	}
	fmd_hdl_debug(hdl, "Delete ckpt event(%s)\n", name);

	/* delete the ereport buffer */
	if (fmd_buf_size(hdl, NULL, name) > 0) {
		fmd_buf_destroy(hdl, NULL, name);
	}

	rc = etm_ckpt_il_delete(hdl, &id);
	if (rc < 0) {
		fmd_hdl_debug(hdl, "Delete id %s failed\n", name);
		return (rc);
	}

	/* update the buffer of the queue */
	sz = sizeof (etm_ckpt_id_list_t) + etm_id_lst->il_ids_sz;
	fmd_buf_write(hdl, NULL, ETM_CKPT_IL_BUF, (void *) etm_id_lst, sz);

	/* commit */
	fmd_thr_checkpoint(hdl);

	return (rc);
}

int
etm_ckpt_add(fmd_hdl_t *hdl, nvlist_t *erpt) {

	int		rc;		/* return code */

	(void) pthread_mutex_lock(&etm_id_lst_lock);

	rc = etm_ckpt_add_entry(hdl, erpt);

	(void) pthread_mutex_unlock(&etm_id_lst_lock);

	return (rc >= 0 ? 0 : rc);
}

int
etm_ckpt_delete(fmd_hdl_t *hdl, nvlist_t *erpt) {
	int		rc;		/* return code */

	(void) pthread_mutex_lock(&etm_id_lst_lock);

	rc = etm_ckpt_delete_entry(hdl, erpt);

	(void) pthread_mutex_unlock(&etm_id_lst_lock);

	return (rc >= 0 ? 0 : rc);
}

/* ARGSUSED */
void
etm_ckpt_init(fmd_hdl_t *hdl) {
	(void) pthread_mutex_init(&etm_id_lst_lock, NULL);
	etm_id_lst = NULL;
}

void
etm_ckpt_fini(fmd_hdl_t *hdl) {
	if (etm_id_lst != NULL) {
		fmd_hdl_free(hdl, etm_id_lst,
		    sizeof (etm_ckpt_id_list_t) + etm_id_lst->il_ids_sz);
	}
	(void) pthread_mutex_destroy(&etm_id_lst_lock);
}