Whamcloud - gitweb
update patchless client for support 2.6.20, 2.6.21 and RHEL5 kernels.
[fs/lustre-release.git] / lnet / libcfs / linux / linux-proc.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
5  *   Author: Zach Brown <zab@zabbo.net>
6  *   Author: Peter J. Braam <braam@clusterfs.com>
7  *   Author: Phil Schwan <phil@clusterfs.com>
8  *
9  *   This file is part of Lustre, http://www.lustre.org.
10  *
11  *   Lustre is free software; you can redistribute it and/or
12  *   modify it under the terms of version 2 of the GNU General Public
13  *   License as published by the Free Software Foundation.
14  *
15  *   Lustre is distributed in the hope that it will be useful,
16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *   GNU General Public License for more details.
19  *
20  *   You should have received a copy of the GNU General Public License
21  *   along with Lustre; if not, write to the Free Software
22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 #ifndef EXPORT_SYMTAB
26 # define EXPORT_SYMTAB
27 #endif
28
29 #ifdef HAVE_KERNEL_CONFIG_H
30 #include <linux/config.h>
31 #endif
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/smp_lock.h>
39 #include <linux/unistd.h>
40 #include <net/sock.h>
41 #include <linux/uio.h>
42
43 #include <asm/system.h>
44 #include <asm/uaccess.h>
45
46 #include <linux/fs.h>
47 #include <linux/file.h>
48 #include <linux/stat.h>
49 #include <linux/list.h>
50 #include <asm/uaccess.h>
51 #include <asm/segment.h>
52
53 #include <linux/proc_fs.h>
54 #include <linux/sysctl.h>
55
56 # define DEBUG_SUBSYSTEM S_LNET
57
58 #include <libcfs/kp30.h>
59 #include <asm/div64.h>
60 #include "tracefile.h"
61
62 static struct ctl_table_header *lnet_table_header = NULL;
63 extern char lnet_upcall[1024];
64
65 #define PSDEV_LNET  (0x100)
66 enum {
67         PSDEV_DEBUG = 1,          /* control debugging */
68         PSDEV_SUBSYSTEM_DEBUG,    /* control debugging */
69         PSDEV_PRINTK,             /* force all messages to console */
70         PSDEV_CONSOLE_RATELIMIT,  /* ratelimit console messages */
71         PSDEV_DEBUG_PATH,         /* crashdump log location */
72         PSDEV_DEBUG_DUMP_PATH,    /* crashdump tracelog location */
73         PSDEV_LNET_UPCALL,        /* User mode upcall script  */
74         PSDEV_LNET_MEMUSED,       /* bytes currently PORTAL_ALLOCated */
75         PSDEV_LNET_CATASTROPHE,   /* if we have LBUGged or panic'd */
76 };
77
78 int LL_PROC_PROTO(proc_dobitmasks);
79
80 static struct ctl_table lnet_table[] = {
81         {
82                 .ctl_name = PSDEV_DEBUG,
83                 .procname = "debug",
84                 .data     = &libcfs_debug,
85                 .maxlen   = sizeof(int),
86                 .mode     = 0644,
87                 .proc_handler = &proc_dobitmasks
88         },
89         {
90                 .ctl_name = PSDEV_SUBSYSTEM_DEBUG,
91                 .procname = "subsystem_debug",
92                 .data     = &libcfs_subsystem_debug,
93                 .maxlen   = sizeof(int),
94                 .mode     = 0644,
95                 .proc_handler = &proc_dobitmasks
96         },
97         {
98                 .ctl_name = PSDEV_PRINTK,
99                 .procname = "printk",
100                 .data     = &libcfs_printk,
101                 .maxlen   = sizeof(int),
102                 .mode     = 0644,
103                 .proc_handler = &proc_dobitmasks
104         },
105         {
106                 .ctl_name = PSDEV_CONSOLE_RATELIMIT,
107                 .procname = "console_ratelimit",
108                 .data     = &libcfs_console_ratelimit,
109                 .maxlen   = sizeof(int),
110                 .mode     = 0644,
111                 .proc_handler = &proc_dointvec
112         },
113
114         {
115                 .ctl_name = PSDEV_DEBUG_PATH,
116                 .procname = "debug_path",
117                 .data     = debug_file_path,
118                 .maxlen   = sizeof(debug_file_path),
119                 .mode     = 0644,
120                 .proc_handler = &proc_dostring,
121                 .strategy =  &sysctl_string
122         },
123
124         {
125                 .ctl_name = PSDEV_LNET_UPCALL,
126                 .procname = "upcall",
127                 .data     = lnet_upcall,
128                 .maxlen   = sizeof(lnet_upcall),
129                 .mode     = 0644,
130                 .proc_handler = &proc_dostring,
131                 .strategy =  &sysctl_string
132         },
133         {
134                 .ctl_name = PSDEV_LNET_MEMUSED,
135                 .procname = "memused",
136                 .data     = (int *)&libcfs_kmemory.counter,
137                 .maxlen   = sizeof(int),
138                 .mode     = 0444,
139                 .proc_handler = &proc_dointvec
140         },
141         {
142                 .ctl_name = PSDEV_LNET_CATASTROPHE,
143                 .procname = "catastrophe",
144                 .data     = &libcfs_catastrophe,
145                 .maxlen   = sizeof(int),
146                 .mode     = 0444,
147                 .proc_handler = &proc_dointvec
148         },
149         {0}
150 };
151
152 static struct ctl_table top_table[2] = {
153         {
154                 .ctl_name = PSDEV_LNET,
155                 .procname = "lnet",
156                 .data     = NULL,
157                 .maxlen   = 0,
158                 .mode     = 0555,
159                 .child    = lnet_table
160         },
161         {0}
162 };
163
164 int LL_PROC_PROTO(proc_dobitmasks)
165 {
166         const int     tmpstrlen = 512;
167         char         *str;
168         int           rc = 0;
169         /* the proc filling api stumps me always, coax proc_dointvec
170          * and proc_dostring into doing the drudgery by cheating
171          * with a dummy ctl_table
172          */
173         struct ctl_table dummy = *table;
174         unsigned int *mask = (unsigned int *)table->data;
175         int           is_subsys = (mask == &libcfs_subsystem_debug) ? 1 : 0;
176
177         str = kmalloc(tmpstrlen, GFP_USER);
178         if (str == NULL)
179                 return -ENOMEM;
180
181         if (write) {
182                 size_t oldlen = *lenp;
183 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8)
184                 loff_t oldpos = *ppos;
185 #endif
186
187                 dummy.proc_handler = &proc_dointvec;
188
189                 /* old proc interface allows user to specify just an int
190                  * value; be compatible and don't break userland.
191                  */
192                 rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
193
194                 if (rc != -EINVAL)
195                         goto out;
196
197                 /* using new interface */
198                 dummy.data = str;
199                 dummy.maxlen = tmpstrlen;
200                 dummy.proc_handler = &proc_dostring;
201
202                 /* proc_dointvec might have changed these */
203                 *lenp = oldlen;
204 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8)
205                 *ppos = oldpos;
206 #endif
207
208                 rc = ll_proc_dostring(&dummy, write, filp, buffer, lenp, ppos);
209
210                 if (rc != 0)
211                         goto out;
212
213                 rc = libcfs_debug_str2mask(mask, dummy.data, is_subsys);
214         } else {
215                 dummy.data = str;
216                 dummy.maxlen = tmpstrlen;
217                 dummy.proc_handler = &proc_dostring;
218
219                 libcfs_debug_mask2str(dummy.data, dummy.maxlen,*mask,is_subsys);
220
221                 rc = ll_proc_dostring(&dummy, write, filp, buffer, lenp, ppos);
222         }
223
224 out:
225         kfree(str);
226         return rc;
227 }
228
229 int insert_proc(void)
230 {
231         struct proc_dir_entry *ent;
232
233 #ifdef CONFIG_SYSCTL
234         if (!lnet_table_header)
235                 lnet_table_header = cfs_register_sysctl_table(top_table, 0);
236 #endif
237
238         ent = create_proc_entry("sys/lnet/dump_kernel", 0, NULL);
239         if (ent == NULL) {
240                 CERROR("couldn't register dump_kernel\n");
241                 return -1;
242         }
243         ent->write_proc = trace_dk;
244
245         ent = create_proc_entry("sys/lnet/daemon_file", 0, NULL);
246         if (ent == NULL) {
247                 CERROR("couldn't register daemon_file\n");
248                 return -1;
249         }
250         ent->write_proc = trace_write_daemon_file;
251         ent->read_proc = trace_read_daemon_file;
252
253         ent = create_proc_entry("sys/lnet/debug_mb", 0, NULL);
254         if (ent == NULL) {
255                 CERROR("couldn't register debug_mb\n");
256                 return -1;
257         }
258         ent->write_proc = trace_write_debug_mb;
259         ent->read_proc = trace_read_debug_mb;
260
261         return 0;
262 }
263
264 void remove_proc(void)
265 {
266         remove_proc_entry("sys/lnet/dump_kernel", NULL);
267         remove_proc_entry("sys/lnet/daemon_file", NULL);
268         remove_proc_entry("sys/lnet/debug_mb", NULL);
269
270 #ifdef CONFIG_SYSCTL
271         if (lnet_table_header)
272                 cfs_unregister_sysctl_table(lnet_table_header);
273         lnet_table_header = NULL;
274 #endif
275 }