mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

net: partial revert of the "Make timestamping selectable: series 

Revert following commits:

commit acec05fb78 ("net_tstamp: Add TIMESTAMPING SOFTWARE and HARDWARE mask")
commit 11d55be06d ("net: ethtool: Add a command to expose current time stamping layer")
commit bb8645b00c ("netlink: specs: Introduce new netlink command to get current timestamp")
commit d905f9c753 ("net: ethtool: Add a command to list available time stamping layers")
commit aed5004ee7 ("netlink: specs: Introduce new netlink command to list available time stamping layers")
commit 51bdf3165f ("net: Replace hwtstamp_source by timestamping layer")
commit 0f7f463d48 ("net: Change the API of PHY default timestamp to MAC")
commit 091fab1228 ("net: ethtool: ts: Update GET_TS to reply the current selected timestamp")
commit 152c75e1d0 ("net: ethtool: ts: Let the active time stamping layer be selectable")
commit ee60ea6be0 ("netlink: specs: Introduce time stamping set command")

They need more time for reviews.

Link: https://lore.kernel.org/all/20231118183529.6e67100c@kernel.org/
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski 2023-11-18 18:38:05 -08:00
parent 055dd7511f
commit 289354f21b
23 changed files with 28 additions and 566 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
Documentation/netlink/specs/ethtool.yaml
View File

@ -939,26 +939,6 @@ attribute-sets:
-
name: burst-tmr
type: u32
-
name: ts
attributes:
-
name: header
type: nest
nested-attributes: header
-
name: ts-layer
type: u32
-
name: ts-list
attributes:
-
name: header
type: nest
nested-attributes: header
-
name: ts-list-layer
type: binary
operations:
enum-model: directional
@ -1709,40 +1689,3 @@ operations:
name: mm-ntf
doc: Notification for change in MAC Merge configuration.
notify: mm-get
-
name: ts-get
doc: Get current timestamp
attribute-set: ts
do:
request:
attributes:
- header
reply:
attributes: &ts
- header
- ts-layer
-
name: ts-list-get
doc: Get list of timestamp devices available on an interface
attribute-set: ts-list
do:
request:
attributes:
- header
reply:
attributes:
- header
- ts-list-layer
-
name: ts-set
doc: Set the timestamp device
attribute-set: ts
do:
request:
attributes: *ts

63
Documentation/networking/ethtool-netlink.rst
View File

@ -225,9 +225,6 @@ Userspace to kernel:
``ETHTOOL_MSG_RSS_GET`` get RSS settings
``ETHTOOL_MSG_MM_GET`` get MAC merge layer state
``ETHTOOL_MSG_MM_SET`` set MAC merge layer parameters
``ETHTOOL_MSG_TS_GET`` get current timestamping
``ETHTOOL_MSG_TS_LIST_GET`` list available timestampings
``ETHTOOL_MSG_TS_SET`` set current timestamping
===================================== =================================
Kernel to userspace:
@ -271,8 +268,6 @@ Kernel to userspace:
``ETHTOOL_MSG_PSE_GET_REPLY`` PSE parameters
``ETHTOOL_MSG_RSS_GET_REPLY`` RSS settings
``ETHTOOL_MSG_MM_GET_REPLY`` MAC merge layer status
``ETHTOOL_MSG_TS_GET_REPLY`` current timestamping
``ETHTOOL_MSG_TS_LIST_GET_REPLY`` available timestampings
======================================== =================================
``GET`` requests are sent by userspace applications to retrieve device
@ -1999,61 +1994,6 @@ The attributes are propagated to the driver through the following structure:
.. kernel-doc:: include/linux/ethtool.h
:identifiers: ethtool_mm_cfg
TS_GET
======
Gets current timestamping.
Request contents:
================================= ====== ====================
``ETHTOOL_A_TS_HEADER`` nested request header
================================= ====== ====================
Kernel response contents:
======================= ====== ==============================
``ETHTOOL_A_TS_HEADER`` nested reply header
``ETHTOOL_A_TS_LAYER`` u32 current timestamping
======================= ====== ==============================
This command get the current timestamp layer.
TS_LIST_GET
===========
Get the list of available timestampings.
Request contents:
================================= ====== ====================
``ETHTOOL_A_TS_HEADER`` nested request header
================================= ====== ====================
Kernel response contents:
=========================== ====== ==============================
``ETHTOOL_A_TS_HEADER`` nested reply header
``ETHTOOL_A_TS_LIST_LAYER`` binary available timestampings
=========================== ====== ==============================
This command lists all the possible timestamp layer available.
TS_SET
======
Modify the selected timestamping.
Request contents:
======================= ====== ===================
``ETHTOOL_A_TS_HEADER`` nested reply header
``ETHTOOL_A_TS_LAYER`` u32 timestamping
======================= ====== ===================
This command set the timestamping with one that should be listed by the
TSLIST_GET command.
Request translation
===================
@ -2160,7 +2100,4 @@ are netlink only.
n/a ``ETHTOOL_MSG_PLCA_GET_STATUS``
n/a ``ETHTOOL_MSG_MM_GET``
n/a ``ETHTOOL_MSG_MM_SET``
n/a ``ETHTOOL_MSG_TS_GET``
n/a ``ETHTOOL_MSG_TS_LIST_GET``
n/a ``ETHTOOL_MSG_TS_SET``
=================================== =====================================

6
drivers/net/ethernet/microchip/lan966x/lan966x_main.c
View File

@ -470,15 +470,15 @@ static int lan966x_port_hwtstamp_set(struct net_device *dev,
struct lan966x_port *port = netdev_priv(dev);
int err;
if (cfg->source != MAC_TIMESTAMPING &&
cfg->source != PHY_TIMESTAMPING)
if (cfg->source != HWTSTAMP_SOURCE_NETDEV &&
cfg->source != HWTSTAMP_SOURCE_PHYLIB)
return -EOPNOTSUPP;
err = lan966x_ptp_setup_traps(port, cfg);
if (err)
return err;
if (cfg->source == MAC_TIMESTAMPING) {
if (cfg->source == HWTSTAMP_SOURCE_NETDEV) {
if (!port->lan966x->ptp)
return -EOPNOTSUPP;

3
drivers/net/phy/bcm-phy-ptp.c
View File

@ -931,9 +931,6 @@ struct bcm_ptp_private *bcm_ptp_probe(struct phy_device *phydev)
return ERR_CAST(clock);
priv->ptp_clock = clock;
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
priv->phydev = phydev;
bcm_ptp_init(priv);

3
drivers/net/phy/dp83640.c
View File

@ -1450,9 +1450,6 @@ static int dp83640_probe(struct phy_device *phydev)
phydev->mii_ts = &dp83640->mii_ts;
phydev->priv = dp83640;
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
spin_lock_init(&dp83640->rx_lock);
skb_queue_head_init(&dp83640->rx_queue);
skb_queue_head_init(&dp83640->tx_queue);

6
drivers/net/phy/micrel.c
View File

@ -3158,9 +3158,6 @@ static void lan8814_ptp_init(struct phy_device *phydev)
ptp_priv->mii_ts.ts_info = lan8814_ts_info;
phydev->mii_ts = &ptp_priv->mii_ts;
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
}
static int lan8814_ptp_probe_once(struct phy_device *phydev)
@ -4589,9 +4586,6 @@ static int lan8841_probe(struct phy_device *phydev)
phydev->mii_ts = &ptp_priv->mii_ts;
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
return 0;
}

2
drivers/net/phy/mscc/mscc_ptp.c
View File

@ -1570,8 +1570,6 @@ int vsc8584_ptp_probe(struct phy_device *phydev)
return PTR_ERR(vsc8531->load_save);
}
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
vsc8531->ptp->phydev = phydev;
return 0;

3
drivers/net/phy/nxp-c45-tja11xx.c
View File

@ -1658,9 +1658,6 @@ static int nxp_c45_probe(struct phy_device *phydev)
priv->mii_ts.ts_info = nxp_c45_ts_info;
phydev->mii_ts = &priv->mii_ts;
ret = nxp_c45_init_ptp_clock(priv);
/* Timestamp selected by default to keep legacy API */
phydev->default_timestamp = true;
} else {
phydev_dbg(phydev, "PTP support not enabled even if the phy supports it");
}

37
drivers/net/phy/phy_device.c
View File

@ -1411,26 +1411,6 @@ int phy_sfp_probe(struct phy_device *phydev,
}
EXPORT_SYMBOL(phy_sfp_probe);
/**
* phy_set_timestamp - set the default selected timestamping device
* @dev: Pointer to net_device
* @phydev: Pointer to phy_device
*
* This is used to set default timestamping device taking into account
* the new API choice, which is selecting the timestamping from MAC by
* default if the phydev does not have default_timestamp flag enabled.
*/
static void phy_set_timestamp(struct net_device *dev, struct phy_device *phydev)
{
const struct ethtool_ops *ops = dev->ethtool_ops;
if (!phy_has_tsinfo(phydev))
return;
if (!ops->get_ts_info || phydev->default_timestamp)
dev->ts_layer = PHY_TIMESTAMPING;
}
/**
* phy_attach_direct - attach a network device to a given PHY device pointer
* @dev: network device to attach
@ -1504,7 +1484,6 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
phydev->phy_link_change = phy_link_change;
if (dev) {
phy_set_timestamp(dev, phydev);
phydev->attached_dev = dev;
dev->phydev = phydev;
@ -1833,22 +1812,6 @@ void phy_detach(struct phy_device *phydev)
phy_suspend(phydev);
if (dev) {
const struct ethtool_ops *ops = dev->ethtool_ops;
struct ethtool_ts_info ts_info = {0};
if (ops->get_ts_info) {
ops->get_ts_info(dev, &ts_info);
if ((ts_info.so_timestamping &
SOF_TIMESTAMPING_HARDWARE_MASK) ==
SOF_TIMESTAMPING_HARDWARE_MASK)
dev->ts_layer = MAC_TIMESTAMPING;
else if ((ts_info.so_timestamping &
SOF_TIMESTAMPING_SOFTWARE_MASK) ==
SOF_TIMESTAMPING_SOFTWARE_MASK)
dev->ts_layer = SOFTWARE_TIMESTAMPING;
} else {
dev->ts_layer = NO_TIMESTAMPING;
}
phydev->attached_dev->phydev = NULL;
phydev->attached_dev = NULL;
}

11
include/linux/net_tstamp.h
View File

@ -5,6 +5,11 @@
#include <uapi/linux/net_tstamp.h>
enum hwtstamp_source {
HWTSTAMP_SOURCE_NETDEV,
HWTSTAMP_SOURCE_PHYLIB,
};
/**
* struct kernel_hwtstamp_config - Kernel copy of struct hwtstamp_config
*
@ -15,8 +20,8 @@
* a legacy implementation of a lower driver
* @copied_to_user: request was passed to a legacy implementation which already
* copied the ioctl request back to user space
* @source: indication whether timestamps should come from software, the netdev
* or from an attached phylib PHY
* @source: indication whether timestamps should come from the netdev or from
* an attached phylib PHY
*
* Prefer using this structure for in-kernel processing of hardware
* timestamping configuration, over the inextensible struct hwtstamp_config
@ -28,7 +33,7 @@ struct kernel_hwtstamp_config {
int rx_filter;
struct ifreq *ifr;
bool copied_to_user;
enum timestamping_layer source;
enum hwtstamp_source source;
};
static inline void hwtstamp_config_to_kernel(struct kernel_hwtstamp_config *kernel_cfg,

5
include/linux/netdevice.h
View File

@ -47,7 +47,6 @@
#include <uapi/linux/if_bonding.h>
#include <uapi/linux/pkt_cls.h>
#include <uapi/linux/netdev.h>
#include <uapi/linux/net_tstamp.h>
#include <linux/hashtable.h>
#include <linux/rbtree.h>
#include <net/net_trackers.h>
@ -2075,8 +2074,6 @@ enum netdev_ml_priv_type {
*
* @dpll_pin: Pointer to the SyncE source pin of a DPLL subsystem,
* where the clock is recovered.
* @ts_layer: Tracks which network device
* performs packet time stamping.
*
* FIXME: cleanup struct net_device such that network protocol info
* moves out.
@ -2438,8 +2435,6 @@ struct net_device {
#if IS_ENABLED(CONFIG_DPLL)
struct dpll_pin *dpll_pin;
#endif
enum timestamping_layer ts_layer;
};
#define to_net_dev(d) container_of(d, struct net_device, dev)

4
include/linux/phy.h
View File

@ -604,8 +604,6 @@ struct macsec_ops;
* handling shall be postponed until PHY has resumed
* @irq_rerun: Flag indicating interrupts occurred while PHY was suspended,
* requiring a rerun of the interrupt handler after resume
* @default_timestamp: Flag indicating whether we are using the phy
* timestamp as the default one
* @interface: enum phy_interface_t value
* @skb: Netlink message for cable diagnostics
* @nest: Netlink nest used for cable diagnostics
@ -669,8 +667,6 @@ struct phy_device {
unsigned irq_suspended:1;
unsigned irq_rerun:1;
unsigned default_timestamp:1;
int rate_matching;
enum phy_state state;

29
include/uapi/linux/ethtool_netlink.h
View File

@ -57,9 +57,6 @@ enum {
ETHTOOL_MSG_PLCA_GET_STATUS,
ETHTOOL_MSG_MM_GET,
ETHTOOL_MSG_MM_SET,
ETHTOOL_MSG_TS_GET,
ETHTOOL_MSG_TS_LIST_GET,
ETHTOOL_MSG_TS_SET,
/* add new constants above here */
__ETHTOOL_MSG_USER_CNT,
@ -112,8 +109,6 @@ enum {
ETHTOOL_MSG_PLCA_NTF,
ETHTOOL_MSG_MM_GET_REPLY,
ETHTOOL_MSG_MM_NTF,
ETHTOOL_MSG_TS_GET_REPLY,
ETHTOOL_MSG_TS_LIST_GET_REPLY,
/* add new constants above here */
__ETHTOOL_MSG_KERNEL_CNT,
@ -980,30 +975,6 @@ enum {
ETHTOOL_A_MM_MAX = (__ETHTOOL_A_MM_CNT - 1)
};
/* TS LAYER */
enum {
ETHTOOL_A_TS_UNSPEC,
ETHTOOL_A_TS_HEADER, /* nest - _A_HEADER_* */
ETHTOOL_A_TS_LAYER, /* u32 */
/* add new constants above here */
__ETHTOOL_A_TS_CNT,
ETHTOOL_A_TS_MAX = (__ETHTOOL_A_TS_CNT - 1)
};
/* TS LIST LAYER */
enum {
ETHTOOL_A_TS_LIST_UNSPEC,
ETHTOOL_A_TS_LIST_HEADER, /* nest - _A_HEADER_* */
ETHTOOL_A_TS_LIST_LAYER, /* array, u32 */
/* add new constants above here */
__ETHTOOL_A_TS_LIST_CNT,
ETHTOOL_A_TS_LIST_MAX = (__ETHTOOL_A_TS_LIST_CNT - 1)
};
/* generic netlink info */
#define ETHTOOL_GENL_NAME "ethtool"
#define ETHTOOL_GENL_VERSION 1

18
include/uapi/linux/net_tstamp.h
View File

@ -13,16 +13,6 @@
#include <linux/types.h>
#include <linux/socket.h> /* for SO_TIMESTAMPING */
/* Layer of the TIMESTAMPING provider */
enum timestamping_layer {
NO_TIMESTAMPING,
SOFTWARE_TIMESTAMPING,
MAC_TIMESTAMPING,
PHY_TIMESTAMPING,
__TIMESTAMPING_COUNT,
};
/* SO_TIMESTAMPING flags */
enum {
SOF_TIMESTAMPING_TX_HARDWARE = (1<<0),
@ -58,14 +48,6 @@ enum {
SOF_TIMESTAMPING_TX_SCHED | \
SOF_TIMESTAMPING_TX_ACK)
#define SOF_TIMESTAMPING_SOFTWARE_MASK (SOF_TIMESTAMPING_RX_SOFTWARE | \
SOF_TIMESTAMPING_TX_SOFTWARE | \
SOF_TIMESTAMPING_SOFTWARE)
#define SOF_TIMESTAMPING_HARDWARE_MASK (SOF_TIMESTAMPING_RX_HARDWARE | \
SOF_TIMESTAMPING_TX_HARDWARE | \
SOF_TIMESTAMPING_RAW_HARDWARE)
/**
* struct so_timestamping - SO_TIMESTAMPING parameter
*

3
net/core/dev.c
View File

@ -10212,9 +10212,6 @@ int register_netdevice(struct net_device *dev)
dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U, GFP_KERNEL, 0, NULL);
if (dev->ethtool_ops->get_ts_info)
dev->ts_layer = MAC_TIMESTAMPING;
out:
return ret;

36
net/core/dev_ioctl.c
View File

@ -259,7 +259,9 @@ static int dev_eth_ioctl(struct net_device *dev,
* @dev: Network device
* @cfg: Timestamping configuration structure
*
* Helper for calling the selected hardware provider timestamping.
* Helper for enforcing a common policy that phylib timestamping, if available,
* should take precedence in front of hardware timestamping provided by the
* netdev.
*
* Note: phy_mii_ioctl() only handles SIOCSHWTSTAMP (not SIOCGHWTSTAMP), and
* there only exists a phydev->mii_ts->hwtstamp() method. So this will return
@ -269,14 +271,10 @@ static int dev_eth_ioctl(struct net_device *dev,
static int dev_get_hwtstamp_phylib(struct net_device *dev,
struct kernel_hwtstamp_config *cfg)
{
enum timestamping_layer ts_layer = dev->ts_layer;
if (ts_layer == PHY_TIMESTAMPING)
if (phy_has_hwtstamp(dev->phydev))
return phy_hwtstamp_get(dev->phydev, cfg);
else if (ts_layer == MAC_TIMESTAMPING)
return dev->netdev_ops->ndo_hwtstamp_get(dev, cfg);
return -EOPNOTSUPP;
return dev->netdev_ops->ndo_hwtstamp_get(dev, cfg);
}
static int dev_get_hwtstamp(struct net_device *dev, struct ifreq *ifr)
@ -317,8 +315,9 @@ static int dev_get_hwtstamp(struct net_device *dev, struct ifreq *ifr)
* @cfg: Timestamping configuration structure
* @extack: Netlink extended ack message structure, for error reporting
*
* Helper for calling the selected hardware provider timestamping.
* If the netdev driver needs to perform specific actions even for PHY
* Helper for enforcing a common policy that phylib timestamping, if available,
* should take precedence in front of hardware timestamping provided by the
* netdev. If the netdev driver needs to perform specific actions even for PHY
* timestamping to work properly (a switch port must trap the timestamped
* frames and not forward them), it must set IFF_SEE_ALL_HWTSTAMP_REQUESTS in
* dev->priv_flags.
@ -328,26 +327,20 @@ int dev_set_hwtstamp_phylib(struct net_device *dev,
struct netlink_ext_ack *extack)
{
const struct net_device_ops *ops = dev->netdev_ops;
enum timestamping_layer ts_layer = dev->ts_layer;
bool phy_ts = phy_has_hwtstamp(dev->phydev);
struct kernel_hwtstamp_config old_cfg = {};
bool changed = false;
int err;
cfg->source = ts_layer;
cfg->source = phy_ts ? HWTSTAMP_SOURCE_PHYLIB : HWTSTAMP_SOURCE_NETDEV;
if (ts_layer != PHY_TIMESTAMPING &&
ts_layer != MAC_TIMESTAMPING)
return -EOPNOTSUPP;
if (ts_layer == PHY_TIMESTAMPING &&
dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS) {
if (phy_ts && (dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS)) {
err = ops->ndo_hwtstamp_get(dev, &old_cfg);
if (err)
return err;
}
if (ts_layer == MAC_TIMESTAMPING ||
dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS) {
if (!phy_ts || (dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS)) {
err = ops->ndo_hwtstamp_set(dev, cfg, extack);
if (err) {
if (extack->_msg)
@ -356,11 +349,10 @@ int dev_set_hwtstamp_phylib(struct net_device *dev,
}
}
if (ts_layer == PHY_TIMESTAMPING &&
dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS)
if (phy_ts && (dev->priv_flags & IFF_SEE_ALL_HWTSTAMP_REQUESTS))
changed = kernel_hwtstamp_config_changed(&old_cfg, cfg);
if (ts_layer == PHY_TIMESTAMPING) {
if (phy_ts) {
err = phy_hwtstamp_set(dev->phydev, cfg, extack);
if (err) {
if (changed)

10
net/core/timestamping.c
View File

@ -21,7 +21,6 @@ static unsigned int classify(const struct sk_buff *skb)
void skb_clone_tx_timestamp(struct sk_buff *skb)
{
enum timestamping_layer ts_layer;
struct mii_timestamper *mii_ts;
struct sk_buff *clone;
unsigned int type;
@ -29,10 +28,6 @@ void skb_clone_tx_timestamp(struct sk_buff *skb)
if (!skb->sk)
return;
ts_layer = skb->dev->ts_layer;
if (ts_layer != PHY_TIMESTAMPING)
return;
type = classify(skb);
if (type == PTP_CLASS_NONE)
return;
@ -49,17 +44,12 @@ EXPORT_SYMBOL_GPL(skb_clone_tx_timestamp);
bool skb_defer_rx_timestamp(struct sk_buff *skb)
{
enum timestamping_layer ts_layer;
struct mii_timestamper *mii_ts;
unsigned int type;
if (!skb->dev || !skb->dev->phydev || !skb->dev->phydev->mii_ts)
return false;
ts_layer = skb->dev->ts_layer;
if (ts_layer != PHY_TIMESTAMPING)
return false;
if (skb_headroom(skb) < ETH_HLEN)
return false;

2
net/ethtool/Makefile
View File

@ -8,4 +8,4 @@ ethtool_nl-y := netlink.o bitset.o strset.o linkinfo.o linkmodes.o rss.o \
linkstate.o debug.o wol.o features.o privflags.o rings.o \
channels.o coalesce.o pause.o eee.o tsinfo.o cabletest.o \
tunnels.o fec.o eeprom.o stats.o phc_vclocks.o mm.o \
module.o pse-pd.o plca.o mm.o ts.o
module.o pse-pd.o plca.o mm.o

19
net/ethtool/common.c
View File

@ -633,28 +633,13 @@ int __ethtool_get_ts_info(struct net_device *dev, struct ethtool_ts_info *info)
{
const struct ethtool_ops *ops = dev->ethtool_ops;
struct phy_device *phydev = dev->phydev;
enum timestamping_layer ts_layer;
int ret;
memset(info, 0, sizeof(*info));
info->cmd = ETHTOOL_GET_TS_INFO;
ts_layer = dev->ts_layer;
if (ts_layer == SOFTWARE_TIMESTAMPING) {
ret = ops->get_ts_info(dev, info);
if (ret)
return ret;
info->so_timestamping &= ~SOF_TIMESTAMPING_HARDWARE_MASK;
info->phc_index = -1;
info->rx_filters = 0;
info->tx_types = 0;
return 0;
}
if (ts_layer == PHY_TIMESTAMPING)
if (phy_has_tsinfo(phydev))
return phy_ts_info(phydev, info);
if (ts_layer == MAC_TIMESTAMPING)
if (ops->get_ts_info)
return ops->get_ts_info(dev, info);
info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |

1
net/ethtool/common.h
View File

@ -35,7 +35,6 @@ extern const char wol_mode_names[][ETH_GSTRING_LEN];
extern const char sof_timestamping_names[][ETH_GSTRING_LEN];
extern const char ts_tx_type_names[][ETH_GSTRING_LEN];
extern const char ts_rx_filter_names[][ETH_GSTRING_LEN];
extern const char ts_layer_names[][ETH_GSTRING_LEN];
extern const char udp_tunnel_type_names[][ETH_GSTRING_LEN];
int __ethtool_get_link(struct net_device *dev);

28
net/ethtool/netlink.c
View File

@ -306,9 +306,6 @@ ethnl_default_requests[__ETHTOOL_MSG_USER_CNT] = {
[ETHTOOL_MSG_PLCA_GET_STATUS] = &ethnl_plca_status_request_ops,
[ETHTOOL_MSG_MM_GET] = &ethnl_mm_request_ops,
[ETHTOOL_MSG_MM_SET] = &ethnl_mm_request_ops,
[ETHTOOL_MSG_TS_GET] = &ethnl_ts_request_ops,
[ETHTOOL_MSG_TS_LIST_GET] = &ethnl_ts_list_request_ops,
[ETHTOOL_MSG_TS_SET] = &ethnl_ts_request_ops,
};
static struct ethnl_dump_ctx *ethnl_dump_context(struct netlink_callback *cb)
@ -1131,31 +1128,6 @@ static const struct genl_ops ethtool_genl_ops[] = {
.policy = ethnl_mm_set_policy,
.maxattr = ARRAY_SIZE(ethnl_mm_set_policy) - 1,
},
{
.cmd = ETHTOOL_MSG_TS_GET,
.doit = ethnl_default_doit,
.start = ethnl_default_start,
.dumpit = ethnl_default_dumpit,
.done = ethnl_default_done,
.policy = ethnl_ts_get_policy,
.maxattr = ARRAY_SIZE(ethnl_ts_get_policy) - 1,
},
{
.cmd = ETHTOOL_MSG_TS_LIST_GET,
.doit = ethnl_default_doit,
.start = ethnl_default_start,
.dumpit = ethnl_default_dumpit,
.done = ethnl_default_done,
.policy = ethnl_ts_get_policy,
.maxattr = ARRAY_SIZE(ethnl_ts_get_policy) - 1,
},
{
.cmd = ETHTOOL_MSG_TS_SET,
.flags = GENL_UNS_ADMIN_PERM,
.doit = ethnl_default_set_doit,
.policy = ethnl_ts_set_policy,
.maxattr = ARRAY_SIZE(ethnl_ts_set_policy) - 1,
},
};
static const struct genl_multicast_group ethtool_nl_mcgrps[] = {

4
net/ethtool/netlink.h
View File

@ -395,8 +395,6 @@ extern const struct ethnl_request_ops ethnl_rss_request_ops;
extern const struct ethnl_request_ops ethnl_plca_cfg_request_ops;
extern const struct ethnl_request_ops ethnl_plca_status_request_ops;
extern const struct ethnl_request_ops ethnl_mm_request_ops;
extern const struct ethnl_request_ops ethnl_ts_request_ops;
extern const struct ethnl_request_ops ethnl_ts_list_request_ops;
extern const struct nla_policy ethnl_header_policy[ETHTOOL_A_HEADER_FLAGS + 1];
extern const struct nla_policy ethnl_header_policy_stats[ETHTOOL_A_HEADER_FLAGS + 1];
@ -443,8 +441,6 @@ extern const struct nla_policy ethnl_plca_set_cfg_policy[ETHTOOL_A_PLCA_MAX + 1]
extern const struct nla_policy ethnl_plca_get_status_policy[ETHTOOL_A_PLCA_HEADER + 1];
extern const struct nla_policy ethnl_mm_get_policy[ETHTOOL_A_MM_HEADER + 1];
extern const struct nla_policy ethnl_mm_set_policy[ETHTOOL_A_MM_MAX + 1];
extern const struct nla_policy ethnl_ts_get_policy[ETHTOOL_A_TS_HEADER + 1];
extern const struct nla_policy ethnl_ts_set_policy[ETHTOOL_A_TS_MAX + 1];
int ethnl_set_features(struct sk_buff *skb, struct genl_info *info);
int ethnl_act_cable_test(struct sk_buff *skb, struct genl_info *info);

244
net/ethtool/ts.c
View File

@ -1,244 +0,0 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <linux/net_tstamp.h>
#include <linux/phy.h>
#include "netlink.h"
#include "common.h"
#include "bitset.h"
struct ts_req_info {
struct ethnl_req_info base;
};
struct ts_reply_data {
struct ethnl_reply_data base;
enum timestamping_layer ts_layer;
};
#define TS_REPDATA(__reply_base) \
container_of(__reply_base, struct ts_reply_data, base)
/* TS_GET */
const struct nla_policy ethnl_ts_get_policy[] = {
[ETHTOOL_A_TS_HEADER] =
NLA_POLICY_NESTED(ethnl_header_policy),
};
static int ts_prepare_data(const struct ethnl_req_info *req_base,
struct ethnl_reply_data *reply_base,
const struct genl_info *info)
{
struct ts_reply_data *data = TS_REPDATA(reply_base);
struct net_device *dev = reply_base->dev;
int ret;
ret = ethnl_ops_begin(dev);
if (ret < 0)
return ret;
data->ts_layer = dev->ts_layer;
ethnl_ops_complete(dev);
return ret;
}
static int ts_reply_size(const struct ethnl_req_info *req_base,
const struct ethnl_reply_data *reply_base)
{
return nla_total_size(sizeof(u32));
}
static int ts_fill_reply(struct sk_buff *skb,
const struct ethnl_req_info *req_base,
const struct ethnl_reply_data *reply_base)
{
struct ts_reply_data *data = TS_REPDATA(reply_base);
return nla_put_u32(skb, ETHTOOL_A_TS_LAYER, data->ts_layer);
}
/* TS_SET */
const struct nla_policy ethnl_ts_set_policy[] = {
[ETHTOOL_A_TS_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy),
[ETHTOOL_A_TS_LAYER] = NLA_POLICY_RANGE(NLA_U32, 0,
__TIMESTAMPING_COUNT - 1)
};
static int ethnl_set_ts_validate(struct ethnl_req_info *req_info,
struct genl_info *info)
{
struct nlattr **tb = info->attrs;
const struct net_device_ops *ops = req_info->dev->netdev_ops;
if (!ops->ndo_hwtstamp_set)
return -EOPNOTSUPP;
if (!tb[ETHTOOL_A_TS_LAYER])
return 0;
return 1;
}
static int ethnl_set_ts(struct ethnl_req_info *req_info, struct genl_info *info)
{
struct net_device *dev = req_info->dev;
const struct ethtool_ops *ops = dev->ethtool_ops;
struct kernel_hwtstamp_config config = {0};
struct nlattr **tb = info->attrs;
enum timestamping_layer ts_layer;
bool mod = false;
int ret;
ts_layer = dev->ts_layer;
ethnl_update_u32(&ts_layer, tb[ETHTOOL_A_TS_LAYER], &mod);
if (!mod)
return 0;
if (ts_layer == SOFTWARE_TIMESTAMPING) {
struct ethtool_ts_info ts_info = {0};
if (!ops->get_ts_info) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_TS_LAYER],
"this net device cannot support timestamping");
return -EINVAL;
}
ops->get_ts_info(dev, &ts_info);
if ((ts_info.so_timestamping &
SOF_TIMESTAMPING_SOFTWARE_MASK) !=
SOF_TIMESTAMPING_SOFTWARE_MASK) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_TS_LAYER],
"this net device cannot support software timestamping");
return -EINVAL;
}
} else if (ts_layer == MAC_TIMESTAMPING) {
struct ethtool_ts_info ts_info = {0};
if (!ops->get_ts_info) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_TS_LAYER],
"this net device cannot support timestamping");
return -EINVAL;
}
ops->get_ts_info(dev, &ts_info);
if ((ts_info.so_timestamping &
SOF_TIMESTAMPING_HARDWARE_MASK) !=
SOF_TIMESTAMPING_HARDWARE_MASK) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_TS_LAYER],
"this net device cannot support hardware timestamping");
return -EINVAL;
}
} else if (ts_layer == PHY_TIMESTAMPING && !phy_has_tsinfo(dev->phydev)) {
NL_SET_ERR_MSG_ATTR(info->extack, tb[ETHTOOL_A_TS_LAYER],
"this phy device cannot support timestamping");
return -EINVAL;
}
/* Disable time stamping in the current layer. */
if (netif_device_present(dev) &&
(dev->ts_layer == PHY_TIMESTAMPING ||
dev->ts_layer == MAC_TIMESTAMPING)) {
ret = dev_set_hwtstamp_phylib(dev, &config, info->extack);
if (ret < 0)
return ret;
}
dev->ts_layer = ts_layer;
return 1;
}
const struct ethnl_request_ops ethnl_ts_request_ops = {
.request_cmd = ETHTOOL_MSG_TS_GET,
.reply_cmd = ETHTOOL_MSG_TS_GET_REPLY,
.hdr_attr = ETHTOOL_A_TS_HEADER,
.req_info_size = sizeof(struct ts_req_info),
.reply_data_size = sizeof(struct ts_reply_data),
.prepare_data = ts_prepare_data,
.reply_size = ts_reply_size,
.fill_reply = ts_fill_reply,
.set_validate = ethnl_set_ts_validate,
.set = ethnl_set_ts,
};
/* TS_LIST_GET */
struct ts_list_reply_data {
struct ethnl_reply_data base;
enum timestamping_layer ts_layer[__TIMESTAMPING_COUNT];
u8 num_ts;
};
#define TS_LIST_REPDATA(__reply_base) \
container_of(__reply_base, struct ts_list_reply_data, base)
static int ts_list_prepare_data(const struct ethnl_req_info *req_base,
struct ethnl_reply_data *reply_base,
const struct genl_info *info)
{
struct ts_list_reply_data *data = TS_LIST_REPDATA(reply_base);
struct net_device *dev = reply_base->dev;
const struct ethtool_ops *ops = dev->ethtool_ops;
int ret, i = 0;
ret = ethnl_ops_begin(dev);
if (ret < 0)
return ret;
if (phy_has_tsinfo(dev->phydev))
data->ts_layer[i++] = PHY_TIMESTAMPING;
if (ops->get_ts_info) {
struct ethtool_ts_info ts_info = {0};
ops->get_ts_info(dev, &ts_info);
if (ts_info.so_timestamping &
SOF_TIMESTAMPING_HARDWARE_MASK)
data->ts_layer[i++] = MAC_TIMESTAMPING;
if (ts_info.so_timestamping &
SOF_TIMESTAMPING_SOFTWARE_MASK)
data->ts_layer[i++] = SOFTWARE_TIMESTAMPING;
}
data->num_ts = i;
ethnl_ops_complete(dev);
return ret;
}
static int ts_list_reply_size(const struct ethnl_req_info *req_base,
const struct ethnl_reply_data *reply_base)
{
struct ts_list_reply_data *data = TS_LIST_REPDATA(reply_base);
return nla_total_size(sizeof(u32)) * data->num_ts;
}
static int ts_list_fill_reply(struct sk_buff *skb,
const struct ethnl_req_info *req_base,
const struct ethnl_reply_data *reply_base)
{
struct ts_list_reply_data *data = TS_LIST_REPDATA(reply_base);
return nla_put(skb, ETHTOOL_A_TS_LIST_LAYER, sizeof(u32) * data->num_ts, data->ts_layer);
}
const struct ethnl_request_ops ethnl_ts_list_request_ops = {
.request_cmd = ETHTOOL_MSG_TS_LIST_GET,
.reply_cmd = ETHTOOL_MSG_TS_LIST_GET_REPLY,
.hdr_attr = ETHTOOL_A_TS_HEADER,
.req_info_size = sizeof(struct ts_req_info),
.reply_data_size = sizeof(struct ts_list_reply_data),
.prepare_data = ts_list_prepare_data,
.reply_size = ts_list_reply_size,
.fill_reply = ts_list_fill_reply,
};