Skip to contentSkip to conversation

Add ability to flash modules' firmware

PATCH Superseded Danielle Ratson 3 participants 27 messages Apr 24, 2024 – May 27, 2024

Subsystems (7)

v5 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v5 cover Add ability to flash modules' firmware

CMIS compliant modules such as QSFP-DD might be running a firmware that can be updated in a vendor-neutral way by exchanging messages between the host and the module as described in section 7.2.2 of revision 4.0 of the CMIS standard.

According to the CMIS standard, the firmware update process is done using a CDB commands sequence.

CDB (Command Data Block Message Communication) reads and writes are performed on memory map pages 9Fh-AFh according to the CMIS standard, section 8.12 of revision 4.0.

Add a pair of new ethtool messages that allow:

* User space to trigger firmware update of transceiver modules

* The kernel to notify user space about the progress of the process

The user interface is designed to be asynchronous in order to avoid RTNL being held for too long and to allow several modules to be updated simultaneously. The interface is designed with CMIS compliant modules in mind, but kept generic enough to accommodate future use cases, if these arise.

The kernel interface that will implement the firmware update using CDB command will include 2 layers that will be added under ethtool:

* The upper layer that will be triggered from the module layer, is cmis_ fw_update.
* The lower one is cmis_cdb.

In the future there might be more operations to implement using CDB commands. Therefore, the idea is to keep the cmis_cdb interface clean and the cmis_fw_update specific to the cdb commands handling it.

The communication between the kernel and the driver will be done using two ethtool operations that enable reading and writing the transceiver module EEPROM.
The operation ethtool_ops::get_module_eeprom_by_page, that is already implemented, will be used for reading from the EEPROM the CDB reply, e.g. reading module setting, state, etc.
The operation ethtool_ops::set_module_eeprom_by_page, that is added in the current patchset, will be used for writing to the EEPROM the CDB command such as start firmware image, run firmware image, etc.

Therefore in order for a driver to implement module flashing, that driver needs to implement the two functions mentioned above.

Patchset overview:
Patch #1-#2: Implement the EEPROM writing in mlxsw. Patch #3: Define the interface between the kernel and user space. Patch #4: Add ability to notify the flashing firmware progress. Patch #5: Add firmware flashing in progress flag.
Patch #6: Add extended compliance codes.
Patch #7: Add the cdb layer.
Patch #8: Add the fw_update layer.
Patch #9: Add ability to flash transceiver modules' firmware. Patch #10: Veto problematic scenarios.

v5:
* Drop all the inline in cmis_cdb.c.
* Modify tools/net/ynl/Makefile.deps so the ynl file will
* include the ethtool.h changes.
* u64>uint for 'total' and 'done' attrs.
* Translate the enum from ethtool_netlink.h to YAML.

Danielle Ratson (8):
ethtool: Add an interface for flashing transceiver modules' firmware
ethtool: Add flashing transceiver modules' firmware notifications
ability
include: netdevice: Add module firmware flashing in progress flag to
net_device
net: sfp: Add more extended compliance codes
ethtool: cmis_cdb: Add a layer for supporting CDB commands
ethtool: cmis_fw_update: add a layer for supporting firmware update
using CDB
ethtool: Add ability to flash transceiver modules' firmware
ethtool: Veto some operations during firmware flashing process

Ido Schimmel (2):
ethtool: Add ethtool operation to write to a transceiver module EEPROM
mlxsw: Implement ethtool operation to write to a transceiver module
EEPROM

 Documentation/netlink/specs/ethtool.yaml      |  55 ++
 Documentation/networking/ethtool-netlink.rst  |  62 ++
 .../net/ethernet/mellanox/mlxsw/core_env.c    |  57 ++
 .../net/ethernet/mellanox/mlxsw/core_env.h    |   6 +
 drivers/net/ethernet/mellanox/mlxsw/minimal.c |  15 +
 .../mellanox/mlxsw/spectrum_ethtool.c         |  15 +
 include/linux/ethtool.h                       |  20 +-
 include/linux/netdevice.h                     |   4 +-
 include/linux/sfp.h                           |   6 +
 include/uapi/linux/ethtool.h                  |  18 +
 include/uapi/linux/ethtool_netlink.h          |  20 +
 net/ethtool/Makefile                          |   2 +-
 net/ethtool/cmis.h                            | 123 ++++
 net/ethtool/cmis_cdb.c                        | 577 ++++++++++++++++++
 net/ethtool/cmis_fw_update.c                  | 397 ++++++++++++
 net/ethtool/eeprom.c                          |   6 +
 net/ethtool/ioctl.c                           |  12 +
 net/ethtool/module.c                          | 286 +++++++++
 net/ethtool/module_fw.h                       |  38 ++
 net/ethtool/netlink.c                         |  37 +-
 net/ethtool/netlink.h                         |   2 +
 tools/net/ynl/Makefile.deps                   |   3 +-
 22 files changed, 1749 insertions(+), 12 deletions(-)
 create mode 100644 net/ethtool/cmis.h
 create mode 100644 net/ethtool/cmis_cdb.c
 create mode 100644 net/ethtool/cmis_fw_update.c
 create mode 100644 net/ethtool/module_fw.h
Signature · 1 line
2.43.0
#1 lore raw

PATCH v5 1/10 ethtool: Add ethtool operation to write to a transceiver module EEPROM

From: Ido Schimmel <[email protected]>

Ethtool can already retrieve information from a transceiver module EEPROM by invoking the ethtool_ops::get_module_eeprom_by_page operation. Add a corresponding operation that allows ethtool to write to a transceiver module EEPROM.

The new write operation is purely an in-kernel API and is not exposed to user space.

The purpose of this operation is not to enable arbitrary read / write access, but to allow the kernel to write to specific addresses as part of transceiver module firmware flashing. In the future, more functionality can be implemented on top of these read / write operations.

Adjust the comments of the 'ethtool_module_eeprom' structure as it is no longer used only for read access.

---
 include/linux/ethtool.h | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)
include/linux/ethtool.h +12 -8
index 6fd9107d3cc0..fa1a5d0e3213 100644
@@ -504,17 +504,16 @@ struct ethtool_ts_stats {
 #define ETH_MODULE_MAX_I2C_ADDRESS	0x7f
 
 /**
- * struct ethtool_module_eeprom - EEPROM dump from specified page
- * @offset: Offset within the specified EEPROM page to begin read, in bytes.
- * @length: Number of bytes to read.
- * @page: Page number to read from.
- * @bank: Page bank number to read from, if applicable by EEPROM spec.
+ * struct ethtool_module_eeprom - plug-in module EEPROM read / write parameters
+ * @offset: When @offset is 0-127, it is used as an address to the Lower Memory
+ *	(@page must be 0). Otherwise, it is used as an address to the
+ *	Upper Memory.
+ * @length: Number of bytes to read / write.
+ * @page: Page number.
+ * @bank: Bank number, if supported by EEPROM spec.
  * @i2c_address: I2C address of a page. Value less than 0x7f expected. Most
  *	EEPROMs use 0x50 or 0x51.
  * @data: Pointer to buffer with EEPROM data of @length size.
- *
- * This can be used to manage pages during EEPROM dump in ethtool and pass
- * required information to the driver.
  */
 struct ethtool_module_eeprom {
 	u32	offset;
@@ -822,6 +821,8 @@ struct ethtool_rxfh_param {
  * @get_module_eeprom_by_page: Get a region of plug-in module EEPROM data from
  *	specified page. Returns a negative error code or the amount of bytes
  *	read.
+ * @set_module_eeprom_by_page: Write to a region of plug-in module EEPROM,
+ *	from kernel space only. Returns a negative error code or zero.
  * @get_eth_phy_stats: Query some of the IEEE 802.3 PHY statistics.
  * @get_eth_mac_stats: Query some of the IEEE 802.3 MAC statistics.
  * @get_eth_ctrl_stats: Query some of the IEEE 802.3 MAC Ctrl statistics.
@@ -956,6 +957,9 @@ struct ethtool_ops {
 	int	(*get_module_eeprom_by_page)(struct net_device *dev,
 					     const struct ethtool_module_eeprom *page,
 					     struct netlink_ext_ack *extack);
+	int	(*set_module_eeprom_by_page)(struct net_device *dev,
+					     const struct ethtool_module_eeprom *page,
+					     struct netlink_ext_ack *extack);
 	void	(*get_eth_phy_stats)(struct net_device *dev,
 				     struct ethtool_eth_phy_stats *phy_stats);
 	void	(*get_eth_mac_stats)(struct net_device *dev,
Signature · 1 line
2.43.0
#2 lore raw

PATCH v5 2/10 mlxsw: Implement ethtool operation to write to a transceiver module EEPROM

In reply to Danielle Ratson

From: Ido Schimmel <[email protected]>

Implement the ethtool_ops::set_module_eeprom_by_page operation to allow ethtool to write to a transceiver module EEPROM, in a similar fashion to the ethtool_ops::get_module_eeprom_by_page operation.

---
 .../net/ethernet/mellanox/mlxsw/core_env.c    | 57 +++++++++++++++++++
 .../net/ethernet/mellanox/mlxsw/core_env.h    |  6 ++
 drivers/net/ethernet/mellanox/mlxsw/minimal.c | 15 +++++
 .../mellanox/mlxsw/spectrum_ethtool.c         | 15 +++++
 4 files changed, 93 insertions(+)
drivers/net/ethernet/mellanox/mlxsw/core_env.c +57 -0
index 6c06b0592760..294e758f1067 100644
@@ -513,6 +513,63 @@ mlxsw_env_get_module_eeprom_by_page(struct mlxsw_core *mlxsw_core,
 }
 EXPORT_SYMBOL(mlxsw_env_get_module_eeprom_by_page);
 
+int
+mlxsw_env_set_module_eeprom_by_page(struct mlxsw_core *mlxsw_core,
+				    u8 slot_index, u8 module,
+				    const struct ethtool_module_eeprom *page,
+				    struct netlink_ext_ack *extack)
+{
+	struct mlxsw_env *mlxsw_env = mlxsw_core_env(mlxsw_core);
+	u32 bytes_written = 0;
+	u16 device_addr;
+	int err;
+
+	if (!mlxsw_env_linecard_is_active(mlxsw_env, slot_index)) {
+		NL_SET_ERR_MSG_MOD(extack,
+				   "Cannot write to EEPROM of a module on an inactive line card");
+		return -EIO;
+	}
+
+	err = mlxsw_env_validate_module_type(mlxsw_core, slot_index, module);
+	if (err) {
+		NL_SET_ERR_MSG_MOD(extack, "EEPROM is not equipped on port module type");
+		return err;
+	}
+
+	device_addr = page->offset;
+
+	while (bytes_written < page->length) {
+		char mcia_pl[MLXSW_REG_MCIA_LEN];
+		char eeprom_tmp[128] = {};
+		u8 size;
+
+		size = min_t(u8, page->length - bytes_written,
+			     mlxsw_env->max_eeprom_len);
+
+		mlxsw_reg_mcia_pack(mcia_pl, slot_index, module, page->page,
+				    device_addr + bytes_written, size,
+				    page->i2c_address);
+		mlxsw_reg_mcia_bank_number_set(mcia_pl, page->bank);
+		memcpy(eeprom_tmp, page->data + bytes_written, size);
+		mlxsw_reg_mcia_eeprom_memcpy_to(mcia_pl, eeprom_tmp);
+
+		err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcia), mcia_pl);
+		if (err) {
+			NL_SET_ERR_MSG_MOD(extack, "Failed to access module's EEPROM");
+			return err;
+		}
+
+		err = mlxsw_env_mcia_status_process(mcia_pl, extack);
+		if (err)
+			return err;
+
+		bytes_written += size;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(mlxsw_env_set_module_eeprom_by_page);
+
 static int mlxsw_env_module_reset(struct mlxsw_core *mlxsw_core, u8 slot_index,
 				  u8 module)
 {
drivers/net/ethernet/mellanox/mlxsw/core_env.h +6 -0
index a197e3ae069c..e4ff17869400 100644
@@ -28,6 +28,12 @@ mlxsw_env_get_module_eeprom_by_page(struct mlxsw_core *mlxsw_core,
 				    const struct ethtool_module_eeprom *page,
 				    struct netlink_ext_ack *extack);
 
+int
+mlxsw_env_set_module_eeprom_by_page(struct mlxsw_core *mlxsw_core,
+				    u8 slot_index, u8 module,
+				    const struct ethtool_module_eeprom *page,
+				    struct netlink_ext_ack *extack);
+
 int mlxsw_env_reset_module(struct net_device *netdev,
 			   struct mlxsw_core *mlxsw_core, u8 slot_index,
 			   u8 module, u32 *flags);
drivers/net/ethernet/mellanox/mlxsw/minimal.c +15 -0
index f0ceb196a6ce..448263423e36 100644
@@ -140,6 +140,20 @@ mlxsw_m_get_module_eeprom_by_page(struct net_device *netdev,
 						   page, extack);
 }
 
+static int
+mlxsw_m_set_module_eeprom_by_page(struct net_device *netdev,
+				  const struct ethtool_module_eeprom *page,
+				  struct netlink_ext_ack *extack)
+{
+	struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
+	struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
+
+	return mlxsw_env_set_module_eeprom_by_page(core,
+						   mlxsw_m_port->slot_index,
+						   mlxsw_m_port->module,
+						   page, extack);
+}
+
 static int mlxsw_m_reset(struct net_device *netdev, u32 *flags)
 {
 	struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
@@ -181,6 +195,7 @@ static const struct ethtool_ops mlxsw_m_port_ethtool_ops = {
 	.get_module_info	= mlxsw_m_get_module_info,
 	.get_module_eeprom	= mlxsw_m_get_module_eeprom,
 	.get_module_eeprom_by_page = mlxsw_m_get_module_eeprom_by_page,
+	.set_module_eeprom_by_page = mlxsw_m_set_module_eeprom_by_page,
 	.reset			= mlxsw_m_reset,
 	.get_module_power_mode	= mlxsw_m_get_module_power_mode,
 	.set_module_power_mode	= mlxsw_m_set_module_power_mode,
drivers/net/ethernet/mellanox/mlxsw/spectrum_ethtool.c +15 -0
index a755b0a901d3..c79da1411d33 100644
@@ -1067,6 +1067,20 @@ mlxsw_sp_get_module_eeprom_by_page(struct net_device *dev,
 						   module, page, extack);
 }
 
+static int
+mlxsw_sp_set_module_eeprom_by_page(struct net_device *dev,
+				   const struct ethtool_module_eeprom *page,
+				   struct netlink_ext_ack *extack)
+{
+	struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+	u8 slot_index = mlxsw_sp_port->mapping.slot_index;
+	u8 module = mlxsw_sp_port->mapping.module;
+
+	return mlxsw_env_set_module_eeprom_by_page(mlxsw_sp->core, slot_index,
+						   module, page, extack);
+}
+
 static int
 mlxsw_sp_get_ts_info(struct net_device *netdev, struct ethtool_ts_info *info)
 {
@@ -1256,6 +1270,7 @@ const struct ethtool_ops mlxsw_sp_port_ethtool_ops = {
 	.get_module_info		= mlxsw_sp_get_module_info,
 	.get_module_eeprom		= mlxsw_sp_get_module_eeprom,
 	.get_module_eeprom_by_page	= mlxsw_sp_get_module_eeprom_by_page,
+	.set_module_eeprom_by_page	= mlxsw_sp_set_module_eeprom_by_page,
 	.get_ts_info			= mlxsw_sp_get_ts_info,
 	.get_eth_phy_stats		= mlxsw_sp_get_eth_phy_stats,
 	.get_eth_mac_stats		= mlxsw_sp_get_eth_mac_stats,
Signature · 1 line
2.43.0
#3 lore raw

PATCH v5 3/10 ethtool: Add an interface for flashing transceiver modules' firmware

In reply to Danielle Ratson

CMIS compliant modules such as QSFP-DD might be running a firmware that can be updated in a vendor-neutral way by exchanging messages between the host and the module as described in section 7.3.1 of revision 5.2 of the CMIS standard.

Add a pair of new ethtool messages that allow:

* User space to trigger firmware update of transceiver modules

* The kernel to notify user space about the progress of the process

The user interface is designed to be asynchronous in order to avoid RTNL being held for too long and to allow several modules to be updated simultaneously. The interface is designed with CMIS compliant modules in mind, but kept generic enough to accommodate future use cases, if these arise.

---

Notes:
v5:
* Modify tools/net/ynl/Makefile.deps so the ynl file will include the ethtool.h changes.
* u64>uint for 'total' and 'done' attrs.
* Translate the enum from ethtool_netlink.h to YAML.

v4:
* s/is composed from/consists of/.

 Documentation/netlink/specs/ethtool.yaml     | 55 +++++++++++++++++
 Documentation/networking/ethtool-netlink.rst | 62 ++++++++++++++++++++
 include/uapi/linux/ethtool.h                 | 18 ++++++
 include/uapi/linux/ethtool_netlink.h         | 20 +++++++
 tools/net/ynl/Makefile.deps                  |  3 +-
 5 files changed, 157 insertions(+), 1 deletion(-)
Documentation/netlink/specs/ethtool.yaml +55 -0
index 00dc61358be8..43c5f21e6096 100644
@@ -20,6 +20,10 @@ definitions:
     name: header-flags
     type: flags
     entries: [ compact-bitsets, omit-reply, stats ]
+  -
+    name: module-fw-flash-status
+    type: enum
+    entries: [ started, in_progress, completed, error ]
 
 attribute-sets:
   -
@@ -975,6 +979,32 @@ attribute-sets:
       -
         name: burst-tmr
         type: u32
+  -
+    name: module-fw-flash
+    attributes:
+      -
+        name: header
+        type: nest
+        nested-attributes: header
+      -
+        name: file-name
+        type: string
+      -
+        name: password
+        type: u32
+      -
+        name: status
+        type: u32
+        enum: module-fw-flash-status
+      -
+        name: status-msg
+        type: string
+      -
+        name: done
+        type: uint
+      -
+        name: total
+        type: uint
 
 operations:
   enum-model: directional
@@ -1730,3 +1760,28 @@ operations:
       name: mm-ntf
       doc: Notification for change in MAC Merge configuration.
       notify: mm-get
+    -
+      name: module-fw-flash-act
+      doc: Flash transceiver module firmware.
+
+      attribute-set: module-fw-flash
+
+      do:
+        request:
+          attributes:
+            - header
+            - file-name
+            - password
+    -
+      name: module-fw-flash-ntf
+      doc: Notification for firmware flashing progress and status.
+
+      attribute-set: module-fw-flash
+
+      event:
+        attributes:
+          - header
+          - status
+          - status-msg
+          - done
+          - total
Documentation/networking/ethtool-netlink.rst +62 -0

84 lines not on this page · raw message

include/uapi/linux/ethtool.h +18 -0
index 041e09c3515d..ac98328f527d 100644
@@ -877,6 +877,24 @@ enum ethtool_mm_verify_status {
 	ETHTOOL_MM_VERIFY_STATUS_DISABLED,
 };
 
+/**
+ * enum ethtool_module_fw_flash_status - plug-in module firmware flashing status
+ * @ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED: The firmware flashing process has
+ *	started.
+ * @ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS: The firmware flashing process
+ *	is in progress.
+ * @ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED: The firmware flashing process was
+ *	completed successfully.
+ * @ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR: The firmware flashing process was
+ *	stopped due to an error.
+ */
+enum ethtool_module_fw_flash_status {
+	ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED = 1,
+	ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS,
+	ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED,
+	ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR,
+};
+
 /**
  * struct ethtool_gstrings - string set for data tagging
  * @cmd: Command number = %ETHTOOL_GSTRINGS
include/uapi/linux/ethtool_netlink.h +20 -0
index f17dbe54bf5e..6fbd43d5a4ea 100644
@@ -57,6 +57,7 @@ enum {
 	ETHTOOL_MSG_PLCA_GET_STATUS,
 	ETHTOOL_MSG_MM_GET,
 	ETHTOOL_MSG_MM_SET,
+	ETHTOOL_MSG_MODULE_FW_FLASH_ACT,
 
 	/* add new constants above here */
 	__ETHTOOL_MSG_USER_CNT,
@@ -109,6 +110,7 @@ enum {
 	ETHTOOL_MSG_PLCA_NTF,
 	ETHTOOL_MSG_MM_GET_REPLY,
 	ETHTOOL_MSG_MM_NTF,
+	ETHTOOL_MSG_MODULE_FW_FLASH_NTF,
 
 	/* add new constants above here */
 	__ETHTOOL_MSG_KERNEL_CNT,
@@ -997,6 +999,24 @@ enum {
 	ETHTOOL_A_MM_MAX = (__ETHTOOL_A_MM_CNT - 1)
 };
 
+/* MODULE_FW_FLASH */
+
+enum {
+	ETHTOOL_A_MODULE_FW_FLASH_UNSPEC,
+	ETHTOOL_A_MODULE_FW_FLASH_HEADER,		/* nest - _A_HEADER_* */
+	ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME,		/* string */
+	ETHTOOL_A_MODULE_FW_FLASH_PASSWORD,		/* u32 */
+	ETHTOOL_A_MODULE_FW_FLASH_PAD,
+	ETHTOOL_A_MODULE_FW_FLASH_STATUS,		/* u32 */
+	ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG,		/* string */
+	ETHTOOL_A_MODULE_FW_FLASH_DONE,			/* uint */
+	ETHTOOL_A_MODULE_FW_FLASH_TOTAL,		/* uint */
+
+	/* add new constants above here */
+	__ETHTOOL_A_MODULE_FW_FLASH_CNT,
+	ETHTOOL_A_MODULE_FW_FLASH_MAX = (__ETHTOOL_A_MODULE_FW_FLASH_CNT - 1)
+};
+
 /* generic netlink info */
 #define ETHTOOL_GENL_NAME "ethtool"
 #define ETHTOOL_GENL_VERSION 1
tools/net/ynl/Makefile.deps +2 -1
index f4e8eb79c1b8..dbdca32a1c61 100644
@@ -16,7 +16,8 @@ get_hdr_inc=-D$(1) -include $(UAPI_PATH)/linux/$(2)
 
 CFLAGS_devlink:=$(call get_hdr_inc,_LINUX_DEVLINK_H_,devlink.h)
 CFLAGS_dpll:=$(call get_hdr_inc,_LINUX_DPLL_H,dpll.h)
-CFLAGS_ethtool:=$(call get_hdr_inc,_LINUX_ETHTOOL_NETLINK_H_,ethtool_netlink.h)
+CFLAGS_ethtool:=$(call get_hdr_inc,_LINUX_ETHTOOL_H,ethtool.h) \
+		$(call get_hdr_inc,_LINUX_ETHTOOL_NETLINK_H_,ethtool_netlink.h)
 CFLAGS_handshake:=$(call get_hdr_inc,_LINUX_HANDSHAKE_H,handshake.h)
 CFLAGS_mptcp_pm:=$(call get_hdr_inc,_LINUX_MPTCP_PM_H,mptcp_pm.h)
 CFLAGS_netdev:=$(call get_hdr_inc,_LINUX_NETDEV_H,netdev.h)
Signature · 1 line
2.43.0
maintainer
#4 lore raw

Re: [PATCH net-next v5 03/10] ethtool: Add an interface for flashing transceiver modules' firmware

Quoted 22 lines · On Wed, 24 Apr 2024 16:30:16 +0300 Danielle Ratson wrote:
Documentation/networking/ethtool-netlink.rst +22 -0
+MODULE_FW_FLASH_ACT
+===================
+
+Flashes transceiver module firmware.
+
+Request contents:
+
+  =======================================  ======  ===========================
+  ``ETHTOOL_A_MODULE_FW_FLASH_HEADER``     nested  request header
+  ``ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME``  string  firmware image file name
+  ``ETHTOOL_A_MODULE_FW_FLASH_PASSWORD``   u32     transceiver module password
+  =======================================  ======  ===========================
+
+The firmware update process consists of three logical steps:
+
+1. Downloading a firmware image to the transceiver module and validating it.
+2. Running the firmware image.
+3. Committing the firmware image so that it is run upon reset.
+
+When flash command is given, those three steps are taken in that order.
+
+The ``ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME`` attribute encodes the firmware

Documentation/networking/ethtool-netlink.rst The attributes are propagated to the driver through the following structure: · line 2076

Quoted 10 lines
Documentation/networking/ethtool-netlink.rst +10 -0
+image file name. The firmware image is downloaded to the transceiver module,
+validated, run and committed.
+
+The optional ``ETHTOOL_A_MODULE_FW_FLASH_PASSWORD`` attribute encodes a password
+that might be required as part of the transceiver module firmware update
+process.
+
+The firmware update process can take several minutes to complete. Therefore,
+during the update process notifications are emitted from the kernel to user
+space updating it about the status and progress.

We should spell out that the request only kicks off the process. devlink flashing blocks the netlink socket send() until it's completed, and the notifications have to be received on another socket. So someone who has devlink experience may expect the same behavior here.

Quoted 10 lines
Documentation/networking/ethtool-netlink.rst +10 -0
+Notification contents:
+
+ +---------------------------------------------------+--------+----------------+
+ | ``ETHTOOL_A_MODULE_FW_FLASH_HEADER``              | nested | reply header   |
+ +---------------------------------------------------+--------+----------------+
+ | ``ETHTOOL_A_MODULE_FW_FLASH_STATUS``              | u32    | status         |
+ +---------------------------------------------------+--------+----------------+
+ | ``ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG``          | string | status message |
+ +---------------------------------------------------+--------+----------------+
+ | ``ETHTOOL_A_MODULE_FW_FLASH_DONE``                | uint   | progress       |

Documentation/networking/ethtool-netlink.rst The attributes are propagated to the driver through the following structure:

Quoted 10 lines
Documentation/networking/ethtool-netlink.rst +9 -0
+ +---------------------------------------------------+--------+----------------+
+ | ``ETHTOOL_A_MODULE_FW_FLASH_TOTAL``               | uint   | total          |
+ +---------------------------------------------------+--------+----------------+
 
+enum {
+	ETHTOOL_A_MODULE_FW_FLASH_UNSPEC,
+	ETHTOOL_A_MODULE_FW_FLASH_HEADER,		/* nest - _A_HEADER_* */
+	ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME,		/* string */
+	ETHTOOL_A_MODULE_FW_FLASH_PASSWORD,		/* u32 */
+	ETHTOOL_A_MODULE_FW_FLASH_PAD,

uint doesn't need pad, and pad is not specified in YAML, so the following attribute IDs will be all off by one in YNL.

Quoted 8 lines
include/uapi/linux/ethtool_netlink.h +8 -0
+	ETHTOOL_A_MODULE_FW_FLASH_STATUS,		/* u32 */
+	ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG,		/* string */
+	ETHTOOL_A_MODULE_FW_FLASH_DONE,			/* uint */
+	ETHTOOL_A_MODULE_FW_FLASH_TOTAL,		/* uint */
+
+	/* add new constants above here */
+	__ETHTOOL_A_MODULE_FW_FLASH_CNT,
+	ETHTOOL_A_MODULE_FW_FLASH_MAX = (__ETHTOOL_A_MODULE_FW_FLASH_CNT - 1)
#5 lore raw

PATCH v5 4/10 ethtool: Add flashing transceiver modules' firmware notifications ability

In reply to Danielle Ratson

Add progress notifications ability to user space while flashing modules' firmware by implementing the interface between the user space and the kernel.

---

Notes:
v2:
* Increase err_msg length.

 net/ethtool/module.c    | 83 +++++++++++++++++++++++++++++++++++++++++
 net/ethtool/module_fw.h | 10 +++++
 2 files changed, 93 insertions(+)
 create mode 100644 net/ethtool/module_fw.h
net/ethtool/module.c +83 -0
index ceb575efc290..114a2ec986fe 100644
@@ -5,6 +5,7 @@
 #include "netlink.h"
 #include "common.h"
 #include "bitset.h"
+#include "module_fw.h"
 
 struct module_req_info {
 	struct ethnl_req_info base;
@@ -158,3 +159,85 @@ const struct ethnl_request_ops ethnl_module_request_ops = {
 	.set			= ethnl_set_module,
 	.set_ntf_cmd		= ETHTOOL_MSG_MODULE_NTF,
 };
+
+/* MODULE_FW_FLASH_NTF */
+
+static void
+ethnl_module_fw_flash_ntf(struct net_device *dev,
+			  enum ethtool_module_fw_flash_status status,
+			  const char *status_msg, u64 done, u64 total)
+{
+	struct sk_buff *skb;
+	void *hdr;
+	int ret;
+
+	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+	if (!skb)
+		return;
+
+	hdr = ethnl_bcastmsg_put(skb, ETHTOOL_MSG_MODULE_FW_FLASH_NTF);
+	if (!hdr)
+		goto err_skb;
+
+	ret = ethnl_fill_reply_header(skb, dev,
+				      ETHTOOL_A_MODULE_FW_FLASH_HEADER);
+	if (ret < 0)
+		goto err_skb;
+
+	if (nla_put_u32(skb, ETHTOOL_A_MODULE_FW_FLASH_STATUS, status))
+		goto err_skb;
+
+	if (status_msg &&
+	    nla_put_string(skb, ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG,
+			   status_msg))
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_DONE, done,
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_TOTAL, total,
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))
+		goto err_skb;
+
+	genlmsg_end(skb, hdr);
+	ethnl_multicast(skb, dev);
+	return;
+
+err_skb:
+	nlmsg_free(skb);
+}
+
+void ethnl_module_fw_flash_ntf_err(struct net_device *dev,
+				   char *err_msg, char *sub_err_msg)
+{
+	char status_msg[120];
+
+	if (sub_err_msg)
+		sprintf(status_msg, "%s, %s.", err_msg, sub_err_msg);
+	else
+		sprintf(status_msg, "%s.", err_msg);
+
+	ethnl_module_fw_flash_ntf(dev, ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR,
+				  status_msg, 0, 0);
+}
+
+void ethnl_module_fw_flash_ntf_start(struct net_device *dev)
+{
+	ethnl_module_fw_flash_ntf(dev, ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED,
+				  NULL, 0, 0);
+}
+
+void ethnl_module_fw_flash_ntf_complete(struct net_device *dev)
+{
+	ethnl_module_fw_flash_ntf(dev, ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED,
+				  NULL, 0, 0);
+}
+
+void ethnl_module_fw_flash_ntf_in_progress(struct net_device *dev, u64 done,
+					   u64 total)
+{
+	ethnl_module_fw_flash_ntf(dev,
+				  ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS,
+				  NULL, done, total);
+}
net/ethtool/module_fw.h new file +10 -0
new file mode 100644
index 000000000000..e40eae442741
@@ -0,0 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+
+#include <uapi/linux/ethtool.h>
+
+void ethnl_module_fw_flash_ntf_err(struct net_device *dev,
+				   char *err_msg, char *sub_err_msg);
+void ethnl_module_fw_flash_ntf_start(struct net_device *dev);
+void ethnl_module_fw_flash_ntf_complete(struct net_device *dev);
+void ethnl_module_fw_flash_ntf_in_progress(struct net_device *dev, u64 done,
+					   u64 total);
Signature · 1 line
2.43.0
maintainer
#6 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 180

Quoted 3 lines · On Wed, 24 Apr 2024 16:30:17 +0300 Danielle Ratson wrote:
net/ethtool/module.c +3 -0
+	hdr = ethnl_bcastmsg_put(skb, ETHTOOL_MSG_MODULE_FW_FLASH_NTF);
+	if (!hdr)
+		goto err_skb;

Do we want to blast it to all listeners or treat it as an async reply? We can save the seq and portid of the original requester and use reply, I think.

Quoted 5 lines
net/ethtool/module.c +5 -0
+	ret = ethnl_fill_reply_header(skb, dev,
+				      ETHTOOL_A_MODULE_FW_FLASH_HEADER);
+	if (ret < 0)
+		goto err_skb;
+

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 196

Quoted 10 lines
net/ethtool/module.c +10 -0
+	if (nla_put_u32(skb, ETHTOOL_A_MODULE_FW_FLASH_STATUS, status))
+		goto err_skb;
+
+	if (status_msg &&
+	    nla_put_string(skb, ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG,
+			   status_msg))
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_DONE, done,
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))

nla_put_uint()

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 200

Quoted 4 lines
net/ethtool/module.c +4 -0
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_TOTAL, total,
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))

nla_put_uint()

Quoted 9 lines
net/ethtool/module.c +9 -0
+		goto err_skb;
+
+	genlmsg_end(skb, hdr);
+	ethnl_multicast(skb, dev);
+	return;
+
+err_skb:
+	nlmsg_free(skb);
+}

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 219

Quoted 10 lines
net/ethtool/module.c +10 -0
+
+void ethnl_module_fw_flash_ntf_err(struct net_device *dev,
+				   char *err_msg, char *sub_err_msg)
+{
+	char status_msg[120];
+
+	if (sub_err_msg)
+		sprintf(status_msg, "%s, %s.", err_msg, sub_err_msg);
+	else
+		sprintf(status_msg, "%s.", err_msg);

Hm, printing in the dot, and assuming sizeof err_msg + sub_err < 116 is a bit surprising. But I guess you have a reason...

Maybe pass them separately to ethnl_module_fw_flash_ntf() then you can nla_reserve() the right amount of space and sprintf() directly into the skb?

Quoted 2 lines
net/ethtool/module.c +2 -0
+	ethnl_module_fw_flash_ntf(dev, ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR,
+				  status_msg, 0, 0);
#7 lore raw

RE: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 17 lines

-----Original Message-----
From: Jakub Kicinski <[email protected]>
Sent: Tuesday, 30 April 2024 6:12
To: Danielle Ratson <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; linux- [email protected]; mlxsw <[email protected]>; Petr Machata <[email protected]>; Ido Schimmel <[email protected]>
Subject: Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

On Wed, 24 Apr 2024 16:30:17 +0300 Danielle Ratson wrote:

Quoted 8 lines

Review

Quoted 1 line
(quoted diff) +1 -0
+	hdr = ethnl_bcastmsg_put(skb,

ETHTOOL_MSG_MODULE_FW_FLASH_NTF);

Review

Quoted 2 lines
(quoted diff) +2 -0
+	if (!hdr)
+		goto err_skb;

Do we want to blast it to all listeners or treat it as an async reply? We can save the seq and portid of the original requester and use reply, I think.

I am sorry, I am not sure I understood what you meant here... it should be an async reply, but not sure I understood your suggestion. Can you explain please?
Thanks!

Quoted 53 lines

Review

Quoted 3 lines
(quoted diff) +2 -0
+	ret = ethnl_fill_reply_header(skb, dev,
+

ETHTOOL_A_MODULE_FW_FLASH_HEADER);

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = {

Quoted 4 lines
net/ethtool/module.c +4 -0
+	if (ret < 0)
+		goto err_skb;
+
+	if (nla_put_u32(skb, ETHTOOL_A_MODULE_FW_FLASH_STATUS,

status))

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = {

Quoted 4 lines
net/ethtool/module.c +4 -0
+		goto err_skb;
+
+	if (status_msg &&
+	    nla_put_string(skb,

ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG,

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = {

Quoted 4 lines
net/ethtool/module.c +4 -0
+			   status_msg))
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_DONE,

done,

Review

Quoted 1 line
(quoted diff) +1 -0
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))

nla_put_uint()

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = {

Quoted 3 lines
net/ethtool/module.c +3 -0
+		goto err_skb;
+
+	if (nla_put_u64_64bit(skb, ETHTOOL_A_MODULE_FW_FLASH_TOTAL,

total,

Review

Quoted 1 line
(quoted diff) +1 -0
+			      ETHTOOL_A_MODULE_FW_FLASH_PAD))

nla_put_uint()

Quoted 8 lines
net/ethtool/module.c +8 -0
+		goto err_skb;
+
+	genlmsg_end(skb, hdr);
+	ethnl_multicast(skb, dev);
+	return;
+
+err_skb:
+	nlmsg_free(skb);

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 219

Quoted 10 lines
net/ethtool/module.c +10 -0
+}
+
+void ethnl_module_fw_flash_ntf_err(struct net_device *dev,
+				   char *err_msg, char *sub_err_msg) {
+	char status_msg[120];
+
+	if (sub_err_msg)
+		sprintf(status_msg, "%s, %s.", err_msg, sub_err_msg);
+	else
+		sprintf(status_msg, "%s.", err_msg);

Hm, printing in the dot, and assuming sizeof err_msg + sub_err < 116 is a bit surprising. But I guess you have a reason...

Quoted 2 lines

Maybe pass them separately to ethnl_module_fw_flash_ntf() then you can nla_reserve() the right amount of space and sprintf() directly into the skb?

I can get rid of the dot actually, would it be ok like that?

Quoted 4 lines

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 240

Quoted 2 lines
net/ethtool/module.c +1 -0
+	ethnl_module_fw_flash_ntf(dev,

ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR,

Quoted 1 line
net/ethtool/module.c +1 -0
+				  status_msg, 0, 0);
maintainer
#8 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 8 lines · On Tue, 30 Apr 2024 18:11:18 +0000 Danielle Ratson wrote:
Quoted 3 lines

Do we want to blast it to all listeners or treat it as an async reply? We can save the seq and portid of the original requester and use reply, I think.

I am sorry, I am not sure I understood what you meant here... it should be an async reply, but not sure I understood your suggestion.

Can you explain please?

Make sure you have read the netlink intro, it should help fill in some gaps I won't explicitly cover:
https://docs.kernel.org/next/userspace-api/netlink/intro.html

"True" notifications will have pid = 0 and seq = 0, while replies to commands have those fields populated based on the request.

pid identifies the socket where the message should be delivered. ethnl_multicast() assumes that it's zero (since it's designed to work for notifications) and sends the message to all sockets subscribed to a multicast / notification group (ETHNL_MCGRP_MONITOR).

So that's the background. What you're doing isn't incorrect but I think it'd be better if we didn't use the multicast group here, and sent the messages as a reply - just to the socket which requested the flashing. Still asynchronously, we just need to save the right pid and seq to use.

Two reasons for this:
1) convenience, the user space socket won't have to subscribe to the multicast group
2) the multicast group is really intended for notifying about _configuration changes_ done to the system. If there is a daemon listening on that group, there's a very high chance it won't care about progress of the flashing. Maybe we can send a single notification that flashing has been completed but not "progress updates"

I think it should work.

Quoted 12 lines
Quoted 12 lines

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 219

Quoted 8 lines
net/ethtool/module.c +8 -0
+void ethnl_module_fw_flash_ntf_err(struct net_device *dev,
+				   char *err_msg, char *sub_err_msg) {
+	char status_msg[120];
+
+	if (sub_err_msg)
+		sprintf(status_msg, "%s, %s.", err_msg, sub_err_msg);
+	else
+		sprintf(status_msg, "%s.", err_msg);  

Hm, printing in the dot, and assuming sizeof err_msg + sub_err < 116 is a bit surprising. But I guess you have a reason...

Quoted 4 lines
Quoted 2 lines

Maybe pass them separately to ethnl_module_fw_flash_ntf() then you can nla_reserve() the right amount of space and sprintf() directly into the skb?

I can get rid of the dot actually, would it be ok like that?

It'd still be better to splice the two strings and the comma directly to the skb, rather than on the stack using a function which doesn't check the bounds of the buffer :S

maintainer
#9 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 37 lines · Jakub Kicinski
Quoted 8 lines · On Tue, 30 Apr 2024 18:11:18 +0000 Danielle Ratson wrote:
Quoted 3 lines

Do we want to blast it to all listeners or treat it as an async reply? We can save the seq and portid of the original requester and use reply, I think.

I am sorry, I am not sure I understood what you meant here... it should be an async reply, but not sure I understood your suggestion.

Can you explain please?

Make sure you have read the netlink intro, it should help fill in some gaps I won't explicitly cover:
https://docs.kernel.org/next/userspace-api/netlink/intro.html

"True" notifications will have pid = 0 and seq = 0, while replies to commands have those fields populated based on the request.

pid identifies the socket where the message should be delivered. ethnl_multicast() assumes that it's zero (since it's designed to work for notifications) and sends the message to all sockets subscribed to a multicast / notification group (ETHNL_MCGRP_MONITOR).

So that's the background. What you're doing isn't incorrect but I think it'd be better if we didn't use the multicast group here, and sent the messages as a reply - just to the socket which requested the flashing. Still asynchronously, we just need to save the right pid and seq to use.

Two reasons for this:
1) convenience, the user space socket won't have to subscribe to the multicast group
2) the multicast group is really intended for notifying about _configuration changes_ done to the system. If there is a daemon listening on that group, there's a very high chance it won't care about progress of the flashing. Maybe we can send a single notification that flashing has been completed but not "progress updates"

Quoted 1 line

I think it should work.

We can try to use unicast, but the current design is influenced by devlink firmware flash (see __devlink_flash_update_notify()) and ethtool cable testing (see ethnl_cable_test_started() and ethnl_cable_test_finished()), both of which use multicast notifications although the latter does not update about progress.

Do you want us to try the unicast approach or be consistent with the above examples?

maintainer
#10 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 8 lines · On Wed, 1 May 2024 10:53:48 +0300 Ido Schimmel wrote:

We can try to use unicast, but the current design is influenced by devlink firmware flash (see __devlink_flash_update_notify()) and ethtool cable testing (see ethnl_cable_test_started() and ethnl_cable_test_finished()), both of which use multicast notifications although the latter does not update about progress.

Do you want us to try the unicast approach or be consistent with the above examples?

We are charting a bit of a new territory here, you're right that the precedents point in the direction of multicast. The unicast is harder to get done on the kernel side (we should probably also check that the socket pid didn't get reused, stop sending the notifications when original socket gets closed?) It will require using pretty much all the pieces of advanced netlink infra we have, I'm happy to explain more, but I'll also understand if you prefer to stick to multicast.

#11 lore raw

RE: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 26 lines

-----Original Message-----
From: Jakub Kicinski <[email protected]>
Sent: Wednesday, 1 May 2024 17:38
To: Ido Schimmel <[email protected]>
Cc: Danielle Ratson <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; linux- [email protected]; mlxsw <[email protected]>; Petr Machata <[email protected]>
Subject: Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 8 lines · On Wed, 1 May 2024 10:53:48 +0300 Ido Schimmel wrote:

We can try to use unicast, but the current design is influenced by devlink firmware flash (see __devlink_flash_update_notify()) and ethtool cable testing (see ethnl_cable_test_started() and ethnl_cable_test_finished()), both of which use multicast notifications although the latter does not update about progress.

Do you want us to try the unicast approach or be consistent with the above examples?

Quoted 7 lines

We are charting a bit of a new territory here, you're right that the precedents point in the direction of multicast.
The unicast is harder to get done on the kernel side (we should probably also check that the socket pid didn't get reused, stop sending the notifications when original socket gets closed?) It will require using pretty much all the pieces of advanced netlink infra we have, I'm happy to explain more, but I'll also understand if you prefer to stick to multicast.

Hi Jakub,

Following our discussion, I wanted to see if you are ok with the idea below:

1. Add a new unicast function to netlink.c:
void *ethnl_unicast_put(struct sk_buff *skb, u32 portid, u32 seq, u8 cmd)

2. Use it in the notification function instead of the multicast previously used along with genlmsg_unicast(). 'portid' and 'seq' taken from genl_info(), are added to the struct ethtool_module_fw_flash, which is accessible from the work item.

3. Create a global list that holds nodes from type struct ethtool_module_fw_flash() and add it as a field in the struct ethtool_module_fw_flash. Before scheduling a work, a new node is added to the list.

4. Add a new netlink notifier that when the relevant event takes place, deletes the node from the list, wait until the end of the work item, with cancel_work_sync() and free allocations.

Thanks,
Danielle

maintainer
#12 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 8 lines · On Wed, 22 May 2024 13:08:43 +0000 Danielle Ratson wrote:

1. Add a new unicast function to netlink.c:
void *ethnl_unicast_put(struct sk_buff *skb, u32 portid, u32 seq, u8 cmd)

2. Use it in the notification function instead of the multicast previously used along with genlmsg_unicast(). 'portid' and 'seq' taken from genl_info(), are added to the struct ethtool_module_fw_flash, which is accessible from the work item.

3. Create a global list that holds nodes from type struct ethtool_module_fw_flash() and add it as a field in the struct ethtool_module_fw_flash. Before scheduling a work, a new node is added to the list.

Makes sense.

Quoted 1 line

4. Add a new netlink notifier that when the relevant event takes place, deletes the node from the list, wait until the end of the work item, with cancel_work_sync() and free allocations.

What's the "relevant event" in this case? Closing of the socket that user had issued the command on?

Easiest way to "notice" the socket got closed would probably be to add some info to genl_sk_priv_*(). ->sock_priv_destroy() will get called. But you can also get a close notification in the family ->unbind callback.

I'm on the fence whether we should cancel the work. We could just mark the command as 'no socket present' and stop sending notifications. Not sure which is better..

#13 lore raw

RE: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 14 lines
Quoted 5 lines

1. Add a new unicast function to netlink.c:
void *ethnl_unicast_put(struct sk_buff *skb, u32 portid, u32 seq, u8 cmd)

2. Use it in the notification function instead of the multicast previously used

along with genlmsg_unicast().

Quoted 1 line

'portid' and 'seq' taken from genl_info(), are added to the struct

ethtool_module_fw_flash, which is accessible from the work item.

Quoted 2 lines

3. Create a global list that holds nodes from type struct

ethtool_module_fw_flash() and add it as a field in the struct ethtool_module_fw_flash.

Quoted 1 line

Before scheduling a work, a new node is added to the list.

Quoted 8 lines

Makes sense.

Quoted 1 line

4. Add a new netlink notifier that when the relevant event takes place,

deletes the node from the list, wait until the end of the work item, with cancel_work_sync() and free allocations.

What's the "relevant event" in this case? Closing of the socket that user had issued the command on?

The event should match the below:
event == NETLINK_URELEASE && notify->protocol == NETLINK_GENERIC

Then iterate over the list to look for work that matches the dev and portid. The socket doesn’t close until the work is done in that case.

Quoted 9 lines

Easiest way to "notice" the socket got closed would probably be to add some info to genl_sk_priv_*(). ->sock_priv_destroy() will get called. But you can also get a close notification in the family
->unbind callback.

I'm on the fence whether we should cancel the work. We could just mark the command as 'no socket present' and stop sending notifications. Not sure which is better..

Is there a scenario that we hit this event and won't intend to cancel the work?

Thanks,
Danielle

maintainer
#14 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 4 lines · On Wed, 22 May 2024 13:56:11 +0000 Danielle Ratson wrote:
Quoted 4 lines
Quoted 1 line

4. Add a new netlink notifier that when the relevant event takes place,

deletes the node from the list, wait until the end of the work item, with cancel_work_sync() and free allocations.

Quoted 8 lines
Quoted 2 lines

What's the "relevant event" in this case? Closing of the socket that user had issued the command on?

The event should match the below:
event == NETLINK_URELEASE && notify->protocol == NETLINK_GENERIC

Then iterate over the list to look for work that matches the dev and portid. The socket doesn’t close until the work is done in that case.

Okay, good, yes. I think you can use one of the callbacks I mentioned below to achieve the same thing with less complexity than the notifier.

Quoted 10 lines
Quoted 8 lines

Easiest way to "notice" the socket got closed would probably be to add some info to genl_sk_priv_*(). ->sock_priv_destroy() will get called. But you can also get a close notification in the family
->unbind callback.

I'm on the fence whether we should cancel the work. We could just mark the command as 'no socket present' and stop sending notifications. Not sure which is better..

Is there a scenario that we hit this event and won't intend to cancel the work?

I think it's up to us. I don't see any legit reason for user space to intentionally cancel the flashing. So the only option is that user space is either buggy or has crashed, and the socket got closed before flashing finished. Right?

maintainer
#15 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 8 lines · Jakub Kicinski
Quoted 7 lines · On Wed, 22 May 2024 13:56:11 +0000 Danielle Ratson wrote:
Quoted 6 lines
Quoted 1 line

4. Add a new netlink notifier that when the relevant event takes place,

deletes the node from the list, wait until the end of the work item, with cancel_work_sync() and free allocations.

What's the "relevant event" in this case? Closing of the socket that user had issued the command on?

Quoted 8 lines
Quoted 5 lines

The event should match the below:
event == NETLINK_URELEASE && notify->protocol == NETLINK_GENERIC

Then iterate over the list to look for work that matches the dev and portid. The socket doesn’t close until the work is done in that case.

Okay, good, yes. I think you can use one of the callbacks I mentioned below to achieve the same thing with less complexity than the notifier.

Danielle already has a POC with the notifier and it's not that complicated. I wasn't aware of the netlink notifier, but we found it when we tried to understand how other netlink families get notified about a socket being closed.

Which advantages do you see in the sock_priv_destroy() approach? Are you against the notifier approach?

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Easiest way to "notice" the socket got closed would probably be to add some info to genl_sk_priv_*(). ->sock_priv_destroy() will get called. But you can also get a close notification in the family
->unbind callback.

Isn't the unbind callback only for multicast (whereas we are using unicast)?

Quoted 11 lines
Quoted 6 lines
Quoted 4 lines

I'm on the fence whether we should cancel the work. We could just mark the command as 'no socket present' and stop sending notifications. Not sure which is better..

Is there a scenario that we hit this event and won't intend to cancel the work?

I think it's up to us. I don't see any legit reason for user space to intentionally cancel the flashing. So the only option is that user space is either buggy or has crashed, and the socket got closed before flashing finished. Right?

We don't think that closing the socket / killing the process mid flashing is a legitimate scenario. We looked into it in order to avoid sending unicast notifications to a socket that did not ask for them but gets them because it was bound to the port ID that was used by the old socket.

I agree that we don't need to cancel the work and can simply have the work item stop sending notifications. User space will get an error if it tries to flash a module that is already being flashed in the background. WDYT?

maintainer
#16 lore raw

Re: [PATCH net-next v5 04/10] ethtool: Add flashing transceiver modules' firmware notifications ability

Quoted 11 lines · On Mon, 27 May 2024 19:10:55 +0300 Ido Schimmel wrote:
Quoted 9 lines · Jakub Kicinski
Quoted 5 lines · On Wed, 22 May 2024 13:56:11 +0000 Danielle Ratson wrote:

The event should match the below:
event == NETLINK_URELEASE && notify->protocol == NETLINK_GENERIC

Then iterate over the list to look for work that matches the dev and portid. The socket doesn’t close until the work is done in that case.

Okay, good, yes. I think you can use one of the callbacks I mentioned below to achieve the same thing with less complexity than the notifier.

Quoted 7 lines

Danielle already has a POC with the notifier and it's not that complicated. I wasn't aware of the netlink notifier, but we found it when we tried to understand how other netlink families get notified about a socket being closed.

Which advantages do you see in the sock_priv_destroy() approach? Are you against the notifier approach?

Notifier is not incorrect, but I worry it will result in more code, and basically duplication of what genl_sk_priv* does. Perhaps you managed to code it up very neatly - if so feel free to send the v6 and we can discuss further if needed?

Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

Easiest way to "notice" the socket got closed would probably be to add some info to genl_sk_priv_*(). ->sock_priv_destroy() will get called. But you can also get a close notification in the family
->unbind callback.

Isn't the unbind callback only for multicast (whereas we are using unicast)?

True, should work in practice, I think. But sock_priv is much better.

Quoted 13 lines
Quoted 6 lines
Quoted 1 line

Is there a scenario that we hit this event and won't intend to cancel the work?

I think it's up to us. I don't see any legit reason for user space to intentionally cancel the flashing. So the only option is that user space is either buggy or has crashed, and the socket got closed before flashing finished. Right?

We don't think that closing the socket / killing the process mid flashing is a legitimate scenario. We looked into it in order to avoid sending unicast notifications to a socket that did not ask for them but gets them because it was bound to the port ID that was used by the old socket.

Quoted 4 lines

I agree that we don't need to cancel the work and can simply have the work item stop sending notifications. User space will get an error if it tries to flash a module that is already being flashed in the background. WDYT?

SGTM!

#17 lore raw

PATCH v5 5/10 include: netdevice: Add module firmware flashing in progress flag to net_device

In reply to Danielle Ratson

Some operations cannot be performed during the firmware flashing process and will be vetoed later in the patchset.
For example, flashing firmware on a device which is already in a flashing process should be forbidden.

In order to veto those scenarios, add a flag in 'struct net_device' that indicates when a firmware flash is taking place on the module.

---
 include/linux/netdevice.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
include/linux/netdevice.h +3 -1
index f849e7d110ed..68a18911c8cf 100644
@@ -1989,6 +1989,8 @@ enum netdev_reg_state {
  *
  *	@threaded:	napi threaded mode is enabled
  *
+ *	@module_fw_flash_in_progress:	Module firmware flashing is in progress.
+ *
  *	@net_notifier_list:	List of per-net netdev notifier block
  *				that follow this device when it is moved
  *				to another network namespace.
@@ -2372,7 +2374,7 @@ struct net_device {
 	bool			proto_down;
 	unsigned		wol_enabled:1;
 	unsigned		threaded:1;
-
+	unsigned		module_fw_flash_in_progress:1;
 	struct list_head	net_notifier_list;
 
 #if IS_ENABLED(CONFIG_MACSEC)
Signature · 1 line
2.43.0
#18 lore raw

PATCH v5 6/10 net: sfp: Add more extended compliance codes

In reply to Danielle Ratson

SFF-8024 is used to define various constants re-used in several SFF SFP-related specifications.

Add SFF-8024 extended compliance code definitions for CMIS compliant modules and use them in the next patch to determine the firmware flashing work.

---
 include/linux/sfp.h | 6 ++++++
 1 file changed, 6 insertions(+)
include/linux/sfp.h +6 -0
index 55c0ab17c9e2..46c145fa855d 100644
@@ -284,6 +284,12 @@ enum {
 	SFF8024_ID_QSFP_8438		= 0x0c,
 	SFF8024_ID_QSFP_8436_8636	= 0x0d,
 	SFF8024_ID_QSFP28_8636		= 0x11,
+	SFF8024_ID_QSFP_DD		= 0x18,
+	SFF8024_ID_OSFP			= 0x19,
+	SFF8024_ID_DSFP			= 0x1B,
+	SFF8024_ID_QSFP_PLUS_CMIS	= 0x1E,
+	SFF8024_ID_SFP_DD_CMIS		= 0x1F,
+	SFF8024_ID_SFP_PLUS_CMIS	= 0x20,
 
 	SFF8024_ENCODING_UNSPEC		= 0x00,
 	SFF8024_ENCODING_8B10B		= 0x01,
Signature · 1 line
2.43.0
#19 lore raw

PATCH v5 7/10 ethtool: cmis_cdb: Add a layer for supporting CDB commands

In reply to Danielle Ratson

CDB (Command Data Block Message Communication) reads and writes are performed on memory map pages 9Fh-AFh according to the CMIS standard, section 8.20 of revision 5.2.
Page 9Fh is used to specify the CDB command to be executed and also provides an area for a local payload (LPL).

According to the CMIS standard, the firmware update process is done using a CDB commands sequence that will be implemented in the next patch.

The kernel interface that will implement the firmware update using CDB command will include 2 layers that will be added under ethtool:

* The upper layer that will be triggered from the module layer, is cmis_fw_update.
* The lower one is cmis_cdb.

In the future there might be more operations to implement using CDB commands. Therefore, the idea is to keep the CDB interface clean and the cmis_fw_update specific to the CDB commands handling it.

These two layers will communicate using the API the consists of three functions:

- struct ethtool_cmis_cdb *
ethtool_cmis_cdb_init(struct net_device *dev,

			struct ethtool_module_fw_flash_params *params);
- void ethtool_cmis_cdb_fini(struct ethtool_cmis_cdb *cdb);
- int ethtool_cmis_cdb_execute_cmd(struct net_device *dev,
				   struct ethtool_cmis_cdb_cmd_args *args);

Add the CDB layer to support initializing, finishing and executing CDB commands:

* The initialization process will include creating of an ethtool_cmis_cdb instance, querying the module CDB support, entering and validating the password from user space (CMD 0x0000) and querying the module features (CMD 0x0040).

* The finishing API will simply free the ethtool_cmis_cdb instance.

* The executing process will write the CDB command to EEPROM using set_module_eeprom_by_page() that was presented earlier, and will process the reply from EEPROM.

---

Notes:

    v5:
    	* Drop all the inline in cmis_cdb.c.
    
    v4:
    	* Add kernel-doc for msleep_pre_rpl and err_msg.
    
    v3:
    	* Use kmemdup() instead of kmalloc+memcpy.
    
    v2:
    	* Define ethtool_cmis_cdb_request::epl_len to be __be16 instead
    	  of u16.
 net/ethtool/Makefile    |   2 +-
 net/ethtool/cmis.h      | 116 ++++++++
 net/ethtool/cmis_cdb.c  | 577 ++++++++++++++++++++++++++++++++++++++++
 net/ethtool/module_fw.h |  10 +
 4 files changed, 704 insertions(+), 1 deletion(-)
 create mode 100644 net/ethtool/cmis.h
 create mode 100644 net/ethtool/cmis_cdb.c
net/ethtool/Makefile +1 -1
index 504f954a1b28..38806b3ecf83 100644
@@ -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
+		   module.o cmis_cdb.o pse-pd.o plca.o mm.o
net/ethtool/cmis.h new file +116 -0

116 lines not on this page · raw message

net/ethtool/cmis_cdb.c new file +577 -0

577 lines not on this page · raw message

net/ethtool/module_fw.h +10 -0
index e40eae442741..96da7a8175f2 100644
@@ -8,3 +8,13 @@ void ethnl_module_fw_flash_ntf_start(struct net_device *dev);
 void ethnl_module_fw_flash_ntf_complete(struct net_device *dev);
 void ethnl_module_fw_flash_ntf_in_progress(struct net_device *dev, u64 done,
 					   u64 total);
+
+/**
+ * struct ethtool_module_fw_flash_params - module firmware flashing parameters
+ * @password: Module password. Only valid when @pass_valid is set.
+ * @password_valid: Whether the module password is valid or not.
+ */
+struct ethtool_module_fw_flash_params {
+	__be32 password;
+	u8 password_valid:1;
+};
Signature · 1 line
2.43.0
#20 lore raw

PATCH v5 8/10 ethtool: cmis_fw_update: add a layer for supporting firmware update using CDB

In reply to Danielle Ratson

According to the CMIS standard, the firmware update process is done using a CDB commands sequence.

Implement a work that will be triggered from the module layer in the next patch the will initiate and execute all the CDB commands in order, to eventually complete the firmware update process.

This flashing process includes, writing the firmware image, running the new firmware image and committing it after testing, so that it will run upon reset.

This work will also notify user space about the progress of the firmware update process.

---

Notes:
v2:
* Decrease msleep before querying completion flag in Write FW Image command.
* Change the condition for failing when LPL is not supported.
* Re-write cmis_fw_update_write_image().

 net/ethtool/Makefile         |   2 +-
 net/ethtool/cmis.h           |   7 +
 net/ethtool/cmis_fw_update.c | 397 +++++++++++++++++++++++++++++++++++
 net/ethtool/module_fw.h      |  18 ++
 4 files changed, 423 insertions(+), 1 deletion(-)
 create mode 100644 net/ethtool/cmis_fw_update.c
net/ethtool/Makefile +1 -1
index 38806b3ecf83..9a190635fe95 100644
@@ -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 cmis_cdb.o pse-pd.o plca.o mm.o
+		   module.o cmis_fw_update.o cmis_cdb.o pse-pd.o plca.o mm.o
net/ethtool/cmis.h +7 -0
index 6c8e88b8ade2..394308e0c942 100644
@@ -20,6 +20,12 @@ struct ethtool_cmis_cdb {
 enum ethtool_cmis_cdb_cmd_id {
 	ETHTOOL_CMIS_CDB_CMD_QUERY_STATUS		= 0x0000,
 	ETHTOOL_CMIS_CDB_CMD_MODULE_FEATURES		= 0x0040,
+	ETHTOOL_CMIS_CDB_CMD_FW_MANAGMENT_FEATURES	= 0x0041,
+	ETHTOOL_CMIS_CDB_CMD_START_FW_DOWNLOAD		= 0x0101,
+	ETHTOOL_CMIS_CDB_CMD_WRITE_FW_BLOCK_LPL		= 0x0103,
+	ETHTOOL_CMIS_CDB_CMD_COMPLETE_FW_DOWNLOAD	= 0x0107,
+	ETHTOOL_CMIS_CDB_CMD_RUN_FW_IMAGE		= 0x0109,
+	ETHTOOL_CMIS_CDB_CMD_COMMIT_FW_IMAGE		= 0x010A,
 };
 
 /**
@@ -47,6 +53,7 @@ struct ethtool_cmis_cdb_request {
 
 #define CDB_F_COMPLETION_VALID		BIT(0)
 #define CDB_F_STATUS_VALID		BIT(1)
+#define CDB_F_MODULE_STATE_VALID	BIT(2)
 
 /**
  * struct ethtool_cmis_cdb_cmd_args - CDB commands execution arguments
net/ethtool/cmis_fw_update.c new file +397 -0

397 lines not on this page · raw message

net/ethtool/module_fw.h +18 -0
index 96da7a8175f2..9af5b15efe85 100644
@@ -9,6 +9,8 @@ void ethnl_module_fw_flash_ntf_complete(struct net_device *dev);
 void ethnl_module_fw_flash_ntf_in_progress(struct net_device *dev, u64 done,
 					   u64 total);
 
+void ethtool_cmis_fw_update(struct work_struct *work);
+
 /**
  * struct ethtool_module_fw_flash_params - module firmware flashing parameters
  * @password: Module password. Only valid when @pass_valid is set.
@@ -18,3 +20,19 @@ struct ethtool_module_fw_flash_params {
 	__be32 password;
 	u8 password_valid:1;
 };
+
+/**
+ * struct ethtool_module_fw_flash - module firmware flashing
+ * @dev: Pointer to the net_device to be flashed.
+ * @dev_tracker: Refcount tracker for @dev.
+ * @params: Module firmware flashing parameters.
+ * @work: The flashing firmware work.
+ * @fw: Firmware to flash.
+ */
+struct ethtool_module_fw_flash {
+	struct net_device *dev;
+	netdevice_tracker dev_tracker;
+	struct ethtool_module_fw_flash_params params;
+	struct work_struct work;
+	const struct firmware *fw;
+};
Signature · 1 line
2.43.0
#21 lore raw

PATCH v5 9/10 ethtool: Add ability to flash transceiver modules' firmware

In reply to Danielle Ratson

Add the ability to flash the modules' firmware by implementing the interface between the user space and the kernel.

Example from a succeeding implementation:

 # ethtool --flash-module-firmware swp40 file test.bin

Transceiver module firmware flashing started for device eth0

Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 0%

[...]

Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 50%

[...]

Transceiver module firmware flashing in progress for device eth0 Status message: Downloading firmware image
Progress: 100%

Transceiver module firmware flashing completed for device eth0

---
 net/ethtool/module.c  | 174 ++++++++++++++++++++++++++++++++++++++++++
 net/ethtool/netlink.c |   7 ++
 net/ethtool/netlink.h |   2 +
 3 files changed, 183 insertions(+)
net/ethtool/module.c +174 -0
index 114a2ec986fe..f42e9a9a1ab8 100644
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-2.0-only
 
 #include <linux/ethtool.h>
+#include <linux/firmware.h>
+#include <linux/sfp.h>
 
 #include "netlink.h"
 #include "common.h"
@@ -160,6 +162,178 @@ const struct ethnl_request_ops ethnl_module_request_ops = {
 	.set_ntf_cmd		= ETHTOOL_MSG_MODULE_NTF,
 };
 
+/* MODULE_FW_FLASH_ACT */
+
+const struct nla_policy
+ethnl_module_fw_flash_act_policy[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD + 1] = {
+	[ETHTOOL_A_MODULE_FW_FLASH_HEADER] =
+		NLA_POLICY_NESTED(ethnl_header_policy),
+	[ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME] = { .type = NLA_NUL_STRING },
+	[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD] = { .type = NLA_U32 },
+};
+
+#define MODULE_EEPROM_PHYS_ID_PAGE	0
+#define MODULE_EEPROM_PHYS_ID_I2C_ADDR	0x50
+
+static int module_flash_fw_work_init(struct ethtool_module_fw_flash *module_fw,
+				     struct net_device *dev,
+				     struct netlink_ext_ack *extack)
+{
+	const struct ethtool_ops *ops = dev->ethtool_ops;
+	struct ethtool_module_eeprom page_data = {};
+	u8 phys_id;
+	int err;
+
+	/* Fetch the SFF-8024 Identifier Value. For all supported standards, it
+	 * is located at I2C address 0x50, byte 0. See section 4.1 in SFF-8024,
+	 * revision 4.9.
+	 */
+	page_data.page = MODULE_EEPROM_PHYS_ID_PAGE;
+	page_data.offset = SFP_PHYS_ID;
+	page_data.length = sizeof(phys_id);
+	page_data.i2c_address = MODULE_EEPROM_PHYS_ID_I2C_ADDR;
+	page_data.data = &phys_id;
+
+	err = ops->get_module_eeprom_by_page(dev, &page_data, extack);
+	if (err < 0)
+		return err;
+
+	switch (phys_id) {
+	case SFF8024_ID_QSFP_DD:
+	case SFF8024_ID_OSFP:
+	case SFF8024_ID_DSFP:
+	case SFF8024_ID_QSFP_PLUS_CMIS:
+	case SFF8024_ID_SFP_DD_CMIS:
+	case SFF8024_ID_SFP_PLUS_CMIS:
+		INIT_WORK(&module_fw->work, ethtool_cmis_fw_update);
+		break;
+	default:
+		NL_SET_ERR_MSG(extack,
+			       "Module type does not support firmware flashing");
+		return -EOPNOTSUPP;
+	}
+
+	return 0;
+}
+
+static int __module_flash_fw_schedule(struct net_device *dev,
+				      struct netlink_ext_ack *extack)
+{
+	const struct ethtool_ops *ops = dev->ethtool_ops;
+
+	if (!ops->set_module_eeprom_by_page ||
+	    !ops->get_module_eeprom_by_page) {
+		NL_SET_ERR_MSG(extack,
+			       "Flashing module firmware is not supported by this device");
+		return -EOPNOTSUPP;
+	}
+
+	if (!ops->reset) {
+		NL_SET_ERR_MSG(extack,
+			       "Reset module is not supported by this device, so flashing is not permitted");
+		return -EOPNOTSUPP;
+	}
+
+	return 0;
+}
+
+static int
+module_flash_fw_schedule(struct net_device *dev, const char *file_name,
+			 struct ethtool_module_fw_flash_params *params,
+			 struct netlink_ext_ack *extack)
+{
+	struct ethtool_module_fw_flash *module_fw;
+	int err;
+
+	err = __module_flash_fw_schedule(dev, extack);
+	if (err < 0)
+		return err;
+
+	module_fw = kzalloc(sizeof(*module_fw), GFP_KERNEL);
+	if (!module_fw)
+		return -ENOMEM;
+
+	module_fw->params = *params;
+	err = request_firmware_direct(&module_fw->fw, file_name, &dev->dev);
+	if (err) {
+		NL_SET_ERR_MSG(extack,
+			       "Failed to request module firmware image");
+		goto err_request_firmware;
+	}
+
+	err = module_flash_fw_work_init(module_fw, dev, extack);
+	if (err < 0) {
+		NL_SET_ERR_MSG(extack,
+			       "Flashing module firmware is not supported by this device");
+		goto err_work_init;
+	}
+
+	dev->module_fw_flash_in_progress = true;
+	netdev_hold(dev, &module_fw->dev_tracker, GFP_KERNEL);
+	module_fw->dev = dev;
+
+	schedule_work(&module_fw->work);
+
+	return 0;
+
+err_work_init:
+	release_firmware(module_fw->fw);
+err_request_firmware:
+	kfree(module_fw);
+	return err;
+}
+
+static int module_flash_fw(struct net_device *dev, struct nlattr **tb,
+			   struct genl_info *info)
+{
+	struct ethtool_module_fw_flash_params params = {};
+	const char *file_name;
+	struct nlattr *attr;
+
+	if (GENL_REQ_ATTR_CHECK(info, ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME))
+		return -EINVAL;
+
+	file_name = nla_data(tb[ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME]);
+
+	attr = tb[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD];
+	if (attr) {
+		params.password = cpu_to_be32(nla_get_u32(attr));
+		params.password_valid = true;
+	}
+
+	return module_flash_fw_schedule(dev, file_name, &params, info->extack);
+}
+
+int ethnl_act_module_fw_flash(struct sk_buff *skb, struct genl_info *info)
+{
+	struct ethnl_req_info req_info = {};
+	struct nlattr **tb = info->attrs;
+	struct net_device *dev;
+	int ret;
+
+	ret = ethnl_parse_header_dev_get(&req_info,
+					 tb[ETHTOOL_A_MODULE_FW_FLASH_HEADER],
+					 genl_info_net(info), info->extack,
+					 true);
+	if (ret < 0)
+		return ret;
+	dev = req_info.dev;
+
+	rtnl_lock();
+	ret = ethnl_ops_begin(dev);
+	if (ret < 0)
+		goto out_rtnl;
+
+	ret = module_flash_fw(dev, tb, info);
+
+	ethnl_ops_complete(dev);
+
+out_rtnl:
+	rtnl_unlock();
+	ethnl_parse_header_dev_put(&req_info);
+	return ret;
+}
+
 /* MODULE_FW_FLASH_NTF */
 
 static void
net/ethtool/netlink.c +7 -0
index 563e94e0cbd8..1a4f6bd1ec7f 100644
@@ -1169,6 +1169,13 @@ static const struct genl_ops ethtool_genl_ops[] = {
 		.policy = ethnl_mm_set_policy,
 		.maxattr = ARRAY_SIZE(ethnl_mm_set_policy) - 1,
 	},
+	{
+		.cmd	= ETHTOOL_MSG_MODULE_FW_FLASH_ACT,
+		.flags	= GENL_UNS_ADMIN_PERM,
+		.doit	= ethnl_act_module_fw_flash,
+		.policy	= ethnl_module_fw_flash_act_policy,
+		.maxattr = ARRAY_SIZE(ethnl_module_fw_flash_act_policy) - 1,
+	},
 };
 
 static const struct genl_multicast_group ethtool_nl_mcgrps[] = {
net/ethtool/netlink.h +2 -0
index d57a890b5d9e..e1e2edd05206 100644
@@ -446,6 +446,7 @@ 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_module_fw_flash_act_policy[ETHTOOL_A_MODULE_FW_FLASH_PASSWORD + 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);
@@ -453,6 +454,7 @@ int ethnl_act_cable_test_tdr(struct sk_buff *skb, struct genl_info *info);
 int ethnl_tunnel_info_doit(struct sk_buff *skb, struct genl_info *info);
 int ethnl_tunnel_info_start(struct netlink_callback *cb);
 int ethnl_tunnel_info_dumpit(struct sk_buff *skb, struct netlink_callback *cb);
+int ethnl_act_module_fw_flash(struct sk_buff *skb, struct genl_info *info);
 
 extern const char stats_std_names[__ETHTOOL_STATS_CNT][ETH_GSTRING_LEN];
 extern const char stats_eth_phy_names[__ETHTOOL_A_STATS_ETH_PHY_CNT][ETH_GSTRING_LEN];
Signature · 1 line
2.43.0
maintainer
#22 lore raw

Re: [PATCH net-next v5 09/10] ethtool: Add ability to flash transceiver modules' firmware

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 250

Quoted 11 lines · On Wed, 24 Apr 2024 16:30:22 +0300 Danielle Ratson wrote:
net/ethtool/module.c +11 -0
+static int
+module_flash_fw_schedule(struct net_device *dev, const char *file_name,
+			 struct ethtool_module_fw_flash_params *params,
+			 struct netlink_ext_ack *extack)
+{
+	struct ethtool_module_fw_flash *module_fw;
+	int err;
+
+	err = __module_flash_fw_schedule(dev, extack);
+	if (err < 0)
+		return err;

Basic dev validation should probably be called directly from ethnl_act_module_fw_flash() rather than two functions down.

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 261

Quoted 10 lines
net/ethtool/module.c +10 -0
+	module_fw = kzalloc(sizeof(*module_fw), GFP_KERNEL);
+	if (!module_fw)
+		return -ENOMEM;
+
+	module_fw->params = *params;
+	err = request_firmware_direct(&module_fw->fw, file_name, &dev->dev);
+	if (err) {
+		NL_SET_ERR_MSG(extack,
+			       "Failed to request module firmware image");
+		goto err_request_firmware;

Please name the labels after the actions they perform.

net/ethtool/module.c const struct ethnl_request_ops ethnl_module_request_ops = { · line 267

Quoted 6 lines
net/ethtool/module.c +6 -0
+	}
+
+	err = module_flash_fw_work_init(module_fw, dev, extack);
+	if (err < 0) {
+		NL_SET_ERR_MSG(extack,
+			       "Flashing module firmware is not supported by this device");

This overwrites the more accurate extack msg already set by module_flash_fw_work_init()

Quoted 2 lines
(quoted diff) +2 -0
+		goto err_work_init;
+	}
#23 lore raw

PATCH v5 10/10 ethtool: Veto some operations during firmware flashing process

In reply to Danielle Ratson

Some operations cannot be performed during the firmware flashing process.

For example:

- Port must be down during the whole flashing process to avoid packet loss while committing reset for example.

- Writing to EEPROM interrupts the flashing process, so operations like ethtool dump, module reset, get and set power mode should be vetoed.

- Split port firmware flashing should be vetoed.

- Flashing firmware on a device which is already in a flashing process should be forbidden.

Use the 'module_fw_flashing_in_progress' flag introduced in a previous patch to veto those operations and prevent interruptions while preforming module firmware flash.

---
 net/ethtool/eeprom.c  |  6 ++++++
 net/ethtool/ioctl.c   | 12 ++++++++++++
 net/ethtool/module.c  | 29 +++++++++++++++++++++++++++++
 net/ethtool/netlink.c | 30 +++++++++++++++++++++++++++++-
 4 files changed, 76 insertions(+), 1 deletion(-)
net/ethtool/eeprom.c +6 -0
index 6209c3a9c8f7..f36811b3ecf1 100644
@@ -91,6 +91,12 @@ static int get_module_eeprom_by_page(struct net_device *dev,
 {
 	const struct ethtool_ops *ops = dev->ethtool_ops;
 
+	if (dev->module_fw_flash_in_progress) {
+		NL_SET_ERR_MSG(extack,
+			       "Module firmware flashing is in progress");
+		return -EBUSY;
+	}
+
 	if (dev->sfp_bus)
 		return sfp_get_module_eeprom_by_page(dev->sfp_bus, page_data, extack);
 
net/ethtool/ioctl.c +12 -0
index 5a55270aa86e..02b23805d2be 100644
@@ -658,6 +658,9 @@ static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
 	if (!dev->ethtool_ops->get_link_ksettings)
 		return -EOPNOTSUPP;
 
+	if (dev->module_fw_flash_in_progress)
+		return -EBUSY;
+
 	memset(&link_ksettings, 0, sizeof(link_ksettings));
 	err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);
 	if (err < 0)
@@ -1449,6 +1452,9 @@ static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 	if (!dev->ethtool_ops->reset)
 		return -EOPNOTSUPP;
 
+	if (dev->module_fw_flash_in_progress)
+		return -EBUSY;
+
 	if (copy_from_user(&reset, useraddr, sizeof(reset)))
 		return -EFAULT;
 
@@ -2462,6 +2468,9 @@ int ethtool_get_module_info_call(struct net_device *dev,
 	const struct ethtool_ops *ops = dev->ethtool_ops;
 	struct phy_device *phydev = dev->phydev;
 
+	if (dev->module_fw_flash_in_progress)
+		return -EBUSY;
+
 	if (dev->sfp_bus)
 		return sfp_get_module_info(dev->sfp_bus, modinfo);
 
@@ -2499,6 +2508,9 @@ int ethtool_get_module_eeprom_call(struct net_device *dev,
 	const struct ethtool_ops *ops = dev->ethtool_ops;
 	struct phy_device *phydev = dev->phydev;
 
+	if (dev->module_fw_flash_in_progress)
+		return -EBUSY;
+
 	if (dev->sfp_bus)
 		return sfp_get_module_eeprom(dev->sfp_bus, ee, data);
 
net/ethtool/module.c +29 -0
index f42e9a9a1ab8..abb7c01e34d2 100644
@@ -3,6 +3,7 @@
 #include <linux/ethtool.h>
 #include <linux/firmware.h>
 #include <linux/sfp.h>
+#include <net/devlink.h>
 
 #include "netlink.h"
 #include "common.h"
@@ -36,6 +37,12 @@ static int module_get_power_mode(struct net_device *dev,
 	if (!ops->get_module_power_mode)
 		return 0;
 
+	if (dev->module_fw_flash_in_progress) {
+		NL_SET_ERR_MSG(extack,
+			       "Module firmware flashing is in progress");
+		return -EBUSY;
+	}
+
 	return ops->get_module_power_mode(dev, &data->power, extack);
 }
 
@@ -112,6 +119,12 @@ ethnl_set_module_validate(struct ethnl_req_info *req_info,
 	if (!tb[ETHTOOL_A_MODULE_POWER_MODE_POLICY])
 		return 0;
 
+	if (req_info->dev->module_fw_flash_in_progress) {
+		NL_SET_ERR_MSG(info->extack,
+			       "Module firmware flashing is in progress");
+		return -EBUSY;
+	}
+
 	if (!ops->get_module_power_mode || !ops->set_module_power_mode) {
 		NL_SET_ERR_MSG_ATTR(info->extack,
 				    tb[ETHTOOL_A_MODULE_POWER_MODE_POLICY],
@@ -219,6 +232,7 @@ static int module_flash_fw_work_init(struct ethtool_module_fw_flash *module_fw,
 static int __module_flash_fw_schedule(struct net_device *dev,
 				      struct netlink_ext_ack *extack)
 {
+	struct devlink_port *devlink_port = dev->devlink_port;
 	const struct ethtool_ops *ops = dev->ethtool_ops;
 
 	if (!ops->set_module_eeprom_by_page ||
@@ -234,6 +248,21 @@ static int __module_flash_fw_schedule(struct net_device *dev,
 		return -EOPNOTSUPP;
 	}
 
+	if (dev->module_fw_flash_in_progress) {
+		NL_SET_ERR_MSG(extack, "Module firmware flashing already in progress");
+		return -EBUSY;
+	}
+
+	if (dev->flags & IFF_UP) {
+		NL_SET_ERR_MSG(extack, "Netdevice is up, so flashing is not permitted");
+		return -EBUSY;
+	}
+
+	if (devlink_port && devlink_port->attrs.split) {
+		NL_SET_ERR_MSG(extack, "Can't perform firmware flashing on a split port");
+		return -EOPNOTSUPP;
+	}
+
 	return 0;
 }
 
net/ethtool/netlink.c +29 -1
index 1a4f6bd1ec7f..90e5b5312aa2 100644
@@ -1194,6 +1194,29 @@ static struct genl_family ethtool_genl_family __ro_after_init = {
 	.n_mcgrps	= ARRAY_SIZE(ethtool_nl_mcgrps),
 };
 
+static int module_netdev_pre_up_event(struct notifier_block *this,
+				      unsigned long event, void *ptr)
+{
+	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
+	struct netdev_notifier_info *info = ptr;
+	struct netlink_ext_ack *extack;
+
+	extack = netdev_notifier_info_to_extack(info);
+
+	if (event == NETDEV_PRE_UP) {
+		if (dev->module_fw_flash_in_progress) {
+			NL_SET_ERR_MSG(extack, "Can't set port up while flashing module firmware");
+			return NOTIFY_BAD;
+		}
+	}
+
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block ethtool_module_netdev_pre_up_notifier = {
+	.notifier_call = module_netdev_pre_up_event,
+};
+
 /* module setup */
 
 static int __init ethnl_init(void)
@@ -1206,7 +1229,12 @@ static int __init ethnl_init(void)
 	ethnl_ok = true;
 
 	ret = register_netdevice_notifier(&ethnl_netdev_notifier);
-	WARN(ret < 0, "ethtool: net device notifier registration failed");
+	if (WARN(ret < 0, "ethtool: net device notifier registration failed"))
+		return ret;
+
+	ret = register_netdevice_notifier(&ethtool_module_netdev_pre_up_notifier);
+	WARN(ret < 0, "ethtool: net device port up notifier registration failed");
+
 	return ret;
 }
 
Signature · 1 line
2.43.0
maintainer
#24 lore raw

Re: [PATCH net-next v5 10/10] ethtool: Veto some operations during firmware flashing process

Quoted 10 lines · On Wed, 24 Apr 2024 16:30:23 +0300 Danielle Ratson wrote:

Some operations cannot be performed during the firmware flashing process.

For example:

- Port must be down during the whole flashing process to avoid packet loss while committing reset for example.

- Writing to EEPROM interrupts the flashing process, so operations like ethtool dump, module reset, get and set power mode should be vetoed.

Quoted 8 lines

- Split port firmware flashing should be vetoed.

- Flashing firmware on a device which is already in a flashing process should be forbidden.

Use the 'module_fw_flashing_in_progress' flag introduced in a previous patch to veto those operations and prevent interruptions while preforming module firmware flash.

Feels a little out of order to add this check after the functionality. I'd merge this with patch 5.

#25 lore raw

RE: [PATCH net-next v5 10/10] ethtool: Veto some operations during firmware flashing process

Quoted 32 lines

-----Original Message-----
From: Jakub Kicinski <[email protected]>
Sent: Tuesday, 30 April 2024 6:24
To: Danielle Ratson <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; linux- [email protected]; mlxsw <[email protected]>; Petr Machata <[email protected]>; Ido Schimmel <[email protected]>
Subject: Re: [PATCH net-next v5 10/10] ethtool: Veto some operations during firmware flashing process

Quoted 15 lines · On Wed, 24 Apr 2024 16:30:23 +0300 Danielle Ratson wrote:

Some operations cannot be performed during the firmware flashing process.

For example:

- Port must be down during the whole flashing process to avoid packet loss while committing reset for example.

- Writing to EEPROM interrupts the flashing process, so operations like ethtool dump, module reset, get and set power mode should be vetoed.

- Split port firmware flashing should be vetoed.

- Flashing firmware on a device which is already in a flashing process should be forbidden.

Quoted 6 lines
Quoted 3 lines

Use the 'module_fw_flashing_in_progress' flag introduced in a previous patch to veto those operations and prevent interruptions while preforming module firmware flash.

Feels a little out of order to add this check after the functionality. I'd merge this with patch 5.

Hi Jakub,

Some of this code is only presented in patch 9, so it will cause splitting some of the vetoes in patch 5 and some of it where the code around is presented. Does it sound reasonable to you?

Thanks,
Danielle

maintainer
#26 lore raw

Re: [PATCH net-next v5 10/10] ethtool: Veto some operations during firmware flashing process

Quoted 3 lines · On Tue, 30 Apr 2024 17:48:17 +0000 Danielle Ratson wrote:

Some of this code is only presented in patch 9, so it will cause splitting some of the vetoes in patch 5 and some of it where the code around is presented. Does it sound reasonable to you?

Yup! Thanks sounds good.