blob: af7469efc61c982cedb0aa29cdebe5dbb4bcf56b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Syscall interface to knfsd.
3 *
4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
5 */
6
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09007#include <linux/slab.h>
Al Viro3f8206d2008-07-26 03:46:43 -04008#include <linux/namei.h>
NeilBrownb41b66d2006-10-02 02:17:48 -07009#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/nfsd_idmap.h>
NeilBrown80212d52006-10-02 02:17:47 -070012#include <linux/sunrpc/svcsock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/nfsd/syscall.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050014#include <linux/lockd/lockd.h>
Chuck Lever41160922009-08-09 15:09:40 -040015#include <linux/sunrpc/clnt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Boaz Harrosh9a74af22009-12-03 20:30:56 +020017#include "nfsd.h"
18#include "cache.h"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020/*
21 * We have a single directory with 9 nodes in it.
22 */
23enum {
24 NFSD_Root = 1,
25 NFSD_Svc,
26 NFSD_Add,
27 NFSD_Del,
28 NFSD_Export,
29 NFSD_Unexport,
30 NFSD_Getfd,
31 NFSD_Getfs,
32 NFSD_List,
J. Bruce Fieldse8e87532009-12-14 12:53:32 -050033 NFSD_Export_features,
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 NFSD_Fh,
Wendy Cheng4373ea82008-01-17 11:10:12 -050035 NFSD_FO_UnlockIP,
Wendy Cheng17efa372008-01-17 11:10:12 -050036 NFSD_FO_UnlockFS,
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 NFSD_Threads,
Greg Bankseed29652006-10-02 02:18:02 -070038 NFSD_Pool_Threads,
Greg Banks03cf6c92009-01-13 21:26:36 +110039 NFSD_Pool_Stats,
NeilBrown70c3b762005-11-07 01:00:25 -080040 NFSD_Versions,
NeilBrown80212d52006-10-02 02:17:47 -070041 NFSD_Ports,
NeilBrown596bbe52006-10-04 02:15:48 -070042 NFSD_MaxBlkSize,
NeilBrown70c3b762005-11-07 01:00:25 -080043 /*
44 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
45 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
46 */
47#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 NFSD_Leasetime,
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050049 NFSD_Gracetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070050 NFSD_RecoveryDir,
NeilBrown70c3b762005-11-07 01:00:25 -080051#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070052};
53
54/*
55 * write() for these nodes.
56 */
57static ssize_t write_svc(struct file *file, char *buf, size_t size);
58static ssize_t write_add(struct file *file, char *buf, size_t size);
59static ssize_t write_del(struct file *file, char *buf, size_t size);
60static ssize_t write_export(struct file *file, char *buf, size_t size);
61static ssize_t write_unexport(struct file *file, char *buf, size_t size);
62static ssize_t write_getfd(struct file *file, char *buf, size_t size);
63static ssize_t write_getfs(struct file *file, char *buf, size_t size);
64static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
Chuck Leverb046ccd2008-12-12 16:57:13 -050065static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
66static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static ssize_t write_threads(struct file *file, char *buf, size_t size);
Greg Bankseed29652006-10-02 02:18:02 -070068static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080069static ssize_t write_versions(struct file *file, char *buf, size_t size);
NeilBrown80212d52006-10-02 02:17:47 -070070static ssize_t write_ports(struct file *file, char *buf, size_t size);
NeilBrown596bbe52006-10-04 02:15:48 -070071static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080072#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070073static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050074static ssize_t write_gracetime(struct file *file, char *buf, size_t size);
NeilBrown0964a3d2005-06-23 22:04:32 -070075static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080076#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static ssize_t (*write_op[])(struct file *, char *, size_t) = {
79 [NFSD_Svc] = write_svc,
80 [NFSD_Add] = write_add,
81 [NFSD_Del] = write_del,
82 [NFSD_Export] = write_export,
83 [NFSD_Unexport] = write_unexport,
84 [NFSD_Getfd] = write_getfd,
85 [NFSD_Getfs] = write_getfs,
86 [NFSD_Fh] = write_filehandle,
Chuck Leverb046ccd2008-12-12 16:57:13 -050087 [NFSD_FO_UnlockIP] = write_unlock_ip,
88 [NFSD_FO_UnlockFS] = write_unlock_fs,
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 [NFSD_Threads] = write_threads,
Greg Bankseed29652006-10-02 02:18:02 -070090 [NFSD_Pool_Threads] = write_pool_threads,
NeilBrown70c3b762005-11-07 01:00:25 -080091 [NFSD_Versions] = write_versions,
NeilBrown80212d52006-10-02 02:17:47 -070092 [NFSD_Ports] = write_ports,
NeilBrown596bbe52006-10-04 02:15:48 -070093 [NFSD_MaxBlkSize] = write_maxblksize,
NeilBrown70c3b762005-11-07 01:00:25 -080094#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 [NFSD_Leasetime] = write_leasetime,
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050096 [NFSD_Gracetime] = write_gracetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070097 [NFSD_RecoveryDir] = write_recoverydir,
NeilBrown70c3b762005-11-07 01:00:25 -080098#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070099};
100
101static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
102{
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -0800103 ino_t ino = file->f_path.dentry->d_inode->i_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 char *data;
105 ssize_t rv;
106
Tobias Klausere8c96f82006-03-24 03:15:34 -0800107 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return -EINVAL;
109
110 data = simple_transaction_get(file, buf, size);
111 if (IS_ERR(data))
112 return PTR_ERR(data);
113
114 rv = write_op[ino](file, data, size);
NeilBrown8971a102007-02-14 00:33:11 -0800115 if (rv >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 simple_transaction_set(file, rv);
117 rv = size;
118 }
119 return rv;
120}
121
NeilBrown73900222005-11-07 01:00:24 -0800122static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
123{
124 if (! file->private_data) {
125 /* An attempt to read a transaction file without writing
126 * causes a 0-byte write so that the file can return
127 * state information
128 */
129 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
130 if (rv < 0)
131 return rv;
132 }
133 return simple_transaction_read(file, buf, size, pos);
134}
135
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800136static const struct file_operations transaction_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 .write = nfsctl_transaction_write,
NeilBrown73900222005-11-07 01:00:24 -0800138 .read = nfsctl_transaction_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 .release = simple_transaction_release,
140};
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static int exports_open(struct inode *inode, struct file *file)
143{
144 return seq_open(file, &nfs_exports_op);
145}
146
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800147static const struct file_operations exports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 .open = exports_open,
149 .read = seq_read,
150 .llseek = seq_lseek,
151 .release = seq_release,
Denis V. Lunev9ef2db22008-04-29 01:02:04 -0700152 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153};
154
J. Bruce Fieldse8e87532009-12-14 12:53:32 -0500155static int export_features_show(struct seq_file *m, void *v)
156{
157 seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
158 return 0;
159}
160
161static int export_features_open(struct inode *inode, struct file *file)
162{
163 return single_open(file, export_features_show, NULL);
164}
165
166static struct file_operations export_features_operations = {
167 .open = export_features_open,
168 .read = seq_read,
169 .llseek = seq_lseek,
170 .release = single_release,
171};
172
Greg Banks03cf6c92009-01-13 21:26:36 +1100173extern int nfsd_pool_stats_open(struct inode *inode, struct file *file);
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900174extern int nfsd_pool_stats_release(struct inode *inode, struct file *file);
Greg Banks03cf6c92009-01-13 21:26:36 +1100175
Alexey Dobriyan828c0952009-10-01 15:43:56 -0700176static const struct file_operations pool_stats_operations = {
Greg Banks03cf6c92009-01-13 21:26:36 +1100177 .open = nfsd_pool_stats_open,
178 .read = seq_read,
179 .llseek = seq_lseek,
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900180 .release = nfsd_pool_stats_release,
Greg Banks03cf6c92009-01-13 21:26:36 +1100181 .owner = THIS_MODULE,
182};
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*----------------------------------------------------------------------------*/
185/*
186 * payload - write methods
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 */
188
Chuck Lever262a0982008-12-12 16:57:35 -0500189/**
190 * write_svc - Start kernel's NFSD server
191 *
192 * Deprecated. /proc/fs/nfsd/threads is preferred.
193 * Function remains to support old versions of nfs-utils.
194 *
195 * Input:
196 * buf: struct nfsctl_svc
197 * svc_port: port number of this
198 * server's listener
199 * svc_nthreads: number of threads to start
200 * size: size in bytes of passed in nfsctl_svc
201 * Output:
202 * On success: returns zero
203 * On error: return code is negative errno value
204 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205static ssize_t write_svc(struct file *file, char *buf, size_t size)
206{
207 struct nfsctl_svc *data;
NeilBrown82e12fe2009-06-16 11:03:07 +1000208 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 if (size < sizeof(*data))
210 return -EINVAL;
211 data = (struct nfsctl_svc*) buf;
NeilBrown82e12fe2009-06-16 11:03:07 +1000212 err = nfsd_svc(data->svc_port, data->svc_nthreads);
213 if (err < 0)
214 return err;
215 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Chuck Lever262a0982008-12-12 16:57:35 -0500218/**
219 * write_add - Add or modify client entry in auth unix cache
220 *
221 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
222 * Function remains to support old versions of nfs-utils.
223 *
224 * Input:
225 * buf: struct nfsctl_client
226 * cl_ident: '\0'-terminated C string
227 * containing domain name
228 * of client
229 * cl_naddr: no. of items in cl_addrlist
230 * cl_addrlist: array of client addresses
231 * cl_fhkeytype: ignored
232 * cl_fhkeylen: ignored
233 * cl_fhkey: ignored
234 * size: size in bytes of passed in nfsctl_client
235 * Output:
236 * On success: returns zero
237 * On error: return code is negative errno value
238 *
239 * Note: Only AF_INET client addresses are passed in, since
240 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
241 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242static ssize_t write_add(struct file *file, char *buf, size_t size)
243{
244 struct nfsctl_client *data;
245 if (size < sizeof(*data))
246 return -EINVAL;
247 data = (struct nfsctl_client *)buf;
248 return exp_addclient(data);
249}
250
Chuck Lever262a0982008-12-12 16:57:35 -0500251/**
252 * write_del - Remove client from auth unix cache
253 *
254 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
255 * Function remains to support old versions of nfs-utils.
256 *
257 * Input:
258 * buf: struct nfsctl_client
259 * cl_ident: '\0'-terminated C string
260 * containing domain name
261 * of client
262 * cl_naddr: ignored
263 * cl_addrlist: ignored
264 * cl_fhkeytype: ignored
265 * cl_fhkeylen: ignored
266 * cl_fhkey: ignored
267 * size: size in bytes of passed in nfsctl_client
268 * Output:
269 * On success: returns zero
270 * On error: return code is negative errno value
271 *
272 * Note: Only AF_INET client addresses are passed in, since
273 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
274 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275static ssize_t write_del(struct file *file, char *buf, size_t size)
276{
277 struct nfsctl_client *data;
278 if (size < sizeof(*data))
279 return -EINVAL;
280 data = (struct nfsctl_client *)buf;
281 return exp_delclient(data);
282}
283
Chuck Lever262a0982008-12-12 16:57:35 -0500284/**
285 * write_export - Export part or all of a local file system
286 *
287 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
288 * Function remains to support old versions of nfs-utils.
289 *
290 * Input:
291 * buf: struct nfsctl_export
292 * ex_client: '\0'-terminated C string
293 * containing domain name
294 * of client allowed to access
295 * this export
296 * ex_path: '\0'-terminated C string
297 * containing pathname of
298 * directory in local file system
299 * ex_dev: fsid to use for this export
300 * ex_ino: ignored
301 * ex_flags: export flags for this export
302 * ex_anon_uid: UID to use for anonymous
303 * requests
304 * ex_anon_gid: GID to use for anonymous
305 * requests
306 * size: size in bytes of passed in nfsctl_export
307 * Output:
308 * On success: returns zero
309 * On error: return code is negative errno value
310 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311static ssize_t write_export(struct file *file, char *buf, size_t size)
312{
313 struct nfsctl_export *data;
314 if (size < sizeof(*data))
315 return -EINVAL;
316 data = (struct nfsctl_export*)buf;
317 return exp_export(data);
318}
319
Chuck Lever262a0982008-12-12 16:57:35 -0500320/**
321 * write_unexport - Unexport a previously exported file system
322 *
323 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
324 * Function remains to support old versions of nfs-utils.
325 *
326 * Input:
327 * buf: struct nfsctl_export
328 * ex_client: '\0'-terminated C string
329 * containing domain name
330 * of client no longer allowed
331 * to access this export
332 * ex_path: '\0'-terminated C string
333 * containing pathname of
334 * directory in local file system
335 * ex_dev: ignored
336 * ex_ino: ignored
337 * ex_flags: ignored
338 * ex_anon_uid: ignored
339 * ex_anon_gid: ignored
340 * size: size in bytes of passed in nfsctl_export
341 * Output:
342 * On success: returns zero
343 * On error: return code is negative errno value
344 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345static ssize_t write_unexport(struct file *file, char *buf, size_t size)
346{
347 struct nfsctl_export *data;
348
349 if (size < sizeof(*data))
350 return -EINVAL;
351 data = (struct nfsctl_export*)buf;
352 return exp_unexport(data);
353}
354
Chuck Lever262a0982008-12-12 16:57:35 -0500355/**
356 * write_getfs - Get a variable-length NFS file handle by path
357 *
358 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
359 * Function remains to support old versions of nfs-utils.
360 *
361 * Input:
362 * buf: struct nfsctl_fsparm
363 * gd_addr: socket address of client
364 * gd_path: '\0'-terminated C string
365 * containing pathname of
366 * directory in local file system
367 * gd_maxlen: maximum size of returned file
368 * handle
369 * size: size in bytes of passed in nfsctl_fsparm
370 * Output:
371 * On success: passed-in buffer filled with a knfsd_fh structure
372 * (a variable-length raw NFS file handle);
373 * return code is the size in bytes of the file handle
374 * On error: return code is negative errno value
375 *
376 * Note: Only AF_INET client addresses are passed in, since gd_addr
377 * is the same size as a struct sockaddr_in.
378 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379static ssize_t write_getfs(struct file *file, char *buf, size_t size)
380{
381 struct nfsctl_fsparm *data;
382 struct sockaddr_in *sin;
383 struct auth_domain *clp;
384 int err = 0;
385 struct knfsd_fh *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100386 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 if (size < sizeof(*data))
389 return -EINVAL;
390 data = (struct nfsctl_fsparm*)buf;
391 err = -EPROTONOSUPPORT;
392 if (data->gd_addr.sa_family != AF_INET)
393 goto out;
394 sin = (struct sockaddr_in *)&data->gd_addr;
395 if (data->gd_maxlen > NFS3_FHSIZE)
396 data->gd_maxlen = NFS3_FHSIZE;
397
398 res = (struct knfsd_fh*)buf;
399
400 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100401
402 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
403
404 clp = auth_unix_lookup(&in6);
405 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 err = -EPERM;
407 else {
408 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
409 auth_domain_put(clp);
410 }
411 exp_readunlock();
412 if (err == 0)
Andrew Morton12127492007-07-17 04:04:34 -0700413 err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 out:
415 return err;
416}
417
Chuck Lever262a0982008-12-12 16:57:35 -0500418/**
419 * write_getfd - Get a fixed-length NFS file handle by path (used by mountd)
420 *
421 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
422 * Function remains to support old versions of nfs-utils.
423 *
424 * Input:
425 * buf: struct nfsctl_fdparm
426 * gd_addr: socket address of client
427 * gd_path: '\0'-terminated C string
428 * containing pathname of
429 * directory in local file system
430 * gd_version: fdparm structure version
431 * size: size in bytes of passed in nfsctl_fdparm
432 * Output:
433 * On success: passed-in buffer filled with nfsctl_res
434 * (a fixed-length raw NFS file handle);
435 * return code is the size in bytes of the file handle
436 * On error: return code is negative errno value
437 *
438 * Note: Only AF_INET client addresses are passed in, since gd_addr
439 * is the same size as a struct sockaddr_in.
440 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441static ssize_t write_getfd(struct file *file, char *buf, size_t size)
442{
443 struct nfsctl_fdparm *data;
444 struct sockaddr_in *sin;
445 struct auth_domain *clp;
446 int err = 0;
447 struct knfsd_fh fh;
448 char *res;
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100449 struct in6_addr in6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 if (size < sizeof(*data))
452 return -EINVAL;
453 data = (struct nfsctl_fdparm*)buf;
454 err = -EPROTONOSUPPORT;
455 if (data->gd_addr.sa_family != AF_INET)
456 goto out;
457 err = -EINVAL;
458 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
459 goto out;
460
461 res = buf;
462 sin = (struct sockaddr_in *)&data->gd_addr;
463 exp_readlock();
Aurélien Charbonf15364b2008-01-18 15:50:56 +0100464
465 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
466
467 clp = auth_unix_lookup(&in6);
468 if (!clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 err = -EPERM;
470 else {
471 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
472 auth_domain_put(clp);
473 }
474 exp_readunlock();
475
476 if (err == 0) {
477 memset(res,0, NFS_FHSIZE);
478 memcpy(res, &fh.fh_base, fh.fh_size);
479 err = NFS_FHSIZE;
480 }
481 out:
482 return err;
483}
484
Chuck Lever262a0982008-12-12 16:57:35 -0500485/**
486 * write_unlock_ip - Release all locks used by a client
487 *
488 * Experimental.
489 *
490 * Input:
491 * buf: '\n'-terminated C string containing a
Chuck Lever41160922009-08-09 15:09:40 -0400492 * presentation format IP address
Chuck Lever262a0982008-12-12 16:57:35 -0500493 * size: length of C string in @buf
494 * Output:
495 * On success: returns zero if all specified locks were released;
496 * returns one if one or more locks were not released
497 * On error: return code is negative errno value
Chuck Lever262a0982008-12-12 16:57:35 -0500498 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500499static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500500{
Chuck Lever41160922009-08-09 15:09:40 -0400501 struct sockaddr_storage address;
502 struct sockaddr *sap = (struct sockaddr *)&address;
503 size_t salen = sizeof(address);
Chuck Lever367c8c72008-06-30 18:58:14 -0400504 char *fo_path;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500505
506 /* sanity check */
507 if (size == 0)
508 return -EINVAL;
509
510 if (buf[size-1] != '\n')
511 return -EINVAL;
512
513 fo_path = buf;
514 if (qword_get(&buf, fo_path, size) < 0)
515 return -EINVAL;
516
Chuck Lever41160922009-08-09 15:09:40 -0400517 if (rpc_pton(fo_path, size, sap, salen) == 0)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500518 return -EINVAL;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500519
Chuck Lever41160922009-08-09 15:09:40 -0400520 return nlmsvc_unlock_all_by_ip(sap);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500521}
522
Chuck Lever262a0982008-12-12 16:57:35 -0500523/**
524 * write_unlock_fs - Release all locks on a local file system
525 *
526 * Experimental.
527 *
528 * Input:
529 * buf: '\n'-terminated C string containing the
530 * absolute pathname of a local file system
531 * size: length of C string in @buf
532 * Output:
533 * On success: returns zero if all specified locks were released;
534 * returns one if one or more locks were not released
535 * On error: return code is negative errno value
536 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500537static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
Wendy Cheng17efa372008-01-17 11:10:12 -0500538{
Al Viroa63bb992008-08-02 01:03:36 -0400539 struct path path;
Wendy Cheng17efa372008-01-17 11:10:12 -0500540 char *fo_path;
541 int error;
542
543 /* sanity check */
544 if (size == 0)
545 return -EINVAL;
546
547 if (buf[size-1] != '\n')
548 return -EINVAL;
549
550 fo_path = buf;
551 if (qword_get(&buf, fo_path, size) < 0)
552 return -EINVAL;
553
Al Viroa63bb992008-08-02 01:03:36 -0400554 error = kern_path(fo_path, 0, &path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500555 if (error)
556 return error;
557
Chuck Lever262a0982008-12-12 16:57:35 -0500558 /*
559 * XXX: Needs better sanity checking. Otherwise we could end up
560 * releasing locks on the wrong file system.
561 *
562 * For example:
563 * 1. Does the path refer to a directory?
564 * 2. Is that directory a mount point, or
565 * 3. Is that directory the root of an exported file system?
566 */
Al Viroa63bb992008-08-02 01:03:36 -0400567 error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb);
Wendy Cheng17efa372008-01-17 11:10:12 -0500568
Al Viroa63bb992008-08-02 01:03:36 -0400569 path_put(&path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500570 return error;
571}
572
Chuck Lever262a0982008-12-12 16:57:35 -0500573/**
574 * write_filehandle - Get a variable-length NFS file handle by path
575 *
576 * On input, the buffer contains a '\n'-terminated C string comprised of
577 * three alphanumeric words separated by whitespace. The string may
578 * contain escape sequences.
579 *
580 * Input:
581 * buf:
582 * domain: client domain name
583 * path: export pathname
584 * maxsize: numeric maximum size of
585 * @buf
586 * size: length of C string in @buf
587 * Output:
588 * On success: passed-in buffer filled with '\n'-terminated C
589 * string containing a ASCII hex text version
590 * of the NFS file handle;
591 * return code is the size in bytes of the string
592 * On error: return code is negative errno value
593 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
595{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 char *dname, *path;
Andrew Morton246d95b2007-08-09 00:53:50 -0700597 int uninitialized_var(maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 char *mesg = buf;
599 int len;
600 struct auth_domain *dom;
601 struct knfsd_fh fh;
602
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500603 if (size == 0)
604 return -EINVAL;
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (buf[size-1] != '\n')
607 return -EINVAL;
608 buf[size-1] = 0;
609
610 dname = mesg;
611 len = qword_get(&mesg, dname, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500612 if (len <= 0)
613 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 path = dname+len+1;
616 len = qword_get(&mesg, path, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500617 if (len <= 0)
618 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620 len = get_int(&mesg, &maxsize);
621 if (len)
622 return len;
623
624 if (maxsize < NFS_FHSIZE)
625 return -EINVAL;
626 if (maxsize > NFS3_FHSIZE)
627 maxsize = NFS3_FHSIZE;
628
629 if (qword_get(&mesg, mesg, size)>0)
630 return -EINVAL;
631
632 /* we have all the words, they are in buf.. */
633 dom = unix_domain_find(dname);
634 if (!dom)
635 return -ENOMEM;
636
637 len = exp_rootfh(dom, path, &fh, maxsize);
638 auth_domain_put(dom);
639 if (len)
640 return len;
641
Chuck Lever54224f02008-12-12 16:57:20 -0500642 mesg = buf;
643 len = SIMPLE_TRANSACTION_LIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
645 mesg[-1] = '\n';
646 return mesg - buf;
647}
648
Chuck Lever262a0982008-12-12 16:57:35 -0500649/**
650 * write_threads - Start NFSD, or report the current number of running threads
651 *
652 * Input:
653 * buf: ignored
654 * size: zero
655 * Output:
656 * On success: passed-in buffer filled with '\n'-terminated C
657 * string numeric value representing the number of
658 * running NFSD threads;
659 * return code is the size in bytes of the string
660 * On error: return code is zero
661 *
662 * OR
663 *
664 * Input:
665 * buf: C string containing an unsigned
666 * integer value representing the
667 * number of NFSD threads to start
668 * size: non-zero length of C string in @buf
669 * Output:
670 * On success: NFS service is started;
671 * passed-in buffer filled with '\n'-terminated C
672 * string numeric value representing the number of
673 * running NFSD threads;
674 * return code is the size in bytes of the string
675 * On error: return code is zero or a negative errno value
676 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677static ssize_t write_threads(struct file *file, char *buf, size_t size)
678{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 char *mesg = buf;
680 int rv;
681 if (size > 0) {
682 int newthreads;
683 rv = get_int(&mesg, &newthreads);
684 if (rv)
685 return rv;
Chuck Lever9e074852008-12-12 16:57:27 -0500686 if (newthreads < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 return -EINVAL;
Chuck Lever9e074852008-12-12 16:57:27 -0500688 rv = nfsd_svc(NFS_PORT, newthreads);
NeilBrown82e12fe2009-06-16 11:03:07 +1000689 if (rv < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 return rv;
NeilBrown82e12fe2009-06-16 11:03:07 +1000691 } else
692 rv = nfsd_nrthreads();
Chuck Levere06b6402009-04-23 19:33:25 -0400693
NeilBrown82e12fe2009-06-16 11:03:07 +1000694 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695}
696
Chuck Lever262a0982008-12-12 16:57:35 -0500697/**
698 * write_pool_threads - Set or report the current number of threads per pool
699 *
700 * Input:
701 * buf: ignored
702 * size: zero
703 *
704 * OR
705 *
706 * Input:
707 * buf: C string containing whitespace-
708 * separated unsigned integer values
709 * representing the number of NFSD
710 * threads to start in each pool
711 * size: non-zero length of C string in @buf
712 * Output:
713 * On success: passed-in buffer filled with '\n'-terminated C
714 * string containing integer values representing the
715 * number of NFSD threads in each pool;
716 * return code is the size in bytes of the string
717 * On error: return code is zero or a negative errno value
718 */
Greg Bankseed29652006-10-02 02:18:02 -0700719static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
720{
721 /* if size > 0, look for an array of number of threads per node
722 * and apply them then write out number of threads per node as reply
723 */
724 char *mesg = buf;
725 int i;
726 int rv;
727 int len;
Neil Brownbedbdd82008-06-10 08:40:35 -0400728 int npools;
Greg Bankseed29652006-10-02 02:18:02 -0700729 int *nthreads;
730
Neil Brownbedbdd82008-06-10 08:40:35 -0400731 mutex_lock(&nfsd_mutex);
732 npools = nfsd_nrpools();
Greg Bankseed29652006-10-02 02:18:02 -0700733 if (npools == 0) {
734 /*
735 * NFS is shut down. The admin can start it by
736 * writing to the threads file but NOT the pool_threads
737 * file, sorry. Report zero threads.
738 */
Neil Brownbedbdd82008-06-10 08:40:35 -0400739 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700740 strcpy(buf, "0\n");
741 return strlen(buf);
742 }
743
744 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
Neil Brownbedbdd82008-06-10 08:40:35 -0400745 rv = -ENOMEM;
Greg Bankseed29652006-10-02 02:18:02 -0700746 if (nthreads == NULL)
Neil Brownbedbdd82008-06-10 08:40:35 -0400747 goto out_free;
Greg Bankseed29652006-10-02 02:18:02 -0700748
749 if (size > 0) {
750 for (i = 0; i < npools; i++) {
751 rv = get_int(&mesg, &nthreads[i]);
752 if (rv == -ENOENT)
753 break; /* fewer numbers than pools */
754 if (rv)
755 goto out_free; /* syntax error */
756 rv = -EINVAL;
757 if (nthreads[i] < 0)
758 goto out_free;
759 }
760 rv = nfsd_set_nrthreads(i, nthreads);
761 if (rv)
762 goto out_free;
763 }
764
765 rv = nfsd_get_nrthreads(npools, nthreads);
766 if (rv)
767 goto out_free;
768
769 mesg = buf;
770 size = SIMPLE_TRANSACTION_LIMIT;
771 for (i = 0; i < npools && size > 0; i++) {
772 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
773 len = strlen(mesg);
774 size -= len;
775 mesg += len;
776 }
J. Bruce Fields413d63d7102009-07-28 11:37:25 -0400777 rv = mesg - buf;
Greg Bankseed29652006-10-02 02:18:02 -0700778out_free:
779 kfree(nthreads);
Neil Brownbedbdd82008-06-10 08:40:35 -0400780 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700781 return rv;
782}
783
Jeff Layton3dd98a32008-06-10 08:40:36 -0400784static ssize_t __write_versions(struct file *file, char *buf, size_t size)
NeilBrown70c3b762005-11-07 01:00:25 -0800785{
NeilBrown70c3b762005-11-07 01:00:25 -0800786 char *mesg = buf;
Benny Halevy8daf2202009-04-03 08:28:59 +0300787 char *vers, *minorp, sign;
Chuck Lever261758b2009-04-23 19:33:18 -0400788 int len, num, remaining;
Benny Halevy8daf2202009-04-03 08:28:59 +0300789 unsigned minor;
NeilBrown70c3b762005-11-07 01:00:25 -0800790 ssize_t tlen = 0;
791 char *sep;
792
793 if (size>0) {
794 if (nfsd_serv)
NeilBrown6658d3a2006-10-02 02:17:46 -0700795 /* Cannot change versions without updating
796 * nfsd_serv->sv_xdrsize, and reallocing
797 * rq_argp and rq_resp
798 */
NeilBrown70c3b762005-11-07 01:00:25 -0800799 return -EBUSY;
800 if (buf[size-1] != '\n')
801 return -EINVAL;
802 buf[size-1] = 0;
803
804 vers = mesg;
805 len = qword_get(&mesg, vers, size);
806 if (len <= 0) return -EINVAL;
807 do {
808 sign = *vers;
809 if (sign == '+' || sign == '-')
Benny Halevy8daf2202009-04-03 08:28:59 +0300810 num = simple_strtol((vers+1), &minorp, 0);
NeilBrown70c3b762005-11-07 01:00:25 -0800811 else
Benny Halevy8daf2202009-04-03 08:28:59 +0300812 num = simple_strtol(vers, &minorp, 0);
813 if (*minorp == '.') {
814 if (num < 4)
815 return -EINVAL;
816 minor = simple_strtoul(minorp+1, NULL, 0);
817 if (minor == 0)
818 return -EINVAL;
819 if (nfsd_minorversion(minor, sign == '-' ?
820 NFSD_CLEAR : NFSD_SET) < 0)
821 return -EINVAL;
822 goto next;
823 }
NeilBrown70c3b762005-11-07 01:00:25 -0800824 switch(num) {
825 case 2:
826 case 3:
827 case 4:
NeilBrown6658d3a2006-10-02 02:17:46 -0700828 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
NeilBrown70c3b762005-11-07 01:00:25 -0800829 break;
830 default:
831 return -EINVAL;
832 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300833 next:
NeilBrown70c3b762005-11-07 01:00:25 -0800834 vers += len + 1;
NeilBrown70c3b762005-11-07 01:00:25 -0800835 } while ((len = qword_get(&mesg, vers, size)) > 0);
836 /* If all get turned off, turn them back on, as
837 * having no versions is BAD
838 */
NeilBrown6658d3a2006-10-02 02:17:46 -0700839 nfsd_reset_versions();
NeilBrown70c3b762005-11-07 01:00:25 -0800840 }
Chuck Lever261758b2009-04-23 19:33:18 -0400841
NeilBrown70c3b762005-11-07 01:00:25 -0800842 /* Now write current state into reply buffer */
843 len = 0;
844 sep = "";
Chuck Lever261758b2009-04-23 19:33:18 -0400845 remaining = SIMPLE_TRANSACTION_LIMIT;
NeilBrown70c3b762005-11-07 01:00:25 -0800846 for (num=2 ; num <= 4 ; num++)
NeilBrown6658d3a2006-10-02 02:17:46 -0700847 if (nfsd_vers(num, NFSD_AVAIL)) {
Chuck Lever261758b2009-04-23 19:33:18 -0400848 len = snprintf(buf, remaining, "%s%c%d", sep,
NeilBrown6658d3a2006-10-02 02:17:46 -0700849 nfsd_vers(num, NFSD_TEST)?'+':'-',
NeilBrown70c3b762005-11-07 01:00:25 -0800850 num);
851 sep = " ";
Chuck Lever261758b2009-04-23 19:33:18 -0400852
853 if (len > remaining)
854 break;
855 remaining -= len;
856 buf += len;
857 tlen += len;
NeilBrown70c3b762005-11-07 01:00:25 -0800858 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300859 if (nfsd_vers(4, NFSD_AVAIL))
Chuck Lever261758b2009-04-23 19:33:18 -0400860 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
861 minor++) {
862 len = snprintf(buf, remaining, " %c4.%u",
Benny Halevy8daf2202009-04-03 08:28:59 +0300863 (nfsd_vers(4, NFSD_TEST) &&
864 nfsd_minorversion(minor, NFSD_TEST)) ?
865 '+' : '-',
866 minor);
Chuck Lever261758b2009-04-23 19:33:18 -0400867
868 if (len > remaining)
869 break;
870 remaining -= len;
871 buf += len;
872 tlen += len;
873 }
874
875 len = snprintf(buf, remaining, "\n");
876 if (len > remaining)
877 return -EINVAL;
878 return tlen + len;
NeilBrown70c3b762005-11-07 01:00:25 -0800879}
880
Chuck Lever262a0982008-12-12 16:57:35 -0500881/**
882 * write_versions - Set or report the available NFS protocol versions
883 *
884 * Input:
885 * buf: ignored
886 * size: zero
887 * Output:
888 * On success: passed-in buffer filled with '\n'-terminated C
889 * string containing positive or negative integer
890 * values representing the current status of each
891 * protocol version;
892 * return code is the size in bytes of the string
893 * On error: return code is zero or a negative errno value
894 *
895 * OR
896 *
897 * Input:
898 * buf: C string containing whitespace-
899 * separated positive or negative
900 * integer values representing NFS
901 * protocol versions to enable ("+n")
902 * or disable ("-n")
903 * size: non-zero length of C string in @buf
904 * Output:
905 * On success: status of zero or more protocol versions has
906 * been updated; passed-in buffer filled with
907 * '\n'-terminated C string containing positive
908 * or negative integer values representing the
909 * current status of each protocol version;
910 * return code is the size in bytes of the string
911 * On error: return code is zero or a negative errno value
912 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400913static ssize_t write_versions(struct file *file, char *buf, size_t size)
914{
915 ssize_t rv;
916
917 mutex_lock(&nfsd_mutex);
918 rv = __write_versions(file, buf, size);
919 mutex_unlock(&nfsd_mutex);
920 return rv;
921}
922
Chuck Lever4cd5dc72009-04-23 19:31:32 -0400923/*
Chuck Lever0a5372d2009-04-23 19:32:10 -0400924 * Zero-length write. Return a list of NFSD's current listener
925 * transports.
926 */
927static ssize_t __write_ports_names(char *buf)
928{
929 if (nfsd_serv == NULL)
930 return 0;
Chuck Lever335c54b2009-04-23 19:32:25 -0400931 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Lever0a5372d2009-04-23 19:32:10 -0400932}
933
934/*
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400935 * A single 'fd' number was written, in which case it must be for
936 * a socket of a supported family/protocol, and we use it as an
937 * nfsd listener.
938 */
939static ssize_t __write_ports_addfd(char *buf)
940{
941 char *mesg = buf;
942 int fd, err;
943
944 err = get_int(&mesg, &fd);
945 if (err != 0 || fd < 0)
946 return -EINVAL;
947
948 err = nfsd_create_serv();
949 if (err != 0)
950 return err;
951
Chuck Leverea068ba2009-04-23 19:32:18 -0400952 err = lockd_up();
Jeff Layton78a8d7c2010-07-19 16:50:05 -0400953 if (err != 0) {
954 svc_destroy(nfsd_serv);
955 return err;
956 }
Chuck Leverea068ba2009-04-23 19:32:18 -0400957
Chuck Leverbfba9ab2009-04-23 19:32:33 -0400958 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
Jeff Layton78a8d7c2010-07-19 16:50:05 -0400959 if (err < 0) {
Chuck Leverea068ba2009-04-23 19:32:18 -0400960 lockd_down();
Jeff Layton78a8d7c2010-07-19 16:50:05 -0400961 svc_destroy(nfsd_serv);
962 return err;
963 }
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400964
Chuck Leverea068ba2009-04-23 19:32:18 -0400965 /* Decrease the count, but don't shut down the service */
966 nfsd_serv->sv_nrthreads--;
967 return err;
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400968}
969
970/*
Chuck Lever82d56592009-04-23 19:31:48 -0400971 * A '-' followed by the 'name' of a socket means we close the socket.
972 */
973static ssize_t __write_ports_delfd(char *buf)
974{
975 char *toclose;
976 int len = 0;
977
978 toclose = kstrdup(buf + 1, GFP_KERNEL);
979 if (toclose == NULL)
980 return -ENOMEM;
981
982 if (nfsd_serv != NULL)
Chuck Lever8435d342009-04-23 19:32:40 -0400983 len = svc_sock_names(nfsd_serv, buf,
984 SIMPLE_TRANSACTION_LIMIT, toclose);
Chuck Lever82d56592009-04-23 19:31:48 -0400985 if (len >= 0)
986 lockd_down();
987
988 kfree(toclose);
989 return len;
990}
991
992/*
Chuck Lever4eb68c22009-04-23 19:31:40 -0400993 * A transport listener is added by writing it's transport name and
994 * a port number.
995 */
996static ssize_t __write_ports_addxprt(char *buf)
997{
998 char transport[16];
Chuck Lever37498292010-01-26 14:04:22 -0500999 struct svc_xprt *xprt;
Chuck Lever4eb68c22009-04-23 19:31:40 -04001000 int port, err;
1001
1002 if (sscanf(buf, "%15s %4u", transport, &port) != 2)
1003 return -EINVAL;
1004
Alexey Dobriyan4be929b2010-05-24 14:33:03 -07001005 if (port < 1 || port > USHRT_MAX)
Chuck Lever4eb68c22009-04-23 19:31:40 -04001006 return -EINVAL;
1007
1008 err = nfsd_create_serv();
1009 if (err != 0)
1010 return err;
1011
1012 err = svc_create_xprt(nfsd_serv, transport,
1013 PF_INET, port, SVC_SOCK_ANONYMOUS);
Chuck Lever68717902010-01-26 14:04:13 -05001014 if (err < 0)
Chuck Lever37498292010-01-26 14:04:22 -05001015 goto out_err;
1016
1017 err = svc_create_xprt(nfsd_serv, transport,
1018 PF_INET6, port, SVC_SOCK_ANONYMOUS);
1019 if (err < 0 && err != -EAFNOSUPPORT)
1020 goto out_close;
Chuck Lever4eb68c22009-04-23 19:31:40 -04001021 return 0;
Chuck Lever37498292010-01-26 14:04:22 -05001022out_close:
1023 xprt = svc_find_xprt(nfsd_serv, transport, PF_INET, port);
1024 if (xprt != NULL) {
1025 svc_close_xprt(xprt);
1026 svc_xprt_put(xprt);
1027 }
1028out_err:
1029 /* Decrease the count, but don't shut down the service */
1030 nfsd_serv->sv_nrthreads--;
1031 return err;
Chuck Lever4eb68c22009-04-23 19:31:40 -04001032}
1033
1034/*
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001035 * A transport listener is removed by writing a "-", it's transport
1036 * name, and it's port number.
1037 */
1038static ssize_t __write_ports_delxprt(char *buf)
1039{
1040 struct svc_xprt *xprt;
1041 char transport[16];
1042 int port;
1043
1044 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
1045 return -EINVAL;
1046
Alexey Dobriyan4be929b2010-05-24 14:33:03 -07001047 if (port < 1 || port > USHRT_MAX || nfsd_serv == NULL)
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001048 return -EINVAL;
1049
1050 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
1051 if (xprt == NULL)
1052 return -ENOTCONN;
1053
1054 svc_close_xprt(xprt);
1055 svc_xprt_put(xprt);
1056 return 0;
1057}
1058
Neil Brownbedbdd82008-06-10 08:40:35 -04001059static ssize_t __write_ports(struct file *file, char *buf, size_t size)
NeilBrown80212d52006-10-02 02:17:47 -07001060{
Chuck Lever0a5372d2009-04-23 19:32:10 -04001061 if (size == 0)
1062 return __write_ports_names(buf);
Chuck Lever0b7c2f62009-04-23 19:31:55 -04001063
1064 if (isdigit(buf[0]))
1065 return __write_ports_addfd(buf);
Chuck Lever82d56592009-04-23 19:31:48 -04001066
1067 if (buf[0] == '-' && isdigit(buf[1]))
1068 return __write_ports_delfd(buf);
Chuck Lever4eb68c22009-04-23 19:31:40 -04001069
1070 if (isalpha(buf[0]))
1071 return __write_ports_addxprt(buf);
Chuck Lever4cd5dc72009-04-23 19:31:32 -04001072
1073 if (buf[0] == '-' && isalpha(buf[1]))
1074 return __write_ports_delxprt(buf);
1075
NeilBrownb41b66d2006-10-02 02:17:48 -07001076 return -EINVAL;
NeilBrown80212d52006-10-02 02:17:47 -07001077}
1078
Chuck Lever262a0982008-12-12 16:57:35 -05001079/**
1080 * write_ports - Pass a socket file descriptor or transport name to listen on
1081 *
1082 * Input:
1083 * buf: ignored
1084 * size: zero
1085 * Output:
1086 * On success: passed-in buffer filled with a '\n'-terminated C
1087 * string containing a whitespace-separated list of
1088 * named NFSD listeners;
1089 * return code is the size in bytes of the string
1090 * On error: return code is zero or a negative errno value
1091 *
1092 * OR
1093 *
1094 * Input:
1095 * buf: C string containing an unsigned
1096 * integer value representing a bound
1097 * but unconnected socket that is to be
Chuck Leverc71206a2009-04-23 19:32:03 -04001098 * used as an NFSD listener; listen(3)
1099 * must be called for a SOCK_STREAM
1100 * socket, otherwise it is ignored
Chuck Lever262a0982008-12-12 16:57:35 -05001101 * size: non-zero length of C string in @buf
1102 * Output:
1103 * On success: NFS service is started;
1104 * passed-in buffer filled with a '\n'-terminated C
1105 * string containing a unique alphanumeric name of
1106 * the listener;
1107 * return code is the size in bytes of the string
1108 * On error: return code is a negative errno value
1109 *
1110 * OR
1111 *
1112 * Input:
1113 * buf: C string containing a "-" followed
1114 * by an integer value representing a
1115 * previously passed in socket file
1116 * descriptor
1117 * size: non-zero length of C string in @buf
1118 * Output:
1119 * On success: NFS service no longer listens on that socket;
1120 * passed-in buffer filled with a '\n'-terminated C
1121 * string containing a unique name of the listener;
1122 * return code is the size in bytes of the string
1123 * On error: return code is a negative errno value
1124 *
1125 * OR
1126 *
1127 * Input:
1128 * buf: C string containing a transport
1129 * name and an unsigned integer value
1130 * representing the port to listen on,
1131 * separated by whitespace
1132 * size: non-zero length of C string in @buf
1133 * Output:
1134 * On success: returns zero; NFS service is started
1135 * On error: return code is a negative errno value
1136 *
1137 * OR
1138 *
1139 * Input:
1140 * buf: C string containing a "-" followed
1141 * by a transport name and an unsigned
1142 * integer value representing the port
1143 * to listen on, separated by whitespace
1144 * size: non-zero length of C string in @buf
1145 * Output:
1146 * On success: returns zero; NFS service no longer listens
1147 * on that transport
1148 * On error: return code is a negative errno value
1149 */
Neil Brownbedbdd82008-06-10 08:40:35 -04001150static ssize_t write_ports(struct file *file, char *buf, size_t size)
1151{
1152 ssize_t rv;
Jeff Layton3dd98a32008-06-10 08:40:36 -04001153
Neil Brownbedbdd82008-06-10 08:40:35 -04001154 mutex_lock(&nfsd_mutex);
1155 rv = __write_ports(file, buf, size);
1156 mutex_unlock(&nfsd_mutex);
1157 return rv;
1158}
1159
1160
NeilBrown596bbe52006-10-04 02:15:48 -07001161int nfsd_max_blksize;
1162
Chuck Lever262a0982008-12-12 16:57:35 -05001163/**
1164 * write_maxblksize - Set or report the current NFS blksize
1165 *
1166 * Input:
1167 * buf: ignored
1168 * size: zero
1169 *
1170 * OR
1171 *
1172 * Input:
1173 * buf: C string containing an unsigned
1174 * integer value representing the new
1175 * NFS blksize
1176 * size: non-zero length of C string in @buf
1177 * Output:
1178 * On success: passed-in buffer filled with '\n'-terminated C string
1179 * containing numeric value of the current NFS blksize
1180 * setting;
1181 * return code is the size in bytes of the string
1182 * On error: return code is zero or a negative errno value
1183 */
NeilBrown596bbe52006-10-04 02:15:48 -07001184static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
1185{
1186 char *mesg = buf;
1187 if (size > 0) {
1188 int bsize;
1189 int rv = get_int(&mesg, &bsize);
1190 if (rv)
1191 return rv;
1192 /* force bsize into allowed range and
1193 * required alignment.
1194 */
1195 if (bsize < 1024)
1196 bsize = 1024;
1197 if (bsize > NFSSVC_MAXBLKSIZE)
1198 bsize = NFSSVC_MAXBLKSIZE;
1199 bsize &= ~(1024-1);
Neil Brownbedbdd82008-06-10 08:40:35 -04001200 mutex_lock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001201 if (nfsd_serv && nfsd_serv->sv_nrthreads) {
Neil Brownbedbdd82008-06-10 08:40:35 -04001202 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001203 return -EBUSY;
1204 }
1205 nfsd_max_blksize = bsize;
Neil Brownbedbdd82008-06-10 08:40:35 -04001206 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -07001207 }
Chuck Levere06b6402009-04-23 19:33:25 -04001208
1209 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
1210 nfsd_max_blksize);
NeilBrown596bbe52006-10-04 02:15:48 -07001211}
1212
NeilBrown70c3b762005-11-07 01:00:25 -08001213#ifdef CONFIG_NFSD_V4
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001214static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 char *mesg = buf;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001217 int rv, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
1219 if (size > 0) {
Jeff Layton3dd98a32008-06-10 08:40:36 -04001220 if (nfsd_serv)
1221 return -EBUSY;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001222 rv = get_int(&mesg, &i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 if (rv)
1224 return rv;
J. Bruce Fieldse7b184f2010-03-02 11:18:40 -05001225 /*
1226 * Some sanity checking. We don't have a reason for
1227 * these particular numbers, but problems with the
1228 * extremes are:
1229 * - Too short: the briefest network outage may
1230 * cause clients to lose all their locks. Also,
1231 * the frequent polling may be wasteful.
1232 * - Too long: do you really want reboot recovery
1233 * to take more than an hour? Or to make other
1234 * clients wait an hour before being able to
1235 * revoke a dead client's locks?
1236 */
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001237 if (i < 10 || i > 3600)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 return -EINVAL;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001239 *time = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 }
Chuck Levere06b6402009-04-23 19:33:25 -04001241
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001242 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
1243}
1244
1245static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
1246{
1247 ssize_t rv;
1248
1249 mutex_lock(&nfsd_mutex);
1250 rv = __nfsd4_write_time(file, buf, size, time);
1251 mutex_unlock(&nfsd_mutex);
1252 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253}
1254
Chuck Lever262a0982008-12-12 16:57:35 -05001255/**
1256 * write_leasetime - Set or report the current NFSv4 lease time
1257 *
1258 * Input:
1259 * buf: ignored
1260 * size: zero
1261 *
1262 * OR
1263 *
1264 * Input:
1265 * buf: C string containing an unsigned
1266 * integer value representing the new
1267 * NFSv4 lease expiry time
1268 * size: non-zero length of C string in @buf
1269 * Output:
1270 * On success: passed-in buffer filled with '\n'-terminated C
1271 * string containing unsigned integer value of the
1272 * current lease expiry time;
1273 * return code is the size in bytes of the string
1274 * On error: return code is zero or a negative errno value
1275 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001276static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
1277{
J. Bruce Fieldsf0135742010-03-01 19:32:36 -05001278 return nfsd4_write_time(file, buf, size, &nfsd4_lease);
Jeff Layton3dd98a32008-06-10 08:40:36 -04001279}
1280
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -05001281/**
1282 * write_gracetime - Set or report current NFSv4 grace period time
1283 *
1284 * As above, but sets the time of the NFSv4 grace period.
1285 *
1286 * Note this should never be set to less than the *previous*
1287 * lease-period time, but we don't try to enforce this. (In the common
1288 * case (a new boot), we don't know what the previous lease time was
1289 * anyway.)
1290 */
1291static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
1292{
1293 return nfsd4_write_time(file, buf, size, &nfsd4_grace);
1294}
1295
Jeff Layton3dd98a32008-06-10 08:40:36 -04001296extern char *nfs4_recoverydir(void);
1297
1298static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
NeilBrown0964a3d2005-06-23 22:04:32 -07001299{
1300 char *mesg = buf;
1301 char *recdir;
1302 int len, status;
1303
Jeff Layton3dd98a32008-06-10 08:40:36 -04001304 if (size > 0) {
1305 if (nfsd_serv)
1306 return -EBUSY;
1307 if (size > PATH_MAX || buf[size-1] != '\n')
1308 return -EINVAL;
1309 buf[size-1] = 0;
NeilBrown0964a3d2005-06-23 22:04:32 -07001310
Jeff Layton3dd98a32008-06-10 08:40:36 -04001311 recdir = mesg;
1312 len = qword_get(&mesg, recdir, size);
1313 if (len <= 0)
1314 return -EINVAL;
NeilBrown0964a3d2005-06-23 22:04:32 -07001315
Jeff Layton3dd98a32008-06-10 08:40:36 -04001316 status = nfs4_reset_recoverydir(recdir);
1317 }
Chuck Lever3d72ab82009-04-23 19:33:10 -04001318
1319 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1320 nfs4_recoverydir());
NeilBrown0964a3d2005-06-23 22:04:32 -07001321}
Jeff Layton3dd98a32008-06-10 08:40:36 -04001322
Chuck Lever262a0982008-12-12 16:57:35 -05001323/**
1324 * write_recoverydir - Set or report the pathname of the recovery directory
1325 *
1326 * Input:
1327 * buf: ignored
1328 * size: zero
1329 *
1330 * OR
1331 *
1332 * Input:
1333 * buf: C string containing the pathname
1334 * of the directory on a local file
1335 * system containing permanent NFSv4
1336 * recovery data
1337 * size: non-zero length of C string in @buf
1338 * Output:
1339 * On success: passed-in buffer filled with '\n'-terminated C string
1340 * containing the current recovery pathname setting;
1341 * return code is the size in bytes of the string
1342 * On error: return code is zero or a negative errno value
1343 */
Jeff Layton3dd98a32008-06-10 08:40:36 -04001344static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1345{
1346 ssize_t rv;
1347
1348 mutex_lock(&nfsd_mutex);
1349 rv = __write_recoverydir(file, buf, size);
1350 mutex_unlock(&nfsd_mutex);
1351 return rv;
1352}
1353
NeilBrown70c3b762005-11-07 01:00:25 -08001354#endif
NeilBrown0964a3d2005-06-23 22:04:32 -07001355
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356/*----------------------------------------------------------------------------*/
1357/*
1358 * populating the filesystem.
1359 */
1360
1361static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1362{
1363 static struct tree_descr nfsd_files[] = {
1364 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
1365 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
1366 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
1367 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
1368 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
1369 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
1370 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
1371 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
J. Bruce Fieldse8e87532009-12-14 12:53:32 -05001372 [NFSD_Export_features] = {"export_features",
1373 &export_features_operations, S_IRUGO},
Wendy Cheng4373ea82008-01-17 11:10:12 -05001374 [NFSD_FO_UnlockIP] = {"unlock_ip",
1375 &transaction_ops, S_IWUSR|S_IRUSR},
Wendy Cheng17efa372008-01-17 11:10:12 -05001376 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1377 &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1379 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Bankseed29652006-10-02 02:18:02 -07001380 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Banks03cf6c92009-01-13 21:26:36 +11001381 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
NeilBrown70c3b762005-11-07 01:00:25 -08001382 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown80212d52006-10-02 02:17:47 -07001383 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
NeilBrown596bbe52006-10-04 02:15:48 -07001384 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385#ifdef CONFIG_NFSD_V4
1386 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -05001387 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown0964a3d2005-06-23 22:04:32 -07001388 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389#endif
1390 /* last one */ {""}
1391 };
1392 return simple_fill_super(sb, 0x6e667364, nfsd_files);
1393}
1394
David Howells454e2392006-06-23 02:02:57 -07001395static int nfsd_get_sb(struct file_system_type *fs_type,
1396 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397{
David Howells454e2392006-06-23 02:02:57 -07001398 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399}
1400
1401static struct file_system_type nfsd_fs_type = {
1402 .owner = THIS_MODULE,
1403 .name = "nfsd",
1404 .get_sb = nfsd_get_sb,
1405 .kill_sb = kill_litter_super,
1406};
1407
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001408#ifdef CONFIG_PROC_FS
1409static int create_proc_exports_entry(void)
1410{
1411 struct proc_dir_entry *entry;
1412
1413 entry = proc_mkdir("fs/nfs", NULL);
1414 if (!entry)
1415 return -ENOMEM;
Denis V. Lunev9ef2db22008-04-29 01:02:04 -07001416 entry = proc_create("exports", 0, entry, &exports_operations);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001417 if (!entry)
1418 return -ENOMEM;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001419 return 0;
1420}
1421#else /* CONFIG_PROC_FS */
1422static int create_proc_exports_entry(void)
1423{
1424 return 0;
1425}
1426#endif
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428static int __init init_nfsd(void)
1429{
1430 int retval;
1431 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1432
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001433 retval = nfs4_state_init(); /* nfs4 locking state */
1434 if (retval)
1435 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 nfsd_stat_init(); /* Statistics */
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001437 retval = nfsd_reply_cache_init();
1438 if (retval)
1439 goto out_free_stat;
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001440 retval = nfsd_export_init();
1441 if (retval)
1442 goto out_free_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 nfsd_lockd_init(); /* lockd->nfsd callbacks */
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001444 retval = nfsd_idmap_init();
1445 if (retval)
1446 goto out_free_lockd;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001447 retval = create_proc_exports_entry();
1448 if (retval)
1449 goto out_free_idmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 retval = register_filesystem(&nfsd_fs_type);
J. Bruce Fields26808d32007-11-09 13:44:06 -05001451 if (retval)
1452 goto out_free_all;
1453 return 0;
1454out_free_all:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001455 remove_proc_entry("fs/nfs/exports", NULL);
1456 remove_proc_entry("fs/nfs", NULL);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001457out_free_idmap:
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001458 nfsd_idmap_shutdown();
1459out_free_lockd:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001460 nfsd_lockd_shutdown();
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001461 nfsd_export_shutdown();
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001462out_free_cache:
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001463 nfsd_reply_cache_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001464out_free_stat:
1465 nfsd_stat_shutdown();
J. Bruce Fields26808d32007-11-09 13:44:06 -05001466 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 return retval;
1468}
1469
1470static void __exit exit_nfsd(void)
1471{
1472 nfsd_export_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001473 nfsd_reply_cache_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 remove_proc_entry("fs/nfs/exports", NULL);
1475 remove_proc_entry("fs/nfs", NULL);
1476 nfsd_stat_shutdown();
1477 nfsd_lockd_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 nfsd_idmap_shutdown();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001479 nfsd4_free_slabs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 unregister_filesystem(&nfsd_fs_type);
1481}
1482
1483MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1484MODULE_LICENSE("GPL");
1485module_init(init_nfsd)
1486module_exit(exit_nfsd)