Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : 
       3                 :            : #include "netlink.h"
       4                 :            : #include "common.h"
       5                 :            : #include "bitset.h"
       6                 :            : 
       7                 :            : struct debug_req_info {
       8                 :            :         struct ethnl_req_info           base;
       9                 :            : };
      10                 :            : 
      11                 :            : struct debug_reply_data {
      12                 :            :         struct ethnl_reply_data         base;
      13                 :            :         u32                             msg_mask;
      14                 :            : };
      15                 :            : 
      16                 :            : #define DEBUG_REPDATA(__reply_base) \
      17                 :            :         container_of(__reply_base, struct debug_reply_data, base)
      18                 :            : 
      19                 :            : static const struct nla_policy
      20                 :            : debug_get_policy[ETHTOOL_A_DEBUG_MAX + 1] = {
      21                 :            :         [ETHTOOL_A_DEBUG_UNSPEC]        = { .type = NLA_REJECT },
      22                 :            :         [ETHTOOL_A_DEBUG_HEADER]        = { .type = NLA_NESTED },
      23                 :            :         [ETHTOOL_A_DEBUG_MSGMASK]       = { .type = NLA_REJECT },
      24                 :            : };
      25                 :            : 
      26                 :          0 : static int debug_prepare_data(const struct ethnl_req_info *req_base,
      27                 :            :                               struct ethnl_reply_data *reply_base,
      28                 :            :                               struct genl_info *info)
      29                 :            : {
      30                 :          0 :         struct debug_reply_data *data = DEBUG_REPDATA(reply_base);
      31                 :          0 :         struct net_device *dev = reply_base->dev;
      32                 :          0 :         int ret;
      33                 :            : 
      34         [ #  # ]:          0 :         if (!dev->ethtool_ops->get_msglevel)
      35                 :            :                 return -EOPNOTSUPP;
      36                 :            : 
      37         [ #  # ]:          0 :         ret = ethnl_ops_begin(dev);
      38         [ #  # ]:          0 :         if (ret < 0)
      39                 :            :                 return ret;
      40                 :          0 :         data->msg_mask = dev->ethtool_ops->get_msglevel(dev);
      41         [ #  # ]:          0 :         ethnl_ops_complete(dev);
      42                 :            : 
      43                 :            :         return 0;
      44                 :            : }
      45                 :            : 
      46                 :          0 : static int debug_reply_size(const struct ethnl_req_info *req_base,
      47                 :            :                             const struct ethnl_reply_data *reply_base)
      48                 :            : {
      49                 :          0 :         const struct debug_reply_data *data = DEBUG_REPDATA(reply_base);
      50                 :          0 :         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
      51                 :            : 
      52                 :          0 :         return ethnl_bitset32_size(&data->msg_mask, NULL, NETIF_MSG_CLASS_COUNT,
      53                 :            :                                    netif_msg_class_names, compact);
      54                 :            : }
      55                 :            : 
      56                 :          0 : static int debug_fill_reply(struct sk_buff *skb,
      57                 :            :                             const struct ethnl_req_info *req_base,
      58                 :            :                             const struct ethnl_reply_data *reply_base)
      59                 :            : {
      60                 :          0 :         const struct debug_reply_data *data = DEBUG_REPDATA(reply_base);
      61                 :          0 :         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
      62                 :            : 
      63                 :          0 :         return ethnl_put_bitset32(skb, ETHTOOL_A_DEBUG_MSGMASK, &data->msg_mask,
      64                 :            :                                   NULL, NETIF_MSG_CLASS_COUNT,
      65                 :            :                                   netif_msg_class_names, compact);
      66                 :            : }
      67                 :            : 
      68                 :            : const struct ethnl_request_ops ethnl_debug_request_ops = {
      69                 :            :         .request_cmd            = ETHTOOL_MSG_DEBUG_GET,
      70                 :            :         .reply_cmd              = ETHTOOL_MSG_DEBUG_GET_REPLY,
      71                 :            :         .hdr_attr               = ETHTOOL_A_DEBUG_HEADER,
      72                 :            :         .max_attr               = ETHTOOL_A_DEBUG_MAX,
      73                 :            :         .req_info_size          = sizeof(struct debug_req_info),
      74                 :            :         .reply_data_size        = sizeof(struct debug_reply_data),
      75                 :            :         .request_policy         = debug_get_policy,
      76                 :            : 
      77                 :            :         .prepare_data           = debug_prepare_data,
      78                 :            :         .reply_size             = debug_reply_size,
      79                 :            :         .fill_reply             = debug_fill_reply,
      80                 :            : };
      81                 :            : 
      82                 :            : /* DEBUG_SET */
      83                 :            : 
      84                 :            : static const struct nla_policy
      85                 :            : debug_set_policy[ETHTOOL_A_DEBUG_MAX + 1] = {
      86                 :            :         [ETHTOOL_A_DEBUG_UNSPEC]        = { .type = NLA_REJECT },
      87                 :            :         [ETHTOOL_A_DEBUG_HEADER]        = { .type = NLA_NESTED },
      88                 :            :         [ETHTOOL_A_DEBUG_MSGMASK]       = { .type = NLA_NESTED },
      89                 :            : };
      90                 :            : 
      91                 :          0 : int ethnl_set_debug(struct sk_buff *skb, struct genl_info *info)
      92                 :            : {
      93                 :          0 :         struct nlattr *tb[ETHTOOL_A_DEBUG_MAX + 1];
      94                 :          0 :         struct ethnl_req_info req_info = {};
      95                 :          0 :         struct net_device *dev;
      96                 :          0 :         bool mod = false;
      97                 :          0 :         u32 msg_mask;
      98                 :          0 :         int ret;
      99                 :            : 
     100                 :          0 :         ret = nlmsg_parse(info->nlhdr, GENL_HDRLEN, tb,
     101                 :            :                           ETHTOOL_A_DEBUG_MAX, debug_set_policy,
     102                 :            :                           info->extack);
     103         [ #  # ]:          0 :         if (ret < 0)
     104                 :            :                 return ret;
     105                 :          0 :         ret = ethnl_parse_header(&req_info, tb[ETHTOOL_A_DEBUG_HEADER],
     106                 :            :                                  genl_info_net(info), info->extack, true);
     107         [ #  # ]:          0 :         if (ret < 0)
     108                 :            :                 return ret;
     109                 :          0 :         dev = req_info.dev;
     110                 :          0 :         ret = -EOPNOTSUPP;
     111   [ #  #  #  # ]:          0 :         if (!dev->ethtool_ops->get_msglevel || !dev->ethtool_ops->set_msglevel)
     112                 :          0 :                 goto out_dev;
     113                 :            : 
     114                 :          0 :         rtnl_lock();
     115         [ #  # ]:          0 :         ret = ethnl_ops_begin(dev);
     116         [ #  # ]:          0 :         if (ret < 0)
     117                 :          0 :                 goto out_rtnl;
     118                 :            : 
     119                 :          0 :         msg_mask = dev->ethtool_ops->get_msglevel(dev);
     120                 :          0 :         ret = ethnl_update_bitset32(&msg_mask, NETIF_MSG_CLASS_COUNT,
     121                 :          0 :                                     tb[ETHTOOL_A_DEBUG_MSGMASK],
     122                 :            :                                     netif_msg_class_names, info->extack, &mod);
     123   [ #  #  #  # ]:          0 :         if (ret < 0 || !mod)
     124                 :          0 :                 goto out_ops;
     125                 :            : 
     126                 :          0 :         dev->ethtool_ops->set_msglevel(dev, msg_mask);
     127                 :          0 :         ethtool_notify(dev, ETHTOOL_MSG_DEBUG_NTF, NULL);
     128                 :            : 
     129                 :          0 : out_ops:
     130         [ #  # ]:          0 :         ethnl_ops_complete(dev);
     131                 :          0 : out_rtnl:
     132                 :          0 :         rtnl_unlock();
     133                 :          0 : out_dev:
     134                 :          0 :         dev_put(dev);
     135                 :          0 :         return ret;
     136                 :            : }