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