Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 */
6
7#include <net/genetlink.h>
8#include <net/sock.h>
9
10#include "devl_internal.h"
11
12#define DEVLINK_NL_FLAG_NEED_PORT BIT(0)
13#define DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT BIT(1)
14#define DEVLINK_NL_FLAG_NEED_DEV_LOCK BIT(2)
15
16static const struct genl_multicast_group devlink_nl_mcgrps[] = {
17 [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
18};
19
20struct devlink_nl_sock_priv {
21 struct devlink_obj_desc __rcu *flt;
22 spinlock_t flt_lock; /* Protects flt. */
23};
24
25static void devlink_nl_sock_priv_init(void *priv)
26{
27 struct devlink_nl_sock_priv *sk_priv = priv;
28
29 spin_lock_init(&sk_priv->flt_lock);
30}
31
32static void devlink_nl_sock_priv_destroy(void *priv)
33{
34 struct devlink_nl_sock_priv *sk_priv = priv;
35 struct devlink_obj_desc *flt;
36
37 flt = rcu_dereference_protected(sk_priv->flt, true);
38 kfree_rcu(flt, rcu);
39}
40
41int devlink_nl_notify_filter_set_doit(struct sk_buff *skb,
42 struct genl_info *info)
43{
44 struct devlink_nl_sock_priv *sk_priv;
45 struct nlattr **attrs = info->attrs;
46 struct devlink_obj_desc *flt;
47 size_t data_offset = 0;
48 size_t data_size = 0;
49 char *pos;
50
51 if (attrs[DEVLINK_ATTR_BUS_NAME])
52 data_size = size_add(data_size,
53 nla_len(attrs[DEVLINK_ATTR_BUS_NAME]) + 1);
54 if (attrs[DEVLINK_ATTR_DEV_NAME])
55 data_size = size_add(data_size,
56 nla_len(attrs[DEVLINK_ATTR_DEV_NAME]) + 1);
57
58 flt = kzalloc(size_add(sizeof(*flt), data_size), GFP_KERNEL);
59 if (!flt)
60 return -ENOMEM;
61
62 pos = (char *) flt->data;
63 if (attrs[DEVLINK_ATTR_BUS_NAME]) {
64 data_offset += nla_strscpy(pos,
65 attrs[DEVLINK_ATTR_BUS_NAME],
66 data_size) + 1;
67 flt->bus_name = pos;
68 pos += data_offset;
69 }
70 if (attrs[DEVLINK_ATTR_DEV_NAME]) {
71 nla_strscpy(pos, attrs[DEVLINK_ATTR_DEV_NAME],
72 data_size - data_offset);
73 flt->dev_name = pos;
74 }
75
76 if (attrs[DEVLINK_ATTR_INDEX]) {
77 flt->devlink_index = nla_get_uint(attrs[DEVLINK_ATTR_INDEX]);
78 flt->devlink_index_valid = true;
79 }
80
81 if (attrs[DEVLINK_ATTR_PORT_INDEX]) {
82 flt->port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
83 flt->port_index_valid = true;
84 }
85
86 /* Don't attach empty filter. */
87 if (!flt->bus_name && !flt->dev_name &&
88 !flt->devlink_index_valid && !flt->port_index_valid) {
89 kfree(flt);
90 flt = NULL;
91 }
92
93 sk_priv = genl_sk_priv_get(&devlink_nl_family, NETLINK_CB(skb).sk);
94 if (IS_ERR(sk_priv)) {
95 kfree(flt);
96 return PTR_ERR(sk_priv);
97 }
98 spin_lock(&sk_priv->flt_lock);
99 flt = rcu_replace_pointer(sk_priv->flt, flt,
100 lockdep_is_held(&sk_priv->flt_lock));
101 spin_unlock(&sk_priv->flt_lock);
102 kfree_rcu(flt, rcu);
103 return 0;
104}
105
106static bool devlink_obj_desc_match(const struct devlink_obj_desc *desc,
107 const struct devlink_obj_desc *flt)
108{
109 if (desc->devlink_index_valid && flt->devlink_index_valid &&
110 desc->devlink_index != flt->devlink_index)
111 return false;
112 if (desc->bus_name && flt->bus_name &&
113 strcmp(desc->bus_name, flt->bus_name))
114 return false;
115 if (desc->dev_name && flt->dev_name &&
116 strcmp(desc->dev_name, flt->dev_name))
117 return false;
118 if (desc->port_index_valid && flt->port_index_valid &&
119 desc->port_index != flt->port_index)
120 return false;
121 return true;
122}
123
124int devlink_nl_notify_filter(struct sock *dsk, struct sk_buff *skb, void *data)
125{
126 struct devlink_obj_desc *desc = data;
127 struct devlink_nl_sock_priv *sk_priv;
128 struct devlink_obj_desc *flt;
129 int ret = 0;
130
131 rcu_read_lock();
132 sk_priv = __genl_sk_priv_get(&devlink_nl_family, dsk);
133 if (!IS_ERR_OR_NULL(sk_priv)) {
134 flt = rcu_dereference(sk_priv->flt);
135 if (flt)
136 ret = !devlink_obj_desc_match(desc, flt);
137 }
138 rcu_read_unlock();
139 return ret;
140}
141
142int devlink_nl_put_nested_handle(struct sk_buff *msg, struct net *net,
143 struct devlink *devlink, int attrtype)
144{
145 struct nlattr *nested_attr;
146 struct net *devl_net;
147
148 nested_attr = nla_nest_start(msg, attrtype);
149 if (!nested_attr)
150 return -EMSGSIZE;
151 if (devlink_nl_put_handle(msg, devlink))
152 goto nla_put_failure;
153
154 rcu_read_lock();
155 devl_net = read_pnet_rcu(&devlink->_net);
156 if (!net_eq(net, devl_net)) {
157 int id = peernet2id_alloc(net, devl_net, GFP_ATOMIC);
158
159 rcu_read_unlock();
160 if (nla_put_s32(msg, DEVLINK_ATTR_NETNS_ID, id))
161 return -EMSGSIZE;
162 } else {
163 rcu_read_unlock();
164 }
165
166 nla_nest_end(msg, nested_attr);
167 return 0;
168
169nla_put_failure:
170 nla_nest_cancel(msg, nested_attr);
171 return -EMSGSIZE;
172}
173
174int devlink_nl_msg_reply_and_new(struct sk_buff **msg, struct genl_info *info)
175{
176 int err;
177
178 if (*msg) {
179 err = genlmsg_reply(*msg, info);
180 if (err)
181 return err;
182 }
183 *msg = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
184 if (!*msg)
185 return -ENOMEM;
186 return 0;
187}
188
189struct devlink *
190devlink_get_from_attrs_lock(struct net *net, struct nlattr **attrs,
191 bool dev_lock)
192{
193 struct devlink *devlink;
194 unsigned long index;
195 char *busname;
196 char *devname;
197
198 if (attrs[DEVLINK_ATTR_INDEX]) {
199 if (attrs[DEVLINK_ATTR_BUS_NAME] ||
200 attrs[DEVLINK_ATTR_DEV_NAME])
201 return ERR_PTR(-EINVAL);
202 index = nla_get_u32(attrs[DEVLINK_ATTR_INDEX]);
203 devlink = devlinks_xa_lookup_get(net, index);
204 if (!devlink)
205 return ERR_PTR(-ENODEV);
206 goto found;
207 }
208
209 if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
210 return ERR_PTR(-EINVAL);
211
212 busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
213 devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
214
215 if (!strcmp(busname, DEVLINK_INDEX_BUS_NAME)) {
216 if (kstrtoul(devname, 10, &index))
217 return ERR_PTR(-ENODEV);
218 devlink = devlinks_xa_lookup_get(net, index);
219 if (!devlink)
220 return ERR_PTR(-ENODEV);
221 goto found;
222 }
223
224 devlinks_xa_for_each_registered_get(net, index, devlink) {
225 if (strcmp(devlink_bus_name(devlink), busname) == 0 &&
226 strcmp(devlink_dev_name(devlink), devname) == 0)
227 goto found;
228 devlink_put(devlink);
229 }
230
231 return ERR_PTR(-ENODEV);
232
233found:
234 devl_dev_lock(devlink, dev_lock);
235 if (devl_is_registered(devlink))
236 return devlink;
237 devl_dev_unlock(devlink, dev_lock);
238 devlink_put(devlink);
239 return ERR_PTR(-ENODEV);
240}
241
242static int __devlink_nl_pre_doit(struct sk_buff *skb, struct genl_info *info,
243 u8 flags)
244{
245 bool dev_lock = flags & DEVLINK_NL_FLAG_NEED_DEV_LOCK;
246 struct devlink_port *devlink_port;
247 struct devlink *devlink;
248 int err;
249
250 devlink = devlink_get_from_attrs_lock(genl_info_net(info), info->attrs,
251 dev_lock);
252 if (IS_ERR(devlink))
253 return PTR_ERR(devlink);
254
255 info->user_ptr[0] = devlink;
256 if (flags & DEVLINK_NL_FLAG_NEED_PORT) {
257 devlink_port = devlink_port_get_from_info(devlink, info);
258 if (IS_ERR(devlink_port)) {
259 err = PTR_ERR(devlink_port);
260 goto unlock;
261 }
262 info->user_ptr[1] = devlink_port;
263 } else if (flags & DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT) {
264 devlink_port = devlink_port_get_from_info(devlink, info);
265 if (!IS_ERR(devlink_port))
266 info->user_ptr[1] = devlink_port;
267 }
268 return 0;
269
270unlock:
271 devl_dev_unlock(devlink, dev_lock);
272 devlink_put(devlink);
273 return err;
274}
275
276int devlink_nl_pre_doit(const struct genl_split_ops *ops,
277 struct sk_buff *skb, struct genl_info *info)
278{
279 return __devlink_nl_pre_doit(skb, info, 0);
280}
281
282int devlink_nl_pre_doit_port(const struct genl_split_ops *ops,
283 struct sk_buff *skb, struct genl_info *info)
284{
285 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_PORT);
286}
287
288int devlink_nl_pre_doit_dev_lock(const struct genl_split_ops *ops,
289 struct sk_buff *skb, struct genl_info *info)
290{
291 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEV_LOCK);
292}
293
294int devlink_nl_pre_doit_port_optional(const struct genl_split_ops *ops,
295 struct sk_buff *skb,
296 struct genl_info *info)
297{
298 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT);
299}
300
301static void __devlink_nl_post_doit(struct sk_buff *skb, struct genl_info *info,
302 u8 flags)
303{
304 bool dev_lock = flags & DEVLINK_NL_FLAG_NEED_DEV_LOCK;
305 struct devlink *devlink;
306
307 devlink = info->user_ptr[0];
308 devl_dev_unlock(devlink, dev_lock);
309 devlink_put(devlink);
310}
311
312void devlink_nl_post_doit(const struct genl_split_ops *ops,
313 struct sk_buff *skb, struct genl_info *info)
314{
315 __devlink_nl_post_doit(skb, info, 0);
316}
317
318void
319devlink_nl_post_doit_dev_lock(const struct genl_split_ops *ops,
320 struct sk_buff *skb, struct genl_info *info)
321{
322 __devlink_nl_post_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEV_LOCK);
323}
324
325static int devlink_nl_inst_single_dumpit(struct sk_buff *msg,
326 struct netlink_callback *cb, int flags,
327 devlink_nl_dump_one_func_t *dump_one,
328 struct nlattr **attrs)
329{
330 struct devlink *devlink;
331 int err;
332
333 devlink = devlink_get_from_attrs_lock(sock_net(msg->sk), attrs, false);
334 if (IS_ERR(devlink))
335 return PTR_ERR(devlink);
336 err = dump_one(msg, devlink, cb, flags | NLM_F_DUMP_FILTERED);
337
338 devl_unlock(devlink);
339 devlink_put(devlink);
340
341 if (err != -EMSGSIZE)
342 return err;
343 return msg->len;
344}
345
346static int devlink_nl_inst_iter_dumpit(struct sk_buff *msg,
347 struct netlink_callback *cb, int flags,
348 devlink_nl_dump_one_func_t *dump_one)
349{
350 struct devlink_nl_dump_state *state = devlink_dump_state(cb);
351 struct devlink *devlink;
352 int err = 0;
353
354 while ((devlink = devlinks_xa_find_get(sock_net(msg->sk),
355 &state->instance))) {
356 devl_lock(devlink);
357
358 if (devl_is_registered(devlink))
359 err = dump_one(msg, devlink, cb, flags);
360 else
361 err = 0;
362
363 devl_unlock(devlink);
364 devlink_put(devlink);
365
366 if (err)
367 break;
368
369 state->instance++;
370
371 /* restart sub-object walk for the next instance */
372 state->idx = 0;
373 state->port_ctx.index = 0;
374 state->port_ctx.index_valid = false;
375 }
376
377 if (err != -EMSGSIZE)
378 return err;
379 return msg->len;
380}
381
382int devlink_nl_dumpit(struct sk_buff *msg, struct netlink_callback *cb,
383 devlink_nl_dump_one_func_t *dump_one)
384{
385 const struct genl_info *info = genl_info_dump(cb);
386 struct nlattr **attrs = info->attrs;
387 int flags = NLM_F_MULTI;
388
389 if (attrs &&
390 (attrs[DEVLINK_ATTR_BUS_NAME] || attrs[DEVLINK_ATTR_DEV_NAME] ||
391 attrs[DEVLINK_ATTR_INDEX]))
392 return devlink_nl_inst_single_dumpit(msg, cb, flags, dump_one,
393 attrs);
394 else
395 return devlink_nl_inst_iter_dumpit(msg, cb, flags, dump_one);
396}
397
398struct genl_family devlink_nl_family __ro_after_init = {
399 .name = DEVLINK_GENL_NAME,
400 .version = DEVLINK_GENL_VERSION,
401 .netnsok = true,
402 .parallel_ops = true,
403 .module = THIS_MODULE,
404 .split_ops = devlink_nl_ops,
405 .n_split_ops = ARRAY_SIZE(devlink_nl_ops),
406 .resv_start_op = DEVLINK_CMD_SELFTESTS_RUN + 1,
407 .mcgrps = devlink_nl_mcgrps,
408 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
409 .sock_priv_size = sizeof(struct devlink_nl_sock_priv),
410 .sock_priv_init = devlink_nl_sock_priv_init,
411 .sock_priv_destroy = devlink_nl_sock_priv_destroy,
412};