1de7b4b805
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
544 lines
14 KiB
C
544 lines
14 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2013 Mikolaj Golub <trociny@FreeBSD.org>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/queue.h>
|
|
|
|
#include <bsnmp/snmpmod.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "hast.h"
|
|
#include "hast_oid.h"
|
|
#include "hast_proto.h"
|
|
#include "hast_tree.h"
|
|
#include "nv.h"
|
|
#include "pjdlog.h"
|
|
#include "proto.h"
|
|
|
|
#define UPDATE_INTERVAL 500 /* update interval in ticks */
|
|
|
|
static struct lmodule *module;
|
|
|
|
static const struct asn_oid oid_hast = OIDX_begemotHast;
|
|
|
|
/* the Object Resource registration index */
|
|
static u_int hast_index = 0;
|
|
|
|
/*
|
|
* Structure that describes single resource.
|
|
*/
|
|
struct hast_snmp_resource {
|
|
TAILQ_ENTRY(hast_snmp_resource) link;
|
|
int32_t index;
|
|
char name[NAME_MAX];
|
|
int error;
|
|
int role;
|
|
char provname[NAME_MAX];
|
|
char localpath[PATH_MAX];
|
|
int32_t extentsize;
|
|
int32_t keepdirty;
|
|
char remoteaddr[HAST_ADDRSIZE];
|
|
char sourceaddr[HAST_ADDRSIZE];
|
|
int replication;
|
|
int status;
|
|
uint64_t dirty;
|
|
uint64_t reads;
|
|
uint64_t writes;
|
|
uint64_t deletes;
|
|
uint64_t flushes;
|
|
uint64_t activemap_updates;
|
|
uint64_t read_errors;
|
|
uint64_t write_errors;
|
|
uint64_t delete_errors;
|
|
uint64_t flush_errors;
|
|
pid_t workerpid;
|
|
uint32_t local_queue;
|
|
uint32_t send_queue;
|
|
uint32_t recv_queue;
|
|
uint32_t done_queue;
|
|
uint32_t idle_queue;
|
|
};
|
|
|
|
static TAILQ_HEAD(, hast_snmp_resource) resources =
|
|
TAILQ_HEAD_INITIALIZER(resources);
|
|
|
|
/* Path to configuration file. */
|
|
static u_char *cfgpath;
|
|
/* Ticks of the last hast resources update. */
|
|
static uint64_t last_resources_update;
|
|
|
|
static void free_resources(void);
|
|
static int hastctl(struct nv *nvin, struct nv **nvout);
|
|
static int hast_fini(void);
|
|
static int hast_init(struct lmodule *mod, int argc, char *argv[]);
|
|
static void hast_start(void);
|
|
static int set_role(const char *resource, int role);
|
|
static int str2role(const char *str);
|
|
static int str2replication(const char *str);
|
|
static int str2status(const char *str);
|
|
static int update_resources(void);
|
|
|
|
const struct snmp_module config = {
|
|
.comment = "This module implements the BEGEMOT MIB for HAST.",
|
|
.init = hast_init,
|
|
.start = hast_start,
|
|
.fini = hast_fini,
|
|
.tree = hast_ctree,
|
|
.tree_size = hast_CTREE_SIZE,
|
|
};
|
|
|
|
static int
|
|
hast_init(struct lmodule *mod, int argc __unused, char *argv[] __unused)
|
|
{
|
|
|
|
module = mod;
|
|
|
|
pjdlog_init(PJDLOG_MODE_SYSLOG);
|
|
pjdlog_debug_set(0);
|
|
|
|
cfgpath = malloc(sizeof(HAST_CONFIG));
|
|
if (cfgpath == NULL) {
|
|
pjdlog_error("Unable to allocate %zu bytes for cfgpath",
|
|
sizeof(HAST_CONFIG));
|
|
return (-1);
|
|
}
|
|
strcpy(cfgpath, HAST_CONFIG);
|
|
return(0);
|
|
}
|
|
|
|
static void
|
|
hast_start(void)
|
|
{
|
|
hast_index = or_register(&oid_hast,
|
|
"The MIB module for BEGEMOT-HAST-MIB.", module);
|
|
}
|
|
|
|
static int
|
|
hast_fini(void)
|
|
{
|
|
|
|
or_unregister(hast_index);
|
|
free_resources();
|
|
free(cfgpath);
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
free_resources(void)
|
|
{
|
|
struct hast_snmp_resource *res;
|
|
|
|
while ((res = TAILQ_FIRST(&resources)) != NULL) {
|
|
TAILQ_REMOVE(&resources, res, link);
|
|
free(res);
|
|
}
|
|
}
|
|
|
|
static int
|
|
str2role(const char *str)
|
|
{
|
|
|
|
if (strcmp(str, "init") == 0)
|
|
return (HAST_ROLE_INIT);
|
|
if (strcmp(str, "primary") == 0)
|
|
return (HAST_ROLE_PRIMARY);
|
|
if (strcmp(str, "secondary") == 0)
|
|
return (HAST_ROLE_SECONDARY);
|
|
return (HAST_ROLE_UNDEF);
|
|
}
|
|
|
|
static int
|
|
str2replication(const char *str)
|
|
{
|
|
|
|
if (strcmp(str, "fullsync") == 0)
|
|
return (HAST_REPLICATION_FULLSYNC);
|
|
if (strcmp(str, "memsync") == 0)
|
|
return (HAST_REPLICATION_MEMSYNC);
|
|
if (strcmp(str, "async") == 0)
|
|
return (HAST_REPLICATION_ASYNC);
|
|
return (-1);
|
|
}
|
|
|
|
static int
|
|
str2status(const char *str)
|
|
{
|
|
|
|
if (strcmp(str, "complete") == 0)
|
|
return (0);
|
|
if (strcmp(str, "degraded") == 0)
|
|
return (1);
|
|
return (-1);
|
|
}
|
|
|
|
static int
|
|
hastctl(struct nv *nvin, struct nv **nvout)
|
|
{
|
|
struct hastd_config *cfg;
|
|
struct proto_conn *conn;
|
|
struct nv *nv;
|
|
int error;
|
|
|
|
cfg = yy_config_parse(cfgpath, true);
|
|
if (cfg == NULL)
|
|
return (-1);
|
|
|
|
/* Setup control connection... */
|
|
if (proto_client(NULL, cfg->hc_controladdr, &conn) == -1) {
|
|
pjdlog_error("Unable to setup control connection to %s",
|
|
cfg->hc_controladdr);
|
|
return (-1);
|
|
}
|
|
/* ...and connect to hastd. */
|
|
if (proto_connect(conn, HAST_TIMEOUT) == -1) {
|
|
pjdlog_error("Unable to connect to hastd via %s",
|
|
cfg->hc_controladdr);
|
|
proto_close(conn);
|
|
return (-1);
|
|
}
|
|
/* Send the command to the server... */
|
|
if (hast_proto_send(NULL, conn, nvin, NULL, 0) == -1) {
|
|
pjdlog_error("Unable to send command to hastd via %s",
|
|
cfg->hc_controladdr);
|
|
proto_close(conn);
|
|
return (-1);
|
|
}
|
|
/* ...and receive reply. */
|
|
if (hast_proto_recv_hdr(conn, &nv) == -1) {
|
|
pjdlog_error("cannot receive reply from hastd via %s",
|
|
cfg->hc_controladdr);
|
|
proto_close(conn);
|
|
return (-1);
|
|
}
|
|
proto_close(conn);
|
|
error = nv_get_int16(nv, "error");
|
|
if (error != 0) {
|
|
pjdlog_error("Error %d received from hastd.", error);
|
|
nv_free(nv);
|
|
return (-1);
|
|
}
|
|
nv_set_error(nv, 0);
|
|
*nvout = nv;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
set_role(const char *resource, int role)
|
|
{
|
|
struct nv *nvin, *nvout;
|
|
int error;
|
|
|
|
nvin = nv_alloc();
|
|
nv_add_string(nvin, resource, "resource%d", 0);
|
|
nv_add_uint8(nvin, HASTCTL_CMD_SETROLE, "cmd");
|
|
nv_add_uint8(nvin, role, "role");
|
|
error = hastctl(nvin, &nvout);
|
|
nv_free(nvin);
|
|
if (error != 0)
|
|
return (-1);
|
|
nv_free(nvout);
|
|
return (SNMP_ERR_NOERROR);
|
|
}
|
|
|
|
static int
|
|
update_resources(void)
|
|
{
|
|
struct hast_snmp_resource *res;
|
|
struct nv *nvin, *nvout;
|
|
static uint64_t now;
|
|
unsigned int i;
|
|
const char *str;
|
|
int error;
|
|
|
|
now = get_ticks();
|
|
if (now - last_resources_update < UPDATE_INTERVAL)
|
|
return (0);
|
|
|
|
last_resources_update = now;
|
|
|
|
free_resources();
|
|
|
|
nvin = nv_alloc();
|
|
nv_add_uint8(nvin, HASTCTL_CMD_STATUS, "cmd");
|
|
nv_add_string(nvin, "all", "resource%d", 0);
|
|
error = hastctl(nvin, &nvout);
|
|
nv_free(nvin);
|
|
if (error != 0)
|
|
return (-1);
|
|
|
|
for (i = 0; ; i++) {
|
|
str = nv_get_string(nvout, "resource%u", i);
|
|
if (str == NULL)
|
|
break;
|
|
res = calloc(1, sizeof(*res));
|
|
if (res == NULL) {
|
|
pjdlog_error("Unable to allocate %zu bytes for "
|
|
"resource", sizeof(*res));
|
|
return (-1);
|
|
}
|
|
res->index = i + 1;
|
|
strncpy(res->name, str, sizeof(res->name) - 1);
|
|
error = nv_get_int16(nvout, "error%u", i);
|
|
if (error != 0)
|
|
continue;
|
|
str = nv_get_string(nvout, "role%u", i);
|
|
res->role = str != NULL ? str2role(str) : HAST_ROLE_UNDEF;
|
|
str = nv_get_string(nvout, "provname%u", i);
|
|
if (str != NULL)
|
|
strncpy(res->provname, str, sizeof(res->provname) - 1);
|
|
str = nv_get_string(nvout, "localpath%u", i);
|
|
if (str != NULL) {
|
|
strncpy(res->localpath, str,
|
|
sizeof(res->localpath) - 1);
|
|
}
|
|
res->extentsize = nv_get_uint32(nvout, "extentsize%u", i);
|
|
res->keepdirty = nv_get_uint32(nvout, "keepdirty%u", i);
|
|
str = nv_get_string(nvout, "remoteaddr%u", i);
|
|
if (str != NULL) {
|
|
strncpy(res->remoteaddr, str,
|
|
sizeof(res->remoteaddr) - 1);
|
|
}
|
|
str = nv_get_string(nvout, "sourceaddr%u", i);
|
|
if (str != NULL) {
|
|
strncpy(res->sourceaddr, str,
|
|
sizeof(res->sourceaddr) - 1);
|
|
}
|
|
str = nv_get_string(nvout, "replication%u", i);
|
|
res->replication = str != NULL ? str2replication(str) : -1;
|
|
str = nv_get_string(nvout, "status%u", i);
|
|
res->status = str != NULL ? str2status(str) : -1;
|
|
res->dirty = nv_get_uint64(nvout, "dirty%u", i);
|
|
res->reads = nv_get_uint64(nvout, "stat_read%u", i);
|
|
res->writes = nv_get_uint64(nvout, "stat_write%u", i);
|
|
res->deletes = nv_get_uint64(nvout, "stat_delete%u", i);
|
|
res->flushes = nv_get_uint64(nvout, "stat_flush%u", i);
|
|
res->activemap_updates =
|
|
nv_get_uint64(nvout, "stat_activemap_update%u", i);
|
|
res->read_errors =
|
|
nv_get_uint64(nvout, "stat_read_error%u", i);
|
|
res->write_errors =
|
|
nv_get_uint64(nvout, "stat_write_error%u", i);
|
|
res->delete_errors =
|
|
nv_get_uint64(nvout, "stat_delete_error%u", i);
|
|
res->flush_errors =
|
|
nv_get_uint64(nvout, "stat_flush_error%u", i);
|
|
res->workerpid = nv_get_int32(nvout, "workerpid%u", i);
|
|
res->local_queue =
|
|
nv_get_uint64(nvout, "local_queue_size%u", i);
|
|
res->send_queue =
|
|
nv_get_uint64(nvout, "send_queue_size%u", i);
|
|
res->recv_queue =
|
|
nv_get_uint64(nvout, "recv_queue_size%u", i);
|
|
res->done_queue =
|
|
nv_get_uint64(nvout, "done_queue_size%u", i);
|
|
res->idle_queue =
|
|
nv_get_uint64(nvout, "idle_queue_size%u", i);
|
|
TAILQ_INSERT_TAIL(&resources, res, link);
|
|
}
|
|
nv_free(nvout);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
op_hastConfig(struct snmp_context *context, struct snmp_value *value,
|
|
u_int sub, u_int iidx __unused, enum snmp_op op)
|
|
{
|
|
asn_subid_t which;
|
|
|
|
which = value->var.subs[sub - 1];
|
|
|
|
switch (op) {
|
|
case SNMP_OP_GET:
|
|
switch (which) {
|
|
case LEAF_hastConfigFile:
|
|
return (string_get(value, cfgpath, -1));
|
|
default:
|
|
return (SNMP_ERR_RES_UNAVAIL);
|
|
}
|
|
case SNMP_OP_SET:
|
|
switch (which) {
|
|
case LEAF_hastConfigFile:
|
|
return (string_save(value, context, -1,
|
|
(u_char **)&cfgpath));
|
|
default:
|
|
return (SNMP_ERR_RES_UNAVAIL);
|
|
}
|
|
case SNMP_OP_GETNEXT:
|
|
case SNMP_OP_ROLLBACK:
|
|
case SNMP_OP_COMMIT:
|
|
return (SNMP_ERR_NOERROR);
|
|
default:
|
|
return (SNMP_ERR_RES_UNAVAIL);
|
|
}
|
|
}
|
|
|
|
int
|
|
op_hastResourceTable(struct snmp_context *context __unused,
|
|
struct snmp_value *value, u_int sub, u_int iidx __unused, enum snmp_op op)
|
|
{
|
|
struct hast_snmp_resource *res;
|
|
asn_subid_t which;
|
|
int ret;
|
|
|
|
if (update_resources() == -1)
|
|
return (SNMP_ERR_RES_UNAVAIL);
|
|
|
|
which = value->var.subs[sub - 1];
|
|
|
|
switch (op) {
|
|
case SNMP_OP_GETNEXT:
|
|
res = NEXT_OBJECT_INT(&resources, &value->var, sub);
|
|
if (res == NULL)
|
|
return (SNMP_ERR_NOSUCHNAME);
|
|
value->var.len = sub + 1;
|
|
value->var.subs[sub] = res->index;
|
|
break;
|
|
case SNMP_OP_GET:
|
|
if (value->var.len - sub != 1)
|
|
return (SNMP_ERR_NOSUCHNAME);
|
|
res = FIND_OBJECT_INT(&resources, &value->var, sub);
|
|
if (res == NULL)
|
|
return (SNMP_ERR_NOSUCHNAME);
|
|
break;
|
|
case SNMP_OP_SET:
|
|
res = FIND_OBJECT_INT(&resources, &value->var, sub);
|
|
if (res == NULL)
|
|
return (SNMP_ERR_NOSUCHNAME);
|
|
switch (which) {
|
|
case LEAF_hastResourceRole:
|
|
ret = set_role(res->name, value->v.integer);
|
|
/* force update on next run */
|
|
last_resources_update = 0;
|
|
break;
|
|
default:
|
|
ret = SNMP_ERR_NOT_WRITEABLE;
|
|
break;
|
|
}
|
|
return ret;
|
|
case SNMP_OP_ROLLBACK:
|
|
case SNMP_OP_COMMIT:
|
|
return (SNMP_ERR_NOERROR);
|
|
default:
|
|
return (SNMP_ERR_RES_UNAVAIL);
|
|
}
|
|
|
|
ret = SNMP_ERR_NOERROR;
|
|
|
|
switch (which) {
|
|
case LEAF_hastResourceIndex:
|
|
value->v.integer = res->index;
|
|
break;
|
|
case LEAF_hastResourceName:
|
|
ret = string_get(value, res->name, -1);
|
|
break;
|
|
case LEAF_hastResourceRole:
|
|
value->v.integer = res->role;
|
|
break;
|
|
case LEAF_hastResourceProvName:
|
|
ret = string_get(value, res->provname, -1);
|
|
break;
|
|
case LEAF_hastResourceLocalPath:
|
|
ret = string_get(value, res->localpath, -1);
|
|
break;
|
|
case LEAF_hastResourceExtentSize:
|
|
value->v.integer = res->extentsize;
|
|
break;
|
|
case LEAF_hastResourceKeepDirty:
|
|
value->v.integer = res->keepdirty;
|
|
break;
|
|
case LEAF_hastResourceRemoteAddr:
|
|
ret = string_get(value, res->remoteaddr, -1);
|
|
break;
|
|
case LEAF_hastResourceSourceAddr:
|
|
ret = string_get(value, res->sourceaddr, -1);
|
|
break;
|
|
case LEAF_hastResourceReplication:
|
|
value->v.integer = res->replication;
|
|
break;
|
|
case LEAF_hastResourceStatus:
|
|
value->v.integer = res->status;
|
|
break;
|
|
case LEAF_hastResourceDirty:
|
|
value->v.counter64 = res->dirty;
|
|
break;
|
|
case LEAF_hastResourceReads:
|
|
value->v.counter64 = res->reads;
|
|
break;
|
|
case LEAF_hastResourceWrites:
|
|
value->v.counter64 = res->writes;
|
|
break;
|
|
case LEAF_hastResourceDeletes:
|
|
value->v.counter64 = res->deletes;
|
|
break;
|
|
case LEAF_hastResourceFlushes:
|
|
value->v.counter64 = res->flushes;
|
|
break;
|
|
case LEAF_hastResourceActivemapUpdates:
|
|
value->v.counter64 = res->activemap_updates;
|
|
break;
|
|
case LEAF_hastResourceReadErrors:
|
|
value->v.counter64 = res->read_errors;
|
|
break;
|
|
case LEAF_hastResourceWriteErrors:
|
|
value->v.counter64 = res->write_errors;
|
|
break;
|
|
case LEAF_hastResourceDeleteErrors:
|
|
value->v.counter64 = res->delete_errors;
|
|
break;
|
|
case LEAF_hastResourceFlushErrors:
|
|
value->v.counter64 = res->flush_errors;
|
|
break;
|
|
case LEAF_hastResourceWorkerPid:
|
|
value->v.integer = res->workerpid;
|
|
break;
|
|
case LEAF_hastResourceLocalQueue:
|
|
value->v.uint32 = res->local_queue;
|
|
break;
|
|
case LEAF_hastResourceSendQueue:
|
|
value->v.uint32 = res->send_queue;
|
|
break;
|
|
case LEAF_hastResourceRecvQueue:
|
|
value->v.uint32 = res->recv_queue;
|
|
break;
|
|
case LEAF_hastResourceDoneQueue:
|
|
value->v.uint32 = res->done_queue;
|
|
break;
|
|
case LEAF_hastResourceIdleQueue:
|
|
value->v.uint32 = res->idle_queue;
|
|
break;
|
|
default:
|
|
ret = SNMP_ERR_RES_UNAVAIL;
|
|
break;
|
|
}
|
|
return (ret);
|
|
}
|