colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e9c76f375b62bec8d65dc6bf0e7594e68a212418
NetworkManager/src/platform/nm-platform-utils.c
Thomas Haller e9c76f375b platform: avoid valgrind warning about uninitialised memory in _ioctl_call() 
==6207== Syscall param ioctl(SIOCETHTOOL) points to uninitialised byte(s)
==6207==    at 0x514603B: ioctl (syscall-template.S:78)
==6207==    by 0x19FC2F: _ioctl_call (nm-platform-utils.c:183)
==6207==    by 0x1A026B: _ethtool_call_handle (nm-platform-utils.c:319)
==6207==    by 0x1A031F: ethtool_get_stringset (nm-platform-utils.c:378)
==6207==    by 0x1A03BC: ethtool_get_stringset_index (nm-platform-utils.c:414)
==6207==    by 0x1A181E: nmp_utils_ethtool_supports_vlans (nm-platform-utils.c:912)
==6207==    by 0x1756D7: link_supports_vlans (nm-linux-platform.c:6508)
==6207==    by 0x1A81D8: nm_platform_link_supports_vlans (nm-platform.c:1536)
==6207==    by 0x14B96B: test_internal (test-link.c:602)
==6207==    by 0x4F5C18D: test_case_run (gtestutils.c:2597)
==6207==    by 0x4F5C18D: g_test_run_suite_internal (gtestutils.c:2685)
==6207==    by 0x4F5BF33: g_test_run_suite_internal (gtestutils.c:2697)
==6207==    by 0x4F5C679: g_test_run_suite (gtestutils.c:2772)
==6207==    by 0x4F5C694: g_test_run (gtestutils.c:2007)
==6207==    by 0x166B4D: main (test-common.c:2092)
==6207==  Address 0x1ffeffeecf is on thread 1's stack
==6207==  in frame #1, created by _ioctl_call (nm-platform-utils.c:110)
==6207==

"ifname" is the stack-allocated array "known_ifnames" of suitable
IFNAMSIZ bytes. But it may not be fully initialized, so using memcpy()
to copy the string leads to unintialized warning.

We really should only copy the valid bytes, either with strcpy() or our
nm_utils_ifname_cpy() wrapper.

Fixes: 856322562e ('platform/ethtool,mii: retry ioctl when interface name was renamed for ehttool/mii')
2019-05-16 10:17:04 +02:00

1464 lines
48 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* nm-platform.c - Handle runtime kernel networking configuration
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2015 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-platform-utils.h"
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <linux/mii.h>
#include <linux/if.h>
#include <linux/version.h>
#include <linux/rtnetlink.h>
#include <fcntl.h>
#include <libudev.h>
#include "nm-utils.h"
#include "nm-setting-wired.h"
#include "nm-libnm-core-intern/nm-ethtool-utils.h"
#include "nm-core-utils.h"
#define ONOFF(bool_val) ((bool_val) ? "on" : "off")
/******************************************************************************
* utils
*****************************************************************************/
extern char *if_indextoname (unsigned __ifindex, char *__ifname);
unsigned if_nametoindex (const char *__ifname);
const char *
nmp_utils_if_indextoname (int ifindex, char *out_ifname/*IFNAMSIZ*/)
{
g_return_val_if_fail (ifindex > 0, NULL);
g_return_val_if_fail (out_ifname, NULL);
return if_indextoname (ifindex, out_ifname);
}
int
nmp_utils_if_nametoindex (const char *ifname)
{
g_return_val_if_fail (ifname, 0);
return if_nametoindex (ifname);
}
/*****************************************************************************/
typedef struct {
int fd;
const int ifindex;
char ifname[IFNAMSIZ];
} SocketHandle;
#define SOCKET_HANDLE_INIT(_ifindex) \
{ \
.fd = -1, \
.ifindex = (_ifindex), \
}
static void
_nm_auto_socket_handle (SocketHandle *shandle)
{
if (shandle->fd >= 0)
nm_close (shandle->fd);
}
#define nm_auto_socket_handle nm_auto(_nm_auto_socket_handle)
/*****************************************************************************/
typedef enum {
IOCTL_CALL_DATA_TYPE_NONE,
IOCTL_CALL_DATA_TYPE_IFRDATA,
IOCTL_CALL_DATA_TYPE_IFRU,
} IoctlCallDataType;
static int
_ioctl_call (const char *log_ioctl_type,
const char *log_subtype,
unsigned long int ioctl_request,
int ifindex,
int *inout_fd,
char *inout_ifname,
IoctlCallDataType edata_type,
gpointer edata,
gsize edata_size,
struct ifreq *out_ifreq)
{
nm_auto_close int fd_close = -1;
int fd;
int r;
gpointer edata_backup = NULL;
gs_free gpointer edata_backup_free = NULL;
guint try_count;
char known_ifnames[2][IFNAMSIZ];
const char *failure_reason = NULL;
struct ifreq ifr;
nm_assert (ifindex > 0);
nm_assert (NM_IN_SET (edata_type, IOCTL_CALL_DATA_TYPE_NONE,
IOCTL_CALL_DATA_TYPE_IFRDATA,
IOCTL_CALL_DATA_TYPE_IFRU));
nm_assert (edata_type != IOCTL_CALL_DATA_TYPE_NONE || edata_size == 0);
nm_assert (edata_type != IOCTL_CALL_DATA_TYPE_IFRDATA || edata_size > 0);
nm_assert (edata_type != IOCTL_CALL_DATA_TYPE_IFRU || (edata_size > 0 && edata_size <= sizeof (ifr.ifr_ifru)));
nm_assert (edata_size == 0 || edata);
/* open a file descriptor (or use the one provided). */
if ( inout_fd
&& *inout_fd >= 0)
fd = *inout_fd;
else {
fd = socket (PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
if (fd < 0) {
r = -NM_ERRNO_NATIVE (errno);
failure_reason = "failed creating socket or ioctl";
goto out;
}
if (inout_fd)
*inout_fd = fd;
else
fd_close = fd;
}
/* resolve the ifindex to name (or use the one provided). */
if ( inout_ifname
&& inout_ifname[0])
nm_utils_ifname_cpy (known_ifnames[0], inout_ifname);
else {
if (!nmp_utils_if_indextoname (ifindex, known_ifnames[0])) {
failure_reason = "cannot resolve ifindex";
r = -ENODEV;
goto out;
}
if (inout_ifname)
nm_utils_ifname_cpy (inout_ifname, known_ifnames[0]);
}
/* we might need to retry the request. Backup edata so that we can
* restore it on retry. */
if (edata_size > 0)
edata_backup = nm_memdup_maybe_a (500, edata, edata_size, &edata_backup_free);
try_count = 0;
again:
{
const char *ifname = known_ifnames[try_count % 2];
nm_assert (ifindex > 0);
nm_assert (ifname && nm_utils_is_valid_iface_name (ifname, NULL));
nm_assert (fd >= 0);
memset (&ifr, 0, sizeof (ifr));
nm_utils_ifname_cpy (ifr.ifr_name, ifname);
if (edata_type == IOCTL_CALL_DATA_TYPE_IFRDATA)
ifr.ifr_data = edata;
else if (edata_type == IOCTL_CALL_DATA_TYPE_IFRU)
memcpy (&ifr.ifr_ifru, edata, NM_MIN (edata_size, sizeof (ifr.ifr_ifru)));
if (ioctl (fd, ioctl_request, &ifr) < 0) {
r = -NM_ERRNO_NATIVE (errno);
nm_log_trace (LOGD_PLATFORM, "%s[%d]: %s, %s: failed: %s",
log_ioctl_type,
ifindex,
log_subtype,
ifname,
nm_strerror_native (-r));
} else {
r = 0;
nm_log_trace (LOGD_PLATFORM, "%s[%d]: %s, %s: success",
log_ioctl_type,
ifindex,
log_subtype,
ifname);
}
}
try_count++;
/* resolve the name again to see whether the ifindex still has the same name. */
if (!nmp_utils_if_indextoname (ifindex, known_ifnames[try_count % 2])) {
/* we could not find the ifindex again. Probably the device just got
* removed.
*
* In both cases we return the error code we got from ioctl above.
* Either it failed because the device was gone already or it still
* managed to complete the call. In both cases, the error code is good. */
failure_reason = "cannot resolve ifindex after ioctl call. Probably the device was just removed";
goto out;
}
/* check whether the ifname changed in the meantime. If yes, would render the result
* invalid. Note that this cannot detect every race regarding renames, for example:
*
* - if_indextoname(#10) gives eth0
* - rename(#10) => eth0_tmp
* - rename(#11) => eth0
* - ioctl(eth0) (wrongly fetching #11, formerly eth1)
* - rename(#11) => eth_something
* - rename(#10) => eth0
* - if_indextoname(#10) gives eth0
*/
if (!nm_streq (known_ifnames[0], known_ifnames[1])) {
gboolean retry;
/* we detected a possible(!) rename.
*
* For getters it's straight forward to just retry the call.
*
* For setters we also always retry. If our previous call operated on the right device,
* calling it again should have no bad effect (just setting the same thing more than once).
*
* The only potential bad thing is if there was a race involving swapping names, and we just
* set the ioctl option on the wrong device. But then the bad thing already happend and
* we cannot detect it (nor do anything about it). At least, we can retry and set the
* option on the right interface. */
retry = (try_count < 5);
nm_log_trace (LOGD_PLATFORM, "%s[%d]: %s: rename detected from \"%s\" to \"%s\". %s",
log_ioctl_type,
ifindex,
log_subtype,
known_ifnames[(try_count - 1) % 2],
known_ifnames[ try_count % 2],
retry
? "Retry"
: "No retry");
if (inout_ifname)
nm_utils_ifname_cpy (inout_ifname, known_ifnames[try_count % 2]);
if (retry) {
if (edata_size > 0)
memcpy (edata, edata_backup, edata_size);
goto again;
}
}
out:
if (failure_reason) {
nm_log_trace (LOGD_PLATFORM, "%s[%d]: %s: %s: %s",
log_ioctl_type,
ifindex,
log_subtype,
failure_reason,
r < 0
? nm_strerror_native (-r)
: "assume success");
}
if (r >= 0)
NM_SET_OUT (out_ifreq, ifr);
return r;
}
/******************************************************************************
* ethtool
*****************************************************************************/
NM_UTILS_ENUM2STR_DEFINE_STATIC (_ethtool_cmd_to_string, guint32,
NM_UTILS_ENUM2STR (ETHTOOL_GDRVINFO, "ETHTOOL_GDRVINFO"),
NM_UTILS_ENUM2STR (ETHTOOL_GFEATURES, "ETHTOOL_GFEATURES"),
NM_UTILS_ENUM2STR (ETHTOOL_GLINK, "ETHTOOL_GLINK"),
NM_UTILS_ENUM2STR (ETHTOOL_GPERMADDR, "ETHTOOL_GPERMADDR"),
NM_UTILS_ENUM2STR (ETHTOOL_GSET, "ETHTOOL_GSET"),
NM_UTILS_ENUM2STR (ETHTOOL_GSSET_INFO, "ETHTOOL_GSSET_INFO"),
NM_UTILS_ENUM2STR (ETHTOOL_GSTATS, "ETHTOOL_GSTATS"),
NM_UTILS_ENUM2STR (ETHTOOL_GSTRINGS, "ETHTOOL_GSTRINGS"),
NM_UTILS_ENUM2STR (ETHTOOL_GWOL, "ETHTOOL_GWOL"),
NM_UTILS_ENUM2STR (ETHTOOL_SFEATURES, "ETHTOOL_SFEATURES"),
NM_UTILS_ENUM2STR (ETHTOOL_SSET, "ETHTOOL_SSET"),
NM_UTILS_ENUM2STR (ETHTOOL_SWOL, "ETHTOOL_SWOL"),
);
static const char *
_ethtool_edata_to_string (gpointer edata, gsize edata_size, char *sbuf, gsize sbuf_len)
{
nm_assert (edata);
nm_assert (edata_size >= sizeof (guint32));
nm_assert ((((intptr_t) edata) % _nm_alignof (guint32)) == 0);
return _ethtool_cmd_to_string (*((guint32 *) edata), sbuf, sbuf_len);
}
/*****************************************************************************/
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
#define ethtool_cmd_speed(pedata) ((pedata)->speed)
#define ethtool_cmd_speed_set(pedata, speed) \
G_STMT_START { (pedata)->speed = (guint16) (speed); } G_STMT_END
#endif
static int
_ethtool_call_handle (SocketHandle *shandle, gpointer edata, gsize edata_size)
{
char sbuf[50];
return _ioctl_call ("ethtool",
_ethtool_edata_to_string (edata, edata_size, sbuf, sizeof (sbuf)),
SIOCETHTOOL,
shandle->ifindex,
&shandle->fd,
shandle->ifname,
IOCTL_CALL_DATA_TYPE_IFRDATA,
edata,
edata_size,
NULL);
}
static int
_ethtool_call_once (int ifindex, gpointer edata, gsize edata_size)
{
char sbuf[50];
return _ioctl_call ("ethtool",
_ethtool_edata_to_string (edata, edata_size, sbuf, sizeof (sbuf)),
SIOCETHTOOL,
ifindex,
NULL,
NULL,
IOCTL_CALL_DATA_TYPE_IFRDATA,
edata,
edata_size,
NULL);
}
/*****************************************************************************/
static struct ethtool_gstrings *
ethtool_get_stringset (SocketHandle *shandle, int stringset_id)
{
struct {
struct ethtool_sset_info info;
guint32 sentinel;
} sset_info = {
.info.cmd = ETHTOOL_GSSET_INFO,
.info.reserved = 0,
.info.sset_mask = (1ULL << stringset_id),
};
gs_free struct ethtool_gstrings *gstrings = NULL;
gsize gstrings_len;
guint32 i, len;
if (_ethtool_call_handle (shandle, &sset_info, sizeof (sset_info)) < 0)
return NULL;
if (!sset_info.info.sset_mask)
return NULL;
len = sset_info.info.data[0];
gstrings_len = sizeof (*gstrings) + (len * ETH_GSTRING_LEN);
gstrings = g_malloc0 (gstrings_len);
gstrings->cmd = ETHTOOL_GSTRINGS;
gstrings->string_set = stringset_id;
gstrings->len = len;
if (gstrings->len > 0) {
if (_ethtool_call_handle (shandle, gstrings, gstrings_len) < 0)
return NULL;
for (i = 0; i < gstrings->len; i++) {
/* ensure NUL terminated */
gstrings->data[i * ETH_GSTRING_LEN + (ETH_GSTRING_LEN - 1)] = '\0';
}
}
return g_steal_pointer (&gstrings);
}
static int
ethtool_gstrings_find (const struct ethtool_gstrings *gstrings, const char *needle)
{
guint32 i;
/* ethtool_get_stringset() always ensures NUL terminated strings at ETH_GSTRING_LEN.
* that means, we cannot possibly request longer names. */
nm_assert (needle && strlen (needle) < ETH_GSTRING_LEN);
for (i = 0; i < gstrings->len; i++) {
if (nm_streq ((char *) &gstrings->data[i * ETH_GSTRING_LEN], needle))
return i;
}
return -1;
}
static int
ethtool_get_stringset_index (SocketHandle *shandle, int stringset_id, const char *needle)
{
gs_free struct ethtool_gstrings *gstrings = NULL;
/* ethtool_get_stringset() always ensures NUL terminated strings at ETH_GSTRING_LEN.
* that means, we cannot possibly request longer names. */
nm_assert (needle && strlen (needle) < ETH_GSTRING_LEN);
gstrings = ethtool_get_stringset (shandle, stringset_id);
if (gstrings)
return ethtool_gstrings_find (gstrings, needle);
return -1;
}
/*****************************************************************************/
static const NMEthtoolFeatureInfo _ethtool_feature_infos[_NM_ETHTOOL_ID_FEATURE_NUM] = {
#define ETHT_FEAT(eid, ...) \
{ \
.ethtool_id = eid, \
.n_kernel_names = NM_NARG (__VA_ARGS__), \
.kernel_names = ((const char *const[]) { __VA_ARGS__ }), \
}
/* the order does only matter for one thing: if it happens that more than one NMEthtoolID
* reference the same kernel-name, then the one that is mentioned *later* will win in
* case these NMEthtoolIDs are set. That mostly only makes sense for ethtool-ids which
* refer to multiple features ("feature-tso"), while also having more specific ids
* ("feature-tx-tcp-segmentation"). */
/* names from ethtool utility, which are aliases for multiple features. */
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_SG, "tx-scatter-gather",
"tx-scatter-gather-fraglist"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TSO, "tx-tcp-segmentation",
"tx-tcp-ecn-segmentation",
"tx-tcp-mangleid-segmentation",
"tx-tcp6-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX, "tx-checksum-ipv4",
"tx-checksum-ip-generic",
"tx-checksum-ipv6",
"tx-checksum-fcoe-crc",
"tx-checksum-sctp"),
/* names from ethtool utility, which are aliases for one feature. */
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_GRO, "rx-gro"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_GSO, "tx-generic-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_LRO, "rx-lro"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_NTUPLE, "rx-ntuple-filter"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX, "rx-checksum"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RXHASH, "rx-hashing"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RXVLAN, "rx-vlan-hw-parse"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TXVLAN, "tx-vlan-hw-insert"),
/* names of features, as known by kernel. */
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_ESP_HW_OFFLOAD, "esp-hw-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_ESP_TX_CSUM_HW_OFFLOAD, "esp-tx-csum-hw-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_FCOE_MTU, "fcoe-mtu"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_HIGHDMA, "highdma"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_HW_TC_OFFLOAD, "hw-tc-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_L2_FWD_OFFLOAD, "l2-fwd-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_LOOPBACK, "loopback"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_ALL, "rx-all"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_FCS, "rx-fcs"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_GRO_HW, "rx-gro-hw"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_UDP_TUNNEL_PORT_OFFLOAD, "rx-udp_tunnel-port-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_VLAN_FILTER, "rx-vlan-filter"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_VLAN_STAG_FILTER, "rx-vlan-stag-filter"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_RX_VLAN_STAG_HW_PARSE, "rx-vlan-stag-hw-parse"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TLS_HW_RECORD, "tls-hw-record"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TLS_HW_TX_OFFLOAD, "tls-hw-tx-offload"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_CHECKSUM_FCOE_CRC, "tx-checksum-fcoe-crc"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_CHECKSUM_IPV4, "tx-checksum-ipv4"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_CHECKSUM_IPV6, "tx-checksum-ipv6"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_CHECKSUM_IP_GENERIC, "tx-checksum-ip-generic"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_CHECKSUM_SCTP, "tx-checksum-sctp"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_ESP_SEGMENTATION, "tx-esp-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_FCOE_SEGMENTATION, "tx-fcoe-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_GRE_CSUM_SEGMENTATION, "tx-gre-csum-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_GRE_SEGMENTATION, "tx-gre-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_GSO_PARTIAL, "tx-gso-partial"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_GSO_ROBUST, "tx-gso-robust"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_IPXIP4_SEGMENTATION, "tx-ipxip4-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_IPXIP6_SEGMENTATION, "tx-ipxip6-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_NOCACHE_COPY, "tx-nocache-copy"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_SCATTER_GATHER, "tx-scatter-gather"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_SCATTER_GATHER_FRAGLIST, "tx-scatter-gather-fraglist"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_SCTP_SEGMENTATION, "tx-sctp-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_TCP6_SEGMENTATION, "tx-tcp6-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_TCP_ECN_SEGMENTATION, "tx-tcp-ecn-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_TCP_MANGLEID_SEGMENTATION, "tx-tcp-mangleid-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_TCP_SEGMENTATION, "tx-tcp-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_UDP_SEGMENTATION, "tx-udp-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_UDP_TNL_CSUM_SEGMENTATION, "tx-udp_tnl-csum-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_UDP_TNL_SEGMENTATION, "tx-udp_tnl-segmentation"),
ETHT_FEAT (NM_ETHTOOL_ID_FEATURE_TX_VLAN_STAG_HW_INSERT, "tx-vlan-stag-hw-insert"),
};
/* the number of kernel features that we handle. It essentially is the sum of all
* kernel_names. So, all ethtool-ids that reference exactly one kernel-name
* (_NM_ETHTOOL_ID_FEATURE_NUM) + some extra, for ethtool-ids that are aliases
* for multiple kernel-names. */
#define N_ETHTOOL_KERNEL_FEATURES (((guint) _NM_ETHTOOL_ID_FEATURE_NUM) + 8u)
static void
_ASSERT_ethtool_feature_infos (void)
{
#if NM_MORE_ASSERTS > 10
guint i, k, n;
bool found[_NM_ETHTOOL_ID_FEATURE_NUM] = { };
G_STATIC_ASSERT_EXPR (G_N_ELEMENTS (_ethtool_feature_infos) == _NM_ETHTOOL_ID_FEATURE_NUM);
n = 0;
for (i = 0; i < G_N_ELEMENTS (_ethtool_feature_infos); i++) {
NMEthtoolFeatureState kstate;
const NMEthtoolFeatureInfo *inf = &_ethtool_feature_infos[i];
g_assert (inf->ethtool_id >= _NM_ETHTOOL_ID_FEATURE_FIRST);
g_assert (inf->ethtool_id <= _NM_ETHTOOL_ID_FEATURE_LAST);
g_assert (inf->n_kernel_names > 0);
for (k = 0; k < i; k++)
g_assert (inf->ethtool_id != _ethtool_feature_infos[k].ethtool_id);
g_assert (!found[inf->ethtool_id - _NM_ETHTOOL_ID_FEATURE_FIRST]);
found[inf->ethtool_id - _NM_ETHTOOL_ID_FEATURE_FIRST] = TRUE;
kstate.idx_kernel_name = inf->n_kernel_names - 1;
g_assert ((guint) kstate.idx_kernel_name == (guint) (inf->n_kernel_names - 1));
n += inf->n_kernel_names;
for (k = 0; k < inf->n_kernel_names; k++) {
g_assert (nm_utils_strv_find_first ((char **) inf->kernel_names,
k,
inf->kernel_names[k]) < 0);
}
}
for (i = 0; i < _NM_ETHTOOL_ID_FEATURE_NUM; i++)
g_assert (found[i]);
g_assert (n == N_ETHTOOL_KERNEL_FEATURES);
#endif
}
static NMEthtoolFeatureStates *
ethtool_get_features (SocketHandle *shandle)
{
gs_free NMEthtoolFeatureStates *states = NULL;
gs_free struct ethtool_gstrings *ss_features = NULL;
_ASSERT_ethtool_feature_infos ();
ss_features = ethtool_get_stringset (shandle, ETH_SS_FEATURES);
if (!ss_features)
return NULL;
if (ss_features->len > 0) {
gs_free struct ethtool_gfeatures *gfeatures_free = NULL;
struct ethtool_gfeatures *gfeatures;
gsize gfeatures_len;
guint idx;
const NMEthtoolFeatureState *states_list0 = NULL;
const NMEthtoolFeatureState *const*states_plist0 = NULL;
guint states_plist_n = 0;
gfeatures_len = sizeof (struct ethtool_gfeatures)
+ (NM_DIV_ROUND_UP (ss_features->len, 32u) * sizeof(gfeatures->features[0]));
gfeatures = nm_malloc0_maybe_a (300, gfeatures_len, &gfeatures_free);
gfeatures->cmd = ETHTOOL_GFEATURES;
gfeatures->size = NM_DIV_ROUND_UP (ss_features->len, 32u);
if (_ethtool_call_handle (shandle, gfeatures, gfeatures_len) < 0)
return NULL;
for (idx = 0; idx < G_N_ELEMENTS (_ethtool_feature_infos); idx++) {
const NMEthtoolFeatureInfo *info = &_ethtool_feature_infos[idx];
guint idx_kernel_name;
for (idx_kernel_name = 0; idx_kernel_name < info->n_kernel_names; idx_kernel_name++) {
NMEthtoolFeatureState *kstate;
const char *kernel_name = info->kernel_names[idx_kernel_name];
int i_feature;
guint i_block;
guint32 i_flag;
i_feature = ethtool_gstrings_find (ss_features, kernel_name);
if (i_feature < 0)
continue;
i_block = ((guint) i_feature) / 32u;
i_flag = (guint32) (1u << (((guint) i_feature) % 32u));
if (!states) {
states = g_malloc0 (sizeof (NMEthtoolFeatureStates)
+ (N_ETHTOOL_KERNEL_FEATURES * sizeof (NMEthtoolFeatureState))
+ ((N_ETHTOOL_KERNEL_FEATURES + G_N_ELEMENTS (_ethtool_feature_infos)) * sizeof (NMEthtoolFeatureState *)));
states_list0 = &states->states_list[0];
states_plist0 = (gpointer) &states_list0[N_ETHTOOL_KERNEL_FEATURES];
states->n_ss_features = ss_features->len;
}
nm_assert (states->n_states < N_ETHTOOL_KERNEL_FEATURES);
kstate = (NMEthtoolFeatureState *) &states_list0[states->n_states];
states->n_states++;
kstate->info = info;
kstate->idx_ss_features = i_feature;
kstate->idx_kernel_name = idx_kernel_name;
kstate->available = !!(gfeatures->features[i_block].available & i_flag);
kstate->requested = !!(gfeatures->features[i_block].requested & i_flag);
kstate->active = !!(gfeatures->features[i_block].active & i_flag);
kstate->never_changed = !!(gfeatures->features[i_block].never_changed & i_flag);
nm_assert (states_plist_n < N_ETHTOOL_KERNEL_FEATURES + G_N_ELEMENTS (_ethtool_feature_infos));
if (!states->states_indexed[info->ethtool_id - _NM_ETHTOOL_ID_FEATURE_FIRST])
states->states_indexed[info->ethtool_id - _NM_ETHTOOL_ID_FEATURE_FIRST] = &states_plist0[states_plist_n];
((const NMEthtoolFeatureState **) states_plist0)[states_plist_n] = kstate;
states_plist_n++;
}
if (states && states->states_indexed[info->ethtool_id - _NM_ETHTOOL_ID_FEATURE_FIRST]) {
nm_assert (states_plist_n < N_ETHTOOL_KERNEL_FEATURES + G_N_ELEMENTS (_ethtool_feature_infos));
nm_assert (!states_plist0[states_plist_n]);
states_plist_n++;
}
}
}
return g_steal_pointer (&states);
}
NMEthtoolFeatureStates *
nmp_utils_ethtool_get_features (int ifindex)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
NMEthtoolFeatureStates *features;
g_return_val_if_fail (ifindex > 0, 0);
features = ethtool_get_features (&shandle);
if (!features) {
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: failure getting features",
ifindex,
"get-features");
return NULL;
}
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: retrieved kernel features",
ifindex,
"get-features");
return features;
}
static const char *
_ethtool_feature_state_to_string (char *buf, gsize buf_size, const NMEthtoolFeatureState *s, const char *prefix)
{
int l;
l = g_snprintf (buf, buf_size,
"%s %s%s",
prefix ?: "",
ONOFF (s->active),
(!s->available || s->never_changed)
? ", [fixed]"
: ((s->requested != s->active)
? (s->requested ? ", [requested on]" : ", [requested off]")
: ""));
nm_assert (l < buf_size);
return buf;
}
gboolean
nmp_utils_ethtool_set_features (int ifindex,
const NMEthtoolFeatureStates *features,
const NMTernary *requested /* indexed by NMEthtoolID - _NM_ETHTOOL_ID_FEATURE_FIRST */,
gboolean do_set /* or reset */)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
gs_free struct ethtool_sfeatures *sfeatures_free = NULL;
struct ethtool_sfeatures *sfeatures;
gsize sfeatures_len;
int r;
guint i, j;
struct {
const NMEthtoolFeatureState *f_state;
NMTernary requested;
} set_states[N_ETHTOOL_KERNEL_FEATURES];
guint set_states_n = 0;
gboolean success = TRUE;
g_return_val_if_fail (ifindex > 0, 0);
g_return_val_if_fail (features, 0);
g_return_val_if_fail (requested, 0);
nm_assert (features->n_states <= N_ETHTOOL_KERNEL_FEATURES);
for (i = 0; i < _NM_ETHTOOL_ID_FEATURE_NUM; i++) {
const NMEthtoolFeatureState *const*states_indexed;
if (requested[i] == NM_TERNARY_DEFAULT)
continue;
if (!(states_indexed = features->states_indexed[i])) {
if (do_set) {
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: set feature %s: skip (not found)",
ifindex,
"set-features",
nm_ethtool_data[i + _NM_ETHTOOL_ID_FEATURE_FIRST]->optname);
success = FALSE;
}
continue;
}
for (j = 0; states_indexed[j]; j++) {
const NMEthtoolFeatureState *s = states_indexed[j];
char sbuf[255];
if (set_states_n >= G_N_ELEMENTS (set_states))
g_return_val_if_reached (FALSE);
if (s->never_changed) {
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: %s feature %s (%s): %s, %s (skip feature marked as never changed)",
ifindex,
"set-features",
do_set ? "set" : "reset",
nm_ethtool_data[i + _NM_ETHTOOL_ID_FEATURE_FIRST]->optname,
s->info->kernel_names[s->idx_kernel_name],
ONOFF (do_set ? requested[i] == NM_TERNARY_TRUE : s->active),
_ethtool_feature_state_to_string (sbuf, sizeof (sbuf), s, do_set ? " currently:" : " before:"));
continue;
}
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: %s feature %s (%s): %s, %s",
ifindex,
"set-features",
do_set ? "set" : "reset",
nm_ethtool_data[i + _NM_ETHTOOL_ID_FEATURE_FIRST]->optname,
s->info->kernel_names[s->idx_kernel_name],
ONOFF (do_set ? requested[i] == NM_TERNARY_TRUE : s->active),
_ethtool_feature_state_to_string (sbuf, sizeof (sbuf), s, do_set ? " currently:" : " before:"));
if ( do_set
&& (!s->available || s->never_changed)
&& (s->active != (requested[i] == NM_TERNARY_TRUE))) {
/* we request to change a flag which kernel reported as fixed.
* While the ethtool operation will silently succeed, mark the request
* as failure. */
success = FALSE;
}
set_states[set_states_n].f_state = s;
set_states[set_states_n].requested = requested[i];
set_states_n++;
}
}
if (set_states_n == 0) {
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: no feature requested",
ifindex,
"set-features");
return TRUE;
}
sfeatures_len = sizeof (struct ethtool_sfeatures)
+ (NM_DIV_ROUND_UP (features->n_ss_features, 32U) * sizeof(sfeatures->features[0]));
sfeatures = nm_malloc0_maybe_a (300, sfeatures_len, &sfeatures_free);
sfeatures->cmd = ETHTOOL_SFEATURES;
sfeatures->size = NM_DIV_ROUND_UP (features->n_ss_features, 32U);
for (i = 0; i < set_states_n; i++) {
const NMEthtoolFeatureState *s = set_states[i].f_state;
guint i_block;
guint32 i_flag;
gboolean is_requested;
i_block = s->idx_ss_features / 32u;
i_flag = (guint32) (1u << (s->idx_ss_features % 32u));
sfeatures->features[i_block].valid |= i_flag;
if (do_set)
is_requested = (set_states[i].requested == NM_TERNARY_TRUE);
else
is_requested = s->active;
if (is_requested)
sfeatures->features[i_block].requested |= i_flag;
else
sfeatures->features[i_block].requested &= ~i_flag;
}
r = _ethtool_call_handle (&shandle, sfeatures, sfeatures_len);
if (r < 0) {
success = FALSE;
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: failure setting features (%s)",
ifindex,
"set-features",
nm_strerror_native (-r));
return FALSE;
}
nm_log_trace (LOGD_PLATFORM, "ethtool[%d]: %s: %s",
ifindex,
"set-features",
success
? "successfully setting features"
: "at least some of the features were not successfully set");
return success;
}
/*****************************************************************************/
gboolean
nmp_utils_ethtool_get_driver_info (int ifindex,
NMPUtilsEthtoolDriverInfo *data)
{
struct ethtool_drvinfo *drvinfo;
G_STATIC_ASSERT_EXPR (sizeof (*data) == sizeof (*drvinfo));
G_STATIC_ASSERT_EXPR (offsetof (NMPUtilsEthtoolDriverInfo, driver) == offsetof (struct ethtool_drvinfo, driver));
G_STATIC_ASSERT_EXPR (offsetof (NMPUtilsEthtoolDriverInfo, version) == offsetof (struct ethtool_drvinfo, version));
G_STATIC_ASSERT_EXPR (offsetof (NMPUtilsEthtoolDriverInfo, fw_version) == offsetof (struct ethtool_drvinfo, fw_version));
G_STATIC_ASSERT_EXPR (sizeof (data->driver) == sizeof (drvinfo->driver));
G_STATIC_ASSERT_EXPR (sizeof (data->version) == sizeof (drvinfo->version));
G_STATIC_ASSERT_EXPR (sizeof (data->fw_version) == sizeof (drvinfo->fw_version));
g_return_val_if_fail (ifindex > 0, FALSE);
g_return_val_if_fail (data, FALSE);
drvinfo = (struct ethtool_drvinfo *) data;
*drvinfo = (struct ethtool_drvinfo) {
.cmd = ETHTOOL_GDRVINFO,
};
return _ethtool_call_once (ifindex, drvinfo, sizeof (*drvinfo)) >= 0;
}
gboolean
nmp_utils_ethtool_get_permanent_address (int ifindex,
guint8 *buf,
size_t *length)
{
struct {
struct ethtool_perm_addr e;
guint8 _extra_data[NM_UTILS_HWADDR_LEN_MAX + 1];
} edata = {
.e.cmd = ETHTOOL_GPERMADDR,
.e.size = NM_UTILS_HWADDR_LEN_MAX,
};
guint i;
g_return_val_if_fail (ifindex > 0, FALSE);
if (_ethtool_call_once (ifindex, &edata, sizeof (edata)) < 0)
return FALSE;
if (edata.e.size > NM_UTILS_HWADDR_LEN_MAX)
return FALSE;
if (edata.e.size < 1)
return FALSE;
if (NM_IN_SET (edata.e.data[0], 0, 0xFF)) {
/* Some drivers might return a permanent address of all zeros.
* Reject that (rh#1264024)
*
* Some drivers return a permanent address of all ones. Reject that too */
for (i = 1; i < edata.e.size; i++) {
if (edata.e.data[0] != edata.e.data[i])
goto not_all_0or1;
}
return FALSE;
}
not_all_0or1:
memcpy (buf, edata.e.data, edata.e.size);
*length = edata.e.size;
return TRUE;
}
gboolean
nmp_utils_ethtool_supports_carrier_detect (int ifindex)
{
struct ethtool_cmd edata = { .cmd = ETHTOOL_GLINK };
g_return_val_if_fail (ifindex > 0, FALSE);
/* We ignore the result. If the ETHTOOL_GLINK call succeeded, then we
* assume the device supports carrier-detect, otherwise we assume it
* doesn't.
*/
return _ethtool_call_once (ifindex, &edata, sizeof (edata)) >= 0;
}
gboolean
nmp_utils_ethtool_supports_vlans (int ifindex)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
gs_free struct ethtool_gfeatures *features_free = NULL;
struct ethtool_gfeatures *features;
gsize features_len;
int idx, block, bit, size;
g_return_val_if_fail (ifindex > 0, FALSE);
idx = ethtool_get_stringset_index (&shandle, ETH_SS_FEATURES, "vlan-challenged");
if (idx < 0) {
nm_log_dbg (LOGD_PLATFORM, "ethtool[%d]: vlan-challenged ethtool feature does not exist?", ifindex);
return FALSE;
}
block = idx / 32;
bit = idx % 32;
size = block + 1;
features_len = sizeof (*features)
+ (size * sizeof (struct ethtool_get_features_block));
features = nm_malloc0_maybe_a (300, features_len, &features_free);
features->cmd = ETHTOOL_GFEATURES;
features->size = size;
if (_ethtool_call_handle (&shandle, features, features_len) < 0)
return FALSE;
return !(features->features[block].active & (1 << bit));
}
int
nmp_utils_ethtool_get_peer_ifindex (int ifindex)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
gsize stats_len;
gs_free struct ethtool_stats *stats_free = NULL;
struct ethtool_stats *stats;
int peer_ifindex_stat;
g_return_val_if_fail (ifindex > 0, 0);
peer_ifindex_stat = ethtool_get_stringset_index (&shandle, ETH_SS_STATS, "peer_ifindex");
if (peer_ifindex_stat < 0) {
nm_log_dbg (LOGD_PLATFORM, "ethtool[%d]: peer_ifindex stat does not exist?", ifindex);
return FALSE;
}
stats_len = sizeof (*stats) + (peer_ifindex_stat + 1) * sizeof (guint64);
stats = nm_malloc0_maybe_a (300, stats_len, &stats_free);
stats->cmd = ETHTOOL_GSTATS;
stats->n_stats = peer_ifindex_stat + 1;
if (_ethtool_call_handle (&shandle, stats, stats_len) < 0)
return 0;
return stats->data[peer_ifindex_stat];
}
gboolean
nmp_utils_ethtool_get_wake_on_lan (int ifindex)
{
struct ethtool_wolinfo wol = {
.cmd = ETHTOOL_GWOL,
};
g_return_val_if_fail (ifindex > 0, FALSE);
if (_ethtool_call_once (ifindex, &wol, sizeof (wol)) < 0)
return FALSE;
return wol.wolopts != 0;
}
gboolean
nmp_utils_ethtool_get_link_settings (int ifindex,
gboolean *out_autoneg,
guint32 *out_speed,
NMPlatformLinkDuplexType *out_duplex)
{
struct ethtool_cmd edata = {
.cmd = ETHTOOL_GSET,
};
g_return_val_if_fail (ifindex > 0, FALSE);
if (_ethtool_call_once (ifindex, &edata, sizeof (edata)) < 0)
return FALSE;
NM_SET_OUT (out_autoneg, (edata.autoneg == AUTONEG_ENABLE));
if (out_speed) {
guint32 speed;
speed = ethtool_cmd_speed (&edata);
if (speed == G_MAXUINT16 || speed == G_MAXUINT32)
speed = 0;
*out_speed = speed;
}
if (out_duplex) {
switch (edata.duplex) {
case DUPLEX_HALF:
*out_duplex = NM_PLATFORM_LINK_DUPLEX_HALF;
break;
case DUPLEX_FULL:
*out_duplex = NM_PLATFORM_LINK_DUPLEX_FULL;
break;
default: /* DUPLEX_UNKNOWN */
*out_duplex = NM_PLATFORM_LINK_DUPLEX_UNKNOWN;
break;
}
}
return TRUE;
}
#define ADVERTISED_INVALID 0
#define BASET_ALL_MODES ( ADVERTISED_10baseT_Half \
| ADVERTISED_10baseT_Full \
| ADVERTISED_100baseT_Half \
| ADVERTISED_100baseT_Full \
| ADVERTISED_1000baseT_Half \
| ADVERTISED_1000baseT_Full \
| ADVERTISED_10000baseT_Full )
static guint32
get_baset_mode (guint32 speed, NMPlatformLinkDuplexType duplex)
{
if (duplex == NM_PLATFORM_LINK_DUPLEX_UNKNOWN)
return ADVERTISED_INVALID;
if (duplex == NM_PLATFORM_LINK_DUPLEX_HALF) {
switch (speed) {
case 10: return ADVERTISED_10baseT_Half;
case 100: return ADVERTISED_100baseT_Half;
case 1000: return ADVERTISED_1000baseT_Half;
default: return ADVERTISED_INVALID;
}
} else {
switch (speed) {
case 10: return ADVERTISED_10baseT_Full;
case 100: return ADVERTISED_100baseT_Full;
case 1000: return ADVERTISED_1000baseT_Full;
case 10000: return ADVERTISED_10000baseT_Full;
default: return ADVERTISED_INVALID;
}
}
}
gboolean
nmp_utils_ethtool_set_link_settings (int ifindex,
gboolean autoneg,
guint32 speed,
NMPlatformLinkDuplexType duplex)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
struct ethtool_cmd edata = {
.cmd = ETHTOOL_GSET,
};
g_return_val_if_fail (ifindex > 0, FALSE);
g_return_val_if_fail ( (speed && duplex != NM_PLATFORM_LINK_DUPLEX_UNKNOWN)
|| (!speed && duplex == NM_PLATFORM_LINK_DUPLEX_UNKNOWN), FALSE);
/* retrieve first current settings */
if (_ethtool_call_handle (&shandle, &edata, sizeof (edata)) < 0)
return FALSE;
/* FIXME: try first new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API
* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3f1ac7a700d039c61d8d8b99f28d605d489a60cf
*/
/* then change the needed ones */
edata.cmd = ETHTOOL_SSET;
if (autoneg) {
edata.autoneg = AUTONEG_ENABLE;
if (!speed)
edata.advertising = edata.supported;
else {
guint32 mode;
mode = get_baset_mode (speed, duplex);
if (!mode) {
nm_log_trace (LOGD_PLATFORM,
"ethtool[%d]: %uBASE-T %s duplex mode cannot be advertised",
ifindex,
speed,
nm_platform_link_duplex_type_to_string (duplex));
return FALSE;
}
if (!(edata.supported & mode)) {
nm_log_trace (LOGD_PLATFORM,
"ethtool[%d]: device does not support %uBASE-T %s duplex mode",
ifindex,
speed,
nm_platform_link_duplex_type_to_string (duplex));
return FALSE;
}
edata.advertising = (edata.supported & ~BASET_ALL_MODES) | mode;
}
} else {
edata.autoneg = AUTONEG_DISABLE;
if (speed)
ethtool_cmd_speed_set (&edata, speed);
switch (duplex) {
case NM_PLATFORM_LINK_DUPLEX_HALF:
edata.duplex = DUPLEX_HALF;
break;
case NM_PLATFORM_LINK_DUPLEX_FULL:
edata.duplex = DUPLEX_FULL;
break;
case NM_PLATFORM_LINK_DUPLEX_UNKNOWN:
break;
default:
g_return_val_if_reached (FALSE);
}
}
return _ethtool_call_handle (&shandle, &edata, sizeof (edata)) >= 0;
}
gboolean
nmp_utils_ethtool_set_wake_on_lan (int ifindex,
NMSettingWiredWakeOnLan wol,
const char *wol_password)
{
struct ethtool_wolinfo wol_info = {
.cmd = ETHTOOL_SWOL,
.wolopts = 0,
};
g_return_val_if_fail (ifindex > 0, FALSE);
if (wol == NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE)
return TRUE;
nm_log_dbg (LOGD_PLATFORM, "ethtool[%d]: setting Wake-on-LAN options 0x%x, password '%s'",
ifindex, (unsigned) wol, wol_password);
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_PHY))
wol_info.wolopts |= WAKE_PHY;
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST))
wol_info.wolopts |= WAKE_UCAST;
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST))
wol_info.wolopts |= WAKE_MCAST;
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST))
wol_info.wolopts |= WAKE_BCAST;
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_ARP))
wol_info.wolopts |= WAKE_ARP;
if (NM_FLAGS_HAS (wol, NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC))
wol_info.wolopts |= WAKE_MAGIC;
if (wol_password) {
if (!nm_utils_hwaddr_aton (wol_password, wol_info.sopass, ETH_ALEN)) {
nm_log_dbg (LOGD_PLATFORM, "ethtool[%d]: couldn't parse Wake-on-LAN password '%s'", ifindex, wol_password);
return FALSE;
}
wol_info.wolopts |= WAKE_MAGICSECURE;
}
return _ethtool_call_once (ifindex, &wol_info, sizeof (wol_info)) >= 0;
}
/******************************************************************************
* mii
*****************************************************************************/
gboolean
nmp_utils_mii_supports_carrier_detect (int ifindex)
{
nm_auto_socket_handle SocketHandle shandle = SOCKET_HANDLE_INIT (ifindex);
int r;
struct ifreq ifr;
struct mii_ioctl_data *mii;
g_return_val_if_fail (ifindex > 0, FALSE);
r = _ioctl_call ("mii",
"SIOCGMIIPHY",
SIOCGMIIPHY,
shandle.ifindex,
&shandle.fd,
shandle.ifname,
IOCTL_CALL_DATA_TYPE_NONE,
NULL,
0,
&ifr);
if (r < 0)
return FALSE;
/* If we can read the BMSR register, we assume that the card supports MII link detection */
mii = (struct mii_ioctl_data *) &ifr.ifr_ifru;
mii->reg_num = MII_BMSR;
r = _ioctl_call ("mii",
"SIOCGMIIREG",
SIOCGMIIREG,
shandle.ifindex,
&shandle.fd,
shandle.ifname,
IOCTL_CALL_DATA_TYPE_IFRU,
mii,
sizeof (*mii),
&ifr);
if (r < 0)
return FALSE;
mii = (struct mii_ioctl_data *) &ifr.ifr_ifru;
nm_log_trace (LOGD_PLATFORM, "mii[%d,%s]: carrier-detect yes: SIOCGMIIREG result 0x%X", ifindex, shandle.ifname, mii->val_out);
return TRUE;
}
/******************************************************************************
* udev
*****************************************************************************/
const char *
nmp_utils_udev_get_driver (struct udev_device *udevice)
{
struct udev_device *parent = NULL, *grandparent = NULL;
const char *driver, *subsys;
driver = udev_device_get_driver (udevice);
if (driver)
goto out;
/* Try the parent */
parent = udev_device_get_parent (udevice);
if (parent) {
driver = udev_device_get_driver (parent);
if (!driver) {
/* Try the grandparent if it's an ibmebus device or if the
* subsys is NULL which usually indicates some sort of
* platform device like a 'gadget' net interface.
*/
subsys = udev_device_get_subsystem (parent);
if ( (g_strcmp0 (subsys, "ibmebus") == 0)
|| (subsys == NULL)) {
grandparent = udev_device_get_parent (parent);
if (grandparent)
driver = udev_device_get_driver (grandparent);
}
}
}
out:
/* Intern the string so we don't have to worry about memory
* management in NMPlatformLink. */
return g_intern_string (driver);
}
/******************************************************************************
* utils
*****************************************************************************/
NMIPConfigSource
nmp_utils_ip_config_source_from_rtprot (guint8 rtprot)
{
return ((int) rtprot) + 1;
}
NMIPConfigSource
nmp_utils_ip_config_source_round_trip_rtprot (NMIPConfigSource source)
{
/* when adding a route to kernel for a give @source, the resulting route
* will be put into the cache with a source of NM_IP_CONFIG_SOURCE_RTPROT_*.
* This function returns that. */
return nmp_utils_ip_config_source_from_rtprot (nmp_utils_ip_config_source_coerce_to_rtprot (source));
}
guint8
nmp_utils_ip_config_source_coerce_to_rtprot (NMIPConfigSource source)
{
/* when adding a route to kernel, we coerce the @source field
* to rtm_protocol. This is not lossless as we map different
* source values to the same RTPROT uint8 value. */
if (source <= NM_IP_CONFIG_SOURCE_UNKNOWN)
return RTPROT_UNSPEC;
if (source <= _NM_IP_CONFIG_SOURCE_RTPROT_LAST)
return source - 1;
switch (source) {
case NM_IP_CONFIG_SOURCE_KERNEL:
return RTPROT_KERNEL;
case NM_IP_CONFIG_SOURCE_IP6LL:
return RTPROT_KERNEL;
case NM_IP_CONFIG_SOURCE_DHCP:
return RTPROT_DHCP;
case NM_IP_CONFIG_SOURCE_NDISC:
return RTPROT_RA;
default:
return RTPROT_STATIC;
}
}
NMIPConfigSource
nmp_utils_ip_config_source_coerce_from_rtprot (NMIPConfigSource source)
{
/* When we receive a route from kernel and put it into the platform cache,
* we preserve the protocol field by converting it to a NMIPConfigSource
* via nmp_utils_ip_config_source_from_rtprot().
*
* However, that is not the inverse of nmp_utils_ip_config_source_coerce_to_rtprot().
* Instead, to go back to the original value, you need another step:
* nmp_utils_ip_config_source_coerce_from_rtprot (nmp_utils_ip_config_source_from_rtprot (rtprot)).
*
* This might partly restore the original source value, but of course that
* is not really possible because nmp_utils_ip_config_source_coerce_to_rtprot()
* is not injective.
* */
switch (source) {
case NM_IP_CONFIG_SOURCE_RTPROT_UNSPEC:
return NM_IP_CONFIG_SOURCE_UNKNOWN;
case NM_IP_CONFIG_SOURCE_RTPROT_KERNEL:
case NM_IP_CONFIG_SOURCE_RTPROT_REDIRECT:
return NM_IP_CONFIG_SOURCE_KERNEL;
case NM_IP_CONFIG_SOURCE_RTPROT_RA:
return NM_IP_CONFIG_SOURCE_NDISC;
case NM_IP_CONFIG_SOURCE_RTPROT_DHCP:
return NM_IP_CONFIG_SOURCE_DHCP;
default:
return NM_IP_CONFIG_SOURCE_USER;
}
}
const char *
nmp_utils_ip_config_source_to_string (NMIPConfigSource source, char *buf, gsize len)
{
const char *s = NULL;
nm_utils_to_string_buffer_init (&buf, &len); \
if (!len)
return buf;
switch (source) {
case NM_IP_CONFIG_SOURCE_UNKNOWN: s = "unknown"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_UNSPEC: s = "rt-unspec"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_REDIRECT: s = "rt-redirect"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_KERNEL: s = "rt-kernel"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_BOOT: s = "rt-boot"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_STATIC: s = "rt-static"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_DHCP: s = "rt-dhcp"; break;
case NM_IP_CONFIG_SOURCE_RTPROT_RA: s = "rt-ra"; break;
case NM_IP_CONFIG_SOURCE_KERNEL: s = "kernel"; break;
case NM_IP_CONFIG_SOURCE_SHARED: s = "shared"; break;
case NM_IP_CONFIG_SOURCE_IP4LL: s = "ipv4ll"; break;
case NM_IP_CONFIG_SOURCE_IP6LL: s = "ipv6ll"; break;
case NM_IP_CONFIG_SOURCE_PPP: s = "ppp"; break;
case NM_IP_CONFIG_SOURCE_WWAN: s = "wwan"; break;
case NM_IP_CONFIG_SOURCE_VPN: s = "vpn"; break;
case NM_IP_CONFIG_SOURCE_DHCP: s = "dhcp"; break;
case NM_IP_CONFIG_SOURCE_NDISC: s = "ndisc"; break;
case NM_IP_CONFIG_SOURCE_USER: s = "user"; break;
default:
break;
}
if (source >= 1 && source <= 0x100) {
if (s)
g_snprintf (buf, len, "%s", s);
else
g_snprintf (buf, len, "rt-%d", ((int) source) - 1);
} else {
if (s)
g_strlcpy (buf, s, len);
else
g_snprintf (buf, len, "(%d)", source);
}
return buf;
}
/**
* nmp_utils_sysctl_open_netdir:
* @ifindex: the ifindex for which to open "/sys/class/net/%s"
* @ifname_guess: (allow-none): optional argument, if present used as initial
* guess as the current name for @ifindex. If guessed right,
* it saves an additional if_indextoname() call.
* @out_ifname: (allow-none): if present, must be at least IFNAMSIZ
* characters. On success, this will contain the actual ifname
* found while opening the directory.
*
* Returns: a negative value on failure, on success returns the open fd
* to the "/sys/class/net/%s" directory for @ifindex.
*/
int
nmp_utils_sysctl_open_netdir (int ifindex,
const char *ifname_guess,
char *out_ifname)
{
#define SYS_CLASS_NET "/sys/class/net/"
const char *ifname = ifname_guess;
char ifname_buf_last_try[IFNAMSIZ];
char ifname_buf[IFNAMSIZ];
guint try_count = 0;
char sysdir[NM_STRLEN (SYS_CLASS_NET) + IFNAMSIZ] = SYS_CLASS_NET;
char fd_buf[256];
ssize_t nn;
g_return_val_if_fail (ifindex >= 0, -1);
ifname_buf_last_try[0] = '\0';
for (try_count = 0; try_count < 10; try_count++, ifname = NULL) {
nm_auto_close int fd_dir = -1;
nm_auto_close int fd_ifindex = -1;
if (!ifname) {
ifname = nmp_utils_if_indextoname (ifindex, ifname_buf);
if (!ifname)
return -1;
}
nm_assert (nm_utils_is_valid_iface_name (ifname, NULL));
if (g_strlcpy (&sysdir[NM_STRLEN (SYS_CLASS_NET)], ifname, IFNAMSIZ) >= IFNAMSIZ)
g_return_val_if_reached (-1);
/* we only retry, if the name changed since previous attempt.
* Hence, it is extremely unlikely that this loop runes until the
* end of the @try_count. */
if (nm_streq (ifname, ifname_buf_last_try))
return -1;
strcpy (ifname_buf_last_try, ifname);
fd_dir = open (sysdir, O_DIRECTORY | O_CLOEXEC);
if (fd_dir < 0)
continue;
fd_ifindex = openat (fd_dir, "ifindex", O_CLOEXEC);
if (fd_ifindex < 0)
continue;
nn = nm_utils_fd_read_loop (fd_ifindex, fd_buf, sizeof (fd_buf) - 2, FALSE);
if (nn <= 0)
continue;
fd_buf[nn] = '\0';
if (ifindex != (int) _nm_utils_ascii_str_to_int64 (fd_buf, 10, 1, G_MAXINT, -1))
continue;
if (out_ifname)
strcpy (out_ifname, ifname);
return nm_steal_fd (&fd_dir);
}
return -1;
}
Reference in New Issue View Git Blame Copy Permalink