[linux-block.git] / net / ethtool / features.c

// SPDX-License-Identifier: GPL-2.0-only

#include "netlink.h"
#include "common.h"
#include "bitset.h"

struct features_req_info {
	struct ethnl_req_info	base;
};

struct features_reply_data {
	struct ethnl_reply_data	base;
	u32			hw[ETHTOOL_DEV_FEATURE_WORDS];
	u32			wanted[ETHTOOL_DEV_FEATURE_WORDS];
	u32			active[ETHTOOL_DEV_FEATURE_WORDS];
	u32			nochange[ETHTOOL_DEV_FEATURE_WORDS];
	u32			all[ETHTOOL_DEV_FEATURE_WORDS];
};

#define FEATURES_REPDATA(__reply_base) \
	container_of(__reply_base, struct features_reply_data, base)

const struct nla_policy ethnl_features_get_policy[] = {
	[ETHTOOL_A_FEATURES_HEADER]	=
		NLA_POLICY_NESTED(ethnl_header_policy),
};

static void ethnl_features_to_bitmap32(u32 *dest, netdev_features_t src)
{
	unsigned int i;

	for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; i++)
		dest[i] = src >> (32 * i);
}

static int features_prepare_data(const struct ethnl_req_info *req_base,
				 struct ethnl_reply_data *reply_base,
				 struct genl_info *info)
{
	struct features_reply_data *data = FEATURES_REPDATA(reply_base);
	struct net_device *dev = reply_base->dev;
	netdev_features_t all_features;

	ethnl_features_to_bitmap32(data->hw, dev->hw_features);
	ethnl_features_to_bitmap32(data->wanted, dev->wanted_features);
	ethnl_features_to_bitmap32(data->active, dev->features);
	ethnl_features_to_bitmap32(data->nochange, NETIF_F_NEVER_CHANGE);
	all_features = GENMASK_ULL(NETDEV_FEATURE_COUNT - 1, 0);
	ethnl_features_to_bitmap32(data->all, all_features);

	return 0;
}

static int features_reply_size(const struct ethnl_req_info *req_base,
			       const struct ethnl_reply_data *reply_base)
{
	const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
	bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
	unsigned int len = 0;
	int ret;

	ret = ethnl_bitset32_size(data->hw, data->all, NETDEV_FEATURE_COUNT,
				  netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	len += ret;
	ret = ethnl_bitset32_size(data->wanted, NULL, NETDEV_FEATURE_COUNT,
				  netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	len += ret;
	ret = ethnl_bitset32_size(data->active, NULL, NETDEV_FEATURE_COUNT,
				  netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	len += ret;
	ret = ethnl_bitset32_size(data->nochange, NULL, NETDEV_FEATURE_COUNT,
				  netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	len += ret;

	return len;
}

static int features_fill_reply(struct sk_buff *skb,
			       const struct ethnl_req_info *req_base,
			       const struct ethnl_reply_data *reply_base)
{
	const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
	bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
	int ret;

	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_HW, data->hw,
				 data->all, NETDEV_FEATURE_COUNT,
				 netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_WANTED, data->wanted,
				 NULL, NETDEV_FEATURE_COUNT,
				 netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_ACTIVE, data->active,
				 NULL, NETDEV_FEATURE_COUNT,
				 netdev_features_strings, compact);
	if (ret < 0)
		return ret;
	return ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_NOCHANGE,
				  data->nochange, NULL, NETDEV_FEATURE_COUNT,
				  netdev_features_strings, compact);
}

const struct ethnl_request_ops ethnl_features_request_ops = {
	.request_cmd		= ETHTOOL_MSG_FEATURES_GET,
	.reply_cmd		= ETHTOOL_MSG_FEATURES_GET_REPLY,
	.hdr_attr		= ETHTOOL_A_FEATURES_HEADER,
	.req_info_size		= sizeof(struct features_req_info),
	.reply_data_size	= sizeof(struct features_reply_data),

	.prepare_data		= features_prepare_data,
	.reply_size		= features_reply_size,
	.fill_reply		= features_fill_reply,
};

/* FEATURES_SET */

const struct nla_policy ethnl_features_set_policy[] = {
	[ETHTOOL_A_FEATURES_HEADER]	=
		NLA_POLICY_NESTED(ethnl_header_policy),
	[ETHTOOL_A_FEATURES_WANTED]	= { .type = NLA_NESTED },
};

static void ethnl_features_to_bitmap(unsigned long *dest, netdev_features_t val)
{
	const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
	unsigned int i;

	for (i = 0; i < words; i++)
		dest[i] = (unsigned long)(val >> (i * BITS_PER_LONG));
}

static netdev_features_t ethnl_bitmap_to_features(unsigned long *src)
{
	const unsigned int nft_bits = sizeof(netdev_features_t) * BITS_PER_BYTE;
	const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
	netdev_features_t ret = 0;
	unsigned int i;

	for (i = 0; i < words; i++)
		ret |= (netdev_features_t)(src[i]) << (i * BITS_PER_LONG);
	ret &= ~(netdev_features_t)0 >> (nft_bits - NETDEV_FEATURE_COUNT);
	return ret;
}

static int features_send_reply(struct net_device *dev, struct genl_info *info,
			       const unsigned long *wanted,
			       const unsigned long *wanted_mask,
			       const unsigned long *active,
			       const unsigned long *active_mask, bool compact)
{
	struct sk_buff *rskb;
	void *reply_payload;
	int reply_len = 0;
	int ret;

	reply_len = ethnl_reply_header_size();
	ret = ethnl_bitset_size(wanted, wanted_mask, NETDEV_FEATURE_COUNT,
				netdev_features_strings, compact);
	if (ret < 0)
		goto err;
	reply_len += ret;
	ret = ethnl_bitset_size(active, active_mask, NETDEV_FEATURE_COUNT,
				netdev_features_strings, compact);
	if (ret < 0)
		goto err;
	reply_len += ret;

	ret = -ENOMEM;
	rskb = ethnl_reply_init(reply_len, dev, ETHTOOL_MSG_FEATURES_SET_REPLY,
				ETHTOOL_A_FEATURES_HEADER, info,
				&reply_payload);
	if (!rskb)
		goto err;

	ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_WANTED, wanted,
			       wanted_mask, NETDEV_FEATURE_COUNT,
			       netdev_features_strings, compact);
	if (ret < 0)
		goto nla_put_failure;
	ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_ACTIVE, active,
			       active_mask, NETDEV_FEATURE_COUNT,
			       netdev_features_strings, compact);
	if (ret < 0)
		goto nla_put_failure;

	genlmsg_end(rskb, reply_payload);
	ret = genlmsg_reply(rskb, info);
	return ret;

nla_put_failure:
	nlmsg_free(rskb);
	WARN_ONCE(1, "calculated message payload length (%d) not sufficient\n",
		  reply_len);
err:
	GENL_SET_ERR_MSG(info, "failed to send reply message");
	return ret;
}

int ethnl_set_features(struct sk_buff *skb, struct genl_info *info)
{
	DECLARE_BITMAP(wanted_diff_mask, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(active_diff_mask, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(old_active, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(old_wanted, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(new_active, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(new_wanted, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(req_wanted, NETDEV_FEATURE_COUNT);
	DECLARE_BITMAP(req_mask, NETDEV_FEATURE_COUNT);
	struct ethnl_req_info req_info = {};
	struct nlattr **tb = info->attrs;
	struct net_device *dev;
	bool mod;
	int ret;

	if (!tb[ETHTOOL_A_FEATURES_WANTED])
		return -EINVAL;
	ret = ethnl_parse_header_dev_get(&req_info,
					 tb[ETHTOOL_A_FEATURES_HEADER],
					 genl_info_net(info), info->extack,
					 true);
	if (ret < 0)
		return ret;
	dev = req_info.dev;

	rtnl_lock();
	ethnl_features_to_bitmap(old_active, dev->features);
	ethnl_features_to_bitmap(old_wanted, dev->wanted_features);
	ret = ethnl_parse_bitset(req_wanted, req_mask, NETDEV_FEATURE_COUNT,
				 tb[ETHTOOL_A_FEATURES_WANTED],
				 netdev_features_strings, info->extack);
	if (ret < 0)
		goto out_rtnl;
	if (ethnl_bitmap_to_features(req_mask) & ~NETIF_F_ETHTOOL_BITS) {
		GENL_SET_ERR_MSG(info, "attempt to change non-ethtool features");
		ret = -EINVAL;
		goto out_rtnl;
	}

	/* set req_wanted bits not in req_mask from old_wanted */
	bitmap_and(req_wanted, req_wanted, req_mask, NETDEV_FEATURE_COUNT);
	bitmap_andnot(new_wanted, old_wanted, req_mask, NETDEV_FEATURE_COUNT);
	bitmap_or(req_wanted, new_wanted, req_wanted, NETDEV_FEATURE_COUNT);
	if (!bitmap_equal(req_wanted, old_wanted, NETDEV_FEATURE_COUNT)) {
		dev->wanted_features &= ~dev->hw_features;
		dev->wanted_features |= ethnl_bitmap_to_features(req_wanted) & dev->hw_features;
		__netdev_update_features(dev);
	}
	ethnl_features_to_bitmap(new_active, dev->features);
	mod = !bitmap_equal(old_active, new_active, NETDEV_FEATURE_COUNT);

	ret = 0;
	if (!(req_info.flags & ETHTOOL_FLAG_OMIT_REPLY)) {
		bool compact = req_info.flags & ETHTOOL_FLAG_COMPACT_BITSETS;

		bitmap_xor(wanted_diff_mask, req_wanted, new_active,
			   NETDEV_FEATURE_COUNT);
		bitmap_xor(active_diff_mask, old_active, new_active,
			   NETDEV_FEATURE_COUNT);
		bitmap_and(wanted_diff_mask, wanted_diff_mask, req_mask,
			   NETDEV_FEATURE_COUNT);
		bitmap_and(req_wanted, req_wanted, wanted_diff_mask,
			   NETDEV_FEATURE_COUNT);
		bitmap_and(new_active, new_active, active_diff_mask,
			   NETDEV_FEATURE_COUNT);

		ret = features_send_reply(dev, info, req_wanted,
					  wanted_diff_mask, new_active,
					  active_diff_mask, compact);
	}
	if (mod)
		netdev_features_change(dev);

out_rtnl:
	rtnl_unlock();
	ethnl_parse_header_dev_put(&req_info);
	return ret;
}
Commit	Line	Data
0524399d MK	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include "netlink.h"
	4	#include "common.h"
	5	#include "bitset.h"
	6
	7	struct features_req_info {
	8	struct ethnl_req_info base;
	9	};
	10
	11	struct features_reply_data {
	12	struct ethnl_reply_data base;
	13	u32 hw[ETHTOOL_DEV_FEATURE_WORDS];
	14	u32 wanted[ETHTOOL_DEV_FEATURE_WORDS];
	15	u32 active[ETHTOOL_DEV_FEATURE_WORDS];
	16	u32 nochange[ETHTOOL_DEV_FEATURE_WORDS];
	17	u32 all[ETHTOOL_DEV_FEATURE_WORDS];
	18	};
	19
	20	#define FEATURES_REPDATA(__reply_base) \
	21	container_of(__reply_base, struct features_reply_data, base)
	22
ff419afa	23	const struct nla_policy ethnl_features_get_policy[] = {
329d9c33 JK	24	[ETHTOOL_A_FEATURES_HEADER] =
329d9c33 JK	25	NLA_POLICY_NESTED(ethnl_header_policy),
0524399d MK	26	};
	27
	28	static void ethnl_features_to_bitmap32(u32 *dest, netdev_features_t src)
	29	{
	30	unsigned int i;
	31
	32	for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; i++)
	33	dest[i] = src >> (32 * i);
	34	}
	35
	36	static int features_prepare_data(const struct ethnl_req_info *req_base,
	37	struct ethnl_reply_data *reply_base,
	38	struct genl_info *info)
	39	{
	40	struct features_reply_data *data = FEATURES_REPDATA(reply_base);
	41	struct net_device *dev = reply_base->dev;
	42	netdev_features_t all_features;
	43
	44	ethnl_features_to_bitmap32(data->hw, dev->hw_features);
	45	ethnl_features_to_bitmap32(data->wanted, dev->wanted_features);
	46	ethnl_features_to_bitmap32(data->active, dev->features);
	47	ethnl_features_to_bitmap32(data->nochange, NETIF_F_NEVER_CHANGE);
	48	all_features = GENMASK_ULL(NETDEV_FEATURE_COUNT - 1, 0);
	49	ethnl_features_to_bitmap32(data->all, all_features);
	50
	51	return 0;
	52	}
	53
	54	static int features_reply_size(const struct ethnl_req_info *req_base,
	55	const struct ethnl_reply_data *reply_base)
	56	{
	57	const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
	58	bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
	59	unsigned int len = 0;
	60	int ret;
	61
	62	ret = ethnl_bitset32_size(data->hw, data->all, NETDEV_FEATURE_COUNT,
	63	netdev_features_strings, compact);
	64	if (ret < 0)
	65	return ret;
	66	len += ret;
	67	ret = ethnl_bitset32_size(data->wanted, NULL, NETDEV_FEATURE_COUNT,
	68	netdev_features_strings, compact);
	69	if (ret < 0)
	70	return ret;
	71	len += ret;
	72	ret = ethnl_bitset32_size(data->active, NULL, NETDEV_FEATURE_COUNT,
	73	netdev_features_strings, compact);
	74	if (ret < 0)
	75	return ret;
	76	len += ret;
	77	ret = ethnl_bitset32_size(data->nochange, NULL, NETDEV_FEATURE_COUNT,
	78	netdev_features_strings, compact);
	79	if (ret < 0)
	80	return ret;
	81	len += ret;
	82
	83	return len;
	84	}
	85
	86	static int features_fill_reply(struct sk_buff *skb,
	87	const struct ethnl_req_info *req_base,
	88	const struct ethnl_reply_data *reply_base)
	89	{
90	const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
91	bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
92	int ret;
93
94	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_HW, data->hw,
95	data->all, NETDEV_FEATURE_COUNT,
96	netdev_features_strings, compact);
97	if (ret < 0)
98	return ret;
99	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_WANTED, data->wanted,
100	NULL, NETDEV_FEATURE_COUNT,
101	netdev_features_strings, compact);
102	if (ret < 0)
103	return ret;
104	ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_ACTIVE, data->active,
105	NULL, NETDEV_FEATURE_COUNT,
106	netdev_features_strings, compact);
107	if (ret < 0)
108	return ret;
109	return ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_NOCHANGE,
110	data->nochange, NULL, NETDEV_FEATURE_COUNT,
111	netdev_features_strings, compact);
112	}
113
114	const struct ethnl_request_ops ethnl_features_request_ops = {
115	.request_cmd = ETHTOOL_MSG_FEATURES_GET,
116	.reply_cmd = ETHTOOL_MSG_FEATURES_GET_REPLY,
117	.hdr_attr = ETHTOOL_A_FEATURES_HEADER,
0524399d MK	118	.req_info_size = sizeof(struct features_req_info),
0524399d MK	119	.reply_data_size = sizeof(struct features_reply_data),
0524399d MK	120
	121	.prepare_data = features_prepare_data,
	122	.reply_size = features_reply_size,
	123	.fill_reply = features_fill_reply,
	124	};
0980bfcd MK	125
	126	/* FEATURES_SET */
	127
ff419afa	128	const struct nla_policy ethnl_features_set_policy[] = {
329d9c33 JK	129	[ETHTOOL_A_FEATURES_HEADER] =
329d9c33 JK	130	NLA_POLICY_NESTED(ethnl_header_policy),
0980bfcd	131	[ETHTOOL_A_FEATURES_WANTED] = { .type = NLA_NESTED },
0980bfcd MK	132	};
	133
	134	static void ethnl_features_to_bitmap(unsigned long *dest, netdev_features_t val)
	135	{
	136	const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
	137	unsigned int i;
	138
0980bfcd MK	139	for (i = 0; i < words; i++)
	140	dest[i] = (unsigned long)(val >> (i * BITS_PER_LONG));
	141	}
	142
	143	static netdev_features_t ethnl_bitmap_to_features(unsigned long *src)
	144	{
	145	const unsigned int nft_bits = sizeof(netdev_features_t) * BITS_PER_BYTE;
	146	const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
	147	netdev_features_t ret = 0;
	148	unsigned int i;
	149
	150	for (i = 0; i < words; i++)
	151	ret \|= (netdev_features_t)(src[i]) << (i * BITS_PER_LONG);
	152	ret &= ~(netdev_features_t)0 >> (nft_bits - NETDEV_FEATURE_COUNT);
	153	return ret;
	154	}
	155
	156	static int features_send_reply(struct net_device dev, struct genl_info info,
	157	const unsigned long *wanted,
	158	const unsigned long *wanted_mask,
	159	const unsigned long *active,
	160	const unsigned long *active_mask, bool compact)
	161	{
	162	struct sk_buff *rskb;
	163	void *reply_payload;
	164	int reply_len = 0;
	165	int ret;
	166
	167	reply_len = ethnl_reply_header_size();
	168	ret = ethnl_bitset_size(wanted, wanted_mask, NETDEV_FEATURE_COUNT,
	169	netdev_features_strings, compact);
	170	if (ret < 0)
	171	goto err;
	172	reply_len += ret;
	173	ret = ethnl_bitset_size(active, active_mask, NETDEV_FEATURE_COUNT,
	174	netdev_features_strings, compact);
	175	if (ret < 0)
	176	goto err;
	177	reply_len += ret;
	178
	179	ret = -ENOMEM;
	180	rskb = ethnl_reply_init(reply_len, dev, ETHTOOL_MSG_FEATURES_SET_REPLY,
	181	ETHTOOL_A_FEATURES_HEADER, info,
	182	&reply_payload);
	183	if (!rskb)
	184	goto err;
	185
	186	ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_WANTED, wanted,
	187	wanted_mask, NETDEV_FEATURE_COUNT,
	188	netdev_features_strings, compact);
	189	if (ret < 0)
	190	goto nla_put_failure;
	191	ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_ACTIVE, active,
	192	active_mask, NETDEV_FEATURE_COUNT,
	193	netdev_features_strings, compact);
	194	if (ret < 0)
	195	goto nla_put_failure;
	196
	197	genlmsg_end(rskb, reply_payload);
	198	ret = genlmsg_reply(rskb, info);
	199	return ret;
	200
	201	nla_put_failure:
	202	nlmsg_free(rskb);
203	WARN_ONCE(1, "calculated message payload length (%d) not sufficient\n",
204	reply_len);
205	err:
206	GENL_SET_ERR_MSG(info, "failed to send reply message");
207	return ret;
208	}
209
210	int ethnl_set_features(struct sk_buff skb, struct genl_info info)
211	{
212	DECLARE_BITMAP(wanted_diff_mask, NETDEV_FEATURE_COUNT);
213	DECLARE_BITMAP(active_diff_mask, NETDEV_FEATURE_COUNT);
214	DECLARE_BITMAP(old_active, NETDEV_FEATURE_COUNT);
840110a4	215	DECLARE_BITMAP(old_wanted, NETDEV_FEATURE_COUNT);
0980bfcd	216	DECLARE_BITMAP(new_active, NETDEV_FEATURE_COUNT);
840110a4	217	DECLARE_BITMAP(new_wanted, NETDEV_FEATURE_COUNT);
0980bfcd MK	218	DECLARE_BITMAP(req_wanted, NETDEV_FEATURE_COUNT);
0980bfcd MK	219	DECLARE_BITMAP(req_mask, NETDEV_FEATURE_COUNT);
0980bfcd	220	struct ethnl_req_info req_info = {};
5028588b	221	struct nlattr **tb = info->attrs;
0980bfcd	222	struct net_device *dev;
9c6451ef	223	bool mod;
0980bfcd MK	224	int ret;
0980bfcd MK	225
0980bfcd MK	226	if (!tb[ETHTOOL_A_FEATURES_WANTED])
	227	return -EINVAL;
	228	ret = ethnl_parse_header_dev_get(&req_info,
	229	tb[ETHTOOL_A_FEATURES_HEADER],
	230	genl_info_net(info), info->extack,
	231	true);
	232	if (ret < 0)
	233	return ret;
	234	dev = req_info.dev;
	235
	236	rtnl_lock();
	237	ethnl_features_to_bitmap(old_active, dev->features);
840110a4	238	ethnl_features_to_bitmap(old_wanted, dev->wanted_features);
0980bfcd MK	239	ret = ethnl_parse_bitset(req_wanted, req_mask, NETDEV_FEATURE_COUNT,
	240	tb[ETHTOOL_A_FEATURES_WANTED],
	241	netdev_features_strings, info->extack);
	242	if (ret < 0)
	243	goto out_rtnl;
	244	if (ethnl_bitmap_to_features(req_mask) & ~NETIF_F_ETHTOOL_BITS) {
	245	GENL_SET_ERR_MSG(info, "attempt to change non-ethtool features");
	246	ret = -EINVAL;
	247	goto out_rtnl;
	248	}
	249
840110a4	250	/* set req_wanted bits not in req_mask from old_wanted */
0980bfcd	251	bitmap_and(req_wanted, req_wanted, req_mask, NETDEV_FEATURE_COUNT);
840110a4 MM	252	bitmap_andnot(new_wanted, old_wanted, req_mask, NETDEV_FEATURE_COUNT);
840110a4 MM	253	bitmap_or(req_wanted, new_wanted, req_wanted, NETDEV_FEATURE_COUNT);
f01204ec MM	254	if (!bitmap_equal(req_wanted, old_wanted, NETDEV_FEATURE_COUNT)) {
	255	dev->wanted_features &= ~dev->hw_features;
	256	dev->wanted_features \|= ethnl_bitmap_to_features(req_wanted) & dev->hw_features;
	257	__netdev_update_features(dev);
0980bfcd	258	}
0980bfcd	259	ethnl_features_to_bitmap(new_active, dev->features);
9c6451ef	260	mod = !bitmap_equal(old_active, new_active, NETDEV_FEATURE_COUNT);
0980bfcd MK	261
	262	ret = 0;
	263	if (!(req_info.flags & ETHTOOL_FLAG_OMIT_REPLY)) {
	264	bool compact = req_info.flags & ETHTOOL_FLAG_COMPACT_BITSETS;
	265
	266	bitmap_xor(wanted_diff_mask, req_wanted, new_active,
	267	NETDEV_FEATURE_COUNT);
	268	bitmap_xor(active_diff_mask, old_active, new_active,
	269	NETDEV_FEATURE_COUNT);
	270	bitmap_and(wanted_diff_mask, wanted_diff_mask, req_mask,
	271	NETDEV_FEATURE_COUNT);
	272	bitmap_and(req_wanted, req_wanted, wanted_diff_mask,
	273	NETDEV_FEATURE_COUNT);
	274	bitmap_and(new_active, new_active, active_diff_mask,
	275	NETDEV_FEATURE_COUNT);
	276
	277	ret = features_send_reply(dev, info, req_wanted,
	278	wanted_diff_mask, new_active,
	279	active_diff_mask, compact);
	280	}
9c6451ef	281	if (mod)
41369138	282	netdev_features_change(dev);
0980bfcd MK	283
	284	out_rtnl:
	285	rtnl_unlock();
34ac17ec	286	ethnl_parse_header_dev_put(&req_info);
0980bfcd MK	287	return ret;
0980bfcd MK	288	}