libipd.c revision fe77cc0407fb667ddc04e1a8f2e203bb7b9c80e1
/*
* This file and its contents are supplied under the terms of the
* Common Development and Distribution License ("CDDL"), version 1.0.
* You may only use this file in accordance with the terms of version
* 1.0 of the CDDL.
*
* A full copy of the text of the CDDL should have accompanied this
* source. A copy of the CDDL is also available via the Internet at
* http://www.illumos.org/license/CDDL.
*/
/*
* Copyright (c) 2012 Joyent, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <libipd.h>
#include <sys/ipd.h>
__thread ipd_errno_t ipd_errno = 0;
__thread char ipd_errmsg[512];
struct ipd_stat {
uint_t is_nzones;
zoneid_t *is_zoneids;
struct ipd_config *is_configs;
};
static ipd_errno_t
xlate_errno(int e)
{
switch (e) {
case 0:
return (EIPD_NOERROR);
case ENOMEM:
case EAGAIN:
return (EIPD_NOMEM);
case ERANGE:
return (EIPD_RANGE);
case EPERM:
return (EIPD_PERM);
case EFAULT:
return (EIPD_FAULT);
case ENOTTY:
return (EIPD_INTERNAL);
default:
return (EIPD_UNKNOWN);
}
}
const char *
ipd_strerror(ipd_errno_t e)
{
switch (e) {
case EIPD_NOERROR:
return ("no error");
case EIPD_NOMEM:
return ("out of memory");
case EIPD_ZC_NOENT:
return ("zone does not exist or is not using ipd");
case EIPD_RANGE:
return ("argument out of range");
case EIPD_PERM:
return ("permission denied");
case EIPD_FAULT:
return ("bad pointer");
case EIPD_INTERNAL:
return ("internal library error");
case EIPD_UNKNOWN:
default:
return ("unknown error");
}
}
static int
ipd_set_errno(ipd_errno_t e, const char *fmt, ...)
{
va_list ap;
ipd_errno = e;
if (fmt != NULL) {
va_start(ap, fmt);
(void) vsnprintf(ipd_errmsg, sizeof (ipd_errmsg), fmt, ap);
va_end(ap);
} else {
(void) strlcpy(ipd_errmsg,
ipd_strerror(e), sizeof (ipd_errmsg));
}
return (-1);
}
int
ipd_open(const char *path)
{
int fd;
if (path == NULL)
path = IPD_DEV_PATH;
fd = open(path, O_RDWR);
if (fd < 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to open %s: %s", path, strerror(errno)));
}
return (fd);
}
int
ipd_close(int fd)
{
(void) close(fd);
return (0);
}
int
ipd_status_read(int fd, ipd_stathdl_t *ispp)
{
struct ipd_stat *isp = NULL;
ipd_ioc_list_t ipil;
uint_t rzones;
uint_t i;
bzero(&ipil, sizeof (ipil));
if (ioctl(fd, IPDIOC_LIST, &ipil) != 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to retrieve ipd zone list: %s", strerror(errno)));
}
for (;;) {
if ((rzones = ipil.ipil_nzones) == 0)
break;
ipil.ipil_info =
malloc(sizeof (ipd_ioc_info_t) * ipil.ipil_nzones);
if (ipil.ipil_info == NULL)
return (ipd_set_errno(EIPD_NOMEM, NULL));
if (ioctl(fd, IPDIOC_LIST, &ipil) != 0) {
free(ipil.ipil_info);
return (ipd_set_errno(xlate_errno(errno),
"unable to retrieve ipd zone list: %s",
strerror(errno)));
}
if (ipil.ipil_nzones <= rzones)
break;
free(ipil.ipil_info);
}
if ((isp = malloc(sizeof (struct ipd_stat))) == NULL) {
free(ipil.ipil_info);
return (ipd_set_errno(EIPD_NOMEM, NULL));
}
isp->is_nzones = ipil.ipil_nzones;
if (isp->is_nzones == 0) {
isp->is_zoneids = NULL;
isp->is_configs = NULL;
*ispp = isp;
return (0);
}
isp->is_zoneids = malloc(sizeof (zoneid_t) * ipil.ipil_nzones);
if (isp->is_zoneids == NULL) {
free(ipil.ipil_info);
free(isp);
return (ipd_set_errno(EIPD_NOMEM, NULL));
}
isp->is_configs = malloc(sizeof (struct ipd_config) * ipil.ipil_nzones);
if (isp->is_configs == NULL) {
free(ipil.ipil_info);
free(isp->is_zoneids);
free(isp);
return (ipd_set_errno(EIPD_NOMEM, NULL));
}
for (i = 0; i < isp->is_nzones; i++) {
isp->is_zoneids[i] = ipil.ipil_info[i].ipii_zoneid;
isp->is_configs[i].ic_corrupt = ipil.ipil_info[i].ipii_corrupt;
isp->is_configs[i].ic_drop = ipil.ipil_info[i].ipii_drop;
isp->is_configs[i].ic_delay = ipil.ipil_info[i].ipii_delay;
isp->is_configs[i].ic_mask =
((!!isp->is_configs[i].ic_corrupt) * IPDM_CORRUPT) |
((!!isp->is_configs[i].ic_drop) * IPDM_DROP) |
((!!isp->is_configs[i].ic_delay) * IPDM_DELAY);
}
*ispp = isp;
return (0);
}
void
ipd_status_foreach_zone(const ipd_stathdl_t hdl, ipd_status_cb_f f, void *arg)
{
const struct ipd_stat *isp = hdl;
uint_t i;
for (i = 0; i < isp->is_nzones; i++)
f(isp->is_zoneids[i], &isp->is_configs[i], arg);
}
int
ipd_status_get_config(const ipd_stathdl_t hdl, zoneid_t z, ipd_config_t **icpp)
{
const struct ipd_stat *isp = hdl;
uint_t i;
for (i = 0; i < isp->is_nzones; i++) {
if (isp->is_zoneids[i] == z) {
*icpp = &isp->is_configs[i];
return (0);
}
}
return (ipd_set_errno(EIPD_ZC_NOENT,
"zone %d does not exist or has no ipd configuration", z));
}
void
ipd_status_free(ipd_stathdl_t hdl)
{
struct ipd_stat *isp = hdl;
if (isp != NULL) {
free(isp->is_zoneids);
free(isp->is_configs);
}
free(isp);
}
int
ipd_ctl(int fd, zoneid_t z, const ipd_config_t *icp)
{
ipd_ioc_perturb_t ipip;
bzero(&ipip, sizeof (ipd_ioc_perturb_t));
ipip.ipip_zoneid = z;
if (icp->ic_mask & IPDM_CORRUPT) {
if (icp->ic_corrupt == 0)
ipip.ipip_arg |= IPD_CORRUPT;
}
if (icp->ic_mask & IPDM_DELAY) {
if (icp->ic_delay == 0)
ipip.ipip_arg |= IPD_DELAY;
}
if (icp->ic_mask & IPDM_DROP) {
if (icp->ic_drop == 0)
ipip.ipip_arg |= IPD_DROP;
}
if (ipip.ipip_arg != 0 && ioctl(fd, IPDIOC_REMOVE, &ipip) != 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to remove cleared ipd settings: %s",
strerror(errno)));
}
if ((icp->ic_mask & IPDM_CORRUPT) && icp->ic_corrupt != 0) {
ipip.ipip_zoneid = z;
ipip.ipip_arg = icp->ic_corrupt;
if (ioctl(fd, IPDIOC_CORRUPT, &ipip) != 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to set corruption rate to %d: %s",
ipip.ipip_arg, strerror(errno)));
}
}
if ((icp->ic_mask & IPDM_DELAY) && icp->ic_delay != 0) {
ipip.ipip_zoneid = z;
ipip.ipip_arg = icp->ic_delay;
if (ioctl(fd, IPDIOC_DELAY, &ipip) != 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to set delay time to %d: %s",
ipip.ipip_arg, strerror(errno)));
}
}
if ((icp->ic_mask & IPDM_DROP) && icp->ic_drop != 0) {
ipip.ipip_zoneid = z;
ipip.ipip_arg = icp->ic_drop;
if (ioctl(fd, IPDIOC_DROP, &ipip) != 0) {
return (ipd_set_errno(xlate_errno(errno),
"unable to set drop probability to %d: %s",
ipip.ipip_arg, strerror(errno)));
}
}
return (0);
}