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
16 static const struct genl_multicast_group devlink_nl_mcgrps[] = {
17 [DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
18 };
19
20 struct devlink_nl_sock_priv {
21 struct devlink_obj_desc __rcu *flt;
22 spinlock_t flt_lock; /* Protects flt. */
23 };
24
25 static 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
32 static 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
41 int 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_PORT_INDEX]) {
77 flt->port_index = nla_get_u32(attrs[DEVLINK_ATTR_PORT_INDEX]);
78 flt->port_index_valid = true;
79 }
80
81 /* Don't attach empty filter. */
82 if (!flt->bus_name && !flt->dev_name && !flt->port_index_valid) {
83 kfree(flt);
84 flt = NULL;
85 }
86
87 sk_priv = genl_sk_priv_get(&devlink_nl_family, NETLINK_CB(skb).sk);
88 if (IS_ERR(sk_priv)) {
89 kfree(flt);
90 return PTR_ERR(sk_priv);
91 }
92 spin_lock(&sk_priv->flt_lock);
93 flt = rcu_replace_pointer(sk_priv->flt, flt,
94 lockdep_is_held(&sk_priv->flt_lock));
95 spin_unlock(&sk_priv->flt_lock);
96 kfree_rcu(flt, rcu);
97 return 0;
98 }
99
100 static bool devlink_obj_desc_match(const struct devlink_obj_desc *desc,
101 const struct devlink_obj_desc *flt)
102 {
103 if (desc->bus_name && flt->bus_name &&
104 strcmp(desc->bus_name, flt->bus_name))
105 return false;
106 if (desc->dev_name && flt->dev_name &&
107 strcmp(desc->dev_name, flt->dev_name))
108 return false;
109 if (desc->port_index_valid && flt->port_index_valid &&
110 desc->port_index != flt->port_index)
111 return false;
112 return true;
113 }
114
115 int devlink_nl_notify_filter(struct sock *dsk, struct sk_buff *skb, void *data)
116 {
117 struct devlink_obj_desc *desc = data;
118 struct devlink_nl_sock_priv *sk_priv;
119 struct devlink_obj_desc *flt;
120 int ret = 0;
121
122 rcu_read_lock();
123 sk_priv = __genl_sk_priv_get(&devlink_nl_family, dsk);
124 if (!IS_ERR_OR_NULL(sk_priv)) {
125 flt = rcu_dereference(sk_priv->flt);
126 if (flt)
127 ret = !devlink_obj_desc_match(desc, flt);
128 }
129 rcu_read_unlock();
130 return ret;
131 }
132
133 int devlink_nl_put_nested_handle(struct sk_buff *msg, struct net *net,
134 struct devlink *devlink, int attrtype)
135 {
136 struct nlattr *nested_attr;
137 struct net *devl_net;
138
139 nested_attr = nla_nest_start(msg, attrtype);
140 if (!nested_attr)
141 return -EMSGSIZE;
142 if (devlink_nl_put_handle(msg, devlink))
143 goto nla_put_failure;
144
145 rcu_read_lock();
146 devl_net = read_pnet_rcu(&devlink->_net);
147 if (!net_eq(net, devl_net)) {
148 int id = peernet2id_alloc(net, devl_net, GFP_ATOMIC);
149
150 rcu_read_unlock();
151 if (nla_put_s32(msg, DEVLINK_ATTR_NETNS_ID, id))
152 return -EMSGSIZE;
153 } else {
154 rcu_read_unlock();
155 }
156
157 nla_nest_end(msg, nested_attr);
158 return 0;
159
160 nla_put_failure:
161 nla_nest_cancel(msg, nested_attr);
162 return -EMSGSIZE;
163 }
164
165 int devlink_nl_msg_reply_and_new(struct sk_buff **msg, struct genl_info *info)
166 {
167 int err;
168
169 if (*msg) {
170 err = genlmsg_reply(*msg, info);
171 if (err)
172 return err;
173 }
174 *msg = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
175 if (!*msg)
176 return -ENOMEM;
177 return 0;
178 }
179
180 struct devlink *
181 devlink_get_from_attrs_lock(struct net *net, struct nlattr **attrs,
182 bool dev_lock)
183 {
184 struct devlink *devlink;
185 unsigned long index;
186 char *busname;
187 char *devname;
188
189 if (!attrs[DEVLINK_ATTR_BUS_NAME] || !attrs[DEVLINK_ATTR_DEV_NAME])
190 return ERR_PTR(-EINVAL);
191
192 busname = nla_data(attrs[DEVLINK_ATTR_BUS_NAME]);
193 devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
194
195 devlinks_xa_for_each_registered_get(net, index, devlink) {
196 if (strcmp(devlink->dev->bus->name, busname) == 0 &&
197 strcmp(dev_name(devlink->dev), devname) == 0) {
198 devl_dev_lock(devlink, dev_lock);
199 if (devl_is_registered(devlink))
200 return devlink;
201 devl_dev_unlock(devlink, dev_lock);
202 }
203 devlink_put(devlink);
204 }
205
206 return ERR_PTR(-ENODEV);
207 }
208
209 static int __devlink_nl_pre_doit(struct sk_buff *skb, struct genl_info *info,
210 u8 flags)
211 {
212 bool dev_lock = flags & DEVLINK_NL_FLAG_NEED_DEV_LOCK;
213 struct devlink_port *devlink_port;
214 struct devlink *devlink;
215 int err;
216
217 devlink = devlink_get_from_attrs_lock(genl_info_net(info), info->attrs,
218 dev_lock);
219 if (IS_ERR(devlink))
220 return PTR_ERR(devlink);
221
222 info->user_ptr[0] = devlink;
223 if (flags & DEVLINK_NL_FLAG_NEED_PORT) {
224 devlink_port = devlink_port_get_from_info(devlink, info);
225 if (IS_ERR(devlink_port)) {
226 err = PTR_ERR(devlink_port);
227 goto unlock;
228 }
229 info->user_ptr[1] = devlink_port;
230 } else if (flags & DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT) {
231 devlink_port = devlink_port_get_from_info(devlink, info);
232 if (!IS_ERR(devlink_port))
233 info->user_ptr[1] = devlink_port;
234 }
235 return 0;
236
237 unlock:
238 devl_dev_unlock(devlink, dev_lock);
239 devlink_put(devlink);
240 return err;
241 }
242
243 int devlink_nl_pre_doit(const struct genl_split_ops *ops,
244 struct sk_buff *skb, struct genl_info *info)
245 {
246 return __devlink_nl_pre_doit(skb, info, 0);
247 }
248
249 int devlink_nl_pre_doit_port(const struct genl_split_ops *ops,
250 struct sk_buff *skb, struct genl_info *info)
251 {
252 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_PORT);
253 }
254
255 int devlink_nl_pre_doit_dev_lock(const struct genl_split_ops *ops,
256 struct sk_buff *skb, struct genl_info *info)
257 {
258 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEV_LOCK);
259 }
260
261 int devlink_nl_pre_doit_port_optional(const struct genl_split_ops *ops,
262 struct sk_buff *skb,
263 struct genl_info *info)
264 {
265 return __devlink_nl_pre_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT);
266 }
267
268 static void __devlink_nl_post_doit(struct sk_buff *skb, struct genl_info *info,
269 u8 flags)
270 {
271 bool dev_lock = flags & DEVLINK_NL_FLAG_NEED_DEV_LOCK;
272 struct devlink *devlink;
273
274 devlink = info->user_ptr[0];
275 devl_dev_unlock(devlink, dev_lock);
276 devlink_put(devlink);
277 }
278
279 void devlink_nl_post_doit(const struct genl_split_ops *ops,
280 struct sk_buff *skb, struct genl_info *info)
281 {
282 __devlink_nl_post_doit(skb, info, 0);
283 }
284
285 void
286 devlink_nl_post_doit_dev_lock(const struct genl_split_ops *ops,
287 struct sk_buff *skb, struct genl_info *info)
288 {
289 __devlink_nl_post_doit(skb, info, DEVLINK_NL_FLAG_NEED_DEV_LOCK);
290 }
291
292 static int devlink_nl_inst_single_dumpit(struct sk_buff *msg,
293 struct netlink_callback *cb, int flags,
294 devlink_nl_dump_one_func_t *dump_one,
295 struct nlattr **attrs)
296 {
297 struct devlink *devlink;
298 int err;
299
300 devlink = devlink_get_from_attrs_lock(sock_net(msg->sk), attrs, false);
301 if (IS_ERR(devlink))
302 return PTR_ERR(devlink);
303 err = dump_one(msg, devlink, cb, flags | NLM_F_DUMP_FILTERED);
304
305 devl_unlock(devlink);
306 devlink_put(devlink);
307
308 if (err != -EMSGSIZE)
309 return err;
310 return msg->len;
311 }
312
313 static int devlink_nl_inst_iter_dumpit(struct sk_buff *msg,
314 struct netlink_callback *cb, int flags,
315 devlink_nl_dump_one_func_t *dump_one)
316 {
317 struct devlink_nl_dump_state *state = devlink_dump_state(cb);
318 struct devlink *devlink;
319 int err = 0;
320
321 while ((devlink = devlinks_xa_find_get(sock_net(msg->sk),
322 &state->instance))) {
323 devl_lock(devlink);
324
325 if (devl_is_registered(devlink))
326 err = dump_one(msg, devlink, cb, flags);
327 else
328 err = 0;
329
330 devl_unlock(devlink);
331 devlink_put(devlink);
332
333 if (err)
334 break;
335
336 state->instance++;
337
338 /* restart sub-object walk for the next instance */
339 state->idx = 0;
340 }
341
342 if (err != -EMSGSIZE)
343 return err;
344 return msg->len;
345 }
346
347 int devlink_nl_dumpit(struct sk_buff *msg, struct netlink_callback *cb,
348 devlink_nl_dump_one_func_t *dump_one)
349 {
350 const struct genl_info *info = genl_info_dump(cb);
351 struct nlattr **attrs = info->attrs;
352 int flags = NLM_F_MULTI;
353
354 if (attrs &&
355 (attrs[DEVLINK_ATTR_BUS_NAME] || attrs[DEVLINK_ATTR_DEV_NAME]))
356 return devlink_nl_inst_single_dumpit(msg, cb, flags, dump_one,
357 attrs);
358 else
359 return devlink_nl_inst_iter_dumpit(msg, cb, flags, dump_one);
360 }
361
362 struct genl_family devlink_nl_family __ro_after_init = {
363 .name = DEVLINK_GENL_NAME,
364 .version = DEVLINK_GENL_VERSION,
365 .netnsok = true,
366 .parallel_ops = true,
367 .module = THIS_MODULE,
368 .split_ops = devlink_nl_ops,
369 .n_split_ops = ARRAY_SIZE(devlink_nl_ops),
370 .resv_start_op = DEVLINK_CMD_SELFTESTS_RUN + 1,
371 .mcgrps = devlink_nl_mcgrps,
372 .n_mcgrps = ARRAY_SIZE(devlink_nl_mcgrps),
373 .sock_priv_size = sizeof(struct devlink_nl_sock_priv),
374 .sock_priv_init = devlink_nl_sock_priv_init,
375 .sock_priv_destroy = devlink_nl_sock_priv_destroy,
376 };
377
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.