1 /* 2 * Copyright (c) 2010 Voltaire Inc. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33 #define pr_fmt(fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__ 34 35 #include <linux/export.h> 36 #include <net/netlink.h> 37 #include <net/net_namespace.h> 38 #include <net/sock.h> 39 #include <rdma/rdma_netlink.h> 40 41 struct ibnl_client { 42 struct list_head list; 43 int index; 44 int nops; 45 const struct ibnl_client_cbs *cb_table; 46 }; 47 48 static DEFINE_MUTEX(ibnl_mutex); 49 static struct sock *nls; 50 static LIST_HEAD(client_list); 51 52 int ibnl_chk_listeners(unsigned int group) 53 { 54 if (netlink_has_listeners(nls, group) == 0) 55 return -1; 56 return 0; 57 } 58 EXPORT_SYMBOL(ibnl_chk_listeners); 59 60 int ibnl_add_client(int index, int nops, 61 const struct ibnl_client_cbs cb_table[]) 62 { 63 struct ibnl_client *cur; 64 struct ibnl_client *nl_client; 65 66 nl_client = kmalloc(sizeof *nl_client, GFP_KERNEL); 67 if (!nl_client) 68 return -ENOMEM; 69 70 nl_client->index = index; 71 nl_client->nops = nops; 72 nl_client->cb_table = cb_table; 73 74 mutex_lock(&ibnl_mutex); 75 76 list_for_each_entry(cur, &client_list, list) { 77 if (cur->index == index) { 78 pr_warn("Client for %d already exists\n", index); 79 mutex_unlock(&ibnl_mutex); 80 kfree(nl_client); 81 return -EINVAL; 82 } 83 } 84 85 list_add_tail(&nl_client->list, &client_list); 86 87 mutex_unlock(&ibnl_mutex); 88 89 return 0; 90 } 91 EXPORT_SYMBOL(ibnl_add_client); 92 93 int ibnl_remove_client(int index) 94 { 95 struct ibnl_client *cur, *next; 96 97 mutex_lock(&ibnl_mutex); 98 list_for_each_entry_safe(cur, next, &client_list, list) { 99 if (cur->index == index) { 100 list_del(&(cur->list)); 101 mutex_unlock(&ibnl_mutex); 102 kfree(cur); 103 return 0; 104 } 105 } 106 pr_warn("Can't remove callback for client idx %d. Not found\n", index); 107 mutex_unlock(&ibnl_mutex); 108 109 return -EINVAL; 110 } 111 EXPORT_SYMBOL(ibnl_remove_client); 112 113 void *ibnl_put_msg(struct sk_buff *skb, struct nlmsghdr **nlh, int seq, 114 int len, int client, int op, int flags) 115 { 116 unsigned char *prev_tail; 117 118 prev_tail = skb_tail_pointer(skb); 119 *nlh = nlmsg_put(skb, 0, seq, RDMA_NL_GET_TYPE(client, op), 120 len, flags); 121 if (!*nlh) 122 goto out_nlmsg_trim; 123 (*nlh)->nlmsg_len = skb_tail_pointer(skb) - prev_tail; 124 return nlmsg_data(*nlh); 125 126 out_nlmsg_trim: 127 nlmsg_trim(skb, prev_tail); 128 return NULL; 129 } 130 EXPORT_SYMBOL(ibnl_put_msg); 131 132 int ibnl_put_attr(struct sk_buff *skb, struct nlmsghdr *nlh, 133 int len, void *data, int type) 134 { 135 unsigned char *prev_tail; 136 137 prev_tail = skb_tail_pointer(skb); 138 if (nla_put(skb, type, len, data)) 139 goto nla_put_failure; 140 nlh->nlmsg_len += skb_tail_pointer(skb) - prev_tail; 141 return 0; 142 143 nla_put_failure: 144 nlmsg_trim(skb, prev_tail - nlh->nlmsg_len); 145 return -EMSGSIZE; 146 } 147 EXPORT_SYMBOL(ibnl_put_attr); 148 149 static int ibnl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 150 { 151 struct ibnl_client *client; 152 int type = nlh->nlmsg_type; 153 int index = RDMA_NL_GET_CLIENT(type); 154 unsigned int op = RDMA_NL_GET_OP(type); 155 156 list_for_each_entry(client, &client_list, list) { 157 if (client->index == index) { 158 if (op >= client->nops || !client->cb_table[op].dump) 159 return -EINVAL; 160 161 /* 162 * For response or local service set_timeout request, 163 * there is no need to use netlink_dump_start. 164 */ 165 if (!(nlh->nlmsg_flags & NLM_F_REQUEST) || 166 (index == RDMA_NL_LS && 167 op == RDMA_NL_LS_OP_SET_TIMEOUT)) { 168 struct netlink_callback cb = { 169 .skb = skb, 170 .nlh = nlh, 171 .dump = client->cb_table[op].dump, 172 .module = client->cb_table[op].module, 173 }; 174 175 return cb.dump(skb, &cb); 176 } 177 178 { 179 struct netlink_dump_control c = { 180 .dump = client->cb_table[op].dump, 181 .module = client->cb_table[op].module, 182 }; 183 return netlink_dump_start(nls, skb, nlh, &c); 184 } 185 } 186 } 187 188 pr_info("Index %d wasn't found in client list\n", index); 189 return -EINVAL; 190 } 191 192 static void ibnl_rcv_reply_skb(struct sk_buff *skb) 193 { 194 struct nlmsghdr *nlh; 195 int msglen; 196 197 /* 198 * Process responses until there is no more message or the first 199 * request. Generally speaking, it is not recommended to mix responses 200 * with requests. 201 */ 202 while (skb->len >= nlmsg_total_size(0)) { 203 nlh = nlmsg_hdr(skb); 204 205 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len) 206 return; 207 208 /* Handle response only */ 209 if (nlh->nlmsg_flags & NLM_F_REQUEST) 210 return; 211 212 ibnl_rcv_msg(skb, nlh); 213 214 msglen = NLMSG_ALIGN(nlh->nlmsg_len); 215 if (msglen > skb->len) 216 msglen = skb->len; 217 skb_pull(skb, msglen); 218 } 219 } 220 221 static void ibnl_rcv(struct sk_buff *skb) 222 { 223 mutex_lock(&ibnl_mutex); 224 ibnl_rcv_reply_skb(skb); 225 netlink_rcv_skb(skb, &ibnl_rcv_msg); 226 mutex_unlock(&ibnl_mutex); 227 } 228 229 int ibnl_unicast(struct sk_buff *skb, struct nlmsghdr *nlh, 230 __u32 pid) 231 { 232 int err; 233 234 err = netlink_unicast(nls, skb, pid, 0); 235 return (err < 0) ? err : 0; 236 } 237 EXPORT_SYMBOL(ibnl_unicast); 238 239 int ibnl_multicast(struct sk_buff *skb, struct nlmsghdr *nlh, 240 unsigned int group, gfp_t flags) 241 { 242 return nlmsg_multicast(nls, skb, 0, group, flags); 243 } 244 EXPORT_SYMBOL(ibnl_multicast); 245 246 int __init ibnl_init(void) 247 { 248 struct netlink_kernel_cfg cfg = { 249 .input = ibnl_rcv, 250 }; 251 252 nls = netlink_kernel_create(&init_net, NETLINK_RDMA, &cfg); 253 if (!nls) { 254 pr_warn("Failed to create netlink socket\n"); 255 return -ENOMEM; 256 } 257 258 nls->sk_sndtimeo = 10 * HZ; 259 return 0; 260 } 261 262 void ibnl_cleanup(void) 263 { 264 struct ibnl_client *cur, *next; 265 266 mutex_lock(&ibnl_mutex); 267 list_for_each_entry_safe(cur, next, &client_list, list) { 268 list_del(&(cur->list)); 269 kfree(cur); 270 } 271 mutex_unlock(&ibnl_mutex); 272 273 netlink_kernel_release(nls); 274 } 275