diff options
author | Trond Myklebust <Trond.Myklebust@netapp.com> | 2009-09-11 14:59:37 -0400 |
---|---|---|
committer | Trond Myklebust <Trond.Myklebust@netapp.com> | 2009-09-11 14:59:37 -0400 |
commit | ab3bbaa8b257845e248e9a01d12a69ca245f4197 (patch) | |
tree | f3054be9bd612194826ed6969d01346d329c3306 | |
parent | 332a3392188e0ad966543c87b8da2b9d246f301d (diff) | |
parent | 2ecda72b49a0849ce41e7fa1fa974a245b9119f8 (diff) |
Merge branch 'nfs-for-2.6.32'
48 files changed, 4064 insertions, 1805 deletions
diff --git a/Documentation/filesystems/nfs.txt b/Documentation/filesystems/nfs.txt new file mode 100644 index 000000000000..f50f26ce6cd0 --- /dev/null +++ b/Documentation/filesystems/nfs.txt | |||
@@ -0,0 +1,98 @@ | |||
1 | |||
2 | The NFS client | ||
3 | ============== | ||
4 | |||
5 | The NFS version 2 protocol was first documented in RFC1094 (March 1989). | ||
6 | Since then two more major releases of NFS have been published, with NFSv3 | ||
7 | being documented in RFC1813 (June 1995), and NFSv4 in RFC3530 (April | ||
8 | 2003). | ||
9 | |||
10 | The Linux NFS client currently supports all the above published versions, | ||
11 | and work is in progress on adding support for minor version 1 of the NFSv4 | ||
12 | protocol. | ||
13 | |||
14 | The purpose of this document is to provide information on some of the | ||
15 | upcall interfaces that are used in order to provide the NFS client with | ||
16 | some of the information that it requires in order to fully comply with | ||
17 | the NFS spec. | ||
18 | |||
19 | The DNS resolver | ||
20 | ================ | ||
21 | |||
22 | NFSv4 allows for one server to refer the NFS client to data that has been | ||
23 | migrated onto another server by means of the special "fs_locations" | ||
24 | attribute. See | ||
25 | http://tools.ietf.org/html/rfc3530#section-6 | ||
26 | and | ||
27 | http://tools.ietf.org/html/draft-ietf-nfsv4-referrals-00 | ||
28 | |||
29 | The fs_locations information can take the form of either an ip address and | ||
30 | a path, or a DNS hostname and a path. The latter requires the NFS client to | ||
31 | do a DNS lookup in order to mount the new volume, and hence the need for an | ||
32 | upcall to allow userland to provide this service. | ||
33 | |||
34 | Assuming that the user has the 'rpc_pipefs' filesystem mounted in the usual | ||
35 | /var/lib/nfs/rpc_pipefs, the upcall consists of the following steps: | ||
36 | |||
37 | (1) The process checks the dns_resolve cache to see if it contains a | ||
38 | valid entry. If so, it returns that entry and exits. | ||
39 | |||
40 | (2) If no valid entry exists, the helper script '/sbin/nfs_cache_getent' | ||
41 | (may be changed using the 'nfs.cache_getent' kernel boot parameter) | ||
42 | is run, with two arguments: | ||
43 | - the cache name, "dns_resolve" | ||
44 | - the hostname to resolve | ||
45 | |||
46 | (3) After looking up the corresponding ip address, the helper script | ||
47 | writes the result into the rpc_pipefs pseudo-file | ||
48 | '/var/lib/nfs/rpc_pipefs/cache/dns_resolve/channel' | ||
49 | in the following (text) format: | ||
50 | |||
51 | "<ip address> <hostname> <ttl>\n" | ||
52 | |||
53 | Where <ip address> is in the usual IPv4 (123.456.78.90) or IPv6 | ||
54 | (ffee:ddcc:bbaa:9988:7766:5544:3322:1100, ffee::1100, ...) format. | ||
55 | <hostname> is identical to the second argument of the helper | ||
56 | script, and <ttl> is the 'time to live' of this cache entry (in | ||
57 | units of seconds). | ||
58 | |||
59 | Note: If <ip address> is invalid, say the string "0", then a negative | ||
60 | entry is created, which will cause the kernel to treat the hostname | ||
61 | as having no valid DNS translation. | ||
62 | |||
63 | |||
64 | |||
65 | |||
66 | A basic sample /sbin/nfs_cache_getent | ||
67 | ===================================== | ||
68 | |||
69 | #!/bin/bash | ||
70 | # | ||
71 | ttl=600 | ||
72 | # | ||
73 | cut=/usr/bin/cut | ||
74 | getent=/usr/bin/getent | ||
75 | rpc_pipefs=/var/lib/nfs/rpc_pipefs | ||
76 | # | ||
77 | die() | ||
78 | { | ||
79 | echo "Usage: $0 cache_name entry_name" | ||
80 | exit 1 | ||
81 | } | ||
82 | |||
83 | [ $# -lt 2 ] && die | ||
84 | cachename="$1" | ||
85 | cache_path=${rpc_pipefs}/cache/${cachename}/channel | ||
86 | |||
87 | case "${cachename}" in | ||
88 | dns_resolve) | ||
89 | name="$2" | ||
90 | result="$(${getent} hosts ${name} | ${cut} -f1 -d\ )" | ||
91 | [ -z "${result}" ] && result="0" | ||
92 | ;; | ||
93 | *) | ||
94 | die | ||
95 | ;; | ||
96 | esac | ||
97 | echo "${result} ${name} ${ttl}" >${cache_path} | ||
98 | |||
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index 7936b801fe6a..ce8853755814 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt | |||
@@ -1503,6 +1503,14 @@ and is between 256 and 4096 characters. It is defined in the file | |||
1503 | [NFS] set the TCP port on which the NFSv4 callback | 1503 | [NFS] set the TCP port on which the NFSv4 callback |
1504 | channel should listen. | 1504 | channel should listen. |
1505 | 1505 | ||
1506 | nfs.cache_getent= | ||
1507 | [NFS] sets the pathname to the program which is used | ||
1508 | to update the NFS client cache entries. | ||
1509 | |||
1510 | nfs.cache_getent_timeout= | ||
1511 | [NFS] sets the timeout after which an attempt to | ||
1512 | update a cache entry is deemed to have failed. | ||
1513 | |||
1506 | nfs.idmap_cache_timeout= | 1514 | nfs.idmap_cache_timeout= |
1507 | [NFS] set the maximum lifetime for idmapper cache | 1515 | [NFS] set the maximum lifetime for idmapper cache |
1508 | entries. | 1516 | entries. |
@@ -2395,6 +2403,18 @@ and is between 256 and 4096 characters. It is defined in the file | |||
2395 | stifb= [HW] | 2403 | stifb= [HW] |
2396 | Format: bpp:<bpp1>[:<bpp2>[:<bpp3>...]] | 2404 | Format: bpp:<bpp1>[:<bpp2>[:<bpp3>...]] |
2397 | 2405 | ||
2406 | sunrpc.min_resvport= | ||
2407 | sunrpc.max_resvport= | ||
2408 | [NFS,SUNRPC] | ||
2409 | SunRPC servers often require that client requests | ||
2410 | originate from a privileged port (i.e. a port in the | ||
2411 | range 0 < portnr < 1024). | ||
2412 | An administrator who wishes to reserve some of these | ||
2413 | ports for other uses may adjust the range that the | ||
2414 | kernel's sunrpc client considers to be privileged | ||
2415 | using these two parameters to set the minimum and | ||
2416 | maximum port values. | ||
2417 | |||
2398 | sunrpc.pool_mode= | 2418 | sunrpc.pool_mode= |
2399 | [NFS] | 2419 | [NFS] |
2400 | Control how the NFS server code allocates CPUs to | 2420 | Control how the NFS server code allocates CPUs to |
@@ -2411,6 +2431,15 @@ and is between 256 and 4096 characters. It is defined in the file | |||
2411 | pernode one pool for each NUMA node (equivalent | 2431 | pernode one pool for each NUMA node (equivalent |
2412 | to global on non-NUMA machines) | 2432 | to global on non-NUMA machines) |
2413 | 2433 | ||
2434 | sunrpc.tcp_slot_table_entries= | ||
2435 | sunrpc.udp_slot_table_entries= | ||
2436 | [NFS,SUNRPC] | ||
2437 | Sets the upper limit on the number of simultaneous | ||
2438 | RPC calls that can be sent from the client to a | ||
2439 | server. Increasing these values may allow you to | ||
2440 | improve throughput, but will also increase the | ||
2441 | amount of memory reserved for use by the client. | ||
2442 | |||
2414 | swiotlb= [IA-64] Number of I/O TLB slabs | 2443 | swiotlb= [IA-64] Number of I/O TLB slabs |
2415 | 2444 | ||
2416 | switches= [HW,M68k] | 2445 | switches= [HW,M68k] |
diff --git a/fs/lockd/host.c b/fs/lockd/host.c index 99d737bd4325..7cb076ac6b45 100644 --- a/fs/lockd/host.c +++ b/fs/lockd/host.c | |||
@@ -87,18 +87,6 @@ static unsigned int nlm_hash_address(const struct sockaddr *sap) | |||
87 | return hash & (NLM_HOST_NRHASH - 1); | 87 | return hash & (NLM_HOST_NRHASH - 1); |
88 | } | 88 | } |
89 | 89 | ||
90 | static void nlm_clear_port(struct sockaddr *sap) | ||
91 | { | ||
92 | switch (sap->sa_family) { | ||
93 | case AF_INET: | ||
94 | ((struct sockaddr_in *)sap)->sin_port = 0; | ||
95 | break; | ||
96 | case AF_INET6: | ||
97 | ((struct sockaddr_in6 *)sap)->sin6_port = 0; | ||
98 | break; | ||
99 | } | ||
100 | } | ||
101 | |||
102 | /* | 90 | /* |
103 | * Common host lookup routine for server & client | 91 | * Common host lookup routine for server & client |
104 | */ | 92 | */ |
@@ -177,7 +165,7 @@ static struct nlm_host *nlm_lookup_host(struct nlm_lookup_host_info *ni) | |||
177 | host->h_addrbuf = nsm->sm_addrbuf; | 165 | host->h_addrbuf = nsm->sm_addrbuf; |
178 | memcpy(nlm_addr(host), ni->sap, ni->salen); | 166 | memcpy(nlm_addr(host), ni->sap, ni->salen); |
179 | host->h_addrlen = ni->salen; | 167 | host->h_addrlen = ni->salen; |
180 | nlm_clear_port(nlm_addr(host)); | 168 | rpc_set_port(nlm_addr(host), 0); |
181 | memcpy(nlm_srcaddr(host), ni->src_sap, ni->src_len); | 169 | memcpy(nlm_srcaddr(host), ni->src_sap, ni->src_len); |
182 | host->h_version = ni->version; | 170 | host->h_version = ni->version; |
183 | host->h_proto = ni->protocol; | 171 | host->h_proto = ni->protocol; |
diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c index 7fce1b525849..30c933188dd7 100644 --- a/fs/lockd/mon.c +++ b/fs/lockd/mon.c | |||
@@ -61,43 +61,6 @@ static inline struct sockaddr *nsm_addr(const struct nsm_handle *nsm) | |||
61 | return (struct sockaddr *)&nsm->sm_addr; | 61 | return (struct sockaddr *)&nsm->sm_addr; |
62 | } | 62 | } |
63 | 63 | ||
64 | static void nsm_display_ipv4_address(const struct sockaddr *sap, char *buf, | ||
65 | const size_t len) | ||
66 | { | ||
67 | const struct sockaddr_in *sin = (struct sockaddr_in *)sap; | ||
68 | snprintf(buf, len, "%pI4", &sin->sin_addr.s_addr); | ||
69 | } | ||
70 | |||
71 | static void nsm_display_ipv6_address(const struct sockaddr *sap, char *buf, | ||
72 | const size_t len) | ||
73 | { | ||
74 | const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; | ||
75 | |||
76 | if (ipv6_addr_v4mapped(&sin6->sin6_addr)) | ||
77 | snprintf(buf, len, "%pI4", &sin6->sin6_addr.s6_addr32[3]); | ||
78 | else if (sin6->sin6_scope_id != 0) | ||
79 | snprintf(buf, len, "%pI6%%%u", &sin6->sin6_addr, | ||
80 | sin6->sin6_scope_id); | ||
81 | else | ||
82 | snprintf(buf, len, "%pI6", &sin6->sin6_addr); | ||
83 | } | ||
84 | |||
85 | static void nsm_display_address(const struct sockaddr *sap, | ||
86 | char *buf, const size_t len) | ||
87 | { | ||
88 | switch (sap->sa_family) { | ||
89 | case AF_INET: | ||
90 | nsm_display_ipv4_address(sap, buf, len); | ||
91 | break; | ||
92 | case AF_INET6: | ||
93 | nsm_display_ipv6_address(sap, buf, len); | ||
94 | break; | ||
95 | default: | ||
96 | snprintf(buf, len, "unsupported address family"); | ||
97 | break; | ||
98 | } | ||
99 | } | ||
100 | |||
101 | static struct rpc_clnt *nsm_create(void) | 64 | static struct rpc_clnt *nsm_create(void) |
102 | { | 65 | { |
103 | struct sockaddr_in sin = { | 66 | struct sockaddr_in sin = { |
@@ -307,8 +270,11 @@ static struct nsm_handle *nsm_create_handle(const struct sockaddr *sap, | |||
307 | memcpy(nsm_addr(new), sap, salen); | 270 | memcpy(nsm_addr(new), sap, salen); |
308 | new->sm_addrlen = salen; | 271 | new->sm_addrlen = salen; |
309 | nsm_init_private(new); | 272 | nsm_init_private(new); |
310 | nsm_display_address((const struct sockaddr *)&new->sm_addr, | 273 | |
311 | new->sm_addrbuf, sizeof(new->sm_addrbuf)); | 274 | if (rpc_ntop(nsm_addr(new), new->sm_addrbuf, |
275 | sizeof(new->sm_addrbuf)) == 0) | ||
276 | (void)snprintf(new->sm_addrbuf, sizeof(new->sm_addrbuf), | ||
277 | "unsupported address family"); | ||
312 | memcpy(new->sm_name, hostname, hostname_len); | 278 | memcpy(new->sm_name, hostname, hostname_len); |
313 | new->sm_name[hostname_len] = '\0'; | 279 | new->sm_name[hostname_len] = '\0'; |
314 | 280 | ||
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile index 845159814de2..da7fda639eac 100644 --- a/fs/nfs/Makefile +++ b/fs/nfs/Makefile | |||
@@ -6,7 +6,8 @@ obj-$(CONFIG_NFS_FS) += nfs.o | |||
6 | 6 | ||
7 | nfs-y := client.o dir.o file.o getroot.o inode.o super.o nfs2xdr.o \ | 7 | nfs-y := client.o dir.o file.o getroot.o inode.o super.o nfs2xdr.o \ |
8 | direct.o pagelist.o proc.o read.o symlink.o unlink.o \ | 8 | direct.o pagelist.o proc.o read.o symlink.o unlink.o \ |
9 | write.o namespace.o mount_clnt.o | 9 | write.o namespace.o mount_clnt.o \ |
10 | dns_resolve.o cache_lib.o | ||
10 | nfs-$(CONFIG_ROOT_NFS) += nfsroot.o | 11 | nfs-$(CONFIG_ROOT_NFS) += nfsroot.o |
11 | nfs-$(CONFIG_NFS_V3) += nfs3proc.o nfs3xdr.o | 12 | nfs-$(CONFIG_NFS_V3) += nfs3proc.o nfs3xdr.o |
12 | nfs-$(CONFIG_NFS_V3_ACL) += nfs3acl.o | 13 | nfs-$(CONFIG_NFS_V3_ACL) += nfs3acl.o |
diff --git a/fs/nfs/cache_lib.c b/fs/nfs/cache_lib.c new file mode 100644 index 000000000000..b4ffd0146ea6 --- /dev/null +++ b/fs/nfs/cache_lib.c | |||
@@ -0,0 +1,140 @@ | |||
1 | /* | ||
2 | * linux/fs/nfs/cache_lib.c | ||
3 | * | ||
4 | * Helper routines for the NFS client caches | ||
5 | * | ||
6 | * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com> | ||
7 | */ | ||
8 | #include <linux/kmod.h> | ||
9 | #include <linux/module.h> | ||
10 | #include <linux/moduleparam.h> | ||
11 | #include <linux/mount.h> | ||
12 | #include <linux/namei.h> | ||
13 | #include <linux/sunrpc/cache.h> | ||
14 | #include <linux/sunrpc/rpc_pipe_fs.h> | ||
15 | |||
16 | #include "cache_lib.h" | ||
17 | |||
18 | #define NFS_CACHE_UPCALL_PATHLEN 256 | ||
19 | #define NFS_CACHE_UPCALL_TIMEOUT 15 | ||
20 | |||
21 | static char nfs_cache_getent_prog[NFS_CACHE_UPCALL_PATHLEN] = | ||
22 | "/sbin/nfs_cache_getent"; | ||
23 | static unsigned long nfs_cache_getent_timeout = NFS_CACHE_UPCALL_TIMEOUT; | ||
24 | |||
25 | module_param_string(cache_getent, nfs_cache_getent_prog, | ||
26 | sizeof(nfs_cache_getent_prog), 0600); | ||
27 | MODULE_PARM_DESC(cache_getent, "Path to the client cache upcall program"); | ||
28 | module_param_named(cache_getent_timeout, nfs_cache_getent_timeout, ulong, 0600); | ||
29 | MODULE_PARM_DESC(cache_getent_timeout, "Timeout (in seconds) after which " | ||
30 | "the cache upcall is assumed to have failed"); | ||
31 | |||
32 | int nfs_cache_upcall(struct cache_detail *cd, char *entry_name) | ||
33 | { | ||
34 | static char *envp[] = { "HOME=/", | ||
35 | "TERM=linux", | ||
36 | "PATH=/sbin:/usr/sbin:/bin:/usr/bin", | ||
37 | NULL | ||
38 | }; | ||
39 | char *argv[] = { | ||
40 | nfs_cache_getent_prog, | ||
41 | cd->name, | ||
42 | entry_name, | ||
43 | NULL | ||
44 | }; | ||
45 | int ret = -EACCES; | ||
46 | |||
47 | if (nfs_cache_getent_prog[0] == '\0') | ||
48 | goto out; | ||
49 | ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); | ||
50 | /* | ||
51 | * Disable the upcall mechanism if we're getting an ENOENT or | ||
52 | * EACCES error. The admin can re-enable it on the fly by using | ||
53 | * sysfs to set the 'cache_getent' parameter once the problem | ||
54 | * has been fixed. | ||
55 | */ | ||
56 | if (ret == -ENOENT || ret == -EACCES) | ||
57 | nfs_cache_getent_prog[0] = '\0'; | ||
58 | out: | ||
59 | return ret > 0 ? 0 : ret; | ||
60 | } | ||
61 | |||
62 | /* | ||
63 | * Deferred request handling | ||
64 | */ | ||
65 | void nfs_cache_defer_req_put(struct nfs_cache_defer_req *dreq) | ||
66 | { | ||
67 | if (atomic_dec_and_test(&dreq->count)) | ||
68 | kfree(dreq); | ||
69 | } | ||
70 | |||
71 | static void nfs_dns_cache_revisit(struct cache_deferred_req *d, int toomany) | ||
72 | { | ||
73 | struct nfs_cache_defer_req *dreq; | ||
74 | |||
75 | dreq = container_of(d, struct nfs_cache_defer_req, deferred_req); | ||
76 | |||
77 | complete_all(&dreq->completion); | ||
78 | nfs_cache_defer_req_put(dreq); | ||
79 | } | ||
80 | |||
81 | static struct cache_deferred_req *nfs_dns_cache_defer(struct cache_req *req) | ||
82 | { | ||
83 | struct nfs_cache_defer_req *dreq; | ||
84 | |||
85 | dreq = container_of(req, struct nfs_cache_defer_req, req); | ||
86 | dreq->deferred_req.revisit = nfs_dns_cache_revisit; | ||
87 | atomic_inc(&dreq->count); | ||
88 | |||
89 | return &dreq->deferred_req; | ||
90 | } | ||
91 | |||
92 | struct nfs_cache_defer_req *nfs_cache_defer_req_alloc(void) | ||
93 | { | ||
94 | struct nfs_cache_defer_req *dreq; | ||
95 | |||
96 | dreq = kzalloc(sizeof(*dreq), GFP_KERNEL); | ||
97 | if (dreq) { | ||
98 | init_completion(&dreq->completion); | ||
99 | atomic_set(&dreq->count, 1); | ||
100 | dreq->req.defer = nfs_dns_cache_defer; | ||
101 | } | ||
102 | return dreq; | ||
103 | } | ||
104 | |||
105 | int nfs_cache_wait_for_upcall(struct nfs_cache_defer_req *dreq) | ||
106 | { | ||
107 | if (wait_for_completion_timeout(&dreq->completion, | ||
108 | nfs_cache_getent_timeout * HZ) == 0) | ||
109 | return -ETIMEDOUT; | ||
110 | return 0; | ||
111 | } | ||
112 | |||
113 | int nfs_cache_register(struct cache_detail *cd) | ||
114 | { | ||
115 | struct nameidata nd; | ||
116 | struct vfsmount *mnt; | ||
117 | int ret; | ||
118 | |||
119 | mnt = rpc_get_mount(); | ||
120 | if (IS_ERR(mnt)) | ||
121 | return PTR_ERR(mnt); | ||
122 | ret = vfs_path_lookup(mnt->mnt_root, mnt, "/cache", 0, &nd); | ||
123 | if (ret) | ||
124 | goto err; | ||
125 | ret = sunrpc_cache_register_pipefs(nd.path.dentry, | ||
126 | cd->name, 0600, cd); | ||
127 | path_put(&nd.path); | ||
128 | if (!ret) | ||
129 | return ret; | ||
130 | err: | ||
131 | rpc_put_mount(); | ||
132 | return ret; | ||
133 | } | ||
134 | |||
135 | void nfs_cache_unregister(struct cache_detail *cd) | ||
136 | { | ||
137 | sunrpc_cache_unregister_pipefs(cd); | ||
138 | rpc_put_mount(); | ||
139 | } | ||
140 | |||
diff --git a/fs/nfs/cache_lib.h b/fs/nfs/cache_lib.h new file mode 100644 index 000000000000..76f856e284e4 --- /dev/null +++ b/fs/nfs/cache_lib.h | |||
@@ -0,0 +1,27 @@ | |||
1 | /* | ||
2 | * Helper routines for the NFS client caches | ||
3 | * | ||
4 | * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com> | ||
5 | */ | ||
6 | |||
7 | #include <linux/completion.h> | ||
8 | #include <linux/sunrpc/cache.h> | ||
9 | #include <asm/atomic.h> | ||
10 | |||
11 | /* | ||
12 | * Deferred request handling | ||
13 | */ | ||
14 | struct nfs_cache_defer_req { | ||
15 | struct cache_req req; | ||
16 | struct cache_deferred_req deferred_req; | ||
17 | struct completion completion; | ||
18 | atomic_t count; | ||
19 | }; | ||
20 | |||
21 | extern int nfs_cache_upcall(struct cache_detail *cd, char *entry_name); | ||
22 | extern struct nfs_cache_defer_req *nfs_cache_defer_req_alloc(void); | ||
23 | extern void nfs_cache_defer_req_put(struct nfs_cache_defer_req *dreq); | ||
24 | extern int nfs_cache_wait_for_upcall(struct nfs_cache_defer_req *dreq); | ||
25 | |||
26 | extern int nfs_cache_register(struct cache_detail *cd); | ||
27 | extern void nfs_cache_unregister(struct cache_detail *cd); | ||
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c index 7f604c7941fb..293fa0528a6e 100644 --- a/fs/nfs/callback.c +++ b/fs/nfs/callback.c | |||
@@ -43,21 +43,29 @@ static struct svc_program nfs4_callback_program; | |||
43 | unsigned int nfs_callback_set_tcpport; | 43 | unsigned int nfs_callback_set_tcpport; |
44 | unsigned short nfs_callback_tcpport; | 44 | unsigned short nfs_callback_tcpport; |
45 | unsigned short nfs_callback_tcpport6; | 45 | unsigned short nfs_callback_tcpport6; |
46 | static const int nfs_set_port_min = 0; | 46 | #define NFS_CALLBACK_MAXPORTNR (65535U) |
47 | static const int nfs_set_port_max = 65535; | ||
48 | 47 | ||
49 | static int param_set_port(const char *val, struct kernel_param *kp) | 48 | static int param_set_portnr(const char *val, struct kernel_param *kp) |
50 | { | 49 | { |
51 | char *endp; | 50 | unsigned long num; |
52 | int num = simple_strtol(val, &endp, 0); | 51 | int ret; |
53 | if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max) | 52 | |
53 | if (!val) | ||
54 | return -EINVAL; | ||
55 | ret = strict_strtoul(val, 0, &num); | ||
56 | if (ret == -EINVAL || num > NFS_CALLBACK_MAXPORTNR) | ||
54 | return -EINVAL; | 57 | return -EINVAL; |
55 | *((int *)kp->arg) = num; | 58 | *((unsigned int *)kp->arg) = num; |
56 | return 0; | 59 | return 0; |
57 | } | 60 | } |
58 | 61 | ||
59 | module_param_call(callback_tcpport, param_set_port, param_get_int, | 62 | static int param_get_portnr(char *buffer, struct kernel_param *kp) |
60 | &nfs_callback_set_tcpport, 0644); | 63 | { |
64 | return param_get_uint(buffer, kp); | ||
65 | } | ||
66 | #define param_check_portnr(name, p) __param_check(name, p, unsigned int); | ||
67 | |||
68 | module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644); | ||
61 | 69 | ||
62 | /* | 70 | /* |
63 | * This is the NFSv4 callback kernel thread. | 71 | * This is the NFSv4 callback kernel thread. |
diff --git a/fs/nfs/client.c b/fs/nfs/client.c index c6be84a161f6..e350bd6a2334 100644 --- a/fs/nfs/client.c +++ b/fs/nfs/client.c | |||
@@ -809,6 +809,9 @@ static int nfs_init_server(struct nfs_server *server, | |||
809 | /* Initialise the client representation from the mount data */ | 809 | /* Initialise the client representation from the mount data */ |
810 | server->flags = data->flags; | 810 | server->flags = data->flags; |
811 | server->options = data->options; | 811 | server->options = data->options; |
812 | server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID| | ||
813 | NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP| | ||
814 | NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME; | ||
812 | 815 | ||
813 | if (data->rsize) | 816 | if (data->rsize) |
814 | server->rsize = nfs_block_size(data->rsize, NULL); | 817 | server->rsize = nfs_block_size(data->rsize, NULL); |
@@ -1075,10 +1078,6 @@ struct nfs_server *nfs_create_server(const struct nfs_parsed_mount_data *data, | |||
1075 | (unsigned long long) server->fsid.major, | 1078 | (unsigned long long) server->fsid.major, |
1076 | (unsigned long long) server->fsid.minor); | 1079 | (unsigned long long) server->fsid.minor); |
1077 | 1080 | ||
1078 | BUG_ON(!server->nfs_client); | ||
1079 | BUG_ON(!server->nfs_client->rpc_ops); | ||
1080 | BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops); | ||
1081 | |||
1082 | spin_lock(&nfs_client_lock); | 1081 | spin_lock(&nfs_client_lock); |
1083 | list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks); | 1082 | list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks); |
1084 | list_add_tail(&server->master_link, &nfs_volume_list); | 1083 | list_add_tail(&server->master_link, &nfs_volume_list); |
@@ -1275,7 +1274,7 @@ static int nfs4_init_server(struct nfs_server *server, | |||
1275 | 1274 | ||
1276 | /* Initialise the client representation from the mount data */ | 1275 | /* Initialise the client representation from the mount data */ |
1277 | server->flags = data->flags; | 1276 | server->flags = data->flags; |
1278 | server->caps |= NFS_CAP_ATOMIC_OPEN; | 1277 | server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR; |
1279 | server->options = data->options; | 1278 | server->options = data->options; |
1280 | 1279 | ||
1281 | /* Get a client record */ | 1280 | /* Get a client record */ |
@@ -1360,10 +1359,6 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data, | |||
1360 | if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN) | 1359 | if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN) |
1361 | server->namelen = NFS4_MAXNAMLEN; | 1360 | server->namelen = NFS4_MAXNAMLEN; |
1362 | 1361 | ||
1363 | BUG_ON(!server->nfs_client); | ||
1364 | BUG_ON(!server->nfs_client->rpc_ops); | ||
1365 | BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops); | ||
1366 | |||
1367 | spin_lock(&nfs_client_lock); | 1362 | spin_lock(&nfs_client_lock); |
1368 | list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks); | 1363 | list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks); |
1369 | list_add_tail(&server->master_link, &nfs_volume_list); | 1364 | list_add_tail(&server->master_link, &nfs_volume_list); |
@@ -1401,7 +1396,7 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data, | |||
1401 | 1396 | ||
1402 | /* Initialise the client representation from the parent server */ | 1397 | /* Initialise the client representation from the parent server */ |
1403 | nfs_server_copy_userdata(server, parent_server); | 1398 | nfs_server_copy_userdata(server, parent_server); |
1404 | server->caps |= NFS_CAP_ATOMIC_OPEN; | 1399 | server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR; |
1405 | 1400 | ||
1406 | /* Get a client representation. | 1401 | /* Get a client representation. |
1407 | * Note: NFSv4 always uses TCP, */ | 1402 | * Note: NFSv4 always uses TCP, */ |
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c index e4e089a8f294..6c3210099d51 100644 --- a/fs/nfs/direct.c +++ b/fs/nfs/direct.c | |||
@@ -934,9 +934,6 @@ out: | |||
934 | * back into its cache. We let the server do generic write | 934 | * back into its cache. We let the server do generic write |
935 | * parameter checking and report problems. | 935 | * parameter checking and report problems. |
936 | * | 936 | * |
937 | * We also avoid an unnecessary invocation of generic_osync_inode(), | ||
938 | * as it is fairly meaningless to sync the metadata of an NFS file. | ||
939 | * | ||
940 | * We eliminate local atime updates, see direct read above. | 937 | * We eliminate local atime updates, see direct read above. |
941 | * | 938 | * |
942 | * We avoid unnecessary page cache invalidations for normal cached | 939 | * We avoid unnecessary page cache invalidations for normal cached |
diff --git a/fs/nfs/dns_resolve.c b/fs/nfs/dns_resolve.c new file mode 100644 index 000000000000..f4d54ba97cc6 --- /dev/null +++ b/fs/nfs/dns_resolve.c | |||
@@ -0,0 +1,335 @@ | |||
1 | /* | ||
2 | * linux/fs/nfs/dns_resolve.c | ||
3 | * | ||
4 | * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com> | ||
5 | * | ||
6 | * Resolves DNS hostnames into valid ip addresses | ||
7 | */ | ||
8 | |||
9 | #include <linux/hash.h> | ||
10 | #include <linux/string.h> | ||
11 | #include <linux/kmod.h> | ||
12 | #include <linux/module.h> | ||
13 | #include <linux/socket.h> | ||
14 | #include <linux/seq_file.h> | ||
15 | #include <linux/inet.h> | ||
16 | #include <linux/sunrpc/clnt.h> | ||
17 | #include <linux/sunrpc/cache.h> | ||
18 | #include <linux/sunrpc/svcauth.h> | ||
19 | |||
20 | #include "dns_resolve.h" | ||
21 | #include "cache_lib.h" | ||
22 | |||
23 | #define NFS_DNS_HASHBITS 4 | ||
24 | #define NFS_DNS_HASHTBL_SIZE (1 << NFS_DNS_HASHBITS) | ||
25 | |||
26 | static struct cache_head *nfs_dns_table[NFS_DNS_HASHTBL_SIZE]; | ||
27 | |||
28 | struct nfs_dns_ent { | ||
29 | struct cache_head h; | ||
30 | |||
31 | char *hostname; | ||
32 | size_t namelen; | ||
33 | |||
34 | struct sockaddr_storage addr; | ||
35 | size_t addrlen; | ||
36 | }; | ||
37 | |||
38 | |||
39 | static void nfs_dns_ent_init(struct cache_head *cnew, | ||
40 | struct cache_head *ckey) | ||
41 | { | ||
42 | struct nfs_dns_ent *new; | ||
43 | struct nfs_dns_ent *key; | ||
44 | |||
45 | new = container_of(cnew, struct nfs_dns_ent, h); | ||
46 | key = container_of(ckey, struct nfs_dns_ent, h); | ||
47 | |||
48 | kfree(new->hostname); | ||
49 | new->hostname = kstrndup(key->hostname, key->namelen, GFP_KERNEL); | ||
50 | if (new->hostname) { | ||
51 | new->namelen = key->namelen; | ||
52 | memcpy(&new->addr, &key->addr, key->addrlen); | ||
53 | new->addrlen = key->addrlen; | ||
54 | } else { | ||
55 | new->namelen = 0; | ||
56 | new->addrlen = 0; | ||
57 | } | ||
58 | } | ||
59 | |||
60 | static void nfs_dns_ent_put(struct kref *ref) | ||
61 | { | ||
62 | struct nfs_dns_ent *item; | ||
63 | |||
64 | item = container_of(ref, struct nfs_dns_ent, h.ref); | ||
65 | kfree(item->hostname); | ||
66 | kfree(item); | ||
67 | } | ||
68 | |||
69 | static struct cache_head *nfs_dns_ent_alloc(void) | ||
70 | { | ||
71 | struct nfs_dns_ent *item = kmalloc(sizeof(*item), GFP_KERNEL); | ||
72 | |||
73 | if (item != NULL) { | ||
74 | item->hostname = NULL; | ||
75 | item->namelen = 0; | ||
76 | item->addrlen = 0; | ||
77 | return &item->h; | ||
78 | } | ||
79 | return NULL; | ||
80 | }; | ||
81 | |||
82 | static unsigned int nfs_dns_hash(const struct nfs_dns_ent *key) | ||
83 | { | ||
84 | return hash_str(key->hostname, NFS_DNS_HASHBITS); | ||
85 | } | ||
86 | |||
87 | static void nfs_dns_request(struct cache_detail *cd, | ||
88 | struct cache_head *ch, | ||
89 | char **bpp, int *blen) | ||
90 | { | ||
91 | struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h); | ||
92 | |||
93 | qword_add(bpp, blen, key->hostname); | ||
94 | (*bpp)[-1] = '\n'; | ||
95 | } | ||
96 | |||
97 | static int nfs_dns_upcall(struct cache_detail *cd, | ||
98 | struct cache_head *ch) | ||
99 | { | ||
100 | struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h); | ||
101 | int ret; | ||
102 | |||
103 | ret = nfs_cache_upcall(cd, key->hostname); | ||
104 | if (ret) | ||
105 | ret = sunrpc_cache_pipe_upcall(cd, ch, nfs_dns_request); | ||
106 | return ret; | ||
107 | } | ||
108 | |||
109 | static int nfs_dns_match(struct cache_head *ca, | ||
110 | struct cache_head *cb) | ||
111 | { | ||
112 | struct nfs_dns_ent *a; | ||
113 | struct nfs_dns_ent *b; | ||
114 | |||
115 | a = container_of(ca, struct nfs_dns_ent, h); | ||
116 | b = container_of(cb, struct nfs_dns_ent, h); | ||
117 | |||
118 | if (a->namelen == 0 || a->namelen != b->namelen) | ||
119 | return 0; | ||
120 | return memcmp(a->hostname, b->hostname, a->namelen) == 0; | ||
121 | } | ||
122 | |||
123 | static int nfs_dns_show(struct seq_file *m, struct cache_detail *cd, | ||
124 | struct cache_head *h) | ||
125 | { | ||
126 | struct nfs_dns_ent *item; | ||
127 | long ttl; | ||
128 | |||
129 | if (h == NULL) { | ||
130 | seq_puts(m, "# ip address hostname ttl\n"); | ||
131 | return 0; | ||
132 | } | ||
133 | item = container_of(h, struct nfs_dns_ent, h); | ||
134 | ttl = (long)item->h.expiry_time - (long)get_seconds(); | ||
135 | if (ttl < 0) | ||
136 | ttl = 0; | ||
137 | |||
138 | if (!test_bit(CACHE_NEGATIVE, &h->flags)) { | ||
139 | char buf[INET6_ADDRSTRLEN+IPV6_SCOPE_ID_LEN+1]; | ||
140 | |||
141 | rpc_ntop((struct sockaddr *)&item->addr, buf, sizeof(buf)); | ||
142 | seq_printf(m, "%15s ", buf); | ||
143 | } else | ||
144 | seq_puts(m, "<none> "); | ||
145 | seq_printf(m, "%15s %ld\n", item->hostname, ttl); | ||
146 | return 0; | ||
147 | } | ||
148 | |||
149 | struct nfs_dns_ent *nfs_dns_lookup(struct cache_detail *cd, | ||
150 | struct nfs_dns_ent *key) | ||
151 | { | ||
152 | struct cache_head *ch; | ||
153 | |||
154 | ch = sunrpc_cache_lookup(cd, | ||
155 | &key->h, | ||
156 | nfs_dns_hash(key)); | ||
157 | if (!ch) | ||
158 | return NULL; | ||
159 | return container_of(ch, struct nfs_dns_ent, h); | ||
160 | } | ||
161 | |||
162 | struct nfs_dns_ent *nfs_dns_update(struct cache_detail *cd, | ||
163 | struct nfs_dns_ent *new, | ||
164 | struct nfs_dns_ent *key) | ||
165 | { | ||
166 | struct cache_head *ch; | ||
167 | |||
168 | ch = sunrpc_cache_update(cd, | ||
169 | &new->h, &key->h, | ||
170 | nfs_dns_hash(key)); | ||
171 | if (!ch) | ||
172 | return NULL; | ||
173 | return container_of(ch, struct nfs_dns_ent, h); | ||
174 | } | ||
175 | |||
176 | static int nfs_dns_parse(struct cache_detail *cd, char *buf, int buflen) | ||
177 | { | ||
178 | char buf1[NFS_DNS_HOSTNAME_MAXLEN+1]; | ||
179 | struct nfs_dns_ent key, *item; | ||
180 | unsigned long ttl; | ||
181 | ssize_t len; | ||
182 | int ret = -EINVAL; | ||
183 | |||
184 | if (buf[buflen-1] != '\n') | ||
185 | goto out; | ||
186 | buf[buflen-1] = '\0'; | ||
187 | |||
188 | len = qword_get(&buf, buf1, sizeof(buf1)); | ||
189 | if (len <= 0) | ||
190 | goto out; | ||
191 | key.addrlen = rpc_pton(buf1, len, | ||
192 | (struct sockaddr *)&key.addr, | ||
193 | sizeof(key.addr)); | ||
194 | |||
195 | len = qword_get(&buf, buf1, sizeof(buf1)); | ||
196 | if (len <= 0) | ||
197 | goto out; | ||
198 | |||
199 | key.hostname = buf1; | ||
200 | key.namelen = len; | ||
201 | memset(&key.h, 0, sizeof(key.h)); | ||
202 | |||
203 | ttl = get_expiry(&buf); | ||
204 | if (ttl == 0) | ||
205 | goto out; | ||
206 | key.h.expiry_time = ttl + get_seconds(); | ||
207 | |||
208 | ret = -ENOMEM; | ||
209 | item = nfs_dns_lookup(cd, &key); | ||
210 | if (item == NULL) | ||
211 | goto out; | ||
212 | |||
213 | if (key.addrlen == 0) | ||
214 | set_bit(CACHE_NEGATIVE, &key.h.flags); | ||
215 | |||
216 | item = nfs_dns_update(cd, &key, item); | ||
217 | if (item == NULL) | ||
218 | goto out; | ||
219 | |||
220 | ret = 0; | ||
221 | cache_put(&item->h, cd); | ||
222 | out: | ||
223 | return ret; | ||
224 | } | ||
225 | |||
226 | static struct cache_detail nfs_dns_resolve = { | ||
227 | .owner = THIS_MODULE, | ||
228 | .hash_size = NFS_DNS_HASHTBL_SIZE, | ||
229 | .hash_table = nfs_dns_table, | ||
230 | .name = "dns_resolve", | ||
231 | .cache_put = nfs_dns_ent_put, | ||
232 | .cache_upcall = nfs_dns_upcall, | ||
233 | .cache_parse = nfs_dns_parse, | ||
234 | .cache_show = nfs_dns_show, | ||
235 | .match = nfs_dns_match, | ||
236 | .init = nfs_dns_ent_init, | ||
237 | .update = nfs_dns_ent_init, | ||
238 | .alloc = nfs_dns_ent_alloc, | ||
239 | }; | ||
240 | |||
241 | static int do_cache_lookup(struct cache_detail *cd, | ||
242 | struct nfs_dns_ent *key, | ||
243 | struct nfs_dns_ent **item, | ||
244 | struct nfs_cache_defer_req *dreq) | ||
245 | { | ||
246 | int ret = -ENOMEM; | ||
247 | |||
248 | *item = nfs_dns_lookup(cd, key); | ||
249 | if (*item) { | ||
250 | ret = cache_check(cd, &(*item)->h, &dreq->req); | ||
251 | if (ret) | ||
252 | *item = NULL; | ||
253 | } | ||
254 | return ret; | ||
255 | } | ||
256 | |||
257 | static int do_cache_lookup_nowait(struct cache_detail *cd, | ||
258 | struct nfs_dns_ent *key, | ||
259 | struct nfs_dns_ent **item) | ||
260 | { | ||
261 | int ret = -ENOMEM; | ||
262 | |||
263 | *item = nfs_dns_lookup(cd, key); | ||
264 | if (!*item) | ||
265 | goto out_err; | ||
266 | ret = -ETIMEDOUT; | ||
267 | if (!test_bit(CACHE_VALID, &(*item)->h.flags) | ||
268 | || (*item)->h.expiry_time < get_seconds() | ||
269 | || cd->flush_time > (*item)->h.last_refresh) | ||
270 | goto out_put; | ||
271 | ret = -ENOENT; | ||
272 | if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags)) | ||
273 | goto out_put; | ||
274 | return 0; | ||
275 | out_put: | ||
276 | cache_put(&(*item)->h, cd); | ||
277 | out_err: | ||
278 | *item = NULL; | ||
279 | return ret; | ||
280 | } | ||
281 | |||
282 | static int do_cache_lookup_wait(struct cache_detail *cd, | ||
283 | struct nfs_dns_ent *key, | ||
284 | struct nfs_dns_ent **item) | ||
285 | { | ||
286 | struct nfs_cache_defer_req *dreq; | ||
287 | int ret = -ENOMEM; | ||
288 | |||
289 | dreq = nfs_cache_defer_req_alloc(); | ||
290 | if (!dreq) | ||
291 | goto out; | ||
292 | ret = do_cache_lookup(cd, key, item, dreq); | ||
293 | if (ret == -EAGAIN) { | ||
294 | ret = nfs_cache_wait_for_upcall(dreq); | ||
295 | if (!ret) | ||
296 | ret = do_cache_lookup_nowait(cd, key, item); | ||
297 | } | ||
298 | nfs_cache_defer_req_put(dreq); | ||
299 | out: | ||
300 | return ret; | ||
301 | } | ||
302 | |||
303 | ssize_t nfs_dns_resolve_name(char *name, size_t namelen, | ||
304 | struct sockaddr *sa, size_t salen) | ||
305 | { | ||
306 | struct nfs_dns_ent key = { | ||
307 | .hostname = name, | ||
308 | .namelen = namelen, | ||
309 | }; | ||
310 | struct nfs_dns_ent *item = NULL; | ||
311 | ssize_t ret; | ||
312 | |||
313 | ret = do_cache_lookup_wait(&nfs_dns_resolve, &key, &item); | ||
314 | if (ret == 0) { | ||
315 | if (salen >= item->addrlen) { | ||
316 | memcpy(sa, &item->addr, item->addrlen); | ||
317 | ret = item->addrlen; | ||
318 | } else | ||
319 | ret = -EOVERFLOW; | ||
320 | cache_put(&item->h, &nfs_dns_resolve); | ||
321 | } else if (ret == -ENOENT) | ||
322 | ret = -ESRCH; | ||
323 | return ret; | ||
324 | } | ||
325 | |||
326 | int nfs_dns_resolver_init(void) | ||
327 | { | ||
328 | return nfs_cache_register(&nfs_dns_resolve); | ||
329 | } | ||
330 | |||
331 | void nfs_dns_resolver_destroy(void) | ||
332 | { | ||
333 | nfs_cache_unregister(&nfs_dns_resolve); | ||
334 | } | ||
335 | |||
diff --git a/fs/nfs/dns_resolve.h b/fs/nfs/dns_resolve.h new file mode 100644 index 000000000000..a3f0938babf7 --- /dev/null +++ b/fs/nfs/dns_resolve.h | |||
@@ -0,0 +1,14 @@ | |||
1 | /* | ||
2 | * Resolve DNS hostnames into valid ip addresses | ||
3 | */ | ||
4 | #ifndef __LINUX_FS_NFS_DNS_RESOLVE_H | ||
5 | #define __LINUX_FS_NFS_DNS_RESOLVE_H | ||
6 | |||
7 | #define NFS_DNS_HOSTNAME_MAXLEN (128) | ||
8 | |||
9 | extern int nfs_dns_resolver_init(void); | ||
10 | extern void nfs_dns_resolver_destroy(void); | ||
11 | extern ssize_t nfs_dns_resolve_name(char *name, size_t namelen, | ||
12 | struct sockaddr *sa, size_t salen); | ||
13 | |||
14 | #endif | ||
diff --git a/fs/nfs/file.c b/fs/nfs/file.c index 05062329b678..5021b75d2d1e 100644 --- a/fs/nfs/file.c +++ b/fs/nfs/file.c | |||
@@ -328,6 +328,42 @@ nfs_file_fsync(struct file *file, struct dentry *dentry, int datasync) | |||
328 | } | 328 | } |
329 | 329 | ||
330 | /* | 330 | /* |
331 | * Decide whether a read/modify/write cycle may be more efficient | ||
332 | * then a modify/write/read cycle when writing to a page in the | ||
333 | * page cache. | ||
334 | * | ||
335 | * The modify/write/read cycle may occur if a page is read before | ||
336 | * being completely filled by the writer. In this situation, the | ||
337 | * page must be completely written to stable storage on the server | ||
338 | * before it can be refilled by reading in the page from the server. | ||
339 | * This can lead to expensive, small, FILE_SYNC mode writes being | ||
340 | * done. | ||
341 | * | ||
342 | * It may be more efficient to read the page first if the file is | ||
343 | * open for reading in addition to writing, the page is not marked | ||
344 | * as Uptodate, it is not dirty or waiting to be committed, | ||
345 | * indicating that it was previously allocated and then modified, | ||
346 | * that there were valid bytes of data in that range of the file, | ||
347 | * and that the new data won't completely replace the old data in | ||
348 | * that range of the file. | ||
349 | */ | ||
350 | static int nfs_want_read_modify_write(struct file *file, struct page *page, | ||
351 | loff_t pos, unsigned len) | ||
352 | { | ||
353 | unsigned int pglen = nfs_page_length(page); | ||
354 | unsigned int offset = pos & (PAGE_CACHE_SIZE - 1); | ||
355 | unsigned int end = offset + len; | ||
356 | |||
357 | if ((file->f_mode & FMODE_READ) && /* open for read? */ | ||
358 | !PageUptodate(page) && /* Uptodate? */ | ||
359 | !PagePrivate(page) && /* i/o request already? */ | ||
360 | pglen && /* valid bytes of file? */ | ||
361 | (end < pglen || offset)) /* replace all valid bytes? */ | ||
362 | return 1; | ||
363 | return 0; | ||
364 | } | ||
365 | |||
366 | /* | ||
331 | * This does the "real" work of the write. We must allocate and lock the | 367 | * This does the "real" work of the write. We must allocate and lock the |
332 | * page to be sent back to the generic routine, which then copies the | 368 | * page to be sent back to the generic routine, which then copies the |
333 | * data from user space. | 369 | * data from user space. |
@@ -340,15 +376,16 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping, | |||
340 | struct page **pagep, void **fsdata) | 376 | struct page **pagep, void **fsdata) |
341 | { | 377 | { |
342 | int ret; | 378 | int ret; |
343 | pgoff_t index; | 379 | pgoff_t index = pos >> PAGE_CACHE_SHIFT; |
344 | struct page *page; | 380 | struct page *page; |
345 | index = pos >> PAGE_CACHE_SHIFT; | 381 | int once_thru = 0; |
346 | 382 | ||
347 | dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n", | 383 | dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n", |
348 | file->f_path.dentry->d_parent->d_name.name, | 384 | file->f_path.dentry->d_parent->d_name.name, |
349 | file->f_path.dentry->d_name.name, | 385 | file->f_path.dentry->d_name.name, |
350 | mapping->host->i_ino, len, (long long) pos); | 386 | mapping->host->i_ino, len, (long long) pos); |
351 | 387 | ||
388 | start: | ||
352 | /* | 389 | /* |
353 | * Prevent starvation issues if someone is doing a consistency | 390 | * Prevent starvation issues if someone is doing a consistency |
354 | * sync-to-disk | 391 | * sync-to-disk |
@@ -367,6 +404,13 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping, | |||
367 | if (ret) { | 404 | if (ret) { |
368 | unlock_page(page); | 405 | unlock_page(page); |
369 | page_cache_release(page); | 406 | page_cache_release(page); |
407 | } else if (!once_thru && | ||
408 | nfs_want_read_modify_write(file, page, pos, len)) { | ||
409 | once_thru = 1; | ||
410 | ret = nfs_readpage(file, page); | ||
411 | page_cache_release(page); | ||
412 | if (!ret) | ||
413 | goto start; | ||
370 | } | 414 | } |
371 | return ret; | 415 | return ret; |
372 | } | 416 | } |
@@ -479,6 +523,7 @@ const struct address_space_operations nfs_file_aops = { | |||
479 | .invalidatepage = nfs_invalidate_page, | 523 | .invalidatepage = nfs_invalidate_page, |
480 | .releasepage = nfs_release_page, | 524 | .releasepage = nfs_release_page, |
481 | .direct_IO = nfs_direct_IO, | 525 | .direct_IO = nfs_direct_IO, |
526 | .migratepage = nfs_migrate_page, | ||
482 | .launder_page = nfs_launder_page, | 527 | .launder_page = nfs_launder_page, |
483 | }; | 528 | }; |
484 | 529 | ||
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c index 86147b0ab2cf..21a84d45916f 100644 --- a/fs/nfs/idmap.c +++ b/fs/nfs/idmap.c | |||
@@ -101,7 +101,7 @@ static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *); | |||
101 | 101 | ||
102 | static unsigned int fnvhash32(const void *, size_t); | 102 | static unsigned int fnvhash32(const void *, size_t); |
103 | 103 | ||
104 | static struct rpc_pipe_ops idmap_upcall_ops = { | 104 | static const struct rpc_pipe_ops idmap_upcall_ops = { |
105 | .upcall = idmap_pipe_upcall, | 105 | .upcall = idmap_pipe_upcall, |
106 | .downcall = idmap_pipe_downcall, | 106 | .downcall = idmap_pipe_downcall, |
107 | .destroy_msg = idmap_pipe_destroy_msg, | 107 | .destroy_msg = idmap_pipe_destroy_msg, |
@@ -119,8 +119,8 @@ nfs_idmap_new(struct nfs_client *clp) | |||
119 | if (idmap == NULL) | 119 | if (idmap == NULL) |
120 | return -ENOMEM; | 120 | return -ENOMEM; |
121 | 121 | ||
122 | idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_dentry, "idmap", | 122 | idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_path.dentry, |
123 | idmap, &idmap_upcall_ops, 0); | 123 | "idmap", idmap, &idmap_upcall_ops, 0); |
124 | if (IS_ERR(idmap->idmap_dentry)) { | 124 | if (IS_ERR(idmap->idmap_dentry)) { |
125 | error = PTR_ERR(idmap->idmap_dentry); | 125 | error = PTR_ERR(idmap->idmap_dentry); |
126 | kfree(idmap); | 126 | kfree(idmap); |
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c index bd7938eda6a8..060022b4651c 100644 --- a/fs/nfs/inode.c +++ b/fs/nfs/inode.c | |||
@@ -46,6 +46,7 @@ | |||
46 | #include "iostat.h" | 46 | #include "iostat.h" |
47 | #include "internal.h" | 47 | #include "internal.h" |
48 | #include "fscache.h" | 48 | #include "fscache.h" |
49 | #include "dns_resolve.h" | ||
49 | 50 | ||
50 | #define NFSDBG_FACILITY NFSDBG_VFS | 51 | #define NFSDBG_FACILITY NFSDBG_VFS |
51 | 52 | ||
@@ -286,6 +287,11 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) | |||
286 | /* We can't support update_atime(), since the server will reset it */ | 287 | /* We can't support update_atime(), since the server will reset it */ |
287 | inode->i_flags |= S_NOATIME|S_NOCMTIME; | 288 | inode->i_flags |= S_NOATIME|S_NOCMTIME; |
288 | inode->i_mode = fattr->mode; | 289 | inode->i_mode = fattr->mode; |
290 | if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0 | ||
291 | && nfs_server_capable(inode, NFS_CAP_MODE)) | ||
292 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
293 | | NFS_INO_INVALID_ACCESS | ||
294 | | NFS_INO_INVALID_ACL; | ||
289 | /* Why so? Because we want revalidate for devices/FIFOs, and | 295 | /* Why so? Because we want revalidate for devices/FIFOs, and |
290 | * that's precisely what we have in nfs_file_inode_operations. | 296 | * that's precisely what we have in nfs_file_inode_operations. |
291 | */ | 297 | */ |
@@ -330,20 +336,46 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr) | |||
330 | nfsi->attr_gencount = fattr->gencount; | 336 | nfsi->attr_gencount = fattr->gencount; |
331 | if (fattr->valid & NFS_ATTR_FATTR_ATIME) | 337 | if (fattr->valid & NFS_ATTR_FATTR_ATIME) |
332 | inode->i_atime = fattr->atime; | 338 | inode->i_atime = fattr->atime; |
339 | else if (nfs_server_capable(inode, NFS_CAP_ATIME)) | ||
340 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; | ||
333 | if (fattr->valid & NFS_ATTR_FATTR_MTIME) | 341 | if (fattr->valid & NFS_ATTR_FATTR_MTIME) |
334 | inode->i_mtime = fattr->mtime; | 342 | inode->i_mtime = fattr->mtime; |
343 | else if (nfs_server_capable(inode, NFS_CAP_MTIME)) | ||
344 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
345 | | NFS_INO_INVALID_DATA; | ||
335 | if (fattr->valid & NFS_ATTR_FATTR_CTIME) | 346 | if (fattr->valid & NFS_ATTR_FATTR_CTIME) |
336 | inode->i_ctime = fattr->ctime; | 347 | inode->i_ctime = fattr->ctime; |
348 | else if (nfs_server_capable(inode, NFS_CAP_CTIME)) | ||
349 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
350 | | NFS_INO_INVALID_ACCESS | ||
351 | | NFS_INO_INVALID_ACL; | ||
337 | if (fattr->valid & NFS_ATTR_FATTR_CHANGE) | 352 | if (fattr->valid & NFS_ATTR_FATTR_CHANGE) |
338 | nfsi->change_attr = fattr->change_attr; | 353 | nfsi->change_attr = fattr->change_attr; |
354 | else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR)) | ||
355 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
356 | | NFS_INO_INVALID_DATA; | ||
339 | if (fattr->valid & NFS_ATTR_FATTR_SIZE) | 357 | if (fattr->valid & NFS_ATTR_FATTR_SIZE) |
340 | inode->i_size = nfs_size_to_loff_t(fattr->size); | 358 | inode->i_size = nfs_size_to_loff_t(fattr->size); |
359 | else | ||
360 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
361 | | NFS_INO_INVALID_DATA | ||
362 | | NFS_INO_REVAL_PAGECACHE; | ||
341 | if (fattr->valid & NFS_ATTR_FATTR_NLINK) | 363 | if (fattr->valid & NFS_ATTR_FATTR_NLINK) |
342 | inode->i_nlink = fattr->nlink; | 364 | inode->i_nlink = fattr->nlink; |
365 | else if (nfs_server_capable(inode, NFS_CAP_NLINK)) | ||
366 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR; | ||
343 | if (fattr->valid & NFS_ATTR_FATTR_OWNER) | 367 | if (fattr->valid & NFS_ATTR_FATTR_OWNER) |
344 | inode->i_uid = fattr->uid; | 368 | inode->i_uid = fattr->uid; |
369 | else if (nfs_server_capable(inode, NFS_CAP_OWNER)) | ||
370 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
371 | | NFS_INO_INVALID_ACCESS | ||
372 | | NFS_INO_INVALID_ACL; | ||
345 | if (fattr->valid & NFS_ATTR_FATTR_GROUP) | 373 | if (fattr->valid & NFS_ATTR_FATTR_GROUP) |
346 | inode->i_gid = fattr->gid; | 374 | inode->i_gid = fattr->gid; |
375 | else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP)) | ||
376 | nfsi->cache_validity |= NFS_INO_INVALID_ATTR | ||
377 | | NFS_INO_INVALID_ACCESS | ||
378 | | NFS_INO_INVALID_ACL; | ||
347 | if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) | 379 | if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) |
348 | inode->i_blocks = fattr->du.nfs2.blocks; | 380 | inode->i_blocks = fattr->du.nfs2.blocks; |
349 | if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { | 381 | if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { |
@@ -1145,6 +1177,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1145 | loff_t cur_isize, new_isize; | 1177 | loff_t cur_isize, new_isize; |
1146 | unsigned long invalid = 0; | 1178 | unsigned long invalid = 0; |
1147 | unsigned long now = jiffies; | 1179 | unsigned long now = jiffies; |
1180 | unsigned long save_cache_validity; | ||
1148 | 1181 | ||
1149 | dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", | 1182 | dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", |
1150 | __func__, inode->i_sb->s_id, inode->i_ino, | 1183 | __func__, inode->i_sb->s_id, inode->i_ino, |
@@ -1171,10 +1204,11 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1171 | */ | 1204 | */ |
1172 | nfsi->read_cache_jiffies = fattr->time_start; | 1205 | nfsi->read_cache_jiffies = fattr->time_start; |
1173 | 1206 | ||
1174 | if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) || (fattr->valid & (NFS_ATTR_FATTR_MTIME|NFS_ATTR_FATTR_CTIME))) | 1207 | save_cache_validity = nfsi->cache_validity; |
1175 | nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR | 1208 | nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR |
1176 | | NFS_INO_INVALID_ATIME | 1209 | | NFS_INO_INVALID_ATIME |
1177 | | NFS_INO_REVAL_PAGECACHE); | 1210 | | NFS_INO_REVAL_FORCED |
1211 | | NFS_INO_REVAL_PAGECACHE); | ||
1178 | 1212 | ||
1179 | /* Do atomic weak cache consistency updates */ | 1213 | /* Do atomic weak cache consistency updates */ |
1180 | nfs_wcc_update_inode(inode, fattr); | 1214 | nfs_wcc_update_inode(inode, fattr); |
@@ -1189,7 +1223,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1189 | nfs_force_lookup_revalidate(inode); | 1223 | nfs_force_lookup_revalidate(inode); |
1190 | nfsi->change_attr = fattr->change_attr; | 1224 | nfsi->change_attr = fattr->change_attr; |
1191 | } | 1225 | } |
1192 | } | 1226 | } else if (server->caps & NFS_CAP_CHANGE_ATTR) |
1227 | invalid |= save_cache_validity; | ||
1193 | 1228 | ||
1194 | if (fattr->valid & NFS_ATTR_FATTR_MTIME) { | 1229 | if (fattr->valid & NFS_ATTR_FATTR_MTIME) { |
1195 | /* NFSv2/v3: Check if the mtime agrees */ | 1230 | /* NFSv2/v3: Check if the mtime agrees */ |
@@ -1201,7 +1236,12 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1201 | nfs_force_lookup_revalidate(inode); | 1236 | nfs_force_lookup_revalidate(inode); |
1202 | memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); | 1237 | memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime)); |
1203 | } | 1238 | } |
1204 | } | 1239 | } else if (server->caps & NFS_CAP_MTIME) |
1240 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1241 | | NFS_INO_INVALID_DATA | ||
1242 | | NFS_INO_REVAL_PAGECACHE | ||
1243 | | NFS_INO_REVAL_FORCED); | ||
1244 | |||
1205 | if (fattr->valid & NFS_ATTR_FATTR_CTIME) { | 1245 | if (fattr->valid & NFS_ATTR_FATTR_CTIME) { |
1206 | /* If ctime has changed we should definitely clear access+acl caches */ | 1246 | /* If ctime has changed we should definitely clear access+acl caches */ |
1207 | if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) { | 1247 | if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) { |
@@ -1215,7 +1255,11 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1215 | } | 1255 | } |
1216 | memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); | 1256 | memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime)); |
1217 | } | 1257 | } |
1218 | } | 1258 | } else if (server->caps & NFS_CAP_CTIME) |
1259 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1260 | | NFS_INO_INVALID_ACCESS | ||
1261 | | NFS_INO_INVALID_ACL | ||
1262 | | NFS_INO_REVAL_FORCED); | ||
1219 | 1263 | ||
1220 | /* Check if our cached file size is stale */ | 1264 | /* Check if our cached file size is stale */ |
1221 | if (fattr->valid & NFS_ATTR_FATTR_SIZE) { | 1265 | if (fattr->valid & NFS_ATTR_FATTR_SIZE) { |
@@ -1231,30 +1275,50 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1231 | dprintk("NFS: isize change on server for file %s/%ld\n", | 1275 | dprintk("NFS: isize change on server for file %s/%ld\n", |
1232 | inode->i_sb->s_id, inode->i_ino); | 1276 | inode->i_sb->s_id, inode->i_ino); |
1233 | } | 1277 | } |
1234 | } | 1278 | } else |
1279 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1280 | | NFS_INO_REVAL_PAGECACHE | ||
1281 | | NFS_INO_REVAL_FORCED); | ||
1235 | 1282 | ||
1236 | 1283 | ||
1237 | if (fattr->valid & NFS_ATTR_FATTR_ATIME) | 1284 | if (fattr->valid & NFS_ATTR_FATTR_ATIME) |
1238 | memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); | 1285 | memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime)); |
1286 | else if (server->caps & NFS_CAP_ATIME) | ||
1287 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME | ||
1288 | | NFS_INO_REVAL_FORCED); | ||
1239 | 1289 | ||
1240 | if (fattr->valid & NFS_ATTR_FATTR_MODE) { | 1290 | if (fattr->valid & NFS_ATTR_FATTR_MODE) { |
1241 | if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { | 1291 | if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) { |
1242 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; | 1292 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; |
1243 | inode->i_mode = fattr->mode; | 1293 | inode->i_mode = fattr->mode; |
1244 | } | 1294 | } |
1245 | } | 1295 | } else if (server->caps & NFS_CAP_MODE) |
1296 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1297 | | NFS_INO_INVALID_ACCESS | ||
1298 | | NFS_INO_INVALID_ACL | ||
1299 | | NFS_INO_REVAL_FORCED); | ||
1300 | |||
1246 | if (fattr->valid & NFS_ATTR_FATTR_OWNER) { | 1301 | if (fattr->valid & NFS_ATTR_FATTR_OWNER) { |
1247 | if (inode->i_uid != fattr->uid) { | 1302 | if (inode->i_uid != fattr->uid) { |
1248 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; | 1303 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; |
1249 | inode->i_uid = fattr->uid; | 1304 | inode->i_uid = fattr->uid; |
1250 | } | 1305 | } |
1251 | } | 1306 | } else if (server->caps & NFS_CAP_OWNER) |
1307 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1308 | | NFS_INO_INVALID_ACCESS | ||
1309 | | NFS_INO_INVALID_ACL | ||
1310 | | NFS_INO_REVAL_FORCED); | ||
1311 | |||
1252 | if (fattr->valid & NFS_ATTR_FATTR_GROUP) { | 1312 | if (fattr->valid & NFS_ATTR_FATTR_GROUP) { |
1253 | if (inode->i_gid != fattr->gid) { | 1313 | if (inode->i_gid != fattr->gid) { |
1254 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; | 1314 | invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL; |
1255 | inode->i_gid = fattr->gid; | 1315 | inode->i_gid = fattr->gid; |
1256 | } | 1316 | } |
1257 | } | 1317 | } else if (server->caps & NFS_CAP_OWNER_GROUP) |
1318 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1319 | | NFS_INO_INVALID_ACCESS | ||
1320 | | NFS_INO_INVALID_ACL | ||
1321 | | NFS_INO_REVAL_FORCED); | ||
1258 | 1322 | ||
1259 | if (fattr->valid & NFS_ATTR_FATTR_NLINK) { | 1323 | if (fattr->valid & NFS_ATTR_FATTR_NLINK) { |
1260 | if (inode->i_nlink != fattr->nlink) { | 1324 | if (inode->i_nlink != fattr->nlink) { |
@@ -1263,7 +1327,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1263 | invalid |= NFS_INO_INVALID_DATA; | 1327 | invalid |= NFS_INO_INVALID_DATA; |
1264 | inode->i_nlink = fattr->nlink; | 1328 | inode->i_nlink = fattr->nlink; |
1265 | } | 1329 | } |
1266 | } | 1330 | } else if (server->caps & NFS_CAP_NLINK) |
1331 | invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR | ||
1332 | | NFS_INO_REVAL_FORCED); | ||
1267 | 1333 | ||
1268 | if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { | 1334 | if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) { |
1269 | /* | 1335 | /* |
@@ -1293,9 +1359,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) | |||
1293 | || S_ISLNK(inode->i_mode))) | 1359 | || S_ISLNK(inode->i_mode))) |
1294 | invalid &= ~NFS_INO_INVALID_DATA; | 1360 | invalid &= ~NFS_INO_INVALID_DATA; |
1295 | if (!nfs_have_delegation(inode, FMODE_READ) || | 1361 | if (!nfs_have_delegation(inode, FMODE_READ) || |
1296 | (nfsi->cache_validity & NFS_INO_REVAL_FORCED)) | 1362 | (save_cache_validity & NFS_INO_REVAL_FORCED)) |
1297 | nfsi->cache_validity |= invalid; | 1363 | nfsi->cache_validity |= invalid; |
1298 | nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED; | ||
1299 | 1364 | ||
1300 | return 0; | 1365 | return 0; |
1301 | out_changed: | 1366 | out_changed: |
@@ -1442,6 +1507,10 @@ static int __init init_nfs_fs(void) | |||
1442 | { | 1507 | { |
1443 | int err; | 1508 | int err; |
1444 | 1509 | ||
1510 | err = nfs_dns_resolver_init(); | ||
1511 | if (err < 0) | ||
1512 | goto out8; | ||
1513 | |||
1445 | err = nfs_fscache_register(); | 1514 | err = nfs_fscache_register(); |
1446 | if (err < 0) | 1515 | if (err < 0) |
1447 | goto out7; | 1516 | goto out7; |
@@ -1500,6 +1569,8 @@ out5: | |||
1500 | out6: | 1569 | out6: |
1501 | nfs_fscache_unregister(); | 1570 | nfs_fscache_unregister(); |
1502 | out7: | 1571 | out7: |
1572 | nfs_dns_resolver_destroy(); | ||
1573 | out8: | ||
1503 | return err; | 1574 | return err; |
1504 | } | 1575 | } |
1505 | 1576 | ||
@@ -1511,6 +1582,7 @@ static void __exit exit_nfs_fs(void) | |||
1511 | nfs_destroy_inodecache(); | 1582 | nfs_destroy_inodecache(); |
1512 | nfs_destroy_nfspagecache(); | 1583 | nfs_destroy_nfspagecache(); |
1513 | nfs_fscache_unregister(); | 1584 | nfs_fscache_unregister(); |
1585 | nfs_dns_resolver_destroy(); | ||
1514 | #ifdef CONFIG_PROC_FS | 1586 | #ifdef CONFIG_PROC_FS |
1515 | rpc_proc_unregister("nfs"); | 1587 | rpc_proc_unregister("nfs"); |
1516 | #endif | 1588 | #endif |
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h index 7dd90a6769d0..e21b1bb9972f 100644 --- a/fs/nfs/internal.h +++ b/fs/nfs/internal.h | |||
@@ -49,6 +49,11 @@ struct nfs_clone_mount { | |||
49 | #define NFS_MAX_SECFLAVORS (12) | 49 | #define NFS_MAX_SECFLAVORS (12) |
50 | 50 | ||
51 | /* | 51 | /* |
52 | * Value used if the user did not specify a port value. | ||
53 | */ | ||
54 | #define NFS_UNSPEC_PORT (-1) | ||
55 | |||
56 | /* | ||
52 | * In-kernel mount arguments | 57 | * In-kernel mount arguments |
53 | */ | 58 | */ |
54 | struct nfs_parsed_mount_data { | 59 | struct nfs_parsed_mount_data { |
@@ -63,6 +68,7 @@ struct nfs_parsed_mount_data { | |||
63 | unsigned int auth_flavor_len; | 68 | unsigned int auth_flavor_len; |
64 | rpc_authflavor_t auth_flavors[1]; | 69 | rpc_authflavor_t auth_flavors[1]; |
65 | char *client_address; | 70 | char *client_address; |
71 | unsigned int version; | ||
66 | unsigned int minorversion; | 72 | unsigned int minorversion; |
67 | char *fscache_uniq; | 73 | char *fscache_uniq; |
68 | 74 | ||
@@ -71,7 +77,7 @@ struct nfs_parsed_mount_data { | |||
71 | size_t addrlen; | 77 | size_t addrlen; |
72 | char *hostname; | 78 | char *hostname; |
73 | u32 version; | 79 | u32 version; |
74 | unsigned short port; | 80 | int port; |
75 | unsigned short protocol; | 81 | unsigned short protocol; |
76 | } mount_server; | 82 | } mount_server; |
77 | 83 | ||
@@ -80,7 +86,7 @@ struct nfs_parsed_mount_data { | |||
80 | size_t addrlen; | 86 | size_t addrlen; |
81 | char *hostname; | 87 | char *hostname; |
82 | char *export_path; | 88 | char *export_path; |
83 | unsigned short port; | 89 | int port; |
84 | unsigned short protocol; | 90 | unsigned short protocol; |
85 | } nfs_server; | 91 | } nfs_server; |
86 | 92 | ||
@@ -102,6 +108,7 @@ struct nfs_mount_request { | |||
102 | }; | 108 | }; |
103 | 109 | ||
104 | extern int nfs_mount(struct nfs_mount_request *info); | 110 | extern int nfs_mount(struct nfs_mount_request *info); |
111 | extern void nfs_umount(const struct nfs_mount_request *info); | ||
105 | 112 | ||
106 | /* client.c */ | 113 | /* client.c */ |
107 | extern struct rpc_program nfs_program; | 114 | extern struct rpc_program nfs_program; |
@@ -213,7 +220,6 @@ void nfs_zap_acl_cache(struct inode *inode); | |||
213 | extern int nfs_wait_bit_killable(void *word); | 220 | extern int nfs_wait_bit_killable(void *word); |
214 | 221 | ||
215 | /* super.c */ | 222 | /* super.c */ |
216 | void nfs_parse_ip_address(char *, size_t, struct sockaddr *, size_t *); | ||
217 | extern struct file_system_type nfs_xdev_fs_type; | 223 | extern struct file_system_type nfs_xdev_fs_type; |
218 | #ifdef CONFIG_NFS_V4 | 224 | #ifdef CONFIG_NFS_V4 |
219 | extern struct file_system_type nfs4_xdev_fs_type; | 225 | extern struct file_system_type nfs4_xdev_fs_type; |
@@ -248,6 +254,12 @@ extern void nfs_read_prepare(struct rpc_task *task, void *calldata); | |||
248 | 254 | ||
249 | /* write.c */ | 255 | /* write.c */ |
250 | extern void nfs_write_prepare(struct rpc_task *task, void *calldata); | 256 | extern void nfs_write_prepare(struct rpc_task *task, void *calldata); |
257 | #ifdef CONFIG_MIGRATION | ||
258 | extern int nfs_migrate_page(struct address_space *, | ||
259 | struct page *, struct page *); | ||
260 | #else | ||
261 | #define nfs_migrate_page NULL | ||
262 | #endif | ||
251 | 263 | ||
252 | /* nfs4proc.c */ | 264 | /* nfs4proc.c */ |
253 | extern int _nfs4_call_sync(struct nfs_server *server, | 265 | extern int _nfs4_call_sync(struct nfs_server *server, |
@@ -368,24 +380,3 @@ unsigned int nfs_page_array_len(unsigned int base, size_t len) | |||
368 | return ((unsigned long)len + (unsigned long)base + | 380 | return ((unsigned long)len + (unsigned long)base + |
369 | PAGE_SIZE - 1) >> PAGE_SHIFT; | 381 | PAGE_SIZE - 1) >> PAGE_SHIFT; |
370 | } | 382 | } |
371 | |||
372 | #define IPV6_SCOPE_DELIMITER '%' | ||
373 | |||
374 | /* | ||
375 | * Set the port number in an address. Be agnostic about the address | ||
376 | * family. | ||
377 | */ | ||
378 | static inline void nfs_set_port(struct sockaddr *sap, unsigned short port) | ||
379 | { | ||
380 | struct sockaddr_in *ap = (struct sockaddr_in *)sap; | ||
381 | struct sockaddr_in6 *ap6 = (struct sockaddr_in6 *)sap; | ||
382 | |||
383 | switch (sap->sa_family) { | ||
384 | case AF_INET: | ||
385 | ap->sin_port = htons(port); | ||
386 | break; | ||
387 | case AF_INET6: | ||
388 | ap6->sin6_port = htons(port); | ||
389 | break; | ||
390 | } | ||
391 | } | ||
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c index 38ef9eaec407..0adefc40cc89 100644 --- a/fs/nfs/mount_clnt.c +++ b/fs/nfs/mount_clnt.c | |||
@@ -209,6 +209,71 @@ out_mnt_err: | |||
209 | goto out; | 209 | goto out; |
210 | } | 210 | } |
211 | 211 | ||
212 | /** | ||
213 | * nfs_umount - Notify a server that we have unmounted this export | ||
214 | * @info: pointer to umount request arguments | ||
215 | * | ||
216 | * MOUNTPROC_UMNT is advisory, so we set a short timeout, and always | ||
217 | * use UDP. | ||
218 | */ | ||
219 | void nfs_umount(const struct nfs_mount_request *info) | ||
220 | { | ||
221 | static const struct rpc_timeout nfs_umnt_timeout = { | ||
222 | .to_initval = 1 * HZ, | ||
223 | .to_maxval = 3 * HZ, | ||
224 | .to_retries = 2, | ||
225 | }; | ||
226 | struct rpc_create_args args = { | ||
227 | .protocol = IPPROTO_UDP, | ||
228 | .address = info->sap, | ||
229 | .addrsize = info->salen, | ||
230 | .timeout = &nfs_umnt_timeout, | ||
231 | .servername = info->hostname, | ||
232 | .program = &mnt_program, | ||
233 | .version = info->version, | ||
234 | .authflavor = RPC_AUTH_UNIX, | ||
235 | .flags = RPC_CLNT_CREATE_NOPING, | ||
236 | }; | ||
237 | struct mountres result; | ||
238 | struct rpc_message msg = { | ||
239 | .rpc_argp = info->dirpath, | ||
240 | .rpc_resp = &result, | ||
241 | }; | ||
242 | struct rpc_clnt *clnt; | ||
243 | int status; | ||
244 | |||
245 | if (info->noresvport) | ||
246 | args.flags |= RPC_CLNT_CREATE_NONPRIVPORT; | ||
247 | |||
248 | clnt = rpc_create(&args); | ||
249 | if (unlikely(IS_ERR(clnt))) | ||
250 | goto out_clnt_err; | ||
251 | |||
252 | dprintk("NFS: sending UMNT request for %s:%s\n", | ||
253 | (info->hostname ? info->hostname : "server"), info->dirpath); | ||
254 | |||
255 | if (info->version == NFS_MNT3_VERSION) | ||
256 | msg.rpc_proc = &clnt->cl_procinfo[MOUNTPROC3_UMNT]; | ||
257 | else | ||
258 | msg.rpc_proc = &clnt->cl_procinfo[MOUNTPROC_UMNT]; | ||
259 | |||
260 | status = rpc_call_sync(clnt, &msg, 0); | ||
261 | rpc_shutdown_client(clnt); | ||
262 | |||
263 | if (unlikely(status < 0)) | ||
264 | goto out_call_err; | ||
265 | |||
266 | return; | ||
267 | |||
268 | out_clnt_err: | ||
269 | dprintk("NFS: failed to create UMNT RPC client, status=%ld\n", | ||
270 | PTR_ERR(clnt)); | ||
271 | return; | ||
272 | |||
273 | out_call_err: | ||
274 | dprintk("NFS: UMNT request failed, status=%d\n", status); | ||
275 | } | ||
276 | |||
212 | /* | 277 | /* |
213 | * XDR encode/decode functions for MOUNT | 278 | * XDR encode/decode functions for MOUNT |
214 | */ | 279 | */ |
@@ -258,7 +323,7 @@ static int decode_status(struct xdr_stream *xdr, struct mountres *res) | |||
258 | return -EIO; | 323 | return -EIO; |
259 | status = ntohl(*p); | 324 | status = ntohl(*p); |
260 | 325 | ||
261 | for (i = 0; i <= ARRAY_SIZE(mnt_errtbl); i++) { | 326 | for (i = 0; i < ARRAY_SIZE(mnt_errtbl); i++) { |
262 | if (mnt_errtbl[i].status == status) { | 327 | if (mnt_errtbl[i].status == status) { |
263 | res->errno = mnt_errtbl[i].errno; | 328 | res->errno = mnt_errtbl[i].errno; |
264 | return 0; | 329 | return 0; |
@@ -309,7 +374,7 @@ static int decode_fhs_status(struct xdr_stream *xdr, struct mountres *res) | |||
309 | return -EIO; | 374 | return -EIO; |
310 | status = ntohl(*p); | 375 | status = ntohl(*p); |
311 | 376 | ||
312 | for (i = 0; i <= ARRAY_SIZE(mnt3_errtbl); i++) { | 377 | for (i = 0; i < ARRAY_SIZE(mnt3_errtbl); i++) { |
313 | if (mnt3_errtbl[i].status == status) { | 378 | if (mnt3_errtbl[i].status == status) { |
314 | res->errno = mnt3_errtbl[i].errno; | 379 | res->errno = mnt3_errtbl[i].errno; |
315 | return 0; | 380 | return 0; |
@@ -407,6 +472,13 @@ static struct rpc_procinfo mnt_procedures[] = { | |||
407 | .p_statidx = MOUNTPROC_MNT, | 472 | .p_statidx = MOUNTPROC_MNT, |
408 | .p_name = "MOUNT", | 473 | .p_name = "MOUNT", |
409 | }, | 474 | }, |
475 | [MOUNTPROC_UMNT] = { | ||
476 | .p_proc = MOUNTPROC_UMNT, | ||
477 | .p_encode = (kxdrproc_t)mnt_enc_dirpath, | ||
478 | .p_arglen = MNT_enc_dirpath_sz, | ||
479 | .p_statidx = MOUNTPROC_UMNT, | ||
480 | .p_name = "UMOUNT", | ||
481 | }, | ||
410 | }; | 482 | }; |
411 | 483 | ||
412 | static struct rpc_procinfo mnt3_procedures[] = { | 484 | static struct rpc_procinfo mnt3_procedures[] = { |
@@ -419,6 +491,13 @@ static struct rpc_procinfo mnt3_procedures[] = { | |||
419 | .p_statidx = MOUNTPROC3_MNT, | 491 | .p_statidx = MOUNTPROC3_MNT, |
420 | .p_name = "MOUNT", | 492 | .p_name = "MOUNT", |
421 | }, | 493 | }, |
494 | [MOUNTPROC3_UMNT] = { | ||
495 | .p_proc = MOUNTPROC3_UMNT, | ||
496 | .p_encode = (kxdrproc_t)mnt_enc_dirpath, | ||
497 | .p_arglen = MNT_enc_dirpath_sz, | ||
498 | .p_statidx = MOUNTPROC3_UMNT, | ||
499 | .p_name = "UMOUNT", | ||
500 | }, | ||
422 | }; | 501 | }; |
423 | 502 | ||
424 | 503 | ||
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c index d0cc5ce0edfe..ee6a13f05443 100644 --- a/fs/nfs/nfs3proc.c +++ b/fs/nfs/nfs3proc.c | |||
@@ -299,7 +299,6 @@ static void nfs3_free_createdata(struct nfs3_createdata *data) | |||
299 | 299 | ||
300 | /* | 300 | /* |
301 | * Create a regular file. | 301 | * Create a regular file. |
302 | * For now, we don't implement O_EXCL. | ||
303 | */ | 302 | */ |
304 | static int | 303 | static int |
305 | nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | 304 | nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, |
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c index 2a2a0a7143ad..2636c26d56fa 100644 --- a/fs/nfs/nfs4namespace.c +++ b/fs/nfs/nfs4namespace.c | |||
@@ -17,6 +17,7 @@ | |||
17 | #include <linux/inet.h> | 17 | #include <linux/inet.h> |
18 | #include "internal.h" | 18 | #include "internal.h" |
19 | #include "nfs4_fs.h" | 19 | #include "nfs4_fs.h" |
20 | #include "dns_resolve.h" | ||
20 | 21 | ||
21 | #define NFSDBG_FACILITY NFSDBG_VFS | 22 | #define NFSDBG_FACILITY NFSDBG_VFS |
22 | 23 | ||
@@ -95,6 +96,20 @@ static int nfs4_validate_fspath(const struct vfsmount *mnt_parent, | |||
95 | return 0; | 96 | return 0; |
96 | } | 97 | } |
97 | 98 | ||
99 | static size_t nfs_parse_server_name(char *string, size_t len, | ||
100 | struct sockaddr *sa, size_t salen) | ||
101 | { | ||
102 | ssize_t ret; | ||
103 | |||
104 | ret = rpc_pton(string, len, sa, salen); | ||
105 | if (ret == 0) { | ||
106 | ret = nfs_dns_resolve_name(string, len, sa, salen); | ||
107 | if (ret < 0) | ||
108 | ret = 0; | ||
109 | } | ||
110 | return ret; | ||
111 | } | ||
112 | |||
98 | static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, | 113 | static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, |
99 | char *page, char *page2, | 114 | char *page, char *page2, |
100 | const struct nfs4_fs_location *location) | 115 | const struct nfs4_fs_location *location) |
@@ -121,11 +136,12 @@ static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, | |||
121 | 136 | ||
122 | if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len)) | 137 | if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len)) |
123 | continue; | 138 | continue; |
124 | nfs_parse_ip_address(buf->data, buf->len, | 139 | mountdata->addrlen = nfs_parse_server_name(buf->data, |
125 | mountdata->addr, &mountdata->addrlen); | 140 | buf->len, |
126 | if (mountdata->addr->sa_family == AF_UNSPEC) | 141 | mountdata->addr, mountdata->addrlen); |
142 | if (mountdata->addrlen == 0) | ||
127 | continue; | 143 | continue; |
128 | nfs_set_port(mountdata->addr, NFS_PORT); | 144 | rpc_set_port(mountdata->addr, NFS_PORT); |
129 | 145 | ||
130 | memcpy(page2, buf->data, buf->len); | 146 | memcpy(page2, buf->data, buf->len); |
131 | page2[buf->len] = '\0'; | 147 | page2[buf->len] = '\0'; |
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index 6917311f201c..be6544aef41f 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c | |||
@@ -61,6 +61,8 @@ | |||
61 | #define NFS4_POLL_RETRY_MIN (HZ/10) | 61 | #define NFS4_POLL_RETRY_MIN (HZ/10) |
62 | #define NFS4_POLL_RETRY_MAX (15*HZ) | 62 | #define NFS4_POLL_RETRY_MAX (15*HZ) |
63 | 63 | ||
64 | #define NFS4_MAX_LOOP_ON_RECOVER (10) | ||
65 | |||
64 | struct nfs4_opendata; | 66 | struct nfs4_opendata; |
65 | static int _nfs4_proc_open(struct nfs4_opendata *data); | 67 | static int _nfs4_proc_open(struct nfs4_opendata *data); |
66 | static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); | 68 | static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); |
@@ -426,17 +428,19 @@ out: | |||
426 | static int nfs4_recover_session(struct nfs4_session *session) | 428 | static int nfs4_recover_session(struct nfs4_session *session) |
427 | { | 429 | { |
428 | struct nfs_client *clp = session->clp; | 430 | struct nfs_client *clp = session->clp; |
431 | unsigned int loop; | ||
429 | int ret; | 432 | int ret; |
430 | 433 | ||
431 | for (;;) { | 434 | for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { |
432 | ret = nfs4_wait_clnt_recover(clp); | 435 | ret = nfs4_wait_clnt_recover(clp); |
433 | if (ret != 0) | 436 | if (ret != 0) |
434 | return ret; | 437 | break; |
435 | if (!test_bit(NFS4CLNT_SESSION_SETUP, &clp->cl_state)) | 438 | if (!test_bit(NFS4CLNT_SESSION_SETUP, &clp->cl_state)) |
436 | break; | 439 | break; |
437 | nfs4_schedule_state_manager(clp); | 440 | nfs4_schedule_state_manager(clp); |
441 | ret = -EIO; | ||
438 | } | 442 | } |
439 | return 0; | 443 | return ret; |
440 | } | 444 | } |
441 | 445 | ||
442 | static int nfs41_setup_sequence(struct nfs4_session *session, | 446 | static int nfs41_setup_sequence(struct nfs4_session *session, |
@@ -1444,18 +1448,20 @@ static int _nfs4_proc_open(struct nfs4_opendata *data) | |||
1444 | static int nfs4_recover_expired_lease(struct nfs_server *server) | 1448 | static int nfs4_recover_expired_lease(struct nfs_server *server) |
1445 | { | 1449 | { |
1446 | struct nfs_client *clp = server->nfs_client; | 1450 | struct nfs_client *clp = server->nfs_client; |
1451 | unsigned int loop; | ||
1447 | int ret; | 1452 | int ret; |
1448 | 1453 | ||
1449 | for (;;) { | 1454 | for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { |
1450 | ret = nfs4_wait_clnt_recover(clp); | 1455 | ret = nfs4_wait_clnt_recover(clp); |
1451 | if (ret != 0) | 1456 | if (ret != 0) |
1452 | return ret; | 1457 | break; |
1453 | if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && | 1458 | if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && |
1454 | !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) | 1459 | !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) |
1455 | break; | 1460 | break; |
1456 | nfs4_schedule_state_recovery(clp); | 1461 | nfs4_schedule_state_recovery(clp); |
1462 | ret = -EIO; | ||
1457 | } | 1463 | } |
1458 | return 0; | 1464 | return ret; |
1459 | } | 1465 | } |
1460 | 1466 | ||
1461 | /* | 1467 | /* |
@@ -1997,12 +2003,34 @@ static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *f | |||
1997 | status = nfs4_call_sync(server, &msg, &args, &res, 0); | 2003 | status = nfs4_call_sync(server, &msg, &args, &res, 0); |
1998 | if (status == 0) { | 2004 | if (status == 0) { |
1999 | memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); | 2005 | memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); |
2006 | server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| | ||
2007 | NFS_CAP_SYMLINKS|NFS_CAP_FILEID| | ||
2008 | NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER| | ||
2009 | NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME| | ||
2010 | NFS_CAP_CTIME|NFS_CAP_MTIME); | ||
2000 | if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) | 2011 | if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) |
2001 | server->caps |= NFS_CAP_ACLS; | 2012 | server->caps |= NFS_CAP_ACLS; |
2002 | if (res.has_links != 0) | 2013 | if (res.has_links != 0) |
2003 | server->caps |= NFS_CAP_HARDLINKS; | 2014 | server->caps |= NFS_CAP_HARDLINKS; |
2004 | if (res.has_symlinks != 0) | 2015 | if (res.has_symlinks != 0) |
2005 | server->caps |= NFS_CAP_SYMLINKS; | 2016 | server->caps |= NFS_CAP_SYMLINKS; |
2017 | if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID) | ||
2018 | server->caps |= NFS_CAP_FILEID; | ||
2019 | if (res.attr_bitmask[1] & FATTR4_WORD1_MODE) | ||
2020 | server->caps |= NFS_CAP_MODE; | ||
2021 | if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS) | ||
2022 | server->caps |= NFS_CAP_NLINK; | ||
2023 | if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER) | ||
2024 | server->caps |= NFS_CAP_OWNER; | ||
2025 | if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP) | ||
2026 | server->caps |= NFS_CAP_OWNER_GROUP; | ||
2027 | if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS) | ||
2028 | server->caps |= NFS_CAP_ATIME; | ||
2029 | if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA) | ||
2030 | server->caps |= NFS_CAP_CTIME; | ||
2031 | if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY) | ||
2032 | server->caps |= NFS_CAP_MTIME; | ||
2033 | |||
2006 | memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); | 2034 | memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); |
2007 | server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; | 2035 | server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; |
2008 | server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; | 2036 | server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; |
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c index 617273e7d47f..cfc30d362f94 100644 --- a/fs/nfs/nfs4xdr.c +++ b/fs/nfs/nfs4xdr.c | |||
@@ -702,29 +702,12 @@ struct compound_hdr { | |||
702 | u32 minorversion; | 702 | u32 minorversion; |
703 | }; | 703 | }; |
704 | 704 | ||
705 | /* | 705 | static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes) |
706 | * START OF "GENERIC" ENCODE ROUTINES. | 706 | { |
707 | * These may look a little ugly since they are imported from a "generic" | 707 | __be32 *p = xdr_reserve_space(xdr, nbytes); |
708 | * set of XDR encode/decode routines which are intended to be shared by | 708 | BUG_ON(!p); |
709 | * all of our NFSv4 implementations (OpenBSD, MacOS X...). | 709 | return p; |
710 | * | 710 | } |
711 | * If the pain of reading these is too great, it should be a straightforward | ||
712 | * task to translate them into Linux-specific versions which are more | ||
713 | * consistent with the style used in NFSv2/v3... | ||
714 | */ | ||
715 | #define WRITE32(n) *p++ = htonl(n) | ||
716 | #define WRITE64(n) do { \ | ||
717 | *p++ = htonl((uint32_t)((n) >> 32)); \ | ||
718 | *p++ = htonl((uint32_t)(n)); \ | ||
719 | } while (0) | ||
720 | #define WRITEMEM(ptr,nbytes) do { \ | ||
721 | p = xdr_encode_opaque_fixed(p, ptr, nbytes); \ | ||
722 | } while (0) | ||
723 | |||
724 | #define RESERVE_SPACE(nbytes) do { \ | ||
725 | p = xdr_reserve_space(xdr, nbytes); \ | ||
726 | BUG_ON(!p); \ | ||
727 | } while (0) | ||
728 | 711 | ||
729 | static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str) | 712 | static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str) |
730 | { | 713 | { |
@@ -749,12 +732,11 @@ static void encode_compound_hdr(struct xdr_stream *xdr, | |||
749 | 732 | ||
750 | dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag); | 733 | dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag); |
751 | BUG_ON(hdr->taglen > NFS4_MAXTAGLEN); | 734 | BUG_ON(hdr->taglen > NFS4_MAXTAGLEN); |
752 | RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2)); | 735 | p = reserve_space(xdr, 4 + hdr->taglen + 8); |
753 | WRITE32(hdr->taglen); | 736 | p = xdr_encode_opaque(p, hdr->tag, hdr->taglen); |
754 | WRITEMEM(hdr->tag, hdr->taglen); | 737 | *p++ = cpu_to_be32(hdr->minorversion); |
755 | WRITE32(hdr->minorversion); | ||
756 | hdr->nops_p = p; | 738 | hdr->nops_p = p; |
757 | WRITE32(hdr->nops); | 739 | *p = cpu_to_be32(hdr->nops); |
758 | } | 740 | } |
759 | 741 | ||
760 | static void encode_nops(struct compound_hdr *hdr) | 742 | static void encode_nops(struct compound_hdr *hdr) |
@@ -829,55 +811,53 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const | |||
829 | len += 16; | 811 | len += 16; |
830 | else if (iap->ia_valid & ATTR_MTIME) | 812 | else if (iap->ia_valid & ATTR_MTIME) |
831 | len += 4; | 813 | len += 4; |
832 | RESERVE_SPACE(len); | 814 | p = reserve_space(xdr, len); |
833 | 815 | ||
834 | /* | 816 | /* |
835 | * We write the bitmap length now, but leave the bitmap and the attribute | 817 | * We write the bitmap length now, but leave the bitmap and the attribute |
836 | * buffer length to be backfilled at the end of this routine. | 818 | * buffer length to be backfilled at the end of this routine. |
837 | */ | 819 | */ |
838 | WRITE32(2); | 820 | *p++ = cpu_to_be32(2); |
839 | q = p; | 821 | q = p; |
840 | p += 3; | 822 | p += 3; |
841 | 823 | ||
842 | if (iap->ia_valid & ATTR_SIZE) { | 824 | if (iap->ia_valid & ATTR_SIZE) { |
843 | bmval0 |= FATTR4_WORD0_SIZE; | 825 | bmval0 |= FATTR4_WORD0_SIZE; |
844 | WRITE64(iap->ia_size); | 826 | p = xdr_encode_hyper(p, iap->ia_size); |
845 | } | 827 | } |
846 | if (iap->ia_valid & ATTR_MODE) { | 828 | if (iap->ia_valid & ATTR_MODE) { |
847 | bmval1 |= FATTR4_WORD1_MODE; | 829 | bmval1 |= FATTR4_WORD1_MODE; |
848 | WRITE32(iap->ia_mode & S_IALLUGO); | 830 | *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO); |
849 | } | 831 | } |
850 | if (iap->ia_valid & ATTR_UID) { | 832 | if (iap->ia_valid & ATTR_UID) { |
851 | bmval1 |= FATTR4_WORD1_OWNER; | 833 | bmval1 |= FATTR4_WORD1_OWNER; |
852 | WRITE32(owner_namelen); | 834 | p = xdr_encode_opaque(p, owner_name, owner_namelen); |
853 | WRITEMEM(owner_name, owner_namelen); | ||
854 | } | 835 | } |
855 | if (iap->ia_valid & ATTR_GID) { | 836 | if (iap->ia_valid & ATTR_GID) { |
856 | bmval1 |= FATTR4_WORD1_OWNER_GROUP; | 837 | bmval1 |= FATTR4_WORD1_OWNER_GROUP; |
857 | WRITE32(owner_grouplen); | 838 | p = xdr_encode_opaque(p, owner_group, owner_grouplen); |
858 | WRITEMEM(owner_group, owner_grouplen); | ||
859 | } | 839 | } |
860 | if (iap->ia_valid & ATTR_ATIME_SET) { | 840 | if (iap->ia_valid & ATTR_ATIME_SET) { |
861 | bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; | 841 | bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; |
862 | WRITE32(NFS4_SET_TO_CLIENT_TIME); | 842 | *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); |
863 | WRITE32(0); | 843 | *p++ = cpu_to_be32(0); |
864 | WRITE32(iap->ia_mtime.tv_sec); | 844 | *p++ = cpu_to_be32(iap->ia_mtime.tv_sec); |
865 | WRITE32(iap->ia_mtime.tv_nsec); | 845 | *p++ = cpu_to_be32(iap->ia_mtime.tv_nsec); |
866 | } | 846 | } |
867 | else if (iap->ia_valid & ATTR_ATIME) { | 847 | else if (iap->ia_valid & ATTR_ATIME) { |
868 | bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; | 848 | bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; |
869 | WRITE32(NFS4_SET_TO_SERVER_TIME); | 849 | *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME); |
870 | } | 850 | } |
871 | if (iap->ia_valid & ATTR_MTIME_SET) { | 851 | if (iap->ia_valid & ATTR_MTIME_SET) { |
872 | bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; | 852 | bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; |
873 | WRITE32(NFS4_SET_TO_CLIENT_TIME); | 853 | *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); |
874 | WRITE32(0); | 854 | *p++ = cpu_to_be32(0); |
875 | WRITE32(iap->ia_mtime.tv_sec); | 855 | *p++ = cpu_to_be32(iap->ia_mtime.tv_sec); |
876 | WRITE32(iap->ia_mtime.tv_nsec); | 856 | *p++ = cpu_to_be32(iap->ia_mtime.tv_nsec); |
877 | } | 857 | } |
878 | else if (iap->ia_valid & ATTR_MTIME) { | 858 | else if (iap->ia_valid & ATTR_MTIME) { |
879 | bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; | 859 | bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; |
880 | WRITE32(NFS4_SET_TO_SERVER_TIME); | 860 | *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME); |
881 | } | 861 | } |
882 | 862 | ||
883 | /* | 863 | /* |
@@ -891,7 +871,7 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const | |||
891 | len = (char *)p - (char *)q - 12; | 871 | len = (char *)p - (char *)q - 12; |
892 | *q++ = htonl(bmval0); | 872 | *q++ = htonl(bmval0); |
893 | *q++ = htonl(bmval1); | 873 | *q++ = htonl(bmval1); |
894 | *q++ = htonl(len); | 874 | *q = htonl(len); |
895 | 875 | ||
896 | /* out: */ | 876 | /* out: */ |
897 | } | 877 | } |
@@ -900,9 +880,9 @@ static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hd | |||
900 | { | 880 | { |
901 | __be32 *p; | 881 | __be32 *p; |
902 | 882 | ||
903 | RESERVE_SPACE(8); | 883 | p = reserve_space(xdr, 8); |
904 | WRITE32(OP_ACCESS); | 884 | *p++ = cpu_to_be32(OP_ACCESS); |
905 | WRITE32(access); | 885 | *p = cpu_to_be32(access); |
906 | hdr->nops++; | 886 | hdr->nops++; |
907 | hdr->replen += decode_access_maxsz; | 887 | hdr->replen += decode_access_maxsz; |
908 | } | 888 | } |
@@ -911,10 +891,10 @@ static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg | |||
911 | { | 891 | { |
912 | __be32 *p; | 892 | __be32 *p; |
913 | 893 | ||
914 | RESERVE_SPACE(8+NFS4_STATEID_SIZE); | 894 | p = reserve_space(xdr, 8+NFS4_STATEID_SIZE); |
915 | WRITE32(OP_CLOSE); | 895 | *p++ = cpu_to_be32(OP_CLOSE); |
916 | WRITE32(arg->seqid->sequence->counter); | 896 | *p++ = cpu_to_be32(arg->seqid->sequence->counter); |
917 | WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); | 897 | xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); |
918 | hdr->nops++; | 898 | hdr->nops++; |
919 | hdr->replen += decode_close_maxsz; | 899 | hdr->replen += decode_close_maxsz; |
920 | } | 900 | } |
@@ -923,10 +903,10 @@ static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *ar | |||
923 | { | 903 | { |
924 | __be32 *p; | 904 | __be32 *p; |
925 | 905 | ||
926 | RESERVE_SPACE(16); | 906 | p = reserve_space(xdr, 16); |
927 | WRITE32(OP_COMMIT); | 907 | *p++ = cpu_to_be32(OP_COMMIT); |
928 | WRITE64(args->offset); | 908 | p = xdr_encode_hyper(p, args->offset); |
929 | WRITE32(args->count); | 909 | *p = cpu_to_be32(args->count); |
930 | hdr->nops++; | 910 | hdr->nops++; |
931 | hdr->replen += decode_commit_maxsz; | 911 | hdr->replen += decode_commit_maxsz; |
932 | } | 912 | } |
@@ -935,30 +915,28 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg * | |||
935 | { | 915 | { |
936 | __be32 *p; | 916 | __be32 *p; |
937 | 917 | ||
938 | RESERVE_SPACE(8); | 918 | p = reserve_space(xdr, 8); |
939 | WRITE32(OP_CREATE); | 919 | *p++ = cpu_to_be32(OP_CREATE); |
940 | WRITE32(create->ftype); | 920 | *p = cpu_to_be32(create->ftype); |
941 | 921 | ||
942 | switch (create->ftype) { | 922 | switch (create->ftype) { |
943 | case NF4LNK: | 923 | case NF4LNK: |
944 | RESERVE_SPACE(4); | 924 | p = reserve_space(xdr, 4); |
945 | WRITE32(create->u.symlink.len); | 925 | *p = cpu_to_be32(create->u.symlink.len); |
946 | xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len); | 926 | xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len); |
947 | break; | 927 | break; |
948 | 928 | ||
949 | case NF4BLK: case NF4CHR: | 929 | case NF4BLK: case NF4CHR: |
950 | RESERVE_SPACE(8); | 930 | p = reserve_space(xdr, 8); |
951 | WRITE32(create->u.device.specdata1); | 931 | *p++ = cpu_to_be32(create->u.device.specdata1); |
952 | WRITE32(create->u.device.specdata2); | 932 | *p = cpu_to_be32(create->u.device.specdata2); |
953 | break; | 933 | break; |
954 | 934 | ||
955 | default: | 935 | default: |
956 | break; | 936 | break; |
957 | } | 937 | } |
958 | 938 | ||
959 | RESERVE_SPACE(4 + create->name->len); | 939 | encode_string(xdr, create->name->len, create->name->name); |
960 | WRITE32(create->name->len); | ||
961 | WRITEMEM(create->name->name, create->name->len); | ||
962 | hdr->nops++; | 940 | hdr->nops++; |
963 | hdr->replen += decode_create_maxsz; | 941 | hdr->replen += decode_create_maxsz; |
964 | 942 | ||
@@ -969,10 +947,10 @@ static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct c | |||
969 | { | 947 | { |
970 | __be32 *p; | 948 | __be32 *p; |
971 | 949 | ||
972 | RESERVE_SPACE(12); | 950 | p = reserve_space(xdr, 12); |
973 | WRITE32(OP_GETATTR); | 951 | *p++ = cpu_to_be32(OP_GETATTR); |
974 | WRITE32(1); | 952 | *p++ = cpu_to_be32(1); |
975 | WRITE32(bitmap); | 953 | *p = cpu_to_be32(bitmap); |
976 | hdr->nops++; | 954 | hdr->nops++; |
977 | hdr->replen += decode_getattr_maxsz; | 955 | hdr->replen += decode_getattr_maxsz; |
978 | } | 956 | } |
@@ -981,11 +959,11 @@ static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm | |||
981 | { | 959 | { |
982 | __be32 *p; | 960 | __be32 *p; |
983 | 961 | ||
984 | RESERVE_SPACE(16); | 962 | p = reserve_space(xdr, 16); |
985 | WRITE32(OP_GETATTR); | 963 | *p++ = cpu_to_be32(OP_GETATTR); |
986 | WRITE32(2); | 964 | *p++ = cpu_to_be32(2); |
987 | WRITE32(bm0); | 965 | *p++ = cpu_to_be32(bm0); |
988 | WRITE32(bm1); | 966 | *p = cpu_to_be32(bm1); |
989 | hdr->nops++; | 967 | hdr->nops++; |
990 | hdr->replen += decode_getattr_maxsz; | 968 | hdr->replen += decode_getattr_maxsz; |
991 | } | 969 | } |
@@ -1012,8 +990,8 @@ static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr) | |||
1012 | { | 990 | { |
1013 | __be32 *p; | 991 | __be32 *p; |
1014 | 992 | ||
1015 | RESERVE_SPACE(4); | 993 | p = reserve_space(xdr, 4); |
1016 | WRITE32(OP_GETFH); | 994 | *p = cpu_to_be32(OP_GETFH); |
1017 | hdr->nops++; | 995 | hdr->nops++; |
1018 | hdr->replen += decode_getfh_maxsz; | 996 | hdr->replen += decode_getfh_maxsz; |
1019 | } | 997 | } |
@@ -1022,10 +1000,9 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct | |||
1022 | { | 1000 | { |
1023 | __be32 *p; | 1001 | __be32 *p; |
1024 | 1002 | ||
1025 | RESERVE_SPACE(8 + name->len); | 1003 | p = reserve_space(xdr, 8 + name->len); |
1026 | WRITE32(OP_LINK); | 1004 | *p++ = cpu_to_be32(OP_LINK); |
1027 | WRITE32(name->len); | 1005 | xdr_encode_opaque(p, name->name, name->len); |
1028 | WRITEMEM(name->name, name->len); | ||
1029 | hdr->nops++; | 1006 | hdr->nops++; |
1030 | hdr->replen += decode_link_maxsz; | 1007 | hdr->replen += decode_link_maxsz; |
1031 | } | 1008 | } |
@@ -1052,27 +1029,27 @@ static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args | |||
1052 | { | 1029 | { |
1053 | __be32 *p; | 1030 | __be32 *p; |
1054 | 1031 | ||
1055 | RESERVE_SPACE(32); | 1032 | p = reserve_space(xdr, 32); |
1056 | WRITE32(OP_LOCK); | 1033 | *p++ = cpu_to_be32(OP_LOCK); |
1057 | WRITE32(nfs4_lock_type(args->fl, args->block)); | 1034 | *p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block)); |
1058 | WRITE32(args->reclaim); | 1035 | *p++ = cpu_to_be32(args->reclaim); |
1059 | WRITE64(args->fl->fl_start); | 1036 | p = xdr_encode_hyper(p, args->fl->fl_start); |
1060 | WRITE64(nfs4_lock_length(args->fl)); | 1037 | p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); |
1061 | WRITE32(args->new_lock_owner); | 1038 | *p = cpu_to_be32(args->new_lock_owner); |
1062 | if (args->new_lock_owner){ | 1039 | if (args->new_lock_owner){ |
1063 | RESERVE_SPACE(4+NFS4_STATEID_SIZE+32); | 1040 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+32); |
1064 | WRITE32(args->open_seqid->sequence->counter); | 1041 | *p++ = cpu_to_be32(args->open_seqid->sequence->counter); |
1065 | WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE); | 1042 | p = xdr_encode_opaque_fixed(p, args->open_stateid->data, NFS4_STATEID_SIZE); |
1066 | WRITE32(args->lock_seqid->sequence->counter); | 1043 | *p++ = cpu_to_be32(args->lock_seqid->sequence->counter); |
1067 | WRITE64(args->lock_owner.clientid); | 1044 | p = xdr_encode_hyper(p, args->lock_owner.clientid); |
1068 | WRITE32(16); | 1045 | *p++ = cpu_to_be32(16); |
1069 | WRITEMEM("lock id:", 8); | 1046 | p = xdr_encode_opaque_fixed(p, "lock id:", 8); |
1070 | WRITE64(args->lock_owner.id); | 1047 | xdr_encode_hyper(p, args->lock_owner.id); |
1071 | } | 1048 | } |
1072 | else { | 1049 | else { |
1073 | RESERVE_SPACE(NFS4_STATEID_SIZE+4); | 1050 | p = reserve_space(xdr, NFS4_STATEID_SIZE+4); |
1074 | WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE); | 1051 | p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE); |
1075 | WRITE32(args->lock_seqid->sequence->counter); | 1052 | *p = cpu_to_be32(args->lock_seqid->sequence->counter); |
1076 | } | 1053 | } |
1077 | hdr->nops++; | 1054 | hdr->nops++; |
1078 | hdr->replen += decode_lock_maxsz; | 1055 | hdr->replen += decode_lock_maxsz; |
@@ -1082,15 +1059,15 @@ static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *ar | |||
1082 | { | 1059 | { |
1083 | __be32 *p; | 1060 | __be32 *p; |
1084 | 1061 | ||
1085 | RESERVE_SPACE(52); | 1062 | p = reserve_space(xdr, 52); |
1086 | WRITE32(OP_LOCKT); | 1063 | *p++ = cpu_to_be32(OP_LOCKT); |
1087 | WRITE32(nfs4_lock_type(args->fl, 0)); | 1064 | *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0)); |
1088 | WRITE64(args->fl->fl_start); | 1065 | p = xdr_encode_hyper(p, args->fl->fl_start); |
1089 | WRITE64(nfs4_lock_length(args->fl)); | 1066 | p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); |
1090 | WRITE64(args->lock_owner.clientid); | 1067 | p = xdr_encode_hyper(p, args->lock_owner.clientid); |
1091 | WRITE32(16); | 1068 | *p++ = cpu_to_be32(16); |
1092 | WRITEMEM("lock id:", 8); | 1069 | p = xdr_encode_opaque_fixed(p, "lock id:", 8); |
1093 | WRITE64(args->lock_owner.id); | 1070 | xdr_encode_hyper(p, args->lock_owner.id); |
1094 | hdr->nops++; | 1071 | hdr->nops++; |
1095 | hdr->replen += decode_lockt_maxsz; | 1072 | hdr->replen += decode_lockt_maxsz; |
1096 | } | 1073 | } |
@@ -1099,13 +1076,13 @@ static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *ar | |||
1099 | { | 1076 | { |
1100 | __be32 *p; | 1077 | __be32 *p; |
1101 | 1078 | ||
1102 | RESERVE_SPACE(12+NFS4_STATEID_SIZE+16); | 1079 | p = reserve_space(xdr, 12+NFS4_STATEID_SIZE+16); |
1103 | WRITE32(OP_LOCKU); | 1080 | *p++ = cpu_to_be32(OP_LOCKU); |
1104 | WRITE32(nfs4_lock_type(args->fl, 0)); | 1081 | *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0)); |
1105 | WRITE32(args->seqid->sequence->counter); | 1082 | *p++ = cpu_to_be32(args->seqid->sequence->counter); |
1106 | WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE); | 1083 | p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE); |
1107 | WRITE64(args->fl->fl_start); | 1084 | p = xdr_encode_hyper(p, args->fl->fl_start); |
1108 | WRITE64(nfs4_lock_length(args->fl)); | 1085 | xdr_encode_hyper(p, nfs4_lock_length(args->fl)); |
1109 | hdr->nops++; | 1086 | hdr->nops++; |
1110 | hdr->replen += decode_locku_maxsz; | 1087 | hdr->replen += decode_locku_maxsz; |
1111 | } | 1088 | } |
@@ -1115,10 +1092,9 @@ static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struc | |||
1115 | int len = name->len; | 1092 | int len = name->len; |
1116 | __be32 *p; | 1093 | __be32 *p; |
1117 | 1094 | ||
1118 | RESERVE_SPACE(8 + len); | 1095 | p = reserve_space(xdr, 8 + len); |
1119 | WRITE32(OP_LOOKUP); | 1096 | *p++ = cpu_to_be32(OP_LOOKUP); |
1120 | WRITE32(len); | 1097 | xdr_encode_opaque(p, name->name, len); |
1121 | WRITEMEM(name->name, len); | ||
1122 | hdr->nops++; | 1098 | hdr->nops++; |
1123 | hdr->replen += decode_lookup_maxsz; | 1099 | hdr->replen += decode_lookup_maxsz; |
1124 | } | 1100 | } |
@@ -1127,21 +1103,21 @@ static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode) | |||
1127 | { | 1103 | { |
1128 | __be32 *p; | 1104 | __be32 *p; |
1129 | 1105 | ||
1130 | RESERVE_SPACE(8); | 1106 | p = reserve_space(xdr, 8); |
1131 | switch (fmode & (FMODE_READ|FMODE_WRITE)) { | 1107 | switch (fmode & (FMODE_READ|FMODE_WRITE)) { |
1132 | case FMODE_READ: | 1108 | case FMODE_READ: |
1133 | WRITE32(NFS4_SHARE_ACCESS_READ); | 1109 | *p++ = cpu_to_be32(NFS4_SHARE_ACCESS_READ); |
1134 | break; | 1110 | break; |
1135 | case FMODE_WRITE: | 1111 | case FMODE_WRITE: |
1136 | WRITE32(NFS4_SHARE_ACCESS_WRITE); | 1112 | *p++ = cpu_to_be32(NFS4_SHARE_ACCESS_WRITE); |
1137 | break; | 1113 | break; |
1138 | case FMODE_READ|FMODE_WRITE: | 1114 | case FMODE_READ|FMODE_WRITE: |
1139 | WRITE32(NFS4_SHARE_ACCESS_BOTH); | 1115 | *p++ = cpu_to_be32(NFS4_SHARE_ACCESS_BOTH); |
1140 | break; | 1116 | break; |
1141 | default: | 1117 | default: |
1142 | WRITE32(0); | 1118 | *p++ = cpu_to_be32(0); |
1143 | } | 1119 | } |
1144 | WRITE32(0); /* for linux, share_deny = 0 always */ | 1120 | *p = cpu_to_be32(0); /* for linux, share_deny = 0 always */ |
1145 | } | 1121 | } |
1146 | 1122 | ||
1147 | static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg) | 1123 | static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg) |
@@ -1151,29 +1127,29 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena | |||
1151 | * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4, | 1127 | * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4, |
1152 | * owner 4 = 32 | 1128 | * owner 4 = 32 |
1153 | */ | 1129 | */ |
1154 | RESERVE_SPACE(8); | 1130 | p = reserve_space(xdr, 8); |
1155 | WRITE32(OP_OPEN); | 1131 | *p++ = cpu_to_be32(OP_OPEN); |
1156 | WRITE32(arg->seqid->sequence->counter); | 1132 | *p = cpu_to_be32(arg->seqid->sequence->counter); |
1157 | encode_share_access(xdr, arg->fmode); | 1133 | encode_share_access(xdr, arg->fmode); |
1158 | RESERVE_SPACE(28); | 1134 | p = reserve_space(xdr, 28); |
1159 | WRITE64(arg->clientid); | 1135 | p = xdr_encode_hyper(p, arg->clientid); |
1160 | WRITE32(16); | 1136 | *p++ = cpu_to_be32(16); |
1161 | WRITEMEM("open id:", 8); | 1137 | p = xdr_encode_opaque_fixed(p, "open id:", 8); |
1162 | WRITE64(arg->id); | 1138 | xdr_encode_hyper(p, arg->id); |
1163 | } | 1139 | } |
1164 | 1140 | ||
1165 | static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg) | 1141 | static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg) |
1166 | { | 1142 | { |
1167 | __be32 *p; | 1143 | __be32 *p; |
1168 | 1144 | ||
1169 | RESERVE_SPACE(4); | 1145 | p = reserve_space(xdr, 4); |
1170 | switch(arg->open_flags & O_EXCL) { | 1146 | switch(arg->open_flags & O_EXCL) { |
1171 | case 0: | 1147 | case 0: |
1172 | WRITE32(NFS4_CREATE_UNCHECKED); | 1148 | *p = cpu_to_be32(NFS4_CREATE_UNCHECKED); |
1173 | encode_attrs(xdr, arg->u.attrs, arg->server); | 1149 | encode_attrs(xdr, arg->u.attrs, arg->server); |
1174 | break; | 1150 | break; |
1175 | default: | 1151 | default: |
1176 | WRITE32(NFS4_CREATE_EXCLUSIVE); | 1152 | *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE); |
1177 | encode_nfs4_verifier(xdr, &arg->u.verifier); | 1153 | encode_nfs4_verifier(xdr, &arg->u.verifier); |
1178 | } | 1154 | } |
1179 | } | 1155 | } |
@@ -1182,14 +1158,14 @@ static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *a | |||
1182 | { | 1158 | { |
1183 | __be32 *p; | 1159 | __be32 *p; |
1184 | 1160 | ||
1185 | RESERVE_SPACE(4); | 1161 | p = reserve_space(xdr, 4); |
1186 | switch (arg->open_flags & O_CREAT) { | 1162 | switch (arg->open_flags & O_CREAT) { |
1187 | case 0: | 1163 | case 0: |
1188 | WRITE32(NFS4_OPEN_NOCREATE); | 1164 | *p = cpu_to_be32(NFS4_OPEN_NOCREATE); |
1189 | break; | 1165 | break; |
1190 | default: | 1166 | default: |
1191 | BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL); | 1167 | BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL); |
1192 | WRITE32(NFS4_OPEN_CREATE); | 1168 | *p = cpu_to_be32(NFS4_OPEN_CREATE); |
1193 | encode_createmode(xdr, arg); | 1169 | encode_createmode(xdr, arg); |
1194 | } | 1170 | } |
1195 | } | 1171 | } |
@@ -1198,16 +1174,16 @@ static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delega | |||
1198 | { | 1174 | { |
1199 | __be32 *p; | 1175 | __be32 *p; |
1200 | 1176 | ||
1201 | RESERVE_SPACE(4); | 1177 | p = reserve_space(xdr, 4); |
1202 | switch (delegation_type) { | 1178 | switch (delegation_type) { |
1203 | case 0: | 1179 | case 0: |
1204 | WRITE32(NFS4_OPEN_DELEGATE_NONE); | 1180 | *p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE); |
1205 | break; | 1181 | break; |
1206 | case FMODE_READ: | 1182 | case FMODE_READ: |
1207 | WRITE32(NFS4_OPEN_DELEGATE_READ); | 1183 | *p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ); |
1208 | break; | 1184 | break; |
1209 | case FMODE_WRITE|FMODE_READ: | 1185 | case FMODE_WRITE|FMODE_READ: |
1210 | WRITE32(NFS4_OPEN_DELEGATE_WRITE); | 1186 | *p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE); |
1211 | break; | 1187 | break; |
1212 | default: | 1188 | default: |
1213 | BUG(); | 1189 | BUG(); |
@@ -1218,8 +1194,8 @@ static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr * | |||
1218 | { | 1194 | { |
1219 | __be32 *p; | 1195 | __be32 *p; |
1220 | 1196 | ||
1221 | RESERVE_SPACE(4); | 1197 | p = reserve_space(xdr, 4); |
1222 | WRITE32(NFS4_OPEN_CLAIM_NULL); | 1198 | *p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL); |
1223 | encode_string(xdr, name->len, name->name); | 1199 | encode_string(xdr, name->len, name->name); |
1224 | } | 1200 | } |
1225 | 1201 | ||
@@ -1227,8 +1203,8 @@ static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type) | |||
1227 | { | 1203 | { |
1228 | __be32 *p; | 1204 | __be32 *p; |
1229 | 1205 | ||
1230 | RESERVE_SPACE(4); | 1206 | p = reserve_space(xdr, 4); |
1231 | WRITE32(NFS4_OPEN_CLAIM_PREVIOUS); | 1207 | *p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS); |
1232 | encode_delegation_type(xdr, type); | 1208 | encode_delegation_type(xdr, type); |
1233 | } | 1209 | } |
1234 | 1210 | ||
@@ -1236,9 +1212,9 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc | |||
1236 | { | 1212 | { |
1237 | __be32 *p; | 1213 | __be32 *p; |
1238 | 1214 | ||
1239 | RESERVE_SPACE(4+NFS4_STATEID_SIZE); | 1215 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); |
1240 | WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR); | 1216 | *p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR); |
1241 | WRITEMEM(stateid->data, NFS4_STATEID_SIZE); | 1217 | xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE); |
1242 | encode_string(xdr, name->len, name->name); | 1218 | encode_string(xdr, name->len, name->name); |
1243 | } | 1219 | } |
1244 | 1220 | ||
@@ -1267,10 +1243,10 @@ static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_co | |||
1267 | { | 1243 | { |
1268 | __be32 *p; | 1244 | __be32 *p; |
1269 | 1245 | ||
1270 | RESERVE_SPACE(4+NFS4_STATEID_SIZE+4); | 1246 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4); |
1271 | WRITE32(OP_OPEN_CONFIRM); | 1247 | *p++ = cpu_to_be32(OP_OPEN_CONFIRM); |
1272 | WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); | 1248 | p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); |
1273 | WRITE32(arg->seqid->sequence->counter); | 1249 | *p = cpu_to_be32(arg->seqid->sequence->counter); |
1274 | hdr->nops++; | 1250 | hdr->nops++; |
1275 | hdr->replen += decode_open_confirm_maxsz; | 1251 | hdr->replen += decode_open_confirm_maxsz; |
1276 | } | 1252 | } |
@@ -1279,10 +1255,10 @@ static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_close | |||
1279 | { | 1255 | { |
1280 | __be32 *p; | 1256 | __be32 *p; |
1281 | 1257 | ||
1282 | RESERVE_SPACE(4+NFS4_STATEID_SIZE+4); | 1258 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4); |
1283 | WRITE32(OP_OPEN_DOWNGRADE); | 1259 | *p++ = cpu_to_be32(OP_OPEN_DOWNGRADE); |
1284 | WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); | 1260 | p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); |
1285 | WRITE32(arg->seqid->sequence->counter); | 1261 | *p = cpu_to_be32(arg->seqid->sequence->counter); |
1286 | encode_share_access(xdr, arg->fmode); | 1262 | encode_share_access(xdr, arg->fmode); |
1287 | hdr->nops++; | 1263 | hdr->nops++; |
1288 | hdr->replen += decode_open_downgrade_maxsz; | 1264 | hdr->replen += decode_open_downgrade_maxsz; |
@@ -1294,10 +1270,9 @@ encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hd | |||
1294 | int len = fh->size; | 1270 | int len = fh->size; |
1295 | __be32 *p; | 1271 | __be32 *p; |
1296 | 1272 | ||
1297 | RESERVE_SPACE(8 + len); | 1273 | p = reserve_space(xdr, 8 + len); |
1298 | WRITE32(OP_PUTFH); | 1274 | *p++ = cpu_to_be32(OP_PUTFH); |
1299 | WRITE32(len); | 1275 | xdr_encode_opaque(p, fh->data, len); |
1300 | WRITEMEM(fh->data, len); | ||
1301 | hdr->nops++; | 1276 | hdr->nops++; |
1302 | hdr->replen += decode_putfh_maxsz; | 1277 | hdr->replen += decode_putfh_maxsz; |
1303 | } | 1278 | } |
@@ -1306,8 +1281,8 @@ static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr) | |||
1306 | { | 1281 | { |
1307 | __be32 *p; | 1282 | __be32 *p; |
1308 | 1283 | ||
1309 | RESERVE_SPACE(4); | 1284 | p = reserve_space(xdr, 4); |
1310 | WRITE32(OP_PUTROOTFH); | 1285 | *p = cpu_to_be32(OP_PUTROOTFH); |
1311 | hdr->nops++; | 1286 | hdr->nops++; |
1312 | hdr->replen += decode_putrootfh_maxsz; | 1287 | hdr->replen += decode_putrootfh_maxsz; |
1313 | } | 1288 | } |
@@ -1317,26 +1292,26 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context | |||
1317 | nfs4_stateid stateid; | 1292 | nfs4_stateid stateid; |
1318 | __be32 *p; | 1293 | __be32 *p; |
1319 | 1294 | ||
1320 | RESERVE_SPACE(NFS4_STATEID_SIZE); | 1295 | p = reserve_space(xdr, NFS4_STATEID_SIZE); |
1321 | if (ctx->state != NULL) { | 1296 | if (ctx->state != NULL) { |
1322 | nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner); | 1297 | nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner); |
1323 | WRITEMEM(stateid.data, NFS4_STATEID_SIZE); | 1298 | xdr_encode_opaque_fixed(p, stateid.data, NFS4_STATEID_SIZE); |
1324 | } else | 1299 | } else |
1325 | WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE); | 1300 | xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE); |
1326 | } | 1301 | } |
1327 | 1302 | ||
1328 | static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr) | 1303 | static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr) |
1329 | { | 1304 | { |
1330 | __be32 *p; | 1305 | __be32 *p; |
1331 | 1306 | ||
1332 | RESERVE_SPACE(4); | 1307 | p = reserve_space(xdr, 4); |
1333 | WRITE32(OP_READ); | 1308 | *p = cpu_to_be32(OP_READ); |
1334 | 1309 | ||
1335 | encode_stateid(xdr, args->context); | 1310 | encode_stateid(xdr, args->context); |
1336 | 1311 | ||
1337 | RESERVE_SPACE(12); | 1312 | p = reserve_space(xdr, 12); |
1338 | WRITE64(args->offset); | 1313 | p = xdr_encode_hyper(p, args->offset); |
1339 | WRITE32(args->count); | 1314 | *p = cpu_to_be32(args->count); |
1340 | hdr->nops++; | 1315 | hdr->nops++; |
1341 | hdr->replen += decode_read_maxsz; | 1316 | hdr->replen += decode_read_maxsz; |
1342 | } | 1317 | } |
@@ -1349,20 +1324,20 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg | |||
1349 | }; | 1324 | }; |
1350 | __be32 *p; | 1325 | __be32 *p; |
1351 | 1326 | ||
1352 | RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20); | 1327 | p = reserve_space(xdr, 12+NFS4_VERIFIER_SIZE+20); |
1353 | WRITE32(OP_READDIR); | 1328 | *p++ = cpu_to_be32(OP_READDIR); |
1354 | WRITE64(readdir->cookie); | 1329 | p = xdr_encode_hyper(p, readdir->cookie); |
1355 | WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE); | 1330 | p = xdr_encode_opaque_fixed(p, readdir->verifier.data, NFS4_VERIFIER_SIZE); |
1356 | WRITE32(readdir->count >> 1); /* We're not doing readdirplus */ | 1331 | *p++ = cpu_to_be32(readdir->count >> 1); /* We're not doing readdirplus */ |
1357 | WRITE32(readdir->count); | 1332 | *p++ = cpu_to_be32(readdir->count); |
1358 | WRITE32(2); | 1333 | *p++ = cpu_to_be32(2); |
1359 | /* Switch to mounted_on_fileid if the server supports it */ | 1334 | /* Switch to mounted_on_fileid if the server supports it */ |
1360 | if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) | 1335 | if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) |
1361 | attrs[0] &= ~FATTR4_WORD0_FILEID; | 1336 | attrs[0] &= ~FATTR4_WORD0_FILEID; |
1362 | else | 1337 | else |
1363 | attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; | 1338 | attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; |
1364 | WRITE32(attrs[0] & readdir->bitmask[0]); | 1339 | *p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]); |
1365 | WRITE32(attrs[1] & readdir->bitmask[1]); | 1340 | *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]); |
1366 | hdr->nops++; | 1341 | hdr->nops++; |
1367 | hdr->replen += decode_readdir_maxsz; | 1342 | hdr->replen += decode_readdir_maxsz; |
1368 | dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n", | 1343 | dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n", |
@@ -1378,8 +1353,8 @@ static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink * | |||
1378 | { | 1353 | { |
1379 | __be32 *p; | 1354 | __be32 *p; |
1380 | 1355 | ||
1381 | RESERVE_SPACE(4); | 1356 | p = reserve_space(xdr, 4); |
1382 | WRITE32(OP_READLINK); | 1357 | *p = cpu_to_be32(OP_READLINK); |
1383 | hdr->nops++; | 1358 | hdr->nops++; |
1384 | hdr->replen += decode_readlink_maxsz; | 1359 | hdr->replen += decode_readlink_maxsz; |
1385 | } | 1360 | } |
@@ -1388,10 +1363,9 @@ static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struc | |||
1388 | { | 1363 | { |
1389 | __be32 *p; | 1364 | __be32 *p; |
1390 | 1365 | ||
1391 | RESERVE_SPACE(8 + name->len); | 1366 | p = reserve_space(xdr, 8 + name->len); |
1392 | WRITE32(OP_REMOVE); | 1367 | *p++ = cpu_to_be32(OP_REMOVE); |
1393 | WRITE32(name->len); | 1368 | xdr_encode_opaque(p, name->name, name->len); |
1394 | WRITEMEM(name->name, name->len); | ||
1395 | hdr->nops++; | 1369 | hdr->nops++; |
1396 | hdr->replen += decode_remove_maxsz; | 1370 | hdr->replen += decode_remove_maxsz; |
1397 | } | 1371 | } |
@@ -1400,14 +1374,10 @@ static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, co | |||
1400 | { | 1374 | { |
1401 | __be32 *p; | 1375 | __be32 *p; |
1402 | 1376 | ||
1403 | RESERVE_SPACE(8 + oldname->len); | 1377 | p = reserve_space(xdr, 4); |
1404 | WRITE32(OP_RENAME); | 1378 | *p = cpu_to_be32(OP_RENAME); |
1405 | WRITE32(oldname->len); | 1379 | encode_string(xdr, oldname->len, oldname->name); |
1406 | WRITEMEM(oldname->name, oldname->len); | 1380 | encode_string(xdr, newname->len, newname->name); |
1407 | |||
1408 | RESERVE_SPACE(4 + newname->len); | ||
1409 | WRITE32(newname->len); | ||
1410 | WRITEMEM(newname->name, newname->len); | ||
1411 | hdr->nops++; | 1381 | hdr->nops++; |
1412 | hdr->replen += decode_rename_maxsz; | 1382 | hdr->replen += decode_rename_maxsz; |
1413 | } | 1383 | } |
@@ -1416,9 +1386,9 @@ static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *client | |||
1416 | { | 1386 | { |
1417 | __be32 *p; | 1387 | __be32 *p; |
1418 | 1388 | ||
1419 | RESERVE_SPACE(12); | 1389 | p = reserve_space(xdr, 12); |
1420 | WRITE32(OP_RENEW); | 1390 | *p++ = cpu_to_be32(OP_RENEW); |
1421 | WRITE64(client_stateid->cl_clientid); | 1391 | xdr_encode_hyper(p, client_stateid->cl_clientid); |
1422 | hdr->nops++; | 1392 | hdr->nops++; |
1423 | hdr->replen += decode_renew_maxsz; | 1393 | hdr->replen += decode_renew_maxsz; |
1424 | } | 1394 | } |
@@ -1428,8 +1398,8 @@ encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr) | |||
1428 | { | 1398 | { |
1429 | __be32 *p; | 1399 | __be32 *p; |
1430 | 1400 | ||
1431 | RESERVE_SPACE(4); | 1401 | p = reserve_space(xdr, 4); |
1432 | WRITE32(OP_RESTOREFH); | 1402 | *p = cpu_to_be32(OP_RESTOREFH); |
1433 | hdr->nops++; | 1403 | hdr->nops++; |
1434 | hdr->replen += decode_restorefh_maxsz; | 1404 | hdr->replen += decode_restorefh_maxsz; |
1435 | } | 1405 | } |
@@ -1439,16 +1409,16 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compoun | |||
1439 | { | 1409 | { |
1440 | __be32 *p; | 1410 | __be32 *p; |
1441 | 1411 | ||
1442 | RESERVE_SPACE(4+NFS4_STATEID_SIZE); | 1412 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); |
1443 | WRITE32(OP_SETATTR); | 1413 | *p++ = cpu_to_be32(OP_SETATTR); |
1444 | WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE); | 1414 | xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE); |
1445 | RESERVE_SPACE(2*4); | 1415 | p = reserve_space(xdr, 2*4); |
1446 | WRITE32(1); | 1416 | *p++ = cpu_to_be32(1); |
1447 | WRITE32(FATTR4_WORD0_ACL); | 1417 | *p = cpu_to_be32(FATTR4_WORD0_ACL); |
1448 | if (arg->acl_len % 4) | 1418 | if (arg->acl_len % 4) |
1449 | return -EINVAL; | 1419 | return -EINVAL; |
1450 | RESERVE_SPACE(4); | 1420 | p = reserve_space(xdr, 4); |
1451 | WRITE32(arg->acl_len); | 1421 | *p = cpu_to_be32(arg->acl_len); |
1452 | xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len); | 1422 | xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len); |
1453 | hdr->nops++; | 1423 | hdr->nops++; |
1454 | hdr->replen += decode_setacl_maxsz; | 1424 | hdr->replen += decode_setacl_maxsz; |
@@ -1460,8 +1430,8 @@ encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr) | |||
1460 | { | 1430 | { |
1461 | __be32 *p; | 1431 | __be32 *p; |
1462 | 1432 | ||
1463 | RESERVE_SPACE(4); | 1433 | p = reserve_space(xdr, 4); |
1464 | WRITE32(OP_SAVEFH); | 1434 | *p = cpu_to_be32(OP_SAVEFH); |
1465 | hdr->nops++; | 1435 | hdr->nops++; |
1466 | hdr->replen += decode_savefh_maxsz; | 1436 | hdr->replen += decode_savefh_maxsz; |
1467 | } | 1437 | } |
@@ -1470,9 +1440,9 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs | |||
1470 | { | 1440 | { |
1471 | __be32 *p; | 1441 | __be32 *p; |
1472 | 1442 | ||
1473 | RESERVE_SPACE(4+NFS4_STATEID_SIZE); | 1443 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); |
1474 | WRITE32(OP_SETATTR); | 1444 | *p++ = cpu_to_be32(OP_SETATTR); |
1475 | WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE); | 1445 | xdr_encode_opaque_fixed(p, arg->stateid.data, NFS4_STATEID_SIZE); |
1476 | hdr->nops++; | 1446 | hdr->nops++; |
1477 | hdr->replen += decode_setattr_maxsz; | 1447 | hdr->replen += decode_setattr_maxsz; |
1478 | encode_attrs(xdr, arg->iap, server); | 1448 | encode_attrs(xdr, arg->iap, server); |
@@ -1482,17 +1452,17 @@ static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclie | |||
1482 | { | 1452 | { |
1483 | __be32 *p; | 1453 | __be32 *p; |
1484 | 1454 | ||
1485 | RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE); | 1455 | p = reserve_space(xdr, 4 + NFS4_VERIFIER_SIZE); |
1486 | WRITE32(OP_SETCLIENTID); | 1456 | *p++ = cpu_to_be32(OP_SETCLIENTID); |
1487 | WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE); | 1457 | xdr_encode_opaque_fixed(p, setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE); |
1488 | 1458 | ||
1489 | encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name); | 1459 | encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name); |
1490 | RESERVE_SPACE(4); | 1460 | p = reserve_space(xdr, 4); |
1491 | WRITE32(setclientid->sc_prog); | 1461 | *p = cpu_to_be32(setclientid->sc_prog); |
1492 | encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid); | 1462 | encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid); |
1493 | encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr); | 1463 | encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr); |
1494 | RESERVE_SPACE(4); | 1464 | p = reserve_space(xdr, 4); |
1495 | WRITE32(setclientid->sc_cb_ident); | 1465 | *p = cpu_to_be32(setclientid->sc_cb_ident); |
1496 | hdr->nops++; | 1466 | hdr->nops++; |
1497 | hdr->replen += decode_setclientid_maxsz; | 1467 | hdr->replen += decode_setclientid_maxsz; |
1498 | } | 1468 | } |
@@ -1501,10 +1471,10 @@ static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_ | |||
1501 | { | 1471 | { |
1502 | __be32 *p; | 1472 | __be32 *p; |
1503 | 1473 | ||
1504 | RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE); | 1474 | p = reserve_space(xdr, 12 + NFS4_VERIFIER_SIZE); |
1505 | WRITE32(OP_SETCLIENTID_CONFIRM); | 1475 | *p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM); |
1506 | WRITE64(client_state->cl_clientid); | 1476 | p = xdr_encode_hyper(p, client_state->cl_clientid); |
1507 | WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE); | 1477 | xdr_encode_opaque_fixed(p, client_state->cl_confirm.data, NFS4_VERIFIER_SIZE); |
1508 | hdr->nops++; | 1478 | hdr->nops++; |
1509 | hdr->replen += decode_setclientid_confirm_maxsz; | 1479 | hdr->replen += decode_setclientid_confirm_maxsz; |
1510 | } | 1480 | } |
@@ -1513,15 +1483,15 @@ static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *arg | |||
1513 | { | 1483 | { |
1514 | __be32 *p; | 1484 | __be32 *p; |
1515 | 1485 | ||
1516 | RESERVE_SPACE(4); | 1486 | p = reserve_space(xdr, 4); |
1517 | WRITE32(OP_WRITE); | 1487 | *p = cpu_to_be32(OP_WRITE); |
1518 | 1488 | ||
1519 | encode_stateid(xdr, args->context); | 1489 | encode_stateid(xdr, args->context); |
1520 | 1490 | ||
1521 | RESERVE_SPACE(16); | 1491 | p = reserve_space(xdr, 16); |
1522 | WRITE64(args->offset); | 1492 | p = xdr_encode_hyper(p, args->offset); |
1523 | WRITE32(args->stable); | 1493 | *p++ = cpu_to_be32(args->stable); |
1524 | WRITE32(args->count); | 1494 | *p = cpu_to_be32(args->count); |
1525 | 1495 | ||
1526 | xdr_write_pages(xdr, args->pages, args->pgbase, args->count); | 1496 | xdr_write_pages(xdr, args->pages, args->pgbase, args->count); |
1527 | hdr->nops++; | 1497 | hdr->nops++; |
@@ -1532,10 +1502,10 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *state | |||
1532 | { | 1502 | { |
1533 | __be32 *p; | 1503 | __be32 *p; |
1534 | 1504 | ||
1535 | RESERVE_SPACE(4+NFS4_STATEID_SIZE); | 1505 | p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); |
1536 | 1506 | ||
1537 | WRITE32(OP_DELEGRETURN); | 1507 | *p++ = cpu_to_be32(OP_DELEGRETURN); |
1538 | WRITEMEM(stateid->data, NFS4_STATEID_SIZE); | 1508 | xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE); |
1539 | hdr->nops++; | 1509 | hdr->nops++; |
1540 | hdr->replen += decode_delegreturn_maxsz; | 1510 | hdr->replen += decode_delegreturn_maxsz; |
1541 | } | 1511 | } |
@@ -1548,16 +1518,16 @@ static void encode_exchange_id(struct xdr_stream *xdr, | |||
1548 | { | 1518 | { |
1549 | __be32 *p; | 1519 | __be32 *p; |
1550 | 1520 | ||
1551 | RESERVE_SPACE(4 + sizeof(args->verifier->data)); | 1521 | p = reserve_space(xdr, 4 + sizeof(args->verifier->data)); |
1552 | WRITE32(OP_EXCHANGE_ID); | 1522 | *p++ = cpu_to_be32(OP_EXCHANGE_ID); |
1553 | WRITEMEM(args->verifier->data, sizeof(args->verifier->data)); | 1523 | xdr_encode_opaque_fixed(p, args->verifier->data, sizeof(args->verifier->data)); |
1554 | 1524 | ||
1555 | encode_string(xdr, args->id_len, args->id); | 1525 | encode_string(xdr, args->id_len, args->id); |
1556 | 1526 | ||
1557 | RESERVE_SPACE(12); | 1527 | p = reserve_space(xdr, 12); |
1558 | WRITE32(args->flags); | 1528 | *p++ = cpu_to_be32(args->flags); |
1559 | WRITE32(0); /* zero length state_protect4_a */ | 1529 | *p++ = cpu_to_be32(0); /* zero length state_protect4_a */ |
1560 | WRITE32(0); /* zero length implementation id array */ | 1530 | *p = cpu_to_be32(0); /* zero length implementation id array */ |
1561 | hdr->nops++; | 1531 | hdr->nops++; |
1562 | hdr->replen += decode_exchange_id_maxsz; | 1532 | hdr->replen += decode_exchange_id_maxsz; |
1563 | } | 1533 | } |
@@ -1571,55 +1541,43 @@ static void encode_create_session(struct xdr_stream *xdr, | |||
1571 | uint32_t len; | 1541 | uint32_t len; |
1572 | struct nfs_client *clp = args->client; | 1542 | struct nfs_client *clp = args->client; |
1573 | 1543 | ||
1574 | RESERVE_SPACE(4); | 1544 | len = scnprintf(machine_name, sizeof(machine_name), "%s", |
1575 | WRITE32(OP_CREATE_SESSION); | 1545 | clp->cl_ipaddr); |
1576 | |||
1577 | RESERVE_SPACE(8); | ||
1578 | WRITE64(clp->cl_ex_clid); | ||
1579 | 1546 | ||
1580 | RESERVE_SPACE(8); | 1547 | p = reserve_space(xdr, 20 + 2*28 + 20 + len + 12); |
1581 | WRITE32(clp->cl_seqid); /*Sequence id */ | 1548 | *p++ = cpu_to_be32(OP_CREATE_SESSION); |
1582 | WRITE32(args->flags); /*flags */ | 1549 | p = xdr_encode_hyper(p, clp->cl_ex_clid); |
1550 | *p++ = cpu_to_be32(clp->cl_seqid); /*Sequence id */ | ||
1551 | *p++ = cpu_to_be32(args->flags); /*flags */ | ||
1583 | 1552 | ||
1584 | RESERVE_SPACE(2*28); /* 2 channel_attrs */ | ||
1585 | /* Fore Channel */ | 1553 | /* Fore Channel */ |
1586 | WRITE32(args->fc_attrs.headerpadsz); /* header padding size */ | 1554 | *p++ = cpu_to_be32(args->fc_attrs.headerpadsz); /* header padding size */ |
1587 | WRITE32(args->fc_attrs.max_rqst_sz); /* max req size */ | 1555 | *p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz); /* max req size */ |
1588 | WRITE32(args->fc_attrs.max_resp_sz); /* max resp size */ | 1556 | *p++ = cpu_to_be32(args->fc_attrs.max_resp_sz); /* max resp size */ |
1589 | WRITE32(args->fc_attrs.max_resp_sz_cached); /* Max resp sz cached */ | 1557 | *p++ = cpu_to_be32(args->fc_attrs.max_resp_sz_cached); /* Max resp sz cached */ |
1590 | WRITE32(args->fc_attrs.max_ops); /* max operations */ | 1558 | *p++ = cpu_to_be32(args->fc_attrs.max_ops); /* max operations */ |
1591 | WRITE32(args->fc_attrs.max_reqs); /* max requests */ | 1559 | *p++ = cpu_to_be32(args->fc_attrs.max_reqs); /* max requests */ |
1592 | WRITE32(0); /* rdmachannel_attrs */ | 1560 | *p++ = cpu_to_be32(0); /* rdmachannel_attrs */ |
1593 | 1561 | ||
1594 | /* Back Channel */ | 1562 | /* Back Channel */ |
1595 | WRITE32(args->fc_attrs.headerpadsz); /* header padding size */ | 1563 | *p++ = cpu_to_be32(args->fc_attrs.headerpadsz); /* header padding size */ |
1596 | WRITE32(args->bc_attrs.max_rqst_sz); /* max req size */ | 1564 | *p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz); /* max req size */ |
1597 | WRITE32(args->bc_attrs.max_resp_sz); /* max resp size */ | 1565 | *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz); /* max resp size */ |
1598 | WRITE32(args->bc_attrs.max_resp_sz_cached); /* Max resp sz cached */ | 1566 | *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached); /* Max resp sz cached */ |
1599 | WRITE32(args->bc_attrs.max_ops); /* max operations */ | 1567 | *p++ = cpu_to_be32(args->bc_attrs.max_ops); /* max operations */ |
1600 | WRITE32(args->bc_attrs.max_reqs); /* max requests */ | 1568 | *p++ = cpu_to_be32(args->bc_attrs.max_reqs); /* max requests */ |
1601 | WRITE32(0); /* rdmachannel_attrs */ | 1569 | *p++ = cpu_to_be32(0); /* rdmachannel_attrs */ |
1602 | 1570 | ||
1603 | RESERVE_SPACE(4); | 1571 | *p++ = cpu_to_be32(args->cb_program); /* cb_program */ |
1604 | WRITE32(args->cb_program); /* cb_program */ | 1572 | *p++ = cpu_to_be32(1); |
1605 | 1573 | *p++ = cpu_to_be32(RPC_AUTH_UNIX); /* auth_sys */ | |
1606 | RESERVE_SPACE(4); /* # of security flavors */ | ||
1607 | WRITE32(1); | ||
1608 | |||
1609 | RESERVE_SPACE(4); | ||
1610 | WRITE32(RPC_AUTH_UNIX); /* auth_sys */ | ||
1611 | 1574 | ||
1612 | /* authsys_parms rfc1831 */ | 1575 | /* authsys_parms rfc1831 */ |
1613 | RESERVE_SPACE(4); | 1576 | *p++ = cpu_to_be32((u32)clp->cl_boot_time.tv_nsec); /* stamp */ |
1614 | WRITE32((u32)clp->cl_boot_time.tv_nsec); /* stamp */ | 1577 | p = xdr_encode_opaque(p, machine_name, len); |
1615 | len = scnprintf(machine_name, sizeof(machine_name), "%s", | 1578 | *p++ = cpu_to_be32(0); /* UID */ |
1616 | clp->cl_ipaddr); | 1579 | *p++ = cpu_to_be32(0); /* GID */ |
1617 | RESERVE_SPACE(16 + len); | 1580 | *p = cpu_to_be32(0); /* No more gids */ |
1618 | WRITE32(len); | ||
1619 | WRITEMEM(machine_name, len); | ||
1620 | WRITE32(0); /* UID */ | ||
1621 | WRITE32(0); /* GID */ | ||
1622 | WRITE32(0); /* No more gids */ | ||
1623 | hdr->nops++; | 1581 | hdr->nops++; |
1624 | hdr->replen += decode_create_session_maxsz; | 1582 | hdr->replen += decode_create_session_maxsz; |
1625 | } | 1583 | } |
@@ -1629,9 +1587,9 @@ static void encode_destroy_session(struct xdr_stream *xdr, | |||
1629 | struct compound_hdr *hdr) | 1587 | struct compound_hdr *hdr) |
1630 | { | 1588 | { |
1631 | __be32 *p; | 1589 | __be32 *p; |
1632 | RESERVE_SPACE(4 + NFS4_MAX_SESSIONID_LEN); | 1590 | p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN); |
1633 | WRITE32(OP_DESTROY_SESSION); | 1591 | *p++ = cpu_to_be32(OP_DESTROY_SESSION); |
1634 | WRITEMEM(session->sess_id.data, NFS4_MAX_SESSIONID_LEN); | 1592 | xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN); |
1635 | hdr->nops++; | 1593 | hdr->nops++; |
1636 | hdr->replen += decode_destroy_session_maxsz; | 1594 | hdr->replen += decode_destroy_session_maxsz; |
1637 | } | 1595 | } |
@@ -1655,8 +1613,8 @@ static void encode_sequence(struct xdr_stream *xdr, | |||
1655 | WARN_ON(args->sa_slotid == NFS4_MAX_SLOT_TABLE); | 1613 | WARN_ON(args->sa_slotid == NFS4_MAX_SLOT_TABLE); |
1656 | slot = tp->slots + args->sa_slotid; | 1614 | slot = tp->slots + args->sa_slotid; |
1657 | 1615 | ||
1658 | RESERVE_SPACE(4); | 1616 | p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN + 16); |
1659 | WRITE32(OP_SEQUENCE); | 1617 | *p++ = cpu_to_be32(OP_SEQUENCE); |
1660 | 1618 | ||
1661 | /* | 1619 | /* |
1662 | * Sessionid + seqid + slotid + max slotid + cache_this | 1620 | * Sessionid + seqid + slotid + max slotid + cache_this |
@@ -1670,12 +1628,11 @@ static void encode_sequence(struct xdr_stream *xdr, | |||
1670 | ((u32 *)session->sess_id.data)[3], | 1628 | ((u32 *)session->sess_id.data)[3], |
1671 | slot->seq_nr, args->sa_slotid, | 1629 | slot->seq_nr, args->sa_slotid, |
1672 | tp->highest_used_slotid, args->sa_cache_this); | 1630 | tp->highest_used_slotid, args->sa_cache_this); |
1673 | RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 16); | 1631 | p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN); |
1674 | WRITEMEM(session->sess_id.data, NFS4_MAX_SESSIONID_LEN); | 1632 | *p++ = cpu_to_be32(slot->seq_nr); |
1675 | WRITE32(slot->seq_nr); | 1633 | *p++ = cpu_to_be32(args->sa_slotid); |
1676 | WRITE32(args->sa_slotid); | 1634 | *p++ = cpu_to_be32(tp->highest_used_slotid); |
1677 | WRITE32(tp->highest_used_slotid); | 1635 | *p = cpu_to_be32(args->sa_cache_this); |
1678 | WRITE32(args->sa_cache_this); | ||
1679 | hdr->nops++; | 1636 | hdr->nops++; |
1680 | hdr->replen += decode_sequence_maxsz; | 1637 | hdr->replen += decode_sequence_maxsz; |
1681 | #endif /* CONFIG_NFS_V4_1 */ | 1638 | #endif /* CONFIG_NFS_V4_1 */ |
@@ -2466,68 +2423,53 @@ static int nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req, uint32_t *p, | |||
2466 | } | 2423 | } |
2467 | #endif /* CONFIG_NFS_V4_1 */ | 2424 | #endif /* CONFIG_NFS_V4_1 */ |
2468 | 2425 | ||
2469 | /* | 2426 | static void print_overflow_msg(const char *func, const struct xdr_stream *xdr) |
2470 | * START OF "GENERIC" DECODE ROUTINES. | 2427 | { |
2471 | * These may look a little ugly since they are imported from a "generic" | 2428 | dprintk("nfs: %s: prematurely hit end of receive buffer. " |
2472 | * set of XDR encode/decode routines which are intended to be shared by | 2429 | "Remaining buffer length is %tu words.\n", |
2473 | * all of our NFSv4 implementations (OpenBSD, MacOS X...). | 2430 | func, xdr->end - xdr->p); |
2474 | * | 2431 | } |
2475 | * If the pain of reading these is too great, it should be a straightforward | ||
2476 | * task to translate them into Linux-specific versions which are more | ||
2477 | * consistent with the style used in NFSv2/v3... | ||
2478 | */ | ||
2479 | #define READ32(x) (x) = ntohl(*p++) | ||
2480 | #define READ64(x) do { \ | ||
2481 | (x) = (u64)ntohl(*p++) << 32; \ | ||
2482 | (x) |= ntohl(*p++); \ | ||
2483 | } while (0) | ||
2484 | #define READTIME(x) do { \ | ||
2485 | p++; \ | ||
2486 | (x.tv_sec) = ntohl(*p++); \ | ||
2487 | (x.tv_nsec) = ntohl(*p++); \ | ||
2488 | } while (0) | ||
2489 | #define COPYMEM(x,nbytes) do { \ | ||
2490 | memcpy((x), p, nbytes); \ | ||
2491 | p += XDR_QUADLEN(nbytes); \ | ||
2492 | } while (0) | ||
2493 | |||
2494 | #define READ_BUF(nbytes) do { \ | ||
2495 | p = xdr_inline_decode(xdr, nbytes); \ | ||
2496 | if (unlikely(!p)) { \ | ||
2497 | dprintk("nfs: %s: prematurely hit end of receive" \ | ||
2498 | " buffer\n", __func__); \ | ||
2499 | dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \ | ||
2500 | __func__, xdr->p, nbytes, xdr->end); \ | ||
2501 | return -EIO; \ | ||
2502 | } \ | ||
2503 | } while (0) | ||
2504 | 2432 | ||
2505 | static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string) | 2433 | static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string) |
2506 | { | 2434 | { |
2507 | __be32 *p; | 2435 | __be32 *p; |
2508 | 2436 | ||
2509 | READ_BUF(4); | 2437 | p = xdr_inline_decode(xdr, 4); |
2510 | READ32(*len); | 2438 | if (unlikely(!p)) |
2511 | READ_BUF(*len); | 2439 | goto out_overflow; |
2440 | *len = be32_to_cpup(p); | ||
2441 | p = xdr_inline_decode(xdr, *len); | ||
2442 | if (unlikely(!p)) | ||
2443 | goto out_overflow; | ||
2512 | *string = (char *)p; | 2444 | *string = (char *)p; |
2513 | return 0; | 2445 | return 0; |
2446 | out_overflow: | ||
2447 | print_overflow_msg(__func__, xdr); | ||
2448 | return -EIO; | ||
2514 | } | 2449 | } |
2515 | 2450 | ||
2516 | static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr) | 2451 | static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr) |
2517 | { | 2452 | { |
2518 | __be32 *p; | 2453 | __be32 *p; |
2519 | 2454 | ||
2520 | READ_BUF(8); | 2455 | p = xdr_inline_decode(xdr, 8); |
2521 | READ32(hdr->status); | 2456 | if (unlikely(!p)) |
2522 | READ32(hdr->taglen); | 2457 | goto out_overflow; |
2458 | hdr->status = be32_to_cpup(p++); | ||
2459 | hdr->taglen = be32_to_cpup(p); | ||
2523 | 2460 | ||
2524 | READ_BUF(hdr->taglen + 4); | 2461 | p = xdr_inline_decode(xdr, hdr->taglen + 4); |
2462 | if (unlikely(!p)) | ||
2463 | goto out_overflow; | ||
2525 | hdr->tag = (char *)p; | 2464 | hdr->tag = (char *)p; |
2526 | p += XDR_QUADLEN(hdr->taglen); | 2465 | p += XDR_QUADLEN(hdr->taglen); |
2527 | READ32(hdr->nops); | 2466 | hdr->nops = be32_to_cpup(p); |
2528 | if (unlikely(hdr->nops < 1)) | 2467 | if (unlikely(hdr->nops < 1)) |
2529 | return nfs4_stat_to_errno(hdr->status); | 2468 | return nfs4_stat_to_errno(hdr->status); |
2530 | return 0; | 2469 | return 0; |
2470 | out_overflow: | ||
2471 | print_overflow_msg(__func__, xdr); | ||
2472 | return -EIO; | ||
2531 | } | 2473 | } |
2532 | 2474 | ||
2533 | static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected) | 2475 | static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected) |
@@ -2536,18 +2478,23 @@ static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected) | |||
2536 | uint32_t opnum; | 2478 | uint32_t opnum; |
2537 | int32_t nfserr; | 2479 | int32_t nfserr; |
2538 | 2480 | ||
2539 | READ_BUF(8); | 2481 | p = xdr_inline_decode(xdr, 8); |
2540 | READ32(opnum); | 2482 | if (unlikely(!p)) |
2483 | goto out_overflow; | ||
2484 | opnum = be32_to_cpup(p++); | ||
2541 | if (opnum != expected) { | 2485 | if (opnum != expected) { |
2542 | dprintk("nfs: Server returned operation" | 2486 | dprintk("nfs: Server returned operation" |
2543 | " %d but we issued a request for %d\n", | 2487 | " %d but we issued a request for %d\n", |
2544 | opnum, expected); | 2488 | opnum, expected); |
2545 | return -EIO; | 2489 | return -EIO; |
2546 | } | 2490 | } |
2547 | READ32(nfserr); | 2491 | nfserr = be32_to_cpup(p); |
2548 | if (nfserr != NFS_OK) | 2492 | if (nfserr != NFS_OK) |
2549 | return nfs4_stat_to_errno(nfserr); | 2493 | return nfs4_stat_to_errno(nfserr); |
2550 | return 0; | 2494 | return 0; |
2495 | out_overflow: | ||
2496 | print_overflow_msg(__func__, xdr); | ||
2497 | return -EIO; | ||
2551 | } | 2498 | } |
2552 | 2499 | ||
2553 | /* Dummy routine */ | 2500 | /* Dummy routine */ |
@@ -2557,8 +2504,11 @@ static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp) | |||
2557 | unsigned int strlen; | 2504 | unsigned int strlen; |
2558 | char *str; | 2505 | char *str; |
2559 | 2506 | ||
2560 | READ_BUF(12); | 2507 | p = xdr_inline_decode(xdr, 12); |
2561 | return decode_opaque_inline(xdr, &strlen, &str); | 2508 | if (likely(p)) |
2509 | return decode_opaque_inline(xdr, &strlen, &str); | ||
2510 | print_overflow_msg(__func__, xdr); | ||
2511 | return -EIO; | ||
2562 | } | 2512 | } |
2563 | 2513 | ||
2564 | static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap) | 2514 | static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap) |
@@ -2566,27 +2516,39 @@ static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap) | |||
2566 | uint32_t bmlen; | 2516 | uint32_t bmlen; |
2567 | __be32 *p; | 2517 | __be32 *p; |
2568 | 2518 | ||
2569 | READ_BUF(4); | 2519 | p = xdr_inline_decode(xdr, 4); |
2570 | READ32(bmlen); | 2520 | if (unlikely(!p)) |
2521 | goto out_overflow; | ||
2522 | bmlen = be32_to_cpup(p); | ||
2571 | 2523 | ||
2572 | bitmap[0] = bitmap[1] = 0; | 2524 | bitmap[0] = bitmap[1] = 0; |
2573 | READ_BUF((bmlen << 2)); | 2525 | p = xdr_inline_decode(xdr, (bmlen << 2)); |
2526 | if (unlikely(!p)) | ||
2527 | goto out_overflow; | ||
2574 | if (bmlen > 0) { | 2528 | if (bmlen > 0) { |
2575 | READ32(bitmap[0]); | 2529 | bitmap[0] = be32_to_cpup(p++); |
2576 | if (bmlen > 1) | 2530 | if (bmlen > 1) |
2577 | READ32(bitmap[1]); | 2531 | bitmap[1] = be32_to_cpup(p); |
2578 | } | 2532 | } |
2579 | return 0; | 2533 | return 0; |
2534 | out_overflow: | ||
2535 | print_overflow_msg(__func__, xdr); | ||
2536 | return -EIO; | ||
2580 | } | 2537 | } |
2581 | 2538 | ||
2582 | static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep) | 2539 | static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep) |
2583 | { | 2540 | { |
2584 | __be32 *p; | 2541 | __be32 *p; |
2585 | 2542 | ||
2586 | READ_BUF(4); | 2543 | p = xdr_inline_decode(xdr, 4); |
2587 | READ32(*attrlen); | 2544 | if (unlikely(!p)) |
2545 | goto out_overflow; | ||
2546 | *attrlen = be32_to_cpup(p); | ||
2588 | *savep = xdr->p; | 2547 | *savep = xdr->p; |
2589 | return 0; | 2548 | return 0; |
2549 | out_overflow: | ||
2550 | print_overflow_msg(__func__, xdr); | ||
2551 | return -EIO; | ||
2590 | } | 2552 | } |
2591 | 2553 | ||
2592 | static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask) | 2554 | static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask) |
@@ -2609,8 +2571,10 @@ static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t * | |||
2609 | if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U))) | 2571 | if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U))) |
2610 | return -EIO; | 2572 | return -EIO; |
2611 | if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) { | 2573 | if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) { |
2612 | READ_BUF(4); | 2574 | p = xdr_inline_decode(xdr, 4); |
2613 | READ32(*type); | 2575 | if (unlikely(!p)) |
2576 | goto out_overflow; | ||
2577 | *type = be32_to_cpup(p); | ||
2614 | if (*type < NF4REG || *type > NF4NAMEDATTR) { | 2578 | if (*type < NF4REG || *type > NF4NAMEDATTR) { |
2615 | dprintk("%s: bad type %d\n", __func__, *type); | 2579 | dprintk("%s: bad type %d\n", __func__, *type); |
2616 | return -EIO; | 2580 | return -EIO; |
@@ -2620,6 +2584,9 @@ static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t * | |||
2620 | } | 2584 | } |
2621 | dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]); | 2585 | dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]); |
2622 | return ret; | 2586 | return ret; |
2587 | out_overflow: | ||
2588 | print_overflow_msg(__func__, xdr); | ||
2589 | return -EIO; | ||
2623 | } | 2590 | } |
2624 | 2591 | ||
2625 | static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change) | 2592 | static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change) |
@@ -2631,14 +2598,19 @@ static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t | |||
2631 | if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U))) | 2598 | if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U))) |
2632 | return -EIO; | 2599 | return -EIO; |
2633 | if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) { | 2600 | if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) { |
2634 | READ_BUF(8); | 2601 | p = xdr_inline_decode(xdr, 8); |
2635 | READ64(*change); | 2602 | if (unlikely(!p)) |
2603 | goto out_overflow; | ||
2604 | xdr_decode_hyper(p, change); | ||
2636 | bitmap[0] &= ~FATTR4_WORD0_CHANGE; | 2605 | bitmap[0] &= ~FATTR4_WORD0_CHANGE; |
2637 | ret = NFS_ATTR_FATTR_CHANGE; | 2606 | ret = NFS_ATTR_FATTR_CHANGE; |
2638 | } | 2607 | } |
2639 | dprintk("%s: change attribute=%Lu\n", __func__, | 2608 | dprintk("%s: change attribute=%Lu\n", __func__, |
2640 | (unsigned long long)*change); | 2609 | (unsigned long long)*change); |
2641 | return ret; | 2610 | return ret; |
2611 | out_overflow: | ||
2612 | print_overflow_msg(__func__, xdr); | ||
2613 | return -EIO; | ||
2642 | } | 2614 | } |
2643 | 2615 | ||
2644 | static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size) | 2616 | static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size) |
@@ -2650,13 +2622,18 @@ static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t * | |||
2650 | if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U))) | 2622 | if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U))) |
2651 | return -EIO; | 2623 | return -EIO; |
2652 | if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) { | 2624 | if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) { |
2653 | READ_BUF(8); | 2625 | p = xdr_inline_decode(xdr, 8); |
2654 | READ64(*size); | 2626 | if (unlikely(!p)) |
2627 | goto out_overflow; | ||
2628 | xdr_decode_hyper(p, size); | ||
2655 | bitmap[0] &= ~FATTR4_WORD0_SIZE; | 2629 | bitmap[0] &= ~FATTR4_WORD0_SIZE; |
2656 | ret = NFS_ATTR_FATTR_SIZE; | 2630 | ret = NFS_ATTR_FATTR_SIZE; |
2657 | } | 2631 | } |
2658 | dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size); | 2632 | dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size); |
2659 | return ret; | 2633 | return ret; |
2634 | out_overflow: | ||
2635 | print_overflow_msg(__func__, xdr); | ||
2636 | return -EIO; | ||
2660 | } | 2637 | } |
2661 | 2638 | ||
2662 | static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 2639 | static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -2667,12 +2644,17 @@ static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, ui | |||
2667 | if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U))) | 2644 | if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U))) |
2668 | return -EIO; | 2645 | return -EIO; |
2669 | if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) { | 2646 | if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) { |
2670 | READ_BUF(4); | 2647 | p = xdr_inline_decode(xdr, 4); |
2671 | READ32(*res); | 2648 | if (unlikely(!p)) |
2649 | goto out_overflow; | ||
2650 | *res = be32_to_cpup(p); | ||
2672 | bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; | 2651 | bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; |
2673 | } | 2652 | } |
2674 | dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true"); | 2653 | dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true"); |
2675 | return 0; | 2654 | return 0; |
2655 | out_overflow: | ||
2656 | print_overflow_msg(__func__, xdr); | ||
2657 | return -EIO; | ||
2676 | } | 2658 | } |
2677 | 2659 | ||
2678 | static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 2660 | static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -2683,12 +2665,17 @@ static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, | |||
2683 | if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U))) | 2665 | if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U))) |
2684 | return -EIO; | 2666 | return -EIO; |
2685 | if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) { | 2667 | if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) { |
2686 | READ_BUF(4); | 2668 | p = xdr_inline_decode(xdr, 4); |
2687 | READ32(*res); | 2669 | if (unlikely(!p)) |
2670 | goto out_overflow; | ||
2671 | *res = be32_to_cpup(p); | ||
2688 | bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; | 2672 | bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; |
2689 | } | 2673 | } |
2690 | dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true"); | 2674 | dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true"); |
2691 | return 0; | 2675 | return 0; |
2676 | out_overflow: | ||
2677 | print_overflow_msg(__func__, xdr); | ||
2678 | return -EIO; | ||
2692 | } | 2679 | } |
2693 | 2680 | ||
2694 | static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid) | 2681 | static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid) |
@@ -2701,9 +2688,11 @@ static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs | |||
2701 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U))) | 2688 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U))) |
2702 | return -EIO; | 2689 | return -EIO; |
2703 | if (likely(bitmap[0] & FATTR4_WORD0_FSID)) { | 2690 | if (likely(bitmap[0] & FATTR4_WORD0_FSID)) { |
2704 | READ_BUF(16); | 2691 | p = xdr_inline_decode(xdr, 16); |
2705 | READ64(fsid->major); | 2692 | if (unlikely(!p)) |
2706 | READ64(fsid->minor); | 2693 | goto out_overflow; |
2694 | p = xdr_decode_hyper(p, &fsid->major); | ||
2695 | xdr_decode_hyper(p, &fsid->minor); | ||
2707 | bitmap[0] &= ~FATTR4_WORD0_FSID; | 2696 | bitmap[0] &= ~FATTR4_WORD0_FSID; |
2708 | ret = NFS_ATTR_FATTR_FSID; | 2697 | ret = NFS_ATTR_FATTR_FSID; |
2709 | } | 2698 | } |
@@ -2711,6 +2700,9 @@ static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs | |||
2711 | (unsigned long long)fsid->major, | 2700 | (unsigned long long)fsid->major, |
2712 | (unsigned long long)fsid->minor); | 2701 | (unsigned long long)fsid->minor); |
2713 | return ret; | 2702 | return ret; |
2703 | out_overflow: | ||
2704 | print_overflow_msg(__func__, xdr); | ||
2705 | return -EIO; | ||
2714 | } | 2706 | } |
2715 | 2707 | ||
2716 | static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 2708 | static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -2721,12 +2713,17 @@ static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint | |||
2721 | if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U))) | 2713 | if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U))) |
2722 | return -EIO; | 2714 | return -EIO; |
2723 | if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) { | 2715 | if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) { |
2724 | READ_BUF(4); | 2716 | p = xdr_inline_decode(xdr, 4); |
2725 | READ32(*res); | 2717 | if (unlikely(!p)) |
2718 | goto out_overflow; | ||
2719 | *res = be32_to_cpup(p); | ||
2726 | bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; | 2720 | bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; |
2727 | } | 2721 | } |
2728 | dprintk("%s: file size=%u\n", __func__, (unsigned int)*res); | 2722 | dprintk("%s: file size=%u\n", __func__, (unsigned int)*res); |
2729 | return 0; | 2723 | return 0; |
2724 | out_overflow: | ||
2725 | print_overflow_msg(__func__, xdr); | ||
2726 | return -EIO; | ||
2730 | } | 2727 | } |
2731 | 2728 | ||
2732 | static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 2729 | static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -2737,12 +2734,17 @@ static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint | |||
2737 | if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U))) | 2734 | if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U))) |
2738 | return -EIO; | 2735 | return -EIO; |
2739 | if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) { | 2736 | if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) { |
2740 | READ_BUF(4); | 2737 | p = xdr_inline_decode(xdr, 4); |
2741 | READ32(*res); | 2738 | if (unlikely(!p)) |
2739 | goto out_overflow; | ||
2740 | *res = be32_to_cpup(p); | ||
2742 | bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; | 2741 | bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; |
2743 | } | 2742 | } |
2744 | dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res); | 2743 | dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res); |
2745 | return 0; | 2744 | return 0; |
2745 | out_overflow: | ||
2746 | print_overflow_msg(__func__, xdr); | ||
2747 | return -EIO; | ||
2746 | } | 2748 | } |
2747 | 2749 | ||
2748 | static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) | 2750 | static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) |
@@ -2754,13 +2756,18 @@ static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t | |||
2754 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U))) | 2756 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U))) |
2755 | return -EIO; | 2757 | return -EIO; |
2756 | if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) { | 2758 | if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) { |
2757 | READ_BUF(8); | 2759 | p = xdr_inline_decode(xdr, 8); |
2758 | READ64(*fileid); | 2760 | if (unlikely(!p)) |
2761 | goto out_overflow; | ||
2762 | xdr_decode_hyper(p, fileid); | ||
2759 | bitmap[0] &= ~FATTR4_WORD0_FILEID; | 2763 | bitmap[0] &= ~FATTR4_WORD0_FILEID; |
2760 | ret = NFS_ATTR_FATTR_FILEID; | 2764 | ret = NFS_ATTR_FATTR_FILEID; |
2761 | } | 2765 | } |
2762 | dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); | 2766 | dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); |
2763 | return ret; | 2767 | return ret; |
2768 | out_overflow: | ||
2769 | print_overflow_msg(__func__, xdr); | ||
2770 | return -EIO; | ||
2764 | } | 2771 | } |
2765 | 2772 | ||
2766 | static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) | 2773 | static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) |
@@ -2772,13 +2779,18 @@ static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitma | |||
2772 | if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U))) | 2779 | if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U))) |
2773 | return -EIO; | 2780 | return -EIO; |
2774 | if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) { | 2781 | if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) { |
2775 | READ_BUF(8); | 2782 | p = xdr_inline_decode(xdr, 8); |
2776 | READ64(*fileid); | 2783 | if (unlikely(!p)) |
2784 | goto out_overflow; | ||
2785 | xdr_decode_hyper(p, fileid); | ||
2777 | bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; | 2786 | bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; |
2778 | ret = NFS_ATTR_FATTR_FILEID; | 2787 | ret = NFS_ATTR_FATTR_FILEID; |
2779 | } | 2788 | } |
2780 | dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); | 2789 | dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid); |
2781 | return ret; | 2790 | return ret; |
2791 | out_overflow: | ||
2792 | print_overflow_msg(__func__, xdr); | ||
2793 | return -EIO; | ||
2782 | } | 2794 | } |
2783 | 2795 | ||
2784 | static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 2796 | static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -2790,12 +2802,17 @@ static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin | |||
2790 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U))) | 2802 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U))) |
2791 | return -EIO; | 2803 | return -EIO; |
2792 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) { | 2804 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) { |
2793 | READ_BUF(8); | 2805 | p = xdr_inline_decode(xdr, 8); |
2794 | READ64(*res); | 2806 | if (unlikely(!p)) |
2807 | goto out_overflow; | ||
2808 | xdr_decode_hyper(p, res); | ||
2795 | bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL; | 2809 | bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL; |
2796 | } | 2810 | } |
2797 | dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res); | 2811 | dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res); |
2798 | return status; | 2812 | return status; |
2813 | out_overflow: | ||
2814 | print_overflow_msg(__func__, xdr); | ||
2815 | return -EIO; | ||
2799 | } | 2816 | } |
2800 | 2817 | ||
2801 | static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 2818 | static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -2807,12 +2824,17 @@ static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint | |||
2807 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U))) | 2824 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U))) |
2808 | return -EIO; | 2825 | return -EIO; |
2809 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) { | 2826 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) { |
2810 | READ_BUF(8); | 2827 | p = xdr_inline_decode(xdr, 8); |
2811 | READ64(*res); | 2828 | if (unlikely(!p)) |
2829 | goto out_overflow; | ||
2830 | xdr_decode_hyper(p, res); | ||
2812 | bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; | 2831 | bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; |
2813 | } | 2832 | } |
2814 | dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res); | 2833 | dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res); |
2815 | return status; | 2834 | return status; |
2835 | out_overflow: | ||
2836 | print_overflow_msg(__func__, xdr); | ||
2837 | return -EIO; | ||
2816 | } | 2838 | } |
2817 | 2839 | ||
2818 | static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 2840 | static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -2824,12 +2846,17 @@ static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uin | |||
2824 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U))) | 2846 | if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U))) |
2825 | return -EIO; | 2847 | return -EIO; |
2826 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) { | 2848 | if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) { |
2827 | READ_BUF(8); | 2849 | p = xdr_inline_decode(xdr, 8); |
2828 | READ64(*res); | 2850 | if (unlikely(!p)) |
2851 | goto out_overflow; | ||
2852 | xdr_decode_hyper(p, res); | ||
2829 | bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; | 2853 | bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; |
2830 | } | 2854 | } |
2831 | dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res); | 2855 | dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res); |
2832 | return status; | 2856 | return status; |
2857 | out_overflow: | ||
2858 | print_overflow_msg(__func__, xdr); | ||
2859 | return -EIO; | ||
2833 | } | 2860 | } |
2834 | 2861 | ||
2835 | static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path) | 2862 | static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path) |
@@ -2838,8 +2865,10 @@ static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path) | |||
2838 | __be32 *p; | 2865 | __be32 *p; |
2839 | int status = 0; | 2866 | int status = 0; |
2840 | 2867 | ||
2841 | READ_BUF(4); | 2868 | p = xdr_inline_decode(xdr, 4); |
2842 | READ32(n); | 2869 | if (unlikely(!p)) |
2870 | goto out_overflow; | ||
2871 | n = be32_to_cpup(p); | ||
2843 | if (n == 0) | 2872 | if (n == 0) |
2844 | goto root_path; | 2873 | goto root_path; |
2845 | dprintk("path "); | 2874 | dprintk("path "); |
@@ -2873,6 +2902,9 @@ out_eio: | |||
2873 | dprintk(" status %d", status); | 2902 | dprintk(" status %d", status); |
2874 | status = -EIO; | 2903 | status = -EIO; |
2875 | goto out; | 2904 | goto out; |
2905 | out_overflow: | ||
2906 | print_overflow_msg(__func__, xdr); | ||
2907 | return -EIO; | ||
2876 | } | 2908 | } |
2877 | 2909 | ||
2878 | static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res) | 2910 | static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res) |
@@ -2890,8 +2922,10 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st | |||
2890 | status = decode_pathname(xdr, &res->fs_path); | 2922 | status = decode_pathname(xdr, &res->fs_path); |
2891 | if (unlikely(status != 0)) | 2923 | if (unlikely(status != 0)) |
2892 | goto out; | 2924 | goto out; |
2893 | READ_BUF(4); | 2925 | p = xdr_inline_decode(xdr, 4); |
2894 | READ32(n); | 2926 | if (unlikely(!p)) |
2927 | goto out_overflow; | ||
2928 | n = be32_to_cpup(p); | ||
2895 | if (n <= 0) | 2929 | if (n <= 0) |
2896 | goto out_eio; | 2930 | goto out_eio; |
2897 | res->nlocations = 0; | 2931 | res->nlocations = 0; |
@@ -2899,8 +2933,10 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st | |||
2899 | u32 m; | 2933 | u32 m; |
2900 | struct nfs4_fs_location *loc = &res->locations[res->nlocations]; | 2934 | struct nfs4_fs_location *loc = &res->locations[res->nlocations]; |
2901 | 2935 | ||
2902 | READ_BUF(4); | 2936 | p = xdr_inline_decode(xdr, 4); |
2903 | READ32(m); | 2937 | if (unlikely(!p)) |
2938 | goto out_overflow; | ||
2939 | m = be32_to_cpup(p); | ||
2904 | 2940 | ||
2905 | loc->nservers = 0; | 2941 | loc->nservers = 0; |
2906 | dprintk("%s: servers ", __func__); | 2942 | dprintk("%s: servers ", __func__); |
@@ -2939,6 +2975,8 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st | |||
2939 | out: | 2975 | out: |
2940 | dprintk("%s: fs_locations done, error = %d\n", __func__, status); | 2976 | dprintk("%s: fs_locations done, error = %d\n", __func__, status); |
2941 | return status; | 2977 | return status; |
2978 | out_overflow: | ||
2979 | print_overflow_msg(__func__, xdr); | ||
2942 | out_eio: | 2980 | out_eio: |
2943 | status = -EIO; | 2981 | status = -EIO; |
2944 | goto out; | 2982 | goto out; |
@@ -2953,12 +2991,17 @@ static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uin | |||
2953 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U))) | 2991 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U))) |
2954 | return -EIO; | 2992 | return -EIO; |
2955 | if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) { | 2993 | if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) { |
2956 | READ_BUF(8); | 2994 | p = xdr_inline_decode(xdr, 8); |
2957 | READ64(*res); | 2995 | if (unlikely(!p)) |
2996 | goto out_overflow; | ||
2997 | xdr_decode_hyper(p, res); | ||
2958 | bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; | 2998 | bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; |
2959 | } | 2999 | } |
2960 | dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res); | 3000 | dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res); |
2961 | return status; | 3001 | return status; |
3002 | out_overflow: | ||
3003 | print_overflow_msg(__func__, xdr); | ||
3004 | return -EIO; | ||
2962 | } | 3005 | } |
2963 | 3006 | ||
2964 | static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink) | 3007 | static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink) |
@@ -2970,12 +3013,17 @@ static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_ | |||
2970 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U))) | 3013 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U))) |
2971 | return -EIO; | 3014 | return -EIO; |
2972 | if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) { | 3015 | if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) { |
2973 | READ_BUF(4); | 3016 | p = xdr_inline_decode(xdr, 4); |
2974 | READ32(*maxlink); | 3017 | if (unlikely(!p)) |
3018 | goto out_overflow; | ||
3019 | *maxlink = be32_to_cpup(p); | ||
2975 | bitmap[0] &= ~FATTR4_WORD0_MAXLINK; | 3020 | bitmap[0] &= ~FATTR4_WORD0_MAXLINK; |
2976 | } | 3021 | } |
2977 | dprintk("%s: maxlink=%u\n", __func__, *maxlink); | 3022 | dprintk("%s: maxlink=%u\n", __func__, *maxlink); |
2978 | return status; | 3023 | return status; |
3024 | out_overflow: | ||
3025 | print_overflow_msg(__func__, xdr); | ||
3026 | return -EIO; | ||
2979 | } | 3027 | } |
2980 | 3028 | ||
2981 | static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname) | 3029 | static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname) |
@@ -2987,12 +3035,17 @@ static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_ | |||
2987 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U))) | 3035 | if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U))) |
2988 | return -EIO; | 3036 | return -EIO; |
2989 | if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) { | 3037 | if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) { |
2990 | READ_BUF(4); | 3038 | p = xdr_inline_decode(xdr, 4); |
2991 | READ32(*maxname); | 3039 | if (unlikely(!p)) |
3040 | goto out_overflow; | ||
3041 | *maxname = be32_to_cpup(p); | ||
2992 | bitmap[0] &= ~FATTR4_WORD0_MAXNAME; | 3042 | bitmap[0] &= ~FATTR4_WORD0_MAXNAME; |
2993 | } | 3043 | } |
2994 | dprintk("%s: maxname=%u\n", __func__, *maxname); | 3044 | dprintk("%s: maxname=%u\n", __func__, *maxname); |
2995 | return status; | 3045 | return status; |
3046 | out_overflow: | ||
3047 | print_overflow_msg(__func__, xdr); | ||
3048 | return -EIO; | ||
2996 | } | 3049 | } |
2997 | 3050 | ||
2998 | static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 3051 | static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -3005,8 +3058,10 @@ static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_ | |||
3005 | return -EIO; | 3058 | return -EIO; |
3006 | if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) { | 3059 | if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) { |
3007 | uint64_t maxread; | 3060 | uint64_t maxread; |
3008 | READ_BUF(8); | 3061 | p = xdr_inline_decode(xdr, 8); |
3009 | READ64(maxread); | 3062 | if (unlikely(!p)) |
3063 | goto out_overflow; | ||
3064 | xdr_decode_hyper(p, &maxread); | ||
3010 | if (maxread > 0x7FFFFFFF) | 3065 | if (maxread > 0x7FFFFFFF) |
3011 | maxread = 0x7FFFFFFF; | 3066 | maxread = 0x7FFFFFFF; |
3012 | *res = (uint32_t)maxread; | 3067 | *res = (uint32_t)maxread; |
@@ -3014,6 +3069,9 @@ static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_ | |||
3014 | } | 3069 | } |
3015 | dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res); | 3070 | dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res); |
3016 | return status; | 3071 | return status; |
3072 | out_overflow: | ||
3073 | print_overflow_msg(__func__, xdr); | ||
3074 | return -EIO; | ||
3017 | } | 3075 | } |
3018 | 3076 | ||
3019 | static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) | 3077 | static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) |
@@ -3026,8 +3084,10 @@ static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32 | |||
3026 | return -EIO; | 3084 | return -EIO; |
3027 | if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) { | 3085 | if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) { |
3028 | uint64_t maxwrite; | 3086 | uint64_t maxwrite; |
3029 | READ_BUF(8); | 3087 | p = xdr_inline_decode(xdr, 8); |
3030 | READ64(maxwrite); | 3088 | if (unlikely(!p)) |
3089 | goto out_overflow; | ||
3090 | xdr_decode_hyper(p, &maxwrite); | ||
3031 | if (maxwrite > 0x7FFFFFFF) | 3091 | if (maxwrite > 0x7FFFFFFF) |
3032 | maxwrite = 0x7FFFFFFF; | 3092 | maxwrite = 0x7FFFFFFF; |
3033 | *res = (uint32_t)maxwrite; | 3093 | *res = (uint32_t)maxwrite; |
@@ -3035,6 +3095,9 @@ static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32 | |||
3035 | } | 3095 | } |
3036 | dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res); | 3096 | dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res); |
3037 | return status; | 3097 | return status; |
3098 | out_overflow: | ||
3099 | print_overflow_msg(__func__, xdr); | ||
3100 | return -EIO; | ||
3038 | } | 3101 | } |
3039 | 3102 | ||
3040 | static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode) | 3103 | static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode) |
@@ -3047,14 +3110,19 @@ static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *m | |||
3047 | if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U))) | 3110 | if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U))) |
3048 | return -EIO; | 3111 | return -EIO; |
3049 | if (likely(bitmap[1] & FATTR4_WORD1_MODE)) { | 3112 | if (likely(bitmap[1] & FATTR4_WORD1_MODE)) { |
3050 | READ_BUF(4); | 3113 | p = xdr_inline_decode(xdr, 4); |
3051 | READ32(tmp); | 3114 | if (unlikely(!p)) |
3115 | goto out_overflow; | ||
3116 | tmp = be32_to_cpup(p); | ||
3052 | *mode = tmp & ~S_IFMT; | 3117 | *mode = tmp & ~S_IFMT; |
3053 | bitmap[1] &= ~FATTR4_WORD1_MODE; | 3118 | bitmap[1] &= ~FATTR4_WORD1_MODE; |
3054 | ret = NFS_ATTR_FATTR_MODE; | 3119 | ret = NFS_ATTR_FATTR_MODE; |
3055 | } | 3120 | } |
3056 | dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode); | 3121 | dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode); |
3057 | return ret; | 3122 | return ret; |
3123 | out_overflow: | ||
3124 | print_overflow_msg(__func__, xdr); | ||
3125 | return -EIO; | ||
3058 | } | 3126 | } |
3059 | 3127 | ||
3060 | static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink) | 3128 | static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink) |
@@ -3066,16 +3134,22 @@ static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t | |||
3066 | if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U))) | 3134 | if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U))) |
3067 | return -EIO; | 3135 | return -EIO; |
3068 | if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) { | 3136 | if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) { |
3069 | READ_BUF(4); | 3137 | p = xdr_inline_decode(xdr, 4); |
3070 | READ32(*nlink); | 3138 | if (unlikely(!p)) |
3139 | goto out_overflow; | ||
3140 | *nlink = be32_to_cpup(p); | ||
3071 | bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; | 3141 | bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; |
3072 | ret = NFS_ATTR_FATTR_NLINK; | 3142 | ret = NFS_ATTR_FATTR_NLINK; |
3073 | } | 3143 | } |
3074 | dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink); | 3144 | dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink); |
3075 | return ret; | 3145 | return ret; |
3146 | out_overflow: | ||
3147 | print_overflow_msg(__func__, xdr); | ||
3148 | return -EIO; | ||
3076 | } | 3149 | } |
3077 | 3150 | ||
3078 | static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid) | 3151 | static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, |
3152 | struct nfs_client *clp, uint32_t *uid, int may_sleep) | ||
3079 | { | 3153 | { |
3080 | uint32_t len; | 3154 | uint32_t len; |
3081 | __be32 *p; | 3155 | __be32 *p; |
@@ -3085,10 +3159,16 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf | |||
3085 | if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U))) | 3159 | if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U))) |
3086 | return -EIO; | 3160 | return -EIO; |
3087 | if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) { | 3161 | if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) { |
3088 | READ_BUF(4); | 3162 | p = xdr_inline_decode(xdr, 4); |
3089 | READ32(len); | 3163 | if (unlikely(!p)) |
3090 | READ_BUF(len); | 3164 | goto out_overflow; |
3091 | if (len < XDR_MAX_NETOBJ) { | 3165 | len = be32_to_cpup(p); |
3166 | p = xdr_inline_decode(xdr, len); | ||
3167 | if (unlikely(!p)) | ||
3168 | goto out_overflow; | ||
3169 | if (!may_sleep) { | ||
3170 | /* do nothing */ | ||
3171 | } else if (len < XDR_MAX_NETOBJ) { | ||
3092 | if (nfs_map_name_to_uid(clp, (char *)p, len, uid) == 0) | 3172 | if (nfs_map_name_to_uid(clp, (char *)p, len, uid) == 0) |
3093 | ret = NFS_ATTR_FATTR_OWNER; | 3173 | ret = NFS_ATTR_FATTR_OWNER; |
3094 | else | 3174 | else |
@@ -3101,9 +3181,13 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf | |||
3101 | } | 3181 | } |
3102 | dprintk("%s: uid=%d\n", __func__, (int)*uid); | 3182 | dprintk("%s: uid=%d\n", __func__, (int)*uid); |
3103 | return ret; | 3183 | return ret; |
3184 | out_overflow: | ||
3185 | print_overflow_msg(__func__, xdr); | ||
3186 | return -EIO; | ||
3104 | } | 3187 | } |
3105 | 3188 | ||
3106 | static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid) | 3189 | static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, |
3190 | struct nfs_client *clp, uint32_t *gid, int may_sleep) | ||
3107 | { | 3191 | { |
3108 | uint32_t len; | 3192 | uint32_t len; |
3109 | __be32 *p; | 3193 | __be32 *p; |
@@ -3113,10 +3197,16 @@ static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nf | |||
3113 | if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U))) | 3197 | if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U))) |
3114 | return -EIO; | 3198 | return -EIO; |
3115 | if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) { | 3199 | if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) { |
3116 | READ_BUF(4); | 3200 | p = xdr_inline_decode(xdr, 4); |
3117 | READ32(len); | 3201 | if (unlikely(!p)) |
3118 | READ_BUF(len); | 3202 | goto out_overflow; |
3119 | if (len < XDR_MAX_NETOBJ) { | 3203 | len = be32_to_cpup(p); |
3204 | p = xdr_inline_decode(xdr, len); | ||
3205 | if (unlikely(!p)) | ||
3206 | goto out_overflow; | ||
3207 | if (!may_sleep) { | ||
3208 | /* do nothing */ | ||
3209 | } else if (len < XDR_MAX_NETOBJ) { | ||
3120 | if (nfs_map_group_to_gid(clp, (char *)p, len, gid) == 0) | 3210 | if (nfs_map_group_to_gid(clp, (char *)p, len, gid) == 0) |
3121 | ret = NFS_ATTR_FATTR_GROUP; | 3211 | ret = NFS_ATTR_FATTR_GROUP; |
3122 | else | 3212 | else |
@@ -3129,6 +3219,9 @@ static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nf | |||
3129 | } | 3219 | } |
3130 | dprintk("%s: gid=%d\n", __func__, (int)*gid); | 3220 | dprintk("%s: gid=%d\n", __func__, (int)*gid); |
3131 | return ret; | 3221 | return ret; |
3222 | out_overflow: | ||
3223 | print_overflow_msg(__func__, xdr); | ||
3224 | return -EIO; | ||
3132 | } | 3225 | } |
3133 | 3226 | ||
3134 | static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev) | 3227 | static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev) |
@@ -3143,9 +3236,11 @@ static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rde | |||
3143 | if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) { | 3236 | if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) { |
3144 | dev_t tmp; | 3237 | dev_t tmp; |
3145 | 3238 | ||
3146 | READ_BUF(8); | 3239 | p = xdr_inline_decode(xdr, 8); |
3147 | READ32(major); | 3240 | if (unlikely(!p)) |
3148 | READ32(minor); | 3241 | goto out_overflow; |
3242 | major = be32_to_cpup(p++); | ||
3243 | minor = be32_to_cpup(p); | ||
3149 | tmp = MKDEV(major, minor); | 3244 | tmp = MKDEV(major, minor); |
3150 | if (MAJOR(tmp) == major && MINOR(tmp) == minor) | 3245 | if (MAJOR(tmp) == major && MINOR(tmp) == minor) |
3151 | *rdev = tmp; | 3246 | *rdev = tmp; |
@@ -3154,6 +3249,9 @@ static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rde | |||
3154 | } | 3249 | } |
3155 | dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor); | 3250 | dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor); |
3156 | return ret; | 3251 | return ret; |
3252 | out_overflow: | ||
3253 | print_overflow_msg(__func__, xdr); | ||
3254 | return -EIO; | ||
3157 | } | 3255 | } |
3158 | 3256 | ||
3159 | static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 3257 | static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -3165,12 +3263,17 @@ static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin | |||
3165 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U))) | 3263 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U))) |
3166 | return -EIO; | 3264 | return -EIO; |
3167 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) { | 3265 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) { |
3168 | READ_BUF(8); | 3266 | p = xdr_inline_decode(xdr, 8); |
3169 | READ64(*res); | 3267 | if (unlikely(!p)) |
3268 | goto out_overflow; | ||
3269 | xdr_decode_hyper(p, res); | ||
3170 | bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; | 3270 | bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; |
3171 | } | 3271 | } |
3172 | dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res); | 3272 | dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res); |
3173 | return status; | 3273 | return status; |
3274 | out_overflow: | ||
3275 | print_overflow_msg(__func__, xdr); | ||
3276 | return -EIO; | ||
3174 | } | 3277 | } |
3175 | 3278 | ||
3176 | static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 3279 | static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -3182,12 +3285,17 @@ static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint | |||
3182 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U))) | 3285 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U))) |
3183 | return -EIO; | 3286 | return -EIO; |
3184 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) { | 3287 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) { |
3185 | READ_BUF(8); | 3288 | p = xdr_inline_decode(xdr, 8); |
3186 | READ64(*res); | 3289 | if (unlikely(!p)) |
3290 | goto out_overflow; | ||
3291 | xdr_decode_hyper(p, res); | ||
3187 | bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; | 3292 | bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; |
3188 | } | 3293 | } |
3189 | dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res); | 3294 | dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res); |
3190 | return status; | 3295 | return status; |
3296 | out_overflow: | ||
3297 | print_overflow_msg(__func__, xdr); | ||
3298 | return -EIO; | ||
3191 | } | 3299 | } |
3192 | 3300 | ||
3193 | static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) | 3301 | static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) |
@@ -3199,12 +3307,17 @@ static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uin | |||
3199 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U))) | 3307 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U))) |
3200 | return -EIO; | 3308 | return -EIO; |
3201 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) { | 3309 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) { |
3202 | READ_BUF(8); | 3310 | p = xdr_inline_decode(xdr, 8); |
3203 | READ64(*res); | 3311 | if (unlikely(!p)) |
3312 | goto out_overflow; | ||
3313 | xdr_decode_hyper(p, res); | ||
3204 | bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; | 3314 | bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; |
3205 | } | 3315 | } |
3206 | dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res); | 3316 | dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res); |
3207 | return status; | 3317 | return status; |
3318 | out_overflow: | ||
3319 | print_overflow_msg(__func__, xdr); | ||
3320 | return -EIO; | ||
3208 | } | 3321 | } |
3209 | 3322 | ||
3210 | static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used) | 3323 | static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used) |
@@ -3216,14 +3329,19 @@ static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint | |||
3216 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U))) | 3329 | if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U))) |
3217 | return -EIO; | 3330 | return -EIO; |
3218 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) { | 3331 | if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) { |
3219 | READ_BUF(8); | 3332 | p = xdr_inline_decode(xdr, 8); |
3220 | READ64(*used); | 3333 | if (unlikely(!p)) |
3334 | goto out_overflow; | ||
3335 | xdr_decode_hyper(p, used); | ||
3221 | bitmap[1] &= ~FATTR4_WORD1_SPACE_USED; | 3336 | bitmap[1] &= ~FATTR4_WORD1_SPACE_USED; |
3222 | ret = NFS_ATTR_FATTR_SPACE_USED; | 3337 | ret = NFS_ATTR_FATTR_SPACE_USED; |
3223 | } | 3338 | } |
3224 | dprintk("%s: space used=%Lu\n", __func__, | 3339 | dprintk("%s: space used=%Lu\n", __func__, |
3225 | (unsigned long long)*used); | 3340 | (unsigned long long)*used); |
3226 | return ret; | 3341 | return ret; |
3342 | out_overflow: | ||
3343 | print_overflow_msg(__func__, xdr); | ||
3344 | return -EIO; | ||
3227 | } | 3345 | } |
3228 | 3346 | ||
3229 | static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time) | 3347 | static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time) |
@@ -3232,12 +3350,17 @@ static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time) | |||
3232 | uint64_t sec; | 3350 | uint64_t sec; |
3233 | uint32_t nsec; | 3351 | uint32_t nsec; |
3234 | 3352 | ||
3235 | READ_BUF(12); | 3353 | p = xdr_inline_decode(xdr, 12); |
3236 | READ64(sec); | 3354 | if (unlikely(!p)) |
3237 | READ32(nsec); | 3355 | goto out_overflow; |
3356 | p = xdr_decode_hyper(p, &sec); | ||
3357 | nsec = be32_to_cpup(p); | ||
3238 | time->tv_sec = (time_t)sec; | 3358 | time->tv_sec = (time_t)sec; |
3239 | time->tv_nsec = (long)nsec; | 3359 | time->tv_nsec = (long)nsec; |
3240 | return 0; | 3360 | return 0; |
3361 | out_overflow: | ||
3362 | print_overflow_msg(__func__, xdr); | ||
3363 | return -EIO; | ||
3241 | } | 3364 | } |
3242 | 3365 | ||
3243 | static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time) | 3366 | static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time) |
@@ -3315,11 +3438,16 @@ static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *c | |||
3315 | { | 3438 | { |
3316 | __be32 *p; | 3439 | __be32 *p; |
3317 | 3440 | ||
3318 | READ_BUF(20); | 3441 | p = xdr_inline_decode(xdr, 20); |
3319 | READ32(cinfo->atomic); | 3442 | if (unlikely(!p)) |
3320 | READ64(cinfo->before); | 3443 | goto out_overflow; |
3321 | READ64(cinfo->after); | 3444 | cinfo->atomic = be32_to_cpup(p++); |
3445 | p = xdr_decode_hyper(p, &cinfo->before); | ||
3446 | xdr_decode_hyper(p, &cinfo->after); | ||
3322 | return 0; | 3447 | return 0; |
3448 | out_overflow: | ||
3449 | print_overflow_msg(__func__, xdr); | ||
3450 | return -EIO; | ||
3323 | } | 3451 | } |
3324 | 3452 | ||
3325 | static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access) | 3453 | static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access) |
@@ -3331,40 +3459,62 @@ static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access) | |||
3331 | status = decode_op_hdr(xdr, OP_ACCESS); | 3459 | status = decode_op_hdr(xdr, OP_ACCESS); |
3332 | if (status) | 3460 | if (status) |
3333 | return status; | 3461 | return status; |
3334 | READ_BUF(8); | 3462 | p = xdr_inline_decode(xdr, 8); |
3335 | READ32(supp); | 3463 | if (unlikely(!p)) |
3336 | READ32(acc); | 3464 | goto out_overflow; |
3465 | supp = be32_to_cpup(p++); | ||
3466 | acc = be32_to_cpup(p); | ||
3337 | access->supported = supp; | 3467 | access->supported = supp; |
3338 | access->access = acc; | 3468 | access->access = acc; |
3339 | return 0; | 3469 | return 0; |
3470 | out_overflow: | ||
3471 | print_overflow_msg(__func__, xdr); | ||
3472 | return -EIO; | ||
3340 | } | 3473 | } |
3341 | 3474 | ||
3342 | static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res) | 3475 | static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len) |
3343 | { | 3476 | { |
3344 | __be32 *p; | 3477 | __be32 *p; |
3478 | |||
3479 | p = xdr_inline_decode(xdr, len); | ||
3480 | if (likely(p)) { | ||
3481 | memcpy(buf, p, len); | ||
3482 | return 0; | ||
3483 | } | ||
3484 | print_overflow_msg(__func__, xdr); | ||
3485 | return -EIO; | ||
3486 | } | ||
3487 | |||
3488 | static int decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid) | ||
3489 | { | ||
3490 | return decode_opaque_fixed(xdr, stateid->data, NFS4_STATEID_SIZE); | ||
3491 | } | ||
3492 | |||
3493 | static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res) | ||
3494 | { | ||
3345 | int status; | 3495 | int status; |
3346 | 3496 | ||
3347 | status = decode_op_hdr(xdr, OP_CLOSE); | 3497 | status = decode_op_hdr(xdr, OP_CLOSE); |
3348 | if (status != -EIO) | 3498 | if (status != -EIO) |
3349 | nfs_increment_open_seqid(status, res->seqid); | 3499 | nfs_increment_open_seqid(status, res->seqid); |
3350 | if (status) | 3500 | if (!status) |
3351 | return status; | 3501 | status = decode_stateid(xdr, &res->stateid); |
3352 | READ_BUF(NFS4_STATEID_SIZE); | 3502 | return status; |
3353 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | 3503 | } |
3354 | return 0; | 3504 | |
3505 | static int decode_verifier(struct xdr_stream *xdr, void *verifier) | ||
3506 | { | ||
3507 | return decode_opaque_fixed(xdr, verifier, 8); | ||
3355 | } | 3508 | } |
3356 | 3509 | ||
3357 | static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res) | 3510 | static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res) |
3358 | { | 3511 | { |
3359 | __be32 *p; | ||
3360 | int status; | 3512 | int status; |
3361 | 3513 | ||
3362 | status = decode_op_hdr(xdr, OP_COMMIT); | 3514 | status = decode_op_hdr(xdr, OP_COMMIT); |
3363 | if (status) | 3515 | if (!status) |
3364 | return status; | 3516 | status = decode_verifier(xdr, res->verf->verifier); |
3365 | READ_BUF(8); | 3517 | return status; |
3366 | COPYMEM(res->verf->verifier, 8); | ||
3367 | return 0; | ||
3368 | } | 3518 | } |
3369 | 3519 | ||
3370 | static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) | 3520 | static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) |
@@ -3378,10 +3528,16 @@ static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) | |||
3378 | return status; | 3528 | return status; |
3379 | if ((status = decode_change_info(xdr, cinfo))) | 3529 | if ((status = decode_change_info(xdr, cinfo))) |
3380 | return status; | 3530 | return status; |
3381 | READ_BUF(4); | 3531 | p = xdr_inline_decode(xdr, 4); |
3382 | READ32(bmlen); | 3532 | if (unlikely(!p)) |
3383 | READ_BUF(bmlen << 2); | 3533 | goto out_overflow; |
3384 | return 0; | 3534 | bmlen = be32_to_cpup(p); |
3535 | p = xdr_inline_decode(xdr, bmlen << 2); | ||
3536 | if (likely(p)) | ||
3537 | return 0; | ||
3538 | out_overflow: | ||
3539 | print_overflow_msg(__func__, xdr); | ||
3540 | return -EIO; | ||
3385 | } | 3541 | } |
3386 | 3542 | ||
3387 | static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res) | 3543 | static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res) |
@@ -3466,7 +3622,8 @@ xdr_error: | |||
3466 | return status; | 3622 | return status; |
3467 | } | 3623 | } |
3468 | 3624 | ||
3469 | static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server) | 3625 | static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, |
3626 | const struct nfs_server *server, int may_sleep) | ||
3470 | { | 3627 | { |
3471 | __be32 *savep; | 3628 | __be32 *savep; |
3472 | uint32_t attrlen, | 3629 | uint32_t attrlen, |
@@ -3538,12 +3695,14 @@ static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, cons | |||
3538 | goto xdr_error; | 3695 | goto xdr_error; |
3539 | fattr->valid |= status; | 3696 | fattr->valid |= status; |
3540 | 3697 | ||
3541 | status = decode_attr_owner(xdr, bitmap, server->nfs_client, &fattr->uid); | 3698 | status = decode_attr_owner(xdr, bitmap, server->nfs_client, |
3699 | &fattr->uid, may_sleep); | ||
3542 | if (status < 0) | 3700 | if (status < 0) |
3543 | goto xdr_error; | 3701 | goto xdr_error; |
3544 | fattr->valid |= status; | 3702 | fattr->valid |= status; |
3545 | 3703 | ||
3546 | status = decode_attr_group(xdr, bitmap, server->nfs_client, &fattr->gid); | 3704 | status = decode_attr_group(xdr, bitmap, server->nfs_client, |
3705 | &fattr->gid, may_sleep); | ||
3547 | if (status < 0) | 3706 | if (status < 0) |
3548 | goto xdr_error; | 3707 | goto xdr_error; |
3549 | fattr->valid |= status; | 3708 | fattr->valid |= status; |
@@ -3633,14 +3792,21 @@ static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh) | |||
3633 | if (status) | 3792 | if (status) |
3634 | return status; | 3793 | return status; |
3635 | 3794 | ||
3636 | READ_BUF(4); | 3795 | p = xdr_inline_decode(xdr, 4); |
3637 | READ32(len); | 3796 | if (unlikely(!p)) |
3797 | goto out_overflow; | ||
3798 | len = be32_to_cpup(p); | ||
3638 | if (len > NFS4_FHSIZE) | 3799 | if (len > NFS4_FHSIZE) |
3639 | return -EIO; | 3800 | return -EIO; |
3640 | fh->size = len; | 3801 | fh->size = len; |
3641 | READ_BUF(len); | 3802 | p = xdr_inline_decode(xdr, len); |
3642 | COPYMEM(fh->data, len); | 3803 | if (unlikely(!p)) |
3804 | goto out_overflow; | ||
3805 | memcpy(fh->data, p, len); | ||
3643 | return 0; | 3806 | return 0; |
3807 | out_overflow: | ||
3808 | print_overflow_msg(__func__, xdr); | ||
3809 | return -EIO; | ||
3644 | } | 3810 | } |
3645 | 3811 | ||
3646 | static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) | 3812 | static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) |
@@ -3662,10 +3828,12 @@ static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl) | |||
3662 | __be32 *p; | 3828 | __be32 *p; |
3663 | uint32_t namelen, type; | 3829 | uint32_t namelen, type; |
3664 | 3830 | ||
3665 | READ_BUF(32); | 3831 | p = xdr_inline_decode(xdr, 32); |
3666 | READ64(offset); | 3832 | if (unlikely(!p)) |
3667 | READ64(length); | 3833 | goto out_overflow; |
3668 | READ32(type); | 3834 | p = xdr_decode_hyper(p, &offset); |
3835 | p = xdr_decode_hyper(p, &length); | ||
3836 | type = be32_to_cpup(p++); | ||
3669 | if (fl != NULL) { | 3837 | if (fl != NULL) { |
3670 | fl->fl_start = (loff_t)offset; | 3838 | fl->fl_start = (loff_t)offset; |
3671 | fl->fl_end = fl->fl_start + (loff_t)length - 1; | 3839 | fl->fl_end = fl->fl_start + (loff_t)length - 1; |
@@ -3676,23 +3844,27 @@ static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl) | |||
3676 | fl->fl_type = F_RDLCK; | 3844 | fl->fl_type = F_RDLCK; |
3677 | fl->fl_pid = 0; | 3845 | fl->fl_pid = 0; |
3678 | } | 3846 | } |
3679 | READ64(clientid); | 3847 | p = xdr_decode_hyper(p, &clientid); |
3680 | READ32(namelen); | 3848 | namelen = be32_to_cpup(p); |
3681 | READ_BUF(namelen); | 3849 | p = xdr_inline_decode(xdr, namelen); |
3682 | return -NFS4ERR_DENIED; | 3850 | if (likely(p)) |
3851 | return -NFS4ERR_DENIED; | ||
3852 | out_overflow: | ||
3853 | print_overflow_msg(__func__, xdr); | ||
3854 | return -EIO; | ||
3683 | } | 3855 | } |
3684 | 3856 | ||
3685 | static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res) | 3857 | static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res) |
3686 | { | 3858 | { |
3687 | __be32 *p; | ||
3688 | int status; | 3859 | int status; |
3689 | 3860 | ||
3690 | status = decode_op_hdr(xdr, OP_LOCK); | 3861 | status = decode_op_hdr(xdr, OP_LOCK); |
3691 | if (status == -EIO) | 3862 | if (status == -EIO) |
3692 | goto out; | 3863 | goto out; |
3693 | if (status == 0) { | 3864 | if (status == 0) { |
3694 | READ_BUF(NFS4_STATEID_SIZE); | 3865 | status = decode_stateid(xdr, &res->stateid); |
3695 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | 3866 | if (unlikely(status)) |
3867 | goto out; | ||
3696 | } else if (status == -NFS4ERR_DENIED) | 3868 | } else if (status == -NFS4ERR_DENIED) |
3697 | status = decode_lock_denied(xdr, NULL); | 3869 | status = decode_lock_denied(xdr, NULL); |
3698 | if (res->open_seqid != NULL) | 3870 | if (res->open_seqid != NULL) |
@@ -3713,16 +3885,13 @@ static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res) | |||
3713 | 3885 | ||
3714 | static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res) | 3886 | static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res) |
3715 | { | 3887 | { |
3716 | __be32 *p; | ||
3717 | int status; | 3888 | int status; |
3718 | 3889 | ||
3719 | status = decode_op_hdr(xdr, OP_LOCKU); | 3890 | status = decode_op_hdr(xdr, OP_LOCKU); |
3720 | if (status != -EIO) | 3891 | if (status != -EIO) |
3721 | nfs_increment_lock_seqid(status, res->seqid); | 3892 | nfs_increment_lock_seqid(status, res->seqid); |
3722 | if (status == 0) { | 3893 | if (status == 0) |
3723 | READ_BUF(NFS4_STATEID_SIZE); | 3894 | status = decode_stateid(xdr, &res->stateid); |
3724 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | ||
3725 | } | ||
3726 | return status; | 3895 | return status; |
3727 | } | 3896 | } |
3728 | 3897 | ||
@@ -3737,34 +3906,46 @@ static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize) | |||
3737 | __be32 *p; | 3906 | __be32 *p; |
3738 | uint32_t limit_type, nblocks, blocksize; | 3907 | uint32_t limit_type, nblocks, blocksize; |
3739 | 3908 | ||
3740 | READ_BUF(12); | 3909 | p = xdr_inline_decode(xdr, 12); |
3741 | READ32(limit_type); | 3910 | if (unlikely(!p)) |
3911 | goto out_overflow; | ||
3912 | limit_type = be32_to_cpup(p++); | ||
3742 | switch (limit_type) { | 3913 | switch (limit_type) { |
3743 | case 1: | 3914 | case 1: |
3744 | READ64(*maxsize); | 3915 | xdr_decode_hyper(p, maxsize); |
3745 | break; | 3916 | break; |
3746 | case 2: | 3917 | case 2: |
3747 | READ32(nblocks); | 3918 | nblocks = be32_to_cpup(p++); |
3748 | READ32(blocksize); | 3919 | blocksize = be32_to_cpup(p); |
3749 | *maxsize = (uint64_t)nblocks * (uint64_t)blocksize; | 3920 | *maxsize = (uint64_t)nblocks * (uint64_t)blocksize; |
3750 | } | 3921 | } |
3751 | return 0; | 3922 | return 0; |
3923 | out_overflow: | ||
3924 | print_overflow_msg(__func__, xdr); | ||
3925 | return -EIO; | ||
3752 | } | 3926 | } |
3753 | 3927 | ||
3754 | static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res) | 3928 | static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res) |
3755 | { | 3929 | { |
3756 | __be32 *p; | 3930 | __be32 *p; |
3757 | uint32_t delegation_type; | 3931 | uint32_t delegation_type; |
3932 | int status; | ||
3758 | 3933 | ||
3759 | READ_BUF(4); | 3934 | p = xdr_inline_decode(xdr, 4); |
3760 | READ32(delegation_type); | 3935 | if (unlikely(!p)) |
3936 | goto out_overflow; | ||
3937 | delegation_type = be32_to_cpup(p); | ||
3761 | if (delegation_type == NFS4_OPEN_DELEGATE_NONE) { | 3938 | if (delegation_type == NFS4_OPEN_DELEGATE_NONE) { |
3762 | res->delegation_type = 0; | 3939 | res->delegation_type = 0; |
3763 | return 0; | 3940 | return 0; |
3764 | } | 3941 | } |
3765 | READ_BUF(NFS4_STATEID_SIZE+4); | 3942 | status = decode_stateid(xdr, &res->delegation); |
3766 | COPYMEM(res->delegation.data, NFS4_STATEID_SIZE); | 3943 | if (unlikely(status)) |
3767 | READ32(res->do_recall); | 3944 | return status; |
3945 | p = xdr_inline_decode(xdr, 4); | ||
3946 | if (unlikely(!p)) | ||
3947 | goto out_overflow; | ||
3948 | res->do_recall = be32_to_cpup(p); | ||
3768 | 3949 | ||
3769 | switch (delegation_type) { | 3950 | switch (delegation_type) { |
3770 | case NFS4_OPEN_DELEGATE_READ: | 3951 | case NFS4_OPEN_DELEGATE_READ: |
@@ -3776,6 +3957,9 @@ static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res) | |||
3776 | return -EIO; | 3957 | return -EIO; |
3777 | } | 3958 | } |
3778 | return decode_ace(xdr, NULL, res->server->nfs_client); | 3959 | return decode_ace(xdr, NULL, res->server->nfs_client); |
3960 | out_overflow: | ||
3961 | print_overflow_msg(__func__, xdr); | ||
3962 | return -EIO; | ||
3779 | } | 3963 | } |
3780 | 3964 | ||
3781 | static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res) | 3965 | static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res) |
@@ -3787,23 +3971,27 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res) | |||
3787 | status = decode_op_hdr(xdr, OP_OPEN); | 3971 | status = decode_op_hdr(xdr, OP_OPEN); |
3788 | if (status != -EIO) | 3972 | if (status != -EIO) |
3789 | nfs_increment_open_seqid(status, res->seqid); | 3973 | nfs_increment_open_seqid(status, res->seqid); |
3790 | if (status) | 3974 | if (!status) |
3975 | status = decode_stateid(xdr, &res->stateid); | ||
3976 | if (unlikely(status)) | ||
3791 | return status; | 3977 | return status; |
3792 | READ_BUF(NFS4_STATEID_SIZE); | ||
3793 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | ||
3794 | 3978 | ||
3795 | decode_change_info(xdr, &res->cinfo); | 3979 | decode_change_info(xdr, &res->cinfo); |
3796 | 3980 | ||
3797 | READ_BUF(8); | 3981 | p = xdr_inline_decode(xdr, 8); |
3798 | READ32(res->rflags); | 3982 | if (unlikely(!p)) |
3799 | READ32(bmlen); | 3983 | goto out_overflow; |
3984 | res->rflags = be32_to_cpup(p++); | ||
3985 | bmlen = be32_to_cpup(p); | ||
3800 | if (bmlen > 10) | 3986 | if (bmlen > 10) |
3801 | goto xdr_error; | 3987 | goto xdr_error; |
3802 | 3988 | ||
3803 | READ_BUF(bmlen << 2); | 3989 | p = xdr_inline_decode(xdr, bmlen << 2); |
3990 | if (unlikely(!p)) | ||
3991 | goto out_overflow; | ||
3804 | savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE); | 3992 | savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE); |
3805 | for (i = 0; i < savewords; ++i) | 3993 | for (i = 0; i < savewords; ++i) |
3806 | READ32(res->attrset[i]); | 3994 | res->attrset[i] = be32_to_cpup(p++); |
3807 | for (; i < NFS4_BITMAP_SIZE; i++) | 3995 | for (; i < NFS4_BITMAP_SIZE; i++) |
3808 | res->attrset[i] = 0; | 3996 | res->attrset[i] = 0; |
3809 | 3997 | ||
@@ -3811,36 +3999,33 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res) | |||
3811 | xdr_error: | 3999 | xdr_error: |
3812 | dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen); | 4000 | dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen); |
3813 | return -EIO; | 4001 | return -EIO; |
4002 | out_overflow: | ||
4003 | print_overflow_msg(__func__, xdr); | ||
4004 | return -EIO; | ||
3814 | } | 4005 | } |
3815 | 4006 | ||
3816 | static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res) | 4007 | static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res) |
3817 | { | 4008 | { |
3818 | __be32 *p; | ||
3819 | int status; | 4009 | int status; |
3820 | 4010 | ||
3821 | status = decode_op_hdr(xdr, OP_OPEN_CONFIRM); | 4011 | status = decode_op_hdr(xdr, OP_OPEN_CONFIRM); |
3822 | if (status != -EIO) | 4012 | if (status != -EIO) |
3823 | nfs_increment_open_seqid(status, res->seqid); | 4013 | nfs_increment_open_seqid(status, res->seqid); |
3824 | if (status) | 4014 | if (!status) |
3825 | return status; | 4015 | status = decode_stateid(xdr, &res->stateid); |
3826 | READ_BUF(NFS4_STATEID_SIZE); | 4016 | return status; |
3827 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | ||
3828 | return 0; | ||
3829 | } | 4017 | } |
3830 | 4018 | ||
3831 | static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res) | 4019 | static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res) |
3832 | { | 4020 | { |
3833 | __be32 *p; | ||
3834 | int status; | 4021 | int status; |
3835 | 4022 | ||
3836 | status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE); | 4023 | status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE); |
3837 | if (status != -EIO) | 4024 | if (status != -EIO) |
3838 | nfs_increment_open_seqid(status, res->seqid); | 4025 | nfs_increment_open_seqid(status, res->seqid); |
3839 | if (status) | 4026 | if (!status) |
3840 | return status; | 4027 | status = decode_stateid(xdr, &res->stateid); |
3841 | READ_BUF(NFS4_STATEID_SIZE); | 4028 | return status; |
3842 | COPYMEM(res->stateid.data, NFS4_STATEID_SIZE); | ||
3843 | return 0; | ||
3844 | } | 4029 | } |
3845 | 4030 | ||
3846 | static int decode_putfh(struct xdr_stream *xdr) | 4031 | static int decode_putfh(struct xdr_stream *xdr) |
@@ -3863,9 +4048,11 @@ static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_ | |||
3863 | status = decode_op_hdr(xdr, OP_READ); | 4048 | status = decode_op_hdr(xdr, OP_READ); |
3864 | if (status) | 4049 | if (status) |
3865 | return status; | 4050 | return status; |
3866 | READ_BUF(8); | 4051 | p = xdr_inline_decode(xdr, 8); |
3867 | READ32(eof); | 4052 | if (unlikely(!p)) |
3868 | READ32(count); | 4053 | goto out_overflow; |
4054 | eof = be32_to_cpup(p++); | ||
4055 | count = be32_to_cpup(p); | ||
3869 | hdrlen = (u8 *) p - (u8 *) iov->iov_base; | 4056 | hdrlen = (u8 *) p - (u8 *) iov->iov_base; |
3870 | recvd = req->rq_rcv_buf.len - hdrlen; | 4057 | recvd = req->rq_rcv_buf.len - hdrlen; |
3871 | if (count > recvd) { | 4058 | if (count > recvd) { |
@@ -3878,6 +4065,9 @@ static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_ | |||
3878 | res->eof = eof; | 4065 | res->eof = eof; |
3879 | res->count = count; | 4066 | res->count = count; |
3880 | return 0; | 4067 | return 0; |
4068 | out_overflow: | ||
4069 | print_overflow_msg(__func__, xdr); | ||
4070 | return -EIO; | ||
3881 | } | 4071 | } |
3882 | 4072 | ||
3883 | static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir) | 4073 | static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir) |
@@ -3892,17 +4082,17 @@ static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct n | |||
3892 | int status; | 4082 | int status; |
3893 | 4083 | ||
3894 | status = decode_op_hdr(xdr, OP_READDIR); | 4084 | status = decode_op_hdr(xdr, OP_READDIR); |
3895 | if (status) | 4085 | if (!status) |
4086 | status = decode_verifier(xdr, readdir->verifier.data); | ||
4087 | if (unlikely(status)) | ||
3896 | return status; | 4088 | return status; |
3897 | READ_BUF(8); | ||
3898 | COPYMEM(readdir->verifier.data, 8); | ||
3899 | dprintk("%s: verifier = %08x:%08x\n", | 4089 | dprintk("%s: verifier = %08x:%08x\n", |
3900 | __func__, | 4090 | __func__, |
3901 | ((u32 *)readdir->verifier.data)[0], | 4091 | ((u32 *)readdir->verifier.data)[0], |
3902 | ((u32 *)readdir->verifier.data)[1]); | 4092 | ((u32 *)readdir->verifier.data)[1]); |
3903 | 4093 | ||
3904 | 4094 | ||
3905 | hdrlen = (char *) p - (char *) iov->iov_base; | 4095 | hdrlen = (char *) xdr->p - (char *) iov->iov_base; |
3906 | recvd = rcvbuf->len - hdrlen; | 4096 | recvd = rcvbuf->len - hdrlen; |
3907 | if (pglen > recvd) | 4097 | if (pglen > recvd) |
3908 | pglen = recvd; | 4098 | pglen = recvd; |
@@ -3990,8 +4180,10 @@ static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req) | |||
3990 | return status; | 4180 | return status; |
3991 | 4181 | ||
3992 | /* Convert length of symlink */ | 4182 | /* Convert length of symlink */ |
3993 | READ_BUF(4); | 4183 | p = xdr_inline_decode(xdr, 4); |
3994 | READ32(len); | 4184 | if (unlikely(!p)) |
4185 | goto out_overflow; | ||
4186 | len = be32_to_cpup(p); | ||
3995 | if (len >= rcvbuf->page_len || len <= 0) { | 4187 | if (len >= rcvbuf->page_len || len <= 0) { |
3996 | dprintk("nfs: server returned giant symlink!\n"); | 4188 | dprintk("nfs: server returned giant symlink!\n"); |
3997 | return -ENAMETOOLONG; | 4189 | return -ENAMETOOLONG; |
@@ -4015,6 +4207,9 @@ static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req) | |||
4015 | kaddr[len+rcvbuf->page_base] = '\0'; | 4207 | kaddr[len+rcvbuf->page_base] = '\0'; |
4016 | kunmap_atomic(kaddr, KM_USER0); | 4208 | kunmap_atomic(kaddr, KM_USER0); |
4017 | return 0; | 4209 | return 0; |
4210 | out_overflow: | ||
4211 | print_overflow_msg(__func__, xdr); | ||
4212 | return -EIO; | ||
4018 | } | 4213 | } |
4019 | 4214 | ||
4020 | static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) | 4215 | static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) |
@@ -4112,10 +4307,16 @@ static int decode_setattr(struct xdr_stream *xdr) | |||
4112 | status = decode_op_hdr(xdr, OP_SETATTR); | 4307 | status = decode_op_hdr(xdr, OP_SETATTR); |
4113 | if (status) | 4308 | if (status) |
4114 | return status; | 4309 | return status; |
4115 | READ_BUF(4); | 4310 | p = xdr_inline_decode(xdr, 4); |
4116 | READ32(bmlen); | 4311 | if (unlikely(!p)) |
4117 | READ_BUF(bmlen << 2); | 4312 | goto out_overflow; |
4118 | return 0; | 4313 | bmlen = be32_to_cpup(p); |
4314 | p = xdr_inline_decode(xdr, bmlen << 2); | ||
4315 | if (likely(p)) | ||
4316 | return 0; | ||
4317 | out_overflow: | ||
4318 | print_overflow_msg(__func__, xdr); | ||
4319 | return -EIO; | ||
4119 | } | 4320 | } |
4120 | 4321 | ||
4121 | static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp) | 4322 | static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp) |
@@ -4124,35 +4325,50 @@ static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp) | |||
4124 | uint32_t opnum; | 4325 | uint32_t opnum; |
4125 | int32_t nfserr; | 4326 | int32_t nfserr; |
4126 | 4327 | ||
4127 | READ_BUF(8); | 4328 | p = xdr_inline_decode(xdr, 8); |
4128 | READ32(opnum); | 4329 | if (unlikely(!p)) |
4330 | goto out_overflow; | ||
4331 | opnum = be32_to_cpup(p++); | ||
4129 | if (opnum != OP_SETCLIENTID) { | 4332 | if (opnum != OP_SETCLIENTID) { |
4130 | dprintk("nfs: decode_setclientid: Server returned operation" | 4333 | dprintk("nfs: decode_setclientid: Server returned operation" |
4131 | " %d\n", opnum); | 4334 | " %d\n", opnum); |
4132 | return -EIO; | 4335 | return -EIO; |
4133 | } | 4336 | } |
4134 | READ32(nfserr); | 4337 | nfserr = be32_to_cpup(p); |
4135 | if (nfserr == NFS_OK) { | 4338 | if (nfserr == NFS_OK) { |
4136 | READ_BUF(8 + NFS4_VERIFIER_SIZE); | 4339 | p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE); |
4137 | READ64(clp->cl_clientid); | 4340 | if (unlikely(!p)) |
4138 | COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE); | 4341 | goto out_overflow; |
4342 | p = xdr_decode_hyper(p, &clp->cl_clientid); | ||
4343 | memcpy(clp->cl_confirm.data, p, NFS4_VERIFIER_SIZE); | ||
4139 | } else if (nfserr == NFSERR_CLID_INUSE) { | 4344 | } else if (nfserr == NFSERR_CLID_INUSE) { |
4140 | uint32_t len; | 4345 | uint32_t len; |
4141 | 4346 | ||
4142 | /* skip netid string */ | 4347 | /* skip netid string */ |
4143 | READ_BUF(4); | 4348 | p = xdr_inline_decode(xdr, 4); |
4144 | READ32(len); | 4349 | if (unlikely(!p)) |
4145 | READ_BUF(len); | 4350 | goto out_overflow; |
4351 | len = be32_to_cpup(p); | ||
4352 | p = xdr_inline_decode(xdr, len); | ||
4353 | if (unlikely(!p)) | ||
4354 | goto out_overflow; | ||
4146 | 4355 | ||
4147 | /* skip uaddr string */ | 4356 | /* skip uaddr string */ |
4148 | READ_BUF(4); | 4357 | p = xdr_inline_decode(xdr, 4); |
4149 | READ32(len); | 4358 | if (unlikely(!p)) |
4150 | READ_BUF(len); | 4359 | goto out_overflow; |
4360 | len = be32_to_cpup(p); | ||
4361 | p = xdr_inline_decode(xdr, len); | ||
4362 | if (unlikely(!p)) | ||
4363 | goto out_overflow; | ||
4151 | return -NFSERR_CLID_INUSE; | 4364 | return -NFSERR_CLID_INUSE; |
4152 | } else | 4365 | } else |
4153 | return nfs4_stat_to_errno(nfserr); | 4366 | return nfs4_stat_to_errno(nfserr); |
4154 | 4367 | ||
4155 | return 0; | 4368 | return 0; |
4369 | out_overflow: | ||
4370 | print_overflow_msg(__func__, xdr); | ||
4371 | return -EIO; | ||
4156 | } | 4372 | } |
4157 | 4373 | ||
4158 | static int decode_setclientid_confirm(struct xdr_stream *xdr) | 4374 | static int decode_setclientid_confirm(struct xdr_stream *xdr) |
@@ -4169,11 +4385,16 @@ static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res) | |||
4169 | if (status) | 4385 | if (status) |
4170 | return status; | 4386 | return status; |
4171 | 4387 | ||
4172 | READ_BUF(16); | 4388 | p = xdr_inline_decode(xdr, 16); |
4173 | READ32(res->count); | 4389 | if (unlikely(!p)) |
4174 | READ32(res->verf->committed); | 4390 | goto out_overflow; |
4175 | COPYMEM(res->verf->verifier, 8); | 4391 | res->count = be32_to_cpup(p++); |
4392 | res->verf->committed = be32_to_cpup(p++); | ||
4393 | memcpy(res->verf->verifier, p, 8); | ||
4176 | return 0; | 4394 | return 0; |
4395 | out_overflow: | ||
4396 | print_overflow_msg(__func__, xdr); | ||
4397 | return -EIO; | ||
4177 | } | 4398 | } |
4178 | 4399 | ||
4179 | static int decode_delegreturn(struct xdr_stream *xdr) | 4400 | static int decode_delegreturn(struct xdr_stream *xdr) |
@@ -4187,6 +4408,7 @@ static int decode_exchange_id(struct xdr_stream *xdr, | |||
4187 | { | 4408 | { |
4188 | __be32 *p; | 4409 | __be32 *p; |
4189 | uint32_t dummy; | 4410 | uint32_t dummy; |
4411 | char *dummy_str; | ||
4190 | int status; | 4412 | int status; |
4191 | struct nfs_client *clp = res->client; | 4413 | struct nfs_client *clp = res->client; |
4192 | 4414 | ||
@@ -4194,36 +4416,45 @@ static int decode_exchange_id(struct xdr_stream *xdr, | |||
4194 | if (status) | 4416 | if (status) |
4195 | return status; | 4417 | return status; |
4196 | 4418 | ||
4197 | READ_BUF(8); | 4419 | p = xdr_inline_decode(xdr, 8); |
4198 | READ64(clp->cl_ex_clid); | 4420 | if (unlikely(!p)) |
4199 | READ_BUF(12); | 4421 | goto out_overflow; |
4200 | READ32(clp->cl_seqid); | 4422 | xdr_decode_hyper(p, &clp->cl_ex_clid); |
4201 | READ32(clp->cl_exchange_flags); | 4423 | p = xdr_inline_decode(xdr, 12); |
4424 | if (unlikely(!p)) | ||
4425 | goto out_overflow; | ||
4426 | clp->cl_seqid = be32_to_cpup(p++); | ||
4427 | clp->cl_exchange_flags = be32_to_cpup(p++); | ||
4202 | 4428 | ||
4203 | /* We ask for SP4_NONE */ | 4429 | /* We ask for SP4_NONE */ |
4204 | READ32(dummy); | 4430 | dummy = be32_to_cpup(p); |
4205 | if (dummy != SP4_NONE) | 4431 | if (dummy != SP4_NONE) |
4206 | return -EIO; | 4432 | return -EIO; |
4207 | 4433 | ||
4208 | /* Throw away minor_id */ | 4434 | /* Throw away minor_id */ |
4209 | READ_BUF(8); | 4435 | p = xdr_inline_decode(xdr, 8); |
4436 | if (unlikely(!p)) | ||
4437 | goto out_overflow; | ||
4210 | 4438 | ||
4211 | /* Throw away Major id */ | 4439 | /* Throw away Major id */ |
4212 | READ_BUF(4); | 4440 | status = decode_opaque_inline(xdr, &dummy, &dummy_str); |
4213 | READ32(dummy); | 4441 | if (unlikely(status)) |
4214 | READ_BUF(dummy); | 4442 | return status; |
4215 | 4443 | ||
4216 | /* Throw away server_scope */ | 4444 | /* Throw away server_scope */ |
4217 | READ_BUF(4); | 4445 | status = decode_opaque_inline(xdr, &dummy, &dummy_str); |
4218 | READ32(dummy); | 4446 | if (unlikely(status)) |
4219 | READ_BUF(dummy); | 4447 | return status; |
4220 | 4448 | ||
4221 | /* Throw away Implementation id array */ | 4449 | /* Throw away Implementation id array */ |
4222 | READ_BUF(4); | 4450 | status = decode_opaque_inline(xdr, &dummy, &dummy_str); |
4223 | READ32(dummy); | 4451 | if (unlikely(status)) |
4224 | READ_BUF(dummy); | 4452 | return status; |
4225 | 4453 | ||
4226 | return 0; | 4454 | return 0; |
4455 | out_overflow: | ||
4456 | print_overflow_msg(__func__, xdr); | ||
4457 | return -EIO; | ||
4227 | } | 4458 | } |
4228 | 4459 | ||
4229 | static int decode_chan_attrs(struct xdr_stream *xdr, | 4460 | static int decode_chan_attrs(struct xdr_stream *xdr, |
@@ -4232,22 +4463,35 @@ static int decode_chan_attrs(struct xdr_stream *xdr, | |||
4232 | __be32 *p; | 4463 | __be32 *p; |
4233 | u32 nr_attrs; | 4464 | u32 nr_attrs; |
4234 | 4465 | ||
4235 | READ_BUF(28); | 4466 | p = xdr_inline_decode(xdr, 28); |
4236 | READ32(attrs->headerpadsz); | 4467 | if (unlikely(!p)) |
4237 | READ32(attrs->max_rqst_sz); | 4468 | goto out_overflow; |
4238 | READ32(attrs->max_resp_sz); | 4469 | attrs->headerpadsz = be32_to_cpup(p++); |
4239 | READ32(attrs->max_resp_sz_cached); | 4470 | attrs->max_rqst_sz = be32_to_cpup(p++); |
4240 | READ32(attrs->max_ops); | 4471 | attrs->max_resp_sz = be32_to_cpup(p++); |
4241 | READ32(attrs->max_reqs); | 4472 | attrs->max_resp_sz_cached = be32_to_cpup(p++); |
4242 | READ32(nr_attrs); | 4473 | attrs->max_ops = be32_to_cpup(p++); |
4474 | attrs->max_reqs = be32_to_cpup(p++); | ||
4475 | nr_attrs = be32_to_cpup(p); | ||
4243 | if (unlikely(nr_attrs > 1)) { | 4476 | if (unlikely(nr_attrs > 1)) { |
4244 | printk(KERN_WARNING "%s: Invalid rdma channel attrs count %u\n", | 4477 | printk(KERN_WARNING "%s: Invalid rdma channel attrs count %u\n", |
4245 | __func__, nr_attrs); | 4478 | __func__, nr_attrs); |
4246 | return -EINVAL; | 4479 | return -EINVAL; |
4247 | } | 4480 | } |
4248 | if (nr_attrs == 1) | 4481 | if (nr_attrs == 1) { |
4249 | READ_BUF(4); /* skip rdma_attrs */ | 4482 | p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */ |
4483 | if (unlikely(!p)) | ||
4484 | goto out_overflow; | ||
4485 | } | ||
4250 | return 0; | 4486 | return 0; |
4487 | out_overflow: | ||
4488 | print_overflow_msg(__func__, xdr); | ||
4489 | return -EIO; | ||
4490 | } | ||
4491 | |||
4492 | static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid) | ||
4493 | { | ||
4494 | return decode_opaque_fixed(xdr, sid->data, NFS4_MAX_SESSIONID_LEN); | ||
4251 | } | 4495 | } |
4252 | 4496 | ||
4253 | static int decode_create_session(struct xdr_stream *xdr, | 4497 | static int decode_create_session(struct xdr_stream *xdr, |
@@ -4259,24 +4503,26 @@ static int decode_create_session(struct xdr_stream *xdr, | |||
4259 | struct nfs4_session *session = clp->cl_session; | 4503 | struct nfs4_session *session = clp->cl_session; |
4260 | 4504 | ||
4261 | status = decode_op_hdr(xdr, OP_CREATE_SESSION); | 4505 | status = decode_op_hdr(xdr, OP_CREATE_SESSION); |
4262 | 4506 | if (!status) | |
4263 | if (status) | 4507 | status = decode_sessionid(xdr, &session->sess_id); |
4508 | if (unlikely(status)) | ||
4264 | return status; | 4509 | return status; |
4265 | 4510 | ||
4266 | /* sessionid */ | ||
4267 | READ_BUF(NFS4_MAX_SESSIONID_LEN); | ||
4268 | COPYMEM(&session->sess_id, NFS4_MAX_SESSIONID_LEN); | ||
4269 | |||
4270 | /* seqid, flags */ | 4511 | /* seqid, flags */ |
4271 | READ_BUF(8); | 4512 | p = xdr_inline_decode(xdr, 8); |
4272 | READ32(clp->cl_seqid); | 4513 | if (unlikely(!p)) |
4273 | READ32(session->flags); | 4514 | goto out_overflow; |
4515 | clp->cl_seqid = be32_to_cpup(p++); | ||
4516 | session->flags = be32_to_cpup(p); | ||
4274 | 4517 | ||
4275 | /* Channel attributes */ | 4518 | /* Channel attributes */ |
4276 | status = decode_chan_attrs(xdr, &session->fc_attrs); | 4519 | status = decode_chan_attrs(xdr, &session->fc_attrs); |
4277 | if (!status) | 4520 | if (!status) |
4278 | status = decode_chan_attrs(xdr, &session->bc_attrs); | 4521 | status = decode_chan_attrs(xdr, &session->bc_attrs); |
4279 | return status; | 4522 | return status; |
4523 | out_overflow: | ||
4524 | print_overflow_msg(__func__, xdr); | ||
4525 | return -EIO; | ||
4280 | } | 4526 | } |
4281 | 4527 | ||
4282 | static int decode_destroy_session(struct xdr_stream *xdr, void *dummy) | 4528 | static int decode_destroy_session(struct xdr_stream *xdr, void *dummy) |
@@ -4300,7 +4546,9 @@ static int decode_sequence(struct xdr_stream *xdr, | |||
4300 | return 0; | 4546 | return 0; |
4301 | 4547 | ||
4302 | status = decode_op_hdr(xdr, OP_SEQUENCE); | 4548 | status = decode_op_hdr(xdr, OP_SEQUENCE); |
4303 | if (status) | 4549 | if (!status) |
4550 | status = decode_sessionid(xdr, &id); | ||
4551 | if (unlikely(status)) | ||
4304 | goto out_err; | 4552 | goto out_err; |
4305 | 4553 | ||
4306 | /* | 4554 | /* |
@@ -4309,36 +4557,43 @@ static int decode_sequence(struct xdr_stream *xdr, | |||
4309 | */ | 4557 | */ |
4310 | status = -ESERVERFAULT; | 4558 | status = -ESERVERFAULT; |
4311 | 4559 | ||
4312 | slot = &res->sr_session->fc_slot_table.slots[res->sr_slotid]; | ||
4313 | READ_BUF(NFS4_MAX_SESSIONID_LEN + 20); | ||
4314 | COPYMEM(id.data, NFS4_MAX_SESSIONID_LEN); | ||
4315 | if (memcmp(id.data, res->sr_session->sess_id.data, | 4560 | if (memcmp(id.data, res->sr_session->sess_id.data, |
4316 | NFS4_MAX_SESSIONID_LEN)) { | 4561 | NFS4_MAX_SESSIONID_LEN)) { |
4317 | dprintk("%s Invalid session id\n", __func__); | 4562 | dprintk("%s Invalid session id\n", __func__); |
4318 | goto out_err; | 4563 | goto out_err; |
4319 | } | 4564 | } |
4565 | |||
4566 | p = xdr_inline_decode(xdr, 20); | ||
4567 | if (unlikely(!p)) | ||
4568 | goto out_overflow; | ||
4569 | |||
4320 | /* seqid */ | 4570 | /* seqid */ |
4321 | READ32(dummy); | 4571 | slot = &res->sr_session->fc_slot_table.slots[res->sr_slotid]; |
4572 | dummy = be32_to_cpup(p++); | ||
4322 | if (dummy != slot->seq_nr) { | 4573 | if (dummy != slot->seq_nr) { |
4323 | dprintk("%s Invalid sequence number\n", __func__); | 4574 | dprintk("%s Invalid sequence number\n", __func__); |
4324 | goto out_err; | 4575 | goto out_err; |
4325 | } | 4576 | } |
4326 | /* slot id */ | 4577 | /* slot id */ |
4327 | READ32(dummy); | 4578 | dummy = be32_to_cpup(p++); |
4328 | if (dummy != res->sr_slotid) { | 4579 | if (dummy != res->sr_slotid) { |
4329 | dprintk("%s Invalid slot id\n", __func__); | 4580 | dprintk("%s Invalid slot id\n", __func__); |
4330 | goto out_err; | 4581 | goto out_err; |
4331 | } | 4582 | } |
4332 | /* highest slot id - currently not processed */ | 4583 | /* highest slot id - currently not processed */ |
4333 | READ32(dummy); | 4584 | dummy = be32_to_cpup(p++); |
4334 | /* target highest slot id - currently not processed */ | 4585 | /* target highest slot id - currently not processed */ |
4335 | READ32(dummy); | 4586 | dummy = be32_to_cpup(p++); |
4336 | /* result flags - currently not processed */ | 4587 | /* result flags - currently not processed */ |
4337 | READ32(dummy); | 4588 | dummy = be32_to_cpup(p); |
4338 | status = 0; | 4589 | status = 0; |
4339 | out_err: | 4590 | out_err: |
4340 | res->sr_status = status; | 4591 | res->sr_status = status; |
4341 | return status; | 4592 | return status; |
4593 | out_overflow: | ||
4594 | print_overflow_msg(__func__, xdr); | ||
4595 | status = -EIO; | ||
4596 | goto out_err; | ||
4342 | #else /* CONFIG_NFS_V4_1 */ | 4597 | #else /* CONFIG_NFS_V4_1 */ |
4343 | return 0; | 4598 | return 0; |
4344 | #endif /* CONFIG_NFS_V4_1 */ | 4599 | #endif /* CONFIG_NFS_V4_1 */ |
@@ -4370,7 +4625,8 @@ static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct | |||
4370 | status = decode_open_downgrade(&xdr, res); | 4625 | status = decode_open_downgrade(&xdr, res); |
4371 | if (status != 0) | 4626 | if (status != 0) |
4372 | goto out; | 4627 | goto out; |
4373 | decode_getfattr(&xdr, res->fattr, res->server); | 4628 | decode_getfattr(&xdr, res->fattr, res->server, |
4629 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4374 | out: | 4630 | out: |
4375 | return status; | 4631 | return status; |
4376 | } | 4632 | } |
@@ -4397,7 +4653,8 @@ static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_ac | |||
4397 | status = decode_access(&xdr, res); | 4653 | status = decode_access(&xdr, res); |
4398 | if (status != 0) | 4654 | if (status != 0) |
4399 | goto out; | 4655 | goto out; |
4400 | decode_getfattr(&xdr, res->fattr, res->server); | 4656 | decode_getfattr(&xdr, res->fattr, res->server, |
4657 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4401 | out: | 4658 | out: |
4402 | return status; | 4659 | return status; |
4403 | } | 4660 | } |
@@ -4424,7 +4681,8 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lo | |||
4424 | goto out; | 4681 | goto out; |
4425 | if ((status = decode_getfh(&xdr, res->fh)) != 0) | 4682 | if ((status = decode_getfh(&xdr, res->fh)) != 0) |
4426 | goto out; | 4683 | goto out; |
4427 | status = decode_getfattr(&xdr, res->fattr, res->server); | 4684 | status = decode_getfattr(&xdr, res->fattr, res->server |
4685 | ,!RPC_IS_ASYNC(rqstp->rq_task)); | ||
4428 | out: | 4686 | out: |
4429 | return status; | 4687 | return status; |
4430 | } | 4688 | } |
@@ -4448,7 +4706,8 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nf | |||
4448 | if ((status = decode_putrootfh(&xdr)) != 0) | 4706 | if ((status = decode_putrootfh(&xdr)) != 0) |
4449 | goto out; | 4707 | goto out; |
4450 | if ((status = decode_getfh(&xdr, res->fh)) == 0) | 4708 | if ((status = decode_getfh(&xdr, res->fh)) == 0) |
4451 | status = decode_getfattr(&xdr, res->fattr, res->server); | 4709 | status = decode_getfattr(&xdr, res->fattr, res->server, |
4710 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4452 | out: | 4711 | out: |
4453 | return status; | 4712 | return status; |
4454 | } | 4713 | } |
@@ -4473,7 +4732,8 @@ static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_rem | |||
4473 | goto out; | 4732 | goto out; |
4474 | if ((status = decode_remove(&xdr, &res->cinfo)) != 0) | 4733 | if ((status = decode_remove(&xdr, &res->cinfo)) != 0) |
4475 | goto out; | 4734 | goto out; |
4476 | decode_getfattr(&xdr, &res->dir_attr, res->server); | 4735 | decode_getfattr(&xdr, &res->dir_attr, res->server, |
4736 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4477 | out: | 4737 | out: |
4478 | return status; | 4738 | return status; |
4479 | } | 4739 | } |
@@ -4503,11 +4763,13 @@ static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_re | |||
4503 | if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0) | 4763 | if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0) |
4504 | goto out; | 4764 | goto out; |
4505 | /* Current FH is target directory */ | 4765 | /* Current FH is target directory */ |
4506 | if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0) | 4766 | if (decode_getfattr(&xdr, res->new_fattr, res->server, |
4767 | !RPC_IS_ASYNC(rqstp->rq_task)) != 0) | ||
4507 | goto out; | 4768 | goto out; |
4508 | if ((status = decode_restorefh(&xdr)) != 0) | 4769 | if ((status = decode_restorefh(&xdr)) != 0) |
4509 | goto out; | 4770 | goto out; |
4510 | decode_getfattr(&xdr, res->old_fattr, res->server); | 4771 | decode_getfattr(&xdr, res->old_fattr, res->server, |
4772 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4511 | out: | 4773 | out: |
4512 | return status; | 4774 | return status; |
4513 | } | 4775 | } |
@@ -4540,11 +4802,13 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_link | |||
4540 | * Note order: OP_LINK leaves the directory as the current | 4802 | * Note order: OP_LINK leaves the directory as the current |
4541 | * filehandle. | 4803 | * filehandle. |
4542 | */ | 4804 | */ |
4543 | if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0) | 4805 | if (decode_getfattr(&xdr, res->dir_attr, res->server, |
4806 | !RPC_IS_ASYNC(rqstp->rq_task)) != 0) | ||
4544 | goto out; | 4807 | goto out; |
4545 | if ((status = decode_restorefh(&xdr)) != 0) | 4808 | if ((status = decode_restorefh(&xdr)) != 0) |
4546 | goto out; | 4809 | goto out; |
4547 | decode_getfattr(&xdr, res->fattr, res->server); | 4810 | decode_getfattr(&xdr, res->fattr, res->server, |
4811 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4548 | out: | 4812 | out: |
4549 | return status; | 4813 | return status; |
4550 | } | 4814 | } |
@@ -4573,11 +4837,13 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_cr | |||
4573 | goto out; | 4837 | goto out; |
4574 | if ((status = decode_getfh(&xdr, res->fh)) != 0) | 4838 | if ((status = decode_getfh(&xdr, res->fh)) != 0) |
4575 | goto out; | 4839 | goto out; |
4576 | if (decode_getfattr(&xdr, res->fattr, res->server) != 0) | 4840 | if (decode_getfattr(&xdr, res->fattr, res->server, |
4841 | !RPC_IS_ASYNC(rqstp->rq_task)) != 0) | ||
4577 | goto out; | 4842 | goto out; |
4578 | if ((status = decode_restorefh(&xdr)) != 0) | 4843 | if ((status = decode_restorefh(&xdr)) != 0) |
4579 | goto out; | 4844 | goto out; |
4580 | decode_getfattr(&xdr, res->dir_fattr, res->server); | 4845 | decode_getfattr(&xdr, res->dir_fattr, res->server, |
4846 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4581 | out: | 4847 | out: |
4582 | return status; | 4848 | return status; |
4583 | } | 4849 | } |
@@ -4609,7 +4875,8 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_g | |||
4609 | status = decode_putfh(&xdr); | 4875 | status = decode_putfh(&xdr); |
4610 | if (status) | 4876 | if (status) |
4611 | goto out; | 4877 | goto out; |
4612 | status = decode_getfattr(&xdr, res->fattr, res->server); | 4878 | status = decode_getfattr(&xdr, res->fattr, res->server, |
4879 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4613 | out: | 4880 | out: |
4614 | return status; | 4881 | return status; |
4615 | } | 4882 | } |
@@ -4716,7 +4983,8 @@ static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_clos | |||
4716 | * an ESTALE error. Shouldn't be a problem, | 4983 | * an ESTALE error. Shouldn't be a problem, |
4717 | * though, since fattr->valid will remain unset. | 4984 | * though, since fattr->valid will remain unset. |
4718 | */ | 4985 | */ |
4719 | decode_getfattr(&xdr, res->fattr, res->server); | 4986 | decode_getfattr(&xdr, res->fattr, res->server, |
4987 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4720 | out: | 4988 | out: |
4721 | return status; | 4989 | return status; |
4722 | } | 4990 | } |
@@ -4748,11 +5016,13 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openr | |||
4748 | goto out; | 5016 | goto out; |
4749 | if (decode_getfh(&xdr, &res->fh) != 0) | 5017 | if (decode_getfh(&xdr, &res->fh) != 0) |
4750 | goto out; | 5018 | goto out; |
4751 | if (decode_getfattr(&xdr, res->f_attr, res->server) != 0) | 5019 | if (decode_getfattr(&xdr, res->f_attr, res->server, |
5020 | !RPC_IS_ASYNC(rqstp->rq_task)) != 0) | ||
4752 | goto out; | 5021 | goto out; |
4753 | if (decode_restorefh(&xdr) != 0) | 5022 | if (decode_restorefh(&xdr) != 0) |
4754 | goto out; | 5023 | goto out; |
4755 | decode_getfattr(&xdr, res->dir_attr, res->server); | 5024 | decode_getfattr(&xdr, res->dir_attr, res->server, |
5025 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4756 | out: | 5026 | out: |
4757 | return status; | 5027 | return status; |
4758 | } | 5028 | } |
@@ -4800,7 +5070,8 @@ static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nf | |||
4800 | status = decode_open(&xdr, res); | 5070 | status = decode_open(&xdr, res); |
4801 | if (status) | 5071 | if (status) |
4802 | goto out; | 5072 | goto out; |
4803 | decode_getfattr(&xdr, res->f_attr, res->server); | 5073 | decode_getfattr(&xdr, res->f_attr, res->server, |
5074 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4804 | out: | 5075 | out: |
4805 | return status; | 5076 | return status; |
4806 | } | 5077 | } |
@@ -4827,7 +5098,8 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_se | |||
4827 | status = decode_setattr(&xdr); | 5098 | status = decode_setattr(&xdr); |
4828 | if (status) | 5099 | if (status) |
4829 | goto out; | 5100 | goto out; |
4830 | decode_getfattr(&xdr, res->fattr, res->server); | 5101 | decode_getfattr(&xdr, res->fattr, res->server, |
5102 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
4831 | out: | 5103 | out: |
4832 | return status; | 5104 | return status; |
4833 | } | 5105 | } |
@@ -5001,7 +5273,8 @@ static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writ | |||
5001 | status = decode_write(&xdr, res); | 5273 | status = decode_write(&xdr, res); |
5002 | if (status) | 5274 | if (status) |
5003 | goto out; | 5275 | goto out; |
5004 | decode_getfattr(&xdr, res->fattr, res->server); | 5276 | decode_getfattr(&xdr, res->fattr, res->server, |
5277 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
5005 | if (!status) | 5278 | if (!status) |
5006 | status = res->count; | 5279 | status = res->count; |
5007 | out: | 5280 | out: |
@@ -5030,7 +5303,8 @@ static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_wri | |||
5030 | status = decode_commit(&xdr, res); | 5303 | status = decode_commit(&xdr, res); |
5031 | if (status) | 5304 | if (status) |
5032 | goto out; | 5305 | goto out; |
5033 | decode_getfattr(&xdr, res->fattr, res->server); | 5306 | decode_getfattr(&xdr, res->fattr, res->server, |
5307 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
5034 | out: | 5308 | out: |
5035 | return status; | 5309 | return status; |
5036 | } | 5310 | } |
@@ -5194,7 +5468,8 @@ static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nf | |||
5194 | if (status != 0) | 5468 | if (status != 0) |
5195 | goto out; | 5469 | goto out; |
5196 | status = decode_delegreturn(&xdr); | 5470 | status = decode_delegreturn(&xdr); |
5197 | decode_getfattr(&xdr, res->fattr, res->server); | 5471 | decode_getfattr(&xdr, res->fattr, res->server, |
5472 | !RPC_IS_ASYNC(rqstp->rq_task)); | ||
5198 | out: | 5473 | out: |
5199 | return status; | 5474 | return status; |
5200 | } | 5475 | } |
@@ -5222,7 +5497,8 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p, | |||
5222 | goto out; | 5497 | goto out; |
5223 | xdr_enter_page(&xdr, PAGE_SIZE); | 5498 | xdr_enter_page(&xdr, PAGE_SIZE); |
5224 | status = decode_getfattr(&xdr, &res->fs_locations->fattr, | 5499 | status = decode_getfattr(&xdr, &res->fs_locations->fattr, |
5225 | res->fs_locations->server); | 5500 | res->fs_locations->server, |
5501 | !RPC_IS_ASYNC(req->rq_task)); | ||
5226 | out: | 5502 | out: |
5227 | return status; | 5503 | return status; |
5228 | } | 5504 | } |
diff --git a/fs/nfs/super.c b/fs/nfs/super.c index 0b4cbdc60abd..867f70504531 100644 --- a/fs/nfs/super.c +++ b/fs/nfs/super.c | |||
@@ -73,7 +73,7 @@ enum { | |||
73 | Opt_cto, Opt_nocto, | 73 | Opt_cto, Opt_nocto, |
74 | Opt_ac, Opt_noac, | 74 | Opt_ac, Opt_noac, |
75 | Opt_lock, Opt_nolock, | 75 | Opt_lock, Opt_nolock, |
76 | Opt_v2, Opt_v3, | 76 | Opt_v2, Opt_v3, Opt_v4, |
77 | Opt_udp, Opt_tcp, Opt_rdma, | 77 | Opt_udp, Opt_tcp, Opt_rdma, |
78 | Opt_acl, Opt_noacl, | 78 | Opt_acl, Opt_noacl, |
79 | Opt_rdirplus, Opt_nordirplus, | 79 | Opt_rdirplus, Opt_nordirplus, |
@@ -127,6 +127,7 @@ static const match_table_t nfs_mount_option_tokens = { | |||
127 | { Opt_nolock, "nolock" }, | 127 | { Opt_nolock, "nolock" }, |
128 | { Opt_v2, "v2" }, | 128 | { Opt_v2, "v2" }, |
129 | { Opt_v3, "v3" }, | 129 | { Opt_v3, "v3" }, |
130 | { Opt_v4, "v4" }, | ||
130 | { Opt_udp, "udp" }, | 131 | { Opt_udp, "udp" }, |
131 | { Opt_tcp, "tcp" }, | 132 | { Opt_tcp, "tcp" }, |
132 | { Opt_rdma, "rdma" }, | 133 | { Opt_rdma, "rdma" }, |
@@ -158,7 +159,7 @@ static const match_table_t nfs_mount_option_tokens = { | |||
158 | { Opt_mountvers, "mountvers=%s" }, | 159 | { Opt_mountvers, "mountvers=%s" }, |
159 | { Opt_nfsvers, "nfsvers=%s" }, | 160 | { Opt_nfsvers, "nfsvers=%s" }, |
160 | { Opt_nfsvers, "vers=%s" }, | 161 | { Opt_nfsvers, "vers=%s" }, |
161 | { Opt_minorversion, "minorversion=%u" }, | 162 | { Opt_minorversion, "minorversion=%s" }, |
162 | 163 | ||
163 | { Opt_sec, "sec=%s" }, | 164 | { Opt_sec, "sec=%s" }, |
164 | { Opt_proto, "proto=%s" }, | 165 | { Opt_proto, "proto=%s" }, |
@@ -272,6 +273,10 @@ static const struct super_operations nfs_sops = { | |||
272 | }; | 273 | }; |
273 | 274 | ||
274 | #ifdef CONFIG_NFS_V4 | 275 | #ifdef CONFIG_NFS_V4 |
276 | static int nfs4_validate_text_mount_data(void *options, | ||
277 | struct nfs_parsed_mount_data *args, const char *dev_name); | ||
278 | static int nfs4_try_mount(int flags, const char *dev_name, | ||
279 | struct nfs_parsed_mount_data *data, struct vfsmount *mnt); | ||
275 | static int nfs4_get_sb(struct file_system_type *fs_type, | 280 | static int nfs4_get_sb(struct file_system_type *fs_type, |
276 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt); | 281 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt); |
277 | static int nfs4_remote_get_sb(struct file_system_type *fs_type, | 282 | static int nfs4_remote_get_sb(struct file_system_type *fs_type, |
@@ -742,127 +747,23 @@ static int nfs_verify_server_address(struct sockaddr *addr) | |||
742 | } | 747 | } |
743 | } | 748 | } |
744 | 749 | ||
750 | dfprintk(MOUNT, "NFS: Invalid IP address specified\n"); | ||
745 | return 0; | 751 | return 0; |
746 | } | 752 | } |
747 | 753 | ||
748 | static void nfs_parse_ipv4_address(char *string, size_t str_len, | ||
749 | struct sockaddr *sap, size_t *addr_len) | ||
750 | { | ||
751 | struct sockaddr_in *sin = (struct sockaddr_in *)sap; | ||
752 | u8 *addr = (u8 *)&sin->sin_addr.s_addr; | ||
753 | |||
754 | if (str_len <= INET_ADDRSTRLEN) { | ||
755 | dfprintk(MOUNT, "NFS: parsing IPv4 address %*s\n", | ||
756 | (int)str_len, string); | ||
757 | |||
758 | sin->sin_family = AF_INET; | ||
759 | *addr_len = sizeof(*sin); | ||
760 | if (in4_pton(string, str_len, addr, '\0', NULL)) | ||
761 | return; | ||
762 | } | ||
763 | |||
764 | sap->sa_family = AF_UNSPEC; | ||
765 | *addr_len = 0; | ||
766 | } | ||
767 | |||
768 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | ||
769 | static int nfs_parse_ipv6_scope_id(const char *string, const size_t str_len, | ||
770 | const char *delim, | ||
771 | struct sockaddr_in6 *sin6) | ||
772 | { | ||
773 | char *p; | ||
774 | size_t len; | ||
775 | |||
776 | if ((string + str_len) == delim) | ||
777 | return 1; | ||
778 | |||
779 | if (*delim != IPV6_SCOPE_DELIMITER) | ||
780 | return 0; | ||
781 | |||
782 | if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)) | ||
783 | return 0; | ||
784 | |||
785 | len = (string + str_len) - delim - 1; | ||
786 | p = kstrndup(delim + 1, len, GFP_KERNEL); | ||
787 | if (p) { | ||
788 | unsigned long scope_id = 0; | ||
789 | struct net_device *dev; | ||
790 | |||
791 | dev = dev_get_by_name(&init_net, p); | ||
792 | if (dev != NULL) { | ||
793 | scope_id = dev->ifindex; | ||
794 | dev_put(dev); | ||
795 | } else { | ||
796 | if (strict_strtoul(p, 10, &scope_id) == 0) { | ||
797 | kfree(p); | ||
798 | return 0; | ||
799 | } | ||
800 | } | ||
801 | |||
802 | kfree(p); | ||
803 | |||
804 | sin6->sin6_scope_id = scope_id; | ||
805 | dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id); | ||
806 | return 1; | ||
807 | } | ||
808 | |||
809 | return 0; | ||
810 | } | ||
811 | |||
812 | static void nfs_parse_ipv6_address(char *string, size_t str_len, | ||
813 | struct sockaddr *sap, size_t *addr_len) | ||
814 | { | ||
815 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; | ||
816 | u8 *addr = (u8 *)&sin6->sin6_addr.in6_u; | ||
817 | const char *delim; | ||
818 | |||
819 | if (str_len <= INET6_ADDRSTRLEN) { | ||
820 | dfprintk(MOUNT, "NFS: parsing IPv6 address %*s\n", | ||
821 | (int)str_len, string); | ||
822 | |||
823 | sin6->sin6_family = AF_INET6; | ||
824 | *addr_len = sizeof(*sin6); | ||
825 | if (in6_pton(string, str_len, addr, | ||
826 | IPV6_SCOPE_DELIMITER, &delim) != 0) { | ||
827 | if (nfs_parse_ipv6_scope_id(string, str_len, | ||
828 | delim, sin6) != 0) | ||
829 | return; | ||
830 | } | ||
831 | } | ||
832 | |||
833 | sap->sa_family = AF_UNSPEC; | ||
834 | *addr_len = 0; | ||
835 | } | ||
836 | #else | ||
837 | static void nfs_parse_ipv6_address(char *string, size_t str_len, | ||
838 | struct sockaddr *sap, size_t *addr_len) | ||
839 | { | ||
840 | sap->sa_family = AF_UNSPEC; | ||
841 | *addr_len = 0; | ||
842 | } | ||
843 | #endif | ||
844 | |||
845 | /* | 754 | /* |
846 | * Construct a sockaddr based on the contents of a string that contains | 755 | * Select between a default port value and a user-specified port value. |
847 | * an IP address in presentation format. | 756 | * If a zero value is set, then autobind will be used. |
848 | * | ||
849 | * If there is a problem constructing the new sockaddr, set the address | ||
850 | * family to AF_UNSPEC. | ||
851 | */ | 757 | */ |
852 | void nfs_parse_ip_address(char *string, size_t str_len, | 758 | static void nfs_set_default_port(struct sockaddr *sap, const int parsed_port, |
853 | struct sockaddr *sap, size_t *addr_len) | 759 | const unsigned short default_port) |
854 | { | 760 | { |
855 | unsigned int i, colons; | 761 | unsigned short port = default_port; |
856 | 762 | ||
857 | colons = 0; | 763 | if (parsed_port != NFS_UNSPEC_PORT) |
858 | for (i = 0; i < str_len; i++) | 764 | port = parsed_port; |
859 | if (string[i] == ':') | ||
860 | colons++; | ||
861 | 765 | ||
862 | if (colons >= 2) | 766 | rpc_set_port(sap, port); |
863 | nfs_parse_ipv6_address(string, str_len, sap, addr_len); | ||
864 | else | ||
865 | nfs_parse_ipv4_address(string, str_len, sap, addr_len); | ||
866 | } | 767 | } |
867 | 768 | ||
868 | /* | 769 | /* |
@@ -904,8 +805,6 @@ static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt) | |||
904 | 805 | ||
905 | /* | 806 | /* |
906 | * Parse the value of the 'sec=' option. | 807 | * Parse the value of the 'sec=' option. |
907 | * | ||
908 | * The flavor_len setting is for v4 mounts. | ||
909 | */ | 808 | */ |
910 | static int nfs_parse_security_flavors(char *value, | 809 | static int nfs_parse_security_flavors(char *value, |
911 | struct nfs_parsed_mount_data *mnt) | 810 | struct nfs_parsed_mount_data *mnt) |
@@ -916,53 +815,43 @@ static int nfs_parse_security_flavors(char *value, | |||
916 | 815 | ||
917 | switch (match_token(value, nfs_secflavor_tokens, args)) { | 816 | switch (match_token(value, nfs_secflavor_tokens, args)) { |
918 | case Opt_sec_none: | 817 | case Opt_sec_none: |
919 | mnt->auth_flavor_len = 0; | ||
920 | mnt->auth_flavors[0] = RPC_AUTH_NULL; | 818 | mnt->auth_flavors[0] = RPC_AUTH_NULL; |
921 | break; | 819 | break; |
922 | case Opt_sec_sys: | 820 | case Opt_sec_sys: |
923 | mnt->auth_flavor_len = 0; | ||
924 | mnt->auth_flavors[0] = RPC_AUTH_UNIX; | 821 | mnt->auth_flavors[0] = RPC_AUTH_UNIX; |
925 | break; | 822 | break; |
926 | case Opt_sec_krb5: | 823 | case Opt_sec_krb5: |
927 | mnt->auth_flavor_len = 1; | ||
928 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5; | 824 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5; |
929 | break; | 825 | break; |
930 | case Opt_sec_krb5i: | 826 | case Opt_sec_krb5i: |
931 | mnt->auth_flavor_len = 1; | ||
932 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I; | 827 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I; |
933 | break; | 828 | break; |
934 | case Opt_sec_krb5p: | 829 | case Opt_sec_krb5p: |
935 | mnt->auth_flavor_len = 1; | ||
936 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P; | 830 | mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P; |
937 | break; | 831 | break; |
938 | case Opt_sec_lkey: | 832 | case Opt_sec_lkey: |
939 | mnt->auth_flavor_len = 1; | ||
940 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY; | 833 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY; |
941 | break; | 834 | break; |
942 | case Opt_sec_lkeyi: | 835 | case Opt_sec_lkeyi: |
943 | mnt->auth_flavor_len = 1; | ||
944 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI; | 836 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI; |
945 | break; | 837 | break; |
946 | case Opt_sec_lkeyp: | 838 | case Opt_sec_lkeyp: |
947 | mnt->auth_flavor_len = 1; | ||
948 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP; | 839 | mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP; |
949 | break; | 840 | break; |
950 | case Opt_sec_spkm: | 841 | case Opt_sec_spkm: |
951 | mnt->auth_flavor_len = 1; | ||
952 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM; | 842 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM; |
953 | break; | 843 | break; |
954 | case Opt_sec_spkmi: | 844 | case Opt_sec_spkmi: |
955 | mnt->auth_flavor_len = 1; | ||
956 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI; | 845 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI; |
957 | break; | 846 | break; |
958 | case Opt_sec_spkmp: | 847 | case Opt_sec_spkmp: |
959 | mnt->auth_flavor_len = 1; | ||
960 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP; | 848 | mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP; |
961 | break; | 849 | break; |
962 | default: | 850 | default: |
963 | return 0; | 851 | return 0; |
964 | } | 852 | } |
965 | 853 | ||
854 | mnt->auth_flavor_len = 1; | ||
966 | return 1; | 855 | return 1; |
967 | } | 856 | } |
968 | 857 | ||
@@ -1001,7 +890,6 @@ static int nfs_parse_mount_options(char *raw, | |||
1001 | while ((p = strsep(&raw, ",")) != NULL) { | 890 | while ((p = strsep(&raw, ",")) != NULL) { |
1002 | substring_t args[MAX_OPT_ARGS]; | 891 | substring_t args[MAX_OPT_ARGS]; |
1003 | unsigned long option; | 892 | unsigned long option; |
1004 | int int_option; | ||
1005 | int token; | 893 | int token; |
1006 | 894 | ||
1007 | if (!*p) | 895 | if (!*p) |
@@ -1047,10 +935,18 @@ static int nfs_parse_mount_options(char *raw, | |||
1047 | break; | 935 | break; |
1048 | case Opt_v2: | 936 | case Opt_v2: |
1049 | mnt->flags &= ~NFS_MOUNT_VER3; | 937 | mnt->flags &= ~NFS_MOUNT_VER3; |
938 | mnt->version = 2; | ||
1050 | break; | 939 | break; |
1051 | case Opt_v3: | 940 | case Opt_v3: |
1052 | mnt->flags |= NFS_MOUNT_VER3; | 941 | mnt->flags |= NFS_MOUNT_VER3; |
942 | mnt->version = 3; | ||
1053 | break; | 943 | break; |
944 | #ifdef CONFIG_NFS_V4 | ||
945 | case Opt_v4: | ||
946 | mnt->flags &= ~NFS_MOUNT_VER3; | ||
947 | mnt->version = 4; | ||
948 | break; | ||
949 | #endif | ||
1054 | case Opt_udp: | 950 | case Opt_udp: |
1055 | mnt->flags &= ~NFS_MOUNT_TCP; | 951 | mnt->flags &= ~NFS_MOUNT_TCP; |
1056 | mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; | 952 | mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; |
@@ -1264,20 +1160,33 @@ static int nfs_parse_mount_options(char *raw, | |||
1264 | switch (option) { | 1160 | switch (option) { |
1265 | case NFS2_VERSION: | 1161 | case NFS2_VERSION: |
1266 | mnt->flags &= ~NFS_MOUNT_VER3; | 1162 | mnt->flags &= ~NFS_MOUNT_VER3; |
1163 | mnt->version = 2; | ||
1267 | break; | 1164 | break; |
1268 | case NFS3_VERSION: | 1165 | case NFS3_VERSION: |
1269 | mnt->flags |= NFS_MOUNT_VER3; | 1166 | mnt->flags |= NFS_MOUNT_VER3; |
1167 | mnt->version = 3; | ||
1270 | break; | 1168 | break; |
1169 | #ifdef CONFIG_NFS_V4 | ||
1170 | case NFS4_VERSION: | ||
1171 | mnt->flags &= ~NFS_MOUNT_VER3; | ||
1172 | mnt->version = 4; | ||
1173 | break; | ||
1174 | #endif | ||
1271 | default: | 1175 | default: |
1272 | goto out_invalid_value; | 1176 | goto out_invalid_value; |
1273 | } | 1177 | } |
1274 | break; | 1178 | break; |
1275 | case Opt_minorversion: | 1179 | case Opt_minorversion: |
1276 | if (match_int(args, &int_option)) | 1180 | string = match_strdup(args); |
1277 | return 0; | 1181 | if (string == NULL) |
1278 | if (int_option < 0 || int_option > NFS4_MAX_MINOR_VERSION) | 1182 | goto out_nomem; |
1279 | return 0; | 1183 | rc = strict_strtoul(string, 10, &option); |
1280 | mnt->minorversion = int_option; | 1184 | kfree(string); |
1185 | if (rc != 0) | ||
1186 | goto out_invalid_value; | ||
1187 | if (option > NFS4_MAX_MINOR_VERSION) | ||
1188 | goto out_invalid_value; | ||
1189 | mnt->minorversion = option; | ||
1281 | break; | 1190 | break; |
1282 | 1191 | ||
1283 | /* | 1192 | /* |
@@ -1352,11 +1261,14 @@ static int nfs_parse_mount_options(char *raw, | |||
1352 | string = match_strdup(args); | 1261 | string = match_strdup(args); |
1353 | if (string == NULL) | 1262 | if (string == NULL) |
1354 | goto out_nomem; | 1263 | goto out_nomem; |
1355 | nfs_parse_ip_address(string, strlen(string), | 1264 | mnt->nfs_server.addrlen = |
1356 | (struct sockaddr *) | 1265 | rpc_pton(string, strlen(string), |
1357 | &mnt->nfs_server.address, | 1266 | (struct sockaddr *) |
1358 | &mnt->nfs_server.addrlen); | 1267 | &mnt->nfs_server.address, |
1268 | sizeof(mnt->nfs_server.address)); | ||
1359 | kfree(string); | 1269 | kfree(string); |
1270 | if (mnt->nfs_server.addrlen == 0) | ||
1271 | goto out_invalid_address; | ||
1360 | break; | 1272 | break; |
1361 | case Opt_clientaddr: | 1273 | case Opt_clientaddr: |
1362 | string = match_strdup(args); | 1274 | string = match_strdup(args); |
@@ -1376,11 +1288,14 @@ static int nfs_parse_mount_options(char *raw, | |||
1376 | string = match_strdup(args); | 1288 | string = match_strdup(args); |
1377 | if (string == NULL) | 1289 | if (string == NULL) |
1378 | goto out_nomem; | 1290 | goto out_nomem; |
1379 | nfs_parse_ip_address(string, strlen(string), | 1291 | mnt->mount_server.addrlen = |
1380 | (struct sockaddr *) | 1292 | rpc_pton(string, strlen(string), |
1381 | &mnt->mount_server.address, | 1293 | (struct sockaddr *) |
1382 | &mnt->mount_server.addrlen); | 1294 | &mnt->mount_server.address, |
1295 | sizeof(mnt->mount_server.address)); | ||
1383 | kfree(string); | 1296 | kfree(string); |
1297 | if (mnt->mount_server.addrlen == 0) | ||
1298 | goto out_invalid_address; | ||
1384 | break; | 1299 | break; |
1385 | case Opt_lookupcache: | 1300 | case Opt_lookupcache: |
1386 | string = match_strdup(args); | 1301 | string = match_strdup(args); |
@@ -1432,8 +1347,11 @@ static int nfs_parse_mount_options(char *raw, | |||
1432 | 1347 | ||
1433 | return 1; | 1348 | return 1; |
1434 | 1349 | ||
1350 | out_invalid_address: | ||
1351 | printk(KERN_INFO "NFS: bad IP address specified: %s\n", p); | ||
1352 | return 0; | ||
1435 | out_invalid_value: | 1353 | out_invalid_value: |
1436 | printk(KERN_INFO "NFS: bad mount option value specified: %s \n", p); | 1354 | printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p); |
1437 | return 0; | 1355 | return 0; |
1438 | out_nomem: | 1356 | out_nomem: |
1439 | printk(KERN_INFO "NFS: not enough memory to parse option\n"); | 1357 | printk(KERN_INFO "NFS: not enough memory to parse option\n"); |
@@ -1445,13 +1363,60 @@ out_security_failure: | |||
1445 | } | 1363 | } |
1446 | 1364 | ||
1447 | /* | 1365 | /* |
1366 | * Match the requested auth flavors with the list returned by | ||
1367 | * the server. Returns zero and sets the mount's authentication | ||
1368 | * flavor on success; returns -EACCES if server does not support | ||
1369 | * the requested flavor. | ||
1370 | */ | ||
1371 | static int nfs_walk_authlist(struct nfs_parsed_mount_data *args, | ||
1372 | struct nfs_mount_request *request) | ||
1373 | { | ||
1374 | unsigned int i, j, server_authlist_len = *(request->auth_flav_len); | ||
1375 | |||
1376 | /* | ||
1377 | * Certain releases of Linux's mountd return an empty | ||
1378 | * flavor list. To prevent behavioral regression with | ||
1379 | * these servers (ie. rejecting mounts that used to | ||
1380 | * succeed), revert to pre-2.6.32 behavior (no checking) | ||
1381 | * if the returned flavor list is empty. | ||
1382 | */ | ||
1383 | if (server_authlist_len == 0) | ||
1384 | return 0; | ||
1385 | |||
1386 | /* | ||
1387 | * We avoid sophisticated negotiating here, as there are | ||
1388 | * plenty of cases where we can get it wrong, providing | ||
1389 | * either too little or too much security. | ||
1390 | * | ||
1391 | * RFC 2623, section 2.7 suggests we SHOULD prefer the | ||
1392 | * flavor listed first. However, some servers list | ||
1393 | * AUTH_NULL first. Our caller plants AUTH_SYS, the | ||
1394 | * preferred default, in args->auth_flavors[0] if user | ||
1395 | * didn't specify sec= mount option. | ||
1396 | */ | ||
1397 | for (i = 0; i < args->auth_flavor_len; i++) | ||
1398 | for (j = 0; j < server_authlist_len; j++) | ||
1399 | if (args->auth_flavors[i] == request->auth_flavs[j]) { | ||
1400 | dfprintk(MOUNT, "NFS: using auth flavor %d\n", | ||
1401 | request->auth_flavs[j]); | ||
1402 | args->auth_flavors[0] = request->auth_flavs[j]; | ||
1403 | return 0; | ||
1404 | } | ||
1405 | |||
1406 | dfprintk(MOUNT, "NFS: server does not support requested auth flavor\n"); | ||
1407 | nfs_umount(request); | ||
1408 | return -EACCES; | ||
1409 | } | ||
1410 | |||
1411 | /* | ||
1448 | * Use the remote server's MOUNT service to request the NFS file handle | 1412 | * Use the remote server's MOUNT service to request the NFS file handle |
1449 | * corresponding to the provided path. | 1413 | * corresponding to the provided path. |
1450 | */ | 1414 | */ |
1451 | static int nfs_try_mount(struct nfs_parsed_mount_data *args, | 1415 | static int nfs_try_mount(struct nfs_parsed_mount_data *args, |
1452 | struct nfs_fh *root_fh) | 1416 | struct nfs_fh *root_fh) |
1453 | { | 1417 | { |
1454 | unsigned int auth_flavor_len = 0; | 1418 | rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS]; |
1419 | unsigned int server_authlist_len = ARRAY_SIZE(server_authlist); | ||
1455 | struct nfs_mount_request request = { | 1420 | struct nfs_mount_request request = { |
1456 | .sap = (struct sockaddr *) | 1421 | .sap = (struct sockaddr *) |
1457 | &args->mount_server.address, | 1422 | &args->mount_server.address, |
@@ -1459,7 +1424,8 @@ static int nfs_try_mount(struct nfs_parsed_mount_data *args, | |||
1459 | .protocol = args->mount_server.protocol, | 1424 | .protocol = args->mount_server.protocol, |
1460 | .fh = root_fh, | 1425 | .fh = root_fh, |
1461 | .noresvport = args->flags & NFS_MOUNT_NORESVPORT, | 1426 | .noresvport = args->flags & NFS_MOUNT_NORESVPORT, |
1462 | .auth_flav_len = &auth_flavor_len, | 1427 | .auth_flav_len = &server_authlist_len, |
1428 | .auth_flavs = server_authlist, | ||
1463 | }; | 1429 | }; |
1464 | int status; | 1430 | int status; |
1465 | 1431 | ||
@@ -1485,23 +1451,25 @@ static int nfs_try_mount(struct nfs_parsed_mount_data *args, | |||
1485 | args->mount_server.addrlen = args->nfs_server.addrlen; | 1451 | args->mount_server.addrlen = args->nfs_server.addrlen; |
1486 | } | 1452 | } |
1487 | request.salen = args->mount_server.addrlen; | 1453 | request.salen = args->mount_server.addrlen; |
1488 | 1454 | nfs_set_default_port(request.sap, args->mount_server.port, 0); | |
1489 | /* | ||
1490 | * autobind will be used if mount_server.port == 0 | ||
1491 | */ | ||
1492 | nfs_set_port(request.sap, args->mount_server.port); | ||
1493 | 1455 | ||
1494 | /* | 1456 | /* |
1495 | * Now ask the mount server to map our export path | 1457 | * Now ask the mount server to map our export path |
1496 | * to a file handle. | 1458 | * to a file handle. |
1497 | */ | 1459 | */ |
1498 | status = nfs_mount(&request); | 1460 | status = nfs_mount(&request); |
1499 | if (status == 0) | 1461 | if (status != 0) { |
1500 | return 0; | 1462 | dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n", |
1463 | request.hostname, status); | ||
1464 | return status; | ||
1465 | } | ||
1501 | 1466 | ||
1502 | dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n", | 1467 | /* |
1503 | request.hostname, status); | 1468 | * MNTv1 (NFSv2) does not support auth flavor negotiation. |
1504 | return status; | 1469 | */ |
1470 | if (args->mount_server.version != NFS_MNT3_VERSION) | ||
1471 | return 0; | ||
1472 | return nfs_walk_authlist(args, &request); | ||
1505 | } | 1473 | } |
1506 | 1474 | ||
1507 | static int nfs_parse_simple_hostname(const char *dev_name, | 1475 | static int nfs_parse_simple_hostname(const char *dev_name, |
@@ -1661,6 +1629,7 @@ static int nfs_validate_mount_data(void *options, | |||
1661 | const char *dev_name) | 1629 | const char *dev_name) |
1662 | { | 1630 | { |
1663 | struct nfs_mount_data *data = (struct nfs_mount_data *)options; | 1631 | struct nfs_mount_data *data = (struct nfs_mount_data *)options; |
1632 | struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; | ||
1664 | 1633 | ||
1665 | if (data == NULL) | 1634 | if (data == NULL) |
1666 | goto out_no_data; | 1635 | goto out_no_data; |
@@ -1672,10 +1641,12 @@ static int nfs_validate_mount_data(void *options, | |||
1672 | args->acregmax = NFS_DEF_ACREGMAX; | 1641 | args->acregmax = NFS_DEF_ACREGMAX; |
1673 | args->acdirmin = NFS_DEF_ACDIRMIN; | 1642 | args->acdirmin = NFS_DEF_ACDIRMIN; |
1674 | args->acdirmax = NFS_DEF_ACDIRMAX; | 1643 | args->acdirmax = NFS_DEF_ACDIRMAX; |
1675 | args->mount_server.port = 0; /* autobind unless user sets port */ | 1644 | args->mount_server.port = NFS_UNSPEC_PORT; |
1676 | args->nfs_server.port = 0; /* autobind unless user sets port */ | 1645 | args->nfs_server.port = NFS_UNSPEC_PORT; |
1677 | args->nfs_server.protocol = XPRT_TRANSPORT_TCP; | 1646 | args->nfs_server.protocol = XPRT_TRANSPORT_TCP; |
1678 | args->auth_flavors[0] = RPC_AUTH_UNIX; | 1647 | args->auth_flavors[0] = RPC_AUTH_UNIX; |
1648 | args->auth_flavor_len = 1; | ||
1649 | args->minorversion = 0; | ||
1679 | 1650 | ||
1680 | switch (data->version) { | 1651 | switch (data->version) { |
1681 | case 1: | 1652 | case 1: |
@@ -1697,8 +1668,11 @@ static int nfs_validate_mount_data(void *options, | |||
1697 | if (data->root.size > NFS3_FHSIZE || data->root.size == 0) | 1668 | if (data->root.size > NFS3_FHSIZE || data->root.size == 0) |
1698 | goto out_invalid_fh; | 1669 | goto out_invalid_fh; |
1699 | mntfh->size = data->root.size; | 1670 | mntfh->size = data->root.size; |
1700 | } else | 1671 | args->version = 3; |
1672 | } else { | ||
1701 | mntfh->size = NFS2_FHSIZE; | 1673 | mntfh->size = NFS2_FHSIZE; |
1674 | args->version = 2; | ||
1675 | } | ||
1702 | 1676 | ||
1703 | 1677 | ||
1704 | memcpy(mntfh->data, data->root.data, mntfh->size); | 1678 | memcpy(mntfh->data, data->root.data, mntfh->size); |
@@ -1720,11 +1694,9 @@ static int nfs_validate_mount_data(void *options, | |||
1720 | args->acdirmin = data->acdirmin; | 1694 | args->acdirmin = data->acdirmin; |
1721 | args->acdirmax = data->acdirmax; | 1695 | args->acdirmax = data->acdirmax; |
1722 | 1696 | ||
1723 | memcpy(&args->nfs_server.address, &data->addr, | 1697 | memcpy(sap, &data->addr, sizeof(data->addr)); |
1724 | sizeof(data->addr)); | ||
1725 | args->nfs_server.addrlen = sizeof(data->addr); | 1698 | args->nfs_server.addrlen = sizeof(data->addr); |
1726 | if (!nfs_verify_server_address((struct sockaddr *) | 1699 | if (!nfs_verify_server_address(sap)) |
1727 | &args->nfs_server.address)) | ||
1728 | goto out_no_address; | 1700 | goto out_no_address; |
1729 | 1701 | ||
1730 | if (!(data->flags & NFS_MOUNT_TCP)) | 1702 | if (!(data->flags & NFS_MOUNT_TCP)) |
@@ -1772,12 +1744,18 @@ static int nfs_validate_mount_data(void *options, | |||
1772 | if (nfs_parse_mount_options((char *)options, args) == 0) | 1744 | if (nfs_parse_mount_options((char *)options, args) == 0) |
1773 | return -EINVAL; | 1745 | return -EINVAL; |
1774 | 1746 | ||
1775 | if (!nfs_verify_server_address((struct sockaddr *) | 1747 | if (!nfs_verify_server_address(sap)) |
1776 | &args->nfs_server.address)) | ||
1777 | goto out_no_address; | 1748 | goto out_no_address; |
1778 | 1749 | ||
1779 | nfs_set_port((struct sockaddr *)&args->nfs_server.address, | 1750 | if (args->version == 4) |
1780 | args->nfs_server.port); | 1751 | #ifdef CONFIG_NFS_V4 |
1752 | return nfs4_validate_text_mount_data(options, | ||
1753 | args, dev_name); | ||
1754 | #else | ||
1755 | goto out_v4_not_compiled; | ||
1756 | #endif | ||
1757 | |||
1758 | nfs_set_default_port(sap, args->nfs_server.port, 0); | ||
1781 | 1759 | ||
1782 | nfs_set_mount_transport_protocol(args); | 1760 | nfs_set_mount_transport_protocol(args); |
1783 | 1761 | ||
@@ -1825,6 +1803,12 @@ out_v3_not_compiled: | |||
1825 | return -EPROTONOSUPPORT; | 1803 | return -EPROTONOSUPPORT; |
1826 | #endif /* !CONFIG_NFS_V3 */ | 1804 | #endif /* !CONFIG_NFS_V3 */ |
1827 | 1805 | ||
1806 | #ifndef CONFIG_NFS_V4 | ||
1807 | out_v4_not_compiled: | ||
1808 | dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n"); | ||
1809 | return -EPROTONOSUPPORT; | ||
1810 | #endif /* !CONFIG_NFS_V4 */ | ||
1811 | |||
1828 | out_nomem: | 1812 | out_nomem: |
1829 | dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n"); | 1813 | dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n"); |
1830 | return -ENOMEM; | 1814 | return -ENOMEM; |
@@ -2120,6 +2104,14 @@ static int nfs_get_sb(struct file_system_type *fs_type, | |||
2120 | if (error < 0) | 2104 | if (error < 0) |
2121 | goto out; | 2105 | goto out; |
2122 | 2106 | ||
2107 | #ifdef CONFIG_NFS_V4 | ||
2108 | if (data->version == 4) { | ||
2109 | error = nfs4_try_mount(flags, dev_name, data, mnt); | ||
2110 | kfree(data->client_address); | ||
2111 | goto out; | ||
2112 | } | ||
2113 | #endif /* CONFIG_NFS_V4 */ | ||
2114 | |||
2123 | /* Get a volume representation */ | 2115 | /* Get a volume representation */ |
2124 | server = nfs_create_server(data, mntfh); | 2116 | server = nfs_create_server(data, mntfh); |
2125 | if (IS_ERR(server)) { | 2117 | if (IS_ERR(server)) { |
@@ -2317,6 +2309,43 @@ static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args) | |||
2317 | args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3); | 2309 | args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3); |
2318 | } | 2310 | } |
2319 | 2311 | ||
2312 | static int nfs4_validate_text_mount_data(void *options, | ||
2313 | struct nfs_parsed_mount_data *args, | ||
2314 | const char *dev_name) | ||
2315 | { | ||
2316 | struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; | ||
2317 | |||
2318 | nfs_set_default_port(sap, args->nfs_server.port, NFS_PORT); | ||
2319 | |||
2320 | nfs_validate_transport_protocol(args); | ||
2321 | |||
2322 | nfs4_validate_mount_flags(args); | ||
2323 | |||
2324 | if (args->version != 4) { | ||
2325 | dfprintk(MOUNT, | ||
2326 | "NFS4: Illegal mount version\n"); | ||
2327 | return -EINVAL; | ||
2328 | } | ||
2329 | |||
2330 | if (args->auth_flavor_len > 1) { | ||
2331 | dfprintk(MOUNT, | ||
2332 | "NFS4: Too many RPC auth flavours specified\n"); | ||
2333 | return -EINVAL; | ||
2334 | } | ||
2335 | |||
2336 | if (args->client_address == NULL) { | ||
2337 | dfprintk(MOUNT, | ||
2338 | "NFS4: mount program didn't pass callback address\n"); | ||
2339 | return -EINVAL; | ||
2340 | } | ||
2341 | |||
2342 | return nfs_parse_devname(dev_name, | ||
2343 | &args->nfs_server.hostname, | ||
2344 | NFS4_MAXNAMLEN, | ||
2345 | &args->nfs_server.export_path, | ||
2346 | NFS4_MAXPATHLEN); | ||
2347 | } | ||
2348 | |||
2320 | /* | 2349 | /* |
2321 | * Validate NFSv4 mount options | 2350 | * Validate NFSv4 mount options |
2322 | */ | 2351 | */ |
@@ -2324,7 +2353,7 @@ static int nfs4_validate_mount_data(void *options, | |||
2324 | struct nfs_parsed_mount_data *args, | 2353 | struct nfs_parsed_mount_data *args, |
2325 | const char *dev_name) | 2354 | const char *dev_name) |
2326 | { | 2355 | { |
2327 | struct sockaddr_in *ap; | 2356 | struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address; |
2328 | struct nfs4_mount_data *data = (struct nfs4_mount_data *)options; | 2357 | struct nfs4_mount_data *data = (struct nfs4_mount_data *)options; |
2329 | char *c; | 2358 | char *c; |
2330 | 2359 | ||
@@ -2337,23 +2366,22 @@ static int nfs4_validate_mount_data(void *options, | |||
2337 | args->acregmax = NFS_DEF_ACREGMAX; | 2366 | args->acregmax = NFS_DEF_ACREGMAX; |
2338 | args->acdirmin = NFS_DEF_ACDIRMIN; | 2367 | args->acdirmin = NFS_DEF_ACDIRMIN; |
2339 | args->acdirmax = NFS_DEF_ACDIRMAX; | 2368 | args->acdirmax = NFS_DEF_ACDIRMAX; |
2340 | args->nfs_server.port = NFS_PORT; /* 2049 unless user set port= */ | 2369 | args->nfs_server.port = NFS_UNSPEC_PORT; |
2341 | args->auth_flavors[0] = RPC_AUTH_UNIX; | 2370 | args->auth_flavors[0] = RPC_AUTH_UNIX; |
2342 | args->auth_flavor_len = 0; | 2371 | args->auth_flavor_len = 1; |
2372 | args->version = 4; | ||
2343 | args->minorversion = 0; | 2373 | args->minorversion = 0; |
2344 | 2374 | ||
2345 | switch (data->version) { | 2375 | switch (data->version) { |
2346 | case 1: | 2376 | case 1: |
2347 | ap = (struct sockaddr_in *)&args->nfs_server.address; | ||
2348 | if (data->host_addrlen > sizeof(args->nfs_server.address)) | 2377 | if (data->host_addrlen > sizeof(args->nfs_server.address)) |
2349 | goto out_no_address; | 2378 | goto out_no_address; |
2350 | if (data->host_addrlen == 0) | 2379 | if (data->host_addrlen == 0) |
2351 | goto out_no_address; | 2380 | goto out_no_address; |
2352 | args->nfs_server.addrlen = data->host_addrlen; | 2381 | args->nfs_server.addrlen = data->host_addrlen; |
2353 | if (copy_from_user(ap, data->host_addr, data->host_addrlen)) | 2382 | if (copy_from_user(sap, data->host_addr, data->host_addrlen)) |
2354 | return -EFAULT; | 2383 | return -EFAULT; |
2355 | if (!nfs_verify_server_address((struct sockaddr *) | 2384 | if (!nfs_verify_server_address(sap)) |
2356 | &args->nfs_server.address)) | ||
2357 | goto out_no_address; | 2385 | goto out_no_address; |
2358 | 2386 | ||
2359 | if (data->auth_flavourlen) { | 2387 | if (data->auth_flavourlen) { |
@@ -2399,39 +2427,14 @@ static int nfs4_validate_mount_data(void *options, | |||
2399 | nfs_validate_transport_protocol(args); | 2427 | nfs_validate_transport_protocol(args); |
2400 | 2428 | ||
2401 | break; | 2429 | break; |
2402 | default: { | 2430 | default: |
2403 | int status; | ||
2404 | |||
2405 | if (nfs_parse_mount_options((char *)options, args) == 0) | 2431 | if (nfs_parse_mount_options((char *)options, args) == 0) |
2406 | return -EINVAL; | 2432 | return -EINVAL; |
2407 | 2433 | ||
2408 | if (!nfs_verify_server_address((struct sockaddr *) | 2434 | if (!nfs_verify_server_address(sap)) |
2409 | &args->nfs_server.address)) | ||
2410 | return -EINVAL; | 2435 | return -EINVAL; |
2411 | 2436 | ||
2412 | nfs_set_port((struct sockaddr *)&args->nfs_server.address, | 2437 | return nfs4_validate_text_mount_data(options, args, dev_name); |
2413 | args->nfs_server.port); | ||
2414 | |||
2415 | nfs_validate_transport_protocol(args); | ||
2416 | |||
2417 | nfs4_validate_mount_flags(args); | ||
2418 | |||
2419 | if (args->auth_flavor_len > 1) | ||
2420 | goto out_inval_auth; | ||
2421 | |||
2422 | if (args->client_address == NULL) | ||
2423 | goto out_no_client_address; | ||
2424 | |||
2425 | status = nfs_parse_devname(dev_name, | ||
2426 | &args->nfs_server.hostname, | ||
2427 | NFS4_MAXNAMLEN, | ||
2428 | &args->nfs_server.export_path, | ||
2429 | NFS4_MAXPATHLEN); | ||
2430 | if (status < 0) | ||
2431 | return status; | ||
2432 | |||
2433 | break; | ||
2434 | } | ||
2435 | } | 2438 | } |
2436 | 2439 | ||
2437 | return 0; | 2440 | return 0; |
@@ -2448,10 +2451,6 @@ out_inval_auth: | |||
2448 | out_no_address: | 2451 | out_no_address: |
2449 | dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n"); | 2452 | dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n"); |
2450 | return -EINVAL; | 2453 | return -EINVAL; |
2451 | |||
2452 | out_no_client_address: | ||
2453 | dfprintk(MOUNT, "NFS4: mount program didn't pass callback address\n"); | ||
2454 | return -EINVAL; | ||
2455 | } | 2454 | } |
2456 | 2455 | ||
2457 | /* | 2456 | /* |
@@ -2618,6 +2617,34 @@ out_err: | |||
2618 | return ret; | 2617 | return ret; |
2619 | } | 2618 | } |
2620 | 2619 | ||
2620 | static int nfs4_try_mount(int flags, const char *dev_name, | ||
2621 | struct nfs_parsed_mount_data *data, | ||
2622 | struct vfsmount *mnt) | ||
2623 | { | ||
2624 | char *export_path; | ||
2625 | struct vfsmount *root_mnt; | ||
2626 | int error; | ||
2627 | |||
2628 | dfprintk(MOUNT, "--> nfs4_try_mount()\n"); | ||
2629 | |||
2630 | export_path = data->nfs_server.export_path; | ||
2631 | data->nfs_server.export_path = "/"; | ||
2632 | root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, data, | ||
2633 | data->nfs_server.hostname); | ||
2634 | data->nfs_server.export_path = export_path; | ||
2635 | |||
2636 | error = PTR_ERR(root_mnt); | ||
2637 | if (IS_ERR(root_mnt)) | ||
2638 | goto out; | ||
2639 | |||
2640 | error = nfs_follow_remote_path(root_mnt, export_path, mnt); | ||
2641 | |||
2642 | out: | ||
2643 | dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n", error, | ||
2644 | error != 0 ? " [error]" : ""); | ||
2645 | return error; | ||
2646 | } | ||
2647 | |||
2621 | /* | 2648 | /* |
2622 | * Get the superblock for an NFS4 mountpoint | 2649 | * Get the superblock for an NFS4 mountpoint |
2623 | */ | 2650 | */ |
@@ -2625,8 +2652,6 @@ static int nfs4_get_sb(struct file_system_type *fs_type, | |||
2625 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt) | 2652 | int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt) |
2626 | { | 2653 | { |
2627 | struct nfs_parsed_mount_data *data; | 2654 | struct nfs_parsed_mount_data *data; |
2628 | char *export_path; | ||
2629 | struct vfsmount *root_mnt; | ||
2630 | int error = -ENOMEM; | 2655 | int error = -ENOMEM; |
2631 | 2656 | ||
2632 | data = kzalloc(sizeof(*data), GFP_KERNEL); | 2657 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
@@ -2638,17 +2663,7 @@ static int nfs4_get_sb(struct file_system_type *fs_type, | |||
2638 | if (error < 0) | 2663 | if (error < 0) |
2639 | goto out; | 2664 | goto out; |
2640 | 2665 | ||
2641 | export_path = data->nfs_server.export_path; | 2666 | error = nfs4_try_mount(flags, dev_name, data, mnt); |
2642 | data->nfs_server.export_path = "/"; | ||
2643 | root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, data, | ||
2644 | data->nfs_server.hostname); | ||
2645 | data->nfs_server.export_path = export_path; | ||
2646 | |||
2647 | error = PTR_ERR(root_mnt); | ||
2648 | if (IS_ERR(root_mnt)) | ||
2649 | goto out; | ||
2650 | |||
2651 | error = nfs_follow_remote_path(root_mnt, export_path, mnt); | ||
2652 | 2667 | ||
2653 | out: | 2668 | out: |
2654 | kfree(data->client_address); | 2669 | kfree(data->client_address); |
diff --git a/fs/nfs/write.c b/fs/nfs/write.c index a34fae21fe10..120acadc6a84 100644 --- a/fs/nfs/write.c +++ b/fs/nfs/write.c | |||
@@ -13,6 +13,7 @@ | |||
13 | #include <linux/file.h> | 13 | #include <linux/file.h> |
14 | #include <linux/writeback.h> | 14 | #include <linux/writeback.h> |
15 | #include <linux/swap.h> | 15 | #include <linux/swap.h> |
16 | #include <linux/migrate.h> | ||
16 | 17 | ||
17 | #include <linux/sunrpc/clnt.h> | 18 | #include <linux/sunrpc/clnt.h> |
18 | #include <linux/nfs_fs.h> | 19 | #include <linux/nfs_fs.h> |
@@ -26,6 +27,7 @@ | |||
26 | #include "internal.h" | 27 | #include "internal.h" |
27 | #include "iostat.h" | 28 | #include "iostat.h" |
28 | #include "nfs4_fs.h" | 29 | #include "nfs4_fs.h" |
30 | #include "fscache.h" | ||
29 | 31 | ||
30 | #define NFSDBG_FACILITY NFSDBG_PAGECACHE | 32 | #define NFSDBG_FACILITY NFSDBG_PAGECACHE |
31 | 33 | ||
@@ -218,24 +220,17 @@ static void nfs_end_page_writeback(struct page *page) | |||
218 | clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC); | 220 | clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC); |
219 | } | 221 | } |
220 | 222 | ||
221 | /* | 223 | static struct nfs_page *nfs_find_and_lock_request(struct page *page) |
222 | * Find an associated nfs write request, and prepare to flush it out | ||
223 | * May return an error if the user signalled nfs_wait_on_request(). | ||
224 | */ | ||
225 | static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio, | ||
226 | struct page *page) | ||
227 | { | 224 | { |
228 | struct inode *inode = page->mapping->host; | 225 | struct inode *inode = page->mapping->host; |
229 | struct nfs_page *req; | 226 | struct nfs_page *req; |
230 | int ret; | 227 | int ret; |
231 | 228 | ||
232 | spin_lock(&inode->i_lock); | 229 | spin_lock(&inode->i_lock); |
233 | for(;;) { | 230 | for (;;) { |
234 | req = nfs_page_find_request_locked(page); | 231 | req = nfs_page_find_request_locked(page); |
235 | if (req == NULL) { | 232 | if (req == NULL) |
236 | spin_unlock(&inode->i_lock); | 233 | break; |
237 | return 0; | ||
238 | } | ||
239 | if (nfs_set_page_tag_locked(req)) | 234 | if (nfs_set_page_tag_locked(req)) |
240 | break; | 235 | break; |
241 | /* Note: If we hold the page lock, as is the case in nfs_writepage, | 236 | /* Note: If we hold the page lock, as is the case in nfs_writepage, |
@@ -247,23 +242,40 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio, | |||
247 | ret = nfs_wait_on_request(req); | 242 | ret = nfs_wait_on_request(req); |
248 | nfs_release_request(req); | 243 | nfs_release_request(req); |
249 | if (ret != 0) | 244 | if (ret != 0) |
250 | return ret; | 245 | return ERR_PTR(ret); |
251 | spin_lock(&inode->i_lock); | 246 | spin_lock(&inode->i_lock); |
252 | } | 247 | } |
253 | if (test_bit(PG_CLEAN, &req->wb_flags)) { | ||
254 | spin_unlock(&inode->i_lock); | ||
255 | BUG(); | ||
256 | } | ||
257 | if (nfs_set_page_writeback(page) != 0) { | ||
258 | spin_unlock(&inode->i_lock); | ||
259 | BUG(); | ||
260 | } | ||
261 | spin_unlock(&inode->i_lock); | 248 | spin_unlock(&inode->i_lock); |
249 | return req; | ||
250 | } | ||
251 | |||
252 | /* | ||
253 | * Find an associated nfs write request, and prepare to flush it out | ||
254 | * May return an error if the user signalled nfs_wait_on_request(). | ||
255 | */ | ||
256 | static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio, | ||
257 | struct page *page) | ||
258 | { | ||
259 | struct nfs_page *req; | ||
260 | int ret = 0; | ||
261 | |||
262 | req = nfs_find_and_lock_request(page); | ||
263 | if (!req) | ||
264 | goto out; | ||
265 | ret = PTR_ERR(req); | ||
266 | if (IS_ERR(req)) | ||
267 | goto out; | ||
268 | |||
269 | ret = nfs_set_page_writeback(page); | ||
270 | BUG_ON(ret != 0); | ||
271 | BUG_ON(test_bit(PG_CLEAN, &req->wb_flags)); | ||
272 | |||
262 | if (!nfs_pageio_add_request(pgio, req)) { | 273 | if (!nfs_pageio_add_request(pgio, req)) { |
263 | nfs_redirty_request(req); | 274 | nfs_redirty_request(req); |
264 | return pgio->pg_error; | 275 | ret = pgio->pg_error; |
265 | } | 276 | } |
266 | return 0; | 277 | out: |
278 | return ret; | ||
267 | } | 279 | } |
268 | 280 | ||
269 | static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio) | 281 | static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, struct nfs_pageio_descriptor *pgio) |
@@ -1580,6 +1592,41 @@ int nfs_wb_page(struct inode *inode, struct page* page) | |||
1580 | return nfs_wb_page_priority(inode, page, FLUSH_STABLE); | 1592 | return nfs_wb_page_priority(inode, page, FLUSH_STABLE); |
1581 | } | 1593 | } |
1582 | 1594 | ||
1595 | #ifdef CONFIG_MIGRATION | ||
1596 | int nfs_migrate_page(struct address_space *mapping, struct page *newpage, | ||
1597 | struct page *page) | ||
1598 | { | ||
1599 | struct nfs_page *req; | ||
1600 | int ret; | ||
1601 | |||
1602 | if (PageFsCache(page)) | ||
1603 | nfs_fscache_release_page(page, GFP_KERNEL); | ||
1604 | |||
1605 | req = nfs_find_and_lock_request(page); | ||
1606 | ret = PTR_ERR(req); | ||
1607 | if (IS_ERR(req)) | ||
1608 | goto out; | ||
1609 | |||
1610 | ret = migrate_page(mapping, newpage, page); | ||
1611 | if (!req) | ||
1612 | goto out; | ||
1613 | if (ret) | ||
1614 | goto out_unlock; | ||
1615 | page_cache_get(newpage); | ||
1616 | req->wb_page = newpage; | ||
1617 | SetPagePrivate(newpage); | ||
1618 | set_page_private(newpage, page_private(page)); | ||
1619 | ClearPagePrivate(page); | ||
1620 | set_page_private(page, 0); | ||
1621 | page_cache_release(page); | ||
1622 | out_unlock: | ||
1623 | nfs_clear_page_tag_locked(req); | ||
1624 | nfs_release_request(req); | ||
1625 | out: | ||
1626 | return ret; | ||
1627 | } | ||
1628 | #endif | ||
1629 | |||
1583 | int __init nfs_init_writepagecache(void) | 1630 | int __init nfs_init_writepagecache(void) |
1584 | { | 1631 | { |
1585 | nfs_wdata_cachep = kmem_cache_create("nfs_write_data", | 1632 | nfs_wdata_cachep = kmem_cache_create("nfs_write_data", |
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c index b92a27629fb7..d9462643155c 100644 --- a/fs/nfsd/export.c +++ b/fs/nfsd/export.c | |||
@@ -85,6 +85,11 @@ static void expkey_request(struct cache_detail *cd, | |||
85 | (*bpp)[-1] = '\n'; | 85 | (*bpp)[-1] = '\n'; |
86 | } | 86 | } |
87 | 87 | ||
88 | static int expkey_upcall(struct cache_detail *cd, struct cache_head *h) | ||
89 | { | ||
90 | return sunrpc_cache_pipe_upcall(cd, h, expkey_request); | ||
91 | } | ||
92 | |||
88 | static struct svc_expkey *svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old); | 93 | static struct svc_expkey *svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old); |
89 | static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *); | 94 | static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *); |
90 | static struct cache_detail svc_expkey_cache; | 95 | static struct cache_detail svc_expkey_cache; |
@@ -259,7 +264,7 @@ static struct cache_detail svc_expkey_cache = { | |||
259 | .hash_table = expkey_table, | 264 | .hash_table = expkey_table, |
260 | .name = "nfsd.fh", | 265 | .name = "nfsd.fh", |
261 | .cache_put = expkey_put, | 266 | .cache_put = expkey_put, |
262 | .cache_request = expkey_request, | 267 | .cache_upcall = expkey_upcall, |
263 | .cache_parse = expkey_parse, | 268 | .cache_parse = expkey_parse, |
264 | .cache_show = expkey_show, | 269 | .cache_show = expkey_show, |
265 | .match = expkey_match, | 270 | .match = expkey_match, |
@@ -355,6 +360,11 @@ static void svc_export_request(struct cache_detail *cd, | |||
355 | (*bpp)[-1] = '\n'; | 360 | (*bpp)[-1] = '\n'; |
356 | } | 361 | } |
357 | 362 | ||
363 | static int svc_export_upcall(struct cache_detail *cd, struct cache_head *h) | ||
364 | { | ||
365 | return sunrpc_cache_pipe_upcall(cd, h, svc_export_request); | ||
366 | } | ||
367 | |||
358 | static struct svc_export *svc_export_update(struct svc_export *new, | 368 | static struct svc_export *svc_export_update(struct svc_export *new, |
359 | struct svc_export *old); | 369 | struct svc_export *old); |
360 | static struct svc_export *svc_export_lookup(struct svc_export *); | 370 | static struct svc_export *svc_export_lookup(struct svc_export *); |
@@ -724,7 +734,7 @@ struct cache_detail svc_export_cache = { | |||
724 | .hash_table = export_table, | 734 | .hash_table = export_table, |
725 | .name = "nfsd.export", | 735 | .name = "nfsd.export", |
726 | .cache_put = svc_export_put, | 736 | .cache_put = svc_export_put, |
727 | .cache_request = svc_export_request, | 737 | .cache_upcall = svc_export_upcall, |
728 | .cache_parse = svc_export_parse, | 738 | .cache_parse = svc_export_parse, |
729 | .cache_show = svc_export_show, | 739 | .cache_show = svc_export_show, |
730 | .match = svc_export_match, | 740 | .match = svc_export_match, |
diff --git a/fs/nfsd/nfs4idmap.c b/fs/nfsd/nfs4idmap.c index 5b398421b051..cdfa86fa1471 100644 --- a/fs/nfsd/nfs4idmap.c +++ b/fs/nfsd/nfs4idmap.c | |||
@@ -146,6 +146,12 @@ idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp, | |||
146 | } | 146 | } |
147 | 147 | ||
148 | static int | 148 | static int |
149 | idtoname_upcall(struct cache_detail *cd, struct cache_head *ch) | ||
150 | { | ||
151 | return sunrpc_cache_pipe_upcall(cd, ch, idtoname_request); | ||
152 | } | ||
153 | |||
154 | static int | ||
149 | idtoname_match(struct cache_head *ca, struct cache_head *cb) | 155 | idtoname_match(struct cache_head *ca, struct cache_head *cb) |
150 | { | 156 | { |
151 | struct ent *a = container_of(ca, struct ent, h); | 157 | struct ent *a = container_of(ca, struct ent, h); |
@@ -175,10 +181,10 @@ idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h) | |||
175 | } | 181 | } |
176 | 182 | ||
177 | static void | 183 | static void |
178 | warn_no_idmapd(struct cache_detail *detail) | 184 | warn_no_idmapd(struct cache_detail *detail, int has_died) |
179 | { | 185 | { |
180 | printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n", | 186 | printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n", |
181 | detail->last_close? "died" : "not been started"); | 187 | has_died ? "died" : "not been started"); |
182 | } | 188 | } |
183 | 189 | ||
184 | 190 | ||
@@ -192,7 +198,7 @@ static struct cache_detail idtoname_cache = { | |||
192 | .hash_table = idtoname_table, | 198 | .hash_table = idtoname_table, |
193 | .name = "nfs4.idtoname", | 199 | .name = "nfs4.idtoname", |
194 | .cache_put = ent_put, | 200 | .cache_put = ent_put, |
195 | .cache_request = idtoname_request, | 201 | .cache_upcall = idtoname_upcall, |
196 | .cache_parse = idtoname_parse, | 202 | .cache_parse = idtoname_parse, |
197 | .cache_show = idtoname_show, | 203 | .cache_show = idtoname_show, |
198 | .warn_no_listener = warn_no_idmapd, | 204 | .warn_no_listener = warn_no_idmapd, |
@@ -325,6 +331,12 @@ nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp, | |||
325 | } | 331 | } |
326 | 332 | ||
327 | static int | 333 | static int |
334 | nametoid_upcall(struct cache_detail *cd, struct cache_head *ch) | ||
335 | { | ||
336 | return sunrpc_cache_pipe_upcall(cd, ch, nametoid_request); | ||
337 | } | ||
338 | |||
339 | static int | ||
328 | nametoid_match(struct cache_head *ca, struct cache_head *cb) | 340 | nametoid_match(struct cache_head *ca, struct cache_head *cb) |
329 | { | 341 | { |
330 | struct ent *a = container_of(ca, struct ent, h); | 342 | struct ent *a = container_of(ca, struct ent, h); |
@@ -363,7 +375,7 @@ static struct cache_detail nametoid_cache = { | |||
363 | .hash_table = nametoid_table, | 375 | .hash_table = nametoid_table, |
364 | .name = "nfs4.nametoid", | 376 | .name = "nfs4.nametoid", |
365 | .cache_put = ent_put, | 377 | .cache_put = ent_put, |
366 | .cache_request = nametoid_request, | 378 | .cache_upcall = nametoid_upcall, |
367 | .cache_parse = nametoid_parse, | 379 | .cache_parse = nametoid_parse, |
368 | .cache_show = nametoid_show, | 380 | .cache_show = nametoid_show, |
369 | .warn_no_listener = warn_no_idmapd, | 381 | .warn_no_listener = warn_no_idmapd, |
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 6d0847562d87..7e906c5b7671 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c | |||
@@ -37,6 +37,7 @@ | |||
37 | #include <linux/nfsd/xdr.h> | 37 | #include <linux/nfsd/xdr.h> |
38 | #include <linux/nfsd/syscall.h> | 38 | #include <linux/nfsd/syscall.h> |
39 | #include <linux/lockd/lockd.h> | 39 | #include <linux/lockd/lockd.h> |
40 | #include <linux/sunrpc/clnt.h> | ||
40 | 41 | ||
41 | #include <asm/uaccess.h> | 42 | #include <asm/uaccess.h> |
42 | #include <net/ipv6.h> | 43 | #include <net/ipv6.h> |
@@ -490,22 +491,18 @@ static ssize_t write_getfd(struct file *file, char *buf, size_t size) | |||
490 | * | 491 | * |
491 | * Input: | 492 | * Input: |
492 | * buf: '\n'-terminated C string containing a | 493 | * buf: '\n'-terminated C string containing a |
493 | * presentation format IPv4 address | 494 | * presentation format IP address |
494 | * size: length of C string in @buf | 495 | * size: length of C string in @buf |
495 | * Output: | 496 | * Output: |
496 | * On success: returns zero if all specified locks were released; | 497 | * On success: returns zero if all specified locks were released; |
497 | * returns one if one or more locks were not released | 498 | * returns one if one or more locks were not released |
498 | * On error: return code is negative errno value | 499 | * On error: return code is negative errno value |
499 | * | ||
500 | * Note: Only AF_INET client addresses are passed in | ||
501 | */ | 500 | */ |
502 | static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) | 501 | static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) |
503 | { | 502 | { |
504 | struct sockaddr_in sin = { | 503 | struct sockaddr_storage address; |
505 | .sin_family = AF_INET, | 504 | struct sockaddr *sap = (struct sockaddr *)&address; |
506 | }; | 505 | size_t salen = sizeof(address); |
507 | int b1, b2, b3, b4; | ||
508 | char c; | ||
509 | char *fo_path; | 506 | char *fo_path; |
510 | 507 | ||
511 | /* sanity check */ | 508 | /* sanity check */ |
@@ -519,14 +516,10 @@ static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) | |||
519 | if (qword_get(&buf, fo_path, size) < 0) | 516 | if (qword_get(&buf, fo_path, size) < 0) |
520 | return -EINVAL; | 517 | return -EINVAL; |
521 | 518 | ||
522 | /* get ipv4 address */ | 519 | if (rpc_pton(fo_path, size, sap, salen) == 0) |
523 | if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4) | ||
524 | return -EINVAL; | ||
525 | if (b1 > 255 || b2 > 255 || b3 > 255 || b4 > 255) | ||
526 | return -EINVAL; | 520 | return -EINVAL; |
527 | sin.sin_addr.s_addr = htonl((b1 << 24) | (b2 << 16) | (b3 << 8) | b4); | ||
528 | 521 | ||
529 | return nlmsvc_unlock_all_by_ip((struct sockaddr *)&sin); | 522 | return nlmsvc_unlock_all_by_ip(sap); |
530 | } | 523 | } |
531 | 524 | ||
532 | /** | 525 | /** |
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h index bd2eba530667..33b283601f62 100644 --- a/include/linux/nfs4.h +++ b/include/linux/nfs4.h | |||
@@ -472,6 +472,7 @@ enum lock_type4 { | |||
472 | 472 | ||
473 | #define NFSPROC4_NULL 0 | 473 | #define NFSPROC4_NULL 0 |
474 | #define NFSPROC4_COMPOUND 1 | 474 | #define NFSPROC4_COMPOUND 1 |
475 | #define NFS4_VERSION 4 | ||
475 | #define NFS4_MINOR_VERSION 0 | 476 | #define NFS4_MINOR_VERSION 0 |
476 | 477 | ||
477 | #if defined(CONFIG_NFS_V4_1) | 478 | #if defined(CONFIG_NFS_V4_1) |
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h index 19fe15d12042..320569eabe3b 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h | |||
@@ -167,6 +167,15 @@ struct nfs_server { | |||
167 | #define NFS_CAP_SYMLINKS (1U << 2) | 167 | #define NFS_CAP_SYMLINKS (1U << 2) |
168 | #define NFS_CAP_ACLS (1U << 3) | 168 | #define NFS_CAP_ACLS (1U << 3) |
169 | #define NFS_CAP_ATOMIC_OPEN (1U << 4) | 169 | #define NFS_CAP_ATOMIC_OPEN (1U << 4) |
170 | #define NFS_CAP_CHANGE_ATTR (1U << 5) | ||
171 | #define NFS_CAP_FILEID (1U << 6) | ||
172 | #define NFS_CAP_MODE (1U << 7) | ||
173 | #define NFS_CAP_NLINK (1U << 8) | ||
174 | #define NFS_CAP_OWNER (1U << 9) | ||
175 | #define NFS_CAP_OWNER_GROUP (1U << 10) | ||
176 | #define NFS_CAP_ATIME (1U << 11) | ||
177 | #define NFS_CAP_CTIME (1U << 12) | ||
178 | #define NFS_CAP_MTIME (1U << 13) | ||
170 | 179 | ||
171 | 180 | ||
172 | /* maximum number of slots to use */ | 181 | /* maximum number of slots to use */ |
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h index 2d8b211b9324..6f52b4d7c447 100644 --- a/include/linux/sunrpc/cache.h +++ b/include/linux/sunrpc/cache.h | |||
@@ -59,6 +59,15 @@ struct cache_head { | |||
59 | 59 | ||
60 | #define CACHE_NEW_EXPIRY 120 /* keep new things pending confirmation for 120 seconds */ | 60 | #define CACHE_NEW_EXPIRY 120 /* keep new things pending confirmation for 120 seconds */ |
61 | 61 | ||
62 | struct cache_detail_procfs { | ||
63 | struct proc_dir_entry *proc_ent; | ||
64 | struct proc_dir_entry *flush_ent, *channel_ent, *content_ent; | ||
65 | }; | ||
66 | |||
67 | struct cache_detail_pipefs { | ||
68 | struct dentry *dir; | ||
69 | }; | ||
70 | |||
62 | struct cache_detail { | 71 | struct cache_detail { |
63 | struct module * owner; | 72 | struct module * owner; |
64 | int hash_size; | 73 | int hash_size; |
@@ -70,15 +79,17 @@ struct cache_detail { | |||
70 | char *name; | 79 | char *name; |
71 | void (*cache_put)(struct kref *); | 80 | void (*cache_put)(struct kref *); |
72 | 81 | ||
73 | void (*cache_request)(struct cache_detail *cd, | 82 | int (*cache_upcall)(struct cache_detail *, |
74 | struct cache_head *h, | 83 | struct cache_head *); |
75 | char **bpp, int *blen); | 84 | |
76 | int (*cache_parse)(struct cache_detail *, | 85 | int (*cache_parse)(struct cache_detail *, |
77 | char *buf, int len); | 86 | char *buf, int len); |
78 | 87 | ||
79 | int (*cache_show)(struct seq_file *m, | 88 | int (*cache_show)(struct seq_file *m, |
80 | struct cache_detail *cd, | 89 | struct cache_detail *cd, |
81 | struct cache_head *h); | 90 | struct cache_head *h); |
91 | void (*warn_no_listener)(struct cache_detail *cd, | ||
92 | int has_died); | ||
82 | 93 | ||
83 | struct cache_head * (*alloc)(void); | 94 | struct cache_head * (*alloc)(void); |
84 | int (*match)(struct cache_head *orig, struct cache_head *new); | 95 | int (*match)(struct cache_head *orig, struct cache_head *new); |
@@ -96,13 +107,15 @@ struct cache_detail { | |||
96 | 107 | ||
97 | /* fields for communication over channel */ | 108 | /* fields for communication over channel */ |
98 | struct list_head queue; | 109 | struct list_head queue; |
99 | struct proc_dir_entry *proc_ent; | ||
100 | struct proc_dir_entry *flush_ent, *channel_ent, *content_ent; | ||
101 | 110 | ||
102 | atomic_t readers; /* how many time is /chennel open */ | 111 | atomic_t readers; /* how many time is /chennel open */ |
103 | time_t last_close; /* if no readers, when did last close */ | 112 | time_t last_close; /* if no readers, when did last close */ |
104 | time_t last_warn; /* when we last warned about no readers */ | 113 | time_t last_warn; /* when we last warned about no readers */ |
105 | void (*warn_no_listener)(struct cache_detail *cd); | 114 | |
115 | union { | ||
116 | struct cache_detail_procfs procfs; | ||
117 | struct cache_detail_pipefs pipefs; | ||
118 | } u; | ||
106 | }; | 119 | }; |
107 | 120 | ||
108 | 121 | ||
@@ -127,6 +140,10 @@ struct cache_deferred_req { | |||
127 | }; | 140 | }; |
128 | 141 | ||
129 | 142 | ||
143 | extern const struct file_operations cache_file_operations_pipefs; | ||
144 | extern const struct file_operations content_file_operations_pipefs; | ||
145 | extern const struct file_operations cache_flush_operations_pipefs; | ||
146 | |||
130 | extern struct cache_head * | 147 | extern struct cache_head * |
131 | sunrpc_cache_lookup(struct cache_detail *detail, | 148 | sunrpc_cache_lookup(struct cache_detail *detail, |
132 | struct cache_head *key, int hash); | 149 | struct cache_head *key, int hash); |
@@ -134,6 +151,13 @@ extern struct cache_head * | |||
134 | sunrpc_cache_update(struct cache_detail *detail, | 151 | sunrpc_cache_update(struct cache_detail *detail, |
135 | struct cache_head *new, struct cache_head *old, int hash); | 152 | struct cache_head *new, struct cache_head *old, int hash); |
136 | 153 | ||
154 | extern int | ||
155 | sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h, | ||
156 | void (*cache_request)(struct cache_detail *, | ||
157 | struct cache_head *, | ||
158 | char **, | ||
159 | int *)); | ||
160 | |||
137 | 161 | ||
138 | extern void cache_clean_deferred(void *owner); | 162 | extern void cache_clean_deferred(void *owner); |
139 | 163 | ||
@@ -171,6 +195,10 @@ extern void cache_purge(struct cache_detail *detail); | |||
171 | extern int cache_register(struct cache_detail *cd); | 195 | extern int cache_register(struct cache_detail *cd); |
172 | extern void cache_unregister(struct cache_detail *cd); | 196 | extern void cache_unregister(struct cache_detail *cd); |
173 | 197 | ||
198 | extern int sunrpc_cache_register_pipefs(struct dentry *parent, const char *, | ||
199 | mode_t, struct cache_detail *); | ||
200 | extern void sunrpc_cache_unregister_pipefs(struct cache_detail *); | ||
201 | |||
174 | extern void qword_add(char **bpp, int *lp, char *str); | 202 | extern void qword_add(char **bpp, int *lp, char *str); |
175 | extern void qword_addhex(char **bpp, int *lp, char *buf, int blen); | 203 | extern void qword_addhex(char **bpp, int *lp, char *buf, int blen); |
176 | extern int qword_get(char **bpp, char *dest, int bufsize); | 204 | extern int qword_get(char **bpp, char *dest, int bufsize); |
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h index 37881f1a0bd7..ab3f6e90caa5 100644 --- a/include/linux/sunrpc/clnt.h +++ b/include/linux/sunrpc/clnt.h | |||
@@ -9,6 +9,10 @@ | |||
9 | #ifndef _LINUX_SUNRPC_CLNT_H | 9 | #ifndef _LINUX_SUNRPC_CLNT_H |
10 | #define _LINUX_SUNRPC_CLNT_H | 10 | #define _LINUX_SUNRPC_CLNT_H |
11 | 11 | ||
12 | #include <linux/socket.h> | ||
13 | #include <linux/in.h> | ||
14 | #include <linux/in6.h> | ||
15 | |||
12 | #include <linux/sunrpc/msg_prot.h> | 16 | #include <linux/sunrpc/msg_prot.h> |
13 | #include <linux/sunrpc/sched.h> | 17 | #include <linux/sunrpc/sched.h> |
14 | #include <linux/sunrpc/xprt.h> | 18 | #include <linux/sunrpc/xprt.h> |
@@ -17,6 +21,7 @@ | |||
17 | #include <linux/sunrpc/xdr.h> | 21 | #include <linux/sunrpc/xdr.h> |
18 | #include <linux/sunrpc/timer.h> | 22 | #include <linux/sunrpc/timer.h> |
19 | #include <asm/signal.h> | 23 | #include <asm/signal.h> |
24 | #include <linux/path.h> | ||
20 | 25 | ||
21 | struct rpc_inode; | 26 | struct rpc_inode; |
22 | 27 | ||
@@ -50,9 +55,7 @@ struct rpc_clnt { | |||
50 | 55 | ||
51 | int cl_nodelen; /* nodename length */ | 56 | int cl_nodelen; /* nodename length */ |
52 | char cl_nodename[UNX_MAXNODENAME]; | 57 | char cl_nodename[UNX_MAXNODENAME]; |
53 | char cl_pathname[30];/* Path in rpc_pipe_fs */ | 58 | struct path cl_path; |
54 | struct vfsmount * cl_vfsmnt; | ||
55 | struct dentry * cl_dentry; /* inode */ | ||
56 | struct rpc_clnt * cl_parent; /* Points to parent of clones */ | 59 | struct rpc_clnt * cl_parent; /* Points to parent of clones */ |
57 | struct rpc_rtt cl_rtt_default; | 60 | struct rpc_rtt cl_rtt_default; |
58 | struct rpc_timeout cl_timeout_default; | 61 | struct rpc_timeout cl_timeout_default; |
@@ -151,5 +154,39 @@ void rpc_force_rebind(struct rpc_clnt *); | |||
151 | size_t rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t); | 154 | size_t rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t); |
152 | const char *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t); | 155 | const char *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t); |
153 | 156 | ||
157 | size_t rpc_ntop(const struct sockaddr *, char *, const size_t); | ||
158 | size_t rpc_pton(const char *, const size_t, | ||
159 | struct sockaddr *, const size_t); | ||
160 | char * rpc_sockaddr2uaddr(const struct sockaddr *); | ||
161 | size_t rpc_uaddr2sockaddr(const char *, const size_t, | ||
162 | struct sockaddr *, const size_t); | ||
163 | |||
164 | static inline unsigned short rpc_get_port(const struct sockaddr *sap) | ||
165 | { | ||
166 | switch (sap->sa_family) { | ||
167 | case AF_INET: | ||
168 | return ntohs(((struct sockaddr_in *)sap)->sin_port); | ||
169 | case AF_INET6: | ||
170 | return ntohs(((struct sockaddr_in6 *)sap)->sin6_port); | ||
171 | } | ||
172 | return 0; | ||
173 | } | ||
174 | |||
175 | static inline void rpc_set_port(struct sockaddr *sap, | ||
176 | const unsigned short port) | ||
177 | { | ||
178 | switch (sap->sa_family) { | ||
179 | case AF_INET: | ||
180 | ((struct sockaddr_in *)sap)->sin_port = htons(port); | ||
181 | break; | ||
182 | case AF_INET6: | ||
183 | ((struct sockaddr_in6 *)sap)->sin6_port = htons(port); | ||
184 | break; | ||
185 | } | ||
186 | } | ||
187 | |||
188 | #define IPV6_SCOPE_DELIMITER '%' | ||
189 | #define IPV6_SCOPE_ID_LEN sizeof("%nnnnnnnnnn") | ||
190 | |||
154 | #endif /* __KERNEL__ */ | 191 | #endif /* __KERNEL__ */ |
155 | #endif /* _LINUX_SUNRPC_CLNT_H */ | 192 | #endif /* _LINUX_SUNRPC_CLNT_H */ |
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h index 70df4f1d8847..77e624883393 100644 --- a/include/linux/sunrpc/msg_prot.h +++ b/include/linux/sunrpc/msg_prot.h | |||
@@ -189,7 +189,22 @@ typedef __be32 rpc_fraghdr; | |||
189 | * Additionally, the two alternative forms specified in Section 2.2 of | 189 | * Additionally, the two alternative forms specified in Section 2.2 of |
190 | * [RFC2373] are also acceptable. | 190 | * [RFC2373] are also acceptable. |
191 | */ | 191 | */ |
192 | #define RPCBIND_MAXUADDRLEN (56u) | 192 | |
193 | #include <linux/inet.h> | ||
194 | |||
195 | /* Maximum size of the port number part of a universal address */ | ||
196 | #define RPCBIND_MAXUADDRPLEN sizeof(".255.255") | ||
197 | |||
198 | /* Maximum size of an IPv4 universal address */ | ||
199 | #define RPCBIND_MAXUADDR4LEN \ | ||
200 | (INET_ADDRSTRLEN + RPCBIND_MAXUADDRPLEN) | ||
201 | |||
202 | /* Maximum size of an IPv6 universal address */ | ||
203 | #define RPCBIND_MAXUADDR6LEN \ | ||
204 | (INET6_ADDRSTRLEN + RPCBIND_MAXUADDRPLEN) | ||
205 | |||
206 | /* Assume INET6_ADDRSTRLEN will always be larger than INET_ADDRSTRLEN... */ | ||
207 | #define RPCBIND_MAXUADDRLEN RPCBIND_MAXUADDR6LEN | ||
193 | 208 | ||
194 | #endif /* __KERNEL__ */ | 209 | #endif /* __KERNEL__ */ |
195 | #endif /* _LINUX_SUNRPC_MSGPROT_H_ */ | 210 | #endif /* _LINUX_SUNRPC_MSGPROT_H_ */ |
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h index cea764c2359f..cf14db975da0 100644 --- a/include/linux/sunrpc/rpc_pipe_fs.h +++ b/include/linux/sunrpc/rpc_pipe_fs.h | |||
@@ -3,6 +3,8 @@ | |||
3 | 3 | ||
4 | #ifdef __KERNEL__ | 4 | #ifdef __KERNEL__ |
5 | 5 | ||
6 | #include <linux/workqueue.h> | ||
7 | |||
6 | struct rpc_pipe_msg { | 8 | struct rpc_pipe_msg { |
7 | struct list_head list; | 9 | struct list_head list; |
8 | void *data; | 10 | void *data; |
@@ -32,8 +34,8 @@ struct rpc_inode { | |||
32 | wait_queue_head_t waitq; | 34 | wait_queue_head_t waitq; |
33 | #define RPC_PIPE_WAIT_FOR_OPEN 1 | 35 | #define RPC_PIPE_WAIT_FOR_OPEN 1 |
34 | int flags; | 36 | int flags; |
35 | struct rpc_pipe_ops *ops; | ||
36 | struct delayed_work queue_timeout; | 37 | struct delayed_work queue_timeout; |
38 | const struct rpc_pipe_ops *ops; | ||
37 | }; | 39 | }; |
38 | 40 | ||
39 | static inline struct rpc_inode * | 41 | static inline struct rpc_inode * |
@@ -44,9 +46,19 @@ RPC_I(struct inode *inode) | |||
44 | 46 | ||
45 | extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *); | 47 | extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *); |
46 | 48 | ||
47 | extern struct dentry *rpc_mkdir(char *, struct rpc_clnt *); | 49 | struct rpc_clnt; |
48 | extern int rpc_rmdir(struct dentry *); | 50 | extern struct dentry *rpc_create_client_dir(struct dentry *, struct qstr *, struct rpc_clnt *); |
49 | extern struct dentry *rpc_mkpipe(struct dentry *, const char *, void *, struct rpc_pipe_ops *, int flags); | 51 | extern int rpc_remove_client_dir(struct dentry *); |
52 | |||
53 | struct cache_detail; | ||
54 | extern struct dentry *rpc_create_cache_dir(struct dentry *, | ||
55 | struct qstr *, | ||
56 | mode_t umode, | ||
57 | struct cache_detail *); | ||
58 | extern void rpc_remove_cache_dir(struct dentry *); | ||
59 | |||
60 | extern struct dentry *rpc_mkpipe(struct dentry *, const char *, void *, | ||
61 | const struct rpc_pipe_ops *, int flags); | ||
50 | extern int rpc_unlink(struct dentry *); | 62 | extern int rpc_unlink(struct dentry *); |
51 | extern struct vfsmount *rpc_get_mount(void); | 63 | extern struct vfsmount *rpc_get_mount(void); |
52 | extern void rpc_put_mount(void); | 64 | extern void rpc_put_mount(void); |
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h index b99c625fddfe..7da466ba4b0d 100644 --- a/include/linux/sunrpc/xdr.h +++ b/include/linux/sunrpc/xdr.h | |||
@@ -117,17 +117,15 @@ static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int le | |||
117 | static inline __be32 * | 117 | static inline __be32 * |
118 | xdr_encode_hyper(__be32 *p, __u64 val) | 118 | xdr_encode_hyper(__be32 *p, __u64 val) |
119 | { | 119 | { |
120 | *p++ = htonl(val >> 32); | 120 | *(__be64 *)p = cpu_to_be64(val); |
121 | *p++ = htonl(val & 0xFFFFFFFF); | 121 | return p + 2; |
122 | return p; | ||
123 | } | 122 | } |
124 | 123 | ||
125 | static inline __be32 * | 124 | static inline __be32 * |
126 | xdr_decode_hyper(__be32 *p, __u64 *valp) | 125 | xdr_decode_hyper(__be32 *p, __u64 *valp) |
127 | { | 126 | { |
128 | *valp = ((__u64) ntohl(*p++)) << 32; | 127 | *valp = be64_to_cpup((__be64 *)p); |
129 | *valp |= ntohl(*p++); | 128 | return p + 2; |
130 | return p; | ||
131 | } | 129 | } |
132 | 130 | ||
133 | /* | 131 | /* |
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h index 1175d58efc2e..c090df442572 100644 --- a/include/linux/sunrpc/xprt.h +++ b/include/linux/sunrpc/xprt.h | |||
@@ -38,10 +38,8 @@ enum rpc_display_format_t { | |||
38 | RPC_DISPLAY_ADDR = 0, | 38 | RPC_DISPLAY_ADDR = 0, |
39 | RPC_DISPLAY_PORT, | 39 | RPC_DISPLAY_PORT, |
40 | RPC_DISPLAY_PROTO, | 40 | RPC_DISPLAY_PROTO, |
41 | RPC_DISPLAY_ALL, | ||
42 | RPC_DISPLAY_HEX_ADDR, | 41 | RPC_DISPLAY_HEX_ADDR, |
43 | RPC_DISPLAY_HEX_PORT, | 42 | RPC_DISPLAY_HEX_PORT, |
44 | RPC_DISPLAY_UNIVERSAL_ADDR, | ||
45 | RPC_DISPLAY_NETID, | 43 | RPC_DISPLAY_NETID, |
46 | RPC_DISPLAY_MAX, | 44 | RPC_DISPLAY_MAX, |
47 | }; | 45 | }; |
diff --git a/net/sunrpc/Makefile b/net/sunrpc/Makefile index db73fd2a3f0e..9d2fca5ad14a 100644 --- a/net/sunrpc/Makefile +++ b/net/sunrpc/Makefile | |||
@@ -10,7 +10,7 @@ obj-$(CONFIG_SUNRPC_XPRT_RDMA) += xprtrdma/ | |||
10 | sunrpc-y := clnt.o xprt.o socklib.o xprtsock.o sched.o \ | 10 | sunrpc-y := clnt.o xprt.o socklib.o xprtsock.o sched.o \ |
11 | auth.o auth_null.o auth_unix.o auth_generic.o \ | 11 | auth.o auth_null.o auth_unix.o auth_generic.o \ |
12 | svc.o svcsock.o svcauth.o svcauth_unix.o \ | 12 | svc.o svcsock.o svcauth.o svcauth_unix.o \ |
13 | rpcb_clnt.o timer.o xdr.o \ | 13 | addr.o rpcb_clnt.o timer.o xdr.o \ |
14 | sunrpc_syms.o cache.o rpc_pipe.o \ | 14 | sunrpc_syms.o cache.o rpc_pipe.o \ |
15 | svc_xprt.o | 15 | svc_xprt.o |
16 | sunrpc-$(CONFIG_NFS_V4_1) += backchannel_rqst.o bc_svc.o | 16 | sunrpc-$(CONFIG_NFS_V4_1) += backchannel_rqst.o bc_svc.o |
diff --git a/net/sunrpc/addr.c b/net/sunrpc/addr.c new file mode 100644 index 000000000000..22e8fd89477f --- /dev/null +++ b/net/sunrpc/addr.c | |||
@@ -0,0 +1,364 @@ | |||
1 | /* | ||
2 | * Copyright 2009, Oracle. All rights reserved. | ||
3 | * | ||
4 | * Convert socket addresses to presentation addresses and universal | ||
5 | * addresses, and vice versa. | ||
6 | * | ||
7 | * Universal addresses are introduced by RFC 1833 and further refined by | ||
8 | * recent RFCs describing NFSv4. The universal address format is part | ||
9 | * of the external (network) interface provided by rpcbind version 3 | ||
10 | * and 4, and by NFSv4. Such an address is a string containing a | ||
11 | * presentation format IP address followed by a port number in | ||
12 | * "hibyte.lobyte" format. | ||
13 | * | ||
14 | * IPv6 addresses can also include a scope ID, typically denoted by | ||
15 | * a '%' followed by a device name or a non-negative integer. Refer to | ||
16 | * RFC 4291, Section 2.2 for details on IPv6 presentation formats. | ||
17 | */ | ||
18 | |||
19 | #include <net/ipv6.h> | ||
20 | #include <linux/sunrpc/clnt.h> | ||
21 | |||
22 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | ||
23 | |||
24 | static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap, | ||
25 | char *buf, const int buflen) | ||
26 | { | ||
27 | const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; | ||
28 | const struct in6_addr *addr = &sin6->sin6_addr; | ||
29 | |||
30 | /* | ||
31 | * RFC 4291, Section 2.2.2 | ||
32 | * | ||
33 | * Shorthanded ANY address | ||
34 | */ | ||
35 | if (ipv6_addr_any(addr)) | ||
36 | return snprintf(buf, buflen, "::"); | ||
37 | |||
38 | /* | ||
39 | * RFC 4291, Section 2.2.2 | ||
40 | * | ||
41 | * Shorthanded loopback address | ||
42 | */ | ||
43 | if (ipv6_addr_loopback(addr)) | ||
44 | return snprintf(buf, buflen, "::1"); | ||
45 | |||
46 | /* | ||
47 | * RFC 4291, Section 2.2.3 | ||
48 | * | ||
49 | * Special presentation address format for mapped v4 | ||
50 | * addresses. | ||
51 | */ | ||
52 | if (ipv6_addr_v4mapped(addr)) | ||
53 | return snprintf(buf, buflen, "::ffff:%pI4", | ||
54 | &addr->s6_addr32[3]); | ||
55 | |||
56 | /* | ||
57 | * RFC 4291, Section 2.2.1 | ||
58 | * | ||
59 | * To keep the result as short as possible, especially | ||
60 | * since we don't shorthand, we don't want leading zeros | ||
61 | * in each halfword, so avoid %pI6. | ||
62 | */ | ||
63 | return snprintf(buf, buflen, "%x:%x:%x:%x:%x:%x:%x:%x", | ||
64 | ntohs(addr->s6_addr16[0]), ntohs(addr->s6_addr16[1]), | ||
65 | ntohs(addr->s6_addr16[2]), ntohs(addr->s6_addr16[3]), | ||
66 | ntohs(addr->s6_addr16[4]), ntohs(addr->s6_addr16[5]), | ||
67 | ntohs(addr->s6_addr16[6]), ntohs(addr->s6_addr16[7])); | ||
68 | } | ||
69 | |||
70 | static size_t rpc_ntop6(const struct sockaddr *sap, | ||
71 | char *buf, const size_t buflen) | ||
72 | { | ||
73 | const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; | ||
74 | char scopebuf[IPV6_SCOPE_ID_LEN]; | ||
75 | size_t len; | ||
76 | int rc; | ||
77 | |||
78 | len = rpc_ntop6_noscopeid(sap, buf, buflen); | ||
79 | if (unlikely(len == 0)) | ||
80 | return len; | ||
81 | |||
82 | if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) && | ||
83 | !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL)) | ||
84 | return len; | ||
85 | |||
86 | rc = snprintf(scopebuf, sizeof(scopebuf), "%c%u", | ||
87 | IPV6_SCOPE_DELIMITER, sin6->sin6_scope_id); | ||
88 | if (unlikely((size_t)rc > sizeof(scopebuf))) | ||
89 | return 0; | ||
90 | |||
91 | len += rc; | ||
92 | if (unlikely(len > buflen)) | ||
93 | return 0; | ||
94 | |||
95 | strcat(buf, scopebuf); | ||
96 | return len; | ||
97 | } | ||
98 | |||
99 | #else /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */ | ||
100 | |||
101 | static size_t rpc_ntop6_noscopeid(const struct sockaddr *sap, | ||
102 | char *buf, const int buflen) | ||
103 | { | ||
104 | return 0; | ||
105 | } | ||
106 | |||
107 | static size_t rpc_ntop6(const struct sockaddr *sap, | ||
108 | char *buf, const size_t buflen) | ||
109 | { | ||
110 | return 0; | ||
111 | } | ||
112 | |||
113 | #endif /* !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) */ | ||
114 | |||
115 | static int rpc_ntop4(const struct sockaddr *sap, | ||
116 | char *buf, const size_t buflen) | ||
117 | { | ||
118 | const struct sockaddr_in *sin = (struct sockaddr_in *)sap; | ||
119 | |||
120 | return snprintf(buf, buflen, "%pI4", &sin->sin_addr); | ||
121 | } | ||
122 | |||
123 | /** | ||
124 | * rpc_ntop - construct a presentation address in @buf | ||
125 | * @sap: socket address | ||
126 | * @buf: construction area | ||
127 | * @buflen: size of @buf, in bytes | ||
128 | * | ||
129 | * Plants a %NUL-terminated string in @buf and returns the length | ||
130 | * of the string, excluding the %NUL. Otherwise zero is returned. | ||
131 | */ | ||
132 | size_t rpc_ntop(const struct sockaddr *sap, char *buf, const size_t buflen) | ||
133 | { | ||
134 | switch (sap->sa_family) { | ||
135 | case AF_INET: | ||
136 | return rpc_ntop4(sap, buf, buflen); | ||
137 | case AF_INET6: | ||
138 | return rpc_ntop6(sap, buf, buflen); | ||
139 | } | ||
140 | |||
141 | return 0; | ||
142 | } | ||
143 | EXPORT_SYMBOL_GPL(rpc_ntop); | ||
144 | |||
145 | static size_t rpc_pton4(const char *buf, const size_t buflen, | ||
146 | struct sockaddr *sap, const size_t salen) | ||
147 | { | ||
148 | struct sockaddr_in *sin = (struct sockaddr_in *)sap; | ||
149 | u8 *addr = (u8 *)&sin->sin_addr.s_addr; | ||
150 | |||
151 | if (buflen > INET_ADDRSTRLEN || salen < sizeof(struct sockaddr_in)) | ||
152 | return 0; | ||
153 | |||
154 | memset(sap, 0, sizeof(struct sockaddr_in)); | ||
155 | |||
156 | if (in4_pton(buf, buflen, addr, '\0', NULL) == 0) | ||
157 | return 0; | ||
158 | |||
159 | sin->sin_family = AF_INET; | ||
160 | return sizeof(struct sockaddr_in);; | ||
161 | } | ||
162 | |||
163 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | ||
164 | static int rpc_parse_scope_id(const char *buf, const size_t buflen, | ||
165 | const char *delim, struct sockaddr_in6 *sin6) | ||
166 | { | ||
167 | char *p; | ||
168 | size_t len; | ||
169 | |||
170 | if ((buf + buflen) == delim) | ||
171 | return 1; | ||
172 | |||
173 | if (*delim != IPV6_SCOPE_DELIMITER) | ||
174 | return 0; | ||
175 | |||
176 | if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) && | ||
177 | !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL)) | ||
178 | return 0; | ||
179 | |||
180 | len = (buf + buflen) - delim - 1; | ||
181 | p = kstrndup(delim + 1, len, GFP_KERNEL); | ||
182 | if (p) { | ||
183 | unsigned long scope_id = 0; | ||
184 | struct net_device *dev; | ||
185 | |||
186 | dev = dev_get_by_name(&init_net, p); | ||
187 | if (dev != NULL) { | ||
188 | scope_id = dev->ifindex; | ||
189 | dev_put(dev); | ||
190 | } else { | ||
191 | if (strict_strtoul(p, 10, &scope_id) == 0) { | ||
192 | kfree(p); | ||
193 | return 0; | ||
194 | } | ||
195 | } | ||
196 | |||
197 | kfree(p); | ||
198 | |||
199 | sin6->sin6_scope_id = scope_id; | ||
200 | return 1; | ||
201 | } | ||
202 | |||
203 | return 0; | ||
204 | } | ||
205 | |||
206 | static size_t rpc_pton6(const char *buf, const size_t buflen, | ||
207 | struct sockaddr *sap, const size_t salen) | ||
208 | { | ||
209 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; | ||
210 | u8 *addr = (u8 *)&sin6->sin6_addr.in6_u; | ||
211 | const char *delim; | ||
212 | |||
213 | if (buflen > (INET6_ADDRSTRLEN + IPV6_SCOPE_ID_LEN) || | ||
214 | salen < sizeof(struct sockaddr_in6)) | ||
215 | return 0; | ||
216 | |||
217 | memset(sap, 0, sizeof(struct sockaddr_in6)); | ||
218 | |||
219 | if (in6_pton(buf, buflen, addr, IPV6_SCOPE_DELIMITER, &delim) == 0) | ||
220 | return 0; | ||
221 | |||
222 | if (!rpc_parse_scope_id(buf, buflen, delim, sin6)) | ||
223 | return 0; | ||
224 | |||
225 | sin6->sin6_family = AF_INET6; | ||
226 | return sizeof(struct sockaddr_in6); | ||
227 | } | ||
228 | #else | ||
229 | static size_t rpc_pton6(const char *buf, const size_t buflen, | ||
230 | struct sockaddr *sap, const size_t salen) | ||
231 | { | ||
232 | return 0; | ||
233 | } | ||
234 | #endif | ||
235 | |||
236 | /** | ||
237 | * rpc_pton - Construct a sockaddr in @sap | ||
238 | * @buf: C string containing presentation format IP address | ||
239 | * @buflen: length of presentation address in bytes | ||
240 | * @sap: buffer into which to plant socket address | ||
241 | * @salen: size of buffer in bytes | ||
242 | * | ||
243 | * Returns the size of the socket address if successful; otherwise | ||
244 | * zero is returned. | ||
245 | * | ||
246 | * Plants a socket address in @sap and returns the size of the | ||
247 | * socket address, if successful. Returns zero if an error | ||
248 | * occurred. | ||
249 | */ | ||
250 | size_t rpc_pton(const char *buf, const size_t buflen, | ||
251 | struct sockaddr *sap, const size_t salen) | ||
252 | { | ||
253 | unsigned int i; | ||
254 | |||
255 | for (i = 0; i < buflen; i++) | ||
256 | if (buf[i] == ':') | ||
257 | return rpc_pton6(buf, buflen, sap, salen); | ||
258 | return rpc_pton4(buf, buflen, sap, salen); | ||
259 | } | ||
260 | EXPORT_SYMBOL_GPL(rpc_pton); | ||
261 | |||
262 | /** | ||
263 | * rpc_sockaddr2uaddr - Construct a universal address string from @sap. | ||
264 | * @sap: socket address | ||
265 | * | ||
266 | * Returns a %NUL-terminated string in dynamically allocated memory; | ||
267 | * otherwise NULL is returned if an error occurred. Caller must | ||
268 | * free the returned string. | ||
269 | */ | ||
270 | char *rpc_sockaddr2uaddr(const struct sockaddr *sap) | ||
271 | { | ||
272 | char portbuf[RPCBIND_MAXUADDRPLEN]; | ||
273 | char addrbuf[RPCBIND_MAXUADDRLEN]; | ||
274 | unsigned short port; | ||
275 | |||
276 | switch (sap->sa_family) { | ||
277 | case AF_INET: | ||
278 | if (rpc_ntop4(sap, addrbuf, sizeof(addrbuf)) == 0) | ||
279 | return NULL; | ||
280 | port = ntohs(((struct sockaddr_in *)sap)->sin_port); | ||
281 | break; | ||
282 | case AF_INET6: | ||
283 | if (rpc_ntop6_noscopeid(sap, addrbuf, sizeof(addrbuf)) == 0) | ||
284 | return NULL; | ||
285 | port = ntohs(((struct sockaddr_in6 *)sap)->sin6_port); | ||
286 | break; | ||
287 | default: | ||
288 | return NULL; | ||
289 | } | ||
290 | |||
291 | if (snprintf(portbuf, sizeof(portbuf), | ||
292 | ".%u.%u", port >> 8, port & 0xff) > (int)sizeof(portbuf)) | ||
293 | return NULL; | ||
294 | |||
295 | if (strlcat(addrbuf, portbuf, sizeof(addrbuf)) > sizeof(addrbuf)) | ||
296 | return NULL; | ||
297 | |||
298 | return kstrdup(addrbuf, GFP_KERNEL); | ||
299 | } | ||
300 | EXPORT_SYMBOL_GPL(rpc_sockaddr2uaddr); | ||
301 | |||
302 | /** | ||
303 | * rpc_uaddr2sockaddr - convert a universal address to a socket address. | ||
304 | * @uaddr: C string containing universal address to convert | ||
305 | * @uaddr_len: length of universal address string | ||
306 | * @sap: buffer into which to plant socket address | ||
307 | * @salen: size of buffer | ||
308 | * | ||
309 | * Returns the size of the socket address if successful; otherwise | ||
310 | * zero is returned. | ||
311 | */ | ||
312 | size_t rpc_uaddr2sockaddr(const char *uaddr, const size_t uaddr_len, | ||
313 | struct sockaddr *sap, const size_t salen) | ||
314 | { | ||
315 | char *c, buf[RPCBIND_MAXUADDRLEN]; | ||
316 | unsigned long portlo, porthi; | ||
317 | unsigned short port; | ||
318 | |||
319 | if (uaddr_len > sizeof(buf)) | ||
320 | return 0; | ||
321 | |||
322 | memcpy(buf, uaddr, uaddr_len); | ||
323 | |||
324 | buf[uaddr_len] = '\n'; | ||
325 | buf[uaddr_len + 1] = '\0'; | ||
326 | |||
327 | c = strrchr(buf, '.'); | ||
328 | if (unlikely(c == NULL)) | ||
329 | return 0; | ||
330 | if (unlikely(strict_strtoul(c + 1, 10, &portlo) != 0)) | ||
331 | return 0; | ||
332 | if (unlikely(portlo > 255)) | ||
333 | return 0; | ||
334 | |||
335 | c[0] = '\n'; | ||
336 | c[1] = '\0'; | ||
337 | |||
338 | c = strrchr(buf, '.'); | ||
339 | if (unlikely(c == NULL)) | ||
340 | return 0; | ||
341 | if (unlikely(strict_strtoul(c + 1, 10, &porthi) != 0)) | ||
342 | return 0; | ||
343 | if (unlikely(porthi > 255)) | ||
344 | return 0; | ||
345 | |||
346 | port = (unsigned short)((porthi << 8) | portlo); | ||
347 | |||
348 | c[0] = '\0'; | ||
349 | |||
350 | if (rpc_pton(buf, strlen(buf), sap, salen) == 0) | ||
351 | return 0; | ||
352 | |||
353 | switch (sap->sa_family) { | ||
354 | case AF_INET: | ||
355 | ((struct sockaddr_in *)sap)->sin_port = htons(port); | ||
356 | return sizeof(struct sockaddr_in); | ||
357 | case AF_INET6: | ||
358 | ((struct sockaddr_in6 *)sap)->sin6_port = htons(port); | ||
359 | return sizeof(struct sockaddr_in6); | ||
360 | } | ||
361 | |||
362 | return 0; | ||
363 | } | ||
364 | EXPORT_SYMBOL_GPL(rpc_uaddr2sockaddr); | ||
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c index 66d458fc6920..fc6a43ccd950 100644 --- a/net/sunrpc/auth_gss/auth_gss.c +++ b/net/sunrpc/auth_gss/auth_gss.c | |||
@@ -89,8 +89,8 @@ static struct rpc_wait_queue pipe_version_rpc_waitqueue; | |||
89 | static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue); | 89 | static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue); |
90 | 90 | ||
91 | static void gss_free_ctx(struct gss_cl_ctx *); | 91 | static void gss_free_ctx(struct gss_cl_ctx *); |
92 | static struct rpc_pipe_ops gss_upcall_ops_v0; | 92 | static const struct rpc_pipe_ops gss_upcall_ops_v0; |
93 | static struct rpc_pipe_ops gss_upcall_ops_v1; | 93 | static const struct rpc_pipe_ops gss_upcall_ops_v1; |
94 | 94 | ||
95 | static inline struct gss_cl_ctx * | 95 | static inline struct gss_cl_ctx * |
96 | gss_get_ctx(struct gss_cl_ctx *ctx) | 96 | gss_get_ctx(struct gss_cl_ctx *ctx) |
@@ -777,7 +777,7 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor) | |||
777 | * that we supported only the old pipe. So we instead create | 777 | * that we supported only the old pipe. So we instead create |
778 | * the new pipe first. | 778 | * the new pipe first. |
779 | */ | 779 | */ |
780 | gss_auth->dentry[1] = rpc_mkpipe(clnt->cl_dentry, | 780 | gss_auth->dentry[1] = rpc_mkpipe(clnt->cl_path.dentry, |
781 | "gssd", | 781 | "gssd", |
782 | clnt, &gss_upcall_ops_v1, | 782 | clnt, &gss_upcall_ops_v1, |
783 | RPC_PIPE_WAIT_FOR_OPEN); | 783 | RPC_PIPE_WAIT_FOR_OPEN); |
@@ -786,7 +786,7 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor) | |||
786 | goto err_put_mech; | 786 | goto err_put_mech; |
787 | } | 787 | } |
788 | 788 | ||
789 | gss_auth->dentry[0] = rpc_mkpipe(clnt->cl_dentry, | 789 | gss_auth->dentry[0] = rpc_mkpipe(clnt->cl_path.dentry, |
790 | gss_auth->mech->gm_name, | 790 | gss_auth->mech->gm_name, |
791 | clnt, &gss_upcall_ops_v0, | 791 | clnt, &gss_upcall_ops_v0, |
792 | RPC_PIPE_WAIT_FOR_OPEN); | 792 | RPC_PIPE_WAIT_FOR_OPEN); |
@@ -1507,7 +1507,7 @@ static const struct rpc_credops gss_nullops = { | |||
1507 | .crunwrap_resp = gss_unwrap_resp, | 1507 | .crunwrap_resp = gss_unwrap_resp, |
1508 | }; | 1508 | }; |
1509 | 1509 | ||
1510 | static struct rpc_pipe_ops gss_upcall_ops_v0 = { | 1510 | static const struct rpc_pipe_ops gss_upcall_ops_v0 = { |
1511 | .upcall = gss_pipe_upcall, | 1511 | .upcall = gss_pipe_upcall, |
1512 | .downcall = gss_pipe_downcall, | 1512 | .downcall = gss_pipe_downcall, |
1513 | .destroy_msg = gss_pipe_destroy_msg, | 1513 | .destroy_msg = gss_pipe_destroy_msg, |
@@ -1515,7 +1515,7 @@ static struct rpc_pipe_ops gss_upcall_ops_v0 = { | |||
1515 | .release_pipe = gss_pipe_release, | 1515 | .release_pipe = gss_pipe_release, |
1516 | }; | 1516 | }; |
1517 | 1517 | ||
1518 | static struct rpc_pipe_ops gss_upcall_ops_v1 = { | 1518 | static const struct rpc_pipe_ops gss_upcall_ops_v1 = { |
1519 | .upcall = gss_pipe_upcall, | 1519 | .upcall = gss_pipe_upcall, |
1520 | .downcall = gss_pipe_downcall, | 1520 | .downcall = gss_pipe_downcall, |
1521 | .destroy_msg = gss_pipe_destroy_msg, | 1521 | .destroy_msg = gss_pipe_destroy_msg, |
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c index 2278a50c6444..2e6a148d277c 100644 --- a/net/sunrpc/auth_gss/svcauth_gss.c +++ b/net/sunrpc/auth_gss/svcauth_gss.c | |||
@@ -181,6 +181,11 @@ static void rsi_request(struct cache_detail *cd, | |||
181 | (*bpp)[-1] = '\n'; | 181 | (*bpp)[-1] = '\n'; |
182 | } | 182 | } |
183 | 183 | ||
184 | static int rsi_upcall(struct cache_detail *cd, struct cache_head *h) | ||
185 | { | ||
186 | return sunrpc_cache_pipe_upcall(cd, h, rsi_request); | ||
187 | } | ||
188 | |||
184 | 189 | ||
185 | static int rsi_parse(struct cache_detail *cd, | 190 | static int rsi_parse(struct cache_detail *cd, |
186 | char *mesg, int mlen) | 191 | char *mesg, int mlen) |
@@ -270,7 +275,7 @@ static struct cache_detail rsi_cache = { | |||
270 | .hash_table = rsi_table, | 275 | .hash_table = rsi_table, |
271 | .name = "auth.rpcsec.init", | 276 | .name = "auth.rpcsec.init", |
272 | .cache_put = rsi_put, | 277 | .cache_put = rsi_put, |
273 | .cache_request = rsi_request, | 278 | .cache_upcall = rsi_upcall, |
274 | .cache_parse = rsi_parse, | 279 | .cache_parse = rsi_parse, |
275 | .match = rsi_match, | 280 | .match = rsi_match, |
276 | .init = rsi_init, | 281 | .init = rsi_init, |
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c index ff0c23053d2f..45cdaff9b361 100644 --- a/net/sunrpc/cache.c +++ b/net/sunrpc/cache.c | |||
@@ -27,10 +27,12 @@ | |||
27 | #include <linux/net.h> | 27 | #include <linux/net.h> |
28 | #include <linux/workqueue.h> | 28 | #include <linux/workqueue.h> |
29 | #include <linux/mutex.h> | 29 | #include <linux/mutex.h> |
30 | #include <linux/pagemap.h> | ||
30 | #include <asm/ioctls.h> | 31 | #include <asm/ioctls.h> |
31 | #include <linux/sunrpc/types.h> | 32 | #include <linux/sunrpc/types.h> |
32 | #include <linux/sunrpc/cache.h> | 33 | #include <linux/sunrpc/cache.h> |
33 | #include <linux/sunrpc/stats.h> | 34 | #include <linux/sunrpc/stats.h> |
35 | #include <linux/sunrpc/rpc_pipe_fs.h> | ||
34 | 36 | ||
35 | #define RPCDBG_FACILITY RPCDBG_CACHE | 37 | #define RPCDBG_FACILITY RPCDBG_CACHE |
36 | 38 | ||
@@ -175,7 +177,13 @@ struct cache_head *sunrpc_cache_update(struct cache_detail *detail, | |||
175 | } | 177 | } |
176 | EXPORT_SYMBOL_GPL(sunrpc_cache_update); | 178 | EXPORT_SYMBOL_GPL(sunrpc_cache_update); |
177 | 179 | ||
178 | static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h); | 180 | static int cache_make_upcall(struct cache_detail *cd, struct cache_head *h) |
181 | { | ||
182 | if (!cd->cache_upcall) | ||
183 | return -EINVAL; | ||
184 | return cd->cache_upcall(cd, h); | ||
185 | } | ||
186 | |||
179 | /* | 187 | /* |
180 | * This is the generic cache management routine for all | 188 | * This is the generic cache management routine for all |
181 | * the authentication caches. | 189 | * the authentication caches. |
@@ -284,76 +292,11 @@ static DEFINE_SPINLOCK(cache_list_lock); | |||
284 | static struct cache_detail *current_detail; | 292 | static struct cache_detail *current_detail; |
285 | static int current_index; | 293 | static int current_index; |
286 | 294 | ||
287 | static const struct file_operations cache_file_operations; | ||
288 | static const struct file_operations content_file_operations; | ||
289 | static const struct file_operations cache_flush_operations; | ||
290 | |||
291 | static void do_cache_clean(struct work_struct *work); | 295 | static void do_cache_clean(struct work_struct *work); |
292 | static DECLARE_DELAYED_WORK(cache_cleaner, do_cache_clean); | 296 | static DECLARE_DELAYED_WORK(cache_cleaner, do_cache_clean); |
293 | 297 | ||
294 | static void remove_cache_proc_entries(struct cache_detail *cd) | 298 | static void sunrpc_init_cache_detail(struct cache_detail *cd) |
295 | { | ||
296 | if (cd->proc_ent == NULL) | ||
297 | return; | ||
298 | if (cd->flush_ent) | ||
299 | remove_proc_entry("flush", cd->proc_ent); | ||
300 | if (cd->channel_ent) | ||
301 | remove_proc_entry("channel", cd->proc_ent); | ||
302 | if (cd->content_ent) | ||
303 | remove_proc_entry("content", cd->proc_ent); | ||
304 | cd->proc_ent = NULL; | ||
305 | remove_proc_entry(cd->name, proc_net_rpc); | ||
306 | } | ||
307 | |||
308 | #ifdef CONFIG_PROC_FS | ||
309 | static int create_cache_proc_entries(struct cache_detail *cd) | ||
310 | { | ||
311 | struct proc_dir_entry *p; | ||
312 | |||
313 | cd->proc_ent = proc_mkdir(cd->name, proc_net_rpc); | ||
314 | if (cd->proc_ent == NULL) | ||
315 | goto out_nomem; | ||
316 | cd->channel_ent = cd->content_ent = NULL; | ||
317 | |||
318 | p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR, | ||
319 | cd->proc_ent, &cache_flush_operations, cd); | ||
320 | cd->flush_ent = p; | ||
321 | if (p == NULL) | ||
322 | goto out_nomem; | ||
323 | |||
324 | if (cd->cache_request || cd->cache_parse) { | ||
325 | p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR, | ||
326 | cd->proc_ent, &cache_file_operations, cd); | ||
327 | cd->channel_ent = p; | ||
328 | if (p == NULL) | ||
329 | goto out_nomem; | ||
330 | } | ||
331 | if (cd->cache_show) { | ||
332 | p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR, | ||
333 | cd->proc_ent, &content_file_operations, cd); | ||
334 | cd->content_ent = p; | ||
335 | if (p == NULL) | ||
336 | goto out_nomem; | ||
337 | } | ||
338 | return 0; | ||
339 | out_nomem: | ||
340 | remove_cache_proc_entries(cd); | ||
341 | return -ENOMEM; | ||
342 | } | ||
343 | #else /* CONFIG_PROC_FS */ | ||
344 | static int create_cache_proc_entries(struct cache_detail *cd) | ||
345 | { | ||
346 | return 0; | ||
347 | } | ||
348 | #endif | ||
349 | |||
350 | int cache_register(struct cache_detail *cd) | ||
351 | { | 299 | { |
352 | int ret; | ||
353 | |||
354 | ret = create_cache_proc_entries(cd); | ||
355 | if (ret) | ||
356 | return ret; | ||
357 | rwlock_init(&cd->hash_lock); | 300 | rwlock_init(&cd->hash_lock); |
358 | INIT_LIST_HEAD(&cd->queue); | 301 | INIT_LIST_HEAD(&cd->queue); |
359 | spin_lock(&cache_list_lock); | 302 | spin_lock(&cache_list_lock); |
@@ -367,11 +310,9 @@ int cache_register(struct cache_detail *cd) | |||
367 | 310 | ||
368 | /* start the cleaning process */ | 311 | /* start the cleaning process */ |
369 | schedule_delayed_work(&cache_cleaner, 0); | 312 | schedule_delayed_work(&cache_cleaner, 0); |
370 | return 0; | ||
371 | } | 313 | } |
372 | EXPORT_SYMBOL_GPL(cache_register); | ||
373 | 314 | ||
374 | void cache_unregister(struct cache_detail *cd) | 315 | static void sunrpc_destroy_cache_detail(struct cache_detail *cd) |
375 | { | 316 | { |
376 | cache_purge(cd); | 317 | cache_purge(cd); |
377 | spin_lock(&cache_list_lock); | 318 | spin_lock(&cache_list_lock); |
@@ -386,7 +327,6 @@ void cache_unregister(struct cache_detail *cd) | |||
386 | list_del_init(&cd->others); | 327 | list_del_init(&cd->others); |
387 | write_unlock(&cd->hash_lock); | 328 | write_unlock(&cd->hash_lock); |
388 | spin_unlock(&cache_list_lock); | 329 | spin_unlock(&cache_list_lock); |
389 | remove_cache_proc_entries(cd); | ||
390 | if (list_empty(&cache_list)) { | 330 | if (list_empty(&cache_list)) { |
391 | /* module must be being unloaded so its safe to kill the worker */ | 331 | /* module must be being unloaded so its safe to kill the worker */ |
392 | cancel_delayed_work_sync(&cache_cleaner); | 332 | cancel_delayed_work_sync(&cache_cleaner); |
@@ -395,7 +335,6 @@ void cache_unregister(struct cache_detail *cd) | |||
395 | out: | 335 | out: |
396 | printk(KERN_ERR "nfsd: failed to unregister %s cache\n", cd->name); | 336 | printk(KERN_ERR "nfsd: failed to unregister %s cache\n", cd->name); |
397 | } | 337 | } |
398 | EXPORT_SYMBOL_GPL(cache_unregister); | ||
399 | 338 | ||
400 | /* clean cache tries to find something to clean | 339 | /* clean cache tries to find something to clean |
401 | * and cleans it. | 340 | * and cleans it. |
@@ -687,18 +626,18 @@ struct cache_reader { | |||
687 | int offset; /* if non-0, we have a refcnt on next request */ | 626 | int offset; /* if non-0, we have a refcnt on next request */ |
688 | }; | 627 | }; |
689 | 628 | ||
690 | static ssize_t | 629 | static ssize_t cache_read(struct file *filp, char __user *buf, size_t count, |
691 | cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos) | 630 | loff_t *ppos, struct cache_detail *cd) |
692 | { | 631 | { |
693 | struct cache_reader *rp = filp->private_data; | 632 | struct cache_reader *rp = filp->private_data; |
694 | struct cache_request *rq; | 633 | struct cache_request *rq; |
695 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | 634 | struct inode *inode = filp->f_path.dentry->d_inode; |
696 | int err; | 635 | int err; |
697 | 636 | ||
698 | if (count == 0) | 637 | if (count == 0) |
699 | return 0; | 638 | return 0; |
700 | 639 | ||
701 | mutex_lock(&queue_io_mutex); /* protect against multiple concurrent | 640 | mutex_lock(&inode->i_mutex); /* protect against multiple concurrent |
702 | * readers on this file */ | 641 | * readers on this file */ |
703 | again: | 642 | again: |
704 | spin_lock(&queue_lock); | 643 | spin_lock(&queue_lock); |
@@ -711,7 +650,7 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos) | |||
711 | } | 650 | } |
712 | if (rp->q.list.next == &cd->queue) { | 651 | if (rp->q.list.next == &cd->queue) { |
713 | spin_unlock(&queue_lock); | 652 | spin_unlock(&queue_lock); |
714 | mutex_unlock(&queue_io_mutex); | 653 | mutex_unlock(&inode->i_mutex); |
715 | BUG_ON(rp->offset); | 654 | BUG_ON(rp->offset); |
716 | return 0; | 655 | return 0; |
717 | } | 656 | } |
@@ -758,49 +697,90 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos) | |||
758 | } | 697 | } |
759 | if (err == -EAGAIN) | 698 | if (err == -EAGAIN) |
760 | goto again; | 699 | goto again; |
761 | mutex_unlock(&queue_io_mutex); | 700 | mutex_unlock(&inode->i_mutex); |
762 | return err ? err : count; | 701 | return err ? err : count; |
763 | } | 702 | } |
764 | 703 | ||
765 | static char write_buf[8192]; /* protected by queue_io_mutex */ | 704 | static ssize_t cache_do_downcall(char *kaddr, const char __user *buf, |
705 | size_t count, struct cache_detail *cd) | ||
706 | { | ||
707 | ssize_t ret; | ||
766 | 708 | ||
767 | static ssize_t | 709 | if (copy_from_user(kaddr, buf, count)) |
768 | cache_write(struct file *filp, const char __user *buf, size_t count, | 710 | return -EFAULT; |
769 | loff_t *ppos) | 711 | kaddr[count] = '\0'; |
712 | ret = cd->cache_parse(cd, kaddr, count); | ||
713 | if (!ret) | ||
714 | ret = count; | ||
715 | return ret; | ||
716 | } | ||
717 | |||
718 | static ssize_t cache_slow_downcall(const char __user *buf, | ||
719 | size_t count, struct cache_detail *cd) | ||
770 | { | 720 | { |
771 | int err; | 721 | static char write_buf[8192]; /* protected by queue_io_mutex */ |
772 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | 722 | ssize_t ret = -EINVAL; |
773 | 723 | ||
774 | if (count == 0) | ||
775 | return 0; | ||
776 | if (count >= sizeof(write_buf)) | 724 | if (count >= sizeof(write_buf)) |
777 | return -EINVAL; | 725 | goto out; |
778 | |||
779 | mutex_lock(&queue_io_mutex); | 726 | mutex_lock(&queue_io_mutex); |
727 | ret = cache_do_downcall(write_buf, buf, count, cd); | ||
728 | mutex_unlock(&queue_io_mutex); | ||
729 | out: | ||
730 | return ret; | ||
731 | } | ||
780 | 732 | ||
781 | if (copy_from_user(write_buf, buf, count)) { | 733 | static ssize_t cache_downcall(struct address_space *mapping, |
782 | mutex_unlock(&queue_io_mutex); | 734 | const char __user *buf, |
783 | return -EFAULT; | 735 | size_t count, struct cache_detail *cd) |
784 | } | 736 | { |
785 | write_buf[count] = '\0'; | 737 | struct page *page; |
786 | if (cd->cache_parse) | 738 | char *kaddr; |
787 | err = cd->cache_parse(cd, write_buf, count); | 739 | ssize_t ret = -ENOMEM; |
788 | else | 740 | |
789 | err = -EINVAL; | 741 | if (count >= PAGE_CACHE_SIZE) |
742 | goto out_slow; | ||
743 | |||
744 | page = find_or_create_page(mapping, 0, GFP_KERNEL); | ||
745 | if (!page) | ||
746 | goto out_slow; | ||
747 | |||
748 | kaddr = kmap(page); | ||
749 | ret = cache_do_downcall(kaddr, buf, count, cd); | ||
750 | kunmap(page); | ||
751 | unlock_page(page); | ||
752 | page_cache_release(page); | ||
753 | return ret; | ||
754 | out_slow: | ||
755 | return cache_slow_downcall(buf, count, cd); | ||
756 | } | ||
790 | 757 | ||
791 | mutex_unlock(&queue_io_mutex); | 758 | static ssize_t cache_write(struct file *filp, const char __user *buf, |
792 | return err ? err : count; | 759 | size_t count, loff_t *ppos, |
760 | struct cache_detail *cd) | ||
761 | { | ||
762 | struct address_space *mapping = filp->f_mapping; | ||
763 | struct inode *inode = filp->f_path.dentry->d_inode; | ||
764 | ssize_t ret = -EINVAL; | ||
765 | |||
766 | if (!cd->cache_parse) | ||
767 | goto out; | ||
768 | |||
769 | mutex_lock(&inode->i_mutex); | ||
770 | ret = cache_downcall(mapping, buf, count, cd); | ||
771 | mutex_unlock(&inode->i_mutex); | ||
772 | out: | ||
773 | return ret; | ||
793 | } | 774 | } |
794 | 775 | ||
795 | static DECLARE_WAIT_QUEUE_HEAD(queue_wait); | 776 | static DECLARE_WAIT_QUEUE_HEAD(queue_wait); |
796 | 777 | ||
797 | static unsigned int | 778 | static unsigned int cache_poll(struct file *filp, poll_table *wait, |
798 | cache_poll(struct file *filp, poll_table *wait) | 779 | struct cache_detail *cd) |
799 | { | 780 | { |
800 | unsigned int mask; | 781 | unsigned int mask; |
801 | struct cache_reader *rp = filp->private_data; | 782 | struct cache_reader *rp = filp->private_data; |
802 | struct cache_queue *cq; | 783 | struct cache_queue *cq; |
803 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | ||
804 | 784 | ||
805 | poll_wait(filp, &queue_wait, wait); | 785 | poll_wait(filp, &queue_wait, wait); |
806 | 786 | ||
@@ -822,14 +802,13 @@ cache_poll(struct file *filp, poll_table *wait) | |||
822 | return mask; | 802 | return mask; |
823 | } | 803 | } |
824 | 804 | ||
825 | static int | 805 | static int cache_ioctl(struct inode *ino, struct file *filp, |
826 | cache_ioctl(struct inode *ino, struct file *filp, | 806 | unsigned int cmd, unsigned long arg, |
827 | unsigned int cmd, unsigned long arg) | 807 | struct cache_detail *cd) |
828 | { | 808 | { |
829 | int len = 0; | 809 | int len = 0; |
830 | struct cache_reader *rp = filp->private_data; | 810 | struct cache_reader *rp = filp->private_data; |
831 | struct cache_queue *cq; | 811 | struct cache_queue *cq; |
832 | struct cache_detail *cd = PDE(ino)->data; | ||
833 | 812 | ||
834 | if (cmd != FIONREAD || !rp) | 813 | if (cmd != FIONREAD || !rp) |
835 | return -EINVAL; | 814 | return -EINVAL; |
@@ -852,15 +831,15 @@ cache_ioctl(struct inode *ino, struct file *filp, | |||
852 | return put_user(len, (int __user *)arg); | 831 | return put_user(len, (int __user *)arg); |
853 | } | 832 | } |
854 | 833 | ||
855 | static int | 834 | static int cache_open(struct inode *inode, struct file *filp, |
856 | cache_open(struct inode *inode, struct file *filp) | 835 | struct cache_detail *cd) |
857 | { | 836 | { |
858 | struct cache_reader *rp = NULL; | 837 | struct cache_reader *rp = NULL; |
859 | 838 | ||
839 | if (!cd || !try_module_get(cd->owner)) | ||
840 | return -EACCES; | ||
860 | nonseekable_open(inode, filp); | 841 | nonseekable_open(inode, filp); |
861 | if (filp->f_mode & FMODE_READ) { | 842 | if (filp->f_mode & FMODE_READ) { |
862 | struct cache_detail *cd = PDE(inode)->data; | ||
863 | |||
864 | rp = kmalloc(sizeof(*rp), GFP_KERNEL); | 843 | rp = kmalloc(sizeof(*rp), GFP_KERNEL); |
865 | if (!rp) | 844 | if (!rp) |
866 | return -ENOMEM; | 845 | return -ENOMEM; |
@@ -875,11 +854,10 @@ cache_open(struct inode *inode, struct file *filp) | |||
875 | return 0; | 854 | return 0; |
876 | } | 855 | } |
877 | 856 | ||
878 | static int | 857 | static int cache_release(struct inode *inode, struct file *filp, |
879 | cache_release(struct inode *inode, struct file *filp) | 858 | struct cache_detail *cd) |
880 | { | 859 | { |
881 | struct cache_reader *rp = filp->private_data; | 860 | struct cache_reader *rp = filp->private_data; |
882 | struct cache_detail *cd = PDE(inode)->data; | ||
883 | 861 | ||
884 | if (rp) { | 862 | if (rp) { |
885 | spin_lock(&queue_lock); | 863 | spin_lock(&queue_lock); |
@@ -903,23 +881,12 @@ cache_release(struct inode *inode, struct file *filp) | |||
903 | cd->last_close = get_seconds(); | 881 | cd->last_close = get_seconds(); |
904 | atomic_dec(&cd->readers); | 882 | atomic_dec(&cd->readers); |
905 | } | 883 | } |
884 | module_put(cd->owner); | ||
906 | return 0; | 885 | return 0; |
907 | } | 886 | } |
908 | 887 | ||
909 | 888 | ||
910 | 889 | ||
911 | static const struct file_operations cache_file_operations = { | ||
912 | .owner = THIS_MODULE, | ||
913 | .llseek = no_llseek, | ||
914 | .read = cache_read, | ||
915 | .write = cache_write, | ||
916 | .poll = cache_poll, | ||
917 | .ioctl = cache_ioctl, /* for FIONREAD */ | ||
918 | .open = cache_open, | ||
919 | .release = cache_release, | ||
920 | }; | ||
921 | |||
922 | |||
923 | static void queue_loose(struct cache_detail *detail, struct cache_head *ch) | 890 | static void queue_loose(struct cache_detail *detail, struct cache_head *ch) |
924 | { | 891 | { |
925 | struct cache_queue *cq; | 892 | struct cache_queue *cq; |
@@ -1020,15 +987,21 @@ static void warn_no_listener(struct cache_detail *detail) | |||
1020 | if (detail->last_warn != detail->last_close) { | 987 | if (detail->last_warn != detail->last_close) { |
1021 | detail->last_warn = detail->last_close; | 988 | detail->last_warn = detail->last_close; |
1022 | if (detail->warn_no_listener) | 989 | if (detail->warn_no_listener) |
1023 | detail->warn_no_listener(detail); | 990 | detail->warn_no_listener(detail, detail->last_close != 0); |
1024 | } | 991 | } |
1025 | } | 992 | } |
1026 | 993 | ||
1027 | /* | 994 | /* |
1028 | * register an upcall request to user-space. | 995 | * register an upcall request to user-space and queue it up for read() by the |
996 | * upcall daemon. | ||
997 | * | ||
1029 | * Each request is at most one page long. | 998 | * Each request is at most one page long. |
1030 | */ | 999 | */ |
1031 | static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h) | 1000 | int sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h, |
1001 | void (*cache_request)(struct cache_detail *, | ||
1002 | struct cache_head *, | ||
1003 | char **, | ||
1004 | int *)) | ||
1032 | { | 1005 | { |
1033 | 1006 | ||
1034 | char *buf; | 1007 | char *buf; |
@@ -1036,9 +1009,6 @@ static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h) | |||
1036 | char *bp; | 1009 | char *bp; |
1037 | int len; | 1010 | int len; |
1038 | 1011 | ||
1039 | if (detail->cache_request == NULL) | ||
1040 | return -EINVAL; | ||
1041 | |||
1042 | if (atomic_read(&detail->readers) == 0 && | 1012 | if (atomic_read(&detail->readers) == 0 && |
1043 | detail->last_close < get_seconds() - 30) { | 1013 | detail->last_close < get_seconds() - 30) { |
1044 | warn_no_listener(detail); | 1014 | warn_no_listener(detail); |
@@ -1057,7 +1027,7 @@ static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h) | |||
1057 | 1027 | ||
1058 | bp = buf; len = PAGE_SIZE; | 1028 | bp = buf; len = PAGE_SIZE; |
1059 | 1029 | ||
1060 | detail->cache_request(detail, h, &bp, &len); | 1030 | cache_request(detail, h, &bp, &len); |
1061 | 1031 | ||
1062 | if (len < 0) { | 1032 | if (len < 0) { |
1063 | kfree(buf); | 1033 | kfree(buf); |
@@ -1075,6 +1045,7 @@ static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h) | |||
1075 | wake_up(&queue_wait); | 1045 | wake_up(&queue_wait); |
1076 | return 0; | 1046 | return 0; |
1077 | } | 1047 | } |
1048 | EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall); | ||
1078 | 1049 | ||
1079 | /* | 1050 | /* |
1080 | * parse a message from user-space and pass it | 1051 | * parse a message from user-space and pass it |
@@ -1242,11 +1213,13 @@ static const struct seq_operations cache_content_op = { | |||
1242 | .show = c_show, | 1213 | .show = c_show, |
1243 | }; | 1214 | }; |
1244 | 1215 | ||
1245 | static int content_open(struct inode *inode, struct file *file) | 1216 | static int content_open(struct inode *inode, struct file *file, |
1217 | struct cache_detail *cd) | ||
1246 | { | 1218 | { |
1247 | struct handle *han; | 1219 | struct handle *han; |
1248 | struct cache_detail *cd = PDE(inode)->data; | ||
1249 | 1220 | ||
1221 | if (!cd || !try_module_get(cd->owner)) | ||
1222 | return -EACCES; | ||
1250 | han = __seq_open_private(file, &cache_content_op, sizeof(*han)); | 1223 | han = __seq_open_private(file, &cache_content_op, sizeof(*han)); |
1251 | if (han == NULL) | 1224 | if (han == NULL) |
1252 | return -ENOMEM; | 1225 | return -ENOMEM; |
@@ -1255,17 +1228,33 @@ static int content_open(struct inode *inode, struct file *file) | |||
1255 | return 0; | 1228 | return 0; |
1256 | } | 1229 | } |
1257 | 1230 | ||
1258 | static const struct file_operations content_file_operations = { | 1231 | static int content_release(struct inode *inode, struct file *file, |
1259 | .open = content_open, | 1232 | struct cache_detail *cd) |
1260 | .read = seq_read, | 1233 | { |
1261 | .llseek = seq_lseek, | 1234 | int ret = seq_release_private(inode, file); |
1262 | .release = seq_release_private, | 1235 | module_put(cd->owner); |
1263 | }; | 1236 | return ret; |
1237 | } | ||
1238 | |||
1239 | static int open_flush(struct inode *inode, struct file *file, | ||
1240 | struct cache_detail *cd) | ||
1241 | { | ||
1242 | if (!cd || !try_module_get(cd->owner)) | ||
1243 | return -EACCES; | ||
1244 | return nonseekable_open(inode, file); | ||
1245 | } | ||
1246 | |||
1247 | static int release_flush(struct inode *inode, struct file *file, | ||
1248 | struct cache_detail *cd) | ||
1249 | { | ||
1250 | module_put(cd->owner); | ||
1251 | return 0; | ||
1252 | } | ||
1264 | 1253 | ||
1265 | static ssize_t read_flush(struct file *file, char __user *buf, | 1254 | static ssize_t read_flush(struct file *file, char __user *buf, |
1266 | size_t count, loff_t *ppos) | 1255 | size_t count, loff_t *ppos, |
1256 | struct cache_detail *cd) | ||
1267 | { | 1257 | { |
1268 | struct cache_detail *cd = PDE(file->f_path.dentry->d_inode)->data; | ||
1269 | char tbuf[20]; | 1258 | char tbuf[20]; |
1270 | unsigned long p = *ppos; | 1259 | unsigned long p = *ppos; |
1271 | size_t len; | 1260 | size_t len; |
@@ -1283,10 +1272,10 @@ static ssize_t read_flush(struct file *file, char __user *buf, | |||
1283 | return len; | 1272 | return len; |
1284 | } | 1273 | } |
1285 | 1274 | ||
1286 | static ssize_t write_flush(struct file * file, const char __user * buf, | 1275 | static ssize_t write_flush(struct file *file, const char __user *buf, |
1287 | size_t count, loff_t *ppos) | 1276 | size_t count, loff_t *ppos, |
1277 | struct cache_detail *cd) | ||
1288 | { | 1278 | { |
1289 | struct cache_detail *cd = PDE(file->f_path.dentry->d_inode)->data; | ||
1290 | char tbuf[20]; | 1279 | char tbuf[20]; |
1291 | char *ep; | 1280 | char *ep; |
1292 | long flushtime; | 1281 | long flushtime; |
@@ -1307,8 +1296,343 @@ static ssize_t write_flush(struct file * file, const char __user * buf, | |||
1307 | return count; | 1296 | return count; |
1308 | } | 1297 | } |
1309 | 1298 | ||
1310 | static const struct file_operations cache_flush_operations = { | 1299 | static ssize_t cache_read_procfs(struct file *filp, char __user *buf, |
1311 | .open = nonseekable_open, | 1300 | size_t count, loff_t *ppos) |
1312 | .read = read_flush, | 1301 | { |
1313 | .write = write_flush, | 1302 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; |
1303 | |||
1304 | return cache_read(filp, buf, count, ppos, cd); | ||
1305 | } | ||
1306 | |||
1307 | static ssize_t cache_write_procfs(struct file *filp, const char __user *buf, | ||
1308 | size_t count, loff_t *ppos) | ||
1309 | { | ||
1310 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | ||
1311 | |||
1312 | return cache_write(filp, buf, count, ppos, cd); | ||
1313 | } | ||
1314 | |||
1315 | static unsigned int cache_poll_procfs(struct file *filp, poll_table *wait) | ||
1316 | { | ||
1317 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | ||
1318 | |||
1319 | return cache_poll(filp, wait, cd); | ||
1320 | } | ||
1321 | |||
1322 | static int cache_ioctl_procfs(struct inode *inode, struct file *filp, | ||
1323 | unsigned int cmd, unsigned long arg) | ||
1324 | { | ||
1325 | struct cache_detail *cd = PDE(inode)->data; | ||
1326 | |||
1327 | return cache_ioctl(inode, filp, cmd, arg, cd); | ||
1328 | } | ||
1329 | |||
1330 | static int cache_open_procfs(struct inode *inode, struct file *filp) | ||
1331 | { | ||
1332 | struct cache_detail *cd = PDE(inode)->data; | ||
1333 | |||
1334 | return cache_open(inode, filp, cd); | ||
1335 | } | ||
1336 | |||
1337 | static int cache_release_procfs(struct inode *inode, struct file *filp) | ||
1338 | { | ||
1339 | struct cache_detail *cd = PDE(inode)->data; | ||
1340 | |||
1341 | return cache_release(inode, filp, cd); | ||
1342 | } | ||
1343 | |||
1344 | static const struct file_operations cache_file_operations_procfs = { | ||
1345 | .owner = THIS_MODULE, | ||
1346 | .llseek = no_llseek, | ||
1347 | .read = cache_read_procfs, | ||
1348 | .write = cache_write_procfs, | ||
1349 | .poll = cache_poll_procfs, | ||
1350 | .ioctl = cache_ioctl_procfs, /* for FIONREAD */ | ||
1351 | .open = cache_open_procfs, | ||
1352 | .release = cache_release_procfs, | ||
1314 | }; | 1353 | }; |
1354 | |||
1355 | static int content_open_procfs(struct inode *inode, struct file *filp) | ||
1356 | { | ||
1357 | struct cache_detail *cd = PDE(inode)->data; | ||
1358 | |||
1359 | return content_open(inode, filp, cd); | ||
1360 | } | ||
1361 | |||
1362 | static int content_release_procfs(struct inode *inode, struct file *filp) | ||
1363 | { | ||
1364 | struct cache_detail *cd = PDE(inode)->data; | ||
1365 | |||
1366 | return content_release(inode, filp, cd); | ||
1367 | } | ||
1368 | |||
1369 | static const struct file_operations content_file_operations_procfs = { | ||
1370 | .open = content_open_procfs, | ||
1371 | .read = seq_read, | ||
1372 | .llseek = seq_lseek, | ||
1373 | .release = content_release_procfs, | ||
1374 | }; | ||
1375 | |||
1376 | static int open_flush_procfs(struct inode *inode, struct file *filp) | ||
1377 | { | ||
1378 | struct cache_detail *cd = PDE(inode)->data; | ||
1379 | |||
1380 | return open_flush(inode, filp, cd); | ||
1381 | } | ||
1382 | |||
1383 | static int release_flush_procfs(struct inode *inode, struct file *filp) | ||
1384 | { | ||
1385 | struct cache_detail *cd = PDE(inode)->data; | ||
1386 | |||
1387 | return release_flush(inode, filp, cd); | ||
1388 | } | ||
1389 | |||
1390 | static ssize_t read_flush_procfs(struct file *filp, char __user *buf, | ||
1391 | size_t count, loff_t *ppos) | ||
1392 | { | ||
1393 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | ||
1394 | |||
1395 | return read_flush(filp, buf, count, ppos, cd); | ||
1396 | } | ||
1397 | |||
1398 | static ssize_t write_flush_procfs(struct file *filp, | ||
1399 | const char __user *buf, | ||
1400 | size_t count, loff_t *ppos) | ||
1401 | { | ||
1402 | struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; | ||
1403 | |||
1404 | return write_flush(filp, buf, count, ppos, cd); | ||
1405 | } | ||
1406 | |||
1407 | static const struct file_operations cache_flush_operations_procfs = { | ||
1408 | .open = open_flush_procfs, | ||
1409 | .read = read_flush_procfs, | ||
1410 | .write = write_flush_procfs, | ||
1411 | .release = release_flush_procfs, | ||
1412 | }; | ||
1413 | |||
1414 | static void remove_cache_proc_entries(struct cache_detail *cd) | ||
1415 | { | ||
1416 | if (cd->u.procfs.proc_ent == NULL) | ||
1417 | return; | ||
1418 | if (cd->u.procfs.flush_ent) | ||
1419 | remove_proc_entry("flush", cd->u.procfs.proc_ent); | ||
1420 | if (cd->u.procfs.channel_ent) | ||
1421 | remove_proc_entry("channel", cd->u.procfs.proc_ent); | ||
1422 | if (cd->u.procfs.content_ent) | ||
1423 | remove_proc_entry("content", cd->u.procfs.proc_ent); | ||
1424 | cd->u.procfs.proc_ent = NULL; | ||
1425 | remove_proc_entry(cd->name, proc_net_rpc); | ||
1426 | } | ||
1427 | |||
1428 | #ifdef CONFIG_PROC_FS | ||
1429 | static int create_cache_proc_entries(struct cache_detail *cd) | ||
1430 | { | ||
1431 | struct proc_dir_entry *p; | ||
1432 | |||
1433 | cd->u.procfs.proc_ent = proc_mkdir(cd->name, proc_net_rpc); | ||
1434 | if (cd->u.procfs.proc_ent == NULL) | ||
1435 | goto out_nomem; | ||
1436 | cd->u.procfs.channel_ent = NULL; | ||
1437 | cd->u.procfs.content_ent = NULL; | ||
1438 | |||
1439 | p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR, | ||
1440 | cd->u.procfs.proc_ent, | ||
1441 | &cache_flush_operations_procfs, cd); | ||
1442 | cd->u.procfs.flush_ent = p; | ||
1443 | if (p == NULL) | ||
1444 | goto out_nomem; | ||
1445 | |||
1446 | if (cd->cache_upcall || cd->cache_parse) { | ||
1447 | p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR, | ||
1448 | cd->u.procfs.proc_ent, | ||
1449 | &cache_file_operations_procfs, cd); | ||
1450 | cd->u.procfs.channel_ent = p; | ||
1451 | if (p == NULL) | ||
1452 | goto out_nomem; | ||
1453 | } | ||
1454 | if (cd->cache_show) { | ||
1455 | p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR, | ||
1456 | cd->u.procfs.proc_ent, | ||
1457 | &content_file_operations_procfs, cd); | ||
1458 | cd->u.procfs.content_ent = p; | ||
1459 | if (p == NULL) | ||
1460 | goto out_nomem; | ||
1461 | } | ||
1462 | return 0; | ||
1463 | out_nomem: | ||
1464 | remove_cache_proc_entries(cd); | ||
1465 | return -ENOMEM; | ||
1466 | } | ||
1467 | #else /* CONFIG_PROC_FS */ | ||
1468 | static int create_cache_proc_entries(struct cache_detail *cd) | ||
1469 | { | ||
1470 | return 0; | ||
1471 | } | ||
1472 | #endif | ||
1473 | |||
1474 | int cache_register(struct cache_detail *cd) | ||
1475 | { | ||
1476 | int ret; | ||
1477 | |||
1478 | sunrpc_init_cache_detail(cd); | ||
1479 | ret = create_cache_proc_entries(cd); | ||
1480 | if (ret) | ||
1481 | sunrpc_destroy_cache_detail(cd); | ||
1482 | return ret; | ||
1483 | } | ||
1484 | EXPORT_SYMBOL_GPL(cache_register); | ||
1485 | |||
1486 | void cache_unregister(struct cache_detail *cd) | ||
1487 | { | ||
1488 | remove_cache_proc_entries(cd); | ||
1489 | sunrpc_destroy_cache_detail(cd); | ||
1490 | } | ||
1491 | EXPORT_SYMBOL_GPL(cache_unregister); | ||
1492 | |||
1493 | static ssize_t cache_read_pipefs(struct file *filp, char __user *buf, | ||
1494 | size_t count, loff_t *ppos) | ||
1495 | { | ||
1496 | struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; | ||
1497 | |||
1498 | return cache_read(filp, buf, count, ppos, cd); | ||
1499 | } | ||
1500 | |||
1501 | static ssize_t cache_write_pipefs(struct file *filp, const char __user *buf, | ||
1502 | size_t count, loff_t *ppos) | ||
1503 | { | ||
1504 | struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; | ||
1505 | |||
1506 | return cache_write(filp, buf, count, ppos, cd); | ||
1507 | } | ||
1508 | |||
1509 | static unsigned int cache_poll_pipefs(struct file *filp, poll_table *wait) | ||
1510 | { | ||
1511 | struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; | ||
1512 | |||
1513 | return cache_poll(filp, wait, cd); | ||
1514 | } | ||
1515 | |||
1516 | static int cache_ioctl_pipefs(struct inode *inode, struct file *filp, | ||
1517 | unsigned int cmd, unsigned long arg) | ||
1518 | { | ||
1519 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1520 | |||
1521 | return cache_ioctl(inode, filp, cmd, arg, cd); | ||
1522 | } | ||
1523 | |||
1524 | static int cache_open_pipefs(struct inode *inode, struct file *filp) | ||
1525 | { | ||
1526 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1527 | |||
1528 | return cache_open(inode, filp, cd); | ||
1529 | } | ||
1530 | |||
1531 | static int cache_release_pipefs(struct inode *inode, struct file *filp) | ||
1532 | { | ||
1533 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1534 | |||
1535 | return cache_release(inode, filp, cd); | ||
1536 | } | ||
1537 | |||
1538 | const struct file_operations cache_file_operations_pipefs = { | ||
1539 | .owner = THIS_MODULE, | ||
1540 | .llseek = no_llseek, | ||
1541 | .read = cache_read_pipefs, | ||
1542 | .write = cache_write_pipefs, | ||
1543 | .poll = cache_poll_pipefs, | ||
1544 | .ioctl = cache_ioctl_pipefs, /* for FIONREAD */ | ||
1545 | .open = cache_open_pipefs, | ||
1546 | .release = cache_release_pipefs, | ||
1547 | }; | ||
1548 | |||
1549 | static int content_open_pipefs(struct inode *inode, struct file *filp) | ||
1550 | { | ||
1551 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1552 | |||
1553 | return content_open(inode, filp, cd); | ||
1554 | } | ||
1555 | |||
1556 | static int content_release_pipefs(struct inode *inode, struct file *filp) | ||
1557 | { | ||
1558 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1559 | |||
1560 | return content_release(inode, filp, cd); | ||
1561 | } | ||
1562 | |||
1563 | const struct file_operations content_file_operations_pipefs = { | ||
1564 | .open = content_open_pipefs, | ||
1565 | .read = seq_read, | ||
1566 | .llseek = seq_lseek, | ||
1567 | .release = content_release_pipefs, | ||
1568 | }; | ||
1569 | |||
1570 | static int open_flush_pipefs(struct inode *inode, struct file *filp) | ||
1571 | { | ||
1572 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1573 | |||
1574 | return open_flush(inode, filp, cd); | ||
1575 | } | ||
1576 | |||
1577 | static int release_flush_pipefs(struct inode *inode, struct file *filp) | ||
1578 | { | ||
1579 | struct cache_detail *cd = RPC_I(inode)->private; | ||
1580 | |||
1581 | return release_flush(inode, filp, cd); | ||
1582 | } | ||
1583 | |||
1584 | static ssize_t read_flush_pipefs(struct file *filp, char __user *buf, | ||
1585 | size_t count, loff_t *ppos) | ||
1586 | { | ||
1587 | struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; | ||
1588 | |||
1589 | return read_flush(filp, buf, count, ppos, cd); | ||
1590 | } | ||
1591 | |||
1592 | static ssize_t write_flush_pipefs(struct file *filp, | ||
1593 | const char __user *buf, | ||
1594 | size_t count, loff_t *ppos) | ||
1595 | { | ||
1596 | struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; | ||
1597 | |||
1598 | return write_flush(filp, buf, count, ppos, cd); | ||
1599 | } | ||
1600 | |||
1601 | const struct file_operations cache_flush_operations_pipefs = { | ||
1602 | .open = open_flush_pipefs, | ||
1603 | .read = read_flush_pipefs, | ||
1604 | .write = write_flush_pipefs, | ||
1605 | .release = release_flush_pipefs, | ||
1606 | }; | ||
1607 | |||
1608 | int sunrpc_cache_register_pipefs(struct dentry *parent, | ||
1609 | const char *name, mode_t umode, | ||
1610 | struct cache_detail *cd) | ||
1611 | { | ||
1612 | struct qstr q; | ||
1613 | struct dentry *dir; | ||
1614 | int ret = 0; | ||
1615 | |||
1616 | sunrpc_init_cache_detail(cd); | ||
1617 | q.name = name; | ||
1618 | q.len = strlen(name); | ||
1619 | q.hash = full_name_hash(q.name, q.len); | ||
1620 | dir = rpc_create_cache_dir(parent, &q, umode, cd); | ||
1621 | if (!IS_ERR(dir)) | ||
1622 | cd->u.pipefs.dir = dir; | ||
1623 | else { | ||
1624 | sunrpc_destroy_cache_detail(cd); | ||
1625 | ret = PTR_ERR(dir); | ||
1626 | } | ||
1627 | return ret; | ||
1628 | } | ||
1629 | EXPORT_SYMBOL_GPL(sunrpc_cache_register_pipefs); | ||
1630 | |||
1631 | void sunrpc_cache_unregister_pipefs(struct cache_detail *cd) | ||
1632 | { | ||
1633 | rpc_remove_cache_dir(cd->u.pipefs.dir); | ||
1634 | cd->u.pipefs.dir = NULL; | ||
1635 | sunrpc_destroy_cache_detail(cd); | ||
1636 | } | ||
1637 | EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs); | ||
1638 | |||
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c index df1039f077c2..fac0ca93f06b 100644 --- a/net/sunrpc/clnt.c +++ b/net/sunrpc/clnt.c | |||
@@ -27,6 +27,8 @@ | |||
27 | #include <linux/types.h> | 27 | #include <linux/types.h> |
28 | #include <linux/kallsyms.h> | 28 | #include <linux/kallsyms.h> |
29 | #include <linux/mm.h> | 29 | #include <linux/mm.h> |
30 | #include <linux/namei.h> | ||
31 | #include <linux/mount.h> | ||
30 | #include <linux/slab.h> | 32 | #include <linux/slab.h> |
31 | #include <linux/utsname.h> | 33 | #include <linux/utsname.h> |
32 | #include <linux/workqueue.h> | 34 | #include <linux/workqueue.h> |
@@ -97,33 +99,49 @@ static int | |||
97 | rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name) | 99 | rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name) |
98 | { | 100 | { |
99 | static uint32_t clntid; | 101 | static uint32_t clntid; |
102 | struct nameidata nd; | ||
103 | struct path path; | ||
104 | char name[15]; | ||
105 | struct qstr q = { | ||
106 | .name = name, | ||
107 | }; | ||
100 | int error; | 108 | int error; |
101 | 109 | ||
102 | clnt->cl_vfsmnt = ERR_PTR(-ENOENT); | 110 | clnt->cl_path.mnt = ERR_PTR(-ENOENT); |
103 | clnt->cl_dentry = ERR_PTR(-ENOENT); | 111 | clnt->cl_path.dentry = ERR_PTR(-ENOENT); |
104 | if (dir_name == NULL) | 112 | if (dir_name == NULL) |
105 | return 0; | 113 | return 0; |
106 | 114 | ||
107 | clnt->cl_vfsmnt = rpc_get_mount(); | 115 | path.mnt = rpc_get_mount(); |
108 | if (IS_ERR(clnt->cl_vfsmnt)) | 116 | if (IS_ERR(path.mnt)) |
109 | return PTR_ERR(clnt->cl_vfsmnt); | 117 | return PTR_ERR(path.mnt); |
118 | error = vfs_path_lookup(path.mnt->mnt_root, path.mnt, dir_name, 0, &nd); | ||
119 | if (error) | ||
120 | goto err; | ||
110 | 121 | ||
111 | for (;;) { | 122 | for (;;) { |
112 | snprintf(clnt->cl_pathname, sizeof(clnt->cl_pathname), | 123 | q.len = snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++); |
113 | "%s/clnt%x", dir_name, | 124 | name[sizeof(name) - 1] = '\0'; |
114 | (unsigned int)clntid++); | 125 | q.hash = full_name_hash(q.name, q.len); |
115 | clnt->cl_pathname[sizeof(clnt->cl_pathname) - 1] = '\0'; | 126 | path.dentry = rpc_create_client_dir(nd.path.dentry, &q, clnt); |
116 | clnt->cl_dentry = rpc_mkdir(clnt->cl_pathname, clnt); | 127 | if (!IS_ERR(path.dentry)) |
117 | if (!IS_ERR(clnt->cl_dentry)) | 128 | break; |
118 | return 0; | 129 | error = PTR_ERR(path.dentry); |
119 | error = PTR_ERR(clnt->cl_dentry); | ||
120 | if (error != -EEXIST) { | 130 | if (error != -EEXIST) { |
121 | printk(KERN_INFO "RPC: Couldn't create pipefs entry %s, error %d\n", | 131 | printk(KERN_INFO "RPC: Couldn't create pipefs entry" |
122 | clnt->cl_pathname, error); | 132 | " %s/%s, error %d\n", |
123 | rpc_put_mount(); | 133 | dir_name, name, error); |
124 | return error; | 134 | goto err_path_put; |
125 | } | 135 | } |
126 | } | 136 | } |
137 | path_put(&nd.path); | ||
138 | clnt->cl_path = path; | ||
139 | return 0; | ||
140 | err_path_put: | ||
141 | path_put(&nd.path); | ||
142 | err: | ||
143 | rpc_put_mount(); | ||
144 | return error; | ||
127 | } | 145 | } |
128 | 146 | ||
129 | static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt) | 147 | static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt) |
@@ -231,8 +249,8 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, stru | |||
231 | return clnt; | 249 | return clnt; |
232 | 250 | ||
233 | out_no_auth: | 251 | out_no_auth: |
234 | if (!IS_ERR(clnt->cl_dentry)) { | 252 | if (!IS_ERR(clnt->cl_path.dentry)) { |
235 | rpc_rmdir(clnt->cl_dentry); | 253 | rpc_remove_client_dir(clnt->cl_path.dentry); |
236 | rpc_put_mount(); | 254 | rpc_put_mount(); |
237 | } | 255 | } |
238 | out_no_path: | 256 | out_no_path: |
@@ -423,8 +441,8 @@ rpc_free_client(struct kref *kref) | |||
423 | 441 | ||
424 | dprintk("RPC: destroying %s client for %s\n", | 442 | dprintk("RPC: destroying %s client for %s\n", |
425 | clnt->cl_protname, clnt->cl_server); | 443 | clnt->cl_protname, clnt->cl_server); |
426 | if (!IS_ERR(clnt->cl_dentry)) { | 444 | if (!IS_ERR(clnt->cl_path.dentry)) { |
427 | rpc_rmdir(clnt->cl_dentry); | 445 | rpc_remove_client_dir(clnt->cl_path.dentry); |
428 | rpc_put_mount(); | 446 | rpc_put_mount(); |
429 | } | 447 | } |
430 | if (clnt->cl_parent != clnt) { | 448 | if (clnt->cl_parent != clnt) { |
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c index 9ced0628d69c..7f676bdf70d3 100644 --- a/net/sunrpc/rpc_pipe.c +++ b/net/sunrpc/rpc_pipe.c | |||
@@ -26,6 +26,7 @@ | |||
26 | #include <linux/sunrpc/clnt.h> | 26 | #include <linux/sunrpc/clnt.h> |
27 | #include <linux/workqueue.h> | 27 | #include <linux/workqueue.h> |
28 | #include <linux/sunrpc/rpc_pipe_fs.h> | 28 | #include <linux/sunrpc/rpc_pipe_fs.h> |
29 | #include <linux/sunrpc/cache.h> | ||
29 | 30 | ||
30 | static struct vfsmount *rpc_mount __read_mostly; | 31 | static struct vfsmount *rpc_mount __read_mostly; |
31 | static int rpc_mount_count; | 32 | static int rpc_mount_count; |
@@ -125,7 +126,7 @@ static void | |||
125 | rpc_close_pipes(struct inode *inode) | 126 | rpc_close_pipes(struct inode *inode) |
126 | { | 127 | { |
127 | struct rpc_inode *rpci = RPC_I(inode); | 128 | struct rpc_inode *rpci = RPC_I(inode); |
128 | struct rpc_pipe_ops *ops; | 129 | const struct rpc_pipe_ops *ops; |
129 | int need_release; | 130 | int need_release; |
130 | 131 | ||
131 | mutex_lock(&inode->i_mutex); | 132 | mutex_lock(&inode->i_mutex); |
@@ -398,66 +399,12 @@ static const struct file_operations rpc_info_operations = { | |||
398 | 399 | ||
399 | 400 | ||
400 | /* | 401 | /* |
401 | * We have a single directory with 1 node in it. | ||
402 | */ | ||
403 | enum { | ||
404 | RPCAUTH_Root = 1, | ||
405 | RPCAUTH_lockd, | ||
406 | RPCAUTH_mount, | ||
407 | RPCAUTH_nfs, | ||
408 | RPCAUTH_portmap, | ||
409 | RPCAUTH_statd, | ||
410 | RPCAUTH_nfsd4_cb, | ||
411 | RPCAUTH_RootEOF | ||
412 | }; | ||
413 | |||
414 | /* | ||
415 | * Description of fs contents. | 402 | * Description of fs contents. |
416 | */ | 403 | */ |
417 | struct rpc_filelist { | 404 | struct rpc_filelist { |
418 | char *name; | 405 | const char *name; |
419 | const struct file_operations *i_fop; | 406 | const struct file_operations *i_fop; |
420 | int mode; | 407 | umode_t mode; |
421 | }; | ||
422 | |||
423 | static struct rpc_filelist files[] = { | ||
424 | [RPCAUTH_lockd] = { | ||
425 | .name = "lockd", | ||
426 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
427 | }, | ||
428 | [RPCAUTH_mount] = { | ||
429 | .name = "mount", | ||
430 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
431 | }, | ||
432 | [RPCAUTH_nfs] = { | ||
433 | .name = "nfs", | ||
434 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
435 | }, | ||
436 | [RPCAUTH_portmap] = { | ||
437 | .name = "portmap", | ||
438 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
439 | }, | ||
440 | [RPCAUTH_statd] = { | ||
441 | .name = "statd", | ||
442 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
443 | }, | ||
444 | [RPCAUTH_nfsd4_cb] = { | ||
445 | .name = "nfsd4_cb", | ||
446 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
447 | }, | ||
448 | }; | ||
449 | |||
450 | enum { | ||
451 | RPCAUTH_info = 2, | ||
452 | RPCAUTH_EOF | ||
453 | }; | ||
454 | |||
455 | static struct rpc_filelist authfiles[] = { | ||
456 | [RPCAUTH_info] = { | ||
457 | .name = "info", | ||
458 | .i_fop = &rpc_info_operations, | ||
459 | .mode = S_IFREG | S_IRUSR, | ||
460 | }, | ||
461 | }; | 408 | }; |
462 | 409 | ||
463 | struct vfsmount *rpc_get_mount(void) | 410 | struct vfsmount *rpc_get_mount(void) |
@@ -469,11 +416,13 @@ struct vfsmount *rpc_get_mount(void) | |||
469 | return ERR_PTR(err); | 416 | return ERR_PTR(err); |
470 | return rpc_mount; | 417 | return rpc_mount; |
471 | } | 418 | } |
419 | EXPORT_SYMBOL_GPL(rpc_get_mount); | ||
472 | 420 | ||
473 | void rpc_put_mount(void) | 421 | void rpc_put_mount(void) |
474 | { | 422 | { |
475 | simple_release_fs(&rpc_mount, &rpc_mount_count); | 423 | simple_release_fs(&rpc_mount, &rpc_mount_count); |
476 | } | 424 | } |
425 | EXPORT_SYMBOL_GPL(rpc_put_mount); | ||
477 | 426 | ||
478 | static int rpc_delete_dentry(struct dentry *dentry) | 427 | static int rpc_delete_dentry(struct dentry *dentry) |
479 | { | 428 | { |
@@ -484,39 +433,8 @@ static const struct dentry_operations rpc_dentry_operations = { | |||
484 | .d_delete = rpc_delete_dentry, | 433 | .d_delete = rpc_delete_dentry, |
485 | }; | 434 | }; |
486 | 435 | ||
487 | static int | ||
488 | rpc_lookup_parent(char *path, struct nameidata *nd) | ||
489 | { | ||
490 | struct vfsmount *mnt; | ||
491 | |||
492 | if (path[0] == '\0') | ||
493 | return -ENOENT; | ||
494 | |||
495 | mnt = rpc_get_mount(); | ||
496 | if (IS_ERR(mnt)) { | ||
497 | printk(KERN_WARNING "%s: %s failed to mount " | ||
498 | "pseudofilesystem \n", __FILE__, __func__); | ||
499 | return PTR_ERR(mnt); | ||
500 | } | ||
501 | |||
502 | if (vfs_path_lookup(mnt->mnt_root, mnt, path, LOOKUP_PARENT, nd)) { | ||
503 | printk(KERN_WARNING "%s: %s failed to find path %s\n", | ||
504 | __FILE__, __func__, path); | ||
505 | rpc_put_mount(); | ||
506 | return -ENOENT; | ||
507 | } | ||
508 | return 0; | ||
509 | } | ||
510 | |||
511 | static void | ||
512 | rpc_release_path(struct nameidata *nd) | ||
513 | { | ||
514 | path_put(&nd->path); | ||
515 | rpc_put_mount(); | ||
516 | } | ||
517 | |||
518 | static struct inode * | 436 | static struct inode * |
519 | rpc_get_inode(struct super_block *sb, int mode) | 437 | rpc_get_inode(struct super_block *sb, umode_t mode) |
520 | { | 438 | { |
521 | struct inode *inode = new_inode(sb); | 439 | struct inode *inode = new_inode(sb); |
522 | if (!inode) | 440 | if (!inode) |
@@ -534,212 +452,274 @@ rpc_get_inode(struct super_block *sb, int mode) | |||
534 | return inode; | 452 | return inode; |
535 | } | 453 | } |
536 | 454 | ||
537 | /* | 455 | static int __rpc_create_common(struct inode *dir, struct dentry *dentry, |
538 | * FIXME: This probably has races. | 456 | umode_t mode, |
539 | */ | 457 | const struct file_operations *i_fop, |
540 | static void rpc_depopulate(struct dentry *parent, | 458 | void *private) |
541 | unsigned long start, unsigned long eof) | ||
542 | { | 459 | { |
543 | struct inode *dir = parent->d_inode; | 460 | struct inode *inode; |
544 | struct list_head *pos, *next; | ||
545 | struct dentry *dentry, *dvec[10]; | ||
546 | int n = 0; | ||
547 | 461 | ||
548 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD); | 462 | BUG_ON(!d_unhashed(dentry)); |
549 | repeat: | 463 | inode = rpc_get_inode(dir->i_sb, mode); |
550 | spin_lock(&dcache_lock); | 464 | if (!inode) |
551 | list_for_each_safe(pos, next, &parent->d_subdirs) { | 465 | goto out_err; |
552 | dentry = list_entry(pos, struct dentry, d_u.d_child); | 466 | inode->i_ino = iunique(dir->i_sb, 100); |
553 | if (!dentry->d_inode || | 467 | if (i_fop) |
554 | dentry->d_inode->i_ino < start || | 468 | inode->i_fop = i_fop; |
555 | dentry->d_inode->i_ino >= eof) | 469 | if (private) |
556 | continue; | 470 | rpc_inode_setowner(inode, private); |
557 | spin_lock(&dentry->d_lock); | 471 | d_add(dentry, inode); |
558 | if (!d_unhashed(dentry)) { | 472 | return 0; |
559 | dget_locked(dentry); | 473 | out_err: |
560 | __d_drop(dentry); | 474 | printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n", |
561 | spin_unlock(&dentry->d_lock); | 475 | __FILE__, __func__, dentry->d_name.name); |
562 | dvec[n++] = dentry; | 476 | dput(dentry); |
563 | if (n == ARRAY_SIZE(dvec)) | 477 | return -ENOMEM; |
564 | break; | ||
565 | } else | ||
566 | spin_unlock(&dentry->d_lock); | ||
567 | } | ||
568 | spin_unlock(&dcache_lock); | ||
569 | if (n) { | ||
570 | do { | ||
571 | dentry = dvec[--n]; | ||
572 | if (S_ISREG(dentry->d_inode->i_mode)) | ||
573 | simple_unlink(dir, dentry); | ||
574 | else if (S_ISDIR(dentry->d_inode->i_mode)) | ||
575 | simple_rmdir(dir, dentry); | ||
576 | d_delete(dentry); | ||
577 | dput(dentry); | ||
578 | } while (n); | ||
579 | goto repeat; | ||
580 | } | ||
581 | mutex_unlock(&dir->i_mutex); | ||
582 | } | 478 | } |
583 | 479 | ||
584 | static int | 480 | static int __rpc_create(struct inode *dir, struct dentry *dentry, |
585 | rpc_populate(struct dentry *parent, | 481 | umode_t mode, |
586 | struct rpc_filelist *files, | 482 | const struct file_operations *i_fop, |
587 | int start, int eof) | 483 | void *private) |
588 | { | 484 | { |
589 | struct inode *inode, *dir = parent->d_inode; | 485 | int err; |
590 | void *private = RPC_I(dir)->private; | ||
591 | struct dentry *dentry; | ||
592 | int mode, i; | ||
593 | 486 | ||
594 | mutex_lock(&dir->i_mutex); | 487 | err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private); |
595 | for (i = start; i < eof; i++) { | 488 | if (err) |
596 | dentry = d_alloc_name(parent, files[i].name); | 489 | return err; |
597 | if (!dentry) | 490 | fsnotify_create(dir, dentry); |
598 | goto out_bad; | ||
599 | dentry->d_op = &rpc_dentry_operations; | ||
600 | mode = files[i].mode; | ||
601 | inode = rpc_get_inode(dir->i_sb, mode); | ||
602 | if (!inode) { | ||
603 | dput(dentry); | ||
604 | goto out_bad; | ||
605 | } | ||
606 | inode->i_ino = i; | ||
607 | if (files[i].i_fop) | ||
608 | inode->i_fop = files[i].i_fop; | ||
609 | if (private) | ||
610 | rpc_inode_setowner(inode, private); | ||
611 | if (S_ISDIR(mode)) | ||
612 | inc_nlink(dir); | ||
613 | d_add(dentry, inode); | ||
614 | fsnotify_create(dir, dentry); | ||
615 | } | ||
616 | mutex_unlock(&dir->i_mutex); | ||
617 | return 0; | 491 | return 0; |
618 | out_bad: | ||
619 | mutex_unlock(&dir->i_mutex); | ||
620 | printk(KERN_WARNING "%s: %s failed to populate directory %s\n", | ||
621 | __FILE__, __func__, parent->d_name.name); | ||
622 | return -ENOMEM; | ||
623 | } | 492 | } |
624 | 493 | ||
625 | static int | 494 | static int __rpc_mkdir(struct inode *dir, struct dentry *dentry, |
626 | __rpc_mkdir(struct inode *dir, struct dentry *dentry) | 495 | umode_t mode, |
496 | const struct file_operations *i_fop, | ||
497 | void *private) | ||
627 | { | 498 | { |
628 | struct inode *inode; | 499 | int err; |
629 | 500 | ||
630 | inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO); | 501 | err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private); |
631 | if (!inode) | 502 | if (err) |
632 | goto out_err; | 503 | return err; |
633 | inode->i_ino = iunique(dir->i_sb, 100); | ||
634 | d_instantiate(dentry, inode); | ||
635 | inc_nlink(dir); | 504 | inc_nlink(dir); |
636 | fsnotify_mkdir(dir, dentry); | 505 | fsnotify_mkdir(dir, dentry); |
637 | return 0; | 506 | return 0; |
638 | out_err: | ||
639 | printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n", | ||
640 | __FILE__, __func__, dentry->d_name.name); | ||
641 | return -ENOMEM; | ||
642 | } | 507 | } |
643 | 508 | ||
644 | static int | 509 | static int __rpc_mkpipe(struct inode *dir, struct dentry *dentry, |
645 | __rpc_rmdir(struct inode *dir, struct dentry *dentry) | 510 | umode_t mode, |
511 | const struct file_operations *i_fop, | ||
512 | void *private, | ||
513 | const struct rpc_pipe_ops *ops, | ||
514 | int flags) | ||
646 | { | 515 | { |
647 | int error; | 516 | struct rpc_inode *rpci; |
648 | error = simple_rmdir(dir, dentry); | 517 | int err; |
649 | if (!error) | 518 | |
650 | d_delete(dentry); | 519 | err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private); |
651 | return error; | 520 | if (err) |
521 | return err; | ||
522 | rpci = RPC_I(dentry->d_inode); | ||
523 | rpci->nkern_readwriters = 1; | ||
524 | rpci->private = private; | ||
525 | rpci->flags = flags; | ||
526 | rpci->ops = ops; | ||
527 | fsnotify_create(dir, dentry); | ||
528 | return 0; | ||
652 | } | 529 | } |
653 | 530 | ||
654 | static struct dentry * | 531 | static int __rpc_rmdir(struct inode *dir, struct dentry *dentry) |
655 | rpc_lookup_create(struct dentry *parent, const char *name, int len, int exclusive) | 532 | { |
533 | int ret; | ||
534 | |||
535 | dget(dentry); | ||
536 | ret = simple_rmdir(dir, dentry); | ||
537 | d_delete(dentry); | ||
538 | dput(dentry); | ||
539 | return ret; | ||
540 | } | ||
541 | |||
542 | static int __rpc_unlink(struct inode *dir, struct dentry *dentry) | ||
543 | { | ||
544 | int ret; | ||
545 | |||
546 | dget(dentry); | ||
547 | ret = simple_unlink(dir, dentry); | ||
548 | d_delete(dentry); | ||
549 | dput(dentry); | ||
550 | return ret; | ||
551 | } | ||
552 | |||
553 | static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry) | ||
554 | { | ||
555 | struct inode *inode = dentry->d_inode; | ||
556 | struct rpc_inode *rpci = RPC_I(inode); | ||
557 | |||
558 | rpci->nkern_readwriters--; | ||
559 | if (rpci->nkern_readwriters != 0) | ||
560 | return 0; | ||
561 | rpc_close_pipes(inode); | ||
562 | return __rpc_unlink(dir, dentry); | ||
563 | } | ||
564 | |||
565 | static struct dentry *__rpc_lookup_create(struct dentry *parent, | ||
566 | struct qstr *name) | ||
656 | { | 567 | { |
657 | struct inode *dir = parent->d_inode; | ||
658 | struct dentry *dentry; | 568 | struct dentry *dentry; |
659 | 569 | ||
660 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); | 570 | dentry = d_lookup(parent, name); |
661 | dentry = lookup_one_len(name, parent, len); | 571 | if (!dentry) { |
662 | if (IS_ERR(dentry)) | 572 | dentry = d_alloc(parent, name); |
663 | goto out_err; | 573 | if (!dentry) { |
574 | dentry = ERR_PTR(-ENOMEM); | ||
575 | goto out_err; | ||
576 | } | ||
577 | } | ||
664 | if (!dentry->d_inode) | 578 | if (!dentry->d_inode) |
665 | dentry->d_op = &rpc_dentry_operations; | 579 | dentry->d_op = &rpc_dentry_operations; |
666 | else if (exclusive) { | ||
667 | dput(dentry); | ||
668 | dentry = ERR_PTR(-EEXIST); | ||
669 | goto out_err; | ||
670 | } | ||
671 | return dentry; | ||
672 | out_err: | 580 | out_err: |
673 | mutex_unlock(&dir->i_mutex); | ||
674 | return dentry; | 581 | return dentry; |
675 | } | 582 | } |
676 | 583 | ||
677 | static struct dentry * | 584 | static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent, |
678 | rpc_lookup_negative(char *path, struct nameidata *nd) | 585 | struct qstr *name) |
679 | { | 586 | { |
680 | struct dentry *dentry; | 587 | struct dentry *dentry; |
681 | int error; | ||
682 | 588 | ||
683 | if ((error = rpc_lookup_parent(path, nd)) != 0) | 589 | dentry = __rpc_lookup_create(parent, name); |
684 | return ERR_PTR(error); | 590 | if (dentry->d_inode == NULL) |
685 | dentry = rpc_lookup_create(nd->path.dentry, nd->last.name, nd->last.len, | 591 | return dentry; |
686 | 1); | 592 | dput(dentry); |
687 | if (IS_ERR(dentry)) | 593 | return ERR_PTR(-EEXIST); |
688 | rpc_release_path(nd); | ||
689 | return dentry; | ||
690 | } | 594 | } |
691 | 595 | ||
692 | /** | 596 | /* |
693 | * rpc_mkdir - Create a new directory in rpc_pipefs | 597 | * FIXME: This probably has races. |
694 | * @path: path from the rpc_pipefs root to the new directory | ||
695 | * @rpc_client: rpc client to associate with this directory | ||
696 | * | ||
697 | * This creates a directory at the given @path associated with | ||
698 | * @rpc_clnt, which will contain a file named "info" with some basic | ||
699 | * information about the client, together with any "pipes" that may | ||
700 | * later be created using rpc_mkpipe(). | ||
701 | */ | 598 | */ |
702 | struct dentry * | 599 | static void __rpc_depopulate(struct dentry *parent, |
703 | rpc_mkdir(char *path, struct rpc_clnt *rpc_client) | 600 | const struct rpc_filelist *files, |
601 | int start, int eof) | ||
704 | { | 602 | { |
705 | struct nameidata nd; | 603 | struct inode *dir = parent->d_inode; |
706 | struct dentry *dentry; | 604 | struct dentry *dentry; |
707 | struct inode *dir; | 605 | struct qstr name; |
606 | int i; | ||
607 | |||
608 | for (i = start; i < eof; i++) { | ||
609 | name.name = files[i].name; | ||
610 | name.len = strlen(files[i].name); | ||
611 | name.hash = full_name_hash(name.name, name.len); | ||
612 | dentry = d_lookup(parent, &name); | ||
613 | |||
614 | if (dentry == NULL) | ||
615 | continue; | ||
616 | if (dentry->d_inode == NULL) | ||
617 | goto next; | ||
618 | switch (dentry->d_inode->i_mode & S_IFMT) { | ||
619 | default: | ||
620 | BUG(); | ||
621 | case S_IFREG: | ||
622 | __rpc_unlink(dir, dentry); | ||
623 | break; | ||
624 | case S_IFDIR: | ||
625 | __rpc_rmdir(dir, dentry); | ||
626 | } | ||
627 | next: | ||
628 | dput(dentry); | ||
629 | } | ||
630 | } | ||
631 | |||
632 | static void rpc_depopulate(struct dentry *parent, | ||
633 | const struct rpc_filelist *files, | ||
634 | int start, int eof) | ||
635 | { | ||
636 | struct inode *dir = parent->d_inode; | ||
637 | |||
638 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD); | ||
639 | __rpc_depopulate(parent, files, start, eof); | ||
640 | mutex_unlock(&dir->i_mutex); | ||
641 | } | ||
642 | |||
643 | static int rpc_populate(struct dentry *parent, | ||
644 | const struct rpc_filelist *files, | ||
645 | int start, int eof, | ||
646 | void *private) | ||
647 | { | ||
648 | struct inode *dir = parent->d_inode; | ||
649 | struct dentry *dentry; | ||
650 | int i, err; | ||
651 | |||
652 | mutex_lock(&dir->i_mutex); | ||
653 | for (i = start; i < eof; i++) { | ||
654 | struct qstr q; | ||
655 | |||
656 | q.name = files[i].name; | ||
657 | q.len = strlen(files[i].name); | ||
658 | q.hash = full_name_hash(q.name, q.len); | ||
659 | dentry = __rpc_lookup_create_exclusive(parent, &q); | ||
660 | err = PTR_ERR(dentry); | ||
661 | if (IS_ERR(dentry)) | ||
662 | goto out_bad; | ||
663 | switch (files[i].mode & S_IFMT) { | ||
664 | default: | ||
665 | BUG(); | ||
666 | case S_IFREG: | ||
667 | err = __rpc_create(dir, dentry, | ||
668 | files[i].mode, | ||
669 | files[i].i_fop, | ||
670 | private); | ||
671 | break; | ||
672 | case S_IFDIR: | ||
673 | err = __rpc_mkdir(dir, dentry, | ||
674 | files[i].mode, | ||
675 | NULL, | ||
676 | private); | ||
677 | } | ||
678 | if (err != 0) | ||
679 | goto out_bad; | ||
680 | } | ||
681 | mutex_unlock(&dir->i_mutex); | ||
682 | return 0; | ||
683 | out_bad: | ||
684 | __rpc_depopulate(parent, files, start, eof); | ||
685 | mutex_unlock(&dir->i_mutex); | ||
686 | printk(KERN_WARNING "%s: %s failed to populate directory %s\n", | ||
687 | __FILE__, __func__, parent->d_name.name); | ||
688 | return err; | ||
689 | } | ||
690 | |||
691 | static struct dentry *rpc_mkdir_populate(struct dentry *parent, | ||
692 | struct qstr *name, umode_t mode, void *private, | ||
693 | int (*populate)(struct dentry *, void *), void *args_populate) | ||
694 | { | ||
695 | struct dentry *dentry; | ||
696 | struct inode *dir = parent->d_inode; | ||
708 | int error; | 697 | int error; |
709 | 698 | ||
710 | dentry = rpc_lookup_negative(path, &nd); | 699 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); |
700 | dentry = __rpc_lookup_create_exclusive(parent, name); | ||
711 | if (IS_ERR(dentry)) | 701 | if (IS_ERR(dentry)) |
712 | return dentry; | 702 | goto out; |
713 | dir = nd.path.dentry->d_inode; | 703 | error = __rpc_mkdir(dir, dentry, mode, NULL, private); |
714 | if ((error = __rpc_mkdir(dir, dentry)) != 0) | 704 | if (error != 0) |
715 | goto err_dput; | 705 | goto out_err; |
716 | RPC_I(dentry->d_inode)->private = rpc_client; | 706 | if (populate != NULL) { |
717 | error = rpc_populate(dentry, authfiles, | 707 | error = populate(dentry, args_populate); |
718 | RPCAUTH_info, RPCAUTH_EOF); | 708 | if (error) |
719 | if (error) | 709 | goto err_rmdir; |
720 | goto err_depopulate; | 710 | } |
721 | dget(dentry); | ||
722 | out: | 711 | out: |
723 | mutex_unlock(&dir->i_mutex); | 712 | mutex_unlock(&dir->i_mutex); |
724 | rpc_release_path(&nd); | ||
725 | return dentry; | 713 | return dentry; |
726 | err_depopulate: | 714 | err_rmdir: |
727 | rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF); | ||
728 | __rpc_rmdir(dir, dentry); | 715 | __rpc_rmdir(dir, dentry); |
729 | err_dput: | 716 | out_err: |
730 | dput(dentry); | ||
731 | printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n", | ||
732 | __FILE__, __func__, path, error); | ||
733 | dentry = ERR_PTR(error); | 717 | dentry = ERR_PTR(error); |
734 | goto out; | 718 | goto out; |
735 | } | 719 | } |
736 | 720 | ||
737 | /** | 721 | static int rpc_rmdir_depopulate(struct dentry *dentry, |
738 | * rpc_rmdir - Remove a directory created with rpc_mkdir() | 722 | void (*depopulate)(struct dentry *)) |
739 | * @dentry: directory to remove | ||
740 | */ | ||
741 | int | ||
742 | rpc_rmdir(struct dentry *dentry) | ||
743 | { | 723 | { |
744 | struct dentry *parent; | 724 | struct dentry *parent; |
745 | struct inode *dir; | 725 | struct inode *dir; |
@@ -748,9 +728,9 @@ rpc_rmdir(struct dentry *dentry) | |||
748 | parent = dget_parent(dentry); | 728 | parent = dget_parent(dentry); |
749 | dir = parent->d_inode; | 729 | dir = parent->d_inode; |
750 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); | 730 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); |
751 | rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF); | 731 | if (depopulate != NULL) |
732 | depopulate(dentry); | ||
752 | error = __rpc_rmdir(dir, dentry); | 733 | error = __rpc_rmdir(dir, dentry); |
753 | dput(dentry); | ||
754 | mutex_unlock(&dir->i_mutex); | 734 | mutex_unlock(&dir->i_mutex); |
755 | dput(parent); | 735 | dput(parent); |
756 | return error; | 736 | return error; |
@@ -776,50 +756,54 @@ rpc_rmdir(struct dentry *dentry) | |||
776 | * The @private argument passed here will be available to all these methods | 756 | * The @private argument passed here will be available to all these methods |
777 | * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private. | 757 | * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private. |
778 | */ | 758 | */ |
779 | struct dentry * | 759 | struct dentry *rpc_mkpipe(struct dentry *parent, const char *name, |
780 | rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags) | 760 | void *private, const struct rpc_pipe_ops *ops, |
761 | int flags) | ||
781 | { | 762 | { |
782 | struct dentry *dentry; | 763 | struct dentry *dentry; |
783 | struct inode *dir, *inode; | 764 | struct inode *dir = parent->d_inode; |
784 | struct rpc_inode *rpci; | 765 | umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR; |
766 | struct qstr q; | ||
767 | int err; | ||
768 | |||
769 | if (ops->upcall == NULL) | ||
770 | umode &= ~S_IRUGO; | ||
771 | if (ops->downcall == NULL) | ||
772 | umode &= ~S_IWUGO; | ||
773 | |||
774 | q.name = name; | ||
775 | q.len = strlen(name); | ||
776 | q.hash = full_name_hash(q.name, q.len), | ||
785 | 777 | ||
786 | dentry = rpc_lookup_create(parent, name, strlen(name), 0); | 778 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); |
779 | dentry = __rpc_lookup_create(parent, &q); | ||
787 | if (IS_ERR(dentry)) | 780 | if (IS_ERR(dentry)) |
788 | return dentry; | 781 | goto out; |
789 | dir = parent->d_inode; | ||
790 | if (dentry->d_inode) { | 782 | if (dentry->d_inode) { |
791 | rpci = RPC_I(dentry->d_inode); | 783 | struct rpc_inode *rpci = RPC_I(dentry->d_inode); |
792 | if (rpci->private != private || | 784 | if (rpci->private != private || |
793 | rpci->ops != ops || | 785 | rpci->ops != ops || |
794 | rpci->flags != flags) { | 786 | rpci->flags != flags) { |
795 | dput (dentry); | 787 | dput (dentry); |
796 | dentry = ERR_PTR(-EBUSY); | 788 | err = -EBUSY; |
789 | goto out_err; | ||
797 | } | 790 | } |
798 | rpci->nkern_readwriters++; | 791 | rpci->nkern_readwriters++; |
799 | goto out; | 792 | goto out; |
800 | } | 793 | } |
801 | inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR); | 794 | |
802 | if (!inode) | 795 | err = __rpc_mkpipe(dir, dentry, umode, &rpc_pipe_fops, |
803 | goto err_dput; | 796 | private, ops, flags); |
804 | inode->i_ino = iunique(dir->i_sb, 100); | 797 | if (err) |
805 | inode->i_fop = &rpc_pipe_fops; | 798 | goto out_err; |
806 | d_instantiate(dentry, inode); | ||
807 | rpci = RPC_I(inode); | ||
808 | rpci->private = private; | ||
809 | rpci->flags = flags; | ||
810 | rpci->ops = ops; | ||
811 | rpci->nkern_readwriters = 1; | ||
812 | fsnotify_create(dir, dentry); | ||
813 | dget(dentry); | ||
814 | out: | 799 | out: |
815 | mutex_unlock(&dir->i_mutex); | 800 | mutex_unlock(&dir->i_mutex); |
816 | return dentry; | 801 | return dentry; |
817 | err_dput: | 802 | out_err: |
818 | dput(dentry); | 803 | dentry = ERR_PTR(err); |
819 | dentry = ERR_PTR(-ENOMEM); | ||
820 | printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n", | 804 | printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n", |
821 | __FILE__, __func__, parent->d_name.name, name, | 805 | __FILE__, __func__, parent->d_name.name, name, |
822 | -ENOMEM); | 806 | err); |
823 | goto out; | 807 | goto out; |
824 | } | 808 | } |
825 | EXPORT_SYMBOL_GPL(rpc_mkpipe); | 809 | EXPORT_SYMBOL_GPL(rpc_mkpipe); |
@@ -842,19 +826,107 @@ rpc_unlink(struct dentry *dentry) | |||
842 | parent = dget_parent(dentry); | 826 | parent = dget_parent(dentry); |
843 | dir = parent->d_inode; | 827 | dir = parent->d_inode; |
844 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); | 828 | mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); |
845 | if (--RPC_I(dentry->d_inode)->nkern_readwriters == 0) { | 829 | error = __rpc_rmpipe(dir, dentry); |
846 | rpc_close_pipes(dentry->d_inode); | ||
847 | error = simple_unlink(dir, dentry); | ||
848 | if (!error) | ||
849 | d_delete(dentry); | ||
850 | } | ||
851 | dput(dentry); | ||
852 | mutex_unlock(&dir->i_mutex); | 830 | mutex_unlock(&dir->i_mutex); |
853 | dput(parent); | 831 | dput(parent); |
854 | return error; | 832 | return error; |
855 | } | 833 | } |
856 | EXPORT_SYMBOL_GPL(rpc_unlink); | 834 | EXPORT_SYMBOL_GPL(rpc_unlink); |
857 | 835 | ||
836 | enum { | ||
837 | RPCAUTH_info, | ||
838 | RPCAUTH_EOF | ||
839 | }; | ||
840 | |||
841 | static const struct rpc_filelist authfiles[] = { | ||
842 | [RPCAUTH_info] = { | ||
843 | .name = "info", | ||
844 | .i_fop = &rpc_info_operations, | ||
845 | .mode = S_IFREG | S_IRUSR, | ||
846 | }, | ||
847 | }; | ||
848 | |||
849 | static int rpc_clntdir_populate(struct dentry *dentry, void *private) | ||
850 | { | ||
851 | return rpc_populate(dentry, | ||
852 | authfiles, RPCAUTH_info, RPCAUTH_EOF, | ||
853 | private); | ||
854 | } | ||
855 | |||
856 | static void rpc_clntdir_depopulate(struct dentry *dentry) | ||
857 | { | ||
858 | rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF); | ||
859 | } | ||
860 | |||
861 | /** | ||
862 | * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs | ||
863 | * @path: path from the rpc_pipefs root to the new directory | ||
864 | * @rpc_client: rpc client to associate with this directory | ||
865 | * | ||
866 | * This creates a directory at the given @path associated with | ||
867 | * @rpc_clnt, which will contain a file named "info" with some basic | ||
868 | * information about the client, together with any "pipes" that may | ||
869 | * later be created using rpc_mkpipe(). | ||
870 | */ | ||
871 | struct dentry *rpc_create_client_dir(struct dentry *dentry, | ||
872 | struct qstr *name, | ||
873 | struct rpc_clnt *rpc_client) | ||
874 | { | ||
875 | return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL, | ||
876 | rpc_clntdir_populate, rpc_client); | ||
877 | } | ||
878 | |||
879 | /** | ||
880 | * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir() | ||
881 | * @dentry: directory to remove | ||
882 | */ | ||
883 | int rpc_remove_client_dir(struct dentry *dentry) | ||
884 | { | ||
885 | return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate); | ||
886 | } | ||
887 | |||
888 | static const struct rpc_filelist cache_pipefs_files[3] = { | ||
889 | [0] = { | ||
890 | .name = "channel", | ||
891 | .i_fop = &cache_file_operations_pipefs, | ||
892 | .mode = S_IFREG|S_IRUSR|S_IWUSR, | ||
893 | }, | ||
894 | [1] = { | ||
895 | .name = "content", | ||
896 | .i_fop = &content_file_operations_pipefs, | ||
897 | .mode = S_IFREG|S_IRUSR, | ||
898 | }, | ||
899 | [2] = { | ||
900 | .name = "flush", | ||
901 | .i_fop = &cache_flush_operations_pipefs, | ||
902 | .mode = S_IFREG|S_IRUSR|S_IWUSR, | ||
903 | }, | ||
904 | }; | ||
905 | |||
906 | static int rpc_cachedir_populate(struct dentry *dentry, void *private) | ||
907 | { | ||
908 | return rpc_populate(dentry, | ||
909 | cache_pipefs_files, 0, 3, | ||
910 | private); | ||
911 | } | ||
912 | |||
913 | static void rpc_cachedir_depopulate(struct dentry *dentry) | ||
914 | { | ||
915 | rpc_depopulate(dentry, cache_pipefs_files, 0, 3); | ||
916 | } | ||
917 | |||
918 | struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name, | ||
919 | mode_t umode, struct cache_detail *cd) | ||
920 | { | ||
921 | return rpc_mkdir_populate(parent, name, umode, NULL, | ||
922 | rpc_cachedir_populate, cd); | ||
923 | } | ||
924 | |||
925 | void rpc_remove_cache_dir(struct dentry *dentry) | ||
926 | { | ||
927 | rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate); | ||
928 | } | ||
929 | |||
858 | /* | 930 | /* |
859 | * populate the filesystem | 931 | * populate the filesystem |
860 | */ | 932 | */ |
@@ -866,6 +938,51 @@ static struct super_operations s_ops = { | |||
866 | 938 | ||
867 | #define RPCAUTH_GSSMAGIC 0x67596969 | 939 | #define RPCAUTH_GSSMAGIC 0x67596969 |
868 | 940 | ||
941 | /* | ||
942 | * We have a single directory with 1 node in it. | ||
943 | */ | ||
944 | enum { | ||
945 | RPCAUTH_lockd, | ||
946 | RPCAUTH_mount, | ||
947 | RPCAUTH_nfs, | ||
948 | RPCAUTH_portmap, | ||
949 | RPCAUTH_statd, | ||
950 | RPCAUTH_nfsd4_cb, | ||
951 | RPCAUTH_cache, | ||
952 | RPCAUTH_RootEOF | ||
953 | }; | ||
954 | |||
955 | static const struct rpc_filelist files[] = { | ||
956 | [RPCAUTH_lockd] = { | ||
957 | .name = "lockd", | ||
958 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
959 | }, | ||
960 | [RPCAUTH_mount] = { | ||
961 | .name = "mount", | ||
962 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
963 | }, | ||
964 | [RPCAUTH_nfs] = { | ||
965 | .name = "nfs", | ||
966 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
967 | }, | ||
968 | [RPCAUTH_portmap] = { | ||
969 | .name = "portmap", | ||
970 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
971 | }, | ||
972 | [RPCAUTH_statd] = { | ||
973 | .name = "statd", | ||
974 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
975 | }, | ||
976 | [RPCAUTH_nfsd4_cb] = { | ||
977 | .name = "nfsd4_cb", | ||
978 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
979 | }, | ||
980 | [RPCAUTH_cache] = { | ||
981 | .name = "cache", | ||
982 | .mode = S_IFDIR | S_IRUGO | S_IXUGO, | ||
983 | }, | ||
984 | }; | ||
985 | |||
869 | static int | 986 | static int |
870 | rpc_fill_super(struct super_block *sb, void *data, int silent) | 987 | rpc_fill_super(struct super_block *sb, void *data, int silent) |
871 | { | 988 | { |
@@ -886,7 +1003,7 @@ rpc_fill_super(struct super_block *sb, void *data, int silent) | |||
886 | iput(inode); | 1003 | iput(inode); |
887 | return -ENOMEM; | 1004 | return -ENOMEM; |
888 | } | 1005 | } |
889 | if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF)) | 1006 | if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL)) |
890 | goto out; | 1007 | goto out; |
891 | sb->s_root = root; | 1008 | sb->s_root = root; |
892 | return 0; | 1009 | return 0; |
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c index beee6da33035..830faf4d9997 100644 --- a/net/sunrpc/rpcb_clnt.c +++ b/net/sunrpc/rpcb_clnt.c | |||
@@ -75,6 +75,37 @@ enum { | |||
75 | #define RPCB_OWNER_STRING "0" | 75 | #define RPCB_OWNER_STRING "0" |
76 | #define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING) | 76 | #define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING) |
77 | 77 | ||
78 | /* | ||
79 | * XDR data type sizes | ||
80 | */ | ||
81 | #define RPCB_program_sz (1) | ||
82 | #define RPCB_version_sz (1) | ||
83 | #define RPCB_protocol_sz (1) | ||
84 | #define RPCB_port_sz (1) | ||
85 | #define RPCB_boolean_sz (1) | ||
86 | |||
87 | #define RPCB_netid_sz (1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN)) | ||
88 | #define RPCB_addr_sz (1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN)) | ||
89 | #define RPCB_ownerstring_sz (1 + XDR_QUADLEN(RPCB_MAXOWNERLEN)) | ||
90 | |||
91 | /* | ||
92 | * XDR argument and result sizes | ||
93 | */ | ||
94 | #define RPCB_mappingargs_sz (RPCB_program_sz + RPCB_version_sz + \ | ||
95 | RPCB_protocol_sz + RPCB_port_sz) | ||
96 | #define RPCB_getaddrargs_sz (RPCB_program_sz + RPCB_version_sz + \ | ||
97 | RPCB_netid_sz + RPCB_addr_sz + \ | ||
98 | RPCB_ownerstring_sz) | ||
99 | |||
100 | #define RPCB_getportres_sz RPCB_port_sz | ||
101 | #define RPCB_setres_sz RPCB_boolean_sz | ||
102 | |||
103 | /* | ||
104 | * Note that RFC 1833 does not put any size restrictions on the | ||
105 | * address string returned by the remote rpcbind database. | ||
106 | */ | ||
107 | #define RPCB_getaddrres_sz RPCB_addr_sz | ||
108 | |||
78 | static void rpcb_getport_done(struct rpc_task *, void *); | 109 | static void rpcb_getport_done(struct rpc_task *, void *); |
79 | static void rpcb_map_release(void *data); | 110 | static void rpcb_map_release(void *data); |
80 | static struct rpc_program rpcb_program; | 111 | static struct rpc_program rpcb_program; |
@@ -122,6 +153,7 @@ static void rpcb_map_release(void *data) | |||
122 | 153 | ||
123 | rpcb_wake_rpcbind_waiters(map->r_xprt, map->r_status); | 154 | rpcb_wake_rpcbind_waiters(map->r_xprt, map->r_status); |
124 | xprt_put(map->r_xprt); | 155 | xprt_put(map->r_xprt); |
156 | kfree(map->r_addr); | ||
125 | kfree(map); | 157 | kfree(map); |
126 | } | 158 | } |
127 | 159 | ||
@@ -268,12 +300,9 @@ static int rpcb_register_inet4(const struct sockaddr *sap, | |||
268 | const struct sockaddr_in *sin = (const struct sockaddr_in *)sap; | 300 | const struct sockaddr_in *sin = (const struct sockaddr_in *)sap; |
269 | struct rpcbind_args *map = msg->rpc_argp; | 301 | struct rpcbind_args *map = msg->rpc_argp; |
270 | unsigned short port = ntohs(sin->sin_port); | 302 | unsigned short port = ntohs(sin->sin_port); |
271 | char buf[32]; | 303 | int result; |
272 | 304 | ||
273 | /* Construct AF_INET universal address */ | 305 | map->r_addr = rpc_sockaddr2uaddr(sap); |
274 | snprintf(buf, sizeof(buf), "%pI4.%u.%u", | ||
275 | &sin->sin_addr.s_addr, port >> 8, port & 0xff); | ||
276 | map->r_addr = buf; | ||
277 | 306 | ||
278 | dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with " | 307 | dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with " |
279 | "local rpcbind\n", (port ? "" : "un"), | 308 | "local rpcbind\n", (port ? "" : "un"), |
@@ -284,7 +313,9 @@ static int rpcb_register_inet4(const struct sockaddr *sap, | |||
284 | if (port) | 313 | if (port) |
285 | msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET]; | 314 | msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET]; |
286 | 315 | ||
287 | return rpcb_register_call(RPCBVERS_4, msg); | 316 | result = rpcb_register_call(RPCBVERS_4, msg); |
317 | kfree(map->r_addr); | ||
318 | return result; | ||
288 | } | 319 | } |
289 | 320 | ||
290 | /* | 321 | /* |
@@ -296,16 +327,9 @@ static int rpcb_register_inet6(const struct sockaddr *sap, | |||
296 | const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap; | 327 | const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap; |
297 | struct rpcbind_args *map = msg->rpc_argp; | 328 | struct rpcbind_args *map = msg->rpc_argp; |
298 | unsigned short port = ntohs(sin6->sin6_port); | 329 | unsigned short port = ntohs(sin6->sin6_port); |
299 | char buf[64]; | 330 | int result; |
300 | 331 | ||
301 | /* Construct AF_INET6 universal address */ | 332 | map->r_addr = rpc_sockaddr2uaddr(sap); |
302 | if (ipv6_addr_any(&sin6->sin6_addr)) | ||
303 | snprintf(buf, sizeof(buf), "::.%u.%u", | ||
304 | port >> 8, port & 0xff); | ||
305 | else | ||
306 | snprintf(buf, sizeof(buf), "%pI6.%u.%u", | ||
307 | &sin6->sin6_addr, port >> 8, port & 0xff); | ||
308 | map->r_addr = buf; | ||
309 | 333 | ||
310 | dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with " | 334 | dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with " |
311 | "local rpcbind\n", (port ? "" : "un"), | 335 | "local rpcbind\n", (port ? "" : "un"), |
@@ -316,7 +340,9 @@ static int rpcb_register_inet6(const struct sockaddr *sap, | |||
316 | if (port) | 340 | if (port) |
317 | msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET]; | 341 | msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET]; |
318 | 342 | ||
319 | return rpcb_register_call(RPCBVERS_4, msg); | 343 | result = rpcb_register_call(RPCBVERS_4, msg); |
344 | kfree(map->r_addr); | ||
345 | return result; | ||
320 | } | 346 | } |
321 | 347 | ||
322 | static int rpcb_unregister_all_protofamilies(struct rpc_message *msg) | 348 | static int rpcb_unregister_all_protofamilies(struct rpc_message *msg) |
@@ -428,7 +454,7 @@ int rpcb_getport_sync(struct sockaddr_in *sin, u32 prog, u32 vers, int prot) | |||
428 | struct rpc_message msg = { | 454 | struct rpc_message msg = { |
429 | .rpc_proc = &rpcb_procedures2[RPCBPROC_GETPORT], | 455 | .rpc_proc = &rpcb_procedures2[RPCBPROC_GETPORT], |
430 | .rpc_argp = &map, | 456 | .rpc_argp = &map, |
431 | .rpc_resp = &map.r_port, | 457 | .rpc_resp = &map, |
432 | }; | 458 | }; |
433 | struct rpc_clnt *rpcb_clnt; | 459 | struct rpc_clnt *rpcb_clnt; |
434 | int status; | 460 | int status; |
@@ -458,7 +484,7 @@ static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt, struct rpcbi | |||
458 | struct rpc_message msg = { | 484 | struct rpc_message msg = { |
459 | .rpc_proc = proc, | 485 | .rpc_proc = proc, |
460 | .rpc_argp = map, | 486 | .rpc_argp = map, |
461 | .rpc_resp = &map->r_port, | 487 | .rpc_resp = map, |
462 | }; | 488 | }; |
463 | struct rpc_task_setup task_setup_data = { | 489 | struct rpc_task_setup task_setup_data = { |
464 | .rpc_client = rpcb_clnt, | 490 | .rpc_client = rpcb_clnt, |
@@ -539,6 +565,7 @@ void rpcb_getport_async(struct rpc_task *task) | |||
539 | goto bailout_nofree; | 565 | goto bailout_nofree; |
540 | } | 566 | } |
541 | 567 | ||
568 | /* Parent transport's destination address */ | ||
542 | salen = rpc_peeraddr(clnt, sap, sizeof(addr)); | 569 | salen = rpc_peeraddr(clnt, sap, sizeof(addr)); |
543 | 570 | ||
544 | /* Don't ever use rpcbind v2 for AF_INET6 requests */ | 571 | /* Don't ever use rpcbind v2 for AF_INET6 requests */ |
@@ -589,11 +616,22 @@ void rpcb_getport_async(struct rpc_task *task) | |||
589 | map->r_prot = xprt->prot; | 616 | map->r_prot = xprt->prot; |
590 | map->r_port = 0; | 617 | map->r_port = 0; |
591 | map->r_xprt = xprt_get(xprt); | 618 | map->r_xprt = xprt_get(xprt); |
592 | map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID); | ||
593 | map->r_addr = rpc_peeraddr2str(rpcb_clnt, RPC_DISPLAY_UNIVERSAL_ADDR); | ||
594 | map->r_owner = ""; | ||
595 | map->r_status = -EIO; | 619 | map->r_status = -EIO; |
596 | 620 | ||
621 | switch (bind_version) { | ||
622 | case RPCBVERS_4: | ||
623 | case RPCBVERS_3: | ||
624 | map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID); | ||
625 | map->r_addr = rpc_sockaddr2uaddr(sap); | ||
626 | map->r_owner = ""; | ||
627 | break; | ||
628 | case RPCBVERS_2: | ||
629 | map->r_addr = NULL; | ||
630 | break; | ||
631 | default: | ||
632 | BUG(); | ||
633 | } | ||
634 | |||
597 | child = rpcb_call_async(rpcb_clnt, map, proc); | 635 | child = rpcb_call_async(rpcb_clnt, map, proc); |
598 | rpc_release_client(rpcb_clnt); | 636 | rpc_release_client(rpcb_clnt); |
599 | if (IS_ERR(child)) { | 637 | if (IS_ERR(child)) { |
@@ -656,176 +694,278 @@ static void rpcb_getport_done(struct rpc_task *child, void *data) | |||
656 | * XDR functions for rpcbind | 694 | * XDR functions for rpcbind |
657 | */ | 695 | */ |
658 | 696 | ||
659 | static int rpcb_encode_mapping(struct rpc_rqst *req, __be32 *p, | 697 | static int rpcb_enc_mapping(struct rpc_rqst *req, __be32 *p, |
660 | struct rpcbind_args *rpcb) | 698 | const struct rpcbind_args *rpcb) |
661 | { | 699 | { |
662 | dprintk("RPC: encoding rpcb request (%u, %u, %d, %u)\n", | 700 | struct rpc_task *task = req->rq_task; |
701 | struct xdr_stream xdr; | ||
702 | |||
703 | dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n", | ||
704 | task->tk_pid, task->tk_msg.rpc_proc->p_name, | ||
663 | rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port); | 705 | rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port); |
706 | |||
707 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | ||
708 | |||
709 | p = xdr_reserve_space(&xdr, sizeof(__be32) * RPCB_mappingargs_sz); | ||
710 | if (unlikely(p == NULL)) | ||
711 | return -EIO; | ||
712 | |||
664 | *p++ = htonl(rpcb->r_prog); | 713 | *p++ = htonl(rpcb->r_prog); |
665 | *p++ = htonl(rpcb->r_vers); | 714 | *p++ = htonl(rpcb->r_vers); |
666 | *p++ = htonl(rpcb->r_prot); | 715 | *p++ = htonl(rpcb->r_prot); |
667 | *p++ = htonl(rpcb->r_port); | 716 | *p = htonl(rpcb->r_port); |
668 | 717 | ||
669 | req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); | ||
670 | return 0; | 718 | return 0; |
671 | } | 719 | } |
672 | 720 | ||
673 | static int rpcb_decode_getport(struct rpc_rqst *req, __be32 *p, | 721 | static int rpcb_dec_getport(struct rpc_rqst *req, __be32 *p, |
674 | unsigned short *portp) | 722 | struct rpcbind_args *rpcb) |
675 | { | 723 | { |
676 | *portp = (unsigned short) ntohl(*p++); | 724 | struct rpc_task *task = req->rq_task; |
677 | dprintk("RPC: rpcb getport result: %u\n", | 725 | struct xdr_stream xdr; |
678 | *portp); | 726 | unsigned long port; |
727 | |||
728 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | ||
729 | |||
730 | rpcb->r_port = 0; | ||
731 | |||
732 | p = xdr_inline_decode(&xdr, sizeof(__be32)); | ||
733 | if (unlikely(p == NULL)) | ||
734 | return -EIO; | ||
735 | |||
736 | port = ntohl(*p); | ||
737 | dprintk("RPC: %5u PMAP_%s result: %lu\n", task->tk_pid, | ||
738 | task->tk_msg.rpc_proc->p_name, port); | ||
739 | if (unlikely(port > USHORT_MAX)) | ||
740 | return -EIO; | ||
741 | |||
742 | rpcb->r_port = port; | ||
679 | return 0; | 743 | return 0; |
680 | } | 744 | } |
681 | 745 | ||
682 | static int rpcb_decode_set(struct rpc_rqst *req, __be32 *p, | 746 | static int rpcb_dec_set(struct rpc_rqst *req, __be32 *p, |
683 | unsigned int *boolp) | 747 | unsigned int *boolp) |
684 | { | 748 | { |
685 | *boolp = (unsigned int) ntohl(*p++); | 749 | struct rpc_task *task = req->rq_task; |
686 | dprintk("RPC: rpcb set/unset call %s\n", | 750 | struct xdr_stream xdr; |
751 | |||
752 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | ||
753 | |||
754 | p = xdr_inline_decode(&xdr, sizeof(__be32)); | ||
755 | if (unlikely(p == NULL)) | ||
756 | return -EIO; | ||
757 | |||
758 | *boolp = 0; | ||
759 | if (*p) | ||
760 | *boolp = 1; | ||
761 | |||
762 | dprintk("RPC: %5u RPCB_%s call %s\n", | ||
763 | task->tk_pid, task->tk_msg.rpc_proc->p_name, | ||
687 | (*boolp ? "succeeded" : "failed")); | 764 | (*boolp ? "succeeded" : "failed")); |
688 | return 0; | 765 | return 0; |
689 | } | 766 | } |
690 | 767 | ||
691 | static int rpcb_encode_getaddr(struct rpc_rqst *req, __be32 *p, | 768 | static int encode_rpcb_string(struct xdr_stream *xdr, const char *string, |
692 | struct rpcbind_args *rpcb) | 769 | const u32 maxstrlen) |
693 | { | 770 | { |
694 | dprintk("RPC: encoding rpcb request (%u, %u, %s)\n", | 771 | u32 len; |
695 | rpcb->r_prog, rpcb->r_vers, rpcb->r_addr); | 772 | __be32 *p; |
696 | *p++ = htonl(rpcb->r_prog); | ||
697 | *p++ = htonl(rpcb->r_vers); | ||
698 | 773 | ||
699 | p = xdr_encode_string(p, rpcb->r_netid); | 774 | if (unlikely(string == NULL)) |
700 | p = xdr_encode_string(p, rpcb->r_addr); | 775 | return -EIO; |
701 | p = xdr_encode_string(p, rpcb->r_owner); | 776 | len = strlen(string); |
777 | if (unlikely(len > maxstrlen)) | ||
778 | return -EIO; | ||
702 | 779 | ||
703 | req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); | 780 | p = xdr_reserve_space(xdr, sizeof(__be32) + len); |
781 | if (unlikely(p == NULL)) | ||
782 | return -EIO; | ||
783 | xdr_encode_opaque(p, string, len); | ||
704 | 784 | ||
705 | return 0; | 785 | return 0; |
706 | } | 786 | } |
707 | 787 | ||
708 | static int rpcb_decode_getaddr(struct rpc_rqst *req, __be32 *p, | 788 | static int rpcb_enc_getaddr(struct rpc_rqst *req, __be32 *p, |
709 | unsigned short *portp) | 789 | const struct rpcbind_args *rpcb) |
710 | { | 790 | { |
711 | char *addr; | 791 | struct rpc_task *task = req->rq_task; |
712 | u32 addr_len; | 792 | struct xdr_stream xdr; |
713 | int c, i, f, first, val; | ||
714 | 793 | ||
715 | *portp = 0; | 794 | dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n", |
716 | addr_len = ntohl(*p++); | 795 | task->tk_pid, task->tk_msg.rpc_proc->p_name, |
796 | rpcb->r_prog, rpcb->r_vers, | ||
797 | rpcb->r_netid, rpcb->r_addr); | ||
717 | 798 | ||
718 | if (addr_len == 0) { | 799 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); |
719 | dprintk("RPC: rpcb_decode_getaddr: " | ||
720 | "service is not registered\n"); | ||
721 | return 0; | ||
722 | } | ||
723 | 800 | ||
724 | /* | 801 | p = xdr_reserve_space(&xdr, |
725 | * Simple sanity check. | 802 | sizeof(__be32) * (RPCB_program_sz + RPCB_version_sz)); |
726 | */ | 803 | if (unlikely(p == NULL)) |
727 | if (addr_len > RPCBIND_MAXUADDRLEN) | 804 | return -EIO; |
728 | goto out_err; | 805 | *p++ = htonl(rpcb->r_prog); |
729 | 806 | *p = htonl(rpcb->r_vers); | |
730 | /* | ||
731 | * Start at the end and walk backwards until the first dot | ||
732 | * is encountered. When the second dot is found, we have | ||
733 | * both parts of the port number. | ||
734 | */ | ||
735 | addr = (char *)p; | ||
736 | val = 0; | ||
737 | first = 1; | ||
738 | f = 1; | ||
739 | for (i = addr_len - 1; i > 0; i--) { | ||
740 | c = addr[i]; | ||
741 | if (c >= '0' && c <= '9') { | ||
742 | val += (c - '0') * f; | ||
743 | f *= 10; | ||
744 | } else if (c == '.') { | ||
745 | if (first) { | ||
746 | *portp = val; | ||
747 | val = first = 0; | ||
748 | f = 1; | ||
749 | } else { | ||
750 | *portp |= (val << 8); | ||
751 | break; | ||
752 | } | ||
753 | } | ||
754 | } | ||
755 | 807 | ||
756 | /* | 808 | if (encode_rpcb_string(&xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN)) |
757 | * Simple sanity check. If we never saw a dot in the reply, | 809 | return -EIO; |
758 | * then this was probably just garbage. | 810 | if (encode_rpcb_string(&xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN)) |
759 | */ | 811 | return -EIO; |
760 | if (first) | 812 | if (encode_rpcb_string(&xdr, rpcb->r_owner, RPCB_MAXOWNERLEN)) |
761 | goto out_err; | 813 | return -EIO; |
762 | 814 | ||
763 | dprintk("RPC: rpcb_decode_getaddr port=%u\n", *portp); | ||
764 | return 0; | 815 | return 0; |
765 | |||
766 | out_err: | ||
767 | dprintk("RPC: rpcbind server returned malformed reply\n"); | ||
768 | return -EIO; | ||
769 | } | 816 | } |
770 | 817 | ||
771 | #define RPCB_program_sz (1u) | 818 | static int rpcb_dec_getaddr(struct rpc_rqst *req, __be32 *p, |
772 | #define RPCB_version_sz (1u) | 819 | struct rpcbind_args *rpcb) |
773 | #define RPCB_protocol_sz (1u) | 820 | { |
774 | #define RPCB_port_sz (1u) | 821 | struct sockaddr_storage address; |
775 | #define RPCB_boolean_sz (1u) | 822 | struct sockaddr *sap = (struct sockaddr *)&address; |
823 | struct rpc_task *task = req->rq_task; | ||
824 | struct xdr_stream xdr; | ||
825 | u32 len; | ||
776 | 826 | ||
777 | #define RPCB_netid_sz (1+XDR_QUADLEN(RPCBIND_MAXNETIDLEN)) | 827 | rpcb->r_port = 0; |
778 | #define RPCB_addr_sz (1+XDR_QUADLEN(RPCBIND_MAXUADDRLEN)) | ||
779 | #define RPCB_ownerstring_sz (1+XDR_QUADLEN(RPCB_MAXOWNERLEN)) | ||
780 | 828 | ||
781 | #define RPCB_mappingargs_sz RPCB_program_sz+RPCB_version_sz+ \ | 829 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); |
782 | RPCB_protocol_sz+RPCB_port_sz | ||
783 | #define RPCB_getaddrargs_sz RPCB_program_sz+RPCB_version_sz+ \ | ||
784 | RPCB_netid_sz+RPCB_addr_sz+ \ | ||
785 | RPCB_ownerstring_sz | ||
786 | 830 | ||
787 | #define RPCB_setres_sz RPCB_boolean_sz | 831 | p = xdr_inline_decode(&xdr, sizeof(__be32)); |
788 | #define RPCB_getportres_sz RPCB_port_sz | 832 | if (unlikely(p == NULL)) |
789 | 833 | goto out_fail; | |
790 | /* | 834 | len = ntohl(*p); |
791 | * Note that RFC 1833 does not put any size restrictions on the | ||
792 | * address string returned by the remote rpcbind database. | ||
793 | */ | ||
794 | #define RPCB_getaddrres_sz RPCB_addr_sz | ||
795 | 835 | ||
796 | #define PROC(proc, argtype, restype) \ | 836 | /* |
797 | [RPCBPROC_##proc] = { \ | 837 | * If the returned universal address is a null string, |
798 | .p_proc = RPCBPROC_##proc, \ | 838 | * the requested RPC service was not registered. |
799 | .p_encode = (kxdrproc_t) rpcb_encode_##argtype, \ | 839 | */ |
800 | .p_decode = (kxdrproc_t) rpcb_decode_##restype, \ | 840 | if (len == 0) { |
801 | .p_arglen = RPCB_##argtype##args_sz, \ | 841 | dprintk("RPC: %5u RPCB reply: program not registered\n", |
802 | .p_replen = RPCB_##restype##res_sz, \ | 842 | task->tk_pid); |
803 | .p_statidx = RPCBPROC_##proc, \ | 843 | return 0; |
804 | .p_timer = 0, \ | ||
805 | .p_name = #proc, \ | ||
806 | } | 844 | } |
807 | 845 | ||
846 | if (unlikely(len > RPCBIND_MAXUADDRLEN)) | ||
847 | goto out_fail; | ||
848 | |||
849 | p = xdr_inline_decode(&xdr, len); | ||
850 | if (unlikely(p == NULL)) | ||
851 | goto out_fail; | ||
852 | dprintk("RPC: %5u RPCB_%s reply: %s\n", task->tk_pid, | ||
853 | task->tk_msg.rpc_proc->p_name, (char *)p); | ||
854 | |||
855 | if (rpc_uaddr2sockaddr((char *)p, len, sap, sizeof(address)) == 0) | ||
856 | goto out_fail; | ||
857 | rpcb->r_port = rpc_get_port(sap); | ||
858 | |||
859 | return 0; | ||
860 | |||
861 | out_fail: | ||
862 | dprintk("RPC: %5u malformed RPCB_%s reply\n", | ||
863 | task->tk_pid, task->tk_msg.rpc_proc->p_name); | ||
864 | return -EIO; | ||
865 | } | ||
866 | |||
808 | /* | 867 | /* |
809 | * Not all rpcbind procedures described in RFC 1833 are implemented | 868 | * Not all rpcbind procedures described in RFC 1833 are implemented |
810 | * since the Linux kernel RPC code requires only these. | 869 | * since the Linux kernel RPC code requires only these. |
811 | */ | 870 | */ |
871 | |||
812 | static struct rpc_procinfo rpcb_procedures2[] = { | 872 | static struct rpc_procinfo rpcb_procedures2[] = { |
813 | PROC(SET, mapping, set), | 873 | [RPCBPROC_SET] = { |
814 | PROC(UNSET, mapping, set), | 874 | .p_proc = RPCBPROC_SET, |
815 | PROC(GETPORT, mapping, getport), | 875 | .p_encode = (kxdrproc_t)rpcb_enc_mapping, |
876 | .p_decode = (kxdrproc_t)rpcb_dec_set, | ||
877 | .p_arglen = RPCB_mappingargs_sz, | ||
878 | .p_replen = RPCB_setres_sz, | ||
879 | .p_statidx = RPCBPROC_SET, | ||
880 | .p_timer = 0, | ||
881 | .p_name = "SET", | ||
882 | }, | ||
883 | [RPCBPROC_UNSET] = { | ||
884 | .p_proc = RPCBPROC_UNSET, | ||
885 | .p_encode = (kxdrproc_t)rpcb_enc_mapping, | ||
886 | .p_decode = (kxdrproc_t)rpcb_dec_set, | ||
887 | .p_arglen = RPCB_mappingargs_sz, | ||
888 | .p_replen = RPCB_setres_sz, | ||
889 | .p_statidx = RPCBPROC_UNSET, | ||
890 | .p_timer = 0, | ||
891 | .p_name = "UNSET", | ||
892 | }, | ||
893 | [RPCBPROC_GETPORT] = { | ||
894 | .p_proc = RPCBPROC_GETPORT, | ||
895 | .p_encode = (kxdrproc_t)rpcb_enc_mapping, | ||
896 | .p_decode = (kxdrproc_t)rpcb_dec_getport, | ||
897 | .p_arglen = RPCB_mappingargs_sz, | ||
898 | .p_replen = RPCB_getportres_sz, | ||
899 | .p_statidx = RPCBPROC_GETPORT, | ||
900 | .p_timer = 0, | ||
901 | .p_name = "GETPORT", | ||
902 | }, | ||
816 | }; | 903 | }; |
817 | 904 | ||
818 | static struct rpc_procinfo rpcb_procedures3[] = { | 905 | static struct rpc_procinfo rpcb_procedures3[] = { |
819 | PROC(SET, getaddr, set), | 906 | [RPCBPROC_SET] = { |
820 | PROC(UNSET, getaddr, set), | 907 | .p_proc = RPCBPROC_SET, |
821 | PROC(GETADDR, getaddr, getaddr), | 908 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, |
909 | .p_decode = (kxdrproc_t)rpcb_dec_set, | ||
910 | .p_arglen = RPCB_getaddrargs_sz, | ||
911 | .p_replen = RPCB_setres_sz, | ||
912 | .p_statidx = RPCBPROC_SET, | ||
913 | .p_timer = 0, | ||
914 | .p_name = "SET", | ||
915 | }, | ||
916 | [RPCBPROC_UNSET] = { | ||
917 | .p_proc = RPCBPROC_UNSET, | ||
918 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, | ||
919 | .p_decode = (kxdrproc_t)rpcb_dec_set, | ||
920 | .p_arglen = RPCB_getaddrargs_sz, | ||
921 | .p_replen = RPCB_setres_sz, | ||
922 | .p_statidx = RPCBPROC_UNSET, | ||
923 | .p_timer = 0, | ||
924 | .p_name = "UNSET", | ||
925 | }, | ||
926 | [RPCBPROC_GETADDR] = { | ||
927 | .p_proc = RPCBPROC_GETADDR, | ||
928 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, | ||
929 | .p_decode = (kxdrproc_t)rpcb_dec_getaddr, | ||
930 | .p_arglen = RPCB_getaddrargs_sz, | ||
931 | .p_replen = RPCB_getaddrres_sz, | ||
932 | .p_statidx = RPCBPROC_GETADDR, | ||
933 | .p_timer = 0, | ||
934 | .p_name = "GETADDR", | ||
935 | }, | ||
822 | }; | 936 | }; |
823 | 937 | ||
824 | static struct rpc_procinfo rpcb_procedures4[] = { | 938 | static struct rpc_procinfo rpcb_procedures4[] = { |
825 | PROC(SET, getaddr, set), | 939 | [RPCBPROC_SET] = { |
826 | PROC(UNSET, getaddr, set), | 940 | .p_proc = RPCBPROC_SET, |
827 | PROC(GETADDR, getaddr, getaddr), | 941 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, |
828 | PROC(GETVERSADDR, getaddr, getaddr), | 942 | .p_decode = (kxdrproc_t)rpcb_dec_set, |
943 | .p_arglen = RPCB_getaddrargs_sz, | ||
944 | .p_replen = RPCB_setres_sz, | ||
945 | .p_statidx = RPCBPROC_SET, | ||
946 | .p_timer = 0, | ||
947 | .p_name = "SET", | ||
948 | }, | ||
949 | [RPCBPROC_UNSET] = { | ||
950 | .p_proc = RPCBPROC_UNSET, | ||
951 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, | ||
952 | .p_decode = (kxdrproc_t)rpcb_dec_set, | ||
953 | .p_arglen = RPCB_getaddrargs_sz, | ||
954 | .p_replen = RPCB_setres_sz, | ||
955 | .p_statidx = RPCBPROC_UNSET, | ||
956 | .p_timer = 0, | ||
957 | .p_name = "UNSET", | ||
958 | }, | ||
959 | [RPCBPROC_GETADDR] = { | ||
960 | .p_proc = RPCBPROC_GETADDR, | ||
961 | .p_encode = (kxdrproc_t)rpcb_enc_getaddr, | ||
962 | .p_decode = (kxdrproc_t)rpcb_dec_getaddr, | ||
963 | .p_arglen = RPCB_getaddrargs_sz, | ||
964 | .p_replen = RPCB_getaddrres_sz, | ||
965 | .p_statidx = RPCBPROC_GETADDR, | ||
966 | .p_timer = 0, | ||
967 | .p_name = "GETADDR", | ||
968 | }, | ||
829 | }; | 969 | }; |
830 | 970 | ||
831 | static struct rpcb_info rpcb_next_version[] = { | 971 | static struct rpcb_info rpcb_next_version[] = { |
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c index adaa81982f74..8cce92189019 100644 --- a/net/sunrpc/sunrpc_syms.c +++ b/net/sunrpc/sunrpc_syms.c | |||
@@ -69,5 +69,5 @@ cleanup_sunrpc(void) | |||
69 | rcu_barrier(); /* Wait for completion of call_rcu()'s */ | 69 | rcu_barrier(); /* Wait for completion of call_rcu()'s */ |
70 | } | 70 | } |
71 | MODULE_LICENSE("GPL"); | 71 | MODULE_LICENSE("GPL"); |
72 | module_init(init_sunrpc); | 72 | fs_initcall(init_sunrpc); /* Ensure we're initialised before nfs */ |
73 | module_exit(cleanup_sunrpc); | 73 | module_exit(cleanup_sunrpc); |
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c index 5c865e2d299e..6caffa34ac01 100644 --- a/net/sunrpc/svcauth_unix.c +++ b/net/sunrpc/svcauth_unix.c | |||
@@ -171,6 +171,11 @@ static void ip_map_request(struct cache_detail *cd, | |||
171 | (*bpp)[-1] = '\n'; | 171 | (*bpp)[-1] = '\n'; |
172 | } | 172 | } |
173 | 173 | ||
174 | static int ip_map_upcall(struct cache_detail *cd, struct cache_head *h) | ||
175 | { | ||
176 | return sunrpc_cache_pipe_upcall(cd, h, ip_map_request); | ||
177 | } | ||
178 | |||
174 | static struct ip_map *ip_map_lookup(char *class, struct in6_addr *addr); | 179 | static struct ip_map *ip_map_lookup(char *class, struct in6_addr *addr); |
175 | static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry); | 180 | static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry); |
176 | 181 | ||
@@ -289,7 +294,7 @@ struct cache_detail ip_map_cache = { | |||
289 | .hash_table = ip_table, | 294 | .hash_table = ip_table, |
290 | .name = "auth.unix.ip", | 295 | .name = "auth.unix.ip", |
291 | .cache_put = ip_map_put, | 296 | .cache_put = ip_map_put, |
292 | .cache_request = ip_map_request, | 297 | .cache_upcall = ip_map_upcall, |
293 | .cache_parse = ip_map_parse, | 298 | .cache_parse = ip_map_parse, |
294 | .cache_show = ip_map_show, | 299 | .cache_show = ip_map_show, |
295 | .match = ip_map_match, | 300 | .match = ip_map_match, |
@@ -523,6 +528,11 @@ static void unix_gid_request(struct cache_detail *cd, | |||
523 | (*bpp)[-1] = '\n'; | 528 | (*bpp)[-1] = '\n'; |
524 | } | 529 | } |
525 | 530 | ||
531 | static int unix_gid_upcall(struct cache_detail *cd, struct cache_head *h) | ||
532 | { | ||
533 | return sunrpc_cache_pipe_upcall(cd, h, unix_gid_request); | ||
534 | } | ||
535 | |||
526 | static struct unix_gid *unix_gid_lookup(uid_t uid); | 536 | static struct unix_gid *unix_gid_lookup(uid_t uid); |
527 | extern struct cache_detail unix_gid_cache; | 537 | extern struct cache_detail unix_gid_cache; |
528 | 538 | ||
@@ -622,7 +632,7 @@ struct cache_detail unix_gid_cache = { | |||
622 | .hash_table = gid_table, | 632 | .hash_table = gid_table, |
623 | .name = "auth.unix.gid", | 633 | .name = "auth.unix.gid", |
624 | .cache_put = unix_gid_put, | 634 | .cache_put = unix_gid_put, |
625 | .cache_request = unix_gid_request, | 635 | .cache_upcall = unix_gid_upcall, |
626 | .cache_parse = unix_gid_parse, | 636 | .cache_parse = unix_gid_parse, |
627 | .cache_show = unix_gid_show, | 637 | .cache_show = unix_gid_show, |
628 | .match = unix_gid_match, | 638 | .match = unix_gid_match, |
diff --git a/net/sunrpc/timer.c b/net/sunrpc/timer.c index 31becbf09263..dd824341c349 100644 --- a/net/sunrpc/timer.c +++ b/net/sunrpc/timer.c | |||
@@ -25,8 +25,13 @@ | |||
25 | #define RPC_RTO_INIT (HZ/5) | 25 | #define RPC_RTO_INIT (HZ/5) |
26 | #define RPC_RTO_MIN (HZ/10) | 26 | #define RPC_RTO_MIN (HZ/10) |
27 | 27 | ||
28 | void | 28 | /** |
29 | rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo) | 29 | * rpc_init_rtt - Initialize an RPC RTT estimator context |
30 | * @rt: context to initialize | ||
31 | * @timeo: initial timeout value, in jiffies | ||
32 | * | ||
33 | */ | ||
34 | void rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo) | ||
30 | { | 35 | { |
31 | unsigned long init = 0; | 36 | unsigned long init = 0; |
32 | unsigned i; | 37 | unsigned i; |
@@ -43,12 +48,16 @@ rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo) | |||
43 | } | 48 | } |
44 | EXPORT_SYMBOL_GPL(rpc_init_rtt); | 49 | EXPORT_SYMBOL_GPL(rpc_init_rtt); |
45 | 50 | ||
46 | /* | 51 | /** |
52 | * rpc_update_rtt - Update an RPC RTT estimator context | ||
53 | * @rt: context to update | ||
54 | * @timer: timer array index (request type) | ||
55 | * @m: recent actual RTT, in jiffies | ||
56 | * | ||
47 | * NB: When computing the smoothed RTT and standard deviation, | 57 | * NB: When computing the smoothed RTT and standard deviation, |
48 | * be careful not to produce negative intermediate results. | 58 | * be careful not to produce negative intermediate results. |
49 | */ | 59 | */ |
50 | void | 60 | void rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m) |
51 | rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m) | ||
52 | { | 61 | { |
53 | long *srtt, *sdrtt; | 62 | long *srtt, *sdrtt; |
54 | 63 | ||
@@ -79,21 +88,25 @@ rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m) | |||
79 | } | 88 | } |
80 | EXPORT_SYMBOL_GPL(rpc_update_rtt); | 89 | EXPORT_SYMBOL_GPL(rpc_update_rtt); |
81 | 90 | ||
82 | /* | 91 | /** |
83 | * Estimate rto for an nfs rpc sent via. an unreliable datagram. | 92 | * rpc_calc_rto - Provide an estimated timeout value |
84 | * Use the mean and mean deviation of rtt for the appropriate type of rpc | 93 | * @rt: context to use for calculation |
85 | * for the frequent rpcs and a default for the others. | 94 | * @timer: timer array index (request type) |
86 | * The justification for doing "other" this way is that these rpcs | 95 | * |
87 | * happen so infrequently that timer est. would probably be stale. | 96 | * Estimate RTO for an NFS RPC sent via an unreliable datagram. Use |
88 | * Also, since many of these rpcs are | 97 | * the mean and mean deviation of RTT for the appropriate type of RPC |
89 | * non-idempotent, a conservative timeout is desired. | 98 | * for frequently issued RPCs, and a fixed default for the others. |
99 | * | ||
100 | * The justification for doing "other" this way is that these RPCs | ||
101 | * happen so infrequently that timer estimation would probably be | ||
102 | * stale. Also, since many of these RPCs are non-idempotent, a | ||
103 | * conservative timeout is desired. | ||
104 | * | ||
90 | * getattr, lookup, | 105 | * getattr, lookup, |
91 | * read, write, commit - A+4D | 106 | * read, write, commit - A+4D |
92 | * other - timeo | 107 | * other - timeo |
93 | */ | 108 | */ |
94 | 109 | unsigned long rpc_calc_rto(struct rpc_rtt *rt, unsigned timer) | |
95 | unsigned long | ||
96 | rpc_calc_rto(struct rpc_rtt *rt, unsigned timer) | ||
97 | { | 110 | { |
98 | unsigned long res; | 111 | unsigned long res; |
99 | 112 | ||
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c index 406e26de584e..8bd690c48b69 100644 --- a/net/sunrpc/xdr.c +++ b/net/sunrpc/xdr.c | |||
@@ -24,7 +24,7 @@ xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj) | |||
24 | unsigned int quadlen = XDR_QUADLEN(obj->len); | 24 | unsigned int quadlen = XDR_QUADLEN(obj->len); |
25 | 25 | ||
26 | p[quadlen] = 0; /* zero trailing bytes */ | 26 | p[quadlen] = 0; /* zero trailing bytes */ |
27 | *p++ = htonl(obj->len); | 27 | *p++ = cpu_to_be32(obj->len); |
28 | memcpy(p, obj->data, obj->len); | 28 | memcpy(p, obj->data, obj->len); |
29 | return p + XDR_QUADLEN(obj->len); | 29 | return p + XDR_QUADLEN(obj->len); |
30 | } | 30 | } |
@@ -35,7 +35,7 @@ xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj) | |||
35 | { | 35 | { |
36 | unsigned int len; | 36 | unsigned int len; |
37 | 37 | ||
38 | if ((len = ntohl(*p++)) > XDR_MAX_NETOBJ) | 38 | if ((len = be32_to_cpu(*p++)) > XDR_MAX_NETOBJ) |
39 | return NULL; | 39 | return NULL; |
40 | obj->len = len; | 40 | obj->len = len; |
41 | obj->data = (u8 *) p; | 41 | obj->data = (u8 *) p; |
@@ -83,7 +83,7 @@ EXPORT_SYMBOL_GPL(xdr_encode_opaque_fixed); | |||
83 | */ | 83 | */ |
84 | __be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes) | 84 | __be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes) |
85 | { | 85 | { |
86 | *p++ = htonl(nbytes); | 86 | *p++ = cpu_to_be32(nbytes); |
87 | return xdr_encode_opaque_fixed(p, ptr, nbytes); | 87 | return xdr_encode_opaque_fixed(p, ptr, nbytes); |
88 | } | 88 | } |
89 | EXPORT_SYMBOL_GPL(xdr_encode_opaque); | 89 | EXPORT_SYMBOL_GPL(xdr_encode_opaque); |
@@ -101,7 +101,7 @@ xdr_decode_string_inplace(__be32 *p, char **sp, | |||
101 | { | 101 | { |
102 | u32 len; | 102 | u32 len; |
103 | 103 | ||
104 | len = ntohl(*p++); | 104 | len = be32_to_cpu(*p++); |
105 | if (len > maxlen) | 105 | if (len > maxlen) |
106 | return NULL; | 106 | return NULL; |
107 | *lenp = len; | 107 | *lenp = len; |
@@ -771,7 +771,7 @@ xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj) | |||
771 | status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj)); | 771 | status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj)); |
772 | if (status) | 772 | if (status) |
773 | return status; | 773 | return status; |
774 | *obj = ntohl(raw); | 774 | *obj = be32_to_cpu(raw); |
775 | return 0; | 775 | return 0; |
776 | } | 776 | } |
777 | EXPORT_SYMBOL_GPL(xdr_decode_word); | 777 | EXPORT_SYMBOL_GPL(xdr_decode_word); |
@@ -779,7 +779,7 @@ EXPORT_SYMBOL_GPL(xdr_decode_word); | |||
779 | int | 779 | int |
780 | xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj) | 780 | xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj) |
781 | { | 781 | { |
782 | __be32 raw = htonl(obj); | 782 | __be32 raw = cpu_to_be32(obj); |
783 | 783 | ||
784 | return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj)); | 784 | return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj)); |
785 | } | 785 | } |
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c index 1dd6123070e9..9a63f669ece4 100644 --- a/net/sunrpc/xprtrdma/transport.c +++ b/net/sunrpc/xprtrdma/transport.c | |||
@@ -168,47 +168,25 @@ static struct rpc_xprt_ops xprt_rdma_procs; /* forward reference */ | |||
168 | static void | 168 | static void |
169 | xprt_rdma_format_addresses(struct rpc_xprt *xprt) | 169 | xprt_rdma_format_addresses(struct rpc_xprt *xprt) |
170 | { | 170 | { |
171 | struct sockaddr_in *addr = (struct sockaddr_in *) | 171 | struct sockaddr *sap = (struct sockaddr *) |
172 | &rpcx_to_rdmad(xprt).addr; | 172 | &rpcx_to_rdmad(xprt).addr; |
173 | char *buf; | 173 | struct sockaddr_in *sin = (struct sockaddr_in *)sap; |
174 | char buf[64]; | ||
174 | 175 | ||
175 | buf = kzalloc(20, GFP_KERNEL); | 176 | (void)rpc_ntop(sap, buf, sizeof(buf)); |
176 | if (buf) | 177 | xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL); |
177 | snprintf(buf, 20, "%pI4", &addr->sin_addr.s_addr); | ||
178 | xprt->address_strings[RPC_DISPLAY_ADDR] = buf; | ||
179 | 178 | ||
180 | buf = kzalloc(8, GFP_KERNEL); | 179 | (void)snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap)); |
181 | if (buf) | 180 | xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL); |
182 | snprintf(buf, 8, "%u", ntohs(addr->sin_port)); | ||
183 | xprt->address_strings[RPC_DISPLAY_PORT] = buf; | ||
184 | 181 | ||
185 | xprt->address_strings[RPC_DISPLAY_PROTO] = "rdma"; | 182 | xprt->address_strings[RPC_DISPLAY_PROTO] = "rdma"; |
186 | 183 | ||
187 | buf = kzalloc(48, GFP_KERNEL); | 184 | (void)snprintf(buf, sizeof(buf), "%02x%02x%02x%02x", |
188 | if (buf) | 185 | NIPQUAD(sin->sin_addr.s_addr)); |
189 | snprintf(buf, 48, "addr=%pI4 port=%u proto=%s", | 186 | xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL); |
190 | &addr->sin_addr.s_addr, | 187 | |
191 | ntohs(addr->sin_port), "rdma"); | 188 | (void)snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap)); |
192 | xprt->address_strings[RPC_DISPLAY_ALL] = buf; | 189 | xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL); |
193 | |||
194 | buf = kzalloc(10, GFP_KERNEL); | ||
195 | if (buf) | ||
196 | snprintf(buf, 10, "%02x%02x%02x%02x", | ||
197 | NIPQUAD(addr->sin_addr.s_addr)); | ||
198 | xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf; | ||
199 | |||
200 | buf = kzalloc(8, GFP_KERNEL); | ||
201 | if (buf) | ||
202 | snprintf(buf, 8, "%4hx", ntohs(addr->sin_port)); | ||
203 | xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf; | ||
204 | |||
205 | buf = kzalloc(30, GFP_KERNEL); | ||
206 | if (buf) | ||
207 | snprintf(buf, 30, "%pI4.%u.%u", | ||
208 | &addr->sin_addr.s_addr, | ||
209 | ntohs(addr->sin_port) >> 8, | ||
210 | ntohs(addr->sin_port) & 0xff); | ||
211 | xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; | ||
212 | 190 | ||
213 | /* netid */ | 191 | /* netid */ |
214 | xprt->address_strings[RPC_DISPLAY_NETID] = "rdma"; | 192 | xprt->address_strings[RPC_DISPLAY_NETID] = "rdma"; |
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c index 83c73c4d017a..62438f3a914d 100644 --- a/net/sunrpc/xprtsock.c +++ b/net/sunrpc/xprtsock.c | |||
@@ -248,8 +248,8 @@ struct sock_xprt { | |||
248 | * Connection of transports | 248 | * Connection of transports |
249 | */ | 249 | */ |
250 | struct delayed_work connect_worker; | 250 | struct delayed_work connect_worker; |
251 | struct sockaddr_storage addr; | 251 | struct sockaddr_storage srcaddr; |
252 | unsigned short port; | 252 | unsigned short srcport; |
253 | 253 | ||
254 | /* | 254 | /* |
255 | * UDP socket buffer size parameters | 255 | * UDP socket buffer size parameters |
@@ -296,117 +296,60 @@ static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt) | |||
296 | return (struct sockaddr_in6 *) &xprt->addr; | 296 | return (struct sockaddr_in6 *) &xprt->addr; |
297 | } | 297 | } |
298 | 298 | ||
299 | static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt, | 299 | static void xs_format_common_peer_addresses(struct rpc_xprt *xprt) |
300 | const char *protocol, | ||
301 | const char *netid) | ||
302 | { | 300 | { |
303 | struct sockaddr_in *addr = xs_addr_in(xprt); | 301 | struct sockaddr *sap = xs_addr(xprt); |
304 | char *buf; | 302 | struct sockaddr_in6 *sin6; |
303 | struct sockaddr_in *sin; | ||
304 | char buf[128]; | ||
305 | 305 | ||
306 | buf = kzalloc(20, GFP_KERNEL); | 306 | (void)rpc_ntop(sap, buf, sizeof(buf)); |
307 | if (buf) { | 307 | xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL); |
308 | snprintf(buf, 20, "%pI4", &addr->sin_addr.s_addr); | ||
309 | } | ||
310 | xprt->address_strings[RPC_DISPLAY_ADDR] = buf; | ||
311 | |||
312 | buf = kzalloc(8, GFP_KERNEL); | ||
313 | if (buf) { | ||
314 | snprintf(buf, 8, "%u", | ||
315 | ntohs(addr->sin_port)); | ||
316 | } | ||
317 | xprt->address_strings[RPC_DISPLAY_PORT] = buf; | ||
318 | |||
319 | xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; | ||
320 | |||
321 | buf = kzalloc(48, GFP_KERNEL); | ||
322 | if (buf) { | ||
323 | snprintf(buf, 48, "addr=%pI4 port=%u proto=%s", | ||
324 | &addr->sin_addr.s_addr, | ||
325 | ntohs(addr->sin_port), | ||
326 | protocol); | ||
327 | } | ||
328 | xprt->address_strings[RPC_DISPLAY_ALL] = buf; | ||
329 | |||
330 | buf = kzalloc(10, GFP_KERNEL); | ||
331 | if (buf) { | ||
332 | snprintf(buf, 10, "%02x%02x%02x%02x", | ||
333 | NIPQUAD(addr->sin_addr.s_addr)); | ||
334 | } | ||
335 | xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf; | ||
336 | 308 | ||
337 | buf = kzalloc(8, GFP_KERNEL); | 309 | switch (sap->sa_family) { |
338 | if (buf) { | 310 | case AF_INET: |
339 | snprintf(buf, 8, "%4hx", | 311 | sin = xs_addr_in(xprt); |
340 | ntohs(addr->sin_port)); | 312 | (void)snprintf(buf, sizeof(buf), "%02x%02x%02x%02x", |
341 | } | 313 | NIPQUAD(sin->sin_addr.s_addr)); |
342 | xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf; | 314 | break; |
343 | 315 | case AF_INET6: | |
344 | buf = kzalloc(30, GFP_KERNEL); | 316 | sin6 = xs_addr_in6(xprt); |
345 | if (buf) { | 317 | (void)snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr); |
346 | snprintf(buf, 30, "%pI4.%u.%u", | 318 | break; |
347 | &addr->sin_addr.s_addr, | 319 | default: |
348 | ntohs(addr->sin_port) >> 8, | 320 | BUG(); |
349 | ntohs(addr->sin_port) & 0xff); | ||
350 | } | 321 | } |
351 | xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; | 322 | xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL); |
352 | |||
353 | xprt->address_strings[RPC_DISPLAY_NETID] = netid; | ||
354 | } | 323 | } |
355 | 324 | ||
356 | static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt, | 325 | static void xs_format_common_peer_ports(struct rpc_xprt *xprt) |
357 | const char *protocol, | ||
358 | const char *netid) | ||
359 | { | 326 | { |
360 | struct sockaddr_in6 *addr = xs_addr_in6(xprt); | 327 | struct sockaddr *sap = xs_addr(xprt); |
361 | char *buf; | 328 | char buf[128]; |
362 | 329 | ||
363 | buf = kzalloc(40, GFP_KERNEL); | 330 | (void)snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap)); |
364 | if (buf) { | 331 | xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL); |
365 | snprintf(buf, 40, "%pI6",&addr->sin6_addr); | ||
366 | } | ||
367 | xprt->address_strings[RPC_DISPLAY_ADDR] = buf; | ||
368 | 332 | ||
369 | buf = kzalloc(8, GFP_KERNEL); | 333 | (void)snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap)); |
370 | if (buf) { | 334 | xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL); |
371 | snprintf(buf, 8, "%u", | 335 | } |
372 | ntohs(addr->sin6_port)); | ||
373 | } | ||
374 | xprt->address_strings[RPC_DISPLAY_PORT] = buf; | ||
375 | 336 | ||
337 | static void xs_format_peer_addresses(struct rpc_xprt *xprt, | ||
338 | const char *protocol, | ||
339 | const char *netid) | ||
340 | { | ||
376 | xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; | 341 | xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; |
342 | xprt->address_strings[RPC_DISPLAY_NETID] = netid; | ||
343 | xs_format_common_peer_addresses(xprt); | ||
344 | xs_format_common_peer_ports(xprt); | ||
345 | } | ||
377 | 346 | ||
378 | buf = kzalloc(64, GFP_KERNEL); | 347 | static void xs_update_peer_port(struct rpc_xprt *xprt) |
379 | if (buf) { | 348 | { |
380 | snprintf(buf, 64, "addr=%pI6 port=%u proto=%s", | 349 | kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]); |
381 | &addr->sin6_addr, | 350 | kfree(xprt->address_strings[RPC_DISPLAY_PORT]); |
382 | ntohs(addr->sin6_port), | ||
383 | protocol); | ||
384 | } | ||
385 | xprt->address_strings[RPC_DISPLAY_ALL] = buf; | ||
386 | |||
387 | buf = kzalloc(36, GFP_KERNEL); | ||
388 | if (buf) | ||
389 | snprintf(buf, 36, "%pi6", &addr->sin6_addr); | ||
390 | |||
391 | xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf; | ||
392 | |||
393 | buf = kzalloc(8, GFP_KERNEL); | ||
394 | if (buf) { | ||
395 | snprintf(buf, 8, "%4hx", | ||
396 | ntohs(addr->sin6_port)); | ||
397 | } | ||
398 | xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf; | ||
399 | |||
400 | buf = kzalloc(50, GFP_KERNEL); | ||
401 | if (buf) { | ||
402 | snprintf(buf, 50, "%pI6.%u.%u", | ||
403 | &addr->sin6_addr, | ||
404 | ntohs(addr->sin6_port) >> 8, | ||
405 | ntohs(addr->sin6_port) & 0xff); | ||
406 | } | ||
407 | xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; | ||
408 | 351 | ||
409 | xprt->address_strings[RPC_DISPLAY_NETID] = netid; | 352 | xs_format_common_peer_ports(xprt); |
410 | } | 353 | } |
411 | 354 | ||
412 | static void xs_free_peer_addresses(struct rpc_xprt *xprt) | 355 | static void xs_free_peer_addresses(struct rpc_xprt *xprt) |
@@ -1587,25 +1530,15 @@ static unsigned short xs_get_random_port(void) | |||
1587 | */ | 1530 | */ |
1588 | static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) | 1531 | static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) |
1589 | { | 1532 | { |
1590 | struct sockaddr *addr = xs_addr(xprt); | ||
1591 | |||
1592 | dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); | 1533 | dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); |
1593 | 1534 | ||
1594 | switch (addr->sa_family) { | 1535 | rpc_set_port(xs_addr(xprt), port); |
1595 | case AF_INET: | 1536 | xs_update_peer_port(xprt); |
1596 | ((struct sockaddr_in *)addr)->sin_port = htons(port); | ||
1597 | break; | ||
1598 | case AF_INET6: | ||
1599 | ((struct sockaddr_in6 *)addr)->sin6_port = htons(port); | ||
1600 | break; | ||
1601 | default: | ||
1602 | BUG(); | ||
1603 | } | ||
1604 | } | 1537 | } |
1605 | 1538 | ||
1606 | static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock) | 1539 | static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock) |
1607 | { | 1540 | { |
1608 | unsigned short port = transport->port; | 1541 | unsigned short port = transport->srcport; |
1609 | 1542 | ||
1610 | if (port == 0 && transport->xprt.resvport) | 1543 | if (port == 0 && transport->xprt.resvport) |
1611 | port = xs_get_random_port(); | 1544 | port = xs_get_random_port(); |
@@ -1614,8 +1547,8 @@ static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket | |||
1614 | 1547 | ||
1615 | static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port) | 1548 | static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port) |
1616 | { | 1549 | { |
1617 | if (transport->port != 0) | 1550 | if (transport->srcport != 0) |
1618 | transport->port = 0; | 1551 | transport->srcport = 0; |
1619 | if (!transport->xprt.resvport) | 1552 | if (!transport->xprt.resvport) |
1620 | return 0; | 1553 | return 0; |
1621 | if (port <= xprt_min_resvport || port > xprt_max_resvport) | 1554 | if (port <= xprt_min_resvport || port > xprt_max_resvport) |
@@ -1633,7 +1566,7 @@ static int xs_bind4(struct sock_xprt *transport, struct socket *sock) | |||
1633 | unsigned short port = xs_get_srcport(transport, sock); | 1566 | unsigned short port = xs_get_srcport(transport, sock); |
1634 | unsigned short last; | 1567 | unsigned short last; |
1635 | 1568 | ||
1636 | sa = (struct sockaddr_in *)&transport->addr; | 1569 | sa = (struct sockaddr_in *)&transport->srcaddr; |
1637 | myaddr.sin_addr = sa->sin_addr; | 1570 | myaddr.sin_addr = sa->sin_addr; |
1638 | do { | 1571 | do { |
1639 | myaddr.sin_port = htons(port); | 1572 | myaddr.sin_port = htons(port); |
@@ -1642,7 +1575,7 @@ static int xs_bind4(struct sock_xprt *transport, struct socket *sock) | |||
1642 | if (port == 0) | 1575 | if (port == 0) |
1643 | break; | 1576 | break; |
1644 | if (err == 0) { | 1577 | if (err == 0) { |
1645 | transport->port = port; | 1578 | transport->srcport = port; |
1646 | break; | 1579 | break; |
1647 | } | 1580 | } |
1648 | last = port; | 1581 | last = port; |
@@ -1666,7 +1599,7 @@ static int xs_bind6(struct sock_xprt *transport, struct socket *sock) | |||
1666 | unsigned short port = xs_get_srcport(transport, sock); | 1599 | unsigned short port = xs_get_srcport(transport, sock); |
1667 | unsigned short last; | 1600 | unsigned short last; |
1668 | 1601 | ||
1669 | sa = (struct sockaddr_in6 *)&transport->addr; | 1602 | sa = (struct sockaddr_in6 *)&transport->srcaddr; |
1670 | myaddr.sin6_addr = sa->sin6_addr; | 1603 | myaddr.sin6_addr = sa->sin6_addr; |
1671 | do { | 1604 | do { |
1672 | myaddr.sin6_port = htons(port); | 1605 | myaddr.sin6_port = htons(port); |
@@ -1675,7 +1608,7 @@ static int xs_bind6(struct sock_xprt *transport, struct socket *sock) | |||
1675 | if (port == 0) | 1608 | if (port == 0) |
1676 | break; | 1609 | break; |
1677 | if (err == 0) { | 1610 | if (err == 0) { |
1678 | transport->port = port; | 1611 | transport->srcport = port; |
1679 | break; | 1612 | break; |
1680 | } | 1613 | } |
1681 | last = port; | 1614 | last = port; |
@@ -1780,8 +1713,11 @@ static void xs_udp_connect_worker4(struct work_struct *work) | |||
1780 | goto out; | 1713 | goto out; |
1781 | } | 1714 | } |
1782 | 1715 | ||
1783 | dprintk("RPC: worker connecting xprt %p to address: %s\n", | 1716 | dprintk("RPC: worker connecting xprt %p via %s to " |
1784 | xprt, xprt->address_strings[RPC_DISPLAY_ALL]); | 1717 | "%s (port %s)\n", xprt, |
1718 | xprt->address_strings[RPC_DISPLAY_PROTO], | ||
1719 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
1720 | xprt->address_strings[RPC_DISPLAY_PORT]); | ||
1785 | 1721 | ||
1786 | xs_udp_finish_connecting(xprt, sock); | 1722 | xs_udp_finish_connecting(xprt, sock); |
1787 | status = 0; | 1723 | status = 0; |
@@ -1822,8 +1758,11 @@ static void xs_udp_connect_worker6(struct work_struct *work) | |||
1822 | goto out; | 1758 | goto out; |
1823 | } | 1759 | } |
1824 | 1760 | ||
1825 | dprintk("RPC: worker connecting xprt %p to address: %s\n", | 1761 | dprintk("RPC: worker connecting xprt %p via %s to " |
1826 | xprt, xprt->address_strings[RPC_DISPLAY_ALL]); | 1762 | "%s (port %s)\n", xprt, |
1763 | xprt->address_strings[RPC_DISPLAY_PROTO], | ||
1764 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
1765 | xprt->address_strings[RPC_DISPLAY_PORT]); | ||
1827 | 1766 | ||
1828 | xs_udp_finish_connecting(xprt, sock); | 1767 | xs_udp_finish_connecting(xprt, sock); |
1829 | status = 0; | 1768 | status = 0; |
@@ -1948,8 +1887,11 @@ static void xs_tcp_setup_socket(struct rpc_xprt *xprt, | |||
1948 | goto out_eagain; | 1887 | goto out_eagain; |
1949 | } | 1888 | } |
1950 | 1889 | ||
1951 | dprintk("RPC: worker connecting xprt %p to address: %s\n", | 1890 | dprintk("RPC: worker connecting xprt %p via %s to " |
1952 | xprt, xprt->address_strings[RPC_DISPLAY_ALL]); | 1891 | "%s (port %s)\n", xprt, |
1892 | xprt->address_strings[RPC_DISPLAY_PROTO], | ||
1893 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
1894 | xprt->address_strings[RPC_DISPLAY_PORT]); | ||
1953 | 1895 | ||
1954 | status = xs_tcp_finish_connecting(xprt, sock); | 1896 | status = xs_tcp_finish_connecting(xprt, sock); |
1955 | dprintk("RPC: %p connect status %d connected %d sock state %d\n", | 1897 | dprintk("RPC: %p connect status %d connected %d sock state %d\n", |
@@ -2120,7 +2062,7 @@ static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) | |||
2120 | struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); | 2062 | struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); |
2121 | 2063 | ||
2122 | seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", | 2064 | seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", |
2123 | transport->port, | 2065 | transport->srcport, |
2124 | xprt->stat.bind_count, | 2066 | xprt->stat.bind_count, |
2125 | xprt->stat.sends, | 2067 | xprt->stat.sends, |
2126 | xprt->stat.recvs, | 2068 | xprt->stat.recvs, |
@@ -2144,7 +2086,7 @@ static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) | |||
2144 | idle_time = (long)(jiffies - xprt->last_used) / HZ; | 2086 | idle_time = (long)(jiffies - xprt->last_used) / HZ; |
2145 | 2087 | ||
2146 | seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", | 2088 | seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", |
2147 | transport->port, | 2089 | transport->srcport, |
2148 | xprt->stat.bind_count, | 2090 | xprt->stat.bind_count, |
2149 | xprt->stat.connect_count, | 2091 | xprt->stat.connect_count, |
2150 | xprt->stat.connect_time, | 2092 | xprt->stat.connect_time, |
@@ -2223,7 +2165,7 @@ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args, | |||
2223 | memcpy(&xprt->addr, args->dstaddr, args->addrlen); | 2165 | memcpy(&xprt->addr, args->dstaddr, args->addrlen); |
2224 | xprt->addrlen = args->addrlen; | 2166 | xprt->addrlen = args->addrlen; |
2225 | if (args->srcaddr) | 2167 | if (args->srcaddr) |
2226 | memcpy(&new->addr, args->srcaddr, args->addrlen); | 2168 | memcpy(&new->srcaddr, args->srcaddr, args->addrlen); |
2227 | 2169 | ||
2228 | return xprt; | 2170 | return xprt; |
2229 | } | 2171 | } |
@@ -2272,7 +2214,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args) | |||
2272 | 2214 | ||
2273 | INIT_DELAYED_WORK(&transport->connect_worker, | 2215 | INIT_DELAYED_WORK(&transport->connect_worker, |
2274 | xs_udp_connect_worker4); | 2216 | xs_udp_connect_worker4); |
2275 | xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP); | 2217 | xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP); |
2276 | break; | 2218 | break; |
2277 | case AF_INET6: | 2219 | case AF_INET6: |
2278 | if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) | 2220 | if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) |
@@ -2280,15 +2222,22 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args) | |||
2280 | 2222 | ||
2281 | INIT_DELAYED_WORK(&transport->connect_worker, | 2223 | INIT_DELAYED_WORK(&transport->connect_worker, |
2282 | xs_udp_connect_worker6); | 2224 | xs_udp_connect_worker6); |
2283 | xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6); | 2225 | xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6); |
2284 | break; | 2226 | break; |
2285 | default: | 2227 | default: |
2286 | kfree(xprt); | 2228 | kfree(xprt); |
2287 | return ERR_PTR(-EAFNOSUPPORT); | 2229 | return ERR_PTR(-EAFNOSUPPORT); |
2288 | } | 2230 | } |
2289 | 2231 | ||
2290 | dprintk("RPC: set up transport to address %s\n", | 2232 | if (xprt_bound(xprt)) |
2291 | xprt->address_strings[RPC_DISPLAY_ALL]); | 2233 | dprintk("RPC: set up xprt to %s (port %s) via %s\n", |
2234 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
2235 | xprt->address_strings[RPC_DISPLAY_PORT], | ||
2236 | xprt->address_strings[RPC_DISPLAY_PROTO]); | ||
2237 | else | ||
2238 | dprintk("RPC: set up xprt to %s (autobind) via %s\n", | ||
2239 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
2240 | xprt->address_strings[RPC_DISPLAY_PROTO]); | ||
2292 | 2241 | ||
2293 | if (try_module_get(THIS_MODULE)) | 2242 | if (try_module_get(THIS_MODULE)) |
2294 | return xprt; | 2243 | return xprt; |
@@ -2337,23 +2286,33 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args) | |||
2337 | if (((struct sockaddr_in *)addr)->sin_port != htons(0)) | 2286 | if (((struct sockaddr_in *)addr)->sin_port != htons(0)) |
2338 | xprt_set_bound(xprt); | 2287 | xprt_set_bound(xprt); |
2339 | 2288 | ||
2340 | INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4); | 2289 | INIT_DELAYED_WORK(&transport->connect_worker, |
2341 | xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP); | 2290 | xs_tcp_connect_worker4); |
2291 | xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP); | ||
2342 | break; | 2292 | break; |
2343 | case AF_INET6: | 2293 | case AF_INET6: |
2344 | if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) | 2294 | if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) |
2345 | xprt_set_bound(xprt); | 2295 | xprt_set_bound(xprt); |
2346 | 2296 | ||
2347 | INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6); | 2297 | INIT_DELAYED_WORK(&transport->connect_worker, |
2348 | xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6); | 2298 | xs_tcp_connect_worker6); |
2299 | xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6); | ||
2349 | break; | 2300 | break; |
2350 | default: | 2301 | default: |
2351 | kfree(xprt); | 2302 | kfree(xprt); |
2352 | return ERR_PTR(-EAFNOSUPPORT); | 2303 | return ERR_PTR(-EAFNOSUPPORT); |
2353 | } | 2304 | } |
2354 | 2305 | ||
2355 | dprintk("RPC: set up transport to address %s\n", | 2306 | if (xprt_bound(xprt)) |
2356 | xprt->address_strings[RPC_DISPLAY_ALL]); | 2307 | dprintk("RPC: set up xprt to %s (port %s) via %s\n", |
2308 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
2309 | xprt->address_strings[RPC_DISPLAY_PORT], | ||
2310 | xprt->address_strings[RPC_DISPLAY_PROTO]); | ||
2311 | else | ||
2312 | dprintk("RPC: set up xprt to %s (autobind) via %s\n", | ||
2313 | xprt->address_strings[RPC_DISPLAY_ADDR], | ||
2314 | xprt->address_strings[RPC_DISPLAY_PROTO]); | ||
2315 | |||
2357 | 2316 | ||
2358 | if (try_module_get(THIS_MODULE)) | 2317 | if (try_module_get(THIS_MODULE)) |
2359 | return xprt; | 2318 | return xprt; |
@@ -2412,3 +2371,55 @@ void cleanup_socket_xprt(void) | |||
2412 | xprt_unregister_transport(&xs_udp_transport); | 2371 | xprt_unregister_transport(&xs_udp_transport); |
2413 | xprt_unregister_transport(&xs_tcp_transport); | 2372 | xprt_unregister_transport(&xs_tcp_transport); |
2414 | } | 2373 | } |
2374 | |||
2375 | static int param_set_uint_minmax(const char *val, struct kernel_param *kp, | ||
2376 | unsigned int min, unsigned int max) | ||
2377 | { | ||
2378 | unsigned long num; | ||
2379 | int ret; | ||
2380 | |||
2381 | if (!val) | ||
2382 | return -EINVAL; | ||
2383 | ret = strict_strtoul(val, 0, &num); | ||
2384 | if (ret == -EINVAL || num < min || num > max) | ||
2385 | return -EINVAL; | ||
2386 | *((unsigned int *)kp->arg) = num; | ||
2387 | return 0; | ||
2388 | } | ||
2389 | |||
2390 | static int param_set_portnr(const char *val, struct kernel_param *kp) | ||
2391 | { | ||
2392 | return param_set_uint_minmax(val, kp, | ||
2393 | RPC_MIN_RESVPORT, | ||
2394 | RPC_MAX_RESVPORT); | ||
2395 | } | ||
2396 | |||
2397 | static int param_get_portnr(char *buffer, struct kernel_param *kp) | ||
2398 | { | ||
2399 | return param_get_uint(buffer, kp); | ||
2400 | } | ||
2401 | #define param_check_portnr(name, p) \ | ||
2402 | __param_check(name, p, unsigned int); | ||
2403 | |||
2404 | module_param_named(min_resvport, xprt_min_resvport, portnr, 0644); | ||
2405 | module_param_named(max_resvport, xprt_max_resvport, portnr, 0644); | ||
2406 | |||
2407 | static int param_set_slot_table_size(const char *val, struct kernel_param *kp) | ||
2408 | { | ||
2409 | return param_set_uint_minmax(val, kp, | ||
2410 | RPC_MIN_SLOT_TABLE, | ||
2411 | RPC_MAX_SLOT_TABLE); | ||
2412 | } | ||
2413 | |||
2414 | static int param_get_slot_table_size(char *buffer, struct kernel_param *kp) | ||
2415 | { | ||
2416 | return param_get_uint(buffer, kp); | ||
2417 | } | ||
2418 | #define param_check_slot_table_size(name, p) \ | ||
2419 | __param_check(name, p, unsigned int); | ||
2420 | |||
2421 | module_param_named(tcp_slot_table_entries, xprt_tcp_slot_table_entries, | ||
2422 | slot_table_size, 0644); | ||
2423 | module_param_named(udp_slot_table_entries, xprt_udp_slot_table_entries, | ||
2424 | slot_table_size, 0644); | ||
2425 | |||