fs: use kmem_cache_zalloc instead
[pv_ops_mirror.git] / fs / nfs / callback.c
bloba796be5051bfa4886254f7bd40a9cb4f7ff4f7de
1 /*
2 * linux/fs/nfs/callback.c
4 * Copyright (C) 2004 Trond Myklebust
6 * NFSv4 callback handling
7 */
9 #include <linux/completion.h>
10 #include <linux/ip.h>
11 #include <linux/module.h>
12 #include <linux/smp_lock.h>
13 #include <linux/sunrpc/svc.h>
14 #include <linux/sunrpc/svcsock.h>
15 #include <linux/nfs_fs.h>
16 #include <linux/mutex.h>
17 #include <linux/freezer.h>
19 #include <net/inet_sock.h>
21 #include "nfs4_fs.h"
22 #include "callback.h"
23 #include "internal.h"
25 #define NFSDBG_FACILITY NFSDBG_CALLBACK
27 struct nfs_callback_data {
28 unsigned int users;
29 struct svc_serv *serv;
30 pid_t pid;
31 struct completion started;
32 struct completion stopped;
35 static struct nfs_callback_data nfs_callback_info;
36 static DEFINE_MUTEX(nfs_callback_mutex);
37 static struct svc_program nfs4_callback_program;
39 unsigned int nfs_callback_set_tcpport;
40 unsigned short nfs_callback_tcpport;
41 static const int nfs_set_port_min = 0;
42 static const int nfs_set_port_max = 65535;
44 static int param_set_port(const char *val, struct kernel_param *kp)
46 char *endp;
47 int num = simple_strtol(val, &endp, 0);
48 if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
49 return -EINVAL;
50 *((int *)kp->arg) = num;
51 return 0;
54 module_param_call(callback_tcpport, param_set_port, param_get_int,
55 &nfs_callback_set_tcpport, 0644);
58 * This is the callback kernel thread.
60 static void nfs_callback_svc(struct svc_rqst *rqstp)
62 int err;
64 __module_get(THIS_MODULE);
65 lock_kernel();
67 nfs_callback_info.pid = current->pid;
68 daemonize("nfsv4-svc");
69 /* Process request with signals blocked, but allow SIGKILL. */
70 allow_signal(SIGKILL);
71 set_freezable();
73 complete(&nfs_callback_info.started);
75 for(;;) {
76 char buf[RPC_MAX_ADDRBUFLEN];
78 if (signalled()) {
79 if (nfs_callback_info.users == 0)
80 break;
81 flush_signals(current);
84 * Listen for a request on the socket
86 err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
87 if (err == -EAGAIN || err == -EINTR)
88 continue;
89 if (err < 0) {
90 printk(KERN_WARNING
91 "%s: terminating on error %d\n",
92 __FUNCTION__, -err);
93 break;
95 dprintk("%s: request from %s\n", __FUNCTION__,
96 svc_print_addr(rqstp, buf, sizeof(buf)));
97 svc_process(rqstp);
100 svc_exit_thread(rqstp);
101 nfs_callback_info.pid = 0;
102 complete(&nfs_callback_info.stopped);
103 unlock_kernel();
104 module_put_and_exit(0);
108 * Bring up the server process if it is not already up.
110 int nfs_callback_up(void)
112 struct svc_serv *serv;
113 int ret = 0;
115 lock_kernel();
116 mutex_lock(&nfs_callback_mutex);
117 if (nfs_callback_info.users++ || nfs_callback_info.pid != 0)
118 goto out;
119 init_completion(&nfs_callback_info.started);
120 init_completion(&nfs_callback_info.stopped);
121 serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
122 ret = -ENOMEM;
123 if (!serv)
124 goto out_err;
126 ret = svc_makesock(serv, IPPROTO_TCP, nfs_callback_set_tcpport,
127 SVC_SOCK_ANONYMOUS);
128 if (ret <= 0)
129 goto out_destroy;
130 nfs_callback_tcpport = ret;
131 dprintk("Callback port = 0x%x\n", nfs_callback_tcpport);
133 ret = svc_create_thread(nfs_callback_svc, serv);
134 if (ret < 0)
135 goto out_destroy;
136 nfs_callback_info.serv = serv;
137 wait_for_completion(&nfs_callback_info.started);
138 out:
139 mutex_unlock(&nfs_callback_mutex);
140 unlock_kernel();
141 return ret;
142 out_destroy:
143 dprintk("Couldn't create callback socket or server thread; err = %d\n",
144 ret);
145 svc_destroy(serv);
146 out_err:
147 nfs_callback_info.users--;
148 goto out;
152 * Kill the server process if it is not already up.
154 void nfs_callback_down(void)
156 lock_kernel();
157 mutex_lock(&nfs_callback_mutex);
158 nfs_callback_info.users--;
159 do {
160 if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0)
161 break;
162 if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0)
163 break;
164 } while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0);
165 mutex_unlock(&nfs_callback_mutex);
166 unlock_kernel();
169 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
171 struct sockaddr_in *addr = svc_addr_in(rqstp);
172 struct nfs_client *clp;
173 char buf[RPC_MAX_ADDRBUFLEN];
175 /* Don't talk to strangers */
176 clp = nfs_find_client(addr, 4);
177 if (clp == NULL)
178 return SVC_DROP;
180 dprintk("%s: %s NFSv4 callback!\n", __FUNCTION__,
181 svc_print_addr(rqstp, buf, sizeof(buf)));
182 nfs_put_client(clp);
184 switch (rqstp->rq_authop->flavour) {
185 case RPC_AUTH_NULL:
186 if (rqstp->rq_proc != CB_NULL)
187 return SVC_DENIED;
188 break;
189 case RPC_AUTH_UNIX:
190 break;
191 case RPC_AUTH_GSS:
192 /* FIXME: RPCSEC_GSS handling? */
193 default:
194 return SVC_DENIED;
196 return SVC_OK;
200 * Define NFS4 callback program
202 static struct svc_version *nfs4_callback_version[] = {
203 [1] = &nfs4_callback_version1,
206 static struct svc_stat nfs4_callback_stats;
208 static struct svc_program nfs4_callback_program = {
209 .pg_prog = NFS4_CALLBACK, /* RPC service number */
210 .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */
211 .pg_vers = nfs4_callback_version, /* version table */
212 .pg_name = "NFSv4 callback", /* service name */
213 .pg_class = "nfs", /* authentication class */
214 .pg_stats = &nfs4_callback_stats,
215 .pg_authenticate = nfs_callback_authenticate,