blob: d5d070fbeb35a98f6053ae4299c225f57a8bdd74 [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>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020044#include "xdr4.h"
J. Bruce Fields06b332a2013-04-09 11:34:36 -040045#include "xdr4cb.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050046#include "vfs.h"
J. Bruce Fieldsbfa4b362012-04-25 16:49:18 -040047#include "current_stateid.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +040049#include "netns.h"
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define NFSDDBG_FACILITY NFSDDBG_PROC
52
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050053#define all_ones {{~0,~0},~0}
54static const stateid_t one_stateid = {
55 .si_generation = ~0,
56 .si_opaque = all_ones,
57};
58static const stateid_t zero_stateid = {
59 /* all fields zero */
60};
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010061static const stateid_t currentstateid = {
62 .si_generation = 1,
63};
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050064
Andy Adamsonec6b5d72009-04-03 08:28:28 +030065static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070066
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050067#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
68#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010069#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/* forward declarations */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040072static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
J. Bruce Fields8b671b82009-02-22 14:51:34 -080074/* Locking: */
75
76/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080077static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
J. Bruce Fields8b671b82009-02-22 14:51:34 -080079/*
80 * Currently used for the del_recall_lru and file hash table. In an
81 * effort to decrease the scope of the client_mutex, this spinlock may
82 * eventually cover more:
83 */
84static DEFINE_SPINLOCK(recall_lock);
85
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040086static struct kmem_cache *openowner_slab = NULL;
87static struct kmem_cache *lockowner_slab = NULL;
Christoph Lametere18b8902006-12-06 20:33:20 -080088static struct kmem_cache *file_slab = NULL;
89static struct kmem_cache *stateid_slab = NULL;
90static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092void
93nfs4_lock_state(void)
94{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080095 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
97
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -040098static void free_session(struct nfsd4_session *);
Benny Halevy508dc6e2012-02-23 17:40:52 -080099
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400100static bool is_session_dead(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800101{
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400102 return ses->se_flags & NFS4_SESSION_DEAD;
103}
104
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -0400105void nfsd4_put_session(struct nfsd4_session *ses)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400106{
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -0400107 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
108 free_session(ses);
109}
110
111static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
112{
113 if (atomic_read(&ses->se_ref) > ref_held_by_me)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400114 return nfserr_jukebox;
115 ses->se_flags |= NFS4_SESSION_DEAD;
116 return nfs_ok;
117}
118
119static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
120{
121 if (is_session_dead(ses))
122 return nfserr_badsession;
123 atomic_inc(&ses->se_ref);
124 return nfs_ok;
Benny Halevy508dc6e2012-02-23 17:40:52 -0800125}
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127void
128nfs4_unlock_state(void)
129{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800130 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
J. Bruce Fields221a6872013-04-01 22:23:49 -0400133static bool is_client_expired(struct nfs4_client *clp)
134{
135 return clp->cl_time == 0;
136}
137
138static __be32 mark_client_expired_locked(struct nfs4_client *clp)
139{
140 if (atomic_read(&clp->cl_refcount))
141 return nfserr_jukebox;
142 clp->cl_time = 0;
143 return nfs_ok;
144}
145
146static __be32 mark_client_expired(struct nfs4_client *clp)
147{
148 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
149 __be32 ret;
150
151 spin_lock(&nn->client_lock);
152 ret = mark_client_expired_locked(clp);
153 spin_unlock(&nn->client_lock);
154 return ret;
155}
156
157static __be32 get_client_locked(struct nfs4_client *clp)
158{
159 if (is_client_expired(clp))
160 return nfserr_expired;
161 atomic_inc(&clp->cl_refcount);
162 return nfs_ok;
163}
164
165/* must be called under the client_lock */
166static inline void
167renew_client_locked(struct nfs4_client *clp)
168{
169 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
170
171 if (is_client_expired(clp)) {
172 WARN_ON(1);
173 printk("%s: client (clientid %08x/%08x) already expired\n",
174 __func__,
175 clp->cl_clientid.cl_boot,
176 clp->cl_clientid.cl_id);
177 return;
178 }
179
180 dprintk("renewing client (clientid %08x/%08x)\n",
181 clp->cl_clientid.cl_boot,
182 clp->cl_clientid.cl_id);
183 list_move_tail(&clp->cl_lru, &nn->client_lru);
184 clp->cl_time = get_seconds();
185}
186
187static inline void
188renew_client(struct nfs4_client *clp)
189{
190 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
191
192 spin_lock(&nn->client_lock);
193 renew_client_locked(clp);
194 spin_unlock(&nn->client_lock);
195}
196
Fengguang Wuba138432013-04-16 22:14:15 -0400197static void put_client_renew_locked(struct nfs4_client *clp)
J. Bruce Fields221a6872013-04-01 22:23:49 -0400198{
199 if (!atomic_dec_and_test(&clp->cl_refcount))
200 return;
201 if (!is_client_expired(clp))
202 renew_client_locked(clp);
203}
204
205void put_client_renew(struct nfs4_client *clp)
206{
207 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
208
209 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
210 return;
211 if (!is_client_expired(clp))
212 renew_client_locked(clp);
213 spin_unlock(&nn->client_lock);
214}
215
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217static inline u32
218opaque_hashval(const void *ptr, int nbytes)
219{
220 unsigned char *cptr = (unsigned char *) ptr;
221
222 u32 x = 0;
223 while (nbytes--) {
224 x *= 37;
225 x += *cptr++;
226 }
227 return x;
228}
229
J. Bruce Fields32513b42011-10-13 16:00:16 -0400230static void nfsd4_free_file(struct nfs4_file *f)
231{
232 kmem_cache_free(file_slab, f);
233}
234
NeilBrown13cd2182005-06-23 22:03:10 -0700235static inline void
236put_nfs4_file(struct nfs4_file *fi)
237{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800238 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
Jeff Layton89876f82013-04-02 09:01:59 -0400239 hlist_del(&fi->fi_hash);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800240 spin_unlock(&recall_lock);
241 iput(fi->fi_inode);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400242 nfsd4_free_file(fi);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800243 }
NeilBrown13cd2182005-06-23 22:03:10 -0700244}
245
246static inline void
247get_nfs4_file(struct nfs4_file *fi)
248{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800249 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700250}
251
NeilBrownef0f3392006-04-10 22:55:41 -0700252static int num_delegations;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800253unsigned long max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700254
255/*
256 * Open owner state (share locks)
257 */
258
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500259/* hash tables for lock and open owners */
260#define OWNER_HASH_BITS 8
261#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
262#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700263
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500264static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400265{
266 unsigned int ret;
267
268 ret = opaque_hashval(ownername->data, ownername->len);
269 ret += clientid;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500270 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400271}
NeilBrownef0f3392006-04-10 22:55:41 -0700272
NeilBrownef0f3392006-04-10 22:55:41 -0700273/* hash table for nfs4_file */
274#define FILE_HASH_BITS 8
275#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800276
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400277static unsigned int file_hashval(struct inode *ino)
278{
279 /* XXX: why are we hashing on inode pointer, anyway? */
280 return hash_ptr(ino, FILE_HASH_BITS);
281}
282
Jeff Layton89876f82013-04-02 09:01:59 -0400283static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700284
J. Bruce Fields34775652013-08-23 17:55:18 -0400285static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
286{
287 WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
288 atomic_inc(&fp->fi_access[oflag]);
289}
290
J. Bruce Fields998db522010-08-07 09:21:41 -0400291static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
292{
293 if (oflag == O_RDWR) {
J. Bruce Fields34775652013-08-23 17:55:18 -0400294 __nfs4_file_get_access(fp, O_RDONLY);
295 __nfs4_file_get_access(fp, O_WRONLY);
J. Bruce Fields998db522010-08-07 09:21:41 -0400296 } else
J. Bruce Fields34775652013-08-23 17:55:18 -0400297 __nfs4_file_get_access(fp, oflag);
J. Bruce Fields998db522010-08-07 09:21:41 -0400298}
299
300static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400301{
302 if (fp->fi_fds[oflag]) {
303 fput(fp->fi_fds[oflag]);
304 fp->fi_fds[oflag] = NULL;
305 }
306}
307
J. Bruce Fields998db522010-08-07 09:21:41 -0400308static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400309{
310 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400311 nfs4_file_put_fd(fp, oflag);
J. Bruce Fields0c7c3e62013-03-28 20:37:14 -0400312 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
J. Bruce Fields3d02fa22011-09-19 15:07:41 -0400313 nfs4_file_put_fd(fp, O_RDWR);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400314 }
315}
316
J. Bruce Fields998db522010-08-07 09:21:41 -0400317static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
318{
319 if (oflag == O_RDWR) {
320 __nfs4_file_put_access(fp, O_RDONLY);
321 __nfs4_file_put_access(fp, O_WRONLY);
322 } else
323 __nfs4_file_put_access(fp, oflag);
324}
325
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500326static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
327kmem_cache *slab)
J. Bruce Fields996e0932011-10-17 11:14:48 -0400328{
329 struct idr *stateids = &cl->cl_stateids;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500330 struct nfs4_stid *stid;
331 int new_id;
332
333 stid = kmem_cache_alloc(slab, GFP_KERNEL);
334 if (!stid)
335 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400336
Jeff Layton398c33a2013-04-29 16:21:20 -0700337 new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
Tejun Heoebd6c702013-03-13 14:59:37 -0700338 if (new_id < 0)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500339 goto out_free;
340 stid->sc_client = cl;
341 stid->sc_type = 0;
342 stid->sc_stateid.si_opaque.so_id = new_id;
343 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
344 /* Will be incremented before return to client: */
345 stid->sc_stateid.si_generation = 0;
346
J. Bruce Fields996e0932011-10-17 11:14:48 -0400347 /*
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500348 * It shouldn't be a problem to reuse an opaque stateid value.
349 * I don't think it is for 4.1. But with 4.0 I worry that, for
350 * example, a stray write retransmission could be accepted by
351 * the server when it should have been rejected. Therefore,
352 * adopt a trick from the sctp code to attempt to maximize the
353 * amount of time until an id is reused, by ensuring they always
354 * "increase" (mod INT_MAX):
J. Bruce Fields996e0932011-10-17 11:14:48 -0400355 */
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500356 return stid;
357out_free:
Wei Yongjun2c44a232013-04-09 14:15:31 +0800358 kmem_cache_free(slab, stid);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500359 return NULL;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400360}
361
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400362static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
363{
364 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
365}
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367static struct nfs4_delegation *
J. Bruce Fields99c41512013-05-21 16:21:25 -0400368alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 dprintk("NFSD alloc_init_deleg\n");
Meelap Shahc2f1a552007-07-17 04:04:39 -0700373 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700374 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400375 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700376 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return dp;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500378 dp->dl_stid.sc_type = NFS4_DELEG_STID;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400379 /*
380 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400381 * meaning of seqid 0 isn't meaningful, really, but let's avoid
382 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400383 */
384 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownef0f3392006-04-10 22:55:41 -0700385 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700386 INIT_LIST_HEAD(&dp->dl_perfile);
387 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 INIT_LIST_HEAD(&dp->dl_recall_lru);
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -0400389 dp->dl_file = NULL;
J. Bruce Fields99c41512013-05-21 16:21:25 -0400390 dp->dl_type = NFS4_OPEN_DELEGATE_READ;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500391 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 dp->dl_time = 0;
393 atomic_set(&dp->dl_count, 1);
J. Bruce Fields57725152012-11-05 15:10:26 -0500394 nfsd4_init_callback(&dp->dl_recall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 return dp;
396}
397
J. Bruce Fields68a33962013-03-21 11:21:50 -0400398static void remove_stid(struct nfs4_stid *s)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500399{
400 struct idr *stateids = &s->sc_client->cl_stateids;
401
402 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500403}
404
Benny Halevy9857df82013-10-14 13:44:52 +0300405static void nfs4_free_stid(struct kmem_cache *slab, struct nfs4_stid *s)
406{
407 kmem_cache_free(slab, s);
408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410void
411nfs4_put_delegation(struct nfs4_delegation *dp)
412{
413 if (atomic_dec_and_test(&dp->dl_count)) {
Benny Halevy9857df82013-10-14 13:44:52 +0300414 nfs4_free_stid(deleg_slab, &dp->dl_stid);
NeilBrownef0f3392006-04-10 22:55:41 -0700415 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
417}
418
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500419static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500421 if (atomic_dec_and_test(&fp->fi_delegees)) {
422 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
423 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400424 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500425 fp->fi_deleg_file = NULL;
426 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427}
428
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400429static void unhash_stid(struct nfs4_stid *s)
430{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500431 s->sc_type = 0;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400432}
433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434/* Called under the state lock. */
435static void
436unhash_delegation(struct nfs4_delegation *dp)
437{
NeilBrownea1da632005-06-23 22:04:17 -0700438 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500440 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 list_del_init(&dp->dl_recall_lru);
442 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500443 nfs4_put_deleg_lease(dp->dl_file);
J. Bruce Fields68a33962013-03-21 11:21:50 -0400444 put_nfs4_file(dp->dl_file);
445 dp->dl_file = NULL;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400446}
447
448
449
450static void destroy_revoked_delegation(struct nfs4_delegation *dp)
451{
452 list_del_init(&dp->dl_recall_lru);
J. Bruce Fields68a33962013-03-21 11:21:50 -0400453 remove_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 nfs4_put_delegation(dp);
455}
456
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400457static void destroy_delegation(struct nfs4_delegation *dp)
458{
459 unhash_delegation(dp);
460 remove_stid(&dp->dl_stid);
461 nfs4_put_delegation(dp);
462}
463
464static void revoke_delegation(struct nfs4_delegation *dp)
465{
466 struct nfs4_client *clp = dp->dl_stid.sc_client;
467
468 if (clp->cl_minorversion == 0)
469 destroy_delegation(dp);
470 else {
471 unhash_delegation(dp);
472 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
473 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
474 }
475}
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477/*
478 * SETCLIENTID state
479 */
480
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400481static unsigned int clientid_hashval(u32 id)
482{
483 return id & CLIENT_HASH_MASK;
484}
485
486static unsigned int clientstr_hashval(const char *name)
487{
488 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
489}
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491/*
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400492 * We store the NONE, READ, WRITE, and BOTH bits separately in the
493 * st_{access,deny}_bmap field of the stateid, in order to track not
494 * only what share bits are currently in force, but also what
495 * combinations of share bits previous opens have used. This allows us
496 * to enforce the recommendation of rfc 3530 14.2.19 that the server
497 * return an error if the client attempt to downgrade to a combination
498 * of share bits not explicable by closing some of its previous opens.
499 *
500 * XXX: This enforcement is actually incomplete, since we don't keep
501 * track of access/deny bit combinations; so, e.g., we allow:
502 *
503 * OPEN allow read, deny write
504 * OPEN allow both, deny none
505 * DOWNGRADE allow read, deny none
506 *
507 * which we should reject.
508 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400509static unsigned int
510bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400511 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400512 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400513
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400514 for (i = 1; i < 4; i++) {
515 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400516 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400517 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400518 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400519}
520
Jeff Layton3a328612012-05-11 09:45:12 -0400521static bool
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400522test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400523 unsigned int access, deny;
524
Jeff Layton5ae037e2012-05-11 09:45:11 -0400525 access = bmap_to_share_mode(stp->st_access_bmap);
526 deny = bmap_to_share_mode(stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400527 if ((access & open->op_share_deny) || (deny & open->op_share_access))
Jeff Layton3a328612012-05-11 09:45:12 -0400528 return false;
529 return true;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400530}
531
Jeff Layton82c5ff12012-05-11 09:45:13 -0400532/* set share access for a given stateid */
533static inline void
534set_access(u32 access, struct nfs4_ol_stateid *stp)
535{
536 __set_bit(access, &stp->st_access_bmap);
537}
538
539/* clear share access for a given stateid */
540static inline void
541clear_access(u32 access, struct nfs4_ol_stateid *stp)
542{
543 __clear_bit(access, &stp->st_access_bmap);
544}
545
546/* test whether a given stateid has access */
547static inline bool
548test_access(u32 access, struct nfs4_ol_stateid *stp)
549{
550 return test_bit(access, &stp->st_access_bmap);
551}
552
Jeff Laytonce0fc432012-05-11 09:45:14 -0400553/* set share deny for a given stateid */
554static inline void
555set_deny(u32 access, struct nfs4_ol_stateid *stp)
556{
557 __set_bit(access, &stp->st_deny_bmap);
558}
559
560/* clear share deny for a given stateid */
561static inline void
562clear_deny(u32 access, struct nfs4_ol_stateid *stp)
563{
564 __clear_bit(access, &stp->st_deny_bmap);
565}
566
567/* test whether a given stateid is denying specific access */
568static inline bool
569test_deny(u32 access, struct nfs4_ol_stateid *stp)
570{
571 return test_bit(access, &stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400572}
573
574static int nfs4_access_to_omode(u32 access)
575{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400576 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400577 case NFS4_SHARE_ACCESS_READ:
578 return O_RDONLY;
579 case NFS4_SHARE_ACCESS_WRITE:
580 return O_WRONLY;
581 case NFS4_SHARE_ACCESS_BOTH:
582 return O_RDWR;
583 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500584 WARN_ON_ONCE(1);
585 return O_RDONLY;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400586}
587
Jeff Layton82c5ff12012-05-11 09:45:13 -0400588/* release all access and file references for a given stateid */
589static void
590release_all_access(struct nfs4_ol_stateid *stp)
591{
592 int i;
593
594 for (i = 1; i < 4; i++) {
595 if (test_access(i, stp))
596 nfs4_file_put_access(stp->st_file,
597 nfs4_access_to_omode(i));
598 clear_access(i, stp);
599 }
600}
601
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400602static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500603{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500604 list_del(&stp->st_perfile);
605 list_del(&stp->st_perstateowner);
606}
607
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400608static void close_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500609{
Jeff Layton82c5ff12012-05-11 09:45:13 -0400610 release_all_access(stp);
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400611 put_nfs4_file(stp->st_file);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400612 stp->st_file = NULL;
613}
614
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400615static void free_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400616{
J. Bruce Fields68a33962013-03-21 11:21:50 -0400617 remove_stid(&stp->st_stid);
Benny Halevy9857df82013-10-14 13:44:52 +0300618 nfs4_free_stid(stateid_slab, &stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500619}
620
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400621static void release_lock_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500622{
623 struct file *file;
624
625 unhash_generic_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400626 unhash_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500627 file = find_any_file(stp->st_file);
628 if (file)
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400629 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400630 close_generic_stateid(stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500631 free_generic_stateid(stp);
632}
633
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400634static void unhash_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500635{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400636 struct nfs4_ol_stateid *stp;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500637
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400638 list_del(&lo->lo_owner.so_strhash);
639 list_del(&lo->lo_perstateid);
J. Bruce Fields009673b2011-11-07 17:40:10 -0500640 list_del(&lo->lo_owner_ino_hash);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400641 while (!list_empty(&lo->lo_owner.so_stateids)) {
642 stp = list_first_entry(&lo->lo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400643 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500644 release_lock_stateid(stp);
645 }
646}
647
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400648static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500649{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400650 unhash_lockowner(lo);
651 nfs4_free_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500652}
653
654static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400655release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500656{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400657 struct nfs4_lockowner *lo;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500658
659 while (!list_empty(&open_stp->st_lockowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400660 lo = list_entry(open_stp->st_lockowners.next,
661 struct nfs4_lockowner, lo_perstateid);
662 release_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500663 }
664}
665
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400666static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields22839632009-01-11 14:27:17 -0500667{
668 unhash_generic_stateid(stp);
669 release_stateid_lockowners(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400670 close_generic_stateid(stp);
671}
672
673static void release_open_stateid(struct nfs4_ol_stateid *stp)
674{
675 unhash_open_stateid(stp);
J. Bruce Fields22839632009-01-11 14:27:17 -0500676 free_generic_stateid(stp);
677}
678
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400679static void unhash_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500680{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400681 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500682
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400683 list_del(&oo->oo_owner.so_strhash);
684 list_del(&oo->oo_perclient);
685 while (!list_empty(&oo->oo_owner.so_stateids)) {
686 stp = list_first_entry(&oo->oo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400687 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500688 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500689 }
690}
691
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400692static void release_last_closed_stateid(struct nfs4_openowner *oo)
693{
694 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
695
696 if (s) {
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400697 free_generic_stateid(s);
698 oo->oo_last_closed_stid = NULL;
699 }
700}
701
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400702static void release_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500703{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400704 unhash_openowner(oo);
705 list_del(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400706 release_last_closed_stateid(oo);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400707 nfs4_free_openowner(oo);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500708}
709
Marc Eshel5282fd72009-04-03 08:27:52 +0300710static inline int
711hash_sessionid(struct nfs4_sessionid *sessionid)
712{
713 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
714
715 return sid->sequence % SESSION_HASH_SIZE;
716}
717
Trond Myklebust8f199b82012-03-20 15:11:17 -0400718#ifdef NFSD_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +0300719static inline void
720dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
721{
722 u32 *ptr = (u32 *)(&sessionid->data[0]);
723 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
724}
Trond Myklebust8f199b82012-03-20 15:11:17 -0400725#else
726static inline void
727dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
728{
729}
730#endif
731
J. Bruce Fields9411b1d2013-04-01 16:37:12 -0400732/*
733 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
734 * won't be used for replay.
735 */
736void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
737{
738 struct nfs4_stateowner *so = cstate->replay_owner;
739
740 if (nfserr == nfserr_replay_me)
741 return;
742
743 if (!seqid_mutating_err(ntohl(nfserr))) {
744 cstate->replay_owner = NULL;
745 return;
746 }
747 if (!so)
748 return;
749 if (so->so_is_open_owner)
750 release_last_closed_stateid(openowner(so));
751 so->so_seqid++;
752 return;
753}
Marc Eshel5282fd72009-04-03 08:27:52 +0300754
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300755static void
756gen_sessionid(struct nfsd4_session *ses)
757{
758 struct nfs4_client *clp = ses->se_client;
759 struct nfsd4_sessionid *sid;
760
761 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
762 sid->clientid = clp->cl_clientid;
763 sid->sequence = current_sessionid++;
764 sid->reserved = 0;
765}
766
767/*
Andy Adamsona6496372009-08-28 08:45:01 -0400768 * The protocol defines ca_maxresponssize_cached to include the size of
769 * the rpc header, but all we need to cache is the data starting after
770 * the end of the initial SEQUENCE operation--the rest we regenerate
771 * each time. Therefore we can advertise a ca_maxresponssize_cached
772 * value that is the number of bytes in our cache plus a few additional
773 * bytes. In order to stay on the safe side, and not promise more than
774 * we can cache, those additional bytes must be the minimum possible: 24
775 * bytes of rpc header (xid through accept state, with AUTH_NULL
776 * verifier), 12 for the compound header (with zero-length tag), and 44
777 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300778 */
Andy Adamsona6496372009-08-28 08:45:01 -0400779#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
780
Andy Adamson557ce262009-08-28 08:45:04 -0400781static void
782free_session_slots(struct nfsd4_session *ses)
783{
784 int i;
785
786 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
787 kfree(ses->se_slots[i]);
788}
789
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400790/*
791 * We don't actually need to cache the rpc and session headers, so we
792 * can allocate a little less for each slot:
793 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400794static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400795{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400796 u32 size;
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400797
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400798 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
799 size = 0;
800 else
801 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
802 return size + sizeof(struct nfsd4_slot);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400803}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300804
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400805/*
806 * XXX: If we run out of reserved DRC memory we could (up to a point)
807 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800808 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400809 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400810static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400811{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400812 u32 slotsize = slot_bytes(ca);
813 u32 num = ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400814 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300815
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400816 spin_lock(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800817 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
818 nfsd_drc_max_mem - nfsd_drc_mem_used);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400819 num = min_t(int, num, avail / slotsize);
820 nfsd_drc_mem_used += num * slotsize;
821 spin_unlock(&nfsd_drc_lock);
822
823 return num;
824}
825
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400826static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400827{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400828 int slotsize = slot_bytes(ca);
829
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400830 spin_lock(&nfsd_drc_lock);
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400831 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400832 spin_unlock(&nfsd_drc_lock);
833}
834
Kinglong Mee60810e52014-01-01 00:35:47 +0800835static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
836 struct nfsd4_channel_attrs *battrs)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400837{
Kinglong Mee60810e52014-01-01 00:35:47 +0800838 int numslots = fattrs->maxreqs;
839 int slotsize = slot_bytes(fattrs);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400840 struct nfsd4_session *new;
841 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300842
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400843 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400844 + sizeof(struct nfsd4_session) > PAGE_SIZE);
845 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400846
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400847 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300848 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400849 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400850 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400851 for (i = 0; i < numslots; i++) {
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400852 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400853 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400854 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400855 }
Kinglong Mee60810e52014-01-01 00:35:47 +0800856
857 memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
858 memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
859
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400860 return new;
861out_free:
862 while (i--)
863 kfree(new->se_slots[i]);
864 kfree(new);
865 return NULL;
866}
867
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400868static void free_conn(struct nfsd4_conn *c)
869{
870 svc_xprt_put(c->cn_xprt);
871 kfree(c);
872}
873
874static void nfsd4_conn_lost(struct svc_xpt_user *u)
875{
876 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
877 struct nfs4_client *clp = c->cn_session->se_client;
878
879 spin_lock(&clp->cl_lock);
880 if (!list_empty(&c->cn_persession)) {
881 list_del(&c->cn_persession);
882 free_conn(c);
883 }
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500884 nfsd4_probe_callback(clp);
J. Bruce Fields2e4b7232013-03-08 09:30:43 -0500885 spin_unlock(&clp->cl_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400886}
887
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400888static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400889{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400890 struct nfsd4_conn *conn;
891
892 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
893 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400894 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400895 svc_xprt_get(rqstp->rq_xprt);
896 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400897 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400898 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
899 return conn;
900}
901
J. Bruce Fields328ead22010-09-29 16:11:06 -0400902static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
903{
904 conn->cn_session = ses;
905 list_add(&conn->cn_persession, &ses->se_conns);
906}
907
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400908static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
909{
910 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400911
912 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400913 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400914 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400915}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400916
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400917static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400918{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400919 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400920 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400921}
922
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400923static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400924{
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400925 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400926
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400927 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400928 ret = nfsd4_register_conn(conn);
929 if (ret)
930 /* oops; xprt is already down: */
931 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fields6a3b1562012-09-12 09:59:17 -0400932 if (conn->cn_flags & NFS4_CDFC4_BACK) {
Weston Andros Adamson24119672012-05-24 15:42:17 -0400933 /* callback channel may be back up */
934 nfsd4_probe_callback(ses->se_client);
935 }
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400936}
937
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400938static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400939{
940 u32 dir = NFS4_CDFC4_FORE;
941
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400942 if (cses->flags & SESSION4_BACK_CHAN)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400943 dir |= NFS4_CDFC4_BACK;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400944 return alloc_conn(rqstp, dir);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400945}
946
947/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400948static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400949{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400950 struct nfs4_client *clp = s->se_client;
951 struct nfsd4_conn *c;
952
953 spin_lock(&clp->cl_lock);
954 while (!list_empty(&s->se_conns)) {
955 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
956 list_del_init(&c->cn_persession);
957 spin_unlock(&clp->cl_lock);
958
959 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
960 free_conn(c);
961
962 spin_lock(&clp->cl_lock);
963 }
964 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400965}
966
J. Bruce Fields1377b692012-09-11 21:42:40 -0400967static void __free_session(struct nfsd4_session *ses)
968{
J. Bruce Fields1377b692012-09-11 21:42:40 -0400969 free_session_slots(ses);
970 kfree(ses);
971}
972
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400973static void free_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800974{
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300975 struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
976
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400977 lockdep_assert_held(&nn->client_lock);
978 nfsd4_del_conns(ses);
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400979 nfsd4_put_drc_mem(&ses->se_fchannel);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400980 __free_session(ses);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400981}
Andy Adamson557ce262009-08-28 08:45:04 -0400982
Fengguang Wu135ae822012-11-10 07:20:25 -0500983static 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 -0400984{
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400985 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300986 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400987
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300988 new->se_client = clp;
989 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300990
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400991 INIT_LIST_HEAD(&new->se_conns);
992
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400993 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300994 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400995 new->se_cb_prog = cses->callback_prog;
J. Bruce Fieldsc6bb3ca2012-11-01 16:31:02 -0400996 new->se_cb_sec = cses->cb_sec;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400997 atomic_set(&new->se_ref, 0);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400998 idx = hash_sessionid(&new->se_sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300999 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001000 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001001 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001002 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001003 spin_unlock(&clp->cl_lock);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001004 spin_unlock(&nn->client_lock);
Kinglong Mee60810e52014-01-01 00:35:47 +08001005
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001006 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001007 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001008 /*
1009 * This is a little silly; with sessions there's no real
1010 * use for the callback address. Use the peer address
1011 * as a reasonable default for now, but consider fixing
1012 * the rpc client not to require an address in the
1013 * future:
1014 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001015 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1016 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001017 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001018}
1019
Benny Halevy9089f1b2010-05-12 00:12:26 +03001020/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +03001021static struct nfsd4_session *
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001022find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
Marc Eshel5282fd72009-04-03 08:27:52 +03001023{
1024 struct nfsd4_session *elem;
1025 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001026 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Marc Eshel5282fd72009-04-03 08:27:52 +03001027
1028 dump_sessionid(__func__, sessionid);
1029 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +03001030 /* Search in the appropriate list */
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001031 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +03001032 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1033 NFS4_MAX_SESSIONID_LEN)) {
1034 return elem;
1035 }
1036 }
1037
1038 dprintk("%s: session not found\n", __func__);
1039 return NULL;
1040}
1041
Benny Halevy9089f1b2010-05-12 00:12:26 +03001042/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +03001043static void
Marc Eshel5282fd72009-04-03 08:27:52 +03001044unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +03001045{
1046 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001047 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +03001048 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001049 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +03001050}
1051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1053static int
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001054STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001056 if (clid->cl_boot == nn->boot_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001058 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001059 clid->cl_boot, clid->cl_id, nn->boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 return 1;
1061}
1062
1063/*
1064 * XXX Should we use a slab cache ?
1065 * This type of memory management is somewhat inefficient, but we use it
1066 * anyway since SETCLIENTID is not a common operation.
1067 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001068static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
1070 struct nfs4_client *clp;
1071
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001072 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1073 if (clp == NULL)
1074 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001075 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001076 if (clp->cl_name.data == NULL) {
1077 kfree(clp);
1078 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001080 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return clp;
1082}
1083
1084static inline void
1085free_client(struct nfs4_client *clp)
1086{
Stanislav Kinsburskybca0ec62013-01-09 12:38:34 +03001087 struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001088
1089 lockdep_assert_held(&nn->client_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001090 while (!list_empty(&clp->cl_sessions)) {
1091 struct nfsd4_session *ses;
1092 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1093 se_perclnt);
1094 list_del(&ses->se_perclnt);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001095 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1096 free_session(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001097 }
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001098 free_svc_cred(&clp->cl_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 kfree(clp->cl_name.data);
majianpeng2d32b292013-01-29 13:16:06 +08001100 idr_destroy(&clp->cl_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 kfree(clp);
1102}
1103
Benny Halevy84d38ac2010-05-12 00:13:16 +03001104/* must be called under the client_lock */
1105static inline void
1106unhash_client_locked(struct nfs4_client *clp)
1107{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001108 struct nfsd4_session *ses;
1109
Benny Halevy84d38ac2010-05-12 00:13:16 +03001110 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001111 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001112 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1113 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001114 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001115}
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117static void
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001118destroy_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001120 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 struct list_head reaplist;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001123 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 INIT_LIST_HEAD(&reaplist);
1126 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001127 while (!list_empty(&clp->cl_delegations)) {
1128 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -07001129 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 list_move(&dp->dl_recall_lru, &reaplist);
1131 }
1132 spin_unlock(&recall_lock);
1133 while (!list_empty(&reaplist)) {
1134 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04001135 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 }
Benny Halevy956c4fe2013-10-29 11:39:12 +02001137 list_splice_init(&clp->cl_revoked, &reaplist);
1138 while (!list_empty(&reaplist)) {
1139 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1140 destroy_revoked_delegation(dp);
1141 }
NeilBrownea1da632005-06-23 22:04:17 -07001142 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001143 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1144 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001146 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001147 if (clp->cl_cb_conn.cb_xprt)
1148 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001149 list_del(&clp->cl_idhash);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001150 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001151 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001152 else
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001153 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001154 spin_lock(&nn->client_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001155 unhash_client_locked(clp);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001156 WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
1157 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001158 spin_unlock(&nn->client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159}
1160
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001161static void expire_client(struct nfs4_client *clp)
1162{
1163 nfsd4_client_record_remove(clp);
1164 destroy_client(clp);
1165}
1166
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001167static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1168{
1169 memcpy(target->cl_verifier.data, source->data,
1170 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001173static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1174{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1176 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1177}
1178
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001179static int copy_cred(struct svc_cred *target, struct svc_cred *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001180{
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001181 if (source->cr_principal) {
1182 target->cr_principal =
1183 kstrdup(source->cr_principal, GFP_KERNEL);
1184 if (target->cr_principal == NULL)
1185 return -ENOMEM;
1186 } else
1187 target->cr_principal = NULL;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001188 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 target->cr_uid = source->cr_uid;
1190 target->cr_gid = source->cr_gid;
1191 target->cr_group_info = source->cr_group_info;
1192 get_group_info(target->cr_group_info);
J. Bruce Fields0dc15312013-05-14 16:07:13 -04001193 target->cr_gss_mech = source->cr_gss_mech;
1194 if (source->cr_gss_mech)
1195 gss_mech_get(source->cr_gss_mech);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}
1198
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001199static long long
1200compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1201{
1202 long long res;
1203
1204 res = o1->len - o2->len;
1205 if (res)
1206 return res;
1207 return (long long)memcmp(o1->data, o2->data, o1->len);
1208}
1209
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001210static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001211{
NeilBrowna55370a2005-06-23 22:03:52 -07001212 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213}
1214
1215static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001216same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1217{
1218 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219}
1220
1221static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001222same_clid(clientid_t *cl1, clientid_t *cl2)
1223{
1224 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225}
1226
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001227static bool groups_equal(struct group_info *g1, struct group_info *g2)
1228{
1229 int i;
1230
1231 if (g1->ngroups != g2->ngroups)
1232 return false;
1233 for (i=0; i<g1->ngroups; i++)
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001234 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001235 return false;
1236 return true;
1237}
1238
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001239/*
1240 * RFC 3530 language requires clid_inuse be returned when the
1241 * "principal" associated with a requests differs from that previously
1242 * used. We use uid, gid's, and gss principal string as our best
1243 * approximation. We also don't want to allow non-gss use of a client
1244 * established using gss: in theory cr_principal should catch that
1245 * change, but in practice cr_principal can be null even in the gss case
1246 * since gssd doesn't always pass down a principal string.
1247 */
1248static bool is_gss_cred(struct svc_cred *cr)
1249{
1250 /* Is cr_flavor one of the gss "pseudoflavors"?: */
1251 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1252}
1253
1254
Vivek Trivedi5559b502012-07-24 21:18:20 +05301255static bool
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001256same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1257{
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001258 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001259 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1260 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001261 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1262 return false;
1263 if (cr1->cr_principal == cr2->cr_principal)
1264 return true;
1265 if (!cr1->cr_principal || !cr2->cr_principal)
1266 return false;
Vivek Trivedi5559b502012-07-24 21:18:20 +05301267 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268}
1269
J. Bruce Fields57266a62013-04-13 14:27:29 -04001270static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
1271{
1272 struct svc_cred *cr = &rqstp->rq_cred;
1273 u32 service;
1274
J. Bruce Fieldsc4720592013-08-07 11:41:49 -04001275 if (!cr->cr_gss_mech)
1276 return false;
J. Bruce Fields57266a62013-04-13 14:27:29 -04001277 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
1278 return service == RPC_GSS_SVC_INTEGRITY ||
1279 service == RPC_GSS_SVC_PRIVACY;
1280}
1281
1282static bool mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
1283{
1284 struct svc_cred *cr = &rqstp->rq_cred;
1285
1286 if (!cl->cl_mach_cred)
1287 return true;
1288 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
1289 return false;
1290 if (!svc_rqst_integrity_protected(rqstp))
1291 return false;
1292 if (!cr->cr_principal)
1293 return false;
1294 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
1295}
1296
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001297static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001298{
1299 static u32 current_clientid = 1;
1300
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001301 clp->cl_clientid.cl_boot = nn->boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 clp->cl_clientid.cl_id = current_clientid++;
1303}
1304
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001305static void gen_confirm(struct nfs4_client *clp)
1306{
Chuck Leverab4684d2012-03-02 17:13:50 -05001307 __be32 verf[2];
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001308 static u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Chuck Leverab4684d2012-03-02 17:13:50 -05001310 verf[0] = (__be32)get_seconds();
1311 verf[1] = (__be32)i++;
1312 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313}
1314
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001315static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
J. Bruce Fields4581d142011-09-06 14:56:09 -04001316{
J. Bruce Fields3abdb602013-02-03 12:23:01 -05001317 struct nfs4_stid *ret;
1318
1319 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1320 if (!ret || !ret->sc_type)
1321 return NULL;
1322 return ret;
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001323}
1324
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001325static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001326{
1327 struct nfs4_stid *s;
1328
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001329 s = find_stateid(cl, t);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001330 if (!s)
1331 return NULL;
1332 if (typemask & s->sc_type)
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001333 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04001334 return NULL;
1335}
1336
Jeff Layton2216d442012-11-12 15:00:57 -05001337static struct nfs4_client *create_client(struct xdr_netobj name,
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001338 struct svc_rqst *rqstp, nfs4_verifier *verf)
1339{
1340 struct nfs4_client *clp;
1341 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001342 int ret;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001343 struct net *net = SVC_NET(rqstp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001344 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001345
1346 clp = alloc_client(name);
1347 if (clp == NULL)
1348 return NULL;
1349
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001350 INIT_LIST_HEAD(&clp->cl_sessions);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001351 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1352 if (ret) {
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001353 spin_lock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001354 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001355 spin_unlock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001356 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001357 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001358 idr_init(&clp->cl_stateids);
Benny Halevy46583e22010-05-12 00:13:29 +03001359 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001360 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001361 INIT_LIST_HEAD(&clp->cl_idhash);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001362 INIT_LIST_HEAD(&clp->cl_openowners);
1363 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001364 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001365 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04001366 INIT_LIST_HEAD(&clp->cl_revoked);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001367 spin_lock_init(&clp->cl_lock);
J. Bruce Fields57725152012-11-05 15:10:26 -05001368 nfsd4_init_callback(&clp->cl_cb_null);
Benny Halevy07cd4902010-05-12 00:13:41 +03001369 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001370 clear_bit(0, &clp->cl_cb_slot_busy);
1371 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1372 copy_verf(clp, verf);
1373 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001374 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001375 clp->cl_cb_session = NULL;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001376 clp->net = net;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001377 return clp;
1378}
1379
NeilBrownfd39ca92005-06-23 22:04:03 -07001380static void
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001381add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1382{
1383 struct rb_node **new = &(root->rb_node), *parent = NULL;
1384 struct nfs4_client *clp;
1385
1386 while (*new) {
1387 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1388 parent = *new;
1389
1390 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1391 new = &((*new)->rb_left);
1392 else
1393 new = &((*new)->rb_right);
1394 }
1395
1396 rb_link_node(&new_clp->cl_namenode, parent, new);
1397 rb_insert_color(&new_clp->cl_namenode, root);
1398}
1399
1400static struct nfs4_client *
1401find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1402{
1403 long long cmp;
1404 struct rb_node *node = root->rb_node;
1405 struct nfs4_client *clp;
1406
1407 while (node) {
1408 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1409 cmp = compare_blob(&clp->cl_name, name);
1410 if (cmp > 0)
1411 node = node->rb_left;
1412 else if (cmp < 0)
1413 node = node->rb_right;
1414 else
1415 return clp;
1416 }
1417 return NULL;
1418}
1419
1420static void
1421add_to_unconfirmed(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422{
1423 unsigned int idhashval;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001424 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001426 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001427 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001429 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001430 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431}
1432
NeilBrownfd39ca92005-06-23 22:04:03 -07001433static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434move_to_confirmed(struct nfs4_client *clp)
1435{
1436 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001437 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001440 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001441 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001442 add_clp_to_name_tree(clp, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001443 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 renew_client(clp);
1445}
1446
1447static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001448find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449{
1450 struct nfs4_client *clp;
1451 unsigned int idhashval = clientid_hashval(clid->cl_id);
1452
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001453 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001454 if (same_clid(&clp->cl_clientid, clid)) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001455 if ((bool)clp->cl_minorversion != sessions)
1456 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001457 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001459 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 }
1461 return NULL;
1462}
1463
1464static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001465find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1466{
1467 struct list_head *tbl = nn->conf_id_hashtbl;
1468
1469 return find_client_in_id_table(tbl, clid, sessions);
1470}
1471
1472static struct nfs4_client *
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001473find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474{
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001475 struct list_head *tbl = nn->unconf_id_hashtbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001477 return find_client_in_id_table(tbl, clid, sessions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478}
1479
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001480static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001481{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001482 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001483}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001484
NeilBrown28ce6052005-06-23 22:03:56 -07001485static struct nfs4_client *
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001486find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001487{
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001488 return find_clp_in_name_tree(name, &nn->conf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001489}
1490
1491static struct nfs4_client *
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001492find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001493{
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001494 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001495}
1496
NeilBrownfd39ca92005-06-23 22:04:03 -07001497static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001498gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001500 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001501 struct sockaddr *sa = svc_addr(rqstp);
1502 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001503 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Jeff Layton7077ecb2009-08-14 12:57:58 -04001505 /* Currently, we only support tcp and tcp6 for the callback channel */
1506 if (se->se_callback_netid_len == 3 &&
1507 !memcmp(se->se_callback_netid_val, "tcp", 3))
1508 expected_family = AF_INET;
1509 else if (se->se_callback_netid_len == 4 &&
1510 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1511 expected_family = AF_INET6;
1512 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 goto out_err;
1514
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001515 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001516 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001517 (struct sockaddr *)&conn->cb_addr,
1518 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001519
J. Bruce Fields07263f12010-05-31 19:09:40 -04001520 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001522
J. Bruce Fields07263f12010-05-31 19:09:40 -04001523 if (conn->cb_addr.ss_family == AF_INET6)
1524 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001525
J. Bruce Fields07263f12010-05-31 19:09:40 -04001526 conn->cb_prog = se->se_callback_prog;
1527 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08001528 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 return;
1530out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001531 conn->cb_addr.ss_family = AF_UNSPEC;
1532 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001533 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 "will not receive delegations\n",
1535 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1536
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 return;
1538}
1539
Andy Adamson074fe892009-04-03 08:28:15 +03001540/*
Andy Adamson557ce262009-08-28 08:45:04 -04001541 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001542 */
1543void
1544nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1545{
Andy Adamson557ce262009-08-28 08:45:04 -04001546 struct nfsd4_slot *slot = resp->cstate.slot;
1547 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001548
Andy Adamson557ce262009-08-28 08:45:04 -04001549 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001550
Andy Adamson557ce262009-08-28 08:45:04 -04001551 slot->sl_opcnt = resp->opcnt;
1552 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001553
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05001554 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001555 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001556 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001557 return;
1558 }
Andy Adamson557ce262009-08-28 08:45:04 -04001559 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1560 base = (char *)resp->cstate.datap -
1561 (char *)resp->xbuf->head[0].iov_base;
1562 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1563 slot->sl_datalen))
1564 WARN("%s: sessions DRC could not cache compound\n", __func__);
1565 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001566}
1567
1568/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001569 * Encode the replay sequence operation from the slot values.
1570 * If cachethis is FALSE encode the uncached rep error on the next
1571 * operation which sets resp->p and increments resp->opcnt for
1572 * nfs4svc_encode_compoundres.
1573 *
Andy Adamson074fe892009-04-03 08:28:15 +03001574 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001575static __be32
1576nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1577 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001578{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001579 struct nfsd4_op *op;
1580 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001581
Andy Adamsonabfabf82009-07-23 19:02:18 -04001582 /* Encode the replayed sequence operation */
1583 op = &args->ops[resp->opcnt - 1];
1584 nfsd4_encode_operation(resp, op);
1585
1586 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05001587 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001588 op = &args->ops[resp->opcnt++];
1589 op->status = nfserr_retry_uncached_rep;
1590 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001591 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001592 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001593}
1594
1595/*
Andy Adamson557ce262009-08-28 08:45:04 -04001596 * The sequence operation is not cached because we can use the slot and
1597 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001598 */
1599__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001600nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1601 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001602{
Andy Adamson557ce262009-08-28 08:45:04 -04001603 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001604 __be32 status;
1605
Andy Adamson557ce262009-08-28 08:45:04 -04001606 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001607
Andy Adamsonabfabf82009-07-23 19:02:18 -04001608 /* Either returns 0 or nfserr_retry_uncached */
1609 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1610 if (status == nfserr_retry_uncached_rep)
1611 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001612
Andy Adamson557ce262009-08-28 08:45:04 -04001613 /* The sequence operation has been encoded, cstate->datap set. */
1614 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001615
Andy Adamson557ce262009-08-28 08:45:04 -04001616 resp->opcnt = slot->sl_opcnt;
1617 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1618 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001619
1620 return status;
1621}
1622
Andy Adamson0733d212009-04-03 08:28:01 +03001623/*
1624 * Set the exchange_id flags returned by the server.
1625 */
1626static void
1627nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1628{
1629 /* pNFS is not supported */
1630 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1631
1632 /* Referrals are supported, Migration is not. */
1633 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1634
1635 /* set the wire flags to return to client. */
1636 clid->flags = new->cl_exchange_flags;
1637}
1638
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001639static bool client_has_state(struct nfs4_client *clp)
1640{
1641 /*
1642 * Note clp->cl_openowners check isn't quite right: there's no
1643 * need to count owners without stateid's.
1644 *
1645 * Also note we should probably be using this in 4.0 case too.
1646 */
J. Bruce Fields6eccece2012-05-29 16:37:44 -04001647 return !list_empty(&clp->cl_openowners)
1648 || !list_empty(&clp->cl_delegations)
1649 || !list_empty(&clp->cl_sessions);
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001650}
1651
Al Virob37ad282006-10-19 23:28:59 -07001652__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001653nfsd4_exchange_id(struct svc_rqst *rqstp,
1654 struct nfsd4_compound_state *cstate,
1655 struct nfsd4_exchange_id *exid)
1656{
Andy Adamson0733d212009-04-03 08:28:01 +03001657 struct nfs4_client *unconf, *conf, *new;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001658 __be32 status;
Jeff Layton363168b2009-08-14 12:57:56 -04001659 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001660 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001661 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001662 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001663 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamson0733d212009-04-03 08:28:01 +03001664
Jeff Layton363168b2009-08-14 12:57:56 -04001665 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001666 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001667 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001668 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001669 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001670
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04001671 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03001672 return nfserr_inval;
1673
Andy Adamson0733d212009-04-03 08:28:01 +03001674 switch (exid->spa_how) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04001675 case SP4_MACH_CRED:
1676 if (!svc_rqst_integrity_protected(rqstp))
1677 return nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001678 case SP4_NONE:
1679 break;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05001680 default: /* checked by xdr code */
1681 WARN_ON_ONCE(1);
Andy Adamson0733d212009-04-03 08:28:01 +03001682 case SP4_SSV:
J. Bruce Fieldsdd303332013-04-12 18:10:56 -04001683 return nfserr_encr_alg_unsupp;
Andy Adamson0733d212009-04-03 08:28:01 +03001684 }
1685
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001686 /* Cases below refer to rfc 5661 section 18.35.4: */
Andy Adamson0733d212009-04-03 08:28:01 +03001687 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001688 conf = find_confirmed_client_by_name(&exid->clname, nn);
Andy Adamson0733d212009-04-03 08:28:01 +03001689 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001690 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1691 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1692
J. Bruce Fields136e6582012-05-12 20:37:23 -04001693 if (update) {
1694 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001695 status = nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001696 goto out;
1697 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04001698 if (!mach_creds_match(conf, rqstp)) {
1699 status = nfserr_wrong_cred;
1700 goto out;
1701 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001702 if (!creds_match) { /* case 9 */
Andy Adamson0733d212009-04-03 08:28:01 +03001703 status = nfserr_perm;
1704 goto out;
1705 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001706 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03001707 status = nfserr_not_same;
1708 goto out;
1709 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001710 /* case 6 */
1711 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1712 new = conf;
1713 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03001714 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001715 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001716 if (client_has_state(conf)) {
1717 status = nfserr_clid_inuse;
1718 goto out;
1719 }
Andy Adamson0733d212009-04-03 08:28:01 +03001720 expire_client(conf);
1721 goto out_new;
1722 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001723 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04001724 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001725 new = conf;
1726 goto out_copy;
1727 }
1728 /* case 5, client reboot */
J. Bruce Fields136e6582012-05-12 20:37:23 -04001729 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001730 }
1731
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001732 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001733 status = nfserr_noent;
1734 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001735 }
1736
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001737 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001738 if (unconf) /* case 4, possible retry or client restart */
Andy Adamson0733d212009-04-03 08:28:01 +03001739 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03001740
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001741 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03001742out_new:
Jeff Layton2216d442012-11-12 15:00:57 -05001743 new = create_client(exid->clname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001744 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001745 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001746 goto out;
1747 }
J. Bruce Fields4f540e22013-05-07 11:57:52 -04001748 new->cl_minorversion = cstate->minorversion;
J. Bruce Fields57266a62013-04-13 14:27:29 -04001749 new->cl_mach_cred = (exid->spa_how == SP4_MACH_CRED);
Andy Adamson0733d212009-04-03 08:28:01 +03001750
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001751 gen_clid(new, nn);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001752 add_to_unconfirmed(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001753out_copy:
1754 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1755 exid->clientid.cl_id = new->cl_clientid.cl_id;
1756
J. Bruce Fields778df3f2012-05-25 21:40:23 -04001757 exid->seqid = new->cl_cs_slot.sl_seqid + 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001758 nfsd4_set_ex_flags(new, exid);
1759
1760 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001761 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001762 status = nfs_ok;
1763
1764out:
1765 nfs4_unlock_state();
Andy Adamson0733d212009-04-03 08:28:01 +03001766 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001767}
1768
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001769static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04001770check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001771{
Andy Adamson88e588d2009-07-23 19:02:15 -04001772 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1773 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001774
1775 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001776 if (slot_inuse) {
1777 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001778 return nfserr_jukebox;
1779 else
1780 return nfserr_seq_misordered;
1781 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05001782 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04001783 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001784 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04001785 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001786 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001787 return nfserr_seq_misordered;
1788}
1789
Andy Adamson49557cc2009-07-23 19:02:16 -04001790/*
1791 * Cache the create session result into the create session single DRC
1792 * slot cache by saving the xdr structure. sl_seqid has been set.
1793 * Do this for solo or embedded create session operations.
1794 */
1795static void
1796nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001797 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04001798{
1799 slot->sl_status = nfserr;
1800 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1801}
1802
1803static __be32
1804nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1805 struct nfsd4_clid_slot *slot)
1806{
1807 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1808 return slot->sl_status;
1809}
1810
Mi Jinlong1b74c252011-07-14 14:50:17 +08001811#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1812 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1813 1 + /* MIN tag is length with zero, only length */ \
1814 3 + /* version, opcount, opcode */ \
1815 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1816 /* seqid, slotID, slotID, cache */ \
1817 4 ) * sizeof(__be32))
1818
1819#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1820 2 + /* verifier: AUTH_NULL, length 0 */\
1821 1 + /* status */ \
1822 1 + /* MIN tag is length with zero, only length */ \
1823 3 + /* opcount, opcode, opstatus*/ \
1824 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1825 /* seqid, slotID, slotID, slotID, status */ \
1826 5 ) * sizeof(__be32))
1827
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001828static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
Mi Jinlong1b74c252011-07-14 14:50:17 +08001829{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001830 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
1831
J. Bruce Fields373cd402013-04-08 15:42:12 -04001832 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
1833 return nfserr_toosmall;
1834 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
1835 return nfserr_toosmall;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001836 ca->headerpadsz = 0;
1837 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
1838 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
1839 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
1840 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
1841 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
1842 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
1843 /*
1844 * Note decreasing slot size below client's request may make it
1845 * difficult for client to function correctly, whereas
1846 * decreasing the number of slots will (just?) affect
1847 * performance. When short on memory we therefore prefer to
1848 * decrease number of slots instead of their size. Clients that
1849 * request larger slots than they need will get poor results:
1850 */
1851 ca->maxreqs = nfsd4_get_drc_mem(ca);
1852 if (!ca->maxreqs)
1853 return nfserr_jukebox;
1854
J. Bruce Fields373cd402013-04-08 15:42:12 -04001855 return nfs_ok;
Mi Jinlong1b74c252011-07-14 14:50:17 +08001856}
1857
Kinglong Mee8a891632013-12-23 18:11:02 +08001858#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
1859 RPC_MAX_HEADER_WITH_AUTH) * sizeof(__be32))
1860#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
1861 RPC_MAX_REPHEADER_WITH_AUTH) * sizeof(__be32))
1862
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001863static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
1864{
1865 ca->headerpadsz = 0;
1866
1867 /*
1868 * These RPC_MAX_HEADER macros are overkill, especially since we
1869 * don't even do gss on the backchannel yet. But this is still
1870 * less than 1k. Tighten up this estimate in the unlikely event
1871 * it turns out to be a problem for some client:
1872 */
Kinglong Mee8a891632013-12-23 18:11:02 +08001873 if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001874 return nfserr_toosmall;
Kinglong Mee8a891632013-12-23 18:11:02 +08001875 if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001876 return nfserr_toosmall;
1877 ca->maxresp_cached = 0;
1878 if (ca->maxops < 2)
1879 return nfserr_toosmall;
1880
1881 return nfs_ok;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001882}
1883
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04001884static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
1885{
1886 switch (cbs->flavor) {
1887 case RPC_AUTH_NULL:
1888 case RPC_AUTH_UNIX:
1889 return nfs_ok;
1890 default:
1891 /*
1892 * GSS case: the spec doesn't allow us to return this
1893 * error. But it also doesn't allow us not to support
1894 * GSS.
1895 * I'd rather this fail hard than return some error the
1896 * client might think it can already handle:
1897 */
1898 return nfserr_encr_alg_unsupp;
1899 }
1900}
1901
Andy Adamson069b6ad2009-04-03 08:27:58 +03001902__be32
1903nfsd4_create_session(struct svc_rqst *rqstp,
1904 struct nfsd4_compound_state *cstate,
1905 struct nfsd4_create_session *cr_ses)
1906{
Jeff Layton363168b2009-08-14 12:57:56 -04001907 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001908 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001909 struct nfsd4_session *new;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001910 struct nfsd4_conn *conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001911 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001912 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001913 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001914
Mi Jinlonga62573d2011-03-23 17:57:07 +08001915 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1916 return nfserr_inval;
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04001917 status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
1918 if (status)
1919 return status;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001920 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
J. Bruce Fields373cd402013-04-08 15:42:12 -04001921 if (status)
1922 return status;
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001923 status = check_backchannel_attrs(&cr_ses->back_channel);
1924 if (status)
Kinglong Meef403e452013-12-23 17:31:21 +08001925 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001926 status = nfserr_jukebox;
Kinglong Mee60810e52014-01-01 00:35:47 +08001927 new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001928 if (!new)
1929 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001930 conn = alloc_conn_from_crses(rqstp, cr_ses);
1931 if (!conn)
1932 goto out_free_session;
Mi Jinlonga62573d2011-03-23 17:57:07 +08001933
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001934 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001935 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001936 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04001937 WARN_ON_ONCE(conf && unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001938
1939 if (conf) {
J. Bruce Fields57266a62013-04-13 14:27:29 -04001940 status = nfserr_wrong_cred;
1941 if (!mach_creds_match(conf, rqstp))
1942 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001943 cs_slot = &conf->cl_cs_slot;
1944 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001945 if (status == nfserr_replay_cache) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001946 status = nfsd4_replay_create_session(cr_ses, cs_slot);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001947 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001948 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001949 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001950 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001951 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001952 } else if (unconf) {
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001953 struct nfs4_client *old;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001954 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001955 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001956 status = nfserr_clid_inuse;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001957 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001958 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04001959 status = nfserr_wrong_cred;
1960 if (!mach_creds_match(unconf, rqstp))
1961 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001962 cs_slot = &unconf->cl_cs_slot;
1963 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001964 if (status) {
1965 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001966 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001967 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001968 }
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001969 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001970 if (old) {
1971 status = mark_client_expired(old);
1972 if (status)
1973 goto out_free_conn;
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001974 expire_client(old);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001975 }
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001976 move_to_confirmed(unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001977 conf = unconf;
1978 } else {
1979 status = nfserr_stale_clientid;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001980 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001981 }
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001982 status = nfs_ok;
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001983 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001984 * We do not support RDMA or persistent sessions
1985 */
1986 cr_ses->flags &= ~SESSION4_PERSIST;
1987 cr_ses->flags &= ~SESSION4_RDMA;
1988
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001989 init_session(rqstp, new, conf, cr_ses);
1990 nfsd4_init_conn(rqstp, conn, new);
1991
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001992 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001993 NFS4_MAX_SESSIONID_LEN);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001994 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001995 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001996
Andy Adamson49557cc2009-07-23 19:02:16 -04001997 /* cache solo and embedded create sessions under the state lock */
1998 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001999 nfs4_unlock_state();
Andy Adamsonec6b5d72009-04-03 08:28:28 +03002000 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002001out_free_conn:
Yanchuan Nian266533c2012-12-24 18:11:45 +08002002 nfs4_unlock_state();
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04002003 free_conn(conn);
2004out_free_session:
2005 __free_session(new);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04002006out_release_drc_mem:
2007 nfsd4_put_drc_mem(&cr_ses->fore_channel);
J. Bruce Fields1ca50792013-03-14 18:12:03 -04002008 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002009}
2010
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002011static __be32 nfsd4_map_bcts_dir(u32 *dir)
2012{
2013 switch (*dir) {
2014 case NFS4_CDFC4_FORE:
2015 case NFS4_CDFC4_BACK:
2016 return nfs_ok;
2017 case NFS4_CDFC4_FORE_OR_BOTH:
2018 case NFS4_CDFC4_BACK_OR_BOTH:
2019 *dir = NFS4_CDFC4_BOTH;
2020 return nfs_ok;
2021 };
2022 return nfserr_inval;
2023}
2024
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002025__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
2026{
2027 struct nfsd4_session *session = cstate->session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002028 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002029 __be32 status;
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002030
J. Bruce Fieldsb78724b2013-05-15 17:34:39 -04002031 status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2032 if (status)
2033 return status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002034 spin_lock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002035 session->se_cb_prog = bc->bc_cb_program;
2036 session->se_cb_sec = bc->bc_cb_sec;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002037 spin_unlock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002038
2039 nfsd4_probe_callback(session->se_client);
2040
2041 return nfs_ok;
2042}
2043
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002044__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2045 struct nfsd4_compound_state *cstate,
2046 struct nfsd4_bind_conn_to_session *bcts)
2047{
2048 __be32 status;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002049 struct nfsd4_conn *conn;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002050 struct nfsd4_session *session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002051 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002052
2053 if (!nfsd4_last_compound_op(rqstp))
2054 return nfserr_not_only_op;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002055 nfs4_lock_state();
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002056 spin_lock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002057 session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002058 spin_unlock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002059 status = nfserr_badsession;
2060 if (!session)
2061 goto out;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002062 status = nfserr_wrong_cred;
2063 if (!mach_creds_match(session->se_client, rqstp))
2064 goto out;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002065 status = nfsd4_map_bcts_dir(&bcts->dir);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002066 if (status)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002067 goto out;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002068 conn = alloc_conn(rqstp, bcts->dir);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002069 status = nfserr_jukebox;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04002070 if (!conn)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04002071 goto out;
2072 nfsd4_init_conn(rqstp, conn, session);
2073 status = nfs_ok;
2074out:
2075 nfs4_unlock_state();
2076 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002077}
2078
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002079static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2080{
2081 if (!session)
2082 return 0;
2083 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2084}
2085
Andy Adamson069b6ad2009-04-03 08:27:58 +03002086__be32
2087nfsd4_destroy_session(struct svc_rqst *r,
2088 struct nfsd4_compound_state *cstate,
2089 struct nfsd4_destroy_session *sessionid)
2090{
Benny Halevye10e0cf2009-04-03 08:28:38 +03002091 struct nfsd4_session *ses;
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002092 __be32 status;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002093 int ref_held_by_me = 0;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002094 struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002095
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002096 nfs4_lock_state();
2097 status = nfserr_not_only_op;
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002098 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04002099 if (!nfsd4_last_compound_op(r))
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002100 goto out;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002101 ref_held_by_me++;
J. Bruce Fields57716352010-04-21 12:27:19 -04002102 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03002103 dump_sessionid(__func__, &sessionid->sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002104 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002105 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002106 status = nfserr_badsession;
2107 if (!ses)
2108 goto out_client_lock;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002109 status = nfserr_wrong_cred;
2110 if (!mach_creds_match(ses->se_client, r))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002111 goto out_client_lock;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002112 nfsd4_get_session_locked(ses);
2113 status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002114 if (status)
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002115 goto out_put_session;
Benny Halevye10e0cf2009-04-03 08:28:38 +03002116 unhash_session(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002117 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002118
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05002119 nfsd4_probe_callback_sync(ses->se_client);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04002120
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002121 spin_lock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002122 status = nfs_ok;
J. Bruce Fieldsf0f51f52013-06-18 14:26:02 -04002123out_put_session:
2124 nfsd4_put_session(ses);
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002125out_client_lock:
2126 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002127out:
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002128 nfs4_unlock_state();
Benny Halevye10e0cf2009-04-03 08:28:38 +03002129 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002130}
2131
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002132static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002133{
2134 struct nfsd4_conn *c;
2135
2136 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002137 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04002138 return c;
2139 }
2140 }
2141 return NULL;
2142}
2143
J. Bruce Fields57266a62013-04-13 14:27:29 -04002144static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002145{
2146 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002147 struct nfsd4_conn *c;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002148 __be32 status = nfs_ok;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002149 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002150
2151 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002152 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002153 if (c)
2154 goto out_free;
2155 status = nfserr_conn_not_bound_to_session;
2156 if (clp->cl_mach_cred)
2157 goto out_free;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002158 __nfsd4_hash_conn(new, ses);
2159 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002160 ret = nfsd4_register_conn(new);
2161 if (ret)
2162 /* oops; xprt is already down: */
2163 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields57266a62013-04-13 14:27:29 -04002164 return nfs_ok;
2165out_free:
2166 spin_unlock(&clp->cl_lock);
2167 free_conn(new);
2168 return status;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002169}
2170
Mi Jinlong868b89c2011-04-27 09:09:58 +08002171static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2172{
2173 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2174
2175 return args->opcnt > session->se_fchannel.maxops;
2176}
2177
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002178static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2179 struct nfsd4_session *session)
2180{
2181 struct xdr_buf *xb = &rqstp->rq_arg;
2182
2183 return xb->len > session->se_fchannel.maxreq_sz;
2184}
2185
Andy Adamson069b6ad2009-04-03 08:27:58 +03002186__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03002187nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002188 struct nfsd4_compound_state *cstate,
2189 struct nfsd4_sequence *seq)
2190{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002191 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002192 struct nfsd4_session *session;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002193 struct nfs4_client *clp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002194 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002195 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002196 __be32 status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002197 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002198
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002199 if (resp->opcnt != 1)
2200 return nfserr_sequence_pos;
2201
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002202 /*
2203 * Will be either used or freed by nfsd4_sequence_check_conn
2204 * below.
2205 */
2206 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2207 if (!conn)
2208 return nfserr_jukebox;
2209
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002210 spin_lock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002211 status = nfserr_badsession;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002212 session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
Benny Halevyb85d4c02009-04-03 08:28:08 +03002213 if (!session)
J. Bruce Fields221a6872013-04-01 22:23:49 -04002214 goto out_no_session;
2215 clp = session->se_client;
2216 status = get_client_locked(clp);
2217 if (status)
2218 goto out_no_session;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002219 status = nfsd4_get_session_locked(session);
2220 if (status)
2221 goto out_put_client;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002222
Mi Jinlong868b89c2011-04-27 09:09:58 +08002223 status = nfserr_too_many_ops;
2224 if (nfsd4_session_too_many_ops(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002225 goto out_put_session;
Mi Jinlong868b89c2011-04-27 09:09:58 +08002226
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002227 status = nfserr_req_too_big;
2228 if (nfsd4_request_too_big(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002229 goto out_put_session;
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002230
Benny Halevyb85d4c02009-04-03 08:28:08 +03002231 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002232 if (seq->slotid >= session->se_fchannel.maxreqs)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002233 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002234
Andy Adamson557ce262009-08-28 08:45:04 -04002235 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002236 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2237
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002238 /* We do not negotiate the number of slots yet, so set the
2239 * maxslots to the session maxreqs which is used to encode
2240 * sr_highest_slotid and the sr_target_slot id to maxslots */
2241 seq->maxslots = session->se_fchannel.maxreqs;
2242
J. Bruce Fields73e79482012-02-13 16:39:00 -05002243 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2244 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002245 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002246 status = nfserr_seq_misordered;
2247 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002248 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002249 cstate->slot = slot;
2250 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002251 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002252 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002253 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002254 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002255 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002256 }
2257 if (status)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002258 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002259
J. Bruce Fields57266a62013-04-13 14:27:29 -04002260 status = nfsd4_sequence_check_conn(conn, session);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002261 conn = NULL;
J. Bruce Fields57266a62013-04-13 14:27:29 -04002262 if (status)
2263 goto out_put_session;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002264
Benny Halevyb85d4c02009-04-03 08:28:08 +03002265 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03002266 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002267 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05002268 if (seq->cachethis)
2269 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002270 else
2271 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002272
2273 cstate->slot = slot;
2274 cstate->session = session;
2275
Benny Halevyb85d4c02009-04-03 08:28:08 +03002276out:
J. Bruce Fields221a6872013-04-01 22:23:49 -04002277 switch (clp->cl_cb_state) {
2278 case NFSD4_CB_DOWN:
2279 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
2280 break;
2281 case NFSD4_CB_FAULT:
2282 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
2283 break;
2284 default:
2285 seq->status_flags = 0;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002286 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04002287 if (!list_empty(&clp->cl_revoked))
2288 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002289out_no_session:
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002290 kfree(conn);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002291 spin_unlock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002292 return status;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002293out_put_session:
2294 nfsd4_put_session(session);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002295out_put_client:
2296 put_client_renew_locked(clp);
2297 goto out_no_session;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002298}
2299
Mi Jinlong345c2842011-10-20 17:51:39 +08002300__be32
2301nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2302{
2303 struct nfs4_client *conf, *unconf, *clp;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002304 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002305 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Mi Jinlong345c2842011-10-20 17:51:39 +08002306
2307 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002308 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002309 conf = find_confirmed_client(&dc->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002310 WARN_ON_ONCE(conf && unconf);
Mi Jinlong345c2842011-10-20 17:51:39 +08002311
2312 if (conf) {
2313 clp = conf;
2314
J. Bruce Fieldsc0293b02013-03-14 18:20:01 -04002315 if (client_has_state(conf)) {
Mi Jinlong345c2842011-10-20 17:51:39 +08002316 status = nfserr_clientid_busy;
2317 goto out;
2318 }
2319 } else if (unconf)
2320 clp = unconf;
2321 else {
2322 status = nfserr_stale_clientid;
2323 goto out;
2324 }
J. Bruce Fields57266a62013-04-13 14:27:29 -04002325 if (!mach_creds_match(clp, rqstp)) {
2326 status = nfserr_wrong_cred;
2327 goto out;
2328 }
Mi Jinlong345c2842011-10-20 17:51:39 +08002329 expire_client(clp);
2330out:
2331 nfs4_unlock_state();
Mi Jinlong345c2842011-10-20 17:51:39 +08002332 return status;
2333}
2334
Andy Adamson069b6ad2009-04-03 08:27:58 +03002335__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002336nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2337{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002338 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002339
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002340 if (rc->rca_one_fs) {
2341 if (!cstate->current_fh.fh_dentry)
2342 return nfserr_nofilehandle;
2343 /*
2344 * We don't take advantage of the rca_one_fs case.
2345 * That's OK, it's optional, we can safely ignore it.
2346 */
2347 return nfs_ok;
2348 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002349
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002350 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002351 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04002352 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2353 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002354 goto out;
2355
2356 status = nfserr_stale_clientid;
2357 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002358 /*
2359 * The following error isn't really legal.
2360 * But we only get here if the client just explicitly
2361 * destroyed the client. Surely it no longer cares what
2362 * error it gets back on an operation for the dead
2363 * client.
2364 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002365 goto out;
2366
2367 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04002368 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002369out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002370 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002371 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002372}
2373
2374__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002375nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2376 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002378 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 nfs4_verifier clverifier = setclid->se_verf;
NeilBrown28ce6052005-06-23 22:03:56 -07002380 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07002381 __be32 status;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002382 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2383
J. Bruce Fields63db4632012-05-18 21:54:19 -04002384 /* Cases below refer to rfc 3530 section 14.2.33: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002386 conf = find_confirmed_client_by_name(&clname, nn);
NeilBrown28ce6052005-06-23 22:03:56 -07002387 if (conf) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04002388 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002390 if (clp_used_exchangeid(conf))
2391 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04002392 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04002393 char addr_str[INET6_ADDRSTRLEN];
2394 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2395 sizeof(addr_str));
2396 dprintk("NFSD: setclientid: string in use by client "
2397 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 goto out;
2399 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002401 unconf = find_unconfirmed_client_by_name(&clname, nn);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002402 if (unconf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 status = nfserr_jukebox;
Jeff Layton2216d442012-11-12 15:00:57 -05002405 new = create_client(clname, rqstp, &clverifier);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002406 if (new == NULL)
2407 goto out;
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002408 if (conf && same_verf(&conf->cl_verifier, &clverifier))
J. Bruce Fields63db4632012-05-18 21:54:19 -04002409 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 copy_clid(new, conf);
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002411 else /* case 4 (new client) or cases 2, 3 (client reboot): */
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002412 gen_clid(new, nn);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002413 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002414 gen_callback(new, setclid, rqstp);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002415 add_to_unconfirmed(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2417 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2418 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2419 status = nfs_ok;
2420out:
2421 nfs4_unlock_state();
2422 return status;
2423}
2424
2425
Al Virob37ad282006-10-19 23:28:59 -07002426__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002427nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2428 struct nfsd4_compound_state *cstate,
2429 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430{
NeilBrown21ab45a2005-06-23 22:04:14 -07002431 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2433 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002434 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03002435 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002437 if (STALE_CLIENTID(clid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 return nfserr_stale_clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002440
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002441 conf = find_confirmed_client(clid, false, nn);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002442 unconf = find_unconfirmed_client(clid, false, nn);
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002443 /*
J. Bruce Fields8695b902012-05-19 10:05:58 -04002444 * We try hard to give out unique clientid's, so if we get an
2445 * attempt to confirm the same clientid with a different cred,
2446 * there's a bug somewhere. Let's charitably assume it's our
2447 * bug.
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002448 */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002449 status = nfserr_serverfault;
2450 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2451 goto out;
2452 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2453 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04002454 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002455 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2456 if (conf && !unconf) /* case 2: probable retransmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 status = nfs_ok;
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002458 else /* case 4: client hasn't noticed we rebooted yet? */
2459 status = nfserr_stale_clientid;
2460 goto out;
2461 }
2462 status = nfs_ok;
2463 if (conf) { /* case 1: callback update */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002464 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2465 nfsd4_probe_callback(conf);
2466 expire_client(unconf);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002467 } else { /* case 3: normal case; new or rebooted client */
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002468 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002469 if (conf) {
2470 status = mark_client_expired(conf);
2471 if (status)
2472 goto out;
J. Bruce Fields8695b902012-05-19 10:05:58 -04002473 expire_client(conf);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002474 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04002475 move_to_confirmed(unconf);
J. Bruce Fieldsf3d03b92012-05-23 11:38:38 -04002476 nfsd4_probe_callback(unconf);
NeilBrown08e89872005-06-23 22:04:11 -07002477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 nfs4_unlock_state();
2480 return status;
2481}
2482
J. Bruce Fields32513b42011-10-13 16:00:16 -04002483static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484{
J. Bruce Fields32513b42011-10-13 16:00:16 -04002485 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2486}
2487
2488/* OPEN Share state helper functions */
2489static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2490{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 unsigned int hashval = file_hashval(ino);
2492
J. Bruce Fields32513b42011-10-13 16:00:16 -04002493 atomic_set(&fp->fi_ref, 1);
J. Bruce Fields32513b42011-10-13 16:00:16 -04002494 INIT_LIST_HEAD(&fp->fi_stateids);
2495 INIT_LIST_HEAD(&fp->fi_delegations);
2496 fp->fi_inode = igrab(ino);
2497 fp->fi_had_conflict = false;
2498 fp->fi_lease = NULL;
2499 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2500 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2501 spin_lock(&recall_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002502 hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
J. Bruce Fields32513b42011-10-13 16:00:16 -04002503 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504}
2505
2506static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002507nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002508{
NeilBrowne60d4392005-06-23 22:03:01 -07002509 if (*slab == NULL)
2510 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002511 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002512 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002513}
2514
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002515void
NeilBrowne60d4392005-06-23 22:03:01 -07002516nfsd4_free_slabs(void)
2517{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002518 nfsd4_free_slab(&openowner_slab);
2519 nfsd4_free_slab(&lockowner_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002520 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002521 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002522 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002523}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524
Bryan Schumaker72083392011-11-01 15:24:59 -04002525int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526nfsd4_init_slabs(void)
2527{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002528 openowner_slab = kmem_cache_create("nfsd4_openowners",
2529 sizeof(struct nfs4_openowner), 0, 0, NULL);
2530 if (openowner_slab == NULL)
2531 goto out_nomem;
2532 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
Yanchuan Nian3c407942012-10-24 14:44:19 +08002533 sizeof(struct nfs4_lockowner), 0, 0, NULL);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002534 if (lockowner_slab == NULL)
NeilBrowne60d4392005-06-23 22:03:01 -07002535 goto out_nomem;
2536 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002537 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002538 if (file_slab == NULL)
2539 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002540 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002541 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002542 if (stateid_slab == NULL)
2543 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002544 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002545 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002546 if (deleg_slab == NULL)
2547 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002549out_nomem:
2550 nfsd4_free_slabs();
2551 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2552 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553}
2554
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002555void nfs4_free_openowner(struct nfs4_openowner *oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002557 kfree(oo->oo_owner.so_owner.data);
2558 kmem_cache_free(openowner_slab, oo);
2559}
2560
2561void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2562{
2563 kfree(lo->lo_owner.so_owner.data);
2564 kmem_cache_free(lockowner_slab, lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565}
2566
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002567static void init_nfs4_replay(struct nfs4_replay *rp)
2568{
2569 rp->rp_status = nfserr_serverfault;
2570 rp->rp_buflen = 0;
2571 rp->rp_buf = rp->rp_ibuf;
2572}
2573
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002574static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575{
2576 struct nfs4_stateowner *sop;
2577
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002578 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002579 if (!sop)
2580 return NULL;
2581
2582 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2583 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002584 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002585 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002587 sop->so_owner.len = owner->len;
2588
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002589 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002590 sop->so_client = clp;
2591 init_nfs4_replay(&sop->so_replay);
2592 return sop;
2593}
2594
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002595static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002596{
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002597 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2598
2599 list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002600 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601}
2602
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002603static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002605 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002607 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2608 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002610 oo->oo_owner.so_is_open_owner = 1;
2611 oo->oo_owner.so_seqid = open->op_seqid;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04002612 oo->oo_flags = NFS4_OO_NEW;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002613 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04002614 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002615 INIT_LIST_HEAD(&oo->oo_close_lru);
2616 hash_openowner(oo, clp, strhashval);
2617 return oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618}
2619
J. Bruce Fields996e0932011-10-17 11:14:48 -04002620static 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 -04002621 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
J. Bruce Fields3abdb602013-02-03 12:23:01 -05002623 stp->st_stid.sc_type = NFS4_OPEN_STID;
NeilBrownea1da632005-06-23 22:04:17 -07002624 INIT_LIST_HEAD(&stp->st_lockowners);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002625 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002626 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002627 stp->st_stateowner = &oo->oo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07002628 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 stp->st_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 stp->st_access_bmap = 0;
2631 stp->st_deny_bmap = 0;
Jeff Layton82c5ff12012-05-11 09:45:13 -04002632 set_access(open->op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002633 set_deny(open->op_share_deny, stp);
NeilBrown4c4cd222005-07-07 17:59:27 -07002634 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635}
2636
2637static void
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002638move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639{
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002640 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2641
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002642 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002644 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002645 oo->oo_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646}
2647
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002649same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2650 clientid_t *clid)
2651{
2652 return (sop->so_owner.len == owner->len) &&
2653 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2654 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655}
2656
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002657static struct nfs4_openowner *
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002658find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2659 bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660{
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002661 struct nfs4_stateowner *so;
2662 struct nfs4_openowner *oo;
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002663 struct nfs4_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002665 list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002666 if (!so->so_is_open_owner)
2667 continue;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002668 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2669 oo = openowner(so);
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002670 clp = oo->oo_owner.so_client;
2671 if ((bool)clp->cl_minorversion != sessions)
2672 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002673 renew_client(oo->oo_owner.so_client);
2674 return oo;
2675 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 }
2677 return NULL;
2678}
2679
2680/* search file_hashtbl[] for file */
2681static struct nfs4_file *
2682find_file(struct inode *ino)
2683{
2684 unsigned int hashval = file_hashval(ino);
2685 struct nfs4_file *fp;
2686
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002687 spin_lock(&recall_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002688 hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002689 if (fp->fi_inode == ino) {
2690 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002691 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002695 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 return NULL;
2697}
2698
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002699/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 * Called to check deny when READ with all zero stateid or
2701 * WRITE with all zero or all one stateid
2702 */
Al Virob37ad282006-10-19 23:28:59 -07002703static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2705{
2706 struct inode *ino = current_fh->fh_dentry->d_inode;
2707 struct nfs4_file *fp;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002708 struct nfs4_ol_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002709 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002712 if (!fp)
2713 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002714 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002716 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
Jeff Laytonce0fc432012-05-11 09:45:14 -04002717 if (test_deny(deny_type, stp) ||
2718 test_deny(NFS4_SHARE_DENY_BOTH, stp))
NeilBrown13cd2182005-06-23 22:03:10 -07002719 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 }
NeilBrown13cd2182005-06-23 22:03:10 -07002721 ret = nfs_ok;
2722out:
2723 put_nfs4_file(fp);
2724 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725}
2726
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002727static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728{
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002729 struct nfs4_client *clp = dp->dl_stid.sc_client;
2730 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2731
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 /* We're assuming the state code never drops its reference
2733 * without first removing the lease. Since we're in this lease
2734 * callback (and since the lease code is serialized by the kernel
2735 * lock) we know the server hasn't removed the lease yet, we know
2736 * it's safe to take a reference: */
2737 atomic_inc(&dp->dl_count);
2738
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002739 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740
Jeff Layton1c8c6012013-06-21 08:58:15 -04002741 /* Only place dl_time is set; protected by i_lock: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 dp->dl_time = get_seconds();
2743
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002744 nfsd4_cb_recall(dp);
2745}
2746
Jeff Layton1c8c6012013-06-21 08:58:15 -04002747/* Called from break_lease() with i_lock held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002748static void nfsd_break_deleg_cb(struct file_lock *fl)
2749{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002750 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2751 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002752
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04002753 if (!fp) {
2754 WARN(1, "(%p)->fl_owner NULL\n", fl);
2755 return;
2756 }
2757 if (fp->fi_had_conflict) {
2758 WARN(1, "duplicate break on %p\n", fp);
2759 return;
2760 }
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002761 /*
2762 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002763 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002764 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002765 */
2766 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002768 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002769 fp->fi_had_conflict = true;
2770 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2771 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002772 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773}
2774
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775static
2776int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2777{
2778 if (arg & F_UNLCK)
2779 return lease_modify(onlist, arg);
2780 else
2781 return -EAGAIN;
2782}
2783
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002784static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002785 .lm_break = nfsd_break_deleg_cb,
2786 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787};
2788
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04002789static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2790{
2791 if (nfsd4_has_session(cstate))
2792 return nfs_ok;
2793 if (seqid == so->so_seqid - 1)
2794 return nfserr_replay_me;
2795 if (seqid == so->so_seqid)
2796 return nfs_ok;
2797 return nfserr_bad_seqid;
2798}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799
Al Virob37ad282006-10-19 23:28:59 -07002800__be32
Andy Adamson66689582009-04-03 08:28:45 +03002801nfsd4_process_open1(struct nfsd4_compound_state *cstate,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03002802 struct nfsd4_open *open, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 clientid_t *clientid = &open->op_clientid;
2805 struct nfs4_client *clp = NULL;
2806 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002807 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002808 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002810 if (STALE_CLIENTID(&open->op_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04002812 /*
2813 * In case we need it later, after we've already created the
2814 * file and don't want to risk a further failure:
2815 */
2816 open->op_file = nfsd4_alloc_file();
2817 if (open->op_file == NULL)
2818 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002820 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002821 oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002822 open->op_openowner = oo;
2823 if (!oo) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002824 clp = find_confirmed_client(clientid, cstate->minorversion,
2825 nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002827 return nfserr_expired;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002828 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002830 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002831 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002832 clp = oo->oo_owner.so_client;
2833 release_openowner(oo);
2834 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002835 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002836 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002837 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2838 if (status)
2839 return status;
2840 clp = oo->oo_owner.so_client;
2841 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002842new_owner:
2843 oo = alloc_init_open_stateowner(strhashval, clp, open);
2844 if (oo == NULL)
2845 return nfserr_jukebox;
2846 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002847alloc_stateid:
2848 open->op_stp = nfs4_alloc_stateid(clp);
2849 if (!open->op_stp)
2850 return nfserr_jukebox;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002851 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852}
2853
Al Virob37ad282006-10-19 23:28:59 -07002854static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002855nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2856{
2857 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2858 return nfserr_openmode;
2859 else
2860 return nfs_ok;
2861}
2862
Daniel Mackc47d8322011-05-16 16:38:14 +02002863static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002864{
J. Bruce Fields24a01112010-05-18 20:01:35 -04002865 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2866}
2867
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002868static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002869{
2870 struct nfs4_stid *ret;
2871
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002872 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002873 if (!ret)
2874 return NULL;
2875 return delegstateid(ret);
2876}
2877
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002878static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2879{
2880 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2881 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2882}
2883
Al Virob37ad282006-10-19 23:28:59 -07002884static __be32
J. Bruce Fields41d22662013-03-21 15:49:47 -04002885nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07002886 struct nfs4_delegation **dp)
2887{
2888 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002889 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002890
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002891 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
NeilBrown567d9822005-06-23 22:02:53 -07002892 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002893 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002894 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002895 status = nfs4_check_delegmode(*dp, flags);
2896 if (status)
2897 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002898out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002899 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07002900 return nfs_ok;
2901 if (status)
2902 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002903 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002904 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002905}
2906
Al Virob37ad282006-10-19 23:28:59 -07002907static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002908nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002910 struct nfs4_ol_stateid *local;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002911 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912
NeilBrown8beefa22005-06-23 22:03:08 -07002913 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 /* ignore lock owners */
2915 if (local->st_stateowner->so_is_open_owner == 0)
2916 continue;
2917 /* remember if we have seen this open owner */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002918 if (local->st_stateowner == &oo->oo_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 *stpp = local;
2920 /* check for conflicting share reservations */
2921 if (!test_share(local, open))
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002922 return nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 }
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002924 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925}
2926
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002927static inline int nfs4_access_to_access(u32 nfs4_access)
2928{
2929 int flags = 0;
2930
2931 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2932 flags |= NFSD_MAY_READ;
2933 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2934 flags |= NFSD_MAY_WRITE;
2935 return flags;
2936}
2937
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002938static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2939 struct svc_fh *cur_fh, struct nfsd4_open *open)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002940{
2941 __be32 status;
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002942 int oflag = nfs4_access_to_omode(open->op_share_access);
2943 int access = nfs4_access_to_access(open->op_share_access);
2944
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002945 if (!fp->fi_fds[oflag]) {
2946 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2947 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002948 if (status)
2949 return status;
2950 }
2951 nfs4_file_get_access(fp, oflag);
2952
2953 return nfs_ok;
2954}
2955
Al Virob37ad282006-10-19 23:28:59 -07002956static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2958 struct nfsd4_open *open)
2959{
2960 struct iattr iattr = {
2961 .ia_valid = ATTR_SIZE,
2962 .ia_size = 0,
2963 };
2964 if (!open->op_truncate)
2965 return 0;
2966 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002967 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2969}
2970
Al Virob37ad282006-10-19 23:28:59 -07002971static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002972nfs4_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 -07002973{
J. Bruce Fieldsb6d2f1c2011-10-10 17:44:19 -04002974 u32 op_share_access = open->op_share_access;
J. Bruce Fields7d947842010-08-20 18:09:31 -04002975 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002976 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977
Jeff Layton82c5ff12012-05-11 09:45:13 -04002978 new_access = !test_access(op_share_access, stp);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002979 if (new_access) {
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002980 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002981 if (status)
2982 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 status = nfsd4_truncate(rqstp, cur_fh, open);
2985 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002986 if (new_access) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04002987 int oflag = nfs4_access_to_omode(op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002988 nfs4_file_put_access(fp, oflag);
2989 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 return status;
2991 }
2992 /* remember the open */
Jeff Layton82c5ff12012-05-11 09:45:13 -04002993 set_access(op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002994 set_deny(open->op_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995
2996 return nfs_ok;
2997}
2998
2999
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000static void
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003001nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002{
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003003 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004}
3005
J. Bruce Fields14a24e92010-12-10 19:02:49 -05003006/* Should we give out recallable state?: */
3007static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
3008{
3009 if (clp->cl_cb_state == NFSD4_CB_UP)
3010 return true;
3011 /*
3012 * In the sessions case, since we don't have to establish a
3013 * separate connection for callbacks, we assume it's OK
3014 * until we hear otherwise:
3015 */
3016 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
3017}
3018
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003019static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
3020{
3021 struct file_lock *fl;
3022
3023 fl = locks_alloc_lock();
3024 if (!fl)
3025 return NULL;
3026 locks_init_lock(fl);
3027 fl->fl_lmops = &nfsd_lease_mng_ops;
J. Bruce Fields617588d2011-07-01 15:18:34 -04003028 fl->fl_flags = FL_DELEG;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003029 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
3030 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003031 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003032 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05003033 return fl;
3034}
3035
J. Bruce Fields99c41512013-05-21 16:21:25 -04003036static int nfs4_setlease(struct nfs4_delegation *dp)
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003037{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003038 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003039 struct file_lock *fl;
3040 int status;
3041
J. Bruce Fields99c41512013-05-21 16:21:25 -04003042 fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003043 if (!fl)
3044 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003045 fl->fl_file = find_readable_file(fp);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003046 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldse8730882012-01-23 13:52:01 -05003047 if (status)
3048 goto out_free;
3049 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003050 fp->fi_lease = fl;
Al Virocb0942b2012-08-27 14:48:26 -04003051 fp->fi_deleg_file = get_file(fl->fl_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003052 atomic_set(&fp->fi_delegees, 1);
3053 list_add(&dp->dl_perfile, &fp->fi_delegations);
3054 return 0;
J. Bruce Fieldse8730882012-01-23 13:52:01 -05003055out_free:
3056 locks_free_lock(fl);
3057 return status;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003058}
3059
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003060static int nfs4_set_delegation(struct nfs4_delegation *dp, struct nfs4_file *fp)
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003061{
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003062 int status;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003063
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003064 if (fp->fi_had_conflict)
3065 return -EAGAIN;
3066 get_nfs4_file(fp);
3067 dp->dl_file = fp;
3068 if (!fp->fi_lease) {
3069 status = nfs4_setlease(dp);
3070 if (status)
3071 goto out_free;
3072 return 0;
3073 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003074 spin_lock(&recall_lock);
3075 if (fp->fi_had_conflict) {
3076 spin_unlock(&recall_lock);
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003077 status = -EAGAIN;
3078 goto out_free;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003079 }
3080 atomic_inc(&fp->fi_delegees);
3081 list_add(&dp->dl_perfile, &fp->fi_delegations);
3082 spin_unlock(&recall_lock);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04003083 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003084 return 0;
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003085out_free:
3086 put_nfs4_file(fp);
3087 dp->dl_file = fp;
3088 return status;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003089}
3090
Benny Halevy4aa89132012-02-21 14:16:44 -08003091static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
3092{
3093 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3094 if (status == -EAGAIN)
3095 open->op_why_no_deleg = WND4_CONTENTION;
3096 else {
3097 open->op_why_no_deleg = WND4_RESOURCE;
3098 switch (open->op_deleg_want) {
3099 case NFS4_SHARE_WANT_READ_DELEG:
3100 case NFS4_SHARE_WANT_WRITE_DELEG:
3101 case NFS4_SHARE_WANT_ANY_DELEG:
3102 break;
3103 case NFS4_SHARE_WANT_CANCEL:
3104 open->op_why_no_deleg = WND4_CANCELLED;
3105 break;
3106 case NFS4_SHARE_WANT_NO_DELEG:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003107 WARN_ON_ONCE(1);
Benny Halevy4aa89132012-02-21 14:16:44 -08003108 }
3109 }
3110}
3111
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112/*
3113 * Attempt to hand out a delegation.
J. Bruce Fields99c41512013-05-21 16:21:25 -04003114 *
3115 * Note we don't support write delegations, and won't until the vfs has
3116 * proper support for them.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 */
3118static void
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003119nfs4_open_delegation(struct net *net, struct svc_fh *fh,
3120 struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121{
3122 struct nfs4_delegation *dp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003123 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
J. Bruce Fields14a24e92010-12-10 19:02:49 -05003124 int cb_up;
J. Bruce Fields99c41512013-05-21 16:21:25 -04003125 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003127 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
NeilBrown7b190fe2005-06-23 22:03:23 -07003128 open->op_recall = 0;
3129 switch (open->op_claim_type) {
3130 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05003131 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07003132 open->op_recall = 1;
J. Bruce Fields99c41512013-05-21 16:21:25 -04003133 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
3134 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003135 break;
3136 case NFS4_OPEN_CLAIM_NULL:
Ming Chened47b062014-01-09 21:26:10 +00003137 case NFS4_OPEN_CLAIM_FH:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003138 /*
3139 * Let's not give out any delegations till everyone's
3140 * had the chance to reclaim theirs....
3141 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003142 if (locks_in_grace(net))
J. Bruce Fields99c41512013-05-21 16:21:25 -04003143 goto out_no_deleg;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003144 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
J. Bruce Fields99c41512013-05-21 16:21:25 -04003145 goto out_no_deleg;
Steve Dickson9a0590a2013-05-15 14:51:49 -04003146 /*
3147 * Also, if the file was opened for write or
3148 * create, there's a good chance the client's
3149 * about to write to it, resulting in an
3150 * immediate recall (since we don't support
3151 * write delegations):
3152 */
NeilBrown7b190fe2005-06-23 22:03:23 -07003153 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
J. Bruce Fields99c41512013-05-21 16:21:25 -04003154 goto out_no_deleg;
3155 if (open->op_create == NFS4_OPEN_CREATE)
3156 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003157 break;
3158 default:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003159 goto out_no_deleg;
NeilBrown7b190fe2005-06-23 22:03:23 -07003160 }
J. Bruce Fields99c41512013-05-21 16:21:25 -04003161 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003162 if (dp == NULL)
3163 goto out_no_deleg;
J. Bruce Fieldsbf7bd3e2013-08-15 16:55:26 -04003164 status = nfs4_set_delegation(dp, stp->st_file);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003165 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003166 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003168 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003170 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003171 STATEID_VAL(&dp->dl_stid.sc_stateid));
J. Bruce Fields99c41512013-05-21 16:21:25 -04003172 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003173 return;
3174out_free:
J. Bruce Fieldsb78800b2013-11-04 17:46:04 -05003175 remove_stid(&dp->dl_stid);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003176 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003177out_no_deleg:
J. Bruce Fields99c41512013-05-21 16:21:25 -04003178 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
3179 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04003180 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
J. Bruce Fields99c41512013-05-21 16:21:25 -04003181 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
J. Bruce Fieldsd08d32e2013-06-21 11:05:32 -04003182 open->op_recall = 1;
3183 }
J. Bruce Fields99c41512013-05-21 16:21:25 -04003184
3185 /* 4.1 client asking for a delegation? */
3186 if (open->op_deleg_want)
3187 nfsd4_open_deleg_none_ext(open, status);
3188 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189}
3190
Benny Halevye27f49c2012-02-21 14:16:54 -08003191static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
3192 struct nfs4_delegation *dp)
3193{
3194 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
3195 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3196 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3197 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
3198 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3199 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3200 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3201 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3202 }
3203 /* Otherwise the client must be confused wanting a delegation
3204 * it already has, therefore we don't return
3205 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
3206 */
3207}
3208
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209/*
3210 * called with nfs4_lock_state() held.
3211 */
Al Virob37ad282006-10-19 23:28:59 -07003212__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3214{
Andy Adamson66689582009-04-03 08:28:45 +03003215 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003216 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 struct nfs4_file *fp = NULL;
3218 struct inode *ino = current_fh->fh_dentry->d_inode;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003219 struct nfs4_ol_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07003220 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003221 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 /*
3224 * Lookup file; if found, lookup stateid and check open request,
3225 * and check for delegations in the process of being recalled.
3226 * If not found, create the nfs4_file struct
3227 */
3228 fp = find_file(ino);
3229 if (fp) {
3230 if ((status = nfs4_check_open(fp, open, &stp)))
3231 goto out;
J. Bruce Fields41d22662013-03-21 15:49:47 -04003232 status = nfs4_check_deleg(cl, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07003233 if (status)
3234 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07003236 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003237 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003238 goto out;
J. Bruce Fields3e772462011-08-10 19:07:33 -04003239 status = nfserr_jukebox;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003240 fp = open->op_file;
3241 open->op_file = NULL;
3242 nfsd4_init_file(fp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 }
3244
3245 /*
3246 * OPEN the file, or upgrade an existing OPEN.
3247 * If truncate fails, the OPEN fails.
3248 */
3249 if (stp) {
3250 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003251 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252 if (status)
3253 goto out;
3254 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003255 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07003256 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 goto out;
J. Bruce Fields4af82502012-06-07 17:30:45 -04003258 status = nfsd4_truncate(rqstp, current_fh, open);
3259 if (status)
3260 goto out;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003261 stp = open->op_stp;
3262 open->op_stp = NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003263 init_open_stateid(stp, fp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003265 update_stateid(&stp->st_stid.sc_stateid);
3266 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267
Benny Halevyd24433c2012-02-16 20:57:17 +02003268 if (nfsd4_has_session(&resp->cstate)) {
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003269 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Andy Adamson66689582009-04-03 08:28:45 +03003270
Benny Halevyd24433c2012-02-16 20:57:17 +02003271 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3272 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3273 open->op_why_no_deleg = WND4_NOT_WANTED;
3274 goto nodeleg;
3275 }
3276 }
3277
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 /*
3279 * Attempt to hand out a delegation. No error return, because the
3280 * OPEN succeeds even if we fail.
3281 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003282 nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003283nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 status = nfs_ok;
3285
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003286 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003287 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288out:
Benny Halevyd24433c2012-02-16 20:57:17 +02003289 /* 4.1 client trying to upgrade/downgrade delegation? */
3290 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08003291 open->op_deleg_want)
3292 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003293
NeilBrown13cd2182005-06-23 22:03:10 -07003294 if (fp)
3295 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07003296 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003297 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 /*
3299 * To finish the open response, we just need to set the rflags.
3300 */
3301 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003302 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03003303 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3305
3306 return status;
3307}
3308
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003309void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3310{
3311 if (open->op_openowner) {
3312 struct nfs4_openowner *oo = open->op_openowner;
3313
3314 if (!list_empty(&oo->oo_owner.so_stateids))
3315 list_del_init(&oo->oo_close_lru);
3316 if (oo->oo_flags & NFS4_OO_NEW) {
3317 if (status) {
3318 release_openowner(oo);
3319 open->op_openowner = NULL;
3320 } else
3321 oo->oo_flags &= ~NFS4_OO_NEW;
3322 }
3323 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04003324 if (open->op_file)
3325 nfsd4_free_file(open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003326 if (open->op_stp)
J. Bruce Fieldsef798592012-08-29 10:32:54 -07003327 free_generic_stateid(open->op_stp);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003328}
3329
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003330static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
3331{
3332 struct nfs4_client *found;
3333
3334 if (STALE_CLIENTID(clid, nn))
3335 return nfserr_stale_clientid;
3336 found = find_confirmed_client(clid, session, nn);
3337 if (clp)
3338 *clp = found;
3339 return found ? nfs_ok : nfserr_expired;
3340}
3341
Al Virob37ad282006-10-19 23:28:59 -07003342__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003343nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3344 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345{
3346 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07003347 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03003348 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349
3350 nfs4_lock_state();
3351 dprintk("process_renew(%08x/%08x): starting\n",
3352 clid->cl_boot, clid->cl_id);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003353 status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
3354 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07003357 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04003358 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359 goto out;
3360 status = nfs_ok;
3361out:
3362 nfs4_unlock_state();
3363 return status;
3364}
3365
NeilBrowna76b4312005-06-23 22:04:01 -07003366static void
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003367nfsd4_end_grace(struct nfsd_net *nn)
NeilBrowna76b4312005-06-23 22:04:01 -07003368{
Jeff Layton33dcc482012-04-10 11:08:48 -04003369 /* do nothing if grace period already ended */
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003370 if (nn->grace_ended)
Jeff Layton33dcc482012-04-10 11:08:48 -04003371 return;
3372
NeilBrowna76b4312005-06-23 22:04:01 -07003373 dprintk("NFSD: end of grace period\n");
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003374 nn->grace_ended = true;
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003375 nfsd4_record_grace_done(nn, nn->boot_time);
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04003376 locks_end_grace(&nn->nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05003377 /*
3378 * Now that every NFSv4 client has had the chance to recover and
3379 * to see the (possibly new, possibly shorter) lease time, we
3380 * can safely set the next grace time to the current lease time:
3381 */
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03003382 nn->nfsd4_grace = nn->nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07003383}
3384
NeilBrownfd39ca92005-06-23 22:04:03 -07003385static time_t
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003386nfs4_laundromat(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387{
3388 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003389 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390 struct nfs4_delegation *dp;
3391 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003392 time_t cutoff = get_seconds() - nn->nfsd4_lease;
3393 time_t t, clientid_val = nn->nfsd4_lease;
3394 time_t u, test_val = nn->nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395
3396 nfs4_lock_state();
3397
3398 dprintk("NFSD: laundromat service - starting\n");
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003399 nfsd4_end_grace(nn);
Benny Halevy36acb662010-05-12 00:13:04 +03003400 INIT_LIST_HEAD(&reaplist);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003401 spin_lock(&nn->client_lock);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03003402 list_for_each_safe(pos, next, &nn->client_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 clp = list_entry(pos, struct nfs4_client, cl_lru);
3404 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3405 t = clp->cl_time - cutoff;
3406 if (clientid_val > t)
3407 clientid_val = t;
3408 break;
3409 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003410 if (mark_client_expired_locked(clp)) {
Benny Halevyd7682982010-05-12 00:13:54 +03003411 dprintk("NFSD: client in use (clientid %08x)\n",
3412 clp->cl_clientid.cl_id);
3413 continue;
3414 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003415 list_move(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03003416 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003417 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03003418 list_for_each_safe(pos, next, &reaplist) {
3419 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003420 dprintk("NFSD: purging unused client (clientid %08x)\n",
3421 clp->cl_clientid.cl_id);
3422 expire_client(clp);
3423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424 spin_lock(&recall_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04003425 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Stanislav Kinsbursky4e37a7c22012-11-26 15:22:03 +03003427 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3428 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3430 u = dp->dl_time - cutoff;
3431 if (test_val > u)
3432 test_val = u;
3433 break;
3434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435 list_move(&dp->dl_recall_lru, &reaplist);
3436 }
3437 spin_unlock(&recall_lock);
3438 list_for_each_safe(pos, next, &reaplist) {
3439 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003440 revoke_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003441 }
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003442 test_val = nn->nfsd4_lease;
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003443 list_for_each_safe(pos, next, &nn->close_lru) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003444 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3445 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3446 u = oo->oo_time - cutoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447 if (test_val > u)
3448 test_val = u;
3449 break;
3450 }
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003451 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 }
3453 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3454 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3455 nfs4_unlock_state();
3456 return clientid_val;
3457}
3458
Harvey Harrisona254b242008-02-20 12:49:00 -08003459static struct workqueue_struct *laundry_wq;
3460static void laundromat_main(struct work_struct *);
Harvey Harrisona254b242008-02-20 12:49:00 -08003461
3462static void
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003463laundromat_main(struct work_struct *laundry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464{
3465 time_t t;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003466 struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3467 work);
3468 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3469 laundromat_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003470
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003471 t = nfs4_laundromat(nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003473 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474}
3475
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003476static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07003477{
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003478 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3479 return nfserr_bad_stateid;
3480 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481}
3482
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003484access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003486 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3487 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3488 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489}
3490
3491static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003492access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003494 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3495 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496}
3497
3498static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003499__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500{
Al Virob37ad282006-10-19 23:28:59 -07003501 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502
J. Bruce Fields02921912010-07-29 15:16:59 -04003503 /* For lock stateid's, we test the parent open, not the lock: */
3504 if (stp->st_openstp)
3505 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003506 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003508 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 goto out;
3510 status = nfs_ok;
3511out:
3512 return status;
3513}
3514
Al Virob37ad282006-10-19 23:28:59 -07003515static inline __be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003516check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003517{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003518 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519 return nfs_ok;
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003520 else if (locks_in_grace(net)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003521 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 * conflicting state; so we must wait out the grace period. */
3523 return nfserr_grace;
3524 } else if (flags & WR_STATE)
3525 return nfs4_share_conflict(current_fh,
3526 NFS4_SHARE_DENY_WRITE);
3527 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3528 return nfs4_share_conflict(current_fh,
3529 NFS4_SHARE_DENY_READ);
3530}
3531
3532/*
3533 * Allow READ/WRITE during grace period on recovered state only for files
3534 * that are not able to provide mandatory locking.
3535 */
3536static inline int
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003537grace_disallows_io(struct net *net, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003538{
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003539 return locks_in_grace(net) && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540}
3541
J. Bruce Fields81b82962011-08-23 11:03:29 -04003542/* Returns true iff a is later than b: */
3543static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3544{
Jim Rees1a9357f2013-05-17 17:33:00 -04003545 return (s32)(a->si_generation - b->si_generation) > 0;
J. Bruce Fields81b82962011-08-23 11:03:29 -04003546}
3547
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003548static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003549{
Andy Adamson66689582009-04-03 08:28:45 +03003550 /*
3551 * When sessions are used the stateid generation number is ignored
3552 * when it is zero.
3553 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04003554 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04003555 return nfs_ok;
3556
3557 if (in->si_generation == ref->si_generation)
3558 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03003559
J. Bruce Fields0836f582008-01-26 19:08:12 -05003560 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003561 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05003562 return nfserr_bad_stateid;
3563 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04003564 * However, we could see a stateid from the past, even from a
3565 * non-buggy client. For example, if the client sends a lock
3566 * while some IO is outstanding, the lock may bump si_generation
3567 * while the IO is still in flight. The client could avoid that
3568 * situation by waiting for responses on all the IO requests,
3569 * but better performance may result in retrying IO that
3570 * receives an old_stateid error if requests are rarely
3571 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003572 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003573 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003574}
3575
Chuck Lever7df302f2012-05-29 13:56:37 -04003576static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04003577{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003578 struct nfs4_stid *s;
3579 struct nfs4_ol_stateid *ols;
3580 __be32 status;
Bryan Schumaker17456802011-07-13 10:50:48 -04003581
Chuck Lever7df302f2012-05-29 13:56:37 -04003582 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3583 return nfserr_bad_stateid;
3584 /* Client debugging aid. */
3585 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3586 char addr_str[INET6_ADDRSTRLEN];
3587 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3588 sizeof(addr_str));
3589 pr_warn_ratelimited("NFSD: client %s testing state ID "
3590 "with incorrect client ID\n", addr_str);
3591 return nfserr_bad_stateid;
3592 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003593 s = find_stateid(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003594 if (!s)
Chuck Lever7df302f2012-05-29 13:56:37 -04003595 return nfserr_bad_stateid;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04003596 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04003597 if (status)
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003598 return status;
J. Bruce Fields23340032013-04-09 17:42:28 -04003599 switch (s->sc_type) {
3600 case NFS4_DELEG_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003601 return nfs_ok;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003602 case NFS4_REVOKED_DELEG_STID:
3603 return nfserr_deleg_revoked;
J. Bruce Fields23340032013-04-09 17:42:28 -04003604 case NFS4_OPEN_STID:
3605 case NFS4_LOCK_STID:
3606 ols = openlockstateid(s);
3607 if (ols->st_stateowner->so_is_open_owner
3608 && !(openowner(ols->st_stateowner)->oo_flags
3609 & NFS4_OO_CONFIRMED))
3610 return nfserr_bad_stateid;
3611 return nfs_ok;
3612 default:
3613 printk("unknown stateid type %x\n", s->sc_type);
3614 case NFS4_CLOSED_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003615 return nfserr_bad_stateid;
J. Bruce Fields23340032013-04-09 17:42:28 -04003616 }
Bryan Schumaker17456802011-07-13 10:50:48 -04003617}
3618
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003619static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
3620 struct nfs4_stid **s, bool sessions,
3621 struct nfsd_net *nn)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003622{
3623 struct nfs4_client *cl;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003624 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003625
3626 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3627 return nfserr_bad_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003628 status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
3629 nn, &cl);
3630 if (status == nfserr_stale_clientid)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003631 return nfserr_stale_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003632 if (status)
3633 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003634 *s = find_stateid_by_type(cl, stateid, typemask);
3635 if (!*s)
3636 return nfserr_bad_stateid;
3637 return nfs_ok;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003638}
3639
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640/*
3641* Checks for stateid operations
3642*/
Al Virob37ad282006-10-19 23:28:59 -07003643__be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003644nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
Benny Halevydd453df2009-04-03 08:28:41 +03003645 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003646{
J. Bruce Fields69064a22011-09-09 11:54:57 -04003647 struct nfs4_stid *s;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003648 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003650 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003651 struct inode *ino = current_fh->fh_dentry->d_inode;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003652 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Al Virob37ad282006-10-19 23:28:59 -07003653 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654
Linus Torvalds1da177e2005-04-16 15:20:36 -07003655 if (filpp)
3656 *filpp = NULL;
3657
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003658 if (grace_disallows_io(net, ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659 return nfserr_grace;
3660
3661 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003662 return check_special_stateids(net, current_fh, stateid, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003663
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003664 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3665 &s, cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003666 if (status)
3667 return status;
J. Bruce Fields69064a22011-09-09 11:54:57 -04003668 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3669 if (status)
3670 goto out;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003671 switch (s->sc_type) {
3672 case NFS4_DELEG_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003673 dp = delegstateid(s);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003674 status = nfs4_check_delegmode(dp, flags);
3675 if (status)
3676 goto out;
Dan Carpenter43b01782010-10-27 23:19:04 +02003677 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003678 *filpp = dp->dl_file->fi_deleg_file;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003679 if (!*filpp) {
3680 WARN_ON_ONCE(1);
3681 status = nfserr_serverfault;
3682 goto out;
3683 }
Dan Carpenter43b01782010-10-27 23:19:04 +02003684 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003685 break;
3686 case NFS4_OPEN_STID:
3687 case NFS4_LOCK_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003688 stp = openlockstateid(s);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003689 status = nfs4_check_fh(current_fh, stp);
3690 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003691 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003692 if (stp->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003693 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003695 status = nfs4_check_openmode(stp, flags);
3696 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003698 if (filpp) {
3699 if (flags & RD_STATE)
3700 *filpp = find_readable_file(stp->st_file);
3701 else
3702 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003703 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003704 break;
3705 default:
3706 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707 }
3708 status = nfs_ok;
3709out:
3710 return status;
3711}
3712
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003713static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003714nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003715{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003716 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003717 return nfserr_locks_held;
3718 release_lock_stateid(stp);
3719 return nfs_ok;
3720}
3721
3722/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003723 * Test if the stateid is valid
3724 */
3725__be32
3726nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3727 struct nfsd4_test_stateid *test_stateid)
3728{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003729 struct nfsd4_test_stateid_id *stateid;
3730 struct nfs4_client *cl = cstate->session->se_client;
3731
3732 nfs4_lock_state();
3733 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
Chuck Lever7df302f2012-05-29 13:56:37 -04003734 stateid->ts_id_status =
3735 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003736 nfs4_unlock_state();
3737
Bryan Schumaker17456802011-07-13 10:50:48 -04003738 return nfs_ok;
3739}
3740
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003741__be32
3742nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3743 struct nfsd4_free_stateid *free_stateid)
3744{
3745 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003746 struct nfs4_stid *s;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003747 struct nfs4_delegation *dp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003748 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003749 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003750
3751 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003752 s = find_stateid(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003753 if (!s)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003754 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003755 switch (s->sc_type) {
3756 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003757 ret = nfserr_locks_held;
3758 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003759 case NFS4_OPEN_STID:
3760 case NFS4_LOCK_STID:
3761 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3762 if (ret)
3763 goto out;
3764 if (s->sc_type == NFS4_LOCK_STID)
3765 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3766 else
3767 ret = nfserr_locks_held;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003768 break;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003769 case NFS4_REVOKED_DELEG_STID:
3770 dp = delegstateid(s);
3771 destroy_revoked_delegation(dp);
3772 ret = nfs_ok;
3773 break;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003774 default:
3775 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003776 }
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003777out:
3778 nfs4_unlock_state();
3779 return ret;
3780}
3781
NeilBrown4c4cd222005-07-07 17:59:27 -07003782static inline int
3783setlkflg (int type)
3784{
3785 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3786 RD_STATE : WR_STATE;
3787}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003789static __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 -04003790{
3791 struct svc_fh *current_fh = &cstate->current_fh;
3792 struct nfs4_stateowner *sop = stp->st_stateowner;
3793 __be32 status;
3794
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003795 status = nfsd4_check_seqid(cstate, sop, seqid);
3796 if (status)
3797 return status;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003798 if (stp->st_stid.sc_type == NFS4_CLOSED_STID
3799 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003800 /*
3801 * "Closed" stateid's exist *only* to return
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003802 * nfserr_replay_me from the previous step, and
3803 * revoked delegations are kept only for free_stateid.
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003804 */
3805 return nfserr_bad_stateid;
3806 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3807 if (status)
3808 return status;
3809 return nfs4_check_fh(current_fh, stp);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003810}
3811
Linus Torvalds1da177e2005-04-16 15:20:36 -07003812/*
3813 * Checks for sequence id mutating operations.
3814 */
Al Virob37ad282006-10-19 23:28:59 -07003815static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003816nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003817 stateid_t *stateid, char typemask,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003818 struct nfs4_ol_stateid **stpp,
3819 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003820{
J. Bruce Fields0836f582008-01-26 19:08:12 -05003821 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003822 struct nfs4_stid *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003824 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3825 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003826
Linus Torvalds1da177e2005-04-16 15:20:36 -07003827 *stpp = NULL;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003828 status = nfsd4_lookup_stateid(stateid, typemask, &s,
3829 cstate->minorversion, nn);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003830 if (status)
3831 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003832 *stpp = openlockstateid(s);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04003833 if (!nfsd4_has_session(cstate))
3834 cstate->replay_owner = (*stpp)->st_stateowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003835
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003836 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3837}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003838
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003839static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3840 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003841{
3842 __be32 status;
3843 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003845 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003846 NFS4_OPEN_STID, stpp, nn);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003847 if (status)
3848 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003849 oo = openowner((*stpp)->st_stateowner);
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003850 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003851 return nfserr_bad_stateid;
NeilBrown3a4f98b2005-07-07 17:59:26 -07003852 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853}
3854
Al Virob37ad282006-10-19 23:28:59 -07003855__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003856nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003857 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003858{
Al Virob37ad282006-10-19 23:28:59 -07003859 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003860 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003861 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003862 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863
Al Viroa6a9f182013-09-16 10:57:01 -04003864 dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
3865 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003866
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003867 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003868 if (status)
3869 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870
3871 nfs4_lock_state();
3872
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003873 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003874 oc->oc_seqid, &oc->oc_req_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003875 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003876 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003877 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003878 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003879 status = nfserr_bad_stateid;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003880 if (oo->oo_flags & NFS4_OO_CONFIRMED)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003881 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003882 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003883 update_stateid(&stp->st_stid.sc_stateid);
3884 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003885 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003886 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003887
Jeff Layton2a4317c2012-03-21 16:42:43 -04003888 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003889 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003891 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003892 if (!cstate->replay_owner)
3893 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 return status;
3895}
3896
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003897static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003898{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003899 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003900 return;
3901 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
Jeff Layton82c5ff12012-05-11 09:45:13 -04003902 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003903}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003904
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003905static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3906{
3907 switch (to_access) {
3908 case NFS4_SHARE_ACCESS_READ:
3909 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3910 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3911 break;
3912 case NFS4_SHARE_ACCESS_WRITE:
3913 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3914 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3915 break;
3916 case NFS4_SHARE_ACCESS_BOTH:
3917 break;
3918 default:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003919 WARN_ON_ONCE(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920 }
3921}
3922
3923static void
Jeff Laytonce0fc432012-05-11 09:45:14 -04003924reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003925{
3926 int i;
3927 for (i = 0; i < 4; i++) {
3928 if ((i & deny) != i)
Jeff Laytonce0fc432012-05-11 09:45:14 -04003929 clear_deny(i, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003930 }
3931}
3932
Al Virob37ad282006-10-19 23:28:59 -07003933__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003934nfsd4_open_downgrade(struct svc_rqst *rqstp,
3935 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003936 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003937{
Al Virob37ad282006-10-19 23:28:59 -07003938 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003939 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003940 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941
Al Viroa6a9f182013-09-16 10:57:01 -04003942 dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
3943 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003944
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04003945 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02003946 if (od->od_deleg_want)
3947 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
3948 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949
3950 nfs4_lock_state();
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003951 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003952 &od->od_stateid, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003953 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003955 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003956 if (!test_access(od->od_share_access, stp)) {
3957 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958 stp->st_access_bmap, od->od_share_access);
3959 goto out;
3960 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04003961 if (!test_deny(od->od_share_deny, stp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003962 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3963 stp->st_deny_bmap, od->od_share_deny);
3964 goto out;
3965 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003966 nfs4_stateid_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003967
Jeff Laytonce0fc432012-05-11 09:45:14 -04003968 reset_union_bmap_deny(od->od_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003970 update_stateid(&stp->st_stid.sc_stateid);
3971 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 status = nfs_ok;
3973out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003974 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003975 if (!cstate->replay_owner)
3976 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977 return status;
3978}
3979
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003980static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3981{
3982 unhash_open_stateid(s);
3983 s->st_stid.sc_type = NFS4_CLOSED_STID;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003984}
3985
Linus Torvalds1da177e2005-04-16 15:20:36 -07003986/*
3987 * nfs4_unlock_state() called after encode
3988 */
Al Virob37ad282006-10-19 23:28:59 -07003989__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003990nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003991 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992{
Al Virob37ad282006-10-19 23:28:59 -07003993 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003994 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003995 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003996 struct net *net = SVC_NET(rqstp);
3997 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003998
Al Viroa6a9f182013-09-16 10:57:01 -04003999 dprintk("NFSD: nfsd4_close on file %pd\n",
4000 cstate->current_fh.fh_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004001
4002 nfs4_lock_state();
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004003 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
4004 &close->cl_stateid,
4005 NFS4_OPEN_STID|NFS4_CLOSED_STID,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004006 &stp, nn);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004007 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004008 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004010 oo = openowner(stp->st_stateowner);
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004011 update_stateid(&stp->st_stid.sc_stateid);
4012 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04004014 nfsd4_close_open_stateid(stp);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004015
Benny Halevy01a87d92013-10-14 09:01:55 +03004016 if (cstate->minorversion)
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004017 free_generic_stateid(stp);
Benny Halevy01a87d92013-10-14 09:01:55 +03004018 else
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004019 oo->oo_last_closed_stid = stp;
J. Bruce Fields04ef5952006-01-18 17:43:21 -08004020
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004021 if (list_empty(&oo->oo_owner.so_stateids)) {
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04004022 if (cstate->minorversion)
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004023 release_openowner(oo);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04004024 else {
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004025 /*
4026 * In the 4.0 case we need to keep the owners around a
4027 * little while to handle CLOSE replay.
4028 */
fanchaoting53584f62013-04-11 21:24:13 +08004029 move_to_close_lru(oo, SVC_NET(rqstp));
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04004030 }
4031 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004033 if (!cstate->replay_owner)
4034 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004035 return status;
4036}
4037
Al Virob37ad282006-10-19 23:28:59 -07004038__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004039nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4040 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004041{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004042 struct nfs4_delegation *dp;
4043 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004044 struct nfs4_stid *s;
Al Virob37ad282006-10-19 23:28:59 -07004045 __be32 status;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004046 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004048 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004049 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004050
4051 nfs4_lock_state();
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004052 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
4053 cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004054 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004055 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04004056 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04004057 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004058 if (status)
4059 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004060
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004061 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004062out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08004063 nfs4_unlock_state();
4064
Linus Torvalds1da177e2005-04-16 15:20:36 -07004065 return status;
4066}
4067
4068
Linus Torvalds1da177e2005-04-16 15:20:36 -07004069#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070
J. Bruce Fields009673b2011-11-07 17:40:10 -05004071#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072
Benny Halevy87df4de2008-12-15 19:42:03 +02004073static inline u64
4074end_offset(u64 start, u64 len)
4075{
4076 u64 end;
4077
4078 end = start + len;
4079 return end >= start ? end: NFS4_MAX_UINT64;
4080}
4081
4082/* last octet in a range */
4083static inline u64
4084last_byte_offset(u64 start, u64 len)
4085{
4086 u64 end;
4087
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004088 WARN_ON_ONCE(!len);
Benny Halevy87df4de2008-12-15 19:42:03 +02004089 end = start + len;
4090 return end > start ? end - 1: NFS4_MAX_UINT64;
4091}
4092
J. Bruce Fields009673b2011-11-07 17:40:10 -05004093static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094{
4095 return (file_hashval(inode) + cl_id
4096 + opaque_hashval(ownername->data, ownername->len))
J. Bruce Fields009673b2011-11-07 17:40:10 -05004097 & LOCKOWNER_INO_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098}
4099
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100/*
4101 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
4102 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
4103 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
4104 * locking, this prevents us from being completely protocol-compliant. The
4105 * real solution to this problem is to start using unsigned file offsets in
4106 * the VFS, but this is a very deep change!
4107 */
4108static inline void
4109nfs4_transform_lock_offset(struct file_lock *lock)
4110{
4111 if (lock->fl_start < 0)
4112 lock->fl_start = OFFSET_MAX;
4113 if (lock->fl_end < 0)
4114 lock->fl_end = OFFSET_MAX;
4115}
4116
NeilBrownd5b90262006-04-10 22:55:22 -07004117/* Hack!: For now, we're defining this just so we can use a pointer to it
4118 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07004119static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07004120};
Linus Torvalds1da177e2005-04-16 15:20:36 -07004121
4122static inline void
4123nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
4124{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004125 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126
NeilBrownd5b90262006-04-10 22:55:22 -07004127 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004128 lo = (struct nfs4_lockowner *) fl->fl_owner;
4129 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
4130 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004131 if (!deny->ld_owner.data)
4132 /* We just don't care that much */
4133 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004134 deny->ld_owner.len = lo->lo_owner.so_owner.len;
4135 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07004136 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004137nevermind:
4138 deny->ld_owner.len = 0;
4139 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07004140 deny->ld_clientid.cl_boot = 0;
4141 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004142 }
4143 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02004144 deny->ld_length = NFS4_MAX_UINT64;
4145 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004146 deny->ld_length = fl->fl_end - fl->fl_start + 1;
4147 deny->ld_type = NFS4_READ_LT;
4148 if (fl->fl_type != F_RDLCK)
4149 deny->ld_type = NFS4_WRITE_LT;
4150}
4151
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004152static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
4153{
4154 struct nfs4_ol_stateid *lst;
4155
4156 if (!same_owner_str(&lo->lo_owner, owner, clid))
4157 return false;
4158 lst = list_first_entry(&lo->lo_owner.so_stateids,
4159 struct nfs4_ol_stateid, st_perstateowner);
4160 return lst->st_file->fi_inode == inode;
4161}
4162
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004163static struct nfs4_lockowner *
4164find_lockowner_str(struct inode *inode, clientid_t *clid,
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004165 struct xdr_netobj *owner, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004166{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004167 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004168 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004169
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004170 list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004171 if (same_lockowner_ino(lo, inode, clid, owner))
4172 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004173 }
4174 return NULL;
4175}
4176
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004177static 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 -04004178{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004179 struct inode *inode = open_stp->st_file->fi_inode;
4180 unsigned int inohash = lockowner_ino_hashval(inode,
4181 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004182 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
J. Bruce Fields009673b2011-11-07 17:40:10 -05004183
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004184 list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004185 list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004186 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04004187}
4188
Linus Torvalds1da177e2005-04-16 15:20:36 -07004189/*
4190 * Alloc a lock owner structure.
4191 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004192 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004193 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004194 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07004195 */
4196
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004197static struct nfs4_lockowner *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004198alloc_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 -04004199 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004201 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4202 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004203 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004204 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4205 lo->lo_owner.so_is_open_owner = 0;
Neil Brownb59e3c02005-09-13 01:25:38 -07004206 /* It is the openowner seqid that will be incremented in encode in the
4207 * case of new lockowners; so increment the lock seqid manually: */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004208 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4209 hash_lockowner(lo, strhashval, clp, open_stp);
4210 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004211}
4212
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004213static struct nfs4_ol_stateid *
4214alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004215{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004216 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04004217 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004218
J. Bruce Fields996e0932011-10-17 11:14:48 -04004219 stp = nfs4_alloc_stateid(clp);
NeilBrown5ac049a2005-06-23 22:03:03 -07004220 if (stp == NULL)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -04004221 return NULL;
J. Bruce Fields3abdb602013-02-03 12:23:01 -05004222 stp->st_stid.sc_type = NFS4_LOCK_STID;
NeilBrown8beefa22005-06-23 22:03:08 -07004223 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004224 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4225 stp->st_stateowner = &lo->lo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07004226 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004227 stp->st_file = fp;
J. Bruce Fields0997b172011-03-02 18:01:35 -05004228 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07004230 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004231 return stp;
4232}
4233
NeilBrownfd39ca92005-06-23 22:04:03 -07004234static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07004235check_lock_length(u64 offset, u64 length)
4236{
Benny Halevy87df4de2008-12-15 19:42:03 +02004237 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004238 LOFF_OVERFLOW(offset, length)));
4239}
4240
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004241static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05004242{
4243 struct nfs4_file *fp = lock_stp->st_file;
4244 int oflag = nfs4_access_to_omode(access);
4245
Jeff Layton82c5ff12012-05-11 09:45:13 -04004246 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05004247 return;
4248 nfs4_file_get_access(fp, oflag);
Jeff Layton82c5ff12012-05-11 09:45:13 -04004249 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05004250}
4251
J. Bruce Fields2355c592012-04-25 16:56:22 -04004252static __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 -04004253{
4254 struct nfs4_file *fi = ost->st_file;
4255 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4256 struct nfs4_client *cl = oo->oo_owner.so_client;
4257 struct nfs4_lockowner *lo;
4258 unsigned int strhashval;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004259 struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004260
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004261 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
4262 &lock->v.new.owner, nn);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004263 if (lo) {
4264 if (!cstate->minorversion)
4265 return nfserr_bad_seqid;
4266 /* XXX: a lockowner always has exactly one stateid: */
4267 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4268 struct nfs4_ol_stateid, st_perstateowner);
4269 return nfs_ok;
4270 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004271 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004272 &lock->v.new.owner);
4273 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4274 if (lo == NULL)
4275 return nfserr_jukebox;
4276 *lst = alloc_init_lock_stateid(lo, fi, ost);
4277 if (*lst == NULL) {
4278 release_lockowner(lo);
4279 return nfserr_jukebox;
4280 }
4281 *new = true;
4282 return nfs_ok;
4283}
4284
Linus Torvalds1da177e2005-04-16 15:20:36 -07004285/*
4286 * LOCK operation
4287 */
Al Virob37ad282006-10-19 23:28:59 -07004288__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004289nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004290 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004291{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004292 struct nfs4_openowner *open_sop = NULL;
4293 struct nfs4_lockowner *lock_sop = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004294 struct nfs4_ol_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004295 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004296 struct file_lock *file_lock = NULL;
4297 struct file_lock *conflock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004298 __be32 status = 0;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004299 bool new_state = false;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004300 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07004301 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004302 struct net *net = SVC_NET(rqstp);
4303 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004304
4305 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4306 (long long) lock->lk_offset,
4307 (long long) lock->lk_length);
4308
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309 if (check_lock_length(lock->lk_offset, lock->lk_length))
4310 return nfserr_inval;
4311
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004312 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004313 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004314 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4315 return status;
4316 }
4317
Linus Torvalds1da177e2005-04-16 15:20:36 -07004318 nfs4_lock_state();
4319
4320 if (lock->lk_is_new) {
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004321 struct nfs4_ol_stateid *open_stp = NULL;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004322
4323 if (nfsd4_has_session(cstate))
4324 /* See rfc 5661 18.10.3: given clientid is ignored: */
4325 memcpy(&lock->v.new.clientid,
4326 &cstate->session->se_client->cl_clientid,
4327 sizeof(clientid_t));
4328
Linus Torvalds1da177e2005-04-16 15:20:36 -07004329 status = nfserr_stale_clientid;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004330 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332
Linus Torvalds1da177e2005-04-16 15:20:36 -07004333 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004334 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004335 lock->lk_new_open_seqid,
4336 &lock->lk_new_open_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004337 &open_stp, nn);
NeilBrown37515172005-07-07 17:59:16 -07004338 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004340 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004341 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004342 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004343 &lock->v.new.clientid))
4344 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004345 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4346 &lock_stp, &new_state);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004347 } else
Benny Halevydd453df2009-04-03 08:28:41 +03004348 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004349 lock->lk_old_lock_seqid,
4350 &lock->lk_old_lock_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004351 NFS4_LOCK_STID, &lock_stp, nn);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004352 if (status)
4353 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004354 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004355
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004356 lkflg = setlkflg(lock->lk_type);
4357 status = nfs4_check_openmode(lock_stp, lkflg);
4358 if (status)
4359 goto out;
4360
NeilBrown0dd395d2005-07-07 17:59:15 -07004361 status = nfserr_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004362 if (locks_in_grace(net) && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004363 goto out;
4364 status = nfserr_no_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004365 if (!locks_in_grace(net) && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004366 goto out;
4367
Jeff Layton21179d82012-08-21 08:03:32 -04004368 file_lock = locks_alloc_lock();
4369 if (!file_lock) {
4370 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4371 status = nfserr_jukebox;
4372 goto out;
4373 }
4374
4375 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004376 switch (lock->lk_type) {
4377 case NFS4_READ_LT:
4378 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004379 filp = find_readable_file(lock_stp->st_file);
4380 if (filp)
4381 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Jeff Layton21179d82012-08-21 08:03:32 -04004382 file_lock->fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004383 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004384 case NFS4_WRITE_LT:
4385 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004386 filp = find_writeable_file(lock_stp->st_file);
4387 if (filp)
4388 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Jeff Layton21179d82012-08-21 08:03:32 -04004389 file_lock->fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004390 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391 default:
4392 status = nfserr_inval;
4393 goto out;
4394 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004395 if (!filp) {
4396 status = nfserr_openmode;
4397 goto out;
4398 }
Jeff Layton21179d82012-08-21 08:03:32 -04004399 file_lock->fl_owner = (fl_owner_t)lock_sop;
4400 file_lock->fl_pid = current->tgid;
4401 file_lock->fl_file = filp;
4402 file_lock->fl_flags = FL_POSIX;
4403 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4404 file_lock->fl_start = lock->lk_offset;
4405 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4406 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407
Jeff Layton21179d82012-08-21 08:03:32 -04004408 conflock = locks_alloc_lock();
4409 if (!conflock) {
4410 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4411 status = nfserr_jukebox;
4412 goto out;
4413 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004414
Jeff Layton21179d82012-08-21 08:03:32 -04004415 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004416 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004417 case 0: /* success! */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004418 update_stateid(&lock_stp->st_stid.sc_stateid);
4419 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004420 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004421 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004422 break;
4423 case (EAGAIN): /* conflock holds conflicting lock */
4424 status = nfserr_denied;
4425 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
Jeff Layton21179d82012-08-21 08:03:32 -04004426 nfs4_set_lock_denied(conflock, &lock->lk_denied);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004427 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004428 case (EDEADLK):
4429 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004430 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04004431 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004432 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04004433 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004434 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004435 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004436out:
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004437 if (status && new_state)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004438 release_lockowner(lock_sop);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004439 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004440 if (!cstate->replay_owner)
4441 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004442 if (file_lock)
4443 locks_free_lock(file_lock);
4444 if (conflock)
4445 locks_free_lock(conflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004446 return status;
4447}
4448
4449/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004450 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4451 * so we do a temporary open here just to get an open file to pass to
4452 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4453 * inode operation.)
4454 */
Al Viro04da6e92012-04-13 00:00:04 -04004455static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004456{
4457 struct file *file;
Al Viro04da6e92012-04-13 00:00:04 -04004458 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4459 if (!err) {
4460 err = nfserrno(vfs_test_lock(file, lock));
4461 nfsd_close(file);
4462 }
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004463 return err;
4464}
4465
4466/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467 * LOCKT operation
4468 */
Al Virob37ad282006-10-19 23:28:59 -07004469__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004470nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4471 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472{
4473 struct inode *inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004474 struct file_lock *file_lock = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004475 struct nfs4_lockowner *lo;
Al Virob37ad282006-10-19 23:28:59 -07004476 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004477 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004478
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004479 if (locks_in_grace(SVC_NET(rqstp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004480 return nfserr_grace;
4481
4482 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4483 return nfserr_inval;
4484
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485 nfs4_lock_state();
4486
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004487 if (!nfsd4_has_session(cstate)) {
4488 status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
4489 if (status)
4490 goto out;
4491 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492
J. Bruce Fields75c096f2011-08-15 18:39:32 -04004493 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004494 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004495
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004496 inode = cstate->current_fh.fh_dentry->d_inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004497 file_lock = locks_alloc_lock();
4498 if (!file_lock) {
4499 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4500 status = nfserr_jukebox;
4501 goto out;
4502 }
4503 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504 switch (lockt->lt_type) {
4505 case NFS4_READ_LT:
4506 case NFS4_READW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004507 file_lock->fl_type = F_RDLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508 break;
4509 case NFS4_WRITE_LT:
4510 case NFS4_WRITEW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004511 file_lock->fl_type = F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004512 break;
4513 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004514 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004515 status = nfserr_inval;
4516 goto out;
4517 }
4518
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004519 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004520 if (lo)
Jeff Layton21179d82012-08-21 08:03:32 -04004521 file_lock->fl_owner = (fl_owner_t)lo;
4522 file_lock->fl_pid = current->tgid;
4523 file_lock->fl_flags = FL_POSIX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004524
Jeff Layton21179d82012-08-21 08:03:32 -04004525 file_lock->fl_start = lockt->lt_offset;
4526 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527
Jeff Layton21179d82012-08-21 08:03:32 -04004528 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529
Jeff Layton21179d82012-08-21 08:03:32 -04004530 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
Al Viro04da6e92012-04-13 00:00:04 -04004531 if (status)
Marc Eshelfd85b812006-11-28 16:26:41 -05004532 goto out;
Al Viro04da6e92012-04-13 00:00:04 -04004533
Jeff Layton21179d82012-08-21 08:03:32 -04004534 if (file_lock->fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004535 status = nfserr_denied;
Jeff Layton21179d82012-08-21 08:03:32 -04004536 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004537 }
4538out:
4539 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004540 if (file_lock)
4541 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004542 return status;
4543}
4544
Al Virob37ad282006-10-19 23:28:59 -07004545__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004546nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004547 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004548{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004549 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004550 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004551 struct file_lock *file_lock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004552 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004553 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004554 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4555
Linus Torvalds1da177e2005-04-16 15:20:36 -07004556 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4557 (long long) locku->lu_offset,
4558 (long long) locku->lu_length);
4559
4560 if (check_lock_length(locku->lu_offset, locku->lu_length))
4561 return nfserr_inval;
4562
4563 nfs4_lock_state();
4564
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004565 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004566 &locku->lu_stateid, NFS4_LOCK_STID,
4567 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004568 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004569 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004570 filp = find_any_file(stp->st_file);
4571 if (!filp) {
4572 status = nfserr_lock_range;
4573 goto out;
4574 }
Jeff Layton21179d82012-08-21 08:03:32 -04004575 file_lock = locks_alloc_lock();
4576 if (!file_lock) {
4577 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4578 status = nfserr_jukebox;
4579 goto out;
4580 }
4581 locks_init_lock(file_lock);
4582 file_lock->fl_type = F_UNLCK;
J. Bruce Fields0a262ff2013-06-17 17:29:40 -04004583 file_lock->fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
Jeff Layton21179d82012-08-21 08:03:32 -04004584 file_lock->fl_pid = current->tgid;
4585 file_lock->fl_file = filp;
4586 file_lock->fl_flags = FL_POSIX;
4587 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4588 file_lock->fl_start = locku->lu_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004589
Jeff Layton21179d82012-08-21 08:03:32 -04004590 file_lock->fl_end = last_byte_offset(locku->lu_offset,
4591 locku->lu_length);
4592 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593
Jeff Layton21179d82012-08-21 08:03:32 -04004594 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004595 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004596 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004597 goto out_nfserr;
4598 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004599 update_stateid(&stp->st_stid.sc_stateid);
4600 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601
4602out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004603 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields71c3bcd2011-09-27 21:42:29 -04004604 if (!cstate->replay_owner)
4605 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004606 if (file_lock)
4607 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004608 return status;
4609
4610out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004611 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004612 goto out;
4613}
4614
4615/*
4616 * returns
4617 * 1: locks held by lockowner
4618 * 0: no locks held by lockowner
4619 */
4620static int
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004621check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004622{
4623 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004624 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004625 int status = 0;
4626
Jeff Layton1c8c6012013-06-21 08:58:15 -04004627 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004628 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004629 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004630 status = 1;
4631 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004633 }
4634out:
Jeff Layton1c8c6012013-06-21 08:58:15 -04004635 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636 return status;
4637}
4638
Al Virob37ad282006-10-19 23:28:59 -07004639__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004640nfsd4_release_lockowner(struct svc_rqst *rqstp,
4641 struct nfsd4_compound_state *cstate,
4642 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643{
4644 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004645 struct nfs4_stateowner *sop;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004646 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004647 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004648 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004649 struct list_head matches;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004650 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
Al Virob37ad282006-10-19 23:28:59 -07004651 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004652 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004653
4654 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4655 clid->cl_boot, clid->cl_id);
4656
Linus Torvalds1da177e2005-04-16 15:20:36 -07004657 nfs4_lock_state();
4658
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004659 status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
4660 if (status)
4661 goto out;
4662
NeilBrown3e9e3db2005-06-23 22:04:20 -07004663 status = nfserr_locks_held;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004664 INIT_LIST_HEAD(&matches);
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004665
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004666 list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004667 if (sop->so_is_open_owner)
4668 continue;
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004669 if (!same_owner_str(sop, owner, clid))
4670 continue;
4671 list_for_each_entry(stp, &sop->so_stateids,
4672 st_perstateowner) {
4673 lo = lockowner(sop);
4674 if (check_for_locks(stp->st_file, lo))
4675 goto out;
4676 list_add(&lo->lo_list, &matches);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004677 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004678 }
4679 /* Clients probably won't expect us to return with some (but not all)
4680 * of the lockowner state released; so don't release any until all
4681 * have been checked. */
4682 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004683 while (!list_empty(&matches)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004684 lo = list_entry(matches.next, struct nfs4_lockowner,
4685 lo_list);
NeilBrown0fa822e2005-07-07 17:59:14 -07004686 /* unhash_stateowner deletes so_perclient only
4687 * for openowners. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004688 list_del(&lo->lo_list);
4689 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004690 }
4691out:
4692 nfs4_unlock_state();
4693 return status;
4694}
4695
4696static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004697alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004698{
NeilBrowna55370a2005-06-23 22:03:52 -07004699 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004700}
4701
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004702bool
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004703nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
NeilBrownc7b9a452005-06-23 22:04:30 -07004704{
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004705 struct nfs4_client_reclaim *crp;
NeilBrownc7b9a452005-06-23 22:04:30 -07004706
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004707 crp = nfsd4_find_reclaim_client(name, nn);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004708 return (crp && crp->cr_clp);
NeilBrownc7b9a452005-06-23 22:04:30 -07004709}
4710
Linus Torvalds1da177e2005-04-16 15:20:36 -07004711/*
4712 * failure => all reset bets are off, nfserr_no_grace...
4713 */
Jeff Layton772a9bb2012-11-12 15:00:54 -05004714struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004715nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004716{
4717 unsigned int strhashval;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004718 struct nfs4_client_reclaim *crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004719
NeilBrowna55370a2005-06-23 22:03:52 -07004720 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4721 crp = alloc_reclaim();
Jeff Layton772a9bb2012-11-12 15:00:54 -05004722 if (crp) {
4723 strhashval = clientstr_hashval(name);
4724 INIT_LIST_HEAD(&crp->cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004725 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
Jeff Layton772a9bb2012-11-12 15:00:54 -05004726 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004727 crp->cr_clp = NULL;
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004728 nn->reclaim_str_hashtbl_size++;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004729 }
4730 return crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004731}
4732
Jeff Layton2a4317c2012-03-21 16:42:43 -04004733void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004734nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
Jeff Laytonce30e532012-11-12 15:00:53 -05004735{
4736 list_del(&crp->cr_strhash);
4737 kfree(crp);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004738 nn->reclaim_str_hashtbl_size--;
Jeff Laytonce30e532012-11-12 15:00:53 -05004739}
4740
4741void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004742nfs4_release_reclaim(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004743{
4744 struct nfs4_client_reclaim *crp = NULL;
4745 int i;
4746
Linus Torvalds1da177e2005-04-16 15:20:36 -07004747 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004748 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
4749 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004750 struct nfs4_client_reclaim, cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004751 nfs4_remove_reclaim_record(crp, nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004752 }
4753 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004754 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755}
4756
4757/*
4758 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04004759struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004760nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004761{
4762 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004763 struct nfs4_client_reclaim *crp = NULL;
4764
Jeff Layton278c9312012-11-12 15:00:52 -05004765 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004766
Jeff Layton278c9312012-11-12 15:00:52 -05004767 strhashval = clientstr_hashval(recdir);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004768 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
Jeff Layton278c9312012-11-12 15:00:52 -05004769 if (same_name(crp->cr_recdir, recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004770 return crp;
4771 }
4772 }
4773 return NULL;
4774}
4775
4776/*
4777* Called from OPEN. Look for clientid in reclaim list.
4778*/
Al Virob37ad282006-10-19 23:28:59 -07004779__be32
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004780nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004781{
Jeff Laytona52d7262012-03-21 09:52:02 -04004782 struct nfs4_client *clp;
4783
4784 /* find clientid in conf_id_hashtbl */
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004785 clp = find_confirmed_client(clid, sessions, nn);
Jeff Laytona52d7262012-03-21 09:52:02 -04004786 if (clp == NULL)
4787 return nfserr_reclaim_bad;
4788
4789 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004790}
4791
Bryan Schumaker65178db2011-11-01 13:35:21 -04004792#ifdef CONFIG_NFSD_FAULT_INJECTION
4793
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004794u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
4795{
J. Bruce Fields221a6872013-04-01 22:23:49 -04004796 if (mark_client_expired(clp))
4797 return 0;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004798 expire_client(clp);
4799 return 1;
4800}
4801
Bryan Schumaker184c1842012-11-29 11:40:44 -05004802u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
4803{
4804 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004805 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004806 printk(KERN_INFO "NFS Client: %s\n", buf);
4807 return 1;
4808}
4809
4810static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
4811 const char *type)
4812{
4813 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004814 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004815 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
4816}
4817
Bryan Schumakerfc291712012-11-29 11:40:40 -05004818static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
4819{
4820 struct nfs4_openowner *oop;
4821 struct nfs4_lockowner *lop, *lo_next;
4822 struct nfs4_ol_stateid *stp, *st_next;
4823 u64 count = 0;
4824
4825 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
4826 list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
4827 list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
4828 if (func)
4829 func(lop);
4830 if (++count == max)
4831 return count;
4832 }
4833 }
4834 }
4835
4836 return count;
4837}
4838
4839u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
4840{
4841 return nfsd_foreach_client_lock(clp, max, release_lockowner);
4842}
4843
Bryan Schumaker184c1842012-11-29 11:40:44 -05004844u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
4845{
4846 u64 count = nfsd_foreach_client_lock(clp, max, NULL);
4847 nfsd_print_count(clp, count, "locked files");
4848 return count;
4849}
4850
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05004851static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
4852{
4853 struct nfs4_openowner *oop, *next;
4854 u64 count = 0;
4855
4856 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
4857 if (func)
4858 func(oop);
4859 if (++count == max)
4860 break;
4861 }
4862
4863 return count;
4864}
4865
4866u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
4867{
4868 return nfsd_foreach_client_open(clp, max, release_openowner);
4869}
4870
Bryan Schumaker184c1842012-11-29 11:40:44 -05004871u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
4872{
4873 u64 count = nfsd_foreach_client_open(clp, max, NULL);
4874 nfsd_print_count(clp, count, "open files");
4875 return count;
4876}
4877
Bryan Schumaker269de302012-11-29 11:40:42 -05004878static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
4879 struct list_head *victims)
4880{
4881 struct nfs4_delegation *dp, *next;
4882 u64 count = 0;
4883
4884 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
4885 if (victims)
4886 list_move(&dp->dl_recall_lru, victims);
4887 if (++count == max)
4888 break;
4889 }
4890 return count;
4891}
4892
4893u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
4894{
4895 struct nfs4_delegation *dp, *next;
4896 LIST_HEAD(victims);
4897 u64 count;
4898
4899 spin_lock(&recall_lock);
4900 count = nfsd_find_all_delegations(clp, max, &victims);
4901 spin_unlock(&recall_lock);
4902
4903 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004904 revoke_delegation(dp);
Bryan Schumaker269de302012-11-29 11:40:42 -05004905
4906 return count;
4907}
4908
4909u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
4910{
4911 struct nfs4_delegation *dp, *next;
4912 LIST_HEAD(victims);
4913 u64 count;
4914
4915 spin_lock(&recall_lock);
4916 count = nfsd_find_all_delegations(clp, max, &victims);
4917 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4918 nfsd_break_one_deleg(dp);
4919 spin_unlock(&recall_lock);
4920
4921 return count;
4922}
4923
Bryan Schumaker184c1842012-11-29 11:40:44 -05004924u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
4925{
4926 u64 count = 0;
4927
4928 spin_lock(&recall_lock);
4929 count = nfsd_find_all_delegations(clp, max, NULL);
4930 spin_unlock(&recall_lock);
4931
4932 nfsd_print_count(clp, count, "delegations");
4933 return count;
4934}
4935
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004936u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004937{
4938 struct nfs4_client *clp, *next;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004939 u64 count = 0;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004940 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004941
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004942 if (!nfsd_netns_ready(nn))
4943 return 0;
4944
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004945 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004946 count += func(clp, max - count);
4947 if ((max != 0) && (count >= max))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004948 break;
4949 }
Bryan Schumaker65178db2011-11-01 13:35:21 -04004950
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004951 return count;
4952}
4953
Bryan Schumaker6c1e82a2012-11-29 11:40:46 -05004954struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
4955{
4956 struct nfs4_client *clp;
4957 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
4958
4959 if (!nfsd_netns_ready(nn))
4960 return NULL;
4961
4962 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
4963 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
4964 return clp;
4965 }
4966 return NULL;
4967}
4968
Bryan Schumaker65178db2011-11-01 13:35:21 -04004969#endif /* CONFIG_NFSD_FAULT_INJECTION */
4970
NeilBrownac4d8ff22005-06-23 22:03:30 -07004971/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004972
Bryan Schumaker72083392011-11-01 15:24:59 -04004973void
NeilBrownac4d8ff22005-06-23 22:03:30 -07004974nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004975{
NeilBrownac4d8ff22005-06-23 22:03:30 -07004976}
4977
Meelap Shahc2f1a552007-07-17 04:04:39 -07004978/*
4979 * Since the lifetime of a delegation isn't limited to that of an open, a
4980 * client may quite reasonably hang on to a delegation as long as it has
4981 * the inode cached. This becomes an obvious problem the first time a
4982 * client's inode cache approaches the size of the server's total memory.
4983 *
4984 * For now we avoid this problem by imposing a hard limit on the number
4985 * of delegations, which varies according to the server's memory size.
4986 */
4987static void
4988set_max_delegations(void)
4989{
4990 /*
4991 * Allow at most 4 delegations per megabyte of RAM. Quick
4992 * estimates suggest that in the worst case (where every delegation
4993 * is for a different inode), a delegation could take about 1.5K,
4994 * giving a worst case usage of about 6% of memory.
4995 */
4996 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4997}
4998
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004999static int nfs4_state_create_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005000{
5001 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5002 int i;
5003
5004 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5005 CLIENT_HASH_SIZE, GFP_KERNEL);
5006 if (!nn->conf_id_hashtbl)
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005007 goto err;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005008 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
5009 CLIENT_HASH_SIZE, GFP_KERNEL);
5010 if (!nn->unconf_id_hashtbl)
5011 goto err_unconf_id;
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005012 nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
5013 OWNER_HASH_SIZE, GFP_KERNEL);
5014 if (!nn->ownerstr_hashtbl)
5015 goto err_ownerstr;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005016 nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
5017 LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
5018 if (!nn->lockowner_ino_hashtbl)
5019 goto err_lockowner_ino;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005020 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
5021 SESSION_HASH_SIZE, GFP_KERNEL);
5022 if (!nn->sessionid_hashtbl)
5023 goto err_sessionid;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005024
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005025 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005026 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005027 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005028 }
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005029 for (i = 0; i < OWNER_HASH_SIZE; i++)
5030 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005031 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
5032 INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005033 for (i = 0; i < SESSION_HASH_SIZE; i++)
5034 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005035 nn->conf_name_tree = RB_ROOT;
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005036 nn->unconf_name_tree = RB_ROOT;
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03005037 INIT_LIST_HEAD(&nn->client_lru);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03005038 INIT_LIST_HEAD(&nn->close_lru);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04005039 INIT_LIST_HEAD(&nn->del_recall_lru);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03005040 spin_lock_init(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005041
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005042 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005043 get_net(net);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005044
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005045 return 0;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005046
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005047err_sessionid:
5048 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005049err_lockowner_ino:
5050 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005051err_ownerstr:
5052 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005053err_unconf_id:
5054 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03005055err:
5056 return -ENOMEM;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005057}
5058
5059static void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005060nfs4_state_destroy_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005061{
5062 int i;
5063 struct nfs4_client *clp = NULL;
5064 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005065 struct rb_node *node, *tmp;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005066
5067 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5068 while (!list_empty(&nn->conf_id_hashtbl[i])) {
5069 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5070 destroy_client(clp);
5071 }
5072 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03005073
5074 node = rb_first(&nn->unconf_name_tree);
5075 while (node != NULL) {
5076 tmp = node;
5077 node = rb_next(tmp);
5078 clp = rb_entry(tmp, struct nfs4_client, cl_namenode);
5079 rb_erase(tmp, &nn->unconf_name_tree);
5080 destroy_client(clp);
5081 }
5082
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03005083 kfree(nn->sessionid_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03005084 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03005085 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03005086 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005087 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005088 put_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005089}
5090
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03005091int
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005092nfs4_state_start_net(struct net *net)
NeilBrownac4d8ff22005-06-23 22:03:30 -07005093{
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04005094 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005095 int ret;
5096
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005097 ret = nfs4_state_create_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03005098 if (ret)
5099 return ret;
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04005100 nfsd4_client_tracking_init(net);
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04005101 nn->boot_time = get_seconds();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04005102 locks_start_grace(net, &nn->nfsd4_manager);
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04005103 nn->grace_ended = false;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005104 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03005105 nn->nfsd4_grace, net);
5106 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005107 return 0;
5108}
5109
5110/* initialization to perform when the nfsd service is started: */
5111
5112int
5113nfs4_state_start(void)
5114{
5115 int ret;
5116
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005117 ret = set_callback_cred();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005118 if (ret)
5119 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07005120 laundry_wq = create_singlethread_workqueue("nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05005121 if (laundry_wq == NULL) {
5122 ret = -ENOMEM;
5123 goto out_recovery;
5124 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005125 ret = nfsd4_create_callback_queue();
5126 if (ret)
5127 goto out_free_laundry;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005128
Meelap Shahc2f1a552007-07-17 04:04:39 -07005129 set_max_delegations();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005130
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005131 return 0;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005132
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005133out_free_laundry:
5134 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05005135out_recovery:
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005136 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005137}
5138
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03005139void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005140nfs4_state_shutdown_net(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005141{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005142 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005143 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005144 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005145
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005146 cancel_delayed_work_sync(&nn->laundromat_work);
5147 locks_end_grace(&nn->nfsd4_manager);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05005148
J. Bruce Fieldse50a26d2013-10-30 10:33:09 -04005149 nfs4_lock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005150 INIT_LIST_HEAD(&reaplist);
5151 spin_lock(&recall_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04005152 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005153 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5154 list_move(&dp->dl_recall_lru, &reaplist);
5155 }
5156 spin_unlock(&recall_lock);
5157 list_for_each_safe(pos, next, &reaplist) {
5158 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04005159 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005160 }
5161
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005162 nfsd4_client_tracking_exit(net);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005163 nfs4_state_destroy_net(net);
J. Bruce Fieldse50a26d2013-10-30 10:33:09 -04005164 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005165}
5166
5167void
5168nfs4_state_shutdown(void)
5169{
NeilBrown5e8d5c22006-04-10 22:55:37 -07005170 destroy_workqueue(laundry_wq);
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04005171 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005172}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005173
5174static void
5175get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5176{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005177 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
5178 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005179}
5180
5181static void
5182put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5183{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005184 if (cstate->minorversion) {
5185 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
5186 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5187 }
5188}
5189
5190void
5191clear_current_stateid(struct nfsd4_compound_state *cstate)
5192{
5193 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005194}
5195
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005196/*
5197 * functions to set current state id
5198 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005199void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005200nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5201{
5202 put_stateid(cstate, &odp->od_stateid);
5203}
5204
5205void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005206nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5207{
5208 put_stateid(cstate, &open->op_stateid);
5209}
5210
5211void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005212nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5213{
5214 put_stateid(cstate, &close->cl_stateid);
5215}
5216
5217void
5218nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5219{
5220 put_stateid(cstate, &lock->lk_resp_stateid);
5221}
5222
5223/*
5224 * functions to consume current state id
5225 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005226
5227void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005228nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5229{
5230 get_stateid(cstate, &odp->od_stateid);
5231}
5232
5233void
5234nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5235{
5236 get_stateid(cstate, &drp->dr_stateid);
5237}
5238
5239void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005240nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5241{
5242 get_stateid(cstate, &fsp->fr_stateid);
5243}
5244
5245void
5246nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5247{
5248 get_stateid(cstate, &setattr->sa_stateid);
5249}
5250
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005251void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005252nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5253{
5254 get_stateid(cstate, &close->cl_stateid);
5255}
5256
5257void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005258nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005259{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005260 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005261}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01005262
5263void
5264nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5265{
5266 get_stateid(cstate, &read->rd_stateid);
5267}
5268
5269void
5270nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5271{
5272 get_stateid(cstate, &write->wr_stateid);
5273}