[deliverable/linux.git] / fs / orangefs / pvfs2-debugfs.c

/*
 * What:		/sys/kernel/debug/orangefs/debug-help
 * Date:		June 2015
 * Contact:		Mike Marshall <hubcap@omnibond.com>
 * Description:
 * 			List of client and kernel debug keywords.
 *
 *
 * What:		/sys/kernel/debug/orangefs/client-debug
 * Date:		June 2015
 * Contact:		Mike Marshall <hubcap@omnibond.com>
 * Description:
 * 			Debug setting for "the client", the userspace
 * 			helper for the kernel module.
 *
 *
 * What:		/sys/kernel/debug/orangefs/kernel-debug
 * Date:		June 2015
 * Contact:		Mike Marshall <hubcap@omnibond.com>
 * Description:
 * 			Debug setting for the orangefs kernel module.
 *
 * 			Any of the keywords, or comma-separated lists
 * 			of keywords, from debug-help can be catted to
 * 			client-debug or kernel-debug.
 *
 * 			"none", "all" and "verbose" are special keywords
 * 			for client-debug. Setting client-debug to "all"
 * 			is kind of like trying to drink water from a
 * 			fire hose, "verbose" triggers most of the same
 * 			output except for the constant flow of output
 * 			from the main wait loop.
 *
 * 			"none" and "all" are similar settings for kernel-debug
 * 			no need for a "verbose".
 */
#include <linux/debugfs.h>
#include <linux/slab.h>

#include <linux/uaccess.h>

#include "pvfs2-debugfs.h"
#include "protocol.h"
#include "pvfs2-kernel.h"

static int orangefs_debug_disabled = 1;

static int orangefs_debug_help_open(struct inode *, struct file *);

const struct file_operations debug_help_fops = {
	.open           = orangefs_debug_help_open,
	.read           = seq_read,
	.release        = seq_release,
	.llseek         = seq_lseek,
};

static void *help_start(struct seq_file *, loff_t *);
static void *help_next(struct seq_file *, void *, loff_t *);
static void help_stop(struct seq_file *, void *);
static int help_show(struct seq_file *, void *);

static const struct seq_operations help_debug_ops = {
	.start	= help_start,
	.next	= help_next,
	.stop	= help_stop,
	.show	= help_show,
};

/*
 * Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
 * ORANGEFS_KMOD_DEBUG_FILE.
 */
static DEFINE_MUTEX(orangefs_debug_lock);

int orangefs_debug_open(struct inode *, struct file *);

static ssize_t orangefs_debug_read(struct file *,
				 char __user *,
				 size_t,
				 loff_t *);

static ssize_t orangefs_debug_write(struct file *,
				  const char __user *,
				  size_t,
				  loff_t *);

static const struct file_operations kernel_debug_fops = {
	.open           = orangefs_debug_open,
	.read           = orangefs_debug_read,
	.write		= orangefs_debug_write,
	.llseek         = generic_file_llseek,
};

/*
 * initialize kmod debug operations, create orangefs debugfs dir and
 * ORANGEFS_KMOD_DEBUG_HELP_FILE.
 */
int pvfs2_debugfs_init(void)
{

	int rc = -ENOMEM;

	debug_dir = debugfs_create_dir("orangefs", NULL);
	if (!debug_dir)
		goto out;

	help_file_dentry = debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE,
				  0444,
				  debug_dir,
				  debug_help_string,
				  &debug_help_fops);
	if (!help_file_dentry)
		goto out;

	orangefs_debug_disabled = 0;
	rc = 0;

out:
	if (rc)
		pvfs2_debugfs_cleanup();

	return rc;
}

void pvfs2_debugfs_cleanup(void)
{
	debugfs_remove_recursive(debug_dir);
}

/* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
static int orangefs_debug_help_open(struct inode *inode, struct file *file)
{
	int rc = -ENODEV;
	int ret;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "orangefs_debug_help_open: start\n");

	if (orangefs_debug_disabled)
		goto out;

	ret = seq_open(file, &help_debug_ops);
	if (ret)
		goto out;

	((struct seq_file *)(file->private_data))->private = inode->i_private;

	rc = 0;

out:
	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "orangefs_debug_help_open: rc:%d:\n",
		     rc);
	return rc;
}

/*
 * I think start always gets called again after stop. Start
 * needs to return NULL when it is done. The whole "payload"
 * in this case is a single (long) string, so by the second
 * time we get to start (pos = 1), we're done.
 */
static void *help_start(struct seq_file *m, loff_t *pos)
{
	void *payload = NULL;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");

	if (*pos == 0)
		payload = m->private;

	return payload;
}

static void *help_next(struct seq_file *m, void *v, loff_t *pos)
{
	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");

	return NULL;
}

static void help_stop(struct seq_file *m, void *p)
{
	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
}

static int help_show(struct seq_file *m, void *v)
{
	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");

	seq_puts(m, v);

	return 0;
}

/*
 * initialize the kernel-debug file.
 */
int pvfs2_kernel_debug_init(void)
{

	int rc = -ENOMEM;
	struct dentry *ret;
	char *k_buffer = NULL;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);

	k_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
	if (!k_buffer)
		goto out;

	if (strlen(kernel_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
		strcpy(k_buffer, kernel_debug_string);
		strcat(k_buffer, "\n");
	} else {
		strcpy(k_buffer, "none\n");
		pr_info("%s: overflow 1!\n", __func__);
	}

	ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
				  0444,
				  debug_dir,
				  k_buffer,
				  &kernel_debug_fops);
	if (!ret) {
		pr_info("%s: failed to create %s.\n",
			__func__,
			ORANGEFS_KMOD_DEBUG_FILE);
		goto out;
	}

	rc = 0;

out:
	if (rc)
		pvfs2_debugfs_cleanup();

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
	return rc;
}

/*
 * initialize the client-debug file.
 */
int pvfs2_client_debug_init(void)
{

	int rc = -ENOMEM;
	char *c_buffer = NULL;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);

	c_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
	if (!c_buffer)
		goto out;

	if (strlen(client_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
		strcpy(c_buffer, client_debug_string);
		strcat(c_buffer, "\n");
	} else {
		strcpy(c_buffer, "none\n");
		pr_info("%s: overflow! 2\n", __func__);
	}

	client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
						  0444,
						  debug_dir,
						  c_buffer,
						  &kernel_debug_fops);
	if (!client_debug_dentry) {
		pr_info("%s: failed to create %s.\n",
			__func__,
			ORANGEFS_CLIENT_DEBUG_FILE);
		goto out;
	}

	rc = 0;

out:
	if (rc)
		pvfs2_debugfs_cleanup();

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
	return rc;
}

/* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
int orangefs_debug_open(struct inode *inode, struct file *file)
{
	int rc = -ENODEV;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "%s: orangefs_debug_disabled: %d\n",
		     __func__,
		     orangefs_debug_disabled);

	if (orangefs_debug_disabled)
		goto out;

	rc = 0;
	mutex_lock(&orangefs_debug_lock);
	file->private_data = inode->i_private;
	mutex_unlock(&orangefs_debug_lock);

out:
	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "orangefs_debug_open: rc: %d\n",
		     rc);
	return rc;
}

static ssize_t orangefs_debug_read(struct file *file,
				 char __user *ubuf,
				 size_t count,
				 loff_t *ppos)
{
	char *buf;
	int sprintf_ret;
	ssize_t read_ret = -ENOMEM;

	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");

	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
	if (!buf)
		goto out;

	mutex_lock(&orangefs_debug_lock);
	sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
	mutex_unlock(&orangefs_debug_lock);

	read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);

	kfree(buf);

out:
	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "orangefs_debug_read: ret: %zu\n",
		     read_ret);

	return read_ret;
}

static ssize_t orangefs_debug_write(struct file *file,
				  const char __user *ubuf,
				  size_t count,
				  loff_t *ppos)
{
	char *buf;
	int rc = -EFAULT;
	size_t silly = 0;
	char *debug_string;
	struct pvfs2_kernel_op_s *new_op = NULL;
	struct client_debug_mask c_mask = { NULL, 0, 0 };

	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		"orangefs_debug_write: %s\n",
		file->f_path.dentry->d_name.name);

	/*
	 * Thwart users who try to jamb a ridiculous number
	 * of bytes into the debug file...
	 */
	if (count > PVFS2_MAX_DEBUG_STRING_LEN + 1) {
		silly = count;
		count = PVFS2_MAX_DEBUG_STRING_LEN + 1;
	}

	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
	if (!buf)
		goto out;
	memset(buf, 0, PVFS2_MAX_DEBUG_STRING_LEN);

	if (copy_from_user(buf, ubuf, count - 1)) {
		gossip_debug(GOSSIP_DEBUGFS_DEBUG,
			     "%s: copy_from_user failed!\n",
			     __func__);
		goto out;
	}

	/*
	 * Map the keyword string from userspace into a valid debug mask.
	 * The mapping process involves mapping the human-inputted string
	 * into a valid mask, and then rebuilding the string from the
	 * verified valid mask.
	 *
	 * A service operation is required to set a new client-side
	 * debug mask.
	 */
	if (!strcmp(file->f_path.dentry->d_name.name,
		    ORANGEFS_KMOD_DEBUG_FILE)) {
		debug_string_to_mask(buf, &gossip_debug_mask, 0);
		debug_mask_to_string(&gossip_debug_mask, 0);
		debug_string = kernel_debug_string;
		gossip_debug(GOSSIP_DEBUGFS_DEBUG,
			     "New kernel debug string is %s\n",
			     kernel_debug_string);
	} else {
		/* Can't reset client debug mask if client is not running. */
		if (is_daemon_in_service()) {
			pr_info("%s: Client not running :%d:\n",
				__func__,
				is_daemon_in_service());
			goto out;
		}

		debug_string_to_mask(buf, &c_mask, 1);
		debug_mask_to_string(&c_mask, 1);
		debug_string = client_debug_string;

		new_op = op_alloc(PVFS2_VFS_OP_PARAM);
		if (!new_op) {
			pr_info("%s: op_alloc failed!\n", __func__);
			goto out;
		}

		new_op->upcall.req.param.op =
			PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES;
		new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET;
		memset(new_op->upcall.req.param.s_value,
		       0,
		       PVFS2_MAX_DEBUG_STRING_LEN);
		sprintf(new_op->upcall.req.param.s_value,
			"%llx %llx\n",
			c_mask.mask1,
			c_mask.mask2);

		/* service_operation returns 0 on success... */
		rc = service_operation(new_op,
				       "pvfs2_param",
					PVFS2_OP_INTERRUPTIBLE);

		if (rc)
			gossip_debug(GOSSIP_DEBUGFS_DEBUG,
				     "%s: service_operation failed! rc:%d:\n",
				     __func__,
				     rc);

		op_release(new_op);
	}

	mutex_lock(&orangefs_debug_lock);
	memset(file->f_inode->i_private, 0, PVFS2_MAX_DEBUG_STRING_LEN);
	sprintf((char *)file->f_inode->i_private, "%s\n", debug_string);
	mutex_unlock(&orangefs_debug_lock);

	*ppos += count;
	if (silly)
		rc = silly;
	else
		rc = count;

out:
	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
		     "orangefs_debug_write: rc: %d\n",
		     rc);
	kfree(buf);
	return rc;
}
Commit	Line	Data
274dcf55 MM	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 "pvfs2-debugfs.h"
	43	#include "protocol.h"
	44	#include "pvfs2-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	*/
84d02150	73	static DEFINE_MUTEX(orangefs_debug_lock);
274dcf55 MM	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 pvfs2_debugfs_init(void)
	99	{
	100
	101	int rc = -ENOMEM;
	102
	103	debug_dir = debugfs_create_dir("orangefs", NULL);
	104	if (!debug_dir)
	105	goto out;
	106
	107	help_file_dentry = debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE,
	108	0444,
	109	debug_dir,
	110	debug_help_string,
	111	&debug_help_fops);
	112	if (!help_file_dentry)
	113	goto out;
	114
	115	orangefs_debug_disabled = 0;
	116	rc = 0;
	117
	118	out:
	119	if (rc)
	120	pvfs2_debugfs_cleanup();
	121
	122	return rc;
	123	}
	124
	125	void pvfs2_debugfs_cleanup(void)
	126	{
	127	debugfs_remove_recursive(debug_dir);
	128	}
	129
	130	/* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
	131	static int orangefs_debug_help_open(struct inode inode, struct file file)
	132	{
	133	int rc = -ENODEV;
	134	int ret;
	135
	136	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
	137	"orangefs_debug_help_open: start\n");
138
139	if (orangefs_debug_disabled)
140	goto out;
141
142	ret = seq_open(file, &help_debug_ops);
143	if (ret)
144	goto out;
145
146	((struct seq_file *)(file->private_data))->private = inode->i_private;
147
148	rc = 0;
149
150	out:
151	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
152	"orangefs_debug_help_open: rc:%d:\n",
153	rc);
154	return rc;
155	}
156
157	/*
158	* I think start always gets called again after stop. Start
159	* needs to return NULL when it is done. The whole "payload"
160	* in this case is a single (long) string, so by the second
161	* time we get to start (pos = 1), we're done.
162	*/
163	static void help_start(struct seq_file m, loff_t *pos)
164	{
165	void *payload = NULL;
166
167	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
168
169	if (*pos == 0)
170	payload = m->private;
171
172	return payload;
173	}
174
175	static void help_next(struct seq_file m, void v, loff_t pos)
176	{
177	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");
178
179	return NULL;
180	}
181
182	static void help_stop(struct seq_file m, void p)
183	{
184	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
185	}
186
187	static int help_show(struct seq_file m, void v)
188	{
189	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");
190
191	seq_puts(m, v);
192
193	return 0;
194	}
195
196	/*
197	* initialize the kernel-debug file.
198	*/
199	int pvfs2_kernel_debug_init(void)
200	{
201
202	int rc = -ENOMEM;
203	struct dentry *ret;
204	char *k_buffer = NULL;
205
206	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
207
208	k_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
209	if (!k_buffer)
210	goto out;
211
212	if (strlen(kernel_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
213	strcpy(k_buffer, kernel_debug_string);
214	strcat(k_buffer, "\n");
215	} else {
216	strcpy(k_buffer, "none\n");
217	pr_info("%s: overflow 1!\n", __func__);
218	}
219
220	ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
221	0444,
222	debug_dir,
223	k_buffer,
224	&kernel_debug_fops);
225	if (!ret) {
226	pr_info("%s: failed to create %s.\n",
227	__func__,
228	ORANGEFS_KMOD_DEBUG_FILE);
229	goto out;
230	}
231
232	rc = 0;
233
234	out:
235	if (rc)
236	pvfs2_debugfs_cleanup();
237
238	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
239	return rc;
240	}
241
242	/*
243	* initialize the client-debug file.
244	*/
245	int pvfs2_client_debug_init(void)
246	{
247
248	int rc = -ENOMEM;
249	char *c_buffer = NULL;
250
251	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
252
253	c_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
254	if (!c_buffer)
255	goto out;
256
257	if (strlen(client_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
258	strcpy(c_buffer, client_debug_string);
259	strcat(c_buffer, "\n");
260	} else {
261	strcpy(c_buffer, "none\n");
262	pr_info("%s: overflow! 2\n", __func__);
263	}
264
265	client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
266	0444,
267	debug_dir,
268	c_buffer,
269	&kernel_debug_fops);
270	if (!client_debug_dentry) {
271	pr_info("%s: failed to create %s.\n",
272	__func__,
273	ORANGEFS_CLIENT_DEBUG_FILE);
274	goto out;
275	}
276
277	rc = 0;
278
279	out:
280	if (rc)
281	pvfs2_debugfs_cleanup();
282
283	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
284	return rc;
285	}
286
287	/* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
288	int orangefs_debug_open(struct inode inode, struct file file)
289	{
290	int rc = -ENODEV;
291
292	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
293	"%s: orangefs_debug_disabled: %d\n",
294	__func__,
295	orangefs_debug_disabled);
296
297	if (orangefs_debug_disabled)
298	goto out;
299
300	rc = 0;
301	mutex_lock(&orangefs_debug_lock);
302	file->private_data = inode->i_private;
303	mutex_unlock(&orangefs_debug_lock);
304
305	out:
306	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
307	"orangefs_debug_open: rc: %d\n",
308	rc);
309	return rc;
310	}
311
312	static ssize_t orangefs_debug_read(struct file *file,
313	char __user *ubuf,
314	size_t count,
315	loff_t *ppos)
316	{
317	char *buf;
318	int sprintf_ret;
319	ssize_t read_ret = -ENOMEM;
320
321	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
322
323	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
324	if (!buf)
325	goto out;
326
327	mutex_lock(&orangefs_debug_lock);
328	sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
329	mutex_unlock(&orangefs_debug_lock);
330
331	read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);
332
333	kfree(buf);
334
335	out:
336	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
337	"orangefs_debug_read: ret: %zu\n",
338	read_ret);
339
340	return read_ret;
341	}
342
343	static ssize_t orangefs_debug_write(struct file *file,
344	const char __user *ubuf,
345	size_t count,
346	loff_t *ppos)
347	{
348	char *buf;
349	int rc = -EFAULT;
350	size_t silly = 0;
351	char *debug_string;
352	struct pvfs2_kernel_op_s *new_op = NULL;
353	struct client_debug_mask c_mask = { NULL, 0, 0 };
354
355	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
356	"orangefs_debug_write: %s\n",
357	file->f_path.dentry->d_name.name);
358
359	/*
360	* Thwart users who try to jamb a ridiculous number
361	* of bytes into the debug file...
362	*/
363	if (count > PVFS2_MAX_DEBUG_STRING_LEN + 1) {
364	silly = count;
365	count = PVFS2_MAX_DEBUG_STRING_LEN + 1;
366	}
367
368	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
369	if (!buf)
370	goto out;
371	memset(buf, 0, PVFS2_MAX_DEBUG_STRING_LEN);
372
373	if (copy_from_user(buf, ubuf, count - 1)) {
374	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
375	"%s: copy_from_user failed!\n",
376	__func__);
377	goto out;
378	}
379
380	/*
381	* Map the keyword string from userspace into a valid debug mask.
382	* The mapping process involves mapping the human-inputted string
383	* into a valid mask, and then rebuilding the string from the
384	* verified valid mask.
385	*
386	* A service operation is required to set a new client-side
387	* debug mask.
388	*/
389	if (!strcmp(file->f_path.dentry->d_name.name,
390	ORANGEFS_KMOD_DEBUG_FILE)) {
391	debug_string_to_mask(buf, &gossip_debug_mask, 0);
392	debug_mask_to_string(&gossip_debug_mask, 0);
393	debug_string = kernel_debug_string;
394	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
395	"New kernel debug string is %s\n",
396	kernel_debug_string);
397	} else {
398	/* Can't reset client debug mask if client is not running. */
399	if (is_daemon_in_service()) {
400	pr_info("%s: Client not running :%d:\n",
401	__func__,
402	is_daemon_in_service());
403	goto out;
404	}
405
406	debug_string_to_mask(buf, &c_mask, 1);
407	debug_mask_to_string(&c_mask, 1);
408	debug_string = client_debug_string;
409
410	new_op = op_alloc(PVFS2_VFS_OP_PARAM);
411	if (!new_op) {
412	pr_info("%s: op_alloc failed!\n", __func__);
413	goto out;
414	}
415
416	new_op->upcall.req.param.op =
417	PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES;
418	new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET;
419	memset(new_op->upcall.req.param.s_value,
420	0,
421	PVFS2_MAX_DEBUG_STRING_LEN);
422	sprintf(new_op->upcall.req.param.s_value,
423	"%llx %llx\n",
424	c_mask.mask1,
425	c_mask.mask2);
426
427	/* service_operation returns 0 on success... */
428	rc = service_operation(new_op,
429	"pvfs2_param",
430	PVFS2_OP_INTERRUPTIBLE);
431
432	if (rc)
433	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
434	"%s: service_operation failed! rc:%d:\n",
435	__func__,
436	rc);
437
438	op_release(new_op);
439	}
440
441	mutex_lock(&orangefs_debug_lock);
442	memset(file->f_inode->i_private, 0, PVFS2_MAX_DEBUG_STRING_LEN);
443	sprintf((char *)file->f_inode->i_private, "%s\n", debug_string);
444	mutex_unlock(&orangefs_debug_lock);
445
446	*ppos += count;
447	if (silly)
448	rc = silly;
449	else
450	rc = count;
451
452	out:
453	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
454	"orangefs_debug_write: rc: %d\n",
455	rc);
456	kfree(buf);
457	return rc;
458	}