blob: 2db7021b01ae3f771f77a7e1d7fd0a693d4d0551 [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
NeilBrown80212d52006-10-02 02:17:47 -070011#include <linux/sunrpc/svcsock.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050012#include <linux/lockd/lockd.h>
Chuck Lever41160922009-08-09 15:09:40 -040013#include <linux/sunrpc/clnt.h>
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -050014#include <linux/sunrpc/gss_api.h>
J. Bruce Fieldsb084f592011-05-31 12:24:58 -040015#include <linux/sunrpc/gss_krb5_enctypes.h>
Jeff Layton813fd322012-03-21 09:52:08 -040016#include <linux/sunrpc/rpc_pipe_fs.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040017#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
J. Bruce Fields2ca72e12011-01-04 17:37:15 -050019#include "idmap.h"
Boaz Harrosh9a74af22009-12-03 20:30:56 +020020#include "nfsd.h"
21#include "cache.h"
Bryan Schumakerf3c75212012-11-27 09:35:10 -050022#include "state.h"
Jeff Layton7ea34ac2012-03-21 09:52:05 -040023#include "netns.h"
Boaz Harrosh9a74af22009-12-03 20:30:56 +020024
Linus Torvalds1da177e2005-04-16 15:20:36 -070025/*
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -050026 * We have a single directory with several nodes in it.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 */
28enum {
29 NFSD_Root = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 NFSD_List,
J. Bruce Fieldse8e87532009-12-14 12:53:32 -050031 NFSD_Export_features,
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 NFSD_Fh,
Wendy Cheng4373ea82008-01-17 11:10:12 -050033 NFSD_FO_UnlockIP,
Wendy Cheng17efa372008-01-17 11:10:12 -050034 NFSD_FO_UnlockFS,
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 NFSD_Threads,
Greg Bankseed29652006-10-02 02:18:02 -070036 NFSD_Pool_Threads,
Greg Banks03cf6c92009-01-13 21:26:36 +110037 NFSD_Pool_Stats,
NeilBrown70c3b762005-11-07 01:00:25 -080038 NFSD_Versions,
NeilBrown80212d52006-10-02 02:17:47 -070039 NFSD_Ports,
NeilBrown596bbe52006-10-04 02:15:48 -070040 NFSD_MaxBlkSize,
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -050041 NFSD_SupportedEnctypes,
NeilBrown70c3b762005-11-07 01:00:25 -080042 /*
43 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
44 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
45 */
46#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 NFSD_Leasetime,
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050048 NFSD_Gracetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070049 NFSD_RecoveryDir,
NeilBrown70c3b762005-11-07 01:00:25 -080050#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070051};
52
53/*
54 * write() for these nodes.
55 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
Chuck Leverb046ccd2008-12-12 16:57:13 -050057static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
58static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static ssize_t write_threads(struct file *file, char *buf, size_t size);
Greg Bankseed29652006-10-02 02:18:02 -070060static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080061static ssize_t write_versions(struct file *file, char *buf, size_t size);
NeilBrown80212d52006-10-02 02:17:47 -070062static ssize_t write_ports(struct file *file, char *buf, size_t size);
NeilBrown596bbe52006-10-04 02:15:48 -070063static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080064#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070065static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050066static ssize_t write_gracetime(struct file *file, char *buf, size_t size);
NeilBrown0964a3d2005-06-23 22:04:32 -070067static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
NeilBrown70c3b762005-11-07 01:00:25 -080068#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70static ssize_t (*write_op[])(struct file *, char *, size_t) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 [NFSD_Fh] = write_filehandle,
Chuck Leverb046ccd2008-12-12 16:57:13 -050072 [NFSD_FO_UnlockIP] = write_unlock_ip,
73 [NFSD_FO_UnlockFS] = write_unlock_fs,
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 [NFSD_Threads] = write_threads,
Greg Bankseed29652006-10-02 02:18:02 -070075 [NFSD_Pool_Threads] = write_pool_threads,
NeilBrown70c3b762005-11-07 01:00:25 -080076 [NFSD_Versions] = write_versions,
NeilBrown80212d52006-10-02 02:17:47 -070077 [NFSD_Ports] = write_ports,
NeilBrown596bbe52006-10-04 02:15:48 -070078 [NFSD_MaxBlkSize] = write_maxblksize,
NeilBrown70c3b762005-11-07 01:00:25 -080079#ifdef CONFIG_NFSD_V4
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 [NFSD_Leasetime] = write_leasetime,
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050081 [NFSD_Gracetime] = write_gracetime,
NeilBrown0964a3d2005-06-23 22:04:32 -070082 [NFSD_RecoveryDir] = write_recoverydir,
NeilBrown70c3b762005-11-07 01:00:25 -080083#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070084};
85
86static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
87{
Al Viro496ad9a2013-01-23 17:07:38 -050088 ino_t ino = file_inode(file)->i_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 char *data;
90 ssize_t rv;
91
Tobias Klausere8c96f82006-03-24 03:15:34 -080092 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 return -EINVAL;
94
95 data = simple_transaction_get(file, buf, size);
96 if (IS_ERR(data))
97 return PTR_ERR(data);
98
99 rv = write_op[ino](file, data, size);
NeilBrown8971a102007-02-14 00:33:11 -0800100 if (rv >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 simple_transaction_set(file, rv);
102 rv = size;
103 }
104 return rv;
105}
106
NeilBrown73900222005-11-07 01:00:24 -0800107static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
108{
109 if (! file->private_data) {
110 /* An attempt to read a transaction file without writing
111 * causes a 0-byte write so that the file can return
112 * state information
113 */
114 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
115 if (rv < 0)
116 return rv;
117 }
118 return simple_transaction_read(file, buf, size, pos);
119}
120
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800121static const struct file_operations transaction_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 .write = nfsctl_transaction_write,
NeilBrown73900222005-11-07 01:00:24 -0800123 .read = nfsctl_transaction_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 .release = simple_transaction_release,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200125 .llseek = default_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126};
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128static int exports_open(struct inode *inode, struct file *file)
129{
Stanislav Kinsburskyf2c7ea12012-03-28 19:09:29 +0400130 int err;
131 struct seq_file *seq;
Stanislav Kinsburskye5f06f72012-04-11 15:13:28 +0400132 struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
Stanislav Kinsburskyf2c7ea12012-03-28 19:09:29 +0400133
134 err = seq_open(file, &nfs_exports_op);
135 if (err)
136 return err;
137
138 seq = file->private_data;
Stanislav Kinsburskye5f06f72012-04-11 15:13:28 +0400139 seq->private = nn->svc_export_cache;
Stanislav Kinsburskyf2c7ea12012-03-28 19:09:29 +0400140 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141}
142
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800143static const struct file_operations exports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 .open = exports_open,
145 .read = seq_read,
146 .llseek = seq_lseek,
147 .release = seq_release,
Denis V. Lunev9ef2db22008-04-29 01:02:04 -0700148 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149};
150
J. Bruce Fieldse8e87532009-12-14 12:53:32 -0500151static int export_features_show(struct seq_file *m, void *v)
152{
153 seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
154 return 0;
155}
156
157static int export_features_open(struct inode *inode, struct file *file)
158{
159 return single_open(file, export_features_show, NULL);
160}
161
162static struct file_operations export_features_operations = {
163 .open = export_features_open,
164 .read = seq_read,
165 .llseek = seq_lseek,
166 .release = single_release,
167};
168
J. Bruce Fieldsb084f592011-05-31 12:24:58 -0400169#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -0500170static int supported_enctypes_show(struct seq_file *m, void *v)
171{
J. Bruce Fieldsb084f592011-05-31 12:24:58 -0400172 seq_printf(m, KRB5_SUPPORTED_ENCTYPES);
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -0500173 return 0;
174}
175
176static int supported_enctypes_open(struct inode *inode, struct file *file)
177{
178 return single_open(file, supported_enctypes_show, NULL);
179}
180
181static struct file_operations supported_enctypes_ops = {
182 .open = supported_enctypes_open,
183 .read = seq_read,
184 .llseek = seq_lseek,
185 .release = single_release,
186};
J. Bruce Fieldsb084f592011-05-31 12:24:58 -0400187#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -0500188
Alexey Dobriyan828c0952009-10-01 15:43:56 -0700189static const struct file_operations pool_stats_operations = {
Greg Banks03cf6c92009-01-13 21:26:36 +1100190 .open = nfsd_pool_stats_open,
191 .read = seq_read,
192 .llseek = seq_lseek,
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900193 .release = nfsd_pool_stats_release,
Greg Banks03cf6c92009-01-13 21:26:36 +1100194 .owner = THIS_MODULE,
195};
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197/*----------------------------------------------------------------------------*/
198/*
199 * payload - write methods
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 */
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Chuck Lever262a0982008-12-12 16:57:35 -0500203/**
204 * write_unlock_ip - Release all locks used by a client
205 *
206 * Experimental.
207 *
208 * Input:
209 * buf: '\n'-terminated C string containing a
Chuck Lever41160922009-08-09 15:09:40 -0400210 * presentation format IP address
Chuck Lever262a0982008-12-12 16:57:35 -0500211 * size: length of C string in @buf
212 * Output:
213 * On success: returns zero if all specified locks were released;
214 * returns one if one or more locks were not released
215 * On error: return code is negative errno value
Chuck Lever262a0982008-12-12 16:57:35 -0500216 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500217static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500218{
Chuck Lever41160922009-08-09 15:09:40 -0400219 struct sockaddr_storage address;
220 struct sockaddr *sap = (struct sockaddr *)&address;
221 size_t salen = sizeof(address);
Chuck Lever367c8c72008-06-30 18:58:14 -0400222 char *fo_path;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500223
224 /* sanity check */
225 if (size == 0)
226 return -EINVAL;
227
228 if (buf[size-1] != '\n')
229 return -EINVAL;
230
231 fo_path = buf;
232 if (qword_get(&buf, fo_path, size) < 0)
233 return -EINVAL;
234
Stanislav Kinsbursky90100b12012-01-13 13:09:19 +0400235 if (rpc_pton(&init_net, fo_path, size, sap, salen) == 0)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500236 return -EINVAL;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500237
Chuck Lever41160922009-08-09 15:09:40 -0400238 return nlmsvc_unlock_all_by_ip(sap);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500239}
240
Chuck Lever262a0982008-12-12 16:57:35 -0500241/**
242 * write_unlock_fs - Release all locks on a local file system
243 *
244 * Experimental.
245 *
246 * Input:
247 * buf: '\n'-terminated C string containing the
248 * absolute pathname of a local file system
249 * size: length of C string in @buf
250 * Output:
251 * On success: returns zero if all specified locks were released;
252 * returns one if one or more locks were not released
253 * On error: return code is negative errno value
254 */
Chuck Leverb046ccd2008-12-12 16:57:13 -0500255static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
Wendy Cheng17efa372008-01-17 11:10:12 -0500256{
Al Viroa63bb992008-08-02 01:03:36 -0400257 struct path path;
Wendy Cheng17efa372008-01-17 11:10:12 -0500258 char *fo_path;
259 int error;
260
261 /* sanity check */
262 if (size == 0)
263 return -EINVAL;
264
265 if (buf[size-1] != '\n')
266 return -EINVAL;
267
268 fo_path = buf;
269 if (qword_get(&buf, fo_path, size) < 0)
270 return -EINVAL;
271
Al Viroa63bb992008-08-02 01:03:36 -0400272 error = kern_path(fo_path, 0, &path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500273 if (error)
274 return error;
275
Chuck Lever262a0982008-12-12 16:57:35 -0500276 /*
277 * XXX: Needs better sanity checking. Otherwise we could end up
278 * releasing locks on the wrong file system.
279 *
280 * For example:
281 * 1. Does the path refer to a directory?
282 * 2. Is that directory a mount point, or
283 * 3. Is that directory the root of an exported file system?
284 */
Al Virod8c95842011-12-07 18:16:57 -0500285 error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
Wendy Cheng17efa372008-01-17 11:10:12 -0500286
Al Viroa63bb992008-08-02 01:03:36 -0400287 path_put(&path);
Wendy Cheng17efa372008-01-17 11:10:12 -0500288 return error;
289}
290
Chuck Lever262a0982008-12-12 16:57:35 -0500291/**
292 * write_filehandle - Get a variable-length NFS file handle by path
293 *
294 * On input, the buffer contains a '\n'-terminated C string comprised of
295 * three alphanumeric words separated by whitespace. The string may
296 * contain escape sequences.
297 *
298 * Input:
299 * buf:
300 * domain: client domain name
301 * path: export pathname
302 * maxsize: numeric maximum size of
303 * @buf
304 * size: length of C string in @buf
305 * Output:
306 * On success: passed-in buffer filled with '\n'-terminated C
307 * string containing a ASCII hex text version
308 * of the NFS file handle;
309 * return code is the size in bytes of the string
310 * On error: return code is negative errno value
311 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
313{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 char *dname, *path;
Andrew Morton246d95b2007-08-09 00:53:50 -0700315 int uninitialized_var(maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 char *mesg = buf;
317 int len;
318 struct auth_domain *dom;
319 struct knfsd_fh fh;
320
J. Bruce Fields87d26ea2008-01-22 17:40:42 -0500321 if (size == 0)
322 return -EINVAL;
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (buf[size-1] != '\n')
325 return -EINVAL;
326 buf[size-1] = 0;
327
328 dname = mesg;
329 len = qword_get(&mesg, dname, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500330 if (len <= 0)
331 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333 path = dname+len+1;
334 len = qword_get(&mesg, path, size);
Chuck Lever54224f02008-12-12 16:57:20 -0500335 if (len <= 0)
336 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338 len = get_int(&mesg, &maxsize);
339 if (len)
340 return len;
341
342 if (maxsize < NFS_FHSIZE)
343 return -EINVAL;
344 if (maxsize > NFS3_FHSIZE)
345 maxsize = NFS3_FHSIZE;
346
347 if (qword_get(&mesg, mesg, size)>0)
348 return -EINVAL;
349
350 /* we have all the words, they are in buf.. */
351 dom = unix_domain_find(dname);
352 if (!dom)
353 return -ENOMEM;
354
Stanislav Kinsburskyb3853e02012-04-11 15:13:21 +0400355 len = exp_rootfh(&init_net, dom, path, &fh, maxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 auth_domain_put(dom);
357 if (len)
358 return len;
359
Chuck Lever54224f02008-12-12 16:57:20 -0500360 mesg = buf;
361 len = SIMPLE_TRANSACTION_LIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
363 mesg[-1] = '\n';
364 return mesg - buf;
365}
366
Chuck Lever262a0982008-12-12 16:57:35 -0500367/**
368 * write_threads - Start NFSD, or report the current number of running threads
369 *
370 * Input:
371 * buf: ignored
372 * size: zero
373 * Output:
374 * On success: passed-in buffer filled with '\n'-terminated C
375 * string numeric value representing the number of
376 * running NFSD threads;
377 * return code is the size in bytes of the string
378 * On error: return code is zero
379 *
380 * OR
381 *
382 * Input:
383 * buf: C string containing an unsigned
384 * integer value representing the
385 * number of NFSD threads to start
386 * size: non-zero length of C string in @buf
387 * Output:
388 * On success: NFS service is started;
389 * passed-in buffer filled with '\n'-terminated C
390 * string numeric value representing the number of
391 * running NFSD threads;
392 * return code is the size in bytes of the string
393 * On error: return code is zero or a negative errno value
394 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395static ssize_t write_threads(struct file *file, char *buf, size_t size)
396{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 char *mesg = buf;
398 int rv;
Stanislav Kinsburskyd41a9412012-12-10 12:19:25 +0300399 struct net *net = &init_net;
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (size > 0) {
402 int newthreads;
403 rv = get_int(&mesg, &newthreads);
404 if (rv)
405 return rv;
Chuck Lever9e074852008-12-12 16:57:27 -0500406 if (newthreads < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return -EINVAL;
Stanislav Kinsburskyd41a9412012-12-10 12:19:25 +0300408 rv = nfsd_svc(newthreads, net);
NeilBrown82e12fe2009-06-16 11:03:07 +1000409 if (rv < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 return rv;
NeilBrown82e12fe2009-06-16 11:03:07 +1000411 } else
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300412 rv = nfsd_nrthreads(net);
Chuck Levere06b6402009-04-23 19:33:25 -0400413
NeilBrown82e12fe2009-06-16 11:03:07 +1000414 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415}
416
Chuck Lever262a0982008-12-12 16:57:35 -0500417/**
418 * write_pool_threads - Set or report the current number of threads per pool
419 *
420 * Input:
421 * buf: ignored
422 * size: zero
423 *
424 * OR
425 *
426 * Input:
427 * buf: C string containing whitespace-
428 * separated unsigned integer values
429 * representing the number of NFSD
430 * threads to start in each pool
431 * size: non-zero length of C string in @buf
432 * Output:
433 * On success: passed-in buffer filled with '\n'-terminated C
434 * string containing integer values representing the
435 * number of NFSD threads in each pool;
436 * return code is the size in bytes of the string
437 * On error: return code is zero or a negative errno value
438 */
Greg Bankseed29652006-10-02 02:18:02 -0700439static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
440{
441 /* if size > 0, look for an array of number of threads per node
442 * and apply them then write out number of threads per node as reply
443 */
444 char *mesg = buf;
445 int i;
446 int rv;
447 int len;
Neil Brownbedbdd82008-06-10 08:40:35 -0400448 int npools;
Greg Bankseed29652006-10-02 02:18:02 -0700449 int *nthreads;
Stanislav Kinsbursky3938a0d2012-12-10 12:19:30 +0300450 struct net *net = &init_net;
Greg Bankseed29652006-10-02 02:18:02 -0700451
Neil Brownbedbdd82008-06-10 08:40:35 -0400452 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300453 npools = nfsd_nrpools(net);
Greg Bankseed29652006-10-02 02:18:02 -0700454 if (npools == 0) {
455 /*
456 * NFS is shut down. The admin can start it by
457 * writing to the threads file but NOT the pool_threads
458 * file, sorry. Report zero threads.
459 */
Neil Brownbedbdd82008-06-10 08:40:35 -0400460 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700461 strcpy(buf, "0\n");
462 return strlen(buf);
463 }
464
465 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
Neil Brownbedbdd82008-06-10 08:40:35 -0400466 rv = -ENOMEM;
Greg Bankseed29652006-10-02 02:18:02 -0700467 if (nthreads == NULL)
Neil Brownbedbdd82008-06-10 08:40:35 -0400468 goto out_free;
Greg Bankseed29652006-10-02 02:18:02 -0700469
470 if (size > 0) {
471 for (i = 0; i < npools; i++) {
472 rv = get_int(&mesg, &nthreads[i]);
473 if (rv == -ENOENT)
474 break; /* fewer numbers than pools */
475 if (rv)
476 goto out_free; /* syntax error */
477 rv = -EINVAL;
478 if (nthreads[i] < 0)
479 goto out_free;
480 }
Stanislav Kinsbursky3938a0d2012-12-10 12:19:30 +0300481 rv = nfsd_set_nrthreads(i, nthreads, net);
Greg Bankseed29652006-10-02 02:18:02 -0700482 if (rv)
483 goto out_free;
484 }
485
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300486 rv = nfsd_get_nrthreads(npools, nthreads, net);
Greg Bankseed29652006-10-02 02:18:02 -0700487 if (rv)
488 goto out_free;
489
490 mesg = buf;
491 size = SIMPLE_TRANSACTION_LIMIT;
492 for (i = 0; i < npools && size > 0; i++) {
493 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
494 len = strlen(mesg);
495 size -= len;
496 mesg += len;
497 }
J. Bruce Fields413d63d7102009-07-28 11:37:25 -0400498 rv = mesg - buf;
Greg Bankseed29652006-10-02 02:18:02 -0700499out_free:
500 kfree(nthreads);
Neil Brownbedbdd82008-06-10 08:40:35 -0400501 mutex_unlock(&nfsd_mutex);
Greg Bankseed29652006-10-02 02:18:02 -0700502 return rv;
503}
504
Jeff Layton3dd98a32008-06-10 08:40:36 -0400505static ssize_t __write_versions(struct file *file, char *buf, size_t size)
NeilBrown70c3b762005-11-07 01:00:25 -0800506{
NeilBrown70c3b762005-11-07 01:00:25 -0800507 char *mesg = buf;
Benny Halevy8daf2202009-04-03 08:28:59 +0300508 char *vers, *minorp, sign;
Chuck Lever261758b2009-04-23 19:33:18 -0400509 int len, num, remaining;
Benny Halevy8daf2202009-04-03 08:28:59 +0300510 unsigned minor;
NeilBrown70c3b762005-11-07 01:00:25 -0800511 ssize_t tlen = 0;
512 char *sep;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300513 struct net *net = &init_net;
514 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
NeilBrown70c3b762005-11-07 01:00:25 -0800515
516 if (size>0) {
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300517 if (nn->nfsd_serv)
NeilBrown6658d3a2006-10-02 02:17:46 -0700518 /* Cannot change versions without updating
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300519 * nn->nfsd_serv->sv_xdrsize, and reallocing
NeilBrown6658d3a2006-10-02 02:17:46 -0700520 * rq_argp and rq_resp
521 */
NeilBrown70c3b762005-11-07 01:00:25 -0800522 return -EBUSY;
523 if (buf[size-1] != '\n')
524 return -EINVAL;
525 buf[size-1] = 0;
526
527 vers = mesg;
528 len = qword_get(&mesg, vers, size);
529 if (len <= 0) return -EINVAL;
530 do {
531 sign = *vers;
532 if (sign == '+' || sign == '-')
Benny Halevy8daf2202009-04-03 08:28:59 +0300533 num = simple_strtol((vers+1), &minorp, 0);
NeilBrown70c3b762005-11-07 01:00:25 -0800534 else
Benny Halevy8daf2202009-04-03 08:28:59 +0300535 num = simple_strtol(vers, &minorp, 0);
536 if (*minorp == '.') {
537 if (num < 4)
538 return -EINVAL;
539 minor = simple_strtoul(minorp+1, NULL, 0);
540 if (minor == 0)
541 return -EINVAL;
542 if (nfsd_minorversion(minor, sign == '-' ?
543 NFSD_CLEAR : NFSD_SET) < 0)
544 return -EINVAL;
545 goto next;
546 }
NeilBrown70c3b762005-11-07 01:00:25 -0800547 switch(num) {
548 case 2:
549 case 3:
550 case 4:
NeilBrown6658d3a2006-10-02 02:17:46 -0700551 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
NeilBrown70c3b762005-11-07 01:00:25 -0800552 break;
553 default:
554 return -EINVAL;
555 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300556 next:
NeilBrown70c3b762005-11-07 01:00:25 -0800557 vers += len + 1;
NeilBrown70c3b762005-11-07 01:00:25 -0800558 } while ((len = qword_get(&mesg, vers, size)) > 0);
559 /* If all get turned off, turn them back on, as
560 * having no versions is BAD
561 */
NeilBrown6658d3a2006-10-02 02:17:46 -0700562 nfsd_reset_versions();
NeilBrown70c3b762005-11-07 01:00:25 -0800563 }
Chuck Lever261758b2009-04-23 19:33:18 -0400564
NeilBrown70c3b762005-11-07 01:00:25 -0800565 /* Now write current state into reply buffer */
566 len = 0;
567 sep = "";
Chuck Lever261758b2009-04-23 19:33:18 -0400568 remaining = SIMPLE_TRANSACTION_LIMIT;
NeilBrown70c3b762005-11-07 01:00:25 -0800569 for (num=2 ; num <= 4 ; num++)
NeilBrown6658d3a2006-10-02 02:17:46 -0700570 if (nfsd_vers(num, NFSD_AVAIL)) {
Chuck Lever261758b2009-04-23 19:33:18 -0400571 len = snprintf(buf, remaining, "%s%c%d", sep,
NeilBrown6658d3a2006-10-02 02:17:46 -0700572 nfsd_vers(num, NFSD_TEST)?'+':'-',
NeilBrown70c3b762005-11-07 01:00:25 -0800573 num);
574 sep = " ";
Chuck Lever261758b2009-04-23 19:33:18 -0400575
576 if (len > remaining)
577 break;
578 remaining -= len;
579 buf += len;
580 tlen += len;
NeilBrown70c3b762005-11-07 01:00:25 -0800581 }
Benny Halevy8daf2202009-04-03 08:28:59 +0300582 if (nfsd_vers(4, NFSD_AVAIL))
Chuck Lever261758b2009-04-23 19:33:18 -0400583 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
584 minor++) {
585 len = snprintf(buf, remaining, " %c4.%u",
Benny Halevy8daf2202009-04-03 08:28:59 +0300586 (nfsd_vers(4, NFSD_TEST) &&
587 nfsd_minorversion(minor, NFSD_TEST)) ?
588 '+' : '-',
589 minor);
Chuck Lever261758b2009-04-23 19:33:18 -0400590
591 if (len > remaining)
592 break;
593 remaining -= len;
594 buf += len;
595 tlen += len;
596 }
597
598 len = snprintf(buf, remaining, "\n");
599 if (len > remaining)
600 return -EINVAL;
601 return tlen + len;
NeilBrown70c3b762005-11-07 01:00:25 -0800602}
603
Chuck Lever262a0982008-12-12 16:57:35 -0500604/**
605 * write_versions - Set or report the available NFS protocol versions
606 *
607 * Input:
608 * buf: ignored
609 * size: zero
610 * Output:
611 * On success: passed-in buffer filled with '\n'-terminated C
612 * string containing positive or negative integer
613 * values representing the current status of each
614 * protocol version;
615 * return code is the size in bytes of the string
616 * On error: return code is zero or a negative errno value
617 *
618 * OR
619 *
620 * Input:
621 * buf: C string containing whitespace-
622 * separated positive or negative
623 * integer values representing NFS
624 * protocol versions to enable ("+n")
625 * or disable ("-n")
626 * size: non-zero length of C string in @buf
627 * Output:
628 * On success: status of zero or more protocol versions has
629 * been updated; passed-in buffer filled with
630 * '\n'-terminated C string containing positive
631 * or negative integer values representing the
632 * current status of each protocol version;
633 * return code is the size in bytes of the string
634 * On error: return code is zero or a negative errno value
635 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400636static ssize_t write_versions(struct file *file, char *buf, size_t size)
637{
638 ssize_t rv;
639
640 mutex_lock(&nfsd_mutex);
641 rv = __write_versions(file, buf, size);
642 mutex_unlock(&nfsd_mutex);
643 return rv;
644}
645
Chuck Lever4cd5dc72009-04-23 19:31:32 -0400646/*
Chuck Lever0a5372d2009-04-23 19:32:10 -0400647 * Zero-length write. Return a list of NFSD's current listener
648 * transports.
649 */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300650static ssize_t __write_ports_names(char *buf, struct net *net)
Chuck Lever0a5372d2009-04-23 19:32:10 -0400651{
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300652 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
653
654 if (nn->nfsd_serv == NULL)
Chuck Lever0a5372d2009-04-23 19:32:10 -0400655 return 0;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300656 return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
Chuck Lever0a5372d2009-04-23 19:32:10 -0400657}
658
659/*
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400660 * A single 'fd' number was written, in which case it must be for
661 * a socket of a supported family/protocol, and we use it as an
662 * nfsd listener.
663 */
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300664static ssize_t __write_ports_addfd(char *buf, struct net *net)
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400665{
666 char *mesg = buf;
667 int fd, err;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300668 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400669
670 err = get_int(&mesg, &fd);
671 if (err != 0 || fd < 0)
672 return -EINVAL;
673
Stanislav Kinsbursky67774362012-12-10 12:19:20 +0300674 err = nfsd_create_serv(net);
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400675 if (err != 0)
676 return err;
677
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300678 err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
Jeff Layton78a8d7c2010-07-19 16:50:05 -0400679 if (err < 0) {
Stanislav Kinsbursky19f7e2c2012-07-03 16:46:41 +0400680 nfsd_destroy(net);
Jeff Layton78a8d7c2010-07-19 16:50:05 -0400681 return err;
682 }
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400683
Chuck Leverea068ba2009-04-23 19:32:18 -0400684 /* Decrease the count, but don't shut down the service */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300685 nn->nfsd_serv->sv_nrthreads--;
Chuck Leverea068ba2009-04-23 19:32:18 -0400686 return err;
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400687}
688
689/*
Chuck Lever4eb68c22009-04-23 19:31:40 -0400690 * A transport listener is added by writing it's transport name and
691 * a port number.
692 */
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300693static ssize_t __write_ports_addxprt(char *buf, struct net *net)
Chuck Lever4eb68c22009-04-23 19:31:40 -0400694{
695 char transport[16];
Chuck Lever37498292010-01-26 14:04:22 -0500696 struct svc_xprt *xprt;
Chuck Lever4eb68c22009-04-23 19:31:40 -0400697 int port, err;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300698 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Chuck Lever4eb68c22009-04-23 19:31:40 -0400699
J. Bruce Fieldsa10fded2012-08-14 17:48:39 -0400700 if (sscanf(buf, "%15s %5u", transport, &port) != 2)
Chuck Lever4eb68c22009-04-23 19:31:40 -0400701 return -EINVAL;
702
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700703 if (port < 1 || port > USHRT_MAX)
Chuck Lever4eb68c22009-04-23 19:31:40 -0400704 return -EINVAL;
705
Stanislav Kinsbursky67774362012-12-10 12:19:20 +0300706 err = nfsd_create_serv(net);
Chuck Lever4eb68c22009-04-23 19:31:40 -0400707 if (err != 0)
708 return err;
709
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300710 err = svc_create_xprt(nn->nfsd_serv, transport, net,
Chuck Lever4eb68c22009-04-23 19:31:40 -0400711 PF_INET, port, SVC_SOCK_ANONYMOUS);
Chuck Lever68717902010-01-26 14:04:13 -0500712 if (err < 0)
Chuck Lever37498292010-01-26 14:04:22 -0500713 goto out_err;
714
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300715 err = svc_create_xprt(nn->nfsd_serv, transport, net,
Chuck Lever37498292010-01-26 14:04:22 -0500716 PF_INET6, port, SVC_SOCK_ANONYMOUS);
717 if (err < 0 && err != -EAFNOSUPPORT)
718 goto out_close;
Jeff Layton0cd14a02010-07-19 16:50:06 -0400719
720 /* Decrease the count, but don't shut down the service */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300721 nn->nfsd_serv->sv_nrthreads--;
Chuck Lever4eb68c22009-04-23 19:31:40 -0400722 return 0;
Chuck Lever37498292010-01-26 14:04:22 -0500723out_close:
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300724 xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port);
Chuck Lever37498292010-01-26 14:04:22 -0500725 if (xprt != NULL) {
726 svc_close_xprt(xprt);
727 svc_xprt_put(xprt);
728 }
729out_err:
Stanislav Kinsbursky19f7e2c2012-07-03 16:46:41 +0400730 nfsd_destroy(net);
Chuck Lever37498292010-01-26 14:04:22 -0500731 return err;
Chuck Lever4eb68c22009-04-23 19:31:40 -0400732}
733
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300734static ssize_t __write_ports(struct file *file, char *buf, size_t size,
735 struct net *net)
NeilBrown80212d52006-10-02 02:17:47 -0700736{
Chuck Lever0a5372d2009-04-23 19:32:10 -0400737 if (size == 0)
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300738 return __write_ports_names(buf, net);
Chuck Lever0b7c2f62009-04-23 19:31:55 -0400739
740 if (isdigit(buf[0]))
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300741 return __write_ports_addfd(buf, net);
Chuck Lever82d56592009-04-23 19:31:48 -0400742
Chuck Lever4eb68c22009-04-23 19:31:40 -0400743 if (isalpha(buf[0]))
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300744 return __write_ports_addxprt(buf, net);
Chuck Lever4cd5dc72009-04-23 19:31:32 -0400745
NeilBrownb41b66d2006-10-02 02:17:48 -0700746 return -EINVAL;
NeilBrown80212d52006-10-02 02:17:47 -0700747}
748
Chuck Lever262a0982008-12-12 16:57:35 -0500749/**
750 * write_ports - Pass a socket file descriptor or transport name to listen on
751 *
752 * Input:
753 * buf: ignored
754 * size: zero
755 * Output:
756 * On success: passed-in buffer filled with a '\n'-terminated C
757 * string containing a whitespace-separated list of
758 * named NFSD listeners;
759 * return code is the size in bytes of the string
760 * On error: return code is zero or a negative errno value
761 *
762 * OR
763 *
764 * Input:
765 * buf: C string containing an unsigned
766 * integer value representing a bound
767 * but unconnected socket that is to be
Chuck Leverc71206a2009-04-23 19:32:03 -0400768 * used as an NFSD listener; listen(3)
769 * must be called for a SOCK_STREAM
770 * socket, otherwise it is ignored
Chuck Lever262a0982008-12-12 16:57:35 -0500771 * size: non-zero length of C string in @buf
772 * Output:
773 * On success: NFS service is started;
774 * passed-in buffer filled with a '\n'-terminated C
775 * string containing a unique alphanumeric name of
776 * the listener;
777 * return code is the size in bytes of the string
778 * On error: return code is a negative errno value
779 *
780 * OR
781 *
782 * Input:
Chuck Lever262a0982008-12-12 16:57:35 -0500783 * buf: C string containing a transport
784 * name and an unsigned integer value
785 * representing the port to listen on,
786 * separated by whitespace
787 * size: non-zero length of C string in @buf
788 * Output:
789 * On success: returns zero; NFS service is started
790 * On error: return code is a negative errno value
Chuck Lever262a0982008-12-12 16:57:35 -0500791 */
Neil Brownbedbdd82008-06-10 08:40:35 -0400792static ssize_t write_ports(struct file *file, char *buf, size_t size)
793{
794 ssize_t rv;
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300795 struct net *net = &init_net;
Jeff Layton3dd98a32008-06-10 08:40:36 -0400796
Neil Brownbedbdd82008-06-10 08:40:35 -0400797 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky08160352012-12-10 12:19:35 +0300798 rv = __write_ports(file, buf, size, net);
Neil Brownbedbdd82008-06-10 08:40:35 -0400799 mutex_unlock(&nfsd_mutex);
800 return rv;
801}
802
803
NeilBrown596bbe52006-10-04 02:15:48 -0700804int nfsd_max_blksize;
805
Chuck Lever262a0982008-12-12 16:57:35 -0500806/**
807 * write_maxblksize - Set or report the current NFS blksize
808 *
809 * Input:
810 * buf: ignored
811 * size: zero
812 *
813 * OR
814 *
815 * Input:
816 * buf: C string containing an unsigned
817 * integer value representing the new
818 * NFS blksize
819 * size: non-zero length of C string in @buf
820 * Output:
821 * On success: passed-in buffer filled with '\n'-terminated C string
822 * containing numeric value of the current NFS blksize
823 * setting;
824 * return code is the size in bytes of the string
825 * On error: return code is zero or a negative errno value
826 */
NeilBrown596bbe52006-10-04 02:15:48 -0700827static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
828{
829 char *mesg = buf;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300830 struct net *net = &init_net;
831 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
832
NeilBrown596bbe52006-10-04 02:15:48 -0700833 if (size > 0) {
834 int bsize;
835 int rv = get_int(&mesg, &bsize);
836 if (rv)
837 return rv;
838 /* force bsize into allowed range and
839 * required alignment.
840 */
841 if (bsize < 1024)
842 bsize = 1024;
843 if (bsize > NFSSVC_MAXBLKSIZE)
844 bsize = NFSSVC_MAXBLKSIZE;
845 bsize &= ~(1024-1);
Neil Brownbedbdd82008-06-10 08:40:35 -0400846 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300847 if (nn->nfsd_serv) {
Neil Brownbedbdd82008-06-10 08:40:35 -0400848 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -0700849 return -EBUSY;
850 }
851 nfsd_max_blksize = bsize;
Neil Brownbedbdd82008-06-10 08:40:35 -0400852 mutex_unlock(&nfsd_mutex);
NeilBrown596bbe52006-10-04 02:15:48 -0700853 }
Chuck Levere06b6402009-04-23 19:33:25 -0400854
855 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
856 nfsd_max_blksize);
NeilBrown596bbe52006-10-04 02:15:48 -0700857}
858
NeilBrown70c3b762005-11-07 01:00:25 -0800859#ifdef CONFIG_NFSD_V4
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300860static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size,
861 time_t *time, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 char *mesg = buf;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500864 int rv, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 if (size > 0) {
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300867 if (nn->nfsd_serv)
Jeff Layton3dd98a32008-06-10 08:40:36 -0400868 return -EBUSY;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500869 rv = get_int(&mesg, &i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 if (rv)
871 return rv;
J. Bruce Fieldse7b184f2010-03-02 11:18:40 -0500872 /*
873 * Some sanity checking. We don't have a reason for
874 * these particular numbers, but problems with the
875 * extremes are:
876 * - Too short: the briefest network outage may
877 * cause clients to lose all their locks. Also,
878 * the frequent polling may be wasteful.
879 * - Too long: do you really want reboot recovery
880 * to take more than an hour? Or to make other
881 * clients wait an hour before being able to
882 * revoke a dead client's locks?
883 */
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500884 if (i < 10 || i > 3600)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 return -EINVAL;
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500886 *time = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 }
Chuck Levere06b6402009-04-23 19:33:25 -0400888
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500889 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
890}
891
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300892static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
893 time_t *time, struct nfsd_net *nn)
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500894{
895 ssize_t rv;
896
897 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300898 rv = __nfsd4_write_time(file, buf, size, time, nn);
J. Bruce Fieldsf0135742010-03-01 19:32:36 -0500899 mutex_unlock(&nfsd_mutex);
900 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901}
902
Chuck Lever262a0982008-12-12 16:57:35 -0500903/**
904 * write_leasetime - Set or report the current NFSv4 lease time
905 *
906 * Input:
907 * buf: ignored
908 * size: zero
909 *
910 * OR
911 *
912 * Input:
913 * buf: C string containing an unsigned
914 * integer value representing the new
915 * NFSv4 lease expiry time
916 * size: non-zero length of C string in @buf
917 * Output:
918 * On success: passed-in buffer filled with '\n'-terminated C
919 * string containing unsigned integer value of the
920 * current lease expiry time;
921 * return code is the size in bytes of the string
922 * On error: return code is zero or a negative errno value
923 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400924static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
925{
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +0300926 struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300927 return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn);
Jeff Layton3dd98a32008-06-10 08:40:36 -0400928}
929
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -0500930/**
931 * write_gracetime - Set or report current NFSv4 grace period time
932 *
933 * As above, but sets the time of the NFSv4 grace period.
934 *
935 * Note this should never be set to less than the *previous*
936 * lease-period time, but we don't try to enforce this. (In the common
937 * case (a new boot), we don't know what the previous lease time was
938 * anyway.)
939 */
940static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
941{
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +0300942 struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300943 return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn);
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -0500944}
945
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300946static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
947 struct nfsd_net *nn)
NeilBrown0964a3d2005-06-23 22:04:32 -0700948{
949 char *mesg = buf;
950 char *recdir;
951 int len, status;
952
Jeff Layton3dd98a32008-06-10 08:40:36 -0400953 if (size > 0) {
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300954 if (nn->nfsd_serv)
Jeff Layton3dd98a32008-06-10 08:40:36 -0400955 return -EBUSY;
956 if (size > PATH_MAX || buf[size-1] != '\n')
957 return -EINVAL;
958 buf[size-1] = 0;
NeilBrown0964a3d2005-06-23 22:04:32 -0700959
Jeff Layton3dd98a32008-06-10 08:40:36 -0400960 recdir = mesg;
961 len = qword_get(&mesg, recdir, size);
962 if (len <= 0)
963 return -EINVAL;
NeilBrown0964a3d2005-06-23 22:04:32 -0700964
Jeff Layton3dd98a32008-06-10 08:40:36 -0400965 status = nfs4_reset_recoverydir(recdir);
Andi Kleen69049962010-07-20 15:24:27 -0700966 if (status)
967 return status;
Jeff Layton3dd98a32008-06-10 08:40:36 -0400968 }
Chuck Lever3d72ab82009-04-23 19:33:10 -0400969
970 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
971 nfs4_recoverydir());
NeilBrown0964a3d2005-06-23 22:04:32 -0700972}
Jeff Layton3dd98a32008-06-10 08:40:36 -0400973
Chuck Lever262a0982008-12-12 16:57:35 -0500974/**
975 * write_recoverydir - Set or report the pathname of the recovery directory
976 *
977 * Input:
978 * buf: ignored
979 * size: zero
980 *
981 * OR
982 *
983 * Input:
984 * buf: C string containing the pathname
985 * of the directory on a local file
986 * system containing permanent NFSv4
987 * recovery data
988 * size: non-zero length of C string in @buf
989 * Output:
990 * On success: passed-in buffer filled with '\n'-terminated C string
991 * containing the current recovery pathname setting;
992 * return code is the size in bytes of the string
993 * On error: return code is zero or a negative errno value
994 */
Jeff Layton3dd98a32008-06-10 08:40:36 -0400995static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
996{
997 ssize_t rv;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300998 struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
Jeff Layton3dd98a32008-06-10 08:40:36 -0400999
1000 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +03001001 rv = __write_recoverydir(file, buf, size, nn);
Jeff Layton3dd98a32008-06-10 08:40:36 -04001002 mutex_unlock(&nfsd_mutex);
1003 return rv;
1004}
1005
NeilBrown70c3b762005-11-07 01:00:25 -08001006#endif
NeilBrown0964a3d2005-06-23 22:04:32 -07001007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008/*----------------------------------------------------------------------------*/
1009/*
1010 * populating the filesystem.
1011 */
1012
1013static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1014{
1015 static struct tree_descr nfsd_files[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
J. Bruce Fieldse8e87532009-12-14 12:53:32 -05001017 [NFSD_Export_features] = {"export_features",
1018 &export_features_operations, S_IRUGO},
Wendy Cheng4373ea82008-01-17 11:10:12 -05001019 [NFSD_FO_UnlockIP] = {"unlock_ip",
1020 &transaction_ops, S_IWUSR|S_IRUSR},
Wendy Cheng17efa372008-01-17 11:10:12 -05001021 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1022 &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1024 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Bankseed29652006-10-02 02:18:02 -07001025 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
Greg Banks03cf6c92009-01-13 21:26:36 +11001026 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
NeilBrown70c3b762005-11-07 01:00:25 -08001027 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown80212d52006-10-02 02:17:47 -07001028 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
NeilBrown596bbe52006-10-04 02:15:48 -07001029 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
J. Bruce Fieldsb084f592011-05-31 12:24:58 -04001030#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
Kevin Coffmanb0b0c0a2011-03-02 19:51:42 -05001031 [NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO},
J. Bruce Fieldsb084f592011-05-31 12:24:58 -04001032#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033#ifdef CONFIG_NFSD_V4
1034 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -05001035 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR},
NeilBrown0964a3d2005-06-23 22:04:32 -07001036 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037#endif
1038 /* last one */ {""}
1039 };
1040 return simple_fill_super(sb, 0x6e667364, nfsd_files);
1041}
1042
Al Virofc14f2f2010-07-25 01:48:30 +04001043static struct dentry *nfsd_mount(struct file_system_type *fs_type,
1044 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045{
Al Virofc14f2f2010-07-25 01:48:30 +04001046 return mount_single(fs_type, flags, data, nfsd_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047}
1048
1049static struct file_system_type nfsd_fs_type = {
1050 .owner = THIS_MODULE,
1051 .name = "nfsd",
Al Virofc14f2f2010-07-25 01:48:30 +04001052 .mount = nfsd_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 .kill_sb = kill_litter_super,
1054};
1055
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001056#ifdef CONFIG_PROC_FS
1057static int create_proc_exports_entry(void)
1058{
1059 struct proc_dir_entry *entry;
1060
1061 entry = proc_mkdir("fs/nfs", NULL);
1062 if (!entry)
1063 return -ENOMEM;
Denis V. Lunev9ef2db22008-04-29 01:02:04 -07001064 entry = proc_create("exports", 0, entry, &exports_operations);
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001065 if (!entry)
1066 return -ENOMEM;
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001067 return 0;
1068}
1069#else /* CONFIG_PROC_FS */
1070static int create_proc_exports_entry(void)
1071{
1072 return 0;
1073}
1074#endif
1075
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001076int nfsd_net_id;
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001077
1078static __net_init int nfsd_init_net(struct net *net)
1079{
1080 int retval;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03001081 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001082
1083 retval = nfsd_export_init(net);
1084 if (retval)
1085 goto out_export_error;
Stanislav Kinsburskyf69adb22012-04-11 17:33:05 +04001086 retval = nfsd_idmap_init(net);
1087 if (retval)
1088 goto out_idmap_error;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03001089 nn->nfsd4_lease = 90; /* default lease time */
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03001090 nn->nfsd4_grace = 90;
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001091 return 0;
1092
Stanislav Kinsburskyf69adb22012-04-11 17:33:05 +04001093out_idmap_error:
1094 nfsd_export_shutdown(net);
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001095out_export_error:
1096 return retval;
1097}
1098
1099static __net_exit void nfsd_exit_net(struct net *net)
1100{
Stanislav Kinsburskyf69adb22012-04-11 17:33:05 +04001101 nfsd_idmap_shutdown(net);
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001102 nfsd_export_shutdown(net);
1103}
1104
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001105static struct pernet_operations nfsd_net_ops = {
Stanislav Kinsbursky5717e012012-04-11 15:13:35 +04001106 .init = nfsd_init_net,
1107 .exit = nfsd_exit_net,
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001108 .id = &nfsd_net_id,
1109 .size = sizeof(struct nfsd_net),
1110};
1111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112static int __init init_nfsd(void)
1113{
1114 int retval;
1115 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1116
Jeff Layton797a9d72012-03-29 07:52:49 -04001117 retval = register_cld_notifier();
Jeff Layton813fd322012-03-21 09:52:08 -04001118 if (retval)
1119 return retval;
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001120 retval = register_pernet_subsys(&nfsd_net_ops);
1121 if (retval < 0)
Jeff Layton813fd322012-03-21 09:52:08 -04001122 goto out_unregister_notifier;
Bryan Schumaker72083392011-11-01 15:24:59 -04001123 retval = nfsd4_init_slabs();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001124 if (retval)
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001125 goto out_unregister_pernet;
Bryan Schumaker72083392011-11-01 15:24:59 -04001126 nfs4_state_init();
Bryan Schumaker65178db2011-11-01 13:35:21 -04001127 retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */
1128 if (retval)
1129 goto out_free_slabs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 nfsd_stat_init(); /* Statistics */
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001131 retval = nfsd_reply_cache_init();
1132 if (retval)
1133 goto out_free_stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 nfsd_lockd_init(); /* lockd->nfsd callbacks */
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001135 retval = create_proc_exports_entry();
1136 if (retval)
Stanislav Kinsburskyf69adb22012-04-11 17:33:05 +04001137 goto out_free_lockd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 retval = register_filesystem(&nfsd_fs_type);
J. Bruce Fields26808d32007-11-09 13:44:06 -05001139 if (retval)
1140 goto out_free_all;
1141 return 0;
1142out_free_all:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001143 remove_proc_entry("fs/nfs/exports", NULL);
1144 remove_proc_entry("fs/nfs", NULL);
J. Bruce Fieldsdbf847e2007-11-08 17:20:34 -05001145out_free_lockd:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001146 nfsd_lockd_shutdown();
J. Bruce Fieldse331f602007-11-12 17:32:21 -05001147 nfsd_reply_cache_shutdown();
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001148out_free_stat:
1149 nfsd_stat_shutdown();
Bryan Schumaker65178db2011-11-01 13:35:21 -04001150 nfsd_fault_inject_cleanup();
1151out_free_slabs:
J. Bruce Fields26808d32007-11-09 13:44:06 -05001152 nfsd4_free_slabs();
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001153out_unregister_pernet:
1154 unregister_pernet_subsys(&nfsd_net_ops);
Jeff Layton813fd322012-03-21 09:52:08 -04001155out_unregister_notifier:
Jeff Layton797a9d72012-03-29 07:52:49 -04001156 unregister_cld_notifier();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 return retval;
1158}
1159
1160static void __exit exit_nfsd(void)
1161{
J. Bruce Fieldsd5c34282007-11-09 14:10:56 -05001162 nfsd_reply_cache_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 remove_proc_entry("fs/nfs/exports", NULL);
1164 remove_proc_entry("fs/nfs", NULL);
1165 nfsd_stat_shutdown();
1166 nfsd_lockd_shutdown();
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001167 nfsd4_free_slabs();
Bryan Schumaker65178db2011-11-01 13:35:21 -04001168 nfsd_fault_inject_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 unregister_filesystem(&nfsd_fs_type);
Jeff Layton7ea34ac2012-03-21 09:52:05 -04001170 unregister_pernet_subsys(&nfsd_net_ops);
Jeff Layton797a9d72012-03-29 07:52:49 -04001171 unregister_cld_notifier();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172}
1173
1174MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1175MODULE_LICENSE("GPL");
1176module_init(init_nfsd)
1177module_exit(exit_nfsd)