OpenSolaris_b135/lib/libpool/common/pool_kernel.c
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <assert.h>
#include <errno.h>
#include <exacct.h>
#include <fcntl.h>
#include <libnvpair.h>
#include <limits.h>
#include <poll.h>
#include <pool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stropts.h>
#include <thread.h>
#include <time.h>
#include <unistd.h>
#include <libxml/tree.h>
#include <sys/mman.h>
#include <sys/pool.h>
#include <sys/pool_impl.h>
#include <sys/priocntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include "dict.h"
#include "pool_internal.h"
#include "pool_impl.h"
#include "pool_kernel_impl.h"
/*
* libpool kernel Manipulation Routines
*
* pool_kernel.c implements the kernel manipulation routines used by the
* libpool kernel datastore. The functions are grouped into the following
* logical areas
*
*/
/*
* Device snapshot transfer buffer size
*/
#define KERNEL_SNAPSHOT_BUF_SZ 65535
/*
* Kernel result set's initial size. 8 is probably large enough for
* most queries. Queries requiring more space are accomodated using
* realloc on a per result set basis.
*/
#define KERNEL_RS_INITIAL_SZ 8
/*
* Property manipulation macros
*/
#define KERNEL_PROP_RDONLY 0x1
/*
* Information required to evaluate qualifying elements for a query
*/
struct query_obj {
const pool_conf_t *conf;
const pool_elem_t *src;
const char *src_attr;
pool_elem_class_t classes;
pool_value_t **props;
pool_knl_result_set_t *rs;
};
/*
* Identifies a pool element with a processor set id
*/
typedef struct pool_set_xref {
pool_knl_pool_t *psx_pool;
uint_t psx_pset_id;
struct pool_set_xref *psx_next;
} pool_set_xref_t;
/*
* Controls exacct snapshot load into libpool data structure
*/
typedef struct pool_snap_load {
int *psl_changed;
pool_set_xref_t *psl_xref;
pool_elem_t *psl_system;
pool_knl_resource_t *psl_pset;
} pool_snap_load_t;
/*
* Information about an XML document which is being constructed
*/
struct knl_to_xml {
xmlDocPtr ktx_doc;
xmlNodePtr ktx_node;
};
/*
* Undo structure processing. The following structures are all used to
* allow changes to the libpool snapshot and kernel following an
* unsuccessful commit.
*/
typedef struct pool_create_undo {
pool_create_t pcu_ioctl;
pool_elem_t *pcu_elem;
} pool_create_undo_t;
typedef struct pool_destroy_undo {
pool_destroy_t pdu_ioctl;
pool_elem_t *pdu_elem;
} pool_destroy_undo_t;
typedef struct pool_assoc_undo {
pool_assoc_t pau_ioctl;
pool_elem_t *pau_assoc;
pool_elem_t *pau_oldres;
pool_elem_t *pau_newres;
} pool_assoc_undo_t;
typedef struct pool_dissoc_undo {
pool_dissoc_t pdu_ioctl;
pool_elem_t *pdu_dissoc;
pool_elem_t *pdu_oldres;
pool_elem_t *pdu_newres;
} pool_dissoc_undo_t;
typedef struct pool_xtransfer_undo {
pool_xtransfer_t pxu_ioctl;
pool_elem_t *pxu_src;
pool_elem_t *pxu_tgt;
pool_component_t **pxu_rl;
} pool_xtransfer_undo_t;
typedef struct pool_propput_undo {
pool_propput_t ppu_ioctl;
pool_elem_t *ppu_elem;
nvlist_t *ppu_alist;
nvlist_t *ppu_blist;
uchar_t ppu_doioctl;
} pool_propput_undo_t;
typedef struct pool_proprm_undo {
pool_proprm_t pru_ioctl;
pool_elem_t *pru_elem;
pool_value_t pru_oldval;
} pool_proprm_undo_t;
extern const char *dtd_location;
extern const char *element_class_tags[];
extern const char pool_info_location[];
/*
* These functions are defined in pool_xml.c and represent the minimum
* XML support required to allow a pool kernel configuration to be
* exported as an XML document.
*/
extern int pool_xml_set_attr(xmlNodePtr, xmlChar *, const pool_value_t *);
extern int pool_xml_set_prop(xmlNodePtr, xmlChar *, const pool_value_t *);
extern void xml_init(void);
extern xmlNodePtr node_create(xmlNodePtr, const xmlChar *);
extern void pool_error_func(void *, const char *, ...);
/*
* Utilities
*/
static int load_group(pool_conf_t *, pool_knl_elem_t *, ea_object_t *,
pool_snap_load_t *);
static void pool_knl_elem_free(pool_knl_elem_t *, int);
static int pool_knl_put_xml_property(pool_elem_t *, xmlNodePtr, const char *,
const pool_value_t *);
static int pool_knl_snap_load_push(pool_snap_load_t *, pool_knl_pool_t *);
static int pool_knl_snap_load_update(pool_snap_load_t *, int, uint_t);
static int pool_knl_snap_load_remove(pool_snap_load_t *, int, uint_t);
static nvpair_t *pool_knl_find_nvpair(nvlist_t *, const char *);
static int pool_knl_nvlist_add_value(nvlist_t *, const char *,
const pool_value_t *);
static int pool_knl_recover(pool_conf_t *);
static uint64_t hash_id(const pool_elem_t *);
static int blocking_open(const char *, int);
/*
* Connections
*/
static void pool_knl_connection_free(pool_knl_connection_t *);
/*
* Configuration
*/
static int pool_knl_close(pool_conf_t *);
static int pool_knl_validate(const pool_conf_t *, pool_valid_level_t);
static int pool_knl_commit(pool_conf_t *);
static int pool_knl_export(const pool_conf_t *, const char *,
pool_export_format_t);
static int pool_knl_rollback(pool_conf_t *);
static pool_result_set_t *pool_knl_exec_query(const pool_conf_t *,
const pool_elem_t *, const char *, pool_elem_class_t, pool_value_t **);
static int pool_knl_remove(pool_conf_t *);
static char *pool_knl_get_binding(pool_conf_t *, pid_t);
static int pool_knl_set_binding(pool_conf_t *, const char *, idtype_t, id_t);
static char *pool_knl_get_resource_binding(pool_conf_t *,
pool_resource_elem_class_t, pid_t);
static int pool_knl_res_transfer(pool_resource_t *, pool_resource_t *,
uint64_t);
static int pool_knl_res_xtransfer(pool_resource_t *, pool_resource_t *,
pool_component_t **);
/*
* Result Sets
*/
static pool_knl_result_set_t *pool_knl_result_set_alloc(const pool_conf_t *);
static int pool_knl_result_set_append(pool_knl_result_set_t *,
pool_knl_elem_t *);
static int pool_knl_result_set_realloc(pool_knl_result_set_t *);
static void pool_knl_result_set_free(pool_knl_result_set_t *);
static pool_elem_t *pool_knl_rs_next(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_prev(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_first(pool_result_set_t *);
static pool_elem_t *pool_knl_rs_last(pool_result_set_t *);
static int pool_knl_rs_set_index(pool_result_set_t *, int);
static int pool_knl_rs_get_index(pool_result_set_t *);
static int pool_knl_rs_count(pool_result_set_t *);
static int pool_knl_rs_close(pool_result_set_t *);
/*
* Element (and sub-type)
*/
static pool_knl_elem_t *pool_knl_elem_wrap(pool_conf_t *, pool_elem_class_t,
pool_resource_elem_class_t, pool_component_elem_class_t);
static pool_elem_t *pool_knl_elem_create(pool_conf_t *, pool_elem_class_t,
pool_resource_elem_class_t, pool_component_elem_class_t);
static int pool_knl_elem_remove(pool_elem_t *);
static int pool_knl_set_container(pool_elem_t *, pool_elem_t *);
static pool_elem_t *pool_knl_get_container(const pool_elem_t *);
/*
* Pool element specific
*/
static int pool_knl_pool_associate(pool_t *, const pool_resource_t *);
static int pool_knl_pool_dissociate(pool_t *, const pool_resource_t *);
/*
* Resource elements specific
*/
static int pool_knl_resource_is_system(const pool_resource_t *);
static int pool_knl_resource_can_associate(const pool_resource_t *);
/* Properties */
static pool_value_class_t pool_knl_get_property(const pool_elem_t *,
const char *, pool_value_t *);
static pool_value_class_t pool_knl_get_dynamic_property(const pool_elem_t *,
const char *, pool_value_t *);
static int pool_knl_put_property(pool_elem_t *, const char *,
const pool_value_t *);
static int pool_knl_rm_property(pool_elem_t *, const char *);
static pool_value_t **pool_knl_get_properties(const pool_elem_t *, uint_t *);
/*
* Logging
*/
static int log_item_commit(log_item_t *);
static int log_item_undo(log_item_t *);
static int log_item_release(log_item_t *);
/*
* Utilities
*/
/*
* load_group() updates the library configuration with the kernel
* snapshot supplied in ep. The function is designed to be called
* recursively. This function depends implicitly on the ordering of
* the data provided in ep. Changes to the ordering of data in ep must
* be matched by changes to this function.
*/
int
load_group(pool_conf_t *conf, pool_knl_elem_t *elem, ea_object_t *ep,
pool_snap_load_t *psl)
{
ea_object_t *eo;
pool_knl_elem_t *old_elem;
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
int ret = PO_SUCCESS;
if ((ep->eo_catalog & EXD_DATA_MASK) == EXD_GROUP_SYSTEM) {
if ((elem = pool_knl_elem_wrap(conf, PEC_SYSTEM, PREC_INVALID,
PCEC_INVALID)) == NULL)
return (PO_FAIL);
if (nvlist_alloc(&elem->pke_properties, NV_UNIQUE_NAME_TYPE,
0) != 0) {
pool_knl_elem_free(elem, PO_FALSE);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Check to see if we already have an element
* for this data. If we have, free the newly
* created elem and continue with the old one
*/
if ((old_elem = dict_get(prov->pkc_elements, elem)) != NULL) {
nvlist_free(old_elem->pke_properties);
old_elem->pke_properties = elem->pke_properties;
pool_knl_elem_free(elem, PO_FALSE);
elem = old_elem;
} else {
if (dict_put(prov->pkc_elements, elem, elem) != NULL) {
pool_knl_elem_free(elem, PO_TRUE);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
psl->psl_system = (pool_elem_t *)elem;
}
for (eo = ep->eo_group.eg_objs; eo != NULL; eo = eo->eo_next) {
int data;
pool_knl_elem_t *prop_elem = NULL;
data = (eo->eo_catalog & EXD_DATA_MASK);
switch (data) {
case EXD_SYSTEM_TSTAMP:
case EXD_POOL_TSTAMP:
case EXD_PSET_TSTAMP:
case EXD_CPU_TSTAMP:
if (eo->eo_item.ei_uint64 > prov->pkc_lotime) {
if (eo->eo_item.ei_uint64 > prov->pkc_ltime)
prov->pkc_ltime = eo->eo_item.ei_uint64;
if (psl->psl_changed) {
switch (data) {
case EXD_SYSTEM_TSTAMP:
*psl->psl_changed |= POU_SYSTEM;
break;
case EXD_POOL_TSTAMP:
*psl->psl_changed |= POU_POOL;
break;
case EXD_PSET_TSTAMP:
*psl->psl_changed |= POU_PSET;
break;
case EXD_CPU_TSTAMP:
*psl->psl_changed |= POU_CPU;
break;
}
}
}
break;
case EXD_SYSTEM_PROP:
case EXD_POOL_PROP:
case EXD_PSET_PROP:
case EXD_CPU_PROP:
if (data == EXD_PSET_PROP) {
prop_elem = elem;
elem = (pool_knl_elem_t *)psl->psl_pset;
}
nvlist_free(elem->pke_properties);
if (nvlist_unpack(eo->eo_item.ei_raw,
eo->eo_item.ei_size, &elem->pke_properties, 0) !=
0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
elem->pke_ltime = prov->pkc_ltime;
if (data == EXD_PSET_PROP) {
elem = prop_elem;
}
break;
case EXD_POOL_POOLID:
if (nvlist_alloc(&elem->pke_properties,
NV_UNIQUE_NAME_TYPE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_add_int64(elem->pke_properties,
"pool.sys_id",
(int64_t)eo->eo_item.ei_uint32) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
NULL) {
nvlist_free(old_elem->pke_properties);
old_elem->pke_properties = elem->pke_properties;
pool_knl_elem_free(elem, PO_FALSE);
elem = old_elem;
} else {
if (dict_put(prov->pkc_elements, elem, elem) !=
NULL) {
pool_knl_elem_free(elem, PO_TRUE);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
if (pool_knl_snap_load_push(psl,
(pool_knl_pool_t *)elem) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
((pool_knl_pool_t *)elem)->pkp_assoc[PREC_PSET] = NULL;
break;
case EXD_POOL_PSETID:
if (pool_knl_snap_load_update(psl, EXD_POOL_PSETID,
eo->eo_item.ei_uint32) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case EXD_PSET_PSETID:
if (nvlist_alloc(&elem->pke_properties,
NV_UNIQUE_NAME_TYPE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_add_int64(elem->pke_properties,
"pset.sys_id",
(int64_t)eo->eo_item.ei_uint32) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
NULL) {
nvlist_free(old_elem->pke_properties);
old_elem->pke_properties = elem->pke_properties;
pool_knl_elem_free(elem, PO_FALSE);
elem = old_elem;
} else {
if (dict_put(prov->pkc_elements, elem, elem) !=
NULL) {
pool_knl_elem_free(elem, PO_TRUE);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
psl->psl_pset = (pool_knl_resource_t *)elem;
if (pool_knl_snap_load_remove(psl, data,
eo->eo_item.ei_uint32) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case EXD_CPU_CPUID:
if (nvlist_alloc(&elem->pke_properties,
NV_UNIQUE_NAME_TYPE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_add_int64(elem->pke_properties,
"cpu.sys_id",
(int64_t)eo->eo_item.ei_uint32) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((old_elem = dict_get(prov->pkc_elements, elem)) !=
NULL) {
nvlist_free(old_elem->pke_properties);
old_elem->pke_properties = elem->pke_properties;
old_elem->pke_parent = elem->pke_parent;
pool_knl_elem_free(elem, PO_FALSE);
elem = old_elem;
} else {
if (dict_put(prov->pkc_elements, elem, elem) !=
NULL) {
pool_knl_elem_free(elem, PO_TRUE);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
break;
case EXD_GROUP_POOL:
if ((elem = pool_knl_elem_wrap(conf, PEC_POOL,
PREC_INVALID, PCEC_INVALID)) == NULL)
return (PO_FAIL);
if (pool_set_container(psl->psl_system,
(pool_elem_t *)elem) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case EXD_GROUP_PSET:
if ((elem = pool_knl_elem_wrap(conf, PEC_RES_COMP,
PREC_PSET, PCEC_INVALID)) == NULL)
return (PO_FAIL);
if (pool_set_container(psl->psl_system,
(pool_elem_t *)elem) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case EXD_GROUP_CPU:
if ((elem = pool_knl_elem_wrap(conf, PEC_COMP,
PREC_INVALID, PCEC_CPU)) == NULL)
return (PO_FAIL);
if (pool_set_container((pool_elem_t *)psl->psl_pset,
(pool_elem_t *)elem) != PO_SUCCESS) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
default:
break;
}
if (eo->eo_type == EO_GROUP) {
if ((ret = load_group(conf, elem, eo, psl)) == PO_FAIL)
break;
}
}
return (ret);
}
/*
* Push a snapshot entry onto the list of pools in the snapshot.
*/
int
pool_knl_snap_load_push(pool_snap_load_t *psl, pool_knl_pool_t *pkp)
{
pool_set_xref_t *psx;
if ((psx = malloc(sizeof (pool_set_xref_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(psx, 0, sizeof (pool_set_xref_t));
psx->psx_pool = pkp;
/*
* Push onto the list of pools
*/
psx->psx_next = psl->psl_xref;
psl->psl_xref = psx;
return (PO_SUCCESS);
}
/*
* Update the current cross-reference for the supplied type of
* resource.
*/
int
pool_knl_snap_load_update(pool_snap_load_t *psl, int type, uint_t id)
{
switch (type) {
case EXD_POOL_PSETID:
psl->psl_xref->psx_pset_id = id;
break;
default:
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Remove a resource entry with the supplied type and id from the
* snapshot list when it is no longer required.
*/
int
pool_knl_snap_load_remove(pool_snap_load_t *psl, int type, uint_t id)
{
pool_set_xref_t *current, *prev, *next;
for (prev = NULL, current = psl->psl_xref; current != NULL;
current = next) {
switch (type) {
case EXD_PSET_PSETID:
if (current->psx_pset_id == id)
current->psx_pool->pkp_assoc[PREC_PSET] =
psl->psl_pset;
break;
default:
return (PO_FAIL);
}
next = current->psx_next;
if (current->psx_pool->pkp_assoc[PREC_PSET] != NULL) {
if (prev != NULL) {
prev->psx_next = current->psx_next;
} else {
psl->psl_xref = current->psx_next;
}
free(current);
} else
prev = current;
}
return (PO_SUCCESS);
}
/*
* Return the nvpair with the supplied name from the supplied list.
*
* NULL is returned if the name cannot be found in the list.
*/
nvpair_t *
pool_knl_find_nvpair(nvlist_t *l, const char *name)
{
nvpair_t *pair;
for (pair = nvlist_next_nvpair(l, NULL); pair != NULL;
pair = nvlist_next_nvpair(l, pair)) {
if (strcmp(nvpair_name(pair), name) == 0)
break;
}
return (pair);
}
/*
* Close the configuration. There are a few steps to closing a configuration:
* - Close the pseudo device
* - Free the data provider
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_close(pool_conf_t *conf)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
if (close(prov->pkc_fd) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Rollback any pending changes before freeing the prov. This
* ensures there are no memory leaks from pending transactions.
* However, don't rollback when we've done a temporary pool since the
* pool/resources haven't really been committed in this case.
* They will all be freed in pool_knl_connection_free and we don't
* want to double free them.
*/
if (!(conf->pc_prov->pc_oflags & PO_TEMP))
(void) pool_knl_rollback(conf);
pool_knl_connection_free(prov);
return (PO_SUCCESS);
}
/*
* Remove elements in this map (previously identified as "dead") from
* the configuration map (prov->pkc_elements).
*/
/* ARGSUSED1 */
static void
remove_dead_elems(const void *key, void **value, void *cl)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
assert(dict_remove(prov->pkc_elements, pke) != NULL);
#ifdef DEBUG
dprintf("remove_dead_elems:\n");
pool_elem_dprintf(TO_ELEM(pke));
#endif /* DEBUG */
pool_knl_elem_free(pke, PO_TRUE);
}
/*
* Find elements which were not updated the last time that
* load_group() was called. Add those elements into a separate map
* (passed in cl) which will be later used to remove these elements
* from the configuration map.
*/
/* ARGSUSED1 */
static void
find_dead_elems(const void *key, void **value, void *cl)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
dict_hdl_t *dead_map = (dict_hdl_t *)cl;
if (pke->pke_ltime < prov->pkc_ltime)
(void) dict_put(dead_map, pke, pke);
}
/*
* Update the snapshot held by the library. This function acts as the
* controller for the snapshot update procedure. Then snapshot is
* actually updated in multiple phases by the load_group() function
* (which updates existing elements and creates new elements as
* required) and then by find_dead_elems and remove_dead_elems
* (respectively responsible for identifying elements which are to be
* removed and then removing them).
*
* Returns PO_SUCCESS
*/
int
pool_knl_update(pool_conf_t *conf, int *changed)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
pool_query_t query = {0};
ea_object_t *ep;
dict_hdl_t *dead_map;
pool_snap_load_t psl = { NULL };
/*
* Ensure the library snapshot is consistent, if there are any
* outstanding transactions return failure.
*/
if (log_size(prov->pkc_log) != 0) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
/*
* Query the kernel for a snapshot of the configuration state. Use
* load_group to allocate the user-land representation of the
* data returned in the snapshot.
*/
/* LINTED E_CONSTANT_CONDITION */
while (1) {
if (ioctl(prov->pkc_fd, POOL_QUERY, &query) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((query.pq_io_buf = calloc(1,
(query.pq_io_bufsize < KERNEL_SNAPSHOT_BUF_SZ) ?
query.pq_io_bufsize * 2 : query.pq_io_bufsize)) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (ioctl(prov->pkc_fd, POOL_QUERY, &query) < 0) {
free(query.pq_io_buf);
if (errno != ENOMEM) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
query.pq_io_bufsize = 0;
query.pq_io_buf = NULL;
} else
break;
}
if (ea_unpack_object(&ep, EUP_NOALLOC, query.pq_io_buf,
query.pq_io_bufsize) != EO_GROUP) {
free(query.pq_io_buf);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
/*
* Update the library snapshot
*/
psl.psl_changed = changed;
prov->pkc_lotime = prov->pkc_ltime;
if (load_group(conf, NULL, ep, &psl) != PO_SUCCESS) {
free(query.pq_io_buf);
ea_free_object(ep, EUP_NOALLOC);
return (PO_FAIL);
}
free(query.pq_io_buf);
ea_free_object(ep, EUP_NOALLOC);
/*
* Now search the dictionary for items that must be removed because
* they were neither created nor updated.
*/
if ((dead_map = dict_new((int (*)(const void *, const void *))
pool_elem_compare, (uint64_t (*)(const void *))hash_id)) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
dict_map(prov->pkc_elements, find_dead_elems, dead_map);
if (dict_length(dead_map) > 0) {
dict_map(dead_map, remove_dead_elems, NULL);
}
dict_free(&dead_map);
return (PO_SUCCESS);
}
/*
* Rely on the kernel to always keep a kernel configuration valid.
* Returns PO_SUCCESS
*/
/* ARGSUSED */
int
pool_knl_validate(const pool_conf_t *conf, pool_valid_level_t level)
{
return ((conf->pc_state == POF_INVALID) ? PO_FAIL : PO_SUCCESS);
}
/*
* Process all the outstanding transactions in the log. If the processing
* fails, then attempt to rollback and "undo" the changes.
*/
int
pool_knl_commit(pool_conf_t *conf)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
int lock = 1;
/*
* Lock the kernel state for the commit
*/
if (ioctl(prov->pkc_fd, POOL_COMMIT, lock) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
lock = 0;
/*
* If the state is LS_FAIL, then try to recover before
* performing the commit.
*/
if (prov->pkc_log->l_state == LS_FAIL) {
if (pool_knl_recover(conf) == PO_FAIL) {
/*
* Unlock the kernel state for the
* commit. Assert that this * can't fail,
* since if it ever does fail the library is
* unusable.
*/
assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
}
}
/*
* Commit the log
*/
if (log_walk(prov->pkc_log, log_item_commit) != PO_SUCCESS) {
(void) pool_knl_recover(conf);
/*
* Unlock the kernel state for the commit. Assert that
* this can't fail, since if it ever does fail the
* library is unusable.
*/
assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Unlock the kernel state for the commit. Assert that this
* can't fail, since if it ever does fail the library is
* unusable.
*/
assert(ioctl(prov->pkc_fd, POOL_COMMIT, lock) >= 0);
/*
* Release the log resources
*/
(void) log_walk(prov->pkc_log, log_item_release);
log_empty(prov->pkc_log);
return (PO_SUCCESS);
}
/*
* prop_build_cb() is designed to be called from
* pool_walk_properties(). The property value is used to put an XML
* property on the supplied ktx_node. This is an essential part of the
* mechanism used to export a kernel configuration in libpool XML
* form.
*/
/* ARGSUSED */
static int
prop_build_cb(pool_conf_t *UNUSED, pool_elem_t *pe, const char *name,
pool_value_t *pval, void *user)
{
struct knl_to_xml *info = (struct knl_to_xml *)user;
return (pool_knl_put_xml_property((pool_elem_t *)pe, info->ktx_node,
name, pval));
}
/*
* Duplicate some of the functionality from pool_xml_put_property()
* (see pool_xml.c) to allow a kernel configuration to add XML nodes
* to an XML tree which represents the kernel configuration. This is
* an essential part of the mechanism used to export a kernel
* configuration in libpool XML form.
*/
int
pool_knl_put_xml_property(pool_elem_t *pe, xmlNodePtr node, const char *name,
const pool_value_t *val)
{
/*
* "type" is a special attribute which is not visible ever outside of
* libpool. Use the specific type accessor function.
*/
if (strcmp(name, c_type) == 0) {
return (pool_xml_set_attr(node, BAD_CAST name,
val));
}
if (is_ns_property(pe, name) != NULL) { /* in ns */
if (pool_xml_set_attr(node,
BAD_CAST property_name_minus_ns(pe, name), val) == PO_FAIL)
return (pool_xml_set_prop(node, BAD_CAST name,
val));
} else
return (pool_xml_set_prop(node, BAD_CAST name, val));
return (PO_SUCCESS);
}
/*
* Export the kernel configuration as an XML file. The configuration
* is used to build an XML document in memory. This document is then
* saved to the supplied location.
*/
int
pool_knl_export(const pool_conf_t *conf, const char *location,
pool_export_format_t fmt)
{
xmlNodePtr node_comment;
xmlNodePtr system;
int ret;
pool_t **ps;
pool_resource_t **rs;
uint_t nelem;
int i;
struct knl_to_xml info;
char_buf_t *cb = NULL;
xmlValidCtxtPtr cvp;
xml_init();
switch (fmt) {
case POX_NATIVE:
info.ktx_doc = xmlNewDoc(BAD_CAST "1.0");
(void) xmlCreateIntSubset(info.ktx_doc, BAD_CAST "system",
BAD_CAST "-//Sun Microsystems Inc//DTD Resource "
"Management All//EN",
BAD_CAST dtd_location);
if ((cvp = xmlNewValidCtxt()) == NULL) {
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
/*
* Call xmlValidateDocument() to force the parsing of
* the DTD. Ignore errors and warning messages as we
* know the document isn't valid.
*/
(void) xmlValidateDocument(cvp, info.ktx_doc);
xmlFreeValidCtxt(cvp);
if ((info.ktx_node = node_create(NULL, BAD_CAST "system")) ==
NULL) {
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
system = info.ktx_node;
info.ktx_doc->_private = (void *)conf;
(void) xmlDocSetRootElement(info.ktx_doc, info.ktx_node);
(void) xmlSetProp(info.ktx_node, BAD_CAST c_ref_id,
BAD_CAST "dummy");
if ((node_comment = xmlNewDocComment(info.ktx_doc,
BAD_CAST "\nConfiguration for pools facility. Do NOT"
" edit this file by hand - use poolcfg(1)"
" or libpool(3POOL) instead.\n")) == NULL) {
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if (xmlAddPrevSibling(info.ktx_node, node_comment) == NULL) {
xmlFree(node_comment);
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if (pool_walk_any_properties((pool_conf_t *)conf,
pool_conf_to_elem(conf), &info, prop_build_cb, 1) ==
PO_FAIL) {
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
/*
* Now add pool details
*/
if ((ps = pool_query_pools(conf, &nelem, NULL)) != NULL) {
for (i = 0; i < nelem; i++) {
pool_elem_t *elem = TO_ELEM(ps[i]);
uint_t nreselem;
const char *sep = "";
int j;
if (elem_is_tmp(elem))
continue;
if ((info.ktx_node = node_create(system,
BAD_CAST element_class_tags
[pool_elem_class(elem)])) == NULL) {
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if (pool_walk_any_properties(
(pool_conf_t *)conf,
elem, &info, prop_build_cb, 1) == PO_FAIL) {
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
/*
* TODO: pset specific res manipulation
*/
if ((rs = pool_query_pool_resources(conf, ps[i],
&nreselem, NULL)) == NULL) {
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
if (set_char_buf(cb, "") == PO_FAIL) {
free(rs);
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
for (j = 0; j < nreselem; j++) {
pool_elem_t *reselem = TO_ELEM(rs[j]);
if (append_char_buf(cb, "%s%s_%d", sep,
pool_elem_class_string(reselem),
(int)elem_get_sysid(reselem)) ==
PO_FAIL) {
free(rs);
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
sep = " ";
}
free(rs);
(void) xmlSetProp(info.ktx_node, BAD_CAST "res",
BAD_CAST cb->cb_buf);
if (set_char_buf(cb, "%s_%d",
pool_elem_class_string(elem),
(int)elem_get_sysid(elem)) == PO_FAIL) {
free(ps);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
(void) xmlSetProp(info.ktx_node,
BAD_CAST c_ref_id,
BAD_CAST cb->cb_buf);
}
free(ps);
}
/*
* Now add resource details (including components)
*/
if ((rs = pool_query_resources(conf, &nelem, NULL)) != NULL) {
for (i = 0; i < nelem; i++) {
pool_elem_t *elem = TO_ELEM(rs[i]);
pool_component_t **cs = NULL;
uint_t ncompelem;
int j;
if (elem_is_tmp(elem))
continue;
if ((info.ktx_node = node_create(system,
BAD_CAST element_class_tags
[pool_elem_class(elem)])) == NULL) {
free(rs);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
if (pool_walk_any_properties(
(pool_conf_t *)conf,
elem, &info, prop_build_cb, 1) == PO_FAIL) {
free(rs);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
if (set_char_buf(cb, "%s_%d",
pool_elem_class_string(elem),
(int)elem_get_sysid(elem)) == PO_FAIL) {
free(rs);
free_char_buf(cb);
xmlFreeDoc(info.ktx_doc);
return (PO_FAIL);
}
(void) xmlSetProp(info.ktx_node,
BAD_CAST c_ref_id,
BAD_CAST cb->cb_buf);
if ((cs = pool_query_resource_components(conf,
rs[i], &ncompelem, NULL)) != NULL) {
xmlNodePtr resource = info.ktx_node;
for (j = 0; j < ncompelem; j++) {
pool_elem_t *compelem =
TO_ELEM(cs[j]);
if ((info.ktx_node =
node_create(resource,
BAD_CAST element_class_tags
[pool_elem_class(
compelem)])) == NULL) {
pool_seterror(
POE_DATASTORE);
free(rs);
free(cs);
free_char_buf(cb);
xmlFreeDoc(info.
ktx_doc);
return (PO_FAIL);
}
if (pool_walk_any_properties(
(pool_conf_t *)conf,
compelem, &info,
prop_build_cb, 1) ==
PO_FAIL) {
free(rs);
free(cs);
free_char_buf(cb);
xmlFreeDoc(info.
ktx_doc);
return (PO_FAIL);
}
if (set_char_buf(cb, "%s_%d",
pool_elem_class_string(
compelem),
(int)elem_get_sysid(
compelem)) == PO_FAIL) {
free(rs);
free(cs);
free_char_buf(cb);
xmlFreeDoc(info.
ktx_doc);
return (PO_FAIL);
}
(void) xmlSetProp(info.ktx_node,
BAD_CAST c_ref_id,
BAD_CAST cb->cb_buf);
}
free(cs);
}
}
free(rs);
}
free_char_buf(cb);
/*
* Set up the message handlers prior to calling
* xmlValidateDocument()
*/
if ((cvp = xmlNewValidCtxt()) == NULL) {
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_DATASTORE);
return (PO_FAIL);
}
cvp->error = pool_error_func;
cvp->warning = pool_error_func;
if (xmlValidateDocument(cvp, info.ktx_doc) == 0) {
xmlFreeValidCtxt(cvp);
xmlFreeDoc(info.ktx_doc);
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
xmlFreeValidCtxt(cvp);
ret = xmlSaveFormatFile(location, info.ktx_doc, 1);
xmlFreeDoc(info.ktx_doc);
if (ret == -1) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
return (PO_SUCCESS);
default:
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
}
/*
* Rollback the changes to the kernel
*/
int
pool_knl_recover(pool_conf_t *conf)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
prov->pkc_log->l_state = LS_RECOVER;
if (log_reverse_walk(prov->pkc_log, log_item_undo) != PO_SUCCESS) {
dprintf("Library configuration consistency error\n");
prov->pkc_log->l_state = LS_FAIL;
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
prov->pkc_log->l_state = LS_DO;
return (PO_SUCCESS);
}
/*
* Rollback the changes to the configuration
*/
int
pool_knl_rollback(pool_conf_t *conf)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
prov->pkc_log->l_state = LS_UNDO;
if (log_reverse_walk(prov->pkc_log, log_item_undo) != PO_SUCCESS) {
dprintf("Kernel configuration consistency error\n");
(void) log_walk(prov->pkc_log, log_item_release);
log_empty(prov->pkc_log);
prov->pkc_log->l_state = LS_FAIL;
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
(void) log_walk(prov->pkc_log, log_item_release);
log_empty(prov->pkc_log);
prov->pkc_log->l_state = LS_DO;
return (PO_SUCCESS);
}
/*
* Callback used to build the result set for a query. Each invocation will
* supply a candidate element for inclusion. The element is filtered by:
* - class
* - properties
* If the element "matches" the target, then it is added to the result
* set, otherwise it is ignored.
*/
/* ARGSUSED1 */
static void
build_result_set(const void *key, void **value, void *cl)
{
struct query_obj *qo = (struct query_obj *)cl;
pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
/*
* Check to see if it's the right class of element
*/
if (qo->classes & (1 << pool_elem_class((pool_elem_t *)key))) {
int i;
/*
* Now check to see if the src element is correct. If no src
* element is supplied, ignore this check
*/
if (qo->src) {
pool_knl_elem_t *parent;
for (parent = pke; parent != NULL;
parent = parent->pke_parent) {
if (parent == (pool_knl_elem_t *)qo->src)
break;
}
if (parent == NULL)
return;
}
/*
* Now check for property matches (if there are any specified)
*/
if (qo->props) {
int matched = PO_TRUE;
for (i = 0; qo->props[i] != NULL; i++) {
pool_value_t val = POOL_VALUE_INITIALIZER;
if (pool_get_property(TO_CONF(TO_ELEM(pke)),
(pool_elem_t *)pke,
pool_value_get_name(qo->props[i]), &val) ==
POC_INVAL) {
matched = PO_FALSE;
break;
} else {
if (pool_value_equal(qo->props[i],
&val) != PO_TRUE) {
matched = PO_FALSE;
break;
}
}
}
if (matched == PO_TRUE)
(void) pool_knl_result_set_append(qo->rs,
(pool_knl_elem_t *)key);
} else {
(void) pool_knl_result_set_append(qo->rs,
(pool_knl_elem_t *)key);
}
}
}
/*
* Execute the supplied query and return a result set which contains
* all qualifying elements.
*/
pool_result_set_t *
pool_knl_exec_query(const pool_conf_t *conf, const pool_elem_t *src,
const char *src_attr, pool_elem_class_t classes, pool_value_t **props)
{
pool_knl_result_set_t *rs;
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
struct query_obj qo;
int matched = PO_TRUE;
/*
* Have a buffer at this point, that we can use
*/
if ((rs = pool_knl_result_set_alloc(conf)) == NULL) {
return (NULL);
}
qo.conf = conf;
qo.src = src;
qo.src_attr = src_attr;
qo.classes = classes;
qo.props = props;
qo.rs = rs;
if (src_attr != NULL) {
pool_knl_pool_t *pkp = (pool_knl_pool_t *)src;
/*
* Note: This logic is resource specific and must be
* extended for additional resource types.
*/
/*
* Check for property matches (if there are any specified)
*/
if (props) {
int i;
for (i = 0; props[i] != NULL; i++) {
pool_value_t val = POOL_VALUE_INITIALIZER;
if (pool_get_property(conf,
(pool_elem_t *)pkp->pkp_assoc[PREC_PSET],
pool_value_get_name(props[i]), &val) ==
POC_INVAL) {
matched = PO_FALSE;
break;
} else {
if (pool_value_equal(props[i],
&val) != PO_TRUE) {
matched = PO_FALSE;
break;
}
}
}
}
if (matched == PO_TRUE)
(void) pool_knl_result_set_append(rs,
(pool_knl_elem_t *)pkp->pkp_assoc[PREC_PSET]);
} else
dict_map(prov->pkc_elements, build_result_set, &qo);
if (rs->pkr_count == 0)
pool_seterror(POE_INVALID_SEARCH);
return ((pool_result_set_t *)rs);
}
/*
* Callback function intended to be used from pool_walk_pools(). If
* the supplied pool is not the default pool attempt to destroy it.
*/
/*ARGSUSED*/
static int
destroy_pool_cb(pool_conf_t *conf, pool_t *pool, void *unused)
{
if (elem_is_default(TO_ELEM(pool)) != PO_TRUE)
return (pool_destroy(conf, pool));
/*
* Return PO_SUCCESS even though we don't delete the default
* pool so that the walk continues
*/
return (PO_SUCCESS);
}
/*
* Remove the configuration details. This means remove all elements
* apart from the system elements.
*/
int
pool_knl_remove(pool_conf_t *conf)
{
uint_t i, nelem;
pool_resource_t **resources;
conf->pc_state = POF_DESTROY;
if ((resources = pool_query_resources(conf, &nelem, NULL)) != NULL) {
for (i = 0; i < nelem; i++) {
if (resource_is_system(resources[i]) == PO_FALSE)
if (pool_resource_destroy(conf, resources[i]) !=
PO_SUCCESS) {
pool_seterror(POE_INVALID_CONF);
return (PO_FAIL);
}
}
free(resources);
}
(void) pool_walk_pools(conf, conf, destroy_pool_cb);
if (pool_conf_commit(conf, PO_FALSE) != PO_SUCCESS)
return (PO_FAIL);
if (pool_conf_close(conf) != PO_SUCCESS)
return (PO_FAIL);
return (PO_SUCCESS);
}
/*
* Determine the name of the pool to which the supplied pid is
* bound. If it cannot be determined return NULL.
*/
char *
pool_knl_get_binding(pool_conf_t *conf, pid_t pid)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
const char *sval;
char *name = NULL;
pool_bindq_t bindq;
pool_value_t *props[] = { NULL, NULL };
uint_t nelem = 0;
pool_t **pools;
pool_value_t val = POOL_VALUE_INITIALIZER;
props[0] = &val;
bindq.pb_o_id_type = P_PID;
bindq.pb_o_id = pid;
if (ioctl(prov->pkc_fd, POOL_BINDQ, &bindq) < 0) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
if (pool_value_set_name(props[0], "pool.sys_id") != PO_SUCCESS) {
return (NULL);
}
pool_value_set_int64(props[0], bindq.pb_i_id);
if ((pools = pool_query_pools(conf, &nelem, props)) == NULL) {
pool_seterror(POE_BADPARAM);
return (NULL);
}
if (nelem != 1) {
free(pools);
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if (pool_get_ns_property(TO_ELEM(pools[0]), c_name, props[0])
== POC_INVAL) {
free(pools);
return (NULL);
}
if (pool_value_get_string(props[0], &sval) != PO_SUCCESS) {
free(pools);
return (NULL);
}
if ((name = strdup(sval)) == NULL) {
free(pools);
pool_seterror(POE_SYSTEM);
return (NULL);
}
return (name);
}
/*
* Bind idtype id to the pool name.
*/
int
pool_knl_set_binding(pool_conf_t *conf, const char *pool_name, idtype_t idtype,
id_t id)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
pool_bind_t bind;
pool_t *pool;
int ret;
if ((pool = pool_get_pool(conf, pool_name)) == NULL)
return (PO_FAIL);
bind.pb_o_id_type = idtype;
bind.pb_o_id = id;
bind.pb_o_pool_id = elem_get_sysid(TO_ELEM(pool));
while ((ret = ioctl(prov->pkc_fd, POOL_BIND, &bind)) < 0 &&
errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* pool_knl_get_resource_binding() returns the binding for a pid to
* the supplied type of resource. If a binding cannot be determined,
* NULL is returned.
*/
char *
pool_knl_get_resource_binding(pool_conf_t *conf,
pool_resource_elem_class_t type, pid_t pid)
{
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
const char *sval;
char *name = NULL;
pool_bindq_t bindq;
pool_value_t *props[] = { NULL, NULL };
uint_t nelem = 0;
pool_t **pools;
pool_resource_t **resources;
pool_value_t val = POOL_VALUE_INITIALIZER;
props[0] = &val;
bindq.pb_o_id_type = P_PID;
bindq.pb_o_id = pid;
if (ioctl(prov->pkc_fd, POOL_BINDQ, &bindq) < 0) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
if (pool_value_set_name(props[0], "pool.sys_id") != PO_SUCCESS) {
return (NULL);
}
pool_value_set_int64(props[0], bindq.pb_i_id);
if ((pools = pool_query_pools(conf, &nelem, props)) == NULL) {
pool_seterror(POE_BADPARAM);
return (NULL);
}
if (nelem != 1) {
free(pools);
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if (pool_value_set_string(props[0], pool_resource_type_string(type)) !=
PO_SUCCESS ||
pool_value_set_name(props[0], c_type) != PO_SUCCESS) {
free(pools);
return (NULL);
}
if ((resources = pool_query_pool_resources(conf, pools[0], &nelem,
NULL)) == NULL) {
free(pools);
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
free(pools);
if (nelem != 1) {
free(resources);
pool_seterror(POE_INVALID_CONF);
return (NULL);
}
if (pool_get_ns_property(TO_ELEM(resources[0]), c_name, props[0]) ==
POC_INVAL) {
free(resources);
return (NULL);
}
free(resources);
if (pool_value_get_string(props[0], &sval) != PO_SUCCESS) {
return (NULL);
}
if ((name = strdup(sval)) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
return (name);
}
/*
* Allocate the required library data structure and initialise it.
*/
pool_knl_elem_t *
pool_knl_elem_wrap(pool_conf_t *conf, pool_elem_class_t class,
pool_resource_elem_class_t res_class,
pool_component_elem_class_t comp_class)
{
pool_knl_elem_t *elem;
pool_elem_t *pe;
switch (class) {
case PEC_SYSTEM:
if ((elem = malloc(sizeof (pool_knl_system_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_knl_system_t));
break;
case PEC_POOL:
if ((elem = malloc(sizeof (pool_knl_pool_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_knl_pool_t));
break;
case PEC_RES_COMP:
case PEC_RES_AGG:
if ((elem = malloc(sizeof (pool_knl_resource_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_knl_resource_t));
break;
case PEC_COMP:
if ((elem = malloc(sizeof (pool_knl_component_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(elem, 0, sizeof (pool_knl_component_t));
break;
default:
pool_seterror(POE_BADPARAM);
return (NULL);
}
pe = TO_ELEM(elem);
pe->pe_conf = conf;
pe->pe_class = class;
pe->pe_resource_class = res_class;
pe->pe_component_class = comp_class;
/* Set up the function pointers for element manipulation */
pe->pe_get_prop = pool_knl_get_property;
pe->pe_put_prop = pool_knl_put_property;
pe->pe_rm_prop = pool_knl_rm_property;
pe->pe_get_props = pool_knl_get_properties;
pe->pe_remove = pool_knl_elem_remove;
pe->pe_get_container = pool_knl_get_container;
pe->pe_set_container = pool_knl_set_container;
/*
* Specific initialisation for different types of element
*/
if (class == PEC_POOL) {
pool_knl_pool_t *pp = (pool_knl_pool_t *)elem;
pp->pp_associate = pool_knl_pool_associate;
pp->pp_dissociate = pool_knl_pool_dissociate;
pp->pkp_assoc[PREC_PSET] = (pool_knl_resource_t *)
resource_by_sysid(conf, PS_NONE, "pset");
}
if (class == PEC_RES_COMP || class == PEC_RES_AGG) {
pool_knl_resource_t *pr = (pool_knl_resource_t *)elem;
pr->pr_is_system = pool_knl_resource_is_system;
pr->pr_can_associate = pool_knl_resource_can_associate;
}
#if DEBUG
if (dict_put(((pool_knl_connection_t *)conf->pc_prov)->pkc_leaks,
elem, elem) != NULL)
assert(!"leak map put failed");
dprintf("allocated %p\n", elem);
#endif /* DEBUG */
return (elem);
}
/*
* Allocate a new pool_knl_elem_t in the supplied configuration of the
* specified class.
* Returns element pointer/NULL
*/
pool_elem_t *
pool_knl_elem_create(pool_conf_t *conf, pool_elem_class_t class,
pool_resource_elem_class_t res_class,
pool_component_elem_class_t comp_class)
{
pool_knl_elem_t *elem;
pool_create_undo_t *create;
pool_knl_connection_t *prov = (pool_knl_connection_t *)conf->pc_prov;
static int id = -3;
char_buf_t *cb;
if ((elem = pool_knl_elem_wrap(conf, class, res_class, comp_class)) ==
NULL)
return (NULL);
/*
* Allocate an nvlist to hold properties
*/
if (nvlist_alloc(&elem->pke_properties, NV_UNIQUE_NAME_TYPE, 0) != 0) {
pool_knl_elem_free(elem, PO_FALSE);
pool_seterror(POE_SYSTEM);
return (NULL);
}
/*
* Allocate a temporary ID and name until the element is
* created for real
*/
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
pool_knl_elem_free(elem, PO_TRUE);
return (NULL);
}
if (set_char_buf(cb, "%s.sys_id",
pool_elem_class_string((pool_elem_t *)elem)) != PO_SUCCESS) {
pool_knl_elem_free(elem, PO_TRUE);
free_char_buf(cb);
return (NULL);
}
(void) nvlist_add_int64(elem->pke_properties, cb->cb_buf, id--);
if (set_char_buf(cb, "%s.name",
pool_elem_class_string((pool_elem_t *)elem)) != PO_SUCCESS) {
pool_knl_elem_free(elem, PO_TRUE);
free_char_buf(cb);
return (NULL);
}
(void) nvlist_add_string(elem->pke_properties, cb->cb_buf, "");
/*
* If it's a resource class, it will need an initial size
*/
if (class == PEC_RES_COMP || class == PEC_RES_AGG) {
if (set_char_buf(cb, "%s.size",
pool_elem_class_string((pool_elem_t *)elem)) !=
PO_SUCCESS) {
pool_knl_elem_free(elem, PO_TRUE);
free_char_buf(cb);
return (NULL);
}
(void) nvlist_add_uint64(elem->pke_properties, cb->cb_buf, 0);
}
free_char_buf(cb);
/*
* Register the newly created element
*/
if (dict_put(prov->pkc_elements, elem, elem) != NULL) {
pool_knl_elem_free(elem, PO_TRUE);
pool_seterror(POE_SYSTEM);
return (NULL);
}
if (prov->pkc_log->l_state != LS_DO)
return ((pool_elem_t *)elem);
/*
* The remaining logic is setting up the arguments for the
* POOL_CREATE ioctl and appending the details into the log.
*/
if ((create = malloc(sizeof (pool_create_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
create->pcu_ioctl.pc_o_type = class;
switch (class) {
case PEC_SYSTEM:
pool_seterror(POE_BADPARAM);
free(create);
return (NULL);
case PEC_POOL: /* NO-OP */
break;
case PEC_RES_COMP:
case PEC_RES_AGG:
create->pcu_ioctl.pc_o_sub_type = res_class;
break;
case PEC_COMP:
create->pcu_ioctl.pc_o_sub_type = comp_class;
break;
default:
pool_seterror(POE_BADPARAM);
free(create);
return (NULL);
}
create->pcu_elem = (pool_elem_t *)elem;
if (log_append(prov->pkc_log, POOL_CREATE, (void *)create) !=
PO_SUCCESS) {
free(create);
return (NULL);
}
return ((pool_elem_t *)elem);
}
/*
* Remove the details of the element from our userland copy and destroy
* the element (if appropriate) in the kernel.
*/
int
pool_knl_elem_remove(pool_elem_t *pe)
{
pool_knl_connection_t *prov;
pool_destroy_undo_t *destroy;
prov = (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
if (dict_remove(prov->pkc_elements, pe) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (prov->pkc_log->l_state != LS_DO) {
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_DESTROY ioctl and appending the details into the log.
*/
if ((destroy = malloc(sizeof (pool_destroy_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
destroy->pdu_ioctl.pd_o_type = pool_elem_class(pe);
if (destroy->pdu_ioctl.pd_o_type == PEC_RES_COMP ||
destroy->pdu_ioctl.pd_o_type == PEC_RES_AGG)
destroy->pdu_ioctl.pd_o_sub_type = pool_resource_elem_class(pe);
if (destroy->pdu_ioctl.pd_o_type == PEC_COMP)
destroy->pdu_ioctl.pd_o_sub_type =
pool_component_elem_class(pe);
destroy->pdu_elem = pe;
if (log_append(prov->pkc_log, POOL_DESTROY, (void *)destroy) !=
PO_SUCCESS) {
free(destroy);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Set the parent of the supplied child to the supplied parent
*/
int
pool_knl_set_container(pool_elem_t *pp, pool_elem_t *pc)
{
pool_knl_elem_t *pkp = (pool_knl_elem_t *)pp;
pool_knl_elem_t *pkc = (pool_knl_elem_t *)pc;
pkc->pke_parent = pkp;
return (PO_SUCCESS);
}
/*
* TODO: Needed for msets and ssets.
*/
/* ARGSUSED */
int
pool_knl_res_transfer(pool_resource_t *src, pool_resource_t *tgt,
uint64_t size) {
return (PO_FAIL);
}
/*
* Transfer resource components from one resource set to another.
*/
int
pool_knl_res_xtransfer(pool_resource_t *src, pool_resource_t *tgt,
pool_component_t **rl) {
pool_elem_t *src_e = TO_ELEM(src);
pool_elem_t *tgt_e = TO_ELEM(tgt);
pool_xtransfer_undo_t *xtransfer;
size_t size;
pool_knl_connection_t *prov =
(pool_knl_connection_t *)TO_CONF(src_e)->pc_prov;
if (prov->pkc_log->l_state != LS_DO) {
/*
* Walk the Result Set and move the resource components
*/
for (size = 0; rl[size] != NULL; size++) {
if (pool_set_container(TO_ELEM(tgt),
TO_ELEM(rl[size])) == PO_FAIL) {
return (PO_FAIL);
}
}
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_XTRANSFER ioctl and appending the details into the log.
*/
if ((xtransfer = malloc(sizeof (pool_xtransfer_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (pool_elem_class(src_e) == PEC_RES_COMP) {
xtransfer->pxu_ioctl.px_o_id_type =
pool_resource_elem_class(src_e);
} else {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
for (xtransfer->pxu_ioctl.px_o_complist_size = 0;
rl[xtransfer->pxu_ioctl.px_o_complist_size] != NULL;
xtransfer->pxu_ioctl.px_o_complist_size++)
/* calculate the size using the terminating NULL */;
if ((xtransfer->pxu_ioctl.px_o_comp_list =
calloc(xtransfer->pxu_ioctl.px_o_complist_size,
sizeof (id_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((xtransfer->pxu_rl = calloc(
xtransfer->pxu_ioctl.px_o_complist_size + 1,
sizeof (pool_component_t *))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memcpy(xtransfer->pxu_rl, rl,
xtransfer->pxu_ioctl.px_o_complist_size *
sizeof (pool_component_t *));
xtransfer->pxu_src = src_e;
xtransfer->pxu_tgt = tgt_e;
if (log_append(prov->pkc_log, POOL_XTRANSFER, (void *)xtransfer) !=
PO_SUCCESS) {
free(xtransfer);
return (PO_FAIL);
}
for (size = 0; rl[size] != NULL; size++) {
if (pool_set_container(TO_ELEM(tgt), TO_ELEM(rl[size])) ==
PO_FAIL) {
return (PO_FAIL);
}
}
return (PO_SUCCESS);
}
/*
* Return the parent of an element.
*/
pool_elem_t *
pool_knl_get_container(const pool_elem_t *pe)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
return ((pool_elem_t *)pke->pke_parent);
}
/*
* Note: This function is resource specific, needs extending for other
* resource types
*/
int
pool_knl_resource_is_system(const pool_resource_t *pr)
{
switch (pool_resource_elem_class(TO_ELEM(pr))) {
case PREC_PSET:
return (PSID_IS_SYSSET(
elem_get_sysid(TO_ELEM(pr))));
default:
return (PO_FALSE);
}
}
/*
* Note: This function is resource specific, needs extending for other
* resource types
*/
int
pool_knl_resource_can_associate(const pool_resource_t *pr)
{
switch (pool_resource_elem_class(TO_ELEM(pr))) {
case PREC_PSET:
return (PO_TRUE);
default:
return (PO_FALSE);
}
}
/*
* pool_knl_pool_associate() associates the supplied resource to the
* supplied pool.
*
* Returns: PO_SUCCESS/PO_FAIL
*/
int
pool_knl_pool_associate(pool_t *pool, const pool_resource_t *resource)
{
pool_knl_connection_t *prov;
pool_knl_pool_t *pkp = (pool_knl_pool_t *)pool;
pool_resource_elem_class_t res_class =
pool_resource_elem_class(TO_ELEM(resource));
pool_assoc_undo_t *assoc;
pool_knl_resource_t *orig_res = pkp->pkp_assoc[res_class];
/*
* Are we allowed to associate with this target?
*/
if (pool_knl_resource_can_associate(resource) == PO_FALSE) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
prov = (pool_knl_connection_t *)(TO_CONF(TO_ELEM(pool)))->pc_prov;
if (prov->pkc_log->l_state != LS_DO) {
pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_ASSOC ioctl and appending the details into the log.
*/
if ((assoc = malloc(sizeof (pool_assoc_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
assoc->pau_assoc = TO_ELEM(pool);
assoc->pau_oldres = (pool_elem_t *)orig_res;
assoc->pau_newres = TO_ELEM(resource);
assoc->pau_ioctl.pa_o_id_type = res_class;
if (log_append(prov->pkc_log, POOL_ASSOC, (void *)assoc) !=
PO_SUCCESS) {
free(assoc);
pkp->pkp_assoc[res_class] = orig_res;
return (PO_FAIL);
}
pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
return (PO_SUCCESS);
}
/*
* pool_knl_pool_dissociate() dissociates the supplied resource from
* the supplied pool.
*
* Returns: PO_SUCCESS/PO_FAIL
*/
int
pool_knl_pool_dissociate(pool_t *pool, const pool_resource_t *resource)
{
pool_knl_connection_t *prov;
pool_dissoc_undo_t *dissoc;
pool_knl_pool_t *pkp = (pool_knl_pool_t *)pool;
pool_resource_t *default_res = (pool_resource_t *)get_default_resource(
resource);
pool_resource_elem_class_t res_class =
pool_resource_elem_class(TO_ELEM(resource));
prov = (pool_knl_connection_t *)(TO_CONF(TO_ELEM(pool)))->pc_prov;
if (prov->pkc_log->l_state != LS_DO) {
pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)default_res;
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_DISSOC ioctl and appending the details into the log.
*/
if ((dissoc = malloc(sizeof (pool_dissoc_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
dissoc->pdu_dissoc = TO_ELEM(pool);
dissoc->pdu_oldres = TO_ELEM(resource);
dissoc->pdu_newres = TO_ELEM(default_res);
dissoc->pdu_ioctl.pd_o_id_type = res_class;
if (log_append(prov->pkc_log, POOL_DISSOC, (void *)dissoc) !=
PO_SUCCESS) {
free(dissoc);
pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)resource;
return (PO_FAIL);
}
/*
* Update our local copy
*/
pkp->pkp_assoc[res_class] = (pool_knl_resource_t *)default_res;
return (PO_SUCCESS);
}
/*
* Allocate a data provider for the supplied configuration and optionally
* discover resources.
* The data provider is the cross over point from the "abstract" configuration
* functions into the data representation specific manipulation routines.
* This function sets up all the required pointers to create a kernel aware
* data provider.
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_connection_alloc(pool_conf_t *conf, int oflags)
{
pool_knl_connection_t *prov;
if ((prov = malloc(sizeof (pool_knl_connection_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(prov, 0, sizeof (pool_knl_connection_t));
/*
* Initialise data members
*/
prov->pc_name = strdup("kernel");
prov->pc_store_type = KERNEL_DATA_STORE;
prov->pc_oflags = oflags;
/*
* Initialise function pointers
*/
prov->pc_close = pool_knl_close;
prov->pc_validate = pool_knl_validate;
prov->pc_commit = pool_knl_commit;
prov->pc_export = pool_knl_export;
prov->pc_rollback = pool_knl_rollback;
prov->pc_exec_query = pool_knl_exec_query;
prov->pc_elem_create = pool_knl_elem_create;
prov->pc_remove = pool_knl_remove;
prov->pc_res_xfer = pool_knl_res_transfer;
prov->pc_res_xxfer = pool_knl_res_xtransfer;
prov->pc_get_binding = pool_knl_get_binding;
prov->pc_set_binding = pool_knl_set_binding;
prov->pc_get_resource_binding = pool_knl_get_resource_binding;
/*
* Associate the provider to it's configuration
*/
conf->pc_prov = (pool_connection_t *)prov;
/*
* End of common initialisation
*/
/*
* Attempt to open the pseudo device, if the configuration is opened
* readonly then try to open an info device, otherwise try to open
* the writeable device.
*/
if (oflags & PO_RDWR) {
if ((prov->pkc_fd = blocking_open(pool_dynamic_location(),
O_RDWR)) < 0) {
free(prov);
conf->pc_prov = NULL;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
} else {
if ((prov->pkc_fd = open(pool_info_location, O_RDWR)) < 0) {
free(prov);
conf->pc_prov = NULL;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
/*
* Allocate the element dictionary
*/
if ((prov->pkc_elements = dict_new((int (*)(const void *, const void *))
pool_elem_compare, (uint64_t (*)(const void *))hash_id)) == NULL) {
(void) close(prov->pkc_fd);
free(prov);
conf->pc_prov = NULL;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
#if DEBUG
if ((prov->pkc_leaks = dict_new(NULL, NULL)) == NULL) {
dict_free(&prov->pkc_elements);
(void) close(prov->pkc_fd);
free(prov);
conf->pc_prov = NULL;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
#endif /* DEBUG */
/*
* Allocate the transaction log
*/
if ((prov->pkc_log = log_alloc(conf)) == NULL) {
#if DEBUG
dict_free(&prov->pkc_leaks);
#endif /* DEBUG */
dict_free(&prov->pkc_elements);
(void) close(prov->pkc_fd);
free(prov);
conf->pc_prov = NULL;
return (PO_FAIL);
}
/*
* At this point the configuration provider has been initialized,
* mark the configuration as valid so that the various routines
* which rely on a valid configuration will work correctly.
*/
conf->pc_state = POF_VALID;
/*
* Update the library snapshot from the kernel
*/
if (pool_knl_update(conf, NULL) != PO_SUCCESS) {
#if DEBUG
dict_free(&prov->pkc_leaks);
#endif /* DEBUG */
dict_free(&prov->pkc_elements);
(void) close(prov->pkc_fd);
free(prov);
conf->pc_prov = NULL;
conf->pc_state = POF_INVALID;
return (PO_FAIL);
}
return (PO_SUCCESS);
}
#if DEBUG
static void
pool_knl_elem_printf_cb(const void *key, void **value, void *cl)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
dict_hdl_t *map = (dict_hdl_t *)cl;
dprintf("leak elem:%p\n", pke);
if (pke->pke_properties != NULL) {
nvlist_print(stdout, pke->pke_properties);
} else
dprintf("no properties\n");
assert(dict_get(map, pke) == NULL);
}
#endif /* DEBUG */
/*
* pool_knl_elem_free() releases the resources associated with the
* supplied element.
*/
static void
pool_knl_elem_free(pool_knl_elem_t *pke, int freeprop)
{
#if DEBUG
pool_conf_t *conf = TO_CONF(TO_ELEM(pke));
if (dict_remove(((pool_knl_connection_t *)conf->pc_prov)->pkc_leaks,
pke) == NULL)
dprintf("%p, wasn't in the leak map\n", pke);
if (freeprop == PO_TRUE) {
pool_elem_dprintf(TO_ELEM(pke));
}
dprintf("released %p\n", pke);
#endif /* DEBUG */
if (freeprop == PO_TRUE) {
nvlist_free(pke->pke_properties);
}
free(pke);
}
/*
* pool_knl_elem_free_cb() is designed to be used with
* dict_map(). When a connection is freed, this function is used to
* free all element resources.
*/
/* ARGSUSED1 */
static void
pool_knl_elem_free_cb(const void *key, void **value, void *cl)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)key;
#ifdef DEBUG
dprintf("pool_knl_elem_free_cb:\n");
dprintf("about to release %p ", pke);
pool_elem_dprintf(TO_ELEM(pke));
#endif /* DEBUG */
pool_knl_elem_free(pke, PO_TRUE);
}
/*
* Free the resources for a kernel data provider.
*/
void
pool_knl_connection_free(pool_knl_connection_t *prov)
{
if (prov->pkc_log != NULL) {
(void) log_walk(prov->pkc_log, log_item_release);
log_free(prov->pkc_log);
}
if (prov->pkc_elements != NULL) {
dict_map(prov->pkc_elements, pool_knl_elem_free_cb, NULL);
#if DEBUG
dprintf("dict length is %llu\n", dict_length(prov->pkc_leaks));
dict_map(prov->pkc_leaks, pool_knl_elem_printf_cb,
prov->pkc_elements);
assert(dict_length(prov->pkc_leaks) == 0);
dict_free(&prov->pkc_leaks);
#endif /* DEBUG */
dict_free(&prov->pkc_elements);
}
free((void *)prov->pc_name);
free(prov);
}
/*
* Return the specified property value.
*
* POC_INVAL is returned if an error is detected and the error code is updated
* to indicate the cause of the error.
*/
pool_value_class_t
pool_knl_get_property(const pool_elem_t *pe, const char *name,
pool_value_t *val)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
nvpair_t *pair;
const pool_prop_t *prop;
if ((prop = provider_get_prop(pe, name)) != NULL)
if (prop_is_stored(prop) == PO_FALSE)
return (pool_knl_get_dynamic_property(pe, name, val));
if ((pair = pool_knl_find_nvpair(pke->pke_properties, name)) == NULL) {
pool_seterror(POE_BADPARAM);
return (POC_INVAL);
}
if (pool_value_from_nvpair(val, pair) == PO_FAIL) {
return (POC_INVAL);
}
return (pool_value_get_type(val));
}
/*
* Return the specified property value.
*
* If a property is designated as dynamic, then this function will
* always try to return the latest value of the property from the
* kernel.
*
* POC_INVAL is returned if an error is detected and the error code is updated
* to indicate the cause of the error.
*/
pool_value_class_t
pool_knl_get_dynamic_property(const pool_elem_t *pe, const char *name,
pool_value_t *val)
{
pool_knl_connection_t *prov;
pool_propget_t propget = { 0 };
nvlist_t *proplist;
nvpair_t *pair;
propget.pp_o_id_type = pool_elem_class(pe);
if (pool_elem_class(pe) == PEC_RES_COMP ||
pool_elem_class(pe) == PEC_RES_AGG)
propget.pp_o_id_subtype = pool_resource_elem_class(pe);
if (pool_elem_class(pe) == PEC_COMP)
propget.pp_o_id_subtype =
(pool_resource_elem_class_t)pool_component_elem_class(pe);
propget.pp_o_id = elem_get_sysid(pe);
propget.pp_o_prop_name_size = strlen(name);
propget.pp_o_prop_name = (char *)name;
propget.pp_i_bufsize = KERNEL_SNAPSHOT_BUF_SZ;
propget.pp_i_buf = malloc(KERNEL_SNAPSHOT_BUF_SZ);
bzero(propget.pp_i_buf, KERNEL_SNAPSHOT_BUF_SZ);
prov = (pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
if (ioctl(prov->pkc_fd, POOL_PROPGET, &propget) < 0) {
free(propget.pp_i_buf);
pool_seterror(POE_SYSTEM);
return (POC_INVAL);
}
if (nvlist_unpack(propget.pp_i_buf, propget.pp_i_bufsize,
&proplist, 0) != 0) {
free(propget.pp_i_buf);
pool_seterror(POE_SYSTEM);
return (POC_INVAL);
}
free(propget.pp_i_buf);
if ((pair = nvlist_next_nvpair(proplist, NULL)) == NULL) {
nvlist_free(proplist);
pool_seterror(POE_SYSTEM);
return (POC_INVAL);
}
if (pool_value_from_nvpair(val, pair) == PO_FAIL) {
nvlist_free(proplist);
return (POC_INVAL);
}
nvlist_free(proplist);
return (pool_value_get_type(val));
}
/*
* Update the specified property value.
*
* PO_FAIL is returned if an error is detected and the error code is updated
* to indicate the cause of the error.
*/
int
pool_knl_put_property(pool_elem_t *pe, const char *name,
const pool_value_t *val)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
pool_knl_connection_t *prov =
(pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
nvpair_t *bp, *ap;
pool_propput_undo_t *propput;
nvlist_t *bl = NULL;
const pool_prop_t *prop;
if ((bp = pool_knl_find_nvpair(pke->pke_properties, name)) != NULL) {
if (nvlist_alloc(&bl, NV_UNIQUE_NAME_TYPE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_add_nvpair(bl, bp) != 0) {
nvlist_free(bl);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
if (pool_knl_nvlist_add_value(pke->pke_properties, name, val) !=
PO_SUCCESS)
return (PO_FAIL);
if (prov->pkc_log->l_state != LS_DO) {
if (bl)
nvlist_free(bl);
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_PROPPUT ioctl and appending the details into the log.
*/
if ((propput = malloc(sizeof (pool_propput_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(propput, 0, sizeof (pool_propput_undo_t));
propput->ppu_blist = bl;
ap = pool_knl_find_nvpair(pke->pke_properties, name);
if (nvlist_alloc(&propput->ppu_alist, NV_UNIQUE_NAME_TYPE, 0) != 0) {
nvlist_free(propput->ppu_blist);
free(propput);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_add_nvpair(propput->ppu_alist, ap) != 0) {
nvlist_free(propput->ppu_blist);
nvlist_free(propput->ppu_alist);
free(propput);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (nvlist_pack(propput->ppu_alist,
(char **)&propput->ppu_ioctl.pp_o_buf,
&propput->ppu_ioctl.pp_o_bufsize, NV_ENCODE_NATIVE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
nvlist_free(propput->ppu_alist);
propput->ppu_ioctl.pp_o_id_type = pool_elem_class(pe);
if (pool_elem_class(pe) == PEC_RES_COMP ||
pool_elem_class(pe) == PEC_RES_AGG)
propput->ppu_ioctl.pp_o_id_sub_type =
pool_resource_elem_class(pe);
if (pool_elem_class(pe) == PEC_COMP)
propput->ppu_ioctl.pp_o_id_sub_type =
(pool_resource_elem_class_t)pool_component_elem_class(pe);
propput->ppu_elem = pe;
if ((prop = provider_get_prop(propput->ppu_elem, name)) != NULL) {
if (prop_is_readonly(prop) == PO_TRUE)
propput->ppu_doioctl |= KERNEL_PROP_RDONLY;
}
if (log_append(prov->pkc_log, POOL_PROPPUT, (void *)propput) !=
PO_SUCCESS) {
nvlist_free(propput->ppu_blist);
free(propput);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Remove the specified property value.
*
* PO_FAIL is returned if an error is detected and the error code is
* updated to indicate the cause of the error.
*/
int
pool_knl_rm_property(pool_elem_t *pe, const char *name)
{
pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
pool_knl_connection_t *prov =
(pool_knl_connection_t *)(TO_CONF(pe))->pc_prov;
pool_proprm_undo_t *proprm;
if (pool_knl_find_nvpair(pke->pke_properties, name) == NULL) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
if ((proprm = malloc(sizeof (pool_proprm_undo_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memset(proprm, 0, sizeof (pool_proprm_undo_t));
proprm->pru_oldval.pv_class = POC_INVAL;
(void) pool_get_property(TO_CONF(pe), pe, name, &proprm->pru_oldval);
if (prov->pkc_log->l_state != LS_DO) {
free(proprm);
(void) nvlist_remove_all(pke->pke_properties, (char *)name);
return (PO_SUCCESS);
}
/*
* The remaining logic is setting up the arguments for the
* POOL_PROPRM ioctl and appending the details into the log.
*/
proprm->pru_ioctl.pp_o_id_type = pool_elem_class(pe);
if (pool_elem_class(pe) == PEC_RES_COMP ||
pool_elem_class(pe) == PEC_RES_AGG)
proprm->pru_ioctl.pp_o_id_sub_type =
pool_resource_elem_class(pe);
if (pool_elem_class(pe) == PEC_COMP)
proprm->pru_ioctl.pp_o_id_sub_type =
(pool_resource_elem_class_t)pool_component_elem_class(pe);
proprm->pru_ioctl.pp_o_prop_name_size = strlen(name);
proprm->pru_ioctl.pp_o_prop_name =
(char *)pool_value_get_name(&proprm->pru_oldval);
proprm->pru_elem = pe;
if (log_append(prov->pkc_log, POOL_PROPRM, (void *)proprm) !=
PO_SUCCESS) {
free(proprm);
return (PO_FAIL);
}
(void) nvlist_remove_all(pke->pke_properties, (char *)name);
return (PO_SUCCESS);
}
/*
* Return a NULL terminated array of pool_value_t which represents all
* of the properties stored for an element
*
* Return NULL on failure. It is the caller's responsibility to free
* the returned array of values.
*/
pool_value_t **
pool_knl_get_properties(const pool_elem_t *pe, uint_t *nprops)
{
nvpair_t *pair;
pool_value_t **result;
pool_knl_elem_t *pke = (pool_knl_elem_t *)pe;
int i = 0;
*nprops = 0;
for (pair = nvlist_next_nvpair(pke->pke_properties, NULL); pair != NULL;
pair = nvlist_next_nvpair(pke->pke_properties, pair))
(*nprops)++;
if ((result = calloc(*nprops + 1, sizeof (pool_value_t *))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
for (pair = nvlist_next_nvpair(pke->pke_properties, NULL); pair != NULL;
pair = nvlist_next_nvpair(pke->pke_properties, pair), i++) {
result[i] = pool_value_alloc();
if (pool_value_from_nvpair(result[i], pair) == PO_FAIL) {
while (i-- >= 0)
pool_value_free(result[i]);
free(result);
return (NULL);
}
}
return (result);
}
/*
* Append an entry to a result set. Reallocate the array used to store
* results if it's full.
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_result_set_append(pool_knl_result_set_t *rs, pool_knl_elem_t *pke)
{
if (rs->pkr_count == rs->pkr_size)
if (pool_knl_result_set_realloc(rs) != PO_SUCCESS)
return (PO_FAIL);
rs->pkr_list[rs->pkr_count++] = pke;
return (PO_SUCCESS);
}
/*
* Resize the array used to store results. A simple doubling strategy
* is used.
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_result_set_realloc(pool_knl_result_set_t *rs)
{
pool_knl_elem_t **old_list = rs->pkr_list;
int new_size = rs->pkr_size * 2;
if ((rs->pkr_list = realloc(rs->pkr_list,
new_size * sizeof (pool_knl_elem_t *))) == NULL) {
rs->pkr_list = old_list;
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
rs->pkr_size = new_size;
return (PO_SUCCESS);
}
/*
* Allocate a result set. The Result Set stores the result of a query.
* Returns pool_knl_result_set_t pointer/NULL
*/
pool_knl_result_set_t *
pool_knl_result_set_alloc(const pool_conf_t *conf)
{
pool_knl_result_set_t *rs;
if ((rs = malloc(sizeof (pool_knl_result_set_t))) == NULL) {
pool_seterror(POE_SYSTEM);
return (NULL);
}
(void) memset(rs, 0, sizeof (pool_knl_result_set_t));
rs->pkr_size = KERNEL_RS_INITIAL_SZ;
if (pool_knl_result_set_realloc(rs) == PO_FAIL) {
free(rs);
pool_seterror(POE_SYSTEM);
return (NULL);
}
rs->prs_conf = conf;
rs->prs_index = -1;
rs->prs_active = PO_TRUE;
/* Fix up the result set accessor functions to the knl specfic ones */
rs->prs_next = pool_knl_rs_next;
rs->prs_prev = pool_knl_rs_prev;
rs->prs_first = pool_knl_rs_first;
rs->prs_last = pool_knl_rs_last;
rs->prs_get_index = pool_knl_rs_get_index;
rs->prs_set_index = pool_knl_rs_set_index;
rs->prs_close = pool_knl_rs_close;
rs->prs_count = pool_knl_rs_count;
return (rs);
}
/*
* Free a result set. Ensure that the resources are all released at
* this point.
*/
void
pool_knl_result_set_free(pool_knl_result_set_t *rs)
{
free(rs->pkr_list);
free(rs);
}
/*
* Return the next element in a result set.
* Returns pool_elem_t pointer/NULL
*/
pool_elem_t *
pool_knl_rs_next(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
if (kset->prs_index == kset->pkr_count - 1)
return (NULL);
return ((pool_elem_t *)kset->pkr_list[++kset->prs_index]);
}
/*
* Return the previous element in a result set.
* Returns pool_elem_t pointer/NULL
*/
pool_elem_t *
pool_knl_rs_prev(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
if (kset->prs_index < 0)
return (NULL);
return ((pool_elem_t *)kset->pkr_list[kset->prs_index--]);
}
/*
* Sets the current index in a result set.
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_rs_set_index(pool_result_set_t *set, int index)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
if (index < 0 || index >= kset->pkr_count) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
kset->prs_index = index;
return (PO_SUCCESS);
}
/*
* Return the current index in a result set.
* Returns current index
*/
int
pool_knl_rs_get_index(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
return (kset->prs_index);
}
/*
* Return the first element in a result set.
* Returns pool_elem_t pointer/NULL
*/
pool_elem_t *
pool_knl_rs_first(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
return ((pool_elem_t *)kset->pkr_list[0]);
}
/*
* Return the last element in a result set.
* Returns pool_elem_t pointer/NULL
*/
pool_elem_t *
pool_knl_rs_last(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
return ((pool_elem_t *)kset->pkr_list[kset->pkr_count - 1]);
}
/*
* Return the number of results in a result set.
* Returns result count
*/
int
pool_knl_rs_count(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
return (kset->pkr_count);
}
/*
* Close a result set. Free the resources
* Returns PO_SUCCESS/PO_FAIL
*/
int
pool_knl_rs_close(pool_result_set_t *set)
{
pool_knl_result_set_t *kset = (pool_knl_result_set_t *)set;
pool_knl_result_set_free(kset);
return (PO_SUCCESS);
}
/*
* Commit an individual transaction log item(). This processing is
* essential to the pool_conf_commit() logic. When pool_conf_commit()
* is invoked, the pending transaction log for the configuration is
* walked and all pending changes to the kernel are invoked. If a
* change succeeds it is marked in the log as successful and
* processing continues, if it fails then failure is returned and the
* log will be "rolled back" to undo changes to the library snapshot
* and the kernel.
*/
int
log_item_commit(log_item_t *li)
{
pool_knl_connection_t *prov =
(pool_knl_connection_t *)li->li_log->l_conf->pc_prov;
pool_create_undo_t *create;
pool_destroy_undo_t *destroy;
pool_assoc_undo_t *assoc;
pool_dissoc_undo_t *dissoc;
pool_propput_undo_t *propput;
pool_proprm_undo_t *proprm;
pool_xtransfer_undo_t *xtransfer;
char_buf_t *cb;
size_t size;
pool_elem_t *pair;
pool_value_t val = POOL_VALUE_INITIALIZER;
int ret;
switch (li->li_op) {
case POOL_CREATE:
create = (pool_create_undo_t *)li->li_details;
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL)
return (PO_FAIL);
if (set_char_buf(cb, "%s.sys_id",
pool_elem_class_string(create->pcu_elem)) != PO_SUCCESS) {
free_char_buf(cb);
return (PO_FAIL);
}
#ifdef DEBUG
dprintf("log_item_commit: POOL_CREATE, remove from dict\n");
pool_elem_dprintf(create->pcu_elem);
#endif /* DEBUG */
/*
* May not need to remove the element if it was
* already destroyed before commit. Just cast the
* return to void.
*/
(void) dict_remove(prov->pkc_elements,
(pool_knl_elem_t *)create->pcu_elem);
if (ioctl(prov->pkc_fd, POOL_CREATE, &create->pcu_ioctl) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Now that we have created our element in the kernel,
* it has a valid allocated system id. Remove the
* element from the element dictionary, using the
* current key, and then re-insert under the new key.
*/
#ifdef DEBUG
pool_elem_dprintf(create->pcu_elem);
#endif /* DEBUG */
assert(nvlist_add_int64(
((pool_knl_elem_t *)create->pcu_elem)->pke_properties,
cb->cb_buf, create->pcu_ioctl.pc_i_id) == 0);
free_char_buf(cb);
assert(dict_put(prov->pkc_elements, create->pcu_elem,
create->pcu_elem) == NULL);
/*
* If the element has a pair in the static
* configuration, update it with the sys_id
*/
if ((pair = pool_get_pair(create->pcu_elem)) != NULL) {
pool_value_set_int64(&val, create->pcu_ioctl.pc_i_id);
assert(pool_put_any_ns_property(pair, c_sys_prop, &val)
== PO_SUCCESS);
}
li->li_state = LS_UNDO;
break;
case POOL_DESTROY:
destroy = (pool_destroy_undo_t *)li->li_details;
destroy->pdu_ioctl.pd_o_id = elem_get_sysid(destroy->pdu_elem);
/*
* It may be that this element was created in the last
* transaction. In which case POOL_CREATE, above, will
* have re-inserted the element in the dictionary. Try
* to remove it just in case this has occurred.
*/
(void) dict_remove(prov->pkc_elements,
(pool_knl_elem_t *)destroy->pdu_elem);
while ((ret = ioctl(prov->pkc_fd, POOL_DESTROY,
&destroy->pdu_ioctl)) < 0 && errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
#ifdef DEBUG
dprintf("log_item_commit: POOL_DESTROY\n");
pool_elem_dprintf(destroy->pdu_elem);
#endif /* DEBUG */
li->li_state = LS_UNDO;
break;
case POOL_ASSOC:
assoc = (pool_assoc_undo_t *)li->li_details;
assoc->pau_ioctl.pa_o_pool_id =
elem_get_sysid(assoc->pau_assoc);
assoc->pau_ioctl.pa_o_res_id =
elem_get_sysid(assoc->pau_newres);
while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC,
&assoc->pau_ioctl)) < 0 && errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_UNDO;
break;
case POOL_DISSOC:
dissoc = (pool_dissoc_undo_t *)li->li_details;
dissoc->pdu_ioctl.pd_o_pool_id =
elem_get_sysid(dissoc->pdu_dissoc);
while ((ret = ioctl(prov->pkc_fd, POOL_DISSOC,
&dissoc->pdu_ioctl)) < 0 && errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_UNDO;
break;
case POOL_TRANSFER:
li->li_state = LS_UNDO;
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
break;
case POOL_XTRANSFER:
xtransfer = (pool_xtransfer_undo_t *)li->li_details;
xtransfer->pxu_ioctl.px_o_src_id =
elem_get_sysid(xtransfer->pxu_src);
xtransfer->pxu_ioctl.px_o_tgt_id =
elem_get_sysid(xtransfer->pxu_tgt);
for (size = 0; xtransfer->pxu_rl[size] != NULL; size ++) {
xtransfer->pxu_ioctl.px_o_comp_list[size] =
elem_get_sysid(TO_ELEM(xtransfer->pxu_rl[size]));
#ifdef DEBUG
dprintf("log_item_commit: POOL_XTRANSFER\n");
pool_elem_dprintf(TO_ELEM(xtransfer->pxu_rl[size]));
#endif /* DEBUG */
}
/*
* Don't actually transfer resources if the configuration
* is in POF_DESTROY state. This is to prevent problems
* relating to transferring off-line CPUs. Instead rely
* on the POOL_DESTROY ioctl to transfer the CPUS.
*/
if (li->li_log->l_conf->pc_state != POF_DESTROY &&
ioctl(prov->pkc_fd, POOL_XTRANSFER,
&xtransfer->pxu_ioctl) < 0) {
#ifdef DEBUG
dprintf("log_item_commit: POOL_XTRANSFER, ioctl "
"failed\n");
#endif /* DEBUG */
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_UNDO;
break;
case POOL_PROPPUT:
propput = (pool_propput_undo_t *)li->li_details;
if (pool_elem_class(propput->ppu_elem) != PEC_SYSTEM) {
propput->ppu_ioctl.pp_o_id =
elem_get_sysid(propput->ppu_elem);
}
/*
* Some properties, e.g. pset.size, are read-only in the
* kernel and attempting to change them will fail and cause
* problems. Although this property is read-only through the
* public interface, the library needs to modify it's value.
*/
if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
if (ioctl(prov->pkc_fd, POOL_PROPPUT,
&propput->ppu_ioctl) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
li->li_state = LS_UNDO;
break;
case POOL_PROPRM:
proprm = (pool_proprm_undo_t *)li->li_details;
if (pool_elem_class(proprm->pru_elem) != PEC_SYSTEM) {
proprm->pru_ioctl.pp_o_id =
elem_get_sysid(proprm->pru_elem);
}
if (ioctl(prov->pkc_fd, POOL_PROPRM, &proprm->pru_ioctl) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_UNDO;
break;
default:
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* Undo an individual transaction log item(). This processing is
* essential to the pool_conf_commit() and pool_conf_rollback()
* logic. Changes to the libpool snapshot and the kernel are carried
* out separately. The library snapshot is updated synchronously,
* however the kernel update is delayed until the user calls
* pool_conf_commit().
*
* When undoing transactions, library changes will be undone unless
* this invocation is as a result of a commit failure, in which case
* the log state will be LS_RECOVER. Kernel changes will only be
* undone if they are marked as having been done, in which case the
* log item state will be LS_UNDO.
*/
int
log_item_undo(log_item_t *li)
{
pool_knl_connection_t *prov =
(pool_knl_connection_t *)li->li_log->l_conf->pc_prov;
pool_create_undo_t *create;
pool_destroy_undo_t *destroy;
pool_assoc_undo_t *assoc;
pool_dissoc_undo_t *dissoc;
pool_propput_undo_t *propput;
pool_proprm_undo_t *proprm;
pool_xtransfer_undo_t *xtransfer;
char_buf_t *cb;
size_t size;
pool_destroy_t u_destroy;
pool_create_t u_create;
pool_assoc_t u_assoc;
pool_xtransfer_t u_xtransfer;
pool_propput_t u_propput;
pool_proprm_t u_proprm;
pool_conf_t *conf = li->li_log->l_conf;
nvpair_t *pair;
nvlist_t *tmplist;
int ret;
if (li->li_log->l_state != LS_RECOVER) {
switch (li->li_op) {
case POOL_CREATE:
create = (pool_create_undo_t *)li->li_details;
(void) dict_remove(prov->pkc_elements, create->pcu_elem);
#ifdef DEBUG
dprintf("log_item_undo: POOL_CREATE\n");
assert(create->pcu_elem != NULL);
dprintf("log_item_undo: POOL_CREATE %p\n", create->pcu_elem);
pool_elem_dprintf(create->pcu_elem);
#endif /* DEBUG */
pool_knl_elem_free((pool_knl_elem_t *)create->pcu_elem,
PO_TRUE);
break;
case POOL_DESTROY:
destroy = (pool_destroy_undo_t *)li->li_details;
assert(dict_put(prov->pkc_elements, destroy->pdu_elem,
destroy->pdu_elem) == NULL);
break;
case POOL_ASSOC:
assoc = (pool_assoc_undo_t *)li->li_details;
if (assoc->pau_oldres != NULL)
((pool_knl_pool_t *)assoc->pau_assoc)->pkp_assoc
[pool_resource_elem_class(assoc->pau_oldres)] =
(pool_knl_resource_t *)assoc->pau_oldres;
break;
case POOL_DISSOC:
dissoc = (pool_dissoc_undo_t *)li->li_details;
if (dissoc->pdu_oldres != NULL)
((pool_knl_pool_t *)dissoc->pdu_dissoc)->pkp_assoc
[pool_resource_elem_class(dissoc->pdu_oldres)] =
(pool_knl_resource_t *)dissoc->pdu_oldres;
break;
case POOL_TRANSFER:
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
break;
case POOL_XTRANSFER:
xtransfer = (pool_xtransfer_undo_t *)li->li_details;
for (size = 0; xtransfer->pxu_rl[size] != NULL; size++) {
pool_value_t val = POOL_VALUE_INITIALIZER;
uint64_t src_size;
uint64_t tgt_size;
if (pool_set_container(xtransfer->pxu_src,
TO_ELEM(xtransfer->pxu_rl[size])) == PO_FAIL) {
return (PO_FAIL);
}
/*
* Maintain the library view of the size
*/
if (resource_get_size(pool_elem_res(xtransfer->pxu_src),
&src_size) != PO_SUCCESS ||
resource_get_size(pool_elem_res(xtransfer->pxu_tgt),
&tgt_size) != PO_SUCCESS) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
src_size++;
tgt_size--;
pool_value_set_uint64(&val, src_size);
(void) pool_put_any_ns_property(xtransfer->pxu_src,
c_size_prop, &val);
pool_value_set_uint64(&val, tgt_size);
(void) pool_put_any_ns_property(xtransfer->pxu_tgt,
c_size_prop, &val);
}
break;
case POOL_PROPPUT:
propput = (pool_propput_undo_t *)li->li_details;
if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
if (propput->ppu_blist != NULL) {
if (nvlist_merge(
((pool_knl_elem_t *)propput->ppu_elem)->
pke_properties, propput->ppu_blist, 0)
!= 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
} else {
if (nvlist_unpack(propput->ppu_ioctl.pp_o_buf,
propput->ppu_ioctl.pp_o_bufsize,
&propput->ppu_alist, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
pair = nvlist_next_nvpair(propput->ppu_alist,
NULL);
(void) nvlist_remove_all(((pool_knl_elem_t *)
propput->ppu_elem)->pke_properties,
nvpair_name(pair));
nvlist_free(propput->ppu_alist);
}
}
break;
case POOL_PROPRM:
proprm = (pool_proprm_undo_t *)li->li_details;
if (pool_value_get_type(&proprm->pru_oldval) != POC_INVAL) {
if (pool_put_property(conf, proprm->pru_elem,
proprm->pru_ioctl.pp_o_prop_name,
&proprm->pru_oldval) != PO_SUCCESS) {
return (PO_FAIL);
}
}
break;
default:
return (PO_FAIL);
}
}
/*
* Only try to undo the state of the kernel if we modified it.
*/
if (li->li_state == LS_DO) {
return (PO_SUCCESS);
}
switch (li->li_op) {
case POOL_CREATE:
create = (pool_create_undo_t *)li->li_details;
u_destroy.pd_o_type = create->pcu_ioctl.pc_o_type;
u_destroy.pd_o_sub_type = create->pcu_ioctl.pc_o_sub_type;
u_destroy.pd_o_id = create->pcu_ioctl.pc_i_id;
while ((ret = ioctl(prov->pkc_fd, POOL_DESTROY,
&u_destroy)) < 0 && errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_DO;
break;
case POOL_DESTROY:
destroy = (pool_destroy_undo_t *)li->li_details;
u_create.pc_o_type = destroy->pdu_ioctl.pd_o_type;
u_create.pc_o_sub_type = destroy->pdu_ioctl.pd_o_sub_type;
if (ioctl(prov->pkc_fd, POOL_CREATE, &u_create) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if ((cb = alloc_char_buf(CB_DEFAULT_LEN)) == NULL) {
return (PO_FAIL);
}
if (set_char_buf(cb, "%s.sys_id",
pool_elem_class_string(destroy->pdu_elem)) != PO_SUCCESS) {
free_char_buf(cb);
return (PO_FAIL);
}
(void) nvlist_add_int64(
((pool_knl_elem_t *)destroy->pdu_elem)->pke_properties,
cb->cb_buf, u_create.pc_i_id);
free_char_buf(cb);
if (dict_put(prov->pkc_elements, destroy->pdu_elem,
destroy->pdu_elem) != NULL) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
/*
* Now we need to reset all the properties and
* associations in the kernel for this newly created
* replacement.
*/
u_propput.pp_o_id_type = destroy->pdu_ioctl.pd_o_type;
u_propput.pp_o_id_sub_type = destroy->pdu_ioctl.pd_o_sub_type;
u_propput.pp_o_id = u_create.pc_i_id;
u_propput.pp_o_buf = NULL;
/*
* Remove the read-only properties before attempting
* to restore the state of the newly created property
*/
(void) nvlist_dup(((pool_knl_elem_t *)destroy->pdu_elem)->
pke_properties, &tmplist, 0);
for (pair = nvlist_next_nvpair(tmplist, NULL); pair != NULL;
pair = nvlist_next_nvpair(tmplist, pair)) {
const pool_prop_t *prop;
char *name = nvpair_name(pair);
if ((prop = provider_get_prop(destroy->pdu_elem,
name)) != NULL)
if (prop_is_readonly(prop) == PO_TRUE)
(void) nvlist_remove_all(tmplist, name);
}
if (nvlist_pack(tmplist, (char **)&u_propput.pp_o_buf,
&u_propput.pp_o_bufsize, NV_ENCODE_NATIVE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
nvlist_free(tmplist);
if (ioctl(prov->pkc_fd, POOL_PROPPUT, &u_propput) < 0) {
free(u_propput.pp_o_buf);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
free(u_propput.pp_o_buf);
/*
* Now reset the associations for all the resource
* types if the thing which we are recreating is a
* pool
*
* TODO: This is resource specific and must be
* extended for additional resource types.
*/
if (destroy->pdu_ioctl.pd_o_type == PEC_POOL) {
u_assoc.pa_o_pool_id = u_create.pc_i_id;
u_assoc.pa_o_res_id =
elem_get_sysid(
TO_ELEM(((pool_knl_pool_t *)destroy->pdu_elem)->
pkp_assoc[PREC_PSET]));
u_assoc.pa_o_id_type = PREC_PSET;
if (ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
li->li_state = LS_DO;
break;
case POOL_ASSOC:
assoc = (pool_assoc_undo_t *)li->li_details;
u_assoc.pa_o_pool_id = elem_get_sysid(assoc->pau_assoc);
u_assoc.pa_o_res_id = elem_get_sysid(assoc->pau_oldres);
u_assoc.pa_o_id_type = assoc->pau_ioctl.pa_o_id_type;
while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc)) < 0 &&
errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_DO;
break;
case POOL_DISSOC:
dissoc = (pool_dissoc_undo_t *)li->li_details;
u_assoc.pa_o_pool_id = elem_get_sysid(dissoc->pdu_dissoc);
u_assoc.pa_o_res_id = elem_get_sysid(dissoc->pdu_oldres);
u_assoc.pa_o_id_type = dissoc->pdu_ioctl.pd_o_id_type;
while ((ret = ioctl(prov->pkc_fd, POOL_ASSOC, &u_assoc)) < 0 &&
errno == EAGAIN)
;
if (ret < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_DO;
break;
case POOL_TRANSFER:
li->li_state = LS_DO;
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
break;
case POOL_XTRANSFER:
xtransfer = (pool_xtransfer_undo_t *)li->li_details;
(void) memcpy(&u_xtransfer, &xtransfer->pxu_ioctl,
sizeof (pool_xtransfer_t));
u_xtransfer.px_o_src_id = elem_get_sysid(xtransfer->pxu_tgt);
u_xtransfer.px_o_tgt_id = elem_get_sysid(xtransfer->pxu_src);
if (ioctl(prov->pkc_fd, POOL_XTRANSFER, &u_xtransfer) < 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
li->li_state = LS_DO;
break;
case POOL_PROPPUT:
propput = (pool_propput_undo_t *)li->li_details;
if ((propput->ppu_doioctl & KERNEL_PROP_RDONLY) == 0) {
if (propput->ppu_blist) {
(void) memcpy(&u_propput, &propput->ppu_ioctl,
sizeof (pool_propput_t));
u_propput.pp_o_id =
elem_get_sysid(propput->ppu_elem);
u_propput.pp_o_buf = NULL;
if (nvlist_pack(propput->ppu_blist,
(char **)&u_propput.pp_o_buf,
&u_propput.pp_o_bufsize,
NV_ENCODE_NATIVE, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (ioctl(prov->pkc_fd, POOL_PROPPUT,
&u_propput) < 0) {
free(u_propput.pp_o_buf);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
free(u_propput.pp_o_buf);
} else {
if (nvlist_unpack(propput->
ppu_ioctl.pp_o_buf,
propput->ppu_ioctl.pp_o_bufsize,
&propput->ppu_alist, 0) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
u_proprm.pp_o_id_type =
propput->ppu_ioctl.pp_o_id_type;
u_proprm.pp_o_id_sub_type =
propput->ppu_ioctl.pp_o_id_sub_type;
u_proprm.pp_o_id =
elem_get_sysid(propput->ppu_elem);
pair = nvlist_next_nvpair(propput->ppu_alist,
NULL);
u_proprm.pp_o_prop_name = nvpair_name(pair);
u_proprm.pp_o_prop_name_size =
strlen(u_proprm.pp_o_prop_name);
if (provider_get_prop(propput->ppu_elem,
u_proprm.pp_o_prop_name) == NULL) {
if (ioctl(prov->pkc_fd, POOL_PROPRM,
&u_proprm) < 0) {
nvlist_free(propput->ppu_alist);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
}
nvlist_free(propput->ppu_alist);
}
}
li->li_state = LS_DO;
break;
case POOL_PROPRM:
proprm = (pool_proprm_undo_t *)li->li_details;
u_propput.pp_o_id_type = proprm->pru_ioctl.pp_o_id_type;
u_propput.pp_o_id_sub_type =
proprm->pru_ioctl.pp_o_id_sub_type;
u_propput.pp_o_id = elem_get_sysid(proprm->pru_elem);
u_propput.pp_o_buf = NULL;
/*
* Only try to remove the appropriate property
*/
if (nvlist_alloc(&tmplist, NV_UNIQUE_NAME_TYPE, 0) !=
0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (pool_knl_nvlist_add_value(tmplist,
pool_value_get_name(&proprm->pru_oldval),
&proprm->pru_oldval) != PO_SUCCESS)
return (PO_FAIL);
if (nvlist_pack(tmplist,
(char **)&u_propput.pp_o_buf, &u_propput.pp_o_bufsize,
NV_ENCODE_NATIVE, 0) != 0) {
nvlist_free(tmplist);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
nvlist_free(tmplist);
if (ioctl(prov->pkc_fd, POOL_PROPPUT, &u_propput) < 0) {
free(u_propput.pp_o_buf);
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
free(u_propput.pp_o_buf);
li->li_state = LS_DO;
break;
default:
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* A log item stores state about the transaction it represents. This
* function releases the resources associated with the transaction and
* used to store the transaction state.
*/
int
log_item_release(log_item_t *li)
{
pool_create_undo_t *create;
pool_destroy_undo_t *destroy;
pool_assoc_undo_t *assoc;
pool_dissoc_undo_t *dissoc;
pool_propput_undo_t *propput;
pool_proprm_undo_t *proprm;
pool_xtransfer_undo_t *xtransfer;
switch (li->li_op) {
case POOL_CREATE:
create = (pool_create_undo_t *)li->li_details;
free(create);
break;
case POOL_DESTROY:
destroy = (pool_destroy_undo_t *)li->li_details;
#ifdef DEBUG
dprintf("log_item_release: POOL_DESTROY\n");
#endif /* DEBUG */
if (li->li_state == LS_UNDO) {
#ifdef DEBUG
pool_elem_dprintf(destroy->pdu_elem);
#endif /* DEBUG */
pool_knl_elem_free((pool_knl_elem_t *)destroy->
pdu_elem, PO_TRUE);
}
free(destroy);
break;
case POOL_ASSOC:
assoc = (pool_assoc_undo_t *)li->li_details;
free(assoc);
break;
case POOL_DISSOC:
dissoc = (pool_dissoc_undo_t *)li->li_details;
free(dissoc);
break;
case POOL_TRANSFER:
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
break;
case POOL_XTRANSFER:
xtransfer = (pool_xtransfer_undo_t *)li->li_details;
free(xtransfer->pxu_rl);
free(xtransfer->pxu_ioctl.px_o_comp_list);
free(xtransfer);
break;
case POOL_PROPPUT:
propput = (pool_propput_undo_t *)li->li_details;
if (propput->ppu_blist)
nvlist_free(propput->ppu_blist);
free(propput->ppu_ioctl.pp_o_buf);
free(propput);
break;
case POOL_PROPRM:
proprm = (pool_proprm_undo_t *)li->li_details;
free(proprm);
break;
default:
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* pool_knl_nvlist_add_value() adds a pool_value_t to an nvlist.
*/
int
pool_knl_nvlist_add_value(nvlist_t *list, const char *name,
const pool_value_t *pv)
{
uint64_t uval;
int64_t ival;
double dval;
uchar_t dval_b[sizeof (double)];
uchar_t bval;
const char *sval;
pool_value_class_t type;
char *nv_name;
if ((type = pool_value_get_type(pv)) == POC_INVAL) {
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
nv_name = (char *)name;
switch (type) {
case POC_UINT:
if (pool_value_get_uint64(pv, &uval) == POC_INVAL) {
return (PO_FAIL);
}
if (nvlist_add_uint64(list, nv_name, uval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case POC_INT:
if (pool_value_get_int64(pv, &ival) == POC_INVAL) {
return (PO_FAIL);
}
if (nvlist_add_int64(list, nv_name, ival) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case POC_DOUBLE:
if (pool_value_get_double(pv, &dval) == POC_INVAL) {
return (PO_FAIL);
}
/*
* Since there is no support for doubles in the
* kernel, store the double value in a byte array.
*/
(void) memcpy(dval_b, &dval, sizeof (double));
if (nvlist_add_byte_array(list, nv_name, dval_b,
sizeof (double)) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case POC_BOOL:
if (pool_value_get_bool(pv, &bval) == POC_INVAL) {
return (PO_FAIL);
}
if (nvlist_add_byte(list, nv_name, bval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
case POC_STRING:
if (pool_value_get_string(pv, &sval) == POC_INVAL) {
return (PO_FAIL);
}
if (nvlist_add_string(list, nv_name, (char *)sval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
break;
default:
pool_seterror(POE_BADPARAM);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
/*
* hash_id() hashes all elements in a pool configuration using the
* "sys_id" property. Not all elements have a "sys_id" property,
* however elem_get_sysid() caters for this by always returning a
* constant value for those elements. This isn't anticipated to lead
* to a performance degradation in the hash, since those elements
* which are likely to be most prevalent in a configuration do have
* "sys_id" as a property.
*/
uint64_t
hash_id(const pool_elem_t *pe)
{
id_t id;
id = elem_get_sysid(pe);
return (hash_buf(&id, sizeof (id)));
}
/*
* blocking_open() guarantees access to the pool device, if open()
* is failing with EBUSY.
*/
int
blocking_open(const char *path, int oflag)
{
int fd;
while ((fd = open(path, oflag)) == -1 && errno == EBUSY)
(void) poll(NULL, 0, 1 * MILLISEC);
return (fd);
}