blob: a0ab6ad7239d885d69675d551d98cc390d0a1196 [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 Fields0a3adad2009-11-04 18:12:35 -050045#include "vfs.h"
J. Bruce Fieldsbfa4b362012-04-25 16:49:18 -040046#include "current_stateid.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +040048#include "netns.h"
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define NFSDDBG_FACILITY NFSDDBG_PROC
51
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050052#define all_ones {{~0,~0},~0}
53static const stateid_t one_stateid = {
54 .si_generation = ~0,
55 .si_opaque = all_ones,
56};
57static const stateid_t zero_stateid = {
58 /* all fields zero */
59};
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010060static const stateid_t currentstateid = {
61 .si_generation = 1,
62};
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050063
Andy Adamsonec6b5d72009-04-03 08:28:28 +030064static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070065
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050066#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
67#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010068#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070/* forward declarations */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040071static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
J. Bruce Fields8b671b82009-02-22 14:51:34 -080073/* Locking: */
74
75/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080076static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
J. Bruce Fields8b671b82009-02-22 14:51:34 -080078/*
79 * Currently used for the del_recall_lru and file hash table. In an
80 * effort to decrease the scope of the client_mutex, this spinlock may
81 * eventually cover more:
82 */
83static DEFINE_SPINLOCK(recall_lock);
84
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040085static struct kmem_cache *openowner_slab = NULL;
86static struct kmem_cache *lockowner_slab = NULL;
Christoph Lametere18b8902006-12-06 20:33:20 -080087static struct kmem_cache *file_slab = NULL;
88static struct kmem_cache *stateid_slab = NULL;
89static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091void
92nfs4_lock_state(void)
93{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080094 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095}
96
Benny Halevy508dc6e2012-02-23 17:40:52 -080097static void free_session(struct kref *);
98
99/* Must be called under the client_lock */
100static void nfsd4_put_session_locked(struct nfsd4_session *ses)
101{
102 kref_put(&ses->se_ref, free_session);
103}
104
105static void nfsd4_get_session(struct nfsd4_session *ses)
106{
107 kref_get(&ses->se_ref);
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110void
111nfs4_unlock_state(void)
112{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800113 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
116static inline u32
117opaque_hashval(const void *ptr, int nbytes)
118{
119 unsigned char *cptr = (unsigned char *) ptr;
120
121 u32 x = 0;
122 while (nbytes--) {
123 x *= 37;
124 x += *cptr++;
125 }
126 return x;
127}
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static struct list_head del_recall_lru;
130
J. Bruce Fields32513b42011-10-13 16:00:16 -0400131static void nfsd4_free_file(struct nfs4_file *f)
132{
133 kmem_cache_free(file_slab, f);
134}
135
NeilBrown13cd2182005-06-23 22:03:10 -0700136static inline void
137put_nfs4_file(struct nfs4_file *fi)
138{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800139 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
140 list_del(&fi->fi_hash);
141 spin_unlock(&recall_lock);
142 iput(fi->fi_inode);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400143 nfsd4_free_file(fi);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800144 }
NeilBrown13cd2182005-06-23 22:03:10 -0700145}
146
147static inline void
148get_nfs4_file(struct nfs4_file *fi)
149{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800150 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700151}
152
NeilBrownef0f3392006-04-10 22:55:41 -0700153static int num_delegations;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800154unsigned long max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700155
156/*
157 * Open owner state (share locks)
158 */
159
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500160/* hash tables for lock and open owners */
161#define OWNER_HASH_BITS 8
162#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
163#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700164
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500165static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400166{
167 unsigned int ret;
168
169 ret = opaque_hashval(ownername->data, ownername->len);
170 ret += clientid;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500171 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400172}
NeilBrownef0f3392006-04-10 22:55:41 -0700173
NeilBrownef0f3392006-04-10 22:55:41 -0700174/* hash table for nfs4_file */
175#define FILE_HASH_BITS 8
176#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800177
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400178static unsigned int file_hashval(struct inode *ino)
179{
180 /* XXX: why are we hashing on inode pointer, anyway? */
181 return hash_ptr(ino, FILE_HASH_BITS);
182}
183
NeilBrownef0f3392006-04-10 22:55:41 -0700184static struct list_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700185
J. Bruce Fields998db522010-08-07 09:21:41 -0400186static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400187{
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500188 WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400189 atomic_inc(&fp->fi_access[oflag]);
190}
191
J. Bruce Fields998db522010-08-07 09:21:41 -0400192static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
193{
194 if (oflag == O_RDWR) {
195 __nfs4_file_get_access(fp, O_RDONLY);
196 __nfs4_file_get_access(fp, O_WRONLY);
197 } else
198 __nfs4_file_get_access(fp, oflag);
199}
200
201static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400202{
203 if (fp->fi_fds[oflag]) {
204 fput(fp->fi_fds[oflag]);
205 fp->fi_fds[oflag] = NULL;
206 }
207}
208
J. Bruce Fields998db522010-08-07 09:21:41 -0400209static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400210{
211 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400212 nfs4_file_put_fd(fp, oflag);
J. Bruce Fields3d02fa22011-09-19 15:07:41 -0400213 /*
214 * It's also safe to get rid of the RDWR open *if*
215 * we no longer have need of the other kind of access
216 * or if we already have the other kind of open:
217 */
218 if (fp->fi_fds[1-oflag]
219 || atomic_read(&fp->fi_access[1 - oflag]) == 0)
220 nfs4_file_put_fd(fp, O_RDWR);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400221 }
222}
223
J. Bruce Fields998db522010-08-07 09:21:41 -0400224static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
225{
226 if (oflag == O_RDWR) {
227 __nfs4_file_put_access(fp, O_RDONLY);
228 __nfs4_file_put_access(fp, O_WRONLY);
229 } else
230 __nfs4_file_put_access(fp, oflag);
231}
232
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500233static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
234kmem_cache *slab)
J. Bruce Fields996e0932011-10-17 11:14:48 -0400235{
236 struct idr *stateids = &cl->cl_stateids;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500237 static int min_stateid = 0;
238 struct nfs4_stid *stid;
239 int new_id;
240
241 stid = kmem_cache_alloc(slab, GFP_KERNEL);
242 if (!stid)
243 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400244
Tejun Heoebd6c702013-03-13 14:59:37 -0700245 new_id = idr_alloc(stateids, stid, min_stateid, 0, GFP_KERNEL);
246 if (new_id < 0)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500247 goto out_free;
248 stid->sc_client = cl;
249 stid->sc_type = 0;
250 stid->sc_stateid.si_opaque.so_id = new_id;
251 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
252 /* Will be incremented before return to client: */
253 stid->sc_stateid.si_generation = 0;
254
J. Bruce Fields996e0932011-10-17 11:14:48 -0400255 /*
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500256 * It shouldn't be a problem to reuse an opaque stateid value.
257 * I don't think it is for 4.1. But with 4.0 I worry that, for
258 * example, a stray write retransmission could be accepted by
259 * the server when it should have been rejected. Therefore,
260 * adopt a trick from the sctp code to attempt to maximize the
261 * amount of time until an id is reused, by ensuring they always
262 * "increase" (mod INT_MAX):
J. Bruce Fields996e0932011-10-17 11:14:48 -0400263 */
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500264
265 min_stateid = new_id+1;
266 if (min_stateid == INT_MAX)
267 min_stateid = 0;
268 return stid;
269out_free:
270 kfree(stid);
271 return NULL;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400272}
273
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400274static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
275{
276 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
277}
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279static struct nfs4_delegation *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400280alloc_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 -0700281{
282 struct nfs4_delegation *dp;
283 struct nfs4_file *fp = stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 dprintk("NFSD alloc_init_deleg\n");
J. Bruce Fieldsc3e48082010-07-28 10:08:57 -0400286 /*
287 * Major work on the lease subsystem (for example, to support
288 * calbacks on stat) will be required before we can support
289 * write delegations properly.
290 */
291 if (type != NFS4_OPEN_DELEGATE_READ)
292 return NULL;
Meelap Shah47f99402007-07-17 04:04:40 -0700293 if (fp->fi_had_conflict)
294 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700295 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700296 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400297 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700298 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return dp;
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500300 dp->dl_stid.sc_type = NFS4_DELEG_STID;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400301 /*
302 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400303 * meaning of seqid 0 isn't meaningful, really, but let's avoid
304 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400305 */
306 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownef0f3392006-04-10 22:55:41 -0700307 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700308 INIT_LIST_HEAD(&dp->dl_perfile);
309 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 INIT_LIST_HEAD(&dp->dl_recall_lru);
NeilBrown13cd2182005-06-23 22:03:10 -0700311 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 dp->dl_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 dp->dl_type = type;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500314 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 dp->dl_time = 0;
316 atomic_set(&dp->dl_count, 1);
J. Bruce Fields57725152012-11-05 15:10:26 -0500317 nfsd4_init_callback(&dp->dl_recall);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 return dp;
319}
320
Fengguang Wue56a3162013-02-11 16:21:42 -0500321static void free_stid(struct nfs4_stid *s, struct kmem_cache *slab)
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500322{
323 struct idr *stateids = &s->sc_client->cl_stateids;
324
325 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
326 kmem_cache_free(slab, s);
327}
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329void
330nfs4_put_delegation(struct nfs4_delegation *dp)
331{
332 if (atomic_dec_and_test(&dp->dl_count)) {
333 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700334 put_nfs4_file(dp->dl_file);
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500335 free_stid(&dp->dl_stid, deleg_slab);
NeilBrownef0f3392006-04-10 22:55:41 -0700336 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
338}
339
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500340static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500342 if (atomic_dec_and_test(&fp->fi_delegees)) {
343 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
344 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400345 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500346 fp->fi_deleg_file = NULL;
347 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400350static void unhash_stid(struct nfs4_stid *s)
351{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500352 s->sc_type = 0;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400353}
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355/* Called under the state lock. */
356static void
357unhash_delegation(struct nfs4_delegation *dp)
358{
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400359 unhash_stid(&dp->dl_stid);
NeilBrownea1da632005-06-23 22:04:17 -0700360 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500362 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 list_del_init(&dp->dl_recall_lru);
364 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500365 nfs4_put_deleg_lease(dp->dl_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 nfs4_put_delegation(dp);
367}
368
369/*
370 * SETCLIENTID state
371 */
372
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400373static unsigned int clientid_hashval(u32 id)
374{
375 return id & CLIENT_HASH_MASK;
376}
377
378static unsigned int clientstr_hashval(const char *name)
379{
380 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
381}
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383/*
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400384 * We store the NONE, READ, WRITE, and BOTH bits separately in the
385 * st_{access,deny}_bmap field of the stateid, in order to track not
386 * only what share bits are currently in force, but also what
387 * combinations of share bits previous opens have used. This allows us
388 * to enforce the recommendation of rfc 3530 14.2.19 that the server
389 * return an error if the client attempt to downgrade to a combination
390 * of share bits not explicable by closing some of its previous opens.
391 *
392 * XXX: This enforcement is actually incomplete, since we don't keep
393 * track of access/deny bit combinations; so, e.g., we allow:
394 *
395 * OPEN allow read, deny write
396 * OPEN allow both, deny none
397 * DOWNGRADE allow read, deny none
398 *
399 * which we should reject.
400 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400401static unsigned int
402bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400403 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400404 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400405
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400406 for (i = 1; i < 4; i++) {
407 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400408 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400409 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400410 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400411}
412
Jeff Layton3a328612012-05-11 09:45:12 -0400413static bool
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400414test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400415 unsigned int access, deny;
416
Jeff Layton5ae037e2012-05-11 09:45:11 -0400417 access = bmap_to_share_mode(stp->st_access_bmap);
418 deny = bmap_to_share_mode(stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400419 if ((access & open->op_share_deny) || (deny & open->op_share_access))
Jeff Layton3a328612012-05-11 09:45:12 -0400420 return false;
421 return true;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400422}
423
Jeff Layton82c5ff12012-05-11 09:45:13 -0400424/* set share access for a given stateid */
425static inline void
426set_access(u32 access, struct nfs4_ol_stateid *stp)
427{
428 __set_bit(access, &stp->st_access_bmap);
429}
430
431/* clear share access for a given stateid */
432static inline void
433clear_access(u32 access, struct nfs4_ol_stateid *stp)
434{
435 __clear_bit(access, &stp->st_access_bmap);
436}
437
438/* test whether a given stateid has access */
439static inline bool
440test_access(u32 access, struct nfs4_ol_stateid *stp)
441{
442 return test_bit(access, &stp->st_access_bmap);
443}
444
Jeff Laytonce0fc432012-05-11 09:45:14 -0400445/* set share deny for a given stateid */
446static inline void
447set_deny(u32 access, struct nfs4_ol_stateid *stp)
448{
449 __set_bit(access, &stp->st_deny_bmap);
450}
451
452/* clear share deny for a given stateid */
453static inline void
454clear_deny(u32 access, struct nfs4_ol_stateid *stp)
455{
456 __clear_bit(access, &stp->st_deny_bmap);
457}
458
459/* test whether a given stateid is denying specific access */
460static inline bool
461test_deny(u32 access, struct nfs4_ol_stateid *stp)
462{
463 return test_bit(access, &stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400464}
465
466static int nfs4_access_to_omode(u32 access)
467{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400468 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400469 case NFS4_SHARE_ACCESS_READ:
470 return O_RDONLY;
471 case NFS4_SHARE_ACCESS_WRITE:
472 return O_WRONLY;
473 case NFS4_SHARE_ACCESS_BOTH:
474 return O_RDWR;
475 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -0500476 WARN_ON_ONCE(1);
477 return O_RDONLY;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400478}
479
Jeff Layton82c5ff12012-05-11 09:45:13 -0400480/* release all access and file references for a given stateid */
481static void
482release_all_access(struct nfs4_ol_stateid *stp)
483{
484 int i;
485
486 for (i = 1; i < 4; i++) {
487 if (test_access(i, stp))
488 nfs4_file_put_access(stp->st_file,
489 nfs4_access_to_omode(i));
490 clear_access(i, stp);
491 }
492}
493
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400494static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500495{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500496 list_del(&stp->st_perfile);
497 list_del(&stp->st_perstateowner);
498}
499
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400500static void close_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500501{
Jeff Layton82c5ff12012-05-11 09:45:13 -0400502 release_all_access(stp);
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400503 put_nfs4_file(stp->st_file);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400504 stp->st_file = NULL;
505}
506
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400507static void free_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400508{
J. Bruce Fields3abdb602013-02-03 12:23:01 -0500509 free_stid(&stp->st_stid, stateid_slab);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500510}
511
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400512static void release_lock_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500513{
514 struct file *file;
515
516 unhash_generic_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400517 unhash_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500518 file = find_any_file(stp->st_file);
519 if (file)
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400520 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400521 close_generic_stateid(stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500522 free_generic_stateid(stp);
523}
524
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400525static void unhash_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500526{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400527 struct nfs4_ol_stateid *stp;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500528
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400529 list_del(&lo->lo_owner.so_strhash);
530 list_del(&lo->lo_perstateid);
J. Bruce Fields009673b2011-11-07 17:40:10 -0500531 list_del(&lo->lo_owner_ino_hash);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400532 while (!list_empty(&lo->lo_owner.so_stateids)) {
533 stp = list_first_entry(&lo->lo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400534 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500535 release_lock_stateid(stp);
536 }
537}
538
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400539static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500540{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400541 unhash_lockowner(lo);
542 nfs4_free_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500543}
544
545static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400546release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500547{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400548 struct nfs4_lockowner *lo;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500549
550 while (!list_empty(&open_stp->st_lockowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400551 lo = list_entry(open_stp->st_lockowners.next,
552 struct nfs4_lockowner, lo_perstateid);
553 release_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500554 }
555}
556
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400557static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields22839632009-01-11 14:27:17 -0500558{
559 unhash_generic_stateid(stp);
560 release_stateid_lockowners(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400561 close_generic_stateid(stp);
562}
563
564static void release_open_stateid(struct nfs4_ol_stateid *stp)
565{
566 unhash_open_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400567 unhash_stid(&stp->st_stid);
J. Bruce Fields22839632009-01-11 14:27:17 -0500568 free_generic_stateid(stp);
569}
570
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400571static void unhash_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500572{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400573 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500574
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400575 list_del(&oo->oo_owner.so_strhash);
576 list_del(&oo->oo_perclient);
577 while (!list_empty(&oo->oo_owner.so_stateids)) {
578 stp = list_first_entry(&oo->oo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400579 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500580 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500581 }
582}
583
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400584static void release_last_closed_stateid(struct nfs4_openowner *oo)
585{
586 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
587
588 if (s) {
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400589 unhash_stid(&s->st_stid);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400590 free_generic_stateid(s);
591 oo->oo_last_closed_stid = NULL;
592 }
593}
594
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400595static void release_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500596{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400597 unhash_openowner(oo);
598 list_del(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400599 release_last_closed_stateid(oo);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400600 nfs4_free_openowner(oo);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500601}
602
Marc Eshel5282fd72009-04-03 08:27:52 +0300603static inline int
604hash_sessionid(struct nfs4_sessionid *sessionid)
605{
606 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
607
608 return sid->sequence % SESSION_HASH_SIZE;
609}
610
Trond Myklebust8f199b82012-03-20 15:11:17 -0400611#ifdef NFSD_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +0300612static inline void
613dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
614{
615 u32 *ptr = (u32 *)(&sessionid->data[0]);
616 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
617}
Trond Myklebust8f199b82012-03-20 15:11:17 -0400618#else
619static inline void
620dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
621{
622}
623#endif
624
Marc Eshel5282fd72009-04-03 08:27:52 +0300625
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300626static void
627gen_sessionid(struct nfsd4_session *ses)
628{
629 struct nfs4_client *clp = ses->se_client;
630 struct nfsd4_sessionid *sid;
631
632 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
633 sid->clientid = clp->cl_clientid;
634 sid->sequence = current_sessionid++;
635 sid->reserved = 0;
636}
637
638/*
Andy Adamsona6496372009-08-28 08:45:01 -0400639 * The protocol defines ca_maxresponssize_cached to include the size of
640 * the rpc header, but all we need to cache is the data starting after
641 * the end of the initial SEQUENCE operation--the rest we regenerate
642 * each time. Therefore we can advertise a ca_maxresponssize_cached
643 * value that is the number of bytes in our cache plus a few additional
644 * bytes. In order to stay on the safe side, and not promise more than
645 * we can cache, those additional bytes must be the minimum possible: 24
646 * bytes of rpc header (xid through accept state, with AUTH_NULL
647 * verifier), 12 for the compound header (with zero-length tag), and 44
648 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300649 */
Andy Adamsona6496372009-08-28 08:45:01 -0400650#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
651
Andy Adamson557ce262009-08-28 08:45:04 -0400652static void
653free_session_slots(struct nfsd4_session *ses)
654{
655 int i;
656
657 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
658 kfree(ses->se_slots[i]);
659}
660
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400661/*
662 * We don't actually need to cache the rpc and session headers, so we
663 * can allocate a little less for each slot:
664 */
665static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
666{
667 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
668}
669
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400670static int nfsd4_sanitize_slot_size(u32 size)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300671{
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400672 size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
673 size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300674
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400675 return size;
676}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300677
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400678/*
679 * XXX: If we run out of reserved DRC memory we could (up to a point)
680 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800681 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400682 */
683static int nfsd4_get_drc_mem(int slotsize, u32 num)
684{
685 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300686
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400687 num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
Andy Adamson557ce262009-08-28 08:45:04 -0400688
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400689 spin_lock(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800690 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
691 nfsd_drc_max_mem - nfsd_drc_mem_used);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400692 num = min_t(int, num, avail / slotsize);
693 nfsd_drc_mem_used += num * slotsize;
694 spin_unlock(&nfsd_drc_lock);
695
696 return num;
697}
698
699static void nfsd4_put_drc_mem(int slotsize, int num)
700{
701 spin_lock(&nfsd_drc_lock);
702 nfsd_drc_mem_used -= slotsize * num;
703 spin_unlock(&nfsd_drc_lock);
704}
705
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400706static struct nfsd4_session *__alloc_session(int slotsize, int numslots)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400707{
708 struct nfsd4_session *new;
709 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300710
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400711 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400712 + sizeof(struct nfsd4_session) > PAGE_SIZE);
713 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400714
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400715 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300716 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400717 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400718 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400719 for (i = 0; i < numslots; i++) {
720 mem = sizeof(struct nfsd4_slot) + slotsize;
721 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
722 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400723 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400724 }
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400725 return new;
726out_free:
727 while (i--)
728 kfree(new->se_slots[i]);
729 kfree(new);
730 return NULL;
731}
732
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300733static void init_forechannel_attrs(struct nfsd4_channel_attrs *new,
734 struct nfsd4_channel_attrs *req,
735 int numslots, int slotsize,
736 struct nfsd_net *nn)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400737{
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300738 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400739
740 new->maxreqs = numslots;
Mi Jinlongd2b21742011-03-10 17:43:37 +0800741 new->maxresp_cached = min_t(u32, req->maxresp_cached,
742 slotsize + NFSD_MIN_HDR_SEQ_SZ);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400743 new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
744 new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
745 new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
746}
747
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400748static void free_conn(struct nfsd4_conn *c)
749{
750 svc_xprt_put(c->cn_xprt);
751 kfree(c);
752}
753
754static void nfsd4_conn_lost(struct svc_xpt_user *u)
755{
756 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
757 struct nfs4_client *clp = c->cn_session->se_client;
758
759 spin_lock(&clp->cl_lock);
760 if (!list_empty(&c->cn_persession)) {
761 list_del(&c->cn_persession);
762 free_conn(c);
763 }
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500764 nfsd4_probe_callback(clp);
J. Bruce Fields2e4b7232013-03-08 09:30:43 -0500765 spin_unlock(&clp->cl_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400766}
767
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400768static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400769{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400770 struct nfsd4_conn *conn;
771
772 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
773 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400774 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400775 svc_xprt_get(rqstp->rq_xprt);
776 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400777 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400778 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
779 return conn;
780}
781
J. Bruce Fields328ead22010-09-29 16:11:06 -0400782static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
783{
784 conn->cn_session = ses;
785 list_add(&conn->cn_persession, &ses->se_conns);
786}
787
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400788static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
789{
790 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400791
792 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400793 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400794 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400795}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400796
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400797static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400798{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400799 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400800 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400801}
802
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400803static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400804{
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400805 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400806
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400807 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400808 ret = nfsd4_register_conn(conn);
809 if (ret)
810 /* oops; xprt is already down: */
811 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fields6a3b1562012-09-12 09:59:17 -0400812 if (conn->cn_flags & NFS4_CDFC4_BACK) {
Weston Andros Adamson24119672012-05-24 15:42:17 -0400813 /* callback channel may be back up */
814 nfsd4_probe_callback(ses->se_client);
815 }
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400816}
817
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400818static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400819{
820 u32 dir = NFS4_CDFC4_FORE;
821
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400822 if (cses->flags & SESSION4_BACK_CHAN)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400823 dir |= NFS4_CDFC4_BACK;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -0400824 return alloc_conn(rqstp, dir);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400825}
826
827/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400828static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400829{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400830 struct nfs4_client *clp = s->se_client;
831 struct nfsd4_conn *c;
832
833 spin_lock(&clp->cl_lock);
834 while (!list_empty(&s->se_conns)) {
835 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
836 list_del_init(&c->cn_persession);
837 spin_unlock(&clp->cl_lock);
838
839 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
840 free_conn(c);
841
842 spin_lock(&clp->cl_lock);
843 }
844 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400845}
846
J. Bruce Fields1377b692012-09-11 21:42:40 -0400847static void __free_session(struct nfsd4_session *ses)
848{
849 nfsd4_put_drc_mem(slot_bytes(&ses->se_fchannel), ses->se_fchannel.maxreqs);
850 free_session_slots(ses);
851 kfree(ses);
852}
853
Benny Halevy508dc6e2012-02-23 17:40:52 -0800854static void free_session(struct kref *kref)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400855{
856 struct nfsd4_session *ses;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300857 struct nfsd_net *nn;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400858
859 ses = container_of(kref, struct nfsd4_session, se_ref);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300860 nn = net_generic(ses->se_client->net, nfsd_net_id);
861
862 lockdep_assert_held(&nn->client_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400863 nfsd4_del_conns(ses);
J. Bruce Fields1377b692012-09-11 21:42:40 -0400864 __free_session(ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400865}
866
J. Bruce Fieldsb0a9d3a2013-03-07 17:26:18 -0500867static void nfsd4_put_session(struct nfsd4_session *ses)
Benny Halevy508dc6e2012-02-23 17:40:52 -0800868{
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300869 struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
870
871 spin_lock(&nn->client_lock);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800872 nfsd4_put_session_locked(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300873 spin_unlock(&nn->client_lock);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800874}
875
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300876static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fchan,
877 struct nfsd_net *nn)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400878{
879 struct nfsd4_session *new;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400880 int numslots, slotsize;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400881 /*
882 * Note decreasing slot size below client's request may
883 * make it difficult for client to function correctly, whereas
884 * decreasing the number of slots will (just?) affect
885 * performance. When short on memory we therefore prefer to
886 * decrease number of slots instead of their size.
887 */
888 slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
889 numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
Mi Jinlongced6dfe2010-11-11 18:03:50 +0800890 if (numslots < 1)
891 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400892
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400893 new = __alloc_session(slotsize, numslots);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400894 if (!new) {
Yanchuan Nian74b70dd2012-12-24 18:11:27 +0800895 nfsd4_put_drc_mem(slotsize, numslots);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400896 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400897 }
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300898 init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize, nn);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400899 return new;
900}
Andy Adamson557ce262009-08-28 08:45:04 -0400901
Fengguang Wu135ae822012-11-10 07:20:25 -0500902static 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 -0400903{
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400904 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300905 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldsa827bcb2012-09-12 09:51:34 -0400906
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300907 new->se_client = clp;
908 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300909
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400910 INIT_LIST_HEAD(&new->se_conns);
911
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400912 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300913 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400914 new->se_cb_prog = cses->callback_prog;
J. Bruce Fieldsc6bb3ca2012-11-01 16:31:02 -0400915 new->se_cb_sec = cses->cb_sec;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300916 kref_init(&new->se_ref);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400917 idx = hash_sessionid(&new->se_sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300918 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300919 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400920 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300921 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400922 spin_unlock(&clp->cl_lock);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300923 spin_unlock(&nn->client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300924
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400925 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400926 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400927 /*
928 * This is a little silly; with sessions there's no real
929 * use for the callback address. Use the peer address
930 * as a reasonable default for now, but consider fixing
931 * the rpc client not to require an address in the
932 * future:
933 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400934 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
935 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400936 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300937}
938
Benny Halevy9089f1b2010-05-12 00:12:26 +0300939/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +0300940static struct nfsd4_session *
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300941find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
Marc Eshel5282fd72009-04-03 08:27:52 +0300942{
943 struct nfsd4_session *elem;
944 int idx;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300945 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Marc Eshel5282fd72009-04-03 08:27:52 +0300946
947 dump_sessionid(__func__, sessionid);
948 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +0300949 /* Search in the appropriate list */
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +0300950 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +0300951 if (!memcmp(elem->se_sessionid.data, sessionid->data,
952 NFS4_MAX_SESSIONID_LEN)) {
953 return elem;
954 }
955 }
956
957 dprintk("%s: session not found\n", __func__);
958 return NULL;
959}
960
Benny Halevy9089f1b2010-05-12 00:12:26 +0300961/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +0300962static void
Marc Eshel5282fd72009-04-03 08:27:52 +0300963unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +0300964{
965 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400966 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +0300967 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400968 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +0300969}
970
Benny Halevy36acb662010-05-12 00:13:04 +0300971/* must be called under the client_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972static inline void
Benny Halevy36acb662010-05-12 00:13:04 +0300973renew_client_locked(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974{
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +0300975 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
976
Benny Halevy07cd4902010-05-12 00:13:41 +0300977 if (is_client_expired(clp)) {
J. Bruce Fields74477582012-05-04 14:57:52 -0400978 WARN_ON(1);
979 printk("%s: client (clientid %08x/%08x) already expired\n",
Benny Halevy07cd4902010-05-12 00:13:41 +0300980 __func__,
981 clp->cl_clientid.cl_boot,
982 clp->cl_clientid.cl_id);
983 return;
984 }
985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 dprintk("renewing client (clientid %08x/%08x)\n",
987 clp->cl_clientid.cl_boot,
988 clp->cl_clientid.cl_id);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +0300989 list_move_tail(&clp->cl_lru, &nn->client_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 clp->cl_time = get_seconds();
991}
992
Benny Halevy36acb662010-05-12 00:13:04 +0300993static inline void
994renew_client(struct nfs4_client *clp)
995{
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +0300996 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
997
998 spin_lock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +0300999 renew_client_locked(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001000 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03001001}
1002
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1004static int
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001005STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001007 if (clid->cl_boot == nn->boot_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001009 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001010 clid->cl_boot, clid->cl_id, nn->boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return 1;
1012}
1013
1014/*
1015 * XXX Should we use a slab cache ?
1016 * This type of memory management is somewhat inefficient, but we use it
1017 * anyway since SETCLIENTID is not a common operation.
1018 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001019static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020{
1021 struct nfs4_client *clp;
1022
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001023 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1024 if (clp == NULL)
1025 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001026 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001027 if (clp->cl_name.data == NULL) {
1028 kfree(clp);
1029 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001031 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 return clp;
1033}
1034
1035static inline void
1036free_client(struct nfs4_client *clp)
1037{
Stanislav Kinsburskybca0ec62013-01-09 12:38:34 +03001038 struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001039
1040 lockdep_assert_held(&nn->client_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001041 while (!list_empty(&clp->cl_sessions)) {
1042 struct nfsd4_session *ses;
1043 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1044 se_perclnt);
1045 list_del(&ses->se_perclnt);
Benny Halevy508dc6e2012-02-23 17:40:52 -08001046 nfsd4_put_session_locked(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001047 }
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001048 free_svc_cred(&clp->cl_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 kfree(clp->cl_name.data);
majianpeng2d32b292013-01-29 13:16:06 +08001050 idr_destroy(&clp->cl_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 kfree(clp);
1052}
1053
Benny Halevyd7682982010-05-12 00:13:54 +03001054void
1055release_session_client(struct nfsd4_session *session)
1056{
1057 struct nfs4_client *clp = session->se_client;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001058 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Benny Halevyd7682982010-05-12 00:13:54 +03001059
J. Bruce Fieldsb0a9d3a2013-03-07 17:26:18 -05001060 nfsd4_put_session(session);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001061 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
Benny Halevyd7682982010-05-12 00:13:54 +03001062 return;
J. Bruce Fieldsb0a9d3a2013-03-07 17:26:18 -05001063 /*
1064 * At this point we also know all sessions have refcnt 1,
1065 * so free_client will delete them all if necessary:
1066 */
1067 if (is_client_expired(clp))
Benny Halevyd7682982010-05-12 00:13:54 +03001068 free_client(clp);
J. Bruce Fieldsb0a9d3a2013-03-07 17:26:18 -05001069 else
Benny Halevyd7682982010-05-12 00:13:54 +03001070 renew_client_locked(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001071 spin_unlock(&nn->client_lock);
Benny Halevyd7682982010-05-12 00:13:54 +03001072}
1073
Benny Halevy84d38ac2010-05-12 00:13:16 +03001074/* must be called under the client_lock */
1075static inline void
1076unhash_client_locked(struct nfs4_client *clp)
1077{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001078 struct nfsd4_session *ses;
1079
Benny Halevy07cd4902010-05-12 00:13:41 +03001080 mark_client_expired(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001081 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001082 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001083 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1084 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001085 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001086}
1087
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088static void
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001089destroy_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001091 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 struct list_head reaplist;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001094 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 INIT_LIST_HEAD(&reaplist);
1097 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001098 while (!list_empty(&clp->cl_delegations)) {
1099 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -07001100 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 list_move(&dp->dl_recall_lru, &reaplist);
1102 }
1103 spin_unlock(&recall_lock);
1104 while (!list_empty(&reaplist)) {
1105 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 unhash_delegation(dp);
1107 }
NeilBrownea1da632005-06-23 22:04:17 -07001108 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001109 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1110 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001112 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001113 if (clp->cl_cb_conn.cb_xprt)
1114 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001115 list_del(&clp->cl_idhash);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001116 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001117 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001118 else
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001119 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001120 spin_lock(&nn->client_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001121 unhash_client_locked(clp);
Benny Halevy46583e22010-05-12 00:13:29 +03001122 if (atomic_read(&clp->cl_refcount) == 0)
1123 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001124 spin_unlock(&nn->client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125}
1126
J. Bruce Fields0d22f682012-09-26 11:36:16 -04001127static void expire_client(struct nfs4_client *clp)
1128{
1129 nfsd4_client_record_remove(clp);
1130 destroy_client(clp);
1131}
1132
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001133static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1134{
1135 memcpy(target->cl_verifier.data, source->data,
1136 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137}
1138
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001139static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1140{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1142 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1143}
1144
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001145static int copy_cred(struct svc_cred *target, struct svc_cred *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001146{
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001147 if (source->cr_principal) {
1148 target->cr_principal =
1149 kstrdup(source->cr_principal, GFP_KERNEL);
1150 if (target->cr_principal == NULL)
1151 return -ENOMEM;
1152 } else
1153 target->cr_principal = NULL;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001154 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 target->cr_uid = source->cr_uid;
1156 target->cr_gid = source->cr_gid;
1157 target->cr_group_info = source->cr_group_info;
1158 get_group_info(target->cr_group_info);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001159 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160}
1161
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001162static long long
1163compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1164{
1165 long long res;
1166
1167 res = o1->len - o2->len;
1168 if (res)
1169 return res;
1170 return (long long)memcmp(o1->data, o2->data, o1->len);
1171}
1172
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001173static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001174{
NeilBrowna55370a2005-06-23 22:03:52 -07001175 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176}
1177
1178static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001179same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1180{
1181 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
1184static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001185same_clid(clientid_t *cl1, clientid_t *cl2)
1186{
1187 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001190static bool groups_equal(struct group_info *g1, struct group_info *g2)
1191{
1192 int i;
1193
1194 if (g1->ngroups != g2->ngroups)
1195 return false;
1196 for (i=0; i<g1->ngroups; i++)
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001197 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001198 return false;
1199 return true;
1200}
1201
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001202/*
1203 * RFC 3530 language requires clid_inuse be returned when the
1204 * "principal" associated with a requests differs from that previously
1205 * used. We use uid, gid's, and gss principal string as our best
1206 * approximation. We also don't want to allow non-gss use of a client
1207 * established using gss: in theory cr_principal should catch that
1208 * change, but in practice cr_principal can be null even in the gss case
1209 * since gssd doesn't always pass down a principal string.
1210 */
1211static bool is_gss_cred(struct svc_cred *cr)
1212{
1213 /* Is cr_flavor one of the gss "pseudoflavors"?: */
1214 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1215}
1216
1217
Vivek Trivedi5559b502012-07-24 21:18:20 +05301218static bool
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001219same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1220{
J. Bruce Fields68eb3502012-08-21 12:48:30 -04001221 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
Eric W. Biederman6fab8772013-02-02 06:53:11 -08001222 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1223 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001224 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1225 return false;
1226 if (cr1->cr_principal == cr2->cr_principal)
1227 return true;
1228 if (!cr1->cr_principal || !cr2->cr_principal)
1229 return false;
Vivek Trivedi5559b502012-07-24 21:18:20 +05301230 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}
1232
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001233static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001234{
1235 static u32 current_clientid = 1;
1236
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04001237 clp->cl_clientid.cl_boot = nn->boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 clp->cl_clientid.cl_id = current_clientid++;
1239}
1240
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001241static void gen_confirm(struct nfs4_client *clp)
1242{
Chuck Leverab4684d2012-03-02 17:13:50 -05001243 __be32 verf[2];
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001244 static u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Chuck Leverab4684d2012-03-02 17:13:50 -05001246 verf[0] = (__be32)get_seconds();
1247 verf[1] = (__be32)i++;
1248 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249}
1250
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001251static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
J. Bruce Fields4581d142011-09-06 14:56:09 -04001252{
J. Bruce Fields3abdb602013-02-03 12:23:01 -05001253 struct nfs4_stid *ret;
1254
1255 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1256 if (!ret || !ret->sc_type)
1257 return NULL;
1258 return ret;
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001259}
1260
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001261static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001262{
1263 struct nfs4_stid *s;
1264
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001265 s = find_stateid(cl, t);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001266 if (!s)
1267 return NULL;
1268 if (typemask & s->sc_type)
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001269 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04001270 return NULL;
1271}
1272
Jeff Layton2216d442012-11-12 15:00:57 -05001273static struct nfs4_client *create_client(struct xdr_netobj name,
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001274 struct svc_rqst *rqstp, nfs4_verifier *verf)
1275{
1276 struct nfs4_client *clp;
1277 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001278 int ret;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001279 struct net *net = SVC_NET(rqstp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001280 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001281
1282 clp = alloc_client(name);
1283 if (clp == NULL)
1284 return NULL;
1285
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001286 INIT_LIST_HEAD(&clp->cl_sessions);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001287 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1288 if (ret) {
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001289 spin_lock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001290 free_client(clp);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001291 spin_unlock(&nn->client_lock);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001292 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001293 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001294 idr_init(&clp->cl_stateids);
Benny Halevy46583e22010-05-12 00:13:29 +03001295 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001296 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001297 INIT_LIST_HEAD(&clp->cl_idhash);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001298 INIT_LIST_HEAD(&clp->cl_openowners);
1299 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001300 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001301 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001302 spin_lock_init(&clp->cl_lock);
J. Bruce Fields57725152012-11-05 15:10:26 -05001303 nfsd4_init_callback(&clp->cl_cb_null);
Benny Halevy07cd4902010-05-12 00:13:41 +03001304 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001305 clear_bit(0, &clp->cl_cb_slot_busy);
1306 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1307 copy_verf(clp, verf);
1308 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001309 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001310 clp->cl_cb_session = NULL;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001311 clp->net = net;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001312 return clp;
1313}
1314
NeilBrownfd39ca92005-06-23 22:04:03 -07001315static void
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001316add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1317{
1318 struct rb_node **new = &(root->rb_node), *parent = NULL;
1319 struct nfs4_client *clp;
1320
1321 while (*new) {
1322 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1323 parent = *new;
1324
1325 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1326 new = &((*new)->rb_left);
1327 else
1328 new = &((*new)->rb_right);
1329 }
1330
1331 rb_link_node(&new_clp->cl_namenode, parent, new);
1332 rb_insert_color(&new_clp->cl_namenode, root);
1333}
1334
1335static struct nfs4_client *
1336find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1337{
1338 long long cmp;
1339 struct rb_node *node = root->rb_node;
1340 struct nfs4_client *clp;
1341
1342 while (node) {
1343 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1344 cmp = compare_blob(&clp->cl_name, name);
1345 if (cmp > 0)
1346 node = node->rb_left;
1347 else if (cmp < 0)
1348 node = node->rb_right;
1349 else
1350 return clp;
1351 }
1352 return NULL;
1353}
1354
1355static void
1356add_to_unconfirmed(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357{
1358 unsigned int idhashval;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001359 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001361 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001362 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001364 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001365 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366}
1367
NeilBrownfd39ca92005-06-23 22:04:03 -07001368static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369move_to_confirmed(struct nfs4_client *clp)
1370{
1371 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001372 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
1374 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001375 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001376 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001377 add_clp_to_name_tree(clp, &nn->conf_name_tree);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001378 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 renew_client(clp);
1380}
1381
1382static struct nfs4_client *
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001383find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384{
1385 struct nfs4_client *clp;
1386 unsigned int idhashval = clientid_hashval(clid->cl_id);
1387
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001388 list_for_each_entry(clp, &nn->conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001389 if (same_clid(&clp->cl_clientid, clid)) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001390 if ((bool)clp->cl_minorversion != sessions)
1391 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001392 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 }
1396 return NULL;
1397}
1398
1399static struct nfs4_client *
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001400find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401{
1402 struct nfs4_client *clp;
1403 unsigned int idhashval = clientid_hashval(clid->cl_id);
1404
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001405 list_for_each_entry(clp, &nn->unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001406 if (same_clid(&clp->cl_clientid, clid)) {
1407 if ((bool)clp->cl_minorversion != sessions)
1408 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 return clp;
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04001410 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 }
1412 return NULL;
1413}
1414
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001415static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001416{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001417 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001418}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001419
NeilBrown28ce6052005-06-23 22:03:56 -07001420static struct nfs4_client *
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001421find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001422{
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001423 return find_clp_in_name_tree(name, &nn->conf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001424}
1425
1426static struct nfs4_client *
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001427find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
NeilBrown28ce6052005-06-23 22:03:56 -07001428{
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001429 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
NeilBrown28ce6052005-06-23 22:03:56 -07001430}
1431
NeilBrownfd39ca92005-06-23 22:04:03 -07001432static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001433gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001435 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001436 struct sockaddr *sa = svc_addr(rqstp);
1437 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001438 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439
Jeff Layton7077ecb2009-08-14 12:57:58 -04001440 /* Currently, we only support tcp and tcp6 for the callback channel */
1441 if (se->se_callback_netid_len == 3 &&
1442 !memcmp(se->se_callback_netid_val, "tcp", 3))
1443 expected_family = AF_INET;
1444 else if (se->se_callback_netid_len == 4 &&
1445 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1446 expected_family = AF_INET6;
1447 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 goto out_err;
1449
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001450 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001451 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001452 (struct sockaddr *)&conn->cb_addr,
1453 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001454
J. Bruce Fields07263f12010-05-31 19:09:40 -04001455 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001457
J. Bruce Fields07263f12010-05-31 19:09:40 -04001458 if (conn->cb_addr.ss_family == AF_INET6)
1459 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001460
J. Bruce Fields07263f12010-05-31 19:09:40 -04001461 conn->cb_prog = se->se_callback_prog;
1462 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08001463 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 return;
1465out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001466 conn->cb_addr.ss_family = AF_UNSPEC;
1467 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001468 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 "will not receive delegations\n",
1470 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1471
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 return;
1473}
1474
Andy Adamson074fe892009-04-03 08:28:15 +03001475/*
Andy Adamson557ce262009-08-28 08:45:04 -04001476 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001477 */
1478void
1479nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1480{
Andy Adamson557ce262009-08-28 08:45:04 -04001481 struct nfsd4_slot *slot = resp->cstate.slot;
1482 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001483
Andy Adamson557ce262009-08-28 08:45:04 -04001484 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001485
Andy Adamson557ce262009-08-28 08:45:04 -04001486 slot->sl_opcnt = resp->opcnt;
1487 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001488
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05001489 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001490 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001491 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001492 return;
1493 }
Andy Adamson557ce262009-08-28 08:45:04 -04001494 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1495 base = (char *)resp->cstate.datap -
1496 (char *)resp->xbuf->head[0].iov_base;
1497 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1498 slot->sl_datalen))
1499 WARN("%s: sessions DRC could not cache compound\n", __func__);
1500 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001501}
1502
1503/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001504 * Encode the replay sequence operation from the slot values.
1505 * If cachethis is FALSE encode the uncached rep error on the next
1506 * operation which sets resp->p and increments resp->opcnt for
1507 * nfs4svc_encode_compoundres.
1508 *
Andy Adamson074fe892009-04-03 08:28:15 +03001509 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001510static __be32
1511nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1512 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001513{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001514 struct nfsd4_op *op;
1515 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001516
Andy Adamsonabfabf82009-07-23 19:02:18 -04001517 /* Encode the replayed sequence operation */
1518 op = &args->ops[resp->opcnt - 1];
1519 nfsd4_encode_operation(resp, op);
1520
1521 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05001522 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001523 op = &args->ops[resp->opcnt++];
1524 op->status = nfserr_retry_uncached_rep;
1525 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001526 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001527 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001528}
1529
1530/*
Andy Adamson557ce262009-08-28 08:45:04 -04001531 * The sequence operation is not cached because we can use the slot and
1532 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001533 */
1534__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001535nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1536 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001537{
Andy Adamson557ce262009-08-28 08:45:04 -04001538 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001539 __be32 status;
1540
Andy Adamson557ce262009-08-28 08:45:04 -04001541 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001542
Andy Adamsonabfabf82009-07-23 19:02:18 -04001543 /* Either returns 0 or nfserr_retry_uncached */
1544 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1545 if (status == nfserr_retry_uncached_rep)
1546 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001547
Andy Adamson557ce262009-08-28 08:45:04 -04001548 /* The sequence operation has been encoded, cstate->datap set. */
1549 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001550
Andy Adamson557ce262009-08-28 08:45:04 -04001551 resp->opcnt = slot->sl_opcnt;
1552 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1553 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001554
1555 return status;
1556}
1557
Andy Adamson0733d212009-04-03 08:28:01 +03001558/*
1559 * Set the exchange_id flags returned by the server.
1560 */
1561static void
1562nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1563{
1564 /* pNFS is not supported */
1565 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1566
1567 /* Referrals are supported, Migration is not. */
1568 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1569
1570 /* set the wire flags to return to client. */
1571 clid->flags = new->cl_exchange_flags;
1572}
1573
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001574static bool client_has_state(struct nfs4_client *clp)
1575{
1576 /*
1577 * Note clp->cl_openowners check isn't quite right: there's no
1578 * need to count owners without stateid's.
1579 *
1580 * Also note we should probably be using this in 4.0 case too.
1581 */
J. Bruce Fields6eccece2012-05-29 16:37:44 -04001582 return !list_empty(&clp->cl_openowners)
1583 || !list_empty(&clp->cl_delegations)
1584 || !list_empty(&clp->cl_sessions);
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001585}
1586
Al Virob37ad282006-10-19 23:28:59 -07001587__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001588nfsd4_exchange_id(struct svc_rqst *rqstp,
1589 struct nfsd4_compound_state *cstate,
1590 struct nfsd4_exchange_id *exid)
1591{
Andy Adamson0733d212009-04-03 08:28:01 +03001592 struct nfs4_client *unconf, *conf, *new;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001593 __be32 status;
Jeff Layton363168b2009-08-14 12:57:56 -04001594 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001595 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001596 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001597 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001598 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamson0733d212009-04-03 08:28:01 +03001599
Jeff Layton363168b2009-08-14 12:57:56 -04001600 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001601 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001602 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001603 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001604 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001605
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04001606 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03001607 return nfserr_inval;
1608
1609 /* Currently only support SP4_NONE */
1610 switch (exid->spa_how) {
1611 case SP4_NONE:
1612 break;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05001613 default: /* checked by xdr code */
1614 WARN_ON_ONCE(1);
Andy Adamson0733d212009-04-03 08:28:01 +03001615 case SP4_SSV:
Andy Adamson0733d212009-04-03 08:28:01 +03001616 case SP4_MACH_CRED:
1617 return nfserr_serverfault; /* no excuse :-/ */
1618 }
1619
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001620 /* Cases below refer to rfc 5661 section 18.35.4: */
Andy Adamson0733d212009-04-03 08:28:01 +03001621 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001622 conf = find_confirmed_client_by_name(&exid->clname, nn);
Andy Adamson0733d212009-04-03 08:28:01 +03001623 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001624 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1625 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1626
J. Bruce Fields136e6582012-05-12 20:37:23 -04001627 if (update) {
1628 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001629 status = nfserr_inval;
Andy Adamson0733d212009-04-03 08:28:01 +03001630 goto out;
1631 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001632 if (!creds_match) { /* case 9 */
Andy Adamson0733d212009-04-03 08:28:01 +03001633 status = nfserr_perm;
1634 goto out;
1635 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001636 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03001637 status = nfserr_not_same;
1638 goto out;
1639 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001640 /* case 6 */
1641 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1642 new = conf;
1643 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03001644 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001645 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001646 if (client_has_state(conf)) {
1647 status = nfserr_clid_inuse;
1648 goto out;
1649 }
Andy Adamson0733d212009-04-03 08:28:01 +03001650 expire_client(conf);
1651 goto out_new;
1652 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001653 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04001654 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001655 new = conf;
1656 goto out_copy;
1657 }
1658 /* case 5, client reboot */
J. Bruce Fields136e6582012-05-12 20:37:23 -04001659 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001660 }
1661
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001662 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001663 status = nfserr_noent;
1664 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001665 }
1666
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03001667 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001668 if (unconf) /* case 4, possible retry or client restart */
Andy Adamson0733d212009-04-03 08:28:01 +03001669 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03001670
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001671 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03001672out_new:
Jeff Layton2216d442012-11-12 15:00:57 -05001673 new = create_client(exid->clname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001674 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001675 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001676 goto out;
1677 }
J. Bruce Fieldsc116a0a2012-09-11 14:53:09 -04001678 new->cl_minorversion = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001679
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03001680 gen_clid(new, nn);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05001681 add_to_unconfirmed(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001682out_copy:
1683 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1684 exid->clientid.cl_id = new->cl_clientid.cl_id;
1685
J. Bruce Fields778df3f2012-05-25 21:40:23 -04001686 exid->seqid = new->cl_cs_slot.sl_seqid + 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001687 nfsd4_set_ex_flags(new, exid);
1688
1689 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001690 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001691 status = nfs_ok;
1692
1693out:
1694 nfs4_unlock_state();
Andy Adamson0733d212009-04-03 08:28:01 +03001695 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001696}
1697
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001698static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04001699check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001700{
Andy Adamson88e588d2009-07-23 19:02:15 -04001701 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1702 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001703
1704 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001705 if (slot_inuse) {
1706 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001707 return nfserr_jukebox;
1708 else
1709 return nfserr_seq_misordered;
1710 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05001711 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04001712 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001713 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04001714 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001715 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001716 return nfserr_seq_misordered;
1717}
1718
Andy Adamson49557cc2009-07-23 19:02:16 -04001719/*
1720 * Cache the create session result into the create session single DRC
1721 * slot cache by saving the xdr structure. sl_seqid has been set.
1722 * Do this for solo or embedded create session operations.
1723 */
1724static void
1725nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001726 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04001727{
1728 slot->sl_status = nfserr;
1729 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1730}
1731
1732static __be32
1733nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1734 struct nfsd4_clid_slot *slot)
1735{
1736 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1737 return slot->sl_status;
1738}
1739
Mi Jinlong1b74c252011-07-14 14:50:17 +08001740#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1741 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1742 1 + /* MIN tag is length with zero, only length */ \
1743 3 + /* version, opcount, opcode */ \
1744 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1745 /* seqid, slotID, slotID, cache */ \
1746 4 ) * sizeof(__be32))
1747
1748#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1749 2 + /* verifier: AUTH_NULL, length 0 */\
1750 1 + /* status */ \
1751 1 + /* MIN tag is length with zero, only length */ \
1752 3 + /* opcount, opcode, opstatus*/ \
1753 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1754 /* seqid, slotID, slotID, slotID, status */ \
1755 5 ) * sizeof(__be32))
1756
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001757static bool check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
Mi Jinlong1b74c252011-07-14 14:50:17 +08001758{
1759 return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1760 || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1761}
1762
Andy Adamson069b6ad2009-04-03 08:27:58 +03001763__be32
1764nfsd4_create_session(struct svc_rqst *rqstp,
1765 struct nfsd4_compound_state *cstate,
1766 struct nfsd4_create_session *cr_ses)
1767{
Jeff Layton363168b2009-08-14 12:57:56 -04001768 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001769 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001770 struct nfsd4_session *new;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001771 struct nfsd4_conn *conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001772 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001773 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001774 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001775
Mi Jinlonga62573d2011-03-23 17:57:07 +08001776 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1777 return nfserr_inval;
J. Bruce Fields49730502012-09-11 15:33:21 -04001778 if (check_forechannel_attrs(cr_ses->fore_channel))
1779 return nfserr_toosmall;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +03001780 new = alloc_session(&cr_ses->fore_channel, nn);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001781 if (!new)
1782 return nfserr_jukebox;
1783 status = nfserr_jukebox;
1784 conn = alloc_conn_from_crses(rqstp, cr_ses);
1785 if (!conn)
1786 goto out_free_session;
Mi Jinlonga62573d2011-03-23 17:57:07 +08001787
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001788 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03001789 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03001790 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04001791 WARN_ON_ONCE(conf && unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001792
1793 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001794 cs_slot = &conf->cl_cs_slot;
1795 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001796 if (status == nfserr_replay_cache) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001797 status = nfsd4_replay_create_session(cr_ses, cs_slot);
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001798 goto out_free_conn;
Andy Adamson49557cc2009-07-23 19:02:16 -04001799 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001800 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001801 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001802 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001803 } else if (unconf) {
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001804 struct nfs4_client *old;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001805 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001806 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001807 status = nfserr_clid_inuse;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001808 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001809 }
Andy Adamson49557cc2009-07-23 19:02:16 -04001810 cs_slot = &unconf->cl_cs_slot;
1811 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001812 if (status) {
1813 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001814 status = nfserr_seq_misordered;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001815 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001816 }
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03001817 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields8f9d3d32012-09-12 14:41:31 -04001818 if (old)
1819 expire_client(old);
1820 move_to_confirmed(unconf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001821 conf = unconf;
1822 } else {
1823 status = nfserr_stale_clientid;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001824 goto out_free_conn;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001825 }
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001826 status = nfs_ok;
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001827 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001828 * We do not support RDMA or persistent sessions
1829 */
1830 cr_ses->flags &= ~SESSION4_PERSIST;
1831 cr_ses->flags &= ~SESSION4_RDMA;
1832
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001833 init_session(rqstp, new, conf, cr_ses);
1834 nfsd4_init_conn(rqstp, conn, new);
1835
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001836 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001837 NFS4_MAX_SESSIONID_LEN);
Mi Jinlong12050652010-11-11 18:03:40 +08001838 memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1839 sizeof(struct nfsd4_channel_attrs));
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001840 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001841 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001842
Andy Adamson49557cc2009-07-23 19:02:16 -04001843 /* cache solo and embedded create sessions under the state lock */
1844 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001845 nfs4_unlock_state();
Yanchuan Nian266533c2012-12-24 18:11:45 +08001846out:
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001847 dprintk("%s returns %d\n", __func__, ntohl(status));
1848 return status;
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001849out_free_conn:
Yanchuan Nian266533c2012-12-24 18:11:45 +08001850 nfs4_unlock_state();
J. Bruce Fields81f0b2a2012-09-12 11:04:33 -04001851 free_conn(conn);
1852out_free_session:
1853 __free_session(new);
1854 goto out;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001855}
1856
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001857static __be32 nfsd4_map_bcts_dir(u32 *dir)
1858{
1859 switch (*dir) {
1860 case NFS4_CDFC4_FORE:
1861 case NFS4_CDFC4_BACK:
1862 return nfs_ok;
1863 case NFS4_CDFC4_FORE_OR_BOTH:
1864 case NFS4_CDFC4_BACK_OR_BOTH:
1865 *dir = NFS4_CDFC4_BOTH;
1866 return nfs_ok;
1867 };
1868 return nfserr_inval;
1869}
1870
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001871__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
1872{
1873 struct nfsd4_session *session = cstate->session;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001874 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001875
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001876 spin_lock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001877 session->se_cb_prog = bc->bc_cb_program;
1878 session->se_cb_sec = bc->bc_cb_sec;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001879 spin_unlock(&nn->client_lock);
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04001880
1881 nfsd4_probe_callback(session->se_client);
1882
1883 return nfs_ok;
1884}
1885
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001886__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1887 struct nfsd4_compound_state *cstate,
1888 struct nfsd4_bind_conn_to_session *bcts)
1889{
1890 __be32 status;
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001891 struct nfsd4_conn *conn;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001892 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001893
1894 if (!nfsd4_last_compound_op(rqstp))
1895 return nfserr_not_only_op;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001896 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001897 cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001898 /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1899 * client_lock iself: */
1900 if (cstate->session) {
1901 nfsd4_get_session(cstate->session);
1902 atomic_inc(&cstate->session->se_client->cl_refcount);
1903 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001904 spin_unlock(&nn->client_lock);
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001905 if (!cstate->session)
1906 return nfserr_badsession;
1907
1908 status = nfsd4_map_bcts_dir(&bcts->dir);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001909 if (status)
1910 return status;
1911 conn = alloc_conn(rqstp, bcts->dir);
1912 if (!conn)
1913 return nfserr_jukebox;
J. Bruce Fieldse1ff3712012-09-11 17:10:25 -04001914 nfsd4_init_conn(rqstp, conn, cstate->session);
J. Bruce Fields3ba63672012-09-11 15:37:40 -04001915 return nfs_ok;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001916}
1917
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001918static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1919{
1920 if (!session)
1921 return 0;
1922 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1923}
1924
Andy Adamson069b6ad2009-04-03 08:27:58 +03001925__be32
1926nfsd4_destroy_session(struct svc_rqst *r,
1927 struct nfsd4_compound_state *cstate,
1928 struct nfsd4_destroy_session *sessionid)
1929{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001930 struct nfsd4_session *ses;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001931 __be32 status = nfserr_badsession;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001932 struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001933
1934 /* Notes:
1935 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1936 * - Should we return nfserr_back_chan_busy if waiting for
1937 * callbacks on to-be-destroyed session?
1938 * - Do we need to clear any callback info from previous session?
1939 */
1940
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001941 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04001942 if (!nfsd4_last_compound_op(r))
1943 return nfserr_not_only_op;
1944 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03001945 dump_sessionid(__func__, &sessionid->sessionid);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001946 spin_lock(&nn->client_lock);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03001947 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
Benny Halevye10e0cf2009-04-03 08:28:38 +03001948 if (!ses) {
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001949 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001950 goto out;
1951 }
1952
1953 unhash_session(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001954 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001955
Benny Halevyab707e152010-05-12 00:14:06 +03001956 nfs4_lock_state();
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05001957 nfsd4_probe_callback_sync(ses->se_client);
Benny Halevyab707e152010-05-12 00:14:06 +03001958 nfs4_unlock_state();
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001959
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001960 spin_lock(&nn->client_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001961 nfsd4_del_conns(ses);
Benny Halevy508dc6e2012-02-23 17:40:52 -08001962 nfsd4_put_session_locked(ses);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03001963 spin_unlock(&nn->client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001964 status = nfs_ok;
1965out:
1966 dprintk("%s returns %d\n", __func__, ntohl(status));
1967 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001968}
1969
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001970static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001971{
1972 struct nfsd4_conn *c;
1973
1974 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001975 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04001976 return c;
1977 }
1978 }
1979 return NULL;
1980}
1981
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001982static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001983{
1984 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001985 struct nfsd4_conn *c;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001986 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001987
1988 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001989 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001990 if (c) {
1991 spin_unlock(&clp->cl_lock);
1992 free_conn(new);
1993 return;
1994 }
1995 __nfsd4_hash_conn(new, ses);
1996 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001997 ret = nfsd4_register_conn(new);
1998 if (ret)
1999 /* oops; xprt is already down: */
2000 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields328ead22010-09-29 16:11:06 -04002001 return;
2002}
2003
Mi Jinlong868b89c2011-04-27 09:09:58 +08002004static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2005{
2006 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2007
2008 return args->opcnt > session->se_fchannel.maxops;
2009}
2010
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002011static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2012 struct nfsd4_session *session)
2013{
2014 struct xdr_buf *xb = &rqstp->rq_arg;
2015
2016 return xb->len > session->se_fchannel.maxreq_sz;
2017}
2018
Andy Adamson069b6ad2009-04-03 08:27:58 +03002019__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03002020nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002021 struct nfsd4_compound_state *cstate,
2022 struct nfsd4_sequence *seq)
2023{
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03002024 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002025 struct nfsd4_session *session;
2026 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002027 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002028 __be32 status;
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002029 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002030
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03002031 if (resp->opcnt != 1)
2032 return nfserr_sequence_pos;
2033
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002034 /*
2035 * Will be either used or freed by nfsd4_sequence_check_conn
2036 * below.
2037 */
2038 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2039 if (!conn)
2040 return nfserr_jukebox;
2041
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002042 spin_lock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002043 status = nfserr_badsession;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03002044 session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
Benny Halevyb85d4c02009-04-03 08:28:08 +03002045 if (!session)
2046 goto out;
2047
Mi Jinlong868b89c2011-04-27 09:09:58 +08002048 status = nfserr_too_many_ops;
2049 if (nfsd4_session_too_many_ops(rqstp, session))
2050 goto out;
2051
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002052 status = nfserr_req_too_big;
2053 if (nfsd4_request_too_big(rqstp, session))
2054 goto out;
2055
Benny Halevyb85d4c02009-04-03 08:28:08 +03002056 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002057 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03002058 goto out;
2059
Andy Adamson557ce262009-08-28 08:45:04 -04002060 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002061 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2062
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002063 /* We do not negotiate the number of slots yet, so set the
2064 * maxslots to the session maxreqs which is used to encode
2065 * sr_highest_slotid and the sr_target_slot id to maxslots */
2066 seq->maxslots = session->se_fchannel.maxreqs;
2067
J. Bruce Fields73e79482012-02-13 16:39:00 -05002068 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2069 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002070 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002071 status = nfserr_seq_misordered;
2072 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
2073 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002074 cstate->slot = slot;
2075 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002076 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002077 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002078 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002079 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002080 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002081 }
2082 if (status)
2083 goto out;
2084
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002085 nfsd4_sequence_check_conn(conn, session);
2086 conn = NULL;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002087
Benny Halevyb85d4c02009-04-03 08:28:08 +03002088 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03002089 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002090 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05002091 if (seq->cachethis)
2092 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002093 else
2094 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002095
2096 cstate->slot = slot;
2097 cstate->session = session;
2098
Benny Halevyb85d4c02009-04-03 08:28:08 +03002099out:
J. Bruce Fields26c0c752010-04-24 15:35:43 -04002100 /* Hold a session reference until done processing the compound. */
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002101 if (cstate->session) {
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05002102 struct nfs4_client *clp = session->se_client;
2103
Benny Halevy36acb662010-05-12 00:13:04 +03002104 nfsd4_get_session(cstate->session);
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05002105 atomic_inc(&clp->cl_refcount);
Benny Halevy54237322011-10-19 19:12:58 -07002106 switch (clp->cl_cb_state) {
2107 case NFSD4_CB_DOWN:
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002108 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
Benny Halevy54237322011-10-19 19:12:58 -07002109 break;
2110 case NFSD4_CB_FAULT:
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002111 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
Benny Halevy54237322011-10-19 19:12:58 -07002112 break;
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002113 default:
2114 seq->status_flags = 0;
Benny Halevy54237322011-10-19 19:12:58 -07002115 }
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002116 }
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002117 kfree(conn);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03002118 spin_unlock(&nn->client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002119 dprintk("%s: return %d\n", __func__, ntohl(status));
2120 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002121}
2122
Mi Jinlong345c2842011-10-20 17:51:39 +08002123__be32
2124nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2125{
2126 struct nfs4_client *conf, *unconf, *clp;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002127 __be32 status = 0;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002128 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Mi Jinlong345c2842011-10-20 17:51:39 +08002129
2130 nfs4_lock_state();
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002131 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002132 conf = find_confirmed_client(&dc->clientid, true, nn);
J. Bruce Fields78389042013-03-12 10:12:37 -04002133 WARN_ON_ONCE(conf && unconf);
Mi Jinlong345c2842011-10-20 17:51:39 +08002134
2135 if (conf) {
2136 clp = conf;
2137
J. Bruce Fields6eccece2012-05-29 16:37:44 -04002138 if (!is_client_expired(conf) && client_has_state(conf)) {
Mi Jinlong345c2842011-10-20 17:51:39 +08002139 status = nfserr_clientid_busy;
2140 goto out;
2141 }
2142
2143 /* rfc5661 18.50.3 */
2144 if (cstate->session && conf == cstate->session->se_client) {
2145 status = nfserr_clientid_busy;
2146 goto out;
2147 }
2148 } else if (unconf)
2149 clp = unconf;
2150 else {
2151 status = nfserr_stale_clientid;
2152 goto out;
2153 }
2154
2155 expire_client(clp);
2156out:
2157 nfs4_unlock_state();
2158 dprintk("%s return %d\n", __func__, ntohl(status));
2159 return status;
2160}
2161
Andy Adamson069b6ad2009-04-03 08:27:58 +03002162__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002163nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2164{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002165 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002166
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002167 if (rc->rca_one_fs) {
2168 if (!cstate->current_fh.fh_dentry)
2169 return nfserr_nofilehandle;
2170 /*
2171 * We don't take advantage of the rca_one_fs case.
2172 * That's OK, it's optional, we can safely ignore it.
2173 */
2174 return nfs_ok;
2175 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002176
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002177 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002178 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04002179 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2180 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002181 goto out;
2182
2183 status = nfserr_stale_clientid;
2184 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002185 /*
2186 * The following error isn't really legal.
2187 * But we only get here if the client just explicitly
2188 * destroyed the client. Surely it no longer cares what
2189 * error it gets back on an operation for the dead
2190 * client.
2191 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002192 goto out;
2193
2194 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04002195 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002196out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002197 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002198 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002199}
2200
2201__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002202nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2203 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002205 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 nfs4_verifier clverifier = setclid->se_verf;
NeilBrown28ce6052005-06-23 22:03:56 -07002207 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07002208 __be32 status;
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002209 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2210
J. Bruce Fields63db4632012-05-18 21:54:19 -04002211 /* Cases below refer to rfc 3530 section 14.2.33: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 nfs4_lock_state();
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002213 conf = find_confirmed_client_by_name(&clname, nn);
NeilBrown28ce6052005-06-23 22:03:56 -07002214 if (conf) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04002215 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002217 if (clp_used_exchangeid(conf))
2218 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04002219 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04002220 char addr_str[INET6_ADDRSTRLEN];
2221 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2222 sizeof(addr_str));
2223 dprintk("NFSD: setclientid: string in use by client "
2224 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 goto out;
2226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03002228 unconf = find_unconfirmed_client_by_name(&clname, nn);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002229 if (unconf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 status = nfserr_jukebox;
Jeff Layton2216d442012-11-12 15:00:57 -05002232 new = create_client(clname, rqstp, &clverifier);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002233 if (new == NULL)
2234 goto out;
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002235 if (conf && same_verf(&conf->cl_verifier, &clverifier))
J. Bruce Fields63db4632012-05-18 21:54:19 -04002236 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 copy_clid(new, conf);
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002238 else /* case 4 (new client) or cases 2, 3 (client reboot): */
Stanislav Kinsburskyc212cec2012-11-14 18:21:10 +03002239 gen_clid(new, nn);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002240 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002241 gen_callback(new, setclid, rqstp);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05002242 add_to_unconfirmed(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2244 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2245 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2246 status = nfs_ok;
2247out:
2248 nfs4_unlock_state();
2249 return status;
2250}
2251
2252
Al Virob37ad282006-10-19 23:28:59 -07002253__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002254nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2255 struct nfsd4_compound_state *cstate,
2256 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257{
NeilBrown21ab45a2005-06-23 22:04:14 -07002258 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2260 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002261 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03002262 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002264 if (STALE_CLIENTID(clid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 return nfserr_stale_clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002267
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002268 conf = find_confirmed_client(clid, false, nn);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03002269 unconf = find_unconfirmed_client(clid, false, nn);
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002270 /*
J. Bruce Fields8695b902012-05-19 10:05:58 -04002271 * We try hard to give out unique clientid's, so if we get an
2272 * attempt to confirm the same clientid with a different cred,
2273 * there's a bug somewhere. Let's charitably assume it's our
2274 * bug.
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002275 */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002276 status = nfserr_serverfault;
2277 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2278 goto out;
2279 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2280 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04002281 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002282 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2283 if (conf && !unconf) /* case 2: probable retransmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 status = nfs_ok;
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002285 else /* case 4: client hasn't noticed we rebooted yet? */
2286 status = nfserr_stale_clientid;
2287 goto out;
2288 }
2289 status = nfs_ok;
2290 if (conf) { /* case 1: callback update */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002291 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2292 nfsd4_probe_callback(conf);
2293 expire_client(unconf);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002294 } else { /* case 3: normal case; new or rebooted client */
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03002295 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
J. Bruce Fields0d22f682012-09-26 11:36:16 -04002296 if (conf)
J. Bruce Fields8695b902012-05-19 10:05:58 -04002297 expire_client(conf);
J. Bruce Fields8695b902012-05-19 10:05:58 -04002298 move_to_confirmed(unconf);
J. Bruce Fieldsf3d03b92012-05-23 11:38:38 -04002299 nfsd4_probe_callback(unconf);
NeilBrown08e89872005-06-23 22:04:11 -07002300 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 nfs4_unlock_state();
2303 return status;
2304}
2305
J. Bruce Fields32513b42011-10-13 16:00:16 -04002306static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307{
J. Bruce Fields32513b42011-10-13 16:00:16 -04002308 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2309}
2310
2311/* OPEN Share state helper functions */
2312static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2313{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 unsigned int hashval = file_hashval(ino);
2315
J. Bruce Fields32513b42011-10-13 16:00:16 -04002316 atomic_set(&fp->fi_ref, 1);
2317 INIT_LIST_HEAD(&fp->fi_hash);
2318 INIT_LIST_HEAD(&fp->fi_stateids);
2319 INIT_LIST_HEAD(&fp->fi_delegations);
2320 fp->fi_inode = igrab(ino);
2321 fp->fi_had_conflict = false;
2322 fp->fi_lease = NULL;
2323 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2324 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2325 spin_lock(&recall_lock);
2326 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2327 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328}
2329
2330static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002331nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002332{
NeilBrowne60d4392005-06-23 22:03:01 -07002333 if (*slab == NULL)
2334 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002335 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002336 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002337}
2338
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002339void
NeilBrowne60d4392005-06-23 22:03:01 -07002340nfsd4_free_slabs(void)
2341{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002342 nfsd4_free_slab(&openowner_slab);
2343 nfsd4_free_slab(&lockowner_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002344 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002345 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002346 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002347}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
Bryan Schumaker72083392011-11-01 15:24:59 -04002349int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350nfsd4_init_slabs(void)
2351{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002352 openowner_slab = kmem_cache_create("nfsd4_openowners",
2353 sizeof(struct nfs4_openowner), 0, 0, NULL);
2354 if (openowner_slab == NULL)
2355 goto out_nomem;
2356 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
Yanchuan Nian3c407942012-10-24 14:44:19 +08002357 sizeof(struct nfs4_lockowner), 0, 0, NULL);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002358 if (lockowner_slab == NULL)
NeilBrowne60d4392005-06-23 22:03:01 -07002359 goto out_nomem;
2360 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002361 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002362 if (file_slab == NULL)
2363 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002364 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002365 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002366 if (stateid_slab == NULL)
2367 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002368 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002369 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002370 if (deleg_slab == NULL)
2371 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002373out_nomem:
2374 nfsd4_free_slabs();
2375 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2376 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377}
2378
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002379void nfs4_free_openowner(struct nfs4_openowner *oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002381 kfree(oo->oo_owner.so_owner.data);
2382 kmem_cache_free(openowner_slab, oo);
2383}
2384
2385void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2386{
2387 kfree(lo->lo_owner.so_owner.data);
2388 kmem_cache_free(lockowner_slab, lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389}
2390
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002391static void init_nfs4_replay(struct nfs4_replay *rp)
2392{
2393 rp->rp_status = nfserr_serverfault;
2394 rp->rp_buflen = 0;
2395 rp->rp_buf = rp->rp_ibuf;
2396}
2397
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002398static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399{
2400 struct nfs4_stateowner *sop;
2401
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002402 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002403 if (!sop)
2404 return NULL;
2405
2406 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2407 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002408 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002409 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002411 sop->so_owner.len = owner->len;
2412
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002413 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002414 sop->so_client = clp;
2415 init_nfs4_replay(&sop->so_replay);
2416 return sop;
2417}
2418
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002419static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002420{
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002421 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2422
2423 list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002424 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425}
2426
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002427static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002429 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002431 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2432 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002434 oo->oo_owner.so_is_open_owner = 1;
2435 oo->oo_owner.so_seqid = open->op_seqid;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04002436 oo->oo_flags = NFS4_OO_NEW;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002437 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04002438 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002439 INIT_LIST_HEAD(&oo->oo_close_lru);
2440 hash_openowner(oo, clp, strhashval);
2441 return oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442}
2443
J. Bruce Fields996e0932011-10-17 11:14:48 -04002444static 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 -04002445 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446
J. Bruce Fields3abdb602013-02-03 12:23:01 -05002447 stp->st_stid.sc_type = NFS4_OPEN_STID;
NeilBrownea1da632005-06-23 22:04:17 -07002448 INIT_LIST_HEAD(&stp->st_lockowners);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002449 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002450 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002451 stp->st_stateowner = &oo->oo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07002452 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 stp->st_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 stp->st_access_bmap = 0;
2455 stp->st_deny_bmap = 0;
Jeff Layton82c5ff12012-05-11 09:45:13 -04002456 set_access(open->op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002457 set_deny(open->op_share_deny, stp);
NeilBrown4c4cd222005-07-07 17:59:27 -07002458 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459}
2460
2461static void
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002462move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463{
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002464 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2465
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002466 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03002468 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002469 oo->oo_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470}
2471
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002473same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2474 clientid_t *clid)
2475{
2476 return (sop->so_owner.len == owner->len) &&
2477 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2478 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479}
2480
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002481static struct nfs4_openowner *
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002482find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2483 bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484{
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002485 struct nfs4_stateowner *so;
2486 struct nfs4_openowner *oo;
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002487 struct nfs4_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002489 list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002490 if (!so->so_is_open_owner)
2491 continue;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002492 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2493 oo = openowner(so);
J. Bruce Fieldsd15c0772012-09-13 16:19:31 -04002494 clp = oo->oo_owner.so_client;
2495 if ((bool)clp->cl_minorversion != sessions)
2496 return NULL;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002497 renew_client(oo->oo_owner.so_client);
2498 return oo;
2499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 }
2501 return NULL;
2502}
2503
2504/* search file_hashtbl[] for file */
2505static struct nfs4_file *
2506find_file(struct inode *ino)
2507{
2508 unsigned int hashval = file_hashval(ino);
2509 struct nfs4_file *fp;
2510
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002511 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002513 if (fp->fi_inode == ino) {
2514 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002515 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002519 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 return NULL;
2521}
2522
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002523/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 * Called to check deny when READ with all zero stateid or
2525 * WRITE with all zero or all one stateid
2526 */
Al Virob37ad282006-10-19 23:28:59 -07002527static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2529{
2530 struct inode *ino = current_fh->fh_dentry->d_inode;
2531 struct nfs4_file *fp;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002532 struct nfs4_ol_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002533 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534
2535 dprintk("NFSD: nfs4_share_conflict\n");
2536
2537 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002538 if (!fp)
2539 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002540 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002542 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
Jeff Laytonce0fc432012-05-11 09:45:14 -04002543 if (test_deny(deny_type, stp) ||
2544 test_deny(NFS4_SHARE_DENY_BOTH, stp))
NeilBrown13cd2182005-06-23 22:03:10 -07002545 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 }
NeilBrown13cd2182005-06-23 22:03:10 -07002547 ret = nfs_ok;
2548out:
2549 put_nfs4_file(fp);
2550 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551}
2552
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002553static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 /* We're assuming the state code never drops its reference
2556 * without first removing the lease. Since we're in this lease
2557 * callback (and since the lease code is serialized by the kernel
2558 * lock) we know the server hasn't removed the lease yet, we know
2559 * it's safe to take a reference: */
2560 atomic_inc(&dp->dl_count);
2561
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
Arnd Bergmann460781b2010-11-17 16:26:56 +01002564 /* only place dl_time is set. protected by lock_flocks*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 dp->dl_time = get_seconds();
2566
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002567 nfsd4_cb_recall(dp);
2568}
2569
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002570/* Called from break_lease() with lock_flocks() held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002571static void nfsd_break_deleg_cb(struct file_lock *fl)
2572{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002573 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2574 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002575
J. Bruce Fields7fa10cd2012-10-16 12:39:33 -04002576 if (!fp) {
2577 WARN(1, "(%p)->fl_owner NULL\n", fl);
2578 return;
2579 }
2580 if (fp->fi_had_conflict) {
2581 WARN(1, "duplicate break on %p\n", fp);
2582 return;
2583 }
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002584 /*
2585 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002586 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002587 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002588 */
2589 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002591 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002592 fp->fi_had_conflict = true;
2593 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2594 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002595 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596}
2597
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598static
2599int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2600{
2601 if (arg & F_UNLCK)
2602 return lease_modify(onlist, arg);
2603 else
2604 return -EAGAIN;
2605}
2606
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002607static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002608 .lm_break = nfsd_break_deleg_cb,
2609 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610};
2611
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04002612static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2613{
2614 if (nfsd4_has_session(cstate))
2615 return nfs_ok;
2616 if (seqid == so->so_seqid - 1)
2617 return nfserr_replay_me;
2618 if (seqid == so->so_seqid)
2619 return nfs_ok;
2620 return nfserr_bad_seqid;
2621}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
Al Virob37ad282006-10-19 23:28:59 -07002623__be32
Andy Adamson66689582009-04-03 08:28:45 +03002624nfsd4_process_open1(struct nfsd4_compound_state *cstate,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03002625 struct nfsd4_open *open, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 clientid_t *clientid = &open->op_clientid;
2628 struct nfs4_client *clp = NULL;
2629 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002630 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002631 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04002633 if (STALE_CLIENTID(&open->op_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04002635 /*
2636 * In case we need it later, after we've already created the
2637 * file and don't want to risk a further failure:
2638 */
2639 open->op_file = nfsd4_alloc_file();
2640 if (open->op_file == NULL)
2641 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002643 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03002644 oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002645 open->op_openowner = oo;
2646 if (!oo) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03002647 clp = find_confirmed_client(clientid, cstate->minorversion,
2648 nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002650 return nfserr_expired;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002651 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002653 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002654 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002655 clp = oo->oo_owner.so_client;
2656 release_openowner(oo);
2657 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002658 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002659 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002660 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2661 if (status)
2662 return status;
2663 clp = oo->oo_owner.so_client;
2664 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002665new_owner:
2666 oo = alloc_init_open_stateowner(strhashval, clp, open);
2667 if (oo == NULL)
2668 return nfserr_jukebox;
2669 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002670alloc_stateid:
2671 open->op_stp = nfs4_alloc_stateid(clp);
2672 if (!open->op_stp)
2673 return nfserr_jukebox;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002674 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675}
2676
Al Virob37ad282006-10-19 23:28:59 -07002677static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002678nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2679{
2680 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2681 return nfserr_openmode;
2682 else
2683 return nfs_ok;
2684}
2685
Daniel Mackc47d8322011-05-16 16:38:14 +02002686static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002687{
J. Bruce Fields24a01112010-05-18 20:01:35 -04002688 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2689}
2690
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002691static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002692{
2693 struct nfs4_stid *ret;
2694
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002695 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002696 if (!ret)
2697 return NULL;
2698 return delegstateid(ret);
2699}
2700
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002701static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2702{
2703 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2704 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2705}
2706
Al Virob37ad282006-10-19 23:28:59 -07002707static __be32
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002708nfs4_check_deleg(struct nfs4_client *cl, struct nfs4_file *fp, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07002709 struct nfs4_delegation **dp)
2710{
2711 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002712 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002713
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002714 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
NeilBrown567d9822005-06-23 22:02:53 -07002715 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002716 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002717 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002718 status = nfs4_check_delegmode(*dp, flags);
2719 if (status)
2720 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002721out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002722 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07002723 return nfs_ok;
2724 if (status)
2725 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002726 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002727 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002728}
2729
Al Virob37ad282006-10-19 23:28:59 -07002730static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002731nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002733 struct nfs4_ol_stateid *local;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002734 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735
NeilBrown8beefa22005-06-23 22:03:08 -07002736 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 /* ignore lock owners */
2738 if (local->st_stateowner->so_is_open_owner == 0)
2739 continue;
2740 /* remember if we have seen this open owner */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002741 if (local->st_stateowner == &oo->oo_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 *stpp = local;
2743 /* check for conflicting share reservations */
2744 if (!test_share(local, open))
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002745 return nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 }
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002747 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748}
2749
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002750static inline int nfs4_access_to_access(u32 nfs4_access)
2751{
2752 int flags = 0;
2753
2754 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2755 flags |= NFSD_MAY_READ;
2756 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2757 flags |= NFSD_MAY_WRITE;
2758 return flags;
2759}
2760
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002761static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2762 struct svc_fh *cur_fh, struct nfsd4_open *open)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002763{
2764 __be32 status;
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002765 int oflag = nfs4_access_to_omode(open->op_share_access);
2766 int access = nfs4_access_to_access(open->op_share_access);
2767
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002768 if (!fp->fi_fds[oflag]) {
2769 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2770 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002771 if (status)
2772 return status;
2773 }
2774 nfs4_file_get_access(fp, oflag);
2775
2776 return nfs_ok;
2777}
2778
Al Virob37ad282006-10-19 23:28:59 -07002779static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2781 struct nfsd4_open *open)
2782{
2783 struct iattr iattr = {
2784 .ia_valid = ATTR_SIZE,
2785 .ia_size = 0,
2786 };
2787 if (!open->op_truncate)
2788 return 0;
2789 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002790 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2792}
2793
Al Virob37ad282006-10-19 23:28:59 -07002794static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002795nfs4_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 -07002796{
J. Bruce Fieldsb6d2f1c2011-10-10 17:44:19 -04002797 u32 op_share_access = open->op_share_access;
J. Bruce Fields7d947842010-08-20 18:09:31 -04002798 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002799 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
Jeff Layton82c5ff12012-05-11 09:45:13 -04002801 new_access = !test_access(op_share_access, stp);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002802 if (new_access) {
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002803 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002804 if (status)
2805 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002806 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 status = nfsd4_truncate(rqstp, cur_fh, open);
2808 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002809 if (new_access) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04002810 int oflag = nfs4_access_to_omode(op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002811 nfs4_file_put_access(fp, oflag);
2812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 return status;
2814 }
2815 /* remember the open */
Jeff Layton82c5ff12012-05-11 09:45:13 -04002816 set_access(op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002817 set_deny(open->op_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818
2819 return nfs_ok;
2820}
2821
2822
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823static void
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05002824nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825{
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002826 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827}
2828
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002829/* Should we give out recallable state?: */
2830static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2831{
2832 if (clp->cl_cb_state == NFSD4_CB_UP)
2833 return true;
2834 /*
2835 * In the sessions case, since we don't have to establish a
2836 * separate connection for callbacks, we assume it's OK
2837 * until we hear otherwise:
2838 */
2839 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2840}
2841
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002842static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2843{
2844 struct file_lock *fl;
2845
2846 fl = locks_alloc_lock();
2847 if (!fl)
2848 return NULL;
2849 locks_init_lock(fl);
2850 fl->fl_lmops = &nfsd_lease_mng_ops;
2851 fl->fl_flags = FL_LEASE;
2852 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2853 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002854 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002855 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002856 return fl;
2857}
2858
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002859static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2860{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002861 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002862 struct file_lock *fl;
2863 int status;
2864
2865 fl = nfs4_alloc_init_lease(dp, flag);
2866 if (!fl)
2867 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002868 fl->fl_file = find_readable_file(fp);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002869 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002870 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002871 if (status) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002872 list_del_init(&dp->dl_perclnt);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002873 locks_free_lock(fl);
2874 return -ENOMEM;
2875 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002876 fp->fi_lease = fl;
Al Virocb0942b2012-08-27 14:48:26 -04002877 fp->fi_deleg_file = get_file(fl->fl_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002878 atomic_set(&fp->fi_delegees, 1);
2879 list_add(&dp->dl_perfile, &fp->fi_delegations);
2880 return 0;
2881}
2882
2883static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2884{
2885 struct nfs4_file *fp = dp->dl_file;
2886
2887 if (!fp->fi_lease)
2888 return nfs4_setlease(dp, flag);
2889 spin_lock(&recall_lock);
2890 if (fp->fi_had_conflict) {
2891 spin_unlock(&recall_lock);
2892 return -EAGAIN;
2893 }
2894 atomic_inc(&fp->fi_delegees);
2895 list_add(&dp->dl_perfile, &fp->fi_delegations);
2896 spin_unlock(&recall_lock);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002897 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002898 return 0;
2899}
2900
Benny Halevy4aa89132012-02-21 14:16:44 -08002901static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
2902{
2903 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2904 if (status == -EAGAIN)
2905 open->op_why_no_deleg = WND4_CONTENTION;
2906 else {
2907 open->op_why_no_deleg = WND4_RESOURCE;
2908 switch (open->op_deleg_want) {
2909 case NFS4_SHARE_WANT_READ_DELEG:
2910 case NFS4_SHARE_WANT_WRITE_DELEG:
2911 case NFS4_SHARE_WANT_ANY_DELEG:
2912 break;
2913 case NFS4_SHARE_WANT_CANCEL:
2914 open->op_why_no_deleg = WND4_CANCELLED;
2915 break;
2916 case NFS4_SHARE_WANT_NO_DELEG:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05002917 WARN_ON_ONCE(1);
Benny Halevy4aa89132012-02-21 14:16:44 -08002918 }
2919 }
2920}
2921
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922/*
2923 * Attempt to hand out a delegation.
2924 */
2925static void
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04002926nfs4_open_delegation(struct net *net, struct svc_fh *fh,
2927 struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928{
2929 struct nfs4_delegation *dp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002930 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002931 int cb_up;
Benny Halevyd24433c2012-02-16 20:57:17 +02002932 int status = 0, flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002934 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002936 open->op_recall = 0;
2937 switch (open->op_claim_type) {
2938 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002939 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07002940 open->op_recall = 1;
2941 flag = open->op_delegate_type;
2942 if (flag == NFS4_OPEN_DELEGATE_NONE)
2943 goto out;
2944 break;
2945 case NFS4_OPEN_CLAIM_NULL:
2946 /* Let's not give out any delegations till everyone's
2947 * had the chance to reclaim theirs.... */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04002948 if (locks_in_grace(net))
NeilBrown7b190fe2005-06-23 22:03:23 -07002949 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002950 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown7b190fe2005-06-23 22:03:23 -07002951 goto out;
2952 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2953 flag = NFS4_OPEN_DELEGATE_WRITE;
2954 else
2955 flag = NFS4_OPEN_DELEGATE_READ;
2956 break;
2957 default:
2958 goto out;
2959 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002961 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002962 if (dp == NULL)
2963 goto out_no_deleg;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002964 status = nfs4_set_delegation(dp, flag);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002965 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002966 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04002968 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002970 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04002971 STATEID_VAL(&dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972out:
2973 open->op_delegate_type = flag;
Benny Halevyd24433c2012-02-16 20:57:17 +02002974 if (flag == NFS4_OPEN_DELEGATE_NONE) {
2975 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
2976 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2977 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2978
Benny Halevy4aa89132012-02-21 14:16:44 -08002979 /* 4.1 client asking for a delegation? */
2980 if (open->op_deleg_want)
2981 nfsd4_open_deleg_none_ext(open, status);
Benny Halevyd24433c2012-02-16 20:57:17 +02002982 }
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002983 return;
2984out_free:
J. Bruce Fields24ffb932012-12-12 15:24:12 -05002985 unhash_stid(&dp->dl_stid);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002986 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002987out_no_deleg:
2988 flag = NFS4_OPEN_DELEGATE_NONE;
2989 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990}
2991
Benny Halevye27f49c2012-02-21 14:16:54 -08002992static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
2993 struct nfs4_delegation *dp)
2994{
2995 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
2996 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
2997 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2998 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
2999 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3000 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3001 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3002 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3003 }
3004 /* Otherwise the client must be confused wanting a delegation
3005 * it already has, therefore we don't return
3006 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
3007 */
3008}
3009
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010/*
3011 * called with nfs4_lock_state() held.
3012 */
Al Virob37ad282006-10-19 23:28:59 -07003013__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3015{
Andy Adamson66689582009-04-03 08:28:45 +03003016 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003017 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 struct nfs4_file *fp = NULL;
3019 struct inode *ino = current_fh->fh_dentry->d_inode;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003020 struct nfs4_ol_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07003021 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07003022 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 /*
3025 * Lookup file; if found, lookup stateid and check open request,
3026 * and check for delegations in the process of being recalled.
3027 * If not found, create the nfs4_file struct
3028 */
3029 fp = find_file(ino);
3030 if (fp) {
3031 if ((status = nfs4_check_open(fp, open, &stp)))
3032 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003033 status = nfs4_check_deleg(cl, fp, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07003034 if (status)
3035 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07003037 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04003038 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003039 goto out;
J. Bruce Fields3e772462011-08-10 19:07:33 -04003040 status = nfserr_jukebox;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003041 fp = open->op_file;
3042 open->op_file = NULL;
3043 nfsd4_init_file(fp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 }
3045
3046 /*
3047 * OPEN the file, or upgrade an existing OPEN.
3048 * If truncate fails, the OPEN fails.
3049 */
3050 if (stp) {
3051 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003052 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 if (status)
3054 goto out;
3055 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003056 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07003057 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 goto out;
J. Bruce Fields4af82502012-06-07 17:30:45 -04003059 status = nfsd4_truncate(rqstp, current_fh, open);
3060 if (status)
3061 goto out;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003062 stp = open->op_stp;
3063 open->op_stp = NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003064 init_open_stateid(stp, fp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003066 update_stateid(&stp->st_stid.sc_stateid);
3067 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068
Benny Halevyd24433c2012-02-16 20:57:17 +02003069 if (nfsd4_has_session(&resp->cstate)) {
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003070 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Andy Adamson66689582009-04-03 08:28:45 +03003071
Benny Halevyd24433c2012-02-16 20:57:17 +02003072 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3073 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3074 open->op_why_no_deleg = WND4_NOT_WANTED;
3075 goto nodeleg;
3076 }
3077 }
3078
Linus Torvalds1da177e2005-04-16 15:20:36 -07003079 /*
3080 * Attempt to hand out a delegation. No error return, because the
3081 * OPEN succeeds even if we fail.
3082 */
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003083 nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003084nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 status = nfs_ok;
3086
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003087 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003088 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089out:
Benny Halevyd24433c2012-02-16 20:57:17 +02003090 /* 4.1 client trying to upgrade/downgrade delegation? */
3091 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08003092 open->op_deleg_want)
3093 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003094
NeilBrown13cd2182005-06-23 22:03:10 -07003095 if (fp)
3096 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07003097 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003098 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 /*
3100 * To finish the open response, we just need to set the rflags.
3101 */
3102 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003103 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03003104 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3106
3107 return status;
3108}
3109
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003110void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3111{
3112 if (open->op_openowner) {
3113 struct nfs4_openowner *oo = open->op_openowner;
3114
3115 if (!list_empty(&oo->oo_owner.so_stateids))
3116 list_del_init(&oo->oo_close_lru);
3117 if (oo->oo_flags & NFS4_OO_NEW) {
3118 if (status) {
3119 release_openowner(oo);
3120 open->op_openowner = NULL;
3121 } else
3122 oo->oo_flags &= ~NFS4_OO_NEW;
3123 }
3124 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04003125 if (open->op_file)
3126 nfsd4_free_file(open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003127 if (open->op_stp)
J. Bruce Fieldsef798592012-08-29 10:32:54 -07003128 free_generic_stateid(open->op_stp);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003129}
3130
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003131static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
3132{
3133 struct nfs4_client *found;
3134
3135 if (STALE_CLIENTID(clid, nn))
3136 return nfserr_stale_clientid;
3137 found = find_confirmed_client(clid, session, nn);
3138 if (clp)
3139 *clp = found;
3140 return found ? nfs_ok : nfserr_expired;
3141}
3142
Al Virob37ad282006-10-19 23:28:59 -07003143__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003144nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3145 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146{
3147 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07003148 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03003149 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150
3151 nfs4_lock_state();
3152 dprintk("process_renew(%08x/%08x): starting\n",
3153 clid->cl_boot, clid->cl_id);
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05003154 status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
3155 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07003158 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04003159 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160 goto out;
3161 status = nfs_ok;
3162out:
3163 nfs4_unlock_state();
3164 return status;
3165}
3166
NeilBrowna76b4312005-06-23 22:04:01 -07003167static void
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003168nfsd4_end_grace(struct nfsd_net *nn)
NeilBrowna76b4312005-06-23 22:04:01 -07003169{
Jeff Layton33dcc482012-04-10 11:08:48 -04003170 /* do nothing if grace period already ended */
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003171 if (nn->grace_ended)
Jeff Layton33dcc482012-04-10 11:08:48 -04003172 return;
3173
NeilBrowna76b4312005-06-23 22:04:01 -07003174 dprintk("NFSD: end of grace period\n");
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04003175 nn->grace_ended = true;
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003176 nfsd4_record_grace_done(nn, nn->boot_time);
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04003177 locks_end_grace(&nn->nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05003178 /*
3179 * Now that every NFSv4 client has had the chance to recover and
3180 * to see the (possibly new, possibly shorter) lease time, we
3181 * can safely set the next grace time to the current lease time:
3182 */
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03003183 nn->nfsd4_grace = nn->nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07003184}
3185
NeilBrownfd39ca92005-06-23 22:04:03 -07003186static time_t
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003187nfs4_laundromat(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003188{
3189 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003190 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 struct nfs4_delegation *dp;
3192 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003193 time_t cutoff = get_seconds() - nn->nfsd4_lease;
3194 time_t t, clientid_val = nn->nfsd4_lease;
3195 time_t u, test_val = nn->nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196
3197 nfs4_lock_state();
3198
3199 dprintk("NFSD: laundromat service - starting\n");
Stanislav Kinsbursky12760c62012-11-14 18:22:12 +03003200 nfsd4_end_grace(nn);
Benny Halevy36acb662010-05-12 00:13:04 +03003201 INIT_LIST_HEAD(&reaplist);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003202 spin_lock(&nn->client_lock);
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03003203 list_for_each_safe(pos, next, &nn->client_lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 clp = list_entry(pos, struct nfs4_client, cl_lru);
3205 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3206 t = clp->cl_time - cutoff;
3207 if (clientid_val > t)
3208 clientid_val = t;
3209 break;
3210 }
Benny Halevyd7682982010-05-12 00:13:54 +03003211 if (atomic_read(&clp->cl_refcount)) {
3212 dprintk("NFSD: client in use (clientid %08x)\n",
3213 clp->cl_clientid.cl_id);
3214 continue;
3215 }
3216 unhash_client_locked(clp);
3217 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03003218 }
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03003219 spin_unlock(&nn->client_lock);
Benny Halevy36acb662010-05-12 00:13:04 +03003220 list_for_each_safe(pos, next, &reaplist) {
3221 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222 dprintk("NFSD: purging unused client (clientid %08x)\n",
3223 clp->cl_clientid.cl_id);
3224 expire_client(clp);
3225 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 spin_lock(&recall_lock);
3227 list_for_each_safe(pos, next, &del_recall_lru) {
3228 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Stanislav Kinsbursky4e37a7c22012-11-26 15:22:03 +03003229 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3230 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3232 u = dp->dl_time - cutoff;
3233 if (test_val > u)
3234 test_val = u;
3235 break;
3236 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 list_move(&dp->dl_recall_lru, &reaplist);
3238 }
3239 spin_unlock(&recall_lock);
3240 list_for_each_safe(pos, next, &reaplist) {
3241 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 unhash_delegation(dp);
3243 }
Stanislav Kinsbursky3d733712012-11-27 14:11:44 +03003244 test_val = nn->nfsd4_lease;
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003245 list_for_each_safe(pos, next, &nn->close_lru) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003246 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3247 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3248 u = oo->oo_time - cutoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 if (test_val > u)
3250 test_val = u;
3251 break;
3252 }
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003253 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 }
3255 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3256 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3257 nfs4_unlock_state();
3258 return clientid_val;
3259}
3260
Harvey Harrisona254b242008-02-20 12:49:00 -08003261static struct workqueue_struct *laundry_wq;
3262static void laundromat_main(struct work_struct *);
Harvey Harrisona254b242008-02-20 12:49:00 -08003263
3264static void
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003265laundromat_main(struct work_struct *laundry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266{
3267 time_t t;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003268 struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3269 work);
3270 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3271 laundromat_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003273 t = nfs4_laundromat(nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03003275 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276}
3277
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003278static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07003279{
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003280 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3281 return nfserr_bad_stateid;
3282 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003283}
3284
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003286access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003288 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3289 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3290 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291}
3292
3293static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003294access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003296 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3297 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298}
3299
3300static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003301__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302{
Al Virob37ad282006-10-19 23:28:59 -07003303 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304
J. Bruce Fields02921912010-07-29 15:16:59 -04003305 /* For lock stateid's, we test the parent open, not the lock: */
3306 if (stp->st_openstp)
3307 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003308 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003310 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311 goto out;
3312 status = nfs_ok;
3313out:
3314 return status;
3315}
3316
Al Virob37ad282006-10-19 23:28:59 -07003317static inline __be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003318check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003320 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321 return nfs_ok;
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003322 else if (locks_in_grace(net)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003323 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 * conflicting state; so we must wait out the grace period. */
3325 return nfserr_grace;
3326 } else if (flags & WR_STATE)
3327 return nfs4_share_conflict(current_fh,
3328 NFS4_SHARE_DENY_WRITE);
3329 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3330 return nfs4_share_conflict(current_fh,
3331 NFS4_SHARE_DENY_READ);
3332}
3333
3334/*
3335 * Allow READ/WRITE during grace period on recovered state only for files
3336 * that are not able to provide mandatory locking.
3337 */
3338static inline int
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003339grace_disallows_io(struct net *net, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340{
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003341 return locks_in_grace(net) && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342}
3343
J. Bruce Fields81b82962011-08-23 11:03:29 -04003344/* Returns true iff a is later than b: */
3345static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3346{
3347 return (s32)a->si_generation - (s32)b->si_generation > 0;
3348}
3349
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003350static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003351{
Andy Adamson66689582009-04-03 08:28:45 +03003352 /*
3353 * When sessions are used the stateid generation number is ignored
3354 * when it is zero.
3355 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04003356 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04003357 return nfs_ok;
3358
3359 if (in->si_generation == ref->si_generation)
3360 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03003361
J. Bruce Fields0836f582008-01-26 19:08:12 -05003362 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003363 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05003364 return nfserr_bad_stateid;
3365 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04003366 * However, we could see a stateid from the past, even from a
3367 * non-buggy client. For example, if the client sends a lock
3368 * while some IO is outstanding, the lock may bump si_generation
3369 * while the IO is still in flight. The client could avoid that
3370 * situation by waiting for responses on all the IO requests,
3371 * but better performance may result in retrying IO that
3372 * receives an old_stateid error if requests are rarely
3373 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003374 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003375 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003376}
3377
Chuck Lever7df302f2012-05-29 13:56:37 -04003378static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04003379{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003380 struct nfs4_stid *s;
3381 struct nfs4_ol_stateid *ols;
3382 __be32 status;
Bryan Schumaker17456802011-07-13 10:50:48 -04003383
Chuck Lever7df302f2012-05-29 13:56:37 -04003384 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3385 return nfserr_bad_stateid;
3386 /* Client debugging aid. */
3387 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3388 char addr_str[INET6_ADDRSTRLEN];
3389 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3390 sizeof(addr_str));
3391 pr_warn_ratelimited("NFSD: client %s testing state ID "
3392 "with incorrect client ID\n", addr_str);
3393 return nfserr_bad_stateid;
3394 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003395 s = find_stateid(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003396 if (!s)
Chuck Lever7df302f2012-05-29 13:56:37 -04003397 return nfserr_bad_stateid;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04003398 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04003399 if (status)
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003400 return status;
3401 if (!(s->sc_type & (NFS4_OPEN_STID | NFS4_LOCK_STID)))
3402 return nfs_ok;
3403 ols = openlockstateid(s);
3404 if (ols->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003405 && !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003406 return nfserr_bad_stateid;
3407 return nfs_ok;
Bryan Schumaker17456802011-07-13 10:50:48 -04003408}
3409
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003410static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
3411 struct nfs4_stid **s, bool sessions,
3412 struct nfsd_net *nn)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003413{
3414 struct nfs4_client *cl;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003415 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003416
3417 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3418 return nfserr_bad_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003419 status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
3420 nn, &cl);
3421 if (status == nfserr_stale_clientid)
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003422 return nfserr_stale_stateid;
J. Bruce Fields0eb6f202013-03-12 17:36:17 -04003423 if (status)
3424 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003425 *s = find_stateid_by_type(cl, stateid, typemask);
3426 if (!*s)
3427 return nfserr_bad_stateid;
3428 return nfs_ok;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003429}
3430
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431/*
3432* Checks for stateid operations
3433*/
Al Virob37ad282006-10-19 23:28:59 -07003434__be32
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003435nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
Benny Halevydd453df2009-04-03 08:28:41 +03003436 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437{
J. Bruce Fields69064a22011-09-09 11:54:57 -04003438 struct nfs4_stid *s;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003439 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003441 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442 struct inode *ino = current_fh->fh_dentry->d_inode;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003443 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Al Virob37ad282006-10-19 23:28:59 -07003444 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446 if (filpp)
3447 *filpp = NULL;
3448
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003449 if (grace_disallows_io(net, ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450 return nfserr_grace;
3451
3452 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04003453 return check_special_stateids(net, current_fh, stateid, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003455 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3456 &s, cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003457 if (status)
3458 return status;
J. Bruce Fields69064a22011-09-09 11:54:57 -04003459 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3460 if (status)
3461 goto out;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003462 switch (s->sc_type) {
3463 case NFS4_DELEG_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003464 dp = delegstateid(s);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003465 status = nfs4_check_delegmode(dp, flags);
3466 if (status)
3467 goto out;
Dan Carpenter43b01782010-10-27 23:19:04 +02003468 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003469 *filpp = dp->dl_file->fi_deleg_file;
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003470 if (!*filpp) {
3471 WARN_ON_ONCE(1);
3472 status = nfserr_serverfault;
3473 goto out;
3474 }
Dan Carpenter43b01782010-10-27 23:19:04 +02003475 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003476 break;
3477 case NFS4_OPEN_STID:
3478 case NFS4_LOCK_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003479 stp = openlockstateid(s);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003480 status = nfs4_check_fh(current_fh, stp);
3481 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003483 if (stp->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003484 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003486 status = nfs4_check_openmode(stp, flags);
3487 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003489 if (filpp) {
3490 if (flags & RD_STATE)
3491 *filpp = find_readable_file(stp->st_file);
3492 else
3493 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003494 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003495 break;
3496 default:
3497 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 }
3499 status = nfs_ok;
3500out:
3501 return status;
3502}
3503
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003504static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003505nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003506{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003507 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003508 return nfserr_locks_held;
3509 release_lock_stateid(stp);
3510 return nfs_ok;
3511}
3512
3513/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003514 * Test if the stateid is valid
3515 */
3516__be32
3517nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3518 struct nfsd4_test_stateid *test_stateid)
3519{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003520 struct nfsd4_test_stateid_id *stateid;
3521 struct nfs4_client *cl = cstate->session->se_client;
3522
3523 nfs4_lock_state();
3524 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
Chuck Lever7df302f2012-05-29 13:56:37 -04003525 stateid->ts_id_status =
3526 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003527 nfs4_unlock_state();
3528
Bryan Schumaker17456802011-07-13 10:50:48 -04003529 return nfs_ok;
3530}
3531
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003532__be32
3533nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3534 struct nfsd4_free_stateid *free_stateid)
3535{
3536 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003537 struct nfs4_stid *s;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003538 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003539 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003540
3541 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003542 s = find_stateid(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003543 if (!s)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003544 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003545 switch (s->sc_type) {
3546 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003547 ret = nfserr_locks_held;
3548 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003549 case NFS4_OPEN_STID:
3550 case NFS4_LOCK_STID:
3551 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3552 if (ret)
3553 goto out;
3554 if (s->sc_type == NFS4_LOCK_STID)
3555 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3556 else
3557 ret = nfserr_locks_held;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003558 break;
3559 default:
3560 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003561 }
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003562out:
3563 nfs4_unlock_state();
3564 return ret;
3565}
3566
NeilBrown4c4cd222005-07-07 17:59:27 -07003567static inline int
3568setlkflg (int type)
3569{
3570 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3571 RD_STATE : WR_STATE;
3572}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003574static __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 -04003575{
3576 struct svc_fh *current_fh = &cstate->current_fh;
3577 struct nfs4_stateowner *sop = stp->st_stateowner;
3578 __be32 status;
3579
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003580 status = nfsd4_check_seqid(cstate, sop, seqid);
3581 if (status)
3582 return status;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003583 if (stp->st_stid.sc_type == NFS4_CLOSED_STID)
3584 /*
3585 * "Closed" stateid's exist *only* to return
3586 * nfserr_replay_me from the previous step.
3587 */
3588 return nfserr_bad_stateid;
3589 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3590 if (status)
3591 return status;
3592 return nfs4_check_fh(current_fh, stp);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003593}
3594
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595/*
3596 * Checks for sequence id mutating operations.
3597 */
Al Virob37ad282006-10-19 23:28:59 -07003598static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003599nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003600 stateid_t *stateid, char typemask,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003601 struct nfs4_ol_stateid **stpp,
3602 struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603{
J. Bruce Fields0836f582008-01-26 19:08:12 -05003604 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003605 struct nfs4_stid *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003607 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3608 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003609
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610 *stpp = NULL;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003611 status = nfsd4_lookup_stateid(stateid, typemask, &s,
3612 cstate->minorversion, nn);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003613 if (status)
3614 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003615 *stpp = openlockstateid(s);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003616 cstate->replay_owner = (*stpp)->st_stateowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003617
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003618 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3619}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003620
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003621static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3622 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003623{
3624 __be32 status;
3625 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003627 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003628 NFS4_OPEN_STID, stpp, nn);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003629 if (status)
3630 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003631 oo = openowner((*stpp)->st_stateowner);
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003632 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003633 return nfserr_bad_stateid;
NeilBrown3a4f98b2005-07-07 17:59:26 -07003634 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635}
3636
Al Virob37ad282006-10-19 23:28:59 -07003637__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003638nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003639 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640{
Al Virob37ad282006-10-19 23:28:59 -07003641 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003642 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003643 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003644 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645
3646 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003647 (int)cstate->current_fh.fh_dentry->d_name.len,
3648 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003650 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003651 if (status)
3652 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653
3654 nfs4_lock_state();
3655
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003656 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003657 oc->oc_seqid, &oc->oc_req_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003658 NFS4_OPEN_STID, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003659 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003660 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003661 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003662 status = nfserr_bad_stateid;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003663 if (oo->oo_flags & NFS4_OO_CONFIRMED)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003664 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003665 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003666 update_stateid(&stp->st_stid.sc_stateid);
3667 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003668 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003669 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003670
Jeff Layton2a4317c2012-03-21 16:42:43 -04003671 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003672 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003674 if (!cstate->replay_owner)
3675 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003676 return status;
3677}
3678
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003679static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003681 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003682 return;
3683 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
Jeff Layton82c5ff12012-05-11 09:45:13 -04003684 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003685}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003686
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003687static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3688{
3689 switch (to_access) {
3690 case NFS4_SHARE_ACCESS_READ:
3691 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3692 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3693 break;
3694 case NFS4_SHARE_ACCESS_WRITE:
3695 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3696 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3697 break;
3698 case NFS4_SHARE_ACCESS_BOTH:
3699 break;
3700 default:
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003701 WARN_ON_ONCE(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003702 }
3703}
3704
3705static void
Jeff Laytonce0fc432012-05-11 09:45:14 -04003706reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707{
3708 int i;
3709 for (i = 0; i < 4; i++) {
3710 if ((i & deny) != i)
Jeff Laytonce0fc432012-05-11 09:45:14 -04003711 clear_deny(i, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712 }
3713}
3714
Al Virob37ad282006-10-19 23:28:59 -07003715__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003716nfsd4_open_downgrade(struct svc_rqst *rqstp,
3717 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003718 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719{
Al Virob37ad282006-10-19 23:28:59 -07003720 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003721 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003722 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003723
3724 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003725 (int)cstate->current_fh.fh_dentry->d_name.len,
3726 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003727
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04003728 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02003729 if (od->od_deleg_want)
3730 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
3731 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732
3733 nfs4_lock_state();
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003734 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003735 &od->od_stateid, &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003736 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003737 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003739 if (!test_access(od->od_share_access, stp)) {
3740 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741 stp->st_access_bmap, od->od_share_access);
3742 goto out;
3743 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04003744 if (!test_deny(od->od_share_deny, stp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3746 stp->st_deny_bmap, od->od_share_deny);
3747 goto out;
3748 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003749 nfs4_stateid_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750
Jeff Laytonce0fc432012-05-11 09:45:14 -04003751 reset_union_bmap_deny(od->od_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003753 update_stateid(&stp->st_stid.sc_stateid);
3754 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003755 status = nfs_ok;
3756out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003757 if (!cstate->replay_owner)
3758 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003759 return status;
3760}
3761
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003762void nfsd4_purge_closed_stateid(struct nfs4_stateowner *so)
3763{
3764 struct nfs4_openowner *oo;
3765 struct nfs4_ol_stateid *s;
3766
3767 if (!so->so_is_open_owner)
3768 return;
3769 oo = openowner(so);
3770 s = oo->oo_last_closed_stid;
3771 if (!s)
3772 return;
3773 if (!(oo->oo_flags & NFS4_OO_PURGE_CLOSE)) {
3774 /* Release the last_closed_stid on the next seqid bump: */
3775 oo->oo_flags |= NFS4_OO_PURGE_CLOSE;
3776 return;
3777 }
3778 oo->oo_flags &= ~NFS4_OO_PURGE_CLOSE;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003779 release_last_closed_stateid(oo);
3780}
3781
3782static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3783{
3784 unhash_open_stateid(s);
3785 s->st_stid.sc_type = NFS4_CLOSED_STID;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003786}
3787
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788/*
3789 * nfs4_unlock_state() called after encode
3790 */
Al Virob37ad282006-10-19 23:28:59 -07003791__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003792nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003793 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003794{
Al Virob37ad282006-10-19 23:28:59 -07003795 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003796 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003797 struct nfs4_ol_stateid *stp;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003798 struct net *net = SVC_NET(rqstp);
3799 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003800
3801 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003802 (int)cstate->current_fh.fh_dentry->d_name.len,
3803 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804
3805 nfs4_lock_state();
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003806 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3807 &close->cl_stateid,
3808 NFS4_OPEN_STID|NFS4_CLOSED_STID,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003809 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003810 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003812 oo = openowner(stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003813 status = nfs_ok;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003814 update_stateid(&stp->st_stid.sc_stateid);
3815 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003817 nfsd4_close_open_stateid(stp);
J. Bruce Fieldscf9182e2012-08-29 15:21:58 -07003818 release_last_closed_stateid(oo);
ycnian@gmail.com491402a2013-03-11 08:46:14 +08003819 oo->oo_flags &= ~NFS4_OO_PURGE_CLOSE;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003820 oo->oo_last_closed_stid = stp;
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003821
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003822 if (list_empty(&oo->oo_owner.so_stateids)) {
3823 if (cstate->minorversion) {
3824 release_openowner(oo);
3825 cstate->replay_owner = NULL;
3826 } else {
3827 /*
3828 * In the 4.0 case we need to keep the owners around a
3829 * little while to handle CLOSE replay.
3830 */
3831 if (list_empty(&oo->oo_owner.so_stateids))
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03003832 move_to_close_lru(oo, SVC_NET(rqstp));
J. Bruce Fields74dbafa2012-06-06 12:53:48 -04003833 }
3834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003835out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003836 if (!cstate->replay_owner)
3837 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 return status;
3839}
3840
Al Virob37ad282006-10-19 23:28:59 -07003841__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003842nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3843 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003845 struct nfs4_delegation *dp;
3846 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003847 struct nfs4_stid *s;
Al Virob37ad282006-10-19 23:28:59 -07003848 __be32 status;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003849 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003851 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003852 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853
3854 nfs4_lock_state();
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03003855 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
3856 cstate->minorversion, nn);
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003857 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003858 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003859 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003860 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003861 if (status)
3862 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003863
3864 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003865out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003866 nfs4_unlock_state();
3867
Linus Torvalds1da177e2005-04-16 15:20:36 -07003868 return status;
3869}
3870
3871
Linus Torvalds1da177e2005-04-16 15:20:36 -07003872#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873
J. Bruce Fields009673b2011-11-07 17:40:10 -05003874#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003875
Benny Halevy87df4de2008-12-15 19:42:03 +02003876static inline u64
3877end_offset(u64 start, u64 len)
3878{
3879 u64 end;
3880
3881 end = start + len;
3882 return end >= start ? end: NFS4_MAX_UINT64;
3883}
3884
3885/* last octet in a range */
3886static inline u64
3887last_byte_offset(u64 start, u64 len)
3888{
3889 u64 end;
3890
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05003891 WARN_ON_ONCE(!len);
Benny Halevy87df4de2008-12-15 19:42:03 +02003892 end = start + len;
3893 return end > start ? end - 1: NFS4_MAX_UINT64;
3894}
3895
J. Bruce Fields009673b2011-11-07 17:40:10 -05003896static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003897{
3898 return (file_hashval(inode) + cl_id
3899 + opaque_hashval(ownername->data, ownername->len))
J. Bruce Fields009673b2011-11-07 17:40:10 -05003900 & LOCKOWNER_INO_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003901}
3902
Linus Torvalds1da177e2005-04-16 15:20:36 -07003903/*
3904 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3905 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3906 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3907 * locking, this prevents us from being completely protocol-compliant. The
3908 * real solution to this problem is to start using unsigned file offsets in
3909 * the VFS, but this is a very deep change!
3910 */
3911static inline void
3912nfs4_transform_lock_offset(struct file_lock *lock)
3913{
3914 if (lock->fl_start < 0)
3915 lock->fl_start = OFFSET_MAX;
3916 if (lock->fl_end < 0)
3917 lock->fl_end = OFFSET_MAX;
3918}
3919
NeilBrownd5b90262006-04-10 22:55:22 -07003920/* Hack!: For now, we're defining this just so we can use a pointer to it
3921 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003922static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003923};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924
3925static inline void
3926nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3927{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003928 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003929
NeilBrownd5b90262006-04-10 22:55:22 -07003930 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003931 lo = (struct nfs4_lockowner *) fl->fl_owner;
3932 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
3933 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04003934 if (!deny->ld_owner.data)
3935 /* We just don't care that much */
3936 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003937 deny->ld_owner.len = lo->lo_owner.so_owner.len;
3938 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003939 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04003940nevermind:
3941 deny->ld_owner.len = 0;
3942 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07003943 deny->ld_clientid.cl_boot = 0;
3944 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 }
3946 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003947 deny->ld_length = NFS4_MAX_UINT64;
3948 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3950 deny->ld_type = NFS4_READ_LT;
3951 if (fl->fl_type != F_RDLCK)
3952 deny->ld_type = NFS4_WRITE_LT;
3953}
3954
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003955static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
3956{
3957 struct nfs4_ol_stateid *lst;
3958
3959 if (!same_owner_str(&lo->lo_owner, owner, clid))
3960 return false;
3961 lst = list_first_entry(&lo->lo_owner.so_stateids,
3962 struct nfs4_ol_stateid, st_perstateowner);
3963 return lst->st_file->fi_inode == inode;
3964}
3965
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003966static struct nfs4_lockowner *
3967find_lockowner_str(struct inode *inode, clientid_t *clid,
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03003968 struct xdr_netobj *owner, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969{
J. Bruce Fields009673b2011-11-07 17:40:10 -05003970 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003971 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03003973 list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003974 if (same_lockowner_ino(lo, inode, clid, owner))
3975 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003976 }
3977 return NULL;
3978}
3979
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003980static 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 -04003981{
J. Bruce Fields009673b2011-11-07 17:40:10 -05003982 struct inode *inode = open_stp->st_file->fi_inode;
3983 unsigned int inohash = lockowner_ino_hashval(inode,
3984 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03003985 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
J. Bruce Fields009673b2011-11-07 17:40:10 -05003986
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03003987 list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03003988 list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003989 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003990}
3991
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992/*
3993 * Alloc a lock owner structure.
3994 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003995 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003996 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05003997 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003998 */
3999
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004000static struct nfs4_lockowner *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004001alloc_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 -04004002 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004004 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4005 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004006 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004007 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4008 lo->lo_owner.so_is_open_owner = 0;
Neil Brownb59e3c02005-09-13 01:25:38 -07004009 /* It is the openowner seqid that will be incremented in encode in the
4010 * case of new lockowners; so increment the lock seqid manually: */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004011 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4012 hash_lockowner(lo, strhashval, clp, open_stp);
4013 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004014}
4015
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004016static struct nfs4_ol_stateid *
4017alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004018{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004019 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04004020 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004021
J. Bruce Fields996e0932011-10-17 11:14:48 -04004022 stp = nfs4_alloc_stateid(clp);
NeilBrown5ac049a2005-06-23 22:03:03 -07004023 if (stp == NULL)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -04004024 return NULL;
J. Bruce Fields3abdb602013-02-03 12:23:01 -05004025 stp->st_stid.sc_type = NFS4_LOCK_STID;
NeilBrown8beefa22005-06-23 22:03:08 -07004026 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004027 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4028 stp->st_stateowner = &lo->lo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07004029 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030 stp->st_file = fp;
J. Bruce Fields0997b172011-03-02 18:01:35 -05004031 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07004033 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034 return stp;
4035}
4036
NeilBrownfd39ca92005-06-23 22:04:03 -07004037static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038check_lock_length(u64 offset, u64 length)
4039{
Benny Halevy87df4de2008-12-15 19:42:03 +02004040 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004041 LOFF_OVERFLOW(offset, length)));
4042}
4043
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004044static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05004045{
4046 struct nfs4_file *fp = lock_stp->st_file;
4047 int oflag = nfs4_access_to_omode(access);
4048
Jeff Layton82c5ff12012-05-11 09:45:13 -04004049 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05004050 return;
4051 nfs4_file_get_access(fp, oflag);
Jeff Layton82c5ff12012-05-11 09:45:13 -04004052 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05004053}
4054
J. Bruce Fields2355c592012-04-25 16:56:22 -04004055static __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 -04004056{
4057 struct nfs4_file *fi = ost->st_file;
4058 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4059 struct nfs4_client *cl = oo->oo_owner.so_client;
4060 struct nfs4_lockowner *lo;
4061 unsigned int strhashval;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004062 struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004063
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004064 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
4065 &lock->v.new.owner, nn);
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004066 if (lo) {
4067 if (!cstate->minorversion)
4068 return nfserr_bad_seqid;
4069 /* XXX: a lockowner always has exactly one stateid: */
4070 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4071 struct nfs4_ol_stateid, st_perstateowner);
4072 return nfs_ok;
4073 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004074 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004075 &lock->v.new.owner);
4076 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4077 if (lo == NULL)
4078 return nfserr_jukebox;
4079 *lst = alloc_init_lock_stateid(lo, fi, ost);
4080 if (*lst == NULL) {
4081 release_lockowner(lo);
4082 return nfserr_jukebox;
4083 }
4084 *new = true;
4085 return nfs_ok;
4086}
4087
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088/*
4089 * LOCK operation
4090 */
Al Virob37ad282006-10-19 23:28:59 -07004091__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004092nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004093 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004095 struct nfs4_openowner *open_sop = NULL;
4096 struct nfs4_lockowner *lock_sop = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004097 struct nfs4_ol_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004098 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004099 struct file_lock *file_lock = NULL;
4100 struct file_lock *conflock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004101 __be32 status = 0;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004102 bool new_state = false;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004103 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07004104 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004105 struct net *net = SVC_NET(rqstp);
4106 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004107
4108 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4109 (long long) lock->lk_offset,
4110 (long long) lock->lk_length);
4111
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112 if (check_lock_length(lock->lk_offset, lock->lk_length))
4113 return nfserr_inval;
4114
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004115 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004116 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004117 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4118 return status;
4119 }
4120
Linus Torvalds1da177e2005-04-16 15:20:36 -07004121 nfs4_lock_state();
4122
4123 if (lock->lk_is_new) {
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004124 struct nfs4_ol_stateid *open_stp = NULL;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004125
4126 if (nfsd4_has_session(cstate))
4127 /* See rfc 5661 18.10.3: given clientid is ignored: */
4128 memcpy(&lock->v.new.clientid,
4129 &cstate->session->se_client->cl_clientid,
4130 sizeof(clientid_t));
4131
Linus Torvalds1da177e2005-04-16 15:20:36 -07004132 status = nfserr_stale_clientid;
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004133 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004135
Linus Torvalds1da177e2005-04-16 15:20:36 -07004136 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004137 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138 lock->lk_new_open_seqid,
4139 &lock->lk_new_open_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004140 &open_stp, nn);
NeilBrown37515172005-07-07 17:59:16 -07004141 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004142 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004143 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004144 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004145 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004146 &lock->v.new.clientid))
4147 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004148 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4149 &lock_stp, &new_state);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004150 } else
Benny Halevydd453df2009-04-03 08:28:41 +03004151 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004152 lock->lk_old_lock_seqid,
4153 &lock->lk_old_lock_stateid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004154 NFS4_LOCK_STID, &lock_stp, nn);
J. Bruce Fieldse1aaa892012-06-06 16:01:37 -04004155 if (status)
4156 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004157 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004158
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004159 lkflg = setlkflg(lock->lk_type);
4160 status = nfs4_check_openmode(lock_stp, lkflg);
4161 if (status)
4162 goto out;
4163
NeilBrown0dd395dc2005-07-07 17:59:15 -07004164 status = nfserr_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004165 if (locks_in_grace(net) && !lock->lk_reclaim)
NeilBrown0dd395dc2005-07-07 17:59:15 -07004166 goto out;
4167 status = nfserr_no_grace;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004168 if (!locks_in_grace(net) && lock->lk_reclaim)
NeilBrown0dd395dc2005-07-07 17:59:15 -07004169 goto out;
4170
Jeff Layton21179d82012-08-21 08:03:32 -04004171 file_lock = locks_alloc_lock();
4172 if (!file_lock) {
4173 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4174 status = nfserr_jukebox;
4175 goto out;
4176 }
4177
4178 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004179 switch (lock->lk_type) {
4180 case NFS4_READ_LT:
4181 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004182 filp = find_readable_file(lock_stp->st_file);
4183 if (filp)
4184 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Jeff Layton21179d82012-08-21 08:03:32 -04004185 file_lock->fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004186 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004187 case NFS4_WRITE_LT:
4188 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004189 filp = find_writeable_file(lock_stp->st_file);
4190 if (filp)
4191 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Jeff Layton21179d82012-08-21 08:03:32 -04004192 file_lock->fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004193 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004194 default:
4195 status = nfserr_inval;
4196 goto out;
4197 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004198 if (!filp) {
4199 status = nfserr_openmode;
4200 goto out;
4201 }
Jeff Layton21179d82012-08-21 08:03:32 -04004202 file_lock->fl_owner = (fl_owner_t)lock_sop;
4203 file_lock->fl_pid = current->tgid;
4204 file_lock->fl_file = filp;
4205 file_lock->fl_flags = FL_POSIX;
4206 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4207 file_lock->fl_start = lock->lk_offset;
4208 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4209 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004210
Jeff Layton21179d82012-08-21 08:03:32 -04004211 conflock = locks_alloc_lock();
4212 if (!conflock) {
4213 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4214 status = nfserr_jukebox;
4215 goto out;
4216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004217
Jeff Layton21179d82012-08-21 08:03:32 -04004218 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004219 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220 case 0: /* success! */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004221 update_stateid(&lock_stp->st_stid.sc_stateid);
4222 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004224 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004225 break;
4226 case (EAGAIN): /* conflock holds conflicting lock */
4227 status = nfserr_denied;
4228 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
Jeff Layton21179d82012-08-21 08:03:32 -04004229 nfs4_set_lock_denied(conflock, &lock->lk_denied);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004230 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004231 case (EDEADLK):
4232 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004233 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04004234 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004235 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04004236 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004237 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004239out:
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004240 if (status && new_state)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004241 release_lockowner(lock_sop);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004242 if (!cstate->replay_owner)
4243 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004244 if (file_lock)
4245 locks_free_lock(file_lock);
4246 if (conflock)
4247 locks_free_lock(conflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004248 return status;
4249}
4250
4251/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004252 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4253 * so we do a temporary open here just to get an open file to pass to
4254 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4255 * inode operation.)
4256 */
Al Viro04da6e92012-04-13 00:00:04 -04004257static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004258{
4259 struct file *file;
Al Viro04da6e92012-04-13 00:00:04 -04004260 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4261 if (!err) {
4262 err = nfserrno(vfs_test_lock(file, lock));
4263 nfsd_close(file);
4264 }
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004265 return err;
4266}
4267
4268/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004269 * LOCKT operation
4270 */
Al Virob37ad282006-10-19 23:28:59 -07004271__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004272nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4273 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004274{
4275 struct inode *inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004276 struct file_lock *file_lock = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004277 struct nfs4_lockowner *lo;
Al Virob37ad282006-10-19 23:28:59 -07004278 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004279 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004281 if (locks_in_grace(SVC_NET(rqstp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004282 return nfserr_grace;
4283
4284 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4285 return nfserr_inval;
4286
Linus Torvalds1da177e2005-04-16 15:20:36 -07004287 nfs4_lock_state();
4288
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004289 if (!nfsd4_has_session(cstate)) {
4290 status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
4291 if (status)
4292 goto out;
4293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004294
J. Bruce Fields75c096f2011-08-15 18:39:32 -04004295 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004297
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004298 inode = cstate->current_fh.fh_dentry->d_inode;
Jeff Layton21179d82012-08-21 08:03:32 -04004299 file_lock = locks_alloc_lock();
4300 if (!file_lock) {
4301 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4302 status = nfserr_jukebox;
4303 goto out;
4304 }
4305 locks_init_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306 switch (lockt->lt_type) {
4307 case NFS4_READ_LT:
4308 case NFS4_READW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004309 file_lock->fl_type = F_RDLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004310 break;
4311 case NFS4_WRITE_LT:
4312 case NFS4_WRITEW_LT:
Jeff Layton21179d82012-08-21 08:03:32 -04004313 file_lock->fl_type = F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004314 break;
4315 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004316 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317 status = nfserr_inval;
4318 goto out;
4319 }
4320
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004321 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004322 if (lo)
Jeff Layton21179d82012-08-21 08:03:32 -04004323 file_lock->fl_owner = (fl_owner_t)lo;
4324 file_lock->fl_pid = current->tgid;
4325 file_lock->fl_flags = FL_POSIX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004326
Jeff Layton21179d82012-08-21 08:03:32 -04004327 file_lock->fl_start = lockt->lt_offset;
4328 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004329
Jeff Layton21179d82012-08-21 08:03:32 -04004330 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331
Jeff Layton21179d82012-08-21 08:03:32 -04004332 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
Al Viro04da6e92012-04-13 00:00:04 -04004333 if (status)
Marc Eshelfd85b812006-11-28 16:26:41 -05004334 goto out;
Al Viro04da6e92012-04-13 00:00:04 -04004335
Jeff Layton21179d82012-08-21 08:03:32 -04004336 if (file_lock->fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004337 status = nfserr_denied;
Jeff Layton21179d82012-08-21 08:03:32 -04004338 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339 }
4340out:
4341 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004342 if (file_lock)
4343 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004344 return status;
4345}
4346
Al Virob37ad282006-10-19 23:28:59 -07004347__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004348nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004349 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004351 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004352 struct file *filp = NULL;
Jeff Layton21179d82012-08-21 08:03:32 -04004353 struct file_lock *file_lock = NULL;
Al Virob37ad282006-10-19 23:28:59 -07004354 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004355 int err;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004356 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4357
Linus Torvalds1da177e2005-04-16 15:20:36 -07004358 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4359 (long long) locku->lu_offset,
4360 (long long) locku->lu_length);
4361
4362 if (check_lock_length(locku->lu_offset, locku->lu_length))
4363 return nfserr_inval;
4364
4365 nfs4_lock_state();
4366
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004367 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004368 &locku->lu_stateid, NFS4_LOCK_STID,
4369 &stp, nn);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004370 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004371 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004372 filp = find_any_file(stp->st_file);
4373 if (!filp) {
4374 status = nfserr_lock_range;
4375 goto out;
4376 }
Jeff Layton21179d82012-08-21 08:03:32 -04004377 file_lock = locks_alloc_lock();
4378 if (!file_lock) {
4379 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4380 status = nfserr_jukebox;
4381 goto out;
4382 }
4383 locks_init_lock(file_lock);
4384 file_lock->fl_type = F_UNLCK;
4385 file_lock->fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
4386 file_lock->fl_pid = current->tgid;
4387 file_lock->fl_file = filp;
4388 file_lock->fl_flags = FL_POSIX;
4389 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4390 file_lock->fl_start = locku->lu_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391
Jeff Layton21179d82012-08-21 08:03:32 -04004392 file_lock->fl_end = last_byte_offset(locku->lu_offset,
4393 locku->lu_length);
4394 nfs4_transform_lock_offset(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004395
4396 /*
4397 * Try to unlock the file in the VFS.
4398 */
Jeff Layton21179d82012-08-21 08:03:32 -04004399 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004400 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004401 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402 goto out_nfserr;
4403 }
4404 /*
4405 * OK, unlock succeeded; the only thing left to do is update the stateid.
4406 */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004407 update_stateid(&stp->st_stid.sc_stateid);
4408 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004409
4410out:
J. Bruce Fields71c3bcd2011-09-27 21:42:29 -04004411 if (!cstate->replay_owner)
4412 nfs4_unlock_state();
Jeff Layton21179d82012-08-21 08:03:32 -04004413 if (file_lock)
4414 locks_free_lock(file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004415 return status;
4416
4417out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004418 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419 goto out;
4420}
4421
4422/*
4423 * returns
4424 * 1: locks held by lockowner
4425 * 0: no locks held by lockowner
4426 */
4427static int
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004428check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004429{
4430 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004431 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004432 int status = 0;
4433
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004434 lock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004435 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004436 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437 status = 1;
4438 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004440 }
4441out:
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004442 unlock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 return status;
4444}
4445
Al Virob37ad282006-10-19 23:28:59 -07004446__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004447nfsd4_release_lockowner(struct svc_rqst *rqstp,
4448 struct nfsd4_compound_state *cstate,
4449 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004450{
4451 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004452 struct nfs4_stateowner *sop;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004453 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004454 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004455 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004456 struct list_head matches;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004457 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
Al Virob37ad282006-10-19 23:28:59 -07004458 __be32 status;
Stanislav Kinsbursky7f2210f2012-11-14 18:21:05 +03004459 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004460
4461 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4462 clid->cl_boot, clid->cl_id);
4463
Linus Torvalds1da177e2005-04-16 15:20:36 -07004464 nfs4_lock_state();
4465
J. Bruce Fields9b2ef622012-12-03 17:24:41 -05004466 status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
4467 if (status)
4468 goto out;
4469
NeilBrown3e9e3db2005-06-23 22:04:20 -07004470 status = nfserr_locks_held;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004471 INIT_LIST_HEAD(&matches);
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004472
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004473 list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004474 if (sop->so_is_open_owner)
4475 continue;
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004476 if (!same_owner_str(sop, owner, clid))
4477 continue;
4478 list_for_each_entry(stp, &sop->so_stateids,
4479 st_perstateowner) {
4480 lo = lockowner(sop);
4481 if (check_for_locks(stp->st_file, lo))
4482 goto out;
4483 list_add(&lo->lo_list, &matches);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004485 }
4486 /* Clients probably won't expect us to return with some (but not all)
4487 * of the lockowner state released; so don't release any until all
4488 * have been checked. */
4489 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004490 while (!list_empty(&matches)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004491 lo = list_entry(matches.next, struct nfs4_lockowner,
4492 lo_list);
NeilBrown0fa822e2005-07-07 17:59:14 -07004493 /* unhash_stateowner deletes so_perclient only
4494 * for openowners. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004495 list_del(&lo->lo_list);
4496 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004497 }
4498out:
4499 nfs4_unlock_state();
4500 return status;
4501}
4502
4503static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004504alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004505{
NeilBrowna55370a2005-06-23 22:03:52 -07004506 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004507}
4508
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004509bool
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004510nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
NeilBrownc7b9a452005-06-23 22:04:30 -07004511{
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004512 struct nfs4_client_reclaim *crp;
NeilBrownc7b9a452005-06-23 22:04:30 -07004513
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004514 crp = nfsd4_find_reclaim_client(name, nn);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004515 return (crp && crp->cr_clp);
NeilBrownc7b9a452005-06-23 22:04:30 -07004516}
4517
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518/*
4519 * failure => all reset bets are off, nfserr_no_grace...
4520 */
Jeff Layton772a9bb2012-11-12 15:00:54 -05004521struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004522nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004523{
4524 unsigned int strhashval;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004525 struct nfs4_client_reclaim *crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004526
NeilBrowna55370a2005-06-23 22:03:52 -07004527 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4528 crp = alloc_reclaim();
Jeff Layton772a9bb2012-11-12 15:00:54 -05004529 if (crp) {
4530 strhashval = clientstr_hashval(name);
4531 INIT_LIST_HEAD(&crp->cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004532 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
Jeff Layton772a9bb2012-11-12 15:00:54 -05004533 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Jeff Layton0ce0c2b2012-11-12 15:00:55 -05004534 crp->cr_clp = NULL;
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004535 nn->reclaim_str_hashtbl_size++;
Jeff Layton772a9bb2012-11-12 15:00:54 -05004536 }
4537 return crp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004538}
4539
Jeff Layton2a4317c2012-03-21 16:42:43 -04004540void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004541nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
Jeff Laytonce30e532012-11-12 15:00:53 -05004542{
4543 list_del(&crp->cr_strhash);
4544 kfree(crp);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004545 nn->reclaim_str_hashtbl_size--;
Jeff Laytonce30e532012-11-12 15:00:53 -05004546}
4547
4548void
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004549nfs4_release_reclaim(struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004550{
4551 struct nfs4_client_reclaim *crp = NULL;
4552 int i;
4553
Linus Torvalds1da177e2005-04-16 15:20:36 -07004554 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004555 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
4556 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004557 struct nfs4_client_reclaim, cr_strhash);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004558 nfs4_remove_reclaim_record(crp, nn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004559 }
4560 }
J. Bruce Fields063b0fb2012-11-25 14:48:10 -05004561 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004562}
4563
4564/*
4565 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04004566struct nfs4_client_reclaim *
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004567nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004568{
4569 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004570 struct nfs4_client_reclaim *crp = NULL;
4571
Jeff Layton278c9312012-11-12 15:00:52 -05004572 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004573
Jeff Layton278c9312012-11-12 15:00:52 -05004574 strhashval = clientstr_hashval(recdir);
Stanislav Kinsbursky52e19c02012-11-14 18:21:16 +03004575 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
Jeff Layton278c9312012-11-12 15:00:52 -05004576 if (same_name(crp->cr_recdir, recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577 return crp;
4578 }
4579 }
4580 return NULL;
4581}
4582
4583/*
4584* Called from OPEN. Look for clientid in reclaim list.
4585*/
Al Virob37ad282006-10-19 23:28:59 -07004586__be32
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004587nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004588{
Jeff Laytona52d7262012-03-21 09:52:02 -04004589 struct nfs4_client *clp;
4590
4591 /* find clientid in conf_id_hashtbl */
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004592 clp = find_confirmed_client(clid, sessions, nn);
Jeff Laytona52d7262012-03-21 09:52:02 -04004593 if (clp == NULL)
4594 return nfserr_reclaim_bad;
4595
4596 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004597}
4598
Bryan Schumaker65178db2011-11-01 13:35:21 -04004599#ifdef CONFIG_NFSD_FAULT_INJECTION
4600
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004601u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
4602{
4603 expire_client(clp);
4604 return 1;
4605}
4606
Bryan Schumaker184c1842012-11-29 11:40:44 -05004607u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
4608{
4609 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004610 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004611 printk(KERN_INFO "NFS Client: %s\n", buf);
4612 return 1;
4613}
4614
4615static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
4616 const char *type)
4617{
4618 char buf[INET6_ADDRSTRLEN];
Bryan Schumaker0a5c33e2012-12-07 16:17:28 -05004619 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
Bryan Schumaker184c1842012-11-29 11:40:44 -05004620 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
4621}
4622
Bryan Schumakerfc291712012-11-29 11:40:40 -05004623static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
4624{
4625 struct nfs4_openowner *oop;
4626 struct nfs4_lockowner *lop, *lo_next;
4627 struct nfs4_ol_stateid *stp, *st_next;
4628 u64 count = 0;
4629
4630 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
4631 list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
4632 list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
4633 if (func)
4634 func(lop);
4635 if (++count == max)
4636 return count;
4637 }
4638 }
4639 }
4640
4641 return count;
4642}
4643
4644u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
4645{
4646 return nfsd_foreach_client_lock(clp, max, release_lockowner);
4647}
4648
Bryan Schumaker184c1842012-11-29 11:40:44 -05004649u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
4650{
4651 u64 count = nfsd_foreach_client_lock(clp, max, NULL);
4652 nfsd_print_count(clp, count, "locked files");
4653 return count;
4654}
4655
Bryan Schumaker4dbdbda2012-11-29 11:40:41 -05004656static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
4657{
4658 struct nfs4_openowner *oop, *next;
4659 u64 count = 0;
4660
4661 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
4662 if (func)
4663 func(oop);
4664 if (++count == max)
4665 break;
4666 }
4667
4668 return count;
4669}
4670
4671u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
4672{
4673 return nfsd_foreach_client_open(clp, max, release_openowner);
4674}
4675
Bryan Schumaker184c1842012-11-29 11:40:44 -05004676u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
4677{
4678 u64 count = nfsd_foreach_client_open(clp, max, NULL);
4679 nfsd_print_count(clp, count, "open files");
4680 return count;
4681}
4682
Bryan Schumaker269de302012-11-29 11:40:42 -05004683static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
4684 struct list_head *victims)
4685{
4686 struct nfs4_delegation *dp, *next;
4687 u64 count = 0;
4688
4689 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
4690 if (victims)
4691 list_move(&dp->dl_recall_lru, victims);
4692 if (++count == max)
4693 break;
4694 }
4695 return count;
4696}
4697
4698u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
4699{
4700 struct nfs4_delegation *dp, *next;
4701 LIST_HEAD(victims);
4702 u64 count;
4703
4704 spin_lock(&recall_lock);
4705 count = nfsd_find_all_delegations(clp, max, &victims);
4706 spin_unlock(&recall_lock);
4707
4708 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4709 unhash_delegation(dp);
4710
4711 return count;
4712}
4713
4714u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
4715{
4716 struct nfs4_delegation *dp, *next;
4717 LIST_HEAD(victims);
4718 u64 count;
4719
4720 spin_lock(&recall_lock);
4721 count = nfsd_find_all_delegations(clp, max, &victims);
4722 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4723 nfsd_break_one_deleg(dp);
4724 spin_unlock(&recall_lock);
4725
4726 return count;
4727}
4728
Bryan Schumaker184c1842012-11-29 11:40:44 -05004729u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
4730{
4731 u64 count = 0;
4732
4733 spin_lock(&recall_lock);
4734 count = nfsd_find_all_delegations(clp, max, NULL);
4735 spin_unlock(&recall_lock);
4736
4737 nfsd_print_count(clp, count, "delegations");
4738 return count;
4739}
4740
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004741u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004742{
4743 struct nfs4_client *clp, *next;
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004744 u64 count = 0;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004745 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004746
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004747 if (!nfsd_netns_ready(nn))
4748 return 0;
4749
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004750 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004751 count += func(clp, max - count);
4752 if ((max != 0) && (count >= max))
Bryan Schumaker65178db2011-11-01 13:35:21 -04004753 break;
4754 }
Bryan Schumaker65178db2011-11-01 13:35:21 -04004755
Bryan Schumaker44e34da602012-11-29 11:40:39 -05004756 return count;
4757}
4758
Bryan Schumaker6c1e82a2012-11-29 11:40:46 -05004759struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
4760{
4761 struct nfs4_client *clp;
4762 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
4763
4764 if (!nfsd_netns_ready(nn))
4765 return NULL;
4766
4767 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
4768 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
4769 return clp;
4770 }
4771 return NULL;
4772}
4773
Bryan Schumaker65178db2011-11-01 13:35:21 -04004774#endif /* CONFIG_NFSD_FAULT_INJECTION */
4775
NeilBrownac4d8ff22005-06-23 22:03:30 -07004776/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004777
Bryan Schumaker72083392011-11-01 15:24:59 -04004778void
NeilBrownac4d8ff22005-06-23 22:03:30 -07004779nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004780{
Bryan Schumaker72083392011-11-01 15:24:59 -04004781 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782
Linus Torvalds1da177e2005-04-16 15:20:36 -07004783 for (i = 0; i < FILE_HASH_SIZE; i++) {
4784 INIT_LIST_HEAD(&file_hashtbl[i]);
4785 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004786 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff22005-06-23 22:03:30 -07004787}
4788
Meelap Shahc2f1a552007-07-17 04:04:39 -07004789/*
4790 * Since the lifetime of a delegation isn't limited to that of an open, a
4791 * client may quite reasonably hang on to a delegation as long as it has
4792 * the inode cached. This becomes an obvious problem the first time a
4793 * client's inode cache approaches the size of the server's total memory.
4794 *
4795 * For now we avoid this problem by imposing a hard limit on the number
4796 * of delegations, which varies according to the server's memory size.
4797 */
4798static void
4799set_max_delegations(void)
4800{
4801 /*
4802 * Allow at most 4 delegations per megabyte of RAM. Quick
4803 * estimates suggest that in the worst case (where every delegation
4804 * is for a different inode), a delegation could take about 1.5K,
4805 * giving a worst case usage of about 6% of memory.
4806 */
4807 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4808}
4809
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004810static int nfs4_state_create_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004811{
4812 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4813 int i;
4814
4815 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4816 CLIENT_HASH_SIZE, GFP_KERNEL);
4817 if (!nn->conf_id_hashtbl)
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004818 goto err;
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004819 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4820 CLIENT_HASH_SIZE, GFP_KERNEL);
4821 if (!nn->unconf_id_hashtbl)
4822 goto err_unconf_id;
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004823 nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
4824 OWNER_HASH_SIZE, GFP_KERNEL);
4825 if (!nn->ownerstr_hashtbl)
4826 goto err_ownerstr;
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004827 nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
4828 LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
4829 if (!nn->lockowner_ino_hashtbl)
4830 goto err_lockowner_ino;
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004831 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
4832 SESSION_HASH_SIZE, GFP_KERNEL);
4833 if (!nn->sessionid_hashtbl)
4834 goto err_sessionid;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004835
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004836 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004837 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004838 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004839 }
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004840 for (i = 0; i < OWNER_HASH_SIZE; i++)
4841 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004842 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
4843 INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004844 for (i = 0; i < SESSION_HASH_SIZE; i++)
4845 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004846 nn->conf_name_tree = RB_ROOT;
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004847 nn->unconf_name_tree = RB_ROOT;
Stanislav Kinsbursky5ed58bb2012-11-14 18:21:56 +03004848 INIT_LIST_HEAD(&nn->client_lru);
Stanislav Kinsbursky73758fed2012-11-14 18:22:01 +03004849 INIT_LIST_HEAD(&nn->close_lru);
Stanislav Kinsburskyc9a49622012-11-26 15:21:58 +03004850 spin_lock_init(&nn->client_lock);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004851
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004852 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004853 get_net(net);
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004854
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004855 return 0;
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004856
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004857err_sessionid:
4858 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004859err_lockowner_ino:
4860 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004861err_ownerstr:
4862 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004863err_unconf_id:
4864 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky382a62e2012-11-14 18:21:26 +03004865err:
4866 return -ENOMEM;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004867}
4868
4869static void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004870nfs4_state_destroy_net(struct net *net)
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004871{
4872 int i;
4873 struct nfs4_client *clp = NULL;
4874 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004875 struct rb_node *node, *tmp;
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004876
4877 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4878 while (!list_empty(&nn->conf_id_hashtbl[i])) {
4879 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4880 destroy_client(clp);
4881 }
4882 }
Stanislav Kinsburskya99454a2012-11-14 18:21:36 +03004883
4884 node = rb_first(&nn->unconf_name_tree);
4885 while (node != NULL) {
4886 tmp = node;
4887 node = rb_next(tmp);
4888 clp = rb_entry(tmp, struct nfs4_client, cl_namenode);
4889 rb_erase(tmp, &nn->unconf_name_tree);
4890 destroy_client(clp);
4891 }
4892
Stanislav Kinsbursky1872de02012-11-14 18:21:51 +03004893 kfree(nn->sessionid_hashtbl);
Stanislav Kinsbursky20e9e2b2012-11-14 18:21:46 +03004894 kfree(nn->lockowner_ino_hashtbl);
Stanislav Kinsbursky9b531132012-11-14 18:21:41 +03004895 kfree(nn->ownerstr_hashtbl);
Stanislav Kinsbursky0a7ec372012-11-14 18:21:31 +03004896 kfree(nn->unconf_id_hashtbl);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004897 kfree(nn->conf_id_hashtbl);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004898 put_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004899}
4900
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03004901int
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004902nfs4_state_start_net(struct net *net)
NeilBrownac4d8ff22005-06-23 22:03:30 -07004903{
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04004904 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004905 int ret;
4906
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004907 ret = nfs4_state_create_net(net);
Stanislav Kinsbursky8daae4d2012-11-14 18:21:21 +03004908 if (ret)
4909 return ret;
Stanislav Kinsbursky5e1533c2012-07-25 16:56:58 +04004910 nfsd4_client_tracking_init(net);
Stanislav Kinsbursky2c142ba2012-07-25 16:57:45 +04004911 nn->boot_time = get_seconds();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +04004912 locks_start_grace(net, &nn->nfsd4_manager);
Stanislav Kinsburskya51c84e2012-07-25 16:57:37 +04004913 nn->grace_ended = false;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004914 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
Stanislav Kinsbursky5284b442012-11-27 14:11:49 +03004915 nn->nfsd4_grace, net);
4916 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004917 return 0;
4918}
4919
4920/* initialization to perform when the nfsd service is started: */
4921
4922int
4923nfs4_state_start(void)
4924{
4925 int ret;
4926
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004927 ret = set_callback_cred();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004928 if (ret)
4929 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07004930 laundry_wq = create_singlethread_workqueue("nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05004931 if (laundry_wq == NULL) {
4932 ret = -ENOMEM;
4933 goto out_recovery;
4934 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004935 ret = nfsd4_create_callback_queue();
4936 if (ret)
4937 goto out_free_laundry;
Stanislav Kinsbursky09121282012-11-14 18:22:17 +03004938
Meelap Shahc2f1a552007-07-17 04:04:39 -07004939 set_max_delegations();
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004940
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004941 return 0;
Stanislav Kinsburskyd85ed442012-11-26 15:22:13 +03004942
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004943out_free_laundry:
4944 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05004945out_recovery:
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004946 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004947}
4948
Jeff Laytonac55fdc2012-11-12 15:00:56 -05004949/* should be called with the state lock held */
Stanislav Kinsburskyf252bc62012-11-26 15:22:18 +03004950void
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004951nfs4_state_shutdown_net(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004952{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004953 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004954 struct list_head *pos, *next, reaplist;
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004955 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004956
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004957 cancel_delayed_work_sync(&nn->laundromat_work);
4958 locks_end_grace(&nn->nfsd4_manager);
Jeff Laytonac55fdc2012-11-12 15:00:56 -05004959
Linus Torvalds1da177e2005-04-16 15:20:36 -07004960 INIT_LIST_HEAD(&reaplist);
4961 spin_lock(&recall_lock);
4962 list_for_each_safe(pos, next, &del_recall_lru) {
4963 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Stanislav Kinsbursky4e37a7c22012-11-26 15:22:03 +03004964 if (dp->dl_stid.sc_client->net != net)
4965 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004966 list_move(&dp->dl_recall_lru, &reaplist);
4967 }
4968 spin_unlock(&recall_lock);
4969 list_for_each_safe(pos, next, &reaplist) {
4970 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004971 unhash_delegation(dp);
4972 }
4973
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +03004974 nfsd4_client_tracking_exit(net);
Stanislav Kinsbursky4dce0ac2012-11-26 15:22:08 +03004975 nfs4_state_destroy_net(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004976}
4977
4978void
4979nfs4_state_shutdown(void)
4980{
NeilBrown5e8d5c22006-04-10 22:55:37 -07004981 destroy_workqueue(laundry_wq);
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04004982 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004983}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004984
4985static void
4986get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
4987{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01004988 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
4989 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004990}
4991
4992static void
4993put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
4994{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01004995 if (cstate->minorversion) {
4996 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
4997 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
4998 }
4999}
5000
5001void
5002clear_current_stateid(struct nfsd4_compound_state *cstate)
5003{
5004 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005005}
5006
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005007/*
5008 * functions to set current state id
5009 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005010void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005011nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5012{
5013 put_stateid(cstate, &odp->od_stateid);
5014}
5015
5016void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005017nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5018{
5019 put_stateid(cstate, &open->op_stateid);
5020}
5021
5022void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005023nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5024{
5025 put_stateid(cstate, &close->cl_stateid);
5026}
5027
5028void
5029nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5030{
5031 put_stateid(cstate, &lock->lk_resp_stateid);
5032}
5033
5034/*
5035 * functions to consume current state id
5036 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005037
5038void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01005039nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5040{
5041 get_stateid(cstate, &odp->od_stateid);
5042}
5043
5044void
5045nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5046{
5047 get_stateid(cstate, &drp->dr_stateid);
5048}
5049
5050void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01005051nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5052{
5053 get_stateid(cstate, &fsp->fr_stateid);
5054}
5055
5056void
5057nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5058{
5059 get_stateid(cstate, &setattr->sa_stateid);
5060}
5061
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005062void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005063nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5064{
5065 get_stateid(cstate, &close->cl_stateid);
5066}
5067
5068void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005069nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005070{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01005071 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01005072}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01005073
5074void
5075nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5076{
5077 get_stateid(cstate, &read->rd_stateid);
5078}
5079
5080void
5081nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5082{
5083 get_stateid(cstate, &write->wr_stateid);
5084}