| /* |
| * ethtool.c: Linux ethernet device configuration tool. |
| * |
| * Copyright (C) 1998 David S. Miller (davem@dm.cobaltmicro.com) |
| * Portions Copyright 2001 Sun Microsystems |
| * Kernel 2.4 update Copyright 2001 Jeff Garzik <jgarzik@mandrakesoft.com> |
| * Wake-on-LAN,natsemi,misc support by Tim Hockin <thockin@sun.com> |
| * Portions Copyright 2002 Intel |
| * Portions Copyright (C) Sun Microsystems 2008 |
| * do_test support by Eli Kupermann <eli.kupermann@intel.com> |
| * ETHTOOL_PHYS_ID support by Chris Leech <christopher.leech@intel.com> |
| * e1000 support by Scott Feldman <scott.feldman@intel.com> |
| * e100 support by Wen Tao <wen-hwa.tao@intel.com> |
| * ixgb support by Nicholas Nunley <Nicholas.d.nunley@intel.com> |
| * amd8111e support by Reeja John <reeja.john@amd.com> |
| * long arguments by Andi Kleen. |
| * SMSC LAN911x support by Steve Glendinning <steve.glendinning@smsc.com> |
| * Rx Network Flow Control configuration support <santwona.behera@sun.com> |
| * Various features by Ben Hutchings <bhutchings@solarflare.com>; |
| * Copyright 2009, 2010 Solarflare Communications |
| * MDI-X set support by Jesse Brandeburg <jesse.brandeburg@intel.com> |
| * Copyright 2012 Intel Corporation |
| * vmxnet3 support by Shrikrishna Khare <skhare@vmware.com> |
| * Various features by Ben Hutchings <ben@decadent.org.uk>; |
| * Copyright 2008-2010, 2013-2016 Ben Hutchings |
| * QSFP+/QSFP28 DOM support by Vidya Sagar Ravipati <vidya@cumulusnetworks.com> |
| * |
| * TODO: |
| * * show settings for all devices |
| */ |
| |
| #include "internal.h" |
| #include <string.h> |
| #include <stdlib.h> |
| #include <sys/stat.h> |
| #include <stdio.h> |
| #include <stddef.h> |
| #include <stdbool.h> |
| #include <errno.h> |
| #include <sys/utsname.h> |
| #include <limits.h> |
| #include <ctype.h> |
| |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| |
| #include <linux/sockios.h> |
| #include <linux/netlink.h> |
| |
| #ifndef MAX_ADDR_LEN |
| #define MAX_ADDR_LEN 32 |
| #endif |
| |
| #ifndef HAVE_NETIF_MSG |
| enum { |
| NETIF_MSG_DRV = 0x0001, |
| NETIF_MSG_PROBE = 0x0002, |
| NETIF_MSG_LINK = 0x0004, |
| NETIF_MSG_TIMER = 0x0008, |
| NETIF_MSG_IFDOWN = 0x0010, |
| NETIF_MSG_IFUP = 0x0020, |
| NETIF_MSG_RX_ERR = 0x0040, |
| NETIF_MSG_TX_ERR = 0x0080, |
| NETIF_MSG_TX_QUEUED = 0x0100, |
| NETIF_MSG_INTR = 0x0200, |
| NETIF_MSG_TX_DONE = 0x0400, |
| NETIF_MSG_RX_STATUS = 0x0800, |
| NETIF_MSG_PKTDATA = 0x1000, |
| NETIF_MSG_HW = 0x2000, |
| NETIF_MSG_WOL = 0x4000, |
| }; |
| #endif |
| |
| #ifndef NETLINK_GENERIC |
| #define NETLINK_GENERIC 16 |
| #endif |
| |
| #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) |
| |
| static void exit_bad_args(void) __attribute__((noreturn)); |
| |
| static void exit_bad_args(void) |
| { |
| fprintf(stderr, |
| "ethtool: bad command line argument(s)\n" |
| "For more information run ethtool -h\n"); |
| exit(1); |
| } |
| |
| typedef enum { |
| CMDL_NONE, |
| CMDL_BOOL, |
| CMDL_S32, |
| CMDL_U8, |
| CMDL_U16, |
| CMDL_U32, |
| CMDL_U64, |
| CMDL_BE16, |
| CMDL_IP4, |
| CMDL_STR, |
| CMDL_FLAG, |
| CMDL_MAC, |
| } cmdline_type_t; |
| |
| struct cmdline_info { |
| const char *name; |
| cmdline_type_t type; |
| /* Points to int (BOOL), s32, u16, u32 (U32/FLAG/IP4), u64, |
| * char * (STR) or u8[6] (MAC). For FLAG, the value accumulates |
| * all flags to be set. */ |
| void *wanted_val; |
| void *ioctl_val; |
| /* For FLAG, the flag value to be set/cleared */ |
| u32 flag_val; |
| /* For FLAG, points to u32 and accumulates all flags seen. |
| * For anything else, points to int and is set if the option is |
| * seen. */ |
| void *seen_val; |
| }; |
| |
| struct flag_info { |
| const char *name; |
| u32 value; |
| }; |
| |
| static const struct flag_info flags_msglvl[] = { |
| { "drv", NETIF_MSG_DRV }, |
| { "probe", NETIF_MSG_PROBE }, |
| { "link", NETIF_MSG_LINK }, |
| { "timer", NETIF_MSG_TIMER }, |
| { "ifdown", NETIF_MSG_IFDOWN }, |
| { "ifup", NETIF_MSG_IFUP }, |
| { "rx_err", NETIF_MSG_RX_ERR }, |
| { "tx_err", NETIF_MSG_TX_ERR }, |
| { "tx_queued", NETIF_MSG_TX_QUEUED }, |
| { "intr", NETIF_MSG_INTR }, |
| { "tx_done", NETIF_MSG_TX_DONE }, |
| { "rx_status", NETIF_MSG_RX_STATUS }, |
| { "pktdata", NETIF_MSG_PKTDATA }, |
| { "hw", NETIF_MSG_HW }, |
| { "wol", NETIF_MSG_WOL }, |
| }; |
| |
| struct off_flag_def { |
| const char *short_name; |
| const char *long_name; |
| const char *kernel_name; |
| u32 get_cmd, set_cmd; |
| u32 value; |
| /* For features exposed through ETHTOOL_GFLAGS, the oldest |
| * kernel version for which we can trust the result. Where |
| * the flag was added at the same time the kernel started |
| * supporting the feature, this is 0 (to allow for backports). |
| * Where the feature was supported before the flag was added, |
| * it is the version that introduced the flag. |
| */ |
| u32 min_kernel_ver; |
| }; |
| static const struct off_flag_def off_flag_def[] = { |
| { "rx", "rx-checksumming", "rx-checksum", |
| ETHTOOL_GRXCSUM, ETHTOOL_SRXCSUM, ETH_FLAG_RXCSUM, 0 }, |
| { "tx", "tx-checksumming", "tx-checksum-*", |
| ETHTOOL_GTXCSUM, ETHTOOL_STXCSUM, ETH_FLAG_TXCSUM, 0 }, |
| { "sg", "scatter-gather", "tx-scatter-gather*", |
| ETHTOOL_GSG, ETHTOOL_SSG, ETH_FLAG_SG, 0 }, |
| { "tso", "tcp-segmentation-offload", "tx-tcp*-segmentation", |
| ETHTOOL_GTSO, ETHTOOL_STSO, ETH_FLAG_TSO, 0 }, |
| { "ufo", "udp-fragmentation-offload", "tx-udp-fragmentation", |
| ETHTOOL_GUFO, ETHTOOL_SUFO, ETH_FLAG_UFO, 0 }, |
| { "gso", "generic-segmentation-offload", "tx-generic-segmentation", |
| ETHTOOL_GGSO, ETHTOOL_SGSO, ETH_FLAG_GSO, 0 }, |
| { "gro", "generic-receive-offload", "rx-gro", |
| ETHTOOL_GGRO, ETHTOOL_SGRO, ETH_FLAG_GRO, 0 }, |
| { "lro", "large-receive-offload", "rx-lro", |
| 0, 0, ETH_FLAG_LRO, |
| KERNEL_VERSION(2,6,24) }, |
| { "rxvlan", "rx-vlan-offload", "rx-vlan-hw-parse", |
| 0, 0, ETH_FLAG_RXVLAN, |
| KERNEL_VERSION(2,6,37) }, |
| { "txvlan", "tx-vlan-offload", "tx-vlan-hw-insert", |
| 0, 0, ETH_FLAG_TXVLAN, |
| KERNEL_VERSION(2,6,37) }, |
| { "ntuple", "ntuple-filters", "rx-ntuple-filter", |
| 0, 0, ETH_FLAG_NTUPLE, 0 }, |
| { "rxhash", "receive-hashing", "rx-hashing", |
| 0, 0, ETH_FLAG_RXHASH, 0 }, |
| }; |
| |
| struct feature_def { |
| char name[ETH_GSTRING_LEN]; |
| int off_flag_index; /* index in off_flag_def; negative if none match */ |
| }; |
| |
| struct feature_defs { |
| size_t n_features; |
| /* Number of features each offload flag is associated with */ |
| unsigned int off_flag_matched[ARRAY_SIZE(off_flag_def)]; |
| /* Name and offload flag index for each feature */ |
| struct feature_def def[0]; |
| }; |
| |
| #define FEATURE_BITS_TO_BLOCKS(n_bits) DIV_ROUND_UP(n_bits, 32U) |
| #define FEATURE_WORD(blocks, index, field) ((blocks)[(index) / 32U].field) |
| #define FEATURE_FIELD_FLAG(index) (1U << (index) % 32U) |
| #define FEATURE_BIT_SET(blocks, index, field) \ |
| (FEATURE_WORD(blocks, index, field) |= FEATURE_FIELD_FLAG(index)) |
| #define FEATURE_BIT_CLEAR(blocks, index, field) \ |
| (FEATURE_WORD(blocks, index, filed) &= ~FEATURE_FIELD_FLAG(index)) |
| #define FEATURE_BIT_IS_SET(blocks, index, field) \ |
| (FEATURE_WORD(blocks, index, field) & FEATURE_FIELD_FLAG(index)) |
| |
| static long long |
| get_int_range(char *str, int base, long long min, long long max) |
| { |
| long long v; |
| char *endp; |
| |
| if (!str) |
| exit_bad_args(); |
| errno = 0; |
| v = strtoll(str, &endp, base); |
| if (errno || *endp || v < min || v > max) |
| exit_bad_args(); |
| return v; |
| } |
| |
| static unsigned long long |
| get_uint_range(char *str, int base, unsigned long long max) |
| { |
| unsigned long long v; |
| char *endp; |
| |
| if (!str) |
| exit_bad_args(); |
| errno = 0; |
| v = strtoull(str, &endp, base); |
| if (errno || *endp || v > max) |
| exit_bad_args(); |
| return v; |
| } |
| |
| static int get_int(char *str, int base) |
| { |
| return get_int_range(str, base, INT_MIN, INT_MAX); |
| } |
| |
| static u32 get_u32(char *str, int base) |
| { |
| return get_uint_range(str, base, 0xffffffff); |
| } |
| |
| static void get_mac_addr(char *src, unsigned char *dest) |
| { |
| int count; |
| int i; |
| int buf[ETH_ALEN]; |
| |
| count = sscanf(src, "%2x:%2x:%2x:%2x:%2x:%2x", |
| &buf[0], &buf[1], &buf[2], &buf[3], &buf[4], &buf[5]); |
| if (count != ETH_ALEN) |
| exit_bad_args(); |
| |
| for (i = 0; i < count; i++) |
| dest[i] = buf[i]; |
| } |
| |
| static int parse_hex_u32_bitmap(const char *s, |
| unsigned int nbits, u32 *result) |
| { |
| const unsigned int nwords = __KERNEL_DIV_ROUND_UP(nbits, 32); |
| size_t slen = strlen(s); |
| size_t i; |
| |
| /* ignore optional '0x' prefix */ |
| if ((slen > 2) && (strncasecmp(s, "0x", 2) == 0)) { |
| slen -= 2; |
| s += 2; |
| } |
| |
| if (slen > 8 * nwords) /* up to 2 digits per byte */ |
| return -1; |
| |
| memset(result, 0, 4 * nwords); |
| for (i = 0; i < slen; ++i) { |
| const unsigned int shift = (slen - 1 - i) * 4; |
| u32 *dest = &result[shift / 32]; |
| u32 nibble; |
| |
| if ('a' <= s[i] && s[i] <= 'f') |
| nibble = 0xa + (s[i] - 'a'); |
| else if ('A' <= s[i] && s[i] <= 'F') |
| nibble = 0xa + (s[i] - 'A'); |
| else if ('0' <= s[i] && s[i] <= '9') |
| nibble = (s[i] - '0'); |
| else |
| return -1; |
| |
| *dest |= (nibble << (shift % 32)); |
| } |
| |
| return 0; |
| } |
| |
| static void parse_generic_cmdline(struct cmd_context *ctx, |
| int *changed, |
| struct cmdline_info *info, |
| unsigned int n_info) |
| { |
| int argc = ctx->argc; |
| char **argp = ctx->argp; |
| int i, idx; |
| int found; |
| |
| for (i = 0; i < argc; i++) { |
| found = 0; |
| for (idx = 0; idx < n_info; idx++) { |
| if (!strcmp(info[idx].name, argp[i])) { |
| found = 1; |
| *changed = 1; |
| if (info[idx].type != CMDL_FLAG && |
| info[idx].seen_val) |
| *(int *)info[idx].seen_val = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| switch (info[idx].type) { |
| case CMDL_BOOL: { |
| int *p = info[idx].wanted_val; |
| if (!strcmp(argp[i], "on")) |
| *p = 1; |
| else if (!strcmp(argp[i], "off")) |
| *p = 0; |
| else |
| exit_bad_args(); |
| break; |
| } |
| case CMDL_S32: { |
| s32 *p = info[idx].wanted_val; |
| *p = get_int_range(argp[i], 0, |
| -0x80000000LL, |
| 0x7fffffff); |
| break; |
| } |
| case CMDL_U8: { |
| u8 *p = info[idx].wanted_val; |
| *p = get_uint_range(argp[i], 0, 0xff); |
| break; |
| } |
| case CMDL_U16: { |
| u16 *p = info[idx].wanted_val; |
| *p = get_uint_range(argp[i], 0, 0xffff); |
| break; |
| } |
| case CMDL_U32: { |
| u32 *p = info[idx].wanted_val; |
| *p = get_uint_range(argp[i], 0, |
| 0xffffffff); |
| break; |
| } |
| case CMDL_U64: { |
| u64 *p = info[idx].wanted_val; |
| *p = get_uint_range( |
| argp[i], 0, |
| 0xffffffffffffffffLL); |
| break; |
| } |
| case CMDL_BE16: { |
| u16 *p = info[idx].wanted_val; |
| *p = cpu_to_be16( |
| get_uint_range(argp[i], 0, |
| 0xffff)); |
| break; |
| } |
| case CMDL_IP4: { |
| u32 *p = info[idx].wanted_val; |
| struct in_addr in; |
| if (!inet_aton(argp[i], &in)) |
| exit_bad_args(); |
| *p = in.s_addr; |
| break; |
| } |
| case CMDL_MAC: |
| get_mac_addr(argp[i], |
| info[idx].wanted_val); |
| break; |
| case CMDL_FLAG: { |
| u32 *p; |
| p = info[idx].seen_val; |
| *p |= info[idx].flag_val; |
| if (!strcmp(argp[i], "on")) { |
| p = info[idx].wanted_val; |
| *p |= info[idx].flag_val; |
| } else if (strcmp(argp[i], "off")) { |
| exit_bad_args(); |
| } |
| break; |
| } |
| case CMDL_STR: { |
| char **s = info[idx].wanted_val; |
| *s = strdup(argp[i]); |
| break; |
| } |
| default: |
| exit_bad_args(); |
| } |
| break; |
| } |
| } |
| if (!found) |
| exit_bad_args(); |
| } |
| } |
| |
| static void flag_to_cmdline_info(const char *name, u32 value, |
| u32 *wanted, u32 *mask, |
| struct cmdline_info *cli) |
| { |
| memset(cli, 0, sizeof(*cli)); |
| cli->name = name; |
| cli->type = CMDL_FLAG; |
| cli->flag_val = value; |
| cli->wanted_val = wanted; |
| cli->seen_val = mask; |
| } |
| |
| static void |
| print_flags(const struct flag_info *info, unsigned int n_info, u32 value) |
| { |
| const char *sep = ""; |
| |
| while (n_info) { |
| if (value & info->value) { |
| printf("%s%s", sep, info->name); |
| sep = " "; |
| value &= ~info->value; |
| } |
| ++info; |
| --n_info; |
| } |
| |
| /* Print any unrecognised flags in hex */ |
| if (value) |
| printf("%s%#x", sep, value); |
| } |
| |
| static int rxflow_str_to_type(const char *str) |
| { |
| int flow_type = 0; |
| |
| if (!strcmp(str, "tcp4")) |
| flow_type = TCP_V4_FLOW; |
| else if (!strcmp(str, "udp4")) |
| flow_type = UDP_V4_FLOW; |
| else if (!strcmp(str, "ah4") || !strcmp(str, "esp4")) |
| flow_type = AH_ESP_V4_FLOW; |
| else if (!strcmp(str, "sctp4")) |
| flow_type = SCTP_V4_FLOW; |
| else if (!strcmp(str, "tcp6")) |
| flow_type = TCP_V6_FLOW; |
| else if (!strcmp(str, "udp6")) |
| flow_type = UDP_V6_FLOW; |
| else if (!strcmp(str, "ah6") || !strcmp(str, "esp6")) |
| flow_type = AH_ESP_V6_FLOW; |
| else if (!strcmp(str, "sctp6")) |
| flow_type = SCTP_V6_FLOW; |
| else if (!strcmp(str, "ether")) |
| flow_type = ETHER_FLOW; |
| |
| return flow_type; |
| } |
| |
| static int do_version(struct cmd_context *ctx maybe_unused) |
| { |
| fprintf(stdout, |
| PACKAGE " version " VERSION |
| #ifndef ETHTOOL_ENABLE_PRETTY_DUMP |
| " (pretty dumps disabled)" |
| #endif |
| "\n"); |
| return 0; |
| } |
| |
| /* link mode routines */ |
| |
| static ETHTOOL_DECLARE_LINK_MODE_MASK(all_advertised_modes); |
| static ETHTOOL_DECLARE_LINK_MODE_MASK(all_advertised_flags); |
| |
| static void init_global_link_mode_masks(void) |
| { |
| static const enum ethtool_link_mode_bit_indices |
| all_advertised_modes_bits[] = { |
| ETHTOOL_LINK_MODE_10baseT_Half_BIT, |
| ETHTOOL_LINK_MODE_10baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_100baseT_Half_BIT, |
| ETHTOOL_LINK_MODE_100baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_1000baseT_Half_BIT, |
| ETHTOOL_LINK_MODE_1000baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, |
| ETHTOOL_LINK_MODE_2500baseX_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseR_FEC_BIT, |
| ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT, |
| ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT, |
| ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, |
| ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, |
| ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, |
| ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, |
| ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT, |
| ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT, |
| ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT, |
| ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT, |
| ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, |
| ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, |
| ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT, |
| ETHTOOL_LINK_MODE_1000baseX_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseCR_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT, |
| ETHTOOL_LINK_MODE_10000baseER_Full_BIT, |
| ETHTOOL_LINK_MODE_2500baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_5000baseT_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseKR_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseSR_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseCR_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT, |
| ETHTOOL_LINK_MODE_50000baseDR_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT, |
| ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT, |
| ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT, |
| ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT, |
| ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT, |
| ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT, |
| ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT, |
| ETHTOOL_LINK_MODE_100baseT1_Full_BIT, |
| ETHTOOL_LINK_MODE_1000baseT1_Full_BIT, |
| }; |
| static const enum ethtool_link_mode_bit_indices |
| additional_advertised_flags_bits[] = { |
| ETHTOOL_LINK_MODE_Autoneg_BIT, |
| ETHTOOL_LINK_MODE_TP_BIT, |
| ETHTOOL_LINK_MODE_AUI_BIT, |
| ETHTOOL_LINK_MODE_MII_BIT, |
| ETHTOOL_LINK_MODE_FIBRE_BIT, |
| ETHTOOL_LINK_MODE_BNC_BIT, |
| ETHTOOL_LINK_MODE_Pause_BIT, |
| ETHTOOL_LINK_MODE_Asym_Pause_BIT, |
| ETHTOOL_LINK_MODE_Backplane_BIT, |
| ETHTOOL_LINK_MODE_FEC_NONE_BIT, |
| ETHTOOL_LINK_MODE_FEC_RS_BIT, |
| ETHTOOL_LINK_MODE_FEC_BASER_BIT, |
| }; |
| unsigned int i; |
| |
| ethtool_link_mode_zero(all_advertised_modes); |
| ethtool_link_mode_zero(all_advertised_flags); |
| for (i = 0; i < ARRAY_SIZE(all_advertised_modes_bits); ++i) { |
| ethtool_link_mode_set_bit(all_advertised_modes_bits[i], |
| all_advertised_modes); |
| ethtool_link_mode_set_bit(all_advertised_modes_bits[i], |
| all_advertised_flags); |
| } |
| |
| for (i = 0; i < ARRAY_SIZE(additional_advertised_flags_bits); ++i) { |
| ethtool_link_mode_set_bit( |
| additional_advertised_flags_bits[i], |
| all_advertised_flags); |
| } |
| } |
| |
| static void dump_link_caps(const char *prefix, const char *an_prefix, |
| const u32 *mask, int link_mode_only); |
| |
| static void dump_supported(const struct ethtool_link_usettings *link_usettings) |
| { |
| fprintf(stdout, " Supported ports: [ "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_TP_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "TP "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_AUI_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "AUI "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_BNC_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "BNC "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_MII_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "MII "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_FIBRE_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "FIBRE "); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_Backplane_BIT, |
| link_usettings->link_modes.supported)) |
| fprintf(stdout, "Backplane "); |
| fprintf(stdout, "]\n"); |
| |
| dump_link_caps("Supported", "Supports", |
| link_usettings->link_modes.supported, 0); |
| } |
| |
| /* Print link capability flags (supported, advertised or lp_advertised). |
| * Assumes that the corresponding SUPPORTED and ADVERTISED flags are equal. |
| */ |
| static void dump_link_caps(const char *prefix, const char *an_prefix, |
| const u32 *mask, int link_mode_only) |
| { |
| static const struct { |
| int same_line; /* print on same line as previous */ |
| unsigned int bit_index; |
| const char *name; |
| } mode_defs[] = { |
| { 0, ETHTOOL_LINK_MODE_10baseT_Half_BIT, |
| "10baseT/Half" }, |
| { 1, ETHTOOL_LINK_MODE_10baseT_Full_BIT, |
| "10baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100baseT_Half_BIT, |
| "100baseT/Half" }, |
| { 1, ETHTOOL_LINK_MODE_100baseT_Full_BIT, |
| "100baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100baseT1_Full_BIT, |
| "100baseT1/Full" }, |
| { 0, ETHTOOL_LINK_MODE_1000baseT_Half_BIT, |
| "1000baseT/Half" }, |
| { 1, ETHTOOL_LINK_MODE_1000baseT_Full_BIT, |
| "1000baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_1000baseT1_Full_BIT, |
| "1000baseT1/Full" }, |
| { 0, ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, |
| "1000baseKX/Full" }, |
| { 0, ETHTOOL_LINK_MODE_2500baseX_Full_BIT, |
| "2500baseX/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseT_Full_BIT, |
| "10000baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, |
| "10000baseKX4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, |
| "10000baseKR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseR_FEC_BIT, |
| "10000baseR_FEC" }, |
| { 0, ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT, |
| "20000baseMLD2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT, |
| "20000baseKR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, |
| "40000baseKR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, |
| "40000baseCR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, |
| "40000baseSR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, |
| "40000baseLR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT, |
| "56000baseKR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT, |
| "56000baseCR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT, |
| "56000baseSR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT, |
| "56000baseLR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, |
| "25000baseCR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, |
| "25000baseKR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, |
| "25000baseSR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT, |
| "50000baseCR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT, |
| "50000baseKR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, |
| "100000baseKR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, |
| "100000baseSR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, |
| "100000baseCR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT, |
| "100000baseLR4_ER4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT, |
| "50000baseSR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_1000baseX_Full_BIT, |
| "1000baseX/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseCR_Full_BIT, |
| "10000baseCR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, |
| "10000baseSR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, |
| "10000baseLR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT, |
| "10000baseLRM/Full" }, |
| { 0, ETHTOOL_LINK_MODE_10000baseER_Full_BIT, |
| "10000baseER/Full" }, |
| { 0, ETHTOOL_LINK_MODE_2500baseT_Full_BIT, |
| "2500baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_5000baseT_Full_BIT, |
| "5000baseT/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseKR_Full_BIT, |
| "50000baseKR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseSR_Full_BIT, |
| "50000baseSR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseCR_Full_BIT, |
| "50000baseCR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT, |
| "50000baseLR_ER_FR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_50000baseDR_Full_BIT, |
| "50000baseDR/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT, |
| "100000baseKR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT, |
| "100000baseSR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT, |
| "100000baseCR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT, |
| "100000baseLR2_ER2_FR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT, |
| "100000baseDR2/Full" }, |
| { 0, ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT, |
| "200000baseKR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT, |
| "200000baseSR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT, |
| "200000baseLR4_ER4_FR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT, |
| "200000baseDR4/Full" }, |
| { 0, ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT, |
| "200000baseCR4/Full" }, |
| }; |
| int indent; |
| int did1, new_line_pend, i; |
| int fecreported = 0; |
| |
| /* Indent just like the separate functions used to */ |
| indent = strlen(prefix) + 14; |
| if (indent < 24) |
| indent = 24; |
| |
| fprintf(stdout, " %s link modes:%*s", prefix, |
| indent - (int)strlen(prefix) - 12, ""); |
| did1 = 0; |
| new_line_pend = 0; |
| for (i = 0; i < ARRAY_SIZE(mode_defs); i++) { |
| if (did1 && !mode_defs[i].same_line) |
| new_line_pend = 1; |
| if (ethtool_link_mode_test_bit(mode_defs[i].bit_index, |
| mask)) { |
| if (new_line_pend) { |
| fprintf(stdout, "\n"); |
| fprintf(stdout, " %*s", indent, ""); |
| new_line_pend = 0; |
| } |
| did1++; |
| fprintf(stdout, "%s ", mode_defs[i].name); |
| } |
| } |
| if (did1 == 0) |
| fprintf(stdout, "Not reported"); |
| fprintf(stdout, "\n"); |
| |
| if (!link_mode_only) { |
| fprintf(stdout, " %s pause frame use: ", prefix); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_Pause_BIT, mask)) { |
| fprintf(stdout, "Symmetric"); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_Asym_Pause_BIT, mask)) |
| fprintf(stdout, " Receive-only"); |
| fprintf(stdout, "\n"); |
| } else { |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_Asym_Pause_BIT, mask)) |
| fprintf(stdout, "Transmit-only\n"); |
| else |
| fprintf(stdout, "No\n"); |
| } |
| |
| fprintf(stdout, " %s auto-negotiation: ", an_prefix); |
| if (ethtool_link_mode_test_bit( |
| ETHTOOL_LINK_MODE_Autoneg_BIT, mask)) |
| fprintf(stdout, "Yes\n"); |
| else |
| fprintf(stdout, "No\n"); |
| |
| fprintf(stdout, " %s FEC modes:", prefix); |
| if (ethtool_link_mode_test_bit(ETHTOOL_LINK_MODE_FEC_NONE_BIT, |
| mask)) { |
| fprintf(stdout, " None"); |
| fecreported = 1; |
| } |
| if (ethtool_link_mode_test_bit(ETHTOOL_LINK_MODE_FEC_BASER_BIT, |
| mask)) { |
| fprintf(stdout, " BaseR"); |
| fecreported = 1; |
| } |
| if (ethtool_link_mode_test_bit(ETHTOOL_LINK_MODE_FEC_RS_BIT, |
| mask)) { |
| fprintf(stdout, " RS"); |
| fecreported = 1; |
| } |
| if (!fecreported) |
| fprintf(stdout, " Not reported"); |
| fprintf(stdout, "\n"); |
| } |
| } |
| |
| static int |
| dump_link_usettings(const struct ethtool_link_usettings *link_usettings) |
| { |
| dump_supported(link_usettings); |
| dump_link_caps("Advertised", "Advertised", |
| link_usettings->link_modes.advertising, 0); |
| if (!ethtool_link_mode_is_empty( |
| link_usettings->link_modes.lp_advertising)) |
| dump_link_caps("Link partner advertised", |
| "Link partner advertised", |
| link_usettings->link_modes.lp_advertising, 0); |
| |
| fprintf(stdout, " Speed: "); |
| if (link_usettings->base.speed == 0 |
| || link_usettings->base.speed == (u16)(-1) |
| || link_usettings->base.speed == (u32)(-1)) |
| fprintf(stdout, "Unknown!\n"); |
| else |
| fprintf(stdout, "%uMb/s\n", link_usettings->base.speed); |
| |
| fprintf(stdout, " Duplex: "); |
| switch (link_usettings->base.duplex) { |
| case DUPLEX_HALF: |
| fprintf(stdout, "Half\n"); |
| break; |
| case DUPLEX_FULL: |
| fprintf(stdout, "Full\n"); |
| break; |
| default: |
| fprintf(stdout, "Unknown! (%i)\n", link_usettings->base.duplex); |
| break; |
| }; |
| |
| fprintf(stdout, " Port: "); |
| switch (link_usettings->base.port) { |
| case PORT_TP: |
| fprintf(stdout, "Twisted Pair\n"); |
| break; |
| case PORT_AUI: |
| fprintf(stdout, "AUI\n"); |
| break; |
| case PORT_BNC: |
| fprintf(stdout, "BNC\n"); |
| break; |
| case PORT_MII: |
| fprintf(stdout, "MII\n"); |
| break; |
| case PORT_FIBRE: |
| fprintf(stdout, "FIBRE\n"); |
| break; |
| case PORT_DA: |
| fprintf(stdout, "Direct Attach Copper\n"); |
| break; |
| case PORT_NONE: |
| fprintf(stdout, "None\n"); |
| break; |
| case PORT_OTHER: |
| fprintf(stdout, "Other\n"); |
| break; |
| default: |
| fprintf(stdout, "Unknown! (%i)\n", link_usettings->base.port); |
| break; |
| }; |
| |
| fprintf(stdout, " PHYAD: %d\n", link_usettings->base.phy_address); |
| fprintf(stdout, " Transceiver: "); |
| switch (link_usettings->deprecated.transceiver) { |
| case XCVR_INTERNAL: |
| fprintf(stdout, "internal\n"); |
| break; |
| case XCVR_EXTERNAL: |
| fprintf(stdout, "external\n"); |
| break; |
| default: |
| fprintf(stdout, "Unknown!\n"); |
| break; |
| }; |
| |
| fprintf(stdout, " Auto-negotiation: %s\n", |
| (link_usettings->base.autoneg == AUTONEG_DISABLE) ? |
| "off" : "on"); |
| |
| if (link_usettings->base.port == PORT_TP) { |
| fprintf(stdout, " MDI-X: "); |
| if (link_usettings->base.eth_tp_mdix_ctrl == ETH_TP_MDI) { |
| fprintf(stdout, "off (forced)\n"); |
| } else if (link_usettings->base.eth_tp_mdix_ctrl |
| == ETH_TP_MDI_X) { |
| fprintf(stdout, "on (forced)\n"); |
| } else { |
| switch (link_usettings->base.eth_tp_mdix) { |
| case ETH_TP_MDI: |
| fprintf(stdout, "off"); |
| break; |
| case ETH_TP_MDI_X: |
| fprintf(stdout, "on"); |
| break; |
| default: |
| fprintf(stdout, "Unknown"); |
| break; |
| } |
| if (link_usettings->base.eth_tp_mdix_ctrl |
| == ETH_TP_MDI_AUTO) |
| fprintf(stdout, " (auto)"); |
| fprintf(stdout, "\n"); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int dump_drvinfo(struct ethtool_drvinfo *info) |
| { |
| fprintf(stdout, |
| "driver: %.*s\n" |
| "version: %.*s\n" |
| "firmware-version: %.*s\n" |
| "expansion-rom-version: %.*s\n" |
| "bus-info: %.*s\n" |
| "supports-statistics: %s\n" |
| "supports-test: %s\n" |
| "supports-eeprom-access: %s\n" |
| "supports-register-dump: %s\n" |
| "supports-priv-flags: %s\n", |
| (int)sizeof(info->driver), info->driver, |
| (int)sizeof(info->version), info->version, |
| (int)sizeof(info->fw_version), info->fw_version, |
| (int)sizeof(info->erom_version), info->erom_version, |
| (int)sizeof(info->bus_info), info->bus_info, |
| info->n_stats ? "yes" : "no", |
| info->testinfo_len ? "yes" : "no", |
| info->eedump_len ? "yes" : "no", |
| info->regdump_len ? "yes" : "no", |
| info->n_priv_flags ? "yes" : "no"); |
| |
| return 0; |
| } |
| |
| static int parse_wolopts(char *optstr, u32 *data) |
| { |
| *data = 0; |
| while (*optstr) { |
| switch (*optstr) { |
| case 'p': |
| *data |= WAKE_PHY; |
| break; |
| case 'u': |
| *data |= WAKE_UCAST; |
| break; |
| case 'm': |
| *data |= WAKE_MCAST; |
| break; |
| case 'b': |
| *data |= WAKE_BCAST; |
| break; |
| case 'a': |
| *data |= WAKE_ARP; |
| break; |
| case 'g': |
| *data |= WAKE_MAGIC; |
| break; |
| case 's': |
| *data |= WAKE_MAGICSECURE; |
| break; |
| case 'f': |
| *data |= WAKE_FILTER; |
| break; |
| case 'd': |
| *data = 0; |
| break; |
| default: |
| return -1; |
| } |
| optstr++; |
| } |
| return 0; |
| } |
| |
| static char *unparse_wolopts(int wolopts) |
| { |
| static char buf[16]; |
| char *p = buf; |
| |
| memset(buf, 0, sizeof(buf)); |
| |
| if (wolopts) { |
| if (wolopts & WAKE_PHY) |
| *p++ = 'p'; |
| if (wolopts & WAKE_UCAST) |
| *p++ = 'u'; |
| if (wolopts & WAKE_MCAST) |
| *p++ = 'm'; |
| if (wolopts & WAKE_BCAST) |
| *p++ = 'b'; |
| if (wolopts & WAKE_ARP) |
| *p++ = 'a'; |
| if (wolopts & WAKE_MAGIC) |
| *p++ = 'g'; |
| if (wolopts & WAKE_MAGICSECURE) |
| *p++ = 's'; |
| if (wolopts & WAKE_FILTER) |
| *p++ = 'f'; |
| } else { |
| *p = 'd'; |
| } |
| |
| return buf; |
| } |
| |
| static int dump_wol(struct ethtool_wolinfo *wol) |
| { |
| fprintf(stdout, " Supports Wake-on: %s\n", |
| unparse_wolopts(wol->supported)); |
| fprintf(stdout, " Wake-on: %s\n", |
| unparse_wolopts(wol->wolopts)); |
| if (wol->supported & WAKE_MAGICSECURE) { |
| int i; |
| int delim = 0; |
| |
| fprintf(stdout, " SecureOn password: "); |
| for (i = 0; i < SOPASS_MAX; i++) { |
| fprintf(stdout, "%s%02x", delim?":":"", wol->sopass[i]); |
| delim = 1; |
| } |
| fprintf(stdout, "\n"); |
| } |
| |
| return 0; |
| } |
| |
| static int parse_rxfhashopts(char *optstr, u32 *data) |
| { |
| *data = 0; |
| while (*optstr) { |
| switch (*optstr) { |
| case 'm': |
| *data |= RXH_L2DA; |
| break; |
| case 'v': |
| *data |= RXH_VLAN; |
| break; |
| case 't': |
| *data |= RXH_L3_PROTO; |
| break; |
| case 's': |
| *data |= RXH_IP_SRC; |
| break; |
| case 'd': |
| *data |= RXH_IP_DST; |
| break; |
| case 'f': |
| *data |= RXH_L4_B_0_1; |
| break; |
| case 'n': |
| *data |= RXH_L4_B_2_3; |
| break; |
| case 'r': |
| *data |= RXH_DISCARD; |
| break; |
| default: |
| return -1; |
| } |
| optstr++; |
| } |
| return 0; |
| } |
| |
| static char *unparse_rxfhashopts(u64 opts) |
| { |
| static char buf[300]; |
| |
| memset(buf, 0, sizeof(buf)); |
| |
| if (opts) { |
| if (opts & RXH_L2DA) |
| strcat(buf, "L2DA\n"); |
| if (opts & RXH_VLAN) |
| strcat(buf, "VLAN tag\n"); |
| if (opts & RXH_L3_PROTO) |
| strcat(buf, "L3 proto\n"); |
| if (opts & RXH_IP_SRC) |
| strcat(buf, "IP SA\n"); |
| if (opts & RXH_IP_DST) |
| strcat(buf, "IP DA\n"); |
| if (opts & RXH_L4_B_0_1) |
| strcat(buf, "L4 bytes 0 & 1 [TCP/UDP src port]\n"); |
| if (opts & RXH_L4_B_2_3) |
| strcat(buf, "L4 bytes 2 & 3 [TCP/UDP dst port]\n"); |
| } else { |
| sprintf(buf, "None"); |
| } |
| |
| return buf; |
| } |
| |
| static int convert_string_to_hashkey(char *rss_hkey, u32 key_size, |
| const char *rss_hkey_string) |
| { |
| u32 i = 0; |
| int hex_byte, len; |
| |
| do { |
| if (i > (key_size - 1)) { |
| fprintf(stderr, |
| "Key is too long for device (%u > %u)\n", |
| i + 1, key_size); |
| goto err; |
| } |
| |
| if (sscanf(rss_hkey_string, "%2x%n", &hex_byte, &len) < 1 || |
| len != 2) { |
| fprintf(stderr, "Invalid RSS hash key format\n"); |
| goto err; |
| } |
| |
| rss_hkey[i++] = hex_byte; |
| rss_hkey_string += 2; |
| |
| if (*rss_hkey_string == ':') { |
| rss_hkey_string++; |
| } else if (*rss_hkey_string != '\0') { |
| fprintf(stderr, "Invalid RSS hash key format\n"); |
| goto err; |
| } |
| |
| } while (*rss_hkey_string); |
| |
| if (i != key_size) { |
| fprintf(stderr, "Key is too short for device (%u < %u)\n", |
| i, key_size); |
| goto err; |
| } |
| |
| return 0; |
| err: |
| return 2; |
| } |
| |
| static int parse_hkey(char **rss_hkey, u32 key_size, |
| const char *rss_hkey_string) |
| { |
| if (!key_size) { |
| fprintf(stderr, |
| "Cannot set RX flow hash configuration:\n" |
| " Hash key setting not supported\n"); |
| return 1; |
| } |
| |
| *rss_hkey = malloc(key_size); |
| if (!(*rss_hkey)) { |
| perror("Cannot allocate memory for RSS hash key"); |
| return 1; |
| } |
| |
| if (convert_string_to_hashkey(*rss_hkey, key_size, |
| rss_hkey_string)) { |
| free(*rss_hkey); |
| *rss_hkey = NULL; |
| return 2; |
| } |
| return 0; |
| } |
| |
| static const struct { |
| const char *name; |
| int (*func)(struct ethtool_drvinfo *info, struct ethtool_regs *regs); |
| |
| } driver_list[] = { |
| #ifdef ETHTOOL_ENABLE_PRETTY_DUMP |
| { "8139cp", realtek_dump_regs }, |
| { "8139too", realtek_dump_regs }, |
| { "r8169", realtek_dump_regs }, |
| { "de2104x", de2104x_dump_regs }, |
| { "e1000", e1000_dump_regs }, |
| { "e1000e", e1000_dump_regs }, |
| { "igb", igb_dump_regs }, |
| { "ixgb", ixgb_dump_regs }, |
| { "ixgbe", ixgbe_dump_regs }, |
| { "ixgbevf", ixgbevf_dump_regs }, |
| { "natsemi", natsemi_dump_regs }, |
| { "e100", e100_dump_regs }, |
| { "amd8111e", amd8111e_dump_regs }, |
| { "pcnet32", pcnet32_dump_regs }, |
| { "fec_8xx", fec_8xx_dump_regs }, |
| { "ibm_emac", ibm_emac_dump_regs }, |
| { "tg3", tg3_dump_regs }, |
| { "skge", skge_dump_regs }, |
| { "sky2", sky2_dump_regs }, |
| { "vioc", vioc_dump_regs }, |
| { "smsc911x", smsc911x_dump_regs }, |
| { "at76c50x-usb", at76c50x_usb_dump_regs }, |
| { "sfc", sfc_dump_regs }, |
| { "st_mac100", st_mac100_dump_regs }, |
| { "st_gmac", st_gmac_dump_regs }, |
| { "et131x", et131x_dump_regs }, |
| { "altera_tse", altera_tse_dump_regs }, |
| { "vmxnet3", vmxnet3_dump_regs }, |
| { "fjes", fjes_dump_regs }, |
| { "lan78xx", lan78xx_dump_regs }, |
| { "dsa", dsa_dump_regs }, |
| { "fec", fec_dump_regs }, |
| #endif |
| }; |
| |
| void dump_hex(FILE *file, const u8 *data, int len, int offset) |
| { |
| int i; |
| |
| fprintf(file, "Offset\t\tValues\n"); |
| fprintf(file, "------\t\t------"); |
| for (i = 0; i < len; i++) { |
| if (i % 16 == 0) |
| fprintf(file, "\n0x%04x:\t\t", i + offset); |
| fprintf(file, "%02x ", data[i]); |
| } |
| fprintf(file, "\n"); |
| } |
| |
| static int dump_regs(int gregs_dump_raw, int gregs_dump_hex, |
| struct ethtool_drvinfo *info, struct ethtool_regs *regs) |
| { |
| int i; |
| |
| if (gregs_dump_raw) { |
| fwrite(regs->data, regs->len, 1, stdout); |
| goto nested; |
| } |
| |
| if (!gregs_dump_hex) |
| for (i = 0; i < ARRAY_SIZE(driver_list); i++) |
| if (!strncmp(driver_list[i].name, info->driver, |
| ETHTOOL_BUSINFO_LEN)) { |
| if (driver_list[i].func(info, regs) == 0) |
| goto nested; |
| /* This version (or some other |
| * variation in the dump format) is |
| * not handled; fall back to hex |
| */ |
| break; |
| } |
| |
| dump_hex(stdout, regs->data, regs->len, 0); |
| |
| nested: |
| /* Recurse dump if some drvinfo and regs structures are nested */ |
| if (info->regdump_len > regs->len + sizeof(*info) + sizeof(*regs)) { |
| info = (struct ethtool_drvinfo *)(®s->data[0] + regs->len); |
| regs = (struct ethtool_regs *)(®s->data[0] + regs->len + sizeof(*info)); |
| |
| return dump_regs(gregs_dump_raw, gregs_dump_hex, info, regs); |
| } |
| |
| return 0; |
| } |
| |
| static int dump_eeprom(int geeprom_dump_raw, |
| struct ethtool_drvinfo *info maybe_unused, |
| struct ethtool_eeprom *ee) |
| { |
| if (geeprom_dump_raw) { |
| fwrite(ee->data, 1, ee->len, stdout); |
| return 0; |
| } |
| #ifdef ETHTOOL_ENABLE_PRETTY_DUMP |
| if (!strncmp("natsemi", info->driver, ETHTOOL_BUSINFO_LEN)) { |
| return natsemi_dump_eeprom(info, ee); |
| } else if (!strncmp("tg3", info->driver, ETHTOOL_BUSINFO_LEN)) { |
| return tg3_dump_eeprom(info, ee); |
| } |
| #endif |
| dump_hex(stdout, ee->data, ee->len, ee->offset); |
| |
| return 0; |
| } |
| |
| static int dump_test(struct ethtool_test *test, |
| struct ethtool_gstrings *strings) |
| { |
| int i, rc; |
| |
| rc = test->flags & ETH_TEST_FL_FAILED; |
| fprintf(stdout, "The test result is %s\n", rc ? "FAIL" : "PASS"); |
| |
| if (test->flags & ETH_TEST_FL_EXTERNAL_LB) |
| fprintf(stdout, "External loopback test was %sexecuted\n", |
| (test->flags & ETH_TEST_FL_EXTERNAL_LB_DONE) ? |
| "" : "not "); |
| |
| if (strings->len) |
| fprintf(stdout, "The test extra info:\n"); |
| |
| for (i = 0; i < strings->len; i++) { |
| fprintf(stdout, "%s\t %d\n", |
| (char *)(strings->data + i * ETH_GSTRING_LEN), |
| (u32) test->data[i]); |
| } |
| |
| fprintf(stdout, "\n"); |
| return rc; |
| } |
| |
| static int dump_pause(const struct ethtool_pauseparam *epause, |
| u32 advertising, u32 lp_advertising) |
| { |
| fprintf(stdout, |
| "Autonegotiate: %s\n" |
| "RX: %s\n" |
| "TX: %s\n", |
| epause->autoneg ? "on" : "off", |
| epause->rx_pause ? "on" : "off", |
| epause->tx_pause ? "on" : "off"); |
| |
| if (lp_advertising) { |
| int an_rx = 0, an_tx = 0; |
| |
| /* Work out negotiated pause frame usage per |
| * IEEE 802.3-2005 table 28B-3. |
| */ |
| if (advertising & lp_advertising & ADVERTISED_Pause) { |
| an_tx = 1; |
| an_rx = 1; |
| } else if (advertising & lp_advertising & |
| ADVERTISED_Asym_Pause) { |
| if (advertising & ADVERTISED_Pause) |
| an_rx = 1; |
| else if (lp_advertising & ADVERTISED_Pause) |
| an_tx = 1; |
| } |
| |
| fprintf(stdout, |
| "RX negotiated: %s\n" |
| "TX negotiated: %s\n", |
| an_rx ? "on" : "off", |
| an_tx ? "on" : "off"); |
| } |
| |
| fprintf(stdout, "\n"); |
| return 0; |
| } |
| |
| static int dump_ring(const struct ethtool_ringparam *ering) |
| { |
| fprintf(stdout, |
| "Pre-set maximums:\n" |
| "RX: %u\n" |
| "RX Mini: %u\n" |
| "RX Jumbo: %u\n" |
| "TX: %u\n", |
| ering->rx_max_pending, |
| ering->rx_mini_max_pending, |
| ering->rx_jumbo_max_pending, |
| ering->tx_max_pending); |
| |
| fprintf(stdout, |
| "Current hardware settings:\n" |
| "RX: %u\n" |
| "RX Mini: %u\n" |
| "RX Jumbo: %u\n" |
| "TX: %u\n", |
| ering->rx_pending, |
| ering->rx_mini_pending, |
| ering->rx_jumbo_pending, |
| ering->tx_pending); |
| |
| fprintf(stdout, "\n"); |
| return 0; |
| } |
| |
| static int dump_channels(const struct ethtool_channels *echannels) |
| { |
| fprintf(stdout, |
| "Pre-set maximums:\n" |
| "RX: %u\n" |
| "TX: %u\n" |
| "Other: %u\n" |
| "Combined: %u\n", |
| echannels->max_rx, echannels->max_tx, |
| echannels->max_other, |
| echannels->max_combined); |
| |
| fprintf(stdout, |
| "Current hardware settings:\n" |
| "RX: %u\n" |
| "TX: %u\n" |
| "Other: %u\n" |
| "Combined: %u\n", |
| echannels->rx_count, echannels->tx_count, |
| echannels->other_count, |
| echannels->combined_count); |
| |
| fprintf(stdout, "\n"); |
| return 0; |
| } |
| |
| static int dump_coalesce(const struct ethtool_coalesce *ecoal) |
| { |
| fprintf(stdout, "Adaptive RX: %s TX: %s\n", |
| ecoal->use_adaptive_rx_coalesce ? "on" : "off", |
| ecoal->use_adaptive_tx_coalesce ? "on" : "off"); |
| |
| fprintf(stdout, |
| "stats-block-usecs: %u\n" |
| "sample-interval: %u\n" |
| "pkt-rate-low: %u\n" |
| "pkt-rate-high: %u\n" |
| "\n" |
| "rx-usecs: %u\n" |
| "rx-frames: %u\n" |
| "rx-usecs-irq: %u\n" |
| "rx-frames-irq: %u\n" |
| "\n" |
| "tx-usecs: %u\n" |
| "tx-frames: %u\n" |
| "tx-usecs-irq: %u\n" |
| "tx-frames-irq: %u\n" |
| "\n" |
| "rx-usecs-low: %u\n" |
| "rx-frames-low: %u\n" |
| "tx-usecs-low: %u\n" |
| "tx-frames-low: %u\n" |
| "\n" |
| "rx-usecs-high: %u\n" |
| "rx-frames-high: %u\n" |
| "tx-usecs-high: %u\n" |
| "tx-frames-high: %u\n" |
| "\n", |
| ecoal->stats_block_coalesce_usecs, |
| ecoal->rate_sample_interval, |
| ecoal->pkt_rate_low, |
| ecoal->pkt_rate_high, |
| |
| ecoal->rx_coalesce_usecs, |
| ecoal->rx_max_coalesced_frames, |
| ecoal->rx_coalesce_usecs_irq, |
| ecoal->rx_max_coalesced_frames_irq, |
| |
| ecoal->tx_coalesce_usecs, |
| ecoal->tx_max_coalesced_frames, |
| ecoal->tx_coalesce_usecs_irq, |
| ecoal->tx_max_coalesced_frames_irq, |
| |
| ecoal->rx_coalesce_usecs_low, |
| ecoal->rx_max_coalesced_frames_low, |
| ecoal->tx_coalesce_usecs_low, |
| ecoal->tx_max_coalesced_frames_low, |
| |
| ecoal->rx_coalesce_usecs_high, |
| ecoal->rx_max_coalesced_frames_high, |
| ecoal->tx_coalesce_usecs_high, |
| ecoal->tx_max_coalesced_frames_high); |
| |
| return 0; |
| } |
| |
| void dump_per_queue_coalesce(struct ethtool_per_queue_op *per_queue_opt, |
| __u32 *queue_mask, int n_queues) |
| { |
| struct ethtool_coalesce *ecoal; |
| int i, idx = 0; |
| |
| ecoal = (struct ethtool_coalesce *)(per_queue_opt + 1); |
| for (i = 0; i < __KERNEL_DIV_ROUND_UP(MAX_NUM_QUEUE, 32); i++) { |
| int queue = i * 32; |
| __u32 mask = queue_mask[i]; |
| |
| while (mask > 0) { |
| if (mask & 0x1) { |
| fprintf(stdout, "Queue: %d\n", queue); |
| dump_coalesce(ecoal + idx); |
| idx++; |
| } |
| mask = mask >> 1; |
| queue++; |
| } |
| if (idx == n_queues) |
| break; |
| } |
| } |
| |
| struct feature_state { |
| u32 off_flags; |
| struct ethtool_gfeatures features; |
| }; |
| |
| static void dump_one_feature(const char *indent, const char *name, |
| const struct feature_state *state, |
| const struct feature_state *ref_state, |
| u32 index) |
| { |
| if (ref_state && |
| !(FEATURE_BIT_IS_SET(state->features.features, index, active) ^ |
| FEATURE_BIT_IS_SET(ref_state->features.features, index, active))) |
| return; |
| |
| printf("%s%s: %s%s\n", |
| indent, name, |
| FEATURE_BIT_IS_SET(state->features.features, index, active) ? |
| "on" : "off", |
| (!FEATURE_BIT_IS_SET(state->features.features, index, available) |
| || FEATURE_BIT_IS_SET(state->features.features, index, |
| never_changed)) |
| ? " [fixed]" |
| : (FEATURE_BIT_IS_SET(state->features.features, index, requested) |
| ^ FEATURE_BIT_IS_SET(state->features.features, index, active)) |
| ? (FEATURE_BIT_IS_SET(state->features.features, index, requested) |
| ? " [requested on]" : " [requested off]") |
| : ""); |
| } |
| |
| static int linux_version_code(void) |
| { |
| struct utsname utsname; |
| unsigned version, patchlevel, sublevel = 0; |
| |
| if (uname(&utsname)) |
| return -1; |
| if (sscanf(utsname.release, "%u.%u.%u", &version, &patchlevel, &sublevel) < 2) |
| return -1; |
| return KERNEL_VERSION(version, patchlevel, sublevel); |
| } |
| |
| static void dump_features(const struct feature_defs *defs, |
| const struct feature_state *state, |
| const struct feature_state *ref_state) |
| { |
| int kernel_ver = linux_version_code(); |
| u32 value; |
| int indent; |
| int i, j; |
| |
| for (i = 0; i < ARRAY_SIZE(off_flag_def); i++) { |
| /* Don't show features whose state is unknown on this |
| * kernel version |
| */ |
| if (defs->off_flag_matched[i] == 0 && |
| ((off_flag_def[i].get_cmd == 0 && |
| kernel_ver < off_flag_def[i].min_kernel_ver) || |
| (off_flag_def[i].get_cmd == ETHTOOL_GUFO && |
| kernel_ver >= KERNEL_VERSION(4, 14, 0)))) |
| continue; |
| |
| value = off_flag_def[i].value; |
| |
| /* If this offload flag matches exactly one generic |
| * feature then it's redundant to show the flag and |
| * feature states separately. Otherwise, show the |
| * flag state first. |
| */ |
| if (defs->off_flag_matched[i] != 1 && |
| (!ref_state || |
| (state->off_flags ^ ref_state->off_flags) & value)) { |
| printf("%s: %s\n", |
| off_flag_def[i].long_name, |
| (state->off_flags & value) ? "on" : "off"); |
| indent = 1; |
| } else { |
| indent = 0; |
| } |
| |
| /* Show matching features */ |
| for (j = 0; j < defs->n_features; j++) { |
| if (defs->def[j].off_flag_index != i) |
| continue; |
| if (defs->off_flag_matched[i] != 1) |
| /* Show all matching feature states */ |
| dump_one_feature(indent ? "\t" : "", |
| defs->def[j].name, |
| state, ref_state, j); |
| else |
| /* Show full state with the old flag name */ |
| dump_one_feature("", off_flag_def[i].long_name, |
| state, ref_state, j); |
| } |
| } |
| |
| /* Show all unmatched features that have non-null names */ |
| for (j = 0; j < defs->n_features; j++) |
| if (defs->def[j].off_flag_index < 0 && defs->def[j].name[0]) |
| dump_one_feature("", defs->def[j].name, |
| state, ref_state, j); |
| } |
| |
| static int dump_rxfhash(int fhash, u64 val) |
| { |
| switch (fhash & ~FLOW_RSS) { |
| case TCP_V4_FLOW: |
| fprintf(stdout, "TCP over IPV4 flows"); |
| break; |
| case UDP_V4_FLOW: |
| fprintf(stdout, "UDP over IPV4 flows"); |
| break; |
| case SCTP_V4_FLOW: |
| fprintf(stdout, "SCTP over IPV4 flows"); |
| break; |
| case AH_ESP_V4_FLOW: |
| case AH_V4_FLOW: |
| case ESP_V4_FLOW: |
| fprintf(stdout, "IPSEC AH/ESP over IPV4 flows"); |
| break; |
| case TCP_V6_FLOW: |
| fprintf(stdout, "TCP over IPV6 flows"); |
| break; |
| case UDP_V6_FLOW: |
| fprintf(stdout, "UDP over IPV6 flows"); |
| break; |
| case SCTP_V6_FLOW: |
| fprintf(stdout, "SCTP over IPV6 flows"); |
| break; |
| case AH_ESP_V6_FLOW: |
| case AH_V6_FLOW: |
| case ESP_V6_FLOW: |
| fprintf(stdout, "IPSEC AH/ESP over IPV6 flows"); |
| break; |
| default: |
| break; |
| } |
| |
| if (val & RXH_DISCARD) { |
| fprintf(stdout, " - All matching flows discarded on RX\n"); |
| return 0; |
| } |
| fprintf(stdout, " use these fields for computing Hash flow key:\n"); |
| |
| fprintf(stdout, "%s\n", unparse_rxfhashopts(val)); |
| |
| return 0; |
| } |
| |
| static void dump_eeecmd(struct ethtool_eee *ep) |
| { |
| ETHTOOL_DECLARE_LINK_MODE_MASK(link_mode); |
| |
| fprintf(stdout, " EEE status: "); |
| if (!ep->supported) { |
| fprintf(stdout, "not supported\n"); |
| return; |
| } else if (!ep->eee_enabled) { |
| fprintf(stdout, "disabled\n"); |
| } else { |
| fprintf(stdout, "enabled - "); |
| if (ep->eee_active) |
| fprintf(stdout, "active\n"); |
| else |
| fprintf(stdout, "inactive\n"); |
| } |
| |
| fprintf(stdout, " Tx LPI:"); |
| if (ep->tx_lpi_enabled) |
| fprintf(stdout, " %d (us)\n", ep->tx_lpi_timer); |
| else |
| fprintf(stdout, " disabled\n"); |
| |
| ethtool_link_mode_zero(link_mode); |
| |
| link_mode[0] = ep->supported; |
| dump_link_caps("Supported EEE", "", link_mode, 1); |
| |
| link_mode[0] = ep->advertised; |
| dump_link_caps("Advertised EEE", "", link_mode, 1); |
| |
| link_mode[0] = ep->lp_advertised; |
| dump_link_caps("Link partner advertised EEE", "", link_mode, 1); |
| } |
| |
| static void dump_fec(u32 fec) |
| { |
| if (fec & ETHTOOL_FEC_NONE) |
| fprintf(stdout, " None"); |
| if (fec & ETHTOOL_FEC_AUTO) |
| fprintf(stdout, " Auto"); |
| if (fec & ETHTOOL_FEC_OFF) |
| fprintf(stdout, " Off"); |
| if (fec & ETHTOOL_FEC_BASER) |
| fprintf(stdout, " BaseR"); |
| if (fec & ETHTOOL_FEC_RS) |
| fprintf(stdout, " RS"); |
| } |
| |
| #define N_SOTS 7 |
| |
| static char *so_timestamping_labels[N_SOTS] = { |
| "hardware-transmit (SOF_TIMESTAMPING_TX_HARDWARE)", |
| "software-transmit (SOF_TIMESTAMPING_TX_SOFTWARE)", |
| "hardware-receive (SOF_TIMESTAMPING_RX_HARDWARE)", |
| "software-receive (SOF_TIMESTAMPING_RX_SOFTWARE)", |
| "software-system-clock (SOF_TIMESTAMPING_SOFTWARE)", |
| "hardware-legacy-clock (SOF_TIMESTAMPING_SYS_HARDWARE)", |
| "hardware-raw-clock (SOF_TIMESTAMPING_RAW_HARDWARE)", |
| }; |
| |
| #define N_TX_TYPES (HWTSTAMP_TX_ONESTEP_SYNC + 1) |
| |
| static char *tx_type_labels[N_TX_TYPES] = { |
| "off (HWTSTAMP_TX_OFF)", |
| "on (HWTSTAMP_TX_ON)", |
| "one-step-sync (HWTSTAMP_TX_ONESTEP_SYNC)", |
| }; |
| |
| #define N_RX_FILTERS (HWTSTAMP_FILTER_NTP_ALL + 1) |
| |
| static char *rx_filter_labels[N_RX_FILTERS] = { |
| "none (HWTSTAMP_FILTER_NONE)", |
| "all (HWTSTAMP_FILTER_ALL)", |
| "some (HWTSTAMP_FILTER_SOME)", |
| "ptpv1-l4-event (HWTSTAMP_FILTER_PTP_V1_L4_EVENT)", |
| "ptpv1-l4-sync (HWTSTAMP_FILTER_PTP_V1_L4_SYNC)", |
| "ptpv1-l4-delay-req (HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ)", |
| "ptpv2-l4-event (HWTSTAMP_FILTER_PTP_V2_L4_EVENT)", |
| "ptpv2-l4-sync (HWTSTAMP_FILTER_PTP_V2_L4_SYNC)", |
| "ptpv2-l4-delay-req (HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ)", |
| "ptpv2-l2-event (HWTSTAMP_FILTER_PTP_V2_L2_EVENT)", |
| "ptpv2-l2-sync (HWTSTAMP_FILTER_PTP_V2_L2_SYNC)", |
| "ptpv2-l2-delay-req (HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ)", |
| "ptpv2-event (HWTSTAMP_FILTER_PTP_V2_EVENT)", |
| "ptpv2-sync (HWTSTAMP_FILTER_PTP_V2_SYNC)", |
| "ptpv2-delay-req (HWTSTAMP_FILTER_PTP_V2_DELAY_REQ)", |
| "ntp-all (HWTSTAMP_FILTER_NTP_ALL)", |
| }; |
| |
| static int dump_tsinfo(const struct ethtool_ts_info *info) |
| { |
| int i; |
| |
| fprintf(stdout, "Capabilities:\n"); |
| |
| for (i = 0; i < N_SOTS; i++) { |
| if (info->so_timestamping & (1 << i)) |
| fprintf(stdout, "\t%s\n", so_timestamping_labels[i]); |
| } |
| |
| fprintf(stdout, "PTP Hardware Clock: "); |
| |
| if (info->phc_index < 0) |
| fprintf(stdout, "none\n"); |
| else |
| fprintf(stdout, "%d\n", info->phc_index); |
| |
| fprintf(stdout, "Hardware Transmit Timestamp Modes:"); |
| |
| if (!info->tx_types) |
| fprintf(stdout, " none\n"); |
| else |
| fprintf(stdout, "\n"); |
| |
| for (i = 0; i < N_TX_TYPES; i++) { |
| if (info->tx_types & (1 << i)) |
| fprintf(stdout, "\t%s\n", tx_type_labels[i]); |
| } |
| |
| fprintf(stdout, "Hardware Receive Filter Modes:"); |
| |
| if (!info->rx_filters) |
| fprintf(stdout, " none\n"); |
| else |
| fprintf(stdout, "\n"); |
| |
| for (i = 0; i < N_RX_FILTERS; i++) { |
| if (info->rx_filters & (1 << i)) |
| fprintf(stdout, "\t%s\n", rx_filter_labels[i]); |
| } |
| |
| return 0; |
| } |
| |
| static struct ethtool_gstrings * |
| get_stringset(struct cmd_context *ctx, enum ethtool_stringset set_id, |
| ptrdiff_t drvinfo_offset, int null_terminate) |
| { |
| struct { |
| struct ethtool_sset_info hdr; |
| u32 buf[1]; |
| } sset_info; |
| struct ethtool_drvinfo drvinfo; |
| u32 len, i; |
| struct ethtool_gstrings *strings; |
| |
| sset_info.hdr.cmd = ETHTOOL_GSSET_INFO; |
| sset_info.hdr.reserved = 0; |
| sset_info.hdr.sset_mask = 1ULL << set_id; |
| if (send_ioctl(ctx, &sset_info) == 0) { |
| len = sset_info.hdr.sset_mask ? sset_info.hdr.data[0] : 0; |
| } else if (errno == EOPNOTSUPP && drvinfo_offset != 0) { |
| /* Fallback for old kernel versions */ |
| drvinfo.cmd = ETHTOOL_GDRVINFO; |
| if (send_ioctl(ctx, &drvinfo)) |
| return NULL; |
| len = *(u32 *)((char *)&drvinfo + drvinfo_offset); |
| } else { |
| return NULL; |
| } |
| |
| strings = calloc(1, sizeof(*strings) + len * ETH_GSTRING_LEN); |
| if (!strings) |
| return NULL; |
| |
| strings->cmd = ETHTOOL_GSTRINGS; |
| strings->string_set = set_id; |
| strings->len = len; |
| if (len != 0 && send_ioctl(ctx, strings)) { |
| free(strings); |
| return NULL; |
| } |
| |
| if (null_terminate) |
| for (i = 0; i < len; i++) |
| strings->data[(i + 1) * ETH_GSTRING_LEN - 1] = 0; |
| |
| return strings; |
| } |
| |
| static struct feature_defs *get_feature_defs(struct cmd_context *ctx) |
| { |
| struct ethtool_gstrings *names; |
| struct feature_defs *defs; |
| u32 n_features; |
| int i, j; |
| |
| names = get_stringset(ctx, ETH_SS_FEATURES, 0, 1); |
| if (names) { |
| n_features = names->len; |
| } else if (errno == EOPNOTSUPP || errno == EINVAL) { |
| /* Kernel doesn't support named features; not an error */ |
| n_features = 0; |
| } else if (errno == EPERM) { |
| /* Kernel bug: ETHTOOL_GSSET_INFO was privileged. |
| * Work around it. */ |
| n_features = 0; |
| } else { |
| return NULL; |
| } |
| |
| defs = malloc(sizeof(*defs) + sizeof(defs->def[0]) * n_features); |
| if (!defs) { |
| free(names); |
| return NULL; |
| } |
| |
| defs->n_features = n_features; |
| memset(defs->off_flag_matched, 0, sizeof(defs->off_flag_matched)); |
| |
| /* Copy out feature names and find those associated with legacy flags */ |
| for (i = 0; i < defs->n_features; i++) { |
| memcpy(defs->def[i].name, names->data + i * ETH_GSTRING_LEN, |
| ETH_GSTRING_LEN); |
| defs->def[i].off_flag_index = -1; |
| |
| for (j = 0; |
| j < ARRAY_SIZE(off_flag_def) && |
| defs->def[i].off_flag_index < 0; |
| j++) { |
| const char *pattern = |
| off_flag_def[j].kernel_name; |
| const char *name = defs->def[i].name; |
| for (;;) { |
| if (*pattern == '*') { |
| /* There is only one wildcard; so |
| * switch to a suffix comparison */ |
| size_t pattern_len = |
| strlen(pattern + 1); |
| size_t name_len = strlen(name); |
| if (name_len < pattern_len) |
| break; /* name is too short */ |
| name += name_len - pattern_len; |
| ++pattern; |
| } else if (*pattern != *name) { |
| break; /* mismatch */ |
| } else if (*pattern == 0) { |
| defs->def[i].off_flag_index = j; |
| defs->off_flag_matched[j]++; |
| break; |
| } else { |
| ++name; |
| ++pattern; |
| } |
| } |
| } |
| } |
| |
| free(names); |
| return defs; |
| } |
| |
| static int do_gdrv(struct cmd_context *ctx) |
| { |
| int err; |
| struct ethtool_drvinfo drvinfo; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| drvinfo.cmd = ETHTOOL_GDRVINFO; |
| err = send_ioctl(ctx, &drvinfo); |
| if (err < 0) { |
| perror("Cannot get driver information"); |
| return 71; |
| } |
| return dump_drvinfo(&drvinfo); |
| } |
| |
| static int do_gpause(struct cmd_context *ctx) |
| { |
| struct ethtool_pauseparam epause; |
| struct ethtool_cmd ecmd; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Pause parameters for %s:\n", ctx->devname); |
| |
| epause.cmd = ETHTOOL_GPAUSEPARAM; |
| err = send_ioctl(ctx, &epause); |
| if (err) { |
| perror("Cannot get device pause settings"); |
| return 76; |
| } |
| |
| if (epause.autoneg) { |
| ecmd.cmd = ETHTOOL_GSET; |
| err = send_ioctl(ctx, &ecmd); |
| if (err) { |
| perror("Cannot get device settings"); |
| return 1; |
| } |
| dump_pause(&epause, ecmd.advertising, ecmd.lp_advertising); |
| } else { |
| dump_pause(&epause, 0, 0); |
| } |
| |
| return 0; |
| } |
| |
| static void do_generic_set1(struct cmdline_info *info, int *changed_out) |
| { |
| int wanted, *v1, *v2; |
| |
| v1 = info->wanted_val; |
| wanted = *v1; |
| |
| if (wanted < 0) |
| return; |
| |
| v2 = info->ioctl_val; |
| if (wanted == *v2) { |
| fprintf(stderr, "%s unmodified, ignoring\n", info->name); |
| } else { |
| *v2 = wanted; |
| *changed_out = 1; |
| } |
| } |
| |
| static void do_generic_set(struct cmdline_info *info, |
| unsigned int n_info, |
| int *changed_out) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < n_info; i++) |
| do_generic_set1(&info[i], changed_out); |
| } |
| |
| static int do_spause(struct cmd_context *ctx) |
| { |
| struct ethtool_pauseparam epause; |
| int gpause_changed = 0; |
| int pause_autoneg_wanted = -1; |
| int pause_rx_wanted = -1; |
| int pause_tx_wanted = -1; |
| struct cmdline_info cmdline_pause[] = { |
| { "autoneg", CMDL_BOOL, &pause_autoneg_wanted, |
| &epause.autoneg }, |
| { "rx", CMDL_BOOL, &pause_rx_wanted, &epause.rx_pause }, |
| { "tx", CMDL_BOOL, &pause_tx_wanted, &epause.tx_pause }, |
| }; |
| int err, changed = 0; |
| |
| parse_generic_cmdline(ctx, &gpause_changed, |
| cmdline_pause, ARRAY_SIZE(cmdline_pause)); |
| |
| epause.cmd = ETHTOOL_GPAUSEPARAM; |
| err = send_ioctl(ctx, &epause); |
| if (err) { |
| perror("Cannot get device pause settings"); |
| return 77; |
| } |
| |
| do_generic_set(cmdline_pause, ARRAY_SIZE(cmdline_pause), &changed); |
| |
| if (!changed) { |
| fprintf(stderr, "no pause parameters changed, aborting\n"); |
| return 78; |
| } |
| |
| epause.cmd = ETHTOOL_SPAUSEPARAM; |
| err = send_ioctl(ctx, &epause); |
| if (err) { |
| perror("Cannot set device pause parameters"); |
| return 79; |
| } |
| |
| return 0; |
| } |
| |
| static int do_sring(struct cmd_context *ctx) |
| { |
| struct ethtool_ringparam ering; |
| int gring_changed = 0; |
| s32 ring_rx_wanted = -1; |
| s32 ring_rx_mini_wanted = -1; |
| s32 ring_rx_jumbo_wanted = -1; |
| s32 ring_tx_wanted = -1; |
| struct cmdline_info cmdline_ring[] = { |
| { "rx", CMDL_S32, &ring_rx_wanted, &ering.rx_pending }, |
| { "rx-mini", CMDL_S32, &ring_rx_mini_wanted, |
| &ering.rx_mini_pending }, |
| { "rx-jumbo", CMDL_S32, &ring_rx_jumbo_wanted, |
| &ering.rx_jumbo_pending }, |
| { "tx", CMDL_S32, &ring_tx_wanted, &ering.tx_pending }, |
| }; |
| int err, changed = 0; |
| |
| parse_generic_cmdline(ctx, &gring_changed, |
| cmdline_ring, ARRAY_SIZE(cmdline_ring)); |
| |
| ering.cmd = ETHTOOL_GRINGPARAM; |
| err = send_ioctl(ctx, &ering); |
| if (err) { |
| perror("Cannot get device ring settings"); |
| return 76; |
| } |
| |
| do_generic_set(cmdline_ring, ARRAY_SIZE(cmdline_ring), &changed); |
| |
| if (!changed) { |
| fprintf(stderr, "no ring parameters changed, aborting\n"); |
| return 80; |
| } |
| |
| ering.cmd = ETHTOOL_SRINGPARAM; |
| err = send_ioctl(ctx, &ering); |
| if (err) { |
| perror("Cannot set device ring parameters"); |
| return 81; |
| } |
| |
| return 0; |
| } |
| |
| static int do_gring(struct cmd_context *ctx) |
| { |
| struct ethtool_ringparam ering; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Ring parameters for %s:\n", ctx->devname); |
| |
| ering.cmd = ETHTOOL_GRINGPARAM; |
| err = send_ioctl(ctx, &ering); |
| if (err == 0) { |
| err = dump_ring(&ering); |
| if (err) |
| return err; |
| } else { |
| perror("Cannot get device ring settings"); |
| return 76; |
| } |
| |
| return 0; |
| } |
| |
| static int do_schannels(struct cmd_context *ctx) |
| { |
| struct ethtool_channels echannels; |
| int gchannels_changed; |
| s32 channels_rx_wanted = -1; |
| s32 channels_tx_wanted = -1; |
| s32 channels_other_wanted = -1; |
| s32 channels_combined_wanted = -1; |
| struct cmdline_info cmdline_channels[] = { |
| { "rx", CMDL_S32, &channels_rx_wanted, &echannels.rx_count }, |
| { "tx", CMDL_S32, &channels_tx_wanted, &echannels.tx_count }, |
| { "other", CMDL_S32, &channels_other_wanted, |
| &echannels.other_count }, |
| { "combined", CMDL_S32, &channels_combined_wanted, |
| &echannels.combined_count }, |
| }; |
| int err, changed = 0; |
| |
| parse_generic_cmdline(ctx, &gchannels_changed, |
| cmdline_channels, ARRAY_SIZE(cmdline_channels)); |
| |
| echannels.cmd = ETHTOOL_GCHANNELS; |
| err = send_ioctl(ctx, &echannels); |
| if (err) { |
| perror("Cannot get device channel parameters"); |
| return 1; |
| } |
| |
| do_generic_set(cmdline_channels, ARRAY_SIZE(cmdline_channels), |
| &changed); |
| |
| if (!changed) { |
| fprintf(stderr, "no channel parameters changed.\n"); |
| fprintf(stderr, "current values: rx %u tx %u other %u" |
| " combined %u\n", echannels.rx_count, |
| echannels.tx_count, echannels.other_count, |
| echannels.combined_count); |
| return 0; |
| } |
| |
| echannels.cmd = ETHTOOL_SCHANNELS; |
| err = send_ioctl(ctx, &echannels); |
| if (err) { |
| perror("Cannot set device channel parameters"); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| static int do_gchannels(struct cmd_context *ctx) |
| { |
| struct ethtool_channels echannels; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Channel parameters for %s:\n", ctx->devname); |
| |
| echannels.cmd = ETHTOOL_GCHANNELS; |
| err = send_ioctl(ctx, &echannels); |
| if (err == 0) { |
| err = dump_channels(&echannels); |
| if (err) |
| return err; |
| } else { |
| perror("Cannot get device channel parameters\n"); |
| return 1; |
| } |
| return 0; |
| |
| } |
| |
| static int do_gcoalesce(struct cmd_context *ctx) |
| { |
| struct ethtool_coalesce ecoal = {}; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Coalesce parameters for %s:\n", ctx->devname); |
| |
| ecoal.cmd = ETHTOOL_GCOALESCE; |
| err = send_ioctl(ctx, &ecoal); |
| if (err == 0) { |
| err = dump_coalesce(&ecoal); |
| if (err) |
| return err; |
| } else { |
| perror("Cannot get device coalesce settings"); |
| return 82; |
| } |
| |
| return 0; |
| } |
| |
| #define DECLARE_COALESCE_OPTION_VARS() \ |
| s32 coal_stats_wanted = -1; \ |
| int coal_adaptive_rx_wanted = -1; \ |
| int coal_adaptive_tx_wanted = -1; \ |
| s32 coal_sample_rate_wanted = -1; \ |
| s32 coal_pkt_rate_low_wanted = -1; \ |
| s32 coal_pkt_rate_high_wanted = -1; \ |
| s32 coal_rx_usec_wanted = -1; \ |
| s32 coal_rx_frames_wanted = -1; \ |
| s32 coal_rx_usec_irq_wanted = -1; \ |
| s32 coal_rx_frames_irq_wanted = -1; \ |
| s32 coal_tx_usec_wanted = -1; \ |
| s32 coal_tx_frames_wanted = -1; \ |
| s32 coal_tx_usec_irq_wanted = -1; \ |
| s32 coal_tx_frames_irq_wanted = -1; \ |
| s32 coal_rx_usec_low_wanted = -1; \ |
| s32 coal_rx_frames_low_wanted = -1; \ |
| s32 coal_tx_usec_low_wanted = -1; \ |
| s32 coal_tx_frames_low_wanted = -1; \ |
| s32 coal_rx_usec_high_wanted = -1; \ |
| s32 coal_rx_frames_high_wanted = -1; \ |
| s32 coal_tx_usec_high_wanted = -1; \ |
| s32 coal_tx_frames_high_wanted = -1 |
| |
| #define COALESCE_CMDLINE_INFO(__ecoal) \ |
| { \ |
| { "adaptive-rx", CMDL_BOOL, &coal_adaptive_rx_wanted, \ |
| &__ecoal.use_adaptive_rx_coalesce }, \ |
| { "adaptive-tx", CMDL_BOOL, &coal_adaptive_tx_wanted, \ |
| &__ecoal.use_adaptive_tx_coalesce }, \ |
| { "sample-interval", CMDL_S32, &coal_sample_rate_wanted, \ |
| &__ecoal.rate_sample_interval }, \ |
| { "stats-block-usecs", CMDL_S32, &coal_stats_wanted, \ |
| &__ecoal.stats_block_coalesce_usecs }, \ |
| { "pkt-rate-low", CMDL_S32, &coal_pkt_rate_low_wanted, \ |
| &__ecoal.pkt_rate_low }, \ |
| { "pkt-rate-high", CMDL_S32, &coal_pkt_rate_high_wanted, \ |
| &__ecoal.pkt_rate_high }, \ |
| { "rx-usecs", CMDL_S32, &coal_rx_usec_wanted, \ |
| &__ecoal.rx_coalesce_usecs }, \ |
| { "rx-frames", CMDL_S32, &coal_rx_frames_wanted, \ |
| &__ecoal.rx_max_coalesced_frames }, \ |
| { "rx-usecs-irq", CMDL_S32, &coal_rx_usec_irq_wanted, \ |
| &__ecoal.rx_coalesce_usecs_irq }, \ |
| { "rx-frames-irq", CMDL_S32, &coal_rx_frames_irq_wanted, \ |
| &__ecoal.rx_max_coalesced_frames_irq }, \ |
| { "tx-usecs", CMDL_S32, &coal_tx_usec_wanted, \ |
| &__ecoal.tx_coalesce_usecs }, \ |
| { "tx-frames", CMDL_S32, &coal_tx_frames_wanted, \ |
| &__ecoal.tx_max_coalesced_frames }, \ |
| { "tx-usecs-irq", CMDL_S32, &coal_tx_usec_irq_wanted, \ |
| &__ecoal.tx_coalesce_usecs_irq }, \ |
| { "tx-frames-irq", CMDL_S32, &coal_tx_frames_irq_wanted, \ |
| &__ecoal.tx_max_coalesced_frames_irq }, \ |
| { "rx-usecs-low", CMDL_S32, &coal_rx_usec_low_wanted, \ |
| &__ecoal.rx_coalesce_usecs_low }, \ |
| { "rx-frames-low", CMDL_S32, &coal_rx_frames_low_wanted, \ |
| &__ecoal.rx_max_coalesced_frames_low }, \ |
| { "tx-usecs-low", CMDL_S32, &coal_tx_usec_low_wanted, \ |
| &__ecoal.tx_coalesce_usecs_low }, \ |
| { "tx-frames-low", CMDL_S32, &coal_tx_frames_low_wanted, \ |
| &__ecoal.tx_max_coalesced_frames_low }, \ |
| { "rx-usecs-high", CMDL_S32, &coal_rx_usec_high_wanted, \ |
| &__ecoal.rx_coalesce_usecs_high }, \ |
| { "rx-frames-high", CMDL_S32, &coal_rx_frames_high_wanted, \ |
| &__ecoal.rx_max_coalesced_frames_high }, \ |
| { "tx-usecs-high", CMDL_S32, &coal_tx_usec_high_wanted, \ |
| &__ecoal.tx_coalesce_usecs_high }, \ |
| { "tx-frames-high", CMDL_S32, &coal_tx_frames_high_wanted, \ |
| &__ecoal.tx_max_coalesced_frames_high }, \ |
| } |
| |
| static int do_scoalesce(struct cmd_context *ctx) |
| { |
| struct ethtool_coalesce ecoal; |
| int gcoalesce_changed = 0; |
| DECLARE_COALESCE_OPTION_VARS(); |
| struct cmdline_info cmdline_coalesce[] = COALESCE_CMDLINE_INFO(ecoal); |
| int err, changed = 0; |
| |
| parse_generic_cmdline(ctx, &gcoalesce_changed, |
| cmdline_coalesce, ARRAY_SIZE(cmdline_coalesce)); |
| |
| ecoal.cmd = ETHTOOL_GCOALESCE; |
| err = send_ioctl(ctx, &ecoal); |
| if (err) { |
| perror("Cannot get device coalesce settings"); |
| return 76; |
| } |
| |
| do_generic_set(cmdline_coalesce, ARRAY_SIZE(cmdline_coalesce), |
| &changed); |
| |
| if (!changed) { |
| fprintf(stderr, "no coalesce parameters changed, aborting\n"); |
| return 80; |
| } |
| |
| ecoal.cmd = ETHTOOL_SCOALESCE; |
| err = send_ioctl(ctx, &ecoal); |
| if (err) { |
| perror("Cannot set device coalesce parameters"); |
| return 81; |
| } |
| |
| return 0; |
| } |
| |
| static struct feature_state * |
| get_features(struct cmd_context *ctx, const struct feature_defs *defs) |
| { |
| struct feature_state *state; |
| struct ethtool_value eval; |
| int err, allfail = 1; |
| u32 value; |
| int i; |
| |
| state = malloc(sizeof(*state) + |
| FEATURE_BITS_TO_BLOCKS(defs->n_features) * |
| sizeof(state->features.features[0])); |
| if (!state) |
| return NULL; |
| |
| state->off_flags = 0; |
| |
| for (i = 0; i < ARRAY_SIZE(off_flag_def); i++) { |
| value = off_flag_def[i].value; |
| if (!off_flag_def[i].get_cmd) |
| continue; |
| eval.cmd = off_flag_def[i].get_cmd; |
| err = send_ioctl(ctx, &eval); |
| if (err) { |
| if (errno == EOPNOTSUPP && |
| off_flag_def[i].get_cmd == ETHTOOL_GUFO) |
| continue; |
| |
| fprintf(stderr, |
| "Cannot get device %s settings: %m\n", |
| off_flag_def[i].long_name); |
| } else { |
| if (eval.data) |
| state->off_flags |= value; |
| allfail = 0; |
| } |
| } |
| |
| eval.cmd = ETHTOOL_GFLAGS; |
| err = send_ioctl(ctx, &eval); |
| if (err) { |
| perror("Cannot get device flags"); |
| } else { |
| state->off_flags |= eval.data & ETH_FLAG_EXT_MASK; |
| allfail = 0; |
| } |
| |
| if (defs->n_features) { |
| state->features.cmd = ETHTOOL_GFEATURES; |
| state->features.size = FEATURE_BITS_TO_BLOCKS(defs->n_features); |
| err = send_ioctl(ctx, &state->features); |
| if (err) |
| perror("Cannot get device generic features"); |
| else |
| allfail = 0; |
| } |
| |
| if (allfail) { |
| free(state); |
| return NULL; |
| } |
| |
| return state; |
| } |
| |
| static int do_gfeatures(struct cmd_context *ctx) |
| { |
| struct feature_defs *defs; |
| struct feature_state *features; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| defs = get_feature_defs(ctx); |
| if (!defs) { |
| perror("Cannot get device feature names"); |
| return 1; |
| } |
| |
| fprintf(stdout, "Features for %s:\n", ctx->devname); |
| |
| features = get_features(ctx, defs); |
| if (!features) { |
| fprintf(stdout, "no feature info available\n"); |
| free(defs); |
| return 1; |
| } |
| |
| dump_features(defs, features, NULL); |
| free(features); |
| free(defs); |
| return 0; |
| } |
| |
| static int do_sfeatures(struct cmd_context *ctx) |
| { |
| struct feature_defs *defs; |
| int any_changed = 0, any_mismatch = 0; |
| u32 off_flags_wanted = 0; |
| u32 off_flags_mask = 0; |
| struct ethtool_sfeatures *efeatures; |
| struct cmdline_info *cmdline_features; |
| struct feature_state *old_state, *new_state; |
| struct ethtool_value eval; |
| int err, rc; |
| int i, j; |
| |
| defs = get_feature_defs(ctx); |
| if (!defs) { |
| perror("Cannot get device feature names"); |
| return 1; |
| } |
| if (defs->n_features) { |
| efeatures = malloc(sizeof(*efeatures) + |
| FEATURE_BITS_TO_BLOCKS(defs->n_features) * |
| sizeof(efeatures->features[0])); |
| if (!efeatures) { |
| perror("Cannot parse arguments"); |
| rc = 1; |
| goto err; |
| } |
| efeatures->cmd = ETHTOOL_SFEATURES; |
| efeatures->size = FEATURE_BITS_TO_BLOCKS(defs->n_features); |
| memset(efeatures->features, 0, |
| FEATURE_BITS_TO_BLOCKS(defs->n_features) * |
| sizeof(efeatures->features[0])); |
| } else { |
| efeatures = NULL; |
| } |
| |
| /* Generate cmdline_info for legacy flags and kernel-named |
| * features, and parse our arguments. |
| */ |
| cmdline_features = calloc(ARRAY_SIZE(off_flag_def) + defs->n_features, |
| sizeof(cmdline_features[0])); |
| if (!cmdline_features) { |
| perror("Cannot parse arguments"); |
| rc = 1; |
| goto err; |
| } |
| for (i = 0; i < ARRAY_SIZE(off_flag_def); i++) |
| flag_to_cmdline_info(off_flag_def[i].short_name, |
| off_flag_def[i].value, |
| &off_flags_wanted, &off_flags_mask, |
| &cmdline_features[i]); |
| for (i = 0; i < defs->n_features; i++) |
| flag_to_cmdline_info( |
| defs->def[i].name, FEATURE_FIELD_FLAG(i), |
| &FEATURE_WORD(efeatures->features, i, requested), |
| &FEATURE_WORD(efeatures->features, i, valid), |
| &cmdline_features[ARRAY_SIZE(off_flag_def) + i]); |
| parse_generic_cmdline(ctx, &any_changed, cmdline_features, |
| ARRAY_SIZE(off_flag_def) + defs->n_features); |
| free(cmdline_features); |
| |
| if (!any_changed) { |
| fprintf(stdout, "no features changed\n"); |
| rc = 0; |
| goto err; |
| } |
| |
| old_state = get_features(ctx, defs); |
| if (!old_state) { |
| rc = 1; |
| goto err; |
| } |
| |
| if (efeatures) { |
| /* For each offload that the user specified, update any |
| * related features that the user did not specify and that |
| * are not fixed. Warn if all related features are fixed. |
| */ |
| for (i = 0; i < ARRAY_SIZE(off_flag_def); i++) { |
| int fixed = 1; |
| |
| if (!(off_flags_mask & off_flag_def[i].value)) |
| continue; |
| |
| for (j = 0; j < defs->n_features; j++) { |
| if (defs->def[j].off_flag_index != i || |
| !FEATURE_BIT_IS_SET( |
| old_state->features.features, |
| j, available) || |
| FEATURE_BIT_IS_SET( |
| old_state->features.features, |
| j, never_changed)) |
| continue; |
| |
| fixed = 0; |
| if (!FEATURE_BIT_IS_SET(efeatures->features, |
| j, valid)) { |
| FEATURE_BIT_SET(efeatures->features, |
| j, valid); |
| if (off_flags_wanted & |
| off_flag_def[i].value) |
| FEATURE_BIT_SET( |
| efeatures->features, |
| j, requested); |
| } |
| } |
| |
| if (fixed) |
| fprintf(stderr, "Cannot change %s\n", |
| off_flag_def[i].long_name); |
| } |
| |
| err = send_ioctl(ctx, efeatures); |
| if (err < 0) { |
| perror("Cannot set device feature settings"); |
| rc = 1; |
| goto err; |
| } |
| } else { |
| for (i = 0; i < ARRAY_SIZE(off_flag_def); i++) { |
| if (!off_flag_def[i].set_cmd) |
| continue; |
| if (off_flags_mask & off_flag_def[i].value) { |
| eval.cmd = off_flag_def[i].set_cmd; |
| eval.data = !!(off_flags_wanted & |
| off_flag_def[i].value); |
| err = send_ioctl(ctx, &eval); |
| if (err) { |
| fprintf(stderr, |
| "Cannot set device %s settings: %m\n", |
| off_flag_def[i].long_name); |
| rc = 1; |
| goto err; |
| } |
| } |
| } |
| |
| if (off_flags_mask & ETH_FLAG_EXT_MASK) { |
| eval.cmd = ETHTOOL_SFLAGS; |
| eval.data = (old_state->off_flags & ~off_flags_mask & |
| ETH_FLAG_EXT_MASK); |
| eval.data |= off_flags_wanted & ETH_FLAG_EXT_MASK; |
| |
| err = send_ioctl(ctx, &eval); |
| if (err) { |
| perror("Cannot set device flag settings"); |
| rc = 92; |
| goto err; |
| } |
| } |
| } |
| |
| /* Compare new state with requested state */ |
| new_state = get_features(ctx, defs); |
| if (!new_state) { |
| rc = 1; |
| goto err; |
| } |
| any_changed = new_state->off_flags != old_state->off_flags; |
| any_mismatch = (new_state->off_flags != |
| ((old_state->off_flags & ~off_flags_mask) | |
| off_flags_wanted)); |
| for (i = 0; i < FEATURE_BITS_TO_BLOCKS(defs->n_features); i++) { |
| if (new_state->features.features[i].active != |
| old_state->features.features[i].active) |
| any_changed = 1; |
| if (new_state->features.features[i].active != |
| ((old_state->features.features[i].active & |
| ~efeatures->features[i].valid) | |
| efeatures->features[i].requested)) |
| any_mismatch = 1; |
| } |
| if (any_mismatch) { |
| if (!any_changed) { |
| fprintf(stderr, |
| "Could not change any device features\n"); |
| rc = 1; |
| goto err; |
| } |
| printf("Actual changes:\n"); |
| dump_features(defs, new_state, old_state); |
| } |
| |
| rc = 0; |
| |
| err: |
| free(defs); |
| if (efeatures) |
| free(efeatures); |
| return rc; |
| } |
| |
| static struct ethtool_link_usettings * |
| do_ioctl_glinksettings(struct cmd_context *ctx) |
| { |
| int err; |
| struct { |
| struct ethtool_link_settings req; |
| __u32 link_mode_data[3 * ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32]; |
| } ecmd; |
| struct ethtool_link_usettings *link_usettings; |
| unsigned int u32_offs; |
| |
| /* Handshake with kernel to determine number of words for link |
| * mode bitmaps. When requested number of bitmap words is not |
| * the one expected by kernel, the latter returns the integer |
| * opposite of what it is expecting. We request length 0 below |
| * (aka. invalid bitmap length) to get this info. |
| */ |
| memset(&ecmd, 0, sizeof(ecmd)); |
| ecmd.req.cmd = ETHTOOL_GLINKSETTINGS; |
| err = send_ioctl(ctx, &ecmd); |
| if (err < 0) |
| return NULL; |
| |
| /* see above: we expect a strictly negative value from kernel. |
| */ |
| if (ecmd.req.link_mode_masks_nwords >= 0 |
| || ecmd.req.cmd != ETHTOOL_GLINKSETTINGS) |
| return NULL; |
| |
| /* got the real ecmd.req.link_mode_masks_nwords, |
| * now send the real request |
| */ |
| ecmd.req.cmd = ETHTOOL_GLINKSETTINGS; |
| ecmd.req.link_mode_masks_nwords = -ecmd.req.link_mode_masks_nwords; |
| err = send_ioctl(ctx, &ecmd); |
| if (err < 0) |
| return NULL; |
| |
| if (ecmd.req.link_mode_masks_nwords <= 0 |
| || ecmd.req.cmd != ETHTOOL_GLINKSETTINGS) |
| return NULL; |
| |
| /* Convert to usettings struct */ |
| link_usettings = calloc(1, sizeof(*link_usettings)); |
| if (link_usettings == NULL) |
| return NULL; |
| |
| /* keep transceiver 0 */ |
| memcpy(&link_usettings->base, &ecmd.req, sizeof(link_usettings->base)); |
| |
| /* copy link mode bitmaps */ |
| u32_offs = 0; |
| memcpy(link_usettings->link_modes.supported, |
| &ecmd.link_mode_data[u32_offs], |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| u32_offs += ecmd.req.link_mode_masks_nwords; |
| memcpy(link_usettings->link_modes.advertising, |
| &ecmd.link_mode_data[u32_offs], |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| u32_offs += ecmd.req.link_mode_masks_nwords; |
| memcpy(link_usettings->link_modes.lp_advertising, |
| &ecmd.link_mode_data[u32_offs], |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| return link_usettings; |
| } |
| |
| static int |
| do_ioctl_slinksettings(struct cmd_context *ctx, |
| const struct ethtool_link_usettings *link_usettings) |
| { |
| struct { |
| struct ethtool_link_settings req; |
| __u32 link_mode_data[3 * ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32]; |
| } ecmd; |
| unsigned int u32_offs; |
| |
| /* refuse to send ETHTOOL_SLINKSETTINGS ioctl if |
| * link_usettings was retrieved with ETHTOOL_GSET |
| */ |
| if (link_usettings->base.cmd != ETHTOOL_GLINKSETTINGS) |
| return -1; |
| |
| /* refuse to send ETHTOOL_SLINKSETTINGS ioctl if deprecated fields |
| * were set |
| */ |
| if (link_usettings->deprecated.transceiver) |
| return -1; |
| |
| if (link_usettings->base.link_mode_masks_nwords <= 0) |
| return -1; |
| |
| memcpy(&ecmd.req, &link_usettings->base, sizeof(ecmd.req)); |
| ecmd.req.cmd = ETHTOOL_SLINKSETTINGS; |
| |
| /* copy link mode bitmaps */ |
| u32_offs = 0; |
| memcpy(&ecmd.link_mode_data[u32_offs], |
| link_usettings->link_modes.supported, |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| u32_offs += ecmd.req.link_mode_masks_nwords; |
| memcpy(&ecmd.link_mode_data[u32_offs], |
| link_usettings->link_modes.advertising, |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| u32_offs += ecmd.req.link_mode_masks_nwords; |
| memcpy(&ecmd.link_mode_data[u32_offs], |
| link_usettings->link_modes.lp_advertising, |
| 4 * ecmd.req.link_mode_masks_nwords); |
| |
| return send_ioctl(ctx, &ecmd); |
| } |
| |
| static struct ethtool_link_usettings * |
| do_ioctl_gset(struct cmd_context *ctx) |
| { |
| int err; |
| struct ethtool_cmd ecmd; |
| struct ethtool_link_usettings *link_usettings; |
| |
| memset(&ecmd, 0, sizeof(ecmd)); |
| ecmd.cmd = ETHTOOL_GSET; |
| err = send_ioctl(ctx, &ecmd); |
| if (err < 0) |
| return NULL; |
| |
| link_usettings = calloc(1, sizeof(*link_usettings)); |
| if (link_usettings == NULL) |
| return NULL; |
| |
| /* remember that ETHTOOL_GSET was used */ |
| link_usettings->base.cmd = ETHTOOL_GSET; |
| |
| link_usettings->base.link_mode_masks_nwords = 1; |
| link_usettings->link_modes.supported[0] = ecmd.supported; |
| link_usettings->link_modes.advertising[0] = ecmd.advertising; |
| link_usettings->link_modes.lp_advertising[0] = ecmd.lp_advertising; |
| link_usettings->base.speed = ethtool_cmd_speed(&ecmd); |
| link_usettings->base.duplex = ecmd.duplex; |
| link_usettings->base.port = ecmd.port; |
| link_usettings->base.phy_address = ecmd.phy_address; |
| link_usettings->deprecated.transceiver = ecmd.transceiver; |
| link_usettings->base.autoneg = ecmd.autoneg; |
| link_usettings->base.mdio_support = ecmd.mdio_support; |
| /* ignored (fully deprecated): maxrxpkt, maxtxpkt */ |
| link_usettings->base.eth_tp_mdix = ecmd.eth_tp_mdix; |
| link_usettings->base.eth_tp_mdix_ctrl = ecmd.eth_tp_mdix_ctrl; |
| |
| return link_usettings; |
| } |
| |
| static bool ethtool_link_mode_is_backward_compatible(const u32 *mask) |
| { |
| unsigned int i; |
| |
| for (i = 1; i < ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32; ++i) |
| if (mask[i]) |
| return false; |
| |
| return true; |
| } |
| |
| static int |
| do_ioctl_sset(struct cmd_context *ctx, |
| const struct ethtool_link_usettings *link_usettings) |
| { |
| struct ethtool_cmd ecmd; |
| |
| /* refuse to send ETHTOOL_SSET ioctl if link_usettings was |
| * retrieved with ETHTOOL_GLINKSETTINGS |
| */ |
| if (link_usettings->base.cmd != ETHTOOL_GSET) |
| return -1; |
| |
| if (link_usettings->base.link_mode_masks_nwords <= 0) |
| return -1; |
| |
| /* refuse to sset if any bit > 31 is set */ |
| if (!ethtool_link_mode_is_backward_compatible( |
| link_usettings->link_modes.supported)) |
| return -1; |
| if (!ethtool_link_mode_is_backward_compatible( |
| link_usettings->link_modes.advertising)) |
| return -1; |
| if (!ethtool_link_mode_is_backward_compatible( |
| link_usettings->link_modes.lp_advertising)) |
| return -1; |
| |
| memset(&ecmd, 0, sizeof(ecmd)); |
| ecmd.cmd = ETHTOOL_SSET; |
| |
| ecmd.supported = link_usettings->link_modes.supported[0]; |
| ecmd.advertising = link_usettings->link_modes.advertising[0]; |
| ecmd.lp_advertising = link_usettings->link_modes.lp_advertising[0]; |
| ethtool_cmd_speed_set(&ecmd, link_usettings->base.speed); |
| ecmd.duplex = link_usettings->base.duplex; |
| ecmd.port = link_usettings->base.port; |
| ecmd.phy_address = link_usettings->base.phy_address; |
| ecmd.transceiver = link_usettings->deprecated.transceiver; |
| ecmd.autoneg = link_usettings->base.autoneg; |
| ecmd.mdio_support = link_usettings->base.mdio_support; |
| /* ignored (fully deprecated): maxrxpkt, maxtxpkt */ |
| ecmd.eth_tp_mdix = link_usettings->base.eth_tp_mdix; |
| ecmd.eth_tp_mdix_ctrl = link_usettings->base.eth_tp_mdix_ctrl; |
| return send_ioctl(ctx, &ecmd); |
| } |
| |
| static int do_gset(struct cmd_context *ctx) |
| { |
| int err; |
| struct ethtool_link_usettings *link_usettings; |
| struct ethtool_wolinfo wolinfo; |
| struct ethtool_value edata; |
| int allfail = 1; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Settings for %s:\n", ctx->devname); |
| |
| link_usettings = do_ioctl_glinksettings(ctx); |
| if (link_usettings == NULL) |
| link_usettings = do_ioctl_gset(ctx); |
| if (link_usettings != NULL) { |
| err = dump_link_usettings(link_usettings); |
| free(link_usettings); |
| if (err) |
| return err; |
| allfail = 0; |
| } else if (errno != EOPNOTSUPP) { |
| perror("Cannot get device settings"); |
| } |
| |
| wolinfo.cmd = ETHTOOL_GWOL; |
| err = send_ioctl(ctx, &wolinfo); |
| if (err == 0) { |
| err = dump_wol(&wolinfo); |
| if (err) |
| return err; |
| allfail = 0; |
| } else if (errno != EOPNOTSUPP) { |
| perror("Cannot get wake-on-lan settings"); |
| } |
| |
| edata.cmd = ETHTOOL_GMSGLVL; |
| err = send_ioctl(ctx, &edata); |
| if (err == 0) { |
| fprintf(stdout, " Current message level: 0x%08x (%d)\n" |
| " ", |
| edata.data, edata.data); |
| print_flags(flags_msglvl, ARRAY_SIZE(flags_msglvl), |
| edata.data); |
| fprintf(stdout, "\n"); |
| allfail = 0; |
| } else if (errno != EOPNOTSUPP) { |
| perror("Cannot get message level"); |
| } |
| |
| edata.cmd = ETHTOOL_GLINK; |
| err = send_ioctl(ctx, &edata); |
| if (err == 0) { |
| fprintf(stdout, " Link detected: %s\n", |
| edata.data ? "yes":"no"); |
| allfail = 0; |
| } else if (errno != EOPNOTSUPP) { |
| perror("Cannot get link status"); |
| } |
| |
| if (allfail) { |
| fprintf(stdout, "No data available\n"); |
| return 75; |
| } |
| return 0; |
| } |
| |
| static int do_sset(struct cmd_context *ctx) |
| { |
| int speed_wanted = -1; |
| int duplex_wanted = -1; |
| int port_wanted = -1; |
| int mdix_wanted = -1; |
| int autoneg_wanted = -1; |
| int phyad_wanted = -1; |
| int xcvr_wanted = -1; |
| u32 *full_advertising_wanted = NULL; |
| u32 *advertising_wanted = NULL; |
| ETHTOOL_DECLARE_LINK_MODE_MASK(mask_full_advertising_wanted); |
| ETHTOOL_DECLARE_LINK_MODE_MASK(mask_advertising_wanted); |
| int gset_changed = 0; /* did anything in GSET change? */ |
| u32 wol_wanted = 0; |
| int wol_change = 0; |
| u8 sopass_wanted[SOPASS_MAX]; |
| int sopass_change = 0; |
| int gwol_changed = 0; /* did anything in GWOL change? */ |
| int msglvl_changed = 0; |
| u32 msglvl_wanted = 0; |
| u32 msglvl_mask = 0; |
| struct cmdline_info cmdline_msglvl[ARRAY_SIZE(flags_msglvl)]; |
| int argc = ctx->argc; |
| char **argp = ctx->argp; |
| int i; |
| int err = 0; |
| |
| for (i = 0; i < ARRAY_SIZE(flags_msglvl); i++) |
| flag_to_cmdline_info(flags_msglvl[i].name, |
| flags_msglvl[i].value, |
| &msglvl_wanted, &msglvl_mask, |
| &cmdline_msglvl[i]); |
| |
| for (i = 0; i < argc; i++) { |
| if (!strcmp(argp[i], "speed")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| speed_wanted = get_int(argp[i], 10); |
| } else if (!strcmp(argp[i], "duplex")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (!strcmp(argp[i], "half")) |
| duplex_wanted = DUPLEX_HALF; |
| else if (!strcmp(argp[i], "full")) |
| duplex_wanted = DUPLEX_FULL; |
| else |
| exit_bad_args(); |
| } else if (!strcmp(argp[i], "port")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (!strcmp(argp[i], "tp")) |
| port_wanted = PORT_TP; |
| else if (!strcmp(argp[i], "aui")) |
| port_wanted = PORT_AUI; |
| else if (!strcmp(argp[i], "bnc")) |
| port_wanted = PORT_BNC; |
| else if (!strcmp(argp[i], "mii")) |
| port_wanted = PORT_MII; |
| else if (!strcmp(argp[i], "fibre")) |
| port_wanted = PORT_FIBRE; |
| else |
| exit_bad_args(); |
| } else if (!strcmp(argp[i], "mdix")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (!strcmp(argp[i], "auto")) |
| mdix_wanted = ETH_TP_MDI_AUTO; |
| else if (!strcmp(argp[i], "on")) |
| mdix_wanted = ETH_TP_MDI_X; |
| else if (!strcmp(argp[i], "off")) |
| mdix_wanted = ETH_TP_MDI; |
| else |
| exit_bad_args(); |
| } else if (!strcmp(argp[i], "autoneg")) { |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (!strcmp(argp[i], "on")) { |
| gset_changed = 1; |
| autoneg_wanted = AUTONEG_ENABLE; |
| } else if (!strcmp(argp[i], "off")) { |
| gset_changed = 1; |
| autoneg_wanted = AUTONEG_DISABLE; |
| } else { |
| exit_bad_args(); |
| } |
| } else if (!strcmp(argp[i], "advertise")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (parse_hex_u32_bitmap( |
| argp[i], |
| ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NBITS, |
| mask_full_advertising_wanted)) |
| exit_bad_args(); |
| full_advertising_wanted = mask_full_advertising_wanted; |
| } else if (!strcmp(argp[i], "phyad")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| phyad_wanted = get_int(argp[i], 0); |
| } else if (!strcmp(argp[i], "xcvr")) { |
| gset_changed = 1; |
| i += 1; |
| if (i >= argc) |
| exit_bad_args(); |
| if (!strcmp(argp[i], "internal")) |
| xcvr_wanted = XCVR_INTERNAL; |
| else if (!strcmp(argp[i], "external")) |
| xcvr_wanted = XCVR_EXTERNAL; |
| else |
| exit_bad_args(); |
| } else if (!strcmp(argp[i], "wol")) { |
| gwol_changed = 1; |
| i++; |
| if (i >= argc) |
| exit_bad_args(); |
| if (parse_wolopts(argp[i], &wol_wanted) < 0) |
| exit_bad_args(); |
| wol_change = 1; |
| } else if (!strcmp(argp[i], "sopass")) { |
| gwol_changed = 1; |
| i++; |
| if (i >= argc) |
| exit_bad_args(); |
| get_mac_addr(argp[i], sopass_wanted); |
| sopass_change = 1; |
| } else if (!strcmp(argp[i], "msglvl")) { |
| i++; |
| if (i >= argc) |
| exit_bad_args(); |
| if (isdigit((unsigned char)argp[i][0])) { |
| msglvl_changed = 1; |
| msglvl_mask = ~0; |
| msglvl_wanted = |
| get_uint_range(argp[i], 0, |
| 0xffffffff); |
| } else { |
| ctx->argc -= i; |
| ctx->argp += i; |
| parse_generic_cmdline( |
| ctx, &msglvl_changed, |
| cmdline_msglvl, |
| ARRAY_SIZE(cmdline_msglvl)); |
| break; |
| } |
| } else { |
| exit_bad_args(); |
| } |
| } |
| |
| if (full_advertising_wanted == NULL) { |
| /* User didn't supply a full advertisement bitfield: |
| * construct one from the specified speed and duplex. |
| */ |
| int adv_bit = -1; |
| |
| if (speed_wanted == SPEED_10 && duplex_wanted == DUPLEX_HALF) |
| adv_bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT; |
| else if (speed_wanted == SPEED_10 && |
| duplex_wanted == DUPLEX_FULL) |
| adv_bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT; |
| else if (speed_wanted == SPEED_100 && |
| duplex_wanted == DUPLEX_HALF) |
| adv_bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT; |
| else if (speed_wanted == SPEED_100 && |
| duplex_wanted == DUPLEX_FULL) |
| adv_bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT; |
| else if (speed_wanted == SPEED_1000 && |
| duplex_wanted == DUPLEX_HALF) |
| adv_bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT; |
| else if (speed_wanted == SPEED_1000 && |
| duplex_wanted == DUPLEX_FULL) |
| adv_bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT; |
| else if (speed_wanted == SPEED_2500 && |
| duplex_wanted == DUPLEX_FULL) |
| adv_bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT; |
| else if (speed_wanted == SPEED_10000 && |
| duplex_wanted == DUPLEX_FULL) |
| adv_bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT; |
| |
| if (adv_bit >= 0) { |
| advertising_wanted = mask_advertising_wanted; |
| ethtool_link_mode_zero(advertising_wanted); |
| ethtool_link_mode_set_bit( |
| adv_bit, advertising_wanted); |
| } |
| /* otherwise: auto negotiate without forcing, |
| * all supported speed will be assigned below |
| */ |
| } |
| |
| if (gset_changed) { |
| struct ethtool_link_usettings *link_usettings; |
| |
| link_usettings = do_ioctl_glinksettings(ctx); |
| if (link_usettings == NULL) |
| link_usettings = do_ioctl_gset(ctx); |
| if (link_usettings == NULL) { |
| perror("Cannot get current device settings"); |
| err = -1; |
| } else { |
| /* Change everything the user specified. */ |
| if (speed_wanted != -1) |
| link_usettings->base.speed = speed_wanted; |
| if (duplex_wanted != -1) |
| link_usettings->base.duplex = duplex_wanted; |
| if (port_wanted != -1) |
| link_usettings->base.port = port_wanted; |
| if (mdix_wanted != -1) { |
| /* check driver supports MDI-X */ |
| if (link_usettings->base.eth_tp_mdix_ctrl |
| != ETH_TP_MDI_INVALID) |
| link_usettings->base.eth_tp_mdix_ctrl |
| = mdix_wanted; |
| else |
| fprintf(stderr, |
| "setting MDI not supported\n"); |
| } |
| if (autoneg_wanted != -1) |
| link_usettings->base.autoneg = autoneg_wanted; |
| if (phyad_wanted != -1) |
| link_usettings->base.phy_address = phyad_wanted; |
| if (xcvr_wanted != -1) |
| link_usettings->deprecated.transceiver |
| = xcvr_wanted; |
| /* XXX If the user specified speed or duplex |
| * then we should mask the advertised modes |
| * accordingly. For now, warn that we aren't |
| * doing that. |
| */ |
| if ((speed_wanted != -1 || duplex_wanted != -1) && |
| link_usettings->base.autoneg && |
| advertising_wanted == NULL) { |
| fprintf(stderr, "Cannot advertise"); |
| if (speed_wanted >= 0) |
| fprintf(stderr, " speed %d", |
| speed_wanted); |
| if (duplex_wanted >= 0) |
| fprintf(stderr, " duplex %s", |
| duplex_wanted ? |
| "full" : "half"); |
| fprintf(stderr, "\n"); |
| } |
| if (autoneg_wanted == AUTONEG_ENABLE && |
| advertising_wanted == NULL && |
| full_advertising_wanted == NULL) { |
| unsigned int i; |
| |
| /* Auto negotiation enabled, but with |
| * unspecified speed and duplex: enable all |
| * supported speeds and duplexes. |
| */ |
| ethtool_link_mode_for_each_u32(i) { |
| u32 sup = link_usettings->link_modes.supported[i]; |
| u32 *adv = link_usettings->link_modes.advertising + i; |
| |
| *adv = ((*adv & ~all_advertised_modes[i]) |
| | (sup & all_advertised_modes[i])); |
| } |
| |
| /* If driver supports unknown flags, we cannot |
| * be sure that we enable all link modes. |
| */ |
| ethtool_link_mode_for_each_u32(i) { |
| u32 sup = link_usettings->link_modes.supported[i]; |
| |
| if ((sup & all_advertised_flags[i]) != sup) { |
| fprintf(stderr, "Driver supports one or more unknown flags\n"); |
| break; |
| } |
| } |
| } else if (advertising_wanted != NULL) { |
| unsigned int i; |
| |
| /* Enable all requested modes */ |
| ethtool_link_mode_for_each_u32(i) { |
| u32 *adv = link_usettings->link_modes.advertising + i; |
| |
| *adv = ((*adv & ~all_advertised_modes[i]) |
| | advertising_wanted[i]); |
| } |
| } else if (full_advertising_wanted != NULL) { |
| ethtool_link_mode_copy( |
| link_usettings->link_modes.advertising, |
| full_advertising_wanted); |
| } |
| |
| /* Try to perform the update. */ |
| if (link_usettings->base.cmd == ETHTOOL_GLINKSETTINGS) |
| err = do_ioctl_slinksettings(ctx, |
| link_usettings); |
| else |
| err = do_ioctl_sset(ctx, link_usettings); |
| free(link_usettings); |
| if (err < 0) |
| perror("Cannot set new settings"); |
| } |
| if (err < 0) { |
| if (speed_wanted != -1) |
| fprintf(stderr, " not setting speed\n"); |
| if (duplex_wanted != -1) |
| fprintf(stderr, " not setting duplex\n"); |
| if (port_wanted != -1) |
| fprintf(stderr, " not setting port\n"); |
| if (autoneg_wanted != -1) |
| fprintf(stderr, " not setting autoneg\n"); |
| if (phyad_wanted != -1) |
| fprintf(stderr, " not setting phy_address\n"); |
| if (xcvr_wanted != -1) |
| fprintf(stderr, " not setting transceiver\n"); |
| if (mdix_wanted != -1) |
| fprintf(stderr, " not setting mdix\n"); |
| } |
| } |
| |
| if (gwol_changed) { |
| struct ethtool_wolinfo wol; |
| |
| wol.cmd = ETHTOOL_GWOL; |
| err = send_ioctl(ctx, &wol); |
| if (err < 0) { |
| perror("Cannot get current wake-on-lan settings"); |
| } else { |
| /* Change everything the user specified. */ |
| if (wol_change) |
| wol.wolopts = wol_wanted; |
| if (sopass_change) { |
| int i; |
| for (i = 0; i < SOPASS_MAX; i++) |
| wol.sopass[i] = sopass_wanted[i]; |
| } |
| |
| /* Try to perform the update. */ |
| wol.cmd = ETHTOOL_SWOL; |
| err = send_ioctl(ctx, &wol); |
| if (err < 0) |
| perror("Cannot set new wake-on-lan settings"); |
| } |
| if (err < 0) { |
| if (wol_change) |
| fprintf(stderr, " not setting wol\n"); |
| if (sopass_change) |
| fprintf(stderr, " not setting sopass\n"); |
| } |
| } |
| |
| if (msglvl_changed) { |
| struct ethtool_value edata; |
| |
| edata.cmd = ETHTOOL_GMSGLVL; |
| err = send_ioctl(ctx, &edata); |
| if (err < 0) { |
| perror("Cannot get msglvl"); |
| } else { |
| edata.cmd = ETHTOOL_SMSGLVL; |
| edata.data = ((edata.data & ~msglvl_mask) | |
| msglvl_wanted); |
| err = send_ioctl(ctx, &edata); |
| if (err < 0) |
| perror("Cannot set new msglvl"); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int do_gregs(struct cmd_context *ctx) |
| { |
| int gregs_changed = 0; |
| int gregs_dump_raw = 0; |
| int gregs_dump_hex = 0; |
| char *gregs_dump_file = NULL; |
| struct cmdline_info cmdline_gregs[] = { |
| { "raw", CMDL_BOOL, &gregs_dump_raw, NULL }, |
| { "hex", CMDL_BOOL, &gregs_dump_hex, NULL }, |
| { "file", CMDL_STR, &gregs_dump_file, NULL }, |
| }; |
| int err; |
| struct ethtool_drvinfo drvinfo; |
| struct ethtool_regs *regs; |
| |
| parse_generic_cmdline(ctx, &gregs_changed, |
| cmdline_gregs, ARRAY_SIZE(cmdline_gregs)); |
| |
| drvinfo.cmd = ETHTOOL_GDRVINFO; |
| err = send_ioctl(ctx, &drvinfo); |
| if (err < 0) { |
| perror("Cannot get driver information"); |
| return 72; |
| } |
| |
| regs = calloc(1, sizeof(*regs)+drvinfo.regdump_len); |
| if (!regs) { |
| perror("Cannot allocate memory for register dump"); |
| return 73; |
| } |
| regs->cmd = ETHTOOL_GREGS; |
| regs->len = drvinfo.regdump_len; |
| err = send_ioctl(ctx, regs); |
| if (err < 0) { |
| perror("Cannot get register dump"); |
| free(regs); |
| return 74; |
| } |
| |
| if (!gregs_dump_raw && gregs_dump_file != NULL) { |
| /* overwrite reg values from file dump */ |
| FILE *f = fopen(gregs_dump_file, "r"); |
| struct ethtool_regs *nregs; |
| struct stat st; |
| size_t nread; |
| |
| if (!f || fstat(fileno(f), &st) < 0) { |
| fprintf(stderr, "Can't open '%s': %s\n", |
| gregs_dump_file, strerror(errno)); |
| if (f) |
| fclose(f); |
| free(regs); |
| return 75; |
| } |
| |
| nregs = realloc(regs, sizeof(*regs) + st.st_size); |
| if (!nregs) { |
| perror("Cannot allocate memory for register dump"); |
| free(regs); /* was not freed by realloc */ |
| return 73; |
| } |
| regs = nregs; |
| regs->len = st.st_size; |
| nread = fread(regs->data, regs->len, 1, f); |
| fclose(f); |
| if (nread != 1) { |
| free(regs); |
| return 75; |
| } |
| } |
| |
| if (dump_regs(gregs_dump_raw, gregs_dump_hex, |
| &drvinfo, regs) < 0) { |
| fprintf(stderr, "Cannot dump registers\n"); |
| free(regs); |
| return 75; |
| } |
| free(regs); |
| |
| return 0; |
| } |
| |
| static int do_nway_rst(struct cmd_context *ctx) |
| { |
| struct ethtool_value edata; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| edata.cmd = ETHTOOL_NWAY_RST; |
| err = send_ioctl(ctx, &edata); |
| if (err < 0) |
| perror("Cannot restart autonegotiation"); |
| |
| return err; |
| } |
| |
| static int do_geeprom(struct cmd_context *ctx) |
| { |
| int geeprom_changed = 0; |
| int geeprom_dump_raw = 0; |
| u32 geeprom_offset = 0; |
| u32 geeprom_length = -1; |
| struct cmdline_info cmdline_geeprom[] = { |
| { "offset", CMDL_U32, &geeprom_offset, NULL }, |
| { "length", CMDL_U32, &geeprom_length, NULL }, |
| { "raw", CMDL_BOOL, &geeprom_dump_raw, NULL }, |
| }; |
| int err; |
| struct ethtool_drvinfo drvinfo; |
| struct ethtool_eeprom *eeprom; |
| |
| parse_generic_cmdline(ctx, &geeprom_changed, |
| cmdline_geeprom, ARRAY_SIZE(cmdline_geeprom)); |
| |
| drvinfo.cmd = ETHTOOL_GDRVINFO; |
| err = send_ioctl(ctx, &drvinfo); |
| if (err < 0) { |
| perror("Cannot get driver information"); |
| return 74; |
| } |
| |
| if (geeprom_length == -1) |
| geeprom_length = drvinfo.eedump_len; |
| |
| if (drvinfo.eedump_len < geeprom_offset + geeprom_length) |
| geeprom_length = drvinfo.eedump_len - geeprom_offset; |
| |
| eeprom = calloc(1, sizeof(*eeprom)+geeprom_length); |
| if (!eeprom) { |
| perror("Cannot allocate memory for EEPROM data"); |
| return 75; |
| } |
| eeprom->cmd = ETHTOOL_GEEPROM; |
| eeprom->len = geeprom_length; |
| eeprom->offset = geeprom_offset; |
| err = send_ioctl(ctx, eeprom); |
| if (err < 0) { |
| perror("Cannot get EEPROM data"); |
| free(eeprom); |
| return 74; |
| } |
| err = dump_eeprom(geeprom_dump_raw, &drvinfo, eeprom); |
| free(eeprom); |
| |
| return err; |
| } |
| |
| static int do_seeprom(struct cmd_context *ctx) |
| { |
| int seeprom_changed = 0; |
| u32 seeprom_magic = 0; |
| u32 seeprom_length = -1; |
| u32 seeprom_offset = 0; |
| u8 seeprom_value = 0; |
| int seeprom_value_seen = 0; |
| struct cmdline_info cmdline_seeprom[] = { |
| { "magic", CMDL_U32, &seeprom_magic, NULL }, |
| { "offset", CMDL_U32, &seeprom_offset, NULL }, |
| { "length", CMDL_U32, &seeprom_length, NULL }, |
| { "value", CMDL_U8, &seeprom_value, NULL, |
| 0, &seeprom_value_seen }, |
| }; |
| int err; |
| struct ethtool_drvinfo drvinfo; |
| struct ethtool_eeprom *eeprom; |
| |
| parse_generic_cmdline(ctx, &seeprom_changed, |
| cmdline_seeprom, ARRAY_SIZE(cmdline_seeprom)); |
| |
| drvinfo.cmd = ETHTOOL_GDRVINFO; |
| err = send_ioctl(ctx, &drvinfo); |
| if (err < 0) { |
| perror("Cannot get driver information"); |
| return 74; |
| } |
| |
| if (seeprom_value_seen) |
| seeprom_length = 1; |
| |
| if (seeprom_length == -1) |
| seeprom_length = drvinfo.eedump_len; |
| |
| if (drvinfo.eedump_len < seeprom_offset + seeprom_length) { |
| fprintf(stderr, "offset & length out of bounds\n"); |
| return 1; |
| } |
| |
| eeprom = calloc(1, sizeof(*eeprom)+seeprom_length); |
| if (!eeprom) { |
| perror("Cannot allocate memory for EEPROM data"); |
| return 75; |
| } |
| |
| eeprom->cmd = ETHTOOL_SEEPROM; |
| eeprom->len = seeprom_length; |
| eeprom->offset = seeprom_offset; |
| eeprom->magic = seeprom_magic; |
| eeprom->data[0] = seeprom_value; |
| |
| /* Multi-byte write: read input from stdin */ |
| if (!seeprom_value_seen) { |
| if (fread(eeprom->data, eeprom->len, 1, stdin) != 1) { |
| fprintf(stderr, "not enough data from stdin\n"); |
| free(eeprom); |
| return 75; |
| } |
| if ((fgetc(stdin) != EOF) || !feof(stdin)) { |
| fprintf(stderr, "too much data from stdin\n"); |
| free(eeprom); |
| return 75; |
| } |
| } |
| |
| err = send_ioctl(ctx, eeprom); |
| if (err < 0) { |
| perror("Cannot set EEPROM data"); |
| err = 87; |
| } |
| free(eeprom); |
| |
| return err; |
| } |
| |
| static int do_test(struct cmd_context *ctx) |
| { |
| enum { |
| ONLINE = 0, |
| OFFLINE, |
| EXTERNAL_LB, |
| } test_type; |
| int err; |
| struct ethtool_test *test; |
| struct ethtool_gstrings *strings; |
| |
| if (ctx->argc > 1) |
| exit_bad_args(); |
| if (ctx->argc == 1) { |
| if (!strcmp(ctx->argp[0], "online")) |
| test_type = ONLINE; |
| else if (!strcmp(*ctx->argp, "offline")) |
| test_type = OFFLINE; |
| else if (!strcmp(*ctx->argp, "external_lb")) |
| test_type = EXTERNAL_LB; |
| else |
| exit_bad_args(); |
| } else { |
| test_type = OFFLINE; |
| } |
| |
| strings = get_stringset(ctx, ETH_SS_TEST, |
| offsetof(struct ethtool_drvinfo, testinfo_len), |
| 1); |
| if (!strings) { |
| perror("Cannot get strings"); |
| return 74; |
| } |
| |
| test = calloc(1, sizeof(*test) + strings->len * sizeof(u64)); |
| if (!test) { |
| perror("Cannot allocate memory for test info"); |
| free(strings); |
| return 73; |
| } |
| memset(test->data, 0, strings->len * sizeof(u64)); |
| test->cmd = ETHTOOL_TEST; |
| test->len = strings->len; |
| if (test_type == EXTERNAL_LB) |
| test->flags = (ETH_TEST_FL_OFFLINE | ETH_TEST_FL_EXTERNAL_LB); |
| else if (test_type == OFFLINE) |
| test->flags = ETH_TEST_FL_OFFLINE; |
| else |
| test->flags = 0; |
| err = send_ioctl(ctx, test); |
| if (err < 0) { |
| perror("Cannot test"); |
| free(test); |
| free(strings); |
| return 74; |
| } |
| |
| err = dump_test(test, strings); |
| free(test); |
| free(strings); |
| |
| return err; |
| } |
| |
| static int do_phys_id(struct cmd_context *ctx) |
| { |
| int err; |
| struct ethtool_value edata; |
| int phys_id_time; |
| |
| if (ctx->argc > 1) |
| exit_bad_args(); |
| if (ctx->argc == 1) |
| phys_id_time = get_int(*ctx->argp, 0); |
| else |
| phys_id_time = 0; |
| |
| edata.cmd = ETHTOOL_PHYS_ID; |
| edata.data = phys_id_time; |
| err = send_ioctl(ctx, &edata); |
| if (err < 0) |
| perror("Cannot identify NIC"); |
| |
| return err; |
| } |
| |
| static int do_gstats(struct cmd_context *ctx, int cmd, int stringset, |
| const char *name) |
| { |
| struct ethtool_gstrings *strings; |
| struct ethtool_stats *stats; |
| unsigned int n_stats, sz_stats, i; |
| int err; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| strings = get_stringset(ctx, stringset, |
| offsetof(struct ethtool_drvinfo, n_stats), |
| 0); |
| if (!strings) { |
| perror("Cannot get stats strings information"); |
| return 96; |
| } |
| |
| n_stats = strings->len; |
| if (n_stats < 1) { |
| fprintf(stderr, "no stats available\n"); |
| free(strings); |
| return 94; |
| } |
| |
| sz_stats = n_stats * sizeof(u64); |
| |
| stats = calloc(1, sz_stats + sizeof(struct ethtool_stats)); |
| if (!stats) { |
| fprintf(stderr, "no memory available\n"); |
| free(strings); |
| return 95; |
| } |
| |
| stats->cmd = cmd; |
| stats->n_stats = n_stats; |
| err = send_ioctl(ctx, stats); |
| if (err < 0) { |
| perror("Cannot get stats information"); |
| free(strings); |
| free(stats); |
| return 97; |
| } |
| |
| /* todo - pretty-print the strings per-driver */ |
| fprintf(stdout, "%s statistics:\n", name); |
| for (i = 0; i < n_stats; i++) { |
| fprintf(stdout, " %.*s: %llu\n", |
| ETH_GSTRING_LEN, |
| &strings->data[i * ETH_GSTRING_LEN], |
| stats->data[i]); |
| } |
| free(strings); |
| free(stats); |
| |
| return 0; |
| } |
| |
| static int do_gnicstats(struct cmd_context *ctx) |
| { |
| return do_gstats(ctx, ETHTOOL_GSTATS, ETH_SS_STATS, "NIC"); |
| } |
| |
| static int do_gphystats(struct cmd_context *ctx) |
| { |
| return do_gstats(ctx, ETHTOOL_GPHYSTATS, ETH_SS_PHY_STATS, "PHY"); |
| } |
| |
| static int do_srxntuple(struct cmd_context *ctx, |
| struct ethtool_rx_flow_spec *rx_rule_fs); |
| |
| static int do_srxclass(struct cmd_context *ctx) |
| { |
| int err; |
| |
| if (ctx->argc < 2) |
| exit_bad_args(); |
| |
| if (!strcmp(ctx->argp[0], "rx-flow-hash")) { |
| int rx_fhash_set; |
| u32 rx_fhash_val; |
| struct ethtool_rxnfc nfccmd; |
| bool flow_rss = false; |
| |
| if (ctx->argc == 5) { |
| if (strcmp(ctx->argp[3], "context")) |
| exit_bad_args(); |
| flow_rss = true; |
| nfccmd.rss_context = get_u32(ctx->argp[4], 0); |
| } else if (ctx->argc != 3) { |
| exit_bad_args(); |
| } |
| rx_fhash_set = rxflow_str_to_type(ctx->argp[1]); |
| if (!rx_fhash_set) |
| exit_bad_args(); |
| if (parse_rxfhashopts(ctx->argp[2], &rx_fhash_val) < 0) |
| exit_bad_args(); |
| |
| nfccmd.cmd = ETHTOOL_SRXFH; |
| nfccmd.flow_type = rx_fhash_set; |
| nfccmd.data = rx_fhash_val; |
| if (flow_rss) |
| nfccmd.flow_type |= FLOW_RSS; |
| |
| err = send_ioctl(ctx, &nfccmd); |
| if (err < 0) |
| perror("Cannot change RX network flow hashing options"); |
| } else if (!strcmp(ctx->argp[0], "flow-type")) { |
| struct ethtool_rx_flow_spec rx_rule_fs; |
| __u32 rss_context = 0; |
| |
| ctx->argc--; |
| ctx->argp++; |
| if (rxclass_parse_ruleopts(ctx, &rx_rule_fs, &rss_context) < 0) |
| exit_bad_args(); |
| |
| /* attempt to add rule via N-tuple specifier */ |
| err = do_srxntuple(ctx, &rx_rule_fs); |
| if (!err) |
| return 0; |
| |
| /* attempt to add rule via network flow classifier */ |
| err = rxclass_rule_ins(ctx, &rx_rule_fs, rss_context); |
| if (err < 0) { |
| fprintf(stderr, "Cannot insert" |
| " classification rule\n"); |
| return 1; |
| } |
| } else if (!strcmp(ctx->argp[0], "delete")) { |
| int rx_class_rule_del = |
| get_uint_range(ctx->argp[1], 0, INT_MAX); |
| |
| err = rxclass_rule_del(ctx, rx_class_rule_del); |
| |
| if (err < 0) { |
| fprintf(stderr, "Cannot delete" |
| " classification rule\n"); |
| return 1; |
| } |
| } else { |
| exit_bad_args(); |
| } |
| |
| return 0; |
| } |
| |
| static int do_grxclass(struct cmd_context *ctx) |
| { |
| struct ethtool_rxnfc nfccmd; |
| int err; |
| |
| if (ctx->argc > 0 && !strcmp(ctx->argp[0], "rx-flow-hash")) { |
| int rx_fhash_get; |
| bool flow_rss = false; |
| |
| if (ctx->argc == 4) { |
| if (strcmp(ctx->argp[2], "context")) |
| exit_bad_args(); |
| flow_rss = true; |
| nfccmd.rss_context = get_u32(ctx->argp[3], 0); |
| } else if (ctx->argc != 2) { |
| exit_bad_args(); |
| } |
| |
| rx_fhash_get = rxflow_str_to_type(ctx->argp[1]); |
| if (!rx_fhash_get) |
| exit_bad_args(); |
| |
| nfccmd.cmd = ETHTOOL_GRXFH; |
| nfccmd.flow_type = rx_fhash_get; |
| if (flow_rss) |
| nfccmd.flow_type |= FLOW_RSS; |
| err = send_ioctl(ctx, &nfccmd); |
| if (err < 0) { |
| perror("Cannot get RX network flow hashing options"); |
| } else { |
| if (flow_rss) |
| fprintf(stdout, "For RSS context %u:\n", |
| nfccmd.rss_context); |
| dump_rxfhash(rx_fhash_get, nfccmd.data); |
| } |
| } else if (ctx->argc == 2 && !strcmp(ctx->argp[0], "rule")) { |
| int rx_class_rule_get = |
| get_uint_range(ctx->argp[1], 0, INT_MAX); |
| |
| err = rxclass_rule_get(ctx, rx_class_rule_get); |
| if (err < 0) |
| fprintf(stderr, "Cannot get RX classification rule\n"); |
| } else if (ctx->argc == 0) { |
| nfccmd.cmd = ETHTOOL_GRXRINGS; |
| err = send_ioctl(ctx, &nfccmd); |
| if (err < 0) |
| perror("Cannot get RX rings"); |
| else |
| fprintf(stdout, "%d RX rings available\n", |
| (int)nfccmd.data); |
| |
| err = rxclass_rule_getall(ctx); |
| if (err < 0) |
| fprintf(stderr, "RX classification rule retrieval failed\n"); |
| |
| } else { |
| exit_bad_args(); |
| } |
| |
| return err ? 1 : 0; |
| } |
| |
| static void print_indir_table(struct cmd_context *ctx, |
| struct ethtool_rxnfc *ring_count, |
| u32 indir_size, u32 *indir) |
| { |
| u32 i; |
| |
| printf("RX flow hash indirection table for %s with %llu RX ring(s):\n", |
| ctx->devname, ring_count->data); |
| |
| if (!indir_size) |
| printf("Operation not supported\n"); |
| |
| for (i = 0; i < indir_size; i++) { |
| if (i % 8 == 0) |
| printf("%5u: ", i); |
| printf(" %5u", indir[i]); |
| if (i % 8 == 7 || i == indir_size - 1) |
| fputc('\n', stdout); |
| } |
| } |
| |
| static int do_grxfhindir(struct cmd_context *ctx, |
| struct ethtool_rxnfc *ring_count) |
| { |
| struct ethtool_rxfh_indir indir_head; |
| struct ethtool_rxfh_indir *indir; |
| int err; |
| |
| indir_head.cmd = ETHTOOL_GRXFHINDIR; |
| indir_head.size = 0; |
| err = send_ioctl(ctx, &indir_head); |
| if (err < 0) { |
| perror("Cannot get RX flow hash indirection table size"); |
| return 1; |
| } |
| |
| indir = malloc(sizeof(*indir) + |
| indir_head.size * sizeof(*indir->ring_index)); |
| if (!indir) { |
| perror("Cannot allocate memory for indirection table"); |
| return 1; |
| } |
| |
| indir->cmd = ETHTOOL_GRXFHINDIR; |
| indir->size = indir_head.size; |
| err = send_ioctl(ctx, indir); |
| if (err < 0) { |
| perror("Cannot get RX flow hash indirection table"); |
| free(indir); |
| return 1; |
| } |
| |
| print_indir_table(ctx, ring_count, indir->size, indir->ring_index); |
| |
| free(indir); |
| return 0; |
| } |
| |
| static int do_grxfh(struct cmd_context *ctx) |
| { |
| struct ethtool_gstrings *hfuncs = NULL; |
| struct ethtool_rxfh rss_head = {0}; |
| struct ethtool_rxnfc ring_count; |
| struct ethtool_rxfh *rss; |
| u32 rss_context = 0; |
| u32 i, indir_bytes; |
| int arg_num = 0; |
| char *hkey; |
| int err; |
| |
| while (arg_num < ctx->argc) { |
| if (!strcmp(ctx->argp[arg_num], "context")) { |
| ++arg_num; |
| rss_context = get_int_range(ctx->argp[arg_num], 0, 1, |
| ETH_RXFH_CONTEXT_ALLOC - 1); |
| ++arg_num; |
| } else { |
| exit_bad_args(); |
| } |
| } |
| |
| ring_count.cmd = ETHTOOL_GRXRINGS; |
| err = send_ioctl(ctx, &ring_count); |
| if (err < 0) { |
| perror("Cannot get RX ring count"); |
| return 1; |
| } |
| |
| rss_head.cmd = ETHTOOL_GRSSH; |
| rss_head.rss_context = rss_context; |
| err = send_ioctl(ctx, &rss_head); |
| if (err < 0 && errno == EOPNOTSUPP && !rss_context) { |
| return do_grxfhindir(ctx, &ring_count); |
| } else if (err < 0) { |
| perror("Cannot get RX flow hash indir size and/or key size"); |
| return 1; |
| } |
| |
| rss = calloc(1, sizeof(*rss) + |
| rss_head.indir_size * sizeof(rss_head.rss_config[0]) + |
| rss_head.key_size); |
| if (!rss) { |
| perror("Cannot allocate memory for RX flow hash config"); |
| return 1; |
| } |
| |
| rss->cmd = ETHTOOL_GRSSH; |
| rss->rss_context = rss_context; |
| rss->indir_size = rss_head.indir_size; |
| rss->key_size = rss_head.key_size; |
| err = send_ioctl(ctx, rss); |
| if (err < 0) { |
| perror("Cannot get RX flow hash configuration"); |
| free(rss); |
| return 1; |
| } |
| |
| print_indir_table(ctx, &ring_count, rss->indir_size, rss->rss_config); |
| |
| indir_bytes = rss->indir_size * sizeof(rss->rss_config[0]); |
| hkey = ((char *)rss->rss_config + indir_bytes); |
| |
| printf("RSS hash key:\n"); |
| if (!rss->key_size) |
| printf("Operation not supported\n"); |
| |
| for (i = 0; i < rss->key_size; i++) { |
| if (i == (rss->key_size - 1)) |
| printf("%02x\n", (u8) hkey[i]); |
| else |
| printf("%02x:", (u8) hkey[i]); |
| } |
| |
| printf("RSS hash function:\n"); |
| if (!rss->hfunc) { |
| printf(" Operation not supported\n"); |
| goto out; |
| } |
| |
| hfuncs = get_stringset(ctx, ETH_SS_RSS_HASH_FUNCS, 0, 1); |
| if (!hfuncs) { |
| perror("Cannot get hash functions names"); |
| free(rss); |
| return 1; |
| } |
| |
| for (i = 0; i < hfuncs->len; i++) |
| printf(" %s: %s\n", |
| (const char *)hfuncs->data + i * ETH_GSTRING_LEN, |
| (rss->hfunc & (1 << i)) ? "on" : "off"); |
| |
| out: |
| free(hfuncs); |
| free(rss); |
| return 0; |
| } |
| |
| static int fill_indir_table(u32 *indir_size, u32 *indir, int rxfhindir_default, |
| int rxfhindir_start, int rxfhindir_equal, |
| char **rxfhindir_weight, u32 num_weights) |
| { |
| u32 i; |
| |
| if (rxfhindir_equal) { |
| for (i = 0; i < *indir_size; i++) |
| indir[i] = rxfhindir_start + (i % rxfhindir_equal); |
| } else if (rxfhindir_weight) { |
| u32 j, weight, sum = 0, partial = 0; |
| |
| for (j = 0; j < num_weights; j++) { |
| weight = get_u32(rxfhindir_weight[j], 0); |
| sum += weight; |
| } |
| |
| if (sum == 0) { |
| fprintf(stderr, |
| "At least one weight must be non-zero\n"); |
| return 2; |
| } |
| |
| if (sum > *indir_size) { |
| fprintf(stderr, |
| "Total weight exceeds the size of the " |
| "indirection table\n"); |
| return 2; |
| } |
| |
| j = -1; |
| for (i = 0; i < *indir_size; i++) { |
| while (i >= (*indir_size) * partial / sum) { |
| j += 1; |
| weight = get_u32(rxfhindir_weight[j], 0); |
| partial += weight; |
| } |
| indir[i] = rxfhindir_start + j; |
| } |
| } else if (rxfhindir_default) { |
| /* "*indir_size == 0" ==> reset indir to default */ |
| *indir_size = 0; |
| } else { |
| *indir_size = ETH_RXFH_INDIR_NO_CHANGE; |
| } |
| |
| return 0; |
| } |
| |
| static int do_srxfhindir(struct cmd_context *ctx, int rxfhindir_default, |
| int rxfhindir_start, int rxfhindir_equal, |
| char **rxfhindir_weight, u32 num_weights) |
| { |
| struct ethtool_rxfh_indir indir_head; |
| struct ethtool_rxfh_indir *indir; |
| int err; |
| |
| indir_head.cmd = ETHTOOL_GRXFHINDIR; |
| indir_head.size = 0; |
| err = send_ioctl(ctx, &indir_head); |
| if (err < 0) { |
| perror("Cannot get RX flow hash indirection table size"); |
| return 1; |
| } |
| |
| indir = malloc(sizeof(*indir) + |
| indir_head.size * sizeof(*indir->ring_index)); |
| |
| if (!indir) { |
| perror("Cannot allocate memory for indirection table"); |
| return 1; |
| } |
| |
| indir->cmd = ETHTOOL_SRXFHINDIR; |
| indir->size = indir_head.size; |
| |
| if (fill_indir_table(&indir->size, indir->ring_index, |
| rxfhindir_default, rxfhindir_start, |
| rxfhindir_equal, rxfhindir_weight, num_weights)) { |
| free(indir); |
| return 1; |
| } |
| |
| err = send_ioctl(ctx, indir); |
| if (err < 0) { |
| perror("Cannot set RX flow hash indirection table"); |
| free(indir); |
| return 1; |
| } |
| |
| free(indir); |
| return 0; |
| } |
| |
| static int do_srxfh(struct cmd_context *ctx) |
| { |
| struct ethtool_rxfh rss_head = {0}; |
| struct ethtool_rxfh *rss = NULL; |
| struct ethtool_rxnfc ring_count; |
| int rxfhindir_equal = 0, rxfhindir_default = 0, rxfhindir_start = 0; |
| struct ethtool_gstrings *hfuncs = NULL; |
| char **rxfhindir_weight = NULL; |
| char *rxfhindir_key = NULL; |
| char *req_hfunc_name = NULL; |
| char *hfunc_name = NULL; |
| char *hkey = NULL; |
| int err = 0; |
| int i; |
| u32 arg_num = 0, indir_bytes = 0; |
| u32 req_hfunc = 0; |
| u32 entry_size = sizeof(rss_head.rss_config[0]); |
| u32 num_weights = 0; |
| u32 rss_context = 0; |
| int delete = 0; |
| |
| if (ctx->argc < 1) |
| exit_bad_args(); |
| |
| while (arg_num < ctx->argc) { |
| if (!strcmp(ctx->argp[arg_num], "equal")) { |
| ++arg_num; |
| rxfhindir_equal = get_int_range(ctx->argp[arg_num], |
| 0, 1, INT_MAX); |
| ++arg_num; |
| } else if (!strcmp(ctx->argp[arg_num], "start")) { |
| ++arg_num; |
| rxfhindir_start = get_int_range(ctx->argp[arg_num], |
| 0, 0, INT_MAX); |
| ++arg_num; |
| } else if (!strcmp(ctx->argp[arg_num], "weight")) { |
| ++arg_num; |
| rxfhindir_weight = ctx->argp + arg_num; |
| while (arg_num < ctx->argc && |
| isdigit((unsigned char)ctx->argp[arg_num][0])) { |
| ++arg_num; |
| ++num_weights; |
| } |
| if (!num_weights) |
| exit_bad_args(); |
| } else if (!strcmp(ctx->argp[arg_num], "hkey")) { |
| ++arg_num; |
| rxfhindir_key = ctx->argp[arg_num]; |
| if (!rxfhindir_key) |
| exit_bad_args(); |
| ++arg_num; |
| } else if (!strcmp(ctx->argp[arg_num], "default")) { |
| ++arg_num; |
| rxfhindir_default = 1; |
| } else if (!strcmp(ctx->argp[arg_num], "hfunc")) { |
| ++arg_num; |
| req_hfunc_name = ctx->argp[arg_num]; |
| if (!req_hfunc_name) |
| exit_bad_args(); |
| ++arg_num; |
| } else if (!strcmp(ctx->argp[arg_num], "context")) { |
| ++arg_num; |
| if(!strcmp(ctx->argp[arg_num], "new")) |
| rss_context = ETH_RXFH_CONTEXT_ALLOC; |
| else |
| rss_context = get_int_range( |
| ctx->argp[arg_num], 0, 1, |
| ETH_RXFH_CONTEXT_ALLOC - 1); |
| ++arg_num; |
| } else if (!strcmp(ctx->argp[arg_num], "delete")) { |
| ++arg_num; |
| delete = 1; |
| } else { |
| exit_bad_args(); |
| } |
| } |
| |
| if (rxfhindir_equal && rxfhindir_weight) { |
| fprintf(stderr, |
| "Equal and weight options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (rxfhindir_equal && rxfhindir_default) { |
| fprintf(stderr, |
| "Equal and default options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (rxfhindir_weight && rxfhindir_default) { |
| fprintf(stderr, |
| "Weight and default options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (rxfhindir_start && rxfhindir_default) { |
| fprintf(stderr, |
| "Start and default options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (rxfhindir_start && !(rxfhindir_equal || rxfhindir_weight)) { |
| fprintf(stderr, |
| "Start must be used with equal or weight options\n"); |
| return 1; |
| } |
| |
| if (rxfhindir_default && rss_context) { |
| fprintf(stderr, |
| "Default and context options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (delete && !rss_context) { |
| fprintf(stderr, "Delete option requires context option\n"); |
| return 1; |
| } |
| |
| if (delete && rxfhindir_weight) { |
| fprintf(stderr, |
| "Delete and weight options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (delete && rxfhindir_equal) { |
| fprintf(stderr, |
| "Delete and equal options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (delete && rxfhindir_default) { |
| fprintf(stderr, |
| "Delete and default options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| if (delete && rxfhindir_key) { |
| fprintf(stderr, |
| "Delete and hkey options are mutually exclusive\n"); |
| return 1; |
| } |
| |
| ring_count.cmd = ETHTOOL_GRXRINGS; |
| err = send_ioctl(ctx, &ring_count); |
| if (err < 0) { |
| perror("Cannot get RX ring count"); |
| return 1; |
| } |
| |
| rss_head.cmd = ETHTOOL_GRSSH; |
| err = send_ioctl(ctx, &rss_head); |
| if (err < 0 && errno == EOPNOTSUPP && !rxfhindir_key && |
| !req_hfunc_name && !rss_context) { |
| return do_srxfhindir(ctx, rxfhindir_default, rxfhindir_start, |
| rxfhindir_equal, rxfhindir_weight, |
| num_weights); |
| } else if (err < 0) { |
| perror("Cannot get RX flow hash indir size and key size"); |
| return 1; |
| } |
| |
| if (rxfhindir_key) { |
| err = parse_hkey(&hkey, rss_head.key_size, |
| rxfhindir_key); |
| if (err) |
| return err; |
| } |
| |
| if (rxfhindir_equal || rxfhindir_weight) |
| indir_bytes = rss_head.indir_size * entry_size; |
| |
| if (rss_head.hfunc && req_hfunc_name) { |
| hfuncs = get_stringset(ctx, ETH_SS_RSS_HASH_FUNCS, 0, 1); |
| if (!hfuncs) { |
| perror("Cannot get hash functions names"); |
| err = 1; |
| goto free; |
| } |
| |
| for (i = 0; i < hfuncs->len && !req_hfunc ; i++) { |
| hfunc_name = (char *)(hfuncs->data + |
| i * ETH_GSTRING_LEN); |
| if (!strncmp(hfunc_name, req_hfunc_name, |
| ETH_GSTRING_LEN)) |
| req_hfunc = (u32)1 << i; |
| } |
| |
| if (!req_hfunc) { |
| fprintf(stderr, |
| "Unknown hash function: %s\n", req_hfunc_name); |
| err = 1; |
| goto free; |
| } |
| } |
| |
| rss = calloc(1, sizeof(*rss) + indir_bytes + rss_head.key_size); |
| if (!rss) { |
| perror("Cannot allocate memory for RX flow hash config"); |
| err = 1; |
| goto free; |
| } |
| rss->cmd = ETHTOOL_SRSSH; |
| rss->rss_context = rss_context; |
| rss->hfunc = req_hfunc; |
| if (delete) { |
| rss->indir_size = rss->key_size = 0; |
| } else { |
| rss->indir_size = rss_head.indir_size; |
| rss->key_size = rss_head.key_size; |
| if (fill_indir_table(&rss->indir_size, rss->rss_config, |
| rxfhindir_default, rxfhindir_start, |
| rxfhindir_equal, rxfhindir_weight, |
| num_weights)) { |
| err = 1; |
| goto free; |
| } |
| } |
| |
| if (hkey) |
| memcpy((char *)rss->rss_config + indir_bytes, |
| hkey, rss->key_size); |
| else |
| rss->key_size = 0; |
| |
| err = send_ioctl(ctx, rss); |
| if (err < 0) { |
| perror("Cannot set RX flow hash configuration"); |
| err = 1; |
| } else if (rss_context == ETH_RXFH_CONTEXT_ALLOC) { |
| printf("New RSS context is %d\n", rss->rss_context); |
| } |
| |
| free: |
| free(hkey); |
| free(rss); |
| free(hfuncs); |
| return err; |
| } |
| |
| static int do_flash(struct cmd_context *ctx) |
| { |
| char *flash_file; |
| int flash_region; |
| struct ethtool_flash efl; |
| int err; |
| |
| if (ctx->argc < 1 || ctx->argc > 2) |
| exit_bad_args(); |
| flash_file = ctx->argp[0]; |
| if (ctx->argc == 2) { |
| flash_region = strtol(ctx->argp[1], NULL, 0); |
| if (flash_region < 0) |
| exit_bad_args(); |
| } else { |
| flash_region = -1; |
| } |
| |
| if (strlen(flash_file) > ETHTOOL_FLASH_MAX_FILENAME - 1) { |
| fprintf(stdout, "Filename too long\n"); |
| return 99; |
| } |
| |
| efl.cmd = ETHTOOL_FLASHDEV; |
| strcpy(efl.data, flash_file); |
| |
| if (flash_region < 0) |
| efl.region = ETHTOOL_FLASH_ALL_REGIONS; |
| else |
| efl.region = flash_region; |
| |
| err = send_ioctl(ctx, &efl); |
| if (err < 0) |
| perror("Flashing failed"); |
| |
| return err; |
| } |
| |
| static int do_permaddr(struct cmd_context *ctx) |
| { |
| int i, err; |
| struct ethtool_perm_addr *epaddr; |
| |
| epaddr = malloc(sizeof(struct ethtool_perm_addr) + MAX_ADDR_LEN); |
| if (!epaddr) { |
| perror("Cannot allocate memory for operation"); |
| return 1; |
| } |
| |
| epaddr->cmd = ETHTOOL_GPERMADDR; |
| epaddr->size = MAX_ADDR_LEN; |
| |
| err = send_ioctl(ctx, epaddr); |
| if (err < 0) |
| perror("Cannot read permanent address"); |
| else { |
| printf("Permanent address:"); |
| for (i = 0; i < epaddr->size; i++) |
| printf("%c%02x", (i == 0) ? ' ' : ':', |
| epaddr->data[i]); |
| printf("\n"); |
| } |
| free(epaddr); |
| |
| return err; |
| } |
| |
| static bool flow_type_is_ntuple_supported(__u32 flow_type) |
| { |
| switch (flow_type) { |
| case TCP_V4_FLOW: |
| case UDP_V4_FLOW: |
| case SCTP_V4_FLOW: |
| case AH_V4_FLOW: |
| case ESP_V4_FLOW: |
| case IPV4_USER_FLOW: |
| case ETHER_FLOW: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| static int flow_spec_to_ntuple(struct ethtool_rx_flow_spec *fsp, |
| struct ethtool_rx_ntuple_flow_spec *ntuple) |
| { |
| size_t i; |
| |
| /* verify location is not specified */ |
| if (fsp->location != RX_CLS_LOC_ANY) |
| return -1; |
| |
| /* destination MAC address in L3/L4 rules is not supported by ntuple */ |
| if (fsp->flow_type & FLOW_MAC_EXT) |
| return -1; |
| |
| /* verify ring cookie can transfer to action */ |
| if (fsp->ring_cookie > INT_MAX && fsp->ring_cookie < (u64)(-2)) |
| return -1; |
| |
| /* verify only one field is setting data field */ |
| if ((fsp->flow_type & FLOW_EXT) && |
| (fsp->m_ext.data[0] || fsp->m_ext.data[1]) && |
| fsp->m_ext.vlan_etype) |
| return -1; |
| |
| /* IPv6 flow types are not supported by ntuple */ |
| if (!flow_type_is_ntuple_supported(fsp->flow_type & ~FLOW_EXT)) |
| return -1; |
| |
| /* Set entire ntuple to ~0 to guarantee all masks are set */ |
| memset(ntuple, ~0, sizeof(*ntuple)); |
| |
| /* set non-filter values */ |
| ntuple->flow_type = fsp->flow_type; |
| ntuple->action = fsp->ring_cookie; |
| |
| /* |
| * Copy over header union, they are identical in layout however |
| * the ntuple union contains additional padding on the end |
| */ |
| memcpy(&ntuple->h_u, &fsp->h_u, sizeof(fsp->h_u)); |
| |
| /* |
| * The same rule mentioned above applies to the mask union. However, |
| * in addition we need to invert the mask bits to match the ntuple |
| * mask which is 1 for masked, versus 0 for masked as seen in nfc. |
| */ |
| memcpy(&ntuple->m_u, &fsp->m_u, sizeof(fsp->m_u)); |
| for (i = 0; i < sizeof(fsp->m_u); i++) |
| ntuple->m_u.hdata[i] ^= 0xFF; |
| |
| /* copy extended fields */ |
| if (fsp->flow_type & FLOW_EXT) { |
| ntuple->vlan_tag = |
| ntohs(fsp->h_ext.vlan_tci); |
| ntuple->vlan_tag_mask = |
| ~ntohs(fsp->m_ext.vlan_tci); |
| if (fsp->m_ext.vlan_etype) { |
| /* |
| * vlan_etype and user data are mutually exclusive |
| * in ntuple configuration as they occupy the same |
| * space. |
| */ |
| if (fsp->m_ext.data[0] || fsp->m_ext.data[1]) |
| return -1; |
| ntuple->data = |
| ntohl(fsp->h_ext.vlan_etype); |
| ntuple->data_mask = |
| ~(u64)ntohl(fsp->m_ext.vlan_etype); |
| } else { |
| ntuple->data = |
| (u64)ntohl(fsp->h_ext.data[0]) << 32; |
| ntuple->data |= |
| (u64)ntohl(fsp->h_ext.data[1]); |
| ntuple->data_mask = |
| (u64)ntohl(~fsp->m_ext.data[0]) << 32; |
| ntuple->data_mask |= |
| (u64)ntohl(~fsp->m_ext.data[1]); |
| } |
| } |
| |
| /* Mask out the extended bit, because ntuple does not know it! */ |
| ntuple->flow_type &= ~FLOW_EXT; |
| |
| return 0; |
| } |
| |
| static int do_srxntuple(struct cmd_context *ctx, |
| struct ethtool_rx_flow_spec *rx_rule_fs) |
| { |
| struct ethtool_rx_ntuple ntuplecmd; |
| struct ethtool_value eval; |
| int err; |
| |
| /* attempt to convert the flow classifier to an ntuple classifier */ |
| err = flow_spec_to_ntuple(rx_rule_fs, &ntuplecmd.fs); |
| if (err) |
| return -1; |
| |
| /* |
| * Check to see if the flag is set for N-tuple, this allows |
| * us to avoid the possible EINVAL response for the N-tuple |
| * flag not being set on the device |
| */ |
| eval.cmd = ETHTOOL_GFLAGS; |
| err = send_ioctl(ctx, &eval); |
| if (err || !(eval.data & ETH_FLAG_NTUPLE)) |
| return -1; |
| |
| /* send rule via N-tuple */ |
| ntuplecmd.cmd = ETHTOOL_SRXNTUPLE; |
| err = send_ioctl(ctx, &ntuplecmd); |
| |
| /* |
| * Display error only if response is something other than op not |
| * supported. It is possible that the interface uses the network |
| * flow classifier interface instead of N-tuple. |
| */ |
| if (err < 0) { |
| if (errno != EOPNOTSUPP) |
| perror("Cannot add new rule via N-tuple"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int do_writefwdump(struct ethtool_dump *dump, const char *dump_file) |
| { |
| int err = 0; |
| FILE *f; |
| size_t bytes; |
| |
| f = fopen(dump_file, "wb+"); |
| |
| if (!f) { |
| fprintf(stderr, "Can't open file %s: %s\n", |
| dump_file, strerror(errno)); |
| return 1; |
| } |
| bytes = fwrite(dump->data, 1, dump->len, f); |
| if (bytes != dump->len) { |
| fprintf(stderr, "Can not write all of dump data\n"); |
| err = 1; |
| } |
| if (fclose(f)) { |
| fprintf(stderr, "Can't close file %s: %s\n", |
| dump_file, strerror(errno)); |
| err = 1; |
| } |
| return err; |
| } |
| |
| static int do_getfwdump(struct cmd_context *ctx) |
| { |
| u32 dump_flag; |
| char *dump_file; |
| int err; |
| struct ethtool_dump edata; |
| struct ethtool_dump *data; |
| |
| if (ctx->argc == 2 && !strcmp(ctx->argp[0], "data")) { |
| dump_flag = ETHTOOL_GET_DUMP_DATA; |
| dump_file = ctx->argp[1]; |
| } else if (ctx->argc == 0) { |
| dump_flag = 0; |
| dump_file = NULL; |
| } else { |
| exit_bad_args(); |
| } |
| |
| edata.cmd = ETHTOOL_GET_DUMP_FLAG; |
| |
| err = send_ioctl(ctx, &edata); |
| if (err < 0) { |
| perror("Can not get dump level\n"); |
| return 1; |
| } |
| if (dump_flag != ETHTOOL_GET_DUMP_DATA) { |
| fprintf(stdout, "flag: %u, version: %u, length: %u\n", |
| edata.flag, edata.version, edata.len); |
| return 0; |
| } |
| data = calloc(1, offsetof(struct ethtool_dump, data) + edata.len); |
| if (!data) { |
| perror("Can not allocate enough memory\n"); |
| return 1; |
| } |
| data->cmd = ETHTOOL_GET_DUMP_DATA; |
| data->len = edata.len; |
| err = send_ioctl(ctx, data); |
| if (err < 0) { |
| perror("Can not get dump data\n"); |
| err = 1; |
| goto free; |
| } |
| err = do_writefwdump(data, dump_file); |
| free: |
| free(data); |
| return err; |
| } |
| |
| static int do_setfwdump(struct cmd_context *ctx) |
| { |
| u32 dump_flag; |
| int err; |
| struct ethtool_dump dump; |
| |
| if (ctx->argc != 1) |
| exit_bad_args(); |
| dump_flag = get_u32(ctx->argp[0], 0); |
| |
| dump.cmd = ETHTOOL_SET_DUMP; |
| dump.flag = dump_flag; |
| err = send_ioctl(ctx, &dump); |
| if (err < 0) { |
| perror("Can not set dump level\n"); |
| return 1; |
| } |
| return 0; |
| } |
| |
| static int do_gprivflags(struct cmd_context *ctx) |
| { |
| struct ethtool_gstrings *strings; |
| struct ethtool_value flags; |
| unsigned int i; |
| int max_len = 0, cur_len, rc; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| strings = get_stringset(ctx, ETH_SS_PRIV_FLAGS, |
| offsetof(struct ethtool_drvinfo, n_priv_flags), |
| 1); |
| if (!strings) { |
| perror("Cannot get private flag names"); |
| return 1; |
| } |
| if (strings->len == 0) { |
| fprintf(stderr, "No private flags defined\n"); |
| rc = 1; |
| goto err; |
| } |
| if (strings->len > 32) { |
| /* ETHTOOL_GPFLAGS can only cover 32 flags */ |
| fprintf(stderr, "Only showing first 32 private flags\n"); |
| strings->len = 32; |
| } |
| |
| flags.cmd = ETHTOOL_GPFLAGS; |
| if (send_ioctl(ctx, &flags)) { |
| perror("Cannot get private flags"); |
| rc = 1; |
| goto err; |
| } |
| |
| /* Find longest string and align all strings accordingly */ |
| for (i = 0; i < strings->len; i++) { |
| cur_len = strlen((const char *)strings->data + |
| i * ETH_GSTRING_LEN); |
| if (cur_len > max_len) |
| max_len = cur_len; |
| } |
| |
| printf("Private flags for %s:\n", ctx->devname); |
| for (i = 0; i < strings->len; i++) |
| printf("%-*s: %s\n", |
| max_len, |
| (const char *)strings->data + i * ETH_GSTRING_LEN, |
| (flags.data & (1U << i)) ? "on" : "off"); |
| |
| rc = 0; |
| |
| err: |
| free(strings); |
| return rc; |
| } |
| |
| static int do_sprivflags(struct cmd_context *ctx) |
| { |
| struct ethtool_gstrings *strings; |
| struct cmdline_info *cmdline; |
| struct ethtool_value flags; |
| u32 wanted_flags = 0, seen_flags = 0; |
| int any_changed, rc; |
| unsigned int i; |
| |
| strings = get_stringset(ctx, ETH_SS_PRIV_FLAGS, |
| offsetof(struct ethtool_drvinfo, n_priv_flags), |
| 1); |
| if (!strings) { |
| perror("Cannot get private flag names"); |
| return 1; |
| } |
| if (strings->len == 0) { |
| fprintf(stderr, "No private flags defined\n"); |
| rc = 1; |
| goto err; |
| } |
| if (strings->len > 32) { |
| /* ETHTOOL_{G,S}PFLAGS can only cover 32 flags */ |
| fprintf(stderr, "Only setting first 32 private flags\n"); |
| strings->len = 32; |
| } |
| |
| cmdline = calloc(strings->len, sizeof(*cmdline)); |
| if (!cmdline) { |
| perror("Cannot parse arguments"); |
| rc = 1; |
| goto err; |
| } |
| for (i = 0; i < strings->len; i++) { |
| cmdline[i].name = ((const char *)strings->data + |
| i * ETH_GSTRING_LEN); |
| cmdline[i].type = CMDL_FLAG; |
| cmdline[i].wanted_val = &wanted_flags; |
| cmdline[i].flag_val = 1U << i; |
| cmdline[i].seen_val = &seen_flags; |
| } |
| parse_generic_cmdline(ctx, &any_changed, cmdline, strings->len); |
| free(cmdline); |
| |
| flags.cmd = ETHTOOL_GPFLAGS; |
| if (send_ioctl(ctx, &flags)) { |
| perror("Cannot get private flags"); |
| rc = 1; |
| goto err; |
| } |
| |
| flags.cmd = ETHTOOL_SPFLAGS; |
| flags.data = (flags.data & ~seen_flags) | wanted_flags; |
| if (send_ioctl(ctx, &flags)) { |
| perror("Cannot set private flags"); |
| rc = 1; |
| goto err; |
| } |
| |
| rc = 0; |
| err: |
| free(strings); |
| return rc; |
| } |
| |
| static int do_tsinfo(struct cmd_context *ctx) |
| { |
| struct ethtool_ts_info info; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| fprintf(stdout, "Time stamping parameters for %s:\n", ctx->devname); |
| info.cmd = ETHTOOL_GET_TS_INFO; |
| if (send_ioctl(ctx, &info)) { |
| perror("Cannot get device time stamping settings"); |
| return -1; |
| } |
| dump_tsinfo(&info); |
| return 0; |
| } |
| |
| static int do_getmodule(struct cmd_context *ctx) |
| { |
| struct ethtool_modinfo modinfo; |
| struct ethtool_eeprom *eeprom; |
| u32 geeprom_offset = 0; |
| u32 geeprom_length = -1; |
| int geeprom_changed = 0; |
| int geeprom_dump_raw = 0; |
| int geeprom_dump_hex = 0; |
| int err; |
| |
| struct cmdline_info cmdline_geeprom[] = { |
| { "offset", CMDL_U32, &geeprom_offset, NULL }, |
| { "length", CMDL_U32, &geeprom_length, NULL }, |
| { "raw", CMDL_BOOL, &geeprom_dump_raw, NULL }, |
| { "hex", CMDL_BOOL, &geeprom_dump_hex, NULL }, |
| }; |
| |
| parse_generic_cmdline(ctx, &geeprom_changed, |
| cmdline_geeprom, ARRAY_SIZE(cmdline_geeprom)); |
| |
| if (geeprom_dump_raw && geeprom_dump_hex) { |
| printf("Hex and raw dump cannot be specified together\n"); |
| return 1; |
| } |
| |
| modinfo.cmd = ETHTOOL_GMODULEINFO; |
| err = send_ioctl(ctx, &modinfo); |
| if (err < 0) { |
| perror("Cannot get module EEPROM information"); |
| return 1; |
| } |
| |
| if (geeprom_length == -1) |
| geeprom_length = modinfo.eeprom_len; |
| |
| if (modinfo.eeprom_len < geeprom_offset + geeprom_length) |
| geeprom_length = modinfo.eeprom_len - geeprom_offset; |
| |
| eeprom = calloc(1, sizeof(*eeprom)+geeprom_length); |
| if (!eeprom) { |
| perror("Cannot allocate memory for Module EEPROM data"); |
| return 1; |
| } |
| |
| eeprom->cmd = ETHTOOL_GMODULEEEPROM; |
| eeprom->len = geeprom_length; |
| eeprom->offset = geeprom_offset; |
| err = send_ioctl(ctx, eeprom); |
| if (err < 0) { |
| perror("Cannot get Module EEPROM data"); |
| free(eeprom); |
| return 1; |
| } |
| |
| /* |
| * SFF-8079 EEPROM layout contains the memory available at A0 address on |
| * the PHY EEPROM. |
| * SFF-8472 defines a virtual extension of the EEPROM, where the |
| * microcontroller on the SFP/SFP+ generates a page at the A2 address, |
| * which contains data relative to optical diagnostics. |
| * The current kernel implementation returns a blob, which contains: |
| * - ETH_MODULE_SFF_8079 => The A0 page only. |
| * - ETH_MODULE_SFF_8472 => The A0 and A2 page concatenated. |
| */ |
| if (geeprom_dump_raw) { |
| fwrite(eeprom->data, 1, eeprom->len, stdout); |
| } else { |
| if (eeprom->offset != 0 || |
| (eeprom->len != modinfo.eeprom_len)) { |
| geeprom_dump_hex = 1; |
| } else if (!geeprom_dump_hex) { |
| switch (modinfo.type) { |
| #ifdef ETHTOOL_ENABLE_PRETTY_DUMP |
| case ETH_MODULE_SFF_8079: |
| sff8079_show_all(eeprom->data); |
| break; |
| case ETH_MODULE_SFF_8472: |
| sff8079_show_all(eeprom->data); |
| sff8472_show_all(eeprom->data); |
| break; |
| case ETH_MODULE_SFF_8436: |
| case ETH_MODULE_SFF_8636: |
| sff8636_show_all(eeprom->data, |
| modinfo.eeprom_len); |
| break; |
| #endif |
| default: |
| geeprom_dump_hex = 1; |
| break; |
| } |
| } |
| if (geeprom_dump_hex) |
| dump_hex(stdout, eeprom->data, |
| eeprom->len, eeprom->offset); |
| } |
| |
| free(eeprom); |
| |
| return 0; |
| } |
| |
| static int do_geee(struct cmd_context *ctx) |
| { |
| struct ethtool_eee eeecmd; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| eeecmd.cmd = ETHTOOL_GEEE; |
| if (send_ioctl(ctx, &eeecmd)) { |
| perror("Cannot get EEE settings"); |
| return 1; |
| } |
| |
| fprintf(stdout, "EEE Settings for %s:\n", ctx->devname); |
| dump_eeecmd(&eeecmd); |
| |
| return 0; |
| } |
| |
| static int do_seee(struct cmd_context *ctx) |
| { |
| int adv_c = -1, lpi_c = -1, lpi_time_c = -1, eee_c = -1; |
| int change = -1, change2 = 0; |
| struct ethtool_eee eeecmd; |
| struct cmdline_info cmdline_eee[] = { |
| { "advertise", CMDL_U32, &adv_c, &eeecmd.advertised }, |
| { "tx-lpi", CMDL_BOOL, &lpi_c, &eeecmd.tx_lpi_enabled }, |
| { "tx-timer", CMDL_U32, &lpi_time_c, &eeecmd.tx_lpi_timer}, |
| { "eee", CMDL_BOOL, &eee_c, &eeecmd.eee_enabled}, |
| }; |
| |
| if (ctx->argc == 0) |
| exit_bad_args(); |
| |
| parse_generic_cmdline(ctx, &change, cmdline_eee, |
| ARRAY_SIZE(cmdline_eee)); |
| |
| eeecmd.cmd = ETHTOOL_GEEE; |
| if (send_ioctl(ctx, &eeecmd)) { |
| perror("Cannot get EEE settings"); |
| return 1; |
| } |
| |
| do_generic_set(cmdline_eee, ARRAY_SIZE(cmdline_eee), &change2); |
| |
| if (change2) { |
| eeecmd.cmd = ETHTOOL_SEEE; |
| if (send_ioctl(ctx, &eeecmd)) { |
| perror("Cannot set EEE settings"); |
| return 1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int do_get_phy_tunable(struct cmd_context *ctx) |
| { |
| int argc = ctx->argc; |
| char **argp = ctx->argp; |
| |
| if (argc < 1) |
| exit_bad_args(); |
| |
| if (!strcmp(argp[0], "downshift")) { |
| struct { |
| struct ethtool_tunable ds; |
| u8 count; |
| } cont; |
| |
| cont.ds.cmd = ETHTOOL_PHY_GTUNABLE; |
| cont.ds.id = ETHTOOL_PHY_DOWNSHIFT; |
| cont.ds.type_id = ETHTOOL_TUNABLE_U8; |
| cont.ds.len = 1; |
| if (send_ioctl(ctx, &cont.ds) < 0) { |
| perror("Cannot Get PHY downshift count"); |
| return 87; |
| } |
| if (cont.count) |
| fprintf(stdout, "Downshift count: %d\n", cont.count); |
| else |
| fprintf(stdout, "Downshift disabled\n"); |
| } else if (!strcmp(argp[0], "fast-link-down")) { |
| struct { |
| struct ethtool_tunable fld; |
| u8 msecs; |
| } cont; |
| |
| cont.fld.cmd = ETHTOOL_PHY_GTUNABLE; |
| cont.fld.id = ETHTOOL_PHY_FAST_LINK_DOWN; |
| cont.fld.type_id = ETHTOOL_TUNABLE_U8; |
| cont.fld.len = 1; |
| if (send_ioctl(ctx, &cont.fld) < 0) { |
| perror("Cannot Get PHY Fast Link Down value"); |
| return 87; |
| } |
| |
| if (cont.msecs == ETHTOOL_PHY_FAST_LINK_DOWN_ON) |
| fprintf(stdout, "Fast Link Down enabled\n"); |
| else if (cont.msecs == ETHTOOL_PHY_FAST_LINK_DOWN_OFF) |
| fprintf(stdout, "Fast Link Down disabled\n"); |
| else |
| fprintf(stdout, "Fast Link Down enabled, %d msecs\n", |
| cont.msecs); |
| } else if (!strcmp(argp[0], "energy-detect-power-down")) { |
| struct { |
| struct ethtool_tunable ds; |
| u16 msecs; |
| } cont; |
| |
| cont.ds.cmd = ETHTOOL_PHY_GTUNABLE; |
| cont.ds.id = ETHTOOL_PHY_EDPD; |
| cont.ds.type_id = ETHTOOL_TUNABLE_U16; |
| cont.ds.len = 2; |
| if (send_ioctl(ctx, &cont.ds) < 0) { |
| perror("Cannot Get PHY Energy Detect Power Down value"); |
| return 87; |
| } |
| |
| if (cont.msecs == ETHTOOL_PHY_EDPD_DISABLE) |
| fprintf(stdout, "Energy Detect Power Down: disabled\n"); |
| else if (cont.msecs == ETHTOOL_PHY_EDPD_NO_TX) |
| fprintf(stdout, |
| "Energy Detect Power Down: enabled, TX disabled\n"); |
| else |
| fprintf(stdout, |
| "Energy Detect Power Down: enabled, TX %u msecs\n", |
| cont.msecs); |
| } else { |
| exit_bad_args(); |
| } |
| |
| return 0; |
| } |
| |
| static __u32 parse_reset(char *val, __u32 bitset, char *arg, __u32 *data) |
| { |
| __u32 bitval = 0; |
| int i; |
| |
| /* Check for component match */ |
| for (i = 0; val[i] != '\0'; i++) |
| if (arg[i] != val[i]) |
| return 0; |
| |
| /* Check if component has -shared specified or not */ |
| if (arg[i] == '\0') |
| bitval = bitset; |
| else if (!strcmp(arg+i, "-shared")) |
| bitval = bitset << ETH_RESET_SHARED_SHIFT; |
| |
| if (bitval) { |
| *data |= bitval; |
| return 1; |
| } |
| return 0; |
| } |
| |
| static int do_reset(struct cmd_context *ctx) |
| { |
| struct ethtool_value resetinfo; |
| __u32 data; |
| int argc = ctx->argc; |
| char **argp = ctx->argp; |
| int i; |
| |
| if (argc == 0) |
| exit_bad_args(); |
| |
| data = 0; |
| |
| for (i = 0; i < argc; i++) { |
| if (!strcmp(argp[i], "flags")) { |
| __u32 flags; |
| |
| i++; |
| if (i >= argc) |
| exit_bad_args(); |
| flags = strtoul(argp[i], NULL, 0); |
| if (flags == 0) |
| exit_bad_args(); |
| else |
| data |= flags; |
| } else if (parse_reset("mgmt", ETH_RESET_MGMT, |
| argp[i], &data)) { |
| } else if (parse_reset("irq", ETH_RESET_IRQ, |
| argp[i], &data)) { |
| } else if (parse_reset("dma", ETH_RESET_DMA, |
| argp[i], &data)) { |
| } else if (parse_reset("filter", ETH_RESET_FILTER, |
| argp[i], &data)) { |
| } else if (parse_reset("offload", ETH_RESET_OFFLOAD, |
| argp[i], &data)) { |
| } else if (parse_reset("mac", ETH_RESET_MAC, |
| argp[i], &data)) { |
| } else if (parse_reset("phy", ETH_RESET_PHY, |
| argp[i], &data)) { |
| } else if (parse_reset("ram", ETH_RESET_RAM, |
| argp[i], &data)) { |
| } else if (parse_reset("ap", ETH_RESET_AP, |
| argp[i], &data)) { |
| } else if (!strcmp(argp[i], "dedicated")) { |
| data |= ETH_RESET_DEDICATED; |
| } else if (!strcmp(argp[i], "all")) { |
| data |= ETH_RESET_ALL; |
| } else { |
| exit_bad_args(); |
| } |
| } |
| |
| resetinfo.cmd = ETHTOOL_RESET; |
| resetinfo.data = data; |
| fprintf(stdout, "ETHTOOL_RESET 0x%x\n", resetinfo.data); |
| |
| if (send_ioctl(ctx, &resetinfo)) { |
| perror("Cannot issue ETHTOOL_RESET"); |
| return 1; |
| } |
| |
| fprintf(stdout, "Components reset: 0x%x\n", data & ~resetinfo.data); |
| if (resetinfo.data) |
| fprintf(stdout, "Components not reset: 0x%x\n", resetinfo.data); |
| |
| return 0; |
| } |
| |
| static int parse_named_bool(struct cmd_context *ctx, const char *name, u8 *on) |
| { |
| if (ctx->argc < 2) |
| return 0; |
| |
| if (strcmp(*ctx->argp, name)) |
| return 0; |
| |
| if (!strcmp(*(ctx->argp + 1), "on")) { |
| *on = 1; |
| } else if (!strcmp(*(ctx->argp + 1), "off")) { |
| *on = 0; |
| } else { |
| fprintf(stderr, "Invalid boolean\n"); |
| exit_bad_args(); |
| } |
| |
| ctx->argc -= 2; |
| ctx->argp += 2; |
| |
| return 1; |
| } |
| |
| static int parse_named_uint(struct cmd_context *ctx, |
| const char *name, |
| unsigned long long *val, |
| unsigned long long max) |
| { |
| if (ctx->argc < 2) |
| return 0; |
| |
| if (strcmp(*ctx->argp, name)) |
| return 0; |
| |
| *val = get_uint_range(*(ctx->argp + 1), 0, max); |
| |
| ctx->argc -= 2; |
| ctx->argp += 2; |
| |
| return 1; |
| } |
| |
| static int parse_named_u8(struct cmd_context *ctx, const char *name, u8 *val) |
| { |
| unsigned long long val1; |
| int ret; |
| |
| ret = parse_named_uint(ctx, name, &val1, 0xff); |
| if (ret) |
| *val = val1; |
| |
| return ret; |
| } |
| |
| static int parse_named_u16(struct cmd_context *ctx, const char *name, u16 *val) |
| { |
| unsigned long long val1; |
| int ret; |
| |
| ret = parse_named_uint(ctx, name, &val1, 0xffff); |
| if (ret) |
| *val = val1; |
| |
| return ret; |
| } |
| |
| static int do_set_phy_tunable(struct cmd_context *ctx) |
| { |
| int err = 0; |
| u8 ds_cnt = DOWNSHIFT_DEV_DEFAULT_COUNT; |
| u8 ds_changed = 0, ds_has_cnt = 0, ds_enable = 0; |
| u8 fld_changed = 0, fld_enable = 0; |
| u8 fld_msecs = ETHTOOL_PHY_FAST_LINK_DOWN_ON; |
| u8 edpd_changed = 0, edpd_enable = 0; |
| u16 edpd_tx_interval = ETHTOOL_PHY_EDPD_DFLT_TX_MSECS; |
| |
| /* Parse arguments */ |
| if (parse_named_bool(ctx, "downshift", &ds_enable)) { |
| ds_changed = 1; |
| ds_has_cnt = parse_named_u8(ctx, "count", &ds_cnt); |
| } else if (parse_named_bool(ctx, "fast-link-down", &fld_enable)) { |
| fld_changed = 1; |
| if (fld_enable) |
| parse_named_u8(ctx, "msecs", &fld_msecs); |
| } else if (parse_named_bool(ctx, "energy-detect-power-down", |
| &edpd_enable)) { |
| edpd_changed = 1; |
| if (edpd_enable) |
| parse_named_u16(ctx, "msecs", &edpd_tx_interval); |
| } else { |
| exit_bad_args(); |
| } |
| |
| /* Validate parameters */ |
| if (ds_changed) { |
| if (!ds_enable && ds_has_cnt) { |
| fprintf(stderr, "'count' may not be set when downshift " |
| "is off.\n"); |
| exit_bad_args(); |
| } |
| |
| if (ds_enable && ds_has_cnt && ds_cnt == 0) { |
| fprintf(stderr, "'count' may not be zero.\n"); |
| exit_bad_args(); |
| } |
| |
| if (!ds_enable) |
| ds_cnt = DOWNSHIFT_DEV_DISABLE; |
| } else if (fld_changed) { |
| if (!fld_enable) |
| fld_msecs = ETHTOOL_PHY_FAST_LINK_DOWN_OFF; |
| else if (fld_msecs == ETHTOOL_PHY_FAST_LINK_DOWN_OFF) |
| exit_bad_args(); |
| } else if (edpd_changed) { |
| if (!edpd_enable) |
| edpd_tx_interval = ETHTOOL_PHY_EDPD_DISABLE; |
| else if (edpd_tx_interval == 0) |
| edpd_tx_interval = ETHTOOL_PHY_EDPD_NO_TX; |
| else if (edpd_tx_interval > ETHTOOL_PHY_EDPD_NO_TX) { |
| fprintf(stderr, "'msecs' max value is %d.\n", |
| (ETHTOOL_PHY_EDPD_NO_TX - 1)); |
| exit_bad_args(); |
| } |
| } |
| |
| /* Do it */ |
| if (ds_changed) { |
| struct { |
| struct ethtool_tunable ds; |
| u8 count; |
| } cont; |
| |
| cont.ds.cmd = ETHTOOL_PHY_STUNABLE; |
| cont.ds.id = ETHTOOL_PHY_DOWNSHIFT; |
| cont.ds.type_id = ETHTOOL_TUNABLE_U8; |
| cont.ds.len = 1; |
| cont.count = ds_cnt; |
| err = send_ioctl(ctx, &cont.ds); |
| if (err < 0) { |
| perror("Cannot Set PHY downshift count"); |
| err = 87; |
| } |
| } else if (fld_changed) { |
| struct { |
| struct ethtool_tunable fld; |
| u8 msecs; |
| } cont; |
| |
| cont.fld.cmd = ETHTOOL_PHY_STUNABLE; |
| cont.fld.id = ETHTOOL_PHY_FAST_LINK_DOWN; |
| cont.fld.type_id = ETHTOOL_TUNABLE_U8; |
| cont.fld.len = 1; |
| cont.msecs = fld_msecs; |
| err = send_ioctl(ctx, &cont.fld); |
| if (err < 0) { |
| perror("Cannot Set PHY Fast Link Down value"); |
| err = 87; |
| } |
| } else if (edpd_changed) { |
| struct { |
| struct ethtool_tunable fld; |
| u16 msecs; |
| } cont; |
| |
| cont.fld.cmd = ETHTOOL_PHY_STUNABLE; |
| cont.fld.id = ETHTOOL_PHY_EDPD; |
| cont.fld.type_id = ETHTOOL_TUNABLE_U16; |
| cont.fld.len = 2; |
| cont.msecs = edpd_tx_interval; |
| err = send_ioctl(ctx, &cont.fld); |
| if (err < 0) { |
| perror("Cannot Set PHY Energy Detect Power Down"); |
| err = 87; |
| } |
| } |
| |
| return err; |
| } |
| |
| static int fecmode_str_to_type(const char *str) |
| { |
| if (!strcasecmp(str, "auto")) |
| return ETHTOOL_FEC_AUTO; |
| if (!strcasecmp(str, "off")) |
| return ETHTOOL_FEC_OFF; |
| if (!strcasecmp(str, "rs")) |
| return ETHTOOL_FEC_RS; |
| if (!strcasecmp(str, "baser")) |
| return ETHTOOL_FEC_BASER; |
| |
| return 0; |
| } |
| |
| static int do_gfec(struct cmd_context *ctx) |
| { |
| struct ethtool_fecparam feccmd = { 0 }; |
| int rv; |
| |
| if (ctx->argc != 0) |
| exit_bad_args(); |
| |
| feccmd.cmd = ETHTOOL_GFECPARAM; |
| rv = send_ioctl(ctx, &feccmd); |
| if (rv != 0) { |
| perror("Cannot get FEC settings"); |
| return rv; |
| } |
| |
| fprintf(stdout, "FEC parameters for %s:\n", ctx->devname); |
| fprintf(stdout, "Configured FEC encodings:"); |
| dump_fec(feccmd.fec); |
| fprintf(stdout, "\n"); |
| |
| fprintf(stdout, "Active FEC encoding:"); |
| dump_fec(feccmd.active_fec); |
| fprintf(stdout, "\n"); |
| |
| return 0; |
| } |
| |
| static int do_sfec(struct cmd_context *ctx) |
| { |
| enum { ARG_NONE, ARG_ENCODING } state = ARG_NONE; |
| struct ethtool_fecparam feccmd; |
| int fecmode = 0, newmode; |
| int rv, i; |
| |
| for (i = 0; i < ctx->argc; i++) { |
| if (!strcmp(ctx->argp[i], "encoding")) { |
| state = ARG_ENCODING; |
| continue; |
| } |
| if (state == ARG_ENCODING) { |
| newmode = fecmode_str_to_type(ctx->argp[i]); |
| if (!newmode) |
| exit_bad_args(); |
| fecmode |= newmode; |
| continue; |
| } |
| exit_bad_args(); |
| } |
| |
| if (!fecmode) |
| exit_bad_args(); |
| |
| feccmd.cmd = ETHTOOL_SFECPARAM; |
| feccmd.fec = fecmode; |
| rv = send_ioctl(ctx, &feccmd); |
| if (rv != 0) { |
| perror("Cannot set FEC settings"); |
| return rv; |
| } |
| |
| return 0; |
| } |
| |
| static int do_perqueue(struct cmd_context *ctx); |
| |
| #ifndef TEST_ETHTOOL |
| int send_ioctl(struct cmd_context *ctx, void *cmd) |
| { |
| ctx->ifr.ifr_data = cmd; |
| return ioctl(ctx->fd, SIOCETHTOOL, &ctx->ifr); |
| } |
| #endif |
| |
| static int show_usage(struct cmd_context *ctx); |
| |
| static const struct option { |
| const char *opts; |
| int want_device; |
| int (*func)(struct cmd_context *); |
| char *help; |
| char *opthelp; |
| } args[] = { |
| { "-s|--change", 1, do_sset, "Change generic options", |
| " [ speed %d ]\n" |
| " [ duplex half|full ]\n" |
| " [ port tp|aui|bnc|mii|fibre ]\n" |
| " [ mdix auto|on|off ]\n" |
| " [ autoneg on|off ]\n" |
| " [ advertise %x ]\n" |
| " [ phyad %d ]\n" |
| " [ xcvr internal|external ]\n" |
| " [ wol p|u|m|b|a|g|s|f|d... ]\n" |
| " [ sopass %x:%x:%x:%x:%x:%x ]\n" |
| " [ msglvl %d | msglvl type on|off ... ]\n" }, |
| { "-a|--show-pause", 1, do_gpause, "Show pause options" }, |
| { "-A|--pause", 1, do_spause, "Set pause options", |
| " [ autoneg on|off ]\n" |
| " [ rx on|off ]\n" |
| " [ tx on|off ]\n" }, |
| { "-c|--show-coalesce", 1, do_gcoalesce, "Show coalesce options" }, |
| { "-C|--coalesce", 1, do_scoalesce, "Set coalesce options", |
| " [adaptive-rx on|off]\n" |
| " [adaptive-tx on|off]\n" |
| " [rx-usecs N]\n" |
| " [rx-frames N]\n" |
| " [rx-usecs-irq N]\n" |
| " [rx-frames-irq N]\n" |
| " [tx-usecs N]\n" |
| " [tx-frames N]\n" |
| " [tx-usecs-irq N]\n" |
| " [tx-frames-irq N]\n" |
| " [stats-block-usecs N]\n" |
| " [pkt-rate-low N]\n" |
| " [rx-usecs-low N]\n" |
| " [rx-frames-low N]\n" |
| " [tx-usecs-low N]\n" |
| " [tx-frames-low N]\n" |
| " [pkt-rate-high N]\n" |
| " [rx-usecs-high N]\n" |
| " [rx-frames-high N]\n" |
| " [tx-usecs-high N]\n" |
| " [tx-frames-high N]\n" |
| " [sample-interval N]\n" }, |
| { "-g|--show-ring", 1, do_gring, "Query RX/TX ring parameters" }, |
| { "-G|--set-ring", 1, do_sring, "Set RX/TX ring parameters", |
| " [ rx N ]\n" |
| " [ rx-mini N ]\n" |
| " [ rx-jumbo N ]\n" |
| " [ tx N ]\n" }, |
| { "-k|--show-features|--show-offload", 1, do_gfeatures, |
| "Get state of protocol offload and other features" }, |
| { "-K|--features|--offload", 1, do_sfeatures, |
| "Set protocol offload and other features", |
| " FEATURE on|off ...\n" }, |
| { "-i|--driver", 1, do_gdrv, "Show driver information" }, |
| { "-d|--register-dump", 1, do_gregs, "Do a register dump", |
| " [ raw on|off ]\n" |
| " [ file FILENAME ]\n" }, |
| { "-e|--eeprom-dump", 1, do_geeprom, "Do a EEPROM dump", |
| " [ raw on|off ]\n" |
| " [ offset N ]\n" |
| " [ length N ]\n" }, |
| { "-E|--change-eeprom", 1, do_seeprom, |
| "Change bytes in device EEPROM", |
| " [ magic N ]\n" |
| " [ offset N ]\n" |
| " [ length N ]\n" |
| " [ value N ]\n" }, |
| { "-r|--negotiate", 1, do_nway_rst, "Restart N-WAY negotiation" }, |
| { "-p|--identify", 1, do_phys_id, |
| "Show visible port identification (e.g. blinking)", |
| " [ TIME-IN-SECONDS ]\n" }, |
| { "-t|--test", 1, do_test, "Execute adapter self test", |
| " [ online | offline | external_lb ]\n" }, |
| { "-S|--statistics", 1, do_gnicstats, "Show adapter statistics" }, |
| { "--phy-statistics", 1, do_gphystats, |
| "Show phy statistics" }, |
| { "-n|-u|--show-nfc|--show-ntuple", 1, do_grxclass, |
| "Show Rx network flow classification options or rules", |
| " [ rx-flow-hash tcp4|udp4|ah4|esp4|sctp4|" |
| "tcp6|udp6|ah6|esp6|sctp6 [context %d] |\n" |
| " rule %d ]\n" }, |
| { "-N|-U|--config-nfc|--config-ntuple", 1, do_srxclass, |
| "Configure Rx network flow classification options or rules", |
| " rx-flow-hash tcp4|udp4|ah4|esp4|sctp4|" |
| "tcp6|udp6|ah6|esp6|sctp6 m|v|t|s|d|f|n|r... [context %d] |\n" |
| " flow-type ether|ip4|tcp4|udp4|sctp4|ah4|esp4|" |
| "ip6|tcp6|udp6|ah6|esp6|sctp6\n" |
| " [ src %x:%x:%x:%x:%x:%x [m %x:%x:%x:%x:%x:%x] ]\n" |
| " [ dst %x:%x:%x:%x:%x:%x [m %x:%x:%x:%x:%x:%x] ]\n" |
| " [ proto %d [m %x] ]\n" |
| " [ src-ip IP-ADDRESS [m IP-ADDRESS] ]\n" |
| " [ dst-ip IP-ADDRESS [m IP-ADDRESS] ]\n" |
| " [ tos %d [m %x] ]\n" |
| " [ tclass %d [m %x] ]\n" |
| " [ l4proto %d [m %x] ]\n" |
| " [ src-port %d [m %x] ]\n" |
| " [ dst-port %d [m %x] ]\n" |
| " [ spi %d [m %x] ]\n" |
| " [ vlan-etype %x [m %x] ]\n" |
| " [ vlan %x [m %x] ]\n" |
| " [ user-def %x [m %x] ]\n" |
| " [ dst-mac %x:%x:%x:%x:%x:%x [m %x:%x:%x:%x:%x:%x] ]\n" |
| " [ action %d ] | [ vf %d queue %d ]\n" |
| " [ context %d ]\n" |
| " [ loc %d]] |\n" |
| " delete %d\n" }, |
| { "-T|--show-time-stamping", 1, do_tsinfo, |
| "Show time stamping capabilities" }, |
| { "-x|--show-rxfh-indir|--show-rxfh", 1, do_grxfh, |
| "Show Rx flow hash indirection table and/or RSS hash key", |
| " [ context %d ]\n" }, |
| { "-X|--set-rxfh-indir|--rxfh", 1, do_srxfh, |
| "Set Rx flow hash indirection table and/or RSS hash key", |
| " [ context %d|new ]\n" |
| " [ equal N | weight W0 W1 ... | default ]\n" |
| " [ hkey %x:%x:%x:%x:%x:.... ]\n" |
| " [ hfunc FUNC ]\n" |
| " [ delete ]\n" }, |
| { "-f|--flash", 1, do_flash, |
| "Flash firmware image from the specified file to a region on the device", |
| " FILENAME [ REGION-NUMBER-TO-FLASH ]\n" }, |
| { "-P|--show-permaddr", 1, do_permaddr, |
| "Show permanent hardware address" }, |
| { "-w|--get-dump", 1, do_getfwdump, |
| "Get dump flag, data", |
| " [ data FILENAME ]\n" }, |
| { "-W|--set-dump", 1, do_setfwdump, |
| "Set dump flag of the device", |
| " N\n"}, |
| { "-l|--show-channels", 1, do_gchannels, "Query Channels" }, |
| { "-L|--set-channels", 1, do_schannels, "Set Channels", |
| " [ rx N ]\n" |
| " [ tx N ]\n" |
| " [ other N ]\n" |
| " [ combined N ]\n" }, |
| { "--show-priv-flags", 1, do_gprivflags, "Query private flags" }, |
| { "--set-priv-flags", 1, do_sprivflags, "Set private flags", |
| " FLAG on|off ...\n" }, |
| { "-m|--dump-module-eeprom|--module-info", 1, do_getmodule, |
| "Query/Decode Module EEPROM information and optical diagnostics if available", |
| " [ raw on|off ]\n" |
| " [ hex on|off ]\n" |
| " [ offset N ]\n" |
| " [ length N ]\n" }, |
| { "--show-eee", 1, do_geee, "Show EEE settings"}, |
| { "--set-eee", 1, do_seee, "Set EEE settings", |
| " [ eee on|off ]\n" |
| " [ advertise %x ]\n" |
| " [ tx-lpi on|off ]\n" |
| " [ tx-timer %d ]\n"}, |
| { "--set-phy-tunable", 1, do_set_phy_tunable, "Set PHY tunable", |
| " [ downshift on|off [count N] ]\n" |
| " [ fast-link-down on|off [msecs N] ]\n" |
| " [ energy-detect-power-down on|off [msecs N] ]\n"}, |
| { "--get-phy-tunable", 1, do_get_phy_tunable, "Get PHY tunable", |
| " [ downshift ]\n" |
| " [ fast-link-down ]\n" |
| " [ energy-detect-power-down ]\n"}, |
| { "--reset", 1, do_reset, "Reset components", |
| " [ flags %x ]\n" |
| " [ mgmt ]\n" |
| " [ mgmt-shared ]\n" |
| " [ irq ]\n" |
| " [ irq-shared ]\n" |
| " [ dma ]\n" |
| " [ dma-shared ]\n" |
| " [ filter ]\n" |
| " [ filter-shared ]\n" |
| " [ offload ]\n" |
| " [ offload-shared ]\n" |
| " [ mac ]\n" |
| " [ mac-shared ]\n" |
| " [ phy ]\n" |
| " [ phy-shared ]\n" |
| " [ ram ]\n" |
| " [ ram-shared ]\n" |
| " [ ap ]\n" |
| " [ ap-shared ]\n" |
| " [ dedicated ]\n" |
| " [ all ]\n"}, |
| { "--show-fec", 1, do_gfec, "Show FEC settings"}, |
| { "--set-fec", 1, do_sfec, "Set FEC settings", |
| " [ encoding auto|off|rs|baser [...]]\n"}, |
| { "-Q|--per-queue", 1, do_perqueue, "Apply per-queue command." |
| "The supported sub commands include --show-coalesce, --coalesce", |
| " [queue_mask %x] SUB_COMMAND\n"}, |
| { "-h|--help", 0, show_usage, "Show this help" }, |
| { "--version", 0, do_version, "Show version number" }, |
| {} |
| }; |
| |
| static int show_usage(struct cmd_context *ctx maybe_unused) |
| { |
| int i; |
| |
| /* ethtool -h */ |
| fprintf(stdout, PACKAGE " version " VERSION "\n"); |
| fprintf(stdout, |
| "Usage:\n" |
| " ethtool DEVNAME\t" |
| "Display standard information about device\n"); |
| for (i = 0; args[i].opts; i++) { |
| fputs(" ethtool ", stdout); |
| fprintf(stdout, "%s %s\t%s\n", |
| args[i].opts, |
| args[i].want_device ? "DEVNAME" : "\t", |
| args[i].help); |
| if (args[i].opthelp) |
| fputs(args[i].opthelp, stdout); |
| } |
| |
| return 0; |
| } |
| |
| static int find_option(char *arg) |
| { |
| const char *opt; |
| size_t len; |
| int k; |
| |
| for (k = 0; args[k].opts; k++) { |
| opt = args[k].opts; |
| for (;;) { |
| len = strcspn(opt, "|"); |
| if (strncmp(arg, opt, len) == 0 && arg[len] == 0) |
| return k; |
| |
| if (opt[len] == 0) |
| break; |
| opt += len + 1; |
| } |
| } |
| |
| return -1; |
| } |
| |
| #define MAX(x, y) (x > y ? x : y) |
| |
| static int find_max_num_queues(struct cmd_context *ctx) |
| { |
| struct ethtool_channels echannels; |
| |
| echannels.cmd = ETHTOOL_GCHANNELS; |
| if (send_ioctl(ctx, &echannels)) |
| return -1; |
| |
| return MAX(echannels.rx_count, echannels.tx_count) + |
| echannels.combined_count; |
| } |
| |
| static struct ethtool_per_queue_op * |
| get_per_queue_coalesce(struct cmd_context *ctx, __u32 *queue_mask, int n_queues) |
| { |
| struct ethtool_per_queue_op *per_queue_opt; |
| |
| per_queue_opt = malloc(sizeof(*per_queue_opt) + n_queues * |
| sizeof(struct ethtool_coalesce)); |
| if (!per_queue_opt) |
| return NULL; |
| |
| memcpy(per_queue_opt->queue_mask, queue_mask, |
| __KERNEL_DIV_ROUND_UP(MAX_NUM_QUEUE, 32) * sizeof(__u32)); |
| per_queue_opt->cmd = ETHTOOL_PERQUEUE; |
| per_queue_opt->sub_command = ETHTOOL_GCOALESCE; |
| if (send_ioctl(ctx, per_queue_opt)) { |
| free(per_queue_opt); |
| perror("Cannot get device per queue parameters"); |
| return NULL; |
| } |
| |
| return per_queue_opt; |
| } |
| |
| static void set_per_queue_coalesce(struct cmd_context *ctx, |
| struct ethtool_per_queue_op *per_queue_opt, |
| int n_queues) |
| { |
| struct ethtool_coalesce ecoal; |
| DECLARE_COALESCE_OPTION_VARS(); |
| struct cmdline_info cmdline_coalesce[] = COALESCE_CMDLINE_INFO(ecoal); |
| __u32 *queue_mask = per_queue_opt->queue_mask; |
| struct ethtool_coalesce *ecoal_q; |
| int gcoalesce_changed = 0; |
| int i, idx = 0; |
| |
| parse_generic_cmdline(ctx, &gcoalesce_changed, |
| cmdline_coalesce, ARRAY_SIZE(cmdline_coalesce)); |
| |
| ecoal_q = (struct ethtool_coalesce *)(per_queue_opt + 1); |
| for (i = 0; i < __KERNEL_DIV_ROUND_UP(MAX_NUM_QUEUE, 32); i++) { |
| int queue = i * 32; |
| __u32 mask = queue_mask[i]; |
| |
| while (mask > 0) { |
| if (mask & 0x1) { |
| int changed = 0; |
| |
| memcpy(&ecoal, ecoal_q + idx, |
| sizeof(struct ethtool_coalesce)); |
| do_generic_set(cmdline_coalesce, |
| ARRAY_SIZE(cmdline_coalesce), |
| &changed); |
| if (!changed) |
| fprintf(stderr, |
| "Queue %d, no coalesce parameters changed\n", |
| queue); |
| memcpy(ecoal_q + idx, &ecoal, |
| sizeof(struct ethtool_coalesce)); |
| idx++; |
| } |
| mask = mask >> 1; |
| queue++; |
| } |
| if (idx == n_queues) |
| break; |
| } |
| |
| per_queue_opt->cmd = ETHTOOL_PERQUEUE; |
| per_queue_opt->sub_command = ETHTOOL_SCOALESCE; |
| |
| if (send_ioctl(ctx, per_queue_opt)) |
| perror("Cannot set device per queue parameters"); |
| } |
| |
| static int do_perqueue(struct cmd_context *ctx) |
| { |
| struct ethtool_per_queue_op *per_queue_opt; |
| __u32 queue_mask[__KERNEL_DIV_ROUND_UP(MAX_NUM_QUEUE, 32)] = {0}; |
| int i, n_queues = 0; |
| |
| if (ctx->argc == 0) |
| exit_bad_args(); |
| |
| /* |
| * The sub commands will be applied to |
| * all queues if no queue_mask set |
| */ |
| if (strncmp(*ctx->argp, "queue_mask", 11)) { |
| n_queues = find_max_num_queues(ctx); |
| if (n_queues < 0) { |
| perror("Cannot get number of queues"); |
| return -EFAULT; |
| } else if (n_queues > MAX_NUM_QUEUE) { |
| n_queues = MAX_NUM_QUEUE; |
| } |
| for (i = 0; i < n_queues / 32; i++) |
| queue_mask[i] = ~0; |
| if (n_queues % 32) |
| queue_mask[i] = (1 << (n_queues - i * 32)) - 1; |
| fprintf(stdout, |
| "The sub commands will be applied to all %d queues\n", |
| n_queues); |
| } else { |
| ctx->argc--; |
| ctx->argp++; |
| if (parse_hex_u32_bitmap(*ctx->argp, MAX_NUM_QUEUE, |
| queue_mask)) { |
| fprintf(stdout, "Invalid queue mask\n"); |
| return -1; |
| } |
| for (i = 0; i < __KERNEL_DIV_ROUND_UP(MAX_NUM_QUEUE, 32); i++) { |
| __u32 mask = queue_mask[i]; |
| |
| while (mask > 0) { |
| if (mask & 0x1) |
| n_queues++; |
| mask = mask >> 1; |
| } |
| } |
| ctx->argc--; |
| ctx->argp++; |
| } |
| |
| i = find_option(ctx->argp[0]); |
| if (i < 0) |
| exit_bad_args(); |
| |
| if (strstr(args[i].opts, "--show-coalesce") != NULL) { |
| per_queue_opt = get_per_queue_coalesce(ctx, queue_mask, |
| n_queues); |
| if (per_queue_opt == NULL) { |
| perror("Cannot get device per queue parameters"); |
| return -EFAULT; |
| } |
| dump_per_queue_coalesce(per_queue_opt, queue_mask, n_queues); |
| free(per_queue_opt); |
| } else if (strstr(args[i].opts, "--coalesce") != NULL) { |
| ctx->argc--; |
| ctx->argp++; |
| per_queue_opt = get_per_queue_coalesce(ctx, queue_mask, |
| n_queues); |
| if (per_queue_opt == NULL) { |
| perror("Cannot get device per queue parameters"); |
| return -EFAULT; |
| } |
| set_per_queue_coalesce(ctx, per_queue_opt, n_queues); |
| free(per_queue_opt); |
| } else { |
| perror("The subcommand is not supported yet"); |
| return -EOPNOTSUPP; |
| } |
| |
| return 0; |
| } |
| |
| int main(int argc, char **argp) |
| { |
| int (*func)(struct cmd_context *); |
| int want_device; |
| struct cmd_context ctx; |
| int k; |
| |
| init_global_link_mode_masks(); |
| |
| /* Skip command name */ |
| argp++; |
| argc--; |
| |
| /* First argument must be either a valid option or a device |
| * name to get settings for (which we don't expect to begin |
| * with '-'). |
| */ |
| if (argc == 0) |
| exit_bad_args(); |
| |
| k = find_option(*argp); |
| if (k >= 0) { |
| argp++; |
| argc--; |
| func = args[k].func; |
| want_device = args[k].want_device; |
| goto opt_found; |
| } |
| if ((*argp)[0] == '-') |
| exit_bad_args(); |
| func = do_gset; |
| want_device = 1; |
| |
| opt_found: |
| if (want_device) { |
| ctx.devname = *argp++; |
| argc--; |
| |
| if (ctx.devname == NULL) |
| exit_bad_args(); |
| if (strlen(ctx.devname) >= IFNAMSIZ) |
| exit_bad_args(); |
| |
| /* Setup our control structures. */ |
| memset(&ctx.ifr, 0, sizeof(ctx.ifr)); |
| strcpy(ctx.ifr.ifr_name, ctx.devname); |
| |
| /* Open control socket. */ |
| ctx.fd = socket(AF_INET, SOCK_DGRAM, 0); |
| if (ctx.fd < 0) |
| ctx.fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); |
| if (ctx.fd < 0) { |
| perror("Cannot get control socket"); |
| return 70; |
| } |
| } else { |
| ctx.fd = -1; |
| } |
| |
| ctx.argc = argc; |
| ctx.argp = argp; |
| |
| return func(&ctx); |
| } |