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_add_client(int index, int nops,
  53                     const struct ibnl_client_cbs cb_table[])
  54 {
  55         struct ibnl_client *cur;
  56         struct ibnl_client *nl_client;
  57
  58         nl_client = kmalloc(sizeof *nl_client, GFP_KERNEL);
  59         if (!nl_client)
  60                 return -ENOMEM;
  61
  62         nl_client->index        = index;
  63         nl_client->nops         = nops;
  64         nl_client->cb_table     = cb_table;
  65
  66         mutex_lock(&ibnl_mutex);
  67
  68         list_for_each_entry(cur, &client_list, list) {
  69                 if (cur->index == index) {
  70                         pr_warn("Client for %d already exists\n", index);
  71                         mutex_unlock(&ibnl_mutex);
  72                         kfree(nl_client);
  73                         return -EINVAL;
  74                 }
  75         }
  76
  77         list_add_tail(&nl_client->list, &client_list);
  78
  79         mutex_unlock(&ibnl_mutex);
  80
  81         return 0;
  82 }
  83 EXPORT_SYMBOL(ibnl_add_client);
  84
  85 int ibnl_remove_client(int index)
  86 {
  87         struct ibnl_client *cur, *next;
  88
  89         mutex_lock(&ibnl_mutex);
  90         list_for_each_entry_safe(cur, next, &client_list, list) {
  91                 if (cur->index == index) {
  92                         list_del(&(cur->list));
  93                         mutex_unlock(&ibnl_mutex);
  94                         kfree(cur);
  95                         return 0;
  96                 }
  97         }
  98         pr_warn("Can't remove callback for client idx %d. Not found\n", index);
  99         mutex_unlock(&ibnl_mutex);
 100
 101         return -EINVAL;
 102 }
 103 EXPORT_SYMBOL(ibnl_remove_client);
 104
 105 void *ibnl_put_msg(struct sk_buff *skb, struct nlmsghdr **nlh, int seq,
 106                    int len, int client, int op, int flags)
 107 {
 108         unsigned char *prev_tail;
 109
 110         prev_tail = skb_tail_pointer(skb);
 111         *nlh = nlmsg_put(skb, 0, seq, RDMA_NL_GET_TYPE(client, op),
 112                          len, flags);
 113         if (!*nlh)
 114                 goto out_nlmsg_trim;
 115         (*nlh)->nlmsg_len = skb_tail_pointer(skb) - prev_tail;
 116         return nlmsg_data(*nlh);
 117
 118 out_nlmsg_trim:
 119         nlmsg_trim(skb, prev_tail);
 120         return NULL;
 121 }
 122 EXPORT_SYMBOL(ibnl_put_msg);
 123
 124 int ibnl_put_attr(struct sk_buff *skb, struct nlmsghdr *nlh,
 125                   int len, void *data, int type)
 126 {
 127         unsigned char *prev_tail;
 128
 129         prev_tail = skb_tail_pointer(skb);
 130         if (nla_put(skb, type, len, data))
 131                 goto nla_put_failure;
 132         nlh->nlmsg_len += skb_tail_pointer(skb) - prev_tail;
 133         return 0;
 134
 135 nla_put_failure:
 136         nlmsg_trim(skb, prev_tail - nlh->nlmsg_len);
 137         return -EMSGSIZE;
 138 }
 139 EXPORT_SYMBOL(ibnl_put_attr);
 140
 141 static int ibnl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
 142 {
 143         struct ibnl_client *client;
 144         int type = nlh->nlmsg_type;
 145         int index = RDMA_NL_GET_CLIENT(type);
 146         int op = RDMA_NL_GET_OP(type);
 147
 148         list_for_each_entry(client, &client_list, list) {
 149                 if (client->index == index) {
 150                         if (op < 0 || op >= client->nops ||
 151                             !client->cb_table[op].dump)
 152                                 return -EINVAL;
 153
 154                         {
 155                                 struct netlink_dump_control c = {
 156                                         .dump = client->cb_table[op].dump,
 157                                         .module = client->cb_table[op].module,
 158                                 };
 159                                 return netlink_dump_start(nls, skb, nlh, &c);
 160                         }
 161                 }
 162         }
 163
 164         pr_info("Index %d wasn't found in client list\n", index);
 165         return -EINVAL;
 166 }
 167
 168 static void ibnl_rcv(struct sk_buff *skb)
 169 {
 170         mutex_lock(&ibnl_mutex);
 171         netlink_rcv_skb(skb, &ibnl_rcv_msg);
 172         mutex_unlock(&ibnl_mutex);
 173 }
 174
 175 int ibnl_unicast(struct sk_buff *skb, struct nlmsghdr *nlh,
 176                         __u32 pid)
 177 {
 178         return nlmsg_unicast(nls, skb, pid);
 179 }
 180 EXPORT_SYMBOL(ibnl_unicast);
 181
 182 int ibnl_multicast(struct sk_buff *skb, struct nlmsghdr *nlh,
 183                         unsigned int group, gfp_t flags)
 184 {
 185         return nlmsg_multicast(nls, skb, 0, group, flags);
 186 }
 187 EXPORT_SYMBOL(ibnl_multicast);
 188
 189 int __init ibnl_init(void)
 190 {
 191         struct netlink_kernel_cfg cfg = {
 192                 .input  = ibnl_rcv,
 193         };
 194
 195         nls = netlink_kernel_create(&init_net, NETLINK_RDMA, &cfg);
 196         if (!nls) {
 197                 pr_warn("Failed to create netlink socket\n");
 198                 return -ENOMEM;
 199         }
 200
 201         return 0;
 202 }
 203
 204 void ibnl_cleanup(void)
 205 {
 206         struct ibnl_client *cur, *next;
 207
 208         mutex_lock(&ibnl_mutex);
 209         list_for_each_entry_safe(cur, next, &client_list, list) {
 210                 list_del(&(cur->list));
 211                 kfree(cur);
 212         }
 213         mutex_unlock(&ibnl_mutex);
 214
 215         netlink_kernel_release(nls);
 216 }