usr/src/uts/common/ipp/flowacct/flowacctddi.c

   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 }