2 * Copyright Samuel Mendoza-Jonas, IBM Corporation 2018.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/if_arp.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/etherdevice.h>
15 #include <linux/module.h>
16 #include <net/genetlink.h>
18 #include <linux/skbuff.h>
20 #include <uapi/linux/ncsi.h>
23 #include "ncsi-netlink.h"
25 static struct genl_family ncsi_genl_family;
27 static const struct nla_policy ncsi_genl_policy[NCSI_ATTR_MAX + 1] = {
28 [NCSI_ATTR_IFINDEX] = { .type = NLA_U32 },
29 [NCSI_ATTR_PACKAGE_LIST] = { .type = NLA_NESTED },
30 [NCSI_ATTR_PACKAGE_ID] = { .type = NLA_U32 },
31 [NCSI_ATTR_CHANNEL_ID] = { .type = NLA_U32 },
34 static struct ncsi_dev_priv *ndp_from_ifindex(struct net *net, u32 ifindex)
36 struct ncsi_dev_priv *ndp;
37 struct net_device *dev;
44 dev = dev_get_by_index(net, ifindex);
46 pr_err("NCSI netlink: No device for ifindex %u\n", ifindex);
50 nd = ncsi_find_dev(dev);
51 ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
57 static int ncsi_write_channel_info(struct sk_buff *skb,
58 struct ncsi_dev_priv *ndp,
59 struct ncsi_channel *nc)
61 struct ncsi_channel_vlan_filter *ncf;
62 struct ncsi_channel_mode *m;
63 struct nlattr *vid_nest;
66 nla_put_u32(skb, NCSI_CHANNEL_ATTR_ID, nc->id);
67 m = &nc->modes[NCSI_MODE_LINK];
68 nla_put_u32(skb, NCSI_CHANNEL_ATTR_LINK_STATE, m->data[2]);
69 if (nc->state == NCSI_CHANNEL_ACTIVE)
70 nla_put_flag(skb, NCSI_CHANNEL_ATTR_ACTIVE);
71 if (ndp->force_channel == nc)
72 nla_put_flag(skb, NCSI_CHANNEL_ATTR_FORCED);
74 nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MAJOR, nc->version.version);
75 nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MINOR, nc->version.alpha2);
76 nla_put_string(skb, NCSI_CHANNEL_ATTR_VERSION_STR, nc->version.fw_name);
78 vid_nest = nla_nest_start(skb, NCSI_CHANNEL_ATTR_VLAN_LIST);
81 ncf = &nc->vlan_filter;
83 while ((i = find_next_bit((void *)&ncf->bitmap, ncf->n_vids,
84 i + 1)) < ncf->n_vids) {
86 nla_put_u16(skb, NCSI_CHANNEL_ATTR_VLAN_ID,
89 nla_nest_end(skb, vid_nest);
94 static int ncsi_write_package_info(struct sk_buff *skb,
95 struct ncsi_dev_priv *ndp, unsigned int id)
97 struct nlattr *pnest, *cnest, *nest;
98 struct ncsi_package *np;
99 struct ncsi_channel *nc;
103 if (id > ndp->package_num) {
104 netdev_info(ndp->ndev.dev, "NCSI: No package with id %u\n", id);
109 NCSI_FOR_EACH_PACKAGE(ndp, np) {
112 pnest = nla_nest_start(skb, NCSI_PKG_ATTR);
115 nla_put_u32(skb, NCSI_PKG_ATTR_ID, np->id);
116 if (ndp->force_package == np)
117 nla_put_flag(skb, NCSI_PKG_ATTR_FORCED);
118 cnest = nla_nest_start(skb, NCSI_PKG_ATTR_CHANNEL_LIST);
120 nla_nest_cancel(skb, pnest);
123 NCSI_FOR_EACH_CHANNEL(np, nc) {
124 nest = nla_nest_start(skb, NCSI_CHANNEL_ATTR);
126 nla_nest_cancel(skb, cnest);
127 nla_nest_cancel(skb, pnest);
130 rc = ncsi_write_channel_info(skb, ndp, nc);
132 nla_nest_cancel(skb, nest);
133 nla_nest_cancel(skb, cnest);
134 nla_nest_cancel(skb, pnest);
137 nla_nest_end(skb, nest);
139 nla_nest_end(skb, cnest);
140 nla_nest_end(skb, pnest);
150 static int ncsi_pkg_info_nl(struct sk_buff *msg, struct genl_info *info)
152 struct ncsi_dev_priv *ndp;
153 unsigned int package_id;
159 if (!info || !info->attrs)
162 if (!info->attrs[NCSI_ATTR_IFINDEX])
165 if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
168 ndp = ndp_from_ifindex(genl_info_net(info),
169 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
173 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
177 hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
178 &ncsi_genl_family, 0, NCSI_CMD_PKG_INFO);
184 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
186 attr = nla_nest_start(skb, NCSI_ATTR_PACKAGE_LIST);
187 rc = ncsi_write_package_info(skb, ndp, package_id);
190 nla_nest_cancel(skb, attr);
194 nla_nest_end(skb, attr);
196 genlmsg_end(skb, hdr);
197 return genlmsg_reply(skb, info);
200 genlmsg_cancel(skb, hdr);
205 static int ncsi_pkg_info_all_nl(struct sk_buff *skb,
206 struct netlink_callback *cb)
208 struct nlattr *attrs[NCSI_ATTR_MAX];
209 struct ncsi_package *np, *package;
210 struct ncsi_dev_priv *ndp;
211 unsigned int package_id;
216 rc = genlmsg_parse(cb->nlh, &ncsi_genl_family, attrs, NCSI_ATTR_MAX,
217 ncsi_genl_policy, NULL);
221 if (!attrs[NCSI_ATTR_IFINDEX])
224 ndp = ndp_from_ifindex(get_net(sock_net(skb->sk)),
225 nla_get_u32(attrs[NCSI_ATTR_IFINDEX]));
230 package_id = cb->args[0];
232 NCSI_FOR_EACH_PACKAGE(ndp, np)
233 if (np->id == package_id)
239 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
240 &ncsi_genl_family, 0, NCSI_CMD_PKG_INFO);
246 attr = nla_nest_start(skb, NCSI_ATTR_PACKAGE_LIST);
247 rc = ncsi_write_package_info(skb, ndp, package->id);
249 nla_nest_cancel(skb, attr);
253 nla_nest_end(skb, attr);
254 genlmsg_end(skb, hdr);
256 cb->args[0] = package_id + 1;
260 genlmsg_cancel(skb, hdr);
264 static int ncsi_set_interface_nl(struct sk_buff *msg, struct genl_info *info)
266 struct ncsi_package *np, *package;
267 struct ncsi_channel *nc, *channel;
268 u32 package_id, channel_id;
269 struct ncsi_dev_priv *ndp;
272 if (!info || !info->attrs)
275 if (!info->attrs[NCSI_ATTR_IFINDEX])
278 if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
281 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
282 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
286 package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
289 spin_lock_irqsave(&ndp->lock, flags);
291 NCSI_FOR_EACH_PACKAGE(ndp, np)
292 if (np->id == package_id)
295 /* The user has set a package that does not exist */
300 if (!info->attrs[NCSI_ATTR_CHANNEL_ID]) {
301 /* Allow any channel */
302 channel_id = NCSI_RESERVED_CHANNEL;
304 channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
305 NCSI_FOR_EACH_CHANNEL(package, nc)
306 if (nc->id == channel_id)
310 if (channel_id != NCSI_RESERVED_CHANNEL && !channel) {
311 /* The user has set a channel that does not exist on this
314 netdev_info(ndp->ndev.dev, "NCSI: Channel %u does not exist!\n",
319 ndp->force_package = package;
320 ndp->force_channel = channel;
321 spin_unlock_irqrestore(&ndp->lock, flags);
323 netdev_info(ndp->ndev.dev, "Set package 0x%x, channel 0x%x%s as preferred\n",
324 package_id, channel_id,
325 channel_id == NCSI_RESERVED_CHANNEL ? " (any)" : "");
327 /* Bounce the NCSI channel to set changes */
328 ncsi_stop_dev(&ndp->ndev);
329 ncsi_start_dev(&ndp->ndev);
334 static int ncsi_clear_interface_nl(struct sk_buff *msg, struct genl_info *info)
336 struct ncsi_dev_priv *ndp;
339 if (!info || !info->attrs)
342 if (!info->attrs[NCSI_ATTR_IFINDEX])
345 ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
346 nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
350 /* Clear any override */
351 spin_lock_irqsave(&ndp->lock, flags);
352 ndp->force_package = NULL;
353 ndp->force_channel = NULL;
354 spin_unlock_irqrestore(&ndp->lock, flags);
355 netdev_info(ndp->ndev.dev, "NCSI: Cleared preferred package/channel\n");
357 /* Bounce the NCSI channel to set changes */
358 ncsi_stop_dev(&ndp->ndev);
359 ncsi_start_dev(&ndp->ndev);
364 static const struct genl_ops ncsi_ops[] = {
366 .cmd = NCSI_CMD_PKG_INFO,
367 .policy = ncsi_genl_policy,
368 .doit = ncsi_pkg_info_nl,
369 .dumpit = ncsi_pkg_info_all_nl,
373 .cmd = NCSI_CMD_SET_INTERFACE,
374 .policy = ncsi_genl_policy,
375 .doit = ncsi_set_interface_nl,
376 .flags = GENL_ADMIN_PERM,
379 .cmd = NCSI_CMD_CLEAR_INTERFACE,
380 .policy = ncsi_genl_policy,
381 .doit = ncsi_clear_interface_nl,
382 .flags = GENL_ADMIN_PERM,
386 static struct genl_family ncsi_genl_family __ro_after_init = {
389 .maxattr = NCSI_ATTR_MAX,
390 .module = THIS_MODULE,
392 .n_ops = ARRAY_SIZE(ncsi_ops),
395 int ncsi_init_netlink(struct net_device *dev)
399 rc = genl_register_family(&ncsi_genl_family);
401 netdev_err(dev, "ncsi: failed to register netlink family\n");
406 int ncsi_unregister_netlink(struct net_device *dev)
410 rc = genl_unregister_family(&ncsi_genl_family);
412 netdev_err(dev, "ncsi: failed to unregister netlink family\n");