License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 08:07:57 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/fs/lockd/host.c
|
|
|
|
*
|
|
|
|
* Management for NLM peer hosts. The nlm_host struct is shared
|
|
|
|
* between client and server implementation. The only reason to
|
|
|
|
* do so is to reduce code bloat.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/in.h>
|
2008-08-27 14:57:23 -06:00
|
|
|
#include <linux/in6.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/sunrpc/clnt.h>
|
2013-02-04 10:50:00 -07:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/sunrpc/svc.h>
|
|
|
|
#include <linux/lockd/lockd.h>
|
2006-03-26 02:37:12 -07:00
|
|
|
#include <linux/mutex.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-31 04:08:13 -07:00
|
|
|
#include <linux/sunrpc/svc_xprt.h>
|
|
|
|
|
2008-08-27 14:57:23 -06:00
|
|
|
#include <net/ipv6.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-25 06:56:11 -06:00
|
|
|
#include "netns.h"
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define NLMDBG_FACILITY NLMDBG_HOSTCACHE
|
|
|
|
#define NLM_HOST_NRHASH 32
|
|
|
|
#define NLM_HOST_REBIND (60 * HZ)
|
2008-02-07 19:03:37 -07:00
|
|
|
#define NLM_HOST_EXPIRE (300 * HZ)
|
|
|
|
#define NLM_HOST_COLLECT (120 * HZ)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-14 08:06:22 -07:00
|
|
|
static struct hlist_head nlm_server_hosts[NLM_HOST_NRHASH];
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
static struct hlist_head nlm_client_hosts[NLM_HOST_NRHASH];
|
2010-12-14 08:05:03 -07:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
#define for_each_host(host, chain, table) \
|
2010-12-14 08:05:03 -07:00
|
|
|
for ((chain) = (table); \
|
|
|
|
(chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry((host), (chain), h_hash)
|
2010-12-14 08:05:03 -07:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
#define for_each_host_safe(host, next, chain, table) \
|
2010-12-14 08:05:03 -07:00
|
|
|
for ((chain) = (table); \
|
|
|
|
(chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe((host), (next), \
|
2010-12-14 08:05:03 -07:00
|
|
|
(chain), h_hash)
|
|
|
|
|
2010-12-14 08:06:32 -07:00
|
|
|
static unsigned long nrhosts;
|
2006-03-26 02:37:12 -07:00
|
|
|
static DEFINE_MUTEX(nlm_host_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-25 06:56:03 -06:00
|
|
|
static void nlm_gc_hosts(struct net *net);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-03 10:50:07 -06:00
|
|
|
struct nlm_lookup_host_info {
|
|
|
|
const int server; /* search for server|client */
|
2008-10-03 10:50:14 -06:00
|
|
|
const struct sockaddr *sap; /* address to search for */
|
|
|
|
const size_t salen; /* it's length */
|
2008-10-03 10:50:07 -06:00
|
|
|
const unsigned short protocol; /* transport to search for*/
|
|
|
|
const u32 version; /* NLM version to search for */
|
|
|
|
const char *hostname; /* remote's hostname */
|
|
|
|
const size_t hostname_len; /* it's length */
|
2008-12-23 13:21:38 -07:00
|
|
|
const int noresvport; /* use non-priv port */
|
2012-01-31 04:08:13 -07:00
|
|
|
struct net *net; /* network namespace to bind */
|
2019-04-24 15:46:50 -06:00
|
|
|
const struct cred *cred;
|
2008-10-03 10:50:07 -06:00
|
|
|
};
|
|
|
|
|
2008-09-03 12:36:08 -06:00
|
|
|
/*
|
|
|
|
* Hash function must work well on big- and little-endian platforms
|
|
|
|
*/
|
|
|
|
static unsigned int __nlm_hash32(const __be32 n)
|
|
|
|
{
|
|
|
|
unsigned int hash = (__force u32)n ^ ((__force u32)n >> 16);
|
|
|
|
return hash ^ (hash >> 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int __nlm_hash_addr4(const struct sockaddr *sap)
|
|
|
|
{
|
|
|
|
const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
|
|
|
|
return __nlm_hash32(sin->sin_addr.s_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int __nlm_hash_addr6(const struct sockaddr *sap)
|
|
|
|
{
|
|
|
|
const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
|
|
|
|
const struct in6_addr addr = sin6->sin6_addr;
|
|
|
|
return __nlm_hash32(addr.s6_addr32[0]) ^
|
|
|
|
__nlm_hash32(addr.s6_addr32[1]) ^
|
|
|
|
__nlm_hash32(addr.s6_addr32[2]) ^
|
|
|
|
__nlm_hash32(addr.s6_addr32[3]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int nlm_hash_address(const struct sockaddr *sap)
|
|
|
|
{
|
|
|
|
unsigned int hash;
|
|
|
|
|
|
|
|
switch (sap->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
hash = __nlm_hash_addr4(sap);
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
hash = __nlm_hash_addr6(sap);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
hash = 0;
|
|
|
|
}
|
|
|
|
return hash & (NLM_HOST_NRHASH - 1);
|
|
|
|
}
|
|
|
|
|
2010-12-14 08:05:23 -07:00
|
|
|
/*
|
|
|
|
* Allocate and initialize an nlm_host. Common to both client and server.
|
|
|
|
*/
|
|
|
|
static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
|
|
|
|
struct nsm_handle *nsm)
|
|
|
|
{
|
|
|
|
struct nlm_host *host = NULL;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
|
|
|
|
if (nsm != NULL)
|
2017-11-29 04:15:44 -07:00
|
|
|
refcount_inc(&nsm->sm_count);
|
2010-12-14 08:05:23 -07:00
|
|
|
else {
|
|
|
|
host = NULL;
|
2015-09-23 06:49:29 -06:00
|
|
|
nsm = nsm_get_handle(ni->net, ni->sap, ni->salen,
|
2010-12-14 08:05:23 -07:00
|
|
|
ni->hostname, ni->hostname_len);
|
|
|
|
if (unlikely(nsm == NULL)) {
|
|
|
|
dprintk("lockd: %s failed; no nsm handle\n",
|
|
|
|
__func__);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
host = kmalloc(sizeof(*host), GFP_KERNEL);
|
|
|
|
if (unlikely(host == NULL)) {
|
|
|
|
dprintk("lockd: %s failed; no memory\n", __func__);
|
|
|
|
nsm_release(nsm);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(nlm_addr(host), ni->sap, ni->salen);
|
|
|
|
host->h_addrlen = ni->salen;
|
|
|
|
rpc_set_port(nlm_addr(host), 0);
|
|
|
|
host->h_srcaddrlen = 0;
|
|
|
|
|
|
|
|
host->h_rpcclnt = NULL;
|
|
|
|
host->h_name = nsm->sm_name;
|
|
|
|
host->h_version = ni->version;
|
|
|
|
host->h_proto = ni->protocol;
|
|
|
|
host->h_reclaiming = 0;
|
|
|
|
host->h_server = ni->server;
|
|
|
|
host->h_noresvport = ni->noresvport;
|
|
|
|
host->h_inuse = 0;
|
|
|
|
init_waitqueue_head(&host->h_gracewait);
|
|
|
|
init_rwsem(&host->h_rwsem);
|
|
|
|
host->h_state = 0;
|
|
|
|
host->h_nsmstate = 0;
|
|
|
|
host->h_pidcount = 0;
|
2017-11-29 04:15:43 -07:00
|
|
|
refcount_set(&host->h_count, 1);
|
2010-12-14 08:05:23 -07:00
|
|
|
mutex_init(&host->h_mutex);
|
|
|
|
host->h_nextrebind = now + NLM_HOST_REBIND;
|
|
|
|
host->h_expires = now + NLM_HOST_EXPIRE;
|
|
|
|
INIT_LIST_HEAD(&host->h_lockowners);
|
|
|
|
spin_lock_init(&host->h_lock);
|
|
|
|
INIT_LIST_HEAD(&host->h_granted);
|
|
|
|
INIT_LIST_HEAD(&host->h_reclaim);
|
|
|
|
host->h_nsmhandle = nsm;
|
|
|
|
host->h_addrbuf = nsm->sm_addrbuf;
|
2012-01-31 04:08:13 -07:00
|
|
|
host->net = ni->net;
|
2019-04-24 15:46:50 -06:00
|
|
|
host->h_cred = get_cred(ni->cred),
|
2015-10-07 05:39:55 -06:00
|
|
|
strlcpy(host->nodename, utsname()->nodename, sizeof(host->nodename));
|
2010-12-14 08:05:23 -07:00
|
|
|
|
|
|
|
out:
|
|
|
|
return host;
|
|
|
|
}
|
|
|
|
|
2006-10-04 03:16:00 -06:00
|
|
|
/*
|
2010-12-14 08:05:33 -07:00
|
|
|
* Destroy an nlm_host and free associated resources
|
|
|
|
*
|
|
|
|
* Caller must hold nlm_host_mutex.
|
2006-10-04 03:16:00 -06:00
|
|
|
*/
|
2010-12-14 08:05:33 -07:00
|
|
|
static void nlm_destroy_host_locked(struct nlm_host *host)
|
2006-10-04 03:16:00 -06:00
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt;
|
2012-07-25 06:56:19 -06:00
|
|
|
struct lockd_net *ln = net_generic(host->net, lockd_net_id);
|
2006-10-04 03:16:00 -06:00
|
|
|
|
2010-12-14 08:05:33 -07:00
|
|
|
dprintk("lockd: destroy host %s\n", host->h_name);
|
|
|
|
|
|
|
|
hlist_del_init(&host->h_hash);
|
|
|
|
|
2006-10-04 03:16:00 -06:00
|
|
|
nsm_unmonitor(host);
|
2008-12-04 12:21:31 -07:00
|
|
|
nsm_release(host->h_nsmhandle);
|
2006-10-04 03:16:00 -06:00
|
|
|
|
2007-06-14 14:40:31 -06:00
|
|
|
clnt = host->h_rpcclnt;
|
|
|
|
if (clnt != NULL)
|
|
|
|
rpc_shutdown_client(clnt);
|
2019-04-24 15:46:50 -06:00
|
|
|
put_cred(host->h_cred);
|
2006-10-04 03:16:00 -06:00
|
|
|
kfree(host);
|
2010-12-14 08:05:33 -07:00
|
|
|
|
2012-07-25 06:56:19 -06:00
|
|
|
ln->nrhosts--;
|
2010-12-14 08:05:33 -07:00
|
|
|
nrhosts--;
|
2006-10-04 03:16:00 -06:00
|
|
|
}
|
|
|
|
|
2008-10-03 10:50:21 -06:00
|
|
|
/**
|
|
|
|
* nlmclnt_lookup_host - Find an NLM host handle matching a remote server
|
|
|
|
* @sap: network address of server
|
|
|
|
* @salen: length of server address
|
|
|
|
* @protocol: transport protocol to use
|
|
|
|
* @version: NLM protocol version
|
|
|
|
* @hostname: '\0'-terminated hostname of server
|
2008-12-23 13:21:38 -07:00
|
|
|
* @noresvport: 1 if non-privileged port should be used
|
2019-04-24 15:46:50 -06:00
|
|
|
* @net: pointer to net namespace
|
|
|
|
* @cred: pointer to cred
|
2008-10-03 10:50:21 -06:00
|
|
|
*
|
|
|
|
* Returns an nlm_host structure that matches the passed-in
|
|
|
|
* [server address, transport protocol, NLM version, server hostname].
|
|
|
|
* If one doesn't already exist in the host cache, a new handle is
|
|
|
|
* created and returned.
|
2006-12-06 21:38:29 -07:00
|
|
|
*/
|
2008-10-03 10:50:21 -06:00
|
|
|
struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
|
|
|
|
const size_t salen,
|
|
|
|
const unsigned short protocol,
|
2008-12-23 13:21:38 -07:00
|
|
|
const u32 version,
|
|
|
|
const char *hostname,
|
2012-01-31 04:08:13 -07:00
|
|
|
int noresvport,
|
2019-04-24 15:46:50 -06:00
|
|
|
struct net *net,
|
|
|
|
const struct cred *cred)
|
2006-12-06 21:38:29 -07:00
|
|
|
{
|
2008-10-03 10:50:07 -06:00
|
|
|
struct nlm_lookup_host_info ni = {
|
|
|
|
.server = 0,
|
2008-10-03 10:50:21 -06:00
|
|
|
.sap = sap,
|
|
|
|
.salen = salen,
|
|
|
|
.protocol = protocol,
|
2008-10-03 10:50:07 -06:00
|
|
|
.version = version,
|
|
|
|
.hostname = hostname,
|
2008-10-03 10:50:21 -06:00
|
|
|
.hostname_len = strlen(hostname),
|
2008-12-23 13:21:38 -07:00
|
|
|
.noresvport = noresvport,
|
2012-01-31 04:08:13 -07:00
|
|
|
.net = net,
|
2019-04-24 15:46:50 -06:00
|
|
|
.cred = cred,
|
2008-10-03 10:50:07 -06:00
|
|
|
};
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
struct hlist_head *chain;
|
|
|
|
struct nlm_host *host;
|
|
|
|
struct nsm_handle *nsm = NULL;
|
2012-07-25 06:56:19 -06:00
|
|
|
struct lockd_net *ln = net_generic(net, lockd_net_id);
|
2007-07-09 14:25:29 -06:00
|
|
|
|
2008-10-03 10:50:07 -06:00
|
|
|
dprintk("lockd: %s(host='%s', vers=%u, proto=%s)\n", __func__,
|
|
|
|
(hostname ? hostname : "<none>"), version,
|
2008-10-03 10:50:21 -06:00
|
|
|
(protocol == IPPROTO_UDP ? "udp" : "tcp"));
|
2008-10-03 10:50:07 -06:00
|
|
|
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
mutex_lock(&nlm_host_mutex);
|
|
|
|
|
|
|
|
chain = &nlm_client_hosts[nlm_hash_address(sap)];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry(host, chain, h_hash) {
|
2012-01-31 04:08:13 -07:00
|
|
|
if (host->net != net)
|
|
|
|
continue;
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
if (!rpc_cmp_addr(nlm_addr(host), sap))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Same address. Share an NSM handle if we already have one */
|
|
|
|
if (nsm == NULL)
|
|
|
|
nsm = host->h_nsmhandle;
|
|
|
|
|
|
|
|
if (host->h_proto != protocol)
|
|
|
|
continue;
|
|
|
|
if (host->h_version != version)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
nlm_get_host(host);
|
|
|
|
dprintk("lockd: %s found host %s (%s)\n", __func__,
|
|
|
|
host->h_name, host->h_addrbuf);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
host = nlm_alloc_host(&ni, nsm);
|
|
|
|
if (unlikely(host == NULL))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
hlist_add_head(&host->h_hash, chain);
|
2012-07-25 06:56:19 -06:00
|
|
|
ln->nrhosts++;
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
nrhosts++;
|
|
|
|
|
|
|
|
dprintk("lockd: %s created host %s (%s)\n", __func__,
|
|
|
|
host->h_name, host->h_addrbuf);
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&nlm_host_mutex);
|
|
|
|
return host;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nlmclnt_release_host - release client nlm_host
|
|
|
|
* @host: nlm_host to release
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void nlmclnt_release_host(struct nlm_host *host)
|
|
|
|
{
|
|
|
|
if (host == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dprintk("lockd: release client host %s\n", host->h_name);
|
|
|
|
|
2012-10-15 15:26:20 -06:00
|
|
|
WARN_ON_ONCE(host->h_server);
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
|
2019-03-18 18:33:24 -06:00
|
|
|
if (refcount_dec_and_mutex_lock(&host->h_count, &nlm_host_mutex)) {
|
2012-10-15 15:26:20 -06:00
|
|
|
WARN_ON_ONCE(!list_empty(&host->h_lockowners));
|
|
|
|
WARN_ON_ONCE(!list_empty(&host->h_granted));
|
|
|
|
WARN_ON_ONCE(!list_empty(&host->h_reclaim));
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
|
|
|
|
nlm_destroy_host_locked(host);
|
|
|
|
mutex_unlock(&nlm_host_mutex);
|
|
|
|
}
|
2006-12-06 21:38:29 -07:00
|
|
|
}
|
|
|
|
|
2008-10-03 10:50:29 -06:00
|
|
|
/**
|
|
|
|
* nlmsvc_lookup_host - Find an NLM host handle matching a remote client
|
|
|
|
* @rqstp: incoming NLM request
|
|
|
|
* @hostname: name of client host
|
|
|
|
* @hostname_len: length of client hostname
|
|
|
|
*
|
|
|
|
* Returns an nlm_host structure that matches the [client address,
|
|
|
|
* transport protocol, NLM version, client hostname] of the passed-in
|
|
|
|
* NLM request. If one doesn't already exist in the host cache, a
|
|
|
|
* new handle is created and returned.
|
|
|
|
*
|
|
|
|
* Before possibly creating a new nlm_host, construct a sockaddr
|
|
|
|
* for a specific source address in case the local system has
|
|
|
|
* multiple network addresses. The family of the address in
|
|
|
|
* rq_daddr is guaranteed to be the same as the family of the
|
|
|
|
* address in rq_addr, so it's safe to use the same family for
|
|
|
|
* the source address.
|
2006-12-06 21:38:29 -07:00
|
|
|
*/
|
2008-10-03 10:50:29 -06:00
|
|
|
struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
|
|
|
|
const char *hostname,
|
|
|
|
const size_t hostname_len)
|
2006-12-06 21:38:29 -07:00
|
|
|
{
|
2010-12-14 08:06:12 -07:00
|
|
|
struct hlist_head *chain;
|
|
|
|
struct nlm_host *host = NULL;
|
|
|
|
struct nsm_handle *nsm = NULL;
|
2011-08-30 03:18:41 -06:00
|
|
|
struct sockaddr *src_sap = svc_daddr(rqstp);
|
|
|
|
size_t src_len = rqstp->rq_daddrlen;
|
2012-07-25 06:57:06 -06:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
2008-10-03 10:50:07 -06:00
|
|
|
struct nlm_lookup_host_info ni = {
|
|
|
|
.server = 1,
|
2008-10-03 10:50:14 -06:00
|
|
|
.sap = svc_addr(rqstp),
|
|
|
|
.salen = rqstp->rq_addrlen,
|
2008-10-03 10:50:07 -06:00
|
|
|
.protocol = rqstp->rq_prot,
|
|
|
|
.version = rqstp->rq_vers,
|
|
|
|
.hostname = hostname,
|
|
|
|
.hostname_len = hostname_len,
|
2012-01-31 04:08:13 -07:00
|
|
|
.net = net,
|
2008-10-03 10:50:07 -06:00
|
|
|
};
|
2012-07-25 06:56:11 -06:00
|
|
|
struct lockd_net *ln = net_generic(net, lockd_net_id);
|
2008-10-03 10:50:07 -06:00
|
|
|
|
2018-09-28 11:41:48 -06:00
|
|
|
dprintk("lockd: %s(host='%.*s', vers=%u, proto=%s)\n", __func__,
|
2008-10-03 10:50:07 -06:00
|
|
|
(int)hostname_len, hostname, rqstp->rq_vers,
|
|
|
|
(rqstp->rq_prot == IPPROTO_UDP ? "udp" : "tcp"));
|
2007-07-09 14:25:29 -06:00
|
|
|
|
2010-12-14 08:06:12 -07:00
|
|
|
mutex_lock(&nlm_host_mutex);
|
|
|
|
|
2012-07-25 06:56:11 -06:00
|
|
|
if (time_after_eq(jiffies, ln->next_gc))
|
2012-07-25 06:56:03 -06:00
|
|
|
nlm_gc_hosts(net);
|
2010-12-14 08:06:12 -07:00
|
|
|
|
2010-12-14 08:06:22 -07:00
|
|
|
chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry(host, chain, h_hash) {
|
2012-01-31 04:08:13 -07:00
|
|
|
if (host->net != net)
|
|
|
|
continue;
|
2010-12-14 08:06:12 -07:00
|
|
|
if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Same address. Share an NSM handle if we already have one */
|
|
|
|
if (nsm == NULL)
|
|
|
|
nsm = host->h_nsmhandle;
|
|
|
|
|
|
|
|
if (host->h_proto != ni.protocol)
|
|
|
|
continue;
|
|
|
|
if (host->h_version != ni.version)
|
|
|
|
continue;
|
2010-12-14 08:06:52 -07:00
|
|
|
if (!rpc_cmp_addr(nlm_srcaddr(host), src_sap))
|
2010-12-14 08:06:12 -07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Move to head of hash chain. */
|
|
|
|
hlist_del(&host->h_hash);
|
|
|
|
hlist_add_head(&host->h_hash, chain);
|
|
|
|
|
|
|
|
nlm_get_host(host);
|
|
|
|
dprintk("lockd: %s found host %s (%s)\n",
|
|
|
|
__func__, host->h_name, host->h_addrbuf);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
host = nlm_alloc_host(&ni, nsm);
|
|
|
|
if (unlikely(host == NULL))
|
|
|
|
goto out;
|
|
|
|
|
2010-12-14 08:06:52 -07:00
|
|
|
memcpy(nlm_srcaddr(host), src_sap, src_len);
|
|
|
|
host->h_srcaddrlen = src_len;
|
2010-12-14 08:06:12 -07:00
|
|
|
hlist_add_head(&host->h_hash, chain);
|
2012-07-25 06:56:19 -06:00
|
|
|
ln->nrhosts++;
|
2010-12-14 08:06:12 -07:00
|
|
|
nrhosts++;
|
|
|
|
|
2018-01-23 17:39:04 -07:00
|
|
|
refcount_inc(&host->h_count);
|
|
|
|
|
2010-12-14 08:06:12 -07:00
|
|
|
dprintk("lockd: %s created host %s (%s)\n",
|
|
|
|
__func__, host->h_name, host->h_addrbuf);
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&nlm_host_mutex);
|
|
|
|
return host;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nlmsvc_release_host - release server nlm_host
|
|
|
|
* @host: nlm_host to release
|
|
|
|
*
|
|
|
|
* Host is destroyed later in nlm_gc_host().
|
|
|
|
*/
|
|
|
|
void nlmsvc_release_host(struct nlm_host *host)
|
|
|
|
{
|
|
|
|
if (host == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dprintk("lockd: release server host %s\n", host->h_name);
|
|
|
|
|
2012-10-15 15:26:20 -06:00
|
|
|
WARN_ON_ONCE(!host->h_server);
|
2017-11-29 04:15:43 -07:00
|
|
|
refcount_dec(&host->h_count);
|
2006-12-06 21:38:29 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Create the NLM RPC client for an NLM peer
|
|
|
|
*/
|
|
|
|
struct rpc_clnt *
|
|
|
|
nlm_bind_host(struct nlm_host *host)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt;
|
|
|
|
|
2008-12-04 12:19:53 -07:00
|
|
|
dprintk("lockd: nlm_bind_host %s (%s)\n",
|
|
|
|
host->h_name, host->h_addrbuf);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Lock host handle */
|
2006-06-09 07:40:24 -06:00
|
|
|
mutex_lock(&host->h_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* If we've already created an RPC client, check whether
|
|
|
|
* RPC rebind is required
|
|
|
|
*/
|
|
|
|
if ((clnt = host->h_rpcclnt) != NULL) {
|
2005-08-25 17:25:49 -06:00
|
|
|
if (time_after_eq(jiffies, host->h_nextrebind)) {
|
2006-01-03 01:55:50 -07:00
|
|
|
rpc_force_rebind(clnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
host->h_nextrebind = jiffies + NLM_HOST_REBIND;
|
2008-08-27 14:57:23 -06:00
|
|
|
dprintk("lockd: next rebind in %lu jiffies\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
host->h_nextrebind - jiffies);
|
|
|
|
}
|
|
|
|
} else {
|
2007-05-14 14:50:44 -06:00
|
|
|
unsigned long increment = nlmsvc_timeout;
|
2006-08-22 18:06:20 -06:00
|
|
|
struct rpc_timeout timeparms = {
|
|
|
|
.to_initval = increment,
|
|
|
|
.to_increment = increment,
|
|
|
|
.to_maxval = increment * 6UL,
|
|
|
|
.to_retries = 5U,
|
|
|
|
};
|
|
|
|
struct rpc_create_args args = {
|
2012-01-31 04:08:13 -07:00
|
|
|
.net = host->net,
|
2006-08-22 18:06:20 -06:00
|
|
|
.protocol = host->h_proto,
|
2008-09-03 12:35:39 -06:00
|
|
|
.address = nlm_addr(host),
|
|
|
|
.addrsize = host->h_addrlen,
|
2006-08-22 18:06:20 -06:00
|
|
|
.timeout = &timeparms,
|
|
|
|
.servername = host->h_name,
|
|
|
|
.program = &nlm_program,
|
|
|
|
.version = host->h_version,
|
|
|
|
.authflavor = RPC_AUTH_UNIX,
|
2008-02-06 09:34:11 -07:00
|
|
|
.flags = (RPC_CLNT_CREATE_NOPING |
|
2006-08-22 18:06:20 -06:00
|
|
|
RPC_CLNT_CREATE_AUTOBIND),
|
2019-04-24 15:46:50 -06:00
|
|
|
.cred = host->h_cred,
|
2006-08-22 18:06:20 -06:00
|
|
|
};
|
|
|
|
|
2008-02-06 09:34:11 -07:00
|
|
|
/*
|
|
|
|
* lockd retries server side blocks automatically so we want
|
|
|
|
* those to be soft RPC calls. Client side calls need to be
|
|
|
|
* hard RPC tasks.
|
|
|
|
*/
|
|
|
|
if (!host->h_server)
|
|
|
|
args.flags |= RPC_CLNT_CREATE_HARDRTRY;
|
2008-12-23 13:21:38 -07:00
|
|
|
if (host->h_noresvport)
|
|
|
|
args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
|
2010-11-02 07:11:55 -06:00
|
|
|
if (host->h_srcaddrlen)
|
|
|
|
args.saddress = nlm_srcaddr(host);
|
2008-02-06 09:34:11 -07:00
|
|
|
|
2006-08-22 18:06:20 -06:00
|
|
|
clnt = rpc_create(&args);
|
|
|
|
if (!IS_ERR(clnt))
|
|
|
|
host->h_rpcclnt = clnt;
|
|
|
|
else {
|
|
|
|
printk("lockd: couldn't create RPC handle for %s\n", host->h_name);
|
|
|
|
clnt = NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-09 07:40:24 -06:00
|
|
|
mutex_unlock(&host->h_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return clnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Force a portmap lookup of the remote lockd port
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nlm_rebind_host(struct nlm_host *host)
|
|
|
|
{
|
|
|
|
dprintk("lockd: rebind host %s\n", host->h_name);
|
|
|
|
if (host->h_rpcclnt && time_after_eq(jiffies, host->h_nextrebind)) {
|
2006-01-03 01:55:50 -07:00
|
|
|
rpc_force_rebind(host->h_rpcclnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
host->h_nextrebind = jiffies + NLM_HOST_REBIND;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Increment NLM host count
|
|
|
|
*/
|
|
|
|
struct nlm_host * nlm_get_host(struct nlm_host *host)
|
|
|
|
{
|
|
|
|
if (host) {
|
|
|
|
dprintk("lockd: get host %s\n", host->h_name);
|
2017-11-29 04:15:43 -07:00
|
|
|
refcount_inc(&host->h_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
host->h_expires = jiffies + NLM_HOST_EXPIRE;
|
|
|
|
}
|
|
|
|
return host;
|
|
|
|
}
|
|
|
|
|
2010-12-14 08:05:13 -07:00
|
|
|
static struct nlm_host *next_host_state(struct hlist_head *cache,
|
|
|
|
struct nsm_handle *nsm,
|
|
|
|
const struct nlm_reboot *info)
|
|
|
|
{
|
NLM: Fix "kernel BUG at fs/lockd/host.c:417!" or ".../host.c:283!"
Nick Bowler <nbowler@elliptictech.com> reports:
> We were just having some NFS server troubles, and my client machine
> running 2.6.38-rc1+ (specifically, commit 2b1caf6ed7b888c95) crashed
> hard (syslog output appended to this mail).
>
> I'm not sure what the exact timeline was or how to reproduce this,
> but the server was rebooted during all this. Since I've never seen
> this happen before, it is possibly a regression from previous kernel
> releases. However, I recently updated my nfs-utils (on the client) to
> version 1.2.3, so that might be related as well.
[ BUG output redacted ]
When done searching, the for_each_host loop in next_host_state() falls
through and returns the final host on the host chain without bumping
it's reference count.
Since the host's ref count is only one at that point, releasing the
host in nlm_host_rebooted() attempts to destroy the host prematurely,
and therefore hits a BUG().
Likely, the original intent of the for_each_host behavior in
next_host_state() was to handle the case when the host chain is empty.
Searching the chain and finding no suitable host to return needs to be
handled as well.
Defensively restructure next_host_state() always to return NULL when
the loop falls through.
Introduced by commit b10e30f6 "lockd: reorganize nlm_host_rebooted".
Cc: J. Bruce Fields <bfields@fieldses.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2011-01-24 13:50:26 -07:00
|
|
|
struct nlm_host *host;
|
2010-12-14 08:05:13 -07:00
|
|
|
struct hlist_head *chain;
|
|
|
|
|
|
|
|
mutex_lock(&nlm_host_mutex);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
for_each_host(host, chain, cache) {
|
2010-12-14 08:05:13 -07:00
|
|
|
if (host->h_nsmhandle == nsm
|
|
|
|
&& host->h_nsmstate != info->state) {
|
|
|
|
host->h_nsmstate = info->state;
|
|
|
|
host->h_state++;
|
|
|
|
|
|
|
|
nlm_get_host(host);
|
NLM: Fix "kernel BUG at fs/lockd/host.c:417!" or ".../host.c:283!"
Nick Bowler <nbowler@elliptictech.com> reports:
> We were just having some NFS server troubles, and my client machine
> running 2.6.38-rc1+ (specifically, commit 2b1caf6ed7b888c95) crashed
> hard (syslog output appended to this mail).
>
> I'm not sure what the exact timeline was or how to reproduce this,
> but the server was rebooted during all this. Since I've never seen
> this happen before, it is possibly a regression from previous kernel
> releases. However, I recently updated my nfs-utils (on the client) to
> version 1.2.3, so that might be related as well.
[ BUG output redacted ]
When done searching, the for_each_host loop in next_host_state() falls
through and returns the final host on the host chain without bumping
it's reference count.
Since the host's ref count is only one at that point, releasing the
host in nlm_host_rebooted() attempts to destroy the host prematurely,
and therefore hits a BUG().
Likely, the original intent of the for_each_host behavior in
next_host_state() was to handle the case when the host chain is empty.
Searching the chain and finding no suitable host to return needs to be
handled as well.
Defensively restructure next_host_state() always to return NULL when
the loop falls through.
Introduced by commit b10e30f6 "lockd: reorganize nlm_host_rebooted".
Cc: J. Bruce Fields <bfields@fieldses.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2011-01-24 13:50:26 -07:00
|
|
|
mutex_unlock(&nlm_host_mutex);
|
|
|
|
return host;
|
2010-12-14 08:05:13 -07:00
|
|
|
}
|
|
|
|
}
|
NLM: Fix "kernel BUG at fs/lockd/host.c:417!" or ".../host.c:283!"
Nick Bowler <nbowler@elliptictech.com> reports:
> We were just having some NFS server troubles, and my client machine
> running 2.6.38-rc1+ (specifically, commit 2b1caf6ed7b888c95) crashed
> hard (syslog output appended to this mail).
>
> I'm not sure what the exact timeline was or how to reproduce this,
> but the server was rebooted during all this. Since I've never seen
> this happen before, it is possibly a regression from previous kernel
> releases. However, I recently updated my nfs-utils (on the client) to
> version 1.2.3, so that might be related as well.
[ BUG output redacted ]
When done searching, the for_each_host loop in next_host_state() falls
through and returns the final host on the host chain without bumping
it's reference count.
Since the host's ref count is only one at that point, releasing the
host in nlm_host_rebooted() attempts to destroy the host prematurely,
and therefore hits a BUG().
Likely, the original intent of the for_each_host behavior in
next_host_state() was to handle the case when the host chain is empty.
Searching the chain and finding no suitable host to return needs to be
handled as well.
Defensively restructure next_host_state() always to return NULL when
the loop falls through.
Introduced by commit b10e30f6 "lockd: reorganize nlm_host_rebooted".
Cc: J. Bruce Fields <bfields@fieldses.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2011-01-24 13:50:26 -07:00
|
|
|
|
2010-12-14 08:05:13 -07:00
|
|
|
mutex_unlock(&nlm_host_mutex);
|
NLM: Fix "kernel BUG at fs/lockd/host.c:417!" or ".../host.c:283!"
Nick Bowler <nbowler@elliptictech.com> reports:
> We were just having some NFS server troubles, and my client machine
> running 2.6.38-rc1+ (specifically, commit 2b1caf6ed7b888c95) crashed
> hard (syslog output appended to this mail).
>
> I'm not sure what the exact timeline was or how to reproduce this,
> but the server was rebooted during all this. Since I've never seen
> this happen before, it is possibly a regression from previous kernel
> releases. However, I recently updated my nfs-utils (on the client) to
> version 1.2.3, so that might be related as well.
[ BUG output redacted ]
When done searching, the for_each_host loop in next_host_state() falls
through and returns the final host on the host chain without bumping
it's reference count.
Since the host's ref count is only one at that point, releasing the
host in nlm_host_rebooted() attempts to destroy the host prematurely,
and therefore hits a BUG().
Likely, the original intent of the for_each_host behavior in
next_host_state() was to handle the case when the host chain is empty.
Searching the chain and finding no suitable host to return needs to be
handled as well.
Defensively restructure next_host_state() always to return NULL when
the loop falls through.
Introduced by commit b10e30f6 "lockd: reorganize nlm_host_rebooted".
Cc: J. Bruce Fields <bfields@fieldses.org>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2011-01-24 13:50:26 -07:00
|
|
|
return NULL;
|
2010-12-14 08:05:13 -07:00
|
|
|
}
|
|
|
|
|
2008-12-05 17:03:31 -07:00
|
|
|
/**
|
|
|
|
* nlm_host_rebooted - Release all resources held by rebooted host
|
2015-09-23 06:49:29 -06:00
|
|
|
* @net: network namespace
|
2008-12-05 17:03:31 -07:00
|
|
|
* @info: pointer to decoded results of NLM_SM_NOTIFY call
|
|
|
|
*
|
|
|
|
* We were notified that the specified host has rebooted. Release
|
|
|
|
* all resources held by that peer.
|
2006-10-04 03:15:52 -06:00
|
|
|
*/
|
2015-09-23 06:49:29 -06:00
|
|
|
void nlm_host_rebooted(const struct net *net, const struct nlm_reboot *info)
|
2006-10-04 03:15:52 -06:00
|
|
|
{
|
2006-10-04 03:15:55 -06:00
|
|
|
struct nsm_handle *nsm;
|
2006-10-04 03:15:56 -06:00
|
|
|
struct nlm_host *host;
|
2006-10-04 03:15:52 -06:00
|
|
|
|
2015-09-23 06:49:29 -06:00
|
|
|
nsm = nsm_reboot_lookup(net, info);
|
2008-12-05 17:03:54 -07:00
|
|
|
if (unlikely(nsm == NULL))
|
2006-10-04 03:15:52 -06:00
|
|
|
return;
|
2006-10-04 03:15:55 -06:00
|
|
|
|
|
|
|
/* Mark all hosts tied to this NSM state as having rebooted.
|
|
|
|
* We run the loop repeatedly, because we drop the host table
|
|
|
|
* lock for this.
|
|
|
|
* To avoid processing a host several times, we match the nsmstate.
|
|
|
|
*/
|
2010-12-14 08:06:22 -07:00
|
|
|
while ((host = next_host_state(nlm_server_hosts, nsm, info)) != NULL) {
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
nlmsvc_free_host_resources(host);
|
2010-12-14 08:06:12 -07:00
|
|
|
nlmsvc_release_host(host);
|
2006-10-04 03:15:52 -06:00
|
|
|
}
|
lockd: Create client-side nlm_host cache
NFS clients don't need the garbage collection processing that is
performed on nlm_host structures. The client picks up an nlm_host at
mount time and holds a reference to it until the file system is
unmounted.
Servers, on the other hand, don't have a precise way to tell when an
nlm_host is no longer being used, so zero refcount nlm_host entries
are left to expire in the cache after a time.
Basically there's nothing holding a reference to an nlm_host between
individual server-side NLM requests, but we can't afford the expense
of recreating them for every new NLM request from a client. The
nlm_host cache adds some lifetime hysteresis to entries in the cache
so the next time a particular nlm_host is needed, it's likely to be
discovered by a lookup rather than created from whole cloth.
With the new implementation, client nlm_host cache items are no longer
garbage collected, and are destroyed directly by a new release
function specialized for client entries, nlmclnt_release_host(). They
are cached in their own data structure, and have their own lookup
logic, simplified and specialized for client nlm_host entries.
However, the client nlm_host cache still shares reboot recovery logic
with the server nlm_host cache. The NSM "peer rebooted" downcall for
clients and servers still come through the same RPC call. This is a
legacy formal API that would be difficult to alter, and besides, the
user space NSM implementation can't tell the difference between peers
that are clients or servers.
For this reason, the client cache continues to share the
nlm_host_mutex (and reboot recovery logic) with the server cache.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-14 08:05:52 -07:00
|
|
|
while ((host = next_host_state(nlm_client_hosts, nsm, info)) != NULL) {
|
|
|
|
nlmclnt_recovery(host);
|
|
|
|
nlmclnt_release_host(host);
|
|
|
|
}
|
|
|
|
|
2010-02-05 13:09:12 -07:00
|
|
|
nsm_release(nsm);
|
2006-10-04 03:15:52 -06:00
|
|
|
}
|
|
|
|
|
2012-07-25 06:56:27 -06:00
|
|
|
static void nlm_complain_hosts(struct net *net)
|
|
|
|
{
|
|
|
|
struct hlist_head *chain;
|
|
|
|
struct nlm_host *host;
|
|
|
|
|
|
|
|
if (net) {
|
|
|
|
struct lockd_net *ln = net_generic(net, lockd_net_id);
|
|
|
|
|
|
|
|
if (ln->nrhosts == 0)
|
|
|
|
return;
|
2017-11-07 22:55:55 -07:00
|
|
|
pr_warn("lockd: couldn't shutdown host module for net %x!\n",
|
|
|
|
net->ns.inum);
|
|
|
|
dprintk("lockd: %lu hosts left in net %x:\n", ln->nrhosts,
|
|
|
|
net->ns.inum);
|
2012-07-25 06:56:27 -06:00
|
|
|
} else {
|
|
|
|
if (nrhosts == 0)
|
|
|
|
return;
|
|
|
|
printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
|
|
|
|
dprintk("lockd: %lu hosts left:\n", nrhosts);
|
|
|
|
}
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
for_each_host(host, chain, nlm_server_hosts) {
|
2012-07-25 06:56:27 -06:00
|
|
|
if (net && host->net != net)
|
|
|
|
continue;
|
2017-11-07 22:55:55 -07:00
|
|
|
dprintk(" %s (cnt %d use %d exp %ld net %x)\n",
|
2017-11-29 04:15:43 -07:00
|
|
|
host->h_name, refcount_read(&host->h_count),
|
2017-11-07 22:55:55 -07:00
|
|
|
host->h_inuse, host->h_expires, host->net->ns.inum);
|
2012-07-25 06:56:27 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void
|
2012-01-31 04:08:29 -07:00
|
|
|
nlm_shutdown_hosts_net(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-10-04 03:15:56 -06:00
|
|
|
struct hlist_head *chain;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nlm_host *host;
|
|
|
|
|
2006-03-26 02:37:12 -07:00
|
|
|
mutex_lock(&nlm_host_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* First, make all hosts eligible for gc */
|
2017-11-07 22:55:55 -07:00
|
|
|
dprintk("lockd: nuking all hosts in net %x...\n",
|
|
|
|
net ? net->ns.inum : 0);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
for_each_host(host, chain, nlm_server_hosts) {
|
2012-01-31 04:08:29 -07:00
|
|
|
if (net && host->net != net)
|
|
|
|
continue;
|
2010-12-14 08:05:03 -07:00
|
|
|
host->h_expires = jiffies - 1;
|
|
|
|
if (host->h_rpcclnt) {
|
|
|
|
rpc_shutdown_client(host->h_rpcclnt);
|
|
|
|
host->h_rpcclnt = NULL;
|
2008-01-29 08:30:55 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Then, perform a garbage collection pass */
|
2012-07-25 06:56:03 -06:00
|
|
|
nlm_gc_hosts(net);
|
2012-07-25 06:56:27 -06:00
|
|
|
nlm_complain_hosts(net);
|
2017-10-30 07:47:58 -06:00
|
|
|
mutex_unlock(&nlm_host_mutex);
|
2012-01-31 04:08:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shut down the hosts module.
|
|
|
|
* Note that this routine is called only at server shutdown time.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nlm_shutdown_hosts(void)
|
|
|
|
{
|
2012-07-25 06:56:35 -06:00
|
|
|
dprintk("lockd: shutting down host module\n");
|
2012-01-31 04:08:29 -07:00
|
|
|
nlm_shutdown_hosts_net(NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Garbage collect any unused NLM hosts.
|
|
|
|
* This GC combines reference counting for async operations with
|
|
|
|
* mark & sweep for resources held by remote clients.
|
|
|
|
*/
|
|
|
|
static void
|
2012-07-25 06:56:03 -06:00
|
|
|
nlm_gc_hosts(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-10-04 03:15:56 -06:00
|
|
|
struct hlist_head *chain;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *next;
|
2006-10-04 03:15:56 -06:00
|
|
|
struct nlm_host *host;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-11-07 22:55:55 -07:00
|
|
|
dprintk("lockd: host garbage collection for net %x\n",
|
|
|
|
net ? net->ns.inum : 0);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
for_each_host(host, chain, nlm_server_hosts) {
|
2012-07-25 06:56:03 -06:00
|
|
|
if (net && host->net != net)
|
|
|
|
continue;
|
2010-12-14 08:05:03 -07:00
|
|
|
host->h_inuse = 0;
|
2012-07-25 06:56:03 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Mark all hosts that hold locks, blocks or shares */
|
2012-07-25 06:55:54 -06:00
|
|
|
nlmsvc_mark_resources(net);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
for_each_host_safe(host, next, chain, nlm_server_hosts) {
|
2012-07-25 06:56:03 -06:00
|
|
|
if (net && host->net != net)
|
|
|
|
continue;
|
2018-01-23 17:39:04 -07:00
|
|
|
if (host->h_inuse || time_before(jiffies, host->h_expires)) {
|
2010-12-14 08:05:03 -07:00
|
|
|
dprintk("nlm_gc_hosts skipping %s "
|
2017-11-07 22:55:55 -07:00
|
|
|
"(cnt %d use %d exp %ld net %x)\n",
|
2017-11-29 04:15:43 -07:00
|
|
|
host->h_name, refcount_read(&host->h_count),
|
2017-11-07 22:55:55 -07:00
|
|
|
host->h_inuse, host->h_expires,
|
|
|
|
host->net->ns.inum);
|
2010-12-14 08:05:03 -07:00
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2018-01-23 17:39:04 -07:00
|
|
|
if (refcount_dec_if_one(&host->h_count))
|
|
|
|
nlm_destroy_host_locked(host);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-07-25 06:56:11 -06:00
|
|
|
if (net) {
|
|
|
|
struct lockd_net *ln = net_generic(net, lockd_net_id);
|
|
|
|
|
|
|
|
ln->next_gc = jiffies + NLM_HOST_COLLECT;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|