blob: f17051838b41aeda88075ac9f81f72f3a1559ce9 [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 -0400100void nfsd4_put_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800101{
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400102 atomic_dec(&ses->se_ref);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800103}
104
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400105static bool is_session_dead(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800106{
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400107 return ses->se_flags & NFS4_SESSION_DEAD;
108}
109
110static __be32 mark_session_dead_locked(struct nfsd4_session *ses)
111{
112 if (atomic_read(&ses->se_ref))
113 return nfserr_jukebox;
114 ses->se_flags |= NFS4_SESSION_DEAD;
115 return nfs_ok;
116}
117
118static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
119{
120 if (is_session_dead(ses))
121 return nfserr_badsession;
122 atomic_inc(&ses->se_ref);
123 return nfs_ok;
Benny Halevy508dc6e2012-02-23 17:40:52 -0800124}
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126void
127nfs4_unlock_state(void)
128{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800129 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130}
131
J. Bruce Fields221a6872013-04-01 22:23:49 -0400132static bool is_client_expired(struct nfs4_client *clp)
133{
134 return clp->cl_time == 0;
135}
136
137static __be32 mark_client_expired_locked(struct nfs4_client *clp)
138{
139 if (atomic_read(&clp->cl_refcount))
140 return nfserr_jukebox;
141 clp->cl_time = 0;
142 return nfs_ok;
143}
144
145static __be32 mark_client_expired(struct nfs4_client *clp)
146{
147 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
148 __be32 ret;
149
150 spin_lock(&nn->client_lock);
151 ret = mark_client_expired_locked(clp);
152 spin_unlock(&nn->client_lock);
153 return ret;
154}
155
156static __be32 get_client_locked(struct nfs4_client *clp)
157{
158 if (is_client_expired(clp))
159 return nfserr_expired;
160 atomic_inc(&clp->cl_refcount);
161 return nfs_ok;
162}
163
164/* must be called under the client_lock */
165static inline void
166renew_client_locked(struct nfs4_client *clp)
167{
168 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
169
170 if (is_client_expired(clp)) {
171 WARN_ON(1);
172 printk("%s: client (clientid %08x/%08x) already expired\n",
173 __func__,
174 clp->cl_clientid.cl_boot,
175 clp->cl_clientid.cl_id);
176 return;
177 }
178
179 dprintk("renewing client (clientid %08x/%08x)\n",
180 clp->cl_clientid.cl_boot,
181 clp->cl_clientid.cl_id);
182 list_move_tail(&clp->cl_lru, &nn->client_lru);
183 clp->cl_time = get_seconds();
184}
185
186static inline void
187renew_client(struct nfs4_client *clp)
188{
189 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
190
191 spin_lock(&nn->client_lock);
192 renew_client_locked(clp);
193 spin_unlock(&nn->client_lock);
194}
195
Fengguang Wuba138432013-04-16 22:14:15 -0400196static void put_client_renew_locked(struct nfs4_client *clp)
J. Bruce Fields221a6872013-04-01 22:23:49 -0400197{
198 if (!atomic_dec_and_test(&clp->cl_refcount))
199 return;
200 if (!is_client_expired(clp))
201 renew_client_locked(clp);
202}
203
204void put_client_renew(struct nfs4_client *clp)
205{
206 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
207
208 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
209 return;
210 if (!is_client_expired(clp))
211 renew_client_locked(clp);
212 spin_unlock(&nn->client_lock);
213}
214
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216static inline u32
217opaque_hashval(const void *ptr, int nbytes)
218{
219 unsigned char *cptr = (unsigned char *) ptr;
220
221 u32 x = 0;
222 while (nbytes--) {
223 x *= 37;
224 x += *cptr++;
225 }
226 return x;
227}
228
J. Bruce Fields32513b42011-10-13 16:00:16 -0400229static void nfsd4_free_file(struct nfs4_file *f)
230{
231 kmem_cache_free(file_slab, f);
232}
233
NeilBrown13cd2182005-06-23 22:03:10 -0700234static inline void
235put_nfs4_file(struct nfs4_file *fi)
236{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800237 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
Jeff Layton89876f82013-04-02 09:01:59 -0400238 hlist_del(&fi->fi_hash);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800239 spin_unlock(&recall_lock);
240 iput(fi->fi_inode);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400241 nfsd4_free_file(fi);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800242 }
NeilBrown13cd2182005-06-23 22:03:10 -0700243}
244
245static inline void
246get_nfs4_file(struct nfs4_file *fi)
247{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800248 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700249}
250
NeilBrownef0f3392006-04-10 22:55:41 -0700251static int num_delegations;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800252unsigned long max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700253
254/*
255 * Open owner state (share locks)
256 */
257
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500258/* hash tables for lock and open owners */
259#define OWNER_HASH_BITS 8
260#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
261#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700262
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500263static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400264{
265 unsigned int ret;
266
267 ret = opaque_hashval(ownername->data, ownername->len);
268 ret += clientid;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500269 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400270}
NeilBrownef0f3392006-04-10 22:55:41 -0700271
NeilBrownef0f3392006-04-10 22:55:41 -0700272/* hash table for nfs4_file */
273#define FILE_HASH_BITS 8
274#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800275
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400276static unsigned int file_hashval(struct inode *ino)
277{
278 /* XXX: why are we hashing on inode pointer, anyway? */
279 return hash_ptr(ino, FILE_HASH_BITS);
280}
281
Jeff Layton89876f82013-04-02 09:01:59 -0400282static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700283
J. Bruce Fields998db522010-08-07 09:21:41 -0400284static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400285{
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500286 WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400287 atomic_inc(&fp->fi_access[oflag]);
288}
289
J. Bruce Fields998db522010-08-07 09:21:41 -0400290static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
291{
292 if (oflag == O_RDWR) {
293 __nfs4_file_get_access(fp, O_RDONLY);
294 __nfs4_file_get_access(fp, O_WRONLY);
295 } else
296 __nfs4_file_get_access(fp, oflag);
297}
298
299static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400300{
301 if (fp->fi_fds[oflag]) {
302 fput(fp->fi_fds[oflag]);
303 fp->fi_fds[oflag] = NULL;
304 }
305}
306
J. Bruce Fields998db522010-08-07 09:21:41 -0400307static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400308{
309 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400310 nfs4_file_put_fd(fp, oflag);
J. Bruce Fields0c7c3e62013-03-28 20:37:14 -0400311 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
J. Bruce Fields3d02fa22011-09-19 15:07:41 -0400312 nfs4_file_put_fd(fp, O_RDWR);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400313 }
314}
315
J. Bruce Fields998db522010-08-07 09:21:41 -0400316static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
317{
318 if (oflag == O_RDWR) {
319 __nfs4_file_put_access(fp, O_RDONLY);
320 __nfs4_file_put_access(fp, O_WRONLY);
321 } else
322 __nfs4_file_put_access(fp, oflag);
323}
324
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500325static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
326kmem_cache *slab)
J. Bruce Fields996e0932011-10-17 11:14:48 -0400327{
328 struct idr *stateids = &cl->cl_stateids;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500329 struct nfs4_stid *stid;
330 int new_id;
331
332 stid = kmem_cache_alloc(slab, GFP_KERNEL);
333 if (!stid)
334 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400335
Jeff Layton398c33a2013-04-29 16:21:20 -0700336 new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
Tejun Heoebd6c702013-03-13 14:59:37 -0700337 if (new_id < 0)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500338 goto out_free;
339 stid->sc_client = cl;
340 stid->sc_type = 0;
341 stid->sc_stateid.si_opaque.so_id = new_id;
342 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
343 /* Will be incremented before return to client: */
344 stid->sc_stateid.si_generation = 0;
345
J. Bruce Fields996e0932011-10-17 11:14:48 -0400346 /*
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500347 * It shouldn't be a problem to reuse an opaque stateid value.
348 * I don't think it is for 4.1. But with 4.0 I worry that, for
349 * example, a stray write retransmission could be accepted by
350 * the server when it should have been rejected. Therefore,
351 * adopt a trick from the sctp code to attempt to maximize the
352 * amount of time until an id is reused, by ensuring they always
353 * "increase" (mod INT_MAX):
J. Bruce Fields996e0932011-10-17 11:14:48 -0400354 */
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500355 return stid;
356out_free:
Wei Yongjun2c44a232013-04-09 14:15:31 +0800357 kmem_cache_free(slab, stid);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500358 return NULL;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400359}
360
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400361static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
362{
363 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
364}
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366static struct nfs4_delegation *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400367alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh, u32 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
369 struct nfs4_delegation *dp;
370 struct nfs4_file *fp = stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 dprintk("NFSD alloc_init_deleg\n");
J. Bruce Fieldsc3e48082010-07-28 10:08:57 -0400373 /*
374 * Major work on the lease subsystem (for example, to support
375 * calbacks on stat) will be required before we can support
376 * write delegations properly.
377 */
378 if (type != NFS4_OPEN_DELEGATE_READ)
379 return NULL;
Meelap Shah47f99402007-07-17 04:04:40 -0700380 if (fp->fi_had_conflict)
381 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700382 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700383 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400384 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700385 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return dp;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500387 dp->dl_stid.sc_type = NFS4_DELEG_STID;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400388 /*
389 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400390 * meaning of seqid 0 isn't meaningful, really, but let's avoid
391 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400392 */
393 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownef0f3392006-04-10 22:55:41 -0700394 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700395 INIT_LIST_HEAD(&dp->dl_perfile);
396 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 INIT_LIST_HEAD(&dp->dl_recall_lru);
NeilBrown13cd2182005-06-23 22:03:10 -0700398 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 dp->dl_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 dp->dl_type = type;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500401 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 dp->dl_time = 0;
403 atomic_set(&dp->dl_count, 1);
J. Bruce Fields57725152012-11-05 15:10:26 -0500404 nfsd4_init_callback(&dp->dl_recall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 return dp;
406}
407
J. Bruce Fields68a33962013-03-21 11:21:50 -0400408static void remove_stid(struct nfs4_stid *s)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500409{
410 struct idr *stateids = &s->sc_client->cl_stateids;
411
412 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500413}
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415void
416nfs4_put_delegation(struct nfs4_delegation *dp)
417{
418 if (atomic_dec_and_test(&dp->dl_count)) {
J. Bruce Fields68a33962013-03-21 11:21:50 -0400419 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700420 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422}
423
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500424static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500426 if (atomic_dec_and_test(&fp->fi_delegees)) {
427 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
428 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400429 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500430 fp->fi_deleg_file = NULL;
431 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432}
433
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400434static void unhash_stid(struct nfs4_stid *s)
435{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500436 s->sc_type = 0;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400437}
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439/* Called under the state lock. */
440static void
441unhash_delegation(struct nfs4_delegation *dp)
442{
NeilBrownea1da632005-06-23 22:04:17 -0700443 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500445 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 list_del_init(&dp->dl_recall_lru);
447 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500448 nfs4_put_deleg_lease(dp->dl_file);
J. Bruce Fields68a33962013-03-21 11:21:50 -0400449 put_nfs4_file(dp->dl_file);
450 dp->dl_file = NULL;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400451}
452
453
454
455static void destroy_revoked_delegation(struct nfs4_delegation *dp)
456{
457 list_del_init(&dp->dl_recall_lru);
J. Bruce Fields68a33962013-03-21 11:21:50 -0400458 remove_stid(&dp->dl_stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 nfs4_put_delegation(dp);
460}
461
J. Bruce Fields3bd64a52013-04-09 17:02:51 -0400462static void destroy_delegation(struct nfs4_delegation *dp)
463{
464 unhash_delegation(dp);
465 remove_stid(&dp->dl_stid);
466 nfs4_put_delegation(dp);
467}
468
469static void revoke_delegation(struct nfs4_delegation *dp)
470{
471 struct nfs4_client *clp = dp->dl_stid.sc_client;
472
473 if (clp->cl_minorversion == 0)
474 destroy_delegation(dp);
475 else {
476 unhash_delegation(dp);
477 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
478 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
479 }
480}
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482/*
483 * SETCLIENTID state
484 */
485
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400486static unsigned int clientid_hashval(u32 id)
487{
488 return id & CLIENT_HASH_MASK;
489}
490
491static unsigned int clientstr_hashval(const char *name)
492{
493 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
494}
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496/*
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400497 * We store the NONE, READ, WRITE, and BOTH bits separately in the
498 * st_{access,deny}_bmap field of the stateid, in order to track not
499 * only what share bits are currently in force, but also what
500 * combinations of share bits previous opens have used. This allows us
501 * to enforce the recommendation of rfc 3530 14.2.19 that the server
502 * return an error if the client attempt to downgrade to a combination
503 * of share bits not explicable by closing some of its previous opens.
504 *
505 * XXX: This enforcement is actually incomplete, since we don't keep
506 * track of access/deny bit combinations; so, e.g., we allow:
507 *
508 * OPEN allow read, deny write
509 * OPEN allow both, deny none
510 * DOWNGRADE allow read, deny none
511 *
512 * which we should reject.
513 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400514static unsigned int
515bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400516 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400517 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400518
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400519 for (i = 1; i < 4; i++) {
520 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400521 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400522 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400523 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400524}
525
Jeff Layton3a328612012-05-11 09:45:12 -0400526static bool
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400527test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400528 unsigned int access, deny;
529
Jeff Layton5ae037e2012-05-11 09:45:11 -0400530 access = bmap_to_share_mode(stp->st_access_bmap);
531 deny = bmap_to_share_mode(stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400532 if ((access & open->op_share_deny) || (deny & open->op_share_access))
Jeff Layton3a328612012-05-11 09:45:12 -0400533 return false;
534 return true;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400535}
536
Jeff Layton82c5ff12012-05-11 09:45:13 -0400537/* set share access for a given stateid */
538static inline void
539set_access(u32 access, struct nfs4_ol_stateid *stp)
540{
541 __set_bit(access, &stp->st_access_bmap);
542}
543
544/* clear share access for a given stateid */
545static inline void
546clear_access(u32 access, struct nfs4_ol_stateid *stp)
547{
548 __clear_bit(access, &stp->st_access_bmap);
549}
550
551/* test whether a given stateid has access */
552static inline bool
553test_access(u32 access, struct nfs4_ol_stateid *stp)
554{
555 return test_bit(access, &stp->st_access_bmap);
556}
557
Jeff Laytonce0fc432012-05-11 09:45:14 -0400558/* set share deny for a given stateid */
559static inline void
560set_deny(u32 access, struct nfs4_ol_stateid *stp)
561{
562 __set_bit(access, &stp->st_deny_bmap);
563}
564
565/* clear share deny for a given stateid */
566static inline void
567clear_deny(u32 access, struct nfs4_ol_stateid *stp)
568{
569 __clear_bit(access, &stp->st_deny_bmap);
570}
571
572/* test whether a given stateid is denying specific access */
573static inline bool
574test_deny(u32 access, struct nfs4_ol_stateid *stp)
575{
576 return test_bit(access, &stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400577}
578
579static int nfs4_access_to_omode(u32 access)
580{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400581 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400582 case NFS4_SHARE_ACCESS_READ:
583 return O_RDONLY;
584 case NFS4_SHARE_ACCESS_WRITE:
585 return O_WRONLY;
586 case NFS4_SHARE_ACCESS_BOTH:
587 return O_RDWR;
588 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500589 WARN_ON_ONCE(1);
590 return O_RDONLY;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400591}
592
Jeff Layton82c5ff12012-05-11 09:45:13 -0400593/* release all access and file references for a given stateid */
594static void
595release_all_access(struct nfs4_ol_stateid *stp)
596{
597 int i;
598
599 for (i = 1; i < 4; i++) {
600 if (test_access(i, stp))
601 nfs4_file_put_access(stp->st_file,
602 nfs4_access_to_omode(i));
603 clear_access(i, stp);
604 }
605}
606
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400607static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500608{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500609 list_del(&stp->st_perfile);
610 list_del(&stp->st_perstateowner);
611}
612
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400613static void close_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500614{
Jeff Layton82c5ff12012-05-11 09:45:13 -0400615 release_all_access(stp);
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400616 put_nfs4_file(stp->st_file);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400617 stp->st_file = NULL;
618}
619
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400620static void free_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400621{
J. Bruce Fields68a33962013-03-21 11:21:50 -0400622 remove_stid(&stp->st_stid);
623 kmem_cache_free(stateid_slab, stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500624}
625
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400626static void release_lock_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500627{
628 struct file *file;
629
630 unhash_generic_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400631 unhash_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500632 file = find_any_file(stp->st_file);
633 if (file)
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400634 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400635 close_generic_stateid(stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500636 free_generic_stateid(stp);
637}
638
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400639static void unhash_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500640{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400641 struct nfs4_ol_stateid *stp;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500642
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400643 list_del(&lo->lo_owner.so_strhash);
644 list_del(&lo->lo_perstateid);
J. Bruce Fields009673b2011-11-07 17:40:10 -0500645 list_del(&lo->lo_owner_ino_hash);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400646 while (!list_empty(&lo->lo_owner.so_stateids)) {
647 stp = list_first_entry(&lo->lo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400648 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500649 release_lock_stateid(stp);
650 }
651}
652
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400653static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500654{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400655 unhash_lockowner(lo);
656 nfs4_free_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500657}
658
659static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400660release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500661{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400662 struct nfs4_lockowner *lo;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500663
664 while (!list_empty(&open_stp->st_lockowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400665 lo = list_entry(open_stp->st_lockowners.next,
666 struct nfs4_lockowner, lo_perstateid);
667 release_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500668 }
669}
670
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400671static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields22839632009-01-11 14:27:17 -0500672{
673 unhash_generic_stateid(stp);
674 release_stateid_lockowners(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400675 close_generic_stateid(stp);
676}
677
678static void release_open_stateid(struct nfs4_ol_stateid *stp)
679{
680 unhash_open_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400681 unhash_stid(&stp->st_stid);
J. Bruce Fields22839632009-01-11 14:27:17 -0500682 free_generic_stateid(stp);
683}
684
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400685static void unhash_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500686{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400687 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500688
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400689 list_del(&oo->oo_owner.so_strhash);
690 list_del(&oo->oo_perclient);
691 while (!list_empty(&oo->oo_owner.so_stateids)) {
692 stp = list_first_entry(&oo->oo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400693 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500694 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500695 }
696}
697
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400698static void release_last_closed_stateid(struct nfs4_openowner *oo)
699{
700 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
701
702 if (s) {
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400703 unhash_stid(&s->st_stid);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400704 free_generic_stateid(s);
705 oo->oo_last_closed_stid = NULL;
706 }
707}
708
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400709static void release_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500710{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400711 unhash_openowner(oo);
712 list_del(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400713 release_last_closed_stateid(oo);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400714 nfs4_free_openowner(oo);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500715}
716
Marc Eshel5282fd72009-04-03 08:27:52 +0300717static inline int
718hash_sessionid(struct nfs4_sessionid *sessionid)
719{
720 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
721
722 return sid->sequence % SESSION_HASH_SIZE;
723}
724
Trond Myklebust8f199b82012-03-20 15:11:17 -0400725#ifdef NFSD_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +0300726static inline void
727dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
728{
729 u32 *ptr = (u32 *)(&sessionid->data[0]);
730 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
731}
Trond Myklebust8f199b82012-03-20 15:11:17 -0400732#else
733static inline void
734dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
735{
736}
737#endif
738
J. Bruce Fields9411b1d2013-04-01 16:37:12 -0400739/*
740 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
741 * won't be used for replay.
742 */
743void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
744{
745 struct nfs4_stateowner *so = cstate->replay_owner;
746
747 if (nfserr == nfserr_replay_me)
748 return;
749
750 if (!seqid_mutating_err(ntohl(nfserr))) {
751 cstate->replay_owner = NULL;
752 return;
753 }
754 if (!so)
755 return;
756 if (so->so_is_open_owner)
757 release_last_closed_stateid(openowner(so));
758 so->so_seqid++;
759 return;
760}
Marc Eshel5282fd72009-04-03 08:27:52 +0300761
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300762static void
763gen_sessionid(struct nfsd4_session *ses)
764{
765 struct nfs4_client *clp = ses->se_client;
766 struct nfsd4_sessionid *sid;
767
768 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
769 sid->clientid = clp->cl_clientid;
770 sid->sequence = current_sessionid++;
771 sid->reserved = 0;
772}
773
774/*
Andy Adamsona6496372009-08-28 08:45:01 -0400775 * The protocol defines ca_maxresponssize_cached to include the size of
776 * the rpc header, but all we need to cache is the data starting after
777 * the end of the initial SEQUENCE operation--the rest we regenerate
778 * each time. Therefore we can advertise a ca_maxresponssize_cached
779 * value that is the number of bytes in our cache plus a few additional
780 * bytes. In order to stay on the safe side, and not promise more than
781 * we can cache, those additional bytes must be the minimum possible: 24
782 * bytes of rpc header (xid through accept state, with AUTH_NULL
783 * verifier), 12 for the compound header (with zero-length tag), and 44
784 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300785 */
Andy Adamsona6496372009-08-28 08:45:01 -0400786#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
787
Andy Adamson557ce262009-08-28 08:45:04 -0400788static void
789free_session_slots(struct nfsd4_session *ses)
790{
791 int i;
792
793 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
794 kfree(ses->se_slots[i]);
795}
796
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400797/*
798 * We don't actually need to cache the rpc and session headers, so we
799 * can allocate a little less for each slot:
800 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400801static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400802{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400803 u32 size;
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400804
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400805 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
806 size = 0;
807 else
808 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
809 return size + sizeof(struct nfsd4_slot);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400810}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300811
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400812/*
813 * XXX: If we run out of reserved DRC memory we could (up to a point)
814 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800815 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400816 */
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400817static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400818{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400819 u32 slotsize = slot_bytes(ca);
820 u32 num = ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400821 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300822
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400823 spin_lock(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800824 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
825 nfsd_drc_max_mem - nfsd_drc_mem_used);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400826 num = min_t(int, num, avail / slotsize);
827 nfsd_drc_mem_used += num * slotsize;
828 spin_unlock(&nfsd_drc_lock);
829
830 return num;
831}
832
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400833static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400834{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400835 int slotsize = slot_bytes(ca);
836
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400837 spin_lock(&nfsd_drc_lock);
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400838 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400839 spin_unlock(&nfsd_drc_lock);
840}
841
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400842static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *attrs)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400843{
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400844 int numslots = attrs->maxreqs;
845 int slotsize = slot_bytes(attrs);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400846 struct nfsd4_session *new;
847 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300848
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400849 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400850 + sizeof(struct nfsd4_session) > PAGE_SIZE);
851 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400852
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400853 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300854 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400855 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400856 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400857 for (i = 0; i < numslots; i++) {
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400858 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400859 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400860 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400861 }
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400862 return new;
863out_free:
864 while (i--)
865 kfree(new->se_slots[i]);
866 kfree(new);
867 return NULL;
868}
869
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400870static void free_conn(struct nfsd4_conn *c)
871{
872 svc_xprt_put(c->cn_xprt);
873 kfree(c);
874}
875
876static void nfsd4_conn_lost(struct svc_xpt_user *u)
877{
878 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
879 struct nfs4_client *clp = c->cn_session->se_client;
880
881 spin_lock(&clp->cl_lock);
882 if (!list_empty(&c->cn_persession)) {
883 list_del(&c->cn_persession);
884 free_conn(c);
885 }
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500886 nfsd4_probe_callback(clp);
J. Bruce Fields2e4b7232013-03-08 09:30:43 -0500887 spin_unlock(&clp->cl_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400888}
889
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400890static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400891{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400892 struct nfsd4_conn *conn;
893
894 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
895 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400896 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400897 svc_xprt_get(rqstp->rq_xprt);
898 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400899 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400900 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
901 return conn;
902}
903
J. Bruce Fields328ead22010-09-29 16:11:06 -0400904static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
905{
906 conn->cn_session = ses;
907 list_add(&conn->cn_persession, &ses->se_conns);
908}
909
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400910static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
911{
912 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400913
914 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400915 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400916 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400917}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400918
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400919static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400920{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400921 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400922 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400923}
924
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400925static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400926{
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400927 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400928
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400929 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400930 ret = nfsd4_register_conn(conn);
931 if (ret)
932 /* oops; xprt is already down: */
933 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fields6a3b1562012-09-12 09:59:17 -0400934 if (conn->cn_flags & NFS4_CDFC4_BACK) {
Weston Andros Adamson24119672012-05-24 15:42:17 -0400935 /* callback channel may be back up */
936 nfsd4_probe_callback(ses->se_client);
937 }
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400938}
939
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400940static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400941{
942 u32 dir = NFS4_CDFC4_FORE;
943
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400944 if (cses->flags & SESSION4_BACK_CHAN)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400945 dir |= NFS4_CDFC4_BACK;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400946 return alloc_conn(rqstp, dir);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400947}
948
949/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400950static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400951{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400952 struct nfs4_client *clp = s->se_client;
953 struct nfsd4_conn *c;
954
955 spin_lock(&clp->cl_lock);
956 while (!list_empty(&s->se_conns)) {
957 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
958 list_del_init(&c->cn_persession);
959 spin_unlock(&clp->cl_lock);
960
961 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
962 free_conn(c);
963
964 spin_lock(&clp->cl_lock);
965 }
966 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400967}
968
J. Bruce Fields1377b692012-09-11 21:42:40 -0400969static void __free_session(struct nfsd4_session *ses)
970{
J. Bruce Fields1377b692012-09-11 21:42:40 -0400971 free_session_slots(ses);
972 kfree(ses);
973}
974
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400975static void free_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800976{
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300977 struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
978
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400979 lockdep_assert_held(&nn->client_lock);
980 nfsd4_del_conns(ses);
J. Bruce Fields55c760c2013-04-08 16:44:14 -0400981 nfsd4_put_drc_mem(&ses->se_fchannel);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400982 __free_session(ses);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400983}
Andy Adamson557ce262009-08-28 08:45:04 -0400984
Fengguang Wu135ae822012-11-10 07:20:25 -0500985static 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 -0400986{
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400987 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300988 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400989
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300990 new->se_client = clp;
991 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300992
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400993 INIT_LIST_HEAD(&new->se_conns);
994
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400995 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300996 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400997 new->se_cb_prog = cses->callback_prog;
J. Bruce Fieldsc6bb3ca2012-11-01 16:31:02 -0400998 new->se_cb_sec = cses->cb_sec;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -0400999 atomic_set(&new->se_ref, 0);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -04001000 idx = hash_sessionid(&new->se_sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001001 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001002 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001003 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001004 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001005 spin_unlock(&clp->cl_lock);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001006 spin_unlock(&nn->client_lock);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001007 memcpy(&new->se_fchannel, &cses->fore_channel,
1008 sizeof(struct nfsd4_channel_attrs));
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001009 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001010 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -04001011 /*
1012 * This is a little silly; with sessions there's no real
1013 * use for the callback address. Use the peer address
1014 * as a reasonable default for now, but consider fixing
1015 * the rpc client not to require an address in the
1016 * future:
1017 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001018 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1019 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001020 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001021}
1022
Benny Halevy9089f1b2010-05-12 00:12:26 +03001023/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +03001024static struct nfsd4_session *
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001025find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
Marc Eshel5282fd72009-04-03 08:27:52 +03001026{
1027 struct nfsd4_session *elem;
1028 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001029 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Marc Eshel5282fd72009-04-03 08:27:52 +03001030
1031 dump_sessionid(__func__, sessionid);
1032 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +03001033 /* Search in the appropriate list */
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001034 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +03001035 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1036 NFS4_MAX_SESSIONID_LEN)) {
1037 return elem;
1038 }
1039 }
1040
1041 dprintk("%s: session not found\n", __func__);
1042 return NULL;
1043}
1044
Benny Halevy9089f1b2010-05-12 00:12:26 +03001045/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +03001046static void
Marc Eshel5282fd72009-04-03 08:27:52 +03001047unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +03001048{
1049 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001050 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +03001051 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001052 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +03001053}
1054
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1056static int
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001057STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001059 if (clid->cl_boot == nn->boot_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001061 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001062 clid->cl_boot, clid->cl_id, nn->boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 return 1;
1064}
1065
1066/*
1067 * XXX Should we use a slab cache ?
1068 * This type of memory management is somewhat inefficient, but we use it
1069 * anyway since SETCLIENTID is not a common operation.
1070 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001071static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072{
1073 struct nfs4_client *clp;
1074
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001075 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1076 if (clp == NULL)
1077 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001078 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001079 if (clp->cl_name.data == NULL) {
1080 kfree(clp);
1081 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001083 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 return clp;
1085}
1086
1087static inline void
1088free_client(struct nfs4_client *clp)
1089{
Stanislav Kinsburskybca0ec62013-01-09 12:38:34 +03001090 struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001091
1092 lockdep_assert_held(&nn->client_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001093 while (!list_empty(&clp->cl_sessions)) {
1094 struct nfsd4_session *ses;
1095 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1096 se_perclnt);
1097 list_del(&ses->se_perclnt);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04001098 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1099 free_session(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001100 }
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001101 free_svc_cred(&clp->cl_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 kfree(clp->cl_name.data);
majianpeng2d32b292013-01-29 13:16:06 +08001103 idr_destroy(&clp->cl_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 kfree(clp);
1105}
1106
Benny Halevy84d38ac2010-05-12 00:13:16 +03001107/* must be called under the client_lock */
1108static inline void
1109unhash_client_locked(struct nfs4_client *clp)
1110{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001111 struct nfsd4_session *ses;
1112
Benny Halevy84d38ac2010-05-12 00:13:16 +03001113 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001114 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001115 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1116 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001117 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001118}
1119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120static void
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001121destroy_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001123 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 struct list_head reaplist;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001126 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 INIT_LIST_HEAD(&reaplist);
1129 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001130 while (!list_empty(&clp->cl_delegations)) {
1131 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -07001132 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 list_move(&dp->dl_recall_lru, &reaplist);
1134 }
1135 spin_unlock(&recall_lock);
1136 while (!list_empty(&reaplist)) {
1137 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04001138 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 }
NeilBrownea1da632005-06-23 22:04:17 -07001140 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001141 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1142 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001144 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001145 if (clp->cl_cb_conn.cb_xprt)
1146 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001147 list_del(&clp->cl_idhash);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001148 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001149 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001150 else
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001151 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001152 spin_lock(&nn->client_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001153 unhash_client_locked(clp);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001154 WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
1155 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001156 spin_unlock(&nn->client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157}
1158
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001159static void expire_client(struct nfs4_client *clp)
1160{
1161 nfsd4_client_record_remove(clp);
1162 destroy_client(clp);
1163}
1164
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001165static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1166{
1167 memcpy(target->cl_verifier.data, source->data,
1168 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169}
1170
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001171static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1172{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1174 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1175}
1176
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001177static int copy_cred(struct svc_cred *target, struct svc_cred *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001178{
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001179 if (source->cr_principal) {
1180 target->cr_principal =
1181 kstrdup(source->cr_principal, GFP_KERNEL);
1182 if (target->cr_principal == NULL)
1183 return -ENOMEM;
1184 } else
1185 target->cr_principal = NULL;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001186 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 target->cr_uid = source->cr_uid;
1188 target->cr_gid = source->cr_gid;
1189 target->cr_group_info = source->cr_group_info;
1190 get_group_info(target->cr_group_info);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001191 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192}
1193
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001194static long long
1195compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1196{
1197 long long res;
1198
1199 res = o1->len - o2->len;
1200 if (res)
1201 return res;
1202 return (long long)memcmp(o1->data, o2->data, o1->len);
1203}
1204
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001205static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001206{
NeilBrowna55370a2005-06-23 22:03:52 -07001207 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208}
1209
1210static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001211same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1212{
1213 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001217same_clid(clientid_t *cl1, clientid_t *cl2)
1218{
1219 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220}
1221
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001222static bool groups_equal(struct group_info *g1, struct group_info *g2)
1223{
1224 int i;
1225
1226 if (g1->ngroups != g2->ngroups)
1227 return false;
1228 for (i=0; i<g1->ngroups; i++)
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001229 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001230 return false;
1231 return true;
1232}
1233
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001234/*
1235 * RFC 3530 language requires clid_inuse be returned when the
1236 * "principal" associated with a requests differs from that previously
1237 * used. We use uid, gid's, and gss principal string as our best
1238 * approximation. We also don't want to allow non-gss use of a client
1239 * established using gss: in theory cr_principal should catch that
1240 * change, but in practice cr_principal can be null even in the gss case
1241 * since gssd doesn't always pass down a principal string.
1242 */
1243static bool is_gss_cred(struct svc_cred *cr)
1244{
1245 /* Is cr_flavor one of the gss "pseudoflavors"?: */
1246 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1247}
1248
1249
Vivek Trivedi5559b502012-07-24 21:18:20 +05301250static bool
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001251same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1252{
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001253 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001254 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1255 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001256 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1257 return false;
1258 if (cr1->cr_principal == cr2->cr_principal)
1259 return true;
1260 if (!cr1->cr_principal || !cr2->cr_principal)
1261 return false;
Vivek Trivedi5559b502012-07-24 21:18:20 +05301262 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263}
1264
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001265static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001266{
1267 static u32 current_clientid = 1;
1268
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001269 clp->cl_clientid.cl_boot = nn->boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 clp->cl_clientid.cl_id = current_clientid++;
1271}
1272
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001273static void gen_confirm(struct nfs4_client *clp)
1274{
Chuck Leverab4684d2012-03-02 17:13:50 -05001275 __be32 verf[2];
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001276 static u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Chuck Leverab4684d2012-03-02 17:13:50 -05001278 verf[0] = (__be32)get_seconds();
1279 verf[1] = (__be32)i++;
1280 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281}
1282
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001283static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
J. Bruce Fields4581d142011-09-06 14:56:09 -04001284{
J. Bruce Fields3abdb602013-02-03 12:23:01 -05001285 struct nfs4_stid *ret;
1286
1287 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1288 if (!ret || !ret->sc_type)
1289 return NULL;
1290 return ret;
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001291}
1292
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001293static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001294{
1295 struct nfs4_stid *s;
1296
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001297 s = find_stateid(cl, t);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001298 if (!s)
1299 return NULL;
1300 if (typemask & s->sc_type)
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001301 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04001302 return NULL;
1303}
1304
Jeff Layton2216d442012-11-12 15:00:57 -05001305static struct nfs4_client *create_client(struct xdr_netobj name,
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001306 struct svc_rqst *rqstp, nfs4_verifier *verf)
1307{
1308 struct nfs4_client *clp;
1309 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001310 int ret;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001311 struct net *net = SVC_NET(rqstp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001312 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001313
1314 clp = alloc_client(name);
1315 if (clp == NULL)
1316 return NULL;
1317
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001318 INIT_LIST_HEAD(&clp->cl_sessions);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001319 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1320 if (ret) {
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001321 spin_lock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001322 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001323 spin_unlock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001324 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001325 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001326 idr_init(&clp->cl_stateids);
Benny Halevy46583e22010-05-12 00:13:29 +03001327 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001328 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001329 INIT_LIST_HEAD(&clp->cl_idhash);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001330 INIT_LIST_HEAD(&clp->cl_openowners);
1331 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001332 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001333 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04001334 INIT_LIST_HEAD(&clp->cl_revoked);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001335 spin_lock_init(&clp->cl_lock);
J. Bruce Fields57725152012-11-05 15:10:26 -05001336 nfsd4_init_callback(&clp->cl_cb_null);
Benny Halevy07cd4902010-05-12 00:13:41 +03001337 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001338 clear_bit(0, &clp->cl_cb_slot_busy);
1339 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1340 copy_verf(clp, verf);
1341 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001342 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001343 clp->cl_cb_session = NULL;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001344 clp->net = net;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001345 return clp;
1346}
1347
NeilBrownfd39ca92005-06-23 22:04:03 -07001348static void
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001349add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1350{
1351 struct rb_node **new = &(root->rb_node), *parent = NULL;
1352 struct nfs4_client *clp;
1353
1354 while (*new) {
1355 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1356 parent = *new;
1357
1358 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1359 new = &((*new)->rb_left);
1360 else
1361 new = &((*new)->rb_right);
1362 }
1363
1364 rb_link_node(&new_clp->cl_namenode, parent, new);
1365 rb_insert_color(&new_clp->cl_namenode, root);
1366}
1367
1368static struct nfs4_client *
1369find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1370{
1371 long long cmp;
1372 struct rb_node *node = root->rb_node;
1373 struct nfs4_client *clp;
1374
1375 while (node) {
1376 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1377 cmp = compare_blob(&clp->cl_name, name);
1378 if (cmp > 0)
1379 node = node->rb_left;
1380 else if (cmp < 0)
1381 node = node->rb_right;
1382 else
1383 return clp;
1384 }
1385 return NULL;
1386}
1387
1388static void
1389add_to_unconfirmed(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
1391 unsigned int idhashval;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001392 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001394 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001395 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001397 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001398 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399}
1400
NeilBrownfd39ca92005-06-23 22:04:03 -07001401static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402move_to_confirmed(struct nfs4_client *clp)
1403{
1404 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001405 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406
1407 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001408 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001409 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001410 add_clp_to_name_tree(clp, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001411 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 renew_client(clp);
1413}
1414
1415static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001416find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 struct nfs4_client *clp;
1419 unsigned int idhashval = clientid_hashval(clid->cl_id);
1420
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001421 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001422 if (same_clid(&clp->cl_clientid, clid)) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001423 if ((bool)clp->cl_minorversion != sessions)
1424 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001425 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 }
1429 return NULL;
1430}
1431
1432static struct nfs4_client *
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001433find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1434{
1435 struct list_head *tbl = nn->conf_id_hashtbl;
1436
1437 return find_client_in_id_table(tbl, clid, sessions);
1438}
1439
1440static struct nfs4_client *
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001441find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442{
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001443 struct list_head *tbl = nn->unconf_id_hashtbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444
J. Bruce Fieldsbfa85e832013-03-14 18:24:52 -04001445 return find_client_in_id_table(tbl, clid, sessions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446}
1447
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001448static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001449{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001450 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001451}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001452
NeilBrown28ce6052005-06-23 22:03:56 -07001453static struct nfs4_client *
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001454find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001455{
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001456 return find_clp_in_name_tree(name, &nn->conf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001457}
1458
1459static struct nfs4_client *
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001460find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001461{
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001462 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001463}
1464
NeilBrownfd39ca92005-06-23 22:04:03 -07001465static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001466gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001468 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001469 struct sockaddr *sa = svc_addr(rqstp);
1470 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001471 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Jeff Layton7077ecb2009-08-14 12:57:58 -04001473 /* Currently, we only support tcp and tcp6 for the callback channel */
1474 if (se->se_callback_netid_len == 3 &&
1475 !memcmp(se->se_callback_netid_val, "tcp", 3))
1476 expected_family = AF_INET;
1477 else if (se->se_callback_netid_len == 4 &&
1478 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1479 expected_family = AF_INET6;
1480 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 goto out_err;
1482
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001483 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001484 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001485 (struct sockaddr *)&conn->cb_addr,
1486 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001487
J. Bruce Fields07263f12010-05-31 19:09:40 -04001488 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001490
J. Bruce Fields07263f12010-05-31 19:09:40 -04001491 if (conn->cb_addr.ss_family == AF_INET6)
1492 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001493
J. Bruce Fields07263f12010-05-31 19:09:40 -04001494 conn->cb_prog = se->se_callback_prog;
1495 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08001496 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return;
1498out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001499 conn->cb_addr.ss_family = AF_UNSPEC;
1500 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001501 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 "will not receive delegations\n",
1503 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 return;
1506}
1507
Andy Adamson074fe892009-04-03 08:28:15 +03001508/*
Andy Adamson557ce262009-08-28 08:45:04 -04001509 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001510 */
1511void
1512nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1513{
Andy Adamson557ce262009-08-28 08:45:04 -04001514 struct nfsd4_slot *slot = resp->cstate.slot;
1515 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001516
Andy Adamson557ce262009-08-28 08:45:04 -04001517 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001518
Andy Adamson557ce262009-08-28 08:45:04 -04001519 slot->sl_opcnt = resp->opcnt;
1520 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001521
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05001522 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001523 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001524 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001525 return;
1526 }
Andy Adamson557ce262009-08-28 08:45:04 -04001527 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1528 base = (char *)resp->cstate.datap -
1529 (char *)resp->xbuf->head[0].iov_base;
1530 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1531 slot->sl_datalen))
1532 WARN("%s: sessions DRC could not cache compound\n", __func__);
1533 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001534}
1535
1536/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001537 * Encode the replay sequence operation from the slot values.
1538 * If cachethis is FALSE encode the uncached rep error on the next
1539 * operation which sets resp->p and increments resp->opcnt for
1540 * nfs4svc_encode_compoundres.
1541 *
Andy Adamson074fe892009-04-03 08:28:15 +03001542 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001543static __be32
1544nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1545 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001546{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001547 struct nfsd4_op *op;
1548 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001549
Andy Adamsonabfabf82009-07-23 19:02:18 -04001550 /* Encode the replayed sequence operation */
1551 op = &args->ops[resp->opcnt - 1];
1552 nfsd4_encode_operation(resp, op);
1553
1554 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05001555 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001556 op = &args->ops[resp->opcnt++];
1557 op->status = nfserr_retry_uncached_rep;
1558 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001559 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001560 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001561}
1562
1563/*
Andy Adamson557ce262009-08-28 08:45:04 -04001564 * The sequence operation is not cached because we can use the slot and
1565 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001566 */
1567__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001568nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1569 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001570{
Andy Adamson557ce262009-08-28 08:45:04 -04001571 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001572 __be32 status;
1573
Andy Adamson557ce262009-08-28 08:45:04 -04001574 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001575
Andy Adamsonabfabf82009-07-23 19:02:18 -04001576 /* Either returns 0 or nfserr_retry_uncached */
1577 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1578 if (status == nfserr_retry_uncached_rep)
1579 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001580
Andy Adamson557ce262009-08-28 08:45:04 -04001581 /* The sequence operation has been encoded, cstate->datap set. */
1582 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001583
Andy Adamson557ce262009-08-28 08:45:04 -04001584 resp->opcnt = slot->sl_opcnt;
1585 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1586 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001587
1588 return status;
1589}
1590
Andy Adamson0733d212009-04-03 08:28:01 +03001591/*
1592 * Set the exchange_id flags returned by the server.
1593 */
1594static void
1595nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1596{
1597 /* pNFS is not supported */
1598 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1599
1600 /* Referrals are supported, Migration is not. */
1601 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1602
1603 /* set the wire flags to return to client. */
1604 clid->flags = new->cl_exchange_flags;
1605}
1606
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001607static bool client_has_state(struct nfs4_client *clp)
1608{
1609 /*
1610 * Note clp->cl_openowners check isn't quite right: there's no
1611 * need to count owners without stateid's.
1612 *
1613 * Also note we should probably be using this in 4.0 case too.
1614 */
J. Bruce Fields6eccece2012-05-29 16:37:44 -04001615 return !list_empty(&clp->cl_openowners)
1616 || !list_empty(&clp->cl_delegations)
1617 || !list_empty(&clp->cl_sessions);
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001618}
1619
Al Virob37ad282006-10-19 23:28:59 -07001620__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001621nfsd4_exchange_id(struct svc_rqst *rqstp,
1622 struct nfsd4_compound_state *cstate,
1623 struct nfsd4_exchange_id *exid)
1624{
Andy Adamson0733d212009-04-03 08:28:01 +03001625 struct nfs4_client *unconf, *conf, *new;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001626 __be32 status;
Jeff Layton363168b2009-08-14 12:57:56 -04001627 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001628 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001629 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001630 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001631 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamson0733d212009-04-03 08:28:01 +03001632
Jeff Layton363168b2009-08-14 12:57:56 -04001633 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001634 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001635 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001636 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001637 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001638
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04001639 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03001640 return nfserr_inval;
1641
1642 /* Currently only support SP4_NONE */
1643 switch (exid->spa_how) {
1644 case SP4_NONE:
1645 break;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05001646 default: /* checked by xdr code */
1647 WARN_ON_ONCE(1);
Andy Adamson0733d212009-04-03 08:28:01 +03001648 case SP4_SSV:
J. Bruce Fieldsdd303332013-04-12 18:10:56 -04001649 return nfserr_encr_alg_unsupp;
Andy Adamson0733d212009-04-03 08:28:01 +03001650 case SP4_MACH_CRED:
1651 return nfserr_serverfault; /* no excuse :-/ */
1652 }
1653
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001654 /* Cases below refer to rfc 5661 section 18.35.4: */
Andy Adamson0733d212009-04-03 08:28:01 +03001655 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001656 conf = find_confirmed_client_by_name(&exid->clname, nn);
Andy Adamson0733d212009-04-03 08:28:01 +03001657 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001658 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1659 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1660
J. Bruce Fields136e6582012-05-12 20:37:23 -04001661 if (update) {
1662 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001663 status = nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001664 goto out;
1665 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001666 if (!creds_match) { /* case 9 */
Andy Adamson0733d212009-04-03 08:28:01 +03001667 status = nfserr_perm;
1668 goto out;
1669 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001670 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03001671 status = nfserr_not_same;
1672 goto out;
1673 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001674 /* case 6 */
1675 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1676 new = conf;
1677 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03001678 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001679 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001680 if (client_has_state(conf)) {
1681 status = nfserr_clid_inuse;
1682 goto out;
1683 }
Andy Adamson0733d212009-04-03 08:28:01 +03001684 expire_client(conf);
1685 goto out_new;
1686 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001687 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04001688 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001689 new = conf;
1690 goto out_copy;
1691 }
1692 /* case 5, client reboot */
J. Bruce Fields136e6582012-05-12 20:37:23 -04001693 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001694 }
1695
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001696 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001697 status = nfserr_noent;
1698 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001699 }
1700
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001701 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001702 if (unconf) /* case 4, possible retry or client restart */
Andy Adamson0733d212009-04-03 08:28:01 +03001703 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03001704
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001705 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03001706out_new:
Jeff Layton2216d442012-11-12 15:00:57 -05001707 new = create_client(exid->clname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001708 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001709 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001710 goto out;
1711 }
J. Bruce Fieldsc116a0a2012-09-11 14:53:09 -04001712 new->cl_minorversion = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001713
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001714 gen_clid(new, nn);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001715 add_to_unconfirmed(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001716out_copy:
1717 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1718 exid->clientid.cl_id = new->cl_clientid.cl_id;
1719
J. Bruce Fields778df3f2012-05-25 21:40:23 -04001720 exid->seqid = new->cl_cs_slot.sl_seqid + 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001721 nfsd4_set_ex_flags(new, exid);
1722
1723 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001724 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001725 status = nfs_ok;
1726
1727out:
1728 nfs4_unlock_state();
Andy Adamson0733d212009-04-03 08:28:01 +03001729 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001730}
1731
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001732static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04001733check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001734{
Andy Adamson88e588d2009-07-23 19:02:15 -04001735 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1736 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001737
1738 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001739 if (slot_inuse) {
1740 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001741 return nfserr_jukebox;
1742 else
1743 return nfserr_seq_misordered;
1744 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05001745 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04001746 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001747 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04001748 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001749 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001750 return nfserr_seq_misordered;
1751}
1752
Andy Adamson49557cc2009-07-23 19:02:16 -04001753/*
1754 * Cache the create session result into the create session single DRC
1755 * slot cache by saving the xdr structure. sl_seqid has been set.
1756 * Do this for solo or embedded create session operations.
1757 */
1758static void
1759nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001760 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04001761{
1762 slot->sl_status = nfserr;
1763 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1764}
1765
1766static __be32
1767nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1768 struct nfsd4_clid_slot *slot)
1769{
1770 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1771 return slot->sl_status;
1772}
1773
Mi Jinlong1b74c252011-07-14 14:50:17 +08001774#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1775 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1776 1 + /* MIN tag is length with zero, only length */ \
1777 3 + /* version, opcount, opcode */ \
1778 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1779 /* seqid, slotID, slotID, cache */ \
1780 4 ) * sizeof(__be32))
1781
1782#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1783 2 + /* verifier: AUTH_NULL, length 0 */\
1784 1 + /* status */ \
1785 1 + /* MIN tag is length with zero, only length */ \
1786 3 + /* opcount, opcode, opstatus*/ \
1787 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1788 /* seqid, slotID, slotID, slotID, status */ \
1789 5 ) * sizeof(__be32))
1790
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001791static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
Mi Jinlong1b74c252011-07-14 14:50:17 +08001792{
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001793 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
1794
J. Bruce Fields373cd402013-04-08 15:42:12 -04001795 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
1796 return nfserr_toosmall;
1797 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
1798 return nfserr_toosmall;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001799 ca->headerpadsz = 0;
1800 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
1801 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
1802 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
1803 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
1804 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
1805 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
1806 /*
1807 * Note decreasing slot size below client's request may make it
1808 * difficult for client to function correctly, whereas
1809 * decreasing the number of slots will (just?) affect
1810 * performance. When short on memory we therefore prefer to
1811 * decrease number of slots instead of their size. Clients that
1812 * request larger slots than they need will get poor results:
1813 */
1814 ca->maxreqs = nfsd4_get_drc_mem(ca);
1815 if (!ca->maxreqs)
1816 return nfserr_jukebox;
1817
J. Bruce Fields373cd402013-04-08 15:42:12 -04001818 return nfs_ok;
Mi Jinlong1b74c252011-07-14 14:50:17 +08001819}
1820
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001821static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
1822{
1823 ca->headerpadsz = 0;
1824
1825 /*
1826 * These RPC_MAX_HEADER macros are overkill, especially since we
1827 * don't even do gss on the backchannel yet. But this is still
1828 * less than 1k. Tighten up this estimate in the unlikely event
1829 * it turns out to be a problem for some client:
1830 */
1831 if (ca->maxreq_sz < NFS4_enc_cb_recall_sz + RPC_MAX_HEADER_WITH_AUTH)
1832 return nfserr_toosmall;
1833 if (ca->maxresp_sz < NFS4_dec_cb_recall_sz + RPC_MAX_REPHEADER_WITH_AUTH)
1834 return nfserr_toosmall;
1835 ca->maxresp_cached = 0;
1836 if (ca->maxops < 2)
1837 return nfserr_toosmall;
1838
1839 return nfs_ok;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001840}
1841
1842__be32
1843nfsd4_create_session(struct svc_rqst *rqstp,
1844 struct nfsd4_compound_state *cstate,
1845 struct nfsd4_create_session *cr_ses)
1846{
Jeff Layton363168b2009-08-14 12:57:56 -04001847 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001848 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001849 struct nfsd4_session *new;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001850 struct nfsd4_conn *conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001851 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001852 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001853 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001854
Mi Jinlonga62573d2011-03-23 17:57:07 +08001855 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1856 return nfserr_inval;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001857 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
J. Bruce Fields373cd402013-04-08 15:42:12 -04001858 if (status)
1859 return status;
J. Bruce Fields06b332a2013-04-09 11:34:36 -04001860 status = check_backchannel_attrs(&cr_ses->back_channel);
1861 if (status)
1862 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001863 status = nfserr_jukebox;
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001864 new = alloc_session(&cr_ses->fore_channel);
1865 if (!new)
1866 goto out_release_drc_mem;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001867 conn = alloc_conn_from_crses(rqstp, cr_ses);
1868 if (!conn)
1869 goto out_free_session;
Mi Jinlonga62573d2011-03-23 17:57:07 +08001870
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001871 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001872 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001873 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04001874 WARN_ON_ONCE(conf && unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001875
1876 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001877 cs_slot = &conf->cl_cs_slot;
1878 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001879 if (status == nfserr_replay_cache) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001880 status = nfsd4_replay_create_session(cr_ses, cs_slot);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001881 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001882 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001883 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001884 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001885 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001886 } else if (unconf) {
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001887 struct nfs4_client *old;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001888 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001889 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001890 status = nfserr_clid_inuse;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001891 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001892 }
Andy Adamson49557cc2009-07-23 19:02:16 -04001893 cs_slot = &unconf->cl_cs_slot;
1894 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001895 if (status) {
1896 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001897 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001898 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001899 }
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001900 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001901 if (old) {
1902 status = mark_client_expired(old);
1903 if (status)
1904 goto out_free_conn;
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001905 expire_client(old);
J. Bruce Fields221a6872013-04-01 22:23:49 -04001906 }
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001907 move_to_confirmed(unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001908 conf = unconf;
1909 } else {
1910 status = nfserr_stale_clientid;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001911 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001912 }
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001913 status = nfs_ok;
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001914 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001915 * We do not support RDMA or persistent sessions
1916 */
1917 cr_ses->flags &= ~SESSION4_PERSIST;
1918 cr_ses->flags &= ~SESSION4_RDMA;
1919
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001920 init_session(rqstp, new, conf, cr_ses);
1921 nfsd4_init_conn(rqstp, conn, new);
1922
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001923 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001924 NFS4_MAX_SESSIONID_LEN);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001925 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001926 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001927
Andy Adamson49557cc2009-07-23 19:02:16 -04001928 /* cache solo and embedded create sessions under the state lock */
1929 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001930 nfs4_unlock_state();
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001931 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001932out_free_conn:
Yanchuan Nian266533c2012-12-24 18:11:45 +08001933 nfs4_unlock_state();
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001934 free_conn(conn);
1935out_free_session:
1936 __free_session(new);
J. Bruce Fields55c760c2013-04-08 16:44:14 -04001937out_release_drc_mem:
1938 nfsd4_put_drc_mem(&cr_ses->fore_channel);
J. Bruce Fields1ca50792013-03-14 18:12:03 -04001939 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001940}
1941
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001942static __be32 nfsd4_map_bcts_dir(u32 *dir)
1943{
1944 switch (*dir) {
1945 case NFS4_CDFC4_FORE:
1946 case NFS4_CDFC4_BACK:
1947 return nfs_ok;
1948 case NFS4_CDFC4_FORE_OR_BOTH:
1949 case NFS4_CDFC4_BACK_OR_BOTH:
1950 *dir = NFS4_CDFC4_BOTH;
1951 return nfs_ok;
1952 };
1953 return nfserr_inval;
1954}
1955
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001956__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
1957{
1958 struct nfsd4_session *session = cstate->session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001959 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001960
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001961 spin_lock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001962 session->se_cb_prog = bc->bc_cb_program;
1963 session->se_cb_sec = bc->bc_cb_sec;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001964 spin_unlock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001965
1966 nfsd4_probe_callback(session->se_client);
1967
1968 return nfs_ok;
1969}
1970
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001971__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1972 struct nfsd4_compound_state *cstate,
1973 struct nfsd4_bind_conn_to_session *bcts)
1974{
1975 __be32 status;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001976 struct nfsd4_conn *conn;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001977 struct nfsd4_session *session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001978 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001979
1980 if (!nfsd4_last_compound_op(rqstp))
1981 return nfserr_not_only_op;
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001982 nfs4_lock_state();
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001983 spin_lock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001984 session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001985 spin_unlock(&nn->client_lock);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001986 status = nfserr_badsession;
1987 if (!session)
1988 goto out;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001989 status = nfsd4_map_bcts_dir(&bcts->dir);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001990 if (status)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001991 goto out;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001992 conn = alloc_conn(rqstp, bcts->dir);
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001993 status = nfserr_jukebox;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001994 if (!conn)
J. Bruce Fields4f6e6c12013-03-18 17:31:30 -04001995 goto out;
1996 nfsd4_init_conn(rqstp, conn, session);
1997 status = nfs_ok;
1998out:
1999 nfs4_unlock_state();
2000 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002001}
2002
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002003static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2004{
2005 if (!session)
2006 return 0;
2007 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2008}
2009
Andy Adamson069b6ad2009-04-03 08:27:58 +03002010__be32
2011nfsd4_destroy_session(struct svc_rqst *r,
2012 struct nfsd4_compound_state *cstate,
2013 struct nfsd4_destroy_session *sessionid)
2014{
Benny Halevye10e0cf2009-04-03 08:28:38 +03002015 struct nfsd4_session *ses;
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002016 __be32 status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002017 struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002018
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002019 nfs4_lock_state();
2020 status = nfserr_not_only_op;
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04002021 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04002022 if (!nfsd4_last_compound_op(r))
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002023 goto out;
J. Bruce Fields57716352010-04-21 12:27:19 -04002024 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03002025 dump_sessionid(__func__, &sessionid->sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002026 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002027 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002028 status = nfserr_badsession;
2029 if (!ses)
2030 goto out_client_lock;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002031 status = mark_session_dead_locked(ses);
2032 if (status)
2033 goto out_client_lock;
Benny Halevye10e0cf2009-04-03 08:28:38 +03002034 unhash_session(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002035 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002036
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05002037 nfsd4_probe_callback_sync(ses->se_client);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04002038
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002039 spin_lock(&nn->client_lock);
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002040 free_session(ses);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002041 status = nfs_ok;
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002042out_client_lock:
2043 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03002044out:
J. Bruce Fieldsabcdff02013-03-14 19:55:33 -04002045 nfs4_unlock_state();
Benny Halevye10e0cf2009-04-03 08:28:38 +03002046 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002047}
2048
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002049static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002050{
2051 struct nfsd4_conn *c;
2052
2053 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002054 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04002055 return c;
2056 }
2057 }
2058 return NULL;
2059}
2060
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002061static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04002062{
2063 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002064 struct nfsd4_conn *c;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002065 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002066
2067 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002068 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields328ead22010-09-29 16:11:06 -04002069 if (c) {
2070 spin_unlock(&clp->cl_lock);
2071 free_conn(new);
2072 return;
2073 }
2074 __nfsd4_hash_conn(new, ses);
2075 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04002076 ret = nfsd4_register_conn(new);
2077 if (ret)
2078 /* oops; xprt is already down: */
2079 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields328ead22010-09-29 16:11:06 -04002080 return;
2081}
2082
Mi Jinlong868b89c2011-04-27 09:09:58 +08002083static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2084{
2085 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2086
2087 return args->opcnt > session->se_fchannel.maxops;
2088}
2089
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002090static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2091 struct nfsd4_session *session)
2092{
2093 struct xdr_buf *xb = &rqstp->rq_arg;
2094
2095 return xb->len > session->se_fchannel.maxreq_sz;
2096}
2097
Andy Adamson069b6ad2009-04-03 08:27:58 +03002098__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03002099nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002100 struct nfsd4_compound_state *cstate,
2101 struct nfsd4_sequence *seq)
2102{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002103 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002104 struct nfsd4_session *session;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002105 struct nfs4_client *clp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002106 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002107 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002108 __be32 status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002109 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002110
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03002111 if (resp->opcnt != 1)
2112 return nfserr_sequence_pos;
2113
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002114 /*
2115 * Will be either used or freed by nfsd4_sequence_check_conn
2116 * below.
2117 */
2118 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2119 if (!conn)
2120 return nfserr_jukebox;
2121
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002122 spin_lock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002123 status = nfserr_badsession;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002124 session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
Benny Halevyb85d4c02009-04-03 08:28:08 +03002125 if (!session)
J. Bruce Fields221a6872013-04-01 22:23:49 -04002126 goto out_no_session;
2127 clp = session->se_client;
2128 status = get_client_locked(clp);
2129 if (status)
2130 goto out_no_session;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002131 status = nfsd4_get_session_locked(session);
2132 if (status)
2133 goto out_put_client;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002134
Mi Jinlong868b89c2011-04-27 09:09:58 +08002135 status = nfserr_too_many_ops;
2136 if (nfsd4_session_too_many_ops(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002137 goto out_put_session;
Mi Jinlong868b89c2011-04-27 09:09:58 +08002138
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002139 status = nfserr_req_too_big;
2140 if (nfsd4_request_too_big(rqstp, session))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002141 goto out_put_session;
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002142
Benny Halevyb85d4c02009-04-03 08:28:08 +03002143 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002144 if (seq->slotid >= session->se_fchannel.maxreqs)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002145 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002146
Andy Adamson557ce262009-08-28 08:45:04 -04002147 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002148 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2149
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002150 /* We do not negotiate the number of slots yet, so set the
2151 * maxslots to the session maxreqs which is used to encode
2152 * sr_highest_slotid and the sr_target_slot id to maxslots */
2153 seq->maxslots = session->se_fchannel.maxreqs;
2154
J. Bruce Fields73e79482012-02-13 16:39:00 -05002155 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2156 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002157 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002158 status = nfserr_seq_misordered;
2159 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002160 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002161 cstate->slot = slot;
2162 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002163 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002164 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002165 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002166 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002167 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002168 }
2169 if (status)
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002170 goto out_put_session;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002171
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002172 nfsd4_sequence_check_conn(conn, session);
2173 conn = NULL;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002174
Benny Halevyb85d4c02009-04-03 08:28:08 +03002175 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03002176 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002177 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05002178 if (seq->cachethis)
2179 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002180 else
2181 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002182
2183 cstate->slot = slot;
2184 cstate->session = session;
2185
Benny Halevyb85d4c02009-04-03 08:28:08 +03002186out:
J. Bruce Fields221a6872013-04-01 22:23:49 -04002187 switch (clp->cl_cb_state) {
2188 case NFSD4_CB_DOWN:
2189 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
2190 break;
2191 case NFSD4_CB_FAULT:
2192 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
2193 break;
2194 default:
2195 seq->status_flags = 0;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002196 }
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04002197 if (!list_empty(&clp->cl_revoked))
2198 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
J. Bruce Fields221a6872013-04-01 22:23:49 -04002199out_no_session:
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002200 kfree(conn);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002201 spin_unlock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002202 return status;
J. Bruce Fields66b2b9b2013-03-19 12:05:39 -04002203out_put_session:
2204 nfsd4_put_session(session);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002205out_put_client:
2206 put_client_renew_locked(clp);
2207 goto out_no_session;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002208}
2209
Mi Jinlong345c2842011-10-20 17:51:39 +08002210__be32
2211nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2212{
2213 struct nfs4_client *conf, *unconf, *clp;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002214 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002215 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Mi Jinlong345c2842011-10-20 17:51:39 +08002216
2217 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002218 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002219 conf = find_confirmed_client(&dc->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002220 WARN_ON_ONCE(conf && unconf);
Mi Jinlong345c2842011-10-20 17:51:39 +08002221
2222 if (conf) {
2223 clp = conf;
2224
J. Bruce Fieldsc0293b02013-03-14 18:20:01 -04002225 if (client_has_state(conf)) {
Mi Jinlong345c2842011-10-20 17:51:39 +08002226 status = nfserr_clientid_busy;
2227 goto out;
2228 }
2229 } else if (unconf)
2230 clp = unconf;
2231 else {
2232 status = nfserr_stale_clientid;
2233 goto out;
2234 }
2235
2236 expire_client(clp);
2237out:
2238 nfs4_unlock_state();
Mi Jinlong345c2842011-10-20 17:51:39 +08002239 return status;
2240}
2241
Andy Adamson069b6ad2009-04-03 08:27:58 +03002242__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002243nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2244{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002245 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002246
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002247 if (rc->rca_one_fs) {
2248 if (!cstate->current_fh.fh_dentry)
2249 return nfserr_nofilehandle;
2250 /*
2251 * We don't take advantage of the rca_one_fs case.
2252 * That's OK, it's optional, we can safely ignore it.
2253 */
2254 return nfs_ok;
2255 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002256
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002257 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002258 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04002259 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2260 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002261 goto out;
2262
2263 status = nfserr_stale_clientid;
2264 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002265 /*
2266 * The following error isn't really legal.
2267 * But we only get here if the client just explicitly
2268 * destroyed the client. Surely it no longer cares what
2269 * error it gets back on an operation for the dead
2270 * client.
2271 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002272 goto out;
2273
2274 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04002275 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002276out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002277 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002278 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002279}
2280
2281__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002282nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2283 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002285 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 nfs4_verifier clverifier = setclid->se_verf;
NeilBrown28ce6052005-06-23 22:03:56 -07002287 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07002288 __be32 status;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002289 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2290
J. Bruce Fields63db4632012-05-18 21:54:19 -04002291 /* Cases below refer to rfc 3530 section 14.2.33: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002293 conf = find_confirmed_client_by_name(&clname, nn);
NeilBrown28ce6052005-06-23 22:03:56 -07002294 if (conf) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04002295 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002297 if (clp_used_exchangeid(conf))
2298 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04002299 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04002300 char addr_str[INET6_ADDRSTRLEN];
2301 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2302 sizeof(addr_str));
2303 dprintk("NFSD: setclientid: string in use by client "
2304 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 goto out;
2306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002308 unconf = find_unconfirmed_client_by_name(&clname, nn);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002309 if (unconf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 status = nfserr_jukebox;
Jeff Layton2216d442012-11-12 15:00:57 -05002312 new = create_client(clname, rqstp, &clverifier);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002313 if (new == NULL)
2314 goto out;
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002315 if (conf && same_verf(&conf->cl_verifier, &clverifier))
J. Bruce Fields63db4632012-05-18 21:54:19 -04002316 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 copy_clid(new, conf);
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002318 else /* case 4 (new client) or cases 2, 3 (client reboot): */
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002319 gen_clid(new, nn);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002320 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002321 gen_callback(new, setclid, rqstp);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002322 add_to_unconfirmed(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2324 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2325 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2326 status = nfs_ok;
2327out:
2328 nfs4_unlock_state();
2329 return status;
2330}
2331
2332
Al Virob37ad282006-10-19 23:28:59 -07002333__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002334nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2335 struct nfsd4_compound_state *cstate,
2336 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337{
NeilBrown21ab45a2005-06-23 22:04:14 -07002338 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2340 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002341 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03002342 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002344 if (STALE_CLIENTID(clid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 return nfserr_stale_clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002347
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002348 conf = find_confirmed_client(clid, false, nn);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002349 unconf = find_unconfirmed_client(clid, false, nn);
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002350 /*
J. Bruce Fields8695b902012-05-19 10:05:58 -04002351 * We try hard to give out unique clientid's, so if we get an
2352 * attempt to confirm the same clientid with a different cred,
2353 * there's a bug somewhere. Let's charitably assume it's our
2354 * bug.
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002355 */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002356 status = nfserr_serverfault;
2357 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2358 goto out;
2359 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2360 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04002361 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002362 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2363 if (conf && !unconf) /* case 2: probable retransmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 status = nfs_ok;
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002365 else /* case 4: client hasn't noticed we rebooted yet? */
2366 status = nfserr_stale_clientid;
2367 goto out;
2368 }
2369 status = nfs_ok;
2370 if (conf) { /* case 1: callback update */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002371 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2372 nfsd4_probe_callback(conf);
2373 expire_client(unconf);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002374 } else { /* case 3: normal case; new or rebooted client */
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002375 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002376 if (conf) {
2377 status = mark_client_expired(conf);
2378 if (status)
2379 goto out;
J. Bruce Fields8695b902012-05-19 10:05:58 -04002380 expire_client(conf);
J. Bruce Fields221a6872013-04-01 22:23:49 -04002381 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04002382 move_to_confirmed(unconf);
J. Bruce Fieldsf3d03b92012-05-23 11:38:38 -04002383 nfsd4_probe_callback(unconf);
NeilBrown08e89872005-06-23 22:04:11 -07002384 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 nfs4_unlock_state();
2387 return status;
2388}
2389
J. Bruce Fields32513b42011-10-13 16:00:16 -04002390static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391{
J. Bruce Fields32513b42011-10-13 16:00:16 -04002392 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2393}
2394
2395/* OPEN Share state helper functions */
2396static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2397{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 unsigned int hashval = file_hashval(ino);
2399
J. Bruce Fields32513b42011-10-13 16:00:16 -04002400 atomic_set(&fp->fi_ref, 1);
J. Bruce Fields32513b42011-10-13 16:00:16 -04002401 INIT_LIST_HEAD(&fp->fi_stateids);
2402 INIT_LIST_HEAD(&fp->fi_delegations);
2403 fp->fi_inode = igrab(ino);
2404 fp->fi_had_conflict = false;
2405 fp->fi_lease = NULL;
2406 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2407 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2408 spin_lock(&recall_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002409 hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
J. Bruce Fields32513b42011-10-13 16:00:16 -04002410 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411}
2412
2413static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002414nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002415{
NeilBrowne60d4392005-06-23 22:03:01 -07002416 if (*slab == NULL)
2417 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002418 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002419 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002420}
2421
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002422void
NeilBrowne60d4392005-06-23 22:03:01 -07002423nfsd4_free_slabs(void)
2424{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002425 nfsd4_free_slab(&openowner_slab);
2426 nfsd4_free_slab(&lockowner_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002427 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002428 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002429 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002430}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431
Bryan Schumaker72083392011-11-01 15:24:59 -04002432int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433nfsd4_init_slabs(void)
2434{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002435 openowner_slab = kmem_cache_create("nfsd4_openowners",
2436 sizeof(struct nfs4_openowner), 0, 0, NULL);
2437 if (openowner_slab == NULL)
2438 goto out_nomem;
2439 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
Yanchuan Nian3c407942012-10-24 14:44:19 +08002440 sizeof(struct nfs4_lockowner), 0, 0, NULL);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002441 if (lockowner_slab == NULL)
NeilBrowne60d4392005-06-23 22:03:01 -07002442 goto out_nomem;
2443 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002444 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002445 if (file_slab == NULL)
2446 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002447 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002448 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002449 if (stateid_slab == NULL)
2450 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002451 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002452 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002453 if (deleg_slab == NULL)
2454 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002456out_nomem:
2457 nfsd4_free_slabs();
2458 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2459 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460}
2461
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002462void nfs4_free_openowner(struct nfs4_openowner *oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002464 kfree(oo->oo_owner.so_owner.data);
2465 kmem_cache_free(openowner_slab, oo);
2466}
2467
2468void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2469{
2470 kfree(lo->lo_owner.so_owner.data);
2471 kmem_cache_free(lockowner_slab, lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472}
2473
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002474static void init_nfs4_replay(struct nfs4_replay *rp)
2475{
2476 rp->rp_status = nfserr_serverfault;
2477 rp->rp_buflen = 0;
2478 rp->rp_buf = rp->rp_ibuf;
2479}
2480
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002481static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482{
2483 struct nfs4_stateowner *sop;
2484
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002485 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002486 if (!sop)
2487 return NULL;
2488
2489 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2490 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002491 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002492 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002494 sop->so_owner.len = owner->len;
2495
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002496 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002497 sop->so_client = clp;
2498 init_nfs4_replay(&sop->so_replay);
2499 return sop;
2500}
2501
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002502static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002503{
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002504 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2505
2506 list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002507 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508}
2509
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002510static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002512 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002514 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2515 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002517 oo->oo_owner.so_is_open_owner = 1;
2518 oo->oo_owner.so_seqid = open->op_seqid;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04002519 oo->oo_flags = NFS4_OO_NEW;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002520 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04002521 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002522 INIT_LIST_HEAD(&oo->oo_close_lru);
2523 hash_openowner(oo, clp, strhashval);
2524 return oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525}
2526
J. Bruce Fields996e0932011-10-17 11:14:48 -04002527static 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 -04002528 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529
J. Bruce Fields3abdb602013-02-03 12:23:01 -05002530 stp->st_stid.sc_type = NFS4_OPEN_STID;
NeilBrownea1da632005-06-23 22:04:17 -07002531 INIT_LIST_HEAD(&stp->st_lockowners);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002532 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002533 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002534 stp->st_stateowner = &oo->oo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07002535 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 stp->st_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537 stp->st_access_bmap = 0;
2538 stp->st_deny_bmap = 0;
Jeff Layton82c5ff12012-05-11 09:45:13 -04002539 set_access(open->op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002540 set_deny(open->op_share_deny, stp);
NeilBrown4c4cd222005-07-07 17:59:27 -07002541 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542}
2543
2544static void
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002545move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546{
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002547 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2548
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002549 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002551 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002552 oo->oo_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553}
2554
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002556same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2557 clientid_t *clid)
2558{
2559 return (sop->so_owner.len == owner->len) &&
2560 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2561 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562}
2563
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002564static struct nfs4_openowner *
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002565find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2566 bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567{
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002568 struct nfs4_stateowner *so;
2569 struct nfs4_openowner *oo;
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002570 struct nfs4_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002572 list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002573 if (!so->so_is_open_owner)
2574 continue;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002575 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2576 oo = openowner(so);
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002577 clp = oo->oo_owner.so_client;
2578 if ((bool)clp->cl_minorversion != sessions)
2579 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002580 renew_client(oo->oo_owner.so_client);
2581 return oo;
2582 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 }
2584 return NULL;
2585}
2586
2587/* search file_hashtbl[] for file */
2588static struct nfs4_file *
2589find_file(struct inode *ino)
2590{
2591 unsigned int hashval = file_hashval(ino);
2592 struct nfs4_file *fp;
2593
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002594 spin_lock(&recall_lock);
Jeff Layton89876f82013-04-02 09:01:59 -04002595 hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002596 if (fp->fi_inode == ino) {
2597 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002598 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002600 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002602 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 return NULL;
2604}
2605
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002606/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 * Called to check deny when READ with all zero stateid or
2608 * WRITE with all zero or all one stateid
2609 */
Al Virob37ad282006-10-19 23:28:59 -07002610static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2612{
2613 struct inode *ino = current_fh->fh_dentry->d_inode;
2614 struct nfs4_file *fp;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002615 struct nfs4_ol_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002616 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002619 if (!fp)
2620 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002621 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002623 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
Jeff Laytonce0fc432012-05-11 09:45:14 -04002624 if (test_deny(deny_type, stp) ||
2625 test_deny(NFS4_SHARE_DENY_BOTH, stp))
NeilBrown13cd2182005-06-23 22:03:10 -07002626 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 }
NeilBrown13cd2182005-06-23 22:03:10 -07002628 ret = nfs_ok;
2629out:
2630 put_nfs4_file(fp);
2631 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632}
2633
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002634static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635{
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002636 struct nfs4_client *clp = dp->dl_stid.sc_client;
2637 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2638
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 /* We're assuming the state code never drops its reference
2640 * without first removing the lease. Since we're in this lease
2641 * callback (and since the lease code is serialized by the kernel
2642 * lock) we know the server hasn't removed the lease yet, we know
2643 * it's safe to take a reference: */
2644 atomic_inc(&dp->dl_count);
2645
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04002646 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647
Jeff Layton1c8c6012013-06-21 08:58:15 -04002648 /* Only place dl_time is set; protected by i_lock: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 dp->dl_time = get_seconds();
2650
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002651 nfsd4_cb_recall(dp);
2652}
2653
Jeff Layton1c8c6012013-06-21 08:58:15 -04002654/* Called from break_lease() with i_lock held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002655static void nfsd_break_deleg_cb(struct file_lock *fl)
2656{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002657 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2658 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002659
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04002660 if (!fp) {
2661 WARN(1, "(%p)->fl_owner NULL\n", fl);
2662 return;
2663 }
2664 if (fp->fi_had_conflict) {
2665 WARN(1, "duplicate break on %p\n", fp);
2666 return;
2667 }
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002668 /*
2669 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002670 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002671 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002672 */
2673 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002675 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002676 fp->fi_had_conflict = true;
2677 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2678 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002679 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680}
2681
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682static
2683int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2684{
2685 if (arg & F_UNLCK)
2686 return lease_modify(onlist, arg);
2687 else
2688 return -EAGAIN;
2689}
2690
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002691static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002692 .lm_break = nfsd_break_deleg_cb,
2693 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694};
2695
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04002696static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2697{
2698 if (nfsd4_has_session(cstate))
2699 return nfs_ok;
2700 if (seqid == so->so_seqid - 1)
2701 return nfserr_replay_me;
2702 if (seqid == so->so_seqid)
2703 return nfs_ok;
2704 return nfserr_bad_seqid;
2705}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706
Al Virob37ad282006-10-19 23:28:59 -07002707__be32
Andy Adamson66689582009-04-03 08:28:45 +03002708nfsd4_process_open1(struct nfsd4_compound_state *cstate,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03002709 struct nfsd4_open *open, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 clientid_t *clientid = &open->op_clientid;
2712 struct nfs4_client *clp = NULL;
2713 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002714 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002715 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002717 if (STALE_CLIENTID(&open->op_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04002719 /*
2720 * In case we need it later, after we've already created the
2721 * file and don't want to risk a further failure:
2722 */
2723 open->op_file = nfsd4_alloc_file();
2724 if (open->op_file == NULL)
2725 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002727 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002728 oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002729 open->op_openowner = oo;
2730 if (!oo) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002731 clp = find_confirmed_client(clientid, cstate->minorversion,
2732 nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002734 return nfserr_expired;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002735 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002737 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002738 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002739 clp = oo->oo_owner.so_client;
2740 release_openowner(oo);
2741 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002742 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002743 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002744 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2745 if (status)
2746 return status;
2747 clp = oo->oo_owner.so_client;
2748 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002749new_owner:
2750 oo = alloc_init_open_stateowner(strhashval, clp, open);
2751 if (oo == NULL)
2752 return nfserr_jukebox;
2753 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002754alloc_stateid:
2755 open->op_stp = nfs4_alloc_stateid(clp);
2756 if (!open->op_stp)
2757 return nfserr_jukebox;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002758 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759}
2760
Al Virob37ad282006-10-19 23:28:59 -07002761static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002762nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2763{
2764 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2765 return nfserr_openmode;
2766 else
2767 return nfs_ok;
2768}
2769
Daniel Mackc47d8322011-05-16 16:38:14 +02002770static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002771{
J. Bruce Fields24a01112010-05-18 20:01:35 -04002772 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2773}
2774
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002775static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002776{
2777 struct nfs4_stid *ret;
2778
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002779 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002780 if (!ret)
2781 return NULL;
2782 return delegstateid(ret);
2783}
2784
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002785static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2786{
2787 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2788 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2789}
2790
Al Virob37ad282006-10-19 23:28:59 -07002791static __be32
J. Bruce Fields41d22662013-03-21 15:49:47 -04002792nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07002793 struct nfs4_delegation **dp)
2794{
2795 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002796 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002797
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002798 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
NeilBrown567d9822005-06-23 22:02:53 -07002799 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002800 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002801 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002802 status = nfs4_check_delegmode(*dp, flags);
2803 if (status)
2804 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002805out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002806 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07002807 return nfs_ok;
2808 if (status)
2809 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002810 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002811 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002812}
2813
Al Virob37ad282006-10-19 23:28:59 -07002814static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002815nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002817 struct nfs4_ol_stateid *local;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002818 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819
NeilBrown8beefa22005-06-23 22:03:08 -07002820 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 /* ignore lock owners */
2822 if (local->st_stateowner->so_is_open_owner == 0)
2823 continue;
2824 /* remember if we have seen this open owner */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002825 if (local->st_stateowner == &oo->oo_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 *stpp = local;
2827 /* check for conflicting share reservations */
2828 if (!test_share(local, open))
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002829 return nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 }
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002831 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832}
2833
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002834static inline int nfs4_access_to_access(u32 nfs4_access)
2835{
2836 int flags = 0;
2837
2838 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2839 flags |= NFSD_MAY_READ;
2840 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2841 flags |= NFSD_MAY_WRITE;
2842 return flags;
2843}
2844
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002845static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2846 struct svc_fh *cur_fh, struct nfsd4_open *open)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002847{
2848 __be32 status;
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002849 int oflag = nfs4_access_to_omode(open->op_share_access);
2850 int access = nfs4_access_to_access(open->op_share_access);
2851
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002852 if (!fp->fi_fds[oflag]) {
2853 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2854 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002855 if (status)
2856 return status;
2857 }
2858 nfs4_file_get_access(fp, oflag);
2859
2860 return nfs_ok;
2861}
2862
Al Virob37ad282006-10-19 23:28:59 -07002863static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2865 struct nfsd4_open *open)
2866{
2867 struct iattr iattr = {
2868 .ia_valid = ATTR_SIZE,
2869 .ia_size = 0,
2870 };
2871 if (!open->op_truncate)
2872 return 0;
2873 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002874 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2876}
2877
Al Virob37ad282006-10-19 23:28:59 -07002878static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002879nfs4_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 -07002880{
J. Bruce Fieldsb6d2f1c2011-10-10 17:44:19 -04002881 u32 op_share_access = open->op_share_access;
J. Bruce Fields7d947842010-08-20 18:09:31 -04002882 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002883 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884
Jeff Layton82c5ff12012-05-11 09:45:13 -04002885 new_access = !test_access(op_share_access, stp);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002886 if (new_access) {
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002887 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002888 if (status)
2889 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002890 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 status = nfsd4_truncate(rqstp, cur_fh, open);
2892 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002893 if (new_access) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04002894 int oflag = nfs4_access_to_omode(op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002895 nfs4_file_put_access(fp, oflag);
2896 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897 return status;
2898 }
2899 /* remember the open */
Jeff Layton82c5ff12012-05-11 09:45:13 -04002900 set_access(op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002901 set_deny(open->op_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902
2903 return nfs_ok;
2904}
2905
2906
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907static void
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05002908nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909{
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002910 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911}
2912
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002913/* Should we give out recallable state?: */
2914static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2915{
2916 if (clp->cl_cb_state == NFSD4_CB_UP)
2917 return true;
2918 /*
2919 * In the sessions case, since we don't have to establish a
2920 * separate connection for callbacks, we assume it's OK
2921 * until we hear otherwise:
2922 */
2923 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2924}
2925
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002926static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2927{
2928 struct file_lock *fl;
2929
2930 fl = locks_alloc_lock();
2931 if (!fl)
2932 return NULL;
2933 locks_init_lock(fl);
2934 fl->fl_lmops = &nfsd_lease_mng_ops;
2935 fl->fl_flags = FL_LEASE;
2936 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2937 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002938 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002939 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002940 return fl;
2941}
2942
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002943static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2944{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002945 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002946 struct file_lock *fl;
2947 int status;
2948
2949 fl = nfs4_alloc_init_lease(dp, flag);
2950 if (!fl)
2951 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002952 fl->fl_file = find_readable_file(fp);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002953 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002954 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002955 if (status) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002956 list_del_init(&dp->dl_perclnt);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002957 locks_free_lock(fl);
2958 return -ENOMEM;
2959 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002960 fp->fi_lease = fl;
Al Virocb0942b2012-08-27 14:48:26 -04002961 fp->fi_deleg_file = get_file(fl->fl_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002962 atomic_set(&fp->fi_delegees, 1);
2963 list_add(&dp->dl_perfile, &fp->fi_delegations);
2964 return 0;
2965}
2966
2967static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2968{
2969 struct nfs4_file *fp = dp->dl_file;
2970
2971 if (!fp->fi_lease)
2972 return nfs4_setlease(dp, flag);
2973 spin_lock(&recall_lock);
2974 if (fp->fi_had_conflict) {
2975 spin_unlock(&recall_lock);
2976 return -EAGAIN;
2977 }
2978 atomic_inc(&fp->fi_delegees);
2979 list_add(&dp->dl_perfile, &fp->fi_delegations);
2980 spin_unlock(&recall_lock);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002981 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002982 return 0;
2983}
2984
Benny Halevy4aa89132012-02-21 14:16:44 -08002985static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
2986{
2987 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2988 if (status == -EAGAIN)
2989 open->op_why_no_deleg = WND4_CONTENTION;
2990 else {
2991 open->op_why_no_deleg = WND4_RESOURCE;
2992 switch (open->op_deleg_want) {
2993 case NFS4_SHARE_WANT_READ_DELEG:
2994 case NFS4_SHARE_WANT_WRITE_DELEG:
2995 case NFS4_SHARE_WANT_ANY_DELEG:
2996 break;
2997 case NFS4_SHARE_WANT_CANCEL:
2998 open->op_why_no_deleg = WND4_CANCELLED;
2999 break;
3000 case NFS4_SHARE_WANT_NO_DELEG:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003001 WARN_ON_ONCE(1);
Benny Halevy4aa89132012-02-21 14:16:44 -08003002 }
3003 }
3004}
3005
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006/*
3007 * Attempt to hand out a delegation.
3008 */
3009static void
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003010nfs4_open_delegation(struct net *net, struct svc_fh *fh,
3011 struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012{
3013 struct nfs4_delegation *dp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003014 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
J. Bruce Fields14a24e92010-12-10 19:02:49 -05003015 int cb_up;
Benny Halevyd24433c2012-02-16 20:57:17 +02003016 int status = 0, flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003018 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07003020 open->op_recall = 0;
3021 switch (open->op_claim_type) {
3022 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05003023 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07003024 open->op_recall = 1;
3025 flag = open->op_delegate_type;
3026 if (flag == NFS4_OPEN_DELEGATE_NONE)
3027 goto out;
3028 break;
3029 case NFS4_OPEN_CLAIM_NULL:
3030 /* Let's not give out any delegations till everyone's
3031 * had the chance to reclaim theirs.... */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003032 if (locks_in_grace(net))
NeilBrown7b190fe2005-06-23 22:03:23 -07003033 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003034 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown7b190fe2005-06-23 22:03:23 -07003035 goto out;
3036 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
3037 flag = NFS4_OPEN_DELEGATE_WRITE;
3038 else
3039 flag = NFS4_OPEN_DELEGATE_READ;
3040 break;
3041 default:
3042 goto out;
3043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003045 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003046 if (dp == NULL)
3047 goto out_no_deleg;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003048 status = nfs4_set_delegation(dp, flag);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05003049 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003050 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003052 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003054 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003055 STATEID_VAL(&dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056out:
3057 open->op_delegate_type = flag;
Benny Halevyd24433c2012-02-16 20:57:17 +02003058 if (flag == NFS4_OPEN_DELEGATE_NONE) {
3059 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
3060 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
3061 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
3062
Benny Halevy4aa89132012-02-21 14:16:44 -08003063 /* 4.1 client asking for a delegation? */
3064 if (open->op_deleg_want)
3065 nfsd4_open_deleg_none_ext(open, status);
Benny Halevyd24433c2012-02-16 20:57:17 +02003066 }
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003067 return;
3068out_free:
J. Bruce Fields24ffb932012-12-12 15:24:12 -05003069 unhash_stid(&dp->dl_stid);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003070 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05003071out_no_deleg:
3072 flag = NFS4_OPEN_DELEGATE_NONE;
3073 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074}
3075
Benny Halevye27f49c2012-02-21 14:16:54 -08003076static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
3077 struct nfs4_delegation *dp)
3078{
3079 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
3080 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3081 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3082 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
3083 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3084 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3085 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3086 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3087 }
3088 /* Otherwise the client must be confused wanting a delegation
3089 * it already has, therefore we don't return
3090 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
3091 */
3092}
3093
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094/*
3095 * called with nfs4_lock_state() held.
3096 */
Al Virob37ad282006-10-19 23:28:59 -07003097__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3099{
Andy Adamson66689582009-04-03 08:28:45 +03003100 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003101 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 struct nfs4_file *fp = NULL;
3103 struct inode *ino = current_fh->fh_dentry->d_inode;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003104 struct nfs4_ol_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07003105 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003106 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 /*
3109 * Lookup file; if found, lookup stateid and check open request,
3110 * and check for delegations in the process of being recalled.
3111 * If not found, create the nfs4_file struct
3112 */
3113 fp = find_file(ino);
3114 if (fp) {
3115 if ((status = nfs4_check_open(fp, open, &stp)))
3116 goto out;
J. Bruce Fields41d22662013-03-21 15:49:47 -04003117 status = nfs4_check_deleg(cl, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07003118 if (status)
3119 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07003121 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003122 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003123 goto out;
J. Bruce Fields3e772462011-08-10 19:07:33 -04003124 status = nfserr_jukebox;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003125 fp = open->op_file;
3126 open->op_file = NULL;
3127 nfsd4_init_file(fp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 }
3129
3130 /*
3131 * OPEN the file, or upgrade an existing OPEN.
3132 * If truncate fails, the OPEN fails.
3133 */
3134 if (stp) {
3135 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003136 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 if (status)
3138 goto out;
3139 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003140 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07003141 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 goto out;
J. Bruce Fields4af82502012-06-07 17:30:45 -04003143 status = nfsd4_truncate(rqstp, current_fh, open);
3144 if (status)
3145 goto out;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003146 stp = open->op_stp;
3147 open->op_stp = NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003148 init_open_stateid(stp, fp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003150 update_stateid(&stp->st_stid.sc_stateid);
3151 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
Benny Halevyd24433c2012-02-16 20:57:17 +02003153 if (nfsd4_has_session(&resp->cstate)) {
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003154 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Andy Adamson66689582009-04-03 08:28:45 +03003155
Benny Halevyd24433c2012-02-16 20:57:17 +02003156 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3157 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3158 open->op_why_no_deleg = WND4_NOT_WANTED;
3159 goto nodeleg;
3160 }
3161 }
3162
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 /*
3164 * Attempt to hand out a delegation. No error return, because the
3165 * OPEN succeeds even if we fail.
3166 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003167 nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003168nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 status = nfs_ok;
3170
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003171 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003172 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003173out:
Benny Halevyd24433c2012-02-16 20:57:17 +02003174 /* 4.1 client trying to upgrade/downgrade delegation? */
3175 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08003176 open->op_deleg_want)
3177 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003178
NeilBrown13cd2182005-06-23 22:03:10 -07003179 if (fp)
3180 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07003181 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003182 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 /*
3184 * To finish the open response, we just need to set the rflags.
3185 */
3186 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003187 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03003188 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3190
3191 return status;
3192}
3193
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003194void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3195{
3196 if (open->op_openowner) {
3197 struct nfs4_openowner *oo = open->op_openowner;
3198
3199 if (!list_empty(&oo->oo_owner.so_stateids))
3200 list_del_init(&oo->oo_close_lru);
3201 if (oo->oo_flags & NFS4_OO_NEW) {
3202 if (status) {
3203 release_openowner(oo);
3204 open->op_openowner = NULL;
3205 } else
3206 oo->oo_flags &= ~NFS4_OO_NEW;
3207 }
3208 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04003209 if (open->op_file)
3210 nfsd4_free_file(open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003211 if (open->op_stp)
J. Bruce Fieldsef798592012-08-29 10:32:54 -07003212 free_generic_stateid(open->op_stp);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003213}
3214
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003215static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
3216{
3217 struct nfs4_client *found;
3218
3219 if (STALE_CLIENTID(clid, nn))
3220 return nfserr_stale_clientid;
3221 found = find_confirmed_client(clid, session, nn);
3222 if (clp)
3223 *clp = found;
3224 return found ? nfs_ok : nfserr_expired;
3225}
3226
Al Virob37ad282006-10-19 23:28:59 -07003227__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003228nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3229 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003230{
3231 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07003232 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03003233 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234
3235 nfs4_lock_state();
3236 dprintk("process_renew(%08x/%08x): starting\n",
3237 clid->cl_boot, clid->cl_id);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003238 status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
3239 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07003242 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04003243 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 goto out;
3245 status = nfs_ok;
3246out:
3247 nfs4_unlock_state();
3248 return status;
3249}
3250
NeilBrowna76b4312005-06-23 22:04:01 -07003251static void
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003252nfsd4_end_grace(struct nfsd_net *nn)
NeilBrowna76b4312005-06-23 22:04:01 -07003253{
Jeff Layton33dcc482012-04-10 11:08:48 -04003254 /* do nothing if grace period already ended */
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003255 if (nn->grace_ended)
Jeff Layton33dcc482012-04-10 11:08:48 -04003256 return;
3257
NeilBrowna76b4312005-06-23 22:04:01 -07003258 dprintk("NFSD: end of grace period\n");
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003259 nn->grace_ended = true;
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003260 nfsd4_record_grace_done(nn, nn->boot_time);
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04003261 locks_end_grace(&nn->nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05003262 /*
3263 * Now that every NFSv4 client has had the chance to recover and
3264 * to see the (possibly new, possibly shorter) lease time, we
3265 * can safely set the next grace time to the current lease time:
3266 */
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03003267 nn->nfsd4_grace = nn->nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07003268}
3269
NeilBrownfd39ca92005-06-23 22:04:03 -07003270static time_t
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003271nfs4_laundromat(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272{
3273 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003274 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275 struct nfs4_delegation *dp;
3276 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003277 time_t cutoff = get_seconds() - nn->nfsd4_lease;
3278 time_t t, clientid_val = nn->nfsd4_lease;
3279 time_t u, test_val = nn->nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280
3281 nfs4_lock_state();
3282
3283 dprintk("NFSD: laundromat service - starting\n");
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003284 nfsd4_end_grace(nn);
Benny Halevy36acb662010-05-12 00:13:04 +03003285 INIT_LIST_HEAD(&reaplist);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003286 spin_lock(&nn->client_lock);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03003287 list_for_each_safe(pos, next, &nn->client_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288 clp = list_entry(pos, struct nfs4_client, cl_lru);
3289 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3290 t = clp->cl_time - cutoff;
3291 if (clientid_val > t)
3292 clientid_val = t;
3293 break;
3294 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003295 if (mark_client_expired_locked(clp)) {
Benny Halevyd7682982010-05-12 00:13:54 +03003296 dprintk("NFSD: client in use (clientid %08x)\n",
3297 clp->cl_clientid.cl_id);
3298 continue;
3299 }
J. Bruce Fields221a6872013-04-01 22:23:49 -04003300 list_move(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03003301 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003302 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03003303 list_for_each_safe(pos, next, &reaplist) {
3304 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 dprintk("NFSD: purging unused client (clientid %08x)\n",
3306 clp->cl_clientid.cl_id);
3307 expire_client(clp);
3308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309 spin_lock(&recall_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04003310 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Stanislav Kinsbursky4e37a7c22012-11-26 15:22:03 +03003312 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3313 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3315 u = dp->dl_time - cutoff;
3316 if (test_val > u)
3317 test_val = u;
3318 break;
3319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 list_move(&dp->dl_recall_lru, &reaplist);
3321 }
3322 spin_unlock(&recall_lock);
3323 list_for_each_safe(pos, next, &reaplist) {
3324 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003325 revoke_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 }
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003327 test_val = nn->nfsd4_lease;
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003328 list_for_each_safe(pos, next, &nn->close_lru) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003329 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3330 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3331 u = oo->oo_time - cutoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 if (test_val > u)
3333 test_val = u;
3334 break;
3335 }
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003336 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337 }
3338 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3339 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3340 nfs4_unlock_state();
3341 return clientid_val;
3342}
3343
Harvey Harrisona254b242008-02-20 12:49:00 -08003344static struct workqueue_struct *laundry_wq;
3345static void laundromat_main(struct work_struct *);
Harvey Harrisona254b242008-02-20 12:49:00 -08003346
3347static void
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003348laundromat_main(struct work_struct *laundry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349{
3350 time_t t;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003351 struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3352 work);
3353 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3354 laundromat_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003356 t = nfs4_laundromat(nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003358 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359}
3360
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003361static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07003362{
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003363 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3364 return nfserr_bad_stateid;
3365 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366}
3367
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003369access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003371 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3372 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3373 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374}
3375
3376static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003377access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003379 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3380 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381}
3382
3383static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003384__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385{
Al Virob37ad282006-10-19 23:28:59 -07003386 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387
J. Bruce Fields02921912010-07-29 15:16:59 -04003388 /* For lock stateid's, we test the parent open, not the lock: */
3389 if (stp->st_openstp)
3390 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003391 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003393 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394 goto out;
3395 status = nfs_ok;
3396out:
3397 return status;
3398}
3399
Al Virob37ad282006-10-19 23:28:59 -07003400static inline __be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003401check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003403 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404 return nfs_ok;
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003405 else if (locks_in_grace(net)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003406 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 * conflicting state; so we must wait out the grace period. */
3408 return nfserr_grace;
3409 } else if (flags & WR_STATE)
3410 return nfs4_share_conflict(current_fh,
3411 NFS4_SHARE_DENY_WRITE);
3412 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3413 return nfs4_share_conflict(current_fh,
3414 NFS4_SHARE_DENY_READ);
3415}
3416
3417/*
3418 * Allow READ/WRITE during grace period on recovered state only for files
3419 * that are not able to provide mandatory locking.
3420 */
3421static inline int
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003422grace_disallows_io(struct net *net, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423{
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003424 return locks_in_grace(net) && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425}
3426
J. Bruce Fields81b82962011-08-23 11:03:29 -04003427/* Returns true iff a is later than b: */
3428static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3429{
3430 return (s32)a->si_generation - (s32)b->si_generation > 0;
3431}
3432
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003433static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003434{
Andy Adamson66689582009-04-03 08:28:45 +03003435 /*
3436 * When sessions are used the stateid generation number is ignored
3437 * when it is zero.
3438 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04003439 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04003440 return nfs_ok;
3441
3442 if (in->si_generation == ref->si_generation)
3443 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03003444
J. Bruce Fields0836f582008-01-26 19:08:12 -05003445 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003446 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05003447 return nfserr_bad_stateid;
3448 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04003449 * However, we could see a stateid from the past, even from a
3450 * non-buggy client. For example, if the client sends a lock
3451 * while some IO is outstanding, the lock may bump si_generation
3452 * while the IO is still in flight. The client could avoid that
3453 * situation by waiting for responses on all the IO requests,
3454 * but better performance may result in retrying IO that
3455 * receives an old_stateid error if requests are rarely
3456 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003457 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003458 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003459}
3460
Chuck Lever7df302f2012-05-29 13:56:37 -04003461static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04003462{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003463 struct nfs4_stid *s;
3464 struct nfs4_ol_stateid *ols;
3465 __be32 status;
Bryan Schumaker17456802011-07-13 10:50:48 -04003466
Chuck Lever7df302f2012-05-29 13:56:37 -04003467 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3468 return nfserr_bad_stateid;
3469 /* Client debugging aid. */
3470 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3471 char addr_str[INET6_ADDRSTRLEN];
3472 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3473 sizeof(addr_str));
3474 pr_warn_ratelimited("NFSD: client %s testing state ID "
3475 "with incorrect client ID\n", addr_str);
3476 return nfserr_bad_stateid;
3477 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003478 s = find_stateid(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003479 if (!s)
Chuck Lever7df302f2012-05-29 13:56:37 -04003480 return nfserr_bad_stateid;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04003481 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04003482 if (status)
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003483 return status;
J. Bruce Fields23340032013-04-09 17:42:28 -04003484 switch (s->sc_type) {
3485 case NFS4_DELEG_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003486 return nfs_ok;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003487 case NFS4_REVOKED_DELEG_STID:
3488 return nfserr_deleg_revoked;
J. Bruce Fields23340032013-04-09 17:42:28 -04003489 case NFS4_OPEN_STID:
3490 case NFS4_LOCK_STID:
3491 ols = openlockstateid(s);
3492 if (ols->st_stateowner->so_is_open_owner
3493 && !(openowner(ols->st_stateowner)->oo_flags
3494 & NFS4_OO_CONFIRMED))
3495 return nfserr_bad_stateid;
3496 return nfs_ok;
3497 default:
3498 printk("unknown stateid type %x\n", s->sc_type);
3499 case NFS4_CLOSED_STID:
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003500 return nfserr_bad_stateid;
J. Bruce Fields23340032013-04-09 17:42:28 -04003501 }
Bryan Schumaker17456802011-07-13 10:50:48 -04003502}
3503
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003504static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
3505 struct nfs4_stid **s, bool sessions,
3506 struct nfsd_net *nn)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003507{
3508 struct nfs4_client *cl;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003509 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003510
3511 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3512 return nfserr_bad_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003513 status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
3514 nn, &cl);
3515 if (status == nfserr_stale_clientid)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003516 return nfserr_stale_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003517 if (status)
3518 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003519 *s = find_stateid_by_type(cl, stateid, typemask);
3520 if (!*s)
3521 return nfserr_bad_stateid;
3522 return nfs_ok;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003523}
3524
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525/*
3526* Checks for stateid operations
3527*/
Al Virob37ad282006-10-19 23:28:59 -07003528__be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003529nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
Benny Halevydd453df2009-04-03 08:28:41 +03003530 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531{
J. Bruce Fields69064a22011-09-09 11:54:57 -04003532 struct nfs4_stid *s;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003533 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003534 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003535 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 struct inode *ino = current_fh->fh_dentry->d_inode;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003537 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Al Virob37ad282006-10-19 23:28:59 -07003538 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540 if (filpp)
3541 *filpp = NULL;
3542
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003543 if (grace_disallows_io(net, ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544 return nfserr_grace;
3545
3546 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003547 return check_special_stateids(net, current_fh, stateid, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003549 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3550 &s, cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003551 if (status)
3552 return status;
J. Bruce Fields69064a22011-09-09 11:54:57 -04003553 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3554 if (status)
3555 goto out;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003556 switch (s->sc_type) {
3557 case NFS4_DELEG_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003558 dp = delegstateid(s);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003559 status = nfs4_check_delegmode(dp, flags);
3560 if (status)
3561 goto out;
Dan Carpenter43b01782010-10-27 23:19:04 +02003562 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003563 *filpp = dp->dl_file->fi_deleg_file;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003564 if (!*filpp) {
3565 WARN_ON_ONCE(1);
3566 status = nfserr_serverfault;
3567 goto out;
3568 }
Dan Carpenter43b01782010-10-27 23:19:04 +02003569 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003570 break;
3571 case NFS4_OPEN_STID:
3572 case NFS4_LOCK_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003573 stp = openlockstateid(s);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003574 status = nfs4_check_fh(current_fh, stp);
3575 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003577 if (stp->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003578 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003580 status = nfs4_check_openmode(stp, flags);
3581 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003583 if (filpp) {
3584 if (flags & RD_STATE)
3585 *filpp = find_readable_file(stp->st_file);
3586 else
3587 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003588 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003589 break;
3590 default:
3591 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 }
3593 status = nfs_ok;
3594out:
3595 return status;
3596}
3597
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003598static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003599nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003600{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003601 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003602 return nfserr_locks_held;
3603 release_lock_stateid(stp);
3604 return nfs_ok;
3605}
3606
3607/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003608 * Test if the stateid is valid
3609 */
3610__be32
3611nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3612 struct nfsd4_test_stateid *test_stateid)
3613{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003614 struct nfsd4_test_stateid_id *stateid;
3615 struct nfs4_client *cl = cstate->session->se_client;
3616
3617 nfs4_lock_state();
3618 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
Chuck Lever7df302f2012-05-29 13:56:37 -04003619 stateid->ts_id_status =
3620 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003621 nfs4_unlock_state();
3622
Bryan Schumaker17456802011-07-13 10:50:48 -04003623 return nfs_ok;
3624}
3625
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003626__be32
3627nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3628 struct nfsd4_free_stateid *free_stateid)
3629{
3630 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003631 struct nfs4_stid *s;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003632 struct nfs4_delegation *dp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003633 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003634 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003635
3636 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003637 s = find_stateid(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003638 if (!s)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003639 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003640 switch (s->sc_type) {
3641 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003642 ret = nfserr_locks_held;
3643 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003644 case NFS4_OPEN_STID:
3645 case NFS4_LOCK_STID:
3646 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3647 if (ret)
3648 goto out;
3649 if (s->sc_type == NFS4_LOCK_STID)
3650 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3651 else
3652 ret = nfserr_locks_held;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003653 break;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003654 case NFS4_REVOKED_DELEG_STID:
3655 dp = delegstateid(s);
3656 destroy_revoked_delegation(dp);
3657 ret = nfs_ok;
3658 break;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003659 default:
3660 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003661 }
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003662out:
3663 nfs4_unlock_state();
3664 return ret;
3665}
3666
NeilBrown4c4cd222005-07-07 17:59:27 -07003667static inline int
3668setlkflg (int type)
3669{
3670 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3671 RD_STATE : WR_STATE;
3672}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003674static __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 -04003675{
3676 struct svc_fh *current_fh = &cstate->current_fh;
3677 struct nfs4_stateowner *sop = stp->st_stateowner;
3678 __be32 status;
3679
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003680 status = nfsd4_check_seqid(cstate, sop, seqid);
3681 if (status)
3682 return status;
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003683 if (stp->st_stid.sc_type == NFS4_CLOSED_STID
3684 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003685 /*
3686 * "Closed" stateid's exist *only* to return
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003687 * nfserr_replay_me from the previous step, and
3688 * revoked delegations are kept only for free_stateid.
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003689 */
3690 return nfserr_bad_stateid;
3691 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3692 if (status)
3693 return status;
3694 return nfs4_check_fh(current_fh, stp);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003695}
3696
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697/*
3698 * Checks for sequence id mutating operations.
3699 */
Al Virob37ad282006-10-19 23:28:59 -07003700static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003701nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003702 stateid_t *stateid, char typemask,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003703 struct nfs4_ol_stateid **stpp,
3704 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705{
J. Bruce Fields0836f582008-01-26 19:08:12 -05003706 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003707 struct nfs4_stid *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003708
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003709 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3710 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003711
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712 *stpp = NULL;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003713 status = nfsd4_lookup_stateid(stateid, typemask, &s,
3714 cstate->minorversion, nn);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003715 if (status)
3716 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003717 *stpp = openlockstateid(s);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04003718 if (!nfsd4_has_session(cstate))
3719 cstate->replay_owner = (*stpp)->st_stateowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003721 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3722}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003723
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003724static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3725 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003726{
3727 __be32 status;
3728 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003729
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003730 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003731 NFS4_OPEN_STID, stpp, nn);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003732 if (status)
3733 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003734 oo = openowner((*stpp)->st_stateowner);
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003735 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003736 return nfserr_bad_stateid;
NeilBrown3a4f98b2005-07-07 17:59:26 -07003737 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738}
3739
Al Virob37ad282006-10-19 23:28:59 -07003740__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003741nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003742 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743{
Al Virob37ad282006-10-19 23:28:59 -07003744 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003745 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003746 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003747 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003748
3749 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003750 (int)cstate->current_fh.fh_dentry->d_name.len,
3751 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003753 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003754 if (status)
3755 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756
3757 nfs4_lock_state();
3758
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003759 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003760 oc->oc_seqid, &oc->oc_req_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003761 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003762 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003763 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003764 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003765 status = nfserr_bad_stateid;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003766 if (oo->oo_flags & NFS4_OO_CONFIRMED)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003767 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003768 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003769 update_stateid(&stp->st_stid.sc_stateid);
3770 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003771 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003772 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003773
Jeff Layton2a4317c2012-03-21 16:42:43 -04003774 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003775 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003777 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003778 if (!cstate->replay_owner)
3779 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 return status;
3781}
3782
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003783static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003785 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003786 return;
3787 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
Jeff Layton82c5ff12012-05-11 09:45:13 -04003788 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003789}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003790
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003791static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3792{
3793 switch (to_access) {
3794 case NFS4_SHARE_ACCESS_READ:
3795 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3796 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3797 break;
3798 case NFS4_SHARE_ACCESS_WRITE:
3799 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3800 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3801 break;
3802 case NFS4_SHARE_ACCESS_BOTH:
3803 break;
3804 default:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003805 WARN_ON_ONCE(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003806 }
3807}
3808
3809static void
Jeff Laytonce0fc432012-05-11 09:45:14 -04003810reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811{
3812 int i;
3813 for (i = 0; i < 4; i++) {
3814 if ((i & deny) != i)
Jeff Laytonce0fc432012-05-11 09:45:14 -04003815 clear_deny(i, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816 }
3817}
3818
Al Virob37ad282006-10-19 23:28:59 -07003819__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003820nfsd4_open_downgrade(struct svc_rqst *rqstp,
3821 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003822 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823{
Al Virob37ad282006-10-19 23:28:59 -07003824 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003825 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003826 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003827
3828 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003829 (int)cstate->current_fh.fh_dentry->d_name.len,
3830 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04003832 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02003833 if (od->od_deleg_want)
3834 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
3835 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003836
3837 nfs4_lock_state();
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003838 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003839 &od->od_stateid, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003840 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003843 if (!test_access(od->od_share_access, stp)) {
3844 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003845 stp->st_access_bmap, od->od_share_access);
3846 goto out;
3847 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04003848 if (!test_deny(od->od_share_deny, stp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3850 stp->st_deny_bmap, od->od_share_deny);
3851 goto out;
3852 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003853 nfs4_stateid_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854
Jeff Laytonce0fc432012-05-11 09:45:14 -04003855 reset_union_bmap_deny(od->od_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003857 update_stateid(&stp->st_stid.sc_stateid);
3858 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003859 status = nfs_ok;
3860out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003861 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003862 if (!cstate->replay_owner)
3863 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003864 return status;
3865}
3866
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003867static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3868{
3869 unhash_open_stateid(s);
3870 s->st_stid.sc_type = NFS4_CLOSED_STID;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003871}
3872
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873/*
3874 * nfs4_unlock_state() called after encode
3875 */
Al Virob37ad282006-10-19 23:28:59 -07003876__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003877nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003878 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003879{
Al Virob37ad282006-10-19 23:28:59 -07003880 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003881 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003882 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003883 struct net *net = SVC_NET(rqstp);
3884 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003885
3886 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003887 (int)cstate->current_fh.fh_dentry->d_name.len,
3888 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003889
3890 nfs4_lock_state();
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003891 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3892 &close->cl_stateid,
3893 NFS4_OPEN_STID|NFS4_CLOSED_STID,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003894 &stp, nn);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003895 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003896 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003897 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003898 oo = openowner(stp->st_stateowner);
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003899 update_stateid(&stp->st_stid.sc_stateid);
3900 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003901
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003902 nfsd4_close_open_stateid(stp);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04003903
3904 if (cstate->minorversion) {
3905 unhash_stid(&stp->st_stid);
3906 free_generic_stateid(stp);
3907 } else
3908 oo->oo_last_closed_stid = stp;
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003909
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003910 if (list_empty(&oo->oo_owner.so_stateids)) {
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04003911 if (cstate->minorversion)
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003912 release_openowner(oo);
J. Bruce Fields3d74e6a2013-03-22 17:44:19 -04003913 else {
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003914 /*
3915 * In the 4.0 case we need to keep the owners around a
3916 * little while to handle CLOSE replay.
3917 */
fanchaoting53584f62013-04-11 21:24:13 +08003918 move_to_close_lru(oo, SVC_NET(rqstp));
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003919 }
3920 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003922 if (!cstate->replay_owner)
3923 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924 return status;
3925}
3926
Al Virob37ad282006-10-19 23:28:59 -07003927__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003928nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3929 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003930{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003931 struct nfs4_delegation *dp;
3932 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003933 struct nfs4_stid *s;
Al Virob37ad282006-10-19 23:28:59 -07003934 __be32 status;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003935 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003936
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003937 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003938 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003939
3940 nfs4_lock_state();
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003941 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
3942 cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003943 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003944 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003945 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003946 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003947 if (status)
3948 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003949
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04003950 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003952 nfs4_unlock_state();
3953
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954 return status;
3955}
3956
3957
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003959
J. Bruce Fields009673b2011-11-07 17:40:10 -05003960#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961
Benny Halevy87df4de2008-12-15 19:42:03 +02003962static inline u64
3963end_offset(u64 start, u64 len)
3964{
3965 u64 end;
3966
3967 end = start + len;
3968 return end >= start ? end: NFS4_MAX_UINT64;
3969}
3970
3971/* last octet in a range */
3972static inline u64
3973last_byte_offset(u64 start, u64 len)
3974{
3975 u64 end;
3976
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003977 WARN_ON_ONCE(!len);
Benny Halevy87df4de2008-12-15 19:42:03 +02003978 end = start + len;
3979 return end > start ? end - 1: NFS4_MAX_UINT64;
3980}
3981
J. Bruce Fields009673b2011-11-07 17:40:10 -05003982static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003983{
3984 return (file_hashval(inode) + cl_id
3985 + opaque_hashval(ownername->data, ownername->len))
J. Bruce Fields009673b2011-11-07 17:40:10 -05003986 & LOCKOWNER_INO_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003987}
3988
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989/*
3990 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3991 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3992 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3993 * locking, this prevents us from being completely protocol-compliant. The
3994 * real solution to this problem is to start using unsigned file offsets in
3995 * the VFS, but this is a very deep change!
3996 */
3997static inline void
3998nfs4_transform_lock_offset(struct file_lock *lock)
3999{
4000 if (lock->fl_start < 0)
4001 lock->fl_start = OFFSET_MAX;
4002 if (lock->fl_end < 0)
4003 lock->fl_end = OFFSET_MAX;
4004}
4005
NeilBrownd5b90262006-04-10 22:55:22 -07004006/* Hack!: For now, we're defining this just so we can use a pointer to it
4007 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07004008static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07004009};
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010
4011static inline void
4012nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
4013{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004014 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004015
NeilBrownd5b90262006-04-10 22:55:22 -07004016 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004017 lo = (struct nfs4_lockowner *) fl->fl_owner;
4018 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
4019 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004020 if (!deny->ld_owner.data)
4021 /* We just don't care that much */
4022 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004023 deny->ld_owner.len = lo->lo_owner.so_owner.len;
4024 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07004025 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04004026nevermind:
4027 deny->ld_owner.len = 0;
4028 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07004029 deny->ld_clientid.cl_boot = 0;
4030 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004031 }
4032 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02004033 deny->ld_length = NFS4_MAX_UINT64;
4034 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004035 deny->ld_length = fl->fl_end - fl->fl_start + 1;
4036 deny->ld_type = NFS4_READ_LT;
4037 if (fl->fl_type != F_RDLCK)
4038 deny->ld_type = NFS4_WRITE_LT;
4039}
4040
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004041static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
4042{
4043 struct nfs4_ol_stateid *lst;
4044
4045 if (!same_owner_str(&lo->lo_owner, owner, clid))
4046 return false;
4047 lst = list_first_entry(&lo->lo_owner.so_stateids,
4048 struct nfs4_ol_stateid, st_perstateowner);
4049 return lst->st_file->fi_inode == inode;
4050}
4051
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004052static struct nfs4_lockowner *
4053find_lockowner_str(struct inode *inode, clientid_t *clid,
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004054 struct xdr_netobj *owner, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004055{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004056 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004057 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004058
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004059 list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05004060 if (same_lockowner_ino(lo, inode, clid, owner))
4061 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004062 }
4063 return NULL;
4064}
4065
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004066static 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 -04004067{
J. Bruce Fields009673b2011-11-07 17:40:10 -05004068 struct inode *inode = open_stp->st_file->fi_inode;
4069 unsigned int inohash = lockowner_ino_hashval(inode,
4070 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004071 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
J. Bruce Fields009673b2011-11-07 17:40:10 -05004072
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004073 list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004074 list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004075 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04004076}
4077
Linus Torvalds1da177e2005-04-16 15:20:36 -07004078/*
4079 * Alloc a lock owner structure.
4080 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004081 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004082 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004083 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07004084 */
4085
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004086static struct nfs4_lockowner *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004087alloc_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 -04004088 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004090 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4091 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004092 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004093 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4094 lo->lo_owner.so_is_open_owner = 0;
Neil Brownb59e3c02005-09-13 01:25:38 -07004095 /* It is the openowner seqid that will be incremented in encode in the
4096 * case of new lockowners; so increment the lock seqid manually: */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004097 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4098 hash_lockowner(lo, strhashval, clp, open_stp);
4099 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100}
4101
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004102static struct nfs4_ol_stateid *
4103alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004104{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004105 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04004106 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004107
J. Bruce Fields996e0932011-10-17 11:14:48 -04004108 stp = nfs4_alloc_stateid(clp);
NeilBrown5ac049a2005-06-23 22:03:03 -07004109 if (stp == NULL)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -04004110 return NULL;
J. Bruce Fields3abdb602013-02-03 12:23:01 -05004111 stp->st_stid.sc_type = NFS4_LOCK_STID;
NeilBrown8beefa22005-06-23 22:03:08 -07004112 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004113 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4114 stp->st_stateowner = &lo->lo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07004115 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004116 stp->st_file = fp;
J. Bruce Fields0997b172011-03-02 18:01:35 -05004117 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004118 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07004119 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 return stp;
4121}
4122
NeilBrownfd39ca92005-06-23 22:04:03 -07004123static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07004124check_lock_length(u64 offset, u64 length)
4125{
Benny Halevy87df4de2008-12-15 19:42:03 +02004126 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004127 LOFF_OVERFLOW(offset, length)));
4128}
4129
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004130static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05004131{
4132 struct nfs4_file *fp = lock_stp->st_file;
4133 int oflag = nfs4_access_to_omode(access);
4134
Jeff Layton82c5ff12012-05-11 09:45:13 -04004135 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05004136 return;
4137 nfs4_file_get_access(fp, oflag);
Jeff Layton82c5ff12012-05-11 09:45:13 -04004138 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05004139}
4140
J. Bruce Fields2355c592012-04-25 16:56:22 -04004141static __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 -04004142{
4143 struct nfs4_file *fi = ost->st_file;
4144 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4145 struct nfs4_client *cl = oo->oo_owner.so_client;
4146 struct nfs4_lockowner *lo;
4147 unsigned int strhashval;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004148 struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004149
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004150 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
4151 &lock->v.new.owner, nn);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004152 if (lo) {
4153 if (!cstate->minorversion)
4154 return nfserr_bad_seqid;
4155 /* XXX: a lockowner always has exactly one stateid: */
4156 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4157 struct nfs4_ol_stateid, st_perstateowner);
4158 return nfs_ok;
4159 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004160 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004161 &lock->v.new.owner);
4162 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4163 if (lo == NULL)
4164 return nfserr_jukebox;
4165 *lst = alloc_init_lock_stateid(lo, fi, ost);
4166 if (*lst == NULL) {
4167 release_lockowner(lo);
4168 return nfserr_jukebox;
4169 }
4170 *new = true;
4171 return nfs_ok;
4172}
4173
Linus Torvalds1da177e2005-04-16 15:20:36 -07004174/*
4175 * LOCK operation
4176 */
Al Virob37ad282006-10-19 23:28:59 -07004177__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004178nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004179 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004180{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004181 struct nfs4_openowner *open_sop = NULL;
4182 struct nfs4_lockowner *lock_sop = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004183 struct nfs4_ol_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004184 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004185 struct file_lock *file_lock = NULL;
4186 struct file_lock *conflock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004187 __be32 status = 0;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004188 bool new_state = false;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004189 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07004190 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004191 struct net *net = SVC_NET(rqstp);
4192 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004193
4194 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4195 (long long) lock->lk_offset,
4196 (long long) lock->lk_length);
4197
Linus Torvalds1da177e2005-04-16 15:20:36 -07004198 if (check_lock_length(lock->lk_offset, lock->lk_length))
4199 return nfserr_inval;
4200
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004201 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004202 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004203 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4204 return status;
4205 }
4206
Linus Torvalds1da177e2005-04-16 15:20:36 -07004207 nfs4_lock_state();
4208
4209 if (lock->lk_is_new) {
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004210 struct nfs4_ol_stateid *open_stp = NULL;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004211
4212 if (nfsd4_has_session(cstate))
4213 /* See rfc 5661 18.10.3: given clientid is ignored: */
4214 memcpy(&lock->v.new.clientid,
4215 &cstate->session->se_client->cl_clientid,
4216 sizeof(clientid_t));
4217
Linus Torvalds1da177e2005-04-16 15:20:36 -07004218 status = nfserr_stale_clientid;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004219 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004221
Linus Torvalds1da177e2005-04-16 15:20:36 -07004222 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004223 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004224 lock->lk_new_open_seqid,
4225 &lock->lk_new_open_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004226 &open_stp, nn);
NeilBrown37515172005-07-07 17:59:16 -07004227 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004228 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004229 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004230 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004231 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004232 &lock->v.new.clientid))
4233 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004234 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4235 &lock_stp, &new_state);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004236 } else
Benny Halevydd453df2009-04-03 08:28:41 +03004237 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004238 lock->lk_old_lock_seqid,
4239 &lock->lk_old_lock_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004240 NFS4_LOCK_STID, &lock_stp, nn);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004241 if (status)
4242 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004243 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004244
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004245 lkflg = setlkflg(lock->lk_type);
4246 status = nfs4_check_openmode(lock_stp, lkflg);
4247 if (status)
4248 goto out;
4249
NeilBrown0dd395d2005-07-07 17:59:15 -07004250 status = nfserr_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004251 if (locks_in_grace(net) && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004252 goto out;
4253 status = nfserr_no_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004254 if (!locks_in_grace(net) && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004255 goto out;
4256
Jeff Layton21179d82012-08-21 08:03:32 -04004257 file_lock = locks_alloc_lock();
4258 if (!file_lock) {
4259 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4260 status = nfserr_jukebox;
4261 goto out;
4262 }
4263
4264 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004265 switch (lock->lk_type) {
4266 case NFS4_READ_LT:
4267 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004268 filp = find_readable_file(lock_stp->st_file);
4269 if (filp)
4270 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Jeff Layton21179d82012-08-21 08:03:32 -04004271 file_lock->fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004272 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004273 case NFS4_WRITE_LT:
4274 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004275 filp = find_writeable_file(lock_stp->st_file);
4276 if (filp)
4277 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Jeff Layton21179d82012-08-21 08:03:32 -04004278 file_lock->fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004279 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280 default:
4281 status = nfserr_inval;
4282 goto out;
4283 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004284 if (!filp) {
4285 status = nfserr_openmode;
4286 goto out;
4287 }
Jeff Layton21179d82012-08-21 08:03:32 -04004288 file_lock->fl_owner = (fl_owner_t)lock_sop;
4289 file_lock->fl_pid = current->tgid;
4290 file_lock->fl_file = filp;
4291 file_lock->fl_flags = FL_POSIX;
4292 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4293 file_lock->fl_start = lock->lk_offset;
4294 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4295 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296
Jeff Layton21179d82012-08-21 08:03:32 -04004297 conflock = locks_alloc_lock();
4298 if (!conflock) {
4299 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4300 status = nfserr_jukebox;
4301 goto out;
4302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303
Jeff Layton21179d82012-08-21 08:03:32 -04004304 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004305 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306 case 0: /* success! */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004307 update_stateid(&lock_stp->st_stid.sc_stateid);
4308 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004310 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004311 break;
4312 case (EAGAIN): /* conflock holds conflicting lock */
4313 status = nfserr_denied;
4314 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
Jeff Layton21179d82012-08-21 08:03:32 -04004315 nfs4_set_lock_denied(conflock, &lock->lk_denied);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004316 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317 case (EDEADLK):
4318 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004319 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04004320 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004321 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04004322 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004323 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004324 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325out:
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004326 if (status && new_state)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004327 release_lockowner(lock_sop);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004328 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004329 if (!cstate->replay_owner)
4330 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004331 if (file_lock)
4332 locks_free_lock(file_lock);
4333 if (conflock)
4334 locks_free_lock(conflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004335 return status;
4336}
4337
4338/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004339 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4340 * so we do a temporary open here just to get an open file to pass to
4341 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4342 * inode operation.)
4343 */
Al Viro04da6e92012-04-13 00:00:04 -04004344static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004345{
4346 struct file *file;
Al Viro04da6e92012-04-13 00:00:04 -04004347 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4348 if (!err) {
4349 err = nfserrno(vfs_test_lock(file, lock));
4350 nfsd_close(file);
4351 }
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004352 return err;
4353}
4354
4355/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004356 * LOCKT operation
4357 */
Al Virob37ad282006-10-19 23:28:59 -07004358__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004359nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4360 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004361{
4362 struct inode *inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004363 struct file_lock *file_lock = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004364 struct nfs4_lockowner *lo;
Al Virob37ad282006-10-19 23:28:59 -07004365 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004366 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004367
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004368 if (locks_in_grace(SVC_NET(rqstp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004369 return nfserr_grace;
4370
4371 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4372 return nfserr_inval;
4373
Linus Torvalds1da177e2005-04-16 15:20:36 -07004374 nfs4_lock_state();
4375
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004376 if (!nfsd4_has_session(cstate)) {
4377 status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
4378 if (status)
4379 goto out;
4380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004381
J. Bruce Fields75c096f2011-08-15 18:39:32 -04004382 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004383 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004384
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004385 inode = cstate->current_fh.fh_dentry->d_inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004386 file_lock = locks_alloc_lock();
4387 if (!file_lock) {
4388 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4389 status = nfserr_jukebox;
4390 goto out;
4391 }
4392 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004393 switch (lockt->lt_type) {
4394 case NFS4_READ_LT:
4395 case NFS4_READW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004396 file_lock->fl_type = F_RDLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004397 break;
4398 case NFS4_WRITE_LT:
4399 case NFS4_WRITEW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004400 file_lock->fl_type = F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004401 break;
4402 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004403 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004404 status = nfserr_inval;
4405 goto out;
4406 }
4407
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004408 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004409 if (lo)
Jeff Layton21179d82012-08-21 08:03:32 -04004410 file_lock->fl_owner = (fl_owner_t)lo;
4411 file_lock->fl_pid = current->tgid;
4412 file_lock->fl_flags = FL_POSIX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004413
Jeff Layton21179d82012-08-21 08:03:32 -04004414 file_lock->fl_start = lockt->lt_offset;
4415 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004416
Jeff Layton21179d82012-08-21 08:03:32 -04004417 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004418
Jeff Layton21179d82012-08-21 08:03:32 -04004419 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
Al Viro04da6e92012-04-13 00:00:04 -04004420 if (status)
Marc Eshelfd85b812006-11-28 16:26:41 -05004421 goto out;
Al Viro04da6e92012-04-13 00:00:04 -04004422
Jeff Layton21179d82012-08-21 08:03:32 -04004423 if (file_lock->fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004424 status = nfserr_denied;
Jeff Layton21179d82012-08-21 08:03:32 -04004425 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004426 }
4427out:
4428 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004429 if (file_lock)
4430 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004431 return status;
4432}
4433
Al Virob37ad282006-10-19 23:28:59 -07004434__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004435nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004436 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437{
J. Bruce Fieldseb2099f2013-04-07 13:28:16 -04004438 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004439 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004440 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004441 struct file_lock *file_lock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004442 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004443 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004444 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4445
Linus Torvalds1da177e2005-04-16 15:20:36 -07004446 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4447 (long long) locku->lu_offset,
4448 (long long) locku->lu_length);
4449
4450 if (check_lock_length(locku->lu_offset, locku->lu_length))
4451 return nfserr_inval;
4452
4453 nfs4_lock_state();
4454
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004455 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004456 &locku->lu_stateid, NFS4_LOCK_STID,
4457 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004458 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004459 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004460 filp = find_any_file(stp->st_file);
4461 if (!filp) {
4462 status = nfserr_lock_range;
4463 goto out;
4464 }
Jeff Layton21179d82012-08-21 08:03:32 -04004465 file_lock = locks_alloc_lock();
4466 if (!file_lock) {
4467 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4468 status = nfserr_jukebox;
4469 goto out;
4470 }
J. Bruce Fieldseb2099f2013-04-07 13:28:16 -04004471 lo = lockowner(stp->st_stateowner);
Jeff Layton21179d82012-08-21 08:03:32 -04004472 locks_init_lock(file_lock);
4473 file_lock->fl_type = F_UNLCK;
J. Bruce Fieldseb2099f2013-04-07 13:28:16 -04004474 file_lock->fl_owner = (fl_owner_t)lo;
Jeff Layton21179d82012-08-21 08:03:32 -04004475 file_lock->fl_pid = current->tgid;
4476 file_lock->fl_file = filp;
4477 file_lock->fl_flags = FL_POSIX;
4478 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4479 file_lock->fl_start = locku->lu_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004480
Jeff Layton21179d82012-08-21 08:03:32 -04004481 file_lock->fl_end = last_byte_offset(locku->lu_offset,
4482 locku->lu_length);
4483 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484
Jeff Layton21179d82012-08-21 08:03:32 -04004485 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004486 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004487 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488 goto out_nfserr;
4489 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004490 update_stateid(&stp->st_stid.sc_stateid);
4491 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492
J. Bruce Fieldseb2099f2013-04-07 13:28:16 -04004493 if (nfsd4_has_session(cstate) && !check_for_locks(stp->st_file, lo)) {
4494 WARN_ON_ONCE(cstate->replay_owner);
4495 release_lockowner(lo);
4496 }
4497
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498out:
J. Bruce Fields9411b1d2013-04-01 16:37:12 -04004499 nfsd4_bump_seqid(cstate, status);
J. Bruce Fields71c3bcd2011-09-27 21:42:29 -04004500 if (!cstate->replay_owner)
4501 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004502 if (file_lock)
4503 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504 return status;
4505
4506out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004507 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508 goto out;
4509}
4510
4511/*
4512 * returns
4513 * 1: locks held by lockowner
4514 * 0: no locks held by lockowner
4515 */
4516static int
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004517check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518{
4519 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004520 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004521 int status = 0;
4522
Jeff Layton1c8c6012013-06-21 08:58:15 -04004523 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004524 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004525 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004526 status = 1;
4527 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529 }
4530out:
Jeff Layton1c8c6012013-06-21 08:58:15 -04004531 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 return status;
4533}
4534
Al Virob37ad282006-10-19 23:28:59 -07004535__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004536nfsd4_release_lockowner(struct svc_rqst *rqstp,
4537 struct nfsd4_compound_state *cstate,
4538 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539{
4540 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004541 struct nfs4_stateowner *sop;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004542 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004543 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004544 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004545 struct list_head matches;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004546 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
Al Virob37ad282006-10-19 23:28:59 -07004547 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004548 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549
4550 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4551 clid->cl_boot, clid->cl_id);
4552
Linus Torvalds1da177e2005-04-16 15:20:36 -07004553 nfs4_lock_state();
4554
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004555 status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
4556 if (status)
4557 goto out;
4558
NeilBrown3e9e3db2005-06-23 22:04:20 -07004559 status = nfserr_locks_held;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004560 INIT_LIST_HEAD(&matches);
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004561
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004562 list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004563 if (sop->so_is_open_owner)
4564 continue;
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004565 if (!same_owner_str(sop, owner, clid))
4566 continue;
4567 list_for_each_entry(stp, &sop->so_stateids,
4568 st_perstateowner) {
4569 lo = lockowner(sop);
4570 if (check_for_locks(stp->st_file, lo))
4571 goto out;
4572 list_add(&lo->lo_list, &matches);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004573 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004574 }
4575 /* Clients probably won't expect us to return with some (but not all)
4576 * of the lockowner state released; so don't release any until all
4577 * have been checked. */
4578 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004579 while (!list_empty(&matches)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004580 lo = list_entry(matches.next, struct nfs4_lockowner,
4581 lo_list);
NeilBrown0fa822e2005-07-07 17:59:14 -07004582 /* unhash_stateowner deletes so_perclient only
4583 * for openowners. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004584 list_del(&lo->lo_list);
4585 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 }
4587out:
4588 nfs4_unlock_state();
4589 return status;
4590}
4591
4592static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004593alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004594{
NeilBrowna55370a2005-06-23 22:03:52 -07004595 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596}
4597
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004598bool
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004599nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
NeilBrownc7b9a452005-06-23 22:04:30 -07004600{
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004601 struct nfs4_client_reclaim *crp;
NeilBrownc7b9a452005-06-23 22:04:30 -07004602
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004603 crp = nfsd4_find_reclaim_client(name, nn);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004604 return (crp && crp->cr_clp);
NeilBrownc7b9a452005-06-23 22:04:30 -07004605}
4606
Linus Torvalds1da177e2005-04-16 15:20:36 -07004607/*
4608 * failure => all reset bets are off, nfserr_no_grace...
4609 */
Jeff Layton772a9bb2012-11-12 15:00:54 -05004610struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004611nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004612{
4613 unsigned int strhashval;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004614 struct nfs4_client_reclaim *crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004615
NeilBrowna55370a2005-06-23 22:03:52 -07004616 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4617 crp = alloc_reclaim();
Jeff Layton772a9bb2012-11-12 15:00:54 -05004618 if (crp) {
4619 strhashval = clientstr_hashval(name);
4620 INIT_LIST_HEAD(&crp->cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004621 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
Jeff Layton772a9bb2012-11-12 15:00:54 -05004622 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004623 crp->cr_clp = NULL;
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004624 nn->reclaim_str_hashtbl_size++;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004625 }
4626 return crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004627}
4628
Jeff Layton2a4317c2012-03-21 16:42:43 -04004629void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004630nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
Jeff Laytonce30e532012-11-12 15:00:53 -05004631{
4632 list_del(&crp->cr_strhash);
4633 kfree(crp);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004634 nn->reclaim_str_hashtbl_size--;
Jeff Laytonce30e532012-11-12 15:00:53 -05004635}
4636
4637void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004638nfs4_release_reclaim(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004639{
4640 struct nfs4_client_reclaim *crp = NULL;
4641 int i;
4642
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004644 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
4645 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004646 struct nfs4_client_reclaim, cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004647 nfs4_remove_reclaim_record(crp, nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004648 }
4649 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004650 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004651}
4652
4653/*
4654 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04004655struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004656nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004657{
4658 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004659 struct nfs4_client_reclaim *crp = NULL;
4660
Jeff Layton278c9312012-11-12 15:00:52 -05004661 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004662
Jeff Layton278c9312012-11-12 15:00:52 -05004663 strhashval = clientstr_hashval(recdir);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004664 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
Jeff Layton278c9312012-11-12 15:00:52 -05004665 if (same_name(crp->cr_recdir, recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004666 return crp;
4667 }
4668 }
4669 return NULL;
4670}
4671
4672/*
4673* Called from OPEN. Look for clientid in reclaim list.
4674*/
Al Virob37ad282006-10-19 23:28:59 -07004675__be32
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004676nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004677{
Jeff Laytona52d7262012-03-21 09:52:02 -04004678 struct nfs4_client *clp;
4679
4680 /* find clientid in conf_id_hashtbl */
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004681 clp = find_confirmed_client(clid, sessions, nn);
Jeff Laytona52d7262012-03-21 09:52:02 -04004682 if (clp == NULL)
4683 return nfserr_reclaim_bad;
4684
4685 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686}
4687
Bryan Schumaker65178db2011-11-01 13:35:21 -04004688#ifdef CONFIG_NFSD_FAULT_INJECTION
4689
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004690u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
4691{
J. Bruce Fields221a6872013-04-01 22:23:49 -04004692 if (mark_client_expired(clp))
4693 return 0;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004694 expire_client(clp);
4695 return 1;
4696}
4697
Bryan Schumaker184c1842012-11-29 11:40:44 -05004698u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
4699{
4700 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004701 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004702 printk(KERN_INFO "NFS Client: %s\n", buf);
4703 return 1;
4704}
4705
4706static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
4707 const char *type)
4708{
4709 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004710 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004711 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
4712}
4713
Bryan Schumakerfc291712012-11-29 11:40:40 -05004714static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
4715{
4716 struct nfs4_openowner *oop;
4717 struct nfs4_lockowner *lop, *lo_next;
4718 struct nfs4_ol_stateid *stp, *st_next;
4719 u64 count = 0;
4720
4721 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
4722 list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
4723 list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
4724 if (func)
4725 func(lop);
4726 if (++count == max)
4727 return count;
4728 }
4729 }
4730 }
4731
4732 return count;
4733}
4734
4735u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
4736{
4737 return nfsd_foreach_client_lock(clp, max, release_lockowner);
4738}
4739
Bryan Schumaker184c1842012-11-29 11:40:44 -05004740u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
4741{
4742 u64 count = nfsd_foreach_client_lock(clp, max, NULL);
4743 nfsd_print_count(clp, count, "locked files");
4744 return count;
4745}
4746
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05004747static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
4748{
4749 struct nfs4_openowner *oop, *next;
4750 u64 count = 0;
4751
4752 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
4753 if (func)
4754 func(oop);
4755 if (++count == max)
4756 break;
4757 }
4758
4759 return count;
4760}
4761
4762u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
4763{
4764 return nfsd_foreach_client_open(clp, max, release_openowner);
4765}
4766
Bryan Schumaker184c1842012-11-29 11:40:44 -05004767u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
4768{
4769 u64 count = nfsd_foreach_client_open(clp, max, NULL);
4770 nfsd_print_count(clp, count, "open files");
4771 return count;
4772}
4773
Bryan Schumaker269de302012-11-29 11:40:42 -05004774static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
4775 struct list_head *victims)
4776{
4777 struct nfs4_delegation *dp, *next;
4778 u64 count = 0;
4779
4780 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
4781 if (victims)
4782 list_move(&dp->dl_recall_lru, victims);
4783 if (++count == max)
4784 break;
4785 }
4786 return count;
4787}
4788
4789u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
4790{
4791 struct nfs4_delegation *dp, *next;
4792 LIST_HEAD(victims);
4793 u64 count;
4794
4795 spin_lock(&recall_lock);
4796 count = nfsd_find_all_delegations(clp, max, &victims);
4797 spin_unlock(&recall_lock);
4798
4799 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04004800 revoke_delegation(dp);
Bryan Schumaker269de302012-11-29 11:40:42 -05004801
4802 return count;
4803}
4804
4805u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
4806{
4807 struct nfs4_delegation *dp, *next;
4808 LIST_HEAD(victims);
4809 u64 count;
4810
4811 spin_lock(&recall_lock);
4812 count = nfsd_find_all_delegations(clp, max, &victims);
4813 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4814 nfsd_break_one_deleg(dp);
4815 spin_unlock(&recall_lock);
4816
4817 return count;
4818}
4819
Bryan Schumaker184c1842012-11-29 11:40:44 -05004820u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
4821{
4822 u64 count = 0;
4823
4824 spin_lock(&recall_lock);
4825 count = nfsd_find_all_delegations(clp, max, NULL);
4826 spin_unlock(&recall_lock);
4827
4828 nfsd_print_count(clp, count, "delegations");
4829 return count;
4830}
4831
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004832u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004833{
4834 struct nfs4_client *clp, *next;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004835 u64 count = 0;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004836 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004837
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004838 if (!nfsd_netns_ready(nn))
4839 return 0;
4840
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004841 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004842 count += func(clp, max - count);
4843 if ((max != 0) && (count >= max))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004844 break;
4845 }
Bryan Schumaker65178db2011-11-01 13:35:21 -04004846
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004847 return count;
4848}
4849
Bryan Schumaker6c1e82a2012-11-29 11:40:46 -05004850struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
4851{
4852 struct nfs4_client *clp;
4853 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
4854
4855 if (!nfsd_netns_ready(nn))
4856 return NULL;
4857
4858 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
4859 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
4860 return clp;
4861 }
4862 return NULL;
4863}
4864
Bryan Schumaker65178db2011-11-01 13:35:21 -04004865#endif /* CONFIG_NFSD_FAULT_INJECTION */
4866
NeilBrownac4d8ff22005-06-23 22:03:30 -07004867/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004868
Bryan Schumaker72083392011-11-01 15:24:59 -04004869void
NeilBrownac4d8ff22005-06-23 22:03:30 -07004870nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004871{
NeilBrownac4d8ff22005-06-23 22:03:30 -07004872}
4873
Meelap Shahc2f1a552007-07-17 04:04:39 -07004874/*
4875 * Since the lifetime of a delegation isn't limited to that of an open, a
4876 * client may quite reasonably hang on to a delegation as long as it has
4877 * the inode cached. This becomes an obvious problem the first time a
4878 * client's inode cache approaches the size of the server's total memory.
4879 *
4880 * For now we avoid this problem by imposing a hard limit on the number
4881 * of delegations, which varies according to the server's memory size.
4882 */
4883static void
4884set_max_delegations(void)
4885{
4886 /*
4887 * Allow at most 4 delegations per megabyte of RAM. Quick
4888 * estimates suggest that in the worst case (where every delegation
4889 * is for a different inode), a delegation could take about 1.5K,
4890 * giving a worst case usage of about 6% of memory.
4891 */
4892 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4893}
4894
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004895static int nfs4_state_create_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004896{
4897 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4898 int i;
4899
4900 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4901 CLIENT_HASH_SIZE, GFP_KERNEL);
4902 if (!nn->conf_id_hashtbl)
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004903 goto err;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004904 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4905 CLIENT_HASH_SIZE, GFP_KERNEL);
4906 if (!nn->unconf_id_hashtbl)
4907 goto err_unconf_id;
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004908 nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
4909 OWNER_HASH_SIZE, GFP_KERNEL);
4910 if (!nn->ownerstr_hashtbl)
4911 goto err_ownerstr;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004912 nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
4913 LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
4914 if (!nn->lockowner_ino_hashtbl)
4915 goto err_lockowner_ino;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004916 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
4917 SESSION_HASH_SIZE, GFP_KERNEL);
4918 if (!nn->sessionid_hashtbl)
4919 goto err_sessionid;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004920
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004921 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004922 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004923 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004924 }
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004925 for (i = 0; i < OWNER_HASH_SIZE; i++)
4926 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004927 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
4928 INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004929 for (i = 0; i < SESSION_HASH_SIZE; i++)
4930 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004931 nn->conf_name_tree = RB_ROOT;
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004932 nn->unconf_name_tree = RB_ROOT;
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004933 INIT_LIST_HEAD(&nn->client_lru);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03004934 INIT_LIST_HEAD(&nn->close_lru);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04004935 INIT_LIST_HEAD(&nn->del_recall_lru);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03004936 spin_lock_init(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004937
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004938 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004939 get_net(net);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004940
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004941 return 0;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004942
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004943err_sessionid:
4944 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004945err_lockowner_ino:
4946 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004947err_ownerstr:
4948 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004949err_unconf_id:
4950 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004951err:
4952 return -ENOMEM;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004953}
4954
4955static void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004956nfs4_state_destroy_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004957{
4958 int i;
4959 struct nfs4_client *clp = NULL;
4960 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004961 struct rb_node *node, *tmp;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004962
4963 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4964 while (!list_empty(&nn->conf_id_hashtbl[i])) {
4965 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4966 destroy_client(clp);
4967 }
4968 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004969
4970 node = rb_first(&nn->unconf_name_tree);
4971 while (node != NULL) {
4972 tmp = node;
4973 node = rb_next(tmp);
4974 clp = rb_entry(tmp, struct nfs4_client, cl_namenode);
4975 rb_erase(tmp, &nn->unconf_name_tree);
4976 destroy_client(clp);
4977 }
4978
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004979 kfree(nn->sessionid_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004980 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004981 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004982 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004983 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004984 put_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004985}
4986
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03004987int
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004988nfs4_state_start_net(struct net *net)
NeilBrownac4d8ff22005-06-23 22:03:30 -07004989{
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04004990 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004991 int ret;
4992
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004993 ret = nfs4_state_create_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004994 if (ret)
4995 return ret;
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04004996 nfsd4_client_tracking_init(net);
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004997 nn->boot_time = get_seconds();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004998 locks_start_grace(net, &nn->nfsd4_manager);
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04004999 nn->grace_ended = false;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005000 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03005001 nn->nfsd4_grace, net);
5002 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005003 return 0;
5004}
5005
5006/* initialization to perform when the nfsd service is started: */
5007
5008int
5009nfs4_state_start(void)
5010{
5011 int ret;
5012
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005013 ret = set_callback_cred();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005014 if (ret)
5015 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07005016 laundry_wq = create_singlethread_workqueue("nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05005017 if (laundry_wq == NULL) {
5018 ret = -ENOMEM;
5019 goto out_recovery;
5020 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005021 ret = nfsd4_create_callback_queue();
5022 if (ret)
5023 goto out_free_laundry;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03005024
Meelap Shahc2f1a552007-07-17 04:04:39 -07005025 set_max_delegations();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005026
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005027 return 0;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03005028
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005029out_free_laundry:
5030 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05005031out_recovery:
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05005032 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005033}
5034
Jeff Laytonac55fdc2012-11-12 15:00:56 -05005035/* should be called with the state lock held */
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03005036void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005037nfs4_state_shutdown_net(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005038{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005039 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005040 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005041 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005042
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005043 cancel_delayed_work_sync(&nn->laundromat_work);
5044 locks_end_grace(&nn->nfsd4_manager);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05005045
Linus Torvalds1da177e2005-04-16 15:20:36 -07005046 INIT_LIST_HEAD(&reaplist);
5047 spin_lock(&recall_lock);
J. Bruce Fieldse8c69d12013-03-21 15:19:33 -04005048 list_for_each_safe(pos, next, &nn->del_recall_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005049 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5050 list_move(&dp->dl_recall_lru, &reaplist);
5051 }
5052 spin_unlock(&recall_lock);
5053 list_for_each_safe(pos, next, &reaplist) {
5054 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
J. Bruce Fields3bd64a52013-04-09 17:02:51 -04005055 destroy_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005056 }
5057
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03005058 nfsd4_client_tracking_exit(net);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03005059 nfs4_state_destroy_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005060}
5061
5062void
5063nfs4_state_shutdown(void)
5064{
NeilBrown5e8d5c22006-04-10 22:55:37 -07005065 destroy_workqueue(laundry_wq);
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04005066 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005068
5069static void
5070get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5071{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005072 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
5073 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005074}
5075
5076static void
5077put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5078{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01005079 if (cstate->minorversion) {
5080 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
5081 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5082 }
5083}
5084
5085void
5086clear_current_stateid(struct nfsd4_compound_state *cstate)
5087{
5088 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005089}
5090
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005091/*
5092 * functions to set current state id
5093 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005094void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005095nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5096{
5097 put_stateid(cstate, &odp->od_stateid);
5098}
5099
5100void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005101nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5102{
5103 put_stateid(cstate, &open->op_stateid);
5104}
5105
5106void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005107nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5108{
5109 put_stateid(cstate, &close->cl_stateid);
5110}
5111
5112void
5113nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5114{
5115 put_stateid(cstate, &lock->lk_resp_stateid);
5116}
5117
5118/*
5119 * functions to consume current state id
5120 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005121
5122void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005123nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5124{
5125 get_stateid(cstate, &odp->od_stateid);
5126}
5127
5128void
5129nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5130{
5131 get_stateid(cstate, &drp->dr_stateid);
5132}
5133
5134void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005135nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5136{
5137 get_stateid(cstate, &fsp->fr_stateid);
5138}
5139
5140void
5141nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5142{
5143 get_stateid(cstate, &setattr->sa_stateid);
5144}
5145
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005146void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005147nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5148{
5149 get_stateid(cstate, &close->cl_stateid);
5150}
5151
5152void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005153nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005154{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005155 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005156}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01005157
5158void
5159nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5160{
5161 get_stateid(cstate, &read->rd_stateid);
5162}
5163
5164void
5165nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5166{
5167 get_stateid(cstate, &write->wr_stateid);
5168}