1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include "netlink.h" 4 #include "common.h" 5 #include "bitset.h" 6 7 struct privflags_req_info { 8 struct ethnl_req_info base; 9 }; 10 11 struct privflags_reply_data { 12 struct ethnl_reply_data base; 13 const char (*priv_flag_names)[ETH_GSTRING_LEN]; 14 unsigned int n_priv_flags; 15 u32 priv_flags; 16 }; 17 18 #define PRIVFLAGS_REPDATA(__reply_base) \ 19 container_of(__reply_base, struct privflags_reply_data, base) 20 21 const struct nla_policy 22 ethnl_privflags_get_policy[ETHTOOL_A_PRIVFLAGS_MAX + 1] = { 23 [ETHTOOL_A_PRIVFLAGS_UNSPEC] = { .type = NLA_REJECT }, 24 [ETHTOOL_A_PRIVFLAGS_HEADER] = { .type = NLA_NESTED }, 25 [ETHTOOL_A_PRIVFLAGS_FLAGS] = { .type = NLA_REJECT }, 26 }; 27 28 static int ethnl_get_priv_flags_info(struct net_device *dev, 29 unsigned int *count, 30 const char (**names)[ETH_GSTRING_LEN]) 31 { 32 const struct ethtool_ops *ops = dev->ethtool_ops; 33 int nflags; 34 35 nflags = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS); 36 if (nflags < 0) 37 return nflags; 38 39 if (names) { 40 *names = kcalloc(nflags, ETH_GSTRING_LEN, GFP_KERNEL); 41 if (!*names) 42 return -ENOMEM; 43 ops->get_strings(dev, ETH_SS_PRIV_FLAGS, (u8 *)*names); 44 } 45 46 /* We can pass more than 32 private flags to userspace via netlink but 47 * we cannot get more with ethtool_ops::get_priv_flags(). Note that we 48 * must not adjust nflags before allocating the space for flag names 49 * as the buffer must be large enough for all flags. 50 */ 51 if (WARN_ONCE(nflags > 32, 52 "device %s reports more than 32 private flags (%d)\n", 53 netdev_name(dev), nflags)) 54 nflags = 32; 55 *count = nflags; 56 57 return 0; 58 } 59 60 static int privflags_prepare_data(const struct ethnl_req_info *req_base, 61 struct ethnl_reply_data *reply_base, 62 struct genl_info *info) 63 { 64 struct privflags_reply_data *data = PRIVFLAGS_REPDATA(reply_base); 65 struct net_device *dev = reply_base->dev; 66 const char (*names)[ETH_GSTRING_LEN]; 67 const struct ethtool_ops *ops; 68 unsigned int nflags; 69 int ret; 70 71 ops = dev->ethtool_ops; 72 if (!ops->get_priv_flags || !ops->get_sset_count || !ops->get_strings) 73 return -EOPNOTSUPP; 74 ret = ethnl_ops_begin(dev); 75 if (ret < 0) 76 return ret; 77 78 ret = ethnl_get_priv_flags_info(dev, &nflags, &names); 79 if (ret < 0) 80 goto out_ops; 81 data->priv_flags = ops->get_priv_flags(dev); 82 data->priv_flag_names = names; 83 data->n_priv_flags = nflags; 84 85 out_ops: 86 ethnl_ops_complete(dev); 87 return ret; 88 } 89 90 static int privflags_reply_size(const struct ethnl_req_info *req_base, 91 const struct ethnl_reply_data *reply_base) 92 { 93 const struct privflags_reply_data *data = PRIVFLAGS_REPDATA(reply_base); 94 bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS; 95 const u32 all_flags = ~(u32)0 >> (32 - data->n_priv_flags); 96 97 return ethnl_bitset32_size(&data->priv_flags, &all_flags, 98 data->n_priv_flags, 99 data->priv_flag_names, compact); 100 } 101 102 static int privflags_fill_reply(struct sk_buff *skb, 103 const struct ethnl_req_info *req_base, 104 const struct ethnl_reply_data *reply_base) 105 { 106 const struct privflags_reply_data *data = PRIVFLAGS_REPDATA(reply_base); 107 bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS; 108 const u32 all_flags = ~(u32)0 >> (32 - data->n_priv_flags); 109 110 return ethnl_put_bitset32(skb, ETHTOOL_A_PRIVFLAGS_FLAGS, 111 &data->priv_flags, &all_flags, 112 data->n_priv_flags, data->priv_flag_names, 113 compact); 114 } 115 116 static void privflags_cleanup_data(struct ethnl_reply_data *reply_data) 117 { 118 struct privflags_reply_data *data = PRIVFLAGS_REPDATA(reply_data); 119 120 kfree(data->priv_flag_names); 121 } 122 123 const struct ethnl_request_ops ethnl_privflags_request_ops = { 124 .request_cmd = ETHTOOL_MSG_PRIVFLAGS_GET, 125 .reply_cmd = ETHTOOL_MSG_PRIVFLAGS_GET_REPLY, 126 .hdr_attr = ETHTOOL_A_PRIVFLAGS_HEADER, 127 .req_info_size = sizeof(struct privflags_req_info), 128 .reply_data_size = sizeof(struct privflags_reply_data), 129 130 .prepare_data = privflags_prepare_data, 131 .reply_size = privflags_reply_size, 132 .fill_reply = privflags_fill_reply, 133 .cleanup_data = privflags_cleanup_data, 134 }; 135 136 /* PRIVFLAGS_SET */ 137 138 static const struct nla_policy 139 privflags_set_policy[ETHTOOL_A_PRIVFLAGS_MAX + 1] = { 140 [ETHTOOL_A_PRIVFLAGS_UNSPEC] = { .type = NLA_REJECT }, 141 [ETHTOOL_A_PRIVFLAGS_HEADER] = { .type = NLA_NESTED }, 142 [ETHTOOL_A_PRIVFLAGS_FLAGS] = { .type = NLA_NESTED }, 143 }; 144 145 int ethnl_set_privflags(struct sk_buff *skb, struct genl_info *info) 146 { 147 struct nlattr *tb[ETHTOOL_A_PRIVFLAGS_MAX + 1]; 148 const char (*names)[ETH_GSTRING_LEN] = NULL; 149 struct ethnl_req_info req_info = {}; 150 const struct ethtool_ops *ops; 151 struct net_device *dev; 152 unsigned int nflags; 153 bool mod = false; 154 bool compact; 155 u32 flags; 156 int ret; 157 158 ret = nlmsg_parse(info->nlhdr, GENL_HDRLEN, tb, 159 ETHTOOL_A_PRIVFLAGS_MAX, privflags_set_policy, 160 info->extack); 161 if (ret < 0) 162 return ret; 163 if (!tb[ETHTOOL_A_PRIVFLAGS_FLAGS]) 164 return -EINVAL; 165 ret = ethnl_bitset_is_compact(tb[ETHTOOL_A_PRIVFLAGS_FLAGS], &compact); 166 if (ret < 0) 167 return ret; 168 ret = ethnl_parse_header_dev_get(&req_info, 169 tb[ETHTOOL_A_PRIVFLAGS_HEADER], 170 genl_info_net(info), info->extack, 171 true); 172 if (ret < 0) 173 return ret; 174 dev = req_info.dev; 175 ops = dev->ethtool_ops; 176 ret = -EOPNOTSUPP; 177 if (!ops->get_priv_flags || !ops->set_priv_flags || 178 !ops->get_sset_count || !ops->get_strings) 179 goto out_dev; 180 181 rtnl_lock(); 182 ret = ethnl_ops_begin(dev); 183 if (ret < 0) 184 goto out_rtnl; 185 ret = ethnl_get_priv_flags_info(dev, &nflags, compact ? NULL : &names); 186 if (ret < 0) 187 goto out_ops; 188 flags = ops->get_priv_flags(dev); 189 190 ret = ethnl_update_bitset32(&flags, nflags, 191 tb[ETHTOOL_A_PRIVFLAGS_FLAGS], names, 192 info->extack, &mod); 193 if (ret < 0 || !mod) 194 goto out_free; 195 ret = ops->set_priv_flags(dev, flags); 196 if (ret < 0) 197 goto out_free; 198 ethtool_notify(dev, ETHTOOL_MSG_PRIVFLAGS_NTF, NULL); 199 200 out_free: 201 kfree(names); 202 out_ops: 203 ethnl_ops_complete(dev); 204 out_rtnl: 205 rtnl_unlock(); 206 out_dev: 207 dev_put(dev); 208 return ret; 209 } 210