blob: c473bd6d52c819957bfecc5181d8b0330ee93891 [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>
NeilBrown6282cd52014-06-04 17:39:26 +100044#include <linux/hash.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"
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define NFSDDBG_FACILITY NFSDDBG_PROC
53
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050054#define all_ones {{~0,~0},~0}
55static const stateid_t one_stateid = {
56 .si_generation = ~0,
57 .si_opaque = all_ones,
58};
59static const stateid_t zero_stateid = {
60 /* all fields zero */
61};
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010062static const stateid_t currentstateid = {
63 .si_generation = 1,
64};
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050065
Andy Adamsonec6b5d72009-04-03 08:28:28 +030066static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070067
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050068#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
69#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010070#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/* forward declarations */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040073static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
J. Bruce Fields8b671b82009-02-22 14:51:34 -080075/* Locking: */
76
77/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080078static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
J. Bruce Fields8b671b82009-02-22 14:51:34 -080080/*
81 * Currently used for the del_recall_lru and file hash table. In an
82 * effort to decrease the scope of the client_mutex, this spinlock may
83 * eventually cover more:
84 */
Benny Halevycdc975052014-05-30 09:09:30 -040085static DEFINE_SPINLOCK(state_lock);
J. Bruce Fields8b671b82009-02-22 14:51:34 -080086
Christoph Hellwigabf11352014-05-21 07:43:03 -070087static struct kmem_cache *openowner_slab;
88static struct kmem_cache *lockowner_slab;
89static struct kmem_cache *file_slab;
90static struct kmem_cache *stateid_slab;
91static struct kmem_cache *deleg_slab;
NeilBrowne60d4392005-06-23 22:03:01 -070092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093void
94nfs4_lock_state(void)
95{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080096 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -040099static void free_session(struct nfsd4_session *);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800100
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400101static bool is_session_dead(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800102{
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400103 return ses->se_flags & NFS4_SESSION_DEAD;
104}
105
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -0400106void nfsd4_put_session(struct nfsd4_session *ses)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400107{
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -0400108 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
109 free_session(ses);
110}
111
112static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
113{
114 if (atomic_read(&ses->se_ref) > ref_held_by_me)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400115 return nfserr_jukebox;
116 ses->se_flags |= NFS4_SESSION_DEAD;
117 return nfs_ok;
118}
119
120static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
121{
122 if (is_session_dead(ses))
123 return nfserr_badsession;
124 atomic_inc(&ses->se_ref);
125 return nfs_ok;
Benny Halevy508dc6e2012-02-23 17:40:52 -0800126}
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128void
129nfs4_unlock_state(void)
130{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800131 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
J. Bruce Fields221a6872013-04-01 22:23:49 -0400134static bool is_client_expired(struct nfs4_client *clp)
135{
136 return clp->cl_time == 0;
137}
138
139static __be32 mark_client_expired_locked(struct nfs4_client *clp)
140{
141 if (atomic_read(&clp->cl_refcount))
142 return nfserr_jukebox;
143 clp->cl_time = 0;
144 return nfs_ok;
145}
146
147static __be32 mark_client_expired(struct nfs4_client *clp)
148{
149 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
150 __be32 ret;
151
152 spin_lock(&nn->client_lock);
153 ret = mark_client_expired_locked(clp);
154 spin_unlock(&nn->client_lock);
155 return ret;
156}
157
158static __be32 get_client_locked(struct nfs4_client *clp)
159{
160 if (is_client_expired(clp))
161 return nfserr_expired;
162 atomic_inc(&clp->cl_refcount);
163 return nfs_ok;
164}
165
166/* must be called under the client_lock */
167static inline void
168renew_client_locked(struct nfs4_client *clp)
169{
170 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
171
172 if (is_client_expired(clp)) {
173 WARN_ON(1);
174 printk("%s: client (clientid %08x/%08x) already expired\n",
175 __func__,
176 clp->cl_clientid.cl_boot,
177 clp->cl_clientid.cl_id);
178 return;
179 }
180
181 dprintk("renewing client (clientid %08x/%08x)\n",
182 clp->cl_clientid.cl_boot,
183 clp->cl_clientid.cl_id);
184 list_move_tail(&clp->cl_lru, &nn->client_lru);
185 clp->cl_time = get_seconds();
186}
187
188static inline void
189renew_client(struct nfs4_client *clp)
190{
191 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
192
193 spin_lock(&nn->client_lock);
194 renew_client_locked(clp);
195 spin_unlock(&nn->client_lock);
196}
197
Fengguang Wuba138432013-04-16 22:14:15 -0400198static void put_client_renew_locked(struct nfs4_client *clp)
J. Bruce Fields221a6872013-04-01 22:23:49 -0400199{
200 if (!atomic_dec_and_test(&clp->cl_refcount))
201 return;
202 if (!is_client_expired(clp))
203 renew_client_locked(clp);
204}
205
206void put_client_renew(struct nfs4_client *clp)
207{
208 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
209
210 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
211 return;
212 if (!is_client_expired(clp))
213 renew_client_locked(clp);
214 spin_unlock(&nn->client_lock);
215}
216
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218static inline u32
219opaque_hashval(const void *ptr, int nbytes)
220{
221 unsigned char *cptr = (unsigned char *) ptr;
222
223 u32 x = 0;
224 while (nbytes--) {
225 x *= 37;
226 x += *cptr++;
227 }
228 return x;
229}
230
J. Bruce Fields32513b42011-10-13 16:00:16 -0400231static void nfsd4_free_file(struct nfs4_file *f)
232{
233 kmem_cache_free(file_slab, f);
234}
235
NeilBrown13cd2182005-06-23 22:03:10 -0700236static inline void
237put_nfs4_file(struct nfs4_file *fi)
238{
Benny Halevycdc975052014-05-30 09:09:30 -0400239 if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) {
Jeff Layton89876f82013-04-02 09:01:59 -0400240 hlist_del(&fi->fi_hash);
Benny Halevycdc975052014-05-30 09:09:30 -0400241 spin_unlock(&state_lock);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800242 iput(fi->fi_inode);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400243 nfsd4_free_file(fi);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800244 }
NeilBrown13cd2182005-06-23 22:03:10 -0700245}
246
247static inline void
248get_nfs4_file(struct nfs4_file *fi)
249{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800250 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700251}
252
NeilBrownef0f3392006-04-10 22:55:41 -0700253static int num_delegations;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800254unsigned long max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700255
256/*
257 * Open owner state (share locks)
258 */
259
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500260/* hash tables for lock and open owners */
261#define OWNER_HASH_BITS 8
262#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
263#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700264
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500265static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400266{
267 unsigned int ret;
268
269 ret = opaque_hashval(ownername->data, ownername->len);
270 ret += clientid;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500271 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400272}
NeilBrownef0f3392006-04-10 22:55:41 -0700273
NeilBrownef0f3392006-04-10 22:55:41 -0700274/* hash table for nfs4_file */
275#define FILE_HASH_BITS 8
276#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800277
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400278static unsigned int file_hashval(struct inode *ino)
279{
280 /* XXX: why are we hashing on inode pointer, anyway? */
281 return hash_ptr(ino, FILE_HASH_BITS);
282}
283
Jeff Layton89876f82013-04-02 09:01:59 -0400284static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700285
J. Bruce Fields34775652013-08-23 17:55:18 -0400286static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
287{
288 WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
289 atomic_inc(&fp->fi_access[oflag]);
290}
291
J. Bruce Fields998db522010-08-07 09:21:41 -0400292static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
293{
294 if (oflag == O_RDWR) {
J. Bruce Fields34775652013-08-23 17:55:18 -0400295 __nfs4_file_get_access(fp, O_RDONLY);
296 __nfs4_file_get_access(fp, O_WRONLY);
J. Bruce Fields998db522010-08-07 09:21:41 -0400297 } else
J. Bruce Fields34775652013-08-23 17:55:18 -0400298 __nfs4_file_get_access(fp, oflag);
J. Bruce Fields998db522010-08-07 09:21:41 -0400299}
300
301static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400302{
303 if (fp->fi_fds[oflag]) {
304 fput(fp->fi_fds[oflag]);
305 fp->fi_fds[oflag] = NULL;
306 }
307}
308
J. Bruce Fields998db522010-08-07 09:21:41 -0400309static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400310{
311 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400312 nfs4_file_put_fd(fp, oflag);
J. Bruce Fields0c7c3e62013-03-28 20:37:14 -0400313 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
J. Bruce Fields3d02fa22011-09-19 15:07:41 -0400314 nfs4_file_put_fd(fp, O_RDWR);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400315 }
316}
317
J. Bruce Fields998db522010-08-07 09:21:41 -0400318static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
319{
320 if (oflag == O_RDWR) {
321 __nfs4_file_put_access(fp, O_RDONLY);
322 __nfs4_file_put_access(fp, O_WRONLY);
323 } else
324 __nfs4_file_put_access(fp, oflag);
325}
326
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500327static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
328kmem_cache *slab)
J. Bruce Fields996e0932011-10-17 11:14:48 -0400329{
330 struct idr *stateids = &cl->cl_stateids;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500331 struct nfs4_stid *stid;
332 int new_id;
333
334 stid = kmem_cache_alloc(slab, GFP_KERNEL);
335 if (!stid)
336 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400337
Jeff Layton398c33a2013-04-29 16:21:20 -0700338 new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
Tejun Heoebd6c702013-03-13 14:59:37 -0700339 if (new_id < 0)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500340 goto out_free;
341 stid->sc_client = cl;
342 stid->sc_type = 0;
343 stid->sc_stateid.si_opaque.so_id = new_id;
344 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
345 /* Will be incremented before return to client: */
346 stid->sc_stateid.si_generation = 0;
347
J. Bruce Fields996e0932011-10-17 11:14:48 -0400348 /*
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500349 * It shouldn't be a problem to reuse an opaque stateid value.
350 * I don't think it is for 4.1. But with 4.0 I worry that, for
351 * example, a stray write retransmission could be accepted by
352 * the server when it should have been rejected. Therefore,
353 * adopt a trick from the sctp code to attempt to maximize the
354 * amount of time until an id is reused, by ensuring they always
355 * "increase" (mod INT_MAX):
J. Bruce Fields996e0932011-10-17 11:14:48 -0400356 */
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500357 return stid;
358out_free:
Wei Yongjun2c44a232013-04-09 14:15:31 +0800359 kmem_cache_free(slab, stid);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500360 return NULL;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400361}
362
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400363static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
364{
365 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
366}
367
NeilBrown6282cd52014-06-04 17:39:26 +1000368/*
369 * When we recall a delegation, we should be careful not to hand it
370 * out again straight away.
371 * To ensure this we keep a pair of bloom filters ('new' and 'old')
372 * in which the filehandles of recalled delegations are "stored".
373 * If a filehandle appear in either filter, a delegation is blocked.
374 * When a delegation is recalled, the filehandle is stored in the "new"
375 * filter.
376 * Every 30 seconds we swap the filters and clear the "new" one,
377 * unless both are empty of course.
378 *
379 * Each filter is 256 bits. We hash the filehandle to 32bit and use the
380 * low 3 bytes as hash-table indices.
381 *
382 * 'state_lock', which is always held when block_delegations() is called,
383 * is used to manage concurrent access. Testing does not need the lock
384 * except when swapping the two filters.
385 */
386static struct bloom_pair {
387 int entries, old_entries;
388 time_t swap_time;
389 int new; /* index into 'set' */
390 DECLARE_BITMAP(set[2], 256);
391} blocked_delegations;
392
393static int delegation_blocked(struct knfsd_fh *fh)
394{
395 u32 hash;
396 struct bloom_pair *bd = &blocked_delegations;
397
398 if (bd->entries == 0)
399 return 0;
400 if (seconds_since_boot() - bd->swap_time > 30) {
401 spin_lock(&state_lock);
402 if (seconds_since_boot() - bd->swap_time > 30) {
403 bd->entries -= bd->old_entries;
404 bd->old_entries = bd->entries;
405 memset(bd->set[bd->new], 0,
406 sizeof(bd->set[0]));
407 bd->new = 1-bd->new;
408 bd->swap_time = seconds_since_boot();
409 }
410 spin_unlock(&state_lock);
411 }
412 hash = arch_fast_hash(&fh->fh_base, fh->fh_size, 0);
413 if (test_bit(hash&255, bd->set[0]) &&
414 test_bit((hash>>8)&255, bd->set[0]) &&
415 test_bit((hash>>16)&255, bd->set[0]))
416 return 1;
417
418 if (test_bit(hash&255, bd->set[1]) &&
419 test_bit((hash>>8)&255, bd->set[1]) &&
420 test_bit((hash>>16)&255, bd->set[1]))
421 return 1;
422
423 return 0;
424}
425
426static void block_delegations(struct knfsd_fh *fh)
427{
428 u32 hash;
429 struct bloom_pair *bd = &blocked_delegations;
430
431 hash = arch_fast_hash(&fh->fh_base, fh->fh_size, 0);
432
433 __set_bit(hash&255, bd->set[bd->new]);
434 __set_bit((hash>>8)&255, bd->set[bd->new]);
435 __set_bit((hash>>16)&255, bd->set[bd->new]);
436 if (bd->entries == 0)
437 bd->swap_time = seconds_since_boot();
438 bd->entries += 1;
439}
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441static struct nfs4_delegation *
J. Bruce Fields99c41512013-05-21 16:21:25 -0400442alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
444 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 dprintk("NFSD alloc_init_deleg\n");
Meelap Shahc2f1a552007-07-17 04:04:39 -0700447 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700448 return NULL;
NeilBrown6282cd52014-06-04 17:39:26 +1000449 if (delegation_blocked(&current_fh->fh_handle))
450 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400451 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700452 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return dp;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400454 /*
455 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400456 * meaning of seqid 0 isn't meaningful, really, but let's avoid
457 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400458 */
459 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownef0f3392006-04-10 22:55:41 -0700460 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700461 INIT_LIST_HEAD(&dp->dl_perfile);
462 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 INIT_LIST_HEAD(&dp->dl_recall_lru);
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -0400464 dp->dl_file = NULL;
J. Bruce Fields99c41512013-05-21 16:21:25 -0400465 dp->dl_type = NFS4_OPEN_DELEGATE_READ;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500466 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 dp->dl_time = 0;
468 atomic_set(&dp->dl_count, 1);
J. Bruce Fields57725152012-11-05 15:10:26 -0500469 nfsd4_init_callback(&dp->dl_recall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return dp;
471}
472
J. Bruce Fields68a33962013-03-21 11:21:50 -0400473static void remove_stid(struct nfs4_stid *s)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500474{
475 struct idr *stateids = &s->sc_client->cl_stateids;
476
477 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500478}
479
Benny Halevy9857df82013-10-14 13:44:52 +0300480static void nfs4_free_stid(struct kmem_cache *slab, struct nfs4_stid *s)
481{
482 kmem_cache_free(slab, s);
483}
484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485void
486nfs4_put_delegation(struct nfs4_delegation *dp)
487{
488 if (atomic_dec_and_test(&dp->dl_count)) {
Benny Halevy9857df82013-10-14 13:44:52 +0300489 nfs4_free_stid(deleg_slab, &dp->dl_stid);
NeilBrownef0f3392006-04-10 22:55:41 -0700490 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492}
493
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500494static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -0500496 if (!fp->fi_lease)
497 return;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500498 if (atomic_dec_and_test(&fp->fi_delegees)) {
499 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
500 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400501 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500502 fp->fi_deleg_file = NULL;
503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504}
505
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400506static void unhash_stid(struct nfs4_stid *s)
507{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500508 s->sc_type = 0;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400509}
510
Benny Halevy931ee562014-05-30 09:09:27 -0400511static void
512hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
513{
Benny Halevycdc975052014-05-30 09:09:30 -0400514 lockdep_assert_held(&state_lock);
Benny Halevy931ee562014-05-30 09:09:27 -0400515
Benny Halevy3fb87d12014-05-30 09:09:31 -0400516 dp->dl_stid.sc_type = NFS4_DELEG_STID;
Benny Halevy931ee562014-05-30 09:09:27 -0400517 list_add(&dp->dl_perfile, &fp->fi_delegations);
518 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
519}
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521/* Called under the state lock. */
522static void
523unhash_delegation(struct nfs4_delegation *dp)
524{
Benny Halevycdc975052014-05-30 09:09:30 -0400525 spin_lock(&state_lock);
Benny Halevy931ee562014-05-30 09:09:27 -0400526 list_del_init(&dp->dl_perclnt);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500527 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 list_del_init(&dp->dl_recall_lru);
Benny Halevycdc975052014-05-30 09:09:30 -0400529 spin_unlock(&state_lock);
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -0500530 if (dp->dl_file) {
531 nfs4_put_deleg_lease(dp->dl_file);
532 put_nfs4_file(dp->dl_file);
533 dp->dl_file = NULL;
534 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400535}
536
537
538
539static void destroy_revoked_delegation(struct nfs4_delegation *dp)
540{
541 list_del_init(&dp->dl_recall_lru);
J. Bruce Fields68a33962013-03-21 11:21:50 -0400542 remove_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 nfs4_put_delegation(dp);
544}
545
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400546static void destroy_delegation(struct nfs4_delegation *dp)
547{
548 unhash_delegation(dp);
549 remove_stid(&dp->dl_stid);
550 nfs4_put_delegation(dp);
551}
552
553static void revoke_delegation(struct nfs4_delegation *dp)
554{
555 struct nfs4_client *clp = dp->dl_stid.sc_client;
556
557 if (clp->cl_minorversion == 0)
558 destroy_delegation(dp);
559 else {
560 unhash_delegation(dp);
561 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
562 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
563 }
564}
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566/*
567 * SETCLIENTID state
568 */
569
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400570static unsigned int clientid_hashval(u32 id)
571{
572 return id & CLIENT_HASH_MASK;
573}
574
575static unsigned int clientstr_hashval(const char *name)
576{
577 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
578}
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580/*
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400581 * We store the NONE, READ, WRITE, and BOTH bits separately in the
582 * st_{access,deny}_bmap field of the stateid, in order to track not
583 * only what share bits are currently in force, but also what
584 * combinations of share bits previous opens have used. This allows us
585 * to enforce the recommendation of rfc 3530 14.2.19 that the server
586 * return an error if the client attempt to downgrade to a combination
587 * of share bits not explicable by closing some of its previous opens.
588 *
589 * XXX: This enforcement is actually incomplete, since we don't keep
590 * track of access/deny bit combinations; so, e.g., we allow:
591 *
592 * OPEN allow read, deny write
593 * OPEN allow both, deny none
594 * DOWNGRADE allow read, deny none
595 *
596 * which we should reject.
597 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400598static unsigned int
599bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400600 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400601 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400602
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400603 for (i = 1; i < 4; i++) {
604 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400605 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400606 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400607 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400608}
609
Jeff Layton3a328612012-05-11 09:45:12 -0400610static bool
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400611test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400612 unsigned int access, deny;
613
Jeff Layton5ae037e2012-05-11 09:45:11 -0400614 access = bmap_to_share_mode(stp->st_access_bmap);
615 deny = bmap_to_share_mode(stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400616 if ((access & open->op_share_deny) || (deny & open->op_share_access))
Jeff Layton3a328612012-05-11 09:45:12 -0400617 return false;
618 return true;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400619}
620
Jeff Layton82c5ff12012-05-11 09:45:13 -0400621/* set share access for a given stateid */
622static inline void
623set_access(u32 access, struct nfs4_ol_stateid *stp)
624{
625 __set_bit(access, &stp->st_access_bmap);
626}
627
628/* clear share access for a given stateid */
629static inline void
630clear_access(u32 access, struct nfs4_ol_stateid *stp)
631{
632 __clear_bit(access, &stp->st_access_bmap);
633}
634
635/* test whether a given stateid has access */
636static inline bool
637test_access(u32 access, struct nfs4_ol_stateid *stp)
638{
639 return test_bit(access, &stp->st_access_bmap);
640}
641
Jeff Laytonce0fc432012-05-11 09:45:14 -0400642/* set share deny for a given stateid */
643static inline void
644set_deny(u32 access, struct nfs4_ol_stateid *stp)
645{
646 __set_bit(access, &stp->st_deny_bmap);
647}
648
649/* clear share deny for a given stateid */
650static inline void
651clear_deny(u32 access, struct nfs4_ol_stateid *stp)
652{
653 __clear_bit(access, &stp->st_deny_bmap);
654}
655
656/* test whether a given stateid is denying specific access */
657static inline bool
658test_deny(u32 access, struct nfs4_ol_stateid *stp)
659{
660 return test_bit(access, &stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400661}
662
663static int nfs4_access_to_omode(u32 access)
664{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400665 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400666 case NFS4_SHARE_ACCESS_READ:
667 return O_RDONLY;
668 case NFS4_SHARE_ACCESS_WRITE:
669 return O_WRONLY;
670 case NFS4_SHARE_ACCESS_BOTH:
671 return O_RDWR;
672 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500673 WARN_ON_ONCE(1);
674 return O_RDONLY;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400675}
676
Jeff Layton82c5ff12012-05-11 09:45:13 -0400677/* release all access and file references for a given stateid */
678static void
679release_all_access(struct nfs4_ol_stateid *stp)
680{
681 int i;
682
683 for (i = 1; i < 4; i++) {
684 if (test_access(i, stp))
685 nfs4_file_put_access(stp->st_file,
686 nfs4_access_to_omode(i));
687 clear_access(i, stp);
688 }
689}
690
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400691static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500692{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500693 list_del(&stp->st_perfile);
694 list_del(&stp->st_perstateowner);
695}
696
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400697static void close_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500698{
Jeff Layton82c5ff12012-05-11 09:45:13 -0400699 release_all_access(stp);
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400700 put_nfs4_file(stp->st_file);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400701 stp->st_file = NULL;
702}
703
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400704static void free_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400705{
J. Bruce Fields68a33962013-03-21 11:21:50 -0400706 remove_stid(&stp->st_stid);
Benny Halevy9857df82013-10-14 13:44:52 +0300707 nfs4_free_stid(stateid_slab, &stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500708}
709
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400710static void release_lock_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500711{
712 struct file *file;
713
714 unhash_generic_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400715 unhash_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500716 file = find_any_file(stp->st_file);
717 if (file)
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400718 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400719 close_generic_stateid(stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500720 free_generic_stateid(stp);
721}
722
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400723static void unhash_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500724{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400725 struct nfs4_ol_stateid *stp;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500726
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400727 list_del(&lo->lo_owner.so_strhash);
728 list_del(&lo->lo_perstateid);
J. Bruce Fields009673b2011-11-07 17:40:10 -0500729 list_del(&lo->lo_owner_ino_hash);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400730 while (!list_empty(&lo->lo_owner.so_stateids)) {
731 stp = list_first_entry(&lo->lo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400732 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500733 release_lock_stateid(stp);
734 }
735}
736
Trond Myklebust50cc6232014-04-18 14:44:03 -0400737static void nfs4_free_lockowner(struct nfs4_lockowner *lo)
738{
739 kfree(lo->lo_owner.so_owner.data);
740 kmem_cache_free(lockowner_slab, lo);
741}
742
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400743static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500744{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400745 unhash_lockowner(lo);
746 nfs4_free_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500747}
748
749static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400750release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500751{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400752 struct nfs4_lockowner *lo;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500753
754 while (!list_empty(&open_stp->st_lockowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400755 lo = list_entry(open_stp->st_lockowners.next,
756 struct nfs4_lockowner, lo_perstateid);
757 release_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500758 }
759}
760
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400761static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields22839632009-01-11 14:27:17 -0500762{
763 unhash_generic_stateid(stp);
764 release_stateid_lockowners(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400765 close_generic_stateid(stp);
766}
767
768static void release_open_stateid(struct nfs4_ol_stateid *stp)
769{
770 unhash_open_stateid(stp);
J. Bruce Fields22839632009-01-11 14:27:17 -0500771 free_generic_stateid(stp);
772}
773
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400774static void unhash_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500775{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400776 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500777
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400778 list_del(&oo->oo_owner.so_strhash);
779 list_del(&oo->oo_perclient);
780 while (!list_empty(&oo->oo_owner.so_stateids)) {
781 stp = list_first_entry(&oo->oo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400782 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500783 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500784 }
785}
786
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400787static void release_last_closed_stateid(struct nfs4_openowner *oo)
788{
789 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
790
791 if (s) {
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400792 free_generic_stateid(s);
793 oo->oo_last_closed_stid = NULL;
794 }
795}
796
Trond Myklebust50cc6232014-04-18 14:44:03 -0400797static void nfs4_free_openowner(struct nfs4_openowner *oo)
798{
799 kfree(oo->oo_owner.so_owner.data);
800 kmem_cache_free(openowner_slab, oo);
801}
802
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400803static void release_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500804{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400805 unhash_openowner(oo);
806 list_del(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400807 release_last_closed_stateid(oo);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400808 nfs4_free_openowner(oo);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500809}
810
Marc Eshel5282fd72009-04-03 08:27:52 +0300811static inline int
812hash_sessionid(struct nfs4_sessionid *sessionid)
813{
814 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
815
816 return sid->sequence % SESSION_HASH_SIZE;
817}
818
Trond Myklebust8f199b82012-03-20 15:11:17 -0400819#ifdef NFSD_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +0300820static inline void
821dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
822{
823 u32 *ptr = (u32 *)(&sessionid->data[0]);
824 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
825}
Trond Myklebust8f199b82012-03-20 15:11:17 -0400826#else
827static inline void
828dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
829{
830}
831#endif
832
J. Bruce Fields9411b1d2013-04-01 16:37:12 -0400833/*
834 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
835 * won't be used for replay.
836 */
837void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
838{
839 struct nfs4_stateowner *so = cstate->replay_owner;
840
841 if (nfserr == nfserr_replay_me)
842 return;
843
844 if (!seqid_mutating_err(ntohl(nfserr))) {
845 cstate->replay_owner = NULL;
846 return;
847 }
848 if (!so)
849 return;
850 if (so->so_is_open_owner)
851 release_last_closed_stateid(openowner(so));
852 so->so_seqid++;
853 return;
854}
Marc Eshel5282fd72009-04-03 08:27:52 +0300855
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300856static void
857gen_sessionid(struct nfsd4_session *ses)
858{
859 struct nfs4_client *clp = ses->se_client;
860 struct nfsd4_sessionid *sid;
861
862 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
863 sid->clientid = clp->cl_clientid;
864 sid->sequence = current_sessionid++;
865 sid->reserved = 0;
866}
867
868/*
Andy Adamsona649637c72009-08-28 08:45:01 -0400869 * The protocol defines ca_maxresponssize_cached to include the size of
870 * the rpc header, but all we need to cache is the data starting after
871 * the end of the initial SEQUENCE operation--the rest we regenerate
872 * each time. Therefore we can advertise a ca_maxresponssize_cached
873 * value that is the number of bytes in our cache plus a few additional
874 * bytes. In order to stay on the safe side, and not promise more than
875 * we can cache, those additional bytes must be the minimum possible: 24
876 * bytes of rpc header (xid through accept state, with AUTH_NULL
877 * verifier), 12 for the compound header (with zero-length tag), and 44
878 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300879 */
Andy Adamsona649637c72009-08-28 08:45:01 -0400880#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
881
Andy Adamson557ce262009-08-28 08:45:04 -0400882static void
883free_session_slots(struct nfsd4_session *ses)
884{
885 int i;
886
887 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
888 kfree(ses->se_slots[i]);
889}
890
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400891/*
892 * We don't actually need to cache the rpc and session headers, so we
893 * can allocate a little less for each slot:
894 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400895static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400896{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400897 u32 size;
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400898
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400899 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
900 size = 0;
901 else
902 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
903 return size + sizeof(struct nfsd4_slot);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400904}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300905
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400906/*
907 * XXX: If we run out of reserved DRC memory we could (up to a point)
908 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800909 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400910 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400911static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400912{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400913 u32 slotsize = slot_bytes(ca);
914 u32 num = ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400915 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300916
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400917 spin_lock(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800918 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
919 nfsd_drc_max_mem - nfsd_drc_mem_used);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400920 num = min_t(int, num, avail / slotsize);
921 nfsd_drc_mem_used += num * slotsize;
922 spin_unlock(&nfsd_drc_lock);
923
924 return num;
925}
926
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400927static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400928{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400929 int slotsize = slot_bytes(ca);
930
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400931 spin_lock(&nfsd_drc_lock);
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400932 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400933 spin_unlock(&nfsd_drc_lock);
934}
935
Kinglong Mee60810e52014-01-01 00:35:47 +0800936static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
937 struct nfsd4_channel_attrs *battrs)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400938{
Kinglong Mee60810e52014-01-01 00:35:47 +0800939 int numslots = fattrs->maxreqs;
940 int slotsize = slot_bytes(fattrs);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400941 struct nfsd4_session *new;
942 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300943
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400944 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400945 + sizeof(struct nfsd4_session) > PAGE_SIZE);
946 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400947
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400948 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300949 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400950 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400951 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400952 for (i = 0; i < numslots; i++) {
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400953 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400954 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400955 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400956 }
Kinglong Mee60810e52014-01-01 00:35:47 +0800957
958 memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
959 memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
960
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400961 return new;
962out_free:
963 while (i--)
964 kfree(new->se_slots[i]);
965 kfree(new);
966 return NULL;
967}
968
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400969static void free_conn(struct nfsd4_conn *c)
970{
971 svc_xprt_put(c->cn_xprt);
972 kfree(c);
973}
974
975static void nfsd4_conn_lost(struct svc_xpt_user *u)
976{
977 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
978 struct nfs4_client *clp = c->cn_session->se_client;
979
980 spin_lock(&clp->cl_lock);
981 if (!list_empty(&c->cn_persession)) {
982 list_del(&c->cn_persession);
983 free_conn(c);
984 }
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500985 nfsd4_probe_callback(clp);
J. Bruce Fields2e4b7232013-03-08 09:30:43 -0500986 spin_unlock(&clp->cl_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400987}
988
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400989static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400990{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400991 struct nfsd4_conn *conn;
992
993 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
994 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400995 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400996 svc_xprt_get(rqstp->rq_xprt);
997 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400998 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400999 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1000 return conn;
1001}
1002
J. Bruce Fields328ead22010-09-29 16:11:06 -04001003static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1004{
1005 conn->cn_session = ses;
1006 list_add(&conn->cn_persession, &ses->se_conns);
1007}
1008
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001009static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1010{
1011 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001012
1013 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001014 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001015 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001016}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001017
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001018static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001019{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001020 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001021 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001022}
1023
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001024static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001025{
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001026 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001027
J. Bruce Fieldsdb906812010-09-29 15:29:32 -04001028 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001029 ret = nfsd4_register_conn(conn);
1030 if (ret)
1031 /* oops; xprt is already down: */
1032 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fields6a3b1562012-09-12 09:59:17 -04001033 if (conn->cn_flags & NFS4_CDFC4_BACK) {
Weston Andros Adamson24119672012-05-24 15:42:17 -04001034 /* callback channel may be back up */
1035 nfsd4_probe_callback(ses->se_client);
1036 }
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001037}
1038
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001039static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001040{
1041 u32 dir = NFS4_CDFC4_FORE;
1042
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001043 if (cses->flags & SESSION4_BACK_CHAN)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001044 dir |= NFS4_CDFC4_BACK;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001045 return alloc_conn(rqstp, dir);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001046}
1047
1048/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001049static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001050{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001051 struct nfs4_client *clp = s->se_client;
1052 struct nfsd4_conn *c;
1053
1054 spin_lock(&clp->cl_lock);
1055 while (!list_empty(&s->se_conns)) {
1056 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1057 list_del_init(&c->cn_persession);
1058 spin_unlock(&clp->cl_lock);
1059
1060 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1061 free_conn(c);
1062
1063 spin_lock(&clp->cl_lock);
1064 }
1065 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001066}
1067
J. Bruce Fields1377b692012-09-11 21:42:40 -04001068static void __free_session(struct nfsd4_session *ses)
1069{
J. Bruce Fields1377b692012-09-11 21:42:40 -04001070 free_session_slots(ses);
1071 kfree(ses);
1072}
1073
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001074static void free_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -08001075{
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001076 struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
1077
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001078 lockdep_assert_held(&nn->client_lock);
1079 nfsd4_del_conns(ses);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001080 nfsd4_put_drc_mem(&ses->se_fchannel);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001081 __free_session(ses);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001082}
Andy Adamson557ce262009-08-28 08:45:04 -04001083
Fengguang Wu135ae822012-11-10 07:20:25 -05001084static 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 -04001085{
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001086 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001087 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -04001088
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001089 new->se_client = clp;
1090 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001091
J. Bruce Fieldsc7662512010-06-06 18:12:14 -04001092 INIT_LIST_HEAD(&new->se_conns);
1093
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04001094 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001095 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -04001096 new->se_cb_prog = cses->callback_prog;
J. Bruce Fieldsc6bb3ca2012-11-01 16:31:02 -04001097 new->se_cb_sec = cses->cb_sec;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001098 atomic_set(&new->se_ref, 0);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001099 idx = hash_sessionid(&new->se_sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001100 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001101 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001102 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001103 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001104 spin_unlock(&clp->cl_lock);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001105 spin_unlock(&nn->client_lock);
Kinglong Mee60810e52014-01-01 00:35:47 +08001106
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001107 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001108 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001109 /*
1110 * This is a little silly; with sessions there's no real
1111 * use for the callback address. Use the peer address
1112 * as a reasonable default for now, but consider fixing
1113 * the rpc client not to require an address in the
1114 * future:
1115 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001116 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1117 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001118 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001119}
1120
Benny Halevy9089f1b2010-05-12 00:12:26 +03001121/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +03001122static struct nfsd4_session *
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001123find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
Marc Eshel5282fd72009-04-03 08:27:52 +03001124{
1125 struct nfsd4_session *elem;
1126 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001127 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Marc Eshel5282fd72009-04-03 08:27:52 +03001128
1129 dump_sessionid(__func__, sessionid);
1130 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +03001131 /* Search in the appropriate list */
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001132 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +03001133 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1134 NFS4_MAX_SESSIONID_LEN)) {
1135 return elem;
1136 }
1137 }
1138
1139 dprintk("%s: session not found\n", __func__);
1140 return NULL;
1141}
1142
Benny Halevy9089f1b2010-05-12 00:12:26 +03001143/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +03001144static void
Marc Eshel5282fd72009-04-03 08:27:52 +03001145unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +03001146{
1147 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001148 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +03001149 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001150 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +03001151}
1152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1154static int
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001155STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156{
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001157 if (clid->cl_boot == nn->boot_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001159 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001160 clid->cl_boot, clid->cl_id, nn->boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 return 1;
1162}
1163
1164/*
1165 * XXX Should we use a slab cache ?
1166 * This type of memory management is somewhat inefficient, but we use it
1167 * anyway since SETCLIENTID is not a common operation.
1168 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001169static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170{
1171 struct nfs4_client *clp;
1172
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001173 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1174 if (clp == NULL)
1175 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001176 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001177 if (clp->cl_name.data == NULL) {
1178 kfree(clp);
1179 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001181 clp->cl_name.len = name.len;
Trond Myklebust5694c932014-04-18 14:43:56 -04001182 INIT_LIST_HEAD(&clp->cl_sessions);
1183 idr_init(&clp->cl_stateids);
1184 atomic_set(&clp->cl_refcount, 0);
1185 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1186 INIT_LIST_HEAD(&clp->cl_idhash);
1187 INIT_LIST_HEAD(&clp->cl_openowners);
1188 INIT_LIST_HEAD(&clp->cl_delegations);
1189 INIT_LIST_HEAD(&clp->cl_lru);
1190 INIT_LIST_HEAD(&clp->cl_callbacks);
1191 INIT_LIST_HEAD(&clp->cl_revoked);
1192 spin_lock_init(&clp->cl_lock);
1193 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 return clp;
1195}
1196
Trond Myklebust4dd86e152014-04-18 14:43:58 -04001197static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198free_client(struct nfs4_client *clp)
1199{
Stanislav Kinsburskybca0ec62013-01-09 12:38:34 +03001200 struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001201
1202 lockdep_assert_held(&nn->client_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001203 while (!list_empty(&clp->cl_sessions)) {
1204 struct nfsd4_session *ses;
1205 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1206 se_perclnt);
1207 list_del(&ses->se_perclnt);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001208 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1209 free_session(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001210 }
Trond Myklebust4cb57e32014-04-18 14:43:57 -04001211 rpc_destroy_wait_queue(&clp->cl_cb_waitq);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001212 free_svc_cred(&clp->cl_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 kfree(clp->cl_name.data);
majianpeng2d32b292013-01-29 13:16:06 +08001214 idr_destroy(&clp->cl_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 kfree(clp);
1216}
1217
Benny Halevy84d38ac2010-05-12 00:13:16 +03001218/* must be called under the client_lock */
1219static inline void
1220unhash_client_locked(struct nfs4_client *clp)
1221{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001222 struct nfsd4_session *ses;
1223
Benny Halevy84d38ac2010-05-12 00:13:16 +03001224 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001225 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001226 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1227 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001228 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001229}
1230
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231static void
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001232destroy_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001234 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 struct list_head reaplist;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001237 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 INIT_LIST_HEAD(&reaplist);
Benny Halevycdc975052014-05-30 09:09:30 -04001240 spin_lock(&state_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001241 while (!list_empty(&clp->cl_delegations)) {
1242 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -07001243 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 list_move(&dp->dl_recall_lru, &reaplist);
1245 }
Benny Halevycdc975052014-05-30 09:09:30 -04001246 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 while (!list_empty(&reaplist)) {
1248 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04001249 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 }
Benny Halevy956c4fe2013-10-29 11:39:12 +02001251 list_splice_init(&clp->cl_revoked, &reaplist);
1252 while (!list_empty(&reaplist)) {
1253 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1254 destroy_revoked_delegation(dp);
1255 }
NeilBrownea1da632005-06-23 22:04:17 -07001256 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001257 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1258 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001260 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001261 if (clp->cl_cb_conn.cb_xprt)
1262 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001263 list_del(&clp->cl_idhash);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001264 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001265 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001266 else
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001267 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001268 spin_lock(&nn->client_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001269 unhash_client_locked(clp);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001270 WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
1271 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001272 spin_unlock(&nn->client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001275static void expire_client(struct nfs4_client *clp)
1276{
1277 nfsd4_client_record_remove(clp);
1278 destroy_client(clp);
1279}
1280
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001281static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1282{
1283 memcpy(target->cl_verifier.data, source->data,
1284 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285}
1286
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001287static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1288{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1290 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1291}
1292
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001293static int copy_cred(struct svc_cred *target, struct svc_cred *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001294{
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001295 if (source->cr_principal) {
1296 target->cr_principal =
1297 kstrdup(source->cr_principal, GFP_KERNEL);
1298 if (target->cr_principal == NULL)
1299 return -ENOMEM;
1300 } else
1301 target->cr_principal = NULL;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001302 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 target->cr_uid = source->cr_uid;
1304 target->cr_gid = source->cr_gid;
1305 target->cr_group_info = source->cr_group_info;
1306 get_group_info(target->cr_group_info);
J. Bruce Fields0dc15312013-05-14 16:07:13 -04001307 target->cr_gss_mech = source->cr_gss_mech;
1308 if (source->cr_gss_mech)
1309 gss_mech_get(source->cr_gss_mech);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001310 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311}
1312
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001313static long long
1314compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1315{
1316 long long res;
1317
1318 res = o1->len - o2->len;
1319 if (res)
1320 return res;
1321 return (long long)memcmp(o1->data, o2->data, o1->len);
1322}
1323
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001324static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001325{
NeilBrowna55370a2005-06-23 22:03:52 -07001326 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327}
1328
1329static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001330same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1331{
1332 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333}
1334
1335static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001336same_clid(clientid_t *cl1, clientid_t *cl2)
1337{
1338 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339}
1340
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001341static bool groups_equal(struct group_info *g1, struct group_info *g2)
1342{
1343 int i;
1344
1345 if (g1->ngroups != g2->ngroups)
1346 return false;
1347 for (i=0; i<g1->ngroups; i++)
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001348 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001349 return false;
1350 return true;
1351}
1352
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001353/*
1354 * RFC 3530 language requires clid_inuse be returned when the
1355 * "principal" associated with a requests differs from that previously
1356 * used. We use uid, gid's, and gss principal string as our best
1357 * approximation. We also don't want to allow non-gss use of a client
1358 * established using gss: in theory cr_principal should catch that
1359 * change, but in practice cr_principal can be null even in the gss case
1360 * since gssd doesn't always pass down a principal string.
1361 */
1362static bool is_gss_cred(struct svc_cred *cr)
1363{
1364 /* Is cr_flavor one of the gss "pseudoflavors"?: */
1365 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1366}
1367
1368
Vivek Trivedi5559b502012-07-24 21:18:20 +05301369static bool
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001370same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1371{
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001372 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001373 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1374 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001375 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1376 return false;
1377 if (cr1->cr_principal == cr2->cr_principal)
1378 return true;
1379 if (!cr1->cr_principal || !cr2->cr_principal)
1380 return false;
Vivek Trivedi5559b502012-07-24 21:18:20 +05301381 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382}
1383
J. Bruce Fields57266a62013-04-13 14:27:29 -04001384static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
1385{
1386 struct svc_cred *cr = &rqstp->rq_cred;
1387 u32 service;
1388
J. Bruce Fieldsc4720592013-08-07 11:41:49 -04001389 if (!cr->cr_gss_mech)
1390 return false;
J. Bruce Fields57266a62013-04-13 14:27:29 -04001391 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
1392 return service == RPC_GSS_SVC_INTEGRITY ||
1393 service == RPC_GSS_SVC_PRIVACY;
1394}
1395
1396static bool mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
1397{
1398 struct svc_cred *cr = &rqstp->rq_cred;
1399
1400 if (!cl->cl_mach_cred)
1401 return true;
1402 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
1403 return false;
1404 if (!svc_rqst_integrity_protected(rqstp))
1405 return false;
1406 if (!cr->cr_principal)
1407 return false;
1408 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
1409}
1410
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001411static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001412{
1413 static u32 current_clientid = 1;
1414
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001415 clp->cl_clientid.cl_boot = nn->boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 clp->cl_clientid.cl_id = current_clientid++;
1417}
1418
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001419static void gen_confirm(struct nfs4_client *clp)
1420{
Chuck Leverab4684d2012-03-02 17:13:50 -05001421 __be32 verf[2];
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001422 static u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
Jeff Laytonf4199922014-06-17 07:44:11 -04001424 /*
1425 * This is opaque to client, so no need to byte-swap. Use
1426 * __force to keep sparse happy
1427 */
1428 verf[0] = (__force __be32)get_seconds();
1429 verf[1] = (__force __be32)i++;
Chuck Leverab4684d2012-03-02 17:13:50 -05001430 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431}
1432
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001433static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
J. Bruce Fields4581d142011-09-06 14:56:09 -04001434{
J. Bruce Fields3abdb602013-02-03 12:23:01 -05001435 struct nfs4_stid *ret;
1436
1437 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1438 if (!ret || !ret->sc_type)
1439 return NULL;
1440 return ret;
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001441}
1442
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001443static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001444{
1445 struct nfs4_stid *s;
1446
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001447 s = find_stateid(cl, t);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001448 if (!s)
1449 return NULL;
1450 if (typemask & s->sc_type)
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001451 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04001452 return NULL;
1453}
1454
Jeff Layton2216d442012-11-12 15:00:57 -05001455static struct nfs4_client *create_client(struct xdr_netobj name,
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001456 struct svc_rqst *rqstp, nfs4_verifier *verf)
1457{
1458 struct nfs4_client *clp;
1459 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001460 int ret;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001461 struct net *net = SVC_NET(rqstp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001462 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001463
1464 clp = alloc_client(name);
1465 if (clp == NULL)
1466 return NULL;
1467
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001468 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1469 if (ret) {
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001470 spin_lock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001471 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001472 spin_unlock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001473 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001474 }
J. Bruce Fields57725152012-11-05 15:10:26 -05001475 nfsd4_init_callback(&clp->cl_cb_null);
Benny Halevy07cd4902010-05-12 00:13:41 +03001476 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001477 clear_bit(0, &clp->cl_cb_slot_busy);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001478 copy_verf(clp, verf);
1479 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001480 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001481 clp->cl_cb_session = NULL;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001482 clp->net = net;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001483 return clp;
1484}
1485
NeilBrownfd39ca92005-06-23 22:04:03 -07001486static void
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001487add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1488{
1489 struct rb_node **new = &(root->rb_node), *parent = NULL;
1490 struct nfs4_client *clp;
1491
1492 while (*new) {
1493 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1494 parent = *new;
1495
1496 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1497 new = &((*new)->rb_left);
1498 else
1499 new = &((*new)->rb_right);
1500 }
1501
1502 rb_link_node(&new_clp->cl_namenode, parent, new);
1503 rb_insert_color(&new_clp->cl_namenode, root);
1504}
1505
1506static struct nfs4_client *
1507find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1508{
1509 long long cmp;
1510 struct rb_node *node = root->rb_node;
1511 struct nfs4_client *clp;
1512
1513 while (node) {
1514 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1515 cmp = compare_blob(&clp->cl_name, name);
1516 if (cmp > 0)
1517 node = node->rb_left;
1518 else if (cmp < 0)
1519 node = node->rb_right;
1520 else
1521 return clp;
1522 }
1523 return NULL;
1524}
1525
1526static void
1527add_to_unconfirmed(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
1529 unsigned int idhashval;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001530 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001532 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001533 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001535 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001536 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537}
1538
NeilBrownfd39ca92005-06-23 22:04:03 -07001539static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540move_to_confirmed(struct nfs4_client *clp)
1541{
1542 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001543 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544
1545 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001546 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001547 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001548 add_clp_to_name_tree(clp, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001549 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 renew_client(clp);
1551}
1552
1553static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001554find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555{
1556 struct nfs4_client *clp;
1557 unsigned int idhashval = clientid_hashval(clid->cl_id);
1558
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001559 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001560 if (same_clid(&clp->cl_clientid, clid)) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001561 if ((bool)clp->cl_minorversion != sessions)
1562 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001563 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 }
1567 return NULL;
1568}
1569
1570static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001571find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1572{
1573 struct list_head *tbl = nn->conf_id_hashtbl;
1574
1575 return find_client_in_id_table(tbl, clid, sessions);
1576}
1577
1578static struct nfs4_client *
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001579find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580{
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001581 struct list_head *tbl = nn->unconf_id_hashtbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001583 return find_client_in_id_table(tbl, clid, sessions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584}
1585
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001586static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001587{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001588 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001589}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001590
NeilBrown28ce6052005-06-23 22:03:56 -07001591static struct nfs4_client *
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001592find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001593{
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001594 return find_clp_in_name_tree(name, &nn->conf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001595}
1596
1597static struct nfs4_client *
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001598find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001599{
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001600 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001601}
1602
NeilBrownfd39ca92005-06-23 22:04:03 -07001603static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001604gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001606 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001607 struct sockaddr *sa = svc_addr(rqstp);
1608 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001609 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
Jeff Layton7077ecb2009-08-14 12:57:58 -04001611 /* Currently, we only support tcp and tcp6 for the callback channel */
1612 if (se->se_callback_netid_len == 3 &&
1613 !memcmp(se->se_callback_netid_val, "tcp", 3))
1614 expected_family = AF_INET;
1615 else if (se->se_callback_netid_len == 4 &&
1616 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1617 expected_family = AF_INET6;
1618 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 goto out_err;
1620
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001621 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001622 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001623 (struct sockaddr *)&conn->cb_addr,
1624 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001625
J. Bruce Fields07263f12010-05-31 19:09:40 -04001626 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001628
J. Bruce Fields07263f12010-05-31 19:09:40 -04001629 if (conn->cb_addr.ss_family == AF_INET6)
1630 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001631
J. Bruce Fields07263f12010-05-31 19:09:40 -04001632 conn->cb_prog = se->se_callback_prog;
1633 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08001634 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 return;
1636out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001637 conn->cb_addr.ss_family = AF_UNSPEC;
1638 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001639 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 "will not receive delegations\n",
1641 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 return;
1644}
1645
Andy Adamson074fe892009-04-03 08:28:15 +03001646/*
J. Bruce Fields067e1ac2014-03-21 17:26:44 -04001647 * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001648 */
1649void
1650nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1651{
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04001652 struct xdr_buf *buf = resp->xdr.buf;
Andy Adamson557ce262009-08-28 08:45:04 -04001653 struct nfsd4_slot *slot = resp->cstate.slot;
1654 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001655
Andy Adamson557ce262009-08-28 08:45:04 -04001656 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001657
Andy Adamson557ce262009-08-28 08:45:04 -04001658 slot->sl_opcnt = resp->opcnt;
1659 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001660
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05001661 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001662 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001663 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001664 return;
1665 }
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04001666 base = resp->cstate.data_offset;
1667 slot->sl_datalen = buf->len - base;
1668 if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
Andy Adamson557ce262009-08-28 08:45:04 -04001669 WARN("%s: sessions DRC could not cache compound\n", __func__);
1670 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001671}
1672
1673/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001674 * Encode the replay sequence operation from the slot values.
1675 * If cachethis is FALSE encode the uncached rep error on the next
1676 * operation which sets resp->p and increments resp->opcnt for
1677 * nfs4svc_encode_compoundres.
1678 *
Andy Adamson074fe892009-04-03 08:28:15 +03001679 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001680static __be32
1681nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1682 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001683{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001684 struct nfsd4_op *op;
1685 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001686
Andy Adamsonabfabf82009-07-23 19:02:18 -04001687 /* Encode the replayed sequence operation */
1688 op = &args->ops[resp->opcnt - 1];
1689 nfsd4_encode_operation(resp, op);
1690
1691 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05001692 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001693 op = &args->ops[resp->opcnt++];
1694 op->status = nfserr_retry_uncached_rep;
1695 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001696 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001697 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001698}
1699
1700/*
Andy Adamson557ce262009-08-28 08:45:04 -04001701 * The sequence operation is not cached because we can use the slot and
1702 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001703 */
J. Bruce Fields3ca2eb92014-03-21 12:04:21 -04001704static __be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001705nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1706 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001707{
Andy Adamson557ce262009-08-28 08:45:04 -04001708 struct nfsd4_slot *slot = resp->cstate.slot;
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04001709 struct xdr_stream *xdr = &resp->xdr;
1710 __be32 *p;
Andy Adamson074fe892009-04-03 08:28:15 +03001711 __be32 status;
1712
Andy Adamson557ce262009-08-28 08:45:04 -04001713 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001714
Andy Adamsonabfabf82009-07-23 19:02:18 -04001715 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
J. Bruce Fields0da7b192014-03-21 11:43:34 -04001716 if (status)
Andy Adamsonabfabf82009-07-23 19:02:18 -04001717 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001718
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04001719 p = xdr_reserve_space(xdr, slot->sl_datalen);
1720 if (!p) {
1721 WARN_ON_ONCE(1);
1722 return nfserr_serverfault;
1723 }
1724 xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
1725 xdr_commit_encode(xdr);
Andy Adamson074fe892009-04-03 08:28:15 +03001726
Andy Adamson557ce262009-08-28 08:45:04 -04001727 resp->opcnt = slot->sl_opcnt;
J. Bruce Fieldsf5236012014-03-21 17:57:57 -04001728 return slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001729}
1730
Andy Adamson0733d212009-04-03 08:28:01 +03001731/*
1732 * Set the exchange_id flags returned by the server.
1733 */
1734static void
1735nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1736{
1737 /* pNFS is not supported */
1738 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1739
1740 /* Referrals are supported, Migration is not. */
1741 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1742
1743 /* set the wire flags to return to client. */
1744 clid->flags = new->cl_exchange_flags;
1745}
1746
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001747static bool client_has_state(struct nfs4_client *clp)
1748{
1749 /*
1750 * Note clp->cl_openowners check isn't quite right: there's no
1751 * need to count owners without stateid's.
1752 *
1753 * Also note we should probably be using this in 4.0 case too.
1754 */
J. Bruce Fields6eccece2012-05-29 16:37:44 -04001755 return !list_empty(&clp->cl_openowners)
1756 || !list_empty(&clp->cl_delegations)
1757 || !list_empty(&clp->cl_sessions);
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001758}
1759
Al Virob37ad282006-10-19 23:28:59 -07001760__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001761nfsd4_exchange_id(struct svc_rqst *rqstp,
1762 struct nfsd4_compound_state *cstate,
1763 struct nfsd4_exchange_id *exid)
1764{
Andy Adamson0733d212009-04-03 08:28:01 +03001765 struct nfs4_client *unconf, *conf, *new;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001766 __be32 status;
Jeff Layton363168b2009-08-14 12:57:56 -04001767 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001768 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001769 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001770 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001771 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamson0733d212009-04-03 08:28:01 +03001772
Jeff Layton363168b2009-08-14 12:57:56 -04001773 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001774 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001775 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001776 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001777 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001778
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04001779 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03001780 return nfserr_inval;
1781
Andy Adamson0733d212009-04-03 08:28:01 +03001782 switch (exid->spa_how) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04001783 case SP4_MACH_CRED:
1784 if (!svc_rqst_integrity_protected(rqstp))
1785 return nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001786 case SP4_NONE:
1787 break;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05001788 default: /* checked by xdr code */
1789 WARN_ON_ONCE(1);
Andy Adamson0733d212009-04-03 08:28:01 +03001790 case SP4_SSV:
J. Bruce Fieldsdd303332013-04-12 18:10:56 -04001791 return nfserr_encr_alg_unsupp;
Andy Adamson0733d212009-04-03 08:28:01 +03001792 }
1793
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001794 /* Cases below refer to rfc 5661 section 18.35.4: */
Andy Adamson0733d212009-04-03 08:28:01 +03001795 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001796 conf = find_confirmed_client_by_name(&exid->clname, nn);
Andy Adamson0733d212009-04-03 08:28:01 +03001797 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001798 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1799 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1800
J. Bruce Fields136e6582012-05-12 20:37:23 -04001801 if (update) {
1802 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001803 status = nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001804 goto out;
1805 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04001806 if (!mach_creds_match(conf, rqstp)) {
1807 status = nfserr_wrong_cred;
1808 goto out;
1809 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001810 if (!creds_match) { /* case 9 */
Andy Adamson0733d212009-04-03 08:28:01 +03001811 status = nfserr_perm;
1812 goto out;
1813 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001814 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03001815 status = nfserr_not_same;
1816 goto out;
1817 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001818 /* case 6 */
1819 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1820 new = conf;
1821 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03001822 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001823 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001824 if (client_has_state(conf)) {
1825 status = nfserr_clid_inuse;
1826 goto out;
1827 }
Andy Adamson0733d212009-04-03 08:28:01 +03001828 expire_client(conf);
1829 goto out_new;
1830 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001831 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04001832 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001833 new = conf;
1834 goto out_copy;
1835 }
1836 /* case 5, client reboot */
J. Bruce Fields136e6582012-05-12 20:37:23 -04001837 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001838 }
1839
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001840 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001841 status = nfserr_noent;
1842 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001843 }
1844
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001845 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001846 if (unconf) /* case 4, possible retry or client restart */
Andy Adamson0733d212009-04-03 08:28:01 +03001847 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03001848
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001849 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03001850out_new:
Jeff Layton2216d442012-11-12 15:00:57 -05001851 new = create_client(exid->clname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001852 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001853 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001854 goto out;
1855 }
J. Bruce Fields4f540e22013-05-07 11:57:52 -04001856 new->cl_minorversion = cstate->minorversion;
J. Bruce Fields57266a62013-04-13 14:27:29 -04001857 new->cl_mach_cred = (exid->spa_how == SP4_MACH_CRED);
Andy Adamson0733d212009-04-03 08:28:01 +03001858
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001859 gen_clid(new, nn);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001860 add_to_unconfirmed(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001861out_copy:
1862 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1863 exid->clientid.cl_id = new->cl_clientid.cl_id;
1864
J. Bruce Fields778df3f2012-05-25 21:40:23 -04001865 exid->seqid = new->cl_cs_slot.sl_seqid + 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001866 nfsd4_set_ex_flags(new, exid);
1867
1868 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001869 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001870 status = nfs_ok;
1871
1872out:
1873 nfs4_unlock_state();
Andy Adamson0733d212009-04-03 08:28:01 +03001874 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001875}
1876
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001877static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04001878check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001879{
Andy Adamson88e588d2009-07-23 19:02:15 -04001880 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1881 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001882
1883 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001884 if (slot_inuse) {
1885 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001886 return nfserr_jukebox;
1887 else
1888 return nfserr_seq_misordered;
1889 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05001890 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04001891 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001892 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04001893 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001894 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001895 return nfserr_seq_misordered;
1896}
1897
Andy Adamson49557cc2009-07-23 19:02:16 -04001898/*
1899 * Cache the create session result into the create session single DRC
1900 * slot cache by saving the xdr structure. sl_seqid has been set.
1901 * Do this for solo or embedded create session operations.
1902 */
1903static void
1904nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001905 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04001906{
1907 slot->sl_status = nfserr;
1908 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1909}
1910
1911static __be32
1912nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1913 struct nfsd4_clid_slot *slot)
1914{
1915 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1916 return slot->sl_status;
1917}
1918
Mi Jinlong1b74c252011-07-14 14:50:17 +08001919#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1920 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1921 1 + /* MIN tag is length with zero, only length */ \
1922 3 + /* version, opcount, opcode */ \
1923 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1924 /* seqid, slotID, slotID, cache */ \
1925 4 ) * sizeof(__be32))
1926
1927#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1928 2 + /* verifier: AUTH_NULL, length 0 */\
1929 1 + /* status */ \
1930 1 + /* MIN tag is length with zero, only length */ \
1931 3 + /* opcount, opcode, opstatus*/ \
1932 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1933 /* seqid, slotID, slotID, slotID, status */ \
1934 5 ) * sizeof(__be32))
1935
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001936static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
Mi Jinlong1b74c252011-07-14 14:50:17 +08001937{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001938 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
1939
J. Bruce Fields373cd402013-04-08 15:42:12 -04001940 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
1941 return nfserr_toosmall;
1942 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
1943 return nfserr_toosmall;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001944 ca->headerpadsz = 0;
1945 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
1946 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
1947 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
1948 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
1949 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
1950 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
1951 /*
1952 * Note decreasing slot size below client's request may make it
1953 * difficult for client to function correctly, whereas
1954 * decreasing the number of slots will (just?) affect
1955 * performance. When short on memory we therefore prefer to
1956 * decrease number of slots instead of their size. Clients that
1957 * request larger slots than they need will get poor results:
1958 */
1959 ca->maxreqs = nfsd4_get_drc_mem(ca);
1960 if (!ca->maxreqs)
1961 return nfserr_jukebox;
1962
J. Bruce Fields373cd402013-04-08 15:42:12 -04001963 return nfs_ok;
Mi Jinlong1b74c252011-07-14 14:50:17 +08001964}
1965
Kinglong Mee8a891632013-12-23 18:11:02 +08001966#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
1967 RPC_MAX_HEADER_WITH_AUTH) * sizeof(__be32))
1968#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
1969 RPC_MAX_REPHEADER_WITH_AUTH) * sizeof(__be32))
1970
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001971static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
1972{
1973 ca->headerpadsz = 0;
1974
1975 /*
1976 * These RPC_MAX_HEADER macros are overkill, especially since we
1977 * don't even do gss on the backchannel yet. But this is still
1978 * less than 1k. Tighten up this estimate in the unlikely event
1979 * it turns out to be a problem for some client:
1980 */
Kinglong Mee8a891632013-12-23 18:11:02 +08001981 if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001982 return nfserr_toosmall;
Kinglong Mee8a891632013-12-23 18:11:02 +08001983 if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001984 return nfserr_toosmall;
1985 ca->maxresp_cached = 0;
1986 if (ca->maxops < 2)
1987 return nfserr_toosmall;
1988
1989 return nfs_ok;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001990}
1991
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04001992static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
1993{
1994 switch (cbs->flavor) {
1995 case RPC_AUTH_NULL:
1996 case RPC_AUTH_UNIX:
1997 return nfs_ok;
1998 default:
1999 /*
2000 * GSS case: the spec doesn't allow us to return this
2001 * error. But it also doesn't allow us not to support
2002 * GSS.
2003 * I'd rather this fail hard than return some error the
2004 * client might think it can already handle:
2005 */
2006 return nfserr_encr_alg_unsupp;
2007 }
2008}
2009
Andy Adamson069b6ad2009-04-03 08:27:58 +03002010__be32
2011nfsd4_create_session(struct svc_rqst *rqstp,
2012 struct nfsd4_compound_state *cstate,
2013 struct nfsd4_create_session *cr_ses)
2014{
Jeff Layton363168b2009-08-14 12:57:56 -04002015 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002016 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04002017 struct nfsd4_session *new;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002018 struct nfsd4_conn *conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002019 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002020 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002021 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002022
Mi Jinlonga62573d2011-03-23 17:57:07 +08002023 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
2024 return nfserr_inval;
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002025 status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
2026 if (status)
2027 return status;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002028 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
J. Bruce Fields373cd402013-04-08 15:42:12 -04002029 if (status)
2030 return status;
J. Bruce Fields06b332a2013-04-09 11:34:36 -04002031 status = check_backchannel_attrs(&cr_ses->back_channel);
2032 if (status)
Kinglong Meef403e452013-12-23 17:31:21 +08002033 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002034 status = nfserr_jukebox;
Kinglong Mee60810e52014-01-01 00:35:47 +08002035 new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002036 if (!new)
2037 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002038 conn = alloc_conn_from_crses(rqstp, cr_ses);
2039 if (!conn)
2040 goto out_free_session;
Mi Jinlonga62573d2011-03-23 17:57:07 +08002041
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002042 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002043 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002044 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002045 WARN_ON_ONCE(conf && unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002046
2047 if (conf) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04002048 status = nfserr_wrong_cred;
2049 if (!mach_creds_match(conf, rqstp))
2050 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002051 cs_slot = &conf->cl_cs_slot;
2052 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03002053 if (status == nfserr_replay_cache) {
Andy Adamson49557cc2009-07-23 19:02:16 -04002054 status = nfsd4_replay_create_session(cr_ses, cs_slot);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002055 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002056 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002057 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002058 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002059 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002060 } else if (unconf) {
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04002061 struct nfs4_client *old;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002062 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04002063 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002064 status = nfserr_clid_inuse;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002065 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002066 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04002067 status = nfserr_wrong_cred;
2068 if (!mach_creds_match(unconf, rqstp))
2069 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04002070 cs_slot = &unconf->cl_cs_slot;
2071 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03002072 if (status) {
2073 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002074 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002075 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002076 }
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002077 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002078 if (old) {
2079 status = mark_client_expired(old);
2080 if (status)
2081 goto out_free_conn;
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04002082 expire_client(old);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002083 }
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04002084 move_to_confirmed(unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002085 conf = unconf;
2086 } else {
2087 status = nfserr_stale_clientid;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002088 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002089 }
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002090 status = nfs_ok;
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002091 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04002092 * We do not support RDMA or persistent sessions
2093 */
2094 cr_ses->flags &= ~SESSION4_PERSIST;
2095 cr_ses->flags &= ~SESSION4_RDMA;
2096
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002097 init_session(rqstp, new, conf, cr_ses);
2098 nfsd4_init_conn(rqstp, conn, new);
2099
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04002100 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002101 NFS4_MAX_SESSIONID_LEN);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04002102 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04002103 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002104
Andy Adamson49557cc2009-07-23 19:02:16 -04002105 /* cache solo and embedded create sessions under the state lock */
2106 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002107 nfs4_unlock_state();
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002108 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002109out_free_conn:
Yanchuan Nian266533c2012-12-24 18:11:45 +08002110 nfs4_unlock_state();
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002111 free_conn(conn);
2112out_free_session:
2113 __free_session(new);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002114out_release_drc_mem:
2115 nfsd4_put_drc_mem(&cr_ses->fore_channel);
J. Bruce Fields1ca50792013-03-14 18:12:03 -04002116 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002117}
2118
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002119static __be32 nfsd4_map_bcts_dir(u32 *dir)
2120{
2121 switch (*dir) {
2122 case NFS4_CDFC4_FORE:
2123 case NFS4_CDFC4_BACK:
2124 return nfs_ok;
2125 case NFS4_CDFC4_FORE_OR_BOTH:
2126 case NFS4_CDFC4_BACK_OR_BOTH:
2127 *dir = NFS4_CDFC4_BOTH;
2128 return nfs_ok;
2129 };
2130 return nfserr_inval;
2131}
2132
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002133__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
2134{
2135 struct nfsd4_session *session = cstate->session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002136 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002137 __be32 status;
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002138
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002139 status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2140 if (status)
2141 return status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002142 spin_lock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002143 session->se_cb_prog = bc->bc_cb_program;
2144 session->se_cb_sec = bc->bc_cb_sec;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002145 spin_unlock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002146
2147 nfsd4_probe_callback(session->se_client);
2148
2149 return nfs_ok;
2150}
2151
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002152__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2153 struct nfsd4_compound_state *cstate,
2154 struct nfsd4_bind_conn_to_session *bcts)
2155{
2156 __be32 status;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002157 struct nfsd4_conn *conn;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002158 struct nfsd4_session *session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002159 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002160
2161 if (!nfsd4_last_compound_op(rqstp))
2162 return nfserr_not_only_op;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002163 nfs4_lock_state();
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002164 spin_lock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002165 session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002166 spin_unlock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002167 status = nfserr_badsession;
2168 if (!session)
2169 goto out;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002170 status = nfserr_wrong_cred;
2171 if (!mach_creds_match(session->se_client, rqstp))
2172 goto out;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002173 status = nfsd4_map_bcts_dir(&bcts->dir);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002174 if (status)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002175 goto out;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002176 conn = alloc_conn(rqstp, bcts->dir);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002177 status = nfserr_jukebox;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002178 if (!conn)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002179 goto out;
2180 nfsd4_init_conn(rqstp, conn, session);
2181 status = nfs_ok;
2182out:
2183 nfs4_unlock_state();
2184 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002185}
2186
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002187static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2188{
2189 if (!session)
2190 return 0;
2191 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2192}
2193
Andy Adamson069b6ad2009-04-03 08:27:58 +03002194__be32
2195nfsd4_destroy_session(struct svc_rqst *r,
2196 struct nfsd4_compound_state *cstate,
2197 struct nfsd4_destroy_session *sessionid)
2198{
Benny Halevye10e0cf2009-04-03 08:28:38 +03002199 struct nfsd4_session *ses;
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002200 __be32 status;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002201 int ref_held_by_me = 0;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002202 struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002203
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002204 nfs4_lock_state();
2205 status = nfserr_not_only_op;
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002206 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04002207 if (!nfsd4_last_compound_op(r))
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002208 goto out;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002209 ref_held_by_me++;
J. Bruce Fields57716352010-04-21 12:27:19 -04002210 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03002211 dump_sessionid(__func__, &sessionid->sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002212 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002213 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002214 status = nfserr_badsession;
2215 if (!ses)
2216 goto out_client_lock;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002217 status = nfserr_wrong_cred;
2218 if (!mach_creds_match(ses->se_client, r))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002219 goto out_client_lock;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002220 nfsd4_get_session_locked(ses);
2221 status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002222 if (status)
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002223 goto out_put_session;
Benny Halevye10e0cf2009-04-03 08:28:38 +03002224 unhash_session(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002225 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002226
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05002227 nfsd4_probe_callback_sync(ses->se_client);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04002228
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002229 spin_lock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002230 status = nfs_ok;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002231out_put_session:
2232 nfsd4_put_session(ses);
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002233out_client_lock:
2234 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002235out:
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002236 nfs4_unlock_state();
Benny Halevye10e0cf2009-04-03 08:28:38 +03002237 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002238}
2239
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002240static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002241{
2242 struct nfsd4_conn *c;
2243
2244 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002245 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04002246 return c;
2247 }
2248 }
2249 return NULL;
2250}
2251
J. Bruce Fields57266a62013-04-13 14:27:29 -04002252static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002253{
2254 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002255 struct nfsd4_conn *c;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002256 __be32 status = nfs_ok;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002257 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002258
2259 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002260 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002261 if (c)
2262 goto out_free;
2263 status = nfserr_conn_not_bound_to_session;
2264 if (clp->cl_mach_cred)
2265 goto out_free;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002266 __nfsd4_hash_conn(new, ses);
2267 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002268 ret = nfsd4_register_conn(new);
2269 if (ret)
2270 /* oops; xprt is already down: */
2271 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002272 return nfs_ok;
2273out_free:
2274 spin_unlock(&clp->cl_lock);
2275 free_conn(new);
2276 return status;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002277}
2278
Mi Jinlong868b89c2011-04-27 09:09:58 +08002279static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2280{
2281 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2282
2283 return args->opcnt > session->se_fchannel.maxops;
2284}
2285
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002286static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2287 struct nfsd4_session *session)
2288{
2289 struct xdr_buf *xb = &rqstp->rq_arg;
2290
2291 return xb->len > session->se_fchannel.maxreq_sz;
2292}
2293
Andy Adamson069b6ad2009-04-03 08:27:58 +03002294__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03002295nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002296 struct nfsd4_compound_state *cstate,
2297 struct nfsd4_sequence *seq)
2298{
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03002299 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002300 struct xdr_stream *xdr = &resp->xdr;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002301 struct nfsd4_session *session;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002302 struct nfs4_client *clp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002303 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002304 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002305 __be32 status;
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002306 int buflen;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002307 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002308
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03002309 if (resp->opcnt != 1)
2310 return nfserr_sequence_pos;
2311
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002312 /*
2313 * Will be either used or freed by nfsd4_sequence_check_conn
2314 * below.
2315 */
2316 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2317 if (!conn)
2318 return nfserr_jukebox;
2319
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002320 spin_lock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002321 status = nfserr_badsession;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002322 session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
Benny Halevyb85d4c02009-04-03 08:28:08 +03002323 if (!session)
J. Bruce Fields221a6872013-04-01 22:23:49 -04002324 goto out_no_session;
2325 clp = session->se_client;
2326 status = get_client_locked(clp);
2327 if (status)
2328 goto out_no_session;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002329 status = nfsd4_get_session_locked(session);
2330 if (status)
2331 goto out_put_client;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002332
Mi Jinlong868b89c2011-04-27 09:09:58 +08002333 status = nfserr_too_many_ops;
2334 if (nfsd4_session_too_many_ops(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002335 goto out_put_session;
Mi Jinlong868b89c2011-04-27 09:09:58 +08002336
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002337 status = nfserr_req_too_big;
2338 if (nfsd4_request_too_big(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002339 goto out_put_session;
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002340
Benny Halevyb85d4c02009-04-03 08:28:08 +03002341 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002342 if (seq->slotid >= session->se_fchannel.maxreqs)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002343 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002344
Andy Adamson557ce262009-08-28 08:45:04 -04002345 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002346 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2347
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002348 /* We do not negotiate the number of slots yet, so set the
2349 * maxslots to the session maxreqs which is used to encode
2350 * sr_highest_slotid and the sr_target_slot id to maxslots */
2351 seq->maxslots = session->se_fchannel.maxreqs;
2352
J. Bruce Fields73e79482012-02-13 16:39:00 -05002353 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2354 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002355 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002356 status = nfserr_seq_misordered;
2357 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002358 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002359 cstate->slot = slot;
2360 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002361 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002362 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002363 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002364 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002365 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002366 }
2367 if (status)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002368 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002369
J. Bruce Fields57266a62013-04-13 14:27:29 -04002370 status = nfsd4_sequence_check_conn(conn, session);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002371 conn = NULL;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002372 if (status)
2373 goto out_put_session;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002374
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002375 buflen = (seq->cachethis) ?
2376 session->se_fchannel.maxresp_cached :
2377 session->se_fchannel.maxresp_sz;
2378 status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
2379 nfserr_rep_too_big;
J. Bruce Fieldsa5cddc82014-05-12 18:10:58 -04002380 if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002381 goto out_put_session;
J. Bruce Fields32aaa622014-03-20 20:47:41 -04002382 svc_reserve(rqstp, buflen);
J. Bruce Fields47ee5292014-03-12 21:39:35 -04002383
2384 status = nfs_ok;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002385 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03002386 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002387 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05002388 if (seq->cachethis)
2389 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002390 else
2391 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002392
2393 cstate->slot = slot;
2394 cstate->session = session;
2395
Benny Halevyb85d4c02009-04-03 08:28:08 +03002396out:
J. Bruce Fields221a6872013-04-01 22:23:49 -04002397 switch (clp->cl_cb_state) {
2398 case NFSD4_CB_DOWN:
2399 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
2400 break;
2401 case NFSD4_CB_FAULT:
2402 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
2403 break;
2404 default:
2405 seq->status_flags = 0;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002406 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04002407 if (!list_empty(&clp->cl_revoked))
2408 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002409out_no_session:
Kinglong Mee3f42d2c2014-03-24 11:56:59 +08002410 if (conn)
2411 free_conn(conn);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002412 spin_unlock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002413 return status;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002414out_put_session:
2415 nfsd4_put_session(session);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002416out_put_client:
2417 put_client_renew_locked(clp);
2418 goto out_no_session;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002419}
2420
Mi Jinlong345c2842011-10-20 17:51:39 +08002421__be32
2422nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2423{
2424 struct nfs4_client *conf, *unconf, *clp;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002425 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002426 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Mi Jinlong345c2842011-10-20 17:51:39 +08002427
2428 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002429 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002430 conf = find_confirmed_client(&dc->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002431 WARN_ON_ONCE(conf && unconf);
Mi Jinlong345c2842011-10-20 17:51:39 +08002432
2433 if (conf) {
2434 clp = conf;
2435
J. Bruce Fieldsc0293b02013-03-14 18:20:01 -04002436 if (client_has_state(conf)) {
Mi Jinlong345c2842011-10-20 17:51:39 +08002437 status = nfserr_clientid_busy;
2438 goto out;
2439 }
2440 } else if (unconf)
2441 clp = unconf;
2442 else {
2443 status = nfserr_stale_clientid;
2444 goto out;
2445 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04002446 if (!mach_creds_match(clp, rqstp)) {
2447 status = nfserr_wrong_cred;
2448 goto out;
2449 }
Mi Jinlong345c2842011-10-20 17:51:39 +08002450 expire_client(clp);
2451out:
2452 nfs4_unlock_state();
Mi Jinlong345c2842011-10-20 17:51:39 +08002453 return status;
2454}
2455
Andy Adamson069b6ad2009-04-03 08:27:58 +03002456__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002457nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2458{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002459 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002460
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002461 if (rc->rca_one_fs) {
2462 if (!cstate->current_fh.fh_dentry)
2463 return nfserr_nofilehandle;
2464 /*
2465 * We don't take advantage of the rca_one_fs case.
2466 * That's OK, it's optional, we can safely ignore it.
2467 */
2468 return nfs_ok;
2469 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002470
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002471 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002472 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04002473 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2474 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002475 goto out;
2476
2477 status = nfserr_stale_clientid;
2478 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002479 /*
2480 * The following error isn't really legal.
2481 * But we only get here if the client just explicitly
2482 * destroyed the client. Surely it no longer cares what
2483 * error it gets back on an operation for the dead
2484 * client.
2485 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002486 goto out;
2487
2488 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04002489 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002490out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002491 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002492 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002493}
2494
2495__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002496nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2497 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002499 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 nfs4_verifier clverifier = setclid->se_verf;
NeilBrown28ce6052005-06-23 22:03:56 -07002501 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07002502 __be32 status;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002503 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2504
J. Bruce Fields63db4632012-05-18 21:54:19 -04002505 /* Cases below refer to rfc 3530 section 14.2.33: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002507 conf = find_confirmed_client_by_name(&clname, nn);
NeilBrown28ce6052005-06-23 22:03:56 -07002508 if (conf) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04002509 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002511 if (clp_used_exchangeid(conf))
2512 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04002513 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04002514 char addr_str[INET6_ADDRSTRLEN];
2515 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2516 sizeof(addr_str));
2517 dprintk("NFSD: setclientid: string in use by client "
2518 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 goto out;
2520 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002522 unconf = find_unconfirmed_client_by_name(&clname, nn);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002523 if (unconf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 status = nfserr_jukebox;
Jeff Layton2216d442012-11-12 15:00:57 -05002526 new = create_client(clname, rqstp, &clverifier);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002527 if (new == NULL)
2528 goto out;
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002529 if (conf && same_verf(&conf->cl_verifier, &clverifier))
J. Bruce Fields63db4632012-05-18 21:54:19 -04002530 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 copy_clid(new, conf);
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002532 else /* case 4 (new client) or cases 2, 3 (client reboot): */
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002533 gen_clid(new, nn);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002534 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002535 gen_callback(new, setclid, rqstp);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002536 add_to_unconfirmed(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2538 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2539 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2540 status = nfs_ok;
2541out:
2542 nfs4_unlock_state();
2543 return status;
2544}
2545
2546
Al Virob37ad282006-10-19 23:28:59 -07002547__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002548nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2549 struct nfsd4_compound_state *cstate,
2550 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551{
NeilBrown21ab45a2005-06-23 22:04:14 -07002552 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2554 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002555 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03002556 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002558 if (STALE_CLIENTID(clid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 return nfserr_stale_clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002561
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002562 conf = find_confirmed_client(clid, false, nn);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002563 unconf = find_unconfirmed_client(clid, false, nn);
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002564 /*
J. Bruce Fields8695b902012-05-19 10:05:58 -04002565 * We try hard to give out unique clientid's, so if we get an
2566 * attempt to confirm the same clientid with a different cred,
2567 * there's a bug somewhere. Let's charitably assume it's our
2568 * bug.
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002569 */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002570 status = nfserr_serverfault;
2571 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2572 goto out;
2573 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2574 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04002575 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002576 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2577 if (conf && !unconf) /* case 2: probable retransmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 status = nfs_ok;
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002579 else /* case 4: client hasn't noticed we rebooted yet? */
2580 status = nfserr_stale_clientid;
2581 goto out;
2582 }
2583 status = nfs_ok;
2584 if (conf) { /* case 1: callback update */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002585 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2586 nfsd4_probe_callback(conf);
2587 expire_client(unconf);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002588 } else { /* case 3: normal case; new or rebooted client */
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002589 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002590 if (conf) {
2591 status = mark_client_expired(conf);
2592 if (status)
2593 goto out;
J. Bruce Fields8695b902012-05-19 10:05:58 -04002594 expire_client(conf);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002595 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04002596 move_to_confirmed(unconf);
J. Bruce Fieldsf3d03b92012-05-23 11:38:38 -04002597 nfsd4_probe_callback(unconf);
NeilBrown08e89872005-06-23 22:04:11 -07002598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 nfs4_unlock_state();
2601 return status;
2602}
2603
J. Bruce Fields32513b42011-10-13 16:00:16 -04002604static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605{
J. Bruce Fields32513b42011-10-13 16:00:16 -04002606 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2607}
2608
2609/* OPEN Share state helper functions */
2610static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2611{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 unsigned int hashval = file_hashval(ino);
2613
J. Bruce Fields32513b42011-10-13 16:00:16 -04002614 atomic_set(&fp->fi_ref, 1);
J. Bruce Fields32513b42011-10-13 16:00:16 -04002615 INIT_LIST_HEAD(&fp->fi_stateids);
2616 INIT_LIST_HEAD(&fp->fi_delegations);
2617 fp->fi_inode = igrab(ino);
2618 fp->fi_had_conflict = false;
2619 fp->fi_lease = NULL;
2620 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2621 memset(fp->fi_access, 0, sizeof(fp->fi_access));
Benny Halevycdc975052014-05-30 09:09:30 -04002622 spin_lock(&state_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002623 hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
Benny Halevycdc975052014-05-30 09:09:30 -04002624 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625}
2626
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002627void
NeilBrowne60d4392005-06-23 22:03:01 -07002628nfsd4_free_slabs(void)
2629{
Christoph Hellwigabf11352014-05-21 07:43:03 -07002630 kmem_cache_destroy(openowner_slab);
2631 kmem_cache_destroy(lockowner_slab);
2632 kmem_cache_destroy(file_slab);
2633 kmem_cache_destroy(stateid_slab);
2634 kmem_cache_destroy(deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002635}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636
Bryan Schumaker72083392011-11-01 15:24:59 -04002637int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638nfsd4_init_slabs(void)
2639{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002640 openowner_slab = kmem_cache_create("nfsd4_openowners",
2641 sizeof(struct nfs4_openowner), 0, 0, NULL);
2642 if (openowner_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07002643 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002644 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
Yanchuan Nian3c407942012-10-24 14:44:19 +08002645 sizeof(struct nfs4_lockowner), 0, 0, NULL);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002646 if (lockowner_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07002647 goto out_free_openowner_slab;
NeilBrowne60d4392005-06-23 22:03:01 -07002648 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002649 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002650 if (file_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07002651 goto out_free_lockowner_slab;
NeilBrown5ac049a2005-06-23 22:03:03 -07002652 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002653 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002654 if (stateid_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07002655 goto out_free_file_slab;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002656 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002657 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002658 if (deleg_slab == NULL)
Christoph Hellwigabf11352014-05-21 07:43:03 -07002659 goto out_free_stateid_slab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 return 0;
Christoph Hellwigabf11352014-05-21 07:43:03 -07002661
2662out_free_stateid_slab:
2663 kmem_cache_destroy(stateid_slab);
2664out_free_file_slab:
2665 kmem_cache_destroy(file_slab);
2666out_free_lockowner_slab:
2667 kmem_cache_destroy(lockowner_slab);
2668out_free_openowner_slab:
2669 kmem_cache_destroy(openowner_slab);
2670out:
NeilBrowne60d4392005-06-23 22:03:01 -07002671 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2672 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673}
2674
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002675static void init_nfs4_replay(struct nfs4_replay *rp)
2676{
2677 rp->rp_status = nfserr_serverfault;
2678 rp->rp_buflen = 0;
2679 rp->rp_buf = rp->rp_ibuf;
2680}
2681
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002682static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683{
2684 struct nfs4_stateowner *sop;
2685
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002686 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002687 if (!sop)
2688 return NULL;
2689
2690 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2691 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002692 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002693 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002695 sop->so_owner.len = owner->len;
2696
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002697 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002698 sop->so_client = clp;
2699 init_nfs4_replay(&sop->so_replay);
2700 return sop;
2701}
2702
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002703static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002704{
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002705 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2706
2707 list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002708 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709}
2710
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002711static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002713 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002715 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2716 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002718 oo->oo_owner.so_is_open_owner = 1;
2719 oo->oo_owner.so_seqid = open->op_seqid;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04002720 oo->oo_flags = NFS4_OO_NEW;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002721 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04002722 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002723 INIT_LIST_HEAD(&oo->oo_close_lru);
2724 hash_openowner(oo, clp, strhashval);
2725 return oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726}
2727
J. Bruce Fields996e0932011-10-17 11:14:48 -04002728static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002729 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730
J. Bruce Fields3abdb602013-02-03 12:23:01 -05002731 stp->st_stid.sc_type = NFS4_OPEN_STID;
NeilBrownea1da632005-06-23 22:04:17 -07002732 INIT_LIST_HEAD(&stp->st_lockowners);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002733 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002734 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002735 stp->st_stateowner = &oo->oo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07002736 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 stp->st_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 stp->st_access_bmap = 0;
2739 stp->st_deny_bmap = 0;
Jeff Layton82c5ff12012-05-11 09:45:13 -04002740 set_access(open->op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002741 set_deny(open->op_share_deny, stp);
NeilBrown4c4cd222005-07-07 17:59:27 -07002742 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743}
2744
2745static void
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002746move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747{
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002748 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2749
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002750 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002752 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002753 oo->oo_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754}
2755
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002757same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2758 clientid_t *clid)
2759{
2760 return (sop->so_owner.len == owner->len) &&
2761 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2762 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763}
2764
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002765static struct nfs4_openowner *
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002766find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2767 bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768{
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002769 struct nfs4_stateowner *so;
2770 struct nfs4_openowner *oo;
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002771 struct nfs4_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002773 list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002774 if (!so->so_is_open_owner)
2775 continue;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002776 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2777 oo = openowner(so);
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002778 clp = oo->oo_owner.so_client;
2779 if ((bool)clp->cl_minorversion != sessions)
2780 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002781 renew_client(oo->oo_owner.so_client);
2782 return oo;
2783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 }
2785 return NULL;
2786}
2787
2788/* search file_hashtbl[] for file */
2789static struct nfs4_file *
2790find_file(struct inode *ino)
2791{
2792 unsigned int hashval = file_hashval(ino);
2793 struct nfs4_file *fp;
2794
Benny Halevycdc975052014-05-30 09:09:30 -04002795 spin_lock(&state_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002796 hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002797 if (fp->fi_inode == ino) {
2798 get_nfs4_file(fp);
Benny Halevycdc975052014-05-30 09:09:30 -04002799 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802 }
Benny Halevycdc975052014-05-30 09:09:30 -04002803 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 return NULL;
2805}
2806
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002807/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 * Called to check deny when READ with all zero stateid or
2809 * WRITE with all zero or all one stateid
2810 */
Al Virob37ad282006-10-19 23:28:59 -07002811static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2813{
2814 struct inode *ino = current_fh->fh_dentry->d_inode;
2815 struct nfs4_file *fp;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002816 struct nfs4_ol_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002817 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002820 if (!fp)
2821 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002822 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002824 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
Jeff Laytonce0fc432012-05-11 09:45:14 -04002825 if (test_deny(deny_type, stp) ||
2826 test_deny(NFS4_SHARE_DENY_BOTH, stp))
NeilBrown13cd2182005-06-23 22:03:10 -07002827 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 }
NeilBrown13cd2182005-06-23 22:03:10 -07002829 ret = nfs_ok;
2830out:
2831 put_nfs4_file(fp);
2832 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833}
2834
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002835static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836{
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002837 struct nfs4_client *clp = dp->dl_stid.sc_client;
2838 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2839
Benny Halevycdc975052014-05-30 09:09:30 -04002840 lockdep_assert_held(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 /* We're assuming the state code never drops its reference
2842 * without first removing the lease. Since we're in this lease
2843 * callback (and since the lease code is serialized by the kernel
2844 * lock) we know the server hasn't removed the lease yet, we know
2845 * it's safe to take a reference: */
2846 atomic_inc(&dp->dl_count);
2847
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002848 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849
Jeff Layton1c8c6012013-06-21 08:58:15 -04002850 /* Only place dl_time is set; protected by i_lock: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 dp->dl_time = get_seconds();
2852
NeilBrown6282cd52014-06-04 17:39:26 +10002853 block_delegations(&dp->dl_fh);
2854
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002855 nfsd4_cb_recall(dp);
2856}
2857
Jeff Layton1c8c6012013-06-21 08:58:15 -04002858/* Called from break_lease() with i_lock held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002859static void nfsd_break_deleg_cb(struct file_lock *fl)
2860{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002861 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2862 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002863
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04002864 if (!fp) {
2865 WARN(1, "(%p)->fl_owner NULL\n", fl);
2866 return;
2867 }
2868 if (fp->fi_had_conflict) {
2869 WARN(1, "duplicate break on %p\n", fp);
2870 return;
2871 }
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002872 /*
2873 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002874 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002875 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002876 */
2877 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Benny Halevycdc975052014-05-30 09:09:30 -04002879 spin_lock(&state_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002880 fp->fi_had_conflict = true;
2881 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2882 nfsd_break_one_deleg(dp);
Benny Halevycdc975052014-05-30 09:09:30 -04002883 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884}
2885
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886static
2887int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2888{
2889 if (arg & F_UNLCK)
2890 return lease_modify(onlist, arg);
2891 else
2892 return -EAGAIN;
2893}
2894
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002895static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002896 .lm_break = nfsd_break_deleg_cb,
2897 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898};
2899
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04002900static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2901{
2902 if (nfsd4_has_session(cstate))
2903 return nfs_ok;
2904 if (seqid == so->so_seqid - 1)
2905 return nfserr_replay_me;
2906 if (seqid == so->so_seqid)
2907 return nfs_ok;
2908 return nfserr_bad_seqid;
2909}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910
Al Virob37ad282006-10-19 23:28:59 -07002911__be32
Andy Adamson66689582009-04-03 08:28:45 +03002912nfsd4_process_open1(struct nfsd4_compound_state *cstate,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03002913 struct nfsd4_open *open, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 clientid_t *clientid = &open->op_clientid;
2916 struct nfs4_client *clp = NULL;
2917 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002918 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002919 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002921 if (STALE_CLIENTID(&open->op_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04002923 /*
2924 * In case we need it later, after we've already created the
2925 * file and don't want to risk a further failure:
2926 */
2927 open->op_file = nfsd4_alloc_file();
2928 if (open->op_file == NULL)
2929 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002931 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002932 oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002933 open->op_openowner = oo;
2934 if (!oo) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002935 clp = find_confirmed_client(clientid, cstate->minorversion,
2936 nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002938 return nfserr_expired;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002939 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002941 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002942 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002943 clp = oo->oo_owner.so_client;
2944 release_openowner(oo);
2945 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002946 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002947 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002948 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2949 if (status)
2950 return status;
2951 clp = oo->oo_owner.so_client;
2952 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002953new_owner:
2954 oo = alloc_init_open_stateowner(strhashval, clp, open);
2955 if (oo == NULL)
2956 return nfserr_jukebox;
2957 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002958alloc_stateid:
2959 open->op_stp = nfs4_alloc_stateid(clp);
2960 if (!open->op_stp)
2961 return nfserr_jukebox;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002962 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963}
2964
Al Virob37ad282006-10-19 23:28:59 -07002965static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002966nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2967{
2968 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2969 return nfserr_openmode;
2970 else
2971 return nfs_ok;
2972}
2973
Daniel Mackc47d8322011-05-16 16:38:14 +02002974static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002975{
J. Bruce Fields24a01112010-05-18 20:01:35 -04002976 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2977}
2978
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002979static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002980{
2981 struct nfs4_stid *ret;
2982
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002983 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002984 if (!ret)
2985 return NULL;
2986 return delegstateid(ret);
2987}
2988
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002989static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2990{
2991 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2992 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2993}
2994
Al Virob37ad282006-10-19 23:28:59 -07002995static __be32
J. Bruce Fields41d22662013-03-21 15:49:47 -04002996nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07002997 struct nfs4_delegation **dp)
2998{
2999 int flags;
Al Virob37ad282006-10-19 23:28:59 -07003000 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07003001
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003002 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
NeilBrown567d9822005-06-23 22:02:53 -07003003 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07003004 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04003005 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07003006 status = nfs4_check_delegmode(*dp, flags);
3007 if (status)
3008 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07003009out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003010 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003011 return nfs_ok;
3012 if (status)
3013 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003014 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07003015 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07003016}
3017
Al Virob37ad282006-10-19 23:28:59 -07003018static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003019nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003021 struct nfs4_ol_stateid *local;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003022 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023
NeilBrown8beefa22005-06-23 22:03:08 -07003024 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 /* ignore lock owners */
3026 if (local->st_stateowner->so_is_open_owner == 0)
3027 continue;
3028 /* remember if we have seen this open owner */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003029 if (local->st_stateowner == &oo->oo_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 *stpp = local;
3031 /* check for conflicting share reservations */
3032 if (!test_share(local, open))
J. Bruce Fields77eaae82011-09-02 12:08:20 -04003033 return nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 }
J. Bruce Fields77eaae82011-09-02 12:08:20 -04003035 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036}
3037
J. Bruce Fields21fb4012010-07-28 12:21:23 -04003038static inline int nfs4_access_to_access(u32 nfs4_access)
3039{
3040 int flags = 0;
3041
3042 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
3043 flags |= NFSD_MAY_READ;
3044 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
3045 flags |= NFSD_MAY_WRITE;
3046 return flags;
3047}
3048
Al Virob37ad282006-10-19 23:28:59 -07003049static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
3051 struct nfsd4_open *open)
3052{
3053 struct iattr iattr = {
3054 .ia_valid = ATTR_SIZE,
3055 .ia_size = 0,
3056 };
3057 if (!open->op_truncate)
3058 return 0;
3059 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08003060 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
3062}
3063
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003064static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
3065 struct svc_fh *cur_fh, struct nfsd4_open *open)
3066{
3067 __be32 status;
3068 int oflag = nfs4_access_to_omode(open->op_share_access);
3069 int access = nfs4_access_to_access(open->op_share_access);
3070
3071 if (!fp->fi_fds[oflag]) {
3072 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
3073 &fp->fi_fds[oflag]);
3074 if (status)
3075 goto out;
3076 }
3077 nfs4_file_get_access(fp, oflag);
3078
3079 status = nfsd4_truncate(rqstp, cur_fh, open);
3080 if (status)
3081 goto out_put_access;
3082
3083 return nfs_ok;
3084
3085out_put_access:
3086 nfs4_file_put_access(fp, oflag);
3087out:
3088 return status;
3089}
3090
Al Virob37ad282006-10-19 23:28:59 -07003091static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003092nfs4_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 -07003093{
J. Bruce Fieldsb6d2f1c2011-10-10 17:44:19 -04003094 u32 op_share_access = open->op_share_access;
Al Virob37ad282006-10-19 23:28:59 -07003095 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003097 if (!test_access(op_share_access, stp))
Casey Bodley0c12eaf2011-07-23 14:58:10 -04003098 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003099 else
3100 status = nfsd4_truncate(rqstp, cur_fh, open);
3101
3102 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 return status;
Christoph Hellwig7e6a72e2014-06-30 11:48:30 -04003104
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 /* remember the open */
Jeff Layton82c5ff12012-05-11 09:45:13 -04003106 set_access(op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04003107 set_deny(open->op_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 return nfs_ok;
3109}
3110
3111
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112static void
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003113nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114{
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003115 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116}
3117
J. Bruce Fields14a24e92010-12-10 19:02:49 -05003118/* Should we give out recallable state?: */
3119static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
3120{
3121 if (clp->cl_cb_state == NFSD4_CB_UP)
3122 return true;
3123 /*
3124 * In the sessions case, since we don't have to establish a
3125 * separate connection for callbacks, we assume it's OK
3126 * until we hear otherwise:
3127 */
3128 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
3129}
3130
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003131static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
3132{
3133 struct file_lock *fl;
3134
3135 fl = locks_alloc_lock();
3136 if (!fl)
3137 return NULL;
3138 locks_init_lock(fl);
3139 fl->fl_lmops = &nfsd_lease_mng_ops;
J. Bruce Fields617588d2011-07-01 15:18:34 -04003140 fl->fl_flags = FL_DELEG;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003141 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
3142 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003143 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003144 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003145 return fl;
3146}
3147
J. Bruce Fields99c41512013-05-21 16:21:25 -04003148static int nfs4_setlease(struct nfs4_delegation *dp)
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003149{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003150 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003151 struct file_lock *fl;
3152 int status;
3153
J. Bruce Fields99c41512013-05-21 16:21:25 -04003154 fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003155 if (!fl)
3156 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003157 fl->fl_file = find_readable_file(fp);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003158 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldse8730882012-01-23 13:52:01 -05003159 if (status)
3160 goto out_free;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003161 fp->fi_lease = fl;
Al Virocb0942b2012-08-27 14:48:26 -04003162 fp->fi_deleg_file = get_file(fl->fl_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003163 atomic_set(&fp->fi_delegees, 1);
Benny Halevycdc975052014-05-30 09:09:30 -04003164 spin_lock(&state_lock);
Benny Halevy931ee562014-05-30 09:09:27 -04003165 hash_delegation_locked(dp, fp);
Benny Halevycdc975052014-05-30 09:09:30 -04003166 spin_unlock(&state_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003167 return 0;
J. Bruce Fieldse8730882012-01-23 13:52:01 -05003168out_free:
3169 locks_free_lock(fl);
3170 return status;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003171}
3172
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003173static int nfs4_set_delegation(struct nfs4_delegation *dp, struct nfs4_file *fp)
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003174{
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003175 if (fp->fi_had_conflict)
3176 return -EAGAIN;
3177 get_nfs4_file(fp);
3178 dp->dl_file = fp;
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -05003179 if (!fp->fi_lease)
3180 return nfs4_setlease(dp);
Benny Halevycdc975052014-05-30 09:09:30 -04003181 spin_lock(&state_lock);
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -05003182 atomic_inc(&fp->fi_delegees);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003183 if (fp->fi_had_conflict) {
Benny Halevycdc975052014-05-30 09:09:30 -04003184 spin_unlock(&state_lock);
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -05003185 return -EAGAIN;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003186 }
Benny Halevy931ee562014-05-30 09:09:27 -04003187 hash_delegation_locked(dp, fp);
Benny Halevycdc975052014-05-30 09:09:30 -04003188 spin_unlock(&state_lock);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003189 return 0;
3190}
3191
Benny Halevy4aa89132012-02-21 14:16:44 -08003192static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
3193{
3194 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3195 if (status == -EAGAIN)
3196 open->op_why_no_deleg = WND4_CONTENTION;
3197 else {
3198 open->op_why_no_deleg = WND4_RESOURCE;
3199 switch (open->op_deleg_want) {
3200 case NFS4_SHARE_WANT_READ_DELEG:
3201 case NFS4_SHARE_WANT_WRITE_DELEG:
3202 case NFS4_SHARE_WANT_ANY_DELEG:
3203 break;
3204 case NFS4_SHARE_WANT_CANCEL:
3205 open->op_why_no_deleg = WND4_CANCELLED;
3206 break;
3207 case NFS4_SHARE_WANT_NO_DELEG:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003208 WARN_ON_ONCE(1);
Benny Halevy4aa89132012-02-21 14:16:44 -08003209 }
3210 }
3211}
3212
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213/*
3214 * Attempt to hand out a delegation.
J. Bruce Fields99c41512013-05-21 16:21:25 -04003215 *
3216 * Note we don't support write delegations, and won't until the vfs has
3217 * proper support for them.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 */
3219static void
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003220nfs4_open_delegation(struct net *net, struct svc_fh *fh,
3221 struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222{
3223 struct nfs4_delegation *dp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003224 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
J. Bruce Fields14a24e92010-12-10 19:02:49 -05003225 int cb_up;
J. Bruce Fields99c41512013-05-21 16:21:25 -04003226 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003228 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
NeilBrown7b190fe2005-06-23 22:03:23 -07003229 open->op_recall = 0;
3230 switch (open->op_claim_type) {
3231 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05003232 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07003233 open->op_recall = 1;
J. Bruce Fields99c41512013-05-21 16:21:25 -04003234 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
3235 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003236 break;
3237 case NFS4_OPEN_CLAIM_NULL:
Ming Chened47b062014-01-09 21:26:10 +00003238 case NFS4_OPEN_CLAIM_FH:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003239 /*
3240 * Let's not give out any delegations till everyone's
3241 * had the chance to reclaim theirs....
3242 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003243 if (locks_in_grace(net))
J. Bruce Fields99c41512013-05-21 16:21:25 -04003244 goto out_no_deleg;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003245 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
J. Bruce Fields99c41512013-05-21 16:21:25 -04003246 goto out_no_deleg;
Steve Dickson9a0590a2013-05-15 14:51:49 -04003247 /*
3248 * Also, if the file was opened for write or
3249 * create, there's a good chance the client's
3250 * about to write to it, resulting in an
3251 * immediate recall (since we don't support
3252 * write delegations):
3253 */
NeilBrown7b190fe2005-06-23 22:03:23 -07003254 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
J. Bruce Fields99c41512013-05-21 16:21:25 -04003255 goto out_no_deleg;
3256 if (open->op_create == NFS4_OPEN_CREATE)
3257 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003258 break;
3259 default:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003260 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003261 }
J. Bruce Fields99c41512013-05-21 16:21:25 -04003262 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003263 if (dp == NULL)
3264 goto out_no_deleg;
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003265 status = nfs4_set_delegation(dp, stp->st_file);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003266 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003267 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003269 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003271 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003272 STATEID_VAL(&dp->dl_stid.sc_stateid));
J. Bruce Fields99c41512013-05-21 16:21:25 -04003273 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003274 return;
3275out_free:
J. Bruce Fieldscbf7a752014-03-03 12:19:18 -05003276 destroy_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003277out_no_deleg:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003278 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
3279 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04003280 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
J. Bruce Fields99c41512013-05-21 16:21:25 -04003281 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04003282 open->op_recall = 1;
3283 }
J. Bruce Fields99c41512013-05-21 16:21:25 -04003284
3285 /* 4.1 client asking for a delegation? */
3286 if (open->op_deleg_want)
3287 nfsd4_open_deleg_none_ext(open, status);
3288 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289}
3290
Benny Halevye27f49c2012-02-21 14:16:54 -08003291static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
3292 struct nfs4_delegation *dp)
3293{
3294 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
3295 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3296 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3297 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
3298 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3299 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3300 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3301 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3302 }
3303 /* Otherwise the client must be confused wanting a delegation
3304 * it already has, therefore we don't return
3305 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
3306 */
3307}
3308
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309/*
3310 * called with nfs4_lock_state() held.
3311 */
Al Virob37ad282006-10-19 23:28:59 -07003312__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3314{
Andy Adamson66689582009-04-03 08:28:45 +03003315 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003316 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317 struct nfs4_file *fp = NULL;
3318 struct inode *ino = current_fh->fh_dentry->d_inode;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003319 struct nfs4_ol_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07003320 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003321 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 /*
3324 * Lookup file; if found, lookup stateid and check open request,
3325 * and check for delegations in the process of being recalled.
3326 * If not found, create the nfs4_file struct
3327 */
3328 fp = find_file(ino);
3329 if (fp) {
3330 if ((status = nfs4_check_open(fp, open, &stp)))
3331 goto out;
J. Bruce Fields41d22662013-03-21 15:49:47 -04003332 status = nfs4_check_deleg(cl, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07003333 if (status)
3334 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07003336 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003337 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003338 goto out;
J. Bruce Fields3e772462011-08-10 19:07:33 -04003339 status = nfserr_jukebox;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003340 fp = open->op_file;
3341 open->op_file = NULL;
3342 nfsd4_init_file(fp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343 }
3344
3345 /*
3346 * OPEN the file, or upgrade an existing OPEN.
3347 * If truncate fails, the OPEN fails.
3348 */
3349 if (stp) {
3350 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003351 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352 if (status)
3353 goto out;
3354 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003355 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07003356 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357 goto out;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003358 stp = open->op_stp;
3359 open->op_stp = NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003360 init_open_stateid(stp, fp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003362 update_stateid(&stp->st_stid.sc_stateid);
3363 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364
Benny Halevyd24433c2012-02-16 20:57:17 +02003365 if (nfsd4_has_session(&resp->cstate)) {
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003366 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Andy Adamson66689582009-04-03 08:28:45 +03003367
Benny Halevyd24433c2012-02-16 20:57:17 +02003368 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3369 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3370 open->op_why_no_deleg = WND4_NOT_WANTED;
3371 goto nodeleg;
3372 }
3373 }
3374
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375 /*
3376 * Attempt to hand out a delegation. No error return, because the
3377 * OPEN succeeds even if we fail.
3378 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003379 nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003380nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381 status = nfs_ok;
3382
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003383 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003384 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385out:
Benny Halevyd24433c2012-02-16 20:57:17 +02003386 /* 4.1 client trying to upgrade/downgrade delegation? */
3387 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08003388 open->op_deleg_want)
3389 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003390
NeilBrown13cd2182005-06-23 22:03:10 -07003391 if (fp)
3392 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07003393 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003394 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 /*
3396 * To finish the open response, we just need to set the rflags.
3397 */
3398 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003399 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03003400 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3402
3403 return status;
3404}
3405
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003406void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3407{
3408 if (open->op_openowner) {
3409 struct nfs4_openowner *oo = open->op_openowner;
3410
3411 if (!list_empty(&oo->oo_owner.so_stateids))
3412 list_del_init(&oo->oo_close_lru);
3413 if (oo->oo_flags & NFS4_OO_NEW) {
3414 if (status) {
3415 release_openowner(oo);
3416 open->op_openowner = NULL;
3417 } else
3418 oo->oo_flags &= ~NFS4_OO_NEW;
3419 }
3420 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04003421 if (open->op_file)
3422 nfsd4_free_file(open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003423 if (open->op_stp)
J. Bruce Fieldsef798592012-08-29 10:32:54 -07003424 free_generic_stateid(open->op_stp);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003425}
3426
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003427static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
3428{
3429 struct nfs4_client *found;
3430
3431 if (STALE_CLIENTID(clid, nn))
3432 return nfserr_stale_clientid;
3433 found = find_confirmed_client(clid, session, nn);
3434 if (clp)
3435 *clp = found;
3436 return found ? nfs_ok : nfserr_expired;
3437}
3438
Al Virob37ad282006-10-19 23:28:59 -07003439__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003440nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3441 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442{
3443 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07003444 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03003445 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446
3447 nfs4_lock_state();
3448 dprintk("process_renew(%08x/%08x): starting\n",
3449 clid->cl_boot, clid->cl_id);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003450 status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
3451 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07003454 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04003455 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003456 goto out;
3457 status = nfs_ok;
3458out:
3459 nfs4_unlock_state();
3460 return status;
3461}
3462
NeilBrowna76b4312005-06-23 22:04:01 -07003463static void
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003464nfsd4_end_grace(struct nfsd_net *nn)
NeilBrowna76b4312005-06-23 22:04:01 -07003465{
Jeff Layton33dcc482012-04-10 11:08:48 -04003466 /* do nothing if grace period already ended */
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003467 if (nn->grace_ended)
Jeff Layton33dcc482012-04-10 11:08:48 -04003468 return;
3469
NeilBrowna76b4312005-06-23 22:04:01 -07003470 dprintk("NFSD: end of grace period\n");
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003471 nn->grace_ended = true;
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003472 nfsd4_record_grace_done(nn, nn->boot_time);
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04003473 locks_end_grace(&nn->nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05003474 /*
3475 * Now that every NFSv4 client has had the chance to recover and
3476 * to see the (possibly new, possibly shorter) lease time, we
3477 * can safely set the next grace time to the current lease time:
3478 */
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03003479 nn->nfsd4_grace = nn->nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07003480}
3481
NeilBrownfd39ca92005-06-23 22:04:03 -07003482static time_t
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003483nfs4_laundromat(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484{
3485 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003486 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 struct nfs4_delegation *dp;
3488 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003489 time_t cutoff = get_seconds() - nn->nfsd4_lease;
Jeff Laytona832e7a2014-05-30 09:09:26 -04003490 time_t t, new_timeo = nn->nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491
3492 nfs4_lock_state();
3493
3494 dprintk("NFSD: laundromat service - starting\n");
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003495 nfsd4_end_grace(nn);
Benny Halevy36acb662010-05-12 00:13:04 +03003496 INIT_LIST_HEAD(&reaplist);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003497 spin_lock(&nn->client_lock);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03003498 list_for_each_safe(pos, next, &nn->client_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 clp = list_entry(pos, struct nfs4_client, cl_lru);
3500 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3501 t = clp->cl_time - cutoff;
Jeff Laytona832e7a2014-05-30 09:09:26 -04003502 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 break;
3504 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003505 if (mark_client_expired_locked(clp)) {
Benny Halevyd7682982010-05-12 00:13:54 +03003506 dprintk("NFSD: client in use (clientid %08x)\n",
3507 clp->cl_clientid.cl_id);
3508 continue;
3509 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003510 list_move(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03003511 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003512 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03003513 list_for_each_safe(pos, next, &reaplist) {
3514 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515 dprintk("NFSD: purging unused client (clientid %08x)\n",
3516 clp->cl_clientid.cl_id);
3517 expire_client(clp);
3518 }
Benny Halevycdc975052014-05-30 09:09:30 -04003519 spin_lock(&state_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04003520 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Stanislav Kinsbursky4e37a7c22012-11-26 15:22:03 +03003522 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3523 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
Jeff Laytona832e7a2014-05-30 09:09:26 -04003525 t = dp->dl_time - cutoff;
3526 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 break;
3528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003529 list_move(&dp->dl_recall_lru, &reaplist);
3530 }
Benny Halevycdc975052014-05-30 09:09:30 -04003531 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532 list_for_each_safe(pos, next, &reaplist) {
3533 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003534 revoke_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003535 }
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003536 list_for_each_safe(pos, next, &nn->close_lru) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003537 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3538 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
Jeff Laytona832e7a2014-05-30 09:09:26 -04003539 t = oo->oo_time - cutoff;
3540 new_timeo = min(new_timeo, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541 break;
3542 }
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003543 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544 }
Jeff Laytona832e7a2014-05-30 09:09:26 -04003545 new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 nfs4_unlock_state();
Jeff Laytona832e7a2014-05-30 09:09:26 -04003547 return new_timeo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548}
3549
Harvey Harrisona254b242008-02-20 12:49:00 -08003550static struct workqueue_struct *laundry_wq;
3551static void laundromat_main(struct work_struct *);
Harvey Harrisona254b242008-02-20 12:49:00 -08003552
3553static void
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003554laundromat_main(struct work_struct *laundry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555{
3556 time_t t;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003557 struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3558 work);
3559 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3560 laundromat_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003562 t = nfs4_laundromat(nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003564 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565}
3566
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003567static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07003568{
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003569 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3570 return nfserr_bad_stateid;
3571 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572}
3573
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003575access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003577 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3578 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3579 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580}
3581
3582static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003583access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003585 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3586 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003587}
3588
3589static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003590__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591{
Al Virob37ad282006-10-19 23:28:59 -07003592 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593
J. Bruce Fields02921912010-07-29 15:16:59 -04003594 /* For lock stateid's, we test the parent open, not the lock: */
3595 if (stp->st_openstp)
3596 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003597 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003598 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003599 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600 goto out;
3601 status = nfs_ok;
3602out:
3603 return status;
3604}
3605
Al Virob37ad282006-10-19 23:28:59 -07003606static inline __be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003607check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003609 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610 return nfs_ok;
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003611 else if (locks_in_grace(net)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003612 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613 * conflicting state; so we must wait out the grace period. */
3614 return nfserr_grace;
3615 } else if (flags & WR_STATE)
3616 return nfs4_share_conflict(current_fh,
3617 NFS4_SHARE_DENY_WRITE);
3618 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3619 return nfs4_share_conflict(current_fh,
3620 NFS4_SHARE_DENY_READ);
3621}
3622
3623/*
3624 * Allow READ/WRITE during grace period on recovered state only for files
3625 * that are not able to provide mandatory locking.
3626 */
3627static inline int
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003628grace_disallows_io(struct net *net, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629{
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003630 return locks_in_grace(net) && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003631}
3632
J. Bruce Fields81b82962011-08-23 11:03:29 -04003633/* Returns true iff a is later than b: */
3634static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3635{
Jim Rees1a9357f2013-05-17 17:33:00 -04003636 return (s32)(a->si_generation - b->si_generation) > 0;
J. Bruce Fields81b82962011-08-23 11:03:29 -04003637}
3638
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003639static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003640{
Andy Adamson66689582009-04-03 08:28:45 +03003641 /*
3642 * When sessions are used the stateid generation number is ignored
3643 * when it is zero.
3644 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04003645 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04003646 return nfs_ok;
3647
3648 if (in->si_generation == ref->si_generation)
3649 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03003650
J. Bruce Fields0836f582008-01-26 19:08:12 -05003651 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003652 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05003653 return nfserr_bad_stateid;
3654 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04003655 * However, we could see a stateid from the past, even from a
3656 * non-buggy client. For example, if the client sends a lock
3657 * while some IO is outstanding, the lock may bump si_generation
3658 * while the IO is still in flight. The client could avoid that
3659 * situation by waiting for responses on all the IO requests,
3660 * but better performance may result in retrying IO that
3661 * receives an old_stateid error if requests are rarely
3662 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003663 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003664 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003665}
3666
Chuck Lever7df302f2012-05-29 13:56:37 -04003667static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04003668{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003669 struct nfs4_stid *s;
3670 struct nfs4_ol_stateid *ols;
3671 __be32 status;
Bryan Schumaker17456802011-07-13 10:50:48 -04003672
Chuck Lever7df302f2012-05-29 13:56:37 -04003673 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3674 return nfserr_bad_stateid;
3675 /* Client debugging aid. */
3676 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3677 char addr_str[INET6_ADDRSTRLEN];
3678 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3679 sizeof(addr_str));
3680 pr_warn_ratelimited("NFSD: client %s testing state ID "
3681 "with incorrect client ID\n", addr_str);
3682 return nfserr_bad_stateid;
3683 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003684 s = find_stateid(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003685 if (!s)
Chuck Lever7df302f2012-05-29 13:56:37 -04003686 return nfserr_bad_stateid;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04003687 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04003688 if (status)
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003689 return status;
J. Bruce Fields23340032013-04-09 17:42:28 -04003690 switch (s->sc_type) {
3691 case NFS4_DELEG_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003692 return nfs_ok;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003693 case NFS4_REVOKED_DELEG_STID:
3694 return nfserr_deleg_revoked;
J. Bruce Fields23340032013-04-09 17:42:28 -04003695 case NFS4_OPEN_STID:
3696 case NFS4_LOCK_STID:
3697 ols = openlockstateid(s);
3698 if (ols->st_stateowner->so_is_open_owner
3699 && !(openowner(ols->st_stateowner)->oo_flags
3700 & NFS4_OO_CONFIRMED))
3701 return nfserr_bad_stateid;
3702 return nfs_ok;
3703 default:
3704 printk("unknown stateid type %x\n", s->sc_type);
3705 case NFS4_CLOSED_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003706 return nfserr_bad_stateid;
J. Bruce Fields23340032013-04-09 17:42:28 -04003707 }
Bryan Schumaker17456802011-07-13 10:50:48 -04003708}
3709
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003710static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
3711 struct nfs4_stid **s, bool sessions,
3712 struct nfsd_net *nn)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003713{
3714 struct nfs4_client *cl;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003715 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003716
3717 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3718 return nfserr_bad_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003719 status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
3720 nn, &cl);
Trond Myklebusta8a7c672014-03-29 14:43:38 -04003721 if (status == nfserr_stale_clientid) {
3722 if (sessions)
3723 return nfserr_bad_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003724 return nfserr_stale_stateid;
Trond Myklebusta8a7c672014-03-29 14:43:38 -04003725 }
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003726 if (status)
3727 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003728 *s = find_stateid_by_type(cl, stateid, typemask);
3729 if (!*s)
3730 return nfserr_bad_stateid;
3731 return nfs_ok;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003732}
3733
Linus Torvalds1da177e2005-04-16 15:20:36 -07003734/*
3735* Checks for stateid operations
3736*/
Al Virob37ad282006-10-19 23:28:59 -07003737__be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003738nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
Benny Halevydd453df2009-04-03 08:28:41 +03003739 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740{
J. Bruce Fields69064a22011-09-09 11:54:57 -04003741 struct nfs4_stid *s;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003742 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003744 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745 struct inode *ino = current_fh->fh_dentry->d_inode;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003746 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Trond Myklebust14bcab12014-04-18 14:44:07 -04003747 struct file *file = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003748 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750 if (filpp)
3751 *filpp = NULL;
3752
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003753 if (grace_disallows_io(net, ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 return nfserr_grace;
3755
3756 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003757 return check_special_stateids(net, current_fh, stateid, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003758
Trond Myklebust14bcab12014-04-18 14:44:07 -04003759 nfs4_lock_state();
3760
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003761 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3762 &s, cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003763 if (status)
Trond Myklebust14bcab12014-04-18 14:44:07 -04003764 goto out;
J. Bruce Fields69064a22011-09-09 11:54:57 -04003765 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3766 if (status)
3767 goto out;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003768 switch (s->sc_type) {
3769 case NFS4_DELEG_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003770 dp = delegstateid(s);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003771 status = nfs4_check_delegmode(dp, flags);
3772 if (status)
3773 goto out;
Dan Carpenter43b01782010-10-27 23:19:04 +02003774 if (filpp) {
Trond Myklebust14bcab12014-04-18 14:44:07 -04003775 file = dp->dl_file->fi_deleg_file;
3776 if (!file) {
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003777 WARN_ON_ONCE(1);
3778 status = nfserr_serverfault;
3779 goto out;
3780 }
Dan Carpenter43b01782010-10-27 23:19:04 +02003781 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003782 break;
3783 case NFS4_OPEN_STID:
3784 case NFS4_LOCK_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003785 stp = openlockstateid(s);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003786 status = nfs4_check_fh(current_fh, stp);
3787 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003789 if (stp->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003790 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003792 status = nfs4_check_openmode(stp, flags);
3793 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003794 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003795 if (filpp) {
3796 if (flags & RD_STATE)
Trond Myklebust14bcab12014-04-18 14:44:07 -04003797 file = find_readable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003798 else
Trond Myklebust14bcab12014-04-18 14:44:07 -04003799 file = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003800 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003801 break;
3802 default:
Trond Myklebust14bcab12014-04-18 14:44:07 -04003803 status = nfserr_bad_stateid;
3804 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003805 }
3806 status = nfs_ok;
Trond Myklebust14bcab12014-04-18 14:44:07 -04003807 if (file)
3808 *filpp = get_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809out:
Trond Myklebust14bcab12014-04-18 14:44:07 -04003810 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811 return status;
3812}
3813
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003814static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003815nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003816{
J. Bruce Fieldsa1b8ff42014-05-20 15:55:21 -04003817 struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
3818
3819 if (check_for_locks(stp->st_file, lo))
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003820 return nfserr_locks_held;
J. Bruce Fieldsa1b8ff42014-05-20 15:55:21 -04003821 /*
3822 * Currently there's a 1-1 lock stateid<->lockowner
3823 * correspondance, and we have to delete the lockowner when we
3824 * delete the lock stateid:
3825 */
J. Bruce Fields48385402014-05-27 11:14:26 -04003826 release_lockowner(lo);
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003827 return nfs_ok;
3828}
3829
3830/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003831 * Test if the stateid is valid
3832 */
3833__be32
3834nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3835 struct nfsd4_test_stateid *test_stateid)
3836{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003837 struct nfsd4_test_stateid_id *stateid;
3838 struct nfs4_client *cl = cstate->session->se_client;
3839
3840 nfs4_lock_state();
3841 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
Chuck Lever7df302f2012-05-29 13:56:37 -04003842 stateid->ts_id_status =
3843 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003844 nfs4_unlock_state();
3845
Bryan Schumaker17456802011-07-13 10:50:48 -04003846 return nfs_ok;
3847}
3848
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003849__be32
3850nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3851 struct nfsd4_free_stateid *free_stateid)
3852{
3853 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003854 struct nfs4_stid *s;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003855 struct nfs4_delegation *dp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003856 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003857 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003858
3859 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003860 s = find_stateid(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003861 if (!s)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003862 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003863 switch (s->sc_type) {
3864 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003865 ret = nfserr_locks_held;
3866 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003867 case NFS4_OPEN_STID:
3868 case NFS4_LOCK_STID:
3869 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3870 if (ret)
3871 goto out;
3872 if (s->sc_type == NFS4_LOCK_STID)
3873 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3874 else
3875 ret = nfserr_locks_held;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003876 break;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003877 case NFS4_REVOKED_DELEG_STID:
3878 dp = delegstateid(s);
3879 destroy_revoked_delegation(dp);
3880 ret = nfs_ok;
3881 break;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003882 default:
3883 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003884 }
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003885out:
3886 nfs4_unlock_state();
3887 return ret;
3888}
3889
NeilBrown4c4cd222005-07-07 17:59:27 -07003890static inline int
3891setlkflg (int type)
3892{
3893 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3894 RD_STATE : WR_STATE;
3895}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003897static __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 -04003898{
3899 struct svc_fh *current_fh = &cstate->current_fh;
3900 struct nfs4_stateowner *sop = stp->st_stateowner;
3901 __be32 status;
3902
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003903 status = nfsd4_check_seqid(cstate, sop, seqid);
3904 if (status)
3905 return status;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003906 if (stp->st_stid.sc_type == NFS4_CLOSED_STID
3907 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003908 /*
3909 * "Closed" stateid's exist *only* to return
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003910 * nfserr_replay_me from the previous step, and
3911 * revoked delegations are kept only for free_stateid.
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003912 */
3913 return nfserr_bad_stateid;
3914 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3915 if (status)
3916 return status;
3917 return nfs4_check_fh(current_fh, stp);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003918}
3919
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920/*
3921 * Checks for sequence id mutating operations.
3922 */
Al Virob37ad282006-10-19 23:28:59 -07003923static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003924nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003925 stateid_t *stateid, char typemask,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003926 struct nfs4_ol_stateid **stpp,
3927 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928{
J. Bruce Fields0836f582008-01-26 19:08:12 -05003929 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003930 struct nfs4_stid *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003931
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003932 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3933 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003934
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935 *stpp = NULL;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003936 status = nfsd4_lookup_stateid(stateid, typemask, &s,
3937 cstate->minorversion, nn);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003938 if (status)
3939 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003940 *stpp = openlockstateid(s);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04003941 if (!nfsd4_has_session(cstate))
3942 cstate->replay_owner = (*stpp)->st_stateowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003943
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003944 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3945}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003946
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003947static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3948 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003949{
3950 __be32 status;
3951 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003953 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003954 NFS4_OPEN_STID, stpp, nn);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003955 if (status)
3956 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003957 oo = openowner((*stpp)->st_stateowner);
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003958 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003959 return nfserr_bad_stateid;
NeilBrown3a4f98b2005-07-07 17:59:26 -07003960 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961}
3962
Al Virob37ad282006-10-19 23:28:59 -07003963__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003964nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003965 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003966{
Al Virob37ad282006-10-19 23:28:59 -07003967 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003968 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003969 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003970 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003971
Al Viroa6a9f182013-09-16 10:57:01 -04003972 dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
3973 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003974
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003975 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003976 if (status)
3977 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978
3979 nfs4_lock_state();
3980
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003981 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003982 oc->oc_seqid, &oc->oc_req_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003983 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003984 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003985 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003986 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003987 status = nfserr_bad_stateid;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003988 if (oo->oo_flags & NFS4_OO_CONFIRMED)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003989 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003990 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003991 update_stateid(&stp->st_stid.sc_stateid);
3992 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003993 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003994 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003995
Jeff Layton2a4317c2012-03-21 16:42:43 -04003996 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003997 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003998out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003999 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004000 if (!cstate->replay_owner)
4001 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002 return status;
4003}
4004
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04004005static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006{
Jeff Layton82c5ff12012-05-11 09:45:13 -04004007 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04004008 return;
4009 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
Jeff Layton82c5ff12012-05-11 09:45:13 -04004010 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04004011}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04004012
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04004013static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
4014{
4015 switch (to_access) {
4016 case NFS4_SHARE_ACCESS_READ:
4017 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
4018 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
4019 break;
4020 case NFS4_SHARE_ACCESS_WRITE:
4021 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
4022 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
4023 break;
4024 case NFS4_SHARE_ACCESS_BOTH:
4025 break;
4026 default:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004027 WARN_ON_ONCE(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004028 }
4029}
4030
4031static void
Jeff Laytonce0fc432012-05-11 09:45:14 -04004032reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004033{
4034 int i;
4035 for (i = 0; i < 4; i++) {
4036 if ((i & deny) != i)
Jeff Laytonce0fc432012-05-11 09:45:14 -04004037 clear_deny(i, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038 }
4039}
4040
Al Virob37ad282006-10-19 23:28:59 -07004041__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004042nfsd4_open_downgrade(struct svc_rqst *rqstp,
4043 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004044 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045{
Al Virob37ad282006-10-19 23:28:59 -07004046 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004047 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004048 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004049
Al Viroa6a9f182013-09-16 10:57:01 -04004050 dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
4051 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004052
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04004053 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02004054 if (od->od_deleg_want)
4055 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
4056 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004057
4058 nfs4_lock_state();
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004059 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004060 &od->od_stateid, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004061 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004062 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04004064 if (!test_access(od->od_share_access, stp)) {
4065 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004066 stp->st_access_bmap, od->od_share_access);
4067 goto out;
4068 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04004069 if (!test_deny(od->od_share_deny, stp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
4071 stp->st_deny_bmap, od->od_share_deny);
4072 goto out;
4073 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04004074 nfs4_stateid_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004075
Jeff Laytonce0fc432012-05-11 09:45:14 -04004076 reset_union_bmap_deny(od->od_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004078 update_stateid(&stp->st_stid.sc_stateid);
4079 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004080 status = nfs_ok;
4081out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004082 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004083 if (!cstate->replay_owner)
4084 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085 return status;
4086}
4087
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004088static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
4089{
4090 unhash_open_stateid(s);
4091 s->st_stid.sc_type = NFS4_CLOSED_STID;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04004092}
4093
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094/*
4095 * nfs4_unlock_state() called after encode
4096 */
Al Virob37ad282006-10-19 23:28:59 -07004097__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004098nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004099 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100{
Al Virob37ad282006-10-19 23:28:59 -07004101 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004102 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004103 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004104 struct net *net = SVC_NET(rqstp);
4105 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106
Al Viroa6a9f182013-09-16 10:57:01 -04004107 dprintk("NFSD: nfsd4_close on file %pd\n",
4108 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004109
4110 nfs4_lock_state();
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004111 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
4112 &close->cl_stateid,
4113 NFS4_OPEN_STID|NFS4_CLOSED_STID,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004114 &stp, nn);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004115 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004116 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004118 oo = openowner(stp->st_stateowner);
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004119 update_stateid(&stp->st_stid.sc_stateid);
4120 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004121
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004122 nfsd4_close_open_stateid(stp);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004123
Benny Halevy01a87d92013-10-14 09:01:55 +03004124 if (cstate->minorversion)
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004125 free_generic_stateid(stp);
Benny Halevy01a87d92013-10-14 09:01:55 +03004126 else
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004127 oo->oo_last_closed_stid = stp;
J. Bruce Fields04ef5952006-01-18 17:43:21 -08004128
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004129 if (list_empty(&oo->oo_owner.so_stateids)) {
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04004130 if (cstate->minorversion)
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004131 release_openowner(oo);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04004132 else {
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004133 /*
4134 * In the 4.0 case we need to keep the owners around a
4135 * little while to handle CLOSE replay.
4136 */
fanchaoting53584f62013-04-11 21:24:13 +08004137 move_to_close_lru(oo, SVC_NET(rqstp));
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004138 }
4139 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004140out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004141 if (!cstate->replay_owner)
4142 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004143 return status;
4144}
4145
Al Virob37ad282006-10-19 23:28:59 -07004146__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004147nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4148 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004149{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004150 struct nfs4_delegation *dp;
4151 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004152 struct nfs4_stid *s;
Al Virob37ad282006-10-19 23:28:59 -07004153 __be32 status;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004154 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004155
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004156 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004157 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004158
4159 nfs4_lock_state();
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004160 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
4161 cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004162 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004163 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004164 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04004165 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004166 if (status)
4167 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004168
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004169 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004171 nfs4_unlock_state();
4172
Linus Torvalds1da177e2005-04-16 15:20:36 -07004173 return status;
4174}
4175
4176
Linus Torvalds1da177e2005-04-16 15:20:36 -07004177#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004178
J. Bruce Fields009673b2011-11-07 17:40:10 -05004179#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004180
Benny Halevy87df4de2008-12-15 19:42:03 +02004181static inline u64
4182end_offset(u64 start, u64 len)
4183{
4184 u64 end;
4185
4186 end = start + len;
4187 return end >= start ? end: NFS4_MAX_UINT64;
4188}
4189
4190/* last octet in a range */
4191static inline u64
4192last_byte_offset(u64 start, u64 len)
4193{
4194 u64 end;
4195
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004196 WARN_ON_ONCE(!len);
Benny Halevy87df4de2008-12-15 19:42:03 +02004197 end = start + len;
4198 return end > start ? end - 1: NFS4_MAX_UINT64;
4199}
4200
J. Bruce Fields009673b2011-11-07 17:40:10 -05004201static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202{
4203 return (file_hashval(inode) + cl_id
4204 + opaque_hashval(ownername->data, ownername->len))
J. Bruce Fields009673b2011-11-07 17:40:10 -05004205 & LOCKOWNER_INO_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004206}
4207
Linus Torvalds1da177e2005-04-16 15:20:36 -07004208/*
4209 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
4210 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
4211 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
4212 * locking, this prevents us from being completely protocol-compliant. The
4213 * real solution to this problem is to start using unsigned file offsets in
4214 * the VFS, but this is a very deep change!
4215 */
4216static inline void
4217nfs4_transform_lock_offset(struct file_lock *lock)
4218{
4219 if (lock->fl_start < 0)
4220 lock->fl_start = OFFSET_MAX;
4221 if (lock->fl_end < 0)
4222 lock->fl_end = OFFSET_MAX;
4223}
4224
NeilBrownd5b90262006-04-10 22:55:22 -07004225/* Hack!: For now, we're defining this just so we can use a pointer to it
4226 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07004227static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07004228};
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229
4230static inline void
4231nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
4232{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004233 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004234
NeilBrownd5b90262006-04-10 22:55:22 -07004235 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004236 lo = (struct nfs4_lockowner *) fl->fl_owner;
4237 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
4238 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004239 if (!deny->ld_owner.data)
4240 /* We just don't care that much */
4241 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004242 deny->ld_owner.len = lo->lo_owner.so_owner.len;
4243 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07004244 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004245nevermind:
4246 deny->ld_owner.len = 0;
4247 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07004248 deny->ld_clientid.cl_boot = 0;
4249 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004250 }
4251 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02004252 deny->ld_length = NFS4_MAX_UINT64;
4253 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004254 deny->ld_length = fl->fl_end - fl->fl_start + 1;
4255 deny->ld_type = NFS4_READ_LT;
4256 if (fl->fl_type != F_RDLCK)
4257 deny->ld_type = NFS4_WRITE_LT;
4258}
4259
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004260static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
4261{
4262 struct nfs4_ol_stateid *lst;
4263
4264 if (!same_owner_str(&lo->lo_owner, owner, clid))
4265 return false;
J. Bruce Fields27b11422014-05-08 11:19:41 -04004266 if (list_empty(&lo->lo_owner.so_stateids)) {
4267 WARN_ON_ONCE(1);
4268 return false;
4269 }
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004270 lst = list_first_entry(&lo->lo_owner.so_stateids,
4271 struct nfs4_ol_stateid, st_perstateowner);
4272 return lst->st_file->fi_inode == inode;
4273}
4274
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004275static struct nfs4_lockowner *
4276find_lockowner_str(struct inode *inode, clientid_t *clid,
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004277 struct xdr_netobj *owner, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004278{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004279 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004280 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004281
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004282 list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004283 if (same_lockowner_ino(lo, inode, clid, owner))
4284 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004285 }
4286 return NULL;
4287}
4288
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004289static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04004290{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004291 struct inode *inode = open_stp->st_file->fi_inode;
4292 unsigned int inohash = lockowner_ino_hashval(inode,
4293 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004294 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
J. Bruce Fields009673b2011-11-07 17:40:10 -05004295
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004296 list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004297 list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004298 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04004299}
4300
Linus Torvalds1da177e2005-04-16 15:20:36 -07004301/*
4302 * Alloc a lock owner structure.
4303 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004304 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004305 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004306 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307 */
4308
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004309static struct nfs4_lockowner *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004310alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004311 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004312
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004313 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4314 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004315 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004316 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4317 lo->lo_owner.so_is_open_owner = 0;
Neil Brownb59e3c02005-09-13 01:25:38 -07004318 /* It is the openowner seqid that will be incremented in encode in the
4319 * case of new lockowners; so increment the lock seqid manually: */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004320 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4321 hash_lockowner(lo, strhashval, clp, open_stp);
4322 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004323}
4324
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004325static struct nfs4_ol_stateid *
4326alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004327{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004328 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04004329 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004330
J. Bruce Fields996e0932011-10-17 11:14:48 -04004331 stp = nfs4_alloc_stateid(clp);
NeilBrown5ac049a2005-06-23 22:03:03 -07004332 if (stp == NULL)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -04004333 return NULL;
J. Bruce Fields3abdb602013-02-03 12:23:01 -05004334 stp->st_stid.sc_type = NFS4_LOCK_STID;
NeilBrown8beefa22005-06-23 22:03:08 -07004335 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004336 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4337 stp->st_stateowner = &lo->lo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07004338 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339 stp->st_file = fp;
J. Bruce Fields0997b172011-03-02 18:01:35 -05004340 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004341 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07004342 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004343 return stp;
4344}
4345
NeilBrownfd39ca92005-06-23 22:04:03 -07004346static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347check_lock_length(u64 offset, u64 length)
4348{
Benny Halevy87df4de2008-12-15 19:42:03 +02004349 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350 LOFF_OVERFLOW(offset, length)));
4351}
4352
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004353static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05004354{
4355 struct nfs4_file *fp = lock_stp->st_file;
4356 int oflag = nfs4_access_to_omode(access);
4357
Jeff Layton82c5ff12012-05-11 09:45:13 -04004358 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05004359 return;
4360 nfs4_file_get_access(fp, oflag);
Jeff Layton82c5ff12012-05-11 09:45:13 -04004361 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05004362}
4363
J. Bruce Fields2355c592012-04-25 16:56:22 -04004364static __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004365{
4366 struct nfs4_file *fi = ost->st_file;
4367 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4368 struct nfs4_client *cl = oo->oo_owner.so_client;
4369 struct nfs4_lockowner *lo;
4370 unsigned int strhashval;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004371 struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004372
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004373 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
4374 &lock->v.new.owner, nn);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004375 if (lo) {
4376 if (!cstate->minorversion)
4377 return nfserr_bad_seqid;
4378 /* XXX: a lockowner always has exactly one stateid: */
4379 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4380 struct nfs4_ol_stateid, st_perstateowner);
4381 return nfs_ok;
4382 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004383 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004384 &lock->v.new.owner);
4385 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4386 if (lo == NULL)
4387 return nfserr_jukebox;
4388 *lst = alloc_init_lock_stateid(lo, fi, ost);
4389 if (*lst == NULL) {
4390 release_lockowner(lo);
4391 return nfserr_jukebox;
4392 }
4393 *new = true;
4394 return nfs_ok;
4395}
4396
Linus Torvalds1da177e2005-04-16 15:20:36 -07004397/*
4398 * LOCK operation
4399 */
Al Virob37ad282006-10-19 23:28:59 -07004400__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004401nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004402 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004403{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004404 struct nfs4_openowner *open_sop = NULL;
4405 struct nfs4_lockowner *lock_sop = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004406 struct nfs4_ol_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004407 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004408 struct file_lock *file_lock = NULL;
4409 struct file_lock *conflock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004410 __be32 status = 0;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004411 bool new_state = false;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004412 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07004413 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004414 struct net *net = SVC_NET(rqstp);
4415 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004416
4417 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4418 (long long) lock->lk_offset,
4419 (long long) lock->lk_length);
4420
Linus Torvalds1da177e2005-04-16 15:20:36 -07004421 if (check_lock_length(lock->lk_offset, lock->lk_length))
4422 return nfserr_inval;
4423
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004424 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004425 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004426 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4427 return status;
4428 }
4429
Linus Torvalds1da177e2005-04-16 15:20:36 -07004430 nfs4_lock_state();
4431
4432 if (lock->lk_is_new) {
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004433 struct nfs4_ol_stateid *open_stp = NULL;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004434
4435 if (nfsd4_has_session(cstate))
4436 /* See rfc 5661 18.10.3: given clientid is ignored: */
4437 memcpy(&lock->v.new.clientid,
4438 &cstate->session->se_client->cl_clientid,
4439 sizeof(clientid_t));
4440
Linus Torvalds1da177e2005-04-16 15:20:36 -07004441 status = nfserr_stale_clientid;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004442 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444
Linus Torvalds1da177e2005-04-16 15:20:36 -07004445 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004446 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004447 lock->lk_new_open_seqid,
4448 &lock->lk_new_open_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004449 &open_stp, nn);
NeilBrown37515172005-07-07 17:59:16 -07004450 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004451 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004452 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004453 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004454 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004455 &lock->v.new.clientid))
4456 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004457 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4458 &lock_stp, &new_state);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004459 } else
Benny Halevydd453df2009-04-03 08:28:41 +03004460 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004461 lock->lk_old_lock_seqid,
4462 &lock->lk_old_lock_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004463 NFS4_LOCK_STID, &lock_stp, nn);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004464 if (status)
4465 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004466 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004468 lkflg = setlkflg(lock->lk_type);
4469 status = nfs4_check_openmode(lock_stp, lkflg);
4470 if (status)
4471 goto out;
4472
NeilBrown0dd395d2005-07-07 17:59:15 -07004473 status = nfserr_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004474 if (locks_in_grace(net) && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004475 goto out;
4476 status = nfserr_no_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004477 if (!locks_in_grace(net) && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004478 goto out;
4479
Jeff Layton21179d82012-08-21 08:03:32 -04004480 file_lock = locks_alloc_lock();
4481 if (!file_lock) {
4482 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4483 status = nfserr_jukebox;
4484 goto out;
4485 }
4486
4487 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488 switch (lock->lk_type) {
4489 case NFS4_READ_LT:
4490 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004491 filp = find_readable_file(lock_stp->st_file);
4492 if (filp)
4493 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Jeff Layton21179d82012-08-21 08:03:32 -04004494 file_lock->fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004495 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496 case NFS4_WRITE_LT:
4497 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004498 filp = find_writeable_file(lock_stp->st_file);
4499 if (filp)
4500 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Jeff Layton21179d82012-08-21 08:03:32 -04004501 file_lock->fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004502 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004503 default:
4504 status = nfserr_inval;
4505 goto out;
4506 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004507 if (!filp) {
4508 status = nfserr_openmode;
4509 goto out;
4510 }
Jeff Layton21179d82012-08-21 08:03:32 -04004511 file_lock->fl_owner = (fl_owner_t)lock_sop;
4512 file_lock->fl_pid = current->tgid;
4513 file_lock->fl_file = filp;
4514 file_lock->fl_flags = FL_POSIX;
4515 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4516 file_lock->fl_start = lock->lk_offset;
4517 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4518 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004519
Jeff Layton21179d82012-08-21 08:03:32 -04004520 conflock = locks_alloc_lock();
4521 if (!conflock) {
4522 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4523 status = nfserr_jukebox;
4524 goto out;
4525 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004526
Jeff Layton21179d82012-08-21 08:03:32 -04004527 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004528 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529 case 0: /* success! */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004530 update_stateid(&lock_stp->st_stid.sc_stateid);
4531 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004533 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004534 break;
4535 case (EAGAIN): /* conflock holds conflicting lock */
4536 status = nfserr_denied;
4537 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
Jeff Layton21179d82012-08-21 08:03:32 -04004538 nfs4_set_lock_denied(conflock, &lock->lk_denied);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004539 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004540 case (EDEADLK):
4541 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004542 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04004543 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004544 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04004545 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004546 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004548out:
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004549 if (status && new_state)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004550 release_lockowner(lock_sop);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004551 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004552 if (!cstate->replay_owner)
4553 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004554 if (file_lock)
4555 locks_free_lock(file_lock);
4556 if (conflock)
4557 locks_free_lock(conflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004558 return status;
4559}
4560
4561/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004562 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4563 * so we do a temporary open here just to get an open file to pass to
4564 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4565 * inode operation.)
4566 */
Al Viro04da6e92012-04-13 00:00:04 -04004567static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004568{
4569 struct file *file;
Al Viro04da6e92012-04-13 00:00:04 -04004570 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4571 if (!err) {
4572 err = nfserrno(vfs_test_lock(file, lock));
4573 nfsd_close(file);
4574 }
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004575 return err;
4576}
4577
4578/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004579 * LOCKT operation
4580 */
Al Virob37ad282006-10-19 23:28:59 -07004581__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004582nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4583 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004584{
4585 struct inode *inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004586 struct file_lock *file_lock = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004587 struct nfs4_lockowner *lo;
Al Virob37ad282006-10-19 23:28:59 -07004588 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004589 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004590
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004591 if (locks_in_grace(SVC_NET(rqstp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592 return nfserr_grace;
4593
4594 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4595 return nfserr_inval;
4596
Linus Torvalds1da177e2005-04-16 15:20:36 -07004597 nfs4_lock_state();
4598
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004599 if (!nfsd4_has_session(cstate)) {
4600 status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
4601 if (status)
4602 goto out;
4603 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004604
J. Bruce Fields75c096f2011-08-15 18:39:32 -04004605 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004607
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004608 inode = cstate->current_fh.fh_dentry->d_inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004609 file_lock = locks_alloc_lock();
4610 if (!file_lock) {
4611 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4612 status = nfserr_jukebox;
4613 goto out;
4614 }
4615 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004616 switch (lockt->lt_type) {
4617 case NFS4_READ_LT:
4618 case NFS4_READW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004619 file_lock->fl_type = F_RDLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004620 break;
4621 case NFS4_WRITE_LT:
4622 case NFS4_WRITEW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004623 file_lock->fl_type = F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004624 break;
4625 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004626 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004627 status = nfserr_inval;
4628 goto out;
4629 }
4630
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004631 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004632 if (lo)
Jeff Layton21179d82012-08-21 08:03:32 -04004633 file_lock->fl_owner = (fl_owner_t)lo;
4634 file_lock->fl_pid = current->tgid;
4635 file_lock->fl_flags = FL_POSIX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636
Jeff Layton21179d82012-08-21 08:03:32 -04004637 file_lock->fl_start = lockt->lt_offset;
4638 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004639
Jeff Layton21179d82012-08-21 08:03:32 -04004640 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004641
Jeff Layton21179d82012-08-21 08:03:32 -04004642 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
Al Viro04da6e92012-04-13 00:00:04 -04004643 if (status)
Marc Eshelfd85b812006-11-28 16:26:41 -05004644 goto out;
Al Viro04da6e92012-04-13 00:00:04 -04004645
Jeff Layton21179d82012-08-21 08:03:32 -04004646 if (file_lock->fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004647 status = nfserr_denied;
Jeff Layton21179d82012-08-21 08:03:32 -04004648 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004649 }
4650out:
4651 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004652 if (file_lock)
4653 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004654 return status;
4655}
4656
Al Virob37ad282006-10-19 23:28:59 -07004657__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004658nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004659 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004660{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004661 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004662 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004663 struct file_lock *file_lock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004664 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004665 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004666 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4667
Linus Torvalds1da177e2005-04-16 15:20:36 -07004668 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4669 (long long) locku->lu_offset,
4670 (long long) locku->lu_length);
4671
4672 if (check_lock_length(locku->lu_offset, locku->lu_length))
4673 return nfserr_inval;
4674
4675 nfs4_lock_state();
4676
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004677 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004678 &locku->lu_stateid, NFS4_LOCK_STID,
4679 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004680 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004681 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004682 filp = find_any_file(stp->st_file);
4683 if (!filp) {
4684 status = nfserr_lock_range;
4685 goto out;
4686 }
Jeff Layton21179d82012-08-21 08:03:32 -04004687 file_lock = locks_alloc_lock();
4688 if (!file_lock) {
4689 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4690 status = nfserr_jukebox;
4691 goto out;
4692 }
4693 locks_init_lock(file_lock);
4694 file_lock->fl_type = F_UNLCK;
J. Bruce Fields0a262ff2013-06-17 17:29:40 -04004695 file_lock->fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
Jeff Layton21179d82012-08-21 08:03:32 -04004696 file_lock->fl_pid = current->tgid;
4697 file_lock->fl_file = filp;
4698 file_lock->fl_flags = FL_POSIX;
4699 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4700 file_lock->fl_start = locku->lu_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004701
Jeff Layton21179d82012-08-21 08:03:32 -04004702 file_lock->fl_end = last_byte_offset(locku->lu_offset,
4703 locku->lu_length);
4704 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004705
Jeff Layton21179d82012-08-21 08:03:32 -04004706 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004707 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004708 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004709 goto out_nfserr;
4710 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004711 update_stateid(&stp->st_stid.sc_stateid);
4712 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004713
4714out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004715 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields71c3bcd2011-09-27 21:42:29 -04004716 if (!cstate->replay_owner)
4717 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004718 if (file_lock)
4719 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004720 return status;
4721
4722out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004723 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724 goto out;
4725}
4726
4727/*
4728 * returns
4729 * 1: locks held by lockowner
4730 * 0: no locks held by lockowner
4731 */
4732static int
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004733check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004734{
4735 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004736 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737 int status = 0;
4738
Jeff Layton1c8c6012013-06-21 08:58:15 -04004739 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004740 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004741 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004742 status = 1;
4743 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004744 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004745 }
4746out:
Jeff Layton1c8c6012013-06-21 08:58:15 -04004747 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004748 return status;
4749}
4750
Al Virob37ad282006-10-19 23:28:59 -07004751__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004752nfsd4_release_lockowner(struct svc_rqst *rqstp,
4753 struct nfsd4_compound_state *cstate,
4754 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755{
4756 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004757 struct nfs4_stateowner *sop;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004758 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004759 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004760 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004761 struct list_head matches;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004762 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
Al Virob37ad282006-10-19 23:28:59 -07004763 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004764 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004765
4766 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4767 clid->cl_boot, clid->cl_id);
4768
Linus Torvalds1da177e2005-04-16 15:20:36 -07004769 nfs4_lock_state();
4770
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004771 status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
4772 if (status)
4773 goto out;
4774
NeilBrown3e9e3db2005-06-23 22:04:20 -07004775 status = nfserr_locks_held;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004776 INIT_LIST_HEAD(&matches);
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004777
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004778 list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004779 if (sop->so_is_open_owner)
4780 continue;
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004781 if (!same_owner_str(sop, owner, clid))
4782 continue;
4783 list_for_each_entry(stp, &sop->so_stateids,
4784 st_perstateowner) {
4785 lo = lockowner(sop);
4786 if (check_for_locks(stp->st_file, lo))
4787 goto out;
4788 list_add(&lo->lo_list, &matches);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004790 }
4791 /* Clients probably won't expect us to return with some (but not all)
4792 * of the lockowner state released; so don't release any until all
4793 * have been checked. */
4794 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004795 while (!list_empty(&matches)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004796 lo = list_entry(matches.next, struct nfs4_lockowner,
4797 lo_list);
NeilBrown0fa822e2005-07-07 17:59:14 -07004798 /* unhash_stateowner deletes so_perclient only
4799 * for openowners. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004800 list_del(&lo->lo_list);
4801 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004802 }
4803out:
4804 nfs4_unlock_state();
4805 return status;
4806}
4807
4808static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004809alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004810{
NeilBrowna55370a2005-06-23 22:03:52 -07004811 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004812}
4813
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004814bool
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004815nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
NeilBrownc7b9a452005-06-23 22:04:30 -07004816{
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004817 struct nfs4_client_reclaim *crp;
NeilBrownc7b9a452005-06-23 22:04:30 -07004818
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004819 crp = nfsd4_find_reclaim_client(name, nn);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004820 return (crp && crp->cr_clp);
NeilBrownc7b9a452005-06-23 22:04:30 -07004821}
4822
Linus Torvalds1da177e2005-04-16 15:20:36 -07004823/*
4824 * failure => all reset bets are off, nfserr_no_grace...
4825 */
Jeff Layton772a9bb2012-11-12 15:00:54 -05004826struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004827nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004828{
4829 unsigned int strhashval;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004830 struct nfs4_client_reclaim *crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004831
NeilBrowna55370a2005-06-23 22:03:52 -07004832 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4833 crp = alloc_reclaim();
Jeff Layton772a9bb2012-11-12 15:00:54 -05004834 if (crp) {
4835 strhashval = clientstr_hashval(name);
4836 INIT_LIST_HEAD(&crp->cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004837 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
Jeff Layton772a9bb2012-11-12 15:00:54 -05004838 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004839 crp->cr_clp = NULL;
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004840 nn->reclaim_str_hashtbl_size++;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004841 }
4842 return crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004843}
4844
Jeff Layton2a4317c2012-03-21 16:42:43 -04004845void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004846nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
Jeff Laytonce30e532012-11-12 15:00:53 -05004847{
4848 list_del(&crp->cr_strhash);
4849 kfree(crp);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004850 nn->reclaim_str_hashtbl_size--;
Jeff Laytonce30e532012-11-12 15:00:53 -05004851}
4852
4853void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004854nfs4_release_reclaim(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004855{
4856 struct nfs4_client_reclaim *crp = NULL;
4857 int i;
4858
Linus Torvalds1da177e2005-04-16 15:20:36 -07004859 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004860 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
4861 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004862 struct nfs4_client_reclaim, cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004863 nfs4_remove_reclaim_record(crp, nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004864 }
4865 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004866 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004867}
4868
4869/*
4870 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04004871struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004872nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004873{
4874 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004875 struct nfs4_client_reclaim *crp = NULL;
4876
Jeff Layton278c9312012-11-12 15:00:52 -05004877 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004878
Jeff Layton278c9312012-11-12 15:00:52 -05004879 strhashval = clientstr_hashval(recdir);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004880 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
Jeff Layton278c9312012-11-12 15:00:52 -05004881 if (same_name(crp->cr_recdir, recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004882 return crp;
4883 }
4884 }
4885 return NULL;
4886}
4887
4888/*
4889* Called from OPEN. Look for clientid in reclaim list.
4890*/
Al Virob37ad282006-10-19 23:28:59 -07004891__be32
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004892nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004893{
Jeff Laytona52d7262012-03-21 09:52:02 -04004894 struct nfs4_client *clp;
4895
4896 /* find clientid in conf_id_hashtbl */
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004897 clp = find_confirmed_client(clid, sessions, nn);
Jeff Laytona52d7262012-03-21 09:52:02 -04004898 if (clp == NULL)
4899 return nfserr_reclaim_bad;
4900
4901 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004902}
4903
Bryan Schumaker65178db2011-11-01 13:35:21 -04004904#ifdef CONFIG_NFSD_FAULT_INJECTION
4905
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004906u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
4907{
J. Bruce Fields221a6872013-04-01 22:23:49 -04004908 if (mark_client_expired(clp))
4909 return 0;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004910 expire_client(clp);
4911 return 1;
4912}
4913
Bryan Schumaker184c1842012-11-29 11:40:44 -05004914u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
4915{
4916 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004917 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004918 printk(KERN_INFO "NFS Client: %s\n", buf);
4919 return 1;
4920}
4921
4922static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
4923 const char *type)
4924{
4925 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004926 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004927 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
4928}
4929
Bryan Schumakerfc291712012-11-29 11:40:40 -05004930static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
4931{
4932 struct nfs4_openowner *oop;
4933 struct nfs4_lockowner *lop, *lo_next;
4934 struct nfs4_ol_stateid *stp, *st_next;
4935 u64 count = 0;
4936
4937 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
4938 list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
4939 list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
4940 if (func)
4941 func(lop);
4942 if (++count == max)
4943 return count;
4944 }
4945 }
4946 }
4947
4948 return count;
4949}
4950
4951u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
4952{
4953 return nfsd_foreach_client_lock(clp, max, release_lockowner);
4954}
4955
Bryan Schumaker184c1842012-11-29 11:40:44 -05004956u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
4957{
4958 u64 count = nfsd_foreach_client_lock(clp, max, NULL);
4959 nfsd_print_count(clp, count, "locked files");
4960 return count;
4961}
4962
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05004963static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
4964{
4965 struct nfs4_openowner *oop, *next;
4966 u64 count = 0;
4967
4968 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
4969 if (func)
4970 func(oop);
4971 if (++count == max)
4972 break;
4973 }
4974
4975 return count;
4976}
4977
4978u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
4979{
4980 return nfsd_foreach_client_open(clp, max, release_openowner);
4981}
4982
Bryan Schumaker184c1842012-11-29 11:40:44 -05004983u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
4984{
4985 u64 count = nfsd_foreach_client_open(clp, max, NULL);
4986 nfsd_print_count(clp, count, "open files");
4987 return count;
4988}
4989
Bryan Schumaker269de302012-11-29 11:40:42 -05004990static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
4991 struct list_head *victims)
4992{
4993 struct nfs4_delegation *dp, *next;
4994 u64 count = 0;
4995
Benny Halevycdc975052014-05-30 09:09:30 -04004996 lockdep_assert_held(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05004997 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
4998 if (victims)
4999 list_move(&dp->dl_recall_lru, victims);
5000 if (++count == max)
5001 break;
5002 }
5003 return count;
5004}
5005
5006u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
5007{
5008 struct nfs4_delegation *dp, *next;
5009 LIST_HEAD(victims);
5010 u64 count;
5011
Benny Halevycdc975052014-05-30 09:09:30 -04005012 spin_lock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05005013 count = nfsd_find_all_delegations(clp, max, &victims);
Benny Halevycdc975052014-05-30 09:09:30 -04005014 spin_unlock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05005015
5016 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04005017 revoke_delegation(dp);
Bryan Schumaker269de302012-11-29 11:40:42 -05005018
5019 return count;
5020}
5021
5022u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
5023{
5024 struct nfs4_delegation *dp, *next;
5025 LIST_HEAD(victims);
5026 u64 count;
5027
Benny Halevycdc975052014-05-30 09:09:30 -04005028 spin_lock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05005029 count = nfsd_find_all_delegations(clp, max, &victims);
5030 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
5031 nfsd_break_one_deleg(dp);
Benny Halevycdc975052014-05-30 09:09:30 -04005032 spin_unlock(&state_lock);
Bryan Schumaker269de302012-11-29 11:40:42 -05005033
5034 return count;
5035}
5036
Bryan Schumaker184c1842012-11-29 11:40:44 -05005037u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
5038{
5039 u64 count = 0;
5040
Benny Halevycdc975052014-05-30 09:09:30 -04005041 spin_lock(&state_lock);
Bryan Schumaker184c1842012-11-29 11:40:44 -05005042 count = nfsd_find_all_delegations(clp, max, NULL);
Benny Halevycdc975052014-05-30 09:09:30 -04005043 spin_unlock(&state_lock);
Bryan Schumaker184c1842012-11-29 11:40:44 -05005044
5045 nfsd_print_count(clp, count, "delegations");
5046 return count;
5047}
5048
Bryan Schumaker44e34da602012-11-29 11:40:39 -05005049u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
Bryan Schumaker65178db2011-11-01 13:35:21 -04005050{
5051 struct nfs4_client *clp, *next;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05005052 u64 count = 0;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005053 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
Bryan Schumaker65178db2011-11-01 13:35:21 -04005054
Bryan Schumaker44e34da602012-11-29 11:40:39 -05005055 if (!nfsd_netns_ready(nn))
5056 return 0;
5057
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03005058 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
Bryan Schumaker44e34da602012-11-29 11:40:39 -05005059 count += func(clp, max - count);
5060 if ((max != 0) && (count >= max))
Bryan Schumaker65178db2011-11-01 13:35:21 -04005061 break;
5062 }
Bryan Schumaker65178db2011-11-01 13:35:21 -04005063
Bryan Schumaker44e34da602012-11-29 11:40:39 -05005064 return count;
5065}
5066
Bryan Schumaker6c1e82a2012-11-29 11:40:46 -05005067struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
5068{
5069 struct nfs4_client *clp;
5070 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
5071
5072 if (!nfsd_netns_ready(nn))
5073 return NULL;
5074
5075 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
5076 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
5077 return clp;
5078 }
5079 return NULL;
5080}
5081
Bryan Schumaker65178db2011-11-01 13:35:21 -04005082#endif /* CONFIG_NFSD_FAULT_INJECTION */
5083
Meelap Shahc2f1a552007-07-17 04:04:39 -07005084/*
5085 * Since the lifetime of a delegation isn't limited to that of an open, a
5086 * client may quite reasonably hang on to a delegation as long as it has
5087 * the inode cached. This becomes an obvious problem the first time a
5088 * client's inode cache approaches the size of the server's total memory.
5089 *
5090 * For now we avoid this problem by imposing a hard limit on the number
5091 * of delegations, which varies according to the server's memory size.
5092 */
5093static void
5094set_max_delegations(void)
5095{
5096 /*
5097 * Allow at most 4 delegations per megabyte of RAM. Quick
5098 * estimates suggest that in the worst case (where every delegation
5099 * is for a different inode), a delegation could take about 1.5K,
5100 * giving a worst case usage of about 6% of memory.
5101 */
5102 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
5103}
5104
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005105static int nfs4_state_create_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005106{
5107 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5108 int i;
5109
5110 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5111 CLIENT_HASH_SIZE, GFP_KERNEL);
5112 if (!nn->conf_id_hashtbl)
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005113 goto err;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005114 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5115 CLIENT_HASH_SIZE, GFP_KERNEL);
5116 if (!nn->unconf_id_hashtbl)
5117 goto err_unconf_id;
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005118 nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
5119 OWNER_HASH_SIZE, GFP_KERNEL);
5120 if (!nn->ownerstr_hashtbl)
5121 goto err_ownerstr;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005122 nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
5123 LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
5124 if (!nn->lockowner_ino_hashtbl)
5125 goto err_lockowner_ino;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005126 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
5127 SESSION_HASH_SIZE, GFP_KERNEL);
5128 if (!nn->sessionid_hashtbl)
5129 goto err_sessionid;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005130
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005131 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005132 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005133 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005134 }
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005135 for (i = 0; i < OWNER_HASH_SIZE; i++)
5136 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005137 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
5138 INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005139 for (i = 0; i < SESSION_HASH_SIZE; i++)
5140 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005141 nn->conf_name_tree = RB_ROOT;
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005142 nn->unconf_name_tree = RB_ROOT;
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03005143 INIT_LIST_HEAD(&nn->client_lru);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03005144 INIT_LIST_HEAD(&nn->close_lru);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04005145 INIT_LIST_HEAD(&nn->del_recall_lru);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03005146 spin_lock_init(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005147
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005148 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005149 get_net(net);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005150
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005151 return 0;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005152
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005153err_sessionid:
5154 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005155err_lockowner_ino:
5156 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005157err_ownerstr:
5158 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005159err_unconf_id:
5160 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005161err:
5162 return -ENOMEM;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005163}
5164
5165static void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005166nfs4_state_destroy_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005167{
5168 int i;
5169 struct nfs4_client *clp = NULL;
5170 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5171
5172 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5173 while (!list_empty(&nn->conf_id_hashtbl[i])) {
5174 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5175 destroy_client(clp);
5176 }
5177 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005178
Kinglong Mee2b905632014-03-26 22:09:30 +08005179 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5180 while (!list_empty(&nn->unconf_id_hashtbl[i])) {
5181 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5182 destroy_client(clp);
5183 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005184 }
5185
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005186 kfree(nn->sessionid_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005187 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005188 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005189 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005190 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005191 put_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005192}
5193
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03005194int
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005195nfs4_state_start_net(struct net *net)
NeilBrownac4d8ff22005-06-23 22:03:30 -07005196{
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04005197 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005198 int ret;
5199
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005200 ret = nfs4_state_create_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005201 if (ret)
5202 return ret;
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04005203 nfsd4_client_tracking_init(net);
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04005204 nn->boot_time = get_seconds();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04005205 locks_start_grace(net, &nn->nfsd4_manager);
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04005206 nn->grace_ended = false;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005207 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03005208 nn->nfsd4_grace, net);
5209 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005210 return 0;
5211}
5212
5213/* initialization to perform when the nfsd service is started: */
5214
5215int
5216nfs4_state_start(void)
5217{
5218 int ret;
5219
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005220 ret = set_callback_cred();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005221 if (ret)
5222 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07005223 laundry_wq = create_singlethread_workqueue("nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05005224 if (laundry_wq == NULL) {
5225 ret = -ENOMEM;
5226 goto out_recovery;
5227 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005228 ret = nfsd4_create_callback_queue();
5229 if (ret)
5230 goto out_free_laundry;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005231
Meelap Shahc2f1a552007-07-17 04:04:39 -07005232 set_max_delegations();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005233
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005234 return 0;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005235
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005236out_free_laundry:
5237 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05005238out_recovery:
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005239 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005240}
5241
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03005242void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005243nfs4_state_shutdown_net(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005244{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005245 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005246 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005247 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005248
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005249 cancel_delayed_work_sync(&nn->laundromat_work);
5250 locks_end_grace(&nn->nfsd4_manager);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05005251
J. Bruce Fieldse50a26d2013-10-30 10:33:09 -04005252 nfs4_lock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005253 INIT_LIST_HEAD(&reaplist);
Benny Halevycdc975052014-05-30 09:09:30 -04005254 spin_lock(&state_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04005255 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005256 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5257 list_move(&dp->dl_recall_lru, &reaplist);
5258 }
Benny Halevycdc975052014-05-30 09:09:30 -04005259 spin_unlock(&state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005260 list_for_each_safe(pos, next, &reaplist) {
5261 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04005262 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005263 }
5264
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005265 nfsd4_client_tracking_exit(net);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005266 nfs4_state_destroy_net(net);
J. Bruce Fieldse50a26d2013-10-30 10:33:09 -04005267 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005268}
5269
5270void
5271nfs4_state_shutdown(void)
5272{
NeilBrown5e8d5c22006-04-10 22:55:37 -07005273 destroy_workqueue(laundry_wq);
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04005274 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005275}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005276
5277static void
5278get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5279{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005280 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
5281 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005282}
5283
5284static void
5285put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5286{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005287 if (cstate->minorversion) {
5288 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
5289 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5290 }
5291}
5292
5293void
5294clear_current_stateid(struct nfsd4_compound_state *cstate)
5295{
5296 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005297}
5298
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005299/*
5300 * functions to set current state id
5301 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005302void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005303nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5304{
5305 put_stateid(cstate, &odp->od_stateid);
5306}
5307
5308void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005309nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5310{
5311 put_stateid(cstate, &open->op_stateid);
5312}
5313
5314void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005315nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5316{
5317 put_stateid(cstate, &close->cl_stateid);
5318}
5319
5320void
5321nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5322{
5323 put_stateid(cstate, &lock->lk_resp_stateid);
5324}
5325
5326/*
5327 * functions to consume current state id
5328 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005329
5330void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005331nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5332{
5333 get_stateid(cstate, &odp->od_stateid);
5334}
5335
5336void
5337nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5338{
5339 get_stateid(cstate, &drp->dr_stateid);
5340}
5341
5342void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005343nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5344{
5345 get_stateid(cstate, &fsp->fr_stateid);
5346}
5347
5348void
5349nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5350{
5351 get_stateid(cstate, &setattr->sa_stateid);
5352}
5353
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005354void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005355nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5356{
5357 get_stateid(cstate, &close->cl_stateid);
5358}
5359
5360void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005361nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005362{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005363 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005364}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01005365
5366void
5367nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5368{
5369 get_stateid(cstate, &read->rd_stateid);
5370}
5371
5372void
5373nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5374{
5375 get_stateid(cstate, &write->wr_stateid);
5376}