drivers/infiniband/sw/rxe/rxe.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
   4  * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
   5  */
   6
   7 #include <rdma/rdma_netlink.h>
   8 #include <net/addrconf.h>
   9 #include "rxe.h"
  10 #include "rxe_loc.h"
  11
  12 MODULE_AUTHOR("Bob Pearson, Frank Zago, John Groves, Kamal Heib");
  13 MODULE_DESCRIPTION("Soft RDMA transport");
  14 MODULE_LICENSE("Dual BSD/GPL");
  15
  16 bool rxe_initialized;
  17
  18 /* free resources for a rxe device all objects created for this device must
  19  * have been destroyed
  20  */
  21 void rxe_dealloc(struct ib_device *ib_dev)
  22 {
  23         struct rxe_dev *rxe = container_of(ib_dev, struct rxe_dev, ib_dev);
  24
  25         rxe_pool_cleanup(&rxe->uc_pool);
  26         rxe_pool_cleanup(&rxe->pd_pool);
  27         rxe_pool_cleanup(&rxe->ah_pool);
  28         rxe_pool_cleanup(&rxe->srq_pool);
  29         rxe_pool_cleanup(&rxe->qp_pool);
  30         rxe_pool_cleanup(&rxe->cq_pool);
  31         rxe_pool_cleanup(&rxe->mr_pool);
  32         rxe_pool_cleanup(&rxe->mw_pool);
  33         rxe_pool_cleanup(&rxe->mc_grp_pool);
  34         rxe_pool_cleanup(&rxe->mc_elem_pool);
  35
  36         if (rxe->tfm)
  37                 crypto_free_shash(rxe->tfm);
  38
  39         mutex_destroy(&rxe->usdev_lock);
  40 }
  41
  42 /* initialize rxe device parameters */
  43 static void rxe_init_device_param(struct rxe_dev *rxe)
  44 {
  45         rxe->max_inline_data                    = RXE_MAX_INLINE_DATA;
  46
  47         rxe->attr.vendor_id                     = RXE_VENDOR_ID;
  48         rxe->attr.max_mr_size                   = RXE_MAX_MR_SIZE;
  49         rxe->attr.page_size_cap                 = RXE_PAGE_SIZE_CAP;
  50         rxe->attr.max_qp                        = RXE_MAX_QP;
  51         rxe->attr.max_qp_wr                     = RXE_MAX_QP_WR;
  52         rxe->attr.device_cap_flags              = RXE_DEVICE_CAP_FLAGS;
  53         rxe->attr.max_send_sge                  = RXE_MAX_SGE;
  54         rxe->attr.max_recv_sge                  = RXE_MAX_SGE;
  55         rxe->attr.max_sge_rd                    = RXE_MAX_SGE_RD;
  56         rxe->attr.max_cq                        = RXE_MAX_CQ;
  57         rxe->attr.max_cqe                       = (1 << RXE_MAX_LOG_CQE) - 1;
  58         rxe->attr.max_mr                        = RXE_MAX_MR;
  59         rxe->attr.max_pd                        = RXE_MAX_PD;
  60         rxe->attr.max_qp_rd_atom                = RXE_MAX_QP_RD_ATOM;
  61         rxe->attr.max_res_rd_atom               = RXE_MAX_RES_RD_ATOM;
  62         rxe->attr.max_qp_init_rd_atom           = RXE_MAX_QP_INIT_RD_ATOM;
  63         rxe->attr.atomic_cap                    = IB_ATOMIC_HCA;
  64         rxe->attr.max_mcast_grp                 = RXE_MAX_MCAST_GRP;
  65         rxe->attr.max_mcast_qp_attach           = RXE_MAX_MCAST_QP_ATTACH;
  66         rxe->attr.max_total_mcast_qp_attach     = RXE_MAX_TOT_MCAST_QP_ATTACH;
  67         rxe->attr.max_ah                        = RXE_MAX_AH;
  68         rxe->attr.max_srq                       = RXE_MAX_SRQ;
  69         rxe->attr.max_srq_wr                    = RXE_MAX_SRQ_WR;
  70         rxe->attr.max_srq_sge                   = RXE_MAX_SRQ_SGE;
  71         rxe->attr.max_fast_reg_page_list_len    = RXE_MAX_FMR_PAGE_LIST_LEN;
  72         rxe->attr.max_pkeys                     = RXE_MAX_PKEYS;
  73         rxe->attr.local_ca_ack_delay            = RXE_LOCAL_CA_ACK_DELAY;
  74         addrconf_addr_eui48((unsigned char *)&rxe->attr.sys_image_guid,
  75                         rxe->ndev->dev_addr);
  76
  77         rxe->max_ucontext                       = RXE_MAX_UCONTEXT;
  78 }
  79
  80 /* initialize port attributes */
  81 static void rxe_init_port_param(struct rxe_port *port)
  82 {
  83         port->attr.state                = IB_PORT_DOWN;
  84         port->attr.max_mtu              = IB_MTU_4096;
  85         port->attr.active_mtu           = IB_MTU_256;
  86         port->attr.gid_tbl_len          = RXE_PORT_GID_TBL_LEN;
  87         port->attr.port_cap_flags       = RXE_PORT_PORT_CAP_FLAGS;
  88         port->attr.max_msg_sz           = RXE_PORT_MAX_MSG_SZ;
  89         port->attr.bad_pkey_cntr        = RXE_PORT_BAD_PKEY_CNTR;
  90         port->attr.qkey_viol_cntr       = RXE_PORT_QKEY_VIOL_CNTR;
  91         port->attr.pkey_tbl_len         = RXE_PORT_PKEY_TBL_LEN;
  92         port->attr.lid                  = RXE_PORT_LID;
  93         port->attr.sm_lid               = RXE_PORT_SM_LID;
  94         port->attr.lmc                  = RXE_PORT_LMC;
  95         port->attr.max_vl_num           = RXE_PORT_MAX_VL_NUM;
  96         port->attr.sm_sl                = RXE_PORT_SM_SL;
  97         port->attr.subnet_timeout       = RXE_PORT_SUBNET_TIMEOUT;
  98         port->attr.init_type_reply      = RXE_PORT_INIT_TYPE_REPLY;
  99         port->attr.active_width         = RXE_PORT_ACTIVE_WIDTH;
 100         port->attr.active_speed         = RXE_PORT_ACTIVE_SPEED;
 101         port->attr.phys_state           = RXE_PORT_PHYS_STATE;
 102         port->mtu_cap                   = ib_mtu_enum_to_int(IB_MTU_256);
 103         port->subnet_prefix             = cpu_to_be64(RXE_PORT_SUBNET_PREFIX);
 104 }
 105
 106 /* initialize port state, note IB convention that HCA ports are always
 107  * numbered from 1
 108  */
 109 static void rxe_init_ports(struct rxe_dev *rxe)
 110 {
 111         struct rxe_port *port = &rxe->port;
 112
 113         rxe_init_port_param(port);
 114         addrconf_addr_eui48((unsigned char *)&port->port_guid,
 115                             rxe->ndev->dev_addr);
 116         spin_lock_init(&port->port_lock);
 117 }
 118
 119 /* init pools of managed objects */
 120 static int rxe_init_pools(struct rxe_dev *rxe)
 121 {
 122         int err;
 123
 124         err = rxe_pool_init(rxe, &rxe->uc_pool, RXE_TYPE_UC,
 125                             rxe->max_ucontext);
 126         if (err)
 127                 goto err1;
 128
 129         err = rxe_pool_init(rxe, &rxe->pd_pool, RXE_TYPE_PD,
 130                             rxe->attr.max_pd);
 131         if (err)
 132                 goto err2;
 133
 134         err = rxe_pool_init(rxe, &rxe->ah_pool, RXE_TYPE_AH,
 135                             rxe->attr.max_ah);
 136         if (err)
 137                 goto err3;
 138
 139         err = rxe_pool_init(rxe, &rxe->srq_pool, RXE_TYPE_SRQ,
 140                             rxe->attr.max_srq);
 141         if (err)
 142                 goto err4;
 143
 144         err = rxe_pool_init(rxe, &rxe->qp_pool, RXE_TYPE_QP,
 145                             rxe->attr.max_qp);
 146         if (err)
 147                 goto err5;
 148
 149         err = rxe_pool_init(rxe, &rxe->cq_pool, RXE_TYPE_CQ,
 150                             rxe->attr.max_cq);
 151         if (err)
 152                 goto err6;
 153
 154         err = rxe_pool_init(rxe, &rxe->mr_pool, RXE_TYPE_MR,
 155                             rxe->attr.max_mr);
 156         if (err)
 157                 goto err7;
 158
 159         err = rxe_pool_init(rxe, &rxe->mw_pool, RXE_TYPE_MW,
 160                             rxe->attr.max_mw);
 161         if (err)
 162                 goto err8;
 163
 164         err = rxe_pool_init(rxe, &rxe->mc_grp_pool, RXE_TYPE_MC_GRP,
 165                             rxe->attr.max_mcast_grp);
 166         if (err)
 167                 goto err9;
 168
 169         err = rxe_pool_init(rxe, &rxe->mc_elem_pool, RXE_TYPE_MC_ELEM,
 170                             rxe->attr.max_total_mcast_qp_attach);
 171         if (err)
 172                 goto err10;
 173
 174         return 0;
 175
 176 err10:
 177         rxe_pool_cleanup(&rxe->mc_grp_pool);
 178 err9:
 179         rxe_pool_cleanup(&rxe->mw_pool);
 180 err8:
 181         rxe_pool_cleanup(&rxe->mr_pool);
 182 err7:
 183         rxe_pool_cleanup(&rxe->cq_pool);
 184 err6:
 185         rxe_pool_cleanup(&rxe->qp_pool);
 186 err5:
 187         rxe_pool_cleanup(&rxe->srq_pool);
 188 err4:
 189         rxe_pool_cleanup(&rxe->ah_pool);
 190 err3:
 191         rxe_pool_cleanup(&rxe->pd_pool);
 192 err2:
 193         rxe_pool_cleanup(&rxe->uc_pool);
 194 err1:
 195         return err;
 196 }
 197
 198 /* initialize rxe device state */
 199 static int rxe_init(struct rxe_dev *rxe)
 200 {
 201         int err;
 202
 203         /* init default device parameters */
 204         rxe_init_device_param(rxe);
 205
 206         rxe_init_ports(rxe);
 207
 208         err = rxe_init_pools(rxe);
 209         if (err)
 210                 return err;
 211
 212         /* init pending mmap list */
 213         spin_lock_init(&rxe->mmap_offset_lock);
 214         spin_lock_init(&rxe->pending_lock);
 215         INIT_LIST_HEAD(&rxe->pending_mmaps);
 216
 217         mutex_init(&rxe->usdev_lock);
 218
 219         return 0;
 220 }
 221
 222 void rxe_set_mtu(struct rxe_dev *rxe, unsigned int ndev_mtu)
 223 {
 224         struct rxe_port *port = &rxe->port;
 225         enum ib_mtu mtu;
 226
 227         mtu = eth_mtu_int_to_enum(ndev_mtu);
 228
 229         /* Make sure that new MTU in range */
 230         mtu = mtu ? min_t(enum ib_mtu, mtu, IB_MTU_4096) : IB_MTU_256;
 231
 232         port->attr.active_mtu = mtu;
 233         port->mtu_cap = ib_mtu_enum_to_int(mtu);
 234 }
 235
 236 /* called by ifc layer to create new rxe device.
 237  * The caller should allocate memory for rxe by calling ib_alloc_device.
 238  */
 239 int rxe_add(struct rxe_dev *rxe, unsigned int mtu, const char *ibdev_name)
 240 {
 241         int err;
 242
 243         err = rxe_init(rxe);
 244         if (err)
 245                 return err;
 246
 247         rxe_set_mtu(rxe, mtu);
 248
 249         return rxe_register_device(rxe, ibdev_name);
 250 }
 251
 252 static int rxe_newlink(const char *ibdev_name, struct net_device *ndev)
 253 {
 254         struct rxe_dev *exists;
 255         int err = 0;
 256
 257         if (is_vlan_dev(ndev)) {
 258                 pr_err("rxe creation allowed on top of a real device only\n");
 259                 err = -EPERM;
 260                 goto err;
 261         }
 262
 263         exists = rxe_get_dev_from_net(ndev);
 264         if (exists) {
 265                 ib_device_put(&exists->ib_dev);
 266                 pr_err("already configured on %s\n", ndev->name);
 267                 err = -EEXIST;
 268                 goto err;
 269         }
 270
 271         err = rxe_net_add(ibdev_name, ndev);
 272         if (err) {
 273                 pr_err("failed to add %s\n", ndev->name);
 274                 goto err;
 275         }
 276 err:
 277         return err;
 278 }
 279
 280 static struct rdma_link_ops rxe_link_ops = {
 281         .type = "rxe",
 282         .newlink = rxe_newlink,
 283 };
 284
 285 static int __init rxe_module_init(void)
 286 {
 287         int err;
 288
 289         err = rxe_net_init();
 290         if (err)
 291                 return err;
 292
 293         rdma_link_register(&rxe_link_ops);
 294         rxe_initialized = true;
 295         pr_info("loaded\n");
 296         return 0;
 297 }
 298
 299 static void __exit rxe_module_exit(void)
 300 {
 301         rdma_link_unregister(&rxe_link_ops);
 302         ib_unregister_driver(RDMA_DRIVER_RXE);
 303         rxe_net_exit();
 304
 305         rxe_initialized = false;
 306         pr_info("unloaded\n");
 307 }
 308
 309 late_initcall(rxe_module_init);
 310 module_exit(rxe_module_exit);
 311
 312 MODULE_ALIAS_RDMA_LINK("rxe");