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, 2015 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/module.h>
33 #include <linux/kernel.h>
34 #include <linux/mm.h>
35 #include <linux/string.h>
36 #include <linux/stat.h>
37 #include <linux/errno.h>
38 #include <linux/unistd.h>
39 #include <net/sock.h>
40 #include <linux/uio.h>
41
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
51 # define DEBUG_SUBSYSTEM S_LNET
52
53 #include "../../include/linux/libcfs/libcfs.h"
54 #include <asm/div64.h>
55
56 #include "../../include/linux/libcfs/libcfs_crypto.h"
57 #include "../../include/linux/lnet/lib-lnet.h"
58 #include "../../include/linux/lnet/lib-dlc.h"
59 #include "../../include/linux/lnet/lnet.h"
60 #include "tracefile.h"
61
62 static struct dentry *lnet_debugfs_root;
63
64 static DECLARE_RWSEM(ioctl_list_sem);
65 static LIST_HEAD(ioctl_list);
66
libcfs_register_ioctl(struct libcfs_ioctl_handler * hand)67 int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
68 {
69 int rc = 0;
70
71 down_write(&ioctl_list_sem);
72 if (!list_empty(&hand->item))
73 rc = -EBUSY;
74 else
75 list_add_tail(&hand->item, &ioctl_list);
76 up_write(&ioctl_list_sem);
77
78 return rc;
79 }
80 EXPORT_SYMBOL(libcfs_register_ioctl);
81
libcfs_deregister_ioctl(struct libcfs_ioctl_handler * hand)82 int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand)
83 {
84 int rc = 0;
85
86 down_write(&ioctl_list_sem);
87 if (list_empty(&hand->item))
88 rc = -ENOENT;
89 else
90 list_del_init(&hand->item);
91 up_write(&ioctl_list_sem);
92
93 return rc;
94 }
95 EXPORT_SYMBOL(libcfs_deregister_ioctl);
96
libcfs_ioctl(unsigned long cmd,void __user * uparam)97 int libcfs_ioctl(unsigned long cmd, void __user *uparam)
98 {
99 struct libcfs_ioctl_data *data = NULL;
100 struct libcfs_ioctl_hdr *hdr;
101 int err;
102
103 /* 'cmd' and permissions get checked in our arch-specific caller */
104 err = libcfs_ioctl_getdata(&hdr, uparam);
105 if (err) {
106 CDEBUG_LIMIT(D_ERROR,
107 "libcfs ioctl: data header error %d\n", err);
108 return err;
109 }
110
111 if (hdr->ioc_version == LIBCFS_IOCTL_VERSION) {
112 /*
113 * The libcfs_ioctl_data_adjust() function performs adjustment
114 * operations on the libcfs_ioctl_data structure to make
115 * it usable by the code. This doesn't need to be called
116 * for new data structures added.
117 */
118 data = container_of(hdr, struct libcfs_ioctl_data, ioc_hdr);
119 err = libcfs_ioctl_data_adjust(data);
120 if (err)
121 goto out;
122 }
123
124 CDEBUG(D_IOCTL, "libcfs ioctl cmd %lu\n", cmd);
125 switch (cmd) {
126 case IOC_LIBCFS_CLEAR_DEBUG:
127 libcfs_debug_clear_buffer();
128 break;
129
130 case IOC_LIBCFS_MARK_DEBUG:
131 if (!data || !data->ioc_inlbuf1 ||
132 data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0') {
133 err = -EINVAL;
134 goto out;
135 }
136 libcfs_debug_mark_buffer(data->ioc_inlbuf1);
137 break;
138
139 default: {
140 struct libcfs_ioctl_handler *hand;
141
142 err = -EINVAL;
143 down_read(&ioctl_list_sem);
144 list_for_each_entry(hand, &ioctl_list, item) {
145 err = hand->handle_ioctl(cmd, hdr);
146 if (err == -EINVAL)
147 continue;
148
149 if (!err) {
150 if (copy_to_user(uparam, hdr, hdr->ioc_len))
151 err = -EFAULT;
152 }
153 break;
154 }
155 up_read(&ioctl_list_sem);
156 break; }
157 }
158 out:
159 LIBCFS_FREE(hdr, hdr->ioc_len);
160 return err;
161 }
162
lprocfs_call_handler(void * data,int write,loff_t * ppos,void __user * buffer,size_t * lenp,int (* handler)(void * data,int write,loff_t pos,void __user * buffer,int len))163 int lprocfs_call_handler(void *data, int write, loff_t *ppos,
164 void __user *buffer, size_t *lenp,
165 int (*handler)(void *data, int write, loff_t pos,
166 void __user *buffer, int len))
167 {
168 int rc = handler(data, write, *ppos, buffer, *lenp);
169
170 if (rc < 0)
171 return rc;
172
173 if (write) {
174 *ppos += *lenp;
175 } else {
176 *lenp = rc;
177 *ppos += rc;
178 }
179 return 0;
180 }
181 EXPORT_SYMBOL(lprocfs_call_handler);
182
__proc_dobitmasks(void * data,int write,loff_t pos,void __user * buffer,int nob)183 static int __proc_dobitmasks(void *data, int write,
184 loff_t pos, void __user *buffer, int nob)
185 {
186 const int tmpstrlen = 512;
187 char *tmpstr;
188 int rc;
189 unsigned int *mask = data;
190 int is_subsys = (mask == &libcfs_subsystem_debug) ? 1 : 0;
191 int is_printk = (mask == &libcfs_printk) ? 1 : 0;
192
193 rc = cfs_trace_allocate_string_buffer(&tmpstr, tmpstrlen);
194 if (rc < 0)
195 return rc;
196
197 if (!write) {
198 libcfs_debug_mask2str(tmpstr, tmpstrlen, *mask, is_subsys);
199 rc = strlen(tmpstr);
200
201 if (pos >= rc) {
202 rc = 0;
203 } else {
204 rc = cfs_trace_copyout_string(buffer, nob,
205 tmpstr + pos, "\n");
206 }
207 } else {
208 rc = cfs_trace_copyin_string(tmpstr, tmpstrlen, buffer, nob);
209 if (rc < 0) {
210 kfree(tmpstr);
211 return rc;
212 }
213
214 rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
215 /* Always print LBUG/LASSERT to console, so keep this mask */
216 if (is_printk)
217 *mask |= D_EMERG;
218 }
219
220 kfree(tmpstr);
221 return rc;
222 }
223
proc_dobitmasks(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)224 static int proc_dobitmasks(struct ctl_table *table, int write,
225 void __user *buffer, size_t *lenp, loff_t *ppos)
226 {
227 return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
228 __proc_dobitmasks);
229 }
230
__proc_dump_kernel(void * data,int write,loff_t pos,void __user * buffer,int nob)231 static int __proc_dump_kernel(void *data, int write,
232 loff_t pos, void __user *buffer, int nob)
233 {
234 if (!write)
235 return 0;
236
237 return cfs_trace_dump_debug_buffer_usrstr(buffer, nob);
238 }
239
proc_dump_kernel(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)240 static int proc_dump_kernel(struct ctl_table *table, int write,
241 void __user *buffer, size_t *lenp, loff_t *ppos)
242 {
243 return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
244 __proc_dump_kernel);
245 }
246
__proc_daemon_file(void * data,int write,loff_t pos,void __user * buffer,int nob)247 static int __proc_daemon_file(void *data, int write,
248 loff_t pos, void __user *buffer, int nob)
249 {
250 if (!write) {
251 int len = strlen(cfs_tracefile);
252
253 if (pos >= len)
254 return 0;
255
256 return cfs_trace_copyout_string(buffer, nob,
257 cfs_tracefile + pos, "\n");
258 }
259
260 return cfs_trace_daemon_command_usrstr(buffer, nob);
261 }
262
proc_daemon_file(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)263 static int proc_daemon_file(struct ctl_table *table, int write,
264 void __user *buffer, size_t *lenp, loff_t *ppos)
265 {
266 return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
267 __proc_daemon_file);
268 }
269
libcfs_force_lbug(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)270 static int libcfs_force_lbug(struct ctl_table *table, int write,
271 void __user *buffer,
272 size_t *lenp, loff_t *ppos)
273 {
274 if (write)
275 LBUG();
276 return 0;
277 }
278
proc_fail_loc(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)279 static int proc_fail_loc(struct ctl_table *table, int write,
280 void __user *buffer,
281 size_t *lenp, loff_t *ppos)
282 {
283 int rc;
284 long old_fail_loc = cfs_fail_loc;
285
286 rc = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
287 if (old_fail_loc != cfs_fail_loc)
288 wake_up(&cfs_race_waitq);
289 return rc;
290 }
291
__proc_cpt_table(void * data,int write,loff_t pos,void __user * buffer,int nob)292 static int __proc_cpt_table(void *data, int write,
293 loff_t pos, void __user *buffer, int nob)
294 {
295 char *buf = NULL;
296 int len = 4096;
297 int rc = 0;
298
299 if (write)
300 return -EPERM;
301
302 LASSERT(cfs_cpt_table);
303
304 while (1) {
305 LIBCFS_ALLOC(buf, len);
306 if (!buf)
307 return -ENOMEM;
308
309 rc = cfs_cpt_table_print(cfs_cpt_table, buf, len);
310 if (rc >= 0)
311 break;
312
313 if (rc == -EFBIG) {
314 LIBCFS_FREE(buf, len);
315 len <<= 1;
316 continue;
317 }
318 goto out;
319 }
320
321 if (pos >= rc) {
322 rc = 0;
323 goto out;
324 }
325
326 rc = cfs_trace_copyout_string(buffer, nob, buf + pos, NULL);
327 out:
328 if (buf)
329 LIBCFS_FREE(buf, len);
330 return rc;
331 }
332
proc_cpt_table(struct ctl_table * table,int write,void __user * buffer,size_t * lenp,loff_t * ppos)333 static int proc_cpt_table(struct ctl_table *table, int write,
334 void __user *buffer, size_t *lenp, loff_t *ppos)
335 {
336 return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
337 __proc_cpt_table);
338 }
339
340 static struct ctl_table lnet_table[] = {
341 {
342 .procname = "debug",
343 .data = &libcfs_debug,
344 .maxlen = sizeof(int),
345 .mode = 0644,
346 .proc_handler = &proc_dobitmasks,
347 },
348 {
349 .procname = "subsystem_debug",
350 .data = &libcfs_subsystem_debug,
351 .maxlen = sizeof(int),
352 .mode = 0644,
353 .proc_handler = &proc_dobitmasks,
354 },
355 {
356 .procname = "printk",
357 .data = &libcfs_printk,
358 .maxlen = sizeof(int),
359 .mode = 0644,
360 .proc_handler = &proc_dobitmasks,
361 },
362 {
363 .procname = "cpu_partition_table",
364 .maxlen = 128,
365 .mode = 0444,
366 .proc_handler = &proc_cpt_table,
367 },
368
369 {
370 .procname = "upcall",
371 .data = lnet_upcall,
372 .maxlen = sizeof(lnet_upcall),
373 .mode = 0644,
374 .proc_handler = &proc_dostring,
375 },
376 {
377 .procname = "debug_log_upcall",
378 .data = lnet_debug_log_upcall,
379 .maxlen = sizeof(lnet_debug_log_upcall),
380 .mode = 0644,
381 .proc_handler = &proc_dostring,
382 },
383 {
384 .procname = "catastrophe",
385 .data = &libcfs_catastrophe,
386 .maxlen = sizeof(int),
387 .mode = 0444,
388 .proc_handler = &proc_dointvec,
389 },
390 {
391 .procname = "dump_kernel",
392 .maxlen = 256,
393 .mode = 0200,
394 .proc_handler = &proc_dump_kernel,
395 },
396 {
397 .procname = "daemon_file",
398 .mode = 0644,
399 .maxlen = 256,
400 .proc_handler = &proc_daemon_file,
401 },
402 {
403 .procname = "force_lbug",
404 .data = NULL,
405 .maxlen = 0,
406 .mode = 0200,
407 .proc_handler = &libcfs_force_lbug
408 },
409 {
410 .procname = "fail_loc",
411 .data = &cfs_fail_loc,
412 .maxlen = sizeof(cfs_fail_loc),
413 .mode = 0644,
414 .proc_handler = &proc_fail_loc
415 },
416 {
417 .procname = "fail_val",
418 .data = &cfs_fail_val,
419 .maxlen = sizeof(int),
420 .mode = 0644,
421 .proc_handler = &proc_dointvec
422 },
423 {
424 .procname = "fail_err",
425 .data = &cfs_fail_err,
426 .maxlen = sizeof(cfs_fail_err),
427 .mode = 0644,
428 .proc_handler = &proc_dointvec,
429 },
430 {
431 }
432 };
433
434 static const struct lnet_debugfs_symlink_def lnet_debugfs_symlinks[] = {
435 { "console_ratelimit",
436 "/sys/module/libcfs/parameters/libcfs_console_ratelimit"},
437 { "debug_path",
438 "/sys/module/libcfs/parameters/libcfs_debug_file_path"},
439 { "panic_on_lbug",
440 "/sys/module/libcfs/parameters/libcfs_panic_on_lbug"},
441 { "libcfs_console_backoff",
442 "/sys/module/libcfs/parameters/libcfs_console_backoff"},
443 { "debug_mb",
444 "/sys/module/libcfs/parameters/libcfs_debug_mb"},
445 { "console_min_delay_centisecs",
446 "/sys/module/libcfs/parameters/libcfs_console_min_delay"},
447 { "console_max_delay_centisecs",
448 "/sys/module/libcfs/parameters/libcfs_console_max_delay"},
449 {},
450 };
451
lnet_debugfs_read(struct file * filp,char __user * buf,size_t count,loff_t * ppos)452 static ssize_t lnet_debugfs_read(struct file *filp, char __user *buf,
453 size_t count, loff_t *ppos)
454 {
455 struct ctl_table *table = filp->private_data;
456 int error;
457
458 error = table->proc_handler(table, 0, (void __user *)buf, &count, ppos);
459 if (!error)
460 error = count;
461
462 return error;
463 }
464
lnet_debugfs_write(struct file * filp,const char __user * buf,size_t count,loff_t * ppos)465 static ssize_t lnet_debugfs_write(struct file *filp, const char __user *buf,
466 size_t count, loff_t *ppos)
467 {
468 struct ctl_table *table = filp->private_data;
469 int error;
470
471 error = table->proc_handler(table, 1, (void __user *)buf, &count, ppos);
472 if (!error)
473 error = count;
474
475 return error;
476 }
477
478 static const struct file_operations lnet_debugfs_file_operations_rw = {
479 .open = simple_open,
480 .read = lnet_debugfs_read,
481 .write = lnet_debugfs_write,
482 .llseek = default_llseek,
483 };
484
485 static const struct file_operations lnet_debugfs_file_operations_ro = {
486 .open = simple_open,
487 .read = lnet_debugfs_read,
488 .llseek = default_llseek,
489 };
490
491 static const struct file_operations lnet_debugfs_file_operations_wo = {
492 .open = simple_open,
493 .write = lnet_debugfs_write,
494 .llseek = default_llseek,
495 };
496
lnet_debugfs_fops_select(umode_t mode)497 static const struct file_operations *lnet_debugfs_fops_select(umode_t mode)
498 {
499 if (!(mode & S_IWUGO))
500 return &lnet_debugfs_file_operations_ro;
501
502 if (!(mode & S_IRUGO))
503 return &lnet_debugfs_file_operations_wo;
504
505 return &lnet_debugfs_file_operations_rw;
506 }
507
lustre_insert_debugfs(struct ctl_table * table,const struct lnet_debugfs_symlink_def * symlinks)508 void lustre_insert_debugfs(struct ctl_table *table,
509 const struct lnet_debugfs_symlink_def *symlinks)
510 {
511 if (!lnet_debugfs_root)
512 lnet_debugfs_root = debugfs_create_dir("lnet", NULL);
513
514 /* Even if we cannot create, just ignore it altogether) */
515 if (IS_ERR_OR_NULL(lnet_debugfs_root))
516 return;
517
518 /* We don't save the dentry returned in next two calls, because
519 * we don't call debugfs_remove() but rather remove_recursive()
520 */
521 for (; table->procname; table++)
522 debugfs_create_file(table->procname, table->mode,
523 lnet_debugfs_root, table,
524 lnet_debugfs_fops_select(table->mode));
525
526 for (; symlinks && symlinks->name; symlinks++)
527 debugfs_create_symlink(symlinks->name, lnet_debugfs_root,
528 symlinks->target);
529 }
530 EXPORT_SYMBOL_GPL(lustre_insert_debugfs);
531
lustre_remove_debugfs(void)532 static void lustre_remove_debugfs(void)
533 {
534 debugfs_remove_recursive(lnet_debugfs_root);
535
536 lnet_debugfs_root = NULL;
537 }
538
libcfs_init(void)539 static int libcfs_init(void)
540 {
541 int rc;
542
543 rc = libcfs_debug_init(5 * 1024 * 1024);
544 if (rc < 0) {
545 pr_err("LustreError: libcfs_debug_init: %d\n", rc);
546 return rc;
547 }
548
549 rc = cfs_cpu_init();
550 if (rc != 0)
551 goto cleanup_debug;
552
553 rc = misc_register(&libcfs_dev);
554 if (rc) {
555 CERROR("misc_register: error %d\n", rc);
556 goto cleanup_cpu;
557 }
558
559 rc = cfs_wi_startup();
560 if (rc) {
561 CERROR("initialize workitem: error %d\n", rc);
562 goto cleanup_deregister;
563 }
564
565 /* max to 4 threads, should be enough for rehash */
566 rc = min(cfs_cpt_weight(cfs_cpt_table, CFS_CPT_ANY), 4);
567 rc = cfs_wi_sched_create("cfs_rh", cfs_cpt_table, CFS_CPT_ANY,
568 rc, &cfs_sched_rehash);
569 if (rc != 0) {
570 CERROR("Startup workitem scheduler: error: %d\n", rc);
571 goto cleanup_deregister;
572 }
573
574 rc = cfs_crypto_register();
575 if (rc) {
576 CERROR("cfs_crypto_register: error %d\n", rc);
577 goto cleanup_wi;
578 }
579
580 lustre_insert_debugfs(lnet_table, lnet_debugfs_symlinks);
581
582 CDEBUG(D_OTHER, "portals setup OK\n");
583 return 0;
584 cleanup_wi:
585 cfs_wi_shutdown();
586 cleanup_deregister:
587 misc_deregister(&libcfs_dev);
588 cleanup_cpu:
589 cfs_cpu_fini();
590 cleanup_debug:
591 libcfs_debug_cleanup();
592 return rc;
593 }
594
libcfs_exit(void)595 static void libcfs_exit(void)
596 {
597 int rc;
598
599 lustre_remove_debugfs();
600
601 if (cfs_sched_rehash) {
602 cfs_wi_sched_destroy(cfs_sched_rehash);
603 cfs_sched_rehash = NULL;
604 }
605
606 cfs_crypto_unregister();
607 cfs_wi_shutdown();
608
609 misc_deregister(&libcfs_dev);
610
611 cfs_cpu_fini();
612
613 rc = libcfs_debug_cleanup();
614 if (rc)
615 pr_err("LustreError: libcfs_debug_cleanup: %d\n", rc);
616 }
617
618 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
619 MODULE_DESCRIPTION("Lustre helper library");
620 MODULE_VERSION(LIBCFS_VERSION);
621 MODULE_LICENSE("GPL");
622
623 module_init(libcfs_init);
624 module_exit(libcfs_exit);
625