blob: c484a2b6cd109e985d9ea46cd59772146e3e3e3c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002* Copyright (c) 2001 The Regents of the University of Michigan.
3* All rights reserved.
4*
5* Kendrick Smith <kmsmith@umich.edu>
6* Andy Adamson <kandros@umich.edu>
7*
8* Redistribution and use in source and binary forms, with or without
9* modification, are permitted provided that the following conditions
10* are met:
11*
12* 1. Redistributions of source code must retain the above copyright
13* notice, this list of conditions and the following disclaimer.
14* 2. Redistributions in binary form must reproduce the above copyright
15* notice, this list of conditions and the following disclaimer in the
16* documentation and/or other materials provided with the distribution.
17* 3. Neither the name of the University nor the names of its
18* contributors may be used to endorse or promote products derived
19* from this software without specific prior written permission.
20*
21* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32*
33*/
34
Dave Hansenaceaf782008-02-15 14:37:31 -080035#include <linux/file.h>
Arnd Bergmannb89f4322010-09-18 15:09:31 +020036#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
NeilBrown0964a3d2005-06-23 22:04:32 -070038#include <linux/namei.h>
Meelap Shahc2f1a552007-07-17 04:04:39 -070039#include <linux/swap.h>
Bryan Schumaker17456802011-07-13 10:50:48 -040040#include <linux/pagemap.h>
Chuck Lever7df302f2012-05-29 13:56:37 -040041#include <linux/ratelimit.h>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050042#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton59766872013-02-04 12:50:00 -050043#include <linux/sunrpc/addr.h>
Daniel Borkmann87545892014-12-10 16:33:11 +010044#include <linux/jhash.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020045#include "xdr4.h"
J. Bruce Fields06b332a2013-04-09 11:34:36 -040046#include "xdr4cb.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050047#include "vfs.h"
J. Bruce Fieldsbfa4b362012-04-25 16:49:18 -040048#include "current_stateid.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +040050#include "netns.h"
Christoph Hellwig9cf514c2014-05-05 13:11:59 +020051#include "pnfs.h"
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +040052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define NFSDDBG_FACILITY NFSDDBG_PROC
54
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050055#define all_ones {{~0,~0},~0}
56static const stateid_t one_stateid = {
57 .si_generation = ~0,
58 .si_opaque = all_ones,
59};
60static const stateid_t zero_stateid = {
61 /* all fields zero */
62};
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010063static const stateid_t currentstateid = {
64 .si_generation = 1,
65};
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050066
Andy Adamsonec6b5d72009-04-03 08:28:28 +030067static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070068
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050069#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
70#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010071#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/* forward declarations */
Jeff Laytonf9c00c32014-07-23 16:17:41 -040074static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
Trond Myklebust60116952014-07-29 21:34:06 -040075static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
J. Bruce Fields8b671b82009-02-22 14:51:34 -080077/* Locking: */
78
J. Bruce Fields8b671b82009-02-22 14:51:34 -080079/*
80 * Currently used for the del_recall_lru and file hash table. In an
81 * effort to decrease the scope of the client_mutex, this spinlock may
82 * eventually cover more:
83 */
Benny Halevycdc97502014-05-30 09:09:30 -040084static DEFINE_SPINLOCK(state_lock);
J. Bruce Fields8b671b82009-02-22 14:51:34 -080085
Jeff Laytonb401be222014-07-29 21:34:33 -040086/*
87 * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
88 * the refcount on the open stateid to drop.
89 */
90static DECLARE_WAIT_QUEUE_HEAD(close_wq);
91
Christoph Hellwigabf11352014-05-21 07:43:03 -070092static struct kmem_cache *openowner_slab;
93static struct kmem_cache *lockowner_slab;
94static struct kmem_cache *file_slab;
95static struct kmem_cache *stateid_slab;
96static struct kmem_cache *deleg_slab;
Sachin Bhamare8287f002015-04-27 14:50:14 +020097static struct kmem_cache *odstate_slab;
NeilBrowne60d4392005-06-23 22:03:01 -070098
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -040099static void free_session(struct nfsd4_session *);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800100
Julia Lawallc4cb8972015-11-21 22:57:39 +0100101static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
Christoph Hellwig0162ac22014-09-24 12:19:19 +0200102
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400103static bool is_session_dead(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800104{
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400105 return ses->se_flags & NFS4_SESSION_DEAD;
106}
107
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -0400108static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
109{
110 if (atomic_read(&ses->se_ref) > ref_held_by_me)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400111 return nfserr_jukebox;
112 ses->se_flags |= NFS4_SESSION_DEAD;
113 return nfs_ok;
114}
115
J. Bruce Fields221a6872013-04-01 22:23:49 -0400116static bool is_client_expired(struct nfs4_client *clp)
117{
118 return clp->cl_time == 0;
119}
120
J. Bruce Fields221a6872013-04-01 22:23:49 -0400121static __be32 get_client_locked(struct nfs4_client *clp)
122{
Trond Myklebust0a880a22014-07-30 08:27:10 -0400123 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
124
125 lockdep_assert_held(&nn->client_lock);
126
J. Bruce Fields221a6872013-04-01 22:23:49 -0400127 if (is_client_expired(clp))
128 return nfserr_expired;
129 atomic_inc(&clp->cl_refcount);
130 return nfs_ok;
131}
132
133/* must be called under the client_lock */
134static inline void
135renew_client_locked(struct nfs4_client *clp)
136{
137 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
138
139 if (is_client_expired(clp)) {
140 WARN_ON(1);
141 printk("%s: client (clientid %08x/%08x) already expired\n",
142 __func__,
143 clp->cl_clientid.cl_boot,
144 clp->cl_clientid.cl_id);
145 return;
146 }
147
148 dprintk("renewing client (clientid %08x/%08x)\n",
149 clp->cl_clientid.cl_boot,
150 clp->cl_clientid.cl_id);
151 list_move_tail(&clp->cl_lru, &nn->client_lru);
152 clp->cl_time = get_seconds();
153}
154
Fengguang Wuba138432013-04-16 22:14:15 -0400155static void put_client_renew_locked(struct nfs4_client *clp)
J. Bruce Fields221a6872013-04-01 22:23:49 -0400156{
Trond Myklebust0a880a22014-07-30 08:27:10 -0400157 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
158
159 lockdep_assert_held(&nn->client_lock);
160
J. Bruce Fields221a6872013-04-01 22:23:49 -0400161 if (!atomic_dec_and_test(&clp->cl_refcount))
162 return;
163 if (!is_client_expired(clp))
164 renew_client_locked(clp);
165}
166
Jeff Layton4b24ca72014-06-30 11:48:44 -0400167static void put_client_renew(struct nfs4_client *clp)
168{
169 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
170
Jeff Laytond6c249b2014-07-08 14:02:50 -0400171 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
172 return;
173 if (!is_client_expired(clp))
174 renew_client_locked(clp);
Jeff Layton4b24ca72014-06-30 11:48:44 -0400175 spin_unlock(&nn->client_lock);
176}
177
Trond Myklebustd4e19e702014-06-30 11:48:42 -0400178static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
179{
180 __be32 status;
181
182 if (is_session_dead(ses))
183 return nfserr_badsession;
184 status = get_client_locked(ses->se_client);
185 if (status)
186 return status;
187 atomic_inc(&ses->se_ref);
188 return nfs_ok;
189}
190
191static void nfsd4_put_session_locked(struct nfsd4_session *ses)
192{
193 struct nfs4_client *clp = ses->se_client;
Trond Myklebust0a880a22014-07-30 08:27:10 -0400194 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
195
196 lockdep_assert_held(&nn->client_lock);
Trond Myklebustd4e19e702014-06-30 11:48:42 -0400197
198 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
199 free_session(ses);
200 put_client_renew_locked(clp);
201}
202
203static void nfsd4_put_session(struct nfsd4_session *ses)
204{
205 struct nfs4_client *clp = ses->se_client;
206 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
207
208 spin_lock(&nn->client_lock);
209 nfsd4_put_session_locked(ses);
210 spin_unlock(&nn->client_lock);
211}
212
Kinglong Meeb5971af2014-08-22 10:18:43 -0400213static inline struct nfs4_stateowner *
214nfs4_get_stateowner(struct nfs4_stateowner *sop)
215{
216 atomic_inc(&sop->so_count);
217 return sop;
218}
219
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400220static int
Trond Myklebustd4f04892014-07-29 21:34:36 -0400221same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400222{
223 return (sop->so_owner.len == owner->len) &&
Trond Myklebustd4f04892014-07-29 21:34:36 -0400224 0 == memcmp(sop->so_owner.data, owner->data, owner->len);
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400225}
226
227static struct nfs4_openowner *
228find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
Trond Myklebustd4f04892014-07-29 21:34:36 -0400229 struct nfs4_client *clp)
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400230{
231 struct nfs4_stateowner *so;
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400232
Trond Myklebustd4f04892014-07-29 21:34:36 -0400233 lockdep_assert_held(&clp->cl_lock);
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400234
Trond Myklebustd4f04892014-07-29 21:34:36 -0400235 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
236 so_strhash) {
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400237 if (!so->so_is_open_owner)
238 continue;
Kinglong Meeb5971af2014-08-22 10:18:43 -0400239 if (same_owner_str(so, &open->op_owner))
240 return openowner(nfs4_get_stateowner(so));
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400241 }
242 return NULL;
243}
244
245static struct nfs4_openowner *
246find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
Trond Myklebustd4f04892014-07-29 21:34:36 -0400247 struct nfs4_client *clp)
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400248{
249 struct nfs4_openowner *oo;
250
Trond Myklebustd4f04892014-07-29 21:34:36 -0400251 spin_lock(&clp->cl_lock);
252 oo = find_openstateowner_str_locked(hashval, open, clp);
253 spin_unlock(&clp->cl_lock);
Trond Myklebust7ffb5882014-07-29 21:34:34 -0400254 return oo;
255}
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257static inline u32
258opaque_hashval(const void *ptr, int nbytes)
259{
260 unsigned char *cptr = (unsigned char *) ptr;
261
262 u32 x = 0;
263 while (nbytes--) {
264 x *= 37;
265 x += *cptr++;
266 }
267 return x;
268}
269
Jeff Layton5b095e92014-10-23 08:01:02 -0400270static void nfsd4_free_file_rcu(struct rcu_head *rcu)
J. Bruce Fields32513b42011-10-13 16:00:16 -0400271{
Jeff Layton5b095e92014-10-23 08:01:02 -0400272 struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
273
274 kmem_cache_free(file_slab, fp);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400275}
276
Christoph Hellwige6ba76e2014-08-14 08:50:16 +0200277void
NeilBrown13cd2182005-06-23 22:03:10 -0700278put_nfs4_file(struct nfs4_file *fi)
279{
Jeff Layton02e12152014-07-16 10:31:57 -0400280 might_lock(&state_lock);
281
Benny Halevycdc97502014-05-30 09:09:30 -0400282 if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) {
Jeff Layton5b095e92014-10-23 08:01:02 -0400283 hlist_del_rcu(&fi->fi_hash);
Benny Halevycdc97502014-05-30 09:09:30 -0400284 spin_unlock(&state_lock);
Sachin Bhamare8287f002015-04-27 14:50:14 +0200285 WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
Jeff Layton5b095e92014-10-23 08:01:02 -0400286 WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
287 call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800288 }
NeilBrown13cd2182005-06-23 22:03:10 -0700289}
290
Trond Myklebustde186432014-07-10 14:07:26 -0400291static struct file *
292__nfs4_get_fd(struct nfs4_file *f, int oflag)
293{
294 if (f->fi_fds[oflag])
295 return get_file(f->fi_fds[oflag]);
296 return NULL;
297}
298
299static struct file *
300find_writeable_file_locked(struct nfs4_file *f)
301{
302 struct file *ret;
303
304 lockdep_assert_held(&f->fi_lock);
305
306 ret = __nfs4_get_fd(f, O_WRONLY);
307 if (!ret)
308 ret = __nfs4_get_fd(f, O_RDWR);
309 return ret;
310}
311
312static struct file *
313find_writeable_file(struct nfs4_file *f)
314{
315 struct file *ret;
316
317 spin_lock(&f->fi_lock);
318 ret = find_writeable_file_locked(f);
319 spin_unlock(&f->fi_lock);
320
321 return ret;
322}
323
324static struct file *find_readable_file_locked(struct nfs4_file *f)
325{
326 struct file *ret;
327
328 lockdep_assert_held(&f->fi_lock);
329
330 ret = __nfs4_get_fd(f, O_RDONLY);
331 if (!ret)
332 ret = __nfs4_get_fd(f, O_RDWR);
333 return ret;
334}
335
336static struct file *
337find_readable_file(struct nfs4_file *f)
338{
339 struct file *ret;
340
341 spin_lock(&f->fi_lock);
342 ret = find_readable_file_locked(f);
343 spin_unlock(&f->fi_lock);
344
345 return ret;
346}
347
Christoph Hellwig4d227fc2014-08-17 07:40:00 -0500348struct file *
Trond Myklebustde186432014-07-10 14:07:26 -0400349find_any_file(struct nfs4_file *f)
350{
351 struct file *ret;
352
353 spin_lock(&f->fi_lock);
354 ret = __nfs4_get_fd(f, O_RDWR);
355 if (!ret) {
356 ret = __nfs4_get_fd(f, O_WRONLY);
357 if (!ret)
358 ret = __nfs4_get_fd(f, O_RDONLY);
359 }
360 spin_unlock(&f->fi_lock);
361 return ret;
362}
363
Trond Myklebust02a35082014-07-25 07:34:22 -0400364static atomic_long_t num_delegations;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800365unsigned long max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700366
367/*
368 * Open owner state (share locks)
369 */
370
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500371/* hash tables for lock and open owners */
372#define OWNER_HASH_BITS 8
373#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
374#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700375
Trond Myklebustd4f04892014-07-29 21:34:36 -0400376static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400377{
378 unsigned int ret;
379
380 ret = opaque_hashval(ownername->data, ownername->len);
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500381 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400382}
NeilBrownef0f3392006-04-10 22:55:41 -0700383
NeilBrownef0f3392006-04-10 22:55:41 -0700384/* hash table for nfs4_file */
385#define FILE_HASH_BITS 8
386#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800387
Trond Myklebustca943212014-07-23 16:17:39 -0400388static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400389{
Trond Myklebustca943212014-07-23 16:17:39 -0400390 return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0);
391}
392
393static unsigned int file_hashval(struct knfsd_fh *fh)
394{
395 return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1);
396}
397
Jeff Layton89876f82013-04-02 09:01:59 -0400398static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700399
Jeff Layton12659652014-07-10 14:07:28 -0400400static void
401__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
J. Bruce Fields34775652013-08-23 17:55:18 -0400402{
Jeff Layton7214e862014-07-10 14:07:33 -0400403 lockdep_assert_held(&fp->fi_lock);
404
Jeff Layton12659652014-07-10 14:07:28 -0400405 if (access & NFS4_SHARE_ACCESS_WRITE)
406 atomic_inc(&fp->fi_access[O_WRONLY]);
407 if (access & NFS4_SHARE_ACCESS_READ)
408 atomic_inc(&fp->fi_access[O_RDONLY]);
J. Bruce Fields34775652013-08-23 17:55:18 -0400409}
410
Jeff Layton12659652014-07-10 14:07:28 -0400411static __be32
412nfs4_file_get_access(struct nfs4_file *fp, u32 access)
J. Bruce Fields998db522010-08-07 09:21:41 -0400413{
Jeff Layton7214e862014-07-10 14:07:33 -0400414 lockdep_assert_held(&fp->fi_lock);
415
Jeff Layton12659652014-07-10 14:07:28 -0400416 /* Does this access mode make sense? */
417 if (access & ~NFS4_SHARE_ACCESS_BOTH)
418 return nfserr_inval;
419
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -0400420 /* Does it conflict with a deny mode already set? */
421 if ((access & fp->fi_share_deny) != 0)
422 return nfserr_share_denied;
423
Jeff Layton12659652014-07-10 14:07:28 -0400424 __nfs4_file_get_access(fp, access);
425 return nfs_ok;
J. Bruce Fields998db522010-08-07 09:21:41 -0400426}
427
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -0400428static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
429{
430 /* Common case is that there is no deny mode. */
431 if (deny) {
432 /* Does this deny mode make sense? */
433 if (deny & ~NFS4_SHARE_DENY_BOTH)
434 return nfserr_inval;
435
436 if ((deny & NFS4_SHARE_DENY_READ) &&
437 atomic_read(&fp->fi_access[O_RDONLY]))
438 return nfserr_share_denied;
439
440 if ((deny & NFS4_SHARE_DENY_WRITE) &&
441 atomic_read(&fp->fi_access[O_WRONLY]))
442 return nfserr_share_denied;
443 }
444 return nfs_ok;
445}
446
J. Bruce Fields998db522010-08-07 09:21:41 -0400447static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400448{
Trond Myklebustde186432014-07-10 14:07:26 -0400449 might_lock(&fp->fi_lock);
450
451 if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
452 struct file *f1 = NULL;
453 struct file *f2 = NULL;
454
Jeff Layton6d338b52014-07-10 14:07:29 -0400455 swap(f1, fp->fi_fds[oflag]);
J. Bruce Fields0c7c3e62013-03-28 20:37:14 -0400456 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
Jeff Layton6d338b52014-07-10 14:07:29 -0400457 swap(f2, fp->fi_fds[O_RDWR]);
Trond Myklebustde186432014-07-10 14:07:26 -0400458 spin_unlock(&fp->fi_lock);
459 if (f1)
460 fput(f1);
461 if (f2)
462 fput(f2);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400463 }
464}
465
Jeff Layton12659652014-07-10 14:07:28 -0400466static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
J. Bruce Fields998db522010-08-07 09:21:41 -0400467{
Jeff Layton12659652014-07-10 14:07:28 -0400468 WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
469
470 if (access & NFS4_SHARE_ACCESS_WRITE)
J. Bruce Fields998db522010-08-07 09:21:41 -0400471 __nfs4_file_put_access(fp, O_WRONLY);
Jeff Layton12659652014-07-10 14:07:28 -0400472 if (access & NFS4_SHARE_ACCESS_READ)
473 __nfs4_file_put_access(fp, O_RDONLY);
J. Bruce Fields998db522010-08-07 09:21:41 -0400474}
475
Sachin Bhamare8287f002015-04-27 14:50:14 +0200476/*
477 * Allocate a new open/delegation state counter. This is needed for
478 * pNFS for proper return on close semantics.
479 *
480 * Note that we only allocate it for pNFS-enabled exports, otherwise
481 * all pointers to struct nfs4_clnt_odstate are always NULL.
482 */
483static struct nfs4_clnt_odstate *
484alloc_clnt_odstate(struct nfs4_client *clp)
485{
486 struct nfs4_clnt_odstate *co;
487
488 co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
489 if (co) {
490 co->co_client = clp;
491 atomic_set(&co->co_odcount, 1);
492 }
493 return co;
494}
495
496static void
497hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
498{
499 struct nfs4_file *fp = co->co_file;
500
501 lockdep_assert_held(&fp->fi_lock);
502 list_add(&co->co_perfile, &fp->fi_clnt_odstate);
503}
504
505static inline void
506get_clnt_odstate(struct nfs4_clnt_odstate *co)
507{
508 if (co)
509 atomic_inc(&co->co_odcount);
510}
511
512static void
513put_clnt_odstate(struct nfs4_clnt_odstate *co)
514{
515 struct nfs4_file *fp;
516
517 if (!co)
518 return;
519
520 fp = co->co_file;
521 if (atomic_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
522 list_del(&co->co_perfile);
523 spin_unlock(&fp->fi_lock);
524
525 nfsd4_return_all_file_layouts(co->co_client, fp);
526 kmem_cache_free(odstate_slab, co);
527 }
528}
529
530static struct nfs4_clnt_odstate *
531find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
532{
533 struct nfs4_clnt_odstate *co;
534 struct nfs4_client *cl;
535
536 if (!new)
537 return NULL;
538
539 cl = new->co_client;
540
541 spin_lock(&fp->fi_lock);
542 list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
543 if (co->co_client == cl) {
544 get_clnt_odstate(co);
545 goto out;
546 }
547 }
548 co = new;
549 co->co_file = fp;
550 hash_clnt_odstate_locked(new);
551out:
552 spin_unlock(&fp->fi_lock);
553 return co;
554}
555
Christoph Hellwigcd61c522014-08-14 08:44:57 +0200556struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl,
Trond Myklebust60116952014-07-29 21:34:06 -0400557 struct kmem_cache *slab)
J. Bruce Fields996e0932011-10-17 11:14:48 -0400558{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500559 struct nfs4_stid *stid;
560 int new_id;
561
Trond Myklebustf8338832014-07-25 07:34:19 -0400562 stid = kmem_cache_zalloc(slab, GFP_KERNEL);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500563 if (!stid)
564 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400565
Jeff Layton4770d722014-07-29 21:34:10 -0400566 idr_preload(GFP_KERNEL);
567 spin_lock(&cl->cl_lock);
568 new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT);
569 spin_unlock(&cl->cl_lock);
570 idr_preload_end();
Tejun Heoebd6c702013-03-13 14:59:37 -0700571 if (new_id < 0)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500572 goto out_free;
573 stid->sc_client = cl;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500574 stid->sc_stateid.si_opaque.so_id = new_id;
575 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
576 /* Will be incremented before return to client: */
Trond Myklebust72c0b0f2014-07-21 09:34:58 -0400577 atomic_set(&stid->sc_count, 1);
Jeff Layton9767feb2015-10-01 09:05:50 -0400578 spin_lock_init(&stid->sc_lock);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500579
J. Bruce Fields996e0932011-10-17 11:14:48 -0400580 /*
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500581 * It shouldn't be a problem to reuse an opaque stateid value.
582 * I don't think it is for 4.1. But with 4.0 I worry that, for
583 * example, a stray write retransmission could be accepted by
584 * the server when it should have been rejected. Therefore,
585 * adopt a trick from the sctp code to attempt to maximize the
586 * amount of time until an id is reused, by ensuring they always
587 * "increase" (mod INT_MAX):
J. Bruce Fields996e0932011-10-17 11:14:48 -0400588 */
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500589 return stid;
590out_free:
Wei Yongjun2c44a232013-04-09 14:15:31 +0800591 kmem_cache_free(slab, stid);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500592 return NULL;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400593}
594
Jeff Laytonb49e0842014-07-29 21:34:11 -0400595static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400596{
Trond Myklebust60116952014-07-29 21:34:06 -0400597 struct nfs4_stid *stid;
598 struct nfs4_ol_stateid *stp;
599
600 stid = nfs4_alloc_stid(clp, stateid_slab);
601 if (!stid)
602 return NULL;
603
604 stp = openlockstateid(stid);
605 stp->st_stid.sc_free = nfs4_free_ol_stateid;
606 return stp;
607}
608
609static void nfs4_free_deleg(struct nfs4_stid *stid)
610{
Trond Myklebust60116952014-07-29 21:34:06 -0400611 kmem_cache_free(deleg_slab, stid);
612 atomic_long_dec(&num_delegations);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400613}
614
NeilBrown6282cd52014-06-04 17:39:26 +1000615/*
616 * When we recall a delegation, we should be careful not to hand it
617 * out again straight away.
618 * To ensure this we keep a pair of bloom filters ('new' and 'old')
619 * in which the filehandles of recalled delegations are "stored".
620 * If a filehandle appear in either filter, a delegation is blocked.
621 * When a delegation is recalled, the filehandle is stored in the "new"
622 * filter.
623 * Every 30 seconds we swap the filters and clear the "new" one,
624 * unless both are empty of course.
625 *
626 * Each filter is 256 bits. We hash the filehandle to 32bit and use the
627 * low 3 bytes as hash-table indices.
628 *
Jeff Laytonf54fe962014-07-25 07:34:26 -0400629 * 'blocked_delegations_lock', which is always taken in block_delegations(),
NeilBrown6282cd52014-06-04 17:39:26 +1000630 * is used to manage concurrent access. Testing does not need the lock
631 * except when swapping the two filters.
632 */
Jeff Laytonf54fe962014-07-25 07:34:26 -0400633static DEFINE_SPINLOCK(blocked_delegations_lock);
NeilBrown6282cd52014-06-04 17:39:26 +1000634static struct bloom_pair {
635 int entries, old_entries;
636 time_t swap_time;
637 int new; /* index into 'set' */
638 DECLARE_BITMAP(set[2], 256);
639} blocked_delegations;
640
641static int delegation_blocked(struct knfsd_fh *fh)
642{
643 u32 hash;
644 struct bloom_pair *bd = &blocked_delegations;
645
646 if (bd->entries == 0)
647 return 0;
648 if (seconds_since_boot() - bd->swap_time > 30) {
Jeff Laytonf54fe962014-07-25 07:34:26 -0400649 spin_lock(&blocked_delegations_lock);
NeilBrown6282cd52014-06-04 17:39:26 +1000650 if (seconds_since_boot() - bd->swap_time > 30) {
651 bd->entries -= bd->old_entries;
652 bd->old_entries = bd->entries;
653 memset(bd->set[bd->new], 0,
654 sizeof(bd->set[0]));
655 bd->new = 1-bd->new;
656 bd->swap_time = seconds_since_boot();
657 }
Jeff Laytonf54fe962014-07-25 07:34:26 -0400658 spin_unlock(&blocked_delegations_lock);
NeilBrown6282cd52014-06-04 17:39:26 +1000659 }
Daniel Borkmann87545892014-12-10 16:33:11 +0100660 hash = jhash(&fh->fh_base, fh->fh_size, 0);
NeilBrown6282cd52014-06-04 17:39:26 +1000661 if (test_bit(hash&255, bd->set[0]) &&
662 test_bit((hash>>8)&255, bd->set[0]) &&
663 test_bit((hash>>16)&255, bd->set[0]))
664 return 1;
665
666 if (test_bit(hash&255, bd->set[1]) &&
667 test_bit((hash>>8)&255, bd->set[1]) &&
668 test_bit((hash>>16)&255, bd->set[1]))
669 return 1;
670
671 return 0;
672}
673
674static void block_delegations(struct knfsd_fh *fh)
675{
676 u32 hash;
677 struct bloom_pair *bd = &blocked_delegations;
678
Daniel Borkmann87545892014-12-10 16:33:11 +0100679 hash = jhash(&fh->fh_base, fh->fh_size, 0);
NeilBrown6282cd52014-06-04 17:39:26 +1000680
Jeff Laytonf54fe962014-07-25 07:34:26 -0400681 spin_lock(&blocked_delegations_lock);
NeilBrown6282cd52014-06-04 17:39:26 +1000682 __set_bit(hash&255, bd->set[bd->new]);
683 __set_bit((hash>>8)&255, bd->set[bd->new]);
684 __set_bit((hash>>16)&255, bd->set[bd->new]);
685 if (bd->entries == 0)
686 bd->swap_time = seconds_since_boot();
687 bd->entries += 1;
Jeff Laytonf54fe962014-07-25 07:34:26 -0400688 spin_unlock(&blocked_delegations_lock);
NeilBrown6282cd52014-06-04 17:39:26 +1000689}
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691static struct nfs4_delegation *
Sachin Bhamare8287f002015-04-27 14:50:14 +0200692alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh,
693 struct nfs4_clnt_odstate *odstate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
695 struct nfs4_delegation *dp;
Trond Myklebust02a35082014-07-25 07:34:22 -0400696 long n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 dprintk("NFSD alloc_init_deleg\n");
Trond Myklebust02a35082014-07-25 07:34:22 -0400699 n = atomic_long_inc_return(&num_delegations);
700 if (n < 0 || n > max_delegations)
701 goto out_dec;
NeilBrown6282cd52014-06-04 17:39:26 +1000702 if (delegation_blocked(&current_fh->fh_handle))
Trond Myklebust02a35082014-07-25 07:34:22 -0400703 goto out_dec;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400704 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700705 if (dp == NULL)
Trond Myklebust02a35082014-07-25 07:34:22 -0400706 goto out_dec;
Trond Myklebust60116952014-07-29 21:34:06 -0400707
708 dp->dl_stid.sc_free = nfs4_free_deleg;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400709 /*
710 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400711 * meaning of seqid 0 isn't meaningful, really, but let's avoid
712 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400713 */
714 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownea1da632005-06-23 22:04:17 -0700715 INIT_LIST_HEAD(&dp->dl_perfile);
716 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 INIT_LIST_HEAD(&dp->dl_recall_lru);
Sachin Bhamare8287f002015-04-27 14:50:14 +0200718 dp->dl_clnt_odstate = odstate;
719 get_clnt_odstate(odstate);
J. Bruce Fields99c41512013-05-21 16:21:25 -0400720 dp->dl_type = NFS4_OPEN_DELEGATE_READ;
Christoph Hellwigf0b5de12014-09-24 12:19:18 +0200721 dp->dl_retries = 1;
722 nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
Christoph Hellwig0162ac22014-09-24 12:19:19 +0200723 &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 return dp;
Trond Myklebust02a35082014-07-25 07:34:22 -0400725out_dec:
726 atomic_long_dec(&num_delegations);
727 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
730void
Trond Myklebust60116952014-07-29 21:34:06 -0400731nfs4_put_stid(struct nfs4_stid *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Trond Myklebust11b91642014-07-29 21:34:08 -0400733 struct nfs4_file *fp = s->sc_file;
Trond Myklebust60116952014-07-29 21:34:06 -0400734 struct nfs4_client *clp = s->sc_client;
735
Jeff Layton4770d722014-07-29 21:34:10 -0400736 might_lock(&clp->cl_lock);
737
Jeff Laytonb401be222014-07-29 21:34:33 -0400738 if (!atomic_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
739 wake_up_all(&close_wq);
Trond Myklebust60116952014-07-29 21:34:06 -0400740 return;
Jeff Laytonb401be222014-07-29 21:34:33 -0400741 }
Trond Myklebust60116952014-07-29 21:34:06 -0400742 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
Jeff Layton4770d722014-07-29 21:34:10 -0400743 spin_unlock(&clp->cl_lock);
Trond Myklebust60116952014-07-29 21:34:06 -0400744 s->sc_free(s);
Trond Myklebust11b91642014-07-29 21:34:08 -0400745 if (fp)
746 put_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747}
748
Jeff Layton9767feb2015-10-01 09:05:50 -0400749void
750nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
751{
752 stateid_t *src = &stid->sc_stateid;
753
754 spin_lock(&stid->sc_lock);
755 if (unlikely(++src->si_generation == 0))
756 src->si_generation = 1;
757 memcpy(dst, src, sizeof(*dst));
758 spin_unlock(&stid->sc_lock);
759}
760
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500761static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Jeff Layton6bcc0342014-08-09 10:22:40 -0400763 struct file *filp = NULL;
Jeff Layton417c6622014-07-21 09:34:57 -0400764
Jeff Layton6bcc0342014-08-09 10:22:40 -0400765 spin_lock(&fp->fi_lock);
Jeff Layton67db1032014-12-13 09:11:40 -0500766 if (fp->fi_deleg_file && --fp->fi_delegees == 0)
Jeff Layton6bcc0342014-08-09 10:22:40 -0400767 swap(filp, fp->fi_deleg_file);
Jeff Layton6bcc0342014-08-09 10:22:40 -0400768 spin_unlock(&fp->fi_lock);
769
770 if (filp) {
Christoph Hellwig2ab99ee2015-01-21 19:14:02 +0100771 vfs_setlease(filp, F_UNLCK, NULL, (void **)&fp);
Jeff Layton6bcc0342014-08-09 10:22:40 -0400772 fput(filp);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500773 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774}
775
Christoph Hellwigcd61c522014-08-14 08:44:57 +0200776void nfs4_unhash_stid(struct nfs4_stid *s)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400777{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500778 s->sc_type = 0;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400779}
780
Andrew Elble34ed9872015-10-15 12:07:28 -0400781/**
782 * nfs4_get_existing_delegation - Discover if this delegation already exists
783 * @clp: a pointer to the nfs4_client we're granting a delegation to
784 * @fp: a pointer to the nfs4_file we're granting a delegation on
785 *
786 * Return:
787 * On success: NULL if an existing delegation was not found.
788 *
789 * On error: -EAGAIN if one was previously granted to this nfs4_client
790 * for this nfs4_file.
791 *
792 */
793
794static int
795nfs4_get_existing_delegation(struct nfs4_client *clp, struct nfs4_file *fp)
Benny Halevy931ee562014-05-30 09:09:27 -0400796{
Andrew Elble34ed9872015-10-15 12:07:28 -0400797 struct nfs4_delegation *searchdp = NULL;
798 struct nfs4_client *searchclp = NULL;
799
Benny Halevycdc97502014-05-30 09:09:30 -0400800 lockdep_assert_held(&state_lock);
Jeff Layton417c6622014-07-21 09:34:57 -0400801 lockdep_assert_held(&fp->fi_lock);
Benny Halevy931ee562014-05-30 09:09:27 -0400802
Andrew Elble34ed9872015-10-15 12:07:28 -0400803 list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
804 searchclp = searchdp->dl_stid.sc_client;
805 if (clp == searchclp) {
806 return -EAGAIN;
807 }
808 }
809 return 0;
810}
811
812/**
813 * hash_delegation_locked - Add a delegation to the appropriate lists
814 * @dp: a pointer to the nfs4_delegation we are adding.
815 * @fp: a pointer to the nfs4_file we're granting a delegation on
816 *
817 * Return:
818 * On success: NULL if the delegation was successfully hashed.
819 *
820 * On error: -EAGAIN if one was previously granted to this
821 * nfs4_client for this nfs4_file. Delegation is not hashed.
822 *
823 */
824
825static int
826hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
827{
828 int status;
829 struct nfs4_client *clp = dp->dl_stid.sc_client;
830
831 lockdep_assert_held(&state_lock);
832 lockdep_assert_held(&fp->fi_lock);
833
834 status = nfs4_get_existing_delegation(clp, fp);
835 if (status)
836 return status;
837 ++fp->fi_delegees;
Trond Myklebust67cb1272014-07-29 21:34:17 -0400838 atomic_inc(&dp->dl_stid.sc_count);
Benny Halevy3fb87d12014-05-30 09:09:31 -0400839 dp->dl_stid.sc_type = NFS4_DELEG_STID;
Benny Halevy931ee562014-05-30 09:09:27 -0400840 list_add(&dp->dl_perfile, &fp->fi_delegations);
Andrew Elble34ed9872015-10-15 12:07:28 -0400841 list_add(&dp->dl_perclnt, &clp->cl_delegations);
842 return 0;
Benny Halevy931ee562014-05-30 09:09:27 -0400843}
844
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400845static bool
Jeff Layton42690672014-07-25 07:34:20 -0400846unhash_delegation_locked(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Trond Myklebust11b91642014-07-29 21:34:08 -0400848 struct nfs4_file *fp = dp->dl_stid.sc_file;
Jeff Layton02e12152014-07-16 10:31:57 -0400849
Jeff Layton42690672014-07-25 07:34:20 -0400850 lockdep_assert_held(&state_lock);
851
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400852 if (list_empty(&dp->dl_perfile))
853 return false;
854
Trond Myklebustb0fc29d2014-07-16 10:31:59 -0400855 dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
Jeff Laytond55a1662014-07-22 13:52:06 -0400856 /* Ensure that deleg break won't try to requeue it */
857 ++dp->dl_time;
Jeff Layton417c6622014-07-21 09:34:57 -0400858 spin_lock(&fp->fi_lock);
Benny Halevy931ee562014-05-30 09:09:27 -0400859 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 list_del_init(&dp->dl_recall_lru);
Jeff Layton02e12152014-07-16 10:31:57 -0400861 list_del_init(&dp->dl_perfile);
862 spin_unlock(&fp->fi_lock);
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400863 return true;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400864}
865
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400866static void destroy_delegation(struct nfs4_delegation *dp)
867{
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400868 bool unhashed;
869
Jeff Layton42690672014-07-25 07:34:20 -0400870 spin_lock(&state_lock);
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400871 unhashed = unhash_delegation_locked(dp);
Jeff Layton42690672014-07-25 07:34:20 -0400872 spin_unlock(&state_lock);
Jeff Layton3fcbbd22015-08-24 12:41:48 -0400873 if (unhashed) {
874 put_clnt_odstate(dp->dl_clnt_odstate);
875 nfs4_put_deleg_lease(dp->dl_stid.sc_file);
876 nfs4_put_stid(&dp->dl_stid);
877 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400878}
879
880static void revoke_delegation(struct nfs4_delegation *dp)
881{
882 struct nfs4_client *clp = dp->dl_stid.sc_client;
883
Jeff Layton2d4a5322014-07-25 07:34:21 -0400884 WARN_ON(!list_empty(&dp->dl_recall_lru));
885
Sachin Bhamare8287f002015-04-27 14:50:14 +0200886 put_clnt_odstate(dp->dl_clnt_odstate);
Jeff Laytonafbda402014-08-09 10:22:41 -0400887 nfs4_put_deleg_lease(dp->dl_stid.sc_file);
888
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400889 if (clp->cl_minorversion == 0)
Trond Myklebust60116952014-07-29 21:34:06 -0400890 nfs4_put_stid(&dp->dl_stid);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400891 else {
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400892 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
Jeff Layton2d4a5322014-07-25 07:34:21 -0400893 spin_lock(&clp->cl_lock);
894 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
895 spin_unlock(&clp->cl_lock);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400896 }
897}
898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899/*
900 * SETCLIENTID state
901 */
902
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400903static unsigned int clientid_hashval(u32 id)
904{
905 return id & CLIENT_HASH_MASK;
906}
907
908static unsigned int clientstr_hashval(const char *name)
909{
910 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
911}
912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913/*
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400914 * We store the NONE, READ, WRITE, and BOTH bits separately in the
915 * st_{access,deny}_bmap field of the stateid, in order to track not
916 * only what share bits are currently in force, but also what
917 * combinations of share bits previous opens have used. This allows us
918 * to enforce the recommendation of rfc 3530 14.2.19 that the server
919 * return an error if the client attempt to downgrade to a combination
920 * of share bits not explicable by closing some of its previous opens.
921 *
922 * XXX: This enforcement is actually incomplete, since we don't keep
923 * track of access/deny bit combinations; so, e.g., we allow:
924 *
925 * OPEN allow read, deny write
926 * OPEN allow both, deny none
927 * DOWNGRADE allow read, deny none
928 *
929 * which we should reject.
930 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400931static unsigned int
932bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400933 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400934 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400935
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400936 for (i = 1; i < 4; i++) {
937 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400938 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400939 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400940 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400941}
942
Jeff Layton82c5ff12012-05-11 09:45:13 -0400943/* set share access for a given stateid */
944static inline void
945set_access(u32 access, struct nfs4_ol_stateid *stp)
946{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400947 unsigned char mask = 1 << access;
948
949 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
950 stp->st_access_bmap |= mask;
Jeff Layton82c5ff12012-05-11 09:45:13 -0400951}
952
953/* clear share access for a given stateid */
954static inline void
955clear_access(u32 access, struct nfs4_ol_stateid *stp)
956{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400957 unsigned char mask = 1 << access;
958
959 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
960 stp->st_access_bmap &= ~mask;
Jeff Layton82c5ff12012-05-11 09:45:13 -0400961}
962
963/* test whether a given stateid has access */
964static inline bool
965test_access(u32 access, struct nfs4_ol_stateid *stp)
966{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400967 unsigned char mask = 1 << access;
968
969 return (bool)(stp->st_access_bmap & mask);
Jeff Layton82c5ff12012-05-11 09:45:13 -0400970}
971
Jeff Laytonce0fc432012-05-11 09:45:14 -0400972/* set share deny for a given stateid */
973static inline void
Jeff Laytonc11c5912014-07-10 14:07:30 -0400974set_deny(u32 deny, struct nfs4_ol_stateid *stp)
Jeff Laytonce0fc432012-05-11 09:45:14 -0400975{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400976 unsigned char mask = 1 << deny;
977
978 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
979 stp->st_deny_bmap |= mask;
Jeff Laytonce0fc432012-05-11 09:45:14 -0400980}
981
982/* clear share deny for a given stateid */
983static inline void
Jeff Laytonc11c5912014-07-10 14:07:30 -0400984clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
Jeff Laytonce0fc432012-05-11 09:45:14 -0400985{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400986 unsigned char mask = 1 << deny;
987
988 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
989 stp->st_deny_bmap &= ~mask;
Jeff Laytonce0fc432012-05-11 09:45:14 -0400990}
991
992/* test whether a given stateid is denying specific access */
993static inline bool
Jeff Laytonc11c5912014-07-10 14:07:30 -0400994test_deny(u32 deny, struct nfs4_ol_stateid *stp)
Jeff Laytonce0fc432012-05-11 09:45:14 -0400995{
Jeff Laytonc11c5912014-07-10 14:07:30 -0400996 unsigned char mask = 1 << deny;
997
998 return (bool)(stp->st_deny_bmap & mask);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400999}
1000
1001static int nfs4_access_to_omode(u32 access)
1002{
J. Bruce Fields8f34a432010-09-02 15:23:16 -04001003 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04001004 case NFS4_SHARE_ACCESS_READ:
1005 return O_RDONLY;
1006 case NFS4_SHARE_ACCESS_WRITE:
1007 return O_WRONLY;
1008 case NFS4_SHARE_ACCESS_BOTH:
1009 return O_RDWR;
1010 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05001011 WARN_ON_ONCE(1);
1012 return O_RDONLY;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04001013}
1014
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04001015/*
1016 * A stateid that had a deny mode associated with it is being released
1017 * or downgraded. Recalculate the deny mode on the file.
1018 */
1019static void
1020recalculate_deny_mode(struct nfs4_file *fp)
1021{
1022 struct nfs4_ol_stateid *stp;
1023
1024 spin_lock(&fp->fi_lock);
1025 fp->fi_share_deny = 0;
1026 list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
1027 fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
1028 spin_unlock(&fp->fi_lock);
1029}
1030
1031static void
1032reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
1033{
1034 int i;
1035 bool change = false;
1036
1037 for (i = 1; i < 4; i++) {
1038 if ((i & deny) != i) {
1039 change = true;
1040 clear_deny(i, stp);
1041 }
1042 }
1043
1044 /* Recalculate per-file deny mode if there was a change */
1045 if (change)
Trond Myklebust11b91642014-07-29 21:34:08 -04001046 recalculate_deny_mode(stp->st_stid.sc_file);
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04001047}
1048
Jeff Layton82c5ff12012-05-11 09:45:13 -04001049/* release all access and file references for a given stateid */
1050static void
1051release_all_access(struct nfs4_ol_stateid *stp)
1052{
1053 int i;
Trond Myklebust11b91642014-07-29 21:34:08 -04001054 struct nfs4_file *fp = stp->st_stid.sc_file;
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04001055
1056 if (fp && stp->st_deny_bmap != 0)
1057 recalculate_deny_mode(fp);
Jeff Layton82c5ff12012-05-11 09:45:13 -04001058
1059 for (i = 1; i < 4; i++) {
1060 if (test_access(i, stp))
Trond Myklebust11b91642014-07-29 21:34:08 -04001061 nfs4_file_put_access(stp->st_stid.sc_file, i);
Jeff Layton82c5ff12012-05-11 09:45:13 -04001062 clear_access(i, stp);
1063 }
1064}
1065
Kinglong Meed50ffde2015-07-16 12:05:07 +08001066static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
1067{
1068 kfree(sop->so_owner.data);
1069 sop->so_ops->so_free(sop);
1070}
1071
Jeff Layton6b180f02014-07-29 21:34:26 -04001072static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
1073{
Jeff Laytona819ecc2014-07-29 21:34:38 -04001074 struct nfs4_client *clp = sop->so_client;
1075
1076 might_lock(&clp->cl_lock);
1077
1078 if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
Jeff Layton6b180f02014-07-29 21:34:26 -04001079 return;
Jeff Layton8f4b54c2014-07-29 21:34:29 -04001080 sop->so_ops->so_unhash(sop);
Jeff Laytona819ecc2014-07-29 21:34:38 -04001081 spin_unlock(&clp->cl_lock);
Kinglong Meed50ffde2015-07-16 12:05:07 +08001082 nfs4_free_stateowner(sop);
Jeff Layton6b180f02014-07-29 21:34:26 -04001083}
1084
Jeff Laytone8568732015-08-24 12:41:47 -04001085static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001086{
Trond Myklebust11b91642014-07-29 21:34:08 -04001087 struct nfs4_file *fp = stp->st_stid.sc_file;
Trond Myklebust1d31a252014-07-10 14:07:25 -04001088
Jeff Layton1c755dc2014-07-29 21:34:12 -04001089 lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
1090
Jeff Laytone8568732015-08-24 12:41:47 -04001091 if (list_empty(&stp->st_perfile))
1092 return false;
1093
Trond Myklebust1d31a252014-07-10 14:07:25 -04001094 spin_lock(&fp->fi_lock);
Jeff Laytone8568732015-08-24 12:41:47 -04001095 list_del_init(&stp->st_perfile);
Trond Myklebust1d31a252014-07-10 14:07:25 -04001096 spin_unlock(&fp->fi_lock);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001097 list_del(&stp->st_perstateowner);
Jeff Laytone8568732015-08-24 12:41:47 -04001098 return true;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001099}
1100
Trond Myklebust60116952014-07-29 21:34:06 -04001101static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001102{
Trond Myklebust60116952014-07-29 21:34:06 -04001103 struct nfs4_ol_stateid *stp = openlockstateid(stid);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -04001104
Sachin Bhamare8287f002015-04-27 14:50:14 +02001105 put_clnt_odstate(stp->st_clnt_odstate);
Trond Myklebust60116952014-07-29 21:34:06 -04001106 release_all_access(stp);
Jeff Laytond3134b12014-07-29 21:34:32 -04001107 if (stp->st_stateowner)
1108 nfs4_put_stateowner(stp->st_stateowner);
Trond Myklebust60116952014-07-29 21:34:06 -04001109 kmem_cache_free(stateid_slab, stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001110}
1111
Jeff Laytonb49e0842014-07-29 21:34:11 -04001112static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001113{
Jeff Laytonb49e0842014-07-29 21:34:11 -04001114 struct nfs4_ol_stateid *stp = openlockstateid(stid);
1115 struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001116 struct file *file;
1117
Jeff Laytonb49e0842014-07-29 21:34:11 -04001118 file = find_any_file(stp->st_stid.sc_file);
1119 if (file)
1120 filp_close(file, (fl_owner_t)lo);
1121 nfs4_free_ol_stateid(stid);
1122}
1123
Jeff Layton2c41beb2014-07-29 21:34:41 -04001124/*
1125 * Put the persistent reference to an already unhashed generic stateid, while
1126 * holding the cl_lock. If it's the last reference, then put it onto the
1127 * reaplist for later destruction.
1128 */
1129static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
1130 struct list_head *reaplist)
1131{
1132 struct nfs4_stid *s = &stp->st_stid;
1133 struct nfs4_client *clp = s->sc_client;
1134
1135 lockdep_assert_held(&clp->cl_lock);
1136
1137 WARN_ON_ONCE(!list_empty(&stp->st_locks));
1138
1139 if (!atomic_dec_and_test(&s->sc_count)) {
1140 wake_up_all(&close_wq);
1141 return;
1142 }
1143
1144 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1145 list_add(&stp->st_locks, reaplist);
1146}
1147
Jeff Laytone8568732015-08-24 12:41:47 -04001148static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
Jeff Layton3c1c9952014-07-29 21:34:39 -04001149{
1150 struct nfs4_openowner *oo = openowner(stp->st_openstp->st_stateowner);
1151
1152 lockdep_assert_held(&oo->oo_owner.so_client->cl_lock);
1153
1154 list_del_init(&stp->st_locks);
Christoph Hellwigcd61c522014-08-14 08:44:57 +02001155 nfs4_unhash_stid(&stp->st_stid);
Jeff Laytone8568732015-08-24 12:41:47 -04001156 return unhash_ol_stateid(stp);
Jeff Layton3c1c9952014-07-29 21:34:39 -04001157}
1158
Jeff Layton5adfd882014-07-29 21:34:31 -04001159static void release_lock_stateid(struct nfs4_ol_stateid *stp)
Jeff Laytonb49e0842014-07-29 21:34:11 -04001160{
Jeff Layton1c755dc2014-07-29 21:34:12 -04001161 struct nfs4_openowner *oo = openowner(stp->st_openstp->st_stateowner);
Jeff Laytone8568732015-08-24 12:41:47 -04001162 bool unhashed;
Jeff Layton1c755dc2014-07-29 21:34:12 -04001163
1164 spin_lock(&oo->oo_owner.so_client->cl_lock);
Jeff Laytone8568732015-08-24 12:41:47 -04001165 unhashed = unhash_lock_stateid(stp);
Jeff Layton1c755dc2014-07-29 21:34:12 -04001166 spin_unlock(&oo->oo_owner.so_client->cl_lock);
Jeff Laytone8568732015-08-24 12:41:47 -04001167 if (unhashed)
1168 nfs4_put_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001169}
1170
Trond Myklebustc58c6612014-07-29 21:34:35 -04001171static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001172{
Trond Myklebustd4f04892014-07-29 21:34:36 -04001173 struct nfs4_client *clp = lo->lo_owner.so_client;
Trond Myklebustc58c6612014-07-29 21:34:35 -04001174
Trond Myklebustd4f04892014-07-29 21:34:36 -04001175 lockdep_assert_held(&clp->cl_lock);
Trond Myklebustc58c6612014-07-29 21:34:35 -04001176
Jeff Layton8f4b54c2014-07-29 21:34:29 -04001177 list_del_init(&lo->lo_owner.so_strhash);
1178}
1179
Jeff Layton2c41beb2014-07-29 21:34:41 -04001180/*
1181 * Free a list of generic stateids that were collected earlier after being
1182 * fully unhashed.
1183 */
1184static void
1185free_ol_stateid_reaplist(struct list_head *reaplist)
1186{
1187 struct nfs4_ol_stateid *stp;
Kinglong Meefb94d762014-08-05 21:20:27 +08001188 struct nfs4_file *fp;
Jeff Layton2c41beb2014-07-29 21:34:41 -04001189
1190 might_sleep();
1191
1192 while (!list_empty(reaplist)) {
1193 stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
1194 st_locks);
1195 list_del(&stp->st_locks);
Kinglong Meefb94d762014-08-05 21:20:27 +08001196 fp = stp->st_stid.sc_file;
Jeff Layton2c41beb2014-07-29 21:34:41 -04001197 stp->st_stid.sc_free(&stp->st_stid);
Kinglong Meefb94d762014-08-05 21:20:27 +08001198 if (fp)
1199 put_nfs4_file(fp);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001200 }
1201}
1202
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001203static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001204{
Trond Myklebustd4f04892014-07-29 21:34:36 -04001205 struct nfs4_client *clp = lo->lo_owner.so_client;
Jeff Layton3c1c9952014-07-29 21:34:39 -04001206 struct nfs4_ol_stateid *stp;
1207 struct list_head reaplist;
1208
1209 INIT_LIST_HEAD(&reaplist);
Trond Myklebustc58c6612014-07-29 21:34:35 -04001210
Trond Myklebustd4f04892014-07-29 21:34:36 -04001211 spin_lock(&clp->cl_lock);
Trond Myklebustc58c6612014-07-29 21:34:35 -04001212 unhash_lockowner_locked(lo);
Jeff Layton3c1c9952014-07-29 21:34:39 -04001213 while (!list_empty(&lo->lo_owner.so_stateids)) {
1214 stp = list_first_entry(&lo->lo_owner.so_stateids,
1215 struct nfs4_ol_stateid, st_perstateowner);
Jeff Laytone8568732015-08-24 12:41:47 -04001216 WARN_ON(!unhash_lock_stateid(stp));
Jeff Layton2c41beb2014-07-29 21:34:41 -04001217 put_ol_stateid_locked(stp, &reaplist);
Jeff Layton3c1c9952014-07-29 21:34:39 -04001218 }
Trond Myklebustd4f04892014-07-29 21:34:36 -04001219 spin_unlock(&clp->cl_lock);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001220 free_ol_stateid_reaplist(&reaplist);
Jeff Layton6b180f02014-07-29 21:34:26 -04001221 nfs4_put_stateowner(&lo->lo_owner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001222}
1223
Jeff Laytond83017f2014-07-29 21:34:42 -04001224static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
1225 struct list_head *reaplist)
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04001226{
1227 struct nfs4_ol_stateid *stp;
1228
Jeff Laytone8568732015-08-24 12:41:47 -04001229 lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
1230
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04001231 while (!list_empty(&open_stp->st_locks)) {
1232 stp = list_entry(open_stp->st_locks.next,
1233 struct nfs4_ol_stateid, st_locks);
Jeff Laytone8568732015-08-24 12:41:47 -04001234 WARN_ON(!unhash_lock_stateid(stp));
Jeff Laytond83017f2014-07-29 21:34:42 -04001235 put_ol_stateid_locked(stp, reaplist);
J. Bruce Fields529d7b22011-03-02 23:48:33 -05001236 }
1237}
1238
Jeff Laytone8568732015-08-24 12:41:47 -04001239static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
Jeff Laytond83017f2014-07-29 21:34:42 -04001240 struct list_head *reaplist)
J. Bruce Fields22839632009-01-11 14:27:17 -05001241{
Jeff Laytone8568732015-08-24 12:41:47 -04001242 bool unhashed;
1243
Jeff Layton2c41beb2014-07-29 21:34:41 -04001244 lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1245
Jeff Laytone8568732015-08-24 12:41:47 -04001246 unhashed = unhash_ol_stateid(stp);
Jeff Laytond83017f2014-07-29 21:34:42 -04001247 release_open_stateid_locks(stp, reaplist);
Jeff Laytone8568732015-08-24 12:41:47 -04001248 return unhashed;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04001249}
1250
1251static void release_open_stateid(struct nfs4_ol_stateid *stp)
1252{
Jeff Layton2c41beb2014-07-29 21:34:41 -04001253 LIST_HEAD(reaplist);
1254
1255 spin_lock(&stp->st_stid.sc_client->cl_lock);
Jeff Laytone8568732015-08-24 12:41:47 -04001256 if (unhash_open_stateid(stp, &reaplist))
1257 put_ol_stateid_locked(stp, &reaplist);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001258 spin_unlock(&stp->st_stid.sc_client->cl_lock);
1259 free_ol_stateid_reaplist(&reaplist);
J. Bruce Fields22839632009-01-11 14:27:17 -05001260}
1261
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001262static void unhash_openowner_locked(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -05001263{
Trond Myklebustd4f04892014-07-29 21:34:36 -04001264 struct nfs4_client *clp = oo->oo_owner.so_client;
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001265
Trond Myklebustd4f04892014-07-29 21:34:36 -04001266 lockdep_assert_held(&clp->cl_lock);
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001267
Jeff Layton8f4b54c2014-07-29 21:34:29 -04001268 list_del_init(&oo->oo_owner.so_strhash);
1269 list_del_init(&oo->oo_perclient);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -05001270}
1271
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001272static void release_last_closed_stateid(struct nfs4_openowner *oo)
1273{
Jeff Layton217526e2014-07-30 08:27:11 -04001274 struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
1275 nfsd_net_id);
1276 struct nfs4_ol_stateid *s;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001277
Jeff Layton217526e2014-07-30 08:27:11 -04001278 spin_lock(&nn->client_lock);
1279 s = oo->oo_last_closed_stid;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001280 if (s) {
Jeff Laytond3134b12014-07-29 21:34:32 -04001281 list_del_init(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001282 oo->oo_last_closed_stid = NULL;
1283 }
Jeff Layton217526e2014-07-30 08:27:11 -04001284 spin_unlock(&nn->client_lock);
1285 if (s)
1286 nfs4_put_stid(&s->st_stid);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001287}
1288
Jeff Layton2c41beb2014-07-29 21:34:41 -04001289static void release_openowner(struct nfs4_openowner *oo)
Jeff Layton8f4b54c2014-07-29 21:34:29 -04001290{
1291 struct nfs4_ol_stateid *stp;
Trond Myklebustd4f04892014-07-29 21:34:36 -04001292 struct nfs4_client *clp = oo->oo_owner.so_client;
Jeff Layton2c41beb2014-07-29 21:34:41 -04001293 struct list_head reaplist;
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001294
Jeff Layton2c41beb2014-07-29 21:34:41 -04001295 INIT_LIST_HEAD(&reaplist);
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001296
Trond Myklebustd4f04892014-07-29 21:34:36 -04001297 spin_lock(&clp->cl_lock);
Trond Myklebust7ffb5882014-07-29 21:34:34 -04001298 unhash_openowner_locked(oo);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001299 while (!list_empty(&oo->oo_owner.so_stateids)) {
1300 stp = list_first_entry(&oo->oo_owner.so_stateids,
1301 struct nfs4_ol_stateid, st_perstateowner);
Jeff Laytone8568732015-08-24 12:41:47 -04001302 if (unhash_open_stateid(stp, &reaplist))
1303 put_ol_stateid_locked(stp, &reaplist);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001304 }
Trond Myklebustd4f04892014-07-29 21:34:36 -04001305 spin_unlock(&clp->cl_lock);
Jeff Layton2c41beb2014-07-29 21:34:41 -04001306 free_ol_stateid_reaplist(&reaplist);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04001307 release_last_closed_stateid(oo);
Jeff Layton6b180f02014-07-29 21:34:26 -04001308 nfs4_put_stateowner(&oo->oo_owner);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -05001309}
1310
Marc Eshel5282fd72009-04-03 08:27:52 +03001311static inline int
1312hash_sessionid(struct nfs4_sessionid *sessionid)
1313{
1314 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
1315
1316 return sid->sequence % SESSION_HASH_SIZE;
1317}
1318
Mark Salter135dd002015-04-06 09:46:00 -04001319#ifdef CONFIG_SUNRPC_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +03001320static inline void
1321dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1322{
1323 u32 *ptr = (u32 *)(&sessionid->data[0]);
1324 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
1325}
Trond Myklebust8f199b82012-03-20 15:11:17 -04001326#else
1327static inline void
1328dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1329{
1330}
1331#endif
1332
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04001333/*
1334 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
1335 * won't be used for replay.
1336 */
1337void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
1338{
1339 struct nfs4_stateowner *so = cstate->replay_owner;
1340
1341 if (nfserr == nfserr_replay_me)
1342 return;
1343
1344 if (!seqid_mutating_err(ntohl(nfserr))) {
Jeff Layton58fb12e2014-07-29 21:34:27 -04001345 nfsd4_cstate_clear_replay(cstate);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04001346 return;
1347 }
1348 if (!so)
1349 return;
1350 if (so->so_is_open_owner)
1351 release_last_closed_stateid(openowner(so));
1352 so->so_seqid++;
1353 return;
1354}
Marc Eshel5282fd72009-04-03 08:27:52 +03001355
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001356static void
1357gen_sessionid(struct nfsd4_session *ses)
1358{
1359 struct nfs4_client *clp = ses->se_client;
1360 struct nfsd4_sessionid *sid;
1361
1362 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
1363 sid->clientid = clp->cl_clientid;
1364 sid->sequence = current_sessionid++;
1365 sid->reserved = 0;
1366}
1367
1368/*
Andy Adamsona6496372009-08-28 08:45:01 -04001369 * The protocol defines ca_maxresponssize_cached to include the size of
1370 * the rpc header, but all we need to cache is the data starting after
1371 * the end of the initial SEQUENCE operation--the rest we regenerate
1372 * each time. Therefore we can advertise a ca_maxresponssize_cached
1373 * value that is the number of bytes in our cache plus a few additional
1374 * bytes. In order to stay on the safe side, and not promise more than
1375 * we can cache, those additional bytes must be the minimum possible: 24
1376 * bytes of rpc header (xid through accept state, with AUTH_NULL
1377 * verifier), 12 for the compound header (with zero-length tag), and 44
1378 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001379 */
Andy Adamsona6496372009-08-28 08:45:01 -04001380#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
1381
Andy Adamson557ce262009-08-28 08:45:04 -04001382static void
1383free_session_slots(struct nfsd4_session *ses)
1384{
1385 int i;
1386
1387 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
1388 kfree(ses->se_slots[i]);
1389}
1390
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -04001391/*
1392 * We don't actually need to cache the rpc and session headers, so we
1393 * can allocate a little less for each slot:
1394 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001395static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -04001396{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001397 u32 size;
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -04001398
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001399 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1400 size = 0;
1401 else
1402 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1403 return size + sizeof(struct nfsd4_slot);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001404}
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001405
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001406/*
1407 * XXX: If we run out of reserved DRC memory we could (up to a point)
1408 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -08001409 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001410 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001411static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001412{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001413 u32 slotsize = slot_bytes(ca);
1414 u32 num = ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001415 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001416
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001417 spin_lock(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -08001418 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
1419 nfsd_drc_max_mem - nfsd_drc_mem_used);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001420 num = min_t(int, num, avail / slotsize);
1421 nfsd_drc_mem_used += num * slotsize;
1422 spin_unlock(&nfsd_drc_lock);
1423
1424 return num;
1425}
1426
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001427static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001428{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001429 int slotsize = slot_bytes(ca);
1430
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001431 spin_lock(&nfsd_drc_lock);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001432 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001433 spin_unlock(&nfsd_drc_lock);
1434}
1435
Kinglong Mee60810e52014-01-01 00:35:47 +08001436static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1437 struct nfsd4_channel_attrs *battrs)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001438{
Kinglong Mee60810e52014-01-01 00:35:47 +08001439 int numslots = fattrs->maxreqs;
1440 int slotsize = slot_bytes(fattrs);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001441 struct nfsd4_session *new;
1442 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001443
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -04001444 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001445 + sizeof(struct nfsd4_session) > PAGE_SIZE);
1446 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -04001447
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001448 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001449 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001450 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -04001451 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001452 for (i = 0; i < numslots; i++) {
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001453 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001454 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -04001455 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -04001456 }
Kinglong Mee60810e52014-01-01 00:35:47 +08001457
1458 memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1459 memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1460
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001461 return new;
1462out_free:
1463 while (i--)
1464 kfree(new->se_slots[i]);
1465 kfree(new);
1466 return NULL;
1467}
1468
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001469static void free_conn(struct nfsd4_conn *c)
1470{
1471 svc_xprt_put(c->cn_xprt);
1472 kfree(c);
1473}
1474
1475static void nfsd4_conn_lost(struct svc_xpt_user *u)
1476{
1477 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
1478 struct nfs4_client *clp = c->cn_session->se_client;
1479
1480 spin_lock(&clp->cl_lock);
1481 if (!list_empty(&c->cn_persession)) {
1482 list_del(&c->cn_persession);
1483 free_conn(c);
1484 }
J. Bruce Fieldseea49802010-11-18 08:34:12 -05001485 nfsd4_probe_callback(clp);
J. Bruce Fields2e4b7232013-03-08 09:30:43 -05001486 spin_unlock(&clp->cl_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001487}
1488
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -04001489static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001490{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001491 struct nfsd4_conn *conn;
1492
1493 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
1494 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001495 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001496 svc_xprt_get(rqstp->rq_xprt);
1497 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -04001498 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001499 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1500 return conn;
1501}
1502
J. Bruce Fields328ead22010-09-29 16:11:06 -04001503static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1504{
1505 conn->cn_session = ses;
1506 list_add(&conn->cn_persession, &ses->se_conns);
1507}
1508
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001509static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1510{
1511 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001512
1513 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001514 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001515 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001516}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001517
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001518static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001519{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001520 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001521 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001522}
1523
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001524static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001525{
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001526 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001527
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001528 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001529 ret = nfsd4_register_conn(conn);
1530 if (ret)
1531 /* oops; xprt is already down: */
1532 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fields57a37142014-07-18 15:06:47 -04001533 /* We may have gained or lost a callback channel: */
1534 nfsd4_probe_callback_sync(ses->se_client);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001535}
1536
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001537static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001538{
1539 u32 dir = NFS4_CDFC4_FORE;
1540
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001541 if (cses->flags & SESSION4_BACK_CHAN)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001542 dir |= NFS4_CDFC4_BACK;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001543 return alloc_conn(rqstp, dir);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001544}
1545
1546/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001547static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001548{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001549 struct nfs4_client *clp = s->se_client;
1550 struct nfsd4_conn *c;
1551
1552 spin_lock(&clp->cl_lock);
1553 while (!list_empty(&s->se_conns)) {
1554 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1555 list_del_init(&c->cn_persession);
1556 spin_unlock(&clp->cl_lock);
1557
1558 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1559 free_conn(c);
1560
1561 spin_lock(&clp->cl_lock);
1562 }
1563 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001564}
1565
J. Bruce Fields1377b692012-09-11 21:42:40 -04001566static void __free_session(struct nfsd4_session *ses)
1567{
J. Bruce Fields1377b692012-09-11 21:42:40 -04001568 free_session_slots(ses);
1569 kfree(ses);
1570}
1571
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001572static void free_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -08001573{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001574 nfsd4_del_conns(ses);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001575 nfsd4_put_drc_mem(&ses->se_fchannel);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001576 __free_session(ses);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001577}
Andy Adamson557ce262009-08-28 08:45:04 -04001578
Fengguang Wu135ae822012-11-10 07:20:25 -05001579static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001580{
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001581 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001582 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001583
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001584 new->se_client = clp;
1585 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001586
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001587 INIT_LIST_HEAD(&new->se_conns);
1588
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001589 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001590 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -04001591 new->se_cb_prog = cses->callback_prog;
J. Bruce Fieldsc6bb3ca2012-11-01 16:31:02 -04001592 new->se_cb_sec = cses->cb_sec;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001593 atomic_set(&new->se_ref, 0);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001594 idx = hash_sessionid(&new->se_sessionid);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001595 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001596 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001597 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001598 spin_unlock(&clp->cl_lock);
Kinglong Mee60810e52014-01-01 00:35:47 +08001599
Chuck Leverb0d2e422014-08-22 15:10:59 -04001600 {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001601 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001602 /*
1603 * This is a little silly; with sessions there's no real
1604 * use for the callback address. Use the peer address
1605 * as a reasonable default for now, but consider fixing
1606 * the rpc client not to require an address in the
1607 * future:
1608 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001609 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1610 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001611 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001612}
1613
Benny Halevy9089f1b2010-05-12 00:12:26 +03001614/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +03001615static struct nfsd4_session *
Trond Myklebustd4e19e702014-06-30 11:48:42 -04001616__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
Marc Eshel5282fd72009-04-03 08:27:52 +03001617{
1618 struct nfsd4_session *elem;
1619 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001620 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Marc Eshel5282fd72009-04-03 08:27:52 +03001621
Trond Myklebust0a880a22014-07-30 08:27:10 -04001622 lockdep_assert_held(&nn->client_lock);
1623
Marc Eshel5282fd72009-04-03 08:27:52 +03001624 dump_sessionid(__func__, sessionid);
1625 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +03001626 /* Search in the appropriate list */
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001627 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +03001628 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1629 NFS4_MAX_SESSIONID_LEN)) {
1630 return elem;
1631 }
1632 }
1633
1634 dprintk("%s: session not found\n", __func__);
1635 return NULL;
1636}
1637
Trond Myklebustd4e19e702014-06-30 11:48:42 -04001638static struct nfsd4_session *
1639find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
1640 __be32 *ret)
1641{
1642 struct nfsd4_session *session;
1643 __be32 status = nfserr_badsession;
1644
1645 session = __find_in_sessionid_hashtbl(sessionid, net);
1646 if (!session)
1647 goto out;
1648 status = nfsd4_get_session_locked(session);
1649 if (status)
1650 session = NULL;
1651out:
1652 *ret = status;
1653 return session;
1654}
1655
Benny Halevy9089f1b2010-05-12 00:12:26 +03001656/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +03001657static void
Marc Eshel5282fd72009-04-03 08:27:52 +03001658unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +03001659{
Trond Myklebust0a880a22014-07-30 08:27:10 -04001660 struct nfs4_client *clp = ses->se_client;
1661 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1662
1663 lockdep_assert_held(&nn->client_lock);
1664
Andy Adamson7116ed62009-04-03 08:27:43 +03001665 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001666 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +03001667 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001668 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +03001669}
1670
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1672static int
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001673STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674{
J. Bruce Fieldsbbc7f332015-01-20 11:51:26 -05001675 /*
1676 * We're assuming the clid was not given out from a boot
1677 * precisely 2^32 (about 136 years) before this one. That seems
1678 * a safe assumption:
1679 */
1680 if (clid->cl_boot == (u32)nn->boot_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001682 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001683 clid->cl_boot, clid->cl_id, nn->boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 return 1;
1685}
1686
1687/*
1688 * XXX Should we use a slab cache ?
1689 * This type of memory management is somewhat inefficient, but we use it
1690 * anyway since SETCLIENTID is not a common operation.
1691 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001692static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693{
1694 struct nfs4_client *clp;
Trond Myklebustd4f04892014-07-29 21:34:36 -04001695 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001697 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1698 if (clp == NULL)
1699 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001700 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
Trond Myklebustd4f04892014-07-29 21:34:36 -04001701 if (clp->cl_name.data == NULL)
1702 goto err_no_name;
1703 clp->cl_ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
1704 OWNER_HASH_SIZE, GFP_KERNEL);
1705 if (!clp->cl_ownerstr_hashtbl)
1706 goto err_no_hashtbl;
1707 for (i = 0; i < OWNER_HASH_SIZE; i++)
1708 INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001709 clp->cl_name.len = name.len;
Trond Myklebust5694c932014-04-18 14:43:56 -04001710 INIT_LIST_HEAD(&clp->cl_sessions);
1711 idr_init(&clp->cl_stateids);
1712 atomic_set(&clp->cl_refcount, 0);
1713 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1714 INIT_LIST_HEAD(&clp->cl_idhash);
1715 INIT_LIST_HEAD(&clp->cl_openowners);
1716 INIT_LIST_HEAD(&clp->cl_delegations);
1717 INIT_LIST_HEAD(&clp->cl_lru);
Trond Myklebust5694c932014-04-18 14:43:56 -04001718 INIT_LIST_HEAD(&clp->cl_revoked);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001719#ifdef CONFIG_NFSD_PNFS
1720 INIT_LIST_HEAD(&clp->cl_lo_states);
1721#endif
Trond Myklebust5694c932014-04-18 14:43:56 -04001722 spin_lock_init(&clp->cl_lock);
1723 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 return clp;
Trond Myklebustd4f04892014-07-29 21:34:36 -04001725err_no_hashtbl:
1726 kfree(clp->cl_name.data);
1727err_no_name:
1728 kfree(clp);
1729 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730}
1731
Trond Myklebust4dd86e152014-04-18 14:43:58 -04001732static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733free_client(struct nfs4_client *clp)
1734{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001735 while (!list_empty(&clp->cl_sessions)) {
1736 struct nfsd4_session *ses;
1737 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1738 se_perclnt);
1739 list_del(&ses->se_perclnt);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001740 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1741 free_session(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001742 }
Trond Myklebust4cb57e32014-04-18 14:43:57 -04001743 rpc_destroy_wait_queue(&clp->cl_cb_waitq);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001744 free_svc_cred(&clp->cl_cred);
Trond Myklebustd4f04892014-07-29 21:34:36 -04001745 kfree(clp->cl_ownerstr_hashtbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 kfree(clp->cl_name.data);
majianpeng2d32b292013-01-29 13:16:06 +08001747 idr_destroy(&clp->cl_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 kfree(clp);
1749}
1750
Benny Halevy84d38ac2010-05-12 00:13:16 +03001751/* must be called under the client_lock */
Trond Myklebust4beb3452014-07-30 08:27:02 -04001752static void
Benny Halevy84d38ac2010-05-12 00:13:16 +03001753unhash_client_locked(struct nfs4_client *clp)
1754{
Trond Myklebust4beb3452014-07-30 08:27:02 -04001755 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001756 struct nfsd4_session *ses;
1757
Trond Myklebust0a880a22014-07-30 08:27:10 -04001758 lockdep_assert_held(&nn->client_lock);
1759
Trond Myklebust4beb3452014-07-30 08:27:02 -04001760 /* Mark the client as expired! */
1761 clp->cl_time = 0;
1762 /* Make it invisible */
1763 if (!list_empty(&clp->cl_idhash)) {
1764 list_del_init(&clp->cl_idhash);
1765 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1766 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1767 else
1768 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1769 }
1770 list_del_init(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001771 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001772 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1773 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001774 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001775}
1776
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777static void
Trond Myklebust4beb3452014-07-30 08:27:02 -04001778unhash_client(struct nfs4_client *clp)
1779{
1780 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1781
1782 spin_lock(&nn->client_lock);
1783 unhash_client_locked(clp);
1784 spin_unlock(&nn->client_lock);
1785}
1786
Jeff Layton97403d92014-07-30 08:27:12 -04001787static __be32 mark_client_expired_locked(struct nfs4_client *clp)
1788{
1789 if (atomic_read(&clp->cl_refcount))
1790 return nfserr_jukebox;
1791 unhash_client_locked(clp);
1792 return nfs_ok;
1793}
1794
Trond Myklebust4beb3452014-07-30 08:27:02 -04001795static void
1796__destroy_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001798 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 struct list_head reaplist;
1801
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 INIT_LIST_HEAD(&reaplist);
Benny Halevycdc97502014-05-30 09:09:30 -04001803 spin_lock(&state_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001804 while (!list_empty(&clp->cl_delegations)) {
1805 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
Jeff Layton3fcbbd22015-08-24 12:41:48 -04001806 WARN_ON(!unhash_delegation_locked(dp));
Jeff Layton42690672014-07-25 07:34:20 -04001807 list_add(&dp->dl_recall_lru, &reaplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 }
Benny Halevycdc97502014-05-30 09:09:30 -04001809 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 while (!list_empty(&reaplist)) {
1811 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
Jeff Layton42690672014-07-25 07:34:20 -04001812 list_del_init(&dp->dl_recall_lru);
Sachin Bhamare8287f002015-04-27 14:50:14 +02001813 put_clnt_odstate(dp->dl_clnt_odstate);
Jeff Laytonafbda402014-08-09 10:22:41 -04001814 nfs4_put_deleg_lease(dp->dl_stid.sc_file);
Trond Myklebust60116952014-07-29 21:34:06 -04001815 nfs4_put_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 }
Jeff Layton2d4a5322014-07-25 07:34:21 -04001817 while (!list_empty(&clp->cl_revoked)) {
Andrew Elblec8764862015-02-25 17:46:27 -05001818 dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
Jeff Layton2d4a5322014-07-25 07:34:21 -04001819 list_del_init(&dp->dl_recall_lru);
Trond Myklebust60116952014-07-29 21:34:06 -04001820 nfs4_put_stid(&dp->dl_stid);
Benny Halevy956c4fe2013-10-29 11:39:12 +02001821 }
NeilBrownea1da632005-06-23 22:04:17 -07001822 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001823 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
Kinglong Meeb5971af2014-08-22 10:18:43 -04001824 nfs4_get_stateowner(&oo->oo_owner);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001825 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 }
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001827 nfsd4_return_all_client_layouts(clp);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001828 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001829 if (clp->cl_cb_conn.cb_xprt)
1830 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001831 free_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832}
1833
Trond Myklebust4beb3452014-07-30 08:27:02 -04001834static void
1835destroy_client(struct nfs4_client *clp)
1836{
1837 unhash_client(clp);
1838 __destroy_client(clp);
1839}
1840
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001841static void expire_client(struct nfs4_client *clp)
1842{
Trond Myklebust4beb3452014-07-30 08:27:02 -04001843 unhash_client(clp);
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001844 nfsd4_client_record_remove(clp);
Trond Myklebust4beb3452014-07-30 08:27:02 -04001845 __destroy_client(clp);
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001846}
1847
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001848static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1849{
1850 memcpy(target->cl_verifier.data, source->data,
1851 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852}
1853
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001854static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1855{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1857 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1858}
1859
J. Bruce Fields50043852015-11-20 15:58:37 -05001860int strdup_if_nonnull(char **target, char *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001861{
J. Bruce Fields50043852015-11-20 15:58:37 -05001862 if (source) {
1863 *target = kstrdup(source, GFP_KERNEL);
1864 if (!*target)
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001865 return -ENOMEM;
1866 } else
J. Bruce Fields50043852015-11-20 15:58:37 -05001867 *target = NULL;
1868 return 0;
1869}
1870
1871static int copy_cred(struct svc_cred *target, struct svc_cred *source)
1872{
1873 int ret;
1874
1875 ret = strdup_if_nonnull(&target->cr_principal, source->cr_principal);
1876 if (ret)
1877 return ret;
J. Bruce Fields414ca012015-11-20 10:48:02 -05001878 ret = strdup_if_nonnull(&target->cr_raw_principal,
1879 source->cr_raw_principal);
1880 if (ret)
1881 return ret;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001882 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 target->cr_uid = source->cr_uid;
1884 target->cr_gid = source->cr_gid;
1885 target->cr_group_info = source->cr_group_info;
1886 get_group_info(target->cr_group_info);
J. Bruce Fields0dc15312013-05-14 16:07:13 -04001887 target->cr_gss_mech = source->cr_gss_mech;
1888 if (source->cr_gss_mech)
1889 gss_mech_get(source->cr_gss_mech);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001890 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891}
1892
Rasmus Villemoesef17af22014-12-05 16:40:07 +01001893static int
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001894compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1895{
Rasmus Villemoesef17af22014-12-05 16:40:07 +01001896 if (o1->len < o2->len)
1897 return -1;
1898 if (o1->len > o2->len)
1899 return 1;
1900 return memcmp(o1->data, o2->data, o1->len);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001901}
1902
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001903static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001904{
NeilBrowna55370a2005-06-23 22:03:52 -07001905 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906}
1907
1908static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001909same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1910{
1911 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912}
1913
1914static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001915same_clid(clientid_t *cl1, clientid_t *cl2)
1916{
1917 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918}
1919
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001920static bool groups_equal(struct group_info *g1, struct group_info *g2)
1921{
1922 int i;
1923
1924 if (g1->ngroups != g2->ngroups)
1925 return false;
1926 for (i=0; i<g1->ngroups; i++)
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001927 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001928 return false;
1929 return true;
1930}
1931
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001932/*
1933 * RFC 3530 language requires clid_inuse be returned when the
1934 * "principal" associated with a requests differs from that previously
1935 * used. We use uid, gid's, and gss principal string as our best
1936 * approximation. We also don't want to allow non-gss use of a client
1937 * established using gss: in theory cr_principal should catch that
1938 * change, but in practice cr_principal can be null even in the gss case
1939 * since gssd doesn't always pass down a principal string.
1940 */
1941static bool is_gss_cred(struct svc_cred *cr)
1942{
1943 /* Is cr_flavor one of the gss "pseudoflavors"?: */
1944 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1945}
1946
1947
Vivek Trivedi5559b502012-07-24 21:18:20 +05301948static bool
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001949same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1950{
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001951 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001952 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1953 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001954 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1955 return false;
1956 if (cr1->cr_principal == cr2->cr_principal)
1957 return true;
1958 if (!cr1->cr_principal || !cr2->cr_principal)
1959 return false;
Vivek Trivedi5559b502012-07-24 21:18:20 +05301960 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961}
1962
J. Bruce Fields57266a62013-04-13 14:27:29 -04001963static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
1964{
1965 struct svc_cred *cr = &rqstp->rq_cred;
1966 u32 service;
1967
J. Bruce Fieldsc4720592013-08-07 11:41:49 -04001968 if (!cr->cr_gss_mech)
1969 return false;
J. Bruce Fields57266a62013-04-13 14:27:29 -04001970 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
1971 return service == RPC_GSS_SVC_INTEGRITY ||
1972 service == RPC_GSS_SVC_PRIVACY;
1973}
1974
1975static bool mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
1976{
1977 struct svc_cred *cr = &rqstp->rq_cred;
1978
1979 if (!cl->cl_mach_cred)
1980 return true;
1981 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
1982 return false;
1983 if (!svc_rqst_integrity_protected(rqstp))
1984 return false;
J. Bruce Fields414ca012015-11-20 10:48:02 -05001985 if (cl->cl_cred.cr_raw_principal)
1986 return 0 == strcmp(cl->cl_cred.cr_raw_principal,
1987 cr->cr_raw_principal);
J. Bruce Fields57266a62013-04-13 14:27:29 -04001988 if (!cr->cr_principal)
1989 return false;
1990 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
1991}
1992
Jeff Layton294ac322014-07-30 08:27:15 -04001993static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001994{
Chuck Leverab4684d2012-03-02 17:13:50 -05001995 __be32 verf[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996
Jeff Laytonf4199922014-06-17 07:44:11 -04001997 /*
1998 * This is opaque to client, so no need to byte-swap. Use
1999 * __force to keep sparse happy
2000 */
2001 verf[0] = (__force __be32)get_seconds();
Kinglong Mee19311aa82015-07-18 07:33:31 +08002002 verf[1] = (__force __be32)nn->clverifier_counter++;
Chuck Leverab4684d2012-03-02 17:13:50 -05002003 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004}
2005
Jeff Layton294ac322014-07-30 08:27:15 -04002006static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2007{
2008 clp->cl_clientid.cl_boot = nn->boot_time;
2009 clp->cl_clientid.cl_id = nn->clientid_counter++;
2010 gen_confirm(clp, nn);
2011}
2012
Jeff Layton4770d722014-07-29 21:34:10 -04002013static struct nfs4_stid *
2014find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
J. Bruce Fields4581d142011-09-06 14:56:09 -04002015{
J. Bruce Fields3abdb602013-02-03 12:23:01 -05002016 struct nfs4_stid *ret;
2017
2018 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
2019 if (!ret || !ret->sc_type)
2020 return NULL;
2021 return ret;
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04002022}
2023
Jeff Layton4770d722014-07-29 21:34:10 -04002024static struct nfs4_stid *
Jeff Layton4770d722014-07-29 21:34:10 -04002025find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002026{
2027 struct nfs4_stid *s;
2028
Jeff Layton4770d722014-07-29 21:34:10 -04002029 spin_lock(&cl->cl_lock);
2030 s = find_stateid_locked(cl, t);
Trond Myklebust2d3f9662014-07-29 21:34:25 -04002031 if (s != NULL) {
2032 if (typemask & s->sc_type)
2033 atomic_inc(&s->sc_count);
2034 else
2035 s = NULL;
2036 }
Jeff Layton4770d722014-07-29 21:34:10 -04002037 spin_unlock(&cl->cl_lock);
2038 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04002039}
2040
Jeff Layton2216d442012-11-12 15:00:57 -05002041static struct nfs4_client *create_client(struct xdr_netobj name,
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002042 struct svc_rqst *rqstp, nfs4_verifier *verf)
2043{
2044 struct nfs4_client *clp;
2045 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04002046 int ret;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002047 struct net *net = SVC_NET(rqstp);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002048
2049 clp = alloc_client(name);
2050 if (clp == NULL)
2051 return NULL;
2052
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04002053 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
2054 if (ret) {
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04002055 free_client(clp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04002056 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002057 }
Christoph Hellwig0162ac22014-09-24 12:19:19 +02002058 nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
Benny Halevy07cd4902010-05-12 00:13:41 +03002059 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002060 clear_bit(0, &clp->cl_cb_slot_busy);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002061 copy_verf(clp, verf);
2062 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04002063 clp->cl_cb_session = NULL;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002064 clp->net = net;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03002065 return clp;
2066}
2067
NeilBrownfd39ca92005-06-23 22:04:03 -07002068static void
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002069add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
2070{
2071 struct rb_node **new = &(root->rb_node), *parent = NULL;
2072 struct nfs4_client *clp;
2073
2074 while (*new) {
2075 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
2076 parent = *new;
2077
2078 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
2079 new = &((*new)->rb_left);
2080 else
2081 new = &((*new)->rb_right);
2082 }
2083
2084 rb_link_node(&new_clp->cl_namenode, parent, new);
2085 rb_insert_color(&new_clp->cl_namenode, root);
2086}
2087
2088static struct nfs4_client *
2089find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
2090{
Rasmus Villemoesef17af22014-12-05 16:40:07 +01002091 int cmp;
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002092 struct rb_node *node = root->rb_node;
2093 struct nfs4_client *clp;
2094
2095 while (node) {
2096 clp = rb_entry(node, struct nfs4_client, cl_namenode);
2097 cmp = compare_blob(&clp->cl_name, name);
2098 if (cmp > 0)
2099 node = node->rb_left;
2100 else if (cmp < 0)
2101 node = node->rb_right;
2102 else
2103 return clp;
2104 }
2105 return NULL;
2106}
2107
2108static void
2109add_to_unconfirmed(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110{
2111 unsigned int idhashval;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002112 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
Trond Myklebust0a880a22014-07-30 08:27:10 -04002114 lockdep_assert_held(&nn->client_lock);
2115
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002116 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002117 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002119 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002120 renew_client_locked(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121}
2122
NeilBrownfd39ca92005-06-23 22:04:03 -07002123static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124move_to_confirmed(struct nfs4_client *clp)
2125{
2126 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002127 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
Trond Myklebust0a880a22014-07-30 08:27:10 -04002129 lockdep_assert_held(&nn->client_lock);
2130
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002132 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002133 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002134 add_clp_to_name_tree(clp, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002135 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002136 renew_client_locked(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137}
2138
2139static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002140find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141{
2142 struct nfs4_client *clp;
2143 unsigned int idhashval = clientid_hashval(clid->cl_id);
2144
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002145 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002146 if (same_clid(&clp->cl_clientid, clid)) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002147 if ((bool)clp->cl_minorversion != sessions)
2148 return NULL;
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002149 renew_client_locked(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002151 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 }
2153 return NULL;
2154}
2155
2156static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002157find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2158{
2159 struct list_head *tbl = nn->conf_id_hashtbl;
2160
Trond Myklebust0a880a22014-07-30 08:27:10 -04002161 lockdep_assert_held(&nn->client_lock);
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002162 return find_client_in_id_table(tbl, clid, sessions);
2163}
2164
2165static struct nfs4_client *
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002166find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167{
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002168 struct list_head *tbl = nn->unconf_id_hashtbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
Trond Myklebust0a880a22014-07-30 08:27:10 -04002170 lockdep_assert_held(&nn->client_lock);
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04002171 return find_client_in_id_table(tbl, clid, sessions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172}
2173
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05002174static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03002175{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05002176 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002177}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03002178
NeilBrown28ce6052005-06-23 22:03:56 -07002179static struct nfs4_client *
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002180find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07002181{
Trond Myklebust0a880a22014-07-30 08:27:10 -04002182 lockdep_assert_held(&nn->client_lock);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002183 return find_clp_in_name_tree(name, &nn->conf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07002184}
2185
2186static struct nfs4_client *
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002187find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07002188{
Trond Myklebust0a880a22014-07-30 08:27:10 -04002189 lockdep_assert_held(&nn->client_lock);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002190 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07002191}
2192
NeilBrownfd39ca92005-06-23 22:04:03 -07002193static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002194gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195{
J. Bruce Fields07263f12010-05-31 19:09:40 -04002196 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002197 struct sockaddr *sa = svc_addr(rqstp);
2198 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04002199 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Jeff Layton7077ecb2009-08-14 12:57:58 -04002201 /* Currently, we only support tcp and tcp6 for the callback channel */
2202 if (se->se_callback_netid_len == 3 &&
2203 !memcmp(se->se_callback_netid_val, "tcp", 3))
2204 expected_family = AF_INET;
2205 else if (se->se_callback_netid_len == 4 &&
2206 !memcmp(se->se_callback_netid_val, "tcp6", 4))
2207 expected_family = AF_INET6;
2208 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 goto out_err;
2210
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002211 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04002212 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04002213 (struct sockaddr *)&conn->cb_addr,
2214 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04002215
J. Bruce Fields07263f12010-05-31 19:09:40 -04002216 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04002218
J. Bruce Fields07263f12010-05-31 19:09:40 -04002219 if (conn->cb_addr.ss_family == AF_INET6)
2220 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04002221
J. Bruce Fields07263f12010-05-31 19:09:40 -04002222 conn->cb_prog = se->se_callback_prog;
2223 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08002224 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 return;
2226out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04002227 conn->cb_addr.ss_family = AF_UNSPEC;
2228 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07002229 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 "will not receive delegations\n",
2231 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
2232
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 return;
2234}
2235
Andy Adamson074fe892009-04-03 08:28:15 +03002236/*
J. Bruce Fields067e1ac2014-03-21 17:26:44 -04002237 * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03002238 */
Trond Myklebustb6076642014-06-30 11:48:35 -04002239static void
Andy Adamson074fe892009-04-03 08:28:15 +03002240nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
2241{
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04002242 struct xdr_buf *buf = resp->xdr.buf;
Andy Adamson557ce262009-08-28 08:45:04 -04002243 struct nfsd4_slot *slot = resp->cstate.slot;
2244 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03002245
Andy Adamson557ce262009-08-28 08:45:04 -04002246 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03002247
Andy Adamson557ce262009-08-28 08:45:04 -04002248 slot->sl_opcnt = resp->opcnt;
2249 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03002250
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002251 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03002252 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04002253 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03002254 return;
2255 }
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04002256 base = resp->cstate.data_offset;
2257 slot->sl_datalen = buf->len - base;
2258 if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
Dan Carpenterd3f03402015-11-21 13:28:50 +03002259 WARN(1, "%s: sessions DRC could not cache compound\n",
2260 __func__);
Andy Adamson557ce262009-08-28 08:45:04 -04002261 return;
Andy Adamson074fe892009-04-03 08:28:15 +03002262}
2263
2264/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04002265 * Encode the replay sequence operation from the slot values.
2266 * If cachethis is FALSE encode the uncached rep error on the next
2267 * operation which sets resp->p and increments resp->opcnt for
2268 * nfs4svc_encode_compoundres.
2269 *
Andy Adamson074fe892009-04-03 08:28:15 +03002270 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04002271static __be32
2272nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
2273 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03002274{
Andy Adamsonabfabf82009-07-23 19:02:18 -04002275 struct nfsd4_op *op;
2276 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03002277
Andy Adamsonabfabf82009-07-23 19:02:18 -04002278 /* Encode the replayed sequence operation */
2279 op = &args->ops[resp->opcnt - 1];
2280 nfsd4_encode_operation(resp, op);
2281
2282 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05002283 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04002284 op = &args->ops[resp->opcnt++];
2285 op->status = nfserr_retry_uncached_rep;
2286 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03002287 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04002288 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03002289}
2290
2291/*
Andy Adamson557ce262009-08-28 08:45:04 -04002292 * The sequence operation is not cached because we can use the slot and
2293 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03002294 */
J. Bruce Fields3ca2eb92014-03-21 12:04:21 -04002295static __be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03002296nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
2297 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03002298{
Andy Adamson557ce262009-08-28 08:45:04 -04002299 struct nfsd4_slot *slot = resp->cstate.slot;
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04002300 struct xdr_stream *xdr = &resp->xdr;
2301 __be32 *p;
Andy Adamson074fe892009-04-03 08:28:15 +03002302 __be32 status;
2303
Andy Adamson557ce262009-08-28 08:45:04 -04002304 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03002305
Andy Adamsonabfabf82009-07-23 19:02:18 -04002306 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
J. Bruce Fields0da7b192014-03-21 11:43:34 -04002307 if (status)
Andy Adamsonabfabf82009-07-23 19:02:18 -04002308 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03002309
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04002310 p = xdr_reserve_space(xdr, slot->sl_datalen);
2311 if (!p) {
2312 WARN_ON_ONCE(1);
2313 return nfserr_serverfault;
2314 }
2315 xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
2316 xdr_commit_encode(xdr);
Andy Adamson074fe892009-04-03 08:28:15 +03002317
Andy Adamson557ce262009-08-28 08:45:04 -04002318 resp->opcnt = slot->sl_opcnt;
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04002319 return slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03002320}
2321
Andy Adamson0733d212009-04-03 08:28:01 +03002322/*
2323 * Set the exchange_id flags returned by the server.
2324 */
2325static void
2326nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
2327{
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002328#ifdef CONFIG_NFSD_PNFS
2329 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
2330#else
Andy Adamson0733d212009-04-03 08:28:01 +03002331 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002332#endif
Andy Adamson0733d212009-04-03 08:28:01 +03002333
2334 /* Referrals are supported, Migration is not. */
2335 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
2336
2337 /* set the wire flags to return to client. */
2338 clid->flags = new->cl_exchange_flags;
2339}
2340
J. Bruce Fields4eaea132015-10-15 16:11:01 -04002341static bool client_has_openowners(struct nfs4_client *clp)
2342{
2343 struct nfs4_openowner *oo;
2344
2345 list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
2346 if (!list_empty(&oo->oo_owner.so_stateids))
2347 return true;
2348 }
2349 return false;
2350}
2351
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04002352static bool client_has_state(struct nfs4_client *clp)
2353{
J. Bruce Fields4eaea132015-10-15 16:11:01 -04002354 return client_has_openowners(clp)
Kinglong Mee47e970b2015-07-21 13:09:17 +08002355#ifdef CONFIG_NFSD_PNFS
2356 || !list_empty(&clp->cl_lo_states)
2357#endif
J. Bruce Fields6eccece2012-05-29 16:37:44 -04002358 || !list_empty(&clp->cl_delegations)
2359 || !list_empty(&clp->cl_sessions);
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04002360}
2361
Al Virob37ad282006-10-19 23:28:59 -07002362__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03002363nfsd4_exchange_id(struct svc_rqst *rqstp,
2364 struct nfsd4_compound_state *cstate,
2365 struct nfsd4_exchange_id *exid)
2366{
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002367 struct nfs4_client *conf, *new;
2368 struct nfs4_client *unconf = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002369 __be32 status;
Jeff Layton363168b2009-08-14 12:57:56 -04002370 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03002371 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04002372 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04002373 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002374 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamson0733d212009-04-03 08:28:01 +03002375
Jeff Layton363168b2009-08-14 12:57:56 -04002376 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03002377 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04002378 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03002379 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04002380 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03002381
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002382 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03002383 return nfserr_inval;
2384
J. Bruce Fields50c7b942015-11-23 15:39:12 -07002385 new = create_client(exid->clname, rqstp, &verf);
2386 if (new == NULL)
2387 return nfserr_jukebox;
2388
Andy Adamson0733d212009-04-03 08:28:01 +03002389 switch (exid->spa_how) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04002390 case SP4_MACH_CRED:
J. Bruce Fields50c7b942015-11-23 15:39:12 -07002391 if (!svc_rqst_integrity_protected(rqstp)) {
2392 status = nfserr_inval;
2393 goto out_nolock;
2394 }
J. Bruce Fields920dd9b2015-11-20 16:42:40 -05002395 /*
2396 * Sometimes userspace doesn't give us a principal.
2397 * Which is a bug, really. Anyway, we can't enforce
2398 * MACH_CRED in that case, better to give up now:
2399 */
J. Bruce Fields414ca012015-11-20 10:48:02 -05002400 if (!new->cl_cred.cr_principal &&
2401 !new->cl_cred.cr_raw_principal) {
J. Bruce Fields920dd9b2015-11-20 16:42:40 -05002402 status = nfserr_serverfault;
2403 goto out_nolock;
2404 }
J. Bruce Fields50c7b942015-11-23 15:39:12 -07002405 new->cl_mach_cred = true;
Andy Adamson0733d212009-04-03 08:28:01 +03002406 case SP4_NONE:
2407 break;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05002408 default: /* checked by xdr code */
2409 WARN_ON_ONCE(1);
Andy Adamson0733d212009-04-03 08:28:01 +03002410 case SP4_SSV:
J. Bruce Fieldsdd303332013-04-12 18:10:56 -04002411 return nfserr_encr_alg_unsupp;
Andy Adamson0733d212009-04-03 08:28:01 +03002412 }
2413
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04002414 /* Cases below refer to rfc 5661 section 18.35.4: */
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002415 spin_lock(&nn->client_lock);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002416 conf = find_confirmed_client_by_name(&exid->clname, nn);
Andy Adamson0733d212009-04-03 08:28:01 +03002417 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04002418 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
2419 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
2420
J. Bruce Fields136e6582012-05-12 20:37:23 -04002421 if (update) {
2422 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04002423 status = nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03002424 goto out;
2425 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04002426 if (!mach_creds_match(conf, rqstp)) {
2427 status = nfserr_wrong_cred;
2428 goto out;
2429 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04002430 if (!creds_match) { /* case 9 */
Andy Adamson0733d212009-04-03 08:28:01 +03002431 status = nfserr_perm;
2432 goto out;
2433 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04002434 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03002435 status = nfserr_not_same;
2436 goto out;
2437 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04002438 /* case 6 */
2439 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04002440 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03002441 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04002442 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04002443 if (client_has_state(conf)) {
2444 status = nfserr_clid_inuse;
2445 goto out;
2446 }
Andy Adamson0733d212009-04-03 08:28:01 +03002447 goto out_new;
2448 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04002449 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04002450 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04002451 goto out_copy;
2452 }
2453 /* case 5, client reboot */
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002454 conf = NULL;
J. Bruce Fields136e6582012-05-12 20:37:23 -04002455 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03002456 }
2457
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04002458 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03002459 status = nfserr_noent;
2460 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03002461 }
2462
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002463 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04002464 if (unconf) /* case 4, possible retry or client restart */
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002465 unhash_client_locked(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03002466
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04002467 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03002468out_new:
Jeff Laytonfd699b82014-07-30 08:27:14 -04002469 if (conf) {
2470 status = mark_client_expired_locked(conf);
2471 if (status)
2472 goto out;
2473 }
J. Bruce Fields4f540e22013-05-07 11:57:52 -04002474 new->cl_minorversion = cstate->minorversion;
Andy Adamson0733d212009-04-03 08:28:01 +03002475
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002476 gen_clid(new, nn);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002477 add_to_unconfirmed(new);
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002478 swap(new, conf);
Andy Adamson0733d212009-04-03 08:28:01 +03002479out_copy:
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04002480 exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
2481 exid->clientid.cl_id = conf->cl_clientid.cl_id;
Andy Adamson0733d212009-04-03 08:28:01 +03002482
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04002483 exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
2484 nfsd4_set_ex_flags(conf, exid);
Andy Adamson0733d212009-04-03 08:28:01 +03002485
2486 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04002487 conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03002488 status = nfs_ok;
2489
2490out:
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002491 spin_unlock(&nn->client_lock);
J. Bruce Fields50c7b942015-11-23 15:39:12 -07002492out_nolock:
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04002493 if (new)
Trond Myklebust3dbacee2014-07-30 08:27:06 -04002494 expire_client(new);
2495 if (unconf)
2496 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03002497 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002498}
2499
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002500static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04002501check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03002502{
Andy Adamson88e588d2009-07-23 19:02:15 -04002503 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
2504 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002505
2506 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04002507 if (slot_inuse) {
2508 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03002509 return nfserr_jukebox;
2510 else
2511 return nfserr_seq_misordered;
2512 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05002513 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04002514 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03002515 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04002516 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03002517 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002518 return nfserr_seq_misordered;
2519}
2520
Andy Adamson49557cc2009-07-23 19:02:16 -04002521/*
2522 * Cache the create session result into the create session single DRC
2523 * slot cache by saving the xdr structure. sl_seqid has been set.
2524 * Do this for solo or embedded create session operations.
2525 */
2526static void
2527nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002528 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04002529{
2530 slot->sl_status = nfserr;
2531 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
2532}
2533
2534static __be32
2535nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
2536 struct nfsd4_clid_slot *slot)
2537{
2538 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
2539 return slot->sl_status;
2540}
2541
Mi Jinlong1b74c252011-07-14 14:50:17 +08002542#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
2543 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
2544 1 + /* MIN tag is length with zero, only length */ \
2545 3 + /* version, opcount, opcode */ \
2546 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2547 /* seqid, slotID, slotID, cache */ \
2548 4 ) * sizeof(__be32))
2549
2550#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
2551 2 + /* verifier: AUTH_NULL, length 0 */\
2552 1 + /* status */ \
2553 1 + /* MIN tag is length with zero, only length */ \
2554 3 + /* opcount, opcode, opstatus*/ \
2555 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2556 /* seqid, slotID, slotID, slotID, status */ \
2557 5 ) * sizeof(__be32))
2558
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002559static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
Mi Jinlong1b74c252011-07-14 14:50:17 +08002560{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002561 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
2562
J. Bruce Fields373cd402013-04-08 15:42:12 -04002563 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
2564 return nfserr_toosmall;
2565 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
2566 return nfserr_toosmall;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002567 ca->headerpadsz = 0;
2568 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
2569 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
2570 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
2571 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
2572 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
2573 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
2574 /*
2575 * Note decreasing slot size below client's request may make it
2576 * difficult for client to function correctly, whereas
2577 * decreasing the number of slots will (just?) affect
2578 * performance. When short on memory we therefore prefer to
2579 * decrease number of slots instead of their size. Clients that
2580 * request larger slots than they need will get poor results:
2581 */
2582 ca->maxreqs = nfsd4_get_drc_mem(ca);
2583 if (!ca->maxreqs)
2584 return nfserr_jukebox;
2585
J. Bruce Fields373cd402013-04-08 15:42:12 -04002586 return nfs_ok;
Mi Jinlong1b74c252011-07-14 14:50:17 +08002587}
2588
Kinglong Mee8a891632013-12-23 18:11:02 +08002589#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
2590 RPC_MAX_HEADER_WITH_AUTH) * sizeof(__be32))
2591#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
2592 RPC_MAX_REPHEADER_WITH_AUTH) * sizeof(__be32))
2593
J. Bruce Fields06b332a2013-04-09 11:34:36 -04002594static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
2595{
2596 ca->headerpadsz = 0;
2597
2598 /*
2599 * These RPC_MAX_HEADER macros are overkill, especially since we
2600 * don't even do gss on the backchannel yet. But this is still
2601 * less than 1k. Tighten up this estimate in the unlikely event
2602 * it turns out to be a problem for some client:
2603 */
Kinglong Mee8a891632013-12-23 18:11:02 +08002604 if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04002605 return nfserr_toosmall;
Kinglong Mee8a891632013-12-23 18:11:02 +08002606 if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04002607 return nfserr_toosmall;
2608 ca->maxresp_cached = 0;
2609 if (ca->maxops < 2)
2610 return nfserr_toosmall;
2611
2612 return nfs_ok;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002613}
2614
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002615static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
2616{
2617 switch (cbs->flavor) {
2618 case RPC_AUTH_NULL:
2619 case RPC_AUTH_UNIX:
2620 return nfs_ok;
2621 default:
2622 /*
2623 * GSS case: the spec doesn't allow us to return this
2624 * error. But it also doesn't allow us not to support
2625 * GSS.
2626 * I'd rather this fail hard than return some error the
2627 * client might think it can already handle:
2628 */
2629 return nfserr_encr_alg_unsupp;
2630 }
2631}
2632
Andy Adamson069b6ad2009-04-03 08:27:58 +03002633__be32
2634nfsd4_create_session(struct svc_rqst *rqstp,
2635 struct nfsd4_compound_state *cstate,
2636 struct nfsd4_create_session *cr_ses)
2637{
Jeff Layton363168b2009-08-14 12:57:56 -04002638 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002639 struct nfs4_client *conf, *unconf;
Jeff Laytond20c11d2014-07-30 08:27:07 -04002640 struct nfs4_client *old = NULL;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04002641 struct nfsd4_session *new;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002642 struct nfsd4_conn *conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002643 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002644 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002645 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002646
Mi Jinlonga62573d2011-03-23 17:57:07 +08002647 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
2648 return nfserr_inval;
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002649 status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
2650 if (status)
2651 return status;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002652 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
J. Bruce Fields373cd402013-04-08 15:42:12 -04002653 if (status)
2654 return status;
J. Bruce Fields06b332a2013-04-09 11:34:36 -04002655 status = check_backchannel_attrs(&cr_ses->back_channel);
2656 if (status)
Kinglong Meef403e452013-12-23 17:31:21 +08002657 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002658 status = nfserr_jukebox;
Kinglong Mee60810e52014-01-01 00:35:47 +08002659 new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002660 if (!new)
2661 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002662 conn = alloc_conn_from_crses(rqstp, cr_ses);
2663 if (!conn)
2664 goto out_free_session;
Mi Jinlonga62573d2011-03-23 17:57:07 +08002665
Jeff Laytond20c11d2014-07-30 08:27:07 -04002666 spin_lock(&nn->client_lock);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002667 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002668 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002669 WARN_ON_ONCE(conf && unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002670
2671 if (conf) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04002672 status = nfserr_wrong_cred;
2673 if (!mach_creds_match(conf, rqstp))
2674 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002675 cs_slot = &conf->cl_cs_slot;
2676 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Kinglong Meef5e22bb2015-07-13 17:32:34 +08002677 if (status) {
2678 if (status == nfserr_replay_cache)
2679 status = nfsd4_replay_create_session(cr_ses, cs_slot);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002680 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002681 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002682 } else if (unconf) {
2683 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04002684 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002685 status = nfserr_clid_inuse;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002686 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002687 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04002688 status = nfserr_wrong_cred;
2689 if (!mach_creds_match(unconf, rqstp))
2690 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002691 cs_slot = &unconf->cl_cs_slot;
2692 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03002693 if (status) {
2694 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002695 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002696 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002697 }
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002698 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002699 if (old) {
Jeff Laytond20c11d2014-07-30 08:27:07 -04002700 status = mark_client_expired_locked(old);
Jeff Layton7abea1e2014-07-30 08:27:13 -04002701 if (status) {
2702 old = NULL;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002703 goto out_free_conn;
Jeff Layton7abea1e2014-07-30 08:27:13 -04002704 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04002705 }
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04002706 move_to_confirmed(unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002707 conf = unconf;
2708 } else {
2709 status = nfserr_stale_clientid;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002710 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002711 }
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002712 status = nfs_ok;
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002713 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04002714 * We do not support RDMA or persistent sessions
2715 */
2716 cr_ses->flags &= ~SESSION4_PERSIST;
2717 cr_ses->flags &= ~SESSION4_RDMA;
2718
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002719 init_session(rqstp, new, conf, cr_ses);
Jeff Laytond20c11d2014-07-30 08:27:07 -04002720 nfsd4_get_session_locked(new);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002721
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04002722 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002723 NFS4_MAX_SESSIONID_LEN);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04002724 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04002725 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002726
Jeff Laytond20c11d2014-07-30 08:27:07 -04002727 /* cache solo and embedded create sessions under the client_lock */
Andy Adamson49557cc2009-07-23 19:02:16 -04002728 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Jeff Laytond20c11d2014-07-30 08:27:07 -04002729 spin_unlock(&nn->client_lock);
2730 /* init connection and backchannel */
2731 nfsd4_init_conn(rqstp, conn, new);
2732 nfsd4_put_session(new);
Jeff Laytond20c11d2014-07-30 08:27:07 -04002733 if (old)
2734 expire_client(old);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002735 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002736out_free_conn:
Jeff Laytond20c11d2014-07-30 08:27:07 -04002737 spin_unlock(&nn->client_lock);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002738 free_conn(conn);
Jeff Laytond20c11d2014-07-30 08:27:07 -04002739 if (old)
2740 expire_client(old);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002741out_free_session:
2742 __free_session(new);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002743out_release_drc_mem:
2744 nfsd4_put_drc_mem(&cr_ses->fore_channel);
J. Bruce Fields1ca50792013-03-14 18:12:03 -04002745 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002746}
2747
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002748static __be32 nfsd4_map_bcts_dir(u32 *dir)
2749{
2750 switch (*dir) {
2751 case NFS4_CDFC4_FORE:
2752 case NFS4_CDFC4_BACK:
2753 return nfs_ok;
2754 case NFS4_CDFC4_FORE_OR_BOTH:
2755 case NFS4_CDFC4_BACK_OR_BOTH:
2756 *dir = NFS4_CDFC4_BOTH;
2757 return nfs_ok;
2758 };
2759 return nfserr_inval;
2760}
2761
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002762__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
2763{
2764 struct nfsd4_session *session = cstate->session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002765 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002766 __be32 status;
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002767
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002768 status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2769 if (status)
2770 return status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002771 spin_lock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002772 session->se_cb_prog = bc->bc_cb_program;
2773 session->se_cb_sec = bc->bc_cb_sec;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002774 spin_unlock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002775
2776 nfsd4_probe_callback(session->se_client);
2777
2778 return nfs_ok;
2779}
2780
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002781__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2782 struct nfsd4_compound_state *cstate,
2783 struct nfsd4_bind_conn_to_session *bcts)
2784{
2785 __be32 status;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002786 struct nfsd4_conn *conn;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002787 struct nfsd4_session *session;
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002788 struct net *net = SVC_NET(rqstp);
2789 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002790
2791 if (!nfsd4_last_compound_op(rqstp))
2792 return nfserr_not_only_op;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002793 spin_lock(&nn->client_lock);
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002794 session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002795 spin_unlock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002796 if (!session)
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002797 goto out_no_session;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002798 status = nfserr_wrong_cred;
2799 if (!mach_creds_match(session->se_client, rqstp))
2800 goto out;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002801 status = nfsd4_map_bcts_dir(&bcts->dir);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002802 if (status)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002803 goto out;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002804 conn = alloc_conn(rqstp, bcts->dir);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002805 status = nfserr_jukebox;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002806 if (!conn)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002807 goto out;
2808 nfsd4_init_conn(rqstp, conn, session);
2809 status = nfs_ok;
2810out:
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002811 nfsd4_put_session(session);
2812out_no_session:
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002813 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002814}
2815
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002816static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2817{
2818 if (!session)
2819 return 0;
2820 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2821}
2822
Andy Adamson069b6ad2009-04-03 08:27:58 +03002823__be32
2824nfsd4_destroy_session(struct svc_rqst *r,
2825 struct nfsd4_compound_state *cstate,
2826 struct nfsd4_destroy_session *sessionid)
2827{
Benny Halevye10e0cf2009-04-03 08:28:38 +03002828 struct nfsd4_session *ses;
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002829 __be32 status;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002830 int ref_held_by_me = 0;
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002831 struct net *net = SVC_NET(r);
2832 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002833
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002834 status = nfserr_not_only_op;
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002835 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04002836 if (!nfsd4_last_compound_op(r))
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002837 goto out;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002838 ref_held_by_me++;
J. Bruce Fields57716352010-04-21 12:27:19 -04002839 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03002840 dump_sessionid(__func__, &sessionid->sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002841 spin_lock(&nn->client_lock);
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002842 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, net, &status);
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002843 if (!ses)
2844 goto out_client_lock;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002845 status = nfserr_wrong_cred;
2846 if (!mach_creds_match(ses->se_client, r))
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002847 goto out_put_session;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002848 status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002849 if (status)
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002850 goto out_put_session;
Benny Halevye10e0cf2009-04-03 08:28:38 +03002851 unhash_session(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002852 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002853
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05002854 nfsd4_probe_callback_sync(ses->se_client);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04002855
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002856 spin_lock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002857 status = nfs_ok;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002858out_put_session:
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002859 nfsd4_put_session_locked(ses);
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002860out_client_lock:
2861 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002862out:
Benny Halevye10e0cf2009-04-03 08:28:38 +03002863 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002864}
2865
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002866static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002867{
2868 struct nfsd4_conn *c;
2869
2870 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002871 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04002872 return c;
2873 }
2874 }
2875 return NULL;
2876}
2877
J. Bruce Fields57266a62013-04-13 14:27:29 -04002878static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002879{
2880 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002881 struct nfsd4_conn *c;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002882 __be32 status = nfs_ok;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002883 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002884
2885 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002886 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002887 if (c)
2888 goto out_free;
2889 status = nfserr_conn_not_bound_to_session;
2890 if (clp->cl_mach_cred)
2891 goto out_free;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002892 __nfsd4_hash_conn(new, ses);
2893 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002894 ret = nfsd4_register_conn(new);
2895 if (ret)
2896 /* oops; xprt is already down: */
2897 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002898 return nfs_ok;
2899out_free:
2900 spin_unlock(&clp->cl_lock);
2901 free_conn(new);
2902 return status;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002903}
2904
Mi Jinlong868b89c2011-04-27 09:09:58 +08002905static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2906{
2907 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2908
2909 return args->opcnt > session->se_fchannel.maxops;
2910}
2911
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002912static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2913 struct nfsd4_session *session)
2914{
2915 struct xdr_buf *xb = &rqstp->rq_arg;
2916
2917 return xb->len > session->se_fchannel.maxreq_sz;
2918}
2919
Andy Adamson069b6ad2009-04-03 08:27:58 +03002920__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03002921nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002922 struct nfsd4_compound_state *cstate,
2923 struct nfsd4_sequence *seq)
2924{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002925 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002926 struct xdr_stream *xdr = &resp->xdr;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002927 struct nfsd4_session *session;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002928 struct nfs4_client *clp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002929 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002930 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002931 __be32 status;
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002932 int buflen;
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002933 struct net *net = SVC_NET(rqstp);
2934 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002935
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002936 if (resp->opcnt != 1)
2937 return nfserr_sequence_pos;
2938
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002939 /*
2940 * Will be either used or freed by nfsd4_sequence_check_conn
2941 * below.
2942 */
2943 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2944 if (!conn)
2945 return nfserr_jukebox;
2946
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002947 spin_lock(&nn->client_lock);
Trond Myklebustd4e19e702014-06-30 11:48:42 -04002948 session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002949 if (!session)
J. Bruce Fields221a6872013-04-01 22:23:49 -04002950 goto out_no_session;
2951 clp = session->se_client;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002952
Mi Jinlong868b89c2011-04-27 09:09:58 +08002953 status = nfserr_too_many_ops;
2954 if (nfsd4_session_too_many_ops(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002955 goto out_put_session;
Mi Jinlong868b89c2011-04-27 09:09:58 +08002956
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002957 status = nfserr_req_too_big;
2958 if (nfsd4_request_too_big(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002959 goto out_put_session;
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002960
Benny Halevyb85d4c02009-04-03 08:28:08 +03002961 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002962 if (seq->slotid >= session->se_fchannel.maxreqs)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002963 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002964
Andy Adamson557ce262009-08-28 08:45:04 -04002965 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002966 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2967
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002968 /* We do not negotiate the number of slots yet, so set the
2969 * maxslots to the session maxreqs which is used to encode
2970 * sr_highest_slotid and the sr_target_slot id to maxslots */
2971 seq->maxslots = session->se_fchannel.maxreqs;
2972
J. Bruce Fields73e79482012-02-13 16:39:00 -05002973 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2974 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002975 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002976 status = nfserr_seq_misordered;
2977 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002978 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002979 cstate->slot = slot;
2980 cstate->session = session;
Jeff Layton4b24ca72014-06-30 11:48:44 -04002981 cstate->clp = clp;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002982 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002983 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002984 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002985 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002986 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002987 }
2988 if (status)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002989 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002990
J. Bruce Fields57266a62013-04-13 14:27:29 -04002991 status = nfsd4_sequence_check_conn(conn, session);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002992 conn = NULL;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002993 if (status)
2994 goto out_put_session;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002995
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002996 buflen = (seq->cachethis) ?
2997 session->se_fchannel.maxresp_cached :
2998 session->se_fchannel.maxresp_sz;
2999 status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
3000 nfserr_rep_too_big;
J. Bruce Fieldsa5cddc82014-05-12 18:10:58 -04003001 if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
J. Bruce Fields47ee5292014-03-12 21:39:35 -04003002 goto out_put_session;
J. Bruce Fields32aaa622014-03-20 20:47:41 -04003003 svc_reserve(rqstp, buflen);
J. Bruce Fields47ee5292014-03-12 21:39:35 -04003004
3005 status = nfs_ok;
Benny Halevyb85d4c02009-04-03 08:28:08 +03003006 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03003007 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05003008 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05003009 if (seq->cachethis)
3010 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05003011 else
3012 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03003013
3014 cstate->slot = slot;
3015 cstate->session = session;
Jeff Layton4b24ca72014-06-30 11:48:44 -04003016 cstate->clp = clp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03003017
Benny Halevyb85d4c02009-04-03 08:28:08 +03003018out:
J. Bruce Fields221a6872013-04-01 22:23:49 -04003019 switch (clp->cl_cb_state) {
3020 case NFSD4_CB_DOWN:
3021 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
3022 break;
3023 case NFSD4_CB_FAULT:
3024 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
3025 break;
3026 default:
3027 seq->status_flags = 0;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03003028 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003029 if (!list_empty(&clp->cl_revoked))
3030 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
J. Bruce Fields221a6872013-04-01 22:23:49 -04003031out_no_session:
Kinglong Mee3f42d2c2014-03-24 11:56:59 +08003032 if (conn)
3033 free_conn(conn);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003034 spin_unlock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03003035 return status;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04003036out_put_session:
Trond Myklebustd4e19e702014-06-30 11:48:42 -04003037 nfsd4_put_session_locked(session);
J. Bruce Fields221a6872013-04-01 22:23:49 -04003038 goto out_no_session;
Andy Adamson069b6ad2009-04-03 08:27:58 +03003039}
3040
Trond Myklebustb6076642014-06-30 11:48:35 -04003041void
3042nfsd4_sequence_done(struct nfsd4_compoundres *resp)
3043{
3044 struct nfsd4_compound_state *cs = &resp->cstate;
3045
3046 if (nfsd4_has_session(cs)) {
Trond Myklebustb6076642014-06-30 11:48:35 -04003047 if (cs->status != nfserr_replay_cache) {
3048 nfsd4_store_cache_entry(resp);
3049 cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
3050 }
Trond Myklebustd4e19e702014-06-30 11:48:42 -04003051 /* Drop session reference that was taken in nfsd4_sequence() */
Trond Myklebustb6076642014-06-30 11:48:35 -04003052 nfsd4_put_session(cs->session);
Jeff Layton4b24ca72014-06-30 11:48:44 -04003053 } else if (cs->clp)
3054 put_client_renew(cs->clp);
Trond Myklebustb6076642014-06-30 11:48:35 -04003055}
3056
Mi Jinlong345c2842011-10-20 17:51:39 +08003057__be32
3058nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
3059{
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003060 struct nfs4_client *conf, *unconf;
3061 struct nfs4_client *clp = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003062 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03003063 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Mi Jinlong345c2842011-10-20 17:51:39 +08003064
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003065 spin_lock(&nn->client_lock);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03003066 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03003067 conf = find_confirmed_client(&dc->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04003068 WARN_ON_ONCE(conf && unconf);
Mi Jinlong345c2842011-10-20 17:51:39 +08003069
3070 if (conf) {
J. Bruce Fieldsc0293b02013-03-14 18:20:01 -04003071 if (client_has_state(conf)) {
Mi Jinlong345c2842011-10-20 17:51:39 +08003072 status = nfserr_clientid_busy;
3073 goto out;
3074 }
Jeff Laytonfd699b82014-07-30 08:27:14 -04003075 status = mark_client_expired_locked(conf);
3076 if (status)
3077 goto out;
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003078 clp = conf;
Mi Jinlong345c2842011-10-20 17:51:39 +08003079 } else if (unconf)
3080 clp = unconf;
3081 else {
3082 status = nfserr_stale_clientid;
3083 goto out;
3084 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04003085 if (!mach_creds_match(clp, rqstp)) {
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003086 clp = NULL;
J. Bruce Fields57266a62013-04-13 14:27:29 -04003087 status = nfserr_wrong_cred;
3088 goto out;
3089 }
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003090 unhash_client_locked(clp);
Mi Jinlong345c2842011-10-20 17:51:39 +08003091out:
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003092 spin_unlock(&nn->client_lock);
Trond Myklebust6b10ad12014-07-30 08:27:08 -04003093 if (clp)
3094 expire_client(clp);
Mi Jinlong345c2842011-10-20 17:51:39 +08003095 return status;
3096}
3097
Andy Adamson069b6ad2009-04-03 08:27:58 +03003098__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04003099nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
3100{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003101 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003102
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04003103 if (rc->rca_one_fs) {
3104 if (!cstate->current_fh.fh_dentry)
3105 return nfserr_nofilehandle;
3106 /*
3107 * We don't take advantage of the rca_one_fs case.
3108 * That's OK, it's optional, we can safely ignore it.
3109 */
3110 return nfs_ok;
3111 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003112
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003113 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04003114 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
3115 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003116 goto out;
3117
3118 status = nfserr_stale_clientid;
3119 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04003120 /*
3121 * The following error isn't really legal.
3122 * But we only get here if the client just explicitly
3123 * destroyed the client. Surely it no longer cares what
3124 * error it gets back on an operation for the dead
3125 * client.
3126 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003127 goto out;
3128
3129 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04003130 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003131out:
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08003132 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04003133}
3134
3135__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003136nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3137 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04003139 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 nfs4_verifier clverifier = setclid->se_verf;
Trond Myklebust3dbacee2014-07-30 08:27:06 -04003141 struct nfs4_client *conf, *new;
3142 struct nfs4_client *unconf = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003143 __be32 status;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03003144 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3145
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04003146 new = create_client(clname, rqstp, &clverifier);
3147 if (new == NULL)
3148 return nfserr_jukebox;
J. Bruce Fields63db4632012-05-18 21:54:19 -04003149 /* Cases below refer to rfc 3530 section 14.2.33: */
Trond Myklebust3dbacee2014-07-30 08:27:06 -04003150 spin_lock(&nn->client_lock);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03003151 conf = find_confirmed_client_by_name(&clname, nn);
J. Bruce Fields2b634822015-10-15 15:33:23 -04003152 if (conf && client_has_state(conf)) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04003153 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05003155 if (clp_used_exchangeid(conf))
3156 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04003157 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04003158 char addr_str[INET6_ADDRSTRLEN];
3159 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
3160 sizeof(addr_str));
3161 dprintk("NFSD: setclientid: string in use by client "
3162 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 goto out;
3164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03003166 unconf = find_unconfirmed_client_by_name(&clname, nn);
J. Bruce Fields8f930712012-05-18 22:06:41 -04003167 if (unconf)
Trond Myklebust3dbacee2014-07-30 08:27:06 -04003168 unhash_client_locked(unconf);
Kinglong Mee41eb1672015-07-13 17:29:41 +08003169 if (conf && same_verf(&conf->cl_verifier, &clverifier)) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04003170 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 copy_clid(new, conf);
Kinglong Mee41eb1672015-07-13 17:29:41 +08003172 gen_confirm(new, nn);
3173 } else /* case 4 (new client) or cases 2, 3 (client reboot): */
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03003174 gen_clid(new, nn);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04003175 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09003176 gen_callback(new, setclid, rqstp);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05003177 add_to_unconfirmed(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
3179 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
3180 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04003181 new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 status = nfs_ok;
3183out:
Trond Myklebust3dbacee2014-07-30 08:27:06 -04003184 spin_unlock(&nn->client_lock);
Trond Myklebust5cc40fd2014-07-30 08:27:05 -04003185 if (new)
3186 free_client(new);
Trond Myklebust3dbacee2014-07-30 08:27:06 -04003187 if (unconf)
3188 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 return status;
3190}
3191
3192
Al Virob37ad282006-10-19 23:28:59 -07003193__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003194nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
3195 struct nfsd4_compound_state *cstate,
3196 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197{
NeilBrown21ab45a2005-06-23 22:04:14 -07003198 struct nfs4_client *conf, *unconf;
Jeff Laytond20c11d2014-07-30 08:27:07 -04003199 struct nfs4_client *old = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
3201 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07003202 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03003203 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04003205 if (STALE_CLIENTID(clid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206 return nfserr_stale_clientid;
NeilBrown21ab45a2005-06-23 22:04:14 -07003207
Jeff Laytond20c11d2014-07-30 08:27:07 -04003208 spin_lock(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03003209 conf = find_confirmed_client(clid, false, nn);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03003210 unconf = find_unconfirmed_client(clid, false, nn);
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05003211 /*
J. Bruce Fields8695b902012-05-19 10:05:58 -04003212 * We try hard to give out unique clientid's, so if we get an
3213 * attempt to confirm the same clientid with a different cred,
J. Bruce Fieldsf984a7c2015-09-01 13:40:53 -04003214 * the client may be buggy; this should never happen.
3215 *
3216 * Nevertheless, RFC 7530 recommends INUSE for this case:
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05003217 */
J. Bruce Fieldsf984a7c2015-09-01 13:40:53 -04003218 status = nfserr_clid_inuse;
J. Bruce Fields8695b902012-05-19 10:05:58 -04003219 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
3220 goto out;
3221 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
3222 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04003223 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04003224 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
3225 if (conf && !unconf) /* case 2: probable retransmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 status = nfs_ok;
J. Bruce Fields90d700b2012-05-19 13:55:22 -04003227 else /* case 4: client hasn't noticed we rebooted yet? */
3228 status = nfserr_stale_clientid;
3229 goto out;
3230 }
3231 status = nfs_ok;
3232 if (conf) { /* case 1: callback update */
Jeff Laytond20c11d2014-07-30 08:27:07 -04003233 old = unconf;
3234 unhash_client_locked(old);
J. Bruce Fields8695b902012-05-19 10:05:58 -04003235 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04003236 } else { /* case 3: normal case; new or rebooted client */
Jeff Laytond20c11d2014-07-30 08:27:07 -04003237 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
3238 if (old) {
J. Bruce Fields2b634822015-10-15 15:33:23 -04003239 status = nfserr_clid_inuse;
3240 if (client_has_state(old)
3241 && !same_creds(&unconf->cl_cred,
3242 &old->cl_cred))
3243 goto out;
Jeff Laytond20c11d2014-07-30 08:27:07 -04003244 status = mark_client_expired_locked(old);
Jeff Layton7abea1e2014-07-30 08:27:13 -04003245 if (status) {
3246 old = NULL;
J. Bruce Fields221a6872013-04-01 22:23:49 -04003247 goto out;
Jeff Layton7abea1e2014-07-30 08:27:13 -04003248 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003249 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04003250 move_to_confirmed(unconf);
Jeff Laytond20c11d2014-07-30 08:27:07 -04003251 conf = unconf;
NeilBrown08e89872005-06-23 22:04:11 -07003252 }
Jeff Laytond20c11d2014-07-30 08:27:07 -04003253 get_client_locked(conf);
3254 spin_unlock(&nn->client_lock);
3255 nfsd4_probe_callback(conf);
3256 spin_lock(&nn->client_lock);
3257 put_client_renew_locked(conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258out:
Jeff Laytond20c11d2014-07-30 08:27:07 -04003259 spin_unlock(&nn->client_lock);
3260 if (old)
3261 expire_client(old);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 return status;
3263}
3264
J. Bruce Fields32513b42011-10-13 16:00:16 -04003265static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266{
J. Bruce Fields32513b42011-10-13 16:00:16 -04003267 return kmem_cache_alloc(file_slab, GFP_KERNEL);
3268}
3269
3270/* OPEN Share state helper functions */
Jeff Layton5b095e92014-10-23 08:01:02 -04003271static void nfsd4_init_file(struct knfsd_fh *fh, unsigned int hashval,
3272 struct nfs4_file *fp)
J. Bruce Fields32513b42011-10-13 16:00:16 -04003273{
Trond Myklebust950e0112014-06-30 11:48:31 -04003274 lockdep_assert_held(&state_lock);
3275
J. Bruce Fields32513b42011-10-13 16:00:16 -04003276 atomic_set(&fp->fi_ref, 1);
Trond Myklebust1d31a252014-07-10 14:07:25 -04003277 spin_lock_init(&fp->fi_lock);
J. Bruce Fields32513b42011-10-13 16:00:16 -04003278 INIT_LIST_HEAD(&fp->fi_stateids);
3279 INIT_LIST_HEAD(&fp->fi_delegations);
Sachin Bhamare8287f002015-04-27 14:50:14 +02003280 INIT_LIST_HEAD(&fp->fi_clnt_odstate);
Trond Myklebuste2cf80d2014-07-23 16:17:38 -04003281 fh_copy_shallow(&fp->fi_fhandle, fh);
Jeff Layton0c637be2014-08-22 12:05:43 -04003282 fp->fi_deleg_file = NULL;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003283 fp->fi_had_conflict = false;
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003284 fp->fi_share_deny = 0;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003285 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
3286 memset(fp->fi_access, 0, sizeof(fp->fi_access));
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02003287#ifdef CONFIG_NFSD_PNFS
3288 INIT_LIST_HEAD(&fp->fi_lo_states);
Christoph Hellwigc5c707f2014-09-23 12:38:48 +02003289 atomic_set(&fp->fi_lo_recalls, 0);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02003290#endif
Jeff Layton5b095e92014-10-23 08:01:02 -04003291 hlist_add_head_rcu(&fp->fi_hash, &file_hashtbl[hashval]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292}
3293
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003294void
NeilBrowne60d4392005-06-23 22:03:01 -07003295nfsd4_free_slabs(void)
3296{
Sachin Bhamare8287f002015-04-27 14:50:14 +02003297 kmem_cache_destroy(odstate_slab);
Christoph Hellwigabf11352014-05-21 07:43:03 -07003298 kmem_cache_destroy(openowner_slab);
3299 kmem_cache_destroy(lockowner_slab);
3300 kmem_cache_destroy(file_slab);
3301 kmem_cache_destroy(stateid_slab);
3302 kmem_cache_destroy(deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07003303}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304
Bryan Schumaker72083392011-11-01 15:24:59 -04003305int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306nfsd4_init_slabs(void)
3307{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003308 openowner_slab = kmem_cache_create("nfsd4_openowners",
3309 sizeof(struct nfs4_openowner), 0, 0, NULL);
3310 if (openowner_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07003311 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003312 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
Yanchuan Nian3c407942012-10-24 14:44:19 +08003313 sizeof(struct nfs4_lockowner), 0, 0, NULL);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003314 if (lockowner_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07003315 goto out_free_openowner_slab;
NeilBrowne60d4392005-06-23 22:03:01 -07003316 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09003317 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07003318 if (file_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07003319 goto out_free_lockowner_slab;
NeilBrown5ac049a2005-06-23 22:03:03 -07003320 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003321 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07003322 if (stateid_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07003323 goto out_free_file_slab;
NeilBrown5b2d21c2005-06-23 22:03:04 -07003324 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09003325 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07003326 if (deleg_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07003327 goto out_free_stateid_slab;
Sachin Bhamare8287f002015-04-27 14:50:14 +02003328 odstate_slab = kmem_cache_create("nfsd4_odstate",
3329 sizeof(struct nfs4_clnt_odstate), 0, 0, NULL);
3330 if (odstate_slab == NULL)
3331 goto out_free_deleg_slab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 return 0;
Christoph Hellwigabf11352014-05-21 07:43:03 -07003333
Sachin Bhamare8287f002015-04-27 14:50:14 +02003334out_free_deleg_slab:
3335 kmem_cache_destroy(deleg_slab);
Christoph Hellwigabf11352014-05-21 07:43:03 -07003336out_free_stateid_slab:
3337 kmem_cache_destroy(stateid_slab);
3338out_free_file_slab:
3339 kmem_cache_destroy(file_slab);
3340out_free_lockowner_slab:
3341 kmem_cache_destroy(lockowner_slab);
3342out_free_openowner_slab:
3343 kmem_cache_destroy(openowner_slab);
3344out:
NeilBrowne60d4392005-06-23 22:03:01 -07003345 dprintk("nfsd4: out of memory while initializing nfsv4\n");
3346 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347}
3348
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003349static void init_nfs4_replay(struct nfs4_replay *rp)
3350{
3351 rp->rp_status = nfserr_serverfault;
3352 rp->rp_buflen = 0;
3353 rp->rp_buf = rp->rp_ibuf;
Jeff Layton58fb12e2014-07-29 21:34:27 -04003354 mutex_init(&rp->rp_mutex);
3355}
3356
3357static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate,
3358 struct nfs4_stateowner *so)
3359{
3360 if (!nfsd4_has_session(cstate)) {
3361 mutex_lock(&so->so_replay.rp_mutex);
Kinglong Meeb5971af2014-08-22 10:18:43 -04003362 cstate->replay_owner = nfs4_get_stateowner(so);
Jeff Layton58fb12e2014-07-29 21:34:27 -04003363 }
3364}
3365
3366void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate)
3367{
3368 struct nfs4_stateowner *so = cstate->replay_owner;
3369
3370 if (so != NULL) {
3371 cstate->replay_owner = NULL;
3372 mutex_unlock(&so->so_replay.rp_mutex);
3373 nfs4_put_stateowner(so);
3374 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003375}
3376
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003377static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378{
3379 struct nfs4_stateowner *sop;
3380
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003381 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003382 if (!sop)
3383 return NULL;
3384
3385 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
3386 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003387 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003388 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003390 sop->so_owner.len = owner->len;
3391
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003392 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003393 sop->so_client = clp;
3394 init_nfs4_replay(&sop->so_replay);
Jeff Layton6b180f02014-07-29 21:34:26 -04003395 atomic_set(&sop->so_count, 1);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003396 return sop;
3397}
3398
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003399static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003400{
Trond Myklebustd4f04892014-07-29 21:34:36 -04003401 lockdep_assert_held(&clp->cl_lock);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03003402
Trond Myklebustd4f04892014-07-29 21:34:36 -04003403 list_add(&oo->oo_owner.so_strhash,
3404 &clp->cl_ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003405 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406}
3407
Jeff Layton8f4b54c2014-07-29 21:34:29 -04003408static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
3409{
Trond Myklebustd4f04892014-07-29 21:34:36 -04003410 unhash_openowner_locked(openowner(so));
Jeff Layton8f4b54c2014-07-29 21:34:29 -04003411}
3412
Jeff Layton6b180f02014-07-29 21:34:26 -04003413static void nfs4_free_openowner(struct nfs4_stateowner *so)
3414{
3415 struct nfs4_openowner *oo = openowner(so);
3416
3417 kmem_cache_free(openowner_slab, oo);
3418}
3419
3420static const struct nfs4_stateowner_operations openowner_ops = {
Jeff Layton8f4b54c2014-07-29 21:34:29 -04003421 .so_unhash = nfs4_unhash_openowner,
3422 .so_free = nfs4_free_openowner,
Jeff Layton6b180f02014-07-29 21:34:26 -04003423};
3424
Andrew Elble7fc05642015-11-05 20:42:43 -05003425static struct nfs4_ol_stateid *
3426nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
3427{
3428 struct nfs4_ol_stateid *local, *ret = NULL;
3429 struct nfs4_openowner *oo = open->op_openowner;
3430
3431 lockdep_assert_held(&fp->fi_lock);
3432
3433 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
3434 /* ignore lock owners */
3435 if (local->st_stateowner->so_is_open_owner == 0)
3436 continue;
3437 if (local->st_stateowner == &oo->oo_owner) {
3438 ret = local;
3439 atomic_inc(&ret->st_stid.sc_count);
3440 break;
3441 }
3442 }
3443 return ret;
3444}
3445
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003446static struct nfs4_openowner *
Trond Myklebust13d6f662014-06-30 11:48:45 -04003447alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
Jeff Laytondb24b3b2014-06-30 11:48:36 -04003448 struct nfsd4_compound_state *cstate)
3449{
Trond Myklebust13d6f662014-06-30 11:48:45 -04003450 struct nfs4_client *clp = cstate->clp;
Trond Myklebust7ffb5882014-07-29 21:34:34 -04003451 struct nfs4_openowner *oo, *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003453 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
3454 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455 return NULL;
Jeff Layton6b180f02014-07-29 21:34:26 -04003456 oo->oo_owner.so_ops = &openowner_ops;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003457 oo->oo_owner.so_is_open_owner = 1;
3458 oo->oo_owner.so_seqid = open->op_seqid;
Jeff Laytond3134b12014-07-29 21:34:32 -04003459 oo->oo_flags = 0;
Jeff Laytondb24b3b2014-06-30 11:48:36 -04003460 if (nfsd4_has_session(cstate))
3461 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003462 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003463 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003464 INIT_LIST_HEAD(&oo->oo_close_lru);
Trond Myklebustd4f04892014-07-29 21:34:36 -04003465 spin_lock(&clp->cl_lock);
3466 ret = find_openstateowner_str_locked(strhashval, open, clp);
Trond Myklebust7ffb5882014-07-29 21:34:34 -04003467 if (ret == NULL) {
3468 hash_openowner(oo, clp, strhashval);
3469 ret = oo;
3470 } else
Kinglong Meed50ffde2015-07-16 12:05:07 +08003471 nfs4_free_stateowner(&oo->oo_owner);
3472
Trond Myklebustd4f04892014-07-29 21:34:36 -04003473 spin_unlock(&clp->cl_lock);
Jeff Laytonc5952332015-03-23 10:53:42 -04003474 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003475}
3476
Andrew Elble7fc05642015-11-05 20:42:43 -05003477static struct nfs4_ol_stateid *
3478init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp,
3479 struct nfsd4_open *open)
3480{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481
Andrew Elble7fc05642015-11-05 20:42:43 -05003482 struct nfs4_openowner *oo = open->op_openowner;
3483 struct nfs4_ol_stateid *retstp = NULL;
3484
3485 spin_lock(&oo->oo_owner.so_client->cl_lock);
3486 spin_lock(&fp->fi_lock);
3487
3488 retstp = nfsd4_find_existing_open(fp, open);
3489 if (retstp)
3490 goto out_unlock;
Trond Myklebustd6f2bc52014-07-29 21:34:19 -04003491 atomic_inc(&stp->st_stid.sc_count);
J. Bruce Fields3abdb602013-02-03 12:23:01 -05003492 stp->st_stid.sc_type = NFS4_OPEN_STID;
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04003493 INIT_LIST_HEAD(&stp->st_locks);
Kinglong Meeb5971af2014-08-22 10:18:43 -04003494 stp->st_stateowner = nfs4_get_stateowner(&oo->oo_owner);
NeilBrown13cd2182005-06-23 22:03:10 -07003495 get_nfs4_file(fp);
Trond Myklebust11b91642014-07-29 21:34:08 -04003496 stp->st_stid.sc_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497 stp->st_access_bmap = 0;
3498 stp->st_deny_bmap = 0;
NeilBrown4c4cd222005-07-07 17:59:27 -07003499 stp->st_openstp = NULL;
Jeff Layton35a92fe2015-09-17 07:47:08 -04003500 init_rwsem(&stp->st_rwsem);
Jeff Layton1c755dc2014-07-29 21:34:12 -04003501 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
Trond Myklebust1d31a252014-07-10 14:07:25 -04003502 list_add(&stp->st_perfile, &fp->fi_stateids);
Andrew Elble7fc05642015-11-05 20:42:43 -05003503
3504out_unlock:
Trond Myklebust1d31a252014-07-10 14:07:25 -04003505 spin_unlock(&fp->fi_lock);
Jeff Layton1c755dc2014-07-29 21:34:12 -04003506 spin_unlock(&oo->oo_owner.so_client->cl_lock);
Andrew Elble7fc05642015-11-05 20:42:43 -05003507 return retstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508}
3509
Jeff Laytond3134b12014-07-29 21:34:32 -04003510/*
3511 * In the 4.0 case we need to keep the owners around a little while to handle
3512 * CLOSE replay. We still do need to release any file access that is held by
3513 * them before returning however.
3514 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515static void
Jeff Laytond3134b12014-07-29 21:34:32 -04003516move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003517{
Jeff Layton217526e2014-07-30 08:27:11 -04003518 struct nfs4_ol_stateid *last;
Jeff Laytond3134b12014-07-29 21:34:32 -04003519 struct nfs4_openowner *oo = openowner(s->st_stateowner);
3520 struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net,
3521 nfsd_net_id);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003522
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003523 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524
Jeff Laytonb401be222014-07-29 21:34:33 -04003525 /*
3526 * We know that we hold one reference via nfsd4_close, and another
3527 * "persistent" reference for the client. If the refcount is higher
3528 * than 2, then there are still calls in progress that are using this
3529 * stateid. We can't put the sc_file reference until they are finished.
3530 * Wait for the refcount to drop to 2. Since it has been unhashed,
3531 * there should be no danger of the refcount going back up again at
3532 * this point.
3533 */
3534 wait_event(close_wq, atomic_read(&s->st_stid.sc_count) == 2);
3535
Jeff Laytond3134b12014-07-29 21:34:32 -04003536 release_all_access(s);
3537 if (s->st_stid.sc_file) {
3538 put_nfs4_file(s->st_stid.sc_file);
3539 s->st_stid.sc_file = NULL;
3540 }
Jeff Layton217526e2014-07-30 08:27:11 -04003541
3542 spin_lock(&nn->client_lock);
3543 last = oo->oo_last_closed_stid;
Jeff Laytond3134b12014-07-29 21:34:32 -04003544 oo->oo_last_closed_stid = s;
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003545 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003546 oo->oo_time = get_seconds();
Jeff Layton217526e2014-07-30 08:27:11 -04003547 spin_unlock(&nn->client_lock);
3548 if (last)
3549 nfs4_put_stid(&last->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550}
3551
Linus Torvalds1da177e2005-04-16 15:20:36 -07003552/* search file_hashtbl[] for file */
3553static struct nfs4_file *
Jeff Layton5b095e92014-10-23 08:01:02 -04003554find_file_locked(struct knfsd_fh *fh, unsigned int hashval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003556 struct nfs4_file *fp;
3557
Jeff Layton5b095e92014-10-23 08:01:02 -04003558 hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash) {
Christoph Hellwig4d94c2e2014-08-14 08:41:48 +02003559 if (fh_match(&fp->fi_fhandle, fh)) {
Jeff Layton5b095e92014-10-23 08:01:02 -04003560 if (atomic_inc_not_zero(&fp->fi_ref))
3561 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07003562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 }
3564 return NULL;
3565}
3566
Christoph Hellwige6ba76e2014-08-14 08:50:16 +02003567struct nfs4_file *
Trond Myklebustca943212014-07-23 16:17:39 -04003568find_file(struct knfsd_fh *fh)
Trond Myklebust950e0112014-06-30 11:48:31 -04003569{
3570 struct nfs4_file *fp;
Jeff Layton5b095e92014-10-23 08:01:02 -04003571 unsigned int hashval = file_hashval(fh);
Trond Myklebust950e0112014-06-30 11:48:31 -04003572
Jeff Layton5b095e92014-10-23 08:01:02 -04003573 rcu_read_lock();
3574 fp = find_file_locked(fh, hashval);
3575 rcu_read_unlock();
Trond Myklebust950e0112014-06-30 11:48:31 -04003576 return fp;
3577}
3578
3579static struct nfs4_file *
Jeff Laytonf9c00c32014-07-23 16:17:41 -04003580find_or_add_file(struct nfs4_file *new, struct knfsd_fh *fh)
Trond Myklebust950e0112014-06-30 11:48:31 -04003581{
3582 struct nfs4_file *fp;
Jeff Layton5b095e92014-10-23 08:01:02 -04003583 unsigned int hashval = file_hashval(fh);
3584
3585 rcu_read_lock();
3586 fp = find_file_locked(fh, hashval);
3587 rcu_read_unlock();
3588 if (fp)
3589 return fp;
Trond Myklebust950e0112014-06-30 11:48:31 -04003590
3591 spin_lock(&state_lock);
Jeff Layton5b095e92014-10-23 08:01:02 -04003592 fp = find_file_locked(fh, hashval);
3593 if (likely(fp == NULL)) {
3594 nfsd4_init_file(fh, hashval, new);
Trond Myklebust950e0112014-06-30 11:48:31 -04003595 fp = new;
3596 }
3597 spin_unlock(&state_lock);
3598
3599 return fp;
3600}
3601
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04003602/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 * Called to check deny when READ with all zero stateid or
3604 * WRITE with all zero or all one stateid
3605 */
Al Virob37ad282006-10-19 23:28:59 -07003606static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
3608{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609 struct nfs4_file *fp;
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003610 __be32 ret = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003611
Trond Myklebustca943212014-07-23 16:17:39 -04003612 fp = find_file(&current_fh->fh_handle);
NeilBrown13cd2182005-06-23 22:03:10 -07003613 if (!fp)
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003614 return ret;
3615 /* Check for conflicting share reservations */
Trond Myklebust1d31a252014-07-10 14:07:25 -04003616 spin_lock(&fp->fi_lock);
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003617 if (fp->fi_share_deny & deny_type)
3618 ret = nfserr_locked;
Trond Myklebust1d31a252014-07-10 14:07:25 -04003619 spin_unlock(&fp->fi_lock);
NeilBrown13cd2182005-06-23 22:03:10 -07003620 put_nfs4_file(fp);
3621 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003622}
3623
Christoph Hellwig0162ac22014-09-24 12:19:19 +02003624static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625{
Christoph Hellwig0162ac22014-09-24 12:19:19 +02003626 struct nfs4_delegation *dp = cb_to_delegation(cb);
Trond Myklebust11b91642014-07-29 21:34:08 -04003627 struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net,
3628 nfsd_net_id);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04003629
Trond Myklebust11b91642014-07-29 21:34:08 -04003630 block_delegations(&dp->dl_stid.sc_file->fi_fhandle);
Jeff Laytonf54fe962014-07-25 07:34:26 -04003631
Jeff Layton02e12152014-07-16 10:31:57 -04003632 /*
3633 * We can't do this in nfsd_break_deleg_cb because it is
Jeff Laytonf54fe962014-07-25 07:34:26 -04003634 * already holding inode->i_lock.
3635 *
Jeff Laytondff13992014-07-08 14:02:49 -04003636 * If the dl_time != 0, then we know that it has already been
3637 * queued for a lease break. Don't queue it again.
3638 */
Jeff Laytonf54fe962014-07-25 07:34:26 -04003639 spin_lock(&state_lock);
Jeff Laytondff13992014-07-08 14:02:49 -04003640 if (dp->dl_time == 0) {
Jeff Laytondff13992014-07-08 14:02:49 -04003641 dp->dl_time = get_seconds();
Jeff Layton02e12152014-07-16 10:31:57 -04003642 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
Jeff Laytondff13992014-07-08 14:02:49 -04003643 }
Jeff Layton02e12152014-07-16 10:31:57 -04003644 spin_unlock(&state_lock);
3645}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003646
Christoph Hellwig0162ac22014-09-24 12:19:19 +02003647static int nfsd4_cb_recall_done(struct nfsd4_callback *cb,
3648 struct rpc_task *task)
3649{
3650 struct nfs4_delegation *dp = cb_to_delegation(cb);
3651
Andrew Elblea4579742015-08-31 12:06:41 -04003652 if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID)
3653 return 1;
3654
Christoph Hellwig0162ac22014-09-24 12:19:19 +02003655 switch (task->tk_status) {
3656 case 0:
3657 return 1;
3658 case -EBADHANDLE:
3659 case -NFS4ERR_BAD_STATEID:
3660 /*
3661 * Race: client probably got cb_recall before open reply
3662 * granting delegation.
3663 */
3664 if (dp->dl_retries--) {
3665 rpc_delay(task, 2 * HZ);
3666 return 0;
3667 }
3668 /*FALLTHRU*/
3669 default:
3670 return -1;
3671 }
3672}
3673
3674static void nfsd4_cb_recall_release(struct nfsd4_callback *cb)
3675{
3676 struct nfs4_delegation *dp = cb_to_delegation(cb);
3677
3678 nfs4_put_stid(&dp->dl_stid);
3679}
3680
Julia Lawallc4cb8972015-11-21 22:57:39 +01003681static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = {
Christoph Hellwig0162ac22014-09-24 12:19:19 +02003682 .prepare = nfsd4_cb_recall_prepare,
3683 .done = nfsd4_cb_recall_done,
3684 .release = nfsd4_cb_recall_release,
3685};
3686
Jeff Layton02e12152014-07-16 10:31:57 -04003687static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
3688{
3689 /*
3690 * We're assuming the state code never drops its reference
3691 * without first removing the lease. Since we're in this lease
3692 * callback (and since the lease code is serialized by the kernel
3693 * lock) we know the server hasn't removed the lease yet, we know
3694 * it's safe to take a reference.
3695 */
Trond Myklebust72c0b0f2014-07-21 09:34:58 -04003696 atomic_inc(&dp->dl_stid.sc_count);
Christoph Hellwigf0b5de12014-09-24 12:19:18 +02003697 nfsd4_run_cb(&dp->dl_recall);
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05003698}
3699
Jeff Layton1c8c6012013-06-21 08:58:15 -04003700/* Called from break_lease() with i_lock held. */
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003701static bool
3702nfsd_break_deleg_cb(struct file_lock *fl)
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05003703{
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003704 bool ret = false;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003705 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
3706 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05003707
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04003708 if (!fp) {
3709 WARN(1, "(%p)->fl_owner NULL\n", fl);
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003710 return ret;
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04003711 }
3712 if (fp->fi_had_conflict) {
3713 WARN(1, "duplicate break on %p\n", fp);
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003714 return ret;
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04003715 }
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04003716 /*
3717 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003718 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05003719 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04003720 */
3721 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722
Jeff Layton02e12152014-07-16 10:31:57 -04003723 spin_lock(&fp->fi_lock);
Jeff Layton417c6622014-07-21 09:34:57 -04003724 fp->fi_had_conflict = true;
3725 /*
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003726 * If there are no delegations on the list, then return true
3727 * so that the lease code will go ahead and delete it.
Jeff Layton417c6622014-07-21 09:34:57 -04003728 */
3729 if (list_empty(&fp->fi_delegations))
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003730 ret = true;
Jeff Layton417c6622014-07-21 09:34:57 -04003731 else
3732 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
3733 nfsd_break_one_deleg(dp);
Jeff Layton02e12152014-07-16 10:31:57 -04003734 spin_unlock(&fp->fi_lock);
Jeff Layton4d01b7f2014-09-01 15:06:54 -04003735 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736}
3737
Jeff Laytonc45198e2014-09-01 07:12:07 -04003738static int
Jeff Layton7448cc32015-01-16 15:05:57 -05003739nfsd_change_deleg_cb(struct file_lock *onlist, int arg,
3740 struct list_head *dispose)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741{
3742 if (arg & F_UNLCK)
Jeff Laytonc45198e2014-09-01 07:12:07 -04003743 return lease_modify(onlist, arg, dispose);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744 else
3745 return -EAGAIN;
3746}
3747
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003748static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04003749 .lm_break = nfsd_break_deleg_cb,
3750 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751};
3752
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003753static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
3754{
3755 if (nfsd4_has_session(cstate))
3756 return nfs_ok;
3757 if (seqid == so->so_seqid - 1)
3758 return nfserr_replay_me;
3759 if (seqid == so->so_seqid)
3760 return nfs_ok;
3761 return nfserr_bad_seqid;
3762}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763
Jeff Layton4b24ca72014-06-30 11:48:44 -04003764static __be32 lookup_clientid(clientid_t *clid,
3765 struct nfsd4_compound_state *cstate,
3766 struct nfsd_net *nn)
3767{
3768 struct nfs4_client *found;
3769
3770 if (cstate->clp) {
3771 found = cstate->clp;
3772 if (!same_clid(&found->cl_clientid, clid))
3773 return nfserr_stale_clientid;
3774 return nfs_ok;
3775 }
3776
3777 if (STALE_CLIENTID(clid, nn))
3778 return nfserr_stale_clientid;
3779
3780 /*
3781 * For v4.1+ we get the client in the SEQUENCE op. If we don't have one
3782 * cached already then we know this is for is for v4.0 and "sessions"
3783 * will be false.
3784 */
3785 WARN_ON_ONCE(cstate->session);
Trond Myklebust3e339f92014-07-30 08:27:09 -04003786 spin_lock(&nn->client_lock);
Jeff Layton4b24ca72014-06-30 11:48:44 -04003787 found = find_confirmed_client(clid, false, nn);
Trond Myklebust3e339f92014-07-30 08:27:09 -04003788 if (!found) {
3789 spin_unlock(&nn->client_lock);
Jeff Layton4b24ca72014-06-30 11:48:44 -04003790 return nfserr_expired;
Trond Myklebust3e339f92014-07-30 08:27:09 -04003791 }
3792 atomic_inc(&found->cl_refcount);
3793 spin_unlock(&nn->client_lock);
Jeff Layton4b24ca72014-06-30 11:48:44 -04003794
3795 /* Cache the nfs4_client in cstate! */
3796 cstate->clp = found;
Jeff Layton4b24ca72014-06-30 11:48:44 -04003797 return nfs_ok;
3798}
3799
Al Virob37ad282006-10-19 23:28:59 -07003800__be32
Andy Adamson66689582009-04-03 08:28:45 +03003801nfsd4_process_open1(struct nfsd4_compound_state *cstate,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003802 struct nfsd4_open *open, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003803{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804 clientid_t *clientid = &open->op_clientid;
3805 struct nfs4_client *clp = NULL;
3806 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003807 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003808 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04003810 if (STALE_CLIENTID(&open->op_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003812 /*
3813 * In case we need it later, after we've already created the
3814 * file and don't want to risk a further failure:
3815 */
3816 open->op_file = nfsd4_alloc_file();
3817 if (open->op_file == NULL)
3818 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819
Trond Myklebust2d91e892014-06-30 11:48:46 -04003820 status = lookup_clientid(clientid, cstate, nn);
3821 if (status)
3822 return status;
3823 clp = cstate->clp;
3824
Trond Myklebustd4f04892014-07-29 21:34:36 -04003825 strhashval = ownerstr_hashval(&open->op_owner);
3826 oo = find_openstateowner_str(strhashval, open, clp);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003827 open->op_openowner = oo;
3828 if (!oo) {
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04003829 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003830 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003831 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08003832 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003833 release_openowner(oo);
3834 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04003835 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08003836 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003837 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
3838 if (status)
3839 return status;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003840 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04003841new_owner:
Trond Myklebust13d6f662014-06-30 11:48:45 -04003842 oo = alloc_init_open_stateowner(strhashval, open, cstate);
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04003843 if (oo == NULL)
3844 return nfserr_jukebox;
3845 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003846alloc_stateid:
Jeff Laytonb49e0842014-07-29 21:34:11 -04003847 open->op_stp = nfs4_alloc_open_stateid(clp);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003848 if (!open->op_stp)
3849 return nfserr_jukebox;
Sachin Bhamare8287f002015-04-27 14:50:14 +02003850
3851 if (nfsd4_has_session(cstate) &&
3852 (cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) {
3853 open->op_odstate = alloc_clnt_odstate(clp);
3854 if (!open->op_odstate)
3855 return nfserr_jukebox;
3856 }
3857
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08003858 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003859}
3860
Al Virob37ad282006-10-19 23:28:59 -07003861static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07003862nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
3863{
3864 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
3865 return nfserr_openmode;
3866 else
3867 return nfs_ok;
3868}
3869
Daniel Mackc47d8322011-05-16 16:38:14 +02003870static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04003871{
J. Bruce Fields24a01112010-05-18 20:01:35 -04003872 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
3873}
3874
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003875static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04003876{
3877 struct nfs4_stid *ret;
3878
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003879 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04003880 if (!ret)
3881 return NULL;
3882 return delegstateid(ret);
3883}
3884
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003885static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
3886{
3887 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
3888 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
3889}
3890
Al Virob37ad282006-10-19 23:28:59 -07003891static __be32
J. Bruce Fields41d22662013-03-21 15:49:47 -04003892nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07003893 struct nfs4_delegation **dp)
3894{
3895 int flags;
Al Virob37ad282006-10-19 23:28:59 -07003896 __be32 status = nfserr_bad_stateid;
Trond Myklebustdcd94cc2014-07-29 21:34:18 -04003897 struct nfs4_delegation *deleg;
NeilBrown567d9822005-06-23 22:02:53 -07003898
Trond Myklebustdcd94cc2014-07-29 21:34:18 -04003899 deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);
3900 if (deleg == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07003901 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04003902 flags = share_access_to_flags(open->op_share_access);
Trond Myklebustdcd94cc2014-07-29 21:34:18 -04003903 status = nfs4_check_delegmode(deleg, flags);
3904 if (status) {
3905 nfs4_put_stid(&deleg->dl_stid);
3906 goto out;
3907 }
3908 *dp = deleg;
NeilBrownc44c5ee2005-06-23 22:02:54 -07003909out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003910 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003911 return nfs_ok;
3912 if (status)
3913 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003914 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07003915 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07003916}
3917
J. Bruce Fields21fb4012010-07-28 12:21:23 -04003918static inline int nfs4_access_to_access(u32 nfs4_access)
3919{
3920 int flags = 0;
3921
3922 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
3923 flags |= NFSD_MAY_READ;
3924 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
3925 flags |= NFSD_MAY_WRITE;
3926 return flags;
3927}
3928
Al Virob37ad282006-10-19 23:28:59 -07003929static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003930nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
3931 struct nfsd4_open *open)
3932{
3933 struct iattr iattr = {
3934 .ia_valid = ATTR_SIZE,
3935 .ia_size = 0,
3936 };
3937 if (!open->op_truncate)
3938 return 0;
3939 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08003940 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
3942}
3943
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003944static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
Jeff Layton6eb3a1d2014-07-10 14:07:31 -04003945 struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
3946 struct nfsd4_open *open)
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003947{
Trond Myklebustde186432014-07-10 14:07:26 -04003948 struct file *filp = NULL;
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003949 __be32 status;
3950 int oflag = nfs4_access_to_omode(open->op_share_access);
3951 int access = nfs4_access_to_access(open->op_share_access);
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003952 unsigned char old_access_bmap, old_deny_bmap;
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003953
Trond Myklebustde186432014-07-10 14:07:26 -04003954 spin_lock(&fp->fi_lock);
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003955
3956 /*
3957 * Are we trying to set a deny mode that would conflict with
3958 * current access?
3959 */
3960 status = nfs4_file_check_deny(fp, open->op_share_deny);
3961 if (status != nfs_ok) {
3962 spin_unlock(&fp->fi_lock);
3963 goto out;
3964 }
3965
3966 /* set access to the file */
3967 status = nfs4_file_get_access(fp, open->op_share_access);
3968 if (status != nfs_ok) {
3969 spin_unlock(&fp->fi_lock);
3970 goto out;
3971 }
3972
3973 /* Set access bits in stateid */
3974 old_access_bmap = stp->st_access_bmap;
3975 set_access(open->op_share_access, stp);
3976
3977 /* Set new deny mask */
3978 old_deny_bmap = stp->st_deny_bmap;
3979 set_deny(open->op_share_deny, stp);
3980 fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
3981
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003982 if (!fp->fi_fds[oflag]) {
Trond Myklebustde186432014-07-10 14:07:26 -04003983 spin_unlock(&fp->fi_lock);
3984 status = nfsd_open(rqstp, cur_fh, S_IFREG, access, &filp);
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003985 if (status)
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04003986 goto out_put_access;
Trond Myklebustde186432014-07-10 14:07:26 -04003987 spin_lock(&fp->fi_lock);
3988 if (!fp->fi_fds[oflag]) {
3989 fp->fi_fds[oflag] = filp;
3990 filp = NULL;
3991 }
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003992 }
Trond Myklebustde186432014-07-10 14:07:26 -04003993 spin_unlock(&fp->fi_lock);
3994 if (filp)
3995 fput(filp);
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003996
3997 status = nfsd4_truncate(rqstp, cur_fh, open);
3998 if (status)
3999 goto out_put_access;
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04004000out:
4001 return status;
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04004002out_put_access:
4003 stp->st_access_bmap = old_access_bmap;
4004 nfs4_file_put_access(fp, open->op_share_access);
4005 reset_union_bmap_deny(bmap_to_share_mode(old_deny_bmap), stp);
4006 goto out;
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04004007}
4008
Al Virob37ad282006-10-19 23:28:59 -07004009static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004010nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004011{
Al Virob37ad282006-10-19 23:28:59 -07004012 __be32 status;
Arnd Bergmann6ac75362015-05-12 23:31:29 +02004013 unsigned char old_deny_bmap = stp->st_deny_bmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004014
Jeff Layton6eb3a1d2014-07-10 14:07:31 -04004015 if (!test_access(open->op_share_access, stp))
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04004016 return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open);
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04004017
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04004018 /* test and set deny mode */
4019 spin_lock(&fp->fi_lock);
4020 status = nfs4_file_check_deny(fp, open->op_share_deny);
4021 if (status == nfs_ok) {
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04004022 set_deny(open->op_share_deny, stp);
4023 fp->fi_share_deny |=
4024 (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
4025 }
4026 spin_unlock(&fp->fi_lock);
4027
4028 if (status != nfs_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004029 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030
Jeff Laytonbaeb4ff2014-07-10 14:07:34 -04004031 status = nfsd4_truncate(rqstp, cur_fh, open);
4032 if (status != nfs_ok)
4033 reset_union_bmap_deny(old_deny_bmap, stp);
4034 return status;
4035}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004036
J. Bruce Fields14a24e92010-12-10 19:02:49 -05004037/* Should we give out recallable state?: */
4038static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
4039{
4040 if (clp->cl_cb_state == NFSD4_CB_UP)
4041 return true;
4042 /*
4043 * In the sessions case, since we don't have to establish a
4044 * separate connection for callbacks, we assume it's OK
4045 * until we hear otherwise:
4046 */
4047 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
4048}
4049
Jeff Laytond564fbe2014-07-16 10:31:58 -04004050static struct file_lock *nfs4_alloc_init_lease(struct nfs4_file *fp, int flag)
J. Bruce Fields22d38c42011-01-31 11:55:12 -05004051{
4052 struct file_lock *fl;
4053
4054 fl = locks_alloc_lock();
4055 if (!fl)
4056 return NULL;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05004057 fl->fl_lmops = &nfsd_lease_mng_ops;
J. Bruce Fields617588d2011-07-01 15:18:34 -04004058 fl->fl_flags = FL_DELEG;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05004059 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
4060 fl->fl_end = OFFSET_MAX;
Jeff Laytond564fbe2014-07-16 10:31:58 -04004061 fl->fl_owner = (fl_owner_t)fp;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05004062 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05004063 return fl;
4064}
4065
Andrew Elble34ed9872015-10-15 12:07:28 -04004066/**
4067 * nfs4_setlease - Obtain a delegation by requesting lease from vfs layer
4068 * @dp: a pointer to the nfs4_delegation we're adding.
4069 *
4070 * Return:
4071 * On success: Return code will be 0 on success.
4072 *
4073 * On error: -EAGAIN if there was an existing delegation.
4074 * nonzero if there is an error in other cases.
4075 *
4076 */
4077
J. Bruce Fields99c41512013-05-21 16:21:25 -04004078static int nfs4_setlease(struct nfs4_delegation *dp)
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05004079{
Trond Myklebust11b91642014-07-29 21:34:08 -04004080 struct nfs4_file *fp = dp->dl_stid.sc_file;
Kinglong Meeefde6b42015-07-13 17:33:24 +08004081 struct file_lock *fl;
Jeff Layton417c6622014-07-21 09:34:57 -04004082 struct file *filp;
4083 int status = 0;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05004084
Jeff Laytond564fbe2014-07-16 10:31:58 -04004085 fl = nfs4_alloc_init_lease(fp, NFS4_OPEN_DELEGATE_READ);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05004086 if (!fl)
4087 return -ENOMEM;
Jeff Layton417c6622014-07-21 09:34:57 -04004088 filp = find_readable_file(fp);
4089 if (!filp) {
4090 /* We should always have a readable file here */
4091 WARN_ON_ONCE(1);
Kinglong Meeaf9dbaf2015-07-13 17:30:51 +08004092 locks_free_lock(fl);
Jeff Layton417c6622014-07-21 09:34:57 -04004093 return -EBADF;
4094 }
4095 fl->fl_file = filp;
Jeff Laytone6f5c782014-08-22 10:40:25 -04004096 status = vfs_setlease(filp, fl->fl_type, &fl, NULL);
Jeff Layton1c7dd2f2014-08-22 10:55:47 -04004097 if (fl)
Jeff Layton417c6622014-07-21 09:34:57 -04004098 locks_free_lock(fl);
Jeff Layton1c7dd2f2014-08-22 10:55:47 -04004099 if (status)
Jeff Layton417c6622014-07-21 09:34:57 -04004100 goto out_fput;
Benny Halevycdc97502014-05-30 09:09:30 -04004101 spin_lock(&state_lock);
Jeff Layton417c6622014-07-21 09:34:57 -04004102 spin_lock(&fp->fi_lock);
4103 /* Did the lease get broken before we took the lock? */
4104 status = -EAGAIN;
4105 if (fp->fi_had_conflict)
4106 goto out_unlock;
4107 /* Race breaker */
Jeff Layton0c637be2014-08-22 12:05:43 -04004108 if (fp->fi_deleg_file) {
Andrew Elble34ed9872015-10-15 12:07:28 -04004109 status = hash_delegation_locked(dp, fp);
Jeff Layton417c6622014-07-21 09:34:57 -04004110 goto out_unlock;
4111 }
Jeff Layton417c6622014-07-21 09:34:57 -04004112 fp->fi_deleg_file = filp;
Andrew Elble34ed9872015-10-15 12:07:28 -04004113 fp->fi_delegees = 0;
4114 status = hash_delegation_locked(dp, fp);
Jeff Layton417c6622014-07-21 09:34:57 -04004115 spin_unlock(&fp->fi_lock);
Benny Halevycdc97502014-05-30 09:09:30 -04004116 spin_unlock(&state_lock);
Andrew Elble34ed9872015-10-15 12:07:28 -04004117 if (status) {
4118 /* Should never happen, this is a new fi_deleg_file */
4119 WARN_ON_ONCE(1);
4120 goto out_fput;
4121 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05004122 return 0;
Jeff Layton417c6622014-07-21 09:34:57 -04004123out_unlock:
4124 spin_unlock(&fp->fi_lock);
4125 spin_unlock(&state_lock);
4126out_fput:
4127 fput(filp);
J. Bruce Fieldse8730882012-01-23 13:52:01 -05004128 return status;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05004129}
4130
Jeff Layton0b266932014-07-25 07:34:25 -04004131static struct nfs4_delegation *
4132nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
Sachin Bhamare8287f002015-04-27 14:50:14 +02004133 struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05004134{
Jeff Layton0b266932014-07-25 07:34:25 -04004135 int status;
4136 struct nfs4_delegation *dp;
Jeff Layton417c6622014-07-21 09:34:57 -04004137
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04004138 if (fp->fi_had_conflict)
Jeff Layton0b266932014-07-25 07:34:25 -04004139 return ERR_PTR(-EAGAIN);
4140
Andrew Elble34ed9872015-10-15 12:07:28 -04004141 spin_lock(&state_lock);
4142 spin_lock(&fp->fi_lock);
4143 status = nfs4_get_existing_delegation(clp, fp);
4144 spin_unlock(&fp->fi_lock);
4145 spin_unlock(&state_lock);
4146
4147 if (status)
4148 return ERR_PTR(status);
4149
Sachin Bhamare8287f002015-04-27 14:50:14 +02004150 dp = alloc_init_deleg(clp, fh, odstate);
Jeff Layton0b266932014-07-25 07:34:25 -04004151 if (!dp)
4152 return ERR_PTR(-ENOMEM);
4153
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04004154 get_nfs4_file(fp);
Benny Halevycdc97502014-05-30 09:09:30 -04004155 spin_lock(&state_lock);
Jeff Layton417c6622014-07-21 09:34:57 -04004156 spin_lock(&fp->fi_lock);
Trond Myklebust11b91642014-07-29 21:34:08 -04004157 dp->dl_stid.sc_file = fp;
Jeff Layton0c637be2014-08-22 12:05:43 -04004158 if (!fp->fi_deleg_file) {
Jeff Layton417c6622014-07-21 09:34:57 -04004159 spin_unlock(&fp->fi_lock);
4160 spin_unlock(&state_lock);
Jeff Layton0b266932014-07-25 07:34:25 -04004161 status = nfs4_setlease(dp);
4162 goto out;
Jeff Layton417c6622014-07-21 09:34:57 -04004163 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05004164 if (fp->fi_had_conflict) {
Jeff Layton417c6622014-07-21 09:34:57 -04004165 status = -EAGAIN;
4166 goto out_unlock;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05004167 }
Andrew Elble34ed9872015-10-15 12:07:28 -04004168 status = hash_delegation_locked(dp, fp);
Jeff Layton417c6622014-07-21 09:34:57 -04004169out_unlock:
4170 spin_unlock(&fp->fi_lock);
Benny Halevycdc97502014-05-30 09:09:30 -04004171 spin_unlock(&state_lock);
Jeff Layton0b266932014-07-25 07:34:25 -04004172out:
4173 if (status) {
Sachin Bhamare8287f002015-04-27 14:50:14 +02004174 put_clnt_odstate(dp->dl_clnt_odstate);
Trond Myklebust60116952014-07-29 21:34:06 -04004175 nfs4_put_stid(&dp->dl_stid);
Jeff Layton0b266932014-07-25 07:34:25 -04004176 return ERR_PTR(status);
4177 }
4178 return dp;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05004179}
4180
Benny Halevy4aa89132012-02-21 14:16:44 -08004181static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
4182{
4183 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4184 if (status == -EAGAIN)
4185 open->op_why_no_deleg = WND4_CONTENTION;
4186 else {
4187 open->op_why_no_deleg = WND4_RESOURCE;
4188 switch (open->op_deleg_want) {
4189 case NFS4_SHARE_WANT_READ_DELEG:
4190 case NFS4_SHARE_WANT_WRITE_DELEG:
4191 case NFS4_SHARE_WANT_ANY_DELEG:
4192 break;
4193 case NFS4_SHARE_WANT_CANCEL:
4194 open->op_why_no_deleg = WND4_CANCELLED;
4195 break;
4196 case NFS4_SHARE_WANT_NO_DELEG:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004197 WARN_ON_ONCE(1);
Benny Halevy4aa89132012-02-21 14:16:44 -08004198 }
4199 }
4200}
4201
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202/*
4203 * Attempt to hand out a delegation.
J. Bruce Fields99c41512013-05-21 16:21:25 -04004204 *
4205 * Note we don't support write delegations, and won't until the vfs has
4206 * proper support for them.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004207 */
4208static void
Jeff Layton4cf59222014-07-25 07:34:24 -04004209nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open,
4210 struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004211{
4212 struct nfs4_delegation *dp;
Jeff Layton4cf59222014-07-25 07:34:24 -04004213 struct nfs4_openowner *oo = openowner(stp->st_stateowner);
4214 struct nfs4_client *clp = stp->st_stid.sc_client;
J. Bruce Fields14a24e92010-12-10 19:02:49 -05004215 int cb_up;
J. Bruce Fields99c41512013-05-21 16:21:25 -04004216 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004217
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004218 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
NeilBrown7b190fe2005-06-23 22:03:23 -07004219 open->op_recall = 0;
4220 switch (open->op_claim_type) {
4221 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05004222 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07004223 open->op_recall = 1;
J. Bruce Fields99c41512013-05-21 16:21:25 -04004224 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
4225 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07004226 break;
4227 case NFS4_OPEN_CLAIM_NULL:
Ming Chened47b062014-01-09 21:26:10 +00004228 case NFS4_OPEN_CLAIM_FH:
J. Bruce Fields99c41512013-05-21 16:21:25 -04004229 /*
4230 * Let's not give out any delegations till everyone's
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -04004231 * had the chance to reclaim theirs, *and* until
4232 * NLM locks have all been reclaimed:
J. Bruce Fields99c41512013-05-21 16:21:25 -04004233 */
Jeff Layton4cf59222014-07-25 07:34:24 -04004234 if (locks_in_grace(clp->net))
J. Bruce Fields99c41512013-05-21 16:21:25 -04004235 goto out_no_deleg;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04004236 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
J. Bruce Fields99c41512013-05-21 16:21:25 -04004237 goto out_no_deleg;
Steve Dickson9a0590a2013-05-15 14:51:49 -04004238 /*
4239 * Also, if the file was opened for write or
4240 * create, there's a good chance the client's
4241 * about to write to it, resulting in an
4242 * immediate recall (since we don't support
4243 * write delegations):
4244 */
NeilBrown7b190fe2005-06-23 22:03:23 -07004245 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
J. Bruce Fields99c41512013-05-21 16:21:25 -04004246 goto out_no_deleg;
4247 if (open->op_create == NFS4_OPEN_CREATE)
4248 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07004249 break;
4250 default:
J. Bruce Fields99c41512013-05-21 16:21:25 -04004251 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07004252 }
Sachin Bhamare8287f002015-04-27 14:50:14 +02004253 dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate);
Jeff Layton0b266932014-07-25 07:34:25 -04004254 if (IS_ERR(dp))
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05004255 goto out_no_deleg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004256
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04004257 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004258
Benny Halevy8c10cbd2009-10-19 12:04:53 +02004259 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04004260 STATEID_VAL(&dp->dl_stid.sc_stateid));
J. Bruce Fields99c41512013-05-21 16:21:25 -04004261 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
Trond Myklebust67cb1272014-07-29 21:34:17 -04004262 nfs4_put_stid(&dp->dl_stid);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05004263 return;
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05004264out_no_deleg:
J. Bruce Fields99c41512013-05-21 16:21:25 -04004265 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
4266 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04004267 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
J. Bruce Fields99c41512013-05-21 16:21:25 -04004268 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04004269 open->op_recall = 1;
4270 }
J. Bruce Fields99c41512013-05-21 16:21:25 -04004271
4272 /* 4.1 client asking for a delegation? */
4273 if (open->op_deleg_want)
4274 nfsd4_open_deleg_none_ext(open, status);
4275 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276}
4277
Benny Halevye27f49c2012-02-21 14:16:54 -08004278static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
4279 struct nfs4_delegation *dp)
4280{
4281 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
4282 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
4283 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4284 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
4285 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
4286 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
4287 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4288 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
4289 }
4290 /* Otherwise the client must be confused wanting a delegation
4291 * it already has, therefore we don't return
4292 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
4293 */
4294}
4295
Al Virob37ad282006-10-19 23:28:59 -07004296__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07004297nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
4298{
Andy Adamson66689582009-04-03 08:28:45 +03004299 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004300 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004301 struct nfs4_file *fp = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004302 struct nfs4_ol_stateid *stp = NULL;
Andrew Elble7fc05642015-11-05 20:42:43 -05004303 struct nfs4_ol_stateid *swapstp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07004304 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004305 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307 /*
4308 * Lookup file; if found, lookup stateid and check open request,
4309 * and check for delegations in the process of being recalled.
4310 * If not found, create the nfs4_file struct
4311 */
Jeff Laytonf9c00c32014-07-23 16:17:41 -04004312 fp = find_or_add_file(open->op_file, &current_fh->fh_handle);
Trond Myklebust950e0112014-06-30 11:48:31 -04004313 if (fp != open->op_file) {
J. Bruce Fields41d22662013-03-21 15:49:47 -04004314 status = nfs4_check_deleg(cl, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07004315 if (status)
4316 goto out;
Andrew Elble7fc05642015-11-05 20:42:43 -05004317 spin_lock(&fp->fi_lock);
Jeff Laytona46cb7f2014-07-10 14:07:35 -04004318 stp = nfsd4_find_existing_open(fp, open);
Andrew Elble7fc05642015-11-05 20:42:43 -05004319 spin_unlock(&fp->fi_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004320 } else {
Trond Myklebust950e0112014-06-30 11:48:31 -04004321 open->op_file = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07004322 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04004323 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07004324 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 }
4326
4327 /*
4328 * OPEN the file, or upgrade an existing OPEN.
4329 * If truncate fails, the OPEN fails.
4330 */
4331 if (stp) {
4332 /* Stateid was found, this is an OPEN upgrade */
Jeff Layton35a92fe2015-09-17 07:47:08 -04004333 down_read(&stp->st_rwsem);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004334 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Jeff Layton35a92fe2015-09-17 07:47:08 -04004335 if (status) {
4336 up_read(&stp->st_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004337 goto out;
Jeff Layton35a92fe2015-09-17 07:47:08 -04004338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04004340 stp = open->op_stp;
4341 open->op_stp = NULL;
Andrew Elble7fc05642015-11-05 20:42:43 -05004342 swapstp = init_open_stateid(stp, fp, open);
4343 if (swapstp) {
4344 nfs4_put_stid(&stp->st_stid);
4345 stp = swapstp;
4346 down_read(&stp->st_rwsem);
4347 status = nfs4_upgrade_open(rqstp, fp, current_fh,
4348 stp, open);
4349 if (status) {
4350 up_read(&stp->st_rwsem);
4351 goto out;
4352 }
4353 goto upgrade_out;
4354 }
Jeff Layton35a92fe2015-09-17 07:47:08 -04004355 down_read(&stp->st_rwsem);
Jeff Layton6eb3a1d2014-07-10 14:07:31 -04004356 status = nfs4_get_vfs_file(rqstp, fp, current_fh, stp, open);
4357 if (status) {
Jeff Layton35a92fe2015-09-17 07:47:08 -04004358 up_read(&stp->st_rwsem);
Jeff Layton6eb3a1d2014-07-10 14:07:31 -04004359 release_open_stateid(stp);
4360 goto out;
4361 }
Sachin Bhamare8287f002015-04-27 14:50:14 +02004362
4363 stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp,
4364 open->op_odstate);
4365 if (stp->st_clnt_odstate == open->op_odstate)
4366 open->op_odstate = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004367 }
Andrew Elble7fc05642015-11-05 20:42:43 -05004368upgrade_out:
Jeff Layton9767feb2015-10-01 09:05:50 -04004369 nfs4_inc_and_copy_stateid(&open->op_stateid, &stp->st_stid);
Jeff Layton35a92fe2015-09-17 07:47:08 -04004370 up_read(&stp->st_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004371
Benny Halevyd24433c2012-02-16 20:57:17 +02004372 if (nfsd4_has_session(&resp->cstate)) {
Benny Halevyd24433c2012-02-16 20:57:17 +02004373 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
4374 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
4375 open->op_why_no_deleg = WND4_NOT_WANTED;
4376 goto nodeleg;
4377 }
4378 }
4379
Linus Torvalds1da177e2005-04-16 15:20:36 -07004380 /*
4381 * Attempt to hand out a delegation. No error return, because the
4382 * OPEN succeeds even if we fail.
4383 */
Jeff Layton4cf59222014-07-25 07:34:24 -04004384 nfs4_open_delegation(current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02004385nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004386 status = nfs_ok;
4387
Benny Halevy8c10cbd2009-10-19 12:04:53 +02004388 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004389 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004390out:
Benny Halevyd24433c2012-02-16 20:57:17 +02004391 /* 4.1 client trying to upgrade/downgrade delegation? */
4392 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08004393 open->op_deleg_want)
4394 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02004395
NeilBrown13cd2182005-06-23 22:03:10 -07004396 if (fp)
4397 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07004398 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
Kinglong Mee87186022015-07-13 17:32:59 +08004399 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004400 /*
4401 * To finish the open response, we just need to set the rflags.
4402 */
4403 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04004404 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03004405 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004406 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
Trond Myklebustdcd94cc2014-07-29 21:34:18 -04004407 if (dp)
4408 nfs4_put_stid(&dp->dl_stid);
Trond Myklebustd6f2bc52014-07-29 21:34:19 -04004409 if (stp)
4410 nfs4_put_stid(&stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004411
4412 return status;
4413}
4414
Jeff Layton58fb12e2014-07-29 21:34:27 -04004415void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
Jeff Layton42297892015-03-23 10:53:44 -04004416 struct nfsd4_open *open)
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04004417{
4418 if (open->op_openowner) {
Jeff Laytond3134b12014-07-29 21:34:32 -04004419 struct nfs4_stateowner *so = &open->op_openowner->oo_owner;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04004420
Jeff Laytond3134b12014-07-29 21:34:32 -04004421 nfsd4_cstate_assign_replay(cstate, so);
4422 nfs4_put_stateowner(so);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04004423 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04004424 if (open->op_file)
Jeff Layton5b095e92014-10-23 08:01:02 -04004425 kmem_cache_free(file_slab, open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04004426 if (open->op_stp)
Trond Myklebust60116952014-07-29 21:34:06 -04004427 nfs4_put_stid(&open->op_stp->st_stid);
Sachin Bhamare8287f002015-04-27 14:50:14 +02004428 if (open->op_odstate)
4429 kmem_cache_free(odstate_slab, open->op_odstate);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04004430}
4431
Al Virob37ad282006-10-19 23:28:59 -07004432__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004433nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4434 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004435{
4436 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07004437 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004438 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004439
Linus Torvalds1da177e2005-04-16 15:20:36 -07004440 dprintk("process_renew(%08x/%08x): starting\n",
4441 clid->cl_boot, clid->cl_id);
Jeff Layton4b24ca72014-06-30 11:48:44 -04004442 status = lookup_clientid(clid, cstate, nn);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004443 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444 goto out;
Jeff Layton4b24ca72014-06-30 11:48:44 -04004445 clp = cstate->clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004446 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07004447 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04004448 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 goto out;
4450 status = nfs_ok;
4451out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004452 return status;
4453}
4454
Jeff Layton7f5ef2e2014-09-12 16:40:21 -04004455void
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03004456nfsd4_end_grace(struct nfsd_net *nn)
NeilBrowna76b4312005-06-23 22:04:01 -07004457{
Jeff Layton33dcc482012-04-10 11:08:48 -04004458 /* do nothing if grace period already ended */
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04004459 if (nn->grace_ended)
Jeff Layton33dcc482012-04-10 11:08:48 -04004460 return;
4461
NeilBrowna76b4312005-06-23 22:04:01 -07004462 dprintk("NFSD: end of grace period\n");
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04004463 nn->grace_ended = true;
J. Bruce Fields70b28232014-09-16 17:37:32 -04004464 /*
4465 * If the server goes down again right now, an NFSv4
4466 * client will still be allowed to reclaim after it comes back up,
4467 * even if it hasn't yet had a chance to reclaim state this time.
4468 *
4469 */
Jeff Layton919b8042014-09-12 16:40:20 -04004470 nfsd4_record_grace_done(nn);
J. Bruce Fields70b28232014-09-16 17:37:32 -04004471 /*
4472 * At this point, NFSv4 clients can still reclaim. But if the
4473 * server crashes, any that have not yet reclaimed will be out
4474 * of luck on the next boot.
4475 *
4476 * (NFSv4.1+ clients are considered to have reclaimed once they
4477 * call RECLAIM_COMPLETE. NFSv4.0 clients are considered to
4478 * have reclaimed after their first OPEN.)
4479 */
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04004480 locks_end_grace(&nn->nfsd4_manager);
J. Bruce Fields70b28232014-09-16 17:37:32 -04004481 /*
4482 * At this point, and once lockd and/or any other containers
4483 * exit their grace period, further reclaims will fail and
4484 * regular locking can resume.
4485 */
NeilBrowna76b4312005-06-23 22:04:01 -07004486}
4487
NeilBrownfd39ca92005-06-23 22:04:03 -07004488static time_t
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004489nfs4_laundromat(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490{
4491 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004492 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493 struct nfs4_delegation *dp;
Jeff Layton217526e2014-07-30 08:27:11 -04004494 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004495 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03004496 time_t cutoff = get_seconds() - nn->nfsd4_lease;
Jeff Laytona832e7a2014-05-30 09:09:26 -04004497 time_t t, new_timeo = nn->nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498
Linus Torvalds1da177e2005-04-16 15:20:36 -07004499 dprintk("NFSD: laundromat service - starting\n");
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03004500 nfsd4_end_grace(nn);
Benny Halevy36acb662010-05-12 00:13:04 +03004501 INIT_LIST_HEAD(&reaplist);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03004502 spin_lock(&nn->client_lock);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004503 list_for_each_safe(pos, next, &nn->client_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504 clp = list_entry(pos, struct nfs4_client, cl_lru);
4505 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
4506 t = clp->cl_time - cutoff;
Jeff Laytona832e7a2014-05-30 09:09:26 -04004507 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508 break;
4509 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04004510 if (mark_client_expired_locked(clp)) {
Benny Halevyd7682982010-05-12 00:13:54 +03004511 dprintk("NFSD: client in use (clientid %08x)\n",
4512 clp->cl_clientid.cl_id);
4513 continue;
4514 }
Trond Myklebust4864af92014-07-30 08:27:03 -04004515 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03004516 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03004517 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03004518 list_for_each_safe(pos, next, &reaplist) {
4519 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004520 dprintk("NFSD: purging unused client (clientid %08x)\n",
4521 clp->cl_clientid.cl_id);
Trond Myklebust4864af92014-07-30 08:27:03 -04004522 list_del_init(&clp->cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004523 expire_client(clp);
4524 }
Benny Halevycdc97502014-05-30 09:09:30 -04004525 spin_lock(&state_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04004526 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4528 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
Jeff Laytona832e7a2014-05-30 09:09:26 -04004529 t = dp->dl_time - cutoff;
4530 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004531 break;
4532 }
Jeff Layton3fcbbd22015-08-24 12:41:48 -04004533 WARN_ON(!unhash_delegation_locked(dp));
Jeff Layton42690672014-07-25 07:34:20 -04004534 list_add(&dp->dl_recall_lru, &reaplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004535 }
Benny Halevycdc97502014-05-30 09:09:30 -04004536 spin_unlock(&state_lock);
Jeff Layton2d4a5322014-07-25 07:34:21 -04004537 while (!list_empty(&reaplist)) {
4538 dp = list_first_entry(&reaplist, struct nfs4_delegation,
4539 dl_recall_lru);
4540 list_del_init(&dp->dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004541 revoke_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004542 }
Jeff Layton217526e2014-07-30 08:27:11 -04004543
4544 spin_lock(&nn->client_lock);
4545 while (!list_empty(&nn->close_lru)) {
4546 oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
4547 oo_close_lru);
4548 if (time_after((unsigned long)oo->oo_time,
4549 (unsigned long)cutoff)) {
Jeff Laytona832e7a2014-05-30 09:09:26 -04004550 t = oo->oo_time - cutoff;
4551 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004552 break;
4553 }
Jeff Layton217526e2014-07-30 08:27:11 -04004554 list_del_init(&oo->oo_close_lru);
4555 stp = oo->oo_last_closed_stid;
4556 oo->oo_last_closed_stid = NULL;
4557 spin_unlock(&nn->client_lock);
4558 nfs4_put_stid(&stp->st_stid);
4559 spin_lock(&nn->client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004560 }
Jeff Layton217526e2014-07-30 08:27:11 -04004561 spin_unlock(&nn->client_lock);
4562
Jeff Laytona832e7a2014-05-30 09:09:26 -04004563 new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
Jeff Laytona832e7a2014-05-30 09:09:26 -04004564 return new_timeo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004565}
4566
Harvey Harrisona254b242008-02-20 12:49:00 -08004567static struct workqueue_struct *laundry_wq;
4568static void laundromat_main(struct work_struct *);
Harvey Harrisona254b242008-02-20 12:49:00 -08004569
4570static void
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004571laundromat_main(struct work_struct *laundry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004572{
4573 time_t t;
Geliang Tang2e55f3a2016-01-01 22:06:28 +08004574 struct delayed_work *dwork = to_delayed_work(laundry);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004575 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
4576 laundromat_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004578 t = nfs4_laundromat(nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004579 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004580 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004581}
4582
Jeff Layton8fcd4612015-07-30 06:57:46 -04004583static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07004584{
Jeff Layton8fcd4612015-07-30 06:57:46 -04004585 if (!fh_match(&fhp->fh_handle, &stp->sc_file->fi_fhandle))
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004586 return nfserr_bad_stateid;
4587 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004588}
4589
Linus Torvalds1da177e2005-04-16 15:20:36 -07004590static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04004591access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592{
Jeff Layton82c5ff12012-05-11 09:45:13 -04004593 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
4594 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
4595 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596}
4597
4598static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04004599access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600{
Jeff Layton82c5ff12012-05-11 09:45:13 -04004601 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
4602 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004603}
4604
4605static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004606__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004607{
Al Virob37ad282006-10-19 23:28:59 -07004608 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004609
J. Bruce Fields02921912010-07-29 15:16:59 -04004610 /* For lock stateid's, we test the parent open, not the lock: */
4611 if (stp->st_openstp)
4612 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04004613 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004614 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04004615 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004616 goto out;
4617 status = nfs_ok;
4618out:
4619 return status;
4620}
4621
Al Virob37ad282006-10-19 23:28:59 -07004622static inline __be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004623check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004624{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004625 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004626 return nfs_ok;
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -04004627 else if (opens_in_grace(net)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004628 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07004629 * conflicting state; so we must wait out the grace period. */
4630 return nfserr_grace;
4631 } else if (flags & WR_STATE)
4632 return nfs4_share_conflict(current_fh,
4633 NFS4_SHARE_DENY_WRITE);
4634 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
4635 return nfs4_share_conflict(current_fh,
4636 NFS4_SHARE_DENY_READ);
4637}
4638
4639/*
4640 * Allow READ/WRITE during grace period on recovered state only for files
4641 * that are not able to provide mandatory locking.
4642 */
4643static inline int
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004644grace_disallows_io(struct net *net, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004645{
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -04004646 return opens_in_grace(net) && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004647}
4648
J. Bruce Fields81b82962011-08-23 11:03:29 -04004649/* Returns true iff a is later than b: */
4650static bool stateid_generation_after(stateid_t *a, stateid_t *b)
4651{
Jim Rees1a9357f2013-05-17 17:33:00 -04004652 return (s32)(a->si_generation - b->si_generation) > 0;
J. Bruce Fields81b82962011-08-23 11:03:29 -04004653}
4654
J. Bruce Fields57b7b432012-04-25 17:58:50 -04004655static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05004656{
Andy Adamson66689582009-04-03 08:28:45 +03004657 /*
4658 * When sessions are used the stateid generation number is ignored
4659 * when it is zero.
4660 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04004661 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04004662 return nfs_ok;
4663
4664 if (in->si_generation == ref->si_generation)
4665 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03004666
J. Bruce Fields0836f582008-01-26 19:08:12 -05004667 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04004668 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05004669 return nfserr_bad_stateid;
4670 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04004671 * However, we could see a stateid from the past, even from a
4672 * non-buggy client. For example, if the client sends a lock
4673 * while some IO is outstanding, the lock may bump si_generation
4674 * while the IO is still in flight. The client could avoid that
4675 * situation by waiting for responses on all the IO requests,
4676 * but better performance may result in retrying IO that
4677 * receives an old_stateid error if requests are rarely
4678 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05004679 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04004680 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05004681}
4682
Christoph Hellwigebe9cb32015-04-28 15:41:15 +02004683static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols)
4684{
4685 if (ols->st_stateowner->so_is_open_owner &&
4686 !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
4687 return nfserr_bad_stateid;
4688 return nfs_ok;
4689}
4690
Chuck Lever7df302f2012-05-29 13:56:37 -04004691static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04004692{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04004693 struct nfs4_stid *s;
Jeff Layton1af71cc2014-07-29 21:34:14 -04004694 __be32 status = nfserr_bad_stateid;
Bryan Schumaker17456802011-07-13 10:50:48 -04004695
Chuck Lever7df302f2012-05-29 13:56:37 -04004696 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
Jeff Layton1af71cc2014-07-29 21:34:14 -04004697 return status;
Chuck Lever7df302f2012-05-29 13:56:37 -04004698 /* Client debugging aid. */
4699 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
4700 char addr_str[INET6_ADDRSTRLEN];
4701 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
4702 sizeof(addr_str));
4703 pr_warn_ratelimited("NFSD: client %s testing state ID "
4704 "with incorrect client ID\n", addr_str);
Jeff Layton1af71cc2014-07-29 21:34:14 -04004705 return status;
Chuck Lever7df302f2012-05-29 13:56:37 -04004706 }
Jeff Layton1af71cc2014-07-29 21:34:14 -04004707 spin_lock(&cl->cl_lock);
4708 s = find_stateid_locked(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04004709 if (!s)
Jeff Layton1af71cc2014-07-29 21:34:14 -04004710 goto out_unlock;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04004711 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04004712 if (status)
Jeff Layton1af71cc2014-07-29 21:34:14 -04004713 goto out_unlock;
J. Bruce Fields23340032013-04-09 17:42:28 -04004714 switch (s->sc_type) {
4715 case NFS4_DELEG_STID:
Jeff Layton1af71cc2014-07-29 21:34:14 -04004716 status = nfs_ok;
4717 break;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004718 case NFS4_REVOKED_DELEG_STID:
Jeff Layton1af71cc2014-07-29 21:34:14 -04004719 status = nfserr_deleg_revoked;
4720 break;
J. Bruce Fields23340032013-04-09 17:42:28 -04004721 case NFS4_OPEN_STID:
4722 case NFS4_LOCK_STID:
Christoph Hellwigebe9cb32015-04-28 15:41:15 +02004723 status = nfsd4_check_openowner_confirmed(openlockstateid(s));
Jeff Layton1af71cc2014-07-29 21:34:14 -04004724 break;
J. Bruce Fields23340032013-04-09 17:42:28 -04004725 default:
4726 printk("unknown stateid type %x\n", s->sc_type);
Trond Myklebustb0fc29d2014-07-16 10:31:59 -04004727 /* Fallthrough */
J. Bruce Fields23340032013-04-09 17:42:28 -04004728 case NFS4_CLOSED_STID:
Trond Myklebustb0fc29d2014-07-16 10:31:59 -04004729 case NFS4_CLOSED_DELEG_STID:
Jeff Layton1af71cc2014-07-29 21:34:14 -04004730 status = nfserr_bad_stateid;
J. Bruce Fields23340032013-04-09 17:42:28 -04004731 }
Jeff Layton1af71cc2014-07-29 21:34:14 -04004732out_unlock:
4733 spin_unlock(&cl->cl_lock);
4734 return status;
Bryan Schumaker17456802011-07-13 10:50:48 -04004735}
4736
Christoph Hellwigcd61c522014-08-14 08:44:57 +02004737__be32
Trond Myklebust2dd6e452014-06-30 11:48:43 -04004738nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
4739 stateid_t *stateid, unsigned char typemask,
4740 struct nfs4_stid **s, struct nfsd_net *nn)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004741{
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04004742 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004743
4744 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
4745 return nfserr_bad_stateid;
Jeff Layton4b24ca72014-06-30 11:48:44 -04004746 status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn);
Trond Myklebusta8a7c672014-03-29 14:43:38 -04004747 if (status == nfserr_stale_clientid) {
Jeff Layton4b24ca72014-06-30 11:48:44 -04004748 if (cstate->session)
Trond Myklebusta8a7c672014-03-29 14:43:38 -04004749 return nfserr_bad_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004750 return nfserr_stale_stateid;
Trond Myklebusta8a7c672014-03-29 14:43:38 -04004751 }
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04004752 if (status)
4753 return status;
Jeff Layton4b24ca72014-06-30 11:48:44 -04004754 *s = find_stateid_by_type(cstate->clp, stateid, typemask);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004755 if (!*s)
4756 return nfserr_bad_stateid;
4757 return nfs_ok;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004758}
4759
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004760static struct file *
4761nfs4_find_file(struct nfs4_stid *s, int flags)
4762{
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004763 if (!s)
4764 return NULL;
4765
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004766 switch (s->sc_type) {
4767 case NFS4_DELEG_STID:
4768 if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file))
4769 return NULL;
4770 return get_file(s->sc_file->fi_deleg_file);
4771 case NFS4_OPEN_STID:
4772 case NFS4_LOCK_STID:
4773 if (flags & RD_STATE)
4774 return find_readable_file(s->sc_file);
4775 else
4776 return find_writeable_file(s->sc_file);
4777 break;
4778 }
4779
4780 return NULL;
4781}
4782
4783static __be32
4784nfs4_check_olstateid(struct svc_fh *fhp, struct nfs4_ol_stateid *ols, int flags)
4785{
4786 __be32 status;
4787
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004788 status = nfsd4_check_openowner_confirmed(ols);
4789 if (status)
4790 return status;
4791 return nfs4_check_openmode(ols, flags);
4792}
4793
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004794static __be32
4795nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s,
4796 struct file **filpp, bool *tmp_file, int flags)
4797{
4798 int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
4799 struct file *file;
4800 __be32 status;
4801
4802 file = nfs4_find_file(s, flags);
4803 if (file) {
4804 status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
4805 acc | NFSD_MAY_OWNER_OVERRIDE);
4806 if (status) {
4807 fput(file);
4808 return status;
4809 }
4810
4811 *filpp = file;
4812 } else {
4813 status = nfsd_open(rqstp, fhp, S_IFREG, acc, filpp);
4814 if (status)
4815 return status;
4816
4817 if (tmp_file)
4818 *tmp_file = true;
4819 }
4820
4821 return 0;
4822}
4823
Linus Torvalds1da177e2005-04-16 15:20:36 -07004824/*
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004825 * Checks for stateid operations
4826 */
Al Virob37ad282006-10-19 23:28:59 -07004827__be32
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004828nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +01004829 struct nfsd4_compound_state *cstate, struct svc_fh *fhp,
4830 stateid_t *stateid, int flags, struct file **filpp, bool *tmp_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004831{
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004832 struct inode *ino = d_inode(fhp->fh_dentry);
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004833 struct net *net = SVC_NET(rqstp);
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004834 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004835 struct nfs4_stid *s = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004836 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004837
Linus Torvalds1da177e2005-04-16 15:20:36 -07004838 if (filpp)
4839 *filpp = NULL;
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004840 if (tmp_file)
4841 *tmp_file = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004842
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004843 if (grace_disallows_io(net, ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004844 return nfserr_grace;
4845
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004846 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
4847 status = check_special_stateids(net, fhp, stateid, flags);
4848 goto done;
4849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004850
Trond Myklebust2dd6e452014-06-30 11:48:43 -04004851 status = nfsd4_lookup_stateid(cstate, stateid,
Jeff Laytondb24b3b2014-06-30 11:48:36 -04004852 NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
Trond Myklebust2dd6e452014-06-30 11:48:43 -04004853 &s, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004854 if (status)
Trond Myklebustc2d1d6a2014-07-30 08:27:25 -04004855 return status;
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004856 status = check_stateid_generation(stateid, &s->sc_stateid,
4857 nfsd4_has_session(cstate));
J. Bruce Fields69064a22011-09-09 11:54:57 -04004858 if (status)
4859 goto out;
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004860
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004861 switch (s->sc_type) {
4862 case NFS4_DELEG_STID:
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004863 status = nfs4_check_delegmode(delegstateid(s), flags);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004864 break;
4865 case NFS4_OPEN_STID:
4866 case NFS4_LOCK_STID:
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004867 status = nfs4_check_olstateid(fhp, openlockstateid(s), flags);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004868 break;
4869 default:
Trond Myklebust14bcab12014-04-18 14:44:07 -04004870 status = nfserr_bad_stateid;
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004871 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004872 }
Jeff Layton8fcd4612015-07-30 06:57:46 -04004873 if (status)
4874 goto out;
4875 status = nfs4_check_fh(fhp, s);
Christoph Hellwiga0649b22015-06-18 16:44:59 +02004876
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004877done:
4878 if (!status && filpp)
4879 status = nfs4_check_file(rqstp, fhp, s, filpp, tmp_file, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004880out:
Christoph Hellwigaf90f702015-06-18 16:45:00 +02004881 if (s)
4882 nfs4_put_stid(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004883 return status;
4884}
4885
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004886/*
Bryan Schumaker17456802011-07-13 10:50:48 -04004887 * Test if the stateid is valid
4888 */
4889__be32
4890nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4891 struct nfsd4_test_stateid *test_stateid)
4892{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05004893 struct nfsd4_test_stateid_id *stateid;
4894 struct nfs4_client *cl = cstate->session->se_client;
4895
Bryan Schumaker03cfb422012-01-27 10:22:49 -05004896 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
Chuck Lever7df302f2012-05-29 13:56:37 -04004897 stateid->ts_id_status =
4898 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
Bryan Schumaker03cfb422012-01-27 10:22:49 -05004899
Bryan Schumaker17456802011-07-13 10:50:48 -04004900 return nfs_ok;
4901}
4902
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004903__be32
4904nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4905 struct nfsd4_free_stateid *free_stateid)
4906{
4907 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004908 struct nfs4_stid *s;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004909 struct nfs4_delegation *dp;
Jeff Laytonfc5a96c2014-07-29 21:34:40 -04004910 struct nfs4_ol_stateid *stp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004911 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004912 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004913
Jeff Layton1af71cc2014-07-29 21:34:14 -04004914 spin_lock(&cl->cl_lock);
4915 s = find_stateid_locked(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004916 if (!s)
Jeff Layton1af71cc2014-07-29 21:34:14 -04004917 goto out_unlock;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004918 switch (s->sc_type) {
4919 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004920 ret = nfserr_locks_held;
Jeff Layton1af71cc2014-07-29 21:34:14 -04004921 break;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004922 case NFS4_OPEN_STID:
Jeff Layton1af71cc2014-07-29 21:34:14 -04004923 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
4924 if (ret)
4925 break;
4926 ret = nfserr_locks_held;
4927 break;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04004928 case NFS4_LOCK_STID:
4929 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
4930 if (ret)
Jeff Layton1af71cc2014-07-29 21:34:14 -04004931 break;
Jeff Laytonfc5a96c2014-07-29 21:34:40 -04004932 stp = openlockstateid(s);
4933 ret = nfserr_locks_held;
4934 if (check_for_locks(stp->st_stid.sc_file,
4935 lockowner(stp->st_stateowner)))
4936 break;
Jeff Laytone8568732015-08-24 12:41:47 -04004937 WARN_ON(!unhash_lock_stateid(stp));
Jeff Layton1af71cc2014-07-29 21:34:14 -04004938 spin_unlock(&cl->cl_lock);
Jeff Laytonfc5a96c2014-07-29 21:34:40 -04004939 nfs4_put_stid(s);
4940 ret = nfs_ok;
Jeff Layton1af71cc2014-07-29 21:34:14 -04004941 goto out;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004942 case NFS4_REVOKED_DELEG_STID:
4943 dp = delegstateid(s);
Jeff Layton2d4a5322014-07-25 07:34:21 -04004944 list_del_init(&dp->dl_recall_lru);
4945 spin_unlock(&cl->cl_lock);
Trond Myklebust60116952014-07-29 21:34:06 -04004946 nfs4_put_stid(s);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004947 ret = nfs_ok;
Jeff Layton1af71cc2014-07-29 21:34:14 -04004948 goto out;
4949 /* Default falls through and returns nfserr_bad_stateid */
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004950 }
Jeff Layton1af71cc2014-07-29 21:34:14 -04004951out_unlock:
4952 spin_unlock(&cl->cl_lock);
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004953out:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04004954 return ret;
4955}
4956
NeilBrown4c4cd222005-07-07 17:59:27 -07004957static inline int
4958setlkflg (int type)
4959{
4960 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
4961 RD_STATE : WR_STATE;
4962}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004963
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004964static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004965{
4966 struct svc_fh *current_fh = &cstate->current_fh;
4967 struct nfs4_stateowner *sop = stp->st_stateowner;
4968 __be32 status;
4969
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004970 status = nfsd4_check_seqid(cstate, sop, seqid);
4971 if (status)
4972 return status;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004973 if (stp->st_stid.sc_type == NFS4_CLOSED_STID
4974 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004975 /*
4976 * "Closed" stateid's exist *only* to return
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004977 * nfserr_replay_me from the previous step, and
4978 * revoked delegations are kept only for free_stateid.
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004979 */
4980 return nfserr_bad_stateid;
Jeff Layton35a92fe2015-09-17 07:47:08 -04004981 down_write(&stp->st_rwsem);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004982 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
Jeff Layton35a92fe2015-09-17 07:47:08 -04004983 if (status == nfs_ok)
4984 status = nfs4_check_fh(current_fh, &stp->st_stid);
4985 if (status != nfs_ok)
4986 up_write(&stp->st_rwsem);
4987 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004988}
4989
Linus Torvalds1da177e2005-04-16 15:20:36 -07004990/*
4991 * Checks for sequence id mutating operations.
4992 */
Al Virob37ad282006-10-19 23:28:59 -07004993static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03004994nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04004995 stateid_t *stateid, char typemask,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004996 struct nfs4_ol_stateid **stpp,
4997 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004998{
J. Bruce Fields0836f582008-01-26 19:08:12 -05004999 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04005000 struct nfs4_stid *s;
Trond Myklebuste17f99b2014-06-30 11:48:34 -04005001 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005002
Benny Halevy8c10cbd2009-10-19 12:04:53 +02005003 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
5004 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07005005
Linus Torvalds1da177e2005-04-16 15:20:36 -07005006 *stpp = NULL;
Trond Myklebust2dd6e452014-06-30 11:48:43 -04005007 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005008 if (status)
5009 return status;
Trond Myklebuste17f99b2014-06-30 11:48:34 -04005010 stp = openlockstateid(s);
Jeff Layton58fb12e2014-07-29 21:34:27 -04005011 nfsd4_cstate_assign_replay(cstate, stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005012
Trond Myklebuste17f99b2014-06-30 11:48:34 -04005013 status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
Trond Myklebustfd911012014-07-29 21:34:24 -04005014 if (!status)
Trond Myklebuste17f99b2014-06-30 11:48:34 -04005015 *stpp = stp;
Trond Myklebustfd911012014-07-29 21:34:24 -04005016 else
5017 nfs4_put_stid(&stp->st_stid);
Trond Myklebuste17f99b2014-06-30 11:48:34 -04005018 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005019}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05005020
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005021static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
5022 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005023{
5024 __be32 status;
5025 struct nfs4_openowner *oo;
Trond Myklebust4cbfc9f2014-07-29 21:34:23 -04005026 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005027
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005028 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
Trond Myklebust4cbfc9f2014-07-29 21:34:23 -04005029 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04005030 if (status)
5031 return status;
Trond Myklebust4cbfc9f2014-07-29 21:34:23 -04005032 oo = openowner(stp->st_stateowner);
5033 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
Jeff Layton35a92fe2015-09-17 07:47:08 -04005034 up_write(&stp->st_rwsem);
Trond Myklebust4cbfc9f2014-07-29 21:34:23 -04005035 nfs4_put_stid(&stp->st_stid);
NeilBrown3a4f98b2005-07-07 17:59:26 -07005036 return nfserr_bad_stateid;
Trond Myklebust4cbfc9f2014-07-29 21:34:23 -04005037 }
5038 *stpp = stp;
NeilBrown3a4f98b2005-07-07 17:59:26 -07005039 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005040}
5041
Al Virob37ad282006-10-19 23:28:59 -07005042__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005043nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08005044 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005045{
Al Virob37ad282006-10-19 23:28:59 -07005046 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005047 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005048 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005049 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005050
Al Viroa6a9f182013-09-16 10:57:01 -04005051 dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
5052 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005053
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005054 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07005055 if (status)
5056 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005057
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005058 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005059 oc->oc_seqid, &oc->oc_req_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005060 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005061 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04005062 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005063 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04005064 status = nfserr_bad_stateid;
Jeff Layton35a92fe2015-09-17 07:47:08 -04005065 if (oo->oo_flags & NFS4_OO_CONFIRMED) {
5066 up_write(&stp->st_rwsem);
Trond Myklebust2585fc72014-07-29 21:34:21 -04005067 goto put_stateid;
Jeff Layton35a92fe2015-09-17 07:47:08 -04005068 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04005069 oo->oo_flags |= NFS4_OO_CONFIRMED;
Jeff Layton9767feb2015-10-01 09:05:50 -04005070 nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid);
Jeff Layton35a92fe2015-09-17 07:47:08 -04005071 up_write(&stp->st_rwsem);
Benny Halevy8c10cbd2009-10-19 12:04:53 +02005072 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005073 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07005074
Jeff Layton2a4317c2012-03-21 16:42:43 -04005075 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04005076 status = nfs_ok;
Trond Myklebust2585fc72014-07-29 21:34:21 -04005077put_stateid:
5078 nfs4_put_stid(&stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005079out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04005080 nfsd4_bump_seqid(cstate, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005081 return status;
5082}
5083
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04005084static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005085{
Jeff Layton82c5ff12012-05-11 09:45:13 -04005086 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04005087 return;
Trond Myklebust11b91642014-07-29 21:34:08 -04005088 nfs4_file_put_access(stp->st_stid.sc_file, access);
Jeff Layton82c5ff12012-05-11 09:45:13 -04005089 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04005090}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04005091
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04005092static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
5093{
5094 switch (to_access) {
5095 case NFS4_SHARE_ACCESS_READ:
5096 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
5097 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
5098 break;
5099 case NFS4_SHARE_ACCESS_WRITE:
5100 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
5101 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
5102 break;
5103 case NFS4_SHARE_ACCESS_BOTH:
5104 break;
5105 default:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05005106 WARN_ON_ONCE(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005107 }
5108}
5109
Al Virob37ad282006-10-19 23:28:59 -07005110__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005111nfsd4_open_downgrade(struct svc_rqst *rqstp,
5112 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08005113 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005114{
Al Virob37ad282006-10-19 23:28:59 -07005115 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005116 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005117 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005118
Al Viroa6a9f182013-09-16 10:57:01 -04005119 dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
5120 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005121
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04005122 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02005123 if (od->od_deleg_want)
5124 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
5125 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005126
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005127 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005128 &od->od_stateid, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005129 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005130 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005131 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04005132 if (!test_access(od->od_share_access, stp)) {
Jeff Laytonc11c5912014-07-10 14:07:30 -04005133 dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07005134 stp->st_access_bmap, od->od_share_access);
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005135 goto put_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005136 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04005137 if (!test_deny(od->od_share_deny, stp)) {
Jeff Laytonc11c5912014-07-10 14:07:30 -04005138 dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07005139 stp->st_deny_bmap, od->od_share_deny);
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005140 goto put_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005141 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04005142 nfs4_stateid_downgrade(stp, od->od_share_access);
Jeff Laytonce0fc432012-05-11 09:45:14 -04005143 reset_union_bmap_deny(od->od_share_deny, stp);
Jeff Layton9767feb2015-10-01 09:05:50 -04005144 nfs4_inc_and_copy_stateid(&od->od_stateid, &stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005145 status = nfs_ok;
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005146put_stateid:
Jeff Layton35a92fe2015-09-17 07:47:08 -04005147 up_write(&stp->st_rwsem);
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005148 nfs4_put_stid(&stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005149out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04005150 nfsd4_bump_seqid(cstate, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005151 return status;
5152}
5153
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04005154static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
5155{
Trond Myklebustacf92952014-06-30 11:48:37 -04005156 struct nfs4_client *clp = s->st_stid.sc_client;
Jeff Laytone8568732015-08-24 12:41:47 -04005157 bool unhashed;
Jeff Laytond83017f2014-07-29 21:34:42 -04005158 LIST_HEAD(reaplist);
Trond Myklebustacf92952014-06-30 11:48:37 -04005159
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04005160 s->st_stid.sc_type = NFS4_CLOSED_STID;
Jeff Layton2c41beb2014-07-29 21:34:41 -04005161 spin_lock(&clp->cl_lock);
Jeff Laytone8568732015-08-24 12:41:47 -04005162 unhashed = unhash_open_stateid(s, &reaplist);
Trond Myklebustacf92952014-06-30 11:48:37 -04005163
Jeff Laytond83017f2014-07-29 21:34:42 -04005164 if (clp->cl_minorversion) {
Jeff Laytone8568732015-08-24 12:41:47 -04005165 if (unhashed)
5166 put_ol_stateid_locked(s, &reaplist);
Jeff Laytond83017f2014-07-29 21:34:42 -04005167 spin_unlock(&clp->cl_lock);
5168 free_ol_stateid_reaplist(&reaplist);
5169 } else {
5170 spin_unlock(&clp->cl_lock);
5171 free_ol_stateid_reaplist(&reaplist);
Jeff Laytone8568732015-08-24 12:41:47 -04005172 if (unhashed)
5173 move_to_close_lru(s, clp->net);
Jeff Laytond83017f2014-07-29 21:34:42 -04005174 }
J. Bruce Fields38c387b2011-09-16 17:42:48 -04005175}
5176
Linus Torvalds1da177e2005-04-16 15:20:36 -07005177/*
5178 * nfs4_unlock_state() called after encode
5179 */
Al Virob37ad282006-10-19 23:28:59 -07005180__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005181nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08005182 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005183{
Al Virob37ad282006-10-19 23:28:59 -07005184 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005185 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005186 struct net *net = SVC_NET(rqstp);
5187 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005188
Al Viroa6a9f182013-09-16 10:57:01 -04005189 dprintk("NFSD: nfsd4_close on file %pd\n",
5190 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005191
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04005192 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
5193 &close->cl_stateid,
5194 NFS4_OPEN_STID|NFS4_CLOSED_STID,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005195 &stp, nn);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04005196 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005197 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005198 goto out;
Jeff Layton9767feb2015-10-01 09:05:50 -04005199 nfs4_inc_and_copy_stateid(&close->cl_stateid, &stp->st_stid);
Jeff Layton35a92fe2015-09-17 07:47:08 -04005200 up_write(&stp->st_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005201
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04005202 nfsd4_close_open_stateid(stp);
Trond Myklebust8a0b5892014-07-29 21:34:20 -04005203
5204 /* put reference from nfs4_preprocess_seqid_op */
5205 nfs4_put_stid(&stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005206out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07005207 return status;
5208}
5209
Al Virob37ad282006-10-19 23:28:59 -07005210__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005211nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5212 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005213{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08005214 struct nfs4_delegation *dp;
5215 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04005216 struct nfs4_stid *s;
Al Virob37ad282006-10-19 23:28:59 -07005217 __be32 status;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005218 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005219
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005220 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08005221 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005222
Trond Myklebust2dd6e452014-06-30 11:48:43 -04005223 status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04005224 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08005225 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04005226 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04005227 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08005228 if (status)
Trond Myklebustfd911012014-07-29 21:34:24 -04005229 goto put_stateid;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08005230
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04005231 destroy_delegation(dp);
Trond Myklebustfd911012014-07-29 21:34:24 -04005232put_stateid:
5233 nfs4_put_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005234out:
5235 return status;
5236}
5237
Benny Halevy87df4de2008-12-15 19:42:03 +02005238static inline u64
5239end_offset(u64 start, u64 len)
5240{
5241 u64 end;
5242
5243 end = start + len;
5244 return end >= start ? end: NFS4_MAX_UINT64;
5245}
5246
5247/* last octet in a range */
5248static inline u64
5249last_byte_offset(u64 start, u64 len)
5250{
5251 u64 end;
5252
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05005253 WARN_ON_ONCE(!len);
Benny Halevy87df4de2008-12-15 19:42:03 +02005254 end = start + len;
5255 return end > start ? end - 1: NFS4_MAX_UINT64;
5256}
5257
Linus Torvalds1da177e2005-04-16 15:20:36 -07005258/*
5259 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
5260 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
5261 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
5262 * locking, this prevents us from being completely protocol-compliant. The
5263 * real solution to this problem is to start using unsigned file offsets in
5264 * the VFS, but this is a very deep change!
5265 */
5266static inline void
5267nfs4_transform_lock_offset(struct file_lock *lock)
5268{
5269 if (lock->fl_start < 0)
5270 lock->fl_start = OFFSET_MAX;
5271 if (lock->fl_end < 0)
5272 lock->fl_end = OFFSET_MAX;
5273}
5274
Jeff Laytoncae80b32015-04-03 09:04:04 -04005275static fl_owner_t
5276nfsd4_fl_get_owner(fl_owner_t owner)
Kinglong Meeaef95832014-08-22 10:18:44 -04005277{
Jeff Laytoncae80b32015-04-03 09:04:04 -04005278 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
5279
5280 nfs4_get_stateowner(&lo->lo_owner);
5281 return owner;
Kinglong Meeaef95832014-08-22 10:18:44 -04005282}
5283
Jeff Laytoncae80b32015-04-03 09:04:04 -04005284static void
5285nfsd4_fl_put_owner(fl_owner_t owner)
Kinglong Meeaef95832014-08-22 10:18:44 -04005286{
Jeff Laytoncae80b32015-04-03 09:04:04 -04005287 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
Kinglong Meeaef95832014-08-22 10:18:44 -04005288
Jeff Laytoncae80b32015-04-03 09:04:04 -04005289 if (lo)
Kinglong Meeaef95832014-08-22 10:18:44 -04005290 nfs4_put_stateowner(&lo->lo_owner);
Kinglong Meeaef95832014-08-22 10:18:44 -04005291}
5292
Alexey Dobriyan7b021962009-09-21 17:01:12 -07005293static const struct lock_manager_operations nfsd_posix_mng_ops = {
Kinglong Meeaef95832014-08-22 10:18:44 -04005294 .lm_get_owner = nfsd4_fl_get_owner,
5295 .lm_put_owner = nfsd4_fl_put_owner,
NeilBrownd5b90262006-04-10 22:55:22 -07005296};
Linus Torvalds1da177e2005-04-16 15:20:36 -07005297
5298static inline void
5299nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
5300{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005301 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005302
NeilBrownd5b90262006-04-10 22:55:22 -07005303 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005304 lo = (struct nfs4_lockowner *) fl->fl_owner;
5305 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
5306 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04005307 if (!deny->ld_owner.data)
5308 /* We just don't care that much */
5309 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005310 deny->ld_owner.len = lo->lo_owner.so_owner.len;
5311 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07005312 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04005313nevermind:
5314 deny->ld_owner.len = 0;
5315 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07005316 deny->ld_clientid.cl_boot = 0;
5317 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005318 }
5319 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02005320 deny->ld_length = NFS4_MAX_UINT64;
5321 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005322 deny->ld_length = fl->fl_end - fl->fl_start + 1;
5323 deny->ld_type = NFS4_READ_LT;
5324 if (fl->fl_type != F_RDLCK)
5325 deny->ld_type = NFS4_WRITE_LT;
5326}
5327
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005328static struct nfs4_lockowner *
Kinglong Meec8623992015-07-13 17:35:37 +08005329find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005330{
Trond Myklebustd4f04892014-07-29 21:34:36 -04005331 unsigned int strhashval = ownerstr_hashval(owner);
Trond Myklebustb3c32bc2014-06-30 11:48:40 -04005332 struct nfs4_stateowner *so;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005333
Trond Myklebust0a880a22014-07-30 08:27:10 -04005334 lockdep_assert_held(&clp->cl_lock);
5335
Trond Myklebustd4f04892014-07-29 21:34:36 -04005336 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
5337 so_strhash) {
Trond Myklebustb3c32bc2014-06-30 11:48:40 -04005338 if (so->so_is_open_owner)
5339 continue;
Kinglong Meeb5971af2014-08-22 10:18:43 -04005340 if (same_owner_str(so, owner))
5341 return lockowner(nfs4_get_stateowner(so));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005342 }
5343 return NULL;
5344}
5345
Trond Myklebustc58c6612014-07-29 21:34:35 -04005346static struct nfs4_lockowner *
Kinglong Meec8623992015-07-13 17:35:37 +08005347find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
Trond Myklebustc58c6612014-07-29 21:34:35 -04005348{
5349 struct nfs4_lockowner *lo;
5350
Trond Myklebustd4f04892014-07-29 21:34:36 -04005351 spin_lock(&clp->cl_lock);
Kinglong Meec8623992015-07-13 17:35:37 +08005352 lo = find_lockowner_str_locked(clp, owner);
Trond Myklebustd4f04892014-07-29 21:34:36 -04005353 spin_unlock(&clp->cl_lock);
Trond Myklebustc58c6612014-07-29 21:34:35 -04005354 return lo;
5355}
5356
Jeff Layton8f4b54c2014-07-29 21:34:29 -04005357static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
5358{
Trond Myklebustc58c6612014-07-29 21:34:35 -04005359 unhash_lockowner_locked(lockowner(sop));
Jeff Layton8f4b54c2014-07-29 21:34:29 -04005360}
5361
Jeff Layton6b180f02014-07-29 21:34:26 -04005362static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
5363{
5364 struct nfs4_lockowner *lo = lockowner(sop);
5365
5366 kmem_cache_free(lockowner_slab, lo);
5367}
5368
5369static const struct nfs4_stateowner_operations lockowner_ops = {
Jeff Layton8f4b54c2014-07-29 21:34:29 -04005370 .so_unhash = nfs4_unhash_lockowner,
5371 .so_free = nfs4_free_lockowner,
Jeff Layton6b180f02014-07-29 21:34:26 -04005372};
5373
Linus Torvalds1da177e2005-04-16 15:20:36 -07005374/*
5375 * Alloc a lock owner structure.
5376 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005377 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005378 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05005379 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07005380 */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005381static struct nfs4_lockowner *
Trond Myklebustc58c6612014-07-29 21:34:35 -04005382alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
5383 struct nfs4_ol_stateid *open_stp,
5384 struct nfsd4_lock *lock)
5385{
Trond Myklebustc58c6612014-07-29 21:34:35 -04005386 struct nfs4_lockowner *lo, *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005387
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005388 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
5389 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005390 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005391 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
5392 lo->lo_owner.so_is_open_owner = 0;
Jeff Layton5db1c032014-07-29 21:34:28 -04005393 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
Jeff Layton6b180f02014-07-29 21:34:26 -04005394 lo->lo_owner.so_ops = &lockowner_ops;
Trond Myklebustd4f04892014-07-29 21:34:36 -04005395 spin_lock(&clp->cl_lock);
Kinglong Meec8623992015-07-13 17:35:37 +08005396 ret = find_lockowner_str_locked(clp, &lock->lk_new_owner);
Trond Myklebustc58c6612014-07-29 21:34:35 -04005397 if (ret == NULL) {
5398 list_add(&lo->lo_owner.so_strhash,
Trond Myklebustd4f04892014-07-29 21:34:36 -04005399 &clp->cl_ownerstr_hashtbl[strhashval]);
Trond Myklebustc58c6612014-07-29 21:34:35 -04005400 ret = lo;
5401 } else
Kinglong Meed50ffde2015-07-16 12:05:07 +08005402 nfs4_free_stateowner(&lo->lo_owner);
5403
Trond Myklebustd4f04892014-07-29 21:34:36 -04005404 spin_unlock(&clp->cl_lock);
J. Bruce Fields340f0ba2015-03-23 11:02:30 -04005405 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005406}
5407
Jeff Layton356a95e2014-07-29 21:34:13 -04005408static void
5409init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
5410 struct nfs4_file *fp, struct inode *inode,
5411 struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005412{
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04005413 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005414
Jeff Layton356a95e2014-07-29 21:34:13 -04005415 lockdep_assert_held(&clp->cl_lock);
5416
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005417 atomic_inc(&stp->st_stid.sc_count);
J. Bruce Fields3abdb602013-02-03 12:23:01 -05005418 stp->st_stid.sc_type = NFS4_LOCK_STID;
Kinglong Meeb5971af2014-08-22 10:18:43 -04005419 stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner);
NeilBrown13cd2182005-06-23 22:03:10 -07005420 get_nfs4_file(fp);
Trond Myklebust11b91642014-07-29 21:34:08 -04005421 stp->st_stid.sc_file = fp;
Jeff Laytonb49e0842014-07-29 21:34:11 -04005422 stp->st_stid.sc_free = nfs4_free_lock_stateid;
J. Bruce Fields0997b172011-03-02 18:01:35 -05005423 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005424 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07005425 stp->st_openstp = open_stp;
Jeff Layton35a92fe2015-09-17 07:47:08 -04005426 init_rwsem(&stp->st_rwsem);
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04005427 list_add(&stp->st_locks, &open_stp->st_locks);
Jeff Layton1c755dc2014-07-29 21:34:12 -04005428 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
Trond Myklebust1d31a252014-07-10 14:07:25 -04005429 spin_lock(&fp->fi_lock);
5430 list_add(&stp->st_perfile, &fp->fi_stateids);
5431 spin_unlock(&fp->fi_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005432}
5433
Jeff Laytonc53530d2014-06-30 11:48:39 -04005434static struct nfs4_ol_stateid *
5435find_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp)
5436{
5437 struct nfs4_ol_stateid *lst;
Jeff Layton356a95e2014-07-29 21:34:13 -04005438 struct nfs4_client *clp = lo->lo_owner.so_client;
5439
5440 lockdep_assert_held(&clp->cl_lock);
Jeff Laytonc53530d2014-06-30 11:48:39 -04005441
5442 list_for_each_entry(lst, &lo->lo_owner.so_stateids, st_perstateowner) {
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005443 if (lst->st_stid.sc_file == fp) {
5444 atomic_inc(&lst->st_stid.sc_count);
Jeff Laytonc53530d2014-06-30 11:48:39 -04005445 return lst;
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005446 }
Jeff Laytonc53530d2014-06-30 11:48:39 -04005447 }
5448 return NULL;
5449}
5450
Jeff Layton356a95e2014-07-29 21:34:13 -04005451static struct nfs4_ol_stateid *
5452find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
5453 struct inode *inode, struct nfs4_ol_stateid *ost,
5454 bool *new)
5455{
5456 struct nfs4_stid *ns = NULL;
5457 struct nfs4_ol_stateid *lst;
5458 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
5459 struct nfs4_client *clp = oo->oo_owner.so_client;
5460
5461 spin_lock(&clp->cl_lock);
5462 lst = find_lock_stateid(lo, fi);
5463 if (lst == NULL) {
5464 spin_unlock(&clp->cl_lock);
5465 ns = nfs4_alloc_stid(clp, stateid_slab);
5466 if (ns == NULL)
5467 return NULL;
5468
5469 spin_lock(&clp->cl_lock);
5470 lst = find_lock_stateid(lo, fi);
5471 if (likely(!lst)) {
5472 lst = openlockstateid(ns);
5473 init_lock_stateid(lst, lo, fi, inode, ost);
5474 ns = NULL;
5475 *new = true;
5476 }
5477 }
5478 spin_unlock(&clp->cl_lock);
5479 if (ns)
5480 nfs4_put_stid(ns);
5481 return lst;
5482}
Jeff Laytonc53530d2014-06-30 11:48:39 -04005483
NeilBrownfd39ca92005-06-23 22:04:03 -07005484static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07005485check_lock_length(u64 offset, u64 length)
5486{
Kinglong Meee7969312015-07-13 17:34:19 +08005487 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
5488 (length > ~offset)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005489}
5490
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005491static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05005492{
Trond Myklebust11b91642014-07-29 21:34:08 -04005493 struct nfs4_file *fp = lock_stp->st_stid.sc_file;
J. Bruce Fields0997b172011-03-02 18:01:35 -05005494
Jeff Layton7214e862014-07-10 14:07:33 -04005495 lockdep_assert_held(&fp->fi_lock);
5496
Jeff Layton82c5ff12012-05-11 09:45:13 -04005497 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05005498 return;
Jeff Layton12659652014-07-10 14:07:28 -04005499 __nfs4_file_get_access(fp, access);
Jeff Layton82c5ff12012-05-11 09:45:13 -04005500 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05005501}
5502
Jeff Layton356a95e2014-07-29 21:34:13 -04005503static __be32
5504lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
5505 struct nfs4_ol_stateid *ost,
5506 struct nfsd4_lock *lock,
5507 struct nfs4_ol_stateid **lst, bool *new)
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005508{
Jeff Layton5db1c032014-07-29 21:34:28 -04005509 __be32 status;
Trond Myklebust11b91642014-07-29 21:34:08 -04005510 struct nfs4_file *fi = ost->st_stid.sc_file;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005511 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
5512 struct nfs4_client *cl = oo->oo_owner.so_client;
David Howells2b0143b2015-03-17 22:25:59 +00005513 struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005514 struct nfs4_lockowner *lo;
5515 unsigned int strhashval;
5516
Kinglong Meec8623992015-07-13 17:35:37 +08005517 lo = find_lockowner_str(cl, &lock->lk_new_owner);
Jeff Laytonc53530d2014-06-30 11:48:39 -04005518 if (!lo) {
Kinglong Mee76f6c9e2015-07-13 17:35:10 +08005519 strhashval = ownerstr_hashval(&lock->lk_new_owner);
Jeff Laytonc53530d2014-06-30 11:48:39 -04005520 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
5521 if (lo == NULL)
5522 return nfserr_jukebox;
5523 } else {
5524 /* with an existing lockowner, seqids must be the same */
Jeff Layton5db1c032014-07-29 21:34:28 -04005525 status = nfserr_bad_seqid;
Jeff Laytonc53530d2014-06-30 11:48:39 -04005526 if (!cstate->minorversion &&
5527 lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
Jeff Layton5db1c032014-07-29 21:34:28 -04005528 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005529 }
Jeff Laytonc53530d2014-06-30 11:48:39 -04005530
Jeff Layton356a95e2014-07-29 21:34:13 -04005531 *lst = find_or_create_lock_stateid(lo, fi, inode, ost, new);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005532 if (*lst == NULL) {
Jeff Layton5db1c032014-07-29 21:34:28 -04005533 status = nfserr_jukebox;
5534 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005535 }
Jeff Layton5db1c032014-07-29 21:34:28 -04005536 status = nfs_ok;
5537out:
5538 nfs4_put_stateowner(&lo->lo_owner);
5539 return status;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005540}
5541
Linus Torvalds1da177e2005-04-16 15:20:36 -07005542/*
5543 * LOCK operation
5544 */
Al Virob37ad282006-10-19 23:28:59 -07005545__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005546nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08005547 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005548{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005549 struct nfs4_openowner *open_sop = NULL;
5550 struct nfs4_lockowner *lock_sop = NULL;
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005551 struct nfs4_ol_stateid *lock_stp = NULL;
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005552 struct nfs4_ol_stateid *open_stp = NULL;
Jeff Layton7214e862014-07-10 14:07:33 -04005553 struct nfs4_file *fp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04005554 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04005555 struct file_lock *file_lock = NULL;
5556 struct file_lock *conflock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07005557 __be32 status = 0;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04005558 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07005559 int err;
Jeff Layton5db1c032014-07-29 21:34:28 -04005560 bool new = false;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005561 struct net *net = SVC_NET(rqstp);
5562 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005563
5564 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
5565 (long long) lock->lk_offset,
5566 (long long) lock->lk_length);
5567
Linus Torvalds1da177e2005-04-16 15:20:36 -07005568 if (check_lock_length(lock->lk_offset, lock->lk_length))
5569 return nfserr_inval;
5570
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005571 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02005572 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08005573 dprintk("NFSD: nfsd4_lock: permission denied!\n");
5574 return status;
5575 }
5576
Linus Torvalds1da177e2005-04-16 15:20:36 -07005577 if (lock->lk_is_new) {
J. Bruce Fields684e5632011-11-04 17:08:10 -04005578 if (nfsd4_has_session(cstate))
5579 /* See rfc 5661 18.10.3: given clientid is ignored: */
Kinglong Mee76f6c9e2015-07-13 17:35:10 +08005580 memcpy(&lock->lk_new_clientid,
J. Bruce Fields684e5632011-11-04 17:08:10 -04005581 &cstate->session->se_client->cl_clientid,
5582 sizeof(clientid_t));
5583
Linus Torvalds1da177e2005-04-16 15:20:36 -07005584 status = nfserr_stale_clientid;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04005585 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005586 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005587
Linus Torvalds1da177e2005-04-16 15:20:36 -07005588 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04005589 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005590 lock->lk_new_open_seqid,
5591 &lock->lk_new_open_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005592 &open_stp, nn);
NeilBrown37515172005-07-07 17:59:16 -07005593 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005594 goto out;
Jeff Layton35a92fe2015-09-17 07:47:08 -04005595 up_write(&open_stp->st_rwsem);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005596 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04005597 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04005598 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
Kinglong Mee76f6c9e2015-07-13 17:35:10 +08005599 &lock->lk_new_clientid))
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04005600 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005601 status = lookup_or_create_lock_state(cstate, open_stp, lock,
Jeff Layton5db1c032014-07-29 21:34:28 -04005602 &lock_stp, &new);
Jeff Layton35a92fe2015-09-17 07:47:08 -04005603 if (status == nfs_ok)
5604 down_write(&lock_stp->st_rwsem);
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005605 } else {
Benny Halevydd453df2009-04-03 08:28:41 +03005606 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005607 lock->lk_old_lock_seqid,
5608 &lock->lk_old_lock_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005609 NFS4_LOCK_STID, &lock_stp, nn);
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005610 }
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04005611 if (status)
5612 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04005613 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005614
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04005615 lkflg = setlkflg(lock->lk_type);
5616 status = nfs4_check_openmode(lock_stp, lkflg);
5617 if (status)
5618 goto out;
5619
NeilBrown0dd395d2005-07-07 17:59:15 -07005620 status = nfserr_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005621 if (locks_in_grace(net) && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07005622 goto out;
5623 status = nfserr_no_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005624 if (!locks_in_grace(net) && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07005625 goto out;
5626
Jeff Layton21179d82012-08-21 08:03:32 -04005627 file_lock = locks_alloc_lock();
5628 if (!file_lock) {
5629 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5630 status = nfserr_jukebox;
5631 goto out;
5632 }
5633
Trond Myklebust11b91642014-07-29 21:34:08 -04005634 fp = lock_stp->st_stid.sc_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005635 switch (lock->lk_type) {
5636 case NFS4_READ_LT:
5637 case NFS4_READW_LT:
Jeff Layton7214e862014-07-10 14:07:33 -04005638 spin_lock(&fp->fi_lock);
5639 filp = find_readable_file_locked(fp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05005640 if (filp)
5641 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Jeff Layton7214e862014-07-10 14:07:33 -04005642 spin_unlock(&fp->fi_lock);
Jeff Layton21179d82012-08-21 08:03:32 -04005643 file_lock->fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05005644 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005645 case NFS4_WRITE_LT:
5646 case NFS4_WRITEW_LT:
Jeff Layton7214e862014-07-10 14:07:33 -04005647 spin_lock(&fp->fi_lock);
5648 filp = find_writeable_file_locked(fp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05005649 if (filp)
5650 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Jeff Layton7214e862014-07-10 14:07:33 -04005651 spin_unlock(&fp->fi_lock);
Jeff Layton21179d82012-08-21 08:03:32 -04005652 file_lock->fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05005653 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005654 default:
5655 status = nfserr_inval;
5656 goto out;
5657 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04005658 if (!filp) {
5659 status = nfserr_openmode;
5660 goto out;
5661 }
Kinglong Meeaef95832014-08-22 10:18:44 -04005662
5663 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner));
Jeff Layton21179d82012-08-21 08:03:32 -04005664 file_lock->fl_pid = current->tgid;
5665 file_lock->fl_file = filp;
5666 file_lock->fl_flags = FL_POSIX;
5667 file_lock->fl_lmops = &nfsd_posix_mng_ops;
5668 file_lock->fl_start = lock->lk_offset;
5669 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
5670 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005671
Jeff Layton21179d82012-08-21 08:03:32 -04005672 conflock = locks_alloc_lock();
5673 if (!conflock) {
5674 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5675 status = nfserr_jukebox;
5676 goto out;
5677 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005678
Jeff Layton21179d82012-08-21 08:03:32 -04005679 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07005680 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005681 case 0: /* success! */
Jeff Layton9767feb2015-10-01 09:05:50 -04005682 nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid);
Al Virob8dd7b92006-10-19 23:29:01 -07005683 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08005684 break;
5685 case (EAGAIN): /* conflock holds conflicting lock */
5686 status = nfserr_denied;
5687 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
Jeff Layton21179d82012-08-21 08:03:32 -04005688 nfs4_set_lock_denied(conflock, &lock->lk_denied);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08005689 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005690 case (EDEADLK):
5691 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08005692 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04005693 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05005694 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04005695 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08005696 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005697 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005698out:
Trond Myklebustde186432014-07-10 14:07:26 -04005699 if (filp)
5700 fput(filp);
Jeff Layton5db1c032014-07-29 21:34:28 -04005701 if (lock_stp) {
5702 /* Bump seqid manually if the 4.0 replay owner is openowner */
5703 if (cstate->replay_owner &&
5704 cstate->replay_owner != &lock_sop->lo_owner &&
5705 seqid_mutating_err(ntohl(status)))
5706 lock_sop->lo_owner.so_seqid++;
5707
Jeff Layton35a92fe2015-09-17 07:47:08 -04005708 up_write(&lock_stp->st_rwsem);
5709
Jeff Layton5db1c032014-07-29 21:34:28 -04005710 /*
5711 * If this is a new, never-before-used stateid, and we are
5712 * returning an error, then just go ahead and release it.
5713 */
5714 if (status && new)
5715 release_lock_stateid(lock_stp);
5716
Trond Myklebust3d0fabd2014-07-29 21:34:15 -04005717 nfs4_put_stid(&lock_stp->st_stid);
Jeff Layton5db1c032014-07-29 21:34:28 -04005718 }
Trond Myklebust0667b1e2014-07-29 21:34:22 -04005719 if (open_stp)
5720 nfs4_put_stid(&open_stp->st_stid);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04005721 nfsd4_bump_seqid(cstate, status);
Jeff Layton21179d82012-08-21 08:03:32 -04005722 if (file_lock)
5723 locks_free_lock(file_lock);
5724 if (conflock)
5725 locks_free_lock(conflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005726 return status;
5727}
5728
5729/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08005730 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
5731 * so we do a temporary open here just to get an open file to pass to
5732 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
5733 * inode operation.)
5734 */
Al Viro04da6e92012-04-13 00:00:04 -04005735static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
J. Bruce Fields55ef1272008-12-20 11:58:38 -08005736{
5737 struct file *file;
Al Viro04da6e92012-04-13 00:00:04 -04005738 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
5739 if (!err) {
5740 err = nfserrno(vfs_test_lock(file, lock));
Christoph Hellwigfd891452015-04-28 15:41:16 +02005741 fput(file);
Al Viro04da6e92012-04-13 00:00:04 -04005742 }
J. Bruce Fields55ef1272008-12-20 11:58:38 -08005743 return err;
5744}
5745
5746/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07005747 * LOCKT operation
5748 */
Al Virob37ad282006-10-19 23:28:59 -07005749__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005750nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5751 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005752{
Jeff Layton21179d82012-08-21 08:03:32 -04005753 struct file_lock *file_lock = NULL;
Jeff Layton5db1c032014-07-29 21:34:28 -04005754 struct nfs4_lockowner *lo = NULL;
Al Virob37ad282006-10-19 23:28:59 -07005755 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03005756 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005757
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04005758 if (locks_in_grace(SVC_NET(rqstp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005759 return nfserr_grace;
5760
5761 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
5762 return nfserr_inval;
5763
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05005764 if (!nfsd4_has_session(cstate)) {
Jeff Layton4b24ca72014-06-30 11:48:44 -04005765 status = lookup_clientid(&lockt->lt_clientid, cstate, nn);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05005766 if (status)
5767 goto out;
5768 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005769
J. Bruce Fields75c096f2011-08-15 18:39:32 -04005770 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005771 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005772
Jeff Layton21179d82012-08-21 08:03:32 -04005773 file_lock = locks_alloc_lock();
5774 if (!file_lock) {
5775 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5776 status = nfserr_jukebox;
5777 goto out;
5778 }
Kinglong Mee6cd90662014-08-15 08:02:55 +08005779
Linus Torvalds1da177e2005-04-16 15:20:36 -07005780 switch (lockt->lt_type) {
5781 case NFS4_READ_LT:
5782 case NFS4_READW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04005783 file_lock->fl_type = F_RDLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005784 break;
5785 case NFS4_WRITE_LT:
5786 case NFS4_WRITEW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04005787 file_lock->fl_type = F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005788 break;
5789 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04005790 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005791 status = nfserr_inval;
5792 goto out;
5793 }
5794
Kinglong Meec8623992015-07-13 17:35:37 +08005795 lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04005796 if (lo)
Jeff Layton21179d82012-08-21 08:03:32 -04005797 file_lock->fl_owner = (fl_owner_t)lo;
5798 file_lock->fl_pid = current->tgid;
5799 file_lock->fl_flags = FL_POSIX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005800
Jeff Layton21179d82012-08-21 08:03:32 -04005801 file_lock->fl_start = lockt->lt_offset;
5802 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005803
Jeff Layton21179d82012-08-21 08:03:32 -04005804 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005805
Jeff Layton21179d82012-08-21 08:03:32 -04005806 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
Al Viro04da6e92012-04-13 00:00:04 -04005807 if (status)
Marc Eshelfd85b812006-11-28 16:26:41 -05005808 goto out;
Al Viro04da6e92012-04-13 00:00:04 -04005809
Jeff Layton21179d82012-08-21 08:03:32 -04005810 if (file_lock->fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005811 status = nfserr_denied;
Jeff Layton21179d82012-08-21 08:03:32 -04005812 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005813 }
5814out:
Jeff Layton5db1c032014-07-29 21:34:28 -04005815 if (lo)
5816 nfs4_put_stateowner(&lo->lo_owner);
Jeff Layton21179d82012-08-21 08:03:32 -04005817 if (file_lock)
5818 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005819 return status;
5820}
5821
Al Virob37ad282006-10-19 23:28:59 -07005822__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08005823nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08005824 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005825{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005826 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005827 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04005828 struct file_lock *file_lock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07005829 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07005830 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005831 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5832
Linus Torvalds1da177e2005-04-16 15:20:36 -07005833 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
5834 (long long) locku->lu_offset,
5835 (long long) locku->lu_length);
5836
5837 if (check_lock_length(locku->lu_offset, locku->lu_length))
5838 return nfserr_inval;
5839
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005840 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005841 &locku->lu_stateid, NFS4_LOCK_STID,
5842 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04005843 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005844 goto out;
Trond Myklebust11b91642014-07-29 21:34:08 -04005845 filp = find_any_file(stp->st_stid.sc_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04005846 if (!filp) {
5847 status = nfserr_lock_range;
Trond Myklebust858cc572014-07-29 21:34:16 -04005848 goto put_stateid;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04005849 }
Jeff Layton21179d82012-08-21 08:03:32 -04005850 file_lock = locks_alloc_lock();
5851 if (!file_lock) {
5852 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
5853 status = nfserr_jukebox;
Trond Myklebustde186432014-07-10 14:07:26 -04005854 goto fput;
Jeff Layton21179d82012-08-21 08:03:32 -04005855 }
Kinglong Mee6cd90662014-08-15 08:02:55 +08005856
Jeff Layton21179d82012-08-21 08:03:32 -04005857 file_lock->fl_type = F_UNLCK;
Kinglong Meeaef95832014-08-22 10:18:44 -04005858 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner));
Jeff Layton21179d82012-08-21 08:03:32 -04005859 file_lock->fl_pid = current->tgid;
5860 file_lock->fl_file = filp;
5861 file_lock->fl_flags = FL_POSIX;
5862 file_lock->fl_lmops = &nfsd_posix_mng_ops;
5863 file_lock->fl_start = locku->lu_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005864
Jeff Layton21179d82012-08-21 08:03:32 -04005865 file_lock->fl_end = last_byte_offset(locku->lu_offset,
5866 locku->lu_length);
5867 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005868
Jeff Layton21179d82012-08-21 08:03:32 -04005869 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07005870 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05005871 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005872 goto out_nfserr;
5873 }
Jeff Layton9767feb2015-10-01 09:05:50 -04005874 nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid);
Trond Myklebustde186432014-07-10 14:07:26 -04005875fput:
5876 fput(filp);
Trond Myklebust858cc572014-07-29 21:34:16 -04005877put_stateid:
Jeff Layton35a92fe2015-09-17 07:47:08 -04005878 up_write(&stp->st_rwsem);
Trond Myklebust858cc572014-07-29 21:34:16 -04005879 nfs4_put_stid(&stp->st_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005880out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04005881 nfsd4_bump_seqid(cstate, status);
Jeff Layton21179d82012-08-21 08:03:32 -04005882 if (file_lock)
5883 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005884 return status;
5885
5886out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07005887 status = nfserrno(err);
Trond Myklebustde186432014-07-10 14:07:26 -04005888 goto fput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005889}
5890
5891/*
5892 * returns
Jeff Laytonf9c00c32014-07-23 16:17:41 -04005893 * true: locks held by lockowner
5894 * false: no locks held by lockowner
Linus Torvalds1da177e2005-04-16 15:20:36 -07005895 */
Jeff Laytonf9c00c32014-07-23 16:17:41 -04005896static bool
5897check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005898{
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05005899 struct file_lock *fl;
Jeff Laytonf9c00c32014-07-23 16:17:41 -04005900 int status = false;
5901 struct file *filp = find_any_file(fp);
5902 struct inode *inode;
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05005903 struct file_lock_context *flctx;
Jeff Laytonf9c00c32014-07-23 16:17:41 -04005904
5905 if (!filp) {
5906 /* Any valid lock stateid should have some sort of access */
5907 WARN_ON_ONCE(1);
5908 return status;
5909 }
5910
5911 inode = file_inode(filp);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05005912 flctx = inode->i_flctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005913
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05005914 if (flctx && !list_empty_careful(&flctx->flc_posix)) {
Jeff Layton6109c852015-01-16 15:05:57 -05005915 spin_lock(&flctx->flc_lock);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05005916 list_for_each_entry(fl, &flctx->flc_posix, fl_list) {
5917 if (fl->fl_owner == (fl_owner_t)lowner) {
5918 status = true;
5919 break;
5920 }
J. Bruce Fields796dadf2006-01-18 17:43:22 -08005921 }
Jeff Layton6109c852015-01-16 15:05:57 -05005922 spin_unlock(&flctx->flc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005923 }
Jeff Laytonf9c00c32014-07-23 16:17:41 -04005924 fput(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005925 return status;
5926}
5927
Al Virob37ad282006-10-19 23:28:59 -07005928__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08005929nfsd4_release_lockowner(struct svc_rqst *rqstp,
5930 struct nfsd4_compound_state *cstate,
5931 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005932{
5933 clientid_t *clid = &rlockowner->rl_clientid;
Jeff Layton882e9d22014-07-29 21:34:37 -04005934 struct nfs4_stateowner *sop;
5935 struct nfs4_lockowner *lo = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04005936 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005937 struct xdr_netobj *owner = &rlockowner->rl_owner;
Trond Myklebustd4f04892014-07-29 21:34:36 -04005938 unsigned int hashval = ownerstr_hashval(owner);
Al Virob37ad282006-10-19 23:28:59 -07005939 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03005940 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Trond Myklebustc58c6612014-07-29 21:34:35 -04005941 struct nfs4_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005942
5943 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
5944 clid->cl_boot, clid->cl_id);
5945
Jeff Layton4b24ca72014-06-30 11:48:44 -04005946 status = lookup_clientid(clid, cstate, nn);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05005947 if (status)
Trond Myklebust51f5e782014-07-30 08:27:27 -04005948 return status;
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05005949
Trond Myklebustd4f04892014-07-29 21:34:36 -04005950 clp = cstate->clp;
Jeff Laytonfd449072014-06-30 11:48:41 -04005951 /* Find the matching lock stateowner */
Trond Myklebustd4f04892014-07-29 21:34:36 -04005952 spin_lock(&clp->cl_lock);
Jeff Layton882e9d22014-07-29 21:34:37 -04005953 list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval],
Trond Myklebustd4f04892014-07-29 21:34:36 -04005954 so_strhash) {
Jeff Layton882e9d22014-07-29 21:34:37 -04005955
5956 if (sop->so_is_open_owner || !same_owner_str(sop, owner))
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05005957 continue;
Jeff Laytonfd449072014-06-30 11:48:41 -04005958
Jeff Layton882e9d22014-07-29 21:34:37 -04005959 /* see if there are still any locks associated with it */
5960 lo = lockowner(sop);
5961 list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
5962 if (check_for_locks(stp->st_stid.sc_file, lo)) {
5963 status = nfserr_locks_held;
5964 spin_unlock(&clp->cl_lock);
Trond Myklebust51f5e782014-07-30 08:27:27 -04005965 return status;
Jeff Layton882e9d22014-07-29 21:34:37 -04005966 }
Jeff Layton5adfd882014-07-29 21:34:31 -04005967 }
Jeff Layton882e9d22014-07-29 21:34:37 -04005968
Kinglong Meeb5971af2014-08-22 10:18:43 -04005969 nfs4_get_stateowner(sop);
Jeff Layton882e9d22014-07-29 21:34:37 -04005970 break;
Jeff Laytonfd449072014-06-30 11:48:41 -04005971 }
Trond Myklebustc58c6612014-07-29 21:34:35 -04005972 spin_unlock(&clp->cl_lock);
Jeff Layton882e9d22014-07-29 21:34:37 -04005973 if (lo)
5974 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005975 return status;
5976}
5977
5978static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07005979alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005980{
NeilBrowna55370a2005-06-23 22:03:52 -07005981 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005982}
5983
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05005984bool
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03005985nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
NeilBrownc7b9a452005-06-23 22:04:30 -07005986{
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05005987 struct nfs4_client_reclaim *crp;
NeilBrownc7b9a452005-06-23 22:04:30 -07005988
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03005989 crp = nfsd4_find_reclaim_client(name, nn);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05005990 return (crp && crp->cr_clp);
NeilBrownc7b9a452005-06-23 22:04:30 -07005991}
5992
Linus Torvalds1da177e2005-04-16 15:20:36 -07005993/*
5994 * failure => all reset bets are off, nfserr_no_grace...
5995 */
Jeff Layton772a9bb2012-11-12 15:00:54 -05005996struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03005997nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005998{
5999 unsigned int strhashval;
Jeff Layton772a9bb2012-11-12 15:00:54 -05006000 struct nfs4_client_reclaim *crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006001
NeilBrowna55370a2005-06-23 22:03:52 -07006002 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
6003 crp = alloc_reclaim();
Jeff Layton772a9bb2012-11-12 15:00:54 -05006004 if (crp) {
6005 strhashval = clientstr_hashval(name);
6006 INIT_LIST_HEAD(&crp->cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006007 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
Jeff Layton772a9bb2012-11-12 15:00:54 -05006008 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05006009 crp->cr_clp = NULL;
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006010 nn->reclaim_str_hashtbl_size++;
Jeff Layton772a9bb2012-11-12 15:00:54 -05006011 }
6012 return crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006013}
6014
Jeff Layton2a4317c2012-03-21 16:42:43 -04006015void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006016nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
Jeff Laytonce30e532012-11-12 15:00:53 -05006017{
6018 list_del(&crp->cr_strhash);
6019 kfree(crp);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006020 nn->reclaim_str_hashtbl_size--;
Jeff Laytonce30e532012-11-12 15:00:53 -05006021}
6022
6023void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006024nfs4_release_reclaim(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006025{
6026 struct nfs4_client_reclaim *crp = NULL;
6027 int i;
6028
Linus Torvalds1da177e2005-04-16 15:20:36 -07006029 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006030 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
6031 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006032 struct nfs4_client_reclaim, cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006033 nfs4_remove_reclaim_record(crp, nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006034 }
6035 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05006036 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006037}
6038
6039/*
6040 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04006041struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006042nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006043{
6044 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006045 struct nfs4_client_reclaim *crp = NULL;
6046
Jeff Layton278c9312012-11-12 15:00:52 -05006047 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006048
Jeff Layton278c9312012-11-12 15:00:52 -05006049 strhashval = clientstr_hashval(recdir);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03006050 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
Jeff Layton278c9312012-11-12 15:00:52 -05006051 if (same_name(crp->cr_recdir, recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006052 return crp;
6053 }
6054 }
6055 return NULL;
6056}
6057
6058/*
6059* Called from OPEN. Look for clientid in reclaim list.
6060*/
Al Virob37ad282006-10-19 23:28:59 -07006061__be32
Trond Myklebust0fe492d2014-06-30 11:48:47 -04006062nfs4_check_open_reclaim(clientid_t *clid,
6063 struct nfsd4_compound_state *cstate,
6064 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006065{
Trond Myklebust0fe492d2014-06-30 11:48:47 -04006066 __be32 status;
Jeff Laytona52d7262012-03-21 09:52:02 -04006067
6068 /* find clientid in conf_id_hashtbl */
Trond Myklebust0fe492d2014-06-30 11:48:47 -04006069 status = lookup_clientid(clid, cstate, nn);
6070 if (status)
Jeff Laytona52d7262012-03-21 09:52:02 -04006071 return nfserr_reclaim_bad;
6072
Jeff Layton3b3e7b72014-09-12 16:40:22 -04006073 if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags))
6074 return nfserr_no_grace;
6075
Trond Myklebust0fe492d2014-06-30 11:48:47 -04006076 if (nfsd4_client_record_check(cstate->clp))
6077 return nfserr_reclaim_bad;
6078
6079 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006080}
6081
Bryan Schumaker65178db2011-11-01 13:35:21 -04006082#ifdef CONFIG_NFSD_FAULT_INJECTION
Jeff Layton016200c2014-07-30 08:27:21 -04006083static inline void
6084put_client(struct nfs4_client *clp)
6085{
6086 atomic_dec(&clp->cl_refcount);
6087}
6088
Jeff Layton285abde2014-07-30 08:27:24 -04006089static struct nfs4_client *
6090nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
6091{
6092 struct nfs4_client *clp;
6093 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6094 nfsd_net_id);
6095
6096 if (!nfsd_netns_ready(nn))
6097 return NULL;
6098
6099 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6100 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
6101 return clp;
6102 }
6103 return NULL;
6104}
6105
Jeff Layton7ec0e362014-07-30 08:27:17 -04006106u64
Jeff Layton285abde2014-07-30 08:27:24 -04006107nfsd_inject_print_clients(void)
Jeff Layton7ec0e362014-07-30 08:27:17 -04006108{
6109 struct nfs4_client *clp;
6110 u64 count = 0;
6111 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6112 nfsd_net_id);
6113 char buf[INET6_ADDRSTRLEN];
6114
6115 if (!nfsd_netns_ready(nn))
6116 return 0;
6117
6118 spin_lock(&nn->client_lock);
6119 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6120 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
6121 pr_info("NFS Client: %s\n", buf);
6122 ++count;
6123 }
6124 spin_unlock(&nn->client_lock);
6125
6126 return count;
6127}
Bryan Schumaker65178db2011-11-01 13:35:21 -04006128
Jeff Laytona0926d12014-07-30 08:27:18 -04006129u64
Jeff Layton285abde2014-07-30 08:27:24 -04006130nfsd_inject_forget_client(struct sockaddr_storage *addr, size_t addr_size)
Jeff Laytona0926d12014-07-30 08:27:18 -04006131{
6132 u64 count = 0;
6133 struct nfs4_client *clp;
6134 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6135 nfsd_net_id);
6136
6137 if (!nfsd_netns_ready(nn))
6138 return count;
6139
6140 spin_lock(&nn->client_lock);
6141 clp = nfsd_find_client(addr, addr_size);
6142 if (clp) {
6143 if (mark_client_expired_locked(clp) == nfs_ok)
6144 ++count;
6145 else
6146 clp = NULL;
6147 }
6148 spin_unlock(&nn->client_lock);
6149
6150 if (clp)
6151 expire_client(clp);
6152
6153 return count;
6154}
6155
Jeff Layton69fc9ed2014-07-30 08:27:19 -04006156u64
Jeff Layton285abde2014-07-30 08:27:24 -04006157nfsd_inject_forget_clients(u64 max)
Jeff Layton69fc9ed2014-07-30 08:27:19 -04006158{
6159 u64 count = 0;
6160 struct nfs4_client *clp, *next;
6161 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6162 nfsd_net_id);
6163 LIST_HEAD(reaplist);
6164
6165 if (!nfsd_netns_ready(nn))
6166 return count;
6167
6168 spin_lock(&nn->client_lock);
6169 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
6170 if (mark_client_expired_locked(clp) == nfs_ok) {
6171 list_add(&clp->cl_lru, &reaplist);
6172 if (max != 0 && ++count >= max)
6173 break;
6174 }
6175 }
6176 spin_unlock(&nn->client_lock);
6177
6178 list_for_each_entry_safe(clp, next, &reaplist, cl_lru)
6179 expire_client(clp);
6180
6181 return count;
6182}
6183
Bryan Schumaker184c1842012-11-29 11:40:44 -05006184static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
6185 const char *type)
6186{
6187 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05006188 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05006189 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
6190}
6191
Jeff Layton016200c2014-07-30 08:27:21 -04006192static void
6193nfsd_inject_add_lock_to_list(struct nfs4_ol_stateid *lst,
6194 struct list_head *collect)
6195{
6196 struct nfs4_client *clp = lst->st_stid.sc_client;
6197 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6198 nfsd_net_id);
6199
6200 if (!collect)
6201 return;
6202
6203 lockdep_assert_held(&nn->client_lock);
6204 atomic_inc(&clp->cl_refcount);
6205 list_add(&lst->st_locks, collect);
6206}
6207
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04006208static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max,
Jeff Layton3738d502014-07-30 08:27:20 -04006209 struct list_head *collect,
Jeff Laytone8568732015-08-24 12:41:47 -04006210 bool (*func)(struct nfs4_ol_stateid *))
Bryan Schumakerfc291712012-11-29 11:40:40 -05006211{
6212 struct nfs4_openowner *oop;
Bryan Schumakerfc291712012-11-29 11:40:40 -05006213 struct nfs4_ol_stateid *stp, *st_next;
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04006214 struct nfs4_ol_stateid *lst, *lst_next;
Bryan Schumakerfc291712012-11-29 11:40:40 -05006215 u64 count = 0;
6216
Jeff Layton016200c2014-07-30 08:27:21 -04006217 spin_lock(&clp->cl_lock);
Bryan Schumakerfc291712012-11-29 11:40:40 -05006218 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
Trond Myklebust3c87b9b2014-06-30 11:48:38 -04006219 list_for_each_entry_safe(stp, st_next,
6220 &oop->oo_owner.so_stateids, st_perstateowner) {
6221 list_for_each_entry_safe(lst, lst_next,
6222 &stp->st_locks, st_locks) {
Jeff Layton3738d502014-07-30 08:27:20 -04006223 if (func) {
Jeff Laytone8568732015-08-24 12:41:47 -04006224 if (func(lst))
6225 nfsd_inject_add_lock_to_list(lst,
6226 collect);
Jeff Layton3738d502014-07-30 08:27:20 -04006227 }
Jeff Layton016200c2014-07-30 08:27:21 -04006228 ++count;
6229 /*
6230 * Despite the fact that these functions deal
6231 * with 64-bit integers for "count", we must
6232 * ensure that it doesn't blow up the
6233 * clp->cl_refcount. Throw a warning if we
6234 * start to approach INT_MAX here.
6235 */
6236 WARN_ON_ONCE(count == (INT_MAX / 2));
6237 if (count == max)
6238 goto out;
Bryan Schumakerfc291712012-11-29 11:40:40 -05006239 }
6240 }
6241 }
Jeff Layton016200c2014-07-30 08:27:21 -04006242out:
6243 spin_unlock(&clp->cl_lock);
Bryan Schumakerfc291712012-11-29 11:40:40 -05006244
6245 return count;
6246}
6247
Jeff Layton016200c2014-07-30 08:27:21 -04006248static u64
6249nfsd_collect_client_locks(struct nfs4_client *clp, struct list_head *collect,
6250 u64 max)
Bryan Schumakerfc291712012-11-29 11:40:40 -05006251{
Jeff Layton016200c2014-07-30 08:27:21 -04006252 return nfsd_foreach_client_lock(clp, max, collect, unhash_lock_stateid);
Bryan Schumakerfc291712012-11-29 11:40:40 -05006253}
6254
Jeff Layton016200c2014-07-30 08:27:21 -04006255static u64
6256nfsd_print_client_locks(struct nfs4_client *clp)
Bryan Schumaker184c1842012-11-29 11:40:44 -05006257{
Jeff Layton016200c2014-07-30 08:27:21 -04006258 u64 count = nfsd_foreach_client_lock(clp, 0, NULL, NULL);
Bryan Schumaker184c1842012-11-29 11:40:44 -05006259 nfsd_print_count(clp, count, "locked files");
6260 return count;
6261}
6262
Jeff Layton016200c2014-07-30 08:27:21 -04006263u64
Jeff Layton285abde2014-07-30 08:27:24 -04006264nfsd_inject_print_locks(void)
Jeff Layton016200c2014-07-30 08:27:21 -04006265{
6266 struct nfs4_client *clp;
6267 u64 count = 0;
6268 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6269 nfsd_net_id);
6270
6271 if (!nfsd_netns_ready(nn))
6272 return 0;
6273
6274 spin_lock(&nn->client_lock);
6275 list_for_each_entry(clp, &nn->client_lru, cl_lru)
6276 count += nfsd_print_client_locks(clp);
6277 spin_unlock(&nn->client_lock);
6278
6279 return count;
6280}
6281
6282static void
6283nfsd_reap_locks(struct list_head *reaplist)
6284{
6285 struct nfs4_client *clp;
6286 struct nfs4_ol_stateid *stp, *next;
6287
6288 list_for_each_entry_safe(stp, next, reaplist, st_locks) {
6289 list_del_init(&stp->st_locks);
6290 clp = stp->st_stid.sc_client;
6291 nfs4_put_stid(&stp->st_stid);
6292 put_client(clp);
6293 }
6294}
6295
6296u64
Jeff Layton285abde2014-07-30 08:27:24 -04006297nfsd_inject_forget_client_locks(struct sockaddr_storage *addr, size_t addr_size)
Jeff Layton016200c2014-07-30 08:27:21 -04006298{
6299 unsigned int count = 0;
6300 struct nfs4_client *clp;
6301 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6302 nfsd_net_id);
6303 LIST_HEAD(reaplist);
6304
6305 if (!nfsd_netns_ready(nn))
6306 return count;
6307
6308 spin_lock(&nn->client_lock);
6309 clp = nfsd_find_client(addr, addr_size);
6310 if (clp)
6311 count = nfsd_collect_client_locks(clp, &reaplist, 0);
6312 spin_unlock(&nn->client_lock);
6313 nfsd_reap_locks(&reaplist);
6314 return count;
6315}
6316
6317u64
Jeff Layton285abde2014-07-30 08:27:24 -04006318nfsd_inject_forget_locks(u64 max)
Jeff Layton016200c2014-07-30 08:27:21 -04006319{
6320 u64 count = 0;
6321 struct nfs4_client *clp;
6322 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6323 nfsd_net_id);
6324 LIST_HEAD(reaplist);
6325
6326 if (!nfsd_netns_ready(nn))
6327 return count;
6328
6329 spin_lock(&nn->client_lock);
6330 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6331 count += nfsd_collect_client_locks(clp, &reaplist, max - count);
6332 if (max != 0 && count >= max)
6333 break;
6334 }
6335 spin_unlock(&nn->client_lock);
6336 nfsd_reap_locks(&reaplist);
6337 return count;
6338}
6339
Jeff Layton82e05ef2014-07-30 08:27:22 -04006340static u64
6341nfsd_foreach_client_openowner(struct nfs4_client *clp, u64 max,
6342 struct list_head *collect,
6343 void (*func)(struct nfs4_openowner *))
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006344{
6345 struct nfs4_openowner *oop, *next;
Jeff Layton82e05ef2014-07-30 08:27:22 -04006346 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6347 nfsd_net_id);
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006348 u64 count = 0;
6349
Jeff Layton82e05ef2014-07-30 08:27:22 -04006350 lockdep_assert_held(&nn->client_lock);
6351
6352 spin_lock(&clp->cl_lock);
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006353 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
Jeff Layton82e05ef2014-07-30 08:27:22 -04006354 if (func) {
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006355 func(oop);
Jeff Layton82e05ef2014-07-30 08:27:22 -04006356 if (collect) {
6357 atomic_inc(&clp->cl_refcount);
6358 list_add(&oop->oo_perclient, collect);
6359 }
6360 }
6361 ++count;
6362 /*
6363 * Despite the fact that these functions deal with
6364 * 64-bit integers for "count", we must ensure that
6365 * it doesn't blow up the clp->cl_refcount. Throw a
6366 * warning if we start to approach INT_MAX here.
6367 */
6368 WARN_ON_ONCE(count == (INT_MAX / 2));
6369 if (count == max)
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006370 break;
6371 }
Jeff Layton82e05ef2014-07-30 08:27:22 -04006372 spin_unlock(&clp->cl_lock);
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006373
6374 return count;
6375}
6376
Jeff Layton82e05ef2014-07-30 08:27:22 -04006377static u64
6378nfsd_print_client_openowners(struct nfs4_client *clp)
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006379{
Jeff Layton82e05ef2014-07-30 08:27:22 -04006380 u64 count = nfsd_foreach_client_openowner(clp, 0, NULL, NULL);
6381
6382 nfsd_print_count(clp, count, "openowners");
6383 return count;
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05006384}
6385
Jeff Layton82e05ef2014-07-30 08:27:22 -04006386static u64
6387nfsd_collect_client_openowners(struct nfs4_client *clp,
6388 struct list_head *collect, u64 max)
Bryan Schumaker184c1842012-11-29 11:40:44 -05006389{
Jeff Layton82e05ef2014-07-30 08:27:22 -04006390 return nfsd_foreach_client_openowner(clp, max, collect,
6391 unhash_openowner_locked);
6392}
6393
6394u64
Jeff Layton285abde2014-07-30 08:27:24 -04006395nfsd_inject_print_openowners(void)
Jeff Layton82e05ef2014-07-30 08:27:22 -04006396{
6397 struct nfs4_client *clp;
6398 u64 count = 0;
6399 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6400 nfsd_net_id);
6401
6402 if (!nfsd_netns_ready(nn))
6403 return 0;
6404
6405 spin_lock(&nn->client_lock);
6406 list_for_each_entry(clp, &nn->client_lru, cl_lru)
6407 count += nfsd_print_client_openowners(clp);
6408 spin_unlock(&nn->client_lock);
6409
6410 return count;
6411}
6412
6413static void
6414nfsd_reap_openowners(struct list_head *reaplist)
6415{
6416 struct nfs4_client *clp;
6417 struct nfs4_openowner *oop, *next;
6418
6419 list_for_each_entry_safe(oop, next, reaplist, oo_perclient) {
6420 list_del_init(&oop->oo_perclient);
6421 clp = oop->oo_owner.so_client;
6422 release_openowner(oop);
6423 put_client(clp);
6424 }
6425}
6426
6427u64
Jeff Layton285abde2014-07-30 08:27:24 -04006428nfsd_inject_forget_client_openowners(struct sockaddr_storage *addr,
6429 size_t addr_size)
Jeff Layton82e05ef2014-07-30 08:27:22 -04006430{
6431 unsigned int count = 0;
6432 struct nfs4_client *clp;
6433 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6434 nfsd_net_id);
6435 LIST_HEAD(reaplist);
6436
6437 if (!nfsd_netns_ready(nn))
6438 return count;
6439
6440 spin_lock(&nn->client_lock);
6441 clp = nfsd_find_client(addr, addr_size);
6442 if (clp)
6443 count = nfsd_collect_client_openowners(clp, &reaplist, 0);
6444 spin_unlock(&nn->client_lock);
6445 nfsd_reap_openowners(&reaplist);
6446 return count;
6447}
6448
6449u64
Jeff Layton285abde2014-07-30 08:27:24 -04006450nfsd_inject_forget_openowners(u64 max)
Jeff Layton82e05ef2014-07-30 08:27:22 -04006451{
6452 u64 count = 0;
6453 struct nfs4_client *clp;
6454 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6455 nfsd_net_id);
6456 LIST_HEAD(reaplist);
6457
6458 if (!nfsd_netns_ready(nn))
6459 return count;
6460
6461 spin_lock(&nn->client_lock);
6462 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6463 count += nfsd_collect_client_openowners(clp, &reaplist,
6464 max - count);
6465 if (max != 0 && count >= max)
6466 break;
6467 }
6468 spin_unlock(&nn->client_lock);
6469 nfsd_reap_openowners(&reaplist);
Bryan Schumaker184c1842012-11-29 11:40:44 -05006470 return count;
6471}
6472
Bryan Schumaker269de302012-11-29 11:40:42 -05006473static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
6474 struct list_head *victims)
6475{
6476 struct nfs4_delegation *dp, *next;
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006477 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6478 nfsd_net_id);
Bryan Schumaker269de302012-11-29 11:40:42 -05006479 u64 count = 0;
6480
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006481 lockdep_assert_held(&nn->client_lock);
6482
6483 spin_lock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05006484 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
Jeff Laytondff13992014-07-08 14:02:49 -04006485 if (victims) {
6486 /*
6487 * It's not safe to mess with delegations that have a
6488 * non-zero dl_time. They might have already been broken
6489 * and could be processed by the laundromat outside of
6490 * the state_lock. Just leave them be.
6491 */
6492 if (dp->dl_time != 0)
6493 continue;
6494
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006495 atomic_inc(&clp->cl_refcount);
Jeff Layton3fcbbd22015-08-24 12:41:48 -04006496 WARN_ON(!unhash_delegation_locked(dp));
Jeff Layton42690672014-07-25 07:34:20 -04006497 list_add(&dp->dl_recall_lru, victims);
Jeff Laytondff13992014-07-08 14:02:49 -04006498 }
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006499 ++count;
6500 /*
6501 * Despite the fact that these functions deal with
6502 * 64-bit integers for "count", we must ensure that
6503 * it doesn't blow up the clp->cl_refcount. Throw a
6504 * warning if we start to approach INT_MAX here.
6505 */
6506 WARN_ON_ONCE(count == (INT_MAX / 2));
6507 if (count == max)
Bryan Schumaker269de302012-11-29 11:40:42 -05006508 break;
6509 }
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006510 spin_unlock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05006511 return count;
6512}
6513
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006514static u64
6515nfsd_print_client_delegations(struct nfs4_client *clp)
Bryan Schumaker269de302012-11-29 11:40:42 -05006516{
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006517 u64 count = nfsd_find_all_delegations(clp, 0, NULL);
Bryan Schumaker184c1842012-11-29 11:40:44 -05006518
6519 nfsd_print_count(clp, count, "delegations");
6520 return count;
6521}
6522
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006523u64
Jeff Layton285abde2014-07-30 08:27:24 -04006524nfsd_inject_print_delegations(void)
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006525{
6526 struct nfs4_client *clp;
6527 u64 count = 0;
6528 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6529 nfsd_net_id);
6530
6531 if (!nfsd_netns_ready(nn))
6532 return 0;
6533
6534 spin_lock(&nn->client_lock);
6535 list_for_each_entry(clp, &nn->client_lru, cl_lru)
6536 count += nfsd_print_client_delegations(clp);
6537 spin_unlock(&nn->client_lock);
6538
6539 return count;
6540}
6541
6542static void
6543nfsd_forget_delegations(struct list_head *reaplist)
6544{
6545 struct nfs4_client *clp;
6546 struct nfs4_delegation *dp, *next;
6547
6548 list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
6549 list_del_init(&dp->dl_recall_lru);
6550 clp = dp->dl_stid.sc_client;
6551 revoke_delegation(dp);
6552 put_client(clp);
6553 }
6554}
6555
6556u64
Jeff Layton285abde2014-07-30 08:27:24 -04006557nfsd_inject_forget_client_delegations(struct sockaddr_storage *addr,
6558 size_t addr_size)
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006559{
6560 u64 count = 0;
6561 struct nfs4_client *clp;
6562 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6563 nfsd_net_id);
6564 LIST_HEAD(reaplist);
6565
6566 if (!nfsd_netns_ready(nn))
6567 return count;
6568
6569 spin_lock(&nn->client_lock);
6570 clp = nfsd_find_client(addr, addr_size);
6571 if (clp)
6572 count = nfsd_find_all_delegations(clp, 0, &reaplist);
6573 spin_unlock(&nn->client_lock);
6574
6575 nfsd_forget_delegations(&reaplist);
6576 return count;
6577}
6578
6579u64
Jeff Layton285abde2014-07-30 08:27:24 -04006580nfsd_inject_forget_delegations(u64 max)
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006581{
6582 u64 count = 0;
6583 struct nfs4_client *clp;
6584 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6585 nfsd_net_id);
6586 LIST_HEAD(reaplist);
6587
6588 if (!nfsd_netns_ready(nn))
6589 return count;
6590
6591 spin_lock(&nn->client_lock);
6592 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6593 count += nfsd_find_all_delegations(clp, max - count, &reaplist);
6594 if (max != 0 && count >= max)
6595 break;
6596 }
6597 spin_unlock(&nn->client_lock);
6598 nfsd_forget_delegations(&reaplist);
6599 return count;
6600}
6601
6602static void
6603nfsd_recall_delegations(struct list_head *reaplist)
6604{
6605 struct nfs4_client *clp;
6606 struct nfs4_delegation *dp, *next;
6607
6608 list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
6609 list_del_init(&dp->dl_recall_lru);
6610 clp = dp->dl_stid.sc_client;
6611 /*
6612 * We skipped all entries that had a zero dl_time before,
6613 * so we can now reset the dl_time back to 0. If a delegation
6614 * break comes in now, then it won't make any difference since
6615 * we're recalling it either way.
6616 */
6617 spin_lock(&state_lock);
6618 dp->dl_time = 0;
6619 spin_unlock(&state_lock);
6620 nfsd_break_one_deleg(dp);
6621 put_client(clp);
6622 }
6623}
6624
6625u64
Jeff Layton285abde2014-07-30 08:27:24 -04006626nfsd_inject_recall_client_delegations(struct sockaddr_storage *addr,
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006627 size_t addr_size)
6628{
6629 u64 count = 0;
6630 struct nfs4_client *clp;
6631 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6632 nfsd_net_id);
6633 LIST_HEAD(reaplist);
6634
6635 if (!nfsd_netns_ready(nn))
6636 return count;
6637
6638 spin_lock(&nn->client_lock);
6639 clp = nfsd_find_client(addr, addr_size);
6640 if (clp)
6641 count = nfsd_find_all_delegations(clp, 0, &reaplist);
6642 spin_unlock(&nn->client_lock);
6643
6644 nfsd_recall_delegations(&reaplist);
6645 return count;
6646}
6647
6648u64
Jeff Layton285abde2014-07-30 08:27:24 -04006649nfsd_inject_recall_delegations(u64 max)
Jeff Layton98d5c7c2014-07-30 08:27:23 -04006650{
6651 u64 count = 0;
6652 struct nfs4_client *clp, *next;
6653 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6654 nfsd_net_id);
6655 LIST_HEAD(reaplist);
6656
6657 if (!nfsd_netns_ready(nn))
6658 return count;
6659
6660 spin_lock(&nn->client_lock);
6661 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
6662 count += nfsd_find_all_delegations(clp, max - count, &reaplist);
6663 if (max != 0 && ++count >= max)
6664 break;
6665 }
6666 spin_unlock(&nn->client_lock);
6667 nfsd_recall_delegations(&reaplist);
6668 return count;
6669}
Bryan Schumaker65178db2011-11-01 13:35:21 -04006670#endif /* CONFIG_NFSD_FAULT_INJECTION */
6671
Meelap Shahc2f1a552007-07-17 04:04:39 -07006672/*
6673 * Since the lifetime of a delegation isn't limited to that of an open, a
6674 * client may quite reasonably hang on to a delegation as long as it has
6675 * the inode cached. This becomes an obvious problem the first time a
6676 * client's inode cache approaches the size of the server's total memory.
6677 *
6678 * For now we avoid this problem by imposing a hard limit on the number
6679 * of delegations, which varies according to the server's memory size.
6680 */
6681static void
6682set_max_delegations(void)
6683{
6684 /*
6685 * Allow at most 4 delegations per megabyte of RAM. Quick
6686 * estimates suggest that in the worst case (where every delegation
6687 * is for a different inode), a delegation could take about 1.5K,
6688 * giving a worst case usage of about 6% of memory.
6689 */
6690 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
6691}
6692
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006693static int nfs4_state_create_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006694{
6695 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6696 int i;
6697
6698 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
6699 CLIENT_HASH_SIZE, GFP_KERNEL);
6700 if (!nn->conf_id_hashtbl)
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006701 goto err;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03006702 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
6703 CLIENT_HASH_SIZE, GFP_KERNEL);
6704 if (!nn->unconf_id_hashtbl)
6705 goto err_unconf_id;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03006706 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
6707 SESSION_HASH_SIZE, GFP_KERNEL);
6708 if (!nn->sessionid_hashtbl)
6709 goto err_sessionid;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006710
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006711 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006712 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03006713 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006714 }
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03006715 for (i = 0; i < SESSION_HASH_SIZE; i++)
6716 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006717 nn->conf_name_tree = RB_ROOT;
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03006718 nn->unconf_name_tree = RB_ROOT;
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03006719 INIT_LIST_HEAD(&nn->client_lru);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03006720 INIT_LIST_HEAD(&nn->close_lru);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04006721 INIT_LIST_HEAD(&nn->del_recall_lru);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03006722 spin_lock_init(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006723
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03006724 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006725 get_net(net);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03006726
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006727 return 0;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006728
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03006729err_sessionid:
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03006730 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03006731err_unconf_id:
6732 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03006733err:
6734 return -ENOMEM;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006735}
6736
6737static void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006738nfs4_state_destroy_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006739{
6740 int i;
6741 struct nfs4_client *clp = NULL;
6742 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6743
6744 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6745 while (!list_empty(&nn->conf_id_hashtbl[i])) {
6746 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
6747 destroy_client(clp);
6748 }
6749 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03006750
Kinglong Mee2b905632014-03-26 22:09:30 +08006751 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
6752 while (!list_empty(&nn->unconf_id_hashtbl[i])) {
6753 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
6754 destroy_client(clp);
6755 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03006756 }
6757
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03006758 kfree(nn->sessionid_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03006759 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006760 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006761 put_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006762}
6763
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03006764int
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006765nfs4_state_start_net(struct net *net)
NeilBrownac4d8ff22005-06-23 22:03:30 -07006766{
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04006767 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006768 int ret;
6769
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006770 ret = nfs4_state_create_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03006771 if (ret)
6772 return ret;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04006773 nn->boot_time = get_seconds();
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04006774 nn->grace_ended = false;
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -04006775 nn->nfsd4_manager.block_opens = true;
Jeff Laytond4318ac2014-09-12 16:40:21 -04006776 locks_start_grace(net, &nn->nfsd4_manager);
6777 nfsd4_client_tracking_init(net);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006778 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03006779 nn->nfsd4_grace, net);
6780 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006781 return 0;
6782}
6783
6784/* initialization to perform when the nfsd service is started: */
6785
6786int
6787nfs4_state_start(void)
6788{
6789 int ret;
6790
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006791 ret = set_callback_cred();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006792 if (ret)
6793 return -ENOMEM;
Jeff Layton51a54562015-08-20 07:17:01 -04006794 laundry_wq = alloc_workqueue("%s", WQ_UNBOUND, 0, "nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05006795 if (laundry_wq == NULL) {
6796 ret = -ENOMEM;
6797 goto out_recovery;
6798 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006799 ret = nfsd4_create_callback_queue();
6800 if (ret)
6801 goto out_free_laundry;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03006802
Meelap Shahc2f1a552007-07-17 04:04:39 -07006803 set_max_delegations();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006804
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006805 return 0;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03006806
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006807out_free_laundry:
6808 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05006809out_recovery:
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05006810 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006811}
6812
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03006813void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006814nfs4_state_shutdown_net(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006815{
Linus Torvalds1da177e2005-04-16 15:20:36 -07006816 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006817 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006818 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006819
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006820 cancel_delayed_work_sync(&nn->laundromat_work);
6821 locks_end_grace(&nn->nfsd4_manager);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05006822
Linus Torvalds1da177e2005-04-16 15:20:36 -07006823 INIT_LIST_HEAD(&reaplist);
Benny Halevycdc97502014-05-30 09:09:30 -04006824 spin_lock(&state_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04006825 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006826 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Jeff Layton3fcbbd22015-08-24 12:41:48 -04006827 WARN_ON(!unhash_delegation_locked(dp));
Jeff Layton42690672014-07-25 07:34:20 -04006828 list_add(&dp->dl_recall_lru, &reaplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006829 }
Benny Halevycdc97502014-05-30 09:09:30 -04006830 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006831 list_for_each_safe(pos, next, &reaplist) {
6832 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Jeff Layton42690672014-07-25 07:34:20 -04006833 list_del_init(&dp->dl_recall_lru);
Sachin Bhamare8287f002015-04-27 14:50:14 +02006834 put_clnt_odstate(dp->dl_clnt_odstate);
Jeff Laytonafbda402014-08-09 10:22:41 -04006835 nfs4_put_deleg_lease(dp->dl_stid.sc_file);
Trond Myklebust60116952014-07-29 21:34:06 -04006836 nfs4_put_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006837 }
6838
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03006839 nfsd4_client_tracking_exit(net);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03006840 nfs4_state_destroy_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006841}
6842
6843void
6844nfs4_state_shutdown(void)
6845{
NeilBrown5e8d5c22006-04-10 22:55:37 -07006846 destroy_workqueue(laundry_wq);
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04006847 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006848}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006849
6850static void
6851get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
6852{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01006853 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
6854 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006855}
6856
6857static void
6858put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
6859{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01006860 if (cstate->minorversion) {
6861 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
6862 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
6863 }
6864}
6865
6866void
6867clear_current_stateid(struct nfsd4_compound_state *cstate)
6868{
6869 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006870}
6871
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01006872/*
6873 * functions to set current state id
6874 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006875void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01006876nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
6877{
6878 put_stateid(cstate, &odp->od_stateid);
6879}
6880
6881void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006882nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
6883{
6884 put_stateid(cstate, &open->op_stateid);
6885}
6886
6887void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01006888nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
6889{
6890 put_stateid(cstate, &close->cl_stateid);
6891}
6892
6893void
6894nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
6895{
6896 put_stateid(cstate, &lock->lk_resp_stateid);
6897}
6898
6899/*
6900 * functions to consume current state id
6901 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01006902
6903void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01006904nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
6905{
6906 get_stateid(cstate, &odp->od_stateid);
6907}
6908
6909void
6910nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
6911{
6912 get_stateid(cstate, &drp->dr_stateid);
6913}
6914
6915void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01006916nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
6917{
6918 get_stateid(cstate, &fsp->fr_stateid);
6919}
6920
6921void
6922nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
6923{
6924 get_stateid(cstate, &setattr->sa_stateid);
6925}
6926
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01006927void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006928nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
6929{
6930 get_stateid(cstate, &close->cl_stateid);
6931}
6932
6933void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01006934nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006935{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01006936 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01006937}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01006938
6939void
6940nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
6941{
6942 get_stateid(cstate, &read->rd_stateid);
6943}
6944
6945void
6946nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
6947{
6948 get_stateid(cstate, &write->wr_stateid);
6949}