| Message ID | 1615828363-464-2-git-send-email-moshe@nvidia.com |
|---|---|
| State | New |
| Headers | show |
| Series | ethtool: Extend module EEPROM dump API | expand |
On 3/15/2021 11:01 PM, Jakub Kicinski wrote: > > On Mon, 15 Mar 2021 19:12:39 +0200 Moshe Shemesh wrote: >> From: Vladyslav Tarasiuk <vladyslavt@nvidia.com> >> >> Define get_module_eeprom_data_by_page() ethtool callback and implement >> netlink infrastructure. >> >> get_module_eeprom_data_by_page() allows network drivers to dump a part >> of module's EEPROM specified by page and bank numbers along with offset >> and length. It is effectively a netlink replacement for >> get_module_info() and get_module_eeprom() pair, which is needed due to >> emergence of complex non-linear EEPROM layouts. >> >> Signed-off-by: Vladyslav Tarasiuk <vladyslavt@nvidia.com> > s/eeprom_data/eeprom/ everywhere? > > Otherwise some of your identifiers are over 30 characters long. That can work part to one struct on the uapi file that can conflict with previous old KAPI struct, but we can figure it too. Will fix. >> diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h >> index cde753bb2093..b3e92db3ad37 100644 >> --- a/include/uapi/linux/ethtool.h >> +++ b/include/uapi/linux/ethtool.h >> @@ -340,6 +340,28 @@ struct ethtool_eeprom { >> __u8 data[0]; >> }; >> >> +/** >> + * struct ethtool_eeprom_data - 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. >> + * @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_eeprom_data { >> + __u32 offset; >> + __u32 length; >> + __u8 page; >> + __u8 bank; >> + __u8 i2c_address; >> + __u8 *data; >> +}; >> + > This structure does not have to be part of uAPI, right? Right, will fix. >> +#define ETH_MODULE_EEPROM_PAGE_LEN 256 >> +#define ETH_MODULE_MAX_I2C_ADDRESS 0x7f > Not sure about these defines either. Probably. >> +static int eeprom_data_prepare_data(const struct ethnl_req_info *req_base, >> + struct ethnl_reply_data *reply_base, >> + struct genl_info *info) >> +{ >> + struct eeprom_data_reply_data *reply = EEPROM_DATA_REPDATA(reply_base); >> + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_base); >> + struct ethtool_eeprom_data page_data = {0}; >> + struct net_device *dev = reply_base->dev; >> + int ret; >> + >> + if (!dev->ethtool_ops->get_module_eeprom_data_by_page) >> + return -EOPNOTSUPP; >> + >> + page_data.offset = request->offset; >> + page_data.length = request->length; >> + page_data.i2c_address = request->i2c_address; >> + page_data.page = request->page; >> + page_data.bank = request->bank; >> + page_data.data = kmalloc(page_data.length, GFP_KERNEL); >> + if (!page_data.data) >> + return -ENOMEM; > nit: new line? Ack. >> + ret = ethnl_ops_begin(dev); >> + if (ret) >> + goto err_free; >> + >> + ret = dev->ethtool_ops->get_module_eeprom_data_by_page(dev, &page_data, >> + info->extack); >> + if (ret < 0) >> + goto err_ops; >> + >> + reply->length = ret; >> + reply->data = page_data.data; >> + >> + ethnl_ops_complete(dev); >> + return 0; >> + >> +err_ops: >> + ethnl_ops_complete(dev); >> +err_free: >> + kfree(page_data.data); >> + return ret; >> +} >> + >> +static int eeprom_data_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, >> + struct netlink_ext_ack *extack) >> +{ >> + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_info); >> + struct net_device *dev = req_info->dev; >> + >> + if (!tb[ETHTOOL_A_EEPROM_DATA_OFFSET] || >> + !tb[ETHTOOL_A_EEPROM_DATA_LENGTH] || >> + !tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]) >> + return -EINVAL; >> + >> + request->i2c_address = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]); >> + if (request->i2c_address > ETH_MODULE_MAX_I2C_ADDRESS) >> + return -EINVAL; > Max value should be set in the netlink policy. Ack >> + request->offset = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_OFFSET]); >> + request->length = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_LENGTH]); >> + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE] && >> + dev->ethtool_ops->get_module_eeprom_data_by_page && > Why check dev->ethtool_ops->get_module_eeprom_data_by_page here? Right, actually not needed here, thanks. >> + request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) >> + return -EINVAL; >> + >> + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE]) >> + request->page = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_PAGE]); >> + if (tb[ETHTOOL_A_EEPROM_DATA_BANK]) >> + request->bank = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_BANK]); >> + >> + return 0; >> +} >> + >> +static int eeprom_data_reply_size(const struct ethnl_req_info *req_base, >> + const struct ethnl_reply_data *reply_base) >> +{ >> + const struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_base); >> + >> + return nla_total_size(sizeof(u32)) + /* _EEPROM_DATA_LENGTH */ >> + nla_total_size(sizeof(u8) * request->length); /* _EEPROM_DATA */ >> +} > Why report length? Is the netlink length of the DATA attribute not > sufficient? Right, thanks. > Should we echo back offset in case driver wants to report re-aligned > data? The driver knows the requested offset and data has to be from that offset. >> +const struct nla_policy ethnl_eeprom_data_get_policy[] = { >> + [ETHTOOL_A_EEPROM_DATA_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy), >> + [ETHTOOL_A_EEPROM_DATA_OFFSET] = { .type = NLA_U32 }, >> + [ETHTOOL_A_EEPROM_DATA_LENGTH] = { .type = NLA_U32 }, >> + [ETHTOOL_A_EEPROM_DATA_PAGE] = { .type = NLA_U8 }, >> + [ETHTOOL_A_EEPROM_DATA_BANK] = { .type = NLA_U8 }, >> + [ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS] = { .type = NLA_U8 }, >> + [ETHTOOL_A_EEPROM_DATA] = { .type = NLA_BINARY }, > This is a policy for inputs, DATA should not be allowed on input, right? Right, thanks.
On Mon, Mar 15, 2021 at 07:12:39PM +0200, Moshe Shemesh wrote: > From: Vladyslav Tarasiuk <vladyslavt@nvidia.com> > > Define get_module_eeprom_data_by_page() ethtool callback and implement > netlink infrastructure. > > get_module_eeprom_data_by_page() allows network drivers to dump a part > of module's EEPROM specified by page and bank numbers along with offset > and length. It is effectively a netlink replacement for > get_module_info() and get_module_eeprom() pair, which is needed due to > emergence of complex non-linear EEPROM layouts. > > Signed-off-by: Vladyslav Tarasiuk <vladyslavt@nvidia.com> > --- > Documentation/networking/ethtool-netlink.rst | 34 ++++- > include/linux/ethtool.h | 8 +- > include/uapi/linux/ethtool.h | 25 +++ > include/uapi/linux/ethtool_netlink.h | 19 +++ > net/ethtool/Makefile | 2 +- > net/ethtool/eeprom.c | 153 +++++++++++++++++++ > net/ethtool/netlink.c | 10 ++ > net/ethtool/netlink.h | 2 + > 8 files changed, 249 insertions(+), 4 deletions(-) > create mode 100644 net/ethtool/eeprom.c > > diff --git a/Documentation/networking/ethtool-netlink.rst b/Documentation/networking/ethtool-netlink.rst > index 05073482db05..25846b97632a 100644 > --- a/Documentation/networking/ethtool-netlink.rst > +++ b/Documentation/networking/ethtool-netlink.rst > @@ -1280,6 +1280,36 @@ Kernel response contents: > For UDP tunnel table empty ``ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES`` indicates that > the table contains static entries, hard-coded by the NIC. > > +EEPROM_DATA > +=========== > + > +Fetch module EEPROM data dump. > + > +Request contents: > + > + ===================================== ====== ========================== > + ``ETHTOOL_A_EEPROM_DATA_HEADER`` nested request header > + ``ETHTOOL_A_EEPROM_DATA_OFFSET`` u32 offset within a page > + ``ETHTOOL_A_EEPROM_DATA_LENGTH`` u32 amount of bytes to read I wonder if offset and length should be u8. At most, we should only be returning a 1/2 page, so 128 bytes. We don't need a u32. > Request translation > =================== > > @@ -1357,8 +1387,8 @@ are netlink only. > ``ETHTOOL_GET_DUMP_FLAG`` n/a > ``ETHTOOL_GET_DUMP_DATA`` n/a > ``ETHTOOL_GET_TS_INFO`` ``ETHTOOL_MSG_TSINFO_GET`` > - ``ETHTOOL_GMODULEINFO`` n/a > - ``ETHTOOL_GMODULEEEPROM`` n/a > + ``ETHTOOL_GMODULEINFO`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` > + ``ETHTOOL_GMODULEEEPROM`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` > ``ETHTOOL_GEEE`` ``ETHTOOL_MSG_EEE_GET`` > ``ETHTOOL_SEEE`` ``ETHTOOL_MSG_EEE_SET`` > ``ETHTOOL_GRSSH`` n/a We should check with Michal about this. It is not a direct replacement of the old IOCTL API, it is new API. He may want it documented differently. > +static int eeprom_data_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, > + struct netlink_ext_ack *extack) > +{ > + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_info); > + struct net_device *dev = req_info->dev; > + > + if (!tb[ETHTOOL_A_EEPROM_DATA_OFFSET] || > + !tb[ETHTOOL_A_EEPROM_DATA_LENGTH] || > + !tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]) > + return -EINVAL; > + > + request->i2c_address = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]); > + if (request->i2c_address > ETH_MODULE_MAX_I2C_ADDRESS) > + return -EINVAL; > + > + request->offset = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_OFFSET]); > + request->length = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_LENGTH]); > + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE] && > + dev->ethtool_ops->get_module_eeprom_data_by_page && > + request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) > + return -EINVAL; You need to watch out for overflows here. 0xfffffff0 + 0x20 is less than ETH_MODULE_EEPROM_PAGE_LEN when it wraps around, but will cause bad things to happen. Andrew
On 3/18/2021 3:03 PM, Andrew Lunn wrote: > > On Mon, Mar 15, 2021 at 07:12:39PM +0200, Moshe Shemesh wrote: >> From: Vladyslav Tarasiuk <vladyslavt@nvidia.com> >> >> Define get_module_eeprom_data_by_page() ethtool callback and implement >> netlink infrastructure. >> >> get_module_eeprom_data_by_page() allows network drivers to dump a part >> of module's EEPROM specified by page and bank numbers along with offset >> and length. It is effectively a netlink replacement for >> get_module_info() and get_module_eeprom() pair, which is needed due to >> emergence of complex non-linear EEPROM layouts. >> >> Signed-off-by: Vladyslav Tarasiuk <vladyslavt@nvidia.com> >> --- >> Documentation/networking/ethtool-netlink.rst | 34 ++++- >> include/linux/ethtool.h | 8 +- >> include/uapi/linux/ethtool.h | 25 +++ >> include/uapi/linux/ethtool_netlink.h | 19 +++ >> net/ethtool/Makefile | 2 +- >> net/ethtool/eeprom.c | 153 +++++++++++++++++++ >> net/ethtool/netlink.c | 10 ++ >> net/ethtool/netlink.h | 2 + >> 8 files changed, 249 insertions(+), 4 deletions(-) >> create mode 100644 net/ethtool/eeprom.c >> >> diff --git a/Documentation/networking/ethtool-netlink.rst b/Documentation/networking/ethtool-netlink.rst >> index 05073482db05..25846b97632a 100644 >> --- a/Documentation/networking/ethtool-netlink.rst >> +++ b/Documentation/networking/ethtool-netlink.rst >> @@ -1280,6 +1280,36 @@ Kernel response contents: >> For UDP tunnel table empty ``ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES`` indicates that >> the table contains static entries, hard-coded by the NIC. >> >> +EEPROM_DATA >> +=========== >> + >> +Fetch module EEPROM data dump. >> + >> +Request contents: >> + >> + ===================================== ====== ========================== >> + ``ETHTOOL_A_EEPROM_DATA_HEADER`` nested request header >> + ``ETHTOOL_A_EEPROM_DATA_OFFSET`` u32 offset within a page >> + ``ETHTOOL_A_EEPROM_DATA_LENGTH`` u32 amount of bytes to read > I wonder if offset and length should be u8. At most, we should only be > returning a 1/2 page, so 128 bytes. We don't need a u32. That's right when page is given, but user may have commands that used to work on the ioctl KAPI with offset higher than one page. >> Request translation >> =================== >> >> @@ -1357,8 +1387,8 @@ are netlink only. >> ``ETHTOOL_GET_DUMP_FLAG`` n/a >> ``ETHTOOL_GET_DUMP_DATA`` n/a >> ``ETHTOOL_GET_TS_INFO`` ``ETHTOOL_MSG_TSINFO_GET`` >> - ``ETHTOOL_GMODULEINFO`` n/a >> - ``ETHTOOL_GMODULEEEPROM`` n/a >> + ``ETHTOOL_GMODULEINFO`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` >> + ``ETHTOOL_GMODULEEEPROM`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` >> ``ETHTOOL_GEEE`` ``ETHTOOL_MSG_EEE_GET`` >> ``ETHTOOL_SEEE`` ``ETHTOOL_MSG_EEE_SET`` >> ``ETHTOOL_GRSSH`` n/a > We should check with Michal about this. It is not a direct replacement > of the old IOCTL API, it is new API. He may want it documented > differently. Michal, please comment on where it should be. >> +static int eeprom_data_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, >> + struct netlink_ext_ack *extack) >> +{ >> + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_info); >> + struct net_device *dev = req_info->dev; >> + >> + if (!tb[ETHTOOL_A_EEPROM_DATA_OFFSET] || >> + !tb[ETHTOOL_A_EEPROM_DATA_LENGTH] || >> + !tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]) >> + return -EINVAL; >> + >> + request->i2c_address = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]); >> + if (request->i2c_address > ETH_MODULE_MAX_I2C_ADDRESS) >> + return -EINVAL; >> + >> + request->offset = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_OFFSET]); >> + request->length = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_LENGTH]); >> + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE] && >> + dev->ethtool_ops->get_module_eeprom_data_by_page && >> + request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) >> + return -EINVAL; > You need to watch out for overflows here. 0xfffffff0 + 0x20 is less > than ETH_MODULE_EEPROM_PAGE_LEN when it wraps around, but will cause > bad things to happen. Ack. > Andrew
On Thu, Mar 18, 2021 at 02:03:02PM +0100, Andrew Lunn wrote: > On Mon, Mar 15, 2021 at 07:12:39PM +0200, Moshe Shemesh wrote: > > > > +EEPROM_DATA > > +=========== > > + > > +Fetch module EEPROM data dump. > > + > > +Request contents: > > + > > + ===================================== ====== ========================== > > + ``ETHTOOL_A_EEPROM_DATA_HEADER`` nested request header > > + ``ETHTOOL_A_EEPROM_DATA_OFFSET`` u32 offset within a page > > + ``ETHTOOL_A_EEPROM_DATA_LENGTH`` u32 amount of bytes to read > > I wonder if offset and length should be u8. At most, we should only be > returning a 1/2 page, so 128 bytes. We don't need a u32. There is no actual gain using NLA_U8 due to padding. Out of the interfaces used here, kernel-userspace API is the least flexible so I would generally prefer NLA_U32, except for bools or enumerated values where it's absolutely obvious the number of possible values cannot grow too much. In this case, I can't really say it's impossible we could have devices with bigger pages in something like 20 years. > > Request translation > > =================== > > > > @@ -1357,8 +1387,8 @@ are netlink only. > > ``ETHTOOL_GET_DUMP_FLAG`` n/a > > ``ETHTOOL_GET_DUMP_DATA`` n/a > > ``ETHTOOL_GET_TS_INFO`` ``ETHTOOL_MSG_TSINFO_GET`` > > - ``ETHTOOL_GMODULEINFO`` n/a > > - ``ETHTOOL_GMODULEEEPROM`` n/a > > + ``ETHTOOL_GMODULEINFO`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` > > + ``ETHTOOL_GMODULEEEPROM`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` > > ``ETHTOOL_GEEE`` ``ETHTOOL_MSG_EEE_GET`` > > ``ETHTOOL_SEEE`` ``ETHTOOL_MSG_EEE_SET`` > > ``ETHTOOL_GRSSH`` n/a > > We should check with Michal about this. It is not a direct replacement > of the old IOCTL API, it is new API. He may want it documented > differently. This table is meant to give a hint in the sense "for what you used ioctl command in left column, use now netlink request in the right". So IMHO it's appropriate. Perhaps it would deserve a comment explaining this. > > + request->offset = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_OFFSET]); > > + request->length = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_LENGTH]); > > + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE] && > > + dev->ethtool_ops->get_module_eeprom_data_by_page && > > + request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) > > + return -EINVAL; > > You need to watch out for overflows here. 0xfffffff0 + 0x20 is less > than ETH_MODULE_EEPROM_PAGE_LEN when it wraps around, but will cause > bad things to happen. BtW, the ioctl code also suffers from this problem and we recently had a report from customer (IIRC the effect was ethtool trying to allocate ~4GB of memory), upstream fix should follow soon. Michal
> > > +Request contents: > > > + > > > + ===================================== ====== ========================== > > > + ``ETHTOOL_A_EEPROM_DATA_HEADER`` nested request header > > > + ``ETHTOOL_A_EEPROM_DATA_OFFSET`` u32 offset within a page > > > + ``ETHTOOL_A_EEPROM_DATA_LENGTH`` u32 amount of bytes to read > > I wonder if offset and length should be u8. At most, we should only be > > returning a 1/2 page, so 128 bytes. We don't need a u32. > > > That's right when page is given, but user may have commands that > used to work on the ioctl KAPI with offset higher than one page. CMIS section 5.4.1 says: The slave maintains an internal current byte address counter containing the byte address accessed during the latest read or write operation incremented by one with roll-over as follows: The current byte address counter rolls-over after a read or write operation at the last byte address of the current 128-byte memory page (127 or 255) to the first byte address (0 or 128) of the same 128-byte memory page. This wrapping is somewhat unexpected. If the user access is for a read starting at 120 and a length of 20, they get bytes 120-127 followed by 0-11. The user is more likely to be expecting 120-139. We have two ways to address this: 1) We limit reads to a maximum of a 1/2 page, and the start and end point needs to be within that 1/2 page. 2) We detect that the read is going to go across a 1/2 page boarder, and perform two reads to the MAC driver, and glue the data back together again in the ethtool core. What i don't want is to leave the individual drivers to solve this, because i expect some of them will get it wrong. Andrew
diff --git a/Documentation/networking/ethtool-netlink.rst b/Documentation/networking/ethtool-netlink.rst index 05073482db05..25846b97632a 100644 --- a/Documentation/networking/ethtool-netlink.rst +++ b/Documentation/networking/ethtool-netlink.rst @@ -1280,6 +1280,36 @@ Kernel response contents: For UDP tunnel table empty ``ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES`` indicates that the table contains static entries, hard-coded by the NIC. +EEPROM_DATA +=========== + +Fetch module EEPROM data dump. + +Request contents: + + ===================================== ====== ========================== + ``ETHTOOL_A_EEPROM_DATA_HEADER`` nested request header + ``ETHTOOL_A_EEPROM_DATA_OFFSET`` u32 offset within a page + ``ETHTOOL_A_EEPROM_DATA_LENGTH`` u32 amount of bytes to read + ``ETHTOOL_A_EEPROM_DATA_PAGE`` u8 page number + ``ETHTOOL_A_EEPROM_DATA_BANK`` u8 bank number + ``ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS`` u8 page I2C address + ===================================== ====== ========================== + +Kernel response contents: + + +---------------------------------------------+--------+---------------------+ + | ``ETHTOOL_A_EEPROM_DATA_HEADER`` | nested | reply header | + +---------------------------------------------+--------+---------------------+ + | ``ETHTOOL_A_EEPROM_DATA_LENGTH`` | u32 | amount of bytes read| + +---------------------------------------------+--------+---------------------+ + | ``ETHTOOL_A_EEPROM_DATA`` | nested | array of bytes from | + | | | module EEPROM | + +---------------------------------------------+--------+---------------------+ + +``ETHTOOL_A_EEPROM_DATA`` has an attribute length equal to the amount of bytes +driver actually read. + Request translation =================== @@ -1357,8 +1387,8 @@ are netlink only. ``ETHTOOL_GET_DUMP_FLAG`` n/a ``ETHTOOL_GET_DUMP_DATA`` n/a ``ETHTOOL_GET_TS_INFO`` ``ETHTOOL_MSG_TSINFO_GET`` - ``ETHTOOL_GMODULEINFO`` n/a - ``ETHTOOL_GMODULEEEPROM`` n/a + ``ETHTOOL_GMODULEINFO`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` + ``ETHTOOL_GMODULEEEPROM`` ``ETHTOOL_MSG_MODULE_EEPROM_GET`` ``ETHTOOL_GEEE`` ``ETHTOOL_MSG_EEE_GET`` ``ETHTOOL_SEEE`` ``ETHTOOL_MSG_EEE_SET`` ``ETHTOOL_GRSSH`` n/a diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h index ec4cd3921c67..9551005b350a 100644 --- a/include/linux/ethtool.h +++ b/include/linux/ethtool.h @@ -81,6 +81,7 @@ enum { #define ETH_RSS_HASH_NO_CHANGE 0 struct net_device; +struct netlink_ext_ack; /* Some generic methods drivers may use in their ethtool_ops */ u32 ethtool_op_get_link(struct net_device *dev); @@ -410,6 +411,9 @@ struct ethtool_pause_stats { * @get_ethtool_phy_stats: Return extended statistics about the PHY device. * This is only useful if the device maintains PHY statistics and * cannot use the standard PHY library helpers. + * @get_module_eeprom_data_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. * * All operations are optional (i.e. the function pointer may be set * to %NULL) and callers must take this into account. Callers must @@ -515,6 +519,9 @@ struct ethtool_ops { const struct ethtool_tunable *, void *); int (*set_phy_tunable)(struct net_device *, const struct ethtool_tunable *, const void *); + int (*get_module_eeprom_data_by_page)(struct net_device *dev, + const struct ethtool_eeprom_data *page, + struct netlink_ext_ack *extack); }; int ethtool_check_ops(const struct ethtool_ops *ops); @@ -538,7 +545,6 @@ int ethtool_virtdev_set_link_ksettings(struct net_device *dev, const struct ethtool_link_ksettings *cmd, u32 *dev_speed, u8 *dev_duplex); -struct netlink_ext_ack; struct phy_device; struct phy_tdr_config; diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h index cde753bb2093..b3e92db3ad37 100644 --- a/include/uapi/linux/ethtool.h +++ b/include/uapi/linux/ethtool.h @@ -340,6 +340,28 @@ struct ethtool_eeprom { __u8 data[0]; }; +/** + * struct ethtool_eeprom_data - 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. + * @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_eeprom_data { + __u32 offset; + __u32 length; + __u8 page; + __u8 bank; + __u8 i2c_address; + __u8 *data; +}; + /** * struct ethtool_eee - Energy Efficient Ethernet information * @cmd: ETHTOOL_{G,S}EEE @@ -1865,6 +1887,9 @@ static inline int ethtool_validate_duplex(__u8 duplex) #define ETH_MODULE_SFF_8636_MAX_LEN 640 #define ETH_MODULE_SFF_8436_MAX_LEN 640 +#define ETH_MODULE_EEPROM_PAGE_LEN 256 +#define ETH_MODULE_MAX_I2C_ADDRESS 0x7f + /* Reset flags */ /* The reset() operation must clear the flags for the components which * were actually reset. On successful return, the flags indicate the diff --git a/include/uapi/linux/ethtool_netlink.h b/include/uapi/linux/ethtool_netlink.h index a286635ac9b8..e1b1b962f3da 100644 --- a/include/uapi/linux/ethtool_netlink.h +++ b/include/uapi/linux/ethtool_netlink.h @@ -42,6 +42,7 @@ enum { ETHTOOL_MSG_CABLE_TEST_ACT, ETHTOOL_MSG_CABLE_TEST_TDR_ACT, ETHTOOL_MSG_TUNNEL_INFO_GET, + ETHTOOL_MSG_EEPROM_DATA_GET, /* add new constants above here */ __ETHTOOL_MSG_USER_CNT, @@ -80,6 +81,7 @@ enum { ETHTOOL_MSG_CABLE_TEST_NTF, ETHTOOL_MSG_CABLE_TEST_TDR_NTF, ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY, + ETHTOOL_MSG_EEPROM_DATA_GET_REPLY, /* add new constants above here */ __ETHTOOL_MSG_KERNEL_CNT, @@ -629,6 +631,23 @@ enum { ETHTOOL_A_TUNNEL_INFO_MAX = (__ETHTOOL_A_TUNNEL_INFO_CNT - 1) }; +/* MODULE EEPROM DATA */ + +enum { + ETHTOOL_A_EEPROM_DATA_UNSPEC, + ETHTOOL_A_EEPROM_DATA_HEADER, /* nest - _A_HEADER_* */ + + ETHTOOL_A_EEPROM_DATA_OFFSET, /* u32 */ + ETHTOOL_A_EEPROM_DATA_LENGTH, /* u32 */ + ETHTOOL_A_EEPROM_DATA_PAGE, /* u8 */ + ETHTOOL_A_EEPROM_DATA_BANK, /* u8 */ + ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS, /* u8 */ + ETHTOOL_A_EEPROM_DATA, /* nested */ + + __ETHTOOL_A_EEPROM_DATA_CNT, + ETHTOOL_A_EEPROM_DATA_MAX = (__ETHTOOL_A_EEPROM_DATA_CNT - 1) +}; + /* generic netlink info */ #define ETHTOOL_GENL_NAME "ethtool" #define ETHTOOL_GENL_VERSION 1 diff --git a/net/ethtool/Makefile b/net/ethtool/Makefile index 7a849ff22dad..d604346bc074 100644 --- a/net/ethtool/Makefile +++ b/net/ethtool/Makefile @@ -7,4 +7,4 @@ obj-$(CONFIG_ETHTOOL_NETLINK) += ethtool_nl.o ethtool_nl-y := netlink.o bitset.o strset.o linkinfo.o linkmodes.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 + tunnels.o eeprom.o diff --git a/net/ethtool/eeprom.c b/net/ethtool/eeprom.c new file mode 100644 index 000000000000..e110336dc231 --- /dev/null +++ b/net/ethtool/eeprom.c @@ -0,0 +1,153 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include <linux/ethtool.h> +#include "netlink.h" +#include "common.h" + +struct eeprom_data_req_info { + struct ethnl_req_info base; + u32 offset; + u32 length; + u8 page; + u8 bank; + u8 i2c_address; +}; + +struct eeprom_data_reply_data { + struct ethnl_reply_data base; + u32 length; + u8 *data; +}; + +#define EEPROM_DATA_REQINFO(__req_base) \ + container_of(__req_base, struct eeprom_data_req_info, base) + +#define EEPROM_DATA_REPDATA(__reply_base) \ + container_of(__reply_base, struct eeprom_data_reply_data, base) + +static int eeprom_data_prepare_data(const struct ethnl_req_info *req_base, + struct ethnl_reply_data *reply_base, + struct genl_info *info) +{ + struct eeprom_data_reply_data *reply = EEPROM_DATA_REPDATA(reply_base); + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_base); + struct ethtool_eeprom_data page_data = {0}; + struct net_device *dev = reply_base->dev; + int ret; + + if (!dev->ethtool_ops->get_module_eeprom_data_by_page) + return -EOPNOTSUPP; + + page_data.offset = request->offset; + page_data.length = request->length; + page_data.i2c_address = request->i2c_address; + page_data.page = request->page; + page_data.bank = request->bank; + page_data.data = kmalloc(page_data.length, GFP_KERNEL); + if (!page_data.data) + return -ENOMEM; + ret = ethnl_ops_begin(dev); + if (ret) + goto err_free; + + ret = dev->ethtool_ops->get_module_eeprom_data_by_page(dev, &page_data, + info->extack); + if (ret < 0) + goto err_ops; + + reply->length = ret; + reply->data = page_data.data; + + ethnl_ops_complete(dev); + return 0; + +err_ops: + ethnl_ops_complete(dev); +err_free: + kfree(page_data.data); + return ret; +} + +static int eeprom_data_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, + struct netlink_ext_ack *extack) +{ + struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_info); + struct net_device *dev = req_info->dev; + + if (!tb[ETHTOOL_A_EEPROM_DATA_OFFSET] || + !tb[ETHTOOL_A_EEPROM_DATA_LENGTH] || + !tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]) + return -EINVAL; + + request->i2c_address = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS]); + if (request->i2c_address > ETH_MODULE_MAX_I2C_ADDRESS) + return -EINVAL; + + request->offset = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_OFFSET]); + request->length = nla_get_u32(tb[ETHTOOL_A_EEPROM_DATA_LENGTH]); + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE] && + dev->ethtool_ops->get_module_eeprom_data_by_page && + request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) + return -EINVAL; + + if (tb[ETHTOOL_A_EEPROM_DATA_PAGE]) + request->page = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_PAGE]); + if (tb[ETHTOOL_A_EEPROM_DATA_BANK]) + request->bank = nla_get_u8(tb[ETHTOOL_A_EEPROM_DATA_BANK]); + + return 0; +} + +static int eeprom_data_reply_size(const struct ethnl_req_info *req_base, + const struct ethnl_reply_data *reply_base) +{ + const struct eeprom_data_req_info *request = EEPROM_DATA_REQINFO(req_base); + + return nla_total_size(sizeof(u32)) + /* _EEPROM_DATA_LENGTH */ + nla_total_size(sizeof(u8) * request->length); /* _EEPROM_DATA */ +} + +static int eeprom_data_fill_reply(struct sk_buff *skb, + const struct ethnl_req_info *req_base, + const struct ethnl_reply_data *reply_base) +{ + struct eeprom_data_reply_data *reply = EEPROM_DATA_REPDATA(reply_base); + + if (nla_put_u32(skb, ETHTOOL_A_EEPROM_DATA_LENGTH, reply->length) || + nla_put(skb, ETHTOOL_A_EEPROM_DATA, reply->length, reply->data)) + return -EMSGSIZE; + + return 0; +} + +static void eeprom_data_cleanup_data(struct ethnl_reply_data *reply_base) +{ + struct eeprom_data_reply_data *reply = EEPROM_DATA_REPDATA(reply_base); + + kfree(reply->data); +} + +const struct ethnl_request_ops ethnl_eeprom_data_request_ops = { + .request_cmd = ETHTOOL_MSG_EEPROM_DATA_GET, + .reply_cmd = ETHTOOL_MSG_EEPROM_DATA_GET_REPLY, + .hdr_attr = ETHTOOL_A_EEPROM_DATA_HEADER, + .req_info_size = sizeof(struct eeprom_data_req_info), + .reply_data_size = sizeof(struct eeprom_data_reply_data), + + .parse_request = eeprom_data_parse_request, + .prepare_data = eeprom_data_prepare_data, + .reply_size = eeprom_data_reply_size, + .fill_reply = eeprom_data_fill_reply, + .cleanup_data = eeprom_data_cleanup_data, +}; + +const struct nla_policy ethnl_eeprom_data_get_policy[] = { + [ETHTOOL_A_EEPROM_DATA_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy), + [ETHTOOL_A_EEPROM_DATA_OFFSET] = { .type = NLA_U32 }, + [ETHTOOL_A_EEPROM_DATA_LENGTH] = { .type = NLA_U32 }, + [ETHTOOL_A_EEPROM_DATA_PAGE] = { .type = NLA_U8 }, + [ETHTOOL_A_EEPROM_DATA_BANK] = { .type = NLA_U8 }, + [ETHTOOL_A_EEPROM_DATA_I2C_ADDRESS] = { .type = NLA_U8 }, + [ETHTOOL_A_EEPROM_DATA] = { .type = NLA_BINARY }, +}; + diff --git a/net/ethtool/netlink.c b/net/ethtool/netlink.c index 50d3c8896f91..ff2528bee192 100644 --- a/net/ethtool/netlink.c +++ b/net/ethtool/netlink.c @@ -245,6 +245,7 @@ ethnl_default_requests[__ETHTOOL_MSG_USER_CNT] = { [ETHTOOL_MSG_PAUSE_GET] = ðnl_pause_request_ops, [ETHTOOL_MSG_EEE_GET] = ðnl_eee_request_ops, [ETHTOOL_MSG_TSINFO_GET] = ðnl_tsinfo_request_ops, + [ETHTOOL_MSG_EEPROM_DATA_GET] = ðnl_eeprom_data_request_ops, }; static struct ethnl_dump_ctx *ethnl_dump_context(struct netlink_callback *cb) @@ -912,6 +913,15 @@ static const struct genl_ops ethtool_genl_ops[] = { .policy = ethnl_tunnel_info_get_policy, .maxattr = ARRAY_SIZE(ethnl_tunnel_info_get_policy) - 1, }, + { + .cmd = ETHTOOL_MSG_EEPROM_DATA_GET, + .doit = ethnl_default_doit, + .start = ethnl_default_start, + .dumpit = ethnl_default_dumpit, + .done = ethnl_default_done, + .policy = ethnl_eeprom_data_get_policy, + .maxattr = ARRAY_SIZE(ethnl_eeprom_data_get_policy) - 1, + }, }; static const struct genl_multicast_group ethtool_nl_mcgrps[] = { diff --git a/net/ethtool/netlink.h b/net/ethtool/netlink.h index 6eabd58d81bf..60954c7b4dfe 100644 --- a/net/ethtool/netlink.h +++ b/net/ethtool/netlink.h @@ -344,6 +344,7 @@ extern const struct ethnl_request_ops ethnl_coalesce_request_ops; extern const struct ethnl_request_ops ethnl_pause_request_ops; extern const struct ethnl_request_ops ethnl_eee_request_ops; extern const struct ethnl_request_ops ethnl_tsinfo_request_ops; +extern const struct ethnl_request_ops ethnl_eeprom_data_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]; @@ -375,6 +376,7 @@ extern const struct nla_policy ethnl_tsinfo_get_policy[ETHTOOL_A_TSINFO_HEADER + extern const struct nla_policy ethnl_cable_test_act_policy[ETHTOOL_A_CABLE_TEST_HEADER + 1]; extern const struct nla_policy ethnl_cable_test_tdr_act_policy[ETHTOOL_A_CABLE_TEST_TDR_CFG + 1]; extern const struct nla_policy ethnl_tunnel_info_get_policy[ETHTOOL_A_TUNNEL_INFO_HEADER + 1]; +extern const struct nla_policy ethnl_eeprom_data_get_policy[ETHTOOL_A_EEPROM_DATA + 1]; int ethnl_set_linkinfo(struct sk_buff *skb, struct genl_info *info); int ethnl_set_linkmodes(struct sk_buff *skb, struct genl_info *info);