git.ipfire.org Git - thirdparty/iproute2.git/blob

1 /*

2 * tcp_metrics.c "ip tcp_metrics/tcpmetrics"

3 *

4 * This program is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU General Public License

6 * version 2 as published by the Free Software Foundation;

7 *

8 * Authors: Julian Anastasov <ja@ssi.bg>, August 2012

9 */

11 #include <stdio.h>

12 #include <stdlib.h>

13 #include <string.h>

14 #include <unistd.h>

15 #include <errno.h>

16 #include <sys/types.h>

17 #include <sys/socket.h>

18 #include <arpa/inet.h>

19 #include <sys/ioctl.h>

20 #include <linux/if.h>

22 #include <linux/genetlink.h>

23 #include <linux/tcp_metrics.h>

25 #include "utils.h"

26 #include "ip_common.h"

27 #include "libgenl.h"

29 static void usage(void)

30 {

31 fprintf(stderr, "Usage: ip tcp_metrics/tcpmetrics { COMMAND | help }\n");

32 fprintf(stderr, " ip tcp_metrics { show | flush } SELECTOR\n");

33 fprintf(stderr, " ip tcp_metrics delete [ address ] ADDRESS\n");

34 fprintf(stderr, "SELECTOR := [ [ address ] PREFIX ]\n");

35 exit(-1);

36 }

38 /* netlink socket */

39 static struct rtnl_handle grth = { .fd = -1 };

40 static int genl_family = -1;

42 #define TCPM_REQUEST(_req, _bufsiz, _cmd, _flags) \

43 GENL_REQUEST(_req, _bufsiz, genl_family, 0, \

44 TCP_METRICS_GENL_VERSION, _cmd, _flags)

46 #define CMD_LIST 0x0001 /* list, lst, show */

47 #define CMD_DEL 0x0002 /* delete, remove */

48 #define CMD_FLUSH 0x0004 /* flush */

50 static struct {

51 char *name;

52 int code;

53 } cmds[] = {

54 { "list", CMD_LIST },

55 { "lst", CMD_LIST },

56 { "show", CMD_LIST },

57 { "delete", CMD_DEL },

58 { "remove", CMD_DEL },

59 { "flush", CMD_FLUSH },

60 };

62 static char *metric_name[TCP_METRIC_MAX + 1] = {

63 [TCP_METRIC_RTT] = "rtt",

64 [TCP_METRIC_RTTVAR] = "rttvar",

65 [TCP_METRIC_SSTHRESH] = "ssthresh",

66 [TCP_METRIC_CWND] = "cwnd",

67 [TCP_METRIC_REORDERING] = "reordering",

68 };

70 static struct

71 {

72 int flushed;

73 char *flushb;

74 int flushp;

75 int flushe;

76 int cmd;

77 inet_prefix daddr;

78 inet_prefix saddr;

79 } f;

81 static int flush_update(void)

82 {

83 if (rtnl_send_check(&grth, f.flushb, f.flushp) < 0) {

84 perror("Failed to send flush request\n");

85 return -1;

86 }

87 f.flushp = 0;

88 return 0;

89 }

91 static int process_msg(const struct sockaddr_nl *who, struct nlmsghdr *n,

92 void *arg)

93 {

94 FILE *fp = (FILE *) arg;

95 struct genlmsghdr *ghdr;

96 struct rtattr *attrs[TCP_METRICS_ATTR_MAX + 1], *a;

97 int len = n->nlmsg_len;

98 inet_prefix daddr, saddr;

99 int family, i, atype, stype, dlen = 0, slen = 0;

100

101 if (n->nlmsg_type != genl_family)

102 return -1;

103

104 len -= NLMSG_LENGTH(GENL_HDRLEN);

105 if (len < 0)

106 return -1;

107

108 ghdr = NLMSG_DATA(n);

109 if (ghdr->cmd != TCP_METRICS_CMD_GET)

110 return 0;

111

112 parse_rtattr(attrs, TCP_METRICS_ATTR_MAX, (void *) ghdr + GENL_HDRLEN,

113 len);

114

115 a = attrs[TCP_METRICS_ATTR_ADDR_IPV4];

116 if (a) {

117 if (f.daddr.family && f.daddr.family != AF_INET)

118 return 0;

119 memcpy(&daddr.data, RTA_DATA(a), 4);

120 daddr.bytelen = 4;

121 family = AF_INET;

122 atype = TCP_METRICS_ATTR_ADDR_IPV4;

123 dlen = RTA_PAYLOAD(a);

124 } else {

125 a = attrs[TCP_METRICS_ATTR_ADDR_IPV6];

126 if (a) {

127 if (f.daddr.family && f.daddr.family != AF_INET6)

128 return 0;

129 memcpy(&daddr.data, RTA_DATA(a), 16);

130 daddr.bytelen = 16;

131 family = AF_INET6;

132 atype = TCP_METRICS_ATTR_ADDR_IPV6;

133 dlen = RTA_PAYLOAD(a);

134 } else

135 return 0;

136 }

137

138 a = attrs[TCP_METRICS_ATTR_SADDR_IPV4];

139 if (a) {

140 if (f.saddr.family && f.saddr.family != AF_INET)

141 return 0;

142 memcpy(&saddr.data, RTA_DATA(a), 4);

143 saddr.bytelen = 4;

144 stype = TCP_METRICS_ATTR_SADDR_IPV4;

145 slen = RTA_PAYLOAD(a);

146 } else {

147 a = attrs[TCP_METRICS_ATTR_SADDR_IPV6];

148 if (a) {

149 if (f.saddr.family && f.saddr.family != AF_INET6)

150 return 0;

151 memcpy(&saddr.data, RTA_DATA(a), 16);

152 saddr.bytelen = 16;

153 stype = TCP_METRICS_ATTR_SADDR_IPV6;

154 slen = RTA_PAYLOAD(a);

155 }

156 }

157

158 if (f.daddr.family && f.daddr.bitlen >= 0 &&

159 inet_addr_match(&daddr, &f.daddr, f.daddr.bitlen))

160 return 0;

161 /* Only check for the source-address if the kernel supports it,

162 * meaning slen != 0.

163 */

164 if (slen && f.saddr.family && f.saddr.bitlen >= 0 &&

165 inet_addr_match(&saddr, &f.saddr, f.saddr.bitlen))

166 return 0;

167

168 if (f.flushb) {

169 struct nlmsghdr *fn;

170

171 TCPM_REQUEST(req2, 128, TCP_METRICS_CMD_DEL, NLM_F_REQUEST);

172

173 addattr_l(&req2.n, sizeof(req2), atype, &daddr.data,

174 daddr.bytelen);

175 if (slen)

176 addattr_l(&req2.n, sizeof(req2), stype, &saddr.data,

177 saddr.bytelen);

178

179 if (NLMSG_ALIGN(f.flushp) + req2.n.nlmsg_len > f.flushe) {

180 if (flush_update())

181 return -1;

182 }

183 fn = (struct nlmsghdr *) (f.flushb + NLMSG_ALIGN(f.flushp));

184 memcpy(fn, &req2.n, req2.n.nlmsg_len);

185 fn->nlmsg_seq = ++grth.seq;

186 f.flushp = (((char *) fn) + req2.n.nlmsg_len) - f.flushb;

187 f.flushed++;

188 if (show_stats < 2)

189 return 0;

190 }

191

192 if (f.cmd & (CMD_DEL | CMD_FLUSH))

193 fprintf(fp, "Deleted ");

194

195 fprintf(fp, "%s",

196 format_host(family, dlen, &daddr.data));

197

198 a = attrs[TCP_METRICS_ATTR_AGE];

199 if (a) {

200 unsigned long long val = rta_getattr_u64(a);

201

202 fprintf(fp, " age %llu.%03llusec",

203 val / 1000, val % 1000);

204 }

205

206 a = attrs[TCP_METRICS_ATTR_TW_TS_STAMP];

207 if (a) {

208 __s32 val = (__s32) rta_getattr_u32(a);

209 __u32 tsval;

210

211 a = attrs[TCP_METRICS_ATTR_TW_TSVAL];

212 tsval = a ? rta_getattr_u32(a) : 0;

213 fprintf(fp, " tw_ts %u/%dsec ago", tsval, val);

214 }

215

216 a = attrs[TCP_METRICS_ATTR_VALS];

217 if (a) {

218 struct rtattr *m[TCP_METRIC_MAX + 1 + 1];

219 unsigned long rtt = 0, rttvar = 0;

220

221 parse_rtattr_nested(m, TCP_METRIC_MAX + 1, a);

222

223 for (i = 0; i < TCP_METRIC_MAX + 1; i++) {

224 unsigned long val;

225

226 a = m[i + 1];

227 if (!a)

228 continue;

229 if (i != TCP_METRIC_RTT &&

230 i != TCP_METRIC_RTT_US &&

231 i != TCP_METRIC_RTTVAR &&

232 i != TCP_METRIC_RTTVAR_US) {

233 if (metric_name[i])

234 fprintf(fp, " %s ", metric_name[i]);

235 else

236 fprintf(fp, " metric_%d ", i);

237 }

238 val = rta_getattr_u32(a);

239 switch (i) {

240 case TCP_METRIC_RTT:

241 if (!rtt)

242 rtt = (val * 1000UL) >> 3;

243 break;

244 case TCP_METRIC_RTTVAR:

245 if (!rttvar)

246 rttvar = (val * 1000UL) >> 2;

247 break;

248 case TCP_METRIC_RTT_US:

249 rtt = val >> 3;

250 break;

251 case TCP_METRIC_RTTVAR_US:

252 rttvar = val >> 2;

253 break;

254 case TCP_METRIC_SSTHRESH:

255 case TCP_METRIC_CWND:

256 case TCP_METRIC_REORDERING:

257 default:

258 fprintf(fp, "%lu", val);

259 break;

260 }

261 }

262 if (rtt)

263 fprintf(fp, " rtt %luus", rtt);

264 if (rttvar)

265 fprintf(fp, " rttvar %luus", rttvar);

266 }

267

268 a = attrs[TCP_METRICS_ATTR_FOPEN_MSS];

269 if (a)

270 fprintf(fp, " fo_mss %u", rta_getattr_u16(a));

271

272 a = attrs[TCP_METRICS_ATTR_FOPEN_SYN_DROPS];

273 if (a) {

274 __u16 syn_loss = rta_getattr_u16(a);

275 unsigned long long ts;

276

277 a = attrs[TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS];

278 ts = a ? rta_getattr_u64(a) : 0;

279

280 fprintf(fp, " fo_syn_drops %u/%llu.%03llusec ago",

281 syn_loss, ts / 1000, ts % 1000);

282 }

283

284 a = attrs[TCP_METRICS_ATTR_FOPEN_COOKIE];

285 if (a) {

286 char cookie[32 + 1];

287 unsigned char *ptr = RTA_DATA(a);

288 int i, max = RTA_PAYLOAD(a);

289

290 if (max > 16)

291 max = 16;

292 cookie[0] = 0;

293 for (i = 0; i < max; i++)

294 sprintf(cookie + i + i, "%02x", ptr[i]);

295 fprintf(fp, " fo_cookie %s", cookie);

296 }

297

298 if (slen) {

299 fprintf(fp, " source %s",

300 format_host(family, slen, &saddr.data));

301 }

302

303 fprintf(fp, "\n");

304

305 fflush(fp);

306 return 0;

307 }

308

309 static int tcpm_do_cmd(int cmd, int argc, char **argv)

310 {

311 TCPM_REQUEST(req, 1024, TCP_METRICS_CMD_GET, NLM_F_REQUEST);

312 int atype = -1, stype = -1;

313 int ack;

314

315 memset(&f, 0, sizeof(f));

316 f.daddr.bitlen = -1;

317 f.daddr.family = preferred_family;

318 f.saddr.bitlen = -1;

319 f.saddr.family = preferred_family;

320

321 switch (preferred_family) {

322 case AF_UNSPEC:

323 case AF_INET:

324 case AF_INET6:

325 break;

326 default:

327 fprintf(stderr, "Unsupported protocol family: %d\n", preferred_family);

328 return -1;

329 }

330

331 for (; argc > 0; argc--, argv++) {

332 if (strcmp(*argv, "src") == 0 ||

333 strcmp(*argv, "source") == 0) {

334 char *who = *argv;

335

336 NEXT_ARG();

337 if (matches(*argv, "help") == 0)

338 usage();

339 if (f.saddr.bitlen >= 0)

340 duparg2(who, *argv);

341

342 get_prefix(&f.saddr, *argv, preferred_family);

343 if (f.saddr.bytelen && f.saddr.bytelen * 8 == f.saddr.bitlen) {

344 if (f.saddr.family == AF_INET)

345 stype = TCP_METRICS_ATTR_SADDR_IPV4;

346 else if (f.saddr.family == AF_INET6)

347 stype = TCP_METRICS_ATTR_SADDR_IPV6;

348 }

349

350 if (stype < 0) {

351 fprintf(stderr, "Error: a specific IP address is expected rather than \"%s\"\n",

352 *argv);

353 return -1;

354 }

355 } else {

356 char *who = "address";

357

358 if (strcmp(*argv, "addr") == 0 ||

359 strcmp(*argv, "address") == 0) {

360 who = *argv;

361 NEXT_ARG();

362 }

363 if (matches(*argv, "help") == 0)

364 usage();

365 if (f.daddr.bitlen >= 0)

366 duparg2(who, *argv);

367

368 get_prefix(&f.daddr, *argv, preferred_family);

369 if (f.daddr.bytelen && f.daddr.bytelen * 8 == f.daddr.bitlen) {

370 if (f.daddr.family == AF_INET)

371 atype = TCP_METRICS_ATTR_ADDR_IPV4;

372 else if (f.daddr.family == AF_INET6)

373 atype = TCP_METRICS_ATTR_ADDR_IPV6;

374 }

375 if ((CMD_DEL & cmd) && atype < 0) {

376 fprintf(stderr, "Error: a specific IP address is expected rather than \"%s\"\n",

377 *argv);

378 return -1;

379 }

380 }

381 argc--; argv++;

382 }

383

384 if (cmd == CMD_DEL && atype < 0)

385 missarg("address");

386

387 /* flush for exact address ? Single del */

388 if (cmd == CMD_FLUSH && atype >= 0)

389 cmd = CMD_DEL;

390

391 /* flush for all addresses ? Single del without address */

392 if (cmd == CMD_FLUSH && f.daddr.bitlen <= 0 &&

393 f.saddr.bitlen <= 0 && preferred_family == AF_UNSPEC) {

394 cmd = CMD_DEL;

395 req.g.cmd = TCP_METRICS_CMD_DEL;

396 ack = 1;

397 } else if (cmd == CMD_DEL) {

398 req.g.cmd = TCP_METRICS_CMD_DEL;

399 ack = 1;

400 } else { /* CMD_FLUSH, CMD_LIST */

401 ack = 0;

402 }

403

404 if (genl_family < 0) {

405 if (rtnl_open_byproto(&grth, 0, NETLINK_GENERIC) < 0) {

406 fprintf(stderr, "Cannot open generic netlink socket\n");

407 exit(1);

408 }

409 genl_family = genl_resolve_family(&grth,

410 TCP_METRICS_GENL_NAME);

411 if (genl_family < 0)

412 exit(1);

413 req.n.nlmsg_type = genl_family;

414 }

415

416 if (!(cmd & CMD_FLUSH) && (atype >= 0 || (cmd & CMD_DEL))) {

417 if (ack)

418 req.n.nlmsg_flags |= NLM_F_ACK;

419 if (atype >= 0)

420 addattr_l(&req.n, sizeof(req), atype, &f.daddr.data,

421 f.daddr.bytelen);

422 if (stype >= 0)

423 addattr_l(&req.n, sizeof(req), stype, &f.saddr.data,

424 f.saddr.bytelen);

425 } else {

426 req.n.nlmsg_flags |= NLM_F_DUMP;

427 }

428

429 f.cmd = cmd;

430 if (cmd & CMD_FLUSH) {

431 int round = 0;

432 char flushb[4096-512];

433

434 f.flushb = flushb;

435 f.flushp = 0;

436 f.flushe = sizeof(flushb);

437

438 for (;;) {

439 req.n.nlmsg_seq = grth.dump = ++grth.seq;

440 if (rtnl_send(&grth, &req, req.n.nlmsg_len) < 0) {

441 perror("Failed to send flush request");

442 exit(1);

443 }

444 f.flushed = 0;

445 if (rtnl_dump_filter(&grth, process_msg, stdout) < 0) {

446 fprintf(stderr, "Flush terminated\n");

447 exit(1);

448 }

449 if (f.flushed == 0) {

450 if (round == 0) {

451 fprintf(stderr, "Nothing to flush.\n");

452 } else if (show_stats)

453 printf("*** Flush is complete after %d round%s ***\n",

454 round, round > 1 ? "s" : "");

455 fflush(stdout);

456 return 0;

457 }

458 round++;

459 if (flush_update() < 0)

460 exit(1);

461 if (show_stats) {

462 printf("\n*** Round %d, deleting %d entries ***\n",

463 round, f.flushed);

464 fflush(stdout);

465 }

466 }

467 return 0;

468 }

469

470 if (ack) {

471 if (rtnl_talk(&grth, &req.n, NULL, 0) < 0)

472 return -2;

473 } else if (atype >= 0) {

474 if (rtnl_talk(&grth, &req.n, &req.n, sizeof(req)) < 0)

475 return -2;

476 if (process_msg(NULL, &req.n, stdout) < 0) {

477 fprintf(stderr, "Dump terminated\n");

478 exit(1);

479 }

480 } else {

481 req.n.nlmsg_seq = grth.dump = ++grth.seq;

482 if (rtnl_send(&grth, &req, req.n.nlmsg_len) < 0) {

483 perror("Failed to send dump request");

484 exit(1);

485 }

486

487 if (rtnl_dump_filter(&grth, process_msg, stdout) < 0) {

488 fprintf(stderr, "Dump terminated\n");

489 exit(1);

490 }

491 }

492 return 0;

493 }

494

495 int do_tcp_metrics(int argc, char **argv)

496 {

497 int i;

498

499 if (argc < 1)

500 return tcpm_do_cmd(CMD_LIST, 0, NULL);

501 for (i = 0; i < ARRAY_SIZE(cmds); i++) {

502 if (matches(argv[0], cmds[i].name) == 0)

503 return tcpm_do_cmd(cmds[i].code, argc-1, argv+1);

504 }

505 if (matches(argv[0], "help") == 0)

506 usage();

507

508 fprintf(stderr, "Command \"%s\" is unknown, try \"ip tcp_metrics help\".\n",

509 *argv);

510 exit(-1);

511 }