1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <sys/conf.h>
  27 #include <sys/ddi.h>
  28 #include <sys/sunddi.h>
  29 #include <sys/modctl.h>
  30 #include <sys/strsubr.h>
  31 #include <sys/socketvar.h>
  32 #include <sys/rds.h>
  33 
  34 #include <sys/ib/ibtl/ibti.h>
  35 #include <sys/ib/clients/rdsv3/rdsv3.h>
  36 #include <sys/ib/clients/rdsv3/rdsv3_debug.h>
  37 #include <sys/ib/clients/rdsv3/rdsv3_af_thr.h>
  38 
  39 extern int rdsv3_init(void);
  40 extern void rdsv3_exit(void);
  41 extern void rdsv3_cong_init(void);
  42 extern void rdsv3_cong_exit(void);
  43 extern void rdsv3_trans_init(void);
  44 extern void rdsv3_trans_exit(void);
  45 extern int rdsv3_sock_init(void);
  46 extern void rdsv3_sock_exit(void);
  47 
  48 /* global */
  49 dev_info_t      *rdsv3_dev_info = NULL;
  50 kmem_cache_t    *rdsv3_alloc_cache = NULL;
  51 
  52 extern kmutex_t rdsv3_rdma_listen_id_lock;
  53 extern struct rdma_cm_id *rdsv3_rdma_listen_id;
  54 
  55 extern kmutex_t rdsv3_sock_lock;
  56 extern list_t rdsv3_sock_list;
  57 
  58 extern void rdsv3_bind_init();
  59 extern void rdsv3_bind_exit();
  60 
  61 int
  62 rdsv3_sock_init()
  63 {
  64         RDSV3_DPRINTF4("rdsv3_sock_init", "Enter");
  65 
  66         rdsv3_alloc_cache = kmem_cache_create("rdsv3_alloc_cache",
  67             sizeof (struct rsock) + sizeof (struct rdsv3_sock), 0, NULL,
  68             NULL, NULL, NULL, NULL, 0);
  69         if (rdsv3_alloc_cache == NULL) {
  70                 RDSV3_DPRINTF2("rdsv3_alloc_cache",
  71                     "kmem_cache_create(rdsv3_alloc_cache) failed");
  72                 return (-1);
  73         }
  74         rdsv3_bind_init();
  75 
  76         mutex_init(&rdsv3_sock_lock, NULL, MUTEX_DRIVER, NULL);
  77         list_create(&rdsv3_sock_list, sizeof (struct rdsv3_sock),
  78             offsetof(struct rdsv3_sock, rs_item));
  79 
  80         RDSV3_DPRINTF4("rdsv3_sock_init", "Return");
  81 
  82         return (0);
  83 }
  84 
  85 void
  86 rdsv3_sock_exit()
  87 {
  88         RDSV3_DPRINTF2("rdsv3_sock_exit", "Enter");
  89 
  90         rdsv3_bind_exit();
  91 
  92         kmem_cache_destroy(rdsv3_alloc_cache);
  93 
  94         list_destroy(&rdsv3_sock_list);
  95         mutex_destroy(&rdsv3_sock_lock);
  96 
  97         RDSV3_DPRINTF2("rdsv3_sock_exit", "Return");
  98 }
  99 
 100 static int
 101 rdsv3_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 102 {
 103         int     ret;
 104 
 105         RDSV3_DPRINTF2("rdsv3_attach", "Enter (dip: %p)", dip);
 106 
 107         if (cmd != DDI_ATTACH)
 108                 return (DDI_FAILURE);
 109 
 110         if (rdsv3_dev_info != NULL) {
 111                 RDSV3_DPRINTF2("rdsv3_attach", "Multiple RDS instances are"
 112                     " not supported (rdsv3_dev_info: 0x%p)", rdsv3_dev_info);
 113                 return (DDI_FAILURE);
 114         }
 115         rdsv3_dev_info = dip;
 116 
 117         mutex_init(&rdsv3_rdma_listen_id_lock, NULL, MUTEX_DRIVER, NULL);
 118         rdsv3_rdma_listen_id = NULL;
 119 
 120         rdsv3_af_init(dip);
 121         rdsv3_trans_init();
 122         ret = rdsv3_init();
 123         if (ret) {
 124                 RDSV3_DPRINTF2("rdsv3_attach", "rdsv3_init failed: %d", ret);
 125                 rdsv3_trans_exit();
 126                 mutex_destroy(&rdsv3_rdma_listen_id_lock);
 127                 rdsv3_dev_info = NULL;
 128                 return (DDI_FAILURE);
 129         }
 130 
 131         ret = rdsv3_sock_init();
 132         if (ret) {
 133                 rdsv3_exit();
 134                 rdsv3_trans_exit();
 135                 mutex_destroy(&rdsv3_rdma_listen_id_lock);
 136                 rdsv3_dev_info = NULL;
 137                 return (DDI_FAILURE);
 138         }
 139 
 140         ret = ddi_create_minor_node(dip, "rdsv3", S_IFCHR, 0, DDI_PSEUDO, 0);
 141         if (ret != DDI_SUCCESS) {
 142                 cmn_err(CE_CONT, "ddi_create_minor_node failed: %d", ret);
 143                 rdsv3_sock_exit();
 144                 rdsv3_exit();
 145                 rdsv3_trans_exit();
 146                 mutex_destroy(&rdsv3_rdma_listen_id_lock);
 147                 rdsv3_dev_info = NULL;
 148                 return (DDI_FAILURE);
 149         }
 150 
 151         RDSV3_DPRINTF2("rdsv3_attach", "Return");
 152 
 153         return (DDI_SUCCESS);
 154 }
 155 
 156 static int
 157 rdsv3_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 158 {
 159         RDSV3_DPRINTF2("rdsv3_detach", "Enter (dip: %p)", dip);
 160 
 161         if (cmd != DDI_DETACH)
 162                 return (DDI_FAILURE);
 163 
 164         rdsv3_sock_exit();
 165         rdsv3_exit();
 166         rdsv3_trans_exit();
 167         ddi_remove_minor_node(dip, "rdsv3");
 168         rdsv3_dev_info = NULL;
 169 
 170         RDSV3_DPRINTF2("rdsv3_detach", "Return");
 171 
 172         return (DDI_SUCCESS);
 173 }
 174 
 175 /* ARGSUSED */
 176 static int
 177 rdsv3_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 178 {
 179         int ret = DDI_FAILURE;
 180 
 181         RDSV3_DPRINTF2("rdsv3_info", "Enter (dip: %p, cmd: %d)", dip, cmd);
 182 
 183         switch (cmd) {
 184         case DDI_INFO_DEVT2DEVINFO:
 185                 if (rdsv3_dev_info != NULL) {
 186                         *result = (void *)rdsv3_dev_info;
 187                         ret = DDI_SUCCESS;
 188                 }
 189                 break;
 190 
 191         case DDI_INFO_DEVT2INSTANCE:
 192                 *result = NULL;
 193                 ret = DDI_SUCCESS;
 194                 break;
 195 
 196         default:
 197                 break;
 198         }
 199 
 200         RDSV3_DPRINTF4("rdsv3_info", "Return");
 201 
 202         return (ret);
 203 }
 204 
 205 /* Driver entry points */
 206 static struct cb_ops    rdsv3_cb_ops = {
 207         nulldev,                /* open */
 208         nulldev,                /* close */
 209         nodev,                  /* strategy */
 210         nodev,                  /* print */
 211         nodev,                  /* dump */
 212         nodev,                  /* read */
 213         nodev,                  /* write */
 214         nodev,                  /* ioctl */
 215         nodev,                  /* devmap */
 216         nodev,                  /* mmap */
 217         nodev,                  /* segmap */
 218         nochpoll,               /* poll */
 219         ddi_prop_op,            /* prop_op */
 220         NULL,                   /* stream */
 221         D_MP,                   /* cb_flag */
 222         CB_REV,                 /* rev */
 223         nodev,                  /* int (*cb_aread)() */
 224         nodev,                  /* int (*cb_awrite)() */
 225 };
 226 
 227 /* Device options */
 228 static struct dev_ops rdsv3_ops = {
 229         DEVO_REV,               /* devo_rev, */
 230         0,                      /* refcnt  */
 231         rdsv3_info,             /* info */
 232         nulldev,                /* identify */
 233         nulldev,                /* probe */
 234         rdsv3_attach,           /* attach */
 235         rdsv3_detach,           /* detach */
 236         nodev,                  /* reset */
 237         &rdsv3_cb_ops,              /* driver ops - devctl interfaces */
 238         NULL,                   /* bus operations */
 239         NULL,                   /* power */
 240         ddi_quiesce_not_needed  /* quiesce */
 241 };
 242 
 243 /*
 244  * Module linkage information.
 245  */
 246 #define RDSV3_DEVDESC   "RDSv3 IB transport driver"
 247 static struct modldrv rdsv3_modldrv = {
 248         &mod_driverops,             /* Driver module */
 249         RDSV3_DEVDESC,          /* Driver name and version */
 250         &rdsv3_ops,         /* Driver ops */
 251 };
 252 
 253 static struct modlinkage rdsv3_modlinkage = {
 254         MODREV_1,
 255         (void *)&rdsv3_modldrv,
 256         NULL
 257 };
 258 
 259 int
 260 _init(void)
 261 {
 262         int     ret;
 263 
 264         if (ibt_hw_is_present() == 0) {
 265                 return (ENODEV);
 266         }
 267 
 268         /* Initialize logging */
 269         rdsv3_logging_initialization();
 270 
 271         ret = mod_install(&rdsv3_modlinkage);
 272         if (ret != 0) {
 273                 /*
 274                  * Could not load module
 275                  */
 276                 rdsv3_logging_destroy();
 277                 return (ret);
 278         }
 279 
 280         return (0);
 281 }
 282 
 283 int
 284 _fini()
 285 {
 286         int     ret;
 287 
 288         /*
 289          * Remove module
 290          */
 291         if ((ret = mod_remove(&rdsv3_modlinkage)) != 0) {
 292                 return (ret);
 293         }
 294 
 295         /* Stop logging */
 296         rdsv3_logging_destroy();
 297 
 298         return (0);
 299 }
 300 
 301 int
 302 _info(struct modinfo *modinfop)
 303 {
 304         return (mod_info(&rdsv3_modlinkage, modinfop));
 305 }