1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/tihdr.h> 28 #include <sys/policy.h> 29 #include <sys/tsol/tnet.h> 30 31 #include <inet/common.h> 32 #include <inet/kstatcom.h> 33 #include <inet/snmpcom.h> 34 #include <inet/mib2.h> 35 #include <inet/optcom.h> 36 #include <inet/snmpcom.h> 37 #include <inet/kstatcom.h> 38 #include <inet/udp_impl.h> 39 40 static int udp_kstat_update(kstat_t *, int); 41 static int udp_kstat2_update(kstat_t *, int); 42 static void udp_sum_mib(udp_stack_t *, mib2_udp_t *); 43 static void udp_clr_stats(udp_stat_t *); 44 static void udp_add_stats(udp_stat_counter_t *, udp_stat_t *); 45 static void udp_add_mib(mib2_udp_t *, mib2_udp_t *); 46 /* 47 * return SNMP stuff in buffer in mpdata. We don't hold any lock and report 48 * information that can be changing beneath us. 49 */ 50 mblk_t * 51 udp_snmp_get(queue_t *q, mblk_t *mpctl, boolean_t legacy_req) 52 { 53 mblk_t *mpdata; 54 mblk_t *mp_conn_ctl; 55 mblk_t *mp_attr_ctl; 56 mblk_t *mp6_conn_ctl; 57 mblk_t *mp6_attr_ctl; 58 mblk_t *mp_conn_tail; 59 mblk_t *mp_attr_tail; 60 mblk_t *mp6_conn_tail; 61 mblk_t *mp6_attr_tail; 62 struct opthdr *optp; 63 mib2_udpEntry_t ude; 64 mib2_udp6Entry_t ude6; 65 mib2_transportMLPEntry_t mlp; 66 int state; 67 zoneid_t zoneid; 68 int i; 69 connf_t *connfp; 70 conn_t *connp = Q_TO_CONN(q); 71 int v4_conn_idx; 72 int v6_conn_idx; 73 boolean_t needattr; 74 udp_t *udp; 75 ip_stack_t *ipst = connp->conn_netstack->netstack_ip; 76 udp_stack_t *us = connp->conn_netstack->netstack_udp; 77 mblk_t *mp2ctl; 78 mib2_udp_t udp_mib; 79 size_t udp_mib_size, ude_size, ude6_size; 80 81 82 /* 83 * make a copy of the original message 84 */ 85 mp2ctl = copymsg(mpctl); 86 87 mp_conn_ctl = mp_attr_ctl = mp6_conn_ctl = NULL; 88 if (mpctl == NULL || 89 (mpdata = mpctl->b_cont) == NULL || 90 (mp_conn_ctl = copymsg(mpctl)) == NULL || 91 (mp_attr_ctl = copymsg(mpctl)) == NULL || 92 (mp6_conn_ctl = copymsg(mpctl)) == NULL || 93 (mp6_attr_ctl = copymsg(mpctl)) == NULL) { 94 freemsg(mp_conn_ctl); 95 freemsg(mp_attr_ctl); 96 freemsg(mp6_conn_ctl); 97 freemsg(mpctl); 98 freemsg(mp2ctl); 99 return (0); 100 } 101 102 zoneid = connp->conn_zoneid; 103 104 if (legacy_req) { 105 udp_mib_size = LEGACY_MIB_SIZE(&udp_mib, mib2_udp_t); 106 ude_size = LEGACY_MIB_SIZE(&ude, mib2_udpEntry_t); 107 ude6_size = LEGACY_MIB_SIZE(&ude6, mib2_udp6Entry_t); 108 } else { 109 udp_mib_size = sizeof (mib2_udp_t); 110 ude_size = sizeof (mib2_udpEntry_t); 111 ude6_size = sizeof (mib2_udp6Entry_t); 112 } 113 114 bzero(&udp_mib, sizeof (udp_mib)); 115 /* fixed length structure for IPv4 and IPv6 counters */ 116 SET_MIB(udp_mib.udpEntrySize, ude_size); 117 SET_MIB(udp_mib.udp6EntrySize, ude6_size); 118 119 udp_sum_mib(us, &udp_mib); 120 121 /* 122 * Synchronize 32- and 64-bit counters. Note that udpInDatagrams and 123 * udpOutDatagrams are not updated anywhere in UDP. The new 64 bits 124 * counters are used. Hence the old counters' values in us_sc_mib 125 * are always 0. 126 */ 127 SYNC32_MIB(&udp_mib, udpInDatagrams, udpHCInDatagrams); 128 SYNC32_MIB(&udp_mib, udpOutDatagrams, udpHCOutDatagrams); 129 130 optp = (struct opthdr *)&mpctl->b_rptr[sizeof (struct T_optmgmt_ack)]; 131 optp->level = MIB2_UDP; 132 optp->name = 0; 133 (void) snmp_append_data(mpdata, (char *)&udp_mib, udp_mib_size); 134 optp->len = msgdsize(mpdata); 135 qreply(q, mpctl); 136 137 mp_conn_tail = mp_attr_tail = mp6_conn_tail = mp6_attr_tail = NULL; 138 v4_conn_idx = v6_conn_idx = 0; 139 140 for (i = 0; i < CONN_G_HASH_SIZE; i++) { 141 connfp = &ipst->ips_ipcl_globalhash_fanout[i]; 142 connp = NULL; 143 144 while ((connp = ipcl_get_next_conn(connfp, connp, 145 IPCL_UDPCONN))) { 146 udp = connp->conn_udp; 147 if (zoneid != connp->conn_zoneid) 148 continue; 149 150 /* 151 * Note that the port numbers are sent in 152 * host byte order 153 */ 154 155 if (udp->udp_state == TS_UNBND) 156 state = MIB2_UDP_unbound; 157 else if (udp->udp_state == TS_IDLE) 158 state = MIB2_UDP_idle; 159 else if (udp->udp_state == TS_DATA_XFER) 160 state = MIB2_UDP_connected; 161 else 162 state = MIB2_UDP_unknown; 163 164 needattr = B_FALSE; 165 bzero(&mlp, sizeof (mlp)); 166 if (connp->conn_mlp_type != mlptSingle) { 167 if (connp->conn_mlp_type == mlptShared || 168 connp->conn_mlp_type == mlptBoth) 169 mlp.tme_flags |= MIB2_TMEF_SHARED; 170 if (connp->conn_mlp_type == mlptPrivate || 171 connp->conn_mlp_type == mlptBoth) 172 mlp.tme_flags |= MIB2_TMEF_PRIVATE; 173 needattr = B_TRUE; 174 } 175 if (connp->conn_anon_mlp) { 176 mlp.tme_flags |= MIB2_TMEF_ANONMLP; 177 needattr = B_TRUE; 178 } 179 switch (connp->conn_mac_mode) { 180 case CONN_MAC_DEFAULT: 181 break; 182 case CONN_MAC_AWARE: 183 mlp.tme_flags |= MIB2_TMEF_MACEXEMPT; 184 needattr = B_TRUE; 185 break; 186 case CONN_MAC_IMPLICIT: 187 mlp.tme_flags |= MIB2_TMEF_MACIMPLICIT; 188 needattr = B_TRUE; 189 break; 190 } 191 mutex_enter(&connp->conn_lock); 192 if (udp->udp_state == TS_DATA_XFER && 193 connp->conn_ixa->ixa_tsl != NULL) { 194 ts_label_t *tsl; 195 196 tsl = connp->conn_ixa->ixa_tsl; 197 mlp.tme_flags |= MIB2_TMEF_IS_LABELED; 198 mlp.tme_doi = label2doi(tsl); 199 mlp.tme_label = *label2bslabel(tsl); 200 needattr = B_TRUE; 201 } 202 mutex_exit(&connp->conn_lock); 203 204 /* 205 * Create an IPv4 table entry for IPv4 entries and also 206 * any IPv6 entries which are bound to in6addr_any 207 * (i.e. anything a IPv4 peer could connect/send to). 208 */ 209 if (connp->conn_ipversion == IPV4_VERSION || 210 (udp->udp_state <= TS_IDLE && 211 IN6_IS_ADDR_UNSPECIFIED(&connp->conn_laddr_v6))) { 212 ude.udpEntryInfo.ue_state = state; 213 /* 214 * If in6addr_any this will set it to 215 * INADDR_ANY 216 */ 217 ude.udpLocalAddress = connp->conn_laddr_v4; 218 ude.udpLocalPort = ntohs(connp->conn_lport); 219 if (udp->udp_state == TS_DATA_XFER) { 220 /* 221 * Can potentially get here for 222 * v6 socket if another process 223 * (say, ping) has just done a 224 * sendto(), changing the state 225 * from the TS_IDLE above to 226 * TS_DATA_XFER by the time we hit 227 * this part of the code. 228 */ 229 ude.udpEntryInfo.ue_RemoteAddress = 230 connp->conn_faddr_v4; 231 ude.udpEntryInfo.ue_RemotePort = 232 ntohs(connp->conn_fport); 233 } else { 234 ude.udpEntryInfo.ue_RemoteAddress = 0; 235 ude.udpEntryInfo.ue_RemotePort = 0; 236 } 237 238 /* 239 * We make the assumption that all udp_t 240 * structs will be created within an address 241 * region no larger than 32-bits. 242 */ 243 ude.udpInstance = (uint32_t)(uintptr_t)udp; 244 ude.udpCreationProcess = 245 (connp->conn_cpid < 0) ? 246 MIB2_UNKNOWN_PROCESS : 247 connp->conn_cpid; 248 ude.udpCreationTime = connp->conn_open_time; 249 250 (void) snmp_append_data2(mp_conn_ctl->b_cont, 251 &mp_conn_tail, (char *)&ude, ude_size); 252 mlp.tme_connidx = v4_conn_idx++; 253 if (needattr) 254 (void) snmp_append_data2( 255 mp_attr_ctl->b_cont, &mp_attr_tail, 256 (char *)&mlp, sizeof (mlp)); 257 } 258 if (connp->conn_ipversion == IPV6_VERSION) { 259 ude6.udp6EntryInfo.ue_state = state; 260 ude6.udp6LocalAddress = connp->conn_laddr_v6; 261 ude6.udp6LocalPort = ntohs(connp->conn_lport); 262 mutex_enter(&connp->conn_lock); 263 if (connp->conn_ixa->ixa_flags & 264 IXAF_SCOPEID_SET) { 265 ude6.udp6IfIndex = 266 connp->conn_ixa->ixa_scopeid; 267 } else { 268 ude6.udp6IfIndex = connp->conn_bound_if; 269 } 270 mutex_exit(&connp->conn_lock); 271 if (udp->udp_state == TS_DATA_XFER) { 272 ude6.udp6EntryInfo.ue_RemoteAddress = 273 connp->conn_faddr_v6; 274 ude6.udp6EntryInfo.ue_RemotePort = 275 ntohs(connp->conn_fport); 276 } else { 277 ude6.udp6EntryInfo.ue_RemoteAddress = 278 sin6_null.sin6_addr; 279 ude6.udp6EntryInfo.ue_RemotePort = 0; 280 } 281 /* 282 * We make the assumption that all udp_t 283 * structs will be created within an address 284 * region no larger than 32-bits. 285 */ 286 ude6.udp6Instance = (uint32_t)(uintptr_t)udp; 287 ude6.udp6CreationProcess = 288 (connp->conn_cpid < 0) ? 289 MIB2_UNKNOWN_PROCESS : 290 connp->conn_cpid; 291 ude6.udp6CreationTime = connp->conn_open_time; 292 293 (void) snmp_append_data2(mp6_conn_ctl->b_cont, 294 &mp6_conn_tail, (char *)&ude6, ude6_size); 295 mlp.tme_connidx = v6_conn_idx++; 296 if (needattr) 297 (void) snmp_append_data2( 298 mp6_attr_ctl->b_cont, 299 &mp6_attr_tail, (char *)&mlp, 300 sizeof (mlp)); 301 } 302 } 303 } 304 305 /* IPv4 UDP endpoints */ 306 optp = (struct opthdr *)&mp_conn_ctl->b_rptr[ 307 sizeof (struct T_optmgmt_ack)]; 308 optp->level = MIB2_UDP; 309 optp->name = MIB2_UDP_ENTRY; 310 optp->len = msgdsize(mp_conn_ctl->b_cont); 311 qreply(q, mp_conn_ctl); 312 313 /* table of MLP attributes... */ 314 optp = (struct opthdr *)&mp_attr_ctl->b_rptr[ 315 sizeof (struct T_optmgmt_ack)]; 316 optp->level = MIB2_UDP; 317 optp->name = EXPER_XPORT_MLP; 318 optp->len = msgdsize(mp_attr_ctl->b_cont); 319 if (optp->len == 0) 320 freemsg(mp_attr_ctl); 321 else 322 qreply(q, mp_attr_ctl); 323 324 /* IPv6 UDP endpoints */ 325 optp = (struct opthdr *)&mp6_conn_ctl->b_rptr[ 326 sizeof (struct T_optmgmt_ack)]; 327 optp->level = MIB2_UDP6; 328 optp->name = MIB2_UDP6_ENTRY; 329 optp->len = msgdsize(mp6_conn_ctl->b_cont); 330 qreply(q, mp6_conn_ctl); 331 332 /* table of MLP attributes... */ 333 optp = (struct opthdr *)&mp6_attr_ctl->b_rptr[ 334 sizeof (struct T_optmgmt_ack)]; 335 optp->level = MIB2_UDP6; 336 optp->name = EXPER_XPORT_MLP; 337 optp->len = msgdsize(mp6_attr_ctl->b_cont); 338 if (optp->len == 0) 339 freemsg(mp6_attr_ctl); 340 else 341 qreply(q, mp6_attr_ctl); 342 343 return (mp2ctl); 344 } 345 346 /* 347 * Return 0 if invalid set request, 1 otherwise, including non-udp requests. 348 * NOTE: Per MIB-II, UDP has no writable data. 349 * TODO: If this ever actually tries to set anything, it needs to be 350 * to do the appropriate locking. 351 */ 352 /* ARGSUSED */ 353 int 354 udp_snmp_set(queue_t *q, t_scalar_t level, t_scalar_t name, 355 uchar_t *ptr, int len) 356 { 357 switch (level) { 358 case MIB2_UDP: 359 return (0); 360 default: 361 return (1); 362 } 363 } 364 365 void 366 udp_kstat_fini(netstackid_t stackid, kstat_t *ksp) 367 { 368 if (ksp != NULL) { 369 ASSERT(stackid == (netstackid_t)(uintptr_t)ksp->ks_private); 370 kstat_delete_netstack(ksp, stackid); 371 } 372 } 373 374 /* 375 * To add stats from one mib2_udp_t to another. Static fields are not added. 376 * The caller should set them up propertly. 377 */ 378 static void 379 udp_add_mib(mib2_udp_t *from, mib2_udp_t *to) 380 { 381 to->udpHCInDatagrams += from->udpHCInDatagrams; 382 to->udpInErrors += from->udpInErrors; 383 to->udpHCOutDatagrams += from->udpHCOutDatagrams; 384 to->udpOutErrors += from->udpOutErrors; 385 } 386 387 388 void * 389 udp_kstat2_init(netstackid_t stackid) 390 { 391 kstat_t *ksp; 392 393 udp_stat_t template = { 394 { "udp_sock_fallback", KSTAT_DATA_UINT64 }, 395 { "udp_out_opt", KSTAT_DATA_UINT64 }, 396 { "udp_out_err_notconn", KSTAT_DATA_UINT64 }, 397 { "udp_out_err_output", KSTAT_DATA_UINT64 }, 398 { "udp_out_err_tudr", KSTAT_DATA_UINT64 }, 399 #ifdef DEBUG 400 { "udp_data_conn", KSTAT_DATA_UINT64 }, 401 { "udp_data_notconn", KSTAT_DATA_UINT64 }, 402 { "udp_out_lastdst", KSTAT_DATA_UINT64 }, 403 { "udp_out_diffdst", KSTAT_DATA_UINT64 }, 404 { "udp_out_ipv6", KSTAT_DATA_UINT64 }, 405 { "udp_out_mapped", KSTAT_DATA_UINT64 }, 406 { "udp_out_ipv4", KSTAT_DATA_UINT64 }, 407 #endif 408 }; 409 410 ksp = kstat_create_netstack(UDP_MOD_NAME, 0, "udpstat", "net", 411 KSTAT_TYPE_NAMED, sizeof (template) / sizeof (kstat_named_t), 412 0, stackid); 413 414 if (ksp == NULL) 415 return (NULL); 416 417 bcopy(&template, ksp->ks_data, sizeof (template)); 418 ksp->ks_update = udp_kstat2_update; 419 ksp->ks_private = (void *)(uintptr_t)stackid; 420 421 kstat_install(ksp); 422 return (ksp); 423 } 424 425 void 426 udp_kstat2_fini(netstackid_t stackid, kstat_t *ksp) 427 { 428 if (ksp != NULL) { 429 ASSERT(stackid == (netstackid_t)(uintptr_t)ksp->ks_private); 430 kstat_delete_netstack(ksp, stackid); 431 } 432 } 433 434 /* 435 * To copy counters from the per CPU udpp_stat_counter_t to the stack 436 * udp_stat_t. 437 */ 438 static void 439 udp_add_stats(udp_stat_counter_t *from, udp_stat_t *to) 440 { 441 to->udp_sock_fallback.value.ui64 += from->udp_sock_fallback; 442 to->udp_out_opt.value.ui64 += from->udp_out_opt; 443 to->udp_out_err_notconn.value.ui64 += from->udp_out_err_notconn; 444 to->udp_out_err_output.value.ui64 += from->udp_out_err_output; 445 to->udp_out_err_tudr.value.ui64 += from->udp_out_err_tudr; 446 #ifdef DEBUG 447 to->udp_data_conn.value.ui64 += from->udp_data_conn; 448 to->udp_data_notconn.value.ui64 += from->udp_data_notconn; 449 to->udp_out_lastdst.value.ui64 += from->udp_out_lastdst; 450 to->udp_out_diffdst.value.ui64 += from->udp_out_diffdst; 451 to->udp_out_ipv6.value.ui64 += from->udp_out_ipv6; 452 to->udp_out_mapped.value.ui64 += from->udp_out_mapped; 453 to->udp_out_ipv4.value.ui64 += from->udp_out_ipv4; 454 #endif 455 } 456 457 /* 458 * To set all udp_stat_t counters to 0. 459 */ 460 static void 461 udp_clr_stats(udp_stat_t *stats) 462 { 463 stats->udp_sock_fallback.value.ui64 = 0; 464 stats->udp_out_opt.value.ui64 = 0; 465 stats->udp_out_err_notconn.value.ui64 = 0; 466 stats->udp_out_err_output.value.ui64 = 0; 467 stats->udp_out_err_tudr.value.ui64 = 0; 468 #ifdef DEBUG 469 stats->udp_data_conn.value.ui64 = 0; 470 stats->udp_data_notconn.value.ui64 = 0; 471 stats->udp_out_lastdst.value.ui64 = 0; 472 stats->udp_out_diffdst.value.ui64 = 0; 473 stats->udp_out_ipv6.value.ui64 = 0; 474 stats->udp_out_mapped.value.ui64 = 0; 475 stats->udp_out_ipv4.value.ui64 = 0; 476 #endif 477 } 478 479 int 480 udp_kstat2_update(kstat_t *kp, int rw) 481 { 482 udp_stat_t *stats; 483 netstackid_t stackid = (netstackid_t)(uintptr_t)kp->ks_private; 484 netstack_t *ns; 485 udp_stack_t *us; 486 int i; 487 int cnt; 488 489 if (rw == KSTAT_WRITE) 490 return (EACCES); 491 492 ns = netstack_find_by_stackid(stackid); 493 if (ns == NULL) 494 return (-1); 495 us = ns->netstack_udp; 496 if (us == NULL) { 497 netstack_rele(ns); 498 return (-1); 499 } 500 stats = (udp_stat_t *)kp->ks_data; 501 udp_clr_stats(stats); 502 503 cnt = us->us_sc_cnt; 504 for (i = 0; i < cnt; i++) 505 udp_add_stats(&us->us_sc[i]->udp_sc_stats, stats); 506 507 netstack_rele(ns); 508 return (0); 509 } 510 511 void * 512 udp_kstat_init(netstackid_t stackid) 513 { 514 kstat_t *ksp; 515 516 udp_named_kstat_t template = { 517 { "inDatagrams", KSTAT_DATA_UINT64, 0 }, 518 { "inErrors", KSTAT_DATA_UINT32, 0 }, 519 { "outDatagrams", KSTAT_DATA_UINT64, 0 }, 520 { "entrySize", KSTAT_DATA_INT32, 0 }, 521 { "entry6Size", KSTAT_DATA_INT32, 0 }, 522 { "outErrors", KSTAT_DATA_UINT32, 0 }, 523 }; 524 525 ksp = kstat_create_netstack(UDP_MOD_NAME, 0, UDP_MOD_NAME, "mib2", 526 KSTAT_TYPE_NAMED, NUM_OF_FIELDS(udp_named_kstat_t), 0, stackid); 527 528 if (ksp == NULL) 529 return (NULL); 530 531 template.entrySize.value.ui32 = sizeof (mib2_udpEntry_t); 532 template.entry6Size.value.ui32 = sizeof (mib2_udp6Entry_t); 533 534 bcopy(&template, ksp->ks_data, sizeof (template)); 535 ksp->ks_update = udp_kstat_update; 536 ksp->ks_private = (void *)(uintptr_t)stackid; 537 538 kstat_install(ksp); 539 return (ksp); 540 } 541 542 /* 543 * To sum up all MIB2 stats for a udp_stack_t from all per CPU stats. The 544 * caller should initialize the target mib2_udp_t properly as this function 545 * just adds up all the per CPU stats. 546 */ 547 static void 548 udp_sum_mib(udp_stack_t *us, mib2_udp_t *udp_mib) 549 { 550 int i; 551 int cnt; 552 553 cnt = us->us_sc_cnt; 554 for (i = 0; i < cnt; i++) 555 udp_add_mib(&us->us_sc[i]->udp_sc_mib, udp_mib); 556 } 557 558 static int 559 udp_kstat_update(kstat_t *kp, int rw) 560 { 561 udp_named_kstat_t *udpkp; 562 netstackid_t stackid = (netstackid_t)(uintptr_t)kp->ks_private; 563 netstack_t *ns; 564 udp_stack_t *us; 565 mib2_udp_t udp_mib; 566 567 if (rw == KSTAT_WRITE) 568 return (EACCES); 569 570 ns = netstack_find_by_stackid(stackid); 571 if (ns == NULL) 572 return (-1); 573 us = ns->netstack_udp; 574 if (us == NULL) { 575 netstack_rele(ns); 576 return (-1); 577 } 578 udpkp = (udp_named_kstat_t *)kp->ks_data; 579 580 bzero(&udp_mib, sizeof (udp_mib)); 581 udp_sum_mib(us, &udp_mib); 582 583 udpkp->inDatagrams.value.ui64 = udp_mib.udpHCInDatagrams; 584 udpkp->inErrors.value.ui32 = udp_mib.udpInErrors; 585 udpkp->outDatagrams.value.ui64 = udp_mib.udpHCOutDatagrams; 586 udpkp->outErrors.value.ui32 = udp_mib.udpOutErrors; 587 netstack_rele(ns); 588 return (0); 589 } 590