Print this page 
OS-277 add ZONE column to dlstat output
Split Close
Expand all
Collapse all
          --- old/usr/src/cmd/dlstat/dlstat.c
          +++ new/usr/src/cmd/dlstat/dlstat.c
↓ open down ↓ 54 lines elided ↑ open up ↑ 
  55   55  #include <stddef.h>
  56   56  #include <ofmt.h>
  57   57  
  58   58  typedef struct link_chain_s {
  59   59          datalink_id_t           lc_linkid;
  60   60          boolean_t               lc_visited;
  61   61          dladm_stat_chain_t      *lc_statchain[DLADM_STAT_NUM_STATS];
  62   62          struct link_chain_s     *lc_next;
  63   63  } link_chain_t;
  64   64  
  65      -typedef void *  (*stats2str_t)(const char *, void *,
       65 +typedef void *  (*stats2str_t)(const char *, const char *, void *,
  66   66                      char, boolean_t);
  67   67  
  68   68  typedef struct show_state {
  69   69          link_chain_t    *ls_linkchain;
  70   70          boolean_t       ls_stattype[DLADM_STAT_NUM_STATS];
  71   71          stats2str_t     ls_stats2str[DLADM_STAT_NUM_STATS];
  72   72          ofmt_handle_t   ls_ofmt;
  73   73          char            ls_unit;
  74   74          boolean_t       ls_parsable;
  75   75  } show_state_t;
↓ open down ↓ 58 lines elided ↑ open up ↑ 
 134  134  
 135  135  /*
 136  136   * dlstat : total stat fields
 137  137   */
 138  138  typedef struct total_fields_buf_s {
 139  139          char t_linkname[MAXLINKNAMELEN];
 140  140          char t_ipackets[MAXSTATLEN];
 141  141          char t_rbytes[MAXSTATLEN];
 142  142          char t_opackets[MAXSTATLEN];
 143  143          char t_obytes[MAXSTATLEN];
      144 +        char t_zone[ZONENAME_MAX];
 144  145  } total_fields_buf_t;
 145  146  
 146  147  static ofmt_field_t total_s_fields[] = {
 147  148  { "LINK",       15,
 148  149      offsetof(total_fields_buf_t, t_linkname),   print_default_cb},
 149  150  { "IPKTS",      8,
 150  151      offsetof(total_fields_buf_t, t_ipackets),   print_default_cb},
 151  152  { "RBYTES",     8,
 152  153      offsetof(total_fields_buf_t, t_rbytes),     print_default_cb},
 153  154  { "OPKTS",      8,
 154  155      offsetof(total_fields_buf_t, t_opackets),   print_default_cb},
 155  156  { "OBYTES",     8,
 156  157      offsetof(total_fields_buf_t, t_obytes),     print_default_cb},
      158 +{ "ZONE",       20,
      159 +    offsetof(total_fields_buf_t, t_zone),       print_default_cb},
 157  160  { NULL,         0,      0,              NULL}};
 158  161  
 159  162  /*
 160  163   * dlstat show-phys: both Rx and Tx stat fields
 161  164   */
 162  165  typedef struct ring_fields_buf_s {
 163  166          char r_linkname[MAXLINKNAMELEN];
 164  167          char r_type[MAXSTATLEN];
 165  168          char r_id[MAXSTATLEN];
 166  169          char r_index[MAXSTATLEN];
↓ open down ↓ 783 lines elided ↑ open up ↑ 
 950  953                                  /* Free stats memory for the removed link */
 951  954                  for (i = 0; i < DLADM_STAT_NUM_STATS; i++) {
 952  955                          if (state->ls_stattype[i])
 953  956                                  dladm_link_stat_free(tofree->lc_statchain[i]);
 954  957                  }
 955  958                  free(tofree);
 956  959          }
 957  960  }
 958  961  
 959  962  void *
 960      -print_total_stats(const char *linkname, void *statentry, char unit,
 961      -    boolean_t parsable)
      963 +print_total_stats(const char *linkname, const char *zonename, void *statentry,
      964 +    char unit, boolean_t parsable)
 962  965  {
 963  966          total_stat_entry_t      *sentry = statentry;
 964  967          total_stat_t            *link_stats = &sentry->tse_stats;
 965  968          total_fields_buf_t      *buf;
 966  969  
 967  970          buf = malloc(sizeof (total_fields_buf_t));
 968  971          if (buf == NULL)
 969  972                  goto done;
 970  973  
 971  974          (void) snprintf(buf->t_linkname, sizeof (buf->t_linkname), "%s",
 972  975              linkname);
      976 +        (void) snprintf(buf->t_zone, sizeof (buf->t_zone), "%s", zonename);
 973  977  
 974  978          map_to_units(buf->t_ipackets, sizeof (buf->t_ipackets),
 975  979              link_stats->ts_ipackets, unit, parsable);
 976  980  
 977  981          map_to_units(buf->t_rbytes, sizeof (buf->t_rbytes),
 978  982              link_stats->ts_rbytes, unit, parsable);
 979  983  
 980  984          map_to_units(buf->t_opackets, sizeof (buf->t_opackets),
 981  985              link_stats->ts_opackets, unit, parsable);
 982  986  
 983  987          map_to_units(buf->t_obytes, sizeof (buf->t_obytes),
 984  988              link_stats->ts_obytes, unit, parsable);
 985  989  
 986  990  done:
 987  991          return (buf);
 988  992  }
 989  993  
 990  994  void *
 991      -print_rx_generic_ring_stats(const char *linkname, void *statentry, char unit,
 992      -    boolean_t parsable)
      995 +print_rx_generic_ring_stats(const char *linkname, const char *zonename, 
      996 +    void *statentry, char unit, boolean_t parsable)
 993  997  {
 994  998          ring_stat_entry_t       *sentry = statentry;
 995  999          ring_stat_t             *link_stats = &sentry->re_stats;
 996 1000          ring_fields_buf_t       *buf;
 997 1001  
 998 1002          buf = malloc(sizeof (ring_fields_buf_t));
 999 1003          if (buf == NULL)
1000 1004                  goto done;
1001 1005  
1002 1006          (void) snprintf(buf->r_linkname, sizeof (buf->r_linkname), "%s",
↓ open down ↓ 12 lines elided ↑ open up ↑ 
1015 1019              link_stats->r_packets, unit, parsable);
1016 1020  
1017 1021          map_to_units(buf->r_bytes, sizeof (buf->r_bytes),
1018 1022              link_stats->r_bytes, unit, parsable);
1019 1023  
1020 1024  done:
1021 1025          return (buf);
1022 1026  }
1023 1027  
1024 1028  void *
1025      -print_tx_generic_ring_stats(const char *linkname, void *statentry, char unit,
1026      -    boolean_t parsable)
     1029 +print_tx_generic_ring_stats(const char *linkname, const char *zonename,
     1030 +    void *statentry, char unit, boolean_t parsable)
1027 1031  {
1028 1032          ring_stat_entry_t       *sentry = statentry;
1029 1033          ring_stat_t             *link_stats = &sentry->re_stats;
1030 1034          ring_fields_buf_t       *buf;
1031 1035  
1032 1036          buf = malloc(sizeof (ring_fields_buf_t));
1033 1037          if (buf == NULL)
1034 1038                  goto done;
1035 1039  
1036 1040          (void) snprintf(buf->r_linkname, sizeof (buf->r_linkname), "%s",
↓ open down ↓ 12 lines elided ↑ open up ↑ 
1049 1053              link_stats->r_packets, unit, parsable);
1050 1054  
1051 1055          map_to_units(buf->r_bytes, sizeof (buf->r_bytes),
1052 1056              link_stats->r_bytes, unit, parsable);
1053 1057  
1054 1058  done:
1055 1059          return (buf);
1056 1060  }
1057 1061  
1058 1062  void *
1059      -print_rx_ring_stats(const char *linkname, void *statentry, char unit,
1060      -    boolean_t parsable)
     1063 +print_rx_ring_stats(const char *linkname, const char *zonename, void *statentry,
     1064 +    char unit, boolean_t parsable)
1061 1065  {
1062 1066          ring_stat_entry_t       *sentry = statentry;
1063 1067          ring_stat_t             *link_stats = &sentry->re_stats;
1064 1068          rx_ring_fields_buf_t    *buf;
1065 1069  
1066 1070          buf = malloc(sizeof (rx_ring_fields_buf_t));
1067 1071          if (buf == NULL)
1068 1072                  goto done;
1069 1073  
1070 1074          (void) snprintf(buf->rr_linkname, sizeof (buf->rr_linkname), "%s",
↓ open down ↓ 12 lines elided ↑ open up ↑ 
1083 1087              link_stats->r_packets, unit, parsable);
1084 1088  
1085 1089          map_to_units(buf->rr_rbytes, sizeof (buf->rr_rbytes),
1086 1090              link_stats->r_bytes, unit, parsable);
1087 1091  
1088 1092  done:
1089 1093          return (buf);
1090 1094  }
1091 1095  
1092 1096  void *
1093      -print_tx_ring_stats(const char *linkname, void *statentry, char unit,
1094      -    boolean_t parsable)
     1097 +print_tx_ring_stats(const char *linkname, const char *zonename, void *statentry,
     1098 +    char unit, boolean_t parsable)
1095 1099  {
1096 1100          ring_stat_entry_t       *sentry = statentry;
1097 1101          ring_stat_t             *link_stats = &sentry->re_stats;
1098 1102          tx_ring_fields_buf_t    *buf;
1099 1103  
1100 1104          buf = malloc(sizeof (tx_ring_fields_buf_t));
1101 1105          if (buf == NULL)
1102 1106                  goto done;
1103 1107  
1104 1108          (void) snprintf(buf->tr_linkname, sizeof (buf->tr_linkname), "%s",
↓ open down ↓ 12 lines elided ↑ open up ↑ 
1117 1121              link_stats->r_packets, unit, parsable);
1118 1122  
1119 1123          map_to_units(buf->tr_obytes, sizeof (buf->tr_obytes),
1120 1124              link_stats->r_bytes, unit, parsable);
1121 1125  
1122 1126  done:
1123 1127          return (buf);
1124 1128  }
1125 1129  
1126 1130  void *
1127      -print_rx_generic_lane_stats(const char *linkname, void *statentry, char unit,
1128      -    boolean_t parsable)
     1131 +print_rx_generic_lane_stats(const char *linkname, const char *zonename,
     1132 +    void *statentry, char unit, boolean_t parsable)
1129 1133  {
1130 1134          rx_lane_stat_entry_t    *sentry = statentry;
1131 1135          rx_lane_stat_t          *link_stats = &sentry->rle_stats;
1132 1136          lane_fields_buf_t       *buf;
1133 1137  
1134 1138          if (sentry->rle_id == L_DFNCT)
1135 1139                  return (NULL);
1136 1140  
1137 1141          buf = malloc(sizeof (lane_fields_buf_t));
1138 1142          if (buf == NULL)
↓ open down ↓ 26 lines elided ↑ open up ↑ 
1165 1169              link_stats->rl_ipackets, unit, parsable);
1166 1170  
1167 1171          map_to_units(buf->l_bytes, sizeof (buf->l_bytes),
1168 1172              link_stats->rl_rbytes, unit, parsable);
1169 1173  
1170 1174  done:
1171 1175          return (buf);
1172 1176  }
1173 1177  
1174 1178  void *
1175      -print_tx_generic_lane_stats(const char *linkname, void *statentry, char unit,
1176      -    boolean_t parsable)
     1179 +print_tx_generic_lane_stats(const char *linkname, const char *zonename,
     1180 +    void *statentry, char unit, boolean_t parsable)
1177 1181  {
1178 1182          tx_lane_stat_entry_t    *sentry = statentry;
1179 1183          tx_lane_stat_t          *link_stats = &sentry->tle_stats;
1180 1184          lane_fields_buf_t       *buf;
1181 1185  
1182 1186          if (sentry->tle_id == L_DFNCT)
1183 1187                  return (NULL);
1184 1188  
1185 1189          buf = malloc(sizeof (lane_fields_buf_t));
1186 1190          if (buf == NULL)
↓ open down ↓ 23 lines elided ↑ open up ↑ 
1210 1214              link_stats->tl_opackets, unit, parsable);
1211 1215  
1212 1216          map_to_units(buf->l_bytes, sizeof (buf->l_bytes),
1213 1217              link_stats->tl_obytes, unit, parsable);
1214 1218  
1215 1219  done:
1216 1220          return (buf);
1217 1221  }
1218 1222  
1219 1223  void *
1220      -print_rx_lane_stats(const char *linkname, void *statentry, char unit,
1221      -    boolean_t parsable)
     1224 +print_rx_lane_stats(const char *linkname, const char *zonename, void *statentry,
     1225 +    char unit, boolean_t parsable)
1222 1226  {
1223 1227          rx_lane_stat_entry_t    *sentry = statentry;
1224 1228          rx_lane_stat_t          *link_stats = &sentry->rle_stats;
1225 1229          rx_lane_fields_buf_t    *buf;
1226 1230  
1227 1231          if (sentry->rle_id == L_DFNCT)
1228 1232                  return (NULL);
1229 1233  
1230 1234          buf = malloc(sizeof (rx_lane_fields_buf_t));
1231 1235          if (buf == NULL)
↓ open down ↓ 44 lines elided ↑ open up ↑ 
1276 1280              link_stats->rl_ch10_50, unit, parsable);
1277 1281  
1278 1282          map_to_units(buf->rl_chg50, sizeof (buf->rl_chg50),
1279 1283              link_stats->rl_chg50, unit, parsable);
1280 1284  
1281 1285  done:
1282 1286          return (buf);
1283 1287  }
1284 1288  
1285 1289  void *
1286      -print_tx_lane_stats(const char *linkname, void *statentry, char unit,
1287      -    boolean_t parsable)
1288      -{
     1290 +print_tx_lane_stats(const char *linkname, const char *zonename, void *statentry,
     1291 +    char unit, boolean_t parsable) {
1289 1292          tx_lane_stat_entry_t    *sentry = statentry;
1290 1293          tx_lane_stat_t          *link_stats = &sentry->tle_stats;
1291 1294          tx_lane_fields_buf_t    *buf = NULL;
1292 1295  
1293 1296          if (sentry->tle_id == L_DFNCT)
1294 1297                  return (NULL);
1295 1298  
1296 1299          buf = malloc(sizeof (tx_lane_fields_buf_t));
1297 1300          if (buf == NULL)
1298 1301                  goto done;
↓ open down ↓ 32 lines elided ↑ open up ↑ 
1331 1334              link_stats->tl_unblockcnt, unit, parsable);
1332 1335  
1333 1336          map_to_units(buf->tl_sdrops, sizeof (buf->tl_sdrops),
1334 1337              link_stats->tl_sdrops, unit, parsable);
1335 1338  
1336 1339  done:
1337 1340          return (buf);
1338 1341  }
1339 1342  
1340 1343  void *
1341      -print_fanout_stats(const char *linkname, void *statentry, char unit,
1342      -    boolean_t parsable)
     1344 +print_fanout_stats(const char *linkname, const char *zonename, void *statentry,
     1345 +    char unit, boolean_t parsable)
1343 1346  {
1344 1347          fanout_stat_entry_t             *sentry = statentry;
1345 1348          fanout_stat_t                   *link_stats = &sentry->fe_stats;
1346 1349          rx_fanout_lane_fields_buf_t     *buf;
1347 1350  
1348 1351          buf = malloc(sizeof (rx_fanout_lane_fields_buf_t));
1349 1352          if (buf == NULL)
1350 1353                  goto done;
1351 1354  
1352 1355          (void) snprintf(buf->rfl_linkname, sizeof (buf->rfl_linkname), "%s",
↓ open down ↓ 32 lines elided ↑ open up ↑ 
1385 1388              link_stats->f_ipackets, unit, parsable);
1386 1389  
1387 1390          map_to_units(buf->rfl_rbytes, sizeof (buf->rfl_rbytes),
1388 1391              link_stats->f_rbytes, unit, parsable);
1389 1392  
1390 1393  done:
1391 1394          return (buf);
1392 1395  }
1393 1396  
1394 1397  void *
1395      -print_aggr_port_stats(const char *linkname, void *statentry, char unit,
1396      -    boolean_t parsable)
     1398 +print_aggr_port_stats(const char *linkname, const char *zonename,
     1399 +    void *statentry, char unit, boolean_t parsable)
1397 1400  {
1398 1401          aggr_port_stat_entry_t  *sentry = statentry;
1399 1402          aggr_port_stat_t        *link_stats = &sentry->ape_stats;
1400 1403          aggr_port_fields_buf_t  *buf;
1401 1404          char                    portname[MAXLINKNAMELEN];
1402 1405  
1403 1406          buf = malloc(sizeof (aggr_port_fields_buf_t));
1404 1407          if (buf == NULL)
1405 1408                  goto done;
1406 1409
↓ open down ↓ 56 lines elided ↑ open up ↑ 
1463 1466  
1464 1467          /* Prev <- curr stats */
1465 1468          link_node->lc_statchain[stattype] = curr_stat;
1466 1469  
1467 1470  done:
1468 1471          return (diff_stat);
1469 1472  }
1470 1473  
1471 1474  void
1472 1475  walk_dlstat_stats(show_state_t *state, const char *linkname,
1473      -    dladm_stat_type_t stattype, dladm_stat_chain_t *diff_stat)
     1476 +    const char *zonename, dladm_stat_type_t stattype,
     1477 +    dladm_stat_chain_t *diff_stat)
1474 1478  {
1475 1479          dladm_stat_chain_t  *curr;
1476 1480  
1477 1481          /* Unpack invidual stat entry and call library consumer's callback */
1478 1482          for (curr = diff_stat; curr != NULL; curr = curr->dc_next) {
1479 1483                  void    *fields_buf;
1480 1484  
1481 1485                  /* Format the raw numbers for printing */
1482 1486                  fields_buf = state->ls_stats2str[stattype](linkname,
1483      -                    curr->dc_statentry, state->ls_unit, state->ls_parsable);
     1487 +                    zonename, curr->dc_statentry, state->ls_unit,
     1488 +                    state->ls_parsable);
1484 1489                  /* Print the stats */
1485 1490                  if (fields_buf != NULL)
1486 1491                          ofmt_print(state->ls_ofmt, fields_buf);
1487 1492                  free(fields_buf);
1488 1493          }
1489 1494  }
1490 1495  
1491 1496  static int
1492 1497  show_queried_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)
1493 1498  {
1494 1499          show_state_t            *state = arg;
1495 1500          int                     i;
1496 1501          dladm_stat_chain_t      *diff_stat;
1497 1502          char                    linkname[DLPI_LINKNAME_MAX];
     1503 +        char                    zonename[DLADM_PROP_VAL_MAX + 1];
     1504 +        char                    *valptr[1];
     1505 +        uint_t                  valcnt = 1;
1498 1506  
1499 1507          if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, linkname,
1500 1508              DLPI_LINKNAME_MAX) != DLADM_STATUS_OK) {
1501 1509                  goto done;
1502 1510          }
1503 1511  
     1512 +        valptr[0] = zonename;
     1513 +        if (dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_CURRENT, "zone",
     1514 +            (char **)valptr, &valcnt) != 0)
     1515 +                zonename[0] = '\0';
     1516 +
1504 1517          for (i = 0; i < DLADM_STAT_NUM_STATS; i++) {
1505 1518                  if (state->ls_stattype[i]) {
1506 1519                          /*
1507 1520                           * Query library for stats
1508 1521                           * Stats are returned as chain of raw numbers
1509 1522                           */
1510 1523                          diff_stat = query_link_stats(handle, linkid, arg, i);
1511      -                        walk_dlstat_stats(state, linkname, i, diff_stat);
     1524 +                        walk_dlstat_stats(state, linkname, zonename, i,
     1525 +                            diff_stat);
1512 1526                          dladm_link_stat_free(diff_stat);
1513 1527                  }
1514 1528          }
1515 1529  done:
1516 1530          return (DLADM_WALK_CONTINUE);
1517 1531  }
1518 1532  
1519 1533  void
1520 1534  show_link_stats(datalink_id_t linkid, show_state_t state, uint32_t interval)
1521 1535  {
↓ open down ↓ 99 lines elided ↑ open up ↑ 
1621 1635          uint32_t                flags = DLADM_OPT_ACTIVE;
1622 1636          datalink_id_t           linkid = DATALINK_ALL_LINKID;
1623 1637          uint32_t                interval = 0;
1624 1638          char                    unit = '\0';
1625 1639          show_state_t            state;
1626 1640          dladm_status_t          status;
1627 1641          char                    *fields_str = NULL;
1628 1642          char                    *o_fields_str = NULL;
1629 1643  
1630 1644          char                    *total_stat_fields =
1631      -            "link,ipkts,rbytes,opkts,obytes";
     1645 +            "link,ipkts,rbytes,opkts,obytes,zone";
1632 1646          char                    *rx_total_stat_fields =
1633 1647              "link,ipkts,rbytes,intrs,polls,ch<10,ch10-50,ch>50";
1634 1648          char                    *tx_total_stat_fields =
1635 1649              "link,opkts,obytes,blkcnt,ublkcnt";
1636 1650  
1637 1651          ofmt_handle_t           ofmt;
1638 1652          ofmt_status_t           oferr;
1639 1653          uint_t                  ofmtflags = OFMT_RIGHTJUST;
1640 1654          ofmt_field_t            *oftemplate;
1641 1655
↓ open down ↓ 816 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX