fault_inject.c 3.65 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8 9 10 11
/*
 * Copyright (c) 2011 Bryan Schumaker <bjschuma@netapp.com>
 *
 * Uses debugfs to create fault injection points for client testing
 */

#include <linux/types.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/module.h>
12
#include <linux/nsproxy.h>
13
#include <linux/sunrpc/addr.h>
14
#include <linux/uaccess.h>
Jérémy Lefaure's avatar
Jérémy Lefaure committed
15
#include <linux/kernel.h>
16 17

#include "state.h"
18
#include "netns.h"
19 20 21

struct nfsd_fault_inject_op {
	char *file;
22 23 24
	u64 (*get)(void);
	u64 (*set_val)(u64);
	u64 (*set_clnt)(struct sockaddr_storage *, size_t);
25 26 27 28
};

static struct dentry *debug_dir;

29 30 31 32 33
static ssize_t fault_inject_read(struct file *file, char __user *buf,
				 size_t len, loff_t *ppos)
{
	static u64 val;
	char read_buf[25];
34
	size_t size;
35
	loff_t pos = *ppos;
36
	struct nfsd_fault_inject_op *op = file_inode(file)->i_private;
37 38

	if (!pos)
39
		val = op->get();
40 41
	size = scnprintf(read_buf, sizeof(read_buf), "%llu\n", val);

42
	return simple_read_from_buffer(buf, len, ppos, read_buf, size);
43 44 45 46 47
}

static ssize_t fault_inject_write(struct file *file, const char __user *buf,
				  size_t len, loff_t *ppos)
{
48
	char write_buf[INET6_ADDRSTRLEN];
49
	size_t size = min(sizeof(write_buf) - 1, len);
50 51
	struct net *net = current->nsproxy->net_ns;
	struct sockaddr_storage sa;
52
	struct nfsd_fault_inject_op *op = file_inode(file)->i_private;
53
	u64 val;
54
	char *nl;
55 56 57

	if (copy_from_user(write_buf, buf, size))
		return -EFAULT;
58 59
	write_buf[size] = '\0';

60 61 62 63 64 65 66
	/* Deal with any embedded newlines in the string */
	nl = strchr(write_buf, '\n');
	if (nl) {
		size = nl - write_buf;
		*nl = '\0';
	}

67
	size = rpc_pton(net, write_buf, size, (struct sockaddr *)&sa, sizeof(sa));
68
	if (size > 0) {
69
		val = op->set_clnt(&sa, size);
70 71 72 73
		if (val)
			pr_info("NFSD [%s]: Client %s had %llu state object(s)\n",
				op->file, write_buf, val);
	} else {
74
		val = simple_strtoll(write_buf, NULL, 0);
75 76 77 78 79
		if (val == 0)
			pr_info("NFSD Fault Injection: %s (all)", op->file);
		else
			pr_info("NFSD Fault Injection: %s (n = %llu)",
				op->file, val);
80
		val = op->set_val(val);
81
		pr_info("NFSD: %s: found %llu", op->file, val);
82
	}
83 84 85 86 87 88 89 90
	return len; /* on success, claim we got the whole input */
}

static const struct file_operations fops_nfsd = {
	.owner   = THIS_MODULE,
	.read    = fault_inject_read,
	.write   = fault_inject_write,
};
91 92 93 94 95 96

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

97 98 99
static struct nfsd_fault_inject_op inject_ops[] = {
	{
		.file     = "forget_clients",
100
		.get	  = nfsd_inject_print_clients,
101
		.set_val  = nfsd_inject_forget_clients,
102
		.set_clnt = nfsd_inject_forget_client,
103 104 105
	},
	{
		.file     = "forget_locks",
106 107 108
		.get	  = nfsd_inject_print_locks,
		.set_val  = nfsd_inject_forget_locks,
		.set_clnt = nfsd_inject_forget_client_locks,
109 110 111
	},
	{
		.file     = "forget_openowners",
112 113 114
		.get	  = nfsd_inject_print_openowners,
		.set_val  = nfsd_inject_forget_openowners,
		.set_clnt = nfsd_inject_forget_client_openowners,
115 116 117
	},
	{
		.file     = "forget_delegations",
118 119 120
		.get	  = nfsd_inject_print_delegations,
		.set_val  = nfsd_inject_forget_delegations,
		.set_clnt = nfsd_inject_forget_client_delegations,
121 122 123
	},
	{
		.file     = "recall_delegations",
124 125 126
		.get	  = nfsd_inject_print_delegations,
		.set_val  = nfsd_inject_recall_delegations,
		.set_clnt = nfsd_inject_recall_client_delegations,
127 128 129
	},
};

130 131 132 133
int nfsd_fault_inject_init(void)
{
	unsigned int i;
	struct nfsd_fault_inject_op *op;
134
	umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
135 136 137 138 139

	debug_dir = debugfs_create_dir("nfsd", NULL);
	if (!debug_dir)
		goto fail;

Jérémy Lefaure's avatar
Jérémy Lefaure committed
140
	for (i = 0; i < ARRAY_SIZE(inject_ops); i++) {
141 142 143 144 145 146 147 148 149 150
		op = &inject_ops[i];
		if (!debugfs_create_file(op->file, mode, debug_dir, op, &fops_nfsd))
			goto fail;
	}
	return 0;

fail:
	nfsd_fault_inject_cleanup();
	return -ENOMEM;
}