blob: 1250fb978ac1451b8d00f87bfe5183eb12d9f26f [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>
Al Viro3f8206d2008-07-26 03:46:43 -040015#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/fcntl.h>
17#include <linux/net.h>
18#include <linux/in.h>
19#include <linux/syscalls.h>
20#include <linux/unistd.h>
21#include <linux/slab.h>
22#include <linux/proc_fs.h>
23#include <linux/seq_file.h>
24#include <linux/pagemap.h>
25#include <linux/init.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050026#include <linux/inet.h>
NeilBrown70c3b762005-11-07 01:00:25 -080027#include <linux/string.h>
NeilBrown80212d52006-10-02 02:17:47 -070028#include <linux/smp_lock.h>
NeilBrownb41b66d2006-10-02 02:17:48 -070029#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <linux/nfs.h>
32#include <linux/nfsd_idmap.h>
NeilBrownb41b66d2006-10-02 02:17:48 -070033#include <linux/lockd/bind.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sunrpc/svc.h>
NeilBrown80212d52006-10-02 02:17:47 -070035#include <linux/sunrpc/svcsock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/nfsd/nfsd.h>
37#include <linux/nfsd/cache.h>
38#include <linux/nfsd/xdr.h>
39#include <linux/nfsd/syscall.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050040#include <linux/lockd/lockd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/uaccess.h>
Aurélien Charbonf15364b2008-01-18 15:50:56 +010043#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45/*
46 * We have a single directory with 9 nodes in it.
47 */
48enum {
49 NFSD_Root = 1,
50 NFSD_Svc,
51 NFSD_Add,
52 NFSD_Del,
53 NFSD_Export,
54 NFSD_Unexport,
55 NFSD_Getfd,
56 NFSD_Getfs,
57 NFSD_List,
58 NFSD_Fh,
Wendy Cheng4373ea82008-01-17 11:10:12 -050059 NFSD_FO_UnlockIP,
Wendy Cheng17efa372008-01-17 11:10:12 -050060 NFSD_FO_UnlockFS,
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 NFSD_Threads,
Greg Bankseed29652006-10-02 02:18:02 -070062 NFSD_Pool_Threads,
Greg Banks03cf6c92009-01-13 21:26:36 +110063 NFSD_Pool_Stats,
NeilBrown70c3b762005-11-07 01:00:25 -080064 NFSD_Versions,
NeilBrown80212d52006-10-02 02:17:47 -070065 NFSD_Ports,
NeilBrown596bbe52006-10-04 02:15:48 -070066 NFSD_MaxBlkSize,
NeilBrown70c3b762005-11-07 01:00:25 -080067 /*
68 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
69 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
70 */
71#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 NFSD_Leasetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070073 NFSD_RecoveryDir,
NeilBrown70c3b762005-11-07 01:00:25 -080074#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
77/*
78 * write() for these nodes.
79 */
80static ssize_t write_svc(struct file *file, char *buf, size_t size);
81static ssize_t write_add(struct file *file, char *buf, size_t size);
82static ssize_t write_del(struct file *file, char *buf, size_t size);
83static ssize_t write_export(struct file *file, char *buf, size_t size);
84static ssize_t write_unexport(struct file *file, char *buf, size_t size);
85static ssize_t write_getfd(struct file *file, char *buf, size_t size);
86static ssize_t write_getfs(struct file *file, char *buf, size_t size);
87static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
Chuck Leverb046ccd2008-12-12 16:57:13 -050088static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
89static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static ssize_t write_threads(struct file *file, char *buf, size_t size);
Greg Bankseed29652006-10-02 02:18:02 -070091static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080092static ssize_t write_versions(struct file *file, char *buf, size_t size);
NeilBrown80212d52006-10-02 02:17:47 -070093static ssize_t write_ports(struct file *file, char *buf, size_t size);
NeilBrown596bbe52006-10-04 02:15:48 -070094static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080095#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
NeilBrown0964a3d2005-06-23 22:04:32 -070097static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080098#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100static ssize_t (*write_op[])(struct file *, char *, size_t) = {
101 [NFSD_Svc] = write_svc,
102 [NFSD_Add] = write_add,
103 [NFSD_Del] = write_del,
104 [NFSD_Export] = write_export,
105 [NFSD_Unexport] = write_unexport,
106 [NFSD_Getfd] = write_getfd,
107 [NFSD_Getfs] = write_getfs,
108 [NFSD_Fh] = write_filehandle,
Chuck Leverb046ccd2008-12-12 16:57:13 -0500109 [NFSD_FO_UnlockIP] = write_unlock_ip,
110 [NFSD_FO_UnlockFS] = write_unlock_fs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 [NFSD_Threads] = write_threads,
Greg Bankseed29652006-10-02 02:18:02 -0700112 [NFSD_Pool_Threads] = write_pool_threads,
NeilBrown70c3b762005-11-07 01:00:25 -0800113 [NFSD_Versions] = write_versions,
NeilBrown80212d52006-10-02 02:17:47 -0700114 [NFSD_Ports] = write_ports,
NeilBrown596bbe52006-10-04 02:15:48 -0700115 [NFSD_MaxBlkSize] = write_maxblksize,
NeilBrown70c3b762005-11-07 01:00:25 -0800116#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 [NFSD_Leasetime] = write_leasetime,
NeilBrown0964a3d2005-06-23 22:04:32 -0700118 [NFSD_RecoveryDir] = write_recoverydir,
NeilBrown70c3b762005-11-07 01:00:25 -0800119#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120};
121
122static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
123{
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -0800124 ino_t ino = file->f_path.dentry->d_inode->i_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 char *data;
126 ssize_t rv;
127
Tobias Klausere8c96f82006-03-24 03:15:34 -0800128 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return -EINVAL;
130
131 data = simple_transaction_get(file, buf, size);
132 if (IS_ERR(data))
133 return PTR_ERR(data);
134
135 rv = write_op[ino](file, data, size);
NeilBrown8971a102007-02-14 00:33:11 -0800136 if (rv >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 simple_transaction_set(file, rv);
138 rv = size;
139 }
140 return rv;
141}
142
NeilBrown73900222005-11-07 01:00:24 -0800143static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
144{
145 if (! file->private_data) {
146 /* An attempt to read a transaction file without writing
147 * causes a 0-byte write so that the file can return
148 * state information
149 */
150 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
151 if (rv < 0)
152 return rv;
153 }
154 return simple_transaction_read(file, buf, size, pos);
155}
156
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800157static const struct file_operations transaction_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 .write = nfsctl_transaction_write,
NeilBrown73900222005-11-07 01:00:24 -0800159 .read = nfsctl_transaction_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 .release = simple_transaction_release,
161};
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163static int exports_open(struct inode *inode, struct file *file)
164{
165 return seq_open(file, &nfs_exports_op);
166}
167
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800168static const struct file_operations exports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 .open = exports_open,
170 .read = seq_read,
171 .llseek = seq_lseek,
172 .release = seq_release,
Denis V. Lunev9ef2db22008-04-29 01:02:04 -0700173 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174};
175
Greg Banks03cf6c92009-01-13 21:26:36 +1100176extern int nfsd_pool_stats_open(struct inode *inode, struct file *file);
177
178static struct file_operations pool_stats_operations = {
179 .open = nfsd_pool_stats_open,
180 .read = seq_read,
181 .llseek = seq_lseek,
182 .release = seq_release,
183 .owner = THIS_MODULE,
184};
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186/*----------------------------------------------------------------------------*/
187/*
188 * payload - write methods
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 */
190
Chuck Lever262a0982008-12-12 16:57:35 -0500191/**
192 * write_svc - Start kernel's NFSD server
193 *
194 * Deprecated. /proc/fs/nfsd/threads is preferred.
195 * Function remains to support old versions of nfs-utils.
196 *
197 * Input:
198 * buf: struct nfsctl_svc
199 * svc_port: port number of this
200 * server's listener
201 * svc_nthreads: number of threads to start
202 * size: size in bytes of passed in nfsctl_svc
203 * Output:
204 * On success: returns zero
205 * On error: return code is negative errno value
206 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207static ssize_t write_svc(struct file *file, char *buf, size_t size)
208{
209 struct nfsctl_svc *data;
NeilBrown82e12fe2009-06-16 11:03:07 +1000210 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (size < sizeof(*data))
212 return -EINVAL;
213 data = (struct nfsctl_svc*) buf;
NeilBrown82e12fe2009-06-16 11:03:07 +1000214 err = nfsd_svc(data->svc_port, data->svc_nthreads);
215 if (err < 0)
216 return err;
217 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
Chuck Lever262a0982008-12-12 16:57:35 -0500220/**
221 * write_add - Add or modify client entry in auth unix cache
222 *
223 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
224 * Function remains to support old versions of nfs-utils.
225 *
226 * Input:
227 * buf: struct nfsctl_client
228 * cl_ident: '\0'-terminated C string
229 * containing domain name
230 * of client
231 * cl_naddr: no. of items in cl_addrlist
232 * cl_addrlist: array of client addresses
233 * cl_fhkeytype: ignored
234 * cl_fhkeylen: ignored
235 * cl_fhkey: ignored
236 * size: size in bytes of passed in nfsctl_client
237 * Output:
238 * On success: returns zero
239 * On error: return code is negative errno value
240 *
241 * Note: Only AF_INET client addresses are passed in, since
242 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
243 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244static ssize_t write_add(struct file *file, char *buf, size_t size)
245{
246 struct nfsctl_client *data;
247 if (size < sizeof(*data))
248 return -EINVAL;
249 data = (struct nfsctl_client *)buf;
250 return exp_addclient(data);
251}
252
Chuck Lever262a0982008-12-12 16:57:35 -0500253/**
254 * write_del - Remove client from auth unix cache
255 *
256 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
257 * Function remains to support old versions of nfs-utils.
258 *
259 * Input:
260 * buf: struct nfsctl_client
261 * cl_ident: '\0'-terminated C string
262 * containing domain name
263 * of client
264 * cl_naddr: ignored
265 * cl_addrlist: ignored
266 * cl_fhkeytype: ignored
267 * cl_fhkeylen: ignored
268 * cl_fhkey: ignored
269 * size: size in bytes of passed in nfsctl_client
270 * Output:
271 * On success: returns zero
272 * On error: return code is negative errno value
273 *
274 * Note: Only AF_INET client addresses are passed in, since
275 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
276 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277static ssize_t write_del(struct file *file, char *buf, size_t size)
278{
279 struct nfsctl_client *data;
280 if (size < sizeof(*data))
281 return -EINVAL;
282 data = (struct nfsctl_client *)buf;
283 return exp_delclient(data);
284}
285
Chuck Lever262a0982008-12-12 16:57:35 -0500286/**
287 * write_export - Export part or all of a local file system
288 *
289 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
290 * Function remains to support old versions of nfs-utils.
291 *
292 * Input:
293 * buf: struct nfsctl_export
294 * ex_client: '\0'-terminated C string
295 * containing domain name
296 * of client allowed to access
297 * this export
298 * ex_path: '\0'-terminated C string
299 * containing pathname of
300 * directory in local file system
301 * ex_dev: fsid to use for this export
302 * ex_ino: ignored
303 * ex_flags: export flags for this export
304 * ex_anon_uid: UID to use for anonymous
305 * requests
306 * ex_anon_gid: GID to use for anonymous
307 * requests
308 * size: size in bytes of passed in nfsctl_export
309 * Output:
310 * On success: returns zero
311 * On error: return code is negative errno value
312 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313static ssize_t write_export(struct file *file, char *buf, size_t size)
314{
315 struct nfsctl_export *data;
316 if (size < sizeof(*data))
317 return -EINVAL;
318 data = (struct nfsctl_export*)buf;
319 return exp_export(data);
320}
321
Chuck Lever262a0982008-12-12 16:57:35 -0500322/**
323 * write_unexport - Unexport a previously exported file system
324 *
325 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
326 * Function remains to support old versions of nfs-utils.
327 *
328 * Input:
329 * buf: struct nfsctl_export
330 * ex_client: '\0'-terminated C string
331 * containing domain name
332 * of client no longer allowed
333 * to access this export
334 * ex_path: '\0'-terminated C string
335 * containing pathname of
336 * directory in local file system
337 * ex_dev: ignored
338 * ex_ino: ignored
339 * ex_flags: ignored
340 * ex_anon_uid: ignored
341 * ex_anon_gid: ignored
342 * size: size in bytes of passed in nfsctl_export
343 * Output:
344 * On success: returns zero
345 * On error: return code is negative errno value
346 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347static ssize_t write_unexport(struct file *file, char *buf, size_t size)
348{
349 struct nfsctl_export *data;
350
351 if (size < sizeof(*data))
352 return -EINVAL;
353 data = (struct nfsctl_export*)buf;
354 return exp_unexport(data);
355}
356
Chuck Lever262a0982008-12-12 16:57:35 -0500357/**
358 * write_getfs - Get a variable-length NFS file handle by path
359 *
360 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
361 * Function remains to support old versions of nfs-utils.
362 *
363 * Input:
364 * buf: struct nfsctl_fsparm
365 * gd_addr: socket address of client
366 * gd_path: '\0'-terminated C string
367 * containing pathname of
368 * directory in local file system
369 * gd_maxlen: maximum size of returned file
370 * handle
371 * size: size in bytes of passed in nfsctl_fsparm
372 * Output:
373 * On success: passed-in buffer filled with a knfsd_fh structure
374 * (a variable-length raw NFS file handle);
375 * return code is the size in bytes of the file handle
376 * On error: return code is negative errno value
377 *
378 * Note: Only AF_INET client addresses are passed in, since gd_addr
379 * is the same size as a struct sockaddr_in.
380 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381static ssize_t write_getfs(struct file *file, char *buf, size_t size)
382{
383 struct nfsctl_fsparm *data;
384 struct sockaddr_in *sin;
385 struct auth_domain *clp;
386 int err = 0;
387 struct knfsd_fh *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100388 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 if (size < sizeof(*data))
391 return -EINVAL;
392 data = (struct nfsctl_fsparm*)buf;
393 err = -EPROTONOSUPPORT;
394 if (data->gd_addr.sa_family != AF_INET)
395 goto out;
396 sin = (struct sockaddr_in *)&data->gd_addr;
397 if (data->gd_maxlen > NFS3_FHSIZE)
398 data->gd_maxlen = NFS3_FHSIZE;
399
400 res = (struct knfsd_fh*)buf;
401
402 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100403
404 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
405
406 clp = auth_unix_lookup(&in6);
407 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 err = -EPERM;
409 else {
410 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
411 auth_domain_put(clp);
412 }
413 exp_readunlock();
414 if (err == 0)
Andrew Morton12127492007-07-17 04:04:34 -0700415 err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 out:
417 return err;
418}
419
Chuck Lever262a0982008-12-12 16:57:35 -0500420/**
421 * write_getfd - Get a fixed-length NFS file handle by path (used by mountd)
422 *
423 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
424 * Function remains to support old versions of nfs-utils.
425 *
426 * Input:
427 * buf: struct nfsctl_fdparm
428 * gd_addr: socket address of client
429 * gd_path: '\0'-terminated C string
430 * containing pathname of
431 * directory in local file system
432 * gd_version: fdparm structure version
433 * size: size in bytes of passed in nfsctl_fdparm
434 * Output:
435 * On success: passed-in buffer filled with nfsctl_res
436 * (a fixed-length raw NFS file handle);
437 * return code is the size in bytes of the file handle
438 * On error: return code is negative errno value
439 *
440 * Note: Only AF_INET client addresses are passed in, since gd_addr
441 * is the same size as a struct sockaddr_in.
442 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443static ssize_t write_getfd(struct file *file, char *buf, size_t size)
444{
445 struct nfsctl_fdparm *data;
446 struct sockaddr_in *sin;
447 struct auth_domain *clp;
448 int err = 0;
449 struct knfsd_fh fh;
450 char *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100451 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 if (size < sizeof(*data))
454 return -EINVAL;
455 data = (struct nfsctl_fdparm*)buf;
456 err = -EPROTONOSUPPORT;
457 if (data->gd_addr.sa_family != AF_INET)
458 goto out;
459 err = -EINVAL;
460 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
461 goto out;
462
463 res = buf;
464 sin = (struct sockaddr_in *)&data->gd_addr;
465 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100466
467 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
468
469 clp = auth_unix_lookup(&in6);
470 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 err = -EPERM;
472 else {
473 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
474 auth_domain_put(clp);
475 }
476 exp_readunlock();
477
478 if (err == 0) {
479 memset(res,0, NFS_FHSIZE);
480 memcpy(res, &fh.fh_base, fh.fh_size);
481 err = NFS_FHSIZE;
482 }
483 out:
484 return err;
485}
486
Chuck Lever262a0982008-12-12 16:57:35 -0500487/**
488 * write_unlock_ip - Release all locks used by a client
489 *
490 * Experimental.
491 *
492 * Input:
493 * buf: '\n'-terminated C string containing a
494 * presentation format IPv4 address
495 * size: length of C string in @buf
496 * Output:
497 * On success: returns zero if all specified locks were released;
498 * returns one if one or more locks were not released
499 * On error: return code is negative errno value
500 *
501 * Note: Only AF_INET client addresses are passed in
502 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500503static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500504{
Chuck Lever367c8c72008-06-30 18:58:14 -0400505 struct sockaddr_in sin = {
506 .sin_family = AF_INET,
507 };
Wendy Cheng4373ea82008-01-17 11:10:12 -0500508 int b1, b2, b3, b4;
Chuck Lever367c8c72008-06-30 18:58:14 -0400509 char c;
510 char *fo_path;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500511
512 /* sanity check */
513 if (size == 0)
514 return -EINVAL;
515
516 if (buf[size-1] != '\n')
517 return -EINVAL;
518
519 fo_path = buf;
520 if (qword_get(&buf, fo_path, size) < 0)
521 return -EINVAL;
522
523 /* get ipv4 address */
Harvey Harrisonbe859402008-10-31 00:56:28 -0700524 if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500525 return -EINVAL;
Chuck Lever367c8c72008-06-30 18:58:14 -0400526 if (b1 > 255 || b2 > 255 || b3 > 255 || b4 > 255)
527 return -EINVAL;
528 sin.sin_addr.s_addr = htonl((b1 << 24) | (b2 << 16) | (b3 << 8) | b4);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500529
Chuck Lever367c8c72008-06-30 18:58:14 -0400530 return nlmsvc_unlock_all_by_ip((struct sockaddr *)&sin);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500531}
532
Chuck Lever262a0982008-12-12 16:57:35 -0500533/**
534 * write_unlock_fs - Release all locks on a local file system
535 *
536 * Experimental.
537 *
538 * Input:
539 * buf: '\n'-terminated C string containing the
540 * absolute pathname of a local file system
541 * size: length of C string in @buf
542 * Output:
543 * On success: returns zero if all specified locks were released;
544 * returns one if one or more locks were not released
545 * On error: return code is negative errno value
546 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500547static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
Wendy Cheng17efa372008-01-17 11:10:12 -0500548{
Al Viroa63bb992008-08-02 01:03:36 -0400549 struct path path;
Wendy Cheng17efa372008-01-17 11:10:12 -0500550 char *fo_path;
551 int error;
552
553 /* sanity check */
554 if (size == 0)
555 return -EINVAL;
556
557 if (buf[size-1] != '\n')
558 return -EINVAL;
559
560 fo_path = buf;
561 if (qword_get(&buf, fo_path, size) < 0)
562 return -EINVAL;
563
Al Viroa63bb992008-08-02 01:03:36 -0400564 error = kern_path(fo_path, 0, &path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500565 if (error)
566 return error;
567
Chuck Lever262a0982008-12-12 16:57:35 -0500568 /*
569 * XXX: Needs better sanity checking. Otherwise we could end up
570 * releasing locks on the wrong file system.
571 *
572 * For example:
573 * 1. Does the path refer to a directory?
574 * 2. Is that directory a mount point, or
575 * 3. Is that directory the root of an exported file system?
576 */
Al Viroa63bb992008-08-02 01:03:36 -0400577 error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb);
Wendy Cheng17efa372008-01-17 11:10:12 -0500578
Al Viroa63bb992008-08-02 01:03:36 -0400579 path_put(&path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500580 return error;
581}
582
Chuck Lever262a0982008-12-12 16:57:35 -0500583/**
584 * write_filehandle - Get a variable-length NFS file handle by path
585 *
586 * On input, the buffer contains a '\n'-terminated C string comprised of
587 * three alphanumeric words separated by whitespace. The string may
588 * contain escape sequences.
589 *
590 * Input:
591 * buf:
592 * domain: client domain name
593 * path: export pathname
594 * maxsize: numeric maximum size of
595 * @buf
596 * size: length of C string in @buf
597 * Output:
598 * On success: passed-in buffer filled with '\n'-terminated C
599 * string containing a ASCII hex text version
600 * of the NFS file handle;
601 * return code is the size in bytes of the string
602 * On error: return code is negative errno value
603 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
605{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 char *dname, *path;
Andrew Morton246d95b2007-08-09 00:53:50 -0700607 int uninitialized_var(maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 char *mesg = buf;
609 int len;
610 struct auth_domain *dom;
611 struct knfsd_fh fh;
612
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500613 if (size == 0)
614 return -EINVAL;
615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 if (buf[size-1] != '\n')
617 return -EINVAL;
618 buf[size-1] = 0;
619
620 dname = mesg;
621 len = qword_get(&mesg, dname, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500622 if (len <= 0)
623 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 path = dname+len+1;
626 len = qword_get(&mesg, path, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500627 if (len <= 0)
628 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 len = get_int(&mesg, &maxsize);
631 if (len)
632 return len;
633
634 if (maxsize < NFS_FHSIZE)
635 return -EINVAL;
636 if (maxsize > NFS3_FHSIZE)
637 maxsize = NFS3_FHSIZE;
638
639 if (qword_get(&mesg, mesg, size)>0)
640 return -EINVAL;
641
642 /* we have all the words, they are in buf.. */
643 dom = unix_domain_find(dname);
644 if (!dom)
645 return -ENOMEM;
646
647 len = exp_rootfh(dom, path, &fh, maxsize);
648 auth_domain_put(dom);
649 if (len)
650 return len;
651
Chuck Lever54224f02008-12-12 16:57:20 -0500652 mesg = buf;
653 len = SIMPLE_TRANSACTION_LIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
655 mesg[-1] = '\n';
656 return mesg - buf;
657}
658
Chuck Lever262a0982008-12-12 16:57:35 -0500659/**
660 * write_threads - Start NFSD, or report the current number of running threads
661 *
662 * Input:
663 * buf: ignored
664 * size: zero
665 * Output:
666 * On success: passed-in buffer filled with '\n'-terminated C
667 * string numeric value representing the number of
668 * running NFSD threads;
669 * return code is the size in bytes of the string
670 * On error: return code is zero
671 *
672 * OR
673 *
674 * Input:
675 * buf: C string containing an unsigned
676 * integer value representing the
677 * number of NFSD threads to start
678 * size: non-zero length of C string in @buf
679 * Output:
680 * On success: NFS service is started;
681 * passed-in buffer filled with '\n'-terminated C
682 * string numeric value representing the number of
683 * running NFSD threads;
684 * return code is the size in bytes of the string
685 * On error: return code is zero or a negative errno value
686 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687static ssize_t write_threads(struct file *file, char *buf, size_t size)
688{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 char *mesg = buf;
690 int rv;
691 if (size > 0) {
692 int newthreads;
693 rv = get_int(&mesg, &newthreads);
694 if (rv)
695 return rv;
Chuck Lever9e074852008-12-12 16:57:27 -0500696 if (newthreads < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 return -EINVAL;
Chuck Lever9e074852008-12-12 16:57:27 -0500698 rv = nfsd_svc(NFS_PORT, newthreads);
NeilBrown82e12fe2009-06-16 11:03:07 +1000699 if (rv < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 return rv;
NeilBrown82e12fe2009-06-16 11:03:07 +1000701 } else
702 rv = nfsd_nrthreads();
Chuck Levere06b6402009-04-23 19:33:25 -0400703
NeilBrown82e12fe2009-06-16 11:03:07 +1000704 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
Chuck Lever262a0982008-12-12 16:57:35 -0500707/**
708 * write_pool_threads - Set or report the current number of threads per pool
709 *
710 * Input:
711 * buf: ignored
712 * size: zero
713 *
714 * OR
715 *
716 * Input:
717 * buf: C string containing whitespace-
718 * separated unsigned integer values
719 * representing the number of NFSD
720 * threads to start in each pool
721 * size: non-zero length of C string in @buf
722 * Output:
723 * On success: passed-in buffer filled with '\n'-terminated C
724 * string containing integer values representing the
725 * number of NFSD threads in each pool;
726 * return code is the size in bytes of the string
727 * On error: return code is zero or a negative errno value
728 */
Greg Bankseed29652006-10-02 02:18:02 -0700729static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
730{
731 /* if size > 0, look for an array of number of threads per node
732 * and apply them then write out number of threads per node as reply
733 */
734 char *mesg = buf;
735 int i;
736 int rv;
737 int len;
Neil Brownbedbdd82008-06-10 08:40:35 -0400738 int npools;
Greg Bankseed29652006-10-02 02:18:02 -0700739 int *nthreads;
740
Neil Brownbedbdd82008-06-10 08:40:35 -0400741 mutex_lock(&nfsd_mutex);
742 npools = nfsd_nrpools();
Greg Bankseed29652006-10-02 02:18:02 -0700743 if (npools == 0) {
744 /*
745 * NFS is shut down. The admin can start it by
746 * writing to the threads file but NOT the pool_threads
747 * file, sorry. Report zero threads.
748 */
Neil Brownbedbdd82008-06-10 08:40:35 -0400749 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700750 strcpy(buf, "0\n");
751 return strlen(buf);
752 }
753
754 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
Neil Brownbedbdd82008-06-10 08:40:35 -0400755 rv = -ENOMEM;
Greg Bankseed29652006-10-02 02:18:02 -0700756 if (nthreads == NULL)
Neil Brownbedbdd82008-06-10 08:40:35 -0400757 goto out_free;
Greg Bankseed29652006-10-02 02:18:02 -0700758
759 if (size > 0) {
760 for (i = 0; i < npools; i++) {
761 rv = get_int(&mesg, &nthreads[i]);
762 if (rv == -ENOENT)
763 break; /* fewer numbers than pools */
764 if (rv)
765 goto out_free; /* syntax error */
766 rv = -EINVAL;
767 if (nthreads[i] < 0)
768 goto out_free;
769 }
770 rv = nfsd_set_nrthreads(i, nthreads);
771 if (rv)
772 goto out_free;
773 }
774
775 rv = nfsd_get_nrthreads(npools, nthreads);
776 if (rv)
777 goto out_free;
778
779 mesg = buf;
780 size = SIMPLE_TRANSACTION_LIMIT;
781 for (i = 0; i < npools && size > 0; i++) {
782 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
783 len = strlen(mesg);
784 size -= len;
785 mesg += len;
786 }
787
Neil Brownbedbdd82008-06-10 08:40:35 -0400788 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700789 return (mesg-buf);
790
791out_free:
792 kfree(nthreads);
Neil Brownbedbdd82008-06-10 08:40:35 -0400793 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700794 return rv;
795}
796
Jeff Layton3dd98a32008-06-10 08:40:36 -0400797static ssize_t __write_versions(struct file *file, char *buf, size_t size)
NeilBrown70c3b762005-11-07 01:00:25 -0800798{
NeilBrown70c3b762005-11-07 01:00:25 -0800799 char *mesg = buf;
Benny Halevy8daf2202009-04-03 08:28:59 +0300800 char *vers, *minorp, sign;
Chuck Lever261758b2009-04-23 19:33:18 -0400801 int len, num, remaining;
Benny Halevy8daf2202009-04-03 08:28:59 +0300802 unsigned minor;
NeilBrown70c3b762005-11-07 01:00:25 -0800803 ssize_t tlen = 0;
804 char *sep;
805
806 if (size>0) {
807 if (nfsd_serv)
NeilBrown6658d3a2006-10-02 02:17:46 -0700808 /* Cannot change versions without updating
809 * nfsd_serv->sv_xdrsize, and reallocing
810 * rq_argp and rq_resp
811 */
NeilBrown70c3b762005-11-07 01:00:25 -0800812 return -EBUSY;
813 if (buf[size-1] != '\n')
814 return -EINVAL;
815 buf[size-1] = 0;
816
817 vers = mesg;
818 len = qword_get(&mesg, vers, size);
819 if (len <= 0) return -EINVAL;
820 do {
821 sign = *vers;
822 if (sign == '+' || sign == '-')
Benny Halevy8daf2202009-04-03 08:28:59 +0300823 num = simple_strtol((vers+1), &minorp, 0);
NeilBrown70c3b762005-11-07 01:00:25 -0800824 else
Benny Halevy8daf2202009-04-03 08:28:59 +0300825 num = simple_strtol(vers, &minorp, 0);
826 if (*minorp == '.') {
827 if (num < 4)
828 return -EINVAL;
829 minor = simple_strtoul(minorp+1, NULL, 0);
830 if (minor == 0)
831 return -EINVAL;
832 if (nfsd_minorversion(minor, sign == '-' ?
833 NFSD_CLEAR : NFSD_SET) < 0)
834 return -EINVAL;
835 goto next;
836 }
NeilBrown70c3b762005-11-07 01:00:25 -0800837 switch(num) {
838 case 2:
839 case 3:
840 case 4:
NeilBrown6658d3a2006-10-02 02:17:46 -0700841 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
NeilBrown70c3b762005-11-07 01:00:25 -0800842 break;
843 default:
844 return -EINVAL;
845 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300846 next:
NeilBrown70c3b762005-11-07 01:00:25 -0800847 vers += len + 1;
NeilBrown70c3b762005-11-07 01:00:25 -0800848 } while ((len = qword_get(&mesg, vers, size)) > 0);
849 /* If all get turned off, turn them back on, as
850 * having no versions is BAD
851 */
NeilBrown6658d3a2006-10-02 02:17:46 -0700852 nfsd_reset_versions();
NeilBrown70c3b762005-11-07 01:00:25 -0800853 }
Chuck Lever261758b2009-04-23 19:33:18 -0400854
NeilBrown70c3b762005-11-07 01:00:25 -0800855 /* Now write current state into reply buffer */
856 len = 0;
857 sep = "";
Chuck Lever261758b2009-04-23 19:33:18 -0400858 remaining = SIMPLE_TRANSACTION_LIMIT;
NeilBrown70c3b762005-11-07 01:00:25 -0800859 for (num=2 ; num <= 4 ; num++)
NeilBrown6658d3a2006-10-02 02:17:46 -0700860 if (nfsd_vers(num, NFSD_AVAIL)) {
Chuck Lever261758b2009-04-23 19:33:18 -0400861 len = snprintf(buf, remaining, "%s%c%d", sep,
NeilBrown6658d3a2006-10-02 02:17:46 -0700862 nfsd_vers(num, NFSD_TEST)?'+':'-',
NeilBrown70c3b762005-11-07 01:00:25 -0800863 num);
864 sep = " ";
Chuck Lever261758b2009-04-23 19:33:18 -0400865
866 if (len > remaining)
867 break;
868 remaining -= len;
869 buf += len;
870 tlen += len;
NeilBrown70c3b762005-11-07 01:00:25 -0800871 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300872 if (nfsd_vers(4, NFSD_AVAIL))
Chuck Lever261758b2009-04-23 19:33:18 -0400873 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
874 minor++) {
875 len = snprintf(buf, remaining, " %c4.%u",
Benny Halevy8daf2202009-04-03 08:28:59 +0300876 (nfsd_vers(4, NFSD_TEST) &&
877 nfsd_minorversion(minor, NFSD_TEST)) ?
878 '+' : '-',
879 minor);
Chuck Lever261758b2009-04-23 19:33:18 -0400880
881 if (len > remaining)
882 break;
883 remaining -= len;
884 buf += len;
885 tlen += len;
886 }
887
888 len = snprintf(buf, remaining, "\n");
889 if (len > remaining)
890 return -EINVAL;
891 return tlen + len;
NeilBrown70c3b762005-11-07 01:00:25 -0800892}
893
Chuck Lever262a0982008-12-12 16:57:35 -0500894/**
895 * write_versions - Set or report the available NFS protocol versions
896 *
897 * Input:
898 * buf: ignored
899 * size: zero
900 * Output:
901 * On success: passed-in buffer filled with '\n'-terminated C
902 * string containing positive or negative integer
903 * values representing the current status of each
904 * protocol version;
905 * return code is the size in bytes of the string
906 * On error: return code is zero or a negative errno value
907 *
908 * OR
909 *
910 * Input:
911 * buf: C string containing whitespace-
912 * separated positive or negative
913 * integer values representing NFS
914 * protocol versions to enable ("+n")
915 * or disable ("-n")
916 * size: non-zero length of C string in @buf
917 * Output:
918 * On success: status of zero or more protocol versions has
919 * been updated; passed-in buffer filled with
920 * '\n'-terminated C string containing positive
921 * or negative integer values representing the
922 * current status of each protocol version;
923 * return code is the size in bytes of the string
924 * On error: return code is zero or a negative errno value
925 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400926static ssize_t write_versions(struct file *file, char *buf, size_t size)
927{
928 ssize_t rv;
929
930 mutex_lock(&nfsd_mutex);
931 rv = __write_versions(file, buf, size);
932 mutex_unlock(&nfsd_mutex);
933 return rv;
934}
935
Chuck Lever4cd5dc72009-04-23 19:31:32 -0400936/*
Chuck Lever0a5372d2009-04-23 19:32:10 -0400937 * Zero-length write. Return a list of NFSD's current listener
938 * transports.
939 */
940static ssize_t __write_ports_names(char *buf)
941{
942 if (nfsd_serv == NULL)
943 return 0;
Chuck Lever335c54b2009-04-23 19:32:25 -0400944 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Lever0a5372d2009-04-23 19:32:10 -0400945}
946
947/*
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400948 * A single 'fd' number was written, in which case it must be for
949 * a socket of a supported family/protocol, and we use it as an
950 * nfsd listener.
951 */
952static ssize_t __write_ports_addfd(char *buf)
953{
954 char *mesg = buf;
955 int fd, err;
956
957 err = get_int(&mesg, &fd);
958 if (err != 0 || fd < 0)
959 return -EINVAL;
960
961 err = nfsd_create_serv();
962 if (err != 0)
963 return err;
964
Chuck Leverea068ba2009-04-23 19:32:18 -0400965 err = lockd_up();
966 if (err != 0)
967 goto out;
968
Chuck Leverbfba9ab2009-04-23 19:32:33 -0400969 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Leverea068ba2009-04-23 19:32:18 -0400970 if (err < 0)
971 lockd_down();
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400972
Chuck Leverea068ba2009-04-23 19:32:18 -0400973out:
974 /* Decrease the count, but don't shut down the service */
975 nfsd_serv->sv_nrthreads--;
976 return err;
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400977}
978
979/*
Chuck Lever82d56592009-04-23 19:31:48 -0400980 * A '-' followed by the 'name' of a socket means we close the socket.
981 */
982static ssize_t __write_ports_delfd(char *buf)
983{
984 char *toclose;
985 int len = 0;
986
987 toclose = kstrdup(buf + 1, GFP_KERNEL);
988 if (toclose == NULL)
989 return -ENOMEM;
990
991 if (nfsd_serv != NULL)
Chuck Lever8435d342009-04-23 19:32:40 -0400992 len = svc_sock_names(nfsd_serv, buf,
993 SIMPLE_TRANSACTION_LIMIT, toclose);
Chuck Lever82d56592009-04-23 19:31:48 -0400994 if (len >= 0)
995 lockd_down();
996
997 kfree(toclose);
998 return len;
999}
1000
1001/*
Chuck Lever4eb68c22009-04-23 19:31:40 -04001002 * A transport listener is added by writing it's transport name and
1003 * a port number.
1004 */
1005static ssize_t __write_ports_addxprt(char *buf)
1006{
1007 char transport[16];
1008 int port, err;
1009
1010 if (sscanf(buf, "%15s %4u", transport, &port) != 2)
1011 return -EINVAL;
1012
1013 if (port < 1 || port > USHORT_MAX)
1014 return -EINVAL;
1015
1016 err = nfsd_create_serv();
1017 if (err != 0)
1018 return err;
1019
1020 err = svc_create_xprt(nfsd_serv, transport,
1021 PF_INET, port, SVC_SOCK_ANONYMOUS);
1022 if (err < 0) {
1023 /* Give a reasonable perror msg for bad transport string */
1024 if (err == -ENOENT)
1025 err = -EPROTONOSUPPORT;
1026 return err;
1027 }
1028 return 0;
1029}
1030
1031/*
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001032 * A transport listener is removed by writing a "-", it's transport
1033 * name, and it's port number.
1034 */
1035static ssize_t __write_ports_delxprt(char *buf)
1036{
1037 struct svc_xprt *xprt;
1038 char transport[16];
1039 int port;
1040
1041 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
1042 return -EINVAL;
1043
1044 if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL)
1045 return -EINVAL;
1046
1047 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
1048 if (xprt == NULL)
1049 return -ENOTCONN;
1050
1051 svc_close_xprt(xprt);
1052 svc_xprt_put(xprt);
1053 return 0;
1054}
1055
Neil Brownbedbdd82008-06-10 08:40:35 -04001056static ssize_t __write_ports(struct file *file, char *buf, size_t size)
NeilBrown80212d52006-10-02 02:17:47 -07001057{
Chuck Lever0a5372d2009-04-23 19:32:10 -04001058 if (size == 0)
1059 return __write_ports_names(buf);
Chuck Lever0b7c2f62009-04-23 19:31:55 -04001060
1061 if (isdigit(buf[0]))
1062 return __write_ports_addfd(buf);
Chuck Lever82d56592009-04-23 19:31:48 -04001063
1064 if (buf[0] == '-' && isdigit(buf[1]))
1065 return __write_ports_delfd(buf);
Chuck Lever4eb68c22009-04-23 19:31:40 -04001066
1067 if (isalpha(buf[0]))
1068 return __write_ports_addxprt(buf);
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001069
1070 if (buf[0] == '-' && isalpha(buf[1]))
1071 return __write_ports_delxprt(buf);
1072
NeilBrownb41b66d2006-10-02 02:17:48 -07001073 return -EINVAL;
NeilBrown80212d52006-10-02 02:17:47 -07001074}
1075
Chuck Lever262a0982008-12-12 16:57:35 -05001076/**
1077 * write_ports - Pass a socket file descriptor or transport name to listen on
1078 *
1079 * Input:
1080 * buf: ignored
1081 * size: zero
1082 * Output:
1083 * On success: passed-in buffer filled with a '\n'-terminated C
1084 * string containing a whitespace-separated list of
1085 * named NFSD listeners;
1086 * return code is the size in bytes of the string
1087 * On error: return code is zero or a negative errno value
1088 *
1089 * OR
1090 *
1091 * Input:
1092 * buf: C string containing an unsigned
1093 * integer value representing a bound
1094 * but unconnected socket that is to be
Chuck Leverc71206a2009-04-23 19:32:03 -04001095 * used as an NFSD listener; listen(3)
1096 * must be called for a SOCK_STREAM
1097 * socket, otherwise it is ignored
Chuck Lever262a0982008-12-12 16:57:35 -05001098 * size: non-zero length of C string in @buf
1099 * Output:
1100 * On success: NFS service is started;
1101 * passed-in buffer filled with a '\n'-terminated C
1102 * string containing a unique alphanumeric name of
1103 * the listener;
1104 * return code is the size in bytes of the string
1105 * On error: return code is a negative errno value
1106 *
1107 * OR
1108 *
1109 * Input:
1110 * buf: C string containing a "-" followed
1111 * by an integer value representing a
1112 * previously passed in socket file
1113 * descriptor
1114 * size: non-zero length of C string in @buf
1115 * Output:
1116 * On success: NFS service no longer listens on that socket;
1117 * passed-in buffer filled with a '\n'-terminated C
1118 * string containing a unique name of the listener;
1119 * return code is the size in bytes of the string
1120 * On error: return code is a negative errno value
1121 *
1122 * OR
1123 *
1124 * Input:
1125 * buf: C string containing a transport
1126 * name and an unsigned integer value
1127 * representing the port to listen on,
1128 * separated by whitespace
1129 * size: non-zero length of C string in @buf
1130 * Output:
1131 * On success: returns zero; NFS service is started
1132 * On error: return code is a negative errno value
1133 *
1134 * OR
1135 *
1136 * Input:
1137 * buf: C string containing a "-" followed
1138 * by a transport name and an unsigned
1139 * integer value representing the port
1140 * to listen on, separated by whitespace
1141 * size: non-zero length of C string in @buf
1142 * Output:
1143 * On success: returns zero; NFS service no longer listens
1144 * on that transport
1145 * On error: return code is a negative errno value
1146 */
Neil Brownbedbdd82008-06-10 08:40:35 -04001147static ssize_t write_ports(struct file *file, char *buf, size_t size)
1148{
1149 ssize_t rv;
Jeff Layton3dd98a32008-06-10 08:40:36 -04001150
Neil Brownbedbdd82008-06-10 08:40:35 -04001151 mutex_lock(&nfsd_mutex);
1152 rv = __write_ports(file, buf, size);
1153 mutex_unlock(&nfsd_mutex);
1154 return rv;
1155}
1156
1157
NeilBrown596bbe52006-10-04 02:15:48 -07001158int nfsd_max_blksize;
1159
Chuck Lever262a0982008-12-12 16:57:35 -05001160/**
1161 * write_maxblksize - Set or report the current NFS blksize
1162 *
1163 * Input:
1164 * buf: ignored
1165 * size: zero
1166 *
1167 * OR
1168 *
1169 * Input:
1170 * buf: C string containing an unsigned
1171 * integer value representing the new
1172 * NFS blksize
1173 * size: non-zero length of C string in @buf
1174 * Output:
1175 * On success: passed-in buffer filled with '\n'-terminated C string
1176 * containing numeric value of the current NFS blksize
1177 * setting;
1178 * return code is the size in bytes of the string
1179 * On error: return code is zero or a negative errno value
1180 */
NeilBrown596bbe52006-10-04 02:15:48 -07001181static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
1182{
1183 char *mesg = buf;
1184 if (size > 0) {
1185 int bsize;
1186 int rv = get_int(&mesg, &bsize);
1187 if (rv)
1188 return rv;
1189 /* force bsize into allowed range and
1190 * required alignment.
1191 */
1192 if (bsize < 1024)
1193 bsize = 1024;
1194 if (bsize > NFSSVC_MAXBLKSIZE)
1195 bsize = NFSSVC_MAXBLKSIZE;
1196 bsize &= ~(1024-1);
Neil Brownbedbdd82008-06-10 08:40:35 -04001197 mutex_lock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001198 if (nfsd_serv && nfsd_serv->sv_nrthreads) {
Neil Brownbedbdd82008-06-10 08:40:35 -04001199 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001200 return -EBUSY;
1201 }
1202 nfsd_max_blksize = bsize;
Neil Brownbedbdd82008-06-10 08:40:35 -04001203 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001204 }
Chuck Levere06b6402009-04-23 19:33:25 -04001205
1206 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
1207 nfsd_max_blksize);
NeilBrown596bbe52006-10-04 02:15:48 -07001208}
1209
NeilBrown70c3b762005-11-07 01:00:25 -08001210#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211extern time_t nfs4_leasetime(void);
1212
Jeff Layton3dd98a32008-06-10 08:40:36 -04001213static ssize_t __write_leasetime(struct file *file, char *buf, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214{
1215 /* if size > 10 seconds, call
1216 * nfs4_reset_lease() then write out the new lease (seconds) as reply
1217 */
1218 char *mesg = buf;
Jeff Layton3dd98a32008-06-10 08:40:36 -04001219 int rv, lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
1221 if (size > 0) {
Jeff Layton3dd98a32008-06-10 08:40:36 -04001222 if (nfsd_serv)
1223 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 rv = get_int(&mesg, &lease);
1225 if (rv)
1226 return rv;
1227 if (lease < 10 || lease > 3600)
1228 return -EINVAL;
1229 nfs4_reset_lease(lease);
1230 }
Chuck Levere06b6402009-04-23 19:33:25 -04001231
1232 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n",
1233 nfs4_lease_time());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234}
1235
Chuck Lever262a0982008-12-12 16:57:35 -05001236/**
1237 * write_leasetime - Set or report the current NFSv4 lease time
1238 *
1239 * Input:
1240 * buf: ignored
1241 * size: zero
1242 *
1243 * OR
1244 *
1245 * Input:
1246 * buf: C string containing an unsigned
1247 * integer value representing the new
1248 * NFSv4 lease expiry time
1249 * size: non-zero length of C string in @buf
1250 * Output:
1251 * On success: passed-in buffer filled with '\n'-terminated C
1252 * string containing unsigned integer value of the
1253 * current lease expiry time;
1254 * return code is the size in bytes of the string
1255 * On error: return code is zero or a negative errno value
1256 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001257static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
1258{
1259 ssize_t rv;
1260
1261 mutex_lock(&nfsd_mutex);
1262 rv = __write_leasetime(file, buf, size);
1263 mutex_unlock(&nfsd_mutex);
1264 return rv;
1265}
1266
1267extern char *nfs4_recoverydir(void);
1268
1269static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
NeilBrown0964a3d2005-06-23 22:04:32 -07001270{
1271 char *mesg = buf;
1272 char *recdir;
1273 int len, status;
1274
Jeff Layton3dd98a32008-06-10 08:40:36 -04001275 if (size > 0) {
1276 if (nfsd_serv)
1277 return -EBUSY;
1278 if (size > PATH_MAX || buf[size-1] != '\n')
1279 return -EINVAL;
1280 buf[size-1] = 0;
NeilBrown0964a3d2005-06-23 22:04:32 -07001281
Jeff Layton3dd98a32008-06-10 08:40:36 -04001282 recdir = mesg;
1283 len = qword_get(&mesg, recdir, size);
1284 if (len <= 0)
1285 return -EINVAL;
NeilBrown0964a3d2005-06-23 22:04:32 -07001286
Jeff Layton3dd98a32008-06-10 08:40:36 -04001287 status = nfs4_reset_recoverydir(recdir);
1288 }
Chuck Lever3d72ab82009-04-23 19:33:10 -04001289
1290 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1291 nfs4_recoverydir());
NeilBrown0964a3d2005-06-23 22:04:32 -07001292}
Jeff Layton3dd98a32008-06-10 08:40:36 -04001293
Chuck Lever262a0982008-12-12 16:57:35 -05001294/**
1295 * write_recoverydir - Set or report the pathname of the recovery directory
1296 *
1297 * Input:
1298 * buf: ignored
1299 * size: zero
1300 *
1301 * OR
1302 *
1303 * Input:
1304 * buf: C string containing the pathname
1305 * of the directory on a local file
1306 * system containing permanent NFSv4
1307 * recovery data
1308 * size: non-zero length of C string in @buf
1309 * Output:
1310 * On success: passed-in buffer filled with '\n'-terminated C string
1311 * containing the current recovery pathname setting;
1312 * return code is the size in bytes of the string
1313 * On error: return code is zero or a negative errno value
1314 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001315static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1316{
1317 ssize_t rv;
1318
1319 mutex_lock(&nfsd_mutex);
1320 rv = __write_recoverydir(file, buf, size);
1321 mutex_unlock(&nfsd_mutex);
1322 return rv;
1323}
1324
NeilBrown70c3b762005-11-07 01:00:25 -08001325#endif
NeilBrown0964a3d2005-06-23 22:04:32 -07001326
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327/*----------------------------------------------------------------------------*/
1328/*
1329 * populating the filesystem.
1330 */
1331
1332static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1333{
1334 static struct tree_descr nfsd_files[] = {
1335 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
1336 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
1337 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
1338 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
1339 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
1340 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
1341 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
1342 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
Wendy Cheng4373ea82008-01-17 11:10:12 -05001343 [NFSD_FO_UnlockIP] = {"unlock_ip",
1344 &transaction_ops, S_IWUSR|S_IRUSR},
Wendy Cheng17efa372008-01-17 11:10:12 -05001345 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1346 &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1348 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Bankseed29652006-10-02 02:18:02 -07001349 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Banks03cf6c92009-01-13 21:26:36 +11001350 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
NeilBrown70c3b762005-11-07 01:00:25 -08001351 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown80212d52006-10-02 02:17:47 -07001352 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
NeilBrown596bbe52006-10-04 02:15:48 -07001353 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354#ifdef CONFIG_NFSD_V4
1355 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown0964a3d2005-06-23 22:04:32 -07001356 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357#endif
1358 /* last one */ {""}
1359 };
1360 return simple_fill_super(sb, 0x6e667364, nfsd_files);
1361}
1362
David Howells454e2392006-06-23 02:02:57 -07001363static int nfsd_get_sb(struct file_system_type *fs_type,
1364 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
David Howells454e2392006-06-23 02:02:57 -07001366 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367}
1368
1369static struct file_system_type nfsd_fs_type = {
1370 .owner = THIS_MODULE,
1371 .name = "nfsd",
1372 .get_sb = nfsd_get_sb,
1373 .kill_sb = kill_litter_super,
1374};
1375
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001376#ifdef CONFIG_PROC_FS
1377static int create_proc_exports_entry(void)
1378{
1379 struct proc_dir_entry *entry;
1380
1381 entry = proc_mkdir("fs/nfs", NULL);
1382 if (!entry)
1383 return -ENOMEM;
Denis V. Lunev9ef2db22008-04-29 01:02:04 -07001384 entry = proc_create("exports", 0, entry, &exports_operations);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001385 if (!entry)
1386 return -ENOMEM;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001387 return 0;
1388}
1389#else /* CONFIG_PROC_FS */
1390static int create_proc_exports_entry(void)
1391{
1392 return 0;
1393}
1394#endif
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396static int __init init_nfsd(void)
1397{
1398 int retval;
1399 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1400
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001401 retval = nfs4_state_init(); /* nfs4 locking state */
1402 if (retval)
1403 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 nfsd_stat_init(); /* Statistics */
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001405 retval = nfsd_reply_cache_init();
1406 if (retval)
1407 goto out_free_stat;
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001408 retval = nfsd_export_init();
1409 if (retval)
1410 goto out_free_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 nfsd_lockd_init(); /* lockd->nfsd callbacks */
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001412 retval = nfsd_idmap_init();
1413 if (retval)
1414 goto out_free_lockd;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001415 retval = create_proc_exports_entry();
1416 if (retval)
1417 goto out_free_idmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 retval = register_filesystem(&nfsd_fs_type);
J. Bruce Fields26808d32007-11-09 13:44:06 -05001419 if (retval)
1420 goto out_free_all;
1421 return 0;
1422out_free_all:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001423 remove_proc_entry("fs/nfs/exports", NULL);
1424 remove_proc_entry("fs/nfs", NULL);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001425out_free_idmap:
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001426 nfsd_idmap_shutdown();
1427out_free_lockd:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001428 nfsd_lockd_shutdown();
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001429 nfsd_export_shutdown();
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001430out_free_cache:
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001431 nfsd_reply_cache_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001432out_free_stat:
1433 nfsd_stat_shutdown();
J. Bruce Fields26808d32007-11-09 13:44:06 -05001434 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 return retval;
1436}
1437
1438static void __exit exit_nfsd(void)
1439{
1440 nfsd_export_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001441 nfsd_reply_cache_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 remove_proc_entry("fs/nfs/exports", NULL);
1443 remove_proc_entry("fs/nfs", NULL);
1444 nfsd_stat_shutdown();
1445 nfsd_lockd_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 nfsd_idmap_shutdown();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001447 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 unregister_filesystem(&nfsd_fs_type);
1449}
1450
1451MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1452MODULE_LICENSE("GPL");
1453module_init(init_nfsd)
1454module_exit(exit_nfsd)