callback.c 5.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * linux/fs/nfs/callback.c
 *
 * Copyright (C) 2004 Trond Myklebust
 *
 * NFSv4 callback handling
 */

#include <linux/completion.h>
#include <linux/ip.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/svcsock.h>
#include <linux/nfs_fs.h>
I
Ingo Molnar 已提交
16
#include <linux/mutex.h>
17
#include <linux/freezer.h>
18 19 20

#include <net/inet_sock.h>

21
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
22
#include "callback.h"
23
#include "internal.h"
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33 34 35

#define NFSDBG_FACILITY NFSDBG_CALLBACK

struct nfs_callback_data {
	unsigned int users;
	struct svc_serv *serv;
	pid_t pid;
	struct completion started;
	struct completion stopped;
};

static struct nfs_callback_data nfs_callback_info;
I
Ingo Molnar 已提交
36
static DEFINE_MUTEX(nfs_callback_mutex);
L
Linus Torvalds 已提交
37 38
static struct svc_program nfs4_callback_program;

39
unsigned int nfs_callback_set_tcpport;
L
Linus Torvalds 已提交
40
unsigned short nfs_callback_tcpport;
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
static const int nfs_set_port_min = 0;
static const int nfs_set_port_max = 65535;

static int param_set_port(const char *val, struct kernel_param *kp)
{
	char *endp;
	int num = simple_strtol(val, &endp, 0);
	if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
		return -EINVAL;
	*((int *)kp->arg) = num;
	return 0;
}

module_param_call(callback_tcpport, param_set_port, param_get_int,
		 &nfs_callback_set_tcpport, 0644);
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

/*
 * This is the callback kernel thread.
 */
static void nfs_callback_svc(struct svc_rqst *rqstp)
{
	int err;

	__module_get(THIS_MODULE);
	lock_kernel();

	nfs_callback_info.pid = current->pid;
	daemonize("nfsv4-svc");
	/* Process request with signals blocked, but allow SIGKILL.  */
	allow_signal(SIGKILL);
71
	set_freezable();
L
Linus Torvalds 已提交
72 73 74

	complete(&nfs_callback_info.started);

75 76 77 78 79 80
	for(;;) {
		if (signalled()) {
			if (nfs_callback_info.users == 0)
				break;
			flush_signals(current);
		}
L
Linus Torvalds 已提交
81 82 83
		/*
		 * Listen for a request on the socket
		 */
84
		err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92
		if (err == -EAGAIN || err == -EINTR)
			continue;
		if (err < 0) {
			printk(KERN_WARNING
					"%s: terminating on error %d\n",
					__FUNCTION__, -err);
			break;
		}
93
		svc_process(rqstp);
L
Linus Torvalds 已提交
94 95
	}

96
	svc_exit_thread(rqstp);
L
Linus Torvalds 已提交
97 98 99 100 101 102 103 104 105 106 107
	nfs_callback_info.pid = 0;
	complete(&nfs_callback_info.stopped);
	unlock_kernel();
	module_put_and_exit(0);
}

/*
 * Bring up the server process if it is not already up.
 */
int nfs_callback_up(void)
{
108
	struct svc_serv *serv = NULL;
L
Linus Torvalds 已提交
109 110 111
	int ret = 0;

	lock_kernel();
I
Ingo Molnar 已提交
112
	mutex_lock(&nfs_callback_mutex);
L
Linus Torvalds 已提交
113 114 115 116
	if (nfs_callback_info.users++ || nfs_callback_info.pid != 0)
		goto out;
	init_completion(&nfs_callback_info.started);
	init_completion(&nfs_callback_info.stopped);
117
	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
L
Linus Torvalds 已提交
118 119 120
	ret = -ENOMEM;
	if (!serv)
		goto out_err;
121

122 123
	ret = svc_create_xprt(serv, "tcp", nfs_callback_set_tcpport,
			      SVC_SOCK_ANONYMOUS);
124
	if (ret <= 0)
125
		goto out_err;
126 127 128
	nfs_callback_tcpport = ret;
	dprintk("Callback port = 0x%x\n", nfs_callback_tcpport);

L
Linus Torvalds 已提交
129 130
	ret = svc_create_thread(nfs_callback_svc, serv);
	if (ret < 0)
131
		goto out_err;
L
Linus Torvalds 已提交
132 133 134
	nfs_callback_info.serv = serv;
	wait_for_completion(&nfs_callback_info.started);
out:
135 136 137 138 139 140 141 142
	/*
	 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
	 * svc_create_thread increments that. So we need to call svc_destroy
	 * on both success and failure so that the refcount is 1 when the
	 * thread exits.
	 */
	if (serv)
		svc_destroy(serv);
I
Ingo Molnar 已提交
143
	mutex_unlock(&nfs_callback_mutex);
L
Linus Torvalds 已提交
144 145
	unlock_kernel();
	return ret;
146
out_err:
147 148
	dprintk("Couldn't create callback socket or server thread; err = %d\n",
		ret);
L
Linus Torvalds 已提交
149 150 151 152 153 154 155
	nfs_callback_info.users--;
	goto out;
}

/*
 * Kill the server process if it is not already up.
 */
156
void nfs_callback_down(void)
L
Linus Torvalds 已提交
157 158
{
	lock_kernel();
I
Ingo Molnar 已提交
159
	mutex_lock(&nfs_callback_mutex);
160 161 162 163 164 165 166
	nfs_callback_info.users--;
	do {
		if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0)
			break;
		if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0)
			break;
	} while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0);
I
Ingo Molnar 已提交
167
	mutex_unlock(&nfs_callback_mutex);
L
Linus Torvalds 已提交
168 169 170 171 172
	unlock_kernel();
}

static int nfs_callback_authenticate(struct svc_rqst *rqstp)
{
173
	struct nfs_client *clp;
174
	char buf[RPC_MAX_ADDRBUFLEN];
L
Linus Torvalds 已提交
175 176

	/* Don't talk to strangers */
177
	clp = nfs_find_client(svc_addr(rqstp), 4);
L
Linus Torvalds 已提交
178 179
	if (clp == NULL)
		return SVC_DROP;
180 181 182

	dprintk("%s: %s NFSv4 callback!\n", __FUNCTION__,
			svc_print_addr(rqstp, buf, sizeof(buf)));
183
	nfs_put_client(clp);
184

L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
	switch (rqstp->rq_authop->flavour) {
		case RPC_AUTH_NULL:
			if (rqstp->rq_proc != CB_NULL)
				return SVC_DENIED;
			break;
		case RPC_AUTH_UNIX:
			break;
		case RPC_AUTH_GSS:
			/* FIXME: RPCSEC_GSS handling? */
		default:
			return SVC_DENIED;
	}
	return SVC_OK;
}

/*
 * Define NFS4 callback program
 */
static struct svc_version *nfs4_callback_version[] = {
	[1] = &nfs4_callback_version1,
};

static struct svc_stat nfs4_callback_stats;

static struct svc_program nfs4_callback_program = {
	.pg_prog = NFS4_CALLBACK,			/* RPC service number */
	.pg_nvers = ARRAY_SIZE(nfs4_callback_version),	/* Number of entries */
	.pg_vers = nfs4_callback_version,		/* version table */
	.pg_name = "NFSv4 callback",			/* service name */
	.pg_class = "nfs",				/* authentication class */
	.pg_stats = &nfs4_callback_stats,
	.pg_authenticate = nfs_callback_authenticate,
};