lnet/lnet/module.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2012, 2014, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_LNET
  38 #include <lnet/lib-lnet.h>
  39 #include <lnet/lib-dlc.h>
  40
  41 static int config_on_load = 0;
  42 CFS_MODULE_PARM(config_on_load, "i", int, 0444,
  43                 "configure network at module load");
  44
  45 static struct mutex lnet_config_mutex;
  46
  47 static int
  48 lnet_configure(void *arg)
  49 {
  50         /* 'arg' only there so I can be passed to cfs_create_thread() */
  51         int    rc = 0;
  52
  53         LNET_MUTEX_LOCK(&lnet_config_mutex);
  54
  55         if (!the_lnet.ln_niinit_self) {
  56                 rc = LNetNIInit(LNET_PID_LUSTRE);
  57                 if (rc >= 0) {
  58                         the_lnet.ln_niinit_self = 1;
  59                         rc = 0;
  60                 }
  61         }
  62
  63         LNET_MUTEX_UNLOCK(&lnet_config_mutex);
  64         return rc;
  65 }
  66
  67 static int
  68 lnet_unconfigure (void)
  69 {
  70         int   refcount;
  71
  72         LNET_MUTEX_LOCK(&lnet_config_mutex);
  73
  74         if (the_lnet.ln_niinit_self) {
  75                 the_lnet.ln_niinit_self = 0;
  76                 LNetNIFini();
  77         }
  78
  79         LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
  80         refcount = the_lnet.ln_refcount;
  81         LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
  82
  83         LNET_MUTEX_UNLOCK(&lnet_config_mutex);
  84         return (refcount == 0) ? 0 : -EBUSY;
  85 }
  86
  87 static int
  88 lnet_dyn_configure(struct libcfs_ioctl_hdr *hdr)
  89 {
  90         struct lnet_ioctl_config_data *conf =
  91           (struct lnet_ioctl_config_data *)hdr;
  92         int                           rc;
  93
  94         LNET_MUTEX_LOCK(&lnet_config_mutex);
  95         if (the_lnet.ln_niinit_self)
  96                 rc = lnet_dyn_add_ni(LNET_PID_LUSTRE,
  97                                      conf->cfg_config_u.cfg_net.net_intf,
  98                                      conf->cfg_config_u.cfg_net.
  99                                         net_peer_timeout,
 100                                      conf->cfg_config_u.cfg_net.
 101                                         net_peer_tx_credits,
 102                                      conf->cfg_config_u.cfg_net.
 103                                         net_peer_rtr_credits,
 104                                      conf->cfg_config_u.cfg_net.
 105                                         net_max_tx_credits);
 106         else
 107                 rc = -EINVAL;
 108         LNET_MUTEX_UNLOCK(&lnet_config_mutex);
 109         return rc;
 110 }
 111
 112 static int
 113 lnet_dyn_unconfigure(struct libcfs_ioctl_hdr *hdr)
 114 {
 115         struct lnet_ioctl_config_data *conf =
 116           (struct lnet_ioctl_config_data *) hdr;
 117         int                           rc;
 118
 119         LNET_MUTEX_LOCK(&lnet_config_mutex);
 120         if (the_lnet.ln_niinit_self)
 121                 rc = lnet_dyn_del_ni(conf->cfg_net);
 122         else
 123                 rc = -EINVAL;
 124         LNET_MUTEX_UNLOCK(&lnet_config_mutex);
 125
 126         return rc;
 127 }
 128
 129 static int
 130 lnet_ioctl(unsigned int cmd, struct libcfs_ioctl_hdr *hdr)
 131 {
 132         int   rc;
 133
 134         switch (cmd) {
 135         case IOC_LIBCFS_CONFIGURE: {
 136                 struct libcfs_ioctl_data *data =
 137                   (struct libcfs_ioctl_data *)hdr;
 138                 the_lnet.ln_nis_from_mod_params = data->ioc_flags;
 139                 return lnet_configure(NULL);
 140         }
 141
 142         case IOC_LIBCFS_UNCONFIGURE:
 143                 return lnet_unconfigure();
 144
 145         case IOC_LIBCFS_ADD_NET:
 146                 return lnet_dyn_configure(hdr);
 147
 148         case IOC_LIBCFS_DEL_NET:
 149                 return lnet_dyn_unconfigure(hdr);
 150
 151         default:
 152                 /* Passing LNET_PID_ANY only gives me a ref if the net is up
 153                  * already; I'll need it to ensure the net can't go down while
 154                  * I'm called into it */
 155                 rc = LNetNIInit(LNET_PID_ANY);
 156                 if (rc >= 0) {
 157                         rc = LNetCtl(cmd, hdr);
 158                         LNetNIFini();
 159                 }
 160                 return rc;
 161         }
 162 }
 163
 164 DECLARE_IOCTL_HANDLER(lnet_ioctl_handler, lnet_ioctl);
 165
 166 static int
 167 init_lnet(void)
 168 {
 169         int                  rc;
 170         ENTRY;
 171
 172         mutex_init(&lnet_config_mutex);
 173
 174         rc = LNetInit();
 175         if (rc != 0) {
 176                 CERROR("LNetInit: error %d\n", rc);
 177                 RETURN(rc);
 178         }
 179
 180         rc = libcfs_register_ioctl(&lnet_ioctl_handler);
 181         LASSERT (rc == 0);
 182
 183         if (config_on_load) {
 184                 /* Have to schedule a separate thread to avoid deadlocking
 185                  * in modload */
 186                 (void) kthread_run(lnet_configure, NULL, "lnet_initd");
 187         }
 188
 189         RETURN(0);
 190 }
 191
 192 static void
 193 fini_lnet(void)
 194 {
 195         int rc;
 196
 197         rc = libcfs_deregister_ioctl(&lnet_ioctl_handler);
 198         LASSERT (rc == 0);
 199
 200         LNetFini();
 201 }
 202
 203 MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
 204 MODULE_DESCRIPTION("Portals v3.1");
 205 MODULE_LICENSE("GPL");
 206
 207 cfs_module(lnet, "1.0.0", init_lnet, fini_lnet);