Whamcloud - gitweb
LU-3963 libcfs: remove proc handler wrappers
[fs/lustre-release.git] / 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, 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 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(LUSTRE_SRV_LNET_PID);
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 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 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(LUSTRE_SRV_LNET_PID,
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 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 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 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 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);