drivers/infiniband/core/netlink.c

   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 }