usr/src/lib/libdladm/common/flowprop.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 (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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <stdlib.h>
  27 #include <strings.h>
  28 #include <errno.h>
  29 #include <ctype.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <sys/dld.h>
  33 #include <sys/dld_ioc.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <libdevinfo.h>
  37 #include <libdladm_impl.h>
  38 #include <libdlflow.h>
  39 #include <libdlflow_impl.h>
  40 #include <libintl.h>
  41
  42 #include <dlfcn.h>
  43 #include <link.h>
  44
  45 /*
  46  * XXX duplicate define
  47  */
  48 #define DLADM_PROP_VAL_MAX      32
  49
  50 static dladm_status_t   i_dladm_set_flowprop_db(dladm_handle_t, const char *,
  51                             const char *, char **, uint_t);
  52 static dladm_status_t   i_dladm_get_flowprop_db(dladm_handle_t, const char *,
  53                             const char *, char **, uint_t *);
  54
  55 static fpd_getf_t       do_get_maxbw;
  56 static fpd_setf_t       do_set_maxbw;
  57 static fpd_checkf_t     do_check_maxbw;
  58
  59 static fpd_getf_t       do_get_priority;
  60 static fpd_setf_t       do_set_priority;
  61 static fpd_checkf_t     do_check_priority;
  62
  63 static fprop_desc_t     prop_table[] = {
  64         { "maxbw",      { "", 0 }, NULL, 0, B_FALSE,
  65             do_set_maxbw, NULL,
  66             do_get_maxbw, do_check_maxbw},
  67         { "priority",   { "", MPL_RESET }, NULL, 0, B_FALSE,
  68             do_set_priority, NULL,
  69             do_get_priority, do_check_priority}
  70 };
  71
  72 #define DLADM_MAX_FLOWPROPS     (sizeof (prop_table) / sizeof (fprop_desc_t))
  73
  74 static prop_table_t     prop_tbl = {
  75         prop_table,
  76         DLADM_MAX_FLOWPROPS
  77 };
  78
  79 static resource_prop_t rsrc_prop_table[] = {
  80         {"maxbw",       extract_maxbw},
  81         {"priority",    extract_priority}
  82 };
  83 #define DLADM_MAX_RSRC_PROP (sizeof (rsrc_prop_table) / \
  84         sizeof (resource_prop_t))
  85
  86 static dladm_status_t   flow_proplist_check(dladm_arg_list_t *);
  87
  88 dladm_status_t
  89 dladm_set_flowprop(dladm_handle_t handle, const char *flow,
  90     const char *prop_name, char **prop_val, uint_t val_cnt, uint_t flags,
  91     char **errprop)
  92 {
  93         dladm_status_t          status = DLADM_STATUS_BADARG;
  94
  95         if (flow == NULL || (prop_val == NULL && val_cnt > 0) ||
  96             (prop_val != NULL && val_cnt == 0) || flags == 0)
  97                 return (DLADM_STATUS_BADARG);
  98
  99         if ((flags & DLADM_OPT_ACTIVE) != 0) {
 100                 status = i_dladm_set_prop_temp(handle, flow, prop_name,
 101                     prop_val, val_cnt, flags, errprop, &prop_tbl);
 102                 if (status == DLADM_STATUS_TEMPONLY &&
 103                     (flags & DLADM_OPT_PERSIST) != 0)
 104                         return (DLADM_STATUS_TEMPONLY);
 105                 if (status != DLADM_STATUS_OK)
 106                         return (status);
 107         }
 108         if ((flags & DLADM_OPT_PERSIST) != 0) {
 109                 if (i_dladm_is_prop_temponly(prop_name, errprop, &prop_tbl))
 110                         return (DLADM_STATUS_TEMPONLY);
 111
 112                 status = i_dladm_set_flowprop_db(handle, flow, prop_name,
 113                     prop_val, val_cnt);
 114         }
 115         return (status);
 116 }
 117
 118 dladm_status_t
 119 dladm_walk_flowprop(int (*func)(void *, const char *), const char *flow,
 120     void *arg)
 121 {
 122         int     i;
 123
 124         if (flow == NULL || func == NULL)
 125                 return (DLADM_STATUS_BADARG);
 126
 127         /* Then show data-flow properties if there are any */
 128         for (i = 0; i < DLADM_MAX_FLOWPROPS; i++) {
 129                 if (func(arg, prop_table[i].pd_name) != DLADM_WALK_CONTINUE)
 130                         break;
 131         }
 132         return (DLADM_STATUS_OK);
 133 }
 134
 135 dladm_status_t
 136 dladm_get_flowprop(dladm_handle_t handle, const char *flow, uint32_t type,
 137     const char *prop_name, char **prop_val, uint_t *val_cntp)
 138 {
 139         dladm_status_t status;
 140
 141         if (flow == NULL || prop_name == NULL || prop_val == NULL ||
 142             val_cntp == NULL || *val_cntp == 0)
 143                 return (DLADM_STATUS_BADARG);
 144
 145         if (type == DLADM_PROP_VAL_PERSISTENT) {
 146                 if (i_dladm_is_prop_temponly(prop_name, NULL, &prop_tbl))
 147                         return (DLADM_STATUS_TEMPONLY);
 148                 return (i_dladm_get_flowprop_db(handle, flow, prop_name,
 149                     prop_val, val_cntp));
 150         }
 151
 152         status = i_dladm_get_prop_temp(handle, flow, type, prop_name,
 153             prop_val, val_cntp, &prop_tbl);
 154         if (status != DLADM_STATUS_NOTFOUND)
 155                 return (status);
 156
 157         return (DLADM_STATUS_BADARG);
 158 }
 159
 160 #define FLOWPROP_RW_DB(handle, statep, writeop)                 \
 161         (i_dladm_rw_db(handle, "/etc/dladm/flowprop.conf",      \
 162         S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, process_prop_db, \
 163         (statep), (writeop)))
 164
 165 static dladm_status_t
 166 i_dladm_set_flowprop_db(dladm_handle_t handle, const char *flow,
 167     const char *prop_name, char **prop_val, uint_t val_cnt)
 168 {
 169         prop_db_state_t state;
 170
 171         state.ls_op = process_prop_set;
 172         state.ls_name = flow;
 173         state.ls_propname = prop_name;
 174         state.ls_propval = prop_val;
 175         state.ls_valcntp = &val_cnt;
 176         state.ls_initop = NULL;
 177
 178         return (FLOWPROP_RW_DB(handle, &state, B_TRUE));
 179 }
 180
 181 static dladm_status_t
 182 i_dladm_get_flowprop_db(dladm_handle_t handle, const char *flow,
 183     const char *prop_name, char **prop_val, uint_t *val_cntp)
 184 {
 185         prop_db_state_t state;
 186
 187         state.ls_op = process_prop_get;
 188         state.ls_name = flow;
 189         state.ls_propname = prop_name;
 190         state.ls_propval = prop_val;
 191         state.ls_valcntp = val_cntp;
 192         state.ls_initop = NULL;
 193
 194         return (FLOWPROP_RW_DB(handle, &state, B_FALSE));
 195 }
 196
 197 dladm_status_t
 198 i_dladm_init_flowprop_db(dladm_handle_t handle)
 199 {
 200         prop_db_state_t state;
 201
 202         state.ls_op = process_prop_init;
 203         state.ls_name = NULL;
 204         state.ls_propname = NULL;
 205         state.ls_propval = NULL;
 206         state.ls_valcntp = NULL;
 207         state.ls_initop = dladm_set_flowprop;
 208
 209         return (FLOWPROP_RW_DB(handle, &state, B_FALSE));
 210 }
 211
 212 #define MIN_INFO_SIZE (4 * 1024)
 213
 214 dladm_status_t
 215 dladm_flow_info(dladm_handle_t handle, const char *flow,
 216     dladm_flow_attr_t *attr)
 217 {
 218         dld_ioc_walkflow_t      *ioc;
 219         int                     bufsize;
 220         dld_flowinfo_t          *flowinfo;
 221
 222         if ((flow == NULL) || (attr == NULL))
 223                 return (DLADM_STATUS_BADARG);
 224
 225         bufsize = MIN_INFO_SIZE;
 226         if ((ioc = calloc(1, bufsize)) == NULL)
 227                 return (dladm_errno2status(errno));
 228
 229         (void) strlcpy(ioc->wf_name, flow, sizeof (ioc->wf_name));
 230         ioc->wf_len = bufsize - sizeof (*ioc);
 231
 232         while (ioctl(dladm_dld_fd(handle), DLDIOC_WALKFLOW, ioc) < 0) {
 233                 if (errno == ENOSPC) {
 234                         bufsize *= 2;
 235                         ioc = realloc(ioc, bufsize);
 236                         if (ioc != NULL) {
 237                                 (void) strlcpy(ioc->wf_name, flow,
 238                                     MAXFLOWNAMELEN);
 239                                 ioc->wf_len = bufsize - sizeof (*ioc);
 240                                 continue;
 241                         }
 242                 }
 243                 free(ioc);
 244                 return (dladm_errno2status(errno));
 245         }
 246
 247         bzero(attr, sizeof (*attr));
 248
 249         flowinfo = (dld_flowinfo_t *)(void *)(ioc + 1);
 250
 251         attr->fa_linkid = flowinfo->fi_linkid;
 252         bcopy(&flowinfo->fi_flowname, &attr->fa_flowname,
 253             sizeof (attr->fa_flowname));
 254         bcopy(&flowinfo->fi_flow_desc, &attr->fa_flow_desc,
 255             sizeof (attr->fa_flow_desc));
 256         bcopy(&flowinfo->fi_resource_props, &attr->fa_resource_props,
 257             sizeof (attr->fa_resource_props));
 258
 259         free(ioc);
 260         return (DLADM_STATUS_OK);
 261 }
 262
 263 /* ARGSUSED */
 264 static dladm_status_t
 265 do_get_maxbw(dladm_handle_t handle, const char *flow, char **prop_val,
 266     uint_t *val_cnt)
 267 {
 268         mac_resource_props_t    *mrp;
 269         char                    buf[DLADM_STRSIZE];
 270         dladm_flow_attr_t       fa;
 271         dladm_status_t          status;
 272
 273         status = dladm_flow_info(handle, flow, &fa);
 274         if (status != DLADM_STATUS_OK)
 275                 return (status);
 276         mrp = &(fa.fa_resource_props);
 277
 278         *val_cnt = 1;
 279         if (mrp->mrp_mask & MRP_MAXBW) {
 280                 (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s",
 281                     dladm_bw2str(mrp->mrp_maxbw, buf));
 282         } else {
 283                 return (DLADM_STATUS_NOTSUP);
 284         }
 285         return (DLADM_STATUS_OK);
 286 }
 287
 288 /* ARGSUSED */
 289 static dladm_status_t
 290 do_set_maxbw(dladm_handle_t handle, const char *flow, val_desc_t *vdp,
 291     uint_t val_cnt)
 292 {
 293         dld_ioc_modifyflow_t    attr;
 294         mac_resource_props_t    mrp;
 295         void                    *val;
 296
 297         if (val_cnt != 1)
 298                 return (DLADM_STATUS_BADVALCNT);
 299
 300         bzero(&mrp, sizeof (mrp));
 301         if (vdp != NULL && (val = (void *)vdp->vd_val) != NULL) {
 302                 bcopy(val, &mrp.mrp_maxbw, sizeof (int64_t));
 303                 free(val);
 304         } else {
 305                 mrp.mrp_maxbw = MRP_MAXBW_RESETVAL;
 306         }
 307         mrp.mrp_mask = MRP_MAXBW;
 308
 309         bzero(&attr, sizeof (attr));
 310         (void) strlcpy(attr.mf_name, flow, sizeof (attr.mf_name));
 311         bcopy(&mrp, &attr.mf_resource_props, sizeof (mac_resource_props_t));
 312
 313         if (ioctl(dladm_dld_fd(handle), DLDIOC_MODIFYFLOW, &attr) < 0)
 314                 return (dladm_errno2status(errno));
 315
 316         return (DLADM_STATUS_OK);
 317 }
 318
 319 /* ARGSUSED */
 320 static dladm_status_t
 321 do_check_maxbw(fprop_desc_t *pdp, char **prop_val, uint_t val_cnt,
 322     val_desc_t **vdpp)
 323 {
 324         uint64_t        *maxbw;
 325         val_desc_t      *vdp = NULL;
 326         dladm_status_t  status = DLADM_STATUS_OK;
 327
 328         if (val_cnt != 1)
 329                 return (DLADM_STATUS_BADVALCNT);
 330
 331         maxbw = malloc(sizeof (uint64_t));
 332         if (maxbw == NULL)
 333                 return (DLADM_STATUS_NOMEM);
 334
 335         status = dladm_str2bw(*prop_val, maxbw);
 336         if (status != DLADM_STATUS_OK) {
 337                 free(maxbw);
 338                 return (status);
 339         }
 340
 341         if ((*maxbw < MRP_MAXBW_MINVAL) && (*maxbw != 0)) {
 342                 free(maxbw);
 343                 return (DLADM_STATUS_MINMAXBW);
 344         }
 345
 346         vdp = malloc(sizeof (val_desc_t));
 347         if (vdp == NULL) {
 348                 free(maxbw);
 349                 return (DLADM_STATUS_NOMEM);
 350         }
 351
 352         vdp->vd_val = (uintptr_t)maxbw;
 353         *vdpp = vdp;
 354         return (DLADM_STATUS_OK);
 355 }
 356
 357 /* ARGSUSED */
 358 static dladm_status_t
 359 do_get_priority(dladm_handle_t handle, const char *flow, char **prop_val,
 360     uint_t *val_cnt)
 361 {
 362         mac_resource_props_t    *mrp;
 363         char                    buf[DLADM_STRSIZE];
 364         dladm_flow_attr_t       fa;
 365         dladm_status_t          status;
 366
 367         bzero(&fa, sizeof (dladm_flow_attr_t));
 368         status = dladm_flow_info(handle, flow, &fa);
 369         if (status != DLADM_STATUS_OK)
 370                 return (status);
 371         mrp = &(fa.fa_resource_props);
 372
 373         *val_cnt = 1;
 374         if (mrp->mrp_mask & MRP_PRIORITY) {
 375                 (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s",
 376                     dladm_pri2str(mrp->mrp_priority, buf));
 377         } else {
 378                 return (DLADM_STATUS_NOTSUP);
 379         }
 380         return (DLADM_STATUS_OK);
 381 }
 382
 383 /* ARGSUSED */
 384 static dladm_status_t
 385 do_set_priority(dladm_handle_t handle, const char *flow, val_desc_t *vdp,
 386     uint_t val_cnt)
 387 {
 388         dld_ioc_modifyflow_t    attr;
 389         mac_resource_props_t    mrp;
 390
 391         if (val_cnt != 1)
 392                 return (DLADM_STATUS_BADVALCNT);
 393
 394         bzero(&mrp, sizeof (mrp));
 395         if (vdp != NULL) {
 396                 bcopy(&vdp->vd_val, &mrp.mrp_priority,
 397                     sizeof (mac_priority_level_t));
 398         } else {
 399                 mrp.mrp_priority = MPL_RESET;
 400         }
 401         mrp.mrp_mask = MRP_PRIORITY;
 402
 403         bzero(&attr, sizeof (attr));
 404         (void) strlcpy(attr.mf_name, flow, sizeof (attr.mf_name));
 405         bcopy(&mrp, &attr.mf_resource_props, sizeof (mac_resource_props_t));
 406
 407         if (ioctl(dladm_dld_fd(handle), DLDIOC_MODIFYFLOW, &attr) < 0)
 408                 return (dladm_errno2status(errno));
 409
 410         return (DLADM_STATUS_OK);
 411 }
 412
 413 /* ARGSUSED */
 414 static dladm_status_t
 415 do_check_priority(fprop_desc_t *pdp, char **prop_val, uint_t val_cnt,
 416     val_desc_t **vdpp)
 417 {
 418         mac_priority_level_t    pri;
 419         val_desc_t      *vdp = NULL;
 420         dladm_status_t  status = DLADM_STATUS_OK;
 421
 422         if (val_cnt != 1)
 423                 return (DLADM_STATUS_BADVALCNT);
 424
 425         status = dladm_str2pri(*prop_val, &pri);
 426         if (status != DLADM_STATUS_OK)
 427                 return (status);
 428
 429         if (pri == -1)
 430                 return (DLADM_STATUS_BADVAL);
 431
 432         vdp = malloc(sizeof (val_desc_t));
 433         if (vdp == NULL)
 434                 return (DLADM_STATUS_NOMEM);
 435
 436         vdp->vd_val = (uint_t)pri;
 437         *vdpp = vdp;
 438         return (DLADM_STATUS_OK);
 439 }
 440
 441 static dladm_status_t
 442 flow_proplist_check(dladm_arg_list_t *proplist)
 443 {
 444         int             i, j;
 445         boolean_t       matched;
 446
 447         for (i = 0; i < proplist->al_count; i++) {
 448                 matched = B_FALSE;
 449                 for (j = 0; j < DLADM_MAX_FLOWPROPS; j++) {
 450                         if (strcmp(proplist->al_info[i].ai_name,
 451                             prop_table[j].pd_name) == 0)
 452                                 matched = B_TRUE;
 453                         }
 454                 if (!matched)
 455                         return (DLADM_STATUS_BADPROP);
 456         }
 457         return (DLADM_STATUS_OK);
 458
 459 }
 460
 461 dladm_status_t
 462 dladm_parse_flow_props(char *str, dladm_arg_list_t **listp, boolean_t novalues)
 463 {
 464         dladm_status_t  status;
 465
 466         status = dladm_parse_args(str, listp, novalues);
 467         if (status != DLADM_STATUS_OK)
 468                 return (status);
 469
 470         if (*listp != NULL && (status = flow_proplist_check(*listp)
 471             != DLADM_STATUS_OK)) {
 472                 dladm_free_props(*listp);
 473                 return (status);
 474         }
 475
 476         return (DLADM_STATUS_OK);
 477 }
 478
 479 /*
 480  * Retrieve the named property from a proplist, check the value and
 481  * convert to a kernel structure.
 482  */
 483 static dladm_status_t
 484 i_dladm_flow_proplist_extract_one(dladm_arg_list_t *proplist,
 485     const char *name, void *arg)
 486 {
 487         dladm_status_t          status;
 488         dladm_arg_info_t        *aip = NULL;
 489         int                     i, j;
 490
 491         /* Find named property in proplist */
 492         for (i = 0; i < proplist->al_count; i++) {
 493                 aip = &proplist->al_info[i];
 494                 if (strcasecmp(aip->ai_name, name) == 0)
 495                         break;
 496         }
 497
 498         /* Property not in list */
 499         if (i == proplist->al_count)
 500                 return (DLADM_STATUS_OK);
 501
 502         for (i = 0; i < DLADM_MAX_FLOWPROPS; i++) {
 503                 fprop_desc_t    *pdp = &prop_table[i];
 504                 val_desc_t      *vdp;
 505
 506                 vdp = malloc(sizeof (val_desc_t) * aip->ai_count);
 507                 if (vdp == NULL)
 508                         return (DLADM_STATUS_NOMEM);
 509
 510                 if (strcasecmp(aip->ai_name, pdp->pd_name) != 0)
 511                         continue;
 512
 513                 if (aip->ai_val == NULL)
 514                         return (DLADM_STATUS_BADARG);
 515
 516                 /* Check property value */
 517                 if (pdp->pd_check != NULL) {
 518                         status = pdp->pd_check(pdp, aip->ai_val,
 519                             aip->ai_count, &vdp);
 520                 } else {
 521                         status = DLADM_STATUS_BADARG;
 522                 }
 523
 524                 if (status != DLADM_STATUS_OK)
 525                         return (status);
 526
 527                 for (j = 0; j < DLADM_MAX_RSRC_PROP; j++) {
 528                         resource_prop_t *rpp = &rsrc_prop_table[j];
 529
 530                         if (strcasecmp(aip->ai_name, rpp->rp_name) != 0)
 531                                 continue;
 532
 533                         /* Extract kernel structure */
 534                         if (rpp->rp_extract != NULL) {
 535                                 status = rpp->rp_extract(vdp,
 536                                     aip->ai_count, arg);
 537                         } else {
 538                                 status = DLADM_STATUS_BADARG;
 539                         }
 540                         break;
 541                 }
 542
 543                 if (status != DLADM_STATUS_OK)
 544                         return (status);
 545
 546                 break;
 547         }
 548         return (status);
 549 }
 550
 551 /*
 552  * Extract properties from a proplist and convert to mac_resource_props_t.
 553  */
 554 dladm_status_t
 555 dladm_flow_proplist_extract(dladm_arg_list_t *proplist,
 556     mac_resource_props_t *mrp)
 557 {
 558         dladm_status_t  status = DLADM_STATUS_OK;
 559
 560         status = i_dladm_flow_proplist_extract_one(proplist, "maxbw", mrp);
 561         if (status != DLADM_STATUS_OK)
 562                 return (status);
 563         status = i_dladm_flow_proplist_extract_one(proplist, "priority", mrp);
 564         if (status != DLADM_STATUS_OK)
 565                 return (status);
 566         return (status);
 567 }
 568
 569 dladm_status_t
 570 i_dladm_set_flow_proplist_db(dladm_handle_t handle, char *flow,
 571     dladm_arg_list_t *proplist)
 572 {
 573         dladm_status_t          status, ssave = DLADM_STATUS_OK;
 574         dladm_arg_info_t        ai;
 575         int                     i;
 576
 577         for (i = 0; i < proplist->al_count; i++) {
 578                 ai = proplist->al_info[i];
 579                 status = i_dladm_set_flowprop_db(handle, flow, ai.ai_name,
 580                     ai.ai_val, ai.ai_count);
 581                 if (status != DLADM_STATUS_OK)
 582                         ssave = status;
 583         }
 584         return (ssave);
 585 }