Whamcloud - gitweb
d0f417f780548bb14d299ea0720197265ac58b98
[fs/lustre-release.git] / libcfs / libcfs / 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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  */
32 #include <linux/miscdevice.h>
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/mm.h>
36 #include <linux/string.h>
37 #include <linux/stat.h>
38 #include <linux/errno.h>
39 #include <linux/unistd.h>
40 #include <net/sock.h>
41 #include <linux/uio.h>
42 #include <linux/uaccess.h>
43
44 #include <linux/fs.h>
45 #include <linux/file.h>
46 #include <linux/list.h>
47
48 #include <linux/sysctl.h>
49 #include <linux/debugfs.h>
50 #include <asm/div64.h>
51
52 #define DEBUG_SUBSYSTEM S_LNET
53
54 #include <libcfs/libcfs.h>
55 #include <libcfs/libcfs_crypto.h>
56 #include <lnet/lib-lnet.h>
57 #include "tracefile.h"
58
59 static struct dentry *lnet_debugfs_root;
60
61 BLOCKING_NOTIFIER_HEAD(libcfs_ioctl_list);
62 EXPORT_SYMBOL(libcfs_ioctl_list);
63
64 static inline size_t libcfs_ioctl_packlen(struct libcfs_ioctl_data *data)
65 {
66         size_t len = sizeof(*data);
67
68         len += (data->ioc_inllen1 + 7) & ~7;
69         len += (data->ioc_inllen2 + 7) & ~7;
70         return len;
71 }
72
73 static bool libcfs_ioctl_is_invalid(struct libcfs_ioctl_data *data)
74 {
75         if (data->ioc_hdr.ioc_len > BIT(30))
76                 return true;
77
78         if (data->ioc_inllen1 > BIT(30))
79                 return true;
80
81         if (data->ioc_inllen2 > BIT(30))
82                 return true;
83
84         if (data->ioc_inlbuf1 && !data->ioc_inllen1)
85                 return true;
86
87         if (data->ioc_inlbuf2 && !data->ioc_inllen2)
88                 return true;
89
90         if (data->ioc_pbuf1 && !data->ioc_plen1)
91                 return true;
92
93         if (data->ioc_pbuf2 && !data->ioc_plen2)
94                 return true;
95
96         if (data->ioc_plen1 && !data->ioc_pbuf1)
97                 return true;
98
99         if (data->ioc_plen2 && !data->ioc_pbuf2)
100                 return true;
101
102         if (libcfs_ioctl_packlen(data) != data->ioc_hdr.ioc_len)
103                 return true;
104
105         if (data->ioc_inllen1 &&
106                 data->ioc_bulk[((data->ioc_inllen1 + 7) & ~7) +
107                                data->ioc_inllen2 - 1] != '\0')
108                 return true;
109
110         return false;
111 }
112
113 int libcfs_ioctl_data_adjust(struct libcfs_ioctl_data *data)
114 {
115         ENTRY;
116
117         if (libcfs_ioctl_is_invalid(data)) {
118                 CERROR("libcfs ioctl: parameter not correctly formatted\n");
119                 RETURN(-EINVAL);
120         }
121
122         if (data->ioc_inllen1 != 0)
123                 data->ioc_inlbuf1 = &data->ioc_bulk[0];
124
125         if (data->ioc_inllen2 != 0)
126                 data->ioc_inlbuf2 = &data->ioc_bulk[0] +
127                                     cfs_size_round(data->ioc_inllen1);
128
129         RETURN(0);
130 }
131
132 int libcfs_ioctl_getdata(struct libcfs_ioctl_hdr **hdr_pp,
133                          struct libcfs_ioctl_hdr __user *uhdr)
134 {
135         struct libcfs_ioctl_hdr hdr;
136         int err;
137
138         ENTRY;
139         if (copy_from_user(&hdr, uhdr, sizeof(hdr)))
140                 RETURN(-EFAULT);
141
142         if (hdr.ioc_version != LIBCFS_IOCTL_VERSION &&
143             hdr.ioc_version != LIBCFS_IOCTL_VERSION2) {
144                 CERROR("libcfs ioctl: version mismatch expected %#x, got %#x\n",
145                        LIBCFS_IOCTL_VERSION, hdr.ioc_version);
146                 RETURN(-EINVAL);
147         }
148
149         if (hdr.ioc_len < sizeof(struct libcfs_ioctl_hdr)) {
150                 CERROR("libcfs ioctl: user buffer too small for ioctl\n");
151                 RETURN(-EINVAL);
152         }
153
154         if (hdr.ioc_len > LIBCFS_IOC_DATA_MAX) {
155                 CERROR("libcfs ioctl: user buffer is too large %d/%d\n",
156                        hdr.ioc_len, LIBCFS_IOC_DATA_MAX);
157                 RETURN(-EINVAL);
158         }
159
160         LIBCFS_ALLOC(*hdr_pp, hdr.ioc_len);
161         if (*hdr_pp == NULL)
162                 RETURN(-ENOMEM);
163
164         if (copy_from_user(*hdr_pp, uhdr, hdr.ioc_len))
165                 GOTO(free, err = -EFAULT);
166
167         if ((*hdr_pp)->ioc_version != hdr.ioc_version ||
168                 (*hdr_pp)->ioc_len != hdr.ioc_len) {
169                 GOTO(free, err = -EINVAL);
170         }
171
172         RETURN(0);
173
174 free:
175         LIBCFS_FREE(*hdr_pp, hdr.ioc_len);
176         RETURN(err);
177 }
178
179 static int libcfs_ioctl(unsigned long cmd, void __user *uparam)
180 {
181         struct libcfs_ioctl_data *data = NULL;
182         struct libcfs_ioctl_hdr  *hdr;
183         int                       err;
184         ENTRY;
185
186         /* 'cmd' and permissions get checked in our arch-specific caller */
187         err = libcfs_ioctl_getdata(&hdr, uparam);
188         if (err != 0) {
189                 CDEBUG_LIMIT(D_ERROR,
190                              "libcfs ioctl: data header error %d\n", err);
191                 RETURN(err);
192         }
193
194         if (hdr->ioc_version == LIBCFS_IOCTL_VERSION) {
195                 /* The libcfs_ioctl_data_adjust() function performs adjustment
196                  * operations on the libcfs_ioctl_data structure to make
197                  * it usable by the code.  This doesn't need to be called
198                  * for new data structures added. */
199                 data = container_of(hdr, struct libcfs_ioctl_data, ioc_hdr);
200                 err = libcfs_ioctl_data_adjust(data);
201                 if (err != 0)
202                         GOTO(out, err);
203         }
204
205         CDEBUG(D_IOCTL, "libcfs ioctl cmd %lu\n", cmd);
206         switch (cmd) {
207         case IOC_LIBCFS_CLEAR_DEBUG:
208                 libcfs_debug_clear_buffer();
209                 break;
210         case IOC_LIBCFS_MARK_DEBUG:
211                 if (data == NULL ||
212                     data->ioc_inlbuf1 == NULL ||
213                     data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0')
214                         GOTO(out, err = -EINVAL);
215
216                 libcfs_debug_mark_buffer(data->ioc_inlbuf1);
217                 break;
218
219         default:
220                 err = blocking_notifier_call_chain(&libcfs_ioctl_list,
221                                                    cmd, hdr);
222                 if (!(err & NOTIFY_STOP_MASK))
223                         /* No-one claimed the ioctl */
224                         err = -EINVAL;
225                 else
226                         err = notifier_to_errno(err);
227                 if (!err)
228                         if (copy_to_user(uparam, hdr, hdr->ioc_len))
229                                 err = -EFAULT;
230                 break;
231         }
232 out:
233         LIBCFS_FREE(hdr, hdr->ioc_len);
234         RETURN(err);
235 }
236
237 static long
238 libcfs_psdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
239 {
240         if (!capable(CAP_SYS_ADMIN))
241                 return -EACCES;
242
243         if (_IOC_TYPE(cmd) != IOC_LIBCFS_TYPE ||
244             _IOC_NR(cmd) < IOC_LIBCFS_MIN_NR  ||
245             _IOC_NR(cmd) > IOC_LIBCFS_MAX_NR) {
246                 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
247                        _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
248                 return -EINVAL;
249         }
250
251         return libcfs_ioctl(cmd, (void __user *)arg);
252 }
253
254 static const struct file_operations libcfs_fops = {
255         .owner                  = THIS_MODULE,
256         .unlocked_ioctl         = libcfs_psdev_ioctl,
257 };
258
259 static struct miscdevice libcfs_dev = {
260         .minor                  = MISC_DYNAMIC_MINOR,
261         .name                   = "lnet",
262         .fops                   = &libcfs_fops,
263 };
264
265 int lprocfs_call_handler(void *data, int write, loff_t *ppos,
266                          void __user *buffer, size_t *lenp,
267                          int (*handler)(void *data, int write, loff_t pos,
268                                         void __user *buffer, int len))
269 {
270         int rc = handler(data, write, *ppos, buffer, *lenp);
271
272         if (rc < 0)
273                 return rc;
274
275         if (write) {
276                 *ppos += *lenp;
277         } else {
278                 *lenp = rc;
279                 *ppos += rc;
280         }
281         return 0;
282 }
283 EXPORT_SYMBOL(lprocfs_call_handler);
284
285 static int __proc_dobitmasks(void *data, int write,
286                              loff_t pos, void __user *buffer, int nob)
287 {
288         const int     tmpstrlen = 512;
289         char         *tmpstr;
290         int           rc;
291         unsigned int *mask = data;
292         int           is_subsys = (mask == &libcfs_subsystem_debug) ? 1 : 0;
293         int           is_printk = (mask == &libcfs_printk) ? 1 : 0;
294
295         rc = cfs_trace_allocate_string_buffer(&tmpstr, tmpstrlen);
296         if (rc < 0)
297                 return rc;
298
299         if (!write) {
300                 libcfs_debug_mask2str(tmpstr, tmpstrlen, *mask, is_subsys);
301                 rc = strlen(tmpstr);
302
303                 if (pos >= rc) {
304                         rc = 0;
305                 } else {
306                         rc = cfs_trace_copyout_string(buffer, nob,
307                                                       tmpstr + pos, "\n");
308                 }
309         } else {
310                 rc = cfs_trace_copyin_string(tmpstr, tmpstrlen, buffer, nob);
311                 if (rc < 0) {
312                         kfree(tmpstr);
313                         return rc;
314                 }
315
316                 rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
317                 /* Always print LBUG/LASSERT to console, so keep this mask */
318                 if (is_printk)
319                         *mask |= D_EMERG;
320         }
321
322         kfree(tmpstr);
323         return rc;
324 }
325
326 static int proc_dobitmasks(struct ctl_table *table, int write,
327                            void __user *buffer, size_t *lenp, loff_t *ppos)
328 {
329         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
330                                     __proc_dobitmasks);
331 }
332
333 static int min_watchdog_ratelimit;              /* disable ratelimiting */
334 static int max_watchdog_ratelimit = (24*60*60); /* limit to once per day */
335
336 static int __proc_dump_kernel(void *data, int write,
337                               loff_t pos, void __user *buffer, int nob)
338 {
339         if (!write)
340                 return 0;
341
342         return cfs_trace_dump_debug_buffer_usrstr(buffer, nob);
343 }
344
345 static int proc_dump_kernel(struct ctl_table *table, int write,
346                             void __user *buffer, size_t *lenp, loff_t *ppos)
347 {
348         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
349                                     __proc_dump_kernel);
350 }
351
352 static int __proc_daemon_file(void *data, int write,
353                               loff_t pos, void __user *buffer, int nob)
354 {
355         if (!write) {
356                 int len = strlen(cfs_tracefile);
357
358                 if (pos >= len)
359                         return 0;
360
361                 return cfs_trace_copyout_string(buffer, nob,
362                                                 cfs_tracefile + pos, "\n");
363         }
364
365         return cfs_trace_daemon_command_usrstr(buffer, nob);
366 }
367
368 static int proc_daemon_file(struct ctl_table *table, int write,
369                             void __user *buffer, size_t *lenp, loff_t *ppos)
370 {
371         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
372                                     __proc_daemon_file);
373 }
374
375 static int libcfs_force_lbug(struct ctl_table *table, int write,
376                              void __user *buffer,
377                              size_t *lenp, loff_t *ppos)
378 {
379         if (write)
380                 LBUG();
381         return 0;
382 }
383
384 static int proc_fail_loc(struct ctl_table *table, int write,
385                          void __user *buffer, size_t *lenp, loff_t *ppos)
386 {
387         int rc;
388         long old_fail_loc = cfs_fail_loc;
389
390         rc = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
391         if (old_fail_loc != cfs_fail_loc)
392                 wake_up(&cfs_race_waitq);
393         return rc;
394 }
395
396 static int __proc_cpt_table(void *data, int write,
397                             loff_t pos, void __user *buffer, int nob)
398 {
399         char *buf = NULL;
400         int   len = 4096;
401         int   rc  = 0;
402
403         if (write)
404                 return -EPERM;
405
406         LASSERT(cfs_cpt_table != NULL);
407
408         while (1) {
409                 LIBCFS_ALLOC(buf, len);
410                 if (buf == NULL)
411                         return -ENOMEM;
412
413                 rc = cfs_cpt_table_print(cfs_cpt_table, buf, len);
414                 if (rc >= 0)
415                         break;
416
417                 if (rc == -EFBIG) {
418                         LIBCFS_FREE(buf, len);
419                         len <<= 1;
420                         continue;
421                 }
422                 goto out;
423         }
424
425         if (pos >= rc) {
426                 rc = 0;
427                 goto out;
428         }
429
430         rc = cfs_trace_copyout_string(buffer, nob, buf + pos, NULL);
431 out:
432         if (buf != NULL)
433                 LIBCFS_FREE(buf, len);
434         return rc;
435 }
436
437 static int proc_cpt_table(struct ctl_table *table, int write,
438                           void __user *buffer, size_t *lenp, loff_t *ppos)
439 {
440         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
441                                     __proc_cpt_table);
442 }
443
444 static int __proc_cpt_distance(void *data, int write,
445                                loff_t pos, void __user *buffer, int nob)
446 {
447         char *buf = NULL;
448         int   len = 4096;
449         int   rc  = 0;
450
451         if (write)
452                 return -EPERM;
453
454         LASSERT(cfs_cpt_table != NULL);
455
456         while (1) {
457                 LIBCFS_ALLOC(buf, len);
458                 if (buf == NULL)
459                         return -ENOMEM;
460
461                 rc = cfs_cpt_distance_print(cfs_cpt_table, buf, len);
462                 if (rc >= 0)
463                         break;
464
465                 if (rc == -EFBIG) {
466                         LIBCFS_FREE(buf, len);
467                         len <<= 1;
468                         continue;
469                 }
470                 goto out;
471         }
472
473         if (pos >= rc) {
474                 rc = 0;
475                 goto out;
476         }
477
478         rc = cfs_trace_copyout_string(buffer, nob, buf + pos, NULL);
479  out:
480         if (buf != NULL)
481                 LIBCFS_FREE(buf, len);
482         return rc;
483 }
484
485 static int proc_cpt_distance(struct ctl_table *table, int write,
486                              void __user *buffer, size_t *lenp, loff_t *ppos)
487 {
488         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
489                                      __proc_cpt_distance);
490 }
491
492 static struct ctl_table lnet_table[] = {
493         {
494                 .procname       = "debug",
495                 .data           = &libcfs_debug,
496                 .maxlen         = sizeof(int),
497                 .mode           = 0644,
498                 .proc_handler   = &proc_dobitmasks,
499         },
500         {
501                 .procname       = "subsystem_debug",
502                 .data           = &libcfs_subsystem_debug,
503                 .maxlen         = sizeof(int),
504                 .mode           = 0644,
505                 .proc_handler   = &proc_dobitmasks,
506         },
507         {
508                 .procname       = "printk",
509                 .data           = &libcfs_printk,
510                 .maxlen         = sizeof(int),
511                 .mode           = 0644,
512                 .proc_handler   = &proc_dobitmasks,
513         },
514         {
515                 .procname       = "cpu_partition_table",
516                 .maxlen         = 128,
517                 .mode           = 0444,
518                 .proc_handler   = &proc_cpt_table,
519         },
520         {
521                 .procname       = "cpu_partition_distance",
522                 .maxlen         = 128,
523                 .mode           = 0444,
524                 .proc_handler   = &proc_cpt_distance,
525         },
526         {
527                 .procname       = "debug_log_upcall",
528                 .data           = lnet_debug_log_upcall,
529                 .maxlen         = sizeof(lnet_debug_log_upcall),
530                 .mode           = 0644,
531                 .proc_handler   = &proc_dostring,
532         },
533         {
534                 .procname       = "lnet_memused",
535                 .data           = (int *)&libcfs_kmemory.counter,
536                 .maxlen         = sizeof(int),
537                 .mode           = 0444,
538                 .proc_handler   = &proc_dointvec,
539         },
540         {
541                 .procname       = "catastrophe",
542                 .data           = &libcfs_catastrophe,
543                 .maxlen         = sizeof(int),
544                 .mode           = 0444,
545                 .proc_handler   = &proc_dointvec,
546         },
547         {
548                 .procname       = "dump_kernel",
549                 .maxlen         = 256,
550                 .mode           = 0200,
551                 .proc_handler   = &proc_dump_kernel,
552         },
553         {
554                 .procname       = "daemon_file",
555                 .mode           = 0644,
556                 .maxlen         = 256,
557                 .proc_handler   = &proc_daemon_file,
558         },
559         {
560                 .procname       = "watchdog_ratelimit",
561                 .data           = &libcfs_watchdog_ratelimit,
562                 .maxlen         = sizeof(int),
563                 .mode           = 0644,
564                 .proc_handler   = &proc_dointvec_minmax,
565                 .extra1         = &min_watchdog_ratelimit,
566                 .extra2         = &max_watchdog_ratelimit,
567         },
568         {
569                 .procname       = "force_lbug",
570                 .data           = NULL,
571                 .maxlen         = 0,
572                 .mode           = 0200,
573                 .proc_handler   = &libcfs_force_lbug
574         },
575         {
576                 .procname       = "fail_loc",
577                 .data           = &cfs_fail_loc,
578                 .maxlen         = sizeof(cfs_fail_loc),
579                 .mode           = 0644,
580                 .proc_handler   = &proc_fail_loc
581         },
582         {
583                 .procname       = "fail_val",
584                 .data           = &cfs_fail_val,
585                 .maxlen         = sizeof(int),
586                 .mode           = 0644,
587                 .proc_handler   = &proc_dointvec
588         },
589         {
590                 .procname       = "fail_err",
591                 .data           = &cfs_fail_err,
592                 .maxlen         = sizeof(cfs_fail_err),
593                 .mode           = 0644,
594                 .proc_handler   = &proc_dointvec,
595         },
596         {
597         }
598 };
599
600 static const struct lnet_debugfs_symlink_def lnet_debugfs_symlinks[] = {
601         { .name         = "console_ratelimit",
602           .target       = "../../../module/libcfs/parameters/libcfs_console_ratelimit" },
603         { .name         = "debug_path",
604           .target       = "../../../module/libcfs/parameters/libcfs_debug_file_path" },
605         { .name         = "panic_on_lbug",
606           .target       = "../../../module/libcfs/parameters/libcfs_panic_on_lbug" },
607         { .name         = "console_backoff",
608           .target       = "../../../module/libcfs/parameters/libcfs_console_backoff" },
609         { .name         = "debug_mb",
610           .target       = "../../../module/libcfs/parameters/libcfs_debug_mb" },
611         { .name         = "console_min_delay_centisecs",
612           .target       = "../../../module/libcfs/parameters/libcfs_console_min_delay" },
613         { .name         = "console_max_delay_centisecs",
614           .target       = "../../../module/libcfs/parameters/libcfs_console_max_delay" },
615         { .name         = NULL },
616 };
617
618 static ssize_t lnet_debugfs_read(struct file *filp, char __user *buf,
619                                  size_t count, loff_t *ppos)
620 {
621         struct ctl_table *table = filp->private_data;
622         ssize_t rc = -EINVAL;
623
624         if (table) {
625                 rc = table->proc_handler(table, 0, buf, &count, ppos);
626                 if (!rc)
627                         rc = count;
628         }
629
630         return rc;
631 }
632
633 static ssize_t lnet_debugfs_write(struct file *filp, const char __user *buf,
634                                   size_t count, loff_t *ppos)
635 {
636         struct ctl_table *table = filp->private_data;
637         ssize_t rc = -EINVAL;
638
639         if (table) {
640                 rc = table->proc_handler(table, 1, (void __user *)buf, &count,
641                                          ppos);
642                 if (!rc)
643                         rc = count;
644         }
645
646         return rc;
647 }
648
649 static const struct file_operations lnet_debugfs_file_operations_rw = {
650         .open           = simple_open,
651         .read           = lnet_debugfs_read,
652         .write          = lnet_debugfs_write,
653         .llseek         = default_llseek,
654 };
655
656 static const struct file_operations lnet_debugfs_file_operations_ro = {
657         .open           = simple_open,
658         .read           = lnet_debugfs_read,
659         .llseek         = default_llseek,
660 };
661
662 static const struct file_operations lnet_debugfs_file_operations_wo = {
663         .open           = simple_open,
664         .write          = lnet_debugfs_write,
665         .llseek         = default_llseek,
666 };
667
668 static const struct file_operations *lnet_debugfs_fops_select(umode_t mode)
669 {
670         if (!(mode & S_IWUGO))
671                 return &lnet_debugfs_file_operations_ro;
672
673         if (!(mode & S_IRUGO))
674                 return &lnet_debugfs_file_operations_wo;
675
676         return &lnet_debugfs_file_operations_rw;
677 }
678
679 void lnet_insert_debugfs(struct ctl_table *table)
680 {
681         if (!lnet_debugfs_root)
682                 lnet_debugfs_root = debugfs_create_dir("lnet", NULL);
683
684         /* Even if we cannot create, just ignore it altogether) */
685         if (IS_ERR_OR_NULL(lnet_debugfs_root))
686                 return;
687
688         /* We don't save the dentry returned in next two calls, because
689          * we don't call debugfs_remove() but rather remove_recursive()
690          */
691         for (; table && table->procname; table++)
692                 debugfs_create_file(table->procname, table->mode,
693                                     lnet_debugfs_root, table,
694                                     lnet_debugfs_fops_select(table->mode));
695 }
696 EXPORT_SYMBOL_GPL(lnet_insert_debugfs);
697
698 static void lnet_insert_debugfs_links(
699                 const struct lnet_debugfs_symlink_def *symlinks)
700 {
701         for (; symlinks && symlinks->name; symlinks++)
702                 debugfs_create_symlink(symlinks->name, lnet_debugfs_root,
703                                        symlinks->target);
704 }
705
706 void lnet_remove_debugfs(struct ctl_table *table)
707 {
708         for (; table && table->procname; table++) {
709                 struct qstr dname = QSTR_INIT(table->procname,
710                                               strlen(table->procname));
711                 struct dentry *dentry;
712
713                 dentry = d_hash_and_lookup(lnet_debugfs_root, &dname);
714                 debugfs_remove(dentry);
715         }
716 }
717 EXPORT_SYMBOL_GPL(lnet_remove_debugfs);
718
719 static int __init libcfs_init(void)
720 {
721         int rc;
722
723 #ifndef HAVE_WAIT_VAR_EVENT
724         wait_bit_init();
725 #endif
726         rc = libcfs_debug_init(5 * 1024 * 1024);
727         if (rc < 0) {
728                 pr_err("LustreError: libcfs_debug_init: rc = %d\n", rc);
729                 return (rc);
730         }
731
732         rc = cfs_cpu_init();
733         if (rc != 0)
734                 goto cleanup_debug;
735
736         rc = misc_register(&libcfs_dev);
737         if (rc) {
738                 CERROR("misc_register: error %d\n", rc);
739                 goto cleanup_cpu;
740         }
741
742         rc = cfs_wi_startup();
743         if (rc) {
744                 CERROR("initialize workitem: error %d\n", rc);
745                 goto cleanup_deregister;
746         }
747
748         cfs_rehash_wq = alloc_workqueue("cfs_rh", WQ_SYSFS, 4);
749         if (!cfs_rehash_wq) {
750                 rc = -ENOMEM;
751                 CERROR("libcfs: failed to start rehash workqueue: rc = %d\n",
752                        rc);
753                 goto cleanup_deregister;
754         }
755
756         rc = cfs_crypto_register();
757         if (rc) {
758                 CERROR("cfs_crypto_regster: error %d\n", rc);
759                 goto cleanup_wi;
760         }
761
762         lnet_insert_debugfs(lnet_table);
763         if (!IS_ERR_OR_NULL(lnet_debugfs_root))
764                 lnet_insert_debugfs_links(lnet_debugfs_symlinks);
765
766         CDEBUG (D_OTHER, "portals setup OK\n");
767         return 0;
768 cleanup_wi:
769         cfs_wi_shutdown();
770 cleanup_deregister:
771         misc_deregister(&libcfs_dev);
772 cleanup_cpu:
773         cfs_cpu_fini();
774 cleanup_debug:
775         libcfs_debug_cleanup();
776         return rc;
777 }
778
779 static void __exit libcfs_exit(void)
780 {
781         int rc;
782
783         /* Remove everthing */
784         debugfs_remove_recursive(lnet_debugfs_root);
785         lnet_debugfs_root = NULL;
786
787         CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
788                atomic_read(&libcfs_kmemory));
789
790         if (cfs_rehash_wq) {
791                 destroy_workqueue(cfs_rehash_wq);
792                 cfs_rehash_wq = NULL;
793         }
794
795         cfs_crypto_unregister();
796         cfs_wi_shutdown();
797
798         misc_deregister(&libcfs_dev);
799
800         cfs_cpu_fini();
801
802         /* the below message is checked in test-framework.sh check_mem_leak() */
803         if (atomic_read(&libcfs_kmemory) != 0)
804                 CERROR("Portals memory leaked: %d bytes\n",
805                        atomic_read(&libcfs_kmemory));
806
807         rc = libcfs_debug_cleanup();
808         if (rc)
809                 pr_err("LustreError: libcfs_debug_cleanup: rc = %d\n", rc);
810 }
811
812 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
813 MODULE_DESCRIPTION("Lustre helper library");
814 MODULE_VERSION(LIBCFS_VERSION);
815 MODULE_LICENSE("GPL");
816
817 module_init(libcfs_init);
818 module_exit(libcfs_exit);