| 1 |
/** |
| 2 |
* collectd - src/utils_taskstats.c |
| 3 |
* Copyright (C) 2017 Florian octo Forster |
| 4 |
* |
| 5 |
* ISC License (ISC) |
| 6 |
* |
| 7 |
* Permission to use, copy, modify, and/or distribute this software for any |
| 8 |
* purpose with or without fee is hereby granted, provided that the above |
| 9 |
* copyright notice and this permission notice appear in all copies. |
| 10 |
* |
| 11 |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 12 |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 13 |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| 14 |
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 15 |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| 16 |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| 17 |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 18 |
* |
| 19 |
* Authors: |
| 20 |
* Florian octo Forster <octo at collectd.org> |
| 21 |
*/ |
| 22 |
|
| 23 |
#include "collectd.h" |
| 24 |
#include "utils/taskstats/taskstats.h" |
| 25 |
|
| 26 |
#include "plugin.h" |
| 27 |
#include "utils/common/common.h" |
| 28 |
#include "utils_time.h" |
| 29 |
|
| 30 |
#include <libmnl/libmnl.h> |
| 31 |
#include <linux/genetlink.h> |
| 32 |
#include <linux/taskstats.h> |
| 33 |
|
| 34 |
struct ts_s { |
| 35 |
struct mnl_socket *nl; |
| 36 |
pid_t pid; |
| 37 |
uint32_t seq; |
| 38 |
uint16_t genl_id_taskstats; |
| 39 |
unsigned int port_id; |
| 40 |
}; |
| 41 |
|
| 42 |
/* nlmsg_errno returns the errno encoded in nlh or zero if not an error. */ |
| 43 |
static int nlmsg_errno(struct nlmsghdr *nlh, size_t sz) { |
| 44 |
if (!mnl_nlmsg_ok(nlh, (int)sz)) { |
| 45 |
ERROR("utils_taskstats: mnl_nlmsg_ok failed."); |
| 46 |
return EPROTO; |
| 47 |
} |
| 48 |
|
| 49 |
if (nlh->nlmsg_type != NLMSG_ERROR) { |
| 50 |
return 0; |
| 51 |
} |
| 52 |
|
| 53 |
struct nlmsgerr *nlerr = mnl_nlmsg_get_payload(nlh); |
| 54 |
/* (struct nlmsgerr).error holds a negative errno. */ |
| 55 |
return nlerr->error * (-1); |
| 56 |
} |
| 57 |
|
| 58 |
static int get_taskstats_attr_cb(const struct nlattr *attr, void *data) { |
| 59 |
struct taskstats *ret_taskstats = data; |
| 60 |
|
| 61 |
uint16_t type = mnl_attr_get_type(attr); |
| 62 |
switch (type) { |
| 63 |
case TASKSTATS_TYPE_STATS: |
| 64 |
if (mnl_attr_get_payload_len(attr) != sizeof(*ret_taskstats)) { |
| 65 |
ERROR("utils_taskstats: mnl_attr_get_payload_len(attr) = %" PRIu32 |
| 66 |
", want %zu", |
| 67 |
mnl_attr_get_payload_len(attr), sizeof(*ret_taskstats)); |
| 68 |
return MNL_CB_ERROR; |
| 69 |
} |
| 70 |
struct taskstats *ts = mnl_attr_get_payload(attr); |
| 71 |
memmove(ret_taskstats, ts, sizeof(*ret_taskstats)); |
| 72 |
return MNL_CB_OK; |
| 73 |
|
| 74 |
case TASKSTATS_TYPE_AGGR_PID: /* fall through */ |
| 75 |
case TASKSTATS_TYPE_AGGR_TGID: |
| 76 |
return mnl_attr_parse_nested(attr, get_taskstats_attr_cb, ret_taskstats); |
| 77 |
|
| 78 |
case TASKSTATS_TYPE_PID: /* fall through */ |
| 79 |
case TASKSTATS_TYPE_TGID: |
| 80 |
/* ignore */ |
| 81 |
return MNL_CB_OK; |
| 82 |
|
| 83 |
default: |
| 84 |
DEBUG("utils_taskstats: unknown attribute %" PRIu16 |
| 85 |
", want one of TASKSTATS_TYPE_AGGR_PID/TGID, TASKSTATS_TYPE_STATS", |
| 86 |
type); |
| 87 |
} |
| 88 |
return MNL_CB_OK; |
| 89 |
} |
| 90 |
|
| 91 |
static int get_taskstats_msg_cb(const struct nlmsghdr *nlh, void *data) { |
| 92 |
return mnl_attr_parse(nlh, sizeof(struct genlmsghdr), get_taskstats_attr_cb, |
| 93 |
data); |
| 94 |
} |
| 95 |
|
| 96 |
static int get_taskstats(ts_t *ts, uint32_t tgid, |
| 97 |
struct taskstats *ret_taskstats) { |
| 98 |
char buffer[MNL_SOCKET_BUFFER_SIZE]; |
| 99 |
uint32_t seq = ts->seq++; |
| 100 |
|
| 101 |
struct nlmsghdr *nlh = mnl_nlmsg_put_header(buffer); |
| 102 |
*nlh = (struct nlmsghdr){ |
| 103 |
.nlmsg_len = nlh->nlmsg_len, |
| 104 |
.nlmsg_type = ts->genl_id_taskstats, |
| 105 |
.nlmsg_flags = NLM_F_REQUEST, |
| 106 |
.nlmsg_seq = seq, |
| 107 |
.nlmsg_pid = ts->pid, |
| 108 |
}; |
| 109 |
|
| 110 |
struct genlmsghdr *genh = mnl_nlmsg_put_extra_header(nlh, sizeof(*genh)); |
| 111 |
*genh = (struct genlmsghdr){ |
| 112 |
.cmd = TASKSTATS_CMD_GET, |
| 113 |
.version = TASKSTATS_GENL_VERSION, // or TASKSTATS_VERSION? |
| 114 |
}; |
| 115 |
|
| 116 |
// mnl_attr_put_u32(nlh, TASKSTATS_CMD_ATTR_PID, tgid); |
| 117 |
mnl_attr_put_u32(nlh, TASKSTATS_CMD_ATTR_TGID, tgid); |
| 118 |
|
| 119 |
if (mnl_socket_sendto(ts->nl, nlh, nlh->nlmsg_len) < 0) { |
| 120 |
int status = errno; |
| 121 |
ERROR("utils_taskstats: mnl_socket_sendto() = %s", STRERROR(status)); |
| 122 |
return status; |
| 123 |
} |
| 124 |
|
| 125 |
int status = mnl_socket_recvfrom(ts->nl, buffer, sizeof(buffer)); |
| 126 |
if (status < 0) { |
| 127 |
status = errno; |
| 128 |
ERROR("utils_taskstats: mnl_socket_recvfrom() = %s", STRERROR(status)); |
| 129 |
return status; |
| 130 |
} else if (status == 0) { |
| 131 |
ERROR("utils_taskstats: mnl_socket_recvfrom() = 0"); |
| 132 |
return ECONNABORTED; |
| 133 |
} |
| 134 |
size_t buffer_size = (size_t)status; |
| 135 |
|
| 136 |
if ((status = nlmsg_errno((void *)buffer, buffer_size)) != 0) { |
| 137 |
ERROR("utils_taskstats: TASKSTATS_CMD_GET(TASKSTATS_CMD_ATTR_TGID = " |
| 138 |
"%" PRIu32 ") = %s", |
| 139 |
(uint32_t)tgid, STRERROR(status)); |
| 140 |
return status; |
| 141 |
} |
| 142 |
|
| 143 |
status = mnl_cb_run(buffer, buffer_size, seq, ts->port_id, |
| 144 |
get_taskstats_msg_cb, ret_taskstats); |
| 145 |
if (status < MNL_CB_STOP) { |
| 146 |
ERROR("utils_taskstats: Parsing message failed."); |
| 147 |
return EPROTO; |
| 148 |
} |
| 149 |
|
| 150 |
return 0; |
| 151 |
} |
| 152 |
|
| 153 |
static int get_family_id_attr_cb(const struct nlattr *attr, void *data) { |
| 154 |
uint16_t type = mnl_attr_get_type(attr); |
| 155 |
if (type != CTRL_ATTR_FAMILY_ID) { |
| 156 |
return MNL_CB_OK; |
| 157 |
} |
| 158 |
|
| 159 |
if (mnl_attr_validate(attr, MNL_TYPE_U16) < 0) { |
| 160 |
ERROR("mnl_attr_validate() = %s", STRERRNO); |
| 161 |
return MNL_CB_ERROR; |
| 162 |
} |
| 163 |
|
| 164 |
uint16_t *ret_family_id = data; |
| 165 |
*ret_family_id = mnl_attr_get_u16(attr); |
| 166 |
return MNL_CB_STOP; |
| 167 |
} |
| 168 |
|
| 169 |
static int get_family_id_msg_cb(const struct nlmsghdr *nlh, void *data) { |
| 170 |
return mnl_attr_parse(nlh, sizeof(struct genlmsghdr), get_family_id_attr_cb, |
| 171 |
data); |
| 172 |
} |
| 173 |
|
| 174 |
/* get_family_id initializes ts->genl_id_taskstats. Returns 0 on success and |
| 175 |
* an error code otherwise. */ |
| 176 |
static int get_family_id(ts_t *ts) { |
| 177 |
char buffer[MNL_SOCKET_BUFFER_SIZE]; |
| 178 |
uint32_t seq = ts->seq++; |
| 179 |
|
| 180 |
struct nlmsghdr *nlh = mnl_nlmsg_put_header(buffer); |
| 181 |
*nlh = (struct nlmsghdr){ |
| 182 |
.nlmsg_len = nlh->nlmsg_len, |
| 183 |
.nlmsg_type = GENL_ID_CTRL, |
| 184 |
.nlmsg_flags = NLM_F_REQUEST, |
| 185 |
.nlmsg_seq = seq, |
| 186 |
.nlmsg_pid = ts->pid, |
| 187 |
}; |
| 188 |
|
| 189 |
struct genlmsghdr *genh = mnl_nlmsg_put_extra_header(nlh, sizeof(*genh)); |
| 190 |
*genh = (struct genlmsghdr){ |
| 191 |
.cmd = CTRL_CMD_GETFAMILY, |
| 192 |
.version = 0x01, |
| 193 |
}; |
| 194 |
|
| 195 |
mnl_attr_put_strz(nlh, CTRL_ATTR_FAMILY_NAME, TASKSTATS_GENL_NAME); |
| 196 |
|
| 197 |
assert(genh->cmd == CTRL_CMD_GETFAMILY); |
| 198 |
assert(genh->version == TASKSTATS_GENL_VERSION); |
| 199 |
|
| 200 |
if (mnl_socket_sendto(ts->nl, nlh, nlh->nlmsg_len) < 0) { |
| 201 |
int status = errno; |
| 202 |
ERROR("utils_taskstats: mnl_socket_sendto() = %s", STRERROR(status)); |
| 203 |
return status; |
| 204 |
} |
| 205 |
|
| 206 |
ts->genl_id_taskstats = 0; |
| 207 |
while (42) { |
| 208 |
int status = mnl_socket_recvfrom(ts->nl, buffer, sizeof(buffer)); |
| 209 |
if (status < 0) { |
| 210 |
status = errno; |
| 211 |
ERROR("utils_taskstats: mnl_socket_recvfrom() = %s", STRERROR(status)); |
| 212 |
return status; |
| 213 |
} else if (status == 0) { |
| 214 |
break; |
| 215 |
} |
| 216 |
size_t buffer_size = (size_t)status; |
| 217 |
|
| 218 |
if ((status = nlmsg_errno((void *)buffer, buffer_size)) != 0) { |
| 219 |
ERROR("utils_taskstats: CTRL_CMD_GETFAMILY(\"%s\"): %s", |
| 220 |
TASKSTATS_GENL_NAME, STRERROR(status)); |
| 221 |
return status; |
| 222 |
} |
| 223 |
|
| 224 |
status = mnl_cb_run(buffer, buffer_size, seq, ts->port_id, |
| 225 |
get_family_id_msg_cb, &ts->genl_id_taskstats); |
| 226 |
if (status < MNL_CB_STOP) { |
| 227 |
ERROR("utils_taskstats: Parsing message failed."); |
| 228 |
return EPROTO; |
| 229 |
} else if (status == MNL_CB_STOP) { |
| 230 |
break; |
| 231 |
} |
| 232 |
} |
| 233 |
|
| 234 |
if (ts->genl_id_taskstats == 0) { |
| 235 |
ERROR("utils_taskstats: Netlink communication succeeded, but " |
| 236 |
"genl_id_taskstats is still zero."); |
| 237 |
return ENOENT; |
| 238 |
} |
| 239 |
|
| 240 |
return 0; |
| 241 |
} |
| 242 |
|
| 243 |
void ts_destroy(ts_t *ts) { |
| 244 |
if (ts == NULL) { |
| 245 |
return; |
| 246 |
} |
| 247 |
|
| 248 |
if (ts->nl != NULL) { |
| 249 |
mnl_socket_close(ts->nl); |
| 250 |
ts->nl = NULL; |
| 251 |
} |
| 252 |
|
| 253 |
sfree(ts); |
| 254 |
} |
| 255 |
|
| 256 |
ts_t *ts_create(void) { |
| 257 |
ts_t *ts = calloc(1, sizeof(*ts)); |
| 258 |
if (ts == NULL) { |
| 259 |
ERROR("utils_taskstats: calloc failed: %s", STRERRNO); |
| 260 |
return NULL; |
| 261 |
} |
| 262 |
|
| 263 |
if ((ts->nl = mnl_socket_open(NETLINK_GENERIC)) == NULL) { |
| 264 |
ERROR("utils_taskstats: mnl_socket_open(NETLINK_GENERIC) = %s", STRERRNO); |
| 265 |
ts_destroy(ts); |
| 266 |
return NULL; |
| 267 |
} |
| 268 |
|
| 269 |
if (mnl_socket_bind(ts->nl, 0, MNL_SOCKET_AUTOPID) != 0) { |
| 270 |
ERROR("utils_taskstats: mnl_socket_bind() = %s", STRERRNO); |
| 271 |
ts_destroy(ts); |
| 272 |
return NULL; |
| 273 |
} |
| 274 |
|
| 275 |
ts->pid = getpid(); |
| 276 |
ts->port_id = mnl_socket_get_portid(ts->nl); |
| 277 |
|
| 278 |
int status = get_family_id(ts); |
| 279 |
if (status != 0) { |
| 280 |
ERROR("utils_taskstats: get_family_id() = %s", STRERROR(status)); |
| 281 |
ts_destroy(ts); |
| 282 |
return NULL; |
| 283 |
} |
| 284 |
|
| 285 |
return ts; |
| 286 |
} |
| 287 |
|
| 288 |
int ts_delay_by_tgid(ts_t *ts, uint32_t tgid, ts_delay_t *out) { |
| 289 |
if ((ts == NULL) || (out == NULL)) { |
| 290 |
return EINVAL; |
| 291 |
} |
| 292 |
|
| 293 |
struct taskstats raw = {0}; |
| 294 |
|
| 295 |
int status = get_taskstats(ts, tgid, &raw); |
| 296 |
if (status != 0) { |
| 297 |
return status; |
| 298 |
} |
| 299 |
|
| 300 |
*out = (ts_delay_t){ |
| 301 |
.cpu_ns = raw.cpu_delay_total, |
| 302 |
.blkio_ns = raw.blkio_delay_total, |
| 303 |
.swapin_ns = raw.swapin_delay_total, |
| 304 |
.freepages_ns = raw.freepages_delay_total, |
| 305 |
}; |
| 306 |
return 0; |
| 307 |
} |