blob: 00388d2a3c9970a3fdfccec1c4dda85904b6fd4e [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>
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>
Chuck Lever41160922009-08-09 15:09:40 -040040#include <linux/sunrpc/clnt.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);
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900177extern int nfsd_pool_stats_release(struct inode *inode, struct file *file);
Greg Banks03cf6c92009-01-13 21:26:36 +1100178
179static struct file_operations pool_stats_operations = {
180 .open = nfsd_pool_stats_open,
181 .read = seq_read,
182 .llseek = seq_lseek,
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900183 .release = nfsd_pool_stats_release,
Greg Banks03cf6c92009-01-13 21:26:36 +1100184 .owner = THIS_MODULE,
185};
186
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187/*----------------------------------------------------------------------------*/
188/*
189 * payload - write methods
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 */
191
Chuck Lever262a0982008-12-12 16:57:35 -0500192/**
193 * write_svc - Start kernel's NFSD server
194 *
195 * Deprecated. /proc/fs/nfsd/threads is preferred.
196 * Function remains to support old versions of nfs-utils.
197 *
198 * Input:
199 * buf: struct nfsctl_svc
200 * svc_port: port number of this
201 * server's listener
202 * svc_nthreads: number of threads to start
203 * size: size in bytes of passed in nfsctl_svc
204 * Output:
205 * On success: returns zero
206 * On error: return code is negative errno value
207 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208static ssize_t write_svc(struct file *file, char *buf, size_t size)
209{
210 struct nfsctl_svc *data;
NeilBrown82e12fe2009-06-16 11:03:07 +1000211 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (size < sizeof(*data))
213 return -EINVAL;
214 data = (struct nfsctl_svc*) buf;
NeilBrown82e12fe2009-06-16 11:03:07 +1000215 err = nfsd_svc(data->svc_port, data->svc_nthreads);
216 if (err < 0)
217 return err;
218 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219}
220
Chuck Lever262a0982008-12-12 16:57:35 -0500221/**
222 * write_add - Add or modify client entry in auth unix cache
223 *
224 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
225 * Function remains to support old versions of nfs-utils.
226 *
227 * Input:
228 * buf: struct nfsctl_client
229 * cl_ident: '\0'-terminated C string
230 * containing domain name
231 * of client
232 * cl_naddr: no. of items in cl_addrlist
233 * cl_addrlist: array of client addresses
234 * cl_fhkeytype: ignored
235 * cl_fhkeylen: ignored
236 * cl_fhkey: ignored
237 * size: size in bytes of passed in nfsctl_client
238 * Output:
239 * On success: returns zero
240 * On error: return code is negative errno value
241 *
242 * Note: Only AF_INET client addresses are passed in, since
243 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
244 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245static ssize_t write_add(struct file *file, char *buf, size_t size)
246{
247 struct nfsctl_client *data;
248 if (size < sizeof(*data))
249 return -EINVAL;
250 data = (struct nfsctl_client *)buf;
251 return exp_addclient(data);
252}
253
Chuck Lever262a0982008-12-12 16:57:35 -0500254/**
255 * write_del - Remove client from auth unix cache
256 *
257 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
258 * Function remains to support old versions of nfs-utils.
259 *
260 * Input:
261 * buf: struct nfsctl_client
262 * cl_ident: '\0'-terminated C string
263 * containing domain name
264 * of client
265 * cl_naddr: ignored
266 * cl_addrlist: ignored
267 * cl_fhkeytype: ignored
268 * cl_fhkeylen: ignored
269 * cl_fhkey: ignored
270 * size: size in bytes of passed in nfsctl_client
271 * Output:
272 * On success: returns zero
273 * On error: return code is negative errno value
274 *
275 * Note: Only AF_INET client addresses are passed in, since
276 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
277 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278static ssize_t write_del(struct file *file, char *buf, size_t size)
279{
280 struct nfsctl_client *data;
281 if (size < sizeof(*data))
282 return -EINVAL;
283 data = (struct nfsctl_client *)buf;
284 return exp_delclient(data);
285}
286
Chuck Lever262a0982008-12-12 16:57:35 -0500287/**
288 * write_export - Export part or all of a local file system
289 *
290 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
291 * Function remains to support old versions of nfs-utils.
292 *
293 * Input:
294 * buf: struct nfsctl_export
295 * ex_client: '\0'-terminated C string
296 * containing domain name
297 * of client allowed to access
298 * this export
299 * ex_path: '\0'-terminated C string
300 * containing pathname of
301 * directory in local file system
302 * ex_dev: fsid to use for this export
303 * ex_ino: ignored
304 * ex_flags: export flags for this export
305 * ex_anon_uid: UID to use for anonymous
306 * requests
307 * ex_anon_gid: GID to use for anonymous
308 * requests
309 * size: size in bytes of passed in nfsctl_export
310 * Output:
311 * On success: returns zero
312 * On error: return code is negative errno value
313 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314static ssize_t write_export(struct file *file, char *buf, size_t size)
315{
316 struct nfsctl_export *data;
317 if (size < sizeof(*data))
318 return -EINVAL;
319 data = (struct nfsctl_export*)buf;
320 return exp_export(data);
321}
322
Chuck Lever262a0982008-12-12 16:57:35 -0500323/**
324 * write_unexport - Unexport a previously exported file system
325 *
326 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
327 * Function remains to support old versions of nfs-utils.
328 *
329 * Input:
330 * buf: struct nfsctl_export
331 * ex_client: '\0'-terminated C string
332 * containing domain name
333 * of client no longer allowed
334 * to access this export
335 * ex_path: '\0'-terminated C string
336 * containing pathname of
337 * directory in local file system
338 * ex_dev: ignored
339 * ex_ino: ignored
340 * ex_flags: ignored
341 * ex_anon_uid: ignored
342 * ex_anon_gid: ignored
343 * size: size in bytes of passed in nfsctl_export
344 * Output:
345 * On success: returns zero
346 * On error: return code is negative errno value
347 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348static ssize_t write_unexport(struct file *file, char *buf, size_t size)
349{
350 struct nfsctl_export *data;
351
352 if (size < sizeof(*data))
353 return -EINVAL;
354 data = (struct nfsctl_export*)buf;
355 return exp_unexport(data);
356}
357
Chuck Lever262a0982008-12-12 16:57:35 -0500358/**
359 * write_getfs - Get a variable-length NFS file handle by path
360 *
361 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
362 * Function remains to support old versions of nfs-utils.
363 *
364 * Input:
365 * buf: struct nfsctl_fsparm
366 * gd_addr: socket address of client
367 * gd_path: '\0'-terminated C string
368 * containing pathname of
369 * directory in local file system
370 * gd_maxlen: maximum size of returned file
371 * handle
372 * size: size in bytes of passed in nfsctl_fsparm
373 * Output:
374 * On success: passed-in buffer filled with a knfsd_fh structure
375 * (a variable-length raw NFS file handle);
376 * return code is the size in bytes of the file handle
377 * On error: return code is negative errno value
378 *
379 * Note: Only AF_INET client addresses are passed in, since gd_addr
380 * is the same size as a struct sockaddr_in.
381 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382static ssize_t write_getfs(struct file *file, char *buf, size_t size)
383{
384 struct nfsctl_fsparm *data;
385 struct sockaddr_in *sin;
386 struct auth_domain *clp;
387 int err = 0;
388 struct knfsd_fh *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100389 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
391 if (size < sizeof(*data))
392 return -EINVAL;
393 data = (struct nfsctl_fsparm*)buf;
394 err = -EPROTONOSUPPORT;
395 if (data->gd_addr.sa_family != AF_INET)
396 goto out;
397 sin = (struct sockaddr_in *)&data->gd_addr;
398 if (data->gd_maxlen > NFS3_FHSIZE)
399 data->gd_maxlen = NFS3_FHSIZE;
400
401 res = (struct knfsd_fh*)buf;
402
403 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100404
405 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
406
407 clp = auth_unix_lookup(&in6);
408 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 err = -EPERM;
410 else {
411 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
412 auth_domain_put(clp);
413 }
414 exp_readunlock();
415 if (err == 0)
Andrew Morton12127492007-07-17 04:04:34 -0700416 err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 out:
418 return err;
419}
420
Chuck Lever262a0982008-12-12 16:57:35 -0500421/**
422 * write_getfd - Get a fixed-length NFS file handle by path (used by mountd)
423 *
424 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
425 * Function remains to support old versions of nfs-utils.
426 *
427 * Input:
428 * buf: struct nfsctl_fdparm
429 * gd_addr: socket address of client
430 * gd_path: '\0'-terminated C string
431 * containing pathname of
432 * directory in local file system
433 * gd_version: fdparm structure version
434 * size: size in bytes of passed in nfsctl_fdparm
435 * Output:
436 * On success: passed-in buffer filled with nfsctl_res
437 * (a fixed-length raw NFS file handle);
438 * return code is the size in bytes of the file handle
439 * On error: return code is negative errno value
440 *
441 * Note: Only AF_INET client addresses are passed in, since gd_addr
442 * is the same size as a struct sockaddr_in.
443 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444static ssize_t write_getfd(struct file *file, char *buf, size_t size)
445{
446 struct nfsctl_fdparm *data;
447 struct sockaddr_in *sin;
448 struct auth_domain *clp;
449 int err = 0;
450 struct knfsd_fh fh;
451 char *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100452 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 if (size < sizeof(*data))
455 return -EINVAL;
456 data = (struct nfsctl_fdparm*)buf;
457 err = -EPROTONOSUPPORT;
458 if (data->gd_addr.sa_family != AF_INET)
459 goto out;
460 err = -EINVAL;
461 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
462 goto out;
463
464 res = buf;
465 sin = (struct sockaddr_in *)&data->gd_addr;
466 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100467
468 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
469
470 clp = auth_unix_lookup(&in6);
471 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 err = -EPERM;
473 else {
474 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
475 auth_domain_put(clp);
476 }
477 exp_readunlock();
478
479 if (err == 0) {
480 memset(res,0, NFS_FHSIZE);
481 memcpy(res, &fh.fh_base, fh.fh_size);
482 err = NFS_FHSIZE;
483 }
484 out:
485 return err;
486}
487
Chuck Lever262a0982008-12-12 16:57:35 -0500488/**
489 * write_unlock_ip - Release all locks used by a client
490 *
491 * Experimental.
492 *
493 * Input:
494 * buf: '\n'-terminated C string containing a
Chuck Lever41160922009-08-09 15:09:40 -0400495 * presentation format IP address
Chuck Lever262a0982008-12-12 16:57:35 -0500496 * size: length of C string in @buf
497 * Output:
498 * On success: returns zero if all specified locks were released;
499 * returns one if one or more locks were not released
500 * On error: return code is negative errno value
Chuck Lever262a0982008-12-12 16:57:35 -0500501 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500502static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500503{
Chuck Lever41160922009-08-09 15:09:40 -0400504 struct sockaddr_storage address;
505 struct sockaddr *sap = (struct sockaddr *)&address;
506 size_t salen = sizeof(address);
Chuck Lever367c8c72008-06-30 18:58:14 -0400507 char *fo_path;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500508
509 /* sanity check */
510 if (size == 0)
511 return -EINVAL;
512
513 if (buf[size-1] != '\n')
514 return -EINVAL;
515
516 fo_path = buf;
517 if (qword_get(&buf, fo_path, size) < 0)
518 return -EINVAL;
519
Chuck Lever41160922009-08-09 15:09:40 -0400520 if (rpc_pton(fo_path, size, sap, salen) == 0)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500521 return -EINVAL;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500522
Chuck Lever41160922009-08-09 15:09:40 -0400523 return nlmsvc_unlock_all_by_ip(sap);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500524}
525
Chuck Lever262a0982008-12-12 16:57:35 -0500526/**
527 * write_unlock_fs - Release all locks on a local file system
528 *
529 * Experimental.
530 *
531 * Input:
532 * buf: '\n'-terminated C string containing the
533 * absolute pathname of a local file system
534 * size: length of C string in @buf
535 * Output:
536 * On success: returns zero if all specified locks were released;
537 * returns one if one or more locks were not released
538 * On error: return code is negative errno value
539 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500540static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
Wendy Cheng17efa372008-01-17 11:10:12 -0500541{
Al Viroa63bb992008-08-02 01:03:36 -0400542 struct path path;
Wendy Cheng17efa372008-01-17 11:10:12 -0500543 char *fo_path;
544 int error;
545
546 /* sanity check */
547 if (size == 0)
548 return -EINVAL;
549
550 if (buf[size-1] != '\n')
551 return -EINVAL;
552
553 fo_path = buf;
554 if (qword_get(&buf, fo_path, size) < 0)
555 return -EINVAL;
556
Al Viroa63bb992008-08-02 01:03:36 -0400557 error = kern_path(fo_path, 0, &path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500558 if (error)
559 return error;
560
Chuck Lever262a0982008-12-12 16:57:35 -0500561 /*
562 * XXX: Needs better sanity checking. Otherwise we could end up
563 * releasing locks on the wrong file system.
564 *
565 * For example:
566 * 1. Does the path refer to a directory?
567 * 2. Is that directory a mount point, or
568 * 3. Is that directory the root of an exported file system?
569 */
Al Viroa63bb992008-08-02 01:03:36 -0400570 error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb);
Wendy Cheng17efa372008-01-17 11:10:12 -0500571
Al Viroa63bb992008-08-02 01:03:36 -0400572 path_put(&path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500573 return error;
574}
575
Chuck Lever262a0982008-12-12 16:57:35 -0500576/**
577 * write_filehandle - Get a variable-length NFS file handle by path
578 *
579 * On input, the buffer contains a '\n'-terminated C string comprised of
580 * three alphanumeric words separated by whitespace. The string may
581 * contain escape sequences.
582 *
583 * Input:
584 * buf:
585 * domain: client domain name
586 * path: export pathname
587 * maxsize: numeric maximum size of
588 * @buf
589 * size: length of C string in @buf
590 * Output:
591 * On success: passed-in buffer filled with '\n'-terminated C
592 * string containing a ASCII hex text version
593 * of the NFS file handle;
594 * return code is the size in bytes of the string
595 * On error: return code is negative errno value
596 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
598{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 char *dname, *path;
Andrew Morton246d95b2007-08-09 00:53:50 -0700600 int uninitialized_var(maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 char *mesg = buf;
602 int len;
603 struct auth_domain *dom;
604 struct knfsd_fh fh;
605
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500606 if (size == 0)
607 return -EINVAL;
608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (buf[size-1] != '\n')
610 return -EINVAL;
611 buf[size-1] = 0;
612
613 dname = mesg;
614 len = qword_get(&mesg, dname, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500615 if (len <= 0)
616 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618 path = dname+len+1;
619 len = qword_get(&mesg, path, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500620 if (len <= 0)
621 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 len = get_int(&mesg, &maxsize);
624 if (len)
625 return len;
626
627 if (maxsize < NFS_FHSIZE)
628 return -EINVAL;
629 if (maxsize > NFS3_FHSIZE)
630 maxsize = NFS3_FHSIZE;
631
632 if (qword_get(&mesg, mesg, size)>0)
633 return -EINVAL;
634
635 /* we have all the words, they are in buf.. */
636 dom = unix_domain_find(dname);
637 if (!dom)
638 return -ENOMEM;
639
640 len = exp_rootfh(dom, path, &fh, maxsize);
641 auth_domain_put(dom);
642 if (len)
643 return len;
644
Chuck Lever54224f02008-12-12 16:57:20 -0500645 mesg = buf;
646 len = SIMPLE_TRANSACTION_LIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
648 mesg[-1] = '\n';
649 return mesg - buf;
650}
651
Chuck Lever262a0982008-12-12 16:57:35 -0500652/**
653 * write_threads - Start NFSD, or report the current number of running threads
654 *
655 * Input:
656 * buf: ignored
657 * size: zero
658 * Output:
659 * On success: passed-in buffer filled with '\n'-terminated C
660 * string numeric value representing the number of
661 * running NFSD threads;
662 * return code is the size in bytes of the string
663 * On error: return code is zero
664 *
665 * OR
666 *
667 * Input:
668 * buf: C string containing an unsigned
669 * integer value representing the
670 * number of NFSD threads to start
671 * size: non-zero length of C string in @buf
672 * Output:
673 * On success: NFS service is started;
674 * passed-in buffer filled with '\n'-terminated C
675 * string numeric value representing the number of
676 * running NFSD threads;
677 * return code is the size in bytes of the string
678 * On error: return code is zero or a negative errno value
679 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680static ssize_t write_threads(struct file *file, char *buf, size_t size)
681{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 char *mesg = buf;
683 int rv;
684 if (size > 0) {
685 int newthreads;
686 rv = get_int(&mesg, &newthreads);
687 if (rv)
688 return rv;
Chuck Lever9e074852008-12-12 16:57:27 -0500689 if (newthreads < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 return -EINVAL;
Chuck Lever9e074852008-12-12 16:57:27 -0500691 rv = nfsd_svc(NFS_PORT, newthreads);
NeilBrown82e12fe2009-06-16 11:03:07 +1000692 if (rv < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 return rv;
NeilBrown82e12fe2009-06-16 11:03:07 +1000694 } else
695 rv = nfsd_nrthreads();
Chuck Levere06b6402009-04-23 19:33:25 -0400696
NeilBrown82e12fe2009-06-16 11:03:07 +1000697 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
699
Chuck Lever262a0982008-12-12 16:57:35 -0500700/**
701 * write_pool_threads - Set or report the current number of threads per pool
702 *
703 * Input:
704 * buf: ignored
705 * size: zero
706 *
707 * OR
708 *
709 * Input:
710 * buf: C string containing whitespace-
711 * separated unsigned integer values
712 * representing the number of NFSD
713 * threads to start in each pool
714 * size: non-zero length of C string in @buf
715 * Output:
716 * On success: passed-in buffer filled with '\n'-terminated C
717 * string containing integer values representing the
718 * number of NFSD threads in each pool;
719 * return code is the size in bytes of the string
720 * On error: return code is zero or a negative errno value
721 */
Greg Bankseed29652006-10-02 02:18:02 -0700722static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
723{
724 /* if size > 0, look for an array of number of threads per node
725 * and apply them then write out number of threads per node as reply
726 */
727 char *mesg = buf;
728 int i;
729 int rv;
730 int len;
Neil Brownbedbdd82008-06-10 08:40:35 -0400731 int npools;
Greg Bankseed29652006-10-02 02:18:02 -0700732 int *nthreads;
733
Neil Brownbedbdd82008-06-10 08:40:35 -0400734 mutex_lock(&nfsd_mutex);
735 npools = nfsd_nrpools();
Greg Bankseed29652006-10-02 02:18:02 -0700736 if (npools == 0) {
737 /*
738 * NFS is shut down. The admin can start it by
739 * writing to the threads file but NOT the pool_threads
740 * file, sorry. Report zero threads.
741 */
Neil Brownbedbdd82008-06-10 08:40:35 -0400742 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700743 strcpy(buf, "0\n");
744 return strlen(buf);
745 }
746
747 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
Neil Brownbedbdd82008-06-10 08:40:35 -0400748 rv = -ENOMEM;
Greg Bankseed29652006-10-02 02:18:02 -0700749 if (nthreads == NULL)
Neil Brownbedbdd82008-06-10 08:40:35 -0400750 goto out_free;
Greg Bankseed29652006-10-02 02:18:02 -0700751
752 if (size > 0) {
753 for (i = 0; i < npools; i++) {
754 rv = get_int(&mesg, &nthreads[i]);
755 if (rv == -ENOENT)
756 break; /* fewer numbers than pools */
757 if (rv)
758 goto out_free; /* syntax error */
759 rv = -EINVAL;
760 if (nthreads[i] < 0)
761 goto out_free;
762 }
763 rv = nfsd_set_nrthreads(i, nthreads);
764 if (rv)
765 goto out_free;
766 }
767
768 rv = nfsd_get_nrthreads(npools, nthreads);
769 if (rv)
770 goto out_free;
771
772 mesg = buf;
773 size = SIMPLE_TRANSACTION_LIMIT;
774 for (i = 0; i < npools && size > 0; i++) {
775 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
776 len = strlen(mesg);
777 size -= len;
778 mesg += len;
779 }
J. Bruce Fields413d63d7102009-07-28 11:37:25 -0400780 rv = mesg - buf;
Greg Bankseed29652006-10-02 02:18:02 -0700781out_free:
782 kfree(nthreads);
Neil Brownbedbdd82008-06-10 08:40:35 -0400783 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700784 return rv;
785}
786
Jeff Layton3dd98a32008-06-10 08:40:36 -0400787static ssize_t __write_versions(struct file *file, char *buf, size_t size)
NeilBrown70c3b762005-11-07 01:00:25 -0800788{
NeilBrown70c3b762005-11-07 01:00:25 -0800789 char *mesg = buf;
Benny Halevy8daf2202009-04-03 08:28:59 +0300790 char *vers, *minorp, sign;
Chuck Lever261758b2009-04-23 19:33:18 -0400791 int len, num, remaining;
Benny Halevy8daf2202009-04-03 08:28:59 +0300792 unsigned minor;
NeilBrown70c3b762005-11-07 01:00:25 -0800793 ssize_t tlen = 0;
794 char *sep;
795
796 if (size>0) {
797 if (nfsd_serv)
NeilBrown6658d3a2006-10-02 02:17:46 -0700798 /* Cannot change versions without updating
799 * nfsd_serv->sv_xdrsize, and reallocing
800 * rq_argp and rq_resp
801 */
NeilBrown70c3b762005-11-07 01:00:25 -0800802 return -EBUSY;
803 if (buf[size-1] != '\n')
804 return -EINVAL;
805 buf[size-1] = 0;
806
807 vers = mesg;
808 len = qword_get(&mesg, vers, size);
809 if (len <= 0) return -EINVAL;
810 do {
811 sign = *vers;
812 if (sign == '+' || sign == '-')
Benny Halevy8daf2202009-04-03 08:28:59 +0300813 num = simple_strtol((vers+1), &minorp, 0);
NeilBrown70c3b762005-11-07 01:00:25 -0800814 else
Benny Halevy8daf2202009-04-03 08:28:59 +0300815 num = simple_strtol(vers, &minorp, 0);
816 if (*minorp == '.') {
817 if (num < 4)
818 return -EINVAL;
819 minor = simple_strtoul(minorp+1, NULL, 0);
820 if (minor == 0)
821 return -EINVAL;
822 if (nfsd_minorversion(minor, sign == '-' ?
823 NFSD_CLEAR : NFSD_SET) < 0)
824 return -EINVAL;
825 goto next;
826 }
NeilBrown70c3b762005-11-07 01:00:25 -0800827 switch(num) {
828 case 2:
829 case 3:
830 case 4:
NeilBrown6658d3a2006-10-02 02:17:46 -0700831 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
NeilBrown70c3b762005-11-07 01:00:25 -0800832 break;
833 default:
834 return -EINVAL;
835 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300836 next:
NeilBrown70c3b762005-11-07 01:00:25 -0800837 vers += len + 1;
NeilBrown70c3b762005-11-07 01:00:25 -0800838 } while ((len = qword_get(&mesg, vers, size)) > 0);
839 /* If all get turned off, turn them back on, as
840 * having no versions is BAD
841 */
NeilBrown6658d3a2006-10-02 02:17:46 -0700842 nfsd_reset_versions();
NeilBrown70c3b762005-11-07 01:00:25 -0800843 }
Chuck Lever261758b2009-04-23 19:33:18 -0400844
NeilBrown70c3b762005-11-07 01:00:25 -0800845 /* Now write current state into reply buffer */
846 len = 0;
847 sep = "";
Chuck Lever261758b2009-04-23 19:33:18 -0400848 remaining = SIMPLE_TRANSACTION_LIMIT;
NeilBrown70c3b762005-11-07 01:00:25 -0800849 for (num=2 ; num <= 4 ; num++)
NeilBrown6658d3a2006-10-02 02:17:46 -0700850 if (nfsd_vers(num, NFSD_AVAIL)) {
Chuck Lever261758b2009-04-23 19:33:18 -0400851 len = snprintf(buf, remaining, "%s%c%d", sep,
NeilBrown6658d3a2006-10-02 02:17:46 -0700852 nfsd_vers(num, NFSD_TEST)?'+':'-',
NeilBrown70c3b762005-11-07 01:00:25 -0800853 num);
854 sep = " ";
Chuck Lever261758b2009-04-23 19:33:18 -0400855
856 if (len > remaining)
857 break;
858 remaining -= len;
859 buf += len;
860 tlen += len;
NeilBrown70c3b762005-11-07 01:00:25 -0800861 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300862 if (nfsd_vers(4, NFSD_AVAIL))
Chuck Lever261758b2009-04-23 19:33:18 -0400863 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
864 minor++) {
865 len = snprintf(buf, remaining, " %c4.%u",
Benny Halevy8daf2202009-04-03 08:28:59 +0300866 (nfsd_vers(4, NFSD_TEST) &&
867 nfsd_minorversion(minor, NFSD_TEST)) ?
868 '+' : '-',
869 minor);
Chuck Lever261758b2009-04-23 19:33:18 -0400870
871 if (len > remaining)
872 break;
873 remaining -= len;
874 buf += len;
875 tlen += len;
876 }
877
878 len = snprintf(buf, remaining, "\n");
879 if (len > remaining)
880 return -EINVAL;
881 return tlen + len;
NeilBrown70c3b762005-11-07 01:00:25 -0800882}
883
Chuck Lever262a0982008-12-12 16:57:35 -0500884/**
885 * write_versions - Set or report the available NFS protocol versions
886 *
887 * Input:
888 * buf: ignored
889 * size: zero
890 * Output:
891 * On success: passed-in buffer filled with '\n'-terminated C
892 * string containing positive or negative integer
893 * values representing the current status of each
894 * protocol version;
895 * return code is the size in bytes of the string
896 * On error: return code is zero or a negative errno value
897 *
898 * OR
899 *
900 * Input:
901 * buf: C string containing whitespace-
902 * separated positive or negative
903 * integer values representing NFS
904 * protocol versions to enable ("+n")
905 * or disable ("-n")
906 * size: non-zero length of C string in @buf
907 * Output:
908 * On success: status of zero or more protocol versions has
909 * been updated; passed-in buffer filled with
910 * '\n'-terminated C string containing positive
911 * or negative integer values representing the
912 * current status of each protocol version;
913 * return code is the size in bytes of the string
914 * On error: return code is zero or a negative errno value
915 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400916static ssize_t write_versions(struct file *file, char *buf, size_t size)
917{
918 ssize_t rv;
919
920 mutex_lock(&nfsd_mutex);
921 rv = __write_versions(file, buf, size);
922 mutex_unlock(&nfsd_mutex);
923 return rv;
924}
925
Chuck Lever4cd5dc72009-04-23 19:31:32 -0400926/*
Chuck Lever0a5372d2009-04-23 19:32:10 -0400927 * Zero-length write. Return a list of NFSD's current listener
928 * transports.
929 */
930static ssize_t __write_ports_names(char *buf)
931{
932 if (nfsd_serv == NULL)
933 return 0;
Chuck Lever335c54b2009-04-23 19:32:25 -0400934 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Lever0a5372d2009-04-23 19:32:10 -0400935}
936
937/*
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400938 * A single 'fd' number was written, in which case it must be for
939 * a socket of a supported family/protocol, and we use it as an
940 * nfsd listener.
941 */
942static ssize_t __write_ports_addfd(char *buf)
943{
944 char *mesg = buf;
945 int fd, err;
946
947 err = get_int(&mesg, &fd);
948 if (err != 0 || fd < 0)
949 return -EINVAL;
950
951 err = nfsd_create_serv();
952 if (err != 0)
953 return err;
954
Chuck Leverea068ba2009-04-23 19:32:18 -0400955 err = lockd_up();
956 if (err != 0)
957 goto out;
958
Chuck Leverbfba9ab2009-04-23 19:32:33 -0400959 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Leverea068ba2009-04-23 19:32:18 -0400960 if (err < 0)
961 lockd_down();
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400962
Chuck Leverea068ba2009-04-23 19:32:18 -0400963out:
964 /* Decrease the count, but don't shut down the service */
965 nfsd_serv->sv_nrthreads--;
966 return err;
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400967}
968
969/*
Chuck Lever82d56592009-04-23 19:31:48 -0400970 * A '-' followed by the 'name' of a socket means we close the socket.
971 */
972static ssize_t __write_ports_delfd(char *buf)
973{
974 char *toclose;
975 int len = 0;
976
977 toclose = kstrdup(buf + 1, GFP_KERNEL);
978 if (toclose == NULL)
979 return -ENOMEM;
980
981 if (nfsd_serv != NULL)
Chuck Lever8435d342009-04-23 19:32:40 -0400982 len = svc_sock_names(nfsd_serv, buf,
983 SIMPLE_TRANSACTION_LIMIT, toclose);
Chuck Lever82d56592009-04-23 19:31:48 -0400984 if (len >= 0)
985 lockd_down();
986
987 kfree(toclose);
988 return len;
989}
990
991/*
Chuck Lever4eb68c22009-04-23 19:31:40 -0400992 * A transport listener is added by writing it's transport name and
993 * a port number.
994 */
995static ssize_t __write_ports_addxprt(char *buf)
996{
997 char transport[16];
998 int port, err;
999
1000 if (sscanf(buf, "%15s %4u", transport, &port) != 2)
1001 return -EINVAL;
1002
1003 if (port < 1 || port > USHORT_MAX)
1004 return -EINVAL;
1005
1006 err = nfsd_create_serv();
1007 if (err != 0)
1008 return err;
1009
1010 err = svc_create_xprt(nfsd_serv, transport,
1011 PF_INET, port, SVC_SOCK_ANONYMOUS);
1012 if (err < 0) {
1013 /* Give a reasonable perror msg for bad transport string */
1014 if (err == -ENOENT)
1015 err = -EPROTONOSUPPORT;
1016 return err;
1017 }
1018 return 0;
1019}
1020
1021/*
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001022 * A transport listener is removed by writing a "-", it's transport
1023 * name, and it's port number.
1024 */
1025static ssize_t __write_ports_delxprt(char *buf)
1026{
1027 struct svc_xprt *xprt;
1028 char transport[16];
1029 int port;
1030
1031 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
1032 return -EINVAL;
1033
1034 if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL)
1035 return -EINVAL;
1036
1037 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
1038 if (xprt == NULL)
1039 return -ENOTCONN;
1040
1041 svc_close_xprt(xprt);
1042 svc_xprt_put(xprt);
1043 return 0;
1044}
1045
Neil Brownbedbdd82008-06-10 08:40:35 -04001046static ssize_t __write_ports(struct file *file, char *buf, size_t size)
NeilBrown80212d52006-10-02 02:17:47 -07001047{
Chuck Lever0a5372d2009-04-23 19:32:10 -04001048 if (size == 0)
1049 return __write_ports_names(buf);
Chuck Lever0b7c2f62009-04-23 19:31:55 -04001050
1051 if (isdigit(buf[0]))
1052 return __write_ports_addfd(buf);
Chuck Lever82d56592009-04-23 19:31:48 -04001053
1054 if (buf[0] == '-' && isdigit(buf[1]))
1055 return __write_ports_delfd(buf);
Chuck Lever4eb68c22009-04-23 19:31:40 -04001056
1057 if (isalpha(buf[0]))
1058 return __write_ports_addxprt(buf);
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001059
1060 if (buf[0] == '-' && isalpha(buf[1]))
1061 return __write_ports_delxprt(buf);
1062
NeilBrownb41b66d2006-10-02 02:17:48 -07001063 return -EINVAL;
NeilBrown80212d52006-10-02 02:17:47 -07001064}
1065
Chuck Lever262a0982008-12-12 16:57:35 -05001066/**
1067 * write_ports - Pass a socket file descriptor or transport name to listen on
1068 *
1069 * Input:
1070 * buf: ignored
1071 * size: zero
1072 * Output:
1073 * On success: passed-in buffer filled with a '\n'-terminated C
1074 * string containing a whitespace-separated list of
1075 * named NFSD listeners;
1076 * return code is the size in bytes of the string
1077 * On error: return code is zero or a negative errno value
1078 *
1079 * OR
1080 *
1081 * Input:
1082 * buf: C string containing an unsigned
1083 * integer value representing a bound
1084 * but unconnected socket that is to be
Chuck Leverc71206a2009-04-23 19:32:03 -04001085 * used as an NFSD listener; listen(3)
1086 * must be called for a SOCK_STREAM
1087 * socket, otherwise it is ignored
Chuck Lever262a0982008-12-12 16:57:35 -05001088 * size: non-zero length of C string in @buf
1089 * Output:
1090 * On success: NFS service is started;
1091 * passed-in buffer filled with a '\n'-terminated C
1092 * string containing a unique alphanumeric name of
1093 * the listener;
1094 * return code is the size in bytes of the string
1095 * On error: return code is a negative errno value
1096 *
1097 * OR
1098 *
1099 * Input:
1100 * buf: C string containing a "-" followed
1101 * by an integer value representing a
1102 * previously passed in socket file
1103 * descriptor
1104 * size: non-zero length of C string in @buf
1105 * Output:
1106 * On success: NFS service no longer listens on that socket;
1107 * passed-in buffer filled with a '\n'-terminated C
1108 * string containing a unique name of the listener;
1109 * return code is the size in bytes of the string
1110 * On error: return code is a negative errno value
1111 *
1112 * OR
1113 *
1114 * Input:
1115 * buf: C string containing a transport
1116 * name and an unsigned integer value
1117 * representing the port to listen on,
1118 * separated by whitespace
1119 * size: non-zero length of C string in @buf
1120 * Output:
1121 * On success: returns zero; NFS service is started
1122 * On error: return code is a negative errno value
1123 *
1124 * OR
1125 *
1126 * Input:
1127 * buf: C string containing a "-" followed
1128 * by a transport name and an unsigned
1129 * integer value representing the port
1130 * to listen on, separated by whitespace
1131 * size: non-zero length of C string in @buf
1132 * Output:
1133 * On success: returns zero; NFS service no longer listens
1134 * on that transport
1135 * On error: return code is a negative errno value
1136 */
Neil Brownbedbdd82008-06-10 08:40:35 -04001137static ssize_t write_ports(struct file *file, char *buf, size_t size)
1138{
1139 ssize_t rv;
Jeff Layton3dd98a32008-06-10 08:40:36 -04001140
Neil Brownbedbdd82008-06-10 08:40:35 -04001141 mutex_lock(&nfsd_mutex);
1142 rv = __write_ports(file, buf, size);
1143 mutex_unlock(&nfsd_mutex);
1144 return rv;
1145}
1146
1147
NeilBrown596bbe52006-10-04 02:15:48 -07001148int nfsd_max_blksize;
1149
Chuck Lever262a0982008-12-12 16:57:35 -05001150/**
1151 * write_maxblksize - Set or report the current NFS blksize
1152 *
1153 * Input:
1154 * buf: ignored
1155 * size: zero
1156 *
1157 * OR
1158 *
1159 * Input:
1160 * buf: C string containing an unsigned
1161 * integer value representing the new
1162 * NFS blksize
1163 * size: non-zero length of C string in @buf
1164 * Output:
1165 * On success: passed-in buffer filled with '\n'-terminated C string
1166 * containing numeric value of the current NFS blksize
1167 * setting;
1168 * return code is the size in bytes of the string
1169 * On error: return code is zero or a negative errno value
1170 */
NeilBrown596bbe52006-10-04 02:15:48 -07001171static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
1172{
1173 char *mesg = buf;
1174 if (size > 0) {
1175 int bsize;
1176 int rv = get_int(&mesg, &bsize);
1177 if (rv)
1178 return rv;
1179 /* force bsize into allowed range and
1180 * required alignment.
1181 */
1182 if (bsize < 1024)
1183 bsize = 1024;
1184 if (bsize > NFSSVC_MAXBLKSIZE)
1185 bsize = NFSSVC_MAXBLKSIZE;
1186 bsize &= ~(1024-1);
Neil Brownbedbdd82008-06-10 08:40:35 -04001187 mutex_lock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001188 if (nfsd_serv && nfsd_serv->sv_nrthreads) {
Neil Brownbedbdd82008-06-10 08:40:35 -04001189 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001190 return -EBUSY;
1191 }
1192 nfsd_max_blksize = bsize;
Neil Brownbedbdd82008-06-10 08:40:35 -04001193 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001194 }
Chuck Levere06b6402009-04-23 19:33:25 -04001195
1196 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
1197 nfsd_max_blksize);
NeilBrown596bbe52006-10-04 02:15:48 -07001198}
1199
NeilBrown70c3b762005-11-07 01:00:25 -08001200#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201extern time_t nfs4_leasetime(void);
1202
Jeff Layton3dd98a32008-06-10 08:40:36 -04001203static ssize_t __write_leasetime(struct file *file, char *buf, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204{
1205 /* if size > 10 seconds, call
1206 * nfs4_reset_lease() then write out the new lease (seconds) as reply
1207 */
1208 char *mesg = buf;
Jeff Layton3dd98a32008-06-10 08:40:36 -04001209 int rv, lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
1211 if (size > 0) {
Jeff Layton3dd98a32008-06-10 08:40:36 -04001212 if (nfsd_serv)
1213 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 rv = get_int(&mesg, &lease);
1215 if (rv)
1216 return rv;
1217 if (lease < 10 || lease > 3600)
1218 return -EINVAL;
1219 nfs4_reset_lease(lease);
1220 }
Chuck Levere06b6402009-04-23 19:33:25 -04001221
1222 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n",
1223 nfs4_lease_time());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224}
1225
Chuck Lever262a0982008-12-12 16:57:35 -05001226/**
1227 * write_leasetime - Set or report the current NFSv4 lease time
1228 *
1229 * Input:
1230 * buf: ignored
1231 * size: zero
1232 *
1233 * OR
1234 *
1235 * Input:
1236 * buf: C string containing an unsigned
1237 * integer value representing the new
1238 * NFSv4 lease expiry time
1239 * size: non-zero length of C string in @buf
1240 * Output:
1241 * On success: passed-in buffer filled with '\n'-terminated C
1242 * string containing unsigned integer value of the
1243 * current lease expiry time;
1244 * return code is the size in bytes of the string
1245 * On error: return code is zero or a negative errno value
1246 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001247static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
1248{
1249 ssize_t rv;
1250
1251 mutex_lock(&nfsd_mutex);
1252 rv = __write_leasetime(file, buf, size);
1253 mutex_unlock(&nfsd_mutex);
1254 return rv;
1255}
1256
1257extern char *nfs4_recoverydir(void);
1258
1259static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
NeilBrown0964a3d2005-06-23 22:04:32 -07001260{
1261 char *mesg = buf;
1262 char *recdir;
1263 int len, status;
1264
Jeff Layton3dd98a32008-06-10 08:40:36 -04001265 if (size > 0) {
1266 if (nfsd_serv)
1267 return -EBUSY;
1268 if (size > PATH_MAX || buf[size-1] != '\n')
1269 return -EINVAL;
1270 buf[size-1] = 0;
NeilBrown0964a3d2005-06-23 22:04:32 -07001271
Jeff Layton3dd98a32008-06-10 08:40:36 -04001272 recdir = mesg;
1273 len = qword_get(&mesg, recdir, size);
1274 if (len <= 0)
1275 return -EINVAL;
NeilBrown0964a3d2005-06-23 22:04:32 -07001276
Jeff Layton3dd98a32008-06-10 08:40:36 -04001277 status = nfs4_reset_recoverydir(recdir);
1278 }
Chuck Lever3d72ab82009-04-23 19:33:10 -04001279
1280 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1281 nfs4_recoverydir());
NeilBrown0964a3d2005-06-23 22:04:32 -07001282}
Jeff Layton3dd98a32008-06-10 08:40:36 -04001283
Chuck Lever262a0982008-12-12 16:57:35 -05001284/**
1285 * write_recoverydir - Set or report the pathname of the recovery directory
1286 *
1287 * Input:
1288 * buf: ignored
1289 * size: zero
1290 *
1291 * OR
1292 *
1293 * Input:
1294 * buf: C string containing the pathname
1295 * of the directory on a local file
1296 * system containing permanent NFSv4
1297 * recovery data
1298 * size: non-zero length of C string in @buf
1299 * Output:
1300 * On success: passed-in buffer filled with '\n'-terminated C string
1301 * containing the current recovery pathname setting;
1302 * return code is the size in bytes of the string
1303 * On error: return code is zero or a negative errno value
1304 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001305static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1306{
1307 ssize_t rv;
1308
1309 mutex_lock(&nfsd_mutex);
1310 rv = __write_recoverydir(file, buf, size);
1311 mutex_unlock(&nfsd_mutex);
1312 return rv;
1313}
1314
NeilBrown70c3b762005-11-07 01:00:25 -08001315#endif
NeilBrown0964a3d2005-06-23 22:04:32 -07001316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317/*----------------------------------------------------------------------------*/
1318/*
1319 * populating the filesystem.
1320 */
1321
1322static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1323{
1324 static struct tree_descr nfsd_files[] = {
1325 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
1326 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
1327 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
1328 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
1329 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
1330 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
1331 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
1332 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
Wendy Cheng4373ea82008-01-17 11:10:12 -05001333 [NFSD_FO_UnlockIP] = {"unlock_ip",
1334 &transaction_ops, S_IWUSR|S_IRUSR},
Wendy Cheng17efa372008-01-17 11:10:12 -05001335 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1336 &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1338 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Bankseed29652006-10-02 02:18:02 -07001339 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Banks03cf6c92009-01-13 21:26:36 +11001340 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
NeilBrown70c3b762005-11-07 01:00:25 -08001341 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown80212d52006-10-02 02:17:47 -07001342 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
NeilBrown596bbe52006-10-04 02:15:48 -07001343 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344#ifdef CONFIG_NFSD_V4
1345 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown0964a3d2005-06-23 22:04:32 -07001346 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347#endif
1348 /* last one */ {""}
1349 };
1350 return simple_fill_super(sb, 0x6e667364, nfsd_files);
1351}
1352
David Howells454e2392006-06-23 02:02:57 -07001353static int nfsd_get_sb(struct file_system_type *fs_type,
1354 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355{
David Howells454e2392006-06-23 02:02:57 -07001356 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
1358
1359static struct file_system_type nfsd_fs_type = {
1360 .owner = THIS_MODULE,
1361 .name = "nfsd",
1362 .get_sb = nfsd_get_sb,
1363 .kill_sb = kill_litter_super,
1364};
1365
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001366#ifdef CONFIG_PROC_FS
1367static int create_proc_exports_entry(void)
1368{
1369 struct proc_dir_entry *entry;
1370
1371 entry = proc_mkdir("fs/nfs", NULL);
1372 if (!entry)
1373 return -ENOMEM;
Denis V. Lunev9ef2db22008-04-29 01:02:04 -07001374 entry = proc_create("exports", 0, entry, &exports_operations);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001375 if (!entry)
1376 return -ENOMEM;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001377 return 0;
1378}
1379#else /* CONFIG_PROC_FS */
1380static int create_proc_exports_entry(void)
1381{
1382 return 0;
1383}
1384#endif
1385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386static int __init init_nfsd(void)
1387{
1388 int retval;
1389 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1390
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001391 retval = nfs4_state_init(); /* nfs4 locking state */
1392 if (retval)
1393 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 nfsd_stat_init(); /* Statistics */
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001395 retval = nfsd_reply_cache_init();
1396 if (retval)
1397 goto out_free_stat;
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001398 retval = nfsd_export_init();
1399 if (retval)
1400 goto out_free_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 nfsd_lockd_init(); /* lockd->nfsd callbacks */
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001402 retval = nfsd_idmap_init();
1403 if (retval)
1404 goto out_free_lockd;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001405 retval = create_proc_exports_entry();
1406 if (retval)
1407 goto out_free_idmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 retval = register_filesystem(&nfsd_fs_type);
J. Bruce Fields26808d32007-11-09 13:44:06 -05001409 if (retval)
1410 goto out_free_all;
1411 return 0;
1412out_free_all:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001413 remove_proc_entry("fs/nfs/exports", NULL);
1414 remove_proc_entry("fs/nfs", NULL);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001415out_free_idmap:
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001416 nfsd_idmap_shutdown();
1417out_free_lockd:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001418 nfsd_lockd_shutdown();
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001419 nfsd_export_shutdown();
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001420out_free_cache:
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001421 nfsd_reply_cache_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001422out_free_stat:
1423 nfsd_stat_shutdown();
J. Bruce Fields26808d32007-11-09 13:44:06 -05001424 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 return retval;
1426}
1427
1428static void __exit exit_nfsd(void)
1429{
1430 nfsd_export_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001431 nfsd_reply_cache_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 remove_proc_entry("fs/nfs/exports", NULL);
1433 remove_proc_entry("fs/nfs", NULL);
1434 nfsd_stat_shutdown();
1435 nfsd_lockd_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 nfsd_idmap_shutdown();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001437 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 unregister_filesystem(&nfsd_fs_type);
1439}
1440
1441MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1442MODULE_LICENSE("GPL");
1443module_init(init_nfsd)
1444module_exit(exit_nfsd)