blob: 42f3820ee8f543ca022d019b3b1de49e5907648c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfsd/nfsctl.c
3 *
4 * Syscall interface to knfsd.
5 *
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/module.h>
10
11#include <linux/linkage.h>
12#include <linux/time.h>
13#include <linux/errno.h>
14#include <linux/fs.h>
15#include <linux/fcntl.h>
16#include <linux/net.h>
17#include <linux/in.h>
18#include <linux/syscalls.h>
19#include <linux/unistd.h>
20#include <linux/slab.h>
21#include <linux/proc_fs.h>
22#include <linux/seq_file.h>
23#include <linux/pagemap.h>
24#include <linux/init.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050025#include <linux/inet.h>
NeilBrown70c3b762005-11-07 01:00:25 -080026#include <linux/string.h>
NeilBrown80212d52006-10-02 02:17:47 -070027#include <linux/smp_lock.h>
NeilBrownb41b66d2006-10-02 02:17:48 -070028#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <linux/nfs.h>
31#include <linux/nfsd_idmap.h>
NeilBrownb41b66d2006-10-02 02:17:48 -070032#include <linux/lockd/bind.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/sunrpc/svc.h>
NeilBrown80212d52006-10-02 02:17:47 -070034#include <linux/sunrpc/svcsock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/nfsd/nfsd.h>
36#include <linux/nfsd/cache.h>
37#include <linux/nfsd/xdr.h>
38#include <linux/nfsd/syscall.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050039#include <linux/lockd/lockd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include <asm/uaccess.h>
Aurélien Charbonf15364b2008-01-18 15:50:56 +010042#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44/*
45 * We have a single directory with 9 nodes in it.
46 */
47enum {
48 NFSD_Root = 1,
49 NFSD_Svc,
50 NFSD_Add,
51 NFSD_Del,
52 NFSD_Export,
53 NFSD_Unexport,
54 NFSD_Getfd,
55 NFSD_Getfs,
56 NFSD_List,
57 NFSD_Fh,
Wendy Cheng4373ea82008-01-17 11:10:12 -050058 NFSD_FO_UnlockIP,
Wendy Cheng17efa372008-01-17 11:10:12 -050059 NFSD_FO_UnlockFS,
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 NFSD_Threads,
Greg Bankseed29652006-10-02 02:18:02 -070061 NFSD_Pool_Threads,
NeilBrown70c3b762005-11-07 01:00:25 -080062 NFSD_Versions,
NeilBrown80212d52006-10-02 02:17:47 -070063 NFSD_Ports,
NeilBrown596bbe52006-10-04 02:15:48 -070064 NFSD_MaxBlkSize,
NeilBrown70c3b762005-11-07 01:00:25 -080065 /*
66 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
67 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
68 */
69#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 NFSD_Leasetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070071 NFSD_RecoveryDir,
NeilBrown70c3b762005-11-07 01:00:25 -080072#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
75/*
76 * write() for these nodes.
77 */
78static ssize_t write_svc(struct file *file, char *buf, size_t size);
79static ssize_t write_add(struct file *file, char *buf, size_t size);
80static ssize_t write_del(struct file *file, char *buf, size_t size);
81static ssize_t write_export(struct file *file, char *buf, size_t size);
82static ssize_t write_unexport(struct file *file, char *buf, size_t size);
83static ssize_t write_getfd(struct file *file, char *buf, size_t size);
84static ssize_t write_getfs(struct file *file, char *buf, size_t size);
85static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
86static ssize_t write_threads(struct file *file, char *buf, size_t size);
Greg Bankseed29652006-10-02 02:18:02 -070087static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080088static ssize_t write_versions(struct file *file, char *buf, size_t size);
NeilBrown80212d52006-10-02 02:17:47 -070089static ssize_t write_ports(struct file *file, char *buf, size_t size);
NeilBrown596bbe52006-10-04 02:15:48 -070090static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080091#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070092static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
NeilBrown0964a3d2005-06-23 22:04:32 -070093static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080094#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Wendy Cheng4373ea82008-01-17 11:10:12 -050096static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size);
Wendy Cheng17efa372008-01-17 11:10:12 -050097static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size);
Wendy Cheng4373ea82008-01-17 11:10:12 -050098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099static ssize_t (*write_op[])(struct file *, char *, size_t) = {
100 [NFSD_Svc] = write_svc,
101 [NFSD_Add] = write_add,
102 [NFSD_Del] = write_del,
103 [NFSD_Export] = write_export,
104 [NFSD_Unexport] = write_unexport,
105 [NFSD_Getfd] = write_getfd,
106 [NFSD_Getfs] = write_getfs,
107 [NFSD_Fh] = write_filehandle,
Wendy Cheng4373ea82008-01-17 11:10:12 -0500108 [NFSD_FO_UnlockIP] = failover_unlock_ip,
Wendy Cheng17efa372008-01-17 11:10:12 -0500109 [NFSD_FO_UnlockFS] = failover_unlock_fs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 [NFSD_Threads] = write_threads,
Greg Bankseed29652006-10-02 02:18:02 -0700111 [NFSD_Pool_Threads] = write_pool_threads,
NeilBrown70c3b762005-11-07 01:00:25 -0800112 [NFSD_Versions] = write_versions,
NeilBrown80212d52006-10-02 02:17:47 -0700113 [NFSD_Ports] = write_ports,
NeilBrown596bbe52006-10-04 02:15:48 -0700114 [NFSD_MaxBlkSize] = write_maxblksize,
NeilBrown70c3b762005-11-07 01:00:25 -0800115#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 [NFSD_Leasetime] = write_leasetime,
NeilBrown0964a3d2005-06-23 22:04:32 -0700117 [NFSD_RecoveryDir] = write_recoverydir,
NeilBrown70c3b762005-11-07 01:00:25 -0800118#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119};
120
121static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
122{
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -0800123 ino_t ino = file->f_path.dentry->d_inode->i_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 char *data;
125 ssize_t rv;
126
Tobias Klausere8c96f82006-03-24 03:15:34 -0800127 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return -EINVAL;
129
130 data = simple_transaction_get(file, buf, size);
131 if (IS_ERR(data))
132 return PTR_ERR(data);
133
134 rv = write_op[ino](file, data, size);
NeilBrown8971a102007-02-14 00:33:11 -0800135 if (rv >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 simple_transaction_set(file, rv);
137 rv = size;
138 }
139 return rv;
140}
141
NeilBrown73900222005-11-07 01:00:24 -0800142static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
143{
144 if (! file->private_data) {
145 /* An attempt to read a transaction file without writing
146 * causes a 0-byte write so that the file can return
147 * state information
148 */
149 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
150 if (rv < 0)
151 return rv;
152 }
153 return simple_transaction_read(file, buf, size, pos);
154}
155
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800156static const struct file_operations transaction_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 .write = nfsctl_transaction_write,
NeilBrown73900222005-11-07 01:00:24 -0800158 .read = nfsctl_transaction_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 .release = simple_transaction_release,
160};
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162static int exports_open(struct inode *inode, struct file *file)
163{
164 return seq_open(file, &nfs_exports_op);
165}
166
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800167static const struct file_operations exports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 .open = exports_open,
169 .read = seq_read,
170 .llseek = seq_lseek,
171 .release = seq_release,
172};
173
174/*----------------------------------------------------------------------------*/
175/*
176 * payload - write methods
177 * If the method has a response, the response should be put in buf,
178 * and the length returned. Otherwise return 0 or and -error.
179 */
180
181static ssize_t write_svc(struct file *file, char *buf, size_t size)
182{
183 struct nfsctl_svc *data;
184 if (size < sizeof(*data))
185 return -EINVAL;
186 data = (struct nfsctl_svc*) buf;
187 return nfsd_svc(data->svc_port, data->svc_nthreads);
188}
189
190static ssize_t write_add(struct file *file, char *buf, size_t size)
191{
192 struct nfsctl_client *data;
193 if (size < sizeof(*data))
194 return -EINVAL;
195 data = (struct nfsctl_client *)buf;
196 return exp_addclient(data);
197}
198
199static ssize_t write_del(struct file *file, char *buf, size_t size)
200{
201 struct nfsctl_client *data;
202 if (size < sizeof(*data))
203 return -EINVAL;
204 data = (struct nfsctl_client *)buf;
205 return exp_delclient(data);
206}
207
208static ssize_t write_export(struct file *file, char *buf, size_t size)
209{
210 struct nfsctl_export *data;
211 if (size < sizeof(*data))
212 return -EINVAL;
213 data = (struct nfsctl_export*)buf;
214 return exp_export(data);
215}
216
217static ssize_t write_unexport(struct file *file, char *buf, size_t size)
218{
219 struct nfsctl_export *data;
220
221 if (size < sizeof(*data))
222 return -EINVAL;
223 data = (struct nfsctl_export*)buf;
224 return exp_unexport(data);
225}
226
227static ssize_t write_getfs(struct file *file, char *buf, size_t size)
228{
229 struct nfsctl_fsparm *data;
230 struct sockaddr_in *sin;
231 struct auth_domain *clp;
232 int err = 0;
233 struct knfsd_fh *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100234 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 if (size < sizeof(*data))
237 return -EINVAL;
238 data = (struct nfsctl_fsparm*)buf;
239 err = -EPROTONOSUPPORT;
240 if (data->gd_addr.sa_family != AF_INET)
241 goto out;
242 sin = (struct sockaddr_in *)&data->gd_addr;
243 if (data->gd_maxlen > NFS3_FHSIZE)
244 data->gd_maxlen = NFS3_FHSIZE;
245
246 res = (struct knfsd_fh*)buf;
247
248 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100249
250 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
251
252 clp = auth_unix_lookup(&in6);
253 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 err = -EPERM;
255 else {
256 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
257 auth_domain_put(clp);
258 }
259 exp_readunlock();
260 if (err == 0)
Andrew Morton12127492007-07-17 04:04:34 -0700261 err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 out:
263 return err;
264}
265
266static ssize_t write_getfd(struct file *file, char *buf, size_t size)
267{
268 struct nfsctl_fdparm *data;
269 struct sockaddr_in *sin;
270 struct auth_domain *clp;
271 int err = 0;
272 struct knfsd_fh fh;
273 char *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100274 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 if (size < sizeof(*data))
277 return -EINVAL;
278 data = (struct nfsctl_fdparm*)buf;
279 err = -EPROTONOSUPPORT;
280 if (data->gd_addr.sa_family != AF_INET)
281 goto out;
282 err = -EINVAL;
283 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
284 goto out;
285
286 res = buf;
287 sin = (struct sockaddr_in *)&data->gd_addr;
288 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100289
290 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
291
292 clp = auth_unix_lookup(&in6);
293 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 err = -EPERM;
295 else {
296 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
297 auth_domain_put(clp);
298 }
299 exp_readunlock();
300
301 if (err == 0) {
302 memset(res,0, NFS_FHSIZE);
303 memcpy(res, &fh.fh_base, fh.fh_size);
304 err = NFS_FHSIZE;
305 }
306 out:
307 return err;
308}
309
Wendy Cheng4373ea82008-01-17 11:10:12 -0500310static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size)
311{
312 __be32 server_ip;
313 char *fo_path, c;
314 int b1, b2, b3, b4;
315
316 /* sanity check */
317 if (size == 0)
318 return -EINVAL;
319
320 if (buf[size-1] != '\n')
321 return -EINVAL;
322
323 fo_path = buf;
324 if (qword_get(&buf, fo_path, size) < 0)
325 return -EINVAL;
326
327 /* get ipv4 address */
328 if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4)
329 return -EINVAL;
330 server_ip = htonl((((((b1<<8)|b2)<<8)|b3)<<8)|b4);
331
332 return nlmsvc_unlock_all_by_ip(server_ip);
333}
334
Wendy Cheng17efa372008-01-17 11:10:12 -0500335static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size)
336{
337 struct nameidata nd;
338 char *fo_path;
339 int error;
340
341 /* sanity check */
342 if (size == 0)
343 return -EINVAL;
344
345 if (buf[size-1] != '\n')
346 return -EINVAL;
347
348 fo_path = buf;
349 if (qword_get(&buf, fo_path, size) < 0)
350 return -EINVAL;
351
352 error = path_lookup(fo_path, 0, &nd);
353 if (error)
354 return error;
355
356 error = nlmsvc_unlock_all_by_sb(nd.path.mnt->mnt_sb);
357
358 path_put(&nd.path);
359 return error;
360}
361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
363{
364 /* request is:
365 * domain path maxsize
366 * response is
367 * filehandle
368 *
369 * qword quoting is used, so filehandle will be \x....
370 */
371 char *dname, *path;
Andrew Morton246d95b2007-08-09 00:53:50 -0700372 int uninitialized_var(maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 char *mesg = buf;
374 int len;
375 struct auth_domain *dom;
376 struct knfsd_fh fh;
377
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500378 if (size == 0)
379 return -EINVAL;
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (buf[size-1] != '\n')
382 return -EINVAL;
383 buf[size-1] = 0;
384
385 dname = mesg;
386 len = qword_get(&mesg, dname, size);
387 if (len <= 0) return -EINVAL;
388
389 path = dname+len+1;
390 len = qword_get(&mesg, path, size);
391 if (len <= 0) return -EINVAL;
392
393 len = get_int(&mesg, &maxsize);
394 if (len)
395 return len;
396
397 if (maxsize < NFS_FHSIZE)
398 return -EINVAL;
399 if (maxsize > NFS3_FHSIZE)
400 maxsize = NFS3_FHSIZE;
401
402 if (qword_get(&mesg, mesg, size)>0)
403 return -EINVAL;
404
405 /* we have all the words, they are in buf.. */
406 dom = unix_domain_find(dname);
407 if (!dom)
408 return -ENOMEM;
409
410 len = exp_rootfh(dom, path, &fh, maxsize);
411 auth_domain_put(dom);
412 if (len)
413 return len;
414
415 mesg = buf; len = SIMPLE_TRANSACTION_LIMIT;
416 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
417 mesg[-1] = '\n';
418 return mesg - buf;
419}
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421static ssize_t write_threads(struct file *file, char *buf, size_t size)
422{
423 /* if size > 0, look for a number of threads and call nfsd_svc
424 * then write out number of threads as reply
425 */
426 char *mesg = buf;
427 int rv;
428 if (size > 0) {
429 int newthreads;
430 rv = get_int(&mesg, &newthreads);
431 if (rv)
432 return rv;
433 if (newthreads <0)
434 return -EINVAL;
435 rv = nfsd_svc(2049, newthreads);
436 if (rv)
437 return rv;
438 }
439 sprintf(buf, "%d\n", nfsd_nrthreads());
440 return strlen(buf);
441}
442
Greg Bankseed29652006-10-02 02:18:02 -0700443static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
444{
445 /* if size > 0, look for an array of number of threads per node
446 * and apply them then write out number of threads per node as reply
447 */
448 char *mesg = buf;
449 int i;
450 int rv;
451 int len;
452 int npools = nfsd_nrpools();
453 int *nthreads;
454
455 if (npools == 0) {
456 /*
457 * NFS is shut down. The admin can start it by
458 * writing to the threads file but NOT the pool_threads
459 * file, sorry. Report zero threads.
460 */
461 strcpy(buf, "0\n");
462 return strlen(buf);
463 }
464
465 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
466 if (nthreads == NULL)
467 return -ENOMEM;
468
469 if (size > 0) {
470 for (i = 0; i < npools; i++) {
471 rv = get_int(&mesg, &nthreads[i]);
472 if (rv == -ENOENT)
473 break; /* fewer numbers than pools */
474 if (rv)
475 goto out_free; /* syntax error */
476 rv = -EINVAL;
477 if (nthreads[i] < 0)
478 goto out_free;
479 }
480 rv = nfsd_set_nrthreads(i, nthreads);
481 if (rv)
482 goto out_free;
483 }
484
485 rv = nfsd_get_nrthreads(npools, nthreads);
486 if (rv)
487 goto out_free;
488
489 mesg = buf;
490 size = SIMPLE_TRANSACTION_LIMIT;
491 for (i = 0; i < npools && size > 0; i++) {
492 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
493 len = strlen(mesg);
494 size -= len;
495 mesg += len;
496 }
497
498 return (mesg-buf);
499
500out_free:
501 kfree(nthreads);
502 return rv;
503}
504
NeilBrown70c3b762005-11-07 01:00:25 -0800505static ssize_t write_versions(struct file *file, char *buf, size_t size)
506{
507 /*
508 * Format:
509 * [-/+]vers [-/+]vers ...
510 */
511 char *mesg = buf;
512 char *vers, sign;
513 int len, num;
514 ssize_t tlen = 0;
515 char *sep;
516
517 if (size>0) {
518 if (nfsd_serv)
NeilBrown6658d3a2006-10-02 02:17:46 -0700519 /* Cannot change versions without updating
520 * nfsd_serv->sv_xdrsize, and reallocing
521 * rq_argp and rq_resp
522 */
NeilBrown70c3b762005-11-07 01:00:25 -0800523 return -EBUSY;
524 if (buf[size-1] != '\n')
525 return -EINVAL;
526 buf[size-1] = 0;
527
528 vers = mesg;
529 len = qword_get(&mesg, vers, size);
530 if (len <= 0) return -EINVAL;
531 do {
532 sign = *vers;
533 if (sign == '+' || sign == '-')
534 num = simple_strtol((vers+1), NULL, 0);
535 else
536 num = simple_strtol(vers, NULL, 0);
537 switch(num) {
538 case 2:
539 case 3:
540 case 4:
NeilBrown6658d3a2006-10-02 02:17:46 -0700541 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
NeilBrown70c3b762005-11-07 01:00:25 -0800542 break;
543 default:
544 return -EINVAL;
545 }
546 vers += len + 1;
547 tlen += len;
548 } while ((len = qword_get(&mesg, vers, size)) > 0);
549 /* If all get turned off, turn them back on, as
550 * having no versions is BAD
551 */
NeilBrown6658d3a2006-10-02 02:17:46 -0700552 nfsd_reset_versions();
NeilBrown70c3b762005-11-07 01:00:25 -0800553 }
554 /* Now write current state into reply buffer */
555 len = 0;
556 sep = "";
557 for (num=2 ; num <= 4 ; num++)
NeilBrown6658d3a2006-10-02 02:17:46 -0700558 if (nfsd_vers(num, NFSD_AVAIL)) {
NeilBrown70c3b762005-11-07 01:00:25 -0800559 len += sprintf(buf+len, "%s%c%d", sep,
NeilBrown6658d3a2006-10-02 02:17:46 -0700560 nfsd_vers(num, NFSD_TEST)?'+':'-',
NeilBrown70c3b762005-11-07 01:00:25 -0800561 num);
562 sep = " ";
563 }
564 len += sprintf(buf+len, "\n");
565 return len;
566}
567
NeilBrown80212d52006-10-02 02:17:47 -0700568static ssize_t write_ports(struct file *file, char *buf, size_t size)
569{
NeilBrownb41b66d2006-10-02 02:17:48 -0700570 if (size == 0) {
571 int len = 0;
572 lock_kernel();
573 if (nfsd_serv)
Tom Tucker9571af12007-12-30 21:08:37 -0600574 len = svc_xprt_names(nfsd_serv, buf, 0);
NeilBrownb41b66d2006-10-02 02:17:48 -0700575 unlock_kernel();
576 return len;
577 }
578 /* Either a single 'fd' number is written, in which
579 * case it must be for a socket of a supported family/protocol,
580 * and we use it as an nfsd socket, or
581 * A '-' followed by the 'name' of a socket in which case
582 * we close the socket.
NeilBrown80212d52006-10-02 02:17:47 -0700583 */
NeilBrownb41b66d2006-10-02 02:17:48 -0700584 if (isdigit(buf[0])) {
585 char *mesg = buf;
586 int fd;
587 int err;
588 err = get_int(&mesg, &fd);
589 if (err)
590 return -EINVAL;
591 if (fd < 0)
592 return -EINVAL;
593 err = nfsd_create_serv();
594 if (!err) {
595 int proto = 0;
NeilBrown5680c442006-10-04 02:15:45 -0700596 err = svc_addsock(nfsd_serv, fd, buf, &proto);
597 if (err >= 0) {
598 err = lockd_up(proto);
599 if (err < 0)
600 svc_sock_names(buf+strlen(buf)+1, nfsd_serv, buf);
NeilBrown3dfb4212006-10-02 02:17:51 -0700601 }
NeilBrownb41b66d2006-10-02 02:17:48 -0700602 /* Decrease the count, but don't shutdown the
603 * the service
604 */
NeilBrowncda9e0c2006-10-04 02:15:44 -0700605 lock_kernel();
NeilBrownb41b66d2006-10-02 02:17:48 -0700606 nfsd_serv->sv_nrthreads--;
NeilBrowncda9e0c2006-10-04 02:15:44 -0700607 unlock_kernel();
NeilBrownb41b66d2006-10-02 02:17:48 -0700608 }
NeilBrown5680c442006-10-04 02:15:45 -0700609 return err < 0 ? err : 0;
NeilBrownb41b66d2006-10-02 02:17:48 -0700610 }
Tom Tuckera2178132007-12-30 21:08:35 -0600611 if (buf[0] == '-' && isdigit(buf[1])) {
NeilBrownb41b66d2006-10-02 02:17:48 -0700612 char *toclose = kstrdup(buf+1, GFP_KERNEL);
613 int len = 0;
614 if (!toclose)
615 return -ENOMEM;
616 lock_kernel();
617 if (nfsd_serv)
618 len = svc_sock_names(buf, nfsd_serv, toclose);
619 unlock_kernel();
NeilBrown37a03472006-10-04 02:15:44 -0700620 if (len >= 0)
621 lockd_down();
NeilBrownb41b66d2006-10-02 02:17:48 -0700622 kfree(toclose);
623 return len;
624 }
Tom Tuckera2178132007-12-30 21:08:35 -0600625 /*
626 * Add a transport listener by writing it's transport name
627 */
628 if (isalpha(buf[0])) {
629 int err;
630 char transport[16];
631 int port;
632 if (sscanf(buf, "%15s %4d", transport, &port) == 2) {
633 err = nfsd_create_serv();
634 if (!err) {
635 err = svc_create_xprt(nfsd_serv,
636 transport, port,
637 SVC_SOCK_ANONYMOUS);
638 if (err == -ENOENT)
639 /* Give a reasonable perror msg for
640 * bad transport string */
641 err = -EPROTONOSUPPORT;
642 }
643 return err < 0 ? err : 0;
644 }
645 }
646 /*
647 * Remove a transport by writing it's transport name and port number
648 */
649 if (buf[0] == '-' && isalpha(buf[1])) {
650 struct svc_xprt *xprt;
651 int err = -EINVAL;
652 char transport[16];
653 int port;
654 if (sscanf(&buf[1], "%15s %4d", transport, &port) == 2) {
655 if (port == 0)
656 return -EINVAL;
657 lock_kernel();
658 if (nfsd_serv) {
659 xprt = svc_find_xprt(nfsd_serv, transport,
660 AF_UNSPEC, port);
661 if (xprt) {
662 svc_close_xprt(xprt);
663 svc_xprt_put(xprt);
664 err = 0;
665 } else
666 err = -ENOTCONN;
667 }
668 unlock_kernel();
669 return err < 0 ? err : 0;
670 }
671 }
NeilBrownb41b66d2006-10-02 02:17:48 -0700672 return -EINVAL;
NeilBrown80212d52006-10-02 02:17:47 -0700673}
674
NeilBrown596bbe52006-10-04 02:15:48 -0700675int nfsd_max_blksize;
676
677static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
678{
679 char *mesg = buf;
680 if (size > 0) {
681 int bsize;
682 int rv = get_int(&mesg, &bsize);
683 if (rv)
684 return rv;
685 /* force bsize into allowed range and
686 * required alignment.
687 */
688 if (bsize < 1024)
689 bsize = 1024;
690 if (bsize > NFSSVC_MAXBLKSIZE)
691 bsize = NFSSVC_MAXBLKSIZE;
692 bsize &= ~(1024-1);
693 lock_kernel();
694 if (nfsd_serv && nfsd_serv->sv_nrthreads) {
695 unlock_kernel();
696 return -EBUSY;
697 }
698 nfsd_max_blksize = bsize;
699 unlock_kernel();
700 }
701 return sprintf(buf, "%d\n", nfsd_max_blksize);
702}
703
NeilBrown70c3b762005-11-07 01:00:25 -0800704#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705extern time_t nfs4_leasetime(void);
706
707static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
708{
709 /* if size > 10 seconds, call
710 * nfs4_reset_lease() then write out the new lease (seconds) as reply
711 */
712 char *mesg = buf;
713 int rv;
714
715 if (size > 0) {
716 int lease;
717 rv = get_int(&mesg, &lease);
718 if (rv)
719 return rv;
720 if (lease < 10 || lease > 3600)
721 return -EINVAL;
722 nfs4_reset_lease(lease);
723 }
724 sprintf(buf, "%ld\n", nfs4_lease_time());
725 return strlen(buf);
726}
727
NeilBrown0964a3d2005-06-23 22:04:32 -0700728static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
729{
730 char *mesg = buf;
731 char *recdir;
732 int len, status;
733
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500734 if (size == 0 || size > PATH_MAX || buf[size-1] != '\n')
NeilBrown0964a3d2005-06-23 22:04:32 -0700735 return -EINVAL;
736 buf[size-1] = 0;
737
738 recdir = mesg;
739 len = qword_get(&mesg, recdir, size);
740 if (len <= 0)
741 return -EINVAL;
742
743 status = nfs4_reset_recoverydir(recdir);
744 return strlen(buf);
745}
NeilBrown70c3b762005-11-07 01:00:25 -0800746#endif
NeilBrown0964a3d2005-06-23 22:04:32 -0700747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748/*----------------------------------------------------------------------------*/
749/*
750 * populating the filesystem.
751 */
752
753static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
754{
755 static struct tree_descr nfsd_files[] = {
756 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
757 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
758 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
759 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
760 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
761 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
762 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
763 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
Wendy Cheng4373ea82008-01-17 11:10:12 -0500764 [NFSD_FO_UnlockIP] = {"unlock_ip",
765 &transaction_ops, S_IWUSR|S_IRUSR},
Wendy Cheng17efa372008-01-17 11:10:12 -0500766 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
767 &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
769 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Bankseed29652006-10-02 02:18:02 -0700770 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown70c3b762005-11-07 01:00:25 -0800771 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown80212d52006-10-02 02:17:47 -0700772 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
NeilBrown596bbe52006-10-04 02:15:48 -0700773 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774#ifdef CONFIG_NFSD_V4
775 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown0964a3d2005-06-23 22:04:32 -0700776 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777#endif
778 /* last one */ {""}
779 };
780 return simple_fill_super(sb, 0x6e667364, nfsd_files);
781}
782
David Howells454e2392006-06-23 02:02:57 -0700783static int nfsd_get_sb(struct file_system_type *fs_type,
784 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
David Howells454e2392006-06-23 02:02:57 -0700786 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
789static struct file_system_type nfsd_fs_type = {
790 .owner = THIS_MODULE,
791 .name = "nfsd",
792 .get_sb = nfsd_get_sb,
793 .kill_sb = kill_litter_super,
794};
795
J. Bruce Fieldse331f602007-11-12 17:32:21 -0500796#ifdef CONFIG_PROC_FS
797static int create_proc_exports_entry(void)
798{
799 struct proc_dir_entry *entry;
800
801 entry = proc_mkdir("fs/nfs", NULL);
802 if (!entry)
803 return -ENOMEM;
804 entry = create_proc_entry("fs/nfs/exports", 0, NULL);
805 if (!entry)
806 return -ENOMEM;
807 entry->proc_fops = &exports_operations;
808 return 0;
809}
810#else /* CONFIG_PROC_FS */
811static int create_proc_exports_entry(void)
812{
813 return 0;
814}
815#endif
816
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817static int __init init_nfsd(void)
818{
819 int retval;
820 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
821
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -0400822 retval = nfs4_state_init(); /* nfs4 locking state */
823 if (retval)
824 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 nfsd_stat_init(); /* Statistics */
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -0500826 retval = nfsd_reply_cache_init();
827 if (retval)
828 goto out_free_stat;
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -0500829 retval = nfsd_export_init();
830 if (retval)
831 goto out_free_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 nfsd_lockd_init(); /* lockd->nfsd callbacks */
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -0500833 retval = nfsd_idmap_init();
834 if (retval)
835 goto out_free_lockd;
J. Bruce Fieldse331f602007-11-12 17:32:21 -0500836 retval = create_proc_exports_entry();
837 if (retval)
838 goto out_free_idmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 retval = register_filesystem(&nfsd_fs_type);
J. Bruce Fields26808d32007-11-09 13:44:06 -0500840 if (retval)
841 goto out_free_all;
842 return 0;
843out_free_all:
J. Bruce Fields26808d32007-11-09 13:44:06 -0500844 remove_proc_entry("fs/nfs/exports", NULL);
845 remove_proc_entry("fs/nfs", NULL);
J. Bruce Fieldse331f602007-11-12 17:32:21 -0500846out_free_idmap:
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -0500847 nfsd_idmap_shutdown();
848out_free_lockd:
J. Bruce Fields26808d32007-11-09 13:44:06 -0500849 nfsd_lockd_shutdown();
J. Bruce Fieldse331f602007-11-12 17:32:21 -0500850 nfsd_export_shutdown();
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -0500851out_free_cache:
J. Bruce Fieldse331f602007-11-12 17:32:21 -0500852 nfsd_reply_cache_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -0500853out_free_stat:
854 nfsd_stat_shutdown();
J. Bruce Fields26808d32007-11-09 13:44:06 -0500855 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return retval;
857}
858
859static void __exit exit_nfsd(void)
860{
861 nfsd_export_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -0500862 nfsd_reply_cache_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 remove_proc_entry("fs/nfs/exports", NULL);
864 remove_proc_entry("fs/nfs", NULL);
865 nfsd_stat_shutdown();
866 nfsd_lockd_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 nfsd_idmap_shutdown();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -0400868 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 unregister_filesystem(&nfsd_fs_type);
870}
871
872MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
873MODULE_LICENSE("GPL");
874module_init(init_nfsd)
875module_exit(exit_nfsd)