2005-04-17 00:20:36 +02: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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2008-07-26 09:46:43 +02:00
|
|
|
#include <linux/namei.h>
|
2006-10-02 11:17:48 +02:00
|
|
|
#include <linux/ctype.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-10-02 11:17:47 +02: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 17:10:12 +01:00
|
|
|
#include <linux/lockd/lockd.h>
|
2009-08-09 21:09:40 +02:00
|
|
|
#include <linux/sunrpc/clnt.h>
|
2011-03-03 01:51:42 +01:00
|
|
|
#include <linux/sunrpc/gss_api.h>
|
2011-05-31 18:24:58 +02:00
|
|
|
#include <linux/sunrpc/gss_krb5_enctypes.h>
|
2011-07-01 20:23:34 +02:00
|
|
|
#include <linux/module.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-04 23:37:15 +01:00
|
|
|
#include "idmap.h"
|
2009-12-03 19:30:56 +01:00
|
|
|
#include "nfsd.h"
|
|
|
|
#include "cache.h"
|
2011-11-01 18:35:21 +01:00
|
|
|
#include "fault_inject.h"
|
2009-12-03 19:30:56 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2011-03-03 01:51:42 +01:00
|
|
|
* We have a single directory with several nodes in it.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NFSD_Root = 1,
|
|
|
|
NFSD_List,
|
2009-12-14 18:53:32 +01:00
|
|
|
NFSD_Export_features,
|
2005-04-17 00:20:36 +02: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 17:10:12 +01:00
|
|
|
NFSD_FO_UnlockIP,
|
2008-01-17 17:10:12 +01:00
|
|
|
NFSD_FO_UnlockFS,
|
2005-04-17 00:20:36 +02:00
|
|
|
NFSD_Threads,
|
2006-10-02 11:18:02 +02:00
|
|
|
NFSD_Pool_Threads,
|
2009-01-13 11:26:36 +01:00
|
|
|
NFSD_Pool_Stats,
|
2005-11-07 10:00:25 +01:00
|
|
|
NFSD_Versions,
|
2006-10-02 11:17:47 +02:00
|
|
|
NFSD_Ports,
|
2006-10-04 11:15:48 +02:00
|
|
|
NFSD_MaxBlkSize,
|
2011-03-03 01:51:42 +01:00
|
|
|
NFSD_SupportedEnctypes,
|
2005-11-07 10:00:25 +01: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-17 00:20:36 +02:00
|
|
|
NFSD_Leasetime,
|
2010-03-02 17:04:06 +01:00
|
|
|
NFSD_Gracetime,
|
2005-06-24 07:04:32 +02:00
|
|
|
NFSD_RecoveryDir,
|
2005-11-07 10:00:25 +01:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* write() for these nodes.
|
|
|
|
*/
|
|
|
|
static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
|
2008-12-12 22:57:13 +01: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-17 00:20:36 +02:00
|
|
|
static ssize_t write_threads(struct file *file, char *buf, size_t size);
|
2006-10-02 11:18:02 +02:00
|
|
|
static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
|
2005-11-07 10:00:25 +01:00
|
|
|
static ssize_t write_versions(struct file *file, char *buf, size_t size);
|
2006-10-02 11:17:47 +02:00
|
|
|
static ssize_t write_ports(struct file *file, char *buf, size_t size);
|
2006-10-04 11:15:48 +02:00
|
|
|
static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
|
2005-11-07 10:00:25 +01:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2005-04-17 00:20:36 +02:00
|
|
|
static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
|
2010-03-02 17:04:06 +01:00
|
|
|
static ssize_t write_gracetime(struct file *file, char *buf, size_t size);
|
2005-06-24 07:04:32 +02:00
|
|
|
static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
|
2005-11-07 10:00:25 +01:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static ssize_t (*write_op[])(struct file *, char *, size_t) = {
|
|
|
|
[NFSD_Fh] = write_filehandle,
|
2008-12-12 22:57:13 +01:00
|
|
|
[NFSD_FO_UnlockIP] = write_unlock_ip,
|
|
|
|
[NFSD_FO_UnlockFS] = write_unlock_fs,
|
2005-04-17 00:20:36 +02:00
|
|
|
[NFSD_Threads] = write_threads,
|
2006-10-02 11:18:02 +02:00
|
|
|
[NFSD_Pool_Threads] = write_pool_threads,
|
2005-11-07 10:00:25 +01:00
|
|
|
[NFSD_Versions] = write_versions,
|
2006-10-02 11:17:47 +02:00
|
|
|
[NFSD_Ports] = write_ports,
|
2006-10-04 11:15:48 +02:00
|
|
|
[NFSD_MaxBlkSize] = write_maxblksize,
|
2005-11-07 10:00:25 +01:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2005-04-17 00:20:36 +02:00
|
|
|
[NFSD_Leasetime] = write_leasetime,
|
2010-03-02 17:04:06 +01:00
|
|
|
[NFSD_Gracetime] = write_gracetime,
|
2005-06-24 07:04:32 +02:00
|
|
|
[NFSD_RecoveryDir] = write_recoverydir,
|
2005-11-07 10:00:25 +01:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
|
|
|
|
{
|
2006-12-08 11:36:41 +01:00
|
|
|
ino_t ino = file->f_path.dentry->d_inode->i_ino;
|
2005-04-17 00:20:36 +02:00
|
|
|
char *data;
|
|
|
|
ssize_t rv;
|
|
|
|
|
2006-03-24 12:15:34 +01:00
|
|
|
if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
|
2005-04-17 00:20:36 +02: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 09:33:11 +01:00
|
|
|
if (rv >= 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
simple_transaction_set(file, rv);
|
|
|
|
rv = size;
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2005-11-07 10:00:24 +01: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 11:56:42 +02:00
|
|
|
static const struct file_operations transaction_ops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.write = nfsctl_transaction_write,
|
2005-11-07 10:00:24 +01:00
|
|
|
.read = nfsctl_transaction_read,
|
2005-04-17 00:20:36 +02: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 18:52:59 +02:00
|
|
|
.llseek = default_llseek,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static int exports_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return seq_open(file, &nfs_exports_op);
|
|
|
|
}
|
|
|
|
|
2006-03-28 11:56:42 +02:00
|
|
|
static const struct file_operations exports_operations = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = exports_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
2008-04-29 10:02:04 +02:00
|
|
|
.owner = THIS_MODULE,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2009-12-14 18:53:32 +01: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);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_operations export_features_operations = {
|
|
|
|
.open = export_features_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2011-05-31 18:24:58 +02:00
|
|
|
#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
|
2011-03-03 01:51:42 +01:00
|
|
|
static int supported_enctypes_show(struct seq_file *m, void *v)
|
|
|
|
{
|
2011-05-31 18:24:58 +02:00
|
|
|
seq_printf(m, KRB5_SUPPORTED_ENCTYPES);
|
2011-03-03 01:51:42 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int supported_enctypes_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, supported_enctypes_show, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_operations supported_enctypes_ops = {
|
|
|
|
.open = supported_enctypes_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
2011-05-31 18:24:58 +02:00
|
|
|
#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
|
2011-03-03 01:51:42 +01:00
|
|
|
|
2009-01-13 11:26:36 +01:00
|
|
|
extern int nfsd_pool_stats_open(struct inode *inode, struct file *file);
|
2009-08-15 17:54:41 +02:00
|
|
|
extern int nfsd_pool_stats_release(struct inode *inode, struct file *file);
|
2009-01-13 11:26:36 +01:00
|
|
|
|
2009-10-02 00:43:56 +02:00
|
|
|
static const struct file_operations pool_stats_operations = {
|
2009-01-13 11:26:36 +01:00
|
|
|
.open = nfsd_pool_stats_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2009-08-15 17:54:41 +02:00
|
|
|
.release = nfsd_pool_stats_release,
|
2009-01-13 11:26:36 +01:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
|
|
* payload - write methods
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2008-12-12 22:57:35 +01:00
|
|
|
/**
|
|
|
|
* write_unlock_ip - Release all locks used by a client
|
|
|
|
*
|
|
|
|
* Experimental.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: '\n'-terminated C string containing a
|
2009-08-09 21:09:40 +02:00
|
|
|
* presentation format IP address
|
2008-12-12 22:57:35 +01: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 22:57:13 +01: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 17:10:12 +01:00
|
|
|
{
|
2009-08-09 21:09:40 +02:00
|
|
|
struct sockaddr_storage address;
|
|
|
|
struct sockaddr *sap = (struct sockaddr *)&address;
|
|
|
|
size_t salen = sizeof(address);
|
2008-07-01 00:58:14 +02:00
|
|
|
char *fo_path;
|
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 17:10:12 +01: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;
|
|
|
|
|
2012-01-13 10:09:19 +01:00
|
|
|
if (rpc_pton(&init_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 17:10:12 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-08-09 21:09:40 +02: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 17:10:12 +01:00
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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 22:57:13 +01:00
|
|
|
static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
|
2008-01-17 17:10:12 +01:00
|
|
|
{
|
2008-08-02 07:03:36 +02:00
|
|
|
struct path path;
|
2008-01-17 17:10:12 +01: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-02 07:03:36 +02:00
|
|
|
error = kern_path(fo_path, 0, &path);
|
2008-01-17 17:10:12 +01:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2008-12-12 22:57:35 +01: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-08 00:16:57 +01:00
|
|
|
error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
|
2008-01-17 17:10:12 +01:00
|
|
|
|
2008-08-02 07:03:36 +02:00
|
|
|
path_put(&path);
|
2008-01-17 17:10:12 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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-17 00:20:36 +02:00
|
|
|
static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *dname, *path;
|
2007-08-09 09:53:50 +02:00
|
|
|
int uninitialized_var(maxsize);
|
2005-04-17 00:20:36 +02:00
|
|
|
char *mesg = buf;
|
|
|
|
int len;
|
|
|
|
struct auth_domain *dom;
|
|
|
|
struct knfsd_fh fh;
|
|
|
|
|
2008-01-22 23:40:42 +01:00
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
dname = mesg;
|
|
|
|
len = qword_get(&mesg, dname, size);
|
2008-12-12 22:57:20 +01:00
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
path = dname+len+1;
|
|
|
|
len = qword_get(&mesg, path, size);
|
2008-12-12 22:57:20 +01:00
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
len = get_int(&mesg, &maxsize);
|
|
|
|
if (len)
|
|
|
|
return len;
|
|
|
|
|
|
|
|
if (maxsize < NFS_FHSIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
if (maxsize > NFS3_FHSIZE)
|
|
|
|
maxsize = NFS3_FHSIZE;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
len = exp_rootfh(dom, path, &fh, maxsize);
|
|
|
|
auth_domain_put(dom);
|
|
|
|
if (len)
|
|
|
|
return len;
|
|
|
|
|
2008-12-12 22:57:20 +01:00
|
|
|
mesg = buf;
|
|
|
|
len = SIMPLE_TRANSACTION_LIMIT;
|
2005-04-17 00:20:36 +02:00
|
|
|
qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
|
|
|
|
mesg[-1] = '\n';
|
|
|
|
return mesg - buf;
|
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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-17 00:20:36 +02:00
|
|
|
static ssize_t write_threads(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
int rv;
|
|
|
|
if (size > 0) {
|
|
|
|
int newthreads;
|
|
|
|
rv = get_int(&mesg, &newthreads);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
2008-12-12 22:57:27 +01:00
|
|
|
if (newthreads < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
2008-12-12 22:57:27 +01:00
|
|
|
rv = nfsd_svc(NFS_PORT, newthreads);
|
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-16 03:03:07 +02:00
|
|
|
if (rv < 0)
|
2005-04-17 00:20:36 +02: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-16 03:03:07 +02:00
|
|
|
} else
|
|
|
|
rv = nfsd_nrthreads();
|
2009-04-24 01:33:25 +02: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-16 03:03:07 +02:00
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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 11:18:02 +02: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 14:40:35 +02:00
|
|
|
int npools;
|
2006-10-02 11:18:02 +02:00
|
|
|
int *nthreads;
|
|
|
|
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_lock(&nfsd_mutex);
|
|
|
|
npools = nfsd_nrpools();
|
2006-10-02 11:18:02 +02: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 14:40:35 +02:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-02 11:18:02 +02:00
|
|
|
strcpy(buf, "0\n");
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
|
2008-06-10 14:40:35 +02:00
|
|
|
rv = -ENOMEM;
|
2006-10-02 11:18:02 +02:00
|
|
|
if (nthreads == NULL)
|
2008-06-10 14:40:35 +02:00
|
|
|
goto out_free;
|
2006-10-02 11:18:02 +02: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;
|
|
|
|
}
|
|
|
|
rv = nfsd_set_nrthreads(i, nthreads);
|
|
|
|
if (rv)
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = nfsd_get_nrthreads(npools, nthreads);
|
|
|
|
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 17:37:25 +02:00
|
|
|
rv = mesg - buf;
|
2006-10-02 11:18:02 +02:00
|
|
|
out_free:
|
|
|
|
kfree(nthreads);
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-02 11:18:02 +02:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
static ssize_t __write_versions(struct file *file, char *buf, size_t size)
|
2005-11-07 10:00:25 +01:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2009-04-03 07:28:59 +02:00
|
|
|
char *vers, *minorp, sign;
|
2009-04-24 01:33:18 +02:00
|
|
|
int len, num, remaining;
|
2009-04-03 07:28:59 +02:00
|
|
|
unsigned minor;
|
2005-11-07 10:00:25 +01:00
|
|
|
ssize_t tlen = 0;
|
|
|
|
char *sep;
|
|
|
|
|
|
|
|
if (size>0) {
|
|
|
|
if (nfsd_serv)
|
2006-10-02 11:17:46 +02:00
|
|
|
/* Cannot change versions without updating
|
|
|
|
* nfsd_serv->sv_xdrsize, and reallocing
|
|
|
|
* rq_argp and rq_resp
|
|
|
|
*/
|
2005-11-07 10:00:25 +01: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 {
|
|
|
|
sign = *vers;
|
|
|
|
if (sign == '+' || sign == '-')
|
2009-04-03 07:28:59 +02:00
|
|
|
num = simple_strtol((vers+1), &minorp, 0);
|
2005-11-07 10:00:25 +01:00
|
|
|
else
|
2009-04-03 07:28:59 +02:00
|
|
|
num = simple_strtol(vers, &minorp, 0);
|
|
|
|
if (*minorp == '.') {
|
|
|
|
if (num < 4)
|
|
|
|
return -EINVAL;
|
|
|
|
minor = simple_strtoul(minorp+1, NULL, 0);
|
|
|
|
if (minor == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (nfsd_minorversion(minor, sign == '-' ?
|
|
|
|
NFSD_CLEAR : NFSD_SET) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
goto next;
|
|
|
|
}
|
2005-11-07 10:00:25 +01:00
|
|
|
switch(num) {
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
case 4:
|
2006-10-02 11:17:46 +02:00
|
|
|
nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
|
2005-11-07 10:00:25 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-04-03 07:28:59 +02:00
|
|
|
next:
|
2005-11-07 10:00:25 +01:00
|
|
|
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
|
|
|
|
*/
|
2006-10-02 11:17:46 +02:00
|
|
|
nfsd_reset_versions();
|
2005-11-07 10:00:25 +01:00
|
|
|
}
|
2009-04-24 01:33:18 +02:00
|
|
|
|
2005-11-07 10:00:25 +01:00
|
|
|
/* Now write current state into reply buffer */
|
|
|
|
len = 0;
|
|
|
|
sep = "";
|
2009-04-24 01:33:18 +02:00
|
|
|
remaining = SIMPLE_TRANSACTION_LIMIT;
|
2005-11-07 10:00:25 +01:00
|
|
|
for (num=2 ; num <= 4 ; num++)
|
2006-10-02 11:17:46 +02:00
|
|
|
if (nfsd_vers(num, NFSD_AVAIL)) {
|
2009-04-24 01:33:18 +02:00
|
|
|
len = snprintf(buf, remaining, "%s%c%d", sep,
|
2006-10-02 11:17:46 +02:00
|
|
|
nfsd_vers(num, NFSD_TEST)?'+':'-',
|
2005-11-07 10:00:25 +01:00
|
|
|
num);
|
|
|
|
sep = " ";
|
2009-04-24 01:33:18 +02:00
|
|
|
|
|
|
|
if (len > remaining)
|
|
|
|
break;
|
|
|
|
remaining -= len;
|
|
|
|
buf += len;
|
|
|
|
tlen += len;
|
2005-11-07 10:00:25 +01:00
|
|
|
}
|
2009-04-03 07:28:59 +02:00
|
|
|
if (nfsd_vers(4, NFSD_AVAIL))
|
2009-04-24 01:33:18 +02:00
|
|
|
for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
|
|
|
|
minor++) {
|
|
|
|
len = snprintf(buf, remaining, " %c4.%u",
|
2009-04-03 07:28:59 +02:00
|
|
|
(nfsd_vers(4, NFSD_TEST) &&
|
|
|
|
nfsd_minorversion(minor, NFSD_TEST)) ?
|
|
|
|
'+' : '-',
|
|
|
|
minor);
|
2009-04-24 01:33:18 +02:00
|
|
|
|
|
|
|
if (len > remaining)
|
|
|
|
break;
|
|
|
|
remaining -= len;
|
|
|
|
buf += len;
|
|
|
|
tlen += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = snprintf(buf, remaining, "\n");
|
|
|
|
if (len > remaining)
|
|
|
|
return -EINVAL;
|
|
|
|
return tlen + len;
|
2005-11-07 10:00:25 +01:00
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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 14:40:36 +02: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-24 01:32:10 +02:00
|
|
|
/*
|
|
|
|
* Zero-length write. Return a list of NFSD's current listener
|
|
|
|
* transports.
|
|
|
|
*/
|
|
|
|
static ssize_t __write_ports_names(char *buf)
|
|
|
|
{
|
|
|
|
if (nfsd_serv == NULL)
|
|
|
|
return 0;
|
2009-04-24 01:32:25 +02:00
|
|
|
return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
|
2009-04-24 01:32:10 +02:00
|
|
|
}
|
|
|
|
|
2009-04-24 01:31:55 +02: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.
|
|
|
|
*/
|
|
|
|
static ssize_t __write_ports_addfd(char *buf)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
int fd, err;
|
|
|
|
|
|
|
|
err = get_int(&mesg, &fd);
|
|
|
|
if (err != 0 || fd < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = nfsd_create_serv();
|
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2009-04-24 01:32:33 +02:00
|
|
|
err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
|
2010-07-19 22:50:05 +02:00
|
|
|
if (err < 0) {
|
|
|
|
svc_destroy(nfsd_serv);
|
|
|
|
return err;
|
|
|
|
}
|
2009-04-24 01:31:55 +02:00
|
|
|
|
2009-04-24 01:32:18 +02:00
|
|
|
/* Decrease the count, but don't shut down the service */
|
|
|
|
nfsd_serv->sv_nrthreads--;
|
|
|
|
return err;
|
2009-04-24 01:31:55 +02:00
|
|
|
}
|
|
|
|
|
2009-04-24 01:31:48 +02:00
|
|
|
/*
|
|
|
|
* A '-' followed by the 'name' of a socket means we close the socket.
|
|
|
|
*/
|
|
|
|
static ssize_t __write_ports_delfd(char *buf)
|
|
|
|
{
|
|
|
|
char *toclose;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
toclose = kstrdup(buf + 1, GFP_KERNEL);
|
|
|
|
if (toclose == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (nfsd_serv != NULL)
|
2009-04-24 01:32:40 +02:00
|
|
|
len = svc_sock_names(nfsd_serv, buf,
|
|
|
|
SIMPLE_TRANSACTION_LIMIT, toclose);
|
2009-04-24 01:31:48 +02:00
|
|
|
kfree(toclose);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2009-04-24 01:31:40 +02:00
|
|
|
/*
|
|
|
|
* A transport listener is added by writing it's transport name and
|
|
|
|
* a port number.
|
|
|
|
*/
|
|
|
|
static ssize_t __write_ports_addxprt(char *buf)
|
|
|
|
{
|
|
|
|
char transport[16];
|
2010-01-26 20:04:22 +01:00
|
|
|
struct svc_xprt *xprt;
|
2009-04-24 01:31:40 +02:00
|
|
|
int port, err;
|
|
|
|
|
|
|
|
if (sscanf(buf, "%15s %4u", transport, &port) != 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-24 23:33:03 +02:00
|
|
|
if (port < 1 || port > USHRT_MAX)
|
2009-04-24 01:31:40 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = nfsd_create_serv();
|
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2010-09-29 14:03:50 +02:00
|
|
|
err = svc_create_xprt(nfsd_serv, transport, &init_net,
|
2009-04-24 01:31:40 +02:00
|
|
|
PF_INET, port, SVC_SOCK_ANONYMOUS);
|
2010-01-26 20:04:13 +01:00
|
|
|
if (err < 0)
|
2010-01-26 20:04:22 +01:00
|
|
|
goto out_err;
|
|
|
|
|
2010-09-29 14:03:50 +02:00
|
|
|
err = svc_create_xprt(nfsd_serv, transport, &init_net,
|
2010-01-26 20:04:22 +01:00
|
|
|
PF_INET6, port, SVC_SOCK_ANONYMOUS);
|
|
|
|
if (err < 0 && err != -EAFNOSUPPORT)
|
|
|
|
goto out_close;
|
2010-07-19 22:50:06 +02:00
|
|
|
|
|
|
|
/* Decrease the count, but don't shut down the service */
|
|
|
|
nfsd_serv->sv_nrthreads--;
|
2009-04-24 01:31:40 +02:00
|
|
|
return 0;
|
2010-01-26 20:04:22 +01:00
|
|
|
out_close:
|
2012-01-20 13:50:53 +01:00
|
|
|
xprt = svc_find_xprt(nfsd_serv, transport, &init_net, PF_INET, port);
|
2010-01-26 20:04:22 +01:00
|
|
|
if (xprt != NULL) {
|
|
|
|
svc_close_xprt(xprt);
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
out_err:
|
2010-07-19 22:50:06 +02:00
|
|
|
svc_destroy(nfsd_serv);
|
2010-01-26 20:04:22 +01:00
|
|
|
return err;
|
2009-04-24 01:31:40 +02:00
|
|
|
}
|
|
|
|
|
2009-04-24 01:31:32 +02:00
|
|
|
/*
|
|
|
|
* A transport listener is removed by writing a "-", it's transport
|
|
|
|
* name, and it's port number.
|
|
|
|
*/
|
|
|
|
static ssize_t __write_ports_delxprt(char *buf)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
|
|
|
char transport[16];
|
|
|
|
int port;
|
|
|
|
|
|
|
|
if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-24 23:33:03 +02:00
|
|
|
if (port < 1 || port > USHRT_MAX || nfsd_serv == NULL)
|
2009-04-24 01:31:32 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-01-20 13:50:53 +01:00
|
|
|
xprt = svc_find_xprt(nfsd_serv, transport, &init_net, AF_UNSPEC, port);
|
2009-04-24 01:31:32 +02:00
|
|
|
if (xprt == NULL)
|
|
|
|
return -ENOTCONN;
|
|
|
|
|
|
|
|
svc_close_xprt(xprt);
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-10 14:40:35 +02:00
|
|
|
static ssize_t __write_ports(struct file *file, char *buf, size_t size)
|
2006-10-02 11:17:47 +02:00
|
|
|
{
|
2009-04-24 01:32:10 +02:00
|
|
|
if (size == 0)
|
|
|
|
return __write_ports_names(buf);
|
2009-04-24 01:31:55 +02:00
|
|
|
|
|
|
|
if (isdigit(buf[0]))
|
|
|
|
return __write_ports_addfd(buf);
|
2009-04-24 01:31:48 +02:00
|
|
|
|
|
|
|
if (buf[0] == '-' && isdigit(buf[1]))
|
|
|
|
return __write_ports_delfd(buf);
|
2009-04-24 01:31:40 +02:00
|
|
|
|
|
|
|
if (isalpha(buf[0]))
|
|
|
|
return __write_ports_addxprt(buf);
|
2009-04-24 01:31:32 +02:00
|
|
|
|
|
|
|
if (buf[0] == '-' && isalpha(buf[1]))
|
|
|
|
return __write_ports_delxprt(buf);
|
|
|
|
|
2006-10-02 11:17:48 +02:00
|
|
|
return -EINVAL;
|
2006-10-02 11:17:47 +02:00
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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-24 01:32:03 +02:00
|
|
|
* used as an NFSD listener; listen(3)
|
|
|
|
* must be called for a SOCK_STREAM
|
|
|
|
* socket, otherwise it is ignored
|
2008-12-12 22:57:35 +01: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 "-" followed
|
|
|
|
* by an integer value representing a
|
|
|
|
* previously passed in socket file
|
|
|
|
* descriptor
|
|
|
|
* size: non-zero length of C string in @buf
|
|
|
|
* Output:
|
|
|
|
* On success: NFS service no longer listens on that socket;
|
|
|
|
* passed-in buffer filled with a '\n'-terminated C
|
|
|
|
* string containing a unique 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
|
|
|
|
*
|
|
|
|
* OR
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* buf: C string containing a "-" followed
|
|
|
|
* by 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 no longer listens
|
|
|
|
* on that transport
|
|
|
|
* On error: return code is a negative errno value
|
|
|
|
*/
|
2008-06-10 14:40:35 +02:00
|
|
|
static ssize_t write_ports(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
2008-06-10 14:40:36 +02:00
|
|
|
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_lock(&nfsd_mutex);
|
|
|
|
rv = __write_ports(file, buf, size);
|
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-04 11:15:48 +02:00
|
|
|
int nfsd_max_blksize;
|
|
|
|
|
2008-12-12 22:57:35 +01: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 11:15:48 +02:00
|
|
|
static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
if (size > 0) {
|
|
|
|
int bsize;
|
|
|
|
int rv = get_int(&mesg, &bsize);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
|
|
|
/* force bsize into allowed range and
|
|
|
|
* required alignment.
|
|
|
|
*/
|
|
|
|
if (bsize < 1024)
|
|
|
|
bsize = 1024;
|
|
|
|
if (bsize > NFSSVC_MAXBLKSIZE)
|
|
|
|
bsize = NFSSVC_MAXBLKSIZE;
|
|
|
|
bsize &= ~(1024-1);
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_lock(&nfsd_mutex);
|
2010-08-07 00:00:33 +02:00
|
|
|
if (nfsd_serv) {
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-04 11:15:48 +02:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
nfsd_max_blksize = bsize;
|
2008-06-10 14:40:35 +02:00
|
|
|
mutex_unlock(&nfsd_mutex);
|
2006-10-04 11:15:48 +02:00
|
|
|
}
|
2009-04-24 01:33:25 +02:00
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
|
|
|
|
nfsd_max_blksize);
|
2006-10-04 11:15:48 +02:00
|
|
|
}
|
|
|
|
|
2005-11-07 10:00:25 +01:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
2010-03-02 01:32:36 +01:00
|
|
|
static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
2010-03-02 01:32:36 +01:00
|
|
|
int rv, i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (size > 0) {
|
2008-06-10 14:40:36 +02:00
|
|
|
if (nfsd_serv)
|
|
|
|
return -EBUSY;
|
2010-03-02 01:32:36 +01:00
|
|
|
rv = get_int(&mesg, &i);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (rv)
|
|
|
|
return rv;
|
2010-03-02 17:18:40 +01: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-02 01:32:36 +01:00
|
|
|
if (i < 10 || i > 3600)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
2010-03-02 01:32:36 +01:00
|
|
|
*time = i;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-04-24 01:33:25 +02:00
|
|
|
|
2010-03-02 01:32:36 +01:00
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
|
|
|
|
|
|
|
mutex_lock(&nfsd_mutex);
|
|
|
|
rv = __nfsd4_write_time(file, buf, size, time);
|
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-12 22:57:35 +01: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 14:40:36 +02:00
|
|
|
static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
2010-03-02 01:32:36 +01:00
|
|
|
return nfsd4_write_time(file, buf, size, &nfsd4_lease);
|
2008-06-10 14:40:36 +02:00
|
|
|
}
|
|
|
|
|
2010-03-02 17:04:06 +01: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)
|
|
|
|
{
|
|
|
|
return nfsd4_write_time(file, buf, size, &nfsd4_grace);
|
|
|
|
}
|
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
extern char *nfs4_recoverydir(void);
|
|
|
|
|
|
|
|
static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
|
2005-06-24 07:04:32 +02:00
|
|
|
{
|
|
|
|
char *mesg = buf;
|
|
|
|
char *recdir;
|
|
|
|
int len, status;
|
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
if (size > 0) {
|
|
|
|
if (nfsd_serv)
|
|
|
|
return -EBUSY;
|
|
|
|
if (size > PATH_MAX || buf[size-1] != '\n')
|
|
|
|
return -EINVAL;
|
|
|
|
buf[size-1] = 0;
|
2005-06-24 07:04:32 +02:00
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
recdir = mesg;
|
|
|
|
len = qword_get(&mesg, recdir, size);
|
|
|
|
if (len <= 0)
|
|
|
|
return -EINVAL;
|
2005-06-24 07:04:32 +02:00
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
status = nfs4_reset_recoverydir(recdir);
|
2010-07-21 00:24:27 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
2008-06-10 14:40:36 +02:00
|
|
|
}
|
2009-04-24 01:33:10 +02:00
|
|
|
|
|
|
|
return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
|
|
|
|
nfs4_recoverydir());
|
2005-06-24 07:04:32 +02:00
|
|
|
}
|
2008-06-10 14:40:36 +02:00
|
|
|
|
2008-12-12 22:57:35 +01: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 14:40:36 +02:00
|
|
|
static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t rv;
|
|
|
|
|
|
|
|
mutex_lock(&nfsd_mutex);
|
|
|
|
rv = __write_recoverydir(file, buf, size);
|
|
|
|
mutex_unlock(&nfsd_mutex);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2005-11-07 10:00:25 +01:00
|
|
|
#endif
|
2005-06-24 07:04:32 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
|
|
* populating the filesystem.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
|
|
|
|
{
|
|
|
|
static struct tree_descr nfsd_files[] = {
|
|
|
|
[NFSD_List] = {"exports", &exports_operations, S_IRUGO},
|
2009-12-14 18:53:32 +01: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 17:10:12 +01:00
|
|
|
[NFSD_FO_UnlockIP] = {"unlock_ip",
|
|
|
|
&transaction_ops, S_IWUSR|S_IRUSR},
|
2008-01-17 17:10:12 +01:00
|
|
|
[NFSD_FO_UnlockFS] = {"unlock_filesystem",
|
|
|
|
&transaction_ops, S_IWUSR|S_IRUSR},
|
2005-04-17 00:20:36 +02:00
|
|
|
[NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
|
|
|
|
[NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
|
2006-10-02 11:18:02 +02:00
|
|
|
[NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
|
2009-01-13 11:26:36 +01:00
|
|
|
[NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
|
2005-11-07 10:00:25 +01:00
|
|
|
[NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
|
2006-10-02 11:17:47 +02:00
|
|
|
[NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
|
2006-10-04 11:15:48 +02:00
|
|
|
[NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
|
2011-05-31 18:24:58 +02:00
|
|
|
#if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
|
2011-03-03 01:51:42 +01:00
|
|
|
[NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO},
|
2011-05-31 18:24:58 +02:00
|
|
|
#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_NFSD_V4
|
|
|
|
[NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
|
2010-03-02 17:04:06 +01:00
|
|
|
[NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR},
|
2005-06-24 07:04:32 +02:00
|
|
|
[NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
/* last one */ {""}
|
|
|
|
};
|
|
|
|
return simple_fill_super(sb, 0x6e667364, nfsd_files);
|
|
|
|
}
|
|
|
|
|
2010-07-24 23:48:30 +02:00
|
|
|
static struct dentry *nfsd_mount(struct file_system_type *fs_type,
|
|
|
|
int flags, const char *dev_name, void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-07-24 23:48:30 +02:00
|
|
|
return mount_single(fs_type, flags, data, nfsd_fill_super);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type nfsd_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "nfsd",
|
2010-07-24 23:48:30 +02:00
|
|
|
.mount = nfsd_mount,
|
2005-04-17 00:20:36 +02:00
|
|
|
.kill_sb = kill_litter_super,
|
|
|
|
};
|
|
|
|
|
2007-11-12 23:32:21 +01: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;
|
2008-04-29 10:02:04 +02:00
|
|
|
entry = proc_create("exports", 0, entry, &exports_operations);
|
2007-11-12 23:32:21 +01:00
|
|
|
if (!entry)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else /* CONFIG_PROC_FS */
|
|
|
|
static int create_proc_exports_entry(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int __init init_nfsd(void)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
|
|
|
|
|
2011-11-01 20:24:59 +01:00
|
|
|
retval = nfsd4_init_slabs();
|
2007-08-01 21:30:59 +02:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
2011-11-01 20:24:59 +01:00
|
|
|
nfs4_state_init();
|
2011-11-01 18:35:21 +01:00
|
|
|
retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */
|
|
|
|
if (retval)
|
|
|
|
goto out_free_slabs;
|
2005-04-17 00:20:36 +02:00
|
|
|
nfsd_stat_init(); /* Statistics */
|
2007-11-09 20:10:56 +01:00
|
|
|
retval = nfsd_reply_cache_init();
|
|
|
|
if (retval)
|
|
|
|
goto out_free_stat;
|
2007-11-08 23:20:34 +01:00
|
|
|
retval = nfsd_export_init();
|
|
|
|
if (retval)
|
|
|
|
goto out_free_cache;
|
2005-04-17 00:20:36 +02:00
|
|
|
nfsd_lockd_init(); /* lockd->nfsd callbacks */
|
2007-11-08 23:20:34 +01:00
|
|
|
retval = nfsd_idmap_init();
|
|
|
|
if (retval)
|
|
|
|
goto out_free_lockd;
|
2007-11-12 23:32:21 +01:00
|
|
|
retval = create_proc_exports_entry();
|
|
|
|
if (retval)
|
|
|
|
goto out_free_idmap;
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = register_filesystem(&nfsd_fs_type);
|
2007-11-09 19:44:06 +01: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-12 23:32:21 +01:00
|
|
|
out_free_idmap:
|
2007-11-08 23:20:34 +01:00
|
|
|
nfsd_idmap_shutdown();
|
|
|
|
out_free_lockd:
|
2007-11-09 19:44:06 +01:00
|
|
|
nfsd_lockd_shutdown();
|
2007-11-12 23:32:21 +01:00
|
|
|
nfsd_export_shutdown();
|
2007-11-08 23:20:34 +01:00
|
|
|
out_free_cache:
|
2007-11-12 23:32:21 +01:00
|
|
|
nfsd_reply_cache_shutdown();
|
2007-11-09 20:10:56 +01:00
|
|
|
out_free_stat:
|
|
|
|
nfsd_stat_shutdown();
|
2011-11-01 18:35:21 +01:00
|
|
|
nfsd_fault_inject_cleanup();
|
|
|
|
out_free_slabs:
|
2007-11-09 19:44:06 +01:00
|
|
|
nfsd4_free_slabs();
|
2005-04-17 00:20:36 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_nfsd(void)
|
|
|
|
{
|
|
|
|
nfsd_export_shutdown();
|
2007-11-09 20:10:56 +01:00
|
|
|
nfsd_reply_cache_shutdown();
|
2005-04-17 00:20:36 +02:00
|
|
|
remove_proc_entry("fs/nfs/exports", NULL);
|
|
|
|
remove_proc_entry("fs/nfs", NULL);
|
|
|
|
nfsd_stat_shutdown();
|
|
|
|
nfsd_lockd_shutdown();
|
|
|
|
nfsd_idmap_shutdown();
|
2007-08-01 21:30:59 +02:00
|
|
|
nfsd4_free_slabs();
|
2011-11-01 18:35:21 +01:00
|
|
|
nfsd_fault_inject_cleanup();
|
2005-04-17 00:20:36 +02:00
|
|
|
unregister_filesystem(&nfsd_fs_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
module_init(init_nfsd)
|
|
|
|
module_exit(exit_nfsd)
|