2019-05-19 06:08:20 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Syscall interface to knfsd.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-07-26 01:46:43 -06:00
|
|
|
#include <linux/namei.h>
|
2006-10-02 03:17:48 -06:00
|
|
|
#include <linux/ctype.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-02 03:17:47 -06:00
|
|
|
#include <linux/sunrpc/svcsock.h>
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
#include <linux/lockd/lockd.h>
|
2013-02-04 10:50:00 -07:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2011-03-02 17:51:42 -07:00
|
|
|
#include <linux/sunrpc/gss_api.h>
|
2011-05-31 10:24:58 -06:00
|
|
|
#include <linux/sunrpc/gss_krb5_enctypes.h>
|
2012-03-21 07:52:08 -06:00
|
|
|
#include <linux/sunrpc/rpc_pipe_fs.h>
|
2011-07-01 12:23:34 -06:00
|
|
|
#include <linux/module.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-04 15:37:15 -07:00
|
|
|
#include "idmap.h"
|
2009-12-03 11:30:56 -07:00
|
|
|
#include "nfsd.h"
|
|
|
|
#include "cache.h"
|
2012-11-27 07:35:10 -07:00
|
|
|
#include "state.h"
|
2012-03-21 07:52:05 -06:00
|
|
|
#include "netns.h"
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 05:11:59 -06:00
|
|
|
#include "pnfs.h"
|
2009-12-03 11:30:56 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2011-03-02 17:51:42 -07:00
|
|
|
* We have a single directory with several nodes in it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NFSD_Root = 1,
|
|
|
|
NFSD_List,
|
2009-12-14 10:53:32 -07:00
|
|
|
NFSD_Export_features,
|
2005-04-16 16:20:36 -06:00
|
|
|
NFSD_Fh,
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
NFSD_FO_UnlockIP,
|
2008-01-17 09:10:12 -07:00
|
|
|
NFSD_FO_UnlockFS,
|
2005-04-16 16:20:36 -06:00
|
|
|
NFSD_Threads,
|
2006-10-02 03:18:02 -06:00
|
|
|
NFSD_Pool_Threads,
|
2009-01-13 03:26:36 -07:00
|
|
|
NFSD_Pool_Stats,
|
2013-03-27 08:15:38 -06:00
|
|
|
NFSD_Reply_Cache_Stats,
|
2005-11-07 02:00:25 -07:00
|
|
|
NFSD_Versions,
|
2006-10-02 03:17:47 -06:00
|
|
|
NFSD_Ports,
|
2006-10-04 03:15:48 -06:00
|
|
|
NFSD_MaxBlkSize,
|
2014-07-02 14:11:22 -06:00
|
|
|
NFSD_MaxConnections,
|
2011-03-02 17:51:42 -07:00
|
|
|
NFSD_SupportedEnctypes,
|
2005-11-07 02:00:25 -07:00
|
|
|
/*
|
|
|
|
* The below MUST come last. Otherwise we leave a hole in nfsd_files[]
|
|
|
|
* with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_NFSD_V4
|
2005-04-16 16:20:36 -06:00
|
|
|
NFSD_Leasetime,
|
2010-03-02 09:04:06 -07:00
|
|
|
NFSD_Gracetime,
|
2005-06-23 23:04:32 -06:00
|
|
|
NFSD_RecoveryDir,
|
2014-09-12 14:40:21 -06:00
|
|
|
NFSD_V4EndGrace,
|
2005-11-07 02:00:25 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* write() for these nodes.
|
|
|
|
*/
|
|
|
|
static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
|
2008-12-12 14:57:13 -07:00
|
|
|
static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
|
|
|
|
static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t write_threads(struct file *file, char *buf, size_t size);
|
2006-10-02 03:18:02 -06:00
|
|
|
static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
|
2005-11-07 02:00:25 -07:00
|
|
|
static ssize_t write_versions(struct file *file, char *buf, size_t size);
|
2006-10-02 03:17:47 -06:00
|
|
|
static ssize_t write_ports(struct file *file, char *buf, size_t size);
|
2006-10-04 03:15:48 -06:00
|
|
|
static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
|
2014-07-02 14:11:22 -06:00
|
|
|
static ssize_t write_maxconn(struct file *file, char *buf, size_t size);
|
2005-11-07 02:00:25 -07:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
|
2010-03-02 09:04:06 -07:00
|
|
|
static ssize_t write_gracetime(struct file *file, char *buf, size_t size);
|
2005-06-23 23:04:32 -06:00
|
|
|
static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
|
2014-09-12 14:40:21 -06:00
|
|
|
static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size);
|
2005-11-07 02:00:25 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-07-17 12:01:25 -06:00
|
|
|
static ssize_t (*const write_op[])(struct file *, char *, size_t) = {
|
2005-04-16 16:20:36 -06:00
|
|
|
[NFSD_Fh] = write_filehandle,
|
2008-12-12 14:57:13 -07:00
|
|
|
[NFSD_FO_UnlockIP] = write_unlock_ip,
|
|
|
|
[NFSD_FO_UnlockFS] = write_unlock_fs,
|
2005-04-16 16:20:36 -06:00
|
|
|
[NFSD_Threads] = write_threads,
|
2006-10-02 03:18:02 -06:00
|
|
|
[NFSD_Pool_Threads] = write_pool_threads,
|
2005-11-07 02:00:25 -07:00
|
|
|
[NFSD_Versions] = write_versions,
|
2006-10-02 03:17:47 -06:00
|
|
|
[NFSD_Ports] = write_ports,
|
2006-10-04 03:15:48 -06:00
|
|
|
[NFSD_MaxBlkSize] = write_maxblksize,
|
2014-07-02 14:11:22 -06:00
|
|
|
[NFSD_MaxConnections] = write_maxconn,
|
2005-11-07 02:00:25 -07:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2005-04-16 16:20:36 -06:00
|
|
|
[NFSD_Leasetime] = write_leasetime,
|
2010-03-02 09:04:06 -07:00
|
|
|
[NFSD_Gracetime] = write_gracetime,
|
2005-06-23 23:04:32 -06:00
|
|
|
[NFSD_RecoveryDir] = write_recoverydir,
|
2014-09-12 14:40:21 -06:00
|
|
|
[NFSD_V4EndGrace] = write_v4_end_grace,
|
2005-11-07 02:00:25 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
|
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
ino_t ino = file_inode(file)->i_ino;
|
2005-04-16 16:20:36 -06:00
|
|
|
char *data;
|
|
|
|
ssize_t rv;
|
|
|
|
|
2006-03-24 04:15:34 -07:00
|
|
|
if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
data = simple_transaction_get(file, buf, size);
|
|
|
|
if (IS_ERR(data))
|
|
|
|
return PTR_ERR(data);
|
|
|
|
|
|
|
|
rv = write_op[ino](file, data, size);
|
2007-02-14 01:33:11 -07:00
|
|
|
if (rv >= 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
simple_transaction_set(file, rv);
|
|
|
|
rv = size;
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2005-11-07 02:00:24 -07:00
|
|
|
static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
|
|
|
|
{
|
|
|
|
if (! file->private_data) {
|
|
|
|
/* An attempt to read a transaction file without writing
|
|
|
|
* causes a 0-byte write so that the file can return
|
|
|
|
* state information
|
|
|
|
*/
|
|
|
|
ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
|
|
|
|
if (rv < 0)
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
return simple_transaction_read(file, buf, size, pos);
|
|
|
|
}
|
|
|
|
|
2006-03-28 02:56:42 -07:00
|
|
|
static const struct file_operations transaction_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.write = nfsctl_transaction_write,
|
2005-11-07 02:00:24 -07:00
|
|
|
.read = nfsctl_transaction_read,
|
2005-04-16 16:20:36 -06:00
|
|
|
.release = simple_transaction_release,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 10:52:59 -06:00
|
|
|
.llseek = default_llseek,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2013-02-01 05:56:17 -07:00
|
|
|
static int exports_net_open(struct net *net, struct file *file)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-03-28 09:09:29 -06:00
|
|
|
int err;
|
|
|
|
struct seq_file *seq;
|
2013-02-01 05:56:17 -07:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2012-03-28 09:09:29 -06:00
|
|
|
|
|
|
|
err = seq_open(file, &nfs_exports_op);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
seq = file->private_data;
|
2012-04-11 05:13:28 -06:00
|
|
|
seq->private = nn->svc_export_cache;
|
2012-03-28 09:09:29 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-02-01 05:56:17 -07:00
|
|
|
static int exports_proc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return exports_net_open(current->nsproxy->net_ns, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations exports_proc_operations = {
|
|
|
|
.open = exports_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int exports_nfsd_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return exports_net_open(inode->i_sb->s_fs_info, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations exports_nfsd_operations = {
|
|
|
|
.open = exports_nfsd_open,
|
2005-04-16 16:20:36 -06:00
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2009-12-14 10:53:32 -07:00
|
|
|
static int export_features_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int export_features_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, export_features_show, NULL);
|
|
|
|
}
|
|
|
|
|
2013-04-04 17:09:41 -06:00
|
|
|
static const struct file_operations export_features_operations = {
|
2009-12-14 10:53:32 -07:00
|
|
|
.open = export_features_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2011-05-31 10:24:58 -06:00
|
|
|
#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
|
2011-03-02 17:51:42 -07:00
|
|
|
static int supported_enctypes_show(struct seq_file *m, void *v)
|
|
|
|
{
|
2011-05-31 10:24:58 -06:00
|
|
|
seq_printf(m, KRB5_SUPPORTED_ENCTYPES);
|
2011-03-02 17:51:42 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int supported_enctypes_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, supported_enctypes_show, NULL);
|
|
|
|
}
|
|
|
|
|
2013-04-04 17:09:41 -06:00
|
|
|
static const struct file_operations supported_enctypes_ops = {
|
2011-03-02 17:51:42 -07:00
|
|
|
.open = supported_enctypes_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
2011-05-31 10:24:58 -06:00
|
|
|
#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
|
2011-03-02 17:51:42 -07:00
|
|
|
|
2009-10-01 16:43:56 -06:00
|
|
|
static const struct file_operations pool_stats_operations = {
|
2009-01-13 03:26:36 -07:00
|
|
|
.open = nfsd_pool_stats_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2009-08-15 09:54:41 -06:00
|
|
|
.release = nfsd_pool_stats_release,
|
2009-01-13 03:26:36 -07:00
|
|
|
};
|
|
|
|
|
2016-08-28 14:36:55 -06:00
|
|
|
static const struct file_operations reply_cache_stats_operations = {
|
2013-03-27 08:15:38 -06:00
|
|
|
.open = nfsd_reply_cache_stats_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
|
|
* payload - write methods
|
|
|
|
*/
|
|
|
|
|
2014-10-21 18:19:11 -06:00
|
|
|
static inline struct net *netns(struct file *file)
|
|
|
|
{
|
|
|
|
return file_inode(file)->i_sb->s_fs_info;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_unlock_ip - Release all locks used by a client
|
|
|
|
*
|
|
|
|
* Experimental.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: '\n'-terminated C string containing a
|
2009-08-09 13:09:40 -06:00
|
|
|
* presentation format IP address
|
2008-12-12 14:57:35 -07:00
|
|
|
* size: length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: returns zero if all specified locks were released;
|
|
|
|
* returns one if one or more locks were not released
|
|
|
|
* On error: return code is negative errno value
|
|
|
|
*/
|
2008-12-12 14:57:13 -07:00
|
|
|
static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
{
|
2009-08-09 13:09:40 -06:00
|
|
|
struct sockaddr_storage address;
|
|
|
|
struct sockaddr *sap = (struct sockaddr *)&address;
|
|
|
|
size_t salen = sizeof(address);
|
2008-06-30 16:58:14 -06:00
|
|
|
char *fo_path;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct net *net = netns(file);
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fo_path = buf;
|
|
|
|
if (qword_get(&buf, fo_path, size) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-02-01 05:56:12 -07:00
|
|
|
if (rpc_pton(net, fo_path, size, sap, salen) == 0)
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-08-09 13:09:40 -06:00
|
|
|
return nlmsvc_unlock_all_by_ip(sap);
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_unlock_fs - Release all locks on a local file system
|
|
|
|
*
|
|
|
|
* Experimental.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: '\n'-terminated C string containing the
|
|
|
|
* absolute pathname of a local file system
|
|
|
|
* size: length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: returns zero if all specified locks were released;
|
|
|
|
* returns one if one or more locks were not released
|
|
|
|
* On error: return code is negative errno value
|
|
|
|
*/
|
2008-12-12 14:57:13 -07:00
|
|
|
static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
|
2008-01-17 09:10:12 -07:00
|
|
|
{
|
2008-08-01 23:03:36 -06:00
|
|
|
struct path path;
|
2008-01-17 09:10:12 -07:00
|
|
|
char *fo_path;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fo_path = buf;
|
|
|
|
if (qword_get(&buf, fo_path, size) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-08-01 23:03:36 -06:00
|
|
|
error = kern_path(fo_path, 0, &path);
|
2008-01-17 09:10:12 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/*
|
|
|
|
* XXX: Needs better sanity checking. Otherwise we could end up
|
|
|
|
* releasing locks on the wrong file system.
|
|
|
|
*
|
|
|
|
* For example:
|
|
|
|
* 1. Does the path refer to a directory?
|
|
|
|
* 2. Is that directory a mount point, or
|
|
|
|
* 3. Is that directory the root of an exported file system?
|
|
|
|
*/
|
2011-12-07 16:16:57 -07:00
|
|
|
error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
|
2008-01-17 09:10:12 -07:00
|
|
|
|
2008-08-01 23:03:36 -06:00
|
|
|
path_put(&path);
|
2008-01-17 09:10:12 -07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_filehandle - Get a variable-length NFS file handle by path
|
|
|
|
*
|
|
|
|
* On input, the buffer contains a '\n'-terminated C string comprised of
|
|
|
|
* three alphanumeric words separated by whitespace. The string may
|
|
|
|
* contain escape sequences.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf:
|
|
|
|
* domain: client domain name
|
|
|
|
* path: export pathname
|
|
|
|
* maxsize: numeric maximum size of
|
|
|
|
* @buf
|
|
|
|
* size: length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string containing a ASCII hex text version
|
|
|
|
* of the NFS file handle;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is negative errno value
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *dname, *path;
|
2007-08-09 01:53:50 -06:00
|
|
|
int uninitialized_var(maxsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
char *mesg = buf;
|
|
|
|
int len;
|
|
|
|
struct auth_domain *dom;
|
|
|
|
struct knfsd_fh fh;
|
|
|
|
|
2008-01-22 15:40:42 -07:00
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
dname = mesg;
|
|
|
|
len = qword_get(&mesg, dname, size);
|
2008-12-12 14:57:20 -07:00
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
path = dname+len+1;
|
|
|
|
len = qword_get(&mesg, path, size);
|
2008-12-12 14:57:20 -07:00
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
len = get_int(&mesg, &maxsize);
|
|
|
|
if (len)
|
|
|
|
return len;
|
|
|
|
|
|
|
|
if (maxsize < NFS_FHSIZE)
|
|
|
|
return -EINVAL;
|
2014-06-10 04:08:19 -06:00
|
|
|
maxsize = min(maxsize, NFS3_FHSIZE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (qword_get(&mesg, mesg, size)>0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* we have all the words, they are in buf.. */
|
|
|
|
dom = unix_domain_find(dname);
|
|
|
|
if (!dom)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-10-21 18:19:11 -06:00
|
|
|
len = exp_rootfh(netns(file), dom, path, &fh, maxsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
auth_domain_put(dom);
|
|
|
|
if (len)
|
|
|
|
return len;
|
|
|
|
|
2008-12-12 14:57:20 -07:00
|
|
|
mesg = buf;
|
|
|
|
len = SIMPLE_TRANSACTION_LIMIT;
|
2005-04-16 16:20:36 -06:00
|
|
|
qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
|
|
|
|
mesg[-1] = '\n';
|
|
|
|
return mesg - buf;
|
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_threads - Start NFSD, or report the current number of running threads
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string numeric value representing the number of
|
|
|
|
* running NFSD threads;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing an unsigned
|
|
|
|
* integer value representing the
|
|
|
|
* number of NFSD threads to start
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: NFS service is started;
|
|
|
|
* passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string numeric value representing the number of
|
|
|
|
* running NFSD threads;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t write_threads(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
int rv;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct net *net = netns(file);
|
2012-12-10 02:19:25 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (size > 0) {
|
|
|
|
int newthreads;
|
|
|
|
rv = get_int(&mesg, &newthreads);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
2008-12-12 14:57:27 -07:00
|
|
|
if (newthreads < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2019-04-09 10:13:37 -06:00
|
|
|
rv = nfsd_svc(newthreads, net, file->f_cred);
|
nfsd: don't take nfsd_mutex twice when setting number of threads.
Currently when we write a number to 'threads' in nfsdfs,
we take the nfsd_mutex, update the number of threads, then take the
mutex again to read the number of threads.
Mostly this isn't a big deal. However if we are write '0', and
portmap happens to be dead, then we can get unpredictable behaviour.
If the nfsd threads all got killed quickly and the last thread is
waiting for portmap to respond, then the second time we take the mutex
we will block waiting for the last thread.
However if the nfsd threads didn't die quite that fast, then there
will be no contention when we try to take the mutex again.
Unpredictability isn't fun, and waiting for the last thread to exit is
pointless, so avoid taking the lock twice.
To achieve this, get nfsd_svc return a non-negative number of active
threads when not returning a negative error.
Signed-off-by: NeilBrown <neilb@suse.de>
2009-06-15 19:03:07 -06:00
|
|
|
if (rv < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return rv;
|
nfsd: don't take nfsd_mutex twice when setting number of threads.
Currently when we write a number to 'threads' in nfsdfs,
we take the nfsd_mutex, update the number of threads, then take the
mutex again to read the number of threads.
Mostly this isn't a big deal. However if we are write '0', and
portmap happens to be dead, then we can get unpredictable behaviour.
If the nfsd threads all got killed quickly and the last thread is
waiting for portmap to respond, then the second time we take the mutex
we will block waiting for the last thread.
However if the nfsd threads didn't die quite that fast, then there
will be no contention when we try to take the mutex again.
Unpredictability isn't fun, and waiting for the last thread to exit is
pointless, so avoid taking the lock twice.
To achieve this, get nfsd_svc return a non-negative number of active
threads when not returning a negative error.
Signed-off-by: NeilBrown <neilb@suse.de>
2009-06-15 19:03:07 -06:00
|
|
|
} else
|
2012-12-06 04:23:24 -07:00
|
|
|
rv = nfsd_nrthreads(net);
|
2009-04-23 17:33:25 -06:00
|
|
|
|
nfsd: don't take nfsd_mutex twice when setting number of threads.
Currently when we write a number to 'threads' in nfsdfs,
we take the nfsd_mutex, update the number of threads, then take the
mutex again to read the number of threads.
Mostly this isn't a big deal. However if we are write '0', and
portmap happens to be dead, then we can get unpredictable behaviour.
If the nfsd threads all got killed quickly and the last thread is
waiting for portmap to respond, then the second time we take the mutex
we will block waiting for the last thread.
However if the nfsd threads didn't die quite that fast, then there
will be no contention when we try to take the mutex again.
Unpredictability isn't fun, and waiting for the last thread to exit is
pointless, so avoid taking the lock twice.
To achieve this, get nfsd_svc return a non-negative number of active
threads when not returning a negative error.
Signed-off-by: NeilBrown <neilb@suse.de>
2009-06-15 19:03:07 -06:00
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_pool_threads - Set or report the current number of threads per pool
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing whitespace-
|
|
|
|
* separated unsigned integer values
|
|
|
|
* representing the number of NFSD
|
|
|
|
* threads to start in each pool
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string containing integer values representing the
|
|
|
|
* number of NFSD threads in each pool;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2006-10-02 03:18:02 -06:00
|
|
|
static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
/* if size > 0, look for an array of number of threads per node
|
|
|
|
* and apply them then write out number of threads per node as reply
|
|
|
|
*/
|
|
|
|
char *mesg = buf;
|
|
|
|
int i;
|
|
|
|
int rv;
|
|
|
|
int len;
|
2008-06-10 06:40:35 -06:00
|
|
|
int npools;
|
2006-10-02 03:18:02 -06:00
|
|
|
int *nthreads;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct net *net = netns(file);
|
2006-10-02 03:18:02 -06:00
|
|
|
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_lock(&nfsd_mutex);
|
2012-12-06 04:23:24 -07:00
|
|
|
npools = nfsd_nrpools(net);
|
2006-10-02 03:18:02 -06:00
|
|
|
if (npools == 0) {
|
|
|
|
/*
|
|
|
|
* NFS is shut down. The admin can start it by
|
|
|
|
* writing to the threads file but NOT the pool_threads
|
|
|
|
* file, sorry. Report zero threads.
|
|
|
|
*/
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-02 03:18:02 -06:00
|
|
|
strcpy(buf, "0\n");
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
|
2008-06-10 06:40:35 -06:00
|
|
|
rv = -ENOMEM;
|
2006-10-02 03:18:02 -06:00
|
|
|
if (nthreads == NULL)
|
2008-06-10 06:40:35 -06:00
|
|
|
goto out_free;
|
2006-10-02 03:18:02 -06:00
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
for (i = 0; i < npools; i++) {
|
|
|
|
rv = get_int(&mesg, &nthreads[i]);
|
|
|
|
if (rv == -ENOENT)
|
|
|
|
break; /* fewer numbers than pools */
|
|
|
|
if (rv)
|
|
|
|
goto out_free; /* syntax error */
|
|
|
|
rv = -EINVAL;
|
|
|
|
if (nthreads[i] < 0)
|
|
|
|
goto out_free;
|
|
|
|
}
|
2012-12-10 02:19:30 -07:00
|
|
|
rv = nfsd_set_nrthreads(i, nthreads, net);
|
2006-10-02 03:18:02 -06:00
|
|
|
if (rv)
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2012-12-06 04:23:24 -07:00
|
|
|
rv = nfsd_get_nrthreads(npools, nthreads, net);
|
2006-10-02 03:18:02 -06:00
|
|
|
if (rv)
|
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
mesg = buf;
|
|
|
|
size = SIMPLE_TRANSACTION_LIMIT;
|
|
|
|
for (i = 0; i < npools && size > 0; i++) {
|
|
|
|
snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
|
|
|
|
len = strlen(mesg);
|
|
|
|
size -= len;
|
|
|
|
mesg += len;
|
|
|
|
}
|
2009-07-28 09:37:25 -06:00
|
|
|
rv = mesg - buf;
|
2006-10-02 03:18:02 -06:00
|
|
|
out_free:
|
|
|
|
kfree(nthreads);
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-02 03:18:02 -06:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2017-02-22 16:35:33 -07:00
|
|
|
static ssize_t
|
2019-04-09 09:46:19 -06:00
|
|
|
nfsd_print_version_support(struct nfsd_net *nn, char *buf, int remaining,
|
|
|
|
const char *sep, unsigned vers, int minor)
|
2017-02-22 16:35:33 -07:00
|
|
|
{
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
const char *format = minor < 0 ? "%s%c%u" : "%s%c%u.%u";
|
2019-04-09 09:46:19 -06:00
|
|
|
bool supported = !!nfsd_vers(nn, vers, NFSD_TEST);
|
2017-02-22 16:35:33 -07:00
|
|
|
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
if (vers == 4 && minor >= 0 &&
|
2019-04-09 09:46:19 -06:00
|
|
|
!nfsd_minorversion(nn, minor, NFSD_TEST))
|
2017-02-22 16:35:33 -07:00
|
|
|
supported = false;
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
if (minor == 0 && supported)
|
|
|
|
/*
|
|
|
|
* special case for backward compatability.
|
|
|
|
* +4.0 is never reported, it is implied by
|
|
|
|
* +4, unless -4.0 is present.
|
|
|
|
*/
|
|
|
|
return 0;
|
2017-02-22 16:35:33 -07:00
|
|
|
return snprintf(buf, remaining, format, sep,
|
|
|
|
supported ? '+' : '-', vers, minor);
|
|
|
|
}
|
|
|
|
|
2008-06-10 06:40:36 -06:00
|
|
|
static ssize_t __write_versions(struct file *file, char *buf, size_t size)
|
2005-11-07 02:00:25 -07:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2009-04-02 23:28:59 -06:00
|
|
|
char *vers, *minorp, sign;
|
2009-04-23 17:33:18 -06:00
|
|
|
int len, num, remaining;
|
2005-11-07 02:00:25 -07:00
|
|
|
ssize_t tlen = 0;
|
|
|
|
char *sep;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2005-11-07 02:00:25 -07:00
|
|
|
|
|
|
|
if (size>0) {
|
2012-12-06 04:23:24 -07:00
|
|
|
if (nn->nfsd_serv)
|
2006-10-02 03:17:46 -06:00
|
|
|
/* Cannot change versions without updating
|
2012-12-06 04:23:24 -07:00
|
|
|
* nn->nfsd_serv->sv_xdrsize, and reallocing
|
2006-10-02 03:17:46 -06:00
|
|
|
* rq_argp and rq_resp
|
|
|
|
*/
|
2005-11-07 02:00:25 -07:00
|
|
|
return -EBUSY;
|
|
|
|
if (buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
vers = mesg;
|
|
|
|
len = qword_get(&mesg, vers, size);
|
|
|
|
if (len <= 0) return -EINVAL;
|
|
|
|
do {
|
2017-02-22 16:35:32 -07:00
|
|
|
enum vers_op cmd;
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
unsigned minor;
|
2005-11-07 02:00:25 -07:00
|
|
|
sign = *vers;
|
|
|
|
if (sign == '+' || sign == '-')
|
2009-04-02 23:28:59 -06:00
|
|
|
num = simple_strtol((vers+1), &minorp, 0);
|
2005-11-07 02:00:25 -07:00
|
|
|
else
|
2009-04-02 23:28:59 -06:00
|
|
|
num = simple_strtol(vers, &minorp, 0);
|
|
|
|
if (*minorp == '.') {
|
2013-01-23 16:25:01 -07:00
|
|
|
if (num != 4)
|
2009-04-02 23:28:59 -06:00
|
|
|
return -EINVAL;
|
2016-12-20 20:32:19 -07:00
|
|
|
if (kstrtouint(minorp+1, 0, &minor) < 0)
|
2009-04-02 23:28:59 -06:00
|
|
|
return -EINVAL;
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
}
|
|
|
|
|
2017-02-22 16:35:32 -07:00
|
|
|
cmd = sign == '-' ? NFSD_CLEAR : NFSD_SET;
|
2005-11-07 02:00:25 -07:00
|
|
|
switch(num) {
|
|
|
|
case 2:
|
|
|
|
case 3:
|
2019-04-09 09:46:19 -06:00
|
|
|
nfsd_vers(nn, num, cmd);
|
2005-11-07 02:00:25 -07:00
|
|
|
break;
|
2017-02-22 16:35:32 -07:00
|
|
|
case 4:
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
if (*minorp == '.') {
|
2019-04-09 09:46:19 -06:00
|
|
|
if (nfsd_minorversion(nn, minor, cmd) < 0)
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
return -EINVAL;
|
2019-04-09 09:46:19 -06:00
|
|
|
} else if ((cmd == NFSD_SET) != nfsd_vers(nn, num, NFSD_TEST)) {
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
/*
|
|
|
|
* Either we have +4 and no minors are enabled,
|
|
|
|
* or we have -4 and at least one minor is enabled.
|
|
|
|
* In either case, propagate 'cmd' to all minors.
|
|
|
|
*/
|
|
|
|
minor = 0;
|
2019-04-09 09:46:19 -06:00
|
|
|
while (nfsd_minorversion(nn, minor, cmd) >= 0)
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
minor++;
|
|
|
|
}
|
|
|
|
break;
|
2005-11-07 02:00:25 -07:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
vers += len + 1;
|
|
|
|
} while ((len = qword_get(&mesg, vers, size)) > 0);
|
|
|
|
/* If all get turned off, turn them back on, as
|
|
|
|
* having no versions is BAD
|
|
|
|
*/
|
2019-04-09 09:46:19 -06:00
|
|
|
nfsd_reset_versions(nn);
|
2005-11-07 02:00:25 -07:00
|
|
|
}
|
2009-04-23 17:33:18 -06:00
|
|
|
|
2005-11-07 02:00:25 -07:00
|
|
|
/* Now write current state into reply buffer */
|
|
|
|
len = 0;
|
|
|
|
sep = "";
|
2009-04-23 17:33:18 -06:00
|
|
|
remaining = SIMPLE_TRANSACTION_LIMIT;
|
2017-02-22 16:35:33 -07:00
|
|
|
for (num=2 ; num <= 4 ; num++) {
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
int minor;
|
2019-04-09 09:46:19 -06:00
|
|
|
if (!nfsd_vers(nn, num, NFSD_AVAIL))
|
2017-02-22 16:35:33 -07:00
|
|
|
continue;
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
|
|
|
|
minor = -1;
|
2017-02-22 16:35:33 -07:00
|
|
|
do {
|
2019-04-09 09:46:19 -06:00
|
|
|
len = nfsd_print_version_support(nn, buf, remaining,
|
2017-02-22 16:35:33 -07:00
|
|
|
sep, num, minor);
|
2014-11-27 08:58:54 -07:00
|
|
|
if (len >= remaining)
|
2017-02-22 16:35:33 -07:00
|
|
|
goto out;
|
2009-04-23 17:33:18 -06:00
|
|
|
remaining -= len;
|
|
|
|
buf += len;
|
|
|
|
tlen += len;
|
2017-02-22 16:35:33 -07:00
|
|
|
minor++;
|
NFSD: further refinement of content of /proc/fs/nfsd/versions
Prior to
e35659f1b03c ("NFSD: correctly range-check v4.x minor version when setting versions.")
v4.0 could not be disabled without disabling all NFSv4 protocols.
So the 'versions' file contained ±4 ±4.1 ±4.2.
Writing "-4" would disable all v4 completely. Writing +4 would enabled those
minor versions that are currently enabled, either by default or otherwise.
After that commit, it was possible to disable v4.0 independently. To
maximize backward compatibility with use cases which never disabled
v4.0, the "versions" file would never contain "+4.0" - that was implied
by "+4", unless explicitly negated by "-4.0".
This introduced an inconsistency in that it was possible to disable all
minor versions, but still have the major version advertised.
e.g. "-4.0 -4.1 -4.2 +4" would result in NFSv4 support being advertised,
but all attempts to use it rejected.
Commit
d3635ff07e8c ("nfsd: fix configuration of supported minor versions")
and following removed this inconsistency. If all minor version were disabled,
the major would be disabled too. If any minor was enabled, the major would be
disabled.
This patch also treated "+4" as equivalent to "+4.0" and "-4" as "-4.0".
A consequence of this is that writing "-4" would only disable 4.0.
This is a regression against the earlier behaviour, in a use case that rpc.nfsd
actually uses.
The command "rpc.nfsd -N 4" will write "+2 +3 -4" to the versions files.
Previously, that would disable v4 completely. Now it will only disable v4.0.
Also "4.0" never appears in the "versions" file when read.
So if only v4.1 is available, the previous kernel would have reported
"+4 -4.0 +4.1 -4.2" the current kernel reports "-4 +4.1 -4.2" which
could easily confuse.
This patch restores the implication that "+4" and "-4" apply more
globals and do not imply "4.0".
Specifically:
writing "-4" will disable all 4.x minor versions.
writing "+4" will enable all 4.1 minor version if none are currently enabled.
rpc.nfsd will list minor versions before major versions, so
rpc.nfsd -V 4.2 -N 4.1
will write "-4.1 +4.2 +2 +3 +4"
so it would be a regression for "+4" to enable always all versions.
reading "-4" implies that no v4.x are enabled
reading "+4" implies that some v4.x are enabled, and that v4.0 is enabled unless
"-4.0" is also present. All other minor versions will explicitly be listed.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-03-09 17:36:39 -07:00
|
|
|
if (len)
|
|
|
|
sep = " ";
|
2017-02-22 16:35:33 -07:00
|
|
|
} while (num == 4 && minor <= NFSD_SUPPORTED_MINOR_VERSION);
|
|
|
|
}
|
|
|
|
out:
|
2009-04-23 17:33:18 -06:00
|
|
|
len = snprintf(buf, remaining, "\n");
|
2014-11-27 08:58:54 -07:00
|
|
|
if (len >= remaining)
|
2009-04-23 17:33:18 -06:00
|
|
|
return -EINVAL;
|
|
|
|
return tlen + len;
|
2005-11-07 02:00:25 -07:00
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_versions - Set or report the available NFS protocol versions
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string containing positive or negative integer
|
|
|
|
* values representing the current status of each
|
|
|
|
* protocol version;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing whitespace-
|
|
|
|
* separated positive or negative
|
|
|
|
* integer values representing NFS
|
|
|
|
* protocol versions to enable ("+n")
|
|
|
|
* or disable ("-n")
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: status of zero or more protocol versions has
|
|
|
|
* been updated; passed-in buffer filled with
|
|
|
|
* '\n'-terminated C string containing positive
|
|
|
|
* or negative integer values representing the
|
|
|
|
* current status of each protocol version;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2008-06-10 06:40:36 -06:00
|
|
|
static ssize_t write_versions(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
|
|
|
|
|
|
|
mutex_lock(&nfsd_mutex);
|
|
|
|
rv = __write_versions(file, buf, size);
|
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2009-04-23 17:32:10 -06:00
|
|
|
/*
|
|
|
|
* Zero-length write. Return a list of NFSD's current listener
|
|
|
|
* transports.
|
|
|
|
*/
|
2012-12-06 04:23:24 -07:00
|
|
|
static ssize_t __write_ports_names(char *buf, struct net *net)
|
2009-04-23 17:32:10 -06:00
|
|
|
{
|
2012-12-06 04:23:24 -07:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
|
|
|
|
|
|
|
if (nn->nfsd_serv == NULL)
|
2009-04-23 17:32:10 -06:00
|
|
|
return 0;
|
2012-12-06 04:23:24 -07:00
|
|
|
return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
|
2009-04-23 17:32:10 -06:00
|
|
|
}
|
|
|
|
|
2009-04-23 17:31:55 -06:00
|
|
|
/*
|
|
|
|
* A single 'fd' number was written, in which case it must be for
|
|
|
|
* a socket of a supported family/protocol, and we use it as an
|
|
|
|
* nfsd listener.
|
|
|
|
*/
|
2019-04-09 10:13:37 -06:00
|
|
|
static ssize_t __write_ports_addfd(char *buf, struct net *net, const struct cred *cred)
|
2009-04-23 17:31:55 -06:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
int fd, err;
|
2012-12-06 04:23:24 -07:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2009-04-23 17:31:55 -06:00
|
|
|
|
|
|
|
err = get_int(&mesg, &fd);
|
|
|
|
if (err != 0 || fd < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-26 06:50:01 -07:00
|
|
|
if (svc_alien_sock(net, fd)) {
|
|
|
|
printk(KERN_ERR "%s: socket net is different to NFSd's one\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-12-10 02:19:20 -07:00
|
|
|
err = nfsd_create_serv(net);
|
2009-04-23 17:31:55 -06:00
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2019-04-09 10:13:37 -06:00
|
|
|
err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT, cred);
|
2010-07-19 14:50:05 -06:00
|
|
|
if (err < 0) {
|
2012-07-03 06:46:41 -06:00
|
|
|
nfsd_destroy(net);
|
2010-07-19 14:50:05 -06:00
|
|
|
return err;
|
|
|
|
}
|
2009-04-23 17:31:55 -06:00
|
|
|
|
2009-04-23 17:32:18 -06:00
|
|
|
/* Decrease the count, but don't shut down the service */
|
2012-12-06 04:23:24 -07:00
|
|
|
nn->nfsd_serv->sv_nrthreads--;
|
2009-04-23 17:32:18 -06:00
|
|
|
return err;
|
2009-04-23 17:31:55 -06:00
|
|
|
}
|
|
|
|
|
2009-04-23 17:31:40 -06:00
|
|
|
/*
|
|
|
|
* A transport listener is added by writing it's transport name and
|
|
|
|
* a port number.
|
|
|
|
*/
|
2019-04-09 10:13:37 -06:00
|
|
|
static ssize_t __write_ports_addxprt(char *buf, struct net *net, const struct cred *cred)
|
2009-04-23 17:31:40 -06:00
|
|
|
{
|
|
|
|
char transport[16];
|
2010-01-26 12:04:22 -07:00
|
|
|
struct svc_xprt *xprt;
|
2009-04-23 17:31:40 -06:00
|
|
|
int port, err;
|
2012-12-06 04:23:24 -07:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2009-04-23 17:31:40 -06:00
|
|
|
|
2012-08-14 15:48:39 -06:00
|
|
|
if (sscanf(buf, "%15s %5u", transport, &port) != 2)
|
2009-04-23 17:31:40 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-24 15:33:03 -06:00
|
|
|
if (port < 1 || port > USHRT_MAX)
|
2009-04-23 17:31:40 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-10 02:19:20 -07:00
|
|
|
err = nfsd_create_serv(net);
|
2009-04-23 17:31:40 -06:00
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2012-12-06 04:23:24 -07:00
|
|
|
err = svc_create_xprt(nn->nfsd_serv, transport, net,
|
2019-04-09 10:13:37 -06:00
|
|
|
PF_INET, port, SVC_SOCK_ANONYMOUS, cred);
|
2010-01-26 12:04:13 -07:00
|
|
|
if (err < 0)
|
2010-01-26 12:04:22 -07:00
|
|
|
goto out_err;
|
|
|
|
|
2012-12-06 04:23:24 -07:00
|
|
|
err = svc_create_xprt(nn->nfsd_serv, transport, net,
|
2019-04-09 10:13:37 -06:00
|
|
|
PF_INET6, port, SVC_SOCK_ANONYMOUS, cred);
|
2010-01-26 12:04:22 -07:00
|
|
|
if (err < 0 && err != -EAFNOSUPPORT)
|
|
|
|
goto out_close;
|
2010-07-19 14:50:06 -06:00
|
|
|
|
|
|
|
/* Decrease the count, but don't shut down the service */
|
2012-12-06 04:23:24 -07:00
|
|
|
nn->nfsd_serv->sv_nrthreads--;
|
2009-04-23 17:31:40 -06:00
|
|
|
return 0;
|
2010-01-26 12:04:22 -07:00
|
|
|
out_close:
|
2012-12-06 04:23:24 -07:00
|
|
|
xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port);
|
2010-01-26 12:04:22 -07:00
|
|
|
if (xprt != NULL) {
|
|
|
|
svc_close_xprt(xprt);
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
out_err:
|
2012-07-03 06:46:41 -06:00
|
|
|
nfsd_destroy(net);
|
2010-01-26 12:04:22 -07:00
|
|
|
return err;
|
2009-04-23 17:31:40 -06:00
|
|
|
}
|
|
|
|
|
2012-12-10 02:19:35 -07:00
|
|
|
static ssize_t __write_ports(struct file *file, char *buf, size_t size,
|
|
|
|
struct net *net)
|
2006-10-02 03:17:47 -06:00
|
|
|
{
|
2009-04-23 17:32:10 -06:00
|
|
|
if (size == 0)
|
2012-12-06 04:23:24 -07:00
|
|
|
return __write_ports_names(buf, net);
|
2009-04-23 17:31:55 -06:00
|
|
|
|
|
|
|
if (isdigit(buf[0]))
|
2019-04-09 10:13:37 -06:00
|
|
|
return __write_ports_addfd(buf, net, file->f_cred);
|
2009-04-23 17:31:48 -06:00
|
|
|
|
2009-04-23 17:31:40 -06:00
|
|
|
if (isalpha(buf[0]))
|
2019-04-09 10:13:37 -06:00
|
|
|
return __write_ports_addxprt(buf, net, file->f_cred);
|
2009-04-23 17:31:32 -06:00
|
|
|
|
2006-10-02 03:17:48 -06:00
|
|
|
return -EINVAL;
|
2006-10-02 03:17:47 -06:00
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_ports - Pass a socket file descriptor or transport name to listen on
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with a '\n'-terminated C
|
|
|
|
* string containing a whitespace-separated list of
|
|
|
|
* named NFSD listeners;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing an unsigned
|
|
|
|
* integer value representing a bound
|
|
|
|
* but unconnected socket that is to be
|
2009-04-23 17:32:03 -06:00
|
|
|
* used as an NFSD listener; listen(3)
|
|
|
|
* must be called for a SOCK_STREAM
|
|
|
|
* socket, otherwise it is ignored
|
2008-12-12 14:57:35 -07:00
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: NFS service is started;
|
|
|
|
* passed-in buffer filled with a '\n'-terminated C
|
|
|
|
* string containing a unique alphanumeric name of
|
|
|
|
* the listener;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is a negative errno value
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing a transport
|
|
|
|
* name and an unsigned integer value
|
|
|
|
* representing the port to listen on,
|
|
|
|
* separated by whitespace
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: returns zero; NFS service is started
|
|
|
|
* On error: return code is a negative errno value
|
|
|
|
*/
|
2008-06-10 06:40:35 -06:00
|
|
|
static ssize_t write_ports(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
2008-06-10 06:40:36 -06:00
|
|
|
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_lock(&nfsd_mutex);
|
2014-10-21 18:19:11 -06:00
|
|
|
rv = __write_ports(file, buf, size, netns(file));
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-04 03:15:48 -06:00
|
|
|
int nfsd_max_blksize;
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_maxblksize - Set or report the current NFS blksize
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing an unsigned
|
|
|
|
* integer value representing the new
|
|
|
|
* NFS blksize
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C string
|
|
|
|
* containing numeric value of the current NFS blksize
|
|
|
|
* setting;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2006-10-04 03:15:48 -06:00
|
|
|
static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2012-12-06 04:23:24 -07:00
|
|
|
|
2006-10-04 03:15:48 -06:00
|
|
|
if (size > 0) {
|
|
|
|
int bsize;
|
|
|
|
int rv = get_int(&mesg, &bsize);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
|
|
|
/* force bsize into allowed range and
|
|
|
|
* required alignment.
|
|
|
|
*/
|
2014-06-10 04:08:19 -06:00
|
|
|
bsize = max_t(int, bsize, 1024);
|
|
|
|
bsize = min_t(int, bsize, NFSSVC_MAXBLKSIZE);
|
2006-10-04 03:15:48 -06:00
|
|
|
bsize &= ~(1024-1);
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_lock(&nfsd_mutex);
|
2012-12-06 04:23:24 -07:00
|
|
|
if (nn->nfsd_serv) {
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-04 03:15:48 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
nfsd_max_blksize = bsize;
|
2008-06-10 06:40:35 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-04 03:15:48 -06:00
|
|
|
}
|
2009-04-23 17:33:25 -06:00
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
|
|
|
|
nfsd_max_blksize);
|
2006-10-04 03:15:48 -06:00
|
|
|
}
|
|
|
|
|
2014-07-02 14:11:22 -06:00
|
|
|
/**
|
|
|
|
* write_maxconn - Set or report the current max number of connections
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing an unsigned
|
|
|
|
* integer value representing the new
|
|
|
|
* number of max connections
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C string
|
|
|
|
* containing numeric value of max_connections setting
|
|
|
|
* for this net namespace;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
|
|
|
static ssize_t write_maxconn(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2014-07-02 14:11:22 -06:00
|
|
|
unsigned int maxconn = nn->max_connections;
|
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
int rv = get_uint(&mesg, &maxconn);
|
|
|
|
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
|
|
|
nn->max_connections = maxconn;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%u\n", maxconn);
|
|
|
|
}
|
|
|
|
|
2005-11-07 02:00:25 -07:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2012-12-06 04:23:24 -07:00
|
|
|
static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size,
|
|
|
|
time_t *time, struct nfsd_net *nn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2010-03-01 17:32:36 -07:00
|
|
|
int rv, i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (size > 0) {
|
2012-12-06 04:23:24 -07:00
|
|
|
if (nn->nfsd_serv)
|
2008-06-10 06:40:36 -06:00
|
|
|
return -EBUSY;
|
2010-03-01 17:32:36 -07:00
|
|
|
rv = get_int(&mesg, &i);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rv)
|
|
|
|
return rv;
|
2010-03-02 09:18:40 -07:00
|
|
|
/*
|
|
|
|
* Some sanity checking. We don't have a reason for
|
|
|
|
* these particular numbers, but problems with the
|
|
|
|
* extremes are:
|
|
|
|
* - Too short: the briefest network outage may
|
|
|
|
* cause clients to lose all their locks. Also,
|
|
|
|
* the frequent polling may be wasteful.
|
|
|
|
* - Too long: do you really want reboot recovery
|
|
|
|
* to take more than an hour? Or to make other
|
|
|
|
* clients wait an hour before being able to
|
|
|
|
* revoke a dead client's locks?
|
|
|
|
*/
|
2010-03-01 17:32:36 -07:00
|
|
|
if (i < 10 || i > 3600)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2010-03-01 17:32:36 -07:00
|
|
|
*time = i;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-04-23 17:33:25 -06:00
|
|
|
|
2010-03-01 17:32:36 -07:00
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
|
|
|
|
}
|
|
|
|
|
2012-12-06 04:23:24 -07:00
|
|
|
static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
|
|
|
|
time_t *time, struct nfsd_net *nn)
|
2010-03-01 17:32:36 -07:00
|
|
|
{
|
|
|
|
ssize_t rv;
|
|
|
|
|
|
|
|
mutex_lock(&nfsd_mutex);
|
2012-12-06 04:23:24 -07:00
|
|
|
rv = __nfsd4_write_time(file, buf, size, time, nn);
|
2010-03-01 17:32:36 -07:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_leasetime - Set or report the current NFSv4 lease time
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing an unsigned
|
|
|
|
* integer value representing the new
|
|
|
|
* NFSv4 lease expiry time
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C
|
|
|
|
* string containing unsigned integer value of the
|
|
|
|
* current lease expiry time;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2008-06-10 06:40:36 -06:00
|
|
|
static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2012-12-06 04:23:24 -07:00
|
|
|
return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn);
|
2008-06-10 06:40:36 -06:00
|
|
|
}
|
|
|
|
|
2010-03-02 09:04:06 -07:00
|
|
|
/**
|
|
|
|
* write_gracetime - Set or report current NFSv4 grace period time
|
|
|
|
*
|
|
|
|
* As above, but sets the time of the NFSv4 grace period.
|
|
|
|
*
|
|
|
|
* Note this should never be set to less than the *previous*
|
|
|
|
* lease-period time, but we don't try to enforce this. (In the common
|
|
|
|
* case (a new boot), we don't know what the previous lease time was
|
|
|
|
* anyway.)
|
|
|
|
*/
|
|
|
|
static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2012-12-06 04:23:24 -07:00
|
|
|
return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn);
|
2010-03-02 09:04:06 -07:00
|
|
|
}
|
|
|
|
|
2012-12-06 04:23:24 -07:00
|
|
|
static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
|
|
|
|
struct nfsd_net *nn)
|
2005-06-23 23:04:32 -06:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
char *recdir;
|
|
|
|
int len, status;
|
|
|
|
|
2008-06-10 06:40:36 -06:00
|
|
|
if (size > 0) {
|
2012-12-06 04:23:24 -07:00
|
|
|
if (nn->nfsd_serv)
|
2008-06-10 06:40:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
if (size > PATH_MAX || buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
buf[size-1] = 0;
|
2005-06-23 23:04:32 -06:00
|
|
|
|
2008-06-10 06:40:36 -06:00
|
|
|
recdir = mesg;
|
|
|
|
len = qword_get(&mesg, recdir, size);
|
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-06-23 23:04:32 -06:00
|
|
|
|
2008-06-10 06:40:36 -06:00
|
|
|
status = nfs4_reset_recoverydir(recdir);
|
2010-07-20 16:24:27 -06:00
|
|
|
if (status)
|
|
|
|
return status;
|
2008-06-10 06:40:36 -06:00
|
|
|
}
|
2009-04-23 17:33:10 -06:00
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
|
|
|
|
nfs4_recoverydir());
|
2005-06-23 23:04:32 -06:00
|
|
|
}
|
2008-06-10 06:40:36 -06:00
|
|
|
|
2008-12-12 14:57:35 -07:00
|
|
|
/**
|
|
|
|
* write_recoverydir - Set or report the pathname of the recovery directory
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing the pathname
|
|
|
|
* of the directory on a local file
|
|
|
|
* system containing permanent NFSv4
|
|
|
|
* recovery data
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: passed-in buffer filled with '\n'-terminated C string
|
|
|
|
* containing the current recovery pathname setting;
|
|
|
|
* return code is the size in bytes of the string
|
|
|
|
* On error: return code is zero or a negative errno value
|
|
|
|
*/
|
2008-06-10 06:40:36 -06:00
|
|
|
static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2008-06-10 06:40:36 -06:00
|
|
|
|
|
|
|
mutex_lock(&nfsd_mutex);
|
2012-12-06 04:23:24 -07:00
|
|
|
rv = __write_recoverydir(file, buf, size, nn);
|
2008-06-10 06:40:36 -06:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-09-12 14:40:21 -06:00
|
|
|
/**
|
|
|
|
* write_v4_end_grace - release grace period for nfsd's v4.x lock manager
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: ignored
|
|
|
|
* size: zero
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: any value
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* passed-in buffer filled with "Y" or "N" with a newline
|
|
|
|
* and NULL-terminated C string. This indicates whether
|
|
|
|
* the grace period has ended in the current net
|
|
|
|
* namespace. Return code is the size in bytes of the
|
|
|
|
* string. Writing a string that starts with 'Y', 'y', or
|
|
|
|
* '1' to the file will end the grace period for nfsd's v4
|
|
|
|
* lock manager.
|
|
|
|
*/
|
|
|
|
static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
2014-10-21 18:19:11 -06:00
|
|
|
struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
|
2014-09-12 14:40:21 -06:00
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
switch(buf[0]) {
|
|
|
|
case 'Y':
|
|
|
|
case 'y':
|
|
|
|
case '1':
|
2019-03-06 06:03:50 -07:00
|
|
|
if (!nn->nfsd_serv)
|
2018-11-27 13:54:17 -07:00
|
|
|
return -EBUSY;
|
2014-09-12 14:40:21 -06:00
|
|
|
nfsd4_end_grace(nn);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%c\n",
|
|
|
|
nn->grace_ended ? 'Y' : 'N');
|
|
|
|
}
|
|
|
|
|
2005-11-07 02:00:25 -07:00
|
|
|
#endif
|
2005-06-23 23:04:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
|
|
* populating the filesystem.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
|
|
|
|
{
|
2017-03-25 22:15:37 -06:00
|
|
|
static const struct tree_descr nfsd_files[] = {
|
2013-02-01 05:56:17 -07:00
|
|
|
[NFSD_List] = {"exports", &exports_nfsd_operations, S_IRUGO},
|
2009-12-14 10:53:32 -07:00
|
|
|
[NFSD_Export_features] = {"export_features",
|
|
|
|
&export_features_operations, S_IRUGO},
|
lockd: unlock lockd locks associated with a given server ip
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server. Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).
This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:
shell> echo 10.1.1.2 > /proc/fs/nfsd/unlock_ip
The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.
For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).
Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.
Signed-off-by: S. Wendy Cheng <wcheng@redhat.com>
Cc: Lon Hohberger <lhh@redhat.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
fs/lockd/svcsubs.c | 66 +++++++++++++++++++++++++++++++++++++++-----
fs/nfsd/nfsctl.c | 65 +++++++++++++++++++++++++++++++++++++++++++
include/linux/lockd/lockd.h | 7 ++++
3 files changed, 131 insertions(+), 7 deletions(-)
2008-01-17 09:10:12 -07:00
|
|
|
[NFSD_FO_UnlockIP] = {"unlock_ip",
|
|
|
|
&transaction_ops, S_IWUSR|S_IRUSR},
|
2008-01-17 09:10:12 -07:00
|
|
|
[NFSD_FO_UnlockFS] = {"unlock_filesystem",
|
|
|
|
&transaction_ops, S_IWUSR|S_IRUSR},
|
2005-04-16 16:20:36 -06:00
|
|
|
[NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
|
|
|
|
[NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
|
2006-10-02 03:18:02 -06:00
|
|
|
[NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
|
2009-01-13 03:26:36 -07:00
|
|
|
[NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
|
2013-03-27 08:15:38 -06:00
|
|
|
[NFSD_Reply_Cache_Stats] = {"reply_cache_stats", &reply_cache_stats_operations, S_IRUGO},
|
2005-11-07 02:00:25 -07:00
|
|
|
[NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
|
2006-10-02 03:17:47 -06:00
|
|
|
[NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
|
2006-10-04 03:15:48 -06:00
|
|
|
[NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
|
2014-07-02 14:11:22 -06:00
|
|
|
[NFSD_MaxConnections] = {"max_connections", &transaction_ops, S_IWUSR|S_IRUGO},
|
2011-05-31 10:24:58 -06:00
|
|
|
#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
|
2011-03-02 17:51:42 -07:00
|
|
|
[NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO},
|
2011-05-31 10:24:58 -06:00
|
|
|
#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
|
|
|
[NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
|
2010-03-02 09:04:06 -07:00
|
|
|
[NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR},
|
2005-06-23 23:04:32 -06:00
|
|
|
[NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
|
2014-09-12 14:40:21 -06:00
|
|
|
[NFSD_V4EndGrace] = {"v4_end_grace", &transaction_ops, S_IWUSR|S_IRUGO},
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
/* last one */ {""}
|
|
|
|
};
|
2016-05-23 13:51:59 -06:00
|
|
|
get_net(sb->s_fs_info);
|
|
|
|
return simple_fill_super(sb, 0x6e667364, nfsd_files);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-07-24 15:48:30 -06:00
|
|
|
static struct dentry *nfsd_mount(struct file_system_type *fs_type,
|
|
|
|
int flags, const char *dev_name, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-05-23 13:51:59 -06:00
|
|
|
struct net *net = current->nsproxy->net_ns;
|
|
|
|
return mount_ns(fs_type, flags, data, net, net->user_ns, nfsd_fill_super);
|
2013-02-01 05:56:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd_umount(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct net *net = sb->s_fs_info;
|
|
|
|
|
|
|
|
kill_litter_super(sb);
|
|
|
|
put_net(net);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type nfsd_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "nfsd",
|
2010-07-24 15:48:30 -06:00
|
|
|
.mount = nfsd_mount,
|
2013-02-01 05:56:12 -07:00
|
|
|
.kill_sb = nfsd_umount,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2013-03-02 20:39:14 -07:00
|
|
|
MODULE_ALIAS_FS("nfsd");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-12 15:32:21 -07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
static int create_proc_exports_entry(void)
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *entry;
|
|
|
|
|
|
|
|
entry = proc_mkdir("fs/nfs", NULL);
|
|
|
|
if (!entry)
|
|
|
|
return -ENOMEM;
|
2013-02-01 05:56:17 -07:00
|
|
|
entry = proc_create("exports", 0, entry,
|
|
|
|
&exports_proc_operations);
|
2013-03-27 02:31:18 -06:00
|
|
|
if (!entry) {
|
|
|
|
remove_proc_entry("fs/nfs", NULL);
|
2007-11-12 15:32:21 -07:00
|
|
|
return -ENOMEM;
|
2013-03-27 02:31:18 -06:00
|
|
|
}
|
2007-11-12 15:32:21 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else /* CONFIG_PROC_FS */
|
|
|
|
static int create_proc_exports_entry(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
netns: make struct pernet_operations::id unsigned int
Make struct pernet_operations::id unsigned.
There are 2 reasons to do so:
1)
This field is really an index into an zero based array and
thus is unsigned entity. Using negative value is out-of-bound
access by definition.
2)
On x86_64 unsigned 32-bit data which are mixed with pointers
via array indexing or offsets added or subtracted to pointers
are preffered to signed 32-bit data.
"int" being used as an array index needs to be sign-extended
to 64-bit before being used.
void f(long *p, int i)
{
g(p[i]);
}
roughly translates to
movsx rsi, esi
mov rdi, [rsi+...]
call g
MOVSX is 3 byte instruction which isn't necessary if the variable is
unsigned because x86_64 is zero extending by default.
Now, there is net_generic() function which, you guessed it right, uses
"int" as an array index:
static inline void *net_generic(const struct net *net, int id)
{
...
ptr = ng->ptr[id - 1];
...
}
And this function is used a lot, so those sign extensions add up.
Patch snipes ~1730 bytes on allyesconfig kernel (without all junk
messing with code generation):
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
Unfortunately some functions actually grow bigger.
This is a semmingly random artefact of code generation with register
allocator being used differently. gcc decides that some variable
needs to live in new r8+ registers and every access now requires REX
prefix. Or it is shifted into r12, so [r12+0] addressing mode has to be
used which is longer than [r8]
However, overall balance is in negative direction:
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
function old new delta
nfsd4_lock 3886 3959 +73
tipc_link_build_proto_msg 1096 1140 +44
mac80211_hwsim_new_radio 2776 2808 +32
tipc_mon_rcv 1032 1058 +26
svcauth_gss_legacy_init 1413 1429 +16
tipc_bcbase_select_primary 379 392 +13
nfsd4_exchange_id 1247 1260 +13
nfsd4_setclientid_confirm 782 793 +11
...
put_client_renew_locked 494 480 -14
ip_set_sockfn_get 730 716 -14
geneve_sock_add 829 813 -16
nfsd4_sequence_done 721 703 -18
nlmclnt_lookup_host 708 686 -22
nfsd4_lockt 1085 1063 -22
nfs_get_client 1077 1050 -27
tcf_bpf_init 1106 1076 -30
nfsd4_encode_fattr 5997 5930 -67
Total: Before=154856051, After=154854321, chg -0.00%
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-11-16 18:58:21 -07:00
|
|
|
unsigned int nfsd_net_id;
|
2012-04-11 05:13:35 -06:00
|
|
|
|
|
|
|
static __net_init int nfsd_init_net(struct net *net)
|
|
|
|
{
|
|
|
|
int retval;
|
2012-11-27 04:11:44 -07:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2012-04-11 05:13:35 -06:00
|
|
|
|
|
|
|
retval = nfsd_export_init(net);
|
|
|
|
if (retval)
|
|
|
|
goto out_export_error;
|
2012-04-11 07:33:05 -06:00
|
|
|
retval = nfsd_idmap_init(net);
|
|
|
|
if (retval)
|
|
|
|
goto out_idmap_error;
|
2019-04-09 09:46:19 -06:00
|
|
|
nn->nfsd_versions = NULL;
|
|
|
|
nn->nfsd4_minorversions = NULL;
|
2019-02-14 10:33:19 -07:00
|
|
|
nn->nfsd4_lease = 90; /* default lease time */
|
|
|
|
nn->nfsd4_grace = 90;
|
2018-06-08 10:28:47 -06:00
|
|
|
nn->somebody_reclaimed = false;
|
2019-03-26 16:06:28 -06:00
|
|
|
nn->track_reclaim_completes = false;
|
nfsd: randomize SETCLIENTID reply to help distinguish servers
NFSv4.1 has built-in trunking support that allows a client to determine
whether two connections to two different IP addresses are actually to
the same server. NFSv4.0 does not, but RFC 7931 attempts to provide
clients a means to do this, basically by performing a SETCLIENTID to one
address and confirming it with a SETCLIENTID_CONFIRM to the other.
Linux clients since 05f4c350ee02 "NFS: Discover NFSv4 server trunking
when mounting" implement a variation on this suggestion. It is possible
that other clients do too.
This depends on the clientid and verifier not being accepted by an
unrelated server. Since both are 64-bit values, that would be very
unlikely if they were random numbers. But they aren't:
knfsd generates the 64-bit clientid by concatenating the 32-bit boot
time (in seconds) and a counter. This makes collisions between
clientids generated by the same server extremely unlikely. But
collisions are very likely between clientids generated by servers that
boot at the same time, and it's quite common for multiple servers to
boot at the same time. The verifier is a concatenation of the
SETCLIENTID time (in seconds) and a counter, so again collisions between
different servers are likely if multiple SETCLIENTIDs are done at the
same time, which is a common case.
Therefore recent NFSv4.0 clients may decide two different servers are
really the same, and mount a filesystem from the wrong server.
Fortunately the Linux client, since 55b9df93ddd6 "nfsv4/v4.1: Verify the
client owner id during trunking detection", only does this when given
the non-default "migration" mount option.
The fault is really with RFC 7931, and needs a client fix, but in the
meantime we can mitigate the chance of these collisions by randomizing
the starting value of the counters used to generate clientids and
verifiers.
Reported-by: Frank Sorenson <fsorenso@redhat.com>
Reviewed-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2016-09-12 14:00:47 -06:00
|
|
|
nn->clverifier_counter = prandom_u32();
|
|
|
|
nn->clientid_counter = prandom_u32();
|
2018-07-20 16:19:20 -06:00
|
|
|
nn->s2s_cp_cl_id = nn->clientid_counter++;
|
2017-11-10 00:19:35 -07:00
|
|
|
|
|
|
|
atomic_set(&nn->ntf_refcnt, 0);
|
|
|
|
init_waitqueue_head(&nn->ntf_wq);
|
2012-04-11 05:13:35 -06:00
|
|
|
return 0;
|
|
|
|
|
2012-04-11 07:33:05 -06:00
|
|
|
out_idmap_error:
|
|
|
|
nfsd_export_shutdown(net);
|
2012-04-11 05:13:35 -06:00
|
|
|
out_export_error:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __net_exit void nfsd_exit_net(struct net *net)
|
|
|
|
{
|
2012-04-11 07:33:05 -06:00
|
|
|
nfsd_idmap_shutdown(net);
|
2012-04-11 05:13:35 -06:00
|
|
|
nfsd_export_shutdown(net);
|
2019-04-09 09:46:19 -06:00
|
|
|
nfsd_netns_free_versions(net_generic(net, nfsd_net_id));
|
2012-04-11 05:13:35 -06:00
|
|
|
}
|
|
|
|
|
2012-03-21 07:52:05 -06:00
|
|
|
static struct pernet_operations nfsd_net_ops = {
|
2012-04-11 05:13:35 -06:00
|
|
|
.init = nfsd_init_net,
|
|
|
|
.exit = nfsd_exit_net,
|
2012-03-21 07:52:05 -06:00
|
|
|
.id = &nfsd_net_id,
|
|
|
|
.size = sizeof(struct nfsd_net),
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init init_nfsd(void)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
|
|
|
|
|
2012-03-21 07:52:05 -06:00
|
|
|
retval = register_pernet_subsys(&nfsd_net_ops);
|
|
|
|
if (retval < 0)
|
2015-04-20 10:00:08 -06:00
|
|
|
return retval;
|
|
|
|
retval = register_cld_notifier();
|
2007-08-01 13:30:59 -06:00
|
|
|
if (retval)
|
2012-03-21 07:52:05 -06:00
|
|
|
goto out_unregister_pernet;
|
2015-04-20 10:00:08 -06:00
|
|
|
retval = nfsd4_init_slabs();
|
|
|
|
if (retval)
|
|
|
|
goto out_unregister_notifier;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 05:11:59 -06:00
|
|
|
retval = nfsd4_init_pnfs();
|
2011-11-01 11:35:21 -06:00
|
|
|
if (retval)
|
|
|
|
goto out_free_slabs;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 05:11:59 -06:00
|
|
|
retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */
|
|
|
|
if (retval)
|
|
|
|
goto out_exit_pnfs;
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd_stat_init(); /* Statistics */
|
2007-11-09 12:10:56 -07:00
|
|
|
retval = nfsd_reply_cache_init();
|
|
|
|
if (retval)
|
|
|
|
goto out_free_stat;
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd_lockd_init(); /* lockd->nfsd callbacks */
|
2007-11-12 15:32:21 -07:00
|
|
|
retval = create_proc_exports_entry();
|
|
|
|
if (retval)
|
2012-04-11 07:33:05 -06:00
|
|
|
goto out_free_lockd;
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = register_filesystem(&nfsd_fs_type);
|
2007-11-09 11:44:06 -07:00
|
|
|
if (retval)
|
|
|
|
goto out_free_all;
|
|
|
|
return 0;
|
|
|
|
out_free_all:
|
|
|
|
remove_proc_entry("fs/nfs/exports", NULL);
|
|
|
|
remove_proc_entry("fs/nfs", NULL);
|
2007-11-08 15:20:34 -07:00
|
|
|
out_free_lockd:
|
2007-11-09 11:44:06 -07:00
|
|
|
nfsd_lockd_shutdown();
|
2007-11-12 15:32:21 -07:00
|
|
|
nfsd_reply_cache_shutdown();
|
2007-11-09 12:10:56 -07:00
|
|
|
out_free_stat:
|
|
|
|
nfsd_stat_shutdown();
|
2011-11-01 11:35:21 -06:00
|
|
|
nfsd_fault_inject_cleanup();
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 05:11:59 -06:00
|
|
|
out_exit_pnfs:
|
|
|
|
nfsd4_exit_pnfs();
|
2011-11-01 11:35:21 -06:00
|
|
|
out_free_slabs:
|
2007-11-09 11:44:06 -07:00
|
|
|
nfsd4_free_slabs();
|
2012-03-21 07:52:08 -06:00
|
|
|
out_unregister_notifier:
|
2012-03-29 05:52:49 -06:00
|
|
|
unregister_cld_notifier();
|
2015-04-20 10:00:08 -06:00
|
|
|
out_unregister_pernet:
|
|
|
|
unregister_pernet_subsys(&nfsd_net_ops);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_nfsd(void)
|
|
|
|
{
|
2007-11-09 12:10:56 -07:00
|
|
|
nfsd_reply_cache_shutdown();
|
2005-04-16 16:20:36 -06:00
|
|
|
remove_proc_entry("fs/nfs/exports", NULL);
|
|
|
|
remove_proc_entry("fs/nfs", NULL);
|
|
|
|
nfsd_stat_shutdown();
|
|
|
|
nfsd_lockd_shutdown();
|
2007-08-01 13:30:59 -06:00
|
|
|
nfsd4_free_slabs();
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 05:11:59 -06:00
|
|
|
nfsd4_exit_pnfs();
|
2011-11-01 11:35:21 -06:00
|
|
|
nfsd_fault_inject_cleanup();
|
2005-04-16 16:20:36 -06:00
|
|
|
unregister_filesystem(&nfsd_fs_type);
|
2012-03-29 05:52:49 -06:00
|
|
|
unregister_cld_notifier();
|
2015-04-20 10:00:08 -06:00
|
|
|
unregister_pernet_subsys(&nfsd_net_ops);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
module_init(init_nfsd)
|
|
|
|
module_exit(exit_nfsd)
|