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)
 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, NLM_F_MULTI);
 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 __init ibnl_init(void)
 176 {
 177         struct netlink_kernel_cfg cfg = {
 178                 .input  = ibnl_rcv,
 179         };
 180
 181         nls = netlink_kernel_create(&init_net, NETLINK_RDMA, &cfg);
 182         if (!nls) {
 183                 pr_warn("Failed to create netlink socket\n");
 184                 return -ENOMEM;
 185         }
 186
 187         return 0;
 188 }
 189
 190 void ibnl_cleanup(void)
 191 {
 192         struct ibnl_client *cur, *next;
 193
 194         mutex_lock(&ibnl_mutex);
 195         list_for_each_entry_safe(cur, next, &client_list, list) {
 196                 list_del(&(cur->list));
 197                 kfree(cur);
 198         }
 199         mutex_unlock(&ibnl_mutex);
 200
 201         netlink_kernel_release(nls);
 202 }