1 /*
2  * What:		/sys/kernel/debug/orangefs/debug-help
3  * Date:		June 2015
4  * Contact:		Mike Marshall <hubcap@omnibond.com>
5  * Description:
6  * 			List of client and kernel debug keywords.
7  *
8  *
9  * What:		/sys/kernel/debug/orangefs/client-debug
10  * Date:		June 2015
11  * Contact:		Mike Marshall <hubcap@omnibond.com>
12  * Description:
13  * 			Debug setting for "the client", the userspace
14  * 			helper for the kernel module.
15  *
16  *
17  * What:		/sys/kernel/debug/orangefs/kernel-debug
18  * Date:		June 2015
19  * Contact:		Mike Marshall <hubcap@omnibond.com>
20  * Description:
21  * 			Debug setting for the orangefs kernel module.
22  *
23  * 			Any of the keywords, or comma-separated lists
24  * 			of keywords, from debug-help can be catted to
25  * 			client-debug or kernel-debug.
26  *
27  * 			"none", "all" and "verbose" are special keywords
28  * 			for client-debug. Setting client-debug to "all"
29  * 			is kind of like trying to drink water from a
30  * 			fire hose, "verbose" triggers most of the same
31  * 			output except for the constant flow of output
32  * 			from the main wait loop.
33  *
34  * 			"none" and "all" are similar settings for kernel-debug
35  * 			no need for a "verbose".
36  */
37 #include <linux/debugfs.h>
38 #include <linux/slab.h>
39 
40 #include <linux/uaccess.h>
41 
42 #include "orangefs-debugfs.h"
43 #include "protocol.h"
44 #include "orangefs-kernel.h"
45 
46 static int orangefs_debug_disabled = 1;
47 
48 static int orangefs_debug_help_open(struct inode *, struct file *);
49 
50 const struct file_operations debug_help_fops = {
51 	.open           = orangefs_debug_help_open,
52 	.read           = seq_read,
53 	.release        = seq_release,
54 	.llseek         = seq_lseek,
55 };
56 
57 static void *help_start(struct seq_file *, loff_t *);
58 static void *help_next(struct seq_file *, void *, loff_t *);
59 static void help_stop(struct seq_file *, void *);
60 static int help_show(struct seq_file *, void *);
61 
62 static const struct seq_operations help_debug_ops = {
63 	.start	= help_start,
64 	.next	= help_next,
65 	.stop	= help_stop,
66 	.show	= help_show,
67 };
68 
69 /*
70  * Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
71  * ORANGEFS_KMOD_DEBUG_FILE.
72  */
73 static DEFINE_MUTEX(orangefs_debug_lock);
74 
75 int orangefs_debug_open(struct inode *, struct file *);
76 
77 static ssize_t orangefs_debug_read(struct file *,
78 				 char __user *,
79 				 size_t,
80 				 loff_t *);
81 
82 static ssize_t orangefs_debug_write(struct file *,
83 				  const char __user *,
84 				  size_t,
85 				  loff_t *);
86 
87 static const struct file_operations kernel_debug_fops = {
88 	.open           = orangefs_debug_open,
89 	.read           = orangefs_debug_read,
90 	.write		= orangefs_debug_write,
91 	.llseek         = generic_file_llseek,
92 };
93 
94 /*
95  * initialize kmod debug operations, create orangefs debugfs dir and
96  * ORANGEFS_KMOD_DEBUG_HELP_FILE.
97  */
98 int orangefs_debugfs_init(void)
99 {
100 
101 	int rc = -ENOMEM;
102 
103 	debug_dir = debugfs_create_dir("orangefs", NULL);
104 	if (!debug_dir) {
105 		pr_info("%s: debugfs_create_dir failed.\n", __func__);
106 		goto out;
107 	}
108 
109 	help_file_dentry = debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE,
110 				  0444,
111 				  debug_dir,
112 				  debug_help_string,
113 				  &debug_help_fops);
114 	if (!help_file_dentry) {
115 		pr_info("%s: debugfs_create_file failed.\n", __func__);
116 		goto out;
117 	}
118 
119 	orangefs_debug_disabled = 0;
120 	rc = 0;
121 
122 out:
123 
124 	return rc;
125 }
126 
127 void orangefs_debugfs_cleanup(void)
128 {
129 	debugfs_remove_recursive(debug_dir);
130 }
131 
132 /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
133 static int orangefs_debug_help_open(struct inode *inode, struct file *file)
134 {
135 	int rc = -ENODEV;
136 	int ret;
137 
138 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
139 		     "orangefs_debug_help_open: start\n");
140 
141 	if (orangefs_debug_disabled)
142 		goto out;
143 
144 	ret = seq_open(file, &help_debug_ops);
145 	if (ret)
146 		goto out;
147 
148 	((struct seq_file *)(file->private_data))->private = inode->i_private;
149 
150 	rc = 0;
151 
152 out:
153 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
154 		     "orangefs_debug_help_open: rc:%d:\n",
155 		     rc);
156 	return rc;
157 }
158 
159 /*
160  * I think start always gets called again after stop. Start
161  * needs to return NULL when it is done. The whole "payload"
162  * in this case is a single (long) string, so by the second
163  * time we get to start (pos = 1), we're done.
164  */
165 static void *help_start(struct seq_file *m, loff_t *pos)
166 {
167 	void *payload = NULL;
168 
169 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
170 
171 	if (*pos == 0)
172 		payload = m->private;
173 
174 	return payload;
175 }
176 
177 static void *help_next(struct seq_file *m, void *v, loff_t *pos)
178 {
179 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");
180 
181 	return NULL;
182 }
183 
184 static void help_stop(struct seq_file *m, void *p)
185 {
186 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
187 }
188 
189 static int help_show(struct seq_file *m, void *v)
190 {
191 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");
192 
193 	seq_puts(m, v);
194 
195 	return 0;
196 }
197 
198 /*
199  * initialize the kernel-debug file.
200  */
201 int orangefs_kernel_debug_init(void)
202 {
203 	int rc = -ENOMEM;
204 	struct dentry *ret;
205 	char *k_buffer = NULL;
206 
207 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
208 
209 	k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
210 	if (!k_buffer)
211 		goto out;
212 
213 	if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
214 		strcpy(k_buffer, kernel_debug_string);
215 		strcat(k_buffer, "\n");
216 	} else {
217 		strcpy(k_buffer, "none\n");
218 		pr_info("%s: overflow 1!\n", __func__);
219 	}
220 
221 	ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
222 				  0444,
223 				  debug_dir,
224 				  k_buffer,
225 				  &kernel_debug_fops);
226 	if (!ret) {
227 		pr_info("%s: failed to create %s.\n",
228 			__func__,
229 			ORANGEFS_KMOD_DEBUG_FILE);
230 		goto out;
231 	}
232 
233 	rc = 0;
234 
235 out:
236 
237 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
238 	return rc;
239 }
240 
241 /*
242  * initialize the client-debug file.
243  */
244 int orangefs_client_debug_init(void)
245 {
246 
247 	int rc = -ENOMEM;
248 	char *c_buffer = NULL;
249 
250 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
251 
252 	c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
253 	if (!c_buffer)
254 		goto out;
255 
256 	if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
257 		strcpy(c_buffer, client_debug_string);
258 		strcat(c_buffer, "\n");
259 	} else {
260 		strcpy(c_buffer, "none\n");
261 		pr_info("%s: overflow! 2\n", __func__);
262 	}
263 
264 	client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
265 						  0444,
266 						  debug_dir,
267 						  c_buffer,
268 						  &kernel_debug_fops);
269 	if (!client_debug_dentry) {
270 		pr_info("%s: failed to create updated %s.\n",
271 			__func__,
272 			ORANGEFS_CLIENT_DEBUG_FILE);
273 		goto out;
274 	}
275 
276 	rc = 0;
277 
278 out:
279 
280 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
281 	return rc;
282 }
283 
284 /* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
285 int orangefs_debug_open(struct inode *inode, struct file *file)
286 {
287 	int rc = -ENODEV;
288 
289 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
290 		     "%s: orangefs_debug_disabled: %d\n",
291 		     __func__,
292 		     orangefs_debug_disabled);
293 
294 	if (orangefs_debug_disabled)
295 		goto out;
296 
297 	rc = 0;
298 	mutex_lock(&orangefs_debug_lock);
299 	file->private_data = inode->i_private;
300 	mutex_unlock(&orangefs_debug_lock);
301 
302 out:
303 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
304 		     "orangefs_debug_open: rc: %d\n",
305 		     rc);
306 	return rc;
307 }
308 
309 static ssize_t orangefs_debug_read(struct file *file,
310 				 char __user *ubuf,
311 				 size_t count,
312 				 loff_t *ppos)
313 {
314 	char *buf;
315 	int sprintf_ret;
316 	ssize_t read_ret = -ENOMEM;
317 
318 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
319 
320 	buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
321 	if (!buf)
322 		goto out;
323 
324 	mutex_lock(&orangefs_debug_lock);
325 	sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
326 	mutex_unlock(&orangefs_debug_lock);
327 
328 	read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);
329 
330 	kfree(buf);
331 
332 out:
333 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
334 		     "orangefs_debug_read: ret: %zu\n",
335 		     read_ret);
336 
337 	return read_ret;
338 }
339 
340 static ssize_t orangefs_debug_write(struct file *file,
341 				  const char __user *ubuf,
342 				  size_t count,
343 				  loff_t *ppos)
344 {
345 	char *buf;
346 	int rc = -EFAULT;
347 	size_t silly = 0;
348 	char *debug_string;
349 	struct orangefs_kernel_op_s *new_op = NULL;
350 	struct client_debug_mask c_mask = { NULL, 0, 0 };
351 
352 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
353 		"orangefs_debug_write: %s\n",
354 		file->f_path.dentry->d_name.name);
355 
356 	/*
357 	 * Thwart users who try to jamb a ridiculous number
358 	 * of bytes into the debug file...
359 	 */
360 	if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
361 		silly = count;
362 		count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
363 	}
364 
365 	buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
366 	if (!buf)
367 		goto out;
368 
369 	if (copy_from_user(buf, ubuf, count - 1)) {
370 		gossip_debug(GOSSIP_DEBUGFS_DEBUG,
371 			     "%s: copy_from_user failed!\n",
372 			     __func__);
373 		goto out;
374 	}
375 
376 	/*
377 	 * Map the keyword string from userspace into a valid debug mask.
378 	 * The mapping process involves mapping the human-inputted string
379 	 * into a valid mask, and then rebuilding the string from the
380 	 * verified valid mask.
381 	 *
382 	 * A service operation is required to set a new client-side
383 	 * debug mask.
384 	 */
385 	if (!strcmp(file->f_path.dentry->d_name.name,
386 		    ORANGEFS_KMOD_DEBUG_FILE)) {
387 		debug_string_to_mask(buf, &gossip_debug_mask, 0);
388 		debug_mask_to_string(&gossip_debug_mask, 0);
389 		debug_string = kernel_debug_string;
390 		gossip_debug(GOSSIP_DEBUGFS_DEBUG,
391 			     "New kernel debug string is %s\n",
392 			     kernel_debug_string);
393 	} else {
394 		/* Can't reset client debug mask if client is not running. */
395 		if (is_daemon_in_service()) {
396 			pr_info("%s: Client not running :%d:\n",
397 				__func__,
398 				is_daemon_in_service());
399 			goto out;
400 		}
401 
402 		debug_string_to_mask(buf, &c_mask, 1);
403 		debug_mask_to_string(&c_mask, 1);
404 		debug_string = client_debug_string;
405 
406 		new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
407 		if (!new_op) {
408 			pr_info("%s: op_alloc failed!\n", __func__);
409 			goto out;
410 		}
411 
412 		new_op->upcall.req.param.op =
413 			ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
414 		new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
415 		memset(new_op->upcall.req.param.s_value,
416 		       0,
417 		       ORANGEFS_MAX_DEBUG_STRING_LEN);
418 		sprintf(new_op->upcall.req.param.s_value,
419 			"%llx %llx\n",
420 			c_mask.mask1,
421 			c_mask.mask2);
422 
423 		/* service_operation returns 0 on success... */
424 		rc = service_operation(new_op,
425 				       "orangefs_param",
426 					ORANGEFS_OP_INTERRUPTIBLE);
427 
428 		if (rc)
429 			gossip_debug(GOSSIP_DEBUGFS_DEBUG,
430 				     "%s: service_operation failed! rc:%d:\n",
431 				     __func__,
432 				     rc);
433 
434 		op_release(new_op);
435 	}
436 
437 	mutex_lock(&orangefs_debug_lock);
438 	memset(file->f_inode->i_private, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
439 	sprintf((char *)file->f_inode->i_private, "%s\n", debug_string);
440 	mutex_unlock(&orangefs_debug_lock);
441 
442 	*ppos += count;
443 	if (silly)
444 		rc = silly;
445 	else
446 		rc = count;
447 
448 out:
449 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
450 		     "orangefs_debug_write: rc: %d\n",
451 		     rc);
452 	kfree(buf);
453 	return rc;
454 }
455