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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2002 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/conf.h> 31 #include <sys/atomic.h> 32 #include <sys/systm.h> 33 #include <sys/socket.h> 34 #include <sys/spl.h> 35 #include <netinet/in.h> 36 #include <sys/modctl.h> 37 #include <sys/sunddi.h> 38 #include <ipp/ipp.h> 39 #include <ipp/ipp_config.h> 40 #include <inet/common.h> 41 #include <ipp/flowacct/flowacct_impl.h> 42 #include <sys/ddi.h> 43 44 #define D_SM_COMMENT "IPP Flow Accounting Module" 45 46 /* DDI file for flowacct ipp module */ 47 48 static int flowacct_create_action(ipp_action_id_t, nvlist_t **, ipp_flags_t); 49 static int flowacct_modify_action(ipp_action_id_t, nvlist_t **, ipp_flags_t); 50 static int flowacct_destroy_action(ipp_action_id_t, ipp_flags_t); 51 static int flowacct_info(ipp_action_id_t, int (*)(nvlist_t *, void *), void *, 52 ipp_flags_t); 53 static int flowacct_invoke_action(ipp_action_id_t, ipp_packet_t *); 54 55 static int update_flowacct_kstats(ipp_stat_t *, void *, int); 56 57 ipp_ops_t flowacct_ops = { 58 IPPO_REV, 59 flowacct_create_action, /* ippo_action_create */ 60 flowacct_modify_action, /* ippo_action_modify */ 61 flowacct_destroy_action, /* ippo_action_destroy */ 62 flowacct_info, /* ippo_action_info */ 63 flowacct_invoke_action /* ippo_action_invoke */ 64 }; 65 66 extern struct mod_ops mod_ippops; 67 68 /* 69 * Module linkage information for the kernel. 70 */ 71 static struct modlipp modlipp = { 72 &mod_ippops, 73 D_SM_COMMENT " 1.12", 74 &flowacct_ops 75 }; 76 77 static struct modlinkage modlinkage = { 78 MODREV_1, 79 (void *)&modlipp, 80 NULL 81 }; 82 83 int 84 _init(void) 85 { 86 return (mod_install(&modlinkage)); 87 } 88 89 int 90 _fini(void) 91 { 92 return (mod_remove(&modlinkage)); 93 } 94 95 int 96 _info(struct modinfo *modinfop) 97 { 98 return (mod_info(&modlinkage, modinfop)); 99 } 100 101 /* Update global stats */ 102 static int 103 update_flowacct_kstats(ipp_stat_t *sp, void *arg, int rw) 104 { 105 flowacct_data_t *flowacct_data = (flowacct_data_t *)arg; 106 flowacct_stat_t *fl_stat = (flowacct_stat_t *)sp->ipps_data; 107 ASSERT((fl_stat != NULL) && (flowacct_data != 0)); 108 109 (void) ipp_stat_named_op(&fl_stat->nbytes, &flowacct_data->nbytes, rw); 110 (void) ipp_stat_named_op(&fl_stat->tbytes, &flowacct_data->tbytes, rw); 111 (void) ipp_stat_named_op(&fl_stat->nflows, &flowacct_data->nflows, rw); 112 (void) ipp_stat_named_op(&fl_stat->usedmem, &flowacct_data->usedmem, 113 rw); 114 (void) ipp_stat_named_op(&fl_stat->npackets, &flowacct_data->npackets, 115 rw); 116 (void) ipp_stat_named_op(&fl_stat->epackets, &flowacct_data->epackets, 117 rw); 118 return (0); 119 } 120 121 /* Initialize global stats */ 122 static int 123 global_statinit(ipp_action_id_t aid, flowacct_data_t *flowacct_data) 124 { 125 flowacct_stat_t *flacct_stat; 126 int err = 0; 127 128 if ((err = ipp_stat_create(aid, FLOWACCT_STATS_STRING, 129 FLOWACCT_STATS_COUNT, update_flowacct_kstats, flowacct_data, 130 &flowacct_data->stats)) != 0) { 131 flowacct0dbg(("global_statinit: error creating flowacct "\ 132 "stats\n")); 133 return (err); 134 } 135 flacct_stat = (flowacct_stat_t *)(flowacct_data->stats)->ipps_data; 136 ASSERT(flacct_stat != NULL); 137 138 if ((err = ipp_stat_named_init(flowacct_data->stats, "bytes_in_tbl", 139 IPP_STAT_UINT64, &flacct_stat->tbytes)) != 0) { 140 flowacct0dbg(("global_statinit: ipp_stat_named_init returned "\ 141 "with error %d\n", err)); 142 return (err); 143 } 144 if ((err = ipp_stat_named_init(flowacct_data->stats, "nbytes", 145 IPP_STAT_UINT64, &flacct_stat->nbytes)) != 0) { 146 flowacct0dbg(("global_statinit: ipp_stat_named_init returned "\ 147 "with error %d\n", err)); 148 return (err); 149 } 150 if ((err = ipp_stat_named_init(flowacct_data->stats, "npackets", 151 IPP_STAT_UINT64, &flacct_stat->npackets)) != 0) { 152 flowacct0dbg(("global_statinit:ipp_stat_named_init returned "\ 153 "with error %d\n", err)); 154 return (err); 155 } 156 if ((err = ipp_stat_named_init(flowacct_data->stats, "usedmem", 157 IPP_STAT_UINT64, &flacct_stat->usedmem)) != 0) { 158 flowacct0dbg(("global_statinit:ipp_stat_named_init returned "\ 159 "with error %d\n", err)); 160 return (err); 161 } 162 if ((err = ipp_stat_named_init(flowacct_data->stats, "flows_in_tbl", 163 IPP_STAT_UINT32, &flacct_stat->nflows)) != 0) { 164 flowacct0dbg(("global_statinit:ipp_stat_named_init returned "\ 165 "with error %d\n", err)); 166 return (err); 167 } 168 if ((err = ipp_stat_named_init(flowacct_data->stats, "epackets", 169 IPP_STAT_UINT64, &flacct_stat->epackets)) != 0) { 170 flowacct0dbg(("global_statinit:ipp_stat_named_init returned "\ 171 "with error %d\n", err)); 172 return (err); 173 } 174 ipp_stat_install(flowacct_data->stats); 175 176 return (err); 177 } 178 179 static int 180 flowacct_create_action(ipp_action_id_t aid, nvlist_t **nvlpp, ipp_flags_t flags) 181 { 182 nvlist_t *nvlp; 183 flowacct_data_t *flowacct_data; 184 char *next_action; 185 int rc, flow_count; 186 list_head_t *head; 187 uint32_t bstats; 188 uint32_t timeout = FLOWACCT_DEF_TIMEOUT; 189 uint32_t timer = FLOWACCT_DEF_TIMER; 190 191 nvlp = *nvlpp; 192 *nvlpp = NULL; /* nvlist should be NULL on return */ 193 194 if ((flowacct_data = kmem_zalloc(FLOWACCT_DATA_SZ, KM_NOSLEEP)) 195 == NULL) { 196 nvlist_free(nvlp); 197 return (ENOMEM); 198 } 199 200 /* parse next action name */ 201 if ((rc = nvlist_lookup_string(nvlp, FLOWACCT_NEXT_ACTION_NAME, 202 &next_action)) != 0) { 203 nvlist_free(nvlp); 204 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 205 flowacct0dbg(("flowacct_create_action: invalid config, "\ 206 "next_action missing\n")); 207 return (rc); 208 } 209 if ((flowacct_data->next_action = ipp_action_lookup(next_action)) 210 == IPP_ACTION_INVAL) { 211 nvlist_free(nvlp); 212 flowacct0dbg(("flowacct_create_action: invalid next_action\n")); 213 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 214 return (EINVAL); 215 } 216 217 if ((rc = ipp_action_name(aid, &flowacct_data->act_name)) != 0) { 218 nvlist_free(nvlp); 219 flowacct0dbg(("flowacct_create_action: invalid next aid\n")); 220 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 221 return (EINVAL); 222 } 223 224 /* parse flow timeout - in millisec, if present */ 225 (void) nvlist_lookup_uint32(nvlp, FLOWACCT_TIMEOUT, &timeout); 226 227 /* Convert to FLOWACCT_MSEC_TO_NSEC */ 228 flowacct_data->timeout = (uint64_t)timeout * FLOWACCT_MSEC_TO_NSEC; 229 230 /* parse flow timer - in millisec, if present */ 231 (void) nvlist_lookup_uint32(nvlp, FLOWACCT_TIMER, &timer); 232 233 /* Convert to FLOWACCT_MSEC_TO_USEC */ 234 flowacct_data->timer = (uint64_t)timer * FLOWACCT_MSEC_TO_USEC; 235 236 if ((rc = nvlist_lookup_uint32(nvlp, FLOWACCT_MAX_LIMIT, 237 &flowacct_data->max_limit)) != 0) { 238 nvlist_free(nvlp); 239 flowacct0dbg(("flowacct_create_action: invalid config, "\ 240 "max_limit missing\n")); 241 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 242 return (rc); 243 } 244 245 if ((rc = nvlist_lookup_uint32(nvlp, IPP_ACTION_STATS_ENABLE, 246 &bstats)) != 0) { 247 flowacct_data->global_stats = B_FALSE; 248 } else { 249 flowacct_data->global_stats = (boolean_t)bstats; 250 if (flowacct_data->global_stats) { 251 if ((rc = global_statinit(aid, flowacct_data)) != 0) { 252 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 253 return (rc); 254 } 255 } 256 } 257 258 nvlist_free(nvlp); 259 260 /* set action chain reference */ 261 if ((rc = ipp_action_ref(aid, flowacct_data->next_action, 262 flags)) != 0) { 263 flowacct0dbg(("flowacct_create_action: ipp_action_ref " \ 264 "returned with error %d\n", rc)); 265 if (flowacct_data->stats != NULL) { 266 ipp_stat_destroy(flowacct_data->stats); 267 } 268 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 269 return (rc); 270 } 271 272 /* Initialize locks */ 273 for (flow_count = 0, head = flowacct_data->flows_tbl; 274 flow_count < (FLOW_TBL_COUNT + 1); flow_count++, head++) { 275 mutex_init(&head->lock, NULL, MUTEX_DEFAULT, 0); 276 } 277 278 ipp_action_set_ptr(aid, (void *)flowacct_data); 279 return (0); 280 } 281 282 static int 283 flowacct_modify_action(ipp_action_id_t aid, nvlist_t **nvlpp, ipp_flags_t flags) 284 { 285 nvlist_t *nvlp; 286 int rc = 0; 287 uint8_t config_type; 288 char *next_action_name, *act_name; 289 ipp_action_id_t next_action; 290 uint32_t timeout, timer, bstats, max_limit; 291 flowacct_data_t *flowacct_data; 292 293 nvlp = *nvlpp; 294 *nvlpp = NULL; /* nvlist should be NULL when this returns */ 295 296 if ((rc = nvlist_lookup_byte(nvlp, IPP_CONFIG_TYPE, &config_type)) 297 != 0) { 298 nvlist_free(nvlp); 299 flowacct0dbg(("flowacct_modify_action: invalid configuration "\ 300 "type\n")); 301 return (rc); 302 } 303 304 if (config_type != IPP_SET) { 305 nvlist_free(nvlp); 306 flowacct0dbg(("flowacct_modify_action: invalid configuration "\ 307 "type %d\n", config_type)); 308 return (EINVAL); 309 } 310 311 flowacct_data = (flowacct_data_t *)ipp_action_get_ptr(aid); 312 313 /* parse next action name, if present */ 314 if ((rc = nvlist_lookup_string(nvlp, FLOWACCT_NEXT_ACTION_NAME, 315 &next_action_name)) == 0) { 316 /* lookup action name to get action id */ 317 if ((next_action = ipp_action_lookup(next_action_name)) 318 == IPP_ACTION_INVAL) { 319 nvlist_free(nvlp); 320 flowacct0dbg(("flowacct_modify_action: next_action "\ 321 "invalid\n")); 322 return (EINVAL); 323 } 324 /* reference new action */ 325 if ((rc = ipp_action_ref(aid, next_action, flags)) != 0) { 326 nvlist_free(nvlp); 327 flowacct0dbg(("flowacct_modify_action: "\ 328 "ipp_action_ref returned with error %d\n", rc)); 329 return (rc); 330 } 331 332 if ((rc = ipp_action_name(aid, &act_name)) != 0) { 333 nvlist_free(nvlp); 334 flowacct0dbg(("flowacct_modify_action: invalid next "\ 335 "aid\n")); 336 return (EINVAL); 337 } 338 339 /* unref old action */ 340 rc = ipp_action_unref(aid, flowacct_data->next_action, flags); 341 ASSERT(rc == 0); 342 flowacct_data->next_action = next_action; 343 kmem_free(flowacct_data->act_name, 344 (strlen(flowacct_data->act_name) + 1)); 345 flowacct_data->act_name = act_name; 346 } 347 348 /* parse timeout, if present */ 349 if ((rc = nvlist_lookup_uint32(nvlp, FLOWACCT_TIMEOUT, &timeout)) 350 == 0) { 351 flowacct_data->timeout = (uint64_t)timeout * 352 FLOWACCT_MSEC_TO_NSEC; 353 } 354 355 /* parse timer, if present */ 356 if ((rc = nvlist_lookup_uint32(nvlp, FLOWACCT_TIMER, &timer)) == 0) { 357 flowacct_data->timer = (uint64_t)timer * FLOWACCT_MSEC_TO_USEC; 358 } 359 360 /* parse max_flow, if present */ 361 if ((rc = nvlist_lookup_uint32(nvlp, FLOWACCT_MAX_LIMIT, &max_limit)) 362 == 0) { 363 flowacct_data->max_limit = max_limit; 364 } 365 366 /* parse gather_stats boolean, if present */ 367 if ((rc = nvlist_lookup_uint32(nvlp, IPP_ACTION_STATS_ENABLE, &bstats)) 368 == 0) { 369 boolean_t new_val = (boolean_t)bstats; 370 371 /* Turning global stats on */ 372 if (new_val && !flowacct_data->global_stats) { 373 rc = global_statinit(aid, flowacct_data); 374 if (rc == 0) { 375 flowacct_data->global_stats = new_val; 376 } else { 377 flowacct0dbg(("flowacct_modify_action: error "\ 378 "enabling stats\n")); 379 } 380 } else if (!new_val && flowacct_data->global_stats) { 381 flowacct_data->global_stats = new_val; 382 ipp_stat_destroy(flowacct_data->stats); 383 } 384 } 385 return (0); 386 } 387 388 static int 389 flowacct_destroy_action(ipp_action_id_t aid, ipp_flags_t flags) 390 { 391 flowacct_data_t *flowacct_data; 392 int rc, flow_count; 393 list_head_t *head; 394 395 flowacct_data = (flowacct_data_t *)ipp_action_get_ptr(aid); 396 ASSERT(flowacct_data != NULL); 397 398 while (flowacct_data->flow_tid != 0) { 399 timeout_id_t tid = flowacct_data->flow_tid; 400 flowacct_data->flow_tid = 0; 401 (void) untimeout(tid); 402 } 403 404 if (flowacct_data->stats != NULL) { 405 ipp_stat_destroy(flowacct_data->stats); 406 } 407 408 /* Dump all the flows to the file */ 409 flowacct_timer(FLOWACCT_PURGE_FLOW, flowacct_data); 410 411 kmem_free(flowacct_data->act_name, (strlen(flowacct_data->act_name) 412 + 1)); 413 414 /* Destroy the locks */ 415 for (flow_count = 0, head = flowacct_data->flows_tbl; 416 flow_count < FLOW_TBL_COUNT; flow_count++, head++) { 417 mutex_destroy(&head->lock); 418 } 419 /* unreference the action */ 420 rc = ipp_action_unref(aid, flowacct_data->next_action, flags); 421 ASSERT(rc == 0); 422 423 424 kmem_free(flowacct_data, FLOWACCT_DATA_SZ); 425 return (0); 426 } 427 428 static int 429 flowacct_invoke_action(ipp_action_id_t aid, ipp_packet_t *packet) 430 { 431 flowacct_data_t *flowacct_data; 432 mblk_t *mp = NULL; 433 int rc; 434 435 /* get mblk from ipp_packet structure */ 436 mp = ipp_packet_get_data(packet); 437 flowacct_data = (flowacct_data_t *)ipp_action_get_ptr(aid); 438 ASSERT(flowacct_data != NULL); 439 440 /* flowacct packet as configured */ 441 if ((rc = flowacct_process(&mp, flowacct_data)) != 0) { 442 return (rc); 443 } else { 444 /* return packet with next action set */ 445 return (ipp_packet_next(packet, flowacct_data->next_action)); 446 } 447 } 448 449 /* ARGSUSED */ 450 static int 451 flowacct_info(ipp_action_id_t aid, int (*fn)(nvlist_t *, void *), void *arg, 452 ipp_flags_t flags) 453 { 454 nvlist_t *nvlp; 455 flowacct_data_t *flowacct_data; 456 char *next_action; 457 uint32_t param; 458 int rc; 459 460 flowacct_data = (flowacct_data_t *)ipp_action_get_ptr(aid); 461 ASSERT(flowacct_data != NULL); 462 ASSERT(fn != NULL); 463 464 /* allocate nvlist to be passed back */ 465 if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) { 466 flowacct0dbg(("flowacct_info: memory allocation failure\n")); 467 return (rc); 468 } 469 470 /* look up next action with the next action id */ 471 if ((rc = ipp_action_name(flowacct_data->next_action, 472 &next_action)) != 0) { 473 flowacct0dbg(("flowacct_info: next action not available\n")); 474 nvlist_free(nvlp); 475 return (rc); 476 } 477 478 /* add next action name */ 479 if ((rc = nvlist_add_string(nvlp, FLOWACCT_NEXT_ACTION_NAME, 480 next_action)) != 0) { 481 flowacct0dbg(("flowacct_info: error adding next action\n")); 482 nvlist_free(nvlp); 483 kmem_free(next_action, (strlen(next_action) + 1)); 484 return (rc); 485 } 486 487 /* free action name */ 488 kmem_free(next_action, (strlen(next_action) + 1)); 489 490 /* add config type */ 491 if ((rc = nvlist_add_byte(nvlp, IPP_CONFIG_TYPE, IPP_SET)) != 0) { 492 flowacct0dbg(("flowacct_info: error adding config type\n")); 493 nvlist_free(nvlp); 494 return (rc); 495 } 496 497 /* add timer */ 498 param = flowacct_data->timer / FLOWACCT_MSEC_TO_USEC; 499 if ((rc = nvlist_add_uint32(nvlp, FLOWACCT_TIMER, param)) != 0) { 500 flowacct0dbg(("flowacct_info: error adding timer info.\n")); 501 nvlist_free(nvlp); 502 return (rc); 503 } 504 505 /* add max_limit */ 506 if ((rc = nvlist_add_uint32(nvlp, FLOWACCT_MAX_LIMIT, 507 flowacct_data->max_limit)) != 0) { 508 flowacct0dbg(("flowacct_info: error adding max_flow info.\n")); 509 nvlist_free(nvlp); 510 return (rc); 511 } 512 513 514 param = flowacct_data->timeout / FLOWACCT_MSEC_TO_NSEC; 515 /* add timeout */ 516 if ((rc = nvlist_add_uint32(nvlp, FLOWACCT_TIMEOUT, param)) != 0) { 517 flowacct0dbg(("flowacct_info: error adding timeout info.\n")); 518 nvlist_free(nvlp); 519 return (rc); 520 } 521 522 /* add global stats boolean */ 523 if ((rc = nvlist_add_uint32(nvlp, IPP_ACTION_STATS_ENABLE, 524 (uint32_t)flowacct_data->global_stats)) != 0) { 525 flowacct0dbg(("flowacct_info: error adding global stats "\ 526 "info.\n")); 527 nvlist_free(nvlp); 528 return (rc); 529 } 530 531 /* call back with nvlist */ 532 rc = fn(nvlp, arg); 533 534 nvlist_free(nvlp); 535 return (rc); 536 } 537